Fix for obj-loader
[platform/core/uifw/dali-toolkit.git] / dali-toolkit / internal / controls / model3d-view / model3d-view-impl.cpp
1 /*
2  * Copyright (c) 2017 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
18 // CLASS HEADER
19 #include "model3d-view-impl.h"
20
21 // EXTERNAL INCLUDES
22 #include <dali/public-api/object/type-registry.h>
23 #include <dali/public-api/animation/constraint.h>
24 #include <dali/public-api/animation/constraint-source.h>
25 #include <dali/public-api/animation/constraints.h>
26 #include <dali/public-api/object/type-registry-helper.h>
27 #include <dali-toolkit/public-api/controls/model3d-view/model3d-view.h>
28 #include <dali/public-api/images/resource-image.h>
29 #include <dali/devel-api/adaptor-framework/file-loader.h>
30 #include <dali/devel-api/adaptor-framework/image-loading.h>
31
32 // INTERNAL INCLUDES
33 #include <dali-toolkit/internal/controls/model3d-view/obj-loader.h>
34
35 namespace Dali
36 {
37
38 namespace Toolkit
39 {
40
41 namespace Internal
42 {
43
44 namespace
45 {
46
47 // Texture indices are constants.
48 enum TextureIndex
49 {
50   DIFFUSE_TEXTURE_INDEX,
51   NORMAL_TEXTURE_INDEX,
52   GLOSS_TEXTURE_INDEX
53 };
54
55 /**
56  * @brief Loads a texture from a file.
57  * @param[in] imageUrl The URL of the file
58  * @return A texture if loading succeeds, an empty handle otherwise
59  */
60 Texture LoadTexture( const char* imageUrl )
61 {
62   Texture texture;
63   Devel::PixelBuffer pixelBuffer = LoadImageFromFile( imageUrl );
64   if( pixelBuffer )
65   {
66     texture = Texture::New( TextureType::TEXTURE_2D, pixelBuffer.GetPixelFormat(), pixelBuffer.GetWidth(), pixelBuffer.GetHeight() );
67     PixelData pixelData = Devel::PixelBuffer::Convert( pixelBuffer );
68     texture.Upload( pixelData );
69     texture.GenerateMipmaps();
70   }
71
72   return texture;
73 }
74
75 // Type registration
76 BaseHandle Create()
77 {
78   return Toolkit::Model3dView::New();
79 }
80
81 // Setup properties, signals and actions using the type-registry.
82 DALI_TYPE_REGISTRATION_BEGIN( Toolkit::Model3dView, Toolkit::Control, Create );
83
84 DALI_PROPERTY_REGISTRATION( Toolkit, Model3dView, "geometryUrl",  STRING, GEOMETRY_URL)
85 DALI_PROPERTY_REGISTRATION( Toolkit, Model3dView, "materialUrl",  STRING, MATERIAL_URL)
86 DALI_PROPERTY_REGISTRATION( Toolkit, Model3dView, "imagesUrl",  STRING, IMAGES_URL)
87 DALI_PROPERTY_REGISTRATION( Toolkit, Model3dView, "illuminationType",  INTEGER, ILLUMINATION_TYPE)
88 DALI_PROPERTY_REGISTRATION( Toolkit, Model3dView, "texture0Url",  STRING, TEXTURE0_URL)
89 DALI_PROPERTY_REGISTRATION( Toolkit, Model3dView, "texture1Url",  STRING, TEXTURE1_URL)
90 DALI_PROPERTY_REGISTRATION( Toolkit, Model3dView, "texture2Url",  STRING, TEXTURE2_URL)
91
92 DALI_ANIMATABLE_PROPERTY_REGISTRATION( Toolkit, Model3dView, "lightPosition",  VECTOR3, LIGHT_POSITION)
93
94 DALI_TYPE_REGISTRATION_END()
95
96
97 #define MAKE_SHADER(A)#A
98
99 //  Diffuse illumination shader
100
101 const char* SIMPLE_VERTEX_SHADER = MAKE_SHADER(
102   attribute highp vec3 aPosition;\n
103   attribute highp vec2 aTexCoord;\n
104   attribute highp vec3 aNormal;\n
105   varying mediump vec3 vIllumination;\n
106   uniform mediump vec3 uSize;\n
107   uniform mediump mat4 uMvpMatrix;\n
108   uniform mediump mat4 uModelView;\n
109   uniform mediump mat3 uNormalMatrix;
110   uniform mediump mat4 uObjectMatrix;\n
111   uniform mediump vec3 uLightPosition;\n
112
113   void main()\n
114   {\n
115     vec4 vertexPosition = vec4(aPosition*min(uSize.x, uSize.y), 1.0);\n
116     vertexPosition = uObjectMatrix * vertexPosition;\n
117     vertexPosition = uMvpMatrix * vertexPosition;\n
118
119     //Illumination in Model-View space - Transform attributes and uniforms\n
120     vec4 vertPos = uModelView * vec4(aPosition.xyz, 1.0);\n
121     vec3 normal = uNormalMatrix * aNormal;\n
122     vec4 lightPos = uModelView * vec4(uLightPosition, 1.0);\n
123     vec3 vecToLight = normalize( lightPos.xyz - vertPos.xyz );\n
124
125     float lightDiffuse = max( dot( vecToLight, normal ), 0.0 );\n
126     vIllumination = vec3(lightDiffuse * 0.5 + 0.5);\n
127
128     gl_Position = vertexPosition;\n
129   }\n
130 );
131
132 const char* SIMPLE_FRAGMENT_SHADER = MAKE_SHADER(
133   precision mediump float;\n
134   varying mediump vec3 vIllumination;\n
135   uniform lowp vec4 uColor;\n
136
137   void main()\n
138   {\n
139     gl_FragColor = vec4( vIllumination.rgb * uColor.rgb, uColor.a);\n
140   }\n
141 );
142
143 //  Diffuse and specular illumination shader with albedo texture
144
145 const char* VERTEX_SHADER = MAKE_SHADER(
146   attribute highp vec3 aPosition;\n
147   attribute highp vec2 aTexCoord;\n
148   attribute highp vec3 aNormal;\n
149   varying mediump vec2 vTexCoord;\n
150   varying mediump vec3 vIllumination;\n
151   varying mediump float vSpecular;\n
152   uniform mediump vec3 uSize;\n
153   uniform mediump mat4 uMvpMatrix;\n
154   uniform mediump mat4 uModelView;
155   uniform mediump mat3 uNormalMatrix;
156   uniform mediump mat4 uObjectMatrix;\n
157   uniform mediump vec3 uLightPosition;\n
158
159   void main()
160   {\n
161     vec4 vertexPosition = vec4(aPosition*min(uSize.x, uSize.y), 1.0);\n
162     vertexPosition = uObjectMatrix * vertexPosition;\n
163     vertexPosition = uMvpMatrix * vertexPosition;\n
164
165     //Illumination in Model-View space - Transform attributes and uniforms\n
166     vec4 vertPos = uModelView * vec4(aPosition.xyz, 1.0);\n
167     vec4 lightPos = uModelView * vec4(uLightPosition, 1.0);\n
168     vec3 normal = normalize(uNormalMatrix * aNormal);\n
169
170     vec3 vecToLight = normalize( lightPos.xyz - vertPos.xyz );\n
171     vec3 viewDir = normalize(-vertPos.xyz);
172
173     vec3 halfVector = normalize(viewDir + vecToLight);
174
175     float lightDiffuse = dot( vecToLight, normal );\n
176     lightDiffuse = max(0.0,lightDiffuse);\n
177     vIllumination = vec3(lightDiffuse * 0.5 + 0.5);\n
178
179     vec3 reflectDir = reflect(-vecToLight, normal);
180     vSpecular = pow( max(dot(reflectDir, viewDir), 0.0), 4.0 );
181
182     vTexCoord = aTexCoord;\n
183     gl_Position = vertexPosition;\n
184   }\n
185 );
186
187 const char* FRAGMENT_SHADER = MAKE_SHADER(
188   precision mediump float;\n
189   varying mediump vec2 vTexCoord;\n
190   varying mediump vec3 vIllumination;\n
191   varying mediump float vSpecular;\n
192   uniform sampler2D sDiffuse;\n
193   uniform lowp vec4 uColor;\n
194
195   void main()\n
196   {\n
197     vec4 texture = texture2D( sDiffuse, vTexCoord );\n
198     gl_FragColor = vec4( vIllumination.rgb * texture.rgb * uColor.rgb + vSpecular * 0.3, texture.a * uColor.a);\n
199   }\n
200 );
201
202 //  Diffuse and specular illumination shader with albedo texture, normal map and gloss map shader
203
204 const char* NRMMAP_VERTEX_SHADER = MAKE_SHADER(
205   attribute highp vec3 aPosition;\n
206   attribute highp vec2 aTexCoord;\n
207   attribute highp vec3 aNormal;\n
208   attribute highp vec3 aTangent;\n
209   attribute highp vec3 aBiNormal;\n
210   varying mediump vec2 vTexCoord;\n
211   varying mediump vec3 vLightDirection;\n
212   varying mediump vec3 vHalfVector;\n
213   uniform mediump vec3 uSize;\n
214   uniform mediump mat4 uMvpMatrix;\n
215   uniform mediump mat4 uModelView;
216   uniform mediump mat3 uNormalMatrix;
217   uniform mediump mat4 uObjectMatrix;\n
218   uniform mediump vec3 uLightPosition;\n
219
220   void main()
221   {\n
222     vec4 vertexPosition = vec4(aPosition*min(uSize.x, uSize.y), 1.0);\n
223     vertexPosition = uObjectMatrix * vertexPosition;\n
224     vertexPosition = uMvpMatrix * vertexPosition;\n
225
226     vec4 vertPos = uModelView * vec4(aPosition.xyz, 1.0);\n
227     vec4 lightPos = uModelView * vec4(uLightPosition, 1.0);\n
228
229     vec3 tangent = normalize(uNormalMatrix * aTangent);
230     vec3 binormal = normalize(uNormalMatrix * aBiNormal);
231     vec3 normal = normalize(uNormalMatrix * aNormal);
232
233     vec3 vecToLight = normalize( lightPos.xyz - vertPos.xyz );\n
234     vLightDirection.x = dot(vecToLight, tangent);
235     vLightDirection.y = dot(vecToLight, binormal);
236     vLightDirection.z = dot(vecToLight, normal);
237
238     vec3 viewDir = normalize(-vertPos.xyz);
239     vec3 halfVector = normalize(viewDir + vecToLight);
240     vHalfVector.x = dot(halfVector, tangent);
241     vHalfVector.y = dot(halfVector, binormal);
242     vHalfVector.z = dot(halfVector, normal);
243
244     vTexCoord = aTexCoord;\n
245     gl_Position = vertexPosition;\n
246   }\n
247 );
248
249 const char* NRMMAP_FRAGMENT_SHADER = MAKE_SHADER(
250   precision mediump float;\n
251   varying mediump vec2 vTexCoord;\n
252   varying mediump vec3 vLightDirection;\n
253   varying mediump vec3 vHalfVector;\n
254   uniform sampler2D sDiffuse;\n
255   uniform sampler2D sNormal;\n
256   uniform sampler2D sGloss;\n
257   uniform lowp vec4 uColor;\n
258
259   void main()\n
260   {\n
261     vec4 texture = texture2D( sDiffuse, vTexCoord );\n
262     vec3 normal = normalize( texture2D( sNormal, vTexCoord ).xyz * 2.0 - 1.0 );\n
263     vec4 glossMap = texture2D( sGloss, vTexCoord );\n
264
265     float lightDiffuse = max( 0.0, dot( normal, normalize(vLightDirection) ) );\n
266     lightDiffuse = lightDiffuse * 0.5 + 0.5;\n
267
268     float shininess = pow (max (dot (normalize( vHalfVector ), normal), 0.0), 16.0)  ;
269
270     gl_FragColor = vec4( texture.rgb * uColor.rgb * lightDiffuse + shininess * glossMap.rgb, texture.a * uColor.a);\n
271   }\n
272 );
273
274
275 } // anonymous namespace
276
277 using namespace Dali;
278
279 Model3dView::Model3dView()
280 : Control( ControlBehaviour( CONTROL_BEHAVIOUR_DEFAULT ) )
281 {
282   mIlluminationType = Toolkit::Model3dView::DIFFUSE_WITH_NORMAL_MAP;
283
284   mCameraFOV = Math::PI_OVER_180 * 45.f;
285
286   mControlSize = Vector2(100.,100.);
287 }
288
289 Model3dView::~Model3dView()
290 {
291 }
292
293 Toolkit::Model3dView Model3dView::New()
294 {
295   Model3dView* impl = new Model3dView();
296
297   Dali::Toolkit::Model3dView handle = Dali::Toolkit::Model3dView( *impl );
298
299   // Second-phase init of the implementation
300   // This can only be done after the CustomActor connection has been made...
301   impl->Initialize();
302
303   return handle;
304 }
305
306 void Model3dView::SetProperty( BaseObject* object, Property::Index index, const Property::Value& value )
307 {
308   Toolkit::Model3dView model3dView = Toolkit::Model3dView::DownCast( Dali::BaseHandle( object ) );
309
310   if( model3dView )
311   {
312     Model3dView& impl( GetImpl( model3dView ) );
313     switch( index )
314     {
315       case Toolkit::Model3dView::Property::GEOMETRY_URL:
316       {
317         if( value.Get(impl.mObjUrl) )
318         {
319           impl.LoadGeometry();
320           impl.CreateGeometry();
321         }
322         break;
323       }
324       case Toolkit::Model3dView::Property::MATERIAL_URL:
325       {
326         if( value.Get(impl.mTextureSetUrl) )
327         {
328           impl.LoadMaterial();
329           impl.CreateMaterial();
330           impl.LoadTextures();
331         }
332         break;
333       }
334       case Toolkit::Model3dView::Property::IMAGES_URL:
335       {
336         if( value.Get(impl.mImagesUrl) )
337         {
338           impl.LoadTextures();
339         }
340         break;
341       }
342       case Toolkit::Model3dView::Property::ILLUMINATION_TYPE:
343       {
344         int illuminationType;
345         if( value.Get(illuminationType) )
346         {
347           impl.mIlluminationType = Toolkit::Model3dView::IlluminationType(illuminationType);
348           impl.CreateGeometry();
349           impl.CreateMaterial();
350           impl.LoadTextures();
351         }
352         break;
353       }
354       case Toolkit::Model3dView::Property::TEXTURE0_URL:
355       {
356         value.Get(impl.mTexture0Url);
357         break;
358       }
359       case Toolkit::Model3dView::Property::TEXTURE1_URL:
360       {
361         value.Get(impl.mTexture1Url);
362         break;
363       }
364       case Toolkit::Model3dView::Property::TEXTURE2_URL:
365       {
366         value.Get(impl.mTexture2Url);
367         break;
368       }
369     }
370   }
371 }
372
373 Property::Value Model3dView::GetProperty( BaseObject* object, Property::Index index )
374 {
375   Property::Value value;
376
377   Toolkit::Model3dView model3dView = Toolkit::Model3dView::DownCast( Dali::BaseHandle( object ) );
378
379   if( model3dView )
380   {
381     Model3dView& impl( GetImpl( model3dView ) );
382     switch( index )
383     {
384       case Toolkit::Model3dView::Property::GEOMETRY_URL:
385       {
386         value = impl.mObjUrl;
387         break;
388       }
389       case Toolkit::Model3dView::Property::MATERIAL_URL:
390       {
391         value = impl.mTextureSetUrl;
392         break;
393       }
394       case Toolkit::Model3dView::Property::IMAGES_URL:
395       {
396         value = impl.mImagesUrl;
397         break;
398       }
399       case Toolkit::Model3dView::Property::ILLUMINATION_TYPE:
400       {
401         value = int(impl.mIlluminationType);
402         break;
403       }
404       case Toolkit::Model3dView::Property::TEXTURE0_URL:
405       {
406         value = impl.mTexture0Url;
407         break;
408       }
409       case Toolkit::Model3dView::Property::TEXTURE1_URL:
410       {
411         value = impl.mTexture1Url;
412         break;
413       }
414       case Toolkit::Model3dView::Property::TEXTURE2_URL:
415       {
416         value = impl.mTexture2Url;
417         break;
418       }
419     }
420   }
421
422   return value;
423 }
424
425 /////////////////////////////////////////////////////////////
426
427
428 void Model3dView::OnStageConnection( int depth )
429 {
430   CustomActor self = Self();
431   self.AddRenderer( mRenderer );
432
433   if( mObjLoader.IsSceneLoaded() )
434   {
435     mMesh = mObjLoader.CreateGeometry( GetShaderProperties( mIlluminationType ), true );
436
437     CreateMaterial();
438     LoadTextures();
439
440     mRenderer.SetGeometry( mMesh );
441
442     //create constraint for lightPosition Property with uLightPosition in the shader
443     Vector3 lightPosition( 0, 0, 0 );
444     Dali::Property::Index lightProperty = mShader.RegisterProperty( "uLightPosition", lightPosition );
445     Constraint constraint = Constraint::New<Vector3>( mShader, lightProperty, EqualToConstraint() );
446     constraint.AddSource( Source( self, Toolkit::Model3dView::Property::LIGHT_POSITION ) );
447     constraint.Apply();
448   }
449
450   Control::OnStageConnection( depth );
451 }
452
453 ///////////////////////////////////////////////////////////
454 //
455 // Private methods
456 //
457
458 void Model3dView::OnInitialize()
459 {
460   //Create empty versions of the geometry and material so we always have a Renderer
461   Geometry mesh = Geometry::New();
462   Shader shader = Shader::New( SIMPLE_VERTEX_SHADER, SIMPLE_FRAGMENT_SHADER );
463   mRenderer = Renderer::New( mesh, shader );
464
465 }
466
467 void Model3dView::LoadGeometry()
468 {
469   //Load file in adaptor
470   std::streampos fileSize;
471   Dali::Vector<char> fileContent;
472
473   if (FileLoader::ReadFile(mObjUrl,fileSize,fileContent,FileLoader::TEXT))
474   {
475     mObjLoader.ClearArrays();
476     mObjLoader.LoadObject(fileContent.Begin(), fileSize);
477
478     //Get size information from the obj loaded
479     mSceneCenter = mObjLoader.GetCenter();
480     mSceneSize = mObjLoader.GetSize();
481   }
482   else
483   {
484     //Error
485   }
486 }
487
488 void Model3dView::LoadMaterial()
489 {
490   //Load file in adaptor
491   std::streampos fileSize;
492   Dali::Vector<char> fileContent;
493
494   if( FileLoader::ReadFile(mTextureSetUrl, fileSize, fileContent, FileLoader::TEXT) )
495   {
496     mObjLoader.LoadMaterial(fileContent.Begin(), fileSize, mTexture0Url, mTexture1Url, mTexture2Url);
497   }
498   else
499   {
500     //Error
501   }
502 }
503
504 void Model3dView::Load()
505 {
506   LoadGeometry();
507   LoadMaterial();
508 }
509
510 void Model3dView::OnRelayout( const Vector2& size, RelayoutContainer& container )
511 {
512   UpdateView();
513 }
514
515 void Model3dView::UpdateView()
516 {
517   if( mObjLoader.IsSceneLoaded() )
518   {
519     //The object will always be centred
520
521     Matrix scaleMatrix;
522     scaleMatrix.SetIdentityAndScale(Vector3(1.0, -1.0, 1.0));
523
524     mShader.RegisterProperty( "uObjectMatrix", scaleMatrix );
525   }
526 }
527
528 void Model3dView::CreateGeometry()
529 {
530   if( mObjLoader.IsSceneLoaded() )
531   {
532     mMesh = mObjLoader.CreateGeometry( GetShaderProperties( mIlluminationType ), true );
533
534     if( mRenderer )
535     {
536       mRenderer.SetGeometry( mMesh );
537       mRenderer.SetProperty( Renderer::Property::DEPTH_WRITE_MODE, DepthWriteMode::ON );
538       mRenderer.SetProperty( Renderer::Property::DEPTH_TEST_MODE, DepthTestMode::ON );
539     }
540   }
541 }
542
543 void Model3dView::UpdateShaderUniforms()
544 {
545   if( mShader )
546   {
547     //Update shader related info, uniforms, etc. for the new shader
548     UpdateView();
549
550     Vector3 lightPosition( 0, 0, 0 );
551     Dali::Property::Index lightProperty = mShader.RegisterProperty( "uLightPosition", lightPosition );
552
553     CustomActor self = Self();
554
555     //create constraint for lightPosition Property with uLightPosition in the shader
556     if( lightProperty )
557     {
558       Constraint constraint = Constraint::New<Vector3>( mShader, lightProperty, EqualToConstraint() );
559       constraint.AddSource( Source( self, Toolkit::Model3dView::Property::LIGHT_POSITION ) );
560       constraint.Apply();
561     }
562   }
563 }
564
565 void Model3dView::CreateMaterial()
566 {
567   if( mObjLoader.IsMaterialLoaded() && (mTexture0Url != "") && mObjLoader.IsTexturePresent() )
568   {
569     if( (mTexture2Url != "") && (mTexture1Url != "") && (mIlluminationType == Toolkit::Model3dView::DIFFUSE_WITH_NORMAL_MAP) )
570     {
571       mShader = Shader::New( NRMMAP_VERTEX_SHADER, NRMMAP_FRAGMENT_SHADER );
572     }
573     else if( mIlluminationType == Toolkit::Model3dView::DIFFUSE_WITH_TEXTURE ||
574              mIlluminationType == Toolkit::Model3dView::DIFFUSE_WITH_NORMAL_MAP )
575     {
576       mShader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER );
577     }
578     else
579     {
580       mShader = Shader::New( SIMPLE_VERTEX_SHADER, SIMPLE_FRAGMENT_SHADER );
581     }
582   }
583   else
584   {
585     mShader = Shader::New( SIMPLE_VERTEX_SHADER, SIMPLE_FRAGMENT_SHADER );
586   }
587
588   mTextureSet = TextureSet::New();
589
590   if( mRenderer )
591   {
592     mRenderer.SetTextures( mTextureSet );
593     mRenderer.SetShader( mShader );
594     mRenderer.SetProperty( Renderer::Property::FACE_CULLING_MODE, FaceCullingMode::BACK );
595   }
596
597   UpdateShaderUniforms();
598 }
599
600 void Model3dView::LoadTextures()
601 {
602   if( !mTextureSet )
603   {
604     return;
605   }
606
607   Sampler sampler = Sampler::New();
608   sampler.SetFilterMode( FilterMode::LINEAR_MIPMAP_LINEAR, FilterMode::LINEAR_MIPMAP_LINEAR );
609
610   // Setup diffuse texture.
611   if( !mTexture0Url.empty() && ( mIlluminationType != Toolkit::Model3dView::DIFFUSE ) )
612   {
613     std::string imageUrl = mImagesUrl + mTexture0Url;
614
615     //Load textures
616     Texture diffuseTexture = LoadTexture( imageUrl.c_str() );
617     if( diffuseTexture )
618     {
619       mTextureSet.SetTexture( DIFFUSE_TEXTURE_INDEX, diffuseTexture );
620       mTextureSet.SetSampler( DIFFUSE_TEXTURE_INDEX, sampler );
621     }
622   }
623
624   if( mIlluminationType == Toolkit::Model3dView::DIFFUSE_WITH_NORMAL_MAP )
625   {
626     // Setup normal map texture.
627     if( !mTexture1Url.empty() )
628     {
629       std::string imageUrl = mImagesUrl + mTexture1Url;
630
631       //Load textures
632       Texture normalTexture = LoadTexture( imageUrl.c_str() );
633       if( normalTexture )
634       {
635         mTextureSet.SetTexture( NORMAL_TEXTURE_INDEX, normalTexture );
636         mTextureSet.SetSampler( NORMAL_TEXTURE_INDEX, sampler );
637       }
638     }
639     if( !mTexture2Url.empty() )
640     {
641       // Setup gloss map texture.
642       std::string imageUrl = mImagesUrl + mTexture2Url;
643
644       //Load textures
645       Texture glossTexture = LoadTexture( imageUrl.c_str() );
646       if( glossTexture )
647       {
648         mTextureSet.SetTexture( GLOSS_TEXTURE_INDEX, glossTexture );
649         mTextureSet.SetSampler( GLOSS_TEXTURE_INDEX, sampler );
650       }
651     }
652   }
653 }
654
655 int Model3dView::GetShaderProperties( Toolkit::Model3dView::IlluminationType illuminationType )
656 {
657   int objectProperties = 0;
658
659   if( illuminationType == Toolkit::Model3dView::DIFFUSE_WITH_TEXTURE ||
660       illuminationType == Toolkit::Model3dView::DIFFUSE_WITH_NORMAL_MAP )
661   {
662     objectProperties |= ObjLoader::TEXTURE_COORDINATES;
663   }
664
665   if( illuminationType == Toolkit::Model3dView::DIFFUSE_WITH_NORMAL_MAP )
666   {
667     objectProperties |= ObjLoader::TANGENTS | ObjLoader::BINORMALS;
668   }
669
670   return objectProperties;
671 }
672
673 } // namespace Internal
674 } // namespace Toolkit
675 } // namespace Dali