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
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);
}
{
// 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
{
return mViewportTrace;
}
+ inline TraceCallStack& GetBufferTrace()
+ {
+ return mBufferTrace;
+ }
template<typename T>
inline bool GetUniformValue(const char* name, T& value) const
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;
--- /dev/null
+/*
+ * 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 <sstream>
+
+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::BufferUsageFlags>(Graphics::BufferUsage::INDEX_BUFFER)) != 0)
+ {
+ target = GL_ELEMENT_ARRAY_BUFFER;
+ }
+ return target;
+}
+
+} // namespace Dali
#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"
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);
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)
{
TraceCallStack::NamedParams namedParams;
out << std::hex << renderTarget;
namedParams["renderTarget"] = out.str();
- mCallStack.PushCall("PresentRenderTarget", "", namedParams);
+ mCallStack.PushCall("Controller::PresentRenderTarget", "", namedParams);
}
/**
*/
void TestGraphicsController::WaitIdle()
{
- mCallStack.PushCall("WaitIdle", "");
+ mCallStack.PushCall("Controller::WaitIdle", "");
}
/**
*/
void TestGraphicsController::Pause()
{
- mCallStack.PushCall("Pause", "");
+ mCallStack.PushCall("Controller::Pause", "");
}
/**
*/
void TestGraphicsController::Resume()
{
- mCallStack.PushCall("Resume", "");
+ mCallStack.PushCall("Controller::Resume", "");
}
void TestGraphicsController::UpdateTextures(const std::vector<Graphics::TextureUpdateInfo>& updateInfoList,
out << "[" << sourceList.size() << "]:";
namedParams["sourceList"] = out.str();
- mCallStack.PushCall("UpdateTextures", "", namedParams);
+ mCallStack.PushCall("Controller::UpdateTextures", "", namedParams);
// Call either TexImage2D or TexSubImage2D
for(unsigned int i = 0; i < updateInfoList.size(); ++i)
TraceCallStack::NamedParams namedParams;
namedParams["enableDepth"] = enableDepth ? "T" : "F";
namedParams["enableStencil"] = enableStencil ? "T" : "F";
- mCallStack.PushCall("EnableDepthStencilBuffer", "", namedParams);
+ mCallStack.PushCall("Controller::EnableDepthStencilBuffer", "", namedParams);
return false;
}
out << numberOfDiscardedRenderers;
TraceCallStack::NamedParams namedParams;
namedParams["numberOfDiscardedrenderers"] = out.str();
- mCallStack.PushCall("RunGarbageCollector", "", namedParams);
+ mCallStack.PushCall("Controller::RunGarbageCollector", "", namedParams);
}
void TestGraphicsController::DiscardUnusedResources()
{
- mCallStack.PushCall("DiscardUnusedResources", "");
+ mCallStack.PushCall("Controller::DiscardUnusedResources", "");
}
bool TestGraphicsController::IsDiscardQueueEmpty()
{
- mCallStack.PushCall("IsDiscardQueueEmpty", "");
+ mCallStack.PushCall("Controller::IsDiscardQueueEmpty", "");
return isDiscardQueueEmptyResult;
}
*/
bool TestGraphicsController::IsDrawOnResumeRequired()
{
- mCallStack.PushCall("IsDrawOnResumeRequired", "");
+ mCallStack.PushCall("Controller::IsDrawOnResumeRequired", "");
return isDrawOnResumeRequiredResult;
}
-Graphics::UniquePtr<Graphics::Buffer> TestGraphicsController::CreateBuffer(const Graphics::BufferCreateInfo& bufferCreateInfo, Graphics::UniquePtr<Graphics::Buffer>&& oldBuffer)
+Graphics::UniquePtr<Graphics::Buffer> TestGraphicsController::CreateBuffer(const Graphics::BufferCreateInfo& createInfo, Graphics::UniquePtr<Graphics::Buffer>&& oldBuffer)
{
std::ostringstream oss;
- oss << "bufferCreateInfo:" << bufferCreateInfo;
- mCallStack.PushCall("CreateBuffer", oss.str());
-
- return Graphics::MakeUnique<TestGraphicsBuffer>();
+ oss << "bufferCreateInfo:" << createInfo;
+ mCallStack.PushCall("Controller::CreateBuffer", oss.str());
+ return Graphics::MakeUnique<TestGraphicsBuffer>(mCallStack, mGlAbstraction, createInfo.size, createInfo.usage);
}
Graphics::UniquePtr<Graphics::CommandBuffer> TestGraphicsController::CreateCommandBuffer(const Graphics::CommandBufferCreateInfo& commandBufferCreateInfo, Graphics::UniquePtr<Graphics::CommandBuffer>&& oldCommandBuffer)
{
std::ostringstream oss;
oss << "commandBufferCreateInfo:" << commandBufferCreateInfo;
- mCallStack.PushCall("CreateCommandBuffer", oss.str());
+ mCallStack.PushCall("Controller::CreateCommandBuffer", oss.str());
return Graphics::MakeUnique<TestGraphicsCommandBuffer>(mCommandBufferCallStack, mGlAbstraction);
}
Graphics::UniquePtr<Graphics::RenderPass> TestGraphicsController::CreateRenderPass(const Graphics::RenderPassCreateInfo& renderPassCreateInfo, Graphics::UniquePtr<Graphics::RenderPass>&& oldRenderPass)
{
- mCallStack.PushCall("CreateRenderPass", "");
+ mCallStack.PushCall("Controller::CreateRenderPass", "");
return nullptr;
}
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<TestGraphicsTexture>(mGlAbstraction, textureCreateInfo);
}
Graphics::UniquePtr<Graphics::Framebuffer> TestGraphicsController::CreateFramebuffer(const Graphics::FramebufferCreateInfo& framebufferCreateInfo, Graphics::UniquePtr<Graphics::Framebuffer>&& oldFramebuffer)
{
- mCallStack.PushCall("CreateFramebuffer", "");
+ mCallStack.PushCall("Controller::CreateFramebuffer", "");
return nullptr;
}
Graphics::UniquePtr<Graphics::Pipeline> TestGraphicsController::CreatePipeline(const Graphics::PipelineCreateInfo& pipelineCreateInfo, Graphics::UniquePtr<Graphics::Pipeline>&& oldPipeline)
{
- mCallStack.PushCall("CreatePipeline", "");
+ mCallStack.PushCall("Controller::CreatePipeline", "");
return nullptr;
}
Graphics::UniquePtr<Graphics::Shader> TestGraphicsController::CreateShader(const Graphics::ShaderCreateInfo& shaderCreateInfo, Graphics::UniquePtr<Graphics::Shader>&& oldShader)
{
- mCallStack.PushCall("CreateShader", "");
+ mCallStack.PushCall("Controller::CreateShader", "");
return nullptr;
}
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<TestGraphicsSampler>(mGlAbstraction, samplerCreateInfo);
}
Graphics::UniquePtr<Graphics::RenderTarget> TestGraphicsController::CreateRenderTarget(const Graphics::RenderTargetCreateInfo& renderTargetCreateInfo, Graphics::UniquePtr<Graphics::RenderTarget>&& oldRenderTarget)
{
- mCallStack.PushCall("CreateRenderTarget", "");
+ mCallStack.PushCall("Controller::CreateRenderTarget", "");
return nullptr;
}
Graphics::UniquePtr<Graphics::Memory> TestGraphicsController::MapBufferRange(const Graphics::MapBufferInfo& mapInfo)
{
- mCallStack.PushCall("MapBufferRange", "");
- return nullptr;
+ mCallStack.PushCall("Controller::MapBufferRange", "");
+
+ auto buffer = static_cast<TestGraphicsBuffer*>(mapInfo.buffer);
+ buffer->memory.resize(mapInfo.offset + mapInfo.size); // For initial testing, allow writes past capacity
+
+ return std::make_unique<TestGraphicsMemory>(mCallStack, *buffer, mapInfo.offset, mapInfo.size);
}
Graphics::UniquePtr<Graphics::Memory> TestGraphicsController::MapTextureRange(const Graphics::MapTextureInfo& mapInfo)
{
- mCallStack.PushCall("MapTextureRange", "");
+ mCallStack.PushCall("Controller::MapTextureRange", "");
return nullptr;
}
void TestGraphicsController::UnmapMemory(Graphics::UniquePtr<Graphics::Memory> 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;
}