X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=automated-tests%2Fsrc%2Fdali-toolkit%2Fdali-toolkit-test-utils%2Ftest-graphics-command-buffer.h;h=c10c3f113c4ffa903903f7c82d78f2b0dd2d32fc;hb=d74d70d51ed70b00e29a2b6feac5419124fffc49;hp=b4cb9b00697a3a7cfad09f490580496a9cb0e5ba;hpb=f1876c34a8f667f79182fa8a772ee889e27290c1;p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git

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 b4cb9b0..c10c3f1 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
@@ -24,8 +24,8 @@
 #include <cstdint>
 #include <vector>
 #include "test-gl-abstraction.h"
-#include "test-graphics-pipeline.h"
 #include "test-graphics-buffer.h"
+#include "test-graphics-pipeline.h"
 #include "test-trace-call-stack.h"
 
 namespace Dali
@@ -37,16 +37,20 @@ 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
+  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
 };
 
 using CommandTypeMask = uint32_t;
@@ -63,7 +67,7 @@ inline CommandTypeMask operator|(T flags, CommandType bit)
 struct VertexBufferBindingDescriptor
 {
   const TestGraphicsBuffer* buffer{nullptr};
-  uint32_t            offset{0u};
+  uint32_t                  offset{0u};
 };
 
 /**
@@ -73,8 +77,8 @@ struct VertexBufferBindingDescriptor
 struct IndexBufferBindingDescriptor
 {
   const TestGraphicsBuffer* buffer{nullptr};
-  uint32_t            offset{};
-  Graphics::Format    format{};
+  uint32_t                  offset{};
+  Graphics::Format          format{};
 };
 
 /**
@@ -84,9 +88,9 @@ struct IndexBufferBindingDescriptor
 struct UniformBufferBindingDescriptor
 {
   const TestGraphicsBuffer* buffer{nullptr};
-  uint32_t            binding{0u};
-  uint32_t            offset{0u};
-  bool                emulated; ///<true if UBO is emulated for old gfx API
+  uint32_t                  binding{0u};
+  uint32_t                  offset{0u};
+  bool                      emulated; ///<true if UBO is emulated for old gfx API
 };
 
 /**
@@ -140,9 +144,9 @@ struct DrawCallDescriptor
     struct
     {
       const TestGraphicsBuffer* buffer;
-      uint32_t            offset;
-      uint32_t            drawCount;
-      uint32_t            stride;
+      uint32_t                  offset;
+      uint32_t                  drawCount;
+      uint32_t                  stride;
     } drawIndexedIndirect;
   };
 };
@@ -170,50 +174,50 @@ struct Command
     {
       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:
       {
-        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:
@@ -221,12 +225,32 @@ struct Command
         // Nothing to do
         break;
       }
+      case CommandType::SET_SCISSOR:
+      {
+        data.scissor.region = rhs.data.scissor.region;
+        break;
+      }
+      case CommandType::SET_SCISSOR_TEST:
+      {
+        data.scissorTest.enable = rhs.data.scissorTest.enable;
+        break;
+      }
+      case CommandType::SET_VIEWPORT:
+      {
+        data.viewport.region = rhs.data.viewport.region;
+        break;
+      }
+      case CommandType::SET_VIEWPORT_TEST:
+      {
+        data.viewportTest.enable = rhs.data.viewportTest.enable;
+        break;
+      }
     }
     type = rhs.type;
   }
 
   /**
-   * @brief Copy constructor
+   * @brief move constructor
    * @param[in] rhs Command
    */
   Command(Command&& rhs) noexcept
@@ -235,50 +259,50 @@ struct Command
     {
       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:
       {
-        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:
@@ -286,14 +310,42 @@ struct Command
         // Nothing to do
         break;
       }
+      case CommandType::SET_SCISSOR:
+      {
+        data.scissor.region = rhs.data.scissor.region;
+        break;
+      }
+      case CommandType::SET_SCISSOR_TEST:
+      {
+        data.scissorTest.enable = rhs.data.scissorTest.enable;
+        break;
+      }
+      case CommandType::SET_VIEWPORT:
+      {
+        data.viewport.region = rhs.data.viewport.region;
+        break;
+      }
+      case CommandType::SET_VIEWPORT_TEST:
+      {
+        data.viewportTest.enable = rhs.data.viewportTest.enable;
+        break;
+      }
     }
     type = rhs.type;
   }
 
   CommandType type{CommandType::FLUSH}; ///< Type of command
 
-  union
+  union CommandData
   {
+    CommandData()
+    {
+    }
+
+    ~CommandData()
+    {
+    } // do nothing
+
     struct
     {
       std::vector<Graphics::TextureBinding> textureBindings;
@@ -329,9 +381,25 @@ struct Command
     struct : public DrawCallDescriptor
     {
     } draw;
-  };
-};
 
+    struct
+    {
+      Graphics::Rect2D region;
+    } scissor;
+    struct
+    {
+      bool enable;
+    } scissorTest;
+    struct
+    {
+      Graphics::Viewport region;
+    } viewport;
+    struct
+    {
+      bool enable;
+    } viewportTest;
+  } data;
+};
 
 class TestGraphicsCommandBuffer : public Graphics::CommandBuffer
 {
@@ -339,7 +407,6 @@ public:
   TestGraphicsCommandBuffer(TraceCallStack& callstack, TestGlAbstraction& glAbstraction);
   ~TestGraphicsCommandBuffer()
   {
-
   }
 
   void BindVertexBuffers(uint32_t                             firstBinding,
@@ -348,7 +415,7 @@ public:
   {
     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());
@@ -365,12 +432,10 @@ public:
 
   void BindUniformBuffers(const std::vector<Graphics::UniformBufferBinding>& bindings) override
   {
-    printf("BindUniformBuffers: bindings.size(): %lu\n", bindings.size());
-
     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)
@@ -404,23 +469,23 @@ public:
   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", "");
   }
 
   void BindTextures(std::vector<Graphics::TextureBinding>& 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<Graphics::SamplerBinding>& samplerBindings) override
   {
     mCommands.emplace_back();
-    mCommands.back().bindSamplers.samplerBindings = std::move(samplerBindings);
+    mCommands.back().data.bindSamplers.samplerBindings = std::move(samplerBindings);
     mCallStack.PushCall("BindSamplers", "");
   }
 
@@ -433,19 +498,19 @@ public:
 
   void BindIndexBuffer(const Graphics::Buffer& buffer,
                        uint32_t                offset,
-                       Graphics::Format                  format) override
+                       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(
-    Graphics::RenderPass&   renderPass,
-    Graphics::RenderTarget& renderTarget,
+    Graphics::RenderPass&             renderPass,
+    Graphics::RenderTarget&           renderTarget,
     Graphics::Extent2D                renderArea,
     std::vector<Graphics::ClearValue> clearValues) override
   {
@@ -474,7 +539,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;
@@ -492,7 +557,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;
@@ -510,7 +575,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<const TestGraphicsBuffer*>(&buffer);
     cmd.drawIndexedIndirect.offset    = offset;
@@ -525,24 +590,56 @@ public:
     mCallStack.PushCall("Reset", "");
   }
 
-  void SetScissor(Graphics::Extent2D value) override
+  void SetScissor(Graphics::Rect2D value) override
   {
-    mCallStack.PushCall("SetScissor", "");
+    TraceCallStack::NamedParams params;
+    params["x"] << value.x;
+    params["y"] << value.y;
+    params["width"] << value.width;
+    params["height"] << value.height;
+    mCallStack.PushCall("SetScissor", params.str(), params);
+
+    mCommands.emplace_back();
+    mCommands.back().type                = CommandType::SET_SCISSOR;
+    mCommands.back().data.scissor.region = value;
   }
 
   void SetScissorTestEnable(bool value) override
   {
-    mCallStack.PushCall("SetScissorTestEnable", "");
+    TraceCallStack::NamedParams params;
+    params["value"] << (value ? "T" : "F");
+    mCallStack.PushCall("SetScissorTestEnable", params.str(), params);
+
+    mCommands.emplace_back();
+    mCommands.back().type                    = CommandType::SET_SCISSOR_TEST;
+    mCommands.back().data.scissorTest.enable = value;
   }
 
   void SetViewport(Graphics::Viewport value) override
   {
-    mCallStack.PushCall("SetViewport", "");
+    TraceCallStack::NamedParams params;
+    params["x"] << value.x;
+    params["y"] << value.y;
+    params["width"] << value.width;
+    params["height"] << value.height;
+    params["minDepth"] << value.minDepth;
+    params["maxDepth"] << value.maxDepth;
+    mCallStack.PushCall("SetViewport", params.str(), params);
+
+    mCommands.emplace_back();
+    mCommands.back().type                 = CommandType::SET_VIEWPORT;
+    mCommands.back().data.viewport.region = value;
   }
 
   void SetViewportEnable(bool value) override
   {
-    mCallStack.PushCall("SetViewportEnable", "");
+    TraceCallStack::NamedParams params;
+    params["value"] << (value ? "T" : "F");
+    mCallStack.PushCall("SetViewportEnable", params.str(), params);
+
+    mCommands.emplace_back();
+    mCommands.back().type                     = CommandType::SET_VIEWPORT_TEST;
+    mCommands.back().data.viewportTest.enable = value;
   }
 
   [[nodiscard]] const std::vector<Command>& GetCommands() const
@@ -560,17 +657,17 @@ public:
    * Retrieves state resolve for selected draw call
    * @param drawCommandIndex
    */
-  void GetStateForDrawCall( int drawCallIndex );
+  void GetStateForDrawCall(int drawCallIndex);
 
   /**
    * Retrieves commands of specified type
    */
-  std::vector<Command*> GetCommandsByType( CommandTypeMask mask );
-
+  std::vector<Command*> GetCommandsByType(CommandTypeMask mask);
 
 private:
-  TraceCallStack&                       mCallStack;
-  TestGlAbstraction&                    mGlAbstraction;
+  TraceCallStack&    mCallStack;
+  TestGlAbstraction& mGlAbstraction;
+
   std::vector<Command> mCommands;
 };