mutter/cogl/cogl-vector.c
Robert Bragg ee940a3d0d Move all types/prototypes from cogl.h -> cogl[1]-context.h
So we can get to the point where cogl.h is merely an aggregation of
header includes for the 1.x api this moves all the function prototypes
and type definitions into a cogl-context.h and a new cogl1-context.h.

Ideally no code internally should ever need to include cogl.h as it just
represents the public facing header for accessing the 1.x api which
should only be used by Clutter.

Reviewed-by: Neil Roberts <neil@linux.intel.com>
2012-02-20 23:12:44 +00:00

297 lines
6.1 KiB
C

/*
* Cogl
*
* An object oriented GL/GLES Abstraction/Utility Layer
*
* Copyright (C) 2010 Intel Corporation.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*
* Authors:
* Robert Bragg <robert@linux.intel.com>
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <cogl.h>
#include <cogl-util.h>
#include <cogl-vector.h>
#include <glib.h>
#include <math.h>
#include <string.h>
#define X 0
#define Y 1
#define Z 2
#define W 3
void
cogl_vector3_init (float *vector, float x, float y, float z)
{
vector[X] = x;
vector[Y] = y;
vector[Z] = z;
}
void
cogl_vector3_init_zero (float *vector)
{
memset (vector, 0, sizeof (float) * 3);
}
gboolean
cogl_vector3_equal (gconstpointer v1, gconstpointer v2)
{
float *vector0 = (float *)v1;
float *vector1 = (float *)v2;
_COGL_RETURN_VAL_IF_FAIL (v1 != NULL, FALSE);
_COGL_RETURN_VAL_IF_FAIL (v2 != NULL, FALSE);
/* There's no point picking an arbitrary epsilon that's appropriate
* for comparing the components so we just use == that will at least
* consider -0 and 0 to be equal. */
return
vector0[X] == vector1[X] &&
vector0[Y] == vector1[Y] &&
vector0[Z] == vector1[Z];
}
gboolean
cogl_vector3_equal_with_epsilon (const float *vector0,
const float *vector1,
float epsilon)
{
_COGL_RETURN_VAL_IF_FAIL (vector0 != NULL, FALSE);
_COGL_RETURN_VAL_IF_FAIL (vector1 != NULL, FALSE);
if (fabsf (vector0[X] - vector1[X]) < epsilon &&
fabsf (vector0[Y] - vector1[Y]) < epsilon &&
fabsf (vector0[Z] - vector1[Z]) < epsilon)
return TRUE;
else
return FALSE;
}
float *
cogl_vector3_copy (const float *vector)
{
if (vector)
return g_slice_copy (sizeof (float) * 3, vector);
return NULL;
}
void
cogl_vector3_free (float *vector)
{
g_slice_free1 (sizeof (float) * 3, vector);
}
void
cogl_vector3_invert (float *vector)
{
vector[X] = -vector[X];
vector[Y] = -vector[Y];
vector[Z] = -vector[Z];
}
void
cogl_vector3_add (float *result,
const float *a,
const float *b)
{
result[X] = a[X] + b[X];
result[Y] = a[Y] + b[Y];
result[Z] = a[Z] + b[Z];
}
void
cogl_vector3_subtract (float *result,
const float *a,
const float *b)
{
result[X] = a[X] - b[X];
result[Y] = a[Y] - b[Y];
result[Z] = a[Z] - b[Z];
}
void
cogl_vector3_multiply_scalar (float *vector,
float scalar)
{
vector[X] *= scalar;
vector[Y] *= scalar;
vector[Z] *= scalar;
}
void
cogl_vector3_divide_scalar (float *vector,
float scalar)
{
float one_over_scalar = 1.0f / scalar;
vector[X] *= one_over_scalar;
vector[Y] *= one_over_scalar;
vector[Z] *= one_over_scalar;
}
void
cogl_vector3_normalize (float *vector)
{
float mag_squared =
vector[X] * vector[X] +
vector[Y] * vector[Y] +
vector[Z] * vector[Z];
if (mag_squared > 0.0f)
{
float one_over_mag = 1.0f / sqrtf (mag_squared);
vector[X] *= one_over_mag;
vector[Y] *= one_over_mag;
vector[Z] *= one_over_mag;
}
}
float
cogl_vector3_magnitude (const float *vector)
{
return sqrtf (vector[X] * vector[X] +
vector[Y] * vector[Y] +
vector[Z] * vector[Z]);
}
void
cogl_vector3_cross_product (float *result,
const float *a,
const float *b)
{
float tmp[3];
tmp[X] = a[Y] * b[Z] - a[Z] * b[Y];
tmp[Y] = a[Z] * b[X] - a[X] * b[Z];
tmp[Z] = a[X] * b[Y] - a[Y] * b[X];
result[X] = tmp[X];
result[Y] = tmp[Y];
result[Z] = tmp[Z];
}
float
cogl_vector3_dot_product (const float *a, const float *b)
{
return a[X] * b[X] + a[Y] * b[Y] + a[Z] * b[Z];
}
float
cogl_vector3_distance (const float *a, const float *b)
{
float dx = b[X] - a[X];
float dy = b[Y] - a[Y];
float dz = b[Z] - a[Z];
return sqrtf (dx * dx + dy * dy + dz * dz);
}
#if 0
void
cogl_vector4_init (float *vector, float x, float y, float z)
{
vector[X] = x;
vector[Y] = y;
vector[Z] = z;
vector[W] = w;
}
void
cogl_vector4_init_zero (float *vector)
{
memset (vector, 0, sizeof (CoglVector4));
}
void
cogl_vector4_init_from_vector4 (float *vector, float *src)
{
*vector4 = *src;
}
gboolean
cogl_vector4_equal (gconstpointer *v0, gconstpointer *v1)
{
_COGL_RETURN_VAL_IF_FAIL (v1 != NULL, FALSE);
_COGL_RETURN_VAL_IF_FAIL (v2 != NULL, FALSE);
return memcmp (v1, v2, sizeof (float) * 4) == 0 ? TRUE : FALSE;
}
float *
cogl_vector4_copy (float *vector)
{
if (vector)
return g_slice_dup (CoglVector4, vector);
return NULL;
}
void
cogl_vector4_free (float *vector)
{
g_slice_free (CoglVector4, vector);
}
void
cogl_vector4_invert (float *vector)
{
vector.x = -vector.x;
vector.y = -vector.y;
vector.z = -vector.z;
vector.w = -vector.w;
}
void
cogl_vector4_add (float *result,
float *a,
float *b)
{
result.x = a.x + b.x;
result.y = a.y + b.y;
result.z = a.z + b.z;
result.w = a.w + b.w;
}
void
cogl_vector4_subtract (float *result,
float *a,
float *b)
{
result.x = a.x - b.x;
result.y = a.y - b.y;
result.z = a.z - b.z;
result.w = a.w - b.w;
}
void
cogl_vector4_divide (float *vector,
float scalar)
{
float one_over_scalar = 1.0f / scalar;
result.x *= one_over_scalar;
result.y *= one_over_scalar;
result.z *= one_over_scalar;
result.w *= one_over_scalar;
}
#endif