#define DALI_INTERNAL_SCENE_GRAPH_RENDERER_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.
#include <dali/devel-api/rendering/renderer-devel.h>
#include <dali/internal/common/blending-options.h>
-#include <dali/internal/common/type-abstraction-enums.h>
+#include <dali/internal/common/memory-pool-key.h>
#include <dali/internal/event/common/event-thread-services.h>
-#include <dali/internal/event/rendering/visual-renderer-impl.h>
#include <dali/internal/render/data-providers/render-data-provider.h>
#include <dali/internal/render/renderers/render-renderer.h>
#include <dali/internal/update/common/animatable-property.h>
#include <dali/internal/update/common/property-owner.h>
#include <dali/internal/update/common/uniform-map.h>
+#include <dali/internal/update/rendering/scene-graph-visual-renderer.h>
#include <dali/public-api/rendering/geometry.h>
#include <dali/public-api/rendering/renderer.h> // Dali::Renderer
class SceneController;
class Renderer;
-using RendererContainer = Dali::Vector<Renderer*>;
-using RendererIter = RendererContainer::Iterator;
-using RendererConstIter = RendererContainer::ConstIterator;
-
class TextureSet;
class Geometry;
+using RendererKey = MemoryPoolKey<SceneGraph::Renderer>;
+
+} // namespace SceneGraph
+} // namespace Internal
+
+// Ensure RendererKey can be used in Dali::Vector
+template<>
+struct TypeTraits<Internal::SceneGraph::RendererKey> : public BasicTypes<Internal::SceneGraph::RendererKey>
+{
+ enum
+ {
+ IS_TRIVIAL_TYPE = true
+ };
+};
+
+namespace Internal
+{
+namespace SceneGraph
+{
+class NodeDataProvider;
+using RendererContainer = Dali::Vector<RendererKey>;
+using RendererIter = RendererContainer::Iterator;
+using RendererConstIter = RendererContainer::ConstIterator;
+
class Renderer : public PropertyOwner,
public UniformMapDataProvider,
- public RenderDataProvider,
- public UniformMap::Observer
+ public RenderDataProvider
{
public:
enum OpacityType
/**
* Construct a new Renderer
*/
- static Renderer* New();
+ static RendererKey NewKey();
/**
* Destructor
void operator delete(void* ptr);
/**
+ * Get a pointer to the object from the given key.
+ * Used by MemoryPoolKey to provide pointer semantics.
+ */
+ static Renderer* Get(RendererKey::KeyType);
+
+ /**
+ * Get the key of the given renderer in the associated memory pool.
+ * @param[in] renderer the given renderer
+ * @return The key in the associated memory pool.
+ */
+ static RendererKey GetKey(const SceneGraph::Renderer& renderer);
+
+ /**
+ * Get the key of the given renderer in the associated memory pool.
+ * @param[in] renderer the given renderer
+ * @return The key in the associated memory pool, or -1 if not
+ * found.
+ */
+ static RendererKey GetKey(SceneGraph::Renderer* renderer);
+
+ /**
* Set the texture set for the renderer
* @param[in] textureSet The texture set this renderer will use
*/
void SetTextures(TextureSet* textureSet);
+ /**
+ * Get the associated texture set
+ * @return the texture set.
+ */
const SceneGraph::TextureSet* GetTextureSet() const
{
return mTextureSet;
/**
* @copydoc RenderDataProvider::GetTextures()
*/
- const Vector<Render::Texture*>* GetTextures() const override;
+ const Vector<Render::TextureKey>* GetTextures() const override;
/**
* @copydoc RenderDataProvider::GetSamplers()
* Retrieve the Render thread renderer
* @return The associated render thread renderer
*/
- Render::Renderer& GetRenderer();
+ Render::RendererKey GetRenderer() const;
/**
* Query whether the renderer is fully opaque, fully transparent or transparent.
* @param[in] updateBufferIndex The current update buffer index.
+ * @param[in] renderPass render pass for this render instruction
* @return OPAQUE if fully opaque, TRANSPARENT if fully transparent and TRANSLUCENT if in between
*/
- OpacityType GetOpacityType(BufferIndex updateBufferIndex, const Node& node) const;
+ OpacityType GetOpacityType(BufferIndex updateBufferIndex, uint32_t renderPass, const Node& node) const;
/**
* Connect the object to the scene graph
void DisconnectFromSceneGraph(SceneController& sceneController, BufferIndex bufferIndex);
/**
+ * Detached from the scene graph object.
+ * @param[in] node node who detach this renderer.
+ */
+ void DetachFromNodeDataProvider(const NodeDataProvider& node);
+
+ /**
* @copydoc RenderDataProvider::GetUniformMapDataProvider()
*/
const UniformMapDataProvider& GetUniformMapDataProvider() const override
/**
* @copydoc RenderDataProvider::IsUpdated()
*/
- bool IsUpdated() const override
- {
- return Updated();
- }
+ bool IsUpdated() const override;
/**
* @copydoc RenderDataProvider::GetVisualTransformedUpdateArea()
*/
Vector4 GetVisualTransformedUpdateArea(BufferIndex updateBufferIndex, const Vector4& originalUpdateArea) noexcept override;
+ uint32_t GetInstanceCount() const override
+ {
+ return mInstanceCount;
+ }
+
+ void SetInstanceCount(uint32_t instanceCount)
+ {
+ mInstanceCount = instanceCount;
+ }
+
/**
* Sets RenderCallback object
*
bool IsDirty() const;
/**
- * Reset both dirty flag and updated flag.
- * @note This is called after rendering has completed.
+ * @brief Reset to base values of all animatable properties.
+ *
+ * @param[in] updateBufferIndex the current buffer index
+ */
+ void ResetToBaseValues(BufferIndex updateBufferIndex);
+
+ /**
+ * @brief Mark all animatable properties as dirty.
+ */
+ void MarkAsDirty();
+
+ /**
+ * Get the capacity of the memory pools
+ * @return the capacity of the memory pools
*/
- void ResetDirtyFlag();
+ static uint32_t GetMemoryPoolCapacity();
-public: // UniformMap::Observer
+public: // PropertyOwner::MappingChanged
/**
- * @copydoc UniformMap::Observer::UniformMappingsChanged
+ * @copydoc PropertyOwner::OnMappingChanged
*/
- void UniformMappingsChanged(const UniformMap& mappings) override;
+ void OnMappingChanged() override;
public: // PropertyOwner implementation
/**
*/
virtual void ResetDefaultProperties(BufferIndex updateBufferIndex){};
+ /**
+ * @copydoc Dali::Internal::SceneGraph::PropertyOwner::AddInitializeResetter
+ */
+ void AddInitializeResetter(ResetterManager& manager) const override;
+
public: // From UniformMapDataProvider
/**
* @copydoc UniformMapDataProvider::GetCollectedUniformMap
/**
* To be used only for 1st stage initialization in event thread.
*/
- void SetVisualProperties(Internal::VisualRenderer::AnimatableVisualProperties* visualProperties)
+ void SetVisualProperties(VisualRenderer::AnimatableVisualProperties* visualProperties)
{
mVisualProperties = visualProperties;
}
/**
* May be accessed from event thread
*/
- const Internal::VisualRenderer::AnimatableVisualProperties* GetVisualProperties() const
+ const VisualRenderer::AnimatableVisualProperties* GetVisualProperties() const
{
return mVisualProperties.Get();
}
private:
CollectedUniformMap mCollectedUniformMap; ///< Uniform maps collected by the renderer
- SceneController* mSceneController; ///< Used for initializing renderers
- Render::Renderer* mRenderer; ///< Raw pointer to the renderer (that's owned by RenderManager)
- TextureSet* mTextureSet; ///< The texture set this renderer uses. (Not owned)
- Render::Geometry* mGeometry; ///< The geometry this renderer uses. (Not owned)
- Shader* mShader; ///< The shader this renderer uses. (Not owned)
+ SceneController* mSceneController; ///< Used for initializing renderers
+ Render::RendererKey mRenderer; ///< Key to the renderer (that's owned by RenderManager)
+ TextureSet* mTextureSet; ///< The texture set this renderer uses. (Not owned)
+ Render::Geometry* mGeometry; ///< The geometry this renderer uses. (Not owned)
+ Shader* mShader; ///< The shader this renderer uses. (Not owned)
OwnerPointer<VisualRenderer::AnimatableVisualProperties> mVisualProperties{nullptr}; ///< VisualProperties (optional/owned)
OwnerPointer<Vector4> mBlendColor; ///< The blend color for blending operation
Dali::Internal::Render::Renderer::StencilParameters mStencilParameters; ///< Struct containing all stencil related options
- uint64_t mUniformsHash{0}; ///< Hash of uniform map property values
- uint32_t mIndexedDrawFirstElement; ///< first element index to be drawn using indexed draw
- uint32_t mIndexedDrawElementsCount; ///< number of elements to be drawn using indexed draw
- uint32_t mBlendBitmask; ///< The bitmask of blending options
- uint32_t mResendFlag; ///< Indicate whether data should be resent to the renderer
- uint32_t mUniformMapChangeCounter{0u}; ///< Value to check if uniform data should be updated
+ uint32_t mIndexedDrawFirstElement; ///< first element index to be drawn using indexed draw
+ uint32_t mIndexedDrawElementsCount; ///< number of elements to be drawn using indexed draw
+ uint32_t mInstanceCount{0}; ///< The number of instances to be drawn
+ uint32_t mBlendBitmask; ///< The bitmask of blending options
+ uint32_t mResendFlag; ///< Indicate whether data should be resent to the renderer
+ UniformMap::SizeType mUniformMapChangeCounter{0u}; ///< Value to check if uniform data should be updated
+ UniformMap::SizeType mShaderMapChangeCounter{0u}; ///< Value to check if uniform data should be updated
DepthFunction::Type mDepthFunction : 4; ///< Local copy of the depth function
FaceCullingMode::Type mFaceCullingMode : 3; ///< Local copy of the mode of face culling
bool mRegenerateUniformMap : 1; ///< true if the map should be regenerated
bool mPremultipledAlphaEnabled : 1; ///< Flag indicating whether the Pre-multiplied Alpha Blending is required
- bool mDirtyFlag : 1; ///< Flag indicating whether the properties are changed
std::vector<Dali::DevelRenderer::DrawCommand> mDrawCommands;
Dali::RenderCallback* mRenderCallback{nullptr};
- /**
- * @brief Cached coefficient value when we calculate visual transformed update size.
- * It can reduce complexity of calculate the vertex position.
- *
- * Vector2 vertexPosition = (XA * aPosition + XB) * originalSize + (CA * aPosition + CB) + Vector2(D, D) * aPosition
- */
- struct VisualTransformedUpdateSizeCoefficientCache
- {
- Vector2 coefXA{Vector2::ZERO};
- Vector2 coefXB{Vector2::ZERO};
- Vector2 coefCA{Vector2::ZERO};
- Vector2 coefCB{Vector2::ZERO};
- float coefD{0.0f};
-
- uint64_t hash{0u};
- uint64_t decoratedHash{0u};
- };
- VisualTransformedUpdateSizeCoefficientCache mVisualPropertiesCoefficient; ///< Coefficient value to calculate visual transformed update size by VisualProperties more faster.
-
public:
AnimatableProperty<float> mOpacity; ///< The opacity value
int32_t mDepthIndex; ///< Used only in PrepareRenderInstructions
};
-/// Messages
-inline void SetTexturesMessage(EventThreadServices& eventThreadServices, const Renderer& renderer, const TextureSet& textureSet)
-{
- using LocalType = MessageValue1<Renderer, TextureSet*>;
-
- // Reserve some memory inside the message queue
- uint32_t* slot = eventThreadServices.ReserveMessageSlot(sizeof(LocalType));
-
- // Construct message in the message queue memory; note that delete should not be called on the return value
- new(slot) LocalType(&renderer, &Renderer::SetTextures, const_cast<TextureSet*>(&textureSet));
-}
-
-inline void SetGeometryMessage(EventThreadServices& eventThreadServices, const Renderer& renderer, const Render::Geometry& geometry)
-{
- using LocalType = MessageValue1<Renderer, Render::Geometry*>;
-
- // Reserve some memory inside the message queue
- uint32_t* slot = eventThreadServices.ReserveMessageSlot(sizeof(LocalType));
-
- // Construct message in the message queue memory; note that delete should not be called on the return value
- new(slot) LocalType(&renderer, &Renderer::SetGeometry, const_cast<Render::Geometry*>(&geometry));
-}
-
-inline void SetShaderMessage(EventThreadServices& eventThreadServices, const Renderer& renderer, const Shader& shader)
-{
- using LocalType = MessageValue1<Renderer, Shader*>;
-
- // Reserve some memory inside the message queue
- uint32_t* slot = eventThreadServices.ReserveMessageSlot(sizeof(LocalType));
-
- // Construct message in the message queue memory; note that delete should not be called on the return value
- new(slot) LocalType(&renderer, &Renderer::SetShader, const_cast<Shader*>(&shader));
-}
-
-inline void SetDepthIndexMessage(EventThreadServices& eventThreadServices, const Renderer& renderer, int depthIndex)
-{
- using LocalType = MessageValue1<Renderer, int>;
-
- // Reserve some memory inside the message queue
- uint32_t* slot = eventThreadServices.ReserveMessageSlot(sizeof(LocalType));
-
- // Construct message in the message queue memory; note that delete should not be called on the return value
- new(slot) LocalType(&renderer, &Renderer::SetDepthIndex, depthIndex);
-}
-
-inline void SetFaceCullingModeMessage(EventThreadServices& eventThreadServices, const Renderer& renderer, FaceCullingMode::Type faceCullingMode)
-{
- using LocalType = MessageValue1<Renderer, FaceCullingMode::Type>;
-
- // Reserve some memory inside the message queue
- uint32_t* slot = eventThreadServices.ReserveMessageSlot(sizeof(LocalType));
-
- new(slot) LocalType(&renderer, &Renderer::SetFaceCullingMode, faceCullingMode);
-}
-
-inline void SetBlendModeMessage(EventThreadServices& eventThreadServices, const Renderer& renderer, BlendMode::Type blendingMode)
-{
- using LocalType = MessageValue1<Renderer, BlendMode::Type>;
-
- // Reserve some memory inside the message queue
- uint32_t* slot = eventThreadServices.ReserveMessageSlot(sizeof(LocalType));
-
- new(slot) LocalType(&renderer, &Renderer::SetBlendMode, blendingMode);
-}
-
-inline void SetBlendingOptionsMessage(EventThreadServices& eventThreadServices, const Renderer& renderer, uint32_t options)
-{
- using LocalType = MessageValue1<Renderer, uint32_t>;
-
- // Reserve some memory inside the message queue
- uint32_t* slot = eventThreadServices.ReserveMessageSlot(sizeof(LocalType));
-
- new(slot) LocalType(&renderer, &Renderer::SetBlendingOptions, options);
-}
-
-inline void SetBlendColorMessage(EventThreadServices& eventThreadServices, const Renderer& renderer, const Vector4& blendColor)
-{
- using LocalType = MessageValue1<Renderer, Vector4>;
-
- // Reserve some memory inside the message queue
- uint32_t* slot = eventThreadServices.ReserveMessageSlot(sizeof(LocalType));
-
- new(slot) LocalType(&renderer, &Renderer::SetBlendColor, blendColor);
-}
-
-inline void SetIndexedDrawFirstElementMessage(EventThreadServices& eventThreadServices, const Renderer& renderer, uint32_t firstElement)
-{
- using LocalType = MessageValue1<Renderer, uint32_t>;
-
- // Reserve some memory inside the message queue
- uint32_t* slot = eventThreadServices.ReserveMessageSlot(sizeof(LocalType));
-
- new(slot) LocalType(&renderer, &Renderer::SetIndexedDrawFirstElement, firstElement);
-}
-
-inline void SetIndexedDrawElementsCountMessage(EventThreadServices& eventThreadServices, const Renderer& renderer, uint32_t elementsCount)
-{
- using LocalType = MessageValue1<Renderer, uint32_t>;
-
- // Reserve some memory inside the message queue
- uint32_t* slot = eventThreadServices.ReserveMessageSlot(sizeof(LocalType));
-
- new(slot) LocalType(&renderer, &Renderer::SetIndexedDrawElementsCount, elementsCount);
-}
-
-inline void SetEnablePreMultipliedAlphaMessage(EventThreadServices& eventThreadServices, const Renderer& renderer, bool preMultiplied)
-{
- using LocalType = MessageValue1<Renderer, bool>;
-
- // Reserve some memory inside the message queue
- uint32_t* slot = eventThreadServices.ReserveMessageSlot(sizeof(LocalType));
-
- new(slot) LocalType(&renderer, &Renderer::EnablePreMultipliedAlpha, preMultiplied);
-}
-
-inline void SetDepthWriteModeMessage(EventThreadServices& eventThreadServices, const Renderer& renderer, DepthWriteMode::Type depthWriteMode)
-{
- using LocalType = MessageValue1<Renderer, DepthWriteMode::Type>;
-
- // Reserve some memory inside the message queue
- uint32_t* slot = eventThreadServices.ReserveMessageSlot(sizeof(LocalType));
-
- new(slot) LocalType(&renderer, &Renderer::SetDepthWriteMode, depthWriteMode);
-}
-
-inline void SetDepthTestModeMessage(EventThreadServices& eventThreadServices, const Renderer& renderer, DepthTestMode::Type depthTestMode)
-{
- using LocalType = MessageValue1<Renderer, DepthTestMode::Type>;
-
- // Reserve some memory inside the message queue
- uint32_t* slot = eventThreadServices.ReserveMessageSlot(sizeof(LocalType));
-
- new(slot) LocalType(&renderer, &Renderer::SetDepthTestMode, depthTestMode);
-}
-
-inline void SetDepthFunctionMessage(EventThreadServices& eventThreadServices, const Renderer& renderer, DepthFunction::Type depthFunction)
-{
- using LocalType = MessageValue1<Renderer, DepthFunction::Type>;
-
- // Reserve some memory inside the message queue
- uint32_t* slot = eventThreadServices.ReserveMessageSlot(sizeof(LocalType));
-
- new(slot) LocalType(&renderer, &Renderer::SetDepthFunction, depthFunction);
-}
-
-inline void SetRenderModeMessage(EventThreadServices& eventThreadServices, const Renderer& renderer, RenderMode::Type mode)
-{
- using LocalType = MessageValue1<Renderer, RenderMode::Type>;
-
- // Reserve some memory inside the message queue
- uint32_t* slot = eventThreadServices.ReserveMessageSlot(sizeof(LocalType));
-
- new(slot) LocalType(&renderer, &Renderer::SetRenderMode, mode);
-}
-
-inline void SetStencilFunctionMessage(EventThreadServices& eventThreadServices, const Renderer& renderer, StencilFunction::Type stencilFunction)
-{
- using LocalType = MessageValue1<Renderer, StencilFunction::Type>;
-
- // Reserve some memory inside the message queue
- uint32_t* slot = eventThreadServices.ReserveMessageSlot(sizeof(LocalType));
-
- new(slot) LocalType(&renderer, &Renderer::SetStencilFunction, stencilFunction);
-}
-
-inline void SetStencilFunctionMaskMessage(EventThreadServices& eventThreadServices, const Renderer& renderer, int mask)
-{
- using LocalType = MessageValue1<Renderer, int>;
-
- // Reserve some memory inside the message queue
- uint32_t* slot = eventThreadServices.ReserveMessageSlot(sizeof(LocalType));
-
- new(slot) LocalType(&renderer, &Renderer::SetStencilFunctionMask, mask);
-}
-
-inline void SetStencilFunctionReferenceMessage(EventThreadServices& eventThreadServices, const Renderer& renderer, int stencilFunctionReference)
-{
- using LocalType = MessageValue1<Renderer, int>;
-
- // Reserve some memory inside the message queue
- uint32_t* slot = eventThreadServices.ReserveMessageSlot(sizeof(LocalType));
-
- new(slot) LocalType(&renderer, &Renderer::SetStencilFunctionReference, stencilFunctionReference);
-}
-
-inline void SetStencilMaskMessage(EventThreadServices& eventThreadServices, const Renderer& renderer, int stencilMask)
-{
- using LocalType = MessageValue1<Renderer, int>;
-
- // Reserve some memory inside the message queue
- uint32_t* slot = eventThreadServices.ReserveMessageSlot(sizeof(LocalType));
-
- new(slot) LocalType(&renderer, &Renderer::SetStencilMask, stencilMask);
-}
-
-inline void SetStencilOperationOnFailMessage(EventThreadServices& eventThreadServices, const Renderer& renderer, StencilOperation::Type stencilOperation)
-{
- using LocalType = MessageValue1<Renderer, StencilOperation::Type>;
-
- // Reserve some memory inside the message queue
- uint32_t* slot = eventThreadServices.ReserveMessageSlot(sizeof(LocalType));
-
- new(slot) LocalType(&renderer, &Renderer::SetStencilOperationOnFail, stencilOperation);
-}
-
-inline void SetStencilOperationOnZFailMessage(EventThreadServices& eventThreadServices, const Renderer& renderer, StencilOperation::Type stencilOperation)
-{
- using LocalType = MessageValue1<Renderer, StencilOperation::Type>;
-
- // Reserve some memory inside the message queue
- uint32_t* slot = eventThreadServices.ReserveMessageSlot(sizeof(LocalType));
-
- new(slot) LocalType(&renderer, &Renderer::SetStencilOperationOnZFail, stencilOperation);
-}
-
-inline void SetStencilOperationOnZPassMessage(EventThreadServices& eventThreadServices, const Renderer& renderer, StencilOperation::Type stencilOperation)
-{
- using LocalType = MessageValue1<Renderer, StencilOperation::Type>;
-
- // Reserve some memory inside the message queue
- uint32_t* slot = eventThreadServices.ReserveMessageSlot(sizeof(LocalType));
-
- new(slot) LocalType(&renderer, &Renderer::SetStencilOperationOnZPass, stencilOperation);
-}
-
-inline void BakeOpacityMessage(EventThreadServices& eventThreadServices, const Renderer& renderer, float opacity)
-{
- using LocalType = MessageDoubleBuffered1<Renderer, float>;
-
- // Reserve some memory inside the message queue
- uint32_t* slot = eventThreadServices.ReserveMessageSlot(sizeof(LocalType));
-
- new(slot) LocalType(&renderer, &Renderer::BakeOpacity, opacity);
-}
-
-inline void SetRenderingBehaviorMessage(EventThreadServices& eventThreadServices, const Renderer& renderer, DevelRenderer::Rendering::Type renderingBehavior)
-{
- using LocalType = MessageValue1<Renderer, DevelRenderer::Rendering::Type>;
-
- // Reserve some memory inside the message queue
- uint32_t* slot = eventThreadServices.ReserveMessageSlot(sizeof(LocalType));
-
- new(slot) LocalType(&renderer, &Renderer::SetRenderingBehavior, renderingBehavior);
-}
-
-inline void SetDrawCommandsMessage(EventThreadServices& eventThreadServices, const Renderer& renderer, Dali::DevelRenderer::DrawCommand* pDrawCommands, uint32_t size)
-{
- using LocalType = MessageValue2<Renderer, Dali::DevelRenderer::DrawCommand*, uint32_t>;
-
- // Reserve some memory inside the message queue
- uint32_t* slot = eventThreadServices.ReserveMessageSlot(sizeof(LocalType));
-
- new(slot) LocalType(&renderer, &Renderer::SetDrawCommands, pDrawCommands, size);
-}
-
-inline void SetRenderCallbackMessage(EventThreadServices& eventThreadServices, const Renderer& renderer, Dali::RenderCallback* callback)
-{
- using LocalType = MessageValue1<Renderer, Dali::RenderCallback*>;
-
- // Reserve some memory inside the message queue
- uint32_t* slot = eventThreadServices.ReserveMessageSlot(sizeof(LocalType));
-
- new(slot) LocalType(&renderer, &Renderer::SetRenderCallback, callback);
-}
-
} // namespace SceneGraph
} // namespace Internal
} // namespace Dali
-#endif // DALI_INTERNAL_SCENE_GRAPH_RENDERER_H
+#endif // DALI_INTERNAL_SCENE_GRAPH_RENDERER_H
projects / platform / core / uifw / dali-core.git / blobdiff