From: David Steele Date: Thu, 4 Feb 2021 16:47:59 +0000 (+0000) Subject: updated test files to match dali-core : buffer impl X-Git-Tag: graphics-backend-pre-release-1~2 X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git;a=commitdiff_plain;h=57818b285f2485c7acd86d92f642f726b4a2bcca updated test files to match dali-core : buffer impl Change-Id: I5b06533a8b92c2f3eb45ed0a708767eccaace780 --- diff --git a/automated-tests/src/dali-scene-loader-internal/CMakeLists.txt b/automated-tests/src/dali-scene-loader-internal/CMakeLists.txt index 22a05cc..086a750 100755 --- a/automated-tests/src/dali-scene-loader-internal/CMakeLists.txt +++ b/automated-tests/src/dali-scene-loader-internal/CMakeLists.txt @@ -43,6 +43,7 @@ SET(TEST_HARNESS_SOURCES ${TEST_HARNESS_DIR}/test-gesture-generator.cpp ${TEST_HARNESS_DIR}/test-gl-abstraction.cpp ${TEST_HARNESS_DIR}/test-gl-sync-abstraction.cpp + ${TEST_HARNESS_DIR}/test-graphics-buffer.cpp ${TEST_HARNESS_DIR}/test-graphics-command-buffer.cpp ${TEST_HARNESS_DIR}/test-graphics-controller.cpp ${TEST_HARNESS_DIR}/test-graphics-texture.cpp diff --git a/automated-tests/src/dali-scene-loader/CMakeLists.txt b/automated-tests/src/dali-scene-loader/CMakeLists.txt index e73dc15..0c17d41 100755 --- a/automated-tests/src/dali-scene-loader/CMakeLists.txt +++ b/automated-tests/src/dali-scene-loader/CMakeLists.txt @@ -57,6 +57,7 @@ SET(TEST_HARNESS_SOURCES ${TEST_HARNESS_DIR}/test-gesture-generator.cpp ${TEST_HARNESS_DIR}/test-gl-abstraction.cpp ${TEST_HARNESS_DIR}/test-gl-sync-abstraction.cpp + ${TEST_HARNESS_DIR}/test-graphics-buffer.cpp ${TEST_HARNESS_DIR}/test-graphics-command-buffer.cpp ${TEST_HARNESS_DIR}/test-graphics-controller.cpp ${TEST_HARNESS_DIR}/test-graphics-texture.cpp diff --git a/automated-tests/src/dali-toolkit-internal/CMakeLists.txt b/automated-tests/src/dali-toolkit-internal/CMakeLists.txt index 14ec132..e75b848 100755 --- a/automated-tests/src/dali-toolkit-internal/CMakeLists.txt +++ b/automated-tests/src/dali-toolkit-internal/CMakeLists.txt @@ -80,6 +80,7 @@ SET(TEST_HARNESS_SOURCES ../dali-toolkit/dali-toolkit-test-utils/test-harness.cpp ../dali-toolkit/dali-toolkit-test-utils/test-gl-abstraction.cpp ../dali-toolkit/dali-toolkit-test-utils/test-gl-sync-abstraction.cpp + ../dali-toolkit/dali-toolkit-test-utils/test-graphics-buffer.cpp ../dali-toolkit/dali-toolkit-test-utils/test-graphics-command-buffer.cpp ../dali-toolkit/dali-toolkit-test-utils/test-graphics-controller.cpp ../dali-toolkit/dali-toolkit-test-utils/test-graphics-texture.cpp diff --git a/automated-tests/src/dali-toolkit-styling/CMakeLists.txt b/automated-tests/src/dali-toolkit-styling/CMakeLists.txt index 694c656..fa86caf 100644 --- a/automated-tests/src/dali-toolkit-styling/CMakeLists.txt +++ b/automated-tests/src/dali-toolkit-styling/CMakeLists.txt @@ -46,6 +46,7 @@ SET(TEST_HARNESS_SOURCES ../dali-toolkit/dali-toolkit-test-utils/test-platform-abstraction.cpp ../dali-toolkit/dali-toolkit-test-utils/test-gl-abstraction.cpp ../dali-toolkit/dali-toolkit-test-utils/test-gl-sync-abstraction.cpp + ../dali-toolkit/dali-toolkit-test-utils/test-graphics-buffer.cpp ../dali-toolkit/dali-toolkit-test-utils/test-graphics-command-buffer.cpp ../dali-toolkit/dali-toolkit-test-utils/test-graphics-controller.cpp ../dali-toolkit/dali-toolkit-test-utils/test-graphics-texture.cpp diff --git a/automated-tests/src/dali-toolkit-third-party/CMakeLists.txt b/automated-tests/src/dali-toolkit-third-party/CMakeLists.txt index 90f8b7c..ec88375 100644 --- a/automated-tests/src/dali-toolkit-third-party/CMakeLists.txt +++ b/automated-tests/src/dali-toolkit-third-party/CMakeLists.txt @@ -32,6 +32,7 @@ SET(TEST_HARNESS_SOURCES ../dali-toolkit/dali-toolkit-test-utils/test-harness.cpp ../dali-toolkit/dali-toolkit-test-utils/test-gl-abstraction.cpp ../dali-toolkit/dali-toolkit-test-utils/test-gl-sync-abstraction.cpp + ../dali-toolkit/dali-toolkit-test-utils/test-graphics-buffer.cpp ../dali-toolkit/dali-toolkit-test-utils/test-graphics-command-buffer.cpp ../dali-toolkit/dali-toolkit-test-utils/test-graphics-controller.cpp ../dali-toolkit/dali-toolkit-test-utils/test-graphics-texture.cpp diff --git a/automated-tests/src/dali-toolkit/CMakeLists.txt b/automated-tests/src/dali-toolkit/CMakeLists.txt index fe00bc9..832a04b 100755 --- a/automated-tests/src/dali-toolkit/CMakeLists.txt +++ b/automated-tests/src/dali-toolkit/CMakeLists.txt @@ -110,6 +110,7 @@ SET(TEST_HARNESS_SOURCES dali-toolkit-test-utils/test-gesture-generator.cpp dali-toolkit-test-utils/test-gl-abstraction.cpp dali-toolkit-test-utils/test-gl-sync-abstraction.cpp + dali-toolkit-test-utils/test-graphics-buffer.cpp dali-toolkit-test-utils/test-graphics-command-buffer.cpp dali-toolkit-test-utils/test-graphics-controller.cpp dali-toolkit-test-utils/test-graphics-texture.cpp diff --git a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-gl-abstraction.h b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-gl-abstraction.h index 2af9660..4e14dd9 100644 --- a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-gl-abstraction.h +++ b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-gl-abstraction.h @@ -102,6 +102,12 @@ public: inline void BindBuffer(GLenum target, GLuint buffer) override { + std::ostringstream o; + o << std::hex << target << ", " << buffer; + TraceCallStack::NamedParams namedParams; + namedParams["target"] = target; + namedParams["buffer"] = buffer; + mBufferTrace.PushCall("BindBuffer", o.str(), namedParams); } inline void BindFramebuffer(GLenum target, GLuint framebuffer) override @@ -242,11 +248,28 @@ public: inline void BufferData(GLenum target, GLsizeiptr size, const void* data, GLenum usage) override { + std::ostringstream o; + o << std::hex << target << ", " << size << ", " << data << ", " << usage; + TraceCallStack::NamedParams namedParams; + namedParams["target"] = target; + namedParams["size"] = size; + namedParams["usage"] = usage; + + mBufferTrace.PushCall("BufferData", o.str(), namedParams); + mBufferDataCalls.push_back(size); } inline void BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data) override { + std::ostringstream o; + o << std::hex << target << ", " << offset << ", " << size << ", " << data; + TraceCallStack::NamedParams namedParams; + namedParams["target"] = target; + namedParams["offset"] = offset; + namedParams["size"] = size; + mBufferTrace.PushCall("BufferSubData", o.str()); + mBufferSubDataCalls.push_back(size); } @@ -613,6 +636,12 @@ public: { // avoids an assert in GpuBuffers *buffers = 1u; + + std::ostringstream o; + o << n; + TraceCallStack::NamedParams namedParams; + namedParams["n"] = o.str(); + mBufferTrace.PushCall("GenBuffers", o.str(), namedParams); } inline void GenerateMipmap(GLenum target) override @@ -2171,6 +2200,10 @@ public: // TEST FUNCTIONS { return mViewportTrace; } + inline TraceCallStack& GetBufferTrace() + { + return mBufferTrace; + } template inline bool GetUniformValue(const char* name, T& value) const @@ -2434,10 +2467,11 @@ private: ActiveTextureType mActiveTextures[MIN_TEXTURE_UNIT_LIMIT]; + TraceCallStack mBufferTrace{"gl"}; TraceCallStack mCullFaceTrace; TraceCallStack mEnableDisableTrace; TraceCallStack mShaderTrace; - TraceCallStack mTextureTrace{"GlA Texture:"}; + TraceCallStack mTextureTrace{"gl"}; TraceCallStack mTexParamaterTrace; TraceCallStack mDrawTrace; TraceCallStack mDepthFunctionTrace; diff --git a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-graphics-buffer.cpp b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-graphics-buffer.cpp new file mode 100644 index 0000000..2696078 --- /dev/null +++ b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-graphics-buffer.cpp @@ -0,0 +1,81 @@ +/* + * Copyright (c) 2021 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. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "test-graphics-buffer.h" + +#include + +namespace Dali +{ +TestGraphicsBuffer::TestGraphicsBuffer(TraceCallStack& callStack, TestGlAbstraction& glAbstraction, uint32_t size, Graphics::BufferUsageFlags usage) +: mCallStack(callStack), + mGl(glAbstraction), + mUsage(usage) +{ + memory.reserve(size); + mGl.GetBufferTrace().EnableLogging(true); +} + +void TestGraphicsBuffer::Bind() +{ + mCallStack.PushCall("Buffer::Bind", ""); + if(!mId) + { + mGl.GenBuffers(1, &mId); + } + mGl.BindBuffer(GetTarget(), mId); +} + +void TestGraphicsBuffer::Unbind() +{ + mCallStack.PushCall("Buffer::Unbind", ""); + if(mId) + { + mGl.BindBuffer(GetTarget(), 0); + } +} + +void TestGraphicsBuffer::Upload(uint32_t offset, uint32_t size) +{ + std::ostringstream o; + o << offset << ", " << size; + TraceCallStack::NamedParams namedParams; + namedParams["offset"] = offset; + namedParams["size"] = size; + mCallStack.PushCall("Buffer::Upload", o.str(), namedParams); + if(size <= memory.size() && mCreated) + { + // Use subData to avoid re-allocation + mGl.BufferSubData(GetTarget(), offset, size, &memory[offset]); + } + else + { + mGl.BufferData(GetTarget(), size, &memory[0], GL_STATIC_DRAW); //@todo Query - do we need other usages? + mCreated = true; + } +} + +GLenum TestGraphicsBuffer::GetTarget() +{ + GLenum target = GL_ARRAY_BUFFER; + if((mUsage & static_cast(Graphics::BufferUsage::INDEX_BUFFER)) != 0) + { + target = GL_ELEMENT_ARRAY_BUFFER; + } + return target; +} + +} // namespace Dali diff --git a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-graphics-buffer.h b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-graphics-buffer.h index 6a0acac..c4abc3e 100644 --- a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-graphics-buffer.h +++ b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-graphics-buffer.h @@ -18,13 +18,28 @@ */ #include +#include + +#include "test-gl-abstraction.h" +#include "test-trace-call-stack.h" namespace Dali { class TestGraphicsBuffer : public Graphics::Buffer { public: - TestGraphicsBuffer() = default; + TestGraphicsBuffer(TraceCallStack& callStack, TestGlAbstraction& glAbstraction, uint32_t size, Graphics::BufferUsageFlags usage); + void Bind(); + void Unbind(); + void Upload(uint32_t offset, uint32_t size); + GLenum GetTarget(); + + TraceCallStack& mCallStack; + TestGlAbstraction& mGl; + std::vector memory; + Graphics::BufferUsageFlags mUsage; + GLuint mId{0}; + bool mCreated{false}; }; } // namespace Dali diff --git a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-graphics-controller.cpp b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-graphics-controller.cpp index 4732a9a..e7f80cd 100644 --- a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-graphics-controller.cpp +++ b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/test-graphics-controller.cpp @@ -16,6 +16,7 @@ #include "test-graphics-controller.h" +#include "dali-test-suite-utils.h" #include "test-graphics-buffer.h" #include "test-graphics-command-buffer.h" #include "test-graphics-sampler.h" @@ -140,6 +141,59 @@ std::ostream& operator<<(std::ostream& o, const Graphics::SamplerCreateInfo& cre return o; } +class TestGraphicsMemory : public Graphics::Memory +{ +public: + TestGraphicsMemory(TraceCallStack& callStack, TestGraphicsBuffer& buffer, uint32_t mappedOffset, uint32_t mappedSize) + : mCallStack(callStack), + mBuffer(buffer), + mMappedOffset(mappedOffset), + mMappedSize(mappedSize) + { + } + + void* LockRegion(uint32_t offset, uint32_t size) override + { + std::ostringstream o; + o << offset << ", " << size; + mCallStack.PushCall("Memory::LockRegion", o.str()); + + if(offset > mMappedOffset + mMappedSize || + size + offset > mMappedOffset + mMappedSize) + { + tet_infoline("TestGraphics.Memory::LockRegion() Out of bounds"); + mBuffer.memory.resize(mMappedOffset + offset + size); // Grow to prevent memcpy from crashing + } + mLockedOffset = offset; + mLockedSize = size; + return &mBuffer.memory[mMappedOffset + offset]; + } + + void Unlock(bool flush) override + { + mCallStack.PushCall("Memory::Unlock", (flush ? "Flush" : "NoFlush")); + if(flush) + { + Flush(); + } + } + + void Flush() override + { + mCallStack.PushCall("Memory::Flush", ""); + mBuffer.Bind(); + mBuffer.Upload(mMappedOffset + mLockedOffset, mLockedSize); + mBuffer.Unbind(); + } + + TraceCallStack& mCallStack; + TestGraphicsBuffer& mBuffer; + uint32_t mMappedOffset; + uint32_t mMappedSize; + uint32_t mLockedOffset; + uint32_t mLockedSize; +}; + TestGraphicsController::TestGraphicsController() { mCallStack.Enable(true); @@ -158,7 +212,7 @@ void TestGraphicsController::SubmitCommandBuffers(const Graphics::SubmitInfo& su out << "cmdBuffer[" << submitInfo.cmdBuffer.size() << "], flags:" << std::hex << submitInfo.flags; namedParams["submitInfo"] = out.str(); - mCallStack.PushCall("SubmitCommandBuffers", "", namedParams); + mCallStack.PushCall("Controller::SubmitCommandBuffers", "", namedParams); for(auto& commandBuffer : submitInfo.cmdBuffer) { @@ -195,7 +249,7 @@ void TestGraphicsController::PresentRenderTarget(Graphics::RenderTarget* renderT TraceCallStack::NamedParams namedParams; out << std::hex << renderTarget; namedParams["renderTarget"] = out.str(); - mCallStack.PushCall("PresentRenderTarget", "", namedParams); + mCallStack.PushCall("Controller::PresentRenderTarget", "", namedParams); } /** @@ -203,7 +257,7 @@ void TestGraphicsController::PresentRenderTarget(Graphics::RenderTarget* renderT */ void TestGraphicsController::WaitIdle() { - mCallStack.PushCall("WaitIdle", ""); + mCallStack.PushCall("Controller::WaitIdle", ""); } /** @@ -211,7 +265,7 @@ void TestGraphicsController::WaitIdle() */ void TestGraphicsController::Pause() { - mCallStack.PushCall("Pause", ""); + mCallStack.PushCall("Controller::Pause", ""); } /** @@ -219,7 +273,7 @@ void TestGraphicsController::Pause() */ void TestGraphicsController::Resume() { - mCallStack.PushCall("Resume", ""); + mCallStack.PushCall("Controller::Resume", ""); } void TestGraphicsController::UpdateTextures(const std::vector& updateInfoList, @@ -233,7 +287,7 @@ void TestGraphicsController::UpdateTextures(const std::vector TestGraphicsController::CreateBuffer(const Graphics::BufferCreateInfo& bufferCreateInfo, Graphics::UniquePtr&& oldBuffer) +Graphics::UniquePtr TestGraphicsController::CreateBuffer(const Graphics::BufferCreateInfo& createInfo, Graphics::UniquePtr&& oldBuffer) { std::ostringstream oss; - oss << "bufferCreateInfo:" << bufferCreateInfo; - mCallStack.PushCall("CreateBuffer", oss.str()); - - return Graphics::MakeUnique(); + oss << "bufferCreateInfo:" << createInfo; + mCallStack.PushCall("Controller::CreateBuffer", oss.str()); + return Graphics::MakeUnique(mCallStack, mGlAbstraction, createInfo.size, createInfo.usage); } Graphics::UniquePtr TestGraphicsController::CreateCommandBuffer(const Graphics::CommandBufferCreateInfo& commandBufferCreateInfo, Graphics::UniquePtr&& oldCommandBuffer) { std::ostringstream oss; oss << "commandBufferCreateInfo:" << commandBufferCreateInfo; - mCallStack.PushCall("CreateCommandBuffer", oss.str()); + mCallStack.PushCall("Controller::CreateCommandBuffer", oss.str()); return Graphics::MakeUnique(mCommandBufferCallStack, mGlAbstraction); } Graphics::UniquePtr TestGraphicsController::CreateRenderPass(const Graphics::RenderPassCreateInfo& renderPassCreateInfo, Graphics::UniquePtr&& oldRenderPass) { - mCallStack.PushCall("CreateRenderPass", ""); + mCallStack.PushCall("Controller::CreateRenderPass", ""); return nullptr; } @@ -317,26 +370,26 @@ Graphics::UniquePtr TestGraphicsController::CreateTexture(con TraceCallStack::NamedParams namedParams; oss << textureCreateInfo; namedParams["textureCreateInfo"] = oss.str(); - mCallStack.PushCall("CreateTexture", params.str(), namedParams); + mCallStack.PushCall("Controller::CreateTexture", params.str(), namedParams); return Graphics::MakeUnique(mGlAbstraction, textureCreateInfo); } Graphics::UniquePtr TestGraphicsController::CreateFramebuffer(const Graphics::FramebufferCreateInfo& framebufferCreateInfo, Graphics::UniquePtr&& oldFramebuffer) { - mCallStack.PushCall("CreateFramebuffer", ""); + mCallStack.PushCall("Controller::CreateFramebuffer", ""); return nullptr; } Graphics::UniquePtr TestGraphicsController::CreatePipeline(const Graphics::PipelineCreateInfo& pipelineCreateInfo, Graphics::UniquePtr&& oldPipeline) { - mCallStack.PushCall("CreatePipeline", ""); + mCallStack.PushCall("Controller::CreatePipeline", ""); return nullptr; } Graphics::UniquePtr TestGraphicsController::CreateShader(const Graphics::ShaderCreateInfo& shaderCreateInfo, Graphics::UniquePtr&& oldShader) { - mCallStack.PushCall("CreateShader", ""); + mCallStack.PushCall("Controller::CreateShader", ""); return nullptr; } @@ -347,57 +400,61 @@ Graphics::UniquePtr TestGraphicsController::CreateSampler(con TraceCallStack::NamedParams namedParams; oss << samplerCreateInfo; namedParams["samplerCreateInfo"] = oss.str(); - mCallStack.PushCall("CreateSampler", params.str(), namedParams); + mCallStack.PushCall("Controller::CreateSampler", params.str(), namedParams); return Graphics::MakeUnique(mGlAbstraction, samplerCreateInfo); } Graphics::UniquePtr TestGraphicsController::CreateRenderTarget(const Graphics::RenderTargetCreateInfo& renderTargetCreateInfo, Graphics::UniquePtr&& oldRenderTarget) { - mCallStack.PushCall("CreateRenderTarget", ""); + mCallStack.PushCall("Controller::CreateRenderTarget", ""); return nullptr; } Graphics::UniquePtr TestGraphicsController::MapBufferRange(const Graphics::MapBufferInfo& mapInfo) { - mCallStack.PushCall("MapBufferRange", ""); - return nullptr; + mCallStack.PushCall("Controller::MapBufferRange", ""); + + auto buffer = static_cast(mapInfo.buffer); + buffer->memory.resize(mapInfo.offset + mapInfo.size); // For initial testing, allow writes past capacity + + return std::make_unique(mCallStack, *buffer, mapInfo.offset, mapInfo.size); } Graphics::UniquePtr TestGraphicsController::MapTextureRange(const Graphics::MapTextureInfo& mapInfo) { - mCallStack.PushCall("MapTextureRange", ""); + mCallStack.PushCall("Controller::MapTextureRange", ""); return nullptr; } void TestGraphicsController::UnmapMemory(Graphics::UniquePtr memory) { - mCallStack.PushCall("UnmapMemory", ""); + mCallStack.PushCall("Controller::UnmapMemory", ""); } Graphics::MemoryRequirements TestGraphicsController::GetTextureMemoryRequirements(Graphics::Texture& texture) const { - mCallStack.PushCall("GetTextureMemoryRequirements", ""); + mCallStack.PushCall("Controller::GetTextureMemoryRequirements", ""); return Graphics::MemoryRequirements{}; } Graphics::MemoryRequirements TestGraphicsController::GetBufferMemoryRequirements(Graphics::Buffer& buffer) const { - mCallStack.PushCall("GetBufferMemoryRequirements", ""); + mCallStack.PushCall("Controller::GetBufferMemoryRequirements", ""); return Graphics::MemoryRequirements{}; } const Graphics::TextureProperties& TestGraphicsController::GetTextureProperties(const Graphics::Texture& texture) { static Graphics::TextureProperties textureProperties{}; - mCallStack.PushCall("GetTextureProperties", ""); + mCallStack.PushCall("Controller::GetTextureProperties", ""); return textureProperties; } bool TestGraphicsController::PipelineEquals(const Graphics::Pipeline& pipeline0, const Graphics::Pipeline& pipeline1) const { - mCallStack.PushCall("PipelineEquals", ""); + mCallStack.PushCall("Controller::PipelineEquals", ""); return false; }