- Removed API to set ( and get ) if a geometry requires writing to the depth buffer when rendering
- Added a property in renderer to specify whether the renderer requires writing to the depth buffer.
- Clean-up shader hints. Removed hints which were not used (i.e never checked)
Change-Id: I4c4b4f17382cefb5b94850c4cc93e64951bf9607
END_TEST;
}
-int UtcDaliGeometrySetGetRequireDepthTesting(void)
-{
- TestApplication application;
-
- tet_infoline("Test SetRequiresDepthTesting, GetRequiresDepthTesting");
-
- Shader shader = Shader::New("VertexSource", "FragmentSource");
- Geometry geometry = CreateQuadGeometry();
- Renderer renderer = Renderer::New( geometry, shader );
-
- Actor actor = Actor::New();
- actor.AddRenderer(renderer);
- actor.SetSize(400, 400);
- Stage::GetCurrent().Add(actor);
-
- DALI_TEST_EQUALS( geometry.GetRequiresDepthTesting(), false, TEST_LOCATION );
-
- geometry.SetRequiresDepthTesting(true);
-
- TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
- glAbstraction.EnableEnableDisableCallTrace(true);
- application.SendNotification();
- application.Render();
-// TODO: Not supported yes
-// TraceCallStack& glEnableStack = glAbstraction.GetEnableDisableTrace();
-// std::ostringstream out;
-// out << GL_DEPTH_TEST;
-// DALI_TEST_CHECK( glEnableStack.FindMethodAndParams( "Enable", out.str().c_str() ) );
-
- DALI_TEST_EQUALS( geometry.GetRequiresDepthTesting(), true, TEST_LOCATION );
-
- END_TEST;
-}
-
// By default, none of the faces should be culled
unsigned int cullFace = renderer.GetProperty<int>( Renderer::Property::FACE_CULLING_MODE );
- DALI_TEST_CHECK( static_cast< Dali::Renderer::FaceCullingMode >( cullFace ) == Renderer::NONE );
+ DALI_TEST_CHECK( static_cast< Dali::Renderer::FaceCullingMode >( cullFace ) == Renderer::CULL_NONE );
TestGlAbstraction& gl = application.GetGlAbstraction();
TraceCallStack& cullFaceStack = gl.GetCullFaceTrace();
{
cullFaceStack.Reset();
- renderer.SetProperty( Renderer::Property::FACE_CULLING_MODE, Renderer::NONE );
+ renderer.SetProperty( Renderer::Property::FACE_CULLING_MODE, Renderer::CULL_NONE );
application.SendNotification();
application.Render();
DALI_TEST_EQUALS( cullFaceStack.CountMethod( "CullFace" ), 0, TEST_LOCATION );
cullFace = renderer.GetProperty<int>( Renderer::Property::FACE_CULLING_MODE );
- DALI_TEST_CHECK( static_cast< Dali::Renderer::FaceCullingMode >( cullFace ) == Renderer::NONE );
+ DALI_TEST_CHECK( static_cast< Dali::Renderer::FaceCullingMode >( cullFace ) == Renderer::CULL_NONE );
}
END_TEST;
tet_infoline("Test setting the blend mode to auto with an opaque color and an image without an alpha channel and a shader with the hint OUTPUT_IS_OPAQUE renders with blending disabled");
Geometry geometry = CreateQuadGeometry();
- Shader shader = Shader::New( "vertexSrc", "fragmentSrc", Shader::HINT_OUTPUT_IS_OPAQUE );
+ Shader shader = Shader::New( "vertexSrc", "fragmentSrc" );
BufferImage image = BufferImage::New( 50, 50, Pixel::RGB888 );
TextureSet textureSet = CreateTextureSet( image );
tet_infoline("Test GetBlendMode()");
Geometry geometry = CreateQuadGeometry();
- Shader shader = Shader::New( "vertexSrc", "fragmentSrc", Shader::HINT_OUTPUT_IS_OPAQUE );
+ Shader shader = Shader::New( "vertexSrc", "fragmentSrc" );
Renderer renderer = Renderer::New( geometry, shader );
// default value
tet_infoline("Test SetBlendColor(color)");
Geometry geometry = CreateQuadGeometry();
- Shader shader = Shader::New( "vertexSrc", "fragmentSrc", Shader::HINT_OUTPUT_IS_OPAQUE );
+ Shader shader = Shader::New( "vertexSrc", "fragmentSrc" );
TextureSet textureSet = TextureSet::New();
BufferImage image = BufferImage::New( 50, 50, Pixel::RGBA8888 );
textureSet.SetImage( 0u, image );
tet_infoline("Test GetBlendColor()");
Geometry geometry = CreateQuadGeometry();
- Shader shader = Shader::New( "vertexSrc", "fragmentSrc", Shader::HINT_OUTPUT_IS_OPAQUE );
+ Shader shader = Shader::New( "vertexSrc", "fragmentSrc" );
Renderer renderer = Renderer::New( geometry, shader );
DALI_TEST_EQUALS( renderer.GetProperty<Vector4>( Renderer::Property::BLENDING_COLOR ), Color::TRANSPARENT, TEST_LOCATION );
tet_infoline("Test BLEND_PRE_MULTIPLIED_ALPHA property");
Geometry geometry = CreateQuadGeometry();
- Shader shader = Shader::New( "vertexSrc", "fragmentSrc", Shader::HINT_OUTPUT_IS_OPAQUE );
+ Shader shader = Shader::New( "vertexSrc", "fragmentSrc" );
Renderer renderer = Renderer::New( geometry, shader );
Actor actor = Actor::New();
tet_infoline("Test get/set progam property");
Shader shader = Shader::New("", "");
- std::string hintSet = "HINT_REQUIRES_SELF_DEPTH_TEST,HINT_MODIFIES_GEOMETRY";
+ std::string hintSet = "HINT_MODIFIES_GEOMETRY";
Property::Map map;
map["vertex"] = VertexSource;
std::string hintGot;
- hintSet = "HINT_REQUIRES_SELF_DEPTH_TEST,HINT_OUTPUT_IS_TRANSPARENT,HINT_OUTPUT_IS_OPAQUE,HINT_MODIFIES_GEOMETRY";
+ hintSet = "HINT_OUTPUT_IS_TRANSPARENT,HINT_MODIFIES_GEOMETRY";
map["hints"] = hintSet;
shader.SetProperty( Shader::Property::PROGRAM, Property::Value(map) );
value = shader.GetProperty(Shader::Property::PROGRAM);
hintGot = (*value.GetMap())["hints"].Get<std::string>();
DALI_TEST_CHECK( hintGot == hintSet );
- hintSet = "HINT_REQUIRES_SELF_DEPTH_TEST";
+ hintSet = "HINT_OUTPUT_IS_TRANSPARENT";
map["hints"] = hintSet;
shader.SetProperty( Shader::Property::PROGRAM, Property::Value(map) );
value = shader.GetProperty(Shader::Property::PROGRAM);
return GetImplementation(*this).GetGeometryType();
}
-void Geometry::SetRequiresDepthTesting( bool requiresDepthTest )
-{
- GetImplementation(*this).SetRequiresDepthTesting( requiresDepthTest );
-}
-
-bool Geometry::GetRequiresDepthTesting() const
-{
- return GetImplementation(*this).GetRequiresDepthTesting();
-}
-
Geometry::Geometry( Internal::Geometry* pointer )
: BaseHandle( pointer )
{
*/
GeometryType GetGeometryType() const;
- /**
- * @brief Set if the geometry requires depth testing
- *
- * Should be set to true if this geometry has overlapping triangles in arbitrary order
- *
- * Calling this function is equivalent to setting the REQUIRES_DEPTH_TESTING property
- *
- * @param[in] requiresDepthTest Specifies if the geometry requires depth testing
- */
- void SetRequiresDepthTesting( bool requiresDepthTest );
-
- /**
- * @brief Return if the geometry requires depth testing
- *
- * @return True if the geometry requires depth testing
- */
- bool GetRequiresDepthTesting() const;
-
public:
/**
* @brief The constructor
*/
enum FaceCullingMode
{
- NONE, ///< None of the faces should be culled
+ CULL_NONE, ///< None of the faces should be culled
CULL_FRONT, ///< Cull front face, back face should never be shown
CULL_BACK, ///< Cull back face, back face should never be shown
CULL_BACK_AND_FRONT, ///< Cull back and front faces, if the geometry is composed of triangles none of the faces will be shown
};
/**
+ * @brief Depth buffer write modes
+ */
+ enum DepthWriteMode
+ {
+ DEPTH_WRITE_OFF, ///< Renderer doesn't write to the depth buffer
+ DEPTH_WRITE_AUTO, ///< Renderer only writes to the depth buffer if it's opaque
+ DEPTH_WRITE_ON ///< Renderer writes to the depth buffer
+ };
+
+ /**
* @brief An enumeration of properties belonging to the Renderer class.
*/
struct Property
enum
{
DEPTH_INDEX = DEFAULT_OBJECT_PROPERTY_START_INDEX, ///< name "depthIndex", type INTEGER
- FACE_CULLING_MODE, ///< name "faceCullingMode", type INTEGER
+ FACE_CULLING_MODE, ///< name "faceCullingMode", type INTEGER @see FaceCullingMode
BLENDING_MODE, ///< name "blendingMode", type INTEGER
BLEND_EQUATION_RGB, ///< name "blendEquationRgb", type INTEGER
BLEND_EQUATION_ALPHA, ///< name "blendEquationAlpha", type INTEGER
BLENDING_COLOR, ///< name "blendingColor", type VECTOR4
BLEND_PRE_MULTIPLIED_ALPHA, ///< name "blendPreMultipledAlpha", type BOOLEAN
INDEX_RANGE_FIRST, ///< name "indexRangeFirst", type INTEGER
- INDEX_RANGE_COUNT ///< name "indexRangeCount", type INTEGER
+ INDEX_RANGE_COUNT, ///< name "indexRangeCount", type INTEGER
+ DEPTH_WRITE_MODE ///< name "depthWriteMode", type INTEGER @see DepthWriteMode
};
};
enum ShaderHints
{
HINT_NONE = 0x00, ///< no hints
- HINT_REQUIRES_SELF_DEPTH_TEST = 0x01, ///< Expects depth testing enabled
HINT_OUTPUT_IS_TRANSPARENT = 0x02, ///< Might generate transparent alpha from opaque inputs
- HINT_OUTPUT_IS_OPAQUE = 0x04, ///< Outputs opaque colors even if the inputs are transparent
HINT_MODIFIES_GEOMETRY = 0x08, ///< Might change position of vertices,
///< this option disables any culling optimizations
};
template <> struct ParameterType< Dali::Renderer::FaceCullingMode > : public BasicType< Dali::Renderer::FaceCullingMode > {};
template <> struct ParameterType< BlendingMode::Type > : public BasicType< BlendingMode::Type > {};
+template <> struct ParameterType< Dali::Renderer::DepthWriteMode > : public BasicType< Dali::Renderer::DepthWriteMode > {};
} //namespace Internal
Dali::Shader::ShaderHints ConvertHints( Dali::ShaderEffect::GeometryHints hints)
{
int convertedHints = Dali::Shader::HINT_NONE;
- if( hints & Dali::ShaderEffect::HINT_DEPTH_BUFFER )
- {
- convertedHints |= Dali::Shader::HINT_REQUIRES_SELF_DEPTH_TEST;
- }
+
if( hints & Dali::ShaderEffect::HINT_BLENDING )
{
convertedHints |= Dali::Shader::HINT_OUTPUT_IS_TRANSPARENT;
return mGeometryType;
}
-void Geometry::SetRequiresDepthTesting( bool requiresDepthTest )
-{
- if( requiresDepthTest != mRequiresDepthTest )
- {
- SceneGraph::SetGeometryRequiresDepthTestMessage(mEventThreadServices.GetUpdateManager(), *mRenderObject, requiresDepthTest );
-
- mRequiresDepthTest = requiresDepthTest;
- }
-}
-
-bool Geometry::GetRequiresDepthTesting() const
-{
- return mRequiresDepthTest;
-}
-
const Render::Geometry* Geometry::GetRenderObject() const
{
return mRenderObject;
Geometry::Geometry()
: mEventThreadServices( *Stage::GetCurrent() ),
mRenderObject( NULL ),
- mGeometryType(Dali::Geometry::TRIANGLES),
- mRequiresDepthTest(false)
+ mGeometryType(Dali::Geometry::TRIANGLES)
{
}
Dali::Geometry::GeometryType GetGeometryType() const;
/**
- * @copydoc Dali::Geometry::SetRequiresDepthTesting()
- */
- void SetRequiresDepthTesting( bool requiresDepthTest );
-
- /**
- * @copydoc Dali::Geometry::GetRequiresDepthTesting()
- */
- bool GetRequiresDepthTesting() const;
-
- /**
* @brief Get the geometry scene object
*
* @return the geometry scene object
std::vector<PropertyBufferPtr> mVertexBuffers; ///< Vector of intrusive pointers to vertex buffers
Dali::Geometry::GeometryType mGeometryType; ///< Geometry type (cached)
- bool mRequiresDepthTest; ///< Establish if geometry requires depth testing (cached)
-
};
} // namespace Internal
DALI_PROPERTY( "blendPreMultipliedAlpha", BOOLEAN, true, false, false, Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA )
DALI_PROPERTY( "indexRangeFirst", INTEGER, true, false, false, Dali::Renderer::Property::INDEX_RANGE_FIRST )
DALI_PROPERTY( "indexRangeCount", INTEGER, true, false, false, Dali::Renderer::Property::INDEX_RANGE_COUNT )
+DALI_PROPERTY( "depthWriteMode", INTEGER, true, false, false, Dali::Renderer::Property::DEPTH_WRITE_MODE )
DALI_PROPERTY_TABLE_END( DEFAULT_OBJECT_PROPERTY_START_INDEX )
const ObjectImplHelper<DEFAULT_PROPERTY_COUNT> RENDERER_IMPL = { DEFAULT_PROPERTY_DETAILS };
}
break;
}
+ case Dali::Renderer::Property::DEPTH_WRITE_MODE:
+ {
+ int value;
+ propertyValue.Get( value );
+ Dali::Renderer::DepthWriteMode mode = static_cast<Dali::Renderer::DepthWriteMode>(value);
+ if( mode != mDepthWriteMode )
+ {
+ mDepthWriteMode = mode;
+ SetDepthWriteModeMessage( GetEventThreadServices(), *mSceneObject, mode );
+ }
+
+ break;
+ }
}
}
value = static_cast<int>( mIndexedDrawElementCount );
break;
}
+ case Dali::Renderer::Property::DEPTH_WRITE_MODE:
+ {
+ value = mDepthWriteMode;
+ break;
+ }
}
return value;
}
mOnStageCount( 0 ),
mIndexedDrawFirstElement( 0 ),
mIndexedDrawElementCount( 0 ),
- mFaceCullingMode( Dali::Renderer::NONE ),
+ mFaceCullingMode( Dali::Renderer::CULL_NONE ),
mBlendingMode( Dali::BlendingMode::AUTO ),
mBlendingOptions(),
+ mDepthWriteMode( Dali::Renderer::DEPTH_WRITE_AUTO ),
mPremultipledAlphaEnabled( false )
{
}
Dali::Renderer::FaceCullingMode mFaceCullingMode; ///< Local copy of face culling mode
BlendingMode::Type mBlendingMode; ///< Local copy of blending mode
BlendingOptions mBlendingOptions; ///< Local copy of blending options bitmask
- bool mPremultipledAlphaEnabled; ///< Flag indicating whether the Pre-multiplied Alpha Blending is required
+ Dali:: Renderer::DepthWriteMode mDepthWriteMode; ///< Local copy of depth write mode
+ bool mPremultipledAlphaEnabled : 1; ///< Flag indicating whether the Pre-multiplied Alpha Blending is required
};
} // namespace Internal
Dali::Scripting::StringEnum ShaderHintsTable[] =
{ { "HINT_NONE", Dali::Shader::HINT_NONE},
- { "HINT_REQUIRES_SELF_DEPTH_TEST", Dali::Shader::HINT_REQUIRES_SELF_DEPTH_TEST},
{ "HINT_OUTPUT_IS_TRANSPARENT", Dali::Shader::HINT_OUTPUT_IS_TRANSPARENT},
- { "HINT_OUTPUT_IS_OPAQUE", Dali::Shader::HINT_OUTPUT_IS_OPAQUE},
{ "HINT_MODIFIES_GEOMETRY", Dali::Shader::HINT_MODIFIES_GEOMETRY}
};
s = "HINT_NONE";
}
- if(hints & Dali::Shader::HINT_REQUIRES_SELF_DEPTH_TEST)
- {
- AppendString(s, "HINT_REQUIRES_SELF_DEPTH_TEST");
- }
-
if(hints & Dali::Shader::HINT_OUTPUT_IS_TRANSPARENT)
{
AppendString(s, "HINT_OUTPUT_IS_TRANSPARENT");
}
- if(hints & Dali::Shader::HINT_OUTPUT_IS_OPAQUE)
- {
- AppendString(s, "HINT_OUTPUT_IS_OPAQUE");
- }
-
if(hints & Dali::Shader::HINT_MODIFIES_GEOMETRY)
{
AppendString(s, "HINT_MODIFIES_GEOMETRY");
{
EventThreadServices& eventThreadServices = GetEventThreadServices();
SceneGraph::UpdateManager& updateManager = eventThreadServices.GetUpdateManager();
-
- // @todo MESH_REWORK - Pass hints directly to a new scene graph shader
- int effectHint = Dali::ShaderEffect::HINT_NONE;
- if( hints & Dali::Shader::HINT_OUTPUT_IS_TRANSPARENT )
- {
- effectHint |= Dali::ShaderEffect::HINT_BLENDING;
- }
-
- if( hints & Dali::Shader::HINT_REQUIRES_SELF_DEPTH_TEST )
- {
- effectHint |= Dali::ShaderEffect::HINT_DEPTH_BUFFER;
- }
-
- if( (hints & Dali::Shader::HINT_MODIFIES_GEOMETRY) == 0x0 )
- {
- effectHint |= Dali::ShaderEffect::HINT_DOESNT_MODIFY_GEOMETRY;
- }
- Dali::ShaderEffect::GeometryHints shaderEffectHint = static_cast<Dali::ShaderEffect::GeometryHints>( effectHint );
-
- mSceneObject = new SceneGraph::Shader( shaderEffectHint );
+ mSceneObject = new SceneGraph::Shader( hints );
// Add to update manager
AddShaderMessage( updateManager, *mSceneObject );
{
const unsigned int renderFlags = renderList.GetFlags();
- bool enableDepthBuffer = ( ( renderFlags & RenderList::DEPTH_BUFFER_ENABLED ) != 0u );
+ if( ( renderFlags & RenderList::DEPTH_BUFFER_ENABLED ) != 0u )
+ {
+ //Enable depth testing
+ context.EnableDepthBuffer( true );
+ }
+ else
+ {
+ //Disable depth test and depth write
+ context.EnableDepthBuffer( false );
+ context.DepthMask( false );
+ }
GLbitfield clearMask = ( renderFlags & RenderList::DEPTH_CLEAR ) ? GL_DEPTH_BUFFER_BIT : 0u;
- context.EnableDepthBuffer( enableDepthBuffer );
-
// Stencil enabled, writing, and clearing...
const bool enableStencilBuffer( renderFlags & RenderList::STENCIL_BUFFER_ENABLED );
const bool enableStencilWrite( renderFlags & RenderList::STENCIL_WRITE );
-
context.EnableStencilBuffer( enableStencilBuffer );
-
if( enableStencilBuffer )
{
context.StencilFunc( (enableStencilWrite ? GL_ALWAYS : GL_EQUAL), 1, 0xFF );
{
bool depthBufferEnabled = ( ( renderList.GetFlags() & RenderList::DEPTH_BUFFER_ENABLED ) != 0u );
size_t count = renderList.Count();
- for ( size_t index = 0; index < count; ++index )
+
+ if( depthBufferEnabled )
{
- const RenderItem& item = renderList.GetItem( index );
- DALI_PRINT_RENDER_ITEM( item );
+ for ( size_t index = 0; index < count; ++index )
+ {
+ const RenderItem& item = renderList.GetItem( index );
+ DALI_PRINT_RENDER_ITEM( item );
- //Enable depth writes if depth buffer is enabled and item is opaque
- context.DepthMask( depthBufferEnabled && ( item.IsOpaque() || item.GetRenderer().RequiresDepthTest() ) );
+ Renderer& renderer = item.GetRenderer();
+ Dali::Renderer::DepthWriteMode depthWriteMode = renderer.GetDepthWriteMode();
+ context.DepthMask( ( depthWriteMode == Dali::Renderer::DEPTH_WRITE_AUTO && item.IsOpaque() ) ||
+ ( depthWriteMode == Dali::Renderer::DEPTH_WRITE_ON ) );
- item.GetRenderer().Render( context, textureCache, bufferIndex, item.GetNode(), defaultShader, item.GetModelViewMatrix(), viewMatrix, projectionMatrix, item.GetSize(), !item.IsOpaque() );
+ renderer.Render( context, textureCache, bufferIndex, item.GetNode(), defaultShader, item.GetModelViewMatrix(), viewMatrix, projectionMatrix, item.GetSize(), !item.IsOpaque() );
+ }
+ }
+ else
+ {
+ for ( size_t index = 0; index < count; ++index )
+ {
+ const RenderItem& item = renderList.GetItem( index );
+ DALI_PRINT_RENDER_ITEM( item );
+ item.GetRenderer().Render( context, textureCache, bufferIndex, item.GetNode(), defaultShader, item.GetModelViewMatrix(), viewMatrix, projectionMatrix, item.GetSize(), !item.IsOpaque() );
+ }
}
}
else
geometry->SetGeometryType( Render::Geometry::GeometryType(geometryType) );
}
-void RenderManager::SetGeometryRequiresDepthTest( Render::Geometry* geometry, bool requiresDepthTest )
-{
- geometry->SetRequiresDepthTest( requiresDepthTest );
-}
-
void RenderManager::AddRenderTracker( Render::RenderTracker* renderTracker )
{
mImpl->AddRenderTracker(renderTracker);
void SetGeometryType( Render::Geometry* geometry, unsigned int geometryType );
/**
- * Set if an existing geometry requires depth testing
- * @param[in] geometry The render geometry
- * @param[in] requiresDepthTest True if depth testing is required, false otherwise
- */
- void SetGeometryRequiresDepthTest( Render::Geometry* geometry, bool requiresDepthTest );
-
- /**
* Adds a render tracker to the RenderManager. RenderManager takes ownership of the
* tracker. The lifetime of the tracker is related to the lifetime of the tracked
* object, usually an offscreen render task.
mBlendEquationSeparateModeAlpha( GL_FUNC_ADD ),
mMaxTextureSize(0),
mClearColor(Color::WHITE), // initial color, never used until it's been set by the user
- mCullFaceMode( Dali::Renderer::NONE ),
+ mCullFaceMode( Dali::Renderer::CULL_NONE ),
mViewPort( 0, 0, 0, 0 )
{
}
mBlendEquationSeparateModeRGB = GL_FUNC_ADD;
mBlendEquationSeparateModeAlpha = GL_FUNC_ADD;
- mCullFaceMode = Dali::Renderer::NONE; //By default cullface is disabled, front face is set to CCW and cull face is set to back
+ mCullFaceMode = Dali::Renderer::CULL_NONE; //By default cullface is disabled, front face is set to CCW and cull face is set to back
// get maximum texture size
mGlAbstraction.GetIntegerv(GL_MAX_TEXTURE_SIZE, &mMaxTextureSize);
mCullFaceMode = mode;
switch(mode)
{
- case Dali::Renderer::NONE:
+ case Dali::Renderer::CULL_NONE:
{
LOG_GL("Disable GL_CULL_FACE\n");
CHECK_GL( mGlAbstraction, mGlAbstraction.Disable(GL_CULL_FACE) );
mIndexBuffer(NULL),
mGeometryType( Dali::Geometry::TRIANGLES ),
mIndicesChanged(false),
- mRequiresDepthTest(false ),
mHasBeenUpdated(false),
mAttributesChanged(true)
{
}
/**
- * Sets if the geometry requires depth testing
- * @param[in] requiresDepthTest True if depth testing is required, false otherwise
- */
- void SetRequiresDepthTest( bool requiresDepthTest )
- {
- mRequiresDepthTest = requiresDepthTest;
- }
-
- /**
- * Check if geometry requires depth testing
- * @return True if depth testing is required, false otherwise
- */
- bool RequiresDepthTest() const
- {
- return mRequiresDepthTest;
- }
-
- /**
* Upload the geometry if it has changed, set up the attributes and perform
* the Draw call corresponding to the geometry type
* @param[in] context The GL context
// Booleans
bool mIndicesChanged : 1;
- bool mRequiresDepthTest : 1;
bool mHasBeenUpdated : 1;
bool mAttributesChanged : 1;
unsigned int blendingBitmask,
const Vector4* blendColor,
Dali::Renderer::FaceCullingMode faceCullingMode,
- bool preMultipliedAlphaEnabled )
+ bool preMultipliedAlphaEnabled,
+ Dali::Renderer::DepthWriteMode depthWriteMode )
{
- return new Renderer( dataProvider, geometry, blendingBitmask, blendColor, faceCullingMode, preMultipliedAlphaEnabled );
+ return new Renderer( dataProvider, geometry, blendingBitmask, blendColor, faceCullingMode, preMultipliedAlphaEnabled, depthWriteMode );
}
Renderer::Renderer( SceneGraph::RenderDataProvider* dataProvider,
unsigned int blendingBitmask,
const Vector4* blendColor,
Dali::Renderer::FaceCullingMode faceCullingMode,
- bool preMultipliedAlphaEnabled)
+ bool preMultipliedAlphaEnabled,
+ Dali::Renderer::DepthWriteMode depthWriteMode )
: mRenderDataProvider( dataProvider ),
mContext(NULL),
mTextureCache( NULL ),
mAttributesLocation(),
mBlendingOptions(),
mFaceCullingMode( faceCullingMode ),
+ mDepthWriteMode( depthWriteMode ),
mIndexedDrawFirstElement( 0 ),
mIndexedDrawElementsCount( 0 ),
- mSamplerBitfield( ImageSampler::PackBitfield( FilterMode::DEFAULT, FilterMode::DEFAULT ) ),
mUpdateAttributesLocation( true ),
mPremultipledAlphaEnabled( preMultipliedAlphaEnabled )
{
mUpdateAttributesLocation = true;
}
-// Note - this is currently called from UpdateThread, PrepareRenderInstructions,
-// as an optimisation.
-// @todo MESH_REWORK Should use Update thread objects only in PrepareRenderInstructions.
-bool Renderer::RequiresDepthTest() const
-{
- return mGeometry->RequiresDepthTest();
-}
-
void Renderer::SetBlending( Context& context, bool blend )
{
context.SetBlend( blend );
mPremultipledAlphaEnabled = enable;
}
-void Renderer::SetSampler( unsigned int samplerBitfield )
+void Renderer::SetDepthWriteMode( Dali::Renderer::DepthWriteMode depthWriteMode )
+{
+ mDepthWriteMode = depthWriteMode;
+}
+
+Dali::Renderer::DepthWriteMode Renderer::GetDepthWriteMode() const
{
- mSamplerBitfield = samplerBitfield;
+ return mDepthWriteMode;
}
void Renderer::Render( Context& context,
* @param[in] blendColor The blend color to pass to GL
* @param[in] faceCullingMode The face-culling mode.
* @param[in] preMultipliedAlphaEnabled whether alpha is pre-multiplied.
+ * @param[in] depthWriteMode Depth buffer write mode
*/
static Renderer* New( SceneGraph::RenderDataProvider* dataProviders,
Render::Geometry* geometry,
unsigned int blendingBitmask,
const Vector4* blendColor,
Dali::Renderer::FaceCullingMode faceCullingMode,
- bool preMultipliedAlphaEnabled);
+ bool preMultipliedAlphaEnabled,
+ Dali::Renderer::DepthWriteMode depthWriteMode );
/**
* Constructor.
* @param[in] blendColor The blend color to pass to GL
* @param[in] faceCullingMode The face-culling mode.
* @param[in] preMultipliedAlphaEnabled whether alpha is pre-multiplied.
+ * @param[in] depthWriteMode Depth buffer write mode
*/
Renderer( SceneGraph::RenderDataProvider* dataProviders,
Render::Geometry* geometry,
unsigned int blendingBitmask,
const Vector4* blendColor,
Dali::Renderer::FaceCullingMode faceCullingMode,
- bool preMultipliedAlphaEnabled);
+ bool preMultipliedAlphaEnabled,
+ Dali::Renderer::DepthWriteMode depthWriteMode );
/**
* Change the data providers of the renderer
void EnablePreMultipliedAlpha( bool preMultipled );
/**
- * Set the sampler used to render the set texture.
- * @param[in] samplerBitfield The packed sampler options used to render.
+ * Query the Renderer's depth write mode
+ * @return The renderer depth write mode
*/
- void SetSampler( unsigned int samplerBitfield );
+ Dali::Renderer::DepthWriteMode GetDepthWriteMode() const;
/**
- * Query whether the derived type of Renderer requires depth testing.
- * @return True if the renderer requires depth testing.
+ * Sets the depth write mode
+ * @param[in] depthWriteMode The depth write mode
*/
- bool RequiresDepthTest() const;
+ void SetDepthWriteMode( Dali::Renderer::DepthWriteMode depthWriteMode );
/**
* Called to render during RenderManager::Render().
/**
* Set the program uniform in the map from the mapped property
+ * @param[in] bufferIndex The index of the previous update buffer.
+ * @param[in] program The shader program
+ * @param[in] map The uniform
*/
void SetUniformFromProperty( BufferIndex bufferIndex, Program& program, UniformIndexMap& map );
*/
bool BindTextures( SceneGraph::TextureCache& textureCache, Program& program );
-public:
+private:
OwnerPointer< SceneGraph::RenderDataProvider > mRenderDataProvider;
-private:
-
Context* mContext;
SceneGraph::TextureCache* mTextureCache;
Render::UniformNameCache* mUniformNameCache;
BlendingOptions mBlendingOptions; /// Blending options including blend color, blend func and blend equation
Dali::Renderer::FaceCullingMode mFaceCullingMode; /// Mode of face culling
+ Dali::Renderer::DepthWriteMode mDepthWriteMode; /// Depth write mode
size_t mIndexedDrawFirstElement; /// Offset of first element to draw
size_t mIndexedDrawElementsCount; /// Number of elements to draw
- unsigned int mSamplerBitfield; ///< Sampler options used for texture filtering
bool mUpdateAttributesLocation:1; ///< Indicates attribute locations have changed
- bool mPremultipledAlphaEnabled:1; ///< Flag indicating whether the Pre-multiplied Alpha Blending is required
+ bool mPremultipledAlphaEnabled:1; ///< Flag indicating whether the Pre-multiplied Alpha Blending is required
};
} // namespace SceneGraph
namespace SceneGraph
{
-Shader::Shader( Dali::ShaderEffect::GeometryHints& hints )
-: mGeometryHints( hints ),
+Shader::Shader( Dali::Shader::ShaderHints& hints )
+: mHints( hints ),
mProgram( NULL ),
mConnectionObservers()
{
/**
* Constructor
- * @param hints Geometry hints
+ * @param hints Shader hints
*/
- Shader( Dali::ShaderEffect::GeometryHints& hints );
+ Shader( Dali::Shader::ShaderHints& hints );
/**
* Virtual destructor
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
- * Query whether a shader geometry hint is set.
+ * Query whether a shader hint is set.
* @pre The shader has been initialized.
- * @param[in] hint The geometry hint to check.
- * @return True if the given geometry hint is set.
+ * @param[in] hint The hint to check.
+ * @return True if the given hint is set.
*/
- bool GeometryHintEnabled( Dali::ShaderEffect::GeometryHints hint ) const
+ bool HintEnabled( Dali::Shader::ShaderHints hint ) const
{
- return mGeometryHints & hint;
- }
-
- /**
- * Retrieve the set of geometry hints.
- * @return The hints.
- */
- Dali::ShaderEffect::GeometryHints GetGeometryHints() const
- {
- return mGeometryHints;
- }
-
- /**
- * Set the geometry hints.
- * @param[in] hints The hints.
- */
- void SetGeometryHints( Dali::ShaderEffect::GeometryHints hints )
- {
- mGeometryHints = hints;
+ return mHints & hint;
}
/**
private: // Data
- Dali::ShaderEffect::GeometryHints mGeometryHints; ///< shader geometry hints for building the geometry
+ Dali::Shader::ShaderHints mHints;
Program* mProgram;
const Matrix& worldMatrix = renderable.mNode->GetWorldMatrix( updateBufferIndex );
const Vector3& size = renderable.mNode->GetSize( updateBufferIndex );
- if ( cull && renderable.mRenderer->GetShader().GeometryHintEnabled( Dali::ShaderEffect::HINT_DOESNT_MODIFY_GEOMETRY ) )
+ if ( cull && !renderable.mRenderer->GetShader().HintEnabled( Dali::Shader::HINT_MODIFIES_GEOMETRY ) )
{
const Vector3& position = worldMatrix.GetTranslation3();
float radius( size.Length() * 0.5f );
flags = RenderList::STENCIL_BUFFER_ENABLED;
}
- // Special optimization if depth test is disabled or if only one opaque rendered in the layer (for example background image)
- // and this renderer does not need depth test against itself (e.g. mesh)
- // and if this layer has got exactly one opaque renderer
- // and this renderer is not interested in depth testing
- // (i.e. is an image and not a mesh)
-
+ // Special optimization. If this layer has got exactly one renderer
+ // and this renderer is not writing to the depth buffer there is no point on enabling
+ // depth buffering
if ( ( renderList.Count() == 1 ) &&
- ( !renderList.GetRenderer( 0 ).RequiresDepthTest() ) &&
- ( !renderList.GetItem(0).IsOpaque() ) )
+ (( renderList.GetRenderer( 0 ).GetDepthWriteMode() == Dali::Renderer::DEPTH_WRITE_OFF ) ||
+ ( renderList.GetRenderer( 0 ).GetDepthWriteMode() == Dali::Renderer::DEPTH_WRITE_AUTO && !renderList.GetItem(0).IsOpaque() )))
{
//Nothing to do here
}
new (slot) DerivedType( &mImpl->renderManager, &RenderManager::RemoveGeometry, geometry );
}
-void UpdateManager::SetGeometryRequiresDepthTest( Render::Geometry* geometry, bool requiresDepthTest )
-{
- typedef MessageValue2< RenderManager, Render::Geometry*, bool > DerivedType;
-
- // Reserve some memory inside the render queue
- unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
-
- // Construct message in the render queue memory; note that delete should not be called on the return value
- new (slot) DerivedType( &mImpl->renderManager, &RenderManager::SetGeometryRequiresDepthTest, geometry, requiresDepthTest );
-}
-
void UpdateManager::SetGeometryType( Render::Geometry* geometry, unsigned int geometryType )
{
typedef MessageValue2< RenderManager, Render::Geometry*, unsigned int > DerivedType;
void RemoveGeometry( Render::Geometry* geometry );
/**
- * Sets if a Geometry requieres depth testing
- * @param[in] geometry The geometry
- * @param[in] requiresDepthTest True if the geometry requires depth testing, false otherwise
- */
- void SetGeometryRequiresDepthTest( Render::Geometry* geometry, bool requiresDepthTest );
-
- /**
* Sets the geometry type of an existing Geometry
* @param[in] geometry The geometry
* @param[in] geometryType The type of the geometry
new (slot) LocalType( &manager, &UpdateManager::SetGeometryType, &geometry, geometryType );
}
-inline void SetGeometryRequiresDepthTestMessage( UpdateManager& manager, Render::Geometry& geometry, bool requiresDepthTest )
-{
- typedef MessageValue2< UpdateManager, Render::Geometry*, bool > LocalType;
-
- // Reserve some memory inside the message queue
- unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
-
- // Construct message in the message queue memory; note that delete should not be called on the return value
- new (slot) LocalType( &manager, &UpdateManager::SetGeometryRequiresDepthTest, &geometry, requiresDepthTest );
-}
-
} // namespace SceneGraph
} // namespace Internal
RESEND_PREMULTIPLIED_ALPHA = 1 << 5,
RESEND_INDEXED_DRAW_FIRST_ELEMENT = 1 << 6,
RESEND_INDEXED_DRAW_ELEMENTS_COUNT = 1 << 7,
+ RESEND_DEPTH_WRITE_MODE = 1 << 8,
};
}
mShader( NULL ),
mBlendColor( NULL ),
mBlendBitmask( 0u ),
- mFaceCullingMode( Dali::Renderer::NONE ),
+ mFaceCullingMode( Dali::Renderer::CULL_NONE ),
mBlendingMode( Dali::BlendingMode::AUTO ),
+ mDepthWriteMode( Dali::Renderer::DEPTH_WRITE_AUTO ),
mIndexedDrawFirstElement( 0 ),
mIndexedDrawElementsCount( 0 ),
mReferenceCount( 0 ),
mResendFlag( 0 ),
mResourcesReady( false ),
mFinishedResourceAcquisition( false ),
+ mPremultipledAlphaEnabled(false),
mDepthIndex( 0 )
{
mUniformMapChanged[0] = false;
mRegenerateUniformMap--;
}
- if( mResendFlag == 0 )
+ if( mResendFlag != 0 )
{
- return;
- }
+ if( mResendFlag & RESEND_DATA_PROVIDER )
+ {
+ RenderDataProvider* dataProvider = NewRenderDataProvider();
- if( mResendFlag & RESEND_DATA_PROVIDER )
- {
- RenderDataProvider* dataProvider = NewRenderDataProvider();
+ typedef MessageValue1< Render::Renderer, OwnerPointer<RenderDataProvider> > DerivedType;
+ unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
+ new (slot) DerivedType( mRenderer, &Render::Renderer::SetRenderDataProvider, dataProvider );
+ }
- typedef MessageValue1< Render::Renderer, OwnerPointer<RenderDataProvider> > DerivedType;
- unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
- new (slot) DerivedType( mRenderer, &Render::Renderer::SetRenderDataProvider, dataProvider );
- mResendFlag &= ~RESEND_DATA_PROVIDER;
- }
+ if( mResendFlag & RESEND_GEOMETRY )
+ {
+ typedef MessageValue1< Render::Renderer, Render::Geometry* > DerivedType;
+ unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
- if( mResendFlag & RESEND_GEOMETRY )
- {
- typedef MessageValue1< Render::Renderer, Render::Geometry* > DerivedType;
- unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
+ new (slot) DerivedType( mRenderer, &Render::Renderer::SetGeometry, mGeometry );
+ }
- new (slot) DerivedType( mRenderer, &Render::Renderer::SetGeometry, mGeometry );
- mResendFlag &= ~RESEND_GEOMETRY;
- }
+ if( mResendFlag & RESEND_FACE_CULLING_MODE )
+ {
+ typedef MessageValue1< Render::Renderer, Dali::Renderer::FaceCullingMode > DerivedType;
+ unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
+ new (slot) DerivedType( mRenderer, &Render::Renderer::SetFaceCullingMode, mFaceCullingMode );
+ }
- if( mResendFlag & RESEND_FACE_CULLING_MODE )
- {
- typedef MessageValue1< Render::Renderer, Dali::Renderer::FaceCullingMode > DerivedType;
- unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
- new (slot) DerivedType( mRenderer, &Render::Renderer::SetFaceCullingMode, mFaceCullingMode );
- mResendFlag &= ~RESEND_FACE_CULLING_MODE;
- }
+ if( mResendFlag & RESEND_BLEND_BIT_MASK )
+ {
+ typedef MessageValue1< Render::Renderer, unsigned int > DerivedType;
+ unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
+ new (slot) DerivedType( mRenderer, &Render::Renderer::SetBlendingBitMask, mBlendBitmask );
+ }
- if( mResendFlag & RESEND_BLEND_BIT_MASK )
- {
- typedef MessageValue1< Render::Renderer, unsigned int > DerivedType;
- unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
- new (slot) DerivedType( mRenderer, &Render::Renderer::SetBlendingBitMask, mBlendBitmask );
- mResendFlag &= ~RESEND_BLEND_BIT_MASK;
- }
+ if( mResendFlag & RESEND_BLEND_COLOR )
+ {
+ typedef MessageValue1< Render::Renderer, const Vector4* > DerivedType;
+ unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
+ new (slot) DerivedType( mRenderer, &Render::Renderer::SetBlendColor, mBlendColor );
+ }
- if( mResendFlag & RESEND_BLEND_COLOR )
- {
- typedef MessageValue1< Render::Renderer, const Vector4* > DerivedType;
- unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
- new (slot) DerivedType( mRenderer, &Render::Renderer::SetBlendColor, mBlendColor );
- mResendFlag &= ~RESEND_BLEND_COLOR;
- }
+ if( mResendFlag & RESEND_PREMULTIPLIED_ALPHA )
+ {
+ typedef MessageValue1< Render::Renderer, bool > DerivedType;
+ unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
+ new (slot) DerivedType( mRenderer, &Render::Renderer::EnablePreMultipliedAlpha, mPremultipledAlphaEnabled );
+ }
- if( mResendFlag & RESEND_PREMULTIPLIED_ALPHA )
- {
- typedef MessageValue1< Render::Renderer, bool > DerivedType;
- unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
- new (slot) DerivedType( mRenderer, &Render::Renderer::EnablePreMultipliedAlpha, mPremultipledAlphaEnabled );
- mResendFlag &= ~RESEND_PREMULTIPLIED_ALPHA;
- }
+ if( mResendFlag & RESEND_INDEXED_DRAW_FIRST_ELEMENT )
+ {
+ typedef MessageValue1< Render::Renderer, size_t > DerivedType;
+ unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
+ new (slot) DerivedType( mRenderer, &Render::Renderer::SetIndexedDrawFirstElement, mIndexedDrawFirstElement );
+ }
- if( mResendFlag & RESEND_INDEXED_DRAW_FIRST_ELEMENT )
- {
- typedef MessageValue1< Render::Renderer, size_t > DerivedType;
- unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
- new (slot) DerivedType( mRenderer, &Render::Renderer::SetIndexedDrawFirstElement, mIndexedDrawFirstElement );
- mResendFlag &= ~RESEND_INDEXED_DRAW_FIRST_ELEMENT;
- }
+ if( mResendFlag & RESEND_INDEXED_DRAW_ELEMENTS_COUNT )
+ {
+ typedef MessageValue1< Render::Renderer, size_t > DerivedType;
+ unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
+ new (slot) DerivedType( mRenderer, &Render::Renderer::SetIndexedDrawElementsCount, mIndexedDrawElementsCount );
+ }
- if( mResendFlag & RESEND_INDEXED_DRAW_ELEMENTS_COUNT )
- {
- typedef MessageValue1< Render::Renderer, size_t > DerivedType;
- unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
- new (slot) DerivedType( mRenderer, &Render::Renderer::SetIndexedDrawElementsCount, mIndexedDrawElementsCount );
- mResendFlag &= ~RESEND_INDEXED_DRAW_FIRST_ELEMENT;
+ if( mResendFlag & RESEND_DEPTH_WRITE_MODE )
+ {
+ typedef MessageValue1< Render::Renderer, Dali::Renderer::DepthWriteMode > DerivedType;
+ unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
+ new (slot) DerivedType( mRenderer, &Render::Renderer::SetDepthWriteMode, mDepthWriteMode );
+ }
+
+ mResendFlag = 0;
}
}
mResendFlag |= RESEND_PREMULTIPLIED_ALPHA;
}
+void Renderer::SetDepthWriteMode( unsigned int depthWriteMode )
+{
+ mDepthWriteMode = static_cast<Dali::Renderer::DepthWriteMode>(depthWriteMode);
+ mResendFlag |= RESEND_DEPTH_WRITE_MODE;
+}
+
//Called when a node with this renderer is added to the stage
void Renderer::OnStageConnect()
{
mRenderer = Render::Renderer::New( dataProvider, mGeometry,
mBlendBitmask, mBlendColor,
static_cast< Dali::Renderer::FaceCullingMode >( mFaceCullingMode ),
- mPremultipledAlphaEnabled );
+ mPremultipledAlphaEnabled,
+ mDepthWriteMode );
+
mSceneController->GetRenderMessageDispatcher().AddRenderer( *mRenderer );
mResendFlag = 0;
}
}
case BlendingMode::AUTO:
{
- bool shaderRequiresBlending( mShader->GeometryHintEnabled( Dali::ShaderEffect::HINT_BLENDING ) );
+ bool shaderRequiresBlending( mShader->HintEnabled( Dali::Shader::HINT_OUTPUT_IS_TRANSPARENT ) );
if( shaderRequiresBlending || ( mTextureSet && mTextureSet->HasAlpha() ) )
{
opacity = Renderer::TRANSLUCENT;
void EnablePreMultipliedAlpha( bool preMultipled );
/**
+ * Sets the depth buffer write mode
+ * @param[in] depthWriteMode The depth buffer write mode
+ */
+ void SetDepthWriteMode( unsigned int depthWriteMode );
+
+ /**
* Called when an actor with this renderer is added to the stage
*/
void OnStageConnect();
unsigned int mBlendBitmask; ///< The bitmask of blending options
Dali::Renderer::FaceCullingMode mFaceCullingMode; ///< The mode of face culling
BlendingMode::Type mBlendingMode; ///< The mode of blending
+ Dali::Renderer::DepthWriteMode mDepthWriteMode; ///< The depth write mode
CollectedUniformMap mCollectedUniformMap[2]; ///< Uniform maps collected by the renderer
size_t mIndexedDrawElementsCount; ///< number of elements to be drawn using indexed draw
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.
- unsigned char mResendFlag; ///< Indicate whether data should be resent to the renderer
+ unsigned char mResendFlag; ///< Indicate whether data should be resent to the renderer
bool mUniformMapChanged[2]; ///< Records if the uniform map has been altered this frame
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)
- bool mPremultipledAlphaEnabled; ///< Flag indicating whether the Pre-multiplied Alpha Blending is required
+ bool mPremultipledAlphaEnabled : 1; ///< Flag indicating whether the Pre-multiplied Alpha Blending is required
+
public:
int mDepthIndex; ///< Used only in PrepareRenderInstructions
new (slot) LocalType( &renderer, &Renderer::EnablePreMultipliedAlpha, preMultiplied );
}
+inline void SetDepthWriteModeMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, Dali::Renderer::DepthWriteMode depthWriteMode )
+{
+ 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::SetDepthWriteMode, depthWriteMode );
+}
+
inline void OnStageConnectMessage( EventThreadServices& eventThreadServices, const Renderer& renderer )
{
typedef Message< Renderer > LocalType;
projects / platform / core / uifw / dali-core.git / commitdiff