DirectRendering:

[platform/core/uifw/dali-toolkit.git] / automated-tests / src / dali-toolkit / dali-toolkit-test-utils / test-graphics-command-buffer.h

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 (file)
--- 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
 
 /*
 #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.
  *
  * 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 TestGraphicsTexture;
 class TestGraphicsBuffer;

+class TestGraphicsCommandBuffer;

 class TestGraphicsSampler;
 class TestGraphicsPipeline;
 
 enum class CommandType
 {
 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<typename T>
 inline CommandTypeMask operator|(T flags, CommandType bit)
 using CommandTypeMask = uint32_t;
 template<typename T>
 inline CommandTypeMask operator|(T flags, CommandType bit)


@@ -105,7 +124,8 @@ struct DrawCallDescriptor
   {
     DRAW,
     DRAW_INDEXED,
   {
     DRAW,
     DRAW_INDEXED,

-    DRAW_INDEXED_INDIRECT
+    DRAW_INDEXED_INDIRECT,
+    DRAW_NATIVE

   };
 
   Type type{}; ///< Type of the draw call
   };
 
   Type type{}; ///< Type of the draw call


@@ -148,6 +168,11 @@ struct DrawCallDescriptor
       uint32_t                  drawCount;
       uint32_t                  stride;
     } drawIndexedIndirect;
       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()
   {
   ~Command()
   {

+    switch(type)
+    {
+      case CommandType::BEGIN_RENDER_PASS:
+      {
+        data.beginRenderPass.~BeginRenderPassDescriptor();
+        break;
+      }
+      default:
+      {
+        break;
+      }
+    }

   }
 
   /**
   }
 
   /**


@@ -172,52 +226,74 @@ struct Command
   {
     switch(rhs.type)
     {
   {
     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:
       {
       case CommandType::BIND_VERTEX_BUFFERS:
       {

-        bindVertexBuffers = rhs.bindVertexBuffers;
+        data.bindVertexBuffers = rhs.data.bindVertexBuffers;

         break;
       }
       case CommandType::BIND_INDEX_BUFFER:
       {
         break;
       }
       case CommandType::BIND_INDEX_BUFFER:
       {

-        bindIndexBuffer = rhs.bindIndexBuffer;
+        data.bindIndexBuffer = rhs.data.bindIndexBuffer;

         break;
       }
       case CommandType::BIND_SAMPLERS:
       {
         break;
       }
       case CommandType::BIND_SAMPLERS:
       {

-        bindSamplers = rhs.bindSamplers;
+        data.bindSamplers = rhs.data.bindSamplers;

         break;
       }
       case CommandType::BIND_TEXTURES:
       {
         break;
       }
       case CommandType::BIND_TEXTURES:
       {

-        bindTextures = rhs.bindTextures;
+        data.bindTextures = rhs.data.bindTextures;

         break;
       }
       case CommandType::BIND_PIPELINE:
       {
         break;
       }
       case CommandType::BIND_PIPELINE:
       {

-        bindPipeline = rhs.bindPipeline;
+        data.bindPipeline = rhs.data.bindPipeline;

         break;
       }
       case CommandType::BIND_UNIFORM_BUFFER:
       {
         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:
       {
         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:
       {
         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:
       {
         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:
         break;
       }
       case CommandType::FLUSH:


@@ -227,22 +303,75 @@ struct Command
       }
       case CommandType::SET_SCISSOR:
       {
       }
       case CommandType::SET_SCISSOR:
       {

-        scissor.region = rhs.scissor.region;
+        data.scissor.region = rhs.data.scissor.region;

         break;
       }
       case CommandType::SET_SCISSOR_TEST:
       {
         break;
       }
       case CommandType::SET_SCISSOR_TEST:
       {

-        scissorTest.enable = rhs.scissorTest.enable;
+        data.scissorTest.enable = rhs.data.scissorTest.enable;

         break;
       }
       case CommandType::SET_VIEWPORT:
       {
         break;
       }
       case CommandType::SET_VIEWPORT:
       {

-        viewport.region = rhs.viewport.region;
+        data.viewport.region = rhs.data.viewport.region;

         break;
       }
       case CommandType::SET_VIEWPORT_TEST:
       {
         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;
       }
     }
         break;
       }
     }


@@ -257,52 +386,73 @@ struct Command
   {
     switch(rhs.type)
     {
   {
     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:
       {
       case CommandType::BIND_VERTEX_BUFFERS:
       {

-        bindVertexBuffers = std::move(rhs.bindVertexBuffers);
+        data.bindVertexBuffers = std::move(rhs.data.bindVertexBuffers);

         break;
       }
       case CommandType::BIND_INDEX_BUFFER:
       {
         break;
       }
       case CommandType::BIND_INDEX_BUFFER:
       {

-        bindIndexBuffer = rhs.bindIndexBuffer;
+        data.bindIndexBuffer = rhs.data.bindIndexBuffer;

         break;
       }
       case CommandType::BIND_UNIFORM_BUFFER:
       {
         break;
       }
       case CommandType::BIND_UNIFORM_BUFFER:
       {

-        bindUniformBuffers = std::move(rhs.bindUniformBuffers);
+        data.bindUniformBuffers = std::move(rhs.data.bindUniformBuffers);

         break;
       }
       case CommandType::BIND_SAMPLERS:
       {
         break;
       }
       case CommandType::BIND_SAMPLERS:
       {

-        bindSamplers = std::move(rhs.bindSamplers);
+        data.bindSamplers = std::move(rhs.data.bindSamplers);

         break;
       }
       case CommandType::BIND_TEXTURES:
       {
         break;
       }
       case CommandType::BIND_TEXTURES:
       {

-        bindTextures = std::move(rhs.bindTextures);
+        data.bindTextures = std::move(rhs.data.bindTextures);

         break;
       }
       case CommandType::BIND_PIPELINE:
       {
         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:
       {
         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:
       {
         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:
       {
         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:
         break;
       }
       case CommandType::FLUSH:


@@ -312,22 +462,75 @@ struct Command
       }
       case CommandType::SET_SCISSOR:
       {
       }
       case CommandType::SET_SCISSOR:
       {

-        scissor.region = rhs.scissor.region;
+        data.scissor.region = rhs.data.scissor.region;

         break;
       }
       case CommandType::SET_SCISSOR_TEST:
       {
         break;
       }
       case CommandType::SET_SCISSOR_TEST:
       {

-        scissorTest.enable = rhs.scissorTest.enable;
+        data.scissorTest.enable = rhs.data.scissorTest.enable;

         break;
       }
       case CommandType::SET_VIEWPORT:
       {
         break;
       }
       case CommandType::SET_VIEWPORT:
       {

-        viewport.region = rhs.viewport.region;
+        data.viewport.region = rhs.data.viewport.region;

         break;
       }
       case CommandType::SET_VIEWPORT_TEST:
       {
         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;
       }
     }
         break;
       }
     }


@@ -336,8 +539,16 @@ struct Command
 
   CommandType type{CommandType::FLUSH}; ///< Type of command
 
 
   CommandType type{CommandType::FLUSH}; ///< Type of command
 

-  union
+  union CommandData

   {
   {

+    CommandData()
+    {
+    }
+
+    ~CommandData()
+    {
+    } // do nothing
+

     struct
     {
       std::vector<Graphics::TextureBinding> textureBindings;
     struct
     {
       std::vector<Graphics::TextureBinding> textureBindings;


@@ -390,7 +601,61 @@ struct Command
     {
       bool enable;
     } viewportTest;
     {
       bool enable;
     } viewportTest;

-  };
+
+    struct BeginRenderPassDescriptor
+    {
+      Graphics::RenderPass*             renderPass;
+      Graphics::RenderTarget*           renderTarget;
+      Graphics::Rect2D                  renderArea;
+      std::vector<Graphics::ClearValue> clearValues;
+    } beginRenderPass;
+
+    struct
+    {
+      Graphics::SyncObject* syncObject;
+    } endRenderPass;
+
+    struct
+    {
+      std::vector<const TestGraphicsCommandBuffer*> 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
 };
 
 class TestGraphicsCommandBuffer : public Graphics::CommandBuffer


@@ -401,13 +666,13 @@ public:
   {
   }
 
   {
   }
 

-  void BindVertexBuffers(uint32_t                             firstBinding,
-                         std::vector<const Graphics::Buffer*> buffers,
-                         std::vector<uint32_t>                offsets) override
+  void BindVertexBuffers(uint32_t                                    firstBinding,
+                         const std::vector<const Graphics::Buffer*>& buffers,
+                         const std::vector<uint32_t>&                offsets) override

   {
     mCommands.emplace_back();
     mCommands.back().type = CommandType::BIND_VERTEX_BUFFERS;
   {
     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());
     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;
     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)
     for(const auto& binding : bindings)
     {
       if(binding.buffer)


@@ -461,23 +726,23 @@ public:
   void BindPipeline(const Graphics::Pipeline& pipeline) override
   {
     mCommands.emplace_back();
   void BindPipeline(const Graphics::Pipeline& pipeline) override
   {
     mCommands.emplace_back();

-    mCommands.back().type                  = CommandType::BIND_PIPELINE;
-    mCommands.back().bindPipeline.pipeline = static_cast<const TestGraphicsPipeline*>(&pipeline);
+    mCommands.back().type                       = CommandType::BIND_PIPELINE;
+    mCommands.back().data.bindPipeline.pipeline = static_cast<const TestGraphicsPipeline*>(&pipeline);

     mCallStack.PushCall("BindPipeline", "");
   }
 
     mCallStack.PushCall("BindPipeline", "");
   }
 

-  void BindTextures(std::vector<Graphics::TextureBinding>& textureBindings) override
+  void BindTextures(const std::vector<Graphics::TextureBinding>& textureBindings) override

   {
     mCommands.emplace_back();
   {
     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", "");
   }
 
     mCallStack.PushCall("BindTextures", "");
   }
 

-  void BindSamplers(std::vector<Graphics::SamplerBinding>& samplerBindings) override
+  void BindSamplers(const std::vector<Graphics::SamplerBinding>& samplerBindings) override

   {
     mCommands.emplace_back();
   {
     mCommands.emplace_back();

-    mCommands.back().bindSamplers.samplerBindings = std::move(samplerBindings);
+    mCommands.back().data.bindSamplers.samplerBindings = std::move(samplerBindings);

     mCallStack.PushCall("BindSamplers", "");
   }
 
     mCallStack.PushCall("BindSamplers", "");
   }
 


@@ -493,20 +758,31 @@ public:
                        Graphics::Format        format) override
   {
     mCommands.emplace_back();
                        Graphics::Format        format) override
   {
     mCommands.emplace_back();

-    mCommands.back().type                   = CommandType::BIND_INDEX_BUFFER;
-    mCommands.back().bindIndexBuffer.buffer = static_cast<const TestGraphicsBuffer*>(&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<const TestGraphicsBuffer*>(&buffer);
+    mCommands.back().data.bindIndexBuffer.offset = offset;
+    mCommands.back().data.bindIndexBuffer.format = format;

     mCallStack.PushCall("BindIndexBuffer", "");
   }
 
   void BeginRenderPass(
     mCallStack.PushCall("BindIndexBuffer", "");
   }
 
   void BeginRenderPass(

-    Graphics::RenderPass&             renderPass,
-    Graphics::RenderTarget&           renderTarget,
-    Graphics::Extent2D                renderArea,
-    std::vector<Graphics::ClearValue> clearValues) override
+    Graphics::RenderPass*                    renderPass,
+    Graphics::RenderTarget*                  renderTarget,
+    Graphics::Rect2D                         renderArea,
+    const std::vector<Graphics::ClearValue>& 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).
    */
    * 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<const CommandBuffer*>&& 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<const TestGraphicsCommandBuffer*>(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(
   }
 
   void Draw(


@@ -531,7 +837,7 @@ public:
   {
     mCommands.emplace_back();
     mCommands.back().type  = CommandType::DRAW;
   {
     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;
     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;
   {
     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;
     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;
   {
     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<const TestGraphicsBuffer*>(&buffer);
     cmd.drawIndexedIndirect.offset    = offset;
     cmd.type                          = DrawCallDescriptor::Type::DRAW_INDEXED_INDIRECT;
     cmd.drawIndexedIndirect.buffer    = static_cast<const TestGraphicsBuffer*>(&buffer);
     cmd.drawIndexedIndirect.offset    = offset;


@@ -592,8 +898,8 @@ public:
     mCallStack.PushCall("SetScissor", params.str(), params);
 
     mCommands.emplace_back();
     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
   }
 
   void SetScissorTestEnable(bool value) override


@@ -603,8 +909,8 @@ public:
     mCallStack.PushCall("SetScissorTestEnable", params.str(), params);
 
     mCommands.emplace_back();
     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
   }
 
   void SetViewport(Graphics::Viewport value) override


@@ -619,8 +925,8 @@ public:
     mCallStack.PushCall("SetViewport", params.str(), params);
 
     mCommands.emplace_back();
     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
   }
 
   void SetViewportEnable(bool value) override


@@ -630,8 +936,114 @@ public:
     mCallStack.PushCall("SetViewportEnable", params.str(), params);
 
     mCommands.emplace_back();
     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<Command>& GetCommands() const
   }
 
   [[nodiscard]] const std::vector<Command>& GetCommands() const


@@ -654,7 +1066,9 @@ public:
   /**
    * Retrieves commands of specified type
    */
   /**
    * Retrieves commands of specified type
    */

-  std::vector<Command*> GetCommandsByType(CommandTypeMask mask);
+  std::vector<const Command*> GetCommandsByType(CommandTypeMask mask) const;
+
+  std::vector<const Command*> GetChildCommandsByType(CommandTypeMask mask) const;

 
 private:
   TraceCallStack&    mCallStack;
 
 private:
   TraceCallStack&    mCallStack;