utc-Dali-Sampler.cpp
utc-Dali-Scripting.cpp
utc-Dali-Shader.cpp
+ utc-Dali-Thread.cpp
utc-Dali-WeakHandle.cpp
)
DALI_TEST_CHECK( atlas );
// Using correct pixel format
- PixelBuffer* buffer = new PixelBuffer[16 * 16];
+ PixelBuffer* buffer = new PixelBuffer[16 * 16 * 4];
BufferImage image = BufferImage::New( buffer, 16, 16, Pixel::RGBA8888 );
DALI_TEST_CHECK( atlas.Upload( image, 0, 0 ) );
DALI_TEST_CHECK( atlas );
// Using image too big for atlas
- PixelBuffer* buffer = new PixelBuffer[16 * 16];
+ PixelBuffer* buffer = new PixelBuffer[16 * 16 * 4];
BufferImage image = BufferImage::New( buffer, 16, 16, Pixel::RGBA8888 );
DALI_TEST_CHECK( !atlas.Upload( image, 0, 0 ) );
DALI_TEST_CHECK( atlas );
// Using valid offsets
- PixelBuffer* buffer = new PixelBuffer[16 * 16];
+ PixelBuffer* buffer = new PixelBuffer[16 * 16 * 4];
BufferImage image = BufferImage::New( buffer, 16, 16, Pixel::RGBA8888 );
DALI_TEST_CHECK( atlas.Upload( image, 0, 0 ) );
DALI_TEST_CHECK( atlas );
// Using invalid offsets
- PixelBuffer* buffer = new PixelBuffer[16 * 16];
+ PixelBuffer* buffer = new PixelBuffer[16 * 16 * 4];
BufferImage image = BufferImage::New( buffer, 16, 16, Pixel::RGBA8888 );
DALI_TEST_CHECK( !atlas.Upload( image, 0, 17 ) );
--- /dev/null
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <iostream>
+#include <stdlib.h>
+#include <unistd.h>
+#include <dali-test-suite-utils.h>
+#include <dali/devel-api/threading/conditional-wait.h>
+#include <dali/devel-api/threading/thread.h>
+
+using Dali::ConditionalWait;
+using Dali::Thread;
+
+namespace // for local variables to avoid name clashes
+{
+volatile int gGlobalValue = 0;
+volatile bool gWorkerThreadWait = true;
+enum ThreadState { INIT, RUN, TERMINATE } volatile gWorkerThreadState = INIT;
+ConditionalWait* volatile gConditionalWait; // volatile pointer to a ConditionalWait object
+
+class WorkerThreadNotify : public Thread
+{
+ virtual void Run()
+ {
+ gGlobalValue = -1;
+ while( gWorkerThreadWait ) // wait till we can exit
+ {
+ gWorkerThreadState = RUN;
+ usleep( 1 ); // 1 microseconds
+ }
+ usleep( 200 ); // give other thread time to get to Wait
+ gGlobalValue = 1;
+ gConditionalWait->Notify();
+ gWorkerThreadState = TERMINATE;
+ }
+};
+
+volatile int gNotifyCount = 0;
+class WorkerThreadNotifyN : public Thread
+{
+ virtual void Run()
+ {
+ while( gNotifyCount > 0 )
+ {
+ gConditionalWait->Notify();
+ usleep( 10 ); // 10 microseconds between each notify
+ }
+ }
+};
+
+class WorkerThreadWaitN : public Thread
+{
+ virtual void Run()
+ {
+ gConditionalWait->Wait();
+ }
+};
+
+}
+
+int UtcConditionalWait1P(void)
+{
+ tet_infoline("Testing ConditionalWait - scenario: wait - notify with 2 threads");
+
+ WorkerThreadNotify thread1;
+ // initialize values
+ gConditionalWait = new ConditionalWait();
+ gWorkerThreadWait = true;
+ DALI_TEST_EQUALS( INIT, gWorkerThreadState, TEST_LOCATION );
+ DALI_TEST_EQUALS( 0, gGlobalValue, TEST_LOCATION );
+
+ thread1.Start();
+ // wait till the thread is in run state
+ while( RUN != gWorkerThreadState )
+ {
+ usleep( 1 ); // 1 microsecond
+ }
+ // let worker continue and finish
+ gWorkerThreadWait = false;
+ gConditionalWait->Wait();
+ DALI_TEST_EQUALS( 1, gGlobalValue, TEST_LOCATION );
+ DALI_TEST_EQUALS( 0u, gConditionalWait->GetWaitCount(), TEST_LOCATION );
+
+ // wait till the thread is terminated state
+ while( TERMINATE != gWorkerThreadState )
+ {
+ usleep( 1 ); // 1 microsecond
+ }
+
+ thread1.Join();
+
+ delete gConditionalWait;
+ END_TEST;
+}
+
+int UtcConditionalWait2P(void)
+{
+ tet_infoline("Testing ConditionalWait - scenario: notify without wait");
+
+ ConditionalWait wait;
+ DALI_TEST_EQUALS( 0u, wait.GetWaitCount(), TEST_LOCATION );
+ wait.Notify();
+ DALI_TEST_EQUALS( 0u, wait.GetWaitCount(), TEST_LOCATION );
+
+ END_TEST;
+}
+
+
+int UtcConditionalWait3P(void)
+{
+ tet_infoline("Testing ConditionalWait - scenario: wait - notify N times 2 threads");
+
+ // initialize values
+ gConditionalWait = new ConditionalWait();
+ gNotifyCount = 100;
+
+ WorkerThreadNotifyN thread1;
+ thread1.Start();
+
+ while( gNotifyCount > 0 )
+ {
+ gConditionalWait->Wait();
+ --gNotifyCount;
+ DALI_TEST_EQUALS( 0u, gConditionalWait->GetWaitCount(), TEST_LOCATION );
+ usleep( 10 ); // 10 microseconds between each notify
+ }
+ DALI_TEST_EQUALS( 0u, gConditionalWait->GetWaitCount(), TEST_LOCATION );
+
+ thread1.Join();
+
+ delete gConditionalWait;
+ END_TEST;
+}
+
+int UtcConditionalWait4P(void)
+{
+ tet_infoline("Testing ConditionalWait - scenario: wait - notify N times from 3 threads");
+
+ // initialize values
+ gConditionalWait = new ConditionalWait();
+ gNotifyCount = 100;
+
+ WorkerThreadNotifyN thread1;
+ thread1.Start();
+ WorkerThreadNotifyN thread2;
+ thread2.Start();
+ WorkerThreadNotifyN thread3;
+ thread3.Start();
+
+ while( gNotifyCount > 0 )
+ {
+ gConditionalWait->Wait();
+ --gNotifyCount;
+ DALI_TEST_EQUALS( 0u, gConditionalWait->GetWaitCount(), TEST_LOCATION );
+ usleep( 10 ); // 10 microseconds between each notify
+ }
+
+ thread1.Join();
+ thread2.Join();
+ thread3.Join();
+
+ delete gConditionalWait;
+ END_TEST;
+}
+
+int UtcConditionalWait5P(void)
+{
+ tet_infoline("Testing ConditionalWait - scenario: 4 threads wait - notify once from 1 thread");
+
+ // initialize values
+ gConditionalWait = new ConditionalWait();
+
+ WorkerThreadWaitN thread1;
+ thread1.Start();
+ WorkerThreadWaitN thread2;
+ thread2.Start();
+ WorkerThreadWaitN thread3;
+ thread3.Start();
+ WorkerThreadWaitN thread4;
+ thread4.Start();
+ // wait till all child threads are waiting
+ while( gConditionalWait->GetWaitCount() < 4 )
+ { }
+
+ // notify once, it will resume all threads
+ gConditionalWait->Notify();
+
+ thread1.Join();
+ thread2.Join();
+ thread3.Join();
+ thread4.Join();
+
+ DALI_TEST_EQUALS( 0u, gConditionalWait->GetWaitCount(), TEST_LOCATION );
+
+ delete gConditionalWait;
+ END_TEST;
+}
+
+int UtcConditionalWaitNonCopyable(void)
+{
+ // we want to make sure that ConditionalWait is not copyable (its copy constructor is not defined)
+ // this test will stop compiling if ConditionalWait has compiler generated copy constructor
+ DALI_COMPILE_TIME_ASSERT( !__has_trivial_copy( ConditionalWait ) );
+
+ DALI_TEST_CHECK( true );
+ END_TEST;
+}
+
+
END_TEST;
}
-int UtcDaliGeometrySetGetGeometryType(void)
+int UtcDaliGeometrySetGetGeometryType01(void)
{
TestApplication application;
- tet_infoline("Test SetGeometryType and GetGeometryType");
+ tet_infoline("Test SetGeometryType and GetGeometryType: without index buffer");
unsigned int numVertex = 4u;
PropertyBuffer vertexBuffer = CreateVertexBuffer("aPosition", "aTexCoord" );
DALI_TEST_EQUALS( geometry.GetGeometryType(), Geometry::POINTS, TEST_LOCATION);
+ /*****************************************************/
+ //TRIANGLE_STRIP, no index buffer
+ geometry.SetGeometryType( Geometry::TRIANGLE_STRIP );
+
+ drawTrace.Reset();
+ drawTrace.Enable(true);
+ application.SendNotification();
+ application.Render(0);
+ application.Render();
+ application.SendNotification();
+ drawTrace.Enable( false );
+
+ // geometry type is set as GL_POINTS
+ // no index buffer, call glDrawArrays,
+ DALI_TEST_EQUALS( drawTrace.CountMethod( "DrawArrays" ), 2, TEST_LOCATION);
+ out.str("");
+ out << GL_TRIANGLE_STRIP << ", " << 0 << ", " << numVertex;
+ DALI_TEST_EQUALS( drawTrace.TestMethodAndParams(1, "DrawArrays", out.str()), true, TEST_LOCATION);
+
+ DALI_TEST_EQUALS( geometry.GetGeometryType(), Geometry::TRIANGLE_STRIP, TEST_LOCATION);
+
+ /*****************************************************/
+ //TRIANGLE_FAN, no index buffer
+ geometry.SetGeometryType( Geometry::TRIANGLE_FAN );
+
+ drawTrace.Reset();
+ drawTrace.Enable(true);
+ application.SendNotification();
+ application.Render(0);
+ application.Render();
+ application.SendNotification();
+ drawTrace.Enable( false );
+
+ // geometry type is set as GL_POINTS
+ // no index buffer, call glDrawArrays,
+ DALI_TEST_EQUALS( drawTrace.CountMethod( "DrawArrays" ), 2, TEST_LOCATION);
+ out.str("");
+ out << GL_TRIANGLE_FAN << ", " << 0 << ", " << numVertex;
+ DALI_TEST_EQUALS( drawTrace.TestMethodAndParams(1, "DrawArrays", out.str()), true, TEST_LOCATION);
+
+ DALI_TEST_EQUALS( geometry.GetGeometryType(), Geometry::TRIANGLE_FAN, TEST_LOCATION);
+
END_TEST;
}
+int UtcDaliGeometrySetGetGeometryType02(void)
+{
+ TestApplication application;
+
+ tet_infoline("Test SetGeometryType and GetGeometryType: with index buffer");
+
+ unsigned int numVertex = 4u;
+ unsigned int numIndex = 3u; // 6 unsigned short
+ PropertyBuffer vertexBuffer = CreateVertexBuffer("aPosition", "aTexCoord" );
+ PropertyBuffer indexBuffer = CreateIndexBuffer( );
+
+ Geometry geometry = Geometry::New();
+ geometry.AddVertexBuffer( vertexBuffer );
+ geometry.SetIndexBuffer( indexBuffer );
+
+ Material material = CreateMaterial(1.f);
+ Renderer renderer = Renderer::New(geometry, material);
+ Actor actor = Actor::New();
+ actor.SetSize(Vector3::ONE * 100.f);
+ actor.AddRenderer(renderer);
+ Stage::GetCurrent().Add(actor);
+
+ TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
+ TraceCallStack& drawTrace = glAbstraction.GetDrawTrace();
+
+ /****************************************************/
+ // Default (TRIANGLES), no index buffer
+ drawTrace.Reset();
+ drawTrace.Enable(true);
+ application.SendNotification();
+ application.Render(0);
+ application.Render();
+ application.SendNotification();
+ drawTrace.Enable( false );
+
+ // Test the default geometry type is GL_TRIANGLE
+ DALI_TEST_EQUALS( drawTrace.CountMethod( "DrawElements" ), 2, TEST_LOCATION);
+ std::stringstream out;
+ out << GL_TRIANGLES << ", " << numIndex << ", " << GL_UNSIGNED_SHORT<<", "<<"indices";
+ DALI_TEST_EQUALS( drawTrace.TestMethodAndParams(1, "DrawElements", out.str()), true, TEST_LOCATION);
+
+ DALI_TEST_EQUALS( geometry.GetGeometryType(), Geometry::TRIANGLES, TEST_LOCATION);
+
+ /*********************************************************/
+ // LINES, no index buffer
+ geometry.SetGeometryType( Geometry::LINES );
+
+ drawTrace.Reset();
+ drawTrace.Enable(true);
+ application.SendNotification();
+ application.Render(0);
+ application.Render();
+ application.SendNotification();
+ drawTrace.Enable( false );
+
+ // geometry type is set as GL_LINES
+ DALI_TEST_EQUALS( drawTrace.CountMethod( "DrawElements" ), 2, TEST_LOCATION);
+ out.str("");
+ out << GL_LINES << ", " << numIndex << ", " << GL_UNSIGNED_SHORT<<", "<<"indices";
+ DALI_TEST_EQUALS( drawTrace.TestMethodAndParams(1, "DrawElements", out.str()), true, TEST_LOCATION);
+
+ DALI_TEST_EQUALS( geometry.GetGeometryType(), Geometry::LINES, TEST_LOCATION);
+
+ /*****************************************************/
+ //POINTS
+ geometry.SetGeometryType( Geometry::POINTS );
+
+ drawTrace.Reset();
+ drawTrace.Enable(true);
+ application.SendNotification();
+ application.Render(0);
+ application.Render();
+ application.SendNotification();
+ drawTrace.Enable( false );
+
+ // geometry type is set as GL_POINTS
+ // As Points does not use the index buffer, call glDrawArrays,
+ DALI_TEST_EQUALS( drawTrace.CountMethod( "DrawArrays" ), 2, TEST_LOCATION);
+ out.str("");
+ out << GL_POINTS << ", " << 0 << ", " << numVertex;
+ DALI_TEST_EQUALS( drawTrace.TestMethodAndParams(1, "DrawArrays", out.str()), true, TEST_LOCATION);
+
+ DALI_TEST_EQUALS( geometry.GetGeometryType(), Geometry::POINTS, TEST_LOCATION);
+
+ /*****************************************************/
+ //TRIANGLE_STRIP
+ geometry.SetGeometryType( Geometry::TRIANGLE_STRIP );
+
+ drawTrace.Reset();
+ drawTrace.Enable(true);
+ application.SendNotification();
+ application.Render(0);
+ application.Render();
+ application.SendNotification();
+ drawTrace.Enable( false );
+
+ // geometry type is set as GL_POINTS
+ DALI_TEST_EQUALS( drawTrace.CountMethod( "DrawElements" ), 2, TEST_LOCATION);
+ out.str("");
+ out << GL_TRIANGLE_STRIP << ", " << numIndex << ", " << GL_UNSIGNED_SHORT<<", "<<"indices";
+ DALI_TEST_EQUALS( drawTrace.TestMethodAndParams(1, "DrawElements", out.str()), true, TEST_LOCATION);
+
+ DALI_TEST_EQUALS( geometry.GetGeometryType(), Geometry::TRIANGLE_STRIP, TEST_LOCATION);
+
+ /*****************************************************/
+ //TRIANGLE_FAN
+ geometry.SetGeometryType( Geometry::TRIANGLE_FAN );
+
+ drawTrace.Reset();
+ drawTrace.Enable(true);
+ application.SendNotification();
+ application.Render(0);
+ application.Render();
+ application.SendNotification();
+ drawTrace.Enable( false );
+
+ // geometry type is set as GL_POINTS
+ DALI_TEST_EQUALS( drawTrace.CountMethod( "DrawElements" ), 2, TEST_LOCATION);
+ out.str("");
+ out << GL_TRIANGLE_FAN << ", " << numIndex << ", " << GL_UNSIGNED_SHORT<<", "<<"indices";
+ DALI_TEST_EQUALS( drawTrace.TestMethodAndParams(1, "DrawElements", out.str()), true, TEST_LOCATION);
+
+ DALI_TEST_EQUALS( geometry.GetGeometryType(), Geometry::TRIANGLE_FAN, TEST_LOCATION);
+
+ END_TEST;
+}
int UtcDaliGeometrySetGetRequireDepthTesting(void)
{
TestApplication application;
Shader shader = Shader::New("vertexSrc", "fragmentSrc");
Image image = BufferImage::New(32, 32, Pixel::RGBA8888);
- Sampler sampler = Sampler::New(image, "sTexture");
Material material = Material::New(shader);
- material.AddSampler( sampler );
+ material.AddTexture( image, "sTexture" );
Material materialCopy(material);
DALI_TEST_CHECK( materialCopy );
- DALI_TEST_EQUALS( materialCopy.GetSamplerAt(0), sampler, TEST_LOCATION );
END_TEST;
}
Shader shader = Shader::New("vertexSrc", "fragmentSrc");
Image image = BufferImage::New(32, 32, Pixel::RGBA8888);
- Sampler sampler = Sampler::New(image, "sTexture");
Material material = Material::New(shader);
- material.AddSampler( sampler );
Material material2;
DALI_TEST_CHECK( !material2 );
material2 = material;
DALI_TEST_CHECK( material2 );
- DALI_TEST_EQUALS( material2.GetSamplerAt(0), sampler, TEST_LOCATION );
END_TEST;
}
END_TEST;
}
-int UtcDaliMaterialAddSampler(void)
+int UtcDaliMaterialGetNumberOfTextures(void)
{
TestApplication application;
- tet_infoline("Test AddSampler(sampler)");
+ tet_infoline("Test GetNumberOfTextures()");
Image image = BufferImage::New(32, 32, Pixel::RGBA8888);
- Sampler sampler1 = Sampler::New(image, "sTexture1");
- Sampler sampler2 = Sampler::New(image, "sTexture2");
-
- Material material = CreateMaterial(0.5f);
-
- Geometry geometry = CreateQuadGeometry();
- Renderer renderer = Renderer::New( geometry, material );
- Actor actor = Actor::New();
- actor.AddRenderer(renderer);
- actor.SetParentOrigin( ParentOrigin::CENTER );
- actor.SetSize(400, 400);
- Stage::GetCurrent().Add( actor );
-
- TestGlAbstraction& gl = application.GetGlAbstraction();
- int textureUnit=-1;
-
- material.AddSampler( sampler1 );
- application.SendNotification();
- application.Render();
- DALI_TEST_CHECK( gl.GetUniformValue<int>( "sTexture1", textureUnit ) );
- DALI_TEST_EQUALS( textureUnit, 0, TEST_LOCATION );
-
- material.AddSampler( sampler2 );
- application.SendNotification();
- application.Render();
- DALI_TEST_CHECK( gl.GetUniformValue<int>( "sTexture2", textureUnit ) );
- DALI_TEST_EQUALS( textureUnit, 1, TEST_LOCATION );
-
- END_TEST;
-}
-
-int UtcDaliMaterialGetNumberOfSampler(void)
-{
- TestApplication application;
-
- tet_infoline("Test GetNumberOfSampler()");
-
- Image image = BufferImage::New(32, 32, Pixel::RGBA8888);
- Sampler sampler0 = Sampler::New(image, "sTexture0");
- Sampler sampler1 = Sampler::New(image, "sTexture1");
- Sampler sampler2 = Sampler::New(image, "sTexture2");
- Sampler sampler3 = Sampler::New(image, "sTexture3");
- Sampler sampler4 = Sampler::New(image, "sTexture4");
-
Material material = CreateMaterial(0.5f);
Geometry geometry = CreateQuadGeometry();
actor.SetSize(400, 400);
Stage::GetCurrent().Add( actor );
- material.AddSampler( sampler0 );
- material.AddSampler( sampler1 );
- DALI_TEST_EQUALS( material.GetNumberOfSamplers(), 2u, TEST_LOCATION );
+ material.AddTexture( image, "sTexture0" );
+ material.AddTexture( image, "sTexture1" );
+ DALI_TEST_EQUALS( material.GetNumberOfTextures(), 2u, TEST_LOCATION );
- material.AddSampler( sampler2 );
- material.AddSampler( sampler3 );
- material.AddSampler( sampler4 );
- DALI_TEST_EQUALS( material.GetNumberOfSamplers(), 5u, TEST_LOCATION );
+ material.AddTexture( image, "sTexture2" );
+ material.AddTexture( image, "sTexture3" );
+ material.AddTexture( image, "sTexture4" );
+ DALI_TEST_EQUALS( material.GetNumberOfTextures(), 5u, TEST_LOCATION );
- material.RemoveSampler(3); // remove sampler3
- DALI_TEST_EQUALS( material.GetNumberOfSamplers(), 4u, TEST_LOCATION );
+ material.RemoveTexture(3);
+ DALI_TEST_EQUALS( material.GetNumberOfTextures(), 4u, TEST_LOCATION );
- material.RemoveSampler(3); // remove sampler4
- material.RemoveSampler(0); // remove sampler0
- DALI_TEST_EQUALS( material.GetNumberOfSamplers(), 2u, TEST_LOCATION );
-
- END_TEST;
-}
-
-int UtcDaliMaterialRemoveSampler(void)
-{
- TestApplication application;
-
- tet_infoline("Test RemoveSampler(index)");
- Image image = BufferImage::New(32, 32, Pixel::RGBA8888);
- Sampler sampler1 = Sampler::New(image, "sTexture1");
- Sampler sampler2 = Sampler::New(image, "sTexture2");
-
- Material material = CreateMaterial(0.5f);
-
- Geometry geometry = CreateQuadGeometry();
- Renderer renderer = Renderer::New( geometry, material );
- Actor actor = Actor::New();
- actor.AddRenderer(renderer);
- actor.SetParentOrigin( ParentOrigin::CENTER );
- actor.SetSize(400, 400);
- Stage::GetCurrent().Add( actor );
-
- material.AddSampler( sampler1 );
- material.AddSampler( sampler2 );
-
- TestGlAbstraction& gl = application.GetGlAbstraction();
- int textureUnit=-1;
- application.SendNotification();
- application.Render();
- DALI_TEST_CHECK( gl.GetUniformValue<int>( "sTexture1", textureUnit ) );
- DALI_TEST_EQUALS( textureUnit, 0, TEST_LOCATION );
- DALI_TEST_CHECK( gl.GetUniformValue<int>( "sTexture2", textureUnit ) );
- DALI_TEST_EQUALS( textureUnit, 1, TEST_LOCATION );
-
- material.RemoveSampler(0); // remove sampler1
- application.SendNotification();
- application.Render();
- // Todo: test the sampler is removed from gl, cannot pass this test with current implementation
- //DALI_TEST_CHECK( ! gl.GetUniformValue<int>( "sTexture1", textureUnit ) );
- DALI_TEST_EQUALS( material.GetNumberOfSamplers(), 1u, TEST_LOCATION );
-
- material.RemoveSampler(0); // remove sampler2
- application.SendNotification();
- application.Render();
- // Todo: test the sampler is removed from gl, cannot pass this test with current implementation
- //DALI_TEST_CHECK( ! gl.GetUniformValue<int>( "sTexture2", textureUnit ) );
- DALI_TEST_EQUALS( material.GetNumberOfSamplers(), 0u, TEST_LOCATION );
-
- END_TEST;
-}
-
-int UtcDaliMaterialGetSamplerAt(void)
-{
- TestApplication application;
-
- tet_infoline("Test GetSamplerAt(index)");
-
- Image image = BufferImage::New(16, 16, Pixel::RGBA8888);
- Sampler sampler1 = Sampler::New(image, "sTexture1");
- Sampler sampler2 = Sampler::New(image, "sTexture2");
- Sampler sampler3 = Sampler::New(image, "sTexture3");
-
- Material material = CreateMaterial(0.5f);
- material.AddSampler( sampler1 );
- material.AddSampler( sampler2 );
- material.AddSampler( sampler3 );
-
- Geometry geometry = CreateQuadGeometry();
- Renderer renderer = Renderer::New( geometry, material );
- Actor actor = Actor::New();
- actor.AddRenderer(renderer);
- actor.SetParentOrigin( ParentOrigin::CENTER );
- actor.SetSize(400, 400);
- Stage::GetCurrent().Add( actor );
-
- application.SendNotification();
- application.Render();
-
- DALI_TEST_EQUALS( material.GetSamplerAt( 0 ), sampler1, TEST_LOCATION );
- DALI_TEST_EQUALS( material.GetSamplerAt( 1 ), sampler2, TEST_LOCATION );
- DALI_TEST_EQUALS( material.GetSamplerAt( 2 ), sampler3, TEST_LOCATION );
-
- Sampler sampler = material.GetSamplerAt( 1 );
- DALI_TEST_EQUALS( sampler.GetImage().GetWidth(), 16u, TEST_LOCATION );
+ material.RemoveTexture(3);
+ material.RemoveTexture(0);
+ DALI_TEST_EQUALS( material.GetNumberOfTextures(), 2u, TEST_LOCATION );
END_TEST;
}
Material material = Material::New(shader);
material.SetProperty(Material::Property::COLOR, Color::WHITE);
BufferImage image = BufferImage::New( 50, 50, Pixel::RGB888 );
- Sampler sampler = Sampler::New( image, "sTexture" );
- material.AddSampler( sampler );
+ material.AddTexture( image, "sTexture" );
Renderer renderer = Renderer::New( geometry, material );
Actor actor = Actor::New();
application.Render();
TraceCallStack& glEnableStack = glAbstraction.GetCullFaceTrace();
- std::ostringstream blendStr;
- blendStr << GL_BLEND;
- DALI_TEST_CHECK( ! glEnableStack.FindMethodAndParams( "Enable", blendStr.str().c_str() ) );
+ DALI_TEST_CHECK( ! glEnableStack.FindMethodAndParams( "Enable", "GL_BLEND" ) );
END_TEST;
}
Material material = Material::New(shader);
material.SetProperty(Material::Property::COLOR, Color::WHITE);
BufferImage image = BufferImage::New( 50, 50, Pixel::RGBA8888 );
- Sampler sampler = Sampler::New( image, "sTexture" );
- material.AddSampler( sampler );
+ material.AddTexture( image, "sTexture" );
Renderer renderer = Renderer::New( geometry, material );
Actor actor = Actor::New();
END_TEST;
}
-
-
int UtcDaliMaterialAnimatedProperty01(void)
{
TestApplication application;
END_TEST;
}
+
+
+int UtcDaliMaterialSetTextureUniformName01(void)
+{
+ TestApplication application;
+
+ Image image = BufferImage::New( 64, 64, Pixel::RGBA8888 );
+
+ Material material = CreateMaterial(1.0f);
+ material.AddTexture( image, "sTexture" );
+
+ int textureIndex = material.GetTextureIndex( "sTexture" );
+ DALI_TEST_EQUALS( textureIndex, 0, TEST_LOCATION );
+
+ material.SetTextureUniformName( 0, "sEffectTexture" );
+ textureIndex = material.GetTextureIndex( "sEffectTexture" );
+ DALI_TEST_EQUALS( textureIndex, 0, TEST_LOCATION );
+
+ Geometry geometry = CreateQuadGeometry();
+ Renderer renderer = Renderer::New( geometry, material );
+ Actor actor = Actor::New();
+ actor.AddRenderer(renderer);
+ actor.SetParentOrigin( ParentOrigin::CENTER );
+ actor.SetSize(400, 400);
+
+ Stage::GetCurrent().Add( actor );
+
+ TestGlAbstraction& gl = application.GetGlAbstraction();
+
+ application.SendNotification();
+ application.Render();
+
+ int textureUnit=-1;
+ DALI_TEST_CHECK( gl.GetUniformValue<int>( "sEffectTexture", textureUnit ) );
+ DALI_TEST_EQUALS( textureUnit, 0, TEST_LOCATION );
+
+ END_TEST;
+}
+
+int UtcDaliMaterialSetTextureUniformName02(void)
+{
+ TestApplication application;
+
+ Image image = BufferImage::New( 64, 64, Pixel::RGBA8888 );
+ Image image2 = BufferImage::New( 64, 64, Pixel::RGBA8888 );
+
+ Material material = CreateMaterial(1.0f);
+ material.AddTexture( image, "sTexture");
+ material.SetTextureUniformName( 0, "sEffectTexture" );
+ material.AddTexture( image2, "sTexture2");
+
+ int textureIndex = material.GetTextureIndex( "sEffectTexture" );
+ DALI_TEST_EQUALS( textureIndex, 0, TEST_LOCATION );
+
+ textureIndex = material.GetTextureIndex( "sTexture2" );
+ DALI_TEST_EQUALS( textureIndex, 1, TEST_LOCATION );
+
+ Geometry geometry = CreateQuadGeometry();
+ Renderer renderer = Renderer::New( geometry, material );
+ Actor actor = Actor::New();
+ actor.AddRenderer(renderer);
+ actor.SetParentOrigin( ParentOrigin::CENTER );
+ actor.SetSize(400, 400);
+
+ Stage::GetCurrent().Add( actor );
+
+ TestGlAbstraction& gl = application.GetGlAbstraction();
+
+ application.SendNotification();
+ application.Render();
+
+ int textureUnit=-1;
+ DALI_TEST_CHECK( gl.GetUniformValue<int>( "sEffectTexture", textureUnit ) );
+ DALI_TEST_EQUALS( textureUnit, 0, TEST_LOCATION );
+
+ DALI_TEST_CHECK( gl.GetUniformValue<int>( "sTexture2", textureUnit ) );
+ DALI_TEST_EQUALS( textureUnit, 1, TEST_LOCATION );
+
+ END_TEST;
+}
+
+int UtcDaliMaterialSetTextureAffectsTransparency(void)
+{
+ TestApplication application;
+
+ Image image = BufferImage::New( 64, 64, Pixel::RGBA8888 );
+
+ Material material = CreateMaterial(1.0f);
+ material.AddTexture( image, "sTexture" );
+
+ Geometry geometry = CreateQuadGeometry();
+ Renderer renderer = Renderer::New( geometry, material );
+ Actor actor = Actor::New();
+ actor.AddRenderer(renderer);
+ actor.SetParentOrigin( ParentOrigin::CENTER );
+ actor.SetSize(400, 400);
+ Stage::GetCurrent().Add( actor );
+
+ TestGlAbstraction& gl = application.GetGlAbstraction();
+
+ // Test SetAffectsTransparency( false )
+ material.SetTextureAffectsTransparency( 0, false );
+
+ gl.EnableCullFaceCallTrace(true);
+ application.SendNotification();
+ application.Render();
+
+ TraceCallStack& glEnableStack = gl.GetCullFaceTrace();
+ std::ostringstream blendStr;
+ blendStr << GL_BLEND;
+ DALI_TEST_CHECK( ! glEnableStack.FindMethodAndParams( "Enable", blendStr.str().c_str() ) );
+
+ // Test SetAffectsTransparency( true )
+ material.SetTextureAffectsTransparency( 0, true );
+
+ glEnableStack.Reset();
+ gl.EnableCullFaceCallTrace(true);
+ application.SendNotification();
+ application.Render();
+
+ DALI_TEST_CHECK( glEnableStack.FindMethodAndParams( "Enable", blendStr.str().c_str() ) );
+
+ END_TEST;
+}
+
+int UtcDaliMaterialAddTexture01(void)
+{
+ TestApplication application;
+
+ Image image = BufferImage::New( 64, 64, Pixel::RGBA8888 );
+
+ Material material = CreateMaterial(1.0f);
+ material.AddTexture( image, "sTexture");
+
+ Geometry geometry = CreateQuadGeometry();
+ Renderer renderer = Renderer::New( geometry, material );
+ Actor actor = Actor::New();
+ actor.AddRenderer(renderer);
+ actor.SetParentOrigin( ParentOrigin::CENTER );
+ actor.SetSize(400, 400);
+
+ Stage::GetCurrent().Add( actor );
+
+ TestGlAbstraction& gl = application.GetGlAbstraction();
+
+ TraceCallStack& texParameterTrace = gl.GetTexParameterTrace();
+ texParameterTrace.Reset();
+ texParameterTrace.Enable( true );
+ application.SendNotification();
+ application.Render();
+
+ int textureUnit=-1;
+ DALI_TEST_CHECK( gl.GetUniformValue<int>( "sTexture", textureUnit ) );
+ DALI_TEST_EQUALS( textureUnit, 0, TEST_LOCATION );
+
+ texParameterTrace.Enable( false );
+
+ // Verify gl state
+ // There are three calls to TexParameteri when the texture is first created
+ // as the texture is using default sampling parametrers there shouldn't be any more calls to TexParameteri
+ DALI_TEST_EQUALS( texParameterTrace.CountMethod( "TexParameteri" ), 3, TEST_LOCATION);
+
+ END_TEST;
+}
+
+int UtcDaliMaterialAddTexture02(void)
+{
+ TestApplication application;
+
+ Image image = BufferImage::New( 64, 64, Pixel::RGBA8888 );
+
+ Material material = CreateMaterial(1.0f);
+
+ Sampler sampler = Sampler::New();
+ sampler.SetFilterMode( FilterMode::NEAREST, FilterMode::NEAREST );
+ material.AddTexture( image, "sTexture", sampler );
+
+ Geometry geometry = CreateQuadGeometry();
+ Renderer renderer = Renderer::New( geometry, material );
+ Actor actor = Actor::New();
+ actor.AddRenderer(renderer);
+ actor.SetParentOrigin( ParentOrigin::CENTER );
+ actor.SetSize(400, 400);
+
+ Stage::GetCurrent().Add( actor );
+
+ TestGlAbstraction& gl = application.GetGlAbstraction();
+
+ TraceCallStack& texParameterTrace = gl.GetTexParameterTrace();
+ texParameterTrace.Reset();
+ texParameterTrace.Enable( true );
+ application.SendNotification();
+ application.Render();
+
+ int textureUnit=-1;
+ DALI_TEST_CHECK( gl.GetUniformValue<int>( "sTexture", textureUnit ) );
+ DALI_TEST_EQUALS( textureUnit, 0, TEST_LOCATION );
+
+ texParameterTrace.Enable( false );
+
+ // Verify gl state
+ // There are three calls to TexParameteri when the texture is first created
+ // Texture minification and magnification filters are now different than default so
+ //there should have been two extra TexParameteri calls to set the new filter mode
+ DALI_TEST_EQUALS( texParameterTrace.CountMethod( "TexParameteri" ), 4, TEST_LOCATION);
+
+ END_TEST;
+}
+
+int UtcDaliMaterialRemoveTexture(void)
+{
+ TestApplication application;
+
+ Image image = BufferImage::New( 64, 64, Pixel::RGBA8888 );
+
+ Material material = CreateMaterial(1.0f);
+ material.RemoveTexture(0);
+ DALI_TEST_EQUALS( material.GetNumberOfTextures(), 0, TEST_LOCATION );
+
+ material.RemoveTexture(1);
+ DALI_TEST_EQUALS( material.GetNumberOfTextures(), 0, TEST_LOCATION );
+
+ Sampler sampler = Sampler::New();
+ sampler.SetFilterMode( FilterMode::NEAREST, FilterMode::NEAREST );
+ material.AddTexture( image, "sTexture", sampler );
+ DALI_TEST_EQUALS( material.GetNumberOfTextures(), 1, TEST_LOCATION );
+
+ material.RemoveTexture(1);
+ DALI_TEST_EQUALS( material.GetNumberOfTextures(), 1, TEST_LOCATION );
+
+ material.RemoveTexture(0);
+ DALI_TEST_EQUALS( material.GetNumberOfTextures(), 0, TEST_LOCATION );
+
+ END_TEST;
+}
+
+int UtcDaliMaterialSetSampler(void)
+{
+ TestApplication application;
+
+ Image image = BufferImage::New( 64, 64, Pixel::RGBA8888 );
+
+ Material material = CreateMaterial(1.0f);
+ material.AddTexture( image, "sTexture");
+
+ Geometry geometry = CreateQuadGeometry();
+ Renderer renderer = Renderer::New( geometry, material );
+ Actor actor = Actor::New();
+ actor.AddRenderer(renderer);
+ actor.SetParentOrigin( ParentOrigin::CENTER );
+ actor.SetSize(400, 400);
+
+ Stage::GetCurrent().Add( actor );
+
+ TestGlAbstraction& gl = application.GetGlAbstraction();
+
+ TraceCallStack& texParameterTrace = gl.GetTexParameterTrace();
+ texParameterTrace.Reset();
+ texParameterTrace.Enable( true );
+ application.SendNotification();
+ application.Render();
+
+ int textureUnit=-1;
+ DALI_TEST_CHECK( gl.GetUniformValue<int>( "sTexture", textureUnit ) );
+ DALI_TEST_EQUALS( textureUnit, 0, TEST_LOCATION );
+
+ texParameterTrace.Enable( false );
+
+ // Verify gl state
+ // There are three calls to TexParameteri when the texture is first created
+ // as the texture is using default sampling parametrers there shouldn't be any more calls to TexParameteri
+ DALI_TEST_EQUALS( texParameterTrace.CountMethod( "TexParameteri" ), 3, TEST_LOCATION);
+
+ texParameterTrace.Reset();
+ texParameterTrace.Enable( true );
+
+ Sampler sampler = Sampler::New();
+ sampler.SetFilterMode( FilterMode::NEAREST, FilterMode::NEAREST );
+ material.SetTextureSampler(0, sampler );
+
+
+ application.SendNotification();
+ application.Render();
+
+ texParameterTrace.Enable( false );
+
+ // Verify gl state
+ //There should have been two calls to TexParameteri to set the new filtering mode
+ DALI_TEST_EQUALS( texParameterTrace.CountMethod( "TexParameteri" ), 2, TEST_LOCATION);
+
+
+ END_TEST;
+}
+
+int UtcDaliMaterialGetTextureIndex(void)
+{
+ TestApplication application;
+
+ Image image0 = BufferImage::New( 64, 64, Pixel::RGBA8888 );
+ Image image1 = BufferImage::New( 64, 64, Pixel::RGBA8888 );
+ Image image2 = BufferImage::New( 64, 64, Pixel::RGBA8888 );
+ Image image3 = BufferImage::New( 64, 64, Pixel::RGBA8888 );
+
+
+ Material material = CreateMaterial(1.0f);
+ material.AddTexture( image0, "sTexture0");
+ material.AddTexture( image1, "sTexture1");
+ material.AddTexture( image2, "sTexture2");
+ material.AddTexture( image3, "sTexture3");
+
+ int textureIndex = material.GetTextureIndex( "sTexture0" );
+ DALI_TEST_EQUALS( textureIndex, 0, TEST_LOCATION );
+
+ textureIndex = material.GetTextureIndex( "sTexture1" );
+ DALI_TEST_EQUALS( textureIndex, 1, TEST_LOCATION );
+
+ textureIndex = material.GetTextureIndex( "sTexture2" );
+ DALI_TEST_EQUALS( textureIndex, 2, TEST_LOCATION );
+
+ textureIndex = material.GetTextureIndex( "sTexture3" );
+ DALI_TEST_EQUALS( textureIndex, 3, TEST_LOCATION );
+
+ material.RemoveTexture(1);
+
+ textureIndex = material.GetTextureIndex( "sTexture0" );
+ DALI_TEST_EQUALS( textureIndex, 0, TEST_LOCATION );
+
+ textureIndex = material.GetTextureIndex( "sTexture2" );
+ DALI_TEST_EQUALS( textureIndex, 1, TEST_LOCATION );
+
+ textureIndex = material.GetTextureIndex( "sTexture3" );
+ DALI_TEST_EQUALS( textureIndex, 2, TEST_LOCATION );
+
+ END_TEST;
+}
#include <stdlib.h>
#include <unistd.h>
#include <dali/public-api/dali-core.h>
-#include <dali/devel-api/common/mutex.h>
+#include <dali/devel-api/threading/mutex.h>
+#include <dali/devel-api/threading/thread.h>
#include <dali-test-suite-utils.h>
using Dali::Mutex;
+using Dali::Thread;
int UtcDaliMutexSingleThread(void)
{
volatile bool gWorkerThreadWait = true;
volatile enum ThreadState { INIT, RUN, LOCKING, TERMINATE } gWorkerThreadState = INIT;
Mutex* volatile gGlobalValueMutex; // volatile pointer to a mutex object
-}
-void* WorkerThread1( void* ptr )
+
+class TestThread : public Thread
{
- gWorkerThreadState = RUN;
+ virtual void Run()
{
- Mutex::ScopedLock lock( *gGlobalValueMutex );
- gWorkerThreadState = LOCKING;
- gGlobalValue = -1;
- while( gWorkerThreadWait ) // wait till we can exit
+ gWorkerThreadState = RUN;
{
- usleep( 1 ); // 1 microsecond
+ Mutex::ScopedLock lock( *gGlobalValueMutex );
+ gWorkerThreadState = LOCKING;
+ gGlobalValue = -1;
+ while( gWorkerThreadWait ) // wait till we can exit
+ {
+ usleep( 1 ); // 1 microsecond
+ }
}
+ gWorkerThreadState = TERMINATE;
}
- gWorkerThreadState = TERMINATE;
- return NULL;
+};
}
int UtcDaliMutexMultiThread(void)
gGlobalValueMutex = new Dali::Mutex();
- pthread_t thread1;
+ TestThread thread1;
// initialize values
gGlobalValue = 0;
gWorkerThreadWait = true;
{
Mutex::ScopedLock lock( *gGlobalValueMutex );
DALI_TEST_EQUALS( true, gGlobalValueMutex->IsLocked(), TEST_LOCATION );
- pthread_create( &thread1, NULL, &WorkerThread1, NULL );
+ thread1.Start();
// wait till the thread is in run state
while( RUN != gWorkerThreadState )
{
usleep( 1 ); // 1 microsecond
}
DALI_TEST_EQUALS( false, gGlobalValueMutex->IsLocked(), TEST_LOCATION );
- void* exitValue;
- pthread_join( thread1, &exitValue );
+ thread1.Join();
END_TEST;
}
END_TEST;
}
-int UtcDaliPropertyBufferConstraint01(void)
-{
- TestApplication application;
-
- tet_infoline("Test that a non-uniform propertyBuffer property can be constrained");
-
- Shader shader = Shader::New("VertexSource", "FragmentSource");
- Material material = Material::New( shader );
- material.SetProperty(Material::Property::COLOR, Color::WHITE);
-
- PropertyBuffer propertyBuffer = CreatePropertyBuffer();
- Geometry geometry = CreateQuadGeometryFromBuffer(propertyBuffer);
- Renderer renderer = Renderer::New( geometry, material );
-
- Actor actor = Actor::New();
- actor.AddRenderer(renderer);
- actor.SetSize(400, 400);
- Stage::GetCurrent().Add(actor);
-
- Vector4 initialColor = Color::WHITE;
- Property::Index colorIndex = propertyBuffer.RegisterProperty( "uFadeColor", initialColor );
-
- application.SendNotification();
- application.Render(0);
- DALI_TEST_EQUALS( propertyBuffer.GetProperty<Vector4>(colorIndex), initialColor, TEST_LOCATION );
-
- // Apply constraint
- Constraint constraint = Constraint::New<Vector4>( propertyBuffer, colorIndex, TestConstraintNoBlue );
- constraint.Apply();
- application.SendNotification();
- application.Render(0);
-
- // Expect no blue component in either buffer - yellow
- DALI_TEST_EQUALS( propertyBuffer.GetProperty<Vector4>(colorIndex), Color::YELLOW, TEST_LOCATION );
- application.Render(0);
- DALI_TEST_EQUALS( propertyBuffer.GetProperty<Vector4>(colorIndex), Color::YELLOW, TEST_LOCATION );
-
- propertyBuffer.RemoveConstraints();
- propertyBuffer.SetProperty(colorIndex, Color::WHITE );
- application.SendNotification();
- application.Render(0);
- DALI_TEST_EQUALS( propertyBuffer.GetProperty<Vector4>(colorIndex), Color::WHITE, TEST_LOCATION );
-
- END_TEST;
-}
-
-int UtcDaliPropertyBufferConstraint02(void)
-{
- TestApplication application;
-
- tet_infoline("Test that a uniform map propertyBuffer property can be constrained");
-
- Shader shader = Shader::New( "VertexSource", "FragmentSource" );
- Material material = Material::New( shader );
- material.SetProperty(Material::Property::COLOR, Color::WHITE);
-
- PropertyBuffer propertyBuffer = CreatePropertyBuffer();
- Geometry geometry = CreateQuadGeometryFromBuffer(propertyBuffer);
- Renderer renderer = Renderer::New( geometry, material );
-
- Actor actor = Actor::New();
- actor.AddRenderer(renderer);
- actor.SetSize(400, 400);
- Stage::GetCurrent().Add(actor);
- application.SendNotification();
- application.Render(0);
-
- Vector4 initialColor = Color::WHITE;
- Property::Index colorIndex = propertyBuffer.RegisterProperty( "uFadeColor", initialColor );
-
- TestGlAbstraction& gl = application.GetGlAbstraction();
-
- application.SendNotification();
- application.Render(0);
-
- Vector4 actualValue(Vector4::ZERO);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, initialColor, TEST_LOCATION );
-
- // Apply constraint
- Constraint constraint = Constraint::New<Vector4>( propertyBuffer, colorIndex, TestConstraintNoBlue );
- constraint.Apply();
- application.SendNotification();
- application.Render(0);
-
- // Expect no blue component in either buffer - yellow
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::YELLOW, TEST_LOCATION );
-
- application.Render(0);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::YELLOW, TEST_LOCATION );
-
- propertyBuffer.RemoveConstraints();
- propertyBuffer.SetProperty(colorIndex, Color::WHITE );
- application.SendNotification();
- application.Render(0);
-
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::WHITE, TEST_LOCATION );
-
- END_TEST;
-}
-
-
-
-int UtcDaliPropertyBufferAnimatedProperty01(void)
-{
- TestApplication application;
-
- tet_infoline("Test that a non-uniform propertyBuffer property can be animated");
-
- Shader shader = Shader::New("VertexSource", "FragmentSource");
- Material material = Material::New( shader );
- material.SetProperty(Material::Property::COLOR, Color::WHITE);
-
- PropertyBuffer propertyBuffer = CreatePropertyBuffer();
- Geometry geometry = CreateQuadGeometryFromBuffer(propertyBuffer);
- Renderer renderer = Renderer::New( geometry, material );
-
- Actor actor = Actor::New();
- actor.AddRenderer(renderer);
- actor.SetSize(400, 400);
- Stage::GetCurrent().Add(actor);
-
- Vector4 initialColor = Color::WHITE;
- Property::Index colorIndex = propertyBuffer.RegisterProperty( "uFadeColor", initialColor );
-
- application.SendNotification();
- application.Render(0);
- DALI_TEST_EQUALS( propertyBuffer.GetProperty<Vector4>(colorIndex), initialColor, TEST_LOCATION );
-
- Animation animation = Animation::New(1.0f);
- KeyFrames keyFrames = KeyFrames::New();
- keyFrames.Add(0.0f, initialColor);
- keyFrames.Add(1.0f, Color::TRANSPARENT);
- animation.AnimateBetween( Property( propertyBuffer, colorIndex ), keyFrames );
- animation.Play();
-
- application.SendNotification();
- application.Render(500);
-
- DALI_TEST_EQUALS( propertyBuffer.GetProperty<Vector4>(colorIndex), Color::WHITE * 0.5f, TEST_LOCATION );
-
- application.Render(500);
-
- DALI_TEST_EQUALS( propertyBuffer.GetProperty<Vector4>(colorIndex), Color::TRANSPARENT, TEST_LOCATION );
-
- END_TEST;
-}
-
-int UtcDaliPropertyBufferAnimatedProperty02(void)
-{
- TestApplication application;
-
- tet_infoline("Test that a uniform map propertyBuffer property can be animated");
-
- Shader shader = Shader::New("VertexSource", "FragmentSource");
- Material material = Material::New( shader );
- material.SetProperty(Material::Property::COLOR, Color::WHITE);
-
- PropertyBuffer propertyBuffer = CreatePropertyBuffer();
- Geometry geometry = CreateQuadGeometryFromBuffer(propertyBuffer);
- Renderer renderer = Renderer::New( geometry, material );
-
- Actor actor = Actor::New();
- actor.AddRenderer(renderer);
- actor.SetSize(400, 400);
- Stage::GetCurrent().Add(actor);
- application.SendNotification();
- application.Render(0);
-
- Vector4 initialColor = Color::WHITE;
- Property::Index colorIndex = propertyBuffer.RegisterProperty( "uFadeColor", initialColor );
-
- TestGlAbstraction& gl = application.GetGlAbstraction();
-
- application.SendNotification();
- application.Render(0);
-
- Vector4 actualValue(Vector4::ZERO);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, initialColor, TEST_LOCATION );
-
- Animation animation = Animation::New(1.0f);
- KeyFrames keyFrames = KeyFrames::New();
- keyFrames.Add(0.0f, initialColor);
- keyFrames.Add(1.0f, Color::TRANSPARENT);
- animation.AnimateBetween( Property( propertyBuffer, colorIndex ), keyFrames );
- animation.Play();
-
- application.SendNotification();
- application.Render(500);
-
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::WHITE * 0.5f, TEST_LOCATION );
-
- application.Render(500);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::TRANSPARENT, TEST_LOCATION );
-
- END_TEST;
-}
-
int UtcDaliPropertyBufferSetData01(void)
{
TestApplication application;
int size = 5u;
PropertyBuffer propertyBuffer = PropertyBuffer::New( texturedQuadVertexFormat, size );
- DALI_TEST_EQUALS( propertyBuffer.GetProperty<int>(PropertyBuffer::Property::SIZE), size, TEST_LOCATION );
+ DALI_TEST_EQUALS( propertyBuffer.GetSize(), size, TEST_LOCATION );
DALI_TEST_EQUALS( propertyBuffer.GetSize(), size, TEST_LOCATION );
size += 3u;
propertyBuffer.SetSize( size );
- DALI_TEST_EQUALS( propertyBuffer.GetProperty<int>(PropertyBuffer::Property::SIZE), size, TEST_LOCATION );
+ DALI_TEST_EQUALS( propertyBuffer.GetSize(), size, TEST_LOCATION );
DALI_TEST_EQUALS( propertyBuffer.GetSize(), size, TEST_LOCATION );
size += 2u;
- propertyBuffer.SetProperty(PropertyBuffer::Property::SIZE, size );
+ propertyBuffer.SetSize( size );
DALI_TEST_EQUALS( propertyBuffer.GetSize(), size, TEST_LOCATION );
END_TEST;
tet_infoline("Test the uniform map precedence is applied properly");
Image image = BufferImage::New( 64, 64, Pixel::RGBA8888 );
- Sampler sampler = Sampler::New(image, "sTexture");
- sampler.SetUniformName( "sEffectTexture" );
Shader shader = Shader::New("VertexSource", "FragmentSource");
Material material = Material::New( shader );
- material.AddSampler( sampler );
+ material.AddTexture( image, "sTexture" );
material.SetProperty(Material::Property::COLOR, Color::WHITE);
PropertyBuffer vertexBuffer = CreatePropertyBuffer();
Property::Index materialFadeColorIndex = material.RegisterProperty( "uFadeColor", Color::BLUE );
- sampler.RegisterProperty( "uFadeColor", Color::CYAN );
shader.RegisterProperty( "uFadeColor", Color::MAGENTA );
geometry.RegisterProperty( "uFadeColor", Color::YELLOW );
- vertexBuffer.RegisterProperty( "uFadeColor", Color::BLACK );
-
-
TestGlAbstraction& gl = application.GetGlAbstraction();
application.SendNotification();
application.Render(0);
- // Expect that the renderer's fade color property is accessed
+ // Expect that the actor's fade color property is accessed
Vector4 actualValue(Vector4::ZERO);
DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::RED, TEST_LOCATION );
+ DALI_TEST_EQUALS( actualValue, Color::GREEN, TEST_LOCATION );
// Animate material's fade color property. Should be no change to uniform
Animation animation = Animation::New(1.0f);
application.Render(500);
DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::RED, TEST_LOCATION );
+ DALI_TEST_EQUALS( actualValue, Color::GREEN, TEST_LOCATION );
application.Render(500);
DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::RED, TEST_LOCATION );
+ DALI_TEST_EQUALS( actualValue, Color::GREEN, TEST_LOCATION );
END_TEST;
}
tet_infoline("Test the uniform map precedence is applied properly");
Image image = BufferImage::New( 64, 64, Pixel::RGBA8888 );
- Sampler sampler = Sampler::New(image, "sTexture");
- sampler.SetUniformName( "sEffectTexture" );
Shader shader = Shader::New("VertexSource", "FragmentSource");
Material material = Material::New( shader );
- material.AddSampler( sampler );
+ material.AddTexture( image, "sTexture" );
material.SetProperty(Material::Property::COLOR, Color::WHITE);
PropertyBuffer vertexBuffer = CreatePropertyBuffer();
Property::Index materialFadeColorIndex = material.RegisterProperty( "uFadeColor", Color::BLUE );
- sampler.RegisterProperty( "uFadeColor", Color::CYAN );
shader.RegisterProperty( "uFadeColor", Color::MAGENTA );
geometry.RegisterProperty( "uFadeColor", Color::YELLOW );
- vertexBuffer.RegisterProperty( "uFadeColor", Color::BLACK );
-
TestGlAbstraction& gl = application.GetGlAbstraction();
tet_infoline("Test the uniform map precedence is applied properly");
Image image = BufferImage::New( 64, 64, Pixel::RGBA8888 );
- Sampler sampler = Sampler::New(image, "sTexture");
- sampler.SetUniformName( "sEffectTexture" );
Shader shader = Shader::New("VertexSource", "FragmentSource");
Material material = Material::New( shader );
- material.AddSampler( sampler );
+ material.AddTexture( image, "sTexture" );
material.SetProperty(Material::Property::COLOR, Color::WHITE);
PropertyBuffer vertexBuffer = CreatePropertyBuffer();
material.RegisterProperty( "uFadeColor", Color::BLUE );
- sampler.RegisterProperty( "uFadeColor", Color::CYAN );
shader.RegisterProperty( "uFadeColor", Color::MAGENTA );
Property::Index geometryFadeColorIndex = geometry.RegisterProperty( "uFadeColor", Color::YELLOW );
- vertexBuffer.RegisterProperty( "uFadeColor", Color::BLACK );
+ geometry.RegisterProperty( "uFadeColor", Color::BLACK );
TestGlAbstraction& gl = application.GetGlAbstraction();
tet_infoline("Test the uniform map precedence is applied properly");
Image image = BufferImage::New( 64, 64, Pixel::RGBA8888 );
- Sampler sampler = Sampler::New(image, "sTexture");
- sampler.SetUniformName( "sEffectTexture" );
Shader shader = Shader::New("VertexSource", "FragmentSource");
Material material = Material::New( shader );
- material.AddSampler( sampler );
+ material.AddTexture( image, "sTexture" );
material.SetProperty(Material::Property::COLOR, Color::WHITE);
PropertyBuffer vertexBuffer = CreatePropertyBuffer();
application.Render(0);
// Don't add property / uniform map to renderer/actor/material
-
- sampler.RegisterProperty( "uFadeColor", Color::CYAN );
shader.RegisterProperty( "uFadeColor", Color::MAGENTA );
Property::Index geometryFadeColorIndex = geometry.RegisterProperty( "uFadeColor", Color::YELLOW );
- vertexBuffer.RegisterProperty( "uFadeColor", Color::BLACK );
+ geometry.RegisterProperty( "uFadeColor", Color::BLACK );
TestGlAbstraction& gl = application.GetGlAbstraction();
// Expect that the sampler's fade color property is accessed
Vector4 actualValue(Vector4::ZERO);
DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::CYAN, TEST_LOCATION );
+ DALI_TEST_EQUALS( actualValue, Color::MAGENTA, TEST_LOCATION );
// Animate geometry's fade color property. Should be no change to uniform
Animation animation = Animation::New(1.0f);
application.Render(500);
DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::CYAN, TEST_LOCATION );
+ DALI_TEST_EQUALS( actualValue, Color::MAGENTA, TEST_LOCATION );
application.Render(500);
DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::CYAN, TEST_LOCATION );
+ DALI_TEST_EQUALS( actualValue, Color::MAGENTA, TEST_LOCATION );
END_TEST;
}
tet_infoline("Test the uniform map precedence is applied properly");
Image image = BufferImage::New( 64, 64, Pixel::RGBA8888 );
- Sampler sampler = Sampler::New(image, "sTexture");
- sampler.SetUniformName( "sEffectTexture" );
Shader shader = Shader::New("VertexSource", "FragmentSource");
Material material = Material::New( shader );
- material.AddSampler( sampler );
material.SetProperty(Material::Property::COLOR, Color::WHITE);
PropertyBuffer vertexBuffer = CreatePropertyBuffer();
Property::Index geometryFadeColorIndex = geometry.RegisterProperty( "uFadeColor", Color::YELLOW );
- vertexBuffer.RegisterProperty( "uFadeColor", Color::BLACK );
+ geometry.RegisterProperty( "uFadeColor", Color::BLACK );
TestGlAbstraction& gl = application.GetGlAbstraction();
END_TEST;
}
-int UtcDaliRendererUniformMapPrecendence06(void)
-{
- TestApplication application;
-
- tet_infoline("Test the uniform map precedence is applied properly");
-
- Image image = BufferImage::New( 64, 64, Pixel::RGBA8888 );
- Sampler sampler = Sampler::New(image, "sTexture");
- sampler.SetUniformName( "sEffectTexture" );
-
- Shader shader = Shader::New("VertexSource", "FragmentSource");
- Material material = Material::New( shader );
- material.AddSampler( sampler );
- material.SetProperty(Material::Property::COLOR, Color::WHITE);
-
- PropertyBuffer vertexBuffer = CreatePropertyBuffer();
- Geometry geometry = CreateQuadGeometryFromBuffer(vertexBuffer);
- Renderer renderer = Renderer::New( geometry, material );
-
- Actor actor = Actor::New();
- actor.AddRenderer(renderer);
- actor.SetSize(400, 400);
- Stage::GetCurrent().Add(actor);
- application.SendNotification();
- application.Render(0);
-
- // Don't add property / uniform map to renderer/actor/material/sampler/shader
-
- geometry.RegisterProperty( "uFadeColor", Color::YELLOW );
-
- Property::Index vertexFadeColorIndex = vertexBuffer.RegisterProperty( "uFadeColor", Color::BLACK );
-
-
- TestGlAbstraction& gl = application.GetGlAbstraction();
-
- application.SendNotification();
- application.Render(0);
-
- // Expect that the geometry's fade color property is accessed
- Vector4 actualValue(Vector4::ZERO);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::YELLOW, TEST_LOCATION );
-
- // Animate vertex buffer's fade color property. Should be no change to uniform
- Animation animation = Animation::New(1.0f);
- KeyFrames keyFrames = KeyFrames::New();
- keyFrames.Add(0.0f, Color::WHITE);
- keyFrames.Add(1.0f, Color::TRANSPARENT);
- animation.AnimateBetween( Property( vertexBuffer, vertexFadeColorIndex ), keyFrames );
- animation.Play();
-
- application.SendNotification();
- application.Render(500);
-
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::YELLOW, TEST_LOCATION );
-
- application.Render(500);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::YELLOW, TEST_LOCATION );
-
- END_TEST;
-}
-
-int UtcDaliRendererUniformMapPrecendence07(void)
-{
- TestApplication application;
-
- tet_infoline("Test the uniform map precedence is applied properly");
-
- Image image = BufferImage::New( 64, 64, Pixel::RGBA8888 );
- Sampler sampler = Sampler::New(image, "sTexture");
- sampler.SetUniformName( "sEffectTexture" );
-
- Shader shader = Shader::New("VertexSource", "FragmentSource");
- Material material = Material::New( shader );
- material.AddSampler( sampler );
- material.SetProperty(Material::Property::COLOR, Color::WHITE);
-
- PropertyBuffer vertexBuffer = CreatePropertyBuffer();
- Geometry geometry = CreateQuadGeometryFromBuffer(vertexBuffer);
- Renderer renderer = Renderer::New( geometry, material );
-
- Actor actor = Actor::New();
- actor.AddRenderer(renderer);
- actor.SetSize(400, 400);
- Stage::GetCurrent().Add(actor);
- application.SendNotification();
- application.Render(0);
-
- // Don't add property / uniform map to renderer/actor/material/sampler/shader/geometry
-
- Property::Index vertexFadeColorIndex = vertexBuffer.RegisterProperty( "uFadeColor", Color::BLACK );
-
- TestGlAbstraction& gl = application.GetGlAbstraction();
-
- application.SendNotification();
- application.Render(0);
-
- // Expect that the vertex buffer's fade color property is accessed
- Vector4 actualValue(Vector4::ZERO);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::BLACK, TEST_LOCATION );
-
- // Animate vertex buffer's fade color property. Should change the uniform
- Animation animation = Animation::New(1.0f);
- KeyFrames keyFrames = KeyFrames::New();
- keyFrames.Add(0.0f, Color::WHITE);
- keyFrames.Add(1.0f, Color::TRANSPARENT);
- animation.AnimateBetween( Property( vertexBuffer, vertexFadeColorIndex ), keyFrames );
- animation.Play();
-
- application.SendNotification();
- application.Render(500);
-
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::WHITE*0.5f, TEST_LOCATION );
-
- application.Render(500);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::TRANSPARENT, TEST_LOCATION );
-
- END_TEST;
-}
-
-
int UtcDaliRendererUniformMapMultipleUniforms01(void)
{
TestApplication application;
tet_infoline("Test the uniform maps are collected from all objects (same type)");
Image image = BufferImage::New( 64, 64, Pixel::RGBA8888 );
- Sampler sampler = Sampler::New(image, "sTexture");
- sampler.SetUniformName( "sEffectTexture" );
Shader shader = Shader::New("VertexSource", "FragmentSource");
Material material = Material::New( shader );
- material.AddSampler( sampler );
material.SetProperty(Material::Property::COLOR, Color::WHITE);
PropertyBuffer vertexBuffer = CreatePropertyBuffer();
renderer.RegisterProperty( "uUniform1", Color::RED );
actor.RegisterProperty( "uUniform2", Color::GREEN );
material.RegisterProperty( "uUniform3", Color::BLUE );
- sampler.RegisterProperty( "uUniform4", Color::CYAN );
- shader.RegisterProperty( "uUniform5", Color::MAGENTA );
- geometry.RegisterProperty( "uUniform6", Color::YELLOW );
- vertexBuffer.RegisterProperty( "uUniform7", Color::BLACK );
-
+ shader.RegisterProperty( "uUniform4", Color::MAGENTA );
+ geometry.RegisterProperty( "uUniform5", Color::YELLOW );
TestGlAbstraction& gl = application.GetGlAbstraction();
DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uUniform3", uniform3Value ) );
DALI_TEST_EQUALS( uniform3Value, Color::BLUE, TEST_LOCATION );
- Vector4 uniform4Value(Vector4::ZERO);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uUniform4", uniform4Value ) );
- DALI_TEST_EQUALS( uniform4Value, Color::CYAN, TEST_LOCATION );
-
Vector4 uniform5Value(Vector4::ZERO);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uUniform5", uniform5Value ) );
+ DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uUniform4", uniform5Value ) );
DALI_TEST_EQUALS( uniform5Value, Color::MAGENTA, TEST_LOCATION );
Vector4 uniform6Value(Vector4::ZERO);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uUniform6", uniform6Value ) );
+ DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uUniform5", uniform6Value ) );
DALI_TEST_EQUALS( uniform6Value, Color::YELLOW, TEST_LOCATION );
- Vector4 uniform7Value(Vector4::ZERO);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uUniform7", uniform7Value ) );
- DALI_TEST_EQUALS( uniform7Value, Color::BLACK, TEST_LOCATION );
-
-
END_TEST;
}
tet_infoline("Test the uniform maps are collected from all objects (different types)");
Image image = BufferImage::New( 64, 64, Pixel::RGBA8888 );
- Sampler sampler = Sampler::New(image, "sTexture");
- sampler.SetUniformName( "sEffectTexture" );
Shader shader = Shader::New("VertexSource", "FragmentSource");
Material material = Material::New( shader );
- material.AddSampler( sampler );
material.SetProperty(Material::Property::COLOR, Color::WHITE);
PropertyBuffer vertexBuffer = CreatePropertyBuffer();
Property::Value value3(Vector3(0.5f, 0.5f, 1.0f));
material.RegisterProperty( "uFadePosition", value3);
- Property::Value value4(Vector2(0.5f, 1.0f));
- sampler.RegisterProperty( "uFadeUV", value4 );
-
Property::Value value5(Matrix3::IDENTITY);
shader.RegisterProperty( "uANormalMatrix", value5 );
Property::Value value6(Matrix::IDENTITY);
geometry.RegisterProperty( "uAWorldMatrix", value6 );
- Property::Value value7(7);
- vertexBuffer.RegisterProperty( "uAnotherFadeColor", value7 );
-
-
TestGlAbstraction& gl = application.GetGlAbstraction();
application.SendNotification();
DALI_TEST_CHECK( gl.GetUniformValue<Vector3>( "uFadePosition", uniform3Value ) );
DALI_TEST_EQUALS( uniform3Value, value3.Get<Vector3>(), TEST_LOCATION );
- Vector2 uniform4Value(Vector2::ZERO);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector2>( "uFadeUV", uniform4Value ) );
- DALI_TEST_EQUALS( uniform4Value, value4.Get<Vector2>(), TEST_LOCATION );
-
Matrix3 uniform5Value;
DALI_TEST_CHECK( gl.GetUniformValue<Matrix3>( "uANormalMatrix", uniform5Value ) );
DALI_TEST_EQUALS( uniform5Value, value5.Get<Matrix3>(), TEST_LOCATION );
DALI_TEST_CHECK( gl.GetUniformValue<Matrix>( "uAWorldMatrix", uniform6Value ) );
DALI_TEST_EQUALS( uniform6Value, value6.Get<Matrix>(), TEST_LOCATION );
- int uniform7Value = 0;
- DALI_TEST_CHECK( gl.GetUniformValue<int>( "uAnotherFadeColor", uniform7Value ) );
- DALI_TEST_EQUALS( uniform7Value, value7.Get<int>(), TEST_LOCATION );
-
END_TEST;
}
*
*/
+#include <unistd.h>
#include <dali/public-api/dali-core.h>
#include <dali-test-suite-utils.h>
int UtcDaliSamplerNew01(void)
{
TestApplication application;
-
- Image image = BufferImage::New( 64, 64, Pixel::RGBA8888 );
- Sampler sampler = Sampler::New(image, "sTexture");
+ Sampler sampler = Sampler::New();
DALI_TEST_EQUALS( (bool)sampler, true, TEST_LOCATION );
END_TEST;
tet_infoline("Testing Dali::Handle::Handle(const Handle&)");
// Initialize an object, ref count == 1
- Image image = BufferImage::New( 64, 64, Pixel::RGBA8888 );
- Sampler sampler = Sampler::New(image, "sTexture");
+ Sampler sampler = Sampler::New();
DALI_TEST_EQUALS(1, sampler.GetBaseObject().ReferenceCount(), TEST_LOCATION);
int UtcDaliSamplerDownCast01(void)
{
TestApplication application;
- Image image = BufferImage::New( 64, 64, Pixel::RGBA8888 );
- Sampler sampler = Sampler::New(image, "sTexture");
+ Sampler sampler = Sampler::New();
BaseHandle handle(sampler);
Sampler sampler2 = Sampler::DownCast(handle);
int UtcDaliSamplerAssignmentOperator(void)
{
TestApplication application;
-
- Image image = BufferImage::New( 64, 64, Pixel::RGBA8888 );
- Sampler sampler1 = Sampler::New(image, "sTexture");
+ Sampler sampler1 = Sampler::New();
Sampler sampler2;
DALI_TEST_CHECK(sampler1 == sampler2);
- sampler2 = Sampler::New(image, "sTexture");
+ sampler2 = Sampler::New();
DALI_TEST_CHECK(!(sampler1 == sampler2));
END_TEST;
}
-int UtcDaliSamplerSetUniformName01(void)
-{
- TestApplication application;
-
- Image image = BufferImage::New( 64, 64, Pixel::RGBA8888 );
- Sampler sampler = Sampler::New(image, "sTexture");
- sampler.SetUniformName( "sEffectTexture" );
-
- Material material = CreateMaterial(1.0f);
- material.AddSampler( sampler );
-
- Geometry geometry = CreateQuadGeometry();
- Renderer renderer = Renderer::New( geometry, material );
- Actor actor = Actor::New();
- actor.AddRenderer(renderer);
- actor.SetParentOrigin( ParentOrigin::CENTER );
- actor.SetSize(400, 400);
-
- Stage::GetCurrent().Add( actor );
-
- TestGlAbstraction& gl = application.GetGlAbstraction();
-
- application.SendNotification();
- application.Render();
-
- int textureUnit=-1;
- DALI_TEST_CHECK( gl.GetUniformValue<int>( "sEffectTexture", textureUnit ) );
- DALI_TEST_EQUALS( textureUnit, 0, TEST_LOCATION );
-
- END_TEST;
-}
-
-int UtcDaliSamplerSetUniformName02(void)
-{
- TestApplication application;
-
- Image image = BufferImage::New( 64, 64, Pixel::RGBA8888 );
- Image image2 = BufferImage::New( 64, 64, Pixel::RGBA8888 );
- Sampler sampler1 = Sampler::New(image, "sTexture");
- sampler1.SetUniformName( "sEffectTexture" );
-
- Sampler sampler2 = Sampler::New(image2, "sTexture2");
-
- Material material = CreateMaterial(1.0f);
- material.AddSampler( sampler1 );
- material.AddSampler( sampler2 );
-
- Geometry geometry = CreateQuadGeometry();
- Renderer renderer = Renderer::New( geometry, material );
- Actor actor = Actor::New();
- actor.AddRenderer(renderer);
- actor.SetParentOrigin( ParentOrigin::CENTER );
- actor.SetSize(400, 400);
-
- Stage::GetCurrent().Add( actor );
-
- TestGlAbstraction& gl = application.GetGlAbstraction();
-
- application.SendNotification();
- application.Render();
-
- int textureUnit=-1;
- DALI_TEST_CHECK( gl.GetUniformValue<int>( "sEffectTexture", textureUnit ) );
- DALI_TEST_EQUALS( textureUnit, 0, TEST_LOCATION );
-
- DALI_TEST_CHECK( gl.GetUniformValue<int>( "sTexture2", textureUnit ) );
- DALI_TEST_EQUALS( textureUnit, 1, TEST_LOCATION );
-
- END_TEST;
-}
-
-int UtcDaliSamplerSetGetImage(void)
-{
- TestApplication application;
-
- Image image1 = BufferImage::New( 64, 64, Pixel::RGBA8888 );
- Image image2 = BufferImage::New( 64, 64, Pixel::RGBA8888 );
- Sampler sampler = Sampler::New(image1, "sTexture");
-
- DALI_TEST_CHECK(image1 == sampler.GetImage());
-
- sampler.SetImage( image2 );
- DALI_TEST_CHECK(!(image1 == sampler.GetImage()));
- DALI_TEST_CHECK(image2 == sampler.GetImage());
-
- END_TEST;
-}
int UtcSamplerSetFilterMode(void)
{
TestApplication application;
Image image = BufferImage::New( 64, 64, Pixel::RGBA8888 );
- Sampler sampler = Sampler::New(image, "sTexture");
+ Sampler sampler = Sampler::New();
Material material = CreateMaterial(1.0f);
- material.AddSampler( sampler );
+ material.AddTexture( image, "sTexture", sampler );
Geometry geometry = CreateQuadGeometry();
Renderer renderer = Renderer::New( geometry, material );
actor.SetSize(400, 400);
Stage::GetCurrent().Add( actor );
- float initialValue = 1.0f;
- sampler.RegisterProperty("uWidthClamp", initialValue );
TestGlAbstraction& gl = application.GetGlAbstraction();
texParameterTrace.Reset();
texParameterTrace.Enable( true );
- sampler.SetFilterMode( Sampler::DEFAULT, Sampler::DEFAULT );
+ sampler.SetFilterMode( FilterMode::DEFAULT, FilterMode::DEFAULT );
application.SendNotification();
application.Render();
// Verify gl state
- // There are two calls to TexParameteri when the texture is first created
+ // There are three calls to TexParameteri when the texture is first created
// Texture mag filter is not called as the first time set it uses the system default
DALI_TEST_EQUALS( texParameterTrace.CountMethod( "TexParameteri" ), 3, TEST_LOCATION);
texParameterTrace.Reset();
texParameterTrace.Enable( true );
- sampler.SetFilterMode( Sampler::DEFAULT, Sampler::DEFAULT );
+ sampler.SetFilterMode( FilterMode::DEFAULT, FilterMode::DEFAULT );
// Flush the queue and render once
application.SendNotification();
texParameterTrace.Reset();
texParameterTrace.Enable( true );
- sampler.SetFilterMode( Sampler::NEAREST, Sampler::NEAREST );
+ sampler.SetFilterMode( FilterMode::NEAREST, FilterMode::NEAREST );
// Flush the queue and render once
application.SendNotification();
out << GL_TEXTURE_2D << ", " << GL_TEXTURE_MAG_FILTER << ", " << GL_NEAREST;
DALI_TEST_EQUALS( texParameterTrace.TestMethodAndParams(1, "TexParameteri", out.str()), true, TEST_LOCATION);
+
/**************************************************************/
// Nearest/Linear
texParameterTrace.Reset();
texParameterTrace.Enable( true );
- sampler.SetFilterMode( Sampler::NEAREST, Sampler::LINEAR );
+ sampler.SetFilterMode( FilterMode::NEAREST, FilterMode::LINEAR );
// Flush the queue and render once
application.SendNotification();
texParameterTrace.Reset();
texParameterTrace.Enable( true );
- sampler.SetFilterMode( Sampler::NONE, Sampler::NONE );
+ sampler.SetFilterMode( FilterMode::NONE, FilterMode::NONE );
// Flush the queue and render once
application.SendNotification();
TestApplication application;
Image image = BufferImage::New( 64, 64, Pixel::RGBA8888 );
- Sampler sampler = Sampler::New(image, "sTexture");
-
Material material = CreateMaterial(1.0f);
- material.AddSampler( sampler );
+ Sampler sampler = Sampler::New();
+ material.AddTexture( image, "sTexture", sampler );
Geometry geometry = CreateQuadGeometry();
Renderer renderer = Renderer::New( geometry, material );
// Verify gl state
- // There are two calls to TexParameteri when the texture is first created
+ // There are three calls to TexParameteri when the texture is first created
// Texture mag filter is not called as the first time set it uses the system default
DALI_TEST_EQUALS( texParameterTrace.CountMethod( "TexParameteri" ), 3, TEST_LOCATION);
texParameterTrace.Reset();
texParameterTrace.Enable( true );
- sampler.SetWrapMode( Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE );
+ sampler.SetWrapMode( WrapMode::CLAMP_TO_EDGE, WrapMode::CLAMP_TO_EDGE );
// Flush the queue and render once
application.SendNotification();
END_TEST;
}
-
-int UtcSamplerSetAffectsTransparency(void)
-{
- TestApplication application;
-
- Image image = BufferImage::New( 64, 64, Pixel::RGBA8888 );
- Sampler sampler = Sampler::New(image, "sTexture");
-
- Material material = CreateMaterial(1.0f);
- material.AddSampler( sampler );
-
- Geometry geometry = CreateQuadGeometry();
- Renderer renderer = Renderer::New( geometry, material );
- Actor actor = Actor::New();
- actor.AddRenderer(renderer);
- actor.SetParentOrigin( ParentOrigin::CENTER );
- actor.SetSize(400, 400);
- Stage::GetCurrent().Add( actor );
-
- TestGlAbstraction& gl = application.GetGlAbstraction();
-
- // Test SetAffectsTransparency( false )
- sampler.SetAffectsTransparency( false );
-
- gl.EnableCullFaceCallTrace(true);
- application.SendNotification();
- application.Render();
-
- TraceCallStack& glEnableStack = gl.GetCullFaceTrace();
- std::ostringstream blendStr;
- blendStr << GL_BLEND;
- DALI_TEST_CHECK( ! glEnableStack.FindMethodAndParams( "Enable", blendStr.str().c_str() ) );
-
- // Test SetAffectsTransparency( true )
- sampler.SetAffectsTransparency( true );
-
- glEnableStack.Reset();
- gl.EnableCullFaceCallTrace(true);
- application.SendNotification();
- application.Render();
-
- DALI_TEST_CHECK( glEnableStack.FindMethodAndParams( "Enable", blendStr.str().c_str() ) );
-
- END_TEST;
-}
--- /dev/null
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <iostream>
+#include <stdlib.h>
+#include <unistd.h>
+#include <dali-test-suite-utils.h>
+#include <dali/devel-api/threading/thread.h>
+
+using Dali::Thread;
+
+namespace
+{
+volatile bool gRunThreadEntryFunc = false;
+
+class TestThread : public Thread
+{
+ virtual void Run()
+ {
+ gRunThreadEntryFunc = true;
+ }
+};
+}
+
+int UtcDaliThreadP(void)
+{
+ tet_infoline("Testing Dali::Thread");
+
+ gRunThreadEntryFunc = false;
+
+ TestThread thread;
+
+ thread.Start();
+ // wait till the thread is terminated
+ while( !gRunThreadEntryFunc )
+ {
+ usleep( 1 ); // 1 microsecond
+ }
+ DALI_TEST_EQUALS( true, gRunThreadEntryFunc, TEST_LOCATION );
+
+ thread.Join();
+
+ // Restart the thread after joined
+ gRunThreadEntryFunc = false;
+ thread.Start();
+ thread.Join();
+ // wait till the thread is terminated
+ while( !gRunThreadEntryFunc )
+ {
+ usleep( 1 ); // 1 microsecond
+ }
+ DALI_TEST_EQUALS( true, gRunThreadEntryFunc, TEST_LOCATION );
+
+ END_TEST;
+}
+
+int UtcDaliThreadNonCopyable(void)
+{
+ // we want to make sure that mutex is not copyable (its copy constructor is not defined)
+ // this test will stop compiling if Mutex has compiler generated copy constructor
+ DALI_COMPILE_TIME_ASSERT( !__has_trivial_copy( Thread ) );
+
+ DALI_TEST_CHECK( true );
+ END_TEST;
+}
BufferImage image = BufferImage::New( pixelBuffer, 1, 1 );
Geometry geometry = CreateGeometry();
- Material material = Material::New( Shader::New( VERTEX_SHADER, FRAGMENT_SHADER ) );
- Sampler sampler = Sampler::New( image, "sTexture" );
- material.AddSampler( sampler );
+ Material material = Material::New( Shader::New( VERTEX_SHADER, FRAGMENT_SHADER, shaderHints ) );
+ material.AddTexture( image, "sTexture" );
Renderer renderer = Renderer::New( geometry, material );
Actor meshActor = Actor::New();
END_TEST;
}
-int UtcDaliInternalAllocateBitmapImage01(void)
-{
- TestApplication application;
- tet_infoline("Testing AllocateBitmapImage()");
- testTicketObserver.Reset();
-
- Internal::ResourceClient& resourceClient = Internal::ThreadLocalStorage::Get().GetResourceClient();
- Internal::ImageTicketPtr imageTicket = resourceClient.AllocateBitmapImage(80, 80, 80, 80, Pixel::RGB565);
- imageTicket->AddObserver( testTicketObserver );
-
- DALI_TEST_CHECK( imageTicket );
- DALI_TEST_EQUALS ( imageTicket->GetLoadingState(), ResourceLoadingSucceeded, TEST_LOCATION );
- DALI_TEST_EQUALS ( imageTicket->GetWidth(), 80, TEST_LOCATION );
- DALI_TEST_EQUALS ( imageTicket->GetHeight(), 80, TEST_LOCATION );
-
- application.SendNotification(); // Flush update queue
- application.Render(0); // Process message
- application.SendNotification(); // Send message to tickets
-
- DALI_TEST_CHECK ( 0 == testTicketObserver.LoadSucceededCalled() ); // Check no message was sent
- DALI_TEST_EQUALS ( imageTicket->GetLoadingState(), ResourceLoadingSucceeded, TEST_LOCATION );
- DALI_TEST_EQUALS ( imageTicket->GetWidth(), 80, TEST_LOCATION );
- DALI_TEST_EQUALS ( imageTicket->GetHeight(), 80, TEST_LOCATION );
-
- Integration::Bitmap* bitmap = resourceClient.GetBitmap(imageTicket);
- DALI_TEST_CHECK ( bitmap != NULL );
- DALI_TEST_EQUALS ( bitmap->GetImageWidth(), 80u, TEST_LOCATION );
- DALI_TEST_EQUALS ( bitmap->GetImageHeight(), 80u, TEST_LOCATION );
- DALI_TEST_EQUALS ( bitmap->GetPackedPixelsProfile()->GetBufferWidth(), 80u, TEST_LOCATION );
- DALI_TEST_EQUALS ( bitmap->GetPackedPixelsProfile()->GetBufferHeight(), 80u, TEST_LOCATION );
- DALI_TEST_EQUALS ( bitmap->GetPixelFormat(), Pixel::RGB565, TEST_LOCATION );
- END_TEST;
-}
-
int UtcDaliInternalAddBitmapImage01(void)
{
TestApplication application;
DALI_TEST_EQUALS ( imageTicket->GetLoadingState(), ResourceLoadingSucceeded, TEST_LOCATION );
DALI_TEST_EQUALS ( imageTicket->GetWidth(), 80, TEST_LOCATION );
DALI_TEST_EQUALS ( imageTicket->GetHeight(), 80, TEST_LOCATION );
-
- Integration::Bitmap* theBitmap = resourceClient.GetBitmap(imageTicket);
- DALI_TEST_CHECK ( theBitmap != NULL );
- DALI_TEST_CHECK ( bitmap == theBitmap );
- DALI_TEST_EQUALS ( bitmap->GetImageWidth(), 80u, TEST_LOCATION );
- DALI_TEST_EQUALS ( bitmap->GetImageHeight(), 80u, TEST_LOCATION );
- DALI_TEST_EQUALS ( bitmap->GetPackedPixelsProfile()->GetBufferWidth(), 80u, TEST_LOCATION );
- DALI_TEST_EQUALS ( bitmap->GetPackedPixelsProfile()->GetBufferHeight(), 80u, TEST_LOCATION );
- DALI_TEST_EQUALS ( bitmap->GetPixelFormat(), Pixel::RGB565, TEST_LOCATION );
END_TEST;
}
DALI_TEST_EQUALS ( imageTicket->GetWidth(), 0, TEST_LOCATION );
DALI_TEST_EQUALS ( imageTicket->GetHeight(), 0, TEST_LOCATION );
DALI_TEST_CHECK ( 0 == testTicketObserver.LoadSucceededCalled() ); // Check no message was sent
-
- Integration::Bitmap* theBitmap = resourceClient.GetBitmap(imageTicket);
- DALI_TEST_CHECK ( theBitmap != NULL );
- DALI_TEST_CHECK ( bitmap == theBitmap );
- DALI_TEST_EQUALS ( bitmap->GetImageWidth(), 0u, TEST_LOCATION );
- DALI_TEST_EQUALS ( bitmap->GetImageHeight(), 0u, TEST_LOCATION );
- DALI_TEST_EQUALS ( bitmap->GetPackedPixelsProfile()->GetBufferWidth(), 0u, TEST_LOCATION );
- DALI_TEST_EQUALS ( bitmap->GetPackedPixelsProfile()->GetBufferHeight(), 0u, TEST_LOCATION );
- DALI_TEST_EQUALS ( bitmap->GetPixelFormat(), Pixel::RGBA8888, TEST_LOCATION );
-
- // There is no way for the ticket's image attributes to be updated if the bitmap
- // reserves a buffer after ticket generation.
- // Probably not an issue - there is no public API in BufferImage to change the image size.
END_TEST;
}
END_TEST;
}
-int UtcDaliInternalGetBitmapImage01(void)
-{
- TestApplication application;
- tet_infoline("Testing GetBitmap() with valid ticket");
- testTicketObserver.Reset();
-
- Internal::ResourceClient& resourceClient = Internal::ThreadLocalStorage::Get().GetResourceClient();
- Integration::Bitmap* bitmap = Integration::Bitmap::New( Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_RETAIN );
- bitmap->GetPackedPixelsProfile()->ReserveBuffer( Pixel::RGBA8888, 20, 20, 80, 80 );
- Internal::ImageTicketPtr imageTicket = resourceClient.AddBitmapImage( bitmap );
-
- Integration::Bitmap* theBitmap = resourceClient.GetBitmap(imageTicket);
- DALI_TEST_CHECK ( theBitmap != NULL );
- DALI_TEST_CHECK ( bitmap == theBitmap );
- DALI_TEST_EQUALS ( bitmap->GetImageWidth(), 20u, TEST_LOCATION );
- DALI_TEST_EQUALS ( bitmap->GetImageHeight(), 20u, TEST_LOCATION );
- DALI_TEST_EQUALS ( bitmap->GetPackedPixelsProfile()->GetBufferWidth(), 80u, TEST_LOCATION );
- DALI_TEST_EQUALS ( bitmap->GetPackedPixelsProfile()->GetBufferHeight(), 80u, TEST_LOCATION );
- DALI_TEST_EQUALS ( bitmap->GetPixelFormat(), Pixel::RGBA8888, TEST_LOCATION );
-
- imageTicket->AddObserver( testTicketObserver );
- application.SendNotification(); // Flush update queue
- application.Render(0); // Process message
- application.SendNotification(); // Send message to tickets
-
- theBitmap = resourceClient.GetBitmap(imageTicket);
- DALI_TEST_CHECK ( theBitmap != NULL );
- DALI_TEST_CHECK ( bitmap == theBitmap );
- DALI_TEST_EQUALS ( bitmap->GetImageWidth(), 20u, TEST_LOCATION );
- DALI_TEST_EQUALS ( bitmap->GetImageHeight(), 20u, TEST_LOCATION );
- DALI_TEST_EQUALS ( bitmap->GetPackedPixelsProfile()->GetBufferWidth(), 80u, TEST_LOCATION );
- DALI_TEST_EQUALS ( bitmap->GetPackedPixelsProfile()->GetBufferHeight(), 80u, TEST_LOCATION );
- DALI_TEST_EQUALS ( bitmap->GetPixelFormat(), Pixel::RGBA8888, TEST_LOCATION );
- END_TEST;
-}
-
-int UtcDaliInternalGetBitmapImage02(void)
-{
- TestApplication application;
- tet_infoline("Testing GetBitmap() with invalid ticket");
-
- Internal::ResourceClient& resourceClient = Internal::ThreadLocalStorage::Get().GetResourceClient();
- Internal::ImageTicketPtr imageTicket;
- Integration::Bitmap* theBitmap = NULL;
- bool exceptionRaised = false;
- try
- {
- theBitmap = resourceClient.GetBitmap(imageTicket);
- } catch (DaliException& e)
- {
- exceptionRaised = true;
- }
- DALI_TEST_CHECK( exceptionRaised );
- DALI_TEST_CHECK( ! theBitmap );
- END_TEST;
-}
-
-int UtcDaliInternalGetBitmapImage03(void)
-{
- TestApplication application;
- tet_infoline("Testing GetBitmap() with valid ticket for incorrect type");
-
- Internal::ResourceClient& resourceClient = Internal::ThreadLocalStorage::Get().GetResourceClient(); Internal::ResourceTicketPtr imageTicket = CheckLoadBitmap( application, "Stuff.png", 100, 100 );
-
- Integration::Bitmap* theBitmap = NULL;
- theBitmap = resourceClient.GetBitmap(imageTicket);
- DALI_TEST_CHECK( ! theBitmap );
-
- END_TEST;
-}
-
int UtcDaliInternalAllocateTexture01(void)
{
TestApplication application;
DALI_TEST_EQUALS ( imageTicket->GetWidth(), 80, TEST_LOCATION );
DALI_TEST_EQUALS ( imageTicket->GetHeight(), 80, TEST_LOCATION );
DALI_TEST_CHECK ( 0 == testTicketObserver.LoadSucceededCalled() ); // Check no message was sent
-
- Integration::Bitmap* theBitmap = NULL;
- theBitmap = resourceClient.GetBitmap(imageTicket);
-
- DALI_TEST_CHECK ( theBitmap == NULL );
END_TEST;
}
DALI_TEST_EQUALS ( imageTicket->GetWidth(), 80, TEST_LOCATION );
DALI_TEST_EQUALS ( imageTicket->GetHeight(), 80, TEST_LOCATION );
DALI_TEST_CHECK ( 0 == testTicketObserver.LoadSucceededCalled() ); // Check no message was sent
-
- Integration::Bitmap* theBitmap = NULL;
- theBitmap = resourceClient.GetBitmap(imageTicket);
- DALI_TEST_CHECK ( theBitmap == NULL );
END_TEST;
}
color.a = opacity;
material.SetProperty(Material::Property::COLOR, color);
- Sampler sampler = Sampler::New( image, "sTexture" );
- material.AddSampler( sampler );
+ material.AddTexture( image, "sTexture" );
return material;
}
TestApplication application;
Actor actor = Actor::New();
- Vector3 vector(100.0f, 100.0f, 100.0f);
+ Vector3 vector(100.0f, 100.0f, 0.0f);
DALI_TEST_CHECK(vector != actor.GetCurrentSize());
application.SendNotification();
application.Render();
- DALI_TEST_CHECK(vector == actor.GetCurrentSize());
+ Vector3 vector2(actor.GetCurrentSize());
+ vector2.z = 0.0f;
+
+ DALI_TEST_CHECK(vector == vector2);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- Vector3 vector(100.0f, 100.0f, 100.0f);
+ Vector3 vector(100.0f, 100.0f, 0.0f);
DALI_TEST_CHECK(vector != actor.GetCurrentSize());
application.SendNotification();
application.Render();
- DALI_TEST_CHECK(vector == actor.GetCurrentSize());
+ Vector3 vector2(actor.GetCurrentSize());
+ vector2.z = 0.0f;
+
+ DALI_TEST_CHECK(vector == vector2);
END_TEST;
}
SignalReceived = false;
image.UploadedSignal().Connect( ImageUploaded );
- std::vector<GLuint> ids;
- ids.push_back(200);
- ids.push_back(201);
- ids.push_back(202);
- application.GetGlAbstraction().SetNextTextureIds(ids);
-
application.SendNotification();
application.Render(0);
application.Render(16);
DALI_TEST_CHECK( image.IsDataExternal() );
application.GetGlAbstraction().EnableTextureCallTrace(true);
- image.Update(RectArea(9,9,5,5)); // notify Core that the image has been updated
+ // Check that update in a frame will be properly uploaded
+ image.Update(RectArea(9,9,5,1)); // notify Core that the image has been updated
application.SendNotification();
application.Render(16);
const TraceCallStack& callStack = application.GetGlAbstraction().GetTextureTrace();
DALI_TEST_EQUALS( callStack.TestMethodAndParams(0, "TexSubImage2D", "9, 9, 5, 1"), true, TEST_LOCATION);
- DALI_TEST_EQUALS( callStack.TestMethodAndParams(1, "TexSubImage2D", "9, 10, 5, 1"), true, TEST_LOCATION);
- DALI_TEST_EQUALS( callStack.TestMethodAndParams(2, "TexSubImage2D", "9, 11, 5, 1"), true, TEST_LOCATION);
- DALI_TEST_EQUALS( callStack.TestMethodAndParams(3, "TexSubImage2D", "9, 12, 5, 1"), true, TEST_LOCATION);
- DALI_TEST_EQUALS( callStack.TestMethodAndParams(4, "TexSubImage2D", "9, 13, 5, 1"), true, TEST_LOCATION);
-
DALI_TEST_CHECK( SignalReceived == true );
SignalReceived = false;
END_TEST;
actor.SetShaderEffect( effect );
const float INVALID_SIZE = float(1u<<31);
- Vector3 vector( INVALID_SIZE, INVALID_SIZE, INVALID_SIZE );
+ Vector3 vector( INVALID_SIZE, INVALID_SIZE, 0.0f );
DALI_TEST_CHECK(vector != actor.GetCurrentSize());
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS(vector, actor.GetCurrentSize(), TEST_LOCATION );
+ Vector3 vector2(actor.GetCurrentSize());
+ vector2.z = 0.0f;
+
+ DALI_TEST_EQUALS(vector, vector2, TEST_LOCATION );
END_TEST;
}
/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
namespace {
-Integration::Bitmap* CreateBitmap( unsigned int imageHeight, unsigned int imageWidth, unsigned int initialColor, Pixel::Format pixelFormat )
+Integration::Bitmap* CreateBitmap( unsigned int imageWidth, unsigned int imageHeight, unsigned int initialColor, Pixel::Format pixelFormat )
{
Integration::Bitmap* bitmap = Integration::Bitmap::New( Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_RETAIN );
- Integration::PixelBuffer* pixbuffer = bitmap->GetPackedPixelsProfile()->ReserveBuffer( pixelFormat, imageWidth,imageHeight,imageWidth,imageHeight );
- unsigned int bytesPerPixel = GetBytesPerPixel( pixelFormat );
+ Integration::PixelBuffer* pixbuffer = bitmap->GetPackedPixelsProfile()->ReserveBuffer( pixelFormat, imageWidth, imageHeight, imageWidth, imageHeight );
+ unsigned int bytesPerPixel = GetBytesPerPixel( pixelFormat );
- memset( pixbuffer, initialColor , imageHeight*imageWidth*bytesPerPixel);
+ memset( pixbuffer, initialColor, imageHeight * imageWidth * bytesPerPixel );
return bitmap;
}
-void InitialiseRegionsToZeroAlpha( Integration::Bitmap* image, unsigned int imageWidth, unsigned int imageHeight, Pixel::Format pixelFormat )
+void InitialiseRegionsToZeroAlpha( Integration::Bitmap* image, unsigned int imageWidth, unsigned int imageHeight, Pixel::Format pixelFormat )
{
PixelBuffer* pixbuffer = image->GetBuffer();
- unsigned int bytesPerPixel = GetBytesPerPixel( pixelFormat );
+ unsigned int bytesPerPixel = GetBytesPerPixel( pixelFormat );
- for ( unsigned int row = 0; row < imageWidth; ++row )
+ for( unsigned int row = 0; row < imageWidth; ++row )
{
- unsigned int pixelOffset = (row*bytesPerPixel);
- pixbuffer[pixelOffset+3] = 0x00;
- pixelOffset += ( imageHeight-1 ) * imageWidth * bytesPerPixel;
- pixbuffer[pixelOffset+3] = 0x00;
+ unsigned int pixelOffset = row * bytesPerPixel;
+ pixbuffer[ pixelOffset + 3 ] = 0x00;
+ pixelOffset += ( imageHeight - 1 ) * imageWidth * bytesPerPixel;
+ pixbuffer[ pixelOffset + 3 ] = 0x00;
}
for ( unsigned int column = 0; column < imageHeight; ++column )
{
- unsigned int pixelOffset = (column*imageWidth*bytesPerPixel);
- pixbuffer[pixelOffset+3] = 0x00;
- pixelOffset += (imageWidth-1)*bytesPerPixel;
- pixbuffer[pixelOffset+3] = 0x00;
+ unsigned int pixelOffset = column * imageWidth * bytesPerPixel;
+ pixbuffer[ pixelOffset + 3 ] = 0x00;
+ pixelOffset += ( imageWidth -1 ) * bytesPerPixel;
+ pixbuffer[ pixelOffset + 3 ] = 0x00;
}
}
-void AddStretchRegionsToImage( Integration::Bitmap* image, unsigned int imageWidth, unsigned int imageHeight, const Vector4& requiredStretchBorder , Pixel::Format pixelFormat )
+void AddStretchRegionsToImage( Integration::Bitmap* image, unsigned int imageWidth, unsigned int imageHeight, const Vector4& requiredStretchBorder, Pixel::Format pixelFormat )
{
PixelBuffer* pixbuffer = image->GetBuffer();
- unsigned int bytesPerPixel = GetBytesPerPixel( pixelFormat );
+ unsigned int bytesPerPixel = GetBytesPerPixel( pixelFormat );
- for ( unsigned int column = requiredStretchBorder.x; column < imageWidth - requiredStretchBorder.z; ++column )
+ for( unsigned int column = requiredStretchBorder.x; column < imageWidth - requiredStretchBorder.z; ++column )
{
- unsigned int pixelOffset = (column*bytesPerPixel);
- pixbuffer[pixelOffset] = 0x00;
- pixbuffer[pixelOffset+1] = 0x00;
- pixbuffer[pixelOffset+2] = 0x00;
- pixbuffer[pixelOffset+3] = 0xFF;
+ unsigned int pixelOffset = column * bytesPerPixel;
+ pixbuffer[ pixelOffset ] = 0x00;
+ pixbuffer[ pixelOffset + 1 ] = 0x00;
+ pixbuffer[ pixelOffset + 2 ] = 0x00;
+ pixbuffer[ pixelOffset + 3 ] = 0xFF;
}
- for ( unsigned int row = requiredStretchBorder.y; row < imageHeight - requiredStretchBorder.w; ++row )
+ for( unsigned int row = requiredStretchBorder.y; row < imageHeight - requiredStretchBorder.w; ++row )
{
- unsigned int pixelOffset = (row*imageWidth*bytesPerPixel);
- pixbuffer[pixelOffset] = 0x00;
- pixbuffer[pixelOffset+1] = 0x00;
- pixbuffer[pixelOffset+2] = 0x00;
- pixbuffer[pixelOffset+3] = 0xFF;
+ unsigned int pixelOffset = row * imageWidth * bytesPerPixel;
+ pixbuffer[ pixelOffset ] = 0x00;
+ pixbuffer[ pixelOffset + 1 ] = 0x00;
+ pixbuffer[ pixelOffset + 2 ] = 0x00;
+ pixbuffer[ pixelOffset + 3 ] = 0xFF;
}
}
void AddChildRegionsToImage( Integration::Bitmap* image, unsigned int imageWidth, unsigned int imageHeight, const Vector4& requiredChildRegion, Pixel::Format pixelFormat )
{
PixelBuffer* pixbuffer = image->GetBuffer();
- unsigned int bytesPerPixel = GetBytesPerPixel( pixelFormat );
+ unsigned int bytesPerPixel = GetBytesPerPixel( pixelFormat );
Integration::Bitmap::PackedPixelsProfile* srcProfile = image->GetPackedPixelsProfile();
unsigned int bufferStride = srcProfile->GetBufferStride();
// Add bottom child region
- for ( unsigned int column = requiredChildRegion.x; column < imageWidth - requiredChildRegion.z; ++column )
+ for( unsigned int column = requiredChildRegion.x; column < imageWidth - requiredChildRegion.z; ++column )
{
- unsigned int pixelOffset = (column*bytesPerPixel);
- pixelOffset += ( imageHeight-1 ) * bufferStride;
- pixbuffer[pixelOffset] = 0x00;
- pixbuffer[pixelOffset+1] = 0x00;
- pixbuffer[pixelOffset+2] = 0x00;
- pixbuffer[pixelOffset+3] = 0xFF;
+ unsigned int pixelOffset = column * bytesPerPixel;
+ pixelOffset += ( imageHeight - 1 ) * bufferStride;
+ pixbuffer[ pixelOffset ] = 0x00;
+ pixbuffer[ pixelOffset + 1 ] = 0x00;
+ pixbuffer[ pixelOffset + 2 ] = 0x00;
+ pixbuffer[ pixelOffset + 3 ] = 0xFF;
}
// Add right child region
for ( unsigned int row = requiredChildRegion.y; row < imageHeight - requiredChildRegion.w; ++row )
{
- unsigned int pixelOffset = row*bufferStride + (imageWidth-1)*bytesPerPixel;
- pixbuffer[pixelOffset] = 0x00;
- pixbuffer[pixelOffset+1] = 0x00;
- pixbuffer[pixelOffset+2] = 0x00;
- pixbuffer[pixelOffset+3] = 0xFF;
+ unsigned int pixelOffset = row * bufferStride + ( imageWidth - 1 ) * bytesPerPixel;
+ pixbuffer[ pixelOffset ] = 0x00;
+ pixbuffer[ pixelOffset + 1 ] = 0x00;
+ pixbuffer[ pixelOffset + 2 ] = 0x00;
+ pixbuffer[ pixelOffset + 3 ] = 0xFF;
}
}
NinePatchImage CustomizeNinePatch( TestApplication& application,
- unsigned int ninePatchImageWidth,
- unsigned int ninePatchImageHeight,
- const Vector4& requiredStretchBorder,
- bool addChildRegion = false,
- Vector4 requiredChildRegion = Vector4::ZERO )
+ unsigned int ninePatchImageWidth,
+ unsigned int ninePatchImageHeight,
+ const Vector4& requiredStretchBorder,
+ bool addChildRegion = false,
+ Vector4 requiredChildRegion = Vector4::ZERO )
{
TestPlatformAbstraction& platform = application.GetPlatform();
DALI_TEST_CHECK( !image );
// initialise handle
- image = NinePatchImage::New("blah.#.png");
+ image = NinePatchImage::New( "blah.#.png" );
DALI_TEST_CHECK( image );
END_TEST;
TestApplication application;
tet_infoline("UtcDaliNinePatchImageDowncast - NinePatchImage::DownCast(BaseHandle)");
- NinePatchImage image = NinePatchImage::New("blah.#.png");
+ NinePatchImage image = NinePatchImage::New( "blah.#.png" );
- BaseHandle object(image);
+ BaseHandle object( image );
- NinePatchImage image2 = NinePatchImage::DownCast(object);
- DALI_TEST_CHECK(image2);
+ NinePatchImage image2 = NinePatchImage::DownCast( object );
+ DALI_TEST_CHECK( image2 );
- NinePatchImage image3 = DownCast< NinePatchImage >(object);
- DALI_TEST_CHECK(image3);
+ NinePatchImage image3 = DownCast< NinePatchImage >( object );
+ DALI_TEST_CHECK( image3 );
BaseHandle unInitializedObject;
- NinePatchImage image4 = NinePatchImage::DownCast(unInitializedObject);
- DALI_TEST_CHECK(!image4);
+ NinePatchImage image4 = NinePatchImage::DownCast( unInitializedObject );
+ DALI_TEST_CHECK( !image4 );
- NinePatchImage image5 = DownCast< NinePatchImage >(unInitializedObject);
- DALI_TEST_CHECK(!image5);
+ NinePatchImage image5 = DownCast< NinePatchImage >( unInitializedObject );
+ DALI_TEST_CHECK( !image5 );
- Image image6 = NinePatchImage::New("blah.#.png");
- NinePatchImage image7 = NinePatchImage::DownCast(image6);
- DALI_TEST_CHECK(image7);
+ Image image6 = NinePatchImage::New( "blah.#.png" );
+ NinePatchImage image7 = NinePatchImage::DownCast( image6 );
+ DALI_TEST_CHECK( image7 );
END_TEST;
}
NinePatchImage image1;
DALI_TEST_CHECK( !image1 );
- image1 = NinePatchImage::New("blah.#.png");
+ image1 = NinePatchImage::New( "blah.#.png" );
NinePatchImage image2( image1 );
DALI_TEST_CHECK( image2 );
* cccc
*/
- const unsigned int ninePatchImageHeight = 8;
- const unsigned int ninePatchImageWidth = 8;
- const Vector4 requiredStretchBorder( 3, 3, 3, 3);
+ const unsigned int ninePatchImageHeight = 18;
+ const unsigned int ninePatchImageWidth = 28;
+ const Vector4 requiredStretchBorder( 3, 4, 5, 6 );
- NinePatchImage ninePatchImage = CustomizeNinePatch( application,ninePatchImageWidth, ninePatchImageHeight, requiredStretchBorder );
+ NinePatchImage ninePatchImage = CustomizeNinePatch( application, ninePatchImageWidth, ninePatchImageHeight, requiredStretchBorder );
DALI_TEST_CHECK( ninePatchImage );
- if ( ninePatchImage )
+ if( ninePatchImage )
{
tet_infoline("Get Stretch regions from NinePatch");
- Vector4 stretchBorders = ninePatchImage.GetStretchBorders();
+
+ const NinePatchImage::StretchRanges& stretchPixelsX = ninePatchImage.GetStretchPixelsX();
+ const NinePatchImage::StretchRanges& stretchPixelsY = ninePatchImage.GetStretchPixelsY();
+
+ DALI_TEST_CHECK( stretchPixelsX.Size() == 1 );
+ DALI_TEST_CHECK( stretchPixelsY.Size() == 1 );
+
+ Vector4 stretchBorders;
+ //The NinePatchImage stretch pixels are in the cropped image space, inset by 1 to get it to uncropped image space
+ stretchBorders.x = stretchPixelsX[ 0 ].GetX() + 1;
+ stretchBorders.y = stretchPixelsY[ 0 ].GetX() + 1;
+ stretchBorders.z = ninePatchImageWidth - stretchPixelsX[ 0 ].GetY() - 1;
+ stretchBorders.w = ninePatchImageHeight - stretchPixelsY[ 0 ].GetY() - 1;
+
tet_printf("stretchBorders left(%f) right(%f) top(%f) bottom(%f)\n", stretchBorders.x, stretchBorders.z, stretchBorders.y, stretchBorders.w );
DALI_TEST_CHECK( stretchBorders == requiredStretchBorder );
}
* cccc
*/
- const unsigned int ninePatchImageHeight = 8;
- const unsigned int ninePatchImageWidth = 8;
+ const unsigned int ninePatchImageHeight = 18;
+ const unsigned int ninePatchImageWidth = 28;
const Vector4 requiredChildRegion( 2, 2, 2, 2 );
- const Vector4 requiredStretchBorder( 3, 3, 3, 3);
+ const Vector4 requiredStretchBorder( 3, 4, 5, 6 );
NinePatchImage ninePatchImage = CustomizeNinePatch( application,ninePatchImageWidth, ninePatchImageHeight, requiredStretchBorder, true, requiredChildRegion );
DALI_TEST_CHECK( ninePatchImage );
if ( ninePatchImage )
{
tet_infoline("Get Child regions from NinePatch");
- Rect<int> childRectangle = ninePatchImage.GetChildRectangle();
+ Rect< int > childRectangle = ninePatchImage.GetChildRectangle();
tet_printf("childRectange x(%d) y(%d) width(%d) height(%d)\n", childRectangle.x, childRectangle.y, childRectangle.width, childRectangle.height );
- Rect<int> childRegion(requiredChildRegion.x, requiredChildRegion.y, ninePatchImageWidth - requiredChildRegion.x - requiredChildRegion.z, ninePatchImageHeight - requiredChildRegion.y - requiredChildRegion.w );
+ Rect< int > childRegion(requiredChildRegion.x, requiredChildRegion.y, ninePatchImageWidth - requiredChildRegion.x - requiredChildRegion.z, ninePatchImageHeight - requiredChildRegion.y - requiredChildRegion.w );
DALI_TEST_CHECK( childRegion == childRectangle );
}
else
const unsigned int ninePatchImageHeight = 8;
const unsigned int ninePatchImageWidth = 8;
- const Vector4 requiredStretchBorder( 1,1,1,1);
+ const Vector4 requiredStretchBorder( 1, 1, 1, 1 );
- NinePatchImage ninePatchImage = CustomizeNinePatch( application,ninePatchImageWidth, ninePatchImageHeight, requiredStretchBorder );
+ NinePatchImage ninePatchImage = CustomizeNinePatch( application, ninePatchImageWidth, ninePatchImageHeight, requiredStretchBorder );
DALI_TEST_CHECK( ninePatchImage );
if ( ninePatchImage )
END_TEST;
}
+
+int UtcDaliNinePatchImageIsNinePatchUrl(void)
+{
+ TestApplication application;
+ tet_infoline("UtcDaliNinePatchImageIsNinePatchUrl - NinePatchImage::IsNinePatchUrl(const std::string&)");
+
+ DALI_TEST_CHECK( NinePatchImage::IsNinePatchUrl( "test.9.jpg" ) );
+ DALI_TEST_CHECK( NinePatchImage::IsNinePatchUrl( "test.#.jpg" ) );
+ DALI_TEST_CHECK( !NinePatchImage::IsNinePatchUrl( "test.9" ) );
+ DALI_TEST_CHECK( !NinePatchImage::IsNinePatchUrl( "test.#" ) );
+ DALI_TEST_CHECK( !NinePatchImage::IsNinePatchUrl( "test" ) );
+
+ END_TEST;
+}
return true;
}
-ImageActor CreateLoadingImage(TestApplication& application, std::string filename, ResourceImage::LoadPolicy loadPolicy, Image::ReleasePolicy releasePolicy)
+ImageActor CreateLoadingImageActor(TestApplication& application, std::string filename, ResourceImage::LoadPolicy loadPolicy, Image::ReleasePolicy releasePolicy)
{
Image image = ResourceImage::New(filename, loadPolicy, releasePolicy);
DALI_TEST_CHECK( image );
return actor;
}
-Sampler CreateSamplerWithLoadingImage(TestApplication& application, std::string filename, ResourceImage::LoadPolicy loadPolicy, Image::ReleasePolicy releasePolicy)
+Image CreateLoadingImage(TestApplication& application, std::string filename, ResourceImage::LoadPolicy loadPolicy, Image::ReleasePolicy releasePolicy)
{
Image image = ResourceImage::New(filename, loadPolicy, releasePolicy);
DALI_TEST_CHECK( image );
application.Render(16);
DALI_TEST_CHECK( application.GetPlatform().WasCalled(TestPlatformAbstraction::LoadResourceFunc) );
- Sampler sampler = Sampler::New( image, "sTexture" );
- application.SendNotification();
- application.Render(16);
- return sampler;
+ return image;
}
void CompleteImageLoad(TestApplication& application, Integration::ResourceId resourceId, Integration::ResourceTypeId requestType)
CameraActor offscreenCameraActor = CameraActor::New();
Stage::GetCurrent().Add( offscreenCameraActor );
- ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
+ ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
Integration::ResourceId imageRequestId = imageRequest->GetId();
Integration::ResourceTypeId imageType = imageRequest->GetType()->id;
CameraActor offscreenCameraActor = CameraActor::New();
Stage::GetCurrent().Add( offscreenCameraActor );
- ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
+ ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
Integration::ResourceId imageRequestId = imageRequest->GetId();
Integration::ResourceTypeId imageType = imageRequest->GetType()->id;
Stage::GetCurrent().Add( rootActor );
CameraActor offscreenCameraActor = CameraActor::New();
- ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
+ ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
Integration::ResourceId imageRequestId = imageRequest->GetId();
Integration::ResourceTypeId imageType = imageRequest->GetType()->id;
CameraActor offscreenCameraActor = CameraActor::New();
Stage::GetCurrent().Add( offscreenCameraActor );
- ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
+ ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
Integration::ResourceId imageRequestId = imageRequest->GetId();
Integration::ResourceTypeId imageType = imageRequest->GetType()->id;
Stage::GetCurrent().Add( offscreenCameraActor );
Material material = CreateMaterial(1.0f);
- Sampler sampler = CreateSamplerWithLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
+ Image image = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
Integration::ResourceId imageRequestId = imageRequest->GetId();
Integration::ResourceTypeId imageType = imageRequest->GetType()->id;
- material.AddSampler( sampler );
+ material.AddTexture( image, "sTexture" );
Geometry geometry = CreateQuadGeometry();
Renderer renderer = Renderer::New(geometry, material);
CameraActor offscreenCameraActor = CameraActor::New();
Stage::GetCurrent().Add( offscreenCameraActor );
- ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
+ ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
Integration::ResourceId imageRequestId = imageRequest->GetId();
Integration::ResourceTypeId imageType = imageRequest->GetType()->id;
Stage::GetCurrent().Add( offscreenCameraActor );
Material material = CreateMaterial(1.0f);
- Sampler sampler = CreateSamplerWithLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
+ Image image = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
Integration::ResourceId imageRequestId = imageRequest->GetId();
Integration::ResourceTypeId imageType = imageRequest->GetType()->id;
- material.AddSampler( sampler );
+ material.AddTexture( image, "sTexture" );
Geometry geometry = CreateQuadGeometry();
Renderer renderer = Renderer::New(geometry, material);
CameraActor offscreenCameraActor = CameraActor::New();
Stage::GetCurrent().Add( offscreenCameraActor );
- ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
+ ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
Integration::ResourceId imageRequestId = imageRequest->GetId();
Integration::ResourceTypeId imageType = imageRequest->GetType()->id;
Stage::GetCurrent().Add( offscreenCameraActor );
Material material = CreateMaterial(1.0f);
- Sampler sampler = CreateSamplerWithLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
+ Image image = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
Integration::ResourceId imageRequestId = imageRequest->GetId();
Integration::ResourceTypeId imageType = imageRequest->GetType()->id;
- material.AddSampler( sampler );
+ material.AddTexture( image, "sTexture" );
Geometry geometry = CreateQuadGeometry();
Renderer renderer = Renderer::New(geometry, material);
CameraActor offscreenCameraActor = CameraActor::New();
Stage::GetCurrent().Add( offscreenCameraActor );
- ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
+ ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
Integration::ResourceId imageRequestId = imageRequest->GetId();
Integration::ResourceTypeId imageType = imageRequest->GetType()->id;
CameraActor offscreenCameraActor = CameraActor::New();
Stage::GetCurrent().Add( offscreenCameraActor );
- ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
+ ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
Integration::ResourceId imageRequestId = imageRequest->GetId();
Integration::ResourceTypeId imageType = imageRequest->GetType()->id;
CameraActor offscreenCameraActor = CameraActor::New();
Stage::GetCurrent().Add( offscreenCameraActor );
- ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
+ ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
Integration::ResourceId imageRequestId = imageRequest->GetId();
Integration::ResourceTypeId imageType = imageRequest->GetType()->id;
CameraActor offscreenCameraActor = CameraActor::New();
Stage::GetCurrent().Add( offscreenCameraActor );
- ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
+ ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
Integration::ResourceId imageRequestId = imageRequest->GetId();
Integration::ResourceTypeId imageType = imageRequest->GetType()->id;
CameraActor offscreenCameraActor = CameraActor::New();
Stage::GetCurrent().Add( offscreenCameraActor );
- ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
+ ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
Integration::ResourceId imageRequestId = imageRequest->GetId();
Integration::ResourceTypeId imageType = imageRequest->GetType()->id;
CameraActor offscreenCameraActor = CameraActor::New();
Stage::GetCurrent().Add( offscreenCameraActor );
- ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
+ ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
Integration::ResourceId imageRequestId = imageRequest->GetId();
Stage::GetCurrent().Add(secondRootActor);
CameraActor offscreenCameraActor = CameraActor::New();
Stage::GetCurrent().Add( offscreenCameraActor );
- ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
+ ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
Integration::ResourceId imageRequestId = imageRequest->GetId();
Integration::ResourceTypeId imageType = imageRequest->GetType()->id;
Stage::GetCurrent().Add( offscreenCameraActor );
Material material = CreateMaterial(1.0f);
- Sampler sampler = CreateSamplerWithLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
+ Image image = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
Integration::ResourceId imageRequestId = imageRequest->GetId();
Integration::ResourceTypeId imageType = imageRequest->GetType()->id;
- material.AddSampler( sampler );
+ material.AddTexture(image, "sTexture" );
Geometry geometry = CreateQuadGeometry();
Renderer renderer = Renderer::New(geometry, material);
CameraActor offscreenCameraActor = CameraActor::New();
Stage::GetCurrent().Add( offscreenCameraActor );
- ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
+ ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
Integration::ResourceId imageRequestId = imageRequest->GetId();
Integration::ResourceTypeId imageType = imageRequest->GetType()->id;
Stage::GetCurrent().Add( offscreenCameraActor );
Material material = CreateMaterial(1.0f);
- Sampler sampler = CreateSamplerWithLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
+ Image image = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
Integration::ResourceId imageRequestId = imageRequest->GetId();
Integration::ResourceTypeId imageType = imageRequest->GetType()->id;
- material.AddSampler( sampler );
+ material.AddTexture( image, "sTexture" );
Geometry geometry = CreateQuadGeometry();
Renderer renderer = Renderer::New(geometry, material);
CameraActor offscreenCameraActor = CameraActor::New();
Stage::GetCurrent().Add( offscreenCameraActor );
- ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
+ ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
Integration::ResourceId imageRequestId = imageRequest->GetId();
Integration::ResourceTypeId imageType = imageRequest->GetType()->id;
CameraActor offscreenCameraActor = CameraActor::New();
Stage::GetCurrent().Add( offscreenCameraActor );
- ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
+ ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
Integration::ResourceId imageRequestId = imageRequest->GetId();
Integration::ResourceTypeId imageType = imageRequest->GetType()->id;
CameraActor offscreenCameraActor = CameraActor::New();
Stage::GetCurrent().Add( offscreenCameraActor );
- ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
+ ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
Integration::ResourceId imageRequestId = imageRequest->GetId();
Integration::ResourceTypeId imageType = imageRequest->GetType()->id;
CameraActor offscreenCameraActor = CameraActor::New();
Stage::GetCurrent().Add( offscreenCameraActor );
- ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
+ ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
Integration::ResourceId imageRequestId = imageRequest->GetId();
Integration::ResourceTypeId imageType = imageRequest->GetType()->id;
CameraActor offscreenCameraActor = CameraActor::New();
Stage::GetCurrent().Add( offscreenCameraActor );
- ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
+ ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
Integration::ResourceId imageRequestId = imageRequest->GetId();
Integration::ResourceTypeId imageType = imageRequest->GetType()->id;
CameraActor offscreenCameraActor = CameraActor::New();
Stage::GetCurrent().Add( offscreenCameraActor );
- ImageActor secondRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
+ ImageActor secondRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
Integration::ResourceId imageRequestId = imageRequest->GetId();
Stage::GetCurrent().Add(secondRootActor);
CameraActor offscreenCameraActor = CameraActor::New();
Stage::GetCurrent().Add( offscreenCameraActor );
- ImageActor firstRootActor = CreateLoadingImage(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
+ ImageActor firstRootActor = CreateLoadingImageActor(application, "aFile.jpg", ResourceImage::IMMEDIATE, Image::UNUSED);
Integration::ResourceRequest* imageRequest = application.GetPlatform().GetRequest();
Integration::ResourceId imageRequestId = imageRequest->GetId();
Integration::ResourceTypeId imageType = imageRequest->GetType()->id;
develapiobjectdir = $(develapidir)/object
develapirenderingdir = $(develapidir)/rendering
develapiscriptingdir = $(develapidir)/scripting
+develapisignalsdir = $(develapidir)/signals
+develapithreadingdir = $(develapidir)/threading
develapi_HEADERS = $(devel_api_header_files)
develapiactors_HEADERS = $(devel_api_core_actors_header_files)
develapiobject_HEADERS = $(devel_api_core_object_header_files)
develapirendering_HEADERS = $(devel_api_core_rendering_header_files)
develapiscripting_HEADERS = $(devel_api_core_scripting_header_files)
-
+develapisignals_HEADERS = $(devel_api_core_signals_header_files)
+develapithreading_HEADERS = $(devel_api_core_threading_header_files)
#public api
/*
* djb2 (http://www.cse.yorku.ca/~oz/hash.html)
*/
-const std::size_t INITIAL_HASH_VALUE = 5381;
inline void HashString( const char* string, std::size_t& hash )
{
namespace Dali
{
+const std::size_t INITIAL_HASH_VALUE = 5381;
+
/**
* @brief Create a hash code for a string
* @param toHash string to hash
-#ifndef __DALI_INTERNAL_OWNER_CONTAINER_H__
-#define __DALI_INTERNAL_OWNER_CONTAINER_H__
+#ifndef __DALI_OWNER_CONTAINER_H__
+#define __DALI_OWNER_CONTAINER_H__
/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
namespace Dali
{
-namespace Internal
-{
-
/**
* OwnerContainer is a vector which own heap-allocated objects.
* Unlike vector this will call delete on the stored pointers during destruction.
};
-} // namespace Internal
-
} // namespace Dali
-#endif //__DALI_INTERNAL_OWNER_CONTAINER_H__
+#endif //__DALI_OWNER_CONTAINER_H__
devel_api_src_files = \
$(devel_api_src_dir)/animation/path-constrainer.cpp \
$(devel_api_src_dir)/common/hash.cpp \
- $(devel_api_src_dir)/common/mutex.cpp \
$(devel_api_src_dir)/events/hit-test-algorithm.cpp \
$(devel_api_src_dir)/images/atlas.cpp \
$(devel_api_src_dir)/images/distance-field.cpp \
$(devel_api_src_dir)/rendering/renderer.cpp \
$(devel_api_src_dir)/rendering/sampler.cpp \
$(devel_api_src_dir)/rendering/shader.cpp \
- $(devel_api_src_dir)/scripting/scripting.cpp
+ $(devel_api_src_dir)/scripting/scripting.cpp \
+ $(devel_api_src_dir)/signals/signal-delegate.cpp \
+ $(devel_api_src_dir)/threading/conditional-wait.cpp \
+ $(devel_api_src_dir)/threading/mutex.cpp \
+ $(devel_api_src_dir)/threading/thread.cpp
# Add devel header files here DALi internal developer files used by Adaptor & Toolkit
devel_api_core_common_header_files = \
$(devel_api_src_dir)/common/hash.h \
$(devel_api_src_dir)/common/map-wrapper.h \
- $(devel_api_src_dir)/common/mutex.h \
+ $(devel_api_src_dir)/common/owner-container.h \
$(devel_api_src_dir)/common/ref-counted-dali-vector.h \
- $(devel_api_src_dir)/common/set-wrapper.h
+ $(devel_api_src_dir)/common/set-wrapper.h
devel_api_core_events_header_files = \
$(devel_api_src_dir)/events/hit-test-algorithm.h
$(devel_api_src_dir)/rendering/sampler.h \
$(devel_api_src_dir)/rendering/shader.h
+devel_api_core_signals_header_files = \
+ $(devel_api_src_dir)/signals/signal-delegate.h
+
devel_api_core_scripting_header_files = \
$(devel_api_src_dir)/scripting/scripting.h
+devel_api_core_threading_header_files = \
+ $(devel_api_src_dir)/threading/conditional-wait.h \
+ $(devel_api_src_dir)/threading/mutex.h \
+ $(devel_api_src_dir)/threading/thread.h
// INTERNAL INCLUDES
#include <dali/public-api/object/property-map.h> // Dali::Property::Map
-#include <dali/internal/event/common/object-impl-helper.h> // Dali::Internal::ObjectHelper
#include <dali/internal/event/common/property-buffer-impl.h> // Dali::Internal::PropertyBuffer
namespace Dali
}
PropertyBuffer::PropertyBuffer( const PropertyBuffer& handle )
-: Handle( handle )
+: BaseHandle( handle )
{
}
return GetImplementation(*this).GetSize();
}
-void PropertyBuffer::SetData( void* data )
+void PropertyBuffer::SetData( const void* data )
{
GetImplementation(*this).SetData( data );
}
PropertyBuffer::PropertyBuffer( Internal::PropertyBuffer* pointer )
-: Handle( pointer )
+: BaseHandle( pointer )
{
}
// INTERNAL INCLUDES
#include <dali/public-api/object/handle.h> // Dali::Handle
-#include <dali/public-api/object/property.h> // Dali::Property::Index
-#include <dali/public-api/object/property-index-ranges.h> // DEFAULT_DERIVED_HANDLE_PROPERTY_START_INDEX
#include <dali/public-api/object/property-map.h> // Dali::Property::Map
namespace Dali
* texturedQuadGeometry.SetIndexBuffer( indices );
*
*/
-class DALI_IMPORT_API PropertyBuffer : public Handle
+class DALI_IMPORT_API PropertyBuffer : public BaseHandle
{
public:
/**
- * @brief An enumeration of properties belonging to the PropertyBuffer class.
- */
- struct Property
- {
- enum
- {
- SIZE = DEFAULT_OBJECT_PROPERTY_START_INDEX, ///< name "size", type INTEGER
- BUFFER_FORMAT, ///< name "buffer-format", type MAP
- };
- };
-
- /**
* @brief Create a PropertyBuffer
*
* Static property buffers use less memory.
*
* @param[in] data A pointer to the data that will be copied to the buffer.
*/
- void SetData( void* data );
+ void SetData( const void* data );
public:
/**
Impl* mImpl;
};
-/**
- * @brief Type CustomActors support
- */
-template <typename Type>
-struct CustomActors
-{
- /**
- * This flag tells Dali if a class is derived from CustomActor.
- */
- enum { IS_CUSTOM_ACTOR = __is_base_of(Dali::CustomActor, Type) };
-};
-
-template <typename Type>
-struct TypeCustomActors : public CustomActors< Type >
-{
-};
-
-template < bool CustomActorType >
-class InternalTypeName
-{
-public: // Typedefs
-
- typedef Dali::Internal::CustomActor InternalObjectType;
-};
-
-template <>
-class InternalTypeName< false >
-{
-public: // Typedefs
-
- typedef Dali::Internal::Actor InternalObjectType;
-};
/**
* @brief Weak handle for the given type of Dali object.
template < class T >
class WeakHandle : public WeakHandleBase
{
-public: // Typedefs
-
- typedef typename InternalTypeName< TypeCustomActors<T>::IS_CUSTOM_ACTOR >::InternalObjectType InternalObjectType;
-
public:
/**
/**
* @copydoc Dali::WeakHandleBase::GetHandle()
*/
- T GetHandle()
+ T GetHandle() const
{
Handle handle( GetBaseHandle() );
if( handle )
{
- return T( reinterpret_cast< InternalObjectType* >( handle.GetObjectPtr() ) );
+ return DownCast< T >( handle );
}
else
{
{
enum
{
- GEOMETRY_TYPE = DEFAULT_OBJECT_PROPERTY_START_INDEX, ///< name "depth-index", type STRING
- GEOMETRY_CENTER, ///< name "geometry-center", type VECTOR3
- GEOMETRY_HALF_EXTENTS, ///< name "geometry-half-extents", type VECTOR3
+ GEOMETRY_TYPE = DEFAULT_OBJECT_PROPERTY_START_INDEX, ///< name "geometry-type", type STRING
REQUIRES_DEPTH_TEST, ///< name "requires-depth-testing", type BOOLEAN
};
};
return Dali::Shader( shaderPtr );
}
-void Material::AddSampler( Sampler& sampler )
+int Material::AddTexture( Image image, const std::string& uniformName, Sampler sampler)
{
- DALI_ASSERT_ALWAYS( sampler && "Sampler handle is uninitialized" );
- GetImplementation(*this).AddSampler( GetImplementation( sampler ) );
+ int index( -1 );
+ if( image )
+ {
+ Internal::ImagePtr imagePtr(&GetImplementation( image ));
+ Internal::SamplerPtr samplerPtr(0);
+ if( sampler )
+ {
+ samplerPtr = &GetImplementation( sampler );
+ }
+
+ index = GetImplementation(*this).AddTexture( imagePtr, uniformName, samplerPtr );
+ }
+ else
+ {
+ DALI_LOG_ERROR("Error adding invalid texture %s to material", uniformName.c_str() );
+ }
+ return index;
+}
+
+void Material::RemoveTexture( size_t index )
+{
+ GetImplementation(*this).RemoveTexture( index );
+}
+
+void Material::SetTextureImage( size_t index, Image image )
+{
+ Internal::Image* imagePtr(0);
+ if( image )
+ {
+ imagePtr = &GetImplementation( image );
+ }
+
+ GetImplementation(*this).SetTextureImage( index, imagePtr );
}
-std::size_t Material::GetNumberOfSamplers() const
+void Material::SetTextureSampler( size_t index, Sampler sampler )
{
- return GetImplementation(*this).GetNumberOfSamplers();
+ Internal::Sampler* samplerPtr(0);
+ if( sampler )
+ {
+ samplerPtr = &GetImplementation( sampler );
+ }
+
+ GetImplementation(*this).SetTextureSampler( index, samplerPtr );
+}
+
+void Material::SetTextureUniformName( size_t index, const std::string& uniformName )
+{
+ GetImplementation(*this).SetTextureUniformName( index, uniformName );
}
-void Material::RemoveSampler( std::size_t index )
+int Material::GetTextureIndex( const std::string& uniformName )
{
- GetImplementation(*this).RemoveSampler( index );
+ return GetImplementation(*this).GetTextureIndex( uniformName );
}
-Sampler Material::GetSamplerAt( unsigned int index ) const
+void Material::SetTextureAffectsTransparency( size_t index, bool affectsTransparency )
{
- Internal::Sampler* samplerPtr( GetImplementation(*this).GetSamplerAt(index) );
- return Dali::Sampler( samplerPtr );
+ GetImplementation(*this).SetTextureAffectsTransparency( index, affectsTransparency );
}
+std::size_t Material::GetNumberOfTextures() const
+{
+ return GetImplementation(*this).GetNumberOfTextures();
+}
+
+
void Material::SetFaceCullingMode( FaceCullingMode cullingMode )
{
GetImplementation(*this).SetFaceCullingMode( cullingMode );
Shader GetShader() const;
/**
- * @brief Add a sampler to this material
+ * @brief Add a new texture to be used by the material
*
- * param[in] sampler The sampler to add to this material
+ * @param[in] image The image used by the texture
+ * @param[in] uniformName The uniform name of the texture
+ * @param[in] sampler Sampling parameters. If not provided the default sampling parameters will be used
+ * @return The index of the texture in the array of textures or -1 if texture can not be added
*/
- void AddSampler( Sampler& sampler );
+ int AddTexture( Image image, const std::string& uniformName, Sampler sampler = Sampler() );
/**
- * @brief Get the number of samplers
+ * @brief Removes a texture from the material
*
- * @return The number of samplers
+ * @param[in] index The index of the texture in the array of textures
*/
- std::size_t GetNumberOfSamplers() const;
+ void RemoveTexture( size_t index );
/**
- * @brief Remove a sampler
+ * @brief Sets the image to be used by a given texture
*
- * The index must be between 0 and GetNumberOfSamplers()-1
+ * @param[in] index The index of the texture in the array of textures
+ * @param[in] image The new image
+ */
+ void SetTextureImage( size_t index, Image image );
+
+ /**
+ * @brief Set the sampler used by a given texture
+ *
+ * @param[in] index The index of the texture in the array of textures
+ * @param[in] sampler The new sampler
+ */
+ void SetTextureSampler( size_t index, Sampler sampler );
+
+ /**
+ * @brief Set the uniform name of a given texture
*
- * @param[in] index The index of the sampler to remove
+ * @param[in] index The index of the texture in the array of textures
+ * @param[in] uniformName The new uniform name
*/
- void RemoveSampler( std::size_t index );
+ void SetTextureUniformName( size_t index, const std::string& uniformName );
/**
- * @brief Get the sampler at the given index for this material
+ * @brief Establish if a given texture will affect the transparency of the material ( true by default )
*
- * The index must be between 0 and GetNumberOfSamplers()-1
+ * @param[in] index The index of the texture in the array of textures
+ * @param[in] affectsTransparency True if the texture affects transparency, false otherwise
+ */
+ void SetTextureAffectsTransparency( size_t index, bool affectsTransparency );
+
+ /*
+ * @brief Retrive the index of a texture given its uniform name
*
- * @param[in] index The index of the sampler
- * @return The sampler at that index
+ * @param[in] uniformName the uniform name
+ * @returns The index in the array of textures or -1 if the texture is not found
+ */
+ int GetTextureIndex( const std::string& uniformName );
+
+ /**
+ * @brief Retrieve the number of textures used by the material
*/
- Sampler GetSamplerAt( unsigned int index ) const;
+ std::size_t GetNumberOfTextures() const;
/**
* @brief Set the culling mode for this material
namespace Dali
{
-Sampler Sampler::New( Image& image, const std::string& textureUnitUniformName )
+Sampler Sampler::New()
{
- Internal::SamplerPtr sampler = Internal::Sampler::New(textureUnitUniformName);
- Internal::ImagePtr imagePtr = &GetImplementation( image );
- sampler->SetImage( imagePtr );
+ Internal::SamplerPtr sampler = Internal::Sampler::New();
return Sampler( sampler.Get() );
}
}
Sampler::Sampler( const Sampler& handle )
-: Handle( handle )
+: BaseHandle( handle )
{
}
return *this;
}
-void Sampler::SetUniformName( const std::string& name )
-{
- GetImplementation(*this).SetTextureUnitUniformName( name );
-}
-
-void Sampler::SetImage( Image& image )
-{
- Internal::ImagePtr imagePtr = &GetImplementation( image );
- GetImplementation(*this).SetImage( imagePtr );
-}
-Image Sampler::GetImage() const
-{
- Internal::ImagePtr imagePtr( GetImplementation(*this).GetImage() );
- return Dali::Image( imagePtr.Get() );
-}
-
-void Sampler::SetFilterMode( FilterMode minFilter, FilterMode magFilter )
+void Sampler::SetFilterMode( FilterMode::Type minFilter, FilterMode::Type magFilter )
{
GetImplementation(*this).SetFilterMode( minFilter, magFilter );
}
-void Sampler::SetWrapMode( WrapMode uWrap, WrapMode vWrap )
+void Sampler::SetWrapMode( WrapMode::Type uWrap, WrapMode::Type vWrap )
{
GetImplementation(*this).SetWrapMode( uWrap, vWrap );
}
-void Sampler::SetAffectsTransparency( bool affectsTransparency )
-{
- GetImplementation(*this).SetAffectsTransparency( affectsTransparency );
-}
-
Sampler::Sampler(Internal::Sampler* pointer)
-: Handle( pointer )
+: BaseHandle( pointer )
{
}
*
*/
-// EXTERNAL INCLUDES
-#include <cstddef> // std::size_t
-#include <string> // std::string
-
// INTERNAL INCLUDES
#include <dali/public-api/object/handle.h> // Dali::Handle
-#include <dali/public-api/images/image.h> // Dali::Image
-#include <dali/public-api/object/property-index-ranges.h> // DEFAULT_DERIVED_HANDLE_PROPERTY_START_INDEX
+#include <dali/public-api/actors/sampling.h>
+#include <dali/integration-api/image-integ.h>
namespace Dali
{
}
/**
- * @brief Sampler is a handle to an object that can be used to provide an image to a material.
+ * @brief Sampler is a handle to an object that can be used to provide the sampling parameters to sample textures
*/
-class DALI_IMPORT_API Sampler : public Handle
+class DALI_IMPORT_API Sampler : public BaseHandle
{
public:
/**
- * @brief Texture filter mode.
- */
- enum FilterMode
- {
- NONE, ///< Use GL system defaults (minification NEAREST_MIPMAP_LINEAR, magnification LINEAR)
- DEFAULT, ///< Use dali defaults (minification LINEAR, magnification LINEAR)
- NEAREST, ///< Filter nearest
- LINEAR ///< Filter linear
- };
-
- /**
- * @brief Texture wrap mode.
- */
- enum WrapMode
- {
- CLAMP_TO_EDGE, ///< The texture coordinates get clamped to the range [0, 1]
- REPEAT, ///< Only the fractional part of the texture coordinates is used
- MIRRORED_REPEAT, ///< If the integer part of the texture coordinate is odd then it uses
- ///< the fractional part, if it's even it uses 1 - the fractional part
- };
-
- /**
- * @brief An enumeration of properties belonging to the Sampler class.
- */
- struct Property
- {
- enum
- {
- MINIFICATION_FILTER = DEFAULT_OBJECT_PROPERTY_START_INDEX, ///< name "minification-filter", type STRING
- MAGNIGICATION_FILTER, ///< name "magnification-filter", type STRING
- U_WRAP, ///< name "u-wrap", type STRING
- V_WRAP, ///< name "v-wrap", type STRING
- AFFECTS_TRANSPARENCY, ///< name "affects-transparency", type BOOLEAN
- };
- };
-
- /**
* @brief Creates a new Sampler object
*
* @param[in] image Image used by this sampler
* @param[in] uniformName String with the name of the uniform
*/
- static Sampler New( Image& image, const std::string& uniformName );
+ static Sampler New();
/**
* @brief Default constructor, creates an empty handle
*/
Sampler& operator=( const Sampler& handle );
- /**
- * @brief Sets the name of the shader uniform that will use this sampler
- *
- * @param[in] name String with the name of the uniform
- */
- void SetUniformName( const std::string& name );
-
- /**
- * @brief Set the image used by this sampler
- *
- * @param[in] image Image used by this sampler
- */
- void SetImage( Image& image );
-
- /**
- * @brief Retrieve the image used by this sampler
- *
- * If no image is assigned, an empty handle is returned
- * @return The image.
- */
- Image GetImage() const;
/**
* @brief Set the filter modes for this sampler
* @param[in] minFilter The minification filter that will be used
* @param[in] magFilter The magnification filter that will be used
*/
- void SetFilterMode( FilterMode minFilter, FilterMode magFilter );
+ void SetFilterMode( FilterMode::Type minFilter, FilterMode::Type magFilter );
/**
* @brief Set the wrap modes for this sampler
* param[in] uWrap Wrap mode for u coordinates
* param[in] vWrap Wrap mode for v coordinates
*/
- void SetWrapMode( WrapMode uWrap, WrapMode vWrap );
-
- /**
- * @brief Set if this sampler should be considered for opacity hinting
- *
- * Calling this function sets the property AFFECTS_TRANSPARENCY
- *
- * param[in] affectsTransparency Specifies if this sampler should be considered for opacity hinting
- */
- void SetAffectsTransparency( bool affectsTransparency );
+ void SetWrapMode( WrapMode::Type uWrap, WrapMode::Type vWrap );
public:
/**
--- /dev/null
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include <dali/devel-api/signals/signal-delegate.h>
+
+namespace Dali
+{
+
+// CallbackBaseFunctor methods:
+
+SignalDelegate::CallbackBaseFunctor::CallbackBaseFunctor( CallbackBase* callback )
+: mCallback( callback )
+{
+}
+
+void SignalDelegate::CallbackBaseFunctor::operator()()
+{
+ if( mCallback )
+ {
+ CallbackBase::Execute( *mCallback );
+ }
+}
+
+SignalDelegate::CallbackBaseFunctor::~CallbackBaseFunctor()
+{
+ // Note: Deleting a CallbackBase will also call it's Reset method.
+ delete mCallback;
+}
+
+
+// SignalDelegate methods:
+
+SignalDelegate::SignalDelegate( Dali::Actor connectActor, const std::string& signalName )
+: mCallbackFunctor( NULL ),
+ mConnectActor( connectActor ),
+ mSignalName( signalName )
+{
+}
+
+bool SignalDelegate::IsConnected()
+{
+ return mCallbackFunctor;
+}
+
+
+} // namespace Dali
--- /dev/null
+#ifndef __DALI_SIGNAL_DELEGATE_H__
+#define __DALI_SIGNAL_DELEGATE_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// INTERNAL INCLUDES
+#include <dali/public-api/actors/actor.h>
+#include <dali/public-api/signals/connection-tracker-interface.h>
+
+namespace Dali
+{
+
+/**
+ * @brief The SignalDelegate object allows direct connection to a signal that has been pre-configured internally.
+ *
+ * EG: The SignalDelegate can be created internally and exposed to the application-developer.
+ * They can then call the connect function to transparently bind to their callback.
+ */
+class DALI_IMPORT_API SignalDelegate
+{
+public:
+
+ /**
+ * @brief Create and set up a signal delegate.
+ *
+ * @param[in] connectActor The actor whose signal should be connected to.
+ * @param[in] signalName The name of the signal within the actor to connect to.
+ */
+ SignalDelegate( Dali::Actor connectActor, const std::string& signalName );
+
+ /**
+ * @brief Destructor.
+ */
+ ~SignalDelegate()
+ {
+ }
+
+public:
+
+ /**
+ * @brief Connect to a FunctorDelegate as received from a type-registry signal connection call.
+ *
+ * This is required to allow connection to an actor's signal. Typically this is done in a generic
+ * way (IE. via a string of the signal name) using the ConnectSignal function.
+ * This function requires a functor.
+ *
+ * @param[in] connectionTracker Passed in to the ConnectSignal function of the actor.
+ * @param[in] functorDelegate A functor delegate object that must be executed when the signal is emitted.
+ * @return True of the connection was made, false otherwise.
+ */
+ bool Connect( ConnectionTrackerInterface* connectionTracker, FunctorDelegate* functorDelegate )
+ {
+ if( !mCallbackFunctor )
+ {
+ // Note: We have to new the CallbackBaseFunctor rather than have it as a concrete object, as it
+ // is converted to a FunctorDelegate again within ConnectSignal. FunctorDelegates gain ownership
+ // of any functor they are created from and therefore always attempt to delete them.
+ mCallbackFunctor = new CallbackBaseFunctor( new CallbackFunctorDelegate0( functorDelegate ) );
+ mConnectActor.ConnectSignal( connectionTracker, mSignalName, *mCallbackFunctor );
+
+ return true;
+ }
+
+ return false;
+ }
+
+ /**
+ * @brief Connect to a non-static member function.
+ *
+ * The object that owns the member function must also inherit from ConnectionTracker.
+ *
+ * @param[in] object Object instance that houses the supplied member-function.
+ * @param[in] memberFunction The member-function to call when the signal is emitted.
+ * @return True of the connection was made, false otherwise.
+ */
+ template< class T >
+ bool Connect( T* object, void ( T::*memberFunction )( void ) )
+ {
+ if( !mCallbackFunctor )
+ {
+ mCallbackFunctor = new CallbackBaseFunctor( MakeCallback( object, memberFunction ) );
+ mConnectActor.ConnectSignal( object, mSignalName, *mCallbackFunctor );
+
+ return true;
+ }
+
+ return false;
+ }
+
+ /**
+ * @brief Checks if this delegate has been connected yet, so it can be determined if it
+ * can be used or a new delegate must be created to set up a new connection (to the same signal).
+ *
+ * @return True if this SignalDelegate has been connected to it's signal.
+ */
+ bool IsConnected();
+
+
+private:
+
+ /**
+ * This functor is used by SignalDelegate in order to callback to a non-static member function
+ * (after it has been converted to a CallbackBase).
+ * The functor can be passed in to a ConnectSignal function of a BaseHandle and call into an
+ * object's member function on despatch.
+ */
+ struct CallbackBaseFunctor
+ {
+ /**
+ * @brief Create and initialise the functor with the callback to be called.
+ *
+ * @param[in] callback A CallbackBase which can be created from a member function, or a FunctorDelegate.
+ */
+ CallbackBaseFunctor( CallbackBase* callback );
+
+ /**
+ * @brief Executes the functor.
+ */
+ void operator()();
+
+ /**
+ * Destructor.
+ * Note that as this is passed in to a ConnectSignal method, it is converted to a FunctorDelegate.
+ * This means that this functor will automatically have it's destructor called, but we still own
+ * the CallbackBase, which must be destroyed manually here.
+ */
+ ~CallbackBaseFunctor();
+
+ private:
+
+ CallbackBase* mCallback; ///< Stores (and owns) the callback to be called on execution.
+ };
+
+private:
+
+ /**
+ * @brief Not defined.
+ */
+ SignalDelegate( const SignalDelegate& rhs );
+
+ /**
+ * @brief Not defined.
+ */
+ const SignalDelegate& operator=( const SignalDelegate& rhs );
+
+private:
+
+ CallbackBaseFunctor* mCallbackFunctor; ///< The functor to allow connection to external callbacks.
+ Dali::Actor mConnectActor; ///< The actor owning the signal to connect to.
+ std::string mSignalName; ///< The name of the signal to connect to.
+
+};
+
+} // namespace Dali
+
+#endif // __DALI_SIGNAL_DELEGATE_H__
--- /dev/null
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include <dali/devel-api/threading/conditional-wait.h>
+
+// INTERNAL INCLUDES
+#include <dali/internal/common/mutex-impl.h>
+
+// EXTERNAL INCLUDES
+#include <pthread.h>
+#include <dali/integration-api/debug.h>
+
+namespace Dali
+{
+
+struct ConditionalWait::ConditionalWaitImpl
+{
+ pthread_mutex_t mutex;
+ pthread_cond_t condition;
+ volatile unsigned int count;
+};
+
+
+ConditionalWait::ScopedLock::ScopedLock( ConditionalWait& wait ) : mWait(wait)
+{
+ Internal::Mutex::Lock( &wait.mImpl->mutex );
+}
+
+ConditionalWait::ScopedLock::~ScopedLock()
+{
+ ConditionalWait& wait = mWait;
+ Internal::Mutex::Unlock( &wait.mImpl->mutex );
+}
+
+ConditionalWait::ConditionalWait()
+: mImpl( new ConditionalWaitImpl )
+{
+ pthread_mutex_init( &mImpl->mutex, NULL );
+ pthread_cond_init( &mImpl->condition, NULL );
+ mImpl->count = 0;
+}
+
+ConditionalWait::~ConditionalWait()
+{
+ pthread_cond_destroy( &mImpl->condition );
+ pthread_mutex_destroy( &mImpl->mutex );
+ delete mImpl;
+}
+
+void ConditionalWait::Notify()
+{
+ // pthread_cond_wait requires a lock to be held
+ Internal::Mutex::Lock( &mImpl->mutex );
+ volatile unsigned int previousCount = mImpl->count;
+ mImpl->count = 0; // change state before broadcast as that may wake clients immediately
+ // broadcast does nothing if the thread is not waiting but still has a system call overhead
+ // broadcast all threads to continue
+ if( 0 != previousCount )
+ {
+ pthread_cond_broadcast( &mImpl->condition );
+ }
+ Internal::Mutex::Unlock( &mImpl->mutex );
+}
+
+void ConditionalWait::Wait()
+{
+ // pthread_cond_wait requires a lock to be held
+ Internal::Mutex::Lock( &mImpl->mutex );
+ ++(mImpl->count);
+ // pthread_cond_wait may wake up without anyone calling Notify
+ do
+ {
+ // wait while condition changes
+ pthread_cond_wait( &mImpl->condition, &mImpl->mutex ); // releases the lock whilst waiting
+ }
+ while( 0 != mImpl->count );
+ // when condition returns the mutex is locked so release the lock
+ Internal::Mutex::Unlock( &mImpl->mutex );
+}
+
+void ConditionalWait::Wait( const ScopedLock& scope )
+{
+ // Scope must be locked:
+ DALI_ASSERT_DEBUG( &scope.GetLockedWait() == this );
+
+ ++(mImpl->count);
+
+ // pthread_cond_wait may wake up without anyone calling Notify so loop until
+ // count has been reset in a notify:
+ do
+ {
+ // wait while condition changes
+ pthread_cond_wait( &mImpl->condition, &mImpl->mutex ); // releases the lock whilst waiting
+ }
+ while( 0 != mImpl->count );
+
+ // We return with our mutex locked safe in the knowledge that the ScopedLock
+ // passed in will unlock it in the caller.
+}
+
+unsigned int ConditionalWait::GetWaitCount() const
+{
+ return mImpl->count;
+}
+
+} // namespace Dali
--- /dev/null
+#ifndef __DALI_CONDITIONAL_WAIT_H__
+#define __DALI_CONDITIONAL_WAIT_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// INTERNAL INCLUDES
+#include <dali/public-api/common/dali-common.h>
+
+namespace Dali
+{
+
+/**
+ * Helper class to allow conditional waiting and notifications between multiple threads.
+ */
+class DALI_IMPORT_API ConditionalWait
+{
+public:
+
+ /**
+ * @brief Allows client code to synchronize updates to its own state with the
+ * internal state of a ConditionalWait object.
+ */
+ class ScopedLock
+ {
+ public:
+ /**
+ * Constructor
+ * @brief Will acquire the internal mutex of the ConditionalWait object passed in.
+ * @param[in] wait The ConditionalWait object to lock.
+ */
+ ScopedLock( ConditionalWait& wait );
+
+ /**
+ * Destructor
+ * @brief Will release the internal mutex of the ConditionalWait object passed in.
+ */
+ ~ScopedLock();
+
+ /**
+ * Getter for the ConditionalWait locked for this instance's lifetime.
+ * @return the ConditionalWait object currently locked.
+ */
+ ConditionalWait& GetLockedWait() const { return mWait; }
+
+ private:
+
+ // Not implemented as ScopedLock cannot be copied:
+ ScopedLock( const ScopedLock& );
+ const ScopedLock& operator=( const ScopedLock& );
+
+ ConditionalWait& mWait;
+ };
+
+ /**
+ * @brief Constructor, creates the internal synchronization objects
+ */
+ ConditionalWait();
+
+ /**
+ * @brief Destructor, non-virtual as this is not a base class
+ */
+ ~ConditionalWait();
+
+ /**
+ * @brief Notifies another thread to continue if it is blocked on a wait.
+ *
+ * Can be called from any thread.
+ * Does not block the current thread but may cause a rescheduling of threads.
+ */
+ void Notify();
+
+ /**
+ * @brief Wait for another thread to notify us when the condition is true and we can continue
+ *
+ * Will always block current thread until Notify is called
+ */
+ void Wait();
+
+ /**
+ * @brief Wait for another thread to notify us when the condition is true and we can continue
+ *
+ * Will always block current thread until Notify is called.
+ * Assumes that the ScopedLock object passed in has already locked the internal state of
+ * this object. Releases the lock while waiting and re-acquires it when returning
+ * from the wait.
+ * param[in] scope A pre-existing lock on the internal state of this object.
+ * @pre scope must have been passed this ConditionalWait during its construction.
+ */
+ void Wait( const ScopedLock& scope );
+
+ /**
+ * @brief Return the count of threads waiting for this conditional
+ * @return count of waits
+ */
+ unsigned int GetWaitCount() const;
+
+private:
+
+ // Not implemented as ConditionalWait is not copyable
+ ConditionalWait( const ConditionalWait& );
+ const ConditionalWait& operator=( const ConditionalWait& );
+
+ struct ConditionalWaitImpl;
+ ConditionalWaitImpl* mImpl;
+
+};
+
+} // namespace Dali
+
+#endif // __DALI_CONDITIONAL_WAIT_H__
*/
// CLASS HEADER
-#include <dali/devel-api/common/mutex.h>
+#include <dali/devel-api/threading/mutex.h>
+
+// INTERNAL INCLUDES
+#include <dali/internal/common/mutex-impl.h>
// EXTERNAL INCLUDES
#include <pthread.h>
Mutex::ScopedLock::ScopedLock( Mutex& mutex )
: mMutex( mutex )
{
- pthread_mutex_lock( &mMutex.mImpl->mutex );
+ Internal::Mutex::Lock( &mMutex.mImpl->mutex );
mMutex.mImpl->locked = true;
}
Mutex::ScopedLock::~ScopedLock()
{
mMutex.mImpl->locked = false;
- pthread_mutex_unlock( &mMutex.mImpl->mutex );
+ Internal::Mutex::Unlock( &mMutex.mImpl->mutex );
}
} // namespace Dali
--- /dev/null
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include <dali/devel-api/threading/thread.h>
+
+// EXTERNAL INCLUDES
+#include <cstddef>
+#include <pthread.h>
+#include <dali/integration-api/debug.h>
+
+namespace Dali
+{
+
+struct Thread::ThreadImpl
+{
+ pthread_t thread;
+ bool isCreated;
+};
+
+Thread::Thread()
+: mImpl( new ThreadImpl )
+{
+ mImpl->isCreated = false;
+}
+
+Thread::~Thread()
+{
+ delete mImpl;
+}
+
+void Thread::Start()
+{
+ DALI_ASSERT_DEBUG( !mImpl->isCreated );
+
+ int error = pthread_create( &(mImpl->thread), NULL, InternalThreadEntryFunc, this );
+ DALI_ASSERT_ALWAYS( !error && "Failed to create a new thread" );
+ mImpl->isCreated = true;
+}
+
+void Thread::Join()
+{
+ if( mImpl->isCreated )
+ {
+ mImpl->isCreated = false;
+ pthread_join( mImpl->thread, NULL );
+ }
+}
+
+void* Thread::InternalThreadEntryFunc( void* This )
+{
+ ( static_cast<Thread*>( This ) )->Run();
+ return NULL;
+}
+
+} // namespace Dali
--- /dev/null
+#ifndef __DALI_THREAD_H__
+#define __DALI_THREAD_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// INTERNAL INCLUDES
+#include <dali/public-api/common/dali-common.h>
+
+
+/**
+ * The top level DALi namespace
+ */
+namespace Dali
+{
+
+/*
+ * @brief Abstract class for thread functionality. Can be used for worker threads.
+ */
+class DALI_IMPORT_API Thread
+{
+public:
+
+ /**
+ * @brief Creates a new thread and make it executable.
+ */
+ void Start();
+
+ /**
+ * @brief Wait for thread termination.
+ */
+ void Join();
+
+protected:
+
+ /**
+ * @brief Constructor
+ */
+ Thread();
+
+ /**
+ * @brief Destructor, virtual as this is used as base class
+ */
+ virtual ~Thread();
+
+ /**
+ * The routine that the thread will execute once it is started.
+ */
+ virtual void Run() = 0;
+
+private:
+
+ /**
+ * Helper for the thread calling the entry function.
+ * @param[in] This A pointer to the current RenderThread object
+ */
+ static void* InternalThreadEntryFunc( void* This );
+
+ // Undefined
+ Thread( const Thread& );
+ // Undefined
+ const Thread& operator=( const Thread& );
+
+private:
+
+ struct ThreadImpl;
+ ThreadImpl* mImpl;
+};
+
+}
+
+#endif /* __DALI_THREAD_H__ */
/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <dali/internal/event/common/thread-local-storage.h>
#include <dali/internal/event/images/bitmap-packed-pixel.h>
#include <dali/internal/event/images/bitmap-compressed.h>
-#include <dali/internal/event/images/bitmap-external.h>
#include <dali/integration-api/gl-abstraction.h>
#include <dali/integration-api/gl-defines.h>
Bitmap::~Bitmap()
{
DALI_LOG_TRACE_METHOD(Debug::Filter::gImage);
-
- // If owned
- if( mDiscardable == ResourcePolicy::OWNED_DISCARD ||
- mDiscardable == ResourcePolicy::OWNED_RETAIN )
- {
- DeletePixelBuffer();
- }
+ DeletePixelBuffer();
}
/**
#include <dali/public-api/images/pixel.h>
#include <dali/public-api/object/ref-object.h>
#include <dali/integration-api/resource-policies.h>
+#include <dali/integration-api/image-integ.h>
namespace Dali
{
/**
* Bitmap class.
* An abstract container for image data.
- * \sa{BitmapPackedPixel BitmapCompressed BitmapExternal} for concrete
- * subclasses.
*/
class DALI_IMPORT_API Bitmap : public Dali::RefObject
{
* and may released away after uploading to GPU.
* OWNED_RETAIN means that the data is owned and must be kept in CPU memory
* e.g. for an image that cannot be reloaded from disk.
- * NOT_OWNED means that the data is managed by an external component and is
- * guaranteed to remain dereferenceable at least as long as the Bitmap remains alive.
*/
static Bitmap* New( Profile profile, ResourcePolicy::Discardable discardable );
$(platform_abstraction_src_dir)/bitmap.cpp \
$(platform_abstraction_src_dir)/core.cpp \
$(platform_abstraction_src_dir)/image-data.cpp \
+ $(platform_abstraction_src_dir)/image-integ.cpp \
$(platform_abstraction_src_dir)/debug.cpp \
$(platform_abstraction_src_dir)/profiling.cpp \
$(platform_abstraction_src_dir)/input-options.cpp \
$(platform_abstraction_src_dir)/bitmap.h \
$(platform_abstraction_src_dir)/resource-policies.h \
$(platform_abstraction_src_dir)/image-data.h \
+ $(platform_abstraction_src_dir)/image-integ.h \
$(platform_abstraction_src_dir)/resource-types.h \
$(platform_abstraction_src_dir)/resource-request.h \
$(platform_abstraction_src_dir)/resource-cache.h \
-#ifndef __DALI_INTERNAL_SCENE_GRAPH_RENDERER_DECLARATIONS_H__
-#define __DALI_INTERNAL_SCENE_GRAPH_RENDERER_DECLARATIONS_H__
-
/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
*
*/
+// CLASS HEADER
+#include <dali/integration-api/image-integ.h>
+
// INTERNAL INCLUDES
-#include <dali/public-api/common/vector-wrapper.h>
+#include <dali/internal/event/images/nine-patch-image-impl.h>
+
+using Dali::Internal::NinePatchImage;
namespace Dali
{
-namespace Internal
+namespace Integration
{
-namespace SceneGraph
+const StretchRanges& GetStretchPixelsX(NinePatchImage ninePatch)
{
+ return GetImplementation(ninePatch).GetStretchPixelsX();
+}
-class Renderer;
-
-typedef std::vector<Renderer*> RendererContainer;
-typedef RendererContainer::iterator RendererIter;
-
-enum EffectType
+const StretchRanges& GetStretchPixelsY(NinePatchImage ninePatch)
{
- NO_EFFECT,
- SHADOW_EFFECT,
- REFLECT_EFFECT
-};
+ return GetImplementation(ninePatch).GetStretchPixelsY();
+}
-} // namespace SceneGraph
+bool IsNinePatchUrl( const std::string& url )
+{
+ return Internal::NinePatchImage::IsNinePatchUrl( url );
+}
-} // namespace Internal
+} // namespace Integration
} // namespace Dali
-
-#endif // __DALI_INTERNAL_SCENE_GRAPH_RENDERER_DECLARATIONS_H__
--- /dev/null
+#ifndef __DALI_INTEGRATION_IMAGE_INTEG_H__
+#define __DALI_INTEGRATION_IMAGE_INTEG_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+
+// INTERNAL INCLUDES
+#include <dali/public-api/images/nine-patch-image.h>
+
+namespace Dali
+{
+
+// Allow Uint16Pair to be treated as a POD type
+template <> struct TypeTraits< Uint16Pair > : public BasicTypes< Uint16Pair > { enum { IS_TRIVIAL_TYPE = true }; };
+
+
+namespace Integration
+{
+
+typedef Dali::Vector< Uint16Pair > StretchRanges;
+
+/**
+* @brief Retrieves the horizontal stretch pixel ranges in the cropped image space
+* @since_tizen 2.4
+*
+* @return the horizontal stretch pixel ranges in the cropped image space
+*/
+DALI_IMPORT_API const StretchRanges& GetStretchPixelsX(NinePatchImage ninePatch);
+
+/**
+* @brief Retrieves the vertical stretch pixel ranges in the cropped image space
+*
+* @return the vertical stretch pixel ranges in the cropped image space
+*/
+DALI_IMPORT_API const StretchRanges& GetStretchPixelsY(NinePatchImage ninePatch);
+
+/**
+* Helper method to determine if the filename indicates that the image has a 9 patch or n patch border.
+* @param [in] url The URL of the image file.
+* @return true if it is a 9 patch or n patch image
+*/
+DALI_IMPORT_API bool IsNinePatchUrl( const std::string& url );
+
+} // namespace Integration
+
+namespace WrapMode
+{
+
+enum Type
+{
+ DEFAULT, ///< Clamp to edge
+ CLAMP_TO_EDGE,
+ REPEAT,
+ MIRRORED_REPEAT
+};
+
+} //namespace WrapMode
+
+
+} // namespace Dali
+
+#endif // __DALI_INTEGRATION_IMAGE_INTEG_H__
#include <dali/internal/event/actor-attachments/actor-attachment-impl.h>
#include <dali/internal/event/actor-attachments/camera-attachment-impl.h>
#include <dali/internal/event/actor-attachments/image-attachment-impl.h>
-#include <dali/internal/event/actor-attachments/renderer-attachment-impl.h>
#include <dali/internal/event/animation/animation-impl.h>
#include <dali/internal/event/animation/animator-connector.h>
#include <dali/internal/update/node-attachments/node-attachment.h>
#include <dali/internal/update/node-attachments/scene-graph-camera-attachment.h>
#include <dali/internal/update/node-attachments/scene-graph-image-attachment.h>
-#include <dali/internal/update/node-attachments/scene-graph-renderer-attachment.h>
+#include <dali/internal/update/rendering/scene-graph-renderer.h>
#include <dali/internal/update/resources/bitmap-metadata.h>
#include <dali/internal/render/gl-resources/bitmap-texture.h>
-#include <dali/internal/render/renderers/scene-graph-image-renderer.h>
+#include <dali/internal/render/renderers/render-geometry.h>
+#include <dali/internal/render/renderers/render-image-renderer.h>
+#include <dali/internal/render/renderers/render-new-renderer.h>
+#include <dali/internal/render/renderers/render-property-buffer.h>
#include <dali/internal/render/renderers/render-renderer.h>
+#include <dali/internal/render/renderers/render-sampler.h>
using Dali::Internal::GestureEventProcessor;
using Dali::Internal::ThreadLocalStorage;
sizeof( Internal::ImageAttachment ) +
sizeof( Internal::SceneGraph::Node ) +
sizeof( Internal::SceneGraph::ImageAttachment ) +
- sizeof( Internal::SceneGraph::ImageRenderer ));
+ sizeof( Internal::Render::ImageRenderer ));
const int LAYER_MEMORY_SIZE(
sizeof( Internal::Layer ) +
sizeof( Internal::ActorAttachment ) +
sizeof( Internal::ImageTicket ) );
const int RENDERER_MEMORY_SIZE(
sizeof( Internal::Renderer ) +
- sizeof( Internal::RendererAttachment ) +
- sizeof( Internal::SceneGraph::RendererAttachment ) +
sizeof( Internal::SceneGraph::Renderer ) +
- sizeof( Internal::SceneGraph::NewRenderer ) );
+ sizeof( Internal::Render::NewRenderer ) );
const int GEOMETRY_MEMORY_SIZE(
sizeof( Internal::Geometry ) +
- sizeof( Internal::SceneGraph::Geometry ) );
+ sizeof( Internal::SceneGraph::Geometry ) +
+ sizeof( Internal::SceneGraph::RenderGeometry) );
const int PROPERTY_BUFFER_MEMORY_SIZE(
sizeof( Internal::PropertyBuffer ) +
- sizeof( Internal::SceneGraph::PropertyBuffer ) );
+ sizeof( Internal::Render::PropertyBuffer ) );
const int MATERIAL_MEMORY_SIZE(
sizeof( Internal::Material ) +
sizeof( Internal::SceneGraph::Material ) );
const int SAMPLER_MEMORY_SIZE(
sizeof( Internal::Sampler ) +
- sizeof( Internal::SceneGraph::Sampler ) );
+ sizeof( Internal::Render::Sampler ) );
const int SHADER_MEMORY_SIZE(
sizeof( Internal::Shader ) +
sizeof( Internal::SceneGraph::Shader ) );
* Dali::Internal::ImageFactoryCache::RequestId
*/
typedef unsigned int ResourceId;
+const ResourceId InvalidResourceId = (ResourceId)-1;
/**
* Used to inform the current loading status
};
/**
- * The discardable policy describes whether a resource is owned or can be discarded.
+ * The discardable policy determines if a resource can be discarded.
* Discarded means that it can be released after uploading to GPU.
*/
enum Discardable
{
OWNED_DISCARD,
OWNED_RETAIN,
- NOT_OWNED
};
} // namespace ResourcePolicy
namespace ImageSampler
{
-namespace
-{
-
-// @todo MESH_REWORK Remove file after image removal
-
-// Adjust these shift sizes if the FilterMode enum grows
-const int MINIFY_BIT_SHIFT = 0; // Room for 16
-const int MAGNIFY_BIT_SHIFT = 4;
-
-const int MASK_MINIFY_FILTER = 0x0000000F;
-const int MASK_MAGNIFY_FILTER = 0x000000F0;
-
-const unsigned int FILTER_MODE_COUNT = 4;
-
-FilterMode::Type FILTER_MODE_OPTIONS[ FILTER_MODE_COUNT ] =
- { FilterMode::NONE,
- FilterMode::DEFAULT,
- FilterMode::NEAREST,
- FilterMode::LINEAR };
-
-} // namespace
-
/**
- * Utility to store one of the FilterMode values.
+ * Utility to store one of the sampling parameters values.
* @param[out] options A bitmask used to store the FilterMode values.
* @param[in] factor The FilterMode value.
* @param[in] bitshift Used to shift to the correct part of options.
*/
-void StoreFilterMode( unsigned int& options, FilterMode::Type mode, int bitShift )
+void StoreSamplingParameter( unsigned int& options, unsigned int mode, int bitShift )
{
- // Start shifting from 1 as 0 is the unassigned state
- switch ( mode )
+ if( mode != 0 )
{
- case FilterMode::NONE:
- {
- // Nothing to do
- break;
- }
- case FilterMode::DEFAULT:
- {
- options |= ( 1u << bitShift );
- break;
- }
- case FilterMode::NEAREST:
- {
- options |= ( 2u << bitShift );
- break;
- }
- case FilterMode::LINEAR:
- {
- options |= ( 3u << bitShift );
- break;
- }
+ options |= ( mode << bitShift );
}
}
* @param[in] bitshift Used to shift to the correct part of options.
* @return Return the filter mode.
*/
-FilterMode::Type RetrieveFilterMode( unsigned int options, int mask, int bitShift )
+unsigned int RetrieveSamplingParameter( unsigned int options, int mask, int bitShift )
{
unsigned int index = options & mask;
index = ( index >> bitShift ); // Zero based index for array
-
- DALI_ASSERT_DEBUG( index < FILTER_MODE_COUNT );
-
- return FILTER_MODE_OPTIONS[ index ];
+ return index;
}
-unsigned int PackBitfield( FilterMode::Type minify, FilterMode::Type magnify )
+unsigned int PackBitfield( FilterMode::Type minify, FilterMode::Type magnify, WrapMode::Type uWrap, WrapMode::Type vWrap )
{
unsigned int bitfield = 0;
- StoreFilterMode( bitfield, minify, MINIFY_BIT_SHIFT );
- StoreFilterMode( bitfield, magnify, MAGNIFY_BIT_SHIFT );
+ StoreSamplingParameter( bitfield, minify, MINIFY_BIT_SHIFT );
+ StoreSamplingParameter( bitfield, magnify, MAGNIFY_BIT_SHIFT );
+ StoreSamplingParameter( bitfield, uWrap, UWRAP_BIT_SHIFT );
+ StoreSamplingParameter( bitfield, vWrap, VWRAP_BIT_SHIFT );
return bitfield;
}
FilterMode::Type GetMinifyFilterMode( unsigned int bitfield )
{
- return RetrieveFilterMode( bitfield, MASK_MINIFY_FILTER, MINIFY_BIT_SHIFT );
+ return static_cast<FilterMode::Type>( RetrieveSamplingParameter( bitfield, MASK_MINIFY_FILTER, MINIFY_BIT_SHIFT ) );
}
FilterMode::Type GetMagnifyFilterMode( unsigned int bitfield )
{
- return RetrieveFilterMode( bitfield, MASK_MAGNIFY_FILTER, MAGNIFY_BIT_SHIFT );
+ return static_cast<FilterMode::Type>( RetrieveSamplingParameter( bitfield, MASK_MAGNIFY_FILTER, MAGNIFY_BIT_SHIFT ) );
+}
+
+WrapMode::Type GetUWrapMode( unsigned int bitfield )
+{
+ return static_cast<WrapMode::Type>( RetrieveSamplingParameter( bitfield, MASK_UWRAP_MODE, UWRAP_BIT_SHIFT ) );
+}
+
+WrapMode::Type GetVWrapMode( unsigned int bitfield )
+{
+ return static_cast<WrapMode::Type>( RetrieveSamplingParameter( bitfield, MASK_VWRAP_MODE, VWRAP_BIT_SHIFT ) );
}
} // namespace ImageSampler
// INTERNAL INCLUDES
#include <dali/public-api/actors/sampling.h>
+#include <dali/integration-api/image-integ.h>
namespace Dali
{
*/
namespace ImageSampler
{
+ /**
+ * Bitshift values
+ */
+ enum
+ {
+ MINIFY_BIT_SHIFT = 0,
+ MAGNIFY_BIT_SHIFT = 4,
+ UWRAP_BIT_SHIFT = 8,
+ VWRAP_BIT_SHIFT = 12
+ };
+
+ /**
+ * Mask values
+ */
+ enum
+ {
+ MASK_MINIFY_FILTER = 0x000F,
+ MASK_MAGNIFY_FILTER = 0x00F0,
+ MASK_UWRAP_MODE = 0x0F00,
+ MASK_VWRAP_MODE = 0xF000,
+ };
+
+ /**
+ * Precalculate default sampler bitfield
+ */
+ enum
+ {
+ DEFAULT_BITFIELD = (Dali::FilterMode::DEFAULT<<MINIFY_BIT_SHIFT) | (Dali::FilterMode::DEFAULT<<MAGNIFY_BIT_SHIFT) | (Dali::WrapMode::DEFAULT<<UWRAP_BIT_SHIFT) | (Dali::WrapMode::DEFAULT<<VWRAP_BIT_SHIFT)
+ };
+
/**
* @brief Pack the filter mode into a bitfield.
*
* @param[in] magnify The magnification filter.
* @return Return the packed bitfield.
*/
- unsigned int PackBitfield( FilterMode::Type minify, FilterMode::Type magnify );
+ unsigned int PackBitfield( FilterMode::Type minify, FilterMode::Type magnify, WrapMode::Type uWrap = WrapMode::DEFAULT, WrapMode::Type vWrap = WrapMode::DEFAULT );
/**
* @brief Return the minification filter from a packed bitfield.
*/
FilterMode::Type GetMagnifyFilterMode( unsigned int bitfield );
+ /**
+ * @brief Return the wrap mode in x direction from a packed bitfield.
+ *
+ * @return Return the wrap mode.
+ */
+ WrapMode::Type GetUWrapMode( unsigned int bitfield );
+
+ /**
+ * @brief Return the wrap mode in y direction from a packed bitfield.
+ *
+ * @return Return the wrap mode.
+ */
+ WrapMode::Type GetVWrapMode( unsigned int bitfield );
+
} // namespace ImageSampler
} // namespace Internal
unsigned int* MessageBuffer::ReserveMessageSlot( std::size_t size )
{
- Dali::Mutex::ScopedLock lock(mMutex);
DALI_ASSERT_DEBUG( 0 != size );
// Number of aligned words required to handle a message of size in bytes
// EXTERNAL INCLUDES
#include <cstddef>
-// INTERNAL INCLUDES
-#include <dali/devel-api/common/mutex.h>
-
namespace Dali
{
std::size_t mCapacity; ///< The memory allocated with respect to sizeof(WordType)
std::size_t mSize; ///< The memory reserved for messages with respect to sizeof(WordType)
- Dali::Mutex mMutex; ///< Mutex to ensure correct access locking
};
} // namespace Internal
--- /dev/null
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// HEADER
+#include <dali/internal/common/mutex-impl.h>
+
+
+#ifdef LOCK_BACKTRACE_ENABLED
+// EXTERNAL INCLUDES
+#include <cstdlib>
+#include <execinfo.h>
+
+// INTERNAL INCLUDES
+#include <dali/public-api/common/dali-common.h>
+#include <dali/integration-api/debug.h>
+
+#endif // LOCK_BACKTRACE_ENABLED
+
+namespace Dali
+{
+#ifdef LOCK_BACKTRACE_ENABLED
+extern std::string Demangle( const char* symbol );
+#endif // LOCK_BACKTRACE_ENABLED
+
+namespace Internal
+{
+
+namespace Mutex
+{
+
+namespace
+{
+#ifdef LOCK_BACKTRACE_ENABLED
+
+// Constants
+const unsigned int MAX_NUM_STACK_FRAMES = 4;
+const unsigned int MAX_LOCK_SUPPORT = 5;
+
+struct BackTraceInfo
+{
+ void * frameArray[ MAX_NUM_STACK_FRAMES ]; ///< Stores the frame array where the lock occurred
+ int size; ///< Number of frames in the frame array (can be less than MAX_NUM_STACK_FRAMES)
+};
+
+__thread BackTraceInfo gBackTraceInfo[ MAX_LOCK_SUPPORT ]; ///< Thread local storage for the backtrace of the locks
+
+#endif // LOCK_BACKTRACE_ENABLED
+
+__thread unsigned int gThreadLockCount = 0; ///<
+} // unnamed namespace
+
+void Lock( pthread_mutex_t* mutex )
+{
+ ++gThreadLockCount;
+
+#ifdef LOCK_BACKTRACE_ENABLED
+
+ if( gThreadLockCount <= MAX_LOCK_SUPPORT )
+ {
+ // Store the frame array for this lock
+ int backTraceIndex = gThreadLockCount - 1;
+ gBackTraceInfo[ backTraceIndex ].size = backtrace( gBackTraceInfo[ backTraceIndex ].frameArray, MAX_NUM_STACK_FRAMES );
+ }
+ else
+ {
+ DALI_LOG_ERROR( "Reached Maximum lock backtrace support. Previous Locks:\n" );
+ }
+
+ // If we've got more than one lock, then show a warning with a backtrace for all locks that we currently hold
+ if( gThreadLockCount > 1 )
+ {
+ for( unsigned int i = 0; ( i < gThreadLockCount ) && ( i < MAX_LOCK_SUPPORT ); ++i )
+ {
+ DALI_LOG_WARNING( "[Lock %d]\n", i+1 );
+ char** symbols = backtrace_symbols( gBackTraceInfo[ i ].frameArray, gBackTraceInfo[ i ].size );
+ for( int j = 1; j < gBackTraceInfo[ i ].size; ++j )
+ {
+ std::string demangled_symbol = Demangle( symbols[ j ] );
+ DALI_LOG_WARNING( " [%02d] %s\n", j, demangled_symbol.c_str() );
+ }
+ free(symbols);
+ }
+ DALI_LOG_WARNING( "====================================\n" );
+ }
+
+#else
+
+ // TODO: Uncomment when locks held per thread at any given time are 1
+ //DALI_ASSERT_DEBUG( gThreadLockCount == 1 );
+
+#endif // LOCK_BACKTRACE_ENABLED
+
+ pthread_mutex_lock( mutex );
+}
+
+void Unlock( pthread_mutex_t* mutex )
+{
+ pthread_mutex_unlock( mutex );
+ --gThreadLockCount;
+}
+
+} // namespace Mutex
+
+} // namespace Internal
+
+} // namespace Dali
--- /dev/null
+#ifndef __DALI_INTERNAL_MUTEX_H__
+#define __DALI_INTERNAL_MUTEX_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include <pthread.h>
+
+namespace Dali
+{
+
+namespace Internal
+{
+
+/**
+ * @brief Namespace to ensure mutex locking is done correctly.
+ *
+ * Displays warnings if two mutex locks are not held by the same thread at any given time which can lead to deadlock.
+ * This can lead to deadlock and should be avoided.
+ *
+ * @note lock backtrace needs to be enabled to see the warnings.
+ */
+namespace Mutex
+{
+
+/**
+ * @brief Locks the given mutex.
+ *
+ * Increments a thread-local storage counter.
+ *
+ * @param A pointer to the mutex that should be locked.
+ *
+ * @note If the counter is > 1 and lock backtrace is enabled, then the backtrace for all locks will be shown as a warning.
+ */
+void Lock( pthread_mutex_t* mutex );
+
+/**
+ * @brief Unlocks the given mutex.
+ *
+ * @param A pointer to the mutex that should be unlocked.
+ *
+ * Decrements a thread-local storage counter.
+ */
+void Unlock( pthread_mutex_t* mutex );
+
+} // namespace Mutex
+
+} // namespace Internal
+
+} // namespace Dali
+
+#endif // __DALI_INTERNAL_MUTEX_H__
+++ /dev/null
-/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-// CLASS HEADER
-#include <dali/internal/event/actor-attachments/renderer-attachment-impl.h>
-
-// INTERNAL INCLUDES
-#include <dali/internal/event/common/event-thread-services.h>
-#include <dali/internal/update/manager/update-manager.h>
-#include <dali/internal/update/node-attachments/scene-graph-renderer-attachment.h>
-
-namespace Dali
-{
-
-namespace Internal
-{
-
-RendererAttachmentPtr RendererAttachment::New( EventThreadServices& eventThreadServices, const SceneGraph::Node& parentNode, Renderer& renderer )
-{
- RendererAttachmentPtr attachment( new RendererAttachment( eventThreadServices ) );
-
- if( attachment )
- {
- attachment->Initialize( eventThreadServices, parentNode, renderer );
- }
- return attachment;
-}
-
-void RendererAttachment::Initialize( EventThreadServices& eventThreadServices, const SceneGraph::Node& parentNode, Renderer& renderer )
-{
- SceneGraph::RendererAttachment* sceneObject = renderer.GetRendererSceneObject();
-
- // Takes ownership of scene object
- AttachToNodeMessage( eventThreadServices.GetUpdateManager(), parentNode, sceneObject );
-
- // Connect to renderer
- mRendererConnector.Set( renderer, false );
-
- // Keep raw pointer for message passing
- mSceneObject = sceneObject;
-}
-
-RendererAttachment::RendererAttachment( EventThreadServices& eventThreadServices )
-: RenderableAttachment(eventThreadServices),
- mSceneObject(NULL)
-{
-}
-
-RendererAttachment::~RendererAttachment()
-{
-}
-
-const SceneGraph::RendererAttachment& RendererAttachment::GetSceneObject() const
-{
- DALI_ASSERT_DEBUG( mSceneObject != NULL );
- return *mSceneObject;
-}
-
-void RendererAttachment::OnStageConnection2()
-{
- mRendererConnector.OnStageConnect();
-}
-
-void RendererAttachment::OnStageDisconnection2()
-{
- mRendererConnector.OnStageDisconnect();
-}
-
-} // namespace Internal
-
-} // namespace Dali
+++ /dev/null
-#ifndef DALI_INTERNAL_RENDERER_ATTACHMENT_H
-#define DALI_INTERNAL_RENDERER_ATTACHMENT_H
-
-/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-// INTERNAL INCLUDES
-#include <dali/internal/event/actor-attachments/renderable-attachment-impl.h>
-#include <dali/internal/event/common/object-connector.h>
-#include <dali/internal/event/rendering/renderer-impl.h>
-
-namespace Dali
-{
-
-namespace Internal
-{
-
-namespace SceneGraph
-{
-class Node;
-class RendererAttachment;
-}
-
-class RendererAttachment;
-typedef IntrusivePtr<RendererAttachment> RendererAttachmentPtr;
-
-/**
- * An attachment for rendering renderers.
- *
- * Currently, the Renderer object creates the SceneGraph::RendererAttachment object, not this. It is attached
- * here as needed.
- */
-class RendererAttachment : public RenderableAttachment
-{
-public:
-
- /**
- * Create a new RendererAttachment.
- * @param[in] eventThreadServices Used for messaging to and reading from the SceneGraph
- * @param[in] parentNode The node to attach a scene-object to.
- * @poaram[in] renderer The renderer for this attachment
- * @return A smart-pointer to the newly allocated RendererAttachment.
- */
- static RendererAttachmentPtr New( EventThreadServices& eventThreadServices, const SceneGraph::Node& parentNode, Renderer& renderer );
-
-
- /**
- * Second stage initialization
- *
- * @param[in] eventThreadServices Used for messaging to and reading from the SceneGraph
- * @param[in] parentNode The node to attach a scene-object to.
- * @poaram[in] renderer The renderer for this attachment
- */
- void Initialize( EventThreadServices& eventThreadServices, const SceneGraph::Node& parentNode, Renderer& renderer );
-
- /**
- * Get the renderer
- *
- * @return The renderer
- */
- Renderer& GetRenderer()
- {
- return *mRendererConnector.Get();
- }
-
-private:
-
- /**
- * First stage construction of a RendererAttachment.
- * @param[in] eventThreadServices Used for messaging to and reading from the SceneGraph
- */
- RendererAttachment( EventThreadServices& eventThreadServices );
-
- /**
- * @copydoc Dali::Internal::RenderableAttachment::GetSceneObject()
- */
- virtual const SceneGraph::RendererAttachment& GetSceneObject() const;
-
- /**
- * @copydoc Dali::Internal::RenderableAttachment::OnStageConnection2()
- */
- virtual void OnStageConnection2();
-
- /**
- * @copydoc Dali::Internal::RenderableAttachment::OnStageDisconnection2()
- */
- virtual void OnStageDisconnection2();
-
-protected:
-
- /**
- * A reference counted object may only be deleted by calling Unreference()
- */
- virtual ~RendererAttachment();
-
-private:
- const SceneGraph::RendererAttachment* mSceneObject; ///< Not owned
-
- ObjectConnector<Renderer> mRendererConnector;
-};
-
-} // namespace Internal
-
-} // namespace Dali
-
-#endif // DALI_INTERNAL_RENDERER_ATTACHMENT_H
#include <dali/internal/event/common/stage-impl.h>
#include <dali/internal/event/common/type-info-impl.h>
#include <dali/internal/event/actor-attachments/actor-attachment-impl.h>
-#include <dali/internal/event/actor-attachments/renderer-attachment-impl.h>
#include <dali/internal/event/animation/constraint-impl.h>
#include <dali/internal/event/common/projection.h>
#include <dali/internal/event/size-negotiation/relayout-controller-impl.h>
void Actor::SetSize( const Vector2& size )
{
- SetSize( Vector3( size.width, size.height, CalculateSizeZ( size ) ) );
+ SetSize( Vector3( size.width, size.height, 0.f ) );
}
void Actor::SetSizeInternal( const Vector2& size )
{
- SetSizeInternal( Vector3( size.width, size.height, CalculateSizeZ( size ) ) );
-}
-
-float Actor::CalculateSizeZ( const Vector2& size ) const
-{
- return std::min( size.width, size.height );
+ SetSizeInternal( Vector3( size.width, size.height, 0.f ) );
}
void Actor::SetSize( const Vector3& size )
{
if( IsRelayoutEnabled() && !mRelayoutData->insideRelayout )
{
+ // TODO we cannot just ignore the given Z but that means rewrite the size negotiation!!
SetPreferredSize( size.GetVectorXY() );
}
else
unsigned int Actor::AddRenderer( Renderer& renderer )
{
- //TODO: MESH_REWORK : Add support for multiple renderers
- if ( ! mAttachment )
+ if( !mRenderers )
{
- mAttachment = RendererAttachment::New( GetEventThreadServices(), *mNode, renderer );
- if( mIsOnStage )
- {
- mAttachment->Connect();
- }
+ mRenderers = new RendererContainer;
+ }
+
+ unsigned int index = mRenderers->size();
+ RendererPtr rendererPtr = RendererPtr( &renderer );
+ mRenderers->push_back( rendererPtr );
+ AddRendererMessage( GetEventThreadServices(), *mNode, renderer.GetRendererSceneObject() );
+
+ if( mIsOnStage)
+ {
+ rendererPtr->Connect();
}
- return 0;
+ return index;
}
unsigned int Actor::GetRendererCount() const
{
- //TODO: MESH_REWORK : Add support for multiple renderers
- RendererAttachment* attachment = dynamic_cast<RendererAttachment*>(mAttachment.Get());
- return attachment ? 1u : 0u;
+ unsigned int rendererCount(0);
+ if( mRenderers )
+ {
+ rendererCount = mRenderers->size();
+ }
+
+ return rendererCount;
}
-Renderer& Actor::GetRendererAt( unsigned int index )
+RendererPtr Actor::GetRendererAt( unsigned int index )
{
- //TODO: MESH_REWORK : Add support for multiple renderers
- DALI_ASSERT_DEBUG( index == 0 && "Only one renderer is supported." );
-
- //TODO: MESH_REWORK : Temporary code
- RendererAttachment* attachment = dynamic_cast<RendererAttachment*>(mAttachment.Get());
- DALI_ASSERT_ALWAYS( attachment && "Actor doesn't have a renderer" );
+ RendererPtr renderer;
+ if( index < GetRendererCount() )
+ {
+ renderer = ( *mRenderers )[ index ];
+ }
- return attachment->GetRenderer();
+ return renderer;
}
void Actor::RemoveRenderer( Renderer& renderer )
{
- //TODO: MESH_REWORK : Add support for multiple renderers
- mAttachment = NULL;
+ if( mRenderers )
+ {
+ RendererIter end = mRenderers->end();
+ for( RendererIter iter = mRenderers->begin(); iter != end; ++iter )
+ {
+ if( (*iter).Get() == &renderer )
+ {
+ mRenderers->erase( iter );
+ RemoveRendererMessage( GetEventThreadServices(), *mNode, renderer.GetRendererSceneObject() );
+ break;
+ }
+ }
+ }
}
void Actor::RemoveRenderer( unsigned int index )
{
- //TODO: MESH_REWORK : Add support for multiple renderers
- mAttachment = NULL;
+ if( index < GetRendererCount() )
+ {
+ RendererPtr renderer = ( *mRenderers )[ index ];
+ RemoveRendererMessage( GetEventThreadServices(), *mNode, renderer.Get()->GetRendererSceneObject() );
+ mRenderers->erase( mRenderers->begin()+index );
+ }
}
void Actor::SetOverlay( bool enable )
Actor::Actor( DerivedType derivedType )
: mParent( NULL ),
mChildren( NULL ),
+ mRenderers( NULL ),
mNode( NULL ),
mParentOrigin( NULL ),
mAnchorPoint( NULL ),
}
}
delete mChildren;
+ delete mRenderers;
// Guard to allow handle destruction after Core has been destroyed
if( EventThreadServices::IsCoreRunning() )
}
}
-void Actor::ConnectToStage( unsigned int parentDepth, int index )
+void Actor::ConnectToStage( unsigned int parentDepth )
{
- // This container is used instead of walking the Actor hierachy.
- // It protects us when the Actor hierachy is modified during OnStageConnectionExternal callbacks.
+ // This container is used instead of walking the Actor hierarchy.
+ // It protects us when the Actor hierarchy is modified during OnStageConnectionExternal callbacks.
ActorContainer connectionList;
-
- // This stage is atomic i.e. not interrupted by user callbacks
- RecursiveConnectToStage( connectionList, parentDepth+1, index );
+ // This stage is atomic i.e. not interrupted by user callbacks.
+ RecursiveConnectToStage( connectionList, parentDepth + 1 );
// Notify applications about the newly connected actors.
const ActorIter endIter = connectionList.end();
RelayoutRequest();
}
-void Actor::RecursiveConnectToStage( ActorContainer& connectionList, unsigned int depth, int index )
+void Actor::RecursiveConnectToStage( ActorContainer& connectionList, unsigned int depth )
{
DALI_ASSERT_ALWAYS( !OnStage() );
mIsOnStage = true;
mDepth = depth;
- ConnectToSceneGraph( index );
+ ConnectToSceneGraph();
// Notification for internal derived classes
OnStageConnectionInternal();
* This method is called when the Actor is connected to the Stage.
* The parent must have added its Node to the scene-graph.
* The child must connect its Node to the parent's Node.
- * This is resursive; the child calls ConnectToStage() for its children.
+ * This is recursive; the child calls ConnectToStage() for its children.
*/
-void Actor::ConnectToSceneGraph( int index )
+void Actor::ConnectToSceneGraph()
{
DALI_ASSERT_DEBUG( mNode != NULL); DALI_ASSERT_DEBUG( mParent != NULL); DALI_ASSERT_DEBUG( mParent->mNode != NULL );
if( NULL != mNode )
{
// Reparent Node in next Update
- ConnectNodeMessage( GetEventThreadServices().GetUpdateManager(), *(mParent->mNode), *mNode, index );
+ ConnectNodeMessage( GetEventThreadServices().GetUpdateManager(), *(mParent->mNode), *mNode );
}
// Notify attachment
mAttachment->Connect();
}
+ unsigned int rendererCount( GetRendererCount() );
+ for( unsigned int i(0); i<rendererCount; ++i )
+ {
+ GetRendererAt(i)->Connect();
+ }
+
// Request relayout on all actors that are added to the scenegraph
RelayoutRequest();
{
mAttachment->Disconnect();
}
+
+ unsigned int rendererCount( GetRendererCount() );
+ for( unsigned int i(0); i<rendererCount; ++i )
+ {
+ GetRendererAt(i)->Disconnect();
+ }
}
void Actor::NotifyStageDisconnection()
return componentIndex;
}
-void Actor::SetParent( Actor* parent, int index )
+void Actor::SetParent( Actor* parent )
{
if( parent )
{
parent->OnStage() )
{
// Instruct each actor to create a corresponding node in the scene graph
- ConnectToStage( parent->GetHierarchyDepth(), index );
+ ConnectToStage( parent->GetHierarchyDepth() );
}
}
else // parent being set to NULL
{
if ( mRelayoutData )
{
- return mRelayoutData->preferredSize;
+ return Vector2( mRelayoutData->preferredSize );
}
return GetDefaultPreferredSize();
typedef ActorContainer::iterator ActorIter;
typedef ActorContainer::const_iterator ActorConstIter;
+typedef std::vector< RendererPtr > RendererContainer;
+typedef RendererContainer::iterator RendererIter;
+
/**
* Actor is the primary object which Dali applications interact with.
* UI controls can be built by combining multiple actors.
/**
* @copydoc Dali::Actor::GetRendererAt()
*/
- Renderer& GetRendererAt( unsigned int index );
+ RendererPtr GetRendererAt( unsigned int index );
/**
* @copydoc Dali::Actor::RemoveRenderer()
/**
* Called on a child during Add() when the parent actor is connected to the Stage.
- * @param[in] stage The stage.
- * @param[in] parentDepth The depth of the parent in the hierarchy
- * @param[in] index If set, it is only used for positioning the actor within the parent's child list.
+ * @param[in] parentDepth The depth of the parent in the hierarchy.
*/
- void ConnectToStage( unsigned int parentDepth, int index = -1 );
+ void ConnectToStage( unsigned int parentDepth );
/**
* Helper for ConnectToStage, to recursively connect a tree of actors.
* This is atomic i.e. not interrupted by user callbacks.
- * @param[in] index If set, it is only used for positioning the actor within the parent's child list.
- * @param[in] depth The depth in the hierarchy of the actor
+ * @param[in] depth The depth in the hierarchy of the actor
* @param[out] connectionList On return, the list of connected actors which require notification.
*/
- void RecursiveConnectToStage( ActorContainer& connectionList, unsigned int depth, int index = -1 );
+ void RecursiveConnectToStage( ActorContainer& connectionList, unsigned int depth );
/**
* Connect the Node associated with this Actor to the scene-graph.
- * @param[in] index If set, it is only used for positioning the actor within the parent's child list.
*/
- void ConnectToSceneGraph( int index = -1 );
+ void ConnectToSceneGraph();
/**
* Helper for ConnectToStage, to notify a connected actor through the public API.
*/
bool IsNodeConnected() const;
- /**
- * Calculate the size of the z dimension for a 2D size
- *
- * @param[in] size The 2D size (X, Y) to calculate Z from
- *
- * @return Return the Z dimension for this size
- */
- float CalculateSizeZ( const Vector2& size ) const;
-
public:
+
// Default property extensions from Object
/**
/**
* Set the actors parent.
* @param[in] parent The new parent.
- * @param[in] index If set, it is only used for positioning the actor within the parent's child list.
*/
- void SetParent( Actor* parent, int index = -1 );
+ void SetParent( Actor* parent );
/**
* Helper to create a Node for this Actor.
Actor* mParent; ///< Each actor (except the root) can have one parent
ActorContainer* mChildren; ///< Container of referenced actors
+ RendererContainer* mRenderers; ///< Renderer container
+
const SceneGraph::Node* mNode; ///< Not owned
Vector3* mParentOrigin; ///< NULL means ParentOrigin::DEFAULT. ParentOrigin is non-animatable
Vector3* mAnchorPoint; ///< NULL means AnchorPoint::DEFAULT. AnchorPoint is non-animatable
void ImageActor::OnInitialize()
{
+ // TODO: Remove this, at the moment its needed for size negotiation to work
SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::ALL_DIMENSIONS );
}
{
newImage = ninePatchImage->CreateCroppedBufferImage();
SetStyle( Dali::ImageActor::STYLE_NINE_PATCH );
- SetNinePatchBorder( ninePatchImage->GetStretchBorders(), true );
+
+ const Integration::StretchRanges& stretchPixelsX = ninePatchImage->GetStretchPixelsX();
+ const Integration::StretchRanges& stretchPixelsY = ninePatchImage->GetStretchPixelsY();
+
+ if( stretchPixelsX.Size() > 0 && stretchPixelsY.Size() > 0 )
+ {
+ Vector4 border;
+ //The NinePatchImage stretch pixels are in the cropped image space, inset by 1 to get it to uncropped image space
+ border.x = stretchPixelsX[ 0 ].GetX() + 1;
+ border.y = stretchPixelsY[ 0 ].GetX() + 1;
+ border.z = image->GetWidth() - stretchPixelsX[ 0 ].GetY() - 1;
+ border.w = image->GetHeight() - stretchPixelsY[ 0 ].GetY() - 1;
+
+ SetNinePatchBorder( border, true );
+ }
}
}
// set the actual image (normal or 9 patch) and natural size based on that
Vector3 ImageActor::GetNaturalSize() const
{
Vector2 naturalSize( CalculateNaturalSize() );
- return Vector3( naturalSize.width, naturalSize.height, CalculateSizeZ( naturalSize ) );
+ return Vector3( naturalSize.width, naturalSize.height, 0.f );
}
Vector2 ImageActor::CalculateNaturalSize() const
// INTERNAL INCLUDES
#include <dali/internal/common/owner-pointer.h>
-#include <dali/internal/common/owner-container.h>
+#include <dali/devel-api/common/owner-container.h>
#include <dali/public-api/animation/alpha-function.h>
#include <dali/public-api/animation/time-period.h>
#include <dali/public-api/common/dali-common.h>
// INTERNAL INCLUDES
#include <dali/internal/event/common/property-helper.h>
#include <dali/public-api/object/property-array.h>
+#include <dali/public-api/object/type-registry.h>
namespace Dali
{
const Dali::Matrix BezierBasis = Dali::Matrix( BezierBasisCoeff );
+
+Dali::BaseHandle Create()
+{
+ return Dali::Path::New();
+}
+
+Dali::TypeRegistration mType( typeid(Dali::Path), typeid(Dali::Handle), Create );
+
} //Unnamed namespace
Path* Path::New()
// INTERNAL INCLUDES
#include <dali/public-api/common/dali-common.h>
-#include <dali/devel-api/common/mutex.h>
-#include <dali/internal/common/owner-container.h>
+#include <dali/devel-api/common/owner-container.h>
+#include <dali/devel-api/threading/mutex.h>
#include <dali/internal/common/message.h>
#include <dali/internal/event/common/property-notification-impl.h>
#include <dali/internal/event/common/complete-notification-interface.h>
#include <dali/public-api/object/property-index-ranges.h>
#include <dali/public-api/object/property-input.h>
#include <dali/public-api/object/property-notification.h>
-#include <dali/internal/common/owner-container.h>
+#include <dali/devel-api/common/owner-container.h>
#include <dali/internal/event/common/event-thread-services.h>
#include <dali/internal/event/common/property-input-impl.h>
#include <dali/internal/event/common/property-metadata.h>
#include <algorithm> // std::sort
// INTERNAL INCLUDES
-#include <dali/public-api/object/type-registry.h>
#include <dali/devel-api/object/property-buffer.h> // Dali::Internal::PropertyBuffer
-
-#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
-#include <dali/internal/update/common/scene-graph-property-buffer.h>
+#include <dali/internal/event/common/stage-impl.h>
#include <dali/internal/update/manager/update-manager.h>
namespace Dali
namespace Internal
{
-using SceneGraph::PropertyBufferMetadata::Format;
-using SceneGraph::PropertyBufferMetadata::Component;
-
namespace
{
/**
- * |name |type |writable|animatable|constraint-input|enum for index-checking|
- */
-DALI_PROPERTY_TABLE_BEGIN
-DALI_PROPERTY( "size", INTEGER, true, false, true, Dali::PropertyBuffer::Property::SIZE )
-DALI_PROPERTY( "buffer-format", MAP, false, false, false, Dali::PropertyBuffer::Property::BUFFER_FORMAT )
-DALI_PROPERTY_TABLE_END( DEFAULT_ACTOR_PROPERTY_START_INDEX )
-
-const ObjectImplHelper<DEFAULT_PROPERTY_COUNT> PROPERTY_BUFFER_IMPL = { DEFAULT_PROPERTY_DETAILS };
-
-BaseHandle Create()
-{
- return Dali::BaseHandle();
-}
-
-TypeRegistration mType( typeid( Dali::PropertyBuffer ), typeid( Dali::Handle ), Create );
-
-/**
* Calculate the alignment requirements of a type
*
* This is used to calculate the memory alignment requirements of a type
SizeChanged();
- SceneGraph::SetSizeMessage( GetEventThreadServices(),
- *mSceneObject,
- mSize );
+ SceneGraph::SetPropertyBufferSize(mEventThreadServices.GetUpdateManager(),*mRenderObject, mSize );
}
std::size_t PropertyBuffer::GetSize() const
const char* source = static_cast<const char*>( data );
std::copy( source, source + mBuffer.Size(), &mBuffer[0] );
- SceneGraph::SetDataMessage( GetEventThreadServices(),
- *mSceneObject,
- new SceneGraph::PropertyBuffer::BufferType( mBuffer ) );
-}
-
-const SceneGraph::PropertyBuffer* PropertyBuffer::GetPropertyBufferSceneObject() const
-{
- return mSceneObject;
+ SceneGraph::SetPropertyBufferData(mEventThreadServices.GetUpdateManager(),*mRenderObject,new Dali::Vector<char>( mBuffer ));
}
void PropertyBuffer::SetFormat( Dali::Property::Map& format )
FormatChanged();
}
-unsigned int PropertyBuffer::GetDefaultPropertyCount() const
+const Render::PropertyBuffer* PropertyBuffer::GetRenderObject() const
{
- return PROPERTY_BUFFER_IMPL.GetDefaultPropertyCount();
-}
-
-void PropertyBuffer::GetDefaultPropertyIndices( Property::IndexContainer& indices ) const
-{
- PROPERTY_BUFFER_IMPL.GetDefaultPropertyIndices( indices );
-}
-
-const char* PropertyBuffer::GetDefaultPropertyName(Property::Index index) const
-{
- return PROPERTY_BUFFER_IMPL.GetDefaultPropertyName( index );
-}
-
-Property::Index PropertyBuffer::GetDefaultPropertyIndex( const std::string& name ) const
-{
- return PROPERTY_BUFFER_IMPL.GetDefaultPropertyIndex( name );
-}
-
-bool PropertyBuffer::IsDefaultPropertyWritable( Property::Index index ) const
-{
- return PROPERTY_BUFFER_IMPL.IsDefaultPropertyWritable( index );
-}
-
-bool PropertyBuffer::IsDefaultPropertyAnimatable( Property::Index index ) const
-{
- return PROPERTY_BUFFER_IMPL.IsDefaultPropertyAnimatable( index );
-}
-
-bool PropertyBuffer::IsDefaultPropertyAConstraintInput( Property::Index index ) const
-{
- return PROPERTY_BUFFER_IMPL.IsDefaultPropertyAConstraintInput( index );
-}
-
-Property::Type PropertyBuffer::GetDefaultPropertyType( Property::Index index ) const
-{
- return PROPERTY_BUFFER_IMPL.GetDefaultPropertyType( index );
-}
-
-void PropertyBuffer::SetDefaultProperty( Property::Index index,
- const Property::Value& propertyValue )
-{
- switch( index )
- {
- case Dali::PropertyBuffer::Property::SIZE:
- {
- SetSize( propertyValue.Get<int>() );
- break;
- }
- case Dali::PropertyBuffer::Property::BUFFER_FORMAT:
- {
- DALI_ASSERT_ALWAYS( 0 && "MESH_REWORK" );
- break;
- }
- }
-}
-
-void PropertyBuffer::SetSceneGraphProperty( Property::Index index,
- const PropertyMetadata& entry,
- const Property::Value& value )
-{
- PROPERTY_BUFFER_IMPL.SetSceneGraphProperty( GetEventThreadServices(), this, index, entry, value );
-}
-
-Property::Value PropertyBuffer::GetDefaultProperty( Property::Index index ) const
-{
- Property::Value value;
-
- switch( index )
- {
- case Dali::PropertyBuffer::Property::SIZE:
- {
- value = static_cast<int>( GetSize() );
- break;
- }
- case Dali::PropertyBuffer::Property::BUFFER_FORMAT:
- {
- DALI_ASSERT_ALWAYS( 0 && "MESH_REWORK" );
- break;
- }
- }
- return value;
-}
-
-const SceneGraph::PropertyOwner* PropertyBuffer::GetPropertyOwner() const
-{
- return mSceneObject;
-}
-
-const SceneGraph::PropertyOwner* PropertyBuffer::GetSceneObject() const
-{
- return mSceneObject;
-}
-
-const SceneGraph::PropertyBase* PropertyBuffer::GetSceneObjectAnimatableProperty( Property::Index index ) const
-{
- DALI_ASSERT_ALWAYS( IsPropertyAnimatable(index) && "Property is not animatable" );
- const SceneGraph::PropertyBase* property = NULL;
-
- if( OnStage() )
- {
- property = PROPERTY_BUFFER_IMPL.GetRegisteredSceneGraphProperty(
- this,
- &PropertyBuffer::FindAnimatableProperty,
- &PropertyBuffer::FindCustomProperty,
- index );
-
- if( property == NULL && index < DEFAULT_PROPERTY_MAX_COUNT )
- {
- DALI_ASSERT_ALWAYS( 0 && "Property is not animatable" );
- }
- }
-
- return property;
-}
-
-const PropertyInputImpl* PropertyBuffer::GetSceneObjectInputProperty( Property::Index index ) const
-{
- const PropertyInputImpl* property = NULL;
-
- if( OnStage() )
- {
- const SceneGraph::PropertyBase* baseProperty =
- PROPERTY_BUFFER_IMPL.GetRegisteredSceneGraphProperty( this,
- &PropertyBuffer::FindAnimatableProperty,
- &PropertyBuffer::FindCustomProperty,
- index );
- property = static_cast<const PropertyInputImpl*>( baseProperty );
-
- if( property == NULL && index < DEFAULT_PROPERTY_MAX_COUNT )
- {
- if( index == Dali::PropertyBuffer::Property::SIZE )
- {
- // @todo MESH_REWORK
- DALI_ASSERT_ALWAYS( 0 && "MESH_REWORK" );
- }
- }
- }
-
- return property;
-}
-
-int PropertyBuffer::GetPropertyComponentIndex( Property::Index index ) const
-{
- return Property::INVALID_COMPONENT_INDEX;
-}
-
-bool PropertyBuffer::OnStage() const
-{
- return mOnStage;
-}
-
-void PropertyBuffer::Connect()
-{
- mOnStage = true;
-}
-
-void PropertyBuffer::Disconnect()
-{
- mOnStage = false;
+ return mRenderObject;
}
PropertyBuffer::~PropertyBuffer()
{
- if( EventThreadServices::IsCoreRunning() )
+ if( EventThreadServices::IsCoreRunning() && mRenderObject)
{
- EventThreadServices& eventThreadServices = GetEventThreadServices();
- SceneGraph::UpdateManager& updateManager = eventThreadServices.GetUpdateManager();
- RemoveMessage( updateManager, updateManager.GetPropertyBufferOwner(), *mSceneObject );
-
- eventThreadServices.UnregisterObject( this );
+ SceneGraph::RemovePropertyBuffer( mEventThreadServices.GetUpdateManager(), *mRenderObject );
}
}
PropertyBuffer::PropertyBuffer()
-: mSceneObject( NULL ),
- mBufferFormat( NULL ),
- mSize( 0 ),
- mOnStage( false )
+:mEventThreadServices( *Stage::GetCurrent() )
+,mRenderObject(NULL)
+,mBufferFormat( NULL )
+,mSize( 0 )
{
}
void PropertyBuffer::Initialize()
{
- EventThreadServices& eventThreadServices = GetEventThreadServices();
- SceneGraph::UpdateManager& updateManager = eventThreadServices.GetUpdateManager();
-
- mSceneObject = new SceneGraph::PropertyBuffer();
- AddMessage( updateManager, updateManager.GetPropertyBufferOwner(), *mSceneObject );
-
- eventThreadServices.RegisterObject( this );
+ mRenderObject = new Render::PropertyBuffer();
+ SceneGraph::AddPropertyBuffer(mEventThreadServices.GetUpdateManager(), *mRenderObject );
}
void PropertyBuffer::FormatChanged()
// Create the format
DALI_ASSERT_DEBUG( mBufferFormat == NULL && "PropertyFormat should not be set yet" );
- Format* bufferFormat = new Format();
- bufferFormat->components.resize( numComponents );
+ Render::PropertyBuffer::Format* format = new Render::PropertyBuffer::Format();
+ format->components.resize( numComponents );
unsigned int currentAlignment = 0u;
unsigned int maxAlignmentRequired = 0u;
StringValuePair component = mFormat.GetPair( i );
// Get the name
- bufferFormat->components[i].name = component.first;
+ format->components[i].name = component.first;
// enums are stored in the map as int
Property::Type type = Property::Type( component.second.Get<int>() );
}
// write to the format
- bufferFormat->components[i].size = elementSize;
- bufferFormat->components[i].offset = currentAlignment;
- bufferFormat->components[i].type = type;
+ format->components[i].size = elementSize;
+ format->components[i].offset = currentAlignment;
+ format->components[i].type = type;
// update offset
currentAlignment += elementSize;
}
// Set the format size
- bufferFormat->size = currentAlignment;
-
- mBufferFormat = bufferFormat;
+ format->size = currentAlignment;
- SceneGraph::SetFormatMessage( GetEventThreadServices(),
- *mSceneObject,
- bufferFormat );
+ mBufferFormat = format;
+ SceneGraph::SetPropertyBufferFormat(mEventThreadServices.GetUpdateManager(), *mRenderObject, format );
if( mSize )
{
SizeChanged();
*
*/
-// EXTERNAL INCLUDES
-#include <utility> // std::pair
-
// INTERNAL INCLUDES
#include <dali/public-api/common/dali-common.h> // DALI_ASSERT_ALWAYS
#include <dali/public-api/common/intrusive-ptr.h> // Dali::IntrusivePtr
+#include <dali/public-api/object/base-object.h>
#include <dali/public-api/object/property-map.h> // Dali::Property::Map
#include <dali/devel-api/object/property-buffer.h> // Dali::PropertyBuffer
-#include <dali/internal/event/common/connectable.h> // Dali::Internal::Connectable
-#include <dali/internal/event/common/object-connector.h> // Dali::Internal::ObjectConnector
-#include <dali/internal/event/common/object-impl.h> // Dali::Internal::Object
+#include <dali/internal/event/common/event-thread-services.h>
+#include <dali/internal/render/renderers/render-property-buffer.h>
namespace Dali
{
namespace Internal
{
-namespace SceneGraph
-{
-class PropertyBuffer;
-
-namespace PropertyBufferMetadata
-{
-struct Format;
-} // namespace PropertyBufferMetadata
-
-} // namespace SceneGraph
class PropertyBuffer;
typedef IntrusivePtr<PropertyBuffer> PropertyBufferPtr;
* PropertyBuffer is an object that contains an array of structures of values that
* can be accessed as properties.
*/
-class PropertyBuffer : public Object, public Connectable
+class PropertyBuffer : public BaseObject
{
public:
void SetData( const void* data );
/**
- * @copydoc PropertBuffer::GetPropertyIndex()
- */
- Dali::Property::Index GetPropertyIndex( const std::string name, std::size_t index );
-
- /**
- * @brief Get the propertyBuffer scene object
- *
- * @return the propertyBuffer scene object
- */
- const SceneGraph::PropertyBuffer* GetPropertyBufferSceneObject() const;
-
- /**
* @brief Set the format of the PropertyBuffer
*
* @pre Has not been set yet
public: // Default property extensions from Object
/**
- * @copydoc Dali::Internal::Object::GetDefaultPropertyCount()
- */
- virtual unsigned int GetDefaultPropertyCount() const;
-
- /**
- * @copydoc Dali::Internal::Object::GetDefaultPropertyIndices()
- */
- virtual void GetDefaultPropertyIndices( Property::IndexContainer& indices ) const;
-
- /**
- * @copydoc Dali::Internal::Object::GetDefaultPropertyName()
- */
- virtual const char* GetDefaultPropertyName(Property::Index index) const;
-
- /**
- * @copydoc Dali::Internal::Object::GetDefaultPropertyIndex()
- */
- virtual Property::Index GetDefaultPropertyIndex(const std::string& name) const;
-
- /**
- * @copydoc Dali::Internal::Object::IsDefaultPropertyWritable()
- */
- virtual bool IsDefaultPropertyWritable(Property::Index index) const;
-
- /**
- * @copydoc Dali::Internal::Object::IsDefaultPropertyAnimatable()
- */
- virtual bool IsDefaultPropertyAnimatable(Property::Index index) const;
-
- /**
- * @copydoc Dali::Internal::Object::IsDefaultPropertyAConstraintInput()
- */
- virtual bool IsDefaultPropertyAConstraintInput( Property::Index index ) const;
-
- /**
- * @copydoc Dali::Internal::Object::GetDefaultPropertyType()
- */
- virtual Property::Type GetDefaultPropertyType(Property::Index index) const;
-
- /**
- * @copydoc Dali::Internal::Object::SetDefaultProperty()
- */
- virtual void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue);
-
- /**
- * @copydoc Dali::Internal::Object::SetSceneGraphProperty()
- */
- virtual void SetSceneGraphProperty( Property::Index index, const PropertyMetadata& entry, const Property::Value& value );
-
- /**
- * @copydoc Dali::Internal::Object::GetDefaultProperty()
- */
- virtual Property::Value GetDefaultProperty( Property::Index index ) const;
-
- /**
- * @copydoc Dali::Internal::Object::GetPropertyOwner()
- */
- virtual const SceneGraph::PropertyOwner* GetPropertyOwner() const;
-
- /**
- * @copydoc Dali::Internal::Object::GetSceneObject()
- */
- virtual const SceneGraph::PropertyOwner* GetSceneObject() const;
-
- /**
- * @copydoc Dali::Internal::Object::GetSceneObjectAnimatableProperty()
- */
- virtual const SceneGraph::PropertyBase* GetSceneObjectAnimatableProperty( Property::Index index ) const;
-
- /**
- * @copydoc Dali::Internal::Object::GetSceneObjectInputProperty()
- */
- virtual const PropertyInputImpl* GetSceneObjectInputProperty( Property::Index index ) const;
-
- /**
- * @copydoc Dali::Internal::Object::GetPropertyComponentIndex()
- */
- virtual int GetPropertyComponentIndex( Property::Index index ) const;
-
-public: // Functions from Connectable
- /**
- * @copydoc Dali::Internal::Connectable::OnStage()
- */
- virtual bool OnStage() const;
-
- /**
- * @copydoc Dali::Internal::Connectable::Contnect()
- */
- virtual void Connect();
-
- /**
- * @copydoc Dali::Internal::Connectable::Disconnect()
+ * @brief Get the render thread side of the PropertyBuffer
+ *
+ * @return The render thread side of this PropertyBuffer
*/
- virtual void Disconnect();
+ const Render::PropertyBuffer* GetRenderObject() const;
protected:
/**
PropertyBuffer& operator=( const PropertyBuffer& );
private: // data
- SceneGraph::PropertyBuffer* mSceneObject; ///< Update side object
+ EventThreadServices& mEventThreadServices; ///<Used to send messages to the render thread via update thread
+ Render::PropertyBuffer* mRenderObject; ///<Render side object
Property::Map mFormat; ///< Format of the property buffer
- const SceneGraph::PropertyBufferMetadata::Format* mBufferFormat; ///< Metadata for the format of the property buffer
+ const Render::PropertyBuffer::Format* mBufferFormat; ///< Metadata for the format of the property buffer
unsigned int mSize; ///< Number of elements in the buffer
Dali::Vector< char > mBuffer; // Data of the property-buffer
-
- bool mOnStage; ///< Flag to know if the object is on stage
};
/**
{
/**
- * These dummy values are used to handle PropertyInputImpl errors
- */
-static const bool DUMMY_BOOLEAN_VALUE( false );
-static const float DUMMY_FLOAT_VALUE( 0.0f );
-static const int DUMMY_INTEGER_VALUE( 0 );
-static const Vector2 DUMMY_VECTOR2_VALUE( 0.0f, 0.0f );
-static const Vector3 DUMMY_VECTOR3_VALUE( 0.0f, 0.0f, 0.0f );
-static const Vector4 DUMMY_VECTOR4_VALUE( 0.0f, 0.0f, 0.0f, 0.0f );
-static const Matrix3 DUMMY_MATRIX3_VALUE;
-static const Matrix DUMMY_MATRIX_VALUE;
-static const Quaternion DUMMY_QUATERNION_VALUE( 1.0f, 0.0f, 0.0f, 0.0f );
-
-/**
* An abstract interface for receiving property values, and for querying whether
* a property value has changed i.e. whether a constraint needs to be reapplied.
*/
virtual const bool& GetBoolean( BufferIndex bufferIndex ) const
{
DALI_ASSERT_ALWAYS( false && "Property type mismatch" );
- return DUMMY_BOOLEAN_VALUE;
+ // the return will never be executed due to assert above so just keep the compiler happy
+ return reinterpret_cast<const bool&>(*this);
}
/**
virtual const int& GetInteger( BufferIndex bufferIndex ) const
{
DALI_ASSERT_ALWAYS( false && "Property type mismatch" );
- return DUMMY_INTEGER_VALUE;
+ // the return will never be executed due to assert above so just keep the compiler happy
+ return reinterpret_cast<const int&>(*this);
}
/**
virtual const float& GetFloat( BufferIndex bufferIndex ) const
{
DALI_ASSERT_ALWAYS( false && "Property type mismatch" );
- return DUMMY_FLOAT_VALUE;
+ // the return will never be executed due to assert above so just keep the compiler happy
+ return reinterpret_cast<const float&>(*this);
}
/**
virtual const Vector2& GetVector2( BufferIndex bufferIndex ) const
{
DALI_ASSERT_ALWAYS( false && "Property type mismatch" );
- return DUMMY_VECTOR2_VALUE;
+ // the return will never be executed due to assert above so just keep the compiler happy
+ return reinterpret_cast<const Vector2&>(*this);
}
/**
virtual const Vector3& GetVector3( BufferIndex bufferIndex ) const
{
DALI_ASSERT_ALWAYS( false && "Property type mismatch" );
- return DUMMY_VECTOR3_VALUE;
+ // the return will never be executed due to assert above so just keep the compiler happy
+ return reinterpret_cast<const Vector3&>(*this);
}
/**
virtual const Vector4& GetVector4( BufferIndex bufferIndex ) const
{
DALI_ASSERT_ALWAYS( false && "Property type mismatch" );
- return DUMMY_VECTOR4_VALUE;
+ // the return will never be executed due to assert above so just keep the compiler happy
+ return reinterpret_cast<const Vector4&>(*this);
}
/**
virtual const Quaternion& GetQuaternion( BufferIndex bufferIndex ) const
{
DALI_ASSERT_ALWAYS( false && "Property type mismatch" );
- return DUMMY_QUATERNION_VALUE;
+ // the return will never be executed due to assert above so just keep the compiler happy
+ return reinterpret_cast<const Quaternion&>(*this);
}
/**
virtual const Matrix3& GetMatrix3( BufferIndex bufferIndex ) const
{
DALI_ASSERT_ALWAYS( false && "Property type mismatch" );
- return DUMMY_MATRIX3_VALUE;
+ // the return will never be executed due to assert above so just keep the compiler happy
+ return reinterpret_cast<const Matrix3&>(*this);
}
/**
virtual const Matrix& GetMatrix( BufferIndex bufferIndex ) const
{
DALI_ASSERT_ALWAYS( false && "Property type mismatch" );
- return DUMMY_MATRIX_VALUE;
+ // the return will never be executed due to assert above so just keep the compiler happy
+ return reinterpret_cast<const Matrix&>(*this);
}
// Accessors for Constraint functions
HitTestInterface& hitCheck,
bool& stencilOnLayer,
bool& stencilHit,
+ bool& overlayHit,
bool parentIsStencil,
bool layerIs3d )
{
}
else
{
- hit.actor = &actor;
- hit.x = hitPointLocal.x;
- hit.y = hitPointLocal.y;
- hit.distance = distance;
- hit.depth = actor.GetHierarchyDepth() * Dali::Layer::TREE_DEPTH_MULTIPLIER;
-
- // Is this actor an Image Actor or contains a renderer?
- if ( ImageActor* imageActor = dynamic_cast< ImageActor* >( &actor ) )
+ if( overlayHit && !actor.IsOverlay() )
{
- hit.depth += imageActor->GetDepthIndex();
+ //If we have already hit an overlay and current actor is not an overlay
+ //ignore current actor
}
- else if ( actor.GetRendererCount() )
+ else
{
- hit.depth += actor.GetRendererAt( 0 ).GetDepthIndex();
+ if( actor.IsOverlay() )
+ {
+ overlayHit = true;
+ }
+
+ hit.actor = &actor;
+ hit.x = hitPointLocal.x;
+ hit.y = hitPointLocal.y;
+ hit.distance = distance;
+ hit.depth = actor.GetHierarchyDepth() * Dali::Layer::TREE_DEPTH_MULTIPLIER;
+
+ // Is this actor an Image Actor or contains a renderer?
+ if ( ImageActor* imageActor = dynamic_cast< ImageActor* >( &actor ) )
+ {
+ hit.depth += imageActor->GetDepthIndex();
+ }
+ else if ( actor.GetRendererCount() > 0 )
+ {
+ //Get renderer with maximum depth
+ int rendererMaxDepth(actor.GetRendererAt( 0 ).Get()->GetDepthIndex());
+ for( unsigned int i(1); i<actor.GetRendererCount(); ++i)
+ {
+ int depth = actor.GetRendererAt( i ).Get()->GetDepthIndex();
+ if( depth > rendererMaxDepth )
+ {
+ rendererMaxDepth = depth;
+ }
+ }
+ hit.depth += rendererMaxDepth;
+ }
}
}
}
hitCheck,
stencilOnLayer,
stencilHit,
+ overlayHit,
isStencil,
layerIs3d) );
HitActor hit;
bool stencilOnLayer = false;
bool stencilHit = false;
+ bool overlayHit = false;
bool layerConsumesHit = false;
const Vector2& stageSize = stage.GetSize();
HitActor previousHit = hit;
stencilOnLayer = false;
stencilHit = false;
+ overlayHit = false;
// Ensure layer is touchable (also checks whether ancestors are also touchable)
if ( IsActuallyHittable ( *layer, screenCoordinates, stageSize, hitCheck ) )
hitCheck,
stencilOnLayer,
stencilHit,
+ overlayHit,
false,
layer->GetBehavior() == Dali::Layer::LAYER_3D);
}
hitCheck,
stencilOnLayer,
stencilHit,
+ overlayHit,
false,
layer->GetBehavior() == Dali::Layer::LAYER_3D);
}
{
AllocateAtlas();
ResourceId destId = GetResourceId();
- ResourceId srcId = bufferImage.GetResourceId();
- if( destId && srcId )
+ if( destId )
{
- mResourceClient.UploadBitmap( destId, srcId, xOffset, yOffset );
+ bufferImage.UploadBitmap( destId, xOffset, yOffset );
uploadSuccess = true;
}
}
* A container for image data that remains in compresssed form as an opaque blob
* in memory rather than being decompressed at load time.
* Used for formats that are supported as GLES texture data directly.
- * \sa{Bitmap BitmapPackedPixel BitmapExternal}
*/
class BitmapCompressed : public Dali::Integration::Bitmap, Dali::Integration::Bitmap::CompressedProfile
{
+++ /dev/null
-/*
- * 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.
- * 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/event/images/bitmap-external.h>
-
-// INTERNAL INCLUDES
-#include <dali/internal/common/core-impl.h>
-
-namespace Dali
-{
-
-namespace Internal
-{
-
-// use power of two bufferWidth and bufferHeight for better performance
-BitmapExternal::BitmapExternal(Dali::Integration::PixelBuffer* pixBuf,
- unsigned int width,
- unsigned int height,
- Pixel::Format pixelFormat,
- unsigned int bufferWidth,
- unsigned int bufferHeight)
-: BitmapPackedPixel(ResourcePolicy::NOT_OWNED, NULL/*pixBuf is externally owned*/),
- mExternalData(pixBuf)
-{
- mImageWidth = width;
- mImageHeight = height;
- mBufferWidth = (bufferWidth != 0) ? bufferWidth : width;
- mBufferHeight = (bufferHeight != 0) ? bufferHeight : height;
- mPixelFormat = pixelFormat;
-
- mBytesPerPixel = Pixel::GetBytesPerPixel(pixelFormat);
- mHasAlphaChannel = Pixel::HasAlpha(pixelFormat);
- mAlphaChannelUsed = mHasAlphaChannel;
-
- DALI_ASSERT_DEBUG(mBufferWidth >= mImageWidth && mBufferHeight >= mImageHeight);
-}
-
-BitmapExternal::~BitmapExternal()
-{
- DALI_LOG_TRACE_METHOD(Debug::Filter::gImage);
-}
-
-} //namespace Internal
-
-} //namespace Dali
+++ /dev/null
-#ifndef __DALI_INTERNAL_BITMAP_EXTERNAL_H__
-#define __DALI_INTERNAL_BITMAP_EXTERNAL_H__
-
-/*
- * 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.
- * 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.
- *
- */
-
-// EXTERNAL INCLUDES
-
-// INTERNAL INCLUDES
-#include <dali/internal/event/images/bitmap-packed-pixel.h>
-
-namespace Dali
-{
-
-namespace Internal
-{
-
-/**
- * Bitmap class.
- * A container for external image data
- */
-class BitmapExternal : public BitmapPackedPixel
-{
-public:
- /**
- * Constructor
- */
-
- /**
- * Creates new BitmapExternal instance with pixel buffer pointer and details.
- * Application has ownership of the buffer, its contents can be modified.
- * Bitmap stores given size information about the image.
- * @pre bufferWidth, bufferHeight have to be power of two
- * @param[in] pixBuf pointer to external pixel buffer
- * @param[in] width Image width in pixels
- * @param[in] height Image height in pixels
- * @param[in] pixelformat pixel format
- * @param[in] bufferWidth Buffer width in pixels
- * @param[in] bufferHeight Buffer height in pixels
- */
- BitmapExternal(Dali::Integration::PixelBuffer* pixBuf,
- unsigned int width,
- unsigned int height,
- Pixel::Format pixelformat,
- unsigned int bufferWidth = 0,
- unsigned int bufferHeight = 0);
-
- /**
- * This does nothing, data is owned by external application.
- */
- virtual Dali::Integration::PixelBuffer* ReserveBuffer(Pixel::Format pixelFormat,
- unsigned int width,
- unsigned int height,
- unsigned int bufferWidth = 0,
- unsigned int bufferHeight = 0)
- {
- return NULL;
- }
-
- /**
- * Get the pixel buffer
- * @return The buffer. You can modify its contents.
- */
- virtual Dali::Integration::PixelBuffer* GetBuffer()
- {
- return mExternalData;
- }
-
-protected:
- /**
- * A reference counted object may only be deleted by calling Unreference()
- */
- virtual ~BitmapExternal();
-
-private:
-
- Dali::Integration::PixelBuffer* mExternalData; ///< Externally owned pixel data
-
-private:
- BitmapExternal(); ///< defined private to prevent use
- BitmapExternal(const BitmapExternal& other); ///< defined private to prevent use
- BitmapExternal& operator = (const BitmapExternal& other); ///< defined private to prevent use
-
- // Changes scope, should be at end of class
- DALI_LOG_OBJECT_STRING_DECLARATION;
-};
-
-} // namespace Internal
-
-} // namespace Dali
-
-#endif // __DALI_INTERNAL_BITMAP_EXTERNAL_H__
* number of bytes.
* This is a vanilla Bitmap class, typically used to hold data decompressed
* from PNG and JPEG file formats for example.
- *
- * \sa{Bitmap BitmapCompressed BitmapExternal}
*/
class BitmapPackedPixel : public Dali::Integration::Bitmap, Dali::Integration::Bitmap::PackedPixelsProfile
{
/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
// CLASS HEADER
#include <dali/internal/event/images/buffer-image-impl.h>
+// EXTERNAL INCLUDES
+#include <string.h>
+
// INTERNAL INCLUDES
#include <dali/public-api/object/type-registry.h>
-#include <dali/integration-api/bitmap.h>
-#include <dali/internal/event/images/bitmap-external.h>
#include <dali/internal/event/common/thread-local-storage.h>
#include <dali/internal/event/resources/resource-client.h>
#include <dali/internal/update/manager/update-manager.h>
#include <dali/internal/event/images/image-factory.h>
+using namespace Dali::Integration;
+
namespace Dali
{
namespace Internal
TypeRegistration mType( typeid( Dali::BufferImage ), typeid( Dali::Image ), NULL );
} // unnamed namespace
-BufferImagePtr BufferImage::New( unsigned int width, unsigned int height, Pixel::Format pixelformat, ReleasePolicy releasePol )
+BufferImagePtr BufferImage::New( unsigned int width,
+ unsigned int height,
+ Pixel::Format pixelformat,
+ ReleasePolicy releasePol )
{
BufferImagePtr internal = new BufferImage( width, height, pixelformat, releasePol );
internal->Initialize();
return internal;
}
-BufferImagePtr BufferImage::New( PixelBuffer* pixBuf, unsigned int width, unsigned int height, Pixel::Format pixelformat, unsigned int stride, ReleasePolicy releasePol )
+BufferImagePtr BufferImage::New( PixelBuffer* pixBuf,
+ unsigned int width,
+ unsigned int height,
+ Pixel::Format pixelformat,
+ unsigned int stride,
+ ReleasePolicy releasePol )
{
BufferImagePtr internal = new BufferImage( pixBuf, width, height, pixelformat, stride, releasePol );
internal->Initialize();
BufferImage::BufferImage(unsigned int width, unsigned int height, Pixel::Format pixelformat, ReleasePolicy releasePol)
: Image(releasePol),
- mIsDataExternal(false)
+ mInternalBuffer(NULL),
+ mExternalBuffer(NULL),
+ mBufferWidth( 0 )
{
- ThreadLocalStorage& tls = ThreadLocalStorage::Get();
- mResourceClient = &tls.GetResourceClient();
- mWidth = width;
- mHeight = height;
+ SetupBuffer( width, height, pixelformat, width, releasePol );
- const ImageTicketPtr& t = mResourceClient->AllocateBitmapImage(width, height, width, height, pixelformat);
- mTicket = t.Get();
-
- mTicket->AddObserver(*this);
+ // Allocate a persistent internal buffer
+ mInternalBuffer = new PixelBuffer[ mBufferSize ];
}
-BufferImage::BufferImage(PixelBuffer* pixBuf, unsigned int width, unsigned int height, Pixel::Format pixelformat, unsigned int stride, ReleasePolicy releasePol)
+BufferImage::BufferImage(PixelBuffer* pixBuf,
+ unsigned int width,
+ unsigned int height,
+ Pixel::Format pixelformat,
+ unsigned int stride,
+ ReleasePolicy releasePol )
: Image(releasePol),
- mIsDataExternal(true)
+ mInternalBuffer(NULL),
+ mExternalBuffer(pixBuf),
+ mBufferWidth( 0 )
{
- ThreadLocalStorage& tls = ThreadLocalStorage::Get();
- mResourceClient = &tls.GetResourceClient();
- mWidth = width;
- mHeight = height;
- Integration::Bitmap* bitmap = new BitmapExternal(pixBuf, width, height, pixelformat, stride);
- const ImageTicketPtr& t = mResourceClient->AddBitmapImage(bitmap);
- mTicket = t.Get();
-
- mTicket->AddObserver(*this);
+ SetupBuffer( width, height, pixelformat, stride ? stride: width, releasePol );
}
BufferImage::~BufferImage()
{
+ delete[] mInternalBuffer;
}
-void BufferImage::Update( RectArea& updateArea )
+void BufferImage::SetupBuffer( unsigned int width,
+ unsigned int height,
+ Pixel::Format pixelformat,
+ unsigned int byteStride,
+ ReleasePolicy releasePol )
{
- if (mTicket)
- {
- // TODO:
- // If updateArea is empty or same as image size, then pass on.
- // If updateArea is larger than image size, throw exception
- // Otherwise, copy updateArea window of pixelBuffer into newly
- // allocated buffer and pass that to resource client. (it will
- // tramp through to BitmapTexture eventually!)
- mResourceClient->UpdateBitmapArea( mTicket, updateArea );
- }
- else if (mIsDataExternal && mBitmapCached)
- {
- // previously freed up resource memory, dali was informed about external BufferImage put back on screen
- Integration::Bitmap* bitmap = mBitmapCached.Get();
- mTicket.Reset((mResourceClient->AddBitmapImage(bitmap)).Get());
+ ThreadLocalStorage& tls = ThreadLocalStorage::Get();
+ mResourceClient = &tls.GetResourceClient();
+ mWidth = width;
+ mHeight = height;
+ mPixelFormat = pixelformat;
+ mBytesPerPixel = Pixel::GetBytesPerPixel( pixelformat );
- mTicket->AddObserver(*this);
- }
+ mByteStride = byteStride * mBytesPerPixel;
+ mBufferSize = height * mByteStride;
+
+ // Respect the desired release policy
+ mResourcePolicy = releasePol == Dali::Image::UNUSED ? ResourcePolicy::OWNED_DISCARD : ResourcePolicy::OWNED_RETAIN;
}
bool BufferImage::IsDataExternal() const
{
- return mIsDataExternal;
+ return ( mExternalBuffer ? true : false );
}
-PixelBuffer* BufferImage::GetBuffer()
+void BufferImage::Update( RectArea& updateArea )
{
- PixelBuffer* buffer = NULL;
-
- Integration::Bitmap* const bitmap = GetBitmap();
-
- if(bitmap)
+ if ( !mTicket )
{
- buffer = bitmap->GetBuffer();
+ CreateHostBitmap();
}
- return buffer;
+ DALI_ASSERT_DEBUG( updateArea.x + updateArea.width <= mWidth && updateArea.y + updateArea.height <= mHeight );
+ UploadArea( mTicket->GetId(), updateArea );
}
-unsigned int BufferImage::GetBufferSize() const
+void BufferImage::CreateHostBitmap()
{
- unsigned int bufferSize = 0;
+ Integration::Bitmap* bitmap = Bitmap::New( Bitmap::BITMAP_2D_PACKED_PIXELS, mResourcePolicy );
+ Bitmap::PackedPixelsProfile* const packedBitmap = bitmap->GetPackedPixelsProfile();
+ DALI_ASSERT_DEBUG(packedBitmap);
- Integration::Bitmap* const bitmap = GetBitmap();
+ packedBitmap->ReserveBuffer( mPixelFormat, mWidth, mHeight );
+ DALI_ASSERT_DEBUG(bitmap->GetBuffer() != 0);
+ DALI_ASSERT_DEBUG(bitmap->GetBufferSize() >= mHeight * mWidth * mBytesPerPixel );
- if(bitmap)
- {
- bufferSize = bitmap->GetBufferSize();
- }
- return bufferSize;
+ mTicket = mResourceClient->AddBitmapImage( bitmap );
+ mTicket->AddObserver(*this);
}
-unsigned int BufferImage::GetBufferStride() const
+void BufferImage::UploadArea( ResourceId destId, const RectArea& area )
{
- unsigned int bufferStride = 0;
+ Integration::Bitmap* bitmap = Bitmap::New( Bitmap::BITMAP_2D_PACKED_PIXELS, mResourcePolicy );
+ Bitmap::PackedPixelsProfile* const packedBitmap = bitmap->GetPackedPixelsProfile();
+ DALI_ASSERT_DEBUG(packedBitmap);
+ DALI_ASSERT_DEBUG( area.width <= mWidth && area.height <= mHeight );
- Integration::Bitmap* const bitmap = GetBitmap();
+ mBufferWidth = area.width ? area.width : mWidth;
+ packedBitmap->ReserveBuffer( mPixelFormat, mBufferWidth, area.height ? area.height : mHeight );
+ DALI_ASSERT_DEBUG(bitmap->GetBuffer() != 0);
+ DALI_ASSERT_DEBUG(bitmap->GetBufferSize() >= mBufferWidth * ( area.height ? area.height : mHeight ) * mBytesPerPixel );
- if(bitmap)
+ // Are we uploading from an external or internal buffer ?
+ if ( mExternalBuffer )
{
- Integration::Bitmap::PackedPixelsProfile* packedBitmap = bitmap->GetPackedPixelsProfile();
- DALI_ASSERT_DEBUG(packedBitmap);
- bufferStride = packedBitmap->GetBufferStride();
+ // Check if we're doing the entire area without stride mismatch between source and dest ?
+ if( ( mByteStride == mWidth * mBytesPerPixel ) && area.IsEmpty() )
+ {
+ memcpy( bitmap->GetBuffer(), mExternalBuffer, mBufferSize );
+ }
+ else
+ {
+ UpdateBufferArea( mExternalBuffer, bitmap->GetBuffer(), area );
+ }
+ }
+ else
+ {
+ // Check if we're doing the entire internal buffer ?
+ if( area.IsEmpty() )
+ {
+ memcpy( bitmap->GetBuffer(), mInternalBuffer, bitmap->GetBufferSize() );
+ }
+ else
+ {
+ UpdateBufferArea( mInternalBuffer, bitmap->GetBuffer(), area );
+ }
}
+ mResourceClient->UploadBitmap( destId, bitmap, area.x, area.y );
- return bufferStride;
}
-Pixel::Format BufferImage::GetPixelFormat() const
+void BufferImage::UploadBitmap( ResourceId destId, std::size_t xOffset, std::size_t yOffset )
{
- Pixel::Format format( Pixel::RGBA8888 );
-
- Integration::Bitmap* const bitmap = GetBitmap();
-
- if( bitmap )
+ RectArea area( xOffset, yOffset, 0, 0 );
+ if ( !mTicket )
{
- format = bitmap->GetPixelFormat();
+ CreateHostBitmap();
}
- return format;
+ UploadArea( destId, area );
}
-void BufferImage::Connect()
+void BufferImage::UpdateBufferArea( PixelBuffer* src, PixelBuffer* dest, const RectArea& area )
{
- ++mConnectionCount;
+ DALI_ASSERT_DEBUG( area.x + area.width <= mWidth && area.y + area.height <= mHeight );
- // application owns bitmap buffer, don't do anything. Update() has to be called manually.
- if (mIsDataExternal)
- {
- return;
- }
+ uint32_t width = mBufferWidth * mBytesPerPixel;
- if (mConnectionCount == 1)
+ src += ( area.y * mByteStride ) + ( area.x * mBytesPerPixel );
+ for ( uint32_t i = 0; i < area.height; ++i )
{
- if (!mTicket && mBitmapCached)
- {
- const ImageTicketPtr& t = mResourceClient->AddBitmapImage(mBitmapCached.Get());
- mTicket = t.Get();
- mTicket->AddObserver(*this);
- }
+ memcpy( dest, src, width );
+ src += mByteStride;
+ dest += width;
}
}
-void BufferImage::Disconnect()
+void BufferImage::Connect()
{
- if (!mTicket)
- {
- return;
- }
-
- --mConnectionCount;
-
- if (mConnectionCount == 0 && mReleasePolicy == Dali::Image::UNUSED)
+ if ( !mConnectionCount++ )
{
- mBitmapCached = mResourceClient->GetBitmap(mTicket);
- // release image memory when it's not visible anymore (decrease ref. count of texture)
- mTicket->RemoveObserver(*this);
- mTicket.Reset();
+ RectArea area;
+ Update( area );
}
}
-Integration::Bitmap * BufferImage::GetBitmap() const
+void BufferImage::Disconnect()
{
- Integration::Bitmap* bitmap = NULL;
-
- if (mTicket)
+ if ( mTicket )
{
- bitmap = mResourceClient->GetBitmap(mTicket);
- }
- else
- {
- // off screen and freeing memory was requested
- bitmap = mBitmapCached.Get();
+ if ( !( --mConnectionCount ) && mReleasePolicy == Dali::Image::UNUSED )
+ {
+ mTicket->RemoveObserver(*this);
+ mTicket.Reset();
+ }
}
-
- DALI_ASSERT_DEBUG(bitmap);
-
- return bitmap;
}
} // namespace Internal
#define __DALI_INTERNAL_BUFFER_IMAGE_H__
/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
ReleasePolicy releasePol = IMAGE_RELEASE_POLICY_DEFAULT );
/**
- * Create a new BufferImage, which uses external data source.
+ * @deprecated Support for externally owned Pixel Buffers is due to be removed TBA. It is recommended that a BufferImage owned Buffer be used instead.
+ *
+ * @brief Create a new BufferImage, which uses external data source.
+ *
* Pixel buffer has to be allocated by application.
- * Application holds ownership of the buffer.
+ * An internal copy is made of the Pixel Buffer, which can then be freed by the Application, unless if there will be a call to Update() later.
+ * The buffer should only be freed when there is no chance of an Update() being called again.
+ * Obtaining the buffer with GetBuffer() and altering the contents, then Update() will not work with externally owned buffers.
* For better performance and portability use power of two dimensions.
* The maximum size of the image is limited by GL_MAX_TEXTURE_SIZE.
- * @note in case releasePol is "OffStage", application has to call Update() whenever image is re-added to the stage
+ *
* @param [in] pixBuf pixel buffer. has to be allocated by application.
* @param [in] width image width in pixels
* @param [in] height image height in pixels
/**
* Create a new BufferImage, which uses external data source.
* Pixel buffer has to be allocated by application.
- * Application holds ownership of the buffer.
+ * An internal copy is made of the Pixel Buffer, which can then be freed by the Application, unless if there will be a call to Update() later.
+ * The buffer should only be freed when there is no chance of Update() being called again.
+ * Note: obtaining the buffer with GetBuffer(), writing changes, then Update() will cause any changes to be lost.
+ * In this case, the BufferImage will update from the external buffer and so changes should be written there.
* For better performance and portability use power of two dimensions.
* The maximum size of the image is limited by GL_MAX_TEXTURE_SIZE.
- * @note in case releasePol is "OffStage", application has to call Update() whenever image is re-added to the stage
* @param [in] pixBuf pixel buffer. has to be allocated by application.
* @param [in] width image width in pixels
* @param [in] height image height in pixels
* Upload the modified contents with Update().
* @return the pixel buffer
*/
- PixelBuffer* GetBuffer();
+ PixelBuffer* GetBuffer() const
+ {
+ return ( mExternalBuffer ? mExternalBuffer : mInternalBuffer );
+ }
/**
* Returns buffer size in bytes.
* @return the buffer size in bytes
*/
- unsigned int GetBufferSize() const;
+ unsigned int GetBufferSize() const
+ {
+ return mBufferSize;
+ }
/**
* Returns buffer stride (in bytes).
* @return the buffer stride
*/
- unsigned int GetBufferStride() const;
+ unsigned int GetBufferStride() const
+ {
+ return mByteStride;
+ }
/**
* Get the pixel format
* @return The pixel format
*/
- Pixel::Format GetPixelFormat() const;
+ Pixel::Format GetPixelFormat() const
+ {
+ return mPixelFormat;
+ }
+
+ /**
+ * @brief Upload pixel data to another resource at an offset
+ *
+ * @param destId ResourceId of the destination
+ * @param xOffset x offset in the destination
+ * @param yOffset y offset in the destination
+ */
+ void UploadBitmap( ResourceId destId, std::size_t xOffset, std::size_t yOffset );
-protected: // From Resource
+protected: // From Image
/**
* @copydoc Dali::Internal::Image::Connect
*/
*/
virtual void Disconnect();
- /**
- * Get the bitmap from local cache or ticket.
- **/
- Integration::Bitmap * GetBitmap() const;
-
private:
- bool mIsDataExternal; ///< whether application holds ownership of pixel buffer or not
- ResourceClient* mResourceClient;
+ void SetupBuffer( unsigned int width,
+ unsigned int height,
+ Pixel::Format pixelformat,
+ unsigned int byteStride,
+ ReleasePolicy releasePol );
-protected:
- Integration::BitmapPtr mBitmapCached;
+ void CreateHostBitmap();
+
+ void UploadArea( ResourceId destId, const RectArea& area );
+
+ void UpdateBufferArea( PixelBuffer* src, PixelBuffer* dest, const RectArea& area );
+
+private:
+
+ PixelBuffer* mInternalBuffer; ///< NULL if the data is supplied by an external buffer.
+ PixelBuffer* mExternalBuffer; ///< NULL if there is no external pixel data (this is never owned by BufferImage).
+ ResourceClient* mResourceClient; ///< pointer to the resource client.
+ uint32_t mBufferSize; ///< size of the pixel buffer.
+ uint32_t mByteStride; ///< width of the pixel buffer in bytes.
+ uint32_t mBytesPerPixel; ///< width of a pixel in bytes.
+ uint32_t mBufferWidth; ///< cached pixel width of bitmap used for transport.
+ Pixel::Format mPixelFormat; ///< pixel format of bitmap.
+ ResourcePolicy::Discardable mResourcePolicy; ///< whether to discard the pixel buffer when removed from the stage or to retain the data.
};
} // namespace Internal
FrameBufferImage::FrameBufferImage( NativeImageInterface& nativeImage )
: Image(),
- mNativeImage(&nativeImage)
+ mNativeImage(&nativeImage),
+ mPixelFormat( Pixel::FIRST_VALID_PIXEL_FORMAT ),
+ mBufferFormat( RenderBuffer::COLOR )
{
mWidth = nativeImage.GetWidth();
mHeight = nativeImage.GetHeight();
FrameBufferImage::FrameBufferImage( NativeImageInterface& nativeImage, ReleasePolicy releasePolicy )
: Image(releasePolicy),
- mNativeImage(&nativeImage)
+ mNativeImage(&nativeImage),
+ mPixelFormat( Pixel::FIRST_VALID_PIXEL_FORMAT ),
+ mBufferFormat( RenderBuffer::COLOR )
{
mWidth = nativeImage.GetWidth();
mHeight = nativeImage.GetHeight();
// INTERNAL INCLUDES
#include <dali/public-api/object/type-registry.h>
#include <dali/integration-api/bitmap.h>
-#include <dali/internal/event/images/bitmap-external.h>
#include <dali/internal/event/common/thread-local-storage.h>
#include <dali/internal/event/resources/resource-client.h>
#include <dali/internal/update/manager/update-manager.h>
Vector4 NinePatchImage::GetStretchBorders()
{
+ Vector4 border;
+
+ const Integration::StretchRanges& stretchPixelsX = GetStretchPixelsX();
+ const Integration::StretchRanges& stretchPixelsY = GetStretchPixelsY();
+
+ if( stretchPixelsX.Size() > 0 && stretchPixelsY.Size() > 0 )
+ {
+ //The NinePatchImage stretch pixels are in the cropped image space, inset by 1 to get it to uncropped image space
+ border.x = stretchPixelsX[ 0 ].GetX() + 1;
+ border.y = stretchPixelsY[ 0 ].GetX() + 1;
+ border.z = GetWidth() - stretchPixelsX[ 0 ].GetY() - 1;
+ border.w = GetHeight() - stretchPixelsY[ 0 ].GetY() - 1;
+ }
+
+ return border;
+}
+
+const Integration::StretchRanges& NinePatchImage::GetStretchPixelsX()
+{
if( ! mParsedBorder )
{
ParseBorders();
}
- return mStretchBorders;
+ return mStretchPixelsX;
+}
+
+const Integration::StretchRanges& NinePatchImage::GetStretchPixelsY()
+{
+ if( ! mParsedBorder )
+ {
+ ParseBorders();
+ }
+ return mStretchPixelsY;
}
Rect<int> NinePatchImage::GetChildRectangle()
void NinePatchImage::ParseBorders()
{
- if( ! mBitmap )
+ if( !mBitmap )
{
DALI_LOG_ERROR( "NinePatchImage: Bitmap not loaded, cannot perform operation\n");
return;
}
+ mStretchPixelsX.Clear();
+ mStretchPixelsY.Clear();
+
Pixel::Format pixelFormat = mBitmap->GetPixelFormat();
- Integration::Bitmap::PackedPixelsProfile* srcProfile = mBitmap->GetPackedPixelsProfile();
- DALI_ASSERT_DEBUG( srcProfile && "Wrong profile for source bitmap");
+ const Integration::Bitmap::PackedPixelsProfile* srcProfile = mBitmap->GetPackedPixelsProfile();
+ DALI_ASSERT_DEBUG( srcProfile && "Wrong profile for source bitmap" );
if( srcProfile )
{
- unsigned int pixelWidth = GetBytesPerPixel(pixelFormat);
- PixelBuffer* srcPixels = mBitmap->GetBuffer();
- unsigned int srcStride = srcProfile->GetBufferStride();
-
- int alphaByte=0;
- int alphaBits=0;
- Pixel::GetAlphaOffsetAndMask(pixelFormat, alphaByte, alphaBits);
- int redByte=0;
- int redBits=0;
- GetRedOffsetAndMask(pixelFormat, redByte, redBits);
+ int alphaByte = 0;
+ int alphaBits = 0;
+ Pixel::GetAlphaOffsetAndMask( pixelFormat, alphaByte, alphaBits );
int testByte = alphaByte;
int testBits = alphaBits;
int testValue = alphaBits; // Opaque == stretch
if( ! alphaBits )
{
- testByte = redByte;
- testBits = redBits;
+ GetRedOffsetAndMask( pixelFormat, testByte, testBits );
testValue = 0; // Black == stretch
}
- int startX1=-1;
- int endX1=-1;
- int startY1=-1;
- int endY1=-1;
- int startX2=-1;
- int endX2=-1;
- int startY2=-1;
- int endY2=-1;
-
- PixelBuffer* top = srcPixels + pixelWidth;
- PixelBuffer* bottom = srcPixels + (mHeight-1)*srcStride + pixelWidth;
-
- // Read the top and bottom rows:
- // (Also read the last column to ensure end value gets set)
- for( unsigned int col=1; col < mWidth; ++col )
+ unsigned int pixelWidth = GetBytesPerPixel( pixelFormat );
+ const PixelBuffer* srcPixels = mBitmap->GetBuffer();
+ unsigned int srcStride = srcProfile->GetBufferStride();
+
+ //TOP
+ const PixelBuffer* top = srcPixels + pixelWidth;
+ unsigned int index = 0;
+ unsigned int width = mBitmap->GetImageWidth();
+ unsigned int height = mBitmap->GetImageHeight();
+
+ for(; index < width - 2; )
{
- if( (top[testByte] & testBits) == testValue )
- {
- if(startX1 < 0)
- {
- startX1 = col;
- }
- }
- else if(startX1 >= 0 && endX1 < 0)
+ Uint16Pair range = ParseRange( index, width - 2, top, pixelWidth, testByte, testBits, testValue );
+ if( range.GetX() != 0xFFFF )
{
- endX1 = col;
+ mStretchPixelsX.PushBack( range );
}
+ }
- if( (bottom[testByte] & testBits) == testValue )
- {
- if(startX2 < 0)
- {
- startX2 = col;
- }
- }
- else if(startX2 >= 0 && endX2 < 0)
+ //LEFT
+ const PixelBuffer* left = srcPixels + srcStride;
+ index = 0;
+ for(; index < height - 2; )
+ {
+ Uint16Pair range = ParseRange( index, height - 2, left, srcStride, testByte, testBits, testValue );
+ if( range.GetX() != 0xFFFF )
{
- endX2 = col;
+ mStretchPixelsY.PushBack( range );
}
+ }
- if ( ( endX2 > 0 ) && ( endX1 > 0 ) )
- {
+ //If there are no stretch pixels then make the entire image stretchable
+ if( mStretchPixelsX.Size() == 0 )
+ {
+ mStretchPixelsX.PushBack( Uint16Pair( 0, width - 2 ) );
+ }
+ if( mStretchPixelsY.Size() == 0 )
+ {
+ mStretchPixelsY.PushBack( Uint16Pair( 0, height - 2 ) );
+ }
+
+ //Child Rectangle
+ //BOTTOM
+ const PixelBuffer* bottom = srcPixels + ( height - 1 ) * srcStride + pixelWidth;
+ index = 0;
+ Uint16Pair contentRangeX = ParseRange( index, width - 2, bottom, pixelWidth, testByte, testBits, testValue );
+ if( contentRangeX.GetX() == 0xFFFF )
+ {
+ contentRangeX = Uint16Pair();
+ }
+
+ //RIGHT
+ const PixelBuffer* right = srcPixels + srcStride + ( width - 1 ) * pixelWidth;
+ index = 0;
+ Uint16Pair contentRangeY = ParseRange( index, height - 2, right, srcStride, testByte, testBits, testValue );
+ if( contentRangeY.GetX() == 0xFFFF )
+ {
+ contentRangeY = Uint16Pair();
+ }
+
+ mChildRectangle.x = contentRangeX.GetX() + 1;
+ mChildRectangle.y = contentRangeY.GetX() + 1;
+ mChildRectangle.width = contentRangeX.GetY() - contentRangeX.GetX();
+ mChildRectangle.height = contentRangeY.GetY() - contentRangeY.GetX();
+
+ mParsedBorder = true;
+ }
+}
+
+Uint16Pair NinePatchImage::ParseRange( unsigned int& index, unsigned int width, const PixelBuffer* & pixel, unsigned int pixelStride, int testByte, int testBits, int testValue )
+{
+ unsigned int start = 0xFFFF;
+ for( ; index < width; ++index, pixel += pixelStride )
+ {
+ if( ( pixel[ testByte ] & testBits ) == testValue )
+ {
+ start = index;
+ ++index;
+ pixel += pixelStride;
break;
- }
+ }
+ }
- top+=pixelWidth;
- bottom+=pixelWidth;
+ unsigned int end = width;
+ for( ; index < width; ++index, pixel += pixelStride )
+ {
+ if( ( pixel[ testByte ] & testBits ) != testValue )
+ {
+ end = index;
+ ++index;
+ pixel += pixelStride;
+ break;
}
+ }
- // Read the left and right columns:
- PixelBuffer* left = srcPixels + srcStride;
- PixelBuffer* right = left + (srcStride - pixelWidth);
+ return Uint16Pair( start, end );
+}
+
+bool NinePatchImage::IsNinePatchUrl( const std::string& url )
+{
+ bool match = false;
- // (Also read the last row to ensure end value gets set)
- for( unsigned int row=1; row < mHeight; ++row )
+ std::string::const_reverse_iterator iter = url.rbegin();
+ enum { SUFFIX, HASH, HASH_DOT, DONE } state = SUFFIX;
+ while(iter < url.rend())
+ {
+ switch(state)
{
- if((left[testByte] & testBits) == testValue)
+ case SUFFIX:
{
- if(startY1 < 0)
+ if(*iter == '.')
{
- startY1 = row;
+ state = HASH;
+ }
+ else if(!isalnum(*iter))
+ {
+ state = DONE;
}
}
- else if(startY1 >= 0 && endY1 < 0)
- {
- endY1 = row;
- }
-
- if((right[testByte] & testBits) == testValue)
+ break;
+ case HASH:
{
- if(startY2 < 0)
+ if( *iter == '#' || *iter == '9' )
+ {
+ state = HASH_DOT;
+ }
+ else
{
- startY2 = row;
+ state = DONE;
}
}
- else if(startY2 >= 0 && endY2 < 0)
+ break;
+ case HASH_DOT:
{
- endY2 = row;
+ if(*iter == '.')
+ {
+ match = true;
+ }
+ state = DONE; // Stop testing characters
}
- left += srcStride;
- right += srcStride;
-
- if ( ( endY2 > 0 ) && ( endY1 > 0 ) )
+ break;
+ case DONE:
{
- break;
}
+ break;
}
- mStretchBorders.x = startX1;
- mStretchBorders.y = startY1;
- mStretchBorders.z = mWidth-endX1;
- mStretchBorders.w = mHeight-endY1;
-
- mChildRectangle.x = startX2;
- mChildRectangle.y = startY2;
- mChildRectangle.width = endX2-startX2;
- mChildRectangle.height = endY2-startY2;
+ // Satisfy prevent
+ if( state == DONE )
+ {
+ break;
+ }
- mParsedBorder = true;
+ ++iter;
}
+ return match;
}
} // namespace Internal
#include <dali/public-api/images/nine-patch-image.h>
#include <dali/internal/event/images/resource-image-impl.h>
#include <dali/internal/event/images/buffer-image-impl.h>
+#include <dali/integration-api/image-integ.h>
namespace Dali
{
*/
class NinePatchImage : public ResourceImage
{
+
public:
/**
virtual ~NinePatchImage();
public:
+
/**
- * Get the stretch borders
- * @return The border in pixels from the left, top, right, and bottom of the image respectively.
- */
+ * Get the stretch borders * @copydoc Dali::NinePatchImage::GetStretchPixels
+ * @return The border in pixels from the left, top, right, and bottom of the image respectively.
+ */
Vector4 GetStretchBorders();
/**
+ * @copydoc Dali::NinePatchImage::GetStretchPixelsX
+ */
+ const Integration::StretchRanges& GetStretchPixelsX();
+
+ /**
+ * @copydoc Dali::NinePatchImage::GetStretchPixelsY
+ */
+ const Integration::StretchRanges& GetStretchPixelsY();
+
+ /**
* Get the child rectangle
* @return the position and size of the child rectangle
*/
*/
BufferImagePtr CreateCroppedBufferImage();
+ /**
+ *
+ * @copydoc Dali::NinePatchImage::
+ */
+ static bool IsNinePatchUrl( const std::string& url );
+
protected: // From Resource
/**
*/
void ParseBorders();
+ Uint16Pair ParseRange( unsigned int& index, unsigned int width, const PixelBuffer* & pixel, unsigned int pixelStride, int testByte, int testBits, int testValue );
+
private:
ResourceClient* mResourceClient;
Integration::BitmapPtr mBitmap;
- Vector4 mStretchBorders;
+ Integration::StretchRanges mStretchPixelsX; //< The horizontal stretchable pixels in the cropped image space
+ Integration::StretchRanges mStretchPixelsY; //< The vertical stretchable pixels in the cropped image space
Rect<int> mChildRectangle;
bool mParsedBorder;
};
ResourceImagePtr ResourceImage::New( const std::string& url, const ImageAttributes& attributes, LoadPolicy loadPol, ReleasePolicy releasePol )
{
ResourceImagePtr image;
- if( IsNinePatch( url ) )
+ if( NinePatchImage::IsNinePatchUrl( url ) )
{
image = NinePatchImage::New( url, releasePol );
}
}
}
-bool ResourceImage::IsNinePatch( const std::string& url )
-{
- bool match = false;
-
- std::string::const_reverse_iterator iter = url.rbegin();
- enum { SUFFIX, HASH, HASH_DOT, DONE } state = SUFFIX;
- while(iter < url.rend())
- {
- switch(state)
- {
- case SUFFIX:
- {
- if(*iter == '.')
- {
- state = HASH;
- }
- else if(!isalnum(*iter))
- {
- state = DONE;
- }
- }
- break;
- case HASH:
- {
- if( *iter == '#' || *iter == '9' )
- {
- state = HASH_DOT;
- }
- else
- {
- state = DONE;
- }
- }
- break;
- case HASH_DOT:
- {
- if(*iter == '.')
- {
- match = true;
- }
- state = DONE; // Stop testing characters
- }
- break;
- case DONE:
- {
- }
- break;
- }
-
- // Satisfy prevent
- if( state == DONE )
- {
- break;
- }
-
- ++iter;
- }
- return match;
-}
-
void ResourceImage::SetTicket( ResourceTicket* ticket )
{
if( ticket == mTicket.Get() )
private:
/**
- * Helper method to determine if the filename indicates that the image has a 9 patch border.
- * @param [in] url The URL of the image file.
- * @return true if it is a 9 patch image
- */
- static bool IsNinePatch( const std::string& url );
-
- /**
* Helper method to set new resource ticket. Stops observing current ticket if any, and starts observing
* the new one or just resets the intrusive pointer.
* @param[in] ticket pointer to new resource Ticket or NULL.
* |name |type |writable|animatable|constraint-input|enum for index-checking|
*/
DALI_PROPERTY_TABLE_BEGIN
-DALI_PROPERTY( "geometry-type", STRING, true, false, true, Dali::Geometry::Property::GEOMETRY_TYPE )
-DALI_PROPERTY( "geometry-center", VECTOR3, true, true, true, Dali::Geometry::Property::GEOMETRY_CENTER )
-DALI_PROPERTY( "geometry-half-extents", VECTOR3, true, true, true, Dali::Geometry::Property::GEOMETRY_HALF_EXTENTS )
-DALI_PROPERTY( "requires-depth-test", BOOLEAN, true, false, true, Dali::Geometry::Property::REQUIRES_DEPTH_TEST )
+DALI_PROPERTY( "geometry-type", STRING, true, false, true, Dali::Geometry::Property::GEOMETRY_TYPE )
+DALI_PROPERTY( "requires-depth-test", BOOLEAN, true, false, true, Dali::Geometry::Property::REQUIRES_DEPTH_TEST )
DALI_PROPERTY_TABLE_END( DEFAULT_ACTOR_PROPERTY_START_INDEX )
const ObjectImplHelper<DEFAULT_PROPERTY_COUNT> GEOMETRY_IMPL = { DEFAULT_PROPERTY_DETAILS };
std::size_t Geometry::AddVertexBuffer( PropertyBuffer& vertexBuffer )
{
- PropertyBufferConnector connector;
- connector.Set( vertexBuffer, OnStage() );
- mVertexBufferConnectors.push_back( connector );
-
- const SceneGraph::PropertyBuffer& sceneGraphPropertyBuffer = static_cast<const SceneGraph::PropertyBuffer&>( *vertexBuffer.GetSceneObject() );
-
- SceneGraph::AddVertexBufferMessage( GetEventThreadServices(), *mSceneObject, sceneGraphPropertyBuffer );
-
- return mVertexBufferConnectors.size() - 1u;
+ mVertexBuffers.push_back( &vertexBuffer );
+ SceneGraph::AddVertexBufferMessage( GetEventThreadServices(), *mSceneObject, *vertexBuffer.GetRenderObject() );
+ return mVertexBuffers.size() - 1u;
}
std::size_t Geometry::GetNumberOfVertexBuffers() const
{
- return mVertexBufferConnectors.size();
+ return mVertexBuffers.size();
}
void Geometry::RemoveVertexBuffer( std::size_t index )
{
- const SceneGraph::PropertyBuffer& sceneGraphPropertyBuffer = static_cast<const SceneGraph::PropertyBuffer&>( *(mVertexBufferConnectors[index].Get()->GetSceneObject()) );
- SceneGraph::RemoveVertexBufferMessage( GetEventThreadServices(), *mSceneObject, sceneGraphPropertyBuffer );
+ const Render::PropertyBuffer& renderPropertyBuffer = static_cast<const Render::PropertyBuffer&>( *(mVertexBuffers[index]->GetRenderObject()) );
+ SceneGraph::RemoveVertexBufferMessage( GetEventThreadServices(), *mSceneObject, renderPropertyBuffer );
- mVertexBufferConnectors.erase( mVertexBufferConnectors.begin() + index );
+ mVertexBuffers.erase( mVertexBuffers.begin() + index );
}
void Geometry::SetIndexBuffer( PropertyBuffer& indexBuffer )
{
- mIndexBufferConnector.Set( indexBuffer, OnStage() );
-
- const SceneGraph::PropertyBuffer& sceneGraphPropertyBuffer = dynamic_cast<const SceneGraph::PropertyBuffer&>( *indexBuffer.GetSceneObject() );
-
- SceneGraph::SetIndexBufferMessage( GetEventThreadServices(), *mSceneObject, sceneGraphPropertyBuffer );
+ mIndexBuffer = &indexBuffer;
+ SceneGraph::SetIndexBufferMessage( GetEventThreadServices(), *mSceneObject, *indexBuffer.GetRenderObject() );
}
void Geometry::SetGeometryType( Dali::Geometry::GeometryType geometryType )
{
- if( NULL != mSceneObject )
+ if( geometryType != mGeometryType )
{
- SceneGraph::DoubleBufferedPropertyMessage<int>::Send(
- GetEventThreadServices(),
- mSceneObject,
- &mSceneObject->mGeometryType,
- &SceneGraph::DoubleBufferedProperty<int>::Set,
- static_cast<int>(geometryType) );
+ SceneGraph::SetGeometryTypeMessage(GetEventThreadServices(),
+ *mSceneObject,
+ geometryType );
+
+ mGeometryType = geometryType;
}
}
Dali::Geometry::GeometryType Geometry::GetGeometryType() const
{
- return mSceneObject->GetGeometryType(GetEventThreadServices().GetEventBufferIndex());
+ return mGeometryType;
}
void Geometry::SetRequiresDepthTesting( bool requiresDepthTest )
{
- if( NULL != mSceneObject )
+ if( requiresDepthTest != mRequiresDepthTest )
{
- SceneGraph::DoubleBufferedPropertyMessage<bool>::Send( GetEventThreadServices(), mSceneObject, &mSceneObject->mRequiresDepthTest, &SceneGraph::DoubleBufferedProperty<bool>::Set, static_cast<int>(requiresDepthTest) );
+ SceneGraph::SetGeometryRequiresDepthTestMessage(GetEventThreadServices(),
+ *mSceneObject,
+ requiresDepthTest );
+
+ mRequiresDepthTest = requiresDepthTest;
}
}
bool Geometry::GetRequiresDepthTesting() const
{
- if( mSceneObject )
- {
- // mSceneObject is being used in a separate thread; copy the value from the previous update
- return mSceneObject->GetRequiresDepthTesting(GetEventThreadServices().GetEventBufferIndex());
- }
- return false;
+ return mRequiresDepthTest;
}
const SceneGraph::Geometry* Geometry::GetGeometrySceneObject() const
{
case Dali::Geometry::Property::GEOMETRY_TYPE :
{
- SceneGraph::DoubleBufferedPropertyMessage<int>::Send( GetEventThreadServices(), mSceneObject, &mSceneObject->mGeometryType, &SceneGraph::DoubleBufferedProperty<int>::Set, propertyValue.Get<int>() );
- break;
- }
- case Dali::Geometry::Property::GEOMETRY_CENTER :
- {
- SceneGraph::AnimatablePropertyMessage<Vector3>::Send( GetEventThreadServices(), mSceneObject, &mSceneObject->mCenter, &SceneGraph::AnimatableProperty<Vector3>::Bake, propertyValue.Get<Vector3>() );
- break;
- }
-
- case Dali::Geometry::Property::GEOMETRY_HALF_EXTENTS :
- {
- SceneGraph::AnimatablePropertyMessage<Vector3>::Send( GetEventThreadServices(), mSceneObject, &mSceneObject->mHalfExtents, &SceneGraph::AnimatableProperty<Vector3>::Bake, propertyValue.Get<Vector3>() );
+ Dali::Geometry::GeometryType geometryType = static_cast<Dali::Geometry::GeometryType>(propertyValue.Get<int>());
+ if( geometryType != mGeometryType )
+ {
+ SceneGraph::SetGeometryTypeMessage(GetEventThreadServices(), *mSceneObject, geometryType );
+ mGeometryType = geometryType;
+ }
break;
}
-
case Dali::Geometry::Property::REQUIRES_DEPTH_TEST :
{
- SceneGraph::DoubleBufferedPropertyMessage<bool>::Send( GetEventThreadServices(), mSceneObject, &mSceneObject->mRequiresDepthTest, &SceneGraph::DoubleBufferedProperty<bool>::Set, propertyValue.Get<bool>() );
+ bool requiresDepthTest = propertyValue.Get<bool>();
+ if( requiresDepthTest != mRequiresDepthTest )
+ {
+ SceneGraph::SetGeometryRequiresDepthTestMessage(GetEventThreadServices(), *mSceneObject, requiresDepthTest);
+ mRequiresDepthTest = requiresDepthTest;
+ }
break;
}
}
Property::Value Geometry::GetDefaultProperty( Property::Index index ) const
{
- BufferIndex bufferIndex = GetEventThreadServices().GetEventBufferIndex();
Property::Value value;
switch( index )
{
if( mSceneObject )
{
- value = mSceneObject->mGeometryType[bufferIndex];
- }
- break;
- }
- case Dali::Geometry::Property::GEOMETRY_CENTER :
- {
- if( mSceneObject )
- {
- value = mSceneObject->mCenter[bufferIndex];
- }
- break;
- }
-
- case Dali::Geometry::Property::GEOMETRY_HALF_EXTENTS :
- {
- if( mSceneObject )
- {
- value = mSceneObject->mHalfExtents[bufferIndex];
+ value = mGeometryType;
}
break;
}
-
case Dali::Geometry::Property::REQUIRES_DEPTH_TEST :
{
if( mSceneObject )
{
- value = mSceneObject->mRequiresDepthTest[bufferIndex];
+ value = mRequiresDepthTest;
}
break;
}
const SceneGraph::PropertyBase* Geometry::GetSceneObjectAnimatableProperty( Property::Index index ) const
{
const SceneGraph::PropertyBase* property = NULL;
-
if( OnStage() )
{
property = GEOMETRY_IMPL.GetRegisteredSceneGraphProperty ( this,
&Geometry::FindAnimatableProperty,
&Geometry::FindCustomProperty,
index );
-
- if( property == NULL && index < DEFAULT_PROPERTY_MAX_COUNT )
- {
- switch(index)
- {
- case Dali::Geometry::Property::GEOMETRY_CENTER :
- {
- property = &mSceneObject->mCenter;
- break;
- }
- case Dali::Geometry::Property::GEOMETRY_HALF_EXTENTS :
- {
- property = &mSceneObject->mHalfExtents;
- break;
- }
- default:
- {
- DALI_ASSERT_ALWAYS( 0 && "Property is not animatable" );
- break;
- }
- }
- }
}
+
return property;
}
if( OnStage() )
{
const SceneGraph::PropertyBase* baseProperty =
- GEOMETRY_IMPL.GetRegisteredSceneGraphProperty ( this,
- &Geometry::FindAnimatableProperty,
- &Geometry::FindCustomProperty,
- index );
+ GEOMETRY_IMPL.GetRegisteredSceneGraphProperty ( this,
+ &Geometry::FindAnimatableProperty,
+ &Geometry::FindCustomProperty,
+ index );
property = static_cast<const PropertyInputImpl*>( baseProperty );
-
- if( property == NULL && index < DEFAULT_PROPERTY_MAX_COUNT )
- {
- switch(index)
- {
- case Dali::Geometry::Property::GEOMETRY_TYPE :
- {
- property = &mSceneObject->mGeometryType;
- break;
- }
- case Dali::Geometry::Property::GEOMETRY_CENTER :
- {
- property = &mSceneObject->mCenter;
- break;
- }
- case Dali::Geometry::Property::GEOMETRY_HALF_EXTENTS :
- {
- property = &mSceneObject->mHalfExtents;
- break;
- }
- case Dali::Geometry::Property::REQUIRES_DEPTH_TEST :
- {
- property = &mSceneObject->mRequiresDepthTest;
- break;
- }
- default:
- {
- DALI_ASSERT_ALWAYS( 0 && "Property cannot be a constraint input");
- break;
- }
- }
- }
}
return property;
}
-int Geometry::GetPropertyComponentIndex( Property::Index index ) const
-{
- // @todo MESH_REWORK - Change this if component properties are added for center/half-extent
- return Property::INVALID_COMPONENT_INDEX;
-}
-
bool Geometry::OnStage() const
{
return mOnStage;
void Geometry::Connect()
{
mOnStage = true;
-
- PropertyBufferConnectorContainer::const_iterator end = mVertexBufferConnectors.end();
- for( PropertyBufferConnectorContainer::iterator it = mVertexBufferConnectors.begin();
- it < end;
- ++it )
- {
- it->OnStageConnect();
- }
- mIndexBufferConnector.OnStageConnect();
}
void Geometry::Disconnect()
{
mOnStage = false;
-
- PropertyBufferConnectorContainer::const_iterator end = mVertexBufferConnectors.end();
- for( PropertyBufferConnectorContainer::iterator it = mVertexBufferConnectors.begin();
- it < end;
- ++it )
- {
- it->OnStageDisconnect();
- }
- mIndexBufferConnector.OnStageDisconnect();
}
Geometry::Geometry()
: mSceneObject( NULL ),
+ mIndexBuffer( NULL ),
+ mGeometryType(Dali::Geometry::TRIANGLES),
+ mRequiresDepthTest(false),
mOnStage( false )
{
}
*/
virtual const PropertyInputImpl* GetSceneObjectInputProperty( Property::Index index ) const;
- /**
- * @copydoc Dali::Internal::Object::GetPropertyComponentIndex()
- */
- virtual int GetPropertyComponentIndex( Property::Index index ) const;
-
public: // Functions from Connectable
/**
* @copydoc Dali::Internal::Connectable::OnStage()
Geometry& operator=( const Geometry& );
private: // data
- typedef ObjectConnector<PropertyBuffer> PropertyBufferConnector;
- typedef std::vector< PropertyBufferConnector > PropertyBufferConnectorContainer;
- PropertyBufferConnectorContainer mVertexBufferConnectors; ///< Vector of connectors that hold the property buffers used by this geometry
- PropertyBufferConnector mIndexBufferConnector; ///< Connector that holds the index buffer used by this geometry
+
SceneGraph::Geometry* mSceneObject;
+
+ std::vector<PropertyBufferPtr> mVertexBuffers; ///< Vector of intrusive pointers to vertex buffers
+ PropertyBufferPtr mIndexBuffer; ///< Intrusive pointer to index buffer
+
+ Dali::Geometry::GeometryType mGeometryType; ///< Geometry type (cached)
+ bool mRequiresDepthTest; ///< Establish if geometry requires depth testing (cached)
+
bool mOnStage;
};
// CLASS HEADER
#include <dali/internal/event/rendering/material-impl.h> // Dali::Internal::Material
+//EXTERNAL INCLUDES
+#include <string>
+
// INTERNAL INCLUDES
#include <dali/public-api/object/type-registry.h>
#include <dali/devel-api/rendering/material.h> // Dali::Internal::Material
#include <dali/internal/event/common/property-helper.h> // DALI_PROPERTY_TABLE_BEGIN, DALI_PROPERTY, DALI_PROPERTY_TABLE_END
#include <dali/internal/update/manager/update-manager.h>
#include <dali/internal/update/rendering/scene-graph-material.h>
-#include <dali/internal/update/rendering/scene-graph-sampler.h>
namespace Dali
{
DALI_ASSERT_DEBUG( mSceneObject )
mShader = &shader;
- const SceneGraph::Shader& sceneGraphShader = dynamic_cast<const SceneGraph::Shader&>( *shader.GetSceneObject() );
+ SceneGraph::Shader& sceneGraphShader = *shader.GetShaderSceneObject();
SceneGraph::SetShaderMessage( GetEventThreadServices(), *mSceneObject, sceneGraphShader );
}
return mShader.Get();
}
-void Material::AddSampler( Sampler& sampler )
+size_t Material::AddTexture( ImagePtr image, const std::string& uniformName, SamplerPtr sampler )
{
- SamplerConnector connector;
- connector.Set( sampler, OnStage() );
- mSamplerConnectors.push_back( connector );
+ size_t index = mTextures.size();
+ mTextures.push_back( Texture( uniformName, image, sampler ) );
+
+ Render::Sampler* renderSampler(0);
+ if( sampler )
+ {
+ renderSampler = sampler->GetSamplerRenderObject();
+ }
+
+ if( mOnStage )
+ {
+ image->Connect();
+ }
+
+ SceneGraph::AddTextureMessage( GetEventThreadServices(), *mSceneObject, uniformName, image->GetResourceId(), renderSampler );
+ return index;
+}
+
+void Material::RemoveTexture( size_t index )
+{
+ if( index < GetNumberOfTextures() )
+ {
+ mTextures.erase( mTextures.begin() + index );
+ SceneGraph::RemoveTextureMessage( GetEventThreadServices(), *mSceneObject, index );
+ }
+}
+
+void Material::SetTextureImage( size_t index, Image* image )
+{
+ if( index < GetNumberOfTextures() )
+ {
+ if( mTextures[index].mImage && mOnStage )
+ {
+ mTextures[index].mImage->Disconnect();
+ image->Connect();
+ }
+
+ mTextures[index].mImage.Reset(image);
+ SceneGraph::SetTextureImageMessage( GetEventThreadServices(), *mSceneObject, index, mTextures[index].mImage.Get()->GetResourceId() );
+ }
+}
+
+void Material::SetTextureSampler( size_t index, Sampler* sampler )
+{
+ if( index < GetNumberOfTextures() )
+ {
+ mTextures[index].mSampler.Reset(sampler);
- const SceneGraph::Sampler& sceneGraphSampler = dynamic_cast<const SceneGraph::Sampler&>( *sampler.GetSceneObject() );
- SceneGraph::AddSamplerMessage( GetEventThreadServices(), *mSceneObject, sceneGraphSampler );
+ Render::Sampler* renderSampler(0);
+ if( sampler )
+ {
+ renderSampler = sampler->GetSamplerRenderObject();
+ }
+ SceneGraph::SetTextureSamplerMessage( GetEventThreadServices(), *mSceneObject, index, renderSampler );
+ }
}
-std::size_t Material::GetNumberOfSamplers() const
+void Material::SetTextureUniformName( size_t index, const std::string& uniformName )
{
- return mSamplerConnectors.size();
+ if( index < GetNumberOfTextures() )
+ {
+ mTextures[index].mUniformName = uniformName;
+ SceneGraph::SetTextureUniformNameMessage( GetEventThreadServices(), *mSceneObject, index, uniformName );
+ }
}
-void Material::RemoveSampler( std::size_t index )
+int Material::GetTextureIndex( const std::string& uniformName )
{
- mSamplerConnectors.erase( mSamplerConnectors.begin() + index );
+ size_t textureCount(GetNumberOfTextures());
+ for( size_t i(0); i<textureCount; ++i )
+ {
+ if( uniformName.compare( mTextures[i].mUniformName ) == 0 )
+ {
+ return i;
+ }
+ }
+
+ return -1;
}
-Sampler* Material::GetSamplerAt( unsigned int index ) const
+void Material::SetTextureAffectsTransparency( size_t index, bool affectsTransparency )
{
- return mSamplerConnectors[index].Get().Get();
+ if( index < GetNumberOfTextures() )
+ {
+ SceneGraph::SetTextureAffectsTransparencyMessage( GetEventThreadServices(), *mSceneObject, index, affectsTransparency );
+ }
+}
+
+size_t Material::GetNumberOfTextures() const
+{
+ return mTextures.size();
}
void Material::SetFaceCullingMode( Dali::Material::FaceCullingMode cullingMode )
int Material::GetPropertyComponentIndex( Property::Index index ) const
{
- // @todo MESH_REWORK - Change this if component properties are added for color/blend-color
return Property::INVALID_COMPONENT_INDEX;
}
{
mOnStage = true;
- SamplerConnectorContainer::const_iterator end = mSamplerConnectors.end();
- for( SamplerConnectorContainer::iterator it = mSamplerConnectors.begin();
- it < end;
- ++it )
+ for( size_t i(0); i<mTextures.size(); ++i )
{
- it->OnStageConnect();
+ if( mTextures[i].mImage )
+ {
+ mTextures[i].mImage->Connect();
+ if( mTextures[i].mImage->GetResourceId() != 0 )
+ {
+ SceneGraph::SetTextureImageMessage( GetEventThreadServices(), *mSceneObject, i, mTextures[i].mImage->GetResourceId() );
+ }
+ }
}
}
void Material::Disconnect()
{
- mOnStage = false;
-
- SamplerConnectorContainer::const_iterator end = mSamplerConnectors.end();
- for( SamplerConnectorContainer::iterator it = mSamplerConnectors.begin();
- it < end;
- ++it )
+ for( size_t i(0); i<mTextures.size(); ++i )
{
- it->OnStageDisconnect();
+ if( mTextures[i].mImage )
+ {
+ mTextures[i].mImage->Disconnect();
+ }
}
+
+ mOnStage = false;
}
Material::Material()
: mSceneObject( NULL ),
+ mBlendingMode( Dali::BlendingMode::AUTO ),
mOnStage( false )
{
}
Shader* GetShader() const;
/**
- * @copydoc Dali::Material::AddSampler()
+ * @copydoc Dali::Material::AddTexture()
*/
- void AddSampler( Sampler& sampler );
+ size_t AddTexture( ImagePtr image, const std::string& uniformName, SamplerPtr sampler );
/**
- * @copydoc Dali::Material::GetNumberOfSamplers()
+ * @copydoc Dali::Material::RemoveTexture()
*/
- std::size_t GetNumberOfSamplers() const;
+ void RemoveTexture( size_t index );
/**
- * @copydoc Dali::Material::RemoveSampler()
+ * @copydoc Dali::Material::SetTextureImage()
*/
- void RemoveSampler( std::size_t index );
+ void SetTextureImage( size_t index, Image* image );
/**
- * @copydoc Dali::Material::GetSamplerAt()
+ * @copydoc Dali::Material::SetTextureSampler()
*/
- Sampler* GetSamplerAt( unsigned int index ) const;
+ void SetTextureSampler( size_t index, Sampler* sampler );
/**
+ * @copydoc Dali::Material::SetTextureUniformName()
+ */
+ void SetTextureUniformName( size_t index, const std::string& uniformName );
+
+ /**
+ * @copydoc Dali::Material::GetTextureIndex()
+ */
+ int GetTextureIndex( const std::string& uniformName );
+
+ /**
+ * @copydoc Dali::Material::SetTextureAffectsTransparency()
+ */
+ void SetTextureAffectsTransparency( size_t index, bool affectsTransparency );
+
+ /**
+ * @copydoc Dali::Material::GetNumberOfTextures()
+ */
+ size_t GetNumberOfTextures() const;
+ /**
* @copydoc Dali::Material::SetFaceCullingMode()
*/
void SetFaceCullingMode( Dali::Material::FaceCullingMode cullingMode );
virtual void Disconnect();
private: // implementation
+
+ struct Texture
+ {
+ Texture()
+ :mUniformName(""),
+ mImage(NULL),
+ mSampler( NULL )
+ {}
+
+ Texture( const std::string& name, ImagePtr image, SamplerPtr sampler )
+ :mUniformName(name),
+ mImage( image ),
+ mSampler( sampler )
+ {}
+
+ std::string mUniformName;
+ ImagePtr mImage;
+ SamplerPtr mSampler;
+ };
+
Material();
/**
private: //data
IntrusivePtr<Shader> mShader; ///< Connector that holds the shader used by this material
-
- typedef ObjectConnector<Sampler> SamplerConnector;
- typedef std::vector< SamplerConnector > SamplerConnectorContainer;
- SamplerConnectorContainer mSamplerConnectors; ///< Vector of connectors that hold the samplers used by this material
-
+ std::vector<Material::Texture> mTextures; ///<Vector of textures used by this material
SceneGraph::Material* mSceneObject;
BlendingMode::Type mBlendingMode; ///< Local store
BlendingOptions mBlendingOptions; ///< Local copy of blending options bitmask
bool mOnStage;
+
};
} // namespace Internal
#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
#include <dali/internal/event/common/property-input-impl.h>
-#include <dali/internal/update/node-attachments/scene-graph-renderer-attachment.h>
+#include <dali/internal/update/rendering/scene-graph-renderer.h>
#include <dali/internal/update/manager/update-manager.h>
namespace Dali
return mDepthIndex;
}
-SceneGraph::RendererAttachment* Renderer::GetRendererSceneObject()
+SceneGraph::Renderer* Renderer::GetRendererSceneObject()
{
return mSceneObject;
}
bool Renderer::OnStage() const
{
- return mOnStage;
+ return mOnStageCount > 0;
}
void Renderer::Connect()
{
- // @todo: MESH_REWORK : check this
- mGeometryConnector.OnStageConnect();
- mMaterialConnector.OnStageConnect();
- mOnStage = true;
+ if( mOnStageCount == 0 )
+ {
+ OnStageConnectMessage( GetEventThreadServices(), *mSceneObject );
+ mGeometryConnector.OnStageConnect();
+ mMaterialConnector.OnStageConnect();
+ }
+ ++mOnStageCount;
}
void Renderer::Disconnect()
{
- // @todo: MESH_REWORK : check this
- mGeometryConnector.OnStageDisconnect();
- mMaterialConnector.OnStageDisconnect();
- mOnStage = false;
+ --mOnStageCount;
+ if( mOnStageCount == 0 )
+ {
+ OnStageDisconnectMessage( GetEventThreadServices(), *mSceneObject);
+ mGeometryConnector.OnStageDisconnect();
+ mMaterialConnector.OnStageDisconnect();
+ }
}
Renderer::Renderer()
: mSceneObject(NULL),
mDepthIndex(0),
- mOnStage(false)
+ mOnStageCount(0)
{
}
EventThreadServices& eventThreadServices = GetEventThreadServices();
SceneGraph::UpdateManager& updateManager = eventThreadServices.GetUpdateManager();
- // Transfer object ownership of scene-object to message
- mSceneObject = SceneGraph::RendererAttachment::New();
-
- // Send message to update to connect to scene graph:
- AttachToSceneGraphMessage( updateManager, mSceneObject );
+ mSceneObject = new SceneGraph::Renderer();
+ AddMessage( updateManager, updateManager.GetRendererOwner(), *mSceneObject );
eventThreadServices.RegisterObject( this );
}
if( EventThreadServices::IsCoreRunning() )
{
EventThreadServices& eventThreadServices = GetEventThreadServices();
+ SceneGraph::UpdateManager& updateManager = eventThreadServices.GetUpdateManager();
+ RemoveMessage( updateManager, updateManager.GetRendererOwner(), *mSceneObject );
+
eventThreadServices.UnregisterObject( this );
}
}
#include <dali/internal/event/common/object-impl.h> // Dali::Internal::Object
#include <dali/internal/event/rendering/material-impl.h> // Dali::Internal::Material
#include <dali/internal/event/rendering/geometry-impl.h> // Dali::Internal::Geometry
+#include <dali/internal/update/nodes/node.h>
namespace Dali
{
{
namespace SceneGraph
{
-class RendererAttachment;
+class Renderer;
}
+
class Renderer;
typedef IntrusivePtr<Renderer> RendererPtr;
/**
* Renderer is an object that can be used to show content by combining a Geometry with a material.
*/
-class Renderer : public Object, public Connectable
+class Renderer : public Object
{
public:
*
* @return the scene object
*/
- SceneGraph::RendererAttachment* GetRendererSceneObject();
+ SceneGraph::Renderer* GetRendererSceneObject();
public: // Default property extensions from Object
Renderer& operator=( const Renderer& );
private: // data
- SceneGraph::RendererAttachment* mSceneObject;
+ SceneGraph::Renderer* mSceneObject;
ObjectConnector<Geometry> mGeometryConnector; ///< Connector that holds the geometry used by this renderer
ObjectConnector<Material> mMaterialConnector; ///< Connector that holds the material used by this renderer
int mDepthIndex;
- bool mOnStage;
+ int mOnStageCount;
};
} // namespace Internal
#include <dali/internal/event/rendering/sampler-impl.h> // Dali::Internal::Sampler
// INTERNAL INCLUDES
-#include <dali/public-api/object/type-registry.h>
#include <dali/devel-api/rendering/sampler.h> // Dali::Internal::Sampler
-#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
-#include <dali/internal/update/rendering/scene-graph-sampler.h> // Dali::Internal::SceneGraph::Sampler
+#include <dali/internal/event/common/stage-impl.h>
#include <dali/internal/update/manager/update-manager.h>
+#include <dali/internal/render/renderers/render-sampler.h>
namespace Dali
{
namespace Internal
{
-namespace
-{
-
-/**
- * |name |type |writable|animatable|constraint-input|enum for index-checking|
- */
-DALI_PROPERTY_TABLE_BEGIN
-DALI_PROPERTY( "minification-filter", STRING, true, false, true, Dali::Sampler::Property::MINIFICATION_FILTER )
-DALI_PROPERTY( "magnification-filter", STRING, true, false, true, Dali::Sampler::Property::MAGNIGICATION_FILTER )
-DALI_PROPERTY( "u-wrap", STRING, true, false, true, Dali::Sampler::Property::U_WRAP )
-DALI_PROPERTY( "v-wrap", STRING, true, false, true, Dali::Sampler::Property::V_WRAP )
-DALI_PROPERTY( "affects-transparency", BOOLEAN, true, false, true, Dali::Sampler::Property::AFFECTS_TRANSPARENCY )
-DALI_PROPERTY_TABLE_END( DEFAULT_ACTOR_PROPERTY_START_INDEX )
-
-const ObjectImplHelper<DEFAULT_PROPERTY_COUNT> SAMPLER_IMPL = { DEFAULT_PROPERTY_DETAILS };
-
-BaseHandle Create()
-{
- return Dali::BaseHandle();
-}
-
-TypeRegistration mType( typeid( Dali::Sampler ), typeid( Dali::Handle ), Create );
-
-} // unnamed namespace
-
-SamplerPtr Sampler::New( const std::string& textureUnitUniformName )
+SamplerPtr Sampler::New( )
{
SamplerPtr sampler( new Sampler() );
- sampler->Initialize( textureUnitUniformName );
+ sampler->Initialize();
return sampler;
}
-void Sampler::SetTextureUnitUniformName( const std::string& name )
-{
- SetTextureUnitUniformNameMessage( GetEventThreadServices(), *mSceneObject, name);
-}
-
-void Sampler::SetImage( ImagePtr& image )
-{
- // Keep a reference to the image object
- mImageConnector.Set( image, OnStage() );
-
- // sceneObject is being used in a separate thread; queue a message to set
- if( mOnStage )
- {
- unsigned int resourceId = image->GetResourceId();
- if( resourceId != 0 )
- {
- SetTextureMessage( GetEventThreadServices(), *mSceneObject, resourceId );
- }
- }
-}
-
-ImagePtr Sampler::GetImage() const
-{
- return mImageConnector.Get();
-}
-
-void Sampler::SetFilterMode( Dali::Sampler::FilterMode minFilter, Dali::Sampler::FilterMode magFilter )
-{
- if( NULL != mSceneObject )
- {
- SetFilterModeMessage( GetEventThreadServices(), *mSceneObject, minFilter, magFilter );
- }
-}
-
-void Sampler::SetWrapMode( Dali::Sampler::WrapMode uWrap, Dali::Sampler::WrapMode vWrap )
-{
- if( NULL != mSceneObject )
- {
- SetWrapModeMessage( GetEventThreadServices(), *mSceneObject, uWrap, vWrap );
- }
-}
-
-void Sampler::SetAffectsTransparency( bool affectsTransparency )
-{
- if( NULL != mSceneObject )
- {
- SceneGraph::DoubleBufferedPropertyMessage<bool>::Send( GetEventThreadServices(), mSceneObject, &mSceneObject->mAffectsTransparency, &SceneGraph::DoubleBufferedProperty<bool>::Set, affectsTransparency );
- }
-}
-
-const SceneGraph::Sampler* Sampler::GetSamplerSceneObject() const
-{
- return mSceneObject;
-}
-
-unsigned int Sampler::GetDefaultPropertyCount() const
-{
- return SAMPLER_IMPL.GetDefaultPropertyCount();
-}
-
-void Sampler::GetDefaultPropertyIndices( Property::IndexContainer& indices ) const
-{
- SAMPLER_IMPL.GetDefaultPropertyIndices( indices );
-}
-
-const char* Sampler::GetDefaultPropertyName(Property::Index index) const
-{
- return SAMPLER_IMPL.GetDefaultPropertyName( index );
-}
-
-Property::Index Sampler::GetDefaultPropertyIndex( const std::string& name ) const
-{
- return SAMPLER_IMPL.GetDefaultPropertyIndex( name );
-}
-
-bool Sampler::IsDefaultPropertyWritable( Property::Index index ) const
+void Sampler::SetFilterMode( Dali::FilterMode::Type minFilter, Dali::FilterMode::Type magFilter )
{
- return SAMPLER_IMPL.IsDefaultPropertyWritable( index );
-}
-
-bool Sampler::IsDefaultPropertyAnimatable( Property::Index index ) const
-{
- return SAMPLER_IMPL.IsDefaultPropertyAnimatable( index );
-}
-
-bool Sampler::IsDefaultPropertyAConstraintInput( Property::Index index ) const
-{
- return SAMPLER_IMPL.IsDefaultPropertyAConstraintInput( index );
-}
-
-Property::Type Sampler::GetDefaultPropertyType( Property::Index index ) const
-{
- return SAMPLER_IMPL.GetDefaultPropertyType( index );
-}
-
-void Sampler::SetDefaultProperty( Property::Index index,
- const Property::Value& propertyValue )
-{
- switch( index )
- {
- case Dali::Sampler::Property::MINIFICATION_FILTER:
- {
- SceneGraph::DoubleBufferedPropertyMessage<int>::Send( GetEventThreadServices(), mSceneObject, &mSceneObject->mMinFilter, &SceneGraph::DoubleBufferedProperty<int>::Set, propertyValue.Get<int>() );
- break;
- }
- case Dali::Sampler::Property::MAGNIGICATION_FILTER:
- {
- SceneGraph::DoubleBufferedPropertyMessage<int>::Send( GetEventThreadServices(), mSceneObject, &mSceneObject->mMagFilter, &SceneGraph::DoubleBufferedProperty<int>::Set, propertyValue.Get<int>() );
- break;
- }
- case Dali::Sampler::Property::U_WRAP:
- {
- SceneGraph::DoubleBufferedPropertyMessage<int>::Send( GetEventThreadServices(), mSceneObject, &mSceneObject->mUWrapMode, &SceneGraph::DoubleBufferedProperty<int>::Set, propertyValue.Get<int>() );
- break;
- }
- case Dali::Sampler::Property::V_WRAP:
- {
- SceneGraph::DoubleBufferedPropertyMessage<int>::Send( GetEventThreadServices(), mSceneObject, &mSceneObject->mVWrapMode, &SceneGraph::DoubleBufferedProperty<int>::Set, propertyValue.Get<int>() );
- break;
- }
- case Dali::Sampler::Property::AFFECTS_TRANSPARENCY:
- {
- SceneGraph::DoubleBufferedPropertyMessage<bool>::Send( GetEventThreadServices(), mSceneObject, &mSceneObject->mAffectsTransparency, &SceneGraph::DoubleBufferedProperty<bool>::Set, propertyValue.Get<bool>() );
- break;
- }
- }
-}
-
-void Sampler::SetSceneGraphProperty( Property::Index index,
- const PropertyMetadata& entry,
- const Property::Value& value )
-{
- SAMPLER_IMPL.SetSceneGraphProperty( GetEventThreadServices(), this, index, entry, value );
- OnPropertySet(index, value);
-}
-
-Property::Value Sampler::GetDefaultProperty( Property::Index index ) const
-{
- BufferIndex bufferIndex = GetEventThreadServices().GetEventBufferIndex();
- Property::Value value;
-
- switch( index )
- {
- case Dali::Sampler::Property::MINIFICATION_FILTER:
- {
- value = mSceneObject->mMinFilter[bufferIndex];
- break;
- }
- case Dali::Sampler::Property::MAGNIGICATION_FILTER:
- {
- value = mSceneObject->mMagFilter[bufferIndex];
- break;
- }
- case Dali::Sampler::Property::U_WRAP:
- {
- value = mSceneObject->mUWrapMode[bufferIndex];
- break;
- }
- case Dali::Sampler::Property::V_WRAP:
- {
- value = mSceneObject->mVWrapMode[bufferIndex];
- break;
- }
- case Dali::Sampler::Property::AFFECTS_TRANSPARENCY:
- {
- value = mSceneObject->mAffectsTransparency[bufferIndex];
- break;
- }
- }
- return value;
-}
-
-const SceneGraph::PropertyOwner* Sampler::GetPropertyOwner() const
-{
- return mSceneObject;
-}
-
-const SceneGraph::PropertyOwner* Sampler::GetSceneObject() const
-{
- return mSceneObject;
-}
-
-const SceneGraph::PropertyBase* Sampler::GetSceneObjectAnimatableProperty( Property::Index index ) const
-{
- DALI_ASSERT_ALWAYS( IsPropertyAnimatable( index ) && "Property is not animatable" );
-
- const SceneGraph::PropertyBase* property = NULL;
-
- if( OnStage() )
+ if( NULL != mRenderObject )
{
- property = SAMPLER_IMPL.GetRegisteredSceneGraphProperty( this,
- &Sampler::FindAnimatableProperty,
- &Sampler::FindCustomProperty,
- index );
-
- if( property == NULL && index < DEFAULT_PROPERTY_MAX_COUNT )
- {
- // No animatable default props
- DALI_ASSERT_ALWAYS( 0 && "Property is not animatable" );
- }
+ SetFilterModeMessage( mEventThreadServices.GetUpdateManager(), *mRenderObject, (unsigned int)minFilter, (unsigned int)magFilter );
}
-
- return property;
}
-const PropertyInputImpl* Sampler::GetSceneObjectInputProperty( Property::Index index ) const
+void Sampler::SetWrapMode( Dali::WrapMode::Type uWrap, Dali::WrapMode::Type vWrap )
{
- const PropertyInputImpl* property = NULL;
-
- if( OnStage() )
+ if( NULL != mRenderObject )
{
- const SceneGraph::PropertyBase* baseProperty =
- SAMPLER_IMPL.GetRegisteredSceneGraphProperty( this,
- &Sampler::FindAnimatableProperty,
- &Sampler::FindCustomProperty,
- index );
- property = static_cast<const PropertyInputImpl*>( baseProperty );
-
- if( property == NULL && index < DEFAULT_PROPERTY_MAX_COUNT )
- {
- switch( index )
- {
- case Dali::Sampler::Property::MINIFICATION_FILTER:
- {
- property = &mSceneObject->mMinFilter;
- break;
- }
- case Dali::Sampler::Property::MAGNIGICATION_FILTER:
- {
- property = &mSceneObject->mMagFilter;
- break;
- }
- case Dali::Sampler::Property::U_WRAP:
- {
- property = &mSceneObject->mUWrapMode;
- break;
- }
- case Dali::Sampler::Property::V_WRAP:
- {
- property = &mSceneObject->mVWrapMode;
- break;
- }
- case Dali::Sampler::Property::AFFECTS_TRANSPARENCY:
- {
- property = &mSceneObject->mAffectsTransparency;
- break;
- }
- }
- }
+ SetWrapModeMessage( mEventThreadServices.GetUpdateManager(), *mRenderObject, (unsigned int)uWrap, (unsigned int)vWrap );
}
-
- return property;
}
-int Sampler::GetPropertyComponentIndex( Property::Index index ) const
+Render::Sampler* Sampler::GetSamplerRenderObject()
{
- return Property::INVALID_COMPONENT_INDEX;
+ return mRenderObject;
}
-bool Sampler::OnStage() const
-{
- return mOnStage;
-}
-
-void Sampler::Connect()
-{
- mOnStage = true;
-
- mImageConnector.OnStageConnect();
-
- // sceneObject is being used in a separate thread; queue a message to set
- unsigned int resourceId = mImageConnector.Get()->GetResourceId();
- SetTextureMessage( GetEventThreadServices(), *mSceneObject, resourceId );
-}
-
-void Sampler::Disconnect()
-{
- mOnStage = false;
-
- mImageConnector.OnStageDisconnect();
-}
Sampler::Sampler()
-: mSceneObject( NULL ),
- mOnStage( false )
+:mEventThreadServices( *Stage::GetCurrent() ),
+ mRenderObject( NULL )
{
}
-void Sampler::Initialize( const std::string& textureUnitUniformName )
+void Sampler::Initialize()
{
- EventThreadServices& eventThreadServices = GetEventThreadServices();
- SceneGraph::UpdateManager& updateManager = eventThreadServices.GetUpdateManager();
-
- mSceneObject = new SceneGraph::Sampler( textureUnitUniformName );
- AddMessage( updateManager, updateManager.GetSamplerOwner(), *mSceneObject );
+ SceneGraph::UpdateManager& updateManager = mEventThreadServices.GetUpdateManager();
- eventThreadServices.RegisterObject( this );
+ mRenderObject = new Render::Sampler();
+ AddSamplerMessage( updateManager, *mRenderObject );
}
Sampler::~Sampler()
{
- if( EventThreadServices::IsCoreRunning() )
+ if( EventThreadServices::IsCoreRunning() && mRenderObject )
{
- EventThreadServices& eventThreadServices = GetEventThreadServices();
- SceneGraph::UpdateManager& updateManager = eventThreadServices.GetUpdateManager();
- RemoveMessage( updateManager, updateManager.GetSamplerOwner(), *mSceneObject );
-
- eventThreadServices.UnregisterObject( this );
+ SceneGraph::UpdateManager& updateManager = mEventThreadServices.GetUpdateManager();
+ RemoveSamplerMessage( updateManager, *mRenderObject );
}
}
*/
// INTERNAL INCLUDES
+#include <dali/public-api/actors/sampling.h>
#include <dali/public-api/common/dali-common.h> // DALI_ASSERT_ALWAYS
#include <dali/public-api/common/intrusive-ptr.h> // Dali::IntrusivePtr
#include <dali/devel-api/rendering/sampler.h> // Dali::Sampler
{
namespace Internal
{
-namespace SceneGraph
+namespace Render
{
class Sampler;
}
* Sampler is an object that contains an array of structures of values that
* can be accessed as properties.
*/
-class Sampler : public Object, public Connectable
+class Sampler : public BaseObject
{
public:
* Create a new Sampler.
* @return A smart-pointer to the newly allocated Sampler.
*/
- static SamplerPtr New( const std::string& textureUnitUniformName );
-
- /**
- * @copydoc Dali::Sampler::SetUniformName()
- */
- void SetTextureUnitUniformName( const std::string& name );
-
- /**
- * @copydoc Dali::Sampler::SetImage()
- */
- void SetImage( ImagePtr& image );
-
- /**
- * @copydoc Dali::Sampler::GetImage()
- */
- ImagePtr GetImage() const;
+ static SamplerPtr New( );
/**
* @copydoc Dali::Sampler::SetFilterMode()
*/
- void SetFilterMode( Dali::Sampler::FilterMode minFilter, Dali::Sampler::FilterMode magFilter );
+ void SetFilterMode( Dali::FilterMode::Type minFilter, Dali::FilterMode::Type magFilter );
/**
* @copydoc Dali::Sampler::SetWrapMode()
*/
- void SetWrapMode( Dali::Sampler::WrapMode uWrap, Dali::Sampler::WrapMode vWrap );
+ void SetWrapMode( Dali::WrapMode::Type uWrap, Dali::WrapMode::Type vWrap );
/**
- * @copydoc Dali::Sampler::SetAffectsTransparency()
- */
- void SetAffectsTransparency( bool affectsTransparency );
-
- /**
- * @brief Get the sampler scene object
+ * Get the render thread sampler
*
- * @return the sampler scene object
- */
- const SceneGraph::Sampler* GetSamplerSceneObject() const;
-
-public: // Default property extensions from Object
-
- /**
- * @copydoc Dali::Internal::Object::GetDefaultPropertyCount()
- */
- virtual unsigned int GetDefaultPropertyCount() const;
-
- /**
- * @copydoc Dali::Internal::Object::GetDefaultPropertyIndices()
- */
- virtual void GetDefaultPropertyIndices( Property::IndexContainer& indices ) const;
-
- /**
- * @copydoc Dali::Internal::Object::GetDefaultPropertyName()
- */
- virtual const char* GetDefaultPropertyName(Property::Index index) const;
-
- /**
- * @copydoc Dali::Internal::Object::GetDefaultPropertyIndex()
- */
- virtual Property::Index GetDefaultPropertyIndex(const std::string& name) const;
-
- /**
- * @copydoc Dali::Internal::Object::IsDefaultPropertyWritable()
+ * @return The render thread sampler
*/
- virtual bool IsDefaultPropertyWritable(Property::Index index) const;
-
- /**
- * @copydoc Dali::Internal::Object::IsDefaultPropertyAnimatable()
- */
- virtual bool IsDefaultPropertyAnimatable(Property::Index index) const;
-
- /**
- * @copydoc Dali::Internal::Object::IsDefaultPropertyAConstraintInput()
- */
- virtual bool IsDefaultPropertyAConstraintInput( Property::Index index ) const;
-
- /**
- * @copydoc Dali::Internal::Object::GetDefaultPropertyType()
- */
- virtual Property::Type GetDefaultPropertyType(Property::Index index) const;
-
- /**
- * @copydoc Dali::Internal::Object::SetDefaultProperty()
- */
- virtual void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue);
-
- /**
- * @copydoc Dali::Internal::Object::SetSceneGraphProperty()
- */
- virtual void SetSceneGraphProperty( Property::Index index, const PropertyMetadata& entry, const Property::Value& value );
-
- /**
- * @copydoc Dali::Internal::Object::GetDefaultProperty()
- */
- virtual Property::Value GetDefaultProperty( Property::Index index ) const;
-
- /**
- * @copydoc Dali::Internal::Object::GetPropertyOwner()
- */
- virtual const SceneGraph::PropertyOwner* GetPropertyOwner() const;
-
- /**
- * @copydoc Dali::Internal::Object::GetSceneObject()
- */
- virtual const SceneGraph::PropertyOwner* GetSceneObject() const;
-
- /**
- * @copydoc Dali::Internal::Object::GetSceneObjectAnimatableProperty()
- */
- virtual const SceneGraph::PropertyBase* GetSceneObjectAnimatableProperty( Property::Index index ) const;
-
- /**
- * @copydoc Dali::Internal::Object::GetSceneObjectInputProperty()
- */
- virtual const PropertyInputImpl* GetSceneObjectInputProperty( Property::Index index ) const;
-
- /**
- * @copydoc Dali::Internal::Object::GetPropertyComponentIndex()
- */
- virtual int GetPropertyComponentIndex( Property::Index index ) const;
-
-public: // Functions from Connectable
- /**
- * @copydoc Dali::Internal::Connectable::OnStage()
- */
- virtual bool OnStage() const;
-
- /**
- * @copydoc Dali::Internal::Connectable::Connect()
- */
- virtual void Connect();
-
- /**
- * @copydoc Dali::Internal::Connectable::Disconnect()
- */
- virtual void Disconnect();
+ Render::Sampler* GetSamplerRenderObject();
private:
Sampler();
/**
* Second stage initialization
*/
- void Initialize( const std::string& textureUnitUniformName );
+ void Initialize( );
protected:
/**
virtual ~Sampler();
private: // data
- //TODO: MESH_REWORK : change to ObjectConnector
- ImageConnector mImageConnector;
- SceneGraph::Sampler* mSceneObject;
- bool mOnStage;
+ EventThreadServices& mEventThreadServices; ///<Used to send messages to the render thread via the update thread
+ Render::Sampler* mRenderObject; ///<Render thread sampler for this sampler
+
};
} // namespace Internal
return mSceneObject;
}
+SceneGraph::Shader* Shader::GetShaderSceneObject()
+{
+ return mSceneObject;
+}
+
unsigned int Shader::GetDefaultPropertyCount() const
{
return SHADER_IMPL.GetDefaultPropertyCount();
*/
const SceneGraph::Shader* GetShaderSceneObject() const;
+ /**
+ * Retrieve the scene-graph shader added by this object.
+ * @return A pointer to the shader.
+ */
+ SceneGraph::Shader* GetShaderSceneObject();
+
public: // Default property extensions from Object
/**
typedef TicketContainer::size_type TicketContainerSize;
typedef std::pair<ResourceId, ResourceTicket*> TicketPair;
-typedef std::map<ResourceId, Bitmap*> BitmapCache;
-typedef BitmapCache::iterator BitmapCacheIter;
-
struct ResourceClient::Impl
{
Impl()
ResourceId mNextId;
TicketContainer mTickets;
- BitmapCache mBitmaps;
};
ResourceClient::ResourceClient( ResourceManager& resourceManager,
return ticket;
}
-ImageTicketPtr ResourceClient::AllocateBitmapImage( unsigned int width,
- unsigned int height,
- unsigned int bufferWidth,
- unsigned int bufferHeight,
- Pixel::Format pixelformat )
-{
- /* buffer is available via public-api, therefore not discardable */
- Bitmap* const bitmap = Bitmap::New( Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_RETAIN );
- Bitmap::PackedPixelsProfile* const packedBitmap = bitmap->GetPackedPixelsProfile();
- DALI_ASSERT_DEBUG(packedBitmap);
-
- packedBitmap->ReserveBuffer(pixelformat, width, height, bufferWidth, bufferHeight);
- DALI_ASSERT_DEBUG(bitmap->GetBuffer() != 0);
- DALI_ASSERT_DEBUG(bitmap->GetBufferSize() >= width * height);
-
- ImageTicketPtr ticket = AddBitmapImage(bitmap);
-
- DALI_ASSERT_DEBUG(bitmap->GetBuffer() != 0);
- DALI_ASSERT_DEBUG(bitmap->GetBufferSize() >= width * height);
- return ticket;
-}
-
ImageTicketPtr ResourceClient::AddBitmapImage(Bitmap* bitmap)
{
DALI_ASSERT_DEBUG( bitmap != NULL );
mImpl->mTickets.insert(TicketPair(newId, newTicket.Get()));
- // Store bitmap for immediate access.
- mImpl->mBitmaps[newId] = bitmap;
-
DALI_LOG_INFO(Debug::Filter::gResource, Debug::General, "ResourceClient: AddBitmapImage() New id = %u\n", newId);
RequestAddBitmapImageMessage( mEventThreadServices, mResourceManager, newId, bitmap );
yOffset );
}
-Bitmap* ResourceClient::GetBitmap(ResourceTicketPtr ticket)
-{
- DALI_ASSERT_DEBUG( ticket );
-
- Bitmap* bitmap = NULL;
- BitmapCacheIter iter = mImpl->mBitmaps.find(ticket->GetId());
-
- if( iter != mImpl->mBitmaps.end() )
- {
- bitmap = iter->second;
- }
- return bitmap;
-}
-
void ResourceClient::CreateGlTexture( ResourceId id )
{
RequestCreateGlTextureMessage( mEventThreadServices, mResourceManager, id );
const ResourceId deadId = ticket.GetId();
const ResourceTypePath& typePath = ticket.GetTypePath();
- // Ensure associated event owned resources are also removed
- mImpl->mBitmaps.erase(ticket.GetId());
-
// The ticket object is dead, remove from tickets container
TicketContainerSize erased = mImpl->mTickets.erase(deadId);
DALI_ASSERT_DEBUG(erased != 0);
ResourceTicketPtr RequestResourceTicket( ResourceId id );
/**
- * Reqeust allocation of a bitmap resource
- * @note Older hardware may require bufferWidth and bufferHeight to be a power of two
- * @param[in] width Image width in pixels
- * @param[in] height Image height in pixels
- * @param[in] bufferWidth Buffer width (stride) in pixels
- * @param[in] bufferHeight Buffer height in pixels
- * @param[in] pixelformat Pixel format
- * @return A ref-counted request object. Keep a copy until the resource is no longer required.
- */
- ImageTicketPtr AllocateBitmapImage ( unsigned int width,
- unsigned int height,
- unsigned int bufferWidth,
- unsigned int bufferHeight,
- Pixel::Format pixelformat );
-
- /**
* Injects a bitmap resource (does not require loading).
* @pre bitmap has to be initialized
* @param[in] bitmap an initialized bitmap
void UploadBitmap( ResourceId destId, Integration::BitmapPtr bitmap, std::size_t xOffset, std::size_t yOffset);
/**
- * Find Bitmap by ticket.
- * @pre ticket has to identify a Bitmap
- * @param[in] ticket The ticket returned from AllocateBitmapImage() or AddBitmapImage()
- * @return The bitmap, or NULL if the ticket did not reference a bitmap
+ * @brief Trigger asynchronous creation of GL texture to back resource immediately.
+ * @param[in] id The resource ID to allocate a GL texture for.
*/
- Integration::Bitmap* GetBitmap(ResourceTicketPtr ticket);
- /**
- * @brief Trigger asynchronous creation of GL texture to back resource immediately.
- * @param[in] id The resource ID to allocate a GL texture for.
- */
- void CreateGlTexture( ResourceId id );
+ void CreateGlTexture( ResourceId id );
public: // From ResourceTicketLifetimeObserver.
$(internal_src_dir)/common/core-impl.cpp \
$(internal_src_dir)/common/internal-constants.cpp \
$(internal_src_dir)/common/message-buffer.cpp \
+ $(internal_src_dir)/common/mutex-impl.cpp \
$(internal_src_dir)/common/image-sampler.cpp \
$(internal_src_dir)/common/image-attributes.cpp \
$(internal_src_dir)/common/fixed-size-memory-pool.cpp \
$(internal_src_dir)/event/actor-attachments/camera-attachment-impl.cpp \
$(internal_src_dir)/event/actor-attachments/image-attachment-impl.cpp \
$(internal_src_dir)/event/actor-attachments/renderable-attachment-impl.cpp \
- $(internal_src_dir)/event/actor-attachments/renderer-attachment-impl.cpp \
$(internal_src_dir)/event/actors/actor-impl.cpp \
$(internal_src_dir)/event/actors/custom-actor-internal.cpp \
$(internal_src_dir)/event/actors/image-actor-impl.cpp \
$(internal_src_dir)/event/events/tap-gesture-processor.cpp \
$(internal_src_dir)/event/events/touch-event-processor.cpp \
$(internal_src_dir)/event/images/atlas-impl.cpp \
- $(internal_src_dir)/event/images/bitmap-external.cpp \
$(internal_src_dir)/event/images/bitmap-packed-pixel.cpp \
$(internal_src_dir)/event/images/bitmap-compressed.cpp \
$(internal_src_dir)/event/images/image-impl.cpp \
$(internal_src_dir)/render/gl-resources/texture-cache.cpp \
$(internal_src_dir)/render/queue/render-queue.cpp \
$(internal_src_dir)/render/renderers/render-geometry.cpp \
+ $(internal_src_dir)/render/renderers/render-new-renderer.cpp \
+ $(internal_src_dir)/render/renderers/render-property-buffer.cpp \
+ $(internal_src_dir)/render/renderers/render-image-renderer.cpp \
$(internal_src_dir)/render/renderers/render-renderer.cpp \
- $(internal_src_dir)/render/renderers/render-renderer-property-buffer.cpp \
- $(internal_src_dir)/render/renderers/scene-graph-image-renderer.cpp \
- $(internal_src_dir)/render/renderers/scene-graph-renderer.cpp \
- $(internal_src_dir)/render/renderers/scene-graph-renderer-debug.cpp \
$(internal_src_dir)/render/shaders/custom-uniform.cpp \
$(internal_src_dir)/render/shaders/program.cpp \
$(internal_src_dir)/render/shaders/program-controller.cpp \
$(internal_src_dir)/update/common/property-owner.cpp \
$(internal_src_dir)/update/common/scene-graph-buffers.cpp \
$(internal_src_dir)/update/common/scene-graph-connection-change-propagator.cpp \
- $(internal_src_dir)/update/common/scene-graph-property-buffer.cpp \
$(internal_src_dir)/update/common/scene-graph-property-notification.cpp \
$(internal_src_dir)/update/common/uniform-map.cpp \
$(internal_src_dir)/update/controllers/render-message-dispatcher.cpp \
$(internal_src_dir)/update/node-attachments/scene-graph-camera-attachment.cpp \
$(internal_src_dir)/update/node-attachments/scene-graph-image-attachment.cpp \
$(internal_src_dir)/update/node-attachments/scene-graph-renderable-attachment.cpp \
- $(internal_src_dir)/update/node-attachments/scene-graph-renderer-attachment.cpp \
$(internal_src_dir)/update/nodes/node.cpp \
$(internal_src_dir)/update/nodes/node-messages.cpp \
$(internal_src_dir)/update/nodes/scene-graph-layer.cpp \
$(internal_src_dir)/update/render-tasks/scene-graph-render-task-list.cpp \
$(internal_src_dir)/update/rendering/scene-graph-geometry.cpp \
$(internal_src_dir)/update/rendering/scene-graph-material.cpp \
- $(internal_src_dir)/update/rendering/scene-graph-sampler.cpp \
+ $(internal_src_dir)/update/rendering/scene-graph-renderer.cpp \
$(internal_src_dir)/update/resources/bitmap-metadata.cpp \
$(internal_src_dir)/update/resources/resource-manager.cpp \
$(internal_src_dir)/update/resources/resource-tracker.cpp \
namespace SceneGraph
{
-bool Is2dBoxOutsideClipSpace(const Matrix& modelMatrix,
- const Matrix& modelViewProjectionMatrix,
+bool Is2dBoxOutsideClipSpace(const Matrix& modelViewProjectionMatrix,
const Rect<float>& boundingBox )
{
// First, calculate if the center is inside clip space:
#define _DALI_INTERNAL_SCENE_GRAPH_CULLING_ALGORITHMS_H_
/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
/**
* Determine if the given bounding box is outside clip space (given by the
* model view projection matrix).
- * @param[in] modelMatrix The world matrix of the bounding box.
* @param[in] modelViewProjectionMatrix The clip space matrix
* @param[in] boundingBox The bounding box of the geometry in object space
* @return true if the bounding box is outside clip space
*/
-bool Is2dBoxOutsideClipSpace(const Matrix& modelMatrix,
- const Matrix& modelViewProjectionMatrix,
+bool Is2dBoxOutsideClipSpace(const Matrix& modelViewProjectionMatrix,
const Rect<float>& boundingBox );
} // SceneGraph
} // Internal
#include <dali/internal/render/common/render-list.h>
#include <dali/internal/render/common/render-instruction.h>
#include <dali/internal/render/gl-resources/context.h>
-#include <dali/internal/render/renderers/scene-graph-renderer.h>
+#include <dali/internal/render/renderers/render-renderer.h>
using Dali::Internal::SceneGraph::RenderItem;
using Dali::Internal::SceneGraph::RenderList;
* @param[in] context The GL context.
* @param[in] defaultShader The default shader to use.
* @param[in] buffer The current render buffer index (previous update buffer)
- * @param[in] frameTime The elapsed time between the last two updates.
* @param[in] viewMatrix The view matrix from the appropriate camera.
* @param[in] projectionMatrix The projection matrix from the appropriate camera.
* @param[in] cullMode True if the renderers should be subjected to clipspace culling
SceneGraph::TextureCache& textureCache,
SceneGraph::Shader& defaultShader,
BufferIndex bufferIndex,
- float frameTime,
const Matrix& viewMatrix,
const Matrix& projectionMatrix,
bool cullMode )
DALI_PRINT_RENDER_ITEM( item );
//Enable depth writes if depth buffer is enabled and item is opaque
- context.DepthMask( depthBufferEnabled && item.IsOpaque() );
+ context.DepthMask( depthBufferEnabled && ( item.IsOpaque() || item.GetRenderer().RequiresDepthTest() ) );
- SceneGraph::Renderer* renderer = const_cast< SceneGraph::Renderer* >( item.GetRenderer() );
- renderer->Render( context, textureCache, bufferIndex, defaultShader, item.GetModelViewMatrix(), viewMatrix, projectionMatrix, frameTime, cullMode );
+ item.GetRenderer().Render( context, textureCache, bufferIndex, item.GetNode(), defaultShader, item.GetModelViewMatrix(), viewMatrix, projectionMatrix, cullMode, !item.IsOpaque() );
}
}
else
const RenderItem& item = renderList.GetItem( index );
DALI_PRINT_RENDER_ITEM( item );
- SceneGraph::Renderer* renderer = const_cast< SceneGraph::Renderer* >( item.GetRenderer() );
- renderer->Render( context, textureCache, bufferIndex, defaultShader, item.GetModelViewMatrix(), viewMatrix, projectionMatrix, frameTime, cullMode );
+ item.GetRenderer().Render( context, textureCache, bufferIndex, item.GetNode(), defaultShader, item.GetModelViewMatrix(), viewMatrix, projectionMatrix, cullMode, !item.IsOpaque() );
}
}
}
-/**
- * Render items from the currentIndex until the depth index changes.
- * Leaves currentIndex pointing at the
- *
- * @param[in] renderList The render-list to process.
- * @param[in] context The GL context.
- * @param[in] defaultShader The default shader to use.
- * @param[in] buffer The current render buffer index (previous update buffer)
- * @param[in] frameTime The elapsed time between the last two updates.
- * @param[in] viewMatrix The view matrix from the appropriate camera.
- * @param[in] projectionMatrix The projection matrix from the appropriate camera.
- * @param[in] cullMode True if the renderers should be subjected to clipspace culling
- * @param[in] depthIndex The current depth index
- * @param[inout] currentIndex On entry, the index in the render list of the first item at the given depth index. On exit, the index of the first item at the next depth index.
- */
-inline void RenderItemsAtDepthIndex(
- const RenderList& renderList,
- Context& context,
- SceneGraph::TextureCache& textureCache,
- SceneGraph::Shader& defaultShader,
- BufferIndex bufferIndex,
- float frameTime,
- const Matrix& viewMatrix,
- const Matrix& projectionMatrix,
- bool cullMode,
- int depthIndex,
- size_t& currentIndex ) // Out parameter
-{
- const size_t count = renderList.Count();
-
- // Don't initialise currentIndex. Ever.
- for( ; currentIndex < count ; currentIndex++ )
- {
- const RenderItem& renderItem = renderList.GetItem( currentIndex );
- DALI_PRINT_RENDER_ITEM( renderItem );
-
- if( renderItem.GetDepthIndex() == depthIndex )
- {
- SceneGraph::Renderer* renderer = const_cast< SceneGraph::Renderer* >( renderItem.GetRenderer() );
- const Matrix& modelViewMatrix = renderItem.GetModelViewMatrix();
- renderer->Render( context, textureCache, bufferIndex, defaultShader, modelViewMatrix, viewMatrix, projectionMatrix, frameTime, cullMode );
-
- }
- else
- {
- break; // Stop iterating when we reach a new depth index
- }
- }
-}
-
-
-
void ProcessRenderInstruction( const RenderInstruction& instruction,
Context& context,
SceneGraph::TextureCache& textureCache,
SceneGraph::Shader& defaultShader,
- BufferIndex bufferIndex,
- float frameTime )
+ BufferIndex bufferIndex )
{
DALI_PRINT_RENDER_INSTRUCTION( instruction, bufferIndex );
if( renderList &&
!renderList->IsEmpty() )
{
- ProcessRenderList( *renderList, context, textureCache, defaultShader, bufferIndex, frameTime, *viewMatrix, *projectionMatrix, instruction.mCullMode );
+ ProcessRenderList( *renderList, context, textureCache, defaultShader, bufferIndex, *viewMatrix, *projectionMatrix, instruction.mCullMode );
}
}
}
* @param[in] textureCache The texture cache used to get textures.
* @param[in] defaultShader The default shader.
* @param[in] buffer The current render buffer index (previous update buffer)
- * @param[in] frameTime The elapsed time between the last two updates.
*/
void ProcessRenderInstruction( const SceneGraph::RenderInstruction& instruction,
Context& context,
SceneGraph::TextureCache& textureCache,
SceneGraph::Shader& defaultShader,
- BufferIndex bufferIndex,
- float frameTime );
+ BufferIndex bufferIndex );
} // namespace Render
*/
// INTERNAL INCLUDES
+#include <dali/devel-api/common/owner-container.h>
#include <dali/internal/common/buffer-index.h>
-#include <dali/internal/common/owner-container.h>
namespace Dali
{
#include <dali/internal/render/common/render-item.h>
// INTERNAL INCLUDES
-#include <dali/internal/render/renderers/scene-graph-renderer.h>
+#include <dali/internal/render/renderers/render-renderer.h>
namespace Dali
{
RenderItem::RenderItem()
: mModelViewMatrix( false ),
mRenderer( NULL ),
+ mNode( NULL ),
mDepthIndex(0),
mIsOpaque(true)
{
mRenderer = NULL;
}
-void RenderItem::SetRenderer( Renderer* renderer )
+void RenderItem::SetRenderer( Render::Renderer* renderer )
{
mRenderer = renderer;
}
-const Renderer* RenderItem::GetRenderer() const
+void RenderItem::SetNode( Node* node )
{
- return mRenderer;
+ mNode = node;
+}
+
+Render::Renderer& RenderItem::GetRenderer() const
+{
+ return *mRenderer;
}
Matrix& RenderItem::GetModelViewMatrix()
#include <dali/public-api/common/vector-wrapper.h>
#include <dali/public-api/actors/layer.h>
#include <dali/public-api/math/matrix.h>
+#include <dali/internal/update/nodes/node.h>
namespace Dali
{
namespace Internal
{
+namespace Render
+{
+class Renderer;
+}
+
namespace SceneGraph
{
-class Renderer;
class RenderItem;
typedef std::vector< RenderItem > RendererItemContainer;
* Retrieve the renderer.
* @return The renderer.
*/
- const Renderer* GetRenderer() const;
+ Render::Renderer& GetRenderer() const;
/**
* Set the renderer
* @param[in] renderer The renderer
*/
- void SetRenderer( Renderer* renderer );
+ void SetRenderer( Render::Renderer* renderer );
/**
+ * Set the node
+ * @param[in] node The node
+ */
+ void SetNode( Node* node );
+
+ /**
+ * Retrieve the node
+ * @return The node
+ */
+ const Node& GetNode() const
+ {
+ return *mNode;
+ }
+ /**
* Retrieve the modelView matrix.
* @return The modelView matrix.
*/
RenderItem( const RenderItem& item );
RenderItem& operator = ( const RenderItem& item );
- Matrix mModelViewMatrix;
- Renderer* mRenderer;
- int mDepthIndex;
- bool mIsOpaque:1;
+ Matrix mModelViewMatrix;
+ Render::Renderer* mRenderer;
+ Node* mNode;
+ int mDepthIndex;
+ bool mIsOpaque:1;
};
} // namespace SceneGraph
// INTERNAL INCLUDES
#include <dali/public-api/math/rect.h>
+#include <dali/devel-api/common/owner-container.h>
#include <dali/internal/render/common/render-item.h>
-#include <dali/internal/common/owner-container.h>
namespace Dali
{
namespace Internal
{
+namespace Render
+{
+class Renderer;
+}
+
namespace SceneGraph
{
class Layer;
-class Renderer;
+
class RenderItem;
typedef OwnerContainer< RenderItem* > RenderItemContainer;
/**
* Get renderer from an item in the list
*/
- const Renderer* GetRenderer( RenderItemContainer::SizeType index ) const
+ const Render::Renderer& GetRenderer( RenderItemContainer::SizeType index ) const
{
DALI_ASSERT_DEBUG( index < GetCachedItemCount() );
return mItems[ index ]->GetRenderer();
#include <dali/internal/render/common/render-manager.h>
// INTERNAL INCLUDES
+#include <dali/public-api/actors/sampling.h>
#include <dali/public-api/common/dali-common.h>
#include <dali/public-api/common/stage.h>
#include <dali/public-api/render-tasks/render-task.h>
#include <dali/internal/render/gl-resources/frame-buffer-texture.h>
#include <dali/internal/render/gl-resources/native-frame-buffer-texture.h>
#include <dali/internal/render/gl-resources/texture-cache.h>
-#include <dali/internal/render/renderers/scene-graph-image-renderer.h>
-#include <dali/internal/render/renderers/scene-graph-renderer.h>
#include <dali/internal/render/renderers/render-geometry.h>
+#include <dali/internal/render/renderers/render-renderer.h>
+#include <dali/internal/render/renderers/render-sampler.h>
#include <dali/internal/render/shaders/program-controller.h>
// Uncomment the next line to enable frame snapshot logging
#ifdef FRAME_SNAPSHOT_LOGGING
-using namespace Dali::Internal::Render;
namespace // unnamed namespace
{
namespace SceneGraph
{
-typedef OwnerContainer< Renderer* > RendererOwnerContainer;
+typedef OwnerContainer< Render::Renderer* > RendererOwnerContainer;
typedef RendererOwnerContainer::Iterator RendererOwnerIter;
typedef OwnerContainer< RenderGeometry* > RenderGeometryOwnerContainer;
typedef RenderGeometryOwnerContainer::Iterator RenderGeometryOwnerIter;
+typedef OwnerContainer< Render::Sampler* > SamplerOwnerContainer;
+typedef SamplerOwnerContainer::Iterator SamplerOwnerIter;
+
+typedef OwnerContainer< Render::PropertyBuffer* > PropertyBufferOwnerContainer;
+typedef PropertyBufferOwnerContainer::Iterator PropertyBufferOwnerIter;
+
typedef OwnerContainer< RenderTracker* > RenderTrackerContainer;
typedef RenderTrackerContainer::Iterator RenderTrackerIter;
typedef RenderTrackerContainer::ConstIterator RenderTrackerConstIter;
resourcePostProcessQueue( resourcePostProcessQ ),
instructions(),
backgroundColor( Dali::Stage::DEFAULT_BACKGROUND_COLOR ),
- frameTime( 0.0f ),
- lastFrameTime( 0.0f ),
frameCount( 0 ),
renderBufferIndex( SceneGraphBuffers::INITIAL_UPDATE_BUFFER_INDEX ),
defaultSurfaceRect(),
rendererContainer(),
+ samplerContainer(),
renderersAdded( false ),
firstRenderCompleted( false ),
defaultShader( NULL ),
Vector4 backgroundColor; ///< The glClear color used at the beginning of each frame.
- volatile float frameTime; ///< The elapsed time since the previous frame
- float lastFrameTime; ///< Last frame delta.
-
unsigned int frameCount; ///< The current frame count
BufferIndex renderBufferIndex; ///< The index of the buffer to read from; this is opposite of the "update" buffer
Rect<int> defaultSurfaceRect; ///< Rectangle for the default surface we are rendering to
RendererOwnerContainer rendererContainer; ///< List of owned renderers
+ SamplerOwnerContainer samplerContainer; ///< List of owned samplers
+ PropertyBufferOwnerContainer propertyBufferContainer; ///< List of owned property buffers
RenderGeometryOwnerContainer renderGeometryContainer; ///< List of owned RenderGeometries
bool renderersAdded;
mImpl->backgroundColor = color;
}
-void RenderManager::SetFrameDeltaTime( float deltaTime )
-{
- Dali::Mutex::ScopedLock lock( mMutex );
- mImpl->frameTime = deltaTime;
-}
-
void RenderManager::SetDefaultSurfaceRect(const Rect<int>& rect)
{
mImpl->defaultSurfaceRect = rect;
}
-void RenderManager::AddRenderer( Renderer* renderer )
+void RenderManager::AddRenderer( Render::Renderer* renderer )
{
// Initialize the renderer as we are now in render thread
renderer->Initialize( mImpl->context, mImpl->textureCache );
}
}
-void RenderManager::RemoveRenderer( Renderer* renderer )
+void RenderManager::RemoveRenderer( Render::Renderer* renderer )
{
DALI_ASSERT_DEBUG( NULL != renderer );
}
}
-void RenderManager::AddImageRenderer( ImageRenderer* renderer, NodeDataProvider* dataProvider )
+void RenderManager::AddSampler( Render::Sampler* sampler )
{
- // Initialize the renderer as we are now in render thread
- renderer->Initialize( mImpl->context, mImpl->textureCache );
- renderer->SetDataProvider( dataProvider );
+ mImpl->samplerContainer.PushBack( sampler );
+}
- if( !mImpl->renderersAdded )
+void RenderManager::RemoveSampler( Render::Sampler* sampler )
+{
+ DALI_ASSERT_DEBUG( NULL != sampler );
+
+ SamplerOwnerContainer& samplers = mImpl->samplerContainer;
+
+ // Find the sampler
+ for ( SamplerOwnerIter iter = samplers.Begin(); iter != samplers.End(); ++iter )
{
- mImpl->renderersAdded = true;
+ if ( *iter == sampler )
+ {
+ samplers.Erase( iter ); // Sampler found; now destroy it
+ break;
+ }
}
+}
+
+void RenderManager::SetFilterMode( Render::Sampler* sampler, unsigned int minFilterMode, unsigned int magFilterMode )
+{
+ sampler->SetFilterMode( (Dali::FilterMode::Type)minFilterMode, (Dali::FilterMode::Type)magFilterMode );
+}
- // Note - ImageRenderers are not owned by RenderManager
+void RenderManager::SetWrapMode( Render::Sampler* sampler, unsigned int uWrapMode, unsigned int vWrapMode )
+{
+ sampler->SetWrapMode( (Dali::WrapMode::Type)uWrapMode, (Dali::WrapMode::Type)vWrapMode );
}
-void RenderManager::RemoveImageRenderer( ImageRenderer* renderer )
+void RenderManager::AddPropertyBuffer( Render::PropertyBuffer* propertyBuffer )
{
- DALI_ASSERT_DEBUG( NULL != renderer );
+ mImpl->propertyBufferContainer.PushBack( propertyBuffer );
+}
+
+void RenderManager::RemovePropertyBuffer( Render::PropertyBuffer* propertyBuffer )
+{
+ DALI_ASSERT_DEBUG( NULL != propertyBuffer );
- // GL cleanup
- renderer->OnRemove();
+ PropertyBufferOwnerContainer& propertyBuffers = mImpl->propertyBufferContainer;
- // Note - ImageRenderers are not owned by RenderManager
+ // Find the sampler
+ for ( PropertyBufferOwnerIter iter = propertyBuffers.Begin(); iter != propertyBuffers.End(); ++iter )
+ {
+ if ( *iter == propertyBuffer )
+ {
+ propertyBuffers.Erase( iter ); // Property buffer found; now destroy it
+ break;
+ }
+ }
+}
+
+void RenderManager::SetPropertyBufferFormat(Render::PropertyBuffer* propertyBuffer, Render::PropertyBuffer::Format* format )
+{
+ propertyBuffer->SetFormat( format );
+}
+
+void RenderManager::SetPropertyBufferData(Render::PropertyBuffer* propertyBuffer, Dali::Vector<char>* data)
+{
+ propertyBuffer->SetData( data );
+}
+
+void RenderManager::SetPropertyBufferSize(Render::PropertyBuffer* propertyBuffer, size_t size )
+{
+ propertyBuffer->SetSize( size );
}
void RenderManager::AddGeometry( RenderGeometry* renderGeometry )
RenderGeometryOwnerContainer& geometries = mImpl->renderGeometryContainer;
- // Find the renderer
+ // Find the geometry
for ( RenderGeometryOwnerIter iter = geometries.Begin(); iter != geometries.End(); ++iter )
{
if ( *iter == renderGeometry )
}
}
-void RenderManager::AddPropertyBuffer( RenderGeometry* renderGeometry, PropertyBufferDataProvider* propertyBuffer, const GpuBuffer::Target& target, const GpuBuffer::Usage& usage )
+void RenderManager::AddPropertyBuffer( RenderGeometry* renderGeometry, Render::PropertyBuffer* propertyBuffer, bool isIndexBuffer )
{
DALI_ASSERT_DEBUG( NULL != renderGeometry );
{
if ( *iter == renderGeometry )
{
- (*iter)->AddPropertyBuffer( propertyBuffer, target, usage );
+ (*iter)->AddPropertyBuffer( propertyBuffer, isIndexBuffer );
break;
}
}
}
-void RenderManager::RemovePropertyBuffer( RenderGeometry* renderGeometry, PropertyBufferDataProvider* propertyBuffer )
+void RenderManager::RemovePropertyBuffer( RenderGeometry* renderGeometry, Render::PropertyBuffer* propertyBuffer )
{
DALI_ASSERT_DEBUG( NULL != renderGeometry );
}
}
+void RenderManager::SetGeometryType( RenderGeometry* geometry, int type )
+{
+ geometry->SetGeometryType( static_cast<Geometry::GeometryType>(type) );
+}
+
+void RenderManager::SetGeometryRequiresDepthTest( RenderGeometry* geometry, bool requiresDepthTest )
+{
+ geometry->SetRequiresDepthTest( requiresDepthTest );
+}
void RenderManager::AddRenderTracker( RenderTracker* renderTracker )
{
// reset the program matrices for all programs once per frame
// this ensures we will set view and projection matrix once per program per camera
- // @todo move programs out of context onto a program controller and let that handle this
mImpl->programController.ResetProgramMatrices();
// if we don't have default shader, no point doing the render calls
{
RenderInstruction& instruction = mImpl->instructions.At( mImpl->renderBufferIndex, i );
- DoRender( instruction, *mImpl->defaultShader, mImpl->lastFrameTime );
+ DoRender( instruction, *mImpl->defaultShader );
const RenderListContainer::SizeType countRenderList = instruction.RenderListCount();
if ( countRenderList > 0 )
PERF_MONITOR_END(PerformanceMonitor::DRAW_NODES);
- SetLastFrameTime();
-
// check if anything has been posted to the update thread
bool updateRequired = !mImpl->resourcePostProcessQueue[ mImpl->renderBufferIndex ].empty();
return updateRequired;
}
-void RenderManager::SetLastFrameTime()
-{
- Dali::Mutex::ScopedLock lock(mMutex);
- mImpl->lastFrameTime = mImpl->frameTime;
-}
-
-void RenderManager::DoRender( RenderInstruction& instruction, Shader& defaultShader, float elapsedTime )
+void RenderManager::DoRender( RenderInstruction& instruction, Shader& defaultShader )
{
Rect<int> viewportRect;
Vector4 clearColor;
mImpl->context,
mImpl->textureCache,
defaultShader,
- mImpl->renderBufferIndex,
- elapsedTime );
+ mImpl->renderBufferIndex );
if(instruction.mOffscreenTextureId != 0)
{
*/
// INTERNAL INCLUDES
-#include <dali/devel-api/common/mutex.h>
#include <dali/public-api/math/rect.h>
#include <dali/internal/common/shader-saver.h>
#include <dali/internal/render/common/post-process-resource-dispatcher.h>
#include <dali/internal/update/resources/resource-manager-declarations.h>
#include <dali/internal/render/gl-resources/gpu-buffer.h>
+#include <dali/internal/render/renderers/render-property-buffer.h>
namespace Dali
{
class ProgramCache;
class ShaderSaver;
-namespace SceneGraph
+namespace Render
{
class Renderer;
-class ImageRenderer;
-class NodeDataProvider;
+class Sampler;
+}
+
+namespace SceneGraph
+{
class RenderQueue;
class TextureCache;
class RenderInstruction;
* @param[in] renderer The renderer to add.
* @post renderer is owned by RenderManager
*/
- void AddRenderer( Renderer* renderer );
+ void AddRenderer( Render::Renderer* renderer );
/**
* Remove a Renderer from the render manager.
* @param[in] renderer The renderer to remove.
* @post renderer is destroyed.
*/
- void RemoveRenderer( Renderer* renderer );
+ void RemoveRenderer( Render::Renderer* renderer );
/**
- * Add an image renderer in the render-thread.
- * ImageRenderers are not owned by render-manager; this is just for initialization.
- * @param[in] renderer The renderer to add.
- * @param[in] dataProvider The Node using this image renderer.
+ * Add a sampler to the render manager.
+ * @param[in] sampler The sampler to add.
+ * @post sampler is owned by RenderManager
*/
- void AddImageRenderer( ImageRenderer* renderer, NodeDataProvider* dataProvider );
+ void AddSampler( Render::Sampler* sampler );
/**
- * Remove an image renderer in the render-thread.
- * ImageRenderers are not owned by render-manager; this is just for GL cleanup.
- * @param[in] renderer The renderer to remove.
+ * Remove a sampler from the render manager.
+ * @param[in] sampler The sampler to remove.
+ * @post sampler is destroyed.
+ */
+ void RemoveSampler( Render::Sampler* sampler );
+
+ /**
+ * Set minification and magnification filter modes for a sampler
+ * @param[in] minFilterMode Filter mode to use when the texture is minificated
+ * @param[in] magFilterMode Filter mode to use when the texture is magnified
+ */
+ void SetFilterMode( Render::Sampler* sampler, unsigned int minFilterMode, unsigned int magFilterMode );
+
+ /**
+ * Set wrapping mode for a sampler
+ * @param[in] uWrapMode Wrap mode in the x direction
+ * @param[in] vWrapMode Wrap mode in the y direction
+ */
+ void SetWrapMode( Render::Sampler* sampler, unsigned int uWrapMode, unsigned int vWrapMode );
+
+ /**
+ * Add a property buffer to the render manager.
+ * @param[in] propertyBuffer The property buffer to add.
+ * @post propertBuffer is owned by RenderManager
+ */
+ void AddPropertyBuffer( Render::PropertyBuffer* propertyBuffer );
+
+ /**
+ * Remove a property buffer from the render manager.
+ * @param[in] propertyBuffer The property buffer to remove.
+ * @post propertyBuffer is destroyed.
*/
- void RemoveImageRenderer( ImageRenderer* renderer );
+ void RemovePropertyBuffer( Render::PropertyBuffer* propertyBuffer );
/**
* Add a geometry to the render manager.
* Adds a property buffer to a RenderGeometry from the render manager.
* @param[in] geometry The geometry
* @param[in] propertyBuffer The property buffer to remove.
- * @param[in] target Specifies the type of the buffer
- * @param[in] usage Specifies how will the buffer be used
+ * @param[in] isIndexBuffer True if the property buffer is intended to be used as an index buffer
*/
- void AddPropertyBuffer( RenderGeometry* renderGeometry, PropertyBufferDataProvider* propertyBuffer, const GpuBuffer::Target& target, const GpuBuffer::Usage& usage );
+ void AddPropertyBuffer( RenderGeometry* renderGeometry, Render::PropertyBuffer* propertyBuffer, bool isIndexBuffer );
/**
* Remove a property buffer from a RenderGeometry from the render manager.
* @param[in] propertyBuffer The property buffer to remove.
* @post property buffer is destroyed.
*/
- void RemovePropertyBuffer( RenderGeometry* renderGeometry, PropertyBufferDataProvider* propertyBuffer );
+ void RemovePropertyBuffer( RenderGeometry* renderGeometry, Render::PropertyBuffer* propertyBuffer );
+
+ /**
+ * Sets the format of an existing property buffer
+ * @param[in] propertyBuffer The property buffer.
+ * @param[in] format The new format of the buffer
+ */
+ void SetPropertyBufferFormat(Render::PropertyBuffer* propertyBuffer, Render::PropertyBuffer::Format* format );
+
+ /**
+ * Sets the data of an existing property buffer
+ * @param[in] propertyBuffer The property buffer.
+ * @param[in] data The new data of the buffer
+ */
+ void SetPropertyBufferData(Render::PropertyBuffer* propertyBuffer, Dali::Vector<char>* data);
+
+ /**
+ * Sets the size of an existing property buffer
+ * @param[in] propertyBuffer The property buffer.
+ * @param[in] size The new size of the buffer
+ */
+ void SetPropertyBufferSize(Render::PropertyBuffer* propertyBuffer, size_t size );
+
+ /**
+ * Set the geometry type of an existing render geometry
+ * @param[in] geometry The render geometry
+ * @param[in] geometryType The new geometry type
+ */
+ void SetGeometryType( RenderGeometry* geometry, int geometryType );
+
+ /**
+ * Set if an existing geometry requires depth testing
+ * @param[in] geometry The render geometry
+ * @param[in] requiresDepthTest True if depth testing is required, false otherwise
+ */
+ void SetGeometryRequiresDepthTest( RenderGeometry* geometry, bool requiresDepthTest );
/**
* Adds a render tracker to the RenderManager. RenderManager takes ownership of the
* Helper to process a single RenderInstruction.
* @param[in] instruction A description of the rendering operation.
* @param[in] defaultShader default shader to use.
- * @param[in] elapsedTime from previous render.
*/
- void DoRender( RenderInstruction& instruction, Shader& defaultShader, float elapsedTime );
+ void DoRender( RenderInstruction& instruction, Shader& defaultShader );
private:
// Undefined
RenderManager& operator=( const RenderManager& rhs );
- // Set the last frame time while locking access
- void SetLastFrameTime();
-
private:
struct Impl;
Impl* mImpl;
- Dali::Mutex mMutex;
};
+++ /dev/null
-#ifndef __DALI_INTERNAL_SCENE_GRAPH_GEOMETRY_DATA_PROVIDER_H__
-#define __DALI_INTERNAL_SCENE_GRAPH_GEOMETRY_DATA_PROVIDER_H__
-/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include <dali/devel-api/rendering/geometry.h>
-#include <dali/internal/common/buffer-index.h>
-#include <dali/internal/common/owner-container.h>
-#include <dali/internal/render/data-providers/property-buffer-data-provider.h>
-
-namespace Dali
-{
-namespace Internal
-{
-namespace SceneGraph
-{
-class PropertyBuffer;
-
-/**
- * An interface to provide geometry properties to the render thread.
- */
-class GeometryDataProvider
-{
-public:
- typedef Dali::Geometry::GeometryType GeometryType;
-
- /**
- * Constructor. Nothing to do as a pure interface.
- */
- GeometryDataProvider() { }
-
-public: // GeometryDataProvider
- /**
- * Get the type of geometry to draw
- */
- virtual GeometryType GetGeometryType( BufferIndex bufferIndex ) const = 0;
-
- /**
- * @todo MESH_REWORK - Should only use this in Update Sorting algorithm
- * Returns true if this geometry requires depth testing, e.g. if it is
- * a set of vertices with differing z values.
- */
- virtual bool GetRequiresDepthTesting( BufferIndex bufferIndex ) const = 0;
-
-protected:
-
- /**
- * Virtual destructor, this is an interface, no deletion through this interface
- */
- virtual ~GeometryDataProvider() { }
-};
-
-} // SceneGraph
-} // Internal
-} // Dali
-
-#endif // __DALI_INTERNAL_SCENE_GRAPH_GEOMETRY_DATA_PROVIDER_H__
* limitations under the License.
*/
+#include <dali/internal/common/buffer-index.h>
#include <dali/public-api/common/dali-vector.h>
#include <dali/public-api/actors/blending.h>
*
*/
+#include <dali/internal/render/data-providers/uniform-map-data-provider.h>
+
namespace Dali
{
struct Vector4;
/**
* An interface to provide data for a Renderer
*/
-class NodeDataProvider
+class NodeDataProvider : UniformMapDataProvider
{
public:
* @param bufferId to use
* @return a reference to the model matrix
*/
- virtual const Matrix& GetModelMatrix( unsigned int bufferId ) = 0;
+ virtual const Matrix& GetModelMatrix( unsigned int bufferId ) const = 0;
/**
* @param bufferId to use
* @return a reference to the color
*/
- virtual const Vector4& GetRenderColor( unsigned int bufferId ) = 0;
+ virtual const Vector4& GetRenderColor( unsigned int bufferId ) const = 0;
/**
* @param[in] bufferIndex The buffer index to use
* @return the actor size
*/
- virtual const Vector3& GetRenderSize( unsigned int bufferIndex ) = 0;
+ virtual const Vector3& GetRenderSize( unsigned int bufferIndex ) const = 0;
+
+ /**
+ * @copydoc Dali::Internal::SceneGraph::UniformMapDataProvider::GetUniformMapChanged()
+ */
+ virtual bool GetUniformMapChanged( BufferIndex bufferIndex ) const = 0;
+
+ /**
+ * @copydoc Dali::Internal::SceneGraph::UniformMapDataProvider::GetUniformMap()
+ */
+ virtual const CollectedUniformMap& GetUniformMap( BufferIndex bufferIndex ) const = 0;
protected:
/**
RenderDataProvider::RenderDataProvider()
: mMaterialDataProvider( NULL ),
mUniformMapDataProvider( NULL ),
- mShader( NULL ),
- mUseBlend( false )
+ mShader( NULL )
{
}
return *mShader;
}
-void RenderDataProvider::SetSamplers( const RenderDataProvider::Samplers& samplers )
+const RenderDataProvider::Textures& RenderDataProvider::GetTextures() const
{
- mSamplers = samplers;
-}
-
-const RenderDataProvider::Samplers& RenderDataProvider::GetSamplers() const
-{
- return mSamplers;
-}
-
-void RenderDataProvider::SetUseBlend( bool useBlend )
-{
- mUseBlend = useBlend;
-}
-
-bool RenderDataProvider::GetUseBlend( BufferIndex bufferIndex ) const
-{
- return mUseBlend;
+ return mTextures;
}
} // SceneGraph
*
*/
-#include <dali/internal/render/data-providers/geometry-data-provider.h>
#include <dali/internal/render/data-providers/material-data-provider.h>
#include <dali/internal/render/data-providers/node-data-provider.h>
-#include <dali/internal/render/data-providers/sampler-data-provider.h>
#include <dali/internal/render/data-providers/property-buffer-data-provider.h>
#include <dali/internal/render/data-providers/uniform-map-data-provider.h>
-
+#include <dali/internal/render/renderers/render-texture.h>
namespace Dali
{
namespace Internal
{
public:
typedef Dali::Vector< const PropertyBufferDataProvider* > VertexBuffers;
- typedef Dali::Vector< const SamplerDataProvider* > Samplers;
+ typedef std::vector< Render::Texture > Textures;
/**
* Constructor.
Shader& GetShader() const;
/**
- * Set the sampler data providers
- * @param[in] samplers The sampler data providers
- */
- void SetSamplers( const Samplers& samplers );
-
- /**
- * Returns the list of sampler data providers
- * @return The list of samplers
- */
- const Samplers& GetSamplers() const;
-
- /**
- * Set the use blend flag to decide if the renderer will perform blending
- * @param[in] useBlend The flag to decide if the renderer will perform blending
- */
- void SetUseBlend( bool useBlend );
-
- /**
- * Get the use blend flag that decides if the renderer will perform blending
- * @param[in] buffer index
- * @return The use blend flag that decides if the renderer will perform blending
+ * Returns the list of textures
+ * @return The list of textures
*/
- bool GetUseBlend( BufferIndex bufferIndex ) const;
+ const Textures& GetTextures() const;
private:
const MaterialDataProvider* mMaterialDataProvider;
const UniformMapDataProvider* mUniformMapDataProvider;
Shader* mShader;
- Samplers mSamplers;
- bool mUseBlend;
+ Textures mTextures;
-// Give RendererAttachment access to our private data to reduce copying vectors on construction.
- friend class RendererAttachment;
+// Give Renderer access to our private data to reduce copying vectors on construction.
+ friend class Renderer;
};
} // SceneGraph
+++ /dev/null
-#ifndef DALI_INTERNAL_SCENE_GRAPH_SAMPLER_DATA_PROVIDER_H
-#define DALI_INTERNAL_SCENE_GRAPH_SAMPLER_DATA_PROVIDER_H
-
-/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <dali/devel-api/rendering/sampler.h>
-#include <dali/integration-api/resource-declarations.h>
-#include <dali/internal/common/buffer-index.h>
-
-namespace Dali
-{
-namespace Internal
-{
-namespace SceneGraph
-{
-
-class SamplerDataProvider
-{
-public:
- typedef Dali::Sampler::FilterMode FilterMode;
- typedef Dali::Sampler::WrapMode WrapMode;
- typedef Dali::Integration::ResourceId ResourceId;
-
- /**
- * Constructor
- */
- SamplerDataProvider()
- {
- }
-
- /**
- * Get the sampler's texture unit uniform name
- * @return The texture unit uniform name
- */
- virtual const std::string& GetTextureUnitUniformName() const = 0;
-
- /**
- * Get the texture identity associated with the sampler
- * @return The texture identity
- */
- virtual ResourceId GetTextureId( BufferIndex bufferIndex ) const = 0;
-
- /**
- * Get the filter mode
- * @param[in] bufferIndex The buffer index to use
- * @return The minify filter mode
- */
- virtual FilterMode GetMinifyFilterMode( BufferIndex bufferIndex ) const = 0;
-
- /**
- * Get the filter mode
- * @param[in] bufferIndex The buffer index to use
- * @return The magnify filter mode
- */
- virtual FilterMode GetMagnifyFilterMode( BufferIndex bufferIndex ) const = 0;
-
- /**
- * Get the horizontal wrap mode
- * @param[in] bufferIndex The buffer index to use
- * @return The horizontal wrap mode
- */
- virtual WrapMode GetUWrapMode( BufferIndex bufferIndex ) const = 0;
-
- /**
- * Get the vertical wrap mode
- * @param[in] bufferIndex The buffer index to use
- * @return The vertical wrap mode
- */
- virtual WrapMode GetVWrapMode( BufferIndex bufferIndex ) const = 0;
-
-protected:
- /**
- * No deletion through this interface
- */
- virtual ~SamplerDataProvider()
- {
- }
-};
-
-} // namespace SceneGraph
-} // namespace Internal
-} // namespace Dali
-
-#endif // DALI_INTERNAL_SCENE_GRAPH_SAMPLER_DATA_PROVIDER_H
updateArea.x, updateArea.y, updateArea.width ,updateArea.height );
const unsigned int pitchPixels = mWidth;
- const unsigned int pixelDepth = GetBytesPerPixel( mPixelFormat );
+ const unsigned int pixelDepth = Dali::Pixel::GetBytesPerPixel( mPixelFormat );
// If the width of the source update area is the same as the pitch, then can
// copy the contents in a single contiguous TexSubImage call.
mContext.TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
mContext.TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+ // If the resource policy is to discard on upload then release buffer
+ DiscardBitmapBuffer();
+
if( pixels != NULL )
{
INCREASE_BY( PerformanceMonitor::TEXTURE_DATA_UPLOADED, GetBytesPerPixel(mPixelFormat) * mWidth * mHeight );
if( ResourcePolicy::OWNED_DISCARD == mDiscardPolicy )
{
DALI_LOG_INFO(Debug::Filter::gImage, Debug::General, " Discarding bitmap\n");
- mBitmap->DiscardBuffer();
+ if ( mBitmap )
+ {
+ mBitmap->DiscardBuffer();
+ }
}
}
void DiscardBitmapBuffer();
private:
- Integration::BitmapPtr mBitmap; ///< The Bitmap the Texture was created from (may be NULL)
- bool mClearPixels; ///< true if initial texture should be cleared on creation
- ResourcePolicy::Discardable mDiscardPolicy; ///< The bitmap discard policy
- Pixel::Format mPixelFormat;
+ Integration::BitmapPtr mBitmap; ///< The Bitmap the Texture was created from (may be NULL)
+ bool mClearPixels:1; ///< true if initial texture should be cleared on creation
+ ResourcePolicy::Discardable mDiscardPolicy:2; ///< The bitmap discard policy
+ Pixel::Format mPixelFormat:5; ///< Pack pixel format into bitfield
// Changes scope, should be at end of class
DALI_LOG_OBJECT_STRING_DECLARATION;
if ( mId ) // If the texture is already bound
{
AssignBitmap( false, pixels, mBitmap->GetBufferSize() );
-
- if( mDiscardPolicy == ResourcePolicy::OWNED_DISCARD )
- {
- mBitmap->DiscardBuffer();
- }
}
}
}
}
-GpuBuffer::GpuBuffer( Context& context, Target target, Usage usage )
+GpuBuffer::GpuBuffer( Context& context )
: mContext( context ),
mCapacity( 0 ),
mSize( 0 ),
mBufferId( 0 ),
- mTarget( target ),
- mUsage( usage ),
mBufferCreated( false )
{
}
* Creates or updates the buffer data depending on whether it
* already exists or not.
*/
-void GpuBuffer::UpdateDataBuffer(GLsizeiptr size,const GLvoid *data)
+void GpuBuffer::UpdateDataBuffer(GLsizeiptr size,const GLvoid *data, Usage usage)
{
DALI_ASSERT_DEBUG( size > 0 );
mSize = size;
}
// make sure the buffer is bound, don't perform any checks because size may be zero
- BindNoChecks(mBufferId);
+ mContext.BindArrayBuffer( mBufferId );
// if the buffer has already been created, just update the data providing it fits
if (mBufferCreated )
// if the data will fit in the existing buffer, just update it
if (size <= mCapacity )
{
- mContext.BufferSubData( TypeAsGlEnum(mTarget), 0, size, data );
+ mContext.BufferSubData( GL_ARRAY_BUFFER, 0, size, data );
}
else
{
// create a new buffer of the larger size,
// gl should automatically deallocate the old buffer
- mContext.BufferData( TypeAsGlEnum(mTarget), size, data, ModeAsGlEnum( mUsage ) );
+ mContext.BufferData( GL_ARRAY_BUFFER, size, data, ModeAsGlEnum( usage ) );
mCapacity = size;
}
}
else
{
// create the buffer
- mContext.BufferData( TypeAsGlEnum(mTarget), size, data, ModeAsGlEnum( mUsage ) );
+ mContext.BufferData( GL_ARRAY_BUFFER, size, data, ModeAsGlEnum( usage ) );
mBufferCreated = true;
mCapacity = size;
}
- switch (mTarget)
- {
- case ARRAY_BUFFER:
- {
- mContext.BindArrayBuffer(0);
- break;
- }
- case ELEMENT_ARRAY_BUFFER:
- {
- mContext.BindElementArrayBuffer(0);
- break;
- }
- case TRANSFORM_FEEDBACK_BUFFER:
- {
- mContext.BindTransformFeedbackBuffer(0);
- break;
- }
- }
+ mContext.BindArrayBuffer(0);
}
-void GpuBuffer::Bind() const
+void GpuBuffer::Bind(Target target) const
{
DALI_ASSERT_DEBUG(mCapacity);
- BindNoChecks(mBufferId);
+ if (target == ARRAY_BUFFER)
+ {
+ mContext.BindArrayBuffer(mBufferId);
+ }
+ else
+ {
+ mContext.BindElementArrayBuffer(mBufferId);
+ }
}
bool GpuBuffer::BufferIsValid() const
mBufferCreated = false;
}
-void GpuBuffer::BindNoChecks(GLuint bufferId) const
-{
- // context currently only supports two targets, element and array
- // and it caches both of them (as in it won't bind them if the
- // buffer id is already bound).
-
- if (mTarget == ARRAY_BUFFER)
- {
- mContext.BindArrayBuffer(bufferId);
- }
- else
- {
- mContext.BindElementArrayBuffer(bufferId);
- }
-}
-
-
} // namespace Internal
} //namespace Dali
/**
* constructor
* @param context drawing context
- * @param target the type of buffer to create @see Type
- * @param usage how the buffer will be used @see DrawMode
*/
- GpuBuffer( Context& context, Target target, Usage usage );
+ GpuBuffer( Context& context );
/**
* Destructor, non virtual as no virtual methods or inheritance
* Creates or updates a buffer object and binds it to the target.
* @param size Specifies the size in bytes of the buffer object's new data store.
* @param data pointer to the data to load
+ * @param usage How the buffer will be used
*/
- void UpdateDataBuffer(GLsizeiptr size, const GLvoid *data);
+ void UpdateDataBuffer(GLsizeiptr size, const GLvoid *data, Usage usage);
/**
* Bind the buffer object to the target
* Will assert if the buffer size is zero
*/
- void Bind() const;
+ void Bind(Target target) const;
/**
* @return true if the GPU buffer is valid, i.e. its created and not empty
return mSize;
}
- void SetStride( GLuint stride )
- {
- mStride = stride;
- }
-
- GLuint GetStride()
- {
- return mStride;
- }
-
/**
* Needs to be called when GL context is destroyed
*/
GLsizeiptr mCapacity; ///< buffer capacity
GLsizeiptr mSize; ///< buffer size
GLuint mBufferId; ///< buffer object name(id)
- GLuint mStride; ///< stride of data in buffer object
- Target mTarget:2; ///< type of buffer (array/element), 2 bits are enough
- Usage mUsage:2; ///< how the buffer is used (read, read/write etc), 2 bits are enough
bool mBufferCreated:1; ///< whether buffer has been created
};
// These match the GL specification
const GLint SYSTEM_MINIFY_DEFAULT = GL_NEAREST_MIPMAP_LINEAR;
const GLint SYSTEM_MAGNIFY_DEFAULT = GL_LINEAR;
+const GLint SYSTEM_WRAP_DEFAULT = GL_CLAMP_TO_EDGE;
// These are the Dali defaults
const GLint DALI_MINIFY_DEFAULT = GL_LINEAR;
return GL_LINEAR;
}
+GLint WrapModeToGL( WrapMode::Type wrapMode, GLint defaultWrapMode )
+{
+ switch( wrapMode )
+ {
+ case WrapMode::DEFAULT:
+ {
+ return defaultWrapMode;
+ }
+ case WrapMode::CLAMP_TO_EDGE:
+ {
+ return GL_CLAMP_TO_EDGE;
+ }
+ case WrapMode::REPEAT:
+ {
+ return GL_REPEAT;
+ }
+ case WrapMode::MIRRORED_REPEAT:
+ {
+ return GL_MIRRORED_REPEAT;
+ }
+ }
+
+ return defaultWrapMode;
+}
+
using Dali::Internal::Vertex2D;
using Dali::Internal::Vertex3D;
}
-void Texture::ApplyTextureParameter( TextureUnit unit, GLint filterType, FilterMode::Type currentFilterMode, FilterMode::Type newFilterMode, GLint daliDefault, GLint systemDefault )
+void Texture::ApplyFilterModeParameter( TextureUnit unit, GLint filterType, FilterMode::Type currentFilterMode, FilterMode::Type newFilterMode, GLint daliDefault, GLint systemDefault )
{
GLint newFilterModeGL = FilterModeToGL( newFilterMode, daliDefault, systemDefault );
GLint currentFilterModeGL = FilterModeToGL( currentFilterMode, daliDefault, systemDefault );
}
}
+void Texture::ApplyWrapModeParameter( TextureUnit unit, GLint wrapType, WrapMode::Type currentWrapMode, WrapMode::Type newWrapMode )
+{
+ GLint newWrapModeGL = WrapModeToGL( newWrapMode, SYSTEM_WRAP_DEFAULT );
+ GLint currentWrapModeGL = WrapModeToGL( currentWrapMode, SYSTEM_WRAP_DEFAULT );
+
+ if( newWrapModeGL != currentWrapModeGL )
+ {
+ mContext.ActiveTexture( unit );
+ mContext.TexParameteri( GL_TEXTURE_2D, wrapType, newWrapModeGL );
+ }
+}
+
void Texture::ApplySampler( TextureUnit unit, unsigned int samplerBitfield )
{
if( mSamplerBitfield != samplerBitfield && mId != 0 )
{
- ApplyTextureParameter( unit,
+ ApplyFilterModeParameter( unit,
GL_TEXTURE_MIN_FILTER,
ImageSampler::GetMinifyFilterMode( mSamplerBitfield ),
ImageSampler::GetMinifyFilterMode( samplerBitfield ),
DALI_MINIFY_DEFAULT,
SYSTEM_MINIFY_DEFAULT );
- ApplyTextureParameter( unit,
- GL_TEXTURE_MAG_FILTER,
- ImageSampler::GetMagnifyFilterMode( mSamplerBitfield ),
- ImageSampler::GetMagnifyFilterMode( samplerBitfield ),
- DALI_MAGNIFY_DEFAULT,
- SYSTEM_MAGNIFY_DEFAULT );
+ ApplyFilterModeParameter( unit,
+ GL_TEXTURE_MAG_FILTER,
+ ImageSampler::GetMagnifyFilterMode( mSamplerBitfield ),
+ ImageSampler::GetMagnifyFilterMode( samplerBitfield ),
+ DALI_MAGNIFY_DEFAULT,
+ SYSTEM_MAGNIFY_DEFAULT );
+
+ ApplyWrapModeParameter( unit,
+ GL_TEXTURE_WRAP_S,
+ ImageSampler::GetUWrapMode( mSamplerBitfield ),
+ ImageSampler::GetUWrapMode( samplerBitfield ));
+
+ ApplyWrapModeParameter( unit,
+ GL_TEXTURE_WRAP_T,
+ ImageSampler::GetVWrapMode( mSamplerBitfield ),
+ ImageSampler::GetVWrapMode( samplerBitfield ));
+
+
mSamplerBitfield = samplerBitfield;
}
// INTERNAL INCLUDES
#include <dali/public-api/object/ref-object.h>
#include <dali/integration-api/bitmap.h>
+#include <dali/integration-api/image-integ.h>
#include <dali/internal/render/common/uv-rect.h>
#include <dali/integration-api/gl-abstraction.h>
#include <dali/internal/render/gl-resources/gl-resource-owner.h>
void GetDefaultTextureCoordinates(UvRect& uv) const;
/**
- * @brief Apply the given texture parameters.
+ * @brief Apply the given texture filtering parameters.
*
* @param[in] texture unit to use
* @param[in] filterType Minification or magnification.
* @param[in] daliDefault The default dali filter mode for the given filterType.
* @param[in] systemDefault The default system filter mode for the given filterType.
*/
- void ApplyTextureParameter( TextureUnit unit, GLint filterType, FilterMode::Type currentFilterMode, FilterMode::Type newFilterMode, GLint daliDefault, GLint systemDefault );
+ void ApplyFilterModeParameter( TextureUnit unit, GLint filterType, FilterMode::Type currentFilterMode, FilterMode::Type newFilterMode, GLint daliDefault, GLint systemDefault );
+
+ /**
+ * @brief Apply the given texture wrap mode.
+ *
+ * @param[in] texture unit to use
+ * @param[in] wrapType UWrap or VWrap
+ * @param[in] currentWrapMode The current wrap mode.
+ * @param[in] newWrapMode The new wrap mode.
+ */
+ void ApplyWrapModeParameter( TextureUnit unit, GLint wrapType, WrapMode::Type currentWrapMode, WrapMode::Type newWrapMode );
protected:
: container0( NULL ),
container1( NULL )
{
- Dali::Mutex::ScopedLock lock(mMutex);
container0 = new MessageBuffer( INITIAL_BUFFER_SIZE );
container1 = new MessageBuffer( INITIAL_BUFFER_SIZE );
}
RenderQueue::~RenderQueue()
{
- Dali::Mutex::ScopedLock lock(mMutex);
if( container0 )
{
for( MessageBuffer::Iterator iter = container0->Begin(); iter.IsValid(); iter.Next() )
unsigned int* RenderQueue::ReserveMessageSlot( BufferIndex updateBufferIndex, std::size_t size )
{
- Dali::Mutex::ScopedLock lock(mMutex);
MessageBuffer* container = GetCurrentContainer( updateBufferIndex );
return container->ReserveMessageSlot( size );
void RenderQueue::ProcessMessages( BufferIndex bufferIndex )
{
- Dali::Mutex::ScopedLock lock(mMutex);
MessageBuffer* container = GetCurrentContainer( bufferIndex );
for( MessageBuffer::Iterator iter = container->Begin(); iter.IsValid(); iter.Next() )
*/
// INTERNAL INCLUDES
-#include <dali/devel-api/common/mutex.h>
#include <dali/internal/common/buffer-index.h>
#include <dali/internal/common/message-buffer.h>
private:
- Dali::Mutex mMutex; ///< Mutex to ensure access locking
MessageBuffer* container0; ///< Messages are queued here when the update buffer index == 0
MessageBuffer* container1; ///< Messages are queued here when the update buffer index == 1
};
*/
#include <dali/internal/render/renderers/render-geometry.h>
-
#include <dali/internal/common/buffer-index.h>
-#include <dali/internal/update/common/scene-graph-property-buffer.h>
-#include <dali/internal/update/rendering/scene-graph-geometry.h>
-#include <dali/internal/render/data-providers/render-data-provider.h>
#include <dali/internal/render/gl-resources/context.h>
#include <dali/internal/render/gl-resources/gpu-buffer.h>
+#include <dali/internal/render/renderers/render-property-buffer.h>
#include <dali/internal/render/shaders/program.h>
namespace Dali
namespace SceneGraph
{
-RenderGeometry::RenderGeometry( const GeometryDataProvider& geometryDataProvider )
-: mGeometryDataProvider( geometryDataProvider ),
+RenderGeometry::RenderGeometry( GeometryType type, bool requiresDepthTest )
+: mIndexBuffer(0),
+ mGeometryType( type ),
+ mRequiresDepthTest(requiresDepthTest ),
mHasBeenUpdated(false),
mAttributesChanged(true)
{
{
}
-void RenderGeometry::AddPropertyBuffer( const PropertyBufferDataProvider* dataProvider, GpuBuffer::Target gpuBufferTarget, GpuBuffer::Usage gpuBufferUsage )
+void RenderGeometry::AddPropertyBuffer( Render::PropertyBuffer* propertyBuffer, bool isIndexBuffer )
{
- if( gpuBufferTarget == GpuBuffer::ELEMENT_ARRAY_BUFFER )
+ if( isIndexBuffer )
{
- RenderPropertyBuffer* renderPropertyBuffer = new RenderPropertyBuffer( *dataProvider, gpuBufferTarget, gpuBufferUsage );
- mIndexBuffer = renderPropertyBuffer;
+ mIndexBuffer = propertyBuffer;
}
- else if( gpuBufferTarget == GpuBuffer::ARRAY_BUFFER )
+ else
{
- RenderPropertyBuffer* renderPropertyBuffer = new RenderPropertyBuffer( *dataProvider, gpuBufferTarget, gpuBufferUsage );
- mVertexBuffers.PushBack( renderPropertyBuffer );
+ mVertexBuffers.PushBack( propertyBuffer );
mAttributesChanged = true;
}
}
-void RenderGeometry::RemovePropertyBuffer( const PropertyBufferDataProvider* dataProvider )
+void RenderGeometry::RemovePropertyBuffer( const Render::PropertyBuffer* propertyBuffer )
{
- if( dataProvider == &mIndexBuffer->GetDataProvider() )
+ if( propertyBuffer == mIndexBuffer )
{
- mIndexBuffer.Reset();
+ mIndexBuffer = 0;
}
else
{
- for( RenderPropertyBufferIter iter( mVertexBuffers.Begin() ); iter != mVertexBuffers.End(); ++iter )
+ size_t bufferCount = mVertexBuffers.Size();
+ for( size_t i(0); i<bufferCount; ++i )
{
- if( dataProvider == &(*iter)->GetDataProvider() )
+ if( propertyBuffer == mVertexBuffers[i] )
{
//This will delete the gpu buffer associated to the RenderPropertyBuffer if there is one
- mVertexBuffers.Remove( iter );
+ mVertexBuffers.Remove( mVertexBuffers.Begin()+i);
mAttributesChanged = true;
break;
}
for( size_t i(0); i< mVertexBuffers.Size(); ++i )
{
- unsigned int attributeCount = mVertexBuffers[i]->GetDataProvider().GetAttributeCount( bufferIndex );
+ unsigned int attributeCount = mVertexBuffers[i]->GetAttributeCount();
for( unsigned int j = 0; j < attributeCount; ++j )
{
- const std::string& attributeName = mVertexBuffers[i]->GetDataProvider().GetAttributeName( bufferIndex, j );
+ const std::string& attributeName = mVertexBuffers[i]->GetAttributeName( j );
unsigned int index = program.RegisterCustomAttribute( attributeName );
GLint location = program.GetCustomAttributeLocation( index );
//Update buffers
if( mIndexBuffer )
{
- mIndexBuffer->Update( context, bufferIndex );
+ if(!mIndexBuffer->Update( context, true ) )
+ {
+ //Index buffer is not ready ( Size, data or format has not been specified yet )
+ return;
+ }
}
for( unsigned int i = 0; i < mVertexBuffers.Count(); ++i )
{
- mVertexBuffers[i]->Update( context, bufferIndex );
+ if( !mVertexBuffers[i]->Update( context, false ) )
+ {
+ //Vertex buffer is not ready ( Size, data or format has not been specified yet )
+ return;
+ }
}
mHasBeenUpdated = true;
}
unsigned int base = 0;
for( unsigned int i = 0; i < mVertexBuffers.Count(); ++i )
{
- mVertexBuffers[i]->BindBuffer( context );
- base += mVertexBuffers[i]->EnableVertexAttributes( context, bufferIndex, attributeLocation, base );
+ mVertexBuffers[i]->BindBuffer( GpuBuffer::ARRAY_BUFFER );
+ base += mVertexBuffers[i]->EnableVertexAttributes( context, attributeLocation, base );
}
if( mIndexBuffer )
{
- mIndexBuffer->BindBuffer( context );
+ mIndexBuffer->BindBuffer( GpuBuffer::ELEMENT_ARRAY_BUFFER );
}
//Bind index buffer
unsigned int numIndices(0u);
if( mIndexBuffer )
{
- const PropertyBufferDataProvider& indexBuffer = mIndexBuffer->GetDataProvider();
- numIndices = mIndexBuffer->GetDataProvider().GetDataSize(bufferIndex) / indexBuffer.GetElementSize(bufferIndex);
+ numIndices = mIndexBuffer->GetDataSize() / mIndexBuffer->GetElementSize();
}
//Draw call
- GeometryDataProvider::GeometryType type = mGeometryDataProvider.GetGeometryType( bufferIndex );
- switch(type)
+ switch(mGeometryType)
{
case Dali::Geometry::TRIANGLES:
{
}
else
{
- const PropertyBufferDataProvider& firstVertexBuffer = mVertexBuffers[0]->GetDataProvider();
- unsigned int numVertices = firstVertexBuffer.GetElementCount( bufferIndex );
+ unsigned int numVertices = mVertexBuffers[0]->GetElementCount();
context.DrawArrays( GL_TRIANGLES, 0, numVertices );
}
break;
}
else
{
- const PropertyBufferDataProvider& firstVertexBuffer = mVertexBuffers[0]->GetDataProvider();
- unsigned int numVertices = firstVertexBuffer.GetElementCount( bufferIndex );
+ unsigned int numVertices = mVertexBuffers[0]->GetElementCount();
context.DrawArrays( GL_LINES, 0, numVertices );
}
break;
}
case Dali::Geometry::POINTS:
{
- const PropertyBufferDataProvider& firstVertexBuffer = mVertexBuffers[0]->GetDataProvider();
- unsigned int numVertices = firstVertexBuffer.GetElementCount( bufferIndex );
+ unsigned int numVertices = mVertexBuffers[0]->GetElementCount();
context.DrawArrays(GL_POINTS, 0, numVertices );
break;
}
+ case Dali::Geometry::TRIANGLE_STRIP:
+ {
+ if( numIndices )
+ {
+ context.DrawElements(GL_TRIANGLE_STRIP, numIndices, GL_UNSIGNED_SHORT, 0);
+ }
+ else
+ {
+ unsigned int numVertices = mVertexBuffers[0]->GetElementCount();
+ context.DrawArrays(GL_TRIANGLE_STRIP, 0, numVertices );
+ }
+ break;
+ }
+ case Dali::Geometry::TRIANGLE_FAN:
+ {
+ if( numIndices )
+ {
+ context.DrawElements(GL_TRIANGLE_FAN, numIndices, GL_UNSIGNED_SHORT, 0);
+ }
+ else
+ {
+ unsigned int numVertices = mVertexBuffers[0]->GetElementCount();
+ context.DrawArrays(GL_TRIANGLE_FAN, 0, numVertices );
+ }
+ break;
+ }
default:
{
DALI_ASSERT_ALWAYS( 0 && "Geometry type not supported (yet)" );
*/
#include <dali/public-api/common/dali-vector.h>
+#include <dali/devel-api/common/owner-container.h>
#include <dali/integration-api/gl-defines.h>
#include <dali/internal/common/buffer-index.h>
-#include <dali/internal/common/owner-container.h>
#include <dali/internal/common/owner-pointer.h>
-#include <dali/internal/render/data-providers/render-data-provider.h>
-#include <dali/internal/render/renderers/render-renderer-property-buffer.h>
+#include <dali/integration-api/gl-abstraction.h>
+#include <dali/internal/update/rendering/scene-graph-geometry.h>
namespace Dali
{
class Program;
class GpuBuffer;
-namespace SceneGraph
+namespace Render
{
-class RenderDataProvider;
-class GeometryDataProvider;
-
-typedef OwnerPointer< RenderPropertyBuffer > RenderPropertyBufferPtr;
-typedef OwnerContainer< RenderPropertyBuffer* > RenderPropertyBufferContainer;
-typedef RenderPropertyBufferContainer::Iterator RenderPropertyBufferIter;
+class PropertyBuffer;
+}
+namespace SceneGraph
+{
/**
* This class encapsulates the GPU buffers. It is used to upload vertex data
{
public:
+ typedef SceneGraph::Geometry::GeometryType GeometryType;
/**
* Constructor. Creates a render geometry object with no GPU buffers.
+ * @param[in] center The center of the geometry
+ * @param[in] geometryType The geometry type
+ * @param[in] requiresDepthTest True if geometry requires depth testing, false otherwise
*/
- RenderGeometry( const GeometryDataProvider& geometryDataProvider );
-
+ RenderGeometry( GeometryType geometryType, bool requiresDepthTest );
/**
* Destructor
*/
/**
* Adds a property buffer to the geometry
* @param[in] dataProvider The PropertyBuffer data provider
- * @param[in] gpuBufferTarget target Specifies the type of the buffer
- * @param[in] gpuBufferUsage usage Specifies how will the buffer be used
+ * @param[in] isIndexBuffer True if the property buffer is intended to be used as an index buffer
*/
- void AddPropertyBuffer( const PropertyBufferDataProvider* dataProvider, GpuBuffer::Target gpuBufferTarget, GpuBuffer::Usage gpuBufferUsage );
+ void AddPropertyBuffer( Render::PropertyBuffer* propertyBuffer, bool isIndexBuffer );
/**
* Removes a PropertyBuffer from the geometry
- * @param[in] dataProvider The property buffer to be removed
+ * @param[in] propertyBuffer The property buffer to be removed
*/
- void RemovePropertyBuffer( const PropertyBufferDataProvider* dataProvider );
+ void RemovePropertyBuffer( const Render::PropertyBuffer* propertyBuffer );
/**
* Gets the attribute locations on the shader for the attributes defined in the geometry RenderBuffers
}
/**
+ * Sets the geometry type
+ * @param[in] type The new geometry type
+ */
+ void SetGeometryType( GeometryType type )
+ {
+ mGeometryType = type;
+ }
+
+ /**
+ * Sets if the geometry requires depth testing
+ * @param[in] requiresDepthTest True if depth testing is required, false otherwise
+ */
+ void SetRequiresDepthTest( bool requiresDepthTest )
+ {
+ mRequiresDepthTest = requiresDepthTest;
+ }
+
+ /**
+ * Check if geometry requires depth testing
+ * @return True if depth testing is required, false otherwise
+ */
+ bool RequiresDepthTest() const
+ {
+ return mRequiresDepthTest;
+ }
+
+ /**
* Upload the geometry if it has changed, set up the attributes and perform
* the Draw call corresponding to the geometry type
* @param[in] context The GL context
private:
- const GeometryDataProvider& mGeometryDataProvider; //Reference to update thread object
-
// PropertyBuffers
- RenderPropertyBufferPtr mIndexBuffer;
- RenderPropertyBufferContainer mVertexBuffers;
+ Render::PropertyBuffer* mIndexBuffer;
+ Vector<Render::PropertyBuffer*> mVertexBuffers;
+
+ GeometryType mGeometryType;
// Booleans
+ bool mRequiresDepthTest : 1;
bool mHasBeenUpdated : 1;
bool mAttributesChanged : 1;
+
};
} // namespace SceneGraph
*/
// CLASS HEADER
-#include <dali/internal/render/renderers/scene-graph-image-renderer.h>
+#include <dali/internal/render/renderers/render-image-renderer.h>
// EXTERNAL INCLUDES
#include <dali/public-api/common/dali-common.h>
#include <dali/internal/render/gl-resources/texture.h>
#include <dali/internal/render/gl-resources/texture-cache.h>
#include <dali/internal/render/gl-resources/texture-units.h>
-#include <dali/internal/render/renderers/scene-graph-renderer-debug.h>
#include <dali/internal/render/shaders/program.h>
#include <dali/internal/render/shaders/scene-graph-shader.h>
#include <dali/internal/update/controllers/scene-controller.h>
+
namespace
{
#if defined(DEBUG_ENABLED)
namespace Internal
{
-namespace SceneGraph
+namespace Render
{
-ImageRenderer* ImageRenderer::New( NodeDataProvider& dataProvider )
+ImageRenderer* ImageRenderer::New()
{
- return new ImageRenderer( dataProvider );
+ return new ImageRenderer();
}
ImageRenderer::~ImageRenderer()
{
- // Note - GL cleanup is done from render-thread in OnRemove()
-}
-
-void ImageRenderer::OnRemove()
-{
if ( mTextureId > 0 )
{
- mTextureCacheDELETEME->RemoveObserver(mTextureId, this);
+ mTextureCache->RemoveObserver(mTextureId, this);
}
GlCleanup();
-
- // Set back to defaults
- mDataProvider = NULL;
- mShader = NULL;
- mTexture = NULL;
- mBorder = Vector4( 0.45, 0.45, 0.1, 0.1 );
- mPixelArea = PixelArea();
- mGeometrySize = Vector2();
- mTextureId = 0;
- mBlendingOptions.SetBlendFunc( DEFAULT_BLENDING_SRC_FACTOR_RGB, DEFAULT_BLENDING_DEST_FACTOR_RGB, DEFAULT_BLENDING_SRC_FACTOR_ALPHA, DEFAULT_BLENDING_DEST_FACTOR_ALPHA );
- mBlendingOptions.SetBlendEquation( DEFAULT_BLENDING_EQUATION_RGB, DEFAULT_BLENDING_EQUATION_ALPHA );
- mBlendingOptions.SetBlendColor( Vector4::ZERO );
- mMeshType = ImageRenderer::QUAD;
- mIsMeshGenerated = false;
- mBorderInPixels = false;
- mUseBlend = false;
- mUsePixelArea = false;
}
void ImageRenderer::SetTextureId( ResourceId textureId )
{
if ( mTextureId > 0 )
{
- mTextureCacheDELETEME->RemoveObserver(mTextureId, this);
+ mTextureCache->RemoveObserver(mTextureId, this);
}
mTextureId = textureId;
if ( textureId > 0 )
{
- mTextureCacheDELETEME->AddObserver(textureId, this);
+ mTextureCache->AddObserver(textureId, this);
}
}
bool ImageRenderer::CheckResources()
{
- if( mDataProvider == NULL )
- {
- return false;
- }
-
if( mTexture == NULL )
{
- if ( mTextureCacheDELETEME )
+ if ( mTextureCache )
{
- mTexture = mTextureCacheDELETEME->GetTexture( mTextureId );
+ mTexture = mTextureCache->GetTexture( mTextureId );
}
}
Integration::ResourceId shaderTextureId = mShader->GetTextureIdToRender() ;
- if( shaderTextureId && mTextureCacheDELETEME->GetTexture( shaderTextureId ) == NULL )
+ if( shaderTextureId && mTextureCache->GetTexture( shaderTextureId ) == NULL )
{
return false;
}
return true;
}
-bool ImageRenderer::IsOutsideClipSpace( Context& context, const Matrix& modelMatrix, const Matrix& modelViewProjectionMatrix )
+bool ImageRenderer::IsOutsideClipSpace( Context& context, const Matrix& modelViewProjectionMatrix )
{
context.IncrementRendererCount();
Rect<float> boundingBox( mGeometrySize.x * -0.5f, mGeometrySize.y * -0.5f, mGeometrySize.x, mGeometrySize.y );
- DEBUG_BOUNDING_BOX( *mContext, boundingBox, modelViewProjectionMatrix );
-
- if(Is2dBoxOutsideClipSpace( modelMatrix, modelViewProjectionMatrix, boundingBox ) )
+ if(SceneGraph::Is2dBoxOutsideClipSpace( modelViewProjectionMatrix, boundingBox ) )
{
context.IncrementCulledCount();
return true;
return false;
}
-void ImageRenderer::DoRender( Context& context, TextureCache& textureCache, BufferIndex bufferIndex, Program& program, const Matrix& modelViewMatrix, const Matrix& viewMatrix )
+void ImageRenderer::DoRender( Context& context, SceneGraph::TextureCache& textureCache, const SceneGraph::NodeDataProvider& node, BufferIndex bufferIndex, Program& program, const Matrix& modelViewMatrix, const Matrix& viewMatrix )
{
DALI_LOG_INFO( gImageRenderFilter, Debug::Verbose, "DoRender() textureId=%d texture:%p\n", mTextureId, mTexture);
DALI_ASSERT_DEBUG( mVertexBuffer );
- mTextureCacheDELETEME->BindTexture( mTexture, mTextureId, GL_TEXTURE_2D, TEXTURE_UNIT_IMAGE );
+ mTextureCache->BindTexture( mTexture, mTextureId, GL_TEXTURE_2D, TEXTURE_UNIT_IMAGE );
if( mTexture->GetTextureId() == 0 )
{
// make sure the vertex is bound, this has to be done before
// we call VertexAttribPointer otherwise you get weird output on the display
- mVertexBuffer->Bind();
+ mVertexBuffer->Bind(GpuBuffer::ARRAY_BUFFER);
samplerLoc = program.GetUniformLocation( Program::UNIFORM_SAMPLER_RECT );
if( -1 != samplerLoc )
case GRID_NINE_PATCH_NO_CENTER:
{
const GLsizei indexCount = mIndexBuffer->GetBufferSize() / sizeof(GLushort); // compiler will optimize this to >> if possible
- mIndexBuffer->Bind();
+ mIndexBuffer->Bind(GpuBuffer::ELEMENT_ARRAY_BUFFER);
context.DrawElements( GL_TRIANGLES, indexCount, GL_UNSIGNED_SHORT, 0 );
break;
}
}
}
-void ImageRenderer::DoSetBlending(Context& context, BufferIndex bufferIndex )
+void ImageRenderer::DoSetBlending(Context& context, BufferIndex bufferIndex, bool blend )
{
// Enables/disables blending mode.
- context.SetBlend( mUseBlend );
+ context.SetBlend( blend );
// Set the blend color
const Vector4* const customColor = mBlendingOptions.GetBlendColor();
// create/destroy if needed/not needed.
if ( size && !mVertexBuffer )
{
- mVertexBuffer = new GpuBuffer( context, GpuBuffer::ARRAY_BUFFER, GpuBuffer::DYNAMIC_DRAW );
+ mVertexBuffer = new GpuBuffer( context );
}
else if ( !size && mVertexBuffer )
{
// update
if ( mVertexBuffer )
{
- mVertexBuffer->UpdateDataBuffer( size, data );
+ mVertexBuffer->UpdateDataBuffer( size, data, GpuBuffer::DYNAMIC_DRAW);
}
}
// create/destroy if needed/not needed.
if ( size && !mIndexBuffer )
{
- mIndexBuffer = new GpuBuffer( context, GpuBuffer::ELEMENT_ARRAY_BUFFER, GpuBuffer::STATIC_DRAW );
+ mIndexBuffer = new GpuBuffer( context );
}
else if ( !size && mIndexBuffer )
{
// update
if ( mIndexBuffer )
{
- mIndexBuffer->UpdateDataBuffer(size,data);
+ mIndexBuffer->UpdateDataBuffer(size,data,GpuBuffer::STATIC_DRAW);
}
}
texture->MapUV( sizeof(verts)/sizeof(Vertex2D), verts, pixelArea );
- UpdateVertexBuffer( *mContextDELETEME, sizeof(verts), verts );
- UpdateIndexBuffer( *mContextDELETEME, 0, NULL );
+ UpdateVertexBuffer( *mContext, sizeof(verts), verts );
+ UpdateIndexBuffer( *mContext, 0, NULL );
}
void ImageRenderer::SetNinePatchMeshData( Texture* texture, const Vector2& size, const Vector4& border, bool borderInPixels, const PixelArea* pixelArea, bool noCenter )
const size_t vertsSize = sizeof( vertsWithCenter );
const unsigned int vertexCount = vertsSize / sizeof( vertsWithCenter[0] );
texture->MapUV( vertexCount, vertsWithCenter, pixelArea );
- UpdateVertexBuffer( *mContextDELETEME, vertsSize, vertsWithCenter );
+ UpdateVertexBuffer( *mContext, vertsSize, vertsWithCenter );
}
else
{
const size_t vertsSize = sizeof( vertsWithNoCenter );
const unsigned int vertexCount = vertsSize / sizeof( vertsWithNoCenter[0] );
texture->MapUV( vertexCount, vertsWithNoCenter, pixelArea );
- UpdateVertexBuffer( *mContextDELETEME, vertsSize, vertsWithNoCenter );
+ UpdateVertexBuffer( *mContext, vertsSize, vertsWithNoCenter );
}
// not using an index buffer
- UpdateIndexBuffer( *mContextDELETEME, 0, NULL );
+ UpdateIndexBuffer( *mContext, 0, NULL );
}
texture->MapUV( totalVertices, vertices, pixelArea );
- UpdateVertexBuffer( *mContextDELETEME, totalVertices * sizeof(Vertex2D) , vertices );
- UpdateIndexBuffer( *mContextDELETEME, totalIndices * sizeof(GLushort), indices );
+ UpdateVertexBuffer( *mContext, totalVertices * sizeof(Vertex2D) , vertices );
+ UpdateIndexBuffer( *mContext, totalIndices * sizeof(GLushort), indices );
delete[] vertices;
delete[] indices;
}
}
-ImageRenderer::ImageRenderer( NodeDataProvider& dataProvider )
-: Renderer( dataProvider ),
+ImageRenderer::ImageRenderer()
+: Renderer(),
mTexture( NULL ),
mBorder( 0.45, 0.45, 0.1, 0.1 ),
mPixelArea(),
-#ifndef __DALI_INTERNAL_SCENE_GRAPH_IMAGE_RENDERER_H__
-#define __DALI_INTERNAL_SCENE_GRAPH_IMAGE_RENDERER_H__
+#ifndef __DALI_INTERNAL_RENDER_IMAGE_RENDERER_H__
+#define __DALI_INTERNAL_RENDER_IMAGE_RENDERER_H__
/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <dali/internal/update/resources/resource-manager-declarations.h>
#include <dali/internal/render/gl-resources/context.h>
#include <dali/internal/render/gl-resources/texture-observer.h>
-#include <dali/internal/render/renderers/scene-graph-renderer.h>
+#include <dali/internal/render/renderers/render-renderer.h>
namespace Dali
{
namespace SceneGraph
{
class NodeDataProvider;
+class TextureCache;
+}
+namespace Render
+{
/**
* Used to render an image.
*/
/**
* Create a new ImageRenderer.
- * @param dataprovider to render
* @return The newly allocated ImageRenderer.
*/
- static ImageRenderer* New( NodeDataProvider& dataprovider );
+ static ImageRenderer* New();
/**
* Virtual destructor
virtual ~ImageRenderer();
/**
- * Called in the render-thread when the renderer is removed
- */
- void OnRemove();
-
- /**
* Set the texture used to render.
* @param[in] textureId The id of the texture used to render.
*/
/**
* @copydoc Dali::Internal::SceneGraph::Renderer::IsOutsideClipSpace()
*/
- virtual bool IsOutsideClipSpace( Context& context, const Matrix& modelMatrix, const Matrix& modelViewProjectionMatrix );
+ virtual bool IsOutsideClipSpace( Context& context, const Matrix& modelViewProjectionMatrix );
/**
* @copydoc Dali::Internal::SceneGraph::Renderer::DoRender()
*/
- virtual void DoRender( Context& context, TextureCache& textureCache, BufferIndex bufferIndex, Program& program, const Matrix& modelViewMatrix, const Matrix& viewMatrix );
+ virtual void DoRender( Context& context, SceneGraph::TextureCache& textureCache, const SceneGraph::NodeDataProvider& node, BufferIndex bufferIndex, Program& program, const Matrix& modelViewMatrix, const Matrix& viewMatrix );
/**
* @copydoc Dali::Internal::SceneGraph::Renderer::DoSetBlending()
*/
- virtual void DoSetBlending( Context& context, BufferIndex bufferIndex );
+ virtual void DoSetBlending( Context& context, BufferIndex bufferIndex, bool blend );
protected: // TextureObserver implementation
/**
* Private constructor. @see New()
*/
- ImageRenderer( NodeDataProvider& dataprovider );
+ ImageRenderer();
// Undefined
ImageRenderer( const ImageRenderer& );
} // namespace Dali
-#endif // __DALI_INTERNAL_SCENE_GRAPH_IMAGE_RENDERER_H__
+#endif // __DALI_INTERNAL_RENDER_IMAGE_RENDERER_H__
--- /dev/null
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "render-new-renderer.h"
+#include <dali/devel-api/common/hash.h>
+#include <dali/internal/common/image-sampler.h>
+#include <dali/internal/event/common/property-input-impl.h>
+#include <dali/internal/update/common/uniform-map.h>
+#include <dali/internal/render/data-providers/render-data-provider.h>
+#include <dali/internal/render/gl-resources/context.h>
+#include <dali/internal/render/gl-resources/texture.h>
+#include <dali/internal/render/gl-resources/texture-cache.h>
+#include <dali/internal/render/renderers/render-sampler.h>
+#include <dali/internal/render/shaders/program.h>
+
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Render
+{
+
+NewRenderer* NewRenderer::New( SceneGraph::RenderDataProvider* dataProvider,
+ SceneGraph::RenderGeometry* renderGeometry )
+{
+ return new NewRenderer( dataProvider, renderGeometry);
+}
+
+
+NewRenderer::NewRenderer( SceneGraph::RenderDataProvider* dataProvider,
+ SceneGraph::RenderGeometry* renderGeometry )
+: Renderer(),
+ mRenderDataProvider( dataProvider ),
+ mRenderGeometry( renderGeometry ),
+ mUpdateAttributesLocation( true )
+{
+}
+
+NewRenderer::~NewRenderer()
+{
+}
+
+void NewRenderer::SetRenderDataProvider( SceneGraph::RenderDataProvider* dataProvider )
+{
+ mRenderDataProvider = dataProvider;
+ mUpdateAttributesLocation = true;
+}
+
+void NewRenderer::SetGeometry( SceneGraph::RenderGeometry* renderGeometry )
+{
+ mRenderGeometry = renderGeometry;
+ mUpdateAttributesLocation = true;
+}
+
+// Note - this is currently called from UpdateThread, PrepareRenderInstructions,
+// as an optimisation.
+// @todo MESH_REWORK Should use Update thread objects only in PrepareRenderInstructions.
+bool NewRenderer::RequiresDepthTest() const
+{
+ if( mRenderGeometry )
+ {
+ return mRenderGeometry->RequiresDepthTest();
+ }
+
+ return true;
+}
+
+bool NewRenderer::CheckResources()
+{
+ // Query material to check it has texture pointers & image has size
+ // Query geometry to check it has vertex buffers
+
+ // General point though - why would we have a render item in RenderThread with no ready
+ // resources in UpdateThread?
+ return true;
+}
+
+bool NewRenderer::IsOutsideClipSpace( Context& context, const Matrix& modelViewProjectionMatrix )
+{
+ // @todo MESH_REWORK Add clipping
+ return false;
+}
+
+void NewRenderer::DoSetUniforms( Context& context, BufferIndex bufferIndex, SceneGraph::Shader* shader, Program* program, unsigned int programIndex )
+{
+ // Do nothing, we're going to set up the uniforms with our own code instead
+}
+
+void NewRenderer::DoSetCullFaceMode( Context& context, BufferIndex bufferIndex )
+{
+}
+
+void NewRenderer::DoSetBlending( Context& context, BufferIndex bufferIndex, bool blend )
+{
+ context.SetBlend( blend );
+ if( blend )
+ {
+ const SceneGraph::MaterialDataProvider& material = mRenderDataProvider->GetMaterial();
+
+ context.SetCustomBlendColor( material.GetBlendColor( bufferIndex ) );
+
+ // Set blend source & destination factors
+ context.BlendFuncSeparate( material.GetBlendSrcFactorRgb( bufferIndex ),
+ material.GetBlendDestFactorRgb( bufferIndex ),
+ material.GetBlendSrcFactorAlpha( bufferIndex ),
+ material.GetBlendDestFactorAlpha( bufferIndex ) );
+
+ // Set blend equations
+ context.BlendEquationSeparate( material.GetBlendEquationRgb( bufferIndex ),
+ material.GetBlendEquationAlpha( bufferIndex ) );
+ }
+}
+
+void NewRenderer::DoRender( Context& context, SceneGraph::TextureCache& textureCache, const SceneGraph::NodeDataProvider& node, BufferIndex bufferIndex, Program& program, const Matrix& modelViewMatrix, const Matrix& viewMatrix )
+{
+ BindTextures( textureCache, program );
+
+ SetUniforms( bufferIndex, node, program );
+
+ if( mUpdateAttributesLocation || mRenderGeometry->AttributesChanged() )
+ {
+ mRenderGeometry->GetAttributeLocationFromProgram( mAttributesLocation, program, bufferIndex );
+ mUpdateAttributesLocation = false;
+ }
+
+ mRenderGeometry->UploadAndDraw( context, bufferIndex, mAttributesLocation );
+}
+
+void NewRenderer::GlContextDestroyed()
+{
+ mRenderGeometry->GlContextDestroyed();
+}
+
+void NewRenderer::GlCleanup()
+{
+}
+
+void NewRenderer::SetUniforms( BufferIndex bufferIndex, const SceneGraph::NodeDataProvider& node, Program& program )
+{
+ // Check if the map has changed
+ DALI_ASSERT_DEBUG( mRenderDataProvider && "No Uniform map data provider available" );
+
+ const SceneGraph::UniformMapDataProvider& uniformMapDataProvider = mRenderDataProvider->GetUniformMap();
+
+ if( uniformMapDataProvider.GetUniformMapChanged( bufferIndex ) ||
+ node.GetUniformMapChanged(bufferIndex))
+ {
+ const SceneGraph::CollectedUniformMap& uniformMap = uniformMapDataProvider.GetUniformMap( bufferIndex );
+ const SceneGraph::CollectedUniformMap& uniformMapNode = node.GetUniformMap( bufferIndex );
+
+ unsigned int maxMaps = uniformMap.Count() + uniformMapNode.Count();
+ mUniformIndexMap.Clear(); // Clear contents, but keep memory if we don't change size
+ mTextureIndexMap.Clear();
+ mUniformIndexMap.Resize( maxMaps );
+
+ unsigned int mapIndex(0);
+ for(; mapIndex < uniformMap.Count() ; ++mapIndex )
+ {
+ mUniformIndexMap[mapIndex].propertyValue = uniformMap[mapIndex]->propertyPtr;
+ mUniformIndexMap[mapIndex].uniformIndex = program.RegisterUniform( uniformMap[mapIndex]->uniformName );
+ }
+
+ for( unsigned int nodeMapIndex = 0; nodeMapIndex < uniformMapNode.Count() ; ++nodeMapIndex )
+ {
+ unsigned int uniformIndex = program.RegisterUniform( uniformMapNode[nodeMapIndex]->uniformName );
+ bool found(false);
+ for( unsigned int i(0); i<uniformMap.Count(); ++i )
+ {
+ if( mUniformIndexMap[i].uniformIndex == uniformIndex )
+ {
+ mUniformIndexMap[i].propertyValue = uniformMapNode[nodeMapIndex]->propertyPtr;
+ found = true;
+ break;
+ }
+ }
+
+ if( !found )
+ {
+ mUniformIndexMap[mapIndex].propertyValue = uniformMapNode[nodeMapIndex]->propertyPtr;
+ mUniformIndexMap[mapIndex].uniformIndex = uniformIndex;
+ ++mapIndex;
+ }
+ }
+
+ mUniformIndexMap.Resize( mapIndex );
+ }
+
+ // Set uniforms in local map
+ for( UniformIndexMappings::Iterator iter = mUniformIndexMap.Begin(),
+ end = mUniformIndexMap.End() ;
+ iter != end ;
+ ++iter )
+ {
+ SetUniformFromProperty( bufferIndex, program, *iter );
+ }
+
+ // @todo MESH_REWORK On merge, copy code from renderer to setup standard matrices and color
+
+ GLint sizeLoc = program.GetUniformLocation( Program::UNIFORM_SIZE );
+ if( -1 != sizeLoc )
+ {
+ Vector3 size = node.GetRenderSize( bufferIndex );
+ program.SetSizeUniform3f( sizeLoc, size.x, size.y, size.z );
+ }
+}
+
+void NewRenderer::SetUniformFromProperty( BufferIndex bufferIndex, Program& program, UniformIndexMap& map )
+{
+ GLint location = program.GetUniformLocation(map.uniformIndex);
+ if( Program::UNIFORM_UNKNOWN != location )
+ {
+ // switch based on property type to use correct GL uniform setter
+ switch ( map.propertyValue->GetType() )
+ {
+ case Property::INTEGER:
+ {
+ program.SetUniform1i( location, map.propertyValue->GetInteger( bufferIndex ) );
+ break;
+ }
+ case Property::FLOAT:
+ {
+ program.SetUniform1f( location, map.propertyValue->GetFloat( bufferIndex ) );
+ break;
+ }
+ case Property::VECTOR2:
+ {
+ Vector2 value( map.propertyValue->GetVector2( bufferIndex ) );
+ program.SetUniform2f( location, value.x, value.y );
+ break;
+ }
+
+ case Property::VECTOR3:
+ {
+ Vector3 value( map.propertyValue->GetVector3( bufferIndex ) );
+ program.SetUniform3f( location, value.x, value.y, value.z );
+ break;
+ }
+
+ case Property::VECTOR4:
+ {
+ Vector4 value( map.propertyValue->GetVector4( bufferIndex ) );
+ program.SetUniform4f( location, value.x, value.y, value.z, value.w );
+ break;
+ }
+
+ case Property::ROTATION:
+ {
+ Quaternion value( map.propertyValue->GetQuaternion( bufferIndex ) );
+ program.SetUniform4f( location, value.mVector.x, value.mVector.y, value.mVector.z, value.mVector.w );
+ break;
+ }
+
+ case Property::MATRIX:
+ {
+ const Matrix& value = map.propertyValue->GetMatrix(bufferIndex);
+ program.SetUniformMatrix4fv(location, 1, value.AsFloat() );
+ break;
+ }
+
+ case Property::MATRIX3:
+ {
+ const Matrix3& value = map.propertyValue->GetMatrix3(bufferIndex);
+ program.SetUniformMatrix3fv(location, 1, value.AsFloat() );
+ break;
+ }
+
+ default:
+ {
+ // Other property types are ignored
+ break;
+ }
+ }
+ }
+}
+
+void NewRenderer::BindTextures(
+ SceneGraph::TextureCache& textureCache,
+ Program& program )
+{
+ int textureUnit = 0;
+
+ const std::vector<Render::Texture>& textures( mRenderDataProvider->GetTextures());
+ for( size_t i(0); i<textures.size(); ++i )
+ {
+ ResourceId textureId = textures[i].GetTextureId();
+ Internal::Texture* texture = textureCache.GetTexture( textureId );
+ if( texture )
+ {
+ textureCache.BindTexture( texture, textureId, GL_TEXTURE_2D, (TextureUnit)textureUnit );
+
+ // Set sampler uniform location for the texture
+ unsigned int uniformIndex = GetTextureUniformIndex( program, textures[i].GetUniformName() );
+ GLint uniformLocation = program.GetUniformLocation( uniformIndex );
+ if( Program::UNIFORM_UNKNOWN != uniformLocation )
+ {
+ program.SetUniform1i( uniformLocation, textureUnit );
+ }
+
+ unsigned int samplerBitfield(0);
+ const Render::Sampler* sampler( textures[i].GetSampler() );
+ if( sampler )
+ {
+ samplerBitfield = ImageSampler::PackBitfield(
+ static_cast< FilterMode::Type >(sampler->GetMinifyFilterMode()),
+ static_cast< FilterMode::Type >(sampler->GetMagnifyFilterMode()),
+ static_cast< WrapMode::Type >(sampler->GetUWrapMode()),
+ static_cast< WrapMode::Type >(sampler->GetVWrapMode())
+ );
+ }
+ else
+ {
+ samplerBitfield = ImageSampler::DEFAULT_BITFIELD;
+ }
+
+ texture->ApplySampler( (TextureUnit)textureUnit, samplerBitfield );
+
+ ++textureUnit;
+ }
+ }
+}
+
+unsigned int NewRenderer::GetTextureUniformIndex( Program& program, const std::string& uniformName )
+{
+ unsigned int uniformIndex = 0;
+ bool found = false;
+
+ size_t uniformNameHash = Dali::CalculateHash( uniformName );
+ for( unsigned int i=0; i< mTextureIndexMap.Count(); ++i )
+ {
+ if( mTextureIndexMap[i].uniformNameHash == uniformNameHash )
+ {
+ uniformIndex = mTextureIndexMap[i].uniformIndex;
+ found = true;
+ }
+ }
+
+ if( ! found )
+ {
+ uniformIndex = program.RegisterUniform( uniformName );
+ TextureUniformIndexMap textureUniformIndexMap = {uniformNameHash,uniformIndex};
+ mTextureIndexMap.PushBack( textureUniformIndexMap );
+ }
+
+ return uniformIndex;
+}
+
+} // SceneGraph
+} // Internal
+} // Dali
--- /dev/null
+#ifndef __DALI_INTERNAL_RENDER_NEW_RENDERER_H__
+#define __DALI_INTERNAL_RENDER_NEW_RENDERER_H__
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <dali/integration-api/resource-declarations.h> // For resource id
+#include <dali/internal/common/owner-pointer.h>
+#include <dali/internal/render/data-providers/render-data-provider.h>
+#include <dali/internal/render/gl-resources/texture-units.h>
+#include <dali/internal/render/renderers/render-renderer.h>
+#include <dali/internal/render/renderers/render-geometry.h>
+#include <dali/internal/update/manager/prepare-render-instructions.h>
+
+
+namespace Dali
+{
+namespace Internal
+{
+class Context;
+class PropertyInputImpl;
+
+namespace Render
+{
+
+/**
+ * The new geometry renderer.
+ *
+ * @todo MESH_REWORK It will be merged into the base class eventually
+ */
+class NewRenderer : public Renderer
+{
+public:
+ typedef Integration::ResourceId ResourceId;
+
+public:
+ /**
+ * Create a new renderer instance
+ * @param[in] dataProviders The data providers for the renderer
+ * @param[in] renderGeometry The geometry for the renderer
+ */
+ static NewRenderer* New( SceneGraph::RenderDataProvider* dataProviders, SceneGraph::RenderGeometry* renderGeometry );
+
+ /**
+ * Constructor.
+ * @param[in] dataProviders The data providers for the renderer
+ * @param[in] renderGeometry The geometry for the renderer
+ */
+ NewRenderer( SceneGraph::RenderDataProvider* dataProviders, SceneGraph::RenderGeometry* renderGeometry );
+
+ virtual ~NewRenderer();
+
+ /**
+ * Change the data providers of the renderer
+ * @param[in] dataProviders The data providers
+ */
+ void SetRenderDataProvider( SceneGraph::RenderDataProvider* dataProviders );
+
+ /**
+ * Change the geometry used by the renderer
+ * @param[in] renderGeometry The new geometry
+ */
+ void SetGeometry( SceneGraph::RenderGeometry* renderGeometry );
+
+ /**
+ * Write the renderer's sort attributes to the passed in reference.
+ * @param[in] bufferIndex The buffer index
+ * @param[out] sortAttributes
+ */
+ void SetSortAttributes( BufferIndex bufferIndex, SceneGraph::RendererWithSortAttributes& sortAttributes ) const
+ {
+ sortAttributes.shader = &( mRenderDataProvider->GetShader() );
+ const std::vector<Render::Texture>& textures( mRenderDataProvider->GetTextures() );
+ if( !textures.empty() )
+ {
+ sortAttributes.textureResourceId = textures[0].GetTextureId();
+ }
+ else
+ {
+ sortAttributes.textureResourceId = Integration::InvalidResourceId;
+ }
+
+ sortAttributes.geometry = mRenderGeometry;
+ }
+
+public: // Implementation of Renderer
+ /**
+ * @copydoc SceneGraph::Renderer::RequiresDepthTest()
+ */
+ virtual bool RequiresDepthTest() const;
+
+ /**
+ * @copydoc SceneGraph::Renderer::CheckResources()
+ */
+ virtual bool CheckResources();
+
+ /**
+ * @copydoc SceneGraph::Renderer::IsOutsideClipSpace()
+ */
+ virtual bool IsOutsideClipSpace( Context& context,
+ const Matrix& modelViewProjectionMatrix );
+
+ /**
+ * @copydoc SceneGraph::Renderer::DoSetUniforms()
+ */
+ virtual void DoSetUniforms( Context& context, BufferIndex bufferIndex, SceneGraph::Shader* shader, Program* program, unsigned int programIndex );
+
+ /**
+ * @copydoc SceneGraph::Renderer::DoSetCullFaceMode
+ */
+ virtual void DoSetCullFaceMode(Context& context, BufferIndex bufferIndex );
+
+ /**
+ * @copydoc SceneGraph::Renderer::DoSetBlending
+ */
+ virtual void DoSetBlending(Context& context, BufferIndex bufferIndex, bool blend );
+
+ /**
+ * @copydoc SceneGraph::Renderer::DoRender()
+ */
+ virtual void DoRender( Context& context,
+ SceneGraph::TextureCache& textureCache,
+ const SceneGraph::NodeDataProvider& node,
+ BufferIndex bufferIndex,
+ Program& program,
+ const Matrix& modelViewMatrix,
+ const Matrix& viewMatrix );
+
+public: // Implementation of GlResourceOwner
+
+ /**
+ * @copydoc Dali::Internal::GlResourceOwner::GlContextDestroyed()
+ */
+ virtual void GlContextDestroyed();
+
+ /**
+ * @copydoc Dali::Internal::GlResourceOwner::GlCleanup()
+ */
+ virtual void GlCleanup();
+
+private:
+ struct UniformIndexMap;
+
+ /**
+ * Set the uniforms from properties according to the uniform map
+ * @param[in] node The node using the renderer
+ * @param[in] program The shader program on which to set the uniforms.
+ */
+ void SetUniforms( BufferIndex bufferIndex, const SceneGraph::NodeDataProvider& node, Program& program );
+
+ /**
+ * Set the program uniform in the map from the mapped property
+ */
+ void SetUniformFromProperty( BufferIndex bufferIndex, Program& program, UniformIndexMap& map );
+
+ /**
+ * Bind the material textures in the samplers and setup the samplers
+ * @param[in] textureCache The texture cache
+ * @param[in] program The shader program
+ */
+ void BindTextures( SceneGraph::TextureCache& textureCache, Program& program );
+
+ /**
+ * Get the texture uniform index of the name sampler in the program.
+ * If not already registered in the program, then this performs the registration
+ * @param[in] program The shader program
+ * @param[in] sampler The sampler holding a texture unit uniform name to search for
+ * @return The texture uniform index in the program
+ */
+ unsigned int GetTextureUniformIndex( Program& program, const std::string& uniformName );
+
+
+public: //@todo MESH_REWORK make private after merge with SceneGraph::Renderer
+ OwnerPointer< SceneGraph::RenderDataProvider > mRenderDataProvider;
+
+private:
+ SceneGraph::RenderGeometry* mRenderGeometry;
+
+ struct UniformIndexMap
+ {
+ unsigned int uniformIndex; // The index of the cached location in the Program
+ const PropertyInputImpl* propertyValue;
+ };
+
+ typedef Dali::Vector< UniformIndexMap > UniformIndexMappings;
+ UniformIndexMappings mUniformIndexMap;
+
+ struct TextureUniformIndexMap
+ {
+ size_t uniformNameHash;
+ unsigned int uniformIndex; // The index of the cached location in the Program
+ };
+
+ typedef Dali::Vector< TextureUniformIndexMap > TextureUniformIndexMappings;
+ TextureUniformIndexMappings mTextureIndexMap;
+
+ Vector<GLint> mAttributesLocation;
+ bool mUpdateAttributesLocation;
+
+};
+
+
+} // SceneGraph
+} // Internal
+} // Dali
+
+#endif // __DALI_INTERNAL_RENDER_NEW_RENDERER_H__
--- /dev/null
+
+#include <dali/internal/render/renderers/render-property-buffer.h>
+#include <dali/internal/event/common/property-buffer-impl.h> // Dali::Internal::PropertyBuffer
+
+namespace
+{
+
+using namespace Dali;
+using Dali::Property;
+using Dali::Internal::PropertyImplementationType;
+
+Dali::GLenum GetPropertyImplementationGlType( Property::Type& propertyType )
+{
+ Dali::GLenum type = GL_BYTE;
+
+ switch( propertyType )
+ {
+ case Property::NONE:
+ case Property::STRING:
+ case Property::ARRAY:
+ case Property::MAP:
+ case Property::RECTANGLE:
+ case Property::ROTATION:
+ {
+ // types not supported by gl
+ break;
+ }
+ case Property::BOOLEAN:
+ {
+ type = GL_BYTE;
+ break;
+ }
+ case Property::INTEGER:
+ {
+ type = GL_SHORT;
+ break;
+ }
+ case Property::FLOAT:
+ case Property::VECTOR2:
+ case Property::VECTOR3:
+ case Property::VECTOR4:
+ case Property::MATRIX3:
+ case Property::MATRIX:
+ {
+ type = GL_FLOAT;
+ break;
+ }
+ }
+
+ return type;
+}
+
+size_t GetPropertyImplementationGlSize( Property::Type& propertyType )
+{
+ size_t size = 1u;
+
+ switch( propertyType )
+ {
+ case Property::NONE:
+ case Property::STRING:
+ case Property::ARRAY:
+ case Property::MAP:
+ case Property::RECTANGLE:
+ case Property::ROTATION:
+ {
+ // types not supported by gl
+ break;
+ }
+ case Property::BOOLEAN:
+ {
+ size = 1u;
+ break;
+ }
+ case Property::INTEGER:
+ {
+ size = 2u;
+ break;
+ }
+ case Property::FLOAT:
+ case Property::VECTOR2:
+ case Property::VECTOR3:
+ case Property::VECTOR4:
+ case Property::MATRIX3:
+ case Property::MATRIX:
+ {
+ size = 4u;
+ break;
+ }
+ }
+
+ return size;
+}
+} //Unnamed namespace
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Render
+{
+
+PropertyBuffer::PropertyBuffer()
+:mFormat(NULL),
+ mData(NULL),
+ mGpuBuffer(NULL),
+ mSize(0),
+ mDataChanged(true)
+{
+}
+
+PropertyBuffer::~PropertyBuffer()
+{
+}
+
+void PropertyBuffer::SetFormat( PropertyBuffer::Format* format )
+{
+ mFormat = format;
+ mDataChanged = true;
+}
+
+void PropertyBuffer::SetData( Dali::Vector<char>* data )
+{
+ mData = data;
+ mDataChanged = true;
+}
+
+void PropertyBuffer::SetSize( unsigned int size )
+{
+ mSize = size;
+ mDataChanged = true;
+}
+
+
+bool PropertyBuffer::Update( Context& context, bool isIndexBuffer )
+{
+ if( !mData || !mFormat || !mSize )
+ {
+ return false;
+ }
+
+ if( !mGpuBuffer || mDataChanged )
+ {
+ if ( ! mGpuBuffer )
+ {
+ mGpuBuffer = new GpuBuffer( context );
+ }
+
+ // Update the GpuBuffer
+ if ( mGpuBuffer )
+ {
+ DALI_ASSERT_DEBUG( mSize && "No data in the property buffer!" );
+
+ const void *data = &((*mData)[0]);
+
+ // Index buffer needs to be unsigned short which is not supported by the property system
+ Vector<unsigned short> ushortData;
+ if( isIndexBuffer )
+ {
+ ushortData.Resize(mSize);
+ const unsigned int* unsignedData = static_cast<const unsigned int*>(data);
+ for( unsigned int i = 0; i < mSize; ++i )
+ {
+ ushortData[i] = unsignedData[i];
+ }
+ data = &(ushortData[0]);
+ }
+
+ mGpuBuffer->UpdateDataBuffer( GetDataSize(), data, GpuBuffer::STATIC_DRAW );
+ }
+
+ mDataChanged = false;
+ }
+
+ return true;
+}
+
+void PropertyBuffer::BindBuffer(GpuBuffer::Target target)
+{
+ if(mGpuBuffer)
+ {
+ mGpuBuffer->Bind(target);
+ }
+}
+
+unsigned int PropertyBuffer::EnableVertexAttributes( Context& context, Vector<GLint>& vAttributeLocation, unsigned int locationBase )
+{
+
+ unsigned int attributeCount = mFormat->components.size();
+
+ GLsizei elementSize = mFormat->size;
+
+ for( unsigned int i = 0; i < attributeCount; ++i )
+ {
+ GLint attributeLocation = vAttributeLocation[i+locationBase];
+ if( attributeLocation != -1 )
+ {
+ context.EnableVertexAttributeArray( attributeLocation );
+
+ GLint attributeSize = mFormat->components[i].size;
+ size_t attributeOffset = mFormat->components[i].offset;
+ Property::Type attributeType = mFormat->components[i].type;
+
+ context.VertexAttribPointer( attributeLocation,
+ attributeSize / GetPropertyImplementationGlSize(attributeType),
+ GetPropertyImplementationGlType(attributeType),
+ GL_FALSE, // Not normalized
+ elementSize,
+ (void*)attributeOffset );
+ }
+ }
+
+ return attributeCount;
+
+}
+
+} //Render
+} //Internal
+} //Dali
--- /dev/null
+#ifndef DALI_INTERNAL_RENDER_PROPERTY_BUFFER_H
+#define DALI_INTERNAL_RENDER_PROPERTY_BUFFER_H
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <dali/internal/common/owner-pointer.h>
+#include <dali/public-api/actors/sampling.h>
+#include <dali/devel-api/rendering/sampler.h>
+#include <dali/internal/render/renderers/render-sampler.h>
+#include <dali/internal/render/gl-resources/gpu-buffer.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Render
+{
+
+class PropertyBuffer
+{
+public:
+
+ struct Component
+ {
+ std::string name;
+ unsigned int offset;
+ unsigned int size;
+ Property::Type type;
+ };
+
+ /**
+ * Structure that holds the meta-data of the format of PropertyBuffer.
+ */
+ struct Format
+ {
+ std::vector<Component> components;
+ unsigned int size;
+ };
+
+ /**
+ * @brief Default constructor
+ */
+ PropertyBuffer();
+
+ /**
+ * @brief Destructor
+ */
+ ~PropertyBuffer();
+
+ /**
+ * @brief Set the format of the buffer
+ *
+ * This function takes ownership of the pointer
+ *
+ * @param[in] format The format for the PropertyBuffer
+ */
+ void SetFormat( PropertyBuffer::Format* format );
+
+ /**
+ * @brief Set the data of the PropertyBuffer
+ *
+ * This function takes ownership of the pointer
+ * @param[in] data The new data of the PropertyBuffer
+ */
+ void SetData( Dali::Vector<char>* data );
+
+ /**
+ * @brief Set the number of elements
+ * @param[in] size The number of elements
+ */
+ void SetSize( unsigned int size );
+
+ /**
+ * @brief Bind the property buffer
+ * @param[in] target The binding point
+ */
+ void BindBuffer(GpuBuffer::Target target);
+
+ /**
+ * Perform the upload of the buffer only when requiered
+ * @param[in] context The GL context
+ * @param[in] isIndexBuffer True if the buffer is used as an index buffer
+ */
+ bool Update( Context& context, bool isIndexBuffer );
+
+ /**
+ * Enable the vertex attributes for each vertex buffer from the corresponding
+ * shader program.
+ * @param[in] context The GL context
+ * @param[in] vAttributeLocation Vector containing attributes location for current program
+ * @param[in] locationBase Index in vAttributeLocation corresponding to the first attribute defined by this buffer
+ */
+ unsigned int EnableVertexAttributes( Context& context, Vector<GLint>& vAttributeLocation, unsigned int locationBase );
+
+ /**
+ * Get the number of attributes present in the buffer
+ * @return The number of attributes stored in this buffer
+ */
+ inline unsigned int GetAttributeCount() const
+ {
+ DALI_ASSERT_DEBUG( mFormat && "Format should be set ");
+ return mFormat->components.size();
+ }
+
+ /**
+ * Retrieve the i-essim attribute name
+ * @param[in] index The index of the attribute
+ * @return The name of the attribute
+ */
+ inline const std::string& GetAttributeName(unsigned int index ) const
+ {
+ DALI_ASSERT_DEBUG( mFormat && "Format should be set ");
+ return mFormat->components[index].name;
+ }
+
+ /**
+ * Retrieve the size of the buffer in bytes
+ * @return The total size of the buffer
+ */
+ inline std::size_t GetDataSize() const
+ {
+ DALI_ASSERT_DEBUG( mFormat && "Format should be set ");
+ return mFormat->size * mSize;
+ }
+
+ /**
+ * Retrieve the size of one element of the buffer
+ * @return The size of one element
+ */
+ inline std::size_t GetElementSize() const
+ {
+ DALI_ASSERT_DEBUG( mFormat && "Format should be set ");
+ return mFormat->size;
+ }
+
+ /**
+ * Retrieve the number of elements in the buffer
+ * @return The total number of elements
+ */
+ inline unsigned int GetElementCount() const
+ {
+ return mSize;
+ }
+
+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
+
+ size_t mSize; ///< Number of Elements in the buffer
+ bool mDataChanged; ///< Flag to know if data has changed in a frame
+
+};
+
+} // namespace Render
+
+
+
+} // namespace Internal
+} // namespace Dali
+
+
+#endif // DALI_INTERNAL_RENDER_PROPERTY_BUFFER_H
+++ /dev/null
-/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-// CLASS HEADERS
-#include <dali/internal/render/renderers/render-renderer-property-buffer.h>
-
-// INTERNAL INCLUDES
-#include <dali/internal/event/common/property-buffer-impl.h> // Dali::Internal::PropertyBuffer
-#include <dali/internal/render/gl-resources/gpu-buffer.h>
-#include <dali/internal/render/shaders/program.h>
-
-namespace
-{
-
-using namespace Dali;
-using Dali::Property;
-using Dali::Internal::PropertyImplementationType;
-
-Dali::GLenum GetPropertyImplementationGlType( Property::Type& propertyType )
-{
- Dali::GLenum type = GL_BYTE;
-
- switch( propertyType )
- {
- case Property::NONE:
- case Property::STRING:
- case Property::ARRAY:
- case Property::MAP:
- case Property::RECTANGLE:
- case Property::ROTATION:
- {
- // types not supported by gl
- break;
- }
- case Property::BOOLEAN:
- {
- type = GL_BYTE;
- break;
- }
- case Property::INTEGER:
- {
- type = GL_SHORT;
- break;
- }
- case Property::FLOAT:
- case Property::VECTOR2:
- case Property::VECTOR3:
- case Property::VECTOR4:
- case Property::MATRIX3:
- case Property::MATRIX:
- {
- type = GL_FLOAT;
- break;
- }
- }
-
- return type;
-}
-
-size_t GetPropertyImplementationGlSize( Property::Type& propertyType )
-{
- size_t size = 1u;
-
- switch( propertyType )
- {
- case Property::NONE:
- case Property::STRING:
- case Property::ARRAY:
- case Property::MAP:
- case Property::RECTANGLE:
- case Property::ROTATION:
- {
- // types not supported by gl
- break;
- }
- case Property::BOOLEAN:
- {
- size = 1u;
- break;
- }
- case Property::INTEGER:
- {
- size = 2u;
- break;
- }
- case Property::FLOAT:
- case Property::VECTOR2:
- case Property::VECTOR3:
- case Property::VECTOR4:
- case Property::MATRIX3:
- case Property::MATRIX:
- {
- size = 4u;
- break;
- }
- }
-
- return size;
-}
-
-void UploadAttribute( Dali::Internal::Context& context,
- Dali::GLint attributeLocation,
- Dali::GLint attributeSize,
- size_t attributeOffset,
- Dali::Property::Type attributeType,
- Dali::GLsizei elementSize )
-{
- // TODO: MESH_REWORK Matrices need multiple calls to this function
- context.VertexAttribPointer( attributeLocation,
- attributeSize / GetPropertyImplementationGlSize(attributeType),
- GetPropertyImplementationGlType(attributeType),
- GL_FALSE, // Not normalized
- elementSize,
- (void*)attributeOffset );
-}
-
-} // unnamed namespace
-
-namespace Dali
-{
-namespace Internal
-{
-namespace SceneGraph
-{
-
-RenderPropertyBuffer::RenderPropertyBuffer( const PropertyBufferDataProvider& propertyBufferDataProvider,
- GpuBuffer::Target gpuBufferTarget,
- GpuBuffer::Usage gpuBufferUsage )
-: mDataProvider( propertyBufferDataProvider ),
- mGpuBuffer( NULL ),
- mGpuBufferTarget( gpuBufferTarget ),
- mGpuBufferUsage( gpuBufferUsage )
-{
-}
-
-RenderPropertyBuffer::~RenderPropertyBuffer()
-{
-}
-
-void RenderPropertyBuffer::Update( Context& context, BufferIndex bufferIndex )
-{
- if( !mGpuBuffer || mDataProvider.HasDataChanged( bufferIndex ) )
- {
- if ( ! mGpuBuffer )
- {
- mGpuBuffer = new GpuBuffer( context, mGpuBufferTarget, mGpuBufferUsage );
- }
-
- // Update the GpuBuffer
- if ( mGpuBuffer )
- {
- std::size_t dataSize = mDataProvider.GetDataSize( bufferIndex );
- DALI_ASSERT_DEBUG( dataSize && "No data in the property buffer!" );
-
- const void *data = &(mDataProvider.GetData( bufferIndex )[0]);
- Vector<unsigned short> ushortData;
-
- // Index buffer needs to be unsigned short which is not supported by the property system
- if( mGpuBufferTarget == GpuBuffer::ELEMENT_ARRAY_BUFFER )
- {
- ushortData.Resize( dataSize );
- const unsigned int* unsignedData = static_cast<const unsigned int*>(data);
- unsigned int numberOfElements = dataSize / sizeof(unsigned int);
- for( unsigned int i = 0; i < numberOfElements; ++i )
- {
- ushortData[i] = unsignedData[i];
- }
- data = &(ushortData[0]);
- }
-
- mGpuBuffer->UpdateDataBuffer( dataSize, data );
- mGpuBuffer->SetStride( mDataProvider.GetElementSize( bufferIndex ) );
- }
- }
-}
-
-void RenderPropertyBuffer::BindBuffer( Context& context )
-{
- mGpuBuffer->Bind();
-}
-
-unsigned int RenderPropertyBuffer::EnableVertexAttributes( Context& context, BufferIndex bufferIndex, Vector<GLint>& vAttributeLocation, unsigned int locationBase )
-{
- unsigned int attributeCount = mDataProvider.GetAttributeCount( bufferIndex );
-
- GLsizei elementSize = mDataProvider.GetElementSize( bufferIndex );
-
- for( unsigned int i = 0; i < attributeCount; ++i )
- {
- GLint attributeLocation = vAttributeLocation[i+locationBase];
- if( attributeLocation != -1 )
- {
- context.EnableVertexAttributeArray( attributeLocation );
-
- GLint attributeSize = mDataProvider.GetAttributeSize( bufferIndex, i );
- size_t attributeOffset = mDataProvider.GetAttributeOffset( bufferIndex, i );
- Property::Type attributeType = mDataProvider.GetAttributeType( bufferIndex, i );
-
- UploadAttribute( context,
- attributeLocation,
- attributeSize,
- attributeOffset,
- attributeType,
- elementSize );
- }
- }
-
- return attributeCount;
-}
-
-void RenderPropertyBuffer::UpdateAttributeLocations( Context& context, BufferIndex bufferIndex, Program& program )
-{
- unsigned int attributeCount = mDataProvider.GetAttributeCount( bufferIndex );
- mAttributesLocation.Resize( attributeCount );
-
- for( unsigned int i = 0; i < attributeCount; ++i )
- {
- const std::string& attributeName = mDataProvider.GetAttributeName( bufferIndex, i );
- unsigned int index = program.RegisterCustomAttribute( attributeName );
- GLint attributeLocation = program.GetCustomAttributeLocation( index );
-
- if( -1 == attributeLocation )
- {
- DALI_LOG_WARNING( "Attribute not found in the shader: %s\n", attributeName.c_str() );
- }
- mAttributesLocation[i] = attributeLocation;
- }
-}
-
-} // namespace SceneGraph
-} // namespace Internal
-} // namespace Dali
+++ /dev/null
-#ifndef DALI_INTERNAL_SCENE_GRAPH_RENDER_RENDERER_PROPERTY_BUFFER_H
-#define DALI_INTERNAL_SCENE_GRAPH_RENDER_RENDERER_PROPERTY_BUFFER_H
-
-/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <dali/integration-api/gl-abstraction.h>
-#include <dali/internal/common/buffer-index.h>
-#include <dali/internal/common/owner-container.h>
-#include <dali/internal/common/owner-pointer.h>
-#include <dali/internal/render/data-providers/property-buffer-data-provider.h>
-#include <dali/internal/render/gl-resources/gpu-buffer.h>
-
-namespace Dali
-{
-namespace Internal
-{
-class Context;
-class Program;
-
-namespace SceneGraph
-{
-class NewRenderer;
-/**
- * This class encapsulates the GPU buffers. It is used to upload vertex data
- * to it's GPU buffers, to bind all the buffers and to setup/teardown vertex attribute
- * bindings
- */
-class RenderPropertyBuffer
-{
-public:
- typedef OwnerContainer< GpuBuffer* > GpuBuffers;
-
- /**
- * Constructor. Creates a render geometry object with no GPU buffers.
- * @param[in] propertyBufferDataProvider The property-buffer data provider (to fetch geometry from)
- * @param[in] gpuBufferTarget Type of target for the gpu-buffer
- * @param[in] gpuBufferUsage Type of target for the gpu-buffer
- */
- RenderPropertyBuffer( const PropertyBufferDataProvider& propertyBufferDataProvider,
- GpuBuffer::Target gpuBufferTarget,
- GpuBuffer::Usage gpuBufferUsage );
-
- /**
- * Destructor
- */
- ~RenderPropertyBuffer();
-
- /**
- * Perform the upload of the buffer only when requiered
- * @param[in] context The GL context
- * @param[in] bufferIndex The current buffer index
- */
- void Update( Context& context, BufferIndex bufferIndex );
-
- /**
- * Bind the geometry buffers
- * @param[in] context The GL context
- */
- void BindBuffer( Context& context );
-
- /**
- * Enable the vertex attributes for each vertex buffer from the corresponding
- * shader program.
- * @param[in] context The GL context
- * @param[in] bufferIndex The current buffer index
- * @param[in] program The shader program to query for attribute locations
- * @param[in] vAttributeLocation Vector containing attributes location for current program
- * @param[in] locationBase Index in vAttributeLocation corresponding to the first attribute defined by this buffer
- */
- unsigned int EnableVertexAttributes( Context& context, BufferIndex bufferIndex, Vector<GLint>& vAttributeLocation, unsigned int locationBase);
-
- /**
- * Get the data provider for the buffer
- */
- const PropertyBufferDataProvider& GetDataProvider() const
- {
- return mDataProvider;
- }
-
-private: // implementation
-
- /**
- * Update attribute locations
- * @param[in] context The GL context
- * @param[in] bufferIndex The current buffer index
- * @param[in] program The shader program to query for attribute locations
- */
- void UpdateAttributeLocations( Context& context, BufferIndex bufferIndex, Program& program );
-
-private:
- const PropertyBufferDataProvider& mDataProvider; ///< Data provider used by this property buffer
- Vector<GLint> mAttributesLocation; ///< Location of the attributes for the property buffer in this renderer.
-
- OwnerPointer<GpuBuffer> mGpuBuffer; ///< Pointer to the GpuBuffer associated with this RenderPropertyBuffer
- GpuBuffer::Target mGpuBufferTarget; ///< The type of GPU buffer to create
- GpuBuffer::Usage mGpuBufferUsage; ///< The type of usage the GPU buffer will have
-};
-
-} // namespace SceneGraph
-} // namespace Internal
-} // namespace Dali
-
-#endif // DALI_INTERNAL_SCENE_GRAPH_RENDER_RENDERER_PROPERTY_BUFFER_H
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
+ *
*/
-#include "render-renderer.h"
+// CLASS HEADER
+#include <dali/internal/render/renderers/render-renderer.h>
-#include <dali/internal/common/image-sampler.h>
-#include <dali/internal/event/common/property-input-impl.h>
-#include <dali/internal/update/common/uniform-map.h>
-#include <dali/internal/render/data-providers/render-data-provider.h>
-#include <dali/internal/render/gl-resources/texture.h>
-#include <dali/internal/render/gl-resources/texture-cache.h>
+
+// INTERNAL INCLUDES
+#include <dali/internal/render/gl-resources/context.h>
+#include <dali/internal/render/shaders/scene-graph-shader.h>
#include <dali/internal/render/shaders/program.h>
+#include <dali/internal/render/data-providers/node-data-provider.h>
+#include <dali/public-api/actors/blending.h>
+#include <dali/internal/common/image-sampler.h>
+#include <dali/internal/render/renderers/render-new-renderer.h>
namespace Dali
{
+
namespace Internal
{
-namespace SceneGraph
-{
-NewRenderer* NewRenderer::New( NodeDataProvider& nodeDataProvider,
- RenderDataProvider* dataProvider,
- RenderGeometry* renderGeometry )
+namespace
{
- return new NewRenderer(nodeDataProvider, dataProvider, renderGeometry);
-}
+static Matrix gModelViewProjectionMatrix( false ); ///< a shared matrix to calculate the MVP matrix, dont want to store it in object to reduce storage overhead
+static Matrix3 gNormalMatrix; ///< a shared matrix to calculate normal matrix, dont want to store it in object to reduce storage overhead
-NewRenderer::NewRenderer( NodeDataProvider& nodeDataProvider,
- RenderDataProvider* dataProvider,
- RenderGeometry* renderGeometry )
-: Renderer( nodeDataProvider ),
- mRenderDataProvider( dataProvider ),
- mRenderGeometry( renderGeometry ),
- mUpdateAttributesLocation( true )
-{
-}
+/**
+ * Helper to set view and projection matrices once per program
+ * @param program to set the matrices to
+ * @param modelMatrix to set
+ * @param viewMatrix to set
+ * @param projectionMatrix to set
+ * @param modelViewMatrix to set
+ * @param modelViewProjectionMatrix to set
+ */
+inline void SetMatrices( Program& program,
+ const Matrix& modelMatrix,
+ const Matrix& viewMatrix,
+ const Matrix& projectionMatrix,
+ const Matrix& modelViewMatrix,
+ const Matrix& modelViewProjectionMatrix )
+{
+ GLint loc = program.GetUniformLocation(Program::UNIFORM_MODEL_MATRIX);
+ if( Program::UNIFORM_UNKNOWN != loc )
+ {
+ program.SetUniformMatrix4fv( loc, 1, modelMatrix.AsFloat() );
+ }
+ loc = program.GetUniformLocation( Program::UNIFORM_VIEW_MATRIX );
+ if( Program::UNIFORM_UNKNOWN != loc )
+ {
+ if( program.GetViewMatrix() != &viewMatrix )
+ {
+ program.SetViewMatrix( &viewMatrix );
+ program.SetUniformMatrix4fv( loc, 1, viewMatrix.AsFloat() );
+ }
+ }
+ // set projection matrix if program has not yet received it this frame or if it is dirty
+ loc = program.GetUniformLocation( Program::UNIFORM_PROJECTION_MATRIX );
+ if( Program::UNIFORM_UNKNOWN != loc )
+ {
+ if( program.GetProjectionMatrix() != &projectionMatrix )
+ {
+ program.SetProjectionMatrix( &projectionMatrix );
+ program.SetUniformMatrix4fv( loc, 1, projectionMatrix.AsFloat() );
+ }
+ }
+ loc = program.GetUniformLocation(Program::UNIFORM_MODELVIEW_MATRIX);
+ if( Program::UNIFORM_UNKNOWN != loc )
+ {
+ program.SetUniformMatrix4fv( loc, 1, modelViewMatrix.AsFloat() );
+ }
-NewRenderer::~NewRenderer()
-{
-}
+ loc = program.GetUniformLocation( Program::UNIFORM_MVP_MATRIX );
+ if( Program::UNIFORM_UNKNOWN != loc )
+ {
+ program.SetUniformMatrix4fv( loc, 1, modelViewProjectionMatrix.AsFloat() );
+ }
-void NewRenderer::SetRenderDataProvider( RenderDataProvider* dataProvider )
-{
- mRenderDataProvider = dataProvider;
- mUpdateAttributesLocation = true;
+ loc = program.GetUniformLocation( Program::UNIFORM_NORMAL_MATRIX );
+ if( Program::UNIFORM_UNKNOWN != loc )
+ {
+ gNormalMatrix = modelViewMatrix;
+ gNormalMatrix.Invert();
+ gNormalMatrix.Transpose();
+ program.SetUniformMatrix3fv( loc, 1, gNormalMatrix.AsFloat() );
+ }
}
-void NewRenderer::SetGeometry( RenderGeometry* renderGeometry )
-{
- mRenderGeometry = renderGeometry;
- mUpdateAttributesLocation = true;
}
-// Note - this is currently called from UpdateThread, PrepareRenderInstructions,
-// as an optimisation.
-// @todo MESH_REWORK Should use Update thread objects only in PrepareRenderInstructions.
-bool NewRenderer::RequiresDepthTest() const
+namespace Render
{
- return true;
-}
-bool NewRenderer::CheckResources()
+void Renderer::Initialize( Context& context, SceneGraph::TextureCache& textureCache )
{
- // Query material to check it has texture pointers & image has size
- // Query geometry to check it has vertex buffers
-
- // General point though - why would we have a render item in RenderThread with no ready
- // resources in UpdateThread?
- return true;
+ mContext = &context;
+ mTextureCache = &textureCache;
}
-bool NewRenderer::IsOutsideClipSpace( Context& context, const Matrix& modelMatrix, const Matrix& modelViewProjectionMatrix )
+Renderer::~Renderer()
{
- // @todo MESH_REWORK Add clipping
- return false;
}
-void NewRenderer::DoSetUniforms( Context& context, BufferIndex bufferIndex, Shader* shader, Program* program, unsigned int programIndex )
+void Renderer::SetShader( SceneGraph::Shader* shader )
{
- // Do nothing, we're going to set up the uniforms with our own code instead
+ mShader = shader;
}
-void NewRenderer::DoSetCullFaceMode( Context& context, BufferIndex bufferIndex )
+void Renderer::SetCullFace( CullFaceMode mode )
{
+ DALI_ASSERT_DEBUG(mode >= CullNone && mode <= CullFrontAndBack);
+ mCullFaceMode = mode;
}
-void NewRenderer::DoSetBlending( Context& context, BufferIndex bufferIndex )
+void Renderer::SetSampler( unsigned int samplerBitfield )
{
- bool blend = mRenderDataProvider->GetUseBlend( bufferIndex );
- context.SetBlend( blend );
- if( blend )
- {
- const MaterialDataProvider& material = mRenderDataProvider->GetMaterial();
-
- context.SetCustomBlendColor( material.GetBlendColor( bufferIndex ) );
-
- // Set blend source & destination factors
- context.BlendFuncSeparate( material.GetBlendSrcFactorRgb( bufferIndex ),
- material.GetBlendDestFactorRgb( bufferIndex ),
- material.GetBlendSrcFactorAlpha( bufferIndex ),
- material.GetBlendDestFactorAlpha( bufferIndex ) );
-
- // Set blend equations
- context.BlendEquationSeparate( material.GetBlendEquationRgb( bufferIndex ),
- material.GetBlendEquationAlpha( bufferIndex ) );
- }
+ mSamplerBitfield = samplerBitfield;
}
-void NewRenderer::DoRender( Context& context, TextureCache& textureCache, BufferIndex bufferIndex, Program& program, const Matrix& modelViewMatrix, const Matrix& viewMatrix )
+void Renderer::Render( Context& context,
+ SceneGraph::TextureCache& textureCache,
+ BufferIndex bufferIndex,
+ const SceneGraph::NodeDataProvider& node,
+ SceneGraph::Shader& defaultShader,
+ const Matrix& modelViewMatrix,
+ const Matrix& viewMatrix,
+ const Matrix& projectionMatrix,
+ bool cull,
+ bool blend )
{
- BindTextures( textureCache, bufferIndex, program, mRenderDataProvider->GetSamplers() );
-
- SetUniforms( bufferIndex, program );
+ NewRenderer* renderer = dynamic_cast<NewRenderer*>(this);
- if( mUpdateAttributesLocation || mRenderGeometry->AttributesChanged() )
+ if( renderer )
{
- mRenderGeometry->GetAttributeLocationFromProgram( mAttributesLocation, program, bufferIndex );
- mUpdateAttributesLocation = false;
+ // Get the shader from the material:
+ mShader = &renderer->mRenderDataProvider->GetShader();
}
- mRenderGeometry->UploadAndDraw( context, bufferIndex, mAttributesLocation );
-}
-
-void NewRenderer::GlContextDestroyed()
-{
- mRenderGeometry->GlContextDestroyed();
-}
-
-void NewRenderer::GlCleanup()
-{
-}
-
-void NewRenderer::SetUniforms( BufferIndex bufferIndex, Program& program )
-{
- // Check if the map has changed
- DALI_ASSERT_DEBUG( mRenderDataProvider && "No Uniform map data provider available" );
-
- const UniformMapDataProvider& uniformMapDataProvider = mRenderDataProvider->GetUniformMap();
-
- if( uniformMapDataProvider.GetUniformMapChanged( bufferIndex ) )
+ // if mShader is NULL it means we're set to default
+ if( !mShader )
{
- const CollectedUniformMap& uniformMap = uniformMapDataProvider.GetUniformMap( bufferIndex );
-
- unsigned int numberOfMaps = uniformMap.Count();
- mUniformIndexMap.Clear(); // Clear contents, but keep memory if we don't change size
- mUniformIndexMap.Resize( numberOfMaps );
-
- // Remap uniform indexes to property value addresses
- for( unsigned int mapIndex = 0 ; mapIndex < numberOfMaps ; ++mapIndex )
- {
- mUniformIndexMap[mapIndex].propertyValue = uniformMap[mapIndex]->propertyPtr;
- mUniformIndexMap[mapIndex].uniformIndex = program.RegisterUniform( uniformMap[mapIndex]->uniformName );
- }
+ mShader = &defaultShader;
}
- // Set uniforms in local map
- for( UniformIndexMappings::Iterator iter = mUniformIndexMap.Begin(),
- end = mUniformIndexMap.End() ;
- iter != end ;
- ++iter )
+ if( !CheckResources() )
{
- SetUniformFromProperty( bufferIndex, program, *iter );
+ // CheckResources() is overriden in derived classes.
+ // Prevents modify the GL state if resources are not ready and nothing is to be rendered.
+ return;
}
- // @todo MESH_REWORK On merge, copy code from renderer to setup standard matrices and color
+ // Calculate the MVP matrix first so we can do the culling test
+ const Matrix& modelMatrix = node.GetModelMatrix( bufferIndex );
+ Matrix::Multiply( gModelViewProjectionMatrix, modelViewMatrix, projectionMatrix );
- GLint sizeLoc = program.GetUniformLocation( Program::UNIFORM_SIZE );
- if( -1 != sizeLoc )
+ // Get the program to use:
+ Program* program = mShader->GetProgram();
+ if( !program )
{
- Vector3 size = mDataProvider->GetRenderSize( bufferIndex );
- program.SetUniform3f( sizeLoc, size.x, size.y, size.z );
+ // if program is NULL it means this is a custom shader with non matching geometry type so we need to use default shaders program
+ program = defaultShader.GetProgram();
+ 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.", (void*) &*mShader );
+ return;
+ }
}
-}
-void NewRenderer::SetUniformFromProperty( BufferIndex bufferIndex, Program& program, UniformIndexMap& map )
-{
- GLint location = program.GetUniformLocation(map.uniformIndex);
- if( Program::UNIFORM_UNKNOWN != location )
+ // Check culling (does not need the program to be in use)
+ if( cull && ! program->ModifiesGeometry() )
{
- // switch based on property type to use correct GL uniform setter
- switch ( map.propertyValue->GetType() )
+ if( IsOutsideClipSpace( context, gModelViewProjectionMatrix ) )
{
- case Property::INTEGER:
- {
- program.SetUniform1i( location, map.propertyValue->GetInteger( bufferIndex ) );
- break;
- }
- case Property::FLOAT:
- {
- program.SetUniform1f( location, map.propertyValue->GetFloat( bufferIndex ) );
- break;
- }
- case Property::VECTOR2:
- {
- Vector2 value( map.propertyValue->GetVector2( bufferIndex ) );
- program.SetUniform2f( location, value.x, value.y );
- break;
- }
-
- case Property::VECTOR3:
- {
- Vector3 value( map.propertyValue->GetVector3( bufferIndex ) );
- program.SetUniform3f( location, value.x, value.y, value.z );
- break;
- }
-
- case Property::VECTOR4:
- {
- Vector4 value( map.propertyValue->GetVector4( bufferIndex ) );
- program.SetUniform4f( location, value.x, value.y, value.z, value.w );
- break;
- }
-
- case Property::ROTATION:
- {
- Quaternion value( map.propertyValue->GetQuaternion( bufferIndex ) );
- program.SetUniform4f( location, value.mVector.x, value.mVector.y, value.mVector.z, value.mVector.w );
- break;
- }
-
- case Property::MATRIX:
- {
- const Matrix& value = map.propertyValue->GetMatrix(bufferIndex);
- program.SetUniformMatrix4fv(location, 1, value.AsFloat() );
- break;
- }
-
- case Property::MATRIX3:
- {
- const Matrix3& value = map.propertyValue->GetMatrix3(bufferIndex);
- program.SetUniformMatrix3fv(location, 1, value.AsFloat() );
- break;
- }
-
- default:
- {
- // Other property types are ignored
- break;
- }
+ // don't do any further gl state changes as this renderer is not visible
+ return;
}
}
-}
-void NewRenderer::BindTextures(
- TextureCache& textureCache,
- BufferIndex bufferIndex,
- Program& program,
- const RenderDataProvider::Samplers& samplers )
-{
- // @todo MESH_REWORK Write a cache of texture units to commonly used sampler textures
- unsigned int textureUnit = 0;
+ // Take the program into use so we can send uniforms to it
+ program->Use();
- for( RenderDataProvider::Samplers::Iterator iter = samplers.Begin();
- iter != samplers.End();
- ++iter )
- {
- const SamplerDataProvider* sampler = *iter;
- ResourceId textureId = sampler->GetTextureId(bufferIndex);
- Texture* texture = textureCache.GetTexture( textureId );
- if( texture != NULL )
- {
- unsigned int textureUnitUniformIndex = GetTextureUnitUniformIndex( program, *sampler );
- TextureUnit theTextureUnit = static_cast<TextureUnit>(textureUnit);
- BindTexture( textureCache, program, textureId, texture, theTextureUnit, textureUnitUniformIndex );
- ApplySampler( bufferIndex, texture, theTextureUnit, *sampler );
- }
+ DoSetCullFaceMode( context, bufferIndex );
- ++textureUnit;
- }
-}
+ DoSetBlending( context, bufferIndex, blend );
-void NewRenderer::BindTexture(
- TextureCache& textureCache,
- Program& program,
- ResourceId id,
- Texture* texture,
- TextureUnit textureUnit,
- unsigned int textureUnitUniformIndex )
-{
- if( texture != NULL )
- {
- textureCache.BindTexture( texture, id, GL_TEXTURE_2D, textureUnit );
+ // Ignore missing uniforms - custom shaders and flat color shaders don't have SAMPLER
+ // set projection and view matrix if program has not yet received them yet this frame
+ SetMatrices( *program, modelMatrix, viewMatrix, projectionMatrix, modelViewMatrix, gModelViewProjectionMatrix );
- // Set sampler uniform location for the texture
- GLint textureUnitLoc = program.GetUniformLocation( textureUnitUniformIndex );
- if( Program::UNIFORM_UNKNOWN != textureUnitLoc )
- {
- program.SetUniform1i( textureUnitLoc, textureUnit );
- }
+ // set color uniform
+ GLint loc = program->GetUniformLocation( Program::UNIFORM_COLOR );
+ if( Program::UNIFORM_UNKNOWN != loc )
+ {
+ const Vector4& color = node.GetRenderColor( bufferIndex );
+ program->SetUniform4f( loc, color.r, color.g, color.b, color.a );
}
-}
-void NewRenderer::ApplySampler(
- BufferIndex bufferIndex,
- Texture* texture,
- TextureUnit textureUnit,
- const SamplerDataProvider& sampler )
-{
- unsigned int samplerBitfield = ImageSampler::PackBitfield(
- static_cast< FilterMode::Type >(sampler.GetMinifyFilterMode(bufferIndex)),
- static_cast< FilterMode::Type >(sampler.GetMagnifyFilterMode(bufferIndex)) );
+ //@todo MESH_REWORK Remove after removing ImageRenderer
+ DoSetUniforms(context, bufferIndex, mShader, program );
- texture->ApplySampler( textureUnit, samplerBitfield );
-
- // @todo MESH_REWORK add support for wrap modes
+ // subclass rendering and actual draw call
+ DoRender( context, textureCache, node, bufferIndex, *program, modelViewMatrix, viewMatrix );
}
-unsigned int NewRenderer::GetTextureUnitUniformIndex(
- Program& program,
- const SamplerDataProvider& sampler )
+void Renderer::SetSortAttributes( BufferIndex bufferIndex, SceneGraph::RendererWithSortAttributes& sortAttributes ) const
{
- // Find sampler in mSamplerNameCache
- // If it doesn't exist,
- // get the index by calling program.RegisterUniform and store it
- // If it exists, it's index should be set.
- // @todo Cache should be reset on scene change
-
- unsigned int uniformIndex = 0;
- bool found = false;
+ sortAttributes.shader = mShader;
+ sortAttributes.textureResourceId = Integration::InvalidResourceId;
+ sortAttributes.geometry = NULL;
+}
- for( unsigned int i=0; i< mTextureUnitUniforms.Count(); ++i )
- {
- if( mTextureUnitUniforms[i].sampler == &sampler )
- {
- uniformIndex = mTextureUnitUniforms[i].index;
- found = true;
- }
- }
+// can be overridden by deriving class
+void Renderer::DoSetUniforms(Context& context, BufferIndex bufferIndex, SceneGraph::Shader* shader, Program* program )
+{
+ shader->SetUniforms( context, *program, bufferIndex );
+}
- if( ! found )
- {
- TextureUnitUniformIndex textureUnitUniformIndex;
- textureUnitUniformIndex.sampler = &sampler;
- textureUnitUniformIndex.index = program.RegisterUniform( sampler.GetTextureUnitUniformName() );
- mTextureUnitUniforms.PushBack( textureUnitUniformIndex );
- uniformIndex = textureUnitUniformIndex.index;
- }
+// can be overridden by deriving class
+void Renderer::DoSetCullFaceMode(Context& context, BufferIndex bufferIndex )
+{
+ // Set face culling mode
+ context.CullFace( mCullFaceMode );
+}
- return uniformIndex;
+Renderer::Renderer()
+: mContext(NULL),
+ mTextureCache( NULL ),
+ mShader( NULL ),
+ mSamplerBitfield( ImageSampler::PackBitfield( FilterMode::DEFAULT, FilterMode::DEFAULT ) ),
+ mCullFaceMode( CullNone )
+{
}
+} // namespace SceneGraph
+
+} // namespace Internal
-} // SceneGraph
-} // Internal
-} // Dali
+} // namespace Dali
-#ifndef __DALI_INTERNAL_SCENE_GRAPH_NEW_RENDERER_H__
-#define __DALI_INTERNAL_SCENE_GRAPH_NEW_RENDERER_H__
+#ifndef __DALI_INTERNAL_RENDER_RENDERER_H__
+#define __DALI_INTERNAL_RENDER_RENDERER_H__
/*
* Copyright (c) 2015 Samsung Electronics Co., Ltd.
*
*/
-#include <dali/integration-api/resource-declarations.h> // For resource id
-#include <dali/internal/common/owner-pointer.h>
-#include <dali/internal/render/data-providers/render-data-provider.h>
-#include <dali/internal/render/gl-resources/texture-units.h>
-#include <dali/internal/render/renderers/scene-graph-renderer.h>
-#include <dali/internal/render/renderers/render-geometry.h>
+// INTERNAL INCLUDES
+#include <dali/public-api/math/matrix.h>
+#include <dali/public-api/math/vector4.h>
+#include <dali/internal/common/blending-options.h>
+#include <dali/internal/common/message.h>
+#include <dali/internal/event/effects/shader-declarations.h>
+#include <dali/internal/render/gl-resources/gl-resource-owner.h>
+#include <dali/integration-api/debug.h>
+#include <dali/internal/common/type-abstraction-enums.h>
+#include <dali/internal/update/manager/prepare-render-instructions.h>
namespace Dali
{
+
namespace Internal
{
-class PropertyInputImpl;
+class Context;
+class Texture;
+class Program;
namespace SceneGraph
{
+class SceneController;
+class Shader;
+class TextureCache;
+class NodeDataProvider;
+}
+
+
+namespace Render
+{
+
/**
- * The new geometry renderer.
- *
- * @todo MESH_REWORK It will be merged into the base class eventually
+ * Renderers are used to render meshes
+ * These objects are used during RenderManager::Render(), so properties modified during
+ * the Update must either be double-buffered, or set via a message added to the RenderQueue.
*/
-class NewRenderer : public Renderer
+class Renderer : public GlResourceOwner
{
public:
- typedef Integration::ResourceId ResourceId;
-public:
/**
- * Create a new renderer instance
- * @param[in] nodeDataProvider The node data provider
- * @param[in] dataProviders The data providers for the renderer
- * @param[in] renderGeometry The geometry for the renderer
+ * Second-phase construction.
+ * This is called when the renderer is inside render thread
+ * @param[in] textureCache to use
*/
- static NewRenderer* New( NodeDataProvider& nodeDataProvider, RenderDataProvider* dataProviders, RenderGeometry* renderGeometry );
- /**
- * Constructor.
- * @param[in] nodeDataProvider The node data provider
- * @param[in] dataProviders The data providers for the renderer
- * @param[in] renderGeometry The geometry for the renderer
- */
- NewRenderer( NodeDataProvider& nodeDataProvider, RenderDataProvider* dataProviders, RenderGeometry* renderGeometry );
-
- virtual ~NewRenderer();
+ void Initialize( Context& context, SceneGraph::TextureCache& textureCache );
/**
- * Change the data providers of the renderer
- * @param[in] dataProviders The data providers
+ * Virtual destructor
*/
- void SetRenderDataProvider( RenderDataProvider* dataProviders );
+ virtual ~Renderer();
/**
- * Change the geometry used by the renderer
- * @param[in] renderGeometry The new geometry
+ * Set the Shader used to render.
+ * @param[in] shader The shader used to render.
*/
- void SetGeometry( RenderGeometry* renderGeometry );
+ void SetShader( SceneGraph::Shader* shader );
-public: // Implementation of Renderer
/**
- * @copydoc SceneGraph::Renderer::RequiresDepthTest()
+ * Set the face-culling mode.
+ * @param[in] mode The face-culling mode.
*/
- virtual bool RequiresDepthTest() const;
+ void SetCullFace( CullFaceMode mode );
/**
- * @copydoc SceneGraph::Renderer::CheckResources()
+ * Set the sampler used to render the set texture.
+ * @param[in] samplerBitfield The packed sampler options used to render.
*/
- virtual bool CheckResources();
+ void SetSampler( unsigned int samplerBitfield );
/**
- * @copydoc SceneGraph::Renderer::IsOutsideClipSpace()
+ * Query whether the derived type of Renderer requires depth testing.
+ * @return True if the renderer requires depth testing.
*/
- virtual bool IsOutsideClipSpace( Context& context,
- const Matrix& modelMatrix,
- const Matrix& modelViewProjectionMatrix );
+ virtual bool RequiresDepthTest() const = 0;
/**
- * @copydoc SceneGraph::Renderer::DoSetUniforms()
+ * Called to render during RenderManager::Render().
+ * @param[in] context The context used for rendering
+ * @param[in] textureCache The texture cache used to get textures
+ * @param[in] bufferIndex The index of the previous update buffer.
+ * @param[in] node The node using this renderer
+ * @param[in] defaultShader in case there is no custom shader
+ * @param[in] modelViewMatrix The model-view matrix.
+ * @param[in] viewMatrix The view matrix.
+ * @param[in] projectionMatrix The projection matrix.
+ * @param[in] cull Whether to frustum cull this renderer
*/
- virtual void DoSetUniforms( Context& context, BufferIndex bufferIndex, Shader* shader, Program* program, unsigned int programIndex );
+ void Render( Context& context,
+ SceneGraph::TextureCache& textureCache,
+ BufferIndex bufferIndex,
+ const SceneGraph::NodeDataProvider& node,
+ SceneGraph::Shader& defaultShader,
+ const Matrix& modelViewMatrix,
+ const Matrix& viewMatrix,
+ const Matrix& projectionMatrix,
+ bool cull,
+ bool blend);
/**
- * @copydoc SceneGraph::Renderer::DoSetCullFaceMode
+ * Write the renderer's sort attributes to the passed in reference
+ *
+ * @param[in] bufferIndex The current update buffer index.
+ * @param[out] sortAttributes
*/
- virtual void DoSetCullFaceMode(Context& context, BufferIndex bufferIndex );
+ virtual void SetSortAttributes( BufferIndex bufferIndex, SceneGraph::RendererWithSortAttributes& sortAttributes ) const;
+protected:
/**
- * @copydoc SceneGraph::Renderer::DoSetBlending
+ * Protected constructor; only derived classes can be instantiated.
+ * @param dataprovider for rendering
*/
- virtual void DoSetBlending(Context& context, BufferIndex bufferIndex );
+ Renderer();
- /**
- * @copydoc SceneGraph::Renderer::DoRender()
- */
- virtual void DoRender( Context& context,
- TextureCache& textureCache,
- BufferIndex bufferIndex,
- Program& program,
- const Matrix& modelViewMatrix,
- const Matrix& viewMatrix );
+private:
-public: // Implementation of GlResourceOwner
+ // Undefined
+ Renderer( const Renderer& );
- /**
- * @copydoc Dali::Internal::GlResourceOwner::GlContextDestroyed()
- */
- virtual void GlContextDestroyed();
+ // Undefined
+ Renderer& operator=( const Renderer& rhs );
/**
- * @copydoc Dali::Internal::GlResourceOwner::GlCleanup()
+ * Checks if renderer's resources are ready to be used.
+ *
+ * @return \e true if they are. Otherwise \e false.
*/
- virtual void GlCleanup();
-
-private:
- struct UniformIndexMap;
+ virtual bool CheckResources() = 0;
/**
- * Set the uniforms from properties according to the uniform map
- * @param[in] program The shader program on which to set the uniforms.
+ * Checks if renderer is culled.
+ * @param[in] modelViewProjectionMatrix The MVP matrix.
+ * @return \e true if it is. Otherwise \e false.
*/
- void SetUniforms( BufferIndex bufferIndex, Program& program );
+ virtual bool IsOutsideClipSpace( Context& context, const Matrix& modelViewProjectionMatrix ) = 0;
/**
- * Set the program uniform in the map from the mapped property
+ * Called from Render prior to DoRender().
+ * @todo MESH_REWORK Remove after merge
*/
- void SetUniformFromProperty( BufferIndex bufferIndex, Program& program, UniformIndexMap& map );
+ virtual void DoSetUniforms( Context& context, BufferIndex bufferIndex, SceneGraph::Shader* shader, Program* program );
/**
- * Bind the material textures in the samplers and setup the samplers
- * @param[in] textureCache The texture cache
- * @param[in] bufferIndex The buffer index
- * @param[in] program The shader program
- * @param[in] samplers The samplers to bind
+ * Called from Render prior to DoRender(). Default method to set CullFaceMode
+ * @todo MESH_REWORK Remove after merge
*/
- void BindTextures( TextureCache& textureCache,
- BufferIndex bufferIndex,
- Program& program,
- const RenderDataProvider::Samplers& samplers );
+ virtual void DoSetCullFaceMode( Context& context, BufferIndex bufferIndex );
/**
- * Bind a material texture to a texture unit, and set the sampler's texture uniform
- * to that texture unit.
- * @param[in] textureCache The texture cache
- * @param[in] program The shader program
- * @param[in] id The resource id of the texture to bind
- * @param[in] texture The texture to bind
- * @param[in] textureUnit The texture unit index to use
- * @param[in] nameIndex The index of the texture uniform in the program
+ * Called from Render prior to DoRender(). Default method to set blending options
+ * @todo MESH_REWORK Remove after merge
*/
- void BindTexture( TextureCache& textureCache,
- Program& program,
- ResourceId id,
- Texture* texture,
- TextureUnit textureUnit,
- unsigned int nameIndex );
+ virtual void DoSetBlending( Context& context, BufferIndex bufferIndex, bool blend ) = 0;
/**
- * Apply the sampler modes to the texture.
- * @param[in] bufferIndex The current buffer index
- * @param[in] texture The texture to which to apply the sampler modes
- * @param[in] textureUnit The texture unit of the texture
- * @param[in] sampler The sampler from which to get the modes.
+ * Called from Render; implemented in derived classes.
+ * @param[in] context The context used for rendering
+ * @param[in] textureCache The texture cache used to get textures
+ * @param[in] bufferIndex The index of the previous update buffer.
+ * @param[in] program to use.
+ * @param[in] modelViewMatrix The model-view matrix.
+ * @param[in] viewMatrix The view matrix.
*/
- void ApplySampler( BufferIndex bufferIndex,
- Texture* texture,
- TextureUnit textureUnit,
- const SamplerDataProvider& sampler );
+ virtual void DoRender( Context& context, SceneGraph::TextureCache& textureCache, const SceneGraph::NodeDataProvider& node, BufferIndex bufferIndex, Program& program, const Matrix& modelViewMatrix, const Matrix& viewMatrix ) = 0;
- /**
- * Get the texture uniform index of the name sampler in the program.
- * If not already registered in the program, then this performs the registration
- * @param[in] program The shader program
- * @param[in] sampler The sampler holding a texture unit uniform name to search for
- * @return The texture uniform index in the program
- */
- unsigned int GetTextureUnitUniformIndex( Program& program,
- const SamplerDataProvider& sampler );
+protected:
-public: //@todo MESH_REWORK make private after merge with SceneGraph::Renderer
- OwnerPointer< RenderDataProvider > mRenderDataProvider;
+ Context* mContext;
+ SceneGraph::TextureCache* mTextureCache;
+ SceneGraph::Shader* mShader;
+ unsigned int mSamplerBitfield; ///< Sampler options used for texture filtering
private:
- RenderGeometry* mRenderGeometry;
- struct TextureUnitUniformIndex
- {
- const SamplerDataProvider* sampler;
- unsigned int index;
- };
-
- typedef Dali::Vector< TextureUnitUniformIndex > TextureUnitUniforms;
- TextureUnitUniforms mTextureUnitUniforms;
-
- struct UniformIndexMap
- {
- unsigned int uniformIndex; // The index of the cached location in the Program
- const PropertyInputImpl* propertyValue;
- };
-
- typedef Dali::Vector< UniformIndexMap > UniformIndexMappings;
- UniformIndexMappings mUniformIndexMap;
-
- Vector<GLint> mAttributesLocation;
- bool mUpdateAttributesLocation;
-
- bool mUseBlend:1; ///< True if blending should be enabled, 1 bit is enough
+ CullFaceMode mCullFaceMode:3; ///< cullface enum, 3 bits is enough
};
+} // namespace SceneGraph
+
+} // namespace Internal
-} // SceneGraph
-} // Internal
-} // Dali
+} // namespace Dali
-#endif // __DALI_INTERNAL_SCENE_GRAPH_NEW_RENDERER_H__
+#endif // __DALI_INTERNAL_RENDER_RENDERER_H__
--- /dev/null
+#ifndef DALI_INTERNAL_RENDER_SAMPLER_H
+#define DALI_INTERNAL_RENDER_SAMPLER_H
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <dali/public-api/actors/sampling.h>
+#include <dali/devel-api/rendering/sampler.h>
+#include <dali/internal/render/renderers/render-sampler.h>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Render
+{
+class Sampler
+{
+public:
+ typedef Dali::FilterMode::Type FilterMode;
+ typedef Dali::WrapMode::Type WrapMode;
+
+ /**
+ * Constructor
+ */
+ Sampler()
+ : mMinFilter( Dali::FilterMode::DEFAULT ),
+ mMagFilter( Dali::FilterMode::DEFAULT ),
+ mUWrapMode( Dali::WrapMode::DEFAULT ),
+ mVWrapMode( Dali::WrapMode::DEFAULT )
+ {}
+
+ /**
+ * Destructor
+ */
+ ~Sampler()
+ {}
+
+ /**
+ * Set the filter modes for minify and magnify filters
+ * @param[in] bufferIndex The buffer index to use
+ * @param[in] minFilter The minify filter
+ * @param[in] magFilter The magnify filter
+ */
+ void SetFilterMode(FilterMode minFilter, FilterMode magFilter )
+ {
+ mMinFilter = minFilter;
+ mMagFilter = magFilter;
+ }
+
+ /**
+ * @param[in] bufferIndex The buffer index to use
+ */
+ void SetWrapMode(WrapMode uWrap, WrapMode vWrap )
+ {
+ mUWrapMode = uWrap;
+ mVWrapMode = vWrap;
+ }
+
+public:
+
+ /**
+ * Get the filter mode
+ * @return The minify filter mode
+ */
+ FilterMode GetMinifyFilterMode() const
+ {
+ return mMinFilter;
+ }
+
+ /**
+ * Get the filter mode
+ * @return The magnify filter mode
+ */
+ FilterMode GetMagnifyFilterMode() const
+ {
+ return mMagFilter;
+ }
+
+ /**
+ * Get the horizontal wrap mode
+ * @return The horizontal wrap mode
+ */
+ WrapMode GetUWrapMode() const
+ {
+ return mUWrapMode;
+ }
+
+ /**
+ * Get the vertical wrap mode
+ * @return The vertical wrap mode
+ */
+ WrapMode GetVWrapMode() const
+ {
+ return mVWrapMode;
+ }
+
+private:
+
+ FilterMode mMinFilter; ///< The minify filter
+ FilterMode mMagFilter; ///< The magnify filter
+ WrapMode mUWrapMode; ///< The horizontal wrap mode
+ WrapMode mVWrapMode; ///< The vertical wrap mode
+
+};
+
+} // namespace Render
+
+} // namespace Internal
+
+} // namespace Dali
+
+
+#endif // DALI_INTERNAL_RENDER_SAMPLER_H
--- /dev/null
+#ifndef DALI_INTERNAL_RENDER_TEXTURE_H
+#define DALI_INTERNAL_RENDER_TEXTURE_H
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <dali/devel-api/rendering/sampler.h>
+#include <dali/integration-api/resource-declarations.h>
+#include <string>
+
+namespace Dali
+{
+namespace Internal
+{
+namespace Render
+{
+class Sampler;
+
+class Texture
+{
+public:
+
+ /**
+ * Constructor
+ */
+ Texture()
+ :mUniformName(),
+ mSampler(0),
+ mTextureId(Integration::InvalidResourceId)
+ {}
+
+ /**
+ * Constructor
+ */
+ Texture( const std::string& samplerName, Integration::ResourceId textureId, Render::Sampler* sampler )
+ :mUniformName( samplerName ),
+ mSampler( sampler ),
+ mTextureId( textureId)
+ {}
+
+ /**
+ * Destructor
+ */
+ ~Texture()
+ {}
+
+ /*
+ * Get the Render::Sampler used by the texture
+ * @Return The Render::Sampler being used or 0 if using the default
+ */
+ inline const Render::Sampler* GetSampler() const
+ {
+ return mSampler;
+ }
+
+public: // called from RenderThread
+
+ /**
+ * Get the texture unit uniform name
+ * @return the name of the texture unit uniform
+ */
+ inline const std::string& GetUniformName() const
+ {
+ return mUniformName;
+ }
+
+ /**
+ * Get the texture ID
+ * @param[in] bufferIndex The buffer index to use
+ * @return the identity of the associated texture
+ */
+ inline Integration::ResourceId GetTextureId() const
+ {
+ return mTextureId;
+ }
+
+private:
+ std::string mUniformName;
+ Render::Sampler* mSampler;
+ Integration::ResourceId mTextureId;
+};
+
+} // namespace SceneGraph
+
+} // namespace Internal
+} // namespace Dali
+
+
+#endif // DALI_INTERNAL_RENDER_TEXTURE_H
+++ /dev/null
-/*
- * 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.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "scene-graph-renderer-debug.h"
-#include <dali/internal/common/shader-data.h>
-#include <dali/integration-api/resource-declarations.h>
-#include <dali/internal/render/shaders/program.h>
-#include <dali/internal/render/gl-resources/context.h>
-#include <dali/internal/render/data-providers/node-data-provider.h>
-#include <dali/internal/render/gl-resources/gpu-buffer.h>
-
-namespace Dali
-{
-namespace Internal
-{
-namespace SceneGraph
-{
-
-namespace
-{
-/* rewritten in another patch
-#if defined ( DEBUG_ENABLED )
-
-// Create shader for debug drawing
-const std::string DEBUG_DRAW_VERTEX_SHADER(
- "attribute mediump vec3 aPosition;\n"
- "uniform mediump mat4 uMvpMatrix;\n"
- "void main()\n"
- "{\n"
- " gl_Position = uMvpMatrix * vec4(aPosition, 1.0);\n"
- "}\n" );
-
-const std::string DEBUG_DRAW_FRAGMENT_SHADER(
- "uniform lowp vec4 uColor;\n"
- "void main()\n"
- "{\n"
- " gl_FragColor = uColor;\n"
- "}\n" );
-
-static Program* gDebugProgram(NULL); ///< a simple debug shader
-
-#endif
-*/
-} // anonymous namespace
-
-void DebugBoundingBox(Context& context, Rect<float> boundingBox, const Matrix& mvp)
-{
-/* rewritten in another patch
-#if defined ( DEBUG_ENABLED )
- if( gDebugProgram == NULL )
- {
- Internal::ShaderDataPtr shaderData( new Internal::ShaderData( DEBUG_DRAW_VERTEX_SHADER, DEBUG_DRAW_FRAGMENT_SHADER ) );
- gDebugProgram = Program::New( shaderData.Get(), context, true );
- }
-
- context.SetBlend( false );
- context.CullFace( CullNone );
-
- const unsigned int numPoints=8;
- GLfloat vertices[numPoints*3] = {
- boundingBox.x, boundingBox.y, 0.0f,
- boundingBox.x, boundingBox.y + boundingBox.height, 0.0f,
-
- boundingBox.x, boundingBox.y + boundingBox.height, 0.0f,
- boundingBox.x + boundingBox.width, boundingBox.y + boundingBox.height, 0.0f,
-
- boundingBox.x + boundingBox.width, boundingBox.y + boundingBox.height, 0.0f,
- boundingBox.x + boundingBox.width, boundingBox.y, 0.0f,
-
- boundingBox.x + boundingBox.width, boundingBox.y, 0.0f,
- boundingBox.x, boundingBox.y, 0.0f,
- };
-
- gDebugProgram->Use();
-
- GpuBuffer vertexBuffer(context,GpuBuffer::ARRAY_BUFFER, GpuBuffer::STATIC_DRAW);
- vertexBuffer.UpdateDataBuffer(numPoints * 3 * sizeof(float), &vertices[0]);
- vertexBuffer.Bind();
-
- GLint positionLoc = gDebugProgram->GetAttribLocation(Program::ATTRIB_POSITION);
- context.VertexAttribPointer( positionLoc, 3, GL_FLOAT, GL_FALSE, 3*sizeof(float), 0 );
- context.EnableVertexAttributeArray( positionLoc );
-
- GLint mvpLoc = gDebugProgram->GetUniformLocation(Program::UNIFORM_MVP_MATRIX);
- if( mvpLoc != Program::UNIFORM_UNKNOWN )
- {
- gDebugProgram->SetUniformMatrix4fv( mvpLoc, 1, mvp.AsFloat() );
- }
- GLint colorLoc = gDebugProgram->GetUniformLocation(Program::UNIFORM_COLOR);
- if( colorLoc != Program::UNIFORM_UNKNOWN )
- {
- gDebugProgram->SetUniform4f( colorLoc, 0.0f, 1.0f, 1.0f, 1.0f );
- }
-
- context.DrawArrays(GL_LINES, 0, numPoints);
-
- context.DisableVertexAttributeArray( positionLoc );
-#endif
-*/
-}
-
-
-} // SceneGraph
-} // Internal
-} // Dali
+++ /dev/null
-#ifndef __DALI_INTERNAL_SCENEGRAPH_RENDERER_DEBUG_H__
-#define __DALI_INTERNAL_SCENEGRAPH_RENDERER_DEBUG_H__
-
-/*
- * 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.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <dali/public-api/math/matrix.h>
-#include <dali/public-api/math/rect.h>
-
-// Uncomment to debug bounding boxes of objects
-//#define DEBUG_DISPLAY_BOUNDING_BOX 1
-
-namespace Dali
-{
-namespace Internal
-{
-class Context;
-
-namespace SceneGraph
-{
-class NodeDataProvider;
-
-void DebugBoundingBox(Context& context, Rect<float> boundingBox, const Matrix& mvp);
-
-#if defined(DEBUG_ENABLED) && defined(DEBUG_DISPLAY_BOUNDING_BOX)
-#define DEBUG_BOUNDING_BOX( context, boundingBox, mvp ) \
- DebugBoundingBox( context, boundingBox, mvp )
-#else
-#define DEBUG_BOUNDING_BOX( context, boundingBox, mvp )
-#endif
-
-} // SceneGraph
-} // Internal
-} // Dali
-
-
-#endif // __DALI_INTERNAL_SCENEGRAPH_RENDERER_DEBUG_H__
*/
// INTERNAL INCLUDES
-#include <dali/internal/common/owner-container.h>
+#include <dali/devel-api/common/owner-container.h>
#include <dali/internal/render/shaders/program.h>
#include <dali/internal/render/shaders/program-cache.h>
"uViewMatrix", // UNIFORM_VIEW_MATRIX,
"uNormalMatrix", // UNIFORM_NORMAL_MATRIX
"uColor", // UNIFORM_COLOR
- "uCustomTextureCoords", // UNIFORM_CUSTOM_TEXTURE_COORDS
"sTexture", // UNIFORM_SAMPLER
"sTextureRect", // UNIFORM_SAMPLER_RECT
"sEffect", // UNIFORM_EFFECT_SAMPLER
- "sEffectRect", // UNIFORM_EFFECT_SAMPLER_RECT
- "uTimeDelta", // UNIFORM_TIME_DELTA
- "sOpacityTexture", // UNIFORM_SAMPLER_OPACITY
- "sNormalMapTexture", // UNIFORM_SAMPLER_NORMAL_MAP
"uSize" // UNIFORM_SIZE
};
CHECK_GL( mGlAbstraction, mGlAbstraction.Uniform2f( location, value0, value1 ) );
}
+void Program::SetSizeUniform3f( GLint location, GLfloat value0, GLfloat value1, GLfloat value2 )
+{
+ if( ( fabsf(value0 - mSizeUniformCache.x) >= Math::MACHINE_EPSILON_1 )||
+ ( fabsf(value1 - mSizeUniformCache.y) >= Math::MACHINE_EPSILON_1 )||
+ ( fabsf(value2 - mSizeUniformCache.z) >= Math::MACHINE_EPSILON_1 ) )
+ {
+ mSizeUniformCache.x = value0;
+ mSizeUniformCache.y = value1;
+ mSizeUniformCache.z = value2;
+ SetUniform3f( location, value0, value1, value2 );
+ }
+}
+
void Program::SetUniform3f( GLint location, GLfloat value0, GLfloat value1, GLfloat value2 )
{
DALI_ASSERT_DEBUG( IsUsed() ); // should not call this if this program is not used
mUniformLocations[ i ].second = UNIFORM_NOT_QUERIED;
}
- // reset uniform cache
+ // reset uniform caches
+ mSizeUniformCache.x = mSizeUniformCache.y = mSizeUniformCache.z = 0.f;
+
for( int i = 0; i < MAX_UNIFORM_CACHE_SIZE; ++i )
{
// GL initializes uniforms to 0
UNIFORM_VIEW_MATRIX,
UNIFORM_NORMAL_MATRIX,
UNIFORM_COLOR,
- UNIFORM_CUSTOM_TEXTURE_COORDS,
UNIFORM_SAMPLER,
UNIFORM_SAMPLER_RECT,
UNIFORM_EFFECT_SAMPLER,
- UNIFORM_EFFECT_SAMPLER_RECT,
- UNIFORM_TIME_DELTA,
- UNIFORM_SAMPLER_OPACITY,
- UNIFORM_SAMPLER_NORMAL_MAP,
UNIFORM_SIZE,
UNIFORM_TYPE_LAST
void SetUniform2f( GLint location, GLfloat value0, GLfloat value1 );
/**
+ * Special handling for size as we're using uniform geometry so size is passed on to most programs
+ * but it rarely changes so we can cache it
+ * @param [in] location of uniform
+ * @param [in] value0 as float
+ * @param [in] value1 as float
+ * @param [in] value2 as float
+ */
+ void SetSizeUniform3f( GLint location, GLfloat value0, GLfloat value1, GLfloat value2 );
+
+ /**
* Sets the uniform value
* @param [in] location of uniform
* @param [in] value0 as float
GLint mUniformCacheInt[ MAX_UNIFORM_CACHE_SIZE ]; ///< Value cache for uniforms of single int
GLfloat mUniformCacheFloat[ MAX_UNIFORM_CACHE_SIZE ]; ///< Value cache for uniforms of single float
GLfloat mUniformCacheFloat4[ MAX_UNIFORM_CACHE_SIZE ][4]; ///< Value cache for uniforms of four float
+ Vector3 mSizeUniformCache; ///< Cache value for size uniform
bool mModifiesGeometry; ///< True if the program changes geometry
};
{
mPlayRange = range;
- //Make sure mElapsedSeconds is within the new range
- mElapsedSeconds = Dali::Clamp(mElapsedSeconds, mPlayRange.x*mDurationSeconds , mPlayRange.y*mDurationSeconds );
+ // Make sure mElapsedSeconds is within the new range
+
+ if( mState == Stopped )
+ {
+ // Ensure that the animation starts at the right place
+ mElapsedSeconds = mPlayRange.x * mDurationSeconds;
+ }
+ else
+ {
+ // If already past the end of the range, but before end of duration, then clamp will
+ // ensure that the animation stops on the next update.
+ // If not yet at the start of the range, clamping will jump to the start
+ mElapsedSeconds = Dali::Clamp(mElapsedSeconds, mPlayRange.x*mDurationSeconds , mPlayRange.y*mDurationSeconds );
+ }
}
void Animation::Play()
void Animation::PlayFrom( float progress )
{
- //If the animation is already playing this has no effect
+ // If the animation is already playing this has no effect
+ // Progress is guaranteed to be in range.
if( mState != Playing )
{
mElapsedSeconds = progress * mDurationSeconds;
Vector2 playRangeSeconds = mPlayRange * mDurationSeconds;
if (mLooping)
{
- if (mElapsedSeconds > playRangeSeconds.y )
+ if ( mElapsedSeconds > playRangeSeconds.y )
{
- mElapsedSeconds = playRangeSeconds.x + fmod(mElapsedSeconds, playRangeSeconds.y);
+ mElapsedSeconds = playRangeSeconds.x + fmodf( ( mElapsedSeconds - playRangeSeconds.x ), ( playRangeSeconds.y - playRangeSeconds.x ) );
}
else if( mElapsedSeconds < playRangeSeconds.x )
{
- mElapsedSeconds = playRangeSeconds.y - fmod(mElapsedSeconds, playRangeSeconds.y);
+ mElapsedSeconds = playRangeSeconds.y - fmodf( ( playRangeSeconds.x - mElapsedSeconds ), ( playRangeSeconds.y - playRangeSeconds.x ) );
}
}
void Animation::UpdateAnimators( BufferIndex bufferIndex, bool bake, bool animationFinished )
{
- float elapsedSecondsClamped = Clamp( mElapsedSeconds, mPlayRange.x * mDurationSeconds,mPlayRange.y * mDurationSeconds );
+ const Vector2 playRange( mPlayRange * mDurationSeconds );
+ float elapsedSecondsClamped = Clamp( mElapsedSeconds, playRange.x, playRange.y );
//Loop through all animators
bool applied(true);
{
if( animator->IsEnabled() )
{
- const float initialDelay(animator->GetInitialDelay());
- if (elapsedSecondsClamped >= initialDelay || mSpeedFactor < 0.0f )
+ const float initialDelay( animator->GetInitialDelay() );
+ if( elapsedSecondsClamped >= initialDelay )
{
// Calculate a progress specific to each individual animator
float progress(1.0f);
*/
// INTERNAL INCLUDES
-#include <dali/internal/common/owner-container.h>
+#include <dali/devel-api/common/owner-container.h>
#include <dali/internal/event/animation/key-frames-impl.h>
#include <dali/internal/event/animation/path-impl.h>
#include <dali/internal/update/nodes/node.h>
* An abstract base class for Constraints.
* This can be used to constrain a property of a scene-object, after animations have been applied.
*/
-class ConstraintBase : public PropertyOwner, public PropertyOwner::Observer
+class ConstraintBase : public PropertyOwner::Observer
{
public:
*/
// INTERNAL INCLUDES
-#include <dali/internal/common/owner-container.h>
+#include <dali/devel-api/common/owner-container.h>
#include <dali/internal/update/nodes/node-declarations.h>
namespace Dali
#include <dali/internal/update/nodes/node.h>
#include <dali/internal/render/queue/render-queue.h>
#include <dali/internal/update/node-attachments/scene-graph-renderable-attachment.h>
-#include <dali/internal/render/renderers/scene-graph-renderer.h>
+#include <dali/internal/render/renderers/render-renderer.h>
#include <dali/internal/render/shaders/scene-graph-shader.h>
namespace Dali
}
}
+void DiscardQueue::Add( BufferIndex updateBufferIndex, Renderer* renderer )
+{
+ DALI_ASSERT_DEBUG( NULL != 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
+ if ( 0u == updateBufferIndex )
+ {
+ mRendererQueue0.PushBack( renderer );
+ }
+ else
+ {
+ mRendererQueue1.PushBack( renderer );
+ }
+}
+
void DiscardQueue::Add( BufferIndex updateBufferIndex, NodeAttachment* attachment )
{
DALI_ASSERT_DEBUG( NULL != attachment );
}
}
-void DiscardQueue::Add( BufferIndex updateBufferIndex, Sampler* sampler )
-{
- DALI_ASSERT_DEBUG( NULL != sampler );
-
- if ( 0u == updateBufferIndex )
- {
- mSamplerQueue0.PushBack( sampler );
- }
- else
- {
- mSamplerQueue1.PushBack( sampler );
- }
-}
-
-void DiscardQueue::Add( BufferIndex updateBufferIndex, PropertyBuffer* propertyBuffer )
-{
- DALI_ASSERT_DEBUG( NULL != propertyBuffer );
-
- if ( 0u == updateBufferIndex )
- {
- mPropertyBufferQueue0.PushBack( propertyBuffer );
- }
- else
- {
- mPropertyBufferQueue1.PushBack( propertyBuffer );
- }
-}
-
void DiscardQueue::Clear( BufferIndex updateBufferIndex )
{
// Destroy some discarded objects; these should no longer own any GL resources
mShaderQueue0.Clear();
mGeometryQueue0.Clear();
mMaterialQueue0.Clear();
- mSamplerQueue0.Clear();
- mPropertyBufferQueue0.Clear();
+ mRendererQueue0.Clear();
}
else
{
mShaderQueue1.Clear();
mGeometryQueue1.Clear();
mMaterialQueue1.Clear();
- mSamplerQueue1.Clear();
- mPropertyBufferQueue1.Clear();
+ mRendererQueue1.Clear();
}
}
// INTERNAL INCLUDES
#include <dali/public-api/object/ref-object.h>
+#include <dali/devel-api/common/owner-container.h>
#include <dali/internal/common/buffer-index.h>
-#include <dali/internal/common/owner-container.h>
#include <dali/internal/update/nodes/node-declarations.h>
#include <dali/internal/update/node-attachments/node-attachment-declarations.h>
-#include <dali/internal/update/common/scene-graph-property-buffer.h>
#include <dali/internal/update/rendering/scene-graph-geometry.h>
#include <dali/internal/update/rendering/scene-graph-material.h>
-#include <dali/internal/update/rendering/scene-graph-sampler.h>
+#include <dali/internal/update/rendering/scene-graph-renderer.h>
namespace Dali
{
typedef OwnerContainer< Shader* > ShaderQueue;
typedef OwnerContainer< Geometry* > GeometryQueue;
typedef OwnerContainer< Material* > MaterialQueue;
- typedef OwnerContainer< Sampler* > SamplerQueue;
- typedef OwnerContainer< PropertyBuffer* > PropertyBufferQueue;
+ typedef OwnerContainer< Renderer* > RendererQueue;
/**
* Create a new DiscardQueue.
* Adds an unwanted material to the discard queue.
* A message will be sent to clean up GL resources in the next Render.
*/
- void Add( BufferIndex updateBufferIndex, PropertyBuffer* material );
-
- /**
- * Adds an unwanted material to the discard queue.
- * A message will be sent to clean up GL resources in the next Render.
- */
void Add( BufferIndex updateBufferIndex, Material* material );
/**
- * Adds an unwanted material to the discard queue.
- * A message will be sent to clean up GL resources in the next Render.
- */
- void Add( BufferIndex updateBufferIndex, Sampler* material );
-
- /**
* Adds an unwanted shader to the discard queue.
* A message will be sent to clean-up GL resources in the next Render.
* @pre This method is not thread-safe, and should only be called from the update-thread.
void Add( BufferIndex bufferIndex, Shader* shader );
/**
+ * Adds an unwanted Renderer to the discard queue.
+ * A message will be sent to clean up GL resources in the next Render.
+ * @param[in] updateBufferIndex The current update buffer index.
+ * @param[in] renderer The discarded renderer; DiscardQueue takes ownership.
+ */
+ void Add( BufferIndex updateBufferIndex, Renderer* renderer );
+
+ /**
* Release the nodes which were queued in the frame N-2.
* @pre This method should be called (once) at the beginning of every Update.
* @param[in] updateBufferIndex The current update buffer index.
ShaderQueue mShaderQueue0;
GeometryQueue mGeometryQueue0;
MaterialQueue mMaterialQueue0;
- SamplerQueue mSamplerQueue0;
- PropertyBufferQueue mPropertyBufferQueue0;
+ RendererQueue mRendererQueue0;
// Messages are queued here when the update buffer index == 1
NodeOwnerContainer mNodeQueue1;
ShaderQueue mShaderQueue1;
GeometryQueue mGeometryQueue1;
MaterialQueue mMaterialQueue1;
- SamplerQueue mSamplerQueue1;
- PropertyBufferQueue mPropertyBufferQueue1;
+ RendererQueue mRendererQueue1;
};
} // namespace SceneGraph
}
/**
- * @copydoc Dali::PropertyInput::GetQuaternion()
- */
- virtual const Quaternion& GetQuaternion() const
- {
- DALI_ASSERT_ALWAYS( false && "Property type mismatch" );
- return DUMMY_QUATERNION_VALUE;
- }
-
- /**
- * @copydoc Dali::PropertyInput::GetQuaternion()
- */
- virtual const Quaternion& GetQuaternion( BufferIndex bufferIndex ) const
- {
- DALI_ASSERT_ALWAYS( false && "Property type mismatch" );
- return DUMMY_QUATERNION_VALUE;
- }
-
- /**
* Set the property value. This will only persist for the current frame; the property
* will be reset with the base value, at the beginning of the next frame.
* @param[in] bufferIndex The buffer to write.
// INTERNAL INCLUDES
#include <dali/public-api/common/dali-vector.h>
+#include <dali/devel-api/common/owner-container.h>
#include <dali/internal/common/message.h>
-#include <dali/internal/common/owner-container.h>
#include <dali/internal/update/common/property-base.h>
#include <dali/internal/update/common/scene-graph-buffers.h>
#include <dali/internal/update/common/uniform-map.h>
/**
* @copydoc UniformMap::Add
*/
- void AddUniformMapping( UniformPropertyMapping* map );
+ virtual void AddUniformMapping( UniformPropertyMapping* map );
/**
* @copydoc UniformMap::Remove
*/
- void RemoveUniformMapping( const std::string& uniformName );
+ virtual void RemoveUniformMapping( const std::string& uniformName );
/**
* Get the mappings table
}
}
+void ConnectionChangePropagator::Destroy( PropertyOwner& object )
+{
+ // Inform observers that the object's children have changed
+ for( ObserversIterator iter = mObservers.Begin(); iter != mObservers.End(); ++iter )
+ {
+ Observer* observer = (*iter);
+ observer->ObservedObjectDestroyed( object );
+ }
+}
+
} // SceneGraph
} // Internal
} // Dali
* changed it's uniform map in some way.
*/
virtual void ConnectedUniformMapChanged() = 0;
+
+ /**
+ * Inform the observer of the object that the object is about to be destroyed
+ */
+ virtual void ObservedObjectDestroyed(PropertyOwner& object){}
};
/**
*/
void ConnectedUniformMapChanged();
+ /**
+ * Inform the observers that the object is about to be destroyed
+ * @param[in] object The connection owner
+ */
+ void Destroy( PropertyOwner& object );
+
private:
typedef Dali::Vector<Observer*> Observers;
typedef Observers::Iterator ObserversIterator;
+++ /dev/null
-/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <dali/internal/update/common/scene-graph-property-buffer.h>
-
-namespace Dali
-{
-namespace Internal
-{
-namespace SceneGraph
-{
-
-PropertyBuffer::PropertyBuffer()
-: mBufferData(NULL),
- mDataChanged(false),
- mSize(0u)
-{
-}
-
-PropertyBuffer::~PropertyBuffer()
-{
-}
-
-void PropertyBuffer::SetFormat( PropertyBufferMetadata::Format* format )
-{
- mFormat = format;
-}
-
-void PropertyBuffer::SetSize( BufferIndex bufferIndex, unsigned int size )
-{
- mSize.Set(bufferIndex, size);
-}
-
-void PropertyBuffer::SetData( BufferIndex bufferIndex, PropertyBufferDataProvider::BufferType* data )
-{
- mBufferData[bufferIndex] = data;
- mDataChanged[bufferIndex] = true;
-}
-
-void PropertyBuffer::ConnectToSceneGraph( SceneController& sceneController, BufferIndex bufferIndex )
-{
-}
-
-void PropertyBuffer::DisconnectFromSceneGraph( SceneController& sceneController, BufferIndex bufferIndex )
-{
-}
-
-bool PropertyBuffer::HasDataChanged( BufferIndex bufferIndex ) const
-{
- return mDataChanged[ bufferIndex ];
-}
-
-unsigned int PropertyBuffer::GetAttributeCount( BufferIndex bufferIndex ) const
-{
- DALI_ASSERT_DEBUG( mFormat && "Format should be set ");
- return mFormat->components.size();
-}
-
-const std::string& PropertyBuffer::GetAttributeName( BufferIndex bufferIndex, unsigned int index ) const
-{
- DALI_ASSERT_DEBUG( mFormat && "Format should be set ");
- return mFormat->components[index].name;
-}
-
-size_t PropertyBuffer::GetAttributeSize( BufferIndex bufferIndex, unsigned int index ) const
-{
- DALI_ASSERT_DEBUG( mFormat && "Format should be set ");
-
- return mFormat->components[index].size;
-}
-
-Property::Type PropertyBuffer::GetAttributeType( BufferIndex bufferIndex, unsigned int index ) const
-{
- DALI_ASSERT_DEBUG( mFormat && "Format should be set ");
-
- return mFormat->components[index].type;
-}
-
-size_t PropertyBuffer::GetAttributeOffset( BufferIndex bufferIndex, unsigned int index ) const
-{
- DALI_ASSERT_DEBUG( mFormat && "Format should be set ");
-
- return mFormat->components[index].offset;
-}
-
-const PropertyBufferDataProvider::BufferType& PropertyBuffer::GetData( BufferIndex bufferIndex ) const
-{
- DALI_ASSERT_DEBUG( mBufferData[bufferIndex] && "Should have some data.");
-
- return *mBufferData[bufferIndex];
-}
-
-std::size_t PropertyBuffer::GetDataSize( BufferIndex bufferIndex ) const
-{
- DALI_ASSERT_DEBUG( mFormat && "Format should be set ");
-
- return mFormat->size * mSize[ bufferIndex ];
-}
-
-
-std::size_t PropertyBuffer::GetElementSize( BufferIndex bufferIndex ) const
-{
- return mFormat->size;
-}
-
-unsigned int PropertyBuffer::GetElementCount( BufferIndex bufferIndex ) const
-{
- return mSize[bufferIndex];
-}
-
-unsigned int PropertyBuffer::GetGpuBufferId( BufferIndex bufferIndex ) const
-{
- //TODO: MESH_REWORK fix this
- DALI_ASSERT_DEBUG(false && "FIX THIS");
-
- return 0;
-}
-
-void PropertyBuffer::ResetDefaultProperties( BufferIndex updateBufferIndex )
-{
- // Age the double buffered properties
- mSize.CopyPrevious(updateBufferIndex);
-
- // Update double buffered value
- mBufferData.CopyPrevious(updateBufferIndex);
-
- // The flag should be reset each frame
- mDataChanged[updateBufferIndex] = false;
-}
-
-} // namespace SceneGraph
-} // namespace Internal
-} // namespace Dali
+++ /dev/null
-#ifndef DALI_INTERNAL_SCENE_GRAPH_PROPERTY_BUFFER_H
-#define DALI_INTERNAL_SCENE_GRAPH_PROPERTY_BUFFER_H
-
-/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <dali/internal/common/buffer-index.h>
-#include <dali/internal/event/common/event-thread-services.h>
-#include <dali/internal/update/common/double-buffered-property.h>
-#include <dali/internal/update/common/property-owner.h>
-#include <dali/internal/render/data-providers/property-buffer-data-provider.h>
-
-namespace Dali
-{
-namespace Internal
-{
-namespace SceneGraph
-{
-class SceneController;
-
-namespace PropertyBufferMetadata
-{
-/**
- * Structure that holds name and size of a component in the PropertyBuffer.
- */
-struct Component
-{
- std::string name;
- unsigned int offset;
- unsigned int size;
- Property::Type type;
-};
-
-/**
- * Structure that holds the meta-data of the format of PropertyBuffer.
- */
-struct Format
-{
- std::vector<Component> components;
- unsigned int size;
-};
-
-} // PropertyBufferMetadata
-
-class PropertyBuffer : public PropertyOwner, public PropertyBufferDataProvider
-{
-public:
-
- /**
- * Constructor
- */
- PropertyBuffer();
-
- /**
- * Destructor
- */
- virtual ~PropertyBuffer();
-
- /**
- * @brief Set the format of the buffer
- *
- * This function takes ownership of the pointer
- *
- * @param[in] format The format for the PropertyBuffer
- */
- void SetFormat( PropertyBufferMetadata::Format* format );
-
- /**
- * @brief Set the data of the PropertyBuffer
- *
- * This function takes ownership of the pointer
- *
- * @param[in] bufferIndex Index for double buffered values
- * @param[in] data The new data of the PropertyBuffer
- */
- void SetData( BufferIndex bufferIndex, PropertyBufferDataProvider::BufferType* data );
-
- /**
- * @brief Set the number of elements
- *
- * @param[in] bufferIndex Index for double buffered values
- * @param[in] size The number of elements
- */
- void SetSize( BufferIndex bufferIndex, unsigned int size );
-
- /**
- * @brief Connect the object to the scene graph
- *
- * @param[in] sceneController The scene controller - used for sending messages to render thread
- * @param[in] bufferIndex The current buffer index - used for sending messages to render thread
- */
- void ConnectToSceneGraph( SceneController& sceneController, BufferIndex bufferIndex );
-
- /**
- * @brief Disconnect the object from the scene graph
- */
- void DisconnectFromSceneGraph( SceneController& sceneController, BufferIndex bufferIndex );
-
-public: // PropertyBufferDataProvider
-
- /**
- * @copydoc PropertyBufferDataProvider::HasDataChanged( BufferIndex bufferIndex )
- */
- virtual bool HasDataChanged( BufferIndex bufferIndex ) const;
-
- /**
- * @copydoc PropertyBufferDataProvider::HasDataChanged( BufferIndex bufferIndex )
- */
- virtual unsigned int GetAttributeCount( BufferIndex bufferIndex ) const;
-
- /**
- * @copydoc PropertyBufferDataProvider::GetAttributeName( BufferIndex bufferIndex, unsigned int index )
- */
- virtual const std::string& GetAttributeName( BufferIndex bufferIndex, unsigned int index ) const;
-
- /**
- * @copydoc PropertyBufferDataProvider::GetAttributeSize( BufferIndex bufferIndex, unsigned int index )
- */
- virtual size_t GetAttributeSize( BufferIndex bufferIndex, unsigned int index ) const;
-
- /**
- * @copydoc PropertyBufferDataProvider::GetAttributeType( BufferIndex bufferIndex, unsigned int index )
- */
- virtual Property::Type GetAttributeType( BufferIndex bufferIndex, unsigned int index ) const;
-
- /**
- * @copydoc PropertyBufferDataProvider::GetAttributeOffset( BufferIndex bufferIndex, unsigned int index )
- */
- virtual size_t GetAttributeOffset( BufferIndex bufferIndex, unsigned int index ) const;
-
- /**
- * @copydoc PropertyBufferDataProvider::GetData( BufferIndex bufferIndex )
- */
- virtual const PropertyBufferDataProvider::BufferType& GetData( BufferIndex bufferIndex ) const;
-
- /**
- * @copydoc PropertyBufferDataProvider::GetDataSize( BufferIndex bufferIndex )
- */
- virtual size_t GetDataSize( BufferIndex bufferIndex ) const;
-
- /**
- * @copydoc PropertyBufferDataProvider::GetElementSize( BufferIndex bufferIndex )
- */
- virtual size_t GetElementSize( BufferIndex bufferIndex ) const;
-
- /**
- * @copydoc PropertyBufferDataProvider::GetElementCount( BufferIndex bufferIndex )
- */
- virtual unsigned int GetElementCount( BufferIndex bufferIndex ) const;
-
- /**
- * @copydoc PropertyBufferDataProvider::GetGpuBufferId
- */
- virtual unsigned int GetGpuBufferId( BufferIndex bufferIndex ) const;
-
-protected: // From PropertyOwner
- /**
- * @copydoc Dali::Internal::SceneGraph::PropertyOwner::ResetDefaultProperties()
- */
- virtual void ResetDefaultProperties( BufferIndex updateBufferIndex );
-
-private:
- OwnerPointer<PropertyBufferMetadata::Format> mFormat; ///< Format of the buffer
-
- DoubleBuffered< OwnerPointer<PropertyBufferDataProvider::BufferType> > mBufferData; ///< Data
- DoubleBuffered< bool > mDataChanged; ///< Flag to know if data has changed in a frame
-
- DoubleBufferedProperty<int> mSize; ///< Number of Elements in the buffer
-};
-
-inline void SetFormatMessage( EventThreadServices& eventThreadServices,
- const PropertyBuffer& propertyBuffer,
- PropertyBufferMetadata::Format* format )
-{
- typedef MessageValue1< PropertyBuffer, OwnerPointer<PropertyBufferMetadata::Format> > 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( &propertyBuffer, &PropertyBuffer::SetFormat, format );
-}
-
-inline void SetSizeMessage( EventThreadServices& eventThreadServices,
- const PropertyBuffer& propertyBuffer,
- unsigned int size )
-{
- typedef MessageDoubleBuffered1 < PropertyBuffer, unsigned int > LocalType;
-
- // Reserve some memory inside the message queue
- unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
-
- // Construct message in the message queue memory; note that delete should not be called on the return value
- new (slot) LocalType( &propertyBuffer, &PropertyBuffer::SetSize, size );
-}
-
-inline void SetDataMessage( EventThreadServices& eventThreadServices,
- const PropertyBuffer& propertyBuffer,
- PropertyBuffer::BufferType* data )
-{
- typedef MessageDoubleBuffered1< PropertyBuffer, OwnerPointer<PropertyBuffer::BufferType> > 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( &propertyBuffer, &PropertyBuffer::SetData, data );
-}
-
-} // namespace SceneGraph
-} // namespace Internal
-} // namespace Dali
-
-#endif // DALI_INTERNAL_SCENE_GRAPH_PROPERTY_BUFFER_H
// INTERNAL INCLUDES
#include <dali/public-api/object/property-notification.h>
+#include <dali/devel-api/common/owner-container.h>
#include <dali/internal/event/common/property-notification-impl.h>
#include <dali/internal/update/common/property-base.h>
-#include <dali/internal/common/owner-container.h>
namespace Dali
{
*/
#include <dali/devel-api/common/hash.h>
-#include <dali/internal/common/owner-container.h>
-
+#include <dali/devel-api/common/owner-container.h>
#include <string>
namespace Dali
{
}
-void RenderMessageDispatcher::AddRenderer( Renderer& renderer )
+void RenderMessageDispatcher::AddRenderer( Render::Renderer& renderer )
{
- typedef MessageValue1< RenderManager, Renderer* > DerivedType;
+ typedef MessageValue1< RenderManager, Render::Renderer* > DerivedType;
// Reserve some memory inside the render queue
unsigned int* slot = mRenderQueue.ReserveMessageSlot( mBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
new (slot) DerivedType( &mRenderManager, &RenderManager::AddRenderer, &renderer );
}
-void RenderMessageDispatcher::RemoveRenderer( Renderer& renderer )
+void RenderMessageDispatcher::RemoveRenderer( Render::Renderer& renderer )
{
- typedef MessageValue1< RenderManager, Renderer* > DerivedType;
+ typedef MessageValue1< RenderManager, Render::Renderer* > DerivedType;
// Reserve some memory inside the render queue
unsigned int* slot = mRenderQueue.ReserveMessageSlot( mBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
new (slot) DerivedType( &mRenderManager, &RenderManager::RemoveRenderer, &renderer );
}
-void RenderMessageDispatcher::AddImageRenderer( ImageRenderer* renderer, NodeDataProvider* dataProvider )
+void RenderMessageDispatcher::AddGeometry( RenderGeometry& renderGeometry )
{
- typedef MessageValue2< RenderManager, ImageRenderer*, NodeDataProvider* > DerivedType;
+ typedef MessageValue1< RenderManager, RenderGeometry* > DerivedType;
// Reserve some memory inside the render queue
unsigned int* slot = mRenderQueue.ReserveMessageSlot( mBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
// Construct message in the render queue memory; note that delete should not be called on the return value
- new (slot) DerivedType( &mRenderManager, &RenderManager::AddImageRenderer, renderer, dataProvider );
+ new (slot) DerivedType( &mRenderManager, &RenderManager::AddGeometry, &renderGeometry );
}
-void RenderMessageDispatcher::RemoveImageRenderer( ImageRenderer* renderer )
+void RenderMessageDispatcher::RemoveGeometry( RenderGeometry& renderGeometry )
{
- typedef MessageValue1< RenderManager, ImageRenderer* > DerivedType;
+ typedef MessageValue1< RenderManager, RenderGeometry* > DerivedType;
// Reserve some memory inside the render queue
unsigned int* slot = mRenderQueue.ReserveMessageSlot( mBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
// Construct message in the render queue memory; note that delete should not be called on the return value
- new (slot) DerivedType( &mRenderManager, &RenderManager::RemoveImageRenderer, renderer );
+ new (slot) DerivedType( &mRenderManager, &RenderManager::RemoveGeometry, &renderGeometry );
}
-void RenderMessageDispatcher::AddGeometry( RenderGeometry& renderGeometry )
+void RenderMessageDispatcher::AddPropertyBuffer( RenderGeometry& renderGeometry, Render::PropertyBuffer* propertyBuffer, bool isIndexBuffer )
{
- typedef MessageValue1< RenderManager, RenderGeometry* > DerivedType;
+ typedef MessageValue3< RenderManager, RenderGeometry*, Render::PropertyBuffer*, bool > DerivedType;
// Reserve some memory inside the render queue
unsigned int* slot = mRenderQueue.ReserveMessageSlot( mBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
// Construct message in the render queue memory; note that delete should not be called on the return value
- new (slot) DerivedType( &mRenderManager, &RenderManager::AddGeometry, &renderGeometry );
+ new (slot) DerivedType( &mRenderManager, &RenderManager::AddPropertyBuffer, &renderGeometry, propertyBuffer, isIndexBuffer);
}
-void RenderMessageDispatcher::RemoveGeometry( RenderGeometry& renderGeometry )
+void RenderMessageDispatcher::RemovePropertyBuffer( RenderGeometry& renderGeometry, Render::PropertyBuffer* propertyBuffer )
{
- typedef MessageValue1< RenderManager, RenderGeometry* > DerivedType;
+ typedef MessageValue2< RenderManager, RenderGeometry*, Render::PropertyBuffer* > DerivedType;
// Reserve some memory inside the render queue
unsigned int* slot = mRenderQueue.ReserveMessageSlot( mBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
// Construct message in the render queue memory; note that delete should not be called on the return value
- new (slot) DerivedType( &mRenderManager, &RenderManager::RemoveGeometry, &renderGeometry );
+ new (slot) DerivedType( &mRenderManager, &RenderManager::RemovePropertyBuffer, &renderGeometry, propertyBuffer );
}
-void RenderMessageDispatcher::AddPropertyBuffer( RenderGeometry& renderGeometry, PropertyBufferDataProvider* propertyBuffer, GpuBuffer::Target target, GpuBuffer::Usage usage )
+void RenderMessageDispatcher::SetGeometryType( RenderGeometry& geometry, int geometryType )
{
- typedef MessageValue4< RenderManager, RenderGeometry*, PropertyBufferDataProvider*, GpuBuffer::Target, GpuBuffer::Usage > DerivedType;
+ typedef MessageValue2< RenderManager, RenderGeometry*, int > DerivedType;
// Reserve some memory inside the render queue
unsigned int* slot = mRenderQueue.ReserveMessageSlot( mBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
// Construct message in the render queue memory; note that delete should not be called on the return value
- new (slot) DerivedType( &mRenderManager, &RenderManager::AddPropertyBuffer, &renderGeometry, propertyBuffer, target, usage );
+ new (slot) DerivedType( &mRenderManager, &RenderManager::SetGeometryType, &geometry, geometryType );
}
-void RenderMessageDispatcher::RemovePropertyBuffer( RenderGeometry& renderGeometry, PropertyBufferDataProvider* propertyBuffer )
+void RenderMessageDispatcher::SetGeometryRequiresDepthTest( RenderGeometry& geometry, bool requiresDepthTest )
{
- typedef MessageValue2< RenderManager, RenderGeometry*, PropertyBufferDataProvider* > DerivedType;
+ typedef MessageValue2< RenderManager, RenderGeometry*, bool > DerivedType;
// Reserve some memory inside the render queue
unsigned int* slot = mRenderQueue.ReserveMessageSlot( mBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
// Construct message in the render queue memory; note that delete should not be called on the return value
- new (slot) DerivedType( &mRenderManager, &RenderManager::RemovePropertyBuffer, &renderGeometry, propertyBuffer );
+ new (slot) DerivedType( &mRenderManager, &RenderManager::SetGeometryRequiresDepthTest, &geometry, requiresDepthTest );
}
void RenderMessageDispatcher::AddRenderTracker( RenderTracker& renderTracker )
// INTERNAL INCLUDES
#include <dali/internal/update/common/scene-graph-buffers.h>
#include <dali/internal/render/gl-resources/gpu-buffer.h>
+#include <dali/internal/render/renderers/render-property-buffer.h>
namespace Dali
{
{
class MessageBase;
-namespace SceneGraph
+namespace Render
{
class Renderer;
-class ImageRenderer;
-class NodeDataProvider;
+}
+namespace SceneGraph
+{
+
class RenderManager;
class RenderQueue;
class RenderTracker;
* @param[in] renderer The renderer to add.
* @post renderer ownership is transferred.
*/
- void AddRenderer( Renderer& renderer );
+ void AddRenderer( Render::Renderer& renderer );
/**
* Remove a Renderer.
* @param[in] renderer The renderer to remove.
* @post renderer will be destroyed in the next Render.
*/
- void RemoveRenderer( Renderer& renderer );
-
- /**
- * Add an image renderer in the render-thread.
- * @param[in] renderer The renderer to add.
- */
- void AddImageRenderer( ImageRenderer* renderer, NodeDataProvider* dataProvider );
-
- /**
- * Remove an image renderer in the render-thread.
- * @param[in] renderer The renderer to remove.
- */
- void RemoveImageRenderer( ImageRenderer* renderer );
+ void RemoveRenderer( Render::Renderer& renderer );
/**
* Add a Geometry
* Add a PropertyBuffer.
* @param[in] renderGeometry The geometry
* @param[in] propertyBuffer The PropertyBuffer
- * @param[in] target Specifies the type of the buffer
- * @param[in] usage Specifies how will the buffer be used
+ * @param[in] isIndexBuffer True if the buffer is intended to be used as an index buffer
*/
- void AddPropertyBuffer( RenderGeometry& renderGeometry, PropertyBufferDataProvider* propertyBuffer, GpuBuffer::Target target, GpuBuffer::Usage usage );
+ void AddPropertyBuffer( RenderGeometry& renderGeometry, Render::PropertyBuffer* propertyBuffer, bool isIndexBuffer );
/**
* Remove a PropertyBuffer.
* @param[in] propertyBuffer The PropertyBuffer
* @post PropertyBuffer will be destroyed in the next Render.
*/
- void RemovePropertyBuffer( RenderGeometry& renderGeometry, PropertyBufferDataProvider* propertyBuffer );
+ void RemovePropertyBuffer( RenderGeometry& renderGeometry, Render::PropertyBuffer* propertyBuffer );
+
+ /**
+ * Set the geometry type of an existing render geometry
+ * @param[in] geometry The render geometry
+ * @param[in] geometryType The new geometry type
+ */
+ void SetGeometryType( RenderGeometry& geometry, int geometryType );
+
+ /**
+ * Set if an existing geometry requires depth testing
+ * @param[in] geometry The render geometry
+ * @param[in] requiresDepthTest True if depth testing is required, false otherwise
+ */
+ void SetGeometryRequiresDepthTest( RenderGeometry& geometry, bool requiresDepthTest );
/**
* Add a Render tracker.
/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <dali/internal/update/controllers/scene-controller-impl.h>
// INTERNAL INCLUDES
-#include <dali/internal/render/renderers/scene-graph-image-renderer.h>
namespace Dali
{
SceneControllerImpl::~SceneControllerImpl()
{
- // Clean-up renderers
- const unsigned int count( mRendererPool.Count() );
- for( unsigned int i=0; i<count; ++i )
- {
- ImageRenderer* renderer = mRendererPool[i];
- delete renderer;
- }
-}
-
-ImageRenderer* SceneControllerImpl::NewImageRenderer( NodeDataProvider& dataProvider )
-{
- ImageRenderer* renderer( NULL );
-
- if( 0 == mRendererPool.Count() )
- {
- renderer = ImageRenderer::New( dataProvider );
- }
- else
- {
- renderer = mRendererPool[ mRendererPool.Count() - 1 ];
-
- mRendererPool.Erase( mRendererPool.End() - 1 );
- }
-
- return renderer;
-}
-
-void SceneControllerImpl::FreeImageRenderer( ImageRenderer& renderer )
-{
- mRendererPool.PushBack( &renderer );
}
} // namespace SceneGraph
#define __DALI_INTERNAL_SCENE_GRAPH_SCENE_CONTROLLER_IMPL_H__
/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
// INTERNAL INCLUDES
#include <dali/internal/update/controllers/scene-controller.h>
-#include <dali/public-api/common/dali-vector.h>
namespace Dali
{
public: // from SceneController
/**
- * @copydoc SceneController::NewImageRenderer()
- */
- virtual ImageRenderer* NewImageRenderer( NodeDataProvider& dataProvider );
-
- /**
- * @copydoc SceneController::FreeImageRenderer()
- */
- virtual void FreeImageRenderer( ImageRenderer& renderer );
-
- /**
* @copydoc SceneController::GetRenderMessageDispatcher()
*/
virtual RenderMessageDispatcher& GetRenderMessageDispatcher() { return mRenderMessageDispatcher; }
TextureCache& mTextureCache; ///< texture cache
CompleteStatusManager& mCompleteStatusManager; ///< Complete Status manager
- Dali::Vector< ImageRenderer* > mRendererPool;
};
} // namespace SceneGraph
class RenderQueue;
class DiscardQueue;
class TextureCache;
-class ImageRenderer;
-class NodeDataProvider;
/**
* Abstract interface for the scene controller
}
/**
- * Get a reusable renderer from the pool
- * @param[in] dataProvider The node using this renderer
- * @return The renderer
- */
- virtual ImageRenderer* NewImageRenderer( NodeDataProvider& dataProvider ) = 0;
-
- /**
- * Return reusable renderer to the pool
- * @param[in] The renderer
- */
- virtual void FreeImageRenderer( ImageRenderer& renderer ) = 0;
-
- /**
* Return the render message dispatcher
* @return A reference to the render message dispatcher
*/
void PanGesture::AddGesture( const Dali::PanGesture& gesture )
{
- Dali::Mutex::ScopedLock lock( mMutex );
mGestures[ mWritePosition ] = gesture;
// Update our write position.
bool PanGesture::ReadAndResampleGestures( FrameGestureInfo& info, unsigned int currentTimestamp )
{
PanInfo lastReadGesture;
- Dali::Mutex::ScopedLock lock( mMutex );
while( mReadPosition != mWritePosition )
{
// Copy the gesture first
unsigned int eventsThisFrame;
// Copy the events into a linear buffer while holding the mutex.
// This is so the lock is not held while any processing is done.
- Dali::Mutex::ScopedLock lock( mMutex );
for( eventsThisFrame = 0; mReadPosition != mWritePosition; ++eventsThisFrame )
{
mReadGestures[ eventsThisFrame ] = mGestures[ mReadPosition ];
*/
// INTERNAL INCLUDES
-#include <dali/devel-api/common/mutex.h>
#include <dali/public-api/common/vector-wrapper.h>
#include <dali/public-api/events/pan-gesture.h>
#include <dali/internal/update/common/property-owner.h>
RelativeVectors mLastInterpolatedAcceleration; ///< Stores the second interpolated point acceleration value from the last frame.
RelativeVectors mLastInitialAcceleration; ///< Stores the initial acceleration value from the last frame.
- volatile unsigned int mWritePosition; ///< The next PanInfo buffer to write to. (starts at 0).
+ unsigned int mWritePosition; ///< The next PanInfo buffer to write to. (starts at 0).
unsigned int mReadPosition; ///< The next PanInfo buffer to read. (starts at 0).
bool mNotAtTarget; ///< Keeps track of if the last gesture used was the most recent received.
bool mInGesture; ///< True if the gesture is currently being handled i.e. between Started <-> Finished/Cancelled.
bool mSmoothingAmountOverridden;
PanGestureProfiling* mProfiling; ///< NULL unless pan-gesture profiling information is required.
- Dali::Mutex mMutex; ///< Mutex to lock access.
// Environment variables:
float mTwoPointVelocityBias; ///< The ratio of first and second interpolated points to use for velocity. 0.0f = 100% of first point. 1.0f = 100% of second point.
float mTwoPointAccelerationBias; ///< The ratio of first and second interpolated points to use for acceleration. 0.0f = 100% of first point. 1.0f = 100% of second point.
int mMultiTapSmoothingRange; ///< The range in time (ms) of points in the history to smooth the final output against.
-
};
} // namespace SceneGraph
#include <algorithm>
// INTERNAL INCLUDES
-#include <dali/internal/common/owner-container.h>
+#include <dali/devel-api/common/owner-container.h>
#include <dali/internal/update/common/discard-queue.h>
#include <dali/internal/update/controllers/scene-controller.h>
class ObjectOwnerContainer
{
public:
- typedef typename Internal::OwnerContainer< Type* > ObjectContainer;
- typedef typename Internal::OwnerContainer< Type* >::Iterator Iterator;
+ typedef typename Dali::OwnerContainer< Type* > ObjectContainer;
+ typedef typename Dali::OwnerContainer< Type* >::Iterator Iterator;
/**
- * @brief Constructor - createw a new object container
+ * @brief Constructor - create a new object container
*
* Object container own update side objects
*
}
}
+ const ObjectContainer& GetObjectContainer()
+ {
+ return mObjectContainer;
+ }
+
private:
- SceneController* mSceneController; ///< SceneControler used to send messages
+ SceneController* mSceneController; ///< SceneController used to send messages
ObjectContainer mObjectContainer; ///< Container for the objects owned
SceneGraphBuffers& mSceneGraphBuffers; ///< Reference to a SceneGraphBuffers to get the indexBuffer
DiscardQueue& mDiscardQueue; ///< Discard queue used for removed objects
#include <dali/internal/update/manager/sorted-layers.h>
#include <dali/internal/update/node-attachments/scene-graph-renderable-attachment.h>
#include <dali/internal/update/nodes/scene-graph-layer.h>
-#include <dali/internal/render/renderers/scene-graph-renderer.h>
+#include <dali/internal/render/renderers/render-renderer.h>
#include <dali/internal/render/common/render-instruction.h>
#include <dali/internal/render/shaders/scene-graph-shader.h>
(*iter)->stencilRenderables.clear();
(*iter)->colorRenderables.clear();
(*iter)->overlayRenderables.clear();
+
+ (*iter)->stencilRenderers.Clear();
+ (*iter)->colorRenderers.Clear();
+ (*iter)->overlayRenderers.Clear();
+
}
}
#include <dali/public-api/actors/layer.h>
#include <dali/integration-api/debug.h>
#include <dali/internal/event/actors/layer-impl.h> // for the default sorting function
-#include <dali/internal/update/node-attachments/scene-graph-renderer-attachment.h>
#include <dali/internal/update/node-attachments/scene-graph-renderable-attachment.h>
#include <dali/internal/update/nodes/scene-graph-layer.h>
#include <dali/internal/update/manager/sorted-layers.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/scene-graph-renderer.h>
+#include <dali/internal/render/renderers/render-renderer.h>
namespace
{
* @param renderList to add the item to
* @param renderable attachment
* @param viewMatrix used to calculate modelview matrix for the item
+ * @param cameraAttachment The camera used to render
+ * @param isLayer3d Whether we are processing a 3D layer or not
*/
inline void AddRendererToRenderList( BufferIndex updateBufferIndex,
RenderList& renderList,
SceneGraph::CameraAttachment& cameraAttachment,
bool isLayer3d )
{
- // Check for cull against view frustum
- bool inside = true;
-
const Node& parentNode = renderable.GetParent();
const Matrix& worldMatrix = parentNode.GetWorldMatrix( updateBufferIndex );
- if ( RendererAttachment* rendererAttachment = dynamic_cast< RendererAttachment* >( &renderable ) )
+ // Get the next free RenderItem and initialization
+ RenderItem& item = renderList.GetNextFreeItem();
+ const Render::Renderer& renderer = renderable.GetRenderer();
+ item.SetRenderer( const_cast< Render::Renderer* >( &renderer ) );
+ item.SetNode( const_cast< Node* >( &parentNode ) );
+
+ item.SetIsOpaque( renderable.IsFullyOpaque(updateBufferIndex) );
+ if( isLayer3d )
{
- if ( rendererAttachment->GetMaterial().GetShader()->GeometryHintEnabled( Dali::ShaderEffect::HINT_DOESNT_MODIFY_GEOMETRY ) )
- {
- // Get the geometry extents for frustum checking
- const Vector3& position = worldMatrix.GetTranslation3();
- const Geometry& geometry = rendererAttachment->GetGeometry();
- const Vector3& scale = parentNode.GetScale( updateBufferIndex );
+ item.SetDepthIndex( renderable.GetDepthIndex() );
+ }
+ else
+ {
+ item.SetDepthIndex( renderable.GetDepthIndex() + static_cast<int>( parentNode.GetDepth() ) * Dali::Layer::TREE_DEPTH_MULTIPLIER );
+ }
- Vector3 center( geometry.mCenter[ updateBufferIndex ] );
- center *= scale;
- center += position;
+ // save MV matrix onto the item
+ Matrix::Multiply( item.GetModelViewMatrix(), worldMatrix, viewMatrix );
+}
- // Do a fast sphere check
- if ( cameraAttachment.CheckSphereInFrustum( updateBufferIndex, center, geometry.mRadius[ updateBufferIndex ] * scale.Length() ) )
- {
- // Check geometry AABB
- if ( !cameraAttachment.CheckAABBInFrustum( updateBufferIndex, center, geometry.mHalfExtents[ updateBufferIndex ] * scale ) )
- {
- inside = false;
- }
- }
- else
+/**
+ * Add a renderer to the list
+ * @param updateBufferIndex to read the model matrix from
+ * @param renderList to add the item to
+ * @param NodeRenderer NodeRenderer pair
+ * @param viewMatrix used to calculate modelview matrix for the item
+ * @param cameraAttachment The camera used to render
+ * @param isLayer3d Whether we are processing a 3D layer or not
+ */
+inline void AddRendererToRenderList( BufferIndex updateBufferIndex,
+ RenderList& renderList,
+ NodeRenderer& renderable,
+ const Matrix& viewMatrix,
+ SceneGraph::CameraAttachment& cameraAttachment,
+ bool isLayer3d )
+{
+ // Check for cull against view frustum
+ const Matrix& worldMatrix = renderable.mNode->GetWorldMatrix( updateBufferIndex );
+ bool inside = true;
+
+ if ( renderable.mRenderer->GetMaterial().GetShader()->GeometryHintEnabled( Dali::ShaderEffect::HINT_DOESNT_MODIFY_GEOMETRY ) )
+ {
+ const Vector3& position = worldMatrix.GetTranslation3();
+ const Vector3& scale = renderable.mNode->GetScale( updateBufferIndex );
+ const Vector3& halfSize = renderable.mNode->GetSize( updateBufferIndex ) * scale * 0.5f;
+
+ // Do a fast sphere check
+ if ( cameraAttachment.CheckSphereInFrustum( updateBufferIndex, position, halfSize.Length() ) )
+ {
+ // Check geometry AABB
+ //TODO: Take into account orientation
+ if ( !cameraAttachment.CheckAABBInFrustum( updateBufferIndex, position, halfSize ) )
{
inside = false;
}
}
+ else
+ {
+ inside = false;
+ }
}
if ( inside )
{
- // Get the next free RenderItem and initialization
+ // Get the next free RenderItem
RenderItem& item = renderList.GetNextFreeItem();
- const Renderer& renderer = renderable.GetRenderer();
- item.SetRenderer( const_cast< Renderer* >( &renderer ) );
- item.SetIsOpaque( renderable.IsFullyOpaque(updateBufferIndex) );
+ item.SetRenderer( &renderable.mRenderer->GetRenderer() );
+ item.SetNode( renderable.mNode );
+ item.SetIsOpaque( renderable.mRenderer->IsFullyOpaque(updateBufferIndex, *renderable.mNode ) );
+
if( isLayer3d )
{
- item.SetDepthIndex( renderable.GetDepthIndex() );
+ item.SetDepthIndex( renderable.mRenderer->GetDepthIndex() );
}
else
{
- item.SetDepthIndex( renderable.GetDepthIndex() + static_cast<int>( parentNode.GetDepth() ) * Dali::Layer::TREE_DEPTH_MULTIPLIER );
+ item.SetDepthIndex( renderable.mRenderer->GetDepthIndex() + static_cast<int>( renderable.mNode->GetDepth() ) * Dali::Layer::TREE_DEPTH_MULTIPLIER );
}
// save MV matrix onto the item
* @param updateBufferIndex to read the model matrix from
* @param renderList to add the items to
* @param renderable attachments
+ * NodeRendererContainer Node-Renderer pairs
* @param viewMatrix used to calculate modelview matrix for the items
+ * @param cameraAttachment The camera used to render
+ * @param isLayer3d Whether we are processing a 3D layer or not
*/
inline void AddRenderersToRenderList( BufferIndex updateBufferIndex,
RenderList& renderList,
RenderableAttachmentContainer& attachments,
+ NodeRendererContainer& renderers,
const Matrix& viewMatrix,
SceneGraph::CameraAttachment& cameraAttachment,
bool isLayer3d )
DALI_LOG_INFO( gRenderListLogFilter, Debug::Verbose, "AddRenderersToRenderList()\n");
// Add renderer for each attachment
- int index=0;
+ unsigned int index(0);
const RenderableAttachmentIter endIter = attachments.end();
for ( RenderableAttachmentIter iter = attachments.begin(); iter != endIter; ++iter )
{
AddRendererToRenderList( updateBufferIndex, renderList, attachment, viewMatrix, cameraAttachment, isLayer3d );
DALI_LOG_INFO( gRenderListLogFilter, Debug::Verbose, " List[%d].renderer = %p\n", index, &(attachment.GetRenderer()));
- index++;
+ ++index;
+ }
+
+ unsigned int rendererCount( renderers.Size() );
+ for( unsigned int i(0); i<rendererCount; ++i )
+ {
+ AddRendererToRenderList( updateBufferIndex, renderList, renderers[i], viewMatrix, cameraAttachment, isLayer3d );
}
}
for( size_t index = 0; index < renderableCount; ++index )
{
RenderableAttachment* attachment = attachmentList[ index ];
- const Renderer& renderer = attachment->GetRenderer();
+ const Render::Renderer& renderer = attachment->GetRenderer();
checkSumNew += size_t( &renderer );
- checkSumOld += size_t( renderList.GetRenderer( index ) );
+ checkSumOld += size_t( &renderList.GetRenderer( index ) );
}
if( checkSumNew == checkSumOld )
{
{
if( lhs.shader == rhs.shader )
{
- if( lhs.material == rhs.material )
+ if( lhs.textureResourceId == rhs.textureResourceId )
{
return lhs.geometry < rhs.geometry;
}
- return lhs.material < rhs.material;
+ return lhs.textureResourceId < rhs.textureResourceId;
}
return lhs.shader < rhs.shader;;
}
//If both RenderItems are opaque, sort using shader, then material then geometry
if( lhs.shader == rhs.shader )
{
- if( lhs.material == rhs.material )
+ if( lhs.textureResourceId == rhs.textureResourceId )
{
return lhs.geometry < rhs.geometry;
}
- return lhs.material < rhs.material;
+ return lhs.textureResourceId < rhs.textureResourceId;
}
return lhs.shader < rhs.shader;
}
{
if( lhs.shader == rhs.shader )
{
- if( lhs.material == rhs.material )
+ if( lhs.textureResourceId == rhs.textureResourceId )
{
return lhs.geometry < rhs.geometry;
}
- return lhs.material < rhs.material;
+ return lhs.textureResourceId < rhs.textureResourceId;
}
return lhs.shader < rhs.shader;
}
}
/**
- * Sort color render items
- * @param colorRenderList to sort
+ * Sort render items
+ * @param bufferIndex The buffer to read from
+ * @param renderList to sort
* @param layer where the renderers are from
* @param sortingHelper to use for sorting the renderitems (to avoid reallocating)
*/
-inline void SortColorRenderItems( BufferIndex bufferIndex, RenderList& renderList, Layer& layer, RendererSortingHelper& sortingHelper )
+inline void SortRenderItems( BufferIndex bufferIndex, RenderList& renderList, Layer& layer, RendererSortingHelper& sortingHelper )
{
const size_t renderableCount = renderList.Count();
// reserve space if needed
{
RenderItem& item = renderList.GetItem( index );
- //@todo MESH_REWORK After merge of RenderableAttachment and RendererAttachment, should instead store the renderable ptr and get the fields directly
- layer.colorRenderables[index]->SetSortAttributes( bufferIndex, sortingHelper[ index ] );
+ item.GetRenderer().SetSortAttributes( bufferIndex, sortingHelper[ index ] );
// the default sorting function should get inlined here
sortingHelper[ index ].zValue = Internal::Layer::ZValue( item.GetModelViewMatrix().GetTranslation3() ) - item.GetDepthIndex();
{
RenderItem& item = renderList.GetItem( index );
- layer.colorRenderables[index]->SetSortAttributes( bufferIndex, sortingHelper[ index ] );
+ item.GetRenderer().SetSortAttributes( bufferIndex, sortingHelper[ index ] );
sortingHelper[ index ].zValue = (*sortFunction)( item.GetModelViewMatrix().GetTranslation3() ) - item.GetDepthIndex();
// keep the renderitem pointer in the helper so we can quickly reorder items after sort
for( unsigned int index = 0; index < renderableCount; ++index, ++renderListIter )
{
*renderListIter = sortingHelper[ index ].renderItem;
- DALI_LOG_INFO( gRenderListLogFilter, Debug::Verbose, " sortedList[%d] = %p\n", index, sortingHelper[ index ].renderItem->GetRenderer() );
+ DALI_LOG_INFO( gRenderListLogFilter, Debug::Verbose, " sortedList[%d] = %p\n", index, &sortingHelper[ index ].renderItem->GetRenderer() );
}
}
}
}
- AddRenderersToRenderList( updateBufferIndex, renderList, layer.colorRenderables, viewMatrix, cameraAttachment, layer.GetBehavior() == Dali::Layer::LAYER_3D );
- SortColorRenderItems( updateBufferIndex, renderList, layer, sortingHelper );
+ AddRenderersToRenderList( updateBufferIndex, renderList, layer.colorRenderables, layer.colorRenderers, viewMatrix, cameraAttachment, layer.GetBehavior() == Dali::Layer::LAYER_3D );
+ SortRenderItems( updateBufferIndex, renderList, layer, sortingHelper );
//Set render flags
unsigned int flags = 0u;
// and if this layer has got exactly one opaque renderer
// and this renderer is not interested in depth testing
// (i.e. is an image and not a mesh)
+
if ( ( renderList.Count() == 1 ) &&
- ( !renderList.GetRenderer( 0 )->RequiresDepthTest() ) &&
+ ( !renderList.GetRenderer( 0 ).RequiresDepthTest() ) &&
( !renderList.GetItem(0).IsOpaque() ) )
{
//Nothing to do here
SceneGraph::CameraAttachment& cameraAttachment,
bool stencilRenderablesExist,
RenderInstruction& instruction,
+ RendererSortingHelper& sortingHelper,
bool tryReuseRenderList )
{
RenderList& overlayRenderList = instruction.GetNextFreeRenderList( layer.overlayRenderables.size() );
return;
}
}
- AddRenderersToRenderList( updateBufferIndex, overlayRenderList, layer.overlayRenderables, viewMatrix, cameraAttachment, layer.GetBehavior() == Dali::Layer::LAYER_3D );
+ AddRenderersToRenderList( updateBufferIndex, overlayRenderList, layer.overlayRenderables, layer.overlayRenderers, viewMatrix, cameraAttachment, layer.GetBehavior() == Dali::Layer::LAYER_3D );
+ SortRenderItems( updateBufferIndex, overlayRenderList, layer, sortingHelper );
}
/**
return;
}
}
- AddRenderersToRenderList( updateBufferIndex, stencilRenderList, layer.stencilRenderables, viewMatrix, cameraAttachment, layer.GetBehavior() == Dali::Layer::LAYER_3D );
+ AddRenderersToRenderList( updateBufferIndex, stencilRenderList, layer.stencilRenderables, layer.stencilRenderers, viewMatrix, cameraAttachment, layer.GetBehavior() == Dali::Layer::LAYER_3D );
}
/**
{
Layer& layer = **iter;
- const bool stencilRenderablesExist( !layer.stencilRenderables.empty() );
- const bool colorRenderablesExist( !layer.colorRenderables.empty() );
- const bool overlayRenderablesExist( !layer.overlayRenderables.empty() );
+ const bool stencilRenderablesExist( !layer.stencilRenderables.empty() || layer.stencilRenderers.Count() != 0u );
+ const bool colorRenderablesExist( !layer.colorRenderables.empty() || layer.colorRenderers.Count() != 0u );
+ const bool overlayRenderablesExist( !layer.overlayRenderables.empty() || layer.overlayRenderers.Count() != 0u );
const bool tryReuseRenderList( viewMatrixHasNotChanged && layer.CanReuseRenderers(renderTask.GetCamera()) );
// Ignore stencils if there's nothing to test
if ( overlayRenderablesExist )
{
AddOverlayRenderers( updateBufferIndex, layer, viewMatrix, cameraAttachment, stencilRenderablesExist,
- instruction, tryReuseRenderList );
+ instruction, sortingHelper, tryReuseRenderList );
}
}
// INTERNAL INCLUDES
#include <dali/internal/common/buffer-index.h>
#include <dali/internal/update/manager/sorted-layers.h>
+#include <dali/integration-api/resource-declarations.h>
namespace Dali
{
class RenderTracker;
class RenderItem;
class Shader;
-class Material;
-class Geometry;
+class RenderGeometry;
+class MaterialDataProvider;
/**
* Structure to store information for sorting the renderers.
RendererWithSortAttributes()
: renderItem( NULL ),
shader(NULL),
- material(NULL),
+ textureResourceId( Integration::InvalidResourceId ),
geometry(NULL),
zValue(0.0f)
{
}
- RenderItem* renderItem; ///< The render item that is being sorted (includes depth index)
- Shader* shader; ///< The shader instance
- Material* material; ///< The material instance
- Geometry* geometry; ///< The geometry instance
- float zValue; // The zValue of the given renderer (either distance from camera, or a custom calculated value)
+ RenderItem* renderItem; ///< The render item that is being sorted (includes depth index)
+ const Shader* shader; ///< The shader instance
+ Integration::ResourceId textureResourceId;///< The first texture resource ID of the sampler instance, is InvalidResourceId if the material doesn't have any samplers
+ const RenderGeometry* geometry; ///< The geometry instance
+ float zValue; ///< The zValue of the given renderer (either distance from camera, or a custom calculated value)
};
typedef std::vector< RendererWithSortAttributes > RendererSortingHelper;
#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/renderers/scene-graph-renderer.h>
+#include <dali/internal/render/renderers/render-renderer.h>
#include <dali/integration-api/debug.h>
#if defined(DEBUG_ENABLED)
int inheritedDrawMode )
{
bool resourcesFinished = true;
- bool forceRender = false;
- const RenderTask* exclusiveTo = node.GetExclusiveRenderTask();
-
- // Cater for edge case where node is exclusively owned, the render task is REFRESH_ONCE, but the parent may be invisible.
- if ( exclusiveTo && Dali::RenderTask::REFRESH_ONCE == renderTask.GetRefreshRate() )
- {
- forceRender = true;
- }
// Short-circuit for invisible nodes
if ( !node.IsVisible( updateBufferIndex ) )
}
// Check whether node is exclusive to a different render-task
+ const RenderTask* exclusiveTo = node.GetExclusiveRenderTask();
if ( exclusiveTo &&
exclusiveTo != &renderTask )
{
inheritedDrawMode |= node.GetDrawMode();
+
if ( node.HasAttachment() )
{
RenderableAttachment* renderable = node.GetAttachment().GetRenderable(); // not all attachments render
// if its not potentially visible, then don't consider this renderable for render complete checking
// note that whilst visibility is inherited (if parent is insible, skip the sub-tree),
// size and color may not be so this needs to be done per renderable
- if( visible || forceRender ) // i.e. some resources are ready
+ if( visible ) // i.e. some resources are ready
{
bool ready = false;
bool complete = false;
}
}
+ if( node.ResolveVisibility( updateBufferIndex ) )
+ {
+ for( unsigned int i(0); i<node.GetRendererCount(); ++i )
+ {
+ Renderer* renderer = node.GetRendererAt( i );
+ bool ready = false;
+ bool complete = false;
+ renderer->GetReadyAndComplete(ready, complete);
+
+ DALI_LOG_INFO(gRenderTaskLogFilter, Debug::General, "Testing renderable:%p ready:%s complete:%s\n", renderer, ready?"T":"F", complete?"T":"F");
+
+ resourcesFinished = !complete ? complete : resourcesFinished;
+
+ resourcesFinished = !complete ? complete : resourcesFinished;
+
+ if( ready ) // i.e. some resources are ready
+ {
+ if( DrawMode::STENCIL == inheritedDrawMode )
+ {
+ layer->stencilRenderers.PushBack( NodeRenderer(&node, renderer ) );
+ }
+ else if( DrawMode::OVERLAY_2D == inheritedDrawMode )
+ {
+ layer->overlayRenderers.PushBack( NodeRenderer(&node, renderer ) );
+ }
+ else
+ {
+ layer->colorRenderers.PushBack( NodeRenderer(&node, renderer ) );
+ }
+ }
+
+
+
+ }
+ }
+
+
// Recurse children
NodeContainer& children = node.GetChildren();
const NodeIter endIter = children.End();
#include <dali/internal/update/node-attachments/scene-graph-renderable-attachment.h>
#include <dali/internal/update/animation/scene-graph-constraint-base.h>
#include <dali/internal/update/nodes/scene-graph-layer.h>
-#include <dali/internal/render/renderers/scene-graph-renderer.h>
+#include <dali/internal/render/renderers/render-renderer.h>
#include <dali/integration-api/debug.h>
if( node.HasAttachment() )
{
- // @todo MESH_REWORK Remove dynamic cast.
- // (Or, if RendererAttachment split into RendererPropertyOwner(?),
- // do as separate pass as per other mesh objects - see also
- // UpdateManager::ResetNodeProperty())
+ // @todo Remove dynamic cast.
NodeAttachment& attachment = node.GetAttachment();
PropertyOwner* propertyOwner = dynamic_cast< PropertyOwner* >( &attachment );
if( propertyOwner != NULL )
AddRenderableToLayer( *layer, *renderable, updateBufferIndex, inheritedDrawMode );
}
}
- else if( node.IsObserved() )
+ else if( node.IsObserved() || node.GetRendererCount() )
{
// This node is being used as a property input for an animation, constraint,
// camera or bone. Ensure it's matrix is updated
UpdateNodeWorldMatrix( node, nodeDirtyFlags, updateBufferIndex );
}
+ if( node.ResolveVisibility(updateBufferIndex) )
+ {
+ node.PrepareRender( updateBufferIndex );
+ }
+
+
// if any child node has moved or had its sort modifier changed, layer is not clean and old frame cannot be reused
// also if node has been deleted, dont reuse old render items
if( nodeDirtyFlags & RenderableUpdateFlags )
// INTERNAL INCLUDES
#include <dali/public-api/common/stage.h>
#include <dali/devel-api/common/set-wrapper.h>
-#include <dali/devel-api/common/mutex.h>
+#include <dali/devel-api/common/owner-container.h>
+#include <dali/devel-api/threading/mutex.h>
#include <dali/integration-api/core.h>
#include <dali/integration-api/render-controller.h>
#include <dali/integration-api/debug.h>
#include <dali/internal/common/core-impl.h>
-#include <dali/internal/common/owner-container.h>
#include <dali/internal/common/message.h>
#include <dali/internal/event/common/notification-manager.h>
#include <dali/internal/update/animation/scene-graph-animation.h>
#include <dali/internal/update/common/discard-queue.h>
#include <dali/internal/update/common/scene-graph-buffers.h>
-#include <dali/internal/update/common/scene-graph-property-buffer.h>
#include <dali/internal/update/controllers/render-message-dispatcher.h>
#include <dali/internal/update/controllers/scene-controller-impl.h>
#include <dali/internal/update/gestures/scene-graph-pan-gesture.h>
#include <dali/internal/update/manager/update-algorithms.h>
#include <dali/internal/update/manager/update-manager-debug.h>
#include <dali/internal/update/node-attachments/scene-graph-camera-attachment.h>
-#include <dali/internal/update/node-attachments/scene-graph-renderer-attachment.h>
#include <dali/internal/update/node-attachments/scene-graph-image-attachment.h>
#include <dali/internal/update/nodes/node.h>
#include <dali/internal/update/nodes/scene-graph-layer.h>
#include <dali/internal/update/render-tasks/scene-graph-render-task.h>
#include <dali/internal/update/render-tasks/scene-graph-render-task-list.h>
#include <dali/internal/update/rendering/scene-graph-material.h>
-#include <dali/internal/update/rendering/scene-graph-sampler.h>
#include <dali/internal/update/rendering/scene-graph-geometry.h>
#include <dali/internal/update/resources/resource-manager.h>
#include <dali/internal/update/resources/complete-status-manager.h>
#include <dali/internal/render/common/performance-monitor.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-sampler.h>
// Un-comment to enable node tree debug logging
//#define NODE_TREE_LOGGING 1
systemLevelTaskList ( completeStatusManager ),
root( NULL ),
systemLevelRoot( NULL ),
- geometries( sceneGraphBuffers, discardQueue ),
+ renderers( sceneGraphBuffers, discardQueue ),
+ geometries( sceneGraphBuffers, discardQueue ),
materials( sceneGraphBuffers, discardQueue ),
- samplers( sceneGraphBuffers, discardQueue ),
- propertyBuffers( sceneGraphBuffers, discardQueue ),
messageQueue( renderController, sceneGraphBuffers ),
keepRenderingSeconds( 0.0f ),
animationFinishedDuringUpdate( false ),
{
sceneController = new SceneControllerImpl( renderMessageDispatcher, renderQueue, discardQueue, textureCache, completeStatusManager );
+ renderers.SetSceneController( *sceneController );
geometries.SetSceneController( *sceneController );
materials.SetSceneController( *sceneController );
- propertyBuffers.SetSceneController( *sceneController );
- samplers.SetSceneController( *sceneController );
}
~Impl()
AnimationContainer animations; ///< A container of owned animations
PropertyNotificationContainer propertyNotifications; ///< A container of owner property notifications.
+ ObjectOwnerContainer<Renderer> renderers;
ObjectOwnerContainer<Geometry> geometries; ///< A container of geometries
ObjectOwnerContainer<Material> materials; ///< A container of materials
- ObjectOwnerContainer<Sampler> samplers; ///< A container of samplers
- ObjectOwnerContainer<PropertyBuffer> propertyBuffers; ///< A container of property buffers
ShaderContainer shaders; ///< A container of owned shaders
mImpl->activeDisconnectedNodes.insert( node ); // Takes ownership of node
}
-void UpdateManager::ConnectNode( Node* parent, Node* node, int index )
+void UpdateManager::ConnectNode( Node* parent, Node* node )
{
DALI_ASSERT_ALWAYS( NULL != parent );
DALI_ASSERT_ALWAYS( NULL != node );
node->SetActive( true );
- parent->ConnectChild( node, index );
+ parent->ConnectChild( node );
}
void UpdateManager::DisconnectNode( Node* node )
}
}
-void UpdateManager::AttachToSceneGraph( RendererAttachment* renderer )
-{
- // @todo MESH_REWORK Take ownership of this object after merge with SceneGraph::RenderableAttachment
-
- SceneGraph::NodeAttachment* attachment = static_cast<SceneGraph::NodeAttachment*>(renderer);
- attachment->Initialize( *mImpl->sceneController, mSceneGraphBuffers.GetUpdateBufferIndex() );
-}
-
void UpdateManager::AddObject( PropertyOwner* object )
{
DALI_ASSERT_DEBUG( NULL != object );
return mImpl->geometries;
}
-ObjectOwnerContainer<Material>& UpdateManager::GetMaterialOwner()
+ObjectOwnerContainer<Renderer>& UpdateManager::GetRendererOwner()
{
- return mImpl->materials;
+ return mImpl->renderers;
}
-ObjectOwnerContainer<Sampler>& UpdateManager::GetSamplerOwner()
-{
- return mImpl->samplers;
-}
-ObjectOwnerContainer<PropertyBuffer>& UpdateManager::GetPropertyBufferOwner()
+ObjectOwnerContainer<Material>& UpdateManager::GetMaterialOwner()
{
- return mImpl->propertyBuffers;
+ return mImpl->materials;
}
void UpdateManager::AddShader( Shader* shader )
return mImpl->messageQueue.FlushQueue();
}
-void UpdateManager::ResetNodeProperty( Node& node )
-{
- BufferIndex bufferIndex = mSceneGraphBuffers.GetUpdateBufferIndex();
-
- node.ResetToBaseValues( bufferIndex );
-}
-
-void UpdateManager::ResetProperties()
+void UpdateManager::ResetProperties( BufferIndex bufferIndex )
{
PERF_MONITOR_START(PerformanceMonitor::RESET_PROPERTIES);
- BufferIndex bufferIndex = mSceneGraphBuffers.GetUpdateBufferIndex();
-
// Clear the "animations finished" flag; This should be set if any (previously playing) animation is stopped
mImpl->animationFinishedDuringUpdate = false;
// Animated properties have to be reset to their original value each frame
- // Reset node properties
+ // Reset root properties
if ( mImpl->root )
{
- ResetNodeProperty( *mImpl->root );
+ mImpl->root->ResetToBaseValues( bufferIndex );
}
-
if ( mImpl->systemLevelRoot )
{
- ResetNodeProperty( *mImpl->systemLevelRoot );
+ mImpl->systemLevelRoot->ResetToBaseValues( bufferIndex );
}
// Reset the Connected Nodes
const std::set<Node*>::iterator endIter = mImpl->connectedNodes.end();
for( std::set<Node*>::iterator iter = mImpl->connectedNodes.begin(); endIter != iter; ++iter )
{
- ResetNodeProperty( **iter );
+ (*iter)->ResetToBaseValues( bufferIndex );
}
// If a Node is disconnected, it may still be "active" (requires a reset in next frame)
mImpl->materials.ResetToBaseValues( bufferIndex );
mImpl->geometries.ResetToBaseValues( bufferIndex );
- mImpl->propertyBuffers.ResetToBaseValues( bufferIndex );
- mImpl->samplers.ResetToBaseValues( bufferIndex );
+ mImpl->renderers.ResetToBaseValues( bufferIndex );
// Reset animatable shader properties to base values
PERF_MONITOR_END(PerformanceMonitor::RESET_PROPERTIES);
}
-bool UpdateManager::ProcessGestures( unsigned int lastVSyncTimeMilliseconds, unsigned int nextVSyncTimeMilliseconds )
+bool UpdateManager::ProcessGestures( BufferIndex bufferIndex, unsigned int lastVSyncTimeMilliseconds, unsigned int nextVSyncTimeMilliseconds )
{
bool gestureUpdated( false );
for ( GestureIter iter = gestures.Begin(), endIter = gestures.End(); iter != endIter; ++iter )
{
PanGesture& gesture = **iter;
- gesture.ResetToBaseValues( mSceneGraphBuffers.GetUpdateBufferIndex() ); // Needs to be done every time as gesture data is written directly to an update-buffer rather than via a message
+ gesture.ResetToBaseValues( bufferIndex ); // Needs to be done every time as gesture data is written directly to an update-buffer rather than via a message
gestureUpdated |= gesture.UpdateProperties( lastVSyncTimeMilliseconds, nextVSyncTimeMilliseconds );
}
return gestureUpdated;
}
-void UpdateManager::Animate( float elapsedSeconds )
+void UpdateManager::Animate( BufferIndex bufferIndex, float elapsedSeconds )
{
PERF_MONITOR_START(PerformanceMonitor::ANIMATE_NODES);
while ( iter != animations.End() )
{
Animation* animation = *iter;
- bool finished = animation->Update(mSceneGraphBuffers.GetUpdateBufferIndex(), elapsedSeconds);
+ bool finished = animation->Update( bufferIndex, elapsedSeconds );
mImpl->animationFinishedDuringUpdate = mImpl->animationFinishedDuringUpdate || finished;
PERF_MONITOR_END(PerformanceMonitor::ANIMATE_NODES);
}
-void UpdateManager::ApplyConstraints()
+void UpdateManager::ApplyConstraints( BufferIndex bufferIndex )
{
PERF_MONITOR_START(PerformanceMonitor::APPLY_CONSTRAINTS);
- BufferIndex bufferIndex = mSceneGraphBuffers.GetUpdateBufferIndex();
-
// constrain custom objects... (in construction order)
OwnerContainer< PropertyOwner* >& customObjects = mImpl->customObjects;
// Constrain Materials and geometries
mImpl->materials.ConstrainObjects( bufferIndex );
mImpl->geometries.ConstrainObjects( bufferIndex );
- mImpl->samplers.ConstrainObjects( bufferIndex );
- mImpl->propertyBuffers.ConstrainObjects( bufferIndex );
+ mImpl->renderers.ConstrainObjects( bufferIndex );
// constrain shaders... (in construction order)
ShaderContainer& shaders = mImpl->shaders;
PERF_MONITOR_END(PerformanceMonitor::APPLY_CONSTRAINTS);
}
-void UpdateManager::ProcessPropertyNotifications()
+void UpdateManager::ProcessPropertyNotifications( BufferIndex bufferIndex )
{
PropertyNotificationContainer ¬ifications = mImpl->propertyNotifications;
PropertyNotificationIter iter = notifications.Begin();
- BufferIndex bufferIndex = mSceneGraphBuffers.GetUpdateBufferIndex();
-
while ( iter != notifications.End() )
{
PropertyNotification* notification = *iter;
}
}
-void UpdateManager::UpdateNodes()
+void UpdateManager::UpdateRenderers( BufferIndex bufferIndex )
+{
+ const OwnerContainer<Renderer*>& rendererContainer( mImpl->renderers.GetObjectContainer() );
+ unsigned int rendererCount( rendererContainer.Size() );
+ for( unsigned int i(0); i<rendererCount; ++i )
+ {
+ if( rendererContainer[i]->IsReferenced() )
+ {
+ rendererContainer[i]->PrepareResources(bufferIndex, mImpl->resourceManager);
+ rendererContainer[i]->PrepareRender( bufferIndex );
+ }
+ }
+}
+
+void UpdateManager::UpdateNodes( BufferIndex bufferIndex )
{
mImpl->nodeDirtyFlags = NothingFlag;
// Prepare resources, update shaders, update attachments, for each node
// And add the renderers to the sorted layers. Start from root, which is also a layer
mImpl->nodeDirtyFlags = UpdateNodesAndAttachments( *( mImpl->root ),
- mSceneGraphBuffers.GetUpdateBufferIndex(),
+ bufferIndex,
mImpl->resourceManager,
mImpl->renderQueue );
if ( mImpl->systemLevelRoot )
{
mImpl->nodeDirtyFlags |= UpdateNodesAndAttachments( *( mImpl->systemLevelRoot ),
- mSceneGraphBuffers.GetUpdateBufferIndex(),
+ bufferIndex,
mImpl->resourceManager,
mImpl->renderQueue );
}
// Measure the time spent in UpdateManager::Update
PERF_MONITOR_START(PerformanceMonitor::UPDATE);
- BufferIndex bufferIndex = mSceneGraphBuffers.GetUpdateBufferIndex();
-
- // Update the frame time delta on the render thread.
- mImpl->renderManager.SetFrameDeltaTime(elapsedSeconds);
+ const BufferIndex bufferIndex = mSceneGraphBuffers.GetUpdateBufferIndex();
// 1) Clear nodes/resources which were previously discarded
mImpl->discardQueue.Clear( bufferIndex );
// 3) Process Touches & Gestures
mImpl->touchResampler.Update();
- const bool gestureUpdated = ProcessGestures( lastVSyncTimeMilliseconds, nextVSyncTimeMilliseconds );
+ const bool gestureUpdated = ProcessGestures( bufferIndex, lastVSyncTimeMilliseconds, nextVSyncTimeMilliseconds );
+
+ const bool updateScene = // The scene-graph requires an update if..
+ (mImpl->nodeDirtyFlags & RenderableUpdateFlags) || // ..nodes were dirty in previous frame OR
+ IsAnimationRunning() || // ..at least one animation is running OR
+ mImpl->messageQueue.IsSceneUpdateRequired() || // ..a message that modifies the scene graph node tree is queued OR
+ resourceChanged || // ..one or more resources were updated/changed OR
+ gestureUpdated; // ..a gesture property was updated
- const bool updateScene = // The scene-graph requires an update if..
- (mImpl->nodeDirtyFlags & RenderableUpdateFlags) || // ..nodes were dirty in previous frame OR
- IsAnimationRunning() || // ..at least one animation is running OR
- mImpl->messageQueue.IsSceneUpdateRequired() || // ..a message that modifies the scene graph node tree is queued OR
- resourceChanged || // ..one or more resources were updated/changed OR
- gestureUpdated; // ..a gesture property was updated
// Although the scene-graph may not require an update, we still need to synchronize double-buffered
// values if the scene was updated in the previous frame.
if( updateScene || mImpl->previousUpdateScene )
{
// 4) Reset properties from the previous update
- ResetProperties();
+ ResetProperties( bufferIndex );
}
// 5) Process the queued scene messages
- mImpl->messageQueue.ProcessMessages();
+ mImpl->messageQueue.ProcessMessages( bufferIndex );
// 6) Post Process Ids of resources updated by renderer
mImpl->resourceManager.PostProcessResources( bufferIndex );
if( updateScene || mImpl->previousUpdateScene )
{
// 7) Animate
- Animate( elapsedSeconds );
+ Animate( bufferIndex, elapsedSeconds );
// 8) Apply Constraints
- ApplyConstraints();
+ ApplyConstraints( bufferIndex );
// 9) Check Property Notifications
- ProcessPropertyNotifications();
+ ProcessPropertyNotifications( bufferIndex );
// 10) Clear the lists of renderable-attachments from the previous update
ClearRenderables( mImpl->sortedLayers );
// 11) Update node hierarchy and perform sorting / culling.
// This will populate each Layer with a list of renderers which are ready.
- UpdateNodes();
+ UpdateNodes( bufferIndex );
+ UpdateRenderers( bufferIndex );
+
// 12) Prepare for the next render
PERF_MONITOR_START(PerformanceMonitor::PREPARE_RENDERABLES);
// 14) 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( mSceneGraphBuffers.GetUpdateBufferIndex(),
+ mImpl->renderInstructions.ResetAndReserve( bufferIndex,
mImpl->taskList.GetTasks().Count() + mImpl->systemLevelTaskList.GetTasks().Count() );
if ( NULL != mImpl->root )
keepUpdating |= KeepUpdating::MONITORING_PERFORMANCE;
#endif
- // The update has finished; swap the double-buffering indices
- mSceneGraphBuffers.Swap();
-
// tell the update manager that we're done so the queue can be given to event thread
mImpl->notificationManager.UpdateCompleted();
+ // The update has finished; swap the double-buffering indices
+ mSceneGraphBuffers.Swap();
+
PERF_MONITOR_END(PerformanceMonitor::UPDATE);
return keepUpdating;
mImpl->shaderSaver = &upstream;
}
+void UpdateManager::AddSampler( Render::Sampler* sampler )
+{
+ typedef MessageValue1< RenderManager, Render::Sampler* > DerivedType;
+
+ // Reserve some memory inside the render queue
+ unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
+
+ // Construct message in the render queue memory; note that delete should not be called on the return value
+ new (slot) DerivedType( &mImpl->renderManager, &RenderManager::AddSampler, sampler );
+}
+
+void UpdateManager::RemoveSampler( Render::Sampler* sampler )
+{
+ typedef MessageValue1< RenderManager, Render::Sampler* > DerivedType;
+
+ // Reserve some memory inside the render queue
+ unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
+
+ // Construct message in the render queue memory; note that delete should not be called on the return value
+ new (slot) DerivedType( &mImpl->renderManager, &RenderManager::RemoveSampler, sampler );
+}
+
+void UpdateManager::SetFilterMode( Render::Sampler* sampler, unsigned int minFilterMode, unsigned int magFilterMode )
+{
+ typedef MessageValue3< RenderManager, Render::Sampler*, unsigned int, unsigned int > DerivedType;
+
+ // Reserve some memory inside the render queue
+ unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
+
+ // Construct message in the render queue memory; note that delete should not be called on the return value
+ new (slot) DerivedType( &mImpl->renderManager, &RenderManager::SetFilterMode, sampler, minFilterMode, magFilterMode );
+}
+
+void UpdateManager::SetWrapMode( Render::Sampler* sampler, unsigned int uWrapMode, unsigned int vWrapMode )
+{
+ typedef MessageValue3< RenderManager, Render::Sampler*, unsigned int, unsigned int > DerivedType;
+
+ // Reserve some memory inside the render queue
+ unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
+
+ // Construct message in the render queue memory; note that delete should not be called on the return value
+ new (slot) DerivedType( &mImpl->renderManager, &RenderManager::SetWrapMode, sampler, uWrapMode, vWrapMode );
+}
+
+void UpdateManager::AddPropertyBuffer( Render::PropertyBuffer* propertyBuffer )
+{
+ typedef MessageValue1< RenderManager, Render::PropertyBuffer* > DerivedType;
+
+ // Reserve some memory inside the render queue
+ unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
+
+ // Construct message in the render queue memory; note that delete should not be called on the return value
+ new (slot) DerivedType( &mImpl->renderManager, &RenderManager::AddPropertyBuffer, propertyBuffer );
+}
+
+void UpdateManager::RemovePropertyBuffer( Render::PropertyBuffer* propertyBuffer )
+{
+ typedef MessageValue1< RenderManager, Render::PropertyBuffer* > DerivedType;
+
+ // Reserve some memory inside the render queue
+ unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
+
+ // Construct message in the render queue memory; note that delete should not be called on the return value
+ new (slot) DerivedType( &mImpl->renderManager, &RenderManager::RemovePropertyBuffer, propertyBuffer );
+}
+
+void UpdateManager::SetPropertyBufferFormat(Render::PropertyBuffer* propertyBuffer, Render::PropertyBuffer::Format* format )
+{
+ typedef MessageValue2< RenderManager, Render::PropertyBuffer*, Render::PropertyBuffer::Format* > DerivedType;
+
+ // Reserve some memory inside the render queue
+ unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
+
+ // Construct message in the render queue memory; note that delete should not be called on the return value
+ new (slot) DerivedType( &mImpl->renderManager, &RenderManager::SetPropertyBufferFormat, propertyBuffer, format );
+}
+
+void UpdateManager::SetPropertyBufferData(Render::PropertyBuffer* propertyBuffer, Dali::Vector<char>* data)
+{
+ typedef MessageValue2< RenderManager, Render::PropertyBuffer*, Dali::Vector<char>* > DerivedType;
+
+ // Reserve some memory inside the render queue
+ unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
+
+ // Construct message in the render queue memory; note that delete should not be called on the return value
+ new (slot) DerivedType( &mImpl->renderManager, &RenderManager::SetPropertyBufferData, propertyBuffer, data );
+}
+
+void UpdateManager::SetPropertyBufferSize(Render::PropertyBuffer* propertyBuffer, size_t size )
+{
+ typedef MessageValue2< RenderManager, Render::PropertyBuffer*, size_t > DerivedType;
+
+ // Reserve some memory inside the render queue
+ unsigned int* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
+
+ // Construct message in the render queue memory; note that delete should not be called on the return value
+ new (slot) DerivedType( &mImpl->renderManager, &RenderManager::SetPropertyBufferSize, propertyBuffer, size );
+}
+
} // namespace SceneGraph
} // namespace Internal
#include <dali/internal/update/node-attachments/node-attachment.h>
#include <dali/internal/update/nodes/node.h>
#include <dali/internal/update/nodes/scene-graph-layer.h>
-
+#include <dali/internal/update/rendering/scene-graph-renderer.h>
#include <dali/internal/render/shaders/scene-graph-shader.h>
+#include <dali/internal/render/renderers/render-property-buffer.h>
namespace Dali
{
class ResourceManager;
class TouchResampler;
+namespace Render
+{
+class Sampler;
+}
// value types used by messages
template <> struct ParameterType< PropertyNotification::NotifyMode >
: public BasicType< PropertyNotification::NotifyMode > {};
class Geometry;
class PropertyBuffer;
class Material;
-class Sampler;
-class RendererAttachment;
/**
* UpdateManager maintains a scene graph i.e. a tree of nodes and attachments and
* Connect a Node to the scene-graph.
* A disconnected Node has has no parent or children, and its properties cannot be animated/constrained.
* @pre The node does not already have a parent.
- * @param[in] node The new parent node.
- * @param[in] node The node to connect.
+ * @param[in] parent The new parent node.
*/
- void ConnectNode( Node* parent, Node* node, int index );
+ void ConnectNode( Node* parent, Node* node );
/**
* Disconnect a Node from the scene-graph.
void AttachToNode( Node* node, NodeAttachment* attachment );
/**
- * Attach a renderer to the scene graph
- */
- void AttachToSceneGraph( RendererAttachment* renderer );
-
-
- /**
* Add a newly created object.
* @param[in] object The object to add.
* @post The object is owned by UpdateManager.
*/
ObjectOwnerContainer< Geometry >& GetGeometryOwner();
+ ObjectOwnerContainer< Renderer >& GetRendererOwner();
/**
* @brief Get the material owner
*
ObjectOwnerContainer< Material >& GetMaterialOwner();
/**
- * @brief Get the sampler owner
- *
- * @return The sampler owner
- */
- ObjectOwnerContainer< Sampler >& GetSamplerOwner();
-
- /**
* @brief Get the property buffer owner
*
* @return The property buffer owner
*/
bool FlushQueue();
+ /**
+ * Add a new sampler to RenderManager
+ * @param[in] sampler The sampler to add
+ * @post Sends a message to RenderManager to add the sampler.
+ * The sampler will be owned by RenderManager
+ */
+ void AddSampler( Render::Sampler* sampler );
+
+ /**
+ * Removes an existing sampler from RenderManager
+ * @param[in] sampler The sampler to remove
+ * @post The sampler will be destroyed in the render thread
+ */
+ void RemoveSampler( Render::Sampler* sampler );
+
+ /**
+ * Sets the filter modes for an existing sampler
+ * @param[in] sampler The sampler
+ * @param[in] minFilterMode The filter to use under minification
+ * @param[in] magFilterMode The filter to use under magnification
+ */
+ void SetFilterMode( Render::Sampler* sampler, unsigned int minFilterMode, unsigned int magFilterMode );
+
+ /**
+ * Sets the wrap mode for an existing sampler
+ * @param[in] sampler The sampler
+ * @param[in] uWrapMode Wrapping mode in x direction
+ * @param[in] vWrapMode Wrapping mode in y direction
+ */
+ void SetWrapMode( Render::Sampler* sampler, unsigned int uWrapMode, unsigned int vWrapMode );
+
+ /**
+ * Add a new sampler to RenderManager
+ * @param[in] propertryBuffer The property buffer to add
+ * @post Sends a message to RenderManager to add the property buffer.
+ * The property buffer will be owned by RenderManager
+ */
+ void AddPropertyBuffer( Render::PropertyBuffer* propertryBuffer );
+
+ /**
+ * Removes an existing PropertyBuffer from RenderManager
+ * @param[in] propertryBuffer The property buffer to remove
+ * @post The property buffer will be destroyed in the render thread
+ */
+ void RemovePropertyBuffer( Render::PropertyBuffer* propertryBuffer );
+
+ /**
+ * Sets the format of an existing property buffer
+ * @param[in] propertyBuffer The property buffer.
+ * @param[in] format The new format of the buffer
+ * @post Sends a message to RenderManager to set the new format to the property buffer.
+ */
+ void SetPropertyBufferFormat(Render::PropertyBuffer* propertyBuffer, Render::PropertyBuffer::Format* format );
+
+ /**
+ * Sets the data of an existing property buffer
+ * @param[in] propertyBuffer The property buffer.
+ * @param[in] data The new data of the buffer
+ * @post Sends a message to RenderManager to set the new data to the property buffer.
+ */
+ void SetPropertyBufferData(Render::PropertyBuffer* propertyBuffer, Dali::Vector<char>* data);
+
+ /**
+ * Sets the size of an existing property buffer
+ * @param[in] propertyBuffer The property buffer.
+ * @param[in] size The new size of the buffer
+ * @post Sends a message to RenderManager to set the new size to the property buffer.
+ */
+ void SetPropertyBufferSize(Render::PropertyBuffer* propertyBuffer, size_t size );
+
public:
/**
void PostProcessResources();
/**
- * Helper to reset a Node properties.
- * @param[in] node The node.
- */
- void ResetNodeProperty( Node& node );
-
- /**
* Helper to reset all Node properties
+ * @param[in] bufferIndex to use
*/
- void ResetProperties();
+ void ResetProperties( BufferIndex bufferIndex );
/**
* Perform gesture updates.
- * @param[in] lastVSyncTime The last VSync time in milliseconds.
- * @param[in] nextVSyncTime The estimated time of the next VSync in milliseconds.
+ * @param[in] bufferIndex to use
+ * @param[in] lastVSyncTime The last VSync time in milliseconds.
+ * @param[in] nextVSyncTime The estimated time of the next VSync in milliseconds.
* @return true, if any properties were updated.
*/
- bool ProcessGestures( unsigned int lastVSyncTimeMilliseconds, unsigned int nextVSyncTimeMilliseconds );
+ bool ProcessGestures( BufferIndex bufferIndex, unsigned int lastVSyncTimeMilliseconds, unsigned int nextVSyncTimeMilliseconds );
/**
* Perform animation updates
+ * @param[in] bufferIndex to use
* @param[in] elapsedSeconds time since last frame
*/
- void Animate( float elapsedSeconds );
+ void Animate( BufferIndex bufferIndex, float elapsedSeconds );
/**
* Perform constraint updates.
* @note Applies constraints to nodes first (depth first search order).
* Then shader constraints second (construction order)
+ * @param[in] bufferIndex to use
*/
- void ApplyConstraints();
+ void ApplyConstraints( BufferIndex bufferIndex );
/**
* Perform property notification updates
+ * @param[in] bufferIndex to use
*/
- void ProcessPropertyNotifications();
+ void ProcessPropertyNotifications( BufferIndex bufferIndex );
/**
* Pass shader binaries queued here on to event thread.
/**
* Update node shaders, opacity, geometry etc.
+ * @param[in] bufferIndex to use
+ */
+ void UpdateNodes( BufferIndex bufferIndex );
+
+ /**
+ * Update Renderers
+ * @param[in] bufferIndex to use
*/
- void UpdateNodes();
+ void UpdateRenderers( BufferIndex bufferIndex );
private:
new (slot) LocalType( &manager, &UpdateManager::AddNode, &node );
}
-inline void ConnectNodeMessage( UpdateManager& manager, const Node& constParent, const Node& constChild, int index )
+inline void ConnectNodeMessage( UpdateManager& manager, const Node& constParent, const Node& constChild )
{
// Update thread can edit the object
Node& parent = const_cast< Node& >( constParent );
Node& child = const_cast< Node& >( constChild );
- typedef MessageValue3< UpdateManager, Node*, Node*, int > LocalType;
+ typedef MessageValue2< UpdateManager, Node*, Node* > LocalType;
// Reserve some memory inside the message queue
unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
// Construct message in the message queue memory; note that delete should not be called on the return value
- new (slot) LocalType( &manager, &UpdateManager::ConnectNode, &parent, &child, index );
+ new (slot) LocalType( &manager, &UpdateManager::ConnectNode, &parent, &child );
}
inline void DisconnectNodeMessage( UpdateManager& manager, const Node& constNode )
new (slot) LocalType( &manager, &UpdateManager::AttachToNode, &parent, attachment );
}
-inline void AttachToSceneGraphMessage( UpdateManager& manager, RendererAttachment* renderer )
-{
- // @todo MESH_REWORK Pass by owner pointer after merge with SceneGraph::RenderableAttachment
- typedef MessageValue1< UpdateManager, RendererAttachment* > LocalType;
-
- // Reserve some memory inside the message queue
- unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
-
- // Construct message in the message queue memory; note that delete should not be called on the return value
- new (slot) LocalType( &manager, &UpdateManager::AttachToSceneGraph, renderer );
-}
-
inline void AddObjectMessage( UpdateManager& manager, PropertyOwner* object )
{
typedef MessageValue1< UpdateManager, OwnerPointer<PropertyOwner> > LocalType;
new (slot) LocalType( &owner, &ObjectOwnerContainer<T>::Remove, &object );
}
+inline void AddSamplerMessage( UpdateManager& manager, Render::Sampler& sampler )
+{
+ typedef MessageValue1< UpdateManager, Render::Sampler* > LocalType;
+
+ // Reserve some memory inside the message queue
+ unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
+
+ // Construct message in the message queue memory; note that delete should not be called on the return value
+ new (slot) LocalType( &manager, &UpdateManager::AddSampler, &sampler );
+}
+
+inline void RemoveSamplerMessage( UpdateManager& manager, Render::Sampler& sampler )
+{
+ typedef MessageValue1< UpdateManager, Render::Sampler* > LocalType;
+
+ // Reserve some memory inside the message queue
+ unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
+
+ // Construct message in the message queue memory; note that delete should not be called on the return value
+ new (slot) LocalType( &manager, &UpdateManager::RemoveSampler, &sampler );
+}
+
+inline void SetFilterModeMessage( UpdateManager& manager, Render::Sampler& sampler, unsigned int minFilterMode, unsigned int magFilterMode )
+{
+ typedef MessageValue3< UpdateManager, Render::Sampler*, unsigned int, unsigned int > LocalType;
+
+ // Reserve some memory inside the message queue
+ unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
+
+ // Construct message in the message queue memory; note that delete should not be called on the return value
+ new (slot) LocalType( &manager, &UpdateManager::SetFilterMode, &sampler, minFilterMode, magFilterMode );
+}
+
+inline void SetWrapModeMessage( UpdateManager& manager, Render::Sampler& sampler, unsigned int uWrapMode, unsigned int vWrapMode )
+{
+ typedef MessageValue3< UpdateManager, Render::Sampler*, unsigned int, unsigned int > LocalType;
+
+ // Reserve some memory inside the message queue
+ unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
+
+ // Construct message in the message queue memory; note that delete should not be called on the return value
+ new (slot) LocalType( &manager, &UpdateManager::SetWrapMode, &sampler, uWrapMode, vWrapMode );
+}
+
+inline void AddPropertyBuffer( UpdateManager& manager, Render::PropertyBuffer& propertyBuffer )
+{
+ typedef MessageValue1< UpdateManager, Render::PropertyBuffer* > LocalType;
+
+ // Reserve some memory inside the message queue
+ unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
+
+ // Construct message in the message queue memory; note that delete should not be called on the return value
+ new (slot) LocalType( &manager, &UpdateManager::AddPropertyBuffer, &propertyBuffer );
+}
+
+inline void RemovePropertyBuffer( UpdateManager& manager, Render::PropertyBuffer& propertyBuffer )
+{
+ typedef MessageValue1< UpdateManager, Render::PropertyBuffer* > LocalType;
+
+ // Reserve some memory inside the message queue
+ unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
+
+ // Construct message in the message queue memory; note that delete should not be called on the return value
+ new (slot) LocalType( &manager, &UpdateManager::RemovePropertyBuffer, &propertyBuffer );
+}
+
+inline void SetPropertyBufferFormat( UpdateManager& manager, Render::PropertyBuffer& propertyBuffer, Render::PropertyBuffer::Format* format )
+{
+ typedef MessageValue2< UpdateManager, Render::PropertyBuffer*, Render::PropertyBuffer::Format* > LocalType;
+
+ // Reserve some memory inside the message queue
+ unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
+
+ // Construct message in the message queue memory; note that delete should not be called on the return value
+ new (slot) LocalType( &manager, &UpdateManager::SetPropertyBufferFormat, &propertyBuffer, format );
+}
+
+inline void SetPropertyBufferData( UpdateManager& manager, Render::PropertyBuffer& propertyBuffer, Vector<char>* data )
+{
+ typedef MessageValue2< UpdateManager, Render::PropertyBuffer*, Vector<char>* > LocalType;
+
+ // Reserve some memory inside the message queue
+ unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
+
+ // Construct message in the message queue memory; note that delete should not be called on the return value
+ new (slot) LocalType( &manager, &UpdateManager::SetPropertyBufferData, &propertyBuffer, data );
+}
+
+inline void SetPropertyBufferSize( UpdateManager& manager, Render::PropertyBuffer& propertyBuffer, size_t size )
+{
+ typedef MessageValue2< UpdateManager, Render::PropertyBuffer*, size_t > LocalType;
+
+ // Reserve some memory inside the message queue
+ unsigned int* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
+
+ // Construct message in the message queue memory; note that delete should not be called on the return value
+ new (slot) LocalType( &manager, &UpdateManager::SetPropertyBufferSize, &propertyBuffer, size );
+}
+
+
} // namespace SceneGraph
} // namespace Internal
*/
// INTERNAL INCLUDES
+#include <dali/devel-api/common/owner-container.h>
#include <dali/internal/common/owner-pointer.h>
-#include <dali/internal/common/owner-container.h>
namespace Dali
{
#include <dali/internal/render/queue/render-queue.h>
#include <dali/internal/render/common/vertex.h>
#include <dali/internal/render/common/performance-monitor.h>
-#include <dali/internal/render/renderers/scene-graph-image-renderer.h>
-#include <dali/internal/render/renderers/scene-graph-renderer-declarations.h>
+#include <dali/internal/render/renderers/render-image-renderer.h>
#include <dali/internal/render/shaders/scene-graph-shader.h>
#include <dali/internal/update/node-attachments/scene-graph-image-attachment-debug.h>
{
// value types used by messages
-template <> struct ParameterType< SceneGraph::ImageRenderer::MeshType >
-: public BasicType< SceneGraph::ImageRenderer::MeshType > {};
+template <> struct ParameterType< Render::ImageRenderer::MeshType >
+: public BasicType< Render::ImageRenderer::MeshType > {};
namespace SceneGraph
{
mIsPixelAreaSet( false ),
mPreviousRefreshHints( 0 ),
mStyle( Dali::ImageActor::STYLE_QUAD ),
- mCullFaceMode( CullNone ),
- mUseBlend( false )
+ mCullFaceMode( CullNone )
{
}
{
DALI_ASSERT_DEBUG( NULL != mSceneController );
- // Get a reusable renderer from the pool
- mImageRenderer = mSceneController->NewImageRenderer( *mParent );
+ // Create main renderer, passing ownership to the render-thread
+ mImageRenderer = Render::ImageRenderer::New();
- mSceneController->GetRenderMessageDispatcher().AddImageRenderer( mImageRenderer, mParent );
+ mSceneController->GetRenderMessageDispatcher().AddRenderer( *mImageRenderer );
ATTACHMENT_LOG_FMT(Debug::General, " renderer: %p\n", mImageRenderer);
if( mTextureId != 0 )
{
- typedef MessageValue1< ImageRenderer, ResourceId > DerivedType;
+ typedef MessageValue1< Render::ImageRenderer, ResourceId > DerivedType;
// Reserve some memory inside the render queue
unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
// Construct message in the render queue memory; note that delete should not be called on the return value
- new (slot) DerivedType( mImageRenderer, &ImageRenderer::SetTextureId, mTextureId );
+ new (slot) DerivedType( mImageRenderer, &Render::ImageRenderer::SetTextureId, mTextureId );
}
- // send messages to renderer
- SendCullFaceChangeMessage( updateBufferIndex );
- SendShaderChangeMessage( updateBufferIndex );
+ // After derived classes have (potentially) created their renderer
+ Render::Renderer& renderer = GetRenderer();
+ renderer.SetCullFace( mCullFaceMode );
+
+ // set the default shader here as well
+ renderer.SetShader( mShader );
}
void ImageAttachment::OnDestroy2()
{
DALI_ASSERT_DEBUG( NULL != mSceneController );
- if( NULL != mImageRenderer )
- {
- // Request GL cleanup in the next Render
- mSceneController->GetRenderMessageDispatcher().RemoveImageRenderer( mImageRenderer );
-
- // Return reusable renderer to the pool
- mSceneController->FreeImageRenderer( *mImageRenderer );
-
- mImageRenderer = NULL;
- }
+ // Request deletion in the next Render
+ mSceneController->GetRenderMessageDispatcher().RemoveRenderer( *mImageRenderer );
+ mImageRenderer = NULL;
}
void ImageAttachment::ConnectedToSceneGraph()
{
}
-Renderer& ImageAttachment::GetRenderer()
+Render::Renderer& ImageAttachment::GetRenderer()
{
return *mImageRenderer;
}
-const Renderer& ImageAttachment::GetRenderer() const
+const Render::Renderer& ImageAttachment::GetRenderer() const
{
return *mImageRenderer;
}
if( mImageRenderer )
{
- typedef MessageValue1< ImageRenderer, ResourceId > DerivedType;
+ typedef MessageValue1< Render::ImageRenderer, ResourceId > DerivedType;
// Reserve some memory inside the render queue
unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
// Construct message in the render queue memory; note that delete should not be called on the return value
- new (slot) DerivedType( mImageRenderer, &ImageRenderer::SetTextureId, mTextureId );
+ new (slot) DerivedType( mImageRenderer, &Render::ImageRenderer::SetTextureId, mTextureId );
}
}
mIsPixelAreaSet = true;
{
- typedef MessageValue1< ImageRenderer, ImageRenderer::PixelArea > DerivedType;
+ typedef MessageValue1< Render::ImageRenderer, Render::ImageRenderer::PixelArea > DerivedType;
// Reserve some memory inside the render queue
unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
// Construct message in the render queue memory; note that delete should not be called on the return value
- new (slot) DerivedType( mImageRenderer, &ImageRenderer::SetPixelArea, pixelArea );
+ new (slot) DerivedType( mImageRenderer, &Render::ImageRenderer::SetPixelArea, pixelArea );
}
// we rely on attachment to not call us unless it actually did change
{
// update the 9 patch border information
- typedef MessageValue2< ImageRenderer, Vector4, bool > DerivedType;
+ typedef MessageValue2< Render::ImageRenderer, Vector4, bool > DerivedType;
// Reserve some memory inside the render queue
unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
// Construct message in the render queue memory; note that delete should not be called on the return value
- new (slot) DerivedType( mImageRenderer, &ImageRenderer::SetNinePatchBorder, border, inPixels );
+ new (slot) DerivedType( mImageRenderer, &Render::ImageRenderer::SetNinePatchBorder, border, inPixels );
if (mStyle != Dali::ImageActor::STYLE_QUAD)
{
void ImageAttachment::SetBlendingOptions( BufferIndex updateBufferIndex, unsigned int options )
{
// Blending options are forwarded to renderer in render-thread
- typedef MessageValue1< ImageRenderer, unsigned int > DerivedType;
+ typedef MessageValue1< Render::ImageRenderer, unsigned int > DerivedType;
// Reserve some memory inside the render queue
unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
// Construct message in the render queue memory; note that delete should not be called on the return value
- new (slot) DerivedType( mImageRenderer, &ImageRenderer::SetBlendingOptions, options );
+ new (slot) DerivedType( mImageRenderer, &Render::ImageRenderer::SetBlendingOptions, options );
}
void ImageAttachment::SetBlendColor( BufferIndex updateBufferIndex, const Vector4& color )
{
// Blend color is forwarded to renderer in render-thread
- typedef MessageValue1< ImageRenderer, Vector4 > DerivedType;
+ typedef MessageValue1< Render::ImageRenderer, Vector4 > DerivedType;
// Reserve some memory inside the render queue
unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
// Construct message in the render queue memory; note that delete should not be called on the return value
- new (slot) DerivedType( mImageRenderer, &ImageRenderer::SetBlendColor, color );
+ new (slot) DerivedType( mImageRenderer, &Render::ImageRenderer::SetBlendColor, color );
}
void ImageAttachment::SetCullFace( BufferIndex updateBufferIndex, CullFaceMode mode )
mCullFaceMode = mode;
- SendCullFaceChangeMessage( updateBufferIndex );
+ typedef MessageValue1< Render::Renderer, CullFaceMode > DerivedType;
+
+ // Reserve some memory inside the render queue
+ unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
+
+ // Construct message in the render queue memory; note that delete should not be called on the return value
+ new (slot) DerivedType( &GetRenderer(), &Render::Renderer::SetCullFace, mode );
}
void ImageAttachment::SetSampler( BufferIndex updateBufferIndex, unsigned int samplerBitfield )
{
DALI_ASSERT_DEBUG(mSceneController);
- typedef MessageValue1< Renderer, unsigned int > DerivedType;
+ typedef MessageValue1< Render::Renderer, unsigned int > DerivedType;
// Reserve some memory inside the render queue
unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
// Construct message in the render queue memory; note that delete should not be called on the return value
- new (slot) DerivedType( &GetRenderer(), &Renderer::SetSampler, samplerBitfield );
+ new (slot) DerivedType( &GetRenderer(), &Render::Renderer::SetSampler, samplerBitfield );
}
void ImageAttachment::ApplyShader( BufferIndex updateBufferIndex, Shader* shader )
mGeometrySize.x = actorSize.x;
mGeometrySize.y = actorSize.y;
- ImageRenderer::MeshType meshType = ImageRenderer::GRID_QUAD;
+ Render::ImageRenderer::MeshType meshType = Render::ImageRenderer::GRID_QUAD;
if ( !PreviousHintEnabled( Dali::ShaderEffect::HINT_GRID ) )
{
if ( mStyle == Dali::ImageActor::STYLE_NINE_PATCH )
{
- meshType = ImageRenderer::NINE_PATCH;
+ meshType = Render::ImageRenderer::NINE_PATCH;
}
else if ( mStyle == Dali::ImageActor::STYLE_NINE_PATCH_NO_CENTER )
{
- meshType = ImageRenderer::NINE_PATCH_NO_CENTER;
+ meshType = Render::ImageRenderer::NINE_PATCH_NO_CENTER;
}
else
{
- meshType = ImageRenderer::QUAD;
+ meshType = Render::ImageRenderer::QUAD;
}
}
else
{
if ( mStyle == Dali::ImageActor::STYLE_NINE_PATCH )
{
- meshType = ImageRenderer::GRID_NINE_PATCH;
+ meshType = Render::ImageRenderer::GRID_NINE_PATCH;
}
else if ( mStyle == Dali::ImageActor::STYLE_NINE_PATCH_NO_CENTER )
{
- meshType = ImageRenderer::GRID_NINE_PATCH_NO_CENTER;
+ meshType = Render::ImageRenderer::GRID_NINE_PATCH_NO_CENTER;
}
else
{
- meshType = ImageRenderer::GRID_QUAD;
+ meshType = Render::ImageRenderer::GRID_QUAD;
}
}
// Recalculate the mesh data in the next render
{
- typedef MessageValue3< ImageRenderer, ImageRenderer::MeshType, Vector2, bool > DerivedType;
+ typedef MessageValue3< Render::ImageRenderer, Render::ImageRenderer::MeshType, Vector2, bool > DerivedType;
// Reserve some memory inside the render queue
unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
// Construct message in the render queue memory; note that delete should not be called on the return value
- new (slot) DerivedType( mImageRenderer, &ImageRenderer::CalculateMeshData, meshType, mGeometrySize, mIsPixelAreaSet );
+ new (slot) DerivedType( mImageRenderer, &Render::ImageRenderer::CalculateMeshData, meshType, mGeometrySize, mIsPixelAreaSet );
}
mRefreshMeshData = false;
}
-
- bool blend = !IsFullyOpaque( updateBufferIndex );
-
- if ( mUseBlend != blend )
- {
- mUseBlend = blend;
-
- // Enable/disable blending in the next render
- typedef MessageValue1< ImageRenderer, bool > DerivedType;
-
- // Reserve some memory inside the render queue
- unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
-
- // Construct message in the render queue memory; note that delete should not be called on the return value
- new (slot) DerivedType( mImageRenderer, &ImageRenderer::SetUseBlend, blend );
- }
}
void RenderableAttachment::SetBlendingMode( BlendingMode::Type mode )
return fullyOpaque;
}
-void ImageAttachment::SendCullFaceChangeMessage( BufferIndex updateBufferIndex )
-{
- typedef MessageValue1< Renderer, CullFaceMode > DerivedType;
-
- // Reserve some memory inside the render queue
- unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
-
- // Construct message in the render queue memory; note that delete should not be called on the return value
- new (slot) DerivedType( &GetRenderer(), &Renderer::SetCullFace, mCullFaceMode );
-}
-
void ImageAttachment::SendShaderChangeMessage( BufferIndex updateBufferIndex )
{
- typedef MessageValue1< Renderer, Shader* > DerivedType;
+ typedef MessageValue1< Render::Renderer, Shader* > DerivedType;
// Reserve memory inside the render queue
unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
// Construct message in the mRenderer queue memory; note that delete should not be called on the return value
- new (slot) DerivedType( &GetRenderer(), &Renderer::SetShader, mShader );
+ new (slot) DerivedType( &GetRenderer(), &Render::Renderer::SetShader, mShader );
}
template <> struct ParameterType< Dali::ImageActor::Style >
: public BasicType< Dali::ImageActor::Style > {};
-namespace SceneGraph
+namespace Render
{
class ImageRenderer;
+}
+
+namespace SceneGraph
+{
class Shader;
class RenderQueue;
/**
* @copydoc RenderableAttachment::GetRenderer().
*/
- virtual Renderer& GetRenderer();
+ virtual Render::Renderer& GetRenderer();
/**
* @copydoc RenderableAttachment::GetRenderer().
*/
- virtual const Renderer& GetRenderer() const;
+ virtual const Render::Renderer& GetRenderer() const;
/**
* Set the ID used to retrieve a texture from ResourceManager.
ImageAttachment( unsigned int textureId );
private:
-
- /**
- * Sends the cull-face mode to the renderer
- * @param updateBufferIndex for the message buffer
- */
- void SendCullFaceChangeMessage( BufferIndex updateBufferIndex );
-
/**
* Sends the shader to the renderer
* @param updateBufferIndex for the message buffer
private: // Data
- ImageRenderer* mImageRenderer; ///< Raw-pointers to renderer that is owned by RenderManager
+ Render::ImageRenderer* mImageRenderer; ///< Raw-pointers to renderer that is owned by RenderManager
unsigned int mTextureId; ///< The resource ID for a texture
// bitfields to fit in single byte
int mPreviousRefreshHints : 4; ///< The shader geometry hints, when the vertex buffer was last refreshed, 4 bits is enough as there's 4 flags
Style mStyle : 2; ///< rendering style, 2 bits is enough as only 2 values in the enum
CullFaceMode mCullFaceMode : 3; ///< Cullface mode, 3 bits is enough for 4 values
- bool mUseBlend : 1; ///< True if the attachment & renderer should be considered opaque for sorting and blending.
BitmapMetadata mBitmapMetadata;///< The bitmap metadata
Vector2 mGeometrySize; ///< The size of the currently used geometry
#include <dali/internal/update/resources/complete-status-manager.h>
#include <dali/internal/update/resources/resource-tracker.h>
#include <dali/internal/render/queue/render-queue.h>
-#include <dali/internal/render/renderers/scene-graph-renderer.h>
+#include <dali/internal/render/renderers/render-renderer.h>
#include <dali/internal/render/shaders/scene-graph-shader.h>
#include <dali/internal/common/image-sampler.h>
bool RenderableAttachment::ResolveVisibility( BufferIndex updateBufferIndex )
{
- mHasSizeAndColorFlag = false;
- const Vector4& color = mParent->GetWorldColor( updateBufferIndex );
- if( color.a > FULLY_TRANSPARENT ) // not fully transparent
- {
- const float MAX_NODE_SIZE = float(1u<<30);
- const Vector3& size = mParent->GetSize( updateBufferIndex );
- if( ( size.width > Math::MACHINE_EPSILON_1000 ) && // width is greater than a very small number
- ( size.height > Math::MACHINE_EPSILON_1000 ) ) // height is greater than a very small number
- {
- if( ( size.width < MAX_NODE_SIZE ) && // width is smaller than the maximum allowed size
- ( size.height < MAX_NODE_SIZE ) ) // height is smaller than the maximum allowed size
- {
- mHasSizeAndColorFlag = true;
- }
- else
- {
- DALI_LOG_ERROR("Actor size should not be bigger than %f.\n", MAX_NODE_SIZE );
- DALI_LOG_ACTOR_TREE( mParent );
- }
- }
- }
+ mHasSizeAndColorFlag = mParent->ResolveVisibility(updateBufferIndex);
return mHasSizeAndColorFlag;
}
void RenderableAttachment::SetSortAttributes( BufferIndex bufferIndex, RendererWithSortAttributes& sortAttributes )
{
sortAttributes.shader = mShader;
- sortAttributes.material = NULL;
+ sortAttributes.textureResourceId = Integration::InvalidResourceId;
sortAttributes.geometry = NULL;
}
#include <dali/internal/update/nodes/node.h>
#include <dali/internal/update/node-attachments/node-attachment.h>
#include <dali/internal/update/resources/resource-manager-declarations.h>
-#include <dali/internal/render/renderers/scene-graph-renderer-declarations.h>
namespace Dali
{
class ResourceManager;
class ResourceTracker;
-namespace SceneGraph
+namespace Render
{
class Renderer;
+}
+namespace SceneGraph
+{
class Shader;
class SortAttributes;
struct RendererWithSortAttributes;
* should always exist during the lifetime of the RenderableAttachment.
* @return A Renderer.
*/
- virtual Renderer& GetRenderer() = 0;
+ virtual Render::Renderer& GetRenderer() = 0;
/**
* Retrieve a Renderer used by this attachment.
* Other renderers are for effects such as shadows and reflections.
* @return A Renderer.
*/
- virtual const Renderer& GetRenderer() const = 0;
+ virtual const Render::Renderer& GetRenderer() const = 0;
/**
* Prepare the object resources.
+++ /dev/null
-/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "scene-graph-renderer-attachment.h"
-#include <dali/internal/update/common/uniform-map.h>
-#include <dali/internal/update/manager/prepare-render-instructions.h>
-#include <dali/internal/update/rendering/scene-graph-geometry.h>
-#include <dali/internal/update/rendering/scene-graph-material.h>
-#include <dali/internal/update/rendering/scene-graph-sampler.h>
-#include <dali/internal/update/resources/complete-status-manager.h>
-#include <dali/internal/update/resources/resource-manager.h>
-#include <dali/internal/render/data-providers/render-data-provider.h>
-#include <dali/internal/render/queue/render-queue.h>
-#include <dali/internal/render/renderers/render-renderer.h>
-#include <dali/internal/render/shaders/scene-graph-shader.h>
-
-#if defined(DEBUG_ENABLED)
-Debug::Filter* gImageAttachmentLogFilter = Debug::Filter::New(Debug::NoLogging, false, "LOG_SCENE_GRAPH_IMAGE_ATTACHMENT");
-
-#define ATTACHMENT_LOG(level) \
- DALI_LOG_INFO(gImageAttachmentLogFilter, level, "SceneGraph::ImageAttachment::%s: this:%p\n", __FUNCTION__, this)
-#define ATTACHMENT_LOG_FMT(level, format, args...) \
- DALI_LOG_INFO(gImageAttachmentLogFilter, level, "SceneGraph::ImageAttachment::%s: this:%p " format, __FUNCTION__, this, ## args)
-
-#else
-
-#define ATTACHMENT_LOG(level)
-#define ATTACHMENT_LOG_FMT(level, format, args...)
-
-#endif
-
-
-namespace // unnamed namespace
-{
-const int REGENERATE_UNIFORM_MAP = 2;
-const int COPY_UNIFORM_MAP = 1;
-}
-
-namespace Dali
-{
-namespace Internal
-{
-namespace SceneGraph
-{
-
-RendererAttachment* RendererAttachment::New()
-{
- return new RendererAttachment();
-}
-
-
-RendererAttachment::RendererAttachment()
-: RenderableAttachment( false ),
- mRenderer(NULL),
- mMaterial(NULL),
- mGeometry(NULL),
- mRegenerateUniformMap(REGENERATE_UNIFORM_MAP),
- mResendDataProviders(false),
- mResendGeometry(false),
- mUseBlend( false ),
- mDepthIndex(0)
-{
- mUniformMapChanged[0]=false;
- mUniformMapChanged[1]=false;
-
- // Observe our own PropertyOwner's uniform map
- AddUniformMapObserver( *this );
-}
-
-
-RendererAttachment::~RendererAttachment()
-{
- if (mMaterial)
- {
- mMaterial->RemoveConnectionObserver(*this);
- mMaterial=NULL;
- }
- if (mGeometry)
- {
- mGeometry->RemoveConnectionObserver(*this);
- mGeometry=NULL;
- }
-}
-
-void RendererAttachment::Initialize2( BufferIndex updateBufferIndex )
-{
- DALI_ASSERT_DEBUG( mSceneController );
-}
-
-void RendererAttachment::OnDestroy2()
-{
-}
-
-void RendererAttachment::ConnectedToSceneGraph()
-{
- mRegenerateUniformMap = REGENERATE_UNIFORM_MAP;
- mParent->AddUniformMapObserver( *this ); // Watch actor's uniform maps
-
- DALI_ASSERT_DEBUG( mParent != NULL );
-
- RenderDataProvider* dataProvider = NewRenderDataProvider();
-
- RenderGeometry* renderGeometry = mGeometry->GetRenderGeometry(mSceneController);
- mRenderer = NewRenderer::New( *mParent, dataProvider, renderGeometry );
- mSceneController->GetRenderMessageDispatcher().AddRenderer( *mRenderer );
-}
-
-void RendererAttachment::DisconnectedFromSceneGraph()
-{
- mRegenerateUniformMap = 0;
- mParent->RemoveUniformMapObserver( *this );
-
- mGeometry->OnRendererDisconnect();
-
- DALI_ASSERT_DEBUG( mSceneController );
- mSceneController->GetRenderMessageDispatcher().RemoveRenderer( *mRenderer );
- mRenderer = NULL;
-}
-
-void RendererAttachment::SetMaterial( BufferIndex updateBufferIndex, Material* material)
-{
- DALI_ASSERT_DEBUG( material != NULL && "Material pointer is NULL" );
-
- mMaterial = material;
- mMaterial->AddConnectionObserver( *this );
- mRegenerateUniformMap = REGENERATE_UNIFORM_MAP;
-
- mResendDataProviders = true;
-}
-
-Material& RendererAttachment::GetMaterial()
-{
- return *mMaterial;
-}
-
-void RendererAttachment::SetGeometry( BufferIndex updateBufferIndex, Geometry* geometry)
-{
- DALI_ASSERT_DEBUG( geometry != NULL && "Geometry pointer is NULL");
- if( mGeometry)
- {
- mGeometry->RemoveConnectionObserver(*this);
- mGeometry->OnRendererDisconnect();
- }
-
- mGeometry = geometry;
- mGeometry->AddConnectionObserver( *this ); // Observe geometry connections / uniform mapping changes
- mRegenerateUniformMap = REGENERATE_UNIFORM_MAP;
-
- if( mRenderer )
- {
- mResendGeometry = true;
- }
-}
-
-Geometry& RendererAttachment::GetGeometry()
-{
- return *mGeometry;
-}
-
-void RendererAttachment::SetSortAttributes( BufferIndex bufferIndex, RendererWithSortAttributes& sortAttributes )
-{
- sortAttributes.shader = mMaterial->GetShader();
- sortAttributes.material = mMaterial;
- sortAttributes.geometry = mGeometry;
-}
-
-void RendererAttachment::SetDepthIndex( int depthIndex )
-{
- mDepthIndex = depthIndex;
-
- if( mParent )
- {
- // only do this if we are on-stage. Ensures the render lists are re-sorted
- mParent->SetDirtyFlag( SortModifierFlag );
- }
-}
-
-Renderer& RendererAttachment::GetRenderer()
-{
- return *mRenderer;
-}
-
-const Renderer& RendererAttachment::GetRenderer() const
-{
- return *mRenderer;
-}
-
-// Called by ProcessRenderTasks after DoPrepareRender
-bool RendererAttachment::IsFullyOpaque( BufferIndex updateBufferIndex )
-{
- bool opaque = false;
-
- if( mMaterial != NULL )
- {
- Material::BlendPolicy blendPolicy = mMaterial->GetBlendPolicy();
- switch( blendPolicy )
- {
- case Material::OPAQUE:
- {
- opaque = true;
- break;
- }
- case Material::TRANSPARENT:
- {
- opaque = false;
- break;
- }
- case Material::USE_ACTOR_COLOR:
- {
- if( mParent )
- {
- opaque = mParent->GetWorldColor( updateBufferIndex ).a >= FULLY_OPAQUE;
- }
- break;
- }
- }
- }
-
- return opaque;
-}
-
-void RendererAttachment::SizeChanged( BufferIndex updateBufferIndex )
-{
- // Do nothing.
-}
-
-bool RendererAttachment::DoPrepareResources(
- BufferIndex updateBufferIndex,
- ResourceManager& resourceManager )
-{
- DALI_ASSERT_DEBUG( mSceneController );
-
- CompleteStatusManager& completeStatusManager = mSceneController->GetCompleteStatusManager();
- bool ready = false;
- mFinishedResourceAcquisition = false;
-
- // Can only be considered ready when all the scene graph objects are connected to the renderer
- if( ( mGeometry ) &&
- ( mGeometry->GetVertexBuffers().Count() > 0 ) &&
- ( mMaterial ) &&
- ( mMaterial->GetShader() != NULL ) )
- {
- unsigned int completeCount = 0;
- unsigned int neverCount = 0;
- unsigned int frameBufferCount = 0;
-
- Vector<Sampler*>& samplers = mMaterial->GetSamplers();
- for( Vector<Sampler*>::ConstIterator iter = samplers.Begin();
- iter != samplers.End(); ++iter )
- {
- Sampler* sampler = *iter;
-
- ResourceId textureId = sampler->GetTextureId( updateBufferIndex );
- BitmapMetadata metaData = resourceManager.GetBitmapMetadata( textureId );
-
- sampler->SetFullyOpaque( metaData.IsFullyOpaque() );
-
- switch( completeStatusManager.GetStatus( textureId ) )
- {
- case CompleteStatusManager::NOT_READY:
- {
- if( metaData.GetIsFramebuffer() )
- {
- frameBufferCount++;
- }
- FollowTracker( textureId ); // @todo MESH_REWORK Trackers per sampler rather than per actor?
- }
- break;
-
- case CompleteStatusManager::COMPLETE:
- {
- completeCount++;
- }
- break;
-
- case CompleteStatusManager::NEVER:
- {
- neverCount++;
- }
- break;
- }
- }
-
- // We are ready if all samplers are complete, or those that aren't are framebuffers
- // We are complete if all samplers are either complete or will never complete
-
- ready = ( completeCount + frameBufferCount >= samplers.Count() ) ;
- mFinishedResourceAcquisition = ( completeCount + neverCount >= samplers.Count() );
- }
-
- return ready;
-}
-
-
-// Uniform maps are checked in the following priority order:
-// Renderer (this object)
-// Actor
-// Material
-// Samplers
-// Shader
-// Geometry
-// VertexBuffers
-void RendererAttachment::DoPrepareRender( BufferIndex updateBufferIndex )
-{
- // @todo MESH_REWORK - call DoPrepareRender on all scene objects? in caller class?
- mMaterial->PrepareRender( updateBufferIndex );
-
- if( mRegenerateUniformMap > 0)
- {
- if( mRegenerateUniformMap == REGENERATE_UNIFORM_MAP)
- {
- DALI_ASSERT_DEBUG( mGeometry != NULL && "No geometry available in DoPrepareRender()" );
- DALI_ASSERT_DEBUG( mMaterial != NULL && "No geometry available in DoPrepareRender()" );
-
- CollectedUniformMap& localMap = mCollectedUniformMap[ updateBufferIndex ];
- localMap.Resize(0);
-
- const UniformMap& rendererUniformMap = PropertyOwner::GetUniformMap();
- AddMappings( localMap, rendererUniformMap );
-
- const UniformMap& actorUniformMap = mParent->GetUniformMap();
- AddMappings( localMap, actorUniformMap );
-
- AddMappings( localMap, mMaterial->GetUniformMap() );
- Vector<Sampler*>& samplers = mMaterial->GetSamplers();
- for( Vector<Sampler*>::ConstIterator iter = samplers.Begin(), end = samplers.End();
- iter != end ;
- ++iter )
- {
- const SceneGraph::Sampler* sampler = (*iter);
- AddMappings( localMap, sampler->GetUniformMap() );
- }
-
- AddMappings( localMap, mMaterial->GetShader()->GetUniformMap() );
-
- AddMappings( localMap, mGeometry->GetUniformMap() );
-
- Vector<PropertyBuffer*>& vertexBuffers = mGeometry->GetVertexBuffers();
- for( Vector<PropertyBuffer*>::ConstIterator iter = vertexBuffers.Begin(), end = vertexBuffers.End() ;
- iter != end ;
- ++iter )
- {
- const SceneGraph::PropertyBuffer* vertexBuffer = *iter;
- AddMappings( localMap, vertexBuffer->GetUniformMap() );
- }
-
- PropertyBuffer* indexBuffer = mGeometry->GetIndexBuffer();
- if( indexBuffer )
- {
- AddMappings( localMap, indexBuffer->GetUniformMap() );
- }
-
- mUniformMapChanged[updateBufferIndex] = true;
- }
- else if( mRegenerateUniformMap == COPY_UNIFORM_MAP )
- {
- // Copy old map into current map
- CollectedUniformMap& localMap = mCollectedUniformMap[ updateBufferIndex ];
- CollectedUniformMap& oldMap = mCollectedUniformMap[ 1-updateBufferIndex ];
-
- localMap.Resize( oldMap.Count() );
-
- unsigned int index=0;
- for( CollectedUniformMap::Iterator iter = oldMap.Begin(), end = oldMap.End() ; iter != end ; ++iter, ++index )
- {
- localMap[index] = *iter;
- }
-
- mUniformMapChanged[updateBufferIndex] = true;
- }
-
- mRegenerateUniformMap--;
- }
-
- bool blend = !IsFullyOpaque( updateBufferIndex );
- if( mUseBlend != blend )
- {
- mUseBlend = blend;
- mResendDataProviders = true;
- }
-
- if( mResendDataProviders )
- {
- RenderDataProvider* dataProvider = NewRenderDataProvider();
-
- // Tell renderer about a new provider
- // @todo MESH_REWORK Should we instead create a new renderer when these change?
-
- typedef MessageValue1< NewRenderer, OwnerPointer<RenderDataProvider> > DerivedType;
- unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
- new (slot) DerivedType( mRenderer, &NewRenderer::SetRenderDataProvider, dataProvider );
- mResendDataProviders = false;
- }
-
- if( mResendGeometry )
- {
- // The first call to GetRenderGeometry() creates the geometry and sends it in a message
- RenderGeometry* geometry = mGeometry->GetRenderGeometry( mSceneController );
-
- typedef MessageValue1< NewRenderer, RenderGeometry* > DerivedType;
- unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
-
- new (slot) DerivedType( mRenderer, &NewRenderer::SetGeometry, geometry );
- mResendGeometry = false;
- }
-}
-
-void RendererAttachment::ConnectionsChanged( PropertyOwner& object )
-{
- // One of our child objects has changed it's connections. Ensure the uniform
- // map gets regenerated during PrepareRender
- mRegenerateUniformMap = REGENERATE_UNIFORM_MAP;
-
- // Ensure the child object pointers get re-sent to the renderer
- mResendDataProviders = true;
-}
-
-void RendererAttachment::ConnectedUniformMapChanged()
-{
- mRegenerateUniformMap = REGENERATE_UNIFORM_MAP;
-}
-
-void RendererAttachment::UniformMappingsChanged( const UniformMap& mappings )
-{
- // The mappings are either from PropertyOwner base class, or the Actor
- mRegenerateUniformMap = REGENERATE_UNIFORM_MAP;
-}
-
-bool RendererAttachment::GetUniformMapChanged( BufferIndex bufferIndex ) const
-{
- return mUniformMapChanged[bufferIndex];
-}
-
-const CollectedUniformMap& RendererAttachment::GetUniformMap( BufferIndex bufferIndex ) const
-{
- return mCollectedUniformMap[ bufferIndex ];
-}
-
-void RendererAttachment::AddMappings( CollectedUniformMap& localMap, const UniformMap& uniformMap )
-{
- // Iterate thru uniformMap.
- // Any maps that aren't in localMap should be added in a single step
- CollectedUniformMap newUniformMappings;
-
- for( unsigned int i=0, count=uniformMap.Count(); i<count; ++i )
- {
- UniformPropertyMapping::Hash nameHash = uniformMap[i].uniformNameHash;
- bool found = false;
-
- for( CollectedUniformMap::Iterator iter = localMap.Begin() ; iter != localMap.End() ; ++iter )
- {
- const UniformPropertyMapping* map = (*iter);
- if( map->uniformNameHash == nameHash )
- {
- if( map->uniformName == uniformMap[i].uniformName )
- {
- found = true;
- break;
- }
- }
- }
- if( !found )
- {
- // it's a new mapping. Add raw ptr to temporary list
- newUniformMappings.PushBack( &uniformMap[i] );
- }
- }
-
- if( newUniformMappings.Count() > 0 )
- {
- localMap.Reserve( localMap.Count() + newUniformMappings.Count() );
-
- for( CollectedUniformMap::Iterator iter = newUniformMappings.Begin(),
- end = newUniformMappings.End() ;
- iter != end ;
- ++iter )
- {
- const UniformPropertyMapping* map = (*iter);
- localMap.PushBack( map );
- }
- //@todo MESH_REWORK Use memcpy to copy ptrs from one array to the other
- }
-}
-
-RenderDataProvider* RendererAttachment::NewRenderDataProvider()
-{
- RenderDataProvider* dataProvider = new RenderDataProvider();
-
- dataProvider->mMaterialDataProvider = mMaterial;
- dataProvider->mUniformMapDataProvider = this;
- dataProvider->mShader = mMaterial->GetShader();
- dataProvider->mUseBlend = mUseBlend;
-
- Vector<Sampler*>& samplers = mMaterial->GetSamplers();
- dataProvider->mSamplers.Reserve( samplers.Count() );
- for( Vector<Sampler*>::Iterator iter = samplers.Begin() ;
- iter != samplers.End();
- ++iter )
- {
- dataProvider->mSamplers.PushBack(*iter); // Convert from derived type to base type
- }
- return dataProvider;
-}
-
-
-} // namespace SceneGraph
-} // namespace Internal
-} // namespace Dali
+++ /dev/null
-#ifndef DALI_INTERNAL_SCENE_GRAPH_RENDERER_ATTACHMENT_H
-#define DALI_INTERNAL_SCENE_GRAPH_RENDERER_ATTACHMENT_H
-
-/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <dali/internal/event/common/event-thread-services.h>
-#include <dali/internal/update/common/double-buffered.h>
-#include <dali/internal/update/common/property-owner.h>
-#include <dali/internal/update/common/animatable-property.h>
-#include <dali/internal/update/common/scene-graph-connection-change-propagator.h>
-#include <dali/internal/update/controllers/render-message-dispatcher.h>
-#include <dali/internal/update/controllers/scene-controller.h>
-#include <dali/internal/update/node-attachments/scene-graph-renderable-attachment.h>
-#include <dali/internal/render/data-providers/render-data-provider.h>
-
-namespace Dali
-{
-namespace Internal
-{
-namespace SceneGraph
-{
-class Material;
-class Geometry;
-class NewRenderer;
-struct RendererWithSortAttributes;
-
-/**
- * The renderer attachment is the SceneGraph equivalent of Dali::Renderer. It is used to create an instance of a geometry and material for rendering, and is attached to an actor.
- *
- * It observes it's children (Material and Geometry) for connection change and for uniform map change, and observer's it's actor parent for uniform map change - this allows it to re-generate the uniform maps used by its RenderThread equivalent class.
- *
- * Lifetime and ownership
- * It is created when a Dali::Renderer is created, and sent to UpdateManager. At this point
- * Initialize is called on the object, but ownership is NOT taken by UpdateManager.
-
- * When a Dali::Renderer is added to an actor, then this object becomes the node attachment
- * for that actor, and the node takes ownership. It will create the Render::NewRenderer object
- * in the Update thread on reciept of the connection message.
-
- * When it's not attached to an actor, it is still possible to send messages to this
- * object, to, e.g., set the material, or a property.
- *
- * @todo MESH_REWORK On merge with RenderableAttachment, change owner of all attachments to UpdateManager.
- */
-class RendererAttachment : public RenderableAttachment,
- public PropertyOwner,
- public UniformMapDataProvider,
- public UniformMap::Observer,
- public ConnectionChangePropagator::Observer
-{
-public:
- /**
- * Create a new renderer attachment.
- * @return The newly allocated RendererAttachment
- */
- static RendererAttachment* New();
-
- /**
- * Constructor
- */
- RendererAttachment();
-
- /**
- * Destructor
- */
- virtual ~RendererAttachment();
-
- /**
- * @copydoc RenderableAttachment::Initialize2().
- */
- virtual void Initialize2( BufferIndex updateBufferIndex );
-
- /**
- * @copydoc RenderableAttachment::OnDestroy2().
- */
- virtual void OnDestroy2();
-
- /**
- * @copydoc NodeAttachment::ConnectedToSceneGraph()
- */
- virtual void ConnectedToSceneGraph();
-
- /**
- * @copydoc NodeAttachment::DisconnectedFromSceneGraph()
- */
- virtual void DisconnectedFromSceneGraph();
-
- /**
- * Set the material for the renderer
- * @param[in] bufferIndex The current frame's buffer index
- * @param[in] material The material this renderer will use
- */
- void SetMaterial( BufferIndex bufferIndex, Material* material);
-
- /**
- * Get the material of this renderer
- * @return the material this renderer uses
- */
- Material& GetMaterial();
-
- /**
- * Set the geometry for the renderer
- * @param[in] bufferIndex The current frame's buffer index
- * @param[in] geometry The geometry this renderer will use
- */
- void SetGeometry( BufferIndex bufferIndex, Geometry* geometry);
-
- /**
- * Get the geometry of this renderer
- * @return the geometry this renderer uses
- */
- Geometry& GetGeometry();
-
- /**
- * Set the depth index
- * @param[in] depthIndex the new depth index to use
- */
- void SetDepthIndex( int depthIndex );
-
-protected: // From NodeAttachment
- /**
- * @brief Get the depth index
- * @return The depth index
- */
- virtual int GetDepthIndex()
- {
- return mDepthIndex;
- }
-
- /**
- * Write the attachment's sort attributes to the passed in reference.
- * @param[in] bufferIndex The buffer index
- * @param[out] sortAttributes
- */
- virtual void SetSortAttributes( BufferIndex bufferIndex, RendererWithSortAttributes& sortAttributes );
-
-protected: // From RenderableAttachment
- /**
- * @copydoc RenderableAttachment::GetRenderer().
- */
- virtual Renderer& GetRenderer();
-
- /**
- * @copydoc RenderableAttachment::GetRenderer().
- */
- virtual const Renderer& GetRenderer() const;
-
- /**
- * @copydoc RenderableAttachment::DoPrepareResources()
- */
- virtual bool DoPrepareResources( BufferIndex updateBufferIndex,
- ResourceManager& resourceManager );
-
- /**
- * @copydoc RenderableAttachment::DoPrepareRender()
- */
- virtual void DoPrepareRender( BufferIndex updateBufferIndex );
-
- /**
- * @copydoc RenderableAttachment::IsFullyOpaque()
- */
- virtual bool IsFullyOpaque( BufferIndex updateBufferIndex );
-
- /**
- * @copydoc RenderableAttachment::SizeChanged()
- */
- virtual void SizeChanged( BufferIndex updateBufferIndex );
-
-protected: // From ConnectionObserver
- /**
- * @copydoc ConnectionObservers::Observer::ConnectionsChanged
- */
- virtual void ConnectionsChanged(PropertyOwner& object);
-
- /**
- * @copydoc ConnectionObservers::Observer::ConnectedUniformMapChanged
- */
- virtual void ConnectedUniformMapChanged();
-
-protected: // From UniformMap::Observer
- /**
- * @copydoc UniformMap::Observer::UniformMappingsChanged
- */
- virtual void UniformMappingsChanged( const UniformMap& mappings );
-
-protected: // From UniformMapDataProvider
- /**
- * @copydoc UniformMapDataProvider::GetUniformMapChanged
- */
- virtual bool GetUniformMapChanged( BufferIndex bufferIndex ) const;
-
- /**
- * @copydoc UniformMapDataProvider::GetUniformMap
- */
- virtual const CollectedUniformMap& GetUniformMap( BufferIndex bufferIndex ) const;
-
-private:
- /**
- * Add any new mappings from map into the current map.
- * This doesn't override any existing mappings.
- * @param[in] localMap The map of collected uniforms.
- * @param[in] map The map to import into the local map
- */
- void AddMappings( CollectedUniformMap& localMap, const UniformMap& map );
-
- /**
- * Create a new render data provider
- * @return the new (initialized) data provider
- */
- RenderDataProvider* NewRenderDataProvider();
-
-private:
- NewRenderer* mRenderer; ///< Raw pointer to the new renderer (that's owned by RenderManager)
-
- Material* mMaterial; ///< The material this renderer uses. (Not owned)
- Geometry* mGeometry; ///< The geometry this renderer uses. (Not owned)
-
- CollectedUniformMap mCollectedUniformMap[2];
- int mRegenerateUniformMap; ///< 2 if the map should be regenerated, 1 if it should be copied.
- bool mUniformMapChanged[2]; ///< Records if the uniform map has been altered this frame
- bool mResendDataProviders : 1; ///< True if the data providers should be resent to the renderer
- bool mResendGeometry : 1; ///< True if geometry should be resent to the renderer
- bool mUseBlend : 1; ///< True if the attachment & renderer should be considered opaque for sorting and blending.
-public: // Properties
-
- int mDepthIndex; ///< Used only in PrepareRenderInstructions
-};
-
-// Messages for RendererAttachment
-
-inline void SetMaterialMessage( EventThreadServices& eventThreadServices, const RendererAttachment& attachment, const Material& material )
-{
- typedef MessageDoubleBuffered1< RendererAttachment, Material* > LocalType;
-
- // Reserve some memory inside the message queue
- unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
-
- // Construct message in the message queue memory; note that delete should not be called on the return value
- new (slot) LocalType( &attachment, &RendererAttachment::SetMaterial, const_cast<Material*>(&material) );
-}
-
-inline void SetGeometryMessage( EventThreadServices& eventThreadServices, const RendererAttachment& attachment, const Geometry& geometry )
-{
- typedef MessageDoubleBuffered1< RendererAttachment, Geometry* > LocalType;
-
- // Reserve some memory inside the message queue
- unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
-
- // Construct message in the message queue memory; note that delete should not be called on the return value
- new (slot) LocalType( &attachment, &RendererAttachment::SetGeometry, const_cast<Geometry*>(&geometry) );
-}
-
-inline void SetDepthIndexMessage( EventThreadServices& eventThreadServices, const RendererAttachment& attachment, int depthIndex )
-{
- typedef MessageValue1< RendererAttachment, int > LocalType;
-
- // Reserve some memory inside the message queue
- unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
-
- // Construct message in the message queue memory; note that delete should not be called on the return value
- new (slot) LocalType( &attachment, &RendererAttachment::SetDepthIndex, depthIndex );
-}
-
-} // namespace SceneGraph
-} // namespace Internal
-} // namespace Dali
-
-
-#endif // DALI_INTERNAL_SCENE_GRAPH_RENDERER_ATTACHMENT_H
// INTERNAL INCLUDES
#include <dali/public-api/common/dali-vector.h>
+#include <dali/devel-api/common/owner-container.h>
#include <dali/internal/common/owner-pointer.h>
-#include <dali/internal/common/owner-container.h>
namespace Dali
{
#include <dali/internal/update/common/discard-queue.h>
#include <dali/public-api/common/dali-common.h>
#include <dali/public-api/common/constants.h>
+#include <dali/internal/common/internal-constants.h>
namespace Dali
{
mExclusiveRenderTask( NULL ),
mAttachment( NULL ),
mChildren(),
+ mRegenerateUniformMap( 0 ),
mDepth(0u),
mDirtyFlags(AllFlags),
mIsRoot( false ),
mPositionInheritanceMode( DEFAULT_POSITION_INHERITANCE_MODE ),
mColorMode( DEFAULT_COLOR_MODE )
{
+ mUniformMapChanged[0] = 0u;
+ mUniformMapChanged[1] = 0u;
}
Node::~Node()
mIsRoot = isRoot;
}
-void Node::ConnectChild( Node* childNode, int index )
+bool Node::ResolveVisibility( BufferIndex updateBufferIndex )
+{
+ bool result = false;
+ const Vector4& color = GetWorldColor( updateBufferIndex );
+ if( color.a > FULLY_TRANSPARENT ) // not fully transparent
+ {
+ const float MAX_NODE_SIZE = float(1u<<30);
+ const Vector3& size = GetSize( updateBufferIndex );
+ if( ( size.width > Math::MACHINE_EPSILON_1000 ) && // width is greater than a very small number
+ ( size.height > Math::MACHINE_EPSILON_1000 ) ) // height is greater than a very small number
+ {
+ if( ( size.width < MAX_NODE_SIZE ) && // width is smaller than the maximum allowed size
+ ( size.height < MAX_NODE_SIZE ) ) // height is smaller than the maximum allowed size
+ {
+ result = true;
+ }
+ else
+ {
+ DALI_LOG_ERROR("Actor size should not be bigger than %f.\n", MAX_NODE_SIZE );
+ DALI_LOG_ACTOR_TREE( mParent );
+ }
+ }
+ }
+ return result;
+}
+
+void Node::AddUniformMapping( UniformPropertyMapping* map )
+{
+ PropertyOwner::AddUniformMapping( map );
+ mRegenerateUniformMap = 2;
+}
+
+void Node::RemoveUniformMapping( const std::string& uniformName )
+{
+ PropertyOwner::RemoveUniformMapping( uniformName );
+ mRegenerateUniformMap = 2;
+}
+
+void Node::PrepareRender( BufferIndex bufferIndex )
+{
+ if(mRegenerateUniformMap != 0 )
+ {
+ if( mRegenerateUniformMap == 2 )
+ {
+ CollectedUniformMap& localMap = mCollectedUniformMap[ bufferIndex ];
+ localMap.Resize(0);
+
+ for( unsigned int i=0, count=mUniformMaps.Count(); i<count; ++i )
+ {
+ localMap.PushBack( &mUniformMaps[i] );
+ }
+ }
+ else if( mRegenerateUniformMap == 1 )
+ {
+ CollectedUniformMap& localMap = mCollectedUniformMap[ bufferIndex ];
+ CollectedUniformMap& oldMap = mCollectedUniformMap[ 1-bufferIndex ];
+
+ localMap.Resize( oldMap.Count() );
+
+ unsigned int index=0;
+ for( CollectedUniformMap::Iterator iter = oldMap.Begin(), end = oldMap.End() ; iter != end ; ++iter, ++index )
+ {
+ localMap[index] = *iter;
+ }
+ }
+ --mRegenerateUniformMap;
+ mUniformMapChanged[bufferIndex] = 1u;
+ }
+}
+
+void Node::ConnectChild( Node* childNode )
{
DALI_ASSERT_ALWAYS( this != childNode );
DALI_ASSERT_ALWAYS( IsRoot() || NULL != mParent ); // Parent should be connected first
// Everything should be reinherited when reconnected to scene-graph
childNode->SetAllDirtyFlags();
- if (index == -1)
- {
- mChildren.PushBack( childNode );
- }
- else
- {
- mChildren.Insert(mChildren.Begin()+index, childNode);
- }
+ // Add the node to the end of the child list.
+ mChildren.PushBack( childNode );
// Inform property observers of new connection
childNode->ConnectToSceneGraph();
found->RecursiveDisconnectFromSceneGraph( updateBufferIndex, connectedNodes, disconnectedNodes );
}
+void Node::RemoveRenderer( Renderer* renderer )
+{
+ unsigned int rendererCount( mRenderer.Size() );
+ for( unsigned int i(0); i<rendererCount; ++i )
+ {
+ if( mRenderer[i] == renderer )
+ {
+ mRenderer.Erase( mRenderer.Begin()+i);
+ return;
+ }
+ }
+}
+
int Node::GetDirtyFlags() const
{
// get initial dirty flags, they are reset ResetDefaultProperties, but setters may have made the node dirty already
#include <dali/internal/update/nodes/node-declarations.h>
#include <dali/internal/update/node-attachments/node-attachment-declarations.h>
#include <dali/internal/render/data-providers/node-data-provider.h>
+#include <dali/internal/update/rendering/scene-graph-renderer.h>
namespace Dali
{
}
/**
+ * Add a renderer to the node
+ * @param[in] renderer The renderer added to the node
+ */
+ 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 )
+ {
+ mRenderer.Erase( mRenderer.Begin()+i);
+ return;
+ }
+ }
+ mRenderer.PushBack( renderer );
+ }
+
+ /**
+ * Remove a renderer from the node
+ * @param[in] renderer The renderer to be removed
+ */
+ void RemoveRenderer( Renderer* renderer );
+
+ /*
+ * Get the renderer at the given index
+ * @param[in] index
+ */
+ Renderer* GetRendererAt( unsigned int index )
+ {
+ return mRenderer[index];
+ }
+
+ /**
+ * Retrieve the number of renderers for the node
+ */
+ unsigned int GetRendererCount()
+ {
+ return mRenderer.Size();
+ }
+
+ /**
* Retreive the object attached to this node.
* @return The attachment.
*/
* @pre The childNode does not already have a parent.
* @pre The childNode is not a root node.
* @param[in] childNode The child to add.
- * @param[in] index to insert at, if not supplied or -1 it will be appended
- *
*/
- void ConnectChild( Node* childNode, int index = -1);
+ void ConnectChild( Node* childNode );
/**
* Disconnect a child (& its children) from the scene-graph.
}
/**
+ * Check if the node is visible i.e Is not fully transparent and has valid size
+ */
+ bool ResolveVisibility( BufferIndex updateBufferIndex );
+
+ /**
* Set the world-matrix of a node, with scale + rotation + translation.
* Scale and rotation are centered at the origin.
* Translation is applied independently of the scale or rotatation axis.
return mDepth;
}
+public:
+ /**
+ * @copydoc UniformMap::Add
+ */
+ void AddUniformMapping( UniformPropertyMapping* map );
+
+ /**
+ * @copydoc UniformMap::Remove
+ */
+ void RemoveUniformMapping( const std::string& uniformName );
+
+ /**
+ * Prepare the node for rendering.
+ * This is called by the UpdateManager when an object is due to be rendered in the current frame.
+ * @param[in] updateBufferIndex The current update buffer index.
+ */
+ void PrepareRender( BufferIndex bufferIndex );
+
protected:
/**
/**
* @copydoc NodeDataProvider::GetModelMatrix
*/
- virtual const Matrix& GetModelMatrix( unsigned int bufferId )
+ virtual const Matrix& GetModelMatrix( unsigned int bufferId ) const
{
return GetWorldMatrix( bufferId );
}
/**
* @copydoc NodeDataProvider::GetRenderColor
*/
- virtual const Vector4& GetRenderColor( unsigned int bufferId )
+ virtual const Vector4& GetRenderColor( unsigned int bufferId ) const
{
return GetWorldColor( bufferId );
}
- virtual const Vector3& GetRenderSize( unsigned int bufferId )
+ virtual const Vector3& GetRenderSize( unsigned int bufferId ) const
{
return GetSize( bufferId );
}
+public: // From UniformMapDataProvider
+ /**
+ * @copydoc UniformMapDataProvider::GetUniformMapChanged
+ */
+ virtual bool GetUniformMapChanged( BufferIndex bufferIndex ) const
+ {
+ return mUniformMapChanged[bufferIndex];
+ }
+
+ /**
+ * @copydoc UniformMapDataProvider::GetUniformMap
+ */
+ virtual const CollectedUniformMap& GetUniformMap( BufferIndex bufferIndex ) const
+ {
+ return mCollectedUniformMap[bufferIndex];
+ }
private:
RenderTask* mExclusiveRenderTask; ///< Nodes can be marked as exclusive to a single RenderTask
NodeAttachmentOwner mAttachment; ///< Optional owned attachment
+ RendererContainer mRenderer; ///< Container of renderers; not owned
+
NodeContainer mChildren; ///< Container of children; not owned
+ CollectedUniformMap mCollectedUniformMap[2]; ///< Uniform maps of the node
+ unsigned int mUniformMapChanged[2]; ///< Records if the uniform map has been altered this frame
+ unsigned int mRegenerateUniformMap : 2; ///< Indicate if the uniform map has to be regenerated this frame
// flags, compressed to bitfield
unsigned short mDepth: 12; ///< Depth in the hierarchy
new (slot) LocalType( &node, &Node::SetInheritOrientation, inherit );
}
-
-
inline void SetParentOriginMessage( EventThreadServices& eventThreadServices, const Node& node, const Vector3& origin )
{
typedef MessageValue1< Node, Vector3 > LocalType;
new (slot) LocalType( &node, &Node::SetDrawMode, drawMode );
}
+inline void AddRendererMessage( EventThreadServices& eventThreadServices, const Node& node, Renderer* renderer )
+{
+ typedef MessageValue1< Node, Renderer* > 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::AddRenderer, renderer );
+}
+
+inline void RemoveRendererMessage( EventThreadServices& eventThreadServices, const Node& node, Renderer* renderer )
+{
+ typedef MessageValue1< Node, Renderer* > 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::RemoveRenderer, renderer );
+}
} // namespace SceneGraph
} // namespace Internal
{
/**
+ * Pair of node-renderer
+ */
+struct NodeRenderer
+{
+ NodeRenderer()
+ :mNode(0),
+ mRenderer(0)
+ {}
+
+ NodeRenderer( Node* node, Renderer* renderer )
+ :mNode(node),
+ mRenderer(renderer)
+ {}
+
+ Node* mNode;
+ Renderer* mRenderer;
+};
+
+typedef Dali::Vector< NodeRenderer > NodeRendererContainer;
+
+/**
* Layers have a "depth" relative to all other layers in the scene-graph.
* Non-layer child nodes (and their attachments) are considered part of the layer.
*
RenderableAttachmentContainer colorRenderables;
RenderableAttachmentContainer overlayRenderables;
+ NodeRendererContainer stencilRenderers;
+ NodeRendererContainer colorRenderers;
+ NodeRendererContainer overlayRenderers;
+
private:
SortFunctionType mSortFunction; ///< Used to sort semi-transparent geometry
// INTERNAL INCLUDES
#include <dali/public-api/common/vector-wrapper.h>
-#include <dali/devel-api/common/mutex.h>
+#include <dali/devel-api/threading/mutex.h>
#include <dali/integration-api/render-controller.h>
#include <dali/internal/common/message.h>
#include <dali/internal/common/message-buffer.h>
return messagesToProcess;
}
-void MessageQueue::ProcessMessages()
+void MessageQueue::ProcessMessages( BufferIndex updateBufferIndex )
{
PERF_MONITOR_START(PerformanceMonitor::PROCESS_MESSAGES);
{
MessageBase* message = reinterpret_cast< MessageBase* >( iter.Get() );
- message->Process( mImpl->sceneGraphBuffers.GetUpdateBufferIndex() );
+ message->Process( updateBufferIndex );
// Call virtual destructor explictly; since delete will not be called after placement new
message->~MessageBase();
/**
* Called once per update; process the previously flushed messages.
+ * @param updateBufferIndex to use
*/
- void ProcessMessages();
+ void ProcessMessages( BufferIndex updateBufferIndex );
/**
* Query whether the queue was empty this frame.
*/
// INTERNAL INCLUDES
+#include <dali/devel-api/common/owner-container.h>
#include <dali/internal/common/message.h>
-#include <dali/internal/common/owner-container.h>
#include <dali/internal/event/common/event-thread-services.h>
namespace Dali
// INTERNAL HEADERS
#include <dali/internal/update/controllers/scene-controller.h>
#include <dali/internal/render/renderers/render-geometry.h>
+#include <dali/internal/render/renderers/render-property-buffer.h>
#include <dali/internal/update/controllers/render-message-dispatcher.h>
namespace Dali
{
Geometry::Geometry()
-: mIndexBuffer( NULL ),
- mRenderGeometry(0),
- mSceneController(0),
- mRendererRefCount(0u),
- mCenter(),
- mHalfExtents(),
- mRadius( 0.0f ),
+: mRenderGeometry(NULL),
+ mSceneController(NULL),
+ mIndexBuffer( NULL ),
mGeometryType(Dali::Geometry::TRIANGLES),
+ mRendererRefCount(0u),
mRequiresDepthTest(false)
{
Geometry::~Geometry()
{
- // @todo Inform renderers of deletion of buffers?
-
- // could remove self from own uniform map observer, but it's about to be destroyed.
+ mConnectionObservers.Destroy( *this );
}
-void Geometry::AddVertexBuffer( PropertyBuffer* vertexBuffer )
+void Geometry::AddVertexBuffer( Render::PropertyBuffer* vertexBuffer )
{
mVertexBuffers.PushBack( vertexBuffer );
- CalculateExtents( vertexBuffer );
- vertexBuffer->AddUniformMapObserver(*this);
mConnectionObservers.ConnectionsChanged(*this);
if( mRenderGeometry )
{
- mSceneController->GetRenderMessageDispatcher().AddPropertyBuffer( *mRenderGeometry, vertexBuffer, GpuBuffer::ARRAY_BUFFER, GpuBuffer::STATIC_DRAW );
+ mSceneController->GetRenderMessageDispatcher().AddPropertyBuffer( *mRenderGeometry, vertexBuffer, false);
}
}
-void Geometry::RemoveVertexBuffer( PropertyBuffer* vertexBuffer )
+void Geometry::RemoveVertexBuffer( Render::PropertyBuffer* vertexBuffer )
{
DALI_ASSERT_DEBUG( NULL != vertexBuffer );
// Find the object and destroy it
- Vector<PropertyBuffer*>::Iterator match = std::find(
- mVertexBuffers.Begin(),
- mVertexBuffers.End(),
- vertexBuffer );
-
- DALI_ASSERT_DEBUG( mVertexBuffers.End() != match );
- if( mVertexBuffers.End() != match )
+ size_t bufferCount(mVertexBuffers.Size());
+ for( size_t i(0); i<bufferCount; ++i )
{
- vertexBuffer->RemoveUniformMapObserver(*this);
- mVertexBuffers.Erase( match );
- mConnectionObservers.ConnectionsChanged(*this);
-
- if( mRenderGeometry )
+ if( vertexBuffer == mVertexBuffers[i] )
{
- mSceneController->GetRenderMessageDispatcher().RemovePropertyBuffer( *mRenderGeometry, vertexBuffer );
+ mVertexBuffers.Erase( mVertexBuffers.Begin()+i );
+ mConnectionObservers.ConnectionsChanged(*this);
+
+ if( mRenderGeometry )
+ {
+ mSceneController->GetRenderMessageDispatcher().RemovePropertyBuffer( *mRenderGeometry, vertexBuffer );
+ }
}
}
}
-void Geometry::SetIndexBuffer( PropertyBuffer* indexBuffer )
+void Geometry::SetIndexBuffer( Render::PropertyBuffer* indexBuffer )
{
if( mIndexBuffer != indexBuffer )
{
mIndexBuffer = indexBuffer;
- indexBuffer->AddUniformMapObserver(*this);
mConnectionObservers.ConnectionsChanged(*this);
if( mRenderGeometry )
{
- mSceneController->GetRenderMessageDispatcher().AddPropertyBuffer( *mRenderGeometry, indexBuffer, GpuBuffer::ELEMENT_ARRAY_BUFFER, GpuBuffer::STATIC_DRAW );
+ mSceneController->GetRenderMessageDispatcher().AddPropertyBuffer( *mRenderGeometry, indexBuffer, true );
}
}
}
{
if( mIndexBuffer )
{
- mIndexBuffer->RemoveUniformMapObserver(*this);
-
if( mRenderGeometry )
{
mSceneController->GetRenderMessageDispatcher().RemovePropertyBuffer( *mRenderGeometry, mIndexBuffer );
mConnectionObservers.ConnectionsChanged(*this);
}
-void Geometry::SetGeometryType( BufferIndex bufferIndex, Geometry::GeometryType geometryType )
+void Geometry::SetGeometryType(Geometry::GeometryType geometryType )
{
- mGeometryType.Set( bufferIndex, geometryType);
+ mGeometryType = geometryType;
+ if( mRenderGeometry )
+ {
+ mSceneController->GetRenderMessageDispatcher().SetGeometryType( *mRenderGeometry, static_cast<int>(geometryType) );
+ }
+}
+
+void Geometry::SetRequiresDepthTest( bool requiresDepthTest )
+{
+ mRequiresDepthTest = requiresDepthTest;
+ if( mRenderGeometry )
+ {
+ mSceneController->GetRenderMessageDispatcher().SetGeometryRequiresDepthTest( *mRenderGeometry, requiresDepthTest );
+ }
}
-Vector<PropertyBuffer*>& Geometry::GetVertexBuffers()
+Vector<Render::PropertyBuffer*>& Geometry::GetVertexBuffers()
{
return mVertexBuffers;
}
-PropertyBuffer* Geometry::GetIndexBuffer()
+Render::PropertyBuffer* Geometry::GetIndexBuffer()
{
return mIndexBuffer;
}
Geometry::GeometryType Geometry::GetGeometryType( BufferIndex bufferIndex) const
{
- int geometryType = mGeometryType[ bufferIndex ];
- return static_cast< GeometryDataProvider::GeometryType > ( geometryType );
+ return mGeometryType;
}
bool Geometry::GetRequiresDepthTesting( BufferIndex bufferIndex ) const
{
- return mRequiresDepthTest.GetBoolean( bufferIndex );
-}
-
-void Geometry::ResetDefaultProperties( BufferIndex updateBufferIndex )
-{
- // Reset the animated properties
- mCenter.ResetToBaseValue( updateBufferIndex );
- mHalfExtents.ResetToBaseValue( updateBufferIndex );
- mRadius.ResetToBaseValue( updateBufferIndex );
-
- // Age the double buffered properties
- mGeometryType.CopyPrevious(updateBufferIndex);
- mRequiresDepthTest.CopyPrevious(updateBufferIndex);
-}
-
-void Geometry::CalculateExtents( PropertyBuffer* vertexBuffer )
-{
- // TODO calculate extents for all vertex buffers attached to geometry
- unsigned int elementIndex = 0;
- unsigned int elementCount = vertexBuffer->GetElementCount( 0 );
- unsigned int elementCount1 = vertexBuffer->GetElementCount( 1 );
-
- // Select the double buffered element list that is the largest...
- if ( elementCount < elementCount1 )
- {
- elementCount = elementCount1;
- elementIndex = 1;
- }
-
- unsigned int attributeCount = vertexBuffer->GetAttributeCount( elementIndex );
- unsigned int elementSize = vertexBuffer->GetElementSize( elementIndex );
-
- std::string posName( "aPos" );
- std::size_t found;
-
- float left = 0.0f;
- float right = 0.0f;
- float top = 0.0f;
- float bottom = 0.0f;
-
- // Find the position attribute index
- for ( unsigned int i = 0; i < attributeCount; ++i )
- {
- found = vertexBuffer->GetAttributeName( 0, i ).find( posName );
- if ( found != std::string::npos )
- {
- unsigned int offset = vertexBuffer->GetAttributeOffset( elementIndex, i );
- const PropertyBufferDataProvider::BufferType& data = vertexBuffer->GetData( elementIndex );
-
- // Check attribute type to determine correct position type
- Property::Type positionType = vertexBuffer->GetAttributeType( elementIndex, i );
- Vector3 halfExtents;
- Vector3 center;
- switch ( positionType )
- {
- case Property::VECTOR2:
- {
- for ( unsigned int j = 0; j < elementCount; ++j )
- {
- const Vector2* position = reinterpret_cast< const Vector2* >( &data[ offset ] );
- offset += elementSize;
-
- if ( position->x < left )
- {
- left = position->x;
- }
- if ( position->x > right )
- {
- right = position->x;
- }
- if ( position->y < top )
- {
- top = position->y;
- }
- if ( position->y > bottom )
- {
- bottom = position->y;
- }
- }
-
- halfExtents = Vector3( ( right - left ) * 0.5f, ( bottom - top ) * 0.5f, 0.0f );
- center = Vector3( halfExtents.x + left , halfExtents.y + top, 0.0f );
- break;
- }
- case Property::VECTOR3:
- {
- float near = 0.0f;
- float far = 0.0f;
- for ( unsigned int j = 0; j < elementCount; ++j )
- {
- const Vector3* position = reinterpret_cast< const Vector3* >( &data[ offset ] );
- offset += elementSize;
-
- if ( position->x < left )
- {
- left = position->x;
- }
- if ( position->x > right )
- {
- right = position->x;
- }
- if ( position->y < top )
- {
- top = position->y;
- }
- if ( position->y > bottom )
- {
- bottom = position->y;
- }
- if ( position->z > far )
- {
- far = position->z;
- }
- if ( position->z < near )
- {
- near = position->z;
- }
- }
- halfExtents = Vector3( ( right - left ) * 0.5f, ( bottom - top ) * 0.5f, ( far - near ) * 0.5f );
- center = Vector3( halfExtents.x + left , halfExtents.y + top, halfExtents.z + near );
- break;
- }
- default:
- {
- break;
- }
- }
- mCenter.Bake( 0, center );
- mCenter.Bake( 1, center );
- mHalfExtents.Bake( 0, halfExtents );
- mHalfExtents.Bake( 1, halfExtents );
-
- float radius = halfExtents.x;
- if ( radius < halfExtents.y )
- {
- radius = halfExtents.y;
- }
- mRadius.SetInitial( radius );
- }
- }
+ return mRequiresDepthTest;
}
void Geometry::ConnectToSceneGraph( SceneController& sceneController, BufferIndex bufferIndex )
RenderGeometry* Geometry::GetRenderGeometry(SceneController* sceneController)
{
- if(!mRenderGeometry)
+ if(!mRenderGeometry )
{
//Create RenderGeometry
mSceneController = sceneController;
- mRenderGeometry = new RenderGeometry( *this );
+ mRenderGeometry = new RenderGeometry( mGeometryType, mRequiresDepthTest );
size_t vertexBufferCount( mVertexBuffers.Size() );
for( size_t i(0); i<vertexBufferCount; ++i )
{
- mRenderGeometry->AddPropertyBuffer( mVertexBuffers[i], GpuBuffer::ARRAY_BUFFER, GpuBuffer::STATIC_DRAW );
+ mRenderGeometry->AddPropertyBuffer( mVertexBuffers[i], false );
}
if( mIndexBuffer )
{
- mRenderGeometry->AddPropertyBuffer( mIndexBuffer, GpuBuffer::ELEMENT_ARRAY_BUFFER, GpuBuffer::STATIC_DRAW );
+ mRenderGeometry->AddPropertyBuffer( mIndexBuffer, true );
}
//Transfer ownership to RenderManager
#include <dali/internal/update/common/property-boolean.h>
#include <dali/internal/update/common/uniform-map.h>
#include <dali/internal/update/common/scene-graph-connection-change-propagator.h>
-#include <dali/internal/update/common/scene-graph-property-buffer.h>
-#include <dali/internal/render/data-providers/geometry-data-provider.h>
#include <dali/internal/render/data-providers/render-data-provider.h>
namespace Dali
{
namespace Internal
{
+namespace Render
+{
+class PropertyBuffer;
+}
namespace SceneGraph
{
class SceneController;
* This scene graph object is a property owner. It describes a geometry using a
* number of PropertyBuffers acting as Vertex buffers.
*/
-class Geometry : public PropertyOwner, public GeometryDataProvider, public UniformMap::Observer
+class Geometry : public PropertyOwner, public UniformMap::Observer
{
public:
+ typedef Dali::Geometry::GeometryType GeometryType;
/**
* Constructor
*/
/**
* Add a property buffer to be used as a vertex buffer
*/
- void AddVertexBuffer( PropertyBuffer* vertexBuffer );
+ void AddVertexBuffer( Render::PropertyBuffer* vertexBuffer );
/**
* Remove a property buffer to be used as a vertex buffer
* @param[in] vertexBuffer the associated vertex buffer to remove
*/
- void RemoveVertexBuffer( PropertyBuffer* vertexBuffer );
+ void RemoveVertexBuffer( Render::PropertyBuffer* vertexBuffer );
/**
* Set the buffer to be used as a source of indices for the geometry
* @param[in] indexBuffer the Property buffer describing the indexes for Line, Triangle tyes.
*/
- void SetIndexBuffer( PropertyBuffer* indexBuffer );
+ void SetIndexBuffer( Render::PropertyBuffer* indexBuffer );
/**
* Clear the index buffer if it is no longer required, e.g. if changing geometry type
* @param[in] bufferIndex Index for double buffered values
* @param[in] geometryType The geometry type
*/
- void SetGeometryType( BufferIndex bufferIndex, GeometryType geometryType );
+ void SetGeometryType( GeometryType geometryType );
+
+ /**
+ * Set if the geometry requires depth testing
+ * @param[in] requiresDepthTest True if depth testing is required, false otherwise
+ */
+ void SetRequiresDepthTest( bool requiresDepthTest );
/**
* Connect the object to the scene graph
* Get the vertex buffers of the geometry
* @return A const reference to the vertex buffers
*/
- Vector<PropertyBuffer*>& GetVertexBuffers();
+ Vector<Render::PropertyBuffer*>& GetVertexBuffers();
/**
* Get the index buffer of the geometry
* @return A pointer to the index buffer if it exists, or NULL if it doesn't.
*/
- PropertyBuffer* GetIndexBuffer();
+ Render::PropertyBuffer* GetIndexBuffer();
/**
* Gets the associated RenderGeometry
*/
virtual bool GetRequiresDepthTesting( BufferIndex bufferIndex ) const;
-protected: // From PropertyOwner
- /**
- * @copydoc Dali::Internal::SceneGraph::PropertyOwner::ResetDefaultProperties()
- */
- virtual void ResetDefaultProperties( BufferIndex updateBufferIndex );
-
private:
- /**
- * @brief Calculate the extents of geometry contained in a vertex buffer.
- *
- * @param[in] vertexBuffer pointer to a vertex buffer.
- */
- void CalculateExtents( PropertyBuffer* vertexBuffer );
+ RenderGeometry* mRenderGeometry;
+ SceneController* mSceneController;
- Vector<PropertyBuffer*> mVertexBuffers; ///< The vertex buffers
- PropertyBuffer* mIndexBuffer; ///< The index buffer if required
- ConnectionChangePropagator mConnectionObservers;
+ Render::PropertyBuffer* mIndexBuffer; ///< The index buffer if required
+ Vector<Render::PropertyBuffer*> mVertexBuffers; ///< The vertex buffers
- RenderGeometry* mRenderGeometry;
- SceneController* mSceneController;
- unsigned int mRendererRefCount;
+ ConnectionChangePropagator mConnectionObservers;
-public: // Properties
- AnimatableProperty<Vector3> mCenter;
- AnimatableProperty<Vector3> mHalfExtents;
- AnimatableProperty<float> mRadius;
- DoubleBufferedProperty<int> mGeometryType;
- DoubleBufferedProperty<bool> mRequiresDepthTest;
+ Geometry::GeometryType mGeometryType;
+ unsigned int mRendererRefCount;
+ bool mRequiresDepthTest;
};
-inline void AddVertexBufferMessage( EventThreadServices& eventThreadServices , const Geometry& geometry, const PropertyBuffer& vertexBuffer )
+inline void AddVertexBufferMessage( EventThreadServices& eventThreadServices , const Geometry& geometry, const Render::PropertyBuffer& vertexBuffer )
{
- typedef MessageValue1< Geometry, PropertyBuffer* > LocalType;
+ typedef MessageValue1< Geometry, Render::PropertyBuffer* > LocalType;
// Reserve some memory inside the message queue
unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
// Construct message in the message queue memory; note that delete should not be called on the return value
- new (slot) LocalType( &geometry, &Geometry::AddVertexBuffer, const_cast<PropertyBuffer*>(&vertexBuffer) );
+ new (slot) LocalType( &geometry, &Geometry::AddVertexBuffer, const_cast<Render::PropertyBuffer*>(&vertexBuffer) );
}
-inline void RemoveVertexBufferMessage( EventThreadServices& eventThreadServices, const Geometry& geometry, const PropertyBuffer& vertexBuffer )
+inline void RemoveVertexBufferMessage( EventThreadServices& eventThreadServices, const Geometry& geometry, const Render::PropertyBuffer& vertexBuffer )
{
- typedef MessageValue1< Geometry, PropertyBuffer* > LocalType;
+ typedef MessageValue1< Geometry, Render::PropertyBuffer* > LocalType;
// Reserve some memory inside the message queue
unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
// Construct message in the message queue memory; note that delete should not be called on the return value
- new (slot) LocalType( &geometry, &Geometry::RemoveVertexBuffer, const_cast<PropertyBuffer*>(&vertexBuffer) );
+ new (slot) LocalType( &geometry, &Geometry::RemoveVertexBuffer, const_cast<Render::PropertyBuffer*>(&vertexBuffer) );
}
-inline void SetIndexBufferMessage( EventThreadServices& eventThreadServices, const Geometry& geometry, const PropertyBuffer& indexBuffer )
+inline void SetIndexBufferMessage( EventThreadServices& eventThreadServices, const Geometry& geometry, const Render::PropertyBuffer& indexBuffer )
{
- typedef MessageValue1< Geometry, PropertyBuffer* > LocalType;
+ typedef MessageValue1< Geometry, Render::PropertyBuffer* > LocalType;
// Reserve some memory inside the message queue
unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
// Construct message in the message queue memory; note that delete should not be called on the return value
- new (slot) LocalType( &geometry, &Geometry::SetIndexBuffer, const_cast<PropertyBuffer*>(&indexBuffer) );
+ new (slot) LocalType( &geometry, &Geometry::SetIndexBuffer, const_cast<Render::PropertyBuffer*>(&indexBuffer) );
}
inline void ClearIndexBufferMessage( EventThreadServices& eventThreadServices, const Geometry& geometry )
inline void SetGeometryTypeMessage( EventThreadServices& eventThreadServices, const Geometry& geometry, SceneGraph::Geometry::GeometryType geometryType )
{
- typedef MessageDoubleBuffered1< Geometry, SceneGraph::Geometry::GeometryType > LocalType;
+ typedef MessageValue1< Geometry, SceneGraph::Geometry::GeometryType > LocalType;
// Reserve some memory inside the message queue
unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
new (slot) LocalType( &geometry, &Geometry::SetGeometryType, geometryType );
}
+inline void SetGeometryRequiresDepthTestMessage( EventThreadServices& eventThreadServices, const Geometry& geometry, bool requiresDepthTest )
+{
+ typedef MessageValue1< Geometry, bool > LocalType;
+
+ // Reserve some memory inside the message queue
+ unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
+
+ // Construct message in the message queue memory; note that delete should not be called on the return value
+ new (slot) LocalType( &geometry, &Geometry::SetRequiresDepthTest, requiresDepthTest );
+}
+
} // namespace SceneGraph
} // namespace Internal
} // namespace Dali
#include <dali/public-api/shader-effects/shader-effect.h>
#include <dali/devel-api/rendering/material.h>
#include <dali/internal/common/internal-constants.h>
-#include <dali/internal/update/rendering/scene-graph-sampler.h>
-#include <dali/internal/render/data-providers/sampler-data-provider.h>
#include <dali/internal/render/shaders/scene-graph-shader.h>
namespace Dali
Material::~Material()
{
+ mConnectionObservers.Destroy( *this );
}
void Material::SetShader( Shader* shader )
return mShader;
}
-void Material::AddSampler( Sampler* sampler )
-{
- mSamplers.PushBack( sampler );
-
- sampler->AddConnectionObserver( *this );
- sampler->AddUniformMapObserver( *this );
-
- mConnectionObservers.ConnectionsChanged(*this);
-}
-
-void Material::RemoveSampler( Sampler* sampler )
-{
- Vector<Sampler*>::Iterator match = std::find( mSamplers.Begin(), mSamplers.End(), sampler );
-
- DALI_ASSERT_DEBUG( mSamplers.End() != match );
- if( mSamplers.End() != match )
- {
- sampler->RemoveConnectionObserver( *this );
- sampler->RemoveUniformMapObserver( *this );
- mSamplers.Erase( match );
- mConnectionObservers.ConnectionsChanged(*this);
- }
- else
- {
- DALI_ASSERT_DEBUG( 0 && "Sampler not found" );
- }
-}
-
void Material::PrepareRender( BufferIndex bufferIndex )
{
mBlendPolicy = OPAQUE;
if( opaque )
{
- // Require that all affecting samplers are opaque
unsigned int opaqueCount=0;
unsigned int affectingCount=0;
-
- for( Vector<Sampler*>::ConstIterator iter = mSamplers.Begin();
- iter != mSamplers.End(); ++iter )
+ size_t textureCount( GetTextureCount() );
+ for( unsigned int i(0); i<textureCount; ++i )
{
- const Sampler* sampler = *iter;
- if( sampler != NULL )
+ if( mAffectsTransparency[i] )
{
- if( sampler->AffectsTransparency( bufferIndex ) )
+ ++affectingCount;
+ if( mIsFullyOpaque[i] )
{
- affectingCount++;
- if( sampler->IsFullyOpaque( bufferIndex ) )
- {
- opaqueCount++;
- }
+ ++opaqueCount;
}
}
}
}
}
-Vector<Sampler*>& Material::GetSamplers()
-{
- return mSamplers;
-}
Material::BlendPolicy Material::GetBlendPolicy() const
{
return blendingOptions.GetBlendEquationAlpha();
}
+void Material::AddTexture( const std::string& name, ResourceId id, Render::Sampler* sampler )
+{
+ mTextureId.PushBack( id );
+ mUniformName.push_back( name );
+ mSamplers.PushBack( sampler );
+ mIsFullyOpaque.PushBack( false );
+ mAffectsTransparency.PushBack( true );
+
+ mConnectionObservers.ConnectionsChanged(*this);
+}
+
+void Material::RemoveTexture( size_t index )
+{
+ mTextureId.Erase( mTextureId.Begin()+index );
+ mUniformName.erase( mUniformName.begin() + index );
+ mSamplers.Erase( mSamplers.Begin()+index );
+ mIsFullyOpaque.Erase( mIsFullyOpaque.Begin()+index );
+ mAffectsTransparency.Erase( mAffectsTransparency.Begin()+index );
+ mConnectionObservers.ConnectionsChanged( *this );
+}
+
+void Material::SetTextureImage( size_t index, ResourceId id )
+{
+ mTextureId[index] = id;
+ mConnectionObservers.ConnectionsChanged(*this);
+}
+
+void Material::SetTextureSampler( size_t index, Render::Sampler* sampler)
+{
+ mSamplers[index] = sampler;
+ mConnectionObservers.ConnectionsChanged(*this);
+}
+
+void Material::SetTextureUniformName( size_t index, const std::string& uniformName)
+{
+ mUniformName[index] = uniformName;
+ mConnectionObservers.ConnectionsChanged(*this);
+}
+
void Material::ConnectToSceneGraph( SceneController& sceneController, BufferIndex bufferIndex )
{
}
#include <dali/internal/update/common/scene-graph-connection-change-propagator.h>
#include <dali/internal/update/common/uniform-map.h>
#include <dali/internal/render/data-providers/material-data-provider.h>
+#include <dali/internal/update/resources/resource-manager-declarations.h>
namespace Dali
{
namespace Internal
{
+namespace Render
+{
+class Sampler;
+}
namespace SceneGraph
{
class Sampler;
void SetShader( Shader* shader );
/**
- * Add a sampler (image + sampler modes) to the material
- * @param[in] sampler A sampler to add
- */
- void AddSampler( Sampler* sampler );
-
- /**
- * Remove a sampler (image + sampler modes) from the material
- * @param[in] sampler A sampler to remove
- */
- void RemoveSampler( Sampler* sampler );
-
- /**
* Prepare the material for rendering.
*
* Determine whether blending is enabled for this material, and store the result.
*/
void SetBlendingOptions( BufferIndex updateBufferIndex, unsigned int options );
+ /**
+ * Adds a new texture to be used by the material
+ * @param[in] image The image used by the texture
+ * @param[in] uniformName The uniform name of the texture
+ * @param[in] sampler Sampling parameters. If not provided the default sampling parameters will be used
+ */
+ void AddTexture( const std::string& name, ResourceId id, Render::Sampler* sampler );
+
+ /**
+ * Removes a texture from the material
+ * @param[in] index The index of the texture in the array of textures
+ */
+ void RemoveTexture( size_t index );
+
+ /**
+ * Sets the image to be used by a given texture
+ * @param[in] index The index of the texture in the array of textures
+ * @param[in] image The new image
+ */
+ void SetTextureImage( size_t index, ResourceId id );
+
+ /**
+ * Set the sampler used by a given texture
+ * @param[in] index The index of the texture in the array of textures
+ * @param[in] sampler The new sampler
+ */
+ void SetTextureSampler( size_t index, Render::Sampler* sampler);
+
+ /**
+ * Set the uniform name of a given texture
+ * @param[in] index The index of the texture in the array of textures
+ * @param[in] uniformName The new uniform name
+ */
+ void SetTextureUniformName( size_t index, const std::string& uniformName);
+
+ /**
+ * Establish if a given texture will affect the transparency of the object ( true by default )
+ * @param[in] index The index of the texture in the array of textures
+ * @param[in] affectsTransparency True if the texture affects transparency, false otherwise
+ */
+ void SetAffectsTransparency( size_t index, bool affectsTransparency )
+ {
+ mAffectsTransparency[index] = affectsTransparency;
+ mConnectionObservers.ConnectionsChanged(*this);
+ }
+
public: // Implementation of MaterialDataProvider
/**
Shader* GetShader() const;
/**
- * Get the samplers this material uses.
- * @return the samplers
+ * Get the ResourceId of a texture used by the material
+ * @param[in] index The index of the texture in the textures array
+ * @return the ResourceId
+ */
+ ResourceId GetTextureId( size_t index )
+ {
+ return mTextureId[index];
+ }
+
+ /**
+ * Get the uniform name of a texture used by the material
+ * @param[in] index The index of the texture in the textures array
+ * @return the uniform name
+ */
+ const std::string& GetTextureUniformName( size_t index )
+ {
+ return mUniformName[index];
+ }
+
+ /**
+ * Get the sampler of a texture used by the material
+ * @param[in] index The index of the texture in the textures array
+ * @return the sampler used by the texture
+ */
+ Render::Sampler* GetTextureSampler( size_t index )
+ {
+ return mSamplers[index];
+ }
+
+ /**
+ * Get the number of textures used by the material
+ * @return The number of textures
*/
- Vector<Sampler*>& GetSamplers();
+ size_t GetTextureCount()
+ {
+ return mTextureId.Size();
+ }
public: // UniformMap::Observer
/**
*/
virtual void ResetDefaultProperties( BufferIndex updateBufferIndex );
+ void SetIsFullyOpaque( size_t index, bool isFullyOpaque )
+ {
+ mIsFullyOpaque[index] = isFullyOpaque;
+ }
+
public: // Property data
AnimatableProperty<Vector4> mColor;
AnimatableProperty<Vector4> mBlendColor;
private:
Shader* mShader;
- Vector<Sampler*> mSamplers; // Not owned
+ Vector<Render::Sampler*> mSamplers; // Not owned
+ Vector<ResourceId> mTextureId;
+ std::vector<std::string> mUniformName;
+ Vector<bool> mIsFullyOpaque;
+ Vector<bool> mAffectsTransparency;
ConnectionChangePropagator mConnectionObservers;
BlendPolicy mBlendPolicy; ///< The blend policy as determined by PrepareRender
};
-inline void SetShaderMessage( EventThreadServices& eventThreadServices, const Material& material, const Shader& shader )
+inline void SetShaderMessage( EventThreadServices& eventThreadServices, const Material& material, Shader& shader )
{
typedef MessageValue1< Material, Shader* > LocalType;
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( &material, &Material::SetShader, const_cast<Shader*>(&shader) );
+ new (slot) LocalType( &material, &Material::SetShader, &shader );
+}
+
+inline void SetBlendingOptionsMessage( EventThreadServices& eventThreadServices, const Material& material, unsigned int options )
+{
+ typedef MessageDoubleBuffered1< Material, unsigned int > LocalType;
+
+ // Reserve some memory inside the message queue
+ unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
+
+ new (slot) LocalType( &material, &Material::SetBlendingOptions, options );
}
-inline void AddSamplerMessage( EventThreadServices& eventThreadServices, const Material& material, const Sampler& sampler )
+inline void AddTextureMessage( EventThreadServices& eventThreadServices, const Material& material, const std::string& uniformName, ResourceId id, Render::Sampler* sampler )
{
- typedef MessageValue1< Material, Sampler* > LocalType;
+ typedef MessageValue3< Material, std::string, ResourceId, Render::Sampler* > 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( &material, &Material::AddSampler, const_cast<Sampler*>(&sampler) );
+ new (slot) LocalType( &material, &Material::AddTexture, uniformName, id, sampler );
}
-inline void RemoveSamplerMessage( EventThreadServices& eventThreadServices, const Material& material, Sampler& sampler )
+inline void RemoveTextureMessage( EventThreadServices& eventThreadServices, const Material& material, size_t index )
{
- typedef MessageValue1< Material, Sampler* > LocalType;
+ typedef MessageValue1< Material, size_t > 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( &material, &Material::RemoveSampler, const_cast<Sampler*>(&sampler) );
+ new (slot) LocalType( &material, &Material::RemoveTexture, index );
}
-inline void SetBlendingOptionsMessage( EventThreadServices& eventThreadServices, const Material& material, unsigned int options )
+inline void SetTextureImageMessage( EventThreadServices& eventThreadServices, const Material& material, size_t index, ResourceId id )
{
- typedef MessageDoubleBuffered1< Material, unsigned int > LocalType;
+ typedef MessageValue2< Material, size_t, ResourceId > LocalType;
// Reserve some memory inside the message queue
unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
- new (slot) LocalType( &material, &Material::SetBlendingOptions, options );
+ // Construct message in the message queue memory; note that delete should not be called on the return value
+ new (slot) LocalType( &material, &Material::SetTextureImage, index, id );
+}
+
+inline void SetTextureSamplerMessage( EventThreadServices& eventThreadServices, const Material& material, size_t index, Render::Sampler* sampler )
+{
+ typedef MessageValue2< Material, size_t, Render::Sampler* > 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( &material, &Material::SetTextureSampler, index, sampler );
+}
+
+inline void SetTextureUniformNameMessage( EventThreadServices& eventThreadServices, const Material& material, size_t index, const std::string& uniformName )
+{
+ typedef MessageValue2< Material, size_t, std::string > 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( &material, &Material::SetTextureUniformName, index, uniformName );
}
+inline void SetTextureAffectsTransparencyMessage( EventThreadServices& eventThreadServices, const Material& material, size_t index, bool affectsTransparency )
+{
+ typedef MessageValue2< Material, size_t, 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( &material, &Material::SetAffectsTransparency, index, affectsTransparency );
+}
} // namespace SceneGraph
} // namespace Internal
--- /dev/null
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// CLASS HEADER
+#include "scene-graph-renderer.h"
+
+// INTERNAL HEADERS
+#include <dali/internal/update/controllers/scene-controller.h>
+#include <dali/internal/render/renderers/render-geometry.h>
+#include <dali/internal/update/controllers/render-message-dispatcher.h>
+#include <dali/internal/update/rendering/scene-graph-geometry.h>
+#include <dali/internal/update/rendering/scene-graph-material.h>
+#include <dali/internal/render/shaders/scene-graph-shader.h>
+#include <dali/internal/render/renderers/render-new-renderer.h>
+#include <dali/internal/render/data-providers/node-data-provider.h>
+#include <dali/internal/update/resources/complete-status-manager.h>
+#include <dali/internal/update/nodes/node.h>
+#include <dali/internal/update/resources/resource-tracker.h>
+#include <dali/internal/render/queue/render-queue.h>
+#include <dali/internal/common/internal-constants.h>
+
+
+namespace // unnamed namespace
+{
+
+const unsigned int UNIFORM_MAP_READY = 0;
+const unsigned int COPY_UNIFORM_MAP = 1;
+const unsigned int REGENERATE_UNIFORM_MAP = 2;
+
+void AddMappings( Dali::Internal::SceneGraph::CollectedUniformMap& localMap, const Dali::Internal::SceneGraph::UniformMap& uniformMap )
+{
+ // Iterate thru uniformMap.
+ // Any maps that aren't in localMap should be added in a single step
+ Dali::Internal::SceneGraph::CollectedUniformMap newUniformMappings;
+
+ for( unsigned int i=0, count=uniformMap.Count(); i<count; ++i )
+ {
+ Dali::Internal::SceneGraph::UniformPropertyMapping::Hash nameHash = uniformMap[i].uniformNameHash;
+ bool found = false;
+
+ for( Dali::Internal::SceneGraph::CollectedUniformMap::Iterator iter = localMap.Begin() ; iter != localMap.End() ; ++iter )
+ {
+ const Dali::Internal::SceneGraph::UniformPropertyMapping* map = (*iter);
+ if( map->uniformNameHash == nameHash )
+ {
+ if( map->uniformName == uniformMap[i].uniformName )
+ {
+ found = true;
+ break;
+ }
+ }
+ }
+ if( !found )
+ {
+ // it's a new mapping. Add raw ptr to temporary list
+ newUniformMappings.PushBack( &uniformMap[i] );
+ }
+ }
+
+ if( newUniformMappings.Count() > 0 )
+ {
+ localMap.Reserve( localMap.Count() + newUniformMappings.Count() );
+
+ for( Dali::Internal::SceneGraph::CollectedUniformMap::Iterator iter = newUniformMappings.Begin(),
+ end = newUniformMappings.End() ;
+ iter != end ;
+ ++iter )
+ {
+ const Dali::Internal::SceneGraph::UniformPropertyMapping* map = (*iter);
+ localMap.PushBack( map );
+ }
+ //@todo MESH_REWORK Use memcpy to copy ptrs from one array to the other
+ }
+}
+}
+
+namespace Dali
+{
+namespace Internal
+{
+namespace SceneGraph
+{
+
+Renderer::Renderer()
+:mSceneController(0),
+ mRenderer(NULL),
+ mMaterial(NULL),
+ mGeometry(NULL),
+ mReferenceCount(0),
+ mRegenerateUniformMap(0),
+ mResendDataProviders(false),
+ mResendGeometry(false),
+ mHasUntrackedResources(false),
+ mFinishedResourceAcquisition(false),
+ mResourcesReady(false),
+ mDepthIndex(0)
+{
+ mUniformMapChanged[0]=false;
+ mUniformMapChanged[1]=false;
+
+ // Observe our own PropertyOwner's uniform map
+ AddUniformMapObserver( *this );
+}
+
+Renderer::~Renderer()
+{
+ if (mMaterial)
+ {
+ mMaterial->RemoveConnectionObserver(*this);
+ mMaterial=NULL;
+ }
+ if (mGeometry)
+ {
+ mGeometry->RemoveConnectionObserver(*this);
+ mGeometry=NULL;
+ }
+}
+
+void Renderer::PrepareRender( BufferIndex updateBufferIndex )
+{
+ mMaterial->PrepareRender( updateBufferIndex );
+
+ if( mRegenerateUniformMap > UNIFORM_MAP_READY )
+ {
+ DALI_ASSERT_DEBUG( mGeometry != NULL && "No geometry available in DoPrepareRender()" );
+ DALI_ASSERT_DEBUG( mMaterial != NULL && "No geometry available in DoPrepareRender()" );
+
+ if( mRegenerateUniformMap == REGENERATE_UNIFORM_MAP)
+ {
+ CollectedUniformMap& localMap = mCollectedUniformMap[ updateBufferIndex ];
+ localMap.Resize(0);
+
+ const UniformMap& rendererUniformMap = PropertyOwner::GetUniformMap();
+ AddMappings( localMap, rendererUniformMap );
+
+ AddMappings( localMap, mMaterial->GetUniformMap() );
+ AddMappings( localMap, mMaterial->GetShader()->GetUniformMap() );
+ AddMappings( localMap, mGeometry->GetUniformMap() );
+
+ }
+ else if( mRegenerateUniformMap == COPY_UNIFORM_MAP )
+ {
+ // Copy old map into current map
+ CollectedUniformMap& localMap = mCollectedUniformMap[ updateBufferIndex ];
+ CollectedUniformMap& oldMap = mCollectedUniformMap[ 1-updateBufferIndex ];
+
+ localMap.Resize( oldMap.Count() );
+
+ unsigned int index=0;
+ for( CollectedUniformMap::Iterator iter = oldMap.Begin(), end = oldMap.End() ; iter != end ; ++iter, ++index )
+ {
+ localMap[index] = *iter;
+ }
+ }
+
+ mUniformMapChanged[updateBufferIndex] = true;
+ mRegenerateUniformMap--;
+ }
+
+ if( mResendDataProviders )
+ {
+ RenderDataProvider* dataProvider = NewRenderDataProvider();
+
+ // Tell renderer about a new provider
+ // @todo MESH_REWORK Should we instead create a new renderer when these change?
+
+ typedef MessageValue1< Render::NewRenderer, OwnerPointer<RenderDataProvider> > DerivedType;
+ unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
+ new (slot) DerivedType( mRenderer, &Render::NewRenderer::SetRenderDataProvider, dataProvider );
+ mResendDataProviders = false;
+ }
+
+ if( mResendGeometry )
+ {
+ // The first call to GetRenderGeometry() creates the geometry and sends it in a message
+ RenderGeometry* geometry = mGeometry->GetRenderGeometry( mSceneController );
+
+ typedef MessageValue1< Render::NewRenderer, RenderGeometry* > DerivedType;
+ unsigned int* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
+
+ new (slot) DerivedType( mRenderer, &Render::NewRenderer::SetGeometry, geometry );
+ mResendGeometry = false;
+ }
+}
+
+void Renderer::SetMaterial( BufferIndex bufferIndex, Material* material)
+{
+ DALI_ASSERT_DEBUG( material != NULL && "Material pointer is NULL" );
+
+ mMaterial = material;
+ mMaterial->AddConnectionObserver( *this );
+ mRegenerateUniformMap = REGENERATE_UNIFORM_MAP;
+
+ mResendDataProviders = true;
+}
+
+void Renderer::SetGeometry( BufferIndex bufferIndex, Geometry* geometry)
+{
+ DALI_ASSERT_DEBUG( geometry != NULL && "Geometry pointer is NULL");
+ if( mGeometry)
+ {
+ mGeometry->RemoveConnectionObserver(*this);
+ mGeometry->OnRendererDisconnect();
+ }
+
+ mGeometry = geometry;
+ mGeometry->AddConnectionObserver( *this ); // Observe geometry connections / uniform mapping changes
+ mRegenerateUniformMap = REGENERATE_UNIFORM_MAP;
+
+ if( mRenderer )
+ {
+ mResendGeometry = true;
+ }
+}
+
+void Renderer::SetDepthIndex( int depthIndex )
+{
+ mDepthIndex = depthIndex;
+}
+
+//Called when a node with this renderer is added to the stage
+void Renderer::OnStageConnect()
+{
+ ++mReferenceCount;
+ if( !mRenderer)
+ {
+ RenderDataProvider* dataProvider = NewRenderDataProvider();
+
+ RenderGeometry* renderGeometry = mGeometry->GetRenderGeometry(mSceneController);
+ mRenderer = Render::NewRenderer::New( dataProvider, renderGeometry );
+ mSceneController->GetRenderMessageDispatcher().AddRenderer( *mRenderer );
+ mResendDataProviders = false;
+ mResendGeometry = false;
+ }
+}
+
+//Called when the node with this renderer has gone out of the stage
+void Renderer::OnStageDisconnect()
+{
+ --mReferenceCount;
+ if( mReferenceCount == 0 )
+ {
+ mSceneController->GetRenderMessageDispatcher().RemoveRenderer( *mRenderer );
+ if( mGeometry )
+ {
+ mGeometry->OnRendererDisconnect();
+ }
+ mRenderer = NULL;
+ }
+}
+
+//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 )
+{
+ mRegenerateUniformMap = REGENERATE_UNIFORM_MAP;
+ mSceneController = &sceneController;
+}
+
+
+//Called just before destroying the scene-graph renderer ( when the "event-thread renderer" is no longer referenced )
+void Renderer::DisconnectFromSceneGraph( SceneController& sceneController, BufferIndex bufferIndex )
+{
+ //Remove renderer from RenderManager
+ if( mRenderer )
+ {
+ mSceneController->GetRenderMessageDispatcher().RemoveRenderer( *mRenderer );
+ mRenderer = NULL;
+ mSceneController = NULL;
+ }
+}
+
+RenderDataProvider* Renderer::NewRenderDataProvider()
+{
+ RenderDataProvider* dataProvider = new RenderDataProvider();
+
+ dataProvider->mMaterialDataProvider = mMaterial;
+ dataProvider->mUniformMapDataProvider = this;
+ dataProvider->mShader = mMaterial->GetShader();
+
+ size_t textureCount( mMaterial->GetTextureCount() );
+ dataProvider->mTextures.resize( textureCount );
+ for( unsigned int i(0); i<textureCount; ++i )
+ {
+ dataProvider->mTextures[i] = Render::Texture( mMaterial->GetTextureUniformName(i),
+ mMaterial->GetTextureId(i),
+ mMaterial->GetTextureSampler(i));
+ }
+
+ return dataProvider;
+}
+
+Render::Renderer& Renderer::GetRenderer()
+{
+ return *mRenderer;
+}
+
+const CollectedUniformMap& Renderer::GetUniformMap( BufferIndex bufferIndex ) const
+{
+ return mCollectedUniformMap[bufferIndex];
+};
+
+void Renderer::PrepareResources( BufferIndex updateBufferIndex, ResourceManager& resourceManager )
+{
+ mHasUntrackedResources = false;
+ mTrackedResources.Clear(); // Resource trackers are only needed if not yet completea
+
+ DALI_ASSERT_DEBUG( mSceneController );
+
+ CompleteStatusManager& completeStatusManager = mSceneController->GetCompleteStatusManager();
+ mResourcesReady = false;
+
+
+ mFinishedResourceAcquisition = false;
+
+ // Can only be considered ready when all the scene graph objects are connected to the renderer
+ if( ( mGeometry ) && ( mGeometry->GetVertexBuffers().Count() > 0 ) &&
+ ( mMaterial ) && ( mMaterial->GetShader() != NULL ) )
+ {
+ unsigned int completeCount = 0;
+ unsigned int neverCount = 0;
+ unsigned int frameBufferCount = 0;
+
+ size_t textureCount( mMaterial->GetTextureCount() );
+ for( unsigned int i(0); i<textureCount; ++i )
+ {
+ ResourceId textureId = mMaterial->GetTextureId(i);
+ BitmapMetadata metaData = resourceManager.GetBitmapMetadata( textureId );
+
+ mMaterial->SetIsFullyOpaque( i, metaData.IsFullyOpaque() );
+
+ switch( completeStatusManager.GetStatus( textureId ) )
+ {
+ case CompleteStatusManager::NOT_READY:
+ {
+ if( metaData.GetIsFramebuffer() )
+ {
+ frameBufferCount++;
+ }
+ if( completeStatusManager.FindResourceTracker(textureId) != NULL )
+ {
+ bool found = false;
+ std::size_t numTrackedResources = mTrackedResources.Count();
+ for( size_t i=0; i < numTrackedResources; ++i )
+ {
+ if(mTrackedResources[i] == textureId)
+ {
+ found = true;
+ break;
+ }
+ }
+ if( ! found )
+ {
+ mTrackedResources.PushBack( textureId );
+ }
+ }
+ else
+ {
+ mHasUntrackedResources = true;
+ }
+ }
+ break;
+
+ case CompleteStatusManager::COMPLETE:
+ {
+ completeCount++;
+ }
+ break;
+
+ case CompleteStatusManager::NEVER:
+ {
+ neverCount++;
+ }
+ break;
+ }
+ }
+
+ // We are ready if all samplers are complete, or those that aren't are framebuffers
+ // We are complete if all samplers are either complete or will nmResendGeometryever complete
+ mResourcesReady = ( completeCount + frameBufferCount >= textureCount ) ;
+ mFinishedResourceAcquisition = ( completeCount + neverCount >= textureCount );
+ }
+}
+
+void Renderer::GetReadyAndComplete(bool& ready, bool& complete) const
+{
+ ready = mResourcesReady;
+ complete = false;
+
+ CompleteStatusManager& completeStatusManager = mSceneController->GetCompleteStatusManager();
+
+ std::size_t numTrackedResources = mTrackedResources.Count();
+ if( mHasUntrackedResources || numTrackedResources == 0 )
+ {
+ complete = mFinishedResourceAcquisition;
+ }
+ else
+ {
+ // If there are tracked resources and no untracked resources, test the trackers
+ bool trackersComplete = true;
+ for( size_t i=0; i < numTrackedResources; ++i )
+ {
+ ResourceId id = mTrackedResources[i];
+ ResourceTracker* tracker = completeStatusManager.FindResourceTracker(id);
+ if( tracker && ! tracker->IsComplete() )
+ {
+ trackersComplete = false;
+ break;
+ }
+ }
+
+ complete = mFinishedResourceAcquisition || trackersComplete;
+ }
+}
+
+// Called by ProcessRenderTasks after DoPrepareRender
+bool Renderer::IsFullyOpaque( BufferIndex updateBufferIndex, const Node& node ) const
+{
+ bool opaque = false;
+
+ if( mMaterial != NULL )
+ {
+ Material::BlendPolicy blendPolicy = mMaterial->GetBlendPolicy();
+ switch( blendPolicy )
+ {
+ case Material::OPAQUE:
+ {
+ opaque = true;
+ break;
+ }
+ case Material::TRANSPARENT:
+ {
+ opaque = false;
+ break;
+ }
+ case Material::USE_ACTOR_COLOR:
+ {
+ opaque = node.GetWorldColor( updateBufferIndex ).a >= FULLY_OPAQUE;
+ break;
+ }
+ }
+ }
+
+ return opaque;
+}
+
+void Renderer::ConnectionsChanged( PropertyOwner& object )
+{
+ // One of our child objects has changed it's connections. Ensure the uniform
+ // map gets regenerated during PrepareRender
+ mRegenerateUniformMap = REGENERATE_UNIFORM_MAP;
+
+ // Ensure the child object pointers get re-sent to the renderer
+ mResendDataProviders = true;
+}
+
+void Renderer::ConnectedUniformMapChanged()
+{
+ mRegenerateUniformMap = REGENERATE_UNIFORM_MAP;
+}
+
+void Renderer::UniformMappingsChanged( const UniformMap& mappings )
+{
+ // The mappings are either from PropertyOwner base class, or the Actor
+ mRegenerateUniformMap = REGENERATE_UNIFORM_MAP;
+}
+
+void Renderer::ObservedObjectDestroyed(PropertyOwner& owner)
+{
+ if( reinterpret_cast<PropertyOwner*>(mGeometry) == &owner )
+ {
+ mGeometry = NULL;
+ }
+ else if( reinterpret_cast<PropertyOwner*>(mMaterial) == &owner )
+ {
+ mMaterial = NULL;
+ }
+}
+
+} // namespace SceneGraph
+} // namespace Internal
+} // namespace Dali
--- /dev/null
+#ifndef DALI_INTERNAL_SCENE_GRAPH_RENDERER2_H
+#define DALI_INTERNAL_SCENE_GRAPH_RENDERER2_H
+
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+#include <dali/devel-api/rendering/geometry.h>
+#include <dali/internal/event/common/event-thread-services.h>
+#include <dali/internal/update/common/animatable-property.h>
+#include <dali/internal/update/common/double-buffered.h>
+#include <dali/internal/update/common/double-buffered-property.h>
+#include <dali/internal/update/common/property-owner.h>
+#include <dali/internal/update/common/property-boolean.h>
+#include <dali/internal/update/common/uniform-map.h>
+#include <dali/internal/update/common/scene-graph-connection-change-propagator.h>
+#include <dali/internal/render/data-providers/render-data-provider.h>
+#include <dali/internal/render/renderers/render-new-renderer.h>
+#include <dali/internal/update/resources/resource-manager.h>
+
+namespace Dali
+{
+namespace Internal
+{
+
+namespace Render
+{
+class NewRenderer;
+}
+
+namespace SceneGraph
+{
+
+class Renderer;
+typedef Dali::Vector< Renderer* > RendererContainer;
+typedef RendererContainer::Iterator RendererIter;
+typedef RendererContainer::ConstIterator RendererConstIter;
+
+class Material;
+class Geometry;
+
+class Renderer : public PropertyOwner,
+ public UniformMapDataProvider,
+ public UniformMap::Observer,
+ public ConnectionChangePropagator::Observer
+{
+public:
+
+ /**
+ * Default constructor
+ */
+ Renderer();
+
+ /**
+ * Destructor
+ */
+ virtual ~Renderer();
+
+ /**
+ * Set the material for the renderer
+ * @param[in] bufferIndex The current frame's buffer index
+ * @param[in] material The material this renderer will use
+ */
+ void SetMaterial( BufferIndex bufferIndex, Material* material);
+
+ /**
+ * Get the material of this renderer
+ * @return the material this renderer uses
+ */
+ Material& GetMaterial()
+ {
+ return *mMaterial;
+ }
+
+ /**
+ * Set the geometry for the renderer
+ * @param[in] bufferIndex The current frame's buffer index
+ * @param[in] geometry The geometry this renderer will use
+ */
+ void SetGeometry( BufferIndex bufferIndex, Geometry* material);
+
+ /**
+ * Get the geometry of this renderer
+ * @return the geometry this renderer uses
+ */
+ Geometry& GetGeometry()
+ {
+ return *mGeometry;
+ }
+
+ /**
+ * Set the depth index
+ * @param[in] depthIndex the new depth index to use
+ */
+ void SetDepthIndex( int depthIndex );
+
+ /**
+ * @brief Get the depth index
+ * @return The depth index
+ */
+ int GetDepthIndex() const
+ {
+ return mDepthIndex;
+ }
+
+ /**
+ * Called when an actor with this renderer is added to the stage
+ */
+ void OnStageConnect();
+
+ /*
+ * Called when an actor with this renderer is removed from the stage
+ */
+ void OnStageDisconnect();
+
+ /**
+ * Prepare the object for rendering.
+ * This is called by the UpdateManager when an object is due to be rendered in the current frame.
+ * @param[in] updateBufferIndex The current update buffer index.
+ */
+ void PrepareRender( BufferIndex updateBufferIndex );
+
+ /*
+ * Retrieve the Render thread renderer
+ * @return The associated render thread renderer
+ */
+ Render::Renderer& GetRenderer();
+
+ /**
+ * Prepare the object resources.
+ * This must be called by the UpdateManager before calling PrepareRender, for each frame.
+ * @param[in] updateBufferIndex The current update buffer index.
+ * @param[in] resourceManager The resource manager.
+ */
+ void PrepareResources( BufferIndex updateBufferIndex, ResourceManager& resourceManager );
+
+ /**
+ * Check whether the renderer has been marked as ready to render
+ * @param[out] ready TRUE if the renderer has resources to render
+ * @param[out] complete TRUE if the renderer resources are complete
+ * (e.g. image has finished loading, framebuffer is ready to render, native image
+ * framebuffer has been rendered)
+ */
+ void GetReadyAndComplete(bool& ready, bool& complete) const;
+
+ /**
+ * Query whether the renderer is fully opaque.
+ * @param[in] updateBufferIndex The current update buffer index.
+ * @return True if fully opaque.
+ */
+ bool IsFullyOpaque( BufferIndex updateBufferIndex, const Node& node ) const;
+
+ /**
+ * Query whether the renderer is currently in use by an actor on the stage
+ */
+ bool IsReferenced() const
+ {
+ return mReferenceCount > 0;
+ }
+
+
+public: // Implementation of ObjectOwnerContainer template methods
+ /**
+ * Connect the object to the scene graph
+ *
+ * @param[in] sceneController The scene controller - used for sending messages to render thread
+ * @param[in] bufferIndex The current buffer index - used for sending messages to render thread
+ */
+ void ConnectToSceneGraph( SceneController& sceneController, BufferIndex bufferIndex );
+
+ /**
+ * Disconnect the object from the scene graph
+ * @param[in] sceneController The scene controller - used for sending messages to render thread
+ * @param[in] bufferIndex The current buffer index - used for sending messages to render thread
+ */
+ void DisconnectFromSceneGraph( SceneController& sceneController, BufferIndex bufferIndex );
+
+public: // Implementation of ConnectionChangePropagator
+ /**
+ * @copydoc ConnectionChangePropagator::AddObserver
+ */
+ void AddConnectionObserver(ConnectionChangePropagator::Observer& observer){};
+
+ /**
+ * @copydoc ConnectionChangePropagator::RemoveObserver
+ */
+ void RemoveConnectionObserver(ConnectionChangePropagator::Observer& observer){};
+
+public:
+
+
+public: // UniformMap::Observer
+ /**
+ * @copydoc UniformMap::Observer::UniformMappingsChanged
+ */
+ virtual void UniformMappingsChanged( const UniformMap& mappings );
+
+public: // ConnectionChangePropagator::Observer
+
+ /**
+ * @copydoc ConnectionChangePropagator::ConnectionsChanged
+ */
+ virtual void ConnectionsChanged( PropertyOwner& owner );
+
+ /**
+ * @copydoc ConnectionChangePropagator::ConnectedUniformMapChanged
+ */
+ virtual void ConnectedUniformMapChanged( );
+
+ /**
+ * @copydoc ConnectionChangePropagator::ConnectedUniformMapChanged
+ */
+ virtual void ObservedObjectDestroyed(PropertyOwner& owner);
+
+public: // PropertyOwner implementation
+ /**
+ * @copydoc Dali::Internal::SceneGraph::PropertyOwner::ResetDefaultProperties()
+ */
+ virtual void ResetDefaultProperties( BufferIndex updateBufferIndex ){};
+
+public: // From UniformMapDataProvider
+
+ /**
+ * @copydoc UniformMapDataProvider::GetUniformMapChanged
+ */
+ virtual bool GetUniformMapChanged( BufferIndex bufferIndex ) const{ return mUniformMapChanged[bufferIndex];}
+
+ /**
+ * @copydoc UniformMapDataProvider::GetUniformMap
+ */
+ virtual const CollectedUniformMap& GetUniformMap( BufferIndex bufferIndex ) const;
+
+private:
+
+ /**
+ * Helper function to create a new render data provider
+ * @return the new (initialized) data provider
+ */
+ RenderDataProvider* NewRenderDataProvider();
+
+ SceneController* mSceneController; ///< Used for initializing renderers whilst attached
+ Render::NewRenderer* mRenderer; ///< Raw pointer to the new renderer (that's owned by RenderManager)
+ Material* mMaterial; ///< The material this renderer uses. (Not owned)
+ Geometry* mGeometry; ///< The geometry this renderer uses. (Not owned)
+
+ Dali::Vector< Integration::ResourceId > mTrackedResources; ///< Filled during PrepareResources if there are uncomplete, tracked resources.
+
+ CollectedUniformMap mCollectedUniformMap[2]; ///< Uniform maps collected by the renderer
+ unsigned int mReferenceCount; ///< Number of nodes currently using this renderer
+ unsigned int mRegenerateUniformMap; ///< 2 if the map should be regenerated, 1 if it should be copied.
+ bool mUniformMapChanged[2]; ///< Records if the uniform map has been altered this frame
+ bool mResendDataProviders : 1; ///< True if the data providers should be resent to the renderer
+ bool mResendGeometry : 1; ///< True if geometry should be resent to the renderer
+ bool mHasUntrackedResources : 1; ///< Set during PrepareResources, true if have tried to follow untracked resources
+ bool mFinishedResourceAcquisition : 1; ///< Set during DoPrepareResources; true if ready & all resource acquisition has finished (successfully or otherwise)
+ bool mResourcesReady : 1; ///< Set during the Update algorithm; true if the attachment has resources ready for the current frame.
+
+public:
+ int mDepthIndex; ///< Used only in PrepareRenderInstructions
+};
+
+
+/// Messages
+inline void SetMaterialMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, const Material& material )
+{
+ typedef MessageDoubleBuffered1< Renderer, Material* > LocalType;
+
+ // Reserve some memory inside the message queue
+ unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
+
+ // Construct message in the message queue memory; note that delete should not be called on the return value
+ new (slot) LocalType( &renderer, &Renderer::SetMaterial, const_cast<Material*>(&material) );
+}
+
+inline void SetGeometryMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, const Geometry& geometry )
+{
+ typedef MessageDoubleBuffered1< Renderer, Geometry* > LocalType;
+
+ // Reserve some memory inside the message queue
+ unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
+
+ // Construct message in the message queue memory; note that delete should not be called on the return value
+ new (slot) LocalType( &renderer, &Renderer::SetGeometry, const_cast<Geometry*>(&geometry) );
+}
+
+inline void SetDepthIndexMessage( EventThreadServices& eventThreadServices, const Renderer& attachment, int depthIndex )
+{
+ typedef MessageValue1< Renderer, int > LocalType;
+
+ // Reserve some memory inside the message queue
+ unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
+
+ // Construct message in the message queue memory; note that delete should not be called on the return value
+ new (slot) LocalType( &attachment, &Renderer::SetDepthIndex, depthIndex );
+}
+
+inline void OnStageConnectMessage( EventThreadServices& eventThreadServices, const Renderer& renderer )
+{
+ typedef Message< Renderer > LocalType;
+
+ // Reserve some memory inside the message queue
+ unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
+
+ // Construct message in the message queue memory; note that delete should not be called on the return value
+ new (slot) LocalType( &renderer, &Renderer::OnStageConnect );
+}
+
+inline void OnStageDisconnectMessage( EventThreadServices& eventThreadServices, const Renderer& renderer )
+{
+ typedef Message< Renderer > LocalType;
+
+ // Reserve some memory inside the message queue
+ unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
+
+ // Construct message in the message queue memory; note that delete should not be called on the return value
+ new (slot) LocalType( &renderer, &Renderer::OnStageDisconnect );
+}
+
+} // namespace SceneGraph
+} // namespace Internal
+} // namespace Dali
+
+#endif // DALI_INTERNAL_SCENE_GRAPH_RENDERER_H
+++ /dev/null
-/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-// CLASS HEADER
-#include "scene-graph-sampler.h"
-
-// EXTERNAL HEADERS
-
-
-namespace Dali
-{
-namespace Internal
-{
-namespace SceneGraph
-{
-
-Sampler::Sampler( const std::string& textureUnitUniformName )
-: mMinFilter( Dali::Sampler::DEFAULT ),
- mMagFilter( Dali::Sampler::DEFAULT ),
- mUWrapMode( Dali::Sampler::CLAMP_TO_EDGE ),
- mVWrapMode( Dali::Sampler::CLAMP_TO_EDGE ),
- mAffectsTransparency( true ),
- mTextureUnitUniformName( textureUnitUniformName ),
- mFullyOpaque(true)
-{
- mTextureId[ 0 ] = mTextureId[ 1 ] = 0u;
-}
-
-Sampler::~Sampler()
-{
-}
-
-void Sampler::SetTextureUnitUniformName( const std::string& textureUnitUniformName )
-{
- mTextureUnitUniformName = textureUnitUniformName;
-}
-
-void Sampler::SetTexture( BufferIndex bufferIndex, Integration::ResourceId textureId )
-{
- if( mTextureId[bufferIndex] != textureId )
- {
- mTextureId[ bufferIndex ] = textureId;
- mConnectionObservers.ConnectionsChanged(*this);
- }
-}
-
-void Sampler::SetFilterMode( BufferIndex bufferIndex, FilterMode minFilter, FilterMode magFilter )
-{
- mMinFilter.Set(bufferIndex, minFilter);
- mMagFilter.Set(bufferIndex, magFilter);
-}
-
-void Sampler::SetWrapMode( BufferIndex bufferIndex, WrapMode uWrap, WrapMode vWrap )
-{
-}
-
-const std::string& Sampler::GetTextureUnitUniformName() const
-{
- return mTextureUnitUniformName;
-}
-
-Integration::ResourceId Sampler::GetTextureId( BufferIndex bufferIndex ) const
-{
- return mTextureId[bufferIndex];
-}
-
-Sampler::FilterMode Sampler::GetMinifyFilterMode( BufferIndex bufferIndex ) const
-{
- return static_cast<Sampler::FilterMode>(mMinFilter[bufferIndex]);
-}
-
-Sampler::FilterMode Sampler::GetMagnifyFilterMode( BufferIndex bufferIndex ) const
-{
- return static_cast<Sampler::FilterMode>(mMagFilter[bufferIndex]);
-}
-
-Sampler::WrapMode Sampler::GetUWrapMode( BufferIndex bufferIndex ) const
-{
- return static_cast<Sampler::WrapMode>(mUWrapMode[bufferIndex]);
-}
-
-Sampler::WrapMode Sampler::GetVWrapMode( BufferIndex bufferIndex ) const
-{
- return static_cast<Sampler::WrapMode>(mVWrapMode[bufferIndex]);
-}
-
-bool Sampler::AffectsTransparency( BufferIndex bufferIndex ) const
-{
- return mAffectsTransparency[bufferIndex] ;
-}
-
-void Sampler::SetFullyOpaque( bool fullyOpaque )
-{
- mFullyOpaque = fullyOpaque;
-}
-
-bool Sampler::IsFullyOpaque( BufferIndex bufferIndex ) const
-{
- return mFullyOpaque;
-}
-
-void Sampler::ConnectToSceneGraph( SceneController& sceneController, BufferIndex bufferIndex )
-{
-}
-
-void Sampler::DisconnectFromSceneGraph(SceneController& sceneController, BufferIndex bufferIndex)
-{
-}
-
-void Sampler::AddConnectionObserver( ConnectionChangePropagator::Observer& observer )
-{
- mConnectionObservers.Add(observer);
-}
-
-void Sampler::RemoveConnectionObserver( ConnectionChangePropagator::Observer& observer )
-{
- mConnectionObservers.Remove(observer);
-}
-
-void Sampler::ResetDefaultProperties( BufferIndex bufferIndex )
-{
- mTextureId[ bufferIndex ] = mTextureId[ 1 - bufferIndex ];
- mMinFilter.CopyPrevious( bufferIndex );
- mMagFilter.CopyPrevious( bufferIndex );
- mUWrapMode.CopyPrevious( bufferIndex );
- mVWrapMode.CopyPrevious( bufferIndex );
- mAffectsTransparency.CopyPrevious( bufferIndex );
-}
-
-} // namespace SceneGraph
-} // namespace Internal
-} // namespace Dali
+++ /dev/null
-#ifndef DALI_INTERNAL_SCENE_GRAPH_SAMPLER_H
-#define DALI_INTERNAL_SCENE_GRAPH_SAMPLER_H
-
-/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <dali/devel-api/rendering/sampler.h>
-#include <dali/integration-api/resource-declarations.h>
-#include <dali/internal/event/common/event-thread-services.h>
-#include <dali/internal/update/common/double-buffered.h>
-#include <dali/internal/update/common/double-buffered-property.h>
-#include <dali/internal/update/common/property-owner.h>
-#include <dali/internal/update/common/scene-graph-connection-change-propagator.h>
-#include <dali/internal/update/resources/bitmap-metadata.h>
-#include <dali/internal/render/data-providers/sampler-data-provider.h>
-
-#include <string>
-
-namespace Dali
-{
-namespace Internal
-{
-namespace SceneGraph
-{
-class SceneController;
-
-class Sampler : public PropertyOwner, public SamplerDataProvider
-{
-public:
- typedef Dali::Sampler::FilterMode FilterMode;
- typedef Dali::Sampler::WrapMode WrapMode;
-
- /**
- * Constructor
- */
- Sampler( const std::string& samplerName );
-
- /**
- * Destructor
- */
- virtual ~Sampler();
-
- /**
- * Set the uniform name of this sampler. This allows the shader to find the
- * GL index of this sampler.
- */
- void SetTextureUnitUniformName( const std::string& textureUnitUniformName );
-
- /**
- * Set the texture identity of this sampler (needs to double buffer this value because
- * it can be read through the data provider interface in the render thread )
- * @param[in] bufferIndex The buffer index to use
- * @param[in] textureId The identity of the texture
- */
- void SetTexture( BufferIndex bufferIndex, Integration::ResourceId textureId );
-
- /**
- * Set the filter modes for minify and magnify filters
- * @param[in] bufferIndex The buffer index to use
- * @param[in] minFilter The minify filter
- * @param[in] magFilter The magnify filter
- */
- void SetFilterMode( BufferIndex bufferIndex, FilterMode minFilter, FilterMode magFilter );
-
- /**
- * @param[in] bufferIndex The buffer index to use
- */
- void SetWrapMode( BufferIndex bufferIndex, WrapMode uWrap, WrapMode vWrap );
-
- /**
- * @param[in] bufferIndex The buffer index to use
- * @return true if this sampler affects transparency of the material
- * @note this should only be called from Update thread
- */
- bool AffectsTransparency( BufferIndex bufferIndex ) const;
-
- /**
- * Sets whether the associated texture is fully opaque or not.
- * @param[in] fullyOpaque true if it's fully opaque
- */
- void SetFullyOpaque( bool fullyOpaque );
-
- /**
- * @param[in] bufferIndex The buffer index to use
- * @return true if the texture is fully opaque
- * @note this should only be called from Update thread
- */
- bool IsFullyOpaque( BufferIndex bufferIndex ) const;
-
-
-public: // SamplerDataProvider interface - called from RenderThread
- /**
- * Get the texture unit uniform name
- * @return the name of the texture unit uniform
- */
- virtual const std::string& GetTextureUnitUniformName() const;
-
- /**
- * Get the texture ID
- * @param[in] bufferIndex The buffer index to use
- * @return the identity of the associated texture
- */
- virtual Integration::ResourceId GetTextureId(BufferIndex buffer) const;
-
- /**
- * Get the filter mode
- * @param[in] bufferIndex The buffer index to use
- * @return The minify filter mode
- */
- virtual FilterMode GetMinifyFilterMode( BufferIndex bufferIndex ) const;
-
- /**
- * Get the filter mode
- * @param[in] bufferIndex The buffer index to use
- * @return The magnify filter mode
- */
- virtual FilterMode GetMagnifyFilterMode( BufferIndex bufferIndex ) const;
-
- /**
- * Get the horizontal wrap mode
- * @param[in] bufferIndex The buffer index to use
- * @return The horizontal wrap mode
- */
- virtual WrapMode GetUWrapMode( BufferIndex bufferIndex ) const;
-
- /**
- * Get the vertical wrap mode
- * @param[in] bufferIndex The buffer index to use
- * @return The vertical wrap mode
- */
- virtual WrapMode GetVWrapMode( BufferIndex bufferIndex ) const;
-
- /**
- * Connect the object to the scene graph
- *
- * @param[in] sceneController The scene controller - used for sending messages to render thread
- * @param[in] bufferIndex The current buffer index - used for sending messages to render thread
- */
- void ConnectToSceneGraph( SceneController& sceneController, BufferIndex bufferIndex );
-
- /**
- * Disconnect the object from the scene graph
- * @param[in] sceneController The scene controller - used for sending messages to render thread
- * @param[in] bufferIndex The current buffer index - used for sending messages to render thread
- */
- void DisconnectFromSceneGraph( SceneController& sceneController, BufferIndex bufferIndex );
-
- /**
- * @copydoc ConnectionChangePropagator::AddObserver
- */
- void AddConnectionObserver(ConnectionChangePropagator::Observer& observer);
-
- /**
- * @copydoc ConnectionChangePropagator::RemoveObserver
- */
- void RemoveConnectionObserver(ConnectionChangePropagator::Observer& observer);
-
-public: // PropertyOwner implementation
- /**
- * @copydoc Dali::Internal::SceneGraph::PropertyOwner::ResetDefaultProperties()
- */
- virtual void ResetDefaultProperties( BufferIndex updateBufferIndex );
-
-public: // Properties
- DoubleBufferedProperty<int> mMinFilter; ///< The minify filter
- DoubleBufferedProperty<int> mMagFilter; ///< The magnify filter
- DoubleBufferedProperty<int> mUWrapMode; ///< The horizontal wrap mode
- DoubleBufferedProperty<int> mVWrapMode; ///< The vertical wrap mode
- DoubleBufferedProperty<bool> mAffectsTransparency; ///< If this sampler affects renderer transparency
-
-private:
- std::string mTextureUnitUniformName; ///< The name of the uniform of the texture unit
- Integration::ResourceId mTextureId[ 2 ]; //< double buffered
- ConnectionChangePropagator mConnectionObservers; ///< Connection observers that will be informed when textures change.
- bool mFullyOpaque; // Update only flag - no need for double buffering
-};
-
-} // namespace SceneGraph
-
-inline void SetTextureUnitUniformNameMessage( EventThreadServices& eventThreadServices, const SceneGraph::Sampler& sampler, const std::string& name )
-{
- typedef MessageValue1< SceneGraph::Sampler, std::string > 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( &sampler, &SceneGraph::Sampler::SetTextureUnitUniformName, name );
-}
-
-
-inline void SetTextureMessage( EventThreadServices& eventThreadServices, const SceneGraph::Sampler& sampler, unsigned int resourceId )
-{
- typedef MessageDoubleBuffered1< SceneGraph::Sampler, unsigned int > LocalType;
-
- // Reserve some memory inside the message queue
- unsigned int* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
-
- // Construct message in the message queue memory; note that delete should not be called on the return value
- new (slot) LocalType( &sampler, &SceneGraph::Sampler::SetTexture, resourceId );
-}
-
-// Declare enum as a message parameter type outside the SceneGraph namespace
-template <> struct ParameterType< SceneGraph::Sampler::FilterMode > : public BasicType< SceneGraph::Sampler::FilterMode > {};
-
-
-inline void SetFilterModeMessage( EventThreadServices& eventThreadServices, const SceneGraph::Sampler& sampler, SceneGraph::Sampler::FilterMode minFilter, SceneGraph::Sampler::FilterMode magFilter )
-{
- typedef MessageDoubleBuffered2< SceneGraph::Sampler, SceneGraph::Sampler::FilterMode, SceneGraph::Sampler::FilterMode > 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( &sampler, &SceneGraph::Sampler::SetFilterMode, minFilter, magFilter );
-}
-
-// Declare enum as a message parameter type
-template <> struct ParameterType< SceneGraph::Sampler::WrapMode > : public BasicType< SceneGraph::Sampler::WrapMode > {};
-
-
-inline void SetWrapModeMessage( EventThreadServices& eventThreadServices, const SceneGraph::Sampler& sampler, SceneGraph::Sampler::WrapMode horizontalWrap, SceneGraph::Sampler::WrapMode verticalWrap )
-{
- typedef MessageDoubleBuffered2< SceneGraph::Sampler, SceneGraph::Sampler::WrapMode, SceneGraph::Sampler::WrapMode > 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( &sampler, &SceneGraph::Sampler::SetWrapMode, horizontalWrap, verticalWrap );
-}
-
-} // namespace Internal
-} // namespace Dali
-
-
-#endif // DALI_INTERNAL_SCENE_GRAPH_SAMPLER_H
*/
enum PositionInheritanceMode
{
- INHERIT_PARENT_POSITION, ///< Actor will inherit its parent position. This is the default @since_tizen 2.4
+ INHERIT_PARENT_POSITION, ///< Actor will inherit its parent position. This is the default. @since_tizen 2.4
USE_PARENT_POSITION, ///< Actor will copy its parent position. This is useful if many actors are stacked together in the same place. This option ignores parent origin and anchor point. @since_tizen 2.4
USE_PARENT_POSITION_PLUS_LOCAL_POSITION, ///< Actor will copy its parent position and add local position. This is useful if many actors are stacked together in the same place with an offset. This option ignores parent origin and anchor point. @since_tizen 2.4
DONT_INHERIT_POSITION ///< Actor will not inherit position. Local position is treated as world position. This is useful if a constraint is used to override local position or if an actor is positioned globally. This option ignores parent origin, anchor point and local position. @since_tizen 2.4
{
enum Type
{
- FIXED, ///< Size is fixed as set by SetSize @since_tizen 2.4
- USE_NATURAL_SIZE, ///< Size is to use the actor's natural size @since_tizen 2.4
- FILL_TO_PARENT, ///< Size is to fill up to the actor's parent's bounds. Aspect ratio not maintained. @since_tizen 2.4
+ FIXED, ///< Size is fixed as set by SetSize. @since_tizen 2.4
+ USE_NATURAL_SIZE, ///< Size is to use the actor's natural size. @since_tizen 2.4
+ FILL_TO_PARENT, ///< Size is to fill up to the actor's parent's bounds. Aspect ratio is not maintained. @since_tizen 2.4
SIZE_RELATIVE_TO_PARENT, ///< The actors size will be ( ParentSize * SizeRelativeToParentFactor ). @since_tizen 2.4
SIZE_FIXED_OFFSET_FROM_PARENT, ///< The actors size will be ( ParentSize + SizeRelativeToParentFactor ). @since_tizen 2.4
- FIT_TO_CHILDREN, ///< Size will adjust to wrap around all children @since_tizen 2.4
- DIMENSION_DEPENDENCY, ///< One dimension is dependent on the other @since_tizen 2.4
- USE_ASSIGNED_SIZE ///< The size will be assigned to the actor @since_tizen 2.4
+ FIT_TO_CHILDREN, ///< Size will adjust to wrap around all children. @since_tizen 2.4
+ DIMENSION_DEPENDENCY, ///< One dimension is dependent on the other. @since_tizen 2.4
+ USE_ASSIGNED_SIZE ///< The size will be assigned to the actor. @since_tizen 2.4
};
const Type DEFAULT = USE_NATURAL_SIZE; ///< Default resize policy
}
{
enum Type
{
- USE_SIZE_SET, ///< Use the size that was set @since_tizen 2.4
- FIT_WITH_ASPECT_RATIO, ///< Fit within the size set maintaining natural size aspect ratio @since_tizen 2.4
+ USE_SIZE_SET, ///< Use the size that was set. @since_tizen 2.4
+ FIT_WITH_ASPECT_RATIO, ///< Fit within the size set maintaining natural size aspect ratio. @since_tizen 2.4
FILL_WITH_ASPECT_RATIO ///< Fill up the size set maintaining natural size aspect ratio. May exceed size bounds in one dimension. @since_tizen 2.4
};
}
Renderer Actor::GetRendererAt( unsigned int index )
{
- return Renderer( &GetImplementation(*this).GetRendererAt( index ) );
+ Internal::RendererPtr renderer = GetImplementation(*this).GetRendererAt( index );
+ return Renderer( renderer.Get() );
}
void Actor::RemoveRenderer( Renderer& renderer )
* {
* // Only hit-test the actor and its children if it is sensitive and visible
* IF ( ACTOR-IS-SENSITIVE &&
- * ACTOR-IS-VISIBLE )
+ * ACTOR-IS-VISIBLE &&
+ * ACTOR-IS-ON-STAGE )
* {
* // Depth-first traversal within current layer, visiting parent first
*
- * // Check whether current actor should be hit-tested
+ * // Check whether current actor should be hit-tested.
* IF ( ( TOUCH-SIGNAL-NOT-EMPTY || HOVER-SIGNAL-NOT-EMPTY ) &&
* ACTOR-HAS-NON-ZERO-SIZE &&
* ACTOR-WORLD-COLOR-IS-NOT-TRANSPARENT )
* {
* IF ( ACTOR-IS-OVERLAY || ( DISTANCE-TO-ACTOR < DISTANCE-TO-LAST-HIT-ACTOR ) )
* {
- * // The current actor is the closest actor that was underneath the touch
+ * // The current actor is the closest actor that was underneath the touch.
* LAST-HIT-ACTOR = CURRENT-ACTOR
* }
* }
* }
*
- * // Keep checking children, in case we hit something closer
+ * // Keep checking children, in case we hit something closer.
* FOR-EACH CHILD (in order)
* {
* IF ( CHILD-IS-NOT-A-LAYER )
* // Continue traversal for this child's sub-tree
* HIT-TEST-WITHIN-LAYER ( CHILD )
* }
- * // else we skip hit-testing the child's sub-tree altogether
+ * // else we skip hit-testing the child's sub-tree altogether.
* }
* }
* }
*
* IF ( NOT-CONSUMED )
* {
- * // If event is not consumed then deliver it to the parent unless we reach the root actor
+ * // If event is not consumed then deliver it to the parent unless we reach the root actor.
* IF ( ACTOR-PARENT )
* {
* EMIT-HOVER-SIGNAL( ACTOR-PARENT )
{
enum
{
- PARENT_ORIGIN = DEFAULT_ACTOR_PROPERTY_START_INDEX, ///< type Vector3 @since_tizen 2.4
- PARENT_ORIGIN_X, ///< type float @since_tizen 2.4
- PARENT_ORIGIN_Y, ///< type float @since_tizen 2.4
- PARENT_ORIGIN_Z, ///< type float @since_tizen 2.4
- ANCHOR_POINT, ///< type Vector3 @since_tizen 2.4
- ANCHOR_POINT_X, ///< type float @since_tizen 2.4
- ANCHOR_POINT_Y, ///< type float @since_tizen 2.4
- ANCHOR_POINT_Z, ///< type float @since_tizen 2.4
- SIZE, ///< type Vector3 @since_tizen 2.4
- SIZE_WIDTH, ///< type float @since_tizen 2.4
- SIZE_HEIGHT, ///< type float @since_tizen 2.4
- SIZE_DEPTH, ///< type float @since_tizen 2.4
- POSITION, ///< type Vector3 @since_tizen 2.4
- POSITION_X, ///< type float @since_tizen 2.4
- POSITION_Y, ///< type float @since_tizen 2.4
- POSITION_Z, ///< type float @since_tizen 2.4
- WORLD_POSITION, ///< type Vector3 (read-only) @since_tizen 2.4
- WORLD_POSITION_X, ///< type float (read-only) @since_tizen 2.4
- WORLD_POSITION_Y, ///< type float (read-only) @since_tizen 2.4
- WORLD_POSITION_Z, ///< type float (read-only) @since_tizen 2.4
- ORIENTATION, ///< type Quaternion @since_tizen 2.4
- WORLD_ORIENTATION, ///< type Quaternion (read-only) @since_tizen 2.4
- SCALE, ///< type Vector3 @since_tizen 2.4
- SCALE_X, ///< type float @since_tizen 2.4
- SCALE_Y, ///< type float @since_tizen 2.4
- SCALE_Z, ///< type float @since_tizen 2.4
- WORLD_SCALE, ///< type Vector3 (read-only) @since_tizen 2.4
- VISIBLE, ///< type bool @since_tizen 2.4
- COLOR, ///< type Vector4 @since_tizen 2.4
- COLOR_RED, ///< type float @since_tizen 2.4
- COLOR_GREEN, ///< type float @since_tizen 2.4
- COLOR_BLUE, ///< type float @since_tizen 2.4
- COLOR_ALPHA, ///< type float @since_tizen 2.4
- WORLD_COLOR, ///< type Vector4 (read-only) @since_tizen 2.4
- WORLD_MATRIX, ///< type Matrix (read-only) @since_tizen 2.4
+ PARENT_ORIGIN = DEFAULT_ACTOR_PROPERTY_START_INDEX, ///< type Vector3 (constraint-input) @since_tizen 2.4
+ PARENT_ORIGIN_X, ///< type float (constraint-input) @since_tizen 2.4
+ PARENT_ORIGIN_Y, ///< type float (constraint-input) @since_tizen 2.4
+ PARENT_ORIGIN_Z, ///< type float (constraint-input) @since_tizen 2.4
+ ANCHOR_POINT, ///< type Vector3 (constraint-input) @since_tizen 2.4
+ ANCHOR_POINT_X, ///< type float (constraint-input) @since_tizen 2.4
+ ANCHOR_POINT_Y, ///< type float (constraint-input) @since_tizen 2.4
+ ANCHOR_POINT_Z, ///< type float (constraint-input) @since_tizen 2.4
+ SIZE, ///< type Vector3 (animatable / constraint-input) @since_tizen 2.4
+ SIZE_WIDTH, ///< type float (animatable / constraint-input) @since_tizen 2.4
+ SIZE_HEIGHT, ///< type float (animatable / constraint-input) @since_tizen 2.4
+ SIZE_DEPTH, ///< type float (animatable / constraint-input) @since_tizen 2.4
+ POSITION, ///< type Vector3 (animatable / constraint-input) @since_tizen 2.4
+ POSITION_X, ///< type float (animatable / constraint-input) @since_tizen 2.4
+ POSITION_Y, ///< type float (animatable / constraint-input) @since_tizen 2.4
+ POSITION_Z, ///< type float (animatable / constraint-input) @since_tizen 2.4
+ WORLD_POSITION, ///< type Vector3 (read-only / constraint-input) @since_tizen 2.4
+ WORLD_POSITION_X, ///< type float (read-only / constraint-input) @since_tizen 2.4
+ WORLD_POSITION_Y, ///< type float (read-only / constraint-input) @since_tizen 2.4
+ WORLD_POSITION_Z, ///< type float (read-only / constraint-input) @since_tizen 2.4
+ ORIENTATION, ///< type Quaternion (animatable / constraint-input) @since_tizen 2.4
+ WORLD_ORIENTATION, ///< type Quaternion (read-only / constraint-input) @since_tizen 2.4
+ SCALE, ///< type Vector3 (animatable / constraint-input) @since_tizen 2.4
+ SCALE_X, ///< type float (animatable / constraint-input) @since_tizen 2.4
+ SCALE_Y, ///< type float (animatable / constraint-input) @since_tizen 2.4
+ SCALE_Z, ///< type float (animatable / constraint-input) @since_tizen 2.4
+ WORLD_SCALE, ///< type Vector3 (read-only / constraint-input) @since_tizen 2.4
+ VISIBLE, ///< type bool (animatable / constraint-input) @since_tizen 2.4
+ COLOR, ///< type Vector4 (animatable / constraint-input) @since_tizen 2.4
+ COLOR_RED, ///< type float (animatable / constraint-input) @since_tizen 2.4
+ COLOR_GREEN, ///< type float (animatable / constraint-input) @since_tizen 2.4
+ COLOR_BLUE, ///< type float (animatable / constraint-input) @since_tizen 2.4
+ COLOR_ALPHA, ///< type float (animatable / constraint-input) @since_tizen 2.4
+ WORLD_COLOR, ///< type Vector4 (read-only / constraint-input) @since_tizen 2.4
+ WORLD_MATRIX, ///< type Matrix (read-only / constraint-input) @since_tizen 2.4
NAME, ///< type std::string @since_tizen 2.4
SENSITIVE, ///< type bool @since_tizen 2.4
LEAVE_REQUIRED, ///< type bool @since_tizen 2.4
* @pre This Actor (the parent) has been initialized.
* @pre The child actor has been initialized.
* @pre The child actor is not the same as the parent actor.
- * @pre The actor is not the Root actor
+ * @pre The actor is not the Root actor.
* @post The child will be referenced by its parent. This means that the child will be kept alive,
* even if the handle passed into this method is reset or destroyed.
* @note if the child already has a parent, it will be removed from old parent
* and reparented to this actor. This may change childs position, color,
- * scale etc as it now inherits them from this actor
+ * scale etc as it now inherits them from this actor.
*/
void Add(Actor child);
/**
* @brief Search through this actor's hierarchy for an actor with the given name.
*
- * The actor itself is also considered in the search
+ * The actor itself is also considered in the search.
* @since_tizen 2.4
* @param[in] actorName the name of the actor to find
* @return A handle to the actor if found, or an empty handle if not.
/**
* @brief Search through this actor's hierarchy for an actor with the given unique ID.
*
- * The actor itself is also considered in the search
+ * The actor itself is also considered in the search.
* @since_tizen 2.4
* @param[in] id the ID of the actor to find
* @return A handle to the actor if found, or an empty handle if not.
* @brief Retrieve the actor's size.
*
* @since_tizen 2.4
- * @return The actor's current size.
+ * @return The actor's target size.
* @pre The Actor has been initialized.
- * @note This return is the value that was set using SetSize or the target size of an animation
+ * @note This return is the value that was set using SetSize or the target size of an animation.
*/
Vector3 GetTargetSize() const;
* @brief Returns the actors position inheritance mode.
*
* @since_tizen 2.4
- * @return True if the actor inherit's it's parent orientation, false if it uses world orientation.
+ * @return Return the position inheritance mode.
* @pre The Actor has been initialized.
*/
PositionInheritanceMode GetPositionInheritanceMode() const;
void SetInheritOrientation(bool inherit);
/**
- * @brief Returns whether the actor inherit's it's parent's orientation.
+ * @brief Returns whether the actor inherits its parent's orientation.
*
* @since_tizen 2.4
- * @return True if the actor inherit's it's parent orientation, false if it uses world orientation.
+ * @return True if the actor inherits its parent orientation, false if it uses world orientation.
* @pre The Actor has been initialized.
*/
bool IsOrientationInherited() const;
* @brief Apply a relative scale to an actor.
*
* @since_tizen 2.4
- * @param[in] relativeScale The scale to combine with the actors existing scale.
+ * @param[in] relativeScale The scale to combine with the actor's existing scale.
* @pre The Actor has been initialized.
*/
void ScaleBy(const Vector3& relativeScale);
void SetInheritScale( bool inherit );
/**
- * @brief Returns whether the actor inherit's it's parent's scale.
+ * @brief Returns whether the actor inherits its parent's scale.
*
* @since_tizen 2.4
- * @return True if the actor inherit's it's parent scale, false if it uses world scale.
+ * @return True if the actor inherits its parent scale, false if it uses world scale.
* @pre The Actor has been initialized.
*/
bool IsScaleInherited() const;
* @brief Set how the actor and its children should be drawn.
*
* Not all actors are renderable, but DrawMode can be inherited from any actor.
- * By default a renderable actor will be drawn as a 3D object. It will be depth-tested against
+ * If an object is in a 3D layer, it will be depth-tested against
* other objects in the world i.e. it may be obscured if other objects are in front.
*
* If DrawMode::OVERLAY_2D is used, the actor and its children will be drawn as a 2D overlay.
* Overlay actors are drawn in a separate pass, after all non-overlay actors within the Layer.
- * For overlay actors, the drawing order is with respect to depth-index property of Actors,
+ * For overlay actors, the drawing order is with respect to tree levels of Actors,
* and depth-testing will not be used.
*
* If DrawMode::STENCIL is used, the actor and its children will be used to stencil-test other actors
* @brief Query how the actor and its children will be drawn.
*
* @since_tizen 2.4
- * @return True if the Actor is an overlay.
+ * @return Return the draw mode type.
*/
DrawMode::Type GetDrawMode() const;
// SIZE NEGOTIATION
/**
- * @brief Set the resize policy to be used for the given dimension(s)
+ * @brief Set the resize policy to be used for the given dimension(s).
*
* @since_tizen 2.4
* @param[in] policy The resize policy to use
void SetResizePolicy( ResizePolicy::Type policy, Dimension::Type dimension );
/**
- * @brief Return the resize policy used for a single dimension
+ * @brief Return the resize policy used for a single dimension.
*
* @since_tizen 2.4
* @param[in] dimension The dimension to get policy for
- * @return Return the dimension resize policy
+ * @return Return the dimension resize policy. If more than one dimension is requested, just return the first one found.
*/
ResizePolicy::Type GetResizePolicy( Dimension::Type dimension ) const;
void SetSizeScalePolicy( SizeScalePolicy::Type policy );
/**
- * @brief Return the size set policy in use
+ * @brief Return the size scale policy in use.
*
* @since_tizen 2.4
- * @return Return the size set policy
+ * @return Return the size scale policy.
*/
SizeScalePolicy::Type GetSizeScalePolicy() const;
Vector3 GetSizeModeFactor() const;
/**
- * @brief Calculate the height of the actor given a width
+ * @brief Calculate the height of the actor given a width.
*
* The natural size is used for default calculation.
* size 0 is treated as aspect ratio 1:1.
*
* @since_tizen 2.4
* @param width Width to use
- * @return Return the height based on the width
+ * @return Return the height based on the width.
*/
float GetHeightForWidth( float width );
/**
- * @brief Calculate the width of the actor given a height
+ * @brief Calculate the width of the actor given a height.
*
* The natural size is used for default calculation.
* size 0 is treated as aspect ratio 1:1.
*
* @since_tizen 2.4
* @param height Height to use
- * @return Return the width based on the height
+ * @return Return the width based on the height.
*/
float GetWidthForHeight( float height );
/**
- * @brief Return the value of negotiated dimension for the given dimension
+ * @brief Return the value of negotiated dimension for the given dimension.
*
* @since_tizen 2.4
* @param dimension The dimension to retrieve
- * @return Return the value of the negotiated dimension
+ * @return Return the value of the negotiated dimension. If more than one dimension is requested, just return the first one found.
*/
float GetRelayoutSize( Dimension::Type dimension ) const;
/**
- * @brief Set the padding for use in layout
+ * @brief Set the padding for use in layout.
*
* @since_tizen 2.4
* @param[in] padding Padding for the actor
void SetPadding( const Padding& padding );
/**
- * @brief Return the value of the padding
+ * @brief Return the value of the padding.
*
* @since_tizen 2.4
* @param paddingOut The returned padding data
void GetPadding( Padding& paddingOut ) const;
/**
- * @brief Set the minimum size an actor can be assigned in size negotiation
+ * @brief Set the minimum size an actor can be assigned in size negotiation.
*
* @since_tizen 2.4
* @param[in] size The minimum size
void SetMinimumSize( const Vector2& size );
/**
- * @brief Return the minimum relayout size
+ * @brief Return the minimum relayout size.
*
* @since_tizen 2.4
- * @return Return the mininmum size
+ * @return Return the mininmum size.
*/
Vector2 GetMinimumSize();
/**
- * @brief Set the maximum size an actor can be assigned in size negotiation
+ * @brief Set the maximum size an actor can be assigned in size negotiation.
*
* @since_tizen 2.4
* @param[in] size The maximum size
void SetMaximumSize( const Vector2& size );
/**
- * @brief Return the maximum relayout size
+ * @brief Return the maximum relayout size.
*
* @since_tizen 2.4
- * @return Return the maximum size
+ * @return Return the maximum size.
*/
Vector2 GetMaximumSize();
/**
- * @brief Get depth in the hierarchy for the actor
+ * @brief Get depth in the hierarchy for the actor.
*
* @since_tizen 2.4
* @return The current depth in the hierarchy of the actor, or -1 if actor is not in the hierarchy
*
* When an actor is connected, it will be directly or indirectly parented to the root Actor.
* @since_tizen 2.4
- * @return The signal
+ * @return The signal to connect to.
* @note The root Actor is provided automatically by Dali::Stage, and is always considered to be connected.
*
* @note When the parent of a set of actors is connected to the stage, then all of the children
* If an actor is disconnected it either has no parent, or is parented to a disconnected actor.
*
* @since_tizen 2.4
- * @return The signal
+ * @return The signal to connect to.
* @note When the parent of a set of actors is disconnected to the stage, then all of the children
* will received this callback, starting with the leaf actors.
* For the following actor tree, the callback order will be D, E, B, F, C, and finally A.
* @brief Get the number of renderers on this actor.
*
* @since_tizen 2.4
- * @remarks Not implemented yet. This will be supported in future version
+ * @remarks Not implemented yet. This will be supported in future version.
* @return The number of renderers on this actor
*/
unsigned int GetRendererCount() const;
* @remarks Not implemented yet. This will be supported in future version.
* @param[in] index The index of the renderer to fetch
* @return The renderer at the specified index
- * @pre The index must be between 0 and GetRendererCount()-1
+ * @pre The index must be between 0 and GetRendererCount()-1.
*
*/
Renderer GetRendererAt( unsigned int index );
* @since_tizen 2.4
* @remarks Not implemented yet. This will be supported in future version.
* @param[in] index Index of the renderer that is to be removed
- * @pre The index must be between 0 and GetRendererCount()-1
+ * @pre The index must be between 0 and GetRendererCount()-1.
*
*/
void RemoveRenderer( unsigned int index );
/**
- * @brief This signal is emitted after the size has been set on the actor during relayout
+ * @brief This signal is emitted after the size has been set on the actor during relayout.
*
* @since_tizen 2.4
- * @return Return the signal
+ * @return Return the signal.
*/
OnRelayoutSignalType& OnRelayoutSignal();
{
enum Type
{
- ADD = 0x8006, ///< ADD @since_tizen 2.4
- SUBTRACT = 0x800A, ///< SUBTRACT @since_tizen 2.4
- REVERSE_SUBTRACT = 0x800B ///< REVERSE_SUBTRACT @since_tizen 2.4
+ ADD = 0x8006, ///< The source and destination colors are added to each other. @since_tizen 2.4
+ SUBTRACT = 0x800A, ///< Subtracts the destination from the source. @since_tizen 2.4
+ REVERSE_SUBTRACT = 0x800B ///< Subtracts the source from the destination. @since_tizen 2.4
};
} // namespace BlendingEquation
*/
enum Type
{
- FREE_LOOK, ///< Camera orientation is taken from CameraActor @since_tizen 2.4
- LOOK_AT_TARGET, ///< Camera is oriented to always look at a target @since_tizen 2.4
+ FREE_LOOK, ///< Camera orientation is taken from CameraActor. @since_tizen 2.4
+ LOOK_AT_TARGET, ///< Camera is oriented to always look at a target. @since_tizen 2.4
};
/**
*/
enum ProjectionMode
{
- PERSPECTIVE_PROJECTION, ///< Distance causes foreshortening; objects further from the camera appear smaller @since_tizen 2.4
- ORTHOGRAPHIC_PROJECTION, ///< Relative distance from the camera does not affect the size of objects @since_tizen 2.4
+ PERSPECTIVE_PROJECTION, ///< Distance causes foreshortening; objects further from the camera appear smaller. @since_tizen 2.4
+ ORTHOGRAPHIC_PROJECTION, ///< Relative distance from the camera does not affect the size of objects. @since_tizen 2.4
};
} // namespace Camera
/**
* @brief Get the field of view in Radians.
*
- * The default field of view is 45 degrees
+ * The default field of view is 45 degrees.
* @since_tizen 2.4
* @return The field of view in radians
*/
/**
* @brief Get the aspect ratio of the camera.
*
- * The default aspect ratio is 4.0f/3.0f
+ * The default aspect ratio is 4.0f/3.0f.
* @since_tizen 2.4
* @return The aspect ratio
*/
/**
* @brief Get the near clipping plane distance.
*
- * The default near clipping plane is 800.0f, to match the default screen height
- * Reduce this value to see objects closer to the camera
+ * The default near clipping plane is 800.0f, to match the default screen height.
+ * Reduce this value to see objects closer to the camera.
* @since_tizen 2.4
* @return The near clipping plane value
*/
/**
* @brief Get the far clipping plane distance.
*
- * The default value is the default near clipping plane + (0xFFFF>>4)
+ * The default value is the default near clipping plane + (0xFFFF>>4).
* @since_tizen 2.4
* @return The far clipping plane value
*/
*
* @since_tizen 2.4
* @param[in] targetPosition The position of the target to look at
- * @pre Camera type is LOOK_AT_TARGET
+ * @pre Camera type is LOOK_AT_TARGET.
*/
void SetTargetPosition( const Vector3& targetPosition );
/**
* @brief Get Camera Target position.
*
- * The target position is Vector3::ZERO
+ * The default target position is Vector3::ZERO.
* @since_tizen 2.4
* @return The target position of the camera
- * @pre Camera type is LOOK_AT_TARGET
+ * @pre Camera type is LOOK_AT_TARGET.
*/
Vector3 GetTargetPosition() const;
* @brief CustomActorImpl is an abstract base class for custom control implementations.
*
* This provides a series of pure virtual methods, which are called when actor-specific events occur.
- * An CustomActorImpl is typically owned by a single CustomActor instance; see also CustomActor::CustomActor( CustomActorImpl &implementation ).
+ * And CustomActorImpl is typically owned by a single CustomActor instance; see also CustomActor::CustomActor( CustomActorImpl &implementation ).
* @since_tizen 2.4
*/
class DALI_IMPORT_API CustomActorImpl : public Dali::RefObject
class Extension; ///< Forward declare future extension interface
/**
- * @brief Virtual destructor.
+ * @brief Virtual destructor
* @since_tizen 2.4
*/
virtual ~CustomActorImpl();
* @brief Used by derived CustomActorImpl instances, to access the public Actor interface.
*
* @since_tizen 2.4
- * @return A pointer to self, or an uninitialized pointer if the CustomActorImpl is not owned.
+ * @return A pointer to self, or an uninitialized pointer if the CustomActorImpl is not owned
*/
CustomActor Self() const;
* @brief Called after a child has been added to the owning actor.
*
* @since_tizen 2.4
- * @param[in] child The child which has been added.
+ * @param[in] child The child which has been added
*/
virtual void OnChildAdd(Actor& child) = 0;
* @brief Called after a child has been removed from the owning actor.
*
* @since_tizen 2.4
- * @param[in] child The child being removed.
+ * @param[in] child The child being removed
*/
virtual void OnChildRemove(Actor& child) = 0;
* @brief Called when the owning actor property is set.
*
* @since_tizen 2.4
- * @param[in] index The Property index that was set.
- * @param[in] propertyValue The value to set.
+ * @param[in] index The Property index that was set
+ * @param[in] propertyValue The value to set
*/
virtual void OnPropertySet( Property::Index index, Property::Value propertyValue );
* @brief Called after a touch-event is received by the owning actor.
*
* @since_tizen 2.4
- * @param[in] event The touch event.
+ * @param[in] event The touch event
* @return True if the event should be consumed.
- * @note This must be enabled during construction. See CustomActorImpl::CustomActorImpl( ActorFlags flags ).
+ * @note CustomActorImpl::REQUIRES_TOUCH_EVENTS must be enabled during construction. See CustomActorImpl::CustomActorImpl( ActorFlags flags ).
*/
virtual bool OnTouchEvent(const TouchEvent& event) = 0;
* @brief Called after a hover-event is received by the owning actor.
*
* @since_tizen 2.4
- * @param[in] event The hover event.
+ * @param[in] event The hover event
* @return True if the event should be consumed.
- * @note This must be enabled during construction. See CustomActorImpl::CustomActorImpl( ActorFlags flags ).
+ * @note CustomActorImpl::REQUIRES_HOVER_EVENTS must be enabled during construction. See CustomActorImpl::CustomActorImpl( ActorFlags flags ).
*/
virtual bool OnHoverEvent(const HoverEvent& event) = 0;
* @brief Called after a wheel-event is received by the owning actor.
*
* @since_tizen 2.4
- * @param[in] event The wheel event.
+ * @param[in] event The wheel event
* @return True if the event should be consumed.
- * @note This must be enabled during construction. See CustomActorImpl::CustomActorImpl( ActorFlags flags ).
+ * @note CustomActorImpl::REQUIRES_WHEEL_EVENTS must be enabled during construction. See CustomActorImpl::CustomActorImpl( ActorFlags flags ).
*/
virtual bool OnWheelEvent(const WheelEvent& event) = 0;
virtual void OnSetResizePolicy( ResizePolicy::Type policy, Dimension::Type dimension ) = 0;
/**
- * @brief Return the natural size of the actor
+ * @brief Return the natural size of the actor.
*
* @since_tizen 2.4
* @return The actor's natural size
virtual Vector3 GetNaturalSize() = 0;
/**
- * @brief Calculate the size for a child
+ * @brief Calculate the size for a child.
*
* @since_tizen 2.4
* @param[in] child The child actor to calculate the size for
* @param[in] dimension The dimension to calculate the size for. E.g. width or height.
- * @return Return the calculated size for the given dimension
+ * @return Return the calculated size for the given dimension.
*/
virtual float CalculateChildSize( const Dali::Actor& child, Dimension::Type dimension ) = 0;
*
* @since_tizen 2.4
* @param height Height to use.
- * @return The width based on the width.
+ * @return The width based on the width
*/
virtual float GetWidthForHeight( float height ) = 0;
/**
- * @brief Determine if this actor is dependent on it's children for relayout
+ * @brief Determine if this actor is dependent on it's children for relayout.
*
* @since_tizen 2.4
* @param dimension The dimension(s) to check for
- * @return Return if the actor is dependent on it's children
+ * @return Return if the actor is dependent on it's children.
*/
virtual bool RelayoutDependentOnChildren( Dimension::Type dimension = Dimension::ALL_DIMENSIONS ) = 0;
virtual void OnLayoutNegotiated( float size, Dimension::Type dimension ) = 0;
/**
- * @brief Retrieve the extension for this control
+ * @brief Retrieve the extension for this control.
*
* @since_tizen 2.4
* @return The extension if available, NULL otherwise
enum ActorFlags
{
ACTOR_BEHAVIOUR_NONE = 0,
- DISABLE_SIZE_NEGOTIATION = 1 << 0, ///< True if control does not need size negotiation, i.e. it can be skipped in the algorithm @since_tizen 2.4
+ DISABLE_SIZE_NEGOTIATION = 1 << 0, ///< True if control does not need size negotiation, i.e. it can be skipped in the algorithm. @since_tizen 2.4
REQUIRES_TOUCH_EVENTS = 1 << 1, ///< True if the OnTouchEvent() callback is required. @since_tizen 2.4
REQUIRES_HOVER_EVENTS = 1 << 2, ///< True if the OnHoverEvent() callback is required. @since_tizen 2.4
REQUIRES_WHEEL_EVENTS = 1 << 3, ///< True if the OnWheelEvent() callback is required. @since_tizen 2.4
// Size negotiation helpers
/**
- * @brief Request a relayout, which means performing a size negotiation on this actor, its parent and children (and potentially whole scene)
+ * @brief Request a relayout, which means performing a size negotiation on this actor, its parent and children (and potentially whole scene).
*
* This method can also be called from a derived class every time it needs a different size.
* At the end of event processing, the relayout process starts and
void RelayoutRequest();
/**
- * @brief provides the Actor implementation of GetHeightForWidth
+ * @brief Provides the Actor implementation of GetHeightForWidth.
* @since_tizen 2.4
* @param width Width to use.
* @return The height based on the width.
float GetHeightForWidthBase( float width );
/**
- * @brief Provides the Actor implementation of GetWidthForHeight
+ * @brief Provides the Actor implementation of GetWidthForHeight.
* @since_tizen 2.4
* @param height Height to use.
* @return The width based on the height.
float GetWidthForHeightBase( float height );
/**
- * @brief Calculate the size for a child using the base actor object
+ * @brief Calculate the size for a child using the base actor object.
*
* @since_tizen 2.4
* @param[in] child The child actor to calculate the size for
- * @param[in] dimension The dimension to calculate the size for. E.g. width or height.
- * @return Return the calculated size for the given dimension
+ * @param[in] dimension The dimension to calculate the size for. E.g. width or height
+ * @return Return the calculated size for the given dimension. If more than one dimension is requested, just return the first one found.
*/
float CalculateChildSizeBase( const Dali::Actor& child, Dimension::Type dimension );
/**
- * @brief Determine if this actor is dependent on it's children for relayout from the base class
+ * @brief Determine if this actor is dependent on it's children for relayout from the base class.
*
* @since_tizen 2.4
* @param dimension The dimension(s) to check for
- * @return Return if the actor is dependent on it's children
+ * @return Return if the actor is dependent on it's children.
*/
bool RelayoutDependentOnChildrenBase( Dimension::Type dimension = Dimension::ALL_DIMENSIONS );
public: // Not intended for application developers
/**
- * @brief Called when ownership of the CustomActorImpl is passed to a CustomActor.
+ * @brief Initialize a CustomActor.
* @since_tizen 2.4
- * @param[in] owner The owning object.
+ * @param[in] owner The owning object
* @pre The CustomActorImpl is not already owned.
+ * @note Called when ownership of the CustomActorImpl is passed to a CustomActor.
*/
void Initialize(Internal::CustomActor& owner);
Internal::CustomActor* GetOwner() const;
/**
- * @brief Called when ownership of the CustomActorImpl is passed to a CustomActor.
+ * @brief Returns whether the OnTouchEvent() callback is required.
* @since_tizen 2.4
* @return True if the OnTouchEvent() callback is required.
+ * @note Called when ownership of the CustomActorImpl is passed to a CustomActor.
*/
bool RequiresTouchEvents() const;
/**
- * @brief Called when ownership of the CustomActorImpl is passed to a CustomActor.
+ * @brief Returns whether the OnHoverEvent() callback is required.
* @since_tizen 2.4
* @return True if the OnHoverEvent() callback is required.
+ * @note Called when ownership of the CustomActorImpl is passed to a CustomActor.
*/
bool RequiresHoverEvents() const;
/**
- * @brief Called when ownership of the CustomActorImpl is passed to a CustomActor.
+ * @brief Returns whether the OnWheelEvent() callback is required.
* @since_tizen 2.4
* @return True if the OnWheelEvent() callback is required.
+ * @note Called when ownership of the CustomActorImpl is passed to a CustomActor.
*/
bool RequiresWheelEvents() const;
/**
- * @brief Called when ownership of the CustomActorImpl is passed to a CustomActor.
+ * @brief Returns whether relayout is enabled.
* @since_tizen 2.4
- * @return Return true if relayout is enabled on the custom actor
+ * @return Return true if relayout is enabled on the custom actor.
+ * @note Called when ownership of the CustomActorImpl is passed to a CustomActor.
*/
bool IsRelayoutEnabled() const;
* @brief Retrieve the custom actor implementation.
*
* @since_tizen 2.4
- * @return The implementation.
+ * @return The implementation
*/
CustomActorImpl& GetImplementation();
* @brief Retrieve the custom actor implementation.
*
* @since_tizen 2.4
- * @return The implementation.
+ * @return The implementation
*/
const CustomActorImpl& GetImplementation() const;
* @brief Create an initialised CustomActor.
*
* @since_tizen 2.4
- * @param[in] implementation The implementation for this custom actor.
- * @return A handle to a newly allocated Dali resource.
+ * @param[in] implementation The implementation for this custom actor
+ * @return A handle to a newly allocated Dali resource
*/
CustomActor(CustomActorImpl& implementation);
* @brief Copy constructor
*
* @since_tizen 2.4
- * @param [in] copy The actor to copy.
+ * @param [in] copy The actor to copy
*/
CustomActor(const CustomActor& copy);
* @brief Assignment operator
*
* @since_tizen 2.4
- * @param [in] rhs The actor to copy.
+ * @param [in] rhs The actor to copy
* @return A reference to this
*/
CustomActor& operator=(const CustomActor& rhs);
* stop the natural size being used.
*
* @since_tizen 2.4
- * @remarks Use of ImageActor should be avoided unless shader effects need to be applied.
+ * @remarks This is an experimental feature and might not be supported in the next release. We do recommend not to use it. Use of ImageActor should be avoided unless shader effects need to be applied.
* For general purpose, use Toolkit::ImageView which has much better performance.
* @see Toolkit::ImageView
*/
public:
/**
- * @brief An enumeration of properties belonging to the ImageActor class.
+ * @brief An enumeration of properties belonging to the ImageActor class
* @since_tizen 2.4
*/
struct Property
enum
{
/**
- * @brief name "pixel-area", type Rect<int>
+ * @brief type Rect<int>
* @since_tizen 2.4
* @remarks This is an experimental feature and might not be supported in the next release.
* We do recommend not to use it.
*/
PIXEL_AREA = DEFAULT_DERIVED_ACTOR_PROPERTY_START_INDEX,
/**
- * @brief name "style", type std::string
+ * @brief type std::string
* @since_tizen 2.4
*/
STYLE,
/**
- * @brief name "border", type Vector4
+ * @brief type Vector4
* @since_tizen 2.4
* @remarks This is an experimental feature and might not be supported in the next release.
* We do recommend not to use it.
*/
BORDER,
/**
- * @brief name "image", type Map {"filename":"", "load-policy":...}
+ * @brief type Map {"filename":"", "loadPolicy":...} \n
* @since_tizen 2.4
*/
IMAGE,
*
* The actor will take the image's natural size unless a custom size
* is chosen, e.g. via Actor:SetSize().
- * If the handle is empty, ImageActor will display nothing
+ * If the handle is empty, ImageActor will display nothing.
* @since_tizen 2.4
* @param[in] image The image to display.
* @return A handle to a newly allocated actor.
* @brief Create a image actor object.
*
* The actor will take the image's natural size unless a custom size
- * is chosen, e.g. via Actor:SetSize()
- * If the handle is empty, ImageActor will display nothing
+ * is chosen, e.g. via Actor:SetSize().
+ * If the handle is empty, ImageActor will display nothing.
* @since_tizen 2.4
* @param [in] image The image to display.
* @param [in] pixelArea The area of the image to display.
* @brief Copy constructor
*
* @since_tizen 2.4
- * @param [in] copy The actor to copy.
+ * @param [in] copy The actor to copy
*/
ImageActor(const ImageActor& copy);
* @brief Assignment operator
*
* @since_tizen 2.4
- * @param [in] rhs The actor to copy.
+ * @param [in] rhs The actor to copy
* @return A reference to this
*/
ImageActor& operator=(const ImageActor& rhs);
/**
* @brief Set the image rendered by the actor.
*
- * Set the image rendered by the actor.
* If actor was already displaying a different image, the old image is dropped and actor may
* temporarily display nothing. Setting an empty image (handle) causes the current image to be
* dropped and actor displays nothing.
* The actor will take the image's natural size unless a custom size
- * is chosen, e.g. via Actor::SetSize()
+ * is chosen, e.g. via Actor::SetSize().
*
* @since_tizen 2.4
- * @param [in] image The image to display.
+ * @param [in] image The image to display
* @pre ImageActor must be initialized.
*/
void SetImage(Image image);
/**
* @brief Retrieve the image rendered by the actor.
*
- * If no image is assigned, an empty handle is returned
+ * If no image is assigned, an empty handle is returned.
* @since_tizen 2.4
- * @return The image.
+ * @return The image
*/
Image GetImage();
* @param [in] pixelArea The area of the image to display.
* This in pixels, relative to the top-left (0,0) of the image.
* @pre Image must be initialized.
- * @note PixelArea should be inside the image data size. It gets clamped by GL
+ * @note PixelArea should be inside the image data size. It gets clamped by GL.
*/
void SetPixelArea(const PixelArea& pixelArea);
* @brief Set how the image is rendered; the default is STYLE_QUAD.
*
* @since_tizen 2.4
- * @param [in] style The new style.
+ * @param [in] style The new style
* @pre Image must be initialized.
*/
void SetStyle(Style style);
* @brief Query how the image is rendered.
*
* @since_tizen 2.4
- * @return The rendering style.
+ * @return The rendering style
* @pre Image must be initialized.
*/
Style GetStyle() const;
* @since_tizen 2.4
* @remarks This is an experimental feature and might not be supported in the next release.
* We do recommend not to use it.
- * @param [in] border The new nine-patch border.
+ * @param [in] border The new nine-patch border
*/
void SetNinePatchBorder(const Vector4& border);
* @since_tizen 2.4
* @remarks This is an experimental feature and might not be supported in the next release.
* We do recommend not to use it.
- * @return The nine-patch border.
+ * @return The nine-patch border
*/
Vector4 GetNinePatchBorder() const;
* The offset can be altered for each coplanar actor hence allowing an order of painting.
* @since_tizen 2.4
* @remarks Avoid using this method as it's a legacy code. Rendering order of actors on the same z position should be
- * determined by the depth level in the scene graph tree, not by this method
- * @param [in] depthOffset The offset to be given to the actor. Positive values pushing it further back.
+ * determined by the depth level in the scene graph tree, not by this method.
+ * @param [in] depthOffset The offset to be given to the actor. Positive values pushing it up front.
* @pre The Actor has been initialized.
* @see Layer::Behavior
*/
* The offset can be altered for each coplanar actor hence allowing an order of painting.
* @since_tizen 2.4
* @remarks Avoid using this method as it's a legacy code. Rendering order of actors on the same z position should be
- * determined by the depth level in the scene graph tree, not by this method
+ * determined by the depth level in the scene graph tree, not by this method.
* @return The offset that has been given to the actor. Positive values pushing it further back.
* @pre The Actor has been initialized.
* @see Layer::Behavior
* @since_tizen 2.4
* @remarks This is an experimental feature and might not be supported in the next release.
* We do recommend not to use it.
- * @param[in] mode The blending mode.
+ * @param[in] mode The blending mode
*/
void SetBlendMode( BlendingMode::Type mode );
* @since_tizen 2.4
* @remarks This is an experimental feature and might not be supported in the next release.
* We do recommend not to use it.
- * @param[out] srcFactorRgb Specifies how the red, green, blue, and alpha source blending factors are computed.
- * @param[out] destFactorRgb Specifies how the red, green, blue, and alpha destination blending factors are computed.
- * @param[out] srcFactorAlpha Specifies how the red, green, blue, and alpha source blending factors are computed.
- * @param[out] destFactorAlpha Specifies how the red, green, blue, and alpha destination blending factors are computed.
+ * @param[out] srcFactorRgb Specifies how the red, green and blue source blending factors are computed.
+ * @param[out] destFactorRgb Specifies how the red, green and blue destination blending factors are computed.
+ * @param[out] srcFactorAlpha Specifies how the alpha source blending factor is computed.
+ * @param[out] destFactorAlpha Specifies how the alpha destination blending factor is computed.
*/
void GetBlendFunc( BlendingFactor::Type& srcFactorRgb, BlendingFactor::Type& destFactorRgb,
BlendingFactor::Type& srcFactorAlpha, BlendingFactor::Type& destFactorAlpha ) const;
* @since_tizen 2.4
* @remarks This is an experimental feature and might not be supported in the next release.
* We do recommend not to use it.
- * @param[in] color The blend color.
+ * @param[in] color The blend color
*/
void SetBlendColor( const Vector4& color );
* @since_tizen 2.4
* @remarks This is an experimental feature and might not be supported in the next release.
* We do recommend not to use it.
- * @return The blend color.
+ * @return The blend color
*/
const Vector4& GetBlendColor() const;
* @since_tizen 2.4
* @remarks This is an experimental feature and might not be supported in the next release.
* We do recommend not to use it.
- * @param[in] minFilter The minification filtering mode.
- * @param[in] magFilter The magnification filtering mode.
+ * @param[in] minFilter The minification filtering mode
+ * @param[in] magFilter The magnification filtering mode
*/
void SetFilterMode( FilterMode::Type minFilter, FilterMode::Type magFilter );
* Shader effects provide special effects like ripple and bend.
* Setting a shader effect removes any shader effect previously set by @ref ImageActor::SetShaderEffect.
* @since_tizen 2.4
- * @param [in] effect The shader effect.
+ * @param [in] effect The shader effect
* @pre The actor has been initialized.
* @pre Effect has been initialized.
*/
* @brief Sets the shader effect for all ImageActors in a tree of Actors.
*
* @since_tizen 2.4
- * @param [in] actor Root of a tree of actors.
- * @param [in] effect The shader effect.
+ * @remarks This is an experimental feature and might not be supported in the next release.
+ * @param [in] actor Root of a tree of actors
+ * @param [in] effect The shader effect
* @see ImageActor::SetShaderEffect
*
*/
* @brief Removes the shader effect from all ImageActors in a tree of Actors.
*
* @since_tizen 2.4
- * @param [in] actor Root of a tree of actors.
+ * @remarks This is an experimental feature and might not be supported in the next release.
+ * @param [in] actor Root of a tree of actors
* @see ImageActor::RemoveShaderEffect
*
*/
}
/**
- * @brief Rectangle describing area on screen that a layer can draw to.
+ * @brief Rectangle describing area on screen that a layer can draw to
*
* @since_tizen 2.4
* @see Dali::Layer::SetClippingBox()
* layer is at depth zero. The stage provides a default layer for it's children (see Stage::GetRootLayer()).
*
* Layered actors inherit position etc. as normal, but are drawn in an order determined
- * by the layers. The depth buffer is cleared before each layer is rendered unless depth
+ * by the layers. In case of LAYER_3D, the depth buffer is cleared before each layer is rendered unless depth
* test is disabled or there's no need for it based on the layers contents;
* actors in lower layers cannot obscure actors in higher layers.
*
* @brief Layer doesn't make use of the depth test (default mode).
*
* This mode is expected to have better performance than the 3D mode.
- * When using this mode any ordering would be with respect to depth-index property of Actors.
+ * When using this mode any ordering would be with respect to tree level of each Actor.
*
* For the following actor tree of the Layer1 object, D and E hide B, B and C hides A,
- * and F hides C, regardless of their z positions.
+ * and F hides C, regardless of their Z positions.
* Rendering order between siblings, such as D & E or B & C, is not determined.
* If you have two overlapped actors, just make them parent-child, not siblings.
*
/**
* @brief Layer will use depth test and do several clears.
*
- * When using this mode depth test will be used. A depth clear will happen for each distinct
- * depth-index value in the layer, opaque renderers are drawn first and write to the depth buffer.
+ * When using this mode depth test will be used. A depth clear will happen for each layer,
+ * which means actors in a layer "above" other layers will be rendered in front of actors in
+ * those layers regardless of their Z positions (see Layer::Raise() and Layer::Lower()).
+ * Opaque renderers are drawn first and write to the depth buffer.
* Then transparent renderers are drawn with depth test enabled but depth write switched off.
* Unlike LAYER_2D, parent-child relationship does not affect rendering order at all.
*
/**
* @brief TREE_DEPTH_MULTIPLIER is used by the rendering sorting algorithm to decide which actors to render first.
- * For 2D layers, this value will be multiplied to the actor depth in the tree and added to the depth index
- * to obtain the value which will be used for ordering
* @since_tizen 2.4
*/
enum TreeDepthMultiplier
TREE_DEPTH_MULTIPLIER = 10000,
};
/**
- * @brief The sort function type.
+ * @brief The sort function type
*
* @since_tizen 2.4
* @param[in] position This is the actor translation from camera.
/**
* @brief Create an empty Layer handle.
*
- * This can be initialised with Layer::New(...)
+ * This can be initialised with Layer::New(...).
* @since_tizen 2.4
*/
Layer();
* @brief Copy constructor
*
* @since_tizen 2.4
- * @param [in] copy The actor to copy.
+ * @param [in] copy The actor to copy
*/
Layer(const Layer& copy);
* @brief Assignment operator
*
* @since_tizen 2.4
- * @param [in] rhs The actor to copy.
+ * @param [in] rhs The actor to copy
* @return A reference to this
*/
Layer& operator=(const Layer& rhs);
/**
* @brief Query the depth of the layer
*
- * 0 is bottom most layer, higher number is on top
+ * 0 is bottom most layer, higher number is on top.
* @since_tizen 2.4
- * @return The current depth of the layer.
- * @pre Layer is on the stage
+ * @return The current depth of the layer
+ * @pre Layer is on the stage.
* If layer is not added to the stage, returns 0.
*/
unsigned int GetDepth() const;
* @brief Increment the depth of the layer.
*
* @since_tizen 2.4
- * @pre Layer is on the stage
+ * @pre Layer is on the stage.
*/
void Raise();
* @brief Decrement the depth of the layer.
*
* @since_tizen 2.4
- * @pre Layer is on the stage
+ * @pre Layer is on the stage.
*/
void Lower();
/**
* @brief Ensures the layers depth is greater than the target layer.
*
- * If the layer already is above target layer its depth is not changed
- * If the layer was below target, its new depth will be immediately above target
+ * If the layer already is above the target layer its depth is not changed.
+ * If the layer was below target, its new depth will be immediately above target.
* @since_tizen 2.4
* @param target Layer to get above of
- * @pre Layer is on the stage
- * @pre Target layer is on the stage
- * @note All layers between this layer and target get new depth values
+ * @pre Layer is on the stage.
+ * @pre Target layer is on the stage.
+ * @note All layers between this layer and target get new depth values.
*/
void RaiseAbove( Layer target );
/**
* @brief Ensures the layers depth is less than the target layer.
*
- * If the layer already is below the layer its depth is not changed
- * If the layer was above target, its new depth will be immediately below target
+ * If the layer already is below the target layer its depth is not changed.
+ * If the layer was above target, its new depth will be immediately below target.
* @since_tizen 2.4
* @param target Layer to get below of
- * @pre Layer is on the stage
- * @pre Target layer is on the stage
- * @note All layers between this layer and target get new depth values
+ * @pre Layer is on the stage.
+ * @pre Target layer is on the stage.
+ * @note All layers between this layer and target get new depth values.
*/
void LowerBelow( Layer target );
/**
* @brief Raises the layer to the top.
* @since_tizen 2.4
- * @pre Layer is on the stage
+ * @pre Layer is on the stage.
*/
void RaiseToTop();
/**
* @brief Lowers the layer to the bottom.
* @since_tizen 2.4
- * @pre layer is on the stage
+ * @pre layer is on the stage.
*/
void LowerToBottom();
/**
* @brief Moves the layer directly above the given layer.
*
- * After the call this layers depth will be immediately above target
+ * After the call this layers depth will be immediately above target.
* @since_tizen 2.4
* @param target Layer to get on top of
- * @pre Layer is on the stage
- * @pre Target layer is on the stage
- * @note All layers between this layer and target get new depth values
+ * @pre Layer is on the stage.
+ * @pre Target layer is on the stage.
+ * @note All layers between this layer and target get new depth values.
*/
void MoveAbove( Layer target );
/**
* @brief Moves the layer directly below the given layer.
*
- * After the call this layers depth will be immediately below target
+ * After the call this layers depth will be immediately below target.
* @since_tizen 2.4
* @param target Layer to get below of
- * @pre Layer is on the stage
- * @pre Target layer is on the stage
- * @note All layers between this layer and target get new depth values
+ * @pre Layer is on the stage.
+ * @pre Target layer is on the stage.
+ * @note All layers between this layer and target get new depth values.
*/
void MoveBelow( Layer target );
/**
- * @brief Set the behavior of the layer
+ * @brief Set the behavior of the layer.
*
* @since_tizen 2.4
* @param[in] behavior The desired behavior
void SetBehavior( Behavior behavior );
/**
- * @brief Get the behavior of the layer
+ * @brief Get the behavior of the layer.
*
* @since_tizen 2.4
* @return The behavior of the layer
* The contents of the layer will not be visible outside this box, when clipping is
* enabled. The default clipping box is empty (0,0,0,0) which means everything is clipped.
* You can only do rectangular clipping using this API in window coordinates.
- * For other kinds of clipping, @see Dali::Actor::SetDrawMode().
+ * For other kinds of clipping, see Dali::Actor::SetDrawMode().
* @since_tizen 2.4
- * @param [in] x The X-coordinate of the top-left corner of the box.
- * @param [in] y The Y-coordinate of the top-left corner of the box.
- * @param [in] width The width of the box.
- * @param [in] height The height of the box.
+ * @param [in] x The X-coordinate of the top-left corner of the box
+ * @param [in] y The Y-coordinate of the top-left corner of the box
+ * @param [in] width The width of the box
+ * @param [in] height The height of the box
*/
void SetClippingBox(int x, int y, int width, int height);
/**
* @brief Whether to disable the depth test.
*
- * By default a layer enables depth test if there is more than one opaque actor or if there is one opaque actor and one, or more, transparent actors.
+ * By default a layer enables depth test if there is more than one opaque actor or if there is one opaque actor and one, or more, transparent actors in LAYER_3D mode.
* However, it's possible to disable the depth test by calling this method.
*
* @since_tizen 2.4
{
enum Type
{
- NONE, ///< Use GL system defaults (minification NEAREST_MIPMAP_LINEAR, magnification LINEAR) @since_tizen 2.4
- DEFAULT, ///< Use dali defaults (minification LINEAR, magnification LINEAR) @since_tizen 2.4
- NEAREST, ///< Filter nearest @since_tizen 2.4
- LINEAR ///< Filter linear @since_tizen 2.4
+ NONE, ///< Use GL defaults (minification NEAREST_MIPMAP_LINEAR, magnification LINEAR)
+ DEFAULT, ///< Use Dali defaults (minification LINEAR, magnification LINEAR)
+ NEAREST, ///< Filter nearest
+ LINEAR ///< Filter linear
};
} //namespace FilterMode
AlphaFunctionPrototype GetCustomFunction() const;
/**
- * @brief Returns the built0in function used by the alpha function
+ * @brief Returns the built-in function used by the alpha function
* @since_tizen 2.4
* @return One of the built-in alpha functions. In case no built-in function
* has been specified, it will return AlphaFunction::DEFAULT
*
* @since_tizen 2.4
* @param [in] target The target object/property to animate.
- * @param [in] keyFrames The key frames
+ * @param [in] keyFrames The set of time/value pairs between which to animate.
*/
void AnimateBetween(Property target, KeyFrames& keyFrames);
*
* @since_tizen 2.4
* @param [in] target The target object/property to animate.
- * @param [in] keyFrames The key frames
+ * @param [in] keyFrames The set of time/value pairs between which to animate.
* @param [in] alpha The alpha function to apply.
*/
void AnimateBetween(Property target, KeyFrames& keyFrames, AlphaFunction alpha);
*
* @since_tizen 2.4
* @param [in] target The target object/property to animate.
- * @param [in] keyFrames The key frames
+ * @param [in] keyFrames The set of time/value pairs between which to animate.
* @param [in] period The effect will occur during this time period.
*/
void AnimateBetween(Property target, KeyFrames& keyFrames, TimePeriod period);
*
* @since_tizen 2.4
* @param [in] target The target object/property to animate.
- * @param [in] keyFrames The key frames
+ * @param [in] keyFrames The set of time/value pairs between which to animate.
* @param [in] alpha The alpha function to apply.
* @param [in] period The effect will occur during this time period.
*/
struct DALI_IMPORT_API ParentSource
{
/**
- * @brief Create a local constraint source.
+ * @brief Create a parent constraint source.
*
* @since_tizen 2.4
* @param [in] index The index of a property, provided by the parent of the constrained object.
Dali::Property::Index GetTargetProperty();
/**
- * @brief Set whether the constraint will "bake" a value when fully-applied.
+ * @brief Set the remove action. Constraint::Bake will "bake" a value when fully-applied.
*
- * Otherwise the constrained value will be discarded, when the constraint is removed.
+ * In case of Constraint::Discard, the constrained value will be discarded, when the constraint is removed.
* The default value is Constraint::Bake.
* @since_tizen 2.4
* @param[in] action The remove-action.
void SetRemoveAction( RemoveAction action );
/**
- * @brief Query whether the constraint will "bake" a value when fully-applied.
+ * @brief Retrieve the remove action that will happen when the constraint is removed.
*
- * Otherwise the constrained value will be discarded, when the constraint is removed.
* @since_tizen 2.4
* @return The remove-action.
*/
}
/**
- * @brief Override functor for float properties
+ * @brief Override functor for Vector2 properties
*
* @since_tizen 2.4
- * @param[in] current The current property value, the constrained value is set
+ * @param[in, out] current The current property value, the constrained value is set
* @param[in] inputs Contains the property to copy
*/
void operator()( Vector2& current, const PropertyInputContainer& inputs )
}
/**
- * @brief Override functor for float properties
+ * @brief Override functor for Vector3 properties
*
* @since_tizen 2.4
* @param[in,out] current The current property value, the constrained value is set
}
/**
- * @brief Override functor for float properties
+ * @brief Override functor for Vector4 properties
*
* @since_tizen 2.4
* @param[in,out] current The current property value, the constrained value is set
}
/**
- * @brief Override functor for float properties
+ * @brief Override functor for Quaternion properties
*
* @since_tizen 2.4
* @param[in,out] current The current property value, the constrained value is set
}
/**
- * @brief Override functor for float properties
+ * @brief Override functor for Matrix3 properties
*
* @since_tizen 2.4
* @param[in,out] current The current property value
}
/**
- * @brief Override functor for float properties
+ * @brief Override functor for Matrix properties
*
* @since_tizen 2.4
* @param[in,out] current The current property value, the constrained value is set
*
* The key frames should be added in time order.
* @since_tizen 2.4
- * @param[in] progress A value between 0.0 and 1.0.
+ * @param[in] progress A progress value between 0.0 and 1.0.
* @param[in] value A value.
*/
void Add(float progress, Property::Value value);
*
* The key frames should be added in time order.
* @since_tizen 2.4
- * @param[in] progress A value between 0.0 and 1.0.
+ * @param[in] progress A progress value between 0.0 and 1.0.
* @param[in] value A value.
* @param[in] alpha The alpha function used to blend to the next keyframe
*/
* A linear map is defined by a set of value-progress pairs.
* Progress must be normalized between [0,1]. If no progress is defined, the values
* are considered to be equally spaced along the x axis.
+ *
+ * Basically, a linear constrainer allows constraining a property to another property
+ * with the changes mapped over a certain range. For example, if you want to change the
+ * opacity of an actor depending on its position along the X-axis, so that it’s fully
+ * transparent on the edges and fully opaque in the center. To do this, an array with
+ * values, 0.0f, 1.0f, 0.0f, is created, which means that there are 3 control points.
+ * You can add as many control points as you want, but they will be linearly spaced.
+ * Then you can apply the linear constrainer by using the alpha of the actor as the
+ * target and the source as the actor’s position.
* @since_tizen 2.4
*/
class DALI_IMPORT_API LinearConstrainer : public Handle
/**
* @brief Create an uninitialized LinearConstrainer handle.
*
- * This can be initialized with @ref PathConstrainer::New
+ * This can be initialized with @ref LinearConstrainer::New
* Calling member functions with an uninitialized LinearConstrainer handle is not allowed.
* @since_tizen 2.4
*/
*
* @since_tizen 2.4
* @param[in] target Property to be constrained
- * @param[in] source Property used as parameter for the path
+ * @param[in] source Property used as parameter for the linear map
* @param[in] range The range of values in the source property which will be mapped to [0,1]
* @param[in] wrap Wrapping domain. Source property will be wrapped in the domain [wrap.x,wrap.y] before mapping to [0,1]. See cfloat.h for FLT_MAX
*/
* @brief This constructor is used by LinearConstrainer::New() methods.
*
* @since_tizen 2.4
- * @param[in] pathConstrainer A pointer to an internal PathConstrainer resource
+ * @param[in] internal A pointer to an internal LinearConstrainer resource
*/
- explicit DALI_INTERNAL LinearConstrainer(Internal::LinearConstrainer* pathConstrainer);
+ explicit DALI_INTERNAL LinearConstrainer(Internal::LinearConstrainer* internal);
};
/**
/**
* @brief Downcast a handle to Path handle.
*
- * If handle points to a KeyFrames object the downcast produces
+ * If handle points to a Path object the downcast produces
* valid handle. If not the returned handle is left uninitialized.
* @since_tizen 2.4
* @param[in] handle Handle to an object
* The generating algorithm is as follows:
* For a given knot point K[N], find the vector that bisects K[N-1],[N] and [N],[N+1].
* Calculate the tangent vector by taking the normal of this bisector.
- * The in control point is the length of the preceding segment back along this bisector multiplied by the curvature
- * The out control point is the length of the succeeding segment forward along this bisector multiplied by the curvature
+ * The in control point is the length of the preceding segment back along this bisector multiplied by the curvature.
+ * The out control point is the length of the succeeding segment forward along this bisector multiplied by the curvature.
*
* @since_tizen 2.4
* @param[in] curvature The curvature of the spline. 0 gives straight lines between the knots,
* pressed.
*
* Currently KeyEvent is also being used to relay messages from the
- * IMF keyboard to the internal core. In future IMF may communicate via its own
+ * IMF(Input Method Framework) keyboard to the internal core. In future IMF may communicate via its own
* module.
* @since_tizen 2.4
*/
* @brief Check to see if Shift key modifier has been supplied.
*
* @since_tizen 2.4
- * @return Bool true if shift modifier
+ * @return True if shift modifier
*/
bool IsShiftModifier() const;
* @brief Check to see if Ctrl (control) key modifier has been supplied.
*
* @since_tizen 2.4
- * @return Bool true if ctrl modifier
+ * @return True if ctrl modifier
*/
bool IsCtrlModifier() const;
* @brief Check to see if Alt key modifier has been supplied.
*
* @since_tizen 2.4
- * @return Bool true if alt modifier
+ * @return True if alt modifier
*/
bool IsAltModifier() const;
/**
* @brief Keycode for the key pressed.
+ *
+ * We recommend not to use this key code value
+ * directly because its meaning might be changed in the future. Currently, it means a
+ * platform-specific key code. You need to use IsKey() to know what a key event means
+ * instead of direct comparison of key code value.
*/
int keyCode;
* @endcode
*
* @since_tizen 2.4
- * @note Multi-touch taps are not currently supported. However, multiple taps (double & triple tap etc.) ARE supported.
+ * @note Multi-touch taps are not currently supported. However, multiple taps (double & triple tap etc.) are supported.
*
* @see TapGesture
*
}
typedef unsigned char PixelBuffer; ///< pixel data buffer @since_tizen 2.4
-typedef Rect<unsigned int> RectArea; ///< rectangular area (x,y,w,h) @since_tizen 2.4
+typedef Dali::Rect<unsigned int> RectArea; ///< rectangular area (x,y,w,h) @since_tizen 2.4
/**
* @brief BufferImage represents an image resource that can be added to ImageViews.
* @param [in] size The width and height to fit the loaded image to.
* @param [in] fittingMode The method used to fit the shape of the image before loading to the shape defined by the size parameter.
* @param [in] samplingMode The filtering method used when sampling pixels from the input image while fitting it to desired size.
- * @param [in] releasePol The releasePolicy to apply to Image. If the Image::UNUSED.
+ * @param [in] releasePol The releasePolicy to apply to Image. The default value is Image::NEVER.
* @param [in] orientationCorrection Reorient the image to respect any orientation metadata in its header.
* policy is set, a reload will not be possible, so the Image should never be
* used once all actors using it have gone off-stage.
/**
* @brief Constructor which creates an uninitialized FrameBufferImage object.
*
- * Use @ref Image::New to create an initialised object.
+ * Use @ref FrameBufferImage::New to create an initialised object.
* @since_tizen 2.4
*/
FrameBufferImage();
* This can only be used for images of up to 65535 x 65535 pixels.
* @since_tizen 2.4
*/
-typedef Uint16Pair ImageDimensions;
+typedef Dali::Uint16Pair ImageDimensions;
/**
* @brief Fitting options, used when resizing images to fit desired dimensions.
* which is repeatedly used. An example would be a button background image.
* The image resource is discarded when all ImageViews using the Image object are discarded.
* @since_tizen 2.4
- * @note if a resource was shared between Image objects it exists until its last reference is gone.
+ * @note If a resource was shared between Image objects it exists until its last reference is gone.
*
* Image objects are responsible for the underlying resource's lifetime.
*
* @brief Pointer to Dali::NativeImageInterface
* @since_tizen 2.4
*/
-typedef IntrusivePtr<NativeImageInterface> NativeImageInterfacePtr;
+typedef Dali::IntrusivePtr<NativeImageInterface> NativeImageInterfacePtr;
/**
* @}
/**
* @brief Constructor which creates an uninitialized NinePatchImage object.
*
- * Use @ref Image::New to create an initialised object.
+ * Use @ref NinePatchImage::New to create an initialised object.
* @since_tizen 2.4
*/
NinePatchImage();
* @brief Create an angle-axis pair.
*
* @since_tizen 2.4
- * @param[in] initialAngle The initial angle in radians.
- * @param[in] initialAxis The initial axis.
+ * @param[in] initialAngle The initial angle in radians
+ * @param[in] initialAxis The initial axis
*/
AngleAxis( Radian initialAngle, const Vector3& initialAxis )
: angle( initialAngle ),
};
-// compiler generated destructor, copy constructor and assignment operators are ok as this class is POD
+// Compiler generated destructor, copy constructor and assignment operators are ok as this class is POD
/**
- * @brief Compare two angle axis for equality
+ * @brief Compare two angle axis for equality.
*
* @since_tizen 2.4
* @param lhs angle axis
* @param rhs angle axis
- * @return true if they are equal
+ * @return True if they are equal
*/
inline bool operator==( const Dali::AngleAxis& lhs, const Dali::AngleAxis& rhs )
{
* @brief Returns the next power of two.
*
* In case of numbers which are already a power of two this function returns the original number.
- * If i is zero returns 1
+ * If i is zero returns 1.
* @since_tizen 2.4
- * @param[in] i input number
- * @return next power of two or i itself in case it's a power of two
+ * @param[in] i Input number
+ * @return The next power of two or i itself in case it's a power of two
*/
inline unsigned int NextPowerOfTwo( unsigned int i )
{
* @brief Whether a number is power of two.
*
* @since_tizen 2.4
- * @param[in] i input number
- * @return true if i is power of two
+ * @param[in] i Input number
+ * @return True if i is power of two.
*/
inline bool IsPowerOfTwo( unsigned int i )
{
* @brief Clamp a value.
*
* @since_tizen 2.4
- * @param[in] value The value to clamp.
- * @param[in] min The minimum allowed value.
- * @param[in] max The maximum allowed value.
+ * @param[in] value The value to clamp
+ * @param[in] min The minimum allowed value
+ * @param[in] max The maximum allowed value
* @return T the clamped value
*/
template< typename T >
* @brief Clamp a value directly.
*
* @since_tizen 2.4
- * @param[in,out] value The value that will be clamped.
- * @param[in] min The minimum allowed value.
- * @param[in] max The maximum allowed value.
+ * @param[in,out] value The value that will be clamped
+ * @param[in] min The minimum allowed value
+ * @param[in] max The maximum allowed valu.
*/
template< typename T >
inline void ClampInPlace( T& value, const T& min, const T& max )
*
* @since_tizen 2.4
* @param[in] offset The offset through the range @p low to @p high.
- * This value is clamped between 0 and 1
+ * This value is clamped between 0 and 1.
* @param[in] low Lowest value in range
* @param[in] high Highest value in range
- * @return A value between low and high.
+ * @return A value between low and high
*/
template< typename T >
inline const T Lerp( const float offset, const T& low, const T& high )
* @brief Get an epsilon that is valid for the given range.
*
* @since_tizen 2.4
- * @param[in] a the first value in the range
- * @param[in] b the second value in the range.
- * @return a suitable epsilon
+ * @param[in] a The first value in the range
+ * @param[in] b The second value in the range
+ * @return A suitable epsilon
*/
inline float GetRangedEpsilon( float a, float b )
{
* @brief Helper function to compare equality of a floating point value with zero.
*
* @since_tizen 2.4
- * @param[in] value the value to compare
- * @return true if the value is equal to zero
+ * @param[in] value The value to compare
+ * @return True if the value is equal to zero.
*/
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wfloat-equal"
* @brief Helper function to compare equality of two floating point values.
*
* @since_tizen 2.4
- * @param[in] a the first value to compare
- * @param[in] b the second value to compare
- * @return true if the values are equal within a minimal epsilon for their values
+ * @param[in] a The first value to compare
+ * @param[in] b The second value to compare
+ * @return True if the values are equal within a minimal epsilon for their values.
*/
inline bool Equals( float a, float b )
{
* @brief Helper function to compare equality of two floating point values.
*
* @since_tizen 2.4
- * @param[in] a the first value to compare
- * @param[in] b the second value to compare
- * @param[in] epsilon the minimum epsilon value that will be used to consider the values different
- * @return true if the difference between the values is less than the epsilon
+ * @param[in] a The first value to compare
+ * @param[in] b The second value to compare
+ * @param[in] epsilon The minimum epsilon value that will be used to consider the values different
+ * @return True if the difference between the values is less than the epsilon.
*/
inline bool Equals( float a, float b, float epsilon )
{
* @brief Get an float that is rounded at specified place of decimals.
*
* @since_tizen 2.4
- * @param[in] value float value
- * @param[in] pos decimal place
- * @return a rounded float
+ * @param[in] value Float value
+ * @param[in] pos Decimal place
+ * @return A rounded float
*/
inline float Round(float value, int pos)
{
* start: 2
* end: 8
*
+ * @code
* 2 8
* (\ / start) (\ / end)
* |----x |
+ * @endcode
*
* The value x will be confined to this domain.
* If x is below 2 e.g. 0, then it is wraped to 6.
* If x is above or equal to 8 e.g. 8.1 then it is
- * wrapped to 2.1
+ * wrapped to 2.1.
*
* Domain wrapping is useful for various problems from
* calculating positions in a space that repeats, to
* computing angles that range from 0 to 360.
*
* @since_tizen 2.4
- * @param[in] x the point to be wrapped within the domain
+ * @param[in] x The point to be wrapped within the domain
* @param[in] start The start of the domain
* @param[in] end The end of the domain
*
- * @return the wrapped value over the domain (start) (end)
- * @note if start = end (i.e. size of domain 0), then wrapping will not occur
+ * @return The wrapped value over the domain (start) (end)
+ * @note If start = end (i.e. size of domain 0), then wrapping will not occur
* and result will always be equal to start.
*
*/
* @brief Find the shortest distance (magnitude) and direction (sign)
* from (a) to (b) in domain (start) to (end).
*
- * (\ / start) (\ / end)
- * |-a b<----|
+ * @code
+ * (\ / start) (\ / end)
+ * |-a b<----|
+ * @endcode
*
* Knowing the shortest distance is useful with wrapped domains
* to solve problems such as determing the closest object to
* target wrapped value (350).
*
* @since_tizen 2.4
- * @param a the current value
- * @param b the target value
- * @param start the start of the domain
- * @param end the end of the domain
- * @return the shortest direction (the sign) and distance (the magnitude)
- * @note assumes both (a) and (b) are already within the domain
- * (start) to (end)
+ * @param a The current value
+ * @param b The target value
+ * @param start The start of the domain
+ * @param end The end of the domain
+ * @return The shortest direction (the sign) and distance (the magnitude)
+ * @note Assumes both (a) and (b) are already within the domain
+ * (start) to (end).
*
*/
inline float ShortestDistanceInDomain( float a, float b, float start, float end )
* }
* );
* @since_tizen 2.4
+ * @remarks This is an experimental feature and might not be supported in the next release. We do recommend not to use it.
*/
#define DALI_COMPOSE_SHADER(STR) #STR
}
/**
- * @brief Shader effects provide a visual effect for image views.
+ * @brief Shader effects provide a visual effect for image actors.
*
* For a Custom shader you can provide the vertex and fragment shader code as strings.
* These shader snippets get concatenated with the default attributes and uniforms.
* <BR>
* <B>
* @since_tizen 2.4
+ * @remarks This is an experimental feature and might not be supported in the next release. We do recommend not to use it.
* @note In order for fade and color animations to work, the fragment shader needs to multiply the fragment color
* with the uniform color "uColor" of the node
* </B>
projects / framework / graphics / dali.git / commitdiff