C# Matrix.Decompose方法代码示例

 public static float GetRotation(ref Matrix matrix)
 {
     Vector3 position3, scale3;
     Quaternion rotationQ;
     matrix.Decompose(out scale3, out rotationQ, out position3);
     Vector2 direction = Vector2.Transform(Vector2.UnitX, rotationQ);
     return (float)Math.Atan2(direction.Y, direction.X);
 }

		/// <summary>
		/// Construct this transform from a matrix
		/// </summary>
		/// <param name="matrix"></param>
		/// <param name="performValidityCheck">When true, the matrix will be checked to make sure it will produce a valid transform</param>
		public Transform(ref Matrix matrix, bool performValidityCheck)
		{
			if (performValidityCheck)
			{
				//validate the matrix is not sheered or inverted on a single axis.
				Vector3 x = new Vector3(matrix.M11, matrix.M12, matrix.M13);
				Vector3 y = new Vector3(matrix.M21, matrix.M22, matrix.M23);
				Vector3 z = new Vector3(matrix.M31, matrix.M32, matrix.M33);

				float xl = x.Length();
				float yl = y.Length();
				float zl = z.Length();

				float maxl = Math.Max(xl, Math.Max(yl, zl));
				float minl = Math.Min(xl, Math.Min(yl, zl));

				if ((maxl - minl) > maxl / 10)
					throw new ArgumentException("The input matrix is not uniformly scaled");

				if (xl > 0.000001f) x /= xl;
				if (yl > 0.000001f) y /= yl;
				if (zl > 0.000001f) z /= zl;

				Vector3 zc = Vector3.Cross(x, y);
				Vector3 yc = Vector3.Cross(z, x);
				Vector3 xc = Vector3.Cross(y, zc);

				if (Vector3.Dot(x, xc) < 0.975f || Vector3.Dot(z, zc) * Vector3.Dot(y, yc) < 0.95f)
					throw new ArgumentException("The input matrix is skewed, sheered or non uniformly scaled");
			}

			Vector3 scale;
			matrix.Decompose(out scale, out Rotation, out Translation);

			//if one or two components are negative, then the Decompose messed up.
			if (scale.X * scale.Y * scale.Z < 0)
			{
				Matrix copy = matrix;
				copy.M11 = -copy.M11;
				copy.M12 = -copy.M12;
				copy.M13 = -copy.M13;
				copy.M21 = -copy.M21;
				copy.M22 = -copy.M22;
				copy.M23 = -copy.M23;
				copy.M31 = -copy.M31;
				copy.M32 = -copy.M32;
				copy.M33 = -copy.M33;
				copy.Decompose(out scale, out Rotation, out Translation);
				scale = -scale;
			}

			this.Scale = Math.Min(Math.Min(scale.X, scale.Y), scale.Z);

			if (Scale > 0.999f && Scale < 1.001f)
				Scale = 1;

			this.Rotation.Normalize();
		}

 public static void DecomposeMatrix2D(ref Matrix matrix, out Vector2 position, out float rotation, out Vector2 scale)
 {
     Vector3 position3, scale3;
     Quaternion rotationQ;
     matrix.Decompose(out scale3, out rotationQ, out position3);
     Vector2 direction = Vector2.Transform(Vector2.UnitX, rotationQ);
     rotation = (float)Math.Atan2(direction.Y, direction.X);
     position = new Vector2(position3.X, position3.Y);
     scale = new Vector2(scale3.X, scale3.Y);
 }

 public virtual void SetTransform(Matrix m)
 {
     Vector3 pos;
     Quaternion quat;
     Vector3 scale;
     m.Decompose(out scale,out quat,out pos);
     Vector3 rot = MathUtils.QuaternionToEuler(quat);
     transform.Set(new Vector2(pos.X,pos.Y), (float)rot.Z);
     SetScale(new Vector2(scale.X,scale.Y));
 }

        public void SetTransform(ref Matrix transform)
        {
            transform.Decompose(out scale, out rotation, out translation);

            if (scale.X > 0.9999f && scale.X <= 1.0001f)
                scale.X = 1;
            if (scale.Y > 0.9999f && scale.Y <= 1.0001f)
                scale.Y = 1;
            if (scale.Z > 0.9999f && scale.Z <= 1.0001f)
                scale.Z = 1;
        }

        // Converts a Rotation Matrix to a quaternion, then into a Vector3 containing
        // Euler angles (X: Pitch, Y: Yaw, Z: Roll)
        public Vector3 MatrixToEulerAngleVector3(Matrix Rotation)
        {
            Vector3 translation, scale;
            Quaternion rotation;

            Rotation.Decompose(out scale, out rotation, out translation);

            Vector3 eulerVec = QuaternionToEulerAngleVector3(rotation);

            return eulerVec;
        }

        /// <summary>
        /// 指定された行列から生成する
        /// </summary>
        /// <param name="matrix"></param>
        /// <returns></returns>
        public static SQTTransformContent FromMatrix(Matrix matrix)
        {
            // 行列の分解
            Quaternion rotation;
            Vector3 translation;
            Vector3 scale;
            matrix.Decompose(out scale, out rotation, out translation);

            
            return new SQTTransformContent(scale, rotation, translation);
        }

        /// <summary>
        /// Creates a new keyframe from given time and transformation matrix.
        /// Since internally the joint transformation is stored in form of its
        /// scale, rotation and translation components the matrix has to be 
        /// decomposed within this constructor.
        /// </summary>
        /// <param name="time">Time of keyframe</param>
        /// <param name="transform">Transformation</param>
        public JointAnimationKeyFrame(float time, Matrix transform)
        {
            _time = time;

            if (!transform.Decompose(out _scale, out _rotation, out _translation))
            {
                throw new ApplicationException("Could not decompose transformation matrix");
            }

            _transform = transform;
        }

        public static BoundingSphere Transform(this BoundingSphere source, Matrix transformation)
        {
            Vector3 translation;
            Vector3 scaling;
            Quaternion rotation;
            transformation.Decompose(out scaling, out rotation, out translation);

            var transformedSphereRadius = source.Radius * new[] { scaling.X, scaling.Y, scaling.Z }.Max();
            var transformedSphereCenter = Vector3.Transform(source.Center, transformation);

            return new BoundingSphere(transformedSphereCenter, transformedSphereRadius);
        }

        public static string GetInfo(Matrix matrix)
        {
            Vector3 scales;
            Quaternion quaternion;
            Vector3 translation;
            matrix.Decompose(out scales, out quaternion, out translation);

            return string.Format("Scales:{0}; Angles:{1}; Trans:{2}", scales,
                //GetAngles(matrix),
                QuaternionToEuler2(quaternion),
                translation);
        }

        public void DrawShield(Matrix world)
        {
            Vector3 scale, translation;
            Quaternion rotation;

            //should actually be up...
            Vector3 side = world.Right;
            Vector3 forward = world.Up;

            world.Decompose(out scale, out rotation, out translation);

            scale.Z *= .8f;
            scale *= 1.5f;
            // scale.X *= 3f;
            //translation -= world.Right;

            rotation = Quaternion.Concatenate(rotation, Quaternion.CreateFromAxisAngle(world.Right, MathHelper.ToRadians(90)));

            Matrix.CreateFromQuaternion(ref rotation, out world);
            world = Matrix.CreateScale(scale) * world;
            world *= Matrix.CreateTranslation(translation);

            // world = Matrix.CreateScale(scale*2) * Matrix.CreateFromQuaternion(rotation) * Matrix.CreateRotationZ((float)(Math.PI / 2)) * Matrix.CreateTranslation(translation);

            Matrix[] ModelTransforms = new Matrix[shieldModel.Bones.Count];
            shieldModel.CopyAbsoluteBoneTransformsTo(ModelTransforms);

            foreach (ModelMesh mesh in shieldModel.Meshes)
            {
                foreach (Effect currentEffect in mesh.Effects)
                {
                    currentEffect.CurrentTechnique = currentEffect.Techniques["Colored"];
                    currentEffect.Parameters["xWorld"].SetValue(ModelTransforms[mesh.ParentBone.Index] * world);
                    currentEffect.Parameters["xView"].SetValue(viewMatrix);
                    currentEffect.Parameters["xProjection"].SetValue(projectionMatrix);

                    Vector3 lightDirection = new Vector3(3, -1, 0);
                    lightDirection.Normalize();

                    currentEffect.Parameters["xLightDirection"].SetValue(lightDirection);
                    currentEffect.Parameters["xShieldP1"].SetValue(P1shieldDirection);
                    currentEffect.Parameters["xShieldP2"].SetValue(P2shieldDirection);
                    currentEffect.Parameters["xShipSide"].SetValue(side);
                    currentEffect.Parameters["xShipForward"].SetValue(forward);
                    //   currentEffect.Parameters["xTexture"].SetValue(texture);

                }
                mesh.Draw();
            }
        }

        public Transform(Matrix matrix)
        {
            matrix.Decompose(out scale, out rotation, out translation);

            if (scale.X > 0.9999f && scale.X <= 1.0001f)
                scale.X = 1;
            if (scale.Y > 0.9999f && scale.Y <= 1.0001f)
                scale.Y = 1;
            if (scale.Z > 0.9999f && scale.Z <= 1.0001f)
                scale.Z = 1;

            #if DEBUG
            this.Validate();
            #endif
        }

        public static BoundingBox TransformBox(BoundingBox aabb, Matrix transform)
        {
            Vector3 scale;
            Quaternion rotation;
            Vector3 translation;

            transform.Decompose(out scale, out rotation, out translation);

            if (rotation != Quaternion.Identity)
                throw new ArgumentException("Rotation of AABBs is not supported.");

            Vector3 center = 0.5f * (aabb.Max + aabb.Min) + translation;
            Vector3 extent = 0.5f * (aabb.Max - aabb.Min) * scale;

            //return new BoundingBox(center - extent, center + extent);
            return BoundingBox.CreateFromPoints(new Vector3[] { center - extent, center + extent });
        }

        /// <summary>
        /// 指定された行列から生成する
        /// </summary>
        /// <param name="matrix"></param>
        /// <returns></returns>
        public static QuatTransform FromMatrix( Matrix matrix )
        {
            // 行列の分解
            Quaternion rotation;
            Vector3 translation;
            Vector3 scale;
            matrix.Decompose( out scale, out rotation, out translation );

            // 一意のスケールか？
            if ( !CloseEnough( scale.X, scale.Y ) || !CloseEnough( scale.X, scale.Z ) )
            {
                throw new InvalidOperationException(
                    "一意のスケール(X,Y,Zが同じスケール値)ではありません" );
            }

            if ( !CloseEnough( scale.X, 1.0f ) )
                throw new InvalidOperationException( "スケール値が1以外です" );

            return new QuatTransform( rotation, translation );
        }

        public static BoundingSphere TransformBoundingSphere(BoundingSphere originalBoundingSphere, Matrix transformationMatrix)
        {
            Vector3 trans;
            Vector3 scaling;
            Quaternion rot;
            transformationMatrix.Decompose(out scaling, out rot, out trans);

            float maxScale = scaling.X;
            if (maxScale < scaling.Y)
                maxScale = scaling.Y;
            if (maxScale < scaling.Z)
                maxScale = scaling.Z;

            float transformedSphereRadius = originalBoundingSphere.Radius * maxScale;
            Vector3 transformedSphereCenter = Vector3.Transform(originalBoundingSphere.Center, transformationMatrix);

            BoundingSphere transformedBoundingSphere = new BoundingSphere(transformedSphereCenter, transformedSphereRadius);

            return transformedBoundingSphere;
        }