View lcov test coverage results on http://www.ufoot.org/liquidwar/v6/doc/coverage/src/lib/mat/index.html.

- Function:
*void***lw6mat_dmat2_zero***(lw6mat_dmat2_t **`dmat2`) `dmat2`: the matrix to initialize.Fills the matrix with zeros, regardless of what was there before. Internally, does a memset the only advantage is that this function should use the right sizeof and therefore avoids typo errors.

**Return value:**none.

- Function:
*void***lw6mat_dmat2_identity***(lw6mat_dmat2_t **`dmat2`) `dmat2`: the matrix to initialize.Loads the matrix with the identity matrix, that is, zero everywhere but one on the main diag.

**Return value:**none.

- Function:
*void***lw6mat_dmat2_translation***(lw6mat_dmat2_t **`dmat2`, double`d`) `dmat2`: the matrix to initialize.`d`: value which defines the translation.Loads the matrix with a translation transformation matrix. By multiplicating by this matrix, a translation is done.

**Return value:**none.

- Function:
*void***lw6mat_dmat2_scale***(lw6mat_dmat2_t **`dmat2`, double`d`) `dmat2`: the matrix to initialize.`d`: value used to scale matrix.Loads the matrix with a scale matrix. By multiplicating by this matrix, a scaling is done.

**Return value:**none.

- Function:
*int***lw6mat_dmat2_is_same***(const lw6mat_dmat2_t **`dmat2_a`, const lw6mat_dmat2_t *`dmat2_b`) `dmat2_a`: 1st matrix to compare`dmat2_b`: 2nd matrix to compareCompares two matrix, returns true if they are equal.

**Return value:**1 if equal, 0 if different.

- Function:
*void***lw6mat_dmat2_transpose***(lw6mat_dmat2_t **`dmat2`) `dmat2`: the matrix to transposeTransposes the matrix, that is, inverts rows and columns.

**Return value:**none.

- Function:
*double***lw6mat_dmat2_det***(const lw6mat_dmat2_t **`dmat2`) `dmat2`: the matrix used to calculate the determinantCalulates the determinant of the matrix.

**Return value:**the determinant.

- Function:
*void***lw6mat_dmat2_mul_scale***(lw6mat_dmat2_t **`dmat2`, double`f`) `dmat2`: matrix to modify`f`: scale factorScales the matrix by multiplying all its members by a scalar value.

**Return value:**none

- Function:
*int***lw6mat_dmat2_inv***(lw6sys_context_t **`sys_context`, lw6mat_dmat2_t *`dmat2_dst`, const lw6mat_dmat2_t *`dmat2_src`) `sys_context`: global system context`dmat2_dst`: the matrix inverted`dmat2_src`: the matrix to invertInverts a matrix. Probably not the fastest implementation, but should work in all cases. Use hardware accelerated API such as OpenGL on dedicated hardware if you want power.

**Return value:**1 if inverted, 0 if error, typically if determinant was 0, matrix can not be inverted.

- Function:
*void***lw6mat_dmat2_mul_dmat2***(lw6mat_dmat2_t **`dmat2`, const lw6mat_dmat2_t *`dmat2_a`, const lw6mat_dmat2_t *`dmat2_b`) `dmat2`: the result matrix`dmat2_a`: the 1st matrix to multiply, on the left`dmat2_b`: the 2nd matrix to multiply, on the rightClassic matrix multiplication.

**Return value:**none.

- Function:
*void***lw6mat_dmat2_mul_dvec2***(lw6mat_dvec2_t **`dvec2_dst`, const lw6mat_dmat2_t *`dmat2`, const lw6mat_dvec2_t *`dvec2_src`) `dvec2_dst`: the result vector`dvec2_src`: the source vectorMultiplication of matrix by vector. The result is a vector, the convention used is that of OpenGL, matrix are column major and vector are columns, that is, should you do it on a paper, vector is placed vertically, on the right of matrix. The other multiplication is not implemented, transposing the matrix will do it the other way if you wish.

**Return value:**none.

- Function:
*char ****lw6mat_dmat2_repr***(lw6sys_context_t **`sys_context`, const lw6mat_dmat2_t *`dmat2`) `sys_context`: global system contextGives a readable version of the matrix, the representation uses newlines, with a different line for each row

**Return value:**newly allocated string

- Function:
*void***lw6mat_dmat3_zero***(lw6mat_dmat3_t **`dmat3`) `dmat3`: the matrix to initialize.Fills the matrix with zeros, regardless of what was there before. Internally, does a memset the only advantage is that this function should use the right sizeof and therefore avoids typo errors.

**Return value:**none.

- Function:
*void***lw6mat_dmat3_identity***(lw6mat_dmat3_t **`dmat3`) `dmat3`: the matrix to initialize.Loads the matrix with the identity matrix, that is, zero everywhere but one on the main diag.

**Return value:**none.

- Function:
*void***lw6mat_dmat3_translation***(lw6mat_dmat3_t **`dmat3`, const lw6mat_dvec2_t *`dvec2`) `dmat3`: the matrix to initialize.`dvec2`: vector which defines the translation.Loads the matrix with a translation transformation matrix. By multiplicating by this matrix, a translation is done.

**Return value:**none.

- Function:
*void***lw6mat_dmat3_scale***(lw6mat_dmat3_t **`dmat3`, const lw6mat_dvec2_t *`dvec2`) `dmat3`: the matrix to initialize.`dvec2`: value used to scale matrix.Loads the matrix with a scale matrix. By multiplicating by this matrix, a scaling is done.

**Return value:**none.

- Function:
*void***lw6mat_dmat3_rot***(lw6mat_dmat3_t **`dmat3`, double`r`) `dmat3`: the matrix to initialize.`r`: value used to for the rotation, angle in radians.Loads the matrix with a rotation matrix. By multiplicating by this matrix, a rotation is done, over a virtual Z axis such as Z is the cross product of X and Y.

**Return value:**none.

- Function:
*int***lw6mat_dmat3_is_same***(const lw6mat_dmat3_t **`dmat3_a`, const lw6mat_dmat3_t *`dmat3_b`) `dmat3_a`: 1st matrix to compare`dmat3_b`: 2nd matrix to compareCompares two matrix, returns true if they are equal.

**Return value:**1 if equal, 0 if different.

- Function:
*void***lw6mat_dmat3_transpose***(lw6mat_dmat3_t **`dmat3`) `dmat3`: the matrix to transposeTransposes the matrix, that is, inverts rows and columns.

**Return value:**none.

- Function:
*double***lw6mat_dmat3_det***(const lw6mat_dmat3_t **`dmat3`) `dmat3`: the matrix used to calculate the determinantCalulates the determinant of the matrix.

**Return value:**the determinant.

- Function:
*void***lw6mat_dmat3_mul_scale***(lw6mat_dmat3_t **`dmat3`, double`f`) `dmat3`: matrix to modify`f`: scale factorScales the matrix by multiplying all its members by a scalar value.

**Return value:**none

- Function:
*int***lw6mat_dmat3_inv***(lw6sys_context_t **`sys_context`, lw6mat_dmat3_t *`dmat3_dst`, const lw6mat_dmat3_t *`dmat3_src`) `sys_context`: global system context`dmat3_dst`: the matrix inverted`dmat3_src`: the matrix to invertInverts a matrix. Probably not the fastest implementation, but should work in all cases. Use hardware accelerated API such as OpenGL on dedicated hardware if you want power.

**Return value:**1 if inverted, 0 if error, typically if determinant was 0, matrix can not be inverted.

- Function:
*void***lw6mat_dmat3_mul_dmat3***(lw6mat_dmat3_t **`dmat3`, const lw6mat_dmat3_t *`dmat3_a`, const lw6mat_dmat3_t *`dmat3_b`) `dmat3`: the result matrix`dmat3_a`: the 1st matrix to multiply, on the left`dmat3_b`: the 2nd matrix to multiply, on the rightClassic matrix multiplication.

**Return value:**none.

- Function:
*void***lw6mat_dmat3_mul_dvec3***(lw6mat_dvec3_t **`dvec3_dst`, const lw6mat_dmat3_t *`dmat3`, const lw6mat_dvec3_t *`dvec3_src`) `dvec3_dst`: the result vector`dvec3_src`: the source vectorMultiplication of matrix by vector. The result is a vector, the convention used is that of OpenGL, matrix are column major and vector are columns, that is, should you do it on a paper, vector is placed vertically, on the right of matrix. The other multiplication is not implemented, transposing the matrix will do it the other way if you wish.

**Return value:**none.

- Function:
*void***lw6mat_dmat3_mul_dvec2***(lw6mat_dvec2_t **`dvec2_dst`, const lw6mat_dmat3_t *`dmat3`, const lw6mat_dvec2_t *`dvec2_src`) `dvec2_dst`: the result vectorMultiplication of matrix by vector. The result is a vector, the convention used is that of OpenGL, matrix are column major and vector are columns, that is, should you do it on a paper, vector is placed vertically, on the right of matrix. The other multiplication is not implemented, transposing the matrix will do it the other way if you wish. The vector, here, is smaller than the matrix, the last element is supposed to be 1, this is how one implements translation through multiplication.

**Return value:**none.

- Function:
*char ****lw6mat_dmat3_repr***(lw6sys_context_t **`sys_context`, const lw6mat_dmat3_t *`dmat3`) `sys_context`: global system contextGives a readable version of the matrix, the representation uses newlines, with a different line for each row

**Return value:**newly allocated string

- Function:
*void***lw6mat_dmat4_zero***(lw6mat_dmat4_t **`dmat4`) `dmat4`: the matrix to initialize.Fills the matrix with zeros, regardless of what was there before. Internally, does a memset the only advantage is that this function should use the right sizeof and therefore avoids typo errors.

**Return value:**none.

- Function:
*void***lw6mat_dmat4_identity***(lw6mat_dmat4_t **`dmat4`) `dmat4`: the matrix to initialize.Loads the matrix with the identity matrix, that is, zero everywhere but one on the main diag.

**Return value:**none.

- Function:
*void***lw6mat_dmat4_translation***(lw6mat_dmat4_t **`dmat4`, const lw6mat_dvec3_t *`dvec3`) `dmat4`: the matrix to initialize.`dvec3`: vector which defines the translation.Loads the matrix with a translation transformation matrix. By multiplicating by this matrix, a translation is done.

**Return value:**none.

- Function:
*void***lw6mat_dmat4_scale***(lw6mat_dmat4_t **`dmat4`, const lw6mat_dvec3_t *`dvec3`) `dmat4`: the matrix to initialize.`dvec3`: value used to scale matrix.Loads the matrix with a scale matrix. By multiplicating by this matrix, a scaling is done.

**Return value:**none.

- Function:
*void***lw6mat_dmat4_rot_x***(lw6mat_dmat4_t **`dmat4`, double`r`) `dmat4`: the matrix to initialize.`r`: value used to for the rotation, angle in radians.Loads the matrix with a rotation matrix. By multiplicating by this matrix, a rotation is done, over the X axis.

**Return value:**none.

- Function:
*void***lw6mat_dmat4_rot_y***(lw6mat_dmat4_t **`dmat4`, double`r`) `dmat4`: the matrix to initialize.`r`: value used to for the rotation, angle in radians.Loads the matrix with a rotation matrix. By multiplicating by this matrix, a rotation is done, over the Y axis.

**Return value:**none.

- Function:
*void***lw6mat_dmat4_rot_z***(lw6mat_dmat4_t **`dmat4`, double`r`) `dmat4`: the matrix to initialize.`r`: value used to for the rotation, angle in radians.Loads the matrix with a rotation matrix. By multiplicating by this matrix, a rotation is done, over the Z axis.

**Return value:**none.

- Function:
*void***lw6mat_dmat4_ortho***(lw6mat_dmat4_t **`dmat4`, double`left`, double`right`, double`bottom`, double`top`, double`nearval`, double`farval`) `dmat4`: the matrix to initialize.`left`: left plane coordinate`right`: right plane coordinate`bottom`: bottom plane coordinate`top`: top plane coordinate`nearval`: near plane coordinate`farval`: far plane coordinateLoads the matrix with an orthogonal projection matrix. Does it the way glOrtho would, see https://www.opengl.org/sdk/docs/man2/xhtml/glOrtho.xml for details.

**Note:**use -nearVal and -farVal to initialize. It’s a little akward, if you expect to pass vectors with positions ranging from nearVal to farVal then you need to pass -nearVal and -farVal to this function. This is probably due to the fact that with a right-handed basis and X,Y set up "as usual", then Z is negative when going farther and farther. This tweak allows farVal to yield +1 and nearVal -1. We keep this function as is here, as this is the way OpenGL functions seem to work.**Return value:**none.

- Function:
*void***lw6mat_dmat4_perspective***(lw6mat_dmat4_t **`dmat4`, double`fovy`, double`aspect`, double`znear`, double`zfar`) `dmat4`: the matrix to initialize.`fovy`: vertical field of view (degrees, not radians)`aspect`: x/y ratio`znear`: near plane coordinate (use -znear to initialize)`zfar`: far plane coordinate (use -zfar to initialize)Loads the matrix with a projection matrix. Does it the way gluPerspective would, see https://www.opengl.org/sdk/docs/man2/xhtml/gluPerspective.xml for details.

**Return value:**none.

- Function:
*int***lw6mat_dmat4_is_same***(const lw6mat_dmat4_t **`dmat4_a`, const lw6mat_dmat4_t *`dmat4_b`) `dmat4_a`: 1st matrix to compare`dmat4_b`: 2nd matrix to compareCompares two matrix, returns true if they are equal.

**Return value:**1 if equal, 0 if different.

- Function:
*void***lw6mat_dmat4_transpose***(lw6mat_dmat4_t **`dmat4`) `dmat4`: the matrix to transposeTransposes the matrix, that is, inverts rows and columns.

**Return value:**none.

- Function:
*double***lw6mat_dmat4_det***(const lw6mat_dmat4_t **`dmat4`) `dmat4`: the matrix used to calculate the determinantCalulates the determinant of the matrix.

**Return value:**the determinant.

- Function:
*void***lw6mat_dmat4_mul_scale***(lw6mat_dmat4_t **`dmat4`, double`f`) `dmat4`: matrix to modify`f`: scale factorScales the matrix by multiplying all its members by a scalar value.

**Return value:**none

- Function:
*int***lw6mat_dmat4_inv***(lw6sys_context_t **`sys_context`, lw6mat_dmat4_t *`dmat4_dst`, const lw6mat_dmat4_t *`dmat4_src`) `sys_context`: global system context`dmat4_dst`: the matrix inverted`dmat4_src`: the matrix to invertInverts a matrix. Probably not the fastest implementation, but should work in all cases. Use hardware accelerated API such as OpenGL on dedicated hardware if you want power.

**Return value:**1 if inverted, 0 if error, typically if determinant was 0, matrix can not be inverted.

- Function:
*void***lw6mat_dmat4_mul_dmat4***(lw6mat_dmat4_t **`dmat4`, const lw6mat_dmat4_t *`dmat4_a`, const lw6mat_dmat4_t *`dmat4_b`) `dmat4`: the result matrix`dmat4_a`: the 1st matrix to multiply, on the left`dmat4_b`: the 2nd matrix to multiply, on the rightClassic matrix multiplication.

**Return value:**none.

- Function:
*void***lw6mat_dmat4_mul_dvec4***(lw6mat_dvec4_t **`dvec4_dst`, const lw6mat_dmat4_t *`dmat4`, const lw6mat_dvec4_t *`dvec4_src`) `dvec4_dst`: the result vector`dmat4`: the matrix to use`dvec4_src`: the source vectorMultiplication of matrix by vector. The result is a vector, the convention used is that of OpenGL, matrix are column major and vector are columns, that is, should you do it on a paper, vector is placed vertically, on the right of matrix. The other multiplication is not implemented, transposing the matrix will do it the other way if you wish.

**Return value:**none.

- Function:
*void***lw6mat_dmat4_mul_dvec3***(lw6mat_dvec3_t **`dvec3_dst`, const lw6mat_dmat4_t *`dmat4`, const lw6mat_dvec3_t *`dvec3_src`) `dvec3_dst`: the result vector`dmat4`: the matrix to use`dvec3_src`: the source vectorMultiplication of matrix by vector. The result is a vector, the convention used is that of OpenGL, matrix are column major and vector are columns, that is, should you do it on a paper, vector is placed vertically, on the right of matrix. The other multiplication is not implemented, transposing the matrix will do it the other way if you wish. The vector, here, is smaller than the matrix, the last element is supposed to be 1, this is how one implements translation through multiplication.

**Return value:**none.

- Function:
*char ****lw6mat_dmat4_repr***(lw6sys_context_t **`sys_context`, const lw6mat_dmat4_t *`dmat4`) `sys_context`: global system contextGives a readable version of the matrix, the representation uses newlines, with a different line for each row

**Return value:**newly allocated string

- Function:
*void***lw6mat_dvec2_zero***(lw6mat_dvec2_t **`dvec2`) `dvec2`: the vector to initialize.Fills the vector with zeros, regardless of what was there before. Internally, does a memset the only advantage is that this function should use the right sizeof and therefore avoids typo errors.

**Return value:**none.

- Function:
*int***lw6mat_dvec2_is_same***(const lw6mat_dvec2_t **`dvec2_a`, const lw6mat_dvec2_t *`dvec2_b`) `dvec2_a`: 1st vector to compare`dvec2_b`: 2nd vector to compareCompares two vectors, returns true if they are equal.

**Return value:**1 if equal, 0 if different.

- Function:
*double***lw6mat_dvec2_len_sq***(const lw6mat_dvec2_t **`dvec2`) `dvec2`: the vector to query.Returns the square of a vector length. To get the real length one should then apply a square root but at this stage one has at least an idea about vector length, and this information is enough to compare them.

**Return value:**sigma(coord*coord)

- Function:
*double***lw6mat_dvec2_len***(const lw6mat_dvec2_t **`dvec2`) `dvec2`: the vector to query.Returns the size/length of a vector, this is the distance of the point from origin, not the number of elements.

**Return value:**the length of the vector.

- Function:
*int***lw6mat_dvec2_normalize***(lw6sys_context_t **`sys_context`, lw6mat_dvec2_t *`dvec2`) `sys_context`: global system context`dvec2`: the vector to normalize.Normalizes a vector, that is, make its length be 1.

**Return value:**1 if OK, 0 if error, such as trying to normalize vector zero.

- Function:
*int***lw6mat_dvec2_homogeneous***(lw6sys_context_t **`sys_context`, lw6mat_dvec2_t *`dvec2`) `sys_context`: global system context`dvec2`: the vector to homogeneous.Transforms a vector into homegeneous coords, that is, scales it so that its last member is 1.

**Return value:**1 if OK, 0 if error, such as trying to operate on vector zero.

- Function:
*void***lw6mat_dvec2_neg***(lw6mat_dvec2_t **`dvec2`) `dvec2`: vector to modifyCalcs the opposite vector, by making a negation on all its members

**Return value:**none

- Function:
*void***lw6mat_dvec2_add***(lw6mat_dvec2_t **`dvec2`, const lw6mat_dvec2_t *`dvec2_a`, const lw6mat_dvec2_t *`dvec2_b`) `dvec2`: result vector`dvec2_a`: 1st vector to add`dvec2_b`: 2nd vector to addAdds two vectors.

**Return value:**none

- Function:
*void***lw6mat_dvec2_sub***(lw6mat_dvec2_t **`dvec2`, const lw6mat_dvec2_t *`dvec2_a`, const lw6mat_dvec2_t *`dvec2_b`) `dvec2`: result vector`dvec2_a`: 1st vector`dvec2_b`: 2nd vector, will be substracted to 1st vectorSubstracts vector b from vector a.

**Return value:**none

- Function:
*double***lw6mat_dvec2_dot***(const lw6mat_dvec2_t **`dvec2_a`, const lw6mat_dvec2_t *`dvec2_b`) `dvec2_a`: 1st vector`dvec2_b`: 2nd vectorCalculates the dot AKA scalar product of the two vectors.

**Return value:**none

- Function:
*void***lw6mat_dvec2_cross***(lw6mat_dvec3_t **`dvec3`, const lw6mat_dvec2_t *`dvec2_a`, const lw6mat_dvec2_t *`dvec2_b`) `dvec3`: result vector`dvec2_a`: 1st vector`dvec2_b`: 2nd vectorCalculates the cross AKA vectorial product of the two vectors. Since cross product only really makes sense in 3D, this function will interpret the 2D vectors as 3D vectors with z set t zero, that is, a vector in the xy plane.

**Return value:**none

- Function:
*void***lw6mat_dvec2_mul_scale***(lw6mat_dvec2_t **`dvec2`, double`f`) `dvec2`: vector to modify`f`: scale factorScales the vector by multiplying all its members by a scalar value.

**Return value:**none

- Function:
*void***lw6mat_dvec2_mul_dvec2***(lw6mat_dmat2_t **`dmat2`, const lw6mat_dvec2_t *`dvec2_a`, const lw6mat_dvec2_t *`dvec2_b`) `dmat2`: result matrix`dvec2_a`: 1st row vector`dvec2_b`: 2nd column vectorMultiplication of a row vector by a column vector to give a matrix.

**Return value:**none

- Function:
*char ****lw6mat_dvec2_repr***(lw6sys_context_t **`sys_context`, const lw6mat_dvec2_t *`dvec2`) `sys_context`: global system contextGives a readable version of the vector

**Return value:**newly allocated string

- Function:
*void***lw6mat_dvec3_zero***(lw6mat_dvec3_t **`dvec3`) `dvec3`: the vector to initialize.Fills the vector with zeros, regardless of what was there before. Internally, does a memset the only advantage is that this function should use the right sizeof and therefore avoids typo errors.

**Return value:**none.

- Function:
*int***lw6mat_dvec3_is_same***(const lw6mat_dvec3_t **`dvec3_a`, const lw6mat_dvec3_t *`dvec3_b`) `dvec3_a`: 1st vector to compare`dvec3_b`: 2nd vector to compareCompares two vectors, returns true if they are equal.

**Return value:**1 if equal, 0 if different.

- Function:
*double***lw6mat_dvec3_len_sq***(const lw6mat_dvec3_t **`dvec3`) `dvec3`: the vector to query.Returns the square of a vector length. To get the real length one should then apply a square root but at this stage one has at least an idea about vector length, and this information is enough to compare them.

**Return value:**sigma(coord*coord)

- Function:
*double***lw6mat_dvec3_len***(const lw6mat_dvec3_t **`dvec3`) `dvec3`: the vector to query.Returns the size/length of a vector, this is the distance of the point from origin, not the number of elements.

**Return value:**the length of the vector.

- Function:
*int***lw6mat_dvec3_normalize***(lw6sys_context_t **`sys_context`, lw6mat_dvec3_t *`dvec3`) `sys_context`: global system context`dvec3`: the vector to normalize.Normalizes a vector, that is, make its length be 1.

**Return value:**1 if OK, 0 if error, such as trying to normalize vector zero.

- Function:
*int***lw6mat_dvec3_homogeneous***(lw6sys_context_t **`sys_context`, lw6mat_dvec3_t *`dvec3`) `sys_context`: global system context`dvec3`: the vector to homogeneous.Transforms a vector into homegeneous coords, that is, scales it so that its last member is 1.

**Return value:**1 if OK, 0 if error, such as trying to operate on vector zero.

- Function:
*void***lw6mat_dvec3_neg***(lw6mat_dvec3_t **`dvec3`) `dvec3`: vector to modifyCalcs the opposite vector, by making a negation on all its members

**Return value:**none

- Function:
*void***lw6mat_dvec3_add***(lw6mat_dvec3_t **`dvec3`, const lw6mat_dvec3_t *`dvec3_a`, const lw6mat_dvec3_t *`dvec3_b`) `dvec3`: result vector`dvec3_a`: 1st vector to add`dvec3_b`: 2nd vector to addAdds two vectors.

**Return value:**none

- Function:
*void***lw6mat_dvec3_sub***(lw6mat_dvec3_t **`dvec3`, const lw6mat_dvec3_t *`dvec3_a`, const lw6mat_dvec3_t *`dvec3_b`) `dvec3`: result vector`dvec3_a`: 1st vector`dvec3_b`: 2nd vector, will be substracted to 1st vectorSubstracts vector b from vector a.

**Return value:**none

- Function:
*double***lw6mat_dvec3_dot***(const lw6mat_dvec3_t **`dvec3_a`, const lw6mat_dvec3_t *`dvec3_b`) `dvec3_a`: 1st vector`dvec3_b`: 2nd vectorCalculates the dot AKA scalar product of the two vectors.

**Return value:**none

- Function:
*void***lw6mat_dvec3_cross***(lw6mat_dvec3_t **`dvec3`, const lw6mat_dvec3_t *`dvec3_a`, const lw6mat_dvec3_t *`dvec3_b`) `dvec3`: result vector`dvec3_a`: 1st vector`dvec3_b`: 2nd vectorCalculates the cross AKA vectorial product of the two vectors.

**Return value:**none

- Function:
*void***lw6mat_dvec3_mul_scale***(lw6mat_dvec3_t **`dvec3`, double`f`) `dvec3`: vector to modify`f`: scale factorScales the vector by multiplying all its members by a scalar value.

**Return value:**none

- Function:
*void***lw6mat_dvec3_mul_dvec3***(lw6mat_dmat3_t **`dmat3`, const lw6mat_dvec3_t *`dvec3_a`, const lw6mat_dvec3_t *`dvec3_b`) `dmat3`: result matrix`dvec3_a`: 1st row vector`dvec3_b`: 3nd column vectorMultiplication of a row vector by a column vector to give a matrix.

**Return value:**none

- Function:
*char ****lw6mat_dvec3_repr***(lw6sys_context_t **`sys_context`, const lw6mat_dvec3_t *`dvec3`) `sys_context`: global system contextGives a readable version of the vector

**Return value:**newly allocated string

- Function:
*void***lw6mat_dvec4_zero***(lw6mat_dvec4_t **`dvec4`) `dvec4`: the vector to initialize.Fills the vector with zeros, regardless of what was there before. Internally, does a memset the only advantage is that this function should use the right sizeof and therefore avoids typo errors.

**Return value:**none.

- Function:
*int***lw6mat_dvec4_is_same***(const lw6mat_dvec4_t **`dvec4_a`, const lw6mat_dvec4_t *`dvec4_b`) `dvec4_a`: 1st vector to compare`dvec4_b`: 2nd vector to compareCompares two vectors, returns true if they are equal.

**Return value:**1 if equal, 0 if different.

- Function:
*double***lw6mat_dvec4_len_sq***(const lw6mat_dvec4_t **`dvec4`) `dvec4`: the vector to query.Returns the square of a vector length. To get the real length one should then apply a square root but at this stage one has at least an idea about vector length, and this information is enough to compare them.

**Return value:**sigma(coord*coord)

- Function:
*double***lw6mat_dvec4_len***(const lw6mat_dvec4_t **`dvec4`) `dvec4`: the vector to query.Returns the size/length of a vector, this is the distance of the point from origin, not the number of elements.

**Return value:**the length of the vector.

- Function:
*int***lw6mat_dvec4_normalize***(lw6sys_context_t **`sys_context`, lw6mat_dvec4_t *`dvec4`) `sys_context`: global system context`dvec4`: the vector to normalize.Normalizes a vector, that is, make its length be 1.

**Return value:**1 if OK, 0 if error, such as trying to normalize vector zero.

- Function:
*int***lw6mat_dvec4_homogeneous***(lw6sys_context_t **`sys_context`, lw6mat_dvec4_t *`dvec4`) `sys_context`: global system context`dvec4`: the vector to homogeneous.Transforms a vector into homegeneous coords, that is, scales it so that its last member is 1.

**Return value:**1 if OK, 0 if error, such as trying to operate on vector zero.

- Function:
*void***lw6mat_dvec4_neg***(lw6mat_dvec4_t **`dvec4`) `dvec4`: vector to modifyCalcs the opposite vector, by making a negation on all its members

**Return value:**none

- Function:
*void***lw6mat_dvec4_add***(lw6mat_dvec4_t **`dvec4`, const lw6mat_dvec4_t *`dvec4_a`, const lw6mat_dvec4_t *`dvec4_b`) `dvec4`: result vector`dvec4_a`: 1st vector to add`dvec4_b`: 2nd vector to addAdds two vectors.

**Return value:**none

- Function:
*void***lw6mat_dvec4_sub***(lw6mat_dvec4_t **`dvec4`, const lw6mat_dvec4_t *`dvec4_a`, const lw6mat_dvec4_t *`dvec4_b`) `dvec4`: result vector`dvec4_a`: 1st vector`dvec4_b`: 2nd vector, will be substracted to 1st vectorSubstracts vector b from vector a.

**Return value:**none

- Function:
*double***lw6mat_dvec4_dot***(const lw6mat_dvec4_t **`dvec4_a`, const lw6mat_dvec4_t *`dvec4_b`) `dvec4_a`: 1st vector`dvec4_b`: 2nd vectorCalculates the dot AKA scalar product of the two vectors.

**Return value:**none

- Function:
*void***lw6mat_dvec4_cross***(lw6mat_dvec3_t **`dvec3`, const lw6mat_dvec4_t *`dvec4_a`, const lw6mat_dvec4_t *`dvec4_b`) `dvec3`: result vector`dvec4_a`: 1st vector`dvec4_b`: 2nd vectorCalculates the cross AKA vectorial product of the two vectors. Since cross product only really makes sense in 3D, this function will interpret the 4D vectors as 3D vectors only, ignoring the last value.

**Return value:**none

- Function:
*void***lw6mat_dvec4_mul_scale***(lw6mat_dvec4_t **`dvec4`, double`f`) `dvec4`: vector to modify`f`: scale factorScales the vector by multiplying all its members by a scalar value.

**Return value:**none

- Function:
*void***lw6mat_dvec4_mul_dvec4***(lw6mat_dmat4_t **`dmat4`, const lw6mat_dvec4_t *`dvec4_a`, const lw6mat_dvec4_t *`dvec4_b`) `dmat4`: result matrix`dvec4_a`: 1st row vector`dvec4_b`: 4nd column vectorMultiplication of a row vector by a column vector to give a matrix.

**Return value:**none

- Function:
*char ****lw6mat_dvec4_repr***(lw6sys_context_t **`sys_context`, const lw6mat_dvec4_t *`dvec4`) `sys_context`: global system contextGives a readable version of the vector

**Return value:**newly allocated string

- Function:
*void***lw6mat_fmat2_zero***(lw6mat_fmat2_t **`fmat2`) `fmat2`: the matrix to initialize.**Return value:**none.

- Function:
*void***lw6mat_fmat2_identity***(lw6mat_fmat2_t **`fmat2`) `fmat2`: the matrix to initialize.Loads the matrix with the identity matrix, that is, zero everywhere but one on the main diag.

**Return value:**none.

- Function:
*void***lw6mat_fmat2_translation***(lw6mat_fmat2_t **`fmat2`, float`f`) `fmat2`: the matrix to initialize.`f`: value which defines the translation.**Return value:**none.

- Function:
*void***lw6mat_fmat2_scale***(lw6mat_fmat2_t **`fmat2`, float`f`) `fmat2`: the matrix to initialize.`f`: value used to scale matrix.Loads the matrix with a scale matrix. By multiplicating by this matrix, a scaling is done.

**Return value:**none.

- Function:
*int***lw6mat_fmat2_is_same***(const lw6mat_fmat2_t **`fmat2_a`, const lw6mat_fmat2_t *`fmat2_b`) `fmat2_a`: 1st matrix to compare`fmat2_b`: 2nd matrix to compareCompares two matrix, returns true if they are equal.

**Return value:**1 if equal, 0 if different.

- Function:
*void***lw6mat_fmat2_transpose***(lw6mat_fmat2_t **`fmat2`) `fmat2`: the matrix to transposeTransposes the matrix, that is, inverts rows and columns.

**Return value:**none.

- Function:
*float***lw6mat_fmat2_det***(const lw6mat_fmat2_t **`fmat2`) `fmat2`: the matrix used to calculate the determinantCalulates the determinant of the matrix.

**Return value:**the determinant.

- Function:
*void***lw6mat_fmat2_mul_scale***(lw6mat_fmat2_t **`fmat2`, float`f`) `fmat2`: matrix to modify`f`: scale factorScales the matrix by multiplying all its members by a scalar value.

**Return value:**none

- Function:
*int***lw6mat_fmat2_inv***(lw6sys_context_t **`sys_context`, lw6mat_fmat2_t *`fmat2_dst`, const lw6mat_fmat2_t *`fmat2_src`) `sys_context`: global system context`fmat2_dst`: the matrix inverted`fmat2_src`: the matrix to invert**Return value:**1 if inverted, 0 if error, typically if determinant was 0, matrix can not be inverted.

- Function:
*void***lw6mat_fmat2_mul_fmat2***(lw6mat_fmat2_t **`fmat2`, const lw6mat_fmat2_t *`fmat2_a`, const lw6mat_fmat2_t *`fmat2_b`) `fmat2`: the result matrix`fmat2_a`: the 1st matrix to multiply, on the left`fmat2_b`: the 2nd matrix to multiply, on the rightClassic matrix multiplication.

**Return value:**none.

- Function:
*void***lw6mat_fmat2_mul_fvec2***(lw6mat_fvec2_t **`fvec2_dst`, const lw6mat_fmat2_t *`fmat2`, const lw6mat_fvec2_t *`fvec2_src`) `fvec2_dst`: the result vector`fvec2_src`: the source vector**Return value:**none.

- Function:
*char ****lw6mat_fmat2_repr***(lw6sys_context_t **`sys_context`, const lw6mat_fmat2_t *`fmat2`) `sys_context`: global system context**Return value:**newly allocated string

- Function:
*void***lw6mat_fmat3_zero***(lw6mat_fmat3_t **`fmat3`) `fmat3`: the matrix to initialize.**Return value:**none.

- Function:
*void***lw6mat_fmat3_identity***(lw6mat_fmat3_t **`fmat3`) `fmat3`: the matrix to initialize.Loads the matrix with the identity matrix, that is, zero everywhere but one on the main diag.

**Return value:**none.

- Function:
*void***lw6mat_fmat3_translation***(lw6mat_fmat3_t **`fmat3`, const lw6mat_fvec2_t *`fvec2`) `fmat3`: the matrix to initialize.`fvec2`: vector which defines the translation.**Return value:**none.

- Function:
*void***lw6mat_fmat3_scale***(lw6mat_fmat3_t **`fmat3`, const lw6mat_fvec2_t *`fvec2`) `fmat3`: the matrix to initialize.`fvec2`: value used to scale matrix.Loads the matrix with a scale matrix. By multiplicating by this matrix, a scaling is done.

**Return value:**none.

- Function:
*void***lw6mat_fmat3_rot***(lw6mat_fmat3_t **`fmat3`, float`r`) `fmat3`: the matrix to initialize.`r`: value used to for the rotation, angle in radians.Loads the matrix with a rotation matrix. By multiplicating by this matrix, a rotation is done, over a virtual Z axis such as Z is the cross product of X and Y.

**Return value:**none.

- Function:
*int***lw6mat_fmat3_is_same***(const lw6mat_fmat3_t **`fmat3_a`, const lw6mat_fmat3_t *`fmat3_b`) `fmat3_a`: 1st matrix to compare`fmat3_b`: 2nd matrix to compareCompares two matrix, returns true if they are equal.

**Return value:**1 if equal, 0 if different.

- Function:
*void***lw6mat_fmat3_transpose***(lw6mat_fmat3_t **`fmat3`) `fmat3`: the matrix to transposeTransposes the matrix, that is, inverts rows and columns.

**Return value:**none.

- Function:
*float***lw6mat_fmat3_det***(const lw6mat_fmat3_t **`fmat3`) `fmat3`: the matrix used to calculate the determinantCalulates the determinant of the matrix.

**Return value:**the determinant.

- Function:
*void***lw6mat_fmat3_mul_scale***(lw6mat_fmat3_t **`fmat3`, float`f`) `fmat3`: matrix to modify`f`: scale factorScales the matrix by multiplying all its members by a scalar value.

**Return value:**none

- Function:
*int***lw6mat_fmat3_inv***(lw6sys_context_t **`sys_context`, lw6mat_fmat3_t *`fmat3_dst`, const lw6mat_fmat3_t *`fmat3_src`) `sys_context`: global system context`fmat3_dst`: the matrix inverted`fmat3_src`: the matrix to invert**Return value:**1 if inverted, 0 if error, typically if determinant was 0, matrix can not be inverted.

- Function:
*void***lw6mat_fmat3_mul_fmat3***(lw6mat_fmat3_t **`fmat3`, const lw6mat_fmat3_t *`fmat3_a`, const lw6mat_fmat3_t *`fmat3_b`) `fmat3`: the result matrix`fmat3_a`: the 1st matrix to multiply, on the left`fmat3_b`: the 2nd matrix to multiply, on the rightClassic matrix multiplication.

**Return value:**none.

- Function:
*void***lw6mat_fmat3_mul_fvec3***(lw6mat_fvec3_t **`fvec3_dst`, const lw6mat_fmat3_t *`fmat3`, const lw6mat_fvec3_t *`fvec3_src`) `fvec3_dst`: the result vector`fvec3_src`: the source vector**Return value:**none.

- Function:
*void***lw6mat_fmat3_mul_fvec2***(lw6mat_fvec2_t **`fvec2_dst`, const lw6mat_fmat3_t *`fmat3`, const lw6mat_fvec2_t *`fvec2_src`) `fvec2_dst`: the result vectorMultiplication of matrix by vector. The result is a vector, the convention used is that of OpenGL, matrix are column major and vector are columns, that is, should you do it on a paper, vector is placed vertically, on the right of matrix. The other multiplication is not implemented, transposing the matrix will do it the other way if you wish. The vector, here, is smaller than the matrix, the last element is supposed to be 1, this is how one implements translation through multiplication.

**Return value:**none.

- Function:
*char ****lw6mat_fmat3_repr***(lw6sys_context_t **`sys_context`, const lw6mat_fmat3_t *`fmat3`) `sys_context`: global system context**Return value:**newly allocated string

- Function:
*void***lw6mat_fmat4_zero***(lw6mat_fmat4_t **`fmat4`) `fmat4`: the matrix to initialize.**Return value:**none.

- Function:
*void***lw6mat_fmat4_identity***(lw6mat_fmat4_t **`fmat4`) `fmat4`: the matrix to initialize.Loads the matrix with the identity matrix, that is, zero everywhere but one on the main diag.

**Return value:**none.

- Function:
*void***lw6mat_fmat4_translation***(lw6mat_fmat4_t **`fmat4`, const lw6mat_fvec3_t *`fvec3`) `fmat4`: the matrix to initialize.`fvec3`: vector which defines the translation.**Return value:**none.

- Function:
*void***lw6mat_fmat4_scale***(lw6mat_fmat4_t **`fmat4`, const lw6mat_fvec3_t *`fvec3`) `fmat4`: the matrix to initialize.`fvec3`: value used to scale matrix.Loads the matrix with a scale matrix. By multiplicating by this matrix, a scaling is done.

**Return value:**none.

- Function:
*void***lw6mat_fmat4_rot_x***(lw6mat_fmat4_t **`fmat4`, float`r`) `fmat4`: the matrix to initialize.`r`: value used to for the rotation, angle in radians.Loads the matrix with a rotation matrix. By multiplicating by this matrix, a rotation is done, over the X axis.

**Return value:**none.

- Function:
*void***lw6mat_fmat4_rot_y***(lw6mat_fmat4_t **`fmat4`, float`r`) `fmat4`: the matrix to initialize.`r`: value used to for the rotation, angle in radians.Loads the matrix with a rotation matrix. By multiplicating by this matrix, a rotation is done, over the Y axis.

**Return value:**none.

- Function:
*void***lw6mat_fmat4_rot_z***(lw6mat_fmat4_t **`fmat4`, float`r`) `fmat4`: the matrix to initialize.`r`: value used to for the rotation, angle in radians.Loads the matrix with a rotation matrix. By multiplicating by this matrix, a rotation is done, over the Z axis.

**Return value:**none.

- Function:
*void***lw6mat_fmat4_ortho***(lw6mat_fmat4_t **`fmat4`, float`left`, float`right`, float`bottom`, float`top`, float`nearval`, float`farval`) `fmat4`: the matrix to initialize.`left`: left plane coordinate`right`: right plane coordinate`bottom`: bottom plane coordinate`top`: top plane coordinate`nearval`: near plane coordinate`farval`: far plane coordinateLoads the matrix with an orthogonal projection matrix. Does it the way glOrtho would, see https://www.opengl.org/sdk/docs/man2/xhtml/glOrtho.xml for details.

**Note:**use -nearVal and -farVal to initialize. It’s a little akward, if you expect to pass vectors with positions ranging from nearVal to farVal then you need to pass -nearVal and -farVal to this function. This is probably due to the fact that with a right-handed basis and X,Y set up "as usual", then Z is negative when going farther and farther. This tweak allows farVal to yield +1 and nearVal -1. We keep this function as is here, as this is the way OpenGL functions seem to work.**Return value:**none.

- Function:
*void***lw6mat_fmat4_perspective***(lw6mat_fmat4_t **`fmat4`, float`fovy`, float`aspect`, float`znear`, float`zfar`) `fmat4`: the matrix to initialize.`fovy`: vertical field of view (degrees, not radians)`aspect`: x/y ratio`znear`: near plane coordinate (use -znear to initialize)`zfar`: far plane coordinate (use -zfar to initialize)Loads the matrix with a projection matrix. Does it the way gluPerspective would, see https://www.opengl.org/sdk/docs/man2/xhtml/gluPerspective.xml for details.

**Return value:**none.

- Function:
*int***lw6mat_fmat4_is_same***(const lw6mat_fmat4_t **`fmat4_a`, const lw6mat_fmat4_t *`fmat4_b`) `fmat4_a`: 1st matrix to compare`fmat4_b`: 2nd matrix to compareCompares two matrix, returns true if they are equal.

**Return value:**1 if equal, 0 if different.

- Function:
*void***lw6mat_fmat4_transpose***(lw6mat_fmat4_t **`fmat4`) `fmat4`: the matrix to transposeTransposes the matrix, that is, inverts rows and columns.

**Return value:**none.

- Function:
*float***lw6mat_fmat4_det***(const lw6mat_fmat4_t **`fmat4`) `fmat4`: the matrix used to calculate the determinantCalulates the determinant of the matrix.

**Return value:**the determinant.

- Function:
*void***lw6mat_fmat4_mul_scale***(lw6mat_fmat4_t **`fmat4`, float`f`) `fmat4`: matrix to modify`f`: scale factorScales the matrix by multiplying all its members by a scalar value.

**Return value:**none

- Function:
*int***lw6mat_fmat4_inv***(lw6sys_context_t **`sys_context`, lw6mat_fmat4_t *`fmat4_dst`, const lw6mat_fmat4_t *`fmat4_src`) `sys_context`: global system context`fmat4_dst`: the matrix inverted`fmat4_src`: the matrix to invert**Return value:**1 if inverted, 0 if error, typically if determinant was 0, matrix can not be inverted.

- Function:
*void***lw6mat_fmat4_mul_fmat4***(lw6mat_fmat4_t **`fmat4`, const lw6mat_fmat4_t *`fmat4_a`, const lw6mat_fmat4_t *`fmat4_b`) `fmat4`: the result matrix`fmat4_a`: the 1st matrix to multiply, on the left`fmat4_b`: the 2nd matrix to multiply, on the rightClassic matrix multiplication.

**Return value:**none.

- Function:
*void***lw6mat_fmat4_mul_fvec4***(lw6mat_fvec4_t **`fvec4_dst`, const lw6mat_fmat4_t *`fmat4`, const lw6mat_fvec4_t *`fvec4_src`) `fvec4_dst`: the result vector`fmat4`: the matrix to use`fvec4_src`: the source vector**Return value:**none.

- Function:
*void***lw6mat_fmat4_mul_fvec3***(lw6mat_fvec3_t **`fvec3_dst`, const lw6mat_fmat4_t *`fmat4`, const lw6mat_fvec3_t *`fvec3_src`) `fvec3_dst`: the result vector`fmat4`: the matrix to use`fvec3_src`: the source vector**Return value:**none.

- Function:
*char ****lw6mat_fmat4_repr***(lw6sys_context_t **`sys_context`, const lw6mat_fmat4_t *`fmat4`) `sys_context`: global system context**Return value:**newly allocated string

- Function:
*void***lw6mat_fvec2_zero***(lw6mat_fvec2_t **`fvec2`) `fvec2`: the vector to initialize.**Return value:**none.

- Function:
*int***lw6mat_fvec2_is_same***(const lw6mat_fvec2_t **`fvec2_a`, const lw6mat_fvec2_t *`fvec2_b`) `fvec2_a`: 1st vector to compare`fvec2_b`: 2nd vector to compareCompares two vectors, returns true if they are equal.

**Return value:**1 if equal, 0 if different.

- Function:
*float***lw6mat_fvec2_len_sq***(const lw6mat_fvec2_t **`fvec2`) `fvec2`: the vector to query.**Return value:**sigma(coord*coord)

- Function:
*float***lw6mat_fvec2_len***(const lw6mat_fvec2_t **`fvec2`) `fvec2`: the vector to query.**Return value:**the length of the vector.

- Function:
*int***lw6mat_fvec2_normalize***(lw6sys_context_t **`sys_context`, lw6mat_fvec2_t *`fvec2`) `sys_context`: global system context`fvec2`: the vector to normalize.Normalizes a vector, that is, make its length be 1.

**Return value:**1 if OK, 0 if error, such as trying to normalize vector zero.

- Function:
*int***lw6mat_fvec2_homogeneous***(lw6sys_context_t **`sys_context`, lw6mat_fvec2_t *`fvec2`) `sys_context`: global system context`fvec2`: the vector to homogeneous.Transforms a vector into homegeneous coords, that is, scales it so that its last member is 1.

**Return value:**1 if OK, 0 if error, such as trying to operate on vector zero.

- Function:
*void***lw6mat_fvec2_neg***(lw6mat_fvec2_t **`fvec2`) `fvec2`: vector to modifyCalcs the opposite vector, by making a negation on all its members

**Return value:**none

- Function:
*void***lw6mat_fvec2_add***(lw6mat_fvec2_t **`fvec2`, const lw6mat_fvec2_t *`fvec2_a`, const lw6mat_fvec2_t *`fvec2_b`) `fvec2`: result vector`fvec2_a`: 1st vector to add`fvec2_b`: 2nd vector to addAdds two vectors.

**Return value:**none

- Function:
*void***lw6mat_fvec2_sub***(lw6mat_fvec2_t **`fvec2`, const lw6mat_fvec2_t *`fvec2_a`, const lw6mat_fvec2_t *`fvec2_b`) `fvec2`: result vector`fvec2_a`: 1st vector`fvec2_b`: 2nd vector, will be substracted to 1st vectorSubstracts vector b from vector a.

**Return value:**none

- Function:
*float***lw6mat_fvec2_dot***(const lw6mat_fvec2_t **`fvec2_a`, const lw6mat_fvec2_t *`fvec2_b`) `fvec2_a`: 1st vector`fvec2_b`: 2nd vectorCalculates the dot AKA scalar product of the two vectors.

**Return value:**none

- Function:
*void***lw6mat_fvec2_cross***(lw6mat_fvec3_t **`fvec3`, const lw6mat_fvec2_t *`fvec2_a`, const lw6mat_fvec2_t *`fvec2_b`) `fvec3`: result vector`fvec2_a`: 1st vector`fvec2_b`: 2nd vectorCalculates the cross AKA vectorial product of the two vectors. Since cross product only really makes sense in 3D, this function will interpret the 2D vectors as 3D vectors with z set t zero, that is, a vector in the xy plane.

**Return value:**none

- Function:
*void***lw6mat_fvec2_mul_scale***(lw6mat_fvec2_t **`fvec2`, float`f`) `fvec2`: vector to modify`f`: scale factorScales the vector by multiplying all its members by a scalar value.

**Return value:**none

- Function:
*void***lw6mat_fvec2_mul_fvec2***(lw6mat_fmat2_t **`fmat2`, const lw6mat_fvec2_t *`fvec2_a`, const lw6mat_fvec2_t *`fvec2_b`) `fmat2`: result matrix`fvec2_a`: 1st row vector`fvec2_b`: 2nd column vectorMultiplication of a row vector by a column vector to give a matrix.

**Return value:**none

- Function:
*char ****lw6mat_fvec2_repr***(lw6sys_context_t **`sys_context`, const lw6mat_fvec2_t *`fvec2`) `sys_context`: global system contextGives a readable version of the vector

**Return value:**newly allocated string

- Function:
*void***lw6mat_fvec3_zero***(lw6mat_fvec3_t **`fvec3`) `fvec3`: the vector to initialize.**Return value:**none.

- Function:
*int***lw6mat_fvec3_is_same***(const lw6mat_fvec3_t **`fvec3_a`, const lw6mat_fvec3_t *`fvec3_b`) `fvec3_a`: 1st vector to compare`fvec3_b`: 2nd vector to compareCompares two vectors, returns true if they are equal.

**Return value:**1 if equal, 0 if different.

- Function:
*float***lw6mat_fvec3_len_sq***(const lw6mat_fvec3_t **`fvec3`) `fvec3`: the vector to query.**Return value:**sigma(coord*coord)

- Function:
*float***lw6mat_fvec3_len***(const lw6mat_fvec3_t **`fvec3`) `fvec3`: the vector to query.**Return value:**the length of the vector.

- Function:
*int***lw6mat_fvec3_normalize***(lw6sys_context_t **`sys_context`, lw6mat_fvec3_t *`fvec3`) `sys_context`: global system context`fvec3`: the vector to normalize.Normalizes a vector, that is, make its length be 1.

**Return value:**1 if OK, 0 if error, such as trying to normalize vector zero.

- Function:
*int***lw6mat_fvec3_homogeneous***(lw6sys_context_t **`sys_context`, lw6mat_fvec3_t *`fvec3`) `sys_context`: global system context`fvec3`: the vector to homogeneous.Transforms a vector into homegeneous coords, that is, scales it so that its last member is 1.

**Return value:**1 if OK, 0 if error, such as trying to operate on vector zero.

- Function:
*void***lw6mat_fvec3_neg***(lw6mat_fvec3_t **`fvec3`) `fvec3`: vector to modifyCalcs the opposite vector, by making a negation on all its members

**Return value:**none

- Function:
*void***lw6mat_fvec3_add***(lw6mat_fvec3_t **`fvec3`, const lw6mat_fvec3_t *`fvec3_a`, const lw6mat_fvec3_t *`fvec3_b`) `fvec3`: result vector`fvec3_a`: 1st vector to add`fvec3_b`: 2nd vector to addAdds two vectors.

**Return value:**none

- Function:
*void***lw6mat_fvec3_sub***(lw6mat_fvec3_t **`fvec3`, const lw6mat_fvec3_t *`fvec3_a`, const lw6mat_fvec3_t *`fvec3_b`) `fvec3`: result vector`fvec3_a`: 1st vector`fvec3_b`: 2nd vector, will be substracted to 1st vectorSubstracts vector b from vector a.

**Return value:**none

- Function:
*float***lw6mat_fvec3_dot***(const lw6mat_fvec3_t **`fvec3_a`, const lw6mat_fvec3_t *`fvec3_b`) `fvec3_a`: 1st vector`fvec3_b`: 2nd vectorCalculates the dot AKA scalar product of the two vectors.

**Return value:**none

- Function:
*void***lw6mat_fvec3_cross***(lw6mat_fvec3_t **`fvec3`, const lw6mat_fvec3_t *`fvec3_a`, const lw6mat_fvec3_t *`fvec3_b`) `fvec3`: result vector`fvec3_a`: 1st vector`fvec3_b`: 2nd vectorCalculates the cross AKA vectorial product of the two vectors.

**Return value:**none

- Function:
*void***lw6mat_fvec3_mul_scale***(lw6mat_fvec3_t **`fvec3`, float`f`) `fvec3`: vector to modify`f`: scale factorScales the vector by multiplying all its members by a scalar value.

**Return value:**none

- Function:
*void***lw6mat_fvec3_mul_fvec3***(lw6mat_fmat3_t **`fmat3`, const lw6mat_fvec3_t *`fvec3_a`, const lw6mat_fvec3_t *`fvec3_b`) `fmat3`: result matrix`fvec3_a`: 1st row vector`fvec3_b`: 3nd column vectorMultiplication of a row vector by a column vector to give a matrix.

**Return value:**none

- Function:
*char ****lw6mat_fvec3_repr***(lw6sys_context_t **`sys_context`, const lw6mat_fvec3_t *`fvec3`) `sys_context`: global system contextGives a readable version of the vector

**Return value:**newly allocated string

- Function:
*void***lw6mat_fvec4_zero***(lw6mat_fvec4_t **`fvec4`) `fvec4`: the vector to initialize.**Return value:**none.

- Function:
*int***lw6mat_fvec4_is_same***(const lw6mat_fvec4_t **`fvec4_a`, const lw6mat_fvec4_t *`fvec4_b`) `fvec4_a`: 1st vector to compare`fvec4_b`: 2nd vector to compareCompares two vectors, returns true if they are equal.

**Return value:**1 if equal, 0 if different.

- Function:
*float***lw6mat_fvec4_len_sq***(const lw6mat_fvec4_t **`fvec4`) `fvec4`: the vector to query.**Return value:**sigma(coord*coord)

- Function:
*float***lw6mat_fvec4_len***(const lw6mat_fvec4_t **`fvec4`) `fvec4`: the vector to query.**Return value:**the length of the vector.

- Function:
*int***lw6mat_fvec4_normalize***(lw6sys_context_t **`sys_context`, lw6mat_fvec4_t *`fvec4`) `sys_context`: global system context`fvec4`: the vector to normalize.Normalizes a vector, that is, make its length be 1.

**Return value:**1 if OK, 0 if error, such as trying to normalize vector zero.

- Function:
*int***lw6mat_fvec4_homogeneous***(lw6sys_context_t **`sys_context`, lw6mat_fvec4_t *`fvec4`) `sys_context`: global system context`fvec4`: the vector to homogeneous.Transforms a vector into homegeneous coords, that is, scales it so that its last member is 1.

**Return value:**1 if OK, 0 if error, such as trying to operate on vector zero.

- Function:
*void***lw6mat_fvec4_neg***(lw6mat_fvec4_t **`fvec4`) `fvec4`: vector to modifyCalcs the opposite vector, by making a negation on all its members

**Return value:**none

- Function:
*void***lw6mat_fvec4_add***(lw6mat_fvec4_t **`fvec4`, const lw6mat_fvec4_t *`fvec4_a`, const lw6mat_fvec4_t *`fvec4_b`) `fvec4`: result vector`fvec4_a`: 1st vector to add`fvec4_b`: 2nd vector to addAdds two vectors.

**Return value:**none

- Function:
*void***lw6mat_fvec4_sub***(lw6mat_fvec4_t **`fvec4`, const lw6mat_fvec4_t *`fvec4_a`, const lw6mat_fvec4_t *`fvec4_b`) `fvec4`: result vector`fvec4_a`: 1st vector`fvec4_b`: 2nd vector, will be substracted to 1st vectorSubstracts vector b from vector a.

**Return value:**none

- Function:
*float***lw6mat_fvec4_dot***(const lw6mat_fvec4_t **`fvec4_a`, const lw6mat_fvec4_t *`fvec4_b`) `fvec4_a`: 1st vector`fvec4_b`: 2nd vectorCalculates the dot AKA scalar product of the two vectors.

**Return value:**none

- Function:
*void***lw6mat_fvec4_cross***(lw6mat_fvec3_t **`fvec3`, const lw6mat_fvec4_t *`fvec4_a`, const lw6mat_fvec4_t *`fvec4_b`) `fvec3`: result vector`fvec4_a`: 1st vector`fvec4_b`: 2nd vectorCalculates the cross AKA vectorial product of the two vectors. Since cross product only really makes sense in 3D, this function will interpret the 4D vectors as 3D vectors only, ignoring the last value.

**Return value:**none

- Function:
*void***lw6mat_fvec4_mul_scale***(lw6mat_fvec4_t **`fvec4`, float`f`) `fvec4`: vector to modify`f`: scale factorScales the vector by multiplying all its members by a scalar value.

**Return value:**none

- Function:
*void***lw6mat_fvec4_mul_fvec4***(lw6mat_fmat4_t **`fmat4`, const lw6mat_fvec4_t *`fvec4_a`, const lw6mat_fvec4_t *`fvec4_b`) `fmat4`: result matrix`fvec4_a`: 1st row vector`fvec4_b`: 4nd column vectorMultiplication of a row vector by a column vector to give a matrix.

**Return value:**none

- Function:
*char ****lw6mat_fvec4_repr***(lw6sys_context_t **`sys_context`, const lw6mat_fvec4_t *`fvec4`) `sys_context`: global system contextGives a readable version of the vector

**Return value:**newly allocated string

- Function:
*int***lw6mat_is_similar_f***(float*`f_a`, float`f_b`) `f_a`: 1st value to compare`f_b`: 2nd value to compareCompares two value, and returns true if they look the same. This similarity is based on a percentage of difference for big enough values, and for very small values, they are just considered equal whatever happens. This is far from perfect but the purpose is usually just to track blunders in matrix code.

**Return value:**1 if similar, 0 if not.

- Function:
*int***lw6mat_is_similar_i***(int32_t*`i_a`, int32_t`i_b`) `i_a`: 1st value to compare`i_b`: 2nd value to compareCompares two value, and returns true if they look the same. This similarity is based on a percentage of difference for big enough values, and for very small values, they are just considered equal whatever happens. This is far from perfect but the purpose is usually just to track blunders in matrix code.

**Return value:**1 if similar, 0 if not.

- Function:
*int***lw6mat_is_similar_d***(double*`d_a`, double`d_b`) `d_a`: 1st value to compare`d_b`: 2nd value to compareCompares two value, and returns true if they look the same. This similarity is based on a percentage of difference for big enough values, and for very small values, they are just considered equal whatever happens. This is far from perfect but the purpose is usually just to track blunders in matrix code.

**Return value:**1 if similar, 0 if not.

- Function:
*int***lw6mat_is_similar_x***(int32_t*`x_a`, int32_t`x_b`) `x_a`: 1st value to compare`x_b`: 2nd value to compare**Return value:**1 if similar, 0 if not.

- Function:
*int***lw6mat_test_register***(lw6sys_context_t **`sys_context`, int`mode`) `sys_context`: global system context`mode`: test mode (bitmask)Registers all tests for the libmat module.

**Return value:**1 if test is successfull, 0 on error.

- Function:
*int***lw6mat_test_run***(lw6sys_context_t **`sys_context`, int`mode`) `sys_context`: global system context`mode`: test mode (bitmask)Runs the

`mat`

module test suite, testing most (if not all...) functions.**Return value:**1 if test is successfull, 0 on error.

- Struct:
**lw6mat_dmat2_t** -
Double 2x2 matrix (AKA 2D rectangle).

- Member of lw6mat_dmat2_t:
**m** **Type:**`double`

**Definition:**`double lw6mat_dmat2_t::m[LW6MAT_MAT2_M_SIZE][LW6MAT_MAT2_M_SIZE]`

Accessor with 2 dimensions array index. The convention is column-major mode as done in OpenGL so that m[i][j] is element at column i and row j. Beware, this is not the most natural order for a C programmer.

- Member of lw6mat_dmat2_t:
**v** **Type:**`double`

**Definition:**`double lw6mat_dmat2_t::v[LW6MAT_MAT2_V_SIZE_X_SIZE]`

Accessor with flat array index. To access element a column i and row j, use i*2+j.

- Struct:
**lw6mat_dmat3_t** -
Double 3x3 matrix (AKA 3D triangle).

- Member of lw6mat_dmat3_t:
**m** **Type:**`double`

**Definition:**`double lw6mat_dmat3_t::m[LW6MAT_MAT3_M_SIZE][LW6MAT_MAT3_M_SIZE]`

Accessor with 2 dimensions array index. The convention is column-major mode as done in OpenGL so that m[i][j] is element at column i and row j. Beware, this is not the most natural order for a C programmer.

- Member of lw6mat_dmat3_t:
**v** **Type:**`double`

**Definition:**`double lw6mat_dmat3_t::v[LW6MAT_MAT3_V_SIZE_X_SIZE]`

Accessor with flat array index. To access element a column i and row j, use i*3+j.

- Struct:
**lw6mat_dmat4_t** -
Double 4x4 matrix (AKA 3D transformation/composition matrix).

- Member of lw6mat_dmat4_t:
**m** **Type:**`double`

**Definition:**`double lw6mat_dmat4_t::m[LW6MAT_MAT4_M_SIZE][LW6MAT_MAT4_M_SIZE]`

Accessor with 2 dimensions array index. The convention is column-major mode as done in OpenGL so that m[i][j] is element at column i and row j. Beware, this is not the most natural order for a C programmer.

- Member of lw6mat_dmat4_t:
**v** **Type:**`double`

**Definition:**`double lw6mat_dmat4_t::v[LW6MAT_MAT4_V_SIZE_X_SIZE]`

Accessor with flat array index. To access element a column i and row j, use i*4+j.

- Struct:
**lw6mat_dvec2_t** -
Double vector with 2 elements (AKA 2D point).

- Member of lw6mat_dvec2_t:
**x** **Type:**`double`

**Definition:**`double lw6mat_dvec2_t::x`

- Member of lw6mat_dvec2_t:
**y** **Type:**`double`

**Definition:**`double lw6mat_dvec2_t::y`

- Member of lw6mat_dvec2_t:
**p** **Type:**`struct lw6mat_dvec2_t::16`

**Definition:**`struct lw6mat_dvec2_t::16 lw6mat_dvec2_t::p`

Accessor with named/point coords.

- Member of lw6mat_dvec2_t:
**s** **Type:**`double`

**Definition:**`double lw6mat_dvec2_t::s`

- Member of lw6mat_dvec2_t:
**t** **Type:**`double`

**Definition:**`double lw6mat_dvec2_t::t`

- Member of lw6mat_dvec2_t:
**t** **Type:**`struct lw6mat_dvec2_t::17`

**Definition:**`struct lw6mat_dvec2_t::17 lw6mat_dvec2_t::t`

Accessor with texture-like name.

- Member of lw6mat_dvec2_t:
**v** **Type:**`double`

**Definition:**`double lw6mat_dvec2_t::v[LW6MAT_VEC2_V_SIZE]`

Accessor with array index.

- Struct:
**lw6mat_dvec3_t** -
Double vector with 3 elements (AKA 3D point).

- Member of lw6mat_dvec3_t:
**x** **Type:**`double`

**Definition:**`double lw6mat_dvec3_t::x`

- Member of lw6mat_dvec3_t:
**y** **Type:**`double`

**Definition:**`double lw6mat_dvec3_t::y`

- Member of lw6mat_dvec3_t:
**z** **Type:**`double`

**Definition:**`double lw6mat_dvec3_t::z`

- Member of lw6mat_dvec3_t:
**p** **Type:**`struct lw6mat_dvec3_t::18`

**Definition:**`struct lw6mat_dvec3_t::18 lw6mat_dvec3_t::p`

Accessor with named/point coords.

- Member of lw6mat_dvec3_t:
**r** **Type:**`double`

**Definition:**`double lw6mat_dvec3_t::r`

- Member of lw6mat_dvec3_t:
**g** **Type:**`double`

**Definition:**`double lw6mat_dvec3_t::g`

- Member of lw6mat_dvec3_t:
**b** **Type:**`double`

**Definition:**`double lw6mat_dvec3_t::b`

- Member of lw6mat_dvec3_t:
**c** **Type:**`struct lw6mat_dvec3_t::19`

**Definition:**`struct lw6mat_dvec3_t::19 lw6mat_dvec3_t::c`

Accessor with color-like name.

- Member of lw6mat_dvec3_t:
**s** **Type:**`double`

**Definition:**`double lw6mat_dvec3_t::s`

- Member of lw6mat_dvec3_t:
**t** **Type:**`double`

**Definition:**`double lw6mat_dvec3_t::t`

- Member of lw6mat_dvec3_t:
**p** **Type:**`double`

**Definition:**`double lw6mat_dvec3_t::p`

- Member of lw6mat_dvec3_t:
**t** **Type:**`struct lw6mat_dvec3_t::20`

**Definition:**`struct lw6mat_dvec3_t::20 lw6mat_dvec3_t::t`

Accessor with texture-like name.

- Member of lw6mat_dvec3_t:
**v** **Type:**`double`

**Definition:**`double lw6mat_dvec3_t::v[LW6MAT_VEC3_V_SIZE]`

Accessor with array index.

- Member of lw6mat_dvec3_t:
**v2** **Type:**`lw6mat_dvec2_t`

**Definition:**`lw6mat_dvec2_t lw6mat_dvec3_t::v2`

Accessor with smaller-sized vector, only 2 dimensions.

- Struct:
**lw6mat_dvec4_t** -
Double vector with 4 elements (AKA quaternion).

- Member of lw6mat_dvec4_t:
**x** **Type:**`double`

**Definition:**`double lw6mat_dvec4_t::x`

- Member of lw6mat_dvec4_t:
**y** **Type:**`double`

**Definition:**`double lw6mat_dvec4_t::y`

- Member of lw6mat_dvec4_t:
**z** **Type:**`double`

**Definition:**`double lw6mat_dvec4_t::z`

- Member of lw6mat_dvec4_t:
**w** **Type:**`double`

**Definition:**`double lw6mat_dvec4_t::w`

- Member of lw6mat_dvec4_t:
**p** **Type:**`struct lw6mat_dvec4_t::21`

**Definition:**`struct lw6mat_dvec4_t::21 lw6mat_dvec4_t::p`

Accessor with named/point coords.

- Member of lw6mat_dvec4_t:
**r** **Type:**`double`

**Definition:**`double lw6mat_dvec4_t::r`

- Member of lw6mat_dvec4_t:
**g** **Type:**`double`

**Definition:**`double lw6mat_dvec4_t::g`

- Member of lw6mat_dvec4_t:
**b** **Type:**`double`

**Definition:**`double lw6mat_dvec4_t::b`

- Member of lw6mat_dvec4_t:
**a** **Type:**`double`

**Definition:**`double lw6mat_dvec4_t::a`

- Member of lw6mat_dvec4_t:
**c** **Type:**`struct lw6mat_dvec4_t::22`

**Definition:**`struct lw6mat_dvec4_t::22 lw6mat_dvec4_t::c`

Accessor with color-like name.

- Member of lw6mat_dvec4_t:
**s** **Type:**`double`

**Definition:**`double lw6mat_dvec4_t::s`

- Member of lw6mat_dvec4_t:
**t** **Type:**`double`

**Definition:**`double lw6mat_dvec4_t::t`

- Member of lw6mat_dvec4_t:
**p** **Type:**`double`

**Definition:**`double lw6mat_dvec4_t::p`

- Member of lw6mat_dvec4_t:
**q** **Type:**`double`

**Definition:**`double lw6mat_dvec4_t::q`

- Member of lw6mat_dvec4_t:
**t** **Type:**`struct lw6mat_dvec4_t::23`

**Definition:**`struct lw6mat_dvec4_t::23 lw6mat_dvec4_t::t`

Accessor with texture-like name.

- Member of lw6mat_dvec4_t:
**v** **Type:**`double`

**Definition:**`double lw6mat_dvec4_t::v[LW6MAT_VEC4_V_SIZE]`

Accessor with array index.

- Member of lw6mat_dvec4_t:
**v2** **Type:**`lw6mat_dvec2_t`

**Definition:**`lw6mat_dvec2_t lw6mat_dvec4_t::v2`

Accessor with smaller-sized vector, only 2 dimensions.

- Member of lw6mat_dvec4_t:
**v3** **Type:**`lw6mat_dvec3_t`

**Definition:**`lw6mat_dvec3_t lw6mat_dvec4_t::v3`

Accessor with smaller-sized vector, only 3 dimensions.

- Struct:
**lw6mat_fmat2_t** -
Float 2x2 matrix (AKA 2D rectangle).

- Member of lw6mat_fmat2_t:
**m** **Type:**`float`

**Definition:**`float lw6mat_fmat2_t::m[LW6MAT_MAT2_M_SIZE][LW6MAT_MAT2_M_SIZE]`

- Member of lw6mat_fmat2_t:
**v** **Type:**`float`

**Definition:**`float lw6mat_fmat2_t::v[LW6MAT_MAT2_V_SIZE_X_SIZE]`

Accessor with flat array index. To access element a column i and row j, use i*4+j.

- Struct:
**lw6mat_fmat3_t** -
Float 3x3 matrix (AKA 3D triangle).

- Member of lw6mat_fmat3_t:
**m** **Type:**`float`

**Definition:**`float lw6mat_fmat3_t::m[LW6MAT_MAT3_M_SIZE][LW6MAT_MAT3_M_SIZE]`

- Member of lw6mat_fmat3_t:
**v** **Type:**`float`

**Definition:**`float lw6mat_fmat3_t::v[LW6MAT_MAT3_V_SIZE_X_SIZE]`

Accessor with flat array index. To access element a column i and row j, use i*3+j.

- Struct:
**lw6mat_fmat4_t** -
Float 4x4 matrix (AKA 3D transformation/composition matrix).

- Member of lw6mat_fmat4_t:
**m** **Type:**`float`

**Definition:**`float lw6mat_fmat4_t::m[LW6MAT_MAT4_M_SIZE][LW6MAT_MAT4_M_SIZE]`

- Member of lw6mat_fmat4_t:
**v** **Type:**`float`

**Definition:**`float lw6mat_fmat4_t::v[LW6MAT_MAT4_V_SIZE_X_SIZE]`

Accessor with flat array index. To access element a column i and row j, use i*4+j.

- Struct:
**lw6mat_fvec2_t** -
Float vector with 2 elements (AKA 2D point).

- Member of lw6mat_fvec2_t:
**x** **Type:**`float`

**Definition:**`float lw6mat_fvec2_t::x`

- Member of lw6mat_fvec2_t:
**y** **Type:**`float`

**Definition:**`float lw6mat_fvec2_t::y`

- Member of lw6mat_fvec2_t:
**p** **Type:**`struct lw6mat_fvec2_t::0`

**Definition:**`struct lw6mat_fvec2_t::0 lw6mat_fvec2_t::p`

Accessor with named/point coords.

- Member of lw6mat_fvec2_t:
**s** **Type:**`float`

**Definition:**`float lw6mat_fvec2_t::s`

- Member of lw6mat_fvec2_t:
**t** **Type:**`float`

**Definition:**`float lw6mat_fvec2_t::t`

- Member of lw6mat_fvec2_t:
**t** **Type:**`struct lw6mat_fvec2_t::1`

**Definition:**`struct lw6mat_fvec2_t::1 lw6mat_fvec2_t::t`

Accessor with texture-like name.

- Member of lw6mat_fvec2_t:
**v** **Type:**`float`

**Definition:**`float lw6mat_fvec2_t::v[LW6MAT_VEC2_V_SIZE]`

Accessor with array index.

- Struct:
**lw6mat_fvec3_t** -
Float vector with 3 elements (AKA 3D point).

- Member of lw6mat_fvec3_t:
**x** **Type:**`float`

**Definition:**`float lw6mat_fvec3_t::x`

- Member of lw6mat_fvec3_t:
**y** **Type:**`float`

**Definition:**`float lw6mat_fvec3_t::y`

- Member of lw6mat_fvec3_t:
**z** **Type:**`float`

**Definition:**`float lw6mat_fvec3_t::z`

- Member of lw6mat_fvec3_t:
**p** **Type:**`struct lw6mat_fvec3_t::2`

**Definition:**`struct lw6mat_fvec3_t::2 lw6mat_fvec3_t::p`

Accessor with named/point coords.

- Member of lw6mat_fvec3_t:
**r** **Type:**`float`

**Definition:**`float lw6mat_fvec3_t::r`

- Member of lw6mat_fvec3_t:
**g** **Type:**`float`

**Definition:**`float lw6mat_fvec3_t::g`

- Member of lw6mat_fvec3_t:
**b** **Type:**`float`

**Definition:**`float lw6mat_fvec3_t::b`

- Member of lw6mat_fvec3_t:
**c** **Type:**`struct lw6mat_fvec3_t::3`

**Definition:**`struct lw6mat_fvec3_t::3 lw6mat_fvec3_t::c`

Accessor with color-like name.

- Member of lw6mat_fvec3_t:
**s** **Type:**`float`

**Definition:**`float lw6mat_fvec3_t::s`

- Member of lw6mat_fvec3_t:
**t** **Type:**`float`

**Definition:**`float lw6mat_fvec3_t::t`

- Member of lw6mat_fvec3_t:
**p** **Type:**`float`

**Definition:**`float lw6mat_fvec3_t::p`

- Member of lw6mat_fvec3_t:
**t** **Type:**`struct lw6mat_fvec3_t::4`

**Definition:**`struct lw6mat_fvec3_t::4 lw6mat_fvec3_t::t`

Accessor with texture-like name.

- Member of lw6mat_fvec3_t:
**v** **Type:**`float`

**Definition:**`float lw6mat_fvec3_t::v[LW6MAT_VEC3_V_SIZE]`

Accessor with array index.

- Member of lw6mat_fvec3_t:
**v2** **Type:**`lw6mat_fvec2_t`

**Definition:**`lw6mat_fvec2_t lw6mat_fvec3_t::v2`

Accessor with smaller-sized vector, only 2 dimensions.

- Struct:
**lw6mat_fvec4_t** -
Float vector with 4 elements (AKA quaternion).

- Member of lw6mat_fvec4_t:
**x** **Type:**`float`

**Definition:**`float lw6mat_fvec4_t::x`

- Member of lw6mat_fvec4_t:
**y** **Type:**`float`

**Definition:**`float lw6mat_fvec4_t::y`

- Member of lw6mat_fvec4_t:
**z** **Type:**`float`

**Definition:**`float lw6mat_fvec4_t::z`

- Member of lw6mat_fvec4_t:
**w** **Type:**`float`

**Definition:**`float lw6mat_fvec4_t::w`

- Member of lw6mat_fvec4_t:
**p** **Type:**`struct lw6mat_fvec4_t::5`

**Definition:**`struct lw6mat_fvec4_t::5 lw6mat_fvec4_t::p`

Accessor with named/point coords.

- Member of lw6mat_fvec4_t:
**r** **Type:**`float`

**Definition:**`float lw6mat_fvec4_t::r`

- Member of lw6mat_fvec4_t:
**g** **Type:**`float`

**Definition:**`float lw6mat_fvec4_t::g`

- Member of lw6mat_fvec4_t:
**b** **Type:**`float`

**Definition:**`float lw6mat_fvec4_t::b`

- Member of lw6mat_fvec4_t:
**a** **Type:**`float`

**Definition:**`float lw6mat_fvec4_t::a`

- Member of lw6mat_fvec4_t:
**c** **Type:**`struct lw6mat_fvec4_t::6`

**Definition:**`struct lw6mat_fvec4_t::6 lw6mat_fvec4_t::c`

Accessor with color-like name.

- Member of lw6mat_fvec4_t:
**s** **Type:**`float`

**Definition:**`float lw6mat_fvec4_t::s`

- Member of lw6mat_fvec4_t:
**t** **Type:**`float`

**Definition:**`float lw6mat_fvec4_t::t`

- Member of lw6mat_fvec4_t:
**p** **Type:**`float`

**Definition:**`float lw6mat_fvec4_t::p`

- Member of lw6mat_fvec4_t:
**q** **Type:**`float`

**Definition:**`float lw6mat_fvec4_t::q`

- Member of lw6mat_fvec4_t:
**t** **Type:**`struct lw6mat_fvec4_t::7`

**Definition:**`struct lw6mat_fvec4_t::7 lw6mat_fvec4_t::t`

Accessor with texture-like name.

- Member of lw6mat_fvec4_t:
**v** **Type:**`float`

**Definition:**`float lw6mat_fvec4_t::v[LW6MAT_VEC4_V_SIZE]`

Accessor with array index.

- Member of lw6mat_fvec4_t:
**v2** **Type:**`lw6mat_fvec2_t`

**Definition:**`lw6mat_fvec2_t lw6mat_fvec4_t::v2`

Accessor with smaller-sized vector, only 2 dimensions.

- Member of lw6mat_fvec4_t:
**v3** **Type:**`lw6mat_fvec3_t`

**Definition:**`lw6mat_fvec3_t lw6mat_fvec4_t::v3`

Accessor with smaller-sized vector, only 3 dimensions.

- Struct:
**lw6mat_imat2_t** -
Integer 2x2 matrix (AKA 2D rectangle).

- Member of lw6mat_imat2_t:
**m** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_imat2_t::m[LW6MAT_MAT2_M_SIZE][LW6MAT_MAT2_M_SIZE]`

- Member of lw6mat_imat2_t:
**v** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_imat2_t::v[LW6MAT_MAT2_V_SIZE_X_SIZE]`

Accessor with flat array index. To access element a column i and row j, use i*2+j.

- Struct:
**lw6mat_imat3_t** -
Integer 3x3 matrix (AKA 3D triangle).

- Member of lw6mat_imat3_t:
**m** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_imat3_t::m[LW6MAT_MAT3_M_SIZE][LW6MAT_MAT3_M_SIZE]`

- Member of lw6mat_imat3_t:
**v** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_imat3_t::v[LW6MAT_MAT3_V_SIZE_X_SIZE]`

Accessor with flat array index. To access element a column i and row j, use i*3+j.

- Struct:
**lw6mat_imat4_t** -
Integer 4x4 matrix (AKA 3D transformation/composition matrix).

- Member of lw6mat_imat4_t:
**m** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_imat4_t::m[LW6MAT_MAT4_M_SIZE][LW6MAT_MAT4_M_SIZE]`

- Member of lw6mat_imat4_t:
**v** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_imat4_t::v[LW6MAT_MAT4_V_SIZE_X_SIZE]`

Accessor with flat array index. To access element a column i and row j, use i*4+j.

- Struct:
**lw6mat_ivec2_t** -
Integer vector with 2 elements (AKA 2D point).

- Member of lw6mat_ivec2_t:
**x** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_ivec2_t::x`

- Member of lw6mat_ivec2_t:
**y** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_ivec2_t::y`

- Member of lw6mat_ivec2_t:
**p** **Type:**`struct lw6mat_ivec2_t::8`

**Definition:**`struct lw6mat_ivec2_t::8 lw6mat_ivec2_t::p`

Accessor with named/point coords.

- Member of lw6mat_ivec2_t:
**s** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_ivec2_t::s`

- Member of lw6mat_ivec2_t:
**t** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_ivec2_t::t`

- Member of lw6mat_ivec2_t:
**t** **Type:**`struct lw6mat_ivec2_t::9`

**Definition:**`struct lw6mat_ivec2_t::9 lw6mat_ivec2_t::t`

Accessor with texture-like name.

- Member of lw6mat_ivec2_t:
**v** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_ivec2_t::v[LW6MAT_VEC2_V_SIZE]`

Accessor with array index.

- Struct:
**lw6mat_ivec3_t** -
Integer vector with 3 elements (AKA 3D point).

- Member of lw6mat_ivec3_t:
**x** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_ivec3_t::x`

- Member of lw6mat_ivec3_t:
**y** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_ivec3_t::y`

- Member of lw6mat_ivec3_t:
**z** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_ivec3_t::z`

- Member of lw6mat_ivec3_t:
**p** **Type:**`struct lw6mat_ivec3_t::10`

**Definition:**`struct lw6mat_ivec3_t::10 lw6mat_ivec3_t::p`

Accessor with named/point coords.

- Member of lw6mat_ivec3_t:
**r** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_ivec3_t::r`

- Member of lw6mat_ivec3_t:
**g** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_ivec3_t::g`

- Member of lw6mat_ivec3_t:
**b** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_ivec3_t::b`

- Member of lw6mat_ivec3_t:
**c** **Type:**`struct lw6mat_ivec3_t::11`

**Definition:**`struct lw6mat_ivec3_t::11 lw6mat_ivec3_t::c`

Accessor with color-like name.

- Member of lw6mat_ivec3_t:
**s** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_ivec3_t::s`

- Member of lw6mat_ivec3_t:
**t** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_ivec3_t::t`

- Member of lw6mat_ivec3_t:
**p** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_ivec3_t::p`

- Member of lw6mat_ivec3_t:
**t** **Type:**`struct lw6mat_ivec3_t::12`

**Definition:**`struct lw6mat_ivec3_t::12 lw6mat_ivec3_t::t`

Accessor with texture-like name.

- Member of lw6mat_ivec3_t:
**v** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_ivec3_t::v[LW6MAT_VEC3_V_SIZE]`

Accessor with array index.

- Struct:
**lw6mat_ivec4_t** -
Integer vector with 4 elements (AKA quaternion).

- Member of lw6mat_ivec4_t:
**x** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_ivec4_t::x`

- Member of lw6mat_ivec4_t:
**y** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_ivec4_t::y`

- Member of lw6mat_ivec4_t:
**z** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_ivec4_t::z`

- Member of lw6mat_ivec4_t:
**w** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_ivec4_t::w`

- Member of lw6mat_ivec4_t:
**p** **Type:**`struct lw6mat_ivec4_t::13`

**Definition:**`struct lw6mat_ivec4_t::13 lw6mat_ivec4_t::p`

Accessor with named/point coords.

- Member of lw6mat_ivec4_t:
**r** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_ivec4_t::r`

- Member of lw6mat_ivec4_t:
**g** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_ivec4_t::g`

- Member of lw6mat_ivec4_t:
**b** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_ivec4_t::b`

- Member of lw6mat_ivec4_t:
**a** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_ivec4_t::a`

- Member of lw6mat_ivec4_t:
**c** **Type:**`struct lw6mat_ivec4_t::14`

**Definition:**`struct lw6mat_ivec4_t::14 lw6mat_ivec4_t::c`

Accessor with color-like name.

- Member of lw6mat_ivec4_t:
**s** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_ivec4_t::s`

- Member of lw6mat_ivec4_t:
**t** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_ivec4_t::t`

- Member of lw6mat_ivec4_t:
**p** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_ivec4_t::p`

- Member of lw6mat_ivec4_t:
**q** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_ivec4_t::q`

- Member of lw6mat_ivec4_t:
**t** **Type:**`struct lw6mat_ivec4_t::15`

**Definition:**`struct lw6mat_ivec4_t::15 lw6mat_ivec4_t::t`

Accessor with texture-like name.

- Member of lw6mat_ivec4_t:
**v** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_ivec4_t::v[LW6MAT_VEC4_V_SIZE]`

Accessor with array index.

- Struct:
**lw6mat_xmat2_t** -
Fixed Point 2x2 matrix (AKA 2D rectangle).

- Member of lw6mat_xmat2_t:
**m** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_xmat2_t::m[LW6MAT_MAT2_M_SIZE][LW6MAT_MAT2_M_SIZE]`

- Member of lw6mat_xmat2_t:
**v** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_xmat2_t::v[LW6MAT_MAT2_V_SIZE_X_SIZE]`

Accessor with flat array index. To access element a column i and row j, use i*3+j.

- Struct:
**lw6mat_xmat3_t** -
Fixed Point 3x3 matrix (AKA 3D triangle).

- Member of lw6mat_xmat3_t:
**m** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_xmat3_t::m[LW6MAT_MAT3_M_SIZE][LW6MAT_MAT3_M_SIZE]`

- Member of lw6mat_xmat3_t:
**v** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_xmat3_t::v[LW6MAT_MAT3_V_SIZE_X_SIZE]`

Accessor with flat array index. To access element a column i and row j, use i*3+j.

- Struct:
**lw6mat_xmat4_t** -
Fixed Point 4x4 matrix (AKA 3D transformation/composition matrix).

- Member of lw6mat_xmat4_t:
**m** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_xmat4_t::m[LW6MAT_MAT4_M_SIZE][LW6MAT_MAT4_M_SIZE]`

- Member of lw6mat_xmat4_t:
**v** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_xmat4_t::v[LW6MAT_MAT4_V_SIZE_X_SIZE]`

Accessor with flat array index. To access element a column i and row j, use i*4+j.

- Struct:
**lw6mat_xvec2_t** -
Fixed Point vector with 2 elements (AKA 2D point).

- Member of lw6mat_xvec2_t:
**x** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_xvec2_t::x`

- Member of lw6mat_xvec2_t:
**y** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_xvec2_t::y`

- Member of lw6mat_xvec2_t:
**p** **Type:**`struct lw6mat_xvec2_t::24`

**Definition:**`struct lw6mat_xvec2_t::24 lw6mat_xvec2_t::p`

Accessor with named/point coords.

- Member of lw6mat_xvec2_t:
**s** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_xvec2_t::s`

- Member of lw6mat_xvec2_t:
**t** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_xvec2_t::t`

- Member of lw6mat_xvec2_t:
**t** **Type:**`struct lw6mat_xvec2_t::25`

**Definition:**`struct lw6mat_xvec2_t::25 lw6mat_xvec2_t::t`

Accessor with texture-like name.

- Member of lw6mat_xvec2_t:
**v** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_xvec2_t::v[LW6MAT_VEC2_V_SIZE]`

Accessor with array index.

- Struct:
**lw6mat_xvec3_t** -
Fixed Point vector with 3 elements (AKA 3D point).

- Member of lw6mat_xvec3_t:
**x** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_xvec3_t::x`

- Member of lw6mat_xvec3_t:
**y** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_xvec3_t::y`

- Member of lw6mat_xvec3_t:
**z** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_xvec3_t::z`

- Member of lw6mat_xvec3_t:
**p** **Type:**`struct lw6mat_xvec3_t::26`

**Definition:**`struct lw6mat_xvec3_t::26 lw6mat_xvec3_t::p`

Accessor with named/point coords.

- Member of lw6mat_xvec3_t:
**r** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_xvec3_t::r`

- Member of lw6mat_xvec3_t:
**g** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_xvec3_t::g`

- Member of lw6mat_xvec3_t:
**b** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_xvec3_t::b`

- Member of lw6mat_xvec3_t:
**c** **Type:**`struct lw6mat_xvec3_t::27`

**Definition:**`struct lw6mat_xvec3_t::27 lw6mat_xvec3_t::c`

Accessor with color-like name.

- Member of lw6mat_xvec3_t:
**s** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_xvec3_t::s`

- Member of lw6mat_xvec3_t:
**t** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_xvec3_t::t`

- Member of lw6mat_xvec3_t:
**p** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_xvec3_t::p`

- Member of lw6mat_xvec3_t:
**t** **Type:**`struct lw6mat_xvec3_t::28`

**Definition:**`struct lw6mat_xvec3_t::28 lw6mat_xvec3_t::t`

Accessor with texture-like name.

- Member of lw6mat_xvec3_t:
**v** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_xvec3_t::v[LW6MAT_VEC3_V_SIZE]`

Accessor with array index.

- Struct:
**lw6mat_xvec4_t** -
Fixed Point vector with 4 elements (AKA quaternion).

- Member of lw6mat_xvec4_t:
**x** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_xvec4_t::x`

- Member of lw6mat_xvec4_t:
**y** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_xvec4_t::y`

- Member of lw6mat_xvec4_t:
**z** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_xvec4_t::z`

- Member of lw6mat_xvec4_t:
**w** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_xvec4_t::w`

- Member of lw6mat_xvec4_t:
**p** **Type:**`struct lw6mat_xvec4_t::29`

**Definition:**`struct lw6mat_xvec4_t::29 lw6mat_xvec4_t::p`

Accessor with named/point coords.

- Member of lw6mat_xvec4_t:
**r** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_xvec4_t::r`

- Member of lw6mat_xvec4_t:
**g** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_xvec4_t::g`

- Member of lw6mat_xvec4_t:
**b** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_xvec4_t::b`

- Member of lw6mat_xvec4_t:
**a** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_xvec4_t::a`

- Member of lw6mat_xvec4_t:
**c** **Type:**`struct lw6mat_xvec4_t::30`

**Definition:**`struct lw6mat_xvec4_t::30 lw6mat_xvec4_t::c`

Accessor with color-like name.

- Member of lw6mat_xvec4_t:
**s** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_xvec4_t::s`

- Member of lw6mat_xvec4_t:
**t** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_xvec4_t::t`

- Member of lw6mat_xvec4_t:
**p** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_xvec4_t::p`

- Member of lw6mat_xvec4_t:
**q** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_xvec4_t::q`

- Member of lw6mat_xvec4_t:
**t** **Type:**`struct lw6mat_xvec4_t::31`

**Definition:**`struct lw6mat_xvec4_t::31 lw6mat_xvec4_t::t`

Accessor with texture-like name.

- Member of lw6mat_xvec4_t:
**v** **Type:**`int32_t`

**Definition:**`int32_t lw6mat_xvec4_t::v[LW6MAT_VEC4_V_SIZE]`

Accessor with array index.