#include <dali/public-api/common/stage.h>
#include <dali/devel-api/adaptor-framework/bitmap-loader.h>
#include <dali/devel-api/adaptor-framework/file-loader.h>
+#include <dali/devel-api/scripting/enum-helper.h>
+#include <dali/devel-api/scripting/scripting.h>
#include <fstream>
//INTERNAL INCLUDES
+#include <dali-toolkit/devel-api/visuals/visual-properties-devel.h>
+#include <dali-toolkit/internal/visuals/visual-base-data-impl.h>
#include <dali-toolkit/internal/visuals/visual-string-constants.h>
-#include <dali-toolkit/internal/visuals/visual-data-impl.h>
namespace Dali
{
GLOSS_INDEX = 2u
};
+//Property names
+const char * const OBJECT_URL_NAME( "objectUrl" );
+const char * const MATERIAL_URL_NAME( "materialUrl" );
+const char * const TEXTURES_PATH_NAME( "texturesPath" );
+const char * const SHADING_MODE_NAME( "shadingMode" );
+const char * const USE_MIPMAPPING_NAME( "useMipmapping" );
+const char * const USE_SOFT_NORMALS_NAME( "useSoftNormals" );
+const char * const LIGHT_POSITION_NAME( "lightPosition" );
+
+//Shading mode
+DALI_ENUM_TO_STRING_TABLE_BEGIN( SHADING_MODE )
+DALI_ENUM_TO_STRING_WITH_SCOPE( Toolkit::MeshVisual::ShadingMode, TEXTURELESS_WITH_DIFFUSE_LIGHTING )
+DALI_ENUM_TO_STRING_WITH_SCOPE( Toolkit::MeshVisual::ShadingMode, TEXTURED_WITH_SPECULAR_LIGHTING )
+DALI_ENUM_TO_STRING_WITH_SCOPE( Toolkit::MeshVisual::ShadingMode, TEXTURED_WITH_DETAILED_SPECULAR_LIGHTING )
+DALI_ENUM_TO_STRING_TABLE_END( SHADING_MODE )
+
//Shader properties
const char * const OBJECT_MATRIX_UNIFORM_NAME( "uObjectMatrix" );
const char * const STAGE_OFFSET_UNIFORM_NAME( "uStageOffset" );
-const char * const SHADER_TYPE_TEXTURELESS( "TEXTURELESS" );
-const char * const SHADER_TYPE_DIFFUSE_TEXTURE( "DIFFUSE_TEXTURE" );
-const char * const SHADER_TYPE_ALL_TEXTURES( "ALL_TEXTURES" );
-
//Shaders
//If a shader requires certain textures, they must be listed in order,
//as detailed in the TextureIndex enum documentation.
uniform mediump vec3 lightPosition;\n
uniform mediump vec2 uStageOffset;\n
+ //Visual size and offset
+ uniform mediump vec2 offset;\n
+ uniform mediump vec2 size;\n
+ uniform mediump vec4 offsetSizeMode;\n
+ uniform mediump vec2 origin;\n
+ uniform mediump vec2 anchorPoint;\n
+
+ vec4 ComputeVertexPosition()\n
+ {\n
+ vec2 visualSize = mix(uSize.xy*size, size, offsetSizeMode.zw );\n
+ float scaleFactor = min( visualSize.x, visualSize.y );\n
+ vec3 originFlipY = vec3(origin.x, -origin.y, 0.0);
+ vec3 anchorPointFlipY = vec3( anchorPoint.x, -anchorPoint.y, 0.0);
+ vec3 offset = vec3( ( offset / uSize.xy ) * offsetSizeMode.xy + offset * (1.0-offsetSizeMode.xy), 0.0) * vec3(1.0,-1.0,1.0);\n
+ return vec4( (aPosition + anchorPointFlipY)*scaleFactor + (offset + originFlipY)*uSize, 1.0 );\n
+ }\n
+
void main()\n
{\n
- vec4 normalisedVertexPosition = vec4( aPosition * min( uSize.x, uSize.y ), 1.0 );\n
+ vec4 normalisedVertexPosition = ComputeVertexPosition();\n
vec4 vertexPosition = uObjectMatrix * normalisedVertexPosition;\n
vertexPosition = uMvpMatrix * vertexPosition;\n
precision mediump float;\n
varying mediump vec3 vIllumination;\n
uniform lowp vec4 uColor;\n
+ uniform lowp vec3 mixColor;\n
+ uniform lowp float opacity;\n
+ uniform lowp float preMultipliedAlpha;\n
+ lowp vec4 visualMixColor()\n
+ {\n
+ return vec4( mixColor * mix( 1.0, opacity, preMultipliedAlpha ), opacity );\n
+ }\n
void main()\n
{\n
- gl_FragColor = vec4( vIllumination.rgb * uColor.rgb, uColor.a );\n
+ gl_FragColor = vec4( vIllumination.rgb * uColor.rgb, uColor.a ) * visualMixColor();\n
}\n
);
uniform mediump vec3 lightPosition;\n
uniform mediump vec2 uStageOffset;\n
+ //Visual size and offset
+ uniform mediump vec2 offset;\n
+ uniform mediump vec2 size;\n
+ uniform mediump vec4 offsetSizeMode;\n
+ uniform mediump vec2 origin;\n
+ uniform mediump vec2 anchorPoint;\n
+
+ vec4 ComputeVertexPosition()\n
+ {\n
+ vec2 visualSize = mix(uSize.xy*size, size, offsetSizeMode.zw );\n
+ float scaleFactor = min( visualSize.x, visualSize.y );\n
+ vec3 originFlipY = vec3(origin.x, -origin.y, 0.0);
+ vec3 anchorPointFlipY = vec3( anchorPoint.x, -anchorPoint.y, 0.0);
+ vec3 offset = vec3( ( offset / uSize.xy ) * offsetSizeMode.xy + offset * (1.0-offsetSizeMode.xy), 0.0) * vec3(1.0,-1.0,1.0);\n
+ return vec4( (aPosition + anchorPointFlipY)*scaleFactor + (offset + originFlipY)*uSize, 1.0 );\n
+ }\n
+
void main()
{\n
- vec4 normalisedVertexPosition = vec4( aPosition * min( uSize.x, uSize.y ), 1.0 );\n
+ vec4 normalisedVertexPosition = ComputeVertexPosition();\n
vec4 vertexPosition = uObjectMatrix * normalisedVertexPosition;\n
vertexPosition = uMvpMatrix * vertexPosition;\n
varying mediump float vSpecular;\n
uniform sampler2D sDiffuse;\n
uniform lowp vec4 uColor;\n
+ uniform lowp vec3 mixColor;\n
+ uniform lowp float opacity;\n
+ uniform lowp float preMultipliedAlpha;\n
+ lowp vec4 visualMixColor()\n
+ {\n
+ return vec4( mixColor * mix( 1.0, opacity, preMultipliedAlpha ), opacity );\n
+ }\n
void main()\n
{\n
vec4 texture = texture2D( sDiffuse, vTexCoord );\n
- gl_FragColor = vec4( vIllumination.rgb * texture.rgb * uColor.rgb + vSpecular * 0.3, texture.a * uColor.a );\n
+ vec4 visualMixColor = visualMixColor();\n
+ gl_FragColor = vec4( vIllumination.rgb * texture.rgb * uColor.rgb * visualMixColor.rgb + vSpecular * 0.3, texture.a * uColor.a * visualMixColor.a );\n
}\n
);
uniform mediump mat4 uObjectMatrix;\n
uniform mediump vec3 lightPosition;\n
uniform mediump vec2 uStageOffset;\n
+
+ //Visual size and offset
+ uniform mediump vec2 offset;\n
+ uniform mediump vec2 size;\n
+ uniform mediump vec4 offsetSizeMode;\n
+ uniform mediump vec2 origin;\n
+ uniform mediump vec2 anchorPoint;\n
+
+ vec4 ComputeVertexPosition()\n
+ {\n
+ vec2 visualSize = mix(uSize.xy*size, size, offsetSizeMode.zw );\n
+ float scaleFactor = min( visualSize.x, visualSize.y );\n
+ vec3 originFlipY = vec3(origin.x, -origin.y, 0.0);
+ vec3 anchorPointFlipY = vec3( anchorPoint.x, -anchorPoint.y, 0.0);
+ vec3 offset = vec3( ( offset / uSize.xy ) * offsetSizeMode.xy + offset * (1.0-offsetSizeMode.xy), 0.0) * vec3(1.0,-1.0,1.0);\n
+ return vec4( (aPosition + anchorPointFlipY)*scaleFactor + (offset + originFlipY)*uSize, 1.0 );\n
+ }\n
+
void main()
{\n
- vec4 normalisedVertexPosition = vec4( aPosition * min( uSize.x, uSize.y ), 1.0 );\n
+ vec4 normalisedVertexPosition = ComputeVertexPosition();\n
vec4 vertexPosition = uObjectMatrix * normalisedVertexPosition;\n
vertexPosition = uMvpMatrix * vertexPosition;\n
uniform sampler2D sNormal;\n
uniform sampler2D sGloss;\n
uniform lowp vec4 uColor;\n
+ uniform lowp vec3 mixColor;\n
+ uniform lowp float opacity;\n
+ uniform lowp float preMultipliedAlpha;\n
+ lowp vec4 visualMixColor()\n
+ {\n
+ return vec4( mixColor * mix( 1.0, opacity, preMultipliedAlpha ), opacity );\n
+ }\n
void main()\n
{\n
vec4 texture = texture2D( sDiffuse, vTexCoord );\n
vec3 normal = normalize( texture2D( sNormal, vTexCoord ).xyz * 2.0 - 1.0 );\n
vec4 glossMap = texture2D( sGloss, vTexCoord );\n
+ vec4 visualMixColor = visualMixColor();\n
float lightDiffuse = max( 0.0, dot( normal, normalize( vLightDirection ) ) );\n
lightDiffuse = lightDiffuse * 0.5 + 0.5;\n
float shininess = pow ( max ( dot ( normalize( vHalfVector ), normal ), 0.0 ), 16.0 ) ;
- gl_FragColor = vec4( texture.rgb * uColor.rgb * lightDiffuse + shininess * glossMap.rgb, texture.a * uColor.a );\n
+ gl_FragColor = vec4( texture.rgb * uColor.rgb * visualMixColor.rgb * lightDiffuse + shininess * glossMap.rgb, texture.a * uColor.a * visualMixColor.a );\n
}\n
);
-} // namespace
+} // unnamed namespace
+
+MeshVisualPtr MeshVisual::New( VisualFactoryCache& factoryCache, const Property::Map& properties )
+{
+ MeshVisualPtr meshVisualPtr( new MeshVisual( factoryCache ) );
+ meshVisualPtr->SetProperties( properties );
+ return meshVisualPtr;
+}
MeshVisual::MeshVisual( VisualFactoryCache& factoryCache )
-: Visual( factoryCache ),
- mShaderType( ALL_TEXTURES ),
+: Visual::Base( factoryCache ),
+ mShadingMode( Toolkit::MeshVisual::ShadingMode::TEXTURED_WITH_DETAILED_SPECULAR_LIGHTING ),
mUseTexture( true ),
mUseMipmapping( true ),
mUseSoftNormals( true )
{
}
-void MeshVisual::DoInitialize( Actor& actor, const Property::Map& propertyMap )
+void MeshVisual::DoSetProperties( const Property::Map& propertyMap )
{
- Property::Value* objectUrl = propertyMap.Find( OBJECT_URL );
- if( !objectUrl || !objectUrl->Get( mObjectUrl ) )
+ for( Property::Map::SizeType iter = 0; iter < propertyMap.Count(); ++iter )
{
- DALI_LOG_ERROR( "Fail to provide object URL to the MeshVisual object.\n" );
- }
-
- Property::Value* materialUrl = propertyMap.Find( MATERIAL_URL );
- if( !materialUrl || !materialUrl->Get( mMaterialUrl ) || mMaterialUrl.empty() )
- {
- mUseTexture = false;
- }
-
- Property::Value* imagesUrl = propertyMap.Find( TEXTURES_PATH );
- if( !imagesUrl || !imagesUrl->Get( mTexturesPath ) )
- {
- //Default behaviour is to assume files are in the same directory,
- // or have their locations detailed in full when supplied.
- mTexturesPath.clear();
- }
-
- Property::Value* shaderType = propertyMap.Find( SHADER_TYPE );
- if( shaderType )
- {
- std::string shaderTypeString;
- if( shaderType->Get( shaderTypeString ) )
+ KeyValuePair keyValue = propertyMap.GetKeyValue( iter );
+ if( keyValue.first.type == Property::Key::INDEX )
+ {
+ DoSetProperty( keyValue.first.indexKey, keyValue.second );
+ }
+ else
{
- if( shaderTypeString == SHADER_TYPE_TEXTURELESS )
+ if( keyValue.first == OBJECT_URL_NAME )
{
- mShaderType = TEXTURELESS;
+ DoSetProperty( Toolkit::MeshVisual::Property::OBJECT_URL, keyValue.second );
}
- else if( shaderTypeString == SHADER_TYPE_DIFFUSE_TEXTURE )
+ else if( keyValue.first == MATERIAL_URL_NAME )
{
- mShaderType = DIFFUSE_TEXTURE;
+ DoSetProperty( Toolkit::MeshVisual::Property::MATERIAL_URL, keyValue.second );
}
- else if( shaderTypeString == SHADER_TYPE_ALL_TEXTURES )
+ else if( keyValue.first == TEXTURES_PATH_NAME )
{
- mShaderType = ALL_TEXTURES;
+ DoSetProperty( Toolkit::MeshVisual::Property::TEXTURES_PATH, keyValue.second );
}
- else
+ else if( keyValue.first == SHADING_MODE_NAME )
+ {
+ DoSetProperty( Toolkit::MeshVisual::Property::SHADING_MODE, keyValue.second );
+ }
+ else if( keyValue.first == USE_MIPMAPPING_NAME )
{
- DALI_LOG_ERROR( "Unknown shader type provided to the MeshVisual object.\n");
+ DoSetProperty( Toolkit::MeshVisual::Property::USE_MIPMAPPING, keyValue.second );
+ }
+ else if( keyValue.first == USE_SOFT_NORMALS_NAME )
+ {
+ DoSetProperty( Toolkit::MeshVisual::Property::USE_SOFT_NORMALS, keyValue.second );
+ }
+ else if( keyValue.first == LIGHT_POSITION_NAME )
+ {
+ DoSetProperty( Toolkit::MeshVisual::Property::LIGHT_POSITION, keyValue.second );
}
}
}
- Property::Value* useMipmapping = propertyMap.Find( USE_MIPMAPPING );
- if( useMipmapping )
- {
- useMipmapping->Get( mUseMipmapping );
- }
-
- Property::Value* useSoftNormals = propertyMap.Find( USE_SOFT_NORMALS );
- if( useSoftNormals )
+ if( mMaterialUrl.empty() )
{
- useSoftNormals->Get( mUseSoftNormals );
+ mUseTexture = false;
}
- Property::Value* lightPosition = propertyMap.Find( LIGHT_POSITION_UNIFORM_NAME );
- if( lightPosition )
+ if( mLightPosition == Vector3::ZERO )
{
- if( !lightPosition->Get( mLightPosition ) )
- {
- DALI_LOG_ERROR( "Invalid value passed for light position in MeshRenderer object.\n" );
- mLightPosition = Vector3::ZERO;
- }
- }
- else
- {
- //Default behaviour is to place the light directly in front of the object,
+ // Default behaviour is to place the light directly in front of the object,
// at a reasonable distance to light everything on screen.
Stage stage = Stage::GetCurrent();
}
}
-void MeshVisual::SetSize( const Vector2& size )
-{
- Visual::SetSize( size );
-
- // ToDo: renderer responds to the size change
-}
-
-void MeshVisual::SetClipRect( const Rect<int>& clipRect )
+void MeshVisual::DoSetProperty( Property::Index index, const Property::Value& value )
{
- Visual::SetClipRect( clipRect );
-
- //ToDo: renderer responds to the clipRect change
+ switch( index )
+ {
+ case Toolkit::MeshVisual::Property::OBJECT_URL:
+ {
+ if( !value.Get( mObjectUrl ) )
+ {
+ DALI_LOG_ERROR("MeshVisual: property objectUrl is the wrong type, use STRING\n");
+ }
+ break;
+ }
+ case Toolkit::MeshVisual::Property::MATERIAL_URL:
+ {
+ if( ! value.Get( mMaterialUrl ) )
+ {
+ DALI_LOG_ERROR("MeshVisual: property materialUrl is the wrong type, use STRING\n");
+ }
+ break;
+ }
+ case Toolkit::MeshVisual::Property::TEXTURES_PATH:
+ {
+ if( ! value.Get( mTexturesPath ) )
+ {
+ mTexturesPath.clear();
+ }
+ break;
+ }
+ case Toolkit::MeshVisual::Property::SHADING_MODE:
+ {
+ Scripting::GetEnumerationProperty( value, SHADING_MODE_TABLE, SHADING_MODE_TABLE_COUNT, mShadingMode );
+ break;
+ }
+ case Toolkit::MeshVisual::Property::USE_MIPMAPPING:
+ {
+ if( !value.Get( mUseMipmapping ) )
+ {
+ DALI_LOG_ERROR("MeshVisual: property useMipmapping is the wrong type, use BOOLEAN\n");
+ }
+ break;
+ }
+ case Toolkit::MeshVisual::Property::USE_SOFT_NORMALS:
+ {
+ if( !value.Get( mUseSoftNormals ) )
+ {
+ DALI_LOG_ERROR("MeshVisual: property useSoftNormals is the wrong type, use BOOLEAN\n");
+ }
+ break;
+ }
+ case Toolkit::MeshVisual::Property::LIGHT_POSITION:
+ {
+ if( !value.Get( mLightPosition ) )
+ {
+ mLightPosition = Vector3::ZERO;
+ DALI_LOG_ERROR("MeshVisual: property lightPosition is the wrong type, use VECTOR3\n");
+ }
+ break;
+ }
+ }
}
-void MeshVisual::SetOffset( const Vector2& offset )
+void MeshVisual::OnSetTransform()
{
- //ToDo: renderer applies the offset
+ if( mImpl->mRenderer )
+ {
+ mImpl->mTransform.RegisterUniforms( mImpl->mRenderer, Direction::LEFT_TO_RIGHT );
+ }
}
void MeshVisual::DoSetOnStage( Actor& actor )
{
InitializeRenderer();
+
+ actor.AddRenderer( mImpl->mRenderer );
}
void MeshVisual::DoCreatePropertyMap( Property::Map& map ) const
{
map.Clear();
- map.Insert( RENDERER_TYPE, MESH_RENDERER );
- map.Insert( OBJECT_URL, mObjectUrl );
- map.Insert( MATERIAL_URL, mMaterialUrl );
- map.Insert( TEXTURES_PATH, mTexturesPath );
-
- std::string shaderTypeString;
- switch( mShaderType )
- {
- case ALL_TEXTURES:
- {
- shaderTypeString = SHADER_TYPE_ALL_TEXTURES;
- break;
- }
-
- case DIFFUSE_TEXTURE:
- {
- shaderTypeString = SHADER_TYPE_DIFFUSE_TEXTURE;
- break;
- }
-
- case TEXTURELESS:
- {
- shaderTypeString = SHADER_TYPE_TEXTURELESS;
- break;
- }
- }
- map.Insert( SHADER_TYPE, shaderTypeString );
-
- map.Insert( USE_MIPMAPPING, mUseMipmapping );
- map.Insert( USE_SOFT_NORMALS, mUseSoftNormals );
- map.Insert( LIGHT_POSITION_UNIFORM_NAME, mLightPosition );
+ map.Insert( Toolkit::DevelVisual::Property::TYPE, Toolkit::Visual::MESH );
+ map.Insert( Toolkit::MeshVisual::Property::OBJECT_URL, mObjectUrl );
+ map.Insert( Toolkit::MeshVisual::Property::MATERIAL_URL, mMaterialUrl );
+ map.Insert( Toolkit::MeshVisual::Property::TEXTURES_PATH, mTexturesPath );
+ map.Insert( Toolkit::MeshVisual::Property::SHADING_MODE, mShadingMode );
+ map.Insert( Toolkit::MeshVisual::Property::USE_MIPMAPPING, mUseMipmapping );
+ map.Insert( Toolkit::MeshVisual::Property::USE_SOFT_NORMALS, mUseSoftNormals );
+ map.Insert( Toolkit::MeshVisual::Property::LIGHT_POSITION, mLightPosition );
}
void MeshVisual::InitializeRenderer()
mImpl->mRenderer = Renderer::New( mGeometry, mShader );
mImpl->mRenderer.SetTextures( mTextureSet );
mImpl->mRenderer.SetProperty( Renderer::Property::DEPTH_WRITE_MODE, DepthWriteMode::ON );
+ mImpl->mRenderer.SetProperty( Renderer::Property::DEPTH_TEST_MODE, DepthTestMode::ON );
+
+ //Register transform properties
+ mImpl->mTransform.RegisterUniforms( mImpl->mRenderer, Direction::LEFT_TO_RIGHT );
}
void MeshVisual::SupplyEmptyGeometry()
mShader = Shader::New( SIMPLE_VERTEX_SHADER, SIMPLE_FRAGMENT_SHADER );
mImpl->mRenderer = Renderer::New( mGeometry, mShader );
- DALI_LOG_ERROR( "Initialisation error in mesh renderer.\n" );
+ DALI_LOG_ERROR( "Initialisation error in mesh visual.\n" );
}
void MeshVisual::UpdateShaderUniforms()
scaleMatrix.SetIdentityAndScale( Vector3( 1.0, -1.0, 1.0 ) );
mShader.RegisterProperty( STAGE_OFFSET_UNIFORM_NAME, Vector2( width, height ) / 2.0f );
- mShader.RegisterProperty( LIGHT_POSITION_UNIFORM_NAME, mLightPosition );
+ mShader.RegisterProperty( LIGHT_POSITION_NAME, mLightPosition );
mShader.RegisterProperty( OBJECT_MATRIX_UNIFORM_NAME, scaleMatrix );
}
void MeshVisual::CreateShader()
{
- if( mShaderType == ALL_TEXTURES )
+ if( mShadingMode == Toolkit::MeshVisual::ShadingMode::TEXTURED_WITH_DETAILED_SPECULAR_LIGHTING )
{
mShader = Shader::New( NORMAL_MAP_VERTEX_SHADER, NORMAL_MAP_FRAGMENT_SHADER );
}
- else if( mShaderType == DIFFUSE_TEXTURE )
+ else if( mShadingMode == Toolkit::MeshVisual::ShadingMode::TEXTURED_WITH_SPECULAR_LIGHTING )
{
mShader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER );
}
//Determine if we need to use a simpler shader to handle the provided data
if( !mUseTexture || !mObjLoader.IsDiffuseMapPresent() )
{
- mShaderType = TEXTURELESS;
+ mShadingMode = Toolkit::MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING;
}
- else if( mShaderType == ALL_TEXTURES && (!mObjLoader.IsNormalMapPresent() || !mObjLoader.IsSpecularMapPresent()) )
+ else if( mShadingMode == Toolkit::MeshVisual::ShadingMode::TEXTURED_WITH_DETAILED_SPECULAR_LIGHTING && (!mObjLoader.IsNormalMapPresent() || !mObjLoader.IsSpecularMapPresent()) )
{
- mShaderType = DIFFUSE_TEXTURE;
+ mShadingMode = Toolkit::MeshVisual::ShadingMode::TEXTURED_WITH_SPECULAR_LIGHTING;
}
int objectProperties = 0;
- if( mShaderType == DIFFUSE_TEXTURE ||
- mShaderType == ALL_TEXTURES )
+ if( mShadingMode == Toolkit::MeshVisual::ShadingMode::TEXTURED_WITH_SPECULAR_LIGHTING ||
+ mShadingMode == Toolkit::MeshVisual::ShadingMode::TEXTURED_WITH_DETAILED_SPECULAR_LIGHTING )
{
objectProperties |= ObjLoader::TEXTURE_COORDINATES;
}
- if( mShaderType == ALL_TEXTURES )
+ if( mShadingMode == Toolkit::MeshVisual::ShadingMode::TEXTURED_WITH_DETAILED_SPECULAR_LIGHTING )
{
objectProperties |= ObjLoader::TANGENTS | ObjLoader::BINORMALS;
}
return true;
}
- DALI_LOG_ERROR( "Failed to load geometry in mesh renderer.\n" );
+ DALI_LOG_ERROR( "Failed to load geometry in mesh visual.\n" );
return false;
}
return true;
}
- DALI_LOG_ERROR( "Failed to find object to load in mesh renderer.\n" );
+ DALI_LOG_ERROR( "Failed to find object to load in mesh visual.\n" );
return false;
}
return true;
}
- DALI_LOG_ERROR( "Failed to find texture set to load in mesh renderer.\n" );
+ DALI_LOG_ERROR( "Failed to find texture set to load in mesh visual.\n" );
mUseTexture = false;
return false;
}
{
mTextureSet = TextureSet::New();
- if( mShaderType != TEXTURELESS )
+ if( mShadingMode != Toolkit::MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING )
{
Sampler sampler = Sampler::New();
if( mUseMipmapping )
}
else
{
- DALI_LOG_ERROR( "Failed to load diffuse map texture in mesh renderer.\n");
+ DALI_LOG_ERROR( "Failed to load diffuse map texture in mesh visual.\n");
return false;
}
}
- if( !mNormalTextureUrl.empty() && ( mShaderType == ALL_TEXTURES ) )
+ if( !mNormalTextureUrl.empty() && ( mShadingMode == Toolkit::MeshVisual::ShadingMode::TEXTURED_WITH_DETAILED_SPECULAR_LIGHTING ) )
{
std::string imageUrl = mTexturesPath + mNormalTextureUrl;
}
else
{
- DALI_LOG_ERROR( "Failed to load normal map texture in mesh renderer.\n");
+ DALI_LOG_ERROR( "Failed to load normal map texture in mesh visual.\n");
return false;
}
}
- if( !mGlossTextureUrl.empty() && ( mShaderType == ALL_TEXTURES ) )
+ if( !mGlossTextureUrl.empty() && ( mShadingMode == Toolkit::MeshVisual::ShadingMode::TEXTURED_WITH_DETAILED_SPECULAR_LIGHTING ) )
{
std::string imageUrl = mTexturesPath + mGlossTextureUrl;
}
else
{
- DALI_LOG_ERROR( "Failed to load gloss map texture in mesh renderer.\n");
+ DALI_LOG_ERROR( "Failed to load gloss map texture in mesh visual.\n");
return false;
}
}
projects / platform / core / uifw / dali-toolkit.git / blobdiff