C# Matrix4.ExtractRotation方法代码示例

        public static void ApplyMatrixTransform(TransformMatrix transformMat, matrix m)
        {
            var transform = transformMat.transform;
            var values = m.Values;
            var mat = new Matrix4(
                (float)values[0], (float)values[1], (float)values[2], (float)values[3],
                (float)values[4], (float)values[5], (float)values[6], (float)values[7],
                (float)values[8], (float)values[9], (float)values[10], (float)values[11],
                (float)values[12], (float)values[13], (float)values[14], (float)values[15]
            );
            mat.Transpose();
            transformMat.matrix *= mat;

            var translation = mat.ExtractTranslation();
            transform.Translation += translation;

            if (translation != Vector3.Zero)
                transform.Flags |= (int)Transform.TransformFlags.HasTranslation;

            var rotation = mat.ExtractRotation();
            transform.Rotation *= rotation;

            if (rotation != Quaternion.Identity)
                transform.Flags |= (int)Transform.TransformFlags.HasRotation;

            var scale = mat.ExtractScale();
            transform.ScaleShear[0, 0] *= scale[0];
            transform.ScaleShear[1, 1] *= scale[1];
            transform.ScaleShear[2, 2] *= scale[2];

            if (transform.ScaleShear != Matrix3.Identity)
                transform.Flags |= (int)Transform.TransformFlags.HasScaleShear;
        }

        public SSpaceMissileClusterVisualData(
            Matrix4 launcherWorldMat, Vector3 launcherVel, int numMissiles,
            ISSpaceMissileTarget target, float timeToHit,
            SSpaceMissileVisualParameters mParams,
            Vector3[] meshPositioningOffsets = null,
            Vector3[] meshPositioningDirections = null,
            BodiesFieldGenerator meshPositioningGenerator = null,
            SSpaceMissileVisualData.AtTargetFunc atTargetFunc = null)
        {
            _target = target;
            _timeToHit = timeToHit;
            _parameters = mParams;
            _missiles = new SSpaceMissileVisualData[numMissiles];
            this.atTargetFunc = atTargetFunc;

            Vector3[] localSpawnPts = new Vector3[numMissiles];
            Quaternion[] localSpawnOrients = new Quaternion[numMissiles];
            if (meshPositioningGenerator != null) {
                meshPositioningGenerator.Generate(numMissiles,
                    (id, scale, pos, orient) => {
                        localSpawnPts [id] = pos;
                        localSpawnOrients [id] = orient;
                        return true;
                    }
                );
            }

            Quaternion launcherOrientation = launcherWorldMat.ExtractRotation();
            for (int i = 0; i < numMissiles; ++i) {
                if (meshPositioningOffsets != null && meshPositioningOffsets.Length > 0) {
                    localSpawnPts [i] += meshPositioningOffsets [i % meshPositioningOffsets.Length];
                }
                if (meshPositioningDirections != null && meshPositioningDirections.Length > 0) {
                    int idx = i % meshPositioningDirections.Length;
                    localSpawnOrients [i] *= OpenTKHelper.getRotationTo(
                        Vector3.UnitZ, meshPositioningDirections [idx], Vector3.UnitZ);
                }
                Vector3 missileWorldPos = Vector3.Transform(localSpawnPts [i], launcherWorldMat);
                Vector3 missileLocalDir = Vector3.Transform(Vector3.UnitZ, localSpawnOrients [i]);
                Vector3 missileWorldDir = Vector3.Transform(missileLocalDir, launcherOrientation);
                Vector3 missileWorldVel = launcherVel + missileWorldDir * mParams.ejectionVelocity;

                _missiles [i] = mParams.createMissile(
                    missileWorldPos, missileWorldDir, missileWorldVel, this, i);

                #if false
                _missiles [i] = new SSpaceMissileVisualData (
                    missileWorldPos, missileWorldDir, missileWorldVel,
                    this, clusterId: i);
                #endif
            }
        }

 /// <summary>
 /// Compute orientation around X once per frame to orient the sprites towards the viewer
 /// </summary>
 public void updateModelView(ref Matrix4 modelViewMatrix)
 {
     Quaternion quat = modelViewMatrix.ExtractRotation();
     // x-orient
     Vector3 test1 = new Vector3(0f, 1f, 0f);
     Vector3 test2 = Vector3.Transform(test1, quat);
     float dot = Vector3.Dot(test1, test2);
     float angle = (float)Math.Acos(dot);
     if (test2.Z < 0f) {
         angle = -angle;
     }
     _orientationX = angle;
 }

        public Camera(int viewportWidth, int viewportHeight, Matrix4 cameraViewMatrix, string name = "Default")
        {
            PreciseTimer = new Stopwatch();

            SetViewportSize(viewportWidth, viewportHeight);

            Location = cameraViewMatrix.ExtractTranslation();
            CameraViewMatrix = cameraViewMatrix;

            //TODO: Someone figure out what this section is meant to be. (tree_game is a good test)
            var quaternion = CameraViewMatrix.ExtractRotation(false);
            Pitch = quaternion.Y;
            Yaw = quaternion.Z;

            Name = name;
        }

        /// <summary>
        /// View matrix that makes the object appear on the screen in pixel dimentions matching it's 
        /// scale value (after modelview and projection transforms)
        /// </summary>
        public static Matrix4 ScaleToScreenPxViewMat(Vector3 objPos, float objScaleX,
                                                     ref Matrix4 viewMat, ref Matrix4 projMat)
        {
            objScaleX = Math.Abs(objScaleX);

            // compute rightmost point in world coordinates
            Matrix4 viewRotInverted = Matrix4.CreateFromQuaternion(viewMat.ExtractRotation().Inverted());
            Vector3 viewRight = Vector3.Transform(Vector3.UnitX, viewRotInverted).Normalized();
            Vector3 rightMostInWorld = objPos + objScaleX * viewRight;

            // compute things in screen coordinates and find the required scale mitigation
            Matrix4 modelViewProjMat = viewMat * projMat;
            RectangleF clientRect = GetClientRect();
            Vector2 centerOnScreen = WorldToScreen(objPos, ref modelViewProjMat, ref clientRect);
            Vector2 rightMostOnScreen = WorldToScreen(rightMostInWorld, ref modelViewProjMat, ref clientRect);
            float distanceObserved = Math.Abs(rightMostOnScreen.X - centerOnScreen.X);
            float scaleMitigation = objScaleX / distanceObserved;
            //System.Console.WriteLine("rightmost x = " + rightMostOnScreen.X);
            return Matrix4.CreateScale(scaleMitigation);
            //return Matrix4.Identity;
        }

        public static void ApplyLightMatrix(Matrix4 world)
        {
            int uEyePosition = Graphics.GetShader().GetUniformLocation("uEyePosition");
            Vector4 eyePosition = Vector4.Transform(new Vector4(world.ExtractTranslation(), 1), world);
            GL.Uniform4(uEyePosition, ref eyePosition);

            for (int i = 0; i < _numLights; i++)
            {
                Vector4 position = _lights[i].Position;
                int uLightPositionLocation = Graphics.GetShader().GetUniformLocation("uLight[" + i + "].Position");
                position = Vector4.Transform(position, world);
                GL.Uniform4(uLightPositionLocation, position);

                Vector4 direction = _lights[i].Direction;
                int uLightDirectionLocation = Graphics.GetShader().GetUniformLocation("uLight[" + i + "].Direction");
                direction = Vector4.Transform(direction, world.ExtractRotation());
                GL.Uniform4(uLightDirectionLocation, direction);
            }
        }

 public void updateModelView(ref Matrix4 modelViewMatrix)
 {
     Quaternion quat = modelViewMatrix.ExtractRotation ().Inverted();
     Vector3 euler = OpenTKHelper.QuaternionToEuler (ref quat);
     Vector3 baseVec = new Vector3 (euler.X + 0.5f*(float)Math.PI, euler.Y, euler.Z);
     orientationMin = baseVec + new Vector3((float)Math.PI/8f, 0f, 0f);
     orientationMax = baseVec + new Vector3((float)Math.PI*3f/8f, 2f*(float)Math.PI, 0f);
 }

 public SSRay Transformed(Matrix4 mat)
 {
     // a point is directly transformed
     // however, a ray is only rotationally transformed.
     return new SSRay( Vector3.Transform(pos, mat) , Vector3.Transform(dir,mat.ExtractRotation()).Normalized() );
 }

 public void Tranform(Matrix4 matrix)
 {
     Position = Vector4.Transform(new Vector4(Position, 1.0f), matrix).Xyz;
     Normal = Vector3.Transform(Normal, matrix.ExtractRotation(true));
 }

        public virtual void Update(float deltaTime)
        {
            if(DirectionLock)
            {
                Position = Target - Direction * Distance;
            }
            else
            {
                Direction = Target - Position;
                Distance = Direction.Length;
                Direction.Normalize();
                rot.X = Vector3.CalculateAngle(Direction, Vector3.UnitZ);
                rot.Y = Vector3.CalculateAngle(Direction, Vector3.UnitY);
            }

            View = Matrix4.LookAt(Position, Target, Up);
            InvView = View.Inverted();

            VPMatrix = View * Projection;
            InvVPMatrix = VPMatrix.Inverted();

            var rotation = VPMatrix.ExtractRotation();
            NormalMatrix = Matrix3.CreateFromQuaternion(rotation);

            Frustum = new BoundingFrustum(VPMatrix);
        }