BrawlLib.Internal.Matrix34 Struct Reference

Public Member Functions
	Matrix34 (params float[] values)
void	Translate (float x, float y, float z)
Matrix34	GetTranslation ()
void	RotateX (float x)
void	RotateY (float y)
void	RotateZ (float z)
void	Multiply (Matrix34 *m)
Vector3	Multiply (Vector3 v)
void	Add (Matrix34 *m)
void	Subtract (Matrix34 *m)
override bool	Equals (object obj)
override int	GetHashCode ()
override string	ToString ()

Static Public Member Functions
static Matrix34	ScaleMatrix (float x, float y, float z)
static Matrix34	TranslationMatrix (float x, float y, float z)
static Matrix34	RotationMatrixX (float x)
static Matrix34	RotationMatrixRX (float x)
static Matrix34	RotationMatrixY (float y)
static Matrix34	RotationMatrixRY (float y)
static Matrix34	RotationMatrix (float x, float y, float z)
static Matrix34	TransformationMatrix (Vector3 scale, Vector3 rotation, Vector3 translation)
static Matrix34	ReverseTransformMatrix (Vector3 scale, Vector3 rotation, Vector3 translation)
static Matrix34	TextureMatrix (TextureFrameState state)
static Matrix34	EnvironmentTexMtx ()
static Matrix	EnvCamMap (int refCam, SCN0Node node, ModelPanelViewport v, float frame)
static Matrix	EnvLightMap (int refLight, SCN0Node node, ModelPanelViewport v, float frame)
static Matrix	ProjectionMapping (int ref_camera, SCN0Node node, ModelPanelViewport v, float frame)
static Matrix	EnvSpecMap (int refCam, int refLight, SCN0Node node, ModelPanelViewport v, float frame)
	This function returns a texture matrix that will aim the texture to the midpoint between the active camera and the given reference camera or light. More...
static Matrix34	operator* (Matrix34 m1, Matrix34 m2)
static bool	operator== (Matrix34 m1, Matrix34 m2)
static bool	operator!= (Matrix34 m1, Matrix34 m2)

Static Public Attributes
static readonly Matrix34	Identity = ScaleMatrix(1.0f, 1.0f, 1.0f)

Properties
float	this[int index] [get, set]

Constructor & Destructor Documentation

Matrix34()

BrawlLib.Internal.Matrix34.Matrix34 ( params float[]  values )

inline

        {
            fixed (float* b = _data)
            {
                for (int i = 0; i < Math.Min(12, values.Length); i++)
                {
                    b[i] = values[i];
                }
            }
        }

Member Function Documentation

Add()

void BrawlLib.Internal.Matrix34.Add ( Matrix34 *  m )

inline

        {
            float* s = (float*) m;
            fixed (float* d = _data)
            {
                for (int i = 0; i < 12; i++)
                {
                    d[i] += s[i];
                }
            }
        }

EnvCamMap()

static Matrix BrawlLib.Internal.Matrix34.EnvCamMap ( int  refCam, SCN0Node  node, ModelPanelViewport  v, float  frame  )

inlinestatic

        {
            GLCamera cam = v.Camera;
            if (refCam >= 0 && node?.CameraGroup != null && refCam < node.CameraGroup.Children.Count)
            {
                SCN0CameraNode camNode = (SCN0CameraNode) node.CameraGroup.Children[refCam];
                camNode.GetModelViewMatrix(frame, out Matrix cm, out Matrix cmInv);
                return (Matrix) EnvironmentTexMtx() * cm.GetRotationMatrix();
            }
 
            return (Matrix) EnvironmentTexMtx() * v.Camera._matrix.GetRotationMatrix();
        }

EnvironmentTexMtx()

static Matrix34 BrawlLib.Internal.Matrix34.EnvironmentTexMtx ( )

inlinestatic

        {
            Matrix34 m = Identity;
            m[0] = 0.5f;
            m[3] = 0.5f;
            m[5] = -0.5f;
            m[7] = 0.5f;
            m[10] = 0.0f;
            m[11] = 1.0f;
            return m;
        }

EnvLightMap()

static Matrix BrawlLib.Internal.Matrix34.EnvLightMap ( int  refLight, SCN0Node  node, ModelPanelViewport  v, float  frame  )

inlinestatic

        {
            Matrix m = Matrix.Identity;
            GLCamera cam = v.Camera;
            Matrix camMtx = cam._matrix;
            Matrix invCamMtx = cam._matrixInverse;
 
            Matrix34 envMtx = new Matrix34(
                0.5f, 0.0f, 0.0f, 0.5f,
                0.0f, -0.5f, 0.0f, 0.5f,
                0.0f, 0.0f, 0.0f, 1.0f);
 
            //If no light is referenced, use the BrawlCrate built-in light
            if (refLight < 0 || node?.LightGroup != null && refLight >= node.LightGroup.Children.Count)
            {
                refLight = 0;
                node = null;
            }
 
            // The light position and direction needs to be transformed with the camera's inverse matrix.
            Vector3 vLook, camUp, vRight, vUp;
 
            vLook = GetLightLook(node, refLight, invCamMtx, v, frame, out bool specEnabled).Normalize();
 
            // Calculate without using a target because the margin of error for calculations must be taken into account when the light is far away.
            // Take the absolute value as a measure against transformation margin.
            if (Math.Abs(vLook._x) < 0.000001f &&
                Math.Abs(vLook._z) < 0.000001f)
            {
                camUp._x = camUp._y = 0.0f;
                if (vLook._y <= 0.0f)
                {
                    // Look straight down
                    camUp._z = -1.0f;
                }
                else
                {
                    // Look straight up
                    camUp._z = 1.0f;
                }
            }
            else
            {
                camUp._x = camUp._z = 0.0f;
                camUp._y = 1.0f;
            }
 
            vUp = (vRight = vLook.Cross(camUp).Normalize()).Cross(vLook);
 
            Matrix34 m34 = new Matrix34(
                vRight._x, vRight._y, vRight._z, 0.0f,
                vUp._x, vUp._y, vUp._z, 0.0f,
                -vLook._x, -vLook._y, -vLook._z, 0.0f);
 
            m34 = (Matrix34) ((Matrix) m34 * invCamMtx);
 
            m34[3] = 0.0f;
            m34[7] = 0.0f;
            m34[11] = 0.0f;
 
            return (Matrix) (envMtx * m34);
 
            //return (Matrix)envMtx * Matrix.RotationMatrix(new Vector3().LookatAngles((Vector3)v._posLight) * Maths._rad2degf);
        }

EnvSpecMap()

static Matrix BrawlLib.Internal.Matrix34.EnvSpecMap ( int  refCam, int  refLight, SCN0Node  node, ModelPanelViewport  v, float  frame  )

inlinestatic

This function returns a texture matrix that will aim the texture to the midpoint between the active camera and the given reference camera or light.

        {
            // Normal environmental map when neither the light nor the camera is specified.
            Matrix34 finalMtx = EnvironmentTexMtx();
 
            GLCamera cam = v.Camera;
            Vector3 vLook, camUp, camLook;
            Matrix camMtx = cam._matrixInverse;
            Matrix invCamMtx = cam._matrix;
 
            Matrix34 m34 = (Matrix34) camMtx;
            camLook._x = -m34[8];
            camLook._y = -m34[9];
            camLook._z = -m34[10];
 
            if (refLight >= 0)
            {
                Vector3 lgtLook = GetLightLook(node, refLight, invCamMtx, v, frame, out bool specEnabled);
 
                // Specular light is already set as a vector taking the center position.
                if (!specEnabled)
                {
                    vLook = GetHalfAngle(camLook, lgtLook);
                }
                else
                {
                    vLook = -lgtLook;
                }
 
                if (Math.Abs(vLook._x) < 0.000001f &&
                    Math.Abs(vLook._z) < 0.000001f)
                {
                    camUp._x = camUp._y = 0.0f;
                    if (vLook._y <= 0.0f)
                    {
                        // Look straight down
                        camUp._z = -1.0f;
                    }
                    else
                    {
                        // Look straight up
                        camUp._z = 1.0f;
                    }
                }
                else
                {
                    camUp._x = camUp._z = 0.0f;
                    camUp._y = 1.0f;
                }
            }
            else if (refCam >= 0)
            {
                SCN0CameraNode camNode = null;
 
                if (node?.CameraGroup != null && refCam < node.CameraGroup.Children.Count)
                {
                    camNode = (SCN0CameraNode) node.CameraGroup.Children[refCam];
                }
                else
                {
                    camNode = new SCN0CameraNode();
                }
 
                camNode.GetModelViewMatrix(frame, out Matrix cM, out Matrix cMInv);
 
                // Map from the midpoint of the view camera and the specified camera.
                Matrix34 lgtCam = (Matrix34) cM;
                camUp._x = lgtCam[4];
                camUp._y = lgtCam[5];
                camUp._z = lgtCam[6];
                Vector3 lgtLook = new Vector3(-lgtCam[8], -lgtCam[9], -lgtCam[10]);
 
                vLook = GetHalfAngle(camLook, lgtLook);
            }
            else
            {
                return (Matrix) finalMtx;
            }
 
            vLook.Normalize();
            Vector3 vRight, vUp;
 
            vUp = (vRight = vLook.Cross(camUp).Normalize()).Cross(vLook);
            m34 = new Matrix34(
                vRight._x, vRight._y, vRight._z, 0.0f,
                vUp._x, vUp._y, vUp._z, 0.0f,
                vLook._x, vLook._y, vLook._z, 0.0f);
 
            m34 = (Matrix34) ((Matrix) m34 * invCamMtx);
            m34[3] = 0.0f;
            m34[7] = 0.0f;
            m34[11] = 0.0f;
 
            return (Matrix) (finalMtx * m34);
        }

Equals()

override bool BrawlLib.Internal.Matrix34.Equals ( object  obj )

inline

        {
            if (obj is Matrix34 matrix34)
            {
                return matrix34 == this;
            }
 
            return base.Equals(obj);
        }

GetHashCode()

override int BrawlLib.Internal.Matrix34.GetHashCode ( )

inline

        {
            return base.GetHashCode();
        }

GetTranslation()

Matrix34 BrawlLib.Internal.Matrix34.GetTranslation ( )

inline

        {
            Matrix34 m = Identity;
            float* p = (float*) &m;
            fixed (float* s = _data)
            {
                p[3] = s[3];
                p[7] = s[7];
                p[11] = s[11];
            }
 
            return m;
        }

Multiply() [1/2]

void BrawlLib.Internal.Matrix34.Multiply ( Matrix34 *  m )

inline

        {
            Matrix34 m2 = this;
 
            float* s1 = (float*) &m2, s2 = (float*) m;
 
            fixed (float* p = _data)
            {
                int index = 0;
                float val;
                for (int b = 0; b < 12; b += 4)
                {
                    for (int a = 0; a < 4; a++)
                    {
                        val = 0.0f;
                        for (int x = b, y = a; y < 12; y += 4)
                        {
                            val += s1[x++] * s2[y];
                        }
 
                        p[index++] = val;
                    }
                }
 
                p[3] += s1[3];
                p[7] += s1[7];
                p[11] += s1[11];
            }
        }

Multiply() [2/2]

Vector3 BrawlLib.Internal.Matrix34.Multiply ( Vector3  v )

inline

        {
            Vector3 nv = new Vector3();
            fixed (float* p = _data)
            {
                nv._x = p[0] * v._x + p[1] * v._y + p[2] * v._z + p[3];
                nv._y = p[4] * v._x + p[5] * v._y + p[6] * v._z + p[7];
                nv._z = p[8] * v._x + p[9] * v._y + p[10] * v._z + p[11];
            }
 
            return nv;
        }

operator!=()

static bool BrawlLib.Internal.Matrix34.operator!= ( Matrix34  m1, Matrix34  m2  )

inlinestatic

        {
            return !(m1 == m2);
        }

operator*()

static Matrix34 BrawlLib.Internal.Matrix34.operator* ( Matrix34  m1, Matrix34  m2  )

inlinestatic

        {
            Matrix34 m;
 
            float* s1 = (float*) &m1, s2 = (float*) &m2, p = (float*) &m;
 
            int index = 0;
            float val;
            for (int b = 0; b < 12; b += 4)
            {
                for (int a = 0; a < 4; a++)
                {
                    val = 0.0f;
                    for (int x = b, y = a; y < 12; y += 4)
                    {
                        val += s1[x++] * s2[y];
                    }
 
                    p[index++] = val;
                }
            }
 
            p[3] += s1[3];
            p[7] += s1[7];
            p[11] += s1[11];
 
            return m;
        }

operator==()

static bool BrawlLib.Internal.Matrix34.operator== ( Matrix34  m1, Matrix34  m2  )

inlinestatic

        {
            float* p1 = (float*) &m1, p2 = (float*) &m2;
            for (int i = 0; i < 12; i++)
            {
                if (*p1++ != *p2++)
                {
                    return false;
                }
            }
 
            return true;
        }

ProjectionMapping()

static Matrix BrawlLib.Internal.Matrix34.ProjectionMapping ( int  ref_camera, SCN0Node  node, ModelPanelViewport  v, float  frame  )

inlinestatic

        {
            Matrix projMtx = Matrix.Identity;
            Matrix camMtx = Matrix.Identity;
            GLCamera cam = v.Camera;
            if (ref_camera >= 0 && node?.CameraGroup != null && ref_camera < node.CameraGroup.Children.Count)
            {
                // Set so that the image is projected from the specified camera.
                // Transform to the viewing coordinate system of the specified camera
                SCN0CameraNode camNode = (SCN0CameraNode) node.CameraGroup.Children[ref_camera];
                camNode.GetModelViewMatrix(frame, out Matrix cm, out Matrix cmInv);
                camMtx = cm * cam._matrix;
                projMtx = (Matrix) ProjectionTexMtx(camNode, frame);
            }
            else
            {
                camMtx = cam._matrix;
                projMtx = (Matrix) ProjectionTexMtx(cam);
            }
 
            return projMtx * camMtx;
        }

ReverseTransformMatrix()

static Matrix34 BrawlLib.Internal.Matrix34.ReverseTransformMatrix ( Vector3  scale, Vector3  rotation, Vector3  translation  )

inlinestatic

        {
            float cosx = (float) Math.Cos(rotation._x / 180.0 * Math.PI);
            float sinx = (float) Math.Sin(rotation._x / 180.0 * Math.PI);
            float cosy = (float) Math.Cos(rotation._y / 180.0 * Math.PI);
            float siny = (float) Math.Sin(rotation._y / 180.0 * Math.PI);
            float cosz = (float) Math.Cos(rotation._z / 180.0 * Math.PI);
            float sinz = (float) Math.Sin(rotation._z / 180.0 * Math.PI);
 
            scale._x = 1 / scale._x;
            scale._y = 1 / scale._y;
            scale._z = 1 / scale._z;
            translation._x = -translation._x;
            translation._y = -translation._y;
            translation._z = -translation._z;
 
            Matrix34 m;
            float* p = (float*) &m;
 
            p[0] = scale._x * cosy * cosz;
            p[1] = scale._x * cosy * sinz;
            p[2] = -scale._x * siny;
            p[3] = translation._x * p[0] + translation._y * p[1] + translation._z * p[2];
            p[4] = scale._y * (sinx * siny * cosz - cosx * sinz);
            p[5] = scale._y * (sinx * siny * sinz + cosx * cosz);
            p[6] = scale._y * sinx * cosy;
            p[7] = translation._x * p[4] + translation._y * p[5] + translation._z * p[6];
            p[8] = scale._z * (cosx * siny * cosz + sinx * sinz);
            p[9] = scale._z * (cosx * siny * sinz - sinx * cosz);
            p[10] = scale._z * cosx * cosy;
            p[11] = translation._x * p[8] + translation._y * p[9] + translation._z * p[10];
 
            return m;
        }

RotateX()

void BrawlLib.Internal.Matrix34.RotateX ( float  x )

inline

        {
            float var1, var2;
            float cosx = (float) Math.Cos(x / 180.0f * Math.PI);
            float sinx = (float) Math.Sin(x / 180.0f * Math.PI);
 
            fixed (float* p = _data)
            {
                var1 = p[1];
                var2 = p[2];
                p[1] = var1 * cosx + var2 * sinx;
                p[2] = var1 * -sinx + var2 * cosx;
 
                var1 = p[5];
                var2 = p[6];
                p[5] = var1 * cosx + var2 * sinx;
                p[6] = var1 * -sinx + var2 * cosx;
 
                var1 = p[9];
                var2 = p[10];
                p[9] = var1 * cosx + var2 * sinx;
                p[10] = var1 * -sinx + var2 * cosx;
            }
        }

RotateY()

void BrawlLib.Internal.Matrix34.RotateY ( float  y )

inline

        {
            float var1, var2;
            float cosy = (float) Math.Cos(y / 180.0f * Math.PI);
            float siny = (float) Math.Sin(y / 180.0f * Math.PI);
 
            fixed (float* p = _data)
            {
                var1 = p[0];
                var2 = p[2];
                p[0] = var1 * cosy + var2 * -siny;
                p[2] = var1 * siny + var2 * cosy;
 
                var1 = p[4];
                var2 = p[6];
                p[4] = var1 * cosy + var2 * -siny;
                p[6] = var1 * siny + var2 * cosy;
 
                var1 = p[8];
                var2 = p[10];
                p[8] = var1 * cosy + var2 * -siny;
                p[10] = var1 * siny + var2 * cosy;
            }
        }

RotateZ()

void BrawlLib.Internal.Matrix34.RotateZ ( float  z )

inline

        {
            float var1, var2;
            float cosz = (float) Math.Cos(z / 180.0f * Math.PI);
            float sinz = (float) Math.Sin(z / 180.0f * Math.PI);
 
            fixed (float* p = _data)
            {
                var1 = p[0];
                var2 = p[1];
                p[0] = var1 * cosz + var2 * sinz;
                p[1] = var1 * -sinz + var2 * cosz;
 
                var1 = p[4];
                var2 = p[5];
                p[4] = var1 * cosz + var2 * sinz;
                p[5] = var1 * -sinz + var2 * cosz;
 
                var1 = p[8];
                var2 = p[9];
                p[8] = var1 * cosz + var2 * sinz;
                p[9] = var1 * -sinz + var2 * cosz;
            }
        }

RotationMatrix()

static Matrix34 BrawlLib.Internal.Matrix34.RotationMatrix ( float  x, float  y, float  z  )

inlinestatic

        {
            float cosx = (float) Math.Cos(x / 180.0f * Math.PI);
            float sinx = (float) Math.Sin(x / 180.0f * Math.PI);
            float cosy = (float) Math.Cos(y / 180.0f * Math.PI);
            float siny = (float) Math.Sin(y / 180.0f * Math.PI);
            float cosz = (float) Math.Cos(z / 180.0f * Math.PI);
            float sinz = (float) Math.Sin(z / 180.0f * Math.PI);
 
            Matrix34 m = Identity;
            float* p = (float*) &m;
 
            p[5] = cosx;
            p[6] = -sinx;
            p[9] = sinx;
            p[10] = cosx;
 
            Matrix34 m2 = Identity;
            float* p2 = (float*) &m2;
            p2[0] = cosy;
            p2[2] = siny;
            p2[8] = -siny;
            p2[10] = cosy;
 
            Matrix34 m3 = Identity;
            float* p3 = (float*) &m3;
            p3[0] = cosz;
            p3[1] = -sinz;
            p3[4] = sinz;
            p3[5] = cosz;
 
            m.Multiply(&m2);
            m.Multiply(&m3);
 
            //p[0] = cosy * cosz;
            //p[1] = cosy * sinz;
            //p[2] = -siny;
            //p[4] = (sinx * siny * cosz - cosx * sinz);
            //p[5] = (sinx * siny * sinz + cosx * cosz);
            //p[6] = sinx * cosy;
            //p[8] = (cosx * siny * cosz + sinx * sinz);
            //p[9] = (cosx * siny * sinz - sinx * cosz);
            //p[10] = cosx * cosy;
 
            return m;
        }

RotationMatrixRX()

static Matrix34 BrawlLib.Internal.Matrix34.RotationMatrixRX ( float  x )

inlinestatic

        {
            Matrix34 m = new Matrix34();
            float* p = (float*) &m;
 
            float cosx = (float) Math.Cos(x / 180.0f * Math.PI);
            float sinx = (float) Math.Sin(x / 180.0f * Math.PI);
 
            p[0] = 1.0f;
            p[5] = cosx;
            p[6] = sinx;
            p[9] = -sinx;
            p[10] = cosx;
 
            return m;
        }

RotationMatrixRY()

static Matrix34 BrawlLib.Internal.Matrix34.RotationMatrixRY ( float  y )

inlinestatic

        {
            Matrix34 m = new Matrix34();
            float* p = (float*) &m;
 
            float cosy = (float) Math.Cos(y / 180.0f * Math.PI);
            float siny = (float) Math.Sin(y / 180.0f * Math.PI);
 
            p[5] = 1.0f;
 
            p[0] = cosy;
            p[2] = -siny;
            p[8] = siny;
            p[10] = cosy;
 
            return m;
        }

RotationMatrixX()

static Matrix34 BrawlLib.Internal.Matrix34.RotationMatrixX ( float  x )

inlinestatic

        {
            Matrix34 m = new Matrix34();
            float* p = (float*) &m;
 
            float cosx = (float) Math.Cos(x / 180.0f * Math.PI);
            float sinx = (float) Math.Sin(x / 180.0f * Math.PI);
 
            p[0] = 1.0f;
            p[5] = cosx;
            p[6] = -sinx;
            p[9] = sinx;
            p[10] = cosx;
 
            return m;
        }

RotationMatrixY()

static Matrix34 BrawlLib.Internal.Matrix34.RotationMatrixY ( float  y )

inlinestatic

        {
            Matrix34 m = new Matrix34();
            float* p = (float*) &m;
 
            float cosy = (float) Math.Cos(y / 180.0f * Math.PI);
            float siny = (float) Math.Sin(y / 180.0f * Math.PI);
 
            p[5] = 1.0f;
 
            p[0] = cosy;
            p[2] = siny;
            p[8] = -siny;
            p[10] = cosy;
 
            return m;
        }

ScaleMatrix()

static Matrix34 BrawlLib.Internal.Matrix34.ScaleMatrix ( float  x, float  y, float  z  )

inlinestatic

        {
            Matrix34 m = new Matrix34();
            float* p = (float*) &m;
            p[0] = x;
            p[5] = y;
            p[10] = z;
            return m;
        }

Subtract()

void BrawlLib.Internal.Matrix34.Subtract ( Matrix34 *  m )

inline

        {
            float* s = (float*) m;
            fixed (float* d = _data)
            {
                for (int i = 0; i < 12; i++)
                {
                    d[i] -= s[i];
                }
            }
        }

TextureMatrix()

static Matrix34 BrawlLib.Internal.Matrix34.TextureMatrix ( TextureFrameState  state )

inlinestatic

        {
            Matrix34 m = Identity;
            if (state.Flags != 7)
            {
                MtxArray[state.Indirect ? 0 : 1 + ((int) state.MatrixMode).Clamp(0, 2) * 7 + state.Flags]((float*) &m,
                    state);
            }
 
            return m;
        }

ToString()

override string BrawlLib.Internal.Matrix34.ToString ( )

inline

        {
            fixed (float* p = _data)
            {
                return CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator.Contains(",")
                    ? $"({p[0]} {p[1]} {p[2]} {p[3]})({p[4]} {p[5]} {p[6]} {p[7]})({p[8]} {p[9]} {p[10]} {p[11]})"
                    : $"({p[0]},{p[1]},{p[2]},{p[3]})({p[4]},{p[5]},{p[6]},{p[7]})({p[8]},{p[9]},{p[10]},{p[11]})";
            }
        }

TransformationMatrix()

static Matrix34 BrawlLib.Internal.Matrix34.TransformationMatrix ( Vector3  scale, Vector3  rotation, Vector3  translation  )

inlinestatic

        {
            float cosx = (float) Math.Cos(rotation._x / 180.0 * Math.PI);
            float sinx = (float) Math.Sin(rotation._x / 180.0 * Math.PI);
            float cosy = (float) Math.Cos(rotation._y / 180.0 * Math.PI);
            float siny = (float) Math.Sin(rotation._y / 180.0 * Math.PI);
            float cosz = (float) Math.Cos(rotation._z / 180.0 * Math.PI);
            float sinz = (float) Math.Sin(rotation._z / 180.0 * Math.PI);
 
            Matrix34 m;
            float* p = (float*) &m;
 
            p[0] = scale._x * cosy * cosz;
            p[1] = scale._y * (sinx * siny * cosz - cosx * sinz);
            p[2] = scale._z * (cosx * siny * cosz + sinx * sinz);
            p[3] = translation._x;
            p[4] = scale._x * cosy * sinz;
            p[5] = scale._y * (sinx * siny * sinz + cosx * cosz);
            p[6] = scale._z * (cosx * siny * sinz - sinx * cosz);
            p[7] = translation._y;
            p[8] = -scale._x * siny;
            p[9] = scale._y * sinx * cosy;
            p[10] = scale._z * cosx * cosy;
            p[11] = translation._z;
 
            return m;
        }

Translate()

void BrawlLib.Internal.Matrix34.Translate ( float  x, float  y, float  z  )

inline

        {
            Matrix34 m = TranslationMatrix(x, y, z);
            Multiply(&m);
        }

TranslationMatrix()

static Matrix34 BrawlLib.Internal.Matrix34.TranslationMatrix ( float  x, float  y, float  z  )

inlinestatic

        {
            Matrix34 m = new Matrix34();
            float* p = (float*) &m;
            p[3] = x;
            p[7] = y;
            p[11] = z;
            p[0] = p[5] = p[10] = 1.0f;
            return m;
        }

Member Data Documentation

Identity

readonly Matrix34 BrawlLib.Internal.Matrix34.Identity = ScaleMatrix(1.0f, 1.0f, 1.0f)

static

Property Documentation

this[int index]

float BrawlLib.Internal.Matrix34.this[int index]

getset

        {
            get
            {
                fixed (float* p = _data)
                {
                    return p[index];
                }
            }
            set
            {
                fixed (float* p = _data)
                {
                    p[index] = value;
                }
            }
        }

---

The documentation for this struct was generated from the following file:

• BrawlLib/Internal/Matrix34.cs