X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Frender%2Frenderers%2Frender-renderer.cpp;h=db30a4e68f067561bd53050b24788d1d432fe968;hb=aa03392fb87007c43c0fd38daf67d43ed93126c0;hp=27b19ed29cce0280c63228f0ddf1b5daf2090fb7;hpb=6a91dd6ff74bf92bc1c9fcc69d1137ef468811d6;p=platform%2Fcore%2Fuifw%2Fdali-core.git diff --git a/dali/internal/render/renderers/render-renderer.cpp b/dali/internal/render/renderers/render-renderer.cpp index 27b19ed..db30a4e 100644 --- a/dali/internal/render/renderers/render-renderer.cpp +++ b/dali/internal/render/renderers/render-renderer.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021 Samsung Electronics Co., Ltd. + * Copyright (c) 2022 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. @@ -22,9 +22,12 @@ #include #include #include +#include +#include #include #include #include +#include #include #include #include @@ -34,162 +37,102 @@ #include #include #include +#include namespace Dali::Internal { namespace { -// Helper to get the vertex input format -Dali::Graphics::VertexInputFormat GetPropertyVertexFormat(Property::Type propertyType) +// Helper to get the property value getter by type +typedef const float& (PropertyInputImpl::*FuncGetter)(BufferIndex) const; +constexpr FuncGetter GetPropertyValueGetter(Property::Type type) { - Dali::Graphics::VertexInputFormat type{}; - - switch(propertyType) + switch(type) { - case Property::NONE: - case Property::STRING: - case Property::ARRAY: - case Property::MAP: - case Property::EXTENTS: // i4? - case Property::RECTANGLE: // i4/f4? - case Property::ROTATION: - { - type = Dali::Graphics::VertexInputFormat::UNDEFINED; - break; - } case Property::BOOLEAN: { - type = Dali::Graphics::VertexInputFormat::UNDEFINED; // type = GL_BYTE; @todo new type for this? - break; + return FuncGetter(&PropertyInputImpl::GetBoolean); } case Property::INTEGER: { - type = Dali::Graphics::VertexInputFormat::INTEGER; // (short) - break; + return FuncGetter(&PropertyInputImpl::GetInteger); } case Property::FLOAT: { - type = Dali::Graphics::VertexInputFormat::FLOAT; - break; + return FuncGetter(&PropertyInputImpl::GetFloat); } case Property::VECTOR2: { - type = Dali::Graphics::VertexInputFormat::FVECTOR2; - break; + return FuncGetter(&PropertyInputImpl::GetVector2); } case Property::VECTOR3: { - type = Dali::Graphics::VertexInputFormat::FVECTOR3; - break; + return FuncGetter(&PropertyInputImpl::GetVector3); } case Property::VECTOR4: { - type = Dali::Graphics::VertexInputFormat::FVECTOR4; - break; + return FuncGetter(&PropertyInputImpl::GetVector4); } case Property::MATRIX3: + { + return FuncGetter(&PropertyInputImpl::GetMatrix3); + } case Property::MATRIX: { - type = Dali::Graphics::VertexInputFormat::FLOAT; - break; + return FuncGetter(&PropertyInputImpl::GetMatrix); + } + default: + { + return nullptr; } } - - return type; } -constexpr Graphics::CullMode ConvertCullFace(Dali::FaceCullingMode::Type mode) +/** + * Helper function that returns size of uniform datatypes based + * on property type. + */ +constexpr int GetPropertyValueSizeForUniform(Property::Type type) { - switch(mode) + switch(type) { - case Dali::FaceCullingMode::NONE: + case Property::Type::BOOLEAN: { - return Graphics::CullMode::NONE; + return sizeof(bool); } - case Dali::FaceCullingMode::FRONT: + case Property::Type::FLOAT: { - return Graphics::CullMode::FRONT; + return sizeof(float); } - case Dali::FaceCullingMode::BACK: + case Property::Type::INTEGER: { - return Graphics::CullMode::BACK; + return sizeof(int); } - case Dali::FaceCullingMode::FRONT_AND_BACK: + case Property::Type::VECTOR2: { - return Graphics::CullMode::FRONT_AND_BACK; + return sizeof(Vector2); } - } - return Graphics::CullMode::NONE; -} - -constexpr Graphics::BlendFactor ConvertBlendFactor(BlendFactor::Type blendFactor) -{ - switch(blendFactor) - { - case BlendFactor::ZERO: - return Graphics::BlendFactor::ZERO; - case BlendFactor::ONE: - return Graphics::BlendFactor::ONE; - case BlendFactor::SRC_COLOR: - return Graphics::BlendFactor::SRC_COLOR; - case BlendFactor::ONE_MINUS_SRC_COLOR: - return Graphics::BlendFactor::ONE_MINUS_SRC_COLOR; - case BlendFactor::SRC_ALPHA: - return Graphics::BlendFactor::SRC_ALPHA; - case BlendFactor::ONE_MINUS_SRC_ALPHA: - return Graphics::BlendFactor::ONE_MINUS_SRC_ALPHA; - case BlendFactor::DST_ALPHA: - return Graphics::BlendFactor::DST_ALPHA; - case BlendFactor::ONE_MINUS_DST_ALPHA: - return Graphics::BlendFactor::ONE_MINUS_DST_ALPHA; - case BlendFactor::DST_COLOR: - return Graphics::BlendFactor::DST_COLOR; - case BlendFactor::ONE_MINUS_DST_COLOR: - return Graphics::BlendFactor::ONE_MINUS_DST_COLOR; - case BlendFactor::SRC_ALPHA_SATURATE: - return Graphics::BlendFactor::SRC_ALPHA_SATURATE; - case BlendFactor::CONSTANT_COLOR: - return Graphics::BlendFactor::CONSTANT_COLOR; - case BlendFactor::ONE_MINUS_CONSTANT_COLOR: - return Graphics::BlendFactor::ONE_MINUS_CONSTANT_COLOR; - case BlendFactor::CONSTANT_ALPHA: - return Graphics::BlendFactor::CONSTANT_ALPHA; - case BlendFactor::ONE_MINUS_CONSTANT_ALPHA: - return Graphics::BlendFactor::ONE_MINUS_CONSTANT_ALPHA; - } - return Graphics::BlendFactor{}; -} - -constexpr Graphics::BlendOp ConvertBlendEquation(DevelBlendEquation::Type blendEquation) -{ - switch(blendEquation) - { - case DevelBlendEquation::ADD: - return Graphics::BlendOp::ADD; - case DevelBlendEquation::SUBTRACT: - return Graphics::BlendOp::SUBTRACT; - case DevelBlendEquation::REVERSE_SUBTRACT: - return Graphics::BlendOp::REVERSE_SUBTRACT; - case DevelBlendEquation::COLOR: - case DevelBlendEquation::COLOR_BURN: - case DevelBlendEquation::COLOR_DODGE: - case DevelBlendEquation::DARKEN: - case DevelBlendEquation::DIFFERENCE: - case DevelBlendEquation::EXCLUSION: - case DevelBlendEquation::HARD_LIGHT: - case DevelBlendEquation::HUE: - case DevelBlendEquation::LIGHTEN: - case DevelBlendEquation::LUMINOSITY: - case DevelBlendEquation::MAX: - case DevelBlendEquation::MIN: - case DevelBlendEquation::MULTIPLY: - case DevelBlendEquation::OVERLAY: - case DevelBlendEquation::SATURATION: - case DevelBlendEquation::SCREEN: - case DevelBlendEquation::SOFT_LIGHT: - return Graphics::BlendOp{}; - } - return Graphics::BlendOp{}; + case Property::Type::VECTOR3: + { + return sizeof(Vector3); + } + case Property::Type::VECTOR4: + { + return sizeof(Vector4); + } + case Property::Type::MATRIX3: + { + return sizeof(Matrix3); + } + case Property::Type::MATRIX: + { + return sizeof(Matrix); + } + default: + { + return 0; + } + }; } /** @@ -234,9 +177,6 @@ Renderer::Renderer(SceneGraph::RenderDataProvider* dataProvider, mRenderDataProvider(dataProvider), mGeometry(geometry), mProgramCache(nullptr), - mUniformIndexMap(), - mAttributeLocations(), - mUniformsHash(), mStencilParameters(stencilParameters), mBlendingOptions(), mIndexedDrawFirstElement(0), @@ -245,10 +185,8 @@ Renderer::Renderer(SceneGraph::RenderDataProvider* dataProvider, mFaceCullingMode(faceCullingMode), mDepthWriteMode(depthWriteMode), mDepthTestMode(depthTestMode), - mUpdateAttributeLocations(true), mPremultipliedAlphaEnabled(preMultipliedAlphaEnabled), - mShaderChanged(false), - mUpdated(true) + mShaderChanged(false) { if(blendingBitmask != 0u) { @@ -258,20 +196,20 @@ Renderer::Renderer(SceneGraph::RenderDataProvider* dataProvider, mBlendingOptions.SetBlendColor(blendColor); } -void Renderer::Initialize(Graphics::Controller& graphicsController, ProgramCache& programCache, Render::ShaderCache& shaderCache, Render::UniformBufferManager& uniformBufferManager) +void Renderer::Initialize(Graphics::Controller& graphicsController, ProgramCache& programCache, Render::ShaderCache& shaderCache, Render::UniformBufferManager& uniformBufferManager, Render::PipelineCache& pipelineCache) { mGraphicsController = &graphicsController; mProgramCache = &programCache; mShaderCache = &shaderCache; mUniformBufferManager = &uniformBufferManager; + mPipelineCache = &pipelineCache; } Renderer::~Renderer() = default; void Renderer::SetGeometry(Render::Geometry* geometry) { - mGeometry = geometry; - mUpdateAttributeLocations = true; + mGeometry = geometry; } void Renderer::SetDrawCommands(Dali::DevelRenderer::DrawCommand* pDrawCommands, uint32_t size) { @@ -283,26 +221,35 @@ void Renderer::BindTextures(Graphics::CommandBuffer& commandBuffer, Vector& samplers(mRenderDataProvider->GetSamplers()); - std::vector& textures(mRenderDataProvider->GetTextures()); + const Dali::Vector* textures(mRenderDataProvider->GetTextures()); + const Dali::Vector* samplers(mRenderDataProvider->GetSamplers()); std::vector textureBindings; - for(uint32_t i = 0; i < static_cast(textures.size()); ++i) // not expecting more than uint32_t of textures + + if(textures != nullptr) { - if(textures[i] && textures[i]->GetGraphicsObject()) + const std::uint32_t texturesCount(static_cast(textures->Count())); + textureBindings.reserve(texturesCount); + + for(uint32_t i = 0; i < texturesCount; ++i) // not expecting more than uint32_t of textures { - // if the sampler exists, - // if it's default, delete the graphics object - // otherwise re-initialize it if dirty + if((*textures)[i] && (*textures)[i]->GetGraphicsObject()) + { + Graphics::Texture* graphicsTexture = (*textures)[i]->GetGraphicsObject(); + // if the sampler exists, + // if it's default, delete the graphics object + // otherwise re-initialize it if dirty - const Graphics::Sampler* graphicsSampler = (samplers[i] ? samplers[i]->GetGraphicsObject() - : nullptr); + const Graphics::Sampler* graphicsSampler = samplers ? ((*samplers)[i] ? (*samplers)[i]->GetGraphicsObject() + : nullptr) + : nullptr; - boundTextures.PushBack(textures[i]->GetGraphicsObject()); - const Graphics::TextureBinding textureBinding{textures[i]->GetGraphicsObject(), graphicsSampler, textureUnit}; - textureBindings.push_back(textureBinding); + boundTextures.PushBack(graphicsTexture); + const Graphics::TextureBinding textureBinding{graphicsTexture, graphicsSampler, textureUnit}; + textureBindings.push_back(textureBinding); - ++textureUnit; + ++textureUnit; + } } } @@ -315,49 +262,41 @@ void Renderer::BindTextures(Graphics::CommandBuffer& commandBuffer, Vector(new RenderCallbackInput); + } + + Graphics::DrawNativeInfo info{}; + info.api = Graphics::DrawNativeAPI::GLES; + info.callback = &static_cast(*mRenderCallback); + 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; + + MatrixUtils::Multiply(mRenderCallbackInput->mvp, modelViewMatrix, projectionMatrix); + + // submit draw + commandBuffer.DrawNative(&info); + return true; + } + // Prepare commands std::vector commands; for(auto& cmd : mDrawCommands) @@ -516,42 +495,46 @@ bool Renderer::Render(Graphics::CommandBuffer& comma } // Create Program - ShaderDataPtr shaderData = mRenderDataProvider->GetShader().GetShaderData(); - const std::vector& vertShader = shaderData->GetShaderForPipelineStage(Graphics::PipelineStage::VERTEX_SHADER); - const std::vector& fragShader = shaderData->GetShaderForPipelineStage(Graphics::PipelineStage::FRAGMENT_SHADER); - Dali::Graphics::Shader& vertexShader = mShaderCache->GetShader( - vertShader, - Graphics::PipelineStage::VERTEX_SHADER, - shaderData->GetSourceMode()); - - Dali::Graphics::Shader& fragmentShader = mShaderCache->GetShader( - fragShader, - Graphics::PipelineStage::FRAGMENT_SHADER, - shaderData->GetSourceMode()); - - std::vector shaderStates{ - Graphics::ShaderState() - .SetShader(vertexShader) - .SetPipelineStage(Graphics::PipelineStage::VERTEX_SHADER), - Graphics::ShaderState() - .SetShader(fragmentShader) - .SetPipelineStage(Graphics::PipelineStage::FRAGMENT_SHADER)}; - - auto createInfo = Graphics::ProgramCreateInfo(); - createInfo.SetShaderState(shaderStates); - - auto graphicsProgram = mGraphicsController->CreateProgram(createInfo, nullptr); - Program* program = Program::New(*mProgramCache, - shaderData, - *mGraphicsController, - std::move(graphicsProgram)); + ShaderDataPtr shaderData = mRenderDataProvider->GetShader().GetShaderData(); + Program* program = Program::New(*mProgramCache, + shaderData, + *mGraphicsController); if(!program) { - DALI_LOG_ERROR("Failed to get program for shader at address %p.\n", reinterpret_cast(&mRenderDataProvider->GetShader())); + DALI_LOG_ERROR("Failed to get program for shader at address %p.\n", reinterpret_cast(&mRenderDataProvider->GetShader())); return false; } + // If program doesn't have Gfx program object assigned yet, prepare it. + if(!program->GetGraphicsProgramPtr()) + { + const std::vector& vertShader = shaderData->GetShaderForPipelineStage(Graphics::PipelineStage::VERTEX_SHADER); + const std::vector& fragShader = shaderData->GetShaderForPipelineStage(Graphics::PipelineStage::FRAGMENT_SHADER); + Dali::Graphics::Shader& vertexShader = mShaderCache->GetShader( + vertShader, + Graphics::PipelineStage::VERTEX_SHADER, + shaderData->GetSourceMode()); + + Dali::Graphics::Shader& fragmentShader = mShaderCache->GetShader( + fragShader, + Graphics::PipelineStage::FRAGMENT_SHADER, + shaderData->GetSourceMode()); + + std::vector shaderStates{ + Graphics::ShaderState() + .SetShader(vertexShader) + .SetPipelineStage(Graphics::PipelineStage::VERTEX_SHADER), + Graphics::ShaderState() + .SetShader(fragmentShader) + .SetPipelineStage(Graphics::PipelineStage::FRAGMENT_SHADER)}; + + auto createInfo = Graphics::ProgramCreateInfo(); + createInfo.SetShaderState(shaderStates); + auto graphicsProgram = mGraphicsController->CreateProgram(createInfo, nullptr); + program->SetGraphicsProgram(std::move(graphicsProgram)); + } + // Prepare the graphics pipeline. This may either re-use an existing pipeline or create a new one. auto& pipeline = PrepareGraphicsPipeline(*program, instruction, node, blend); @@ -559,9 +542,9 @@ bool Renderer::Render(Graphics::CommandBuffer& comma 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 @@ -578,76 +561,110 @@ bool Renderer::Render(Graphics::CommandBuffer& comma } } - 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->GetUniformMap(); + const SceneGraph::UniformMapDataProvider& uniformMapDataProvider = mRenderDataProvider->GetUniformMapDataProvider(); + const SceneGraph::CollectedUniformMap& uniformMap = uniformMapDataProvider.GetCollectedUniformMap(); + const SceneGraph::UniformMap& uniformMapNode = node.GetNodeUniformMap(); + + 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; - if(uniformMapDataProvider.GetUniformMapChanged(bufferIndex) || - node.GetUniformMapChanged(bufferIndex) || - mUniformIndexMap.Count() == 0 || - mShaderChanged) + 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(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); } - - // @todo Temporary workaround to reduce workload each frame. Find a better way. - auto& sceneGraphRenderer = const_cast(static_cast(uniformMapDataProvider)); - sceneGraphRenderer.AgeUniformMap(); + return renderItemMapIndex; } void Renderer::WriteUniformBuffer( @@ -660,31 +677,22 @@ 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 uniformBlockAllocationBytes{0u}; - uint32_t uniformBlockMaxSize{0u}; uint32_t uboOffset{0u}; auto& reflection = mGraphicsController->GetProgramReflection(program->GetGraphicsProgram()); - for(auto i = 0u; i < reflection.GetUniformBlockCount(); ++i) - { - auto blockSize = GetUniformBufferDataAlignment(reflection.GetUniformBlockSize(i)); - if(uniformBlockMaxSize < blockSize) - { - uniformBlockMaxSize = blockSize; - } - uniformBlockAllocationBytes += blockSize; - } + + uint32_t uniformBlockAllocationBytes = program->GetUniformBlocksMemoryRequirements().totalSizeRequired; // Create uniform buffer view from uniform buffer Graphics::UniquePtr uboView{nullptr}; if(uniformBlockAllocationBytes) { auto uboPoolView = mUniformBufferManager->GetUniformBufferViewPool(bufferIndex); - - uboView = uboPoolView->CreateUniformBufferView(uniformBlockAllocationBytes); + uboView = uboPoolView->CreateUniformBufferView(uniformBlockAllocationBytes); } // update the uniform buffer @@ -709,7 +717,7 @@ void Renderer::WriteUniformBuffer( if(mvpUniformInfo && !mvpUniformInfo->name.empty()) { Matrix modelViewProjectionMatrix(false); - Matrix::Multiply(modelViewProjectionMatrix, modelViewMatrix, projectionMatrix); + MatrixUtils::Multiply(modelViewProjectionMatrix, modelViewMatrix, projectionMatrix); WriteDefaultUniform(mvpUniformInfo, *uboView, modelViewProjectionMatrix); } @@ -722,21 +730,22 @@ void Renderer::WriteUniformBuffer( WriteDefaultUniform(normalUniformInfo, *uboView, normalMatrix); } - Vector4 finalColor; - const Vector4& color = node.GetRenderColor(bufferIndex); + Vector4 finalColor; ///< Applied renderer's opacity color + const Vector4& color = node.GetRenderColor(bufferIndex); ///< Actor's original color if(mPremultipliedAlphaEnabled) { - float alpha = color.a * mRenderDataProvider->GetOpacity(bufferIndex); - finalColor = Vector4(color.r * alpha, color.g * alpha, color.b * alpha, alpha); + const float& alpha = color.a * mRenderDataProvider->GetOpacity(bufferIndex); + finalColor = Vector4(color.r * alpha, color.g * alpha, color.b * alpha, alpha); } else { finalColor = Vector4(color.r, color.g, color.b, color.a * mRenderDataProvider->GetOpacity(bufferIndex)); } WriteDefaultUniform(program->GetDefaultUniform(Program::DefaultUniformIndex::COLOR), *uboView, finalColor); + 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); @@ -772,7 +781,8 @@ void Renderer::FillUniformBuffer(Program& p Render::UniformBufferView& ubo, std::vector*& outBindings, uint32_t& offset, - BufferIndex updateBufferIndex) + BufferIndex updateBufferIndex, + std::size_t nodeIndex) { auto& reflection = mGraphicsController->GetProgramReflection(program.GetGraphicsProgram()); auto uboCount = reflection.GetUniformBlockCount(); @@ -787,99 +797,51 @@ void Renderer::FillUniformBuffer(Program& p 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) { - // @todo This means parsing the uniform string every frame. Instead, store the array index if present. - int arrayIndex = (*iter).arrayIndex; - - auto uniformInfo = Graphics::UniformInfo{}; - auto uniformFound = program.GetUniform((*iter).uniformName.GetCString(), - (*iter).uniformNameHashNoArray ? (*iter).uniformNameHashNoArray - : (*iter).uniformNameHash, - uniformInfo); + auto& uniform = *iter; + int arrayIndex = uniform.arrayIndex; - if(uniformFound) + if(!uniform.uniformFunc) { - auto dst = ubo.GetOffset() + uniformInfo.offset; - switch((*iter).propertyValue->GetType()) + auto uniformInfo = Graphics::UniformInfo{}; + auto uniformFound = program.GetUniform(uniform.uniformName.GetStringView(), + uniform.uniformNameHash, + uniform.uniformNameHashNoArray, + uniformInfo); + + uniform.uniformOffset = uniformInfo.offset; + uniform.uniformLocation = uniformInfo.location; + + if(uniformFound) { - case Property::Type::BOOLEAN: - { - ubo.Write(&(*iter).propertyValue->GetBoolean(updateBufferIndex), - sizeof(bool), - dst + static_cast(sizeof(bool)) * arrayIndex); - break; - } - case Property::Type::INTEGER: - { - ubo.Write(&(*iter).propertyValue->GetInteger(updateBufferIndex), - sizeof(int32_t), - dst + static_cast(sizeof(int32_t)) * arrayIndex); - break; - } - case Property::Type::FLOAT: - { - ubo.Write(&(*iter).propertyValue->GetFloat(updateBufferIndex), - sizeof(float), - dst + static_cast(sizeof(float)) * arrayIndex); - break; - } - case Property::Type::VECTOR2: - { - ubo.Write(&(*iter).propertyValue->GetVector2(updateBufferIndex), - sizeof(Vector2), - dst + static_cast(sizeof(Vector2)) * arrayIndex); - break; - } - case Property::Type::VECTOR3: - { - ubo.Write(&(*iter).propertyValue->GetVector3(updateBufferIndex), - sizeof(Vector3), - dst + static_cast(sizeof(Vector3)) * arrayIndex); - break; - } - case Property::Type::VECTOR4: - { - ubo.Write(&(*iter).propertyValue->GetVector4(updateBufferIndex), - sizeof(Vector4), - dst + static_cast(sizeof(Vector4)) * arrayIndex); - break; - } - case Property::Type::MATRIX: - { - ubo.Write(&(*iter).propertyValue->GetMatrix(updateBufferIndex), - sizeof(Matrix), - dst + static_cast(sizeof(Matrix)) * arrayIndex); - break; - } - case Property::Type::MATRIX3: - { - // @todo: handle data padding properly - // Get padding requirement from Graphics - // - // Vulkan: - // - //const auto& matrix = &(*iter).propertyValue->GetMatrix3(updateBufferIndex); - //for(int i = 0; i < 3; ++i) - //{ - //ubo.Write(&matrix->AsFloat()[i * 3], - // sizeof(float) * 3, - // dst + (i * static_cast(sizeof(Vector4)))); - //} - // GL: - ubo.Write(&(*iter).propertyValue->GetMatrix3(updateBufferIndex), - sizeof(Matrix3), - dst + static_cast(sizeof(Matrix3)) * arrayIndex); - break; - } - default: - { - } + auto dst = ubo.GetOffset() + uniformInfo.offset; + const auto typeSize = GetPropertyValueSizeForUniform((*iter).propertyValue->GetType()); + const auto dest = dst + static_cast(typeSize) * arrayIndex; + const auto func = GetPropertyValueGetter((*iter).propertyValue->GetType()); + + ubo.Write(&((*iter).propertyValue->*func)(updateBufferIndex), + typeSize, + dest); + + uniform.uniformSize = typeSize; + uniform.uniformFunc = func; } } + else + { + auto dst = ubo.GetOffset() + uniform.uniformOffset; + const auto typeSize = uniform.uniformSize; + const auto dest = dst + static_cast(typeSize) * arrayIndex; + const auto func = uniform.uniformFunc; + + ubo.Write(&((*iter).propertyValue->*func)(updateBufferIndex), + typeSize, + dest); + } } } // write output bindings @@ -900,243 +862,58 @@ void Renderer::SetShaderChanged(bool value) mShaderChanged = value; } -bool Renderer::Updated(BufferIndex bufferIndex, const SceneGraph::NodeDataProvider* node) +bool Renderer::Updated(BufferIndex bufferIndex) { - if(mUpdated) + if(mRenderCallback || mShaderChanged || mGeometry->AttributesChanged() || mRenderDataProvider->IsUpdated()) { - mUpdated = false; return true; } - if(mShaderChanged || mUpdateAttributeLocations || mGeometry->AttributesChanged()) + auto* textures = mRenderDataProvider->GetTextures(); + if(textures) { - return true; - } - - for(const auto& texture : mRenderDataProvider->GetTextures()) - { - if(texture && texture->IsNativeImage()) + for(auto iter = textures->Begin(), end = textures->End(); iter < end; ++iter) { - return true; + auto texture = *iter; + 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->GetUniformMap(); - 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) { - Graphics::InputAssemblyState inputAssemblyState{}; - Graphics::VertexInputState vertexInputState{}; - Graphics::ProgramState programState{}; - uint32_t bindingIndex{0u}; - - if(mUpdateAttributeLocations || mGeometry->AttributesChanged()) - { - mAttributeLocations.Clear(); - mUpdateAttributeLocations = true; - } - - auto& reflection = mGraphicsController->GetProgramReflection(program.GetGraphicsProgram()); - - /** - * Bind Attributes - */ - uint32_t base = 0; - for(auto&& vertexBuffer : mGeometry->GetVertexBuffers()) - { - const VertexBuffer::Format& vertexFormat = *vertexBuffer->GetFormat(); - - vertexInputState.bufferBindings.emplace_back(vertexFormat.size, // stride - Graphics::VertexInputRate::PER_VERTEX); - - const uint32_t attributeCount = vertexBuffer->GetAttributeCount(); - for(uint32_t i = 0; i < attributeCount; ++i) - { - if(mUpdateAttributeLocations) - { - auto attributeName = vertexBuffer->GetAttributeName(i); - int32_t pLocation = reflection.GetVertexAttributeLocation(std::string(attributeName.GetStringView())); - if(-1 == pLocation) - { - DALI_LOG_WARNING("Attribute not found in the shader: %s\n", attributeName.GetCString()); - } - mAttributeLocations.PushBack(pLocation); - } - - auto location = static_cast(mAttributeLocations[base + i]); - - vertexInputState.attributes.emplace_back(location, - bindingIndex, - vertexFormat.components[i].offset, - GetPropertyVertexFormat(vertexFormat.components[i].type)); - } - base += attributeCount; - ++bindingIndex; - } - mUpdateAttributeLocations = false; - - // Get the topology - inputAssemblyState.SetTopology(mGeometry->GetTopology()); + // Prepare query info + PipelineCacheQueryInfo queryInfo{}; + queryInfo.program = &program; + queryInfo.renderer = this; + queryInfo.geometry = mGeometry; + queryInfo.blendingEnabled = blend; + queryInfo.blendingOptions = &mBlendingOptions; + queryInfo.alphaPremultiplied = mPremultipliedAlphaEnabled; + queryInfo.cameraUsingReflection = instruction.GetCamera()->GetReflectionUsed(); - // Get the program - programState.SetProgram(program.GetGraphicsProgram()); + auto pipelineResult = mPipelineCache->GetPipeline(queryInfo, true); - Graphics::RasterizationState rasterizationState{}; - - //Set cull face mode - const Dali::Internal::SceneGraph::Camera* cam = instruction.GetCamera(); - if(cam->GetReflectionUsed()) - { - auto adjFaceCullingMode = mFaceCullingMode; - switch(mFaceCullingMode) - { - case FaceCullingMode::Type::FRONT: - { - adjFaceCullingMode = FaceCullingMode::Type::BACK; - break; - } - case FaceCullingMode::Type::BACK: - { - adjFaceCullingMode = FaceCullingMode::Type::FRONT; - break; - } - default: - { - // nothing to do, leave culling as it is - } - } - rasterizationState.SetCullMode(ConvertCullFace(adjFaceCullingMode)); - } - else - { - rasterizationState.SetCullMode(ConvertCullFace(mFaceCullingMode)); - } - - rasterizationState.SetFrontFace(Graphics::FrontFace::COUNTER_CLOCKWISE); - - /** - * Set Polygon mode - */ - switch(mGeometry->GetTopology()) - { - case Graphics::PrimitiveTopology::TRIANGLE_LIST: - case Graphics::PrimitiveTopology::TRIANGLE_STRIP: - case Graphics::PrimitiveTopology::TRIANGLE_FAN: - rasterizationState.SetPolygonMode(Graphics::PolygonMode::FILL); - break; - case Graphics::PrimitiveTopology::LINE_LIST: - case Graphics::PrimitiveTopology::LINE_LOOP: - case Graphics::PrimitiveTopology::LINE_STRIP: - rasterizationState.SetPolygonMode(Graphics::PolygonMode::LINE); - break; - case Graphics::PrimitiveTopology::POINT_LIST: - rasterizationState.SetPolygonMode(Graphics::PolygonMode::POINT); - break; - } - - // @todo Add blend barrier to the Graphics API if we are using advanced - // blending options. Command? - - Graphics::ColorBlendState colorBlendState{}; - colorBlendState.SetBlendEnable(false); - - if(blend) - { - colorBlendState.SetBlendEnable(true); - - Graphics::BlendOp rgbOp = ConvertBlendEquation(mBlendingOptions.GetBlendEquationRgb()); - Graphics::BlendOp alphaOp = ConvertBlendEquation(mBlendingOptions.GetBlendEquationRgb()); - if(mBlendingOptions.IsAdvancedBlendEquationApplied() && mPremultipliedAlphaEnabled) - { - if(rgbOp != alphaOp) - { - DALI_LOG_ERROR("Advanced Blend Equation MUST be applied by using BlendEquation.\n"); - alphaOp = rgbOp; - } - } - - colorBlendState - .SetSrcColorBlendFactor(ConvertBlendFactor(mBlendingOptions.GetBlendSrcFactorRgb())) - .SetSrcAlphaBlendFactor(ConvertBlendFactor(mBlendingOptions.GetBlendSrcFactorAlpha())) - .SetDstColorBlendFactor(ConvertBlendFactor(mBlendingOptions.GetBlendDestFactorRgb())) - .SetDstAlphaBlendFactor(ConvertBlendFactor(mBlendingOptions.GetBlendDestFactorAlpha())) - .SetColorBlendOp(rgbOp) - .SetAlphaBlendOp(alphaOp); - - // Blend color is optional and rarely used - auto* blendColor = const_cast(mBlendingOptions.GetBlendColor()); - if(blendColor) - { - colorBlendState.SetBlendConstants(blendColor->AsFloat()); - } - } - - mUpdated = true; - - // Create the pipeline - Graphics::PipelineCreateInfo createInfo; - createInfo - .SetInputAssemblyState(&inputAssemblyState) - .SetVertexInputState(&vertexInputState) - .SetRasterizationState(&rasterizationState) - .SetColorBlendState(&colorBlendState) - .SetProgramState(&programState); - - // Store a pipeline per renderer per render (renderer can be owned by multiple nodes, - // and re-drawn in multiple instructions). - // @todo This is only needed because ColorBlend state can change. Fixme! - // This is ameliorated by the fact that implementation caches pipelines, and we're only storing - // handles. - auto hash = HashedPipeline::GetHash(&node, &instruction, blend); - HashedPipeline* hashedPipeline = nullptr; - for(auto& element : mGraphicsPipelines) - { - if(element.mHash == hash) - { - hashedPipeline = &element; - break; - } - } + // should be never null? + return *pipelineResult.pipeline; +} - if(hashedPipeline != nullptr) - { - hashedPipeline->mGraphicsPipeline = mGraphicsController->CreatePipeline( - createInfo, - std::move(hashedPipeline->mGraphicsPipeline)); - } - else - { - mGraphicsPipelines.emplace_back(); - mGraphicsPipelines.back().mHash = hash; - mGraphicsPipelines.back().mGraphicsPipeline = mGraphicsController->CreatePipeline(createInfo, nullptr); - hashedPipeline = &mGraphicsPipelines.back(); - } - return *hashedPipeline->mGraphicsPipeline.get(); +void Renderer::SetRenderCallback(RenderCallback* callback) +{ + mRenderCallback = callback; } } // namespace Render