Пример #1
0
        void recordDraw(CommandBuffer cmd, Framebuffer fb)
        {
            renderPass.Begin(cmd, fb);

            cmd.SetViewport(fb.Width, fb.Height);
            cmd.SetScissor(fb.Width, fb.Height);

            cmd.BindDescriptorSet(gBuffPipeline.Layout, dsMain);

            envCube.RecordDraw(cmd);
            renderPass.BeginSubPass(cmd);

            if (model != null)
            {
                gBuffPipeline.Bind(cmd);
                model.Bind(cmd);
                model.DrawAll(cmd, gBuffPipeline.Layout);
            }
            renderPass.BeginSubPass(cmd);

            cmd.BindDescriptorSet(composePipeline.Layout, dsGBuff, 1);

            if (currentDebugView == DebugView.none)
            {
                composePipeline.Bind(cmd);
            }
            else
            {
                debugPipeline.Bind(cmd);
                uint debugValue = (uint)currentDebugView - 1;
                if (currentDebugView == DebugView.shadowMap)
                {
                    debugValue += (uint)((lightNumDebug << 8));
                }
                else
                {
                    debugValue += (uint)((debugFace << 8) + (debugMip << 16));
                }
                cmd.PushConstant(debugPipeline.Layout, VkShaderStageFlags.Fragment, debugValue, (uint)Marshal.SizeOf <Matrix4x4> ());
            }

            cmd.Draw(3, 1, 0, 0);

            renderPass.BeginSubPass(cmd);
            toneMappingPipeline.Bind(cmd);
            cmd.Draw(3, 1, 0, 0);

            renderPass.End(cmd);
        }
Пример #2
0
        void recordDraw(CommandBuffer cmd, Framebuffer fb)
        {
            cmd.BeginRegion("models", 0.5f, 1f, 0f);
            pipeline.RenderPass.Begin(cmd, fb);

            cmd.SetViewport(fb.Width, fb.Height);
            cmd.SetScissor(fb.Width, fb.Height);

            cmd.BindDescriptorSet(pipeline.Layout, dsMats);
            pipeline.Bind(cmd);
            model.Bind(cmd);
            model.DrawAll(cmd, pipeline.Layout);

            cmd.EndRegion();
            cmd.BeginRegion("vkvg", 0.5f, 1f, 0f);
            uiPipeline.Bind(cmd);

            timestampQPool.Start(cmd);

            vkvgImage.SetLayout(cmd, VkImageAspectFlags.Color, VkImageLayout.ColorAttachmentOptimal, VkImageLayout.ShaderReadOnlyOptimal,
                                VkPipelineStageFlags.ColorAttachmentOutput, VkPipelineStageFlags.FragmentShader);

            cmd.Draw(3, 1, 0, 0);

            vkvgImage.SetLayout(cmd, VkImageAspectFlags.Color, VkImageLayout.ShaderReadOnlyOptimal, VkImageLayout.ColorAttachmentOptimal,
                                VkPipelineStageFlags.FragmentShader, VkPipelineStageFlags.BottomOfPipe);

            timestampQPool.End(cmd);

            pipeline.RenderPass.End(cmd);
            cmd.EndRegion();
        }
Пример #3
0
        public void update_shadow_map(CommandPool cmdPool)
        {
            update_light_matrices();

            CommandBuffer cmd = cmdPool.AllocateAndStart();

            shadowPass.Begin(cmd, fbShadowMap);

            cmd.SetViewport(SHADOWMAP_SIZE, SHADOWMAP_SIZE);
            cmd.SetScissor(SHADOWMAP_SIZE, SHADOWMAP_SIZE);

            cmd.BindDescriptorSet(shadowPipeline.Layout, dsShadow);

            Vk.vkCmdSetDepthBias(cmd.Handle, depthBiasConstant, 0.0f, depthBiasSlope);

            shadowPipeline.Bind(cmd);

            if (renderer.model != null)
            {
                renderer.model.Bind(cmd);
                renderer.model.DrawAll(cmd, shadowPipeline.Layout, true);
            }

            shadowPass.End(cmd);

            renderer.presentQueue.EndSubmitAndWait(cmd);
            updateShadowMap = false;
        }
Пример #4
0
            //TODO:destset for binding must be variable
            //TODO: ADD REFAULT MAT IF NO MAT DEFINED
            public override void RenderNode(CommandBuffer cmd, PipelineLayout pipelineLayout, Node node, Matrix4x4 currentTransform, bool shadowPass = false)
            {
                Matrix4x4 localMat = node.localMatrix * currentTransform;

                cmd.PushConstant(pipelineLayout, VkShaderStageFlags.Vertex, localMat);

                if (node.Mesh != null)
                {
                    foreach (Primitive p in node.Mesh.Primitives)
                    {
                        cmd.PushConstant(pipelineLayout, VkShaderStageFlags.Fragment, (int)p.material, (uint)Marshal.SizeOf <Matrix4x4> ());
                        if (descriptorSets[p.material] != null)
                        {
                            cmd.BindDescriptorSet(pipelineLayout, descriptorSets[p.material], 1);
                        }
                        cmd.DrawIndexed(p.indexCount, 1, p.indexBase, p.vertexBase, 0);
                    }
                }
                if (node.Children == null)
                {
                    return;
                }
                foreach (Node child in node.Children)
                {
                    RenderNode(cmd, pipelineLayout, child, localMat);
                }
            }
Пример #5
0
        void recordDraw(CommandBuffer cmd, Framebuffer fb)
        {
            renderPass.Begin(cmd, fb);

            cmd.SetViewport(fb.Width, fb.Height);
            cmd.SetScissor(fb.Width, fb.Height);

            cmd.BindDescriptorSet(gBuffPipeline.Layout, dsMain);
            gBuffPipeline.Bind(cmd);
            model.Bind(cmd);
            model.DrawAll(cmd, gBuffPipeline.Layout);

            renderPass.BeginSubPass(cmd);

            cmd.BindDescriptorSet(composePipeline.Layout, dsGBuff, 2);
            composePipeline.Bind(cmd);

            cmd.Draw(3, 1, 0, 0);

            renderPass.End(cmd);
        }
Пример #6
0
        void recordDraw(CommandBuffer cmd, Framebuffer fb)
        {
            pipeline.RenderPass.Begin(cmd, fb);

            cmd.SetViewport(fb.Width, fb.Height);
            cmd.SetScissor(fb.Width, fb.Height);
            cmd.BindDescriptorSet(pipeline.Layout, descriptorSet);

            pipeline.Bind(cmd);

            cmd.BindVertexBuffer(vbo, 0);
            cmd.Draw(36);

            pipeline.RenderPass.End(cmd);
        }
Пример #7
0
        void recordDraw(CommandBuffer cmd, Framebuffer fb)
        {
            texture.SetLayout(cmd, VkImageAspectFlags.Color, VkImageLayout.Undefined, VkImageLayout.ShaderReadOnlyOptimal,
                              VkPipelineStageFlags.BottomOfPipe, VkPipelineStageFlags.FragmentShader);

            pipeline.RenderPass.Begin(cmd, fb);

            cmd.SetViewport(fb.Width, fb.Height);
            cmd.SetScissor(fb.Width, fb.Height);
            cmd.BindDescriptorSet(pipeline.Layout, descriptorSet);

            pipeline.Bind(cmd);

            cmd.BindVertexBuffer(vbo, 0);
            cmd.BindIndexBuffer(ibo, VkIndexType.Uint16);
            cmd.DrawIndexed((uint)indices.Length);

            pipeline.RenderPass.End(cmd);
        }
Пример #8
0
        void recordDraw(CommandBuffer cmd, Framebuffer fb)
        {
            uiPipeline.RenderPass.Begin(cmd, fb);

            cmd.SetViewport(fb.Width, fb.Height);
            cmd.SetScissor(fb.Width, fb.Height);

            uiPipeline.Bind(cmd);
            cmd.BindDescriptorSet(uiPipeline.Layout, dsVkvg);

            vkvgImage.SetLayout(cmd, VkImageAspectFlags.Color, VkImageLayout.ColorAttachmentOptimal, VkImageLayout.ShaderReadOnlyOptimal,
                                VkPipelineStageFlags.ColorAttachmentOutput, VkPipelineStageFlags.FragmentShader);

            cmd.Draw(3, 1, 0, 0);

            vkvgImage.SetLayout(cmd, VkImageAspectFlags.Color, VkImageLayout.ShaderReadOnlyOptimal, VkImageLayout.ColorAttachmentOptimal,
                                VkPipelineStageFlags.FragmentShader, VkPipelineStageFlags.BottomOfPipe);


            uiPipeline.RenderPass.End(cmd);
        }