+++ /dev/null
-/*\r
- * GPAC - Multimedia Framework C SDK\r
- *\r
- * Copyright (c) Jean Le Feuvre 2000-2005 \r
- * All rights reserved\r
- *\r
- * This file is part of GPAC / common tools sub-project\r
- *\r
- * GPAC is free software; you can redistribute it and/or modify\r
- * it under the terms of the GNU Lesser General Public License as published by\r
- * the Free Software Foundation; either version 2, or (at your option)\r
- * any later version.\r
- * \r
- * GPAC is distributed in the hope that it will be useful,\r
- * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r
- * GNU Lesser General Public License for more details.\r
- * \r
- * You should have received a copy of the GNU Lesser General Public\r
- * License along with this library; see the file COPYING. If not, write to\r
- * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. \r
- *\r
- */\r
-\r
-#ifndef _GF_MATH_H_\r
-#define _GF_MATH_H_\r
-\r
-#ifdef __cplusplus\r
-extern "C" {\r
-#endif\r
-\r
-/*!\r
- * \file <gpac/math.h>\r
- * \brief math and trigo functions.\r
- */\r
-\r
-#include <gpac/setup.h>\r
- \r
-/*NOTE: there is a conflict on Win32 VC6 with C++ and gpac headers when including <math.h>*/\r
-#if !defined(__cplusplus) || defined(__SYMBIAN32__)\r
-#include <math.h>\r
-#endif\r
-\r
-/*!\r
- \cond DUMMY_DOXY_SECTION\r
-*/\r
-\r
-#ifndef GPAC_FIXED_POINT\r
-/*note: \r
- to turn fp on, change to GPAC_FIXED_POINT\r
- to turn fp off, change to GPAC_NO_FIXED_POINT\r
- this is needed by configure+sed to modify this file directly\r
-*/\r
-#define GPAC_NO_FIXED_POINT\r
-#endif\r
-\r
-/*!\r
- \endcond\r
-*/\r
-\r
-\r
-/*!\r
- *\addtogroup math_grp math\r
- *\ingroup utils_grp\r
- *\brief Mathematics and Trigonometric functions\r
- *\r
- *This section documents the math and trigo functions used in the GPAC framework. GPAC can be compiled with\r
- *fixed-point support, representing float values on a 16.16 signed integer, which implies a developer \r
- *must take care of float computations when using GPAC.\n\r
- *A developper should not need to know in which mode the framework has been compiled as long as he uses\r
- *the math functions of GPAC which work in both float and fixed-point mode.\n\r
- *Using fixed-point version is decided at compilation time and cannot be changed. The feature is signaled\r
- *through the following macros:\r
- *- GPAC_FIXED_POINT: when defined, GPAC has been compiled in fixed-point mode\r
- *- GPAC_NO_FIXED_POINT: when defined, GPAC has been compiled in regular (float) mode\r
- * @{\r
- */\r
-\r
-\r
-/*****************************************************************************************\r
- FIXED-POINT SUPPORT - HARDCODED FOR 16.16 representation\r
- the software rasterizer also use a 16.16 representation even in non-fixed version\r
-******************************************************************************************/\r
-\r
-#ifdef GPAC_FIXED_POINT\r
-\r
-/*!\r
- *Fixed 16.16 number\r
- *\hideinitializer\r
- \note This documentation has been generated for a fixed-point version of the GPAC framework.\r
- */\r
-typedef s32 Fixed;\r
-#define FIX_ONE 0x10000L\r
-#define INT2FIX(v) ((Fixed)( ((s32) (v) ) << 16))\r
-#define FLT2FIX(v) ((Fixed) ((v) * FIX_ONE))\r
-#define FIX2INT(v) ((s32)(((v)+((FIX_ONE>>1)))>>16))\r
-#define FIX2FLT(v) ((Float)( ((Float)(v)) / ((Float) FIX_ONE)))\r
-#define FIX_EPSILON 2\r
-#define FIX_MAX 0x7FFFFFFF\r
-#define FIX_MIN -FIX_MAX\r
-#define GF_PI2 102944\r
-#define GF_PI 205887\r
-#define GF_2PI 411774\r
-\r
-/*!\return 1/a, expressed as fixed number*/\r
-Fixed gf_invfix(Fixed a);\r
-/*!\return a*b, expressed as fixed number*/\r
-Fixed gf_mulfix(Fixed a, Fixed b);\r
-/*!\return a*b/c, expressed as fixed number*/\r
-Fixed gf_muldiv(Fixed a, Fixed b, Fixed c);\r
-/*!\return a/b, expressed as fixed number*/\r
-Fixed gf_divfix(Fixed a, Fixed b);\r
-/*!\return sqrt(a), expressed as fixed number*/\r
-Fixed gf_sqrt(Fixed x);\r
-/*!\return ceil(a), expressed as fixed number*/\r
-Fixed gf_ceil(Fixed a);\r
-/*!\return floor(a), expressed as fixed number*/\r
-Fixed gf_floor(Fixed a);\r
-/*!\return cos(a), expressed as fixed number*/\r
-Fixed gf_cos(Fixed angle);\r
-/*!\return sin(a), expressed as fixed number*/\r
-Fixed gf_sin(Fixed angle);\r
-/*!\return tan(a), expressed as fixed number*/\r
-Fixed gf_tan(Fixed angle);\r
-/*!\return acos(a), expressed as fixed number*/\r
-Fixed gf_acos(Fixed angle);\r
-/*!\return asin(a), expressed as fixed number*/\r
-Fixed gf_asin(Fixed angle);\r
-/*!\return atan(y, x), expressed as fixed number*/\r
-Fixed gf_atan2(Fixed y, Fixed x);\r
-\r
-#else\r
-\r
-\r
-/*!Fixed is 32bit float number\r
- \note This documentation has been generated for a float version of the GPAC framework.\r
-*/\r
-typedef Float Fixed;\r
-#define FIX_ONE 1.0f\r
-#define INT2FIX(v) ((Float) (v))\r
-#define FLT2FIX(v) ((Float) (v))\r
-#define FIX2INT(v) ((s32)(v))\r
-#define FIX2FLT(v) ((Float) (v))\r
-#define FIX_EPSILON GF_EPSILON_FLOAT\r
-#define FIX_MAX GF_MAX_FLOAT\r
-#define FIX_MIN -GF_MAX_FLOAT\r
-#define GF_PI2 1.5707963267949f\r
-#define GF_PI 3.1415926535898f\r
-#define GF_2PI 6.2831853071796f\r
-\r
-/*!\hideinitializer 1/_a, expressed as fixed number*/\r
-#define gf_invfix(_a) (FIX_ONE/(_a))\r
-/*!\hideinitializer _a*_b, expressed as fixed number*/\r
-#define gf_mulfix(_a, _b) ((_a)*(_b))\r
-/*!\hideinitializer _a*_b/_c, expressed as fixed number*/\r
-#define gf_muldiv(_a, _b, _c) ((_c) ? (_a)*(_b)/(_c) : GF_MAX_FLOAT)\r
-/*!\hideinitializer _a/_b, expressed as fixed number*/\r
-#define gf_divfix(_a, _b) ((_b) ? (_a)/(_b) : GF_MAX_FLOAT)\r
-/*!\hideinitializer sqrt(_a), expressed as fixed number*/\r
-#define gf_sqrt(_a) ((Float) sqrt(_a))\r
-/*!\hideinitializer ceil(_a), expressed as fixed number*/\r
-#define gf_ceil(_a) ((Float) ceil(_a))\r
-/*!\hideinitializer floor(_a), expressed as fixed number*/\r
-#define gf_floor(_a) ((Float) floor(_a))\r
-/*!\hideinitializer cos(_a), expressed as fixed number*/\r
-#define gf_cos(_a) ((Float) cos(_a))\r
-/*!\hideinitializer sin(_a), expressed as fixed number*/\r
-#define gf_sin(_a) ((Float) sin(_a))\r
-/*!\hideinitializer tan(_a), expressed as fixed number*/\r
-#define gf_tan(_a) ((Float) tan(_a))\r
-/*!\hideinitializer atan2(_y,_x), expressed as fixed number*/\r
-#define gf_atan2(_y, _x) ((Float) atan2(_y, _x))\r
-/*!\hideinitializer acos(_a), expressed as fixed number*/\r
-#define gf_acos(_a) ((Float) acos(_a))\r
-/*!\hideinitializer asin(_a), expressed as fixed number*/\r
-#define gf_asin(_a) ((Float) asin(_a))\r
-\r
-#endif\r
-\r
-/*!\def FIX_ONE\r
- \hideinitializer\r
- Fixed unit value\r
-*/\r
-/*!\def INT2FIX(v)\r
- \hideinitializer\r
- Conversion from integer to fixed\r
-*/\r
-/*!\def FLT2FIX(v)\r
- \hideinitializer\r
- Conversion from float to fixed\r
-*/\r
-/*!\def FIX2INT(v)\r
- \hideinitializer\r
- Conversion from fixed to integer\r
-*/\r
-/*!\def FIX2FLT(v)\r
- \hideinitializer\r
- Conversion from fixed to float\r
-*/\r
-/*!\def FIX_EPSILON\r
- \hideinitializer\r
- Epsilon Fixed (positive value closest to 0)\r
-*/\r
-/*!\def FIX_MAX\r
- \hideinitializer\r
- Maximum Fixed (maximum representable fixed value)\r
-*/\r
-/*!\def FIX_MIN\r
- \hideinitializer\r
- Minimum Fixed (minimum representable fixed value)\r
-*/\r
-/*!\def GF_PI2\r
- \hideinitializer\r
- PI/2 expressed as Fixed\r
-*/\r
-/*!\def GF_PI\r
- \hideinitializer\r
- PI expressed as Fixed\r
-*/\r
-/*!\def GF_2PI\r
- \hideinitializer\r
- 2*PI expressed as Fixed\r
-*/\r
-\r
-Fixed gf_angle_diff(Fixed a, Fixed b);\r
-\r
-/*!\r
- * \brief Field bit-size \r
- *\r
- * Gets the number of bits needed to represent the value.\r
- * \param MaxVal Maximum value to be represented.\r
- * \return number of bits required to represent the value.\r
- */\r
-u32 gf_get_bit_size(u32 MaxVal);\r
-\r
-/*!\r
- * \brief Get power of 2\r
- *\r
- * Gets the closest power of 2 greater or equal to the value.\r
- * \param val value to be used.\r
- * \return requested power of 2.\r
- */\r
-u32 gf_get_next_pow2(u32 val);\r
-\r
-/*!\r
- *\addtogroup math2d_grp math2d\r
- *\ingroup math_grp\r
- *\brief 2D Mathematics functions\r
- *\r
- *This section documents mathematic tools for 2D geometry and color matrices operations\r
- * @{\r
- */\r
-\r
-/*!\brief 2D point\r
- *\r
- *The 2D point object is used in all the GPAC framework for both point and vector representation.\r
-*/\r
-typedef struct __vec2f\r
-{\r
- Fixed x;\r
- Fixed y;\r
-} GF_Point2D;\r
-/*!\r
- *\brief get 2D vector length\r
- *\r
- *Gets the length of a 2D vector\r
- *\return length of the vector\r
- */\r
-Fixed gf_v2d_len(GF_Point2D *vec);\r
-/*!\r
- *\brief 2D vector from polar coordinates\r
- *\r
- *Constructs a 2D vector from its polar coordinates\r
- *\param length the length of the vector\r
- *\param angle the angle of the vector in radians\r
- *\return the 2D vector\r
- */\r
-GF_Point2D gf_v2d_from_polar(Fixed length, Fixed angle);\r
-\r
-/*!\brief rectangle 2D\r
- *\r
- *The 2D rectangle used in the GPAC project.\r
- */\r
-typedef struct\r
-{\r
- /*!the left coordinate of the rectangle*/\r
- Fixed x;\r
- /*!the top coordinate of the rectangle, regardless of the canvas orientation. In other words, y is always the \r
- greatest coordinate value, even if the rectangle is presented bottom-up. This insures proper rectangles testing*/\r
- Fixed y;\r
- /*!the width of the rectangle. Width must be greater than or equal to 0*/\r
- Fixed width;\r
- /*!the height of the rectangle. Height must be greater than or equal to 0*/\r
- Fixed height;\r
-} GF_Rect;\r
-\r
-/*!\r
- \brief rectangle union\r
- *\r
- *Gets the union of two rectangles.\r
- *\param rc1 first rectangle of the union. Upon return, this rectangle will contain the result of the union\r
- *\param rc2 second rectangle of the union\r
-*/\r
-void gf_rect_union(GF_Rect *rc1, GF_Rect *rc2);\r
-/*!\r
- \brief centers a rectangle\r
- *\r
- *Builds a rectangle centered on the origin\r
- *\param w width of the rectangle\r
- *\param h height of the rectangle\r
- *\return centered rectangle object\r
-*/\r
-GF_Rect gf_rect_center(Fixed w, Fixed h);\r
-/*!\r
- \brief rectangle overlap test\r
- *\r
- *Tests if two rectangles overlap.\r
- *\param rc1 first rectangle to test\r
- *\param rc2 second rectangle to test\r
- *\return 1 if rectangles overlap, 0 otherwise\r
-*/\r
-Bool gf_rect_overlaps(GF_Rect rc1, GF_Rect rc2);\r
-/*!\r
- \brief rectangle identity test\r
- *\r
- *Tests if two rectangles are identical.\r
- *\param rc1 first rectangle to test\r
- *\param rc2 second rectangle to test\r
- *\return 1 if rectangles are identical, 0 otherwise\r
-*/\r
-Bool gf_rect_equal(GF_Rect rc1, GF_Rect rc2);\r
-\r
-/*!\r
- *\brief pixel-aligned rectangle\r
- *\r
- *Pixel-aligned rectangle used in the GPAC framework. This is usually needed for 2D drawing algorithms.\r
- */\r
-typedef struct\r
-{\r
- /*!the left coordinate of the rectangle*/\r
- s32 x;\r
- /*!the top coordinate of the rectangle, regardless of the canvas orientation. In other words, y is always the \r
- greatest coordinate value, even if the rectangle is presented bottom-up. This insures proper rectangles operations*/\r
- s32 y;\r
- /*!the width of the rectangle. Width must be greater than or equal to 0*/\r
- s32 width;\r
- /*!the height of the rectangle. Height must be greater than or equal to 0*/\r
- s32 height;\r
-} GF_IRect;\r
-/*!\r
- *\brief gets the pixelized version of a rectangle\r
- *\r
- *Returns the smallest pixel-aligned rectangle completely containing a rectangle\r
- *\param r the rectangle to transform\r
- *\return the pixel-aligned transformed rectangle\r
-*/\r
-GF_IRect gf_rect_pixelize(GF_Rect *r);\r
-\r
-\r
-/*!\r
- *\brief 2D matrix\r
- *\r
- *The 2D affine matrix object usied in GPAC. The transformation of P(x,y) in P'(X, Y) is:\r
- \code\r
- X = m[0]*x + m[1]*y + m[2];\r
- Y = m[3]*x + m[4]*y + m[5];\r
- \endcode\r
-*/\r
-typedef struct\r
-{\r
- Fixed m[6];\r
-} GF_Matrix2D;\r
-\r
-/*!\brief matrix initialization\r
- *\hideinitializer\r
- *\r
- *Inits the matrix to the identity matrix\r
-*/\r
-#define gf_mx2d_init(_obj) { memset((_obj).m, 0, sizeof(Fixed)*6); (_obj).m[0] = (_obj).m[4] = FIX_ONE; }\r
-/*!\brief matrix copy\r
- *\hideinitializer\r
- *\r
- *Copies the matrix _from to the matrix _obj\r
-*/\r
-#define gf_mx2d_copy(_obj, from) memcpy((_obj).m, (from).m, sizeof(Fixed)*6)\r
-/*!\brief matrix identity testing\r
- *\hideinitializer\r
- *\r
- *This macro evaluates to 1 if the matrix _obj is the identity matrix, 0 otherwise\r
-*/\r
-#define gf_mx2d_is_identity(_obj) ((!(_obj).m[1] && !(_obj).m[2] && !(_obj).m[3] && !(_obj).m[5] && ((_obj).m[0]==FIX_ONE) && ((_obj).m[4]==FIX_ONE)) ? 1 : 0)\r
-\r
-/*!\brief 2D matrix multiplication\r
- *\r
- *Multiplies two 2D matrices from*_this\r
- *\param _this matrix being transformed. Once the function is called, _this contains the result matrix\r
- *\param from transformation matrix to add\r
-*/\r
-void gf_mx2d_add_matrix(GF_Matrix2D *_this, GF_Matrix2D *from);\r
-\r
-/*!\brief 2D matrix pre-multiplication\r
- *\r
- *Multiplies two 2D matrices _this*from\r
- *\param _this matrix being transformed. Once the function is called, _this contains the result matrix\r
- *\param from transformation matrix to add\r
-*/\r
-void gf_mx2d_pre_multiply(GF_Matrix2D *_this, GF_Matrix2D *from);\r
-\r
-/*!\brief matrix translating\r
- *\r
- *Translates a 2D matrix\r
- *\param _this matrix being transformed. Once the function is called, _this contains the result matrix\r
- *\param cx horizontal translation\r
- *\param cy vertical translation\r
-*/\r
-void gf_mx2d_add_translation(GF_Matrix2D *_this, Fixed cx, Fixed cy);\r
-/*!\brief matrix rotating\r
- *\r
- *Rotates a 2D matrix\r
- *\param _this matrix being transformed. Once the function is called, _this contains the result matrix\r
- *\param cx horizontal rotation center coordinate\r
- *\param cy vertical rotation center coordinate\r
- *\param angle rotation angle in radians\r
-*/\r
-void gf_mx2d_add_rotation(GF_Matrix2D *_this, Fixed cx, Fixed cy, Fixed angle);\r
-/*!\brief matrix scaling\r
- *\r
- *Scales a 2D matrix\r
- *\param _this matrix being transformed. Once the function is called, _this contains the result matrix\r
- *\param scale_x horizontal scaling factor\r
- *\param scale_y vertical scaling factor\r
-*/\r
-void gf_mx2d_add_scale(GF_Matrix2D *_this, Fixed scale_x, Fixed scale_y);\r
-/*!\brief matrix uncentered scaling\r
- *\r
- *Scales a 2D matrix with a non-centered scale\r
- *\param _this matrix being transformed. Once the function is called, _this contains the result matrix\r
- *\param scale_x horizontal scaling factor\r
- *\param scale_y vertical scaling factor\r
- *\param cx horizontal scaling center coordinate\r
- *\param cy vertical scaling center coordinate\r
- *\param angle scale orienttion angle in radians\r
-*/\r
-void gf_mx2d_add_scale_at(GF_Matrix2D *_this, Fixed scale_x, Fixed scale_y, Fixed cx, Fixed cy, Fixed angle);\r
-/*!\brief matrix skewing\r
- *\r
- *Skews a 2D matrix\r
- *\param _this matrix being transformed. Once the function is called, _this contains the result matrix\r
- *\param skew_x horizontal skew factor\r
- *\param skew_y vertical skew factor\r
-*/\r
-void gf_mx2d_add_skew(GF_Matrix2D *_this, Fixed skew_x, Fixed skew_y);\r
-/*!\brief matrix horizontal skewing\r
- *\r
- *Skews a 2D matrix horizontally by a given angle\r
- *\param _this matrix being transformed. Once the function is called, _this contains the result matrix\r
- *\param angle horizontal skew angle in radians\r
-*/\r
-void gf_mx2d_add_skew_x(GF_Matrix2D *_this, Fixed angle);\r
-/*!\brief matrix vertical skewing\r
- *\r
- *Skews a 2D matrix vertically by a given angle\r
- *\param _this matrix being transformed. Once the function is called, _this contains the result matrix\r
- *\param angle vertical skew angle in radians\r
-*/\r
-void gf_mx2d_add_skew_y(GF_Matrix2D *_this, Fixed angle);\r
-/*!\brief matrix inversing\r
- *\r
- *Inverses a 2D matrix \r
- *\param _this matrix being transformed. Once the function is called, _this contains the result matrix\r
-*/\r
-void gf_mx2d_inverse(GF_Matrix2D *_this);\r
-/*!\brief matrix coordinate transformation\r
- *\r
- *Applies a 2D matrix transformation to coordinates\r
- *\param _this transformation matrix\r
- *\param x pointer to horizontal coordinate. Once the function is called, x contains the transformed horizontal coordinate\r
- *\param y pointer to vertical coordinate. Once the function is called, y contains the transformed vertical coordinate\r
-*/\r
-void gf_mx2d_apply_coords(GF_Matrix2D *_this, Fixed *x, Fixed *y);\r
-/*!\brief matrix point transformation\r
- *\r
- *Applies a 2D matrix transformation to a 2D point\r
- *\param _this transformation matrix\r
- *\param pt pointer to 2D point. Once the function is called, pt contains the transformed point\r
-*/\r
-void gf_mx2d_apply_point(GF_Matrix2D *_this, GF_Point2D *pt);\r
-/*!\brief matrix rectangle transformation\r
- *\r
- *Applies a 2D matrix transformation to a rectangle, giving the enclosing rectangle of the transformed one\r
- *\param _this transformation matrix\r
- *\param rc pointer to rectangle. Once the function is called, rc contains the transformed rectangle\r
-*/\r
-void gf_mx2d_apply_rect(GF_Matrix2D *_this, GF_Rect *rc);\r
-\r
-/*!\brief matrix decomposition\r
- *\r
- *Decomposes a 2D matrix M as M=Scale x Rotation x Translation if possible\r
- *\param _this transformation matrix\r
- *\param scale resulting scale part\r
- *\param rotate resulting rotation part\r
- *\param translate resulting translation part\r
- *\return 0 if matrix cannot be decomposed, 1 otherwise\r
-*/\r
-Bool gf_mx2d_decompose(GF_Matrix2D *_this, GF_Point2D *scale, Fixed *rotate, GF_Point2D *translate);\r
-\r
-/*! @} */\r
-\r
-\r
-/*!\r
- *\addtogroup math3d_grp math3d\r
- *\ingroup math_grp\r
- *\brief 3D Mathematics functions\r
- *\r
- *This section documents mathematic tools for 3D geometry operations\r
- * @{\r
- */\r
-\r
-/*!\brief 3D point or vector\r
- *\r
- *The 3D point object is used in all the GPAC framework for both point and vector representation.\r
-*/\r
-typedef struct __vec3f\r
-{\r
- Fixed x;\r
- Fixed y;\r
- Fixed z;\r
-} GF_Vec;\r
-\r
-/*base vector operations are MACROs for faster access*/\r
-/*!\hideinitializer macro evaluating to 1 if vectors are equal, 0 otherwise*/\r
-#define gf_vec_equal(v1, v2) (((v1).x == (v2).x) && ((v1).y == (v2).y) && ((v1).z == (v2).z))\r
-/*!\hideinitializer macro reversing a vector v = v*/\r
-#define gf_vec_rev(v) { (v).x = -(v).x; (v).y = -(v).y; (v).z = -(v).z; }\r
-/*!\hideinitializer macro performing the minus operation res = v1 - v2*/\r
-#define gf_vec_diff(res, v1, v2) { (res).x = (v1).x - (v2).x; (res).y = (v1).y - (v2).y; (res).z = (v1).z - (v2).z; }\r
-/*!\hideinitializer macro performing the add operation res = v1 + v2*/\r
-#define gf_vec_add(res, v1, v2) { (res).x = (v1).x + (v2).x; (res).y = (v1).y + (v2).y; (res).z = (v1).z + (v2).z; }\r
-\r
-/*!\r
- *\brief get 3D vector length\r
- *\r
- *Gets the length of a 3D vector\r
- *\return length of the vector\r
- */\r
-Fixed gf_vec_len(GF_Vec v);\r
-/*!\r
- *\brief get 3D vector square length\r
- *\r
- *Gets the square length of a 3D vector\r
- *\return square length of the vector\r
- */\r
-Fixed gf_vec_lensq(GF_Vec v);\r
-/*!\r
- *\brief get 3D vector dot product\r
- *\r
- *Gets the dot product of two vectors\r
- *\return dot product of the vectors\r
- */\r
-Fixed gf_vec_dot(GF_Vec v1, GF_Vec v2);\r
-/*!\r
- *\brief vector normalization\r
- *\r
- *Norms the vector, eg make its length equal to \ref FIX_ONE\r
- *\param v vector to normalize\r
- */\r
-void gf_vec_norm(GF_Vec *v);\r
-/*!\r
- *\brief vector scaling\r
- *\r
- *Scales a vector by a given amount\r
- *\param v vector to scale\r
- *\param f scale factor\r
- *\return scaled vector\r
- */\r
-GF_Vec gf_vec_scale(GF_Vec v, Fixed f);\r
-/*!\r
- *\brief vector cross product\r
- *\r
- *Gets the cross product of two vectors\r
- *\param v1 first vector\r
- *\param v2 second vector\r
- *\return cross-product vector\r
- */\r
-GF_Vec gf_vec_cross(GF_Vec v1, GF_Vec v2);\r
-\r
-/*!\brief 4D vector\r
- *\r
- *The 4D vector object is used in all the GPAC framework for 4 dimension vectors, VRML Rotations and quaternions representation.\r
-*/\r
-typedef struct __vec4f\r
-{\r
- Fixed x;\r
- Fixed y;\r
- Fixed z;\r
- Fixed q;\r
-} GF_Vec4;\r
-\r
-\r
-/*!\brief 3D matrix\r
- *\r
- *The 3D matrix object used in GPAC. The matrix is oriented like OpenGL matrices (column-major ordering), with \r
- the translation part at the end of the coefficients list.\r
- \note Unless specified otherwise, the matrix object is always expected to represent an affine transformation.\r
- */\r
-typedef struct\r
-{\r
- Fixed m[16];\r
-} GF_Matrix;\r
-\r
-\r
-/*!\hideinitializer gets the len of a quaternion*/\r
-#define gf_quat_len(v) gf_sqrt(gf_mulfix((v).q,(v).q) + gf_mulfix((v).x,(v).x) + gf_mulfix((v).y,(v).y) + gf_mulfix((v).z,(v).z))\r
-/*!\hideinitializer normalizes a quaternion*/\r
-#define gf_quat_norm(v) { \\r
- Fixed __mag = gf_quat_len(v); \\r
- (v).x = gf_divfix((v).x, __mag); (v).y = gf_divfix((v).y, __mag); (v).z = gf_divfix((v).z, __mag); (v).q = gf_divfix((v).q, __mag); \\r
- } \\r
-\r
-/*!\brief quaternion to rotation\r
- *\r
- *Transforms a quaternion to a Rotation, expressed as a 4 dimension vector with x,y,z for axis and q for rotation angle\r
- *\param quat the quaternion to transform\r
- *\return the rotation value\r
- */\r
-GF_Vec4 gf_quat_to_rotation(GF_Vec4 *quat);\r
-/*!\brief quaternion from rotation\r
- *\r
- *Transforms a Rotation to a quaternion\r
- *\param rot the rotation to transform\r
- *\return the quaternion value\r
- */\r
-GF_Vec4 gf_quat_from_rotation(GF_Vec4 rot);\r
-/*!inverses a quaternion*/\r
-GF_Vec4 gf_quat_get_inv(GF_Vec4 *quat);\r
-/*!\brief quaternion multiplication\r
- *\r
- *Multiplies two quaternions\r
- *\param q1 the first quaternion\r
- *\param q2 the second quaternion\r
- *\return the resulting quaternion\r
- */\r
-GF_Vec4 gf_quat_multiply(GF_Vec4 *q1, GF_Vec4 *q2);\r
-/*!\brief quaternion vector rotating\r
- *\r
- *Rotates a vector with a quaternion \r
- *\param quat the quaternion modelizing the rotation\r
- *\param vec the vector to rotate\r
- *\return the resulting vector\r
- */\r
-GF_Vec gf_quat_rotate(GF_Vec4 *quat, GF_Vec *vec);\r
-/*!\brief quaternion from axis and cos\r
- *\r
- *Constructs a quaternion from an axis and a cosinus value (shortcut to \ref gf_quat_from_rotation)\r
- *\param axis the rotation axis\r
- *\param cos_a the rotation cosinus value\r
- *\return the resulting quaternion\r
- */\r
-GF_Vec4 gf_quat_from_axis_cos(GF_Vec axis, Fixed cos_a);\r
-/*!\brief quaternion interpolation\r
- *\r
- *Interpolates two quaternions using spherical linear interpolation\r
- *\param q1 the first quaternion\r
- *\param q2 the second quaternion\r
- *\param frac the fraction of the interpolation, between 0 and \ref FIX_ONE\r
- *\return the interpolated quaternion\r
- */\r
-GF_Vec4 gf_quat_slerp(GF_Vec4 q1, GF_Vec4 q2, Fixed frac);\r
-\r
-/*!\brief 3D Bounding Box\r
- *\r
- *The 3D Bounding Box is a 3D Axis-Aligned Bounding Box used to in various tools of the GPAC framework for bounds \r
- estimation of a 3D object. It features an axis-aligned box and a sphere bounding volume for fast intersection tests.\r
- */\r
-typedef struct\r
-{\r
- /*!minimum x, y, and z of the object*/\r
- GF_Vec min_edge;\r
- /*!maximum x, y, and z of the object*/\r
- GF_Vec max_edge;\r
-\r
- /*!center of the bounding box.\note this is computed from min_edge and max_edge*/\r
- GF_Vec center;\r
- /*!radius of the bounding sphere for this box.\note this is computed from min_edge and max_edge*/\r
- Fixed radius;\r
- /*!the bbox center and radius are valid*/\r
- Bool is_set;\r
-} GF_BBox;\r
-/*!updates information of the bounding box based on the edge information*/\r
-void gf_bbox_refresh(GF_BBox *b);\r
-/*!builds a bounding box from a 2D rectangle*/\r
-void gf_bbox_from_rect(GF_BBox *box, GF_Rect *rc);\r
-/*!builds a rectangle from a 3D bounding box.\note The z dimension is lost and no projection is performed*/\r
-void gf_rect_from_bbox(GF_Rect *rc, GF_BBox *box);\r
-/*!\brief bounding box expansion\r
- *\r
- *Checks if a point is inside a bounding box and updates the bounding box to include it if not the case\r
- *\param box the bounding box object\r
- *\param pt the 3D point to check\r
-*/\r
-void gf_bbox_grow_point(GF_BBox *box, GF_Vec pt);\r
-/*!performs the union of two bounding boxes*/\r
-void gf_bbox_union(GF_BBox *b1, GF_BBox *b2);\r
-/*!checks if two bounding boxes are equal or not*/\r
-Bool gf_bbox_equal(GF_BBox *b1, GF_BBox *b2);\r
-/*!checks if a point is inside a bounding box or not*/\r
-Bool gf_bbox_point_inside(GF_BBox *box, GF_Vec *p);\r
-/*!\brief get box vertices\r
- *\r
- *Returns the 8 bounding box vertices given the minimum and maximum edge. Vertices are ordered to respect \r
- "p-vertex indexes", (vertex from a box closest to plane) and so that n-vertex (vertex from a box farthest from plane) \r
- is 7-p_vx_idx\r
- *\param bmin minimum edge of the box\r
- *\param bmax maximum edge of the box\r
- *\param vecs list of 8 3D points used to store the vertices.\r
-*/\r
-void gf_bbox_get_vertices(GF_Vec bmin, GF_Vec bmax, GF_Vec *vecs);\r
-\r
-\r
-/*!\brief matrix initialization\r
- *\hideinitializer\r
- *\r
- *Inits the matrix to the identity matrix\r
-*/\r
-#define gf_mx_init(_obj) { memset((_obj).m, 0, sizeof(Fixed)*16); (_obj).m[0] = (_obj).m[5] = (_obj).m[10] = (_obj).m[15] = FIX_ONE; }\r
-/*!\brief matrix copy\r
- *\hideinitializer\r
- *\r
- *Copies the matrix _from to the matrix _obj\r
-*/\r
-#define gf_mx_copy(_obj, from) memcpy(&(_obj), &(from), sizeof(GF_Matrix));\r
-/*!\brief matrix constructor from 2D\r
- *\r
- *Initializes a 3D matrix from a 2D matrix.\note all z-related coefficients will be set to default.\r
-*/\r
-void gf_mx_from_mx2d(GF_Matrix *mx, GF_Matrix2D *mat2D);\r
-/*!\brief matrix identity testing\r
- *\r
- *Tests if two matrices are equal or not.\r
- \return 1 if matrices are same, 0 otherwise\r
-*/\r
-Bool gf_mx_equal(GF_Matrix *mx1, GF_Matrix *mx2);\r
-/*!\brief matrix translation\r
- *\r
- *Translates a matrix \r
- *\param mx the matrix being transformed. Once the function is called, contains the result matrix\r
- *\param tx horizontal translation\r
- *\param ty vertical translation\r
- *\param tz depth translation\r
-*/\r
-void gf_mx_add_translation(GF_Matrix *mx, Fixed tx, Fixed ty, Fixed tz);\r
-/*!\brief matrix scaling\r
- *\r
- *Scales a matrix \r
- *\param mx the matrix being transformed. Once the function is called, contains the result matrix\r
- *\param sx horizontal translation scaling\r
- *\param sy vertical translation scaling\r
- *\param sz depth translation scaling\r
-*/\r
-void gf_mx_add_scale(GF_Matrix *mx, Fixed sx, Fixed sy, Fixed sz);\r
-/*!\brief matrix rotating\r
- *\r
- *Rotates a matrix \r
- *\param mx the matrix being transformed. Once the function is called, contains the result matrix\r
- *\param angle rotation angle in radians\r
- *\param x horizontal coordinate of rotation axis\r
- *\param y vertical coordinate of rotation axis\r
- *\param z depth coordinate of rotation axis\r
-*/\r
-void gf_mx_add_rotation(GF_Matrix *mx, Fixed angle, Fixed x, Fixed y, Fixed z);\r
-/*!\brief matrices multiplication \r
- *\r
- *Multiplies a matrix with another one mx = mx*mul\r
- *\param mx the matrix being transformed. Once the function is called, contains the result matrix\r
- *\param mul the matrix to add\r
-*/\r
-void gf_mx_add_matrix(GF_Matrix *mx, GF_Matrix *mul);\r
-/*!\brief 2D matrix multiplication\r
- *\r
- *Adds a 2D affine matrix to a matrix\r
- *\param mx the matrix \r
- *\param mat2D the matrix to premultiply\r
- */\r
-void gf_mx_add_matrix_2d(GF_Matrix *mx, GF_Matrix2D *mat2D);\r
-\r
-/*!\brief affine matrix inversion\r
- *\r
- *Inverses an affine matrix.\warning Results are undefined if the matrix is not an affine one\r
- *\param mx the matrix to inverse\r
- */\r
-void gf_mx_inverse(GF_Matrix *mx);\r
-/*!\brief matrix point transformation\r
- *\r
- *Applies a 3D matrix transformation to a 3D point\r
- *\param mx transformation matrix\r
- *\param pt pointer to 3D point. Once the function is called, pt contains the transformed point\r
-*/\r
-void gf_mx_apply_vec(GF_Matrix *mx, GF_Vec *pt);\r
-/*!\brief matrix rectangle transformation\r
- *\r
- *Applies a 3D matrix transformation to a rectangle, giving the enclosing rectangle of the transformed one.\note all depth information are discarded.\r
- *\param _this transformation matrix\r
- *\param rc pointer to rectangle. Once the function is called, rc contains the transformed rectangle\r
-*/\r
-void gf_mx_apply_rect(GF_Matrix *_this, GF_Rect *rc);\r
-/*!\brief ortho matrix construction\r
- *\r
- *Creates an orthogonal projection matrix\r
- *\param mx matrix to initialize\r
- *\param left min horizontal coordinate of viewport\r
- *\param right max horizontal coordinate of viewport\r
- *\param bottom min vertical coordinate of viewport\r
- *\param top max vertical coordinate of viewport\r
- *\param z_near min depth coordinate of viewport\r
- *\param z_far max depth coordinate of viewport\r
-*/\r
-void gf_mx_ortho(GF_Matrix *mx, Fixed left, Fixed right, Fixed bottom, Fixed top, Fixed z_near, Fixed z_far);\r
-/*!\brief perspective matrix construction\r
- *\r
- *Creates a perspective projection matrix\r
- *\param mx matrix to initialize\r
- *\param foc camera field of view angle in radian\r
- *\param aspect_ratio viewport aspect ratio\r
- *\param z_near min depth coordinate of viewport\r
- *\param z_far max depth coordinate of viewport\r
-*/\r
-void gf_mx_perspective(GF_Matrix *mx, Fixed foc, Fixed aspect_ratio, Fixed z_near, Fixed z_far);\r
-/*!\brief creates look matrix\r
- *\r
- *Creates a transformation matrix looking at a given direction from a given point (camera matrix).\r
- *\param mx matrix to initialize\r
- *\param position position\r
- *\param target look direction\r
- *\param up_vector vector describing the up direction\r
-*/\r
-void gf_mx_lookat(GF_Matrix *mx, GF_Vec position, GF_Vec target, GF_Vec up_vector);\r
-/*!\brief matrix box transformation\r
- *\r
- *Applies a 3D matrix transformation to a bounding box, giving the enclosing box of the transformed one\r
- *\param mx transformation matrix\r
- *\param b pointer to bounding box. Once the function is called, contains the transformed bounding box\r
-*/\r
-void gf_mx_apply_bbox(GF_Matrix *mx, GF_BBox *b);\r
-/*!\brief matrix box sphere transformation\r
- *\r
- *Applies a 3D matrix transformation to a bounding box, computing only the enclosing sphere of the transformed one.\r
- *\param mx transformation matrix\r
- *\param b pointer to bounding box. Once the function is called, contains the transformed bounding sphere\r
-*/\r
-void gf_mx_apply_bbox_sphere(GF_Matrix *mx, GF_BBox *box);\r
-/*!\brief non-affine matrix multiplication\r
- *\r
- *Multiplies two non-affine matrices mx = mx*mul\r
-*/\r
-void gf_mx_add_matrix_4x4(GF_Matrix *mat, GF_Matrix *mul);\r
-/*!\brief non-affine matrix inversion\r
- *\r
- *Inverses a non-affine matrices\r
- *\return 1 if inversion was done, 0 if inversion not possible.\r
-*/\r
-Bool gf_mx_inverse_4x4(GF_Matrix *mx);\r
-/*!\brief matrix 4D vector transformation\r
- *\r
- *Applies a 3D non-affine matrix transformation to a 4 dimension vector\r
- *\param mx transformation matrix\r
- *\param vec pointer to the vector. Once the function is called, contains the transformed vector\r
-*/\r
-void gf_mx_apply_vec_4x4(GF_Matrix *mx, GF_Vec4 *vec);\r
-/*!\brief matrix decomposition\r
- *\r
- *Decomposes a matrix into translation, scale, shear and rotate\r
- *\param mx the matrix to decompose\r
- *\param translate the decomposed translation part\r
- *\param scale the decomposed scaling part\r
- *\param rotate the decomposed rotation part, expressed as a Rotataion (axis + angle)\r
- *\param shear the decomposed shear part\r
- */\r
-void gf_mx_decompose(GF_Matrix *mx, GF_Vec *translate, GF_Vec *scale, GF_Vec4 *rotate, GF_Vec *shear);\r
-/*!\brief matrix vector rotation\r
- *\r
- *Rotates a vector with a given matrix, ignoring any translation.\r
- *\param mx transformation matrix\r
- *\param pt pointer to 3D vector. Once the function is called, pt contains the transformed vector\r
- */\r
-void gf_mx_rotate_vector(GF_Matrix *mx, GF_Vec *pt);\r
-/*!\brief matrix initialization from vectors\r
- *\r
- *Inits a matrix to rotate the local axis in the given vectors\r
- \param mx matrix to initialize\r
- \param x_axis target normalized X axis\r
- \param y_axis target normalized Y axis\r
- \param z_axis target normalized Z axis\r
-*/\r
-void gf_mx_rotation_matrix_from_vectors(GF_Matrix *mx, GF_Vec x_axis, GF_Vec y_axis, GF_Vec z_axis);\r
-/*!\brief matrix to 2D matrix \r
- *\r
- *Inits a 2D matrix by removing all depth info from a 3D matrix\r
- *\param mx2d 2D matrix to initialize\r
- *\param mx 3D matrix to use\r
-*/\r
-void gf_mx2d_from_mx(GF_Matrix2D *mx2d, GF_Matrix *mx);\r
-\r
-/*!\brief Plane object*/\r
-typedef struct\r
-{\r
- /*!normal vector to the plane*/\r
- GF_Vec normal;\r
- /*!distance from origin of the plane*/\r
- Fixed d;\r
-} GF_Plane;\r
-/*!\brief matrix plane transformation\r
- *\r
- *Transorms a plane by a given matrix\r
- *\param mx the matrix to use\r
- *\param plane pointer to 3D plane. Once the function is called, plane contains the transformed plane\r
- */\r
-void gf_mx_apply_plane(GF_Matrix *mx, GF_Plane *plane);\r
-/*!\brief point to plane distance\r
- *\r
- *Gets the distance between a point and a plne\r
- *\param plane the plane to use\r
- *\param p pointer to ^point to check\r
- *\return the distance between the place and the point\r
- */\r
-Fixed gf_plane_get_distance(GF_Plane *plane, GF_Vec *p);\r
-/*!\brief closest point on a line\r
- *\r
- *Gets the closest point on a line from a given point in space\r
- *\param line_pt a point of the line to test\r
- *\param line_vec the normalized direction vector of the line\r
- *\param pt the point to check\r
- *\return the closest point on the line to the desired point\r
- */\r
-GF_Vec gf_closest_point_to_line(GF_Vec line_pt, GF_Vec line_vec, GF_Vec pt);\r
-/*!\brief box p-vertex index\r
- *\r
- *Gets the p-vertex index for a given plane. The p-vertex index is the index of the closest vertex of a bounding box to the plane. The vertices of a box are always \r
- *ordered in GPAC? cf \ref gf_bbox_get_vertices\r
- *\param p the plane to check\r
- *\return the p-vertex index value, ranging from 0 to 7\r
-*/\r
-u32 gf_plane_get_p_vertex_idx(GF_Plane *p);\r
-/*!\brief plane line intersection\r
- *\r
- *Checks for the intersection of a plane and a line\r
- *\param plane plane to test\r
- *\param linepoint a point on the line to test\r
- *\param linevec normalized direction vector of the line to test\r
- *\param outPoint optional pointer to retrieve the intersection point, NULL otherwise\r
- *\return 1 if line and plane intersect, 0 otherwise\r
-*/\r
-Bool gf_plane_intersect_line(GF_Plane *plane, GF_Vec *linepoint, GF_Vec *linevec, GF_Vec *outPoint);\r
-\r
-/*!Classification types for box/plane position used in \ref gf_bbox_plane_relation*/\r
-enum \r
-{ \r
- /*!box is in front of the plane*/\r
- GF_BBOX_FRONT,\r
- /*!box intersects the plane*/\r
- GF_BBOX_INTER,\r
- /*!box is back of the plane*/\r
- GF_BBOX_BACK\r
-};\r
-/*!\brief box-plane relation\r
- *\r
- *Gets the spatial relation between a box and a plane\r
- *\param box the box to check\r
- *\param p the plane to check\r
- *\return the relation type\r
- */\r
-u32 gf_bbox_plane_relation(GF_BBox *box, GF_Plane *p);\r
-\r
-/*!\brief 3D Ray\r
- *\r
- *The 3D ray object is used in GPAC for all collision and mouse interaction tests\r
-*/\r
-typedef struct\r
-{\r
- /*!origin point of the ray*/\r
- GF_Vec orig;\r
- /*!normalized direction vector of the ray*/\r
- GF_Vec dir;\r
-} GF_Ray;\r
-\r
-/*!\brief ray constructor\r
- *\r
- *Constructs a ray object\r
- *\param start starting point of the ray\r
- *\param end end point of the ray, or any point on the ray\r
- *\return the ray object\r
-*/\r
-GF_Ray gf_ray(GF_Vec start, GF_Vec end);\r
-/*!\brief matrix ray transformation\r
- *\r
- *Transforms a ray by a given transformation matrix\r
- *\param mx the matrix to use\r
- *\param r pointer to the ray. Once the function is called, contains the transformed ray\r
-*/\r
-void gf_mx_apply_ray(GF_Matrix *mx, GF_Ray *r);\r
-/*!\brief ray box intersection test\r
- *\r
- *Checks if a ray intersects a box or not\r
- *\param ray the ray to check\r
- *\param min_edge the minimum edge of the box to check\r
- *\param max_edge the maximum edge of the box to check\r
- *\param out_point optional location of a 3D point to store the intersection, NULL otherwise.\r
- *\return retuns 1 if the ray intersects the box, 0 otherwise\r
-*/\r
-Bool gf_ray_hit_box(GF_Ray *ray, GF_Vec min_edge, GF_Vec max_edge, GF_Vec *out_point);\r
-/*!\brief ray sphere intersection test\r
- *\r
- *Checks if a ray intersects a box or not\r
- *\param ray the ray to check\r
- *\param center the center of the sphere to check. If NULL, the origin (0,0,0)is used\r
- *\param radius the radius of the sphere to check\r
- *\param out_point optional location of a 3D point to store the intersection, NULL otherwise\r
- *\return retuns 1 if the ray intersects the sphere, 0 otherwise\r
-*/\r
-Bool gf_ray_hit_sphere(GF_Ray *ray, GF_Vec *center, Fixed radius, GF_Vec *out_point);\r
-/*!\brief ray triangle intersection test\r
- *\r
- *Checks if a ray intersects a triangle or not\r
- *\param ray the ray to check\r
- *\param v0 first vertex of the triangle\r
- *\param v1 second vertex of the triangle\r
- *\param v2 third vertex of the triangle\r
- *\param dist optional location of a fixed number to store the intersection distance from ray origin if any, NULL otherwise\r
- *\return retuns 1 if the ray intersects the triangle, 0 otherwise\r
-*/\r
-Bool gf_ray_hit_triangle(GF_Ray *ray, GF_Vec *v0, GF_Vec *v1, GF_Vec *v2, Fixed *dist);\r
-/*same as above and performs backface cull (solid meshes)*/\r
-/*!\brief ray triangle intersection test\r
- *\r
- *Checks if a ray intersects a triangle or not, performing backface culling. For parameters details, look at \ref gf_ray_hit_triangle_backcull\r
- */\r
-Bool gf_ray_hit_triangle_backcull(GF_Ray *ray, GF_Vec *v0, GF_Vec *v1, GF_Vec *v2, Fixed *dist);\r
-\r
-/*! @} */\r
-\r
-/*! @} */\r
-\r
-#ifdef __cplusplus\r
-}\r
-#endif\r
-\r
-\r
-#endif /*_GF_MATH_H_*/\r
-\r