public override void RenderCamera(RenderPipelineContext context)
        {
            if (!context.dynamicContextRead.settings.ViewerUI)
            {
                return;
            }
            var graphicsContext = context.graphicsContext;

            graphicsContext.SetPObject(context.RPAssetsManager.PObjectWidgetUI1, CullMode.none);
            graphicsContext.SetCBVR(constantBuffers[0], 0);
            graphicsContext.SetSRVT(context.UI1Texture, 1);
            graphicsContext.SetMesh(context.ndcQuadMesh);
            graphicsContext.DrawIndexedInstanced(context.ndcQuadMeshIndexCount, 0, 0, allocated, 0);

            var selectedEntity = context.dynamicContextRead.selectedEntity;

            if (selectedEntity != null)
            {
                graphicsContext.SetSRVT(context.ScreenSizeDSVs[0], 2);
                graphicsContext.SetPObject(context.RPAssetsManager.PObjectWidgetUI2, CullMode.none);
                graphicsContext.SetCBVR(bgConstantBuffers[0], 0);
                graphicsContext.SetCBVR(context.CBs_Bone[indexOfSelectedEntity], 3);
                graphicsContext.DrawIndexedInstanced(context.ndcQuadMeshIndexCount, 0, 0, selectedEntity.boneComponent.bones.Count, 0);
            }
            var selectedLight = context.dynamicContextRead.selectedLightings;

            if (selectedLight.Count > 0)
            {
                graphicsContext.SetMesh(context.cubeWireMesh);
                graphicsContext.SetPObject(context.RPAssetsManager.PObjectWidgetUILight, CullMode.none, true);
                graphicsContext.SetCBVR(bgConstantBuffers[1], 0);
                graphicsContext.DrawIndexedInstanced(context.cubeWireMeshIndexCount, 0, 0, selectedLight.Count, 0);
            }
        }
        public override void RenderCamera(RenderPipelineContext context, GraphicsContext graphicsContext)
        {
            var rsPostProcess = context.RPAssetsManager.rootSignaturePostProcess;

            graphicsContext.SetRootSignature(rsPostProcess);
            graphicsContext.SetRenderTargetScreen(context.dynamicContextRead.settings.backgroundColor, context.ScreenSizeDSVs[1], true, true);
            graphicsContext.SetCBVR(postProcessDataBuffer, 0);
            graphicsContext.SetSRVT(context.outputRTV, 1);
            graphicsContext.SetSRVT(context.postProcessBackground, 2);
            graphicsContext.SetMesh(context.ndcQuadMesh);
            PSODesc desc = new PSODesc
            {
                blendState        = EBlendState.none,
                cullMode          = ECullMode.back,
                depthBias         = 0,
                dsvFormat         = DxgiFormat.DXGI_FORMAT_UNKNOWN,
                inputLayout       = EInputLayout.postProcess,
                ptt               = ED3D12PrimitiveTopologyType.TRIANGLE,
                rtvFormat         = context.swapChainFormat,
                renderTargetCount = 1,
                streamOutput      = false,
                wireFrame         = false,
            };

            SetPipelineStateVariant(context.deviceResources, graphicsContext, rsPostProcess, ref desc, context.RPAssetsManager.PObjectPostProcess);
            graphicsContext.DrawIndexed(context.ndcQuadMeshIndexCount, 0, 0);
        }
Exemple #3
0
 public override void PrepareRenderData(RenderPipelineContext context)
 {
     if (!innerStruct.Equals(prevData))
     {
         Marshal.StructureToPtr(innerStruct, Marshal.UnsafeAddrOfPinnedArrayElement(rcDataUploadBuffer, 0), true);
         context.graphicsContext.UpdateResource(postProcessDataBuffer, rcDataUploadBuffer, c_postProcessDataSize, 0);
         prevData = innerStruct;
     }
 }
Exemple #4
0
 public void Process(RenderPipelineContext rp, MiscProcessContext context)
 {
     if (context.miscProcessPairs.Count == 0)
     {
         return;
     }
     if (!Ready)
     {
         return;
     }
     ref byte[]      bigBuffer       = ref rp.bigBuffer;
        public override void RenderCamera(RenderPipelineContext context, GraphicsContext graphicsContext)
        {
            if (!context.dynamicContextRead.settings.ViewerUI)
            {
                return;
            }
            var rpAssets = context.RPAssetsManager;
            var rsPP     = rpAssets.rootSignaturePostProcess;

            graphicsContext.SetCBVR(constantBuffer, 0);
            graphicsContext.SetSRVT(context.UI1Texture, 1);
            graphicsContext.SetMesh(context.ndcQuadMesh);

            PSODesc desc;

            desc.blendState        = EBlendState.alpha;
            desc.cullMode          = ECullMode.none;
            desc.depthBias         = 0;
            desc.dsvFormat         = DxgiFormat.DXGI_FORMAT_UNKNOWN;
            desc.inputLayout       = EInputLayout.postProcess;
            desc.ptt               = ED3D12PrimitiveTopologyType.TRIANGLE;
            desc.rtvFormat         = context.swapChainFormat;
            desc.renderTargetCount = 1;
            desc.streamOutput      = false;
            desc.wireFrame         = false;
            SetPipelineStateVariant(context.deviceResources, graphicsContext, rsPP, ref desc, rpAssets.PObjectWidgetUI1);
            graphicsContext.DrawIndexedInstanced(context.ndcQuadMeshIndexCount, 0, 0, allocated, 0);

            var selectedEntity = context.dynamicContextRead.selectedEntity;

            if (selectedEntity != null)
            {
                desc.ptt = ED3D12PrimitiveTopologyType.TRIANGLE;
                graphicsContext.SetSRVT(context.ScreenSizeDSVs[0], 2);
                graphicsContext.SetCBVR(bgConstantBuffers[0], 0);
                graphicsContext.SetCBVR(context.CBs_Bone[indexOfSelectedEntity], 3);
                SetPipelineStateVariant(context.deviceResources, graphicsContext, rsPP, ref desc, rpAssets.PObjectWidgetUI2);

                graphicsContext.DrawIndexedInstanced(context.ndcQuadMeshIndexCount, 0, 0, selectedEntity.rendererComponent.bones.Count, 0);
            }
            var selectedLight = context.dynamicContextRead.selectedLightings;

            if (selectedLight.Count > 0)
            {
                desc.ptt = ED3D12PrimitiveTopologyType.LINE;
                graphicsContext.SetMesh(context.cubeWireMesh);
                graphicsContext.SetCBVR(bgConstantBuffers[1], 0);
                SetPipelineStateVariant(context.deviceResources, graphicsContext, rsPP, ref desc, rpAssets.PObjectWidgetUILight);

                graphicsContext.DrawIndexedInstanced(context.cubeWireMeshIndexCount, 0, 0, selectedLight.Count, 0);
            }
        }
Exemple #6
0
        public override void RenderCamera(RenderPipelineContext context)
        {
            var graphicsContext = context.graphicsContext;

            graphicsContext.SetRootSignature(context.RPAssetsManager.rootSignaturePostProcess);
            graphicsContext.SetRenderTargetScreen(context.dynamicContextRead.settings.backgroundColor, context.ScreenSizeDSVs[1], true, true);
            graphicsContext.SetCBVR(postProcessDataBuffer, 0);
            graphicsContext.SetSRVT(context.outputRTV, 1);
            graphicsContext.SetSRVT(context.postProcessBackground, 2);
            graphicsContext.SetMesh(context.ndcQuadMesh);
            graphicsContext.SetPObject(context.RPAssetsManager.PObjectPostProcess, CullMode.back);
            graphicsContext.DrawIndexed(context.ndcQuadMeshIndexCount, 0, 0);
        }
Exemple #7
0
        public override void PrepareRenderData(RenderPipelineContext context, GraphicsContext graphicsContext)
        {
            var rendererComponents = context.dynamicContextRead.rendererComponents;
            var deviceResources    = context.deviceResources;
            int countMaterials     = 0;

            for (int i = 0; i < rendererComponents.Count; i++)
            {
                countMaterials += rendererComponents[i].Materials.Count;
            }
            DesireMaterialBuffers(deviceResources, countMaterials);
            var     cameras          = context.dynamicContextRead.cameras;
            var     camera           = context.dynamicContextRead.cameras[0];
            ref var settings         = ref context.dynamicContextRead.settings;
Exemple #8
0
 public abstract void RenderCamera(RenderPipelineContext context, GraphicsContext graphicsContext);
Exemple #9
0
 public abstract void PrepareRenderData(RenderPipelineContext context, GraphicsContext graphicsContext);
        public override void PrepareRenderData(RenderPipelineContext context)
        {
            if (!context.dynamicContextRead.settings.ViewerUI)
            {
                return;
            }
            var     graphicsContext = context.graphicsContext;
            IntPtr  pData           = Marshal.UnsafeAddrOfPinnedArrayElement(context.bigBuffer, 0);
            Vector2 screenSize      = new Vector2(context.screenWidth, context.screenHeight) / context.logicScale;

            Marshal.StructureToPtr(screenSize, pData, true);

            allocated = 0;
            int allocatedSize = 32;

            void write(_Data data1)
            {
                Marshal.StructureToPtr(data1, pData + allocatedSize, true);
                allocatedSize += 32;
                allocated++;
            }

            #region Buttons
            write(new _Data()
            {
                size     = c_buttonSize,
                offset   = new Vector2(screenSize.X, 0) + new Vector2(-192, 64),
                uvSize   = new Vector2(0.25f, 0.25f),
                uvOffset = new Vector2(0, 0),
            });
            write(new _Data()
            {
                size     = c_buttonSize,
                offset   = new Vector2(screenSize.X, 0) + new Vector2(-128, 64),
                uvSize   = new Vector2(0.25f, 0.25f),
                uvOffset = new Vector2(0.25f, 0),
            });
            write(new _Data()
            {
                size     = c_buttonSize,
                offset   = new Vector2(screenSize.X, 0) + new Vector2(-64, 64),
                uvSize   = new Vector2(0.25f, 0.25f),
                uvOffset = new Vector2(0.5f, 0),
            });
            write(new _Data()
            {
                size     = c_buttonSize,
                offset   = new Vector2(screenSize.X, 0) + new Vector2(-192, 0),
                uvSize   = new Vector2(0.25f, 0.25f),
                uvOffset = new Vector2(0, 0.25f),
            });
            write(new _Data()
            {
                size     = c_buttonSize,
                offset   = new Vector2(screenSize.X, 0) + new Vector2(-128, 0),
                uvSize   = new Vector2(0.25f, 0.25f),
                uvOffset = new Vector2(0.25f, 0.25f),
            });
            write(new _Data()
            {
                size     = c_buttonSize,
                offset   = new Vector2(screenSize.X, 0) + new Vector2(-64, 0),
                uvSize   = new Vector2(0.25f, 0.25f),
                uvOffset = new Vector2(0.5f, 0.25f),
            });
            #endregion

            graphicsContext.UpdateResource(constantBuffers[0], context.bigBuffer, c_bufferSize, 0);

            var cam = context.dynamicContextRead.cameras[0];

            var selectedEntity = context.dynamicContextRead.selectedEntity;
            if (selectedEntity != null)
            {
                indexOfSelectedEntity = context.dynamicContextRead.entities.IndexOf(selectedEntity);
                Matrix4x4.Invert(cam.pMatrix, out Matrix4x4 mat1);
                Marshal.StructureToPtr(Matrix4x4.Transpose(cam.vpMatrix), pData, true);
                Marshal.StructureToPtr(Matrix4x4.Transpose(mat1), pData + 64, true);
                Marshal.StructureToPtr(new _Data()
                {
                    size     = new Vector2(16, 16),
                    offset   = new Vector2(0, 0),
                    uvSize   = new Vector2(0.25f, 0.25f),
                    uvOffset = new Vector2(0, 0),
                }, pData + 128, true);
                Marshal.StructureToPtr(screenSize, pData + 160, true);
                var bones = selectedEntity.boneComponent.bones;
                for (int i = 0; i < bones.Count; i++)
                {
                    Marshal.StructureToPtr(bones[i].staticPosition, pData + i * 16 + 256, true);
                }
                graphicsContext.UpdateResource(bgConstantBuffers[0], context.bigBuffer, c_bgBufferSize, 0);
            }
            var selectedLight = context.dynamicContextRead.selectedLightings;
            for (int i = 0; i < selectedLight.Count; i++)
            {
                Marshal.StructureToPtr(Matrix4x4.Transpose(cam.vpMatrix), pData, true);
                Marshal.StructureToPtr(selectedLight[i].Position - cam.Pos, pData + i * 16 + 128, true);
                Marshal.StructureToPtr(selectedLight[i].Range, pData + i * 16 + 140, true);
                if (i >= 1024)
                {
                    break;
                }
            }
            if (selectedLight.Count > 0)
            {
                graphicsContext.UpdateResource(bgConstantBuffers[1], context.bigBuffer, c_bgBufferSize, 0);
            }
        }
 public override void PrepareRenderData(RenderPipelineContext context)
 {
     var     deviceResources  = context.deviceResources;
     var     cameras          = context.dynamicContextRead.cameras;
     var     graphicsContext  = context.graphicsContext;
     ref var settings         = ref context.dynamicContextRead.settings;
 public override void PrepareRenderData(RenderPipelineContext context, GraphicsContext graphicsContext)
 {
     Marshal.StructureToPtr(innerStruct, Marshal.UnsafeAddrOfPinnedArrayElement(context.bigBuffer, 0), true);
     graphicsContext.UpdateResource(postProcessDataBuffer, context.bigBuffer, c_postProcessDataSize, 0);
 }
 public abstract void RenderCamera(RenderPipelineContext context);