C# Matrix4.MultiplyByTransform方法代码示例

        public void RenderDynamicEntitySkin(LitShaderDescription shader, Entity ent, Matrix4 mvMatrix, Matrix4 pMatrix)
        {
            GL.UniformMatrix4(shader.Projection, false, ref pMatrix);

            for (var i = 0; i < ent.Bf.BoneTags.Count; i++)
            {
                var mat0 = mvMatrix * ent.Bt.BtBody[i].GetWorldTransform();
                var tr1 = new Matrix4();
                // Calculate parent transform
                var btag = ent.Bf.BoneTags[i];
                var foundParentTransform = false;
                for (var j = 0; j < ent.Bf.BoneTags.Count; j++)
                {
                    if(ent.Bf.BoneTags[i] == btag.Parent)
                    {
                        tr1 = ent.Bt.BtBody[j].GetWorldTransform();
                        foundParentTransform = true;
                        break;
                    }
                }
                if (!foundParentTransform)
                    tr1 = (Matrix4) ent.Transform;

                var translate = new Transform();
                translate.SetIdentity();
                translate.Origin += btag.Offset;

                var secondTransform = tr1.MultiplyByTransform(translate);
                var mat1 = mvMatrix * secondTransform;

                var transforms = new float[32];
                unsafe
                {
                    Array.Copy(Helper.GetArrayFromPointer(&mat0.Row0.X, 16), transforms, 16);
                    Array.Copy(Helper.GetArrayFromPointer(&mat1.Row0.X, 16), 0, transforms, 16, 16);
                }
                GL.UniformMatrix4(shader.ModelView, 2, false, transforms);

                if (btag.MeshSkin != null)
                {
                    RenderMesh(btag.MeshSkin);
                }
            }
        }

        public unsafe void RenderRoom(Room room, Matrix4 modelViewMatrix, Matrix4 modelViewProjectionMatrix, Matrix4 projection)
        {
            var needStencil = false;
            if (STENCIL_FRUSTUM)
            {
                // start test stencil test code
                if(room.Frustum.Any())
                {
                    needStencil = room.OverlappedRoomList.Any(r => renderList.Contains(r));

                    if(needStencil)
                    {
                        var shader = ShaderManager.GetStencilShader();
                        GL.UseProgram(shader.Program);
                        GL.UniformMatrix4(shader.ModelViewProjection, false, ref EngineCamera.GLViewProjMat);
                        GL.Enable(EnableCap.StencilTest);
                        GL.Clear(ClearBufferMask.StencilBufferBit);
                        GL.StencilFunc(StencilFunction.Never, 1, 0x00);
                        GL.StencilOp(StencilOp.Replace, StencilOp.Keep, StencilOp.Keep);

                        var stencilVBO = Helper.GenBufferU();

                        var attribs = new[]
                        {
                            new VertexArrayAttribute((int) UnlitShaderDescription.VertexAttribs.Position, 3,
                                VertexAttribPointerType.Float, false, stencilVBO, 3 * sizeof(float), 0)
                        };

                        var array = new VertexArray(0, 1, attribs);
                        array.Bind();

                        foreach (var f in room.Frustum)
                        {
                            GL.BindBuffer(BufferTarget.ArrayBuffer, stencilVBO);
                            GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)(f.Vertices.Count * sizeof(Vector3)), IntPtr.Zero, BufferUsageHint.StreamDraw);

                            unsafe
                            {
                                var v = (float*) GL.MapBuffer(BufferTarget.ArrayBuffer, BufferAccess.WriteOnly);

                                foreach(var it in f.Vertices.AsEnumerable().Reverse())
                                {
                                    *v++ = it.X;
                                    *v++ = it.Y;
                                    *v++ = it.Z;
                                }

                                GL.UnmapBuffer(BufferTarget.ArrayBuffer);
                            }

                            GL.DrawArrays(PrimitiveType.TriangleFan, 0, f.Vertices.Count);
                        }

                        GL.StencilFunc(StencilFunction.Equal, 1, 0xFF);
                        GL.DeleteBuffer(stencilVBO);
                    }
                }
            }

            if(!skipRoom && room.Mesh != null)
            {
                var modelViewProjectionTransform = modelViewProjectionMatrix.MultiplyByTransform(room.Transform);

                var shader = ShaderManager.GetRoomShader(room.LightMode == 1, room.Flags.HasFlagUns(1));

                var tint = new float[4];
                EngineWorld.CalculateWaterTint(tint, true);
                GL.UseProgram(shader.Program);

                GL.Uniform4(shader.TintMult, 1, tint);
                GL.Uniform1(shader.CurrentTick, SDL.SDL_GetTicks());
                GL.Uniform1(shader.Sampler, 0);
                GL.UniformMatrix4(shader.ModelViewProjection, false, ref modelViewProjectionTransform);
                RenderMesh(room.Mesh);
            }

            if(room.StaticMesh.Any())
            {
                GL.UseProgram(ShaderManager.GetStaticMeshShader().Program);
                foreach (var sm in room.StaticMesh)
                {
                    if(sm.WasRendered != 0 || !sm.OBB.IsVisibleInRoom(room, Camera))
                    {
                        continue;
                    }

                    if(sm.Hide && !drawDummyStatics)
                    {
                        continue;
                    }

                    var transform = modelViewProjectionMatrix.MultiplyByTransform(sm.Transform);
                    GL.UniformMatrix4(ShaderManager.GetStaticMeshShader().ModelViewProjection, false, ref transform);

                    var tint = sm.Tint.CloneArr();

                    // If this static mesh is in a water room
                    if(room.Flags.HasFlagUns(RoomFlag.Water))
                    {
                        EngineWorld.CalculateWaterTint(tint, false);
//.........这里部分代码省略.........

        public void RenderSkeletalModelSkin(LitShaderDescription shader, Entity ent, Matrix4 mvMatrix, Matrix4 pMatrix)
        {
            GL.UniformMatrix4(shader.Projection, false, ref pMatrix);

            foreach (var btag in ent.Bf.BoneTags)
            {
                var transforms = new float[32];
                var mvTransforms = mvMatrix.MultiplyByTransform(btag.FullTransform);
                unsafe
                {
                    Array.Copy(Helper.GetArrayFromPointer(&mvTransforms.Row0.X, 16), transforms, 16);
                }

                // Calculate parent transform
                var parentTransform = btag.Parent == null ? ent.Transform : btag.Parent.FullTransform;

                var translate = new Transform();
                translate.SetIdentity();
                translate.Origin += btag.Offset;

                var secondTransform = parentTransform * translate;

                var mvTransforms2 = mvMatrix.MultiplyByTransform(secondTransform);
                unsafe
                {
                    Array.Copy(Helper.GetArrayFromPointer(&mvTransforms2.Row0.X, 16), 0, transforms, 16, 16);
                }
                GL.UniformMatrix4(shader.ModelView, 2, false, transforms);

                if(btag.MeshSkin != null)
                {
                    RenderMesh(btag.MeshSkin);
                }
            }
        }

        public void RenderSkyBox(Matrix4 modelViewProjectionMatrix)
        {
            if (drawSkybox && World?.SkyBox != null)
            {
                GL.DepthMask(false);
                var tr = new Transform();
                tr.Origin = Camera.Position + World.SkyBox.Animations[0].Frames[0].BoneTags[0].Offset;
                tr.Rotation = World.SkyBox.Animations[0].Frames[0].BoneTags[0].QRotate;
                var fullView = modelViewProjectionMatrix.MultiplyByTransform(tr);

                var shader = ShaderManager.GetStaticMeshShader();
                GL.UseProgram(shader.Program);
                GL.UniformMatrix4(shader.ModelViewProjection, false, ref fullView);
                GL.Uniform1(shader.Sampler, 0);
                var tint = new float[] {1, 1, 1, 1};
                GL.Uniform4(shader.TintMult, 1, tint);

                RenderMesh(World.SkyBox.MeshTree[0].MeshBase);
                GL.DepthMask(true);
            }
        }

        public void RenderSkeletalModel(LitShaderDescription shader, SSBoneFrame bframe, Matrix4 mvMatrix,
            Matrix4 mvpMatrix)
        {
            foreach (var btag in bframe.BoneTags)
            {
                var mvTransform = mvMatrix.MultiplyByTransform(btag.FullTransform);
                GL.UniformMatrix4(shader.ModelView, false, ref mvTransform);

                var mvpTransform = mvpMatrix.MultiplyByTransform(btag.FullTransform);
                GL.UniformMatrix4(shader.ModelViewProjection, false, ref mvpTransform);

                RenderMesh(btag.MeshBase);
                if (btag.MeshSlot != null)
                {
                    RenderMesh(btag.MeshSlot);
                }
            }
        }