clutter 2.0.0-x86-mingw32

data/vendor/local/include/cogl/cogl/cogl-vector.h

@@ -0,0 +1,351 @@
+/*
+ * Cogl
+ *
+ * An object oriented GL/GLES Abstraction/Utility Layer
+ *
+ * Copyright (C) 2008,2009,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>
+ */
+
+#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
+
+COGL_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
+ */
+CoglBool
+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
+ */
+CoglBool
+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);
+
+COGL_END_DECLS
+
+#endif /* __COGL_VECTOR_H */
+

data/vendor/local/include/cogl/cogl/cogl-version.h

@@ -0,0 +1,185 @@
+/*
+ * Cogl
+ *
+ * An object oriented GL/GLES Abstraction/Utility Layer
+ *
+ * Copyright (C) 2012 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, see <http://www.gnu.org/licenses/>.
+ *
+ *
+ */
+
+#ifndef __COGL_VERSION_H__
+#define __COGL_VERSION_H__
+
+#include <cogl/cogl-defines.h>
+
+/**
+ * SECTION:cogl-version
+ * @short_description: Macros for determining the version of Cogl being used
+ *
+ * Cogl offers a set of macros for checking the version of the library
+ * at compile time.
+ *
+ * Since: 1.12.0
+ */
+
+/**
+ * COGL_VERSION_MAJOR:
+ *
+ * The major version of the Cogl library (1, if %COGL_VERSION is 1.2.3)
+ *
+ * Since: 1.12.0
+ */
+#define COGL_VERSION_MAJOR COGL_VERSION_MAJOR_INTERNAL
+
+/**
+ * COGL_VERSION_MINOR:
+ *
+ * The minor version of the Cogl library (2, if %COGL_VERSION is 1.2.3)
+ *
+ * Since: 1.12.0
+ */
+#define COGL_VERSION_MINOR COGL_VERSION_MINOR_INTERNAL
+
+/**
+ * COGL_VERSION_MICRO:
+ *
+ * The micro version of the Cogl library (3, if %COGL_VERSION is 1.2.3)
+ *
+ * Since: 1.12.0
+ */
+#define COGL_VERSION_MICRO COGL_VERSION_MICRO_INTERNAL
+
+/**
+ * COGL_VERSION_STRING:
+ *
+ * The full version of the Cogl library, in string form (suited for
+ * string concatenation)
+ *
+ * Since: 1.12.0
+ */
+#define COGL_VERSION_STRING COGL_VERSION_STRING_INTERNAL
+
+/* Macros to handle compacting a 3-component version number into an
+ * int for quick comparison. This assumes all of the components are <=
+ * 1023 and that an int is >= 31 bits */
+#define COGL_VERSION_COMPONENT_BITS 10
+#define COGL_VERSION_MAX_COMPONENT_VALUE        \
+  ((1 << COGL_VERSION_COMPONENT_BITS) - 1)
+
+/**
+ * COGL_VERSION:
+ *
+ * The Cogl version encoded into a single integer using the
+ * COGL_VERSION_ENCODE() macro. This can be used for quick comparisons
+ * with particular versions.
+ *
+ * Since: 1.12.0
+ */
+#define COGL_VERSION                            \
+  COGL_VERSION_ENCODE (COGL_VERSION_MAJOR,      \
+                       COGL_VERSION_MINOR,      \
+                       COGL_VERSION_MICRO)
+
+/**
+ * COGL_VERSION_ENCODE:
+ * @major: The major part of a version number
+ * @minor: The minor part of a version number
+ * @micro: The micro part of a version number
+ *
+ * Encodes a 3 part version number into a single integer. This can be
+ * used to compare the Cogl version. For example if there is a known
+ * bug in Cogl versions between 1.3.2 and 1.3.4 you could use the
+ * following code to provide a workaround:
+ *
+ * |[
+ * #if COGL_VERSION >= COGL_VERSION_ENCODE (1, 3, 2) && \
+ *     COGL_VERSION <= COGL_VERSION_ENCODE (1, 3, 4)
+ *   /<!-- -->* Do the workaround *<!-- -->/
+ * #endif
+ * ]|
+ *
+ * Since: 1.12.0
+ */
+#define COGL_VERSION_ENCODE(major, minor, micro)        \
+  (((major) << (COGL_VERSION_COMPONENT_BITS * 2)) |     \
+   ((minor) << COGL_VERSION_COMPONENT_BITS)             \
+   | (micro))
+
+/**
+ * COGL_VERSION_GET_MAJOR:
+ * @version: An encoded version number
+ *
+ * Extracts the major part of an encoded version number.
+ *
+ * Since: 1.12.0
+ */
+#define COGL_VERSION_GET_MAJOR(version)                 \
+  (((version) >> (COGL_VERSION_COMPONENT_BITS * 2))     \
+   & COGL_VERSION_MAX_COMPONENT_VALUE)
+
+/**
+ * COGL_VERSION_GET_MINOR:
+ * @version: An encoded version number
+ *
+ * Extracts the minor part of an encoded version number.
+ *
+ * Since: 1.12.0
+ */
+#define COGL_VERSION_GET_MINOR(version)         \
+  (((version) >> COGL_VERSION_COMPONENT_BITS) & \
+   COGL_VERSION_MAX_COMPONENT_VALUE)
+
+/**
+ * COGL_VERSION_GET_MICRO:
+ * @version: An encoded version number
+ *
+ * Extracts the micro part of an encoded version number.
+ *
+ * Since: 1.12.0
+ */
+#define COGL_VERSION_GET_MICRO(version) \
+  ((version) & COGL_VERSION_MAX_COMPONENT_VALUE)
+
+/**
+ * COGL_VERSION_CHECK:
+ * @major: The major part of a version number
+ * @minor: The minor part of a version number
+ * @micro: The micro part of a version number
+ *
+ * A convenient macro to check whether the Cogl version being compiled
+ * against is at least the given version number. For example if the
+ * function cogl_pipeline_frobnicate was added in version 2.0.1 and
+ * you want to conditionally use that function when it is available,
+ * you could write the following:
+ *
+ * |[
+ * #if COGL_VERSION_CHECK (2, 0, 1)
+ * cogl_pipeline_frobnicate (pipeline);
+ * #else
+ * /<!-- -->* Frobnication is not supported. Use a red color instead *<!-- -->/
+ * cogl_pipeline_set_color_4f (pipeline, 1.0f, 0.0f, 0.0f, 1.0f);
+ * #endif
+ * ]|
+ *
+ * Return value: %TRUE if the Cogl version being compiled against is
+ *   greater than or equal to the given three part version number.
+ * Since: 1.12.0
+ */
+#define COGL_VERSION_CHECK(major, minor, micro) \
+  (COGL_VERSION >= COGL_VERSION_ENCODE (major, minor, micro))
+
+#endif /* __COGL_VERSION_H__ */