X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Frender%2Frenderers%2Frender-renderer.cpp;h=7a19c6b77072a021ca7e0e34f2a7b1650e1ca49d;hb=c4750afbf79f15bf71e2aa8ef54f84750463aae2;hp=cac206d22ed4a8e5e747c9a3410d807eb417ba34;hpb=1c4d16d1a10942f90b67c5ed352992f330c4a0d4;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 cac206d..7a19c6b 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) 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. @@ -19,263 +19,184 @@ #include // INTERNAL INCLUDES -#include #include +#include #include +#include +#include +#include #include #include #include -#include +#include #include #include #include #include +#include +#include #include -#include +#include +#include +#include -namespace Dali -{ -namespace Internal +namespace Dali::Internal { namespace { -/** - * Helper to set view and projection matrices once per program - * @param program to set the matrices to - * @param modelMatrix to set - * @param viewMatrix to set - * @param projectionMatrix to set - * @param modelViewMatrix to set - * @param modelViewProjectionMatrix to set - */ -inline void SetMatrices(Program& program, - const Matrix& modelMatrix, - const Matrix& viewMatrix, - const Matrix& projectionMatrix, - const Matrix& modelViewMatrix) -{ - GLint loc = program.GetUniformLocation(Program::UNIFORM_MODEL_MATRIX); - if(Program::UNIFORM_UNKNOWN != loc) - { - program.SetUniformMatrix4fv(loc, 1, modelMatrix.AsFloat()); - } - loc = program.GetUniformLocation(Program::UNIFORM_VIEW_MATRIX); - if(Program::UNIFORM_UNKNOWN != loc) - { - if(program.GetViewMatrix() != &viewMatrix) - { - program.SetViewMatrix(&viewMatrix); - program.SetUniformMatrix4fv(loc, 1, viewMatrix.AsFloat()); - } - } - // set projection matrix if program has not yet received it this frame or if it is dirty - loc = program.GetUniformLocation(Program::UNIFORM_PROJECTION_MATRIX); - if(Program::UNIFORM_UNKNOWN != loc) - { - if(program.GetProjectionMatrix() != &projectionMatrix) - { - program.SetProjectionMatrix(&projectionMatrix); - program.SetUniformMatrix4fv(loc, 1, projectionMatrix.AsFloat()); - } - } - loc = program.GetUniformLocation(Program::UNIFORM_MODELVIEW_MATRIX); - if(Program::UNIFORM_UNKNOWN != loc) - { - program.SetUniformMatrix4fv(loc, 1, modelViewMatrix.AsFloat()); - } - - loc = program.GetUniformLocation(Program::UNIFORM_MVP_MATRIX); - if(Program::UNIFORM_UNKNOWN != loc) - { - Matrix modelViewProjectionMatrix(false); - Matrix::Multiply(modelViewProjectionMatrix, modelViewMatrix, projectionMatrix); - program.SetUniformMatrix4fv(loc, 1, modelViewProjectionMatrix.AsFloat()); - } - - loc = program.GetUniformLocation(Program::UNIFORM_NORMAL_MATRIX); - if(Program::UNIFORM_UNKNOWN != loc) - { - Matrix3 normalMatrix; - normalMatrix = modelViewMatrix; - normalMatrix.Invert(); - normalMatrix.Transpose(); - program.SetUniformMatrix3fv(loc, 1, normalMatrix.AsFloat()); - } -} - -// 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: { - type = Dali::Graphics::VertexInputFormat::FLOAT; - break; + 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; + 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; + } + }; } -constexpr Graphics::BlendFactor ConvertBlendFactor(BlendFactor::Type blendFactor) +/** + * Helper function to calculate the correct alignment of data for uniform buffers + * @param dataSize size of uniform buffer + * @return aligned offset of data + */ +inline uint32_t GetUniformBufferDataAlignment(uint32_t dataSize) { - 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{}; + return ((dataSize / 256u) + ((dataSize % 256u) ? 1u : 0u)) * 256u; } -constexpr Graphics::BlendOp ConvertBlendEquation(DevelBlendEquation::Type blendEquation) +/** + * @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) { - switch(blendEquation) + static const Render::Geometry* gLatestVertexBoundGeometry = nullptr; + if(gLatestVertexBoundGeometry == geometry) { - 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 true; } - return Graphics::BlendOp{}; + 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 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(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, @@ -288,13 +209,10 @@ Renderer::Renderer(SceneGraph::RenderDataProvider* dataProvider, DepthTestMode::Type depthTestMode, DepthFunction::Type depthFunction, StencilParameters& stencilParameters) -: mRenderDataProvider(dataProvider), - mContext(nullptr), +: mGraphicsController(nullptr), + mRenderDataProvider(dataProvider), mGeometry(geometry), mProgramCache(nullptr), - mUniformIndexMap(), - mAttributeLocations(), - mUniformsHash(), mStencilParameters(stencilParameters), mBlendingOptions(), mIndexedDrawFirstElement(0), @@ -303,10 +221,8 @@ Renderer::Renderer(SceneGraph::RenderDataProvider* dataProvider, mFaceCullingMode(faceCullingMode), mDepthWriteMode(depthWriteMode), mDepthTestMode(depthTestMode), - mUpdateAttributeLocations(true), - mPremultipledAlphaEnabled(preMultipliedAlphaEnabled), - mShaderChanged(false), - mUpdated(true) + mPremultipliedAlphaEnabled(preMultipliedAlphaEnabled), + mShaderChanged(false) { if(blendingBitmask != 0u) { @@ -316,262 +232,118 @@ Renderer::Renderer(SceneGraph::RenderDataProvider* dataProvider, mBlendingOptions.SetBlendColor(blendColor); } -void Renderer::Initialize(Context& context, Graphics::Controller& graphicsController, ProgramCache& programCache, Render::ShaderCache& shaderCache) +void Renderer::Initialize(Graphics::Controller& graphicsController, ProgramCache& programCache, Render::ShaderCache& shaderCache, Render::UniformBufferManager& uniformBufferManager, Render::PipelineCache& pipelineCache) { - mContext = &context; - mGraphicsController = &graphicsController; - mProgramCache = &programCache; - mShaderCache = &shaderCache; + mGraphicsController = &graphicsController; + mProgramCache = &programCache; + mShaderCache = &shaderCache; + mUniformBufferManager = &uniformBufferManager; + mPipelineCache = &pipelineCache; } Renderer::~Renderer() = default; -void Renderer::SetGeometry(Render::Geometry* geometry) -{ - mGeometry = geometry; - mUpdateAttributeLocations = true; -} -void Renderer::SetDrawCommands(Dali::DevelRenderer::DrawCommand* pDrawCommands, uint32_t size) -{ - mDrawCommands.clear(); - mDrawCommands.insert(mDrawCommands.end(), pDrawCommands, pDrawCommands + size); -} - -void Renderer::GlContextDestroyed() +void Renderer::operator delete(void* ptr) { - mGeometry->GlContextDestroyed(); + gRenderRendererMemoryPool.FreeThreadSafe(static_cast(ptr)); } -void Renderer::GlCleanup() +Renderer* Renderer::Get(RendererKey::KeyType rendererKey) { + return gRenderRendererMemoryPool.GetPtrFromKey(rendererKey); } -void Renderer::SetUniforms(BufferIndex bufferIndex, const SceneGraph::NodeDataProvider& node, const Vector3& size, Program& program) +void Renderer::SetGeometry(Render::Geometry* geometry) { - // Check if the map has changed - DALI_ASSERT_DEBUG(mRenderDataProvider && "No Uniform map data provider available"); - - const SceneGraph::UniformMapDataProvider& uniformMapDataProvider = mRenderDataProvider->GetUniformMap(); - - if(uniformMapDataProvider.GetUniformMapChanged(bufferIndex) || - node.GetUniformMapChanged(bufferIndex) || - mUniformIndexMap.Count() == 0 || - mShaderChanged) - { - // Reset shader pointer - mShaderChanged = false; - - const SceneGraph::CollectedUniformMap& uniformMap = uniformMapDataProvider.GetUniformMap(bufferIndex); - const SceneGraph::CollectedUniformMap& uniformMapNode = node.GetUniformMap(bufferIndex); - - uint32_t 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); - - uint32_t mapIndex = 0; - for(; mapIndex < uniformMap.Count(); ++mapIndex) - { - mUniformIndexMap[mapIndex].propertyValue = uniformMap[mapIndex].propertyPtr; - mUniformIndexMap[mapIndex].uniformIndex = program.RegisterUniform(uniformMap[mapIndex].uniformName); - } - - for(uint32_t nodeMapIndex = 0; nodeMapIndex < uniformMapNode.Count(); ++nodeMapIndex) - { - uint32_t uniformIndex = program.RegisterUniform(uniformMapNode[nodeMapIndex].uniformName); - bool found(false); - for(uint32_t i = 0; i < uniformMap.Count(); ++i) - { - if(mUniformIndexMap[i].uniformIndex == uniformIndex) - { - mUniformIndexMap[i].propertyValue = uniformMapNode[nodeMapIndex].propertyPtr; - found = true; - break; - } - } - - if(!found) - { - mUniformIndexMap[mapIndex].propertyValue = uniformMapNode[nodeMapIndex].propertyPtr; - mUniformIndexMap[mapIndex].uniformIndex = uniformIndex; - ++mapIndex; - } - } - - mUniformIndexMap.Resize(mapIndex); - } - - // Set uniforms in local map - for(UniformIndexMappings::Iterator iter = mUniformIndexMap.Begin(), - end = mUniformIndexMap.End(); - iter != end; - ++iter) - { - SetUniformFromProperty(bufferIndex, program, *iter); - } - - GLint sizeLoc = program.GetUniformLocation(Program::UNIFORM_SIZE); - if(-1 != sizeLoc) - { - program.SetSizeUniform3f(sizeLoc, size.x, size.y, size.z); - } + mGeometry = geometry; } -void Renderer::SetUniformFromProperty(BufferIndex bufferIndex, Program& program, UniformIndexMap& map) +void Renderer::SetDrawCommands(Dali::DevelRenderer::DrawCommand* pDrawCommands, uint32_t size) { - GLint location = program.GetUniformLocation(map.uniformIndex); - if(Program::UNIFORM_UNKNOWN != location) - { - // switch based on property type to use correct GL uniform setter - switch(map.propertyValue->GetType()) - { - case Property::INTEGER: - { - program.SetUniform1i(location, map.propertyValue->GetInteger(bufferIndex)); - break; - } - case Property::FLOAT: - { - program.SetUniform1f(location, map.propertyValue->GetFloat(bufferIndex)); - break; - } - case Property::VECTOR2: - { - Vector2 value(map.propertyValue->GetVector2(bufferIndex)); - program.SetUniform2f(location, value.x, value.y); - break; - } - - case Property::VECTOR3: - { - Vector3 value(map.propertyValue->GetVector3(bufferIndex)); - program.SetUniform3f(location, value.x, value.y, value.z); - break; - } - - case Property::VECTOR4: - { - Vector4 value(map.propertyValue->GetVector4(bufferIndex)); - program.SetUniform4f(location, value.x, value.y, value.z, value.w); - break; - } - - case Property::ROTATION: - { - Quaternion value(map.propertyValue->GetQuaternion(bufferIndex)); - program.SetUniform4f(location, value.mVector.x, value.mVector.y, value.mVector.z, value.mVector.w); - break; - } - - case Property::MATRIX: - { - const Matrix& value = map.propertyValue->GetMatrix(bufferIndex); - program.SetUniformMatrix4fv(location, 1, value.AsFloat()); - break; - } - - case Property::MATRIX3: - { - const Matrix3& value = map.propertyValue->GetMatrix3(bufferIndex); - program.SetUniformMatrix3fv(location, 1, value.AsFloat()); - break; - } - - default: - { - // Other property types are ignored - break; - } - } - } + mDrawCommands.clear(); + mDrawCommands.insert(mDrawCommands.end(), pDrawCommands, pDrawCommands + size); } -bool Renderer::BindTextures(Program& program, Graphics::CommandBuffer& commandBuffer, Vector& boundTextures) +void Renderer::BindTextures(Graphics::CommandBuffer& commandBuffer, Vector& boundTextures) { uint32_t textureUnit = 0; - bool result = true; - GLint uniformLocation(-1); - std::vector& samplers(mRenderDataProvider->GetSamplers()); - std::vector& textures(mRenderDataProvider->GetTextures()); + auto textures(mRenderDataProvider->GetTextures()); + auto samplers(mRenderDataProvider->GetSamplers()); std::vector textureBindings; - for(uint32_t i = 0; i < static_cast(textures.size()) && result; ++i) // not expecting more than uint32_t of textures + + if(textures != nullptr) { - if(textures[i]) + 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(program.GetSamplerUniformLocation(i, uniformLocation)) + 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}; + boundTextures.PushBack(graphicsTexture); + const Graphics::TextureBinding textureBinding{graphicsTexture, graphicsSampler, textureUnit}; textureBindings.push_back(textureBinding); - program.SetUniform1i(uniformLocation, textureUnit); // Get through shader reflection ++textureUnit; } } } - if(textureBindings.size() > 0) + if(!textureBindings.empty()) { commandBuffer.BindTextures(textureBindings); } - - return result; } 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) { - mPremultipledAlphaEnabled = enable; - mUpdated = true; + mPremultipliedAlphaEnabled = enable; } 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 @@ -587,7 +359,6 @@ DepthTestMode::Type Renderer::GetDepthTestMode() const void Renderer::SetDepthFunction(DepthFunction::Type depthFunction) { mDepthFunction = depthFunction; - mUpdated = true; } DepthFunction::Type Renderer::GetDepthFunction() const @@ -598,7 +369,6 @@ DepthFunction::Type Renderer::GetDepthFunction() const void Renderer::SetRenderMode(RenderMode::Type renderMode) { mStencilParameters.renderMode = renderMode; - mUpdated = true; } RenderMode::Type Renderer::GetRenderMode() const @@ -609,7 +379,6 @@ RenderMode::Type Renderer::GetRenderMode() const void Renderer::SetStencilFunction(StencilFunction::Type stencilFunction) { mStencilParameters.stencilFunction = stencilFunction; - mUpdated = true; } StencilFunction::Type Renderer::GetStencilFunction() const @@ -620,7 +389,6 @@ StencilFunction::Type Renderer::GetStencilFunction() const void Renderer::SetStencilFunctionMask(int stencilFunctionMask) { mStencilParameters.stencilFunctionMask = stencilFunctionMask; - mUpdated = true; } int Renderer::GetStencilFunctionMask() const @@ -631,7 +399,6 @@ int Renderer::GetStencilFunctionMask() const void Renderer::SetStencilFunctionReference(int stencilFunctionReference) { mStencilParameters.stencilFunctionReference = stencilFunctionReference; - mUpdated = true; } int Renderer::GetStencilFunctionReference() const @@ -642,7 +409,6 @@ int Renderer::GetStencilFunctionReference() const void Renderer::SetStencilMask(int stencilMask) { mStencilParameters.stencilMask = stencilMask; - mUpdated = true; } int Renderer::GetStencilMask() const @@ -653,7 +419,6 @@ int Renderer::GetStencilMask() const void Renderer::SetStencilOperationOnFail(StencilOperation::Type stencilOperationOnFail) { mStencilParameters.stencilOperationOnFail = stencilOperationOnFail; - mUpdated = true; } StencilOperation::Type Renderer::GetStencilOperationOnFail() const @@ -664,7 +429,6 @@ StencilOperation::Type Renderer::GetStencilOperationOnFail() const void Renderer::SetStencilOperationOnZFail(StencilOperation::Type stencilOperationOnZFail) { mStencilParameters.stencilOperationOnZFail = stencilOperationOnZFail; - mUpdated = true; } StencilOperation::Type Renderer::GetStencilOperationOnZFail() const @@ -675,7 +439,6 @@ StencilOperation::Type Renderer::GetStencilOperationOnZFail() const void Renderer::SetStencilOperationOnZPass(StencilOperation::Type stencilOperationOnZPass) { mStencilParameters.stencilOperationOnZPass = stencilOperationOnZPass; - mUpdated = true; } StencilOperation::Type Renderer::GetStencilOperationOnZPass() const @@ -688,7 +451,7 @@ void Renderer::Upload() mGeometry->Upload(*mGraphicsController); } -void Renderer::Render(Context& context, +bool Renderer::Render(Graphics::CommandBuffer& commandBuffer, BufferIndex bufferIndex, const SceneGraph::NodeDataProvider& node, const Matrix& modelMatrix, @@ -704,7 +467,56 @@ void Renderer::Render(Context& conte // Before doing anything test if the call happens in the right queue if(mDrawCommands.empty() && queueIndex > 0) { - return; + return false; + } + + // Check if there is render callback + if(mRenderCallback) + { + if(!mRenderCallbackInput) + { + mRenderCallbackInput = std::unique_ptr(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.GetRenderTextureKey()->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::MultiplyProjectionMatrix(mRenderCallbackInput->mvp, modelViewMatrix, projectionMatrix); + + // submit draw + commandBuffer.DrawNative(&info); + return true; } // Prepare commands @@ -720,355 +532,449 @@ void Renderer::Render(Context& conte // Have commands but nothing to be drawn - abort if(!mDrawCommands.empty() && commands.empty()) { - return; + return false; } - Graphics::UniquePtr commandBuffer = mGraphicsController->CreateCommandBuffer( - Graphics::CommandBufferCreateInfo() - .SetLevel(Graphics::CommandBufferLevel::SECONDARY), - nullptr); - - //Set blending mode + // Set blending mode if(!mDrawCommands.empty()) { - blend = (commands[0]->queue == DevelRenderer::RENDER_QUEUE_OPAQUE ? false : blend); + blend = (commands[0]->queue != DevelRenderer::RENDER_QUEUE_OPAQUE) && blend; } - // Create Shader. - // Really, need to have a pipeline cache in implementation. - // Get the program to use - // The program cache owns the Program object so we don't need to worry about this raw allocation here. + // Create Program ShaderDataPtr shaderData = mRenderDataProvider->GetShader().GetShaderData(); - Dali::Graphics::Shader& vertexShader = mShaderCache->GetShader( - shaderData->GetShaderForPipelineStage(Graphics::PipelineStage::VERTEX_SHADER), - Graphics::PipelineStage::VERTEX_SHADER, - shaderData->GetSourceMode()); - - Dali::Graphics::Shader& fragmentShader = mShaderCache->GetShader( - shaderData->GetShaderForPipelineStage(Graphics::PipelineStage::FRAGMENT_SHADER), - 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); - - mGraphicsProgram = mGraphicsController->CreateProgram(createInfo, std::move(mGraphicsProgram)); Program* program = Program::New(*mProgramCache, shaderData, - *mGraphicsController, - *mGraphicsProgram, - (shaderData->GetHints() & Dali::Shader::Hint::MODIFIES_GEOMETRY) != 0x0); - + *mGraphicsController); if(!program) { - DALI_LOG_ERROR("Failed to get program for shader at address %p.\n", reinterpret_cast(&mRenderDataProvider->GetShader())); - return; + DALI_LOG_ERROR("Failed to get program for shader at address %p.\n", reinterpret_cast(&mRenderDataProvider->GetShader())); + return false; } - // Temporarily create a pipeline here - this will be used for transporting - // topology, vertex format, attrs, rasterization state - mGraphicsPipeline = PrepareGraphicsPipeline(*program, instruction, blend, std::move(mGraphicsPipeline)); + // 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()); - commandBuffer->BindPipeline(*mGraphicsPipeline.get()); + Dali::Graphics::Shader& fragmentShader = mShaderCache->GetShader( + fragShader, + Graphics::PipelineStage::FRAGMENT_SHADER, + shaderData->GetSourceMode()); - if(DALI_LIKELY(BindTextures(*program, *commandBuffer.get(), boundTextures))) - { - // Only set up and draw if we have textures and they are all valid + std::vector shaderStates{ + Graphics::ShaderState() + .SetShader(vertexShader) + .SetPipelineStage(Graphics::PipelineStage::VERTEX_SHADER), + Graphics::ShaderState() + .SetShader(fragmentShader) + .SetPipelineStage(Graphics::PipelineStage::FRAGMENT_SHADER)}; - // set projection and view matrix if program has not yet received them yet this frame - SetMatrices(*program, modelMatrix, viewMatrix, projectionMatrix, modelViewMatrix); + auto createInfo = Graphics::ProgramCreateInfo(); + createInfo.SetShaderState(shaderStates); + auto graphicsProgram = mGraphicsController->CreateProgram(createInfo, nullptr); + program->SetGraphicsProgram(std::move(graphicsProgram)); + } - // set color uniform - GLint loc = program->GetUniformLocation(Program::UNIFORM_COLOR); - if(Program::UNIFORM_UNKNOWN != loc) - { - const Vector4& color = node.GetRenderColor(bufferIndex); - if(mPremultipledAlphaEnabled) - { - float alpha = color.a * mRenderDataProvider->GetOpacity(bufferIndex); - program->SetUniform4f(loc, color.r * alpha, color.g * alpha, color.b * alpha, alpha); - } - else - { - program->SetUniform4f(loc, color.r, color.g, color.b, color.a * mRenderDataProvider->GetOpacity(bufferIndex)); - } - } + // Prepare the graphics pipeline. This may either re-use an existing pipeline or create a new one. + auto& pipeline = PrepareGraphicsPipeline(*program, instruction, node, blend); + + commandBuffer.BindPipeline(pipeline); + + BindTextures(commandBuffer, boundTextures); - SetUniforms(bufferIndex, node, size, *program); + std::size_t nodeIndex = BuildUniformIndexMap(bufferIndex, node, size, *program); - 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 + WriteUniformBuffer(bufferIndex, commandBuffer, program, instruction, node, modelMatrix, modelViewMatrix, viewMatrix, projectionMatrix, size, nodeIndex); - //@todo manage mDrawCommands in the same way as above command buffer?! + 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 + + // Reuse latest bound vertex attributes location, or Bind buffers to attribute locations. + if(ReuseLatestBoundVertexAttributes(mGeometry) || mGeometry->BindVertexAttributes(commandBuffer)) + { if(mDrawCommands.empty()) { - drawn = mGeometry->Draw(*mGraphicsController, *commandBuffer.get(), mIndexedDrawFirstElement, mIndexedDrawElementsCount); + drawn = mGeometry->Draw(*mGraphicsController, commandBuffer, mIndexedDrawFirstElement, mIndexedDrawElementsCount); } else { for(auto& cmd : commands) { - // @todo This should generate a command buffer per cmd - // Tests WILL fail. (Temporarily commented out) - mGeometry->Draw(*mGraphicsController, *commandBuffer.get(), cmd->firstIndex, cmd->elementCount); + drawn |= mGeometry->Draw(*mGraphicsController, commandBuffer, cmd->firstIndex, cmd->elementCount); } } - - // Command buffer contains Texture bindings, vertex bindings, index buffer binding, pipeline(vertex format) - // @todo We should return the command buffer(s) and let the calling method submit - // If not drawn, then don't add command buffer to submit info, and if empty, don't - // submit. - if(drawn) - { - Graphics::SubmitInfo submitInfo{{}, 0 | Graphics::SubmitFlagBits::FLUSH}; - submitInfo.cmdBuffer.push_back(commandBuffer.get()); - mGraphicsController->SubmitCommandBuffers(submitInfo); - } - - mUpdated = false; } -} + else + { + // BindVertexAttributes failed. Reset cached geometry. + ReuseLatestBoundVertexAttributes(nullptr); + } -void Renderer::SetSortAttributes(BufferIndex bufferIndex, - SceneGraph::RenderInstructionProcessor::SortAttributes& sortAttributes) const -{ - sortAttributes.shader = &(mRenderDataProvider->GetShader()); - sortAttributes.geometry = mGeometry; + return drawn; } -void Renderer::SetShaderChanged(bool value) +std::size_t Renderer::BuildUniformIndexMap(BufferIndex bufferIndex, const SceneGraph::NodeDataProvider& node, const Vector3& size, Program& program) { - mShaderChanged = value; -} + // Check if the map has changed + DALI_ASSERT_DEBUG(mRenderDataProvider && "No Uniform map data provider available"); -bool Renderer::Updated(BufferIndex bufferIndex, const SceneGraph::NodeDataProvider* node) -{ - if(mUpdated) + 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; + + 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()) { - mUpdated = false; - return true; - } + renderItemMapIndex = mUniformIndexMaps.size(); + RenderItemLookup renderItemLookup; + renderItemLookup.node = nodePtr; + renderItemLookup.index = renderItemMapIndex; + renderItemLookup.nodeChangeCounter = nodeChangeCounter; + renderItemLookup.renderItemMapChangeCounter = renderItemMapChangeCounter; + mNodeIndexMap.emplace_back(renderItemLookup); - if(mShaderChanged || mUpdateAttributeLocations || mGeometry->AttributesChanged()) + updateMaps = true; + mUniformIndexMaps.resize(mUniformIndexMaps.size() + 1); + } + else { - return true; + renderItemMapIndex = iter->index; + + updateMaps = (nodeChangeCounter != iter->nodeChangeCounter) || + (renderItemMapChangeCounter != iter->renderItemMapChangeCounter) || + (mUniformIndexMaps[renderItemMapIndex].size() == 0); + + iter->nodeChangeCounter = nodeChangeCounter; + iter->renderItemMapChangeCounter = renderItemMapChangeCounter; } - for(const auto& texture : mRenderDataProvider->GetTextures()) + if(updateMaps || mShaderChanged) { - if(texture && texture->IsNativeImage()) + // Reset shader pointer + mShaderChanged = false; + + const uint32_t mapCount = uniformMap.Count(); + const uint32_t mapNodeCount = uniformMapNode.Count(); + + 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 < mapCount; ++mapIndex) { - return true; + 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 < mapNodeCount; ++nodeMapIndex) + { + auto hash = uniformMapNode[nodeMapIndex].uniformNameHash; + auto& name = uniformMapNode[nodeMapIndex].uniformName; + bool found(false); + for(uint32_t i = 0; i < mapCount; ++i) + { + if(mUniformIndexMaps[renderItemMapIndex][i].uniformNameHash == hash && + mUniformIndexMaps[renderItemMapIndex][i].uniformName == name) + { + mUniformIndexMaps[renderItemMapIndex][i].propertyValue = uniformMapNode[nodeMapIndex].propertyPtr; + found = true; + break; + } + } + + if(!found) + { + 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; + } + } + + mUniformIndexMaps[renderItemMapIndex].resize(mapIndex); } + return renderItemMapIndex; +} + +void Renderer::WriteUniformBuffer( + BufferIndex bufferIndex, + Graphics::CommandBuffer& commandBuffer, + Program* program, + const SceneGraph::RenderInstruction& instruction, + const SceneGraph::NodeDataProvider& node, + const Matrix& modelMatrix, + const Matrix& modelViewMatrix, + const Matrix& viewMatrix, + const Matrix& projectionMatrix, + const Vector3& size, + std::size_t nodeIndex) +{ + // Create the UBO + uint32_t uboOffset{0u}; + + auto& reflection = mGraphicsController->GetProgramReflection(program->GetGraphicsProgram()); + + uint32_t uniformBlockAllocationBytes = program->GetUniformBlocksMemoryRequirements().totalSizeRequired; - uint64_t hash = 0xc70f6907UL; - const SceneGraph::CollectedUniformMap& uniformMapNode = node->GetUniformMap(bufferIndex); - for(const auto& uniformProperty : uniformMapNode) + // Create uniform buffer view from uniform buffer + Graphics::UniquePtr uboView{nullptr}; + if(uniformBlockAllocationBytes) { - hash = uniformProperty.propertyPtr->Hash(bufferIndex, hash); + auto uboPoolView = mUniformBufferManager->GetUniformBufferViewPool(bufferIndex); + uboView = uboPoolView->CreateUniformBufferView(uniformBlockAllocationBytes); } - const SceneGraph::UniformMapDataProvider& uniformMapDataProvider = mRenderDataProvider->GetUniformMap(); - const SceneGraph::CollectedUniformMap& uniformMap = uniformMapDataProvider.GetUniformMap(bufferIndex); - for(const auto& uniformProperty : uniformMap) + // update the uniform buffer + // pass shared UBO and offset, return new offset for next item to be used + // don't process bindings if there are no uniform buffers allocated + if(uboView) { - hash = uniformProperty.propertyPtr->Hash(bufferIndex, hash); + auto uboCount = reflection.GetUniformBlockCount(); + mUniformBufferBindings.resize(uboCount); + + std::vector* bindings{&mUniformBufferBindings}; + + mUniformBufferBindings[0].buffer = uboView->GetBuffer(&mUniformBufferBindings[0].offset); + + // Write default uniforms + WriteDefaultUniform(program->GetDefaultUniform(Program::DefaultUniformIndex::MODEL_MATRIX), *uboView, modelMatrix); + WriteDefaultUniform(program->GetDefaultUniform(Program::DefaultUniformIndex::VIEW_MATRIX), *uboView, viewMatrix); + WriteDefaultUniform(program->GetDefaultUniform(Program::DefaultUniformIndex::PROJECTION_MATRIX), *uboView, projectionMatrix); + WriteDefaultUniform(program->GetDefaultUniform(Program::DefaultUniformIndex::MODEL_VIEW_MATRIX), *uboView, modelViewMatrix); + + auto mvpUniformInfo = program->GetDefaultUniform(Program::DefaultUniformIndex::MVP_MATRIX); + if(mvpUniformInfo && !mvpUniformInfo->name.empty()) + { + Matrix modelViewProjectionMatrix(false); + MatrixUtils::MultiplyProjectionMatrix(modelViewProjectionMatrix, modelViewMatrix, projectionMatrix); + WriteDefaultUniform(mvpUniformInfo, *uboView, modelViewProjectionMatrix); + } + + auto normalUniformInfo = program->GetDefaultUniform(Program::DefaultUniformIndex::NORMAL_MATRIX); + if(normalUniformInfo && !normalUniformInfo->name.empty()) + { + Matrix3 normalMatrix(modelViewMatrix); + normalMatrix.Invert(); + normalMatrix.Transpose(); + WriteDefaultUniform(normalUniformInfo, *uboView, normalMatrix); + } + + Vector4 finalColor; ///< Applied renderer's opacity color + const Vector4& color = node.GetRenderColor(bufferIndex); ///< Actor's original color + if(mPremultipliedAlphaEnabled) + { + 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, nodeIndex); + + // Write uSize in the end, as it shouldn't be overridable by dynamic properties. + WriteDefaultUniform(program->GetDefaultUniform(Program::DefaultUniformIndex::SIZE), *uboView, size); + + commandBuffer.BindUniformBuffers(*bindings); } +} - if(mUniformsHash != hash) +template +bool Renderer::WriteDefaultUniform(const Graphics::UniformInfo* uniformInfo, Render::UniformBufferView& ubo, const T& data) +{ + if(uniformInfo && !uniformInfo->name.empty()) { - mUniformsHash = hash; + WriteUniform(ubo, *uniformInfo, data); return true; } - return false; } -Graphics::UniquePtr Renderer::PrepareGraphicsPipeline( - Program& program, - const Dali::Internal::SceneGraph::RenderInstruction& instruction, - bool blend, - Graphics::UniquePtr&& oldPipeline) +template +void Renderer::WriteUniform(Render::UniformBufferView& ubo, const Graphics::UniformInfo& uniformInfo, const T& data) { - Graphics::InputAssemblyState inputAssemblyState{}; - Graphics::VertexInputState vertexInputState{}; - Graphics::ProgramState programState{}; - uint32_t bindingIndex{0u}; + WriteUniform(ubo, uniformInfo, &data, sizeof(T)); +} - if(mUpdateAttributeLocations || mGeometry->AttributesChanged()) - { - mAttributeLocations.Clear(); - mUpdateAttributeLocations = true; - } +void Renderer::WriteUniform(Render::UniformBufferView& ubo, const Graphics::UniformInfo& uniformInfo, const void* data, uint32_t size) +{ + ubo.Write(data, size, ubo.GetOffset() + uniformInfo.offset); +} - auto& reflection = mGraphicsController->GetProgramReflection(*mGraphicsProgram.get()); +void Renderer::FillUniformBuffer(Program& program, + const SceneGraph::RenderInstruction& instruction, + Render::UniformBufferView& ubo, + std::vector*& outBindings, + uint32_t& offset, + BufferIndex updateBufferIndex, + std::size_t nodeIndex) +{ + auto& reflection = mGraphicsController->GetProgramReflection(program.GetGraphicsProgram()); + auto uboCount = reflection.GetUniformBlockCount(); - /** - * Bind Attributes - */ - uint32_t base = 0; - for(auto&& vertexBuffer : mGeometry->GetVertexBuffers()) + // Setup bindings + uint32_t dataOffset = offset; + for(auto i = 0u; i < uboCount; ++i) { - const VertexBuffer::Format& vertexFormat = *vertexBuffer->GetFormat(); + mUniformBufferBindings[i].dataSize = reflection.GetUniformBlockSize(i); + mUniformBufferBindings[i].binding = reflection.GetUniformBlockBinding(i); - vertexInputState.bufferBindings.emplace_back(vertexFormat.size, // stride - Graphics::VertexInputRate::PER_VERTEX); + dataOffset += GetUniformBufferDataAlignment(mUniformBufferBindings[i].dataSize); + mUniformBufferBindings[i].buffer = ubo.GetBuffer(&mUniformBufferBindings[i].offset); - const uint32_t attributeCount = vertexBuffer->GetAttributeCount(); - for(uint32_t i = 0; i < attributeCount; ++i) + for(auto iter = mUniformIndexMaps[nodeIndex].begin(), + end = mUniformIndexMaps[nodeIndex].end(); + iter != end; + ++iter) { - 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); - } - - uint32_t location = static_cast(mAttributeLocations[base + i]); + auto& uniform = *iter; + int arrayIndex = uniform.arrayIndex; - vertexInputState.attributes.emplace_back(location, - bindingIndex, - vertexFormat.components[i].offset, - GetPropertyVertexFormat(vertexFormat.components[i].type)); - } - base += attributeCount; - ++bindingIndex; - } - mUpdateAttributeLocations = false; + if(!uniform.uniformFunc) + { + auto uniformInfo = Graphics::UniformInfo{}; + auto uniformFound = program.GetUniform(uniform.uniformName.GetStringView(), + uniform.uniformNameHash, + uniform.uniformNameHashNoArray, + uniformInfo); - // Get the topology - inputAssemblyState.SetTopology(mGeometry->GetTopology()); + uniform.uniformOffset = uniformInfo.offset; + uniform.uniformLocation = uniformInfo.location; - // Get the program - programState.SetProgram(*mGraphicsProgram.get()); + if(uniformFound) + { + 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()); - Graphics::RasterizationState rasterizationState{}; + ubo.Write(&((*iter).propertyValue->*func)(updateBufferIndex), + typeSize, + dest); - //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; + uniform.uniformSize = typeSize; + uniform.uniformFunc = func; + } } - default: + else { - // nothing to do, leave culling as it is + 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); } } - rasterizationState.SetCullMode(ConvertCullFace(adjFaceCullingMode)); - } - else - { - rasterizationState.SetCullMode(ConvertCullFace(mFaceCullingMode)); } + // write output bindings + outBindings = &mUniformBufferBindings; - 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; - } + // Update offset + offset = dataOffset; +} - // @todo How to signal a blend barrier is needed? - //if(mBlendingOptions.IsAdvancedBlendEquationApplied() && mPremultipledAlphaEnabled) - //{ - // context.BlendBarrier(); - //} +void Renderer::SetSortAttributes(SceneGraph::RenderInstructionProcessor::SortAttributes& sortAttributes) const +{ + sortAttributes.shader = &(mRenderDataProvider->GetShader()); + sortAttributes.geometry = mGeometry; +} - Graphics::ColorBlendState colorBlendState{}; - colorBlendState.SetBlendEnable(false); +void Renderer::SetShaderChanged(bool value) +{ + mShaderChanged = value; +} - if(blend) +bool Renderer::Updated(BufferIndex bufferIndex) +{ + if(mRenderCallback || mShaderChanged || mGeometry->AttributesChanged() || mRenderDataProvider->IsUpdated()) { - colorBlendState.SetBlendEnable(true); + return true; + } - Graphics::BlendOp rgbOp = ConvertBlendEquation(mBlendingOptions.GetBlendEquationRgb()); - Graphics::BlendOp alphaOp = ConvertBlendEquation(mBlendingOptions.GetBlendEquationRgb()); - if(mBlendingOptions.IsAdvancedBlendEquationApplied() && mPremultipledAlphaEnabled) + auto* textures = mRenderDataProvider->GetTextures(); + if(textures) + { + for(auto iter = textures->Begin(), end = textures->End(); iter < end; ++iter) { - if(rgbOp != alphaOp) + auto texture = *iter; + if(texture && texture->Updated()) { - DALI_LOG_ERROR("Advanced Blend Equation MUST be applied by using BlendEquation.\n"); - alphaOp = rgbOp; + return true; } } - - 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 - Vector4* blendColor = const_cast(mBlendingOptions.GetBlendColor()); - if(blendColor) - { - colorBlendState.SetBlendConstants(blendColor->AsFloat()); - } } + return false; +} - // Take the program into use so we can send uniforms to it - // @todo Remove this call entirely! - program.Use(); - - mUpdated = true; - - // Create a new pipeline - return mGraphicsController->CreatePipeline( - Graphics::PipelineCreateInfo() - .SetInputAssemblyState(&inputAssemblyState) // Passed as pointers - shallow copy will break. TOO C LIKE - .SetVertexInputState(&vertexInputState) - .SetRasterizationState(&rasterizationState) - .SetColorBlendState(&colorBlendState) - .SetProgramState(&programState) - .SetNextExtension(&mLegacyProgram), - std::move(oldPipeline)); +Vector4 Renderer::GetVisualTransformedUpdateArea(BufferIndex bufferIndex, const Vector4& originalUpdateArea) const noexcept +{ + return mRenderDataProvider->GetVisualTransformedUpdateArea(bufferIndex, originalUpdateArea); } -} // namespace Render +Graphics::Pipeline& Renderer::PrepareGraphicsPipeline( + Program& program, + const Dali::Internal::SceneGraph::RenderInstruction& instruction, + const SceneGraph::NodeDataProvider& node, + bool blend) +{ + // 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(); + + queryInfo.GenerateHash(); + + // Find or generate new pipeline. + auto pipelineResult = mPipelineCache->GetPipeline(queryInfo, true); + + // should be never null? + return *pipelineResult.pipeline; +} -} // namespace Internal +void Renderer::SetRenderCallback(RenderCallback* callback) +{ + mRenderCallback = callback; +} + +} // namespace Render -} // namespace Dali +} // namespace Dali::Internal