projects / platform / core / uifw / dali-toolkit.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Ambient occlusion support in DLI model
[platform/core/uifw/dali-toolkit.git] / automated-tests / src / dali-scene-loader / utc-Dali-ShaderDefinitionFactory.cpp
diff --git a/automated-tests/src/dali-scene-loader/utc-Dali-ShaderDefinitionFactory.cpp b/automated-tests/src/dali-scene-loader/utc-Dali-ShaderDefinitionFactory.cpp
index c1b5481..80ed66d 100644 (file)
--- a/automated-tests/src/dali-scene-loader/utc-Dali-ShaderDefinitionFactory.cpp
+++ b/automated-tests/src/dali-scene-loader/utc-Dali-ShaderDefinitionFactory.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,20 +18,19 @@
 // Enable debug log for test coverage
 #define DEBUG_ENABLED 1
 
+#include <dali-test-suite-utils.h>
+#include <set>
+#include <string_view>
 #include "dali-scene-loader/public-api/gltf2-loader.h"
-#include "dali-scene-loader/public-api/shader-definition-factory.h"
 #include "dali-scene-loader/public-api/node-definition.h"
 #include "dali-scene-loader/public-api/resource-bundle.h"
-#include <dali-test-suite-utils.h>
-#include <string_view>
-#include <set>
+#include "dali-scene-loader/public-api/shader-definition-factory.h"
 
 using namespace Dali;
 using namespace Dali::SceneLoader;
 
 namespace
 {
-
 bool EndsWith(const std::string& str, const std::string& suffix) // ends_width() is C++20
 {
   return str.size() >= suffix.size() && str.substr(str.size() - suffix.size()).compare(suffix) == 0;
@@ -57,7 +56,7 @@ void ClearMeshesAndMaterials(ResourceBundle& resources)
 
 struct Context
 {
-  ResourceBundle resources;
+  ResourceBundle          resources;
   ShaderDefinitionFactory factory;
 
   Context()
@@ -68,29 +67,29 @@ struct Context
 
 struct ShaderParameters
 {
-  MeshDefinition& meshDef;
+  MeshDefinition&     meshDef;
   MaterialDefinition& materialDef;
-  NodeDefinition& nodeDef;
+  NodeDefinition&     nodeDef;
 };
 
 struct Permutation
 {
-  using ConfigureFn = void(*)(ShaderParameters&);
+  using ConfigureFn = void (*)(ShaderParameters&);
 
   ConfigureFn configureFn;
 
   std::set<std::string> defines;
-  RendererState::Type rendererStateSet = 0;
-  RendererState::Type rendererStateClear = 0;
+  RendererState::Type   rendererStateSet   = 0;
+  RendererState::Type   rendererStateClear = 0;
 };
 
 struct PermutationSet
 {
   std::vector<const Permutation*> permutations;
-  Index shaderIdx;
+  Index                           shaderIdx;
 };
 
-}
+} // namespace
 
 int UtcDaliShaderDefinitionFactoryProduceShaderInvalid(void)
 {
@@ -121,173 +120,157 @@ int UtcDaliShaderDefinitionFactoryProduceShader(void)
       [](ShaderParameters& p) {
         p.materialDef.mFlags |= MaterialDefinition::TRANSPARENCY;
       },
-      { "THREE_TEX" },
+      {"THREE_TEX"},
       RendererState::ALPHA_BLEND,
       RendererState::DEPTH_WRITE,
     },
-    {
-      [](ShaderParameters& p) {
-        p.materialDef.mTextureStages.push_back({ MaterialDefinition::ALBEDO, {} });
-      },
-      { "THREE_TEX" }
-    },
-    {
-      [](ShaderParameters& p) {
-        p.materialDef.mTextureStages.push_back({ MaterialDefinition::METALLIC | MaterialDefinition::ROUGHNESS, {} });
-      },
-      { "THREE_TEX" }
-    },
-    {
-      [](ShaderParameters& p) {
-        p.materialDef.mTextureStages.push_back({ MaterialDefinition::NORMAL, {} });
-      },
-      { "THREE_TEX" }
-    },
-    {
-      [](ShaderParameters& p) {
-        p.materialDef.mFlags |= MaterialDefinition::SUBSURFACE;
-      },
-      { "SSS" }
-    },
-    {
-      [](ShaderParameters& p) {
-        p.materialDef.SetAlphaCutoff(.5f);
-      },
-      { "ALPHA_TEST" }
-    },
-    {
-      [](ShaderParameters& p) {
-        p.materialDef.SetAlphaCutoff(1.f);
-      },
-      { "ALPHA_TEST" }
-    },
-    {
-      [](ShaderParameters& p) {
-        p.materialDef.mFlags |= MaterialDefinition::GLTF_CHANNELS;
-      },
-      { "GLTF_CHANNELS" }
-    },
-    {
-      [](ShaderParameters& p) {
-        p.meshDef.mJoints0.mBlob.mOffset = 0;
-        p.meshDef.mWeights0.mBlob.mOffset = 0;
-      },
-      { "SKINNING" }
-    },
-    {
-      [](ShaderParameters& p) {
-        p.meshDef.mFlags |= MeshDefinition::FLIP_UVS_VERTICAL;
-      },
-      { "FLIP_V" }
-    },
+    {[](ShaderParameters& p) {
+       p.materialDef.mTextureStages.push_back({MaterialDefinition::ALBEDO, {}});
+     },
+     {"THREE_TEX"}},
+    {[](ShaderParameters& p) {
+       p.materialDef.mTextureStages.push_back({MaterialDefinition::METALLIC | MaterialDefinition::ROUGHNESS, {}});
+     },
+     {"THREE_TEX"}},
+    {[](ShaderParameters& p) {
+       p.materialDef.mTextureStages.push_back({MaterialDefinition::NORMAL, {}});
+     },
+     {"THREE_TEX"}},
+    {[](ShaderParameters& p) {
+       p.materialDef.mFlags |= MaterialDefinition::SUBSURFACE;
+     },
+     {"SSS"}},
+    {[](ShaderParameters& p) {
+       p.materialDef.SetAlphaCutoff(.5f);
+     },
+     {"ALPHA_TEST"}},
+    {[](ShaderParameters& p) {
+       p.materialDef.SetAlphaCutoff(1.f);
+     },
+     {"ALPHA_TEST"}},
+    {[](ShaderParameters& p) {
+       p.materialDef.mFlags |= MaterialDefinition::GLTF_CHANNELS;
+     },
+     {"GLTF_CHANNELS"}},
+    {[](ShaderParameters& p) {
+       p.meshDef.mJoints0.mBlob.mOffset  = 0;
+       p.meshDef.mWeights0.mBlob.mOffset = 0;
+     },
+     {"SKINNING"}},
+    {[](ShaderParameters& p) {
+       p.meshDef.mFlags |= MeshDefinition::FLIP_UVS_VERTICAL;
+     },
+     {"FLIP_V"}},
     {
       [](ShaderParameters& p) {
         p.meshDef.mBlendShapes.push_back({});
       },
     },
-    {
-      [](ShaderParameters& p) {
-        p.meshDef.mBlendShapes.back().deltas.mBlob.mOffset = 0;
-      },
-      { "MORPH_POSITION", "MORPH" }
-    },
-    {
-      [](ShaderParameters& p) {
-        p.meshDef.mBlendShapes.back().normals.mBlob.mOffset = 0;
-      },
-      { "MORPH_NORMAL", "MORPH" }
-    },
-    {
-      [](ShaderParameters& p) {
-        p.meshDef.mBlendShapes.back().tangents.mBlob.mOffset = 0;
-      },
-      { "MORPH_TANGENT", "MORPH" }
-    },
-    {
-      [](ShaderParameters& p) {
-        auto& blendShapes = p.meshDef.mBlendShapes;
-        DALI_ASSERT_ALWAYS(!blendShapes.empty() &&
-          (blendShapes.back().deltas.mBlob.mOffset != MeshDefinition::INVALID ||
-          blendShapes.back().normals.mBlob.mOffset != MeshDefinition::INVALID ||
-          blendShapes.back().tangents.mBlob.mOffset != MeshDefinition::INVALID));
-        p.meshDef.mBlendShapeVersion = BlendShapes::Version::VERSION_2_0;
-      },
-      { "MORPH_VERSION_2_0" }
-    },
+    {[](ShaderParameters& p) {
+       p.meshDef.mBlendShapes.back().deltas.mBlob.mOffset = 0;
+     },
+     {"MORPH_POSITION", "MORPH"}},
+    {[](ShaderParameters& p) {
+       p.meshDef.mBlendShapes.back().normals.mBlob.mOffset = 0;
+     },
+     {"MORPH_NORMAL", "MORPH"}},
+    {[](ShaderParameters& p) {
+       p.meshDef.mBlendShapes.back().tangents.mBlob.mOffset = 0;
+     },
+     {"MORPH_TANGENT", "MORPH"}},
+    {[](ShaderParameters& p) {
+       auto& blendShapes = p.meshDef.mBlendShapes;
+       DALI_ASSERT_ALWAYS(!blendShapes.empty() &&
+                          (blendShapes.back().deltas.mBlob.mOffset != MeshDefinition::INVALID ||
+                           blendShapes.back().normals.mBlob.mOffset != MeshDefinition::INVALID ||
+                           blendShapes.back().tangents.mBlob.mOffset != MeshDefinition::INVALID));
+       p.meshDef.mBlendShapeVersion = BlendShapes::Version::VERSION_2_0;
+     },
+     {"MORPH_VERSION_2_0"}},
+
+    {[](ShaderParameters& p) {
+       p.materialDef.mFlags |= MaterialDefinition::OCCLUSION;
+     },
+
+     {"OCCLUSION"}},
   };
 
-  PermutationSet permSets[] {
+  PermutationSet permSets[]{
     // default
-    { { &permutations[0] }, 0 },
+    {{&permutations[0]}, 0},
 
     // alpha
-    { { &permutations[0], &permutations[1] }, 1 },
+    {{&permutations[0], &permutations[1]}, 1},
 
     // three-texture setups
-    { { &permutations[0], &permutations[2] }, 2 },
-    { { &permutations[0], &permutations[3] }, 2 },
-    { { &permutations[0], &permutations[4] }, 2 },
-    { { &permutations[0], &permutations[2], &permutations[3] }, 2 },
-    { { &permutations[0], &permutations[3], &permutations[4] }, 2 },
-    { { &permutations[0], &permutations[4], &permutations[2] }, 2 },
-    { { &permutations[0], &permutations[2], &permutations[3], &permutations[4] }, 2 },
+    {{&permutations[0], &permutations[2]}, 2},
+    {{&permutations[0], &permutations[3]}, 2},
+    {{&permutations[0], &permutations[4]}, 2},
+    {{&permutations[0], &permutations[2], &permutations[3]}, 2},
+    {{&permutations[0], &permutations[3], &permutations[4]}, 2},
+    {{&permutations[0], &permutations[4], &permutations[2]}, 2},
+    {{&permutations[0], &permutations[2], &permutations[3], &permutations[4]}, 2},
 
     // subsurface scattering
-    { { &permutations[0], &permutations[5] }, 3 },
+    {{&permutations[0], &permutations[5]}, 3},
 
     // alpha test
-    { { &permutations[0], &permutations[6] }, 4 },
-    { { &permutations[0], &permutations[7] }, 4 },
+    {{&permutations[0], &permutations[6]}, 4},
+    {{&permutations[0], &permutations[7]}, 4},
 
     // glTF channels
-    { { &permutations[0], &permutations[8] }, 5 },
+    {{&permutations[0], &permutations[8]}, 5},
 
     // skinning
-    { { &permutations[0], &permutations[9] }, 6 },
+    {{&permutations[0], &permutations[9]}, 6},
 
     // flip uvs
-    { { &permutations[0], &permutations[10] }, 7 },
+    {{&permutations[0], &permutations[10]}, 7},
 
     // morphing
-    { { &permutations[0], &permutations[11], &permutations[12] }, 8 },
-    { { &permutations[0], &permutations[11], &permutations[13] }, 9 },
-    { { &permutations[0], &permutations[11], &permutations[14] }, 10 },
-    { { &permutations[0], &permutations[11], &permutations[12], &permutations[13] }, 11 },
-    { { &permutations[0], &permutations[11], &permutations[13], &permutations[14] }, 12 },
-    { { &permutations[0], &permutations[11], &permutations[14], &permutations[12] }, 13 },
-    { { &permutations[0], &permutations[11], &permutations[12], &permutations[13], &permutations[14] }, 14 },
-
-    { { &permutations[0], &permutations[11], &permutations[12], &permutations[15] }, 15 },
-    { { &permutations[0], &permutations[11], &permutations[13], &permutations[15] }, 16 },
-    { { &permutations[0], &permutations[11], &permutations[14], &permutations[15] }, 17 },
-    { { &permutations[0], &permutations[11], &permutations[12], &permutations[13], &permutations[15] }, 18 },
-    { { &permutations[0], &permutations[11], &permutations[13], &permutations[14], &permutations[15] }, 19 },
-    { { &permutations[0], &permutations[11], &permutations[14], &permutations[12], &permutations[15] }, 20 },
-    { { &permutations[0], &permutations[11], &permutations[12], &permutations[13], &permutations[14], &permutations[15] }, 21 },
+    {{&permutations[0], &permutations[11], &permutations[12]}, 8},
+    {{&permutations[0], &permutations[11], &permutations[13]}, 9},
+    {{&permutations[0], &permutations[11], &permutations[14]}, 10},
+    {{&permutations[0], &permutations[11], &permutations[12], &permutations[13]}, 11},
+    {{&permutations[0], &permutations[11], &permutations[13], &permutations[14]}, 12},
+    {{&permutations[0], &permutations[11], &permutations[14], &permutations[12]}, 13},
+    {{&permutations[0], &permutations[11], &permutations[12], &permutations[13], &permutations[14]}, 14},
+
+    {{&permutations[0], &permutations[11], &permutations[12], &permutations[15]}, 15},
+    {{&permutations[0], &permutations[11], &permutations[13], &permutations[15]}, 16},
+    {{&permutations[0], &permutations[11], &permutations[14], &permutations[15]}, 17},
+    {{&permutations[0], &permutations[11], &permutations[12], &permutations[13], &permutations[15]}, 18},
+    {{&permutations[0], &permutations[11], &permutations[13], &permutations[14], &permutations[15]}, 19},
+    {{&permutations[0], &permutations[11], &permutations[14], &permutations[12], &permutations[15]}, 20},
+    {{&permutations[0], &permutations[11], &permutations[12], &permutations[13], &permutations[14], &permutations[15]}, 21},
 
     // etc.
-    { { &permutations[0], &permutations[1], &permutations[2] }, 1 },
-    { { &permutations[0], &permutations[1], &permutations[3] }, 1 },
-    { { &permutations[0], &permutations[1], &permutations[2], &permutations[3] }, 1 },
+    {{&permutations[0], &permutations[1], &permutations[2]}, 1},
+    {{&permutations[0], &permutations[1], &permutations[3]}, 1},
+    {{&permutations[0], &permutations[1], &permutations[2], &permutations[3]}, 1},
+
+    // occlusion
+    {{&permutations[0], &permutations[16]}, 22},
   };
-  for(auto& ps: permSets)
+
+  for(auto& ps : permSets)
   {
     printf("%ld\n", &ps - permSets);
 
-    auto modelNode = new ModelNode();
-    modelNode->mMeshIdx = 0;
+    auto modelNode          = new ModelNode();
+    modelNode->mMeshIdx     = 0;
     modelNode->mMaterialIdx = 0;
 
     NodeDefinition nodeDef;
     nodeDef.mRenderable.reset(modelNode);
 
-    auto& meshDef = NewMeshDefinition(ctx.resources);
-    auto& materialDef = NewMaterialDefinition(ctx.resources);
-    ShaderParameters sp{ meshDef, materialDef, nodeDef };
+    auto&            meshDef     = NewMeshDefinition(ctx.resources);
+    auto&            materialDef = NewMaterialDefinition(ctx.resources);
+    ShaderParameters sp{meshDef, materialDef, nodeDef};
 
     std::set<std::string> defines;
-    RendererState::Type rendererState = 0;
-    for (auto p : ps.permutations)
+    RendererState::Type   rendererState = 0;
+    for(auto p : ps.permutations)
     {
       p->configureFn(sp);
       defines.insert(p->defines.begin(), p->defines.end());
@@ -303,10 +286,10 @@ int UtcDaliShaderDefinitionFactoryProduceShader(void)
     DALI_TEST_EQUAL(shaderDef.mRendererState, rendererState);
 
     uint32_t definesUnmatched = shaderDef.mDefines.size();
-    for (auto& d: shaderDef.mDefines)
+    for(auto& d : shaderDef.mDefines)
     {
       auto iFind = defines.find(d);
-      if (iFind != defines.end())
+      if(iFind != defines.end())
       {
         defines.erase(iFind);
         --definesUnmatched;
Domain: Graphics System / DALi;