// to prevent use of class member data, I declare this method as 'static'
        static void Execute(H1DebugDrawCommandData InData)
        {
            if (InData.PrimitiveType != H1DebugDrawCommandData.EPrimitiveType.Invalid)
            {
                SGD.H1Transform Transform = InData.GetTransform();

                // get the command list object from thread context
                SharpDX.Direct3D12.GraphicsCommandList CommandList = Thread.H1ThreadGlobal.ThreadContext.RendererContext.CurrCommandList.CommandList;

                switch (InData.PrimitiveType)
                {
                case H1DebugDrawCommandData.EPrimitiveType.Box:
                {
                    SGD.H1RenderUtils.DrawBox(CommandList, Transform);
                    break;
                }

                case H1DebugDrawCommandData.EPrimitiveType.Plane10x10:
                {
                    SGD.H1RenderUtils.DrawPlane10x10(CommandList, new SharpDX.Vector2(0, 0), new SharpDX.Vector2(1, 1));
                    break;
                }
                }
            }
        }
        // @TODO - I need to wrap command list separately!, it is just temporary method! SHOULD!! FIX!!
        public void setVertexBuffers(SharpDX.Direct3D12.GraphicsCommandList commandList)
        {
            SharpDX.Direct3D12.VertexBufferView positionVertexBufferView = ((Gen2Layer.H1VertexBufferView)m_PositionVertexBuffer.View).View;
            SharpDX.Direct3D12.VertexBufferView normalVertexBufferView   = ((Gen2Layer.H1VertexBufferView)m_NormalVertexBuffer.View).View;
            SharpDX.Direct3D12.VertexBufferView texcoordVertexBufferView = ((Gen2Layer.H1VertexBufferView)m_TexcoordVertexBuffers[0].View).View;
            SharpDX.Direct3D12.VertexBufferView colorVertexBufferView    = ((Gen2Layer.H1VertexBufferView)m_ColorVertexBuffer.View).View;

            commandList.SetVertexBuffer(0, positionVertexBufferView);
            commandList.SetVertexBuffer(1, normalVertexBufferView);
            commandList.SetVertexBuffer(2, texcoordVertexBufferView);
            commandList.SetVertexBuffer(3, colorVertexBufferView);
        }
        // @TODO - I need to wrap command list separately!, it is just temporary method! SHOULD!! FIX!!
        public void setVertexBuffers(SharpDX.Direct3D12.GraphicsCommandList commandList)
        {
            SharpDX.Direct3D12.VertexBufferView PositionBufferView  = ((Gen2Layer.H1VertexBufferView)m_ShaderData.PositionBuffer.View).View;
            SharpDX.Direct3D12.VertexBufferView TangentZBufferView  = ((Gen2Layer.H1VertexBufferView)m_ShaderData.TangentZBuffer.View).View;
            SharpDX.Direct3D12.VertexBufferView TangentXBufferView  = ((Gen2Layer.H1VertexBufferView)m_ShaderData.TangentXBuffer.View).View;
            SharpDX.Direct3D12.VertexBufferView BoneIndicesView     = ((Gen2Layer.H1VertexBufferView)m_ShaderData.BoneIndices.View).View;
            SharpDX.Direct3D12.VertexBufferView BoneWeightsView     = ((Gen2Layer.H1VertexBufferView)m_ShaderData.BoneWeights.View).View;
            SharpDX.Direct3D12.VertexBufferView Texcoord0BufferView = ((Gen2Layer.H1VertexBufferView)m_ShaderData.TexcoordBuffers[0].View).View;
            SharpDX.Direct3D12.VertexBufferView ColorBufferView     = ((Gen2Layer.H1VertexBufferView)m_ShaderData.ColorBuffer.View).View;

            commandList.SetVertexBuffer(0, PositionBufferView);
            commandList.SetVertexBuffer(1, TangentZBufferView);
            commandList.SetVertexBuffer(2, TangentXBufferView);
            commandList.SetVertexBuffer(3, BoneIndicesView);
            commandList.SetVertexBuffer(4, BoneWeightsView);
            commandList.SetVertexBuffer(5, Texcoord0BufferView);
            commandList.SetVertexBuffer(6, ColorBufferView);
        }
Example #4
0
        // @TODO - change this delivering directly command list from the renderer after implementing overall rendering system
        public void SkeletonDebugDrawing(SharpDX.Direct3D12.GraphicsCommandList commandList, Boolean bDebugDraw = true)
        {
            // @TODO - temporary to check if animation is working
            H1SkeletalMeshComponent skeletalMeshComponent = H1Global <H1World> .Instance.PersistentLevel.GetActor(0).GetActorComponent <H1SkeletalMeshComponent>();

            List <H1AnimInstance.InterpolatedLocalTransform> interpolatedLocalTransforms = new List <H1AnimInstance.InterpolatedLocalTransform>();

            for (Int32 boneIndex = 0; boneIndex < m_Skeleton.RefSkeleton.RefBoneInfoList.Count; ++boneIndex)
            {
                H1AnimInstance.InterpolatedLocalTransform interpolatedLocalTransform = new H1AnimInstance.InterpolatedLocalTransform();
                H1MeshBoneInfo meshBoneInfo = m_Skeleton.RefSkeleton.RefBoneInfoList[boneIndex];

                interpolatedLocalTransform.BoneName       = meshBoneInfo.Name;
                interpolatedLocalTransform.LocalTransform = m_Skeleton.RefSkeleton.RefBoneBases[boneIndex];

                interpolatedLocalTransforms.Add(interpolatedLocalTransform);
            }

            // extract interpolated local transforms
            skeletalMeshComponent.AnimScriptInstance.ExtractInterpolatedLocalTransform(0.0f, ref interpolatedLocalTransforms);

            H1Transform[] globalTransforms = new H1Transform[m_Skeleton.RefSkeleton.RefBoneBases.Count];
            // tracking only upper parent index by one
            Int32[] transformParentIndices = new Int32[m_Skeleton.RefSkeleton.RefBoneBases.Count];

            for (Int32 boneIndex = 0; boneIndex < m_Skeleton.RefSkeleton.RefBoneInfoList.Count; ++boneIndex)
            {
                H1MeshBoneInfo meshBoneInfo = m_Skeleton.RefSkeleton.RefBoneInfoList[boneIndex];

                //H1Transform localTransform = m_Skeleton.RefSkeleton.RefBoneBases[boneIndex];
                H1Transform localTransform = interpolatedLocalTransforms[boneIndex].LocalTransform;

                // extract parent locals
                List <H1Transform> parentLocalTransforms = new List <H1Transform>();
                H1MeshBoneInfo     currMeshBoneInfo      = meshBoneInfo;
                while (currMeshBoneInfo.ParentIndex != -1)
                {
                    //parentLocalTransforms.Add(m_Skeleton.RefSkeleton.RefBoneBases[currMeshBoneInfo.ParentIndex]);
                    parentLocalTransforms.Add(interpolatedLocalTransforms[currMeshBoneInfo.ParentIndex].LocalTransform);
                    currMeshBoneInfo = m_Skeleton.RefSkeleton.RefBoneInfoList[currMeshBoneInfo.ParentIndex];
                }

                // generate global transform for current bone space
                // 1. start to transform current local transformation matrix
                Matrix globalTransformMtx = localTransform.Transformation;
                // 2. from curr bone space to root space by going up to each parent node space
                for (Int32 index = 0; index < parentLocalTransforms.Count; ++index)
                {
                    Matrix parentLocalTransformMtx = parentLocalTransforms[index].Transformation;
                    globalTransformMtx = Matrix.Multiply(globalTransformMtx, parentLocalTransformMtx);
                }

                // decompose global matrix and generate H1Transform
                Vector3    translation;
                Vector3    scale;
                Quaternion rotate;
                globalTransformMtx.Decompose(out scale, out rotate, out translation);

                H1Transform globalTransform = new H1Transform();
                globalTransform.Translation = translation;
                globalTransform.Scaling     = scale;
                globalTransform.Rotation    = rotate;

                globalTransforms[boneIndex]       = globalTransform;
                transformParentIndices[boneIndex] = meshBoneInfo.ParentIndex;
            }

            // set bone matrices
            Int32 currGlobalBoneIndex = 0;

            foreach (H1Transform boneTransform in globalTransforms)
            {
                // @TODO - temporary scaling to match when we importing vertices in H1AssimpImporter
                //boneTransform.Scaling = boneTransform.Scaling * 0.01f;

                // get global offset matrices
                Matrix globalOffsetMatrix = m_Skeleton.RefSkeleton.RefOffsetBases[currGlobalBoneIndex].Transformation;

                // pass multiplied global offset matrices and animated global matrices
                H1Global <H1ManagedRenderer> .Instance.SetBoneMatrix(currGlobalBoneIndex, Matrix.Multiply(globalOffsetMatrix, boneTransform.Transformation));

                currGlobalBoneIndex++;
            }

            // when debug draw is enabled
            if (bDebugDraw == true)
            {
                for (Int32 boneIndex = 0; boneIndex < globalTransforms.Count(); ++boneIndex)
                {
                    Int32 parentIndex = transformParentIndices[boneIndex];
                    if (parentIndex < 0)
                    {
                        continue;
                    }

                    H1Transform parentBoneTransform = globalTransforms[parentIndex];
                    H1Transform boneTransform       = globalTransforms[boneIndex];

                    Vector3 parentLoc = parentBoneTransform.Translation * 0.005f;
                    Vector3 currLoc   = boneTransform.Translation * 0.005f;

                    float length = (currLoc - parentLoc).Length();
                    if (length < 0.001f)
                    {
                        continue;
                    }

                    Vector3 zAxis = Vector3.Normalize(currLoc - parentLoc);

                    Matrix  pitchMtx     = Matrix.RotationYawPitchRoll(0, 0.1f, 0);
                    Vector4 rotatedZAxis = Vector3.Transform(zAxis, pitchMtx);
                    rotatedZAxis /= rotatedZAxis.W;

                    Vector3 yAxis = Vector3.Normalize(Vector3.Cross(zAxis, Vector3.Normalize(new Vector3(rotatedZAxis.X, rotatedZAxis.Y, rotatedZAxis.Z))));
                    Vector3 xAxis = Vector3.Normalize(Vector3.Cross(zAxis, yAxis));

                    //H1RenderUtils.DrawCapsule(commandList, parentLoc, xAxis, yAxis, zAxis, 0.03f, length / 2.0f, 16);
                    H1RenderUtils.DrawDashedLine(commandList, parentLoc, currLoc, 2.0f);
                    //H1RenderUtils.DrawWireStar(commandList, currLoc, 0.03f);
                }
            }
        }