示例#1
0
        protected override void DrawCore(RenderContext context, RenderDrawContext drawContext)
        {
            var graphicsDevice  = drawContext.GraphicsDevice;
            var graphicsContext = drawContext.GraphicsContext;
            var commandList     = drawContext.GraphicsContext.CommandList;

            myCustomShader.UpdateEffect(graphicsDevice);
            var normal = new Vector3(1, 0, 0);

            VertexBuffer = Buffer.New(graphicsDevice, new[] { new VertexPositionNormalColor(new Vector3(-0.5f, -0.5f, 0.5f), normal, Color.Red), new VertexPositionNormalColor(new Vector3(0, 0.4f, -0.5f), normal, Color.Red), new VertexPositionNormalColor(new Vector3(10, 10f, 0f), normal, Color.Red), }, BufferFlags.VertexBuffer, GraphicsResourceUsage.Immutable);



            drawContext.CommandList.Clear(drawContext.CommandList.RenderTarget, Color.Green);
            drawContext.CommandList.Clear(drawContext.CommandList.DepthStencilBuffer, DepthStencilClearOptions.DepthBuffer);

            myCustomShader.Parameters.Set(TransformationKeys.WorldViewProjection, WorldMatrix);
            myCustomShader.Parameters.Set(test_shader1Keys.Color, Color.Red);

            pipelineState.State.RootSignature  = myCustomShader.RootSignature;
            pipelineState.State.EffectBytecode = myCustomShader.Effect.Bytecode;
            pipelineState.State.Output.CaptureState(commandList);
            pipelineState.Update();
            ;
            commandList.SetPipelineState(pipelineState.CurrentState);

            myCustomShader.Apply(graphicsContext);

            commandList.SetVertexBuffer(0, VertexBuffer, 0, VertexDeclaration.VertexStride);
            commandList.Draw(3);
        }
        public override void Draw(RenderDrawContext context, RenderView renderView, RenderViewStage renderViewStage, int startIndex, int endIndex)
        {
            // First do everything that doesn't change per individual render object
            var graphicsDevice  = context.GraphicsDevice;
            var graphicsContext = context.GraphicsContext;
            var commandList     = context.GraphicsContext.CommandList;

            // Refresh shader, might have changed during runtime
            myCustomShader.UpdateEffect(graphicsDevice);

            // Set common shader parameters if needed
            //myCustomShader.Parameters.Set(TransformationKeys.ViewProjection, renderView.ViewProjection);

            for (int index = startIndex; index < endIndex; index++)
            {
                var renderNodeReference = renderViewStage.SortedRenderNodes[index].RenderNode;
                var renderNode          = GetRenderNode(renderNodeReference);
                var myRenderObject      = (MyRenderObject)renderNode.RenderObject;

                if (myRenderObject.VertexBuffer == null)
                {
                    continue; //next render object
                }
                // Assign shader parameters
                myCustomShader.Parameters.Set(TransformationKeys.WorldViewProjection, myRenderObject.WorldMatrix * renderView.ViewProjection);
                myCustomShader.Parameters.Set(TexturingKeys.Texture0, myRenderObject.Texture);
                myCustomShader.Parameters.Set(MyCustomShaderKeys.TextureScale, myRenderObject.TextureScale);
                myCustomShader.Parameters.Set(MyCustomShaderKeys.Color, myRenderObject.Color);

                // Prepare pipeline state
                pipelineState.State.RootSignature  = myCustomShader.RootSignature;
                pipelineState.State.EffectBytecode = myCustomShader.Effect.Bytecode;
                pipelineState.State.Output.CaptureState(commandList);
                pipelineState.Update();
                commandList.SetPipelineState(pipelineState.CurrentState);

                // Apply the effect
                myCustomShader.Apply(graphicsContext);

                // Set vertex buffer and draw
                commandList.SetVertexBuffer(0, myRenderObject.VertexBuffer, 0, MyRenderObject.VertexDeclaration.VertexStride);
                commandList.Draw(MyRenderObject.VertexCount, 0);
            }
        }
示例#3
0
        void ILowLevelAPIRender.Draw(RenderContext renderContext, RenderDrawContext drawContext, RenderView renderView, RenderViewStage renderViewStage, CommandList commandList)
        {
            if (!enabledPin.Value)
            {
                return;
            }

            try
            {
                var pipelineState = this.pipelineState ?? (this.pipelineState = new MutablePipelineState(renderContext.GraphicsDevice));

                // TODO1: PerFrame could be done in Update if we'd have access to frame time
                // TODO2: This code can be optimized by using parameter accessors and not parameter keys
                parameters.SetPerFrameParameters(perFrameParams, drawContext.RenderContext);
                parameters.SetPerViewParameters(perViewParams, renderView);

                if (worldPin != null)
                {
                    var world = worldPin.ShaderValue;
                    parameters.SetPerDrawParameters(perDrawParams, renderView, ref world);
                }

                // Set permutation parameters before updating the effect (needed by compiler)
                parameters.Set(ComputeEffectShaderKeys.ThreadNumbers, threadNumbersPin.Value);

                // Give user chance to override
                parameterSetterPin?.Value.Invoke(parameters, renderView, drawContext);

                if (instance.UpdateEffect(renderContext.GraphicsDevice) || pipelineStateDirty)
                {
                    threadGroupCountAccessor = parameters.GetAccessor(ComputeShaderBaseKeys.ThreadGroupCountGlobal);
                    foreach (var p in Inputs.OfType <ParameterPin>())
                    {
                        p.Update(parameters);
                    }
                    pipelineState.State.SetDefaults();
                    pipelineState.State.RootSignature  = instance.RootSignature;
                    pipelineState.State.EffectBytecode = instance.Effect.Bytecode;
                    pipelineState.Update();
                    pipelineStateDirty = false;
                }

                // Apply pipeline state
                commandList.SetPipelineState(pipelineState.CurrentState);

                // Set thread group count as provided by input pin
                var threadGroupCount = dispatchCountPin.Value;
                parameters.Set(ComputeShaderBaseKeys.ThreadGroupCountGlobal, threadGroupCount);

                // TODO: This can be optimized by uploading only parameters from the PerDispatch groups - look in Xenkos RootEffectRenderFeature
                var iterationCount = Math.Max(iterationCountPin.Value, 1);
                for (int i = 0; i < iterationCount; i++)
                {
                    // Give user chance to override
                    iterationParameterSetterPin.Value?.Invoke(parameters, renderView, drawContext, i);

                    // The thread group count can be set for each dispatch
                    threadGroupCount = parameters.Get(threadGroupCountAccessor);

                    // Upload the parameters
                    instance.Apply(drawContext.GraphicsContext);

                    // Draw a full screen quad
                    commandList.Dispatch(threadGroupCount.X, threadGroupCount.Y, threadGroupCount.Z);
                }
            }
            catch (Exception e)
            {
                var re = new RuntimeException(e.InnermostException(), this);
                RuntimeGraph.ReportException(re);
            }
        }
        public override void Draw(RenderDrawContext context, RenderView renderView, RenderViewStage renderViewStage)
        {
            shader.UpdateEffect(context.GraphicsDevice);

            foreach (var renderNode in renderViewStage.SortedRenderNodes)
            {
                var renderMesh = renderNode.RenderObject as RenderMesh;
                if (renderMesh == null)
                {
                    continue;
                }

                // get wireframe script
                WireframeScript wireframeScript = null;
                if (renderMesh.Source is ModelComponent)
                {
                    wireframeScript = (renderMesh.Source as ModelComponent).Entity.Get <WireframeScript>();
                }

                if (wireframeScript == null || !wireframeScript.Enabled)
                {
                    continue;
                }

                MeshDraw drawData = renderMesh.ActiveMeshDraw;

                // bind VB
                for (int slot = 0; slot < drawData.VertexBuffers.Length; slot++)
                {
                    var vertexBuffer = drawData.VertexBuffers[slot];
                    context.CommandList.SetVertexBuffer(slot, vertexBuffer.Buffer, vertexBuffer.Offset, vertexBuffer.Stride);
                }

                // set shader parameters
                shader.Parameters.Set(TransformationKeys.WorldViewProjection, renderMesh.World * renderView.ViewProjection); // matrix
                shader.Parameters.Set(TransformationKeys.WorldScale, new Vector3(ScaleAdjust + 1.0f));                       // increase size to avoid z-fight
                shader.Parameters.Set(SinglePassWireframeShaderKeys.Viewport, new Vector4(context.RenderContext.RenderView.ViewSize, 0, 0));
                shader.Parameters.Set(SinglePassWireframeShaderKeys.LineWidth, wireframeScript.LineWidth);
                shader.Parameters.Set(SinglePassWireframeShaderKeys.LineColor, (Vector3)wireframeScript.Color);

                // prepare pipeline state
                pipelineState.State.RootSignature  = shader.RootSignature;
                pipelineState.State.EffectBytecode = shader.Effect.Bytecode;
                pipelineState.State.PrimitiveType  = drawData.PrimitiveType;

                pipelineState.State.Output.CaptureState(context.CommandList);
                pipelineState.Update();

                context.CommandList.SetIndexBuffer(drawData.IndexBuffer.Buffer, drawData.IndexBuffer.Offset, drawData.IndexBuffer.Is32Bit);
                context.CommandList.SetPipelineState(pipelineState.CurrentState);

                // apply the effect
                shader.Apply(context.GraphicsContext);

                if (drawData.IndexBuffer != null)
                {
                    context.CommandList.DrawIndexed(drawData.DrawCount, drawData.StartLocation);
                }
                else
                {
                    context.CommandList.Draw(drawData.DrawCount, drawData.StartLocation);
                }
            }
        }