コード例 #1
0
        public void UpdatePerFrameResources(GraphicsDevice gd, CommandList cl, GraphicsSystem sc)
        {
            WorldAndInverse wai;

            wai.World        = _transform.GetTransformMatrix();
            wai.InverseWorld = VdUtilities.CalculateInverseTranspose(ref wai.World);
            gd.UpdateBuffer(_worldAndInverseBuffer, 0, ref wai);
        }
コード例 #2
0
        // modifies projection matrix in place
        // clipPlane is in camera space
        public static void CalculateObliqueMatrixPerspective(ref Matrix4x4 projection, Matrix4x4 view, Plane clipPlane)
        {
            Matrix4x4 invTransposeView = VdUtilities.CalculateInverseTranspose(view);
            Vector4   clipV4           = new Vector4(clipPlane.Normal, clipPlane.D);

            clipV4 = Vector4.Transform(clipV4, invTransposeView);

            Vector4 q = new Vector4(
                (Math.Sign(clipV4.X) + projection.M13) / projection.M11,
                (Math.Sign(clipV4.Y) + projection.M23) / projection.M22,
                -1f,
                (1 + projection.M33) / projection.M34);

            Vector4 c = clipV4 * (1f / Vector4.Dot(clipV4, q));

            projection.M31 = c.X;
            projection.M32 = c.Y;
            projection.M33 = c.Z;
            projection.M34 = c.W;
        }
コード例 #3
0
        public void Render(GraphicsDevice gd, CommandList cl, SceneContext sc, RenderPasses renderPass, SpriteModelResourceContainer modelResource, ref SpriteModelRenderData renderData)
        {
            if (renderData.Shared.RenderMode == RenderMode.Glow)
            {
                renderData.Shared.RenderAmount = GlowBlend(ref renderData.Shared, sc.ViewState);
            }

            //Don't render if blend is 0 (even if blend were ignored below)
            if (renderData.Shared.RenderAmount == 0)
            {
                return;
            }

            var blend = renderData.Shared.RenderMode != RenderMode.Normal ? renderData.Shared.RenderAmount : 255;

            //TODO: glow sprite visibility testing
            var angles = GetSpriteAngles(ref renderData.Shared, modelResource.SpriteModel.SpriteFile.Type, sc.ViewState);

            angles = VectorUtils.ToRadians(angles);

            var wai = new WorldAndInverse();

            var anglesWithoutYaw = angles;

            anglesWithoutYaw.Y = 0;

            wai.World = Matrix4x4.CreateScale(renderData.Shared.Scale)
                * WorldAndInverse.CreateRotationMatrix(anglesWithoutYaw)
                * WorldAndInverse.CreateRotationMatrix(new Vector3(0, angles.Y, 0))
                * Matrix4x4.CreateTranslation(renderData.Shared.Origin);

            wai.InverseWorld = VdUtilities.CalculateInverseTranspose(ref wai.World);

            //var wai = new WorldAndInverse(renderData.Origin, angles, renderData.Scale);

            sc.UpdateWorldAndInverseBuffer(cl, ref wai);

            var alpha = 255;

            switch (renderData.Shared.RenderMode)
            {
                case RenderMode.Normal:
                case RenderMode.TransTexture:
                case RenderMode.TransAlpha:
                    alpha = blend;
                    break;
            }

            var renderColor = new Vector4(CalculateSpriteColor(ref renderData.Shared, blend), alpha) / 255.0f;

            cl.UpdateBuffer(modelResource.RenderColorBuffer, 0, ref renderColor);

            renderData.Frame = Math.Clamp((int)renderData.Frame, 0, modelResource.VertexBuffers.Length - 1);

            var frameBuffer = modelResource.VertexBuffers[(int)renderData.Frame];

            var pipeline = Pipelines[renderData.Shared.RenderMode];

            cl.SetVertexBuffer(0, frameBuffer);
            cl.SetIndexBuffer(modelResource.IndexBuffer, IndexFormat.UInt16);
            cl.SetPipeline(pipeline);
            cl.SetGraphicsResourceSet(0, modelResource.ResourceSet);
            cl.DrawIndexed((uint)SPRResourceUtils.Indices.Length, 1, 0, 0, 0);
        }