2101 lines
43 KiB
C
2101 lines
43 KiB
C
#ifndef BH_MATH_H
|
|
#define BH_MATH_H
|
|
|
|
|
|
#include "common.h"
|
|
|
|
|
|
/**
|
|
* 2D floating point vector.
|
|
*/
|
|
typedef struct bh_point2f_s
|
|
{
|
|
/** X component */
|
|
float x;
|
|
|
|
/** Y Component */
|
|
float y;
|
|
} bh_point2f_t;
|
|
|
|
|
|
/**
|
|
* 3D floating point vector.
|
|
*/
|
|
typedef struct bh_point3f_s
|
|
{
|
|
/** X component */
|
|
float x;
|
|
|
|
/** Y component */
|
|
float y;
|
|
|
|
/** Z component */
|
|
float z;
|
|
} bh_point3f_t;
|
|
|
|
|
|
/**
|
|
* 4D floating point vector.
|
|
*/
|
|
typedef struct bh_point4f_s
|
|
{
|
|
/** X component */
|
|
float x;
|
|
|
|
/** Y component */
|
|
float y;
|
|
|
|
/** Z component */
|
|
float z;
|
|
|
|
/** W component */
|
|
float w;
|
|
} bh_point4f_t;
|
|
|
|
|
|
/**
|
|
* 2D integer vector.
|
|
*/
|
|
typedef struct bh_point2i_s
|
|
{
|
|
/** X component */
|
|
int x;
|
|
|
|
/** Y component */
|
|
int y;
|
|
} bh_point2i_t;
|
|
|
|
|
|
/**
|
|
* 3D integer vector.
|
|
*/
|
|
typedef struct bh_point3i_s
|
|
{
|
|
/** X component */
|
|
int x;
|
|
|
|
/** Y component */
|
|
int y;
|
|
|
|
/** Z component */
|
|
int z;
|
|
} bh_point3i_t;
|
|
|
|
|
|
/**
|
|
* 4D integer vector.
|
|
*/
|
|
typedef struct bh_point4i_s
|
|
{
|
|
/** X component */
|
|
int x;
|
|
|
|
/** Y component */
|
|
int y;
|
|
|
|
/** Z component */
|
|
int z;
|
|
|
|
/** W component */
|
|
int w;
|
|
} bh_point4i_t;
|
|
|
|
|
|
/**
|
|
* 3x3 floating point matrix.
|
|
*
|
|
* Each vector represent one column of the matrix.
|
|
*/
|
|
typedef struct bh_matrix3f_s
|
|
{
|
|
/** First column */
|
|
bh_point3f_t x;
|
|
|
|
/** Second column */
|
|
bh_point3f_t y;
|
|
|
|
/** Third colum */
|
|
bh_point3f_t z;
|
|
} bh_matrix3f_t;
|
|
|
|
|
|
/**
|
|
* 4x4 floating point matrix.
|
|
*
|
|
* Each vector represent one column of the matrix.
|
|
*/
|
|
typedef struct bh_matrix4f_s
|
|
{
|
|
/** First column */
|
|
bh_point4f_t x;
|
|
|
|
/** Second column */
|
|
bh_point4f_t y;
|
|
|
|
/** Third column */
|
|
bh_point4f_t z;
|
|
|
|
/** Forth column */
|
|
bh_point4f_t w;
|
|
} bh_matrix4f_t;
|
|
|
|
|
|
/**
|
|
* 2D floating point line.
|
|
*/
|
|
typedef struct bh_line2f_s
|
|
{
|
|
/** Normal vector */
|
|
bh_point2f_t normal;
|
|
|
|
/** Distance from the origin */
|
|
float distance;
|
|
} bh_line2f_t;
|
|
|
|
|
|
/**
|
|
* 3D floating point plane.
|
|
*/
|
|
typedef struct bh_plane3f_s
|
|
{
|
|
/** Normal vector */
|
|
bh_point3f_t normal;
|
|
|
|
/** Distance from the origin */
|
|
float distance;
|
|
} bh_plane3f_t;
|
|
|
|
|
|
/**
|
|
* 2D floating point ray.
|
|
*/
|
|
typedef struct bh_ray2f_s
|
|
{
|
|
/** Origin */
|
|
bh_point2f_t origin;
|
|
|
|
/** Normal or direction */
|
|
bh_point2f_t normal;
|
|
} bh_ray2f_t;
|
|
|
|
|
|
/**
|
|
* 3D floating point ray.
|
|
*/
|
|
typedef struct bh_ray3f_s
|
|
{
|
|
/** Origin */
|
|
bh_point3f_t origin;
|
|
|
|
/** Normal or direction */
|
|
bh_point3f_t normal;
|
|
} bh_ray3f_t;
|
|
|
|
|
|
/**
|
|
* 2D floating point AABB
|
|
*/
|
|
typedef struct bh_aabb2f_s
|
|
{
|
|
/** Origin */
|
|
bh_point2f_t origin;
|
|
|
|
/** Size */
|
|
bh_point2f_t size;
|
|
} bh_aabb2f_t;
|
|
|
|
|
|
/**
|
|
* 3D floating point AABB
|
|
*/
|
|
typedef struct bh_aabb3f_s
|
|
{
|
|
/** Origin */
|
|
bh_point3f_t origin;
|
|
|
|
/** Size */
|
|
bh_point3f_t size;
|
|
} bh_aabb3f_t;
|
|
|
|
|
|
/**
|
|
* 2D integer AABB
|
|
*/
|
|
typedef struct bh_aabb2i_s
|
|
{
|
|
/** Origin */
|
|
bh_point2i_t origin;
|
|
|
|
/** Size */
|
|
bh_point2i_t size;
|
|
} bh_aabb2i_t;
|
|
|
|
|
|
/**
|
|
* 3D integer AABB
|
|
*/
|
|
typedef struct bh_aabb3i_s
|
|
{
|
|
/** Origin */
|
|
bh_point3i_t origin;
|
|
|
|
/** Size */
|
|
bh_point3i_t size;
|
|
} bh_aabb3i_t;
|
|
|
|
|
|
/**
|
|
* Floating point quaternion
|
|
*/
|
|
typedef bh_point4f_t bh_quat_t;
|
|
|
|
|
|
/**
|
|
* Adds components of two vectors.
|
|
*
|
|
* result = a + b
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point4f_t *bh_point4f_add(const bh_point4f_t *a,
|
|
const bh_point4f_t *b,
|
|
bh_point4f_t *result);
|
|
|
|
|
|
/**
|
|
* Subtracts components of two vectors.
|
|
*
|
|
* result = a - b
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point4f_t *bh_point4f_sub(const bh_point4f_t *a,
|
|
const bh_point4f_t *b,
|
|
bh_point4f_t *result);
|
|
|
|
|
|
/**
|
|
* Multiplies components of two vectors.
|
|
*
|
|
* result = a * b
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point4f_t *bh_point4f_mul(const bh_point4f_t *a,
|
|
const bh_point4f_t *b,
|
|
bh_point4f_t *result);
|
|
|
|
|
|
/**
|
|
* Scales the vector.
|
|
*
|
|
* result = a * b
|
|
*
|
|
* \param a Value
|
|
* \param b Factor
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point4f_t *bh_point4f_scale(const bh_point4f_t *a,
|
|
float b,
|
|
bh_point4f_t *result);
|
|
|
|
|
|
/**
|
|
* Multiplies and adds three vectors.
|
|
*
|
|
* result = a * b + c
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param c Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point4f_t *bh_point4f_madd(const bh_point4f_t *a,
|
|
const bh_point4f_t *b,
|
|
const bh_point4f_t *c,
|
|
bh_point4f_t *result);
|
|
|
|
|
|
/**
|
|
* Negates the vector.
|
|
*
|
|
* result = -in
|
|
*
|
|
* \param in Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point4f_t *bh_point4f_negate(const bh_point4f_t *in,
|
|
bh_point4f_t *result);
|
|
|
|
|
|
/**
|
|
* Calculates the dot product of two vectors.
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
*
|
|
* \return Returns the dot product.
|
|
*/
|
|
float bh_point4f_dot(const bh_point4f_t *a,
|
|
const bh_point4f_t *b);
|
|
|
|
|
|
/**
|
|
* Calculates the dot product of two vectors with w component.
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
*
|
|
* \return Returns the dot product.
|
|
*/
|
|
float bh_point4f_dot3(const bh_point4f_t *a,
|
|
const bh_point4f_t *b);
|
|
|
|
|
|
/**
|
|
* Calculates the cross product of two vectors without w component.
|
|
*
|
|
* result = a x b
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point4f_t *bh_point4f_cross(const bh_point4f_t *a,
|
|
const bh_point4f_t *b,
|
|
bh_point4f_t *result);
|
|
|
|
|
|
/**
|
|
* Calculates the length of the vector.
|
|
*
|
|
* \param in Value
|
|
*
|
|
* \return Returns the length.
|
|
*/
|
|
float bh_point4f_length(const bh_point4f_t *in);
|
|
|
|
|
|
/**
|
|
* Normilizes the vector.
|
|
*
|
|
* result = in / |in|
|
|
*
|
|
* \param in Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point4f_t *bh_point4f_normal(const bh_point4f_t *in,
|
|
bh_point4f_t *result);
|
|
|
|
|
|
/**
|
|
* Calculates vector, containing minimum components of two vectors.
|
|
*
|
|
* result = min(a, b)
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point4f_t *bh_point4f_min(const bh_point4f_t *a,
|
|
const bh_point4f_t *b,
|
|
bh_point4f_t *result);
|
|
|
|
|
|
/**
|
|
* Calculates vector, containing maximum components of two vectors.
|
|
*
|
|
* result = max(a, b)
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point4f_t *bh_point4f_max(const bh_point4f_t *a,
|
|
const bh_point4f_t *b,
|
|
bh_point4f_t *result);
|
|
|
|
|
|
/**
|
|
* Calculates linear interpolation between two vectors.
|
|
*
|
|
* result = a + (b - a) * t
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param t Factor
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point4f_t *bh_point4f_lerp(const bh_point4f_t *a,
|
|
const bh_point4f_t *b,
|
|
float t,
|
|
bh_point4f_t *result);
|
|
|
|
|
|
/**
|
|
* Calculates spherical linear interpolation between two vectors.
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param t Factor
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point4f_t *bh_point4f_slerp(const bh_point4f_t *a,
|
|
const bh_point4f_t *b,
|
|
float t,
|
|
bh_point4f_t *result);
|
|
|
|
|
|
/**
|
|
* Adds components of two vectors.
|
|
*
|
|
* result = a + b
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point3f_t *bh_point3f_add(const bh_point3f_t *a,
|
|
const bh_point3f_t *b,
|
|
bh_point3f_t *result);
|
|
|
|
|
|
/**
|
|
* Subtracts components of two vectors.
|
|
*
|
|
* result = a - b
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point3f_t *bh_point3f_sub(const bh_point3f_t *a,
|
|
const bh_point3f_t *b,
|
|
bh_point3f_t *result);
|
|
|
|
|
|
/**
|
|
* Multiplies components of two vectors.
|
|
*
|
|
* result = a * b
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point3f_t *bh_point3f_mul(const bh_point3f_t *a,
|
|
const bh_point3f_t *b,
|
|
bh_point3f_t *result);
|
|
|
|
|
|
/**
|
|
* Scales the vector.
|
|
*
|
|
* result = a * b
|
|
*
|
|
* \param a Value
|
|
* \param b Factor
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point3f_t *bh_point3f_scale(const bh_point3f_t *a,
|
|
float b,
|
|
bh_point3f_t *result);
|
|
|
|
|
|
/**
|
|
* Multiplies and adds three vectors.
|
|
*
|
|
* result = a * b + c
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param c Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point3f_t *bh_point3f_madd(const bh_point3f_t *a,
|
|
const bh_point3f_t *b,
|
|
const bh_point3f_t *c,
|
|
bh_point3f_t *result);
|
|
|
|
|
|
/**
|
|
* Negates the vector.
|
|
*
|
|
* result = -in
|
|
*
|
|
* \param in Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point3f_t *bh_point3f_negate(const bh_point3f_t *in,
|
|
bh_point3f_t *result);
|
|
|
|
|
|
/**
|
|
* Calculates the dot product of two vectors.
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
*
|
|
* \return Returns the dot product.
|
|
*/
|
|
float bh_point3f_dot(const bh_point3f_t *a,
|
|
const bh_point3f_t *b);
|
|
|
|
|
|
/**
|
|
* Calculates the cross product of two vectors.
|
|
*
|
|
* result = a x b
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point3f_t *bh_point3f_cross(const bh_point3f_t *a,
|
|
const bh_point3f_t *b,
|
|
bh_point3f_t *result);
|
|
|
|
|
|
/**
|
|
* Calculates the length of the vector.
|
|
*
|
|
* \param in Value
|
|
*
|
|
* \return Returns the length.
|
|
*/
|
|
float bh_point3f_length(const bh_point3f_t *in);
|
|
|
|
|
|
/**
|
|
* Normilizes the vector.
|
|
*
|
|
* result = in / |in|
|
|
*
|
|
* \param in Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point3f_t *bh_point3f_normal(const bh_point3f_t *in,
|
|
bh_point3f_t *result);
|
|
|
|
|
|
/**
|
|
* Calculates vector, containing minimum components of two vectors.
|
|
*
|
|
* result = min(a, b)
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point3f_t *bh_point3f_min(const bh_point3f_t *a,
|
|
const bh_point3f_t *b,
|
|
bh_point3f_t *result);
|
|
|
|
|
|
/**
|
|
* Calculates vector, containing maximum components of two vectors.
|
|
*
|
|
* result = max(a, b)
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point3f_t *bh_point3f_max(const bh_point3f_t *a,
|
|
const bh_point3f_t *b,
|
|
bh_point3f_t *result);
|
|
|
|
|
|
/**
|
|
* Calculates linear interpolation between two vectors.
|
|
*
|
|
* result = a + (b - a) * t
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param t Factor
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point3f_t *bh_point3f_lerp(const bh_point3f_t *a,
|
|
const bh_point3f_t *b,
|
|
float t,
|
|
bh_point3f_t *result);
|
|
|
|
|
|
/**
|
|
* Calculates spherical linear interpolation between two vectors.
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param t Factor
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point3f_t *bh_point3f_slerp(const bh_point3f_t *a,
|
|
const bh_point3f_t *b,
|
|
float t,
|
|
bh_point3f_t *result);
|
|
|
|
|
|
/**
|
|
* Adds components of two vectors.
|
|
*
|
|
* result = a + b
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point2f_t *bh_point2f_add(const bh_point2f_t *a,
|
|
const bh_point2f_t *b,
|
|
bh_point2f_t *result);
|
|
|
|
|
|
/**
|
|
* Subtracts components of two vectors.
|
|
*
|
|
* result = a - b
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point2f_t *bh_point2f_sub(const bh_point2f_t *a,
|
|
const bh_point2f_t *b,
|
|
bh_point2f_t *result);
|
|
|
|
|
|
/**
|
|
* Multiplies components of two vectors.
|
|
*
|
|
* result = a * b
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point2f_t *bh_point2f_mul(const bh_point2f_t *a,
|
|
const bh_point2f_t *b,
|
|
bh_point2f_t *result);
|
|
|
|
|
|
/**
|
|
* Scales the vector.
|
|
*
|
|
* result = a * b
|
|
*
|
|
* \param a Value
|
|
* \param b Factor
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point2f_t *bh_point2f_scale(const bh_point2f_t *a,
|
|
float b,
|
|
bh_point2f_t *result);
|
|
|
|
|
|
/**
|
|
* Multiplies and adds three vectors.
|
|
*
|
|
* result = a * b + c
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param c Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point2f_t *bh_point2f_madd(const bh_point2f_t *a,
|
|
const bh_point2f_t *b,
|
|
const bh_point2f_t *c,
|
|
bh_point2f_t *result);
|
|
|
|
|
|
/**
|
|
* Negates the vector.
|
|
*
|
|
* result = -in
|
|
*
|
|
* \param in Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point2f_t *bh_point2f_negate(const bh_point2f_t *in,
|
|
bh_point2f_t *result);
|
|
|
|
|
|
/**
|
|
* Calculates the dot product of two vectors.
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
*
|
|
* \return Returns the dot product.
|
|
*/
|
|
float bh_point2f_dot(const bh_point2f_t *a,
|
|
const bh_point2f_t *b);
|
|
|
|
|
|
/**
|
|
* Calculates the cross product of two vectors and returns its z component.
|
|
*
|
|
* result = a x b
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
*
|
|
* \return Returns z component of the result vector.
|
|
*/
|
|
float bh_point2f_cross(const bh_point2f_t *a,
|
|
const bh_point2f_t *b);
|
|
|
|
|
|
/**
|
|
* Calculates the length of the vector.
|
|
*
|
|
* \param in Value
|
|
*
|
|
* \return Returns the length.
|
|
*/
|
|
float bh_point2f_length(const bh_point2f_t *in);
|
|
|
|
|
|
/**
|
|
* Normilizes the vector.
|
|
*
|
|
* result = in / |in|
|
|
*
|
|
* \param in Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point2f_t *bh_point2f_normal(const bh_point2f_t *in,
|
|
bh_point2f_t *result);
|
|
|
|
|
|
/**
|
|
* Calculates vector, containing minimum components of two vectors.
|
|
*
|
|
* result = min(a, b)
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point2f_t *bh_point2f_min(const bh_point2f_t *a,
|
|
const bh_point2f_t *b,
|
|
bh_point2f_t *result);
|
|
|
|
|
|
/**
|
|
* Calculates vector, containing maximum components of two vectors.
|
|
*
|
|
* result = max(a, b)
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point2f_t *bh_point2f_max(const bh_point2f_t *a,
|
|
const bh_point2f_t *b,
|
|
bh_point2f_t *result);
|
|
|
|
|
|
/**
|
|
* Calculates linear interpolation between two vectors.
|
|
*
|
|
* result = a + (b - a) * t
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param t Factor
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point2f_t *bh_point2f_lerp(const bh_point2f_t *a,
|
|
const bh_point2f_t *b,
|
|
float t,
|
|
bh_point2f_t *result);
|
|
|
|
|
|
/**
|
|
* Calculates spherical linear interpolation between two vectors.
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param t Factor
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point2f_t *bh_point2f_slerp(const bh_point2f_t *a,
|
|
const bh_point2f_t *b,
|
|
float t,
|
|
bh_point2f_t *result);
|
|
|
|
|
|
/**
|
|
* Adds components of two vectors.
|
|
*
|
|
* result = a + b
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point4i_t *bh_point4i_add(const bh_point4i_t *a,
|
|
const bh_point4i_t *b,
|
|
bh_point4i_t *result);
|
|
|
|
|
|
/**
|
|
* Subtracts components of two vectors.
|
|
*
|
|
* result = a - b
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point4i_t *bh_point4i_sub(const bh_point4i_t *a,
|
|
const bh_point4i_t *b,
|
|
bh_point4i_t *result);
|
|
|
|
|
|
/**
|
|
* Multiplies components of two vectors.
|
|
*
|
|
* result = a * b
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point4i_t *bh_point4i_mul(const bh_point4i_t *a,
|
|
const bh_point4i_t *b,
|
|
bh_point4i_t *result);
|
|
|
|
|
|
/**
|
|
* Scales the vector.
|
|
*
|
|
* result = a * b
|
|
*
|
|
* \param a Value
|
|
* \param b Factor
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point4i_t *bh_point4i_scale(const bh_point4i_t *a,
|
|
int b,
|
|
bh_point4i_t *result);
|
|
|
|
|
|
/**
|
|
* Multiplies and adds three vectors.
|
|
*
|
|
* result = a * b + c
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param c Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point4i_t *bh_point4i_madd(const bh_point4i_t *a,
|
|
const bh_point4i_t *b,
|
|
const bh_point4i_t *c,
|
|
bh_point4i_t *result);
|
|
|
|
|
|
/**
|
|
* Negates the vector.
|
|
*
|
|
* result = -in
|
|
*
|
|
* \param in Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point4i_t *bh_point4i_negate(const bh_point4i_t *in,
|
|
bh_point4i_t *result);
|
|
|
|
|
|
/**
|
|
* Calculates vector, containing minimum components of two vectors.
|
|
*
|
|
* result = min(a, b)
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point4i_t *bh_point4i_min(const bh_point4i_t *a,
|
|
const bh_point4i_t *b,
|
|
bh_point4i_t *result);
|
|
|
|
|
|
/**
|
|
* Calculates vector, containing maximum components of two vectors.
|
|
*
|
|
* result = max(a, b)
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point4i_t *bh_point4i_max(const bh_point4i_t *a,
|
|
const bh_point4i_t *b,
|
|
bh_point4i_t *result);
|
|
|
|
|
|
/**
|
|
* Calculates linear interpolation between two vectors.
|
|
*
|
|
* result = a + (b - a) * t
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param t Factor
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point4i_t *bh_point4i_lerp(const bh_point4i_t *a,
|
|
const bh_point4i_t *b,
|
|
float t,
|
|
bh_point4i_t *result);
|
|
|
|
|
|
/**
|
|
* Adds components of two vectors.
|
|
*
|
|
* result = a + b
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point3i_t *bh_point3i_add(const bh_point3i_t *a,
|
|
const bh_point3i_t *b,
|
|
bh_point3i_t *result);
|
|
|
|
|
|
/**
|
|
* Subtracts components of two vectors.
|
|
*
|
|
* result = a - b
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point3i_t *bh_point3i_sub(const bh_point3i_t *a,
|
|
const bh_point3i_t *b,
|
|
bh_point3i_t *result);
|
|
|
|
|
|
/**
|
|
* Multiplies components of two vectors.
|
|
*
|
|
* result = a * b
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point3i_t *bh_point3i_mul(const bh_point3i_t *a,
|
|
const bh_point3i_t *b,
|
|
bh_point3i_t *result);
|
|
|
|
|
|
/**
|
|
* Scales the vector.
|
|
*
|
|
* result = a * b
|
|
*
|
|
* \param a Value
|
|
* \param b Factor
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point3i_t *bh_point3i_scale(const bh_point3i_t *a,
|
|
int b,
|
|
bh_point3i_t *result);
|
|
|
|
|
|
/**
|
|
* Multiplies and adds three vectors.
|
|
*
|
|
* result = a * b + c
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param c Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point3i_t *bh_point3i_madd(const bh_point3i_t *a,
|
|
const bh_point3i_t *b,
|
|
const bh_point3i_t *c,
|
|
bh_point3i_t *result);
|
|
|
|
|
|
/**
|
|
* Negates the vector.
|
|
*
|
|
* result = -in
|
|
*
|
|
* \param in Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point3i_t *bh_point3i_negate(const bh_point3i_t *in,
|
|
bh_point3i_t *result);
|
|
|
|
|
|
/**
|
|
* Calculates vector, containing minimum components of two vectors.
|
|
*
|
|
* result = min(a, b)
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point3i_t *bh_point3i_min(const bh_point3i_t *a,
|
|
const bh_point3i_t *b,
|
|
bh_point3i_t *result);
|
|
|
|
|
|
/**
|
|
* Calculates vector, containing maximum components of two vectors.
|
|
*
|
|
* result = max(a, b)
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point3i_t *bh_point3i_max(const bh_point3i_t *a,
|
|
const bh_point3i_t *b,
|
|
bh_point3i_t *result);
|
|
|
|
|
|
/**
|
|
* Calculates linear interpolation between two vectors.
|
|
*
|
|
* result = a + (b - a) * t
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param t Factor
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point3i_t *bh_point3i_lerp(const bh_point3i_t *a,
|
|
const bh_point3i_t *b,
|
|
float t,
|
|
bh_point3i_t *result);
|
|
|
|
|
|
/**
|
|
* Adds components of two vectors.
|
|
*
|
|
* result = a + b
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point2i_t *bh_point2i_add(const bh_point2i_t *a,
|
|
const bh_point2i_t *b,
|
|
bh_point2i_t *result);
|
|
|
|
|
|
/**
|
|
* Subtracts components of two vectors.
|
|
*
|
|
* result = a - b
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point2i_t *bh_point2i_sub(const bh_point2i_t *a,
|
|
const bh_point2i_t *b,
|
|
bh_point2i_t *result);
|
|
|
|
|
|
/**
|
|
* Multiplies components of two vectors.
|
|
*
|
|
* result = a * b
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point2i_t *bh_point2i_mul(const bh_point2i_t *a,
|
|
const bh_point2i_t *b,
|
|
bh_point2i_t *result);
|
|
|
|
|
|
/**
|
|
* Scales the vector.
|
|
*
|
|
* result = a * b
|
|
*
|
|
* \param a Value
|
|
* \param b Factor
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point2i_t *bh_point2i_scale(const bh_point2i_t *a,
|
|
int b,
|
|
bh_point2i_t *result);
|
|
|
|
|
|
/**
|
|
* Multiplies and adds three vectors.
|
|
*
|
|
* result = a * b + c
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param c Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point2i_t *bh_point2i_madd(const bh_point2i_t *a,
|
|
const bh_point2i_t *b,
|
|
const bh_point2i_t *c,
|
|
bh_point2i_t *result);
|
|
|
|
|
|
/**
|
|
* Negates the vector.
|
|
*
|
|
* result = -in
|
|
*
|
|
* \param in Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point2i_t *bh_point2i_negate(const bh_point2i_t *in,
|
|
bh_point2i_t *result);
|
|
|
|
|
|
/**
|
|
* Calculates vector, containing minimum components of two vectors.
|
|
*
|
|
* result = min(a, b)
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point2i_t *bh_point2i_min(const bh_point2i_t *a,
|
|
const bh_point2i_t *b,
|
|
bh_point2i_t *result);
|
|
|
|
|
|
/**
|
|
* Calculates vector, containing maximum components of two vectors.
|
|
*
|
|
* result = max(a, b)
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point2i_t *bh_point2i_max(const bh_point2i_t *a,
|
|
const bh_point2i_t *b,
|
|
bh_point2i_t *result);
|
|
|
|
|
|
/**
|
|
* Calculates linear interpolation between two vectors.
|
|
*
|
|
* result = a + (b - a) * t
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param t Factor
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point2i_t *bh_point2i_lerp(const bh_point2i_t *a,
|
|
const bh_point2i_t *b,
|
|
float t,
|
|
bh_point2i_t *result);
|
|
|
|
|
|
/**
|
|
* Adds components of two quaternions.
|
|
*
|
|
* result = a + b
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
#define bh_quat_add bh_point4f_add
|
|
|
|
|
|
/**
|
|
* Subtracts components of two quaternions.
|
|
*
|
|
* result = a - b
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
#define bh_quat_sub bh_point4f_sub
|
|
|
|
|
|
/**
|
|
* Scales the quaternion.
|
|
*
|
|
* result = a * b
|
|
*
|
|
* \param a Value
|
|
* \param b Factor
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
#define bh_quat_scale bh_point4f_scale
|
|
|
|
|
|
/**
|
|
* Negates the quaternion.
|
|
*
|
|
* result = -in
|
|
*
|
|
* \param in Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
#define bh_quat_negate bh_point4f_negate
|
|
|
|
|
|
/**
|
|
* Calculates the dot product of two quaternions.
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
*
|
|
* \return Returns the dot product.
|
|
*/
|
|
#define bh_quat_dot bh_point4f_dot
|
|
|
|
|
|
/**
|
|
* Calculates the length of the quaternion.
|
|
*
|
|
* \param in Value
|
|
*
|
|
* \return Returns the length.
|
|
*/
|
|
#define bh_quat_length bh_point4f_length
|
|
|
|
|
|
/**
|
|
* Normilizes the quaternion.
|
|
*
|
|
* result = in / |in|
|
|
*
|
|
* \param in Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
#define bh_quat_normal bh_point4f_normal
|
|
|
|
|
|
/**
|
|
* Calculates linear interpolation between two quaternions.
|
|
*
|
|
* result = a + (b - a) * t
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param t Factor
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
#define bh_quat_lerp bh_point4f_lerp
|
|
|
|
|
|
/**
|
|
* Calculates spherical linear interpolation between two quaternions.
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param t Factor
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
#define bh_quat_slerp bh_point4f_slerp
|
|
|
|
|
|
/**
|
|
* Sets quaternions to identity.
|
|
*
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_quat_t *bh_quat_identity(bh_quat_t *result);
|
|
|
|
|
|
/**
|
|
* Conjugates the quaternion.
|
|
*
|
|
* result = (-in.x, -in.y, -in.z, in.w)
|
|
*
|
|
* \param in Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_quat_t *bh_quat_conjugate(const bh_quat_t *in,
|
|
bh_quat_t *result);
|
|
|
|
|
|
/**
|
|
* Calculates the inverse of the quaternion.
|
|
*
|
|
* \param in Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_quat_t *bh_quat_inverse(const bh_quat_t *in,
|
|
bh_quat_t *result);
|
|
|
|
|
|
/**
|
|
* Multiplies two quaternions.
|
|
*
|
|
* result = a * b
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_quat_t *bh_quat_mul(const bh_quat_t *a,
|
|
const bh_quat_t *b,
|
|
bh_quat_t *result);
|
|
|
|
|
|
/**
|
|
* Sets quaternion from euler angles (roll, pitch, yaw).
|
|
*
|
|
* Order of the rotation is ZYX (yaw, pitch, roll).
|
|
*
|
|
* \param roll Roll
|
|
* \param pitch Pitch
|
|
* \param yaw Yaw
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_quat_t *bh_quat_set_euler(float roll,
|
|
float pitch,
|
|
float yaw,
|
|
bh_quat_t *result);
|
|
|
|
|
|
/**
|
|
* Sets quaternion from axis of rotation and angle.
|
|
*
|
|
* \param axis Axis
|
|
* \param angle Angle
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_quat_t *bh_quat_set_rotation(const bh_point3f_t *axis,
|
|
float angle,
|
|
bh_quat_t *result);
|
|
|
|
|
|
/**
|
|
* Calculates euler angles (roll, pitch, yaw) from quaternion.
|
|
*
|
|
* Order of the rotation is ZYX (yaw, pitch, roll).
|
|
*
|
|
* \param in Value
|
|
* \param roll Roll
|
|
* \param pitch Pitch
|
|
* \param yaw Yaw
|
|
*/
|
|
void bh_quat_euler(const bh_quat_t *in,
|
|
float *roll,
|
|
float *pitch,
|
|
float *yaw);
|
|
|
|
|
|
/**
|
|
* Calculates axis of rotation and angle from quaternion.
|
|
*
|
|
* \param in Value
|
|
* \param axis Axis
|
|
* \param angle Angle
|
|
*/
|
|
void bh_quat_rotation(const bh_quat_t *in,
|
|
bh_point3f_t *axis,
|
|
float *angle);
|
|
|
|
|
|
/**
|
|
* Calculates rotation matrix from quaternion.
|
|
*
|
|
* \param in Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_matrix4f_t *bh_quat_matrix(const bh_quat_t *in,
|
|
bh_matrix4f_t *result);
|
|
|
|
|
|
/**
|
|
* Sets matrix to identity.
|
|
*
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_matrix4f_t *bh_matrix4f_identity(bh_matrix4f_t *result);
|
|
|
|
|
|
/**
|
|
* Adds two matricies.
|
|
*
|
|
* result = a + b
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_matrix4f_t *bh_matrix4f_add(const bh_matrix4f_t *a,
|
|
const bh_matrix4f_t *b,
|
|
bh_matrix4f_t *result);
|
|
|
|
|
|
/**
|
|
* Subtracts two matricies.
|
|
*
|
|
* result = a - b
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_matrix4f_t *bh_matrix4f_sub(const bh_matrix4f_t *a,
|
|
const bh_matrix4f_t *b,
|
|
bh_matrix4f_t *result);
|
|
|
|
|
|
/**
|
|
* Multiplies two matricies.
|
|
*
|
|
* result = a * b
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_matrix4f_t *bh_matrix4f_mul(const bh_matrix4f_t *a,
|
|
const bh_matrix4f_t *b,
|
|
bh_matrix4f_t *result);
|
|
|
|
|
|
/**
|
|
* Scales the matrix.
|
|
*
|
|
* result = a * b
|
|
*
|
|
* \param a Value
|
|
* \param b Factor
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_matrix4f_t *bh_matrix4f_scale(const bh_matrix4f_t *a,
|
|
float b,
|
|
bh_matrix4f_t *result);
|
|
|
|
|
|
/**
|
|
* Transposes the matrix.
|
|
*
|
|
* result = a^T
|
|
*
|
|
* \param in Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_matrix4f_t *bh_matrix4f_transpose(const bh_matrix4f_t *in,
|
|
bh_matrix4f_t *result);
|
|
|
|
|
|
/**
|
|
* Calculates the trace of the matrix.
|
|
*
|
|
* \param in Value
|
|
*
|
|
* \return Returns trace value.
|
|
*/
|
|
float bh_matrix4f_trace(const bh_matrix4f_t *in);
|
|
|
|
|
|
/**
|
|
* Calculates the determinant of the matrix.
|
|
*
|
|
* \param in Value
|
|
*
|
|
* \return Returns determinant value.
|
|
*/
|
|
float bh_matrix4f_determinant(const bh_matrix4f_t *in);
|
|
|
|
|
|
/**
|
|
* Calculates the inverse of the matrix.
|
|
*
|
|
* If matrix has no inverse - identity matrix will be returned.
|
|
*
|
|
* result = in^-1
|
|
*
|
|
* \param in Value
|
|
* \param result Result
|
|
*
|
|
* \return On success, returns inverse of the matrix.
|
|
* \return On failure, returns identity matrix.
|
|
*/
|
|
bh_matrix4f_t *bh_matrix4f_inverse(const bh_matrix4f_t *in,
|
|
bh_matrix4f_t *result);
|
|
|
|
|
|
/**
|
|
* Calculates scaling matrix.
|
|
*
|
|
* \param x X scale
|
|
* \param y Y scale
|
|
* \param z Z scale
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_matrix4f_t *bh_matrix4f_scaling(float x,
|
|
float y,
|
|
float z,
|
|
bh_matrix4f_t *result);
|
|
|
|
|
|
/**
|
|
* Calculates translation matrix.
|
|
*
|
|
* \param x X scale
|
|
* \param y Y scale
|
|
* \param z Z scale
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_matrix4f_t *bh_matrix4f_translation(float x,
|
|
float y,
|
|
float z,
|
|
bh_matrix4f_t *result);
|
|
|
|
|
|
/**
|
|
* Calculates x-rotation matrix (or rotation around x axis).
|
|
*
|
|
* \param angle Angle
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_matrix4f_t *bh_matrix4f_rotation_x(float angle,
|
|
bh_matrix4f_t *result);
|
|
|
|
|
|
/**
|
|
* Calculates y-rotation matrix (or rotation around y axis).
|
|
*
|
|
* \param angle Angle
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_matrix4f_t *bh_matrix4f_rotation_y(float angle,
|
|
bh_matrix4f_t *result);
|
|
|
|
|
|
/**
|
|
* Calculates z-rotation matrix (or rotation around z axis).
|
|
*
|
|
* \param angle Angle
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_matrix4f_t *bh_matrix4f_rotation_z(float angle,
|
|
bh_matrix4f_t *result);
|
|
|
|
|
|
/**
|
|
* Calculates rotation matrix around axis.
|
|
*
|
|
* \param axis Axis
|
|
* \param angle Angle
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_matrix4f_t *bh_matrix4f_rotation(const bh_point3f_t *axis,
|
|
float angle,
|
|
bh_matrix4f_t *result);
|
|
|
|
|
|
/**
|
|
* Calculates rotation matrix from euler angles (roll, pitch, yaw).
|
|
*
|
|
* Order of the rotation is ZYX (yaw, pitch, roll).
|
|
*
|
|
* \param roll Roll
|
|
* \param pitch Pitch
|
|
* \param yaw Yaw
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_matrix4f_t *bh_matrix4f_rotation_euler(float roll,
|
|
float pitch,
|
|
float yaw,
|
|
bh_matrix4f_t *result);
|
|
|
|
|
|
/**
|
|
* Calculates rotation matrix from quaternion.
|
|
*
|
|
* \param rotation Quaternion
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_matrix4f_t *bh_matrix4f_rotation_quat(bh_quat_t *rotation,
|
|
bh_matrix4f_t *result);
|
|
|
|
|
|
/**
|
|
* Calculates orthographic projection matrix.
|
|
*
|
|
* \param x_min Min x
|
|
* \param x_max Max x
|
|
* \param y_min Min y
|
|
* \param y_max Max y
|
|
* \param z_min Min z
|
|
* \param z_max Max z
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_matrix4f_t *bh_matrix4f_ortho(float x_min,
|
|
float x_max,
|
|
float y_min,
|
|
float y_max,
|
|
float z_min,
|
|
float z_max,
|
|
bh_matrix4f_t *result);
|
|
|
|
|
|
/**
|
|
* Calculates perspective projection matrix.
|
|
*
|
|
* \param fov Field of view
|
|
* \param aspect Aspect ratio
|
|
* \param z_min Min z
|
|
* \param z_max Max z
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_matrix4f_t *bh_matrix4f_perspective(float fov,
|
|
float aspect,
|
|
float z_min,
|
|
float z_max,
|
|
bh_matrix4f_t *result);
|
|
|
|
|
|
/**
|
|
* Calculates camera view matrix.
|
|
*
|
|
* \param camera Position
|
|
* \param at Target
|
|
* \param up Up
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_matrix4f_t *bh_matrix4f_lookat(const bh_point3f_t *camera,
|
|
const bh_point3f_t *at,
|
|
const bh_point3f_t *up,
|
|
bh_matrix4f_t *result);
|
|
|
|
|
|
/**
|
|
* Applies matrix to vector.
|
|
*
|
|
* \param a Matrix
|
|
* \param b Vector
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point3f_t *bh_matrix4f_transform_point3f(const bh_matrix4f_t *a,
|
|
const bh_point3f_t *b,
|
|
bh_point3f_t *result);
|
|
|
|
|
|
/**
|
|
* Applies matrix to vector.
|
|
*
|
|
* \param a Matrix
|
|
* \param b Vector
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point4f_t *bh_matrix4f_transform_point4f(const bh_matrix4f_t *a,
|
|
const bh_point4f_t *b,
|
|
bh_point4f_t *result);
|
|
|
|
|
|
/**
|
|
* Sets matrix to identity.
|
|
*
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_matrix3f_t *bh_matrix3f_identity(bh_matrix3f_t *result);
|
|
|
|
|
|
/**
|
|
* Adds two matricies.
|
|
*
|
|
* result = a + b
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_matrix3f_t *bh_matrix3f_add(const bh_matrix3f_t *a,
|
|
const bh_matrix3f_t *b,
|
|
bh_matrix3f_t *result);
|
|
|
|
|
|
/**
|
|
* Subtracts two matricies.
|
|
*
|
|
* result = a - b
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_matrix3f_t *bh_matrix3f_sub(const bh_matrix3f_t *a,
|
|
const bh_matrix3f_t *b,
|
|
bh_matrix3f_t *result);
|
|
|
|
|
|
/**
|
|
* Multiplies two matricies.
|
|
*
|
|
* result = a * b
|
|
*
|
|
* \param a Value
|
|
* \param b Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_matrix3f_t *bh_matrix3f_mul(const bh_matrix3f_t *a,
|
|
const bh_matrix3f_t *b,
|
|
bh_matrix3f_t *result);
|
|
|
|
|
|
/**
|
|
* Scales the matrix.
|
|
*
|
|
* result = a * b
|
|
*
|
|
* \param a Value
|
|
* \param b Factor
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_matrix3f_t *bh_matrix3f_scale(const bh_matrix3f_t *a,
|
|
float b,
|
|
bh_matrix3f_t *result);
|
|
|
|
|
|
/**
|
|
* Transposes the matrix.
|
|
*
|
|
* result = a^T
|
|
*
|
|
* \param in Value
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_matrix3f_t *bh_matrix3f_transpose(const bh_matrix3f_t *in,
|
|
bh_matrix3f_t *result);
|
|
|
|
|
|
/**
|
|
* Calculates the trace of the matrix.
|
|
*
|
|
* \param in Value
|
|
*
|
|
* \return Returns trace value.
|
|
*/
|
|
float bh_matrix3f_trace(const bh_matrix3f_t *in);
|
|
|
|
|
|
/**
|
|
* Calculates the determinant of the matrix.
|
|
*
|
|
* \param in Value
|
|
*
|
|
* \return Returns determinant value.
|
|
*/
|
|
float bh_matrix3f_determinant(const bh_matrix3f_t *in);
|
|
|
|
|
|
/**
|
|
* Calculates the inverse of the matrix.
|
|
*
|
|
* If matrix has no inverse - identity matrix will be returned.
|
|
*
|
|
* result = in^-1
|
|
*
|
|
* \param in Value
|
|
* \param result Result
|
|
*
|
|
* \return On success, returns inverse of the matrix.
|
|
* \return On failure, returns identity matrix.
|
|
*/
|
|
bh_matrix3f_t *bh_matrix3f_inverse(const bh_matrix3f_t *in,
|
|
bh_matrix3f_t *result);
|
|
|
|
|
|
/**
|
|
* Calculates scaling matrix.
|
|
*
|
|
* \param x X scale
|
|
* \param y Y scale
|
|
* \param z Z scale
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_matrix3f_t *bh_matrix3f_scaling(float x,
|
|
float y,
|
|
bh_matrix3f_t *result);
|
|
|
|
|
|
/**
|
|
* Calculates translation matrix.
|
|
*
|
|
* \param x X scale
|
|
* \param y Y scale
|
|
* \param z Z scale
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_matrix3f_t *bh_matrix3f_translation(float x,
|
|
float y,
|
|
bh_matrix3f_t *result);
|
|
|
|
|
|
/**
|
|
* Calculates rotation matrix.
|
|
*
|
|
* \param angle Angle
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_matrix3f_t *bh_matrix3f_rotation(float angle,
|
|
bh_matrix3f_t *result);
|
|
|
|
|
|
/**
|
|
* Applies matrix to vector.
|
|
*
|
|
* \param a Matrix
|
|
* \param b Vector
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point2f_t *bh_matrix3f_transform_point2f(const bh_matrix3f_t *a,
|
|
const bh_point2f_t *b,
|
|
bh_point2f_t *result);
|
|
|
|
|
|
/**
|
|
* Applies matrix to vector.
|
|
*
|
|
* \param a Matrix
|
|
* \param b Vector
|
|
* \param result Result
|
|
*
|
|
* \return Returns pointer to the result.
|
|
*/
|
|
bh_point3f_t *bh_matrix3f_transform_point3f(const bh_matrix3f_t *a,
|
|
const bh_point3f_t *b,
|
|
bh_point3f_t *result);
|
|
|
|
|
|
#endif /* BH_MATH_H */
|