C# Matrix4.Invert方法代码示例

        public bool Render(Material material, Light light, Camera camera, Matrix4 worldMatrix, Func<int, bool> renderDelegate)
        {
            Params["m_World"].SetValue(worldMatrix);
            Params["m_WorldIT"].SetValue(worldMatrix.Invert().Transpose());
            Params["m_WVP"].SetValue(worldMatrix * camera.ViewMatrix * camera.ProjectionMatrix);
            Params["g_vLightPos"].SetValue(light.Position);
            Params["m_ViewInv"].SetValue(camera.ViewMatrix.Invert());
            Params["DiffuseTexture"].SetValue(material.DiffuseTexture);
            Params["useNormalMap"].SetValue(material.UseNormalMap);
            Params["NormalTexture"].SetValue(material.NormalTexture);
            Params["specularPower"].SetValue(material.SpecularPower);
            Params["specularColor"].SetValue(material.SpecularColor);
            Params["useOffsetMapping"].SetValue(material.UseOffsetMapping);
            Params["HeightMapTexture"].SetValue(material.HeightMapTexture);
            Params["g_fOffsetBias"].SetValue(material.OffsetHeight);

            return RenderTechnique(renderDelegate, material.Technique);
        }

        private void CalculateMatrices()
        {
            Rectangle viewport = GetViewport3D();
            _projectionMatrix = Matrix4d.Perspective(45, viewport.Width / (double) viewport.Height, 4, 512);

            Bounds3 vec = Bounds3.EmptyBounds;
            Bounds3 allBounds = Bounds3.EmptyBounds;
            int count = 0;

            if (CurrentModel != null)
            {
                int meshIndex = 0;
                foreach (Mesh mesh in CurrentModel.Meshes)
                {
                    allBounds += mesh.Bounds;

                    if (CurrentModel.PartsEnabled[meshIndex])
                    {
                        vec += mesh.Bounds;
                        count++;
                    }

                    meshIndex++;
                }
            }

            if (count == 0)
                vec.Mins = vec.Maxs = allBounds.Mins = allBounds.Maxs = Vector3.Zero;

            GrassY = allBounds.Maxs.Y;
            Vector3 center = vec.Center;

            _viewMatrix =
                Matrix4.CreateTranslation(-center.X + _3DOffset.X, -center.Y + _3DOffset.Y, -center.Z + _3DOffset.Z) *
                Matrix4.CreateFromAxisAngle(new Vector3(0, -1, 0), MathHelper.DegreesToRadians(_3DRotationY)) *
                Matrix4.CreateFromAxisAngle(new Vector3(1, 0, 0), MathHelper.DegreesToRadians(_3DRotationX)) *
                Matrix4.CreateTranslation(0, 0, _3DZoom);

            _cameraMatrix = _viewMatrix;
            _cameraMatrix.Invert();

            CameraPosition = Vector3.TransformPosition(Vector3.Zero, _cameraMatrix);
        }

 /// <summary>
 /// Called to set the current yaw to be the offset. This is useful when trying to align the sensors to the screen.
 /// </summary>
 public Matrix4 calibrateZero()
 {
     mCalibratedOrientation =  transformOrientation(mCurrentOrientation);
     mCalibratedOrientation.Invert();
     mCalibYawPitchRoll = mYawPitchRoll;
     return mCalibratedOrientation;
 }

 public void Process(BaseCameraApplication app)
 {
     bbox = app.GetPrimaryDevice().GetBoundingBox();
     GroundPlane = app.GetPrimaryDevice().GetGroundPlane();
     GroundPlane.Invert();
 }

        /// <summary>
        /// Current Model View Should be Straight Forward!
        /// </summary>
        /// <param name="render"></param>
        /// <param name="zNear"></param>
        /// <param name="zFar"></param>
        /// <param name="m">Model View Should to Straight Forward</param>
        public void Render(Action render, float zNear, float zFar, Matrix4 m)
        {
            m.Invert();

            GL.loadProjection(90, 90, zNear, zFar);
            GL.Viewport(0, 0, this._Resolution, this._Resolution);

            GL.BindFramebuffer(FramebufferTarget.Framebuffer, this._FrameBuffer);
            GL.DrawBuffer((DrawBufferMode)FramebufferAttachment.ColorAttachment0);

            for (int i = 0; i < 6; i++)
            {
                if (this._Use[i])
                {
                    GL.FramebufferTexture2D(
                        FramebufferTarget.Framebuffer,
                        FramebufferAttachment.ColorAttachment0,
                        CubeColorMap._TextureTargets[i],
                        this._ColorText,
                        0);

                    GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);

                    GL.LoadMatrix(ref CubeColorMap._Matrices[i]);
                    GL.MultMatrix(ref m);

                    render();
                }
            }

            GL.BindFramebuffer(FramebufferTarget.Framebuffer, 0);
            GL.DrawBuffer(DrawBufferMode.Back);
        }

        public void Update()
        {
            Console.WriteLine($"Position: {Position} Target: {Target}");

            //somehow it must be -d and -y
            var p0 = new Vector3(-1,  1, -D); //top left
            var p1 = new Vector3( 1,  1, -D); //top right
            var p2 = new Vector3(-1, -1, -D); //bottom left

            _cameraMatrix = Matrix4.LookAt(Position, Target, Vector3.UnitY);;
            _cameraMatrix.Invert();

            _p0     = Vector3.Transform(p0, _cameraMatrix);
            var tp1 = Vector3.Transform(p1, _cameraMatrix);
            var tp2 = Vector3.Transform(p2, _cameraMatrix);

            _e1 = tp1 - _p0;
            _e2 = tp2 - _p0;
        }

        private Vector3 bestFitPlane(Vector3[] vs)
        {
            Vector3 avgs = Vector3.Zero;

            foreach (Vector3 v in vs) avgs = Vector3.Add(v, avgs);

            avgs /= vs.Length;

            var zerod = new Vector3[vs.Length];

            for (int i = 0; i < vs.Length; i++) zerod[i] = Vector3.Subtract(avgs, vs[i]);

            // a b c
            // d e f
            // g h i
            Vector4 row1 = new Vector4(0, 0, 0, 0);
            Vector4 row2 = new Vector4(0, 0, 0, 0);
            Vector4 row3 = new Vector4(0, 0, 0, 0);
            Vector4 row4 = new Vector4(0, 0, 0, 1);

            Vector4 b = new Vector4(0, 0, 0, 1);

            foreach (Vector3 v in zerod)
            {
                row1.X += v.X * v.X;
                row1.Y += v.X * v.Z;
                row1.Z += v.X;

                row2.X += v.Z * v.X;
                row2.Y += v.Z * v.Z;
                row2.Z += v.Z;

                row3.X += v.X;
                row3.Y += v.Z;
                row3.Z += 1;

                b.X += v.Y * v.X;
                b.Y += v.Y * v.Z;
                b.Z += v.Y;
            }

            Matrix4 mat = new Matrix4(row1, row2, row3, row4);
            mat.Invert();

            Vector4 result;
            Vector4.Transform(ref b, ref mat, out result);
            Vector3 ret = new Vector3(result.X, -1, result.Y);

            ret.Normalize();

            if (ret.Y < 0) ret *= -1;

            return ret;
        }

        public void Matrix4_InvertTest()
        {
            Matrix4 a = new Matrix4(1, 2, 2, 2,
                    2, 2, 1, 1,
                    1, 2, 1, 0,
                    1, 2, 2, 1);

            Matrix4 b = new Matrix4(-1, 1, -1, 1,
                             1, -0.5f, 1.5f, -1.5f,
                            -1, 0, -1, 2,
                             1, 0, 0, -1);

            Assert.AreEqual(b, a.Invert());

            Matrix4 ai = a.Invert();
            Assert.AreEqual(b, ai);

            // A(A-1) = (A-1)A = I
            Assert.AreEqual(Matrix4.Identity, a * a.Invert());
            Assert.AreEqual(Matrix4.Identity, a.Invert() * a);

            // (AB)-1 = B-1A-1
            Matrix4 c = new Matrix4(2, 3, 2, 2,
                            3, 3, 3, 3,
                            3, 2, 2, 3,
                            3, 2, 1, 2);
            // TODO: Fail in release mode.
            //Assert.AreEqual((a * c).Invert(), c.Invert() * a.Invert());

            // (M-1)-1 = M
            Assert.AreEqual(a, a.Invert().Invert());

            // I-1 = I
            Assert.AreEqual(Matrix4.Identity, Matrix4.Identity.Invert());

            // (MT)-1 = (M-1)T
            Assert.AreEqual(a.Transpose().Invert(), a.Invert().Transpose());
        }

        private void CalculateProjection()
        {
            Matrix4 view = Matrix4.LookAt(_position, _lookAt, _up);
            Matrix4 projection = Matrix4.Identity;
            switch (_cameraType)
            {
                case CameraType.Perspective:
                    projection = Matrix4.CreatePerspectiveFieldOfView(_fov, _aspectRatio, _zNear, _zFar);
                    break;

                case CameraType.Orthogonal:
                    projection = Matrix4.CreateOrthographic(_width * _fov, _height * _fov, _zNear, _zFar);
                    break;

                case CameraType.HUD:
                    projection = Matrix4.CreateOrthographicOffCenter(0.0f, _width, _height, 0.0f, _zNear, _zFar);
                    break;
            }
            _viewProjectMatrix = view * projection;
            _invViewProjectMatrix = _viewProjectMatrix;
            _invViewProjectMatrix.Invert();
            _isDirty = false;
        }

        public static void invert() {
            var m = new Matrix4(_priorInv);

            m.Invert();

            AreEqual(_postInv, m, 10);
        }

        public bool Initialize(String daeFileName)
        {
            var fi = new FileInfo(daeFileName);
            if (!fi.Exists)
                return false;

            var scene = LoadDaeScene(fi.FullName);
            if (scene == null)
                return false;

            foreach (var t in BodyMeshes)
                t.Destroy();
            BodyMeshes.Clear();
            Bones.Clear();
            bonesMapping.Clear();
            Animations.Clear();
            Poses.Clear();
            rootNode = null;
            СurrentAnimation = null;

            m_globalInverseTransform = FromMatrix(scene.RootNode.Transform);
            m_globalInverseTransform.Invert();

            var title = Path.GetFileNameWithoutExtension(fi.FullName);
            LoadBodyMeshes(fi.FullName, scene, scene.RootNode, null);
            LoadBonesInfo(rootNode);
            LoadAnimations(scene, title);

            return true;
        }