#include <dali/graphics-api/graphics-types.h>
#include <dali/integration-api/debug.h>
#include <dali/internal/common/image-sampler.h>
+#include <dali/internal/common/matrix-utils.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>
#include <dali/internal/render/data-providers/uniform-map-data-provider.h>
mRenderDataProvider(dataProvider),
mGeometry(geometry),
mProgramCache(nullptr),
- mUniformIndexMap(),
- mUniformsHash(),
mStencilParameters(stencilParameters),
mBlendingOptions(),
mIndexedDrawFirstElement(0),
mDepthWriteMode(depthWriteMode),
mDepthTestMode(depthTestMode),
mPremultipliedAlphaEnabled(preMultipliedAlphaEnabled),
- mShaderChanged(false),
- mUpdated(true)
+ mShaderChanged(false)
{
if(blendingBitmask != 0u)
{
void Renderer::SetGeometry(Render::Geometry* geometry)
{
mGeometry = geometry;
- mUpdated = true;
}
void Renderer::SetDrawCommands(Dali::DevelRenderer::DrawCommand* pDrawCommands, uint32_t size)
{
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.reserved = nullptr;
+ info.userData = mRenderCallbackInput.get();
+
+ // Set storage for the context to be used
+ info.glesNativeInfo.eglSharedContextStoragePointer = &mRenderCallbackInput->eglContext;
+ info.reserved = nullptr;
+
+ auto& textureResources = mRenderCallback->GetTextureResources();
+
+ if(!textureResources.empty())
+ {
+ mRenderCallbackTextureBindings.clear();
+ mRenderCallbackInput->textureBindings.resize(textureResources.size());
+ auto i = 0u;
+ for(auto& texture : textureResources)
+ {
+ auto& textureImpl = GetImplementation(texture);
+ auto graphicsTexture = textureImpl.GetRenderObject()->GetGraphicsObject();
+
+ auto properties = mGraphicsController->GetTextureProperties(*graphicsTexture);
+
+ mRenderCallbackTextureBindings.emplace_back(graphicsTexture);
+ mRenderCallbackInput->textureBindings[i++] = properties.nativeHandle;
+ }
+ info.textureCount = mRenderCallbackTextureBindings.size();
+ info.textureList = mRenderCallbackTextureBindings.data();
+ }
// pass render callback input
- mRenderCallbackInput.size = size;
- mRenderCallbackInput.projection = projectionMatrix;
- Matrix::Multiply(mRenderCallbackInput.mvp, modelViewMatrix, projectionMatrix);
+ mRenderCallbackInput->size = size;
+ mRenderCallbackInput->projection = projectionMatrix;
+
+ MatrixUtils::Multiply(mRenderCallbackInput->mvp, modelViewMatrix, projectionMatrix);
// submit draw
commandBuffer.DrawNative(&info);
BindTextures(commandBuffer, boundTextures);
- 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);
+ 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
}
}
- mUpdated = false;
return drawn;
}
-void 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");
const SceneGraph::UniformMapDataProvider& uniformMapDataProvider = mRenderDataProvider->GetUniformMapDataProvider();
+ const SceneGraph::CollectedUniformMap& uniformMap = uniformMapDataProvider.GetCollectedUniformMap();
+ const SceneGraph::UniformMap& uniformMapNode = node.GetNodeUniformMap();
- if(uniformMapDataProvider.GetUniformMapChanged(bufferIndex) ||
- node.GetUniformMapChanged(bufferIndex) ||
- mUniformIndexMap.Count() == 0 ||
- mShaderChanged)
+ bool updateMaps;
+
+ // Usual case is to only have 1 node, however we do allow multiple nodes to reuse the same
+ // renderer, so we have to cache uniform map per render item (node / renderer pair).
+
+ // Specially, if node don't have uniformMap, we mark nodePtr as nullptr.
+ // So, all nodes without uniformMap will share same UniformIndexMap, contains only render data providers.
+ const auto nodePtr = uniformMapNode.Count() ? &node : nullptr;
+
+ const auto nodeChangeCounter = nodePtr ? uniformMapNode.GetChangeCounter() : 0;
+ const auto renderItemMapChangeCounter = uniformMap.GetChangeCounter();
+
+ auto iter = std::find_if(mNodeIndexMap.begin(), mNodeIndexMap.end(), [nodePtr](RenderItemLookup& element) { return element.node == nodePtr; });
+
+ std::size_t renderItemMapIndex;
+ if(iter == mNodeIndexMap.end())
+ {
+ renderItemMapIndex = mUniformIndexMaps.size();
+ RenderItemLookup renderItemLookup;
+ renderItemLookup.node = nodePtr;
+ renderItemLookup.index = renderItemMapIndex;
+ renderItemLookup.nodeChangeCounter = nodeChangeCounter;
+ renderItemLookup.renderItemMapChangeCounter = renderItemMapChangeCounter;
+ mNodeIndexMap.emplace_back(renderItemLookup);
+
+ updateMaps = true;
+ mUniformIndexMaps.resize(mUniformIndexMaps.size() + 1);
+ }
+ else
+ {
+ renderItemMapIndex = iter->index;
+
+ updateMaps = (nodeChangeCounter != iter->nodeChangeCounter) ||
+ (renderItemMapChangeCounter != iter->renderItemMapChangeCounter) ||
+ (mUniformIndexMaps[renderItemMapIndex].size() == 0);
+
+ iter->nodeChangeCounter = nodeChangeCounter;
+ iter->renderItemMapChangeCounter = renderItemMapChangeCounter;
+ }
+
+ if(updateMaps || mShaderChanged)
{
// Reset shader pointer
mShaderChanged = false;
- const SceneGraph::CollectedUniformMap& uniformMap = uniformMapDataProvider.GetUniformMap(bufferIndex);
- const SceneGraph::CollectedUniformMap& uniformMapNode = node.GetUniformMap(bufferIndex);
+ const uint32_t mapCount = uniformMap.Count();
+ const uint32_t mapNodeCount = uniformMapNode.Count();
- auto maxMaps = static_cast<uint32_t>(uniformMap.Count() + uniformMapNode.Count()); // 4,294,967,295 maps should be enough
- mUniformIndexMap.Clear(); // Clear contents, but keep memory if we don't change size
- mUniformIndexMap.Resize(maxMaps);
+ mUniformIndexMaps[renderItemMapIndex].clear(); // Clear contents, but keep memory if we don't change size
+ mUniformIndexMaps[renderItemMapIndex].resize(mapCount + mapNodeCount);
// Copy uniform map into mUniformIndexMap
uint32_t mapIndex = 0;
- for(; mapIndex < uniformMap.Count(); ++mapIndex)
+ for(; mapIndex < mapCount; ++mapIndex)
{
- mUniformIndexMap[mapIndex].propertyValue = uniformMap[mapIndex].propertyPtr;
- mUniformIndexMap[mapIndex].uniformName = uniformMap[mapIndex].uniformName;
- mUniformIndexMap[mapIndex].uniformNameHash = uniformMap[mapIndex].uniformNameHash;
- mUniformIndexMap[mapIndex].uniformNameHashNoArray = uniformMap[mapIndex].uniformNameHashNoArray;
- mUniformIndexMap[mapIndex].arrayIndex = uniformMap[mapIndex].arrayIndex;
+ mUniformIndexMaps[renderItemMapIndex][mapIndex].propertyValue = uniformMap.mUniformMap[mapIndex].propertyPtr;
+ mUniformIndexMaps[renderItemMapIndex][mapIndex].uniformName = uniformMap.mUniformMap[mapIndex].uniformName;
+ mUniformIndexMaps[renderItemMapIndex][mapIndex].uniformNameHash = uniformMap.mUniformMap[mapIndex].uniformNameHash;
+ mUniformIndexMaps[renderItemMapIndex][mapIndex].uniformNameHashNoArray = uniformMap.mUniformMap[mapIndex].uniformNameHashNoArray;
+ mUniformIndexMaps[renderItemMapIndex][mapIndex].arrayIndex = uniformMap.mUniformMap[mapIndex].arrayIndex;
}
- for(uint32_t nodeMapIndex = 0; nodeMapIndex < uniformMapNode.Count(); ++nodeMapIndex)
+ for(uint32_t nodeMapIndex = 0; nodeMapIndex < mapNodeCount; ++nodeMapIndex)
{
auto hash = uniformMapNode[nodeMapIndex].uniformNameHash;
auto& name = uniformMapNode[nodeMapIndex].uniformName;
bool found(false);
- for(uint32_t i = 0; i < uniformMap.Count(); ++i)
+ for(uint32_t i = 0; i < mapCount; ++i)
{
- if(mUniformIndexMap[i].uniformNameHash == hash &&
- mUniformIndexMap[i].uniformName == name)
+ if(mUniformIndexMaps[renderItemMapIndex][i].uniformNameHash == hash &&
+ mUniformIndexMaps[renderItemMapIndex][i].uniformName == name)
{
- mUniformIndexMap[i].propertyValue = uniformMapNode[nodeMapIndex].propertyPtr;
- found = true;
+ mUniformIndexMaps[renderItemMapIndex][i].propertyValue = uniformMapNode[nodeMapIndex].propertyPtr;
+ found = true;
break;
}
}
if(!found)
{
- mUniformIndexMap[mapIndex].propertyValue = uniformMapNode[nodeMapIndex].propertyPtr;
- mUniformIndexMap[mapIndex].uniformName = uniformMapNode[nodeMapIndex].uniformName;
- mUniformIndexMap[mapIndex].uniformNameHash = uniformMapNode[nodeMapIndex].uniformNameHash;
- mUniformIndexMap[mapIndex].uniformNameHashNoArray = uniformMapNode[nodeMapIndex].uniformNameHashNoArray;
- mUniformIndexMap[mapIndex].arrayIndex = uniformMapNode[nodeMapIndex].arrayIndex;
+ mUniformIndexMaps[renderItemMapIndex][mapIndex].propertyValue = uniformMapNode[nodeMapIndex].propertyPtr;
+ mUniformIndexMaps[renderItemMapIndex][mapIndex].uniformName = uniformMapNode[nodeMapIndex].uniformName;
+ mUniformIndexMaps[renderItemMapIndex][mapIndex].uniformNameHash = uniformMapNode[nodeMapIndex].uniformNameHash;
+ mUniformIndexMaps[renderItemMapIndex][mapIndex].uniformNameHashNoArray = uniformMapNode[nodeMapIndex].uniformNameHashNoArray;
+ mUniformIndexMaps[renderItemMapIndex][mapIndex].arrayIndex = uniformMapNode[nodeMapIndex].arrayIndex;
++mapIndex;
}
}
- mUniformIndexMap.Resize(mapIndex);
+ mUniformIndexMaps[renderItemMapIndex].resize(mapIndex);
}
+ return renderItemMapIndex;
}
void Renderer::WriteUniformBuffer(
const Matrix& modelViewMatrix,
const Matrix& viewMatrix,
const Matrix& projectionMatrix,
- const Vector3& size)
+ const Vector3& size,
+ std::size_t nodeIndex)
{
// Create the UBO
uint32_t uboOffset{0u};
if(uniformBlockAllocationBytes)
{
auto uboPoolView = mUniformBufferManager->GetUniformBufferViewPool(bufferIndex);
-
- uboView = uboPoolView->CreateUniformBufferView(uniformBlockAllocationBytes);
+ uboView = uboPoolView->CreateUniformBufferView(uniformBlockAllocationBytes);
}
// update the uniform buffer
if(mvpUniformInfo && !mvpUniformInfo->name.empty())
{
Matrix modelViewProjectionMatrix(false);
- Matrix::Multiply(modelViewProjectionMatrix, modelViewMatrix, projectionMatrix);
+ MatrixUtils::Multiply(modelViewProjectionMatrix, modelViewMatrix, projectionMatrix);
WriteDefaultUniform(mvpUniformInfo, *uboView, modelViewProjectionMatrix);
}
WriteDefaultUniform(program->GetDefaultUniform(Program::DefaultUniformIndex::ACTOR_COLOR), *uboView, color);
// Write uniforms from the uniform map
- FillUniformBuffer(*program, instruction, *uboView, bindings, uboOffset, bufferIndex);
+ FillUniformBuffer(*program, instruction, *uboView, bindings, uboOffset, bufferIndex, nodeIndex);
// Write uSize in the end, as it shouldn't be overridable by dynamic properties.
WriteDefaultUniform(program->GetDefaultUniform(Program::DefaultUniformIndex::SIZE), *uboView, size);
Render::UniformBufferView& ubo,
std::vector<Graphics::UniformBufferBinding>*& outBindings,
uint32_t& offset,
- BufferIndex updateBufferIndex)
+ BufferIndex updateBufferIndex,
+ std::size_t nodeIndex)
{
auto& reflection = mGraphicsController->GetProgramReflection(program.GetGraphicsProgram());
auto uboCount = reflection.GetUniformBlockCount();
dataOffset += GetUniformBufferDataAlignment(mUniformBufferBindings[i].dataSize);
mUniformBufferBindings[i].buffer = ubo.GetBuffer(&mUniformBufferBindings[i].offset);
- for(UniformIndexMappings::Iterator iter = mUniformIndexMap.Begin(),
- end = mUniformIndexMap.End();
+ for(auto iter = mUniformIndexMaps[nodeIndex].begin(),
+ end = mUniformIndexMaps[nodeIndex].end();
iter != end;
++iter)
{
if(!uniform.uniformFunc)
{
auto uniformInfo = Graphics::UniformInfo{};
- auto uniformFound = program.GetUniform(uniform.uniformName.GetCString(),
+ auto uniformFound = program.GetUniform(uniform.uniformName.GetStringView(),
uniform.uniformNameHash,
uniform.uniformNameHashNoArray,
uniformInfo);
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;
}
}
}
-
- uint64_t hash = 0xc70f6907UL;
- const SceneGraph::CollectedUniformMap& uniformMapNode = node->GetUniformMap(bufferIndex);
- for(const auto& uniformProperty : uniformMapNode)
- {
- hash = uniformProperty.propertyPtr->Hash(bufferIndex, hash);
- }
-
- const SceneGraph::UniformMapDataProvider& uniformMapDataProvider = mRenderDataProvider->GetUniformMapDataProvider();
- const SceneGraph::CollectedUniformMap& uniformMap = uniformMapDataProvider.GetUniformMap(bufferIndex);
- for(const auto& uniformProperty : uniformMap)
- {
- hash = uniformProperty.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;