automated-tests/src/dali-scene3d/utc-Dali-ShaderManager.cpp

   1 /*
   2  * Copyright (c) 2022 Samsung Electronics Co., Ltd.
   3  *
   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
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  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.
  15  *
  16  */
  17
  18 // Enable debug log for test coverage
  19 #define DEBUG_ENABLED 1
  20
  21 #include <dali-scene3d/public-api/loader/node-definition.h>
  22 #include <dali-scene3d/public-api/loader/resource-bundle.h>
  23 #include <dali-scene3d/public-api/loader/shader-manager.h>
  24 #include <dali-test-suite-utils.h>
  25 #include <set>
  26 #include <string_view>
  27
  28 using namespace Dali;
  29 using namespace Dali::Scene3D::Loader;
  30
  31 namespace
  32 {
  33 struct Context
  34 {
  35   ResourceBundle resources;
  36 };
  37
  38 struct ShaderParameters
  39 {
  40   MeshDefinition&     meshDefinition;
  41   MaterialDefinition& materialDefinition;
  42   NodeDefinition&     nodeDefinition;
  43 };
  44
  45 struct Permutation
  46 {
  47   using ConfigureFn = void (*)(ShaderParameters&);
  48
  49   ConfigureFn configureFn;
  50
  51   std::set<ShaderOption::Type> options;
  52   RendererState::Type          rendererStateSet   = 0;
  53   RendererState::Type          rendererStateClear = 0;
  54 };
  55
  56 struct PermutationSet
  57 {
  58   std::vector<const Permutation*> permutations;
  59 };
  60
  61 } // namespace
  62
  63 int UtcDaliShaderDefinitionFactoryProduceShader(void)
  64 {
  65   Context ctx;
  66   ctx.resources.mMaterials.push_back({});
  67   ctx.resources.mMeshes.push_back({});
  68
  69   Permutation permutations[]{
  70     {
  71       [](ShaderParameters& p) {},
  72       {},
  73       RendererState::DEPTH_TEST | RendererState::CULL_BACK,
  74     },
  75     {
  76       [](ShaderParameters& p)
  77       {
  78         p.materialDefinition.mFlags |= MaterialDefinition::TRANSPARENCY;
  79       },
  80       {ShaderOption::Type::THREE_TEXTURE},
  81       RendererState::ALPHA_BLEND,
  82     },
  83     {[](ShaderParameters& p)
  84      {
  85        p.materialDefinition.mFlags |= MaterialDefinition::ALBEDO;
  86        p.materialDefinition.mTextureStages.push_back({MaterialDefinition::ALBEDO, {}});
  87      },
  88      {ShaderOption::Type::THREE_TEXTURE, ShaderOption::Type::BASE_COLOR_TEXTURE}},
  89     {[](ShaderParameters& p)
  90      {
  91        p.materialDefinition.mTextureStages.push_back({MaterialDefinition::METALLIC | MaterialDefinition::ROUGHNESS, {}});
  92      },
  93      {ShaderOption::Type::THREE_TEXTURE, ShaderOption::Type::METALLIC_ROUGHNESS_TEXTURE}},
  94     {[](ShaderParameters& p)
  95      {
  96        p.materialDefinition.mFlags |= MaterialDefinition::NORMAL;
  97        p.materialDefinition.mTextureStages.push_back({MaterialDefinition::NORMAL, {}});
  98      },
  99      {ShaderOption::Type::THREE_TEXTURE, ShaderOption::Type::NORMAL_TEXTURE}},
 100     {[](ShaderParameters& p)
 101      {
 102        p.materialDefinition.mFlags |= MaterialDefinition::SUBSURFACE;
 103      },
 104      {ShaderOption::Type::SUBSURFACE}},
 105     {[](ShaderParameters& p)
 106      {
 107        p.materialDefinition.SetAlphaCutoff(.5f);
 108      },
 109      {ShaderOption::Type::ALPHA_TEST}},
 110     {[](ShaderParameters& p)
 111      {
 112        p.materialDefinition.SetAlphaCutoff(1.f);
 113      },
 114      {ShaderOption::Type::ALPHA_TEST}},
 115     {[](ShaderParameters& p)
 116      {
 117        p.materialDefinition.mFlags |= MaterialDefinition::GLTF_CHANNELS;
 118      },
 119      {ShaderOption::Type::GLTF_CHANNELS}},
 120     {[](ShaderParameters& p)
 121      {
 122        p.meshDefinition.mJoints0.mBlob.mOffset  = 0;
 123        p.meshDefinition.mWeights0.mBlob.mOffset = 0;
 124      },
 125      {ShaderOption::Type::SKINNING}},
 126     {[](ShaderParameters& p)
 127      {
 128        p.meshDefinition.mFlags |= MeshDefinition::FLIP_UVS_VERTICAL;
 129      },
 130      {ShaderOption::Type::FLIP_UVS_VERTICAL}},
 131     {
 132       [](ShaderParameters& p)
 133       {
 134         p.meshDefinition.mBlendShapes.push_back({});
 135       },
 136     },
 137     {[](ShaderParameters& p)
 138      {
 139        p.meshDefinition.mBlendShapes.back().deltas.mBlob.mOffset = 0;
 140      },
 141      {ShaderOption::Type::MORPH_POSITION}},
 142     {[](ShaderParameters& p)
 143      {
 144        p.meshDefinition.mBlendShapes.back().normals.mBlob.mOffset = 0;
 145      },
 146      {ShaderOption::Type::MORPH_NORMAL}},
 147     {[](ShaderParameters& p)
 148      {
 149        p.meshDefinition.mBlendShapes.back().tangents.mBlob.mOffset = 0;
 150      },
 151      {ShaderOption::Type::MORPH_TANGENT}},
 152     {[](ShaderParameters& p)
 153      {
 154        auto& blendShapes = p.meshDefinition.mBlendShapes;
 155        DALI_ASSERT_ALWAYS(!blendShapes.empty() &&
 156                           (blendShapes.back().deltas.mBlob.mOffset != MeshDefinition::INVALID ||
 157                            blendShapes.back().normals.mBlob.mOffset != MeshDefinition::INVALID ||
 158                            blendShapes.back().tangents.mBlob.mOffset != MeshDefinition::INVALID));
 159        p.meshDefinition.mBlendShapeVersion = BlendShapes::Version::VERSION_2_0;
 160      },
 161      {ShaderOption::Type::MORPH_VERSION_2_0}},
 162
 163     {[](ShaderParameters& p)
 164      {
 165        p.materialDefinition.mFlags |= MaterialDefinition::OCCLUSION;
 166      },
 167      {ShaderOption::Type::OCCLUSION}},
 168
 169     {[](ShaderParameters& p)
 170      {
 171        p.meshDefinition.mColors.mBlob.mOffset = 0;
 172      },
 173      {ShaderOption::Type::COLOR_ATTRIBUTE}},
 174     {[](ShaderParameters& p)
 175      {
 176        p.meshDefinition.mTangentType = Property::VECTOR4;
 177      },
 178      {ShaderOption::Type::VEC4_TANGENT}},
 179   };
 180
 181   PermutationSet permutationSets[]{
 182     // default
 183     {{&permutations[0]}},
 184
 185     // alpha
 186     {{&permutations[0], &permutations[1]}},
 187
 188     // three-texture setups
 189     {{&permutations[0], &permutations[2]}},
 190     {{&permutations[0], &permutations[3]}},
 191     {{&permutations[0], &permutations[4]}},
 192     {{&permutations[0], &permutations[2], &permutations[3]}},
 193     {{&permutations[0], &permutations[3], &permutations[4]}},
 194     {{&permutations[0], &permutations[4], &permutations[2]}},
 195     {{&permutations[0], &permutations[2], &permutations[3], &permutations[4]}},
 196
 197     // subsurface scattering
 198     {{&permutations[0], &permutations[5]}},
 199
 200     // alpha test
 201     {{&permutations[0], &permutations[6]}},
 202     {{&permutations[0], &permutations[7]}},
 203
 204     // glTF channels
 205     {{&permutations[0], &permutations[8]}},
 206
 207     // skinning
 208     {{&permutations[0], &permutations[9]}},
 209
 210     // flip uvs
 211     {{&permutations[0], &permutations[10]}},
 212
 213     // morphing
 214     {{&permutations[0], &permutations[11], &permutations[12]}},
 215     {{&permutations[0], &permutations[11], &permutations[13]}},
 216     {{&permutations[0], &permutations[11], &permutations[14]}},
 217     {{&permutations[0], &permutations[11], &permutations[12], &permutations[13]}},
 218     {{&permutations[0], &permutations[11], &permutations[13], &permutations[14]}},
 219     {{&permutations[0], &permutations[11], &permutations[14], &permutations[12]}},
 220     {{&permutations[0], &permutations[11], &permutations[12], &permutations[13], &permutations[14]}},
 221
 222     {{&permutations[0], &permutations[11], &permutations[12], &permutations[15]}},
 223     {{&permutations[0], &permutations[11], &permutations[13], &permutations[15]}},
 224     {{&permutations[0], &permutations[11], &permutations[14], &permutations[15]}},
 225     {{&permutations[0], &permutations[11], &permutations[12], &permutations[13], &permutations[15]}},
 226     {{&permutations[0], &permutations[11], &permutations[13], &permutations[14], &permutations[15]}},
 227     {{&permutations[0], &permutations[11], &permutations[14], &permutations[12], &permutations[15]}},
 228     {{&permutations[0], &permutations[11], &permutations[12], &permutations[13], &permutations[14], &permutations[15]}},
 229
 230     // etc.
 231     {{&permutations[0], &permutations[1], &permutations[2]}},
 232     {{&permutations[0], &permutations[1], &permutations[3]}},
 233     {{&permutations[0], &permutations[1], &permutations[2], &permutations[3]}},
 234
 235     // occlusion
 236     {{&permutations[0], &permutations[16]}},
 237   };
 238
 239   TestApplication app;
 240   ShaderManager   shaderManager;
 241   for(auto& permutationSet : permutationSets)
 242   {
 243     static int tc = 0;
 244     tet_printf("Test %d's tc\n", ++tc);
 245     auto modelRenderable          = new ModelRenderable();
 246     modelRenderable->mMeshIdx     = 0;
 247     modelRenderable->mMaterialIdx = 0;
 248
 249     NodeDefinition                              nodeDefinition;
 250     std::unique_ptr<NodeDefinition::Renderable> renderable;
 251     renderable.reset(modelRenderable);
 252     nodeDefinition.mRenderables.push_back(std::move(renderable));
 253
 254     MeshDefinition     meshDefinition;
 255     MaterialDefinition materialDefinition;
 256     ShaderParameters   shaderParameter{meshDefinition, materialDefinition, nodeDefinition};
 257
 258     std::set<std::string> defines;
 259     ShaderOption          option;
 260     RendererState::Type   rendererState = 0;
 261     for(auto permutation : permutationSet.permutations)
 262     {
 263       permutation->configureFn(shaderParameter);
 264       if(materialDefinition.mFlags & MaterialDefinition::TRANSPARENCY)
 265       {
 266         option.SetTransparency();
 267       }
 268       for(auto&& optionType : permutation->options)
 269       {
 270         option.AddOption(optionType);
 271       }
 272       rendererState = (rendererState | permutation->rendererStateSet) & ~permutation->rendererStateClear;
 273     }
 274     option.AddOption(ShaderOption::Type::THREE_TEXTURE);
 275
 276     Shader shaderFromMeshAndMaterial = shaderManager.ProduceShader(materialDefinition, meshDefinition);
 277     Shader shaderFromOption          = shaderManager.ProduceShader(option);
 278     DALI_TEST_EQUAL(shaderFromMeshAndMaterial, shaderFromOption);
 279
 280     RendererState::Type rendererStateFromMaterialDefinition = shaderManager.GetRendererState(materialDefinition);
 281     DALI_TEST_EQUAL(rendererStateFromMaterialDefinition, rendererState);
 282   }
 283
 284   END_TEST;
 285 }