Create visual's border property map for only valid type
[platform/core/uifw/dali-toolkit.git] / dali-scene-loader / public-api / shader-definition-factory.cpp
1 /*
2  * Copyright (c) 2021 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 #include "dali-scene-loader/public-api/shader-definition-factory.h"
18 #include <cstring>
19 #include "dali-scene-loader/internal/hash.h"
20 #include "dali-scene-loader/public-api/blend-shape-details.h"
21 #include "dali-scene-loader/public-api/node-definition.h"
22 #include "dali/devel-api/common/map-wrapper.h"
23
24 namespace Dali
25 {
26 namespace SceneLoader
27 {
28 namespace
29 {
30 struct ResourceReceiver : IResourceReceiver
31 {
32   const ResourceBundle&     mResources;
33   const MeshDefinition*     mMeshDef     = nullptr;
34   const MaterialDefinition* mMaterialDef = nullptr;
35
36   ResourceReceiver(const ResourceBundle& resources)
37   : mResources(resources)
38   {
39   }
40
41   void Register(ResourceType::Value type, Index id) override
42   {
43     switch(type)
44     {
45       case ResourceType::Mesh:
46         mMeshDef = &mResources.mMeshes[id].first;
47         break;
48
49       case ResourceType::Material:
50         mMaterialDef = &mResources.mMaterials[id].first;
51         break;
52
53       default:
54         break;
55     }
56   }
57 };
58
59 const std::string PBR_SHADER_NAME = "dli_pbr";
60
61 void RetrieveBlendShapeComponents(const std::vector<MeshDefinition::BlendShape>& blendShapes, bool& hasPositions, bool& hasNormals, bool& hasTangents)
62 {
63   for(const auto& blendShape : blendShapes)
64   {
65     hasPositions = hasPositions || blendShape.deltas.IsDefined();
66     hasNormals   = hasNormals || blendShape.normals.IsDefined();
67     hasTangents  = hasTangents || blendShape.tangents.IsDefined();
68   }
69 }
70
71 uint64_t HashNode(const NodeDefinition& nodeDef, const MaterialDefinition& materialDef, const MeshDefinition& meshDef)
72 {
73   Hash hash;
74
75   // note: could be per vertex / fragment component - in WatchViewer, these have the same name.
76   hash.Add(PBR_SHADER_NAME);
77
78   const bool hasTransparency = MaskMatch(materialDef.mFlags, MaterialDefinition::TRANSPARENCY);
79   hash.Add(hasTransparency);
80
81   if(hasTransparency ||
82      materialDef.CheckTextures(MaterialDefinition::ALBEDO) ||
83      materialDef.CheckTextures(MaterialDefinition::METALLIC | MaterialDefinition::ROUGHNESS) ||
84      materialDef.CheckTextures(MaterialDefinition::NORMAL))
85   {
86     hash.Add("3TEX");
87   }
88
89   if(materialDef.GetAlphaCutoff() > 0.f)
90   {
91     hash.Add("ALPH" /*A_TEST*/);
92   }
93
94   if(MaskMatch(materialDef.mFlags, MaterialDefinition::SUBSURFACE))
95   {
96     hash.Add("SSS");
97   }
98
99   if(MaskMatch(materialDef.mFlags, MaterialDefinition::GLTF_CHANNELS))
100   {
101     hash.Add("GLTF" /*_CHANNELS*/);
102   }
103
104   if(meshDef.IsSkinned())
105   {
106     hash.Add("SKIN" /*NING*/);
107   }
108
109   if(MaskMatch(meshDef.mFlags, MeshDefinition::FLIP_UVS_VERTICAL))
110   {
111     hash.Add("FLIP" /*_V*/);
112   }
113
114   if(meshDef.HasBlendShapes())
115   {
116     bool hasPositions = false;
117     bool hasNormals   = false;
118     bool hasTangents  = false;
119     RetrieveBlendShapeComponents(meshDef.mBlendShapes, hasPositions, hasNormals, hasTangents);
120     if(hasPositions)
121     {
122       hash.Add("MORPHPOS");
123     }
124
125     if(hasNormals)
126     {
127       hash.Add("MORPHNOR");
128     }
129
130     if(hasTangents)
131     {
132       hash.Add("MORPHTAN");
133     }
134
135     if(hasPositions || hasNormals || hasTangents)
136     {
137       hash.Add("MORPH");
138
139       if(BlendShapes::Version::VERSION_2_0 == meshDef.mBlendShapeVersion)
140       {
141         hash.Add("MORPHV2");
142       }
143     }
144   }
145
146   return hash;
147 }
148 } // namespace
149
150 struct ShaderDefinitionFactory::Impl
151 {
152   ResourceBundle*           mResources; // no ownership
153   std::map<uint64_t, Index> mShaderMap;
154 };
155
156 ShaderDefinitionFactory::ShaderDefinitionFactory()
157 : mImpl{new Impl()}
158 {
159 }
160
161 ShaderDefinitionFactory::~ShaderDefinitionFactory() = default;
162
163 void ShaderDefinitionFactory::SetResources(ResourceBundle& resources)
164 {
165   mImpl->mResources = &resources;
166   mImpl->mShaderMap.clear();
167 }
168
169 Index ShaderDefinitionFactory::ProduceShader(const NodeDefinition& nodeDef)
170 {
171   DALI_ASSERT_DEBUG(nodeDef.mRenderable);
172
173   auto&            resources = *mImpl->mResources;
174   ResourceReceiver receiver{resources};
175   nodeDef.mRenderable->RegisterResources(receiver);
176   if(!(receiver.mMeshDef && receiver.mMaterialDef))
177   {
178     return INVALID_INDEX;
179   }
180
181   auto&    shaderMap = mImpl->mShaderMap;
182   uint64_t hash      = HashNode(nodeDef, *receiver.mMaterialDef, *receiver.mMeshDef);
183   auto     iFind     = shaderMap.find(hash);
184   if(iFind != shaderMap.end())
185   {
186     return iFind->second;
187   }
188
189   ShaderDefinition shaderDef;
190   shaderDef.mVertexShaderPath   = PBR_SHADER_NAME + ".vsh";
191   shaderDef.mFragmentShaderPath = PBR_SHADER_NAME + ".fsh";
192   shaderDef.mRendererState      = RendererState::DEPTH_TEST | RendererState::DEPTH_WRITE | RendererState::CULL_BACK;
193
194   auto&      materialDef     = *receiver.mMaterialDef;
195   const bool hasTransparency = MaskMatch(materialDef.mFlags, MaterialDefinition::TRANSPARENCY);
196   if(hasTransparency)
197   {
198     // TODO: this requires more granularity
199     shaderDef.mRendererState = (shaderDef.mRendererState | RendererState::ALPHA_BLEND) & ~RendererState::DEPTH_WRITE;
200   }
201
202   if(hasTransparency ||
203      materialDef.CheckTextures(MaterialDefinition::ALBEDO) ||
204      materialDef.CheckTextures(MaterialDefinition::METALLIC | MaterialDefinition::ROUGHNESS) ||
205      materialDef.CheckTextures(MaterialDefinition::NORMAL))
206   {
207     shaderDef.mDefines.push_back("THREE_TEX");
208   }
209
210   if(materialDef.GetAlphaCutoff() > 0.f)
211   {
212     shaderDef.mDefines.push_back("ALPHA_TEST");
213   }
214
215   if(MaskMatch(materialDef.mFlags, MaterialDefinition::SUBSURFACE))
216   {
217     shaderDef.mDefines.push_back("SSS");
218   }
219
220   if(MaskMatch(receiver.mMaterialDef->mFlags, MaterialDefinition::GLTF_CHANNELS))
221   {
222     shaderDef.mDefines.push_back("GLTF_CHANNELS");
223   }
224
225   const auto& meshDef = *receiver.mMeshDef;
226   if(meshDef.IsSkinned())
227   {
228     shaderDef.mDefines.push_back("SKINNING");
229   }
230
231   if(MaskMatch(meshDef.mFlags, MeshDefinition::FLIP_UVS_VERTICAL))
232   {
233     shaderDef.mDefines.push_back("FLIP_V");
234   }
235
236   if(meshDef.HasBlendShapes())
237   {
238     bool hasPositions = false;
239     bool hasNormals   = false;
240     bool hasTangents  = false;
241     RetrieveBlendShapeComponents(meshDef.mBlendShapes, hasPositions, hasNormals, hasTangents);
242
243     if(hasPositions)
244     {
245       shaderDef.mDefines.push_back("MORPH_POSITION");
246     }
247
248     if(hasNormals)
249     {
250       shaderDef.mDefines.push_back("MORPH_NORMAL");
251     }
252
253     if(hasTangents)
254     {
255       shaderDef.mDefines.push_back("MORPH_TANGENT");
256     }
257
258     if(hasPositions || hasNormals || hasTangents)
259     {
260       shaderDef.mDefines.push_back("MORPH");
261
262       if(BlendShapes::Version::VERSION_2_0 == meshDef.mBlendShapeVersion)
263       {
264         shaderDef.mDefines.push_back("MORPH_VERSION_2_0");
265       }
266     }
267   }
268
269   shaderDef.mUniforms["uMaxLOD"]     = 6.f;
270   shaderDef.mUniforms["uCubeMatrix"] = Matrix::IDENTITY;
271
272   Index result    = resources.mShaders.size();
273   shaderMap[hash] = result;
274
275   resources.mShaders.emplace_back(std::move(shaderDef), Shader());
276
277   return result;
278 }
279
280 } // namespace SceneLoader
281 } // namespace Dali