Пример #1
0
    private void CalculateVelocity()
    {
        Vector3G  vector3G  = new Vector3G();
        double    num       = (double)Time.time - (double)this.lastVelocityCalc;
        Character character = base.idMain;
        Vector3   vector3   = (!character ? base.transform.position : character.origin);
        Vector3G  vector3G1 = new Vector3G(ref vector3);
        double    num1      = 1 / num;

        vector3G.x = num1 * (vector3G1.x - this.lastPosPrecise.x);
        vector3G.y = num1 * (vector3G1.y - this.lastPosPrecise.y);
        vector3G.z = num1 * (vector3G1.z - this.lastPosPrecise.z);
        Matrix4x4G matrix4x4G = new Matrix4x4G(base.transform.worldToLocalMatrix);

        Matrix4x4G.Mult3x3(ref vector3G, ref matrix4x4G, out this.localVelocityPrecise);
        this.lastVelocityCalc = Time.time;
        this.speedPrecise     = Math.Sqrt(this.localVelocityPrecise.x * this.localVelocityPrecise.x + this.localVelocityPrecise.z * this.localVelocityPrecise.z);
        if (this.speedPrecise >= (double)this.movement.configuration.minMoveSpeed)
        {
            double num2 = 1 / this.speedPrecise;
            this.movementNormalPrecise.x = (double)this.localVelocity.x * num2;
            this.movementNormalPrecise.y = (double)this.localVelocity.z * num2;
            double num3 = this.anglePrecise;
            this.anglePrecise = Math.Atan2(this.movementNormalPrecise.x, this.movementNormalPrecise.y) / 3.14159265358979 * 180;
            float single = this.movement.configuration.maxTurnSpeed;
            if (single > 0f && this.anglePrecise != num3 && this.lastAngleSpeedPrecise >= 0.05)
            {
                double num4 = (double)Time.deltaTime * (double)single;
                if (Precise.MoveTowardsAngle(ref num3, ref this.anglePrecise, ref num4, out this.anglePrecise))
                {
                    double num5 = this.anglePrecise / 180 * 3.14159265358979;
                    this.movementNormalPrecise.x = Math.Sin(num5);
                    this.movementNormalPrecise.y = Math.Cos(num5);
                }
            }
            this.lastAngleSpeedPrecise = this.speedPrecise;
        }
        else
        {
            this.speedPrecise            = 0;
            this.movementNormalPrecise.x = 0;
            this.movementNormalPrecise.y = 0;
            if (this.lastAngleSpeedPrecise > 0)
            {
                float single1 = this.movement.configuration.maxTimeBetweenTurns;
                float single2 = single1;
                if (single1 > 0f)
                {
                    PlayerAnimation playerAnimation = this;
                    playerAnimation.lastAngleSpeedPrecise = playerAnimation.lastAngleSpeedPrecise - (double)(Time.deltaTime / single2);
                }
            }
        }
        this.lastPosPrecise = vector3G1;
        this.lastPos        = vector3;
        this.movementNormal = this.movementNormalPrecise.f;
        this.speed          = (float)this.speedPrecise;
        this.angle          = (float)this.anglePrecise;
        this.localVelocity  = this.localVelocityPrecise.f;
    }
Пример #2
0
    internal static void ApplyTransitionAlterations(Camera camera, CameraFX fx, bool useFX)
    {
        Matrix4x4G matrix4x4G;
        Matrix4x4G matrix4x4G1;

        if (!useFX)
        {
            camera.ExtractCameraMatrixWorldToCamera(out matrix4x4G);
            camera.ExtractCameraMatrixProjection(out matrix4x4G1);
            int num = CameraFX.g_trans.Update(ref matrix4x4G, ref matrix4x4G1);
            if ((num & 1) == 1)
            {
                camera.ResetWorldToCameraMatrix();
                camera.worldToCameraMatrix = matrix4x4G.f;
            }
            if ((num & 2) == 2)
            {
                camera.ResetProjectionMatrix();
                camera.projectionMatrix = matrix4x4G1.f;
            }
        }
        else
        {
            int num1 = CameraFX.g_trans.Update(ref fx.worldToCameraMatrix, ref fx.projectionMatrix);
            if ((num1 & 1) == 1)
            {
                camera.worldToCameraMatrix = fx.worldToCameraMatrix.f;
                Matrix4x4G.Inverse(ref fx.worldToCameraMatrix, out fx.cameraToWorldMatrix);
            }
            if ((num1 & 2) == 2)
            {
                camera.projectionMatrix = fx.projectionMatrix.f;
            }
        }
    }
        // Token: 0x06003B75 RID: 15221 RVA: 0x000D42E4 File Offset: 0x000D24E4
        public bool UnProject(ref Vector3G win, out Vector3G objectCoordinate)
        {
            Matrix4x4G matrix4x4G;

            Matrix4x4G.Mult(ref this.projection, ref this.modelview, ref matrix4x4G);
            Matrix4x4G matrix4x4G2;

            if (!Matrix4x4G.Inverse(ref matrix4x4G, ref matrix4x4G2))
            {
                objectCoordinate = default(Vector3G);
                return(false);
            }
            Vector4G vector4G;

            vector4G.x = (win.x - this.offset.x) / this.size.x * 2.0 - 1.0;
            vector4G.y = (win.y - this.offset.y) / this.size.y * 2.0 - 1.0;
            vector4G.z = -win.z;
            vector4G.w = 1.0;
            Vector4G vector4G2;

            Matrix4x4G.Mult(ref vector4G, ref matrix4x4G2, ref vector4G2);
            if (vector4G2.w == 0.0)
            {
                objectCoordinate = default(Vector3G);
                return(false);
            }
            vector4G2.w        = 1.0 / vector4G2.w;
            objectCoordinate.x = vector4G2.x * vector4G2.w;
            objectCoordinate.y = vector4G2.y * vector4G2.w;
            objectCoordinate.z = vector4G2.z * vector4G2.w;
            return(true);
        }
Пример #4
0
    public static Matrix4x4G Transpose(Matrix4x4G v)
    {
        Matrix4x4G matrixxg;

        Matrix4x4G.Transpose(ref v, out matrixxg);
        return(matrixxg);
    }
Пример #5
0
 private void GatherInfo(CCMotor motor)
 {
     if (motor.isGrounded && !motor.isSliding)
     {
         this.groundLocalVelocity           = this.localVelocity;
         this.groundWorldVelocity           = this.worldVelocity;
         this.groundLocalAngularVelocity    = this.localAngularVelocity;
         this.groundLocalVelocityMag        = this.localVelocityMag;
         this.groundWorldVelocityMag        = this.worldVelocityMag;
         this.groundLocalAngularVelocityMag = this.localAngularVelocityMag;
     }
     else
     {
         this.groundLocalVelocity           = new Vector3G();
         this.groundWorldVelocity           = new Vector3G();
         this.groundLocalAngularVelocity    = new Vector3G();
         this.groundLocalVelocityMag        = 0.0;
         this.groundWorldVelocityMag        = 0.0;
         this.groundLocalAngularVelocityMag = 0.0;
     }
     this.inputForce.x = motor.input.moveDirection.x;
     this.inputForce.y = motor.input.moveDirection.y;
     this.inputForce.z = motor.input.moveDirection.z;
     Matrix4x4G.Mult3x3(ref this.inputForce, ref this.worldToLocal, out this.inputForce);
     this.inputForce.x *= this.cfg.inputForceMultiplier.x;
     this.inputForce.y *= this.cfg.inputForceMultiplier.y;
     this.inputForce.z *= this.cfg.inputForceMultiplier.z;
 }
Пример #6
0
        public bool UnProject(ref Vector3G win, out Vector3G objectCoordinate)
        {
            Matrix4x4G matrixxg;
            Matrix4x4G matrixxg2;
            Vector4G   vectorg;
            Vector4G   vectorg2;

            Matrix4x4G.Mult(ref this.projection, ref this.modelview, out matrixxg);
            if (!Matrix4x4G.Inverse(ref matrixxg, out matrixxg2))
            {
                objectCoordinate = new Vector3G();
                return(false);
            }
            vectorg.x = (((win.x - this.offset.x) / this.size.x) * 2.0) - 1.0;
            vectorg.y = (((win.y - this.offset.y) / this.size.y) * 2.0) - 1.0;
            vectorg.z = -win.z;
            vectorg.w = 1.0;
            Matrix4x4G.Mult(ref vectorg, ref matrixxg2, out vectorg2);
            if (vectorg2.w == 0.0)
            {
                objectCoordinate = new Vector3G();
                return(false);
            }
            vectorg2.w         = 1.0 / vectorg2.w;
            objectCoordinate.x = vectorg2.x * vectorg2.w;
            objectCoordinate.y = vectorg2.y * vectorg2.w;
            objectCoordinate.z = vectorg2.z * vectorg2.w;
            return(true);
        }
Пример #7
0
    public static Matrix4x4G Slerp(double t, Matrix4x4G a, Matrix4x4G b)
    {
        Matrix4x4G  identity = Matrix4x4G.identity;
        Vector3G    dotB     = Slerp(t, DIR_X(a), DIR_X(b));
        Vector3G    up       = Slerp(t, DIR_Y(a), DIR_Y(b));
        Vector3G    forward  = Slerp(t, DIR_Z(a), DIR_Z(b));
        QuaternionG rotation = LookRotation(forward, up);

        up = Rotate(rotation, Y3(Length(up)));
        if (CrossDot(forward, up, dotB) > 0.0)
        {
            dotB = Rotate(rotation, X3(-Length(dotB)));
        }
        else
        {
            dotB = Rotate(rotation, X3(Length(dotB)));
        }
        DIR_X(ref identity, dotB);
        DIR_Y(ref identity, up);
        DIR_Z(ref identity, forward);
        SCALE(ref identity, Linear(t, SCALE(a), SCALE(b)));
        TRANS(ref identity, Linear(t, TRANS(a), TRANS(b)));
        identity.m33 = Linear(t, a.m33, b.m33);
        return(identity);
    }
Пример #8
0
 internal static void ApplyTransitionAlterations(Camera camera, CameraFX fx, bool useFX)
 {
     if (useFX)
     {
         int num = g_trans.Update(ref fx.worldToCameraMatrix, ref fx.projectionMatrix);
         if ((num & 1) == 1)
         {
             camera.worldToCameraMatrix = fx.worldToCameraMatrix.f;
             Matrix4x4G.Inverse(ref fx.worldToCameraMatrix, out fx.cameraToWorldMatrix);
         }
         if ((num & 2) == 2)
         {
             camera.projectionMatrix = fx.projectionMatrix.f;
         }
     }
     else
     {
         Matrix4x4G matrixxg;
         Matrix4x4G matrixxg2;
         camera.ExtractCameraMatrixWorldToCamera(out matrixxg);
         camera.ExtractCameraMatrixProjection(out matrixxg2);
         int num2 = g_trans.Update(ref matrixxg, ref matrixxg2);
         if ((num2 & 1) == 1)
         {
             camera.ResetWorldToCameraMatrix();
             camera.worldToCameraMatrix = matrixxg.f;
         }
         if ((num2 & 2) == 2)
         {
             camera.ResetProjectionMatrix();
             camera.projectionMatrix = matrixxg2.f;
         }
     }
 }
Пример #9
0
 // Token: 0x06002BC8 RID: 11208 RVA: 0x000A375C File Offset: 0x000A195C
 internal static void ApplyTransitionAlterations(Camera camera, global::CameraFX fx, bool useFX)
 {
     if (useFX)
     {
         int num = global::CameraFX.g_trans.Update(ref fx.worldToCameraMatrix, ref fx.projectionMatrix);
         if ((num & 1) == 1)
         {
             camera.worldToCameraMatrix = fx.worldToCameraMatrix.f;
             Matrix4x4G.Inverse(ref fx.worldToCameraMatrix, ref fx.cameraToWorldMatrix);
         }
         if ((num & 2) == 2)
         {
             camera.projectionMatrix = fx.projectionMatrix.f;
         }
     }
     else
     {
         Matrix4x4G matrix4x4G;
         Precise.ExtractCameraMatrixWorldToCamera(camera, ref matrix4x4G);
         Matrix4x4G matrix4x4G2;
         Precise.ExtractCameraMatrixProjection(camera, ref matrix4x4G2);
         int num2 = global::CameraFX.g_trans.Update(ref matrix4x4G, ref matrix4x4G2);
         if ((num2 & 1) == 1)
         {
             camera.ResetWorldToCameraMatrix();
             camera.worldToCameraMatrix = matrix4x4G.f;
         }
         if ((num2 & 2) == 2)
         {
             camera.ResetProjectionMatrix();
             camera.projectionMatrix = matrix4x4G2.f;
         }
     }
 }
Пример #10
0
 // Token: 0x06002E36 RID: 11830 RVA: 0x000B0710 File Offset: 0x000AE910
 private void GatherInfo(global::CCMotor motor)
 {
     if (motor.isGrounded && !motor.isSliding)
     {
         this.groundLocalVelocity           = this.localVelocity;
         this.groundWorldVelocity           = this.worldVelocity;
         this.groundLocalAngularVelocity    = this.localAngularVelocity;
         this.groundLocalVelocityMag        = this.localVelocityMag;
         this.groundWorldVelocityMag        = this.worldVelocityMag;
         this.groundLocalAngularVelocityMag = this.localAngularVelocityMag;
     }
     else
     {
         this.groundLocalVelocity           = default(Vector3G);
         this.groundWorldVelocity           = default(Vector3G);
         this.groundLocalAngularVelocity    = default(Vector3G);
         this.groundLocalVelocityMag        = 0.0;
         this.groundWorldVelocityMag        = 0.0;
         this.groundLocalAngularVelocityMag = 0.0;
     }
     this.inputForce.x = (double)motor.input.moveDirection.x;
     this.inputForce.y = (double)motor.input.moveDirection.y;
     this.inputForce.z = (double)motor.input.moveDirection.z;
     Matrix4x4G.Mult3x3(ref this.inputForce, ref this.worldToLocal, ref this.inputForce);
     this.inputForce.x = this.inputForce.x * (double)this.cfg.inputForceMultiplier.x;
     this.inputForce.y = this.inputForce.y * (double)this.cfg.inputForceMultiplier.y;
     this.inputForce.z = this.inputForce.z * (double)this.cfg.inputForceMultiplier.z;
 }
Пример #11
0
        public bool UnProject(ref Vector3G win, out Vector3G objectCoordinate)
        {
            objectCoordinate = new Vector3G();
            Matrix4x4G matrix4x4G;
            Matrix4x4G matrix4x4G1;
            Vector4G   vector4G = new Vector4G();
            Vector4G   vector4G1;

            Matrix4x4G.Mult(ref this.projection, ref this.modelview, out matrix4x4G);
            if (!Matrix4x4G.Inverse(ref matrix4x4G, out matrix4x4G1))
            {
                objectCoordinate = new Vector3G();
                return(false);
            }
            vector4G.x = (win.x - this.offset.x) / this.size.x * 2 - 1;
            vector4G.y = (win.y - this.offset.y) / this.size.y * 2 - 1;
            vector4G.z = -win.z;
            vector4G.w = 1;
            Matrix4x4G.Mult(ref vector4G, ref matrix4x4G1, out vector4G1);
            if (vector4G1.w == 0)
            {
                objectCoordinate = new Vector3G();
                return(false);
            }
            vector4G1.w        = 1 / vector4G1.w;
            objectCoordinate.x = vector4G1.x * vector4G1.w;
            objectCoordinate.y = vector4G1.y * vector4G1.w;
            objectCoordinate.z = vector4G1.z * vector4G1.w;
            return(true);
        }
Пример #12
0
    public static Matrix4x4G Inverse(Matrix4x4G v)
    {
        Matrix4x4G matrixxg;

        Matrix4x4G.Inverse(ref v, out matrixxg);
        return(matrixxg);
    }
    // Token: 0x06000420 RID: 1056 RVA: 0x00014844 File Offset: 0x00012A44
    private void CalculateVelocity()
    {
        double            num    = (double)Time.time - (double)this.lastVelocityCalc;
        global::Character idMain = base.idMain;
        Vector3           vector = (!idMain) ? base.transform.position : idMain.origin;
        Vector3G          vector3G;

        vector3G..ctor(ref vector);
        double   num2 = 1.0 / num;
        Vector3G vector3G2;

        vector3G2.x = num2 * (vector3G.x - this.lastPosPrecise.x);
        vector3G2.y = num2 * (vector3G.y - this.lastPosPrecise.y);
        vector3G2.z = num2 * (vector3G.z - this.lastPosPrecise.z);
        Matrix4x4G matrix4x4G;

        matrix4x4G..ctor(base.transform.worldToLocalMatrix);
        Matrix4x4G.Mult3x3(ref vector3G2, ref matrix4x4G, ref this.localVelocityPrecise);
        this.lastVelocityCalc = Time.time;
        this.speedPrecise     = Math.Sqrt(this.localVelocityPrecise.x * this.localVelocityPrecise.x + this.localVelocityPrecise.z * this.localVelocityPrecise.z);
        if (this.speedPrecise < (double)this.movement.configuration.minMoveSpeed)
        {
            this.speedPrecise            = 0.0;
            this.movementNormalPrecise.x = 0.0;
            this.movementNormalPrecise.y = 0.0;
            float maxTimeBetweenTurns;
            if (this.lastAngleSpeedPrecise > 0.0 && (maxTimeBetweenTurns = this.movement.configuration.maxTimeBetweenTurns) > 0f)
            {
                this.lastAngleSpeedPrecise -= (double)(Time.deltaTime / maxTimeBetweenTurns);
            }
        }
        else
        {
            double num3 = 1.0 / this.speedPrecise;
            this.movementNormalPrecise.x = (double)this.localVelocity.x * num3;
            this.movementNormalPrecise.y = (double)this.localVelocity.z * num3;
            double num4 = this.anglePrecise;
            this.anglePrecise = Math.Atan2(this.movementNormalPrecise.x, this.movementNormalPrecise.y) / 3.1415926535897931 * 180.0;
            float maxTurnSpeed = this.movement.configuration.maxTurnSpeed;
            if (maxTurnSpeed > 0f && this.anglePrecise != num4 && this.lastAngleSpeedPrecise >= 0.05)
            {
                double num5 = (double)Time.deltaTime * (double)maxTurnSpeed;
                if (Precise.MoveTowardsAngle(ref num4, ref this.anglePrecise, ref num5, ref this.anglePrecise))
                {
                    double num6 = this.anglePrecise / 180.0 * 3.1415926535897931;
                    this.movementNormalPrecise.x = Math.Sin(num6);
                    this.movementNormalPrecise.y = Math.Cos(num6);
                }
            }
            this.lastAngleSpeedPrecise = this.speedPrecise;
        }
        this.lastPosPrecise = vector3G;
        this.lastPos        = vector;
        this.movementNormal = this.movementNormalPrecise.f;
        this.speed          = (float)this.speedPrecise;
        this.angle          = (float)this.anglePrecise;
        this.localVelocity  = this.localVelocityPrecise.f;
    }
Пример #14
0
 public void Set(float duration, TransitionFunction func)
 {
     this.start    = CameraFX.CameraTransitionData.timeSource;
     this.lastTime = this.start;
     this.end      = this.start + duration;
     this.view     = this.lastView;
     this.proj     = this.lastProj;
     this.func     = func;
 }
Пример #15
0
    private void PushPosition()
    {
        VectorStamp stamp;
        VectorStamp stamp2;
        Vector3     eyesOrigin;
        Vector3     eulerAngles;
        Character   character;

        this.worldToLocal.f = this.otherParent.worldToLocalMatrix;
        this.localToWorld.f = this.otherParent.localToWorldMatrix;
        stamp.timeStamp     = Time.time;
        stamp.valid         = true;
        if ((this._motor != null) && ((character = this._motor.idMain as Character) != null))
        {
            eulerAngles = character.eyesAngles.eulerAngles;
            eyesOrigin  = character.eyesOrigin;
        }
        else
        {
            eulerAngles = this.otherParent.eulerAngles;
            eyesOrigin  = this.otherParent.position;
        }
        stamp.vector.x   = eyesOrigin.x;
        stamp.vector.y   = eyesOrigin.y;
        stamp.vector.z   = eyesOrigin.z;
        stamp2.vector.x  = eulerAngles.x;
        stamp2.vector.y  = eulerAngles.y;
        stamp2.vector.z  = eulerAngles.z;
        stamp2.timeStamp = Time.time;
        stamp2.valid     = true;
        if (this.lastPosition.valid && (this.lastPosition.timeStamp != stamp.timeStamp))
        {
            double num = 1.0 / ((double)(stamp.timeStamp - this.lastPosition.timeStamp));
            this.worldVelocity.x = (stamp.vector.x - this.lastPosition.vector.x) * num;
            this.worldVelocity.y = (stamp.vector.y - this.lastPosition.vector.y) * num;
            this.worldVelocity.z = (stamp.vector.z - this.lastPosition.vector.z) * num;
            Matrix4x4G.Mult3x3(ref this.worldVelocity, ref this.worldToLocal, out this.localVelocity);
        }
        this.impulseForce.Sample(ref this.localVelocity, stamp.timeStamp);
        this.lastPosition = stamp;
        if (this.lastRotation.valid && (this.lastRotation.timeStamp != stamp2.timeStamp))
        {
            double num2 = 1.0 / ((double)(stamp2.timeStamp - this.lastRotation.timeStamp));
            Precise.DeltaAngle(ref this.lastRotation.vector.x, ref stamp2.vector.x, out this.localAngularVelocity.x);
            Precise.DeltaAngle(ref this.lastRotation.vector.y, ref stamp2.vector.y, out this.localAngularVelocity.y);
            Precise.DeltaAngle(ref this.lastRotation.vector.z, ref stamp2.vector.z, out this.localAngularVelocity.z);
            this.localAngularVelocity.x *= num2;
            this.localAngularVelocity.y *= num2;
            this.localAngularVelocity.z *= num2;
        }
        this.impulseTorque.Sample(ref this.localAngularVelocity, stamp2.timeStamp);
        this.lastRotation            = stamp2;
        this.localVelocityMag        = Math.Sqrt(((this.localVelocity.x * this.localVelocity.x) + (this.localVelocity.y * this.localVelocity.y)) + (this.localVelocity.z * this.localVelocity.z));
        this.worldVelocityMag        = Math.Sqrt(((this.worldVelocity.x * this.worldVelocity.x) + (this.worldVelocity.y * this.worldVelocity.y)) + (this.worldVelocity.z * this.worldVelocity.z));
        this.localAngularVelocityMag = Math.Sqrt(((this.localAngularVelocity.x * this.localAngularVelocity.x) + (this.localAngularVelocity.y * this.localAngularVelocity.y)) + (this.localAngularVelocity.z * this.localAngularVelocity.z));
    }
Пример #16
0
    // Token: 0x06002E35 RID: 11829 RVA: 0x000B02B8 File Offset: 0x000AE4B8
    private void PushPosition()
    {
        this.worldToLocal.f = this.otherParent.worldToLocalMatrix;
        this.localToWorld.f = this.otherParent.localToWorldMatrix;
        global::HeadBob.VectorStamp vectorStamp;
        vectorStamp.timeStamp = Time.time;
        vectorStamp.valid     = true;
        global::Character character;
        Vector3           eulerAngles;
        Vector3           vector;

        if (this._motor && (character = (this._motor.idMain as global::Character)))
        {
            eulerAngles = character.eyesAngles.eulerAngles;
            vector      = character.eyesOrigin;
        }
        else
        {
            eulerAngles = this.otherParent.eulerAngles;
            vector      = this.otherParent.position;
        }
        vectorStamp.vector.x = (double)vector.x;
        vectorStamp.vector.y = (double)vector.y;
        vectorStamp.vector.z = (double)vector.z;
        global::HeadBob.VectorStamp vectorStamp2;
        vectorStamp2.vector.x  = (double)eulerAngles.x;
        vectorStamp2.vector.y  = (double)eulerAngles.y;
        vectorStamp2.vector.z  = (double)eulerAngles.z;
        vectorStamp2.timeStamp = Time.time;
        vectorStamp2.valid     = true;
        if (this.lastPosition.valid && this.lastPosition.timeStamp != vectorStamp.timeStamp)
        {
            double num = 1.0 / (double)(vectorStamp.timeStamp - this.lastPosition.timeStamp);
            this.worldVelocity.x = (vectorStamp.vector.x - this.lastPosition.vector.x) * num;
            this.worldVelocity.y = (vectorStamp.vector.y - this.lastPosition.vector.y) * num;
            this.worldVelocity.z = (vectorStamp.vector.z - this.lastPosition.vector.z) * num;
            Matrix4x4G.Mult3x3(ref this.worldVelocity, ref this.worldToLocal, ref this.localVelocity);
        }
        this.impulseForce.Sample(ref this.localVelocity, vectorStamp.timeStamp);
        this.lastPosition = vectorStamp;
        if (this.lastRotation.valid && this.lastRotation.timeStamp != vectorStamp2.timeStamp)
        {
            double num2 = 1.0 / (double)(vectorStamp2.timeStamp - this.lastRotation.timeStamp);
            Precise.DeltaAngle(ref this.lastRotation.vector.x, ref vectorStamp2.vector.x, ref this.localAngularVelocity.x);
            Precise.DeltaAngle(ref this.lastRotation.vector.y, ref vectorStamp2.vector.y, ref this.localAngularVelocity.y);
            Precise.DeltaAngle(ref this.lastRotation.vector.z, ref vectorStamp2.vector.z, ref this.localAngularVelocity.z);
            this.localAngularVelocity.x = this.localAngularVelocity.x * num2;
            this.localAngularVelocity.y = this.localAngularVelocity.y * num2;
            this.localAngularVelocity.z = this.localAngularVelocity.z * num2;
        }
        this.impulseTorque.Sample(ref this.localAngularVelocity, vectorStamp2.timeStamp);
        this.lastRotation            = vectorStamp2;
        this.localVelocityMag        = Math.Sqrt(this.localVelocity.x * this.localVelocity.x + this.localVelocity.y * this.localVelocity.y + this.localVelocity.z * this.localVelocity.z);
        this.worldVelocityMag        = Math.Sqrt(this.worldVelocity.x * this.worldVelocity.x + this.worldVelocity.y * this.worldVelocity.y + this.worldVelocity.z * this.worldVelocity.z);
        this.localAngularVelocityMag = Math.Sqrt(this.localAngularVelocity.x * this.localAngularVelocity.x + this.localAngularVelocity.y * this.localAngularVelocity.y + this.localAngularVelocity.z * this.localAngularVelocity.z);
    }
Пример #17
0
    private void CalculateVelocity()
    {
        Vector3G  vectorg2;
        double    num     = Time.time - this.lastVelocityCalc;
        Character idMain  = base.idMain;
        Vector3   v       = (idMain == null) ? base.transform.position : idMain.origin;
        Vector3G  vectorg = new Vector3G(ref v);
        double    num2    = 1.0 / num;

        vectorg2.x = num2 * (vectorg.x - this.lastPosPrecise.x);
        vectorg2.y = num2 * (vectorg.y - this.lastPosPrecise.y);
        vectorg2.z = num2 * (vectorg.z - this.lastPosPrecise.z);
        Matrix4x4G b = new Matrix4x4G(base.transform.worldToLocalMatrix);

        Matrix4x4G.Mult3x3(ref vectorg2, ref b, out this.localVelocityPrecise);
        this.lastVelocityCalc = Time.time;
        this.speedPrecise     = Math.Sqrt((this.localVelocityPrecise.x * this.localVelocityPrecise.x) + (this.localVelocityPrecise.z * this.localVelocityPrecise.z));
        if (this.speedPrecise < this.movement.configuration.minMoveSpeed)
        {
            float num3;
            this.speedPrecise            = 0.0;
            this.movementNormalPrecise.x = 0.0;
            this.movementNormalPrecise.y = 0.0;
            if ((this.lastAngleSpeedPrecise > 0.0) && ((num3 = this.movement.configuration.maxTimeBetweenTurns) > 0f))
            {
                this.lastAngleSpeedPrecise -= Time.deltaTime / num3;
            }
        }
        else
        {
            double num4 = 1.0 / this.speedPrecise;
            this.movementNormalPrecise.x = this.localVelocity.x * num4;
            this.movementNormalPrecise.y = this.localVelocity.z * num4;
            double anglePrecise = this.anglePrecise;
            this.anglePrecise = (Math.Atan2(this.movementNormalPrecise.x, this.movementNormalPrecise.y) / 3.1415926535897931) * 180.0;
            float maxTurnSpeed = this.movement.configuration.maxTurnSpeed;
            if (((maxTurnSpeed > 0f) && (this.anglePrecise != anglePrecise)) && (this.lastAngleSpeedPrecise >= 0.05))
            {
                double maxDelta = Time.deltaTime * maxTurnSpeed;
                if (Precise.MoveTowardsAngle(ref anglePrecise, ref this.anglePrecise, ref maxDelta, out this.anglePrecise))
                {
                    double a = (this.anglePrecise / 180.0) * 3.1415926535897931;
                    this.movementNormalPrecise.x = Math.Sin(a);
                    this.movementNormalPrecise.y = Math.Cos(a);
                }
            }
            this.lastAngleSpeedPrecise = this.speedPrecise;
        }
        this.lastPosPrecise = vectorg;
        this.lastPos        = v;
        this.movementNormal = this.movementNormalPrecise.f;
        this.speed          = (float)this.speedPrecise;
        this.angle          = (float)this.anglePrecise;
        this.localVelocity  = this.localVelocityPrecise.f;
    }
Пример #18
0
    private void Update()
    {
        double aspectRatio = (this.aspect <= 0f) ? (((double)Screen.height) / ((double)Screen.width)) : ((double)this.aspect);

        this.unity = Matrix4x4.Perspective(this.fov, (float)aspectRatio, this.near, this.far);
        double fov  = this.fov;
        double near = this.near;
        double far  = this.far;

        Matrix4x4G.Perspective(ref fov, ref aspectRatio, ref near, ref far, out this.facep);
        this.unity2 = this.facep.f;
    }
Пример #19
0
    private Matrix4x4G MultG(Matrix4x4G a, Matrix4x4G b)
    {
        Matrix4x4G matrixxg;

        if (this.revG)
        {
            Matrix4x4G.Mult(ref b, ref a, out matrixxg);
            return(matrixxg);
        }
        Matrix4x4G.Mult(ref a, ref b, out matrixxg);
        return(matrixxg);
    }
Пример #20
0
    // Token: 0x06003DE5 RID: 15845 RVA: 0x000DF454 File Offset: 0x000DD654
    private void Update()
    {
        double num = (this.aspect <= 0f) ? ((double)Screen.height / (double)Screen.width) : ((double)this.aspect);

        this.unity = Matrix4x4.Perspective(this.fov, (float)num, this.near, this.far);
        double num2 = (double)this.fov;
        double num3 = (double)this.near;
        double num4 = (double)this.far;

        Matrix4x4G.Perspective(ref num2, ref num, ref num3, ref num4, ref this.facep);
        this.unity2 = this.facep.f;
    }
Пример #21
0
 private Matrix4x4G MultG(Matrix4x4G a, Matrix4x4G b)
 {
     Matrix4x4G matrix4x4G;
     if (!this.revG)
     {
         Matrix4x4G.Mult(ref a, ref b, out matrix4x4G);
     }
     else
     {
         Matrix4x4G.Mult(ref b, ref a, out matrix4x4G);
     }
     return matrix4x4G;
 }
Пример #22
0
    private Matrix4x4G MultG(Matrix4x4G a, Matrix4x4G b)
    {
        Matrix4x4G matrix4x4G;

        if (!this.revG)
        {
            Matrix4x4G.Mult(ref a, ref b, out matrix4x4G);
        }
        else
        {
            Matrix4x4G.Mult(ref b, ref a, out matrix4x4G);
        }
        return(matrix4x4G);
    }
Пример #23
0
    // Token: 0x06003DD2 RID: 15826 RVA: 0x000DEBA8 File Offset: 0x000DCDA8
    private Matrix4x4G MultG(Matrix4x4G a, Matrix4x4G b)
    {
        Matrix4x4G result;

        if (this.revG)
        {
            Matrix4x4G.Mult(ref b, ref a, ref result);
        }
        else
        {
            Matrix4x4G.Mult(ref a, ref b, ref result);
        }
        return(result);
    }
Пример #24
0
    // Token: 0x06003DFB RID: 15867 RVA: 0x000E059C File Offset: 0x000DE79C
    private void OnDrawGizmos()
    {
        Matrix4x4G matrix4x4G;

        Precise.ExtractLocalToWorld(base.transform, ref matrix4x4G);
        Matrix4x4 localToWorldMatrix = base.transform.localToWorldMatrix;
        Vector3   vector             = localToWorldMatrix.MultiplyPoint(Vector3.zero);
        Vector3   vector2            = localToWorldMatrix.MultiplyPoint(Vector3.forward);
        Vector3   vector3            = localToWorldMatrix.MultiplyPoint(Vector3.up);
        Vector3   vector4            = localToWorldMatrix.MultiplyPoint(Vector3.right);
        Vector3G  vector3G;

        vector3G.x = 1.0;
        vector3G.y = 0.0;
        vector3G.z = 0.0;
        Vector3G vector3G2;

        Matrix4x4G.Mult(ref vector3G, ref matrix4x4G, ref vector3G2);
        vector3G.x = 0.0;
        vector3G.y = 1.0;
        vector3G.z = 0.0;
        Vector3G vector3G3;

        Matrix4x4G.Mult(ref vector3G, ref matrix4x4G, ref vector3G3);
        vector3G.x = 0.0;
        vector3G.y = 0.0;
        vector3G.z = 1.0;
        Vector3G vector3G4;

        Matrix4x4G.Mult(ref vector3G, ref matrix4x4G, ref vector3G4);
        vector3G.x = 0.0;
        vector3G.y = 0.0;
        vector3G.z = 0.0;
        Vector3G vector3G5;

        Matrix4x4G.Mult(ref vector3G, ref matrix4x4G, ref vector3G5);
        Gizmos.color = Color.red * new Color(1f, 1f, 1f, 0.5f);
        Gizmos.DrawLine(vector, vector4);
        Gizmos.color = Color.green * new Color(1f, 1f, 1f, 0.5f);
        Gizmos.DrawLine(vector, vector3);
        Gizmos.color = Color.blue * new Color(1f, 1f, 1f, 0.5f);
        Gizmos.DrawLine(vector, vector2);
        Gizmos.color = Color.red * new Color(1f, 1f, 1f, 1f);
        Gizmos.DrawLine(vector3G5.f, vector3G2.f);
        Gizmos.color = Color.green * new Color(1f, 1f, 1f, 1f);
        Gizmos.DrawLine(vector3G5.f, vector3G3.f);
        Gizmos.color = Color.blue * new Color(1f, 1f, 1f, 1f);
        Gizmos.DrawLine(vector3G5.f, vector3G4.f);
    }
Пример #25
0
        public int Update(ref Matrix4x4G currentView, ref Matrix4x4G currentProj)
        {
            int num;

            try
            {
                float single = CameraFX.CameraTransitionData.timeSource;
                if (this.end > single)
                {
                    float single1 = Mathf.InverseLerp(this.start, this.end, single);
                    if (single1 < 1f)
                    {
                        single1 = this.func.Evaluate(single1);
                        Matrix4x4G camera     = TransitionFunctions.SlerpWorldToCamera((double)single1, this.view, currentView);
                        Matrix4x4G matrix4x4G = TransitionFunctions.Linear((double)single1, this.proj, currentProj);
                        this.lastTime = single;
                        if (!Matrix4x4G.Equals(ref camera, ref currentView))
                        {
                            currentView = camera;
                            if (Matrix4x4G.Equals(ref matrix4x4G, ref currentProj))
                            {
                                num = 1;
                                return(num);
                            }
                            else
                            {
                                currentProj = matrix4x4G;
                                num         = 3;
                                return(num);
                            }
                        }
                        else if (!Matrix4x4G.Equals(ref matrix4x4G, ref currentProj))
                        {
                            currentProj = matrix4x4G;
                            num         = 2;
                            return(num);
                        }
                    }
                }
                num = 0;
            }
            finally
            {
                this.lastView = currentView;
                this.lastProj = currentProj;
            }
            return(num);
        }
Пример #26
0
    private void Update()
    {
        Matrix4x4  unity;
        Matrix4x4G facep;

        if ((this.transforms != null) && (this.transforms.Length > 0))
        {
            if (this.revMul)
            {
                int index = this.transforms.Length - 1;
                unity = this.transforms[index].unity;
                facep = this.transforms[index].facep;
                index--;
                while (index >= 0)
                {
                    unity = this.transforms[index].unity * unity;
                    facep = this.MultG(this.transforms[index].facep, facep);
                    index--;
                }
            }
            else
            {
                int num2 = 0;
                unity = this.transforms[num2].unity;
                facep = this.transforms[num2].facep;
                num2++;
                while (num2 < this.transforms.Length)
                {
                    unity *= this.transforms[num2].unity;
                    facep  = this.MultG(facep, this.transforms[num2].facep);
                    num2++;
                }
            }
        }
        else
        {
            unity = Matrix4x4.identity;
            facep = Matrix4x4G.identity;
        }
        if (this.projection != null)
        {
            unity = this.projection.UnityMatrix * unity;
            facep = this.MultG(this.projection.GMatrix, facep);
        }
        this.unity = unity;
        this.facep = facep;
    }
Пример #27
0
    private void OnDrawGizmos()
    {
        Matrix4x4G matrix4x4G;
        Vector3G   vector3G;
        Vector3G   vector3G1;
        Vector3G   vector3G2;
        Vector3G   vector3G3;
        Vector3G   vector3G4 = new Vector3G();

        base.transform.ExtractLocalToWorld(out matrix4x4G);
        Matrix4x4 matrix4x4 = base.transform.localToWorldMatrix;
        Vector3   vector3   = matrix4x4.MultiplyPoint(Vector3.zero);
        Vector3   vector31  = matrix4x4.MultiplyPoint(Vector3.forward);
        Vector3   vector32  = matrix4x4.MultiplyPoint(Vector3.up);
        Vector3   vector33  = matrix4x4.MultiplyPoint(Vector3.right);

        vector3G4.x = 1;
        vector3G4.y = 0;
        vector3G4.z = 0;
        Matrix4x4G.Mult(ref vector3G4, ref matrix4x4G, out vector3G);
        vector3G4.x = 0;
        vector3G4.y = 1;
        vector3G4.z = 0;
        Matrix4x4G.Mult(ref vector3G4, ref matrix4x4G, out vector3G1);
        vector3G4.x = 0;
        vector3G4.y = 0;
        vector3G4.z = 1;
        Matrix4x4G.Mult(ref vector3G4, ref matrix4x4G, out vector3G2);
        vector3G4.x = 0;
        vector3G4.y = 0;
        vector3G4.z = 0;
        Matrix4x4G.Mult(ref vector3G4, ref matrix4x4G, out vector3G3);
        Gizmos.color = Color.red * new Color(1f, 1f, 1f, 0.5f);
        Gizmos.DrawLine(vector3, vector33);
        Gizmos.color = Color.green * new Color(1f, 1f, 1f, 0.5f);
        Gizmos.DrawLine(vector3, vector32);
        Gizmos.color = Color.blue * new Color(1f, 1f, 1f, 0.5f);
        Gizmos.DrawLine(vector3, vector31);
        Gizmos.color = Color.red * new Color(1f, 1f, 1f, 1f);
        Gizmos.DrawLine(vector3G3.f, vector3G.f);
        Gizmos.color = Color.green * new Color(1f, 1f, 1f, 1f);
        Gizmos.DrawLine(vector3G3.f, vector3G1.f);
        Gizmos.color = Color.blue * new Color(1f, 1f, 1f, 1f);
        Gizmos.DrawLine(vector3G3.f, vector3G2.f);
    }
Пример #28
0
    private void OnDrawGizmos()
    {
        Matrix4x4G matrixxg;
        Vector3G   vectorg;
        Vector3G   vectorg2;
        Vector3G   vectorg3;
        Vector3G   vectorg4;
        Vector3G   vectorg5;

        base.transform.ExtractLocalToWorld(out matrixxg);
        Matrix4x4 localToWorldMatrix = base.transform.localToWorldMatrix;
        Vector3   from    = localToWorldMatrix.MultiplyPoint(Vector3.zero);
        Vector3   to      = localToWorldMatrix.MultiplyPoint(Vector3.forward);
        Vector3   vector3 = localToWorldMatrix.MultiplyPoint(Vector3.up);
        Vector3   vector4 = localToWorldMatrix.MultiplyPoint(Vector3.right);

        vectorg5.x = 1.0;
        vectorg5.y = 0.0;
        vectorg5.z = 0.0;
        Matrix4x4G.Mult(ref vectorg5, ref matrixxg, out vectorg);
        vectorg5.x = 0.0;
        vectorg5.y = 1.0;
        vectorg5.z = 0.0;
        Matrix4x4G.Mult(ref vectorg5, ref matrixxg, out vectorg2);
        vectorg5.x = 0.0;
        vectorg5.y = 0.0;
        vectorg5.z = 1.0;
        Matrix4x4G.Mult(ref vectorg5, ref matrixxg, out vectorg3);
        vectorg5.x = 0.0;
        vectorg5.y = 0.0;
        vectorg5.z = 0.0;
        Matrix4x4G.Mult(ref vectorg5, ref matrixxg, out vectorg4);
        Gizmos.color = Color.red * new Color(1f, 1f, 1f, 0.5f);
        Gizmos.DrawLine(from, vector4);
        Gizmos.color = Color.green * new Color(1f, 1f, 1f, 0.5f);
        Gizmos.DrawLine(from, vector3);
        Gizmos.color = Color.blue * new Color(1f, 1f, 1f, 0.5f);
        Gizmos.DrawLine(from, to);
        Gizmos.color = Color.red * new Color(1f, 1f, 1f, 1f);
        Gizmos.DrawLine(vectorg4.f, vectorg.f);
        Gizmos.color = Color.green * new Color(1f, 1f, 1f, 1f);
        Gizmos.DrawLine(vectorg4.f, vectorg2.f);
        Gizmos.color = Color.blue * new Color(1f, 1f, 1f, 1f);
        Gizmos.DrawLine(vectorg4.f, vectorg3.f);
    }
Пример #29
0
        // Token: 0x06002BD6 RID: 11222 RVA: 0x000A3D54 File Offset: 0x000A1F54
        public int Update(ref Matrix4x4G currentView, ref Matrix4x4G currentProj)
        {
            int result;

            try
            {
                float timeSource = global::CameraFX.CameraTransitionData.timeSource;
                if (this.end > timeSource)
                {
                    float num = Mathf.InverseLerp(this.start, this.end, timeSource);
                    if (num < 1f)
                    {
                        num = this.func.Evaluate(num);
                        Matrix4x4G matrix4x4G  = global::TransitionFunctions.SlerpWorldToCamera((double)num, this.view, currentView);
                        Matrix4x4G matrix4x4G2 = global::TransitionFunctions.Linear((double)num, this.proj, currentProj);
                        this.lastTime = timeSource;
                        if (!Matrix4x4G.Equals(ref matrix4x4G, ref currentView))
                        {
                            currentView = matrix4x4G;
                            if (!Matrix4x4G.Equals(ref matrix4x4G2, ref currentProj))
                            {
                                currentProj = matrix4x4G2;
                                return(3);
                            }
                            return(1);
                        }
                        else if (!Matrix4x4G.Equals(ref matrix4x4G2, ref currentProj))
                        {
                            currentProj = matrix4x4G2;
                            return(2);
                        }
                    }
                }
                result = 0;
            }
            finally
            {
                this.lastView = currentView;
                this.lastProj = currentProj;
            }
            return(result);
        }
Пример #30
0
        public int Update(ref Matrix4x4G currentView, ref Matrix4x4G currentProj)
        {
            int num3;

            try
            {
                float timeSource = CameraFX.CameraTransitionData.timeSource;
                if (this.end > timeSource)
                {
                    float t = Mathf.InverseLerp(this.start, this.end, timeSource);
                    if (t < 1f)
                    {
                        t = this.func.Evaluate(t);
                        Matrix4x4G a         = TransitionFunctions.SlerpWorldToCamera((double)t, this.view, currentView);
                        Matrix4x4G matrixxg2 = TransitionFunctions.Linear((double)t, this.proj, currentProj);
                        this.lastTime = timeSource;
                        if (!Matrix4x4G.Equals(ref a, ref currentView))
                        {
                            currentView = a;
                            if (!Matrix4x4G.Equals(ref matrixxg2, ref currentProj))
                            {
                                currentProj = matrixxg2;
                                return(3);
                            }
                            return(1);
                        }
                        if (!Matrix4x4G.Equals(ref matrixxg2, ref currentProj))
                        {
                            currentProj = matrixxg2;
                            return(2);
                        }
                    }
                }
                num3 = 0;
            }
            finally
            {
                this.lastView = currentView;
                this.lastProj = currentProj;
            }
            return(num3);
        }
Пример #31
0
    public static Matrix4x4G Evaluate(this TransitionFunction f, double t, Matrix4x4G a, Matrix4x4G b)
    {
        switch (f)
        {
        case TransitionFunction.Linear:
            return(Linear(t, a, b));

        case TransitionFunction.Round:
            return(Round(t, a, b));

        case TransitionFunction.Floor:
            return(Floor(t, a, b));

        case TransitionFunction.Ceil:
            return(Ceil(t, a, b));

        case TransitionFunction.Spline:
            return(Spline(t, a, b));
        }
        throw new ArgumentOutOfRangeException("v", "Attempted use of unrecognized TransitionFunction enum value");
    }
Пример #32
0
 public static Matrix4x4G Transpose(Matrix4x4G v)
 {
     Matrix4x4G matrix4x4G;
     Matrix4x4G.Transpose(ref v, out matrix4x4G);
     return matrix4x4G;
 }
Пример #33
0
 public static Matrix4x4G Linear(double t, Matrix4x4G a, Matrix4x4G b)
 {
     return TransitionFunctions.Sum(TransitionFunctions.Mul(a, 1 - t), TransitionFunctions.Mul(b, t));
 }
Пример #34
0
 public static Matrix4x4G Floor(double t, Matrix4x4G a, Matrix4x4G b)
 {
     return (t >= 1 ? b : a);
 }
Пример #35
0
 private static void TRANS(ref Matrix4x4G a, Vector3G v)
 {
     TransitionFunctions.SET_X3(ref a, v);
 }
Пример #36
0
 private static void SET_X3(ref Matrix4x4G m, Vector3G v)
 {
     m.m03 = v.x;
     m.m13 = v.y;
     m.m23 = v.z;
 }
Пример #37
0
 private static void SET_X1(ref Matrix4x4G m, Vector3G v)
 {
     m.m01 = v.x;
     m.m11 = v.y;
     m.m21 = v.z;
 }
Пример #38
0
 private static void SET_3X(ref Matrix4x4G m, Vector3G v)
 {
     m.m30 = v.x;
     m.m31 = v.y;
     m.m32 = v.z;
 }
Пример #39
0
 private static void SET_1X(ref Matrix4x4G m, Vector3G v)
 {
     m.m10 = v.x;
     m.m11 = v.y;
     m.m12 = v.z;
 }
Пример #40
0
 private static void SCALE(ref Matrix4x4G a, Vector3G v)
 {
     TransitionFunctions.SET_3X(ref a, v);
 }
Пример #41
0
 private static Vector3G GET_X3(Matrix4x4G a)
 {
     return TransitionFunctions.VECT3F(a.m03, a.m13, a.m23);
 }
Пример #42
0
 public static Matrix4x4G Sum(Matrix4x4G a, Matrix4x4G b)
 {
     Matrix4x4G matrix4x4G = new Matrix4x4G();
     matrix4x4G.m00 = a.m00 + b.m00;
     matrix4x4G.m10 = a.m10 + b.m10;
     matrix4x4G.m20 = a.m20 + b.m20;
     matrix4x4G.m30 = a.m30 + b.m30;
     matrix4x4G.m01 = a.m01 + b.m01;
     matrix4x4G.m11 = a.m11 + b.m11;
     matrix4x4G.m21 = a.m21 + b.m21;
     matrix4x4G.m31 = a.m31 + b.m31;
     matrix4x4G.m02 = a.m02 + b.m02;
     matrix4x4G.m12 = a.m12 + b.m12;
     matrix4x4G.m22 = a.m22 + b.m22;
     matrix4x4G.m32 = a.m32 + b.m32;
     matrix4x4G.m03 = a.m03 + b.m03;
     matrix4x4G.m13 = a.m13 + b.m13;
     matrix4x4G.m23 = a.m23 + b.m23;
     matrix4x4G.m33 = a.m33 + b.m33;
     return matrix4x4G;
 }
Пример #43
0
 private static Vector3G SCALE(Matrix4x4G a)
 {
     return TransitionFunctions.GET_3X(a);
 }
Пример #44
0
 private static Vector3G DIR_Z(Matrix4x4G a)
 {
     return TransitionFunctions.GET_X2(a);
 }
Пример #45
0
 private static void SET_0X(ref Matrix4x4G m, Vector3G v)
 {
     m.m00 = v.x;
     m.m01 = v.y;
     m.m02 = v.z;
 }
Пример #46
0
 private static void DIR_Z(ref Matrix4x4G a, Vector3G v)
 {
     TransitionFunctions.SET_X2(ref a, v);
 }
Пример #47
0
 private static void SET_2X(ref Matrix4x4G m, Vector3G v)
 {
     m.m20 = v.x;
     m.m21 = v.y;
     m.m22 = v.z;
 }
Пример #48
0
 private static Vector3G GET_0X(Matrix4x4G a)
 {
     return TransitionFunctions.VECT3F(a.m00, a.m01, a.m02);
 }
Пример #49
0
 private static void SET_X0(ref Matrix4x4G m, Vector3G v)
 {
     m.m00 = v.x;
     m.m10 = v.y;
     m.m20 = v.z;
 }
Пример #50
0
 private static Vector3G GET_1X(Matrix4x4G a)
 {
     return TransitionFunctions.VECT3F(a.m10, a.m11, a.m12);
 }
Пример #51
0
 private static void SET_X2(ref Matrix4x4G m, Vector3G v)
 {
     m.m02 = v.x;
     m.m12 = v.y;
     m.m22 = v.z;
 }
Пример #52
0
 private static Vector3G GET_2X(Matrix4x4G a)
 {
     return TransitionFunctions.VECT3F(a.m20, a.m21, a.m22);
 }
Пример #53
0
 private static Vector3G TRANS(Matrix4x4G a)
 {
     return TransitionFunctions.GET_X3(a);
 }
Пример #54
0
 private static Vector3G GET_3X(Matrix4x4G a)
 {
     return TransitionFunctions.VECT3F(a.m30, a.m31, a.m32);
 }
Пример #55
0
 public static Matrix4x4G Evaluate(this TransitionFunction f, double t, Matrix4x4G a, Matrix4x4G b)
 {
     switch (f)
     {
         case TransitionFunction.Linear:
         {
             return TransitionFunctions.Linear(t, a, b);
         }
         case TransitionFunction.Round:
         {
             return TransitionFunctions.Round(t, a, b);
         }
         case TransitionFunction.Floor:
         {
             return TransitionFunctions.Floor(t, a, b);
         }
         case TransitionFunction.Ceil:
         {
             return TransitionFunctions.Ceil(t, a, b);
         }
         case TransitionFunction.Spline:
         {
             return TransitionFunctions.Spline(t, a, b);
         }
     }
     throw new ArgumentOutOfRangeException("v", "Attempted use of unrecognized TransitionFunction enum value");
 }
Пример #56
0
 private static Vector3G GET_X0(Matrix4x4G a)
 {
     return TransitionFunctions.VECT3F(a.m00, a.m10, a.m20);
 }
Пример #57
0
 public static Matrix4x4G Inverse(Matrix4x4G v)
 {
     Matrix4x4G matrix4x4G;
     Matrix4x4G.Inverse(ref v, out matrix4x4G);
     return matrix4x4G;
 }
Пример #58
0
 private static Vector3G GET_X1(Matrix4x4G a)
 {
     return TransitionFunctions.VECT3F(a.m01, a.m11, a.m21);
 }
Пример #59
0
 public static Matrix4x4G Mul(Matrix4x4G a, double b)
 {
     Matrix4x4G matrix4x4G = new Matrix4x4G();
     matrix4x4G.m00 = a.m00 * b;
     matrix4x4G.m10 = a.m10 * b;
     matrix4x4G.m20 = a.m20 * b;
     matrix4x4G.m30 = a.m30 * b;
     matrix4x4G.m01 = a.m01 * b;
     matrix4x4G.m11 = a.m11 * b;
     matrix4x4G.m21 = a.m21 * b;
     matrix4x4G.m31 = a.m31 * b;
     matrix4x4G.m02 = a.m02 * b;
     matrix4x4G.m12 = a.m12 * b;
     matrix4x4G.m22 = a.m22 * b;
     matrix4x4G.m32 = a.m32 * b;
     matrix4x4G.m03 = a.m03 * b;
     matrix4x4G.m13 = a.m13 * b;
     matrix4x4G.m23 = a.m23 * b;
     matrix4x4G.m33 = a.m33 * b;
     return matrix4x4G;
 }
Пример #60
0
 private static Vector3G GET_X2(Matrix4x4G a)
 {
     return TransitionFunctions.VECT3F(a.m02, a.m12, a.m22);
 }