![]() |
![]() |
![]() |
Cogl Reference Manual | ![]() |
---|---|---|---|---|
Top | Description |
#define cogl_vector3_init #define cogl_vector3_init_zero #define cogl_vector3_equal #define cogl_vector3_equal_with_epsilon #define cogl_vector3_copy #define cogl_vector3_free #define cogl_vector3_invert #define cogl_vector3_add #define cogl_vector3_subtract #define cogl_vector3_multiply_scalar #define cogl_vector3_divide_scalar #define cogl_vector3_normalize #define cogl_vector3_magnitude #define cogl_vector3_cross_product #define cogl_vector3_dot_product #define cogl_vector3_distance
This exposes a utility API that can be used for basic manipulation of 3 component float vectors.
#define cogl_vector3_init cogl_vector3_init_EXP
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.
|
The CoglVector3 you want to initialize |
|
The x component |
|
The y component |
|
The z component |
Since 1.4
Stability Level: Unstable
#define cogl_vector3_init_zero cogl_vector3_init_zero_EXP
Initializes a 3 component, single precision float vector with zero for each component.
|
The CoglVector3 you want to initialize |
Since 1.4
Stability Level: Unstable
#define cogl_vector3_equal cogl_vector3_equal_EXP
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.
|
The first CoglVector3 you want to compare |
|
The second CoglVector3 you want to compare |
Returns : |
TRUE if the vectors are equal else FALSE. |
Since 1.4
Stability Level: Unstable
#define cogl_vector3_equal_with_epsilon cogl_vector3_equal_with_epsilon_EXP
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:
1 |
if (fabsf (vector0->x - vector1->x) < epsilon) |
|
The first CoglVector3 you want to compare |
|
The second CoglVector3 you want to compare |
|
The allowable difference between components to still be considered equal |
Returns : |
TRUE if the vectors are equal else FALSE. |
Since 1.4
Stability Level: Unstable
#define cogl_vector3_copy cogl_vector3_copy_EXP
Allocates a new CoglVector3 structure 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()
|
The CoglVector3 you want to copy |
Returns : |
A newly allocated CoglVector3. |
Since 1.4
Stability Level: Unstable
#define cogl_vector3_free cogl_vector3_free_EXP
Frees a CoglVector3 that was previously allocated with
cogl_vector_copy()
|
The CoglVector3 you want to free |
Since 1.4
Stability Level: Unstable
#define cogl_vector3_invert cogl_vector3_invert_EXP
Inverts/negates all the components of the given vector
.
|
The CoglVector3 you want to manipulate |
Since 1.4
Stability Level: Unstable
#define cogl_vector3_add cogl_vector3_add_EXP
Adds each of the corresponding components in vectors a
and b
storing the results in result
.
|
Where you want the result written |
|
The first vector operand |
|
The second vector operand |
Since 1.4
Stability Level: Unstable
#define cogl_vector3_subtract cogl_vector3_subtract_EXP
Subtracts each of the corresponding components in vector b
from
a
storing the results in result
.
|
Where you want the result written |
|
The first vector operand |
|
The second vector operand |
Since 1.4
Stability Level: Unstable
#define cogl_vector3_multiply_scalar cogl_vector3_multiply_scalar_EXP
Multiplies each of the vector
components by the given scalar.
|
The CoglVector3 you want to manipulate |
|
The scalar you want to multiply the vector components by |
Since 1.4
Stability Level: Unstable
#define cogl_vector3_divide_scalar cogl_vector3_divide_scalar_EXP
Divides each of the vector
components by the given scalar.
|
The CoglVector3 you want to manipulate |
|
The scalar you want to divide the vector components by |
Since 1.4
Stability Level: Unstable
#define cogl_vector3_normalize cogl_vector3_normalize_EXP
Updates the vector so it is a "unit vector" such that the
vector
s magnitude or length is equal to 1.
|
The CoglVector3 you want to manipulate |
Since 1.4
Stability Level: Unstable
#define cogl_vector3_magnitude cogl_vector3_magnitude_EXP
Calculates the scalar magnitude or length of vector
.
|
The CoglVector3 you want the magnitude for |
Returns : |
The magnitude of vector .
|
Since 1.4
Stability Level: Unstable
#define cogl_vector3_cross_product cogl_vector3_cross_product_EXP
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.
|
Where you want the result written |
|
Your first CoglVector3 |
|
Your second CoglVector3 |
Returns : |
The cross product between two vectors u and v .
|
Since 1.4
Stability Level: Unstable
#define cogl_vector3_dot_product cogl_vector3_dot_product_EXP
Calculates the dot product of the two CoglVector3s. 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.
The dot product is calculated as:
1 |
(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:
1 |
|a||b|cos𝜃 |
|
Your first CoglVector3 |
|
Your second CoglVector3 |
Returns : |
The dot product of two vectors. |
Since 1.4
Stability Level: Unstable
#define cogl_vector3_distance cogl_vector3_distance_EXP
If you consider the two given vectors as (x,y,z) points instead then this will compute the distance between those two points.
|
The first point |
|
The second point |
Returns : |
The distance between two points given as CoglVector3 s
|
Since 1.4
Stability Level: Unstable