/*
- * Copyright (c) 2020 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2021 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.
* limitations under the License.
*
*/
-#include "dali-scene-loader/internal/hash.h"
#include "dali-scene-loader/public-api/shader-definition-factory.h"
-#include "dali-scene-loader/public-api/node-definition.h"
+#include <cstring>
+#include "dali-scene-loader/internal/hash.h"
#include "dali-scene-loader/public-api/blend-shape-details.h"
+#include "dali-scene-loader/public-api/node-definition.h"
#include "dali/devel-api/common/map-wrapper.h"
-#include <cstring>
namespace Dali
{
{
struct ResourceReceiver : IResourceReceiver
{
- const ResourceBundle& mResources;
- const MeshDefinition* mMeshDef = nullptr;
+ const ResourceBundle& mResources;
+ const MeshDefinition* mMeshDef = nullptr;
const MaterialDefinition* mMaterialDef = nullptr;
ResourceReceiver(const ResourceBundle& resources)
: mResources(resources)
- {}
+ {
+ }
void Register(ResourceType::Value type, Index id) override
{
- switch (type)
+ switch(type)
{
- case ResourceType::Mesh:
- mMeshDef = &mResources.mMeshes[id].first;
- break;
+ case ResourceType::Mesh:
+ mMeshDef = &mResources.mMeshes[id].first;
+ break;
- case ResourceType::Material:
- mMaterialDef = &mResources.mMaterials[id].first;
- break;
+ case ResourceType::Material:
+ mMaterialDef = &mResources.mMaterials[id].first;
+ break;
- default:
- break;
+ default:
+ break;
}
}
};
void RetrieveBlendShapeComponents(const std::vector<MeshDefinition::BlendShape>& blendShapes, bool& hasPositions, bool& hasNormals, bool& hasTangents)
{
- for (const auto& blendShape : blendShapes)
+ for(const auto& blendShape : blendShapes)
{
hasPositions = hasPositions || blendShape.deltas.IsDefined();
- hasNormals = hasNormals || blendShape.normals.IsDefined();
- hasTangents = hasTangents || blendShape.tangents.IsDefined();
+ hasNormals = hasNormals || blendShape.normals.IsDefined();
+ hasTangents = hasTangents || blendShape.tangents.IsDefined();
}
}
const bool hasTransparency = MaskMatch(materialDef.mFlags, MaterialDefinition::TRANSPARENCY);
hash.Add(hasTransparency);
- if (hasTransparency ||
- materialDef.CheckTextures(MaterialDefinition::ALBEDO) ||
- materialDef.CheckTextures(MaterialDefinition::METALLIC | MaterialDefinition::ROUGHNESS) ||
- materialDef.CheckTextures(MaterialDefinition::NORMAL))
+ if(hasTransparency ||
+ materialDef.CheckTextures(MaterialDefinition::ALBEDO) ||
+ materialDef.CheckTextures(MaterialDefinition::METALLIC | MaterialDefinition::ROUGHNESS) ||
+ materialDef.CheckTextures(MaterialDefinition::NORMAL))
{
hash.Add("3TEX");
}
- if (materialDef.GetAlphaCutoff() > 0.f)
+ if(materialDef.GetAlphaCutoff() > 0.f)
{
- hash.Add("ALPH"/*A_TEST*/);
+ hash.Add("ALPH" /*A_TEST*/);
}
- if (MaskMatch(materialDef.mFlags, MaterialDefinition::SUBSURFACE))
+ if(MaskMatch(materialDef.mFlags, MaterialDefinition::SUBSURFACE))
{
hash.Add("SSS");
}
- if (MaskMatch(materialDef.mFlags, MaterialDefinition::GLTF_CHANNELS))
+ if(MaskMatch(materialDef.mFlags, MaterialDefinition::GLTF_CHANNELS))
{
- hash.Add("GLTF"/*_CHANNELS*/);
+ hash.Add("GLTF" /*_CHANNELS*/);
}
- if (meshDef.IsSkinned())
+ if(meshDef.IsSkinned())
{
- hash.Add("SKIN"/*NING*/);
+ hash.Add("SKIN" /*NING*/);
}
- if (MaskMatch(meshDef.mFlags, MeshDefinition::FLIP_UVS_VERTICAL))
+ if(MaskMatch(meshDef.mFlags, MeshDefinition::FLIP_UVS_VERTICAL))
{
- hash.Add("FLIP"/*_V*/);
+ hash.Add("FLIP" /*_V*/);
}
- if (meshDef.HasBlendShapes())
+ if(meshDef.HasBlendShapes())
{
bool hasPositions = false;
- bool hasNormals = false;
- bool hasTangents = false;
+ bool hasNormals = false;
+ bool hasTangents = false;
RetrieveBlendShapeComponents(meshDef.mBlendShapes, hasPositions, hasNormals, hasTangents);
- if (hasPositions)
+ if(hasPositions)
{
hash.Add("MORPHPOS");
}
- if (hasNormals)
+ if(hasNormals)
{
hash.Add("MORPHNOR");
}
- if (hasTangents)
+ if(hasTangents)
{
hash.Add("MORPHTAN");
}
- if (hasPositions || hasNormals || hasTangents)
+ if(hasPositions || hasNormals || hasTangents)
{
hash.Add("MORPH");
- if (BlendShapes::Version::VERSION_2_0 == meshDef.mBlendShapeVersion)
+ if(BlendShapes::Version::VERSION_2_0 == meshDef.mBlendShapeVersion)
{
hash.Add("MORPHV2");
}
return hash;
}
-}
+} // namespace
struct ShaderDefinitionFactory::Impl
{
- ResourceBundle* mResources; // no ownership
+ ResourceBundle* mResources; // no ownership
std::map<uint64_t, Index> mShaderMap;
};
ShaderDefinitionFactory::ShaderDefinitionFactory()
-: mImpl{ new Impl() }
-{}
+: mImpl{new Impl()}
+{
+}
ShaderDefinitionFactory::~ShaderDefinitionFactory() = default;
{
DALI_ASSERT_DEBUG(nodeDef.mRenderable);
- auto& resources = *mImpl->mResources;
- ResourceReceiver receiver{ resources };
+ auto& resources = *mImpl->mResources;
+ ResourceReceiver receiver{resources};
nodeDef.mRenderable->RegisterResources(receiver);
- if (!(receiver.mMeshDef && receiver.mMaterialDef))
+ if(!(receiver.mMeshDef && receiver.mMaterialDef))
{
return INVALID_INDEX;
}
- auto& shaderMap = mImpl->mShaderMap;
- uint64_t hash = HashNode(nodeDef, *receiver.mMaterialDef, *receiver.mMeshDef);
- auto iFind = shaderMap.find(hash);
- if (iFind != shaderMap.end())
+ auto& shaderMap = mImpl->mShaderMap;
+ uint64_t hash = HashNode(nodeDef, *receiver.mMaterialDef, *receiver.mMeshDef);
+ auto iFind = shaderMap.find(hash);
+ if(iFind != shaderMap.end())
{
return iFind->second;
}
ShaderDefinition shaderDef;
- shaderDef.mVertexShaderPath = PBR_SHADER_NAME + ".vsh";
+ shaderDef.mVertexShaderPath = PBR_SHADER_NAME + ".vsh";
shaderDef.mFragmentShaderPath = PBR_SHADER_NAME + ".fsh";
- shaderDef.mRendererState = RendererState::DEPTH_TEST | RendererState::DEPTH_WRITE | RendererState::CULL_BACK;
+ shaderDef.mRendererState = RendererState::DEPTH_TEST | RendererState::DEPTH_WRITE | RendererState::CULL_BACK;
- auto& materialDef = *receiver.mMaterialDef;
+ auto& materialDef = *receiver.mMaterialDef;
const bool hasTransparency = MaskMatch(materialDef.mFlags, MaterialDefinition::TRANSPARENCY);
- if (hasTransparency)
+ if(hasTransparency)
{
// TODO: this requires more granularity
shaderDef.mRendererState = (shaderDef.mRendererState | RendererState::ALPHA_BLEND) & ~RendererState::DEPTH_WRITE;
}
- if (hasTransparency ||
- materialDef.CheckTextures(MaterialDefinition::ALBEDO) ||
- materialDef.CheckTextures(MaterialDefinition::METALLIC | MaterialDefinition::ROUGHNESS) ||
- materialDef.CheckTextures(MaterialDefinition::NORMAL))
+ if(hasTransparency ||
+ materialDef.CheckTextures(MaterialDefinition::ALBEDO) ||
+ materialDef.CheckTextures(MaterialDefinition::METALLIC | MaterialDefinition::ROUGHNESS) ||
+ materialDef.CheckTextures(MaterialDefinition::NORMAL))
{
shaderDef.mDefines.push_back("THREE_TEX");
}
- if (materialDef.GetAlphaCutoff() > 0.f)
+ if(materialDef.GetAlphaCutoff() > 0.f)
{
shaderDef.mDefines.push_back("ALPHA_TEST");
}
- if (MaskMatch(materialDef.mFlags, MaterialDefinition::SUBSURFACE))
+ if(MaskMatch(materialDef.mFlags, MaterialDefinition::SUBSURFACE))
{
shaderDef.mDefines.push_back("SSS");
}
- if (MaskMatch(receiver.mMaterialDef->mFlags, MaterialDefinition::GLTF_CHANNELS))
+ if(MaskMatch(receiver.mMaterialDef->mFlags, MaterialDefinition::GLTF_CHANNELS))
{
shaderDef.mDefines.push_back("GLTF_CHANNELS");
}
const auto& meshDef = *receiver.mMeshDef;
- if (meshDef.IsSkinned())
+ if(meshDef.IsSkinned())
{
shaderDef.mDefines.push_back("SKINNING");
}
- if (MaskMatch(meshDef.mFlags, MeshDefinition::FLIP_UVS_VERTICAL))
+ if(MaskMatch(meshDef.mFlags, MeshDefinition::FLIP_UVS_VERTICAL))
{
shaderDef.mDefines.push_back("FLIP_V");
}
- if (meshDef.HasBlendShapes())
+ if(meshDef.HasBlendShapes())
{
bool hasPositions = false;
- bool hasNormals = false;
- bool hasTangents = false;
+ bool hasNormals = false;
+ bool hasTangents = false;
RetrieveBlendShapeComponents(meshDef.mBlendShapes, hasPositions, hasNormals, hasTangents);
- if (hasPositions)
+ if(hasPositions)
{
shaderDef.mDefines.push_back("MORPH_POSITION");
}
- if (hasNormals)
+ if(hasNormals)
{
shaderDef.mDefines.push_back("MORPH_NORMAL");
}
- if (hasTangents)
+ if(hasTangents)
{
shaderDef.mDefines.push_back("MORPH_TANGENT");
}
- if (hasPositions || hasNormals || hasTangents)
+ if(hasPositions || hasNormals || hasTangents)
{
shaderDef.mDefines.push_back("MORPH");
- if (BlendShapes::Version::VERSION_2_0 == meshDef.mBlendShapeVersion)
+ if(BlendShapes::Version::VERSION_2_0 == meshDef.mBlendShapeVersion)
{
shaderDef.mDefines.push_back("MORPH_VERSION_2_0");
}
}
}
- shaderDef.mUniforms["uMaxLOD"] = 6.f;
+ shaderDef.mUniforms["uMaxLOD"] = 6.f;
shaderDef.mUniforms["uCubeMatrix"] = Matrix::IDENTITY;
- Index result = resources.mShaders.size();
+ Index result = resources.mShaders.size();
shaderMap[hash] = result;
resources.mShaders.emplace_back(std::move(shaderDef), Shader());
return result;
}
-}
-}
+} // namespace SceneLoader
+} // namespace Dali
projects / platform / core / uifw / dali-toolkit.git / blobdiff