return vertexData;
}
-PropertyBuffer CreateIndexBuffer()
-{
- const unsigned short indexData[6] = { 0, 3, 1, 0, 2, 3 };
- const unsigned int numberElements = sizeof(indexData)/sizeof(indexData[0]) ;
-
- Property::Map indexFormat;
- indexFormat["indices"] = Property::INTEGER;
- PropertyBuffer indices = PropertyBuffer::New( indexFormat );
- indices.SetData( indexData, numberElements );
-
- return indices;
-}
}
tet_infoline("Test SetIndexBuffer");
PropertyBuffer vertexBuffer = CreateVertexBuffer("aPosition", "aTexCoord" );
- PropertyBuffer indexBuffer = CreateIndexBuffer( );
Geometry geometry = Geometry::New();
geometry.AddVertexBuffer( vertexBuffer );
// Set index buffer
application.GetGlAbstraction().ResetBufferDataCalls();
- geometry.SetIndexBuffer( indexBuffer );
+ const unsigned short indexData[6] = { 0, 3, 1, 0, 2, 3 };
+ geometry.SetIndexBuffer( indexData, sizeof(indexData)/sizeof(indexData[0]) );
application.SendNotification();
application.Render(0);
application.Render();
unsigned int numVertex = 4u;
unsigned int numIndex = 6u; // 6 unsigned short
PropertyBuffer vertexBuffer = CreateVertexBuffer("aPosition", "aTexCoord" );
- PropertyBuffer indexBuffer = CreateIndexBuffer( );
+
Geometry geometry = Geometry::New();
geometry.AddVertexBuffer( vertexBuffer );
- geometry.SetIndexBuffer( indexBuffer );
+ const unsigned short indexData[6] = { 0, 3, 1, 0, 2, 3 };
+ geometry.SetIndexBuffer( indexData, sizeof(indexData)/sizeof(indexData[0]) );
Shader shader = CreateShader();
Renderer renderer = Renderer::New(geometry, shader);
END_TEST;
}
-int UtcDaliGeometryPropertyRequiresDepthTest(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.GetProperty<bool>(Geometry::Property::REQUIRES_DEPTH_TEST), false, TEST_LOCATION );
-
- geometry.SetProperty(Geometry::Property::REQUIRES_DEPTH_TEST, true );
-
- TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
- glAbstraction.EnableEnableDisableCallTrace(true);
- application.SendNotification();
- application.Render();
-// TODO: Not supported yet
-// 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.GetProperty<bool>(Geometry::Property::REQUIRES_DEPTH_TEST), true, TEST_LOCATION );
-
- END_TEST;
-}
-
-int UtcDaliGeometryConstraint(void)
-{
- TestApplication application;
-
- tet_infoline("Test that a custom geometry property can be constrained");
-
- 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);
-
- Vector4 initialColor = Color::WHITE;
- Property::Index colorIndex = geometry.RegisterProperty( "uFadeColor", initialColor );
-
- application.SendNotification();
- application.Render(0);
- DALI_TEST_EQUALS( geometry.GetProperty<Vector4>(colorIndex), initialColor, TEST_LOCATION );
-
- // Apply constraint
- Constraint constraint = Constraint::New<Vector4>( geometry, colorIndex, TestConstraintNoBlue );
- constraint.Apply();
- application.SendNotification();
- application.Render(0);
-
- // Expect no blue component in either buffer - yellow
- DALI_TEST_EQUALS( geometry.GetProperty<Vector4>(colorIndex), Color::YELLOW, TEST_LOCATION );
- application.Render(0);
- DALI_TEST_EQUALS( geometry.GetProperty<Vector4>(colorIndex), Color::YELLOW, TEST_LOCATION );
-
- geometry.RemoveConstraints();
- geometry.SetProperty(colorIndex, Color::WHITE );
- application.SendNotification();
- application.Render(0);
- DALI_TEST_EQUALS( geometry.GetProperty<Vector4>(colorIndex), Color::WHITE, TEST_LOCATION );
-
- END_TEST;
-}
-
-int UtcDaliGeometryConstraint02(void)
-{
- TestApplication application;
-
- tet_infoline("Test that a uniform map geometry property can be constrained");
-
- 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);
- application.SendNotification();
- application.Render(0);
-
- Vector4 initialColor = Color::WHITE;
- Property::Index colorIndex = geometry.RegisterProperty( "uFadeColor", initialColor );
-
- TestGlAbstraction& gl = application.GetGlAbstraction();
-
- application.SendNotification();
- application.Render(0);
-
- Vector4 actualValue(Vector4::ZERO);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, initialColor, TEST_LOCATION );
-
- // Apply constraint
- Constraint constraint = Constraint::New<Vector4>( geometry, colorIndex, TestConstraintNoBlue );
- constraint.Apply();
- application.SendNotification();
- application.Render(0);
-
- // Expect no blue component in either buffer - yellow
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::YELLOW, TEST_LOCATION );
-
- application.Render(0);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::YELLOW, TEST_LOCATION );
-
- geometry.RemoveConstraints();
- geometry.SetProperty(colorIndex, Color::WHITE );
- application.SendNotification();
- application.Render(0);
-
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::WHITE, TEST_LOCATION );
-
- END_TEST;
-}
-
-
-
-int UtcDaliGeometryAnimatedProperty01(void)
-{
- TestApplication application;
-
- tet_infoline("Test that a custom geometry property can be animated");
-
- 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);
-
- Vector4 initialColor = Color::WHITE;
- Property::Index colorIndex = geometry.RegisterProperty( "uFadeColor", initialColor );
-
- application.SendNotification();
- application.Render(0);
- DALI_TEST_EQUALS( geometry.GetProperty<Vector4>(colorIndex), initialColor, TEST_LOCATION );
-
- Animation animation = Animation::New(1.0f);
- KeyFrames keyFrames = KeyFrames::New();
- keyFrames.Add(0.0f, initialColor);
- keyFrames.Add(1.0f, Color::TRANSPARENT);
- animation.AnimateBetween( Property( geometry, colorIndex ), keyFrames );
- animation.Play();
-
- application.SendNotification();
- application.Render(500);
-
- DALI_TEST_EQUALS( geometry.GetProperty<Vector4>(colorIndex), Color::WHITE * 0.5f, TEST_LOCATION );
-
- application.Render(500);
-
- DALI_TEST_EQUALS( geometry.GetProperty<Vector4>(colorIndex), Color::TRANSPARENT, TEST_LOCATION );
-
- END_TEST;
-}
-
-int UtcDaliGeometryAnimatedProperty02(void)
-{
- TestApplication application;
-
- tet_infoline("Test that a uniform map geometry property can be animated");
-
- 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);
- application.SendNotification();
- application.Render(0);
-
- Vector4 initialColor = Color::WHITE;
- Property::Index colorIndex = geometry.RegisterProperty( "uFadeColor", initialColor );
-
- TestGlAbstraction& gl = application.GetGlAbstraction();
-
- application.SendNotification();
- application.Render(0);
-
- Vector4 actualValue(Vector4::ZERO);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, initialColor, TEST_LOCATION );
-
- Animation animation = Animation::New(1.0f);
- KeyFrames keyFrames = KeyFrames::New();
- keyFrames.Add(0.0f, initialColor);
- keyFrames.Add(1.0f, Color::TRANSPARENT);
- animation.AnimateBetween( Property( geometry, colorIndex ), keyFrames );
- animation.Play();
-
- application.SendNotification();
- application.Render(500);
-
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::WHITE * 0.5f, TEST_LOCATION );
-
- application.Render(500);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::TRANSPARENT, TEST_LOCATION );
-
- END_TEST;
-}
tet_infoline( "Test SetGeometry, GetGeometry" );
Geometry geometry1 = CreateQuadGeometry();
- geometry1.RegisterProperty( "uFadeColor", Color::RED );
-
Geometry geometry2 = CreateQuadGeometry();
- geometry2.RegisterProperty( "uFadeColor", Color::GREEN );
Shader shader = CreateShader();
Renderer renderer = Renderer::New(geometry1, shader);
actor.SetSize(400, 400);
Stage::GetCurrent().Add(actor);
- TestGlAbstraction& gl = application.GetGlAbstraction();
application.SendNotification();
application.Render(0);
-
- // Expect that the first geometry's fade color property is accessed
- Vector4 actualValue(Vector4::ZERO);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::RED, TEST_LOCATION );
-
DALI_TEST_EQUALS( renderer.GetGeometry(), geometry1, TEST_LOCATION );
// Set geometry2 to the renderer
application.SendNotification();
application.Render(0);
-
- // Expect that the second geometry's fade color property is accessed
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::GREEN, TEST_LOCATION );
-
DALI_TEST_EQUALS( renderer.GetGeometry(), geometry2, TEST_LOCATION );
END_TEST;
shader.RegisterProperty( "uFadeColor", Color::MAGENTA );
- geometry.RegisterProperty( "uFadeColor", Color::YELLOW );
-
TestGlAbstraction& gl = application.GetGlAbstraction();
application.SendNotification();
shader.RegisterProperty( "uFadeColor", Color::MAGENTA );
- geometry.RegisterProperty( "uFadeColor", Color::YELLOW );
-
TestGlAbstraction& gl = application.GetGlAbstraction();
textureSet.RegisterProperty( "uFadeColor", Color::BLUE );
- shader.RegisterProperty( "uFadeColor", Color::MAGENTA );
-
- Property::Index geometryFadeColorIndex = geometry.RegisterProperty( "uFadeColor", Color::YELLOW );
-
- geometry.RegisterProperty( "uFadeColor", Color::BLACK );
-
+ Property::Index shaderFadeColorIndex = shader.RegisterProperty( "uFadeColor", Color::BLACK );
TestGlAbstraction& gl = application.GetGlAbstraction();
KeyFrames keyFrames = KeyFrames::New();
keyFrames.Add(0.0f, Color::WHITE);
keyFrames.Add(1.0f, Color::TRANSPARENT);
- animation.AnimateBetween( Property( geometry, geometryFadeColorIndex ), keyFrames );
+ animation.AnimateBetween( Property( shader, shaderFadeColorIndex ), keyFrames );
animation.Play();
application.SendNotification();
END_TEST;
}
-
-int UtcDaliRendererUniformMapPrecendence04(void)
-{
- TestApplication application;
-
- tet_infoline("Test the uniform map precedence is applied properly");
-
- Image image = BufferImage::New( 64, 64, Pixel::RGBA8888 );
-
- Shader shader = Shader::New("VertexSource", "FragmentSource");
- TextureSet textureSet = CreateTextureSet( image );
-
- PropertyBuffer vertexBuffer = CreatePropertyBuffer();
- Geometry geometry = CreateQuadGeometryFromBuffer(vertexBuffer);
- Renderer renderer = Renderer::New( geometry, shader );
- renderer.SetTextures( textureSet );
-
- Actor actor = Actor::New();
- actor.AddRenderer(renderer);
- actor.SetSize(400, 400);
- Stage::GetCurrent().Add(actor);
- application.SendNotification();
- application.Render(0);
-
- // Don't add property / uniform map to renderer/actor/texture set
- shader.RegisterProperty( "uFadeColor", Color::MAGENTA );
-
- Property::Index geometryFadeColorIndex = geometry.RegisterProperty( "uFadeColor", Color::YELLOW );
-
- geometry.RegisterProperty( "uFadeColor", Color::BLACK );
-
-
- TestGlAbstraction& gl = application.GetGlAbstraction();
-
- application.SendNotification();
- application.Render(0);
-
- // Expect that the sampler's fade color property is accessed
- Vector4 actualValue(Vector4::ZERO);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::MAGENTA, TEST_LOCATION );
-
- // Animate geometry's fade color property. Should be no change to uniform
- Animation animation = Animation::New(1.0f);
- KeyFrames keyFrames = KeyFrames::New();
- keyFrames.Add(0.0f, Color::WHITE);
- keyFrames.Add(1.0f, Color::TRANSPARENT);
- animation.AnimateBetween( Property( geometry, geometryFadeColorIndex ), keyFrames );
- animation.Play();
-
- application.SendNotification();
- application.Render(500);
-
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::MAGENTA, TEST_LOCATION );
-
- application.Render(500);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::MAGENTA, TEST_LOCATION );
-
- END_TEST;
-}
-
-int UtcDaliRendererUniformMapPrecendence05(void)
-{
- TestApplication application;
-
- tet_infoline("Test the uniform map precedence is applied properly");
-
- Image image = BufferImage::New( 64, 64, Pixel::RGBA8888 );
-
- Shader shader = Shader::New("VertexSource", "FragmentSource");
- TextureSet textureSet = CreateTextureSet( image );
-
- PropertyBuffer vertexBuffer = CreatePropertyBuffer();
- Geometry geometry = CreateQuadGeometryFromBuffer(vertexBuffer);
- Renderer renderer = Renderer::New( geometry, shader );
- renderer.SetTextures( textureSet );
-
- Actor actor = Actor::New();
- actor.AddRenderer(renderer);
- actor.SetSize(400, 400);
- Stage::GetCurrent().Add(actor);
- application.SendNotification();
- application.Render(0);
-
- // Don't add property / uniform map to renderer/actor/texture set/sampler
-
- shader.RegisterProperty( "uFadeColor", Color::MAGENTA );
-
- Property::Index geometryFadeColorIndex = geometry.RegisterProperty( "uFadeColor", Color::YELLOW );
-
- geometry.RegisterProperty( "uFadeColor", Color::BLACK );
-
-
- TestGlAbstraction& gl = application.GetGlAbstraction();
-
- application.SendNotification();
- application.Render(0);
-
- // Expect that the shader's fade color property is accessed
- Vector4 actualValue(Vector4::ZERO);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::MAGENTA, TEST_LOCATION );
-
- // Animate geometry's fade color property. Should be no change to uniform
- Animation animation = Animation::New(1.0f);
- KeyFrames keyFrames = KeyFrames::New();
- keyFrames.Add(0.0f, Color::WHITE);
- keyFrames.Add(1.0f, Color::TRANSPARENT);
- animation.AnimateBetween( Property( geometry, geometryFadeColorIndex ), keyFrames );
- animation.Play();
-
- application.SendNotification();
- application.Render(500);
-
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::MAGENTA, TEST_LOCATION );
-
- application.Render(500);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::MAGENTA, TEST_LOCATION );
-
- END_TEST;
-}
-
int UtcDaliRendererUniformMapMultipleUniforms01(void)
{
TestApplication application;
actor.RegisterProperty( "uUniform2", Color::GREEN );
textureSet.RegisterProperty( "uUniform3", Color::BLUE );
shader.RegisterProperty( "uUniform4", Color::MAGENTA );
- geometry.RegisterProperty( "uUniform5", Color::YELLOW );
TestGlAbstraction& gl = application.GetGlAbstraction();
DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uUniform3", uniform3Value ) );
DALI_TEST_EQUALS( uniform3Value, Color::BLUE, TEST_LOCATION );
- Vector4 uniform5Value(Vector4::ZERO);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uUniform4", uniform5Value ) );
- DALI_TEST_EQUALS( uniform5Value, Color::MAGENTA, TEST_LOCATION );
-
- Vector4 uniform6Value(Vector4::ZERO);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uUniform5", uniform6Value ) );
- DALI_TEST_EQUALS( uniform6Value, Color::YELLOW, TEST_LOCATION );
+ Vector4 uniform4Value(Vector4::ZERO);
+ DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uUniform4", uniform4Value ) );
+ DALI_TEST_EQUALS( uniform4Value, Color::MAGENTA, TEST_LOCATION );
END_TEST;
}
-
int UtcDaliRendererUniformMapMultipleUniforms02(void)
{
TestApplication application;
Property::Value value5(Matrix3::IDENTITY);
shader.RegisterProperty( "uANormalMatrix", value5 );
- Property::Value value6(Matrix::IDENTITY);
- geometry.RegisterProperty( "uAWorldMatrix", value6 );
-
TestGlAbstraction& gl = application.GetGlAbstraction();
application.SendNotification();
DALI_TEST_CHECK( gl.GetUniformValue<Matrix3>( "uANormalMatrix", uniform5Value ) );
DALI_TEST_EQUALS( uniform5Value, value5.Get<Matrix3>(), TEST_LOCATION );
- Matrix uniform6Value;
- DALI_TEST_CHECK( gl.GetUniformValue<Matrix>( "uAWorldMatrix", uniform6Value ) );
- DALI_TEST_EQUALS( uniform6Value, value6.Get<Matrix>(), TEST_LOCATION );
-
END_TEST;
}
// --------------------------------------------------------------------------
// index buffer
- unsigned indices[] = { 0, 2, 4, 6, 8, // offset = 0, count = 5
+ unsigned short indices[] = { 0, 2, 4, 6, 8, // offset = 0, count = 5
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, // offset = 5, count = 10
1, 3, 5, 7, 9, 1 }; // offset = 15, count = 6 // line strip
- Property::Map format;
- format["indices"] = Property::INTEGER;
- PropertyBuffer indexBuffer = PropertyBuffer::New( format );
- indexBuffer.SetData( indices, sizeof(indices)/sizeof(indices[0]));
// --------------------------------------------------------------------------
// vertex buffer
vertexBuffer.SetData( shapes, sizeof(shapes)/sizeof(shapes[0]));
// --------------------------------------------------------------------------
- geometry.SetIndexBuffer( indexBuffer );
+ geometry.SetIndexBuffer( indices, sizeof(indices)/sizeof(indices[0]) );
geometry.AddVertexBuffer( vertexBuffer );
// create shader
texturedQuadVertices.SetData( texturedQuadVertexData, 4 );
// Create indices
- unsigned int indexData[6] = { 0, 3, 1, 0, 2, 3 };
- Property::Map indexFormat;
- indexFormat["indices"] = Property::INTEGER;
- PropertyBuffer indices = PropertyBuffer::New( indexFormat );
- indices.SetData( indexData, sizeof(indexData)/sizeof(indexData[0]) );
+ unsigned short indexData[6] = { 0, 3, 1, 0, 2, 3 };
// Create the geometry object
Geometry texturedQuadGeometry = Geometry::New();
texturedQuadGeometry.AddVertexBuffer( texturedQuadVertices );
- texturedQuadGeometry.SetIndexBuffer( indices );
+ texturedQuadGeometry.SetIndexBuffer( indexData, sizeof(indexData)/sizeof(indexData[0]) );
return texturedQuadGeometry;
}
{ Vector2( halfQuadSize, halfQuadSize), Vector2(1.f, 1.f) } };
vertexData.SetData(texturedQuadVertexData, 4);
- unsigned int indexData[6] = { 0, 3, 1, 0, 2, 3 };
- Property::Map indexFormat;
- indexFormat["indices"] = Property::INTEGER;
- PropertyBuffer indices = PropertyBuffer::New( indexFormat );
- indices.SetData( indexData, sizeof(indexData)/sizeof(indexData[0]) );
+ unsigned short indexData[6] = { 0, 3, 1, 0, 2, 3 };
Geometry geometry = Geometry::New();
geometry.AddVertexBuffer( vertexData );
- geometry.SetIndexBuffer( indices );
+ geometry.SetIndexBuffer( indexData, sizeof(indexData)/sizeof(indexData[0]) );
return geometry;
}
*
* // Create indices
* unsigned int indexData[6] = { 0, 3, 1, 0, 2, 3 };
- * Property::Map indexFormat;
- * indexFormat["indices"] = Property::INTEGER;
- * PropertyBuffer indices = PropertyBuffer::New( indexFormat );
- * indices.SetData( indexData, 6 );
*
* // Create the geometry object
* Geometry texturedQuadGeometry = Geometry::New();
* texturedQuadGeometry.AddVertexBuffer( texturedQuadVertices );
- * texturedQuadGeometry.SetIndexBuffer( indices );
+ * texturedQuadGeometry.SetIndexBuffer( indexData, sizeof(indexData)/sizeof(indexData[0] );
*
*/
class DALI_IMPORT_API PropertyBuffer : public BaseHandle
}
Geometry::Geometry( const Geometry& handle )
-: Handle( handle )
+: BaseHandle( handle )
{
}
GetImplementation(*this).RemoveVertexBuffer( index );
}
-void Geometry::SetIndexBuffer( PropertyBuffer& indexBuffer )
+void Geometry::SetIndexBuffer( const unsigned short* indices, size_t count )
{
- DALI_ASSERT_ALWAYS( indexBuffer && "indexBuffer is not initialized ");
- GetImplementation(*this).SetIndexBuffer( GetImplementation( indexBuffer ) );
+ GetImplementation(*this).SetIndexBuffer( indices, count );
}
void Geometry::SetGeometryType( GeometryType geometryType )
}
Geometry::Geometry( Internal::Geometry* pointer )
-: Handle( pointer )
+: BaseHandle( pointer )
{
}
/**
* @brief Geometry is handle to an object that can be used to define a geometric elements.
*/
-class DALI_IMPORT_API Geometry : public Handle
+class DALI_IMPORT_API Geometry : public BaseHandle
{
public:
TRIANGLE_STRIP
};
- /**
- * @brief An enumeration of properties belonging to the Geometry class.
- */
- struct Property
- {
- enum
- {
- GEOMETRY_TYPE = DEFAULT_OBJECT_PROPERTY_START_INDEX, ///< name "geometryType", type STRING
- REQUIRES_DEPTH_TEST, ///< name "requiresDepthTesting", type BOOLEAN
- };
- };
/**
* @brief Creates a new Geometry object
void RemoveVertexBuffer( std::size_t index );
/**
- * @brief Set a PropertyBuffer to be used as a source of indices for the geometry
- *
- * This buffer is required to have exactly one component and it must be of the type Property::INTEGER
+ * @brief Set a the index data to be used as a source of indices for the geometry
*
- * By setting this buffer the will case the geometry to be rendered using indices.
- * To unset call SetIndexBuffer with an empty handle.
+ * Setting this buffer will cause the geometry to be rendered using indices.
+ * To unset call SetIndexBuffer with a null pointer or count 0
*
- * @param[in] indexBuffer PropertyBuffer to be used as a source of indices for the geometry
+ * @param[in] indices Array of indices
+ * @param[in] count Number of indices in the array
*/
- void SetIndexBuffer( PropertyBuffer& indexBuffer );
+ void SetIndexBuffer( const unsigned short* indices, size_t count );
/**
* @brief Set the type of primitives this geometry contains
sizeof( Internal::Render::Renderer ) );
const int GEOMETRY_MEMORY_SIZE(
sizeof( Internal::Geometry ) +
- sizeof( Internal::SceneGraph::Geometry ) +
- sizeof( Internal::SceneGraph::RenderGeometry) );
+ sizeof( Internal::Render::Geometry) );
const int PROPERTY_BUFFER_MEMORY_SIZE(
sizeof( Internal::PropertyBuffer ) +
sizeof( Internal::Render::PropertyBuffer ) );
}
// Create indices
- Vector< unsigned int > indices;
+ Vector< unsigned short > indices;
indices.Reserve( ( gridWidth + 2 ) * gridHeight * 2 - 2);
for( unsigned int row = 0u; row < gridHeight; ++row )
vertexPropertyBuffer->SetData( &vertices[ 0 ], vertices.size() );
}
- Property::Map indexFormat;
- indexFormat[ "indices" ] = Property::INTEGER;
- PropertyBufferPtr indexPropertyBuffer = PropertyBuffer::New( indexFormat );
- if( indices.Size() > 0 )
- {
- indexPropertyBuffer->SetData( &indices[ 0 ], indices.Size() );
- }
-
// Create the geometry object
GeometryPtr geometry = Geometry::New();
geometry->AddVertexBuffer( *vertexPropertyBuffer );
- geometry->SetIndexBuffer( *indexPropertyBuffer );
+ if( indices.Size() > 0 )
+ {
+ geometry->SetIndexBuffer( &indices[0], indices.Size() );
+ }
geometry->SetGeometryType( Dali::Geometry::TRIANGLE_STRIP );
return geometry;
namespace
{
-/**
- * |name |type |writable|animatable|constraint-input|enum for index-checking|
- */
-DALI_PROPERTY_TABLE_BEGIN
-DALI_PROPERTY( "geometryType", STRING, true, false, true, Dali::Geometry::Property::GEOMETRY_TYPE )
-DALI_PROPERTY( "requiresDepthTest", BOOLEAN, true, false, true, Dali::Geometry::Property::REQUIRES_DEPTH_TEST )
-DALI_PROPERTY_TABLE_END( DEFAULT_ACTOR_PROPERTY_START_INDEX )
-
-const ObjectImplHelper<DEFAULT_PROPERTY_COUNT> GEOMETRY_IMPL = { DEFAULT_PROPERTY_DETAILS };
-
BaseHandle Create()
{
return Dali::Geometry::New();
std::size_t Geometry::AddVertexBuffer( PropertyBuffer& vertexBuffer )
{
mVertexBuffers.push_back( &vertexBuffer );
- SceneGraph::AddVertexBufferMessage( GetEventThreadServices(), *mSceneObject, *vertexBuffer.GetRenderObject() );
+ SceneGraph::AddVertexBufferMessage( mEventThreadServices.GetUpdateManager(), *mRenderObject, *vertexBuffer.GetRenderObject() );
return mVertexBuffers.size() - 1u;
}
void Geometry::RemoveVertexBuffer( std::size_t index )
{
const Render::PropertyBuffer& renderPropertyBuffer = static_cast<const Render::PropertyBuffer&>( *(mVertexBuffers[index]->GetRenderObject()) );
- SceneGraph::RemoveVertexBufferMessage( GetEventThreadServices(), *mSceneObject, renderPropertyBuffer );
+ SceneGraph::RemoveVertexBufferMessage( mEventThreadServices.GetUpdateManager(), *mRenderObject, renderPropertyBuffer );
mVertexBuffers.erase( mVertexBuffers.begin() + index );
}
-void Geometry::SetIndexBuffer( PropertyBuffer& indexBuffer )
+void Geometry::SetIndexBuffer( const unsigned short* indices, size_t count )
{
- mIndexBuffer = &indexBuffer;
- SceneGraph::SetIndexBufferMessage( GetEventThreadServices(), *mSceneObject, *indexBuffer.GetRenderObject() );
+ Dali::Vector<unsigned short> indexData;
+ if( indices && count )
+ {
+ indexData.Resize( count );
+ std::copy( indices, indices + count, indexData.Begin() );
+ }
+
+ SceneGraph::SetIndexBufferMessage( mEventThreadServices.GetUpdateManager(), *mRenderObject, indexData );
}
void Geometry::SetGeometryType( Dali::Geometry::GeometryType geometryType )
{
if( geometryType != mGeometryType )
{
- SceneGraph::SetGeometryTypeMessage(GetEventThreadServices(),
- *mSceneObject,
- geometryType );
+ SceneGraph::SetGeometryTypeMessage(mEventThreadServices.GetUpdateManager(), *mRenderObject, geometryType );
mGeometryType = geometryType;
}
{
if( requiresDepthTest != mRequiresDepthTest )
{
- SceneGraph::SetGeometryRequiresDepthTestMessage(GetEventThreadServices(),
- *mSceneObject,
- requiresDepthTest );
+ SceneGraph::SetGeometryRequiresDepthTestMessage(mEventThreadServices.GetUpdateManager(), *mRenderObject, requiresDepthTest );
mRequiresDepthTest = requiresDepthTest;
}
return mRequiresDepthTest;
}
-const SceneGraph::Geometry* Geometry::GetGeometrySceneObject() const
-{
- return mSceneObject;
-}
-
-unsigned int Geometry::GetDefaultPropertyCount() const
-{
- return GEOMETRY_IMPL.GetDefaultPropertyCount();
-}
-
-void Geometry::GetDefaultPropertyIndices( Property::IndexContainer& indices ) const
-{
- GEOMETRY_IMPL.GetDefaultPropertyIndices( indices );
-}
-
-const char* Geometry::GetDefaultPropertyName(Property::Index index) const
+const Render::Geometry* Geometry::GetRenderObject() const
{
- return GEOMETRY_IMPL.GetDefaultPropertyName( index );
-}
-
-Property::Index Geometry::GetDefaultPropertyIndex( const std::string& name ) const
-{
- return GEOMETRY_IMPL.GetDefaultPropertyIndex( name );
-}
-
-bool Geometry::IsDefaultPropertyWritable( Property::Index index ) const
-{
- return GEOMETRY_IMPL.IsDefaultPropertyWritable( index );
-}
-
-bool Geometry::IsDefaultPropertyAnimatable( Property::Index index ) const
-{
- return GEOMETRY_IMPL.IsDefaultPropertyAnimatable( index );
-}
-
-bool Geometry::IsDefaultPropertyAConstraintInput( Property::Index index ) const
-{
- return GEOMETRY_IMPL.IsDefaultPropertyAConstraintInput( index );
-}
-
-Property::Type Geometry::GetDefaultPropertyType( Property::Index index ) const
-{
- return GEOMETRY_IMPL.GetDefaultPropertyType( index );
-}
-
-void Geometry::SetDefaultProperty( Property::Index index,
- const Property::Value& propertyValue )
-{
- switch( index )
- {
- case Dali::Geometry::Property::GEOMETRY_TYPE :
- {
- Dali::Geometry::GeometryType geometryType = static_cast<Dali::Geometry::GeometryType>(propertyValue.Get<int>());
- if( geometryType != mGeometryType )
- {
- SceneGraph::SetGeometryTypeMessage(GetEventThreadServices(), *mSceneObject, geometryType );
- mGeometryType = geometryType;
- }
- break;
- }
- case Dali::Geometry::Property::REQUIRES_DEPTH_TEST :
- {
- bool requiresDepthTest = propertyValue.Get<bool>();
- if( requiresDepthTest != mRequiresDepthTest )
- {
- SceneGraph::SetGeometryRequiresDepthTestMessage(GetEventThreadServices(), *mSceneObject, requiresDepthTest);
- mRequiresDepthTest = requiresDepthTest;
- }
- break;
- }
- }
-}
-
-void Geometry::SetSceneGraphProperty( Property::Index index,
- const PropertyMetadata& entry,
- const Property::Value& value )
-{
- GEOMETRY_IMPL.SetSceneGraphProperty( GetEventThreadServices(), this, index, entry, value );
-}
-
-Property::Value Geometry::GetDefaultProperty( Property::Index index ) const
-{
- Property::Value value;
-
- switch( index )
- {
- case Dali::Geometry::Property::GEOMETRY_TYPE :
- {
- if( mSceneObject )
- {
- value = mGeometryType;
- }
- break;
- }
- case Dali::Geometry::Property::REQUIRES_DEPTH_TEST :
- {
- if( mSceneObject )
- {
- value = mRequiresDepthTest;
- }
- break;
- }
- }
-
- return value;
-}
-
-const SceneGraph::PropertyOwner* Geometry::GetPropertyOwner() const
-{
- return mSceneObject;
-}
-
-const SceneGraph::PropertyOwner* Geometry::GetSceneObject() const
-{
- return mSceneObject;
-}
-
-const SceneGraph::PropertyBase* Geometry::GetSceneObjectAnimatableProperty( Property::Index index ) const
-{
- const SceneGraph::PropertyBase* property = NULL;
- if( OnStage() )
- {
- property = GEOMETRY_IMPL.GetRegisteredSceneGraphProperty ( this,
- &Geometry::FindAnimatableProperty,
- &Geometry::FindCustomProperty,
- index );
- }
-
- return property;
-}
-
-const PropertyInputImpl* Geometry::GetSceneObjectInputProperty( Property::Index index ) const
-{
- const PropertyInputImpl* property = NULL;
-
- if( OnStage() )
- {
- const SceneGraph::PropertyBase* baseProperty =
- GEOMETRY_IMPL.GetRegisteredSceneGraphProperty ( this,
- &Geometry::FindAnimatableProperty,
- &Geometry::FindCustomProperty,
- index );
-
- property = static_cast<const PropertyInputImpl*>( baseProperty );
- }
-
- return property;
-}
-
-bool Geometry::OnStage() const
-{
- return mOnStage;
-}
-
-void Geometry::Connect()
-{
- mOnStage = true;
-}
-
-void Geometry::Disconnect()
-{
- mOnStage = false;
+ return mRenderObject;
}
Geometry::Geometry()
-: mSceneObject( NULL ),
- mIndexBuffer( NULL ),
+: mEventThreadServices( *Stage::GetCurrent() ),
+ mRenderObject( NULL ),
mGeometryType(Dali::Geometry::TRIANGLES),
- mRequiresDepthTest(false),
- mOnStage( false )
+ mRequiresDepthTest(false)
{
}
void Geometry::Initialize()
{
- EventThreadServices& eventThreadServices = GetEventThreadServices();
- SceneGraph::UpdateManager& updateManager = eventThreadServices.GetUpdateManager();
-
- mSceneObject = new SceneGraph::Geometry();
- AddMessage( updateManager, updateManager.GetGeometryOwner(), *mSceneObject );
-
- eventThreadServices.RegisterObject( this );
+ mRenderObject = new Render::Geometry();
+ AddGeometry( mEventThreadServices.GetUpdateManager(), *mRenderObject );
}
Geometry::~Geometry()
{
- if( EventThreadServices::IsCoreRunning() )
+ if( EventThreadServices::IsCoreRunning() && mRenderObject )
{
- EventThreadServices& eventThreadServices = GetEventThreadServices();
- SceneGraph::UpdateManager& updateManager = eventThreadServices.GetUpdateManager();
- RemoveMessage( updateManager, updateManager.GetGeometryOwner(), *mSceneObject );
-
- eventThreadServices.UnregisterObject( this );
+ RemoveGeometry( mEventThreadServices.GetUpdateManager(), *mRenderObject );
}
}
#include <dali/internal/event/common/object-connector.h> // Dali::Internal::ObjectConnector
#include <dali/internal/event/common/object-impl.h> // Dali::Internal::Object
#include <dali/internal/event/common/property-buffer-impl.h> // Dali::Internal::PropertyBuffer
+#include <dali/internal/render/renderers/render-geometry.h>
namespace Dali
{
* Geometry is an object that contains an array of structures of values that
* can be accessed as properties.
*/
-class Geometry : public Object, public Connectable
+class Geometry : public BaseObject
{
public:
/**
* @copydoc Dali::Geometry::SetIndexBuffer()
*/
- void SetIndexBuffer( PropertyBuffer& indexBuffer );
+ void SetIndexBuffer( const unsigned short* indices, size_t count );
/**
* @copydoc Dali::Geometry::SetGeometryType()
*
* @return the geometry scene object
*/
- const SceneGraph::Geometry* GetGeometrySceneObject() const;
+ const Render::Geometry* GetRenderObject() const;
-public: // Default property extensions from Object
-
- /**
- * @copydoc Dali::Internal::Object::GetDefaultPropertyCount()
- */
- virtual unsigned int GetDefaultPropertyCount() const;
-
- /**
- * @copydoc Dali::Internal::Object::GetDefaultPropertyIndices()
- */
- virtual void GetDefaultPropertyIndices( Property::IndexContainer& indices ) const;
-
- /**
- * @copydoc Dali::Internal::Object::GetDefaultPropertyName()
- */
- virtual const char* GetDefaultPropertyName(Property::Index index) const;
-
- /**
- * @copydoc Dali::Internal::Object::GetDefaultPropertyIndex()
- */
- virtual Property::Index GetDefaultPropertyIndex(const std::string& name) const;
-
- /**
- * @copydoc Dali::Internal::Object::IsDefaultPropertyWritable()
- */
- virtual bool IsDefaultPropertyWritable(Property::Index index) const;
-
- /**
- * @copydoc Dali::Internal::Object::IsDefaultPropertyAnimatable()
- */
- virtual bool IsDefaultPropertyAnimatable(Property::Index index) const;
-
- /**
- * @copydoc Dali::Internal::Object::IsDefaultPropertyAConstraintInput()
- */
- virtual bool IsDefaultPropertyAConstraintInput( Property::Index index ) const;
-
- /**
- * @copydoc Dali::Internal::Object::GetDefaultPropertyType()
- */
- virtual Property::Type GetDefaultPropertyType(Property::Index index) const;
-
- /**
- * @copydoc Dali::Internal::Object::SetDefaultProperty()
- */
- virtual void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue);
-
- /**
- * @copydoc Dali::Internal::Object::SetSceneGraphProperty()
- */
- virtual void SetSceneGraphProperty( Property::Index index, const PropertyMetadata& entry, const Property::Value& value );
-
- /**
- * @copydoc Dali::Internal::Object::GetDefaultProperty()
- */
- virtual Property::Value GetDefaultProperty( Property::Index index ) const;
-
- /**
- * @copydoc Dali::Internal::Object::GetPropertyOwner()
- */
- virtual const SceneGraph::PropertyOwner* GetPropertyOwner() const;
-
- /**
- * @copydoc Dali::Internal::Object::GetSceneObject()
- */
- virtual const SceneGraph::PropertyOwner* GetSceneObject() const;
-
- /**
- * @copydoc Dali::Internal::Object::GetSceneObjectAnimatableProperty()
- */
- virtual const SceneGraph::PropertyBase* GetSceneObjectAnimatableProperty( Property::Index index ) const;
-
- /**
- * @copydoc Dali::Internal::Object::GetSceneObjectInputProperty()
- */
- virtual const PropertyInputImpl* GetSceneObjectInputProperty( Property::Index index ) const;
-
-public: // Functions from Connectable
- /**
- * @copydoc Dali::Internal::Connectable::OnStage()
- */
- virtual bool OnStage() const;
-
- /**
- * @copydoc Dali::Internal::Connectable::Connect()
- */
- virtual void Connect();
+private: // implementation
/**
- * @copydoc Dali::Internal::Connectable::Disconnect()
+ * Constructor
*/
- virtual void Disconnect();
-
-private: // implementation
Geometry();
/**
void Initialize();
protected:
+
/**
* A reference counted object may only be deleted by calling Unreference()
*/
private: // data
- SceneGraph::Geometry* mSceneObject;
+ EventThreadServices& mEventThreadServices; ///<Used to send messages to the render thread via update thread
+ Render::Geometry* mRenderObject;
std::vector<PropertyBufferPtr> mVertexBuffers; ///< Vector of intrusive pointers to vertex buffers
- PropertyBufferPtr mIndexBuffer; ///< Intrusive pointer to index buffer
-
Dali::Geometry::GeometryType mGeometryType; ///< Geometry type (cached)
bool mRequiresDepthTest; ///< Establish if geometry requires depth testing (cached)
- bool mOnStage;
};
} // namespace Internal
#include <dali/internal/event/common/property-input-impl.h>
#include <dali/internal/update/rendering/scene-graph-renderer.h>
#include <dali/internal/update/manager/update-manager.h>
+#include <dali/internal/render/renderers/render-geometry.h>
namespace Dali
{
void Renderer::SetGeometry( Geometry& geometry )
{
- mGeometryConnector.Set( geometry, OnStage() );
- const SceneGraph::Geometry* geometrySceneObject = geometry.GetGeometrySceneObject();
+ mGeometry = &geometry;
+ const Render::Geometry* geometrySceneObject = geometry.GetRenderObject();
SetGeometryMessage( GetEventThreadServices(), *mSceneObject, *geometrySceneObject );
}
Geometry* Renderer::GetGeometry() const
{
- return mGeometryConnector.Get().Get();
+ return mGeometry.Get();
}
void Renderer::SetTextures( TextureSet& textureSet )
if( mOnStageCount == 0 )
{
OnStageConnectMessage( GetEventThreadServices(), *mSceneObject );
- mGeometryConnector.OnStageConnect();
mTextureSetConnector.OnStageConnect();
}
++mOnStageCount;
if( mOnStageCount == 0 )
{
OnStageDisconnectMessage( GetEventThreadServices(), *mSceneObject);
- mGeometryConnector.OnStageDisconnect();
mTextureSetConnector.OnStageDisconnect();
}
}
private: // data
SceneGraph::Renderer* mSceneObject;
Vector4* mBlendColor; ///< Local copy of blend color, pointer only as its rarely used
- ObjectConnector<Geometry> mGeometryConnector; ///< Connector that holds the geometry used by this renderer
+ GeometryPtr mGeometry; ///< Connector that holds the geometry used by this renderer
ObjectConnector<TextureSet> mTextureSetConnector; ///< Connector that holds the texture set used by this renderer
IntrusivePtr<Shader> mShader; ///< Connector that holds the shader used by this renderer
$(internal_src_dir)/update/nodes/scene-graph-layer.cpp \
$(internal_src_dir)/update/render-tasks/scene-graph-render-task.cpp \
$(internal_src_dir)/update/render-tasks/scene-graph-render-task-list.cpp \
- $(internal_src_dir)/update/rendering/scene-graph-geometry.cpp \
$(internal_src_dir)/update/rendering/scene-graph-texture-set.cpp \
$(internal_src_dir)/update/rendering/scene-graph-renderer.cpp \
$(internal_src_dir)/update/resources/resource-manager.cpp
typedef OwnerContainer< Render::Renderer* > RendererOwnerContainer;
typedef RendererOwnerContainer::Iterator RendererOwnerIter;
-typedef OwnerContainer< RenderGeometry* > RenderGeometryOwnerContainer;
-typedef RenderGeometryOwnerContainer::Iterator RenderGeometryOwnerIter;
+typedef OwnerContainer< Render::Geometry* > GeometryOwnerContainer;
+typedef GeometryOwnerContainer::Iterator GeometryOwnerIter;
typedef OwnerContainer< Render::Sampler* > SamplerOwnerContainer;
typedef SamplerOwnerContainer::Iterator SamplerOwnerIter;
RendererOwnerContainer rendererContainer; ///< List of owned renderers
SamplerOwnerContainer samplerContainer; ///< List of owned samplers
PropertyBufferOwnerContainer propertyBufferContainer; ///< List of owned property buffers
- RenderGeometryOwnerContainer renderGeometryContainer; ///< List of owned RenderGeometries
+ GeometryOwnerContainer geometryContainer; ///< List of owned Geometries
bool renderersAdded;
propertyBuffer->SetData( data, size );
}
-void RenderManager::AddGeometry( RenderGeometry* renderGeometry )
+void RenderManager::SetIndexBuffer( Render::Geometry* geometry, Dali::Vector<unsigned short>& indices )
{
- mImpl->renderGeometryContainer.PushBack( renderGeometry );
+ geometry->SetIndexBuffer( indices );
}
-void RenderManager::RemoveGeometry( RenderGeometry* renderGeometry )
+void RenderManager::AddGeometry( Render::Geometry* geometry )
{
- DALI_ASSERT_DEBUG( NULL != renderGeometry );
+ mImpl->geometryContainer.PushBack( geometry );
+}
+
+void RenderManager::RemoveGeometry( Render::Geometry* geometry )
+{
+ DALI_ASSERT_DEBUG( NULL != geometry );
- RenderGeometryOwnerContainer& geometries = mImpl->renderGeometryContainer;
+ GeometryOwnerContainer& geometries = mImpl->geometryContainer;
// Find the geometry
- for ( RenderGeometryOwnerIter iter = geometries.Begin(); iter != geometries.End(); ++iter )
+ for ( GeometryOwnerIter iter = geometries.Begin(); iter != geometries.End(); ++iter )
{
- if ( *iter == renderGeometry )
+ if ( *iter == geometry )
{
geometries.Erase( iter ); // Geometry found; now destroy it
break;
}
}
-void RenderManager::AddPropertyBuffer( RenderGeometry* renderGeometry, Render::PropertyBuffer* propertyBuffer, bool isIndexBuffer )
+void RenderManager::AddVertexBuffer( Render::Geometry* geometry, Render::PropertyBuffer* propertyBuffer )
{
- DALI_ASSERT_DEBUG( NULL != renderGeometry );
+ DALI_ASSERT_DEBUG( NULL != geometry );
- RenderGeometryOwnerContainer& geometries = mImpl->renderGeometryContainer;
+ GeometryOwnerContainer& geometries = mImpl->geometryContainer;
// Find the renderer
- for ( RenderGeometryOwnerIter iter = geometries.Begin(); iter != geometries.End(); ++iter )
+ for ( GeometryOwnerIter iter = geometries.Begin(); iter != geometries.End(); ++iter )
{
- if ( *iter == renderGeometry )
+ if ( *iter == geometry )
{
- (*iter)->AddPropertyBuffer( propertyBuffer, isIndexBuffer );
+ (*iter)->AddPropertyBuffer( propertyBuffer );
break;
}
}
}
-void RenderManager::RemovePropertyBuffer( RenderGeometry* renderGeometry, Render::PropertyBuffer* propertyBuffer )
+void RenderManager::RemoveVertexBuffer( Render::Geometry* geometry, Render::PropertyBuffer* propertyBuffer )
{
- DALI_ASSERT_DEBUG( NULL != renderGeometry );
+ DALI_ASSERT_DEBUG( NULL != geometry );
- RenderGeometryOwnerContainer& geometries = mImpl->renderGeometryContainer;
+ GeometryOwnerContainer& geometries = mImpl->geometryContainer;
// Find the renderer
- for ( RenderGeometryOwnerIter iter = geometries.Begin(); iter != geometries.End(); ++iter )
+ for ( GeometryOwnerIter iter = geometries.Begin(); iter != geometries.End(); ++iter )
{
- if ( *iter == renderGeometry )
+ if ( *iter == geometry )
{
(*iter)->RemovePropertyBuffer( propertyBuffer );
break;
}
}
-void RenderManager::SetGeometryType( RenderGeometry* geometry, int type )
+void RenderManager::SetGeometryType( Render::Geometry* geometry, unsigned int geometryType )
{
- geometry->SetGeometryType( static_cast<Geometry::GeometryType>(type) );
+ geometry->SetGeometryType( Render::Geometry::GeometryType(geometryType) );
}
-void RenderManager::SetGeometryRequiresDepthTest( RenderGeometry* geometry, bool requiresDepthTest )
+void RenderManager::SetGeometryRequiresDepthTest( Render::Geometry* geometry, bool requiresDepthTest )
{
geometry->SetRequiresDepthTest( requiresDepthTest );
}
}
//Notify RenderGeometries that rendering has finished
- for ( RenderGeometryOwnerIter iter = mImpl->renderGeometryContainer.Begin(); iter != mImpl->renderGeometryContainer.End(); ++iter )
+ for ( GeometryOwnerIter iter = mImpl->geometryContainer.Begin(); iter != mImpl->geometryContainer.End(); ++iter )
{
(*iter)->OnRenderFinished();
}
class Renderer;
class Sampler;
class RenderTracker;
+class Geometry;
}
namespace SceneGraph
class RenderInstruction;
class RenderInstructionContainer;
class Shader;
-class RenderGeometry;
class PropertyBufferDataProvider;
/**
* @param[in] geometry The geometry to add.
* @post geometry is owned by RenderManager
*/
- void AddGeometry( RenderGeometry* geometry );
+ void AddGeometry( Render::Geometry* geometry );
/**
* Remove a geometry from the render manager.
* @param[in] geometry The geometry to remove.
* @post geometry is destroyed.
*/
- void RemoveGeometry( RenderGeometry* geometry );
+ void RemoveGeometry( Render::Geometry* geometry );
/**
- * Adds a property buffer to a RenderGeometry from the render manager.
+ * Adds a property buffer to a geometry from the render manager.
* @param[in] geometry The geometry
* @param[in] propertyBuffer The property buffer to remove.
- * @param[in] isIndexBuffer True if the property buffer is intended to be used as an index buffer
*/
- void AddPropertyBuffer( RenderGeometry* renderGeometry, Render::PropertyBuffer* propertyBuffer, bool isIndexBuffer );
+ void AddVertexBuffer( Render::Geometry* geometry, Render::PropertyBuffer* propertyBuffer );
/**
- * Remove a property buffer from a RenderGeometry from the render manager.
+ * Remove a property buffer from a Render::Geometry from the render manager.
* @param[in] geometry The geometry
* @param[in] propertyBuffer The property buffer to remove.
* @post property buffer is destroyed.
*/
- void RemovePropertyBuffer( RenderGeometry* renderGeometry, Render::PropertyBuffer* propertyBuffer );
+ void RemoveVertexBuffer( Render::Geometry* geometry, Render::PropertyBuffer* propertyBuffer );
/**
* Sets the format of an existing property buffer
void SetPropertyBufferData( Render::PropertyBuffer* propertyBuffer, Dali::Vector<char>* data, size_t size );
/**
+ * Sets the data for the index buffer of an existing geometry
+ * @param[in] geometry The geometry
+ * @param[in] data A vector containing the indices
+ */
+ void SetIndexBuffer( Render::Geometry* geometry, Dali::Vector<unsigned short>& data );
+
+ /**
* Set the geometry type of an existing render geometry
* @param[in] geometry The render geometry
* @param[in] geometryType The new geometry type
*/
- void SetGeometryType( RenderGeometry* geometry, int geometryType );
+ 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( RenderGeometry* geometry, bool requiresDepthTest );
+ void SetGeometryRequiresDepthTest( Render::Geometry* geometry, bool requiresDepthTest );
/**
* Adds a render tracker to the RenderManager. RenderManager takes ownership of the
GLenum glTargetEnum = GL_ARRAY_BUFFER;
- if(ELEMENT_ARRAY_BUFFER == target)
- {
- glTargetEnum = GL_ELEMENT_ARRAY_BUFFER;
- }
- else if(TRANSFORM_FEEDBACK_BUFFER == target)
- {
- glTargetEnum = GL_TRANSFORM_FEEDBACK_BUFFER;
- }
-
// make sure the buffer is bound, don't perform any checks because size may be zero
if(ARRAY_BUFFER == target)
{
}
else if(ELEMENT_ARRAY_BUFFER == target)
{
+ glTargetEnum = GL_ELEMENT_ARRAY_BUFFER;
mContext.BindElementArrayBuffer( mBufferId );
}
else if(TRANSFORM_FEEDBACK_BUFFER == target)
{
+ glTargetEnum = GL_TRANSFORM_FEEDBACK_BUFFER;
mContext.BindTransformFeedbackBuffer( mBufferId );
}
{
namespace Internal
{
-namespace SceneGraph
+namespace Render
{
-RenderGeometry::RenderGeometry( GeometryType type, bool requiresDepthTest )
-: mIndexBuffer(0),
- mGeometryType( type ),
- mRequiresDepthTest(requiresDepthTest ),
+Geometry::Geometry()
+: mIndices(),
+ mIndexBuffer(NULL),
+ mGeometryType( Dali::Geometry::TRIANGLES ),
+ mIndicesChanged(false),
+ mRequiresDepthTest(false ),
mHasBeenUpdated(false),
mAttributesChanged(true)
{
}
-RenderGeometry::~RenderGeometry()
+Geometry::~Geometry()
{
}
-void RenderGeometry::GlContextCreated( Context& context )
+void Geometry::GlContextCreated( Context& context )
{
}
-void RenderGeometry::GlContextDestroyed()
+void Geometry::GlContextDestroyed()
{
}
-void RenderGeometry::AddPropertyBuffer( Render::PropertyBuffer* propertyBuffer, bool isIndexBuffer )
+void Geometry::AddPropertyBuffer( Render::PropertyBuffer* propertyBuffer )
{
- if( isIndexBuffer )
- {
- mIndexBuffer = propertyBuffer;
- }
- else
- {
- mVertexBuffers.PushBack( propertyBuffer );
- mAttributesChanged = true;
- }
+ mVertexBuffers.PushBack( propertyBuffer );
+ mAttributesChanged = true;
}
-void RenderGeometry::RemovePropertyBuffer( const Render::PropertyBuffer* propertyBuffer )
+void Geometry::SetIndexBuffer( Dali::Vector<unsigned short>& indices )
{
- if( propertyBuffer == mIndexBuffer )
- {
- mIndexBuffer = 0;
- }
- else
+ mIndices.Swap( indices );
+ mIndicesChanged = true;
+}
+
+void Geometry::RemovePropertyBuffer( const Render::PropertyBuffer* propertyBuffer )
+{
+ size_t bufferCount = mVertexBuffers.Size();
+ for( size_t i(0); i<bufferCount; ++i )
{
- size_t bufferCount = mVertexBuffers.Size();
- for( size_t i(0); i<bufferCount; ++i )
+ if( propertyBuffer == mVertexBuffers[i] )
{
- if( propertyBuffer == mVertexBuffers[i] )
- {
- //This will delete the gpu buffer associated to the RenderPropertyBuffer if there is one
- mVertexBuffers.Remove( mVertexBuffers.Begin()+i);
- mAttributesChanged = true;
- break;
- }
+ //This will delete the gpu buffer associated to the RenderPropertyBuffer if there is one
+ mVertexBuffers.Remove( mVertexBuffers.Begin()+i);
+ mAttributesChanged = true;
+ break;
}
}
}
-void RenderGeometry::GetAttributeLocationFromProgram( Vector<GLint>& attributeLocation, Program& program, BufferIndex bufferIndex ) const
+void Geometry::GetAttributeLocationFromProgram( Vector<GLint>& attributeLocation, Program& program, BufferIndex bufferIndex ) const
{
attributeLocation.Clear();
}
}
-void RenderGeometry::OnRenderFinished()
+void Geometry::OnRenderFinished()
{
mHasBeenUpdated = false;
mAttributesChanged = false;
}
-void RenderGeometry::UploadAndDraw(
+void Geometry::UploadAndDraw(
Context& context,
BufferIndex bufferIndex,
Vector<GLint>& attributeLocation,
if( !mHasBeenUpdated )
{
// Update buffers
- if( mIndexBuffer )
+ if( mIndicesChanged )
{
- if(!mIndexBuffer->Update( context, true ) )
+ if( mIndices.Empty() )
{
- //Index buffer is not ready ( Size, data or format has not been specified yet )
- return;
+ mIndexBuffer = NULL;
+ }
+ else
+ {
+ if ( mIndexBuffer == NULL )
+ {
+ mIndexBuffer = new GpuBuffer( context );
+ }
+
+ std::size_t bufferSize = sizeof( unsigned short ) * mIndices.Size();
+ mIndexBuffer->UpdateDataBuffer( bufferSize, &mIndices[0], GpuBuffer::STATIC_DRAW, GpuBuffer::ELEMENT_ARRAY_BUFFER );
}
+
+ mIndicesChanged = false;
}
for( unsigned int i = 0; i < mVertexBuffers.Count(); ++i )
{
- if( !mVertexBuffers[i]->Update( context, false ) )
+ if( !mVertexBuffers[i]->Update( context ) )
{
//Vertex buffer is not ready ( Size, data or format has not been specified yet )
return;
}
//Bind buffers to attribute locations
- unsigned int base = 0;
- for( unsigned int i = 0; i < mVertexBuffers.Count(); ++i )
+ unsigned int base = 0u;
+ size_t vertexBufferCount(mVertexBuffers.Count());
+ for( unsigned int i = 0; i < vertexBufferCount; ++i )
{
mVertexBuffers[i]->BindBuffer( GpuBuffer::ARRAY_BUFFER );
base += mVertexBuffers[i]->EnableVertexAttributes( context, attributeLocation, base );
}
- if( mIndexBuffer )
- {
- mIndexBuffer->BindBuffer( GpuBuffer::ELEMENT_ARRAY_BUFFER );
- }
-
- //Bind index buffer
+ GLenum geometryGLType(0);
unsigned int numIndices(0u);
intptr_t firstIndexOffset(0u);
if( mIndexBuffer )
{
- numIndices = mIndexBuffer->GetDataSize() / mIndexBuffer->GetElementSize();
+ numIndices = mIndices.Size();
+
+ if( elementBufferOffset )
+ {
+ elementBufferOffset = elementBufferOffset >= numIndices ? numIndices- 1 : elementBufferOffset;
+ firstIndexOffset = elementBufferOffset * sizeof(GLushort);
+ }
if ( elementBufferCount )
{
- numIndices = elementBufferCount > numIndices ? numIndices : elementBufferCount;
+ numIndices = std::min( elementBufferCount, numIndices - elementBufferOffset );
}
- firstIndexOffset = elementBufferOffset * sizeof(GLushort);
}
- //Draw call
switch(mGeometryType)
{
case Dali::Geometry::TRIANGLES:
{
- if( numIndices )
- {
- context.DrawElements(GL_TRIANGLES, numIndices, GL_UNSIGNED_SHORT, reinterpret_cast<void*>(firstIndexOffset) );
- }
- else
- {
- unsigned int numVertices = mVertexBuffers[0]->GetElementCount();
- context.DrawArrays( GL_TRIANGLES, 0, numVertices );
- }
+ geometryGLType = GL_TRIANGLES;
break;
}
case Dali::Geometry::LINES:
{
- if( numIndices )
- {
- context.DrawElements(GL_LINES, numIndices, GL_UNSIGNED_SHORT, reinterpret_cast<void*>(firstIndexOffset) );
- }
- else
- {
- unsigned int numVertices = mVertexBuffers[0]->GetElementCount();
- context.DrawArrays( GL_LINES, 0, numVertices );
- }
+ geometryGLType = GL_LINES;
break;
}
case Dali::Geometry::POINTS:
{
- unsigned int numVertices = mVertexBuffers[0]->GetElementCount();
- context.DrawArrays(GL_POINTS, 0, numVertices );
+ geometryGLType = GL_POINTS;
break;
}
case Dali::Geometry::TRIANGLE_STRIP:
{
- if( numIndices )
- {
- context.DrawElements(GL_TRIANGLE_STRIP, numIndices, GL_UNSIGNED_SHORT, reinterpret_cast<void*>(firstIndexOffset) );
- }
- else
- {
- unsigned int numVertices = mVertexBuffers[0]->GetElementCount();
- context.DrawArrays(GL_TRIANGLE_STRIP, 0, numVertices );
- }
+ geometryGLType = GL_TRIANGLE_STRIP;
break;
}
case Dali::Geometry::TRIANGLE_FAN:
{
- if( numIndices )
- {
- context.DrawElements(GL_TRIANGLE_FAN, numIndices, GL_UNSIGNED_SHORT, reinterpret_cast<void*>(firstIndexOffset) );
- }
- else
- {
- unsigned int numVertices = mVertexBuffers[0]->GetElementCount();
- context.DrawArrays(GL_TRIANGLE_FAN, 0, numVertices );
- }
+ geometryGLType = GL_TRIANGLE_FAN;
break;
}
case Dali::Geometry::LINE_LOOP:
{
- if( numIndices )
- {
- context.DrawElements(GL_LINE_LOOP, numIndices, GL_UNSIGNED_SHORT, reinterpret_cast<void*>(firstIndexOffset) );
- }
- else
- {
- unsigned int numVertices = mVertexBuffers[0]->GetElementCount();
- context.DrawArrays(GL_LINE_LOOP, 0, numVertices );
- }
+ geometryGLType = GL_LINE_LOOP;
break;
}
case Dali::Geometry::LINE_STRIP:
{
- if( numIndices )
- {
- context.DrawElements(GL_LINE_STRIP, numIndices, GL_UNSIGNED_SHORT, reinterpret_cast<void*>(firstIndexOffset) );
- }
- else
- {
- unsigned int numVertices = mVertexBuffers[0]->GetElementCount();
- context.DrawArrays(GL_LINE_STRIP, 0, numVertices );
- }
+ geometryGLType = GL_LINE_STRIP;
break;
}
default:
}
}
- //Disable atrributes
+ //Draw call
+ if( mIndexBuffer && geometryGLType != GL_POINTS )
+ {
+ //Indexed draw call
+ mIndexBuffer->Bind( GpuBuffer::ELEMENT_ARRAY_BUFFER );
+ context.DrawElements(geometryGLType, numIndices, GL_UNSIGNED_SHORT, reinterpret_cast<void*>(firstIndexOffset));
+ }
+ else
+ {
+ //Unindex draw call
+ unsigned int numVertices(0u);
+ if( vertexBufferCount > 0 )
+ {
+ numVertices = mVertexBuffers[0]->GetElementCount();
+ }
+
+ context.DrawArrays( geometryGLType, 0, numVertices );
+ }
+
+ //Disable attributes
for( unsigned int i = 0; i < attributeLocation.Count(); ++i )
{
if( attributeLocation[i] != -1 )
-#ifndef DALI_INTERNAL_SCENE_GRAPH_RENDER_GEOMETRY_H
-#define DALI_INTERNAL_SCENE_GRAPH_RENDER_GEOMETRY_H
+#ifndef DALI_INTERNAL_RENDER_GEOMETRY_H
+#define DALI_INTERNAL_RENDER_GEOMETRY_H
/*
* Copyright (c) 2015 Samsung Electronics Co., Ltd.
#include <dali/public-api/common/dali-vector.h>
#include <dali/devel-api/common/owner-container.h>
+#include <dali/devel-api/rendering/geometry.h>
+#include <dali/internal/common/owner-pointer.h>
#include <dali/integration-api/gl-defines.h>
#include <dali/internal/common/buffer-index.h>
#include <dali/internal/common/owner-pointer.h>
#include <dali/integration-api/gl-abstraction.h>
-#include <dali/internal/update/rendering/scene-graph-geometry.h>
+#include <dali/devel-api/rendering/geometry.h>
+
namespace Dali
{
namespace Render
{
class PropertyBuffer;
-}
-
-namespace SceneGraph
-{
/**
* This class encapsulates the GPU buffers. It is used to upload vertex data
* to it's GPU buffers, to bind all the buffers and to setup/teardown vertex attribute
* bindings
*/
-class RenderGeometry
+class Geometry
{
public:
+ typedef Dali::Geometry::GeometryType GeometryType;
+
+ Geometry();
- typedef SceneGraph::Geometry::GeometryType GeometryType;
- /**
- * Constructor. Creates a render geometry object with no GPU buffers.
- * @param[in] center The center of the geometry
- * @param[in] geometryType The geometry type
- * @param[in] requiresDepthTest True if geometry requires depth testing, false otherwise
- */
- RenderGeometry( GeometryType geometryType, bool requiresDepthTest );
/**
* Destructor
*/
- ~RenderGeometry();
+ ~Geometry();
/**
* Called on Gl Context created
/**
* Adds a property buffer to the geometry
* @param[in] dataProvider The PropertyBuffer data provider
- * @param[in] isIndexBuffer True if the property buffer is intended to be used as an index buffer
*/
- void AddPropertyBuffer( Render::PropertyBuffer* propertyBuffer, bool isIndexBuffer );
+ void AddPropertyBuffer( Render::PropertyBuffer* propertyBuffer );
+
+ /**
+ * Set the data for the index buffer to be used by the geometry
+ * @param[in] indices A vector containing the indices
+ */
+ void SetIndexBuffer( Dali::Vector<unsigned short>& indices );
/**
* Removes a PropertyBuffer from the geometry
private:
// PropertyBuffers
- Render::PropertyBuffer* mIndexBuffer;
- Vector<Render::PropertyBuffer*> mVertexBuffers;
+ Vector< Render::PropertyBuffer* > mVertexBuffers;
- GeometryType mGeometryType;
+ Dali::Vector< unsigned short> mIndices;
+ OwnerPointer< GpuBuffer > mIndexBuffer;
+ GeometryType mGeometryType;
// Booleans
+ bool mIndicesChanged : 1;
bool mRequiresDepthTest : 1;
bool mHasBeenUpdated : 1;
bool mAttributesChanged : 1;
};
-} // namespace SceneGraph
+} // namespace Render
} // namespace Internal
} // namespace Dali
-#endif // DALI_INTERNAL_SCENE_GRAPH_SAMPLER_DATA_PROVIDER_H
+#endif // DALI_INTERNAL_RENDER_GEOMETRY_H
mDataChanged = true;
}
-bool PropertyBuffer::Update( Context& context, bool isIndexBuffer )
+bool PropertyBuffer::Update( Context& context )
{
if( !mData || !mFormat || !mSize )
{
if ( mGpuBuffer )
{
DALI_ASSERT_DEBUG( mSize && "No data in the property buffer!" );
-
- const void *data = &((*mData)[0]);
- std::size_t dataSize = GetDataSize();
-
- // Index buffer needs to be unsigned short which is not supported by the property system
- Vector<unsigned short> ushortData;
- if( isIndexBuffer )
- {
- ushortData.Resize(mSize);
- const unsigned int* unsignedData = static_cast<const unsigned int*>(data);
- for( unsigned int i = 0; i < mSize; ++i )
- {
- ushortData[i] = unsignedData[i];
- }
- data = &(ushortData[0]);
- dataSize = ushortData.Size() * sizeof( unsigned short );
- }
-
- GpuBuffer::Target target = GpuBuffer::ARRAY_BUFFER;
- if(isIndexBuffer)
- {
- target = GpuBuffer::ELEMENT_ARRAY_BUFFER;
- }
- mGpuBuffer->UpdateDataBuffer( dataSize, data, GpuBuffer::STATIC_DRAW, target );
-
+ mGpuBuffer->UpdateDataBuffer( GetDataSize(), &((*mData)[0]), GpuBuffer::STATIC_DRAW, GpuBuffer::ARRAY_BUFFER );
}
mDataChanged = false;
/**
* Perform the upload of the buffer only when requiered
* @param[in] context The GL context
- * @param[in] isIndexBuffer True if the buffer is used as an index buffer
*/
- bool Update( Context& context, bool isIndexBuffer );
+ bool Update( Context& context );
/**
* Enable the vertex attributes for each vertex buffer from the corresponding
{
Renderer* Renderer::New( SceneGraph::RenderDataProvider* dataProvider,
- SceneGraph::RenderGeometry* renderGeometry,
+ Render::Geometry* geometry,
unsigned int blendingBitmask,
const Vector4* blendColor,
Dali::Renderer::FaceCullingMode faceCullingMode,
bool preMultipliedAlphaEnabled )
{
- return new Renderer( dataProvider, renderGeometry, blendingBitmask, blendColor, faceCullingMode, preMultipliedAlphaEnabled );
+ return new Renderer( dataProvider, geometry, blendingBitmask, blendColor, faceCullingMode, preMultipliedAlphaEnabled );
}
Renderer::Renderer( SceneGraph::RenderDataProvider* dataProvider,
- SceneGraph::RenderGeometry* renderGeometry,
+ Render::Geometry* geometry,
unsigned int blendingBitmask,
const Vector4* blendColor,
Dali::Renderer::FaceCullingMode faceCullingMode,
mContext(NULL),
mTextureCache( NULL ),
mUniformNameCache( NULL ),
- mRenderGeometry( renderGeometry ),
+ mGeometry( geometry ),
mUniformIndexMap(),
mAttributesLocation(),
mBlendingOptions(),
mUpdateAttributesLocation = true;
}
-void Renderer::SetGeometry( SceneGraph::RenderGeometry* renderGeometry )
+void Renderer::SetGeometry( Render::Geometry* geometry )
{
- mRenderGeometry = renderGeometry;
+ mGeometry = geometry;
mUpdateAttributesLocation = true;
}
// @todo MESH_REWORK Should use Update thread objects only in PrepareRenderInstructions.
bool Renderer::RequiresDepthTest() const
{
- return mRenderGeometry->RequiresDepthTest();
+ return mGeometry->RequiresDepthTest();
}
void Renderer::SetBlending( Context& context, bool blend )
void Renderer::GlContextDestroyed()
{
- mRenderGeometry->GlContextDestroyed();
+ mGeometry->GlContextDestroyed();
}
void Renderer::GlCleanup()
}
}
- SetUniforms( bufferIndex, node, size, *program );
+ SetUniforms( bufferIndex, node, size, *program );
- if( mUpdateAttributesLocation || mRenderGeometry->AttributesChanged() )
+ if( mUpdateAttributesLocation || mGeometry->AttributesChanged() )
{
- mRenderGeometry->GetAttributeLocationFromProgram( mAttributesLocation, *program, bufferIndex );
+ mGeometry->GetAttributeLocationFromProgram( mAttributesLocation, *program, bufferIndex );
mUpdateAttributesLocation = false;
}
- mRenderGeometry->UploadAndDraw( context, bufferIndex, mAttributesLocation, mIndexedDrawFirstElement, mIndexedDrawElementsCount );
+ mGeometry->UploadAndDraw( context, bufferIndex, mAttributesLocation, mIndexedDrawFirstElement, mIndexedDrawElementsCount );
}
}
sortAttributes.textureResourceId = Integration::InvalidResourceId;
}
- sortAttributes.geometry = mRenderGeometry;
+ sortAttributes.geometry = mGeometry;
}
} // namespace SceneGraph
#include <dali/devel-api/rendering/texture-set.h>
#include <dali/internal/common/blending-options.h>
#include <dali/internal/common/message.h>
+#include <dali/internal/event/common/property-input-impl.h>
#include <dali/internal/event/effects/shader-declarations.h>
#include <dali/internal/render/gl-resources/gl-resource-owner.h>
#include <dali/integration-api/debug.h>
#include <dali/internal/common/type-abstraction-enums.h>
#include <dali/internal/update/manager/prepare-render-instructions.h>
+#include <dali/internal/render/data-providers/render-data-provider.h>
#include <dali/internal/render/renderers/render-geometry.h>
namespace Dali
/**
* Create a new renderer instance
* @param[in] dataProviders The data providers for the renderer
- * @param[in] renderGeometry The geometry for the renderer
+ * @param[in] geometry The geometry for the renderer
* @param[in] blendingBitmask A bitmask of blending options.
* @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.
*/
static Renderer* New( SceneGraph::RenderDataProvider* dataProviders,
- SceneGraph::RenderGeometry* renderGeometry,
+ Render::Geometry* geometry,
unsigned int blendingBitmask,
const Vector4* blendColor,
Dali::Renderer::FaceCullingMode faceCullingMode,
/**
* Constructor.
* @param[in] dataProviders The data providers for the renderer
- * @param[in] renderGeometry The geometry for the renderer
+ * @param[in] geometry The geometry for the renderer
* @param[in] blendingBitmask A bitmask of blending options.
* @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.
*/
Renderer( SceneGraph::RenderDataProvider* dataProviders,
- SceneGraph::RenderGeometry* renderGeometry,
+ Render::Geometry* geometry,
unsigned int blendingBitmask,
const Vector4* blendColor,
Dali::Renderer::FaceCullingMode faceCullingMode,
/**
* Change the geometry used by the renderer
- * @param[in] renderGeometry The new geometry
+ * @param[in] geometry The new geometry
*/
- void SetGeometry( SceneGraph::RenderGeometry* renderGeometry );
+ void SetGeometry( Render::Geometry* geometry );
/**
* Second-phase construction.
* This is called when the renderer is inside render thread
Context* mContext;
SceneGraph::TextureCache* mTextureCache;
Render::UniformNameCache* mUniformNameCache;
- SceneGraph::RenderGeometry* mRenderGeometry;
+ Render::Geometry* mGeometry;
struct UniformIndexMap
{
}
}
-void DiscardQueue::Add( BufferIndex updateBufferIndex, Geometry* geometry )
-{
- DALI_ASSERT_DEBUG( NULL != geometry );
-
- // The GL resources will now be freed in frame N
- // The Update for frame N+1 may occur in parallel with the rendering of frame N
- // Queue the node for destruction in frame N+2
- if ( 0u == updateBufferIndex )
- {
- mGeometryQueue0.PushBack( geometry );
- }
- else
- {
- mGeometryQueue1.PushBack( geometry );
- }
-}
-
void DiscardQueue::Add( BufferIndex updateBufferIndex, TextureSet* textureSet )
{
DALI_ASSERT_DEBUG( NULL != textureSet );
{
mNodeQueue0.Clear();
mShaderQueue0.Clear();
- mGeometryQueue0.Clear();
mTextureSetQueue0.Clear();
mRendererQueue0.Clear();
}
{
mNodeQueue1.Clear();
mShaderQueue1.Clear();
- mGeometryQueue1.Clear();
mTextureSetQueue1.Clear();
mRendererQueue1.Clear();
}
#include <dali/devel-api/common/owner-container.h>
#include <dali/internal/common/buffer-index.h>
#include <dali/internal/update/nodes/node-declarations.h>
-#include <dali/internal/update/rendering/scene-graph-geometry.h>
#include <dali/internal/update/rendering/scene-graph-texture-set.h>
#include <dali/internal/update/rendering/scene-graph-renderer.h>
public:
typedef OwnerContainer< Shader* > ShaderQueue;
- typedef OwnerContainer< Geometry* > GeometryQueue;
typedef OwnerContainer< TextureSet* > TextureSetQueue;
typedef OwnerContainer< Renderer* > RendererQueue;
void Add( BufferIndex updateBufferIndex, Node* node );
/**
- * Adds an unwanted geometry to the discard queue.
- * A message will be sent to clean up GL resources in the next Render
- */
- void Add( BufferIndex updateBufferIndex, Geometry* geometry );
-
- /**
* Adds an unwanted texture set to the discard queue.
* A message will be sent to clean up GL resources in the next Render.
*/
// Messages are queued here when the update buffer index == 0
NodeOwnerContainer mNodeQueue0;
ShaderQueue mShaderQueue0;
- GeometryQueue mGeometryQueue0;
TextureSetQueue mTextureSetQueue0;
RendererQueue mRendererQueue0;
// Messages are queued here when the update buffer index == 1
NodeOwnerContainer mNodeQueue1;
ShaderQueue mShaderQueue1;
- GeometryQueue mGeometryQueue1;
TextureSetQueue mTextureSetQueue1;
RendererQueue mRendererQueue1;
};
new (slot) DerivedType( &mRenderManager, &RenderManager::RemoveRenderer, &renderer );
}
-void RenderMessageDispatcher::AddGeometry( RenderGeometry& renderGeometry )
-{
- typedef MessageValue1< RenderManager, RenderGeometry* > DerivedType;
-
- // Reserve some memory inside the render queue
- unsigned int* slot = mRenderQueue.ReserveMessageSlot( mBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
-
- // Construct message in the render queue memory; note that delete should not be called on the return value
- new (slot) DerivedType( &mRenderManager, &RenderManager::AddGeometry, &renderGeometry );
-}
-
-void RenderMessageDispatcher::RemoveGeometry( RenderGeometry& renderGeometry )
-{
- typedef MessageValue1< RenderManager, RenderGeometry* > DerivedType;
-
- // Reserve some memory inside the render queue
- unsigned int* slot = mRenderQueue.ReserveMessageSlot( mBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
-
- // Construct message in the render queue memory; note that delete should not be called on the return value
- new (slot) DerivedType( &mRenderManager, &RenderManager::RemoveGeometry, &renderGeometry );
-}
-
-void RenderMessageDispatcher::AddPropertyBuffer( RenderGeometry& renderGeometry, Render::PropertyBuffer* propertyBuffer, bool isIndexBuffer )
-{
- typedef MessageValue3< RenderManager, RenderGeometry*, Render::PropertyBuffer*, bool > DerivedType;
-
- // Reserve some memory inside the render queue
- unsigned int* slot = mRenderQueue.ReserveMessageSlot( mBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
-
- // Construct message in the render queue memory; note that delete should not be called on the return value
- new (slot) DerivedType( &mRenderManager, &RenderManager::AddPropertyBuffer, &renderGeometry, propertyBuffer, isIndexBuffer);
-}
-
-void RenderMessageDispatcher::RemovePropertyBuffer( RenderGeometry& renderGeometry, Render::PropertyBuffer* propertyBuffer )
-{
- typedef MessageValue2< RenderManager, RenderGeometry*, Render::PropertyBuffer* > DerivedType;
-
- // Reserve some memory inside the render queue
- unsigned int* slot = mRenderQueue.ReserveMessageSlot( mBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
-
- // Construct message in the render queue memory; note that delete should not be called on the return value
- new (slot) DerivedType( &mRenderManager, &RenderManager::RemovePropertyBuffer, &renderGeometry, propertyBuffer );
-}
-
-void RenderMessageDispatcher::SetGeometryType( RenderGeometry& geometry, int geometryType )
-{
- typedef MessageValue2< RenderManager, RenderGeometry*, int > DerivedType;
-
- // Reserve some memory inside the render queue
- unsigned int* slot = mRenderQueue.ReserveMessageSlot( mBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
-
- // Construct message in the render queue memory; note that delete should not be called on the return value
- new (slot) DerivedType( &mRenderManager, &RenderManager::SetGeometryType, &geometry, geometryType );
-}
-
-void RenderMessageDispatcher::SetGeometryRequiresDepthTest( RenderGeometry& geometry, bool requiresDepthTest )
-{
- typedef MessageValue2< RenderManager, RenderGeometry*, bool > DerivedType;
-
- // Reserve some memory inside the render queue
- unsigned int* slot = mRenderQueue.ReserveMessageSlot( mBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
-
- // Construct message in the render queue memory; note that delete should not be called on the return value
- new (slot) DerivedType( &mRenderManager, &RenderManager::SetGeometryRequiresDepthTest, &geometry, requiresDepthTest );
-}
-
void RenderMessageDispatcher::AddRenderTracker( Render::RenderTracker& renderTracker )
{
typedef MessageValue1< RenderManager, Render::RenderTracker* > DerivedType;
class RenderManager;
class RenderQueue;
-class RenderGeometry;
class PropertyBufferDataProvider;
/**
* A utility class for sending messages to the render-thread.
void RemoveRenderer( Render::Renderer& renderer );
/**
- * Add a Geometry
- * @param[in] renderGeometry The geometry to add.
- * @post RenderGeometry ownership is transferred.
- */
- void AddGeometry( RenderGeometry& renderGeometry );
-
- /**
- * Remove a Geometry.
- * @param[in] renderGeometry The geometry to remove.
- * @post RenderGeometry will be destroyed in the next Render.
- */
- void RemoveGeometry( RenderGeometry& renderGeometry );
-
- /**
- * Add a PropertyBuffer.
- * @param[in] renderGeometry The geometry
- * @param[in] propertyBuffer The PropertyBuffer
- * @param[in] isIndexBuffer True if the buffer is intended to be used as an index buffer
- */
- void AddPropertyBuffer( RenderGeometry& renderGeometry, Render::PropertyBuffer* propertyBuffer, bool isIndexBuffer );
-
- /**
- * Remove a PropertyBuffer.
- * @param[in] renderGeometry The geometry
- * @param[in] propertyBuffer The PropertyBuffer
- * @post PropertyBuffer will be destroyed in the next Render.
- */
- void RemovePropertyBuffer( RenderGeometry& renderGeometry, Render::PropertyBuffer* propertyBuffer );
-
- /**
- * Set the geometry type of an existing render geometry
- * @param[in] geometry The render geometry
- * @param[in] geometryType The new geometry type
- */
- void SetGeometryType( RenderGeometry& geometry, 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( RenderGeometry& geometry, bool requiresDepthTest );
-
- /**
* Add a Render tracker.
* @param[in] renderTracker The render tracker to add.
* @post ownership is transferred
#include <dali/internal/update/manager/sorted-layers.h>
#include <dali/internal/update/render-tasks/scene-graph-render-task.h>
#include <dali/internal/update/rendering/scene-graph-texture-set.h>
-#include <dali/internal/update/rendering/scene-graph-geometry.h>
#include <dali/internal/update/resources/resource-manager-declarations.h>
#include <dali/internal/render/common/render-item.h>
#include <dali/internal/render/common/render-tracker.h>
namespace Internal
{
+namespace Render
+{
+class Geometry;
+}
+
namespace SceneGraph
{
class RenderTracker;
class RenderItem;
class Shader;
-class RenderGeometry;
/**
* Structure to store information for sorting the renderers.
RenderItem* renderItem; ///< The render item that is being sorted (includes depth index)
const Shader* shader; ///< The shader instance
Integration::ResourceId textureResourceId;///< The first texture resource ID of the texture set instance, is InvalidResourceId if the texture set doesn't have any textures
- const RenderGeometry* geometry; ///< The geometry instance
+ const Render::Geometry* geometry; ///< The geometry instance
float zValue; ///< The zValue of the given renderer (either distance from camera, or a custom calculated value)
};
#include <dali/internal/update/render-tasks/scene-graph-render-task.h>
#include <dali/internal/update/render-tasks/scene-graph-render-task-list.h>
#include <dali/internal/update/rendering/scene-graph-texture-set.h>
-#include <dali/internal/update/rendering/scene-graph-geometry.h>
#include <dali/internal/update/resources/resource-manager.h>
#include <dali/internal/update/touch/touch-resampler.h>
root( NULL ),
systemLevelRoot( NULL ),
renderers( sceneGraphBuffers, discardQueue ),
- geometries( sceneGraphBuffers, discardQueue ),
textureSets( sceneGraphBuffers, discardQueue ),
messageQueue( renderController, sceneGraphBuffers ),
keepRenderingSeconds( 0.0f ),
sceneController = new SceneControllerImpl( renderMessageDispatcher, renderQueue, discardQueue, textureCache );
renderers.SetSceneController( *sceneController );
- geometries.SetSceneController( *sceneController );
textureSets.SetSceneController( *sceneController );
// create first 'dummy' node
PropertyNotificationContainer propertyNotifications; ///< A container of owner property notifications.
ObjectOwnerContainer<Renderer> renderers;
- ObjectOwnerContainer<Geometry> geometries; ///< A container of geometries
ObjectOwnerContainer<TextureSet> textureSets; ///< A container of texture sets
ShaderContainer shaders; ///< A container of owned shaders
propertyNotification->SetNotifyMode( notifyMode );
}
-ObjectOwnerContainer<Geometry>& UpdateManager::GetGeometryOwner()
-{
- return mImpl->geometries;
-}
-
ObjectOwnerContainer<Renderer>& UpdateManager::GetRendererOwner()
{
return mImpl->renderers;
}
mImpl->textureSets.ResetToBaseValues( bufferIndex );
- mImpl->geometries.ResetToBaseValues( bufferIndex );
mImpl->renderers.ResetToBaseValues( bufferIndex );
// Reset animatable shader properties to base values
//This will populate each Layer with a list of renderers which are ready.
UpdateNodes( bufferIndex );
- //Apply constraints to RenderTasks, shaders and geometries
+ //Apply constraints to RenderTasks, shaders
ConstrainRenderTasks( bufferIndex );
ConstrainShaders( bufferIndex );
- mImpl->geometries.ConstrainObjects( bufferIndex );
//Update renderers and apply constraints
UpdateRenderers( bufferIndex );
new (slot) DerivedType( &mImpl->renderManager, &RenderManager::SetPropertyBufferData, propertyBuffer, data, size );
}
+void UpdateManager::AddGeometry( Render::Geometry* geometry )
+{
+ typedef MessageValue1< RenderManager, Render::Geometry* > 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::AddGeometry, geometry );
+}
+
+void UpdateManager::RemoveGeometry( Render::Geometry* geometry )
+{
+ typedef MessageValue1< RenderManager, Render::Geometry* > 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::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;
+
+ // 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::SetGeometryType, geometry, geometryType );
+}
+
+void UpdateManager::SetIndexBuffer( Render::Geometry* geometry, Dali::Vector<unsigned short>& indices )
+{
+ typedef IndexBufferMessage< RenderManager > 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, geometry, indices );
+}
+
+void UpdateManager::RemoveVertexBuffer( Render::Geometry* geometry, Render::PropertyBuffer* propertyBuffer )
+{
+ typedef MessageValue2< RenderManager, Render::Geometry*, Render::PropertyBuffer* > 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::RemoveVertexBuffer, geometry, propertyBuffer );
+}
+
+void UpdateManager::AddVertexBuffer( Render::Geometry* geometry, Render::PropertyBuffer* propertyBuffer )
+{
+ typedef MessageValue2< RenderManager, Render::Geometry*, Render::PropertyBuffer* > 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::AddVertexBuffer, geometry, propertyBuffer );
+}
+
+
} // namespace SceneGraph
} // namespace Internal
class RenderTaskList;
class RenderQueue;
class TextureCache;
-class Geometry;
class PropertyBuffer;
class TextureSet;
void PropertyNotificationSetNotify( PropertyNotification* propertyNotification, PropertyNotification::NotifyMode notifyMode );
/**
- * @brief Get the geometry owner
- *
- * @return The geometry owner
- */
- ObjectOwnerContainer< Geometry >& GetGeometryOwner();
-
- /**
* @brief Get the renderer owner
*
* @return The renderer owner
void SetWrapMode( Render::Sampler* sampler, unsigned int uWrapMode, unsigned int vWrapMode );
/**
- * Add a new sampler to RenderManager
+ * Add a new property buffer to RenderManager
* @param[in] propertryBuffer The property buffer to add
* @post Sends a message to RenderManager to add the property buffer.
* The property buffer will be owned by RenderManager
*/
void SetPropertyBufferData(Render::PropertyBuffer* propertyBuffer, Dali::Vector<char>* data, size_t size);
+ /**
+ * Adds a geometry to the RenderManager
+ * @param[in] geometry The geometry to add
+ * @post Sends a message to RenderManager to add the Geometry
+ * The geometry will be owned by RenderManager
+ */
+ void AddGeometry( Render::Geometry* geometry );
+
+ /**
+ * Removes an existing Geometry from RenderManager
+ * @param[in] geometry The geometry to remove
+ * @post The geometry will be destroyed in the render thread
+ */
+ 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
+ */
+ void SetGeometryType( Render::Geometry* geometry, unsigned int geometryType );
+
+ /**
+ * Sets the index buffer to be used by a geometry
+ * @param[in] geometry The geometry
+ * @param[in] indices A vector containing the indices for the geometry
+ */
+ void SetIndexBuffer( Render::Geometry* geometry, Dali::Vector<unsigned short>& indices );
+
+ /**
+ * Adds a vertex buffer to a geomtry
+ * @param[in] geometry The geometry
+ * @param[in] propertyBuffer The property buffer
+ */
+ void AddVertexBuffer( Render::Geometry* geometry, Render::PropertyBuffer* propertyBuffer );
+
+ /**
+ * Removes a vertex buffer from a geometry
+ * @param[in] geometry The geometry
+ * @param[in] propertyBuffer The property buffer
+ */
+ void RemoveVertexBuffer( Render::Geometry* geometry, Render::PropertyBuffer* propertyBuffer );
+
+
public:
/**
new (slot) LocalType( &manager, &UpdateManager::SetPropertyBufferData, &propertyBuffer, data, size );
}
+inline void AddGeometry( UpdateManager& manager, Render::Geometry& geometry )
+{
+ typedef MessageValue1< UpdateManager, Render::Geometry* > 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::AddGeometry, &geometry );
+}
+
+inline void RemoveGeometry( UpdateManager& manager, Render::Geometry& geometry )
+{
+ typedef MessageValue1< UpdateManager, Render::Geometry* > 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::RemoveGeometry, &geometry );
+}
+
+inline void AddVertexBufferMessage( UpdateManager& manager, Render::Geometry& geometry, const Render::PropertyBuffer& vertexBuffer )
+{
+ typedef MessageValue2< UpdateManager, Render::Geometry*, Render::PropertyBuffer* > 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::AddVertexBuffer, &geometry, const_cast<Render::PropertyBuffer*>(&vertexBuffer) );
+}
+
+inline void RemoveVertexBufferMessage( UpdateManager& manager, Render::Geometry& geometry, const Render::PropertyBuffer& vertexBuffer )
+{
+ typedef MessageValue2< UpdateManager, Render::Geometry*, Render::PropertyBuffer* > 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::RemoveVertexBuffer, &geometry, const_cast<Render::PropertyBuffer*>(&vertexBuffer) );
+}
+
+// Custom message type for SetIndexBuffer() used to move data with Vector::Swap()
+template< typename T >
+class IndexBufferMessage : public MessageBase
+{
+public:
+
+ /**
+ * Constructor which does a Vector::Swap()
+ */
+ IndexBufferMessage( T* manager, Render::Geometry* geometry, Dali::Vector<unsigned short>& indices )
+ : MessageBase(),
+ mManager( manager ),
+ mRenderGeometry( geometry )
+ {
+ mIndices.Swap( indices );
+ }
+
+ /**
+ * Virtual destructor
+ */
+ virtual ~IndexBufferMessage()
+ {
+ }
+
+ /**
+ * @copydoc MessageBase::Process
+ */
+ virtual void Process( BufferIndex /*bufferIndex*/ )
+ {
+ DALI_ASSERT_DEBUG( mManager && "Message does not have an object" );
+ mManager->SetIndexBuffer( mRenderGeometry, mIndices );
+ }
+
+private:
+
+ T* mManager;
+ Render::Geometry* mRenderGeometry;
+ Dali::Vector<unsigned short> mIndices;
+};
+
+inline void SetIndexBufferMessage( UpdateManager& manager, Render::Geometry& geometry, Dali::Vector<unsigned short>& indices )
+{
+ typedef IndexBufferMessage< UpdateManager > 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, &geometry, indices );
+}
+
+inline void SetGeometryTypeMessage( UpdateManager& manager, Render::Geometry& geometry, unsigned int geometryType )
+{
+ typedef MessageValue2< UpdateManager, Render::Geometry*, unsigned int > 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::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
+++ /dev/null
-/*
- * Copyright (c) 2015 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.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-// CLASS HEADER
-#include "scene-graph-geometry.h"
-
-// INTERNAL HEADERS
-#include <dali/internal/update/controllers/scene-controller.h>
-#include <dali/internal/render/renderers/render-geometry.h>
-#include <dali/internal/render/renderers/render-property-buffer.h>
-#include <dali/internal/update/controllers/render-message-dispatcher.h>
-
-namespace Dali
-{
-namespace Internal
-{
-namespace SceneGraph
-{
-
-Geometry::Geometry()
-: mRenderGeometry(NULL),
- mSceneController(NULL),
- mIndexBuffer( NULL ),
- mGeometryType(Dali::Geometry::TRIANGLES),
- mRendererRefCount(0u),
- mRequiresDepthTest(false)
-{
-
- // Observe our own PropertyOwner's uniform map
- AddUniformMapObserver( *this );
-}
-
-Geometry::~Geometry()
-{
- mConnectionObservers.Destroy( *this );
-}
-
-void Geometry::AddVertexBuffer( Render::PropertyBuffer* vertexBuffer )
-{
- mVertexBuffers.PushBack( vertexBuffer );
- mConnectionObservers.ConnectionsChanged(*this);
-
- if( mRenderGeometry )
- {
- mSceneController->GetRenderMessageDispatcher().AddPropertyBuffer( *mRenderGeometry, vertexBuffer, false);
- }
-}
-
-void Geometry::RemoveVertexBuffer( Render::PropertyBuffer* vertexBuffer )
-{
- DALI_ASSERT_DEBUG( NULL != vertexBuffer );
-
- // Find the object and destroy it
- size_t bufferCount(mVertexBuffers.Size());
- for( size_t i(0); i<bufferCount; ++i )
- {
- if( vertexBuffer == mVertexBuffers[i] )
- {
- mVertexBuffers.Erase( mVertexBuffers.Begin()+i );
- mConnectionObservers.ConnectionsChanged(*this);
-
- if( mRenderGeometry )
- {
- mSceneController->GetRenderMessageDispatcher().RemovePropertyBuffer( *mRenderGeometry, vertexBuffer );
- }
- }
- }
-}
-
-void Geometry::SetIndexBuffer( Render::PropertyBuffer* indexBuffer )
-{
- if( mIndexBuffer != indexBuffer )
- {
- mIndexBuffer = indexBuffer;
- mConnectionObservers.ConnectionsChanged(*this);
-
- if( mRenderGeometry )
- {
- mSceneController->GetRenderMessageDispatcher().AddPropertyBuffer( *mRenderGeometry, indexBuffer, true );
- }
- }
-}
-
-void Geometry::ClearIndexBuffer()
-{
- if( mIndexBuffer )
- {
- if( mRenderGeometry )
- {
- mSceneController->GetRenderMessageDispatcher().RemovePropertyBuffer( *mRenderGeometry, mIndexBuffer );
- }
- }
- mIndexBuffer = 0;
- mConnectionObservers.ConnectionsChanged(*this);
-}
-
-void Geometry::SetGeometryType(Geometry::GeometryType geometryType )
-{
- mGeometryType = geometryType;
- if( mRenderGeometry )
- {
- mSceneController->GetRenderMessageDispatcher().SetGeometryType( *mRenderGeometry, static_cast<int>(geometryType) );
- }
-}
-
-void Geometry::SetRequiresDepthTest( bool requiresDepthTest )
-{
- mRequiresDepthTest = requiresDepthTest;
- if( mRenderGeometry )
- {
- mSceneController->GetRenderMessageDispatcher().SetGeometryRequiresDepthTest( *mRenderGeometry, requiresDepthTest );
- }
-}
-
-Vector<Render::PropertyBuffer*>& Geometry::GetVertexBuffers()
-{
- return mVertexBuffers;
-}
-
-Render::PropertyBuffer* Geometry::GetIndexBuffer()
-{
- return mIndexBuffer;
-}
-
-Geometry::GeometryType Geometry::GetGeometryType( BufferIndex bufferIndex) const
-{
- return mGeometryType;
-}
-
-bool Geometry::GetRequiresDepthTesting( BufferIndex bufferIndex ) const
-{
- return mRequiresDepthTest;
-}
-
-void Geometry::ConnectToSceneGraph( SceneController& sceneController, BufferIndex bufferIndex )
-{
-}
-
-void Geometry::DisconnectFromSceneGraph( SceneController& sceneController, BufferIndex bufferIndex )
-{
-}
-
-void Geometry::AddConnectionObserver( ConnectionChangePropagator::Observer& observer )
-{
- mConnectionObservers.Add(observer);
-}
-
-void Geometry::RemoveConnectionObserver( ConnectionChangePropagator::Observer& observer )
-{
- mConnectionObservers.Remove(observer);
-}
-
-void Geometry::UniformMappingsChanged( const UniformMap& mappings )
-{
- // Our uniform map, or that of one of the watched children has changed.
- // Inform connected observers.
- mConnectionObservers.ConnectedUniformMapChanged();
-}
-
-RenderGeometry* Geometry::GetRenderGeometry(SceneController* sceneController)
-{
- if(!mRenderGeometry )
- {
- //Create RenderGeometry
- mSceneController = sceneController;
- mRenderGeometry = new RenderGeometry( mGeometryType, mRequiresDepthTest );
-
- size_t vertexBufferCount( mVertexBuffers.Size() );
- for( size_t i(0); i<vertexBufferCount; ++i )
- {
- mRenderGeometry->AddPropertyBuffer( mVertexBuffers[i], false );
- }
-
- if( mIndexBuffer )
- {
- mRenderGeometry->AddPropertyBuffer( mIndexBuffer, true );
- }
-
- //Transfer ownership to RenderManager
- sceneController->GetRenderMessageDispatcher().AddGeometry( *mRenderGeometry );
- }
-
- ++mRendererRefCount;
- return mRenderGeometry;
-}
-
-void Geometry::OnRendererDisconnect()
-{
- --mRendererRefCount;
- if( mRendererRefCount == 0 )
- {
- //Delete the corresponding RenderGeometry via message to RenderManager
- mSceneController->GetRenderMessageDispatcher().RemoveGeometry( *mRenderGeometry );
-
- mRenderGeometry = 0;
- mSceneController = 0;
- }
-}
-
-
-} // namespace SceneGraph
-} // namespace Internal
-} // namespace Dali
+++ /dev/null
-#ifndef DALI_INTERNAL_SCENE_GRAPH_GEOMETRY_H
-#define DALI_INTERNAL_SCENE_GRAPH_GEOMETRY_H
-
-/*
- * Copyright (c) 2015 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.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <dali/devel-api/rendering/geometry.h>
-#include <dali/internal/event/common/event-thread-services.h>
-#include <dali/internal/update/common/animatable-property.h>
-#include <dali/internal/update/common/double-buffered.h>
-#include <dali/internal/update/common/property-owner.h>
-#include <dali/internal/update/common/uniform-map.h>
-#include <dali/internal/update/common/scene-graph-connection-change-propagator.h>
-#include <dali/internal/render/data-providers/render-data-provider.h>
-
-namespace Dali
-{
-namespace Internal
-{
-namespace Render
-{
-class PropertyBuffer;
-}
-namespace SceneGraph
-{
-class SceneController;
-class RenderGeometry;
-
-/**
- * This scene graph object is a property owner. It describes a geometry using a
- * number of PropertyBuffers acting as Vertex buffers.
- */
-class Geometry : public PropertyOwner, public UniformMap::Observer
-{
-public:
-
- typedef Dali::Geometry::GeometryType GeometryType;
- /**
- * Constructor
- */
- Geometry();
-
- /**
- * Destructor
- */
- virtual ~Geometry();
-
- /**
- * Add a property buffer to be used as a vertex buffer
- */
- void AddVertexBuffer( Render::PropertyBuffer* vertexBuffer );
-
- /**
- * Remove a property buffer to be used as a vertex buffer
- * @param[in] vertexBuffer the associated vertex buffer to remove
- */
- void RemoveVertexBuffer( Render::PropertyBuffer* vertexBuffer );
-
- /**
- * Set the buffer to be used as a source of indices for the geometry
- * @param[in] indexBuffer the Property buffer describing the indexes for Line, Triangle tyes.
- */
- void SetIndexBuffer( Render::PropertyBuffer* indexBuffer );
-
- /**
- * Clear the index buffer if it is no longer required, e.g. if changing geometry type
- * to POINTS.
- */
- void ClearIndexBuffer();
-
- /**
- * Set the type of geometry to draw (Points, Lines, Triangles, etc)
- * @param[in] bufferIndex Index for double buffered values
- * @param[in] geometryType The geometry type
- */
- void SetGeometryType( GeometryType geometryType );
-
- /**
- * Set if the geometry requires depth testing
- * @param[in] requiresDepthTest True if depth testing is required, false otherwise
- */
- void SetRequiresDepthTest( bool requiresDepthTest );
-
- /**
- * 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 );
-
- /**
- * 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 );
-
- /**
- * @copydoc ConnectionObservers::AddObserver
- */
- void AddConnectionObserver(ConnectionChangePropagator::Observer& observer);
-
- /**
- * @copydoc ConnectionObservers::RemoveObserver
- */
- void RemoveConnectionObserver(ConnectionChangePropagator::Observer& observer);
-
-public: // UniformMap::Observer
- /**
- * @copydoc UniformMap::Observer::UniformMappingsChanged
- */
- virtual void UniformMappingsChanged( const UniformMap& mappings );
-
- /**
- * Get the vertex buffers of the geometry
- * @return A const reference to the vertex buffers
- */
- Vector<Render::PropertyBuffer*>& GetVertexBuffers();
-
- /**
- * Get the index buffer of the geometry
- * @return A pointer to the index buffer if it exists, or NULL if it doesn't.
- */
- Render::PropertyBuffer* GetIndexBuffer();
-
- /**
- * Gets the associated RenderGeometry
- * @param[in] sceneController The scene controller
- * @return The RenderGeometry associated to this Geometry
- */
- RenderGeometry* GetRenderGeometry(SceneController* sceneController);
-
- /**
- * Called from renderers using this geometry when they get disconnected from the scenegraph
- */
- void OnRendererDisconnect();
-
-
-public: // GeometryDataProvider
- /**
- * Get the type of geometry to draw
- * @param[in] bufferIndex Index for double buffered values
- */
- virtual GeometryType GetGeometryType( BufferIndex bufferIndex ) const;
-
- /**
- * Returns true if this geometry requires depth testing, e.g. if it is
- * a set of vertices with z != 0
- * @param[in] bufferIndex Index for double buffered values
- */
- virtual bool GetRequiresDepthTesting( BufferIndex bufferIndex ) const;
-
-private:
-
- RenderGeometry* mRenderGeometry;
- SceneController* mSceneController;
-
- Render::PropertyBuffer* mIndexBuffer; ///< The index buffer if required
- Vector<Render::PropertyBuffer*> mVertexBuffers; ///< The vertex buffers
-
- ConnectionChangePropagator mConnectionObservers;
-
- Geometry::GeometryType mGeometryType;
- unsigned int mRendererRefCount;
- bool mRequiresDepthTest;
-};
-
-inline void AddVertexBufferMessage( EventThreadServices& eventThreadServices , const Geometry& geometry, const Render::PropertyBuffer& vertexBuffer )
-{
- typedef MessageValue1< Geometry, Render::PropertyBuffer* > 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( &geometry, &Geometry::AddVertexBuffer, const_cast<Render::PropertyBuffer*>(&vertexBuffer) );
-}
-
-inline void RemoveVertexBufferMessage( EventThreadServices& eventThreadServices, const Geometry& geometry, const Render::PropertyBuffer& vertexBuffer )
-{
- typedef MessageValue1< Geometry, Render::PropertyBuffer* > 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( &geometry, &Geometry::RemoveVertexBuffer, const_cast<Render::PropertyBuffer*>(&vertexBuffer) );
-}
-
-inline void SetIndexBufferMessage( EventThreadServices& eventThreadServices, const Geometry& geometry, const Render::PropertyBuffer& indexBuffer )
-{
- typedef MessageValue1< Geometry, Render::PropertyBuffer* > 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( &geometry, &Geometry::SetIndexBuffer, const_cast<Render::PropertyBuffer*>(&indexBuffer) );
-}
-
-inline void ClearIndexBufferMessage( EventThreadServices& eventThreadServices, const Geometry& geometry )
-{
- typedef Message< 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( &geometry, &Geometry::ClearIndexBuffer );
-}
-
-} // namespace SceneGraph
-
-// Declare enum as a message parameter type
-template <> struct ParameterType< SceneGraph::Geometry::GeometryType > : public BasicType< SceneGraph::Geometry::GeometryType > {};
-
-namespace SceneGraph
-{
-
-inline void SetGeometryTypeMessage( EventThreadServices& eventThreadServices, const Geometry& geometry, SceneGraph::Geometry::GeometryType geometryType )
-{
- typedef MessageValue1< Geometry, SceneGraph::Geometry::GeometryType > 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( &geometry, &Geometry::SetGeometryType, geometryType );
-}
-
-inline void SetGeometryRequiresDepthTestMessage( EventThreadServices& eventThreadServices, const Geometry& geometry, bool requiresDepthTest )
-{
- typedef MessageValue1< Geometry, bool > 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( &geometry, &Geometry::SetRequiresDepthTest, requiresDepthTest );
-}
-
-} // namespace SceneGraph
-} // namespace Internal
-} // namespace Dali
-
-#endif // DALI_INTERNAL_SCENE_GRAPH_GEOMETRY_H
#include <dali/internal/update/controllers/scene-controller.h>
#include <dali/internal/render/renderers/render-geometry.h>
#include <dali/internal/update/controllers/render-message-dispatcher.h>
-#include <dali/internal/update/rendering/scene-graph-geometry.h>
#include <dali/internal/update/rendering/scene-graph-texture-set.h>
#include <dali/internal/render/shaders/scene-graph-shader.h>
#include <dali/internal/render/renderers/render-renderer.h>
mBlendBitmask( 0u ),
mFaceCullingMode( Dali::Renderer::NONE ),
mBlendingMode( Dali::BlendingMode::AUTO ),
+ mIndexedDrawFirstElement( 0 ),
+ mIndexedDrawElementsCount( 0 ),
mReferenceCount( 0 ),
mRegenerateUniformMap( 0 ),
mResendFlag( 0 ),
mResourcesReady( false ),
mFinishedResourceAcquisition( false ),
- mIndexedDrawFirstElement( 0 ),
- mIndexedDrawElementsCount( 0 ),
mDepthIndex( 0 )
{
mUniformMapChanged[0] = false;
mTextureSet->RemoveConnectionObserver(*this);
mTextureSet=NULL;
}
- if (mGeometry)
- {
- mGeometry->RemoveConnectionObserver(*this);
- mGeometry=NULL;
- }
if( mShader )
{
mShader->RemoveConnectionObserver(*this);
mFinishedResourceAcquisition = false;
// Can only be considered ready when all the scene graph objects are connected to the renderer
- if( ( mGeometry ) && ( mGeometry->GetVertexBuffers().Count() > 0 ) && ( mShader ) )
+ if( mGeometry && mShader )
{
if( mTextureSet )
{
}
AddMappings( localMap, mShader->GetUniformMap() );
- AddMappings( localMap, mGeometry->GetUniformMap() );
-
}
else if( mRegenerateUniformMap == COPY_UNIFORM_MAP )
{
if( mResendFlag & RESEND_GEOMETRY )
{
- // The first call to GetRenderGeometry() creates the geometry and sends it in a message
- RenderGeometry* geometry = mGeometry->GetRenderGeometry( mSceneController );
-
- typedef MessageValue1< Render::Renderer, RenderGeometry* > DerivedType;
+ typedef MessageValue1< Render::Renderer, Render::Geometry* > DerivedType;
unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
- new (slot) DerivedType( mRenderer, &Render::Renderer::SetGeometry, geometry );
+ new (slot) DerivedType( mRenderer, &Render::Renderer::SetGeometry, mGeometry );
mResendFlag &= ~RESEND_GEOMETRY;
}
mResendFlag |= RESEND_DATA_PROVIDER;
}
-void Renderer::SetGeometry( Geometry* geometry )
+void Renderer::SetGeometry( Render::Geometry* geometry )
{
DALI_ASSERT_DEBUG( geometry != NULL && "Geometry pointer is NULL");
- if( mGeometry)
- {
- mGeometry->RemoveConnectionObserver(*this);
- mGeometry->OnRendererDisconnect();
- }
-
mGeometry = geometry;
- mGeometry->AddConnectionObserver( *this ); // Observe geometry connections / uniform mapping changes
- mRegenerateUniformMap = REGENERATE_UNIFORM_MAP;
if( mRenderer )
{
{
RenderDataProvider* dataProvider = NewRenderDataProvider();
- RenderGeometry* renderGeometry = mGeometry->GetRenderGeometry(mSceneController);
- mRenderer = Render::Renderer::New( dataProvider, renderGeometry,
+ mRenderer = Render::Renderer::New( dataProvider, mGeometry,
mBlendBitmask, mBlendColor,
static_cast< Dali::Renderer::FaceCullingMode >( mFaceCullingMode ),
mPremultipledAlphaEnabled );
if( mReferenceCount == 0 )
{
mSceneController->GetRenderMessageDispatcher().RemoveRenderer( *mRenderer );
- if( mGeometry )
- {
- mGeometry->OnRendererDisconnect();
- }
mRenderer = NULL;
}
}
void Renderer::ObservedObjectDestroyed(PropertyOwner& owner)
{
- if( reinterpret_cast<PropertyOwner*>(mGeometry) == &owner )
- {
- mGeometry = NULL;
- }
- else if( reinterpret_cast<PropertyOwner*>(mTextureSet) == &owner )
+ if( reinterpret_cast<PropertyOwner*>(mTextureSet) == &owner )
{
mTextureSet = NULL;
}
namespace Render
{
class Renderer;
+class Geometry;
}
namespace SceneGraph
* Set the geometry for the renderer
* @param[in] geometry The geometry this renderer will use
*/
- void SetGeometry( Geometry* geometry );
-
- /**
- * Get the geometry of this renderer
- * @return the geometry this renderer uses
- */
- Geometry& GetGeometry()
- {
- return *mGeometry;
- }
+ void SetGeometry( Render::Geometry* geometry );
/**
* Set the depth index
private:
- SceneController* mSceneController; ///< Used for initializing renderers whilst attached
- Render::Renderer* mRenderer; ///< Raw pointer to the new renderer (that's owned by RenderManager)
+ SceneController* mSceneController; ///< Used for initializing renderers whilst attached
+ Render::Renderer* mRenderer; ///< Raw pointer to the renderer (that's owned by RenderManager)
TextureSet* mTextureSet; ///< The texture set this renderer uses. (Not owned)
- Geometry* mGeometry; ///< The geometry this renderer uses. (Not owned)
+ Render::Geometry* mGeometry; ///< The geometry this renderer uses. (Not owned)
Shader* mShader;
Vector4* mBlendColor; ///< The blend color for blending operation
BlendingMode::Type mBlendingMode; ///< The mode of blending
CollectedUniformMap mCollectedUniformMap[2]; ///< Uniform maps collected by the renderer
+
+ 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 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
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
- size_t mIndexedDrawFirstElement; ///< first element index to be drawn using indexed draw
- size_t mIndexedDrawElementsCount; ///< number of elements to be drawn using indexed draw
-
public:
int mDepthIndex; ///< Used only in PrepareRenderInstructions
};
new (slot) LocalType( &renderer, &Renderer::SetTextures, const_cast<TextureSet*>(&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 MessageValue1< 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*>(&geometry) );
+ new (slot) LocalType( &renderer, &Renderer::SetGeometry, const_cast<Render::Geometry*>(&geometry) );
}
inline void SetShaderMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, Shader& shader )
projects / platform / core / uifw / dali-core.git / commitdiff