util_mesh_dtk.hpp

Go to the documentation of this file.

 
#ifndef _UTIL_MESH_DTK_HPP_
#define _UTIL_MESH_DTK_HPP_
 
#include "util/util_stl_dtk.hpp"
#include "util/util_ent_dtk.hpp"
#include "util/dtk_picture.hpp"
#include <cstdio>
#include "def/define.h"
#include "util/BaseTypes/dtk_dir.hpp"
#include "util/BaseTypes/dtk_matrix.hpp"
#include "util/BaseTypes/dtk_object.hpp"
#include "util/BaseTypes/dtk_pnt.hpp"
#include "util/BaseTypes/dtk_rgb.hpp"
#include "util/BaseTypes/dtk_string.hpp"
#include "util/BaseTypes/dtk_transfo.hpp"
#include "util/dtk_val.hpp"
#include "util/error_dtk.hpp"
#include "util/util_ptr_dtk.hpp"
 
class Dtk_material;
class Dtk_mesh;
class Dtk_mesh_face;
typedef Dtk_SmartPtr<Dtk_material>              Dtk_MaterialPtr;
typedef Dtk_SmartPtr<Dtk_mesh>                         Dtk_MeshPtr;
typedef Dtk_SmartPtr<Dtk_mesh_face>                    Dtk_mesh_facePtr;
 
/* Filtres */
 
#define DTK_MESH_XYZ                   1
#define DTK_MESH_NORMAL                2
#define DTK_MESH_RGB                   4
#define DTK_MESH_UV_TEXTURES           8    // textures
#define DTK_MESH_UV_BREP              16
#define DTK_MESH_DOUBLEPRECISION     32
// combinations
#define DTK_MESH_XYZ_NORMAL            3
#define DTK_MESH_XYZ_NORMAL_UVTEXTURES 11
#define DTK_MESH_XYZ_NORMAL_RGB        7
#define DTK_MESH_ALL                   31
 
/* Types de triangulation */
 
enum DTK_FACET_TYPE { DTK_UNKNOWN_FACET, DTK_TRIANGLES, DTK_TRIANGLE_STRIP, DTK_TRIANGLE_FAN, DTK_POLYGONS, DTK_MOCKUP };
 
enum DTK_MESH_CRV_TYPE  { DTK_MESH_UNKNOWN_CRV_TYPE, DTK_MESH_CIRCLE, DTK_MESH_LINE, DTK_MESH_OTHERCRV };
 
#define DTK_VALUE_M        1000.0
#define DTK_VALUE_CM       10.0
#define DTK_VALUE_MM       1.0
#define DTK_VALUE_INCH     25.4
#define DTK_VALUE_FEET     304.8
 
 
/// @cond OLD_DTK_API
struct Dtk_bounding_box
{
    Dtk_pnt A;
    Dtk_pnt B;
    Dtk_pnt M;
};
 
typedef Dtk_bounding_box dtk_mesh_face_bb;
typedef Dtk_tab<dtk_mesh_face_bb> dtk_mesh_body_face_bb;
 
typedef Dtk_tab<dtk_mesh_body_face_bb> dtk_mesh_per_body_face_bb;
typedef Dtk_bounding_box dtk_mesh_body_bb;
 
typedef Dtk_tab<dtk_mesh_body_bb> dtk_mesh_bodies_bb;
typedef Dtk_bounding_box dtk_mesh_all_bodies_bb;
 
typedef Dtk_bounding_box dtk_mesh_crv_bb;
typedef Dtk_tab<dtk_mesh_crv_bb> dtk_mesh_per_crv_bb;
typedef Dtk_bounding_box dtk_mesh_all_crvs_bb;
 
 
class Dtk_material_value
{
public:
    Dtk_string NameProperties;
    Dtk_tab<Dtk_Val > PropertiesValue;
 
     //! \deprecated Use Dtk_material_value::Dtk_material_value(const Dtk_material_value &) instead
     SetAsDeprecated( "2026.4", "Use Dtk_material_value::Dtk_material_value(const Dtk_material_value &) instead" )
     void _Copy(const Dtk_material_value & s)
     {
          NameProperties = s.NameProperties;
          for(Dtk_Size_t i=0;i<s.PropertiesValue.size();i++)
          {
               PropertiesValue.push_back(Dtk_Val(s.PropertiesValue.at(i)));
          }
     }
};
 
class Dtk_rendering
{
public:
    Dtk_string name;
    Dtk_tab<Dtk_material_value> value;
 
     //! \deprecated Use Dtk_rendering::Dtk_rendering(const Dtk_rendering &) instead
     SetAsDeprecated( "2026.4", "Use Dtk_rendering::Dtk_rendering(const Dtk_rendering &) instead" )
     void _Copy(const Dtk_rendering * s)
     {
          if(s)
          {
               name = s->name;
               value = s->value;
          }
     }
};
 
class Dtk_drw
{
public:
    Dtk_string name;
    Dtk_picture * picture;
    Dtk_string picturename;
    Dtk_tab<Dtk_material_value> value;
 
    Dtk_drw( ) : picture( nullptr ){}
    ~Dtk_drw()
    {
          delete picture;
        picture = nullptr;
    }
 
     Dtk_drw( const Dtk_drw& s ) : name( s.name ), picturename( s.picturename ), picture( nullptr ), value( s.value )
     {
          if( s.picture )
          {
               picture = new Dtk_picture( *s.picture );
          }
     }
     Dtk_drw& operator=( const Dtk_drw& s )
     {
          if( this != &s )
          {
               name = s.name;
               picturename = s.picturename;
               delete picture;
               picture = nullptr;
               if( s.picture )
               {
                    picture = new Dtk_picture( *s.picture );
               }
               value = s.value;
          }
          return *this;
     }
     Dtk_drw( Dtk_drw && s ) DTK_NOEXCEPT : name( std::move( s.name ) ), picturename( std::move( s.picturename ) ), picture( s.picture ), value( std::move( s.value ) )
     {
          s.picture = nullptr;
     }
     Dtk_drw& operator=( Dtk_drw && s ) DTK_NOEXCEPT
     {
          if( this != &s )
          {
               name = std::move( s.name );
               picturename = std::move( s.picturename );
               delete picture;
               picture = s.picture;
               s.picture = nullptr;
               value = std::move( s.value );
          }
          return *this;
     }
     //! \deprecated Use Dtk_drw::Dtk_drw(const Dtk_drw &) instead
     SetAsDeprecated( "2026.4", "Use Dtk_drw::Dtk_drw(const Dtk_drw &) instead" )
          void _Copy( const Dtk_drw* s )
     {
          if( s )
          {
               name = s->name;
               picturename = s->picturename;
               if( s->picture )
               {
                    picture = new Dtk_picture( *s->picture );
               }
               value = s->value;
          }
     }
};
 
class Dtk_drafting
{
public:
    Dtk_string name;
    Dtk_tab<Dtk_drw * > drw;
    Dtk_tab<Dtk_material_value> value;
 
     Dtk_drafting() : drw(), value() {}
     Dtk_drafting( const Dtk_drafting& s ) : name( s.name ), drw(), value( s.value )
     {
          for( Dtk_Size_t i = 0; i < s.drw.size(); i++ )
          {
               if( s.drw.at( i ) != nullptr )
               {
                    drw.push_back( new Dtk_drw( *s.drw.at( i ) ) );
               }
          }
     }
 
     Dtk_drafting& operator=( const Dtk_drafting& s )
     {
          if( this != &s )
          {
               name = s.name;
               value = s.value;
               for( Dtk_Size_t i = 0; i < drw.size(); i++ )
               {
                    delete drw.at( i );
                    drw.at( i ) = nullptr;
               }
               drw.clear();
               drw.reserve( s.drw.size() );
               for( Dtk_Size_t i = 0; i < s.drw.size(); i++ )
               {
                    if( s.drw.at( i ) == nullptr )
                    {
                         drw.push_back( nullptr );
                         continue;
                    }
                    drw.push_back( new Dtk_drw( *s.drw.at( i ) ) );
               }
          }
          return *this;
     }
 
     Dtk_drafting( Dtk_drafting && s ) DTK_NOEXCEPT : name( std::move( s.name ) ), drw( std::move( s.drw ) ), value( std::move( s.value ) )
     {
          s.drw.clear();
     }
 
     Dtk_drafting& operator=( Dtk_drafting && s ) DTK_NOEXCEPT
     {
          if( this != &s )
          {
               name = std::move( s.name );
               value = std::move( s.value );
               for( Dtk_Size_t i = 0; i < drw.size(); i++ )
               {
                    delete drw.at( i );
                    drw.at( i ) = nullptr;
               }
               drw = std::move( s.drw );
               s.drw.clear();
          }
          return *this;
     }
 
     ~Dtk_drafting()
     {
          for( Dtk_Size_t i = 0; i < drw.size(); i++ )
          {
               delete drw.at( i );
               drw.at( i ) = nullptr;
          }
     }
 
     //! \deprecated Use Dtk_drafting::Dtk_drafting(const Dtk_drafting &) instead
     SetAsDeprecated( "2026.4", "Use Dtk_drafting::Dtk_drafting(const Dtk_drafting &) instead" )
     void _Copy(const Dtk_drafting * s)
     {
          if(s)
          {
               name = s->name;
               for(Dtk_Size_t i=0;i<s->drw.size();i++)
               {
                    if( s->drw.at(i) != nullptr )
                    {
                         drw.push_back( new Dtk_drw( *s->drw.at( i ) ) );
                    }
               }
               value = s->value;
          }
     }
};
 
class Dtk_analysis
{
public:
    Dtk_string name;
    Dtk_tab<Dtk_material_value> value;
 
     //! \deprecated Use Dtk_analysis::Dtk_analysis(const Dtk_analysis &) instead
     SetAsDeprecated( "2026.4", "Use Dtk_analysis::Dtk_analysis(const Dtk_analysis &) instead" )
     void _Copy(const Dtk_analysis * s)
     {
          if(s)
          {
               name = s->name;
               value = s->value;
          }
     }
};
 
class Dtk_composites
{
public:
    Dtk_string name;
    Dtk_tab<Dtk_material_value> value;
 
     //! \deprecated Use Dtk_composites::Dtk_composites(const Dtk_composites &) instead
     SetAsDeprecated( "2026.4", "Use Dtk_composites::Dtk_composites(const Dtk_composites &) instead" )
     void _Copy(const Dtk_composites * s)
     {
          if(s)
          {
               name = s->name;
               value = s->value;
          }
     }
};
 
class Dtk_positioned
{
public:
    Dtk_string name;
    Dtk_tab<Dtk_material_value> value;
    Dtk_transfo * matrix;
    
     Dtk_positioned() : matrix( nullptr ){}
    ~Dtk_positioned()
    {
        delete matrix;
        matrix = nullptr;
    }
     Dtk_positioned( const Dtk_positioned& s ) : name( s.name ), matrix( nullptr ), value( s.value )
     {
          if( s.matrix )
          {
               matrix = new Dtk_transfo( s.matrix->getXdir(), s.matrix->getYdir(), s.matrix->getZdir(), s.matrix->getOrigin(), s.matrix->getScale() );
          }
     }
     Dtk_positioned& operator=( const Dtk_positioned& s )
     {
          if( this != &s )
          {
               name = s.name;
               value = s.value;
               delete matrix;
               matrix = nullptr;
               if( s.matrix )
               {
                    matrix = new Dtk_transfo( s.matrix->getXdir(), s.matrix->getYdir(), s.matrix->getZdir(), s.matrix->getOrigin(), s.matrix->getScale() );
               }
          }
          return *this;
     }
     Dtk_positioned( Dtk_positioned && s ) DTK_NOEXCEPT : name( std::move( s.name ) ), matrix( s.matrix ), value( std::move( s.value ) )
     {
          s.matrix = nullptr;
     }
     Dtk_positioned& operator=( Dtk_positioned && s ) DTK_NOEXCEPT
     {
          if( this != &s )
          {
               name = std::move( s.name );
               value = std::move( s.value );
               delete matrix;
               matrix = s.matrix;
               s.matrix = nullptr;
          }
          return *this;
     }
 
     //! \deprecated Use Dtk_positioned::Dtk_positioned(const Dtk_positioned &) instead
     SetAsDeprecated( "2026.4", "Use Dtk_positioned::Dtk_positioned(const Dtk_positioned &) instead" )
          void _Copy( const Dtk_positioned* s )
     {
          if( s )
          {
               name = s->name;
               value = s->value;
               if( s->matrix )
               {
                    matrix = new Dtk_transfo( s->matrix->getXdir(), s->matrix->getYdir(), s->matrix->getZdir(), s->matrix->getOrigin(), s->matrix->getScale() );
               }
          }
     }
};
 
//! \brief Gathers material related datas
class Dtk_material : public Dtk_Object
{
protected:
    enum 
    {
        _typeID = DTK_TYPE_MATERIAL
    };
private:
    friend class Dtk_SmartPtr<Dtk_material>;
public:
    //! \brief type of material
    Dtk_string label;
 
    double ambient;             
    double diffuse;
    double specular;
    double refraction;
    double transparency;
    double reflectivity;
    double roughness;
    double  _Density;
 
     Dtk_Int32 _renderID;
     Dtk_Int32 _physicalID;
     //! \brief identifiant dans la library de material
     Dtk_Int32 _identifier_library;
    //! \brief Texture clamping setting (u)
    bool repeat_u;
    //! \brief Texture clamping setting (v)
    bool repeat_v;
    //! \brief picture
    Dtk_picture * picture;
    //! \brief Texture filename
    Dtk_string texture;
 
    //! \brief other properties
    Dtk_rendering  * rendering;
    Dtk_drafting   * drafting;
    Dtk_analysis   * analysis;
    Dtk_composites * composites;
    Dtk_positioned * positioned;
 
    //! \DtkDynamicType
    Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId)
    { 
        if (inId == _typeID)
        {
            return 1; 
        }
        return Dtk_material::DtkDynamicType(inId); 
    }
    //! \DtkDynamicCast
    static Dtk_material * DtkDynamicCast(Dtk_Object * s)
    { 
        if(s->DtkDynamicType(_typeID)) 
            return static_cast<Dtk_material * >(s); 
        return NULL; 
    } 
 
 
     //! \deprecated Use Dtk_material::Dtk_material(const Dtk_MaterialPtr &) instead
     SetAsDeprecated( "2026.4", "Use Dtk_material::Dtk_material(const Dtk_MaterialPtr &) instead" )
     void _Copy(const Dtk_MaterialPtr & s)
     {
          if(s.IsNotNULL())
          {
               label = s->label;
               ambient = s->ambient;             
               diffuse = s->diffuse;
               specular = s->specular;
               refraction = s->refraction;
               transparency = s->transparency;
               reflectivity = s->reflectivity;
               roughness = s->roughness;
               _Density = s->_Density;
               _renderID = s->_renderID;
               repeat_u = s->repeat_u;
               repeat_v = s->repeat_v;
               texture = s->texture;
               _identifier_library = s->_identifier_library;
               if(s->picture)
               {
                    picture = new Dtk_picture(*s->picture);
               }
               if(s->rendering)
               {
                    rendering = new Dtk_rendering(*s->rendering);
               }
               if(s->drafting)
               {
                    drafting = new Dtk_drafting( *s->drafting );
               }
               if(s->analysis)
               {
                    analysis = new Dtk_analysis( *s->analysis );
               }
               if(s->composites)
               {
                    composites = new Dtk_composites( *s->composites );
               }
               if(s->positioned)
               {
                    positioned = new Dtk_positioned( *s->positioned );
               }
          }
     }
 
     Dtk_material( const Dtk_material& s ) : label(s.label), texture(s.texture ),roughness( s.roughness ), refraction( s.refraction ), ambient( s.ambient ), transparency( s.transparency ), diffuse( s.diffuse ), specular( s.specular ),
     reflectivity( s.reflectivity ), repeat_u( s.repeat_u ), repeat_v( s.repeat_v ), _Density( s._Density ), _renderID( s._renderID ), _physicalID( s._physicalID ),
          _identifier_library( s._identifier_library ), picture( nullptr ), rendering( nullptr ), drafting( nullptr ), analysis( nullptr ), composites( nullptr ), positioned( nullptr )
     {
          if( s.picture )
          {
               picture = new Dtk_picture(*s.picture);
          }
          if( s.rendering )
          {
               rendering = new Dtk_rendering(*s.rendering);
          }
          if( s.drafting )
          {
               drafting = new Dtk_drafting( *s.drafting );
          }
          if( s.analysis )
          {
               analysis = new Dtk_analysis( *s.analysis );
          }
          if( s.composites )
          {
               composites = new Dtk_composites( *s.composites );
          }
          if( s.positioned )
          {
               positioned = new Dtk_positioned( *s.positioned );
          }
     }
     Dtk_material& operator=( const Dtk_material& s )
     {
          if( this != &s )
          {
               roughness = s.roughness;
               refraction = s.refraction;
               ambient = s.ambient;
               transparency = s.transparency;
               diffuse = s.diffuse;
               specular = s.specular;
               reflectivity = s.reflectivity;
               repeat_u = s.repeat_u;
               repeat_v = s.repeat_v;
               _Density = s._Density;
               _renderID = s._renderID;
               _physicalID = s._physicalID;
               _identifier_library = s._identifier_library;
               if( picture )
               {
                    delete picture;
                    picture = nullptr;
               }
               picture = s.picture ? new Dtk_picture( *s.picture ) : nullptr;
               if( rendering )
               {
                    delete rendering;
                    rendering = nullptr;
               }
               rendering = s.rendering ? new Dtk_rendering( *s.rendering ) : nullptr;
               if( drafting )
               {
                    delete drafting;
                    drafting = nullptr;
               }
               drafting = s.drafting ? new Dtk_drafting( *s.drafting ) : nullptr;
               if( analysis )
               {
                    delete analysis;
                    analysis = nullptr;
               }
               analysis = s.analysis ? new Dtk_analysis( *s.analysis ) : nullptr;
               if( composites )
               {
                    delete composites;
                    composites = nullptr;
               }
               composites = s.composites ? new Dtk_composites( *s.composites ) : nullptr;
               if( positioned )
               {
                    delete positioned;
                    positioned = nullptr;
               }
               positioned = s.positioned ? new Dtk_positioned( *s.positioned ) : nullptr;
          }
          return *this;
     }
 
     Dtk_material( Dtk_material&& s ) DTK_NOEXCEPT : roughness( s.roughness ), refraction( s.refraction ), ambient( s.ambient ), transparency( s.transparency ), diffuse( s.diffuse ), specular( s.specular ),
          reflectivity( s.reflectivity ), repeat_u( s.repeat_u ), repeat_v( s.repeat_v ), _Density( s._Density ), _renderID( s._renderID ), _physicalID( s._physicalID ),
          _identifier_library( s._identifier_library ), picture( s.picture ), rendering( s.rendering ), drafting( s.drafting ), analysis( s.analysis ), composites( s.composites ), positioned( s.positioned )
     {
          s.picture = nullptr;
          s.rendering = nullptr;
          s.drafting = nullptr;
          s.analysis = nullptr;
          s.composites = nullptr;
          s.positioned = nullptr;
     }
    //Constructor
     Dtk_material() : roughness( 0.0 ), refraction( 0.0 ), ambient( 0.0 ), diffuse( 0.0 ), specular( 0.0 ), transparency( 0.0 ), reflectivity( 0.0 ), 
     repeat_u( 0 ), repeat_v( 0 ), rendering( nullptr ), drafting( nullptr ), analysis( nullptr ), composites( nullptr ), positioned( nullptr ), picture( nullptr ),
     _Density( 0.0 ), _renderID( -1 ), _physicalID( -1 ), _identifier_library( 0 )
    {}
     Dtk_material& operator=( Dtk_material&& s ) DTK_NOEXCEPT
     {
          roughness = s.roughness;
          refraction = s.refraction;
          ambient = s.ambient;
          diffuse = s.diffuse;
          specular = s.specular;
          transparency = s.transparency;
          reflectivity = s.reflectivity;
          repeat_u = s.repeat_u;
          repeat_v = s.repeat_v;
          _Density = s._Density;
          _renderID = s._renderID;
          _physicalID = s._physicalID;
          _identifier_library = s._identifier_library;
          if( rendering )
          {
               delete rendering;
               rendering = nullptr;
          }
          rendering = s.rendering;
          s.rendering = nullptr;
          if( drafting )
          {
               delete drafting;
               drafting = nullptr;
          }
          drafting = s.drafting;
          s.drafting = nullptr;
          if( analysis )
          {
               delete analysis;
               analysis = nullptr;
          }
          analysis = s.analysis;
          s.analysis = nullptr;
          if( composites )
          {
               delete composites;
               composites = nullptr;
          }
          composites = s.composites;
          s.composites = nullptr;
          if( positioned )
          {
               delete positioned;
               positioned = nullptr;
          }
          positioned = s.positioned;
          s.positioned = nullptr;
          if( picture )
          {
               delete picture;
               picture = nullptr;
          }
          picture = s.picture;
          s.picture = nullptr;
          return *this;
     }
 
    // Destructor
    ~Dtk_material()
    {
        delete picture;
        picture = NULL;
        delete drafting;
        drafting = NULL;
        delete rendering;
        rendering = NULL;
        delete analysis;
        analysis = NULL;
        delete composites;
        composites = NULL;
        delete positioned;
        positioned = NULL;
    }
 
     inline Dtk_Double64 GetDensity() const {return _Density;}
     inline void SetDensity(const Dtk_Double64 inDensity) {_Density = inDensity;}
     inline Dtk_Int32 GetRenderID() const {return _renderID;}
     inline void SetRenderID(const Dtk_Int32 inRenderID) {_renderID = inRenderID;}
     inline Dtk_Int32 GetPhysicalMaterialID() const { return _physicalID; }
     inline void SetPhysicalMaterialID(const Dtk_Int32 inPhysicalID) { _physicalID = inPhysicalID; }
 
};
//! \endcond
 
/* Class mesh */
 
class Dtk_mesh_vertex;
class Dtk_facet; 
class Dtk_mesh_face;
 
 
 
//! \class Dtk_mesh 
//! \brief This is a high level mesh class.
//!
//!    This class gathers all the datas related to a triangulated mesh.
class Dtk_mesh:public Dtk_Entity
{
     private:
          friend class Dtk_SmartPtr<Dtk_mesh>;
     protected:
          enum {
               _typeID = DTK_TYPE_MESH
          };        
          int                            id;
        Dtk_bool                       back_face_culling;
          Dtk_bool                         HasTextureValues; 
        int                            vertex_format;
#ifdef NOCOMPRESSEDVERTICES
          Dtk_tab<Dtk_mesh_vertex *>     vertices;      // hide, and hide subclasses.
#else
          Dtk_tab<Dtk_UChar8> cvertices;
          Dtk_Size_t sizeonevertex,ofsVTX,ofsNRM,ofsRGB,ofsUV,ofsUVBrep;
          void C_GetVertex(Dtk_Size_t i,Dtk_pnt& out) const;
          void C_GetNormal(Dtk_Size_t i,Dtk_dir& out) const;
          void C_GetRGB(Dtk_Size_t i,Dtk_RGB& out) const;
          Dtk_Float32 C_GetU(Dtk_Size_t i) const;
          Dtk_Float32 C_GetV(Dtk_Size_t i) const;
          Dtk_Float32 C_GetUBrep(Dtk_Size_t i) const;
          Dtk_Float32 C_GetVBrep(Dtk_Size_t i) const;
          void C_SetVertex(Dtk_Size_t i,const Dtk_pnt& out);
          void C_SetNormal(Dtk_Size_t i,const Dtk_dir& out);
          void C_SetRGB(Dtk_Size_t i,const Dtk_RGB& out);
          void C_SetUV(Dtk_Size_t i,Dtk_Float32 u,Dtk_Float32 v);
          void C_SetUVBrep(Dtk_Size_t i,Dtk_Float32 u,Dtk_Float32 v);
          void C_ComputeOffsets();
#endif
          Dtk_StreamPtr _stream;
        Dtk_tab<Dtk_mesh_face *>       submeshes; 
        friend class Dtk_mesh_face;
        Dtk_bool check_params(const Dtk_pnt * inVertex, const Dtk_dir * inNormal, const Dtk_RGB * inColor, Dtk_Float32 inU, Dtk_Float32 inV);
        Dtk_bool check_params(const Dtk_tab<Dtk_pnt> * inVertices, const Dtk_tab<Dtk_dir> * inNormals, const Dtk_tab<Dtk_RGB> * inColors, const Dtk_tab<Dtk_Float32> * inU, const Dtk_tab<Dtk_Float32> * inV);
          void clean_up();
        inline virtual Dtk_Object* Clone() { return new Dtk_mesh(*this); }
public:
        Dtk_mesh(int inVertex_format = DTK_MESH_XYZ, Dtk_bool inBack_face_culling = true);
        Dtk_mesh(const Dtk_mesh &inMesh);
        Dtk_mesh( Dtk_mesh && inMesh) DTK_NOEXCEPT;
          Dtk_mesh& operator=(const Dtk_mesh &inMesh);
          Dtk_mesh& operator=( Dtk_mesh &&inMesh) DTK_NOEXCEPT;
        ~Dtk_mesh();
    
     public:
          //! \DtkDynamicType
          Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
          //! \DtkDynamicCast
          static Dtk_mesh* DtkDynamicCast(Dtk_Object *s);
 
          //! \brief Constructor
          //! \param inVertex_format : the chosen vertex format you will work with
          //! \param inBack_face_culling : culling mode
          //!
          //! \b Vertex \b formats \b available: \n
          //!
          //!    -    \b DTK_MESH_XYZ                    : each point has xyz coords\n
          //!    -    \b DTK_MESH_NORMAL                 : each point has a normal\n
          //!    -    \b DTK_MESH_RGB                    : each point has a color\n
          //!    -    \b DTK_MESH_UVTEXTURES             : each point has UV texture coords\n
          //!    -    \b DTK_MESH_UVBBREP                : each point has UVbrep match coords\n
          //!    -    \b DTK_MESH_DOUBLEPRECISION        : each point has xyz coords as double\n
          //!\n
          //!\b For \b example : DTK_MESH_XYZ | DTK_MESH_NORMAL | DTK_MESH_UVTEXTURES : to have coords,normals, and uv textures
          //!\n
          //void dump_vertices();
          static Dtk_MeshPtr Create(int inVertex_format = DTK_MESH_XYZ, Dtk_bool inBack_face_culling = true);
 
          //! \CreateCopy{in}
          static Dtk_MeshPtr Create(const Dtk_mesh & in);
 
        //! \brief Checks The current vertex format of the Dtk_mesh object
        //! \param inFormat : vertex format to test with
        //! \return true if the format includes inFormat parameters, else false
        Dtk_bool check_format(int inFormat);
 
        //! \brief Compute round normals from geometry
        //! \warning Can alter vertex_format
        //! \return return 0 if ok 
        int compute_round_normals();
 
        //! \brief Compute the mesh Bounding Box
        //! \param[out] min, max : computed extrem points of the boundig box
        //! \return return 0 if ok
        int compute_bb(Dtk_pnt * min, Dtk_pnt * max);
 
        //! \brief Compute the mesh Bounding Box
        //! \param[out] min, max : computed extrem points of the boundig box
        //! \return return 0 if ok
        int compute_bb_center(Dtk_pnt * i);
 
          //! \brief Decompose all complex geometry (triangle strips, fan, polygons) into triangles, and append it into the internal triangle array
          //! \brief Note that mockup decomposition is not yet supported.
          //! \return return 0 if ok
          int explode();
 
          //! \brief Decompose complex geometry (triangle strips, fan, polygons) according to specified parameters into triangles, and append it into the internal triangle array
          //! \brief Note that mockup decomposition is not yet supported.
          //! \return return 0 if ok
          int explode(Dtk_bool ExplodeTristrips, Dtk_bool ExplodeTrifans, Dtk_bool ExplodePolygons, Dtk_bool ExplodeMockups);
 
          //! \brief Assemble all simple triangle, try to make triange-strips
          //! \return return 0 if ok
          int makestrips();
 
          //! \brief Change Vertex format, check constructor comment to see options
          //! \param[in] inVertex_format : the chosen vertex format you will work with
          //! \return return 0 if ok
          int change_vertex_format(int inVertex_format);
 
          //! \brief Apply a transformation matrix to the Mesh
          //! \param[in] inMatrix : Matrix to apply
          //! \return return 0 if ok
          int transform(Dtk_transfo * inMatrix);
 
          //! \brief Make a copy of the current mesh, applying a transformation on it.
          //! \param[in] inMatrix : Matrix to apply
          //! \return The copy mesh, NULL if error.
        Dtk_mesh * transform2Cpy(Dtk_transfo * inMatrix);
 
        //! \brief Return the true of false if culled or not
          //! \return True or false.
        Dtk_bool is_backface_culled();
        int to_stl(Dtk_string inFilename,Dtk_bool inIsAciiMode=DTK_FALSE);
 
        //! \brief Return true if the current vertex format includes 3D coords (XYZ)
        Dtk_bool has_xyz();
        //! \brief Return true if the current vertex format includes normal
        Dtk_bool has_normals();
        //! \brief Return true if the current vertex format includes color (RGB)
        Dtk_bool has_colors();
        //! \brief Return true if the current vertex format includes texture coords (UVTEXTURES)
        Dtk_bool has_texcoords();
 
        //! \brief Add a vertex to the mesh vertices list
        //! \param inVertex : vertex to add
        //! \param inNormal : normal to add (if vertex format includes normal)
        //! \param inColor : color to add (if vertex format includes color)
        //! \param inU, inV : texture coords (if vertex format includes tex coords)
        //! \return return 0 if ok, 1 if error, 2 if wrong vertex format
        int add_vertex(const Dtk_pnt * inVertex,const  Dtk_dir * inNormal = NULL,const  Dtk_RGB * inColor = NULL, Dtk_Float32 inU = 0., Dtk_Float32 inV = 0., Dtk_Float32 inUBrep = 0., Dtk_Float32 inVBrep = 0.);    
        
          int reserve_vertex(Dtk_Size_t nb);
        //! \brief Add a face (Dtk_mesh_face) to the mesh
        //! \param in_mesh_face : face to add
        //! \return return 0 if ok, 1 if error
        int add_mesh_face(Dtk_mesh_face * inMesh_face);
 
        //! \brief Set a vertex 
        //! \param inPos : indice in the vertices array
        //! \param inVertex : vertex to set
        //! \param inNormal : normal to set (if vertex format includes normal)
        //! \param inColor : color to set (if vertex format includes color)
        //! \param inU, inV : texture coords (if vertex format includes tex coord)
        //! \return return 0 if ok, 1 if error, 2 if wrong vertex format
        int set_vertex(Dtk_Size_t inPos, const Dtk_pnt * inVertex, const Dtk_dir * inNormal = NULL, const Dtk_RGB * inColor = NULL, Dtk_Float32 inU = 0., Dtk_Float32 inV = 0., Dtk_Float32 inUBrep = 0., Dtk_Float32 inVBrep = 0.);
 
        //! \brief Set a normal to a point (if vertex format includes normal)
        //! \param inPos : indice in the vertices array
        //! \param inNormal : normal to set
        //! \return return 0 if ok, 1 if error, 2 if wrong vertex format
        int set_normal(Dtk_Size_t inPos, const Dtk_dir * inNormal);
 
        //! \brief Set a color to a point (if vertex format includes color)
        //! \param inPos : indice in the vertices array
        //! \param inColor : color to set
        //! \return return 0 if ok, 1 if error, 2 if wrong vertex format
        int set_color(Dtk_Size_t inPos, const Dtk_RGB * inColor);
 
        //! \brief Set texture coords to a point (if vertex format includes tex coords)
        //! \param inPos : indice in the vertices array
        //! \param inU, inV : U,V to set
        //! \return return 0 if ok, 1 if error, 2 if wrong vertex format
        int set_texcoords(Dtk_Size_t inPos, Dtk_Float32 inU, Dtk_Float32 inV);
 
          //! \brief Return texture coords (if vertex format includes tex coords)
          //! \param inPos : indice in the vertices array
          //! \param[out] outU, outV : UVtextures returned
          //! \return return 0 if ok, 1 if error, 2 if wrong vertex format
          int get_texcoords(Dtk_Size_t inPos, Dtk_Float32 * outU, Dtk_Float32 * outV);
 
        //! \brief Return the vertices array size
        Dtk_Size_t get_nb_vertices() const;
 
        //! \brief Return a vertex
        //! \param inPos : indice in the vertices array
        //! \param[out] outVertex : vertex returned
        //! \return return 0 if ok, 1 if error, 2 if wrong vertex format
        int get_vertex(Dtk_Size_t inPos, Dtk_pnt * outVertex);
        
          //! \brief Return a vertex (2nd form of get_vertex)
          //! \param inPos : indice in the vertices array
          //! \return The vertex
          Dtk_pnt get_vertex(Dtk_Size_t inPos);
 
        //! \brief Return a normal (if vertex format includes normal)
          //! \brief Note, if vertex format does not support normal, the fonction will return a null vector
        //! \param inPos : indice in the vertices array
        //! \param[out]: outNormal : vertex returned
        //! \param[in]: inMeshFace : current mesh face
        //! \return return 0 if ok, 1 if error, 2 if wrong vertex format
        int get_normal(Dtk_Size_t inPos, Dtk_dir * outNormal,Dtk_mesh_face * inMeshFace = NULL);
 
          //! \brief Return a vertex (2nd form of get_normal)
          //! \brief Note, if vertex format does not support normal, the fonction will return a null vector
          //! \param inPos : indice in the vertices array
          //! \return The normal
          Dtk_dir get_normal(Dtk_Size_t inPos);
 
 
          Dtk_Float32 GetUTexture(Dtk_Size_t inPos) const;
          Dtk_Float32 GetVTexture(Dtk_Size_t inPos) const;
 
          Dtk_Float32 GetUBrep(Dtk_Size_t inPos) const;
          Dtk_Float32 GetVBrep(Dtk_Size_t inPos) const;
 
        //! \brief Return a color (if vertex format includes color)
        //! \param inPos : indice in the vertices array
        //! \param[out] outColor : color returned
        //! \return return 0 if ok, 1 if error, 2 if wrong vertex format
        int get_color(Dtk_Size_t inPos, Dtk_RGB * outColor);    
        
        //! \brief Return the faces array size
        Dtk_Size_t get_nb_mesh_face() const;
 
        //! \brief Return a face
        //! \param inPos : indice in the faces array
        Dtk_mesh_face* get_mesh_face(Dtk_Size_t inPos);
 
          //! \brief Return the array of mesh faces
          Dtk_tab<Dtk_mesh_face *> & get_mesh_faces();
          Dtk_tab<Dtk_mesh_face *> const & get_mesh_faces() const;
 
        //! \brief Return total number of facets
        Dtk_Size_t get_nb_facets();
        
          //! \brief Set an id to the mesh 
          //! \param inId : id to set
          void set_id(int inId);
 
          //! \brief Return the mesh id
        int get_id();
 
        //! \brief set color in Dtk_mesh
        void set_mesh_color(const Dtk_RGB & inColor);
        
        //! \brief get color in Dtk_mesh
        Dtk_RGB get_mesh_color();
 
          //! \brief Return DtkInfosPtr of this Dtk_Mesh may be NULL
        const Dtk_InfoPtr& get_Infos();
 
          //! \brief Set DtkInfosPtr of this Dtk_Mesh
        void set_Infos(const Dtk_InfoPtr& inDtkInfosPtr);
 
          //! \brief Set the material of the mesh
        void set_material(Dtk_MaterialPtr inMat);
 
          //! \brief Get the material of the mesh
        Dtk_MaterialPtr get_material();
 
          //! \brief Perform a scale of the model
          //! \brief Note : calling this function has the same effect than calling "transform" method with a scale matrix.
        int rescale_model(float ratio);
 
          //! \brief Reduce memory cost of the Dtk_mesh, to call after adding all geometry
          //! \brief The Dtk_mesh class hold internal containers that keep more memory not to reallocate each data enqueuing (like reserve of a std::vector)
          //! \brief This function remove all reserves to free some useless memory
          void reduce();
 
          //! \brief Merge another Dtk_mesh.
        //! \param inMesh : mesh to merge.
          void merge(const Dtk_mesh* inMesh);
          void merge(const Dtk_SmartPtr<Dtk_mesh>& inMesh);
 
          void mergemove( Dtk_tab<Dtk_MeshPtr>& inArraymesh );
          void mergemove( Dtk_SmartPtr<Dtk_mesh>& inmesh );
          void mergemove( Dtk_mesh* inmesh );
          void reserve_submesh( Dtk_Size_t nb );
 
 
          //! \brief Merge subfaces that have the same properties
          void reducesubfaces();
 
          //! \brief Get a reference to the mesh face array   // DEPRECATED, UNSAFE.
          Dtk_tab<Dtk_mesh_face *>& get_mesh_face_array();
 
          enum type_detk get_type_detk() const;
          Dtk_ErrorStatus Transform(const Dtk_transfo&);
 
          Dtk_Size_t GetSize() const;
 
        //! \brief Apply texture mapping to the mesh. It will modify points texture UV coordinates.
        Dtk_bool apply_render_infos(Dtk_RenderInfosPtr);
 
 
        Dtk_ErrorStatus Store(FILE* inFile, Dtk_Size_t inIo = 1);
        Dtk_ErrorStatus Store(const Dtk_string& inFile, Dtk_Size_t inIo = 1);
          void SetStream(Dtk_StreamPtr inStream);
          Dtk_StreamPtr GetStream() const;
};
 
/* Class mesh_vertex : vertex data */
 
//! \class Dtk_mesh_vertex
//! \brief For internal use.
//!
//!    This class gathers all the datas related to a vertex.
class Dtk_mesh_vertex
{
protected:
     Dtk_Float32 vertex[3];
public:
     Dtk_mesh_vertex();
     Dtk_mesh_vertex(const Dtk_pnt * inVertex);
     virtual ~Dtk_mesh_vertex();
     virtual Dtk_pnt GetVertex() const;
     virtual Dtk_dir GetNormal() const;
     virtual Dtk_RGB GetRGB() const;
     virtual Dtk_Float32 GetU() const;
     virtual Dtk_Float32 GetV() const;
     virtual Dtk_Int32 SetVertex(const Dtk_pnt&);
     virtual Dtk_Int32 SetNormal(const Dtk_dir&);
     virtual Dtk_Int32 SetRGB(const Dtk_RGB&);
     virtual Dtk_Int32 SetU(Dtk_Float32);
     virtual Dtk_Int32 SetV(Dtk_Float32);
     virtual Dtk_Int32 transform(Dtk_transfo&);
     virtual Dtk_Size_t GetSize() const ;
};
 
class Dtk_mesh_vertex_norm:public Dtk_mesh_vertex
{
protected:
     Dtk_Float32 normal[3];
public:
     Dtk_mesh_vertex_norm();
     Dtk_mesh_vertex_norm(const Dtk_pnt * inVertex,const Dtk_dir * inNorm);
     Dtk_dir GetNormal() const;
     Dtk_Int32 SetNormal(const Dtk_dir&);
     Dtk_Int32 transform(Dtk_transfo&);
      Dtk_Size_t GetSize() const ;
};
 
class Dtk_mesh_vertex_norm_color:public Dtk_mesh_vertex_norm
{
protected:
     Dtk_RGB color;
public:
     Dtk_mesh_vertex_norm_color();
     Dtk_mesh_vertex_norm_color(const Dtk_pnt * inVertex,const Dtk_dir * inNorm,const Dtk_RGB* inRGB);
     Dtk_RGB GetRGB() const;
     Dtk_Int32 SetRGB(const Dtk_RGB&);
      Dtk_Size_t GetSize() const ;
};
 
class Dtk_mesh_vertex_norm_color_uv:public Dtk_mesh_vertex_norm_color
{
protected:
     Dtk_Float32 u,v;
public:
     Dtk_mesh_vertex_norm_color_uv();
     Dtk_mesh_vertex_norm_color_uv(const Dtk_pnt * inVertex,const Dtk_dir * inNorm,const Dtk_RGB* inRGB,Dtk_Float32 inU,Dtk_Float32 inV);
     Dtk_Float32 GetU() const;
     Dtk_Float32 GetV() const;
     Dtk_Int32 SetU(Dtk_Float32);
     Dtk_Int32 SetV(Dtk_Float32);
      Dtk_Size_t GetSize() const ;
};
 
 
/* --------------------------------------------- */
 
enum DTK_MESH_TYPE_FACE { DTK_MESH_UNKNOWN_TYPE_FACE, DTK_MESH_CYLINDER, DTK_MESH_PLANE, DTK_MESH_OTHERSRF };
class Dtk_mesh_circle_data;
 
//! \class Dtk_mesh_face
//! \brief This is a high level face class.
//!
//!    This class gathers all the datas related to a triangulated mesh face.
class Dtk_mesh_face:public Dtk_Object
{
private:
     friend class Dtk_SmartPtr<Dtk_mesh_face>;
protected:
     enum {
          _typeID = DTK_TYPE_MESH_FACE
     };        
     Dtk_mesh * mesh;
// all types
     Dtk_tab<Dtk_UInt32> triangles;
    Dtk_tab<Dtk_tab<Dtk_UInt32> > polygons;
     Dtk_tab<Dtk_tab<Dtk_UInt32> > tristrips;
     Dtk_tab<Dtk_tab<Dtk_UInt32> > trifans;
     Dtk_tab<Dtk_tab<Dtk_tab<Dtk_UInt32> > > mockup;
     Dtk_tab<Dtk_tab<Dtk_UInt32> > polylines;
     Dtk_tab<Dtk_UInt32> points;
     Dtk_tab<Dtk_InfoPtr> subinfos;
// additionnal
    Dtk_InfoPtr _infos;
     Dtk_mesh_face( const Dtk_mesh_face & );
     Dtk_mesh_face( Dtk_mesh_face&& ) DTK_NOEXCEPT;
     friend class Dtk_mesh;
private:
     int explode_tristrips(Dtk_tab<Dtk_UInt32>* ret);
     int explode_trifans(Dtk_tab<Dtk_UInt32>* ret);
     int explode_polygons(Dtk_tab<Dtk_UInt32>* ret);
     int explode_mockups(Dtk_tab<Dtk_UInt32>* ret);
     int add_shapevertices(const Dtk_tab<Dtk_pnt> * inVertices,const  Dtk_tab<Dtk_dir> * inNormals,const  Dtk_tab<Dtk_RGB> * inColors,const  Dtk_tab<Dtk_Float32> * inU, const Dtk_tab<Dtk_Float32> * inV);
 
     int _finddoublonstriangles();
public:
    //! \brief Constructor
    //! \param inMesh : the mesh which will contain the face
    Dtk_mesh_face(Dtk_mesh * inMesh);
 
     //! \brief Copy Constructor
     //! \brief Do not use param shift.
     Dtk_mesh_face(const Dtk_mesh_face& inMeshface,Dtk_mesh* inMesh,Dtk_UInt32 shift=0);
     
    //! \brief Destructor
    ~Dtk_mesh_face();
 
public:
     //! \DtkDynamicType
     Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId);
 
     //! \DtkDynamicCast
     static Dtk_mesh_face* DtkDynamicCast(Dtk_Object *s);
 
     //! \CreateCopy{in}
     static Dtk_mesh_facePtr Create(const Dtk_mesh_face &in);
 
    //! \brief Compute round normals from geometry
    //! \warning Can alter vertex_format
    //! \return return 0 if ok, 1 if error
    int compute_round_normals();
 
    //! \brief Compute the mesh Bounding Box
    //! \param[out] min, max : computed extrem points of the boundig box
    //! \return return 0 if ok
    int compute_bb(Dtk_pnt * min, Dtk_pnt * max);
 
    //! \brief Compute the mesh Bounding Box
    //! \param[out] in : computed center point of the boundig box
    //! \return return 0 if ok
    int compute_bb_center(Dtk_pnt * i);
 
     //! \brief Decompose all complex geometry (triangle strips, fan, polygons) into triangles, and append it into the internal triangle array
     //! \brief Note that mockup decomposition is not yet supported.
     //! \return return 0 if ok
     int explode();
 
     //! \brief Decompose complex geometry (triangle strips, fan, polygons) according to specified parameters into triangles, and append it into the internal triangle array
     //! \brief Note that mockup decomposition is not yet supported.
     //! \return return 0 if ok
     int explode(Dtk_bool ExplodeTristrips, Dtk_bool ExplodeTrifans, Dtk_bool ExplodePolygons, Dtk_bool ExplodeMockups);
 
     int makestrips();
 
    //! \brief Compute all facets (triangles) holded by the class, including trianglestrips, fans, polygons
     //! \return Number of facets
     Dtk_Size_t get_nb_facets();
 
     //! \brief Compute the total number of vertices used in the face
     //! \param[in] inOnce (default = true) : Imagine a case we have 2 adjascent triangles, with 2 common vertices. If inOnce = true, return 4, if false, return 6.
     //! \return return an array of indices.
     Dtk_Size_t get_nb_vertices(int inOnce=1);
 
     Dtk_mesh* get_mesh();
 
 
// triangles
 
     //! \brief Add one of multiple triangles
     //! \brief On this form, indices MUST match an existing vertex inside Dtk_Mesh class
     //! \param[in] inIndices : Array of indices. Must be a multiple of 3. This will add arraysize/3 triangles
     //! \return return 0 if ok, other value if fails.
     int add_triangles(Dtk_tab<Dtk_UInt32> * inIndices);
     int add_triangles(const Dtk_UInt32* inIndices,Dtk_Size_t nb);
 
     //! \brief Add one of multiple triangles and the corresponding vertices
     //! \param[in] inIndices : Array of indices. Must be a multiple of 3. This will add arraysize/3 triangles.
     //! \param[in] inVertices : Array of vertices. They will be added into the mesh. inIndices values are indices of this table
     //! \param[in] inNormals : Array of normals (or NULL is not specified). If specified, size must be the same than inVertices.
     //! \param[in] inColors : Array of RGBcolors (or NULL is not specified). If specified, size must be the same than inVertices.
     //! \param[in] inU : Array of u params (or NULL is not specified). If specified, size must be the same than inVertices.
     //! \param[in] inV : Array of v params (or NULL is not specified). If specified, size must be the same than inVertices.
     //! \return return 0 if ok, other value if fails.
     int add_triangles(const Dtk_tab<Dtk_UInt32> * inIndices,const Dtk_tab<Dtk_pnt> * inVertices,const  Dtk_tab<Dtk_dir> * inNormals = NULL,const  Dtk_tab<Dtk_RGB> * inColors = NULL,const  Dtk_tab<Dtk_Float32> * inU = NULL,const  Dtk_tab<Dtk_Float32> * inV = NULL);
     
     //! \brief Get the number of simple triangles kept in the class instance
     //! \return return Number of triangles
     Dtk_Size_t get_nbtriangles() const;
 
     //! \brief Get pointer of triangle indices of i-th triangle.
     //! \param[in] inI : triangle to get (use get_nbtriangles to see how many triangles there is)
     //! \brief Use the result as an array (check example below)
     //! \b Sample:
     //! \code 
     //! const Dtk_UInt32* t = get_triangle_indices(5);   // get the 5th triangle indices
     //! printf("indices are : %d %d %d\n",t[0],t[1],t[2]);
     //! \endcode
     //! \return return Number of triangles
     const Dtk_UInt32* get_triangle_indices(Dtk_Size_t inI) const;
 
     //! \brief Get the V-th vertex of the inI-th triangle.
     //! \param[in] inI : triangle to get (use get_nbtriangles to see how many triangles there is)
     //! \param[in] inV : Vertex to get (0, 1 or 2)
     //! \return The vertex.
     Dtk_pnt get_triangle_vertex(Dtk_Size_t inI,Dtk_Size_t inV) const;
 
     //! \brief Get the center normal of the inI-th triangle.
     //! \param[in] inI : triangle to get (use get_nbtriangles to see how many triangles there is)
     //! \return the normal of the triangle .
     Dtk_dir get_triangle_normal(Dtk_Size_t inI) const;
 
     //! \brief Reverse the i-th triangle of the set of triangle, so that the normal will be inversed.
     //! \param[in] inI : triangle to reverse (use get_nbtriangles to see how many triangles there is)
     void reverse_triangle(Dtk_Size_t inI);
 
// trianglestrip
     //! \brief Add one triangle strip
     //! \brief On this form, indices MUST match an existing vertex inside Dtk_Mesh class
     //! \param[in] inIndices : Array of indices. Must be a at least 3.
     //! \return return 0 if ok, other value if fails.
     int add_triangle_strip(const Dtk_tab<Dtk_UInt32> * inIndices);
 
     int reserve_triangle_strip(Dtk_Size_t nb);
 
     //! \brief Add one triangle strip and the corresponding vertices
     //! \param[in] inIndices : Array of indices. Must be at least 3.
     //! \param[in] inVertices : Array of vertices. They will be added into the mesh. inIndices values are indices of this table
     //! \param[in] inNormals : Array of normals (or NULL is not specified). If specified, size must be the same than inVertices.
     //! \param[in] inColors : Array of RGBcolors (or NULL is not specified). If specified, size must be the same than inVertices.
     //! \param[in] inU : Array of u params (or NULL is not specified). If specified, size must be the same than inVertices.
     //! \param[in] inV : Array of v params (or NULL is not specified). If specified, size must be the same than inVertices.
     //! \return return 0 if ok, other value if fails.
     int add_triangle_strip(const Dtk_tab<Dtk_UInt32> * inIndices,const Dtk_tab<Dtk_pnt> * inVertices,const Dtk_tab<Dtk_dir> * inNormals = NULL,const  Dtk_tab<Dtk_RGB> * inColors = NULL,const  Dtk_tab<Dtk_Float32> * inU = NULL,const  Dtk_tab<Dtk_Float32> * inV = NULL);
 
     //! \brief Get the number of triangle strips kept in the class instance
     //! \return return Number of triangle strips
     Dtk_Size_t get_nbtriangle_strips() const;
 
     //! \brief Get inI-th triangle strip
     //! \param[in] inI : indice of the triangle strip to get.
     //! \return return an array of indices.
     const Dtk_tab<Dtk_UInt32>* get_triangle_strip_indices(Dtk_Size_t inI) const;
 
// trianglefan
     //! \brief Add one triangle fan
     //! \brief On this form, indices MUST match an existing vertex inside Dtk_Mesh class
     //! \param[in] inIndices : Array of indices. Must be a at least 3.
     //! \return return 0 if ok, other value if fails.
     int add_triangle_fan(const Dtk_tab<Dtk_UInt32> * inIndices);
 
     //! \brief Add one triangle fan and the corresponding vertices
     //! \param[in] inIndices : Array of indices. Must be at least 3.
     //! \param[in] inVertices : Array of vertices. They will be added into the mesh. inIndices values are indices of this table
     //! \param[in] inNormals : Array of normals (or NULL is not specified). If specified, size must be the same than inVertices.
     //! \param[in] inColors : Array of RGBcolors (or NULL is not specified). If specified, size must be the same than inVertices.
     //! \param[in] inU : Array of u params (or NULL is not specified). If specified, size must be the same than inVertices.
     //! \param[in] inV : Array of v params (or NULL is not specified). If specified, size must be the same than inVertices.
     //! \return return 0 if ok, other value if fails.
     int add_triangle_fan(const Dtk_tab<Dtk_UInt32> * inIndices,const  Dtk_tab<Dtk_pnt> * inVertices,const  Dtk_tab<Dtk_dir> * inNormals = NULL,const  Dtk_tab<Dtk_RGB> * inColors = NULL,const  Dtk_tab<Dtk_Float32> * inU = NULL,const  Dtk_tab<Dtk_Float32> * inV = NULL);
 
     //! \brief Get the number of triangle fans kept in the class instance
     //! \param[in] inI : indice of the triangle fan to get.
     //! \return return Number of triangle fans
     Dtk_Size_t get_nbtriangle_fans() const;
 
     //! \brief Get inI-th triangle fan
     //! \return return an array of indices.
     const Dtk_tab<Dtk_UInt32>* get_triangle_fan_indices(Dtk_Size_t inI) const;
 
// polygons
     //! \brief Add one polygon
     //! \brief poygon MUST be convex
     //! \brief On this form, indices MUST match an existing vertex inside Dtk_Mesh class
     //! \param[in] inIndices : Array of indices. Must be a at least 3.
     //! \return return 0 if ok, other value if fails.
     int add_polygon(const Dtk_tab<Dtk_UInt32> * inIndices);
 
     //! \brief Add one polygon and the corresponding vertices
     //! \brief poygon MUST be convex
     //! \param[in] inIndices : Array of indices. Must be at least 3.
     //! \param[in] inVertices : Array of vertices. They will be added into the mesh. inIndices values are indices of this table
     //! \param[in] inNormals : Array of normals (or NULL is not specified). If specified, size must be the same than inVertices.
     //! \param[in] inColors : Array of RGBcolors (or NULL is not specified). If specified, size must be the same than inVertices.
     //! \param[in] inU : Array of u params (or NULL is not specified). If specified, size must be the same than inVertices.
     //! \param[in] inV : Array of v params (or NULL is not specified). If specified, size must be the same than inVertices.
     //! \return return 0 if ok, other value if fails.
     int add_polygon(const Dtk_tab<Dtk_UInt32> * inIndices,const  Dtk_tab<Dtk_pnt> * inVertices,const  Dtk_tab<Dtk_dir> * inNormals = NULL,const  Dtk_tab<Dtk_RGB> * inColors = NULL,const  Dtk_tab<Dtk_Float32> * inU = NULL,const  Dtk_tab<Dtk_Float32> * inV = NULL);
 
     //! \brief Get the number of polygons kept in the class instance
     //! \return return Number of polygons
     Dtk_Size_t get_nbpolygons() const;
 
     //! \brief Get inI-th polygon
     //! \param[in] inI : indice of the polygon to get.
     //! \return return an array of indices.
     const Dtk_tab<Dtk_UInt32>* get_polygon_indices(Dtk_Size_t inI) const;
 
 
     Dtk_dir get_polygon_normal(Dtk_Size_t inI) const;
 
// mockups
     //! \brief Add one mockup
     //! \brief On this form, indices MUST match an existing vertex inside Dtk_Mesh class
     //! \param[in] inIndices : Array of Array of indices (ie : Array of polygons). The first polygon is the outer limit of the mockups, the others are inner loops
     //! \brief Note : Polygons MUST be convex
     //! \brief Note : Face is ALWAYS on the left of polygon. It means that for outer polygon, the sens is counterclockwise, for the other, sense is clockwise
     //! \return return 0 if ok, other value if fails.
     int add_mockup(const Dtk_tab<Dtk_tab<Dtk_UInt32> > * inIndices);
 
     //! \brief Add one polygon and the corresponding vertices
     //! \brief poygon MUST be convex
     //! \param[in] inIndices : Array of Array of indices (ie : Array of polygons). The first polygon is the outer limit of the mockups, the others are inner loops
     //! \brief Note : Polygons MUST be convex
     //! \brief Note : Face is ALWAYS on the left of polygon. It means that for outer polygon, the sens is counterclockwise, for the other, sense is clockwise
     //! \param[in] inVertices : Array of vertices. They will be added into the mesh. inIndices values are indices of this table
     //! \param[in] inNormals : Array of normals (or NULL is not specified). If specified, size must be the same than inVertices.
     //! \param[in] inColors : Array of RGBcolors (or NULL is not specified). If specified, size must be the same than inVertices.
     //! \param[in] inU : Array of u params (or NULL is not specified). If specified, size must be the same than inVertices.
     //! \param[in] inV : Array of v params (or NULL is not specified). If specified, size must be the same than inVertices.
     //! \return return 0 if ok, other value if fails.
     int add_mockup(const Dtk_tab<Dtk_tab<Dtk_UInt32> > * inIndices, const Dtk_tab<Dtk_pnt> * inVertices, const Dtk_tab<Dtk_dir> * inNormals = NULL, const Dtk_tab<Dtk_RGB> * inColors = NULL, const Dtk_tab<Dtk_Float32> * inU = NULL, const Dtk_tab<Dtk_Float32> * inV = NULL);
 
     int add_mockups(const Dtk_tab<Dtk_tab<Dtk_tab<Dtk_UInt32> > >* inIndices, const Dtk_tab<Dtk_pnt> * inVertices, const Dtk_tab<Dtk_dir> * inNormals = NULL, const Dtk_tab<Dtk_RGB> * inColors = NULL, const Dtk_tab<Dtk_Float32> * inU =NULL , const Dtk_tab<Dtk_Float32> * inV = NULL);
 
     //! \brief Get the number of mockups kept in the class instance
     //! \return return Number of mockups
     Dtk_Size_t get_nbmockups() const;
 
     //! \brief Get inI-th mockup
     //! \return return an array of indices.
     const Dtk_tab<Dtk_tab<Dtk_UInt32> >* get_mockup_indices(Dtk_Size_t inI) const;
 
     Dtk_dir get_mockup_normal(Dtk_Size_t inI) const;
 
// polylines
 
     //! \brief Add one polyline
     //! \brief On this form, indices MUST match an existing vertex inside Dtk_Mesh class
     //! \param[in] inIndices : Array of indices. Must be a at least 3.
     //! \return return 0 if ok, other value if fails.
     int add_polyline(const Dtk_tab<Dtk_UInt32> * inIndices);
 
     //! \brief Add one polyline and the corresponding vertices
     //! \param[in] inIndices : Array of indices. Must be at least 2.
     //! \param[in] inVertices : Array of vertices. They will be added into the mesh. inIndices values are indices of this table
     //! \param[in] inNormals : Array of normals (or NULL is not specified). If specified, size must be the same than inVertices.
     //! \param[in] inColors : Array of RGBcolors (or NULL is not specified). If specified, size must be the same than inVertices.
     //! \param[in] inU : Array of u params (or NULL is not specified). If specified, size must be the same than inVertices.
     //! \param[in] inV : Array of v params (or NULL is not specified). If specified, size must be the same than inVertices.
     //! \return return 0 if ok, other value if fails.
     int add_polyline(const Dtk_tab<Dtk_UInt32> * inIndices,const  Dtk_tab<Dtk_pnt> * inVertices,const  Dtk_tab<Dtk_dir> * inNormals = NULL,const  Dtk_tab<Dtk_RGB> * inColors = NULL,const  Dtk_tab<Dtk_Float32> * inU = NULL,const  Dtk_tab<Dtk_Float32> * inV = NULL);
 
     void reserve_polylines(Dtk_Size_t nb);
     //! \brief Get the number of polylines kept in the class instance
     //! \return return Number of polylines
     Dtk_Size_t get_nbpolylines() const;
 
     //! \brief Get inI-th polygon
     //! \param[in] inI : indice of the polygon to get.
     //! \return return an array of indices.
     const Dtk_tab<Dtk_UInt32>* get_polyline_indices(Dtk_Size_t inI) const;
 
// points
 
     int add_point(Dtk_UInt32 inpnt);
     int add_points(const Dtk_tab<Dtk_UInt32> * pnts);
     int add_points(const Dtk_tab<Dtk_UInt32> * inIndices,const  Dtk_tab<Dtk_pnt> * inVertices,const  Dtk_tab<Dtk_dir> * inNormals = NULL,const  Dtk_tab<Dtk_RGB> * inColors = NULL,const  Dtk_tab<Dtk_Float32> * inU = NULL,const  Dtk_tab<Dtk_Float32> * inV = NULL);
     Dtk_Size_t get_nbpoints() const;
     Dtk_UInt32 get_point_indice(Dtk_Size_t inI) const;
 
 
// subinfos
 
     int add_subinfo(Dtk_InfoPtr& ininf);
     Dtk_Size_t get_nbsubinfos() const;
     Dtk_InfoPtr& get_subinfo(Dtk_Size_t inI);
     const Dtk_InfoPtr& get_subinfo(Dtk_Size_t inI) const;
 
     //! \brief Reduce memory cost of the Dtk_mesh, to call after adding all geometry
     //! \brief The Dtk_mesh class hold internal containers that keep more memory not to reallocate each data enqueuing (like reserve of a std::vector)
     //! \brief This function remove all reserves to free some useless memory
     void reduce();
 
   //! \brief Merge a face into the current face
     //! \param[in] inMeshface : Mesh face to append to the current face.
   void merge(Dtk_mesh_face* inMeshface);
 
// additionnal infos
     //! \brief acces to class info of mesh_face
   Dtk_InfoPtr& info();
   //! \brief acces to class info of mesh_face
   const Dtk_InfoPtr& info() const;
 
     //! \brief Set an Id to the face
     //! \param inId : set an Id to the face
     void set_id(int inId);
     //! \brief Return the face Id
     int get_id() const;
 
     //! \brief Set a color to the face. Sometimes, one needs to set a color to a face, not the vertices.
     //! \param inColor : RGB color
     void set_face_color(const Dtk_RGB& inColor);
     //! \brief Return the RGB face color
     Dtk_RGB get_face_color() const;
 
     //! \brief Return the RGB face color (indice)
     int get_face_icolor() const;
     //! \brief Set a color to the face (indexed). Sometimes, one needs to set a color to a face, not the vertices.
     //! \param inColor : indice of a RGB color
     void set_face_icolor(int inColor);
 
     //! \brief Return the current face type
     DTK_MESH_TYPE_FACE get_face_type() const;
     //! \brief Set a face type
     //! \param inType : face type. Can be DTK_MESH_CYLINDER, DTK_MESH_PLANE or DTK_MESH_OTHERSRF
     void set_face_type(DTK_MESH_TYPE_FACE inType);
 
     //! \brief Return the mesh_circle_data of the current face. If it doesn't exist, NULL is returned.
     Dtk_mesh_circle_data get_mesh_circle_data() const;
     //! \brief Set a mesh_circle_data object to the face, in order to add circular datas (for cylinders)
     //! \param inCircle A Dtk_mesh_circle_data object, filled.
     void set_mesh_circle_data(const Dtk_mesh_circle_data& inCircle);
 
     //! \brief Some interfaces need to keep a normal for a specific type of face. Use this to retrieve a global face normal
     Dtk_dir get_face_normal() const;
     //! \brief Some interfaces need to keep a normal for a specific type of face. Use this to store a global face normal
     void set_face_normal(const Dtk_dir&);
 
     //! \brief Get a name for the face
     Dtk_string get_face_name() const;
     //! \brief Set a name for the face
     //! \param inName : Name to set.
     void set_face_name(const Dtk_string& inName);
 
     virtual Dtk_Size_t GetSize() const; 
 
    Dtk_ErrorStatus _Store(void*);
};
 
/*
 
//! \class Dtk_facet
//! \brief This is a high level abstract facet class, used for both triangles and polygons.
//!
//!    This class gathers all the datas related to a facet.
class Dtk_facet
{
    protected:
 
        // indices 
        Dtk_tab<int>        indices;
        Dtk_mesh *            mesh;
 
        Dtk_Size_t                    numset;
 
        friend class Dtk_mesh;
        friend class Dtk_mesh_face;
 
        void set_numset(Dtk_Size_t);
        void set_mesh(Dtk_mesh* inMesh);
 
    public:
    
        //! \brief Default constructor
        Dtk_facet();
 
        //! \brief Constructor
        //! \param inIndices : indices of the facet vertices
        //! \warning Please remember that vertices are stored in a Dtk_mesh object
        Dtk_facet(Dtk_tab<int> * inIndices);
 
        //! \brief Destructor
        ~Dtk_facet();
        
        //! \brief Do some clean up (called by the destructor)
        void clean_up();
 
        //! \brief Used to compute normals
        //! \warning Pure virtual method 
        virtual int compute_normal(Dtk_dir * outNormal) = 0;
 
        //! \brief A way to check if a facet is valid or not
        //! \warning Pure virtual method 
        virtual Dtk_bool is_valid() = 0;
 
        //! \brief Add a vertex only by an indice
        //! \warning No test is made to check the validity of the parameter. You may call is_valid once the facet is attached to a mesh.
        //! \return The current number of vertices
        Dtk_Size_t        add_indice(int inIndice);
        
        //! \brief Add a vertex
        //! \param inPnt : vertex
        //!    \param inNormal : normal
        //! \param inColor : color
        //! \param inU, inV : tex coords
        //! \warning A mesh must be set
        //! \return return 0 if ok, 1 if error
        int        add_vertex(Dtk_pnt * inPnt, Dtk_dir * inNormal = NULL, Dtk_RGB * inColor = NULL, Dtk_Float32 inU = 0., Dtk_Float32 inV = 0.);        
 
        //! \brief Return the current number of vertices 
        Dtk_Size_t            get_nb_vertices();
        
        //! \brief Get a vertex from a facet
        //! \param inIndice : indice of the vertex to get
        //! \param[out] outPnt : vertex returned
        //! \return return 0 if ok, 1 if error, 2 if wrong vertex format
        int            get_vertex(Dtk_Size_t inIndice, Dtk_pnt* outPnt);
 
        //! \brief Get a normal from a facet
        //! \param inIndice : indice of the vertex to get the normal
        //! \param[out] outPnt : normal returned
        //! \return return 0 if ok, 1 if error, 2 if wrong vertex format
        int            get_normal(Dtk_Size_t inIndice, Dtk_dir* outNormal);
 
        //! \brief Get a color from a facet
        //! \param inIndice : indice of the vertex to get the color
        //! \param[out] outColor : color returned
        //! \return return 0 if ok, 1 if error, 2 if wrong vertex format
        int            get_color(Dtk_Size_t inIndice, Dtk_RGB* outColor);
 
        //! \brief Get texture coords from a facet
        //! \param inIndice : indice of the vertex to get the texture coords
        //! \param[out] outU, outV : UV coords returned
        //! \return return 0 if ok, 1 if error, 2 if wrong vertex format
        int            get_texcoords(Dtk_Size_t inIndice, double* ouU, double* outV);
 
        //! \brief Return the number of vertices
        Dtk_Size_t            get_nb_indices();
 
        //! \brief Return the vertex indices array
        Dtk_tab<int>get_indices();
 
        //! \brief Return an vertex indice
        //! \param inIndice : indice in the vertex indices array
        int            get_indice(int inIndice);
 
        //! \brief Return the mesh set to the facet
        Dtk_mesh *    get_mesh();
};
 
*/
/*
 
// n points, n normales
//! \class Dtk_triangle
//! \brief This is a high level triangle class.
//!
//!    This class gathers all the datas related to a triangle.
class Dtk_triangle: public Dtk_facet
{
    public:
 
        //! \brief Constructor
        Dtk_triangle();
        
        //! \brief Constructor
        //! \param inIndices : indices of the vertices 
        Dtk_triangle(Dtk_tab<int> * inIndices);
 
        //! \Destructor
        ~Dtk_triangle();
 
        //! \brief Is_valid method
        Dtk_bool is_valid();
 
        //! \brief To compute the facet normal
        //! \param[out] outNormal : the normal returned
        //! \return return 0 if ok, 1 if error
        int compute_normal(Dtk_dir * outNormal);
};
 
*/
 
/*
 
class Dtk_planar_facet: public Dtk_facet
{
    friend class Dtk_mesh;
    ///////////////////////////donnees membre : brep
    ////////////////////////// loops internes
    public:
 
        Dtk_planar_facet();
        Dtk_planar_facet(Dtk_tab<int> *);
        ~Dtk_planar_facet();
 
        Dtk_bool is_valid();
        int compute_normal(Dtk_dir *);
 
        Dtk_triangle * to_strip();
        Dtk_triangle * to_triangles();
};
 
*/
 
 
class Dtk_mesh_circle_data;
 
 
//! \class Dtk_mesh_curve
//! \brief This is a high level curve class.
//!
//!    This class gathers all the datas related to a curve.
//! In this class, vertices are indexed or not.
class Dtk_mesh_curve
{
        int                    type;        // kind or crv
        DTK_MESH_CRV_TYPE      crv_type;    // crv type
        Dtk_tab<int>           indices;     // si type != 120
        Dtk_tab<Dtk_pnt>       vertices;    // si type == 120
        Dtk_RGB                color;
        unsigned long          id;
        int                    line_type;
        float                  thickness;
        Dtk_mesh_circle_data * circle_data;
 
    public:
 
        //! \brief Default constructor
        Dtk_mesh_curve();
        //! \brief Default destructor
        ~Dtk_mesh_curve();
 
        //! \brief Add an indexed vertex to the curve (indice to an external vertices array, like the one inside Dtk_mesh)
        //! \param inIndice : indice
        void    add_indice(int inIndice);
        //! \brief Get an indice from the indices array. Indices array size must be greater than inNum
        //! \param inNum : indice to return
        int        get_indice(Dtk_Size_t inNum);
        //! \brief Pop the last indice from the indices array
        int        pop_indice();
 
        //! \brief Add a vertex to the vertices array
        //! \param inVertex : vertex to add
        void    add_vertex(Dtk_pnt inVertex);
        //! \brief Get a vertex from the verxtex array
        //! \param inIndice : number of the vertex to get
        //! \param[out] outVertex : vertex returned
        //! \return return 0 if ok
        int        get_vertex(Dtk_Size_t inIndice, Dtk_pnt * outVertex);
        //! \brief Pop the last vertex from the vertices array
        int        pop_vertex(Dtk_pnt*);
 
        //! \brief Return the vertices array size
        Dtk_Size_t     get_nb_vertices();
        //! \brief Return the indices array size
        Dtk_Size_t     get_nb_indices();
 
        //! \brief Set an ID to the curve
        //! \param inID : ID
        void            set_id(unsigned long inID);
        //! \brief Return the ID of the curve
        unsigned long    get_id();
 
        //! \brief Set the curve type 
        //! \param inType : type of the curve, can be : 
        //!
        //!
        //!    -    \b DTK_CGR_CRV_WIREFRAME_INDICE        : wireframe curve with indexed vertices\n
        //!    -    \b DTK_CGR_CRV_WIREFRAME_PNTS        : wireframe curve non indexed\n
        //!    -    \b DTK_CGR_CRV_BOUNDARY_INDICE        : boundary curve with indexed vertices\n
        //!    -    \b DTK_CGR_CRV_BOUNDARY_PNTS        : boundary curve non indexed\n
        //!    -    \b DTK_CGR_CRV_NO_BOUNDARY_INDICE    : internal\n
        //!    -    \b DTK_CGR_CRV_NO_BOUNDARY_PNTS        : internal\n
        //!\n
        void set_type(int inType);
        //! \brief Return the curve type
        int get_type();
        //! \brief Set the curve nature
        //! \param type : can be DTK_MESH_CIRCLE, DTK_MESH_LINE or DTK_MESH_OTHERCRV
        //! if DTK_MESH_CIRCLE, the Dtk_mesh_curve object must have a mesh_circle_data object set (see set_mesh_circle_data(..) help)
        void set_crv_type(DTK_MESH_CRV_TYPE type);
        //! \brief Return the curve nature
        //! \return DTK_MESH_CRV_TYPE value
        DTK_MESH_CRV_TYPE get_crv_type();
 
        //! \brief Set a RGB color to the curve
        //! \param R, G, B : RGB values
        void    set_color(int R, int G, int B);
        //! \brief Return the curve color
        //! \return A Dtk_RGB object is returned
        Dtk_RGB    get_color();
 
        //! \brief Set thickness in Dtk_mesh_curve
        void set_thickness(float inThickness);
 
        //! \brief Get thickness of Dtk_mesh_curve
        float get_thickness();
 
        //! \brief Set line type in Dtk_mesh_curve
        void set_linetype(int inLineType);
 
        //! \brief Get line type of Dtk_mesh_curve
        int get_linetype();
 
        //! \brief Set a mesh_circle_data object to the face, in order to add circular datas (for circles)
        //! \param inCircle A Dtk_mesh_circle_data object, filled.
        void                    set_mesh_circle_data(Dtk_mesh_circle_data * inCircle);
        Dtk_mesh_circle_data *    get_mesh_circle_data();
        //! \brief
        Dtk_mesh_curve * transform2Cpy(Dtk_transfo * inMatrix);
};
 
 
 
//! \class Dtk_mesh_circle_data
//! \brief This class gathers circle datas.
class Dtk_mesh_circle_data
{
    Dtk_dir axis;
    Dtk_pnt center;
    double    radius;
 
    public:
        //! \brief Default constructor
        Dtk_mesh_circle_data();
        //! \brief Default destructor
        ~Dtk_mesh_circle_data();
 
        //! \brief Used to set the circle/cylinder axis
        //! \param inAxis : axis 
        void        set_axis(Dtk_dir inAxis);
        //! \brief Return the circle/cylinder axis
        Dtk_dir        get_axis() const;
 
        //! \brief Used to set the circle/cylinder center
        //! \param inCenter : center
        void        set_center(Dtk_pnt inCenter);
        //! \brief Return the circle/cylinder center
        Dtk_pnt        get_center() const;
 
        //! \brief Used to set the circle/cylinder radius
        //! \param inRadius : radius
        void        set_radius(double inRadius);
        //! \brief Return the circle/cylinder radius
        double        get_radius() const;
};
 
 
 
// new class Dtk_MeshPolyline
//! \class  Dtk_MeshPolyline
//! \brief This is the Polyline in Mesh mode.
//!
 
class Dtk_MeshPolyline :public Dtk_Object
{
private:
     friend class Dtk_SmartPtr<Dtk_MeshPolyline>;
     Dtk_tab<Dtk_UInt32> points;   // array of indice in vertex array from Dtk_MEsh of Polyline
     int  TopoID;
 
public:
     Dtk_MeshPolyline();
     virtual ~Dtk_MeshPolyline();
     void AddVertex(const Dtk_UInt32 ind);
     Dtk_UInt32 GetVertexInd(const Dtk_UInt32 ival);
     int GetTopoID() { return (TopoID); };
     void SetTopoID(const int ival);
     Dtk_Size_t GetNbVertex() { return (points.size()); };
 
     //downcasting
     int DtkDynamicType(const int& inId);
     static Dtk_MeshPolyline * DtkDynamicCast(Dtk_Object * nObject);
 
 
};
 
typedef Dtk_SmartPtr<Dtk_MeshPolyline>                 Dtk_MeshPolylinePtr;
 
 
 
 
#endif