Replace CoglVector* by graphene_vec*_t

This is an extremely straightforward and minimalistic port of
CoglVector APIs to the corresponding Graphene APIs.

Make ClutterPlane use graphene_vec3_t internally too, for the
simplest purpose of keeping the patch focused.

https://gitlab.gnome.org/GNOME/mutter/merge_requests/458

clutter/clutter/clutter-paint-volume.c

@@ -1097,24 +1097,18 @@ _clutter_paint_volume_cull (ClutterPaintVolume *pv,
 
   for (i = 0; i < 4; i++)
     {
+      const ClutterPlane *plane = &planes[i];
       int out = 0;
       for (j = 0; j < vertex_count; j++)
         {
-          ClutterVertex p;
+          graphene_vec3_t v;
-          float distance;
 
-          /* XXX: for perspective projections this can be optimized
+          graphene_vec3_init (&v,
-           * out because all the planes should pass through the origin
+                              vertices[j].x - graphene_vec3_get_x (&plane->v0),
-           * so (0,0,0) is a valid v0. */
+                              vertices[j].y - graphene_vec3_get_y (&plane->v0),
-          p.x = vertices[j].x - planes[i].v0[0];
+                              vertices[j].z - graphene_vec3_get_z (&plane->v0));
-          p.y = vertices[j].y - planes[i].v0[1];
-          p.z = vertices[j].z - planes[i].v0[2];
 
-          distance = (planes[i].n[0] * p.x +
+          if (graphene_vec3_dot (&plane->n, &v) < 0)
-                      planes[i].n[1] * p.y +
-                      planes[i].n[2] * p.z);
-
-          if (distance < 0)
             out++;
         }
 

clutter/clutter/clutter-private.h

@@ -292,8 +292,8 @@ PangoDirection _clutter_pango_find_base_dir     (const gchar *text,
 
 typedef struct _ClutterPlane
 {
-  float v0[3];
+  graphene_vec3_t v0;
-  float n[3];
+  graphene_vec3_t n;
 } ClutterPlane;
 
 typedef enum _ClutterCullResult

clutter/clutter/clutter-stage.c

@@ -715,8 +715,9 @@ _cogl_util_get_eye_planes_for_screen_poly (float *polygon,
   Vector4 *tmp_poly;
   ClutterPlane *plane;
   int i;
-  float b[3];
+  Vector4 *poly;
-  float c[3];
+  graphene_vec3_t b;
+  graphene_vec3_t c;
   int count;
 
   tmp_poly = g_alloca (sizeof (Vector4) * n_vertices * 2);
@@ -783,23 +784,37 @@ _cogl_util_get_eye_planes_for_screen_poly (float *polygon,
   for (i = 0; i < count; i++)
     {
       plane = &planes[i];
-      memcpy (plane->v0, tmp_poly + i, sizeof (float) * 3);
+
-      memcpy (b, tmp_poly + n_vertices + i, sizeof (float) * 3);
+      poly = &tmp_poly[i];
-      memcpy (c, tmp_poly + n_vertices + i + 1, sizeof (float) * 3);
+      graphene_vec3_init (&plane->v0, poly->x, poly->y, poly->z);
-      cogl_vector3_subtract (b, b, plane->v0);
+
-      cogl_vector3_subtract (c, c, plane->v0);
+      poly = &tmp_poly[n_vertices + i];
-      cogl_vector3_cross_product (plane->n, b, c);
+      graphene_vec3_init (&b, poly->x, poly->y, poly->z);
-      cogl_vector3_normalize (plane->n);
+
+      poly = &tmp_poly[n_vertices + i + 1];
+      graphene_vec3_init (&c, poly->x, poly->y, poly->z);
+
+      graphene_vec3_subtract (&b, &plane->v0, &b);
+      graphene_vec3_subtract (&c, &plane->v0, &c);
+      graphene_vec3_cross (&b, &c, &plane->n);
+      graphene_vec3_normalize (&plane->n, &plane->n);
     }
 
   plane = &planes[n_vertices - 1];
-  memcpy (plane->v0, tmp_poly + 0, sizeof (float) * 3);
+
-  memcpy (b, tmp_poly + (2 * n_vertices - 1), sizeof (float) * 3);
+  poly = &tmp_poly[0];
-  memcpy (c, tmp_poly + n_vertices, sizeof (float) * 3);
+  graphene_vec3_init (&plane->v0, poly->x, poly->y, poly->z);
-  cogl_vector3_subtract (b, b, plane->v0);
+
-  cogl_vector3_subtract (c, c, plane->v0);
+  poly = &tmp_poly[2 * n_vertices - 1];
-  cogl_vector3_cross_product (plane->n, b, c);
+  graphene_vec3_init (&b, poly->x, poly->y, poly->z);
-  cogl_vector3_normalize (plane->n);
+
+  poly = &tmp_poly[n_vertices];
+  graphene_vec3_init (&c, poly->x, poly->y, poly->z);
+
+  graphene_vec3_subtract (&b, &plane->v0, &b);
+  graphene_vec3_subtract (&c, &plane->v0, &c);
+  graphene_vec3_cross (&b, &c, &plane->n);
+  graphene_vec3_normalize (&plane->n, &plane->n);
 }
 
 static void

cogl/cogl/cogl-matrix.c

@@ -75,7 +75,6 @@
 #include <cogl-debug.h>
 #include <cogl-matrix.h>
 #include <cogl-matrix-private.h>
-#include <cogl-vector.h>
 
 #include <glib.h>
 #include <math.h>
@@ -2184,41 +2183,41 @@ cogl_matrix_look_at (CoglMatrix *matrix,
                      float world_up_z)
 {
   CoglMatrix tmp;
-  float forward[3];
+  graphene_vec3_t forward;
-  float side[3];
+  graphene_vec3_t side;
-  float up[3];
+  graphene_vec3_t up;
 
   /* Get a unit viewing direction vector */
-  cogl_vector3_init (forward,
+  graphene_vec3_init (&forward,
                       object_x - eye_position_x,
                       object_y - eye_position_y,
                       object_z - eye_position_z);
-  cogl_vector3_normalize (forward);
+  graphene_vec3_normalize (&forward, &forward);
 
-  cogl_vector3_init (up, world_up_x, world_up_y, world_up_z);
+  graphene_vec3_init (&up, world_up_x, world_up_y, world_up_z);
 
   /* Take the sideways direction as being perpendicular to the viewing
    * direction and the word up vector. */
-  cogl_vector3_cross_product (side, forward, up);
+  graphene_vec3_cross (&forward, &up, &side);
-  cogl_vector3_normalize (side);
+  graphene_vec3_normalize (&side, &side);
 
   /* Now we have unit sideways and forward-direction vectors calculate
    * a new mutually perpendicular up vector. */
-  cogl_vector3_cross_product (up, side, forward);
+  graphene_vec3_cross (&side, &forward, &up);
 
-  tmp.xx = side[0];
+  tmp.xx = graphene_vec3_get_x (&side);
-  tmp.yx = side[1];
+  tmp.yx = graphene_vec3_get_y (&side);
-  tmp.zx = side[2];
+  tmp.zx = graphene_vec3_get_z (&side);
   tmp.wx = 0;
 
-  tmp.xy = up[0];
+  tmp.xy = graphene_vec3_get_x (&up);
-  tmp.yy = up[1];
+  tmp.yy = graphene_vec3_get_y (&up);
-  tmp.zy = up[2];
+  tmp.zy = graphene_vec3_get_z (&up);
   tmp.wy = 0;
 
-  tmp.xz = -forward[0];
+  tmp.xz = -graphene_vec3_get_x (&forward);
-  tmp.yz = -forward[1];
+  tmp.yz = -graphene_vec3_get_y (&forward);
-  tmp.zz = -forward[2];
+  tmp.zz = -graphene_vec3_get_z (&forward);
   tmp.wz = 0;
 
   tmp.xw = 0;

cogl/cogl/cogl-vector.c

@@ -1,298 +0,0 @@
-/*
- * Cogl
- *
- * A Low Level GPU Graphics and Utilities API
- *
- * Copyright (C) 2010 Intel Corporation.
- *
- * Permission is hereby granted, free of charge, to any person
- * obtaining a copy of this software and associated documentation
- * files (the "Software"), to deal in the Software without
- * restriction, including without limitation the rights to use, copy,
- * modify, merge, publish, distribute, sublicense, and/or sell copies
- * of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- *
- * Authors:
- *   Robert Bragg <robert@linux.intel.com>
- */
-
-#include "cogl-config.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 (const void *v1, const void *v2)
-{
-  float *vector0 = (float *)v1;
-  float *vector1 = (float *)v2;
-
-  g_return_val_if_fail (v1 != NULL, FALSE);
-  g_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)
-{
-  g_return_val_if_fail (vector0 != NULL, FALSE);
-  g_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 (const void *v0, const void *v1)
-{
-  g_return_val_if_fail (v1 != NULL, FALSE);
-  g_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

cogl/cogl/cogl-vector.h

@@ -1,356 +0,0 @@
-/*
- * Cogl
- *
- * A Low Level GPU Graphics and Utilities API
- *
- * Copyright (C) 2008,2009,2010 Intel Corporation.
- *
- * Permission is hereby granted, free of charge, to any person
- * obtaining a copy of this software and associated documentation
- * files (the "Software"), to deal in the Software without
- * restriction, including without limitation the rights to use, copy,
- * modify, merge, publish, distribute, sublicense, and/or sell copies
- * of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- *
- * Authors:
- *   Robert Bragg <robert@linux.intel.com>
- */
-
-#if !defined(__COGL_H_INSIDE__) && !defined(COGL_COMPILATION)
-#error "Only <cogl/cogl.h> can be included directly."
-#endif
-
-#ifndef __COGL_VECTOR_H
-#define __COGL_VECTOR_H
-
-G_BEGIN_DECLS
-
-/**
- * SECTION:cogl-vector
- * @short_description: Functions for handling single precision float
- *                     vectors.
- *
- * This exposes a utility API that can be used for basic manipulation of 3
- * component float vectors.
- */
-
-/**
- * cogl_vector3_init:
- * @vector: The 3 component vector you want to initialize
- * @x: The x component
- * @y: The y component
- * @z: The z component
- *
- * Initializes a 3 component, single precision float vector which can
- * then be manipulated with the cogl_vector convenience APIs. Vectors
- * can also be used in places where a "point" is often desired.
- *
- * Since: 1.4
- * Stability: Unstable
- */
-void
-cogl_vector3_init (float *vector, float x, float y, float z);
-
-/**
- * cogl_vector3_init_zero:
- * @vector: The 3 component vector you want to initialize
- *
- * Initializes a 3 component, single precision float vector with zero
- * for each component.
- *
- * Since: 1.4
- * Stability: Unstable
- */
-void
-cogl_vector3_init_zero (float *vector);
-
-/**
- * cogl_vector3_equal:
- * @v1: The first 3 component vector you want to compare
- * @v2: The second 3 component vector you want to compare
- *
- * Compares the components of two vectors and returns TRUE if they are
- * the same.
- *
- * The comparison of the components is done with the '==' operator
- * such that -0 is considered equal to 0, but otherwise there is no
- * fuzziness such as an epsilon to consider vectors that are
- * essentially identical except for some minor precision error
- * differences due to the way they have been manipulated.
- *
- * Returns: TRUE if the vectors are equal else FALSE.
- *
- * Since: 1.4
- * Stability: Unstable
- */
-gboolean
-cogl_vector3_equal (const void *v1, const void *v2);
-
-/**
- * cogl_vector3_equal_with_epsilon:
- * @vector0: The first 3 component vector you want to compare
- * @vector1: The second 3 component vector you want to compare
- * @epsilon: The allowable difference between components to still be
- *           considered equal
- *
- * Compares the components of two vectors using the given epsilon and
- * returns TRUE if they are the same, using an internal epsilon for
- * comparing the floats.
- *
- * Each component is compared against the epsilon value in this way:
- * |[
- *   if (fabsf (vector0->x - vector1->x) < epsilon)
- * ]|
- *
- * Returns: TRUE if the vectors are equal else FALSE.
- *
- * Since: 1.4
- * Stability: Unstable
- */
-gboolean
-cogl_vector3_equal_with_epsilon (const float *vector0,
-                                 const float *vector1,
-                                 float epsilon);
-
-/**
- * cogl_vector3_copy:
- * @vector: The 3 component vector you want to copy
- *
- * Allocates a new 3 component float vector on the heap initializing
- * the components from the given @vector and returns a pointer to the
- * newly allocated vector. You should free the memory using
- * cogl_vector3_free()
- *
- * Returns: A newly allocated 3 component float vector
- *
- * Since: 1.4
- * Stability: Unstable
- */
-float *
-cogl_vector3_copy (const float *vector);
-
-/**
- * cogl_vector3_free:
- * @vector: The 3 component you want to free
- *
- * Frees a 3 component vector that was previously allocated with
- * cogl_vector3_copy()
- *
- * Since: 1.4
- * Stability: Unstable
- */
-void
-cogl_vector3_free (float *vector);
-
-/**
- * cogl_vector3_invert:
- * @vector: The 3 component vector you want to manipulate
- *
- * Inverts/negates all the components of the given @vector.
- *
- * Since: 1.4
- * Stability: Unstable
- */
-void
-cogl_vector3_invert (float *vector);
-
-/**
- * cogl_vector3_add:
- * @result: Where you want the result written
- * @a: The first vector operand
- * @b: The second vector operand
- *
- * Adds each of the corresponding components in vectors @a and @b
- * storing the results in @result.
- *
- * Since: 1.4
- * Stability: Unstable
- */
-void
-cogl_vector3_add (float *result,
-                  const float *a,
-                  const float *b);
-
-/**
- * cogl_vector3_subtract:
- * @result: Where you want the result written
- * @a: The first vector operand
- * @b: The second vector operand
- *
- * Subtracts each of the corresponding components in vector @b from
- * @a storing the results in @result.
- *
- * Since: 1.4
- * Stability: Unstable
- */
-void
-cogl_vector3_subtract (float *result,
-                       const float *a,
-                       const float *b);
-
-/**
- * cogl_vector3_multiply_scalar:
- * @vector: The 3 component vector you want to manipulate
- * @scalar: The scalar you want to multiply the vector components by
- *
- * Multiplies each of the @vector components by the given scalar.
- *
- * Since: 1.4
- * Stability: Unstable
- */
-void
-cogl_vector3_multiply_scalar (float *vector,
-                              float scalar);
-
-/**
- * cogl_vector3_divide_scalar:
- * @vector: The 3 component vector you want to manipulate
- * @scalar: The scalar you want to divide the vector components by
- *
- * Divides each of the @vector components by the given scalar.
- *
- * Since: 1.4
- * Stability: Unstable
- */
-void
-cogl_vector3_divide_scalar (float *vector,
-                            float scalar);
-
-/**
- * cogl_vector3_normalize:
- * @vector: The 3 component vector you want to manipulate
- *
- * Updates the vector so it is a "unit vector" such that the
- * @vector<!-- -->s magnitude or length is equal to 1.
- *
- * <note>It's safe to use this function with the [0, 0, 0] vector, it will not
- * try to divide components by 0 (its norm) and will leave the vector
- * untouched.</note>
- *
- * Since: 1.4
- * Stability: Unstable
- */
-void
-cogl_vector3_normalize (float *vector);
-
-/**
- * cogl_vector3_magnitude:
- * @vector: The 3 component vector you want the magnitude for
- *
- * Calculates the scalar magnitude or length of @vector.
- *
- * Returns: The magnitude of @vector.
- *
- * Since: 1.4
- * Stability: Unstable
- */
-float
-cogl_vector3_magnitude (const float *vector);
-
-/**
- * cogl_vector3_cross_product:
- * @result: Where you want the result written
- * @u: Your first 3 component vector
- * @v: Your second 3 component vector
- *
- * Calculates the cross product between the two vectors @u and @v.
- *
- * The cross product is a vector perpendicular to both @u and @v. This
- * can be useful for calculating the normal of a polygon by creating
- * two vectors in its plane using the polygons vertices and taking
- * their cross product.
- *
- * If the two vectors are parallel then the cross product is 0.
- *
- * You can use a right hand rule to determine which direction the
- * perpendicular vector will point: If you place the two vectors tail,
- * to tail and imagine grabbing the perpendicular line that extends
- * through the common tail with your right hand such that you fingers
- * rotate in the direction from @u to @v then the resulting vector
- * points along your extended thumb.
- *
- * Returns: The cross product between two vectors @u and @v.
- *
- * Since: 1.4
- * Stability: Unstable
- */
-void
-cogl_vector3_cross_product (float *result,
-                            const float *u,
-                            const float *v);
-
-/**
- * cogl_vector3_dot_product:
- * @a: Your first 3 component vector
- * @b: Your second 3 component vector
- *
- * Calculates the dot product of the two 3 component vectors. This
- * can be used to determine the magnitude of one vector projected onto
- * another. (for example a surface normal)
- *
- * For example if you have a polygon with a given normal vector and
- * some other point for which you want to calculate its distance from
- * the polygon, you can create a vector between one of the polygon
- * vertices and that point and use the dot product to calculate the
- * magnitude for that vector but projected onto the normal of the
- * polygon. This way you don't just get the distance from the point to
- * the edge of the polygon you get the distance from the point to the
- * nearest part of the polygon.
- *
- * <note>If you don't use a unit length normal in the above example
- * then you would then also have to divide the result by the magnitude
- * of the normal</note>
- *
- * The dot product is calculated as:
- * |[
- *  (a->x * b->x + a->y * b->y + a->z * b->z)
- * ]|
- *
- * For reference, the dot product can also be calculated from the
- * angle between two vectors as:
- * |[
- *  |a||b|cos𝜃
- * ]|
- *
- * Returns: The dot product of two vectors.
- *
- * Since: 1.4
- * Stability: Unstable
- */
-float
-cogl_vector3_dot_product (const float *a, const float *b);
-
-/**
- * cogl_vector3_distance:
- * @a: The first point
- * @b: The second point
- *
- * If you consider the two given vectors as (x,y,z) points instead
- * then this will compute the distance between those two points.
- *
- * Returns: The distance between two points given as 3 component
- *          vectors.
- *
- * Since: 1.4
- * Stability: Unstable
- */
-float
-cogl_vector3_distance (const float *a, const float *b);
-
-G_END_DECLS
-
-#endif /* __COGL_VECTOR_H */
-

cogl/cogl/cogl.h

@@ -101,7 +101,6 @@
 #include <cogl/cogl-context.h>
 #include <cogl/cogl-buffer.h>
 #include <cogl/cogl-pixel-buffer.h>
-#include <cogl/cogl-vector.h>
 #include <cogl/cogl-texture-2d.h>
 #include <cogl/cogl-texture-2d-gl.h>
 #include <cogl/cogl-texture-2d-sliced.h>

cogl/cogl/cogl.symbols

@@ -885,23 +885,6 @@ cogl_texture_2d_sliced_new_with_size
 cogl_transform
 cogl_translate
 
-cogl_vector3_add
-cogl_vector3_copy
-cogl_vector3_cross_product
-cogl_vector3_distance
-cogl_vector3_divide_scalar
-cogl_vector3_dot_product
-cogl_vector3_equal
-cogl_vector3_equal_with_epsilon
-cogl_vector3_free
-cogl_vector3_init
-cogl_vector3_init_zero
-cogl_vector3_invert
-cogl_vector3_magnitude
-cogl_vector3_multiply_scalar
-cogl_vector3_normalize
-cogl_vector3_subtract
-
 cogl_vertex_buffer_add
 cogl_vertex_buffer_delete
 cogl_vertex_buffer_disable

cogl/cogl/meson.build

@@ -112,7 +112,6 @@ cogl_nonintrospected_headers = [
   'cogl-attribute.h',
   'cogl-primitive.h',
   'cogl-frame-info.h',
-  'cogl-vector.h',
   'cogl-output.h',
   'cogl-matrix-stack.h',
   'cogl-poll.h',
@@ -264,7 +263,6 @@ cogl_sources = [
   'cogl-primitive-private.h',
   'cogl-primitive.c',
   'cogl-matrix.c',
-  'cogl-vector.c',
   'cogl-matrix-private.h',
   'cogl-matrix-stack.c',
   'cogl-matrix-stack-private.h',