2 * Copyright (c) 2021 Samsung Electronics Co., Ltd.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
19 #include <dali/devel-api/actors/actor-devel.h>
20 #include <dali/devel-api/common/capabilities.h>
21 #include <dali/devel-api/common/stage.h>
22 #include <dali/devel-api/rendering/renderer-devel.h>
23 #include <dali/integration-api/render-task-list-integ.h>
24 #include <dali/public-api/dali-core.h>
29 #include <dali-test-suite-utils.h>
30 #include <mesh-builder.h>
31 #include <test-trace-call-stack.h>
32 #include "test-graphics-command-buffer.h"
36 namespace // unnamed namespace
38 const BlendFactor::Type DEFAULT_BLEND_FACTOR_SRC_RGB(BlendFactor::SRC_ALPHA);
39 const BlendFactor::Type DEFAULT_BLEND_FACTOR_DEST_RGB(BlendFactor::ONE_MINUS_SRC_ALPHA);
40 const BlendFactor::Type DEFAULT_BLEND_FACTOR_SRC_ALPHA(BlendFactor::ONE);
41 const BlendFactor::Type DEFAULT_BLEND_FACTOR_DEST_ALPHA(BlendFactor::ONE_MINUS_SRC_ALPHA);
43 const BlendEquation::Type DEFAULT_BLEND_EQUATION_RGB(BlendEquation::ADD);
44 const BlendEquation::Type DEFAULT_BLEND_EQUATION_ALPHA(BlendEquation::ADD);
47 * @brief Get GL stencil test enumeration value as a string.
48 * @return The string representation of the value of GL_STENCIL_TEST
50 std::string GetStencilTestString(void)
52 std::stringstream stream;
53 stream << std::hex << GL_STENCIL_TEST;
58 * @brief Get GL depth test enumeration value as a string.
59 * @return The string representation of the value of GL_DEPTH_TEST
61 std::string GetDepthTestString(void)
63 std::stringstream stream;
64 stream << std::hex << GL_DEPTH_TEST;
68 void ResetDebugAndFlush(TestApplication& application, TraceCallStack& glEnableDisableStack, TraceCallStack& glStencilFunctionStack)
70 glEnableDisableStack.Reset();
71 glStencilFunctionStack.Reset();
72 application.SendNotification();
76 void TestConstraintNoBlue(Vector4& current, const PropertyInputContainer& inputs)
81 Renderer CreateRenderer(Actor actor, Geometry geometry, Shader shader, int depthIndex)
83 Texture image0 = CreateTexture(TextureType::TEXTURE_2D, Pixel::RGB888, 64, 64);
84 TextureSet textureSet0 = CreateTextureSet(image0);
85 Renderer renderer0 = Renderer::New(geometry, shader);
86 renderer0.SetTextures(textureSet0);
87 renderer0.SetProperty(Renderer::Property::DEPTH_INDEX, depthIndex);
88 actor.AddRenderer(renderer0);
92 Actor CreateActor(Actor parent, int siblingOrder, const char* location)
94 Actor actor = Actor::New();
95 actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
96 actor.SetProperty(Actor::Property::PARENT_ORIGIN, AnchorPoint::CENTER);
97 actor.SetProperty(Actor::Property::POSITION, Vector2(0.0f, 0.0f));
98 actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
100 actor.SetProperty(Dali::DevelActor::Property::SIBLING_ORDER, siblingOrder);
101 DALI_TEST_EQUALS(actor.GetProperty<int>(Dali::DevelActor::Property::SIBLING_ORDER), siblingOrder, TEST_INNER_LOCATION(location));
106 } // unnamed namespace
108 void renderer_test_startup(void)
110 test_return_value = TET_UNDEF;
113 void renderer_test_cleanup(void)
115 test_return_value = TET_PASS;
118 int UtcDaliRendererNew01(void)
120 TestApplication application;
122 Geometry geometry = CreateQuadGeometry();
123 Shader shader = CreateShader();
124 Renderer renderer = Renderer::New(geometry, shader);
126 DALI_TEST_EQUALS((bool)renderer, true, TEST_LOCATION);
130 int UtcDaliRendererNew02(void)
132 TestApplication application;
134 DALI_TEST_EQUALS((bool)renderer, false, TEST_LOCATION);
138 int UtcDaliRendererCopyConstructor(void)
140 TestApplication application;
142 Geometry geometry = CreateQuadGeometry();
143 Shader shader = CreateShader();
144 Renderer renderer = Renderer::New(geometry, shader);
146 Renderer rendererCopy(renderer);
147 DALI_TEST_EQUALS((bool)rendererCopy, true, TEST_LOCATION);
152 int UtcDaliRendererAssignmentOperator(void)
154 TestApplication application;
156 Geometry geometry = CreateQuadGeometry();
157 Shader shader = CreateShader();
158 Renderer renderer = Renderer::New(geometry, shader);
161 DALI_TEST_EQUALS((bool)renderer2, false, TEST_LOCATION);
163 renderer2 = renderer;
164 DALI_TEST_EQUALS((bool)renderer2, true, TEST_LOCATION);
168 int UtcDaliRendererMoveConstructor(void)
170 TestApplication application;
172 Geometry geometry = CreateQuadGeometry();
173 Shader shader = Shader::New("vertexSrc", "fragmentSrc");
174 Renderer renderer = Renderer::New(geometry, shader);
175 DALI_TEST_CHECK(renderer);
176 DALI_TEST_EQUALS(1, renderer.GetBaseObject().ReferenceCount(), TEST_LOCATION);
177 DALI_TEST_EQUALS(renderer.GetProperty<Vector4>(Renderer::Property::BLEND_COLOR), Color::TRANSPARENT, TEST_LOCATION);
179 renderer.SetProperty(Renderer::Property::BLEND_COLOR, Color::MAGENTA);
180 application.SendNotification();
181 application.Render();
182 DALI_TEST_EQUALS(renderer.GetProperty<Vector4>(Renderer::Property::BLEND_COLOR), Color::MAGENTA, TEST_LOCATION);
184 Renderer move = std::move(renderer);
185 DALI_TEST_CHECK(move);
186 DALI_TEST_EQUALS(1, move.GetBaseObject().ReferenceCount(), TEST_LOCATION);
187 DALI_TEST_EQUALS(move.GetProperty<Vector4>(Renderer::Property::BLEND_COLOR), Color::MAGENTA, TEST_LOCATION);
188 DALI_TEST_CHECK(!renderer);
193 int UtcDaliRendererMoveAssignment(void)
195 TestApplication application;
197 Geometry geometry = CreateQuadGeometry();
198 Shader shader = Shader::New("vertexSrc", "fragmentSrc");
199 Renderer renderer = Renderer::New(geometry, shader);
200 DALI_TEST_CHECK(renderer);
201 DALI_TEST_EQUALS(1, renderer.GetBaseObject().ReferenceCount(), TEST_LOCATION);
202 DALI_TEST_EQUALS(renderer.GetProperty<Vector4>(Renderer::Property::BLEND_COLOR), Color::TRANSPARENT, TEST_LOCATION);
204 renderer.SetProperty(Renderer::Property::BLEND_COLOR, Color::MAGENTA);
205 application.SendNotification();
206 application.Render();
207 DALI_TEST_EQUALS(renderer.GetProperty<Vector4>(Renderer::Property::BLEND_COLOR), Color::MAGENTA, TEST_LOCATION);
210 move = std::move(renderer);
211 DALI_TEST_CHECK(move);
212 DALI_TEST_EQUALS(1, move.GetBaseObject().ReferenceCount(), TEST_LOCATION);
213 DALI_TEST_EQUALS(move.GetProperty<Vector4>(Renderer::Property::BLEND_COLOR), Color::MAGENTA, TEST_LOCATION);
214 DALI_TEST_CHECK(!renderer);
219 int UtcDaliRendererDownCast01(void)
221 TestApplication application;
223 Geometry geometry = CreateQuadGeometry();
224 Shader shader = CreateShader();
225 Renderer renderer = Renderer::New(geometry, shader);
227 BaseHandle handle(renderer);
228 Renderer renderer2 = Renderer::DownCast(handle);
229 DALI_TEST_EQUALS((bool)renderer2, true, TEST_LOCATION);
233 int UtcDaliRendererDownCast02(void)
235 TestApplication application;
237 Handle handle = Handle::New(); // Create a custom object
238 Renderer renderer = Renderer::DownCast(handle);
239 DALI_TEST_EQUALS((bool)renderer, false, TEST_LOCATION);
243 // using a template to auto deduce the parameter types
244 template<typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
245 void TEST_RENDERER_PROPERTY(P1 renderer, P2 stringName, P3 type, P4 isWriteable, P5 isAnimateable, P6 isConstraintInput, P7 enumName, P8 LOCATION)
247 DALI_TEST_EQUALS(renderer.GetPropertyName(enumName), stringName, LOCATION);
248 DALI_TEST_EQUALS(renderer.GetPropertyIndex(stringName), static_cast<Property::Index>(enumName), LOCATION);
249 DALI_TEST_EQUALS(renderer.GetPropertyType(enumName), type, LOCATION);
250 DALI_TEST_EQUALS(renderer.IsPropertyWritable(enumName), isWriteable, LOCATION);
251 DALI_TEST_EQUALS(renderer.IsPropertyAnimatable(enumName), isAnimateable, LOCATION);
252 DALI_TEST_EQUALS(renderer.IsPropertyAConstraintInput(enumName), isConstraintInput, LOCATION);
255 int UtcDaliRendererDefaultProperties(void)
257 TestApplication application;
258 /* from renderer-impl.cpp
259 DALI_PROPERTY( "depthIndex", INTEGER, true, false, false, Dali::Renderer::Property::DEPTH_INDEX )
260 DALI_PROPERTY( "faceCullingMode", INTEGER, true, false, false, Dali::Renderer::Property::FACE_CULLING_MODE )
261 DALI_PROPERTY( "blendMode", INTEGER, true, false, false, Dali::Renderer::Property::BLEND_MODE )
262 DALI_PROPERTY( "blendEquationRgb", INTEGER, true, false, false, Dali::Renderer::Property::BLEND_EQUATION_RGB )
263 DALI_PROPERTY( "blendEquationAlpha", INTEGER, true, false, false, Dali::Renderer::Property::BLEND_EQUATION_ALPHA )
264 DALI_PROPERTY( "blendFactorSrcRgb", INTEGER, true, false, false, Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB )
265 DALI_PROPERTY( "blendFactorDestRgb", INTEGER, true, false, false, Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB )
266 DALI_PROPERTY( "blendFactorSrcAlpha", INTEGER, true, false, false, Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA )
267 DALI_PROPERTY( "blendFactorDestAlpha", INTEGER, true, false, false, Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA )
268 DALI_PROPERTY( "blendColor", VECTOR4, true, false, false, Dali::Renderer::Property::BLEND_COLOR )
269 DALI_PROPERTY( "blendPreMultipliedAlpha", BOOLEAN, true, false, false, Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA )
270 DALI_PROPERTY( "indexRangeFirst", INTEGER, true, false, false, Dali::Renderer::Property::INDEX_RANGE_FIRST )
271 DALI_PROPERTY( "indexRangeCount", INTEGER, true, false, false, Dali::Renderer::Property::INDEX_RANGE_COUNT )
272 DALI_PROPERTY( "depthWriteMode", INTEGER, true, false, false, Dali::Renderer::Property::DEPTH_WRITE_MODE )
273 DALI_PROPERTY( "depthFunction", INTEGER, true, false, false, Dali::Renderer::Property::DEPTH_FUNCTION )
274 DALI_PROPERTY( "depthTestMode", INTEGER, true, false, false, Dali::Renderer::Property::DEPTH_TEST_MODE )
275 DALI_PROPERTY( "renderMode", INTEGER, true, false, false, Dali::Renderer::Property::RENDER_MODE )
276 DALI_PROPERTY( "stencilFunction", INTEGER, true, false, false, Dali::Renderer::Property::STENCIL_FUNCTION )
277 DALI_PROPERTY( "stencilFunctionMask", INTEGER, true, false, false, Dali::Renderer::Property::STENCIL_FUNCTION_MASK )
278 DALI_PROPERTY( "stencilFunctionReference", INTEGER, true, false, false, Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE )
279 DALI_PROPERTY( "stencilMask", INTEGER, true, false, false, Dali::Renderer::Property::STENCIL_MASK )
280 DALI_PROPERTY( "stencilOperationOnFail", INTEGER, true, false, false, Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL )
281 DALI_PROPERTY( "stencilOperationOnZFail", INTEGER, true, false, false, Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL )
282 DALI_PROPERTY( "stencilOperationOnZPass", INTEGER, true, false, false, Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS )
283 DALI_PROPERTY( "opacity", FLOAT, true, true, true, Dali::DevelRenderer::Property::OPACITY )
284 DALI_PROPERTY( "renderingBehavior", INTEGER, true, false, false, Dali::DevelRenderer::Property::RENDERING_BEHAVIOR )
285 DALI_PROPERTY( "blendEquation", INTEGER, true, false, false, Dali::DevelRenderer::Property::BLEND_EQUATION )
288 Geometry geometry = CreateQuadGeometry();
289 Shader shader = CreateShader();
290 Renderer renderer = Renderer::New(geometry, shader);
291 DALI_TEST_EQUALS(renderer.GetPropertyCount(), 27, TEST_LOCATION);
293 TEST_RENDERER_PROPERTY(renderer, "depthIndex", Property::INTEGER, true, false, false, Renderer::Property::DEPTH_INDEX, TEST_LOCATION);
294 TEST_RENDERER_PROPERTY(renderer, "faceCullingMode", Property::INTEGER, true, false, false, Renderer::Property::FACE_CULLING_MODE, TEST_LOCATION);
295 TEST_RENDERER_PROPERTY(renderer, "blendMode", Property::INTEGER, true, false, false, Renderer::Property::BLEND_MODE, TEST_LOCATION);
296 TEST_RENDERER_PROPERTY(renderer, "blendEquationRgb", Property::INTEGER, true, false, false, Renderer::Property::BLEND_EQUATION_RGB, TEST_LOCATION);
297 TEST_RENDERER_PROPERTY(renderer, "blendEquationAlpha", Property::INTEGER, true, false, false, Renderer::Property::BLEND_EQUATION_ALPHA, TEST_LOCATION);
298 TEST_RENDERER_PROPERTY(renderer, "blendFactorSrcRgb", Property::INTEGER, true, false, false, Renderer::Property::BLEND_FACTOR_SRC_RGB, TEST_LOCATION);
299 TEST_RENDERER_PROPERTY(renderer, "blendFactorDestRgb", Property::INTEGER, true, false, false, Renderer::Property::BLEND_FACTOR_DEST_RGB, TEST_LOCATION);
300 TEST_RENDERER_PROPERTY(renderer, "blendFactorSrcAlpha", Property::INTEGER, true, false, false, Renderer::Property::BLEND_FACTOR_SRC_ALPHA, TEST_LOCATION);
301 TEST_RENDERER_PROPERTY(renderer, "blendFactorDestAlpha", Property::INTEGER, true, false, false, Renderer::Property::BLEND_FACTOR_DEST_ALPHA, TEST_LOCATION);
302 TEST_RENDERER_PROPERTY(renderer, "blendColor", Property::VECTOR4, true, false, false, Renderer::Property::BLEND_COLOR, TEST_LOCATION);
303 TEST_RENDERER_PROPERTY(renderer, "blendPreMultipliedAlpha", Property::BOOLEAN, true, false, false, Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA, TEST_LOCATION);
304 TEST_RENDERER_PROPERTY(renderer, "indexRangeFirst", Property::INTEGER, true, false, false, Renderer::Property::INDEX_RANGE_FIRST, TEST_LOCATION);
305 TEST_RENDERER_PROPERTY(renderer, "indexRangeCount", Property::INTEGER, true, false, false, Renderer::Property::INDEX_RANGE_COUNT, TEST_LOCATION);
306 TEST_RENDERER_PROPERTY(renderer, "depthWriteMode", Property::INTEGER, true, false, false, Renderer::Property::DEPTH_WRITE_MODE, TEST_LOCATION);
307 TEST_RENDERER_PROPERTY(renderer, "depthFunction", Property::INTEGER, true, false, false, Renderer::Property::DEPTH_FUNCTION, TEST_LOCATION);
308 TEST_RENDERER_PROPERTY(renderer, "depthTestMode", Property::INTEGER, true, false, false, Renderer::Property::DEPTH_TEST_MODE, TEST_LOCATION);
309 TEST_RENDERER_PROPERTY(renderer, "renderMode", Property::INTEGER, true, false, false, Renderer::Property::RENDER_MODE, TEST_LOCATION);
310 TEST_RENDERER_PROPERTY(renderer, "stencilFunction", Property::INTEGER, true, false, false, Renderer::Property::STENCIL_FUNCTION, TEST_LOCATION);
311 TEST_RENDERER_PROPERTY(renderer, "stencilFunctionMask", Property::INTEGER, true, false, false, Renderer::Property::STENCIL_FUNCTION_MASK, TEST_LOCATION);
312 TEST_RENDERER_PROPERTY(renderer, "stencilFunctionReference", Property::INTEGER, true, false, false, Renderer::Property::STENCIL_FUNCTION_REFERENCE, TEST_LOCATION);
313 TEST_RENDERER_PROPERTY(renderer, "stencilMask", Property::INTEGER, true, false, false, Renderer::Property::STENCIL_MASK, TEST_LOCATION);
314 TEST_RENDERER_PROPERTY(renderer, "stencilOperationOnFail", Property::INTEGER, true, false, false, Renderer::Property::STENCIL_OPERATION_ON_FAIL, TEST_LOCATION);
315 TEST_RENDERER_PROPERTY(renderer, "stencilOperationOnZFail", Property::INTEGER, true, false, false, Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL, TEST_LOCATION);
316 TEST_RENDERER_PROPERTY(renderer, "stencilOperationOnZPass", Property::INTEGER, true, false, false, Renderer::Property::STENCIL_OPERATION_ON_Z_PASS, TEST_LOCATION);
317 TEST_RENDERER_PROPERTY(renderer, "opacity", Property::FLOAT, true, true, true, DevelRenderer::Property::OPACITY, TEST_LOCATION);
318 TEST_RENDERER_PROPERTY(renderer, "renderingBehavior", Property::INTEGER, true, false, false, DevelRenderer::Property::RENDERING_BEHAVIOR, TEST_LOCATION);
319 TEST_RENDERER_PROPERTY(renderer, "blendEquation", Property::INTEGER, true, false, false, DevelRenderer::Property::BLEND_EQUATION, TEST_LOCATION);
324 int UtcDaliRendererSetGetGeometry(void)
326 TestApplication application;
327 tet_infoline("Test SetGeometry, GetGeometry");
329 Geometry geometry1 = CreateQuadGeometry();
330 Geometry geometry2 = CreateQuadGeometry();
332 Shader shader = CreateShader();
333 Renderer renderer = Renderer::New(geometry1, shader);
334 Actor actor = Actor::New();
335 actor.AddRenderer(renderer);
336 actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
337 application.GetScene().Add(actor);
339 application.SendNotification();
340 application.Render(0);
341 DALI_TEST_EQUALS(renderer.GetGeometry(), geometry1, TEST_LOCATION);
343 // Set geometry2 to the renderer
344 renderer.SetGeometry(geometry2);
346 application.SendNotification();
347 application.Render(0);
348 DALI_TEST_EQUALS(renderer.GetGeometry(), geometry2, TEST_LOCATION);
353 int UtcDaliRendererSetGetShader(void)
355 TestApplication application;
356 tet_infoline("Test SetShader, GetShader");
358 TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
359 glAbstraction.EnableCullFaceCallTrace(true);
361 Shader shader1 = CreateShader();
362 shader1.RegisterProperty("uFadeColor", Color::RED);
364 Shader shader2 = CreateShader();
365 shader2.RegisterProperty("uFadeColor", Color::GREEN);
367 Geometry geometry = CreateQuadGeometry();
368 Renderer renderer = Renderer::New(geometry, shader1);
369 Actor actor = Actor::New();
370 actor.AddRenderer(renderer);
371 actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
372 application.GetScene().Add(actor);
374 TestGlAbstraction& gl = application.GetGlAbstraction();
375 application.SendNotification();
376 application.Render(0);
378 // Expect that the first shaders's fade color property is accessed
379 Vector4 actualValue(Vector4::ZERO);
380 DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uFadeColor", actualValue));
381 DALI_TEST_EQUALS(actualValue, Color::RED, TEST_LOCATION);
383 DALI_TEST_EQUALS(renderer.GetShader(), shader1, TEST_LOCATION);
385 // set the second shader to the renderer
386 renderer.SetShader(shader2);
388 application.SendNotification();
389 application.Render(0);
391 // Expect that the second shader's fade color property is accessed
392 DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uFadeColor", actualValue));
393 DALI_TEST_EQUALS(actualValue, Color::GREEN, TEST_LOCATION);
395 DALI_TEST_EQUALS(renderer.GetShader(), shader2, TEST_LOCATION);
400 int UtcDaliRendererSetGetDepthIndex(void)
402 TestApplication application;
404 tet_infoline("Test SetDepthIndex, GetDepthIndex");
406 Shader shader = CreateShader();
407 Geometry geometry = CreateQuadGeometry();
408 Renderer renderer = Renderer::New(geometry, shader);
409 Actor actor = Actor::New();
410 actor.AddRenderer(renderer);
411 actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
412 application.GetScene().Add(actor);
414 application.SendNotification();
415 application.Render(0);
416 DALI_TEST_EQUALS(renderer.GetProperty<int>(Renderer::Property::DEPTH_INDEX), 0, TEST_LOCATION);
418 renderer.SetProperty(Renderer::Property::DEPTH_INDEX, 1);
420 DALI_TEST_EQUALS(renderer.GetProperty<int>(Renderer::Property::DEPTH_INDEX), 1, TEST_LOCATION);
421 DALI_TEST_EQUALS(renderer.GetCurrentProperty<int>(Renderer::Property::DEPTH_INDEX), 0, TEST_LOCATION);
423 application.SendNotification();
424 application.Render(0);
425 DALI_TEST_EQUALS(renderer.GetCurrentProperty<int>(Renderer::Property::DEPTH_INDEX), 1, TEST_LOCATION);
427 renderer.SetProperty(Renderer::Property::DEPTH_INDEX, 10);
429 DALI_TEST_EQUALS(renderer.GetProperty<int>(Renderer::Property::DEPTH_INDEX), 10, TEST_LOCATION);
430 DALI_TEST_EQUALS(renderer.GetCurrentProperty<int>(Renderer::Property::DEPTH_INDEX), 1, TEST_LOCATION);
432 application.SendNotification();
433 application.Render(0);
434 DALI_TEST_EQUALS(renderer.GetCurrentProperty<int>(Renderer::Property::DEPTH_INDEX), 10, TEST_LOCATION);
439 int UtcDaliRendererSetGetFaceCullingMode(void)
441 TestApplication application;
443 tet_infoline("Test SetFaceCullingMode(cullingMode)");
444 Geometry geometry = CreateQuadGeometry();
445 Shader shader = CreateShader();
446 Renderer renderer = Renderer::New(geometry, shader);
448 Actor actor = Actor::New();
449 actor.AddRenderer(renderer);
450 actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
451 application.GetScene().Add(actor);
453 // By default, none of the faces should be culled
454 unsigned int cullFace = renderer.GetProperty<int>(Renderer::Property::FACE_CULLING_MODE);
455 DALI_TEST_CHECK(static_cast<FaceCullingMode::Type>(cullFace) == FaceCullingMode::NONE);
457 TestGlAbstraction& gl = application.GetGlAbstraction();
458 TraceCallStack& cullFaceStack = gl.GetCullFaceTrace();
459 gl.EnableCullFaceCallTrace(true);
462 cullFaceStack.Reset();
463 renderer.SetProperty(Renderer::Property::FACE_CULLING_MODE, FaceCullingMode::FRONT_AND_BACK);
464 application.SendNotification();
465 application.Render();
467 DALI_TEST_EQUALS(cullFaceStack.CountMethod("CullFace"), 1, TEST_LOCATION);
469 std::ostringstream cullModeString;
470 cullModeString << std::hex << GL_FRONT_AND_BACK;
472 DALI_TEST_CHECK(cullFaceStack.FindMethodAndParams("CullFace", cullModeString.str()));
473 cullFace = renderer.GetProperty<int>(Renderer::Property::FACE_CULLING_MODE);
474 DALI_TEST_CHECK(static_cast<FaceCullingMode::Type>(cullFace) == FaceCullingMode::FRONT_AND_BACK);
478 cullFaceStack.Reset();
479 renderer.SetProperty(Renderer::Property::FACE_CULLING_MODE, FaceCullingMode::BACK);
480 application.SendNotification();
481 application.Render();
483 DALI_TEST_EQUALS(cullFaceStack.CountMethod("CullFace"), 1, TEST_LOCATION);
485 std::ostringstream cullModeString;
486 cullModeString << std::hex << GL_BACK;
488 DALI_TEST_CHECK(cullFaceStack.FindMethodAndParams("CullFace", cullModeString.str()));
489 cullFace = renderer.GetProperty<int>(Renderer::Property::FACE_CULLING_MODE);
490 DALI_TEST_CHECK(static_cast<FaceCullingMode::Type>(cullFace) == FaceCullingMode::BACK);
494 cullFaceStack.Reset();
495 renderer.SetProperty(Renderer::Property::FACE_CULLING_MODE, FaceCullingMode::FRONT);
496 application.SendNotification();
497 application.Render();
499 DALI_TEST_EQUALS(cullFaceStack.CountMethod("CullFace"), 1, TEST_LOCATION);
501 std::ostringstream cullModeString;
502 cullModeString << std::hex << GL_FRONT;
504 DALI_TEST_CHECK(cullFaceStack.FindMethodAndParams("CullFace", cullModeString.str()));
505 cullFace = renderer.GetProperty<int>(Renderer::Property::FACE_CULLING_MODE);
506 DALI_TEST_CHECK(static_cast<FaceCullingMode::Type>(cullFace) == FaceCullingMode::FRONT);
510 cullFaceStack.Reset();
511 renderer.SetProperty(Renderer::Property::FACE_CULLING_MODE, FaceCullingMode::NONE);
512 application.SendNotification();
513 application.Render();
515 DALI_TEST_EQUALS(cullFaceStack.CountMethod("CullFace"), 0, TEST_LOCATION);
516 cullFace = renderer.GetProperty<int>(Renderer::Property::FACE_CULLING_MODE);
517 DALI_TEST_CHECK(static_cast<FaceCullingMode::Type>(cullFace) == FaceCullingMode::NONE);
523 int UtcDaliRendererBlendOptions01(void)
525 TestApplication application;
527 tet_infoline("Test BLEND_FACTOR properties ");
529 Geometry geometry = CreateQuadGeometry();
530 Shader shader = CreateShader();
531 Renderer renderer = Renderer::New(geometry, shader);
533 Actor actor = Actor::New();
534 // set a transparent actor color so that blending is enabled
535 actor.SetProperty(Actor::Property::OPACITY, 0.5f);
536 actor.AddRenderer(renderer);
537 actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
538 application.GetScene().Add(actor);
540 renderer.SetProperty(Renderer::Property::BLEND_FACTOR_SRC_RGB, BlendFactor::ONE_MINUS_SRC_COLOR);
541 renderer.SetProperty(Renderer::Property::BLEND_FACTOR_DEST_RGB, BlendFactor::SRC_ALPHA_SATURATE);
542 renderer.SetProperty(Renderer::Property::BLEND_FACTOR_SRC_ALPHA, BlendFactor::ONE_MINUS_SRC_COLOR);
543 renderer.SetProperty(Renderer::Property::BLEND_FACTOR_DEST_ALPHA, BlendFactor::SRC_ALPHA_SATURATE);
545 // Test that Set was successful:
546 int srcFactorRgb = renderer.GetProperty<int>(Renderer::Property::BLEND_FACTOR_SRC_RGB);
547 int destFactorRgb = renderer.GetProperty<int>(Renderer::Property::BLEND_FACTOR_DEST_RGB);
548 int srcFactorAlpha = renderer.GetProperty<int>(Renderer::Property::BLEND_FACTOR_SRC_ALPHA);
549 int destFactorAlpha = renderer.GetProperty<int>(Renderer::Property::BLEND_FACTOR_DEST_ALPHA);
551 DALI_TEST_EQUALS((int)BlendFactor::ONE_MINUS_SRC_COLOR, srcFactorRgb, TEST_LOCATION);
552 DALI_TEST_EQUALS((int)BlendFactor::SRC_ALPHA_SATURATE, destFactorRgb, TEST_LOCATION);
553 DALI_TEST_EQUALS((int)BlendFactor::ONE_MINUS_SRC_COLOR, srcFactorAlpha, TEST_LOCATION);
554 DALI_TEST_EQUALS((int)BlendFactor::SRC_ALPHA_SATURATE, destFactorAlpha, TEST_LOCATION);
556 application.SendNotification();
557 application.Render();
559 TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
561 DALI_TEST_EQUALS((GLenum)GL_ONE_MINUS_SRC_COLOR, glAbstraction.GetLastBlendFuncSrcRgb(), TEST_LOCATION);
562 DALI_TEST_EQUALS((GLenum)GL_SRC_ALPHA_SATURATE, glAbstraction.GetLastBlendFuncDstRgb(), TEST_LOCATION);
563 DALI_TEST_EQUALS((GLenum)GL_ONE_MINUS_SRC_COLOR, glAbstraction.GetLastBlendFuncSrcAlpha(), TEST_LOCATION);
564 DALI_TEST_EQUALS((GLenum)GL_SRC_ALPHA_SATURATE, glAbstraction.GetLastBlendFuncDstAlpha(), TEST_LOCATION);
569 int UtcDaliRendererBlendOptions02(void)
571 TestApplication application;
573 tet_infoline("Test BLEND_FACTOR properties ");
575 Geometry geometry = CreateQuadGeometry();
576 Shader shader = CreateShader();
577 Renderer renderer = Renderer::New(geometry, shader);
579 Actor actor = Actor::New();
580 actor.SetProperty(Actor::Property::OPACITY, 0.5f); // enable blending
581 actor.AddRenderer(renderer);
582 actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
583 application.GetScene().Add(actor);
585 renderer.SetProperty(Renderer::Property::BLEND_FACTOR_SRC_RGB, BlendFactor::CONSTANT_COLOR);
586 renderer.SetProperty(Renderer::Property::BLEND_FACTOR_DEST_RGB, BlendFactor::ONE_MINUS_CONSTANT_COLOR);
587 renderer.SetProperty(Renderer::Property::BLEND_FACTOR_SRC_ALPHA, BlendFactor::CONSTANT_ALPHA);
588 renderer.SetProperty(Renderer::Property::BLEND_FACTOR_DEST_ALPHA, BlendFactor::ONE_MINUS_CONSTANT_ALPHA);
590 // Test that Set was successful:
592 int srcFactorRgb = renderer.GetProperty<int>(Renderer::Property::BLEND_FACTOR_SRC_RGB);
593 int destFactorRgb = renderer.GetProperty<int>(Renderer::Property::BLEND_FACTOR_DEST_RGB);
594 int srcFactorAlpha = renderer.GetProperty<int>(Renderer::Property::BLEND_FACTOR_SRC_ALPHA);
595 int destFactorAlpha = renderer.GetProperty<int>(Renderer::Property::BLEND_FACTOR_DEST_ALPHA);
597 DALI_TEST_EQUALS((int)BlendFactor::CONSTANT_COLOR, srcFactorRgb, TEST_LOCATION);
598 DALI_TEST_EQUALS((int)BlendFactor::ONE_MINUS_CONSTANT_COLOR, destFactorRgb, TEST_LOCATION);
599 DALI_TEST_EQUALS((int)BlendFactor::CONSTANT_ALPHA, srcFactorAlpha, TEST_LOCATION);
600 DALI_TEST_EQUALS((int)BlendFactor::ONE_MINUS_CONSTANT_ALPHA, destFactorAlpha, TEST_LOCATION);
603 application.SendNotification();
604 application.Render();
606 TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
607 DALI_TEST_EQUALS((GLenum)GL_CONSTANT_COLOR, glAbstraction.GetLastBlendFuncSrcRgb(), TEST_LOCATION);
608 DALI_TEST_EQUALS((GLenum)GL_ONE_MINUS_CONSTANT_COLOR, glAbstraction.GetLastBlendFuncDstRgb(), TEST_LOCATION);
609 DALI_TEST_EQUALS((GLenum)GL_CONSTANT_ALPHA, glAbstraction.GetLastBlendFuncSrcAlpha(), TEST_LOCATION);
610 DALI_TEST_EQUALS((GLenum)GL_ONE_MINUS_CONSTANT_ALPHA, glAbstraction.GetLastBlendFuncDstAlpha(), TEST_LOCATION);
615 int UtcDaliRendererBlendOptions03(void)
617 TestApplication application;
619 tet_infoline("Test GetBlendEquation() defaults ");
621 Geometry geometry = CreateQuadGeometry();
622 Shader shader = CreateShader();
623 Renderer renderer = Renderer::New(geometry, shader);
625 Actor actor = Actor::New();
626 actor.AddRenderer(renderer);
627 actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
628 application.GetScene().Add(actor);
630 // Test the defaults as documented in blending.h
631 int equationRgb = renderer.GetProperty<int>(Renderer::Property::BLEND_EQUATION_RGB);
632 int equationAlpha = renderer.GetProperty<int>(Renderer::Property::BLEND_EQUATION_ALPHA);
634 DALI_TEST_EQUALS((int)BlendEquation::ADD, equationRgb, TEST_LOCATION);
635 DALI_TEST_EQUALS((int)BlendEquation::ADD, equationAlpha, TEST_LOCATION);
640 int UtcDaliRendererBlendOptions04(void)
642 TestApplication application;
644 tet_infoline("Test SetBlendEquation() ");
646 Geometry geometry = CreateQuadGeometry();
647 Shader shader = CreateShader();
648 Renderer renderer = Renderer::New(geometry, shader);
650 Actor actor = Actor::New();
651 actor.SetProperty(Actor::Property::OPACITY, 0.1f);
652 actor.AddRenderer(renderer);
653 actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
654 application.GetScene().Add(actor);
656 // Test the single blending equation setting
658 renderer.SetProperty(Renderer::Property::BLEND_EQUATION_RGB, BlendEquation::REVERSE_SUBTRACT);
659 int equationRgb = renderer.GetProperty<int>(Renderer::Property::BLEND_EQUATION_RGB);
660 DALI_TEST_EQUALS((int)BlendEquation::REVERSE_SUBTRACT, equationRgb, TEST_LOCATION);
663 renderer.SetProperty(Renderer::Property::BLEND_EQUATION_RGB, BlendEquation::REVERSE_SUBTRACT);
664 renderer.SetProperty(Renderer::Property::BLEND_EQUATION_ALPHA, BlendEquation::REVERSE_SUBTRACT);
666 // Test that Set was successful
668 int equationRgb = renderer.GetProperty<int>(Renderer::Property::BLEND_EQUATION_RGB);
669 int equationAlpha = renderer.GetProperty<int>(Renderer::Property::BLEND_EQUATION_ALPHA);
670 DALI_TEST_EQUALS((int)BlendEquation::REVERSE_SUBTRACT, equationRgb, TEST_LOCATION);
671 DALI_TEST_EQUALS((int)BlendEquation::REVERSE_SUBTRACT, equationAlpha, TEST_LOCATION);
674 // Render & check GL commands
675 application.SendNotification();
676 application.Render();
678 TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
679 DALI_TEST_EQUALS((GLenum)GL_FUNC_REVERSE_SUBTRACT, glAbstraction.GetLastBlendEquationRgb(), TEST_LOCATION);
680 DALI_TEST_EQUALS((GLenum)GL_FUNC_REVERSE_SUBTRACT, glAbstraction.GetLastBlendEquationAlpha(), TEST_LOCATION);
685 int UtcDaliRendererBlendOptions05(void)
687 TestApplication application;
689 tet_infoline("Test SetAdvancedBlendEquation ");
691 Geometry geometry = CreateQuadGeometry();
692 Shader shader = CreateShader();
693 Renderer renderer = Renderer::New(geometry, shader);
695 Actor actor = Actor::New();
696 actor.SetProperty(Actor::Property::OPACITY, 0.1f);
698 actor.AddRenderer(renderer);
699 actor.SetProperty(Actor::Property::SIZE, Vector2(400, 400));
700 application.GetScene().Add(actor);
702 if(Dali::Capabilities::IsBlendEquationSupported(DevelBlendEquation::MAX))
704 renderer.SetProperty(DevelRenderer::Property::BLEND_EQUATION, DevelBlendEquation::MAX);
705 int equationRgb = renderer.GetProperty<int>(DevelRenderer::Property::BLEND_EQUATION);
706 DALI_TEST_EQUALS((int)DevelBlendEquation::MAX, equationRgb, TEST_LOCATION);
709 if(Dali::Capabilities::IsBlendEquationSupported(DevelBlendEquation::SCREEN))
711 renderer.SetProperty(Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA, true);
712 renderer.SetProperty(DevelRenderer::Property::BLEND_EQUATION, DevelBlendEquation::SCREEN);
713 int equation = renderer.GetProperty<int>(DevelRenderer::Property::BLEND_EQUATION);
715 DALI_TEST_EQUALS((int)DevelBlendEquation::SCREEN, equation, TEST_LOCATION);
716 DALI_TEST_EQUALS(DevelRenderer::IsAdvancedBlendEquationApplied(renderer), true, TEST_LOCATION);
718 application.SendNotification();
719 application.Render();
722 if(Dali::Capabilities::IsBlendEquationSupported(DevelBlendEquation::SCREEN) &&
723 Dali::Capabilities::IsBlendEquationSupported(DevelBlendEquation::MULTIPLY))
725 renderer.SetProperty(DevelRenderer::Property::BLEND_EQUATION, DevelBlendEquation::ADD);
726 renderer.SetProperty(Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA, true);
727 renderer.SetProperty(DevelRenderer::Property::BLEND_EQUATION_RGB, DevelBlendEquation::SCREEN);
728 renderer.SetProperty(DevelRenderer::Property::BLEND_EQUATION_ALPHA, DevelBlendEquation::MULTIPLY);
729 int equationRgb = renderer.GetProperty<int>(DevelRenderer::Property::BLEND_EQUATION_RGB);
730 int equationAlpha = renderer.GetProperty<int>(DevelRenderer::Property::BLEND_EQUATION_ALPHA);
732 DALI_TEST_EQUALS((int)DevelBlendEquation::ADD, equationRgb, TEST_LOCATION);
733 DALI_TEST_EQUALS((int)DevelBlendEquation::ADD, equationAlpha, TEST_LOCATION);
734 DALI_TEST_EQUALS(DevelRenderer::IsAdvancedBlendEquationApplied(renderer), false, TEST_LOCATION);
736 application.SendNotification();
737 application.Render();
740 tet_infoline("Error Checking\n");
741 if(Dali::Capabilities::IsBlendEquationSupported(DevelBlendEquation::MULTIPLY) &&
742 Dali::Capabilities::IsBlendEquationSupported(DevelBlendEquation::SCREEN) &&
743 Dali::Capabilities::IsBlendEquationSupported(DevelBlendEquation::OVERLAY) &&
744 Dali::Capabilities::IsBlendEquationSupported(DevelBlendEquation::DARKEN) &&
745 Dali::Capabilities::IsBlendEquationSupported(DevelBlendEquation::LIGHTEN) &&
746 Dali::Capabilities::IsBlendEquationSupported(DevelBlendEquation::COLOR_DODGE) &&
747 Dali::Capabilities::IsBlendEquationSupported(DevelBlendEquation::COLOR_BURN) &&
748 Dali::Capabilities::IsBlendEquationSupported(DevelBlendEquation::HARD_LIGHT) &&
749 Dali::Capabilities::IsBlendEquationSupported(DevelBlendEquation::SOFT_LIGHT) &&
750 Dali::Capabilities::IsBlendEquationSupported(DevelBlendEquation::DIFFERENCE) &&
751 Dali::Capabilities::IsBlendEquationSupported(DevelBlendEquation::EXCLUSION) &&
752 Dali::Capabilities::IsBlendEquationSupported(DevelBlendEquation::HUE) &&
753 Dali::Capabilities::IsBlendEquationSupported(DevelBlendEquation::SATURATION) &&
754 Dali::Capabilities::IsBlendEquationSupported(DevelBlendEquation::COLOR) &&
755 Dali::Capabilities::IsBlendEquationSupported(DevelBlendEquation::LUMINOSITY))
757 renderer.SetProperty(DevelRenderer::Property::BLEND_EQUATION, DevelBlendEquation::MULTIPLY);
758 DALI_TEST_EQUALS((int)DevelBlendEquation::MULTIPLY, renderer.GetProperty<int>(DevelRenderer::Property::BLEND_EQUATION), TEST_LOCATION);
760 renderer.SetProperty(DevelRenderer::Property::BLEND_EQUATION, DevelBlendEquation::SCREEN);
761 DALI_TEST_EQUALS((int)DevelBlendEquation::SCREEN, renderer.GetProperty<int>(DevelRenderer::Property::BLEND_EQUATION), TEST_LOCATION);
763 renderer.SetProperty(DevelRenderer::Property::BLEND_EQUATION, DevelBlendEquation::OVERLAY);
764 DALI_TEST_EQUALS((int)DevelBlendEquation::OVERLAY, renderer.GetProperty<int>(DevelRenderer::Property::BLEND_EQUATION), TEST_LOCATION);
766 renderer.SetProperty(DevelRenderer::Property::BLEND_EQUATION, DevelBlendEquation::DARKEN);
767 DALI_TEST_EQUALS((int)DevelBlendEquation::DARKEN, renderer.GetProperty<int>(DevelRenderer::Property::BLEND_EQUATION), TEST_LOCATION);
769 renderer.SetProperty(DevelRenderer::Property::BLEND_EQUATION, DevelBlendEquation::LIGHTEN);
770 DALI_TEST_EQUALS((int)DevelBlendEquation::LIGHTEN, renderer.GetProperty<int>(DevelRenderer::Property::BLEND_EQUATION), TEST_LOCATION);
772 renderer.SetProperty(DevelRenderer::Property::BLEND_EQUATION, DevelBlendEquation::COLOR_DODGE);
773 DALI_TEST_EQUALS((int)DevelBlendEquation::COLOR_DODGE, renderer.GetProperty<int>(DevelRenderer::Property::BLEND_EQUATION), TEST_LOCATION);
775 renderer.SetProperty(DevelRenderer::Property::BLEND_EQUATION, DevelBlendEquation::COLOR_BURN);
776 DALI_TEST_EQUALS((int)DevelBlendEquation::COLOR_BURN, renderer.GetProperty<int>(DevelRenderer::Property::BLEND_EQUATION), TEST_LOCATION);
778 renderer.SetProperty(DevelRenderer::Property::BLEND_EQUATION, DevelBlendEquation::HARD_LIGHT);
779 DALI_TEST_EQUALS((int)DevelBlendEquation::HARD_LIGHT, renderer.GetProperty<int>(DevelRenderer::Property::BLEND_EQUATION), TEST_LOCATION);
781 renderer.SetProperty(DevelRenderer::Property::BLEND_EQUATION, DevelBlendEquation::SOFT_LIGHT);
782 DALI_TEST_EQUALS((int)DevelBlendEquation::SOFT_LIGHT, renderer.GetProperty<int>(DevelRenderer::Property::BLEND_EQUATION), TEST_LOCATION);
784 renderer.SetProperty(DevelRenderer::Property::BLEND_EQUATION, DevelBlendEquation::DIFFERENCE);
785 DALI_TEST_EQUALS((int)DevelBlendEquation::DIFFERENCE, renderer.GetProperty<int>(DevelRenderer::Property::BLEND_EQUATION), TEST_LOCATION);
787 renderer.SetProperty(DevelRenderer::Property::BLEND_EQUATION, DevelBlendEquation::EXCLUSION);
788 DALI_TEST_EQUALS((int)DevelBlendEquation::EXCLUSION, renderer.GetProperty<int>(DevelRenderer::Property::BLEND_EQUATION), TEST_LOCATION);
790 renderer.SetProperty(DevelRenderer::Property::BLEND_EQUATION, DevelBlendEquation::HUE);
791 DALI_TEST_EQUALS((int)DevelBlendEquation::HUE, renderer.GetProperty<int>(DevelRenderer::Property::BLEND_EQUATION), TEST_LOCATION);
793 renderer.SetProperty(DevelRenderer::Property::BLEND_EQUATION, DevelBlendEquation::SATURATION);
794 DALI_TEST_EQUALS((int)DevelBlendEquation::SATURATION, renderer.GetProperty<int>(DevelRenderer::Property::BLEND_EQUATION), TEST_LOCATION);
796 renderer.SetProperty(DevelRenderer::Property::BLEND_EQUATION, DevelBlendEquation::COLOR);
797 DALI_TEST_EQUALS((int)DevelBlendEquation::COLOR, renderer.GetProperty<int>(DevelRenderer::Property::BLEND_EQUATION), TEST_LOCATION);
799 renderer.SetProperty(DevelRenderer::Property::BLEND_EQUATION, DevelBlendEquation::LUMINOSITY);
800 DALI_TEST_EQUALS((int)DevelBlendEquation::LUMINOSITY, renderer.GetProperty<int>(DevelRenderer::Property::BLEND_EQUATION), TEST_LOCATION);
806 int UtcDaliRendererSetBlendMode01(void)
808 TestApplication application;
810 tet_infoline("Test setting the blend mode to on with an opaque color renders with blending enabled");
812 Geometry geometry = CreateQuadGeometry();
813 Shader shader = CreateShader();
814 Renderer renderer = Renderer::New(geometry, shader);
816 Actor actor = Actor::New();
817 actor.SetProperty(Actor::Property::OPACITY, 1.0f);
818 actor.AddRenderer(renderer);
819 actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
820 application.GetScene().Add(actor);
822 renderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::ON);
824 TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
825 glAbstraction.EnableEnableDisableCallTrace(true);
827 application.SendNotification();
828 application.Render();
830 TraceCallStack& glEnableStack = glAbstraction.GetEnableDisableTrace();
831 TraceCallStack::NamedParams params;
832 params["cap"] << std::hex << GL_BLEND;
833 DALI_TEST_CHECK(glEnableStack.FindMethodAndParams("Enable", params));
838 int UtcDaliRendererSetBlendMode01b(void)
840 TestApplication application;
842 tet_infoline("Test setting the blend mode to on with an transparent color renders with blending enabled");
844 Geometry geometry = CreateQuadGeometry();
845 Shader shader = CreateShader();
846 Renderer renderer = Renderer::New(geometry, shader);
848 Actor actor = Actor::New();
849 actor.SetProperty(Actor::Property::OPACITY, 0.0f);
850 actor.AddRenderer(renderer);
851 actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
852 application.GetScene().Add(actor);
854 renderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::ON);
856 TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
857 glAbstraction.EnableEnableDisableCallTrace(true);
858 glAbstraction.EnableDrawCallTrace(true);
860 application.SendNotification();
861 application.Render();
863 TraceCallStack& glEnableStack = glAbstraction.GetEnableDisableTrace();
864 DALI_TEST_CHECK(!glEnableStack.FindMethod("Enable"));
866 DALI_TEST_CHECK(!glAbstraction.GetDrawTrace().FindMethod("DrawElements"));
871 int UtcDaliRendererSetBlendMode02(void)
873 TestApplication application;
875 tet_infoline("Test setting the blend mode to off with a transparent color renders with blending disabled (and not enabled)");
877 Geometry geometry = CreateQuadGeometry();
878 Shader shader = CreateShader();
879 Renderer renderer = Renderer::New(geometry, shader);
881 Actor actor = Actor::New();
882 actor.SetProperty(Actor::Property::OPACITY, 0.15f);
883 actor.AddRenderer(renderer);
884 actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
885 application.GetScene().Add(actor);
887 renderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::OFF);
889 TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
890 glAbstraction.EnableEnableDisableCallTrace(true);
892 application.SendNotification();
893 application.Render();
895 TraceCallStack& glEnableStack = glAbstraction.GetEnableDisableTrace();
896 TraceCallStack::NamedParams params;
897 params["cap"] << std::hex << GL_BLEND;
898 DALI_TEST_CHECK(!glEnableStack.FindMethodAndParams("Enable", params));
903 int UtcDaliRendererSetBlendMode03(void)
905 TestApplication application;
907 tet_infoline("Test setting the blend mode to auto with a transparent color renders with blending enabled");
909 Geometry geometry = CreateQuadGeometry();
910 Shader shader = CreateShader();
911 Renderer renderer = Renderer::New(geometry, shader);
913 Actor actor = Actor::New();
914 actor.SetProperty(Actor::Property::OPACITY, 0.75f);
915 actor.AddRenderer(renderer);
916 actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
917 application.GetScene().Add(actor);
919 renderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::AUTO);
921 TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
922 glAbstraction.EnableEnableDisableCallTrace(true);
924 application.SendNotification();
925 application.Render();
927 TraceCallStack& glEnableStack = glAbstraction.GetEnableDisableTrace();
928 TraceCallStack::NamedParams params;
929 params["cap"] << std::hex << GL_BLEND;
930 DALI_TEST_CHECK(glEnableStack.FindMethodAndParams("Enable", params));
935 int UtcDaliRendererSetBlendMode04(void)
937 TestApplication application;
939 tet_infoline("Test setting the blend mode to auto with an opaque color renders with blending disabled");
941 Geometry geometry = CreateQuadGeometry();
942 Shader shader = CreateShader();
943 Renderer renderer = Renderer::New(geometry, shader);
945 Actor actor = Actor::New();
946 actor.AddRenderer(renderer);
947 actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
948 application.GetScene().Add(actor);
950 renderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::AUTO);
952 TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
953 glAbstraction.EnableEnableDisableCallTrace(true);
955 application.SendNotification();
956 application.Render();
958 TraceCallStack& glEnableStack = glAbstraction.GetEnableDisableTrace();
959 TraceCallStack::NamedParams params;
960 params["cap"] << std::hex << GL_BLEND;
961 DALI_TEST_CHECK(!glEnableStack.FindMethodAndParams("Enable", params));
962 DALI_TEST_CHECK(glEnableStack.FindMethodAndParams("Disable", params));
967 int UtcDaliRendererSetBlendMode04b(void)
969 TestApplication application;
971 tet_infoline("Test setting the blend mode to auto with a transparent actor color renders with blending enabled");
973 Geometry geometry = CreateQuadGeometry();
974 Shader shader = CreateShader();
975 Renderer renderer = Renderer::New(geometry, shader);
977 Actor actor = Actor::New();
978 actor.AddRenderer(renderer);
979 actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
980 actor.SetProperty(Actor::Property::COLOR, Vector4(1.0f, 0.0f, 1.0f, 0.5f));
981 application.GetScene().Add(actor);
983 renderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::AUTO);
985 TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
986 glAbstraction.EnableEnableDisableCallTrace(true);
988 application.SendNotification();
989 application.Render();
991 TraceCallStack& glEnableStack = glAbstraction.GetEnableDisableTrace();
992 TraceCallStack::NamedParams params;
993 params["cap"] << std::hex << GL_BLEND;
994 DALI_TEST_CHECK(glEnableStack.FindMethodAndParams("Enable", params));
999 int UtcDaliRendererSetBlendMode04c(void)
1001 TestApplication application;
1003 tet_infoline("Test setting the blend mode to auto with an opaque opaque actor color renders with blending disabled");
1005 Geometry geometry = CreateQuadGeometry();
1006 Shader shader = CreateShader();
1007 Renderer renderer = Renderer::New(geometry, shader);
1009 Actor actor = Actor::New();
1010 actor.AddRenderer(renderer);
1011 actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
1012 actor.SetProperty(Actor::Property::COLOR, Color::MAGENTA);
1013 application.GetScene().Add(actor);
1015 renderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::AUTO);
1017 TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
1018 glAbstraction.EnableEnableDisableCallTrace(true);
1020 application.SendNotification();
1021 application.Render();
1023 TraceCallStack& glEnableStack = glAbstraction.GetEnableDisableTrace();
1024 TraceCallStack::NamedParams params;
1025 params["cap"] << std::hex << GL_BLEND;
1026 DALI_TEST_CHECK(!glEnableStack.FindMethodAndParams("Enable", params));
1027 DALI_TEST_CHECK(glEnableStack.FindMethodAndParams("Disable", params));
1032 int UtcDaliRendererSetBlendMode05(void)
1034 TestApplication application;
1036 tet_infoline("Test setting the blend mode to auto with an opaque color and an image with an alpha channel renders with blending enabled");
1038 Geometry geometry = CreateQuadGeometry();
1039 Texture image = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 40, 40);
1041 Shader shader = CreateShader();
1042 TextureSet textureSet = CreateTextureSet(image);
1043 Renderer renderer = Renderer::New(geometry, shader);
1044 renderer.SetTextures(textureSet);
1046 Actor actor = Actor::New();
1047 actor.AddRenderer(renderer);
1048 actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
1049 application.GetScene().Add(actor);
1051 renderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::AUTO);
1053 TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
1054 glAbstraction.EnableEnableDisableCallTrace(true);
1056 application.SendNotification();
1057 application.Render();
1059 TraceCallStack& glEnableStack = glAbstraction.GetEnableDisableTrace();
1060 TraceCallStack::NamedParams params;
1061 params["cap"] << std::hex << GL_BLEND;
1062 DALI_TEST_CHECK(glEnableStack.FindMethodAndParams("Enable", params));
1067 int UtcDaliRendererSetBlendMode06(void)
1069 TestApplication application;
1070 tet_infoline("Test setting the blend mode to auto with an opaque color and an image without an alpha channel and a shader with the hint OUTPUT_IS_TRANSPARENT renders with blending enabled");
1072 Geometry geometry = CreateQuadGeometry();
1073 Shader shader = Shader::New("vertexSrc", "fragmentSrc", Shader::Hint::OUTPUT_IS_TRANSPARENT);
1075 Renderer renderer = Renderer::New(geometry, shader);
1077 Actor actor = Actor::New();
1078 actor.AddRenderer(renderer);
1079 actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
1080 application.GetScene().Add(actor);
1082 renderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::AUTO);
1084 TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
1085 glAbstraction.EnableEnableDisableCallTrace(true);
1087 application.SendNotification();
1088 application.Render();
1090 TraceCallStack& glEnableStack = glAbstraction.GetEnableDisableTrace();
1091 TraceCallStack::NamedParams params;
1092 params["cap"] << std::hex << GL_BLEND;
1093 DALI_TEST_CHECK(glEnableStack.FindMethodAndParams("Enable", params));
1098 int UtcDaliRendererSetBlendMode07(void)
1100 TestApplication application;
1101 tet_infoline("Test setting the blend mode to auto with an opaque color and an image without an alpha channel and a shader with the hint OUTPUT_IS_OPAQUE renders with blending disabled");
1103 Geometry geometry = CreateQuadGeometry();
1104 Shader shader = Shader::New("vertexSrc", "fragmentSrc");
1106 Texture image = Texture::New(TextureType::TEXTURE_2D, Pixel::RGB888, 50, 50);
1107 TextureSet textureSet = CreateTextureSet(image);
1108 Renderer renderer = Renderer::New(geometry, shader);
1109 renderer.SetTextures(textureSet);
1111 Actor actor = Actor::New();
1112 actor.AddRenderer(renderer);
1113 actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
1114 application.GetScene().Add(actor);
1116 renderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::AUTO);
1118 TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
1119 glAbstraction.EnableEnableDisableCallTrace(true);
1121 application.SendNotification();
1122 application.Render();
1124 TraceCallStack& glEnableStack = glAbstraction.GetEnableDisableTrace();
1125 TraceCallStack::NamedParams params;
1126 params["cap"] << std::hex << GL_BLEND;
1127 DALI_TEST_CHECK(!glEnableStack.FindMethodAndParams("Enable", params));
1132 int UtcDaliRendererSetBlendMode08(void)
1134 TestApplication application;
1136 tet_infoline("Test setting the blend mode to auto with opaque color and Advanced Blend Equation.");
1138 if(Dali::Capabilities::IsBlendEquationSupported(DevelBlendEquation::SCREEN))
1140 Geometry geometry = CreateQuadGeometry();
1141 Shader shader = CreateShader();
1142 Renderer renderer = Renderer::New(geometry, shader);
1144 Actor actor = Actor::New();
1145 actor.SetProperty(Actor::Property::OPACITY, 1.0f);
1146 actor.AddRenderer(renderer);
1147 actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
1148 application.GetScene().Add(actor);
1150 renderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::AUTO);
1151 renderer.SetProperty(Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA, true);
1152 renderer.SetProperty(DevelRenderer::Property::BLEND_EQUATION, DevelBlendEquation::SCREEN);
1154 TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
1155 glAbstraction.EnableEnableDisableCallTrace(true);
1157 application.SendNotification();
1158 application.Render();
1160 TraceCallStack& glEnableStack = glAbstraction.GetEnableDisableTrace();
1161 TraceCallStack::NamedParams params;
1162 params["cap"] << std::hex << GL_BLEND;
1163 DALI_TEST_CHECK(glEnableStack.FindMethodAndParams("Enable", params));
1169 int UtcDaliRendererSetBlendMode08b(void)
1171 TestApplication application;
1173 tet_infoline("Test setting the blend mode to off with opaque color and Advanced Blend Equation.");
1175 if(Dali::Capabilities::IsBlendEquationSupported(DevelBlendEquation::SCREEN))
1177 Geometry geometry = CreateQuadGeometry();
1178 Shader shader = CreateShader();
1179 Renderer renderer = Renderer::New(geometry, shader);
1181 Actor actor = Actor::New();
1182 actor.SetProperty(Actor::Property::OPACITY, 1.0f);
1183 actor.AddRenderer(renderer);
1184 actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
1185 application.GetScene().Add(actor);
1187 renderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::OFF);
1188 renderer.SetProperty(Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA, true);
1189 renderer.SetProperty(DevelRenderer::Property::BLEND_EQUATION, DevelBlendEquation::SCREEN);
1191 TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
1192 glAbstraction.EnableEnableDisableCallTrace(true);
1194 application.SendNotification();
1195 application.Render();
1197 TraceCallStack& glEnableStack = glAbstraction.GetEnableDisableTrace();
1198 TraceCallStack::NamedParams params;
1199 params["cap"] << std::hex << GL_BLEND;
1200 DALI_TEST_CHECK(!glEnableStack.FindMethodAndParams("Enable", params));
1206 int UtcDaliRendererSetBlendMode09(void)
1208 TestApplication application;
1210 tet_infoline("Test setting the blend mode to on_without_cull with an opaque color renders with blending enabled");
1212 Geometry geometry = CreateQuadGeometry();
1213 Shader shader = CreateShader();
1214 Renderer renderer = Renderer::New(geometry, shader);
1216 Actor actor = Actor::New();
1217 actor.SetProperty(Actor::Property::OPACITY, 1.0f);
1218 actor.AddRenderer(renderer);
1219 actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
1220 application.GetScene().Add(actor);
1222 renderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::ON_WITHOUT_CULL);
1224 TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
1225 glAbstraction.EnableEnableDisableCallTrace(true);
1227 application.SendNotification();
1228 application.Render();
1230 TraceCallStack& glEnableStack = glAbstraction.GetEnableDisableTrace();
1231 TraceCallStack::NamedParams params;
1232 params["cap"] << std::hex << GL_BLEND;
1233 DALI_TEST_CHECK(glEnableStack.FindMethodAndParams("Enable", params));
1238 int UtcDaliRendererSetBlendMode09b(void)
1240 TestApplication application;
1242 tet_infoline("Test setting the blend mode to on_without_cull with an transparent color renders with blending enabled");
1244 Geometry geometry = CreateQuadGeometry();
1245 Shader shader = CreateShader();
1246 Renderer renderer = Renderer::New(geometry, shader);
1248 Actor actor = Actor::New();
1249 actor.SetProperty(Actor::Property::OPACITY, 0.0f);
1250 actor.AddRenderer(renderer);
1251 actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
1252 application.GetScene().Add(actor);
1254 renderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::ON_WITHOUT_CULL);
1256 TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
1257 glAbstraction.EnableEnableDisableCallTrace(true);
1258 glAbstraction.EnableDrawCallTrace(true);
1260 application.SendNotification();
1261 application.Render();
1263 TraceCallStack& glEnableStack = glAbstraction.GetEnableDisableTrace();
1264 DALI_TEST_CHECK(glEnableStack.FindMethod("Enable"));
1266 DALI_TEST_CHECK(glAbstraction.GetDrawTrace().FindMethod("DrawElements"));
1271 int UtcDaliRendererGetBlendMode(void)
1273 TestApplication application;
1275 tet_infoline("Test GetBlendMode()");
1277 Geometry geometry = CreateQuadGeometry();
1278 Shader shader = Shader::New("vertexSrc", "fragmentSrc");
1279 Renderer renderer = Renderer::New(geometry, shader);
1282 unsigned int mode = renderer.GetProperty<int>(Renderer::Property::BLEND_MODE);
1283 DALI_TEST_EQUALS(static_cast<BlendMode::Type>(mode), BlendMode::AUTO, TEST_LOCATION);
1286 renderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::ON);
1287 mode = renderer.GetProperty<int>(Renderer::Property::BLEND_MODE);
1288 DALI_TEST_EQUALS(static_cast<BlendMode::Type>(mode), BlendMode::ON, TEST_LOCATION);
1291 renderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::OFF);
1292 mode = renderer.GetProperty<int>(Renderer::Property::BLEND_MODE);
1293 DALI_TEST_EQUALS(static_cast<BlendMode::Type>(mode), BlendMode::OFF, TEST_LOCATION);
1296 renderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::ON_WITHOUT_CULL);
1297 mode = renderer.GetProperty<int>(Renderer::Property::BLEND_MODE);
1298 DALI_TEST_EQUALS(static_cast<BlendMode::Type>(mode), BlendMode::ON_WITHOUT_CULL, TEST_LOCATION);
1303 int UtcDaliRendererSetBlendColor(void)
1305 TestApplication application;
1307 tet_infoline("Test SetBlendColor(color)");
1309 Geometry geometry = CreateQuadGeometry();
1310 Shader shader = Shader::New("vertexSrc", "fragmentSrc");
1311 TextureSet textureSet = TextureSet::New();
1312 Texture image = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 50, 50);
1313 textureSet.SetTexture(0u, image);
1314 Renderer renderer = Renderer::New(geometry, shader);
1315 renderer.SetTextures(textureSet);
1317 Actor actor = Actor::New();
1318 actor.AddRenderer(renderer);
1319 actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
1320 application.GetScene().Add(actor);
1322 TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
1324 renderer.SetProperty(Renderer::Property::BLEND_COLOR, Color::TRANSPARENT);
1326 application.SendNotification();
1327 application.Render();
1329 DALI_TEST_EQUALS(renderer.GetProperty<Vector4>(Renderer::Property::BLEND_COLOR), Color::TRANSPARENT, TEST_LOCATION);
1330 DALI_TEST_EQUALS(renderer.GetCurrentProperty<Vector4>(Renderer::Property::BLEND_COLOR), Color::TRANSPARENT, TEST_LOCATION);
1331 DALI_TEST_EQUALS(glAbstraction.GetLastBlendColor(), Color::TRANSPARENT, TEST_LOCATION);
1333 renderer.SetProperty(Renderer::Property::BLEND_COLOR, Color::MAGENTA);
1335 DALI_TEST_EQUALS(renderer.GetProperty<Vector4>(Renderer::Property::BLEND_COLOR), Color::MAGENTA, TEST_LOCATION);
1336 DALI_TEST_EQUALS(renderer.GetCurrentProperty<Vector4>(Renderer::Property::BLEND_COLOR), Color::TRANSPARENT, TEST_LOCATION);
1338 application.SendNotification();
1339 application.Render();
1341 DALI_TEST_EQUALS(renderer.GetCurrentProperty<Vector4>(Renderer::Property::BLEND_COLOR), Color::MAGENTA, TEST_LOCATION);
1342 DALI_TEST_EQUALS(glAbstraction.GetLastBlendColor(), Color::MAGENTA, TEST_LOCATION);
1344 Vector4 color(0.1f, 0.2f, 0.3f, 0.4f);
1345 renderer.SetProperty(Renderer::Property::BLEND_COLOR, color);
1346 application.SendNotification();
1347 application.Render();
1348 DALI_TEST_EQUALS(glAbstraction.GetLastBlendColor(), color, TEST_LOCATION);
1353 int UtcDaliRendererGetBlendColor(void)
1355 TestApplication application;
1357 tet_infoline("Test GetBlendColor()");
1359 Geometry geometry = CreateQuadGeometry();
1360 Shader shader = Shader::New("vertexSrc", "fragmentSrc");
1361 Renderer renderer = Renderer::New(geometry, shader);
1363 DALI_TEST_EQUALS(renderer.GetProperty<Vector4>(Renderer::Property::BLEND_COLOR), Color::TRANSPARENT, TEST_LOCATION);
1365 renderer.SetProperty(Renderer::Property::BLEND_COLOR, Color::MAGENTA);
1366 application.SendNotification();
1367 application.Render();
1368 DALI_TEST_EQUALS(renderer.GetProperty<Vector4>(Renderer::Property::BLEND_COLOR), Color::MAGENTA, TEST_LOCATION);
1370 Vector4 color(0.1f, 0.2f, 0.3f, 0.4f);
1371 renderer.SetProperty(Renderer::Property::BLEND_COLOR, color);
1372 application.SendNotification();
1373 application.Render();
1374 DALI_TEST_EQUALS(renderer.GetProperty<Vector4>(Renderer::Property::BLEND_COLOR), color, TEST_LOCATION);
1379 int UtcDaliRendererPreMultipledAlpha(void)
1381 TestApplication application;
1383 tet_infoline("Test BLEND_PRE_MULTIPLIED_ALPHA property");
1385 Geometry geometry = CreateQuadGeometry();
1386 Shader shader = Shader::New("vertexSrc", "fragmentSrc");
1387 Renderer renderer = Renderer::New(geometry, shader);
1389 Actor actor = Actor::New();
1390 actor.AddRenderer(renderer);
1391 actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
1392 actor.SetProperty(Actor::Property::COLOR, Vector4(1.0f, 0.0f, 1.0f, 0.5f));
1393 application.GetScene().Add(actor);
1395 Property::Value value = renderer.GetProperty(Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA);
1396 bool preMultipliedAlpha;
1397 DALI_TEST_CHECK(value.Get(preMultipliedAlpha));
1398 DALI_TEST_CHECK(!preMultipliedAlpha);
1400 int srcFactorRgb = renderer.GetProperty<int>(Renderer::Property::BLEND_FACTOR_SRC_RGB);
1401 int destFactorRgb = renderer.GetProperty<int>(Renderer::Property::BLEND_FACTOR_DEST_RGB);
1402 int srcFactorAlpha = renderer.GetProperty<int>(Renderer::Property::BLEND_FACTOR_SRC_ALPHA);
1403 int destFactorAlpha = renderer.GetProperty<int>(Renderer::Property::BLEND_FACTOR_DEST_ALPHA);
1405 DALI_TEST_EQUALS((int)DEFAULT_BLEND_FACTOR_SRC_RGB, srcFactorRgb, TEST_LOCATION);
1406 DALI_TEST_EQUALS((int)DEFAULT_BLEND_FACTOR_DEST_RGB, destFactorRgb, TEST_LOCATION);
1407 DALI_TEST_EQUALS((int)DEFAULT_BLEND_FACTOR_SRC_ALPHA, srcFactorAlpha, TEST_LOCATION);
1408 DALI_TEST_EQUALS((int)DEFAULT_BLEND_FACTOR_DEST_ALPHA, destFactorAlpha, TEST_LOCATION);
1410 application.SendNotification();
1411 application.Render();
1413 Vector4 actualValue(Vector4::ZERO);
1414 Vector4 actualActorColor(Vector4::ZERO);
1415 TestGlAbstraction& gl = application.GetGlAbstraction();
1416 DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uColor", actualValue));
1417 DALI_TEST_EQUALS(actualValue, Vector4(1.0f, 0.0f, 1.0f, 0.5f), TEST_LOCATION);
1418 DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uActorColor", actualActorColor));
1419 DALI_TEST_EQUALS(actualActorColor, Vector4(1.0f, 0.0f, 1.0f, 0.5f), TEST_LOCATION);
1421 // Enable pre-multiplied alpha
1422 renderer.SetProperty(Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA, true);
1424 application.SendNotification();
1425 application.Render();
1427 value = renderer.GetProperty(Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA);
1428 DALI_TEST_CHECK(value.Get(preMultipliedAlpha));
1429 DALI_TEST_CHECK(preMultipliedAlpha);
1431 value = renderer.GetCurrentProperty(Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA);
1432 DALI_TEST_CHECK(value.Get(preMultipliedAlpha));
1433 DALI_TEST_CHECK(preMultipliedAlpha);
1435 srcFactorRgb = renderer.GetProperty<int>(Renderer::Property::BLEND_FACTOR_SRC_RGB);
1436 destFactorRgb = renderer.GetProperty<int>(Renderer::Property::BLEND_FACTOR_DEST_RGB);
1437 srcFactorAlpha = renderer.GetProperty<int>(Renderer::Property::BLEND_FACTOR_SRC_ALPHA);
1438 destFactorAlpha = renderer.GetProperty<int>(Renderer::Property::BLEND_FACTOR_DEST_ALPHA);
1440 DALI_TEST_EQUALS((int)BlendFactor::ONE, srcFactorRgb, TEST_LOCATION);
1441 DALI_TEST_EQUALS((int)BlendFactor::ONE_MINUS_SRC_ALPHA, destFactorRgb, TEST_LOCATION);
1442 DALI_TEST_EQUALS((int)BlendFactor::ONE, srcFactorAlpha, TEST_LOCATION);
1443 DALI_TEST_EQUALS((int)BlendFactor::ONE_MINUS_SRC_ALPHA, destFactorAlpha, TEST_LOCATION);
1445 DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uColor", actualValue));
1446 DALI_TEST_EQUALS(actualValue, Vector4(0.5f, 0.0f, 0.5f, 0.5f), TEST_LOCATION);
1447 // Note : uActorColor doesn't premultiplied.
1448 DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uActorColor", actualActorColor));
1449 DALI_TEST_EQUALS(actualActorColor, Vector4(1.0f, 0.0f, 1.0f, 0.5f), TEST_LOCATION);
1451 // Disable pre-multiplied alpha again
1452 renderer.SetProperty(Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA, false);
1454 application.SendNotification();
1455 application.Render();
1457 value = renderer.GetProperty(Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA);
1458 DALI_TEST_CHECK(value.Get(preMultipliedAlpha));
1459 DALI_TEST_CHECK(!preMultipliedAlpha);
1461 value = renderer.GetCurrentProperty(Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA);
1462 DALI_TEST_CHECK(value.Get(preMultipliedAlpha));
1463 DALI_TEST_CHECK(!preMultipliedAlpha);
1465 srcFactorRgb = renderer.GetProperty<int>(Renderer::Property::BLEND_FACTOR_SRC_RGB);
1466 destFactorRgb = renderer.GetProperty<int>(Renderer::Property::BLEND_FACTOR_DEST_RGB);
1467 srcFactorAlpha = renderer.GetProperty<int>(Renderer::Property::BLEND_FACTOR_SRC_ALPHA);
1468 destFactorAlpha = renderer.GetProperty<int>(Renderer::Property::BLEND_FACTOR_DEST_ALPHA);
1470 DALI_TEST_EQUALS((int)BlendFactor::SRC_ALPHA, srcFactorRgb, TEST_LOCATION);
1471 DALI_TEST_EQUALS((int)BlendFactor::ONE_MINUS_SRC_ALPHA, destFactorRgb, TEST_LOCATION);
1472 DALI_TEST_EQUALS((int)BlendFactor::ONE, srcFactorAlpha, TEST_LOCATION);
1473 DALI_TEST_EQUALS((int)BlendFactor::ONE_MINUS_SRC_ALPHA, destFactorAlpha, TEST_LOCATION);
1475 DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uColor", actualValue));
1476 DALI_TEST_EQUALS(actualValue, Vector4(1.0f, 0.0f, 1.0f, 0.5f), TEST_LOCATION);
1477 DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uActorColor", actualActorColor));
1478 DALI_TEST_EQUALS(actualActorColor, Vector4(1.0f, 0.0f, 1.0f, 0.5f), TEST_LOCATION);
1483 int UtcDaliRendererConstraint01(void)
1485 TestApplication application;
1487 tet_infoline("Test that a non-uniform renderer property can be constrained");
1489 Shader shader = Shader::New("VertexSource", "FragmentSource");
1490 Geometry geometry = CreateQuadGeometry();
1491 Renderer renderer = Renderer::New(geometry, shader);
1493 Actor actor = Actor::New();
1494 actor.AddRenderer(renderer);
1495 actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
1496 application.GetScene().Add(actor);
1498 Vector4 initialColor = Color::WHITE;
1499 Property::Index colorIndex = renderer.RegisterProperty("uFadeColor", initialColor);
1501 application.SendNotification();
1502 application.Render(0);
1503 DALI_TEST_EQUALS(renderer.GetProperty<Vector4>(colorIndex), initialColor, TEST_LOCATION);
1506 Constraint constraint = Constraint::New<Vector4>(renderer, colorIndex, TestConstraintNoBlue);
1508 application.SendNotification();
1509 application.Render(0);
1511 // Expect no blue component in either buffer - yellow
1512 DALI_TEST_EQUALS(renderer.GetCurrentProperty<Vector4>(colorIndex), Color::YELLOW, TEST_LOCATION);
1513 application.Render(0);
1514 DALI_TEST_EQUALS(renderer.GetCurrentProperty<Vector4>(colorIndex), Color::YELLOW, TEST_LOCATION);
1516 renderer.RemoveConstraints();
1517 renderer.SetProperty(colorIndex, Color::WHITE);
1518 application.SendNotification();
1519 application.Render(0);
1520 DALI_TEST_EQUALS(renderer.GetCurrentProperty<Vector4>(colorIndex), Color::WHITE, TEST_LOCATION);
1525 int UtcDaliRendererConstraint02(void)
1527 TestApplication application;
1529 tet_infoline("Test that a uniform map renderer property can be constrained");
1531 Shader shader = Shader::New("VertexSource", "FragmentSource");
1532 Geometry geometry = CreateQuadGeometry();
1533 Renderer renderer = Renderer::New(geometry, shader);
1535 Actor actor = Actor::New();
1536 actor.AddRenderer(renderer);
1537 actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
1538 application.GetScene().Add(actor);
1539 application.SendNotification();
1540 application.Render(0);
1542 Vector4 initialColor = Color::WHITE;
1543 Property::Index colorIndex = renderer.RegisterProperty("uFadeColor", initialColor);
1545 TestGlAbstraction& gl = application.GetGlAbstraction();
1547 application.SendNotification();
1548 application.Render(0);
1550 Vector4 actualValue(Vector4::ZERO);
1551 DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uFadeColor", actualValue));
1552 DALI_TEST_EQUALS(actualValue, initialColor, TEST_LOCATION);
1555 Constraint constraint = Constraint::New<Vector4>(renderer, colorIndex, TestConstraintNoBlue);
1557 application.SendNotification();
1558 application.Render(0);
1560 // Expect no blue component in either buffer - yellow
1561 DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uFadeColor", actualValue));
1562 DALI_TEST_EQUALS(actualValue, Color::YELLOW, TEST_LOCATION);
1564 application.Render(0);
1565 DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uFadeColor", actualValue));
1566 DALI_TEST_EQUALS(actualValue, Color::YELLOW, TEST_LOCATION);
1568 renderer.RemoveConstraints();
1569 renderer.SetProperty(colorIndex, Color::WHITE);
1570 application.SendNotification();
1571 application.Render(0);
1573 DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uFadeColor", actualValue));
1574 DALI_TEST_EQUALS(actualValue, Color::WHITE, TEST_LOCATION);
1579 int UtcDaliRendererAnimatedProperty01(void)
1581 TestApplication application;
1583 tet_infoline("Test that a non-uniform renderer property can be animated");
1585 Shader shader = Shader::New("VertexSource", "FragmentSource");
1586 Geometry geometry = CreateQuadGeometry();
1587 Renderer renderer = Renderer::New(geometry, shader);
1589 Actor actor = Actor::New();
1590 actor.AddRenderer(renderer);
1591 actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
1592 application.GetScene().Add(actor);
1594 Vector4 initialColor = Color::WHITE;
1595 Property::Index colorIndex = renderer.RegisterProperty("uFadeColor", initialColor);
1597 application.SendNotification();
1598 application.Render(0);
1599 DALI_TEST_EQUALS(renderer.GetProperty<Vector4>(colorIndex), initialColor, TEST_LOCATION);
1601 Animation animation = Animation::New(1.0f);
1602 KeyFrames keyFrames = KeyFrames::New();
1603 keyFrames.Add(0.0f, initialColor);
1604 keyFrames.Add(1.0f, Color::TRANSPARENT);
1605 animation.AnimateBetween(Property(renderer, colorIndex), keyFrames);
1608 application.SendNotification();
1609 application.Render(500);
1611 DALI_TEST_EQUALS(renderer.GetCurrentProperty<Vector4>(colorIndex), Color::WHITE * 0.5f, TEST_LOCATION);
1613 application.Render(500);
1615 DALI_TEST_EQUALS(renderer.GetCurrentProperty<Vector4>(colorIndex), Color::TRANSPARENT, TEST_LOCATION);
1620 int UtcDaliRendererAnimatedProperty02(void)
1622 TestApplication application;
1624 tet_infoline("Test that a uniform map renderer property can be animated");
1626 Shader shader = Shader::New("VertexSource", "FragmentSource");
1627 Geometry geometry = CreateQuadGeometry();
1628 Renderer renderer = Renderer::New(geometry, shader);
1630 Actor actor = Actor::New();
1631 actor.AddRenderer(renderer);
1632 actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
1633 application.GetScene().Add(actor);
1634 application.SendNotification();
1635 application.Render(0);
1637 Vector4 initialColor = Color::WHITE;
1638 Property::Index colorIndex = renderer.RegisterProperty("uFadeColor", initialColor);
1640 TestGlAbstraction& gl = application.GetGlAbstraction();
1642 application.SendNotification();
1643 application.Render(0);
1645 Vector4 actualValue(Vector4::ZERO);
1646 DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uFadeColor", actualValue));
1647 DALI_TEST_EQUALS(actualValue, initialColor, TEST_LOCATION);
1649 Animation animation = Animation::New(1.0f);
1650 KeyFrames keyFrames = KeyFrames::New();
1651 keyFrames.Add(0.0f, initialColor);
1652 keyFrames.Add(1.0f, Color::TRANSPARENT);
1653 animation.AnimateBetween(Property(renderer, colorIndex), keyFrames);
1656 application.SendNotification();
1657 application.Render(500);
1659 DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uFadeColor", actualValue));
1660 DALI_TEST_EQUALS(actualValue, Color::WHITE * 0.5f, TEST_LOCATION);
1662 application.Render(500);
1663 DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uFadeColor", actualValue));
1664 DALI_TEST_EQUALS(actualValue, Color::TRANSPARENT, TEST_LOCATION);
1669 int UtcDaliRendererUniformMapPrecendence01(void)
1671 TestApplication application;
1673 tet_infoline("Test the uniform map precedence is applied properly");
1675 Texture image = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 64, 64);
1677 Shader shader = Shader::New("VertexSource", "FragmentSource");
1678 TextureSet textureSet = CreateTextureSet(image);
1680 Geometry geometry = CreateQuadGeometry();
1681 Renderer renderer = Renderer::New(geometry, shader);
1682 renderer.SetTextures(textureSet);
1684 Actor actor = Actor::New();
1685 actor.AddRenderer(renderer);
1686 actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
1687 application.GetScene().Add(actor);
1688 application.SendNotification();
1689 application.Render(0);
1691 renderer.RegisterProperty("uFadeColor", Color::RED);
1692 actor.RegisterProperty("uFadeColor", Color::GREEN);
1693 Property::Index shaderFadeColorIndex = shader.RegisterProperty("uFadeColor", Color::MAGENTA);
1695 TestGlAbstraction& gl = application.GetGlAbstraction();
1697 application.SendNotification();
1698 application.Render(0);
1700 // Expect that the actor's fade color property is accessed
1701 Vector4 actualValue(Vector4::ZERO);
1702 DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uFadeColor", actualValue));
1703 DALI_TEST_EQUALS(actualValue, Color::GREEN, TEST_LOCATION);
1705 // Animate shader's fade color property. Should be no change to uniform
1706 Animation animation = Animation::New(1.0f);
1707 KeyFrames keyFrames = KeyFrames::New();
1708 keyFrames.Add(0.0f, Color::WHITE);
1709 keyFrames.Add(1.0f, Color::TRANSPARENT);
1710 animation.AnimateBetween(Property(shader, shaderFadeColorIndex), keyFrames);
1713 application.SendNotification();
1714 application.Render(500);
1716 DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uFadeColor", actualValue));
1717 DALI_TEST_EQUALS(actualValue, Color::GREEN, TEST_LOCATION);
1719 application.Render(500);
1720 DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uFadeColor", actualValue));
1721 DALI_TEST_EQUALS(actualValue, Color::GREEN, TEST_LOCATION);
1726 int UtcDaliRendererUniformMapPrecendence02(void)
1728 TestApplication application;
1730 tet_infoline("Test the uniform map precedence is applied properly");
1732 Texture image = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 64, 64);
1734 Shader shader = Shader::New("VertexSource", "FragmentSource");
1735 TextureSet textureSet = CreateTextureSet(image);
1737 Geometry geometry = CreateQuadGeometry();
1738 Renderer renderer = Renderer::New(geometry, shader);
1739 renderer.SetTextures(textureSet);
1741 Actor actor = Actor::New();
1742 actor.AddRenderer(renderer);
1743 actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
1744 application.GetScene().Add(actor);
1745 application.SendNotification();
1746 application.Render(0);
1748 // Don't add property / uniform map to renderer
1749 actor.RegisterProperty("uFadeColor", Color::GREEN);
1750 Property::Index shaderFadeColorIndex = shader.RegisterProperty("uFadeColor", Color::BLUE);
1752 TestGlAbstraction& gl = application.GetGlAbstraction();
1754 application.SendNotification();
1755 application.Render(0);
1757 // Expect that the actor's fade color property is accessed
1758 Vector4 actualValue(Vector4::ZERO);
1759 DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uFadeColor", actualValue));
1760 DALI_TEST_EQUALS(actualValue, Color::GREEN, TEST_LOCATION);
1762 // Animate texture set's fade color property. Should be no change to uniform
1763 Animation animation = Animation::New(1.0f);
1764 KeyFrames keyFrames = KeyFrames::New();
1765 keyFrames.Add(0.0f, Color::WHITE);
1766 keyFrames.Add(1.0f, Color::TRANSPARENT);
1767 animation.AnimateBetween(Property(shader, shaderFadeColorIndex), keyFrames);
1770 application.SendNotification();
1771 application.Render(500);
1773 DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uFadeColor", actualValue));
1774 DALI_TEST_EQUALS(actualValue, Color::GREEN, TEST_LOCATION);
1776 application.Render(500);
1777 DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uFadeColor", actualValue));
1778 DALI_TEST_EQUALS(actualValue, Color::GREEN, TEST_LOCATION);
1783 int UtcDaliRendererUniformMapPrecendence03(void)
1785 TestApplication application;
1787 tet_infoline("Test the uniform map precedence is applied properly");
1789 Texture image = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 64, 64);
1791 Shader shader = Shader::New("VertexSource", "FragmentSource");
1792 TextureSet textureSet = CreateTextureSet(image);
1794 Geometry geometry = CreateQuadGeometry();
1795 Renderer renderer = Renderer::New(geometry, shader);
1796 renderer.SetTextures(textureSet);
1798 Actor actor = Actor::New();
1799 actor.AddRenderer(renderer);
1800 actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
1801 application.GetScene().Add(actor);
1802 application.SendNotification();
1803 application.Render(0);
1805 // Don't add property / uniform map to renderer or actor
1806 shader.RegisterProperty("uFadeColor", Color::BLACK);
1808 TestGlAbstraction& gl = application.GetGlAbstraction();
1810 application.SendNotification();
1811 application.Render(0);
1813 // Expect that the shader's fade color property is accessed
1814 Vector4 actualValue(Vector4::ZERO);
1815 DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uFadeColor", actualValue));
1816 DALI_TEST_EQUALS(actualValue, Color::BLACK, TEST_LOCATION);
1821 int UtcDaliRendererUniformMapMultipleUniforms01(void)
1823 TestApplication application;
1825 tet_infoline("Test the uniform maps are collected from all objects (same type)");
1827 Texture image = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 64, 64);
1829 Shader shader = Shader::New("VertexSource", "FragmentSource");
1830 TextureSet textureSet = CreateTextureSet(image);
1832 Geometry geometry = CreateQuadGeometry();
1833 Renderer renderer = Renderer::New(geometry, shader);
1834 renderer.SetTextures(textureSet);
1836 Actor actor = Actor::New();
1837 actor.AddRenderer(renderer);
1838 actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
1839 application.GetScene().Add(actor);
1840 application.SendNotification();
1841 application.Render(0);
1843 renderer.RegisterProperty("uUniform1", Color::RED);
1844 actor.RegisterProperty("uUniform2", Color::GREEN);
1845 shader.RegisterProperty("uUniform3", Color::MAGENTA);
1847 TestGlAbstraction& gl = application.GetGlAbstraction();
1849 application.SendNotification();
1850 application.Render(0);
1852 // Expect that each of the object's uniforms are set
1853 Vector4 uniform1Value(Vector4::ZERO);
1854 DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uUniform1", uniform1Value));
1855 DALI_TEST_EQUALS(uniform1Value, Color::RED, TEST_LOCATION);
1857 Vector4 uniform2Value(Vector4::ZERO);
1858 DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uUniform2", uniform2Value));
1859 DALI_TEST_EQUALS(uniform2Value, Color::GREEN, TEST_LOCATION);
1861 Vector4 uniform3Value(Vector4::ZERO);
1862 DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uUniform3", uniform3Value));
1863 DALI_TEST_EQUALS(uniform3Value, Color::MAGENTA, TEST_LOCATION);
1868 int UtcDaliRendererUniformMapMultipleUniforms02(void)
1870 TestApplication application;
1872 tet_infoline("Test the uniform maps are collected from all objects (different types)");
1874 Texture image = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 64, 64);
1876 Shader shader = Shader::New("VertexSource", "FragmentSource");
1877 TextureSet textureSet = CreateTextureSet(image);
1879 Geometry geometry = CreateQuadGeometry();
1880 Renderer renderer = Renderer::New(geometry, shader);
1881 renderer.SetTextures(textureSet);
1883 Actor actor = Actor::New();
1884 actor.AddRenderer(renderer);
1885 actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
1886 application.GetScene().Add(actor);
1887 application.SendNotification();
1888 application.Render(0);
1890 Property::Value value1(Color::RED);
1891 renderer.RegisterProperty("uFadeColor", value1);
1893 Property::Value value2(1.0f);
1894 actor.RegisterProperty("uFadeProgress", value2);
1896 Property::Value value3(Matrix3::IDENTITY);
1897 shader.RegisterProperty("uANormalMatrix", value3);
1899 TestGlAbstraction& gl = application.GetGlAbstraction();
1901 application.SendNotification();
1902 application.Render(0);
1904 // Expect that each of the object's uniforms are set
1905 Vector4 uniform1Value(Vector4::ZERO);
1906 DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uFadeColor", uniform1Value));
1907 DALI_TEST_EQUALS(uniform1Value, value1.Get<Vector4>(), TEST_LOCATION);
1909 float uniform2Value(0.0f);
1910 DALI_TEST_CHECK(gl.GetUniformValue<float>("uFadeProgress", uniform2Value));
1911 DALI_TEST_EQUALS(uniform2Value, value2.Get<float>(), TEST_LOCATION);
1913 Matrix3 uniform3Value;
1914 DALI_TEST_CHECK(gl.GetUniformValue<Matrix3>("uANormalMatrix", uniform3Value));
1915 DALI_TEST_EQUALS(uniform3Value, value3.Get<Matrix3>(), TEST_LOCATION);
1920 int UtcDaliRendererRenderOrder2DLayer(void)
1922 TestApplication application;
1923 tet_infoline("Test the rendering order in a 2D layer is correct");
1925 Shader shader = Shader::New("VertexSource", "FragmentSource");
1926 Geometry geometry = CreateQuadGeometry();
1928 Actor root = application.GetScene().GetRootLayer();
1930 Actor actor0 = CreateActor(root, 0, TEST_LOCATION);
1931 Renderer renderer0 = CreateRenderer(actor0, geometry, shader, 0);
1933 Actor actor1 = CreateActor(root, 0, TEST_LOCATION);
1934 Renderer renderer1 = CreateRenderer(actor1, geometry, shader, 0);
1936 Actor actor2 = CreateActor(root, 0, TEST_LOCATION);
1937 Renderer renderer2 = CreateRenderer(actor2, geometry, shader, 0);
1939 Actor actor3 = CreateActor(root, 0, TEST_LOCATION);
1940 Renderer renderer3 = CreateRenderer(actor3, geometry, shader, 0);
1942 application.SendNotification();
1943 application.Render(0);
1946 * Create the following hierarchy:
1959 * Expected rendering order : actor2 - actor1 - actor0 - actor3
1964 application.SendNotification();
1965 application.Render(0);
1967 TestGlAbstraction& gl = application.GetGlAbstraction();
1968 gl.GetTextureTrace().Reset();
1969 gl.EnableTextureCallTrace(true);
1970 application.SendNotification();
1971 application.Render(0);
1973 int textureBindIndex[4];
1974 for(unsigned int i(0); i < 4; ++i)
1976 std::stringstream params;
1977 params << std::hex << GL_TEXTURE_2D << std::dec << ", " << i + 1;
1978 textureBindIndex[i] = gl.GetTextureTrace().FindIndexFromMethodAndParams("BindTexture", params.str());
1981 //Check that actor1 has been rendered after actor2
1982 DALI_TEST_GREATER(textureBindIndex[1], textureBindIndex[2], TEST_LOCATION);
1984 //Check that actor0 has been rendered after actor1
1985 DALI_TEST_GREATER(textureBindIndex[0], textureBindIndex[1], TEST_LOCATION);
1987 //Check that actor3 has been rendered after actor0
1988 DALI_TEST_GREATER(textureBindIndex[3], textureBindIndex[0], TEST_LOCATION);
1993 int UtcDaliRendererRenderOrder2DLayerMultipleRenderers(void)
1995 TestApplication application;
1996 tet_infoline("Test the rendering order in a 2D layer is correct using multiple renderers per actor");
1999 * Creates the following hierarchy:
2001 * actor0------------------------>actor1
2005 * renderer0 renderer1 renderer2 renderer3 renderer4 renderer5
2007 * renderer0 has depth index 2
2008 * renderer1 has depth index 0
2009 * renderer2 has depth index 1
2011 * renderer3 has depth index 1
2012 * renderer4 has depth index 0
2013 * renderer5 has depth index -1
2015 * Expected rendering order: renderer1 - renderer2 - renderer0 - renderer5 - renderer4 - renderer3
2018 Shader shader = Shader::New("VertexSource", "FragmentSource");
2019 Geometry geometry = CreateQuadGeometry();
2021 Actor root = application.GetScene().GetRootLayer();
2023 Actor actor0 = CreateActor(root, 0, TEST_LOCATION);
2024 Actor actor1 = CreateActor(actor0, 0, TEST_LOCATION);
2025 Renderer renderer0 = CreateRenderer(actor0, geometry, shader, 2);
2026 Renderer renderer1 = CreateRenderer(actor0, geometry, shader, 0);
2027 Renderer renderer2 = CreateRenderer(actor0, geometry, shader, 1);
2028 Renderer renderer3 = CreateRenderer(actor1, geometry, shader, 1);
2029 Renderer renderer4 = CreateRenderer(actor1, geometry, shader, 0);
2030 Renderer renderer5 = CreateRenderer(actor1, geometry, shader, -1);
2032 application.SendNotification();
2033 application.Render(0);
2035 TestGlAbstraction& gl = application.GetGlAbstraction();
2036 gl.GetTextureTrace().Reset();
2037 gl.EnableTextureCallTrace(true);
2038 application.SendNotification();
2039 application.Render(0);
2041 int textureBindIndex[6];
2042 for(unsigned int i(0); i < 6; ++i)
2044 std::stringstream params;
2045 params << std::hex << GL_TEXTURE_2D << std::dec << ", " << i + 1;
2046 textureBindIndex[i] = gl.GetTextureTrace().FindIndexFromMethodAndParams("BindTexture", params.str());
2049 //Check that renderer3 has been rendered after renderer4
2050 DALI_TEST_GREATER(textureBindIndex[3], textureBindIndex[4], TEST_LOCATION);
2052 //Check that renderer0 has been rendered after renderer2
2053 DALI_TEST_GREATER(textureBindIndex[4], textureBindIndex[5], TEST_LOCATION);
2055 //Check that renderer5 has been rendered after renderer2
2056 DALI_TEST_GREATER(textureBindIndex[5], textureBindIndex[0], TEST_LOCATION);
2058 //Check that renderer0 has been rendered after renderer2
2059 DALI_TEST_GREATER(textureBindIndex[0], textureBindIndex[2], TEST_LOCATION);
2061 //Check that renderer2 has been rendered after renderer1
2062 DALI_TEST_GREATER(textureBindIndex[2], textureBindIndex[1], TEST_LOCATION);
2067 int UtcDaliRendererRenderOrder2DLayerSiblingOrder(void)
2069 TestApplication application;
2070 tet_infoline("Test the rendering order in a 2D layer is correct using sibling order");
2073 * Creates the following hierarchy:
2081 * actor0 (SIBLING_ORDER:1) actor1 (SIBLING_ORDER:0)
2085 * renderer0 renderer1 actor2 renderer2 renderer3 renderer4
2086 * DI:2 DI:0 | DI:0 DI:1 DI:2
2091 * actor0 has sibling order 1
2092 * actor1 has sibling order 0
2093 * actor2 has sibling order 0
2095 * renderer0 has depth index 2
2096 * renderer1 has depth index 0
2098 * renderer2 has depth index 0
2099 * renderer3 has depth index 1
2100 * renderer4 has depth index 2
2102 * renderer5 has depth index -1
2104 * Expected rendering order: renderer2 - renderer3 - renderer4 - renderer1 - renderer0 - renderer5
2107 Shader shader = Shader::New("VertexSource", "FragmentSource");
2108 Geometry geometry = CreateQuadGeometry();
2109 Actor root = application.GetScene().GetRootLayer();
2110 Actor actor0 = CreateActor(root, 1, TEST_LOCATION);
2111 Actor actor1 = CreateActor(root, 0, TEST_LOCATION);
2112 Actor actor2 = CreateActor(actor0, 0, TEST_LOCATION);
2114 Renderer renderer0 = CreateRenderer(actor0, geometry, shader, 2);
2115 Renderer renderer1 = CreateRenderer(actor0, geometry, shader, 0);
2116 Renderer renderer2 = CreateRenderer(actor1, geometry, shader, 0);
2117 Renderer renderer3 = CreateRenderer(actor1, geometry, shader, 1);
2118 Renderer renderer4 = CreateRenderer(actor1, geometry, shader, 2);
2119 Renderer renderer5 = CreateRenderer(actor2, geometry, shader, -1);
2121 application.SendNotification();
2122 application.Render();
2124 TestGlAbstraction& gl = application.GetGlAbstraction();
2125 gl.GetTextureTrace().Reset();
2126 gl.EnableTextureCallTrace(true);
2127 application.SendNotification();
2128 application.Render(0);
2130 int textureBindIndex[6];
2131 for(unsigned int i(0); i < 6; ++i)
2133 std::stringstream params;
2134 params << std::hex << GL_TEXTURE_2D << std::dec << ", " << i + 1;
2135 textureBindIndex[i] = gl.GetTextureTrace().FindIndexFromMethodAndParams("BindTexture", params.str());
2138 DALI_TEST_EQUALS(textureBindIndex[2], 0, TEST_LOCATION);
2139 DALI_TEST_EQUALS(textureBindIndex[3], 1, TEST_LOCATION);
2140 DALI_TEST_EQUALS(textureBindIndex[4], 2, TEST_LOCATION);
2141 DALI_TEST_EQUALS(textureBindIndex[1], 3, TEST_LOCATION);
2142 DALI_TEST_EQUALS(textureBindIndex[0], 4, TEST_LOCATION);
2143 DALI_TEST_EQUALS(textureBindIndex[5], 5, TEST_LOCATION);
2145 // Change sibling order of actor1
2146 // New Expected rendering order: renderer1 - renderer0 - renderer 5 - renderer2 - renderer3 - renderer4
2147 actor1.SetProperty(Dali::DevelActor::Property::SIBLING_ORDER, 2);
2149 gl.GetTextureTrace().Reset();
2150 application.SendNotification();
2151 application.Render(0);
2153 for(unsigned int i(0); i < 6; ++i)
2155 std::stringstream params;
2156 params << std::hex << GL_TEXTURE_2D << std::dec << ", " << i + 1;
2157 textureBindIndex[i] = gl.GetTextureTrace().FindIndexFromMethodAndParams("BindTexture", params.str());
2160 DALI_TEST_EQUALS(textureBindIndex[1], 0, TEST_LOCATION);
2161 DALI_TEST_EQUALS(textureBindIndex[0], 1, TEST_LOCATION);
2162 DALI_TEST_EQUALS(textureBindIndex[5], 2, TEST_LOCATION);
2163 DALI_TEST_EQUALS(textureBindIndex[2], 3, TEST_LOCATION);
2164 DALI_TEST_EQUALS(textureBindIndex[3], 4, TEST_LOCATION);
2165 DALI_TEST_EQUALS(textureBindIndex[4], 5, TEST_LOCATION);
2170 int UtcDaliRendererRenderOrder2DLayerOverlay(void)
2172 TestApplication application;
2173 tet_infoline("Test the rendering order in a 2D layer is correct for overlays");
2175 Shader shader = Shader::New("VertexSource", "FragmentSource");
2176 Geometry geometry = CreateQuadGeometry();
2177 Actor root = application.GetScene().GetRootLayer();
2180 * Create the following hierarchy:
2187 * (Overlay) (Regular actor)
2197 * Expected rendering order : actor2 - actor4 - actor1 - actor0 - actor3
2200 Actor actor0 = CreateActor(root, 0, TEST_LOCATION);
2201 actor0.SetProperty(Actor::Property::DRAW_MODE, DrawMode::OVERLAY_2D);
2202 Renderer renderer0 = CreateRenderer(actor0, geometry, shader, 0);
2204 Actor actor1 = CreateActor(root, 0, TEST_LOCATION);
2205 actor1.SetProperty(Actor::Property::DRAW_MODE, DrawMode::OVERLAY_2D);
2206 Renderer renderer1 = CreateRenderer(actor1, geometry, shader, 0);
2208 Actor actor2 = CreateActor(root, 0, TEST_LOCATION);
2209 Renderer renderer2 = CreateRenderer(actor2, geometry, shader, 0);
2211 Actor actor3 = CreateActor(root, 0, TEST_LOCATION);
2212 actor3.SetProperty(Actor::Property::DRAW_MODE, DrawMode::OVERLAY_2D);
2213 Renderer renderer3 = CreateRenderer(actor3, geometry, shader, 0);
2215 Actor actor4 = CreateActor(root, 0, TEST_LOCATION);
2216 Renderer renderer4 = CreateRenderer(actor4, geometry, shader, 0);
2218 application.SendNotification();
2219 application.Render(0);
2226 TestGlAbstraction& gl = application.GetGlAbstraction();
2227 gl.GetTextureTrace().Reset();
2228 gl.EnableTextureCallTrace(true);
2229 application.SendNotification();
2230 application.Render(0);
2232 int textureBindIndex[5];
2233 for(unsigned int i(0); i < 5; ++i)
2235 std::stringstream params;
2236 params << std::hex << GL_TEXTURE_2D << std::dec << ", " << i + 1;
2237 textureBindIndex[i] = gl.GetTextureTrace().FindIndexFromMethodAndParams("BindTexture", params.str());
2240 //Check that actor4 has been rendered after actor2
2241 DALI_TEST_GREATER(textureBindIndex[4], textureBindIndex[2], TEST_LOCATION);
2243 //Check that actor1 has been rendered after actor4
2244 DALI_TEST_GREATER(textureBindIndex[1], textureBindIndex[4], TEST_LOCATION);
2246 //Check that actor0 has been rendered after actor1
2247 DALI_TEST_GREATER(textureBindIndex[0], textureBindIndex[1], TEST_LOCATION);
2249 //Check that actor3 has been rendered after actor0
2250 DALI_TEST_GREATER(textureBindIndex[3], textureBindIndex[0], TEST_LOCATION);
2255 int UtcDaliRendererSetIndexRange(void)
2259 "attribute vec2 aPosition;\n"
2262 " gl_Position = aPosition;\n"
2267 " gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0)\n"
2270 TestApplication application;
2271 tet_infoline("Test setting the range of indices to draw");
2273 TestGlAbstraction& gl = application.GetGlAbstraction();
2274 gl.EnableDrawCallTrace(true);
2276 Actor actor = Actor::New();
2277 actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
2280 Geometry geometry = Geometry::New();
2281 geometry.SetType(Geometry::LINE_LOOP);
2283 // --------------------------------------------------------------------------
2285 unsigned short indices[] = {0, 2, 4, 6, 8, // offset = 0, count = 5
2295 9, // offset = 5, count = 10
2301 1}; // offset = 15, count = 6 // line strip
2303 // --------------------------------------------------------------------------
2312 {Vector2(0.0f, 1.00f)},
2313 {Vector2(0.0f, -1.00f)},
2314 {Vector2(-0.95f, 0.31f)},
2315 {Vector2(0.59f, 0.81f)},
2316 {Vector2(-0.59f, -0.81f)},
2317 {Vector2(-0.95f, -0.31f)},
2318 {Vector2(0.59f, -0.81f)},
2319 {Vector2(0.95f, -0.31f)},
2320 {Vector2(0.95f, 0.31f)},
2321 {Vector2(-0.59f, 0.81f)},
2323 Property::Map vertexFormat;
2324 vertexFormat["aPosition"] = Property::VECTOR2;
2325 VertexBuffer vertexBuffer = VertexBuffer::New(vertexFormat);
2326 vertexBuffer.SetData(shapes, sizeof(shapes) / sizeof(shapes[0]));
2328 // --------------------------------------------------------------------------
2329 geometry.SetIndexBuffer(indices, sizeof(indices) / sizeof(indices[0]));
2330 geometry.AddVertexBuffer(vertexBuffer);
2333 Shader shader = Shader::New(vertexShader, fragmentShader);
2334 Renderer renderer = Renderer::New(geometry, shader);
2335 actor.AddRenderer(renderer);
2337 Integration::Scene scene = application.GetScene();
2342 // LINE_LOOP, first 0, count 5
2344 renderer.SetIndexRange(0, 5);
2345 application.SendNotification();
2346 application.Render();
2348 Property::Value value = renderer.GetProperty(Renderer::Property::INDEX_RANGE_FIRST);
2350 DALI_TEST_CHECK(value.Get(convertedValue));
2351 DALI_TEST_CHECK(convertedValue == 0);
2353 value = renderer.GetCurrentProperty(Renderer::Property::INDEX_RANGE_FIRST);
2354 DALI_TEST_CHECK(value.Get(convertedValue));
2355 DALI_TEST_CHECK(convertedValue == 0);
2357 value = renderer.GetProperty(Renderer::Property::INDEX_RANGE_COUNT);
2358 DALI_TEST_CHECK(value.Get(convertedValue));
2359 DALI_TEST_CHECK(convertedValue == 5);
2361 value = renderer.GetCurrentProperty(Renderer::Property::INDEX_RANGE_COUNT);
2362 DALI_TEST_CHECK(value.Get(convertedValue));
2363 DALI_TEST_CHECK(convertedValue == 5);
2365 sprintf(buffer, "%u, 5, %u, indices", GL_LINE_LOOP, GL_UNSIGNED_SHORT);
2366 bool result = gl.GetDrawTrace().FindMethodAndParams("DrawElements", buffer);
2367 DALI_TEST_CHECK(result);
2370 // LINE_LOOP, first 5, count 10
2372 renderer.SetIndexRange(5, 10);
2373 sprintf(buffer, "%u, 10, %u, indices", GL_LINE_LOOP, GL_UNSIGNED_SHORT);
2374 application.SendNotification();
2375 application.Render();
2376 bool result = gl.GetDrawTrace().FindMethodAndParams("DrawElements", buffer);
2377 DALI_TEST_CHECK(result);
2380 // LINE_STRIP, first 15, count 6
2382 renderer.SetIndexRange(15, 6);
2383 geometry.SetType(Geometry::LINE_STRIP);
2384 sprintf(buffer, "%u, 6, %u, indices", GL_LINE_STRIP, GL_UNSIGNED_SHORT);
2385 application.SendNotification();
2386 application.Render();
2387 bool result = gl.GetDrawTrace().FindMethodAndParams("DrawElements", buffer);
2388 DALI_TEST_CHECK(result);
2391 // Index out of bounds
2393 renderer.SetIndexRange(15, 30);
2394 geometry.SetType(Geometry::LINE_STRIP);
2395 sprintf(buffer, "%u, 6, %u, indices", GL_LINE_STRIP, GL_UNSIGNED_SHORT);
2396 application.SendNotification();
2397 application.Render();
2398 bool result = gl.GetDrawTrace().FindMethodAndParams("DrawElements", buffer);
2399 DALI_TEST_CHECK(result);
2402 // drawing whole buffer starting from 15 ( last valid primitive )
2404 renderer.SetIndexRange(15, 0);
2405 geometry.SetType(Geometry::LINE_STRIP);
2406 sprintf(buffer, "%u, 6, %u, indices", GL_LINE_STRIP, GL_UNSIGNED_SHORT);
2407 application.SendNotification();
2408 application.Render();
2409 bool result = gl.GetDrawTrace().FindMethodAndParams("DrawElements", buffer);
2410 DALI_TEST_CHECK(result);
2416 int UtcDaliRendererSetDepthFunction(void)
2418 TestApplication application;
2420 tet_infoline("Test setting the depth function");
2422 Geometry geometry = CreateQuadGeometry();
2423 Shader shader = CreateShader();
2424 Renderer renderer = Renderer::New(geometry, shader);
2426 Actor actor = Actor::New();
2427 actor.AddRenderer(renderer);
2428 actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
2429 Integration::Scene scene = application.GetScene();
2430 scene.GetRootLayer().SetProperty(Layer::Property::BEHAVIOR, Layer::LAYER_3D);
2433 TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
2434 TraceCallStack& glEnableDisableStack = glAbstraction.GetEnableDisableTrace();
2435 TraceCallStack& glDepthFunctionStack = glAbstraction.GetDepthFunctionTrace();
2437 glEnableDisableStack.Enable(true);
2438 glDepthFunctionStack.Enable(true);
2439 glEnableDisableStack.EnableLogging(true);
2440 glDepthFunctionStack.EnableLogging(true);
2442 std::ostringstream depthTestStr;
2443 depthTestStr << std::hex << GL_DEPTH_TEST;
2447 renderer.SetProperty(Renderer::Property::DEPTH_FUNCTION, DepthFunction::NEVER);
2449 glEnableDisableStack.Reset();
2450 glDepthFunctionStack.Reset();
2451 application.SendNotification();
2452 application.Render();
2454 DALI_TEST_CHECK(glEnableDisableStack.FindMethodAndParams("Enable", depthTestStr.str().c_str()));
2455 std::ostringstream depthFunctionStr;
2456 depthFunctionStr << std::hex << GL_NEVER;
2457 DALI_TEST_CHECK(glDepthFunctionStack.FindMethodAndParams("DepthFunc", depthFunctionStr.str().c_str()));
2462 renderer.SetProperty(Renderer::Property::DEPTH_FUNCTION, DepthFunction::ALWAYS);
2464 glDepthFunctionStack.Reset();
2465 application.SendNotification();
2466 application.Render();
2468 std::ostringstream depthFunctionStr;
2469 depthFunctionStr << std::hex << GL_ALWAYS;
2470 DALI_TEST_CHECK(glDepthFunctionStack.FindMethodAndParams("DepthFunc", depthFunctionStr.str().c_str()));
2475 renderer.SetProperty(Renderer::Property::DEPTH_FUNCTION, DepthFunction::LESS);
2477 glDepthFunctionStack.Reset();
2478 application.SendNotification();
2479 application.Render();
2481 std::ostringstream depthFunctionStr;
2482 depthFunctionStr << std::hex << GL_LESS;
2483 DALI_TEST_CHECK(glDepthFunctionStack.FindMethodAndParams("DepthFunc", depthFunctionStr.str().c_str()));
2488 renderer.SetProperty(Renderer::Property::DEPTH_FUNCTION, DepthFunction::GREATER);
2490 glDepthFunctionStack.Reset();
2491 application.SendNotification();
2492 application.Render();
2494 std::ostringstream depthFunctionStr;
2495 depthFunctionStr << std::hex << GL_GREATER;
2496 DALI_TEST_CHECK(glDepthFunctionStack.FindMethodAndParams("DepthFunc", depthFunctionStr.str().c_str()));
2501 renderer.SetProperty(Renderer::Property::DEPTH_FUNCTION, DepthFunction::EQUAL);
2503 glDepthFunctionStack.Reset();
2504 application.SendNotification();
2505 application.Render();
2507 std::ostringstream depthFunctionStr;
2508 depthFunctionStr << std::hex << GL_EQUAL;
2509 DALI_TEST_CHECK(glDepthFunctionStack.FindMethodAndParams("DepthFunc", depthFunctionStr.str().c_str()));
2514 renderer.SetProperty(Renderer::Property::DEPTH_FUNCTION, DepthFunction::NOT_EQUAL);
2516 glDepthFunctionStack.Reset();
2517 application.SendNotification();
2518 application.Render();
2520 std::ostringstream depthFunctionStr;
2521 depthFunctionStr << std::hex << GL_NOTEQUAL;
2522 DALI_TEST_CHECK(glDepthFunctionStack.FindMethodAndParams("DepthFunc", depthFunctionStr.str().c_str()));
2527 renderer.SetProperty(Renderer::Property::DEPTH_FUNCTION, DepthFunction::LESS_EQUAL);
2529 glDepthFunctionStack.Reset();
2530 application.SendNotification();
2531 application.Render();
2533 std::ostringstream depthFunctionStr;
2534 depthFunctionStr << std::hex << GL_LEQUAL;
2535 DALI_TEST_CHECK(glDepthFunctionStack.FindMethodAndParams("DepthFunc", depthFunctionStr.str().c_str()));
2540 renderer.SetProperty(Renderer::Property::DEPTH_FUNCTION, DepthFunction::GREATER_EQUAL);
2542 glDepthFunctionStack.Reset();
2543 application.SendNotification();
2544 application.Render();
2546 std::ostringstream depthFunctionStr;
2547 depthFunctionStr << std::hex << GL_GEQUAL;
2548 DALI_TEST_CHECK(glDepthFunctionStack.FindMethodAndParams("DepthFunc", depthFunctionStr.str().c_str()));
2555 * @brief This templatized function checks an enumeration property is setting and getting correctly.
2556 * The checks performed are as follows:
2557 * - Check the initial/default value.
2558 * - Set a different value via enum.
2559 * - Check it was set.
2560 * - Set a different value via string.
2561 * - Check it was set.
2563 template<typename T>
2564 void CheckEnumerationProperty(TestApplication& application, Renderer& renderer, Property::Index propertyIndex, T initialValue, T firstCheckEnumeration, T secondCheckEnumeration, std::string secondCheckString)
2566 application.SendNotification();
2567 application.Render();
2569 DALI_TEST_CHECK(renderer.GetProperty<int>(propertyIndex) == static_cast<int>(initialValue));
2570 DALI_TEST_CHECK(renderer.GetCurrentProperty<int>(propertyIndex) == static_cast<int>(initialValue));
2571 renderer.SetProperty(propertyIndex, firstCheckEnumeration);
2572 DALI_TEST_CHECK(renderer.GetProperty<int>(propertyIndex) == static_cast<int>(firstCheckEnumeration));
2573 DALI_TEST_CHECK(renderer.GetCurrentProperty<int>(propertyIndex) != static_cast<int>(firstCheckEnumeration));
2575 application.SendNotification();
2576 application.Render();
2578 DALI_TEST_CHECK(renderer.GetProperty<int>(propertyIndex) == static_cast<int>(firstCheckEnumeration));
2579 DALI_TEST_CHECK(renderer.GetCurrentProperty<int>(propertyIndex) == static_cast<int>(firstCheckEnumeration));
2581 renderer.SetProperty(propertyIndex, secondCheckString);
2582 DALI_TEST_CHECK(renderer.GetProperty<int>(propertyIndex) == static_cast<int>(secondCheckEnumeration));
2583 DALI_TEST_CHECK(renderer.GetCurrentProperty<int>(propertyIndex) != static_cast<int>(secondCheckEnumeration));
2585 application.SendNotification();
2586 application.Render();
2588 DALI_TEST_CHECK(renderer.GetProperty<int>(propertyIndex) == static_cast<int>(secondCheckEnumeration));
2589 DALI_TEST_CHECK(renderer.GetCurrentProperty<int>(propertyIndex) == static_cast<int>(secondCheckEnumeration));
2592 int UtcDaliRendererEnumProperties(void)
2594 TestApplication application;
2595 tet_infoline("Test Renderer enumeration properties can be set with both integer and string values");
2597 Geometry geometry = CreateQuadGeometry();
2598 Shader shader = CreateShader();
2599 Renderer renderer = Renderer::New(geometry, shader);
2601 Actor actor = Actor::New();
2602 actor.AddRenderer(renderer);
2603 actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
2604 application.GetScene().Add(actor);
2607 * Here we use a templatized function to perform several checks on each enumeration property.
2608 * @see CheckEnumerationProperty for details of the checks performed.
2611 CheckEnumerationProperty<FaceCullingMode::Type>(application, renderer, Renderer::Property::FACE_CULLING_MODE, FaceCullingMode::NONE, FaceCullingMode::FRONT, FaceCullingMode::BACK, "BACK");
2612 CheckEnumerationProperty<BlendMode::Type>(application, renderer, Renderer::Property::BLEND_MODE, BlendMode::AUTO, BlendMode::OFF, BlendMode::ON, "ON");
2613 CheckEnumerationProperty<BlendEquation::Type>(application, renderer, Renderer::Property::BLEND_EQUATION_RGB, BlendEquation::ADD, BlendEquation::SUBTRACT, BlendEquation::REVERSE_SUBTRACT, "REVERSE_SUBTRACT");
2614 CheckEnumerationProperty<BlendEquation::Type>(application, renderer, Renderer::Property::BLEND_EQUATION_ALPHA, BlendEquation::ADD, BlendEquation::SUBTRACT, BlendEquation::REVERSE_SUBTRACT, "REVERSE_SUBTRACT");
2615 CheckEnumerationProperty<BlendFactor::Type>(application, renderer, Renderer::Property::BLEND_FACTOR_SRC_RGB, BlendFactor::SRC_ALPHA, BlendFactor::ONE, BlendFactor::SRC_COLOR, "SRC_COLOR");
2616 CheckEnumerationProperty<BlendFactor::Type>(application, renderer, Renderer::Property::BLEND_FACTOR_DEST_RGB, BlendFactor::ONE_MINUS_SRC_ALPHA, BlendFactor::ONE, BlendFactor::SRC_COLOR, "SRC_COLOR");
2617 CheckEnumerationProperty<BlendFactor::Type>(application, renderer, Renderer::Property::BLEND_FACTOR_SRC_ALPHA, BlendFactor::ONE, BlendFactor::ONE_MINUS_SRC_ALPHA, BlendFactor::SRC_COLOR, "SRC_COLOR");
2618 CheckEnumerationProperty<BlendFactor::Type>(application, renderer, Renderer::Property::BLEND_FACTOR_DEST_ALPHA, BlendFactor::ONE_MINUS_SRC_ALPHA, BlendFactor::ONE, BlendFactor::SRC_COLOR, "SRC_COLOR");
2619 CheckEnumerationProperty<DepthWriteMode::Type>(application, renderer, Renderer::Property::DEPTH_WRITE_MODE, DepthWriteMode::AUTO, DepthWriteMode::OFF, DepthWriteMode::ON, "ON");
2620 CheckEnumerationProperty<DepthFunction::Type>(application, renderer, Renderer::Property::DEPTH_FUNCTION, DepthFunction::LESS, DepthFunction::ALWAYS, DepthFunction::GREATER, "GREATER");
2621 CheckEnumerationProperty<DepthTestMode::Type>(application, renderer, Renderer::Property::DEPTH_TEST_MODE, DepthTestMode::AUTO, DepthTestMode::OFF, DepthTestMode::ON, "ON");
2622 CheckEnumerationProperty<StencilFunction::Type>(application, renderer, Renderer::Property::STENCIL_FUNCTION, StencilFunction::ALWAYS, StencilFunction::LESS, StencilFunction::EQUAL, "EQUAL");
2623 CheckEnumerationProperty<RenderMode::Type>(application, renderer, Renderer::Property::RENDER_MODE, RenderMode::AUTO, RenderMode::NONE, RenderMode::STENCIL, "STENCIL");
2624 CheckEnumerationProperty<StencilOperation::Type>(application, renderer, Renderer::Property::STENCIL_OPERATION_ON_FAIL, StencilOperation::KEEP, StencilOperation::REPLACE, StencilOperation::INCREMENT, "INCREMENT");
2625 CheckEnumerationProperty<StencilOperation::Type>(application, renderer, Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL, StencilOperation::KEEP, StencilOperation::REPLACE, StencilOperation::INCREMENT, "INCREMENT");
2626 CheckEnumerationProperty<StencilOperation::Type>(application, renderer, Renderer::Property::STENCIL_OPERATION_ON_Z_PASS, StencilOperation::KEEP, StencilOperation::REPLACE, StencilOperation::INCREMENT, "INCREMENT");
2628 if(Dali::Capabilities::IsBlendEquationSupported(DevelBlendEquation::MAX) &&
2629 Dali::Capabilities::IsBlendEquationSupported(DevelBlendEquation::MIN))
2631 application.SendNotification();
2632 application.Render();
2633 CheckEnumerationProperty<DevelBlendEquation::Type>(application, renderer, DevelRenderer::Property::BLEND_EQUATION, DevelBlendEquation::REVERSE_SUBTRACT, DevelBlendEquation::MAX, DevelBlendEquation::MIN, "MIN");
2636 if(Dali::Capabilities::IsBlendEquationSupported(DevelBlendEquation::SCREEN))
2638 application.SendNotification();
2639 application.Render();
2640 CheckEnumerationProperty<DevelBlendEquation::Type>(application, renderer, DevelRenderer::Property::BLEND_EQUATION, DevelBlendEquation::MIN, DevelBlendEquation::MULTIPLY, DevelBlendEquation::SCREEN, "SCREEN");
2646 Renderer RendererTestFixture(TestApplication& application)
2648 Geometry geometry = CreateQuadGeometry();
2649 Shader shader = CreateShader();
2650 Renderer renderer = Renderer::New(geometry, shader);
2652 Actor actor = Actor::New();
2653 actor.AddRenderer(renderer);
2654 actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
2655 Integration::Scene scene = application.GetScene();
2656 scene.GetRootLayer().SetProperty(Layer::Property::BEHAVIOR, Layer::LAYER_3D);
2662 int UtcDaliRendererSetDepthTestMode(void)
2664 TestApplication application;
2665 tet_infoline("Test setting the DepthTestMode");
2667 Renderer renderer = RendererTestFixture(application);
2668 TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
2669 TraceCallStack& glEnableDisableStack = glAbstraction.GetEnableDisableTrace();
2670 glEnableDisableStack.Enable(true);
2671 glEnableDisableStack.EnableLogging(true);
2673 glEnableDisableStack.Reset();
2674 application.SendNotification();
2675 application.Render();
2677 // Check depth-test is enabled by default.
2678 DALI_TEST_CHECK(glEnableDisableStack.FindMethodAndParams("Enable", GetDepthTestString()));
2679 DALI_TEST_CHECK(!glEnableDisableStack.FindMethodAndParams("Disable", GetDepthTestString()));
2681 // Turn off depth-testing. We want to check if the depth buffer has been disabled, so we need to turn off depth-write as well for this case.
2682 renderer.SetProperty(Renderer::Property::DEPTH_TEST_MODE, DepthTestMode::OFF);
2683 renderer.SetProperty(Renderer::Property::DEPTH_WRITE_MODE, DepthWriteMode::OFF);
2685 glEnableDisableStack.Reset();
2686 application.SendNotification();
2687 application.Render();
2689 // Check the depth buffer was disabled.
2690 DALI_TEST_CHECK(glEnableDisableStack.FindMethodAndParams("Disable", GetDepthTestString()));
2692 // Turn on automatic mode depth-testing.
2693 // Layer behavior is currently set to LAYER_3D so AUTO should enable depth-testing.
2694 renderer.SetProperty(Renderer::Property::DEPTH_TEST_MODE, DepthTestMode::AUTO);
2696 glEnableDisableStack.Reset();
2697 application.SendNotification();
2698 application.Render();
2700 // Check depth-test is now enabled.
2701 DALI_TEST_CHECK(glEnableDisableStack.FindMethodAndParams("Enable", GetDepthTestString()));
2702 DALI_TEST_CHECK(!glEnableDisableStack.FindMethodAndParams("Disable", GetDepthTestString()));
2704 // Change the layer behavior to LAYER_UI.
2705 // Note this will also disable depth testing for the layer by default, we test this first.
2706 application.GetScene().GetRootLayer().SetProperty(Layer::Property::BEHAVIOR, Layer::LAYER_UI);
2708 glEnableDisableStack.Reset();
2709 application.SendNotification();
2710 application.Render();
2712 // Check depth-test is disabled.
2713 DALI_TEST_CHECK(glEnableDisableStack.FindMethodAndParams("Disable", GetDepthTestString()));
2715 // Turn the layer depth-test flag back on, and confirm that depth testing is now on.
2716 application.GetScene().GetRootLayer().SetProperty(Layer::Property::DEPTH_TEST, true);
2718 glEnableDisableStack.Reset();
2719 application.SendNotification();
2720 application.Render();
2722 // Check depth-test is *still* disabled.
2723 DALI_TEST_CHECK(glEnableDisableStack.FindMethodAndParams("Enable", GetDepthTestString()));
2728 int UtcDaliRendererSetDepthWriteMode(void)
2730 TestApplication application;
2731 tet_infoline("Test setting the DepthWriteMode");
2733 Renderer renderer = RendererTestFixture(application);
2734 TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
2736 application.SendNotification();
2737 application.Render();
2739 // Check the default depth-write status first.
2740 DALI_TEST_CHECK(glAbstraction.GetLastDepthMask());
2742 // Turn off depth-writing.
2743 renderer.SetProperty(Renderer::Property::DEPTH_WRITE_MODE, DepthWriteMode::OFF);
2745 application.SendNotification();
2746 application.Render();
2748 // Check depth-write is now disabled.
2749 DALI_TEST_CHECK(!glAbstraction.GetLastDepthMask());
2751 // Test the AUTO mode for depth-writing.
2752 // As our renderer is opaque, depth-testing should be enabled.
2753 renderer.SetProperty(Renderer::Property::DEPTH_WRITE_MODE, DepthWriteMode::AUTO);
2755 application.SendNotification();
2756 application.Render();
2758 // Check depth-write is now enabled.
2759 DALI_TEST_CHECK(glAbstraction.GetLastDepthMask());
2761 // Now make the renderer be treated as translucent by enabling blending.
2762 // The AUTO depth-write mode should turn depth-write off in this scenario.
2763 renderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::ON);
2765 application.SendNotification();
2766 application.Render();
2768 // Check depth-write is now disabled.
2769 DALI_TEST_CHECK(!glAbstraction.GetLastDepthMask());
2774 int UtcDaliRendererCheckStencilDefaults(void)
2776 TestApplication application;
2777 tet_infoline("Test the stencil defaults");
2779 Renderer renderer = RendererTestFixture(application);
2780 TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
2781 TraceCallStack& glEnableDisableStack = glAbstraction.GetEnableDisableTrace();
2782 TraceCallStack& glStencilFunctionStack = glAbstraction.GetStencilFunctionTrace();
2783 glEnableDisableStack.Enable(true);
2784 glEnableDisableStack.EnableLogging(true);
2785 glStencilFunctionStack.Enable(true);
2786 glStencilFunctionStack.EnableLogging(true);
2788 ResetDebugAndFlush(application, glEnableDisableStack, glStencilFunctionStack);
2790 // Check the defaults:
2791 DALI_TEST_EQUALS<int>(static_cast<int>(renderer.GetProperty(Renderer::Property::STENCIL_FUNCTION).Get<int>()), static_cast<int>(StencilFunction::ALWAYS), TEST_LOCATION);
2792 DALI_TEST_EQUALS<int>(static_cast<int>(renderer.GetProperty(Renderer::Property::STENCIL_FUNCTION_MASK).Get<int>()), 0xFF, TEST_LOCATION);
2793 DALI_TEST_EQUALS<int>(static_cast<int>(renderer.GetProperty(Renderer::Property::STENCIL_FUNCTION_REFERENCE).Get<int>()), 0x00, TEST_LOCATION);
2794 DALI_TEST_EQUALS<int>(static_cast<int>(renderer.GetProperty(Renderer::Property::STENCIL_MASK).Get<int>()), 0xFF, TEST_LOCATION);
2795 DALI_TEST_EQUALS<int>(static_cast<int>(renderer.GetProperty(Renderer::Property::STENCIL_OPERATION_ON_FAIL).Get<int>()), static_cast<int>(StencilOperation::KEEP), TEST_LOCATION);
2796 DALI_TEST_EQUALS<int>(static_cast<int>(renderer.GetProperty(Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL).Get<int>()), static_cast<int>(StencilOperation::KEEP), TEST_LOCATION);
2797 DALI_TEST_EQUALS<int>(static_cast<int>(renderer.GetProperty(Renderer::Property::STENCIL_OPERATION_ON_Z_PASS).Get<int>()), static_cast<int>(StencilOperation::KEEP), TEST_LOCATION);
2802 int UtcDaliRendererSetRenderModeToUseStencilBuffer(void)
2804 TestApplication application;
2805 tet_infoline("Test setting the RenderMode to use the stencil buffer");
2807 Renderer renderer = RendererTestFixture(application);
2808 TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
2809 TraceCallStack& glEnableDisableStack = glAbstraction.GetEnableDisableTrace();
2810 TraceCallStack& glStencilFunctionStack = glAbstraction.GetStencilFunctionTrace();
2811 glEnableDisableStack.Enable(true);
2812 glEnableDisableStack.EnableLogging(true);
2813 glStencilFunctionStack.Enable(true);
2814 glStencilFunctionStack.EnableLogging(true);
2816 // Set the StencilFunction to something other than the default, to confirm it is set as a property,
2817 // but NO GL call has been made while the RenderMode is set to not use the stencil buffer.
2818 renderer.SetProperty(Renderer::Property::RENDER_MODE, RenderMode::NONE);
2819 ResetDebugAndFlush(application, glEnableDisableStack, glStencilFunctionStack);
2821 renderer.SetProperty(Renderer::Property::STENCIL_FUNCTION, StencilFunction::NEVER);
2822 DALI_TEST_EQUALS<int>(static_cast<int>(renderer.GetProperty(Renderer::Property::STENCIL_FUNCTION).Get<int>()), static_cast<int>(StencilFunction::NEVER), TEST_LOCATION);
2824 ResetDebugAndFlush(application, glEnableDisableStack, glStencilFunctionStack);
2825 std::string methodString("StencilFunc");
2826 DALI_TEST_CHECK(!glStencilFunctionStack.FindMethod(methodString));
2828 // Test the other RenderModes that will not enable the stencil buffer.
2829 renderer.SetProperty(Renderer::Property::RENDER_MODE, RenderMode::AUTO);
2830 ResetDebugAndFlush(application, glEnableDisableStack, glStencilFunctionStack);
2831 DALI_TEST_CHECK(!glStencilFunctionStack.FindMethod(methodString));
2833 renderer.SetProperty(Renderer::Property::RENDER_MODE, RenderMode::COLOR);
2834 ResetDebugAndFlush(application, glEnableDisableStack, glStencilFunctionStack);
2835 DALI_TEST_CHECK(!glStencilFunctionStack.FindMethod(methodString));
2837 // Now set the RenderMode to modes that will use the stencil buffer, and check the StencilFunction has changed.
2838 renderer.SetProperty(Renderer::Property::RENDER_MODE, RenderMode::STENCIL);
2839 ResetDebugAndFlush(application, glEnableDisableStack, glStencilFunctionStack);
2841 DALI_TEST_CHECK(glEnableDisableStack.FindMethodAndParams("Enable", GetStencilTestString()));
2842 DALI_TEST_CHECK(glStencilFunctionStack.FindMethod(methodString));
2844 // Test the COLOR_STENCIL RenderMode as it also enables the stencil buffer.
2845 // First set a mode to turn off the stencil buffer, so the enable is required.
2846 renderer.SetProperty(Renderer::Property::RENDER_MODE, RenderMode::COLOR);
2847 ResetDebugAndFlush(application, glEnableDisableStack, glStencilFunctionStack);
2848 renderer.SetProperty(Renderer::Property::RENDER_MODE, RenderMode::COLOR_STENCIL);
2849 // Set a different stencil function as the last one is cached.
2850 renderer.SetProperty(Renderer::Property::STENCIL_FUNCTION, StencilFunction::ALWAYS);
2851 ResetDebugAndFlush(application, glEnableDisableStack, glStencilFunctionStack);
2853 DALI_TEST_CHECK(glEnableDisableStack.FindMethodAndParams("Enable", GetStencilTestString()));
2854 DALI_TEST_CHECK(glStencilFunctionStack.FindMethod(methodString));
2859 // Helper function for the SetRenderModeToUseColorBuffer test.
2860 void CheckRenderModeColorMask(TestApplication& application, Renderer& renderer, RenderMode::Type renderMode, bool expectedValue)
2862 // Set the RenderMode property to a value that should not allow color buffer writes.
2863 renderer.SetProperty(Renderer::Property::RENDER_MODE, renderMode);
2864 application.SendNotification();
2865 application.Render();
2867 // Check if ColorMask has been called, and that the values are correct.
2868 TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
2869 const TestGlAbstraction::ColorMaskParams& colorMaskParams(glAbstraction.GetColorMaskParams());
2871 DALI_TEST_EQUALS<bool>(colorMaskParams.red, expectedValue, TEST_LOCATION);
2872 DALI_TEST_EQUALS<bool>(colorMaskParams.green, expectedValue, TEST_LOCATION);
2873 DALI_TEST_EQUALS<bool>(colorMaskParams.blue, expectedValue, TEST_LOCATION);
2874 // @todo Only check alpha if framebuffer supports it.
2875 //DALI_TEST_EQUALS<bool>(colorMaskParams.alpha, expectedValue, TEST_LOCATION);
2878 int UtcDaliRendererSetRenderModeToUseColorBuffer(void)
2880 TestApplication application;
2881 tet_infoline("Test setting the RenderMode to use the color buffer");
2883 Renderer renderer = RendererTestFixture(application);
2885 // Set the RenderMode property to a value that should not allow color buffer writes.
2886 // Then check if ColorMask has been called, and that the values are correct.
2887 CheckRenderModeColorMask(application, renderer, RenderMode::AUTO, true);
2888 CheckRenderModeColorMask(application, renderer, RenderMode::NONE, false);
2889 CheckRenderModeColorMask(application, renderer, RenderMode::COLOR, true);
2890 CheckRenderModeColorMask(application, renderer, RenderMode::STENCIL, false);
2891 CheckRenderModeColorMask(application, renderer, RenderMode::COLOR_STENCIL, true);
2896 int UtcDaliRendererSetStencilFunction(void)
2898 TestApplication application;
2899 tet_infoline("Test setting the StencilFunction");
2901 Renderer renderer = RendererTestFixture(application);
2902 TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
2903 TraceCallStack& glEnableDisableStack = glAbstraction.GetEnableDisableTrace();
2904 TraceCallStack& glStencilFunctionStack = glAbstraction.GetStencilFunctionTrace();
2905 glEnableDisableStack.Enable(true);
2906 glEnableDisableStack.EnableLogging(true);
2907 glStencilFunctionStack.Enable(true);
2908 glStencilFunctionStack.EnableLogging(true);
2910 // RenderMode must use the stencil for StencilFunction to operate.
2911 renderer.SetProperty(Renderer::Property::RENDER_MODE, RenderMode::STENCIL);
2912 ResetDebugAndFlush(application, glEnableDisableStack, glStencilFunctionStack);
2915 * Lookup table for testing StencilFunction.
2916 * Note: This MUST be in the same order as the Dali::StencilFunction enum.
2918 const int StencilFunctionLookupTable[] = {
2927 const int StencilFunctionLookupTableCount = sizeof(StencilFunctionLookupTable) / sizeof(StencilFunctionLookupTable[0]);
2930 * Loop through all types of StencilFunction, checking:
2931 * - The value is cached (set in event thread side)
2932 * - Causes "glStencilFunc" to be called
2933 * - Checks the correct parameters to "glStencilFunc" were used
2935 std::string nonChangingParameters = "0, 255";
2936 std::string methodString("StencilFunc");
2937 for(int i = 0; i < StencilFunctionLookupTableCount; ++i)
2939 // Set the property.
2940 renderer.SetProperty(Renderer::Property::STENCIL_FUNCTION, static_cast<Dali::StencilFunction::Type>(i));
2942 // Check GetProperty returns the same value.
2943 DALI_TEST_EQUALS<int>(static_cast<int>(renderer.GetProperty(Renderer::Property::STENCIL_FUNCTION).Get<int>()), i, TEST_LOCATION);
2945 // Reset the trace debug.
2946 ResetDebugAndFlush(application, glEnableDisableStack, glStencilFunctionStack);
2948 // Check the function is called and the parameters are correct.
2949 std::stringstream parameterStream;
2950 parameterStream << StencilFunctionLookupTable[i] << ", " << nonChangingParameters;
2952 DALI_TEST_CHECK(glStencilFunctionStack.FindMethodAndParams(methodString, parameterStream.str()));
2955 // Change the Function Reference only and check the behavior is correct:
2956 // 170 is 0xaa in hex / 10101010 in binary (every other bit set).
2957 int testValueReference = 170;
2958 renderer.SetProperty(Renderer::Property::STENCIL_FUNCTION_REFERENCE, testValueReference);
2960 DALI_TEST_EQUALS<int>(static_cast<int>(renderer.GetProperty(Renderer::Property::STENCIL_FUNCTION_REFERENCE).Get<int>()), testValueReference, TEST_LOCATION);
2962 ResetDebugAndFlush(application, glEnableDisableStack, glStencilFunctionStack);
2964 DALI_TEST_EQUALS<int>(static_cast<int>(renderer.GetCurrentProperty(Renderer::Property::STENCIL_FUNCTION_REFERENCE).Get<int>()), testValueReference, TEST_LOCATION);
2966 std::stringstream parameterStream;
2967 parameterStream << StencilFunctionLookupTable[StencilOperation::DECREMENT_WRAP] << ", " << testValueReference << ", 255";
2969 DALI_TEST_CHECK(glStencilFunctionStack.FindMethodAndParams(methodString, parameterStream.str()));
2971 // Change the Function Mask only and check the behavior is correct:
2972 // 85 is 0x55 in hex / 01010101 in binary (every other bit set).
2973 int testValueMask = 85;
2974 renderer.SetProperty(Renderer::Property::STENCIL_FUNCTION_MASK, testValueMask);
2976 DALI_TEST_EQUALS<int>(static_cast<int>(renderer.GetProperty(Renderer::Property::STENCIL_FUNCTION_MASK).Get<int>()), testValueMask, TEST_LOCATION);
2978 ResetDebugAndFlush(application, glEnableDisableStack, glStencilFunctionStack);
2980 DALI_TEST_EQUALS<int>(static_cast<int>(renderer.GetCurrentProperty(Renderer::Property::STENCIL_FUNCTION_MASK).Get<int>()), testValueMask, TEST_LOCATION);
2982 // Clear the stringstream.
2983 parameterStream.str(std::string());
2984 parameterStream << StencilFunctionLookupTable[StencilOperation::DECREMENT_WRAP] << ", " << testValueReference << ", " << testValueMask;
2986 DALI_TEST_CHECK(glStencilFunctionStack.FindMethodAndParams(methodString, parameterStream.str()));
2991 int UtcDaliRendererSetStencilOperation(void)
2993 TestApplication application;
2994 tet_infoline("Test setting the StencilOperation");
2996 Renderer renderer = RendererTestFixture(application);
2997 TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
2998 TraceCallStack& glEnableDisableStack = glAbstraction.GetEnableDisableTrace();
2999 TraceCallStack& glStencilFunctionStack = glAbstraction.GetStencilFunctionTrace();
3000 glEnableDisableStack.Enable(true);
3001 glEnableDisableStack.EnableLogging(true);
3002 glStencilFunctionStack.Enable(true);
3003 glStencilFunctionStack.EnableLogging(true);
3005 // RenderMode must use the stencil for StencilOperation to operate.
3006 renderer.SetProperty(Renderer::Property::RENDER_MODE, RenderMode::STENCIL);
3009 * Lookup table for testing StencilOperation.
3010 * Note: This MUST be in the same order as the Dali::StencilOperation enum.
3012 const int StencilOperationLookupTable[] = {
3021 const int StencilOperationLookupTableCount = sizeof(StencilOperationLookupTable) / sizeof(StencilOperationLookupTable[0]);
3023 // Set all 3 StencilOperation properties to a default.
3024 renderer.SetProperty(Renderer::Property::STENCIL_OPERATION_ON_FAIL, StencilOperation::KEEP);
3025 renderer.SetProperty(Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL, StencilOperation::ZERO);
3026 renderer.SetProperty(Renderer::Property::STENCIL_OPERATION_ON_Z_PASS, StencilOperation::ZERO);
3028 // Set our expected parameter list to the equivalent result.
3029 int parameters[] = {StencilOperationLookupTable[StencilOperation::ZERO], StencilOperationLookupTable[StencilOperation::ZERO], StencilOperationLookupTable[StencilOperation::ZERO]};
3031 ResetDebugAndFlush(application, glEnableDisableStack, glStencilFunctionStack);
3034 * Loop through all types of StencilOperation, checking:
3035 * - The value is cached (set in event thread side)
3036 * - Causes "glStencilFunc" to be called
3037 * - Checks the correct parameters to "glStencilFunc" were used
3038 * - Checks the above for all 3 parameter placements of StencilOperation ( OnFail, OnZFail, OnPass )
3040 std::string methodString("StencilOp");
3042 for(int i = 0; i < StencilOperationLookupTableCount; ++i)
3044 for(int j = 0; j < StencilOperationLookupTableCount; ++j)
3046 for(int k = 0; k < StencilOperationLookupTableCount; ++k)
3048 // Set the property (outer loop causes all 3 different properties to be set separately).
3049 renderer.SetProperty(Renderer::Property::STENCIL_OPERATION_ON_FAIL, static_cast<Dali::StencilFunction::Type>(i));
3050 renderer.SetProperty(Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL, static_cast<Dali::StencilFunction::Type>(j));
3051 renderer.SetProperty(Renderer::Property::STENCIL_OPERATION_ON_Z_PASS, static_cast<Dali::StencilFunction::Type>(k));
3053 // Check GetProperty returns the same value.
3054 DALI_TEST_EQUALS<int>(static_cast<int>(renderer.GetProperty(Renderer::Property::STENCIL_OPERATION_ON_FAIL).Get<int>()), i, TEST_LOCATION);
3055 DALI_TEST_EQUALS<int>(static_cast<int>(renderer.GetProperty(Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL).Get<int>()), j, TEST_LOCATION);
3056 DALI_TEST_EQUALS<int>(static_cast<int>(renderer.GetProperty(Renderer::Property::STENCIL_OPERATION_ON_Z_PASS).Get<int>()), k, TEST_LOCATION);
3058 // Reset the trace debug.
3059 ResetDebugAndFlush(application, glEnableDisableStack, glStencilFunctionStack);
3061 // Check the function is called and the parameters are correct.
3062 // Set the expected parameter value at its correct index (only)
3063 parameters[0u] = StencilOperationLookupTable[i];
3064 parameters[1u] = StencilOperationLookupTable[j];
3065 parameters[2u] = StencilOperationLookupTable[k];
3067 // Build the parameter list.
3068 std::stringstream parameterStream;
3069 for(int parameterBuild = 0; parameterBuild < 3; ++parameterBuild)
3071 parameterStream << parameters[parameterBuild];
3072 // Comma-separate the parameters.
3073 if(parameterBuild < 2)
3075 parameterStream << ", ";
3079 // Check the function was called and the parameters were correct.
3080 DALI_TEST_CHECK(glStencilFunctionStack.FindMethodAndParams(methodString, parameterStream.str()));
3088 int UtcDaliRendererSetStencilMask(void)
3090 TestApplication application;
3091 tet_infoline("Test setting the StencilMask");
3093 Renderer renderer = RendererTestFixture(application);
3094 TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
3095 TraceCallStack& glEnableDisableStack = glAbstraction.GetEnableDisableTrace();
3096 TraceCallStack& glStencilFunctionStack = glAbstraction.GetStencilFunctionTrace();
3097 glEnableDisableStack.Enable(true);
3098 glEnableDisableStack.EnableLogging(true);
3099 glStencilFunctionStack.Enable(true);
3100 glStencilFunctionStack.EnableLogging(true);
3102 // RenderMode must use the stencil for StencilMask to operate.
3103 renderer.SetProperty(Renderer::Property::RENDER_MODE, RenderMode::STENCIL);
3105 // Set the StencilMask property to a value.
3106 renderer.SetProperty(Renderer::Property::STENCIL_MASK, 0x00);
3108 // Check GetProperty returns the same value.
3109 DALI_TEST_EQUALS<int>(static_cast<int>(renderer.GetProperty(Renderer::Property::STENCIL_MASK).Get<int>()), 0x00, TEST_LOCATION);
3111 ResetDebugAndFlush(application, glEnableDisableStack, glStencilFunctionStack);
3113 DALI_TEST_EQUALS<int>(static_cast<int>(renderer.GetCurrentProperty(Renderer::Property::STENCIL_MASK).Get<int>()), 0x00, TEST_LOCATION);
3115 std::string methodString("StencilMask");
3116 std::string parameterString = "0";
3118 // Check the function was called and the parameters were correct.
3119 DALI_TEST_CHECK(glStencilFunctionStack.FindMethodAndParams(methodString, parameterString));
3121 // Set the StencilMask property to another value to ensure it has changed.
3122 renderer.SetProperty(Renderer::Property::STENCIL_MASK, 0xFF);
3124 // Check GetProperty returns the same value.
3125 DALI_TEST_EQUALS<int>(static_cast<int>(renderer.GetProperty(Renderer::Property::STENCIL_MASK).Get<int>()), 0xFF, TEST_LOCATION);
3127 ResetDebugAndFlush(application, glEnableDisableStack, glStencilFunctionStack);
3129 DALI_TEST_EQUALS<int>(static_cast<int>(renderer.GetCurrentProperty(Renderer::Property::STENCIL_MASK).Get<int>()), 0xFF, TEST_LOCATION);
3131 parameterString = "255";
3133 // Check the function was called and the parameters were correct.
3134 DALI_TEST_CHECK(glStencilFunctionStack.FindMethodAndParams(methodString, parameterString));
3139 int UtcDaliRendererWrongNumberOfTextures(void)
3141 TestApplication application;
3142 tet_infoline("Test renderer does render even if number of textures is different than active samplers in the shader");
3144 //Create a TextureSet with 4 textures (One more texture in the texture set than active samplers)
3145 //@note Shaders in the test suit have 3 active samplers. See TestGlAbstraction::GetActiveUniform()
3146 Texture texture = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 64u, 64u);
3147 TextureSet textureSet = CreateTextureSet();
3148 textureSet.SetTexture(0, texture);
3149 textureSet.SetTexture(1, texture);
3150 textureSet.SetTexture(2, texture);
3151 textureSet.SetTexture(3, texture);
3152 Shader shader = Shader::New("VertexSource", "FragmentSource");
3153 Geometry geometry = CreateQuadGeometry();
3154 Renderer renderer = Renderer::New(geometry, shader);
3155 renderer.SetTextures(textureSet);
3157 Actor actor = Actor::New();
3158 actor.AddRenderer(renderer);
3159 actor.SetProperty(Actor::Property::POSITION, Vector2(0.0f, 0.0f));
3160 actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
3161 application.GetScene().Add(actor);
3163 TestGlAbstraction& gl = application.GetGlAbstraction();
3164 TraceCallStack& drawTrace = gl.GetDrawTrace();
3166 drawTrace.Enable(true);
3167 drawTrace.EnableLogging(true);
3169 application.SendNotification();
3170 application.Render(0);
3172 //Test we do the drawcall when TextureSet has more textures than there are active samplers in the shader
3173 DALI_TEST_EQUALS(drawTrace.CountMethod("DrawElements"), 1, TEST_LOCATION);
3175 //Create a TextureSet with 1 texture (two more active samplers than texture in the texture set)
3176 //@note Shaders in the test suit have 3 active samplers. See TestGlAbstraction::GetActiveUniform()
3177 textureSet = CreateTextureSet();
3178 renderer.SetTextures(textureSet);
3179 textureSet.SetTexture(0, texture);
3181 application.SendNotification();
3182 application.Render(0);
3184 //Test we do the drawcall when TextureSet has less textures than there are active samplers in the shader.
3185 DALI_TEST_EQUALS(drawTrace.CountMethod("DrawElements"), 1, TEST_LOCATION);
3190 int UtcDaliRendererOpacity(void)
3192 TestApplication application;
3194 tet_infoline("Test OPACITY property");
3196 Geometry geometry = CreateQuadGeometry();
3197 Shader shader = Shader::New("vertexSrc", "fragmentSrc");
3198 Renderer renderer = Renderer::New(geometry, shader);
3200 Actor actor = Actor::New();
3201 actor.AddRenderer(renderer);
3202 actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
3203 actor.SetProperty(Actor::Property::COLOR, Vector4(1.0f, 0.0f, 1.0f, 1.0f));
3204 application.GetScene().Add(actor);
3206 Property::Value value = renderer.GetProperty(DevelRenderer::Property::OPACITY);
3208 DALI_TEST_CHECK(value.Get(opacity));
3209 DALI_TEST_EQUALS(opacity, 1.0f, Dali::Math::MACHINE_EPSILON_1, TEST_LOCATION);
3211 application.SendNotification();
3212 application.Render();
3214 Vector4 actualValue;
3215 Vector4 actualActorColor;
3216 TestGlAbstraction& gl = application.GetGlAbstraction();
3217 DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uColor", actualValue));
3218 DALI_TEST_EQUALS(actualValue.a, 1.0f, Dali::Math::MACHINE_EPSILON_1, TEST_LOCATION);
3219 DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uActorColor", actualActorColor));
3220 DALI_TEST_EQUALS(actualActorColor.a, 1.0f, Dali::Math::MACHINE_EPSILON_1, TEST_LOCATION);
3222 renderer.SetProperty(DevelRenderer::Property::OPACITY, 0.5f);
3224 application.SendNotification();
3225 application.Render();
3227 value = renderer.GetProperty(DevelRenderer::Property::OPACITY);
3228 DALI_TEST_CHECK(value.Get(opacity));
3229 DALI_TEST_EQUALS(opacity, 0.5f, Dali::Math::MACHINE_EPSILON_1, TEST_LOCATION);
3231 value = renderer.GetCurrentProperty(DevelRenderer::Property::OPACITY);
3232 DALI_TEST_CHECK(value.Get(opacity));
3233 DALI_TEST_EQUALS(opacity, 0.5f, Dali::Math::MACHINE_EPSILON_1, TEST_LOCATION);
3235 DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uColor", actualValue));
3236 DALI_TEST_EQUALS(actualValue.a, 0.5f, Dali::Math::MACHINE_EPSILON_1, TEST_LOCATION);
3238 // Note : Renderer opacity doesn't apply to uActorColor.
3239 DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uActorColor", actualActorColor));
3240 DALI_TEST_EQUALS(actualActorColor.a, 1.0f, Dali::Math::MACHINE_EPSILON_1, TEST_LOCATION);
3245 int UtcDaliRendererOpacityAnimation(void)
3247 TestApplication application;
3249 tet_infoline("Test OPACITY property animation");
3251 Geometry geometry = CreateQuadGeometry();
3252 Shader shader = Shader::New("vertexSrc", "fragmentSrc");
3253 Renderer renderer = Renderer::New(geometry, shader);
3255 Actor actor = Actor::New();
3256 actor.AddRenderer(renderer);
3257 actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
3258 actor.SetProperty(Actor::Property::COLOR, Vector4(1.0f, 0.0f, 1.0f, 1.0f));
3259 application.GetScene().Add(actor);
3261 application.SendNotification();
3262 application.Render(0);
3264 Property::Value value = renderer.GetProperty(DevelRenderer::Property::OPACITY);
3266 DALI_TEST_CHECK(value.Get(opacity));
3267 DALI_TEST_EQUALS(opacity, 1.0f, Dali::Math::MACHINE_EPSILON_1, TEST_LOCATION);
3269 Animation animation = Animation::New(1.0f);
3270 animation.AnimateTo(Property(renderer, DevelRenderer::Property::OPACITY), 0.0f);
3273 application.SendNotification();
3274 application.Render(1000);
3276 value = renderer.GetProperty(DevelRenderer::Property::OPACITY);
3277 DALI_TEST_CHECK(value.Get(opacity));
3278 DALI_TEST_EQUALS(opacity, 0.0f, Dali::Math::MACHINE_EPSILON_1, TEST_LOCATION);
3280 // Need to clear the animation before setting the property as the animation value is baked and will override any previous setters
3282 renderer.SetProperty(DevelRenderer::Property::OPACITY, 0.1f);
3284 animation.AnimateBy(Property(renderer, DevelRenderer::Property::OPACITY), 0.5f);
3287 application.SendNotification();
3288 application.Render(1000);
3290 value = renderer.GetProperty(DevelRenderer::Property::OPACITY);
3291 DALI_TEST_CHECK(value.Get(opacity));
3292 DALI_TEST_EQUALS(opacity, 0.6f, Dali::Math::MACHINE_EPSILON_1, TEST_LOCATION);
3293 DALI_TEST_EQUALS(opacity, renderer.GetCurrentProperty(DevelRenderer::Property::OPACITY).Get<float>(), Dali::Math::MACHINE_EPSILON_1, TEST_LOCATION);
3298 int UtcDaliRendererInvalidProperty(void)
3300 TestApplication application;
3302 tet_infoline("Test invalid property");
3304 Geometry geometry = CreateQuadGeometry();
3305 Shader shader = Shader::New("vertexSrc", "fragmentSrc");
3306 Renderer renderer = Renderer::New(geometry, shader);
3308 Actor actor = Actor::New();
3309 actor.AddRenderer(renderer);
3310 actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
3311 application.GetScene().Add(actor);
3313 application.SendNotification();
3314 application.Render(0);
3316 Property::Value value = renderer.GetProperty(Renderer::Property::DEPTH_INDEX + 100);
3317 DALI_TEST_CHECK(value.GetType() == Property::Type::NONE);
3319 value = renderer.GetCurrentProperty(Renderer::Property::DEPTH_INDEX + 100);
3320 DALI_TEST_CHECK(value.GetType() == Property::Type::NONE);
3325 int UtcDaliRendererRenderingBehavior(void)
3327 TestApplication application;
3329 tet_infoline("Test RENDERING_BEHAVIOR property");
3331 Geometry geometry = CreateQuadGeometry();
3332 Shader shader = Shader::New("vertexSrc", "fragmentSrc");
3333 Renderer renderer = Renderer::New(geometry, shader);
3335 Actor actor = Actor::New();
3336 actor.AddRenderer(renderer);
3337 actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
3338 actor.SetProperty(Actor::Property::COLOR, Vector4(1.0f, 0.0f, 1.0f, 1.0f));
3339 application.GetScene().Add(actor);
3341 Property::Value value = renderer.GetProperty(DevelRenderer::Property::RENDERING_BEHAVIOR);
3342 int renderingBehavior;
3343 DALI_TEST_CHECK(value.Get(renderingBehavior));
3344 DALI_TEST_EQUALS(static_cast<DevelRenderer::Rendering::Type>(renderingBehavior), DevelRenderer::Rendering::IF_REQUIRED, TEST_LOCATION);
3346 application.SendNotification();
3347 application.Render();
3349 uint32_t updateStatus = application.GetUpdateStatus();
3351 DALI_TEST_CHECK(!(updateStatus & Integration::KeepUpdating::STAGE_KEEP_RENDERING));
3353 TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
3354 TraceCallStack& drawTrace = glAbstraction.GetDrawTrace();
3355 drawTrace.Enable(true);
3358 renderer.SetProperty(DevelRenderer::Property::RENDERING_BEHAVIOR, DevelRenderer::Rendering::CONTINUOUSLY);
3360 value = renderer.GetProperty(DevelRenderer::Property::RENDERING_BEHAVIOR);
3361 DALI_TEST_CHECK(value.Get(renderingBehavior));
3362 DALI_TEST_EQUALS(static_cast<DevelRenderer::Rendering::Type>(renderingBehavior), DevelRenderer::Rendering::CONTINUOUSLY, TEST_LOCATION);
3364 // Render and check the update status
3365 application.SendNotification();
3366 application.Render();
3368 updateStatus = application.GetUpdateStatus();
3370 DALI_TEST_CHECK(updateStatus & Integration::KeepUpdating::STAGE_KEEP_RENDERING);
3372 value = renderer.GetCurrentProperty(DevelRenderer::Property::RENDERING_BEHAVIOR);
3373 DALI_TEST_CHECK(value.Get(renderingBehavior));
3374 DALI_TEST_EQUALS(static_cast<DevelRenderer::Rendering::Type>(renderingBehavior), DevelRenderer::Rendering::CONTINUOUSLY, TEST_LOCATION);
3376 DALI_TEST_EQUALS(drawTrace.CountMethod("DrawElements"), 1, TEST_LOCATION);
3380 // Render again and check the update status
3381 application.SendNotification();
3382 application.Render();
3384 updateStatus = application.GetUpdateStatus();
3386 DALI_TEST_CHECK(updateStatus & Integration::KeepUpdating::STAGE_KEEP_RENDERING);
3388 DALI_TEST_EQUALS(drawTrace.CountMethod("DrawElements"), 1, TEST_LOCATION);
3391 // Render again and check the update status
3392 Animation animation = Animation::New(1.0f);
3393 animation.AnimateTo(Property(renderer, DevelRenderer::Property::OPACITY), 0.0f, TimePeriod(0.5f, 0.5f));
3398 application.SendNotification();
3399 application.Render(0);
3401 DALI_TEST_EQUALS(drawTrace.CountMethod("DrawElements"), 1, TEST_LOCATION);
3405 application.SendNotification();
3406 application.Render(100);
3408 updateStatus = application.GetUpdateStatus();
3410 DALI_TEST_CHECK(updateStatus & Integration::KeepUpdating::STAGE_KEEP_RENDERING);
3412 DALI_TEST_EQUALS(drawTrace.CountMethod("DrawElements"), 1, TEST_LOCATION);
3415 // Change rendering behavior
3416 renderer.SetProperty(DevelRenderer::Property::RENDERING_BEHAVIOR, DevelRenderer::Rendering::IF_REQUIRED);
3418 // Render and check the update status
3419 application.SendNotification();
3420 application.Render();
3422 updateStatus = application.GetUpdateStatus();
3424 DALI_TEST_CHECK(!(updateStatus & Integration::KeepUpdating::STAGE_KEEP_RENDERING));
3429 int UtcDaliRendererRegenerateUniformMap(void)
3431 TestApplication application;
3433 tet_infoline("Test regenerating uniform map when attaching renderer to the node");
3435 Geometry geometry = CreateQuadGeometry();
3436 Shader shader = Shader::New("vertexSrc", "fragmentSrc");
3437 Renderer renderer = Renderer::New(geometry, shader);
3439 Actor actor = Actor::New();
3440 actor.AddRenderer(renderer);
3441 actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
3442 actor.SetProperty(Actor::Property::COLOR, Vector4(1.0f, 0.0f, 1.0f, 1.0f));
3443 application.GetScene().Add(actor);
3445 application.SendNotification();
3446 application.Render();
3448 actor.RemoveRenderer(renderer);
3449 shader = Shader::New("vertexSrc", "fragmentSrc");
3450 shader.RegisterProperty("opacity", 0.5f);
3451 renderer.SetShader(shader);
3453 Stage::GetCurrent().KeepRendering(1.0f);
3455 // Update for several frames
3456 application.SendNotification();
3457 application.Render();
3458 application.SendNotification();
3459 application.Render();
3460 application.SendNotification();
3461 application.Render();
3462 application.SendNotification();
3463 application.Render();
3466 actor.AddRenderer(renderer);
3467 application.SendNotification();
3468 application.Render();
3470 // Nothing to test here, the test must not crash
3471 auto updateStatus = application.GetUpdateStatus();
3472 DALI_TEST_CHECK(updateStatus & Integration::KeepUpdating::STAGE_KEEP_RENDERING);
3477 int UtcDaliRendererAddDrawCommands(void)
3479 TestApplication application;
3481 tet_infoline("Test adding draw commands to the renderer");
3483 TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
3484 glAbstraction.EnableEnableDisableCallTrace(true);
3486 Geometry geometry = CreateQuadGeometry();
3487 Shader shader = Shader::New("vertexSrc", "fragmentSrc");
3488 Renderer renderer = Renderer::New(geometry, shader);
3490 renderer.SetProperty(Renderer::Property::BLEND_MODE, Dali::BlendMode::ON);
3491 Actor actor = Actor::New();
3492 actor.AddRenderer(renderer);
3493 actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
3494 actor.SetProperty(Actor::Property::COLOR, Vector4(1.0f, 0.0f, 1.0f, 1.0f));
3495 application.GetScene().Add(actor);
3497 // Expect delivering a single draw call
3498 auto& drawTrace = glAbstraction.GetDrawTrace();
3500 drawTrace.Enable(true);
3501 application.SendNotification();
3502 application.Render();
3504 DALI_TEST_EQUALS(drawTrace.CountMethod("DrawElements"), 1, TEST_LOCATION);
3506 tet_infoline("\n\nTesting extension draw commands\n");
3507 auto drawCommand1 = DevelRenderer::DrawCommand{};
3508 drawCommand1.drawType = DevelRenderer::DrawType::INDEXED;
3509 drawCommand1.firstIndex = 0;
3510 drawCommand1.elementCount = 2;
3511 drawCommand1.queue = DevelRenderer::RENDER_QUEUE_OPAQUE;
3513 auto drawCommand2 = DevelRenderer::DrawCommand{};
3514 drawCommand2.drawType = DevelRenderer::DrawType::INDEXED;
3515 drawCommand2.firstIndex = 2;
3516 drawCommand2.elementCount = 2;
3517 drawCommand2.queue = DevelRenderer::RENDER_QUEUE_TRANSPARENT;
3519 auto drawCommand3 = DevelRenderer::DrawCommand{};
3520 drawCommand3.drawType = DevelRenderer::DrawType::ARRAY;
3521 drawCommand3.firstIndex = 2;
3522 drawCommand3.elementCount = 2;
3523 drawCommand3.queue = DevelRenderer::RENDER_QUEUE_OPAQUE;
3525 DevelRenderer::AddDrawCommand(renderer, drawCommand1);
3526 DevelRenderer::AddDrawCommand(renderer, drawCommand2);
3527 DevelRenderer::AddDrawCommand(renderer, drawCommand3);
3530 drawTrace.Enable(true);
3531 application.SendNotification();
3532 application.Render();
3534 DALI_TEST_EQUALS(drawTrace.CountMethod("DrawElements"), 3, TEST_LOCATION);
3537 int UtcDaliRendererSetGeometryNegative(void)
3539 TestApplication application;
3540 Dali::Renderer instance;
3543 Dali::Geometry arg1;
3544 instance.SetGeometry(arg1);
3545 DALI_TEST_CHECK(false); // Should not get here
3549 DALI_TEST_CHECK(true); // We expect an assert
3554 int UtcDaliRendererSetTexturesNegative(void)
3556 TestApplication application;
3557 Dali::Renderer instance;
3560 Dali::TextureSet arg1;
3561 instance.SetTextures(arg1);
3562 DALI_TEST_CHECK(false); // Should not get here
3566 DALI_TEST_CHECK(true); // We expect an assert
3571 int UtcDaliRendererSetShaderNegative(void)
3573 TestApplication application;
3574 Dali::Renderer instance;
3578 instance.SetShader(arg1);
3579 DALI_TEST_CHECK(false); // Should not get here
3583 DALI_TEST_CHECK(true); // We expect an assert
3588 int UtcDaliRendererGetGeometryNegative(void)
3590 TestApplication application;
3591 Dali::Renderer instance;
3594 instance.GetGeometry();
3595 DALI_TEST_CHECK(false); // Should not get here
3599 DALI_TEST_CHECK(true); // We expect an assert
3604 int UtcDaliRendererGetTexturesNegative(void)
3606 TestApplication application;
3607 Dali::Renderer instance;
3610 instance.GetTextures();
3611 DALI_TEST_CHECK(false); // Should not get here
3615 DALI_TEST_CHECK(true); // We expect an assert
3620 int UtcDaliRendererGetShaderNegative(void)
3622 TestApplication application;
3623 Dali::Renderer instance;
3626 instance.GetShader();
3627 DALI_TEST_CHECK(false); // Should not get here
3631 DALI_TEST_CHECK(true); // We expect an assert
3636 int UtcDaliRendererCheckTextureBindingP(void)
3638 TestApplication application;
3640 tet_infoline("Test adding draw commands to the renderer");
3642 TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
3643 glAbstraction.EnableEnableDisableCallTrace(true);
3645 Geometry geometry = CreateQuadGeometry();
3646 Shader shader = Shader::New("vertexSrc", "fragmentSrc");
3647 Renderer renderer = Renderer::New(geometry, shader);
3649 renderer.SetProperty(Renderer::Property::BLEND_MODE, Dali::BlendMode::ON);
3650 Actor actor = Actor::New();
3651 actor.AddRenderer(renderer);
3652 actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
3653 actor.SetProperty(Actor::Property::COLOR, Vector4(1.0f, 0.0f, 1.0f, 1.0f));
3654 application.GetScene().Add(actor);
3656 TestGraphicsController& graphics = application.GetGraphicsController();
3657 TraceCallStack& cmdBufCallstack = graphics.mCommandBufferCallStack;
3658 cmdBufCallstack.Enable(true);
3660 application.SendNotification();
3661 application.Render();
3663 DALI_TEST_CHECK(!cmdBufCallstack.FindMethod("BindTextures"));
3665 Texture image0 = CreateTexture(TextureType::TEXTURE_2D, Pixel::RGB888, 64, 64);
3666 TextureSet textureSet0 = CreateTextureSet(image0);
3667 renderer.SetTextures(textureSet0);
3669 application.SendNotification();
3670 application.Render();
3672 DALI_TEST_CHECK(cmdBufCallstack.FindMethod("BindTextures"));
3676 int UtcDaliRendererPreparePipeline(void)
3678 TestApplication application;
3680 tet_infoline("Test that rendering an actor binds the attributes locs from the reflection");
3682 Property::Map vf = CreateModelVertexFormat();
3683 Geometry modelGeometry = CreateModelGeometry(vf);
3684 Shader shader = Shader::New("vertexSrc", "fragmentSrc");
3685 Renderer renderer = Renderer::New(modelGeometry, shader);
3686 Actor actor = Actor::New();
3688 // Change the order up to get a fair test
3689 Property::Map modelVF;
3690 modelVF["aBoneIndex[0]"] = Property::INTEGER;
3691 modelVF["aBoneIndex[1]"] = Property::INTEGER;
3692 modelVF["aBoneIndex[2]"] = Property::INTEGER;
3693 modelVF["aBoneIndex[3]"] = Property::INTEGER;
3694 modelVF["aBoneWeights[0]"] = Property::FLOAT;
3695 modelVF["aBoneWeights[1]"] = Property::FLOAT;
3696 modelVF["aBoneWeights[2]"] = Property::FLOAT;
3697 modelVF["aBoneWeights[3]"] = Property::FLOAT;
3698 modelVF["aPosition"] = Property::VECTOR3;
3699 modelVF["aNormal"] = Property::VECTOR3;
3700 modelVF["aTexCoord1"] = Property::VECTOR3;
3701 modelVF["aTexCoord2"] = Property::VECTOR3;
3703 Property::Array vfs;
3704 vfs.PushBack(modelVF);
3705 TestGraphicsController& graphics = application.GetGraphicsController();
3706 graphics.SetVertexFormats(vfs);
3708 actor.AddRenderer(renderer);
3709 actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
3710 actor.SetProperty(Actor::Property::COLOR, Color::WHITE);
3711 application.GetScene().Add(actor);
3713 TraceCallStack& cmdBufCallstack = graphics.mCommandBufferCallStack;
3714 TraceCallStack& graphicsCallstack = graphics.mCallStack;
3715 cmdBufCallstack.Enable(true);
3716 graphicsCallstack.Enable(true);
3718 application.SendNotification();
3719 application.Render();
3721 DALI_TEST_CHECK(graphicsCallstack.FindMethod("SubmitCommandBuffers"));
3722 std::vector<Graphics::SubmitInfo>& submissions = graphics.mSubmitStack;
3723 DALI_TEST_CHECK(submissions.size() > 0);
3725 TestGraphicsCommandBuffer* cmdBuf = static_cast<TestGraphicsCommandBuffer*>((submissions.back().cmdBuffer[0]));
3727 auto result = cmdBuf->GetChildCommandsByType(0 | CommandType::BIND_PIPELINE);
3728 auto pipeline = result[0]->data.bindPipeline.pipeline;
3732 DALI_TEST_EQUALS(pipeline->vertexInputState.attributes.size(), 12, TEST_LOCATION);
3733 DALI_TEST_EQUALS(pipeline->vertexInputState.attributes[3].location, // 4th requested attr: aTexCoord2
3736 DALI_TEST_EQUALS(pipeline->vertexInputState.attributes[3].format, // 4th requested attr: aTexCoord2
3737 Graphics::VertexInputFormat::FVECTOR3,