[3.0] Version downgrade (1.2.0 to 1.1.45) 30/84730/1
authortaeyoon <taeyoon0.lee@samsung.com>
Mon, 22 Aug 2016 06:53:10 +0000 (15:53 +0900)
committertaeyoon <taeyoon0.lee@samsung.com>
Mon, 22 Aug 2016 06:59:19 +0000 (15:59 +0900)
  Final integration work for tizen 3.0 merged 1.2.0 in tizen branch.
  1.2.0 already includes new features (Public-APIs) for next tizen release.
  For tizen 3.0, we downgrade tizen branch to 1.1.45

This reverts commit 109a3e9b900bc22d74847e7f4bd4565000033bc2.

Revert "Preparation for minor version upgrade"

This reverts commit 27ebdfb5c9b78436803e91fed85853cd6455cb17.

Revert "Adding ObjectDestructionTracker to dali-test-suite-utils for testing object destruction"

This reverts commit 7d801dcd5b760e024df8598102bbac06e35db1d5.

Revert "Batching clean-up"

This reverts commit 7da3cb30b108447404f7fe088156638d0bf3f1ca.

Revert "Render textures created from NativeImages where not handled correctly"

This reverts commit ca38f7946c5835a022d950555d7f96dbaf7f4708.

Revert "Geometry Batching"

This reverts commit 449cde6cfe99f1e9297bec8cdb5cedff37502afb.

Revert "Added missing newline chars to logging commands"

This reverts commit 2b10280985738c74efa2aa0fb956a837c69acee6.

Revert "Renderer to support enum and string properties"

This reverts commit 24a1e2d36b9340010242c40b043e208674cb4695.

Revert "Renderer Depth UTCs + test-gl-abstraction update"

This reverts commit 816210ab8d8ba78361d681a4b7b0208dbf5452b4.

Change-Id: Ia7bf3df83fc08633a17dcf196f1092b646eed472

66 files changed:
automated-tests/src/dali-internal/CMakeLists.txt
automated-tests/src/dali-internal/utc-Dali-Internal-GeometryBatcher.cpp [deleted file]
automated-tests/src/dali/dali-test-suite-utils/dali-test-suite-utils.cpp
automated-tests/src/dali/dali-test-suite-utils/dali-test-suite-utils.h
automated-tests/src/dali/dali-test-suite-utils/test-gl-abstraction.cpp
automated-tests/src/dali/dali-test-suite-utils/test-gl-abstraction.h
automated-tests/src/dali/utc-Dali-Renderer.cpp
dali/devel-api/threading/conditional-wait.cpp
dali/devel-api/threading/mutex.cpp
dali/internal/common/core-impl.cpp
dali/internal/common/core-impl.h
dali/internal/common/math.cpp
dali/internal/common/math.h
dali/internal/common/mutex-impl.cpp
dali/internal/event/actors/actor-impl.cpp
dali/internal/event/actors/actor-impl.h
dali/internal/event/actors/image-actor-impl.cpp
dali/internal/event/animation/constraint-base.cpp
dali/internal/event/common/stage-impl.cpp
dali/internal/event/common/type-info-impl.cpp
dali/internal/event/rendering/renderer-impl.cpp
dali/internal/event/rendering/renderer-impl.h
dali/internal/event/rendering/texture-impl.cpp
dali/internal/event/rendering/texture-set-impl.cpp
dali/internal/event/resources/archive.cpp
dali/internal/event/resources/resource-client.cpp
dali/internal/file.list
dali/internal/render/common/render-algorithms.cpp
dali/internal/render/common/render-algorithms.h
dali/internal/render/common/render-item.cpp
dali/internal/render/common/render-item.h
dali/internal/render/common/render-manager.cpp
dali/internal/render/common/render-manager.h
dali/internal/render/gl-resources/bitmap-texture.cpp
dali/internal/render/gl-resources/compressed-bitmap-texture.cpp
dali/internal/render/gl-resources/frame-buffer-texture.cpp
dali/internal/render/gl-resources/native-texture.cpp
dali/internal/render/renderers/render-geometry.cpp
dali/internal/render/renderers/render-geometry.h
dali/internal/render/renderers/render-property-buffer.cpp
dali/internal/render/renderers/render-property-buffer.h
dali/internal/render/renderers/render-renderer.cpp
dali/internal/render/renderers/render-renderer.h
dali/internal/render/renderers/render-texture.cpp
dali/internal/update/common/discard-queue.cpp
dali/internal/update/common/discard-queue.h
dali/internal/update/manager/geometry-batcher.cpp [deleted file]
dali/internal/update/manager/geometry-batcher.h [deleted file]
dali/internal/update/manager/prepare-render-instructions.cpp
dali/internal/update/manager/prepare-render-instructions.h
dali/internal/update/manager/process-render-tasks.cpp
dali/internal/update/manager/process-render-tasks.h
dali/internal/update/manager/update-manager-debug.cpp
dali/internal/update/manager/update-manager.cpp
dali/internal/update/manager/update-manager.h
dali/internal/update/nodes/node.cpp
dali/internal/update/nodes/node.h
dali/internal/update/render-tasks/scene-graph-camera.cpp
dali/internal/update/rendering/scene-graph-renderer.cpp
dali/internal/update/rendering/scene-graph-renderer.h
dali/public-api/actors/actor.h
dali/public-api/dali-core-version.cpp
dali/public-api/object/ref-object.cpp
dali/public-api/rendering/renderer.h
dali/public-api/signals/base-signal.cpp
packaging/dali.spec

index afedb0d7735d4c6c460d0f120fcd2dbc7f3d9a5b..4bc9f1020fad9bf308242cebc83f59ebf663e009 100644 (file)
@@ -12,7 +12,6 @@ SET(TC_SOURCES
         utc-Dali-Internal-FixedSizeMemoryPool.cpp
         utc-Dali-Internal-MemoryPoolObjectAllocator.cpp
         utc-Dali-Internal-FrustumCulling.cpp
-        utc-Dali-Internal-GeometryBatcher.cpp
 )
 
 LIST(APPEND TC_SOURCES
diff --git a/automated-tests/src/dali-internal/utc-Dali-Internal-GeometryBatcher.cpp b/automated-tests/src/dali-internal/utc-Dali-Internal-GeometryBatcher.cpp
deleted file mode 100644 (file)
index f2c679f..0000000
+++ /dev/null
@@ -1,403 +0,0 @@
-#include <dali/public-api/dali-core.h>
-#include <dali/internal/event/actors/actor-impl.h>
-#include <dali/internal/update/manager/geometry-batcher.h>
-
-#include <dali-test-suite-utils.h>
-
-namespace
-{
-
-class MockActor : public Dali::Internal::Actor
-{
-public:
-  inline const Dali::Internal::SceneGraph::Node* GetNode()
-  {
-    return mNode;
-  }
-
-  inline const bool IsNodeBatchParent()
-  {
-    return mNode->mIsBatchParent;
-  }
-};
-
-Geometry CreateBatchQuadGeometryVector2( Vector4 texCoords )
-{
-  const float halfWidth = 0.5f;
-  const float halfHeight = 0.5f;
-  struct QuadVertex {
-    QuadVertex( const Vector2& vertexPosition, const Vector2& vertexTexCoords )
-      : position( vertexPosition ),
-        texCoords( vertexTexCoords )
-    {}
-    Vector2 position;
-    Vector2 texCoords;
-  };
-
-  // special case, when texture takes whole space
-  if( texCoords == Vector4::ZERO )
-  {
-    texCoords = Vector4(0.0f, 0.0f, 1.0f, 1.0f);
-  }
-
-  QuadVertex quadVertexData[6] =
-  {
-    QuadVertex( Vector2(-halfWidth,   -halfHeight ),   Vector2(texCoords.x, texCoords.y) ),
-    QuadVertex( Vector2( halfWidth,   -halfHeight ),   Vector2(texCoords.z, texCoords.y) ),
-    QuadVertex( Vector2(-halfWidth,    halfHeight ),   Vector2(texCoords.x, texCoords.w) ),
-    QuadVertex( Vector2( halfWidth,   -halfHeight ),   Vector2(texCoords.z, texCoords.y) ),
-    QuadVertex( Vector2(-halfWidth,    halfHeight ),   Vector2(texCoords.x, texCoords.w) ),
-    QuadVertex( Vector2( halfWidth,    halfHeight ),   Vector2(texCoords.z, texCoords.w) ),
-  };
-
-  Property::Map vertexFormat;
-  vertexFormat[ "aPosition" ] = Property::VECTOR2;
-  vertexFormat[ "aTexCoord" ] = Property::VECTOR2;
-  PropertyBuffer vertexBuffer = PropertyBuffer::New( vertexFormat );
-  vertexBuffer.SetData( quadVertexData, 6 );
-
-  // create geometry as normal, single quad
-  Geometry geometry = Geometry::New();
-  geometry.AddVertexBuffer( vertexBuffer );
-  geometry.SetType( Geometry::TRIANGLES );
-
-  return geometry;
-}
-
-Geometry CreateBatchQuadGeometryVector3( Vector4 texCoords )
-{
-  const float halfWidth = 0.5f;
-  const float halfHeight = 0.5f;
-  struct QuadVertex {
-    QuadVertex( const Vector3& vertexPosition, const Vector2& vertexTexCoords )
-      : position( vertexPosition ),
-        texCoords( vertexTexCoords )
-    {}
-    Vector3 position;
-    Vector2 texCoords;
-  };
-
-  // special case, when texture takes whole space
-  if( texCoords == Vector4::ZERO )
-  {
-    texCoords = Vector4(0.0f, 0.0f, 1.0f, 1.0f);
-  }
-
-  QuadVertex quadVertexData[6] =
-  {
-    QuadVertex( Vector3(-halfWidth,   -halfHeight, 0.0f ),   Vector2(texCoords.x, texCoords.y) ),
-    QuadVertex( Vector3( halfWidth,   -halfHeight, 0.0f ),   Vector2(texCoords.z, texCoords.y) ),
-    QuadVertex( Vector3(-halfWidth,    halfHeight, 0.0f ),   Vector2(texCoords.x, texCoords.w) ),
-    QuadVertex( Vector3( halfWidth,   -halfHeight, 0.0f ),   Vector2(texCoords.z, texCoords.y) ),
-    QuadVertex( Vector3(-halfWidth,    halfHeight, 0.0f ),   Vector2(texCoords.x, texCoords.w) ),
-    QuadVertex( Vector3( halfWidth,    halfHeight, 0.0f ),   Vector2(texCoords.z, texCoords.w) ),
-  };
-
-  Property::Map vertexFormat;
-  vertexFormat[ "aPosition" ] = Property::VECTOR3;
-  vertexFormat[ "aTexCoord" ] = Property::VECTOR2;
-  PropertyBuffer vertexBuffer = PropertyBuffer::New( vertexFormat );
-  vertexBuffer.SetData( quadVertexData, 6 );
-
-  // create geometry as normal, single quad
-  Geometry geometry = Geometry::New();
-  geometry.AddVertexBuffer( vertexBuffer );
-  geometry.SetType( Geometry::TRIANGLES );
-  return geometry;
-}
-
-Geometry CreateBatchQuadGeometryVector4( Vector4 texCoords )
-{
-  const float halfWidth = 0.5f;
-  const float halfHeight = 0.5f;
-  struct QuadVertex {
-    QuadVertex( const Vector4& vertexPosition, const Vector2& vertexTexCoords )
-      : position( vertexPosition ),
-        texCoords( vertexTexCoords )
-    {}
-    Vector4 position;
-    Vector2 texCoords;
-  };
-
-  // special case, when texture takes whole space
-  if( texCoords == Vector4::ZERO )
-  {
-    texCoords = Vector4(0.0f, 0.0f, 1.0f, 1.0f);
-  }
-
-  QuadVertex quadVertexData[6] =
-  {
-    QuadVertex( Vector4(-halfWidth,   -halfHeight, 0.0f, 1.0f ),   Vector2(texCoords.x, texCoords.y) ),
-    QuadVertex( Vector4( halfWidth,   -halfHeight, 0.0f, 1.0f ),   Vector2(texCoords.z, texCoords.y) ),
-    QuadVertex( Vector4(-halfWidth,    halfHeight, 0.0f, 1.0f ),   Vector2(texCoords.x, texCoords.w) ),
-    QuadVertex( Vector4( halfWidth,   -halfHeight, 0.0f, 1.0f ),   Vector2(texCoords.z, texCoords.y) ),
-    QuadVertex( Vector4(-halfWidth,    halfHeight, 0.0f, 1.0f ),   Vector2(texCoords.x, texCoords.w) ),
-    QuadVertex( Vector4( halfWidth,    halfHeight, 0.0f, 1.0f ),   Vector2(texCoords.z, texCoords.w) ),
-  };
-
-  Property::Map vertexFormat;
-  vertexFormat[ "aPosition" ] = Property::VECTOR4;
-  vertexFormat[ "aTexCoord" ] = Property::VECTOR2;
-  PropertyBuffer vertexBuffer = PropertyBuffer::New( vertexFormat );
-  vertexBuffer.SetData( quadVertexData, 6 );
-
-  // create geometry as normal, single quad
-  Geometry geometry = Geometry::New();
-  geometry.AddVertexBuffer( vertexBuffer );
-  geometry.SetType( Geometry::TRIANGLES );
-  return geometry;
-}
-
-
-void CreateShadersAndTextureSets( Shader* shaders, size_t shaderCount, TextureSet* textureSets, size_t textureSetCount )
-{
-  for( size_t i = 0; i < shaderCount; ++i )
-  {
-    shaders[i] = Shader::New( "", "" );
-  }
-
-  for( size_t i = 0; i < textureSetCount; ++i )
-  {
-    textureSets[i] = TextureSet::New();
-  }
-}
-
-Vector4 WHOLE_IMAGE( 0.0f, 0.0f, 1.0f, 1.0f );
-
-Actor CreateActor( Actor& parent, Shader& shader, TextureSet& textureSet, Vector3 position, Vector4 texCoords, Geometry(*geomfunc)(Vector4) = CreateBatchQuadGeometryVector2 )
-{
-  Geometry geometry = geomfunc( texCoords );
-  Renderer renderer = Renderer::New( geometry, shader );
-
-  renderer.SetTextures( textureSet );
-  renderer.SetProperty( Dali::Renderer::Property::BATCHING_ENABLED, true );
-
-  Actor actor = Actor::New();
-  actor.SetPosition( position );
-  parent.Add( actor );
-  actor.AddRenderer( renderer );
-  return actor;
-}
-
-Actor CreateActor( Vector3 position )
-{
-  Actor actor = Actor::New();
-  actor.SetPosition( position );
-  return actor;
-}
-
-
-Actor CreateBatchParent( Vector3 pos )
-{
-  Actor actor = Actor::New();
-  actor.SetProperty( Actor::Property::BATCH_PARENT, true );
-  actor.SetPosition( pos );
-  Stage::GetCurrent().Add( actor );
-  return actor;
-}
-
-void AddChildren( Actor parent, Actor* children, size_t size )
-{
-  for( size_t i = 0; i < size; ++i )
-  {
-    parent.Add( children[i] );
-  }
-}
-
-}
-
-int UtcDaliGeometryBatcherBatchLevel0(void)
-{
-  TestApplication app;
-  TestGlAbstraction& glAbstraction = app.GetGlAbstraction();
-  glAbstraction.EnableDrawCallTrace( true );
-  TraceCallStack& drawTrace = glAbstraction.GetDrawTrace();
-
-  Shader shaders[1];
-  TextureSet textureSets[1];
-
-  CreateShadersAndTextureSets( shaders, 1, textureSets, 1 );
-  Actor batchParent = CreateBatchParent( Vector3::ZERO );
-  batchParent.SetSize( Stage::GetCurrent().GetSize() );
-
-  Actor children[] = {
-    CreateActor( batchParent, shaders[0], textureSets[0], Vector3( 0.0f, 0.0f, 0.0f ), WHOLE_IMAGE ),
-    CreateActor( batchParent, shaders[0], textureSets[0], Vector3( 10.0f, 0.0f, 0.0f ), WHOLE_IMAGE ),
-    CreateActor( batchParent, shaders[0], textureSets[0], Vector3( 20.0f, 0.0f, 0.0f ), WHOLE_IMAGE ),
-    CreateActor( batchParent, shaders[0], textureSets[0], Vector3( 30.0f, 0.0f, 0.0f ), WHOLE_IMAGE )
-  };
-
-  app.SendNotification();
-  app.Render( 16 );
-  app.SendNotification();
-  app.Render( 16 );
-
-  // should be 1 draw call
-  {
-    int result = drawTrace.CountMethod( "DrawElements");
-    DALI_TEST_CHECK( result == 1 );
-  }
-
-  // remove actor
-  batchParent.Remove( children[0] );
-  children[0].Reset();
-
-  // update
-  app.SendNotification();
-  app.Render( 16 );
-
-  // test geometry for that batch, 1 batch, 3 children, 18 elements in the buffer
-  //Dali::Internal::Actor& actor = GetImplementation( children[1] );
-  MockActor* mockActor = static_cast<MockActor*>( &GetImplementation( children[1] ) );
-  Dali::Internal::SceneGraph::GeometryBatcher* geometryBatcher = mockActor->GetNode()->mGeometryBatcher;
-  DALI_TEST_CHECK( geometryBatcher ); // must not be NULL
-
-  Dali::Internal::Render::Geometry* geometry = geometryBatcher->GetGeometry( 0 );
-  int elementCount = geometry->GetPropertyBuffer(0)->GetElementCount();
-  DALI_TEST_CHECK( elementCount == 18 );
-
-  // delete batch parent
-  Stage::GetCurrent().Remove( batchParent );
-  batchParent.Reset();
-
-  // update
-  app.SendNotification();
-  app.Render( 16 );
-
-  END_TEST;
-}
-
-int UtcDaliGeometryBatcherBatchMultipleTextureSet(void)
-{
-  TestApplication app;
-  TestGlAbstraction& glAbstraction = app.GetGlAbstraction();
-  glAbstraction.EnableDrawCallTrace( true );
-  TraceCallStack& drawTrace = glAbstraction.GetDrawTrace();
-
-  Shader shaders[1];
-  TextureSet textureSets[3];
-  CreateShadersAndTextureSets( shaders, 1, textureSets, 3 );
-
-  Actor batchParent = CreateBatchParent( Vector3::ZERO );
-  batchParent.SetSize( Stage::GetCurrent().GetSize() );
-
-  Actor children[] = {
-    CreateActor( batchParent, shaders[0], textureSets[0], Vector3( 0.0f, 0.0f, 0.0f ), WHOLE_IMAGE ),
-    CreateActor( batchParent, shaders[0], textureSets[0], Vector3( 10.0f, 0.0f, 0.0f ), WHOLE_IMAGE ),
-    CreateActor( batchParent, shaders[0], textureSets[0], Vector3( 20.0f, 0.0f, 0.0f ), WHOLE_IMAGE ),
-    CreateActor( batchParent, shaders[0], textureSets[0], Vector3( 30.0f, 0.0f, 0.0f ), WHOLE_IMAGE ),
-    CreateActor( batchParent, shaders[0], textureSets[1], Vector3( 0.0f, 0.0f, 0.0f ), WHOLE_IMAGE ),
-    CreateActor( batchParent, shaders[0], textureSets[2], Vector3( 10.0f, 0.0f, 0.0f ), WHOLE_IMAGE ),
-    CreateActor( batchParent, shaders[0], textureSets[2], Vector3( 20.0f, 0.0f, 0.0f ), WHOLE_IMAGE ),
-    CreateActor( batchParent, shaders[0], textureSets[1], Vector3( 30.0f, 0.0f, 0.0f ), WHOLE_IMAGE ),
-    CreateActor( batchParent, shaders[0], textureSets[1], Vector3( 0.0f, 0.0f, 0.0f ), WHOLE_IMAGE ),
-    CreateActor( batchParent, shaders[0], textureSets[1], Vector3( 10.0f, 0.0f, 0.0f ), WHOLE_IMAGE ),
-    CreateActor( batchParent, shaders[0], textureSets[2], Vector3( 20.0f, 0.0f, 0.0f ), WHOLE_IMAGE ),
-    CreateActor( batchParent, shaders[0], textureSets[2], Vector3( 30.0f, 0.0f, 0.0f ), WHOLE_IMAGE )
-  };
-
-  // must update twice
-  app.SendNotification();
-  app.Render( 16 );
-  app.SendNotification();
-  app.Render( 16 );
-
-  // should be 3 draw calls here
-  {
-    int result = drawTrace.CountMethod( "DrawElements");
-    DALI_TEST_CHECK( result == 3 );
-  }
-
-  // test assigned indices
-  {
-    bool indicesTest( true );
-    for( size_t i = 0; i < 12; ++i )
-    {
-      MockActor* mockActor = static_cast<MockActor*>( &GetImplementation( children[1] ) );
-      if( mockActor->GetNode()->mBatchIndex == BATCH_NULL_HANDLE )
-      {
-        indicesTest = false;
-      }
-    }
-    DALI_TEST_CHECK( indicesTest );
-  }
-
-  END_TEST;
-}
-
-int UtcDaliGeometryBatcherSettingBatchParent(void)
-{
-  TestApplication app;
-
-  Shader shaders[1];
-  TextureSet textureSets[1];
-  CreateShadersAndTextureSets( shaders, 1, textureSets, 1 );
-
-  Actor batchParent = CreateBatchParent( Vector3::ZERO );
-  batchParent.SetSize( Stage::GetCurrent().GetSize() );
-  app.SendNotification();
-  app.Render( 16 );
-
-  MockActor* mockActor = static_cast<MockActor*>( &GetImplementation( batchParent ) );
-  DALI_TEST_CHECK( mockActor->IsNodeBatchParent() );
-
-  END_TEST;
-}
-
-int UtcDaliGeometryBatcherBatchMultipleParents(void)
-{
-  TestApplication app;
-  TestGlAbstraction& glAbstraction = app.GetGlAbstraction();
-  glAbstraction.EnableDrawCallTrace( true );
-  TraceCallStack& drawTrace = glAbstraction.GetDrawTrace();
-
-  Shader shaders[2];
-  TextureSet textureSets[2];
-  CreateShadersAndTextureSets( shaders, 2, textureSets, 2 );
-
-  Actor batchParent0 = CreateBatchParent( Vector3::ZERO ); // Vector2
-  batchParent0.SetSize( Stage::GetCurrent().GetSize() );
-  Actor batchParent1 = CreateBatchParent( Vector3::ZERO ); // Vector3
-  batchParent1.SetSize( Stage::GetCurrent().GetSize() );
-  Actor batchParent2 = CreateBatchParent( Vector3::ZERO ); // Vector4
-  batchParent2.SetSize( Stage::GetCurrent().GetSize() );
-
-  CreateActor( batchParent0, shaders[0], textureSets[0], Vector3( 0.0f, 0.0f, 0.0f ), WHOLE_IMAGE );
-  CreateActor( batchParent0, shaders[0], textureSets[0], Vector3( 10.0f, 0.0f, 0.0f ), WHOLE_IMAGE );
-  CreateActor( batchParent0, shaders[0], textureSets[0], Vector3( 20.0f, 0.0f, 0.0f ), WHOLE_IMAGE );
-  CreateActor( batchParent0, shaders[0], textureSets[0], Vector3( 30.0f, 0.0f, 0.0f ), WHOLE_IMAGE );
-  CreateActor( batchParent0, shaders[0], textureSets[0], Vector3( 0.0f, 0.0f, 0.0f ), WHOLE_IMAGE );
-  CreateActor( batchParent1, shaders[1], textureSets[1], Vector3( 0.0f, 0.0f, 0.0f ), WHOLE_IMAGE,  CreateBatchQuadGeometryVector3 );
-  CreateActor( batchParent1, shaders[1], textureSets[1], Vector3( 10.0f, 0.0f, 0.0f ), WHOLE_IMAGE, CreateBatchQuadGeometryVector3 );
-  CreateActor( batchParent1, shaders[1], textureSets[1], Vector3( 20.0f, 0.0f, 0.0f ), WHOLE_IMAGE, CreateBatchQuadGeometryVector3 );
-  CreateActor( batchParent2, shaders[0], textureSets[1], Vector3( 30.0f, 0.0f, 0.0f ), WHOLE_IMAGE, CreateBatchQuadGeometryVector4 );
-  CreateActor( batchParent2, shaders[0], textureSets[1], Vector3( 0.0f, 0.0f, 0.0f ), WHOLE_IMAGE,  CreateBatchQuadGeometryVector4 );
-  CreateActor( batchParent2, shaders[0], textureSets[1], Vector3( 30.0f, 0.0f, 0.0f ), WHOLE_IMAGE, CreateBatchQuadGeometryVector4 );
-  CreateActor( batchParent2, shaders[0], textureSets[1], Vector3( 0.0f, 0.0f, 0.0f ), WHOLE_IMAGE,  CreateBatchQuadGeometryVector4 );
-
-  // must update twice
-  app.SendNotification();
-  app.Render( 16 );
-  app.SendNotification();
-  app.Render( 16 );
-
-  // should be 3 draw calls here
-  {
-    int result = drawTrace.CountMethod( "DrawElements");
-    DALI_TEST_EQUALS( result, 3, TEST_LOCATION );
-  }
-
-  // delete batch parent
-  Stage::GetCurrent().Remove( batchParent1 );
-  batchParent1.Reset();
-  drawTrace.Reset();
-  app.SendNotification();
-  app.Render( 16 );
-  // should be 2 draw calls here
-  {
-    int result = drawTrace.CountMethod( "DrawElements");
-    DALI_TEST_EQUALS( result, 2, TEST_LOCATION );
-  }
-
-  END_TEST;
-}
index b50f506489cb409a7e291584187ab3a240ec60a7..467bb526280c47e3d8be9c943aa7e39a16464414 100644 (file)
@@ -337,51 +337,3 @@ BufferImage CreateBufferImage()
 {
   return CreateBufferImage(4, 4, Color::WHITE);
 }
-
-namespace Test
-{
-
-struct ObjectDestructionFunctor
-{
-  // Create a ObjectDestructionFunctor passing in a Dali::RefObject* to be monitored and a bool variable.
-  // Create ObjectRegistry instance and connect to the ObjectDestroyedSignal passing in the above functor for the callback.
-  // Get the ObjectPointer (Actor::GetObjectPtr) of the Actor to be checked for destruction and assign it to the Dali::RefObject*
-  // Check the bool variable which would be true when object destroyed.
-  ObjectDestructionFunctor( Dali::RefObject* objectPtr, bool& refObjectDestroyed )
-  : refObjectPointerToCheck( objectPtr ),
-    refObjectDestroyedBoolean( refObjectDestroyed )
-  {
-    refObjectDestroyed = false;
-  }
-
-  void operator()( const Dali::RefObject* objectPointer )
-  {
-    if ( refObjectPointerToCheck == objectPointer )
-    {
-      refObjectDestroyedBoolean = true;
-    }
-  }
-
-  Dali::RefObject* refObjectPointerToCheck;
-  bool& refObjectDestroyedBoolean;
-};
-
-ObjectDestructionTracker::ObjectDestructionTracker()
-  :mRefObjectDestroyed( false)
-{
-}
-
-void ObjectDestructionTracker::Start( Actor actor )
-{
-  ObjectDestructionFunctor destructionFunctor( actor.GetObjectPtr(), mRefObjectDestroyed );
-
-  ObjectRegistry objectRegistry = Stage::GetCurrent().GetObjectRegistry();
-  objectRegistry.ObjectDestroyedSignal().Connect( this, destructionFunctor );
-}
-
-bool ObjectDestructionTracker::IsDestroyed()
-{
-   return mRefObjectDestroyed;
-}
-
-} // namespace Test
index 8cefb7c53a7edc5b22769391ada8506ebab9d24e..7f81872e1388101410e950f9cb6b514de80fd00e 100644 (file)
@@ -499,45 +499,4 @@ struct DefaultFunctionCoverage
 BufferImage CreateBufferImage();
 BufferImage CreateBufferImage(int width, int height, const Vector4& color);
 
-// Test namespace to prevent pollution of Dali namespace, add Test helper functions here
-namespace Test
-{
-/**
- *  @brief
- *
- *  Helper to check object destruction occurred
- *  1) In main part of code create an ObjectDestructionTracker
- *  2) Within sub section of main create object Actor test and call Start with Actor to test for destruction
- *  3) Perform code which is expected to destroy Actor
- *  4) Back in main part of code use IsDestroyed() to test if Actor was destroyed
- */
-class ObjectDestructionTracker : public ConnectionTracker
-{
-public:
-
-  /**
-   * @brief Call in main part of code
-   */
-  ObjectDestructionTracker();
-
-  /**
-   * @brief Call in sub bock of code where the Actor being checked is still alive.
-   *
-   * @param[in] actor Actor to be checked for destruction
-   */
-  void Start( Actor actor );
-
-  /**
-   * @brief Call to check if Actor alive or destroyed.
-   *
-   * @return bool true if Actor was destroyed
-   */
-  bool IsDestroyed();
-
-private:
-  bool mRefObjectDestroyed;
-};
-
-} // namespace Test
-
 #endif // __DALI_TEST_SUITE_UTILS_H__
index 6e9b9f0e92d06d8513abb0b5bb67be858ffb53b2..d42a548e55509da3bcdd8cdf845bb6fc37747185 100644 (file)
@@ -70,7 +70,6 @@ void TestGlAbstraction::Initialize()
   mLastShaderIdUsed = 0;
   mLastProgramIdUsed = 0;
   mLastUniformIdUsed = 0;
-  mLastDepthMask = false;
 
   mUniforms.clear();
   mProgramUniforms1i.clear();
@@ -80,10 +79,8 @@ void TestGlAbstraction::Initialize()
   mProgramUniforms4f.clear();
 
   mCullFaceTrace.Reset();
-  mDepthFunctionTrace.Reset();
   mEnableDisableTrace.Reset();
   mShaderTrace.Reset();
-  mStencilFunctionTrace.Reset();
   mTextureTrace.Reset();
   mTexParamaterTrace.Reset();
   mDrawTrace.Reset();
index 10c326429ebe43375b6b0245deb5e5ba75aa6a08..1f5597700a4c0a2925a398ff1897ec5b590cebc8 100644 (file)
@@ -1,8 +1,8 @@
-#ifndef TEST_GL_ABSTRACTION_H
-#define TEST_GL_ABSTRACTION_H
+#ifndef __TEST_GL_ABSTRACTION_H__
+#define __TEST_GL_ABSTRACTION_H__
 
 /*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2014 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.
@@ -468,12 +468,6 @@ public:
 
   inline void DepthMask(GLboolean flag)
   {
-    mLastDepthMask = flag;
-  }
-
-  inline bool GetLastDepthMask() const
-  {
-    return mLastDepthMask;
   }
 
   inline void DepthRangef(GLclampf zNear, GLclampf zFar)
@@ -2065,8 +2059,6 @@ private:
   GLenum  mLastBlendFuncSrcAlpha;
   GLenum  mLastBlendFuncDstAlpha;
 
-  GLboolean mLastDepthMask;
-
   // Data for manipulating the IDs returned by GenTextures
   GLuint mLastAutoTextureIdUsed;
   std::vector<GLuint> mNextTextureIds;
@@ -2266,4 +2258,6 @@ bool BlendEnabled(const Dali::TraceCallStack& callStack);
 bool BlendDisabled(const Dali::TraceCallStack& callStack);
 
 
-#endif // TEST_GL_ABSTRACTION_H
+
+
+#endif // __TEST_GL_ES_H__
index 3bfbacf68263fd559a75bfb9b71294a1d664929a..a812941120232bef2d5ff848ce344158361554dd 100644 (file)
@@ -36,8 +36,8 @@ const BlendFactor::Type   DEFAULT_BLEND_FACTOR_DEST_RGB(   BlendFactor::ONE_MINU
 const BlendFactor::Type   DEFAULT_BLEND_FACTOR_SRC_ALPHA(  BlendFactor::ONE );
 const BlendFactor::Type   DEFAULT_BLEND_FACTOR_DEST_ALPHA( BlendFactor::ONE_MINUS_SRC_ALPHA );
 
-const BlendEquation::Type DEFAULT_BLEND_EQUATION_RGB(      BlendEquation::ADD );
-const BlendEquation::Type DEFAULT_BLEND_EQUATION_ALPHA(    BlendEquation::ADD );
+const BlendEquation::Type DEFAULT_BLEND_EQUATION_RGB(   BlendEquation::ADD );
+const BlendEquation::Type DEFAULT_BLEND_EQUATION_ALPHA( BlendEquation::ADD );
 
 /**
  * @brief Get GL stencil test enumeration value as a string.
@@ -50,17 +50,6 @@ std::string GetStencilTestString(void)
   return stream.str();
 }
 
-/**
- * @brief Get GL depth test enumeration value as a string.
- * @return The string representation of the value of GL_DEPTH_TEST
- */
-std::string GetDepthTestString(void)
-{
-  std::stringstream stream;
-  stream << GL_DEPTH_TEST;
-  return stream.str();
-}
-
 void ResetDebugAndFlush( TestApplication& application, TraceCallStack& glEnableDisableStack, TraceCallStack& glStencilFunctionStack )
 {
   glEnableDisableStack.Reset();
@@ -1058,6 +1047,8 @@ int UtcDaliRendererConstraint02(void)
   END_TEST;
 }
 
+
+
 int UtcDaliRendererAnimatedProperty01(void)
 {
   TestApplication application;
@@ -1400,6 +1391,7 @@ int UtcDaliRendererUniformMapMultipleUniforms02(void)
   END_TEST;
 }
 
+
 int UtcDaliRendererRenderOrder2DLayer(void)
 {
   TestApplication application;
@@ -2045,60 +2037,7 @@ int UtcDaliRendererSetDepthFunction(void)
   END_TEST;
 }
 
-/**
- * @brief This templatized function checks an enumeration property is setting and getting correctly.
- * The checks performed are as follows:
- *  - Check the initial/default value.
- *  - Set a different value via enum.
- *  - Check it was set.
- *  - Set a different value via string.
- *  - Check it was set.
- */
-template< typename T >
-void CheckEnumerationProperty( Renderer& renderer, Property::Index propertyIndex, T initialValue, T firstCheckEnumeration, T secondCheckEnumeration, std::string secondCheckString )
-{
-  DALI_TEST_CHECK( renderer.GetProperty<int>( propertyIndex ) == static_cast<int>( initialValue ) );
-  renderer.SetProperty( propertyIndex, firstCheckEnumeration );
-  DALI_TEST_CHECK( renderer.GetProperty<int>( propertyIndex ) == static_cast<int>( firstCheckEnumeration ) );
-  renderer.SetProperty( propertyIndex, secondCheckString );
-  DALI_TEST_CHECK( renderer.GetProperty<int>( propertyIndex ) == static_cast<int>( secondCheckEnumeration ) );
-}
-
-int UtcDaliRendererEnumProperties(void)
-{
-  TestApplication application;
-  tet_infoline( "Test Renderer enumeration properties can be set with both integer and string values" );
-
-  Geometry geometry = CreateQuadGeometry();
-  Shader shader = CreateShader();
-  Renderer renderer = Renderer::New( geometry, shader );
-
-  /*
-   * Here we use a templatized function to perform several checks on each enumeration property.
-   * @see CheckEnumerationProperty for details of the checks performed.
-   */
-
-  CheckEnumerationProperty< FaceCullingMode::Type >( renderer, Renderer::Property::FACE_CULLING_MODE, FaceCullingMode::NONE, FaceCullingMode::FRONT, FaceCullingMode::BACK, "BACK" );
-  CheckEnumerationProperty< BlendMode::Type >( renderer, Renderer::Property::BLEND_MODE, BlendMode::AUTO, BlendMode::OFF, BlendMode::ON, "ON" );
-  CheckEnumerationProperty< BlendEquation::Type >( renderer, Renderer::Property::BLEND_EQUATION_RGB, BlendEquation::ADD, BlendEquation::SUBTRACT, BlendEquation::REVERSE_SUBTRACT, "REVERSE_SUBTRACT" );
-  CheckEnumerationProperty< BlendEquation::Type >( renderer, Renderer::Property::BLEND_EQUATION_ALPHA, BlendEquation::ADD, BlendEquation::SUBTRACT, BlendEquation::REVERSE_SUBTRACT, "REVERSE_SUBTRACT" );
-  CheckEnumerationProperty< BlendFactor::Type >( renderer, Renderer::Property::BLEND_FACTOR_SRC_RGB, BlendFactor::SRC_ALPHA, BlendFactor::ONE, BlendFactor::SRC_COLOR, "SRC_COLOR" );
-  CheckEnumerationProperty< BlendFactor::Type >( renderer, Renderer::Property::BLEND_FACTOR_DEST_RGB, BlendFactor::ONE_MINUS_SRC_ALPHA, BlendFactor::ONE, BlendFactor::SRC_COLOR, "SRC_COLOR" );
-  CheckEnumerationProperty< BlendFactor::Type >( renderer, Renderer::Property::BLEND_FACTOR_SRC_ALPHA, BlendFactor::ONE, BlendFactor::ONE_MINUS_SRC_ALPHA, BlendFactor::SRC_COLOR, "SRC_COLOR" );
-  CheckEnumerationProperty< BlendFactor::Type >( renderer, Renderer::Property::BLEND_FACTOR_DEST_ALPHA, BlendFactor::ONE_MINUS_SRC_ALPHA, BlendFactor::ONE, BlendFactor::SRC_COLOR, "SRC_COLOR" );
-  CheckEnumerationProperty< DepthWriteMode::Type >( renderer, Renderer::Property::DEPTH_WRITE_MODE, DepthWriteMode::AUTO, DepthWriteMode::OFF, DepthWriteMode::ON, "ON" );
-  CheckEnumerationProperty< DepthFunction::Type >( renderer, Renderer::Property::DEPTH_FUNCTION, DepthFunction::LESS, DepthFunction::ALWAYS, DepthFunction::GREATER, "GREATER" );
-  CheckEnumerationProperty< DepthTestMode::Type >( renderer, Renderer::Property::DEPTH_TEST_MODE, DepthTestMode::AUTO, DepthTestMode::OFF, DepthTestMode::ON, "ON" );
-  CheckEnumerationProperty< StencilFunction::Type >( renderer, Renderer::Property::STENCIL_FUNCTION, StencilFunction::ALWAYS, StencilFunction::LESS, StencilFunction::EQUAL, "EQUAL" );
-  CheckEnumerationProperty< StencilMode::Type >( renderer, Renderer::Property::STENCIL_MODE, StencilMode::AUTO, StencilMode::OFF, StencilMode::ON, "ON" );
-  CheckEnumerationProperty< StencilOperation::Type >( renderer, Renderer::Property::STENCIL_OPERATION_ON_FAIL, StencilOperation::KEEP, StencilOperation::REPLACE, StencilOperation::INCREMENT, "INCREMENT" );
-  CheckEnumerationProperty< StencilOperation::Type >( renderer, Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL, StencilOperation::KEEP, StencilOperation::REPLACE, StencilOperation::INCREMENT, "INCREMENT" );
-  CheckEnumerationProperty< StencilOperation::Type >( renderer, Renderer::Property::STENCIL_OPERATION_ON_Z_PASS, StencilOperation::KEEP, StencilOperation::REPLACE, StencilOperation::INCREMENT, "INCREMENT" );
-
-  END_TEST;
-}
-
-Renderer RendererTestFixture( TestApplication& application )
+Renderer StencilTestFixture( TestApplication& application )
 {
   Geometry geometry = CreateQuadGeometry();
   Shader shader = CreateShader();
@@ -2114,124 +2053,12 @@ Renderer RendererTestFixture( TestApplication& application )
   return renderer;
 }
 
-int UtcDaliRendererSetDepthTestMode(void)
-{
-  TestApplication application;
-  tet_infoline("Test setting the DepthTestMode");
-
-  Renderer renderer = RendererTestFixture( application );
-  TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
-  glAbstraction.EnableEnableDisableCallTrace( true );
-  TraceCallStack& glEnableDisableStack = glAbstraction.GetEnableDisableTrace();
-
-  glEnableDisableStack.Reset();
-  application.SendNotification();
-  application.Render();
-
-  // Check depth-test is enabled by default.
-  DALI_TEST_CHECK( glEnableDisableStack.FindMethodAndParams( "Enable", GetDepthTestString() ) );
-  DALI_TEST_CHECK( !glEnableDisableStack.FindMethodAndParams( "Disable", GetDepthTestString() ) );
-
-  // Turn off depth-testing. We want to check if the depth buffer has been disabled, so we need to turn off depth-write as well for this case.
-  renderer.SetProperty( Renderer::Property::DEPTH_TEST_MODE, DepthTestMode::OFF );
-  renderer.SetProperty( Renderer::Property::DEPTH_WRITE_MODE, DepthWriteMode::OFF );
-
-  glEnableDisableStack.Reset();
-  application.SendNotification();
-  application.Render();
-
-  // Check the depth buffer was disabled.
-  DALI_TEST_CHECK( glEnableDisableStack.FindMethodAndParams( "Disable", GetDepthTestString() ) );
-
-  // Turn on automatic mode depth-testing.
-  // Layer behavior is currently set to LAYER_3D so AUTO should enable depth-testing.
-  renderer.SetProperty( Renderer::Property::DEPTH_TEST_MODE, DepthTestMode::AUTO );
-
-  glEnableDisableStack.Reset();
-  application.SendNotification();
-  application.Render();
-
-  // Check depth-test is now enabled.
-  DALI_TEST_CHECK( glEnableDisableStack.FindMethodAndParams( "Enable", GetDepthTestString() ) );
-  DALI_TEST_CHECK( !glEnableDisableStack.FindMethodAndParams( "Disable", GetDepthTestString() ) );
-
-  // Change the layer behavior to LAYER_2D.
-  // Note this will also disable depth testing for the layer by default, we test this first.
-  Stage::GetCurrent().GetRootLayer().SetBehavior( Layer::LAYER_2D );
-
-  glEnableDisableStack.Reset();
-  application.SendNotification();
-  application.Render();
-
-  // Check depth-test is disabled.
-  DALI_TEST_CHECK( glEnableDisableStack.FindMethodAndParams( "Disable", GetDepthTestString() ) );
-
-  // Turn the layer depth-test flag back on, and confirm that depth testing is *still* off.
-  // This is because our renderer has DepthTestMode::AUTO and our layer behavior is LAYER_2D.
-  Stage::GetCurrent().GetRootLayer().SetDepthTestDisabled( false );
-
-  glEnableDisableStack.Reset();
-  application.SendNotification();
-  application.Render();
-
-  // Check depth-test is *still* disabled.
-  DALI_TEST_CHECK( glEnableDisableStack.FindMethodAndParams( "Disable", GetDepthTestString() ) );
-
-  END_TEST;
-}
-
-int UtcDaliRendererSetDepthWriteMode(void)
-{
-  TestApplication application;
-  tet_infoline("Test setting the DepthWriteMode");
-
-  Renderer renderer = RendererTestFixture( application );
-  TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
-
-  application.SendNotification();
-  application.Render();
-
-  // Check the default depth-write status first.
-  DALI_TEST_CHECK( glAbstraction.GetLastDepthMask() );
-
-  // Turn off depth-writing.
-  renderer.SetProperty( Renderer::Property::DEPTH_WRITE_MODE, DepthWriteMode::OFF );
-
-  application.SendNotification();
-  application.Render();
-
-  // Check depth-write is now disabled.
-  DALI_TEST_CHECK( !glAbstraction.GetLastDepthMask() );
-
-  // Test the AUTO mode for depth-writing.
-  // As our renderer is opaque, depth-testing should be enabled.
-  renderer.SetProperty( Renderer::Property::DEPTH_WRITE_MODE, DepthWriteMode::AUTO );
-
-  application.SendNotification();
-  application.Render();
-
-  // Check depth-write is now enabled.
-  DALI_TEST_CHECK( glAbstraction.GetLastDepthMask() );
-
-  // Now make the renderer be treated as translucent by enabling blending.
-  // The AUTO depth-write mode should turn depth-write off in this scenario.
-  renderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::ON );
-
-  application.SendNotification();
-  application.Render();
-
-  // Check depth-write is now disabled.
-  DALI_TEST_CHECK( !glAbstraction.GetLastDepthMask() );
-
-  END_TEST;
-}
-
 int UtcDaliRendererCheckStencilDefaults(void)
 {
   TestApplication application;
   tet_infoline("Test the stencil defaults");
 
-  Renderer renderer = RendererTestFixture( application );
+  Renderer renderer = StencilTestFixture( application );
   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
   glAbstraction.EnableEnableDisableCallTrace( true );
   glAbstraction.EnableStencilFunctionCallTrace( true );
@@ -2257,7 +2084,7 @@ int UtcDaliRendererSetStencilMode(void)
   TestApplication application;
   tet_infoline("Test setting the StencilMode");
 
-  Renderer renderer = RendererTestFixture( application );
+  Renderer renderer = StencilTestFixture( application );
   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
   glAbstraction.EnableEnableDisableCallTrace( true );
   glAbstraction.EnableStencilFunctionCallTrace( true );
@@ -2290,7 +2117,7 @@ int UtcDaliRendererSetStencilFunction(void)
   TestApplication application;
   tet_infoline("Test setting the StencilFunction");
 
-  Renderer renderer = RendererTestFixture( application );
+  Renderer renderer = StencilTestFixture( application );
   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
   glAbstraction.EnableEnableDisableCallTrace( true );
   glAbstraction.EnableStencilFunctionCallTrace( true );
@@ -2380,7 +2207,7 @@ int UtcDaliRendererSetStencilOperation(void)
   TestApplication application;
   tet_infoline("Test setting the StencilOperation");
 
-  Renderer renderer = RendererTestFixture( application );
+  Renderer renderer = StencilTestFixture( application );
   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
   glAbstraction.EnableEnableDisableCallTrace( true );
   glAbstraction.EnableStencilFunctionCallTrace( true );
@@ -2467,7 +2294,7 @@ int UtcDaliRendererSetStencilMask(void)
   TestApplication application;
   tet_infoline("Test setting the StencilMask");
 
-  Renderer renderer = RendererTestFixture( application );
+  Renderer renderer = StencilTestFixture( application );
   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
   glAbstraction.EnableEnableDisableCallTrace( true );
   glAbstraction.EnableStencilFunctionCallTrace( true );
@@ -2512,7 +2339,7 @@ int UtcDaliRendererSetWriteToColorBuffer(void)
   TestApplication application;
   tet_infoline("Test setting the WriteToColorBuffer flag");
 
-  Renderer renderer = RendererTestFixture( application );
+  Renderer renderer = StencilTestFixture( application );
   TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
 
   // Set the StencilMask property to a value.
index adc5760a6f7e0e234f2db6ef9aa352aebfa516b4..4a1ed8b125e9e4434cce3f45e5d5dc6f292b858f 100644 (file)
@@ -52,11 +52,11 @@ ConditionalWait::ConditionalWait()
 {
   if( pthread_mutex_init( &mImpl->mutex, NULL ) )
   {
-    DALI_LOG_ERROR( "Unable to initialise mutex in ConditionalWait\n" );
+    DALI_LOG_ERROR( "Unable to initialise mutex in ConditionalWait" );
   }
   if( pthread_cond_init( &mImpl->condition, NULL ) )
   {
-    DALI_LOG_ERROR( "Unable to initialise conditional\n" );
+    DALI_LOG_ERROR( "Unable to initialise conditional" );
   }
   mImpl->count = 0;
 }
@@ -65,11 +65,11 @@ ConditionalWait::~ConditionalWait()
 {
   if( pthread_cond_destroy( &mImpl->condition ) )
   {
-    DALI_LOG_ERROR( "Unable to destroy conditional\n" );
+    DALI_LOG_ERROR( "Unable to destroy conditional" );
   }
   if( pthread_mutex_destroy( &mImpl->mutex ) )
   {
-    DALI_LOG_ERROR( "Unable to destroy mutex in ConditionalWait\n" );
+    DALI_LOG_ERROR( "Unable to destroy mutex in ConditionalWait" );
   }
   delete mImpl;
 }
@@ -86,7 +86,7 @@ void ConditionalWait::Notify()
   {
     if( pthread_cond_broadcast( &mImpl->condition ) )
     {
-      DALI_LOG_ERROR( "Error calling pthread_cond_broadcast\n" );
+      DALI_LOG_ERROR( "Error calling pthread_cond_broadcast" );
     }
   }
   Internal::Mutex::Unlock( &mImpl->mutex );
@@ -105,7 +105,7 @@ void ConditionalWait::Notify( const ScopedLock& scope )
   {
     if( pthread_cond_broadcast( &mImpl->condition ) )
     {
-      DALI_LOG_ERROR( "Error calling pthread_cond_broadcast\n" );
+      DALI_LOG_ERROR( "Error calling pthread_cond_broadcast" );
     }
   }
 }
@@ -121,7 +121,7 @@ void ConditionalWait::Wait()
     // wait while condition changes
     if( pthread_cond_wait( &mImpl->condition, &mImpl->mutex ) ) // releases the lock whilst waiting
     {
-      DALI_LOG_ERROR( "Error calling pthread_cond_wait\n" );
+      DALI_LOG_ERROR( "Error calling pthread_cond_wait" );
       break;
     }
   }
@@ -144,7 +144,7 @@ void ConditionalWait::Wait( const ScopedLock& scope )
     // wait while condition changes
     if( pthread_cond_wait( &mImpl->condition, &mImpl->mutex ) ) // releases the lock whilst waiting
     {
-      DALI_LOG_ERROR( "Error calling pthread_cond_wait\n" );
+      DALI_LOG_ERROR( "Error calling pthread_cond_wait" );
       break;
     }
   }
index 4e0cb30ea2d9aaab41d45e5c7e762488beaeb2cd..fdb9cde0c8d44515bcdf39b167711d573bd6c86c 100644 (file)
@@ -39,7 +39,7 @@ Mutex::Mutex()
 {
   if( pthread_mutex_init( &mImpl->mutex, NULL ) )
   {
-    DALI_LOG_ERROR( "Unable to initialise Mutex\n" );
+    DALI_LOG_ERROR( "Unable to initialise Mutex" );
   }
   mImpl->locked = false;
 }
@@ -48,7 +48,7 @@ Mutex::~Mutex()
 {
   if( pthread_mutex_destroy( &mImpl->mutex ) )
   {
-    DALI_LOG_ERROR( "Unable to destroy Mutex\n" );
+    DALI_LOG_ERROR( "Unable to destroy Mutex" );
   }
   // nothing else to do as there is no Lock/Unlock API
   // ScopedLock destructor will always unlock the mutex
index b4154824c6f813c1c08b19e2ca1540a5edf52444..c9ca158da92371cf9235362ee64c77ec0d8c3b21 100644 (file)
@@ -44,7 +44,6 @@
 #include <dali/internal/update/common/discard-queue.h>
 #include <dali/internal/update/common/texture-cache-dispatcher.h>
 #include <dali/internal/update/manager/update-manager.h>
-#include <dali/internal/update/manager/geometry-batcher.h>
 #include <dali/internal/update/resources/resource-manager.h>
 
 #include <dali/internal/render/common/performance-monitor.h>
@@ -98,7 +97,6 @@ Core::Core( RenderController& renderController, PlatformAbstraction& platform,
   mNotificationManager(NULL),
   mImageFactory(NULL),
   mShaderFactory(NULL),
-  mGeometryBatcher( NULL ),
   mIsActive(true),
   mProcessingEvent(false)
 {
@@ -116,9 +114,7 @@ Core::Core( RenderController& renderController, PlatformAbstraction& platform,
 
   mTextureUploadedQueue = new LockedResourceQueue;
 
-  mGeometryBatcher = new SceneGraph::GeometryBatcher();
-
-  mRenderManager = RenderManager::New( glAbstraction, glSyncAbstraction, *mGeometryBatcher, *mTextureUploadedQueue );
+  mRenderManager = RenderManager::New( glAbstraction, glSyncAbstraction, *mTextureUploadedQueue );
 
   RenderQueue& renderQueue = mRenderManager->GetRenderQueue();
   TextureCache& textureCache = mRenderManager->GetTextureCache();
@@ -149,8 +145,7 @@ Core::Core( RenderController& renderController, PlatformAbstraction& platform,
                                        renderController,
                                       *mRenderManager,
                                        renderQueue,
-                                      *mTextureCacheDispatcher,
-                                      *mGeometryBatcher );
+                                      *mTextureCacheDispatcher );
 
   mRenderManager->SetShaderSaver( *mUpdateManager );
 
@@ -215,7 +210,6 @@ Core::~Core()
   delete mTextureCacheDispatcher;
   delete mUpdateManager;
   delete mRenderManager;
-  delete mGeometryBatcher;
   delete mTextureUploadedQueue;
 }
 
@@ -319,7 +313,7 @@ void Core::ProcessEvents()
   // Guard against calls to ProcessEvents() during ProcessEvents()
   if( mProcessingEvent )
   {
-    DALI_LOG_ERROR( "ProcessEvents should not be called from within ProcessEvents!\n" );
+    DALI_LOG_ERROR( "ProcessEvents should not be called from within ProcessEvents!" );
     mRenderController.RequestProcessEventsOnIdle();
     return;
   }
index d40f827ed679dac6f2c74d114ea7c1df1df2133a..b9472cdfea6914332f11f91c9881142c0d5a47c1 100644 (file)
@@ -66,7 +66,6 @@ class UpdateManager;
 class RenderManager;
 class DiscardQueue;
 class TextureCacheDispatcher;
-class GeometryBatcher;
 }
 
 /**
@@ -295,7 +294,7 @@ private:
   ResourceClient*                           mResourceClient;              ///< Asynchronous Resource Loading
   ResourceManager*                          mResourceManager;             ///< Asynchronous Resource Loading
   IntrusivePtr< RelayoutController >        mRelayoutController;          ///< Size negotiation relayout controller
-  SceneGraph::GeometryBatcher*              mGeometryBatcher;             ///< Instance of the geometry batcher
+
   bool                                      mIsActive         : 1;        ///< Whether Core is active or suspended
   bool                                      mProcessingEvent  : 1;        ///< True during ProcessEvents()
 
index 3b0baf90c406a26b4ce34dc869f66576b0dcbad9..1e3c0519315db97b3b29b64ff11e7c4252dd4e9c 100644 (file)
@@ -57,80 +57,3 @@ float Dali::Internal::Length( const Vec3 v )
 {
   return sqrtf(v[0]*v[0] + v[1]*v[1] + v[2]*v[2]);
 }
-
-void Dali::Internal::MultiplyVectorBySize( Vec2& result, const Vec2 v, const Size3 s )
-{
-  result[0] = v[0] * s[0];
-  result[1] = v[1] * s[1];
-}
-
-void Dali::Internal::MultiplyVectorBySize( Vec3& result, const Vec3 v, const Size3 s )
-{
-  result[0] = v[0] * s[0];
-  result[1] = v[1] * s[1];
-  result[2] = v[2] * s[2];
-}
-
-void Dali::Internal::MultiplyVectorBySize( Vec4& result, const Vec4 v, const Size3 s )
-{
-  result[0] = v[0] * s[0];
-  result[1] = v[1] * s[1];
-  result[2] = v[2] * s[2];
-  result[3] = 1.0f;
-}
-
-void Dali::Internal::MultiplyVectorByMatrix4( Vec2& result, const Mat4 m, const Vec2 v )
-{
-  result[0] = v[0] * m[0] + v[1] * m[4] + m[12];
-  result[1] = v[0] * m[1] + v[1] * m[5] + m[13];
-}
-
-void Dali::Internal::MultiplyVectorByMatrix4( Vec3& result, const Mat4 m, const Vec3 v )
-{
-  result[0] = v[0] * m[0] + v[1] * m[4] + v[2] * m[8]  +  m[12];
-  result[1] = v[0] * m[1] + v[1] * m[5] + v[2] * m[9]  +  m[13];
-  result[2] = v[0] * m[2] + v[1] * m[6] + v[2] * m[10] +  m[14];
-}
-
-void Dali::Internal::MultiplyVectorByMatrix4( Vec4& result, const Mat4 m, const Vec4 rhs )
-{
-  result[0] = rhs[0] * m[0] + rhs[1] * m[4] + rhs[2] * m[8]  +  rhs[3] * m[12];
-  result[1] = rhs[0] * m[1] + rhs[1] * m[5] + rhs[2] * m[9]  +  rhs[3] * m[13];
-  result[2] = rhs[0] * m[2] + rhs[1] * m[6] + rhs[2] * m[10] +  rhs[3] * m[14];
-  result[3] = rhs[0] * m[3] + rhs[1] * m[7] + rhs[2] * m[11] +  rhs[3] * m[15];
-}
-
-void Dali::Internal::MultiplyMatrices( float* result, const Mat4 lhs, const Mat4 rhs )
-{
-  for( int i=0; i < 4; i++ )
-  {
-    // i<<2 gives the first vector / column
-    int loc = i<<2;
-    int loc1 = loc + 1;
-    int loc2 = loc + 2;
-    int loc3 = loc + 3;
-    float value0 = lhs[loc];
-    float value1 = lhs[loc1];
-    float value2 = lhs[loc2];
-    float value3 = lhs[loc3];
-    result[loc]  = (value0 * rhs[0]) +
-                   (value1 * rhs[4]) +
-                   (value2 * rhs[8]) +
-                   (value3 * rhs[12]);
-
-    result[loc1] = (value0 * rhs[1]) +
-                   (value1 * rhs[5]) +
-                   (value2 * rhs[9]) +
-                   (value3 * rhs[13]);
-
-    result[loc2] = (value0 * rhs[2]) +
-                   (value1 * rhs[6]) +
-                   (value2 * rhs[10])+
-                   (value3 * rhs[14]);
-
-    result[loc3] = (value0 * rhs[3]) +
-                   (value1 * rhs[7]) +
-                   (value2 * rhs[11])+
-                   (value3 * rhs[15]);
-  }
-}
index 4fce86913a822f6511c2d67a6c927deb7d173e8e..ebb62910dc322277fe48feb88c226f28c9683371 100644 (file)
@@ -24,11 +24,9 @@ namespace Dali
 namespace Internal
 {
 
-typedef float Vec2[2];
 typedef float Vec3[3];
 typedef float Vec4[4];
 typedef float Mat4[16];
-typedef Vec3  Size3;
 
 /**
  * @brief Applies a transformation matrix to a vector
@@ -47,70 +45,6 @@ void TransformVector3( Vec3 result, const Mat4 m, const Vec3 v );
  */
 float Length( const Vec3 v );
 
-/**
- * @brief Transforms 2D vector by the Size3 and stores value in Vec2
- *
- * @param[out] result Vec2 type to store final value
- * @param[in] v Vector to transform
- * @param[in] s Size to transform with
- */
-void MultiplyVectorBySize( Vec2& result, const Vec2 v, const Size3 s );
-
-/**
- * @brief Transforms 3D vector by the Size3 and stores value in Vec3
- *
- * @param[out] result Vec3 type to store final value
- * @param[in] v Vector to transform
- * @param[in] s Size to transform with
- */
-void MultiplyVectorBySize( Vec3& result, const Vec3 v, const Size3 s );
-
-/**
- * @brief Transforms 4D vector by the Size3 and stores value in Vec4
- *
- * @param[out] result Vec4 type to store final value
- * @param[in] v Vector to transform
- * @param[in] s Size to transform with
- */
-void MultiplyVectorBySize( Vec4& result, const Vec4 v, const Size3 s );
-
-/**
- * @brief Multiplies 2D vector by the matrix
- *
- * @param[out] result Result of the multiplication
- * @param[in] m Matrix to use
- * @param[in] v Vector to multiply
- */
-void MultiplyVectorByMatrix4( Vec2& result, const Mat4 m, const Vec2 v );
-
-/**
- * @brief Multiplies 3D vector by the matrix
- *
- * @param[out] result Result of the multiplication
- * @param[in] m Matrix to use
- * @param[in] v Vector to multiply
- */
-void MultiplyVectorByMatrix4( Vec3& result, const Mat4 m, const Vec3 v );
-
-/**
- * @brief Multiplies 4D vector by the matrix
- *
- * @param[out] result Result of the multiplication
- * @param[in] m Matrix to use
- * @param[in] v Vector to multiply
- */
-void MultiplyVectorByMatrix4( Vec4& result, const Mat4 m, const Vec4 v );
-
-/**
- * @brief Multiplies two Mat4 matrices
- *
- * @param[out] result Result of multiplication
- * @param[in] lhs Left-hand-side matrix to use
- * @param[in] rhs Right-hand-side matrix to use
- */
-void MultiplyMatrices( float* result, const Mat4 lhs, const Mat4 rhs );
-
-
 } // namespace Internal
 
 } // namespace Dali
index 06d1ddfceebd8ad235e9cf3cbaaa39ef614a9790..c046dc35c8b0b2c321498626fde9f0ade3fca4e3 100644 (file)
@@ -109,7 +109,7 @@ void Lock( pthread_mutex_t* mutex )
 
   if( pthread_mutex_lock( mutex ) )
   {
-    DALI_LOG_ERROR( "Error calling pthread_mutex_lock\n" );
+    DALI_LOG_ERROR( "Error calling pthread_mutex_lock" );
   }
 }
 
@@ -117,7 +117,7 @@ void Unlock( pthread_mutex_t* mutex )
 {
   if( pthread_mutex_unlock( mutex ) )
   {
-    DALI_LOG_ERROR( "Error calling pthread_mutex_unlock\n" );
+    DALI_LOG_ERROR( "Error calling pthread_mutex_unlock" );
   }
   --gThreadLockCount;
 }
index 7b1975745046e15efd8419f79a8433377b4a7aaa..5df7b5c6a740f7ada195d9e6d0a761f30d859472 100644 (file)
@@ -200,7 +200,6 @@ DALI_PROPERTY( "padding",           VECTOR4,  true,  false, false, Dali::Actor::
 DALI_PROPERTY( "minimumSize",       VECTOR2,  true,  false, false, Dali::Actor::Property::MINIMUM_SIZE )
 DALI_PROPERTY( "maximumSize",       VECTOR2,  true,  false, false, Dali::Actor::Property::MAXIMUM_SIZE )
 DALI_PROPERTY( "inheritPosition",   BOOLEAN,  true,  false, false, Dali::Actor::Property::INHERIT_POSITION )
-DALI_PROPERTY( "batchParent",          BOOLEAN,  true,  false, false, Dali::Actor::Property::BATCH_PARENT )
 DALI_PROPERTY_TABLE_END( DEFAULT_ACTOR_PROPERTY_START_INDEX )
 
 // Signals
@@ -1975,8 +1974,7 @@ Actor::Actor( DerivedType derivedType )
   mInheritScale( true ),
   mDrawMode( DrawMode::NORMAL ),
   mPositionInheritanceMode( Node::DEFAULT_POSITION_INHERITANCE_MODE ),
-  mColorMode( Node::DEFAULT_COLOR_MODE ),
-  mIsBatchParent( false )
+  mColorMode( Node::DEFAULT_COLOR_MODE )
 {
 }
 
@@ -2650,20 +2648,6 @@ void Actor::SetDefaultProperty( Property::Index index, const Property::Value& pr
       break;
     }
 
-    case Dali::Actor::Property::BATCH_PARENT:
-    {
-      bool value;
-
-      if( property.Get( value ) )
-      {
-        if( value != mIsBatchParent )
-        {
-          mIsBatchParent = value;
-          SetIsBatchParentMessage( GetEventThreadServices(), *mNode, mIsBatchParent );
-        }
-      }
-      break;
-    }
     default:
     {
       // this can happen in the case of a non-animatable default property so just do nothing
@@ -3155,12 +3139,6 @@ Property::Value Actor::GetDefaultProperty( Property::Index index ) const
       break;
     }
 
-    case Dali::Actor::Property::BATCH_PARENT:
-    {
-      value = mIsBatchParent;
-      break;
-    }
-
     default:
     {
       DALI_ASSERT_ALWAYS( false && "Actor Property index invalid" ); // should not come here
index d40bde1b51a71161e954cbb7a244f223f525c757..d38493b5532cc94f17a7361835a2e3acaafd3ce8 100644 (file)
@@ -1833,8 +1833,6 @@ private:
   static ActorContainer mNullChildren;  ///< Empty container (shared by all actors, returned by GetChildren() const)
   static unsigned int mActorCounter;    ///< A counter to track the actor instance creation
 
-  bool mIsBatchParent : 1;              ///< Flag indicating that the actor is a batch parent
-
 };
 
 } // namespace Internal
index 92016de44e3f766b9c65f3981057cad1ae16cd68..93d1ab4c610af1c73167250649d2dac242801688 100644 (file)
@@ -271,25 +271,25 @@ void ImageActor::ClearPixelArea()
 
 void ImageActor::SetStyle( Dali::ImageActor::Style style )
 {
-  DALI_LOG_WARNING( "SetStyle Deprecated. Only STYLE_QUAD supported.\n" );
+  DALI_LOG_WARNING( "SetStyle Deprecated. Only STYLE_QUAD supported." );
   mStyle = style;
 }
 
 Dali::ImageActor::Style ImageActor::GetStyle() const
 {
-  DALI_LOG_WARNING( "GetStyle Deprecated. Only STYLE_QUAD supported.\n" );
+  DALI_LOG_WARNING( "GetStyle Deprecated. Only STYLE_QUAD supported." );
   return mStyle;
 }
 
 void ImageActor::SetNinePatchBorder( const Vector4& border )
 {
-  DALI_LOG_WARNING( "SetNinePatchBorder Deprecated. Only STYLE_QUAD supported.\n" );
+  DALI_LOG_WARNING( "SetNinePatchBorder Deprecated. Only STYLE_QUAD supported." );
   mNinePatchBorder = border;
 }
 
 Vector4 ImageActor::GetNinePatchBorder() const
 {
-  DALI_LOG_WARNING( "GetNinePatchBorder Deprecated. Only STYLE_QUAD supported.\n" );
+  DALI_LOG_WARNING( "GetNinePatchBorder Deprecated. Only STYLE_QUAD supported." );
   return mNinePatchBorder;
 }
 
index c702014b43597e19b61f40dcd9028a590465e497..f78154390137b9f4d40dfc125d24e00f8fe932a5 100644 (file)
@@ -71,7 +71,7 @@ void ConstraintBase::AddSource( Source source )
     }
     else
     {
-      DALI_LOG_ERROR( "Constraint source object not found\n" );
+      DALI_LOG_ERROR( "Constraint source object not found" );
     }
   }
 }
index aea8308169473dc59b235f97ef36d3eb1987d2da..fe95c3e5ec88a97975bf1c98277d1b3d351f76f7 100644 (file)
@@ -412,7 +412,7 @@ void Stage::SetStereoBase( float stereoBase )
 {
   if( ! Equals( mStereoBase, stereoBase ) )
   {
-    DALI_LOG_INFO( Debug::Filter::gActor, Debug::Concise, "old( %.2f) new(%.2f)\n", mStereoBase, stereoBase );
+    DALI_LOG_INFO( Debug::Filter::gActor, Debug::Concise, "old( %.2f) new(%.2f)", mStereoBase, stereoBase );
     mStereoBase = stereoBase;
 
     switch( mViewMode  )
@@ -572,7 +572,7 @@ Dali::Stage::EventProcessingFinishedSignalType& Stage::EventProcessingFinishedSi
 
 Dali::Stage::TouchedSignalType& Stage::TouchedSignal()
 {
-  DALI_LOG_WARNING( "Deprecated. Use TouchSignal() instead.\n" );
+  DALI_LOG_WARNING( "Deprecated. Use TouchSignal() instead." );
   return mTouchedSignal;
 }
 
index 479f2e851c0f6998894cbe3e9c44194fbb534ecd..b0809a794004ec725795aae7ebdf9863d09c5358 100644 (file)
@@ -349,7 +349,7 @@ void TypeInfo::AddActionFunction( const std::string &actionName, Dali::TypeInfo:
     }
     else
     {
-      DALI_LOG_WARNING("Action already exists in TypeRegistry Type\n", actionName.c_str());
+      DALI_LOG_WARNING("Action already exists in TypeRegistry Type", actionName.c_str());
     }
   }
 }
@@ -371,7 +371,7 @@ void TypeInfo::AddConnectorFunction( const std::string& signalName, Dali::TypeIn
     }
     else
     {
-      DALI_LOG_WARNING("Signal name already exists in TypeRegistry Type for signal connector function\n", signalName.c_str());
+      DALI_LOG_WARNING("Signal name already exists in TypeRegistry Type for signal connector function", signalName.c_str());
     }
   }
 }
index 0b89b26a69d7d0cfa28c256d18d4195e8ff53513..0bd59c7c2689d9d2cb9e0034d04d17212258bf42 100644 (file)
@@ -19,7 +19,6 @@
 #include <dali/internal/event/rendering/renderer-impl.h> // Dali::Internal::Renderer
 
 // INTERNAL INCLUDES
-#include <dali/devel-api/scripting/scripting.h>
 #include <dali/public-api/object/type-registry.h>
 #include <dali/internal/event/common/object-impl-helper.h> // Dali::Internal::ObjectHelper
 #include <dali/internal/event/common/property-helper.h>    // DALI_PROPERTY_TABLE_BEGIN, DALI_PROPERTY, DALI_PROPERTY_TABLE_END
@@ -37,7 +36,7 @@ namespace
 {
 
 /**
- * Properties: |name                              |type     |writable|animatable|constraint-input|enum for index-checking|
+ *            |name                              |type     |writable|animatable|constraint-input|enum for index-checking|
  */
 DALI_PROPERTY_TABLE_BEGIN
 DALI_PROPERTY( "depthIndex",                      INTEGER,   true, false,  false, Dali::Renderer::Property::DEPTH_INDEX )
@@ -65,99 +64,8 @@ DALI_PROPERTY( "stencilOperationOnFail",          INTEGER,   true, false,  false
 DALI_PROPERTY( "stencilOperationOnZFail",         INTEGER,   true, false,  false, Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL )
 DALI_PROPERTY( "stencilOperationOnZPass",         INTEGER,   true, false,  false, Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS )
 DALI_PROPERTY( "writeToColorBuffer",              BOOLEAN,   true, false,  false, Dali::Renderer::Property::WRITE_TO_COLOR_BUFFER )
-DALI_PROPERTY( "batchingEnabled",                 BOOLEAN,   true, false,  false, Dali::Renderer::Property::BATCHING_ENABLED )
 DALI_PROPERTY_TABLE_END( DEFAULT_RENDERER_PROPERTY_START_INDEX )
 
-// Property string to enumeration tables:
-
-DALI_ENUM_TO_STRING_TABLE_BEGIN( FACE_CULLING_MODE )
-DALI_ENUM_TO_STRING_WITH_SCOPE( FaceCullingMode, NONE )
-DALI_ENUM_TO_STRING_WITH_SCOPE( FaceCullingMode, FRONT )
-DALI_ENUM_TO_STRING_WITH_SCOPE( FaceCullingMode, BACK )
-DALI_ENUM_TO_STRING_WITH_SCOPE( FaceCullingMode, FRONT_AND_BACK )
-DALI_ENUM_TO_STRING_TABLE_END( FACE_CULLING_MODE )
-
-DALI_ENUM_TO_STRING_TABLE_BEGIN( BLEND_MODE )
-DALI_ENUM_TO_STRING_WITH_SCOPE( BlendMode, OFF )
-DALI_ENUM_TO_STRING_WITH_SCOPE( BlendMode, AUTO )
-DALI_ENUM_TO_STRING_WITH_SCOPE( BlendMode, ON )
-DALI_ENUM_TO_STRING_TABLE_END( BLEND_MODE )
-
-DALI_ENUM_TO_STRING_TABLE_BEGIN( BLEND_EQUATION )
-DALI_ENUM_TO_STRING_WITH_SCOPE( BlendEquation, ADD )
-DALI_ENUM_TO_STRING_WITH_SCOPE( BlendEquation, SUBTRACT )
-DALI_ENUM_TO_STRING_WITH_SCOPE( BlendEquation, REVERSE_SUBTRACT )
-DALI_ENUM_TO_STRING_TABLE_END( BLEND_EQUATION )
-
-DALI_ENUM_TO_STRING_TABLE_BEGIN( BLEND_FACTOR )
-DALI_ENUM_TO_STRING_WITH_SCOPE( BlendFactor, ZERO )
-DALI_ENUM_TO_STRING_WITH_SCOPE( BlendFactor, ONE )
-DALI_ENUM_TO_STRING_WITH_SCOPE( BlendFactor, SRC_COLOR )
-DALI_ENUM_TO_STRING_WITH_SCOPE( BlendFactor, ONE_MINUS_SRC_COLOR )
-DALI_ENUM_TO_STRING_WITH_SCOPE( BlendFactor, SRC_ALPHA )
-DALI_ENUM_TO_STRING_WITH_SCOPE( BlendFactor, ONE_MINUS_SRC_ALPHA )
-DALI_ENUM_TO_STRING_WITH_SCOPE( BlendFactor, DST_ALPHA )
-DALI_ENUM_TO_STRING_WITH_SCOPE( BlendFactor, ONE_MINUS_DST_ALPHA )
-DALI_ENUM_TO_STRING_WITH_SCOPE( BlendFactor, DST_COLOR )
-DALI_ENUM_TO_STRING_WITH_SCOPE( BlendFactor, ONE_MINUS_DST_COLOR )
-DALI_ENUM_TO_STRING_WITH_SCOPE( BlendFactor, SRC_ALPHA_SATURATE )
-DALI_ENUM_TO_STRING_WITH_SCOPE( BlendFactor, CONSTANT_COLOR )
-DALI_ENUM_TO_STRING_WITH_SCOPE( BlendFactor, ONE_MINUS_CONSTANT_COLOR )
-DALI_ENUM_TO_STRING_WITH_SCOPE( BlendFactor, CONSTANT_ALPHA )
-DALI_ENUM_TO_STRING_WITH_SCOPE( BlendFactor, ONE_MINUS_CONSTANT_ALPHA )
-DALI_ENUM_TO_STRING_TABLE_END( BLEND_FACTOR )
-
-DALI_ENUM_TO_STRING_TABLE_BEGIN( DEPTH_WRITE_MODE )
-DALI_ENUM_TO_STRING_WITH_SCOPE( DepthWriteMode, OFF )
-DALI_ENUM_TO_STRING_WITH_SCOPE( DepthWriteMode, AUTO )
-DALI_ENUM_TO_STRING_WITH_SCOPE( DepthWriteMode, ON )
-DALI_ENUM_TO_STRING_TABLE_END( DEPTH_WRITE_MODE )
-
-DALI_ENUM_TO_STRING_TABLE_BEGIN( DEPTH_TEST_MODE )
-DALI_ENUM_TO_STRING_WITH_SCOPE( DepthTestMode, OFF )
-DALI_ENUM_TO_STRING_WITH_SCOPE( DepthTestMode, AUTO )
-DALI_ENUM_TO_STRING_WITH_SCOPE( DepthTestMode, ON )
-DALI_ENUM_TO_STRING_TABLE_END( DEPTH_TEST_MODE )
-
-DALI_ENUM_TO_STRING_TABLE_BEGIN( DEPTH_FUNCTION )
-DALI_ENUM_TO_STRING_WITH_SCOPE( DepthFunction, NEVER )
-DALI_ENUM_TO_STRING_WITH_SCOPE( DepthFunction, ALWAYS )
-DALI_ENUM_TO_STRING_WITH_SCOPE( DepthFunction, LESS )
-DALI_ENUM_TO_STRING_WITH_SCOPE( DepthFunction, GREATER )
-DALI_ENUM_TO_STRING_WITH_SCOPE( DepthFunction, EQUAL )
-DALI_ENUM_TO_STRING_WITH_SCOPE( DepthFunction, NOT_EQUAL )
-DALI_ENUM_TO_STRING_WITH_SCOPE( DepthFunction, LESS_EQUAL )
-DALI_ENUM_TO_STRING_WITH_SCOPE( DepthFunction, GREATER_EQUAL )
-DALI_ENUM_TO_STRING_TABLE_END( DEPTH_FUNCTION )
-
-DALI_ENUM_TO_STRING_TABLE_BEGIN( STENCIL_FUNCTION )
-DALI_ENUM_TO_STRING_WITH_SCOPE( StencilFunction, NEVER )
-DALI_ENUM_TO_STRING_WITH_SCOPE( StencilFunction, LESS )
-DALI_ENUM_TO_STRING_WITH_SCOPE( StencilFunction, EQUAL )
-DALI_ENUM_TO_STRING_WITH_SCOPE( StencilFunction, LESS_EQUAL )
-DALI_ENUM_TO_STRING_WITH_SCOPE( StencilFunction, GREATER )
-DALI_ENUM_TO_STRING_WITH_SCOPE( StencilFunction, NOT_EQUAL )
-DALI_ENUM_TO_STRING_WITH_SCOPE( StencilFunction, GREATER_EQUAL )
-DALI_ENUM_TO_STRING_WITH_SCOPE( StencilFunction, ALWAYS )
-DALI_ENUM_TO_STRING_TABLE_END( STENCIL_FUNCTION )
-
-DALI_ENUM_TO_STRING_TABLE_BEGIN( STENCIL_MODE )
-DALI_ENUM_TO_STRING_WITH_SCOPE( StencilMode, OFF )
-DALI_ENUM_TO_STRING_WITH_SCOPE( StencilMode, AUTO )
-DALI_ENUM_TO_STRING_WITH_SCOPE( StencilMode, ON )
-DALI_ENUM_TO_STRING_TABLE_END( STENCIL_MODE )
-
-DALI_ENUM_TO_STRING_TABLE_BEGIN( STENCIL_OPERATION )
-DALI_ENUM_TO_STRING_WITH_SCOPE( StencilOperation, ZERO )
-DALI_ENUM_TO_STRING_WITH_SCOPE( StencilOperation, KEEP )
-DALI_ENUM_TO_STRING_WITH_SCOPE( StencilOperation, REPLACE )
-DALI_ENUM_TO_STRING_WITH_SCOPE( StencilOperation, INCREMENT )
-DALI_ENUM_TO_STRING_WITH_SCOPE( StencilOperation, DECREMENT )
-DALI_ENUM_TO_STRING_WITH_SCOPE( StencilOperation, INVERT )
-DALI_ENUM_TO_STRING_WITH_SCOPE( StencilOperation, INCREMENT_WRAP )
-DALI_ENUM_TO_STRING_WITH_SCOPE( StencilOperation, DECREMENT_WRAP )
-DALI_ENUM_TO_STRING_TABLE_END( STENCIL_OPERATION )
-
 const ObjectImplHelper<DEFAULT_PROPERTY_COUNT> RENDERER_IMPL = { DEFAULT_PROPERTY_DETAILS };
 
 BaseHandle Create()
@@ -227,6 +135,21 @@ int Renderer::GetDepthIndex() const
   return mDepthIndex;
 }
 
+void Renderer::SetFaceCullingMode( FaceCullingMode::Type cullingMode )
+{
+  if( mFaceCullingMode != cullingMode )
+  {
+    mFaceCullingMode = cullingMode;
+
+    SetFaceCullingModeMessage( GetEventThreadServices(), *mSceneObject, mFaceCullingMode );
+  }
+}
+
+FaceCullingMode::Type Renderer::GetFaceCullingMode()
+{
+  return mFaceCullingMode;
+}
+
 void Renderer::SetBlendMode( BlendMode::Type mode )
 {
   if( mBlendMode != mode )
@@ -348,11 +271,6 @@ bool Renderer::IsPreMultipliedAlphaEnabled() const
   return mPremultipledAlphaEnabled;
 }
 
-bool Renderer::IsBatchingEnabled() const
-{
-  return mBatchingEnabled;
-}
-
 SceneGraph::Renderer* Renderer::GetRendererSceneObject()
 {
   return mSceneObject;
@@ -410,88 +328,109 @@ void Renderer::SetDefaultProperty( Property::Index index,
     }
     case Dali::Renderer::Property::FACE_CULLING_MODE:
     {
-      FaceCullingMode::Type convertedValue = mFaceCullingMode;
-      if( Scripting::GetEnumerationProperty< FaceCullingMode::Type >( propertyValue, FACE_CULLING_MODE_TABLE, FACE_CULLING_MODE_TABLE_COUNT, convertedValue ) )
+      int faceCullingMode;
+      if( propertyValue.Get( faceCullingMode ) )
       {
-        mFaceCullingMode = convertedValue;
-        SetFaceCullingModeMessage( GetEventThreadServices(), *mSceneObject, convertedValue );
+        SetFaceCullingMode( FaceCullingMode::Type( faceCullingMode ) );
       }
       break;
     }
     case Dali::Renderer::Property::BLEND_MODE:
     {
-      BlendMode::Type convertedValue = mBlendMode;
-      if( Scripting::GetEnumerationProperty< BlendMode::Type >( propertyValue, BLEND_MODE_TABLE, BLEND_MODE_TABLE_COUNT, convertedValue ) )
+      int blendingMode;
+      if( propertyValue.Get( blendingMode ) )
       {
-        SetBlendMode( convertedValue );
+        SetBlendMode( BlendMode::Type( blendingMode ) );
       }
       break;
     }
     case Dali::Renderer::Property::BLEND_EQUATION_RGB:
     {
-      BlendEquation::Type convertedValue = mBlendingOptions.GetBlendEquationRgb();
-
-      if( Scripting::GetEnumerationProperty< BlendEquation::Type >( propertyValue, BLEND_EQUATION_TABLE, BLEND_EQUATION_TABLE_COUNT, convertedValue ) )
+      int blendingEquation;
+      if( propertyValue.Get( blendingEquation ) )
       {
         BlendEquation::Type alphaEquation = mBlendingOptions.GetBlendEquationAlpha();
-        mBlendingOptions.SetBlendEquation( convertedValue, alphaEquation );
+        mBlendingOptions.SetBlendEquation( static_cast<BlendEquation::Type>( blendingEquation ), alphaEquation );
         SetBlendingOptionsMessage( GetEventThreadServices(), *mSceneObject, mBlendingOptions.GetBitmask() );
       }
       break;
     }
     case Dali::Renderer::Property::BLEND_EQUATION_ALPHA:
     {
-      BlendEquation::Type convertedValue = mBlendingOptions.GetBlendEquationAlpha();
-
-      if( Scripting::GetEnumerationProperty< BlendEquation::Type >( propertyValue, BLEND_EQUATION_TABLE, BLEND_EQUATION_TABLE_COUNT, convertedValue ) )
+      int blendingEquation;
+      if( propertyValue.Get( blendingEquation ) )
       {
         BlendEquation::Type rgbEquation = mBlendingOptions.GetBlendEquationRgb();
-        mBlendingOptions.SetBlendEquation( rgbEquation, convertedValue );
+        mBlendingOptions.SetBlendEquation( rgbEquation, static_cast<BlendEquation::Type>( blendingEquation ) );
         SetBlendingOptionsMessage( GetEventThreadServices(), *mSceneObject, mBlendingOptions.GetBitmask() );
       }
       break;
     }
     case Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB:
     {
-      BlendFactor::Type sourceFactorRgb, destinationFactorRgb, sourceFactorAlpha, destinationFactorAlpha;
-      GetBlendFunc( sourceFactorRgb, destinationFactorRgb, sourceFactorAlpha, destinationFactorAlpha );
-
-      if( Scripting::GetEnumerationProperty< BlendFactor::Type >( propertyValue, BLEND_FACTOR_TABLE, BLEND_FACTOR_TABLE_COUNT, sourceFactorRgb ) )
+      int blendingFactor;
+      if( propertyValue.Get( blendingFactor ) )
       {
-        SetBlendFunc( sourceFactorRgb, destinationFactorRgb, sourceFactorAlpha, destinationFactorAlpha );
+        BlendFactor::Type srcFactorRgb;
+        BlendFactor::Type destFactorRgb;
+        BlendFactor::Type srcFactorAlpha;
+        BlendFactor::Type destFactorAlpha;
+        GetBlendFunc( srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha );
+        SetBlendFunc( static_cast<BlendFactor::Type>( blendingFactor ),
+            destFactorRgb,
+            srcFactorAlpha,
+            destFactorAlpha );
       }
       break;
     }
     case Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB:
     {
-      BlendFactor::Type sourceFactorRgb, destinationFactorRgb, sourceFactorAlpha, destinationFactorAlpha;
-      GetBlendFunc( sourceFactorRgb, destinationFactorRgb, sourceFactorAlpha, destinationFactorAlpha );
-
-      if( Scripting::GetEnumerationProperty< BlendFactor::Type >( propertyValue, BLEND_FACTOR_TABLE, BLEND_FACTOR_TABLE_COUNT, destinationFactorRgb ) )
+      int blendingFactor;
+      if( propertyValue.Get( blendingFactor ) )
       {
-        SetBlendFunc( sourceFactorRgb, destinationFactorRgb, sourceFactorAlpha, destinationFactorAlpha );
+        BlendFactor::Type srcFactorRgb;
+        BlendFactor::Type destFactorRgb;
+        BlendFactor::Type srcFactorAlpha;
+        BlendFactor::Type destFactorAlpha;
+        GetBlendFunc( srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha );
+        SetBlendFunc( srcFactorRgb,
+            static_cast<BlendFactor::Type>( blendingFactor ),
+            srcFactorAlpha,
+            destFactorAlpha );
       }
       break;
     }
     case Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA:
     {
-      BlendFactor::Type sourceFactorRgb, destinationFactorRgb, sourceFactorAlpha, destinationFactorAlpha;
-      GetBlendFunc( sourceFactorRgb, destinationFactorRgb, sourceFactorAlpha, destinationFactorAlpha );
-
-      if( Scripting::GetEnumerationProperty< BlendFactor::Type >( propertyValue, BLEND_FACTOR_TABLE, BLEND_FACTOR_TABLE_COUNT, sourceFactorAlpha ) )
+      int blendingFactor;
+      if( propertyValue.Get( blendingFactor ) )
       {
-        SetBlendFunc( sourceFactorRgb, destinationFactorRgb, sourceFactorAlpha, destinationFactorAlpha );
+        BlendFactor::Type srcFactorRgb;
+        BlendFactor::Type destFactorRgb;
+        BlendFactor::Type srcFactorAlpha;
+        BlendFactor::Type destFactorAlpha;
+        GetBlendFunc( srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha );
+        SetBlendFunc( srcFactorRgb,
+            destFactorRgb,
+            static_cast<BlendFactor::Type>( blendingFactor ),
+            destFactorAlpha );
       }
       break;
     }
     case Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA:
     {
-      BlendFactor::Type sourceFactorRgb, destinationFactorRgb, sourceFactorAlpha, destinationFactorAlpha;
-      GetBlendFunc( sourceFactorRgb, destinationFactorRgb, sourceFactorAlpha, destinationFactorAlpha );
-
-      if( Scripting::GetEnumerationProperty< BlendFactor::Type >( propertyValue, BLEND_FACTOR_TABLE, BLEND_FACTOR_TABLE_COUNT, destinationFactorAlpha ) )
+      int blendingFactor;
+      if( propertyValue.Get( blendingFactor ) )
       {
-        SetBlendFunc( sourceFactorRgb, destinationFactorRgb, sourceFactorAlpha, destinationFactorAlpha );
+        BlendFactor::Type srcFactorRgb;
+        BlendFactor::Type destFactorRgb;
+        BlendFactor::Type srcFactorAlpha;
+        BlendFactor::Type destFactorAlpha;
+        GetBlendFunc( srcFactorRgb, destFactorRgb, srcFactorAlpha, destFactorAlpha );
+        SetBlendFunc( srcFactorRgb,
+            destFactorRgb,
+            srcFactorAlpha,
+            static_cast<BlendFactor::Type>( blendingFactor ) );
       }
       break;
     }
@@ -533,51 +472,61 @@ void Renderer::SetDefaultProperty( Property::Index index,
     }
     case Dali::Renderer::Property::DEPTH_WRITE_MODE:
     {
-      DepthWriteMode::Type convertedValue = mDepthWriteMode;
-      if( Scripting::GetEnumerationProperty< DepthWriteMode::Type >( propertyValue, DEPTH_WRITE_MODE_TABLE, DEPTH_WRITE_MODE_TABLE_COUNT, convertedValue ) )
+      int value;
+      propertyValue.Get( value );
+      DepthWriteMode::Type mode = static_cast<DepthWriteMode::Type>(value);
+      if( mode != mDepthWriteMode )
       {
-        mDepthWriteMode = convertedValue;
-        SetDepthWriteModeMessage( GetEventThreadServices(), *mSceneObject, convertedValue );
+        mDepthWriteMode = mode;
+        SetDepthWriteModeMessage( GetEventThreadServices(), *mSceneObject, mode );
       }
       break;
     }
     case Dali::Renderer::Property::DEPTH_FUNCTION:
     {
-      DepthFunction::Type convertedValue = mDepthFunction;
-      if( Scripting::GetEnumerationProperty< DepthFunction::Type >( propertyValue, DEPTH_FUNCTION_TABLE, DEPTH_FUNCTION_TABLE_COUNT, convertedValue ) )
+      int value;
+      propertyValue.Get( value );
+      DepthFunction::Type depthFunction = static_cast<DepthFunction::Type>(value);
+      if( depthFunction != mDepthFunction )
       {
-        mDepthFunction = convertedValue;
-        SetDepthFunctionMessage( GetEventThreadServices(), *mSceneObject, convertedValue );
+        mDepthFunction = depthFunction;
+        SetDepthFunctionMessage( GetEventThreadServices(), *mSceneObject, depthFunction );
       }
       break;
     }
     case Dali::Renderer::Property::DEPTH_TEST_MODE:
     {
-      DepthTestMode::Type convertedValue = mDepthTestMode;
-      if( Scripting::GetEnumerationProperty< DepthTestMode::Type >( propertyValue, DEPTH_TEST_MODE_TABLE, DEPTH_TEST_MODE_TABLE_COUNT, convertedValue ) )
+      int value;
+      propertyValue.Get( value );
+      DepthTestMode::Type mode = static_cast<DepthTestMode::Type>(value);
+      if( mode != mDepthTestMode )
       {
-        mDepthTestMode = convertedValue;
-        SetDepthTestModeMessage( GetEventThreadServices(), *mSceneObject, convertedValue );
+        mDepthTestMode = mode;
+        SetDepthTestModeMessage( GetEventThreadServices(), *mSceneObject, mode );
       }
       break;
     }
     case Dali::Renderer::Property::STENCIL_MODE:
     {
-      StencilMode::Type convertedValue = mStencilParameters.stencilMode;
-      if( Scripting::GetEnumerationProperty< StencilMode::Type >( propertyValue, STENCIL_MODE_TABLE, STENCIL_MODE_TABLE_COUNT, convertedValue ) )
+      int value;
+      propertyValue.Get( value );
+      StencilMode::Type stencilMode = static_cast<StencilMode::Type>( value );
+      if( stencilMode != mStencilParameters.stencilMode )
       {
-        mStencilParameters.stencilMode = convertedValue;
-        SetStencilModeMessage( GetEventThreadServices(), *mSceneObject, convertedValue );
+        mStencilParameters.stencilMode = stencilMode;
+        SetStencilModeMessage( GetEventThreadServices(), *mSceneObject, stencilMode );
       }
       break;
     }
     case Dali::Renderer::Property::STENCIL_FUNCTION:
     {
-      StencilFunction::Type convertedValue = mStencilParameters.stencilFunction;
-      if( Scripting::GetEnumerationProperty< StencilFunction::Type >( propertyValue, STENCIL_FUNCTION_TABLE, STENCIL_FUNCTION_TABLE_COUNT, convertedValue ) )
+      int value;
+      propertyValue.Get( value );
+      StencilFunction::Type stencilFunction = static_cast<StencilFunction::Type>( value );
+      if( stencilFunction != mStencilParameters.stencilFunction )
       {
-        mStencilParameters.stencilFunction = convertedValue;
-        SetStencilFunctionMessage( GetEventThreadServices(), *mSceneObject, convertedValue );
+        mStencilParameters.stencilFunction = stencilFunction;
+        SetStencilFunctionMessage( GetEventThreadServices(), *mSceneObject, stencilFunction );
       }
       break;
     }
@@ -622,31 +571,37 @@ void Renderer::SetDefaultProperty( Property::Index index,
     }
     case Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL:
     {
-      StencilOperation::Type convertedValue = mStencilParameters.stencilOperationOnFail;
-      if( Scripting::GetEnumerationProperty< StencilOperation::Type >( propertyValue, STENCIL_OPERATION_TABLE, STENCIL_OPERATION_TABLE_COUNT, convertedValue ) )
+      int value;
+      propertyValue.Get( value );
+      StencilOperation::Type stencilOperation = static_cast<StencilOperation::Type>( value );
+      if( stencilOperation != mStencilParameters.stencilOperationOnFail )
       {
-        mStencilParameters.stencilOperationOnFail = convertedValue;
-        SetStencilOperationOnFailMessage( GetEventThreadServices(), *mSceneObject, convertedValue );
+        mStencilParameters.stencilOperationOnFail = stencilOperation;
+        SetStencilOperationOnFailMessage( GetEventThreadServices(), *mSceneObject, stencilOperation );
       }
       break;
     }
     case Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL:
     {
-      StencilOperation::Type convertedValue = mStencilParameters.stencilOperationOnZFail;
-      if( Scripting::GetEnumerationProperty< StencilOperation::Type >( propertyValue, STENCIL_OPERATION_TABLE, STENCIL_OPERATION_TABLE_COUNT, convertedValue ) )
+      int value;
+      propertyValue.Get( value );
+      StencilOperation::Type stencilOperation = static_cast<StencilOperation::Type>( value );
+      if( stencilOperation != mStencilParameters.stencilOperationOnZFail )
       {
-        mStencilParameters.stencilOperationOnZFail = convertedValue;
-        SetStencilOperationOnZFailMessage( GetEventThreadServices(), *mSceneObject, convertedValue );
+        mStencilParameters.stencilOperationOnZFail = stencilOperation;
+        SetStencilOperationOnZFailMessage( GetEventThreadServices(), *mSceneObject, stencilOperation );
       }
       break;
     }
     case Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS:
     {
-      StencilOperation::Type convertedValue = mStencilParameters.stencilOperationOnZPass;
-      if( Scripting::GetEnumerationProperty< StencilOperation::Type >( propertyValue, STENCIL_OPERATION_TABLE, STENCIL_OPERATION_TABLE_COUNT, convertedValue ) )
+      int value;
+      propertyValue.Get( value );
+      StencilOperation::Type stencilOperation = static_cast<StencilOperation::Type>( value );
+      if( stencilOperation != mStencilParameters.stencilOperationOnZPass )
       {
-        mStencilParameters.stencilOperationOnZPass = convertedValue;
-        SetStencilOperationOnZPassMessage( GetEventThreadServices(), *mSceneObject, convertedValue );
+        mStencilParameters.stencilOperationOnZPass = stencilOperation;
+        SetStencilOperationOnZPassMessage( GetEventThreadServices(), *mSceneObject, stencilOperation );
       }
       break;
     }
@@ -663,19 +618,6 @@ void Renderer::SetDefaultProperty( Property::Index index,
       }
       break;
     }
-    case Dali::Renderer::Property::BATCHING_ENABLED:
-    {
-      bool enabled;
-      if( propertyValue.Get( enabled ) )
-      {
-        if( mBatchingEnabled != enabled )
-        {
-          mBatchingEnabled = enabled;
-          SetBatchingEnabledMessage( GetEventThreadServices(), *mSceneObject, mBatchingEnabled );
-        }
-      }
-      break;
-    }
   }
 }
 
@@ -789,11 +731,6 @@ Property::Value Renderer::GetDefaultProperty( Property::Index index ) const
       value = mDepthWriteMode;
       break;
     }
-    case Dali::Renderer::Property::BATCHING_ENABLED:
-    {
-      value = mBatchingEnabled;
-      break;
-    }
     case Dali::Renderer::Property::DEPTH_FUNCTION:
     {
       value = mDepthFunction;
@@ -940,8 +877,7 @@ Renderer::Renderer()
   mDepthWriteMode( DepthWriteMode::AUTO ),
   mDepthTestMode( DepthTestMode::AUTO ),
   mWriteToColorBuffer( true ),
-  mPremultipledAlphaEnabled( false ),
-  mBatchingEnabled( false )
+  mPremultipledAlphaEnabled( false )
 {
 }
 
index 14a2b7975fb4e7639dce4e08f5d428db50ea2f03..64d99ba657424bd789686d90592f56dc24721c37 100644 (file)
@@ -95,6 +95,16 @@ public:
    */
   int GetDepthIndex() const;
 
+  /**
+    * @copydoc Dali::Renderer::SetFaceCullingMode()
+    */
+   void SetFaceCullingMode( FaceCullingMode::Type cullingMode );
+
+   /**
+    * @copydoc Dali::Renderer::GetFaceCullingMode()
+    */
+   FaceCullingMode::Type GetFaceCullingMode();
+
    /**
     * @copydoc Dali::Renderer::SetBlendMode()
     */
@@ -171,18 +181,12 @@ public:
     */
    bool IsPreMultipliedAlphaEnabled() const;
 
-   /**
-    * Returns state of batching mode
-    * @return batching mode state ( true if enabled )
-    */
-   bool IsBatchingEnabled() const;
-
-   /**
-    * @brief Get the scene graph object
-    *
-    * @return the scene object
-    */
-   SceneGraph::Renderer* GetRendererSceneObject();
+  /**
+   * @brief Get the scene graph object
+   *
+   * @return the scene object
+   */
+  SceneGraph::Renderer* GetRendererSceneObject();
 
 public: // Default property extensions from Object
 
@@ -320,7 +324,6 @@ private: // data
   DepthTestMode::Type          mDepthTestMode:2;              ///< Local copy of the depth test mode
   bool                         mWriteToColorBuffer:1;         ///< Local copy of the write to color buffer flag
   bool                         mPremultipledAlphaEnabled:1;   ///< Flag indicating whether the Pre-multiplied Alpha Blending is required
-  bool                         mBatchingEnabled : 1;          ///< Flag indicating whether render is batchable or not
 };
 
 } // namespace Internal
index c0f658c9717358df7f10818524694504dff993fc..704ab4015128e23e010a2213dab6498452e84671 100644 (file)
@@ -108,14 +108,14 @@ bool NewTexture::Upload( PixelDataPtr pixelData,
   {
     if( mNativeImage )
     {
-      DALI_LOG_ERROR( "OpenGL ES does not support uploading data to native texture\n");
+      DALI_LOG_ERROR( "OpenGL ES does not support uploading data to native texture");
     }
     else
     {
       unsigned int pixelDataSize = pixelData->GetWidth()*pixelData->GetHeight();
       if( pixelData->GetBuffer() == NULL || pixelDataSize == 0 )
       {
-        DALI_LOG_ERROR( "PixelData is empty\n");
+        DALI_LOG_ERROR( "PixelData is empty");
       }
       else
       {
@@ -124,12 +124,12 @@ bool NewTexture::Upload( PixelDataPtr pixelData,
         {
           if( pixelDataSize < width * height )
           {
-            DALI_LOG_ERROR( "PixelData of an incorrect size when trying to update texture\n");
+            DALI_LOG_ERROR( "PixelData of an incorrect size when trying to update texture");
           }
           else if( ( xOffset + width  > ( mWidth  / (1<<mipmap) ) ) ||
               ( yOffset + height > ( mHeight / (1<<mipmap) ) ) )
           {
-            DALI_LOG_ERROR( "Texture update area out of bounds\n");
+            DALI_LOG_ERROR( "Texture update area out of bounds");
           }
           else
           {
@@ -141,7 +141,7 @@ bool NewTexture::Upload( PixelDataPtr pixelData,
         }
         else
         {
-          DALI_LOG_ERROR( "Bad format\n");
+          DALI_LOG_ERROR( "Bad format");
         }
       }
     }
index 110eeceff53278ae6bf56faa070f70b4c0ec1bbc..0c10ea24c83d75627384c09ccf483d5bf938ce93 100644 (file)
@@ -40,7 +40,7 @@ void TextureSet::SetImage( size_t index, ImagePtr image )
 {
   if( !mNewTextures.empty() )
   {
-    DALI_LOG_ERROR( "Error: Cannot mix images and textures in the same TextureSet\n");
+    DALI_LOG_ERROR( "Error: Cannot mix images and textures in the same TextureSet");
     return;
   }
 
@@ -83,7 +83,7 @@ void TextureSet::SetTexture( size_t index, NewTexturePtr texture )
 {
   if( !mImages.empty() )
   {
-    DALI_LOG_ERROR( "Error: Cannot mix images and textures in the same texture set\n");
+    DALI_LOG_ERROR( "Error: Cannot mix images and textures in the same texture set");
     return;
   }
 
@@ -119,7 +119,7 @@ Image* TextureSet::GetImage( size_t index ) const
   }
   else
   {
-    DALI_LOG_ERROR( "Error: Invalid index to TextureSet::GetImage\n");
+    DALI_LOG_ERROR( "Error: Invalid index to TextureSet::GetImage");
   }
 
   return result;
@@ -134,7 +134,7 @@ NewTexture* TextureSet::GetTexture( size_t index ) const
   }
   else
   {
-    DALI_LOG_ERROR( "Error: Invalid index to TextureSet::GetTexture\n");
+    DALI_LOG_ERROR( "Error: Invalid index to TextureSet::GetTexture");
   }
 
   return result;
@@ -176,7 +176,7 @@ Sampler* TextureSet::GetSampler( size_t index ) const
   }
   else
   {
-    DALI_LOG_ERROR( "Error: Invalid index to TextureSet::GetSampler\n");
+    DALI_LOG_ERROR( "Error: Invalid index to TextureSet::GetSampler");
   }
 
   return result;
index fe163c6571a73fc27cd66934d5a530a501f4edef..a2400e3573b90c1b03fe11ca5754a30e60820341 100644 (file)
@@ -50,7 +50,7 @@ Archive::~Archive()
 {
   if(!mChunkStack.empty())
   {
-    DALI_LOG_ERROR("mChunkStack should be empty!\n");
+    DALI_LOG_ERROR("mChunkStack should be empty!");
   }
 }
 
index 2a0e2cdf44e8dcd8239f5d4a8c55d072ed6cc004..c0f7bf01df6910cc2aa70a2dc1d0a26e3105195d 100644 (file)
@@ -153,7 +153,7 @@ ResourceTicketPtr ResourceClient::DecodeResource(
       case ResourceNativeImage:
       case ResourceTargetImage:
       {
-        DALI_LOG_ERROR( "Unsupported resource type passed for decoding from a memory buffer.\n" );
+        DALI_LOG_ERROR( "Unsupported resource type passed for decoding from a memory buffer." );
       }
     }
 
index e90d723de32ae13a96f3b315ecd700ff8cb07796..92a2e1f5eeb737dadf7ac28665e783e19767bdf2 100644 (file)
@@ -147,7 +147,6 @@ internal_src_files = \
   $(internal_src_dir)/update/gestures/scene-graph-pan-gesture.cpp \
   $(internal_src_dir)/update/queue/update-message-queue.cpp \
   $(internal_src_dir)/update/manager/prepare-render-instructions.cpp \
-  $(internal_src_dir)/update/manager/geometry-batcher.cpp \
   $(internal_src_dir)/update/manager/process-render-tasks.cpp \
   $(internal_src_dir)/update/manager/transform-manager.cpp \
   $(internal_src_dir)/update/manager/update-algorithms.cpp \
index 02353f3d72533b109fb0f041b49367ffd6af9212..95c0caeeb3bcd0b06495e2fc9bad8ff0461800aa 100644 (file)
 #include <dali/internal/render/gl-resources/context.h>
 #include <dali/internal/render/renderers/render-renderer.h>
 #include <dali/internal/update/nodes/scene-graph-layer.h>
-#include <dali/internal/update/manager/geometry-batcher.h>
 
 using Dali::Internal::SceneGraph::RenderItem;
 using Dali::Internal::SceneGraph::RenderList;
 using Dali::Internal::SceneGraph::RenderListContainer;
 using Dali::Internal::SceneGraph::RenderInstruction;
-using Dali::Internal::SceneGraph::GeometryBatcher;
 
 namespace Dali
 {
@@ -217,7 +215,6 @@ inline void SetupDepthBuffer( const RenderItem& item, Context& context, bool isL
  * @param[in] buffer The current render buffer index (previous update buffer)
  * @param[in] viewMatrix The view matrix from the appropriate camera.
  * @param[in] projectionMatrix The projection matrix from the appropriate camera.
- * @param[in] geometryBatcher The instance of the geometry batcher
  */
 inline void ProcessRenderList(
   const RenderList& renderList,
@@ -226,8 +223,7 @@ inline void ProcessRenderList(
   SceneGraph::Shader& defaultShader,
   BufferIndex bufferIndex,
   const Matrix& viewMatrix,
-  const Matrix& projectionMatrix,
-  GeometryBatcher* geometryBatcher )
+  const Matrix& projectionMatrix )
 {
   DALI_PRINT_RENDER_LIST( renderList );
 
@@ -245,34 +241,14 @@ inline void ProcessRenderList(
   if( DALI_LIKELY( !renderList.HasColorRenderItems() || !depthTestEnabled ) )
   {
     size_t count = renderList.Count();
-    bool skip( false );
     for ( size_t index = 0; index < count; ++index )
     {
       const RenderItem& item = renderList.GetItem( index );
       DALI_PRINT_RENDER_ITEM( item );
 
       SetupPerRendererFlags( item, context, usedStencilBuffer, stencilManagedByDrawMode );
-
-      // Check if the node has a valid batch index value ( set previously by
-      // GeometryBatcher ). If so, then it queries the geometry object for this particular batch.
-      // If not, it still checks if the batch parent is set as it is possible, batching may
-      // fail ( for example if vertex format or buffers are not set ). In that case we need
-      // to skip rendering, otherwise unwanted GPU buffers will get uploaded. This is very rare case.
-      uint32_t batchIndex = item.mNode->mBatchIndex;
-      if( batchIndex != BATCH_NULL_HANDLE )
-      {
-        item.mBatchRenderGeometry = geometryBatcher->GetGeometry( batchIndex );
-      }
-      else
-      {
-        skip = item.mNode->GetBatchParent();
-        item.mBatchRenderGeometry = NULL;
-      }
-      if( !skip )
-      {
-        item.mRenderer->Render( context, textureCache, bufferIndex, *item.mNode, defaultShader,
-                              item.mModelMatrix, item.mModelViewMatrix, viewMatrix, projectionMatrix, item.mSize, item.mBatchRenderGeometry, !item.mIsOpaque );
-      }
+      item.mRenderer->Render( context, textureCache, bufferIndex, *item.mNode, defaultShader,
+                              item.mModelMatrix, item.mModelViewMatrix, viewMatrix, projectionMatrix, item.mSize, !item.mIsOpaque );
     }
   }
   else
@@ -288,7 +264,7 @@ inline void ProcessRenderList(
       SetupPerRendererFlags( item, context, usedStencilBuffer, stencilManagedByDrawMode );
 
       item.mRenderer->Render( context, textureCache, bufferIndex, *item.mNode, defaultShader,
-                              item.mModelMatrix, item.mModelViewMatrix, viewMatrix, projectionMatrix, item.mSize, item.mBatchRenderGeometry, !item.mIsOpaque );
+                              item.mModelMatrix, item.mModelViewMatrix, viewMatrix, projectionMatrix, item.mSize, !item.mIsOpaque );
     }
   }
 }
@@ -297,7 +273,6 @@ void ProcessRenderInstruction( const RenderInstruction& instruction,
                                Context& context,
                                SceneGraph::TextureCache& textureCache,
                                SceneGraph::Shader& defaultShader,
-                               GeometryBatcher& geometryBatcher,
                                BufferIndex bufferIndex )
 {
   DALI_PRINT_RENDER_INSTRUCTION( instruction, bufferIndex );
@@ -322,7 +297,7 @@ void ProcessRenderInstruction( const RenderInstruction& instruction,
       if(  renderList &&
           !renderList->IsEmpty() )
       {
-        ProcessRenderList( *renderList, context, textureCache, defaultShader, bufferIndex, *viewMatrix, *projectionMatrix, &geometryBatcher );
+        ProcessRenderList( *renderList, context, textureCache, defaultShader, bufferIndex, *viewMatrix, *projectionMatrix );
       }
     }
   }
index 1bf2dd0e0ec861bdd8f6f9d06d662d00877b0b33..a2e4c578ba9795c6399403d8376c22eb7d505a1a 100644 (file)
@@ -32,7 +32,6 @@ namespace SceneGraph
 class RenderInstruction;
 class Shader;
 class TextureCache;
-class GeometryBatcher;
 }
 
 namespace Render
@@ -44,14 +43,12 @@ namespace Render
  * @param[in] context The GL context.
  * @param[in] textureCache The texture cache used to get textures.
  * @param[in] defaultShader The default shader.
- * @param[in] geometryBatcher The instace of geometry batcher.
  * @param[in] bufferIndex The current render buffer index (previous update buffer)
  */
 void ProcessRenderInstruction( const SceneGraph::RenderInstruction& instruction,
                                Context& context,
                                SceneGraph::TextureCache& textureCache,
                                SceneGraph::Shader& defaultShader,
-                               SceneGraph::GeometryBatcher& geometryBatcher,
                                BufferIndex bufferIndex );
 
 } // namespace Render
index d7fd016eb7a12ac59f744d387ec11ec7545f6c5a..d81f068382c0b112d93b75c7d7f50e321f92849e 100644 (file)
@@ -47,10 +47,8 @@ RenderItem::RenderItem()
   mSize(),
   mRenderer( NULL ),
   mNode( NULL ),
-  mBatchRenderGeometry( NULL ),
   mDepthIndex( 0 ),
-  mIsOpaque( true ),
-  mBatched( false )
+  mIsOpaque( true )
 {
 }
 
index bd37bdafea7954ab8a599b5b7f27756edbc1b488..d429452c826491071a262708db868974013a2c24 100644 (file)
@@ -33,7 +33,6 @@ namespace Internal
 namespace Render
 {
 class Renderer;
-class RenderGeometry;
 }
 
 namespace SceneGraph
@@ -60,18 +59,14 @@ struct RenderItem
    */
   void operator delete( void* ptr );
 
+
   Matrix            mModelMatrix;
   Matrix            mModelViewMatrix;
   Vector3           mSize;
   Render::Renderer* mRenderer;
   Node*             mNode;
-
-  mutable Render::Geometry* mBatchRenderGeometry;
-
   int               mDepthIndex;
   bool              mIsOpaque:1;
-  bool              mBatched:1;
-
 
 private:
 
index 497b0e511656c91e46895a40505aef1d352b7310..a4281eb397c9f76bfca2fc812500979a6afa2576 100644 (file)
@@ -81,8 +81,7 @@ struct RenderManager::Impl
   Impl( Integration::GlAbstraction& glAbstraction,
         Integration::GlSyncAbstraction& glSyncAbstraction,
         LockedResourceQueue& textureUploadedQ,
-        TextureUploadedDispatcher& postProcessDispatcher,
-        GeometryBatcher& geometryBatcher )
+        TextureUploadedDispatcher& postProcessDispatcher )
   : context( glAbstraction ),
     glSyncAbstraction( glSyncAbstraction ),
     renderQueue(),
@@ -100,8 +99,7 @@ struct RenderManager::Impl
     renderersAdded( false ),
     firstRenderCompleted( false ),
     defaultShader( NULL ),
-    programController( glAbstraction ),
-    geometryBatcher( geometryBatcher )
+    programController( glAbstraction )
   {
   }
 
@@ -170,17 +168,14 @@ struct RenderManager::Impl
   bool                          firstRenderCompleted;     ///< False until the first render is done
   Shader*                       defaultShader;            ///< Default shader to use
   ProgramController             programController;        ///< Owner of the GL programs
-
-  SceneGraph::GeometryBatcher&  geometryBatcher;          ///< Instance of geometry batcher
 };
 
 RenderManager* RenderManager::New( Integration::GlAbstraction& glAbstraction,
                                    Integration::GlSyncAbstraction& glSyncAbstraction,
-                                   SceneGraph::GeometryBatcher& geometryBatcher,
                                    LockedResourceQueue& textureUploadedQ )
 {
   RenderManager* manager = new RenderManager;
-  manager->mImpl = new Impl( glAbstraction, glSyncAbstraction, textureUploadedQ, *manager, geometryBatcher );
+  manager->mImpl = new Impl( glAbstraction, glSyncAbstraction, textureUploadedQ, *manager );
   return manager;
 }
 
@@ -690,7 +685,6 @@ void RenderManager::DoRender( RenderInstruction& instruction, Shader& defaultSha
                                     mImpl->context,
                                     mImpl->textureCache,
                                     defaultShader,
-                                    mImpl->geometryBatcher,
                                     mImpl->renderBufferIndex );
 
   if(instruction.mOffscreenTextureId != 0)
index 40cc7c1a359115bec3d3f0e64156ed4a30a24c34..93b9661d8a232e6d92fe9c8b688c8e73513088cf 100644 (file)
@@ -63,7 +63,6 @@ class RenderInstruction;
 class RenderInstructionContainer;
 class Shader;
 class PropertyBufferDataProvider;
-class GeometryBatcher;
 
 /**
  * RenderManager is responsible for rendering the result of the previous "update", which
@@ -77,12 +76,10 @@ public:
    * Construct a new RenderManager.
    * @param[in]  glAbstraction The GL abstraction used for rendering.
    * @param[in]  glSyncAbstraction The GL sync abstraction used fence sync creation/deletion.
-   * @param[in]  geometryBatcher The geometry batcher instance
-   * @param[out] resourcePostProcessQueue A queue for sending rendered texture ids to the update-thread.*
+   * @param[out] resourcePostProcessQueue A queue for sending rendered texture ids to the update-thread.
    */
   static RenderManager* New( Integration::GlAbstraction& glAbstraction,
                              Integration::GlSyncAbstraction& glSyncAbstraction,
-                             SceneGraph::GeometryBatcher& geometryBatcher,
                              LockedResourceQueue& resourcePostProcessQueue );
 
   /**
index 58d80c265b67dd7655aad55ffe1edc033e4fbf73..19061e7718261f24577826835d187930ac6490be 100644 (file)
@@ -189,7 +189,7 @@ void BitmapTexture::Update( Integration::Bitmap* bitmap )
   DALI_ASSERT_DEBUG( bitmap != 0 );
   if( !bitmap )
   {
-    DALI_LOG_ERROR( "Passed a null bitmap to update this bitmap texture.\n" );
+    DALI_LOG_ERROR( "Passed a null bitmap to update this bitmap texture." );
     return;
   }
 
@@ -199,7 +199,7 @@ void BitmapTexture::Update( Integration::Bitmap* bitmap )
   if( !bitmapPackedPixels )
   {
     ///! This should never happen.
-    DALI_LOG_ERROR("Passed an incompatible bitmap type to update this bitmap texture.\n");
+    DALI_LOG_ERROR("Passed an incompatible bitmap type to update this bitmap texture.");
     return;
   }
   mBitmap = bitmap;
index 3ec72dbcd6831c9ab0e0292a59a99dd1d77d7db9..7a23adb4a8af947b6cbf6ee6490cbd02161e5e85 100644 (file)
@@ -101,7 +101,7 @@ void CompressedBitmapTexture::Update( Integration::Bitmap* bitmap )
 
   if( !bitmap )
   {
-    DALI_LOG_ERROR( "Passed a null bitmap to update this compressed bitmap texture.\n" );
+    DALI_LOG_ERROR( "Passed a null bitmap to update this compressed bitmap texture." );
     return;
   }
 
index e1c697ebe1da7f9ebb778cce7e50d8b83ab3fdaf..9d0259af749cb08b99aa3163b188e48ef91af3b6 100644 (file)
@@ -136,7 +136,7 @@ bool FrameBufferTexture::CreateGlTexture()
   if( mNativeImage &&
       !mNativeImage->GlExtensionCreate() )
   {
-    DALI_LOG_ERROR( "Error creating native image!\n" );
+    DALI_LOG_ERROR( "Error creating native image!" );
     return false;
   }
 
index 8110880d31176a0a8bb13a5f45df58dada69c197..43a5db14a35ca84611b650386d8386e8342e0888 100644 (file)
@@ -104,7 +104,7 @@ bool NativeTexture::CreateGlTexture()
   }
   else
   {
-    DALI_LOG_ERROR( "Error creating native image!\n" );
+    DALI_LOG_ERROR( "Error creating native image!" );
   }
 
   return mId != 0;
index 0c3bd0a1bac0ca42b728b61a796278db904d5a29..803b6eb0723530ae2c5ea3353890f0ed2f73f13e 100644 (file)
@@ -50,7 +50,7 @@ void Geometry::GlContextDestroyed()
 {
 }
 
-void Geometry::AddPropertyBuffer( Render::PropertyBuffer* propertyBuffer)
+void Geometry::AddPropertyBuffer( Render::PropertyBuffer* propertyBuffer )
 {
   mVertexBuffers.PushBack( propertyBuffer );
   mAttributesChanged = true;
@@ -62,11 +62,6 @@ void Geometry::SetIndexBuffer( Dali::Vector<unsigned short>& indices )
   mIndicesChanged = true;
 }
 
-const Dali::Vector<unsigned short>* Geometry::GetIndexBuffer() const
-{
-  return &mIndices;
-}
-
 void Geometry::RemovePropertyBuffer( const Render::PropertyBuffer* propertyBuffer )
 {
   size_t bufferCount = mVertexBuffers.Size();
@@ -75,22 +70,13 @@ void Geometry::RemovePropertyBuffer( const Render::PropertyBuffer* propertyBuffe
     if( propertyBuffer == mVertexBuffers[i] )
     {
       //This will delete the gpu buffer associated to the RenderPropertyBuffer if there is one
-      mVertexBuffers.Remove( mVertexBuffers.Begin()+i );
+      mVertexBuffers.Remove( mVertexBuffers.Begin()+i);
       mAttributesChanged = true;
       break;
     }
   }
 }
 
-const Render::PropertyBuffer* Geometry::GetPropertyBuffer( size_t index ) const
-{
-  if( index < mVertexBuffers.Size() )
-  {
-    return mVertexBuffers[ index ];
-  }
-  return NULL;
-}
-
 void Geometry::GetAttributeLocationFromProgram( Vector<GLint>& attributeLocation, Program& program, BufferIndex bufferIndex ) const
 {
   attributeLocation.Clear();
@@ -150,10 +136,8 @@ void Geometry::UploadAndDraw(
       mIndicesChanged = false;
     }
 
-    size_t count = mVertexBuffers.Count();
-    for( unsigned int i = 0; i < count; ++i )
+    for( unsigned int i = 0; i < mVertexBuffers.Count(); ++i )
     {
-
       if( !mVertexBuffers[i]->Update( context ) )
       {
         //Vertex buffer is not ready ( Size, data or format has not been specified yet )
index 60758588dceb57dd69393aee055d24c7adf58927..205e0f1bd5b9ebabf484d7a8825ee59ff589ecea 100644 (file)
@@ -77,25 +77,12 @@ public:
    */
   void SetIndexBuffer( Dali::Vector<unsigned short>& indices );
 
-  /**
-   * Obtains pointer to the storage of indexed elements
-   * @return Pointer to the index buffer
-   */
-  const Dali::Vector<unsigned short>* GetIndexBuffer() const;
-
   /**
    * Removes a PropertyBuffer from the geometry
    * @param[in] propertyBuffer The property buffer to be removed
    */
   void RemovePropertyBuffer(  const Render::PropertyBuffer* propertyBuffer );
 
-  /**
-   * Returns property buffer at specified index
-   * @param[in] index of the property buffer
-   * @return pointer to the property buffer or NULL
-   */
-  const Render::PropertyBuffer* GetPropertyBuffer( size_t index ) const;
-
   /**
    * Gets the attribute locations on the shader for the attributes defined in the geometry RenderBuffers
    * @param[out] attributeLocation The vector where the attributes locations will be stored
@@ -155,6 +142,7 @@ private:
   bool mIndicesChanged : 1;
   bool mHasBeenUpdated : 1;
   bool mAttributesChanged : 1;
+
 };
 
 } // namespace Render
index 9664318d759070ee7248012f2e42ded95e870c74..6be4623c0e4ca7aec6fdf7b7584d6bbb5d530b59 100644 (file)
@@ -125,11 +125,6 @@ void PropertyBuffer::SetData( Dali::Vector<char>* data, size_t size )
   mDataChanged = true;
 }
 
-void PropertyBuffer::UpdateData()
-{
-  mDataChanged = true;
-}
-
 bool PropertyBuffer::Update( Context& context )
 {
   if( !mData || !mFormat || !mSize )
index 47748a145bb19ad8faca2b35a2bfdf821ec517ff..ed1e0b21c6547a801847fe596ff22c21017a3218 100644 (file)
@@ -79,12 +79,6 @@ public:
    */
   void SetData( Dali::Vector<char>* data, size_t size );
 
-  /**
-   * @brief Sets flag to update data in the buffer when next PropertyBuffer::Update()
-   * is called.
-   */
-  void UpdateData();
-
   /**
    * @brief Set the number of elements
    * @param[in] size The number of elements
@@ -162,39 +156,14 @@ public:
     return mSize;
   }
 
-  /**
-   * Retrieve reference to the data storage vector
-   * @return Reference to the data storage
-   */
-  inline const Dali::Vector< char >& GetData() const
-  {
-    return *mData.Get();
-  }
-
-  /**
-   * Retrieve data writeable pointer ( direct access to the buffer data )
-   * @return Pointer to data converted to requested type
-   */
-  template <typename T>
-  inline T* GetDataTypedPtr()
-  {
-    Dali::Vector< char >* data = mData.Release();
-    mData = data;
-    return reinterpret_cast<T*>( &data->operator[]( 0 ) );
-  }
-
-  inline const PropertyBuffer::Format* GetFormat() const
-  {
-    return mFormat.Get();
-  }
-
 private:
-  OwnerPointer< PropertyBuffer::Format >  mFormat;    ///< Format of the buffer
-  OwnerPointer< Dali::Vector< char > >    mData;      ///< Data
-  OwnerPointer< GpuBuffer >               mGpuBuffer; ///< Pointer to the GpuBuffer associated with this RenderPropertyBuffer
+  OwnerPointer< PropertyBuffer::Format >  mFormat;  ///< Format of the buffer
+  OwnerPointer< Dali::Vector< char > >    mData;    ///< Data
+  OwnerPointer< GpuBuffer > mGpuBuffer;               ///< Pointer to the GpuBuffer associated with this RenderPropertyBuffer
 
   size_t mSize;       ///< Number of Elements in the buffer
   bool mDataChanged;  ///< Flag to know if data has changed in a frame
+
 };
 
 } // namespace Render
index cfaa2be394773786ce7579f48b2552fb0ca61790..01c03e391ed916570c567c788574e870ae490e42 100644 (file)
@@ -154,8 +154,7 @@ Renderer::Renderer( SceneGraph::RenderDataProvider* dataProvider,
   mDepthTestMode( depthTestMode ),
   mWriteToColorBuffer( writeToColorBuffer ),
   mUpdateAttributesLocation( true ),
-  mPremultipledAlphaEnabled( preMultipliedAlphaEnabled ),
-  mBatchingEnabled( false )
+  mPremultipledAlphaEnabled( preMultipliedAlphaEnabled )
 {
   if(  blendingBitmask != 0u )
   {
@@ -573,11 +572,6 @@ bool Renderer::GetWriteToColorBuffer() const
   return mWriteToColorBuffer;
 }
 
-void Renderer::SetBatchingEnabled( bool batchingEnabled )
-{
-  mBatchingEnabled = batchingEnabled;
-}
-
 void Renderer::Render( Context& context,
                        SceneGraph::TextureCache& textureCache,
                        BufferIndex bufferIndex,
@@ -588,7 +582,6 @@ void Renderer::Render( Context& context,
                        const Matrix& viewMatrix,
                        const Matrix& projectionMatrix,
                        const Vector3& size,
-                       Render::Geometry* externalGeometry,
                        bool blend )
 {
   // Get the program to use:
@@ -600,7 +593,7 @@ void Renderer::Render( Context& context,
     DALI_ASSERT_DEBUG( program && "Default shader should always have a program available." );
     if( !program )
     {
-      DALI_LOG_ERROR( "Failed to get program for shader at address %p.\n", (void*)&mRenderDataProvider->GetShader() );
+      DALI_LOG_ERROR( "Failed to get program for shader at address %p.", (void*)&mRenderDataProvider->GetShader() );
       return;
     }
   }
@@ -637,15 +630,14 @@ void Renderer::Render( Context& context,
     }
 
     SetUniforms( bufferIndex, node, size, *program );
-    Render::Geometry* geometry = externalGeometry ? externalGeometry : mGeometry;
 
-    if( mUpdateAttributesLocation || geometry->AttributesChanged() )
+    if( mUpdateAttributesLocation || mGeometry->AttributesChanged() )
     {
-      geometry->GetAttributeLocationFromProgram( mAttributesLocation, *program, bufferIndex );
+      mGeometry->GetAttributeLocationFromProgram( mAttributesLocation, *program, bufferIndex );
       mUpdateAttributesLocation = false;
     }
 
-    geometry->UploadAndDraw( context, bufferIndex, mAttributesLocation, mIndexedDrawFirstElement, mIndexedDrawElementsCount );
+    mGeometry->UploadAndDraw( context, bufferIndex, mAttributesLocation, mIndexedDrawFirstElement, mIndexedDrawElementsCount );
   }
 }
 
index 8011c312337412bf8460aa00c26940cb07933d85..d7e657512bb61faa208a7837d491ab7f4f9afd0b 100644 (file)
@@ -166,22 +166,12 @@ public:
    * @param[in] geometry The new geometry
    */
   void SetGeometry( Render::Geometry* geometry );
-
-  /**
-   * Retrieves the geometry used by the renderer
-   * @return The geometry used by the renderer
-   */
-  Render::Geometry* GetGeometry() const
-  {
-    return mGeometry;
-  }
-
   /**
    * Second-phase construction.
    * This is called when the renderer is inside render thread
-   * @param[in] context Context used by the renderer
-   * @param[in] textureCache The texture cache to use
-   * @param[in] uniformNameCache Cache of uniform names to use
+   * @param[in] context to use
+   * @param[in] textureCache to use
+   * @param[in] uniformNameCache to use
    */
   void Initialize( Context& context, SceneGraph::TextureCache& textureCache, Render::UniformNameCache& uniformNameCache );
 
@@ -371,12 +361,6 @@ public:
    */
   bool GetWriteToColorBuffer() const;
 
-  /**
-   * Sets batching mode on the renderer
-   * @param[in] batchingEnabled batching state
-   */
-  void SetBatchingEnabled( bool batchingEnabled );
-
   /**
    * Called to render during RenderManager::Render().
    * @param[in] context The context used for rendering
@@ -387,9 +371,6 @@ public:
    * @param[in] modelViewMatrix The model-view matrix.
    * @param[in] viewMatrix The view matrix.
    * @param[in] projectionMatrix The projection matrix.
-   * @param[in] size Size of the render item
-   * @param[in] externalGeometry Optional external geometry, if set the original geometry is ignored. If NULL, original geometry will be drawn as normal.
-   * @param[in] blend If true, blending is enabled
    */
   void Render( Context& context,
                SceneGraph::TextureCache& textureCache,
@@ -401,7 +382,6 @@ public:
                const Matrix& viewMatrix,
                const Matrix& projectionMatrix,
                const Vector3& size,
-               Render::Geometry* externalGeometry,
                bool blend);
 
   /**
@@ -488,7 +468,6 @@ private:
   bool                         mWriteToColorBuffer:1;       ///< True if we are writing to the color buffer
   bool                         mUpdateAttributesLocation:1; ///< Indicates attribute locations have changed
   bool                         mPremultipledAlphaEnabled:1; ///< Flag indicating whether the Pre-multiplied Alpha Blending is required
-  bool mBatchingEnabled:1;                ///< Flag indicating if the renderer is batchable
 };
 
 } // namespace SceneGraph
index 8ca26470376ddf94362076e1fbb60c6cdac2141a..59c1206c9e0a0f3470de0413c6abbe768e80a071 100644 (file)
@@ -625,11 +625,6 @@ void NewTexture::Destroy( Context& context )
   if( mId )
   {
     context.DeleteTextures( 1, &mId );
-
-    if( mNativeImage )
-    {
-      mNativeImage->GlExtensionDestroy();
-    }
   }
 }
 
@@ -650,12 +645,7 @@ void NewTexture::Initialize(Context& context)
       context.TexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_WRAP_DEFAULT );
 
       // platform specific implementation decides on what GL extension to use
-      if( mNativeImage->TargetTexture() != 0u )
-      {
-        context.DeleteTextures( 1, &mId );
-        mNativeImage->GlExtensionDestroy();
-        mId = 0u;
-      }
+      mNativeImage->TargetTexture();
     }
   }
   else
@@ -813,12 +803,6 @@ bool NewTexture::Bind( Context& context, unsigned int textureUnit, Render::Sampl
 
     ApplySampler( context, sampler );
 
-    if( mNativeImage )
-    {
-      //Allow implementation specific operations after binding the texture
-      mNativeImage->PrepareTexture();
-    }
-
     return true;
   }
 
index e89c964a45ac712251f2ad4fa736ffcf1bf70eb2..e0114b4bed71f0183a6c494828834df9830a6ba4 100644 (file)
@@ -26,7 +26,6 @@
 #include <dali/internal/render/renderers/render-renderer.h>
 #include <dali/internal/render/shaders/scene-graph-shader.h>
 #include <dali/internal/update/render-tasks/scene-graph-camera.h>
-#include <dali/internal/update/manager/geometry-batcher.h>
 
 namespace Dali
 {
@@ -53,21 +52,14 @@ void DiscardQueue::Add( BufferIndex updateBufferIndex, Node* node )
   // 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
-  mNodeQueue[ updateBufferIndex ].PushBack( node );
-
-  // If batching, then mark corresponding batch to be destroyed too
-  if( node->GetIsBatchParent() )
+  if ( 0u == updateBufferIndex )
   {
-    mGeometryBatcher->RemoveBatchParent( node );
+    mNodeQueue0.PushBack( node );
   }
-  else if( node->GetBatchParent() )
+  else
   {
-    if( node->mBatchIndex != BATCH_NULL_HANDLE )
-    {
-      mGeometryBatcher->RemoveNode( node );
-    }
+    mNodeQueue1.PushBack( node );
   }
-
 }
 
 void DiscardQueue::Add( BufferIndex updateBufferIndex, Shader* shader )
@@ -79,7 +71,14 @@ void DiscardQueue::Add( BufferIndex updateBufferIndex, Shader* shader )
   // 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
-  mShaderQueue[ updateBufferIndex ].PushBack( shader );
+  if ( 0u == updateBufferIndex )
+  {
+    mShaderQueue0.PushBack( shader );
+  }
+  else
+  {
+    mShaderQueue1.PushBack( shader );
+  }
 }
 
 void DiscardQueue::Add( BufferIndex updateBufferIndex, Renderer* renderer )
@@ -89,28 +88,48 @@ void DiscardQueue::Add( BufferIndex updateBufferIndex, Renderer* renderer )
   // 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
-  mRendererQueue[ updateBufferIndex ].PushBack( renderer );
+  if ( 0u == updateBufferIndex )
+  {
+    mRendererQueue0.PushBack( renderer );
+  }
+  else
+  {
+    mRendererQueue1.PushBack( renderer );
+  }
 }
 
 void DiscardQueue::Add( BufferIndex updateBufferIndex, Camera* camera )
 {
   DALI_ASSERT_DEBUG( NULL != camera );
 
-  mCameraQueue[ updateBufferIndex ].PushBack( camera );
+  if ( 0u == updateBufferIndex )
+  {
+    mCameraQueue0.PushBack( camera );
+  }
+  else
+  {
+    mCameraQueue1.PushBack( camera );
+  }
 }
 
 void DiscardQueue::Clear( BufferIndex updateBufferIndex )
 {
   // Destroy some discarded objects; these should no longer own any GL resources
-  mNodeQueue[ updateBufferIndex ].Clear();
-  mShaderQueue[ updateBufferIndex ].Clear();
-  mRendererQueue[ updateBufferIndex ].Clear();
-  mCameraQueue[ updateBufferIndex ].Clear();
-}
 
-void DiscardQueue::SetGeometryBatcher( GeometryBatcher* geometryBatcher )
-{
-  mGeometryBatcher = geometryBatcher;
+  if ( 0u == updateBufferIndex )
+  {
+    mNodeQueue0.Clear();
+    mShaderQueue0.Clear();
+    mRendererQueue0.Clear();
+    mCameraQueue0.Clear();
+  }
+  else
+  {
+    mNodeQueue1.Clear();
+    mShaderQueue1.Clear();
+    mRendererQueue1.Clear();
+    mCameraQueue1.Clear();
+  }
 }
 
 } // namespace SceneGraph
index 899d85668fe274af0354f7187c63a0539965328e..a8a35ef67c4b2cd54229757b2273cd7e16f4f5e7 100644 (file)
@@ -35,7 +35,6 @@ namespace Internal
 namespace SceneGraph
 {
 
-class GeometryBatcher;
 class RenderQueue;
 class Shader;
 class Camera;
@@ -108,12 +107,6 @@ public:
    */
   void Clear( BufferIndex updateBufferIndex );
 
-  /**
-   * Sets pointer to the GeometryBatcher instance
-   * @param[in] geometryBatcher Instance of the GeometryBatcher
-   */
-  void SetGeometryBatcher( GeometryBatcher* geometryBatcher );
-
 private:
 
   // Undefined
@@ -126,14 +119,17 @@ private:
 
   RenderQueue& mRenderQueue; ///< Used to send GL clean-up messages for the next Render.
 
-  // Messages are queued here following the current update buffer number
-  NodeOwnerContainer           mNodeQueue[2];
-  ShaderQueue                  mShaderQueue[2];
-  RendererQueue                mRendererQueue[2];
-  CameraQueue                  mCameraQueue[2];
-
-
-  GeometryBatcher*             mGeometryBatcher; ///< Geometry batcher needed to clean up batches upon node deletion
+  // Messages are queued here when the update buffer index == 0
+  NodeOwnerContainer           mNodeQueue0;
+  ShaderQueue                  mShaderQueue0;
+  RendererQueue                mRendererQueue0;
+  CameraQueue                  mCameraQueue0;
+
+  // Messages are queued here when the update buffer index == 1
+  NodeOwnerContainer           mNodeQueue1;
+  ShaderQueue                  mShaderQueue1;
+  RendererQueue                mRendererQueue1;
+  CameraQueue                  mCameraQueue1;
 };
 
 } // namespace SceneGraph
diff --git a/dali/internal/update/manager/geometry-batcher.cpp b/dali/internal/update/manager/geometry-batcher.cpp
deleted file mode 100644 (file)
index 58a9dbb..0000000
+++ /dev/null
@@ -1,581 +0,0 @@
-/*
- * Copyright (c) 2016 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 <dali/internal/update/manager/geometry-batcher.h>
-
-// INTERNAL INCLUDES
-#include <dali/internal/render/common/render-item.h>
-#include <dali/internal/render/common/render-tracker.h>
-#include <dali/internal/render/common/render-instruction.h>
-#include <dali/internal/render/common/render-instruction-container.h>
-#include <dali/internal/render/shaders/scene-graph-shader.h>
-#include <dali/internal/render/renderers/render-renderer.h>
-#include <dali/internal/render/renderers/render-property-buffer.h>
-#include <dali/internal/render/renderers/render-geometry.h>
-#include <dali/internal/update/rendering/scene-graph-renderer.h>
-#include <dali/internal/update/controllers/scene-controller.h>
-#include <dali/internal/update/manager/update-manager.h>
-#include <dali/internal/common/math.h>
-
-namespace
-{
-
-// helper macros to deal with handles
-#define BATCH_LOCAL_INDEX(x) (x&0xFFFF)
-#define BATCH_PARENT_INDEX(x) ((x>>16)&0xFFFF)
-#define BATCH_INDEX_CREATE( batchParentIndex, batchIndex ) ( ( ( (batchParentIndex)&0xFFFF ) << 16 ) | ( (batchIndex)&0xFFFF ) )
-
-/**
- * The TransformVertexBufferInfo struct
- * Must be filled before transforming vertices
- */
-struct TransformVertexBufferData
-{
-  void*                         destinationPtr;       ///< pointer to the destination vertex buffer
-  const void*                   sourcePtr;            ///< pointer to the source vertex buffer
-  float*                        transform;            ///< transform relative to batch parent
-  const float*                  worldMatrix;          ///< model/world matrix of node being batched
-  const float*                  parentInvWorldMatrix; ///< inv world matrix of batch parent
-  unsigned                      componentSize;        ///< size of component
-  unsigned                      vertexCount;          ///< number of vertices to process
-  const float*                  size;                 ///< size of render item
-};
-
-/**
- * @brief function transforms vertices from 'source' and writes into 'destination'
- * @param[in,out] data Filled TransformVertexBufferInfo arguments structure
- */
-template <typename PositionType >
-void TransformVertexBuffer( TransformVertexBufferData& data )
-{
-  const PositionType* source = reinterpret_cast<const PositionType*>( data.sourcePtr );
-  PositionType* destination = reinterpret_cast<PositionType*>( data.destinationPtr );
-
-  size_t componentSize = data.componentSize ? data.componentSize : sizeof( PositionType );
-  const void* sourceEnd = (reinterpret_cast<const char*>( source ) + ( data.vertexCount*componentSize ));
-  for( ; source < sourceEnd;
-       *(reinterpret_cast<char**>( &destination )) += componentSize,
-       *(reinterpret_cast<const char**>( &source )) += componentSize
-       )
-  {
-    Dali::Internal::MultiplyVectorBySize( *destination, *source, data.size );
-    Dali::Internal::MultiplyVectorByMatrix4( *destination, data.transform, *destination );
-  }
-}
-
-} //Unnamed namespace
-
-namespace Dali
-{
-
-namespace Internal
-{
-
-namespace SceneGraph
-{
-
-/**
- * @brief The VertexDescriptor struct
- * Holds details of vertex format used for batching
- */
-struct VertexDescriptor
-{
-  VertexDescriptor()
-    : mVertexComponentSize( 0 ),
-      mVertexPositionType( Dali::Property::NONE ),
-      mVertexFormat( NULL )
-  {
-  }
-
-  unsigned int mVertexComponentSize; ///< Vertex component size in bytes
-  Dali::Property::Type mVertexPositionType;  ///< Vertex position type ( may be Vector2, Vector3, Vector4 )
-  Dali::Internal::Render::PropertyBuffer::Format* mVertexFormat; ///< Vertex format cloned from the very first batched item
-};
-
-struct BatchKey
-{
-  BatchKey()
-  : batchParentNode( NULL ),
-    shader( NULL ),
-    textureSet( NULL ),
-    depthIndex( 0 )
-  {
-  }
-
-  ~BatchKey()
-  {
-  }
-
-  BatchKey( Node* node )
-  {
-    MakeFromNode( node );
-  }
-
-  inline void MakeFromNode( Node* node )
-  {
-    Renderer* renderer = node->GetRendererAt( 0 );
-    batchParentNode = node->GetBatchParent();
-    shader = &renderer->GetShader();
-    textureSet = renderer->GetTextures();
-    depthIndex = renderer->GetDepthIndex();
-  }
-
-  inline bool operator==( const BatchKey& key )
-  {
-    return batchParentNode == key.batchParentNode && shader == key.shader && textureSet == key.textureSet && depthIndex == key.depthIndex;
-  }
-
-  inline bool operator!=( const BatchKey& key )
-  {
-    return !( *this == key );
-  }
-
-  const Node*           batchParentNode;    /// batch parent node that owns batch
-  const Shader*         shader;             /// shader associated with the batch
-  const TextureSet*     textureSet;         /// texture set used by the batch
-  int                   depthIndex;         /// depth index of the batch
-};
-
-/**
- * @brief The Batch struct
- * Stores details of single batch
- */
-struct Batch
-{
-  Batch( const BatchKey& key, Render::Geometry* batchGeometry = NULL )
-   : batchKey( key ),
-     geometry( batchGeometry ),
-     renderedFrame( 0 ),
-     dirty( true )
-  {}
-
-
-  BatchKey                batchKey;       /// Unique batch key
-  Vector<unsigned short>  indices;        /// index buffer per batch
-  Render::Geometry*       geometry;       /// Batch geometry
-  size_t                  renderedFrame;  /// Flag used to determine if batch has already rendered during a frame
-  bool                    dirty;          /// 'dirty' flag per batch
-};
-
-typedef std::vector<Batch> BatchList;
-
-/**
- * @brief The BatchParent struct
- * Stores list of children of single batch parent
- */
-struct BatchParent
-{
-  Node*                   node;             /// Pointer to a node which is a parent for batch(es)
-  Vector<Node*>           batchedChildren;  /// List of batchable children
-  BatchList               batches;          /// List of batches which belong to this parent
-  Render::PropertyBuffer* vertexBuffer;     /// Vertex buffer shared by all batches for this parent
-  bool                    needsUpdate;      /// Flag indicating if batches should be updated
-};
-
-struct Impl
-{
-  Impl() :
-    currentFrame( 0 )
-  {}
-
-  int GetBatchKeyIndex( size_t batchParentIndex, const BatchKey& key )
-  {
-    BatchParent& batchParent = batchParents[ batchParentIndex ];
-    for( size_t j = 0; j < batchParent.batches.size(); ++j )
-    {
-      if( batchParent.batches[j].batchKey == key )
-      {
-        return BATCH_INDEX_CREATE( batchParentIndex, j );
-      }
-    }
-    return -1;
-  }
-
-  std::vector<BatchParent>          batchParents; /// non-trivial type, hence std::vector
-  UpdateManager*                    updateManager;
-  size_t                            currentFrame;
-};
-
-GeometryBatcher::GeometryBatcher() :
-  mImpl( NULL )
-{
-  mImpl = new Impl();
-}
-
-void GeometryBatcher::SetUpdateManager( UpdateManager* updateManager )
-{
-  mImpl->updateManager = updateManager;
-}
-
-GeometryBatcher::~GeometryBatcher()
-{
-  delete mImpl;
-}
-
-bool GeometryBatcher::CloneVertexFormat( const Render::Geometry* sourceGeometry, VertexDescriptor& vertexDescriptor )
-{
-  const Render::Geometry* geometry = sourceGeometry;
-  const Render::PropertyBuffer::Format* format = geometry->GetPropertyBuffer( 0 )->GetFormat();
-
-  if( !format )
-  {
-    return false;
-  }
-
-  Render::PropertyBuffer::Format* clonedVertexFormat = new Render::PropertyBuffer::Format( *format );
-  Render::PropertyBuffer::Component& firstComponent = clonedVertexFormat->components[0];
-
-  vertexDescriptor.mVertexPositionType = firstComponent.type;
-  vertexDescriptor.mVertexComponentSize = clonedVertexFormat->size;
-  vertexDescriptor.mVertexFormat = clonedVertexFormat;
-
-  return true;
-}
-
-void GeometryBatcher::Update( BufferIndex bufferIndex )
-{
-  if( !mImpl->batchParents.empty() )
-  {
-    std::vector<BatchParent>::iterator iter = mImpl->batchParents.begin();
-    std::vector<BatchParent>::iterator end = mImpl->batchParents.end();
-
-    // for each Batch Parent
-    for( size_t batchParentIndex = 0; iter != end; ++iter, ++batchParentIndex )
-    {
-      BatchParent& batchParentData = *iter;
-      // Skip update if batch parent doesn't need it
-      if( !batchParentData.needsUpdate )
-      {
-        continue;
-      }
-
-      Node* batchParentNode = batchParentData.node;
-
-      // Skip if batch parent doesn't have batched children
-      size_t size = batchParentData.batchedChildren.Size();
-      if( !size )
-      {
-        batchParentData.needsUpdate = false;
-        continue;
-      }
-
-      bool batchingFailed( false );
-      uint32_t batchKeyIndex( BATCH_NULL_HANDLE );
-
-      BatchKey oldKey;
-      BatchKey key;
-      VertexDescriptor vertexDescriptor;
-
-      // Destination vertex buffer per batch parent
-      Vector<char>& vertexBufferDest = *( new Vector<char>() );
-      Render::PropertyBuffer* batchVertexBuffer = new Render::PropertyBuffer();
-
-      size_t currentElementIndex = 0;
-
-      Matrix invWorldMatrix( batchParentNode->GetWorldMatrix( bufferIndex ) );
-      invWorldMatrix.Invert();
-
-      // For each batched child of this batch parent...
-      for( size_t i = 0; i < size; ++i )
-      {
-        Node* node = batchParentData.batchedChildren[i];
-
-        const SceneGraph::Renderer* renderer = node->GetRendererAt( 0 );
-
-        // Geometry
-        const Render::Geometry* geometry = &renderer->GetGeometry();
-
-        // Generate batch key
-        key.MakeFromNode( node );
-
-        // format of first property buffer
-        const Render::PropertyBuffer* vertexBuffer = geometry->GetPropertyBuffer( 0 );
-
-        // Geometry of the node may not be ready, in that case we discard whole batch
-        if( !vertexBuffer || ( !vertexDescriptor.mVertexFormat && !CloneVertexFormat( geometry, vertexDescriptor ) ) )
-        {
-          batchingFailed = true;
-          break;
-        }
-
-        // Instantiate new batch
-        if( oldKey != key )
-        {
-          oldKey = key;
-          batchKeyIndex = mImpl->GetBatchKeyIndex( batchParentIndex, key );
-
-          if( batchKeyIndex == BATCH_NULL_HANDLE )
-          {
-            // Create new batch geometry
-            Render::Geometry* newGeometry = new Render::Geometry();
-
-            Batch batch( key, newGeometry );
-
-            // push new batch
-            batchParentData.batches.push_back( batch );
-
-            // rebuild handle
-            batchKeyIndex = BATCH_INDEX_CREATE( batchParentIndex, batchParentData.batches.size()-1 );
-
-            // Vertex buffer may be set before it's filled with data
-            newGeometry->AddPropertyBuffer( batchVertexBuffer );
-
-            // Register geometry with update manager
-            mImpl->updateManager->AddGeometry( newGeometry );
-          }
-        }
-
-        // Tell node which batch it belongs to
-        node->mBatchIndex = batchKeyIndex;
-
-        uint32_t localIndex = BATCH_LOCAL_INDEX( batchKeyIndex );
-
-        if( !batchParentData.batches[ localIndex ].dirty )
-        {
-          continue;
-        }
-
-        const uint32_t vertexBufferSize = vertexBuffer->GetDataSize();
-        const char* vertexDataSource = &vertexBuffer->GetData()[ 0 ];
-
-        uint32_t currentSize = vertexBufferDest.Size();
-        vertexBufferDest.Resize( currentSize + vertexBufferSize );
-        char* vertexDataDest = &vertexBufferDest[ currentSize ];
-
-        // copy data as they are
-        std::copy( vertexDataSource, vertexDataSource + vertexBufferSize, vertexDataDest );
-
-        // transform node
-        const Matrix& worldMatrix = node->GetWorldMatrix( bufferIndex );
-
-        // vertex count
-        const unsigned int sourceVertexCount = vertexBufferSize / vertexDescriptor.mVertexComponentSize;
-
-        // compute transform for the node
-        TransformVertexBufferData transformParameters;
-        transformParameters.destinationPtr = vertexDataDest;
-        transformParameters.sourcePtr = vertexDataSource;
-
-        // perform transformation
-        Matrix transformMatrix;
-        Dali::Internal::MultiplyMatrices( transformMatrix.AsFloat(), worldMatrix.AsFloat(), invWorldMatrix.AsFloat() );
-        transformParameters.transform = transformMatrix.AsFloat();
-        transformParameters.componentSize = vertexDescriptor.mVertexComponentSize;
-        transformParameters.vertexCount = sourceVertexCount;
-        transformParameters.size = node->GetSize( bufferIndex ).AsFloat();
-
-        // Perform vertex transform based on the vertex format
-        switch( vertexDescriptor.mVertexPositionType )
-        {
-          case Dali::Property::VECTOR2:
-          {
-            TransformVertexBuffer<Vec2>( transformParameters );
-            break;
-          }
-          case Dali::Property::VECTOR3:
-          {
-            TransformVertexBuffer<Vec3>( transformParameters );
-            break;
-          }
-          case Dali::Property::VECTOR4:
-          {
-            TransformVertexBuffer<Vec4>( transformParameters );
-            break;
-          }
-          default:
-          {
-            DALI_ASSERT_ALWAYS( true && "Incorrect vertex format! Use Vector2, Vector3 or Vector4 as position!" );
-          }
-        }
-
-        // update index buffer
-        Batch& batch = batchParentData.batches[ localIndex ];
-        uint32_t currentIndexOffset = batch.indices.Size();
-        batch.indices.Resize( batch.indices.Size() + sourceVertexCount );
-        for( size_t k = 0; k < sourceVertexCount; ++k )
-        {
-          size_t index = currentElementIndex + k;
-          batch.indices[k + currentIndexOffset] = (unsigned short)index;
-        }
-
-        currentElementIndex += sourceVertexCount;
-      }
-
-      if( batchingFailed )
-      {
-        delete &vertexBufferDest;
-        delete batchVertexBuffer;
-        continue;
-      }
-
-      // Add shared property buffer
-      mImpl->updateManager->AddPropertyBuffer( batchVertexBuffer );
-      batchVertexBuffer->SetFormat( vertexDescriptor.mVertexFormat );
-      batchVertexBuffer->SetData( &vertexBufferDest, vertexBufferDest.Size()/vertexDescriptor.mVertexComponentSize );
-
-      batchParentData.needsUpdate = false;
-      batchParentData.vertexBuffer = batchVertexBuffer;
-
-      // Update index buffers for all batches own by that batch parent
-      std::vector<Batch>::iterator iter = batchParentData.batches.begin();
-      std::vector<Batch>::iterator end = batchParentData.batches.end();
-      for( ; iter != end; ++iter )
-      {
-        Batch& batch = (*iter);
-        batch.geometry->SetIndexBuffer( batch.indices );
-        batch.dirty = false;
-      }
-    }
-  }
-  ++mImpl->currentFrame;
-}
-
-void GeometryBatcher::AddBatchParent( Node* node )
-{
-  BatchParent batchParent;
-  batchParent.node = node;
-  batchParent.needsUpdate = true;
-  batchParent.batchedChildren.Clear();
-
-  mImpl->batchParents.push_back( batchParent );
-}
-
-void GeometryBatcher::RemoveBatchParent( Node* node )
-{
-  for( size_t i = 0; i < mImpl->batchParents.size(); ++i )
-  {
-    BatchParent& batchParent = mImpl->batchParents[i];
-    if( node == batchParent.node )
-    {
-      // tell children they're not batched anymore
-      Vector<Node*>::Iterator iter = batchParent.batchedChildren.Begin();
-      Vector<Node*>::Iterator end = batchParent.batchedChildren.End();
-      for( ; iter != end; ++iter )
-      {
-        Node* child = *iter;
-        child->mBatchIndex = BATCH_NULL_HANDLE;
-      }
-
-      // delete all resources that belongs to the batch parent
-      for( size_t j = 0; j < batchParent.batches.size(); ++j )
-      {
-        Batch& batch = batchParent.batches[j];
-        mImpl->updateManager->RemoveGeometry( batch.geometry );
-      }
-
-      // delete main vertex buffer
-      mImpl->updateManager->RemovePropertyBuffer( batchParent.vertexBuffer );
-
-      return;
-    }
-  }
-}
-
-void GeometryBatcher::AddNode( Node* node )
-{
-  // look for batch parent
-  Node* currentNode = node->GetParent();
-  Node* batchParent = NULL;
-  while( currentNode )
-  {
-    if( currentNode->mIsBatchParent )
-    {
-      batchParent = currentNode;
-    }
-    currentNode = currentNode->GetParent();
-  }
-
-  if( batchParent )
-  {
-    // find batch parent
-    for( size_t i = 0; i < mImpl->batchParents.size(); ++i )
-    {
-      if( mImpl->batchParents[i].node == batchParent )
-      {
-        mImpl->batchParents[i].batchedChildren.PushBack( node );
-        node->SetBatchParent( batchParent );
-        mImpl->batchParents[i].needsUpdate = true;
-        break;
-      }
-    }
-  }
-}
-
-void GeometryBatcher::RemoveNode( Node* node )
-{
-  if( node->mBatchIndex == BATCH_NULL_HANDLE )
-  {
-    return;
-  }
-
-  uint32_t parentIndex = BATCH_PARENT_INDEX( node->mBatchIndex );
-
-  BatchParent& batchParent = mImpl->batchParents[ parentIndex ];
-
-  // delete all batches from batch parent
-  for( size_t i = 0; i < batchParent.batches.size(); ++i )
-  {
-    Batch& batch = batchParent.batches[ i ];
-
-    // delete geometry
-    mImpl->updateManager->RemoveGeometry( batch.geometry );
-  }
-
-  batchParent.batches.clear();
-
-  // for all children reset batch index to BATCH_NULL_HANDLE
-  for( size_t i = 0; i < batchParent.batchedChildren.Size(); )
-  {
-    Node* child = batchParent.batchedChildren[i];
-
-    if( node == child )
-    {
-      batchParent.batchedChildren.Erase( batchParent.batchedChildren.Begin() + i );
-    }
-    else
-    {
-      child->mBatchIndex = BATCH_NULL_HANDLE;
-      ++i;
-    }
-  }
-
-  mImpl->updateManager->RemovePropertyBuffer( batchParent.vertexBuffer );
-  batchParent.needsUpdate = true;
-}
-
-bool GeometryBatcher::HasRendered( uint32_t batchIndex )
-{
-  return mImpl->batchParents[ BATCH_PARENT_INDEX( batchIndex ) ].batches[ BATCH_LOCAL_INDEX( batchIndex ) ].renderedFrame == mImpl->currentFrame;
-}
-
-void GeometryBatcher::SetRendered( uint32_t batchIndex )
-{
-  mImpl->batchParents[ BATCH_PARENT_INDEX( batchIndex ) ].batches[ BATCH_LOCAL_INDEX( batchIndex ) ].renderedFrame = mImpl->currentFrame;
-}
-
-Render::Geometry* GeometryBatcher::GetGeometry( uint32_t batchIndex )
-{
-  return mImpl->batchParents[ BATCH_PARENT_INDEX( batchIndex) ].batches[ BATCH_LOCAL_INDEX( batchIndex ) ].geometry;
-}
-
-} // namespace SceneGraph
-
-} // namespace Internal
-
-
-} // namespace Dali
diff --git a/dali/internal/update/manager/geometry-batcher.h b/dali/internal/update/manager/geometry-batcher.h
deleted file mode 100644 (file)
index c19e034..0000000
+++ /dev/null
@@ -1,146 +0,0 @@
-#ifndef DALI_INTERNAL_SCENE_GRAPH_GEOMETRY_BATCHER_H
-#define DALI_INTERNAL_SCENE_GRAPH_GEOMETRY_BATCHER_H
-
-/*
- * Copyright (c) 2016 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.
- *
- */
-
-// INTERNAL INCLUDES
-#include <dali/internal/render/renderers/render-property-buffer.h>
-#include <dali/internal/update/rendering/scene-graph-texture-set.h>
-#include <dali/internal/render/common/render-list.h>
-
-// PUBLIC INCLUDES
-#include <dali/public-api/common/dali-vector.h>
-
-/// Value used by a node to indicate the batch index as null or invalid
-#define BATCH_NULL_HANDLE 0xFFFFFFFF
-
-namespace Dali
-{
-
-namespace Internal
-{
-
-namespace Render
-{
-class Geometry;
-}
-
-namespace SceneGraph
-{
-struct BatchInfo;
-struct BatchStreamMarker;
-
-class Node;
-class RenderInstructionContainer;
-
-class GeometryBatcher
-{
-
-public:
-
-  /**
-   * The constructor of GeometryBatcher
-   */
-  GeometryBatcher();
-
-  /**
-   * The destructor of GeometryBatcher
-   */
-  ~GeometryBatcher();
-
-  /**
-   * Assigns the update manager object
-   * @param[in] updateManager Pointer to instance of update manager
-   */
-  void SetUpdateManager( UpdateManager* updateManager );
-
-  /**
-   * Updates all batches
-   * @param[in] index Update buffer index
-   */
-  void Update( BufferIndex index );
-
-  /**
-   * @brief Add node to batch parents list
-   * @param[in] node instance of a node to be added
-   */
-  void AddBatchParent( Node* node );
-
-  /**
-   * @brief Remove node from list of batch parents
-   * @param[in] node valid instance of node to be removed
-   */
-  void RemoveBatchParent( Node* node );
-
-  /**
-   * @brief Add batchable node
-   * @param[in] node valid instance of the node to be added
-   */
-  void AddNode( Node* node );
-
-  /**
-   * @brief Remove batchable node
-   * @param[in] node valid instance of the node to be removed
-   */
-  void RemoveNode( Node* node );
-
-  /**
-   * @brief Return the geometry object associated with specified batch index
-   * @param[in] batchIndex VALID index of the batch
-   * @return instance of the batched geometry
-   */
-  Render::Geometry* GetGeometry( uint32_t batchIndex );
-
-  /**
-   * @brief Query if a batch at given index has been already rendered
-   * @param batchIndex VALID index of a batch to query
-   * @return true if batch has rendered, false otherwise
-   */
-  bool HasRendered( uint32_t batchIndex );
-
-  /**
-   * @brief Sets a batch at given index as rendered
-   * @param batchIndex VALID index of a batch
-   */
-  void SetRendered( uint32_t batchIndex );
-
-private:
-
-  /**
-   * @brief Clones vertex format of source geometry and stores generated data in the batchInfo object
-   * @param[in] sourceGeometry Geometry of the very first batched item
-   * @param[out] batchInfo Batch info object used to store cloned vertex format
-   * @return true on success, false otherwise
-   */
-  bool CloneVertexFormat( const Render::Geometry* sourceGeometry, struct VertexDescriptor& batchInfo );
-
-private:
-
-  struct Impl* mImpl; ///< Pointer to an instance of geometry batcher implementation
-
-};
-
-} // SceneGraph
-
-} // Internal
-
-} // Dali
-
-
-#endif //DALI_INTERNAL_SCENE_GRAPH_GEOMETRY_BATCHER_H
-
index 350d66e910df204b2a6a2e93a4536be2088069ca..41616a192d98b687ab557b5ad83b505f6cffb5a8 100644 (file)
@@ -34,8 +34,6 @@
 #include <dali/internal/render/common/render-instruction-container.h>
 #include <dali/internal/render/shaders/scene-graph-shader.h>
 #include <dali/internal/render/renderers/render-renderer.h>
-#include <dali/internal/render/renderers/render-property-buffer.h>
-#include <dali/internal/update/manager/geometry-batcher.h>
 
 namespace
 {
@@ -60,7 +58,6 @@ namespace SceneGraph
  * @param renderable Node-Renderer pair
  * @param viewMatrix used to calculate modelview matrix for the item
  * @param camera The camera used to render
- * @param geometryBatcher The instance of the geometry batcher
  * @param isLayer3d Whether we are processing a 3D layer or not
  * @param cull Whether frustum culling is enabled or not
  */
@@ -69,37 +66,19 @@ inline void AddRendererToRenderList( BufferIndex updateBufferIndex,
                                      Renderable& renderable,
                                      const Matrix& viewMatrix,
                                      SceneGraph::Camera& camera,
-                                     GeometryBatcher& geometryBatcher,
                                      bool isLayer3d,
                                      bool cull )
 {
-  // discard renderable early if it belongs to the batch which has been consumed in during frame
-  Node* renderableNode = renderable.mNode;
-  const bool batchingValid( renderable.mRenderer->IsBatchingEnabled() && renderableNode->mBatchIndex != BATCH_NULL_HANDLE );
-  if( batchingValid && geometryBatcher.HasRendered( renderableNode->mBatchIndex ) )
-  {
-    return;
-  }
-
   bool inside( true );
-  const Node* batchParentNode = renderable.mNode->GetBatchParent();
-  const Node* node = ( renderable.mRenderer->IsBatchingEnabled() && batchParentNode ) ?
-        batchParentNode : renderableNode;
-
   if ( cull && !renderable.mRenderer->GetShader().HintEnabled( Dali::Shader::Hint::MODIFIES_GEOMETRY ) )
   {
-    const Vector4& boundingSphere = node->GetBoundingSphere();
+    const Vector4& boundingSphere = renderable.mNode->GetBoundingSphere();
     inside = (boundingSphere.w > Math::MACHINE_EPSILON_1000) &&
              (camera.CheckSphereInFrustum( updateBufferIndex, Vector3(boundingSphere), boundingSphere.w ) );
   }
 
-  if( inside )
+  if ( inside )
   {
-    if( batchingValid )
-    {
-      geometryBatcher.SetRendered( renderableNode->mBatchIndex );
-    }
-
     Renderer::Opacity opacity = renderable.mRenderer->GetOpacity( updateBufferIndex, *renderable.mNode );
     if( opacity != Renderer::TRANSPARENT )
     {
@@ -118,7 +97,7 @@ inline void AddRendererToRenderList( BufferIndex updateBufferIndex,
         item.mDepthIndex = renderable.mRenderer->GetDepthIndex() + static_cast<int>( renderable.mNode->GetDepth() ) * Dali::Layer::TREE_DEPTH_MULTIPLIER;
       }
       // save MV matrix onto the item
-      node->GetWorldMatrixAndSize( item.mModelMatrix, item.mSize );
+      renderable.mNode->GetWorldMatrixAndSize( item.mModelMatrix, item.mSize );
       Matrix::Multiply( item.mModelViewMatrix, item.mModelMatrix, viewMatrix );
     }
   }
@@ -132,7 +111,6 @@ inline void AddRendererToRenderList( BufferIndex updateBufferIndex,
  * NodeRendererContainer Node-Renderer pairs
  * @param viewMatrix used to calculate modelview matrix for the items
  * @param camera The camera used to render
- * @param geometryBatcher The instance of the geometry batcher
  * @param isLayer3d Whether we are processing a 3D layer or not
  * @param cull Whether frustum culling is enabled or not
  */
@@ -141,7 +119,6 @@ inline void AddRenderersToRenderList( BufferIndex updateBufferIndex,
                                       RenderableContainer& renderers,
                                       const Matrix& viewMatrix,
                                       SceneGraph::Camera& camera,
-                                      GeometryBatcher* geometryBatcher,
                                       bool isLayer3d,
                                       bool cull)
 {
@@ -150,7 +127,7 @@ inline void AddRenderersToRenderList( BufferIndex updateBufferIndex,
   unsigned int rendererCount( renderers.Size() );
   for( unsigned int i(0); i<rendererCount; ++i )
   {
-    AddRendererToRenderList( updateBufferIndex, renderList, renderers[i], viewMatrix, camera, *geometryBatcher, isLayer3d, cull );
+    AddRendererToRenderList( updateBufferIndex, renderList, renderers[i], viewMatrix, camera, isLayer3d, cull );
   }
 }
 
@@ -353,7 +330,6 @@ inline void SortRenderItems( BufferIndex bufferIndex, RenderList& renderList, La
  * @param stencilRenderablesExist is true if there are stencil renderers on this layer
  * @param instruction to fill in
  * @param sortingHelper to use for sorting the renderitems (to avoid reallocating)
- * @param geometryBatcher the instance of the geometry batcher
  * @param tryReuseRenderList whether to try to reuse the cached items from the instruction
  * @param cull Whether frustum culling is enabled or not
  */
@@ -364,7 +340,6 @@ inline void AddColorRenderers( BufferIndex updateBufferIndex,
                                bool stencilRenderablesExist,
                                RenderInstruction& instruction,
                                RendererSortingHelper& sortingHelper,
-                               GeometryBatcher& geometryBatcher,
                                bool tryReuseRenderList,
                                bool cull)
 {
@@ -382,7 +357,7 @@ inline void AddColorRenderers( BufferIndex updateBufferIndex,
     }
   }
 
-  AddRenderersToRenderList( updateBufferIndex, renderList, layer.colorRenderables, viewMatrix, camera, &geometryBatcher, layer.GetBehavior() == Dali::Layer::LAYER_3D, cull );
+  AddRenderersToRenderList( updateBufferIndex, renderList, layer.colorRenderables, viewMatrix, camera, layer.GetBehavior() == Dali::Layer::LAYER_3D, cull );
   SortRenderItems( updateBufferIndex, renderList, layer, sortingHelper );
 
   // Setup the render flags for stencil.
@@ -435,7 +410,7 @@ inline void AddOverlayRenderers( BufferIndex updateBufferIndex,
       return;
     }
   }
-  AddRenderersToRenderList( updateBufferIndex, overlayRenderList, layer.overlayRenderables, viewMatrix, camera, NULL, layer.GetBehavior() == Dali::Layer::LAYER_3D, cull );
+  AddRenderersToRenderList( updateBufferIndex, overlayRenderList, layer.overlayRenderables, viewMatrix, camera, layer.GetBehavior() == Dali::Layer::LAYER_3D, cull );
   SortRenderItems( updateBufferIndex, overlayRenderList, layer, sortingHelper );
 }
 
@@ -474,7 +449,7 @@ inline void AddStencilRenderers( BufferIndex updateBufferIndex,
       return;
     }
   }
-  AddRenderersToRenderList( updateBufferIndex, stencilRenderList, layer.stencilRenderables, viewMatrix, camera, NULL, layer.GetBehavior() == Dali::Layer::LAYER_3D, cull );
+  AddRenderersToRenderList( updateBufferIndex, stencilRenderList, layer.stencilRenderables, viewMatrix, camera, layer.GetBehavior() == Dali::Layer::LAYER_3D, cull );
 }
 
 void PrepareRenderInstruction( BufferIndex updateBufferIndex,
@@ -482,8 +457,7 @@ void PrepareRenderInstruction( BufferIndex updateBufferIndex,
                                RenderTask& renderTask,
                                RendererSortingHelper& sortingHelper,
                                bool cull,
-                               RenderInstructionContainer& instructions,
-                               GeometryBatcher& geometryBatcher )
+                               RenderInstructionContainer& instructions )
 {
   // Retrieve the RenderInstruction buffer from the RenderInstructionContainer
   // then populate with instructions.
@@ -520,7 +494,6 @@ void PrepareRenderInstruction( BufferIndex updateBufferIndex,
                          stencilRenderablesExist,
                          instruction,
                          sortingHelper,
-                         geometryBatcher,
                          tryReuseRenderList,
                          cull );
     }
index bd1680410266d98fb7708944e748136fe9c2f98a..0abbc2b6f7e524318c6a0b0fbce65343bf792b93 100644 (file)
@@ -39,7 +39,6 @@ namespace SceneGraph
 class RenderTracker;
 struct RenderItem;
 class Shader;
-class GeometryBatcher;
 
 /**
  * Structure to store information for sorting the renderers.
@@ -90,8 +89,7 @@ void PrepareRenderInstruction( BufferIndex updateBufferIndex,
                                RenderTask& renderTask,
                                RendererSortingHelper& sortingHelper,
                                bool cull,
-                               RenderInstructionContainer& instructions,
-                               GeometryBatcher& geometryBatcher );
+                               RenderInstructionContainer& instructions );
 
 } // namespace SceneGraph
 
index b04a108362d54d9fcfc6599c6ac713f24a43e079..4ab67b4f4b74f75321429892737c5efefabc27a3 100644 (file)
@@ -163,6 +163,8 @@ bool AddRenderablesForTask( BufferIndex updateBufferIndex,
     }
   }
 
+
+
   // Recurse children
   NodeContainer& children = node.GetChildren();
   const NodeIter endIter = children.End();
@@ -182,7 +184,6 @@ void ProcessRenderTasks( BufferIndex updateBufferIndex,
                          Layer& rootNode,
                          SortedLayerPointers& sortedLayers,
                          RendererSortingHelper& sortingHelper,
-                         GeometryBatcher& geometryBatcher,
                          RenderInstructionContainer& instructions )
 {
   RenderTaskList::RenderTaskContainer& taskContainer = renderTasks.GetTasks();
@@ -257,8 +258,7 @@ void ProcessRenderTasks( BufferIndex updateBufferIndex,
                                 renderTask,
                                 sortingHelper,
                                 renderTask.GetCullMode(),
-                                instructions,
-                                geometryBatcher );
+                                instructions );
     }
     else
     {
@@ -321,8 +321,7 @@ void ProcessRenderTasks( BufferIndex updateBufferIndex,
                                 renderTask,
                                 sortingHelper,
                                 renderTask.GetCullMode(),
-                                instructions,
-                                geometryBatcher );
+                                instructions );
     }
 
     renderTask.SetResourcesFinished( resourcesFinished );
index 3758b024eae6a9617b813f7d0c341b7dfb609872..24df0eaf0ccd43e0549cec7475aa55008cab3cf3 100644 (file)
@@ -41,7 +41,6 @@ class RenderTaskList;
  * @param[in] rootNode The root node of the scene-graph.
  * @param[in] sortedLayers The layers containing lists of opaque/transparent renderables.
  * @param[in] sortingHelper Helper container for sorting transparent renderables.
- * @param[in] geometryBatcher The instance of the geometry batcher
  * @param[out] instructions The instructions for rendering the next frame.
  */
 void ProcessRenderTasks( BufferIndex updateBufferIndex,
@@ -49,7 +48,6 @@ void ProcessRenderTasks( BufferIndex updateBufferIndex,
                          Layer& rootNode,
                          SortedLayerPointers& sortedLayers,
                          RendererSortingHelper& sortingHelper,
-                         GeometryBatcher& geometryBatcher,
                          RenderInstructionContainer& instructions );
 
 } // namespace SceneGraph
index c5f61598b93bafeeb57601dba52af30759ad4884..1c21fe4939c411880540a48e39cb2d8ae9ce4ce3 100644 (file)
@@ -73,7 +73,7 @@ void PrintNodes( const Node& node, BufferIndex updateBufferIndex, int level )
         << "  Scale (" << scale.x << ", " << scale.y << ", " << scale.z << ")"
         << std::endl;
 
-    DALI_LOG_INFO(gNodeLogFilter, Debug::Verbose, "%s\n", oss.str().c_str());
+    DALI_LOG_INFO(gNodeLogFilter, Debug::Verbose, "%s", oss.str().c_str());
   }
 
   {
@@ -85,7 +85,7 @@ void PrintNodes( const Node& node, BufferIndex updateBufferIndex, int level )
         << std::setw(level*2) << std::setfill(' ') << "";
 
     std::string trafoMatrix = Debug::MatrixToString(node.GetWorldMatrix(updateBufferIndex), 2, level*2);
-    DALI_LOG_INFO(gNodeLogFilter, Debug::Verbose, "%s\n", trafoMatrix.c_str());
+    DALI_LOG_INFO(gNodeLogFilter, Debug::Verbose, "%s", trafoMatrix.c_str());
   }
 
   ++level;
index ee790398f280bcc647a75cbe3e46611c98f97a75..b2a52d9972b7792b96f9c789ce4252bf4c866a6f 100644 (file)
 #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/resources/resource-manager.h>
-#include <dali/internal/update/manager/geometry-batcher.h>
-#include <dali/internal/update/render-tasks/scene-graph-camera.h>
 
 #include <dali/internal/render/common/render-instruction-container.h>
 #include <dali/internal/render/common/render-manager.h>
 #include <dali/internal/render/queue/render-queue.h>
 #include <dali/internal/render/gl-resources/texture-cache.h>
 #include <dali/internal/render/shaders/scene-graph-shader.h>
+#include <dali/internal/render/renderers/render-frame-buffer.h>
+#include <dali/internal/render/renderers/render-sampler.h>
+#include <dali/internal/update/render-tasks/scene-graph-camera.h>
 
 // Un-comment to enable node tree debug logging
 //#define NODE_TREE_LOGGING 1
@@ -130,8 +131,7 @@ struct UpdateManager::Impl
         RenderController& renderController,
         RenderManager& renderManager,
         RenderQueue& renderQueue,
-        SceneGraphBuffers& sceneGraphBuffers,
-        GeometryBatcher& geometryBatcher )
+        SceneGraphBuffers& sceneGraphBuffers )
   : renderMessageDispatcher( renderManager, renderQueue, sceneGraphBuffers ),
     notificationManager( notificationManager ),
     transformManager(),
@@ -145,7 +145,6 @@ struct UpdateManager::Impl
     renderManager( renderManager ),
     renderQueue( renderQueue ),
     renderInstructions( renderManager.GetRenderInstructionContainer() ),
-    geometryBatcher( geometryBatcher ),
     backgroundColor( Dali::Stage::DEFAULT_BACKGROUND_COLOR ),
     taskList( renderMessageDispatcher, resourceManager ),
     systemLevelTaskList( renderMessageDispatcher, resourceManager ),
@@ -166,8 +165,6 @@ struct UpdateManager::Impl
 
     renderers.SetSceneController( *sceneController );
 
-    discardQueue.SetGeometryBatcher( &geometryBatcher );
-
     // create first 'dummy' node
     nodes.PushBack(0u);
   }
@@ -230,7 +227,6 @@ struct UpdateManager::Impl
   RenderManager&                      renderManager;                 ///< This is responsible for rendering the results of each "update"
   RenderQueue&                        renderQueue;                   ///< Used to queue messages for the next render
   RenderInstructionContainer&         renderInstructions;            ///< Used to prepare the render instructions
-  GeometryBatcher&                    geometryBatcher;               ///< An instance of the GeometryBatcher
 
   Vector4                             backgroundColor;               ///< The glClear color used at the beginning of each frame.
 
@@ -282,8 +278,7 @@ UpdateManager::UpdateManager( NotificationManager& notificationManager,
                               RenderController& controller,
                               RenderManager& renderManager,
                               RenderQueue& renderQueue,
-                              TextureCacheDispatcher& textureCacheDispatcher,
-                              GeometryBatcher& geometryBatcher )
+                              TextureCacheDispatcher& textureCacheDispatcher )
   : mImpl(NULL)
 {
   mImpl = new Impl( notificationManager,
@@ -294,11 +289,9 @@ UpdateManager::UpdateManager( NotificationManager& notificationManager,
                     controller,
                     renderManager,
                     renderQueue,
-                    mSceneGraphBuffers,
-                    geometryBatcher );
+                    mSceneGraphBuffers );
 
   textureCacheDispatcher.SetBufferIndices( &mSceneGraphBuffers );
-  mImpl->geometryBatcher.SetUpdateManager( this );
 }
 
 UpdateManager::~UpdateManager()
@@ -315,13 +308,13 @@ void UpdateManager::InstallRoot( SceneGraph::Layer* layer, bool systemLevel )
   {
     DALI_ASSERT_DEBUG( mImpl->root == NULL && "Root Node already installed" );
     mImpl->root = layer;
-    mImpl->root->CreateTransform( &mImpl->transformManager );
+    mImpl->root->CreateTransform( &mImpl->transformManager);
   }
   else
   {
     DALI_ASSERT_DEBUG( mImpl->systemLevelRoot == NULL && "System-level Root Node already installed" );
     mImpl->systemLevelRoot = layer;
-    mImpl->systemLevelRoot->CreateTransform( &mImpl->transformManager );
+    mImpl->systemLevelRoot->CreateTransform( &mImpl->transformManager);
   }
 
   layer->SetRoot(true);
@@ -339,8 +332,7 @@ void UpdateManager::AddNode( Node* node )
     if(node > (*iter))
     {
       mImpl->nodes.Insert((iter+1), node);
-      node->CreateTransform( &mImpl->transformManager );
-      node->mGeometryBatcher = &mImpl->geometryBatcher;
+      node->CreateTransform( &mImpl->transformManager);
       break;
     }
   }
@@ -987,9 +979,6 @@ unsigned int UpdateManager::Update( float elapsedSeconds,
     //Process Property Notifications
     ProcessPropertyNotifications( bufferIndex );
 
-    //Update geometry batcher
-    mImpl->geometryBatcher.Update( bufferIndex );
-
     //Process the RenderTasks; this creates the instructions for rendering the next frame.
     //reset the update buffer index and make sure there is enough room in the instruction container
     mImpl->renderInstructions.ResetAndReserve( bufferIndex,
@@ -1002,7 +991,6 @@ unsigned int UpdateManager::Update( float elapsedSeconds,
                            *mImpl->root,
                            mImpl->sortedLayers,
                            mImpl->renderSortingHelper,
-                           mImpl->geometryBatcher,
                            mImpl->renderInstructions );
 
       // Process the system-level RenderTasks last
@@ -1013,7 +1001,6 @@ unsigned int UpdateManager::Update( float elapsedSeconds,
                              *mImpl->systemLevelRoot,
                              mImpl->systemLevelSortedLayers,
                              mImpl->renderSortingHelper,
-                             mImpl->geometryBatcher,
                              mImpl->renderInstructions );
       }
     }
index 7f15563470f0e63be6c9c50e58b138fc9f9d17cc..e90ab9dbacca43df6c6ac25ac631f2ec46d2c231 100644 (file)
@@ -104,7 +104,6 @@ public:
    * @param[in] renderManager This is responsible for rendering the results of each "update".
    * @param[in] renderQueue Used to queue messages for the next render.
    * @param[in] textureCacheDispatcher Used for sending messages to texture cache.
-   * @param[in] geometryBatcher Used when geometry batching is enabled.
    */
   UpdateManager( NotificationManager& notificationManager,
                  CompleteNotificationInterface& animationFinishedNotifier,
@@ -114,8 +113,7 @@ public:
                  Integration::RenderController& controller,
                  RenderManager& renderManager,
                  RenderQueue& renderQueue,
-                 TextureCacheDispatcher& textureCacheDispatcher,
-                 GeometryBatcher& geometryBatcher );
+                 TextureCacheDispatcher& textureCacheDispatcher );
 
   /**
    * Destructor.
index 0a7dc5a17dfd5cc3fa815bfa466e5be8053726d0..b3a9767c7e4a37f2849c852796179ca2be9b54db 100644 (file)
@@ -22,7 +22,6 @@
 #include <dali/internal/common/internal-constants.h>
 #include <dali/internal/common/memory-pool-object-allocator.h>
 #include <dali/internal/update/common/discard-queue.h>
-#include <dali/internal/update/manager/geometry-batcher.h>
 #include <dali/public-api/common/dali-common.h>
 #include <dali/public-api/common/constants.h>
 
@@ -50,7 +49,7 @@ Node* Node::New()
 }
 
 Node::Node()
-: mTransformManager( NULL ),
+: mTransformManager(0),
   mTransformId( INVALID_TRANSFORM_ID ),
   mParentOrigin( TRANSFORM_PROPERTY_PARENT_ORIGIN ),
   mAnchorPoint( TRANSFORM_PROPERTY_ANCHOR_POINT ),
@@ -65,11 +64,7 @@ Node::Node()
   mWorldOrientation(), // initialized to identity by default
   mWorldMatrix(),
   mWorldColor( Color::WHITE ),
-  mGeometryBatcher( NULL ),
-  mBatchIndex( BATCH_NULL_HANDLE ),
-  mIsBatchParent( false ),
   mParent( NULL ),
-  mBatchParent( NULL ),
   mExclusiveRenderTask( NULL ),
   mChildren(),
   mRegenerateUniformMap( 0 ),
@@ -216,35 +211,6 @@ void Node::DisconnectChild( BufferIndex updateBufferIndex, Node& childNode )
   found->RecursiveDisconnectFromSceneGraph( updateBufferIndex );
 }
 
-void Node::AddRenderer( Renderer* renderer )
-{
-  //Check that it has not been already added
-  unsigned int rendererCount( mRenderer.Size() );
-  for( unsigned int i(0); i<rendererCount; ++i )
-  {
-    if( mRenderer[i] == renderer )
-    {
-      //Renderer already in the list
-      return;
-    }
-  }
-
-  //If it is the first renderer added, make sure the world transform will be calculated
-  //in the next update as world transform is not computed if node has no renderers
-  if( rendererCount == 0 )
-  {
-    mDirtyFlags |= TransformFlag;
-  }
-
-  mRenderer.PushBack( renderer );
-
-  // Tell geometry batcher if should batch the child
-  if( mRenderer.Size() == 1 && mRenderer[0]->mBatchingEnabled )
-  {
-    mGeometryBatcher->AddNode( this );
-  }
-}
-
 void Node::RemoveRenderer( Renderer* renderer )
 {
   unsigned int rendererCount( mRenderer.Size() );
@@ -286,7 +252,7 @@ void Node::ResetDefaultProperties( BufferIndex updateBufferIndex )
   mDirtyFlags = NothingFlag;
 }
 
-void Node::SetParent( Node& parentNode )
+void Node::SetParent(Node& parentNode)
 {
   DALI_ASSERT_ALWAYS(this != &parentNode);
   DALI_ASSERT_ALWAYS(!mIsRoot);
@@ -301,29 +267,6 @@ void Node::SetParent( Node& parentNode )
   }
 }
 
-void Node::SetBatchParent( Node* batchParentNode )
-{
-  DALI_ASSERT_ALWAYS(!mIsRoot);
-  mBatchParent = batchParentNode;
-}
-
-void Node::SetIsBatchParent( bool enabled )
-{
-  if( mIsBatchParent != enabled )
-  {
-    mIsBatchParent = enabled;
-
-    if( enabled )
-    {
-      mGeometryBatcher->AddBatchParent( this );
-    }
-    else
-    {
-      mGeometryBatcher->RemoveBatchParent( this );
-    }
-  }
-}
-
 void Node::RecursiveDisconnectFromSceneGraph( BufferIndex updateBufferIndex )
 {
   DALI_ASSERT_ALWAYS(!mIsRoot);
index 3f8bbacf50560cc500e766733c7c8a5ea8a8f12c..4846122861dcecdc8f2d23bca8923358f337d38e 100644 (file)
@@ -56,7 +56,6 @@ class DiscardQueue;
 class Layer;
 class RenderTask;
 class UpdateManager;
-class GeometryBatcher;
 
 /**
  * Flag whether property has changed, during the Update phase.
@@ -146,7 +145,28 @@ public:
    * Add a renderer to the node
    * @param[in] renderer The renderer added to the node
    */
-  void AddRenderer( Renderer* renderer );
+  void AddRenderer( Renderer* renderer )
+  {
+    //Check that it has not been already added
+    unsigned int rendererCount( mRenderer.Size() );
+    for( unsigned int i(0); i<rendererCount; ++i )
+    {
+      if( mRenderer[i] == renderer )
+      {
+        //Renderer already in the list
+        return;
+      }
+    }
+
+    //If it is the first renderer added, make sure the world transform will be calculated
+    //in the next update as world transform is not computed if node has no renderers
+    if( rendererCount == 0 )
+    {
+      mDirtyFlags |= TransformFlag;
+    }
+
+    mRenderer.PushBack( renderer );
+  }
 
   /**
    * Remove a renderer from the node
@@ -158,7 +178,7 @@ public:
    * Get the renderer at the given index
    * @param[in] index
    */
-  Renderer* GetRendererAt( unsigned int index ) const
+  Renderer* GetRendererAt( unsigned int index )
   {
     return mRenderer[index];
   }
@@ -591,6 +611,7 @@ public:
            (mTransformManager->IsLocalMatrixDirty( mTransformId ));
   }
 
+
   /**
    * Retrieve the cached world-matrix of a node.
    * @param[in] bufferIndex The buffer to read from.
@@ -664,36 +685,6 @@ public:
     return mDepth;
   }
 
-  /**
-   * @brief Turns on or off being a batch parent for the node
-   * @param[in] enabled If true the node becomes a parent for batch of its children
-   */
-  void SetIsBatchParent( bool enabled );
-
-  /**
-   * @brief Tells if the node is a batch parent
-   * @return True if node is a batch parent, false otherwise.
-   */
-  inline bool GetIsBatchParent()
-  {
-    return mIsBatchParent;
-  }
-
-  /**
-   * Set the batch parent of a Node.
-   * @param[in] batchParentNode The new batch parent.
-   */
-  void SetBatchParent( Node* batchParentNode );
-
-  /**
-   * Retrieve the batch parent of a Node.
-   * @return The batch parent node, or NULL if the Node has not been added to the scene-graph.
-   */
-  Node* GetBatchParent() const
-  {
-    return mBatchParent;
-  }
-
 public:
   /**
    * @copydoc UniformMap::Add
@@ -726,9 +717,7 @@ protected:
    * Set the parent of a Node.
    * @param[in] parentNode the new parent.
    */
-  void SetParent( Node& parentNode );
-
-protected:
+  void SetParent(Node& parentNode);
 
   /**
    * Protected constructor; See also Node::New()
@@ -810,16 +799,11 @@ public: // Default properties
   TransformManagerVector3Input    mWorldScale;
   TransformManagerQuaternionInput mWorldOrientation;  ///< Full inherited orientation
   TransformManagerMatrixInput     mWorldMatrix;       ///< Full inherited world matrix
-  InheritedColor                  mWorldColor;        ///< Full inherited color
-
-  GeometryBatcher*                mGeometryBatcher;  ///< A pointer to an instance of geometry batcher
-  uint32_t                        mBatchIndex;       ///< Batch 32bit handle, BATCH_NULL_HANDLE by default
-  bool                            mIsBatchParent:1;  ///< Marks node as a batch parent
+  InheritedColor      mWorldColor;        ///< Full inherited color
 
 protected:
 
   Node*               mParent;                       ///< Pointer to parent node (a child is owned by its parent)
-  Node*               mBatchParent;                  ///< Pointer to batch parent node
   RenderTask*         mExclusiveRenderTask;          ///< Nodes can be marked as exclusive to a single RenderTask
 
   RendererContainer   mRenderer;                     ///< Container of renderers; not owned
@@ -943,19 +927,6 @@ inline void RemoveRendererMessage( EventThreadServices& eventThreadServices, con
   // Construct message in the message queue memory; note that delete should not be called on the return value
   new (slot) LocalType( &node, &Node::RemoveRenderer, renderer );
 }
-
-inline void SetIsBatchParentMessage( EventThreadServices& eventThreadServices, const Node& node, bool isBatchParent )
-{
-  typedef MessageValue1< Node, 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( &node, &Node::SetIsBatchParent, isBatchParent );
-}
-
-
 } // namespace SceneGraph
 
 } // namespace Internal
index c9e4b7adabbb1abd362348f889b3fd436abc84ea..158ed37e8f4a775122e2dc9c884fc92e4973a25a 100644 (file)
@@ -65,7 +65,7 @@ void Frustum(Matrix& result, float left, float right, float bottom, float top, f
   float deltaZ = far - near;
   if ((near <= 0.0f) || (far <= 0.0f) || Equals(right, left) || Equals(bottom, top) || (deltaZ <= 0.0f))
   {
-    DALI_LOG_ERROR("Invalid parameters passed into Frustum!\n");
+    DALI_LOG_ERROR("Invalid parameters passed into Frustum!");
     DALI_ASSERT_DEBUG("Invalid parameters passed into Frustum!");
     return;
   }
@@ -104,7 +104,7 @@ void Orthographic(Matrix& result, float left, float right, float bottom, float t
 {
   if ( Equals(right, left) || Equals(top, bottom) || Equals(far, near) )
   {
-    DALI_LOG_ERROR( "Cannot create orthographic projection matrix with a zero dimension.\n" );
+    DALI_LOG_ERROR( "Cannot create orthographic projection matrix with a zero dimension." );
     DALI_ASSERT_DEBUG( "Cannot create orthographic projection matrix with a zero dimension." );
     return;
   }
index c28a236d7d7f677169959fb502d897b7eeefb269..17b402f1a0e028a7287aa23d9650cd9eec0033e0 100644 (file)
@@ -107,8 +107,7 @@ enum Flags
   RESEND_STENCIL_OPERATION_ON_FAIL   = 1 << 16,
   RESEND_STENCIL_OPERATION_ON_Z_FAIL = 1 << 17,
   RESEND_STENCIL_OPERATION_ON_Z_PASS = 1 << 18,
-  RESEND_WRITE_TO_COLOR_BUFFER       = 1 << 19,
-  RESEND_BATCHING_MODE               = 1 << 20,
+  RESEND_WRITE_TO_COLOR_BUFFER       = 1 << 19
 };
 
 } // Anonymous namespace
@@ -147,7 +146,6 @@ Renderer::Renderer()
   mResourcesReady( false ),
   mFinishedResourceAcquisition( false ),
   mPremultipledAlphaEnabled( false ),
-  mBatchingEnabled( false ),
   mDepthIndex( 0 )
 {
   mUniformMapChanged[0] = false;
@@ -378,13 +376,6 @@ void Renderer::PrepareRender( BufferIndex updateBufferIndex )
       new (slot) DerivedType( mRenderer, &Render::Renderer::SetWriteToColorBuffer, mWriteToColorBuffer );
     }
 
-    if( mResendFlag & RESEND_BATCHING_MODE )
-    {
-      typedef MessageValue1< Render::Renderer, bool > DerivedType;
-      unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
-      new (slot) DerivedType( mRenderer, &Render::Renderer::SetBatchingEnabled, mBatchingEnabled );
-    }
-
     mResendFlag = 0;
   }
 }
@@ -559,12 +550,6 @@ void Renderer::SetWriteToColorBuffer( bool writeToColorBuffer )
   mResendFlag |= RESEND_WRITE_TO_COLOR_BUFFER;
 }
 
-void Renderer::SetBatchingEnabled( bool batchingEnabled )
-{
-  mBatchingEnabled = batchingEnabled;
-  mResendFlag |= RESEND_BATCHING_MODE;
-}
-
 //Called when SceneGraph::Renderer is added to update manager ( that happens when an "event-thread renderer" is created )
 void Renderer::ConnectToSceneGraph( SceneController& sceneController, BufferIndex bufferIndex )
 {
index 1a86cb97f0c4843a95d3676cb1691a16ea21774e..4249b0fe3828ed84c3f49372639746ed44926a9a 100644 (file)
@@ -87,14 +87,6 @@ public:
    */
   void SetTextures( TextureSet* textureSet );
 
-  /**
-   * Returns current texture set object
-   * @return Pointer to the texture set
-   */
-  const TextureSet* GetTextures() const
-  {
-    return mTextureSet;
-  }
 
   /**
    * Set the shader for the renderer
@@ -106,7 +98,7 @@ public:
    * Get the shader used by this renderer
    * @return the shader this renderer uses
    */
-  const Shader& GetShader() const
+  Shader& GetShader()
   {
     return *mShader;
   }
@@ -117,15 +109,6 @@ public:
    */
   void SetGeometry( Render::Geometry* geometry );
 
-  /**
-   * Get the geometry of this renderer
-   * @return the geometry this renderer uses
-   */
-  const Render::Geometry& GetGeometry() const
-  {
-    return *mGeometry;
-  }
-
   /**
    * Set the depth index
    * @param[in] depthIndex the new depth index to use
@@ -255,21 +238,6 @@ public:
    */
   void SetWriteToColorBuffer( bool writeToColorBuffer );
 
-  /**
-   * Turns on batching feature for the renderer
-   * @param[in] batchingEnabled if true, enables the batching mode for the renderer
-   */
-  void SetBatchingEnabled( bool batchingEnabled );
-
-  /**
-   * Tests whether batching feature is enabled for this renderer
-   * @return batching state
-   */
-  bool IsBatchingEnabled() const
-  {
-    return mBatchingEnabled;
-  }
-
   /**
    * Prepare the object for rendering.
    * This is called by the UpdateManager when an object is due to be rendered in the current frame.
@@ -422,7 +390,6 @@ private:
 
 public:
 
-  bool                         mBatchingEnabled : 1;              ///< Flag indicating whether the render supports batching
   int                          mDepthIndex;                       ///< Used only in PrepareRenderInstructions
 };
 
@@ -662,16 +629,6 @@ inline void SetWriteToColorBufferMessage( EventThreadServices& eventThreadServic
   new (slot) LocalType( &renderer, &Renderer::SetWriteToColorBuffer, writeToColorBuffer );
 }
 
-inline void SetBatchingEnabledMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, bool batchable )
-{
-  typedef MessageValue1< Renderer, bool > LocalType;
-
-  // Reserve some memory inside the message queue
-  unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
-
-  new (slot) LocalType( &renderer, &Renderer::SetBatchingEnabled, batchable );
-}
-
 } // namespace SceneGraph
 } // namespace Internal
 } // namespace Dali
index 0103c63916ec17a485c17521b26c9982c409aeb2..2008faf1c719efe8f58007087bc1b3da8c59b656 100644 (file)
@@ -307,8 +307,7 @@ public:
       PADDING,                                            ///< name "padding",               type Vector4 @SINCE_1_0.0
       MINIMUM_SIZE,                                       ///< name "minimumSize",           type Vector2 @SINCE_1_0.0
       MAXIMUM_SIZE,                                       ///< name "maximumSize",           type Vector2 @SINCE_1_0.0
-      INHERIT_POSITION,                                   ///< name "inheritPosition",       type bool @SINCE_1_1.24
-      BATCH_PARENT,                                       ///< name "batchParent",           type bool @SINCE_1_2.0
+      INHERIT_POSITION,                                   ///< name "inheritPosition", type bool @SINCE_1_1.24
     };
   };
 
index 97ed015be30372d8b4a738102de1580e78ba7d27..4b1884565066d7b3e15c745195305380818aeeca 100644 (file)
@@ -27,8 +27,8 @@ namespace Dali
 {
 
 const unsigned int CORE_MAJOR_VERSION = 1;
-const unsigned int CORE_MINOR_VERSION = 2;
-const unsigned int CORE_MICRO_VERSION = 0;
+const unsigned int CORE_MINOR_VERSION = 1;
+const unsigned int CORE_MICRO_VERSION = 45;
 const char * const CORE_BUILD_DATE    = __DATE__ " " __TIME__;
 
 #ifndef EMSCRIPTEN
index 3060f4b48889676c987523013017b3f7b4e60bee..5805e369d4560adc7a448479dc713ac799753255 100644 (file)
@@ -42,7 +42,7 @@ RefObject::~RefObject()
 #ifdef ENABLE_DEBUG
   if(mCount)
   {
-    DALI_LOG_ERROR("mCount should be zero, deleting referenced object!\n");
+    DALI_LOG_ERROR("mCount should be zero, deleting referenced object!");
   }
 #endif // ENABLE_DEBUG
 }
index 1a48391037cf9ba9a881115e4e829c68e49e1063..9c06ea3e39deebaa374c48740800fb0d5c9f3727 100644 (file)
@@ -420,15 +420,7 @@ public:
        * @note The default value is True
        * @SINCE_1_1.43
        */
-      WRITE_TO_COLOR_BUFFER,
-
-      /**
-       * @brief name "batchingEnabled", type BOOLEAN
-       * @SINCE_1_2.0
-       * @see Batching
-       * @note The default value is 'false'
-       */
-      BATCHING_ENABLED
+      WRITE_TO_COLOR_BUFFER
     };
   };
 
index 8d759e7f06691b0baa231215e47e3383183d40e0..61509942c2de59da1f83e2e6a1a2bdae087b0888 100644 (file)
@@ -314,7 +314,7 @@ BaseSignal::EmitGuard::EmitGuard( bool& flag )
   else
   {
     // mFlag is NULL when Emit() is called during Emit()
-    DALI_LOG_ERROR( "Cannot call Emit() from inside Emit()\n" );
+    DALI_LOG_ERROR( "Cannot call Emit() from inside Emit()" );
   }
 }
 
index a2a94d6e55e150da0b2b99bd50df6847c130dfc5..72d6453ddebead79c4558651c5f8522387c2afcd 100644 (file)
@@ -1,6 +1,6 @@
 Name:       dali
 Summary:    The OpenGLES Canvas Core Library
-Version:    1.2.0
+Version:    1.1.45
 Release:    1
 Group:      System/Libraries
 License:    Apache-2.0 and BSD-2-Clause and MIT