2 * Copyright (c) 2016 Samsung Electronics Co., Ltd.
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
19 #include "mesh-visual.h"
22 #include <dali/integration-api/debug.h>
23 #include <dali/public-api/common/stage.h>
24 #include <dali/devel-api/adaptor-framework/bitmap-loader.h>
25 #include <dali/devel-api/adaptor-framework/file-loader.h>
26 #include <dali/devel-api/scripting/enum-helper.h>
27 #include <dali/devel-api/scripting/scripting.h>
31 #include <dali-toolkit/devel-api/visuals/visual-properties-devel.h>
32 #include <dali-toolkit/internal/visuals/visual-base-data-impl.h>
33 #include <dali-toolkit/internal/visuals/visual-string-constants.h>
41 * @brief Loads a texture from a file
42 * @param[in] imageUrl The url of the file
43 * @param[in] generateMipmaps Indicates whether to generate mipmaps for the texture
44 * @return A texture if loading succeeds, an empty handle otherwise
46 Texture LoadTexture( const char* imageUrl, bool generateMipmaps )
49 Dali::BitmapLoader loader = Dali::BitmapLoader::New( imageUrl );
51 PixelData pixelData = loader.GetPixelData();
54 texture = Texture::New( TextureType::TEXTURE_2D, pixelData.GetPixelFormat(), pixelData.GetWidth(), pixelData.GetHeight() );
55 texture.Upload( pixelData );
59 texture.GenerateMipmaps();
76 //Defines ordering of textures for shaders.
77 //All shaders, if including certain texture types, must include them in the same order.
78 //Within the texture set for the renderer, textures are ordered in the same manner.
87 const char * const OBJECT_URL_NAME( "objectUrl" );
88 const char * const MATERIAL_URL_NAME( "materialUrl" );
89 const char * const TEXTURES_PATH_NAME( "texturesPath" );
90 const char * const SHADING_MODE_NAME( "shadingMode" );
91 const char * const USE_MIPMAPPING_NAME( "useMipmapping" );
92 const char * const USE_SOFT_NORMALS_NAME( "useSoftNormals" );
93 const char * const LIGHT_POSITION_NAME( "lightPosition" );
96 DALI_ENUM_TO_STRING_TABLE_BEGIN( SHADING_MODE )
97 DALI_ENUM_TO_STRING_WITH_SCOPE( Toolkit::MeshVisual::ShadingMode, TEXTURELESS_WITH_DIFFUSE_LIGHTING )
98 DALI_ENUM_TO_STRING_WITH_SCOPE( Toolkit::MeshVisual::ShadingMode, TEXTURED_WITH_SPECULAR_LIGHTING )
99 DALI_ENUM_TO_STRING_WITH_SCOPE( Toolkit::MeshVisual::ShadingMode, TEXTURED_WITH_DETAILED_SPECULAR_LIGHTING )
100 DALI_ENUM_TO_STRING_TABLE_END( SHADING_MODE )
103 const char * const OBJECT_MATRIX_UNIFORM_NAME( "uObjectMatrix" );
104 const char * const STAGE_OFFSET_UNIFORM_NAME( "uStageOffset" );
107 //If a shader requires certain textures, they must be listed in order,
108 //as detailed in the TextureIndex enum documentation.
110 //A basic shader that doesn't use textures at all.
111 const char* SIMPLE_VERTEX_SHADER = DALI_COMPOSE_SHADER(
112 attribute highp vec3 aPosition;\n
113 attribute highp vec3 aNormal;\n
114 varying mediump vec3 vIllumination;\n
115 uniform mediump vec3 uSize;\n
116 uniform mediump mat4 uMvpMatrix;\n
117 uniform mediump mat4 uModelView;\n
118 uniform mediump mat4 uViewMatrix;\n
119 uniform mediump mat3 uNormalMatrix;
120 uniform mediump mat4 uObjectMatrix;\n
121 uniform mediump vec3 lightPosition;\n
122 uniform mediump vec2 uStageOffset;\n
124 //Visual size and offset
125 uniform mediump vec2 offset;\n
126 uniform mediump vec2 size;\n
127 uniform mediump vec4 offsetSizeMode;\n
128 uniform mediump vec2 origin;\n
129 uniform mediump vec2 anchorPoint;\n
131 vec4 ComputeVertexPosition()\n
133 vec2 visualSize = mix(uSize.xy*size, size, offsetSizeMode.zw );\n
134 float scaleFactor = min( visualSize.x, visualSize.y );\n
135 vec3 originFlipY = vec3(origin.x, -origin.y, 0.0);
136 vec3 anchorPointFlipY = vec3( anchorPoint.x, -anchorPoint.y, 0.0);
137 vec3 offset = vec3( ( offset / uSize.xy ) * offsetSizeMode.xy + offset * (1.0-offsetSizeMode.xy), 0.0) * vec3(1.0,-1.0,1.0);\n
138 return vec4( (aPosition + anchorPointFlipY)*scaleFactor + (offset + originFlipY)*uSize, 1.0 );\n
143 vec4 normalisedVertexPosition = ComputeVertexPosition();\n
144 vec4 vertexPosition = uObjectMatrix * normalisedVertexPosition;\n
145 vertexPosition = uMvpMatrix * vertexPosition;\n
147 //Illumination in Model-View space - Transform attributes and uniforms\n
148 vec4 mvVertexPosition = uModelView * normalisedVertexPosition;\n
149 vec3 normal = uNormalMatrix * mat3( uObjectMatrix ) * aNormal;\n
151 vec4 mvLightPosition = vec4( ( lightPosition.xy - uStageOffset ), lightPosition.z, 1.0 );\n
152 mvLightPosition = uViewMatrix * mvLightPosition;\n
153 vec3 vectorToLight = normalize( mvLightPosition.xyz - mvVertexPosition.xyz );\n
155 float lightDiffuse = max( dot( vectorToLight, normal ), 0.0 );\n
156 vIllumination = vec3( lightDiffuse * 0.5 + 0.5 );\n
158 gl_Position = vertexPosition;\n
162 //Fragment shader corresponding to the texture-less shader.
163 const char* SIMPLE_FRAGMENT_SHADER = DALI_COMPOSE_SHADER(
164 precision mediump float;\n
165 varying mediump vec3 vIllumination;\n
166 uniform lowp vec4 uColor;\n
167 uniform lowp vec3 mixColor;\n
168 uniform lowp float opacity;\n
169 uniform lowp float preMultipliedAlpha;\n
171 lowp vec4 visualMixColor()\n
173 return vec4( mixColor * mix( 1.0, opacity, preMultipliedAlpha ), opacity );\n
177 gl_FragColor = vec4( vIllumination.rgb * uColor.rgb, uColor.a ) * visualMixColor();\n
181 //Diffuse and specular illumination shader with albedo texture. Texture is index 0.
182 const char* VERTEX_SHADER = DALI_COMPOSE_SHADER(
183 attribute highp vec3 aPosition;\n
184 attribute highp vec2 aTexCoord;\n
185 attribute highp vec3 aNormal;\n
186 varying mediump vec2 vTexCoord;\n
187 varying mediump vec3 vIllumination;\n
188 varying mediump float vSpecular;\n
189 uniform mediump vec3 uSize;\n
190 uniform mediump mat4 uMvpMatrix;\n
191 uniform mediump mat4 uModelView;
192 uniform mediump mat4 uViewMatrix;\n
193 uniform mediump mat3 uNormalMatrix;
194 uniform mediump mat4 uObjectMatrix;\n
195 uniform mediump vec3 lightPosition;\n
196 uniform mediump vec2 uStageOffset;\n
198 //Visual size and offset
199 uniform mediump vec2 offset;\n
200 uniform mediump vec2 size;\n
201 uniform mediump vec4 offsetSizeMode;\n
202 uniform mediump vec2 origin;\n
203 uniform mediump vec2 anchorPoint;\n
205 vec4 ComputeVertexPosition()\n
207 vec2 visualSize = mix(uSize.xy*size, size, offsetSizeMode.zw );\n
208 float scaleFactor = min( visualSize.x, visualSize.y );\n
209 vec3 originFlipY = vec3(origin.x, -origin.y, 0.0);
210 vec3 anchorPointFlipY = vec3( anchorPoint.x, -anchorPoint.y, 0.0);
211 vec3 offset = vec3( ( offset / uSize.xy ) * offsetSizeMode.xy + offset * (1.0-offsetSizeMode.xy), 0.0) * vec3(1.0,-1.0,1.0);\n
212 return vec4( (aPosition + anchorPointFlipY)*scaleFactor + (offset + originFlipY)*uSize, 1.0 );\n
217 vec4 normalisedVertexPosition = ComputeVertexPosition();\n
218 vec4 vertexPosition = uObjectMatrix * normalisedVertexPosition;\n
219 vertexPosition = uMvpMatrix * vertexPosition;\n
221 //Illumination in Model-View space - Transform attributes and uniforms\n
222 vec4 mvVertexPosition = uModelView * normalisedVertexPosition;\n
223 vec3 normal = normalize( uNormalMatrix * mat3( uObjectMatrix ) * aNormal );\n
225 vec4 mvLightPosition = vec4( ( lightPosition.xy - uStageOffset ), lightPosition.z, 1.0 );\n
226 mvLightPosition = uViewMatrix * mvLightPosition;\n
227 vec3 vectorToLight = normalize( mvLightPosition.xyz - mvVertexPosition.xyz );\n
229 vec3 viewDirection = normalize( -mvVertexPosition.xyz );
231 float lightDiffuse = dot( vectorToLight, normal );\n
232 lightDiffuse = max( 0.0,lightDiffuse );\n
233 vIllumination = vec3( lightDiffuse * 0.5 + 0.5 );\n
235 vec3 reflectDirection = reflect( -vectorToLight, normal );
236 vSpecular = pow( max( dot( reflectDirection, viewDirection ), 0.0 ), 4.0 );
238 vTexCoord = aTexCoord;\n
239 gl_Position = vertexPosition;\n
243 //Fragment shader corresponding to the diffuse and specular illumination shader with albedo texture
244 const char* FRAGMENT_SHADER = DALI_COMPOSE_SHADER(
245 precision mediump float;\n
246 varying mediump vec2 vTexCoord;\n
247 varying mediump vec3 vIllumination;\n
248 varying mediump float vSpecular;\n
249 uniform sampler2D sDiffuse;\n
250 uniform lowp vec4 uColor;\n
251 uniform lowp vec3 mixColor;\n
252 uniform lowp float opacity;\n
253 uniform lowp float preMultipliedAlpha;\n
255 lowp vec4 visualMixColor()\n
257 return vec4( mixColor * mix( 1.0, opacity, preMultipliedAlpha ), opacity );\n
261 vec4 texture = texture2D( sDiffuse, vTexCoord );\n
262 vec4 visualMixColor = visualMixColor();\n
263 gl_FragColor = vec4( vIllumination.rgb * texture.rgb * uColor.rgb * visualMixColor.rgb + vSpecular * 0.3, texture.a * uColor.a * visualMixColor.a );\n
267 //Diffuse and specular illumination shader with albedo texture, normal map and gloss map shader.
268 //Diffuse (albedo) texture is index 0, normal is 1, gloss is 2. They must be declared in this order.
269 const char* NORMAL_MAP_VERTEX_SHADER = DALI_COMPOSE_SHADER(
270 attribute highp vec3 aPosition;\n
271 attribute highp vec2 aTexCoord;\n
272 attribute highp vec3 aNormal;\n
273 attribute highp vec3 aTangent;\n
274 attribute highp vec3 aBiNormal;\n
275 varying mediump vec2 vTexCoord;\n
276 varying mediump vec3 vLightDirection;\n
277 varying mediump vec3 vHalfVector;\n
278 uniform mediump vec3 uSize;\n
279 uniform mediump mat4 uMvpMatrix;\n
280 uniform mediump mat4 uModelView;
281 uniform mediump mat4 uViewMatrix;\n
282 uniform mediump mat3 uNormalMatrix;
283 uniform mediump mat4 uObjectMatrix;\n
284 uniform mediump vec3 lightPosition;\n
285 uniform mediump vec2 uStageOffset;\n
287 //Visual size and offset
288 uniform mediump vec2 offset;\n
289 uniform mediump vec2 size;\n
290 uniform mediump vec4 offsetSizeMode;\n
291 uniform mediump vec2 origin;\n
292 uniform mediump vec2 anchorPoint;\n
294 vec4 ComputeVertexPosition()\n
296 vec2 visualSize = mix(uSize.xy*size, size, offsetSizeMode.zw );\n
297 float scaleFactor = min( visualSize.x, visualSize.y );\n
298 vec3 originFlipY = vec3(origin.x, -origin.y, 0.0);
299 vec3 anchorPointFlipY = vec3( anchorPoint.x, -anchorPoint.y, 0.0);
300 vec3 offset = vec3( ( offset / uSize.xy ) * offsetSizeMode.xy + offset * (1.0-offsetSizeMode.xy), 0.0) * vec3(1.0,-1.0,1.0);\n
301 return vec4( (aPosition + anchorPointFlipY)*scaleFactor + (offset + originFlipY)*uSize, 1.0 );\n
306 vec4 normalisedVertexPosition = ComputeVertexPosition();\n
307 vec4 vertexPosition = uObjectMatrix * normalisedVertexPosition;\n
308 vertexPosition = uMvpMatrix * vertexPosition;\n
310 vec4 mvVertexPosition = uModelView * normalisedVertexPosition;\n
312 vec3 tangent = normalize( uNormalMatrix * mat3( uObjectMatrix ) * aTangent );
313 vec3 binormal = normalize( uNormalMatrix * mat3( uObjectMatrix ) * aBiNormal );
314 vec3 normal = normalize( uNormalMatrix * mat3( uObjectMatrix ) * aNormal );
316 vec4 mvLightPosition = vec4( ( lightPosition.xy - uStageOffset ), lightPosition.z, 1.0 );\n
317 mvLightPosition = uViewMatrix * mvLightPosition;\n
318 vec3 vectorToLight = normalize( mvLightPosition.xyz - mvVertexPosition.xyz );\n
319 vLightDirection.x = dot( vectorToLight, tangent );
320 vLightDirection.y = dot( vectorToLight, binormal );
321 vLightDirection.z = dot( vectorToLight, normal );
323 vec3 viewDirection = normalize( -mvVertexPosition.xyz );
324 vec3 halfVector = normalize( viewDirection + vectorToLight );
325 vHalfVector.x = dot( halfVector, tangent );
326 vHalfVector.y = dot( halfVector, binormal );
327 vHalfVector.z = dot( halfVector, normal );
329 vTexCoord = aTexCoord;\n
330 gl_Position = vertexPosition;\n
334 //Fragment shader corresponding to the shader that uses all textures (diffuse, normal and gloss maps)
335 const char* NORMAL_MAP_FRAGMENT_SHADER = DALI_COMPOSE_SHADER(
336 precision mediump float;\n
337 varying mediump vec2 vTexCoord;\n
338 varying mediump vec3 vLightDirection;\n
339 varying mediump vec3 vHalfVector;\n
340 uniform sampler2D sDiffuse;\n
341 uniform sampler2D sNormal;\n
342 uniform sampler2D sGloss;\n
343 uniform lowp vec4 uColor;\n
344 uniform lowp vec3 mixColor;\n
345 uniform lowp float opacity;\n
346 uniform lowp float preMultipliedAlpha;\n
348 lowp vec4 visualMixColor()\n
350 return vec4( mixColor * mix( 1.0, opacity, preMultipliedAlpha ), opacity );\n
354 vec4 texture = texture2D( sDiffuse, vTexCoord );\n
355 vec3 normal = normalize( texture2D( sNormal, vTexCoord ).xyz * 2.0 - 1.0 );\n
356 vec4 glossMap = texture2D( sGloss, vTexCoord );\n
357 vec4 visualMixColor = visualMixColor();\n
359 float lightDiffuse = max( 0.0, dot( normal, normalize( vLightDirection ) ) );\n
360 lightDiffuse = lightDiffuse * 0.5 + 0.5;\n
362 float shininess = pow ( max ( dot ( normalize( vHalfVector ), normal ), 0.0 ), 16.0 ) ;
364 gl_FragColor = vec4( texture.rgb * uColor.rgb * visualMixColor.rgb * lightDiffuse + shininess * glossMap.rgb, texture.a * uColor.a * visualMixColor.a );\n
368 } // unnamed namespace
370 MeshVisualPtr MeshVisual::New( VisualFactoryCache& factoryCache, const Property::Map& properties )
372 MeshVisualPtr meshVisualPtr( new MeshVisual( factoryCache ) );
373 meshVisualPtr->SetProperties( properties );
374 return meshVisualPtr;
377 MeshVisual::MeshVisual( VisualFactoryCache& factoryCache )
378 : Visual::Base( factoryCache ),
379 mShadingMode( Toolkit::MeshVisual::ShadingMode::TEXTURED_WITH_DETAILED_SPECULAR_LIGHTING ),
381 mUseMipmapping( true ),
382 mUseSoftNormals( true )
386 MeshVisual::~MeshVisual()
390 void MeshVisual::DoSetProperties( const Property::Map& propertyMap )
392 for( Property::Map::SizeType iter = 0; iter < propertyMap.Count(); ++iter )
394 KeyValuePair keyValue = propertyMap.GetKeyValue( iter );
395 if( keyValue.first.type == Property::Key::INDEX )
397 DoSetProperty( keyValue.first.indexKey, keyValue.second );
401 if( keyValue.first == OBJECT_URL_NAME )
403 DoSetProperty( Toolkit::MeshVisual::Property::OBJECT_URL, keyValue.second );
405 else if( keyValue.first == MATERIAL_URL_NAME )
407 DoSetProperty( Toolkit::MeshVisual::Property::MATERIAL_URL, keyValue.second );
409 else if( keyValue.first == TEXTURES_PATH_NAME )
411 DoSetProperty( Toolkit::MeshVisual::Property::TEXTURES_PATH, keyValue.second );
413 else if( keyValue.first == SHADING_MODE_NAME )
415 DoSetProperty( Toolkit::MeshVisual::Property::SHADING_MODE, keyValue.second );
417 else if( keyValue.first == USE_MIPMAPPING_NAME )
419 DoSetProperty( Toolkit::MeshVisual::Property::USE_MIPMAPPING, keyValue.second );
421 else if( keyValue.first == USE_SOFT_NORMALS_NAME )
423 DoSetProperty( Toolkit::MeshVisual::Property::USE_SOFT_NORMALS, keyValue.second );
425 else if( keyValue.first == LIGHT_POSITION_NAME )
427 DoSetProperty( Toolkit::MeshVisual::Property::LIGHT_POSITION, keyValue.second );
432 if( mMaterialUrl.empty() )
437 if( mLightPosition == Vector3::ZERO )
439 // Default behaviour is to place the light directly in front of the object,
440 // at a reasonable distance to light everything on screen.
441 Stage stage = Stage::GetCurrent();
443 mLightPosition = Vector3( stage.GetSize().width / 2, stage.GetSize().height / 2, stage.GetSize().width * 5 );
447 void MeshVisual::DoSetProperty( Property::Index index, const Property::Value& value )
451 case Toolkit::MeshVisual::Property::OBJECT_URL:
453 if( !value.Get( mObjectUrl ) )
455 DALI_LOG_ERROR("MeshVisual: property objectUrl is the wrong type, use STRING\n");
459 case Toolkit::MeshVisual::Property::MATERIAL_URL:
461 if( ! value.Get( mMaterialUrl ) )
463 DALI_LOG_ERROR("MeshVisual: property materialUrl is the wrong type, use STRING\n");
467 case Toolkit::MeshVisual::Property::TEXTURES_PATH:
469 if( ! value.Get( mTexturesPath ) )
471 mTexturesPath.clear();
475 case Toolkit::MeshVisual::Property::SHADING_MODE:
477 Scripting::GetEnumerationProperty( value, SHADING_MODE_TABLE, SHADING_MODE_TABLE_COUNT, mShadingMode );
480 case Toolkit::MeshVisual::Property::USE_MIPMAPPING:
482 if( !value.Get( mUseMipmapping ) )
484 DALI_LOG_ERROR("MeshVisual: property useMipmapping is the wrong type, use BOOLEAN\n");
488 case Toolkit::MeshVisual::Property::USE_SOFT_NORMALS:
490 if( !value.Get( mUseSoftNormals ) )
492 DALI_LOG_ERROR("MeshVisual: property useSoftNormals is the wrong type, use BOOLEAN\n");
496 case Toolkit::MeshVisual::Property::LIGHT_POSITION:
498 if( !value.Get( mLightPosition ) )
500 mLightPosition = Vector3::ZERO;
501 DALI_LOG_ERROR("MeshVisual: property lightPosition is the wrong type, use VECTOR3\n");
508 void MeshVisual::OnSetTransform()
510 if( mImpl->mRenderer )
512 mImpl->mTransform.RegisterUniforms( mImpl->mRenderer, Direction::LEFT_TO_RIGHT );
516 void MeshVisual::DoSetOnStage( Actor& actor )
518 InitializeRenderer();
520 actor.AddRenderer( mImpl->mRenderer );
522 // Mesh loaded and ready to display
526 void MeshVisual::DoCreatePropertyMap( Property::Map& map ) const
529 map.Insert( Toolkit::DevelVisual::Property::TYPE, Toolkit::Visual::MESH );
530 map.Insert( Toolkit::MeshVisual::Property::OBJECT_URL, mObjectUrl );
531 map.Insert( Toolkit::MeshVisual::Property::MATERIAL_URL, mMaterialUrl );
532 map.Insert( Toolkit::MeshVisual::Property::TEXTURES_PATH, mTexturesPath );
533 map.Insert( Toolkit::MeshVisual::Property::SHADING_MODE, mShadingMode );
534 map.Insert( Toolkit::MeshVisual::Property::USE_MIPMAPPING, mUseMipmapping );
535 map.Insert( Toolkit::MeshVisual::Property::USE_SOFT_NORMALS, mUseSoftNormals );
536 map.Insert( Toolkit::MeshVisual::Property::LIGHT_POSITION, mLightPosition );
539 void MeshVisual::DoCreateInstancePropertyMap( Property::Map& map ) const
544 void MeshVisual::InitializeRenderer()
546 //Try to load the geometry from the file.
547 if( !LoadGeometry() )
549 SupplyEmptyGeometry();
553 //If a texture is used by the obj file, load the supplied material file.
554 if( mObjLoader.IsTexturePresent() && !mMaterialUrl.empty() )
556 if( !LoadMaterial() )
558 SupplyEmptyGeometry();
563 //Now that the required parts are loaded, create the geometry for the object.
564 if( !CreateGeometry() )
566 SupplyEmptyGeometry();
572 //Load the various texture files supplied by the material file.
573 if( !LoadTextures() )
575 SupplyEmptyGeometry();
579 mImpl->mRenderer = Renderer::New( mGeometry, mShader );
580 mImpl->mRenderer.SetTextures( mTextureSet );
581 mImpl->mRenderer.SetProperty( Renderer::Property::DEPTH_WRITE_MODE, DepthWriteMode::ON );
582 mImpl->mRenderer.SetProperty( Renderer::Property::DEPTH_TEST_MODE, DepthTestMode::ON );
584 //Register transform properties
585 mImpl->mTransform.RegisterUniforms( mImpl->mRenderer, Direction::LEFT_TO_RIGHT );
588 void MeshVisual::SupplyEmptyGeometry()
590 mGeometry = Geometry::New();
591 mShader = Shader::New( SIMPLE_VERTEX_SHADER, SIMPLE_FRAGMENT_SHADER );
592 mImpl->mRenderer = Renderer::New( mGeometry, mShader );
594 DALI_LOG_ERROR( "Initialisation error in mesh visual.\n" );
597 void MeshVisual::UpdateShaderUniforms()
599 Stage stage = Stage::GetCurrent();
600 float width = stage.GetSize().width;
601 float height = stage.GetSize().height;
604 scaleMatrix.SetIdentityAndScale( Vector3( 1.0, -1.0, 1.0 ) );
606 mShader.RegisterProperty( STAGE_OFFSET_UNIFORM_NAME, Vector2( width, height ) / 2.0f );
607 mShader.RegisterProperty( LIGHT_POSITION_NAME, mLightPosition );
608 mShader.RegisterProperty( OBJECT_MATRIX_UNIFORM_NAME, scaleMatrix );
611 void MeshVisual::CreateShader()
613 if( mShadingMode == Toolkit::MeshVisual::ShadingMode::TEXTURED_WITH_DETAILED_SPECULAR_LIGHTING )
615 mShader = Shader::New( NORMAL_MAP_VERTEX_SHADER, NORMAL_MAP_FRAGMENT_SHADER );
617 else if( mShadingMode == Toolkit::MeshVisual::ShadingMode::TEXTURED_WITH_SPECULAR_LIGHTING )
619 mShader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER );
623 mShader = Shader::New( SIMPLE_VERTEX_SHADER, SIMPLE_FRAGMENT_SHADER );
626 UpdateShaderUniforms();
629 bool MeshVisual::CreateGeometry()
631 //Determine if we need to use a simpler shader to handle the provided data
632 if( !mUseTexture || !mObjLoader.IsDiffuseMapPresent() )
634 mShadingMode = Toolkit::MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING;
636 else if( mShadingMode == Toolkit::MeshVisual::ShadingMode::TEXTURED_WITH_DETAILED_SPECULAR_LIGHTING && (!mObjLoader.IsNormalMapPresent() || !mObjLoader.IsSpecularMapPresent()) )
638 mShadingMode = Toolkit::MeshVisual::ShadingMode::TEXTURED_WITH_SPECULAR_LIGHTING;
641 int objectProperties = 0;
643 if( mShadingMode == Toolkit::MeshVisual::ShadingMode::TEXTURED_WITH_SPECULAR_LIGHTING ||
644 mShadingMode == Toolkit::MeshVisual::ShadingMode::TEXTURED_WITH_DETAILED_SPECULAR_LIGHTING )
646 objectProperties |= ObjLoader::TEXTURE_COORDINATES;
649 if( mShadingMode == Toolkit::MeshVisual::ShadingMode::TEXTURED_WITH_DETAILED_SPECULAR_LIGHTING )
651 objectProperties |= ObjLoader::TANGENTS | ObjLoader::BINORMALS;
654 //Create geometry with attributes required by shader.
655 mGeometry = mObjLoader.CreateGeometry( objectProperties, mUseSoftNormals );
662 DALI_LOG_ERROR( "Failed to load geometry in mesh visual.\n" );
666 bool MeshVisual::LoadGeometry()
668 std::streampos fileSize;
669 Dali::Vector<char> fileContent;
671 if( FileLoader::ReadFile( mObjectUrl, fileSize, fileContent, FileLoader::TEXT ) )
673 mObjLoader.ClearArrays();
674 mObjLoader.LoadObject( fileContent.Begin(), fileSize );
676 //Get size information from the obj loaded
677 mSceneCenter = mObjLoader.GetCenter();
678 mSceneSize = mObjLoader.GetSize();
683 DALI_LOG_ERROR( "Failed to find object to load in mesh visual.\n" );
687 bool MeshVisual::LoadMaterial()
689 std::streampos fileSize;
690 Dali::Vector<char> fileContent;
692 if( FileLoader::ReadFile( mMaterialUrl, fileSize, fileContent, FileLoader::TEXT ) )
694 //Load data into obj (usable) form
695 mObjLoader.LoadMaterial( fileContent.Begin(), fileSize, mDiffuseTextureUrl, mNormalTextureUrl, mGlossTextureUrl );
699 DALI_LOG_ERROR( "Failed to find texture set to load in mesh visual.\n" );
704 bool MeshVisual::LoadTextures()
706 mTextureSet = TextureSet::New();
708 if( mShadingMode != Toolkit::MeshVisual::ShadingMode::TEXTURELESS_WITH_DIFFUSE_LIGHTING )
710 Sampler sampler = Sampler::New();
713 sampler.SetFilterMode( FilterMode::LINEAR_MIPMAP_LINEAR, FilterMode::LINEAR_MIPMAP_LINEAR );
716 if( !mDiffuseTextureUrl.empty() )
718 std::string imageUrl = mTexturesPath + mDiffuseTextureUrl;
721 Texture diffuseTexture = LoadTexture( imageUrl.c_str(), mUseMipmapping );
724 mTextureSet.SetTexture( DIFFUSE_INDEX, diffuseTexture );
725 mTextureSet.SetSampler( DIFFUSE_INDEX, sampler );
729 DALI_LOG_ERROR( "Failed to load diffuse map texture in mesh visual.\n");
734 if( !mNormalTextureUrl.empty() && ( mShadingMode == Toolkit::MeshVisual::ShadingMode::TEXTURED_WITH_DETAILED_SPECULAR_LIGHTING ) )
736 std::string imageUrl = mTexturesPath + mNormalTextureUrl;
739 Texture normalTexture = LoadTexture( imageUrl.c_str(), mUseMipmapping );
742 mTextureSet.SetTexture( NORMAL_INDEX, normalTexture );
743 mTextureSet.SetSampler( NORMAL_INDEX, sampler );
747 DALI_LOG_ERROR( "Failed to load normal map texture in mesh visual.\n");
752 if( !mGlossTextureUrl.empty() && ( mShadingMode == Toolkit::MeshVisual::ShadingMode::TEXTURED_WITH_DETAILED_SPECULAR_LIGHTING ) )
754 std::string imageUrl = mTexturesPath + mGlossTextureUrl;
757 Texture glossTexture = LoadTexture( imageUrl.c_str(), mUseMipmapping );
760 mTextureSet.SetTexture( GLOSS_INDEX, glossTexture );
761 mTextureSet.SetSampler( GLOSS_INDEX, sampler );
765 DALI_LOG_ERROR( "Failed to load gloss map texture in mesh visual.\n");
773 } // namespace Internal
775 } // namespace Toolkit