X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Fupdate%2Frendering%2Fscene-graph-renderer.h;h=4249b0fe3828ed84c3f49372639746ed44926a9a;hb=0ec8b37a80208c66d87e4322092d40694092bf81;hp=0c16aedbc5835a1260e3f2178cfa479db8c8f349;hpb=928021bdb0265663657f5308b27d41df568cd1b9;p=platform%2Fcore%2Fuifw%2Fdali-core.git diff --git a/dali/internal/update/rendering/scene-graph-renderer.h b/dali/internal/update/rendering/scene-graph-renderer.h index 0c16aed..1886342 100644 --- a/dali/internal/update/rendering/scene-graph-renderer.h +++ b/dali/internal/update/rendering/scene-graph-renderer.h @@ -1,8 +1,8 @@ -#ifndef DALI_INTERNAL_SCENE_GRAPH_RENDERER2_H -#define DALI_INTERNAL_SCENE_GRAPH_RENDERER2_H +#ifndef DALI_INTERNAL_SCENE_GRAPH_RENDERER_H +#define DALI_INTERNAL_SCENE_GRAPH_RENDERER_H /* - * Copyright (c) 2015 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. @@ -17,48 +17,152 @@ * limitations under the License. */ - -#include +#include +#include +#include #include +#include +#include #include -#include -#include #include -#include #include -#include -#include +#include +#include // Dali::Renderer namespace Dali { namespace Internal { - namespace Render { class Renderer; -} +class Geometry; +} // namespace Render namespace SceneGraph { class SceneController; class Renderer; -typedef Dali::Vector< Renderer* > RendererContainer; -typedef RendererContainer::Iterator RendererIter; -typedef RendererContainer::ConstIterator RendererConstIter; - -class Material; +class TextureSet; class Geometry; -class Renderer : public PropertyOwner, - public UniformMapDataProvider, - public UniformMap::Observer, - public ConnectionChangePropagator::Observer +using RendererKey = MemoryPoolKey; + +} // namespace SceneGraph +} // namespace Internal + +// Ensure RendererKey can be used in Dali::Vector +template<> +struct TypeTraits : public BasicTypes { -public: + enum + { + IS_TRIVIAL_TYPE = true + }; +}; - enum Opacity +namespace Internal +{ +namespace SceneGraph +{ +using RendererContainer = Dali::Vector; +using RendererIter = RendererContainer::Iterator; +using RendererConstIter = RendererContainer::ConstIterator; + +namespace VisualRenderer +{ +struct AnimatableVisualProperties +{ + AnimatableVisualProperties() + : mTransformOffset(Vector2::ZERO), + mTransformSize(Vector2::ONE), + mTransformOrigin(Vector2::ZERO), + mTransformAnchorPoint(Vector2::ZERO), + mTransformOffsetSizeMode(Vector4::ZERO), + mExtraSize(Vector2::ZERO), + mMixColor(Vector3::ONE), + mPreMultipliedAlpha(0.0f), + mExtendedPropertiesDeleteFunction(nullptr) + { + } + + ~AnimatableVisualProperties() + { + if(mExtendedProperties && mExtendedPropertiesDeleteFunction) + { + mExtendedPropertiesDeleteFunction(mExtendedProperties); + } + } + + /** + * @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 mCoefficient; ///< Coefficient value to calculate visual transformed update size by VisualProperties more faster. + + AnimatableProperty mTransformOffset; + AnimatableProperty mTransformSize; + AnimatableProperty mTransformOrigin; + AnimatableProperty mTransformAnchorPoint; + AnimatableProperty mTransformOffsetSizeMode; + AnimatableProperty mExtraSize; + AnimatableProperty mMixColor; + AnimatableProperty mPreMultipliedAlpha; + + void* mExtendedProperties{nullptr}; // Enable derived class to extend properties further + void (*mExtendedPropertiesDeleteFunction)(void*){nullptr}; // Derived class's custom delete functor +}; + +struct AnimatableDecoratedVisualProperties +{ + AnimatableDecoratedVisualProperties() + : mCornerRadius(Vector4::ZERO), + mCornerRadiusPolicy(1.0f), + mBorderlineWidth(0.0f), + mBorderlineColor(Color::BLACK), + mBorderlineOffset(0.0f), + mBlurRadius(0.0f) + { + } + ~AnimatableDecoratedVisualProperties() + { + } + + // Delete function of AnimatableDecoratedVisualProperties* converted as void* + static void DeleteFunction(void* data) + { + delete static_cast(data); + } + + AnimatableProperty mCornerRadius; + AnimatableProperty mCornerRadiusPolicy; + AnimatableProperty mBorderlineWidth; + AnimatableProperty mBorderlineColor; + AnimatableProperty mBorderlineOffset; + AnimatableProperty mBlurRadius; +}; +} // namespace VisualRenderer + +class Renderer : public PropertyOwner, + public UniformMapDataProvider, + public RenderDataProvider +{ +public: + enum OpacityType { OPAQUE, TRANSPARENT, @@ -66,52 +170,92 @@ public: }; /** - * Default constructor + * Construct a new Renderer */ - Renderer(); + static RendererKey NewKey(); /** * Destructor */ - virtual ~Renderer(); + ~Renderer() override; + + /** + * Overriden delete operator + * Deletes the renderer from its global memory pool + */ + 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); /** - * Set the material for the renderer - * @param[in] bufferIndex The current frame's buffer index - * @param[in] material The material this renderer will use + * 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. */ - void SetMaterial( BufferIndex bufferIndex, Material* material); + static RendererKey GetKey(SceneGraph::Renderer* renderer); /** - * Get the material of this renderer - * @return the material this renderer uses + * Set the texture set for the renderer + * @param[in] textureSet The texture set this renderer will use */ - Material& GetMaterial() + void SetTextures(TextureSet* textureSet); + + /** + * Get the associated texture set + * @return the texture set. + */ + const SceneGraph::TextureSet* GetTextureSet() const { - return *mMaterial; + return mTextureSet; } /** - * Set the geometry for the renderer - * @param[in] bufferIndex The current frame's buffer index - * @param[in] geometry The geometry this renderer will use + * @copydoc RenderDataProvider::GetTextures() + */ + const Vector* GetTextures() const override; + + /** + * @copydoc RenderDataProvider::GetSamplers() + */ + const Vector* GetSamplers() const override; + + /** + * Set the shader for the renderer + * @param[in] shader The shader this renderer will use */ - void SetGeometry( BufferIndex bufferIndex, Geometry* material); + void SetShader(Shader* shader); /** - * Get the geometry of this renderer - * @return the geometry this renderer uses + * @copydoc RenderDataProvider::GetShader() */ - Geometry& GetGeometry() + const Shader& GetShader() const override { - return *mGeometry; + return *mShader; } /** + * Set the geometry for the renderer + * @param[in] geometry The geometry this renderer will use + */ + void SetGeometry(Render::Geometry* geometry); + + /** * Set the depth index * @param[in] depthIndex the new depth index to use */ - void SetDepthIndex( int depthIndex ); + void SetDepthIndex(int depthIndex); /** * @brief Get the depth index @@ -123,211 +267,398 @@ public: } /** - * Called when an actor with this renderer is added to the stage + * Set the face culling mode + * @param[in] faceCullingMode to use */ - void OnStageConnect(); + void SetFaceCullingMode(FaceCullingMode::Type faceCullingMode); - /* - * Called when an actor with this renderer is removed from the stage + /** + * Get face culling mode + * @return The face culling mode */ - void OnStageDisconnect(); + FaceCullingMode::Type GetFaceCullingMode() const; /** - * Prepare the object for rendering. - * This is called by the UpdateManager when an object is due to be rendered in the current frame. + * Set the blending mode + * @param[in] blendingMode to use + */ + void SetBlendMode(BlendMode::Type blendingMode); + + /** + * Get the blending mode + * @return The the blending mode + */ + BlendMode::Type GetBlendMode() const; + + /** + * Set the blending options. This should only be called from the update thread. + * @param[in] options A bitmask of blending options. + */ + void SetBlendingOptions(uint32_t options); + + /** + * Get the blending options + * @return The the blending mode + */ + uint32_t GetBlendingOptions() const; + + /** + * Set the blend color for blending operation + * @param blendColor to pass to GL + */ + void SetBlendColor(const Vector4& blendColor); + + /** + * Get the blending color + * @return The blend color + */ + Vector4 GetBlendColor() const; + + /** + * Set the index of first element for indexed draw + * @param[in] firstElement index of first element to draw + */ + void SetIndexedDrawFirstElement(uint32_t firstElement); + + /** + * Get the index of first element for indexed draw + * @return The index of first element for indexed draw + */ + uint32_t GetIndexedDrawFirstElement() const; + + /** + * Set the number of elements to draw by indexed draw + * @param[in] elementsCount number of elements to draw + */ + void SetIndexedDrawElementsCount(uint32_t elementsCount); + + /** + * Get the number of elements to draw by indexed draw + * @return The number of elements to draw by indexed draw + */ + uint32_t GetIndexedDrawElementsCount() const; + + /** + * @brief Set whether the Pre-multiplied Alpha Blending is required + * @param[in] preMultipled whether alpha is pre-multiplied. + */ + void EnablePreMultipliedAlpha(bool preMultipled); + + /** + * @brief Query whether alpha is pre-multiplied. + * @return True is alpha is pre-multiplied, false otherwise. + */ + bool IsPreMultipliedAlphaEnabled() const; + + /** + * Sets the depth buffer write mode + * @param[in] depthWriteMode The depth buffer write mode + */ + void SetDepthWriteMode(DepthWriteMode::Type depthWriteMode); + + /** + * Get the depth buffer write mode + * @return The depth buffer write mode + */ + DepthWriteMode::Type GetDepthWriteMode() const; + + /** + * Sets the depth buffer test mode + * @param[in] depthTestMode The depth buffer test mode + */ + void SetDepthTestMode(DepthTestMode::Type depthTestMode); + + /** + * Get the depth buffer test mode + * @return The depth buffer test mode + */ + DepthTestMode::Type GetDepthTestMode() const; + + /** + * Sets the depth function + * @param[in] depthFunction The depth function + */ + void SetDepthFunction(DepthFunction::Type depthFunction); + + /** + * Get the depth function + * @return The depth function + */ + DepthFunction::Type GetDepthFunction() const; + + /** + * Sets the render mode + * @param[in] mode The render mode + */ + void SetRenderMode(RenderMode::Type mode); + + /** + * Sets the stencil function + * @param[in] stencilFunction The stencil function + */ + void SetStencilFunction(StencilFunction::Type stencilFunction); + + /** + * Sets the stencil function mask + * @param[in] stencilFunctionMask The stencil function mask + */ + void SetStencilFunctionMask(int stencilFunctionMask); + + /** + * Sets the stencil function reference + * @param[in] stencilFunctionReference The stencil function reference + */ + void SetStencilFunctionReference(int stencilFunctionReference); + + /** + * Sets the stencil mask + * @param[in] stencilMask The stencil mask + */ + void SetStencilMask(int stencilMask); + + /** + * Sets the stencil operation for when the stencil test fails + * @param[in] stencilOperationOnFail The stencil operation + */ + void SetStencilOperationOnFail(StencilOperation::Type stencilOperationOnFail); + + /** + * Sets the stencil operation for when the depth test fails + * @param[in] stencilOperationOnZFail The stencil operation + */ + void SetStencilOperationOnZFail(StencilOperation::Type stencilOperationOnZFail); + + /** + * Sets the stencil operation for when the depth test passes + * @param[in] stencilOperationOnZPass The stencil operation + */ + void SetStencilOperationOnZPass(StencilOperation::Type stencilOperationOnZPass); + + /** + * Gets the stencil parameters + * @return The stencil parameters + */ + const Render::Renderer::StencilParameters& GetStencilParameters() const; + + /** + * Bakes the opacity * @param[in] updateBufferIndex The current update buffer index. + * @param[in] opacity The opacity */ - void PrepareRender( BufferIndex updateBufferIndex ); + void BakeOpacity(BufferIndex updateBufferIndex, float opacity); - /* - * Retrieve the Render thread renderer - * @return The associated render thread renderer + /** + * @copydoc RenderDataProvider::GetOpacity() */ - Render::Renderer& GetRenderer(); + float GetOpacity(BufferIndex updateBufferIndex) const override; /** - * Check whether the renderer has been marked as ready to render - * ready means that renderer has all resources and should produce correct result - * complete means all resources have finished loading - * It's possible that renderer is complete but not ready, - * for example in case of resource load failed - * @param[out] ready TRUE if the renderer has resources to render - * @param[out] complete TRUE if the renderer resources are complete + * Sets the rendering behavior + * @param[in] renderingBehavior The rendering behavior required. */ - void GetReadyAndComplete( bool& ready, bool& complete ) const; + void SetRenderingBehavior(DevelRenderer::Rendering::Type renderingBehavior); /** - * Query whether the renderer is fully opaque, fully transparent or transparent. + * Gets the rendering behavior + * @return The rendering behavior + */ + DevelRenderer::Rendering::Type GetRenderingBehavior() const; + + /** + * Prepare the object for rendering. + * This is called by the UpdateManager when an object is due to be rendered in the current frame. * @param[in] updateBufferIndex The current update buffer index. - * @return OPAQUE if fully opaque, TRANSPARENT if fully transparent and TRANSLUCENT if in between + * @return Whether this renderer has been updated in the current frame */ - Opacity GetOpacity( BufferIndex updateBufferIndex, const Node& node ) const; + bool PrepareRender(BufferIndex updateBufferIndex); /** - * Query whether the renderer is currently in use by an actor on the stage + * Retrieve the Render thread renderer + * @return The associated render thread renderer */ - bool IsReferenced() const - { - return mReferenceCount > 0; - } + Render::RendererKey GetRenderer(); + /** + * Query whether the renderer is fully opaque, fully transparent or transparent. + * @param[in] updateBufferIndex The current update buffer index. + * @return OPAQUE if fully opaque, TRANSPARENT if fully transparent and TRANSLUCENT if in between + */ + OpacityType GetOpacityType(BufferIndex updateBufferIndex, const Node& node) const; -public: // Implementation of ObjectOwnerContainer template methods /** * Connect the object to the scene graph * * @param[in] sceneController The scene controller - used for sending messages to render thread * @param[in] bufferIndex The current buffer index - used for sending messages to render thread */ - void ConnectToSceneGraph( SceneController& sceneController, BufferIndex bufferIndex ); + void ConnectToSceneGraph(SceneController& sceneController, BufferIndex bufferIndex); /** * Disconnect the object from the scene graph * @param[in] sceneController The scene controller - used for sending messages to render thread * @param[in] bufferIndex The current buffer index - used for sending messages to render thread */ - void DisconnectFromSceneGraph( SceneController& sceneController, BufferIndex bufferIndex ); + void DisconnectFromSceneGraph(SceneController& sceneController, BufferIndex bufferIndex); + + /** + * @copydoc RenderDataProvider::GetUniformMapDataProvider() + */ + const UniformMapDataProvider& GetUniformMapDataProvider() const override + { + return *this; + }; -public: // Implementation of ConnectionChangePropagator /** - * @copydoc ConnectionChangePropagator::AddObserver + * @copydoc RenderDataProvider::IsUpdated() */ - void AddConnectionObserver(ConnectionChangePropagator::Observer& observer){}; + bool IsUpdated() const override; /** - * @copydoc ConnectionChangePropagator::RemoveObserver + * @copydoc RenderDataProvider::GetVisualTransformedUpdateArea() */ - void RemoveConnectionObserver(ConnectionChangePropagator::Observer& observer){}; + Vector4 GetVisualTransformedUpdateArea(BufferIndex updateBufferIndex, const Vector4& originalUpdateArea) noexcept override; -public: + /** + * Sets RenderCallback object + * + * @param[in] callback Valid pointer to RenderCallback object + */ + void SetRenderCallback(RenderCallback* callback); + + /** + * Returns currently set RenderCallback pointer + * + * @return RenderCallback pointer or nullptr + */ + RenderCallback* GetRenderCallback() + { + return mRenderCallback; + } + /** + * Merge shader uniform map into renderer uniform map if any of the + * maps have changed. Only update uniform map if added to render + * instructions. + * @param[in] updateBufferIndex The current update buffer index. + */ + void UpdateUniformMap(BufferIndex updateBufferIndex); -public: // UniformMap::Observer /** - * @copydoc UniformMap::Observer::UniformMappingsChanged + * Set the given external draw commands on this renderer. */ - virtual void UniformMappingsChanged( const UniformMap& mappings ); + void SetDrawCommands(Dali::DevelRenderer::DrawCommand* pDrawCommands, uint32_t size); -public: // ConnectionChangePropagator::Observer + /** + * Query whether a renderer is dirty. + * @return true if the renderer is dirty. + * @note It is used to decide whether to reuse the RenderList. We can't reuse the RenderList if this is dirty. + */ + bool IsDirty() const; /** - * @copydoc ConnectionChangePropagator::ConnectionsChanged + * Reset both dirty flag and updated flag. + * @note This is called after rendering has completed. */ - virtual void ConnectionsChanged( PropertyOwner& owner ); + void ResetDirtyFlag(); /** - * @copydoc ConnectionChangePropagator::ConnectedUniformMapChanged + * Get the capacity of the memory pools + * @return the capacity of the memory pools */ - virtual void ConnectedUniformMapChanged( ); + static uint32_t GetMemoryPoolCapacity(); +public: // PropertyOwner::MappingChanged /** - * @copydoc ConnectionChangePropagator::ConnectedUniformMapChanged + * @copydoc PropertyOwner::OnMappingChanged */ - virtual void ObservedObjectDestroyed(PropertyOwner& owner); + void OnMappingChanged() override; public: // PropertyOwner implementation /** * @copydoc Dali::Internal::SceneGraph::PropertyOwner::ResetDefaultProperties() */ - virtual void ResetDefaultProperties( BufferIndex updateBufferIndex ){}; + virtual void ResetDefaultProperties(BufferIndex updateBufferIndex){}; public: // From UniformMapDataProvider + /** + * @copydoc UniformMapDataProvider::GetCollectedUniformMap + */ + const CollectedUniformMap& GetCollectedUniformMap() const override; +public: // For VisualProperties /** - * @copydoc UniformMapDataProvider::GetUniformMapChanged + * To be used only for 1st stage initialization in event thread. */ - virtual bool GetUniformMapChanged( BufferIndex bufferIndex ) const{ return mUniformMapChanged[bufferIndex];} + void SetVisualProperties(VisualRenderer::AnimatableVisualProperties* visualProperties) + { + mVisualProperties = visualProperties; + } /** - * @copydoc UniformMapDataProvider::GetUniformMap + * May be accessed from event thread */ - virtual const CollectedUniformMap& GetUniformMap( BufferIndex bufferIndex ) const; + const VisualRenderer::AnimatableVisualProperties* GetVisualProperties() const + { + return mVisualProperties.Get(); + } private: - /** - * Helper function to create a new render data provider - * @return the new (initialized) data provider + * Protected constructor; See also Renderer::New() */ - RenderDataProvider* NewRenderDataProvider(); - - SceneController* mSceneController; ///< Used for initializing renderers whilst attached - Render::Renderer* mRenderer; ///< Raw pointer to the new renderer (that's owned by RenderManager) - Material* mMaterial; ///< The material this renderer uses. (Not owned) - Geometry* mGeometry; ///< The geometry this renderer uses. (Not owned) - - CollectedUniformMap mCollectedUniformMap[2]; ///< Uniform maps collected by the renderer - unsigned int mReferenceCount; ///< Number of nodes currently using this renderer - unsigned int mRegenerateUniformMap; ///< 2 if the map should be regenerated, 1 if it should be copied. - bool mUniformMapChanged[2]; ///< Records if the uniform map has been altered this frame - bool mResendDataProviders; ///< True if the data providers should be resent to the renderer - bool mResendGeometry; ///< True if geometry should be resent to the renderer - bool mResourcesReady; ///< Set during the Update algorithm; true if the attachment has resources ready for the current frame. - bool mFinishedResourceAcquisition; ///< Set during DoPrepareResources; true if ready & all resource acquisition has finished (successfully or otherwise) - -public: - int mDepthIndex; ///< Used only in PrepareRenderInstructions -}; - - -/// Messages -inline void SetMaterialMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, const Material& material ) -{ - typedef MessageDoubleBuffered1< Renderer, Material* > LocalType; - - // Reserve some memory inside the message queue - unsigned int* 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::SetMaterial, const_cast(&material) ); -} - -inline void SetGeometryMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, const Geometry& geometry ) -{ - typedef MessageDoubleBuffered1< Renderer, Geometry* > LocalType; - - // Reserve some memory inside the message queue - unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) ); + Renderer(); - // 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(&geometry) ); -} +private: + enum Decay + { + DONE = 0, + LAST = 1, + INITIAL = 2 + }; -inline void SetDepthIndexMessage( EventThreadServices& eventThreadServices, const Renderer& attachment, int depthIndex ) -{ - typedef MessageValue1< Renderer, int > LocalType; +private: + CollectedUniformMap mCollectedUniformMap; ///< Uniform maps collected by the renderer - // Reserve some memory inside the message queue - unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) ); + 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) - // Construct message in the message queue memory; note that delete should not be called on the return value - new (slot) LocalType( &attachment, &Renderer::SetDepthIndex, depthIndex ); -} + OwnerPointer mVisualProperties{nullptr}; ///< VisualProperties (optional/owned) + OwnerPointer mBlendColor; ///< The blend color for blending operation -inline void OnStageConnectMessage( EventThreadServices& eventThreadServices, const Renderer& renderer ) -{ - typedef Message< Renderer > LocalType; + Dali::Internal::Render::Renderer::StencilParameters mStencilParameters; ///< Struct containing all stencil related options - // Reserve some memory inside the message queue - unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) ); + 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 + 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 - // Construct message in the message queue memory; note that delete should not be called on the return value - new (slot) LocalType( &renderer, &Renderer::OnStageConnect ); -} + DepthFunction::Type mDepthFunction : 4; ///< Local copy of the depth function + FaceCullingMode::Type mFaceCullingMode : 3; ///< Local copy of the mode of face culling + BlendMode::Type mBlendMode : 3; ///< Local copy of the mode of blending + DepthWriteMode::Type mDepthWriteMode : 3; ///< Local copy of the depth write mode + DepthTestMode::Type mDepthTestMode : 3; ///< Local copy of the depth test mode + DevelRenderer::Rendering::Type mRenderingBehavior : 2; ///< The rendering behavior + Decay mUpdateDecay : 2; ///< Update decay (aging) -inline void OnStageDisconnectMessage( EventThreadServices& eventThreadServices, const Renderer& renderer ) -{ - typedef Message< Renderer > LocalType; + 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 - // Reserve some memory inside the message queue - unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) ); + std::vector mDrawCommands; + Dali::RenderCallback* mRenderCallback{nullptr}; - // Construct message in the message queue memory; note that delete should not be called on the return value - new (slot) LocalType( &renderer, &Renderer::OnStageDisconnect ); -} +public: + AnimatableProperty mOpacity; ///< The opacity value + int32_t mDepthIndex; ///< Used only in PrepareRenderInstructions +}; } // namespace SceneGraph } // namespace Internal } // namespace Dali -#endif // DALI_INTERNAL_SCENE_GRAPH_RENDERER_H +#endif // DALI_INTERNAL_SCENE_GRAPH_RENDERER_H