#define DALI_INTERNAL_SCENE_GRAPH_LAYER_H
/*
- * Copyright (c) 2022 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2024 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.
{
namespace SceneGraph
{
-
using RenderableContainer = Dali::Vector<Renderable>;
/**
}
/**
+ * Get the reuse of the model view matrices of all renderers for this layer is enabled.
+ * @param[in] updateBufferIndex The current update buffer index.
+ * @return Whether all child transform was clean or not.
+ */
+ bool GetReuseRenderers(BufferIndex updateBufferIndex) const
+ {
+ return mAllChildTransformsClean[updateBufferIndex];
+ }
+
+ /**
* Checks if it is ok to reuse renderers. Renderers can be reused if ModelView transform for all the renderers
* has not changed from previous use.
* @param[in] camera A pointer to the camera that we want to use to render the list.
Layer();
// Delete copy and move
- Layer(const Layer&) = delete;
- Layer(Layer&&) = delete;
+ Layer(const Layer&) = delete;
+ Layer(Layer&&) = delete;
Layer& operator=(const Layer& rhs) = delete;
- Layer& operator=(Layer&& rhs) = delete;
+ Layer& operator=(Layer&& rhs) = delete;
public: // For update-algorithms
RenderableContainer colorRenderables;
/*
- * Copyright (c) 2023 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2024 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.
mUpdateDecay(Renderer::Decay::INITIAL),
mRegenerateUniformMap(false),
mPremultipledAlphaEnabled(false),
- mDirtyFlag(true),
mOpacity(1.0f),
mDepthIndex(0)
{
bool Renderer::PrepareRender(BufferIndex updateBufferIndex)
{
- bool rendererUpdated = mDirtyFlag || mResendFlag || mRenderingBehavior == DevelRenderer::Rendering::CONTINUOUSLY || mUpdateDecay > 0;
+ bool rendererUpdated = Updated() || mResendFlag || mRenderingBehavior == DevelRenderer::Rendering::CONTINUOUSLY || mUpdateDecay > 0;
auto shaderMapChangeCounter = mShader ? mShader->GetUniformMap().GetChangeCounter() : 0u;
bool shaderMapChanged = mShader && (mShaderMapChangeCounter != shaderMapChangeCounter);
if(shaderMapChanged)
mUpdateDecay = static_cast<Renderer::Decay>(static_cast<int>(mUpdateDecay) - 1);
}
- if(mDirtyFlag || mResendFlag || mRenderingBehavior == DevelRenderer::Rendering::CONTINUOUSLY) // We don't check mUpdateDecay
+ if(mResendFlag || mRenderingBehavior == DevelRenderer::Rendering::CONTINUOUSLY) // We don't check mUpdateDecay
{
SetUpdated(true);
}
{
DALI_ASSERT_DEBUG(textureSet != NULL && "Texture set pointer is NULL");
- mTextureSet = textureSet;
+ if(mTextureSet != textureSet)
+ {
+ mTextureSet = textureSet;
- mDirtyFlag = true;
- SetUpdated(true);
+ SetUpdated(true);
+ }
}
const Vector<Render::TextureKey>* Renderer::GetTextures() const
{
DALI_ASSERT_DEBUG(shader != NULL && "Shader pointer is NULL");
- mShader = shader;
- mShaderMapChangeCounter = 0u;
- mRegenerateUniformMap = true;
- mResendFlag |= RESEND_GEOMETRY | RESEND_SHADER;
- mDirtyFlag = true;
+ if(mShader != shader)
+ {
+ mShader = shader;
+ mShaderMapChangeCounter = 0u;
+ mRegenerateUniformMap = true;
+ mResendFlag |= RESEND_GEOMETRY | RESEND_SHADER;
+
+ SetUpdated(true);
+ }
}
void Renderer::SetGeometry(Render::Geometry* geometry)
{
DALI_ASSERT_DEBUG(geometry != NULL && "Geometry pointer is NULL");
- mGeometry = geometry;
-
- mDirtyFlag = true;
- if(mRenderer)
+ if(mGeometry != geometry)
{
- mResendFlag |= RESEND_GEOMETRY;
+ mGeometry = geometry;
+
+ if(mRenderer)
+ {
+ mResendFlag |= RESEND_GEOMETRY;
+ }
+ SetUpdated(true);
}
}
void Renderer::SetDepthIndex(int depthIndex)
{
- mDepthIndex = depthIndex;
+ if(mDepthIndex != depthIndex)
+ {
+ mDepthIndex = depthIndex;
- mDirtyFlag = true;
- SetUpdated(true);
+ SetUpdated(true);
+ }
}
void Renderer::SetFaceCullingMode(FaceCullingMode::Type faceCullingMode)
{
- mFaceCullingMode = faceCullingMode;
- mResendFlag |= RESEND_FACE_CULLING_MODE;
+ if(mFaceCullingMode != faceCullingMode)
+ {
+ mFaceCullingMode = faceCullingMode;
+ mResendFlag |= RESEND_FACE_CULLING_MODE;
+
+ SetUpdated(true);
+ }
}
FaceCullingMode::Type Renderer::GetFaceCullingMode() const
void Renderer::SetBlendMode(BlendMode::Type blendingMode)
{
- mBlendMode = blendingMode;
+ if(mBlendMode != blendingMode)
+ {
+ mBlendMode = blendingMode;
- mDirtyFlag = true;
- SetUpdated(true);
+ SetUpdated(true);
+ }
}
BlendMode::Type Renderer::GetBlendMode() const
{
mBlendBitmask = options;
mResendFlag |= RESEND_BLEND_BIT_MASK;
- mDirtyFlag = true;
+
+ SetUpdated(true);
}
}
}
mResendFlag |= RESEND_BLEND_COLOR;
+
+ SetUpdated(true);
}
Vector4 Renderer::GetBlendColor() const
void Renderer::SetIndexedDrawFirstElement(uint32_t firstElement)
{
- mIndexedDrawFirstElement = firstElement;
- mResendFlag |= RESEND_INDEXED_DRAW_FIRST_ELEMENT;
+ if(mIndexedDrawFirstElement != firstElement)
+ {
+ mIndexedDrawFirstElement = firstElement;
+ mResendFlag |= RESEND_INDEXED_DRAW_FIRST_ELEMENT;
+
+ SetUpdated(true);
+ }
}
uint32_t Renderer::GetIndexedDrawFirstElement() const
void Renderer::SetIndexedDrawElementsCount(uint32_t elementsCount)
{
- mIndexedDrawElementsCount = elementsCount;
- mResendFlag |= RESEND_INDEXED_DRAW_ELEMENTS_COUNT;
+ if(mIndexedDrawElementsCount != elementsCount)
+ {
+ mIndexedDrawElementsCount = elementsCount;
+ mResendFlag |= RESEND_INDEXED_DRAW_ELEMENTS_COUNT;
+
+ SetUpdated(true);
+ }
}
uint32_t Renderer::GetIndexedDrawElementsCount() const
void Renderer::EnablePreMultipliedAlpha(bool preMultipled)
{
- mPremultipledAlphaEnabled = preMultipled;
- mResendFlag |= RESEND_PREMULTIPLIED_ALPHA;
+ if(mPremultipledAlphaEnabled != preMultipled)
+ {
+ mPremultipledAlphaEnabled = preMultipled;
+ mResendFlag |= RESEND_PREMULTIPLIED_ALPHA;
+
+ SetUpdated(true);
+ }
}
bool Renderer::IsPreMultipliedAlphaEnabled() const
void Renderer::SetRenderCallback(RenderCallback* callback)
{
- mRenderCallback = callback;
- mResendFlag |= RESEND_SET_RENDER_CALLBACK;
- mDirtyFlag = true;
+ if(mRenderCallback != callback)
+ {
+ mRenderCallback = callback;
+ mResendFlag |= RESEND_SET_RENDER_CALLBACK;
+
+ SetUpdated(true);
+ }
}
const Render::Renderer::StencilParameters& Renderer::GetStencilParameters() const
{
mOpacity.Bake(updateBufferIndex, opacity);
- mDirtyFlag = true;
SetUpdated(true);
}
void Renderer::SetRenderingBehavior(DevelRenderer::Rendering::Type renderingBehavior)
{
- mRenderingBehavior = renderingBehavior;
+ if(mRenderingBehavior != renderingBehavior)
+ {
+ mRenderingBehavior = renderingBehavior;
- mDirtyFlag = true;
- SetUpdated(true);
+ SetUpdated(true);
+ }
}
DevelRenderer::Rendering::Type Renderer::GetRenderingBehavior() const
bool Renderer::IsDirty() const
{
// Check whether the opacity property has changed
- return (mDirtyFlag || !mOpacity.IsClean());
-}
-
-void Renderer::ResetDirtyFlag()
-{
- mDirtyFlag = false;
-
- SetUpdated(false);
+ return (Updated() || !mOpacity.IsClean());
}
void Renderer::ResetToBaseValues(BufferIndex updateBufferIndex)