New proposal for Engine::Displayable

Shaders/Lines/Wireframe.geom.glsl

@@ -20,6 +20,7 @@ in vec4 vPosition[2];
 out vec4 gColor;
 out float pixelWidthDiv2;
 uniform vec2 viewport;
+uniform float pixelWidth;
 vec4 vColor[2];
 
 void main() {
@@ -34,7 +35,6 @@ void main() {
     vec4 scss1 = css1 * css0.w;
 
     vec3 dir           = ( scss1 - scss0 ).xyz;
-    float pixelWidth   = 1.8;
     const float border = 4.;
     vec3 slope         = normalize( vec3( -dir.y, dir.x, 0 ) );
     vec4 n             = vec4( vec3( pixelWidth + border ) / vp * slope, 0 );

examples/DrawPrimitives/AllPrimitivesComponent.cpp

@@ -133,18 +133,18 @@ void AllPrimitivesComponent::initialize() {
 
     //// CUBES ////
     if ( ENABLE_CUBES ) {
-        std::shared_ptr<Mesh> cube1( new Mesh( "Cube" ) );
+        std::shared_ptr<GeometryDisplayable> cube1( new GeometryDisplayable( "Cube" ) );
         auto coord = cellSize / 16_ra;
         cube1->loadGeometry(
-            Geometry::makeSharpBox( Vector3 { coord, coord, coord }, Color::Green() ) );
+            Geometry::makeSharpBox2( Vector3 { coord, coord, coord }, Color::Green() ) );
         auto renderObject1 = RenderObject::createRenderObject(
             "Cube1", this, RenderObjectType::Geometry, cube1, {} );
         renderObject1->setLocalTransform( Transform { Translation( cellCorner ) } );
         renderObject1->setMaterial( blinnPhongMaterial );
         addRenderObject( renderObject1 );
 
-        std::shared_ptr<Mesh> texCube( new Mesh( "Cube" ) );
-        texCube->loadGeometry( Geometry::makeSharpBox(
+        std::shared_ptr<GeometryDisplayable> texCube( new GeometryDisplayable( "Cube" ) );
+        texCube->loadGeometry( Geometry::makeSharpBox2(
             Vector3 { 1.2_ra * coord, 1.2_ra * coord, 1.2_ra * coord }, Color::White(), true ) );
         auto renderObjectTexCube = RenderObject::createRenderObject(
             "TexCube", this, RenderObjectType::Geometry, texCube, {} );
@@ -155,14 +155,15 @@ void AllPrimitivesComponent::initialize() {
         addRenderObject( renderObjectTexCube );
 
         // another cube
-        std::shared_ptr<Mesh> cube2( new Mesh( "Cube" ) );
+        std::shared_ptr<GeometryDisplayable> cube2( new GeometryDisplayable( "Cube" ) );
         coord = cellSize / 4_ra;
-        cube2->loadGeometry( Geometry::makeSharpBox( Vector3 { coord, coord, coord } ) );
+        cube2->loadGeometry( Geometry::makeSharpBox2( Vector3 { coord, coord, coord } ) );
+
         const std::string myColourName { "colour" };
         cube2->getCoreGeometry().addAttrib(
             myColourName, Vector4Array { cube2->getNumVertices(), Color::Red() } );
 
-        cube2->setAttribNameCorrespondance(
+        cube2->setAttribNameMatching(
             myColourName, Ra::Core::Geometry::getAttribName( Ra::Core::Geometry::VERTEX_COLOR ) );
         auto renderObject2 = RenderObject::createRenderObject(
             "CubeRO_2", this, RenderObjectType::Geometry, cube2, {} );
@@ -649,9 +650,8 @@ void AllPrimitivesComponent::initialize() {
         auto hepta = VectorNui( 7 );
         hepta << 3, 2, 4, 5, 6, 7, 8;
         polyMesh.setIndices( { quad, hepta } );
+        auto poly1 = make_shared<GeometryDisplayable>( "Poly", std::move( polyMesh ) );
 
-        std::shared_ptr<Data::PolyMesh> poly1(
-            new Data::PolyMesh( "Poly", std::move( polyMesh ) ) );
         poly1->getCoreGeometry().addAttrib(
             Ra::Core::Geometry::getAttribName( Ra::Core::Geometry::VERTEX_COLOR ),
             Vector4Array { poly1->getNumVertices(), colorBoost * Color { 1_ra, 0.6_ra, 0.1_ra } } );
@@ -664,11 +664,12 @@ void AllPrimitivesComponent::initialize() {
 
         addRenderObject( renderObject1 );
 
-        Ra::Core::Geometry::TopologicalMesh topo { poly1->getCoreGeometry() };
+        Ra::Core::Geometry::TopologicalMesh topo { poly1->getCoreGeometry(),
+                                                   poly1->active_layer_key() };
         topo.triangulate();
         topo.checkIntegrity();
         auto triangulated = topo.toTriangleMesh();
-        std::shared_ptr<Mesh> poly2( new Mesh( "Poly", std::move( triangulated ) ) );
+        auto poly2        = make_shared<GeometryDisplayable>( "Poly", std::move( triangulated ) );
         poly2->getCoreGeometry().addAttrib(
             Ra::Core::Geometry::getAttribName( Ra::Core::Geometry::VERTEX_COLOR ),
             Vector4Array { poly2->getNumVertices(), colorBoost * Color { 0_ra, 0.6_ra, 0.1_ra } } );
@@ -698,19 +699,16 @@ void AllPrimitivesComponent::initialize() {
             auto geomData = data->getGeometryData();
 
             for ( const auto& gd : geomData ) {
-                std::shared_ptr<AttribArrayDisplayable> mesh { nullptr };
+                std::shared_ptr<GeometryDisplayable> mesh { nullptr };
                 switch ( gd->getType() ) {
                 case Ra::Core::Asset::GeometryData::TRI_MESH:
-                    mesh = std::shared_ptr<Mesh> {
-                        createMeshFromGeometryData<Geometry::TriangleMesh>( "logo", gd ) };
+                    mesh = createMeshFromGeometryData2<Geometry::TriangleMesh>( "logo", gd );
                     break;
                 case Ra::Core::Asset::GeometryData::QUAD_MESH:
-                    mesh = std::shared_ptr<Data::QuadMesh> {
-                        createMeshFromGeometryData<Geometry::QuadMesh>( "logo", gd ) };
+                    mesh = createMeshFromGeometryData2<Geometry::QuadMesh>( "logo", gd );
                     break;
                 case Ra::Core::Asset::GeometryData::POLY_MESH:
-                    mesh = std::shared_ptr<Data::PolyMesh> {
-                        createMeshFromGeometryData<Geometry::PolyMesh>( "logo", gd ) };
+                    mesh = createMeshFromGeometryData2<Geometry::PolyMesh>( "logo", gd );
                     break;
                 default:
                     break;
@@ -868,7 +866,7 @@ void AllPrimitivesComponent::initialize() {
     auto addMesh = [this, colorBoost, plainMaterial]( Vector3 pos, TopologicalMesh topo1 ) {
         topo1.checkIntegrity();
         auto mesh1 = topo1.toTriangleMesh();
-        std::shared_ptr<Mesh> poly( new Mesh( "TEST", std::move( mesh1 ) ) );
+        auto poly  = make_shared<GeometryDisplayable>( "topo mesh", std::move( mesh1 ) );
 
         auto renderObject2 =
             RenderObject::createRenderObject( "TEST", this, RenderObjectType::Geometry, poly, {} );
@@ -1058,8 +1056,8 @@ void AllPrimitivesComponent::initialize() {
         {
             using Ra::Engine::Data::Mesh;
             {
-                auto torusGeom = makeParametricTorus<32, 16>( .04_ra, .01_ra, Color::White() );
-                auto torusMesh = make_shared<Mesh>( "Torus", std::move( torusGeom ) );
+                auto geom      = makeParametricTorus<16, 8>( .04_ra, .01_ra, Color::White() );
+                auto torusMesh = make_shared<GeometryDisplayable>( "Torus", std::move( geom ) );
                 auto torus     = RenderObject::createRenderObject(
                     "test_torus", this, RenderObjectType::Geometry, torusMesh, {} );
                 torus->setMaterial( blinnPhongMaterial );
@@ -1070,10 +1068,9 @@ void AllPrimitivesComponent::initialize() {
             }
 
             {
-                auto texTorusGeom =
-                    makeParametricTorus<64, 16>( .1_ra, .05_ra, Color::White(), true );
+                auto geom = makeParametricTorus<32, 12>( .1_ra, .05_ra, Color::White(), true );
                 auto texTorusMesh =
-                    make_shared<Mesh>( "Textured Torus", std::move( texTorusGeom ) );
+                    make_shared<GeometryDisplayable>( "Textured Torus", std::move( geom ) );
                 auto texTorus = RenderObject::createRenderObject(
                     "test_tex_torus", this, RenderObjectType::Geometry, texTorusMesh, {} );
                 texTorus->setMaterial( blinnPhongTexturedMaterial );

examples/HelloRadium/main.cpp

@@ -27,7 +27,7 @@ int main( int argc, char* argv[] ) {
     //! [Verifying the OpenGL version available to the engine]
 
     //! [Creating the cube]
-    auto cube = Ra::Core::Geometry::makeSharpBox( { 0.1f, 0.1f, 0.1f } );
+    auto cube { std::move( Ra::Core::Geometry::makeSharpBox2( { 0.1f, 0.1f, 0.1f } ) ) };
     //! [Creating the cube]
 
     //! [Colorize the Cube]
@@ -41,8 +41,8 @@ int main( int argc, char* argv[] ) {
     //! [Create the engine entity for the cube]
 
     //! [Create a geometry component with the cube]
-    auto c =
-        new Ra::Engine::Scene::TriangleMeshComponent( "Cube Mesh", e, std::move( cube ), nullptr );
+    auto c = new Ra::Engine::Scene::GeometryDisplayableComponent(
+        "Cube Mesh", e, std::move( cube ), nullptr );
     //! [Create a geometry component with the cube]
 
     //! [Register the entity/component association to the geometry system ]

examples/SimpleSkinning/main.cpp

@@ -5,12 +5,15 @@
 #include <Engine/FrameInfo.hpp>
 #include <Engine/RadiumEngine.hpp>
 #include <Engine/Scene/CameraManager.hpp>
+#include <Engine/Scene/DefaultLightManager.hpp>
+#include <Engine/Scene/DirLight.hpp>
 #include <Engine/Scene/EntityManager.hpp>
 #include <Engine/Scene/GeometryComponent.hpp>
 #include <Engine/Scene/SkeletonBasedAnimationSystem.hpp>
 #include <Engine/Scene/SkeletonComponent.hpp>
 #include <Engine/Scene/SkinningComponent.hpp>
 #include <Engine/Scene/System.hpp>
+#include <Engine/Scene/SystemDisplay.hpp>
 #include <Gui/BaseApplication.hpp>
 #include <Gui/RadiumWindow/SimpleWindowFactory.hpp>
 #include <Gui/Viewer/Viewer.hpp>
@@ -71,6 +74,13 @@ class SkinningSystem : public Scene::System
 };
 
 void setupScene( Ra::Engine::RadiumEngine* engine ) {
+
+    DefaultLightManager* lightManager =
+        static_cast<DefaultLightManager*>( engine->getSystem( "DefaultLightManager" ) );
+    auto light = new Engine::Scene::DirectionalLight(
+        Ra::Engine::Scene::SystemEntity::getInstance(), "light" );
+    lightManager->addLight( light );
+
     auto animationSystem = new SkinningSystem;
     engine->registerSystem( "Simple animation system", animationSystem );
 

src/Core/Animation/LinearBlendSkinning.cpp

@@ -1,3 +1,4 @@
+#include "Core/Types.hpp"
 #include <Core/Animation/LinearBlendSkinning.hpp>
 
 #include <Core/Animation/SkinningData.hpp>
@@ -33,9 +34,10 @@ void linearBlendSkinning( const SkinningRefData& refData,
             const Scalar w                 = it.value();
             // prepare the pose w.r.t. the bind matrix and the mesh transform
             const Transform M = refData.m_meshTransformInverse * pose[j] * bindMatrix[j];
+            const Matrix3 N   = M.matrix().inverse().transpose().block<3, 3>( 0, 0 );
             // apply LBS
             frameData.m_currentPosition[i] += w * ( M * vertices[i] );
-            frameData.m_currentNormal[i] += w * ( M.linear() * normals[i] );
+            frameData.m_currentNormal[i] += w * ( N * normals[i] );
             frameData.m_currentTangent[i] += w * ( M.linear() * tangents[i] );
             frameData.m_currentBitangent[i] += w * ( M.linear() * bitangents[i] );
         }

src/Core/Animation/SkinningData.hpp

@@ -13,7 +13,7 @@ namespace Animation {
 /// \brief Skinning data that get set at startup including the "reference state".
 struct SkinningRefData {
     /// The mesh in reference position.
-    Geometry::TriangleMesh m_referenceMesh;
+    Geometry::AttribArrayGeometry m_referenceMesh;
 
     /// The inverse of the mesh's transform.
     Transform m_meshTransformInverse;

src/Core/Geometry/AbstractGeometry.hpp

@@ -13,8 +13,9 @@ namespace Geometry {
 /// \warning: Part of the current proposal for a modular implementation of
 /// displayable objects.
 ///
-/// \note We use a struct because all members are public anyway
-struct RA_CORE_API AbstractGeometry {
+class RA_CORE_API AbstractGeometry
+{
+  public:
     /*
      * Note: Explicitly defaulted virtual destructor, copy/move constructors,
      * copy/move assignment operators

src/Core/Geometry/IndexedGeometry.cpp

@@ -1,4 +1,6 @@
 #include <Core/Geometry/IndexedGeometry.hpp>
+#include <Core/Geometry/TriangleMesh.hpp>
+
 #include <iterator>
 
 namespace Ra {
@@ -56,23 +58,33 @@ void MultiIndexedGeometry::checkConsistency() const {
 }
 
 bool MultiIndexedGeometry::append( const MultiIndexedGeometry& other ) {
+
+    int offset = other.vertices().size();
+    // first append attribs
+    AttribArrayGeometry::append( other );
+
+    // then indices, and offset.
     bool dataHasBeenCopied = false;
     for ( const auto& [key, value] : other.m_indices ) {
         auto it = m_indices.find( key );
         if ( it == m_indices.end() ) // copy entire layer
         {
             m_indices[key] = std::make_pair(
                 value.first, std::unique_ptr<GeometryIndexLayerBase> { value.second->clone() } );
-
             dataHasBeenCopied = true;
+            m_indices[key].second->offset( offset );
+            ///\todo offest indices.
         }
         else {
             // try to append to an existing layer: should always work
-            if ( it->second.second->append( *( value.second ) ) ) { dataHasBeenCopied = true; }
+            if ( it->second.second->append( *( value.second ), offset ) ) {
+                dataHasBeenCopied = true;
+            }
             else {
                 CORE_ASSERT( false,
                              "Inconsistency: layers with different semantics shares the same key" );
             }
+            ///\todo offest indices.
         }
     }
 
@@ -210,23 +222,23 @@ void MultiIndexedGeometry::unlockLayer( const LayerKeyType& layerKey ) {
 //////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////
 
-std::pair<bool, GeometryIndexLayerBase&>
-MultiIndexedGeometry::addLayer( std::unique_ptr<GeometryIndexLayerBase>&& layer,
-                                const bool withLock,
-                                const std::string& layerName ) {
+auto MultiIndexedGeometry::addLayer( std::unique_ptr<GeometryIndexLayerBase>&& layer,
+                                     const bool withLock,
+                                     const std::string& layerName )
+    -> std::pair<bool, LayerKeyType> {
     LayerKeyType key { layer->semantics(), layerName };
-    std::pair<LayerKeyType, EntryType> elt { key, std::make_pair( false, std::move( layer ) ) };
+    auto elt             = std::make_pair( key, std::make_pair( false, std::move( layer ) ) );
     auto [pos, inserted] = m_indices.insert( std::move( elt ) );
     notify();
 
     if ( withLock ) {
         CORE_ASSERT( !pos->second.first, "try to get already locked layer" );
         pos->second.first = true;
     }
-    /// If not inserted, the pointer is deleted. So the caller must ensure this possible deletion
-    /// is safe before calling this method.
+    /// If not inserted, the pointer is deleted. So the caller must ensure this possible
+    /// deletion is safe before calling this method.
 
-    return { inserted, *( pos->second.second ) };
+    return { inserted, key };
 }
 //////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////
@@ -245,7 +257,7 @@ void MultiIndexedGeometry::deepClear() {
 //////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////
 
-std::size_t MultiIndexedGeometry::KeyHash::operator()( const LayerKeyType& k ) const {
+std::size_t MultiIndexedGeometry::LayerKeyHash::operator()( const LayerKeyType& k ) const {
     // Mix semantic collection into a single identifier string
     std::ostringstream stream;
     std::copy( k.first.begin(), k.first.end(), std::ostream_iterator<std::string>( stream, "" ) );
@@ -256,15 +268,6 @@ std::size_t MultiIndexedGeometry::KeyHash::operator()( const LayerKeyType& k ) c
     return std::hash<std::string> {}( result ) ^ ( std::hash<std::string> {}( k.second ) << 1 );
 }
 
-//////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////
-
-void PointCloudIndexLayer::linearIndices( const AttribArrayGeometry& attr ) {
-    auto nbVert = attr.vertices().size();
-    collection().resize( nbVert );
-    collection().getMap() = IndexContainerType::Matrix::LinSpaced( nbVert, 0, nbVert - 1 );
-}
-
 } // namespace Geometry
 } // namespace Core
 } // namespace Ra