/*
- * Copyright (c) 2022 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2023 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.
#include <dali/integration-api/debug.h>
#include <dali/internal/common/image-sampler.h>
#include <dali/internal/common/matrix-utils.h>
+#include <dali/internal/common/memory-pool-object-allocator.h>
#include <dali/internal/event/rendering/texture-impl.h>
#include <dali/internal/render/common/render-instruction.h>
#include <dali/internal/render/data-providers/node-data-provider.h>
return ((dataSize / 256u) + ((dataSize % 256u) ? 1u : 0u)) * 256u;
}
+/**
+ * @brief Store latest bound RenderGeometry, and help that we can skip duplicated vertex attributes bind.
+ *
+ * @param[in] geometry Current geometry to be used, or nullptr if render finished
+ * @return True if we can reuse latest bound vertex attributes. False otherwise.
+ */
+inline bool ReuseLatestBoundVertexAttributes(const Render::Geometry* geometry)
+{
+ static const Render::Geometry* gLatestVertexBoundGeometry = nullptr;
+ if(gLatestVertexBoundGeometry == geometry)
+ {
+ return true;
+ }
+ gLatestVertexBoundGeometry = geometry;
+ return false;
+}
+
} // namespace
namespace Render
{
-Renderer* Renderer::New(SceneGraph::RenderDataProvider* dataProvider,
- Render::Geometry* geometry,
- uint32_t blendingBitmask,
- const Vector4& blendColor,
- FaceCullingMode::Type faceCullingMode,
- bool preMultipliedAlphaEnabled,
- DepthWriteMode::Type depthWriteMode,
- DepthTestMode::Type depthTestMode,
- DepthFunction::Type depthFunction,
- StencilParameters& stencilParameters)
+namespace
+{
+MemoryPoolObjectAllocator<Renderer> gRenderRendererMemoryPool;
+}
+
+void Renderer::PrepareCommandBuffer()
{
- return new Renderer(dataProvider, geometry, blendingBitmask, blendColor, faceCullingMode, preMultipliedAlphaEnabled, depthWriteMode, depthTestMode, depthFunction, stencilParameters);
+ // Reset latest geometry informations, So we can bind the first of geometry.
+ ReuseLatestBoundVertexAttributes(nullptr);
+
+ // todo : Fill here as many caches as we can store for reduce the number of command buffers
+}
+
+RendererKey Renderer::NewKey(SceneGraph::RenderDataProvider* dataProvider,
+ Render::Geometry* geometry,
+ uint32_t blendingBitmask,
+ const Vector4& blendColor,
+ FaceCullingMode::Type faceCullingMode,
+ bool preMultipliedAlphaEnabled,
+ DepthWriteMode::Type depthWriteMode,
+ DepthTestMode::Type depthTestMode,
+ DepthFunction::Type depthFunction,
+ StencilParameters& stencilParameters)
+{
+ void* ptr = gRenderRendererMemoryPool.AllocateRawThreadSafe();
+ auto key = gRenderRendererMemoryPool.GetKeyFromPtr(static_cast<Renderer*>(ptr));
+
+ // Use placement new to construct renderer.
+ new(ptr) Renderer(dataProvider, geometry, blendingBitmask, blendColor, faceCullingMode, preMultipliedAlphaEnabled, depthWriteMode, depthTestMode, depthFunction, stencilParameters);
+ return RendererKey(key);
}
Renderer::Renderer(SceneGraph::RenderDataProvider* dataProvider,
mDepthWriteMode(depthWriteMode),
mDepthTestMode(depthTestMode),
mPremultipliedAlphaEnabled(preMultipliedAlphaEnabled),
- mShaderChanged(false),
- mUpdated(true)
+ mShaderChanged(false)
{
if(blendingBitmask != 0u)
{
Renderer::~Renderer() = default;
+void Renderer::operator delete(void* ptr)
+{
+ gRenderRendererMemoryPool.FreeThreadSafe(static_cast<Renderer*>(ptr));
+}
+
+Renderer* Renderer::Get(RendererKey::KeyType rendererKey)
+{
+ return gRenderRendererMemoryPool.GetPtrFromKey(rendererKey);
+}
+
void Renderer::SetGeometry(Render::Geometry* geometry)
{
mGeometry = geometry;
- mUpdated = true;
}
+
void Renderer::SetDrawCommands(Dali::DevelRenderer::DrawCommand* pDrawCommands, uint32_t size)
{
mDrawCommands.clear();
{
uint32_t textureUnit = 0;
- const Dali::Vector<Render::Texture*>* textures(mRenderDataProvider->GetTextures());
- const Dali::Vector<Render::Sampler*>* samplers(mRenderDataProvider->GetSamplers());
+ auto textures(mRenderDataProvider->GetTextures());
+ auto samplers(mRenderDataProvider->GetSamplers());
std::vector<Graphics::TextureBinding> textureBindings;
void Renderer::SetFaceCullingMode(FaceCullingMode::Type mode)
{
mFaceCullingMode = mode;
- mUpdated = true;
}
void Renderer::SetBlendingBitMask(uint32_t bitmask)
{
mBlendingOptions.SetBitmask(bitmask);
- mUpdated = true;
}
void Renderer::SetBlendColor(const Vector4& color)
{
mBlendingOptions.SetBlendColor(color);
- mUpdated = true;
}
void Renderer::SetIndexedDrawFirstElement(uint32_t firstElement)
{
mIndexedDrawFirstElement = firstElement;
- mUpdated = true;
}
void Renderer::SetIndexedDrawElementsCount(uint32_t elementsCount)
{
mIndexedDrawElementsCount = elementsCount;
- mUpdated = true;
}
void Renderer::EnablePreMultipliedAlpha(bool enable)
{
mPremultipliedAlphaEnabled = enable;
- mUpdated = true;
}
void Renderer::SetDepthWriteMode(DepthWriteMode::Type depthWriteMode)
{
mDepthWriteMode = depthWriteMode;
- mUpdated = true;
}
void Renderer::SetDepthTestMode(DepthTestMode::Type depthTestMode)
{
mDepthTestMode = depthTestMode;
- mUpdated = true;
}
DepthWriteMode::Type Renderer::GetDepthWriteMode() const
void Renderer::SetDepthFunction(DepthFunction::Type depthFunction)
{
mDepthFunction = depthFunction;
- mUpdated = true;
}
DepthFunction::Type Renderer::GetDepthFunction() const
void Renderer::SetRenderMode(RenderMode::Type renderMode)
{
mStencilParameters.renderMode = renderMode;
- mUpdated = true;
}
RenderMode::Type Renderer::GetRenderMode() const
void Renderer::SetStencilFunction(StencilFunction::Type stencilFunction)
{
mStencilParameters.stencilFunction = stencilFunction;
- mUpdated = true;
}
StencilFunction::Type Renderer::GetStencilFunction() const
void Renderer::SetStencilFunctionMask(int stencilFunctionMask)
{
mStencilParameters.stencilFunctionMask = stencilFunctionMask;
- mUpdated = true;
}
int Renderer::GetStencilFunctionMask() const
void Renderer::SetStencilFunctionReference(int stencilFunctionReference)
{
mStencilParameters.stencilFunctionReference = stencilFunctionReference;
- mUpdated = true;
}
int Renderer::GetStencilFunctionReference() const
void Renderer::SetStencilMask(int stencilMask)
{
mStencilParameters.stencilMask = stencilMask;
- mUpdated = true;
}
int Renderer::GetStencilMask() const
void Renderer::SetStencilOperationOnFail(StencilOperation::Type stencilOperationOnFail)
{
mStencilParameters.stencilOperationOnFail = stencilOperationOnFail;
- mUpdated = true;
}
StencilOperation::Type Renderer::GetStencilOperationOnFail() const
void Renderer::SetStencilOperationOnZFail(StencilOperation::Type stencilOperationOnZFail)
{
mStencilParameters.stencilOperationOnZFail = stencilOperationOnZFail;
- mUpdated = true;
}
StencilOperation::Type Renderer::GetStencilOperationOnZFail() const
void Renderer::SetStencilOperationOnZPass(StencilOperation::Type stencilOperationOnZPass)
{
mStencilParameters.stencilOperationOnZPass = stencilOperationOnZPass;
- mUpdated = true;
}
StencilOperation::Type Renderer::GetStencilOperationOnZPass() const
// Check if there is render callback
if(mRenderCallback)
{
+ if(!mRenderCallbackInput)
+ {
+ mRenderCallbackInput = std::unique_ptr<RenderCallbackInput>(new RenderCallbackInput);
+ }
+
Graphics::DrawNativeInfo info{};
info.api = Graphics::DrawNativeAPI::GLES;
info.callback = &static_cast<Dali::CallbackBase&>(*mRenderCallback);
- info.userData = &mRenderCallbackInput;
+ info.userData = mRenderCallbackInput.get();
// Set storage for the context to be used
- info.glesNativeInfo.eglSharedContextStoragePointer = &mRenderCallbackInput.eglContext;
+ info.glesNativeInfo.eglSharedContextStoragePointer = &mRenderCallbackInput->eglContext;
info.reserved = nullptr;
auto& textureResources = mRenderCallback->GetTextureResources();
if(!textureResources.empty())
{
mRenderCallbackTextureBindings.clear();
- mRenderCallbackInput.textureBindings.resize(textureResources.size());
+ mRenderCallbackInput->textureBindings.resize(textureResources.size());
auto i = 0u;
for(auto& texture : textureResources)
{
auto& textureImpl = GetImplementation(texture);
- auto graphicsTexture = textureImpl.GetRenderObject()->GetGraphicsObject();
+ auto graphicsTexture = textureImpl.GetRenderTextureKey()->GetGraphicsObject();
- const auto& properties = mGraphicsController->GetTextureProperties(*graphicsTexture);
+ auto properties = mGraphicsController->GetTextureProperties(*graphicsTexture);
mRenderCallbackTextureBindings.emplace_back(graphicsTexture);
- mRenderCallbackInput.textureBindings[i] = properties.nativeHandle;
+ mRenderCallbackInput->textureBindings[i++] = properties.nativeHandle;
}
info.textureCount = mRenderCallbackTextureBindings.size();
info.textureList = mRenderCallbackTextureBindings.data();
}
// pass render callback input
- mRenderCallbackInput.size = size;
- mRenderCallbackInput.projection = projectionMatrix;
+ mRenderCallbackInput->size = size;
+ mRenderCallbackInput->projection = projectionMatrix;
- MatrixUtils::Multiply(mRenderCallbackInput.mvp, modelViewMatrix, projectionMatrix);
+ MatrixUtils::MultiplyProjectionMatrix(mRenderCallbackInput->mvp, modelViewMatrix, projectionMatrix);
// submit draw
commandBuffer.DrawNative(&info);
BindTextures(commandBuffer, boundTextures);
- int nodeIndex = BuildUniformIndexMap(bufferIndex, node, size, *program);
+ std::size_t nodeIndex = BuildUniformIndexMap(bufferIndex, node, size, *program);
WriteUniformBuffer(bufferIndex, commandBuffer, program, instruction, node, modelMatrix, modelViewMatrix, viewMatrix, projectionMatrix, size, nodeIndex);
bool drawn = false; // Draw can fail if there are no vertex buffers or they haven't been uploaded yet
// @todo We should detect this case much earlier to prevent unnecessary work
- if(mDrawCommands.empty())
+ // Reuse latest bound vertex attributes location, or Bind buffers to attribute locations.
+ if(ReuseLatestBoundVertexAttributes(mGeometry) || mGeometry->BindVertexAttributes(commandBuffer))
{
- drawn = mGeometry->Draw(*mGraphicsController, commandBuffer, mIndexedDrawFirstElement, mIndexedDrawElementsCount);
+ if(mDrawCommands.empty())
+ {
+ drawn = mGeometry->Draw(*mGraphicsController, commandBuffer, mIndexedDrawFirstElement, mIndexedDrawElementsCount);
+ }
+ else
+ {
+ for(auto& cmd : commands)
+ {
+ drawn |= mGeometry->Draw(*mGraphicsController, commandBuffer, cmd->firstIndex, cmd->elementCount);
+ }
+ }
}
else
{
- for(auto& cmd : commands)
- {
- mGeometry->Draw(*mGraphicsController, commandBuffer, cmd->firstIndex, cmd->elementCount);
- }
+ // BindVertexAttributes failed. Reset cached geometry.
+ ReuseLatestBoundVertexAttributes(nullptr);
}
- mUpdated = false;
return drawn;
}
-int Renderer::BuildUniformIndexMap(BufferIndex bufferIndex, const SceneGraph::NodeDataProvider& node, const Vector3& size, Program& program)
+std::size_t Renderer::BuildUniformIndexMap(BufferIndex bufferIndex, const SceneGraph::NodeDataProvider& node, const Vector3& size, Program& program)
{
// Check if the map has changed
DALI_ASSERT_DEBUG(mRenderDataProvider && "No Uniform map data provider available");
auto iter = std::find_if(mNodeIndexMap.begin(), mNodeIndexMap.end(), [nodePtr](RenderItemLookup& element) { return element.node == nodePtr; });
- int renderItemMapIndex;
+ std::size_t renderItemMapIndex;
if(iter == mNodeIndexMap.end())
{
renderItemMapIndex = mUniformIndexMaps.size();
const Matrix& viewMatrix,
const Matrix& projectionMatrix,
const Vector3& size,
- int nodeIndex)
+ std::size_t nodeIndex)
{
// Create the UBO
uint32_t uboOffset{0u};
if(mvpUniformInfo && !mvpUniformInfo->name.empty())
{
Matrix modelViewProjectionMatrix(false);
- MatrixUtils::Multiply(modelViewProjectionMatrix, modelViewMatrix, projectionMatrix);
+ MatrixUtils::MultiplyProjectionMatrix(modelViewProjectionMatrix, modelViewMatrix, projectionMatrix);
WriteDefaultUniform(mvpUniformInfo, *uboView, modelViewProjectionMatrix);
}
std::vector<Graphics::UniformBufferBinding>*& outBindings,
uint32_t& offset,
BufferIndex updateBufferIndex,
- int nodeIndex)
+ std::size_t nodeIndex)
{
auto& reflection = mGraphicsController->GetProgramReflection(program.GetGraphicsProgram());
auto uboCount = reflection.GetUniformBlockCount();
mShaderChanged = value;
}
-bool Renderer::Updated(BufferIndex bufferIndex, const SceneGraph::NodeDataProvider* node)
+bool Renderer::Updated(BufferIndex bufferIndex)
{
- if(mUpdated)
- {
- mUpdated = false;
- return true;
- }
-
- if(mRenderCallback || mShaderChanged || mGeometry->AttributesChanged())
+ if(mRenderCallback || mShaderChanged || mGeometry->AttributesChanged() || mRenderDataProvider->IsUpdated())
{
return true;
}
for(auto iter = textures->Begin(), end = textures->End(); iter < end; ++iter)
{
auto texture = *iter;
- if(texture && texture->IsNativeImage())
+ if(texture && texture->Updated())
{
return true;
}
}
}
-
- // Hash the property values. If the values are different, then rendering is required.
- uint64_t hash = 0xc70f6907UL;
- const SceneGraph::UniformMap& uniformMapNode = node->GetNodeUniformMap();
- for(uint32_t i = 0u, count = uniformMapNode.Count(); i < count; ++i)
- {
- hash = uniformMapNode[i].propertyPtr->Hash(bufferIndex, hash);
- }
-
- const SceneGraph::UniformMapDataProvider& uniformMapDataProvider = mRenderDataProvider->GetUniformMapDataProvider();
- const SceneGraph::CollectedUniformMap& collectedUniformMap = uniformMapDataProvider.GetCollectedUniformMap();
- for(uint32_t i = 0u, count = collectedUniformMap.Count(); i < count; ++i)
- {
- hash = collectedUniformMap.mUniformMap[i].propertyPtr->Hash(bufferIndex, hash);
- }
-
- if(mUniformsHash != hash)
- {
- mUniformsHash = hash;
- return true;
- }
-
return false;
}
+Vector4 Renderer::GetVisualTransformedUpdateArea(BufferIndex bufferIndex, const Vector4& originalUpdateArea) const noexcept
+{
+ return mRenderDataProvider->GetVisualTransformedUpdateArea(bufferIndex, originalUpdateArea);
+}
+
Graphics::Pipeline& Renderer::PrepareGraphicsPipeline(
Program& program,
const Dali::Internal::SceneGraph::RenderInstruction& instruction,
const SceneGraph::NodeDataProvider& node,
bool blend)
{
- if(mGeometry->AttributesChanged())
- {
- mUpdated = true;
- }
-
// Prepare query info
PipelineCacheQueryInfo queryInfo{};
queryInfo.program = &program;
queryInfo.alphaPremultiplied = mPremultipliedAlphaEnabled;
queryInfo.cameraUsingReflection = instruction.GetCamera()->GetReflectionUsed();
+ queryInfo.GenerateHash();
+
+ // Find or generate new pipeline.
auto pipelineResult = mPipelineCache->GetPipeline(queryInfo, true);
// should be never null?