From 95b71e4983493a1293176dca2fe735337a95af1d Mon Sep 17 00:00:00 2001 From: Adam Bialogonski Date: Fri, 5 Mar 2021 16:50:26 +0000 Subject: [PATCH] Test harness for UBO - Added test command buffer implementation - Added UBO support Change-Id: I783671f0392d151ed3910d839701ddb5d8d63647 --- .../dali-test-suite-utils/test-gl-abstraction.h | 25 +- .../dali-test-suite-utils/test-graphics-buffer.cpp | 69 +++ .../dali-test-suite-utils/test-graphics-buffer.h | 8 + .../test-graphics-command-buffer.cpp | 157 ++---- .../test-graphics-command-buffer.h | 562 ++++++++++++++++++--- .../test-graphics-controller.cpp | 208 ++++---- .../test-graphics-reflection.cpp | 79 ++- .../test-graphics-reflection.h | 2 + automated-tests/src/dali/utc-Dali-Geometry.cpp | 4 +- automated-tests/src/dali/utc-Dali-Renderer.cpp | 7 +- automated-tests/src/dali/utc-Dali-Shader.cpp | 4 +- automated-tests/src/dali/utc-Dali-VertexBuffer.cpp | 9 +- 12 files changed, 847 insertions(+), 287 deletions(-) diff --git a/automated-tests/src/dali/dali-test-suite-utils/test-gl-abstraction.h b/automated-tests/src/dali/dali-test-suite-utils/test-gl-abstraction.h index 1d93731..64696b7 100644 --- a/automated-tests/src/dali/dali-test-suite-utils/test-gl-abstraction.h +++ b/automated-tests/src/dali/dali-test-suite-utils/test-gl-abstraction.h @@ -899,7 +899,7 @@ public: if(it2 == uniformIDs.end()) { // Uniform not found, so add it... - uniformIDs[name] = ++mLastUniformIdUsed; + uniformIDs[name] = mLastUniformIdUsed++; return mLastUniformIdUsed; } @@ -971,9 +971,30 @@ public: mShaderTrace.PushCall("LinkProgram", out.str(), namedParams); mNumberOfActiveUniforms = 3; - GetUniformLocation(program, "sTexture"); + + GetUniformLocation(program, "uRendererColor"); + GetUniformLocation(program, "uCustom"); + GetUniformLocation(program, "uCustom3"); + GetUniformLocation(program, "uFadeColor"); + GetUniformLocation(program, "uUniform1"); + GetUniformLocation(program, "uUniform2"); + GetUniformLocation(program, "uUniform3"); + GetUniformLocation(program, "uFadeProgress"); + GetUniformLocation(program, "uANormalMatrix"); GetUniformLocation(program, "sEffect"); + GetUniformLocation(program, "sTexture"); + GetUniformLocation(program, "sTextureRect"); GetUniformLocation(program, "sGloss"); + GetUniformLocation(program, "uColor"); + GetUniformLocation(program, "uModelMatrix"); + GetUniformLocation(program, "uModelView"); + GetUniformLocation(program, "uMvpMatrix"); + GetUniformLocation(program, "uNormalMatrix"); + GetUniformLocation(program, "uProjection"); + GetUniformLocation(program, "uSize"); + GetUniformLocation(program, "uViewMatrix"); + GetUniformLocation(program, "uLightCameraProjectionMatrix"); + GetUniformLocation(program, "uLightCameraViewMatrix"); } inline void PixelStorei(GLenum pname, GLint param) override diff --git a/automated-tests/src/dali/dali-test-suite-utils/test-graphics-buffer.cpp b/automated-tests/src/dali/dali-test-suite-utils/test-graphics-buffer.cpp index 90640e5..55c7dc4 100644 --- a/automated-tests/src/dali/dali-test-suite-utils/test-graphics-buffer.cpp +++ b/automated-tests/src/dali/dali-test-suite-utils/test-graphics-buffer.cpp @@ -15,6 +15,8 @@ */ #include "test-graphics-buffer.h" +#include "test-graphics-program.h" +#include "test-graphics-reflection.h" #include #include "dali-test-suite-utils.h" @@ -78,4 +80,71 @@ GLenum TestGraphicsBuffer::GetTarget() return target; } +void TestGraphicsBuffer::BindAsUniformBuffer( const TestGraphicsProgram* program ) const +{ + auto* reflection = static_cast(&program->GetReflection()); + + Graphics::UniformBlockInfo uboInfo{}; + reflection->GetUniformBlock(0, uboInfo); + + auto* data = memory.data(); + + for( const auto& member : uboInfo.members ) + { + auto type = reflection->GetMemberType( 0, member.location ); + switch(type) + { + case Property::VECTOR4: + { + auto value = *reinterpret_cast(data+member.offset); + mGl.Uniform4f( member.location, value.x, value.y, value.z, value.w ); + break; + } + case Property::VECTOR3: + { + auto value = *reinterpret_cast(data+member.offset); + mGl.Uniform3f( member.location, value.x, value.y, value.z ); + break; + } + case Property::VECTOR2: + { + auto value = *reinterpret_cast(data+member.offset); + mGl.Uniform2f( member.location, value.x, value.y ); + break; + } + case Property::FLOAT: + { + auto value = *reinterpret_cast(data+member.offset); + mGl.Uniform1f( member.location, value ); + break; + } + case Property::INTEGER: + { + auto ptr = reinterpret_cast(data+member.offset); + auto value = *ptr; + mGl.Uniform1i( member.location, value ); + break; + } + case Property::MATRIX: + { + auto value = reinterpret_cast(data+member.offset); + mGl.UniformMatrix4fv( member.location, 1, GL_FALSE, value ); + break; + } + case Property::MATRIX3: + { + auto value = reinterpret_cast(data+member.offset); + mGl.UniformMatrix3fv( member.location, 1, GL_FALSE, value ); + break; + } + default: + { + + } + } + } + + +} + } // namespace Dali diff --git a/automated-tests/src/dali/dali-test-suite-utils/test-graphics-buffer.h b/automated-tests/src/dali/dali-test-suite-utils/test-graphics-buffer.h index c4abc3e..64107cf 100644 --- a/automated-tests/src/dali/dali-test-suite-utils/test-graphics-buffer.h +++ b/automated-tests/src/dali/dali-test-suite-utils/test-graphics-buffer.h @@ -25,6 +25,7 @@ namespace Dali { +class TestGraphicsProgram; class TestGraphicsBuffer : public Graphics::Buffer { public: @@ -34,6 +35,13 @@ public: void Upload(uint32_t offset, uint32_t size); GLenum GetTarget(); + bool IsCPUAllocated() const + { + return true; + } + + void BindAsUniformBuffer( const TestGraphicsProgram* program ) const; + TraceCallStack& mCallStack; TestGlAbstraction& mGl; std::vector memory; diff --git a/automated-tests/src/dali/dali-test-suite-utils/test-graphics-command-buffer.cpp b/automated-tests/src/dali/dali-test-suite-utils/test-graphics-command-buffer.cpp index a0dee4a..88e7168 100644 --- a/automated-tests/src/dali/dali-test-suite-utils/test-graphics-command-buffer.cpp +++ b/automated-tests/src/dali/dali-test-suite-utils/test-graphics-command-buffer.cpp @@ -24,134 +24,55 @@ TestGraphicsCommandBuffer::TestGraphicsCommandBuffer(TraceCallStack& callstack, { } -void TestGraphicsCommandBuffer::BindVertexBuffers(uint32_t firstBinding, - std::vector buffers, - std::vector offsets) +int TestGraphicsCommandBuffer::GetDrawCallsCount() { - mVertexBufferBindings.firstBinding = firstBinding; - mVertexBufferBindings.buffers = buffers; // Copy - mVertexBufferBindings.offsets = offsets; // Copy - mCallStack.PushCall("BindVertexBuffers", ""); -} - -void TestGraphicsCommandBuffer::BindUniformBuffers(const std::vector& bindings) -{ - mCallStack.PushCall("BindUniformBuffers", ""); -} - -void TestGraphicsCommandBuffer::BindPipeline(const Graphics::Pipeline& pipeline) -{ - mPipeline = static_cast(const_cast(&pipeline)); - mCallStack.PushCall("BindPipeline", ""); -} - -void TestGraphicsCommandBuffer::BindTextures(std::vector& textureBindings) -{ - mCallStack.PushCall("BindTextures", ""); - for(auto& binding : textureBindings) + int count = 0; + for( auto& cmd : mCommands ) { - mTextureBindings.push_back(binding); + if( cmd.type == CommandType::DRAW || + cmd.type == CommandType::DRAW_INDEXED || + cmd.type == CommandType::DRAW_INDEXED_INDIRECT ) + { + ++count; + } } + return count; } -void TestGraphicsCommandBuffer::BindSamplers(std::vector& samplerBindings) -{ - mCallStack.PushCall("BindSamplers", ""); -} - -void TestGraphicsCommandBuffer::BindPushConstants(void* data, - uint32_t size, - uint32_t binding) +void TestGraphicsCommandBuffer::GetStateForDrawCall( int drawCallIndex ) { - mCallStack.PushCall("BindPushConstants", ""); -} - -void TestGraphicsCommandBuffer::BindIndexBuffer(const Graphics::Buffer& buffer, - uint32_t offset, - Graphics::Format format) -{ - mIndexBufferBinding.buffer = &buffer; - mIndexBufferBinding.offset = offset; - mIndexBufferBinding.format = format; - mCallStack.PushCall("BindIndexBuffer", ""); -} - -void TestGraphicsCommandBuffer::BeginRenderPass( - Graphics::RenderPass& renderPass, - Graphics::RenderTarget& renderTarget, - Graphics::Extent2D renderArea, - std::vector clearValues) -{ - mCallStack.PushCall("BeginRenderPass", ""); -} - -void TestGraphicsCommandBuffer::EndRenderPass() -{ - mCallStack.PushCall("EndRenderPass", ""); -} - -void TestGraphicsCommandBuffer::Draw( - uint32_t vertexCount, - uint32_t instanceCount, - uint32_t firstVertex, - uint32_t firstInstance) -{ - drawCommand.drawType = Draw::DrawType::Unindexed; - drawCommand.u.unindexedDraw.vertexCount = vertexCount; - drawCommand.u.unindexedDraw.instanceCount = instanceCount; - drawCommand.u.unindexedDraw.firstVertex = firstVertex; - drawCommand.u.unindexedDraw.firstInstance = firstInstance; - mCallStack.PushCall("Draw", ""); -} - -void TestGraphicsCommandBuffer::DrawIndexed( - uint32_t indexCount, - uint32_t instanceCount, - uint32_t firstIndex, - int32_t vertexOffset, - uint32_t firstInstance) -{ - drawCommand.drawType = TestGraphicsCommandBuffer::Draw::DrawType::Indexed; - drawCommand.u.indexedDraw.indexCount = indexCount; - drawCommand.u.indexedDraw.instanceCount = instanceCount; - drawCommand.u.indexedDraw.firstIndex = firstIndex; - drawCommand.u.indexedDraw.vertexOffset = vertexOffset; - drawCommand.u.indexedDraw.firstInstance = firstInstance; - mCallStack.PushCall("DrawIndexed", ""); -} - -void TestGraphicsCommandBuffer::DrawIndexedIndirect( - Graphics::Buffer& buffer, - uint32_t offset, - uint32_t drawCount, - uint32_t stride) -{ - mCallStack.PushCall("DrawIndexedIndirect", ""); -} - -void TestGraphicsCommandBuffer::Reset(Graphics::CommandBuffer& commandBuffer) -{ - mCallStack.PushCall("Reset", ""); -} - -void TestGraphicsCommandBuffer::SetScissor(Graphics::Extent2D value) -{ - mCallStack.PushCall("SetScissor", ""); -} - -void TestGraphicsCommandBuffer::SetScissorTestEnable(bool value) -{ - mCallStack.PushCall("SetScissorTestEnable", ""); -} + int index = 0; + std::vector mCommandStack{}; + for( auto& cmd : mCommands ) + { + mCommandStack.push_back(cmd); + if( cmd.type == CommandType::DRAW || + cmd.type == CommandType::DRAW_INDEXED || + cmd.type == CommandType::DRAW_INDEXED_INDIRECT ) + { + if( index == drawCallIndex ) + { + break; + } + mCommandStack.clear(); + ++index; + } + } -void TestGraphicsCommandBuffer::SetViewport(Graphics::Viewport value) -{ - mCallStack.PushCall("SetViewport", ""); + // } -void TestGraphicsCommandBuffer::SetViewportEnable(bool value) +std::vector TestGraphicsCommandBuffer::GetCommandsByType( CommandTypeMask mask ) { - mCallStack.PushCall("SetViewportEnable", ""); + std::vector mCommandStack{}; + for( auto& cmd : mCommands ) + { + if(uint32_t(cmd.type) == (mask & uint32_t(cmd.type)) ) + { + mCommandStack.emplace_back( &cmd ); + } + } + return mCommandStack; } } // namespace Dali diff --git a/automated-tests/src/dali/dali-test-suite-utils/test-graphics-command-buffer.h b/automated-tests/src/dali/dali-test-suite-utils/test-graphics-command-buffer.h index 151a9df..1eccb8d 100644 --- a/automated-tests/src/dali/dali-test-suite-utils/test-graphics-command-buffer.h +++ b/automated-tests/src/dali/dali-test-suite-utils/test-graphics-command-buffer.h @@ -25,119 +25,551 @@ #include #include "test-gl-abstraction.h" #include "test-graphics-pipeline.h" +#include "test-graphics-buffer.h" #include "test-trace-call-stack.h" namespace Dali { +class TestGraphicsTexture; +class TestGraphicsBuffer; +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 +}; + +using CommandTypeMask = uint32_t; +template +inline CommandTypeMask operator|(T flags, CommandType bit) +{ + return static_cast(flags) | static_cast(bit); +} + +/** + * @brief Descriptor of single buffer binding within + * command buffer. + */ +struct VertexBufferBindingDescriptor +{ + const TestGraphicsBuffer* buffer{nullptr}; + uint32_t offset{0u}; +}; + +/** + * @brief Descriptor of ix buffer binding within + * command buffer. + */ +struct IndexBufferBindingDescriptor +{ + const TestGraphicsBuffer* buffer{nullptr}; + uint32_t offset{}; + Graphics::Format format{}; +}; + +/** + * @brief Descriptor of uniform buffer binding within + * command buffer. + */ +struct UniformBufferBindingDescriptor +{ + const TestGraphicsBuffer* buffer{nullptr}; + uint32_t binding{0u}; + uint32_t offset{0u}; + bool emulated; /// textureBindings; + } bindTextures{}; + + // BindSampler command + struct + { + std::vector samplerBindings; + } bindSamplers; + + struct + { + using Binding = VertexBufferBindingDescriptor; + std::vector vertexBufferBindings; + } bindVertexBuffers; + + struct : public IndexBufferBindingDescriptor + { + } bindIndexBuffer; + + struct + { + std::vector uniformBufferBindings{}; + UniformBufferBindingDescriptor standaloneUniformsBufferBinding{}; + } bindUniformBuffers; + + struct + { + const TestGraphicsPipeline* pipeline{nullptr}; + } bindPipeline; + + struct : public DrawCallDescriptor + { + } draw; + }; +}; + + class TestGraphicsCommandBuffer : public Graphics::CommandBuffer { public: TestGraphicsCommandBuffer(TraceCallStack& callstack, TestGlAbstraction& glAbstraction); + ~TestGraphicsCommandBuffer() + { + + } void BindVertexBuffers(uint32_t firstBinding, std::vector buffers, - std::vector offsets); + std::vector offsets) override + { + mCommands.emplace_back(); + mCommands.back().type = CommandType::BIND_VERTEX_BUFFERS; + auto& bindings = mCommands.back().bindVertexBuffers.vertexBufferBindings; + if(bindings.size() < firstBinding + buffers.size()) + { + bindings.resize(firstBinding + buffers.size()); + auto index = firstBinding; + for(auto& buf : buffers) + { + bindings[index].buffer = static_cast(buf); + bindings[index].offset = offsets[index - firstBinding]; + index++; + } + } + mCallStack.PushCall("BindVertexBuffers", ""); + } - void BindUniformBuffers(const std::vector& bindings); + void BindUniformBuffers(const std::vector& bindings) override + { + mCommands.emplace_back(); + auto& cmd = mCommands.back(); + cmd.type = CommandType::BIND_UNIFORM_BUFFER; + auto& bindCmd = cmd.bindUniformBuffers; + for(const auto& binding : bindings) + { + if(binding.buffer) + { + auto testBuffer = static_cast(binding.buffer); + if(testBuffer->IsCPUAllocated()) // standalone uniforms + { + bindCmd.standaloneUniformsBufferBinding.buffer = testBuffer; + bindCmd.standaloneUniformsBufferBinding.offset = binding.offset; + bindCmd.standaloneUniformsBufferBinding.binding = binding.binding; + bindCmd.standaloneUniformsBufferBinding.emulated = true; + } + else // Bind regular UBO + { + // resize binding slots + if(binding.binding >= bindCmd.uniformBufferBindings.size()) + { + bindCmd.uniformBufferBindings.resize(binding.binding + 1); + } + auto& slot = bindCmd.uniformBufferBindings[binding.binding]; + slot.buffer = testBuffer; + slot.offset = binding.offset; + slot.binding = binding.binding; + slot.emulated = false; + } + } + } + mCallStack.PushCall("BindUniformBuffers", ""); + } - void BindPipeline(const Graphics::Pipeline& pipeline); + void BindPipeline(const Graphics::Pipeline& pipeline) override + { + mCommands.emplace_back(); + mCommands.back().type = CommandType::BIND_PIPELINE; + mCommands.back().bindPipeline.pipeline = static_cast(&pipeline); + mCallStack.PushCall("BindPipeline", ""); + } - void BindTextures(std::vector& textureBindings); + void BindTextures(std::vector& textureBindings) override + { + mCommands.emplace_back(); + mCommands.back().type = CommandType::BIND_TEXTURES; + mCommands.back().bindTextures.textureBindings = std::move(textureBindings); + mCallStack.PushCall("BindTextures", ""); + } - void BindSamplers(std::vector& samplerBindings); + void BindSamplers(std::vector& samplerBindings) override + { + mCommands.emplace_back(); + mCommands.back().bindSamplers.samplerBindings = std::move(samplerBindings); + mCallStack.PushCall("BindSamplers", ""); + } void BindPushConstants(void* data, uint32_t size, - uint32_t binding); + uint32_t binding) override + { + mCallStack.PushCall("BindPushConstants", ""); + } void BindIndexBuffer(const Graphics::Buffer& buffer, uint32_t offset, - Graphics::Format format); + 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; + mCallStack.PushCall("BindIndexBuffer", ""); + } - void BeginRenderPass(Graphics::RenderPass& renderPass, - Graphics::RenderTarget& renderTarget, - Graphics::Extent2D renderArea, - std::vector clearValues); + void BeginRenderPass( + Graphics::RenderPass& renderPass, + Graphics::RenderTarget& renderTarget, + Graphics::Extent2D renderArea, + std::vector clearValues) override + { + mCallStack.PushCall("BeginRenderPass", ""); + } - void EndRenderPass(); + /** + * @brief Ends current render pass + * + * This command must be issued in order to finalize the render pass. + * It's up to the implementation whether anything has to be done but + * the Controller may use end RP marker in order to resolve resource + * dependencies (for example, to know when target texture is ready + * before passing it to another render pass). + */ + void EndRenderPass() override + { + mCallStack.PushCall("EndRenderPass", ""); + } void Draw( uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, - uint32_t firstInstance); + uint32_t firstInstance) override + { + mCommands.emplace_back(); + mCommands.back().type = CommandType::DRAW; + auto& cmd = mCommands.back().draw; + cmd.type = DrawCallDescriptor::Type::DRAW; + cmd.draw.vertexCount = vertexCount; + cmd.draw.instanceCount = instanceCount; + cmd.draw.firstInstance = firstInstance; + cmd.draw.firstVertex = firstVertex; + mCallStack.PushCall("Draw", ""); + } void DrawIndexed( uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, - uint32_t firstInstance); + uint32_t firstInstance) override + { + mCommands.emplace_back(); + mCommands.back().type = CommandType::DRAW_INDEXED; + auto& cmd = mCommands.back().draw; + cmd.type = DrawCallDescriptor::Type::DRAW_INDEXED; + cmd.drawIndexed.firstIndex = firstIndex; + cmd.drawIndexed.firstInstance = firstInstance; + cmd.drawIndexed.indexCount = indexCount; + cmd.drawIndexed.vertexOffset = vertexOffset; + cmd.drawIndexed.instanceCount = instanceCount; + mCallStack.PushCall("DrawIndexed", ""); + } void DrawIndexedIndirect( Graphics::Buffer& buffer, uint32_t offset, uint32_t drawCount, - uint32_t stride); - - void Reset(Graphics::CommandBuffer& commandBuffer); - - void SetScissor(Graphics::Extent2D value); - - void SetScissorTestEnable(bool value); + uint32_t stride) override + { + mCommands.emplace_back(); + mCommands.back().type = CommandType::DRAW_INDEXED_INDIRECT; + auto& cmd = mCommands.back().draw; + cmd.type = DrawCallDescriptor::Type::DRAW_INDEXED_INDIRECT; + cmd.drawIndexedIndirect.buffer = static_cast(&buffer); + cmd.drawIndexedIndirect.offset = offset; + cmd.drawIndexedIndirect.drawCount = drawCount; + cmd.drawIndexedIndirect.stride = stride; + mCallStack.PushCall("DrawIndexedIndirect", ""); + } - void SetViewport(Graphics::Viewport value); + void Reset() override + { + mCommands.clear(); + mCallStack.PushCall("Reset", ""); + } - void SetViewportEnable(bool value); + void SetScissor(Graphics::Extent2D value) override + { + mCallStack.PushCall("SetScissor", ""); + } -public: - TraceCallStack& mCallStack; - TestGlAbstraction& mGlAbstraction; - TestGraphicsPipeline* mPipeline{nullptr}; - std::vector mTextureBindings{}; + void SetScissorTestEnable(bool value) override + { + mCallStack.PushCall("SetScissorTestEnable", ""); + } - struct VertexBuffersBinding + void SetViewport(Graphics::Viewport value) override { - uint32_t firstBinding; - std::vector buffers; - std::vector offsets; - }; - VertexBuffersBinding mVertexBufferBindings{}; + mCallStack.PushCall("SetViewport", ""); + } - struct IndexBufferBinding + void SetViewportEnable(bool value) override { - const Graphics::Buffer* buffer; - uint32_t offset; - Graphics::Format format; - }; - IndexBufferBinding mIndexBufferBinding{}; + mCallStack.PushCall("SetViewportEnable", ""); + } - struct Draw + [[nodiscard]] const std::vector& GetCommands() const { - enum class DrawType - { - Indexed, - Unindexed - } drawType; - union - { - struct IndexedDraw - { - uint32_t indexCount; - uint32_t instanceCount; - uint32_t firstIndex; - int32_t vertexOffset; - uint32_t firstInstance; - } indexedDraw; - struct UnindexedDraw - { - uint32_t vertexCount; - uint32_t instanceCount; - uint32_t firstVertex; - uint32_t firstInstance; - } unindexedDraw; - } u; - } drawCommand; + return mCommands; + } + + /** + * Returns number of draw commands + * @return + */ + int GetDrawCallsCount(); + + /** + * Retrieves state resolve for selected draw call + * @param drawCommandIndex + */ + void GetStateForDrawCall( int drawCallIndex ); + + /** + * Retrieves commands of specified type + */ + std::vector GetCommandsByType( CommandTypeMask mask ); + + +private: + TraceCallStack& mCallStack; + TestGlAbstraction& mGlAbstraction; + std::vector mCommands; }; } // namespace Dali diff --git a/automated-tests/src/dali/dali-test-suite-utils/test-graphics-controller.cpp b/automated-tests/src/dali/dali-test-suite-utils/test-graphics-controller.cpp index fe9c329..755d259 100644 --- a/automated-tests/src/dali/dali-test-suite-utils/test-graphics-controller.cpp +++ b/automated-tests/src/dali/dali-test-suite-utils/test-graphics-controller.cpp @@ -458,121 +458,157 @@ void TestGraphicsController::SubmitCommandBuffers(const Graphics::SubmitInfo& su for(auto& graphicsCommandBuffer : submitInfo.cmdBuffer) { auto commandBuffer = Uncast(graphicsCommandBuffer); - for(auto& binding : commandBuffer->mTextureBindings) + + auto value = commandBuffer->GetCommandsByType(0 | CommandType::BIND_TEXTURES); + if(!value.empty()) { - if(binding.texture) + // must be fixed + for (auto &binding : value[0]->bindTextures.textureBindings) { - auto texture = Uncast(binding.texture); + if (binding.texture) + { + auto texture = Uncast(binding.texture); - texture->Bind(binding.binding); + texture->Bind(binding.binding); - if(binding.sampler) - { - auto sampler = Uncast(binding.sampler); - if(sampler) + if (binding.sampler) { - sampler->Apply(texture->GetTarget()); + auto sampler = Uncast(binding.sampler); + if (sampler) + { + sampler->Apply(texture->GetTarget()); + } } - } - texture->Prepare(); // Ensure native texture is ready + texture->Prepare(); // Ensure native texture is ready + } } } // IndexBuffer binding, - auto& indexBufferBinding = commandBuffer->mIndexBufferBinding; - if(indexBufferBinding.buffer) + auto bindIndexBufferCmds = commandBuffer->GetCommandsByType(0 | CommandType::BIND_INDEX_BUFFER); + if (!bindIndexBufferCmds.empty()) { - auto buffer = Uncast(indexBufferBinding.buffer); - buffer->Bind(); + auto &indexBufferBinding = bindIndexBufferCmds[0]->bindIndexBuffer; + if (indexBufferBinding.buffer) + { + auto buffer = Uncast(indexBufferBinding.buffer); + buffer->Bind(); + } } // VertexBuffer binding, - for(auto graphicsBuffer : commandBuffer->mVertexBufferBindings.buffers) + auto bindVertexBufferCmds = commandBuffer->GetCommandsByType(0 | CommandType::BIND_VERTEX_BUFFERS); + if (!bindVertexBufferCmds.empty()) { - auto vertexBuffer = Uncast(graphicsBuffer); - vertexBuffer->Bind(); + for (auto &binding : bindVertexBufferCmds[0]->bindVertexBuffers.vertexBufferBindings) + { + auto graphicsBuffer = binding.buffer; + auto vertexBuffer = Uncast(graphicsBuffer); + vertexBuffer->Bind(); + } } - // Pipeline attribute setup - auto& vi = commandBuffer->mPipeline->vertexInputState; - for(auto& attribute : vi.attributes) - { - mGl.EnableVertexAttribArray(attribute.location); - uint32_t attributeOffset = attribute.offset; - GLsizei stride = vi.bufferBindings[attribute.binding].stride; - - mGl.VertexAttribPointer(attribute.location, - GetNumComponents(attribute.format), - GetGlType(attribute.format), - GL_FALSE, // Not normalized - stride, - reinterpret_cast(attributeOffset)); - } - - // Cull face setup - auto& rasterizationState = commandBuffer->mPipeline->rasterizationState; - if(rasterizationState.cullMode == Graphics::CullMode::NONE) + auto bindPipelineCmds = commandBuffer->GetCommandsByType(0 | CommandType::BIND_PIPELINE); + if (!bindPipelineCmds.empty()) { - mGl.Disable(GL_CULL_FACE); - } - else - { - mGl.Enable(GL_CULL_FACE); - mGl.CullFace(GetCullFace(rasterizationState.cullMode)); - } - - mGl.FrontFace(GetFrontFace(rasterizationState.frontFace)); - // We don't modify glPolygonMode in our context/abstraction from GL_FILL (the GL default), - // so it isn't present in the API (and won't have any tests!) + auto pipeline = bindPipelineCmds[0]->bindPipeline.pipeline; + auto &vi = pipeline->vertexInputState; + for (auto &attribute : vi.attributes) + { + mGl.EnableVertexAttribArray(attribute.location); + uint32_t attributeOffset = attribute.offset; + GLsizei stride = vi.bufferBindings[attribute.binding].stride; + + mGl.VertexAttribPointer(attribute.location, + GetNumComponents(attribute.format), + GetGlType(attribute.format), + GL_FALSE, // Not normalized + stride, + reinterpret_cast(attributeOffset)); + } + // Cull face setup + auto &rasterizationState = pipeline->rasterizationState; + if (rasterizationState.cullMode == Graphics::CullMode::NONE) + { + mGl.Disable(GL_CULL_FACE); + } + else + { + mGl.Enable(GL_CULL_FACE); + mGl.CullFace(GetCullFace(rasterizationState.cullMode)); + } - // Blending setup - auto& colorBlendState = commandBuffer->mPipeline->colorBlendState; - if(colorBlendState.blendEnable) - { - mGl.Enable(GL_BLEND); + mGl.FrontFace(GetFrontFace(rasterizationState.frontFace)); + // We don't modify glPolygonMode in our context/abstraction from GL_FILL (the GL default), + // so it isn't present in the API (and won't have any tests!) - mGl.BlendFuncSeparate(GetBlendFactor(colorBlendState.srcColorBlendFactor), - GetBlendFactor(colorBlendState.dstColorBlendFactor), - GetBlendFactor(colorBlendState.srcAlphaBlendFactor), - GetBlendFactor(colorBlendState.dstAlphaBlendFactor)); - if(colorBlendState.colorBlendOp != colorBlendState.alphaBlendOp) + // Blending setup + auto &colorBlendState = pipeline->colorBlendState; + if (colorBlendState.blendEnable) { - mGl.BlendEquationSeparate(GetBlendOp(colorBlendState.colorBlendOp), GetBlendOp(colorBlendState.alphaBlendOp)); + mGl.Enable(GL_BLEND); + + mGl.BlendFuncSeparate(GetBlendFactor(colorBlendState.srcColorBlendFactor), + GetBlendFactor(colorBlendState.dstColorBlendFactor), + GetBlendFactor(colorBlendState.srcAlphaBlendFactor), + GetBlendFactor(colorBlendState.dstAlphaBlendFactor)); + if (colorBlendState.colorBlendOp != colorBlendState.alphaBlendOp) + { + mGl.BlendEquationSeparate(GetBlendOp(colorBlendState.colorBlendOp), GetBlendOp(colorBlendState.alphaBlendOp)); + } + else + { + mGl.BlendEquation(GetBlendOp(colorBlendState.colorBlendOp)); + } + mGl.BlendColor(colorBlendState.blendConstants[0], + colorBlendState.blendConstants[1], + colorBlendState.blendConstants[2], + colorBlendState.blendConstants[3]); } else { - mGl.BlendEquation(GetBlendOp(colorBlendState.colorBlendOp)); + mGl.Disable(GL_BLEND); } - mGl.BlendColor(colorBlendState.blendConstants[0], - colorBlendState.blendConstants[1], - colorBlendState.blendConstants[2], - colorBlendState.blendConstants[3]); - } - else - { - mGl.Disable(GL_BLEND); - } - // draw call - auto topology = commandBuffer->mPipeline->inputAssemblyState.topology; + // draw call + auto topology = pipeline->inputAssemblyState.topology; - if(commandBuffer->drawCommand.drawType == TestGraphicsCommandBuffer::Draw::DrawType::Indexed) - { - mGl.DrawElements(GetTopology(topology), - static_cast(commandBuffer->drawCommand.u.indexedDraw.indexCount), - GL_UNSIGNED_SHORT, - reinterpret_cast(commandBuffer->drawCommand.u.indexedDraw.firstIndex)); - } - else - { - mGl.DrawArrays(GetTopology(topology), 0, commandBuffer->drawCommand.u.unindexedDraw.vertexCount); - } + // UniformBuffer binding (once we know pipeline) + auto bindUniformBuffersCmds = commandBuffer->GetCommandsByType(0 | CommandType::BIND_UNIFORM_BUFFER); + if (!bindUniformBuffersCmds.empty()) + { + auto buffer = bindUniformBuffersCmds[0]->bindUniformBuffers.standaloneUniformsBufferBinding; + printf("%p\n", buffer.buffer); - // attribute clear - for(auto& attribute : vi.attributes) - { - mGl.DisableVertexAttribArray(attribute.location); + // based on reflection, issue gl calls + buffer.buffer->BindAsUniformBuffer( static_cast(pipeline->programState.program) ); + } + + auto drawCmds = commandBuffer->GetCommandsByType( 0 | + CommandType::DRAW | + CommandType::DRAW_INDEXED_INDIRECT | + CommandType::DRAW_INDEXED ); + + if(!drawCmds.empty()) + { + if (drawCmds[0]->draw.type == DrawCallDescriptor::Type::DRAW_INDEXED ) + { + mGl.DrawElements(GetTopology(topology), + static_cast(drawCmds[0]->draw.drawIndexed.indexCount), + GL_UNSIGNED_SHORT, + reinterpret_cast(drawCmds[0]->draw.drawIndexed.firstIndex)); + } + else + { + mGl.DrawArrays(GetTopology(topology), 0, drawCmds[0]->draw.draw.vertexCount); + } + } + // attribute clear + for (auto &attribute : vi.attributes) + { + mGl.DisableVertexAttribArray(attribute.location); + } } } } diff --git a/automated-tests/src/dali/dali-test-suite-utils/test-graphics-reflection.cpp b/automated-tests/src/dali/dali-test-suite-utils/test-graphics-reflection.cpp index c9ef2d0..7b2b0dc 100644 --- a/automated-tests/src/dali/dali-test-suite-utils/test-graphics-reflection.cpp +++ b/automated-tests/src/dali/dali-test-suite-utils/test-graphics-reflection.cpp @@ -16,11 +16,52 @@ #include "test-graphics-reflection.h" #include - +#include +#include namespace Dali { +namespace +{ +// Add members +struct UniformData +{ + std::string name; + Property::Type type; + UniformData( const std::string& name, Property::Type type = Property::Type::NONE) + : name(name), type(type) + {} +}; +static const std::vector UNIFORMS = + { + UniformData("uRendererColor",Property::Type::FLOAT), + UniformData("uCustom", Property::Type::INTEGER), + UniformData("uCustom3", Property::Type::VECTOR3), + UniformData("uFadeColor", Property::Type::VECTOR4), + UniformData("uUniform1", Property::Type::VECTOR4), + UniformData("uUniform2", Property::Type::VECTOR4), + UniformData("uUniform3", Property::Type::VECTOR4), + UniformData("uFadeProgress", Property::Type::FLOAT), + UniformData("uANormalMatrix", Property::Type::MATRIX3), + UniformData("sEffect", Property::Type::FLOAT), + UniformData("sTexture", Property::Type::FLOAT), + UniformData("sTextureRect", Property::Type::FLOAT), + UniformData("sGloss", Property::Type::FLOAT), + UniformData("uColor", Property::Type::VECTOR4), + UniformData("uModelMatrix", Property::Type::MATRIX), + UniformData("uModelView", Property::Type::MATRIX), + UniformData("uMvpMatrix", Property::Type::MATRIX), + UniformData("uNormalMatrix", Property::Type::MATRIX3), + UniformData("uProjection", Property::Type::MATRIX), + UniformData("uSize", Property::Type::VECTOR3), + UniformData("uViewMatrix", Property::Type::MATRIX), + UniformData("uLightCameraProjectionMatrix", Property::Type::MATRIX), + UniformData("uLightCameraViewMatrix", Property::Type::MATRIX), + + }; +} + TestGraphicsReflection::TestGraphicsReflection(TestGlAbstraction& gl, Property::Array& vfs) -: mGl(gl) + : mGl(gl) { for(Property::Array::SizeType i = 0; i < vfs.Count(); ++i) { @@ -78,7 +119,7 @@ std::vector TestGraphicsReflection::GetVertexAttributeLocations() cons uint32_t TestGraphicsReflection::GetUniformBlockCount() const { - return 0u; + return 1u; } uint32_t TestGraphicsReflection::GetUniformBlockBinding(uint32_t index) const @@ -88,11 +129,32 @@ uint32_t TestGraphicsReflection::GetUniformBlockBinding(uint32_t index) const uint32_t TestGraphicsReflection::GetUniformBlockSize(uint32_t index) const { - return 0u; + // 64 bytes per uniform (64 = 4x4 matrix) + // TODO: fix if array will be used + return 64 * UNIFORMS.size(); } bool TestGraphicsReflection::GetUniformBlock(uint32_t index, Dali::Graphics::UniformBlockInfo& out) const { + auto& info = out; + info.name = ""; + info.members = {}; + info.binding = 0; + info.size = 64 * UNIFORMS.size(); + info.descriptorSet = 0; + info.members.clear(); + int loc = 0; + for( const auto& data : UNIFORMS ) + { + info.members.emplace_back(); + auto& item = info.members.back(); + item.name = data.name; + item.binding = 0; + item.offset = loc*64; + item.location = loc++; + item.bufferIndex = 0; + item.uniformClass = Graphics::UniformClass::UNIFORM; + } return true; } @@ -108,12 +170,12 @@ std::string TestGraphicsReflection::GetUniformBlockName(uint32_t blockIndex) con uint32_t TestGraphicsReflection::GetUniformBlockMemberCount(uint32_t blockIndex) const { - return 0u; + return UNIFORMS.size(); } std::string TestGraphicsReflection::GetUniformBlockMemberName(uint32_t blockIndex, uint32_t memberLocation) const { - return std::string{}; + return UNIFORMS[memberLocation].name; } uint32_t TestGraphicsReflection::GetUniformBlockMemberOffset(uint32_t blockIndex, uint32_t memberLocation) const @@ -136,4 +198,9 @@ Graphics::ShaderLanguage TestGraphicsReflection::GetLanguage() const return Graphics::ShaderLanguage::GLSL_3_1; } +Dali::Property::Type TestGraphicsReflection::GetMemberType( int blockIndex, int location) const +{ + return UNIFORMS[location].type; +} + } // namespace Dali diff --git a/automated-tests/src/dali/dali-test-suite-utils/test-graphics-reflection.h b/automated-tests/src/dali/dali-test-suite-utils/test-graphics-reflection.h index 9311e07..543cf6e 100644 --- a/automated-tests/src/dali/dali-test-suite-utils/test-graphics-reflection.h +++ b/automated-tests/src/dali/dali-test-suite-utils/test-graphics-reflection.h @@ -55,6 +55,8 @@ public: // Test methods } } + Dali::Property::Type GetMemberType( int blockIndex, int location) const; + TestGlAbstraction& mGl; mutable std::vector mAttributes; }; diff --git a/automated-tests/src/dali/utc-Dali-Geometry.cpp b/automated-tests/src/dali/utc-Dali-Geometry.cpp index bbf9d3a..3654fdd 100644 --- a/automated-tests/src/dali/utc-Dali-Geometry.cpp +++ b/automated-tests/src/dali/utc-Dali-Geometry.cpp @@ -202,7 +202,7 @@ int UtcDaliGeometryAddVertexBuffer(void) const TestGlAbstraction::BufferDataCalls& bufferDataCalls = application.GetGlAbstraction().GetBufferDataCalls(); - DALI_TEST_EQUALS(bufferDataCalls.size(), 1u, TEST_LOCATION); + DALI_TEST_EQUALS(bufferDataCalls.size(), 3u, TEST_LOCATION); DALI_TEST_EQUALS(bufferDataCalls[0], 4 * sizeof(TexturedQuadVertex), TEST_LOCATION); } @@ -322,7 +322,7 @@ int UtcDaliGeometrySetIndexBuffer(void) const TestGlAbstraction::BufferDataCalls& bufferDataCalls = application.GetGlAbstraction().GetBufferDataCalls(); - DALI_TEST_EQUALS(bufferDataCalls.size(), 1u, TEST_LOCATION); + DALI_TEST_EQUALS(bufferDataCalls.size(), 3u, TEST_LOCATION); DALI_TEST_EQUALS(bufferDataCalls[0], 4 * sizeof(TexturedQuadVertex), TEST_LOCATION); } diff --git a/automated-tests/src/dali/utc-Dali-Renderer.cpp b/automated-tests/src/dali/utc-Dali-Renderer.cpp index b6b00de..667b065 100644 --- a/automated-tests/src/dali/utc-Dali-Renderer.cpp +++ b/automated-tests/src/dali/utc-Dali-Renderer.cpp @@ -3650,8 +3650,11 @@ int UtcDaliRendererPreparePipeline(void) std::vector& submissions = graphics.mSubmitStack; DALI_TEST_EQUALS(submissions.size(), 1, TEST_LOCATION); DALI_TEST_EQUALS(submissions[0].cmdBuffer.size(), 1, TEST_LOCATION); - const TestGraphicsCommandBuffer* cmdBuf = static_cast((submissions[0].cmdBuffer[0])); - auto pipeline = cmdBuf->mPipeline; + TestGraphicsCommandBuffer* cmdBuf = static_cast((submissions[0].cmdBuffer[0])); + //auto pipeline = cmdBuf->mPipeline; + auto result = cmdBuf->GetCommandsByType( 0 | CommandType::BIND_PIPELINE ); + auto pipeline = result[0]->bindPipeline.pipeline; + if(pipeline) { DALI_TEST_EQUALS(pipeline->vertexInputState.attributes.size(), 12, TEST_LOCATION); diff --git a/automated-tests/src/dali/utc-Dali-Shader.cpp b/automated-tests/src/dali/utc-Dali-Shader.cpp index 4633c21..9d51d27 100644 --- a/automated-tests/src/dali/utc-Dali-Shader.cpp +++ b/automated-tests/src/dali/utc-Dali-Shader.cpp @@ -370,7 +370,7 @@ int UtcDaliShaderAnimatedProperty02(void) application.Render(100); // register another custom property as well - Property::Index customIndex = shader.RegisterProperty("uCustom", Vector3(1, 2, 3)); + Property::Index customIndex = shader.RegisterProperty("uCustom3", Vector3(1, 2, 3)); DALI_TEST_EQUALS(shader.GetProperty(customIndex), Vector3(1, 2, 3), TEST_LOCATION); application.SendNotification(); @@ -380,7 +380,7 @@ int UtcDaliShaderAnimatedProperty02(void) DALI_TEST_EQUALS(actualValue, Color::TRANSPARENT, TEST_LOCATION); Vector3 customValue; - DALI_TEST_CHECK(gl.GetUniformValue("uCustom", customValue)); + DALI_TEST_CHECK(gl.GetUniformValue("uCustom3", customValue)); DALI_TEST_EQUALS(customValue, Vector3(1, 2, 3), TEST_LOCATION); END_TEST; } diff --git a/automated-tests/src/dali/utc-Dali-VertexBuffer.cpp b/automated-tests/src/dali/utc-Dali-VertexBuffer.cpp index d2bec9f..1f286aa 100644 --- a/automated-tests/src/dali/utc-Dali-VertexBuffer.cpp +++ b/automated-tests/src/dali/utc-Dali-VertexBuffer.cpp @@ -191,7 +191,7 @@ int UtcDaliVertexBufferSetData01(void) const TestGlAbstraction::BufferDataCalls& bufferDataCalls = application.GetGlAbstraction().GetBufferDataCalls(); - DALI_TEST_EQUALS(bufferDataCalls.size(), 1u, TEST_LOCATION); + DALI_TEST_EQUALS(bufferDataCalls.size(), 3u, TEST_LOCATION); DALI_TEST_EQUALS(bufferDataCalls[0], sizeof(texturedQuadVertexData), TEST_LOCATION); } @@ -244,7 +244,7 @@ int UtcDaliVertexBufferSetData02(void) const TestGlAbstraction::BufferDataCalls& bufferDataCalls = application.GetGlAbstraction().GetBufferDataCalls(); - DALI_TEST_EQUALS(bufferDataCalls.size(), 1u, TEST_LOCATION); + DALI_TEST_EQUALS(bufferDataCalls.size(), 2u, TEST_LOCATION); DALI_TEST_EQUALS(bufferDataCalls[0], sizeof(texturedQuadVertexData), TEST_LOCATION); } @@ -262,8 +262,9 @@ int UtcDaliVertexBufferSetData02(void) const TestGlAbstraction::BufferDataCalls& bufferDataCalls = application.GetGlAbstraction().GetBufferDataCalls(); - DALI_TEST_EQUALS(bufferSubDataCalls.size(), 1u, TEST_LOCATION); - DALI_TEST_EQUALS(bufferDataCalls.size(), 1u, TEST_LOCATION); + // test below includes updates of uniform buffers + DALI_TEST_EQUALS(bufferSubDataCalls.size(), 17u, TEST_LOCATION); + DALI_TEST_EQUALS(bufferDataCalls.size(), 3u, TEST_LOCATION); if(bufferSubDataCalls.size()) { -- 2.7.4