X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git;a=blobdiff_plain;f=automated-tests%2Fsrc%2Fdali-toolkit%2Fdali-toolkit-test-utils%2Ftest-graphics-command-buffer.h;h=407dadefb9fac71018aff54d63a78714e38cbadb;hp=b07166c1d149db0cabc41d074558491dd5102459;hb=fece0e05db90e80f3177d434f6f21a245b965f9c;hpb=cc7c738325821be41979913e81fffb961656e0c0 diff --git a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-graphics-command-buffer.h b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-graphics-command-buffer.h index b07166c..407dade 100644 --- a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-graphics-command-buffer.h +++ b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-graphics-command-buffer.h @@ -2,7 +2,7 @@ #define DALI_TEST_GRAPHICS_COMMAND_BUFFER_H /* - * Copyright (c) 2021 Samsung Electronics Co., Ltd. + * Copyright (c) 2022 Samsung Electronics Co., Ltd. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -32,27 +32,46 @@ namespace Dali { class TestGraphicsTexture; class TestGraphicsBuffer; +class TestGraphicsCommandBuffer; class TestGraphicsSampler; class TestGraphicsPipeline; enum class CommandType { - FLUSH = 1 << 0, - BIND_TEXTURES = 1 << 1, - BIND_SAMPLERS = 1 << 2, - BIND_VERTEX_BUFFERS = 1 << 3, - BIND_INDEX_BUFFER = 1 << 4, - BIND_UNIFORM_BUFFER = 1 << 5, - BIND_PIPELINE = 1 << 6, - DRAW = 1 << 7, - DRAW_INDEXED = 1 << 8, - DRAW_INDEXED_INDIRECT = 1 << 9, - SET_SCISSOR = 1 << 10, - SET_SCISSOR_TEST = 1 << 11, - SET_VIEWPORT = 1 << 12, - SET_VIEWPORT_TEST = 1 << 13 + FLUSH = 1 << 0, + BIND_TEXTURES = 1 << 1, + BIND_SAMPLERS = 1 << 2, + BIND_VERTEX_BUFFERS = 1 << 3, + BIND_INDEX_BUFFER = 1 << 4, + BIND_UNIFORM_BUFFER = 1 << 5, + BIND_PIPELINE = 1 << 6, + DRAW = 1 << 7, + DRAW_INDEXED = 1 << 8, + DRAW_INDEXED_INDIRECT = 1 << 9, + SET_SCISSOR = 1 << 10, + SET_SCISSOR_TEST = 1 << 11, + SET_VIEWPORT = 1 << 12, + SET_VIEWPORT_TEST = 1 << 13, + BEGIN_RENDER_PASS = 1 << 14, + END_RENDER_PASS = 1 << 15, + EXECUTE_COMMAND_BUFFERS = 1 << 16, + SET_COLOR_MASK = 1 << 17, + CLEAR_STENCIL_BUFFER = 1 << 18, + CLEAR_DEPTH_BUFFER = 1 << 19, + SET_STENCIL_TEST_ENABLE = 1 << 20, + SET_STENCIL_WRITE_MASK = 1 << 21, + SET_STENCIL_OP = 1 << 22, + SET_STENCIL_FUNC = 1 << 23, + SET_DEPTH_COMPARE_OP = 1 << 24, + SET_DEPTH_TEST_ENABLE = 1 << 25, + SET_DEPTH_WRITE_ENABLE = 1 << 26, + DRAW_NATIVE = 1 << 27, }; +std::ostream& operator<<(std::ostream& os, Graphics::StencilOp op); + +std::ostream& operator<<(std::ostream& os, Graphics::CompareOp op); + using CommandTypeMask = uint32_t; template inline CommandTypeMask operator|(T flags, CommandType bit) @@ -105,7 +124,8 @@ struct DrawCallDescriptor { DRAW, DRAW_INDEXED, - DRAW_INDEXED_INDIRECT + DRAW_INDEXED_INDIRECT, + DRAW_NATIVE }; Type type{}; ///< Type of the draw call @@ -148,6 +168,11 @@ struct DrawCallDescriptor uint32_t drawCount; uint32_t stride; } drawIndexedIndirect; + + struct + { + Graphics::DrawNativeInfo drawNativeInfo; + } drawNative; }; }; @@ -160,8 +185,37 @@ struct Command { } + Command(CommandType type) + : type(type) + { + // do non-trivial initialization + switch(type) + { + case CommandType::BEGIN_RENDER_PASS: + { + new(&data.beginRenderPass) CommandData::BeginRenderPassDescriptor(); + break; + } + default: + { + } + } + } + ~Command() { + switch(type) + { + case CommandType::BEGIN_RENDER_PASS: + { + data.beginRenderPass.~BeginRenderPassDescriptor(); + break; + } + default: + { + break; + } + } } /** @@ -172,52 +226,74 @@ struct Command { switch(rhs.type) { + case CommandType::BEGIN_RENDER_PASS: + { + new(&data.beginRenderPass) CommandData::BeginRenderPassDescriptor(rhs.data.beginRenderPass); + break; + } + case CommandType::END_RENDER_PASS: + { + data.endRenderPass = rhs.data.endRenderPass; + break; + } + case CommandType::EXECUTE_COMMAND_BUFFERS: + { + data.executeCommandBuffers = rhs.data.executeCommandBuffers; + break; + } + case CommandType::BIND_VERTEX_BUFFERS: { - bindVertexBuffers = rhs.bindVertexBuffers; + data.bindVertexBuffers = rhs.data.bindVertexBuffers; break; } case CommandType::BIND_INDEX_BUFFER: { - bindIndexBuffer = rhs.bindIndexBuffer; + data.bindIndexBuffer = rhs.data.bindIndexBuffer; break; } case CommandType::BIND_SAMPLERS: { - bindSamplers = rhs.bindSamplers; + data.bindSamplers = rhs.data.bindSamplers; break; } case CommandType::BIND_TEXTURES: { - bindTextures = rhs.bindTextures; + data.bindTextures = rhs.data.bindTextures; break; } case CommandType::BIND_PIPELINE: { - bindPipeline = rhs.bindPipeline; + data.bindPipeline = rhs.data.bindPipeline; break; } case CommandType::BIND_UNIFORM_BUFFER: { - bindUniformBuffers = rhs.bindUniformBuffers; + data.bindUniformBuffers = rhs.data.bindUniformBuffers; + break; + } + case CommandType::DRAW_NATIVE: + { + data.draw.type = rhs.data.draw.type; + data.draw.drawNative = rhs.data.draw.drawNative; break; } case CommandType::DRAW: { - draw.type = rhs.draw.type; - draw.draw = rhs.draw.draw; + data.draw.type = rhs.data.draw.type; + data.draw.draw = rhs.data.draw.draw; break; } case CommandType::DRAW_INDEXED: { - draw.type = rhs.draw.type; - draw.drawIndexed = rhs.draw.drawIndexed; + data.draw.type = rhs.data.draw.type; + data.draw.drawIndexed = rhs.data.draw.drawIndexed; break; } case CommandType::DRAW_INDEXED_INDIRECT: { - draw.type = rhs.draw.type; - draw.drawIndexedIndirect = rhs.draw.drawIndexedIndirect; + data.draw.type = rhs.data.draw.type; + data.draw.drawIndexedIndirect = rhs.data.draw.drawIndexedIndirect; break; } case CommandType::FLUSH: @@ -227,22 +303,75 @@ struct Command } case CommandType::SET_SCISSOR: { - scissor.region = rhs.scissor.region; + data.scissor.region = rhs.data.scissor.region; break; } case CommandType::SET_SCISSOR_TEST: { - scissorTest.enable = rhs.scissorTest.enable; + data.scissorTest.enable = rhs.data.scissorTest.enable; break; } case CommandType::SET_VIEWPORT: { - viewport.region = rhs.viewport.region; + data.viewport.region = rhs.data.viewport.region; break; } case CommandType::SET_VIEWPORT_TEST: { - viewportTest.enable = rhs.viewportTest.enable; + data.viewportTest.enable = rhs.data.viewportTest.enable; + break; + } + case CommandType::SET_COLOR_MASK: + { + data.colorMask.enabled = rhs.data.colorMask.enabled; + break; + } + case CommandType::CLEAR_STENCIL_BUFFER: + { + break; + } + case CommandType::CLEAR_DEPTH_BUFFER: + { + break; + } + case CommandType::SET_STENCIL_TEST_ENABLE: + { + data.stencilTest.enabled = rhs.data.stencilTest.enabled; + break; + } + case CommandType::SET_STENCIL_FUNC: + { + data.stencilFunc.compareMask = rhs.data.stencilFunc.compareMask; + data.stencilFunc.compareOp = rhs.data.stencilFunc.compareOp; + data.stencilFunc.reference = rhs.data.stencilFunc.reference; + break; + } + case CommandType::SET_STENCIL_WRITE_MASK: + { + data.stencilWriteMask.mask = rhs.data.stencilWriteMask.mask; + break; + } + case CommandType::SET_STENCIL_OP: + { + data.stencilOp.failOp = rhs.data.stencilOp.failOp; + data.stencilOp.depthFailOp = rhs.data.stencilOp.depthFailOp; + data.stencilOp.passOp = rhs.data.stencilOp.passOp; + break; + } + + case CommandType::SET_DEPTH_COMPARE_OP: + { + data.depth.compareOp = rhs.data.depth.compareOp; + break; + } + case CommandType::SET_DEPTH_TEST_ENABLE: + { + data.depth.testEnabled = rhs.data.depth.testEnabled; + break; + } + case CommandType::SET_DEPTH_WRITE_ENABLE: + { + data.depth.writeEnabled = rhs.data.depth.writeEnabled; break; } } @@ -257,52 +386,73 @@ struct Command { switch(rhs.type) { + case CommandType::BEGIN_RENDER_PASS: + { + new(&data.beginRenderPass) CommandData::BeginRenderPassDescriptor(std::move(rhs.data.beginRenderPass)); + break; + } + case CommandType::END_RENDER_PASS: + { + data.endRenderPass = std::move(rhs.data.endRenderPass); + break; + } + case CommandType::EXECUTE_COMMAND_BUFFERS: + { + data.executeCommandBuffers = std::move(rhs.data.executeCommandBuffers); + break; + } case CommandType::BIND_VERTEX_BUFFERS: { - bindVertexBuffers = std::move(rhs.bindVertexBuffers); + data.bindVertexBuffers = std::move(rhs.data.bindVertexBuffers); break; } case CommandType::BIND_INDEX_BUFFER: { - bindIndexBuffer = rhs.bindIndexBuffer; + data.bindIndexBuffer = rhs.data.bindIndexBuffer; break; } case CommandType::BIND_UNIFORM_BUFFER: { - bindUniformBuffers = std::move(rhs.bindUniformBuffers); + data.bindUniformBuffers = std::move(rhs.data.bindUniformBuffers); break; } case CommandType::BIND_SAMPLERS: { - bindSamplers = std::move(rhs.bindSamplers); + data.bindSamplers = std::move(rhs.data.bindSamplers); break; } case CommandType::BIND_TEXTURES: { - bindTextures = std::move(rhs.bindTextures); + data.bindTextures = std::move(rhs.data.bindTextures); break; } case CommandType::BIND_PIPELINE: { - bindPipeline = rhs.bindPipeline; + data.bindPipeline = rhs.data.bindPipeline; + break; + } + case CommandType::DRAW_NATIVE: + { + data.draw.type = rhs.data.draw.type; + data.draw.drawNative = rhs.data.draw.drawNative; break; } case CommandType::DRAW: { - draw.type = rhs.draw.type; - draw.draw = rhs.draw.draw; + data.draw.type = rhs.data.draw.type; + data.draw.draw = rhs.data.draw.draw; break; } case CommandType::DRAW_INDEXED: { - draw.type = rhs.draw.type; - draw.drawIndexed = rhs.draw.drawIndexed; + data.draw.type = rhs.data.draw.type; + data.draw.drawIndexed = rhs.data.draw.drawIndexed; break; } case CommandType::DRAW_INDEXED_INDIRECT: { - draw.type = rhs.draw.type; - draw.drawIndexedIndirect = rhs.draw.drawIndexedIndirect; + data.draw.type = rhs.data.draw.type; + data.draw.drawIndexedIndirect = rhs.data.draw.drawIndexedIndirect; break; } case CommandType::FLUSH: @@ -312,22 +462,75 @@ struct Command } case CommandType::SET_SCISSOR: { - scissor.region = rhs.scissor.region; + data.scissor.region = rhs.data.scissor.region; break; } case CommandType::SET_SCISSOR_TEST: { - scissorTest.enable = rhs.scissorTest.enable; + data.scissorTest.enable = rhs.data.scissorTest.enable; break; } case CommandType::SET_VIEWPORT: { - viewport.region = rhs.viewport.region; + data.viewport.region = rhs.data.viewport.region; break; } case CommandType::SET_VIEWPORT_TEST: { - viewportTest.enable = rhs.viewportTest.enable; + data.viewportTest.enable = rhs.data.viewportTest.enable; + break; + } + + case CommandType::SET_COLOR_MASK: + { + data.colorMask.enabled = rhs.data.colorMask.enabled; + break; + } + case CommandType::CLEAR_STENCIL_BUFFER: + { + break; + } + case CommandType::CLEAR_DEPTH_BUFFER: + { + break; + } + case CommandType::SET_STENCIL_TEST_ENABLE: + { + data.stencilTest.enabled = rhs.data.stencilTest.enabled; + break; + } + case CommandType::SET_STENCIL_WRITE_MASK: + { + data.stencilWriteMask.mask = rhs.data.stencilWriteMask.mask; + break; + } + case CommandType::SET_STENCIL_OP: + { + data.stencilOp.failOp = rhs.data.stencilOp.failOp; + data.stencilOp.depthFailOp = rhs.data.stencilOp.depthFailOp; + data.stencilOp.passOp = rhs.data.stencilOp.passOp; + break; + } + case CommandType::SET_STENCIL_FUNC: + { + data.stencilFunc.compareMask = rhs.data.stencilFunc.compareMask; + data.stencilFunc.compareOp = rhs.data.stencilFunc.compareOp; + data.stencilFunc.reference = rhs.data.stencilFunc.reference; + break; + } + case CommandType::SET_DEPTH_COMPARE_OP: + { + data.depth.compareOp = rhs.data.depth.compareOp; + break; + } + case CommandType::SET_DEPTH_TEST_ENABLE: + { + data.depth.testEnabled = rhs.data.depth.testEnabled; + break; + } + case CommandType::SET_DEPTH_WRITE_ENABLE: + { + data.depth.writeEnabled = rhs.data.depth.writeEnabled; break; } } @@ -336,8 +539,16 @@ struct Command CommandType type{CommandType::FLUSH}; ///< Type of command - union + union CommandData { + CommandData() + { + } + + ~CommandData() + { + } // do nothing + struct { std::vector textureBindings; @@ -390,7 +601,61 @@ struct Command { bool enable; } viewportTest; - }; + + struct BeginRenderPassDescriptor + { + Graphics::RenderPass* renderPass; + Graphics::RenderTarget* renderTarget; + Graphics::Rect2D renderArea; + std::vector clearValues; + } beginRenderPass; + + struct + { + Graphics::SyncObject* syncObject; + } endRenderPass; + + struct + { + std::vector buffers; + } executeCommandBuffers; + + struct + { + Graphics::CompareOp compareOp; + bool testEnabled; + bool writeEnabled; + } depth; + + struct + { + Graphics::StencilOp failOp; + Graphics::StencilOp passOp; + Graphics::StencilOp depthFailOp; + } stencilOp; + + struct + { + uint32_t mask; + } stencilWriteMask; + + struct + { + uint32_t compareMask; + Graphics::CompareOp compareOp; + uint32_t reference; + } stencilFunc; + + struct + { + bool enabled; + } stencilTest; + + struct + { + bool enabled; + } colorMask; + } data; }; class TestGraphicsCommandBuffer : public Graphics::CommandBuffer @@ -401,13 +666,13 @@ public: { } - void BindVertexBuffers(uint32_t firstBinding, - std::vector buffers, - std::vector offsets) override + void BindVertexBuffers(uint32_t firstBinding, + const std::vector& buffers, + const std::vector& offsets) override { mCommands.emplace_back(); mCommands.back().type = CommandType::BIND_VERTEX_BUFFERS; - auto& bindings = mCommands.back().bindVertexBuffers.vertexBufferBindings; + auto& bindings = mCommands.back().data.bindVertexBuffers.vertexBufferBindings; if(bindings.size() < firstBinding + buffers.size()) { bindings.resize(firstBinding + buffers.size()); @@ -427,7 +692,7 @@ public: mCommands.emplace_back(); auto& cmd = mCommands.back(); cmd.type = CommandType::BIND_UNIFORM_BUFFER; - auto& bindCmd = cmd.bindUniformBuffers; + auto& bindCmd = cmd.data.bindUniformBuffers; for(const auto& binding : bindings) { if(binding.buffer) @@ -461,23 +726,23 @@ public: void BindPipeline(const Graphics::Pipeline& pipeline) override { mCommands.emplace_back(); - mCommands.back().type = CommandType::BIND_PIPELINE; - mCommands.back().bindPipeline.pipeline = static_cast(&pipeline); + mCommands.back().type = CommandType::BIND_PIPELINE; + mCommands.back().data.bindPipeline.pipeline = static_cast(&pipeline); mCallStack.PushCall("BindPipeline", ""); } - void BindTextures(std::vector& textureBindings) override + void BindTextures(const std::vector& textureBindings) override { mCommands.emplace_back(); - mCommands.back().type = CommandType::BIND_TEXTURES; - mCommands.back().bindTextures.textureBindings = std::move(textureBindings); + mCommands.back().type = CommandType::BIND_TEXTURES; + mCommands.back().data.bindTextures.textureBindings = std::move(textureBindings); mCallStack.PushCall("BindTextures", ""); } - void BindSamplers(std::vector& samplerBindings) override + void BindSamplers(const std::vector& samplerBindings) override { mCommands.emplace_back(); - mCommands.back().bindSamplers.samplerBindings = std::move(samplerBindings); + mCommands.back().data.bindSamplers.samplerBindings = std::move(samplerBindings); mCallStack.PushCall("BindSamplers", ""); } @@ -493,20 +758,31 @@ public: Graphics::Format format) override { mCommands.emplace_back(); - mCommands.back().type = CommandType::BIND_INDEX_BUFFER; - mCommands.back().bindIndexBuffer.buffer = static_cast(&buffer); - mCommands.back().bindIndexBuffer.offset = offset; - mCommands.back().bindIndexBuffer.format = format; + mCommands.back().type = CommandType::BIND_INDEX_BUFFER; + mCommands.back().data.bindIndexBuffer.buffer = static_cast(&buffer); + mCommands.back().data.bindIndexBuffer.offset = offset; + mCommands.back().data.bindIndexBuffer.format = format; mCallStack.PushCall("BindIndexBuffer", ""); } void BeginRenderPass( - Graphics::RenderPass& renderPass, - Graphics::RenderTarget& renderTarget, - Graphics::Extent2D renderArea, - std::vector clearValues) override + Graphics::RenderPass* renderPass, + Graphics::RenderTarget* renderTarget, + Graphics::Rect2D renderArea, + const std::vector& clearValues) override { - mCallStack.PushCall("BeginRenderPass", ""); + mCommands.emplace_back(CommandType::BEGIN_RENDER_PASS); + auto& cmd = mCommands.back(); + cmd.data.beginRenderPass.renderPass = renderPass; + cmd.data.beginRenderPass.renderTarget = renderTarget; + cmd.data.beginRenderPass.renderArea = renderArea; + cmd.data.beginRenderPass.clearValues = clearValues; + + TraceCallStack::NamedParams namedParams; + namedParams["renderPass"] << std::hex << renderPass; + namedParams["renderTarget"] << std::hex << renderTarget; + namedParams["renderArea"] << renderArea.width << ", " << renderArea.height; + mCallStack.PushCall("BeginRenderPass", namedParams.str(), namedParams); } /** @@ -518,9 +794,39 @@ public: * dependencies (for example, to know when target texture is ready * before passing it to another render pass). */ - void EndRenderPass() override + void EndRenderPass(Graphics::SyncObject* syncObject) override + { + mCommands.emplace_back(CommandType::END_RENDER_PASS); + auto& cmd = mCommands.back(); + + cmd.data.endRenderPass.syncObject = syncObject; + + TraceCallStack::NamedParams namedParams; + namedParams["syncObject"] << std::hex << syncObject; + mCallStack.PushCall("EndRenderPass", namedParams.str(), namedParams); + } + + void ExecuteCommandBuffers(std::vector&& commandBuffers) override + { + mCommands.emplace_back(); + auto& cmd = mCommands.back(); + cmd.type = CommandType::EXECUTE_COMMAND_BUFFERS; + cmd.data.executeCommandBuffers.buffers.reserve(commandBuffers.size()); + for(auto&& item : commandBuffers) + { + cmd.data.executeCommandBuffers.buffers.emplace_back(static_cast(item)); + } + mCallStack.PushCall("ExecuteCommandBuffers", ""); + } + + void DrawNative(const Graphics::DrawNativeInfo* drawInfo) { - mCallStack.PushCall("EndRenderPass", ""); + mCommands.emplace_back(); + mCommands.back().type = CommandType::DRAW_NATIVE; + auto& cmd = mCommands.back().data.draw; + cmd.type = DrawCallDescriptor::Type::DRAW_NATIVE; + cmd.drawNative.drawNativeInfo = *drawInfo; + mCallStack.PushCall("DrawNative", ""); } void Draw( @@ -531,7 +837,7 @@ public: { mCommands.emplace_back(); mCommands.back().type = CommandType::DRAW; - auto& cmd = mCommands.back().draw; + auto& cmd = mCommands.back().data.draw; cmd.type = DrawCallDescriptor::Type::DRAW; cmd.draw.vertexCount = vertexCount; cmd.draw.instanceCount = instanceCount; @@ -549,7 +855,7 @@ public: { mCommands.emplace_back(); mCommands.back().type = CommandType::DRAW_INDEXED; - auto& cmd = mCommands.back().draw; + auto& cmd = mCommands.back().data.draw; cmd.type = DrawCallDescriptor::Type::DRAW_INDEXED; cmd.drawIndexed.firstIndex = firstIndex; cmd.drawIndexed.firstInstance = firstInstance; @@ -567,7 +873,7 @@ public: { mCommands.emplace_back(); mCommands.back().type = CommandType::DRAW_INDEXED_INDIRECT; - auto& cmd = mCommands.back().draw; + auto& cmd = mCommands.back().data.draw; cmd.type = DrawCallDescriptor::Type::DRAW_INDEXED_INDIRECT; cmd.drawIndexedIndirect.buffer = static_cast(&buffer); cmd.drawIndexedIndirect.offset = offset; @@ -592,8 +898,8 @@ public: mCallStack.PushCall("SetScissor", params.str(), params); mCommands.emplace_back(); - mCommands.back().type = CommandType::SET_SCISSOR; - mCommands.back().scissor.region = value; + mCommands.back().type = CommandType::SET_SCISSOR; + mCommands.back().data.scissor.region = value; } void SetScissorTestEnable(bool value) override @@ -603,8 +909,8 @@ public: mCallStack.PushCall("SetScissorTestEnable", params.str(), params); mCommands.emplace_back(); - mCommands.back().type = CommandType::SET_SCISSOR_TEST; - mCommands.back().scissorTest.enable = value; + mCommands.back().type = CommandType::SET_SCISSOR_TEST; + mCommands.back().data.scissorTest.enable = value; } void SetViewport(Graphics::Viewport value) override @@ -619,8 +925,8 @@ public: mCallStack.PushCall("SetViewport", params.str(), params); mCommands.emplace_back(); - mCommands.back().type = CommandType::SET_VIEWPORT; - mCommands.back().viewport.region = value; + mCommands.back().type = CommandType::SET_VIEWPORT; + mCommands.back().data.viewport.region = value; } void SetViewportEnable(bool value) override @@ -630,8 +936,114 @@ public: mCallStack.PushCall("SetViewportEnable", params.str(), params); mCommands.emplace_back(); - mCommands.back().type = CommandType::SET_VIEWPORT_TEST; - mCommands.back().viewportTest.enable = value; + mCommands.back().type = CommandType::SET_VIEWPORT_TEST; + mCommands.back().data.viewportTest.enable = value; + } + + void SetColorMask(bool enabled) override + { + TraceCallStack::NamedParams params; + params["enabled"] << (enabled ? "T" : "F"); + mCallStack.PushCall("SetColorMask", params.str(), params); + mCommands.emplace_back(); + mCommands.back().type = CommandType::SET_COLOR_MASK; + mCommands.back().data.colorMask.enabled = enabled; + } + + void ClearStencilBuffer() override + { + mCallStack.PushCall("SetStencilMask", ""); + mCommands.emplace_back(); + mCommands.back().type = CommandType::CLEAR_STENCIL_BUFFER; + } + + void SetStencilTestEnable(bool stencilEnable) override + { + TraceCallStack::NamedParams params; + params["enabled"] << (stencilEnable ? "T" : "F"); + mCallStack.PushCall("SetStencilTestEnable", params.str(), params); + mCommands.emplace_back(); + mCommands.back().type = CommandType::SET_STENCIL_TEST_ENABLE; + mCommands.back().data.stencilTest.enabled = stencilEnable; + } + + void SetStencilWriteMask(uint32_t writeMask) override + { + TraceCallStack::NamedParams params; + params["writeMask"] << std::hex << writeMask; + mCallStack.PushCall("SetStencilWriteMask", params.str(), params); + mCommands.emplace_back(); + mCommands.back().type = CommandType::SET_STENCIL_WRITE_MASK; + mCommands.back().data.stencilWriteMask.mask = writeMask; + } + + void SetStencilOp(Graphics::StencilOp failOp, + Graphics::StencilOp passOp, + Graphics::StencilOp depthFailOp) override + { + TraceCallStack::NamedParams params; + params["failOp"] << failOp; + params["passOp"] << passOp; + params["depthFailOp"] << depthFailOp; + mCallStack.PushCall("SetStencilOp", params.str(), params); + mCommands.emplace_back(); + mCommands.back().type = CommandType::SET_STENCIL_OP; + mCommands.back().data.stencilOp.failOp = failOp; + mCommands.back().data.stencilOp.passOp = passOp; + mCommands.back().data.stencilOp.depthFailOp = depthFailOp; + } + + void SetStencilFunc(Graphics::CompareOp compareOp, + uint32_t reference, + uint32_t compareMask) override + { + TraceCallStack::NamedParams params; + params["compareOp"] << compareOp; + params["compareMask"] << std::hex << compareMask; + params["reference"] << std::hex << reference; + mCallStack.PushCall("SetStencilFunc", params.str(), params); + + mCommands.emplace_back(); + mCommands.back().type = CommandType::SET_STENCIL_FUNC; + + mCommands.back().data.stencilFunc.compareOp = compareOp; + mCommands.back().data.stencilFunc.compareMask = compareMask; + mCommands.back().data.stencilFunc.reference = reference; + } + + void SetDepthCompareOp(Graphics::CompareOp compareOp) override + { + TraceCallStack::NamedParams params; + params["compareOp"] << compareOp; + mCallStack.PushCall("SetDepthCompareOp", params.str(), params); + mCommands.emplace_back(); + mCommands.back().type = CommandType::SET_DEPTH_COMPARE_OP; + mCommands.back().data.depth.compareOp = compareOp; + } + + void SetDepthTestEnable(bool depthTestEnable) override + { + TraceCallStack::NamedParams params; + params["enabled"] << (depthTestEnable ? "T" : "F"); + mCallStack.PushCall("SetDepthTestEnable", params.str(), params); + mCommands.emplace_back(); + mCommands.back().type = CommandType::SET_DEPTH_TEST_ENABLE; + mCommands.back().data.depth.testEnabled = depthTestEnable; + } + void SetDepthWriteEnable(bool depthWriteEnable) override + { + TraceCallStack::NamedParams params; + params["enabled"] << (depthWriteEnable ? "T" : "F"); + mCallStack.PushCall("SetDepthWriteEnable", params.str(), params); + mCommands.emplace_back(); + mCommands.back().type = CommandType::SET_DEPTH_WRITE_ENABLE; + mCommands.back().data.depth.writeEnabled = depthWriteEnable; + } + void ClearDepthBuffer() override + { + mCallStack.PushCall("ClearDepthBuffer", ""); + mCommands.emplace_back(); + mCommands.back().type = CommandType::CLEAR_DEPTH_BUFFER; } [[nodiscard]] const std::vector& GetCommands() const @@ -654,7 +1066,9 @@ public: /** * Retrieves commands of specified type */ - std::vector GetCommandsByType(CommandTypeMask mask); + std::vector GetCommandsByType(CommandTypeMask mask) const; + + std::vector GetChildCommandsByType(CommandTypeMask mask) const; private: TraceCallStack& mCallStack;