diff --git a/Shaders/Materials/Lambertian/Lambertian.frag.glsl b/Shaders/Materials/Lambertian/Lambertian.frag.glsl
index 6611334bfad..302f2a05597 100644
--- a/Shaders/Materials/Lambertian/Lambertian.frag.glsl
+++ b/Shaders/Materials/Lambertian/Lambertian.frag.glsl
@@ -7,11 +7,21 @@ layout( location = 6 ) in vec3 in_lightVector;
 out vec4 out_color;
 
 void main() {
-    vec4 bc     = getBaseColor( material, getPerVertexTexCoord() );
-    vec3 normal = getWorldSpaceNormal();
+    vec4 bc            = getDiffuseColor( material, getPerVertexTexCoord() );
+    vec3 normalWorld   = getWorldSpaceNormal();
+    vec3 tangentWorld  = getWorldSpaceTangent();   // normalized tangent
+    vec3 binormalWorld = getWorldSpaceBiTangent(); // normalized bitangent
+
     // Computing attributes using dfdx or dfdy must be done before discarding fragments
     if ( toDiscard( material, bc ) ) discard;
 
+    vec3 lightDir = normalize( in_lightVector ); // incident direction
+    normalWorld   = getNormal( material,
+                               getPerVertexTexCoord(),
+                               normalWorld,
+                               tangentWorld,
+                               binormalWorld ); // normalized bump-mapped normal
+
     vec3 le   = lightContributionFrom( light, getWorldSpacePosition().xyz );
-    out_color = vec4( bc.rgb * dot( normal, normalize( in_lightVector ) ) * le, 1 );
+    out_color = vec4( (bc.rgb / Pi) * dot( normalWorld, lightDir ) * le, 1 );
 }
diff --git a/Shaders/Materials/Lambertian/Lambertian.glsl b/Shaders/Materials/Lambertian/Lambertian.glsl
index bb1f8df94d4..812db5b091e 100644
--- a/Shaders/Materials/Lambertian/Lambertian.glsl
+++ b/Shaders/Materials/Lambertian/Lambertian.glsl
@@ -4,9 +4,11 @@
 struct LambertianTextures {
     int hasColor;
     int hasMask;
+    int hasNormal;
 
     sampler2D color;
     sampler2D mask;
+    sampler2D normal;
 };
 
 struct Material {
@@ -17,8 +19,6 @@ struct Material {
 
 //------------------- VertexAttrib interface ---------------------
 vec4 getPerVertexBaseColor();
-vec3 getWorldSpaceNormal();
-#define DONT_USE_INPUT_TANGENT
 
 //----------------------------------------------------------------
 const float Pi = 3.141592653589793;
@@ -51,10 +51,18 @@ vec3 getSpecularColor( Material material, vec3 texCoord ) {
     return vec3( 0 );
 }
 
-// Return the world-space normal computed according to the microgeometry definition`
-// As no normal map is defined, return N
+// Return the world-space normal computed according to the microgeometry definition
 vec3 getNormal( Material material, vec3 texCoord, vec3 N, vec3 T, vec3 B ) {
-    return N;
+    if ( material.tex.hasNormal == 1 ) {
+        vec3 normalLocal = normalize( vec3( texture( material.tex.normal, texCoord.xy ) ) * 2 - 1 );
+        mat3 tbn;
+        tbn[0] = T;
+        tbn[1] = B;
+        tbn[2] = N;
+        return normalize( tbn * normalLocal );
+    } else {
+        return N;
+    }
 }
 
 // return true if the fragment must be condidered as transparent (either fully or partially)
diff --git a/Shaders/Materials/Lambertian/Lambertian.vert.glsl b/Shaders/Materials/Lambertian/Lambertian.vert.glsl
index bb0b82d5314..1139523c0a0 100644
--- a/Shaders/Materials/Lambertian/Lambertian.vert.glsl
+++ b/Shaders/Materials/Lambertian/Lambertian.vert.glsl
@@ -5,6 +5,7 @@
 // declare expected attributes
 layout( location = 0 ) in vec3 in_position;
 layout( location = 1 ) in vec3 in_normal;
+layout( location = 2 ) in vec3 in_tangent;
 layout( location = 4 ) in vec3 in_texcoord;
 layout( location = 5 ) in vec4 in_color;
 
@@ -17,6 +18,7 @@ layout( location = 0 ) out vec3 out_position;
 layout( location = 1 ) out vec3 out_normal;
 layout( location = 2 ) out vec3 out_texcoord;
 layout( location = 3 ) out vec3 out_vertexcolor;
+layout( location = 4 ) out vec3 out_tangent;
 layout( location = 6 ) out vec3 out_lightVector;
 
 // Main function for vertex shader
@@ -46,5 +48,8 @@ void main() {
     vec3 normal = mat3( transform.worldNormal ) * in_normal;
     out_normal  = normal;
 
+    vec3 tangent = mat3( transform.model ) * in_tangent;
+    out_tangent = tangent;
+
     out_lightVector = getLightDirection( light, out_position );
 }
diff --git a/examples/DrawPrimitives/AllPrimitivesComponent.cpp b/examples/DrawPrimitives/AllPrimitivesComponent.cpp
index 3437251299c..80abc24a2a0 100644
--- a/examples/DrawPrimitives/AllPrimitivesComponent.cpp
+++ b/examples/DrawPrimitives/AllPrimitivesComponent.cpp
@@ -693,35 +693,34 @@ void AllPrimitivesComponent::initialize() {
         data                 = l.loadFile( filename );
 #endif
         if ( data != nullptr ) {
-            auto geomData = data->getGeometryData();
+            const auto& geomData = data->getGeometryData();
 
             for ( const auto& gd : geomData ) {
                 std::shared_ptr<AttribArrayDisplayable> mesh { nullptr };
                 switch ( gd->getType() ) {
                 case Ra::Core::Asset::GeometryData::TRI_MESH:
                     mesh = std::shared_ptr<Mesh> {
-                        createMeshFromGeometryData<Geometry::TriangleMesh>( "logo", gd ) };
+                        createMeshFromGeometryData<Geometry::TriangleMesh>( "logo", gd.get() ) };
                     break;
                 case Ra::Core::Asset::GeometryData::QUAD_MESH:
                     mesh = std::shared_ptr<Data::QuadMesh> {
-                        createMeshFromGeometryData<Geometry::QuadMesh>( "logo", gd ) };
+                        createMeshFromGeometryData<Geometry::QuadMesh>( "logo", gd.get() ) };
                     break;
                 case Ra::Core::Asset::GeometryData::POLY_MESH:
                     mesh = std::shared_ptr<Data::PolyMesh> {
-                        createMeshFromGeometryData<Geometry::PolyMesh>( "logo", gd ) };
+                        createMeshFromGeometryData<Geometry::PolyMesh>( "logo", gd.get() ) };
                     break;
                 default:
                     break;
                 }
 
                 std::shared_ptr<Data::Material> roMaterial;
-                const Core::Asset::MaterialData* md =
-                    gd->hasMaterial() ? &( gd->getMaterial() ) : nullptr;
+                auto mm = gd->hasMaterial() ? gd->getMaterial().getMaterialModel() : nullptr;
                 // First extract the material from asset or create a default one
-                if ( md != nullptr ) {
+                if ( mm != nullptr ) {
                     auto converter =
-                        Data::EngineMaterialConverters::getMaterialConverter( md->getType() );
-                    auto mat = converter.second( md );
+                        Data::EngineMaterialConverters::getMaterialConverter( mm->getType() );
+                    auto mat = converter.second( mm.get() );
                     roMaterial.reset( mat );
                 }
                 else {
diff --git a/examples/RawShaderMaterial/main.cpp b/examples/RawShaderMaterial/main.cpp
index f6be9e9401a..e5fe772fdb8 100644
--- a/examples/RawShaderMaterial/main.cpp
+++ b/examples/RawShaderMaterial/main.cpp
@@ -102,11 +102,11 @@ std::shared_ptr<Ra::Engine::Rendering::RenderObject> initQuad( Ra::Gui::BaseAppl
     paramProvider->setOrComputeTheParameterValues();
 
     //! [Create the shader material]
-    Ra::Core::Asset::RawShaderMaterialData mat { "Quad Material", _config1, paramProvider };
+    auto mat = std::make_shared<Ra::Core::Material::RawShaderMaterialModel>(
+        "Quad Material", _config1, paramProvider );
 
     //! [Create a geometry component using the custom material]
-    auto c =
-        new Ra::Engine::Scene::TriangleMeshComponent( "Quad Mesh", e, std::move( quad ), &mat );
+    auto c = new Ra::Engine::Scene::TriangleMeshComponent( "Quad Mesh", e, std::move( quad ), mat );
 
     //! [Register the entity/component association to the geometry system ]
     auto system = app.m_engine->getSystem( "GeometrySystem" );
diff --git a/examples/SimpleAnimation/main.cpp b/examples/SimpleAnimation/main.cpp
index a8e019e8e2d..d22d9ef2199 100644
--- a/examples/SimpleAnimation/main.cpp
+++ b/examples/SimpleAnimation/main.cpp
@@ -3,8 +3,8 @@
 #include <Gui/RadiumWindow/SimpleWindowFactory.hpp>
 
 // include the core geometry/appearance interface
-#include <Core/Asset/BlinnPhongMaterialData.hpp>
 #include <Core/Geometry/MeshPrimitives.hpp>
+#include <Core/Material/BlinnPhongMaterialModel.hpp>
 
 // include the Engine/entity/component/system/animation interface
 #include <Engine/FrameInfo.hpp>
@@ -49,10 +49,11 @@ class KeyFramedGeometryComponent : public Ra::Engine::Scene::TriangleMeshCompone
     inline KeyFramedGeometryComponent( const std::string& name,
                                        Ra::Engine::Scene::Entity* entity,
                                        Ra::Core::Geometry::TriangleMesh&& mesh ) :
-        Ra::Engine::Scene::TriangleMeshComponent( name,
-                                                  entity,
-                                                  std::move( mesh ),
-                                                  new Ra::Core::Asset::BlinnPhongMaterialData {} ),
+        Ra::Engine::Scene::TriangleMeshComponent(
+            name,
+            entity,
+            std::move( mesh ),
+            std::make_shared<Ra::Core::Material::BlinnPhongMaterialModel>( name + "Material" ) ),
         m_transform( 0_ra, Ra::Core::Transform::Identity() ) {
         //! [Creating the transform KeyFrames]
         Ra::Core::Transform T = Ra::Core::Transform::Identity();
diff --git a/examples/TexturedQuad/main.cpp b/examples/TexturedQuad/main.cpp
index 7cc38dabe7a..d8f8d589e39 100644
--- a/examples/TexturedQuad/main.cpp
+++ b/examples/TexturedQuad/main.cpp
@@ -3,8 +3,8 @@
 #include <Gui/RadiumWindow/SimpleWindowFactory.hpp>
 
 // include the Engine/entity/component interface
-#include <Core/Asset/BlinnPhongMaterialData.hpp>
 #include <Core/Geometry/MeshPrimitives.hpp>
+#include <Core/Material/BlinnPhongMaterialModel.hpp>
 #include <Engine/Data/TextureManager.hpp>
 #include <Engine/Scene/EntityManager.hpp>
 #include <Engine/Scene/GeometryComponent.hpp>
@@ -43,17 +43,18 @@ int main( int argc, char* argv[] ) {
     //! [Create an entity and component to draw or data]
     auto e = app.m_engine->getEntityManager()->createEntity( "Textured quad" );
 
-    Ra::Core::Asset::BlinnPhongMaterialData matData( "myMaterialData" );
+    auto matData =
+        std::make_shared<Ra::Core::Material::BlinnPhongMaterialModel>( "myMaterialData" );
     // remove glossy highlight
-    matData.m_specular    = Ra::Core::Utils::Color::Black();
-    matData.m_hasSpecular = true;
+    matData->m_ks          = Ra::Core::Utils::Color::Black();
+    matData->m_hasSpecular = true;
 
-    matData.m_hasTexDiffuse = true;
+    matData->m_hasTexDiffuse = true;
     // this name has to be the same as texManager added texture name
-    matData.m_texDiffuse = "myTexture";
+    matData->m_texDiffuse = "myTexture";
 
     // the entity get's this new component ownership. a bit wired since hidden in ctor.
-    new Ra::Engine::Scene::TriangleMeshComponent( "Quad Mesh", e, std::move( quad ), &matData );
+    new Ra::Engine::Scene::TriangleMeshComponent( "Quad Mesh", e, std::move( quad ), matData );
     //! [Create an entity and component to draw or data]
 
     //! [Tell the window that something is to be displayed]
diff --git a/examples/TexturedQuadDynamic/main.cpp b/examples/TexturedQuadDynamic/main.cpp
index 4ddc602f6cd..673a47e98c0 100644
--- a/examples/TexturedQuadDynamic/main.cpp
+++ b/examples/TexturedQuadDynamic/main.cpp
@@ -5,8 +5,8 @@
 #include <Gui/Viewer/Viewer.hpp>
 
 // include the Engine/entity/component interface
-#include <Core/Asset/BlinnPhongMaterialData.hpp>
 #include <Core/Geometry/MeshPrimitives.hpp>
+#include <Core/Material/BlinnPhongMaterialModel.hpp>
 #include <Engine/Data/TextureManager.hpp>
 #include <Engine/Scene/EntityManager.hpp>
 #include <Engine/Scene/GeometryComponent.hpp>
@@ -48,17 +48,18 @@ int main( int argc, char* argv[] ) {
     //! [Create an entity and component to draw or data]
     auto e = app.m_engine->getEntityManager()->createEntity( "Textured quad" );
 
-    Ra::Core::Asset::BlinnPhongMaterialData matData( "myMaterialData" );
+    auto matData =
+        std::make_shared<Ra::Core::Material::BlinnPhongMaterialModel>( "myMaterialData" );
     // remove glossy highlight
-    matData.m_specular    = Ra::Core::Utils::Color::Black();
-    matData.m_hasSpecular = true;
+    matData->m_ks          = Ra::Core::Utils::Color::Black();
+    matData->m_hasSpecular = true;
 
-    matData.m_hasTexDiffuse = true;
+    matData->m_hasTexDiffuse = true;
     // this name has to be the same as texManager added texture name
-    matData.m_texDiffuse = "myTexture";
+    matData->m_texDiffuse = "myTexture";
 
     // the entity get's this new component ownership. a bit wired since hidden in ctor.
-    new Ra::Engine::Scene::TriangleMeshComponent( "Quad Mesh", e, std::move( quad ), &matData );
+    new Ra::Engine::Scene::TriangleMeshComponent( "Quad Mesh", e, std::move( quad ), matData );
     //! [Create an entity and component to draw or data]
 
     //! [Tell the window that something is to be displayed]
diff --git a/src/Core/Asset/AnimationData.cpp b/src/Core/Asset/AnimationData.cpp
index b4aa88ffca9..26e9b8fa23c 100644
--- a/src/Core/Asset/AnimationData.cpp
+++ b/src/Core/Asset/AnimationData.cpp
@@ -1,17 +1,20 @@
 #include <Core/Asset/AnimationData.hpp>
 
+#include <Core/Utils/Log.hpp>
+
 namespace Ra {
 namespace Core {
 namespace Asset {
 
-HandleAnimation::HandleAnimation( const std::string& name ) :
-    m_name( name ), m_anim( -1, Transform::Identity() ) {}
-
-AnimationData::AnimationData( const std::string& name ) :
-    AssetData( name ), m_time(), m_dt( 0.0 ), m_keyFrame() {}
-
-AnimationData::~AnimationData() {}
-
+void AnimationData::displayInfo() const {
+    using namespace Core::Utils; // log
+    LOG( logDEBUG ) << "======== ANIMATION INFO ========";
+    LOG( logDEBUG ) << " Name              : " << getName();
+    LOG( logDEBUG ) << " Start Time        : " << m_time.getStart();
+    LOG( logDEBUG ) << " End   Time        : " << m_time.getEnd();
+    LOG( logDEBUG ) << " Time Step         : " << m_dt;
+    LOG( logDEBUG ) << " Animated Object # : " << m_keyFrame.size();
+}
 } // namespace Asset
 } // namespace Core
 } // namespace Ra
diff --git a/src/Core/Asset/AnimationData.hpp b/src/Core/Asset/AnimationData.hpp
index 525431879df..81f99bb4e95 100644
--- a/src/Core/Asset/AnimationData.hpp
+++ b/src/Core/Asset/AnimationData.hpp
@@ -4,26 +4,27 @@
 #include <Core/Asset/AnimationTime.hpp>
 #include <Core/Asset/AssetData.hpp>
 #include <Core/RaCore.hpp>
-#include <Core/Utils/Log.hpp>
 
 #include <string>
 #include <vector>
 
 namespace Ra {
 namespace Core {
+using namespace Animation;
 namespace Asset {
 
 /**
  * A HandleAnimation stores data for an animation Handle.
  */
 struct RA_CORE_API HandleAnimation {
-    explicit HandleAnimation( const std::string& name = "" );
+    explicit HandleAnimation( const std::string& name = "" ) :
+        m_name( name ), m_anim( -1, Transform::Identity() ) {}
 
     /// The Handle's name.
     std::string m_name;
 
     /// The list of KeyFramed transforms applied to the Handle.
-    Core::Animation::KeyFramedValue<Transform> m_anim;
+    KeyFramedValue<Transform> m_anim;
 
     /// The AnimationTime for the Handle.
     AnimationTime m_animationTime;
@@ -37,14 +38,8 @@ struct RA_CORE_API HandleAnimation {
 class RA_CORE_API AnimationData : public AssetData
 {
   public:
-    explicit AnimationData( const std::string& name = "" );
-
-    ~AnimationData();
-
-    /**
-     * Sets the name of the animation.
-     */
-    inline void setName( const std::string& name ) { m_name = name; }
+    explicit AnimationData( const std::string& name = "" ) :
+        AssetData( name ), m_dt( 0.0 ), m_keyFrame() {}
 
     /// \name Time
     /// \{
@@ -59,12 +54,12 @@ class RA_CORE_API AnimationData : public AssetData
      */
     inline void setTime( const AnimationTime& time ) { m_time = time; }
     /**
-     * \returns the animation timestep.
+     * \returns the animation time-step.
      */
     inline AnimationTime::Time getTimeStep() const { return m_dt; }
 
     /**
-     * Sets the animation timestep.
+     * Sets the animation time-step.
      */
     inline void setTimeStep( const AnimationTime::Time& delta ) { m_dt = delta; }
 
@@ -81,49 +76,32 @@ class RA_CORE_API AnimationData : public AssetData
     /**
      * \returns the list of HandleAnimations, i.e. the whole animation frames.
      */
-    inline std::vector<HandleAnimation> getHandleData() const { return m_keyFrame; }
+    inline const std::vector<HandleAnimation>& getHandleData() const { return m_keyFrame; }
 
     /**
      * Sets the animation frames.
      */
-    inline void setHandleData( const std::vector<HandleAnimation>& frameList );
+    inline void setHandleData( std::vector<HandleAnimation>&& keyFrames ) {
+        m_keyFrame = std::move( keyFrames );
+    }
     /// \}
 
     /**
      * Print stat info to the Debug output.
      */
-    inline void displayInfo() const;
+    void displayInfo() const;
 
-  protected:
+  private:
     /// The AnimationTime for the object.
     AnimationTime m_time;
 
-    /// The animation timestep.
+    /// The animation time-step.
     AnimationTime::Time m_dt { 0 };
 
     /// The animation frames.
     std::vector<HandleAnimation> m_keyFrame;
 };
 
-inline void AnimationData::setHandleData( const std::vector<HandleAnimation>& frameList ) {
-    const uint size = frameList.size();
-    m_keyFrame.resize( size );
-#pragma omp parallel for
-    for ( int i = 0; i < int( size ); ++i ) {
-        m_keyFrame[i] = frameList[i];
-    }
-}
-
-inline void AnimationData::displayInfo() const {
-    using namespace Core::Utils; // log
-    LOG( logDEBUG ) << "======== ANIMATION INFO ========";
-    LOG( logDEBUG ) << " Name              : " << m_name;
-    LOG( logDEBUG ) << " Start Time        : " << m_time.getStart();
-    LOG( logDEBUG ) << " End   Time        : " << m_time.getEnd();
-    LOG( logDEBUG ) << " Time Step         : " << m_dt;
-    LOG( logDEBUG ) << " Animated Object # : " << m_keyFrame.size();
-}
-
 } // namespace Asset
 } // namespace Core
 } // namespace Ra
diff --git a/src/Core/Asset/AnimationTime.hpp b/src/Core/Asset/AnimationTime.hpp
index 6eb774cb906..cb28b28795a 100644
--- a/src/Core/Asset/AnimationTime.hpp
+++ b/src/Core/Asset/AnimationTime.hpp
@@ -1,6 +1,6 @@
 #pragma once
-
 #include <Core/RaCore.hpp>
+
 #include <algorithm>
 #include <limits>
 
@@ -20,13 +20,9 @@ class RA_CORE_API AnimationTime
     using Time = Scalar;
 
     AnimationTime( const Time& start = std::numeric_limits<Time>::max(),
-                   const Time& end   = -std::numeric_limits<Time>::max() ) :
+                   const Time& end   = std::numeric_limits<Time>::lowest() ) :
         m_start( start ), m_end( end ) {}
 
-    AnimationTime( const AnimationTime& time ) = default;
-
-    ~AnimationTime() {}
-
     ///\name Time
     /// \{
 
@@ -85,14 +81,14 @@ class RA_CORE_API AnimationTime
     /**
      * Return true if \f$ t \in [start,end] \f$.
      */
-    inline bool contains( const Time& t ) const { return ( ( t >= m_start ) && ( t <= m_end ) ); }
+    inline bool contains( const Time& t ) const { return ( t >= m_start ) && ( t <= m_end ); }
 
     /**
      * Return true if \f$ *this \cap time \neq \emptyset \f$.
      */
     inline bool intersect( const AnimationTime& time ) const {
-        return ( contains( time.m_start ) || contains( time.m_end ) || time.contains( m_start ) ||
-                 time.contains( m_end ) );
+        return contains( time.m_start ) || contains( time.m_end ) || time.contains( m_start ) ||
+               time.contains( m_end );
     }
     /// \}
 
@@ -103,7 +99,7 @@ class RA_CORE_API AnimationTime
      * Returns true if *this and \p time represent the same animation time.
      */
     inline bool operator==( const AnimationTime& time ) const {
-        return ( ( m_start == time.m_start ) && ( m_end == time.m_end ) );
+        return ( m_start == time.m_start ) && ( m_end == time.m_end );
     }
 
     /**
@@ -119,19 +115,19 @@ class RA_CORE_API AnimationTime
     /**
      * Returns true if \f$ t < end \f$.
      */
-    inline bool operator<( const Time& t ) const { return ( t < m_end ); }
+    inline bool operator<( const Time& t ) const { return t < m_end; }
 
     /**
      * Returns true if \f$ t > start \f$.
      */
-    inline bool operator>( const Time& t ) const { return ( t > m_start ); }
+    inline bool operator>( const Time& t ) const { return t > m_start; }
 
-  protected:
+  private:
     /// Animation starting time.
-    Time m_start;
+    Time m_start { std::numeric_limits<Time>::max() };
 
     /// Animation ending time.
-    Time m_end;
+    Time m_end { std::numeric_limits<Time>::lowest() };
 };
 
 } // namespace Asset
diff --git a/src/Core/Asset/AssetData.hpp b/src/Core/Asset/AssetData.hpp
index 606083a73bf..e4e7a0f59c1 100644
--- a/src/Core/Asset/AssetData.hpp
+++ b/src/Core/Asset/AssetData.hpp
@@ -1,6 +1,6 @@
 #pragma once
-
 #include <Core/RaCore.hpp>
+
 #include <string>
 
 namespace Ra {
@@ -19,16 +19,15 @@ class RA_CORE_API AssetData
     /// Construct an asset data given its name.
     explicit AssetData( const std::string& name ) : m_name( name ) {}
 
-    /// Copy constructor. Default here
-    AssetData( const AssetData& other ) = default;
-
     /// Simple delete operator
-    virtual ~AssetData() {}
+    virtual ~AssetData() = default;
 
-    /// Acces to the name of the asset
-    inline virtual const std::string& getName() const { return m_name; }
+    /// Access to the name of the asset
+    inline const std::string& getName() const { return m_name; }
+    /// Set the name of the asset
+    inline void setName( const std::string& name ) { m_name = name; }
 
-  protected:
+  private:
     std::string m_name;
 };
 
diff --git a/src/Core/Asset/BlinnPhongMaterialData.cpp b/src/Core/Asset/BlinnPhongMaterialData.cpp
deleted file mode 100644
index 336ebb38b46..00000000000
--- a/src/Core/Asset/BlinnPhongMaterialData.cpp
+++ /dev/null
@@ -1,33 +0,0 @@
-#include <Core/Asset/BlinnPhongMaterialData.hpp>
-
-namespace Ra {
-namespace Core {
-namespace Asset {
-
-///////////////////
-/// BLINN PHONG ///
-///////////////////
-BlinnPhongMaterialData::BlinnPhongMaterialData( const std::string& name ) :
-    MaterialData( name, "BlinnPhong" ),
-    m_diffuse(),
-    m_specular(),
-    m_shininess(),
-    m_opacity( 1.0 ),
-    m_texDiffuse( "" ),
-    m_texSpecular( "" ),
-    m_texShininess( "" ),
-    m_texNormal( "" ),
-    m_texOpacity( "" ),
-    m_hasDiffuse( false ),
-    m_hasSpecular( false ),
-    m_hasShininess( false ),
-    m_hasOpacity( false ),
-    m_hasTexDiffuse( false ),
-    m_hasTexSpecular( false ),
-    m_hasTexShininess( false ),
-    m_hasTexNormal( false ),
-    m_hasTexOpacity( false ) {}
-
-} // namespace Asset
-} // namespace Core
-} // namespace Ra
diff --git a/src/Core/Asset/BlinnPhongMaterialData.hpp b/src/Core/Asset/BlinnPhongMaterialData.hpp
deleted file mode 100644
index 2fa05e0e5eb..00000000000
--- a/src/Core/Asset/BlinnPhongMaterialData.hpp
+++ /dev/null
@@ -1,121 +0,0 @@
-#pragma once
-
-#include <Core/Asset/MaterialData.hpp>
-#include <Core/Utils/Color.hpp>
-#include <Core/Utils/Log.hpp>
-
-namespace Ra {
-namespace Core {
-namespace Asset {
-
-// RADIUM SUPPORTED MATERIALS
-class RA_CORE_API BlinnPhongMaterialData : public MaterialData
-{
-  public:
-    explicit BlinnPhongMaterialData( const std::string& name = "" );
-
-    /// DEBUG
-    inline void displayInfo() const final;
-
-    /// QUERY
-    inline bool hasDiffuse() const;
-
-    inline bool hasSpecular() const;
-
-    inline bool hasShininess() const;
-
-    inline bool hasOpacity() const;
-
-    inline bool hasDiffuseTexture() const;
-
-    inline bool hasSpecularTexture() const;
-
-    inline bool hasShininessTexture() const;
-
-    inline bool hasNormalTexture() const;
-
-    inline bool hasOpacityTexture() const;
-
-    /// DATA MEMBERS
-    Core::Utils::Color m_diffuse;
-    Core::Utils::Color m_specular;
-    Scalar m_shininess;
-    Scalar m_opacity;
-    std::string m_texDiffuse;
-    std::string m_texSpecular;
-    std::string m_texShininess;
-    std::string m_texNormal;
-    std::string m_texOpacity;
-    bool m_hasDiffuse;
-    bool m_hasSpecular;
-    bool m_hasShininess;
-    bool m_hasOpacity;
-    bool m_hasTexDiffuse;
-    bool m_hasTexSpecular;
-    bool m_hasTexShininess;
-    bool m_hasTexNormal;
-    bool m_hasTexOpacity;
-};
-
-///////////////////
-/// BLINN PHONG ///
-///////////////////
-inline bool BlinnPhongMaterialData::hasDiffuse() const {
-    return m_hasDiffuse;
-}
-
-inline bool BlinnPhongMaterialData::hasSpecular() const {
-    return m_hasSpecular;
-}
-
-inline bool BlinnPhongMaterialData::hasShininess() const {
-    return m_hasShininess;
-}
-
-inline bool BlinnPhongMaterialData::hasOpacity() const {
-    return m_hasOpacity;
-}
-
-inline bool BlinnPhongMaterialData::hasDiffuseTexture() const {
-    return m_hasTexDiffuse;
-}
-
-inline bool BlinnPhongMaterialData::hasSpecularTexture() const {
-    return m_hasTexSpecular;
-}
-
-inline bool BlinnPhongMaterialData::hasShininessTexture() const {
-    return m_hasTexShininess;
-}
-
-inline bool BlinnPhongMaterialData::hasNormalTexture() const {
-    return m_hasTexNormal;
-}
-
-inline bool BlinnPhongMaterialData::hasOpacityTexture() const {
-    return m_hasTexOpacity;
-}
-
-/// DEBUG
-inline void BlinnPhongMaterialData::displayInfo() const {
-    using namespace Core::Utils; // log
-    auto print = []( bool ok, const std::string& name, const auto& value ) {
-        if ( ok ) { LOG( logINFO ) << name << value; }
-        else { LOG( logINFO ) << name << "NO"; }
-    };
-
-    LOG( logINFO ) << "======== MATERIAL INFO ========";
-    print( hasDiffuse(), " Kd             : ", m_diffuse.transpose() );
-    print( hasSpecular(), " Ks             : ", m_specular.transpose() );
-    print( hasShininess(), " Ns             : ", m_shininess );
-    print( hasOpacity(), " Opacity        : ", m_opacity );
-    print( hasDiffuseTexture(), " Kd Texture     : ", m_texDiffuse );
-    print( hasSpecularTexture(), " Ks Texture     : ", m_texSpecular );
-    print( hasShininessTexture(), " Ns Texture     : ", m_texShininess );
-    print( hasNormalTexture(), " Normal Texture : ", m_texNormal );
-    print( hasOpacityTexture(), " Alpha Texture  : ", m_texOpacity );
-}
-
-} // namespace Asset
-} // namespace Core
-} // namespace Ra
diff --git a/src/Core/Asset/Camera.cpp b/src/Core/Asset/Camera.cpp
index 4ffdb413c5a..85f18837e5b 100644
--- a/src/Core/Asset/Camera.cpp
+++ b/src/Core/Asset/Camera.cpp
@@ -1,19 +1,13 @@
 #include <Core/Asset/Camera.hpp>
-#include <Core/Containers/MakeShared.hpp>
-#include <Core/Math/Math.hpp>
 
 namespace Ra {
-
-using Core::Math::Pi;
-using Core::Math::PiDiv2;
-using Core::Math::PiDiv4;
-
 namespace Core {
 
-namespace Asset {
+using Math::Pi;
+using Math::PiDiv2;
+using Math::PiDiv4;
 
-Camera::Camera( Scalar width, Scalar height ) :
-    m_width { width }, m_height { height }, m_aspect { width / height } {}
+namespace Asset {
 
 Camera& Camera::operator=( const Camera& rhs ) {
     m_frame      = rhs.getFrame();
diff --git a/src/Core/Asset/Camera.hpp b/src/Core/Asset/Camera.hpp
index 6fb6b8cfcce..bb6a242daac 100644
--- a/src/Core/Asset/Camera.hpp
+++ b/src/Core/Asset/Camera.hpp
@@ -1,8 +1,9 @@
 #pragma once
+#include <Core/RaCore.hpp>
 
 #include <Core/Math/Math.hpp>
 #include <Core/Types.hpp>
-#include <Core/Utils/Observable.hpp>
+
 namespace Ra {
 namespace Core {
 namespace Asset {
@@ -20,40 +21,39 @@ class RA_CORE_API Camera
     /// Define the projection type.
     enum class ProjType { ORTHOGRAPHIC, PERSPECTIVE };
 
-    Camera( Scalar height = 1_ra, Scalar width = 1_ra );
-
-    ~Camera() = default;
+    explicit Camera( Scalar width = 1_ra, Scalar height = 1_ra ) :
+        m_width { width }, m_height { height }, m_aspect { width / height } {}
 
     Camera& operator=( const Camera& rhs );
 
     /// Return the frame of the camera.
     /// Where Y is the up vector and -Z is the direction vector.
-    inline Core::Transform getFrame() const;
+    inline Transform getFrame() const { return m_frame; }
 
     /// Set the frame of the camera to \b frame.
-    inline void setFrame( const Core::Transform& frame );
+    inline void setFrame( const Transform& frame ) { m_frame = frame; }
 
     /// Return the position.
-    inline Core::Vector3 getPosition() const;
+    inline Vector3 getPosition() const { return m_frame.translation(); }
 
     /// Set the position of the camera to \b position.
-    inline void setPosition( const Core::Vector3& position );
+    inline void setPosition( const Vector3& position );
 
     /// Return the direction the camera is looking at.
-    inline Core::Vector3 getDirection() const;
+    inline Vector3 getDirection() const;
 
     /// Set the direction of the camera to \b direction.
     /// The other vectors will be rotated accordingly.
-    void setDirection( const Core::Vector3& direction );
+    void setDirection( const Vector3& direction );
 
     /// Return the up vector.
-    inline Core::Vector3 getUpVector() const;
+    inline Vector3 getUpVector() const;
 
     /// Set the up vector of the camera to \b upVector.
     /// The other vectors will be rotated accordingly.
-    inline void setUpVector( const Core::Vector3& upVector );
+    inline void setUpVector( const Vector3& upVector );
 
-    inline Core::Vector3 getRightVector() const;
+    inline Vector3 getRightVector() const;
 
     //
     // Utility functions
@@ -64,104 +64,104 @@ class RA_CORE_API Camera
 
     /// Return a ray emanating from the camera, passing by the point given by
     /// screen coordinates x and y.
-    Core::Ray getRayFromScreen( const Core::Vector2& pix ) const;
+    Ray getRayFromScreen( const Vector2& pix ) const;
 
     /// Return the screen coordinates + depth of the given point p (in world coordinates).
-    Core::Vector3 projectToScreen( const Core::Vector3& p ) const;
+    Vector3 projectToScreen( const Vector3& p ) const;
 
     /// Return NDC cordinate in the view NDC cube \f$ [-1,1]^3 \f$
-    Core::Vector3 projectToNDC( const Core::Vector3& p ) const;
+    Vector3 projectToNDC( const Vector3& p ) const;
 
     /// Return the 3D point in world space corresponding to screen coordinates pix.
     /// pix.x() and pix.y() are in pixel coordinates \f$ \in [0, getWidth()] \times [0, getHeight()]
     /// \f$. The returned point lies on z near plane.
-    Core::Vector3 unProjectFromScreen( const Core::Vector2& pix ) const;
+    Vector3 unProjectFromScreen( const Vector2& pix ) const;
 
     /// Return the 3D point in world space corresponding to screen pixels pix.x(), pix.y(), at depth
     /// pix.z()
     /// x and y are in pixel coordinates (from (0,0) to width,height, z is in 0, 1 (0 near, 1 far
     /// plane)
-    Core::Vector3 unProjectFromScreen( const Core::Vector3& pix ) const;
+    Vector3 unProjectFromScreen( const Vector3& pix ) const;
 
     /// Return the 3D point in world space corresponding to NDC cube \f$ [-1,1]^3 \f$  point pix.
-    Core::Vector3 unProjectFromNDC( const Core::Vector3& pix ) const;
+    Vector3 unProjectFromNDC( const Vector3& pix ) const;
 
     //
     // Getters and setters for projection matrix parameters.
     //
 
     /// Return the projection type.
-    inline ProjType getType() const;
+    inline ProjType getType() const { return m_projType; }
 
     /// Set the projection type to \b projectionType.
-    inline void setType( const ProjType& projectionType );
+    inline void setType( const ProjType& projectionType ) { m_projType = projectionType; }
 
     /// Return the zoom factor.
-    inline Scalar getZoomFactor() const;
+    inline Scalar getZoomFactor() const { return m_zoomFactor; }
 
     /// Set the zoom factor to \b zoomFactor.
     inline void setZoomFactor( const Scalar& zoomFactor );
 
     /// Return the horizontal Field Of View.
     /// \note Meaningless for orthogonal projection.
-    inline Scalar getFOV() const;
+    inline Scalar getFOV() const { return m_fov; }
 
     /// Set the Field Of View to 'fov' in the x (horizontal) direction.
     /// If you have an vertical field of view, you can convert it to horizontal as
     /// Scalar fovx = 2_ra*std::atan( radiumCam->getAspect() * std::tan( cam.yfov / 2_ra ) );
-    //        if ( fovxDiv2 < 0_ra ) { fovxDiv2 = Ra::Core::Math::PiDiv2; }
+    //        if ( fovxDiv2 < 0_ra ) { fovxDiv2 = Math::PiDiv2; }
     /// \note Meaningless for orthogonal projection.
     /// \warning Trigger a rebuild of the projection matrix.
     inline void setFOV( Scalar fov );
 
-    inline Scalar getMinZNear() const;
-    inline Scalar getMinZRange() const;
+    inline Scalar getMinZNear() const { return m_minZNear; }
+    inline Scalar getMinZRange() const { return m_minZRange; }
 
     /// Return the projection matrix.
-    inline Core::Matrix4 getProjMatrix() const;
-    inline Core::Matrix4 getViewMatrix() const;
+    inline Matrix4 getProjMatrix() const { return m_projMatrix; }
+    inline Matrix4 getViewMatrix() const { return getFrame().inverse().matrix(); }
 
     /// Update the projection matrix according to the current parameters.
     void updateProjMatrix();
 
     /// set projection to \b projMatrix.
     /// \see perspective(), ortho().
-    inline void setProjMatrix( Core::Matrix4 projMatrix );
+    inline void setProjMatrix( Matrix4 projMatrix ) { m_projMatrix = projMatrix; }
 
     /// Return the Z Near plane distance from the camera.
-    inline Scalar getZNear() const;
+    inline Scalar getZNear() const { return m_zNear; }
 
     /// Set the Z Near plane distance to  \b zNear.
     inline void setZNear( Scalar zNear );
 
     /// Return the Z Far plane distance from the camera.
-    inline Scalar getZFar() const;
+    inline Scalar getZFar() const { return m_zFar; }
 
     /// Set the Z Far plane distance to \b zFar.
     inline void setZFar( Scalar zFar );
 
     /// Return the width of the viewport.
-    inline Scalar getWidth() const;
+    inline Scalar getWidth() const { return m_width; }
 
     /// Return the height of the viewport.
-    inline Scalar getHeight() const;
+    inline Scalar getHeight() const { return m_height; }
 
     /// Return the aspect ratio of the viewport.
-    inline Scalar getAspect() const;
+    inline Scalar getAspect() const { return m_aspect; }
 
     /// Set xmag and ymag for orthographic camera
     inline void setXYmag( Scalar xmag, Scalar ymag );
 
     /// Get xmag and ymag for orthographic camera
-    inline std::pair<Scalar, Scalar> getXYmag() const;
+    inline std::pair<Scalar, Scalar> getXYmag() const { return { m_xmag, m_ymag }; }
 
     /// Change the viewport size. Also compute aspectRatio.
     void setViewport( Scalar width, Scalar height );
 
-    void applyTransform( const Core::Transform& T );
+    void applyTransform( const Transform& T );
 
     /// Fit the Z-range of the camera to the scene's aabb. This will maximize z-buffer precision
-    void fitZRange( const Core::Aabb& aabb );
+    void fitZRange( const Aabb& aabb );
 
     const Scalar m_minZNear { 0.01_ra };
     const Scalar m_minZRange { 0.01_ra };
@@ -175,7 +175,7 @@ class RA_CORE_API Camera
     /// \param y : fov in the horizontal direction, i.e. getFOV()
     /// \param n : z near, i.e. getZNear()
     /// \param f : z far, i.e. getZFar()
-    static Core::Matrix4 perspective( Scalar a, Scalar y, Scalar n, Scalar f );
+    static Matrix4 perspective( Scalar a, Scalar y, Scalar n, Scalar f );
 
     /// \brief Build a projection matrix from the parameters of the view volume
     /// \see perspective()
@@ -189,7 +189,7 @@ class RA_CORE_API Camera
     /// \param t : top
     /// \param n : z near
     /// \param f : z far
-    static Core::Matrix4 frustum( Scalar l, Scalar r, Scalar b, Scalar t, Scalar n, Scalar f );
+    static Matrix4 frustum( Scalar l, Scalar r, Scalar b, Scalar t, Scalar n, Scalar f );
 
     /// \brief Build a projection matrix from the parameters of the view volume
     /// Implements the algorithms described here
@@ -202,14 +202,14 @@ class RA_CORE_API Camera
     /// \param t : top
     /// \param n : z near
     /// \param f : z far
-    static Core::Matrix4 ortho( Scalar l, Scalar r, Scalar b, Scalar t, Scalar n, Scalar f );
+    static Matrix4 ortho( Scalar l, Scalar r, Scalar b, Scalar t, Scalar n, Scalar f );
 
   private:
     /// Camera frame (inverse of the view matrix).
     /// This represent the transformation from view space to world space.
-    Core::Transform m_frame { Core::Transform::Identity() };
+    Transform m_frame { Transform::Identity() };
 
-    Core::Matrix4 m_projMatrix { Core::Matrix4::Identity() }; ///< Projection matrix
+    Matrix4 m_projMatrix { Matrix4::Identity() }; ///< Projection matrix
 
     Scalar m_width { 1_ra };  ///< Viewport width (in pixels)
     Scalar m_height { 1_ra }; ///< Viewport height (in pixels)
@@ -223,7 +223,7 @@ class RA_CORE_API Camera
 
     /// \name Perspective projection parameters
     ///@{
-    Scalar m_fov { Core::Math::PiDiv4 }; ///< Horizontal Field Of View
+    Scalar m_fov { Math::PiDiv4 }; ///< Horizontal Field Of View
     ///@}
 
     /// \name Orthographic projection parameters
@@ -233,44 +233,28 @@ class RA_CORE_API Camera
     ///@}
 };
 
-inline Core::Transform Camera::getFrame() const {
-    return m_frame;
-}
-
-inline void Camera::setFrame( const Core::Transform& frame ) {
-    m_frame = frame;
-}
-
-inline Core::Vector3 Camera::getPosition() const {
-    return ( m_frame.translation() );
-}
-
-inline void Camera::setPosition( const Core::Vector3& position ) {
-    Core::Transform T = Core::Transform::Identity();
-    T.translation()   = position - m_frame.translation();
+inline void Camera::setPosition( const Vector3& position ) {
+    Transform T     = Transform::Identity();
+    T.translation() = position - m_frame.translation();
     applyTransform( T );
 }
 
-inline Core::Vector3 Camera::getDirection() const {
+inline Vector3 Camera::getDirection() const {
     return ( -m_frame.linear().block<3, 1>( 0, 2 ) ).normalized();
 }
 
-inline Core::Vector3 Camera::getUpVector() const {
-    return ( m_frame.affine().block<3, 1>( 0, 1 ) );
+inline Vector3 Camera::getUpVector() const {
+    return m_frame.affine().block<3, 1>( 0, 1 );
 }
 
-inline void Camera::setUpVector( const Core::Vector3& upVector ) {
-    Core::Transform T = Core::Transform::Identity();
-    T.rotate( Core::Quaternion::FromTwoVectors( getUpVector(), upVector ) );
+inline void Camera::setUpVector( const Vector3& upVector ) {
+    Transform T = Transform::Identity();
+    T.rotate( Quaternion::FromTwoVectors( getUpVector(), upVector ) );
     applyTransform( T );
 }
 
-inline Core::Vector3 Camera::getRightVector() const {
-    return ( m_frame.affine().block<3, 1>( 0, 0 ) );
-}
-
-inline Scalar Camera::getFOV() const {
-    return m_fov;
+inline Vector3 Camera::getRightVector() const {
+    return m_frame.affine().block<3, 1>( 0, 0 );
 }
 
 inline void Camera::setFOV( Scalar fov ) {
@@ -281,73 +265,21 @@ inline void Camera::setFOV( Scalar fov ) {
     updateProjMatrix();
 }
 
-inline Scalar Camera::getZNear() const {
-    return m_zNear;
-}
-
 inline void Camera::setZNear( Scalar zNear ) {
     m_zNear = zNear;
     updateProjMatrix();
 }
 
-inline Scalar Camera::getZFar() const {
-    return m_zFar;
-}
-
 inline void Camera::setZFar( Scalar zFar ) {
     m_zFar = zFar;
     updateProjMatrix();
 }
 
-inline Scalar Camera::getZoomFactor() const {
-    return m_zoomFactor;
-}
-
 inline void Camera::setZoomFactor( const Scalar& zoomFactor ) {
     m_zoomFactor = zoomFactor;
     updateProjMatrix();
 }
 
-inline Scalar Camera::getWidth() const {
-    return m_width;
-}
-
-inline Scalar Camera::getHeight() const {
-    return m_height;
-}
-
-inline Scalar Camera::getAspect() const {
-    return m_aspect;
-}
-
-inline Camera::ProjType Camera::getType() const {
-    return m_projType;
-}
-
-inline void Camera::setType( const ProjType& projectionType ) {
-    m_projType = projectionType;
-}
-
-inline Core::Matrix4 Camera::getViewMatrix() const {
-    return getFrame().inverse().matrix();
-}
-
-inline Core::Matrix4 Camera::getProjMatrix() const {
-    return m_projMatrix;
-}
-
-inline Scalar Camera::getMinZNear() const {
-    return m_minZNear;
-}
-
-inline Scalar Camera::getMinZRange() const {
-    return m_minZRange;
-}
-
-inline void Camera::setProjMatrix( Core::Matrix4 projMatrix ) {
-    m_projMatrix = projMatrix;
-}
-
 inline void Camera::setXYmag( Scalar xmag, Scalar ymag ) {
     m_xmag = xmag;
     m_ymag = ymag;
@@ -356,10 +288,6 @@ inline void Camera::setXYmag( Scalar xmag, Scalar ymag ) {
     updateProjMatrix();
 }
 
-inline std::pair<Scalar, Scalar> Camera::getXYmag() const {
-    return { m_xmag, m_ymag };
-}
-
 } // namespace Asset
 } // namespace Core
 } // namespace Ra
diff --git a/src/Core/Asset/FileData.cpp b/src/Core/Asset/FileData.cpp
index 12933570238..30f73475b87 100644
--- a/src/Core/Asset/FileData.cpp
+++ b/src/Core/Asset/FileData.cpp
@@ -1,24 +1,29 @@
 #include <Core/Asset/FileData.hpp>
 
+#include <Core/Utils/Log.hpp>
+
 namespace Ra {
 namespace Core {
 namespace Asset {
 
 /// CONSTRUCTOR
-FileData::FileData( const std::string& filename, const bool VERBOSE_MODE ) :
-    m_filename( filename ),
-    m_loadingTime( 0.0 ),
-    m_geometryData(),
-    m_volumeData(),
-    m_handleData(),
-    m_animationData(),
-    m_lightData(),
-    m_processed( false ),
-    m_verbose( VERBOSE_MODE ) {}
-
-/// DESTRUCTOR
-FileData::~FileData() {}
 
+void FileData::displayInfo() const {
+    using namespace Core::Utils; // log
+    uint64_t vtxCount = 0;
+    for ( const auto& geom : m_geometryData ) {
+        vtxCount += geom->getGeometry().vertices().size();
+    }
+    LOG( logINFO ) << "======== LOADING SUMMARY ========";
+    LOG( logINFO ) << "Mesh loaded        : " << m_geometryData.size();
+    LOG( logINFO ) << "Total vertex count : " << vtxCount;
+    LOG( logINFO ) << "Handle loaded      : " << m_handleData.size();
+    LOG( logINFO ) << "Animation loaded   : " << m_animationData.size();
+    LOG( logINFO ) << "Volume loaded      : " << m_volumeData.size();
+    LOG( logINFO ) << "Light loaded       : " << m_lightData.size();
+    LOG( logINFO ) << "Camera loaded      : " << m_cameraData.size();
+    LOG( logINFO ) << "Loading Time (sec) : " << m_loadingTime;
+}
 } // namespace Asset
 } // namespace Core
 } // namespace Ra
diff --git a/src/Core/Asset/FileData.hpp b/src/Core/Asset/FileData.hpp
index 4a1080369e7..19ec42fea65 100644
--- a/src/Core/Asset/FileData.hpp
+++ b/src/Core/Asset/FileData.hpp
@@ -1,8 +1,5 @@
 #pragma once
-
-#include <memory>
-#include <string>
-#include <vector>
+#include <Core/RaCore.hpp>
 
 #include <Core/Asset/AnimationData.hpp>
 #include <Core/Asset/Camera.hpp>
@@ -10,8 +7,10 @@
 #include <Core/Asset/HandleData.hpp>
 #include <Core/Asset/LightData.hpp>
 #include <Core/Asset/VolumeData.hpp>
-#include <Core/RaCore.hpp>
-#include <Core/Utils/Log.hpp>
+
+#include <memory>
+#include <string>
+#include <vector>
 
 namespace Ra {
 namespace Core {
@@ -21,187 +20,71 @@ class RA_CORE_API FileData final
 {
   public:
     /// CONSTRUCTOR
-    FileData( const std::string& filename = "", const bool VERBOSE_MODE = false );
+    explicit FileData( const std::string& filename = "", const bool VERBOSE_MODE = false ) :
+        m_filename( filename ), m_verbose( VERBOSE_MODE ) {}
 
     FileData( FileData&& data ) = default;
 
-    /// DESTRUCTOR
-    ~FileData();
-
     /// FILENAME
-    inline std::string getFileName() const;
+    [[nodiscard]] inline std::string getFileName() const { return m_filename; }
 
-    inline void setFileName( const std::string& filename );
+    inline void setFileName( const std::string& filename ) { m_filename = filename; }
 
     /// TIMING
-    inline Scalar getLoadingTime() const;
+    [[nodiscard]] inline Scalar getLoadingTime() const { return m_loadingTime; }
 
     /// DATA
-    inline std::vector<GeometryData*> getGeometryData() const;
-    inline std::vector<VolumeData*> getVolumeData() const;
-    inline std::vector<HandleData*> getHandleData() const;
-    inline std::vector<AnimationData*> getAnimationData() const;
-    inline std::vector<LightData*> getLightData() const;
-    inline std::vector<Camera*> getCameraData() const;
+    [[nodiscard]] inline const auto& getGeometryData() const { return m_geometryData; }
+    [[nodiscard]] inline const auto& getVolumeData() const { return m_volumeData; }
+    [[nodiscard]] inline const auto& getHandleData() const { return m_handleData; }
+    [[nodiscard]] inline const auto& getAnimationData() const { return m_animationData; }
+    [[nodiscard]] inline const auto& getLightData() const { return m_lightData; }
+    [[nodiscard]] inline const auto& getCameraData() const { return m_cameraData; }
 
-    inline void setVerbose( const bool VERBOSE_MODE );
+    inline void setVerbose( const bool VERBOSE_MODE ) { m_verbose = VERBOSE_MODE; }
 
     /// QUERY
-    inline bool isInitialized() const;
-    inline bool isProcessed() const;
-    inline bool hasGeometry() const;
-    inline bool hasHandle() const;
-    inline bool hasAnimation() const;
-    inline bool hasLight() const;
-    inline bool hasCamera() const;
-    inline bool isVerbose() const;
+    inline bool isInitialized() const { return !m_processed && m_filename != ""; }
+    inline bool isProcessed() const { return m_processed; }
+    inline bool hasGeometry() const { return !m_geometryData.empty(); }
+    inline bool hasHandle() const { return !m_handleData.empty(); }
+    inline bool hasAnimation() const { return !m_animationData.empty(); }
+    inline bool hasLight() const { return !m_lightData.empty(); }
+    inline bool hasCamera() const { return !m_cameraData.empty(); }
+    inline bool isVerbose() const { return m_verbose; }
 
     /// RESET
     inline void reset();
 
-    inline void displayInfo() const;
+    void displayInfo() const;
 
     // TODO(Matthieu) : handle attributes in a better way than "public:"
   public:
     /// VARIABLE
     std::string m_filename;
-    Scalar m_loadingTime;
+    Scalar m_loadingTime { 0_ra };
     std::vector<std::unique_ptr<GeometryData>> m_geometryData;
     std::vector<std::unique_ptr<VolumeData>> m_volumeData;
     std::vector<std::unique_ptr<HandleData>> m_handleData;
     std::vector<std::unique_ptr<AnimationData>> m_animationData;
     std::vector<std::unique_ptr<LightData>> m_lightData;
     std::vector<std::unique_ptr<Camera>> m_cameraData;
-    bool m_processed;
-    bool m_verbose;
+    bool m_processed { false };
+    bool m_verbose { false };
 };
 
-/// FILENAME
-inline std::string FileData::getFileName() const {
-    return m_filename;
-}
-
-inline void FileData::setFileName( const std::string& filename ) {
-    m_filename = filename;
-}
-
-/// TIMING
-inline Scalar FileData::getLoadingTime() const {
-    return m_loadingTime;
-}
-
-/// DATA
-inline std::vector<GeometryData*> FileData::getGeometryData() const {
-    std::vector<GeometryData*> list;
-    list.reserve( m_geometryData.size() );
-    for ( const auto& item : m_geometryData ) {
-        list.push_back( item.get() );
-    }
-    return list;
-}
-
-inline std::vector<VolumeData*> FileData::getVolumeData() const {
-    std::vector<VolumeData*> list;
-    list.reserve( m_volumeData.size() );
-    for ( const auto& item : m_volumeData ) {
-        list.push_back( item.get() );
-    }
-    return list;
-}
-
-inline std::vector<HandleData*> FileData::getHandleData() const {
-    std::vector<HandleData*> list;
-    list.reserve( m_handleData.size() );
-    for ( const auto& item : m_handleData ) {
-        list.push_back( item.get() );
-    }
-    return list;
-}
-
-inline std::vector<AnimationData*> FileData::getAnimationData() const {
-    std::vector<AnimationData*> list;
-    list.reserve( m_animationData.size() );
-    for ( const auto& item : m_animationData ) {
-        list.push_back( item.get() );
-    }
-    return list;
-}
-
-inline std::vector<LightData*> FileData::getLightData() const {
-    std::vector<LightData*> list;
-    list.reserve( m_lightData.size() );
-    for ( const auto& item : m_lightData ) {
-        list.push_back( item.get() );
-    }
-    return list;
-}
-
-inline std::vector<Camera*> FileData::getCameraData() const {
-    std::vector<Camera*> list;
-    list.reserve( m_cameraData.size() );
-    for ( const auto& item : m_cameraData ) {
-        list.push_back( item.get() );
-    }
-    return list;
-}
-
-inline void FileData::setVerbose( const bool VERBOSE_MODE ) {
-    m_verbose = VERBOSE_MODE;
-}
-
-/// QUERY
-inline bool FileData::isInitialized() const {
-    return ( ( m_filename != "" ) && !m_processed );
-}
-
-inline bool FileData::isProcessed() const {
-    return m_processed;
-}
-
-inline bool FileData::hasGeometry() const {
-    return ( !m_geometryData.empty() );
-}
-
-inline bool FileData::hasHandle() const {
-    return ( !m_handleData.empty() );
-}
-
-inline bool FileData::hasAnimation() const {
-    return ( !m_animationData.empty() );
-}
-
-inline bool FileData::hasLight() const {
-    return ( !m_lightData.empty() );
-}
-
-inline bool FileData::isVerbose() const {
-    return m_verbose;
-}
-
 /// RESET
 inline void FileData::reset() {
     m_filename = "";
     m_geometryData.clear();
+    m_volumeData.clear();
     m_handleData.clear();
     m_animationData.clear();
+    m_lightData.clear();
+    m_cameraData.clear();
     m_processed = false;
 }
 
-inline void FileData::displayInfo() const {
-    using namespace Core::Utils; // log
-    uint64_t vtxCount = 0;
-    for ( const auto& geom : m_geometryData ) {
-        vtxCount += geom->getGeometry().vertices().size();
-    }
-    LOG( logINFO ) << "======== LOADING SUMMARY ========";
-    LOG( logINFO ) << "Mesh loaded        : " << m_geometryData.size();
-    LOG( logINFO ) << "Total vertex count : " << vtxCount;
-    LOG( logINFO ) << "Handle loaded      : " << m_handleData.size();
-    LOG( logINFO ) << "Animation loaded   : " << m_animationData.size();
-    LOG( logINFO ) << "Volume loaded        : " << m_volumeData.size();
-    LOG( logINFO ) << "Loading Time (sec) : " << m_loadingTime;
-}
-
 } // namespace Asset
 } // namespace Core
 } // namespace Ra
diff --git a/src/Core/Asset/GeometryData.cpp b/src/Core/Asset/GeometryData.cpp
index d4a78d62550..55584f79576 100644
--- a/src/Core/Asset/GeometryData.cpp
+++ b/src/Core/Asset/GeometryData.cpp
@@ -1,6 +1,6 @@
-#include "Core/Geometry/StandardAttribNames.hpp"
 #include <Core/Asset/GeometryData.hpp>
 
+#include <Core/Geometry/StandardAttribNames.hpp>
 #include <Core/Utils/Log.hpp>
 
 namespace Ra {
@@ -14,8 +14,6 @@ GeometryData::GeometryData( const std::string& name, const GeometryType& type )
     m_geometry(),
     m_material() {}
 
-GeometryData::~GeometryData() {}
-
 void GeometryData::displayInfo() const {
     using namespace Core::Utils; // log
     std::string type;
@@ -58,7 +56,7 @@ void GeometryData::displayInfo() const {
 
     using namespace Geometry;
     LOG( logINFO ) << "======== MESH INFO ========";
-    LOG( logINFO ) << " Name           : " << m_name;
+    LOG( logINFO ) << " Name           : " << getName();
     LOG( logINFO ) << " Type           : " << type;
     LOG( logINFO ) << " Edge #         : " << ( hasEdges() ? getPrimitiveCount() : 0 );
     LOG( logINFO ) << " Face #         : " << ( hasFaces() ? getPrimitiveCount() : 0 );
@@ -70,7 +68,7 @@ void GeometryData::displayInfo() const {
     LOG( logINFO ) << " Color ?        : " << hasAttrib( MeshAttrib::VERTEX_COLOR );
     LOG( logINFO ) << " Material ?     : " << ( ( !hasMaterial() ) ? "NO" : "YES" );
 
-    if ( hasMaterial() ) { m_material->displayInfo(); }
+    if ( hasMaterial() ) { m_material.displayInfo(); }
 }
 } // namespace Asset
 } // namespace Core
diff --git a/src/Core/Asset/GeometryData.hpp b/src/Core/Asset/GeometryData.hpp
index 59ccb880a41..4e424451ec9 100644
--- a/src/Core/Asset/GeometryData.hpp
+++ b/src/Core/Asset/GeometryData.hpp
@@ -1,87 +1,70 @@
 #pragma once
+#include <Core/RaCore.hpp>
 
 #include <Core/Asset/AssetData.hpp>
 #include <Core/Asset/MaterialData.hpp>
-#include <Core/Containers/VectorArray.hpp>
-#include <Core/Geometry/StandardAttribNames.hpp>
-#include <Core/Geometry/TriangleMesh.hpp>
-#include <Core/RaCore.hpp>
+#include <Core/Geometry/IndexedGeometry.hpp>
 #include <Core/Types.hpp>
-#include <Core/Utils/Attribs.hpp>
-#include <Core/Utils/Index.hpp>
 
-#include <memory>
 #include <string>
-#include <vector>
-
-#include <algorithm> //std::transform
 
 namespace Ra {
 namespace Core {
-namespace Asset {
-
-class MaterialData;
+using namespace Geometry;
 
+namespace Asset {
 /**
  * The GeometryData class stores all the geometry related data of a loaded object.
  */
 class RA_CORE_API GeometryData : public AssetData
 {
-  public:
-    using ColorArray = Vector4Array;
-
   public:
     EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 
     /**
      * The type of geometry.
      */
-    enum GeometryType {
-        UNKNOWN     = 1 << 0,
-        POINT_CLOUD = 1 << 1,
-        LINE_MESH   = 1 << 2,
-        TRI_MESH    = 1 << 3,
-        QUAD_MESH   = 1 << 4,
-        POLY_MESH   = 1 << 5,
-        TETRA_MESH  = 1 << 6,
-        HEX_MESH    = 1 << 7
+    enum GeometryType : unsigned int {
+        UNKNOWN     = 1u << 0u,
+        POINT_CLOUD = 1u << 1u,
+        LINE_MESH   = 1u << 2u,
+        TRI_MESH    = 1u << 3u,
+        QUAD_MESH   = 1u << 4u,
+        POLY_MESH   = 1u << 5u,
+        TETRA_MESH  = 1u << 6u,
+        HEX_MESH    = 1u << 7u
     };
 
-    GeometryData( const std::string& name = "", const GeometryType& type = UNKNOWN );
+    explicit GeometryData( const std::string& name = "", const GeometryType& type = UNKNOWN );
 
     GeometryData( const GeometryData& data ) = delete;
 
-    ~GeometryData();
-
     /// \name Data access
     /// \{
 
-    /// Return the name of the object.
-    inline void setName( const std::string& name );
-
     /// Return the type of geometry.
-    inline GeometryType getType() const;
+    inline GeometryType getType() const { return m_type; }
 
     /// Set the type of geometry.
-    inline void setType( const GeometryType& type );
+    inline void setType( const GeometryType& type ) { m_type = type; }
 
     /// Return the Transform of the object.
-    inline Transform getFrame() const;
+    inline Transform getFrame() const { return m_frame; }
 
     /// Set the Transform of the object.
-    inline void setFrame( const Transform& frame );
+    inline void setFrame( const Transform& frame ) { m_frame = frame; }
 
     /// Return the MaterialData associated to the objet.
-    inline const MaterialData& getMaterial() const;
+    inline const MaterialData& getMaterial() const { return m_material; }
 
     /// Set the MaterialData for the object.
-    inline void setMaterial( MaterialData* material );
+    inline void setMaterial( MaterialData material ) { m_material = material; }
 
     /// Read/write access to the multiIndexedGeometry;
-    inline Geometry::MultiIndexedGeometry& getGeometry();
+    inline MultiIndexedGeometry& getGeometry() { return m_geometry; }
 
     /// Read only access to the multiIndexedGeometry;
-    inline const Geometry::MultiIndexedGeometry& getGeometry() const;
+    inline const MultiIndexedGeometry& getGeometry() const { return m_geometry; }
 
     /// \}
 
@@ -89,26 +72,26 @@ class RA_CORE_API GeometryData : public AssetData
     /// \{
 
     /// Return true if the object is a Point Cloud.
-    inline bool isPointCloud() const;
+    inline bool isPointCloud() const { return m_type == POINT_CLOUD; }
 
     /// Return true if the object is a Line Mesh.
-    inline bool isLineMesh() const;
+    inline bool isLineMesh() const { return m_type == LINE_MESH; }
 
     /// Return true if the object is a Triangle Mesh.
-    inline bool isTriMesh() const;
+    inline bool isTriMesh() const { return m_type == TRI_MESH; }
 
     /// Return true if the object is a Quadrangle Mesh.
-    inline bool isQuadMesh() const;
+    inline bool isQuadMesh() const { return m_type == QUAD_MESH; }
 
     /// Return true if the object is a Polygon Mesh.
     /// \note Return false for Triangle and Quadrangle meshes.
-    inline bool isPolyMesh() const;
+    inline bool isPolyMesh() const { return m_type == POLY_MESH; }
 
     /// Return true if the object is a Tetrahedron Mesh.
-    inline bool isTetraMesh() const;
+    inline bool isTetraMesh() const { return m_type == TETRA_MESH; }
 
-    /// Return true if the object is a Hexahedron Mesh.
-    inline bool isHexMesh() const;
+    /// Return true if the object is a hexahedron Mesh.
+    inline bool isHexMesh() const { return m_type == HEX_MESH; }
 
     /// Return true if the object has lines.
     inline bool hasEdges() const;
@@ -120,17 +103,17 @@ class RA_CORE_API GeometryData : public AssetData
     inline bool hasPolyhedra() const;
 
     /// Return true if the object has MaterialData.
-    inline bool hasMaterial() const;
+    inline bool hasMaterial() const { return m_material.getMaterialModel() != nullptr; }
 
     /// Used to track easily the number of primitives in the geometry data
-    inline void setPrimitiveCount( int n );
+    inline void setPrimitiveCount( int n ) { m_primitiveCount = n; }
 
     /// Return the number of primitives in the geometry data
-    inline int getPrimitiveCount() const;
+    inline int getPrimitiveCount() const { return m_primitiveCount; }
 
     /// \}
 
-    /// Print stast info to the Debug output.
+    /// Print stat info to the Debug output.
     void displayInfo() const;
 
   protected:
@@ -141,86 +124,30 @@ class RA_CORE_API GeometryData : public AssetData
     GeometryType m_type;
 
     /// Named attributes
-    Core::Geometry::MultiIndexedGeometry m_geometry;
+    MultiIndexedGeometry m_geometry;
 
     /// Simple tracking of geometric primitive number
     int m_primitiveCount { -1 };
 
     /// The MaterialData for the object.
-    std::shared_ptr<MaterialData> m_material;
+    MaterialData m_material;
 };
 
-inline void GeometryData::setName( const std::string& name ) {
-    m_name = name;
-}
-
-inline GeometryData::GeometryType GeometryData::getType() const {
-    return m_type;
-}
-
-inline void GeometryData::setType( const GeometryType& type ) {
-    m_type = type;
-}
-
-inline Transform GeometryData::getFrame() const {
-    return m_frame;
-}
-
-inline void GeometryData::setFrame( const Transform& frame ) {
-    m_frame = frame;
-}
-
-inline const MaterialData& GeometryData::getMaterial() const {
-    return *( m_material.get() );
-}
-
-inline void GeometryData::setMaterial( MaterialData* material ) {
-    m_material.reset( material );
-}
-
-inline bool GeometryData::isPointCloud() const {
-    return ( m_type == POINT_CLOUD );
-}
-
-inline bool GeometryData::isLineMesh() const {
-    return ( m_type == LINE_MESH );
-}
-
-inline bool GeometryData::isTriMesh() const {
-    return ( m_type == TRI_MESH );
-}
-
-inline bool GeometryData::isQuadMesh() const {
-    return ( m_type == QUAD_MESH );
-}
-
-inline bool GeometryData::isPolyMesh() const {
-    return ( m_type == POLY_MESH );
-}
-
-inline bool GeometryData::isTetraMesh() const {
-    return ( m_type == TETRA_MESH );
-}
-
-inline bool GeometryData::isHexMesh() const {
-    return ( m_type == HEX_MESH );
-}
-
 inline bool GeometryData::hasEdges() const {
-    return m_geometry.containsLayer( { Geometry::LineIndexLayer::staticSemanticName }, "indices" );
+    return m_geometry.containsLayer( { LineIndexLayer::staticSemanticName }, "indices" );
 }
 
 inline bool GeometryData::hasFaces() const {
     std::string layerSemanticName;
     switch ( m_type ) {
     case TRI_MESH:
-        layerSemanticName = std::string( Geometry::TriangleIndexLayer::staticSemanticName );
+        layerSemanticName = std::string( TriangleIndexLayer::staticSemanticName );
         break;
     case QUAD_MESH:
-        layerSemanticName = std::string( Geometry::QuadIndexLayer::staticSemanticName );
+        layerSemanticName = std::string( QuadIndexLayer::staticSemanticName );
         break;
     case POLY_MESH:
-        layerSemanticName = std::string( Geometry::PolyIndexLayer::staticSemanticName );
+        layerSemanticName = std::string( PolyIndexLayer::staticSemanticName );
         break;
     default:
         return false;
@@ -229,26 +156,7 @@ inline bool GeometryData::hasFaces() const {
 }
 
 inline bool GeometryData::hasPolyhedra() const {
-    return m_geometry.containsLayer( { Geometry::PolyIndexLayer::staticSemanticName }, "indices" );
-}
-
-inline bool GeometryData::hasMaterial() const {
-    return m_material != nullptr;
-}
-
-const Geometry::MultiIndexedGeometry& GeometryData::getGeometry() const {
-    return m_geometry;
-}
-
-Geometry::MultiIndexedGeometry& GeometryData::getGeometry() {
-    return m_geometry;
-}
-
-inline void GeometryData::setPrimitiveCount( int n ) {
-    m_primitiveCount = n;
-}
-inline int GeometryData::getPrimitiveCount() const {
-    return m_primitiveCount;
+    return m_geometry.containsLayer( { PolyIndexLayer::staticSemanticName }, "indices" );
 }
 
 } // namespace Asset
diff --git a/src/Core/Asset/HandleData.cpp b/src/Core/Asset/HandleData.cpp
index 98be19ca307..2ceb30a19d7 100644
--- a/src/Core/Asset/HandleData.cpp
+++ b/src/Core/Asset/HandleData.cpp
@@ -1,15 +1,37 @@
 #include <Core/Asset/HandleData.hpp>
 
+#include <Core/Utils/Log.hpp>
+
 namespace Ra {
 namespace Core {
 namespace Asset {
 
-HandleComponentData::HandleComponentData() : m_name( "" ) {}
-
-HandleData::HandleData( const std::string& name, const HandleType& type ) :
-    AssetData( name ), m_type( type ) {}
-
-HandleData::~HandleData() {}
+void HandleData::displayInfo() const {
+    using namespace Core::Utils; // log
+    std::string type;
+    switch ( m_type ) {
+    case POINT_CLOUD:
+        type = "POINT CLOUD";
+        break;
+    case SKELETON:
+        type = "SKELETON";
+        break;
+    case CAGE:
+        type = "CAGE";
+        break;
+    case UNKNOWN:
+    default:
+        type = "UNKNOWN";
+        break;
+    }
+    LOG( logINFO ) << "======== HANDLE INFO ========";
+    LOG( logINFO ) << " Name            : " << getName();
+    LOG( logINFO ) << " Type            : " << type;
+    LOG( logINFO ) << " Element #       : " << m_component.size();
+    LOG( logINFO ) << " Edge #          : " << m_edge.size();
+    LOG( logINFO ) << " Face #          : " << m_face.size();
+    LOG( logINFO ) << " Need EndNodes ? : " << ( ( m_endNode ) ? "YES" : "NO" );
+}
 
 } // namespace Asset
 } // namespace Core
diff --git a/src/Core/Asset/HandleData.hpp b/src/Core/Asset/HandleData.hpp
index 9995f3974e8..04f6c307a7b 100644
--- a/src/Core/Asset/HandleData.hpp
+++ b/src/Core/Asset/HandleData.hpp
@@ -4,7 +4,6 @@
 #include <Core/Containers/AlignedStdVector.hpp>
 #include <Core/RaCore.hpp>
 #include <Core/Types.hpp>
-#include <Core/Utils/Log.hpp>
 
 #include <map>
 #include <set>
@@ -21,8 +20,6 @@ namespace Asset {
 struct RA_CORE_API HandleComponentData {
     EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 
-    HandleComponentData();
-
     /// Handle name.
     std::string m_name;
 
@@ -32,7 +29,7 @@ struct RA_CORE_API HandleComponentData {
     /// Per skinned-mesh matrix from mesh space to bone space (local).
     std::map<std::string, Core::Transform> m_bindMatrices;
 
-    /// Per skinned-mesh vertex weigths.
+    /// Per skinned-mesh vertex weights.
     std::map<std::string, std::vector<std::pair<uint, Scalar>>> m_weights;
 };
 
@@ -49,65 +46,59 @@ class RA_CORE_API HandleData : public AssetData
      */
     enum HandleType { UNKNOWN = 1 << 0, POINT_CLOUD = 1 << 1, SKELETON = 1 << 2, CAGE = 1 << 3 };
 
-    HandleData( const std::string& name = "", const HandleType& type = UNKNOWN );
-
-    HandleData( const HandleData& data ) = default;
-
-    ~HandleData();
+    explicit HandleData( const std::string& name = "", const HandleType& type = UNKNOWN ) :
+        AssetData( name ), m_type( type ) {}
 
     /// \name HandleArray
     /// \{
 
-    /**
-     * Set the name of the Handle system.
-     */
-    inline void setName( const std::string& name );
-
     /**
      * Return the type of the Handle system.
      */
-    inline HandleType getType() const;
+    inline HandleType getType() const { return m_type; }
 
     /**
      * Set the type of the Handle system.
      */
-    inline void setType( const HandleType& type );
+    inline void setType( const HandleType& type ) { m_type = type; }
 
     /**
      * Return the transformation of the Handle system.
      */
-    inline Core::Transform getFrame() const;
+    inline Core::Transform getFrame() const { return m_frame; }
 
     /**
      * Set the transformation of the Handle system.
      */
-    inline void setFrame( const Core::Transform& frame );
+    inline void setFrame( const Core::Transform& frame ) { m_frame = frame; }
 
     /**
      * Add \p name to the list of bound mesh names.
      */
-    inline void addBindMesh( const std::string& name );
+    inline void addBindMesh( const std::string& name ) { m_bindMeshes.insert( name ); }
 
     /**
      * Returns the list of bound mesh names.
      */
-    inline const std::set<std::string>& getBindMeshes() const;
+    inline const std::set<std::string>& getBindMeshes() const { return m_bindMeshes; }
     /// \}
 
     /**
      * Return the maximal number of vertices influenced by a Handle.
      */
-    inline uint getVertexSize() const;
+    inline uint getVertexSize() const { return m_vertexSize; }
 
     /**
      * Set the maximal number of vertices influenced by a Handle.
      */
-    inline void setVertexSize( uint size );
+    inline void setVertexSize( uint size ) { m_vertexSize = size; }
 
     /**
      * Set the map from Handle names to Handle storage index.
      */
-    inline void setNameTable( const std::map<std::string, uint>& nameTable );
+    inline void setNameTable( const std::map<std::string, uint>& nameTable ) {
+        m_nameTable = nameTable;
+    }
 
     /**
      * Recompute the map from Handle names to Handle storage index.
@@ -120,17 +111,17 @@ class RA_CORE_API HandleData : public AssetData
     /**
      * Return the number of Handles in the system.
      */
-    inline uint getComponentDataSize() const;
+    inline uint getComponentDataSize() const { return m_component.size(); }
 
     /**
      * Return the list of HandleComponentData.
      */
-    inline const Core::AlignedStdVector<HandleComponentData>& getComponentData() const;
+    inline const auto& getComponentData() const { return m_component; }
 
     /**
      * Return the list of HandleComponentData.
      */
-    inline Core::AlignedStdVector<HandleComponentData>& getComponentData();
+    inline auto& getComponentData() { return m_component; }
 
     /**
      * Return the \p i-th HandleComponentData.
@@ -145,42 +136,48 @@ class RA_CORE_API HandleData : public AssetData
     /**
      * Set the HandleComponentData for the Handle system.
      */
-    inline void setComponents( const Core::AlignedStdVector<HandleComponentData>& components );
+    inline void setComponents( Core::AlignedStdVector<HandleComponentData>&& components ) {
+        m_component = std::move( components );
+    }
 
     /**
      * Return the HandleArray hierarchy, i.e.\ bones hierarchy.
      */
-    inline const Core::AlignedStdVector<Core::Vector2ui>& getEdgeData() const;
+    inline const auto& getEdgeData() const { return m_edge; }
 
     /**
      * Return the HandleArray hierarchy, i.e.\ bones hierarchy.
      */
-    inline Core::AlignedStdVector<Core::Vector2ui>& getEdgeData();
+    inline auto& getEdgeData() { return m_edge; }
 
     /**
      * Set the HandleArray linear hierarchy part, i.e.\ bones hierarchy.
      */
-    inline void setEdges( const Core::AlignedStdVector<Core::Vector2ui>& edgeList );
+    inline void setEdges( Core::AlignedStdVector<Core::Vector2ui>&& edgeList ) {
+        m_edge = std::move( edgeList );
+    }
 
     /**
      * Return the HandleArray N-Dimensional parts, i.e.\ cage polyhedra.
      */
-    inline const Core::AlignedStdVector<Core::VectorNui>& getFaceData() const;
+    inline const auto& getFaceData() const { return m_face; }
 
     /**
      * Return the HandleArray N-Dimensional parts, i.e.\ cage polyhedra.
      */
-    inline Core::AlignedStdVector<Core::VectorNui>& getFaceData();
+    inline auto& getFaceData() { return m_face; }
 
     /**
      * Set the HandleArray N-Dimensional parts, i.e.\ cage polyhedra.
      */
-    inline void setFaces( const Core::AlignedStdVector<Core::VectorNui>& faceList );
-
+    // inline void setFaces( const Core::AlignedStdVector<Core::VectorNui>& faceList );
+    inline void setFaces( Core::AlignedStdVector<Core::VectorNui>&& faceList ) {
+        m_face = std::move( faceList );
+    }
     /**
      * Set whether the Handle system needs end bones.
      */
-    inline void needEndNodes( bool need );
+    inline void needEndNodes( bool need ) { m_endNode = need; }
     /// \}
 
     /// \name Status querries
@@ -189,37 +186,37 @@ class RA_CORE_API HandleData : public AssetData
     /**
      * Return true if the Handle system is a Point Cloud.
      */
-    inline bool isPointCloud() const;
+    inline bool isPointCloud() const { return m_type == POINT_CLOUD; }
 
     /**
      * Return true if the Handle system is a Skeleton.
      */
-    inline bool isSkeleton() const;
+    inline bool isSkeleton() const { return m_type == SKELETON; }
 
     /**
      * Return true if the Handle system is a Cage.
      */
-    inline bool isCage() const;
+    inline bool isCage() const { return m_type == CAGE; }
 
     /**
      * Return true if the Handle system has Handles.
      */
-    inline bool hasComponents() const;
+    inline bool hasComponents() const { return !m_component.empty(); }
 
     /**
      * Return true if the Handle system has a hierarchy.
      */
-    inline bool hasEdges() const;
+    inline bool hasEdges() const { return !m_edge.empty(); }
 
     /**
      * Return true if the Handle system has N-Dimensional parts.
      */
-    inline bool hasFaces() const;
+    inline bool hasFaces() const { return !m_face.empty(); }
 
     /**
      * Return true if the Handle system needs end bones.
      */
-    inline bool needsEndNodes() const;
+    inline bool needsEndNodes() const { return m_endNode; }
 
     /**
      * Return the storage index of the Handle with the given name
@@ -231,7 +228,7 @@ class RA_CORE_API HandleData : public AssetData
     /**
      * Print stat info to the Debug output.
      */
-    inline void displayInfo() const;
+    void displayInfo() const;
 
   private:
     /// The type of the Handle system.
@@ -262,59 +259,6 @@ class RA_CORE_API HandleData : public AssetData
     Core::AlignedStdVector<Core::VectorNui> m_face;
 };
 
-inline void HandleData::setName( const std::string& name ) {
-    m_name = name;
-}
-
-inline HandleData::HandleType HandleData::getType() const {
-    return m_type;
-}
-
-inline void HandleData::setType( const HandleType& type ) {
-    m_type = type;
-}
-
-inline Core::Transform HandleData::getFrame() const {
-    return m_frame;
-}
-
-inline void HandleData::setFrame( const Core::Transform& frame ) {
-    m_frame = frame;
-}
-
-inline uint HandleData::getVertexSize() const {
-    return m_vertexSize;
-}
-inline void HandleData::setVertexSize( uint size ) {
-    m_vertexSize = size;
-}
-
-inline void HandleData::setNameTable( const std::map<std::string, uint>& nameTable ) {
-    m_nameTable = nameTable;
-}
-
-inline uint HandleData::getComponentDataSize() const {
-    return m_component.size();
-}
-
-inline const Core::AlignedStdVector<HandleComponentData>& HandleData::getComponentData() const {
-    return m_component;
-}
-
-inline Core::AlignedStdVector<HandleComponentData>& HandleData::getComponentData() {
-    return m_component;
-}
-
-inline void
-HandleData::setComponents( const Core::AlignedStdVector<HandleComponentData>& components ) {
-    const uint size = components.size();
-    m_component.resize( size );
-#pragma omp parallel for
-    for ( int i = 0; i < int( size ); ++i ) {
-        m_component[i] = components[i];
-    }
-}
-
 inline const HandleComponentData& HandleData::getComponent( const uint i ) const {
     CORE_ASSERT( ( i < m_component.size() ), "Index i out of bound" );
     return m_component[i];
@@ -325,40 +269,6 @@ inline HandleComponentData& HandleData::getComponent( const uint i ) {
     return m_component[i];
 }
 
-inline const Core::AlignedStdVector<Core::Vector2ui>& HandleData::getEdgeData() const {
-    return m_edge;
-}
-
-inline Core::AlignedStdVector<Core::Vector2ui>& HandleData::getEdgeData() {
-    return m_edge;
-}
-
-inline void HandleData::setEdges( const Core::AlignedStdVector<Core::Vector2ui>& edgeList ) {
-    const uint size = edgeList.size();
-    m_edge.resize( size );
-#pragma omp parallel for
-    for ( int i = 0; i < int( size ); ++i ) {
-        m_edge[i] = edgeList[i];
-    }
-}
-
-inline const Core::AlignedStdVector<Core::VectorNui>& HandleData::getFaceData() const {
-    return m_face;
-}
-
-inline Core::AlignedStdVector<Core::VectorNui>& HandleData::getFaceData() {
-    return m_face;
-}
-
-inline void HandleData::setFaces( const Core::AlignedStdVector<Core::VectorNui>& faceList ) {
-    const uint size = faceList.size();
-    m_face.resize( size );
-#pragma omp parallel for
-    for ( int i = 0; i < int( size ); ++i ) {
-        m_face[i] = faceList[i];
-    }
-}
-
 inline void HandleData::recomputeAllIndices() {
     m_nameTable.clear();
     for ( uint i = 0; i < getComponentDataSize(); ++i ) {
@@ -366,79 +276,12 @@ inline void HandleData::recomputeAllIndices() {
     }
 }
 
-inline bool HandleData::isPointCloud() const {
-    return ( m_type == POINT_CLOUD );
-}
-
-inline bool HandleData::isSkeleton() const {
-    return ( m_type == SKELETON );
-}
-
-inline bool HandleData::isCage() const {
-    return ( m_type == CAGE );
-}
-
-inline bool HandleData::hasComponents() const {
-    return !m_component.empty();
-}
-
-inline bool HandleData::hasEdges() const {
-    return !m_edge.empty();
-}
-
-inline bool HandleData::hasFaces() const {
-    return !m_face.empty();
-}
-
-inline bool HandleData::needsEndNodes() const {
-    return m_endNode;
-}
-
 inline int HandleData::getIndexOf( const std::string& name ) const {
     auto it = m_nameTable.find( name );
     if ( it == m_nameTable.end() ) { return -1; }
     return it->second;
 }
 
-inline void HandleData::needEndNodes( bool need ) {
-    m_endNode = need;
-}
-
-inline void HandleData::addBindMesh( const std::string& name ) {
-    m_bindMeshes.insert( name );
-}
-
-inline const std::set<std::string>& HandleData::getBindMeshes() const {
-    return m_bindMeshes;
-}
-
-inline void HandleData::displayInfo() const {
-    using namespace Core::Utils; // log
-    std::string type;
-    switch ( m_type ) {
-    case POINT_CLOUD:
-        type = "POINT CLOUD";
-        break;
-    case SKELETON:
-        type = "SKELETON";
-        break;
-    case CAGE:
-        type = "CAGE";
-        break;
-    case UNKNOWN:
-    default:
-        type = "UNKNOWN";
-        break;
-    }
-    LOG( logINFO ) << "======== HANDLE INFO ========";
-    LOG( logINFO ) << " Name            : " << m_name;
-    LOG( logINFO ) << " Type            : " << type;
-    LOG( logINFO ) << " Element #       : " << m_component.size();
-    LOG( logINFO ) << " Edge #          : " << m_edge.size();
-    LOG( logINFO ) << " Face #          : " << m_face.size();
-    LOG( logINFO ) << " Need EndNodes ? : " << ( ( m_endNode ) ? "YES" : "NO" );
-}
-
 } // namespace Asset
 } // namespace Core
 } // namespace Ra
diff --git a/src/Core/Asset/LightData.cpp b/src/Core/Asset/LightData.cpp
index a1fe8efc174..3a2b5a5ae62 100644
--- a/src/Core/Asset/LightData.cpp
+++ b/src/Core/Asset/LightData.cpp
@@ -1,12 +1,12 @@
 #include <Core/Asset/LightData.hpp>
 
+#include <Core/Utils/Log.hpp>
+
 namespace Ra {
 namespace Core {
 namespace Asset {
 
 /// CONSTRUCTOR
-LightData::LightData( const std::string& name, const LightType& type ) :
-    AssetData( name ), m_frame( Eigen::Matrix<Scalar, 4, 4>::Identity() ), m_type( type ) {}
 
 LightData::LightData( const LightData& data ) :
     AssetData( data ), m_frame( data.m_frame ), m_type( data.m_type ), m_color( data.m_color ) {
@@ -29,8 +29,31 @@ LightData::LightData( const LightData& data ) :
     }
 }
 
-/// DESTRUCTOR
-LightData::~LightData() {}
+void LightData::displayInfo() const {
+    using namespace Core::Utils; // log
+    std::string type;
+    switch ( m_type ) {
+    case POINT_LIGHT:
+        type = "POINT LIGHT";
+        break;
+    case SPOT_LIGHT:
+        type = "SPOT LIGHT";
+        break;
+    case DIRECTIONAL_LIGHT:
+        type = "DIRECTIONAL LIGHT";
+        break;
+    case AREA_LIGHT:
+        type = "AREA LIGHT";
+        break;
+    case UNKNOWN:
+    default:
+        type = "UNKNOWN";
+        break;
+    }
+    LOG( logINFO ) << "======== LIGHT INFO ========";
+    LOG( logINFO ) << " Name           : " << getName();
+    LOG( logINFO ) << " Type           : " << type;
+}
 
 } // namespace Asset
 } // namespace Core
diff --git a/src/Core/Asset/LightData.hpp b/src/Core/Asset/LightData.hpp
index f6659196ea3..35a174226e6 100644
--- a/src/Core/Asset/LightData.hpp
+++ b/src/Core/Asset/LightData.hpp
@@ -1,9 +1,9 @@
 #pragma once
+#include <Core/RaCore.hpp>
 
 #include <Core/Asset/AssetData.hpp>
-#include <Core/RaCore.hpp>
+#include <Core/Types.hpp>
 #include <Core/Utils/Color.hpp>
-#include <Core/Utils/Log.hpp>
 
 #include <memory>
 #include <string>
@@ -31,23 +31,23 @@ class RA_CORE_API LightData : public AssetData
     /** Supported light type
      *
      */
-    enum LightType {
-        UNKNOWN           = 1 << 0,
-        POINT_LIGHT       = 1 << 1,
-        SPOT_LIGHT        = 1 << 2,
-        DIRECTIONAL_LIGHT = 1 << 3,
-        AREA_LIGHT        = 1 << 4
+    enum LightType : unsigned int {
+        UNKNOWN           = 1u << 0u,
+        POINT_LIGHT       = 1u << 1u,
+        SPOT_LIGHT        = 1u << 2u,
+        DIRECTIONAL_LIGHT = 1u << 3u,
+        AREA_LIGHT        = 1u << 4u
     };
 
     /**
      * Define the parameters of the attenuation function.
-     * The only supported attenuation function is 1/ (constant + linear*dist + quadradic*dist^2 )
+     * The only supported attenuation function is 1/ (constant + linear*dist + quadratic*dist^2 )
      */
     struct LightAttenuation {
-        Scalar constant;
-        Scalar linear;
-        Scalar quadratic;
-        explicit LightAttenuation( Scalar c = 1, Scalar l = 0, Scalar q = 0 ) :
+        Scalar constant { 1_ra };
+        Scalar linear { 0_ra };
+        Scalar quadratic { 0_ra };
+        explicit LightAttenuation( Scalar c = 1_ra, Scalar l = 0_ra, Scalar q = 0_ra ) :
             constant( c ), linear( l ), quadratic( q ) {}
     };
     // TODO : allow to define other attenuation function such
@@ -55,9 +55,10 @@ class RA_CORE_API LightData : public AssetData
 
     /**
      * Light constructor.
-     * Must be called explicitely with a name for the light and its type.
+     * Must be called explicitly with a name for the light and its type.
      */
-    explicit LightData( const std::string& name = "", const LightType& type = UNKNOWN );
+    explicit LightData( const std::string& name = "", const LightType& type = UNKNOWN ) :
+        AssetData( name ), m_type( type ) {}
 
     /**
      * Copy constructor.
@@ -67,27 +68,17 @@ class RA_CORE_API LightData : public AssetData
      */
     LightData( const LightData& data );
 
-    /// Destructor
-    ~LightData();
-
     /**
-     * Extension of of the AssetData interface so that we can modify an abcet afeter ts creation.
-     * This has no impact on the coherence of the LightData object and could be used without
-     * restriction.
-     */
-    inline void setName( const std::string& name );
-
-    /**
-     * Acces to the local frame of the light.
+     * Access to the local frame of the light.
      * @return the local frame
      */
-    inline const Eigen::Matrix<Scalar, 4, 4>& getFrame() const;
+    inline const Matrix4& getFrame() const { return m_frame; }
 
     /**
      * Set the local frame of the light.
      * @param frame the local frame
      */
-    inline void setFrame( const Eigen::Matrix<Scalar, 4, 4>& frame );
+    inline void setFrame( const Matrix4& frame ) { m_frame = frame; }
 
     /**
      * Construct a directional light.
@@ -97,8 +88,7 @@ class RA_CORE_API LightData : public AssetData
      * ``DIRECTIONAL_LIGHT`` light, whatever it was before the call and only the directional light
      * part of the union is consistent after the call
      */
-    inline void setLight( const Core::Utils::Color& color,
-                          const Eigen::Matrix<Scalar, 3, 1>& direction );
+    inline void setLight( const Core::Utils::Color& color, const Vector3& direction );
 
     /**
      * Construct a point light.
@@ -108,98 +98,98 @@ class RA_CORE_API LightData : public AssetData
      * the union is consistent after the call
      */
     inline void setLight( const Core::Utils::Color& color,
-                          const Eigen::Matrix<Scalar, 3, 1>& position,
+                          const Vector3& position,
                           LightAttenuation attenuation );
 
     /**
      * Construct a spot light.
      * A spot light is defined by its color, its position, the cone axis and light distribution
-     * (constant inside inangle, quadratically deacreasing toward 0 fron inAngle to ouAngle) and its
+     * (constant inside inAngle, quadratically decreasing toward 0 from inAngle to ouAngle) and its
      * attenuation. \note The object on which this method is called is unconditionally promoted to
      * ``SPOT_LIGHT`` light, whatever it was before the call and only the directional light part of
      * the union is consistent after the call
      */
     inline void setLight( const Core::Utils::Color& color,
-                          const Eigen::Matrix<Scalar, 3, 1>& position,
-                          const Eigen::Matrix<Scalar, 3, 1>& direction,
+                          const Vector3& position,
+                          const Vector3& direction,
                           Scalar inAngle,
                           Scalar outAngle,
                           LightAttenuation attenuation );
 
     /**
      * Construct a area light.
-     * An area light, (isotropic with constant emision defined by its color) is approximated by its
+     * An area light, (isotropic with constant emission defined by its color) is approximated by its
      * center and the covariance matrices modelling the spatial extent as well as the elliptical
      * distribution of normals. \note The object on which this method is called is unconditionally
      * promoted to ``AREA_LIGHT`` light, whatever it was before the call and only the directional
      * light part of the union is consistent after the call
      */
     inline void setLight( const Core::Utils::Color& color,
-                          const Eigen::Matrix<Scalar, 3, 1>& cog,
-                          const Eigen::Matrix<Scalar, 3, 3>& spatialCov,
-                          const Eigen::Matrix<Scalar, 3, 3>& normalCov,
+                          const Vector3& cog,
+                          const Matrix3& spatialCov,
+                          const Matrix3& normalCov,
                           LightAttenuation attenuation );
 
     /**
      * Access to the type of the object
      */
-    inline LightType getType() const;
+    inline LightType getType() const { return m_type; }
 
     /**
      * Returns true if the light is a PointLight
      */
-    inline bool isPointLight() const;
+    inline bool isPointLight() const { return m_type == POINT_LIGHT; }
 
     /**
      * Returns true if the light is a SpotLight
      */
-    inline bool isSpotLight() const;
+    inline bool isSpotLight() const { return m_type == SPOT_LIGHT; }
 
     /**
      * Returns true if the light is a DirectionalLight
      */
-    inline bool isDirectionalLight() const;
+    inline bool isDirectionalLight() const { return m_type == DIRECTIONAL_LIGHT; }
 
     /**
      * Returns true if the light is an AreaLight
      */
-    inline bool isAreaLight() const;
+    inline bool isAreaLight() const { return m_type == AREA_LIGHT; }
 
     /**
-     * For debugging purpose, prints out the formated content of the LightData object.
+     * For debugging purpose, prints out the formatted content of the LightData object.
      */
-    inline void displayInfo() const;
+    void displayInfo() const;
 
   protected:
     /// VARIABLE
 
-    Eigen::Matrix<Scalar, 4, 4> m_frame;
-    LightType m_type;
+    Matrix4 m_frame { Matrix4::Identity() };
+    LightType m_type { UNKNOWN };
 
     // This part is public so that systems handling lights could access to the data.
-    // TODO : make these protected with getters ? Define independant types ?
+    // TODO : make these protected with getters ? Define independent types ?
   public:
-    Core::Utils::Color m_color;
+    Core::Utils::Color m_color { Utils::Color::White() };
 
     struct DirLight {
-        Eigen::Matrix<Scalar, 3, 1> direction;
+        Vector3 direction;
     };
     struct PointLight {
-        Eigen::Matrix<Scalar, 3, 1> position;
+        Vector3 position;
         LightAttenuation attenuation;
     };
     struct SpotLight {
-        Eigen::Matrix<Scalar, 3, 1> position;
-        Eigen::Matrix<Scalar, 3, 1> direction;
+        Vector3 position;
+        Vector3 direction;
         Scalar innerAngle;
         Scalar outerAngle;
         LightAttenuation attenuation;
     };
     struct AreaLight {
-        // TODO : this representation is usefull but might be improved
-        Eigen::Matrix<Scalar, 3, 1> position;
-        Eigen::Matrix<Scalar, 3, 3> spatialCovariance;
-        Eigen::Matrix<Scalar, 3, 3> normalCovariance;
+        // TODO : this representation is useful but might be improved
+        Vector3 position;
+        Matrix3 spatialCovariance;
+        Matrix3 normalCovariance;
         LightAttenuation attenuation;
     };
 
@@ -215,28 +205,8 @@ class RA_CORE_API LightData : public AssetData
 ///  LIGHT DATA   ///
 /////////////////////
 
-/// NAME
-inline void LightData::setName( const std::string& name ) {
-    m_name = name;
-}
-
-/// TYPE
-inline LightData::LightType LightData::getType() const {
-    return m_type;
-}
-
-/// FRAME
-inline const Eigen::Matrix<Scalar, 4, 4>& LightData::getFrame() const {
-    return m_frame;
-}
-
-inline void LightData::setFrame( const Eigen::Matrix<Scalar, 4, 4>& frame ) {
-    m_frame = frame;
-}
-
 /// construct a directional light
-inline void LightData::setLight( const Core::Utils::Color& color,
-                                 const Eigen::Matrix<Scalar, 3, 1>& direction ) {
+inline void LightData::setLight( const Core::Utils::Color& color, const Vector3& direction ) {
     m_type               = DIRECTIONAL_LIGHT;
     m_color              = color;
     m_dirlight.direction = direction;
@@ -244,7 +214,7 @@ inline void LightData::setLight( const Core::Utils::Color& color,
 
 /// construct a point light
 inline void LightData::setLight( const Core::Utils::Color& color,
-                                 const Eigen::Matrix<Scalar, 3, 1>& position,
+                                 const Vector3& position,
                                  LightAttenuation attenuation ) {
     m_type                   = POINT_LIGHT;
     m_color                  = color;
@@ -254,8 +224,8 @@ inline void LightData::setLight( const Core::Utils::Color& color,
 
 /// construct a spot light
 inline void LightData::setLight( const Core::Utils::Color& color,
-                                 const Eigen::Matrix<Scalar, 3, 1>& position,
-                                 const Eigen::Matrix<Scalar, 3, 1>& direction,
+                                 const Vector3& position,
+                                 const Vector3& direction,
                                  Scalar inAngle,
                                  Scalar outAngle,
                                  LightAttenuation attenuation ) {
@@ -270,9 +240,9 @@ inline void LightData::setLight( const Core::Utils::Color& color,
 
 /// construct an area light
 inline void LightData::setLight( const Core::Utils::Color& color,
-                                 const Eigen::Matrix<Scalar, 3, 1>& cog,
-                                 const Eigen::Matrix<Scalar, 3, 3>& spatialCov,
-                                 const Eigen::Matrix<Scalar, 3, 3>& normalCov,
+                                 const Vector3& cog,
+                                 const Matrix3& spatialCov,
+                                 const Matrix3& normalCov,
                                  LightAttenuation attenuation ) {
     m_type                        = AREA_LIGHT;
     m_color                       = color;
@@ -282,50 +252,6 @@ inline void LightData::setLight( const Core::Utils::Color& color,
     m_arealight.attenuation       = attenuation;
 }
 
-/// QUERY
-inline bool LightData::isPointLight() const {
-    return ( m_type == POINT_LIGHT );
-}
-
-inline bool LightData::isSpotLight() const {
-    return ( m_type == SPOT_LIGHT );
-}
-
-inline bool LightData::isDirectionalLight() const {
-    return ( m_type == DIRECTIONAL_LIGHT );
-}
-
-inline bool LightData::isAreaLight() const {
-    return ( m_type == AREA_LIGHT );
-}
-
-/// DEBUG
-inline void LightData::displayInfo() const {
-    using namespace Core::Utils; // log
-    std::string type;
-    switch ( m_type ) {
-    case POINT_LIGHT:
-        type = "POINT LIGHT";
-        break;
-    case SPOT_LIGHT:
-        type = "SPOT LIGHT";
-        break;
-    case DIRECTIONAL_LIGHT:
-        type = "DIRECTIONAL LIGHT";
-        break;
-    case AREA_LIGHT:
-        type = "AREA LIGHT";
-        break;
-    case UNKNOWN:
-    default:
-        type = "UNKNOWN";
-        break;
-    }
-    LOG( logINFO ) << "======== LIGHT INFO ========";
-    LOG( logINFO ) << " Name           : " << m_name;
-    LOG( logINFO ) << " Type           : " << type;
-}
-
 } // namespace Asset
 } // namespace Core
 } // namespace Ra
diff --git a/src/Core/Asset/MaterialData.cpp b/src/Core/Asset/MaterialData.cpp
deleted file mode 100644
index 3d23b34daff..00000000000
--- a/src/Core/Asset/MaterialData.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-#include <Core/Asset/MaterialData.hpp>
-#include <Core/Utils/Log.hpp>
-
-namespace Ra {
-namespace Core {
-namespace Asset {
-
-/// CONSTRUCTOR
-MaterialData::MaterialData( const std::string& name, const std::string& type ) :
-    AssetData( name ), m_type( type ) {}
-
-MaterialData::~MaterialData() {}
-
-/// DEBUG
-void MaterialData::displayInfo() const {
-    using namespace Core::Utils; // log
-    LOG( logERROR ) << "MaterialData : unkonwn material type : " << m_type;
-}
-
-} // namespace Asset
-} // namespace Core
-} // namespace Ra
diff --git a/src/Core/Asset/MaterialData.hpp b/src/Core/Asset/MaterialData.hpp
index fce815bf100..e6620a963e3 100644
--- a/src/Core/Asset/MaterialData.hpp
+++ b/src/Core/Asset/MaterialData.hpp
@@ -5,11 +5,14 @@
 #include <Core/Asset/AssetData.hpp>
 #include <Core/RaCore.hpp>
 
+#include <Core/Material/MaterialModel.hpp>
+
 namespace Ra {
 namespace Core {
 namespace Asset {
 
-/** @brief represent material data loaded by a file loader.
+/** \brief represent material data loaded by a file loader.
+ * \todo rewrite the doc
  * Material data must be identified by a unique name.
  * Radium Engine reserves the following names
  *  "AbstractMaterial"  --> unknown material, might serve for error management
@@ -32,58 +35,27 @@ namespace Asset {
  *
  *      The active system (GeometrySystem is the Radium Default), will then automatically use your
  * new material and technique so that the rendering will be fine. When writing your own system, see
- * GeometrySystem implementation as an example.
- *
- *  That's all folks.
+ * GeometrySystem implementation as an example
  */
 class RA_CORE_API MaterialData : public AssetData
 {
   public:
     /// MATERIAL DATA
-    MaterialData( const std::string& name = "", const std::string& type = "AbstractMaterial" );
-    virtual ~MaterialData();
-
-    /// NAME
-    inline void setName( const std::string& name );
-
-    /// TYPE
-    inline std::string getType() const;
-
-    inline void setType( const std::string& type );
+    MaterialData( const std::string& name = "" ) : AssetData( name ) {}
 
     /// DEBUG
-    virtual void displayInfo() const;
+    void displayInfo() const {
+        if ( m_material ) { m_material->displayInfo(); }
+    }
+
+    /// Model
+    void setMaterialModel( Material::MaterialModelPtr model ) { m_material = model; }
+    Material::MaterialModelPtr getMaterialModel() const { return m_material; }
 
   private:
-    std::string m_type;
+    Material::MaterialModelPtr m_material;
 };
 
 } // namespace Asset
 } // namespace Core
 } // namespace Ra
-
-namespace Ra {
-namespace Core {
-namespace Asset {
-
-////////////////
-/// MATERIAL ///
-////////////////
-
-/// NAME
-inline void MaterialData::setName( const std::string& name ) {
-    m_name = name;
-}
-
-/// TYPE
-inline std::string MaterialData::getType() const {
-    return m_type;
-}
-
-inline void MaterialData::setType( const std::string& type ) {
-    m_type = type;
-}
-
-} // namespace Asset
-} // namespace Core
-} // namespace Ra
diff --git a/src/Core/Asset/VolumeData.hpp b/src/Core/Asset/VolumeData.hpp
index c09e4ae706b..c3c17f187a0 100644
--- a/src/Core/Asset/VolumeData.hpp
+++ b/src/Core/Asset/VolumeData.hpp
@@ -16,10 +16,10 @@ namespace Asset {
  * Participating media defined by a grid density
  */
 struct VolumeData : public AssetData {
-    inline VolumeData( const std::string& name = "" ) : AssetData( name ) {}
-    /// The underlaying density matrix
+    explicit VolumeData( const std::string& name = "" ) : AssetData( name ) {}
+    /// The underlying density matrix
     Geometry::AbstractVolume* volume { nullptr };
-    /// Absortion coefficient of the volume (default is Air)
+    /// Absorption coefficient of the volume (default is Air)
     Utils::Color sigma_a { 0.0011_ra, 0.0024_ra, 0.014_ra };
     /// Scattering coefficient of the volume (default is Air)
     Utils::Color sigma_s { 2.55_ra, 3.21_ra, 3.77_ra };
diff --git a/src/Core/Material/BlinnPhongMaterialModel.cpp b/src/Core/Material/BlinnPhongMaterialModel.cpp
new file mode 100644
index 00000000000..5ff3a48a53e
--- /dev/null
+++ b/src/Core/Material/BlinnPhongMaterialModel.cpp
@@ -0,0 +1,29 @@
+#include <Core/Material/BlinnPhongMaterialModel.hpp>
+
+#include <Core/Utils/Log.hpp>
+
+namespace Ra {
+namespace Core {
+namespace Material {
+void BlinnPhongMaterialModel::displayInfo() const {
+    using namespace Core::Utils; // log
+    auto print = []( bool ok, const std::string& name, const auto& value ) {
+        if ( ok ) { LOG( logINFO ) << name << value; }
+        else { LOG( logINFO ) << name << "NO"; }
+    };
+
+    LOG( logINFO ) << "======== MATERIAL INFO ========";
+    print( true, " Type           : ", getType() );
+    print( true, " Kd             : ", m_kd.transpose() );
+    print( true, " Ks             : ", m_ks.transpose() );
+    print( true, " Ns             : ", m_ns );
+    print( true, " Opacity        : ", m_alpha );
+    print( hasDiffuseTexture(), " Kd Texture     : ", m_texDiffuse );
+    print( hasSpecularTexture(), " Ks Texture     : ", m_texSpecular );
+    print( hasShininessTexture(), " Ns Texture     : ", m_texShininess );
+    print( hasNormalTexture(), " Normal Texture : ", m_texNormal );
+    print( hasOpacityTexture(), " Alpha Texture  : ", m_texOpacity );
+}
+} // namespace Material
+} // namespace Core
+} // namespace Ra
diff --git a/src/Core/Material/BlinnPhongMaterialModel.hpp b/src/Core/Material/BlinnPhongMaterialModel.hpp
new file mode 100644
index 00000000000..0fe93db1920
--- /dev/null
+++ b/src/Core/Material/BlinnPhongMaterialModel.hpp
@@ -0,0 +1,52 @@
+#pragma once
+
+#include <Core/Material/MaterialModel.hpp>
+#include <Core/Utils/Color.hpp>
+
+namespace Ra {
+namespace Core {
+namespace Material {
+
+// RADIUM SUPPORTED MATERIALS
+class RA_CORE_API BlinnPhongMaterialModel : public MaterialModel
+{
+  public:
+    explicit BlinnPhongMaterialModel( const std::string& name = "" ) :
+        MaterialModel( name, "BlinnPhong" ) {}
+    ~BlinnPhongMaterialModel() override = default;
+
+    /// DEBUG
+    void displayInfo() const override;
+
+    /// QUERY
+
+    bool hasDiffuseTexture() const { return m_hasTexDiffuse; }
+
+    bool hasSpecularTexture() const { return m_hasTexSpecular; }
+
+    bool hasShininessTexture() const { return m_hasTexShininess; }
+
+    bool hasNormalTexture() const { return m_hasTexNormal; }
+
+    bool hasOpacityTexture() const { return m_hasTexOpacity; }
+
+    /// DATA MEMBERS
+    Core::Utils::Color m_kd { 0.7_ra, 0.7_ra, 0.7_ra };
+    Core::Utils::Color m_ks { 0.3_ra, 0.3_ra, 0.3_ra };
+    Scalar m_ns { 64_ra };
+    Scalar m_alpha { 1_ra };
+    std::string m_texDiffuse;
+    std::string m_texSpecular;
+    std::string m_texShininess;
+    std::string m_texNormal;
+    std::string m_texOpacity;
+    bool m_hasTexDiffuse { false };
+    bool m_hasTexSpecular { false };
+    bool m_hasTexShininess { false };
+    bool m_hasTexNormal { false };
+    bool m_hasTexOpacity { false };
+};
+
+} // namespace Material
+} // namespace Core
+} // namespace Ra
diff --git a/src/Core/Material/MaterialModel.cpp b/src/Core/Material/MaterialModel.cpp
new file mode 100644
index 00000000000..bfd24b816d7
--- /dev/null
+++ b/src/Core/Material/MaterialModel.cpp
@@ -0,0 +1,13 @@
+#include <Core/Material/MaterialModel.hpp>
+#include <Core/Utils/Log.hpp>
+
+namespace Ra {
+namespace Core {
+namespace Material {
+void MaterialModel::displayInfo() const {
+    using namespace Core::Utils; // log
+    LOG( logERROR ) << "MaterialModel : unknown material type : " << m_materialType;
+}
+} // namespace Material
+} // namespace Core
+} // namespace Ra
diff --git a/src/Core/Material/MaterialModel.hpp b/src/Core/Material/MaterialModel.hpp
new file mode 100644
index 00000000000..688ef8ff778
--- /dev/null
+++ b/src/Core/Material/MaterialModel.hpp
@@ -0,0 +1,49 @@
+#pragma once
+#include <string>
+
+#include <Core/RaCore.hpp>
+
+#include <Core/Utils/Observable.hpp>
+
+namespace Ra {
+namespace Core {
+namespace Material {
+
+/** @brief represent material model, loaded by a file loader.
+ *
+ */
+class RA_CORE_API MaterialModel : public Utils::ObservableVoid
+{
+  public:
+    /// MATERIAL DATA
+    MaterialModel( const std::string& name = "", const std::string& type = "AbstractMaterial" );
+    virtual ~MaterialModel() { detachAll(); };
+
+    /// NAME
+    inline const std::string& getName() const { return m_name; }
+    inline void setName( const std::string& name ) { m_name = name; }
+
+    /// TYPE
+    inline std::string getType() const { return m_materialType; }
+    inline void setType( const std::string& type ) { m_materialType = type; }
+
+    /// DEBUG
+    virtual void displayInfo() const;
+
+  private:
+    std::string m_materialType;
+    std::string m_name;
+};
+
+/**
+ * \brief Convenient alias for material usage
+ */
+
+using MaterialModelPtr = std::shared_ptr<MaterialModel>;
+
+inline MaterialModel::MaterialModel( const std::string& name, const std::string& type ) :
+    m_materialType { type }, m_name { name } {}
+
+} // namespace Material
+} // namespace Core
+} // namespace Ra
diff --git a/src/Core/Material/SimpleMaterialModel.cpp b/src/Core/Material/SimpleMaterialModel.cpp
new file mode 100644
index 00000000000..37e3248e21a
--- /dev/null
+++ b/src/Core/Material/SimpleMaterialModel.cpp
@@ -0,0 +1,41 @@
+#include <Core/Material/SimpleMaterialModel.hpp>
+
+#include <Core/Utils/Log.hpp>
+
+namespace Ra {
+namespace Core {
+namespace Material {
+
+void SimpleMaterialModel::displayInfo() const {
+    using namespace Core::Utils; // log
+    auto print = []( bool ok, const std::string& name, const auto& value ) {
+        if ( ok ) { LOG( logINFO ) << name << value; }
+        else { LOG( logINFO ) << name << "NO"; }
+    };
+
+    LOG( logINFO ) << "======== MATERIAL INFO ========";
+    print( true, " Type           : ", getType() );
+    print( true, " Kd             : ", m_kd.transpose() );
+    print( true, " Opacity        : ", m_alpha );
+    print( hasDiffuseTexture(), " Kd Texture     : ", m_texDiffuse );
+    print( hasOpacityTexture(), " Alpha Texture  : ", m_texOpacity );
+}
+
+void LambertianMaterialModel::displayInfo() const {
+    using namespace Core::Utils; // log
+    auto print = []( bool ok, const std::string& name, const auto& value ) {
+        if ( ok ) { LOG( logINFO ) << name << value; }
+        else { LOG( logINFO ) << name << "NO"; }
+    };
+
+    LOG( logINFO ) << "======== MATERIAL INFO ========";
+    print( true, " Type           : ", getType() );
+    print( true, " Kd             : ", m_kd.transpose() );
+    print( true, " Opacity        : ", m_alpha );
+    print( hasDiffuseTexture(), " Kd Texture     : ", m_texDiffuse );
+    print( hasNormalTexture(), " Normal Texture : ", m_texNormal );
+    print( hasOpacityTexture(), " Alpha Texture  : ", m_texOpacity );
+}
+} // namespace Material
+} // namespace Core
+} // namespace Ra
diff --git a/src/Core/Material/SimpleMaterialModel.hpp b/src/Core/Material/SimpleMaterialModel.hpp
new file mode 100644
index 00000000000..83d3126344d
--- /dev/null
+++ b/src/Core/Material/SimpleMaterialModel.hpp
@@ -0,0 +1,57 @@
+#pragma once
+
+#include <Core/Material/MaterialModel.hpp>
+#include <Core/Utils/Color.hpp>
+
+namespace Ra {
+namespace Core {
+namespace Material {
+
+// RADIUM SUPPORTED MATERIALS
+class RA_CORE_API SimpleMaterialModel : public MaterialModel
+{
+  protected:
+    SimpleMaterialModel( const std::string& name, const std::string type ) :
+        MaterialModel( name, type ) {}
+
+  public:
+    explicit SimpleMaterialModel( const std::string& name = "" ) : MaterialModel( name, "Plain" ) {}
+    ~SimpleMaterialModel() override = default;
+
+    /// DEBUG
+    void displayInfo() const override;
+
+    /// QUERY
+    bool hasDiffuseTexture() const { return m_hasTexDiffuse; }
+    bool hasOpacityTexture() const { return m_hasTexOpacity; }
+
+    /// DATA MEMBERS
+    Core::Utils::Color m_kd { 0.9_ra, 0.9_ra, 0.9_ra };
+    Scalar m_alpha { 1_ra };
+    std::string m_texDiffuse;
+    std::string m_texOpacity;
+    bool m_hasTexDiffuse { false };
+    bool m_hasTexOpacity { false };
+};
+
+class RA_CORE_API LambertianMaterialModel : public SimpleMaterialModel
+{
+  public:
+    explicit LambertianMaterialModel( const std::string& name = "" ) :
+        SimpleMaterialModel( name, "Lambertian" ) {}
+    ~LambertianMaterialModel() override = default;
+
+    /// DEBUG
+    void displayInfo() const override;
+
+    /// QUERY
+    bool hasNormalTexture() const { return m_hasTexNormal; }
+
+    /// DATA MEMBERS
+    std::string m_texNormal;
+    bool m_hasTexNormal { false };
+};
+
+} // namespace Material
+} // namespace Core
+} // namespace Ra
diff --git a/src/Core/filelist.cmake b/src/Core/filelist.cmake
index 7aabbe1b640..101f98962d4 100644
--- a/src/Core/filelist.cmake
+++ b/src/Core/filelist.cmake
@@ -15,14 +15,12 @@ set(core_sources
     Animation/Sequence.cpp
     Animation/Skeleton.cpp
     Asset/AnimationData.cpp
-    Asset/BlinnPhongMaterialData.cpp
     Asset/Camera.cpp
     Asset/FileData.cpp
     Asset/GeometryData.cpp
     Asset/HandleData.cpp
     Asset/HandleToSkeleton.cpp
     Asset/LightData.cpp
-    Asset/MaterialData.cpp
     Containers/AdjacencyList.cpp
     Containers/VariableSet.cpp
     Geometry/CatmullClarkSubdivider.cpp
@@ -35,6 +33,9 @@ set(core_sources
     Geometry/TriangleMesh.cpp
     Geometry/Volume.cpp
     Geometry/deprecated/TopologicalMesh.cpp
+    Material/BlinnPhongMaterialModel.cpp
+    Material/MaterialModel.cpp
+    Material/SimpleMaterialModel.cpp
     Resources/Resources.cpp
     Tasks/TaskQueue.cpp
     Utils/Attribs.cpp
@@ -63,7 +64,6 @@ set(core_headers
     Asset/AnimationData.hpp
     Asset/AnimationTime.hpp
     Asset/AssetData.hpp
-    Asset/BlinnPhongMaterialData.hpp
     Asset/Camera.hpp
     Asset/DataLoader.hpp
     Asset/FileData.hpp
@@ -101,6 +101,9 @@ set(core_headers
     Geometry/TriangleMesh.hpp
     Geometry/Volume.hpp
     Geometry/deprecated/TopologicalMesh.hpp
+    Material/BlinnPhongMaterialModel.hpp
+    Material/MaterialModel.hpp
+    Material/SimpleMaterialModel.hpp
     Math/DualQuaternion.hpp
     Math/Interpolation.hpp
     Math/LinearAlgebra.hpp
diff --git a/src/Engine/Data/BlinnPhongMaterial.cpp b/src/Engine/Data/BlinnPhongMaterial.cpp
index c430379064f..126773a09ce 100644
--- a/src/Engine/Data/BlinnPhongMaterial.cpp
+++ b/src/Engine/Data/BlinnPhongMaterial.cpp
@@ -1,4 +1,4 @@
-#include <Core/Asset/BlinnPhongMaterialData.hpp>
+#include <Core/Material/BlinnPhongMaterialModel.hpp>
 #include <Engine/Data/BlinnPhongMaterial.hpp>
 #include <Engine/Data/MaterialConverters.hpp>
 #include <Engine/Data/ShaderConfigFactory.hpp>
@@ -148,16 +148,16 @@ void BlinnPhongMaterial::unregisterMaterial() {
 }
 
 Material*
-BlinnPhongMaterialConverter::operator()( const Ra::Core::Asset::MaterialData* toconvert ) {
+BlinnPhongMaterialConverter::operator()( const Ra::Core::Material::MaterialModel* toconvert ) {
     auto result = new BlinnPhongMaterial( toconvert->getName() );
     // we are sure here that the concrete type of "toconvert" is BlinnPhongMaterialData
     // static cst is safe here
-    auto source = static_cast<const Ra::Core::Asset::BlinnPhongMaterialData*>( toconvert );
+    auto source = static_cast<const Ra::Core::Material::BlinnPhongMaterialModel*>( toconvert );
 
-    if ( source->hasDiffuse() ) result->m_kd = source->m_diffuse;
-    if ( source->hasSpecular() ) result->m_ks = source->m_specular;
-    if ( source->hasShininess() ) result->m_ns = source->m_shininess;
-    if ( source->hasOpacity() ) result->m_alpha = source->m_opacity;
+    result->m_kd    = source->m_kd;
+    result->m_ks    = source->m_ks;
+    result->m_ns    = source->m_ns;
+    result->m_alpha = source->m_alpha;
     if ( source->hasDiffuseTexture() )
         result->addTexture( BlinnPhongMaterial::TextureSemantic::TEX_DIFFUSE,
                             source->m_texDiffuse );
diff --git a/src/Engine/Data/BlinnPhongMaterial.hpp b/src/Engine/Data/BlinnPhongMaterial.hpp
index 50980bc1f23..a41ae9ecee5 100644
--- a/src/Engine/Data/BlinnPhongMaterial.hpp
+++ b/src/Engine/Data/BlinnPhongMaterial.hpp
@@ -11,8 +11,8 @@
 
 namespace Ra {
 namespace Core {
-namespace Asset {
-class MaterialData;
+namespace Material {
+class MaterialModel;
 }
 } // namespace Core
 
@@ -135,7 +135,7 @@ class RA_ENGINE_API BlinnPhongMaterialConverter final
     BlinnPhongMaterialConverter()  = default;
     ~BlinnPhongMaterialConverter() = default;
 
-    Material* operator()( const Ra::Core::Asset::MaterialData* toconvert );
+    Material* operator()( const Ra::Core::Material::MaterialModel* toconvert );
 };
 
 // Add a texture as material parameter from an already existing Radium Texture
diff --git a/src/Engine/Data/LambertianMaterial.cpp b/src/Engine/Data/LambertianMaterial.cpp
index 3714801da0d..3cd8a0e4d5f 100644
--- a/src/Engine/Data/LambertianMaterial.cpp
+++ b/src/Engine/Data/LambertianMaterial.cpp
@@ -1,5 +1,6 @@
+#include <Core/Material/SimpleMaterialModel.hpp>
 #include <Engine/Data/LambertianMaterial.hpp>
-
+#include <Engine/Data/MaterialConverters.hpp>
 #include <Engine/Data/ShaderConfigFactory.hpp>
 #include <Engine/Data/ShaderProgramManager.hpp>
 #include <Engine/Data/TextureManager.hpp>
@@ -25,6 +26,8 @@ void LambertianMaterial::registerMaterial() {
     auto resourcesRootDir { RadiumEngine::getInstance()->getResourcesDir() };
     auto shaderProgramManager = RadiumEngine::getInstance()->getShaderProgramManager();
 
+    EngineMaterialConverters::registerMaterialConverter( materialName,
+                                                         LambertianMaterialConverter() );
     shaderProgramManager->addNamedString(
         "/Lambertian.glsl", resourcesRootDir + "Shaders/Materials/Lambertian/Lambertian.glsl" );
     // registering re-usable shaders
@@ -58,6 +61,7 @@ void LambertianMaterial::registerMaterial() {
 }
 
 void LambertianMaterial::unregisterMaterial() {
+    EngineMaterialConverters::removeMaterialConverter( materialName );
     Rendering::EngineRenderTechniques::removeDefaultTechnique( materialName );
 }
 
@@ -71,6 +75,26 @@ nlohmann::json LambertianMaterial::getParametersMetadata() const {
     return s_parametersMetadata;
 }
 
+Material*
+LambertianMaterialConverter::operator()( const Ra::Core::Material::MaterialModel* toconvert ) {
+    auto result = new LambertianMaterial( toconvert->getName() );
+    // we are sure here that the concrete type of "toconvert" is BlinnPhongMaterialData
+    // static cst is safe here
+    auto source = static_cast<const Ra::Core::Material::LambertianMaterialModel*>( toconvert );
+
+    result->m_color = source->m_kd;
+    result->m_alpha = source->m_alpha;
+
+    if ( source->hasDiffuseTexture() )
+        result->addTexture( SimpleMaterial::TextureSemantic::TEX_COLOR, source->m_texDiffuse );
+    if ( source->hasOpacityTexture() )
+        result->addTexture( SimpleMaterial::TextureSemantic::TEX_MASK, source->m_texOpacity );
+    if ( source->hasNormalTexture() )
+        result->addTexture( SimpleMaterial::TextureSemantic::TEX_NORMAL, source->m_texNormal );
+
+    return result;
+}
+
 } // namespace Data
 } // namespace Engine
 } // namespace Ra
diff --git a/src/Engine/Data/LambertianMaterial.hpp b/src/Engine/Data/LambertianMaterial.hpp
index 220cf2e3ab2..8187289f750 100644
--- a/src/Engine/Data/LambertianMaterial.hpp
+++ b/src/Engine/Data/LambertianMaterial.hpp
@@ -3,6 +3,12 @@
 #include <Engine/Data/SimpleMaterial.hpp>
 
 namespace Ra {
+namespace Core {
+namespace Material {
+class MaterialModel;
+}
+} // namespace Core
+
 namespace Engine {
 namespace Data {
 /**
@@ -18,6 +24,8 @@ namespace Data {
  */
 class RA_ENGINE_API LambertianMaterial final : public SimpleMaterial
 {
+    friend class LambertianMaterialConverter;
+
   public:
     /**
      * Construct a named Lambertian material
@@ -58,6 +66,18 @@ class RA_ENGINE_API LambertianMaterial final : public SimpleMaterial
     static nlohmann::json s_parametersMetadata;
 };
 
+/**
+ * Converter from an external representation coming from FileData to internal representation.
+ */
+class RA_ENGINE_API LambertianMaterialConverter final
+{
+  public:
+    LambertianMaterialConverter()  = default;
+    ~LambertianMaterialConverter() = default;
+
+    Material* operator()( const Ra::Core::Material::MaterialModel* toconvert );
+};
+
 } // namespace Data
 } // namespace Engine
 } // namespace Ra
diff --git a/src/Engine/Data/MaterialConverters.cpp b/src/Engine/Data/MaterialConverters.cpp
index 72cd51268a4..f13262b0854 100644
--- a/src/Engine/Data/MaterialConverters.cpp
+++ b/src/Engine/Data/MaterialConverters.cpp
@@ -19,7 +19,7 @@ using namespace Core::Utils; // log
 
 namespace EngineMaterialConverters {
 /// Map that stores each conversion function
-static std::map<std::string, std::function<RadiumMaterialPtr( AssetMaterialPtr )>>
+static std::map<std::string, std::function<RadiumMaterialPtr( MaterialModelPtr )>>
     MaterialConverterRegistry;
 
 bool registerMaterialConverter( const std::string& name, ConverterFunction converter ) {
@@ -35,7 +35,7 @@ bool removeMaterialConverter( const std::string& name ) {
 std::pair<bool, ConverterFunction> getMaterialConverter( const std::string& name ) {
     auto search = MaterialConverterRegistry.find( name );
     if ( search != MaterialConverterRegistry.end() ) { return { true, search->second }; }
-    auto result = std::make_pair( false, [name]( AssetMaterialPtr ) -> RadiumMaterialPtr {
+    auto result = std::make_pair( false, [name]( MaterialModelPtr ) -> RadiumMaterialPtr {
         LOG( logERROR ) << "Required material converter " << name << " not found!";
         return nullptr;
     } );
diff --git a/src/Engine/Data/MaterialConverters.hpp b/src/Engine/Data/MaterialConverters.hpp
index dcff906d014..0737e808bd4 100644
--- a/src/Engine/Data/MaterialConverters.hpp
+++ b/src/Engine/Data/MaterialConverters.hpp
@@ -12,9 +12,9 @@ class Material;
 }
 } // namespace Engine
 namespace Core {
-namespace Asset {
-class MaterialData;
-}
+namespace Material {
+class MaterialModel;
+} // namespace Material
 } // namespace Core
 
 ///////////////////////////////////////////////
@@ -42,7 +42,7 @@ namespace EngineMaterialConverters {
 /**
  * Type of a pointer to an IO/ASSET representation of the material
  */
-using AssetMaterialPtr = const Ra::Core::Asset::MaterialData*;
+using MaterialModelPtr = const Ra::Core::Material::MaterialModel*;
 /**
  * Type of a pointer to an Engine representation of the material
  */
@@ -51,7 +51,7 @@ using RadiumMaterialPtr = Ra::Engine::Data::Material*;
 /**
  * Type of the conversion functor from IO/ASSET representation to Engine representation
  */
-using ConverterFunction = std::function<RadiumMaterialPtr( AssetMaterialPtr )>;
+using ConverterFunction = std::function<RadiumMaterialPtr( MaterialModelPtr )>;
 
 /** register a new material converter
  *  @return true if converter added, false else (e.g, a converter with the same name exists)
diff --git a/src/Engine/Data/PlainMaterial.cpp b/src/Engine/Data/PlainMaterial.cpp
index 993af771e12..c7c7b26d58e 100644
--- a/src/Engine/Data/PlainMaterial.cpp
+++ b/src/Engine/Data/PlainMaterial.cpp
@@ -1,5 +1,6 @@
+#include <Core/Material/SimpleMaterialModel.hpp>
+#include <Engine/Data/MaterialConverters.hpp>
 #include <Engine/Data/PlainMaterial.hpp>
-
 #include <Engine/Data/ShaderConfigFactory.hpp>
 #include <Engine/Data/ShaderProgramManager.hpp>
 #include <Engine/Data/TextureManager.hpp>
@@ -26,6 +27,8 @@ void PlainMaterial::registerMaterial() {
     auto resourcesRootDir { RadiumEngine::getInstance()->getResourcesDir() };
     auto shaderProgramManager = RadiumEngine::getInstance()->getShaderProgramManager();
 
+    EngineMaterialConverters::registerMaterialConverter( materialName, PlainMaterialConverter() );
+
     shaderProgramManager->addNamedString( "/Plain.glsl",
                                           resourcesRootDir + "Shaders/Materials/Plain/Plain.glsl" );
     // registering re-usable shaders
@@ -58,6 +61,7 @@ void PlainMaterial::registerMaterial() {
 }
 
 void PlainMaterial::unregisterMaterial() {
+    EngineMaterialConverters::removeMaterialConverter( materialName );
     Rendering::EngineRenderTechniques::removeDefaultTechnique( "Plain" );
 }
 
@@ -71,6 +75,23 @@ nlohmann::json PlainMaterial::getParametersMetadata() const {
     return s_parametersMetadata;
 }
 
+Material* PlainMaterialConverter::operator()( const Ra::Core::Material::MaterialModel* toconvert ) {
+    auto result = new PlainMaterial( toconvert->getName() );
+    // we are sure here that the concrete type of "toconvert" is BlinnPhongMaterialData
+    // static cst is safe here
+    auto source = static_cast<const Ra::Core::Material::SimpleMaterialModel*>( toconvert );
+
+    result->m_color = source->m_kd;
+    result->m_alpha = source->m_alpha;
+
+    if ( source->hasDiffuseTexture() )
+        result->addTexture( SimpleMaterial::TextureSemantic::TEX_COLOR, source->m_texDiffuse );
+    if ( source->hasOpacityTexture() )
+        result->addTexture( SimpleMaterial::TextureSemantic::TEX_MASK, source->m_texOpacity );
+
+    return result;
+}
+
 } // namespace Data
 } // namespace Engine
 } // namespace Ra
diff --git a/src/Engine/Data/PlainMaterial.hpp b/src/Engine/Data/PlainMaterial.hpp
index 91ec2252644..8928fe3bbc1 100644
--- a/src/Engine/Data/PlainMaterial.hpp
+++ b/src/Engine/Data/PlainMaterial.hpp
@@ -3,6 +3,12 @@
 #include <Engine/Data/SimpleMaterial.hpp>
 
 namespace Ra {
+namespace Core {
+namespace Material {
+class MaterialModel;
+}
+} // namespace Core
+
 namespace Engine {
 namespace Data {
 /**
@@ -18,6 +24,8 @@ namespace Data {
  */
 class RA_ENGINE_API PlainMaterial final : public SimpleMaterial
 {
+    friend class PlainMaterialConverter;
+
   public:
     /**
      * Construct a named Plain material
@@ -57,6 +65,19 @@ class RA_ENGINE_API PlainMaterial final : public SimpleMaterial
   private:
     static nlohmann::json s_parametersMetadata;
 };
+
+/**
+ * Converter from an external representation coming from FileData to internal representation.
+ */
+class RA_ENGINE_API PlainMaterialConverter final
+{
+  public:
+    PlainMaterialConverter()  = default;
+    ~PlainMaterialConverter() = default;
+
+    Material* operator()( const Ra::Core::Material::MaterialModel* toconvert );
+};
+
 } // namespace Data
 } // namespace Engine
 } // namespace Ra
diff --git a/src/Engine/Data/RawShaderMaterial.cpp b/src/Engine/Data/RawShaderMaterial.cpp
index 0c7e3030178..2d4ff4340d7 100644
--- a/src/Engine/Data/RawShaderMaterial.cpp
+++ b/src/Engine/Data/RawShaderMaterial.cpp
@@ -7,7 +7,6 @@
 namespace Ra {
 namespace Engine {
 namespace Data {
-
 RawShaderMaterial::RawShaderMaterial(
     const std::string& instanceName,
     const std::vector<std::pair<Data::ShaderType, std::string>>& shaders,
diff --git a/src/Engine/Data/RawShaderMaterial.hpp b/src/Engine/Data/RawShaderMaterial.hpp
index 7d797e80e9c..5bba92bbd23 100644
--- a/src/Engine/Data/RawShaderMaterial.hpp
+++ b/src/Engine/Data/RawShaderMaterial.hpp
@@ -2,7 +2,7 @@
 
 #include <Engine/RaEngine.hpp>
 
-#include <Core/Asset/MaterialData.hpp>
+#include <Core/Material/MaterialModel.hpp>
 #include <Engine/Data/Material.hpp>
 
 namespace Ra {
@@ -14,12 +14,12 @@ class RawShaderMaterialConverter;
 } // namespace Engine
 
 namespace Core {
-namespace Asset {
+namespace Material {
 
 /**
  * External shaderMaterial representation
  */
-class RA_ENGINE_API RawShaderMaterialData : public MaterialData
+class RA_ENGINE_API RawShaderMaterialModel : public MaterialModel
 {
     /// allow converter to access private members
     friend class Ra::Engine::Data::RawShaderMaterialConverter;
@@ -32,23 +32,23 @@ class RA_ENGINE_API RawShaderMaterialData : public MaterialData
      * allowed)
      * @param paramProvider The parameter provider for the resulting program
      */
-    RawShaderMaterialData(
+    RawShaderMaterialModel(
         const std::string& instanceName,
         const std::vector<std::pair<Ra::Engine::Data::ShaderType, std::string>>& shaders,
         std::shared_ptr<Ra::Engine::Data::ShaderParameterProvider> paramProvider ) :
-        MaterialData( instanceName, "Ra::Engine::Data::RawShaderMaterial" ),
+        MaterialModel( instanceName, "Ra::Engine::Data::RawShaderMaterial" ),
         m_shaders { shaders },
         m_paramProvider { std::move( paramProvider ) } {}
-    RawShaderMaterialData()                               = delete;
-    RawShaderMaterialData( const RawShaderMaterialData& ) = delete;
-    ~RawShaderMaterialData()                              = default;
+    RawShaderMaterialModel()                                = delete;
+    RawShaderMaterialModel( const RawShaderMaterialModel& ) = delete;
+    ~RawShaderMaterialModel()                               = default;
 
   private:
     std::vector<std::pair<Ra::Engine::Data::ShaderType, std::string>> m_shaders;
     std::shared_ptr<Ra::Engine::Data::ShaderParameterProvider> m_paramProvider;
 };
 
-} // namespace Asset
+} // namespace Material
 } // namespace Core
 
 namespace Engine {
@@ -63,7 +63,7 @@ class RA_ENGINE_API RawShaderMaterialConverter final
   public:
     RawShaderMaterialConverter()  = default;
     ~RawShaderMaterialConverter() = default;
-    inline Material* operator()( const Ra::Core::Asset::MaterialData* toconvert );
+    inline Material* operator()( const Ra::Core::Material::MaterialModel* toconvert );
 };
 
 /**
@@ -156,8 +156,8 @@ class RA_ENGINE_API RawShaderMaterial : public Material
 };
 
 inline Material*
-RawShaderMaterialConverter::operator()( const Ra::Core::Asset::MaterialData* toconvert ) {
-    auto mat = static_cast<const Core::Asset::RawShaderMaterialData*>( toconvert );
+RawShaderMaterialConverter::operator()( const Ra::Core::Material::MaterialModel* toconvert ) {
+    auto mat = static_cast<const Core::Material::RawShaderMaterialModel*>( toconvert );
     return new RawShaderMaterial( mat->getName(), mat->m_shaders, mat->m_paramProvider );
 }
 
diff --git a/src/Engine/Data/SimpleMaterial.cpp b/src/Engine/Data/SimpleMaterial.cpp
index be031fcda5a..82e26fc1fbe 100644
--- a/src/Engine/Data/SimpleMaterial.cpp
+++ b/src/Engine/Data/SimpleMaterial.cpp
@@ -27,6 +27,9 @@ void SimpleMaterial::updateRenderingParameters() {
     tex = getTexture( SimpleMaterial::TextureSemantic::TEX_MASK );
     if ( tex != nullptr ) { renderParameters.addParameter( "material.tex.mask", tex ); }
     renderParameters.addParameter( "material.tex.hasMask", tex != nullptr );
+    tex = getTexture( SimpleMaterial::TextureSemantic::TEX_NORMAL );
+    if ( tex != nullptr ) { renderParameters.addParameter( "material.tex.normal", tex ); }
+    renderParameters.addParameter( "material.tex.hasNormal", tex != nullptr );
 }
 
 void SimpleMaterial::updateGL() {
diff --git a/src/Engine/Data/SimpleMaterial.hpp b/src/Engine/Data/SimpleMaterial.hpp
index 02a273d386a..6ae8a620e37 100644
--- a/src/Engine/Data/SimpleMaterial.hpp
+++ b/src/Engine/Data/SimpleMaterial.hpp
@@ -20,7 +20,7 @@ class RA_ENGINE_API SimpleMaterial : public Material, public ParameterSetEditing
 {
   public:
     /// Semantic of the texture : define which BSDF parameter is controled by the texture
-    enum class TextureSemantic { TEX_COLOR, TEX_MASK };
+    enum class TextureSemantic { TEX_COLOR, TEX_MASK, TEX_NORMAL };
 
     /**
      * Construct a named  material
@@ -75,10 +75,22 @@ class RA_ENGINE_API SimpleMaterial : public Material, public ParameterSetEditing
   public:
     /// The base color of the material
     Core::Utils::Color m_color { 0.9, 0.9, 0.9, 1.0 };
+    /// Transparency of the material (not use right now)
+    Scalar m_alpha { 1.0 };
     /// Indicates if the material will takes its base color from vertices' attributes.
     /// \todo make this private ?
     bool m_perVertexColor { false };
 
+  protected:
+    /**
+     * Add an new texture, from a given file, to control the specified BSDF parameter.
+     * @param semantic The texture semantic
+     * @param texture  The texture to use (file)
+     * @return the corresponding TextureData struct
+     */
+    inline TextureParameters& addTexture( const TextureSemantic& semantic,
+                                          const std::string& texture );
+
   private:
     /**
      * Update the rendering parameters for the Material
@@ -116,6 +128,17 @@ inline TextureParameters& SimpleMaterial::addTexture( const TextureSemantic& sem
     return m_pendingTextures[semantic];
 }
 
+// Add a texture as material parameter with texture parameter set by default for this material
+inline TextureParameters& SimpleMaterial::addTexture( const TextureSemantic& semantic,
+                                                      const std::string& texture ) {
+    CORE_ASSERT( !texture.empty(), "Invalid texture name" );
+    TextureParameters data;
+    data.name  = texture;
+    data.wrapS = GL_REPEAT;
+    data.wrapT = GL_REPEAT;
+    return addTexture( semantic, data );
+}
+
 inline Texture* SimpleMaterial::getTexture( const TextureSemantic& semantic ) const {
     Texture* tex = nullptr;
 
diff --git a/src/Engine/Scene/CameraManager.cpp b/src/Engine/Scene/CameraManager.cpp
index 09bcca00ad1..4f94f2bb0e6 100644
--- a/src/Engine/Scene/CameraManager.cpp
+++ b/src/Engine/Scene/CameraManager.cpp
@@ -96,9 +96,9 @@ void CameraManager::generateTasks( Core::TaskQueue* taskQueue,
 }
 
 void CameraManager::handleAssetLoading( Entity* entity, const FileData* filedata ) {
-    std::vector<Camera*> cameraData = filedata->getCameraData();
-    uint id                         = 0;
-    uint cpt                        = 0;
+    const auto& cameraData = filedata->getCameraData();
+    uint id                = 0;
+    uint cpt               = 0;
     for ( const auto& data : cameraData ) {
         std::string componentName = "CAMERA_" + entity->getName() + std::to_string( id++ );
         auto comp                 = new CameraComponent( entity, componentName, 100, 100 );
diff --git a/src/Engine/Scene/GeometryComponent.cpp b/src/Engine/Scene/GeometryComponent.cpp
index c9056fed4dd..6632489fa82 100644
--- a/src/Engine/Scene/GeometryComponent.cpp
+++ b/src/Engine/Scene/GeometryComponent.cpp
@@ -53,7 +53,7 @@ PointCloudComponent::PointCloudComponent( const std::string& name,
 PointCloudComponent::PointCloudComponent( const std::string& name,
                                           Entity* entity,
                                           Core::Geometry::PointCloud&& mesh,
-                                          Core::Asset::MaterialData* mat ) :
+                                          Core::Material::MaterialModelPtr mat ) :
     GeometryComponent( name, entity ),
     m_displayMesh( new Data::PointCloud( name, std::move( mesh ) ) ) {
     finalizeROFromGeometry( mat, Core::Transform::Identity() );
@@ -78,18 +78,20 @@ void PointCloudComponent::generatePointCloud( const Ra::Core::Asset::GeometryDat
 
     m_displayMesh->loadGeometry( std::move( mesh ) );
 
-    finalizeROFromGeometry( data->hasMaterial() ? &( data->getMaterial() ) : nullptr,
+    finalizeROFromGeometry( data->hasMaterial() ? data->getMaterial().getMaterialModel() : nullptr,
                             data->getFrame() );
 }
 
-void PointCloudComponent::finalizeROFromGeometry( const Core::Asset::MaterialData* data,
+void PointCloudComponent::finalizeROFromGeometry( Core::Material::MaterialModelPtr matModel,
                                                   Core::Transform transform ) {
     // The technique for rendering this component
     std::shared_ptr<Data::Material> roMaterial;
     // First extract the material from asset or create a default one
-    if ( data != nullptr ) {
-        auto converter = Data::EngineMaterialConverters::getMaterialConverter( data->getType() );
-        auto mat       = converter.second( data );
+    if ( matModel != nullptr ) {
+        auto converter =
+            Data::EngineMaterialConverters::getMaterialConverter( matModel->getType() );
+        // todo : convert from the shared ptr instead of from the raw ptr
+        auto mat = converter.second( matModel.get() );
         roMaterial.reset( mat );
     }
     else {
@@ -99,7 +101,7 @@ void PointCloudComponent::finalizeROFromGeometry( const Core::Asset::MaterialDat
             Ra::Core::Geometry::getAttribName( Ra::Core::Geometry::VERTEX_COLOR ) );
         roMaterial.reset( mat );
     }
-    // initialize with a default rendertechique that draws nothing
+    // initialize with a default rendertechnique that draws nothing
     std::string roName( m_name + "_" + m_contentName + "_RO" );
     auto ro = Rendering::RenderObject::createRenderObject( roName,
                                                            this,
diff --git a/src/Engine/Scene/GeometryComponent.hpp b/src/Engine/Scene/GeometryComponent.hpp
index 16fa5104e15..540a1494112 100644
--- a/src/Engine/Scene/GeometryComponent.hpp
+++ b/src/Engine/Scene/GeometryComponent.hpp
@@ -5,6 +5,7 @@
 #include <Core/Containers/MakeShared.hpp>
 #include <Core/Geometry/TriangleMesh.hpp>
 #include <Core/Geometry/Volume.hpp>
+#include <Core/Material/MaterialModel.hpp>
 #include <Engine/Data/BlinnPhongMaterial.hpp>
 #include <Engine/Data/MaterialConverters.hpp>
 #include <Engine/Data/Mesh.hpp>
@@ -80,7 +81,7 @@ class SurfaceMeshComponent : public GeometryComponent
     inline SurfaceMeshComponent( const std::string& name,
                                  Entity* entity,
                                  CoreMeshType&& mesh,
-                                 Core::Asset::MaterialData* mat = nullptr );
+                                 Core::Material::MaterialModelPtr mat = nullptr );
 
     ~SurfaceMeshComponent() override = default;
 
@@ -95,7 +96,7 @@ class SurfaceMeshComponent : public GeometryComponent
   private:
     inline void generateMesh( const Ra::Core::Asset::GeometryData* data );
 
-    inline void finalizeROFromGeometry( const Core::Asset::MaterialData* data,
+    inline void finalizeROFromGeometry( Core::Material::MaterialModelPtr matModel,
                                         Core::Transform transform );
 
     // Give access to the mesh and (if deformable) to update it
@@ -130,7 +131,7 @@ class RA_ENGINE_API PointCloudComponent : public GeometryComponent
     PointCloudComponent( const std::string& name,
                          Entity* entity,
                          Core::Geometry::PointCloud&& mesh,
-                         Core::Asset::MaterialData* mat = nullptr );
+                         Core::Material::MaterialModelPtr mat = nullptr );
 
     ~PointCloudComponent() override;
 
@@ -154,7 +155,8 @@ class RA_ENGINE_API PointCloudComponent : public GeometryComponent
   private:
     void generatePointCloud( const Ra::Core::Asset::GeometryData* data );
 
-    void finalizeROFromGeometry( const Core::Asset::MaterialData* data, Core::Transform transform );
+    void finalizeROFromGeometry( Core::Material::MaterialModelPtr matModel,
+                                 Core::Transform transform );
 
     // Give access to the mesh and (if deformable) to update it
     const Ra::Core::Geometry::PointCloud* getMeshOutput() const;
@@ -229,7 +231,7 @@ template <typename CoreMeshType>
 SurfaceMeshComponent<CoreMeshType>::SurfaceMeshComponent( const std::string& name,
                                                           Entity* entity,
                                                           CoreMeshType&& mesh,
-                                                          Core::Asset::MaterialData* mat ) :
+                                                          Core::Material::MaterialModelPtr mat ) :
     GeometryComponent( name, entity ),
     m_displayMesh( new RenderMeshType( name, std::move( mesh ) ) ) {
     setContentName( name );
@@ -244,20 +246,21 @@ void SurfaceMeshComponent<CoreMeshType>::generateMesh( const Ra::Core::Asset::Ge
 
     m_displayMesh->loadGeometry( std::move( mesh ) );
 
-    finalizeROFromGeometry( data->hasMaterial() ? &( data->getMaterial() ) : nullptr,
+    finalizeROFromGeometry( data->hasMaterial() ? data->getMaterial().getMaterialModel() : nullptr,
                             data->getFrame() );
 }
 
 template <typename CoreMeshType>
 void SurfaceMeshComponent<CoreMeshType>::finalizeROFromGeometry(
-    const Core::Asset::MaterialData* data,
+    Core::Material::MaterialModelPtr matModel,
     Core::Transform transform ) {
     // The technique for rendering this component
     std::shared_ptr<Data::Material> roMaterial;
     // First extract the material from asset or create a default one
-    if ( data != nullptr ) {
-        auto converter = Data::EngineMaterialConverters::getMaterialConverter( data->getType() );
-        auto mat       = converter.second( data );
+    if ( matModel != nullptr ) {
+        auto converter =
+            Data::EngineMaterialConverters::getMaterialConverter( matModel->getType() );
+        auto mat = converter.second( matModel.get() );
         roMaterial.reset( mat );
     }
     else {
diff --git a/src/Engine/Scene/GeometrySystem.cpp b/src/Engine/Scene/GeometrySystem.cpp
index 78517d084d6..ad7db56f358 100644
--- a/src/Engine/Scene/GeometrySystem.cpp
+++ b/src/Engine/Scene/GeometrySystem.cpp
@@ -18,7 +18,7 @@ GeometrySystem::GeometrySystem() : System() {}
 
 void GeometrySystem::handleAssetLoading( Entity* entity,
                                          const Ra::Core::Asset::FileData* fileData ) {
-    auto geomData = fileData->getGeometryData();
+    const auto& geomData = fileData->getGeometryData();
 
     uint id = 0;
 
@@ -27,19 +27,19 @@ void GeometrySystem::handleAssetLoading( Entity* entity,
         std::string componentName = "GEOM_" + entity->getName() + std::to_string( id++ );
         switch ( data->getType() ) {
         case Ra::Core::Asset::GeometryData::POINT_CLOUD:
-            comp = new PointCloudComponent( componentName, entity, data );
+            comp = new PointCloudComponent( componentName, entity, data.get() );
             break;
         case Ra::Core::Asset::GeometryData::LINE_MESH:
-            //            comp = new LineMeshComponent( componentName, entity, data );
+            //            comp = new LineMeshComponent( componentName, entity, data.get() );
             //            break;
         case Ra::Core::Asset::GeometryData::TRI_MESH:
-            comp = new TriangleMeshComponent( componentName, entity, data );
+            comp = new TriangleMeshComponent( componentName, entity, data.get() );
             break;
         case Ra::Core::Asset::GeometryData::QUAD_MESH:
-            comp = new QuadMeshComponent( componentName, entity, data );
+            comp = new QuadMeshComponent( componentName, entity, data.get() );
             break;
         case Ra::Core::Asset::GeometryData::POLY_MESH:
-            comp = new PolyMeshComponent( componentName, entity, data );
+            comp = new PolyMeshComponent( componentName, entity, data.get() );
             break;
         case Ra::Core::Asset::GeometryData::TETRA_MESH:
         case Ra::Core::Asset::GeometryData::HEX_MESH:
@@ -50,13 +50,13 @@ void GeometrySystem::handleAssetLoading( Entity* entity,
         registerComponent( entity, comp );
     }
 
-    auto volumeData = fileData->getVolumeData();
+    const auto& volumeData = fileData->getVolumeData();
 
     id = 0;
 
     for ( const auto& data : volumeData ) {
         std::string componentName = "VOL_" + entity->getName() + std::to_string( id++ );
-        auto comp                 = new VolumeComponent( componentName, entity, data );
+        auto comp                 = new VolumeComponent( componentName, entity, data.get() );
         registerComponent( entity, comp );
     }
 }
diff --git a/src/Engine/Scene/LightManager.cpp b/src/Engine/Scene/LightManager.cpp
index ffa9ba2a0b3..472c3bd8458 100644
--- a/src/Engine/Scene/LightManager.cpp
+++ b/src/Engine/Scene/LightManager.cpp
@@ -39,8 +39,8 @@ void LightManager::generateTasks( Core::TaskQueue* /*taskQueue*/,
 }
 
 void LightManager::handleAssetLoading( Entity* entity, const FileData* filedata ) {
-    std::vector<LightData*> lightData = filedata->getLightData();
-    uint id                           = 0;
+    const auto& lightData = filedata->getLightData();
+    uint id               = 0;
 
     // If thereis some lights already in the manager, just remove from the manager the lights that
     // belong to the system entity (e.g. the headlight) from the list of managed lights. Beware to
diff --git a/src/Engine/Scene/SkeletonBasedAnimationSystem.cpp b/src/Engine/Scene/SkeletonBasedAnimationSystem.cpp
index 8337d42c4c6..a128af33c2d 100644
--- a/src/Engine/Scene/SkeletonBasedAnimationSystem.cpp
+++ b/src/Engine/Scene/SkeletonBasedAnimationSystem.cpp
@@ -87,15 +87,15 @@ void SkeletonBasedAnimationSystem::generateTasks( Core::TaskQueue* taskQueue,
 
 void SkeletonBasedAnimationSystem::handleAssetLoading( Entity* entity,
                                                        const Core::Asset::FileData* fileData ) {
-    auto skelData = fileData->getHandleData();
-    auto animData = fileData->getAnimationData();
+    const auto& skelData = fileData->getHandleData();
+    const auto& animData = fileData->getAnimationData();
 
     // deal with AnimationComponents
     Scalar startTime = std::numeric_limits<Scalar>::max();
     Scalar endTime   = 0;
     for ( const auto& skel : skelData ) {
         auto component = new SkeletonComponent( "AC_" + skel->getName(), entity );
-        component->handleSkeletonLoading( skel );
+        component->handleSkeletonLoading( skel.get() );
         component->handleAnimationLoading( animData );
         auto [s, e] = component->getAnimationTimeInterval();
         startTime   = std::min( startTime, s );
@@ -109,7 +109,7 @@ void SkeletonBasedAnimationSystem::handleAssetLoading( Entity* entity,
     engine->setEndTime( endTime );
 
     // deal with SkinningComponents
-    auto geomData = fileData->getGeometryData();
+    const auto& geomData = fileData->getGeometryData();
     if ( geomData.size() > 0 && skelData.size() > 0 ) {
         for ( const auto& geom : geomData ) {
             // look for a skeleton skinning this mesh
@@ -125,7 +125,7 @@ void SkeletonBasedAnimationSystem::handleAssetLoading( Entity* entity,
                 const auto& skel             = *it;
                 SkinningComponent* component = new SkinningComponent(
                     "SkC_" + geom->getName(), SkinningComponent::LBS, entity );
-                component->handleSkinDataLoading( skel, geom->getName() );
+                component->handleSkinDataLoading( skel.get(), geom->getName() );
                 registerComponent( entity, component );
             }
         }
diff --git a/src/Engine/Scene/SkeletonComponent.cpp b/src/Engine/Scene/SkeletonComponent.cpp
index b47ed0e888d..c6db485c5d4 100644
--- a/src/Engine/Scene/SkeletonComponent.cpp
+++ b/src/Engine/Scene/SkeletonComponent.cpp
@@ -90,7 +90,7 @@ void SkeletonComponent::handleSkeletonLoading( const Core::Asset::HandleData* da
 }
 
 void SkeletonComponent::handleAnimationLoading(
-    const std::vector<Core::Asset::AnimationData*>& data ) {
+    const std::vector<std::unique_ptr<Core::Asset::AnimationData>>& data ) {
     CORE_ASSERT( ( m_skel.size() != 0 ), "A Skeleton should be loaded first." );
     m_animations.clear();
     m_animations.reserve( data.size() );
diff --git a/src/Engine/Scene/SkeletonComponent.hpp b/src/Engine/Scene/SkeletonComponent.hpp
index 9ec28d62a85..778cb16578c 100644
--- a/src/Engine/Scene/SkeletonComponent.hpp
+++ b/src/Engine/Scene/SkeletonComponent.hpp
@@ -75,7 +75,8 @@ class RA_ENGINE_API SkeletonComponent : public Component
     void handleSkeletonLoading( const Core::Asset::HandleData* data );
 
     /// Create the animations from the given data.
-    void handleAnimationLoading( const std::vector<Core::Asset::AnimationData*>& data );
+    void
+    handleAnimationLoading( const std::vector<std::unique_ptr<Core::Asset::AnimationData>>& data );
     /// \}
 
     /// \name Skeleton-based animation data
diff --git a/src/IO/AssimpLoader/AssimpAnimationDataLoader.cpp b/src/IO/AssimpLoader/AssimpAnimationDataLoader.cpp
index f8021f906d9..6d07c51ecdc 100644
--- a/src/IO/AssimpLoader/AssimpAnimationDataLoader.cpp
+++ b/src/IO/AssimpLoader/AssimpAnimationDataLoader.cpp
@@ -111,7 +111,7 @@ void AssimpAnimationDataLoader::fetchAnimation( const aiAnimation* anim,
         fetchHandleAnimation( anim->mChannels[i], keyFrame[i], data->getTimeStep() );
         time.extends( keyFrame[i].m_animationTime );
     }
-    data->setHandleData( keyFrame );
+    data->setHandleData( std::move( keyFrame ) );
     data->setTime( time );
 }
 
diff --git a/src/IO/AssimpLoader/AssimpGeometryDataLoader.cpp b/src/IO/AssimpLoader/AssimpGeometryDataLoader.cpp
index 537aa34bb20..74e3b7dced7 100644
--- a/src/IO/AssimpLoader/AssimpGeometryDataLoader.cpp
+++ b/src/IO/AssimpLoader/AssimpGeometryDataLoader.cpp
@@ -5,8 +5,8 @@
 
 #include <Core/Utils/Log.hpp>
 
-#include <Core/Asset/BlinnPhongMaterialData.hpp>
-
+#include <Core/Material/BlinnPhongMaterialModel.hpp>
+#include <Core/Material/SimpleMaterialModel.hpp>
 namespace Ra {
 namespace IO {
 
@@ -212,71 +212,150 @@ void AssimpGeometryDataLoader::loadMaterial( const aiMaterial& material,
         matName = assimpName.C_Str();
     }
     // Radium V2 : use AI_MATKEY_SHADING_MODEL to select the apropriate model
-    // (http://assimp.sourceforge.net/lib_html/material_8h.html#a93e23e0201d6ed86fb4287e15218e4cf)
-    auto blinnPhongMaterial = new BlinnPhongMaterialData( matName );
-    if ( AI_DEFAULT_MATERIAL_NAME != matName ) {
-        aiColor4D color;
-        float shininess;
-        float opacity;
-        aiString name;
-
-        if ( AI_SUCCESS == material.Get( AI_MATKEY_COLOR_DIFFUSE, color ) ) {
-            blinnPhongMaterial->m_hasDiffuse = true;
-            blinnPhongMaterial->m_diffuse    = assimpToCore( color );
+    // (https://assimp.sourceforge.net/lib_html/materials.html)
+    MaterialData assetMaterial( matName );
+
+    // Identify Lambertian or Blinn-Phong material
+    // The following correspond to assimp doc but always identify Gouraud shading model
+    int shadingModel = aiShadingMode_Gouraud;
+    material.Get( AI_MATKEY_SHADING_MODEL, shadingModel );
+    if ( shadingModel == aiShadingMode_Gouraud ) {
+        // follow assimp documentation at https://assimp.sourceforge.net/lib_html/materials.html
+        // here, if shininess is present, assume phong shading model (somehow different of what's
+        // written in the - buggy? - documentation)
+        float sd { -1 };
+        if ( AI_SUCCESS == material.Get( AI_MATKEY_SHININESS, sd ) ) {
+            shadingModel = ( sd > 0 ) ? aiShadingMode_Phong : aiShadingMode_Gouraud;
         }
+    }
+    if ( AI_DEFAULT_MATERIAL_NAME != matName ) {
+        switch ( shadingModel ) {
+        case aiShadingMode_Flat: {
+            LOG( logINFO ) << "Loading assimp shadingModel Flat --> plainMaterial";
+            auto plainMaterial = std::make_shared<Core::Material::SimpleMaterialModel>( matName );
+            assetMaterial.setMaterialModel( plainMaterial );
+            aiColor4D color;
+            aiString name;
+            if ( AI_SUCCESS == material.Get( AI_MATKEY_COLOR_DIFFUSE, color ) ) {
+                plainMaterial->m_kd = assimpToCore( color );
+            }
+            if ( AI_SUCCESS ==
+                 material.Get( AI_MATKEY_TEXTURE( aiTextureType_DIFFUSE, 0 ), name ) ) {
+                plainMaterial->m_texDiffuse    = m_filepath + "/" + assimpToCore( name );
+                plainMaterial->m_hasTexDiffuse = true;
+            }
+            if ( AI_SUCCESS ==
+                 material.Get( AI_MATKEY_TEXTURE( aiTextureType_OPACITY, 0 ), name ) ) {
+                plainMaterial->m_texOpacity    = m_filepath + "/" + assimpToCore( name );
+                plainMaterial->m_hasTexOpacity = true;
+            }
+        } break;
 
-        if ( AI_SUCCESS == material.Get( AI_MATKEY_COLOR_SPECULAR, color ) ) {
-            blinnPhongMaterial->m_hasSpecular = true;
-            blinnPhongMaterial->m_specular    = assimpToCore( color );
-        }
+        case aiShadingMode_Gouraud: {
 
-        if ( AI_SUCCESS == material.Get( AI_MATKEY_SHININESS, shininess ) ) {
-            blinnPhongMaterial->m_hasShininess = true;
-            // Assimp gives the Phong exponent, we use the Blinn-Phong exponent
-            blinnPhongMaterial->m_shininess = shininess * 4;
-        }
+            auto lambertianMaterial =
+                std::make_shared<Core::Material::LambertianMaterialModel>( matName );
+            assetMaterial.setMaterialModel( lambertianMaterial );
+            aiColor4D color;
+            aiString name;
+            if ( AI_SUCCESS == material.Get( AI_MATKEY_COLOR_DIFFUSE, color ) ) {
+                lambertianMaterial->m_kd = assimpToCore( color );
+            }
+            if ( AI_SUCCESS ==
+                 material.Get( AI_MATKEY_TEXTURE( aiTextureType_DIFFUSE, 0 ), name ) ) {
+                lambertianMaterial->m_texDiffuse    = m_filepath + "/" + assimpToCore( name );
+                lambertianMaterial->m_hasTexDiffuse = true;
+            }
+            if ( AI_SUCCESS ==
+                 material.Get( AI_MATKEY_TEXTURE( aiTextureType_OPACITY, 0 ), name ) ) {
+                lambertianMaterial->m_texOpacity    = m_filepath + "/" + assimpToCore( name );
+                lambertianMaterial->m_hasTexOpacity = true;
+            }
+            if ( AI_SUCCESS ==
+                 material.Get( AI_MATKEY_TEXTURE( aiTextureType_NORMALS, 0 ), name ) ) {
+                lambertianMaterial->m_texNormal    = m_filepath + "/" + assimpToCore( name );
+                lambertianMaterial->m_hasTexNormal = true;
+            }
+            // Assimp loads objs bump maps as height maps, gj bro
+            if ( AI_SUCCESS ==
+                 material.Get( AI_MATKEY_TEXTURE( aiTextureType_HEIGHT, 0 ), name ) ) {
+                lambertianMaterial->m_texNormal    = m_filepath + "/" + assimpToCore( name );
+                lambertianMaterial->m_hasTexNormal = true;
+            }
+        } break;
 
-        if ( AI_SUCCESS == material.Get( AI_MATKEY_OPACITY, opacity ) ) {
-            blinnPhongMaterial->m_hasOpacity = true;
-            // NOTE(charly): Due to collada way of handling objects that have an alpha map, we must
-            // ensure
-            //               we do not have zeros in here.
-            blinnPhongMaterial->m_opacity = opacity < 1e-5 ? 1 : opacity;
-        }
+        default: {
+            // all other shading model are considered as blinn-phong ...
+            auto blinnPhongMaterial =
+                std::make_shared<Core::Material::BlinnPhongMaterialModel>( matName );
+            assetMaterial.setMaterialModel( blinnPhongMaterial );
 
-        if ( AI_SUCCESS == material.Get( AI_MATKEY_TEXTURE( aiTextureType_DIFFUSE, 0 ), name ) ) {
-            blinnPhongMaterial->m_texDiffuse    = m_filepath + "/" + assimpToCore( name );
-            blinnPhongMaterial->m_hasTexDiffuse = true;
-        }
+            aiColor4D color;
+            float shininess;
+            float opacity;
+            aiString name;
 
-        if ( AI_SUCCESS == material.Get( AI_MATKEY_TEXTURE( aiTextureType_SPECULAR, 0 ), name ) ) {
-            blinnPhongMaterial->m_texSpecular    = m_filepath + "/" + assimpToCore( name );
-            blinnPhongMaterial->m_hasTexSpecular = true;
-        }
+            if ( AI_SUCCESS == material.Get( AI_MATKEY_COLOR_DIFFUSE, color ) ) {
+                blinnPhongMaterial->m_kd = assimpToCore( color );
+            }
 
-        if ( AI_SUCCESS == material.Get( AI_MATKEY_TEXTURE( aiTextureType_SHININESS, 0 ), name ) ) {
-            blinnPhongMaterial->m_texShininess    = m_filepath + "/" + assimpToCore( name );
-            blinnPhongMaterial->m_hasTexShininess = true;
-        }
+            if ( AI_SUCCESS == material.Get( AI_MATKEY_COLOR_SPECULAR, color ) ) {
+                blinnPhongMaterial->m_ks = assimpToCore( color );
+            }
 
-        if ( AI_SUCCESS == material.Get( AI_MATKEY_TEXTURE( aiTextureType_NORMALS, 0 ), name ) ) {
-            blinnPhongMaterial->m_texNormal    = m_filepath + "/" + assimpToCore( name );
-            blinnPhongMaterial->m_hasTexNormal = true;
-        }
+            if ( AI_SUCCESS == material.Get( AI_MATKEY_SHININESS, shininess ) ) {
+                // Assimp gives the Phong exponent, we use the Blinn-Phong exponent
+                blinnPhongMaterial->m_ns = shininess * 4;
+            }
 
-        // Assimp loads objs bump maps as height maps, gj bro
-        if ( AI_SUCCESS == material.Get( AI_MATKEY_TEXTURE( aiTextureType_HEIGHT, 0 ), name ) ) {
-            blinnPhongMaterial->m_texNormal    = m_filepath + "/" + assimpToCore( name );
-            blinnPhongMaterial->m_hasTexNormal = true;
-        }
+            if ( AI_SUCCESS == material.Get( AI_MATKEY_OPACITY, opacity ) ) {
+                // NOTE(charly): Due to collada way of handling objects that have an alpha map, we
+                // must ensure
+                //               we do not have zeros in here.
+                blinnPhongMaterial->m_alpha = opacity < 1e-5 ? 1 : opacity;
+            }
+
+            if ( AI_SUCCESS ==
+                 material.Get( AI_MATKEY_TEXTURE( aiTextureType_DIFFUSE, 0 ), name ) ) {
+                blinnPhongMaterial->m_texDiffuse    = m_filepath + "/" + assimpToCore( name );
+                blinnPhongMaterial->m_hasTexDiffuse = true;
+            }
+
+            if ( AI_SUCCESS ==
+                 material.Get( AI_MATKEY_TEXTURE( aiTextureType_SPECULAR, 0 ), name ) ) {
+                blinnPhongMaterial->m_texSpecular    = m_filepath + "/" + assimpToCore( name );
+                blinnPhongMaterial->m_hasTexSpecular = true;
+            }
+
+            if ( AI_SUCCESS ==
+                 material.Get( AI_MATKEY_TEXTURE( aiTextureType_SHININESS, 0 ), name ) ) {
+                blinnPhongMaterial->m_texShininess    = m_filepath + "/" + assimpToCore( name );
+                blinnPhongMaterial->m_hasTexShininess = true;
+            }
+
+            if ( AI_SUCCESS ==
+                 material.Get( AI_MATKEY_TEXTURE( aiTextureType_NORMALS, 0 ), name ) ) {
+                blinnPhongMaterial->m_texNormal    = m_filepath + "/" + assimpToCore( name );
+                blinnPhongMaterial->m_hasTexNormal = true;
+            }
 
-        if ( AI_SUCCESS == material.Get( AI_MATKEY_TEXTURE( aiTextureType_OPACITY, 0 ), name ) ) {
-            blinnPhongMaterial->m_texOpacity    = m_filepath + "/" + assimpToCore( name );
-            blinnPhongMaterial->m_hasTexOpacity = true;
+            // Assimp loads objs bump maps as height maps, gj bro
+            if ( AI_SUCCESS ==
+                 material.Get( AI_MATKEY_TEXTURE( aiTextureType_HEIGHT, 0 ), name ) ) {
+                blinnPhongMaterial->m_texNormal    = m_filepath + "/" + assimpToCore( name );
+                blinnPhongMaterial->m_hasTexNormal = true;
+            }
+
+            if ( AI_SUCCESS ==
+                 material.Get( AI_MATKEY_TEXTURE( aiTextureType_OPACITY, 0 ), name ) ) {
+                blinnPhongMaterial->m_texOpacity    = m_filepath + "/" + assimpToCore( name );
+                blinnPhongMaterial->m_hasTexOpacity = true;
+            }
+        }
         }
     }
     else { LOG( logINFO ) << "Found assimp default material " << matName; }
-    data.setMaterial( blinnPhongMaterial );
+    data.setMaterial( assetMaterial );
 }
 
 void AssimpGeometryDataLoader::loadGeometryData(