X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Fupdate%2Frendering%2Fscene-graph-renderer.h;h=f1ef2a729a9cc88d88db203ac1c2d19f54949afc;hb=649ec06daecb510fb84fe4642a6af957f127e7ab;hp=748a059d2737d4525dc6e4f6b75e67933729d66e;hpb=2f8cc65e1dab6e1d2d76d908e2b34ce39f8c69a1;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 748a059..f1ef2a7 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) 2018 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,39 +17,40 @@ * limitations under the License. */ - -#include +#include +#include // Dali::Renderer +#include +#include #include -#include -#include -#include #include -#include #include #include +#include #include -#include -#include +#include namespace Dali { + namespace Internal { namespace Render { -class NewRenderer; +class Renderer; +class Geometry; } 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, @@ -59,10 +60,17 @@ class Renderer : public PropertyOwner, { public: + enum OpacityType + { + OPAQUE, + TRANSPARENT, + TRANSLUCENT + }; + /** - * Default constructor + * Construct a new Renderer */ - Renderer(); + static Renderer* New(); /** * Destructor @@ -70,38 +78,48 @@ public: virtual ~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 + * Overriden delete operator + * Deletes the renderer from its global memory pool */ - void SetMaterial( BufferIndex bufferIndex, Material* material); + void operator delete( void* ptr ); /** - * 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 ); + + /** + * Returns current texture set object + * @return Pointer to the texture set + */ + const TextureSet* GetTextures() 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 + * 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 + * Get the shader used by this renderer + * @return the shader this renderer uses */ - Geometry& GetGeometry() + const Shader& GetShader() const { - 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 */ @@ -117,14 +135,192 @@ public: } /** - * Called when an actor with this renderer is added to the stage + * Set the face culling mode + * @param[in] faceCullingMode to use + */ + void SetFaceCullingMode( FaceCullingMode::Type faceCullingMode ); + + /** + * Get face culling mode + * @return The face culling mode + */ + FaceCullingMode::Type GetFaceCullingMode() const; + + /** + * 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( unsigned int options ); + + /** + * Get the blending options + * @return The the blending mode */ - void OnStageConnect(); + unsigned int GetBlendingOptions() const; - /* - * Called when an actor with this renderer is removed from the stage + /** + * 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( size_t firstElement ); + + /** + * Get the index of first element for indexed draw + * @return The index of first element for indexed draw + */ + size_t GetIndexedDrawFirstElement() const; + + /** + * Set the number of elements to draw by indexed draw + * @param[in] elementsCount number of elements to draw + */ + void SetIndexedDrawElementsCount( size_t elementsCount ); + + /** + * Get the number of elements to draw by indexed draw + * @return The number of elements to draw by indexed draw */ - void OnStageDisconnect(); + size_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 BakeOpacity( BufferIndex updateBufferIndex, float opacity ); + + /** + * Gets the opacity + * @param[in] bufferIndex The buffer to read from. + * @return The opacity + */ + float GetOpacity( BufferIndex updateBufferIndex ) const; /** * Prepare the object for rendering. @@ -133,46 +329,29 @@ public: */ void PrepareRender( BufferIndex updateBufferIndex ); - /* + /** * Retrieve the Render thread renderer * @return The associated render thread renderer */ Render::Renderer& GetRenderer(); /** - * Prepare the object resources. - * This must be called by the UpdateManager before calling PrepareRender, for each frame. - * @param[in] updateBufferIndex The current update buffer index. - * @param[in] resourceManager The resource manager. - */ - void PrepareResources( BufferIndex updateBufferIndex, ResourceManager& resourceManager ); - - /** - * Check whether the renderer has been marked as ready to render - * @param[out] ready TRUE if the renderer has resources to render - * @param[out] complete TRUE if the renderer resources are complete - * (e.g. image has finished loading, framebuffer is ready to render, native image - * framebuffer has been rendered) + * 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 */ - void GetReadyAndComplete(bool& ready, bool& complete) const; + OpacityType GetOpacityType( BufferIndex updateBufferIndex, const Node& node ) const; /** - * Query whether the renderer is fully opaque. - * @param[in] updateBufferIndex The current update buffer index. - * @return True if fully opaque. + * Called by the TextureSet to notify to the renderer that it has changed */ - bool IsFullyOpaque( BufferIndex updateBufferIndex, const Node& node ) const; + void TextureSetChanged(); /** - * Query whether the renderer is currently in use by an actor on the stage + * Called by the TextureSet to notify to the renderer that it is about to be deleted */ - bool IsReferenced() const - { - return mReferenceCount > 0; - } + void TextureSetDeleted(); - -public: // Implementation of ObjectOwnerContainer template methods /** * Connect the object to the scene graph * @@ -199,9 +378,6 @@ public: // Implementation of ConnectionChangePropagator */ void RemoveConnectionObserver(ConnectionChangePropagator::Observer& observer){}; -public: - - public: // UniformMap::Observer /** * @copydoc UniformMap::Observer::UniformMappingsChanged @@ -246,87 +422,285 @@ public: // From UniformMapDataProvider private: /** - * Helper function to create a new render data provider - * @return the new (initialized) data provider + * Protected constructor; See also Renderer::New() + */ + Renderer(); + + /** + * Update texture set to the render data provider */ - RenderDataProvider* NewRenderDataProvider(); + void UpdateTextureSet(); - SceneController* mSceneController; ///< Used for initializing renderers whilst attached - Render::NewRenderer* 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) +private: + + CollectedUniformMap mCollectedUniformMap[2]; ///< 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) + RenderDataProvider* mRenderDataProvider; ///< The render data provider + OwnerPointer< Vector4 > mBlendColor; ///< The blend color for blending operation + + Dali::Internal::Render::Renderer::StencilParameters mStencilParameters; ///< Struct containing all stencil related options - Dali::Vector< Integration::ResourceId > mTrackedResources; ///< Filled during PrepareResources if there are uncomplete, tracked resources. + size_t mIndexedDrawFirstElement; ///< first element index to be drawn using indexed draw + size_t mIndexedDrawElementsCount; ///< number of elements to be drawn using indexed draw + unsigned int mBlendBitmask; ///< The bitmask of blending options + unsigned int mRegenerateUniformMap; ///< 2 if the map should be regenerated, 1 if it should be copied. + unsigned int mResendFlag; ///< Indicate whether data should be resent to the renderer - 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 : 1; ///< True if the data providers should be resent to the renderer - bool mResendGeometry : 1; ///< True if geometry should be resent to the renderer - bool mHasUntrackedResources : 1; ///< Set during PrepareResources, true if have tried to follow untracked resources - bool mFinishedResourceAcquisition : 1; ///< Set during DoPrepareResources; true if ready & all resource acquisition has finished (successfully or otherwise) - bool mResourcesReady : 1; ///< Set during the Update algorithm; true if the attachment has resources ready for the current frame. + DepthFunction::Type mDepthFunction:3; ///< Local copy of the depth function + FaceCullingMode::Type mFaceCullingMode:2; ///< Local copy of the mode of face culling + BlendMode::Type mBlendMode:2; ///< Local copy of the mode of blending + DepthWriteMode::Type mDepthWriteMode:2; ///< Local copy of the depth write mode + DepthTestMode::Type mDepthTestMode:2; ///< Local copy of the depth test mode + + bool mUniformMapChanged[2]; ///< Records if the uniform map has been altered this frame + bool mPremultipledAlphaEnabled:1; ///< Flag indicating whether the Pre-multiplied Alpha Blending is required public: - int mDepthIndex; ///< Used only in PrepareRenderInstructions + + AnimatableProperty< float > mOpacity; ///< The opacity value + int mDepthIndex; ///< Used only in PrepareRenderInstructions + }; /// Messages -inline void SetMaterialMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, const Material& material ) +inline void SetTexturesMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, const TextureSet& textureSet ) { - typedef MessageDoubleBuffered1< Renderer, Material* > LocalType; + typedef MessageValue1< Renderer, TextureSet* > 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) ); + new (slot) LocalType( &renderer, &Renderer::SetTextures, const_cast(&textureSet) ); } -inline void SetGeometryMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, const Geometry& geometry ) +inline void SetGeometryMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, const Render::Geometry& geometry ) { - typedef MessageDoubleBuffered1< Renderer, Geometry* > LocalType; + typedef MessageValue1< Renderer, Render::Geometry* > 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::SetGeometry, const_cast(&geometry) ); + new (slot) LocalType( &renderer, &Renderer::SetGeometry, const_cast(&geometry) ); } -inline void SetDepthIndexMessage( EventThreadServices& eventThreadServices, const Renderer& attachment, int depthIndex ) +inline void SetShaderMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, Shader& shader ) { - typedef MessageValue1< Renderer, int > LocalType; + typedef MessageValue1< Renderer, Shader* > 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( &attachment, &Renderer::SetDepthIndex, depthIndex ); + new (slot) LocalType( &renderer, &Renderer::SetShader, &shader ); } -inline void OnStageConnectMessage( EventThreadServices& eventThreadServices, const Renderer& renderer ) +inline void SetDepthIndexMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, int depthIndex ) { - typedef Message< Renderer > LocalType; + typedef MessageValue1< Renderer, int > 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::OnStageConnect ); + new (slot) LocalType( &renderer, &Renderer::SetDepthIndex, depthIndex ); } -inline void OnStageDisconnectMessage( EventThreadServices& eventThreadServices, const Renderer& renderer ) +inline void SetFaceCullingModeMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, FaceCullingMode::Type faceCullingMode ) { - typedef Message< Renderer > LocalType; + typedef MessageValue1< Renderer, FaceCullingMode::Type > 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::OnStageDisconnect ); + new (slot) LocalType( &renderer, &Renderer::SetFaceCullingMode, faceCullingMode ); +} + +inline void SetBlendModeMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, BlendMode::Type blendingMode ) +{ + typedef MessageValue1< Renderer, BlendMode::Type > LocalType; + + // Reserve some memory inside the message queue + unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) ); + + new (slot) LocalType( &renderer, &Renderer::SetBlendMode, blendingMode ); +} + +inline void SetBlendingOptionsMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, unsigned int options ) +{ + typedef MessageValue1< Renderer, unsigned int > LocalType; + + // Reserve some memory inside the message queue + unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) ); + + new (slot) LocalType( &renderer, &Renderer::SetBlendingOptions, options ); +} + +inline void SetBlendColorMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, const Vector4& blendColor ) +{ + typedef MessageValue1< Renderer, Vector4 > LocalType; + + // Reserve some memory inside the message queue + unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) ); + + new (slot) LocalType( &renderer, &Renderer::SetBlendColor, blendColor ); +} + +inline void SetIndexedDrawFirstElementMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, size_t firstElement ) +{ + typedef MessageValue1< Renderer, size_t > LocalType; + + // Reserve some memory inside the message queue + unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) ); + + new (slot) LocalType( &renderer, &Renderer::SetIndexedDrawFirstElement, firstElement ); +} + +inline void SetIndexedDrawElementsCountMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, size_t elementsCount ) +{ + typedef MessageValue1< Renderer, size_t > LocalType; + + // Reserve some memory inside the message queue + unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) ); + + new (slot) LocalType( &renderer, &Renderer::SetIndexedDrawElementsCount, elementsCount ); +} + +inline void SetEnablePreMultipliedAlphaMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, bool preMultiplied ) +{ + typedef MessageValue1< Renderer, bool > LocalType; + + // Reserve some memory inside the message queue + unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) ); + + new (slot) LocalType( &renderer, &Renderer::EnablePreMultipliedAlpha, preMultiplied ); +} + +inline void SetDepthWriteModeMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, DepthWriteMode::Type depthWriteMode ) +{ + typedef MessageValue1< Renderer, DepthWriteMode::Type > LocalType; + + // Reserve some memory inside the message queue + unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) ); + + new (slot) LocalType( &renderer, &Renderer::SetDepthWriteMode, depthWriteMode ); +} + +inline void SetDepthTestModeMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, DepthTestMode::Type depthTestMode ) +{ + typedef MessageValue1< Renderer, DepthTestMode::Type > LocalType; + + // Reserve some memory inside the message queue + unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) ); + + new (slot) LocalType( &renderer, &Renderer::SetDepthTestMode, depthTestMode ); +} + +inline void SetDepthFunctionMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, DepthFunction::Type depthFunction ) +{ + typedef MessageValue1< Renderer, DepthFunction::Type > LocalType; + + // Reserve some memory inside the message queue + unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) ); + + new (slot) LocalType( &renderer, &Renderer::SetDepthFunction, depthFunction ); +} + +inline void SetRenderModeMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, RenderMode::Type mode ) +{ + typedef MessageValue1< Renderer, RenderMode::Type > LocalType; + + // Reserve some memory inside the message queue + unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) ); + + new (slot) LocalType( &renderer, &Renderer::SetRenderMode, mode ); +} + +inline void SetStencilFunctionMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, StencilFunction::Type stencilFunction ) +{ + typedef MessageValue1< Renderer, StencilFunction::Type > LocalType; + + // Reserve some memory inside the message queue + unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) ); + + new (slot) LocalType( &renderer, &Renderer::SetStencilFunction, stencilFunction ); +} + +inline void SetStencilFunctionMaskMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, int mask ) +{ + typedef MessageValue1< Renderer, int > LocalType; + + // Reserve some memory inside the message queue + unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) ); + + new (slot) LocalType( &renderer, &Renderer::SetStencilFunctionMask, mask ); +} + +inline void SetStencilFunctionReferenceMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, int stencilFunctionReference ) +{ + typedef MessageValue1< Renderer, int > LocalType; + + // Reserve some memory inside the message queue + unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) ); + + new (slot) LocalType( &renderer, &Renderer::SetStencilFunctionReference, stencilFunctionReference ); +} + +inline void SetStencilMaskMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, int stencilMask ) +{ + typedef MessageValue1< Renderer, int > LocalType; + + // Reserve some memory inside the message queue + unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) ); + + new (slot) LocalType( &renderer, &Renderer::SetStencilMask, stencilMask ); +} + +inline void SetStencilOperationOnFailMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, StencilOperation::Type stencilOperation ) +{ + typedef MessageValue1< Renderer, StencilOperation::Type > LocalType; + + // Reserve some memory inside the message queue + unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) ); + + new (slot) LocalType( &renderer, &Renderer::SetStencilOperationOnFail, stencilOperation ); +} + +inline void SetStencilOperationOnZFailMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, StencilOperation::Type stencilOperation ) +{ + typedef MessageValue1< Renderer, StencilOperation::Type > LocalType; + + // Reserve some memory inside the message queue + unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) ); + + new (slot) LocalType( &renderer, &Renderer::SetStencilOperationOnZFail, stencilOperation ); +} + +inline void SetStencilOperationOnZPassMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, StencilOperation::Type stencilOperation ) +{ + typedef MessageValue1< Renderer, StencilOperation::Type > LocalType; + + // Reserve some memory inside the message queue + unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) ); + + new (slot) LocalType( &renderer, &Renderer::SetStencilOperationOnZPass, stencilOperation ); +} + +inline void BakeOpacityMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, float opacity ) +{ + typedef MessageDoubleBuffered1< Renderer, float > LocalType; + + // Reserve some memory inside the message queue + unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) ); + + new (slot) LocalType( &renderer, &Renderer::BakeOpacity, opacity ); } } // namespace SceneGraph