uniform sampler2D sNormalRoughness;
#endif
-uniform float uSpecularFactor;
-uniform vec3 uSpecularColorFactor;
-#ifdef MATERIAL_SPECULAR_TEXTURE
-uniform sampler2D sSpecular;
-#endif
-#ifdef MATERIAL_SPECULAR_COLOR_TEXTURE
-uniform sampler2D sSpecularColor;
-#endif
-
#ifdef OCCLUSION
uniform sampler2D sOcclusion;
uniform float uOcclusionStrength;
uniform vec3 uEmissiveFactor;
#endif
+uniform float uSpecularFactor;
+uniform vec3 uSpecularColorFactor;
+#ifdef MATERIAL_SPECULAR_TEXTURE
+uniform sampler2D sSpecular;
+#endif
+#ifdef MATERIAL_SPECULAR_COLOR_TEXTURE
+uniform sampler2D sSpecularColor;
+#endif
+
//// For IBL
uniform sampler2D sbrdfLUT;
uniform samplerCube sDiffuseEnvSampler;
#endif // THREE_TEX
// The value of uOpaque and uMask can be 0.0 or 1.0.
+ // If uMask is 0.0, a Pixel that has bigger alpha than uAlphaThreashold becomes fully opaque,
+ // in other hand, a pixel that has smaller alpha than uAlphaThreashold becomes fully transparent.
// If uOpaque is 1.0, alpha value of final color is 1.0;
- // If uOpaque is 0.0 and uMask is 1.0, alpha value of final color is 0.0 when input alpha is lower than uAlphaThreshold or
- // 1.0 when input alpha is larger than uAlphaThreshold.
// https://www.khronos.org/registry/glTF/specs/2.0/glTF-2.0.html#_material_alphamode
+ if(uMask > 0.5 && baseColor.a < uAlphaThreshold)
+ {
+ discard;
+ }
baseColor.a = mix(baseColor.a, 1.0, uOpaque);
- baseColor.a = min(mix(baseColor.a, floor(baseColor.a - uAlphaThreshold + 1.0), uMask), 1.0);
metallic = clamp(metallic, 0.0, 1.0);
// Roughness is authored as perceptual roughness; as is convention,
{
if(s)
{
- return (s->mMinFilter < gt::Filter::NEAREST_MIPMAP_NEAREST) ? (s->mMinFilter - gt::Filter::NEAREST) : ((s->mMinFilter - gt::Filter::NEAREST_MIPMAP_NEAREST) + 2) | ((s->mMagFilter - gt::Filter::NEAREST) << SamplerFlags::FILTER_MAG_SHIFT) | (ConvertWrapMode(s->mWrapS) << SamplerFlags::WRAP_S_SHIFT) | (ConvertWrapMode(s->mWrapT) << SamplerFlags::WRAP_T_SHIFT);
+ return ((s->mMinFilter < gt::Filter::NEAREST_MIPMAP_NEAREST) ? (s->mMinFilter - gt::Filter::NEAREST) : ((s->mMinFilter - gt::Filter::NEAREST_MIPMAP_NEAREST) + 2)) | ((s->mMagFilter - gt::Filter::NEAREST) << SamplerFlags::FILTER_MAG_SHIFT) | (ConvertWrapMode(s->mWrapS) << SamplerFlags::WRAP_S_SHIFT) | (ConvertWrapMode(s->mWrapT) << SamplerFlags::WRAP_T_SHIFT);
}
else
{
MaterialDefinition matDef;
auto& pbr = m.mPbrMetallicRoughness;
- if(pbr.mBaseColorFactor.a < 1.f)
+ if(m.mAlphaMode == gt::AlphaMode::BLEND)
{
+ matDef.mIsOpaque = false;
matDef.mFlags |= MaterialDefinition::TRANSPARENCY;
}
if(m.mAlphaMode == gt::AlphaMode::MASK)
{
+ matDef.mIsMask = true;
matDef.SetAlphaCutoff(std::min(1.f, std::max(0.f, m.mAlphaCutoff)));
}
void ConvertNodes(const gt::Document& doc, ConversionContext& cctx, bool isMRendererModel)
{
- ConvertSceneNodes(*doc.mScene, cctx, isMRendererModel);
+ uint32_t rootSceneIndex = 0u;
+ if(doc.mScene)
+ {
+ rootSceneIndex = doc.mScene.GetIndex();
+ }
+ ConvertSceneNodes(doc.mScenes[rootSceneIndex], cctx, isMRendererModel);
- for(uint32_t i = 0, i1 = doc.mScene.GetIndex(); i < i1; ++i)
+ for(uint32_t i = 0, i1 = rootSceneIndex; i < i1; ++i)
{
ConvertSceneNodes(doc.mScenes[i], cctx, isMRendererModel);
}
- for(uint32_t i = doc.mScene.GetIndex() + 1; i < doc.mScenes.size(); ++i)
+ for(uint32_t i = rootSceneIndex + 1; i < doc.mScenes.size(); ++i)
{
ConvertSceneNodes(doc.mScenes[i], cctx, isMRendererModel);
}
MaterialDefinition() = default;
- MaterialDefinition(const MaterialDefinition&) = delete;
+ MaterialDefinition(const MaterialDefinition&) = delete;
MaterialDefinition& operator=(const MaterialDefinition&) = delete;
- MaterialDefinition(MaterialDefinition&&) = default;
+ MaterialDefinition(MaterialDefinition&&) = default;
MaterialDefinition& operator=(MaterialDefinition&&) = default;
/**
bool mNeedNormalTexture = true;
bool mDoubleSided = false;
+ bool mIsOpaque = true;
+ bool mIsMask = false;
+
std::vector<TextureStage> mTextureStages;
};
} // namespace Scene3D
} // namespace Dali
-#endif //DALI_SCENE3D_LOADER_MATERIAL_DEFINITION_H
+#endif // DALI_SCENE3D_LOADER_MATERIAL_DEFINITION_H
DALI_ASSERT_DEBUG(descriptor.mStride > descriptor.mElementSizeHint);
const uint32_t diff = descriptor.mStride - descriptor.mElementSizeHint;
uint32_t readSize = 0;
- while(readSize < descriptor.mLength &&
+ uint32_t totalSize = (descriptor.mLength / descriptor.mElementSizeHint) * descriptor.mStride;
+ while(readSize < totalSize &&
source.read(reinterpret_cast<char*>(target), descriptor.mElementSizeHint) &&
source.seekg(diff, std::istream::cur))
{
readSize += descriptor.mStride;
target += descriptor.mElementSizeHint;
}
- return readSize == descriptor.mLength;
+ return readSize == totalSize;
}
}
uint32_t MeshDefinition::Blob::GetBufferSize() const
{
- return IsConsecutive() ? mLength : (mLength * mElementSizeHint / mStride);
+ return mLength;
}
void MeshDefinition::Blob::ComputeMinMax(uint32_t numComponents, uint32_t count, float* values)
actor.RegisterProperty(IBL_INTENSITY_STRING.data(), resources.mEnvironmentMaps[envIdx].first.mIblIntensity);
actor.RegisterProperty(IBL_Y_DIRECTION.data(), resources.mEnvironmentMaps[envIdx].first.mYDirection);
- float opaque = 0.0f;
- float mask = 0.0f;
+ float opaque = matDef.mIsOpaque ? 1.0f : 0.0f;
+ float mask = matDef.mIsMask ? 1.0f : 0.0f;
float alphaCutoff = matDef.GetAlphaCutoff();
- if(!MaskMatch(matDef.mFlags, MaterialDefinition::TRANSPARENCY))
- {
- opaque = 1.0f;
- }
- else
- {
- if(alphaCutoff > 0.f)
- {
- mask = 1.0f;
- }
- }
+
actor.RegisterProperty("uOpaque", opaque);
actor.RegisterProperty("uMask", mask);
actor.RegisterProperty("uAlphaThreshold", alphaCutoff);
hash.Add("EMIS" /*SIVE*/);
}
+ if(MaskMatch(materialDef.mFlags, MaterialDefinition::SPECULAR))
+ {
+ hash.Add("SPECTEX");
+ }
+
+ if(MaskMatch(materialDef.mFlags, MaterialDefinition::SPECULAR_COLOR))
+ {
+ hash.Add("SPECCOLTEX");
+ }
+
if(MaskMatch(materialDef.mFlags, MaterialDefinition::GLTF_CHANNELS))
{
hash.Add("GLTF" /*_CHANNELS*/);
shaderDef.mDefines.push_back("SSS");
}
- if(MaskMatch(materialDef.mFlags, MaterialDefinition::SPECULAR))
+ if(MaskMatch(materialDef.mFlags, MaterialDefinition::OCCLUSION))
{
- shaderDef.mDefines.push_back("MATERIAL_SPECULAR_TEXTURE");
+ shaderDef.mDefines.push_back("OCCLUSION");
}
- if(MaskMatch(materialDef.mFlags, MaterialDefinition::SPECULAR_COLOR))
+ if(MaskMatch(materialDef.mFlags, MaterialDefinition::EMISSIVE))
{
- shaderDef.mDefines.push_back("MATERIAL_SPECULAR_COLOR_TEXTURE");
+ shaderDef.mDefines.push_back("EMISSIVE");
}
- if(MaskMatch(materialDef.mFlags, MaterialDefinition::OCCLUSION))
+ if(MaskMatch(materialDef.mFlags, MaterialDefinition::SPECULAR))
{
- shaderDef.mDefines.push_back("OCCLUSION");
+ shaderDef.mDefines.push_back("MATERIAL_SPECULAR_TEXTURE");
}
- if(MaskMatch(materialDef.mFlags, MaterialDefinition::EMISSIVE))
+ if(MaskMatch(materialDef.mFlags, MaterialDefinition::SPECULAR_COLOR))
{
- shaderDef.mDefines.push_back("EMISSIVE");
+ shaderDef.mDefines.push_back("MATERIAL_SPECULAR_COLOR_TEXTURE");
}
if(MaskMatch(materialDef.mFlags, MaterialDefinition::GLTF_CHANNELS))