soc-2008-mxcurioni: first version of lib3ds code. It does NOT work yet and has to...
authorMaxime Curioni <maxime.curioni@gmail.com>
Thu, 7 Aug 2008 15:04:25 +0000 (15:04 +0000)
committerMaxime Curioni <maxime.curioni@gmail.com>
Thu, 7 Aug 2008 15:04:25 +0000 (15:04 +0000)
All of the reference to the original Material class were renamed to FrsMaterial to resolve a name collision with Blender. To keep the window context necessary to draw the strokes after RE_Database_FromScene has been called, the display_clear function is used.

47 files changed:
source/blender/freestyle/intern/app_blender/Controller.cpp
source/blender/freestyle/intern/app_blender/Controller.h
source/blender/freestyle/intern/app_blender/api.cpp
source/blender/freestyle/intern/python/BPy_Convert.cpp
source/blender/freestyle/intern/python/BPy_Convert.h
source/blender/freestyle/intern/python/BPy_FrsMaterial.cpp
source/blender/freestyle/intern/python/BPy_FrsMaterial.h
source/blender/freestyle/intern/python/Director.cpp
source/blender/freestyle/intern/python/Interface1D/FEdge/BPy_FEdgeSharp.cpp
source/blender/freestyle/intern/python/Interface1D/FEdge/BPy_FEdgeSmooth.cpp
source/blender/freestyle/intern/python/UnaryFunction0D/BPy_UnaryFunction0DMaterial.cpp
source/blender/freestyle/intern/python/UnaryFunction0D/BPy_UnaryFunction0DMaterial.h
source/blender/freestyle/intern/rendering/GLDebugRenderer.cpp
source/blender/freestyle/intern/rendering/GLDebugRenderer.h
source/blender/freestyle/intern/rendering/GLMonoColorRenderer.cpp
source/blender/freestyle/intern/rendering/GLMonoColorRenderer.h
source/blender/freestyle/intern/rendering/GLRenderer.cpp
source/blender/freestyle/intern/rendering/GLRenderer.h
source/blender/freestyle/intern/rendering/GLSelectRenderer.cpp
source/blender/freestyle/intern/rendering/GLSelectRenderer.h
source/blender/freestyle/intern/scene_graph/BlenderFileLoader.cpp [new file with mode: 0644]
source/blender/freestyle/intern/scene_graph/BlenderFileLoader.h [new file with mode: 0644]
source/blender/freestyle/intern/scene_graph/FrsMaterial.h [moved from source/blender/freestyle/intern/scene_graph/Material.h with 87% similarity]
source/blender/freestyle/intern/scene_graph/IndexedFaceSet.cpp
source/blender/freestyle/intern/scene_graph/IndexedFaceSet.h
source/blender/freestyle/intern/scene_graph/MaxFileLoader.cpp
source/blender/freestyle/intern/scene_graph/NodeShape.cpp
source/blender/freestyle/intern/scene_graph/NodeShape.h
source/blender/freestyle/intern/scene_graph/OrientedLineRep.cpp
source/blender/freestyle/intern/scene_graph/Rep.h
source/blender/freestyle/intern/scene_graph/SceneVisitor.h
source/blender/freestyle/intern/stroke/Curve.h
source/blender/freestyle/intern/stroke/StrokeTesselator.cpp
source/blender/freestyle/intern/stroke/StrokeTesselator.h
source/blender/freestyle/intern/view_map/Functions0D.cpp
source/blender/freestyle/intern/view_map/Functions0D.h
source/blender/freestyle/intern/view_map/Silhouette.cpp
source/blender/freestyle/intern/view_map/Silhouette.h
source/blender/freestyle/intern/view_map/ViewEdgeXBuilder.cpp
source/blender/freestyle/intern/view_map/ViewMapBuilder.cpp
source/blender/freestyle/intern/view_map/ViewMapIO.cpp
source/blender/freestyle/intern/view_map/ViewMapTesselator.h
source/blender/freestyle/intern/winged_edge/WEdge.cpp
source/blender/freestyle/intern/winged_edge/WEdge.h
source/blender/freestyle/intern/winged_edge/WingedEdgeBuilder.cpp
source/blender/freestyle/intern/winged_edge/WingedEdgeBuilder.h
source/blender/render/intern/source/pipeline.c

index ff6ca96e657968f2b25b522b3bae366307aaecc4..183695ec731df4e55accca531d13cb60ea11c833 100755 (executable)
@@ -64,6 +64,8 @@
 
 #include "../system/StringUtils.h"
 
+#include "../scene_graph/BlenderFileLoader.h"
+
 Controller::Controller()
 {
        
@@ -168,6 +170,107 @@ void Controller::setView(AppGLWidget *iView)
   _Canvas->setViewer(_pView);
 }
 
+int Controller::LoadMesh(Render *re)
+{
+  if (_pView)
+    _pView->setUpdateMode(false);
+  
+  BlenderFileLoader loader(re);
+  
+  _Chrono.start();
+  
+  NodeGroup *blenderScene = loader.Load();
+
+  if (blenderScene == NULL) {
+       cout << "Cannot load scene" << endl;
+    return 1;
+  }
+
+  cout << "Scene loaded\n" << endl;
+
+  printf("Mesh cleaning    : %lf\n", _Chrono.stop());
+  _SceneNumFaces += loader.numFacesRead();
+
+  if(loader.minEdgeSize() < _minEdgeSize)
+    {
+      _minEdgeSize = loader.minEdgeSize();
+      _EPSILON = _minEdgeSize*1e-6;
+      if(_EPSILON < DBL_MIN)
+       _EPSILON = 0.0;
+    }
+
+  cout << "Epsilon computed : " << _EPSILON << endl;
+
+  // DEBUG
+//   ScenePrettyPrinter spp;
+//   blenderScene->accept(spp);
+       
+  _RootNode->AddChild(blenderScene);
+  _RootNode->UpdateBBox(); // FIXME: Correct that by making a Renderer to compute the bbox
+
+  _pView->setModel(_RootNode);
+  //_pView->FitBBox();
+
+
+  _Chrono.start();
+
+  
+  WXEdgeBuilder wx_builder;
+  blenderScene->accept(wx_builder);
+  _winged_edge = wx_builder.getWingedEdge();
+
+  printf("WEdge building   : %lf\n", _Chrono.stop());
+
+ _Chrono.start();
+
+  _Grid.clear();
+  Vec3r size;
+  for(unsigned int i=0; i<3; i++)
+    {
+      size[i] = fabs(_RootNode->bbox().getMax()[i] - _RootNode->bbox().getMin()[i]);
+      size[i] += size[i]/10.0; // let make the grid 1/10 bigger to avoid numerical errors while computing triangles/cells intersections
+      if(size[i]==0){
+          cout << "Warning: the bbox size is 0 in dimension "<<i<<endl;
+      }
+    }
+  _Grid.configure(Vec3r(_RootNode->bbox().getMin() - size / 20.0), size,
+                 _SceneNumFaces);
+
+  // Fill in the grid:
+  WFillGrid fillGridRenderer(&_Grid, _winged_edge);
+  fillGridRenderer.fillGrid();
+
+  printf("Grid building    : %lf\n", _Chrono.stop());
+  
+  // DEBUG
+//   _Grid.displayDebug();
+   
+  _pView->setDebug(_DebugNode);
+
+  //delete stuff
+  //  if(0 != ws_builder)
+  //    {
+  //      delete ws_builder;
+  //      ws_builder = 0;
+  //    }
+  _pView->updateGL();
+  
+
+       //soc QFileInfo qfi(iFileName);
+       //soc string basename((const char*)qfi.fileName().toAscii().data());
+       // char cleaned[FILE_MAX];
+       // BLI_strncpy(cleaned, iFileName, FILE_MAX);
+       // BLI_cleanup_file(NULL, cleaned);
+       // string basename = StringUtils::toAscii( string(cleaned) );
+
+  _ListOfModels.push_back("Blender_models");
+
+  cout << "Triangles nb     : " << _SceneNumFaces << endl;
+  _bboxDiag = (_RootNode->bbox().getMax()-_RootNode->bbox().getMin()).norm();
+  cout << "Bounding Box     : " << _bboxDiag << endl;
+  return 0;
+}
+
 
 int Controller::Load3DSFile(const char *iFileName)
 {
@@ -649,6 +752,8 @@ void Controller::ComputeViewMap()
   _ViewMap = vmBuilder.BuildViewMap(*_winged_edge, _VisibilityAlgo, _EPSILON);
   _ViewMap->setScene3dBBox(_RootNode->bbox());
   
+       printf("ViewMap edge count : %i\n", _ViewMap->viewedges_size() );
+
   //Tesselate the 3D edges:
   _SilhouetteNode = sTesselator3d.Tesselate(_ViewMap);
   _SilhouetteNode->addRef();
@@ -953,9 +1058,9 @@ NodeGroup * Controller::BuildRep(vector<ViewEdge*>::iterator vedges_begin,
                                        vector<ViewEdge*>::iterator vedges_end)
 {
   ViewMapTesselator2D tesselator2D;
-  Material mat;
+  FrsMaterial mat;
   mat.setDiffuse(1,1,0.3,1);
-  tesselator2D.setMaterial(mat);
+  tesselator2D.setFrsMaterial(mat);
 
   return (tesselator2D.Tesselate(vedges_begin, vedges_end));
 }
index 032e21a1ce5b05c605fe875aefd336a7ed819826..7b982b7e9a24c23dd0760c8684f9c0d70b27a802 100755 (executable)
@@ -51,6 +51,16 @@ class AppCanvas;
 class InteractiveShader;
 class Shader;
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+       #include "render_types.h"
+
+#ifdef __cplusplus
+}
+#endif
+
 class Controller
 {
 public:
@@ -62,6 +72,7 @@ public:
   //soc
        void init_options();
 
+       int  LoadMesh( Render *re );
   int  Load3DSFile(const char *iFileName);
   void CloseFile();
   void LoadViewMapFile(const char *iFileName, bool only_camera = false);
index a6490324fbfe30b7eb6dda63eae7ed8fdaceccfc..01c4cfb1460abff47341d8ccb6938274c484b722 100644 (file)
@@ -14,6 +14,7 @@ extern "C" {
 #include "renderpipeline.h"
 
 #include "BLI_blenlib.h"
+#include "BIF_renderwin.h"
 #include "BPY_extern.h"
 
 #ifdef __cplusplus
@@ -103,6 +104,10 @@ extern "C" {
                }
        }
        
+       void FRS_load_mesh( Render *re ){
+               controller->LoadMesh(re);
+       }
+       
        void FRS_prepare(Render* re) {
                FRS_initialize();
                
@@ -110,15 +115,12 @@ extern "C" {
                FRS_init_camera(re);
                
                FRS_scene_3ds_export(re);
+               //FRS_load_mesh(re);
        }
 
        void FRS_render(Render* re, int render_in_layer) {
                
-               if(render_in_layer) {
-                       view->workingBuffer = GL_COLOR_ATTACHMENT1_EXT;
-               } else {
-                       view->workingBuffer = GL_BACK;
-               }
+               view->workingBuffer = GL_BACK;
                
                // add style module
                cout << "Module: " << style_module << endl;
@@ -185,8 +187,13 @@ extern "C" {
                        }
                        
                } else {
-                       FRS_render(re, render_in_layer);
+                       // used to reobtain ogl context after RE_Database_FromScene call
+                       re->display_clear(re->result);
+                       
+                       // render strokes
+                       FRS_render(re, render_in_layer);                
                        
+                       // display result
                        RenderResult rres;
                        RE_GetResultImage(re, &rres);
                        view->readPixels(0, 0, re->winx, re->winy, AppGLWidget::RGBA, rres.rectf );             
index 5f4b7098f291c25bd2350ce7d36fae6dd0f97308..38eeced69581c857b9fcee77be72b64369ee9c40 100644 (file)
@@ -190,9 +190,9 @@ PyObject * BPy_ViewShape_from_ViewShape( ViewShape& vs ) {
        return py_vs;
 }
 
-PyObject * BPy_FrsMaterial_from_Material( Material& m ){
+PyObject * BPy_FrsMaterial_from_FrsMaterial( FrsMaterial& m ){
        PyObject *py_m = FrsMaterial_Type.tp_new( &FrsMaterial_Type, 0, 0 );
-       ((BPy_FrsMaterial*) py_m)->m = new Material( m );
+       ((BPy_FrsMaterial*) py_m)->m = new FrsMaterial( m );
 
        return py_m;
 }
index 10efb2e5246a9d211367fc904368ed84e0bb94cd..4ddfbe38d54300c9eba3e67da100aabc832aff88 100644 (file)
@@ -20,8 +20,8 @@ using namespace Geometry;
 // Interface1D
 #include "../view_map/Interface1D.h"
 
-// Material
-#include "../scene_graph/Material.h"
+// FrsMaterial
+#include "../scene_graph/FrsMaterial.h"
 
 // Nature::VertexNature, Nature::EdgeNature
 #include "../winged_edge/Nature.h"
@@ -78,7 +78,7 @@ PyObject * BPy_Id_from_Id( Id& id );
 PyObject * BPy_Interface0D_from_Interface0D( Interface0D& if0D );
 PyObject * BPy_Interface1D_from_Interface1D( Interface1D& if1D );
 PyObject * BPy_IntegrationType_from_IntegrationType( int i );
-PyObject * BPy_FrsMaterial_from_Material( Material& m );
+PyObject * BPy_FrsMaterial_from_FrsMaterial( FrsMaterial& m );
 PyObject * BPy_Nature_from_Nature( unsigned short n );
 PyObject * BPy_MediumType_from_MediumType( int n );
 PyObject * BPy_SShape_from_SShape( SShape& ss );
index 052583e462152374b8b7d14e9c778a5a1e5eefb4..6f7d4ba5015a763597ff5fc6f2995c373da59257 100644 (file)
@@ -180,17 +180,17 @@ int FrsMaterial___init__(BPy_FrsMaterial *self, PyObject *args, PyObject *kwds)
         return -1;
 
        if( !obj1 ){
-               self->m = new Material();
+               self->m = new FrsMaterial();
 
        } else if( BPy_FrsMaterial_Check(obj1) ) {
                if( ((BPy_FrsMaterial *) obj1)->m )
-                       self->m = new Material(*( ((BPy_FrsMaterial *) obj1)->m ));
+                       self->m = new FrsMaterial(*( ((BPy_FrsMaterial *) obj1)->m ));
                else
                        return -1;
 
        } else if( PyFloat_Check(obj1) ) {
                f1 = PyFloat_AsDouble(obj1);
-               self->m = new Material(&f1, &f2, &f3, &f4, f5);
+               self->m = new FrsMaterial(&f1, &f2, &f3, &f4, f5);
 
        } else {
                return -1;
index b25ddfc77bc1e336ac7da7e00a2b85ea259fb4e6..95264180f2f791bb4a1daceceda72be209d3c0a2 100644 (file)
@@ -1,7 +1,7 @@
 #ifndef FREESTYLE_PYTHON_FRSMATERIAL_H
 #define FREESTYLE_PYTHON_FRSMATERIAL_H
 
-#include "../scene_graph/Material.h"
+#include "../scene_graph/FrsMaterial.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -18,7 +18,7 @@ extern PyTypeObject FrsMaterial_Type;
 /*---------------------------Python BPy_FrsMaterial structure definition----------*/
 typedef struct {
        PyObject_HEAD
-       Material *m;
+       FrsMaterial *m;
 } BPy_FrsMaterial;
 
 /*---------------------------Python BPy_FrsMaterial visible prototypes-----------*/
index 153ea79eabf99ed2c9ffeb71733bedc1c81ce134..b56cd59e2f6c2abb3e5ec8159d706f807fe9d6e0 100644 (file)
@@ -109,7 +109,7 @@ void Director_BPy_UnaryFunction0D___call__( void *uf0D, PyObject *obj, Interface
                ((UnaryFunction0D<Id> *) uf0D)->result = *( ((BPy_Id *) result)->id );
        
        } else if ( BPy_UnaryFunction0DMaterial_Check(obj) ) {
-               ((UnaryFunction0D<Material> *) uf0D)->result = *( ((BPy_FrsMaterial *) result)->m );
+               ((UnaryFunction0D<FrsMaterial> *) uf0D)->result = *( ((BPy_FrsMaterial *) result)->m );
        
        } else if ( BPy_UnaryFunction0DUnsigned_Check(obj) ) {
                ((UnaryFunction0D<unsigned> *) uf0D)->result = PyInt_AsLong(result);
index 22a4dbc378e69b38b170e00e4f8394e4bfa72578..336331d92d51285328c23fa200593d5edd0ccbe1 100644 (file)
@@ -166,21 +166,21 @@ PyObject * FEdgeSharp_normalB( BPy_FEdgeSharp *self ) {
 }
 
 PyObject * FEdgeSharp_aMaterialIndex( BPy_FEdgeSharp *self ) {
-       return PyInt_FromLong( self->fes->aMaterialIndex() );
+       return PyInt_FromLong( self->fes->aFrsMaterialIndex() );
 }
 
 PyObject * FEdgeSharp_bMaterialIndex( BPy_FEdgeSharp *self ) {
-       return PyInt_FromLong( self->fes->bMaterialIndex() );
+       return PyInt_FromLong( self->fes->bFrsMaterialIndex() );
 }
 
 PyObject * FEdgeSharp_aMaterial( BPy_FEdgeSharp *self ) {
-       Material m( self->fes->aMaterial() );
-       return BPy_FrsMaterial_from_Material(m);
+       FrsMaterial m( self->fes->aFrsMaterial() );
+       return BPy_FrsMaterial_from_FrsMaterial(m);
 }
 
 PyObject * FEdgeSharp_bMaterial( BPy_FEdgeSharp *self ) {
-       Material m( self->fes->aMaterial() );
-       return BPy_FrsMaterial_from_Material(m);
+       FrsMaterial m( self->fes->aFrsMaterial() );
+       return BPy_FrsMaterial_from_FrsMaterial(m);
 }
 
 PyObject * FEdgeSharp_setNormalA( BPy_FEdgeSharp *self, PyObject *args ) {
@@ -225,7 +225,7 @@ PyObject * FEdgeSharp_setaMaterialIndex( BPy_FEdgeSharp *self, PyObject *args )
                Py_RETURN_NONE;
        }
        
-       self->fes->setaMaterialIndex( i );
+       self->fes->setaFrsMaterialIndex( i );
 
        Py_RETURN_NONE;
 }
@@ -238,7 +238,7 @@ PyObject * FEdgeSharp_setbMaterialIndex( BPy_FEdgeSharp *self, PyObject *args )
                Py_RETURN_NONE;
        }
        
-       self->fes->setbMaterialIndex( i );
+       self->fes->setbFrsMaterialIndex( i );
 
        Py_RETURN_NONE;
 }
index 6a11b6c1e98e721e2b42dfebbbdedf4fa79e7823..0970e22a72672d6b9620f50fd2a20b0e95bbc2c9 100644 (file)
@@ -152,13 +152,13 @@ PyObject * FEdgeSmooth_normal( BPy_FEdgeSmooth *self ) {
 }
 
 PyObject * FEdgeSmooth_materialIndex( BPy_FEdgeSmooth *self ) {
-       return PyInt_FromLong( self->fes->materialIndex() );
+       return PyInt_FromLong( self->fes->frs_materialIndex() );
 }
 
 
 PyObject * FEdgeSmooth_material( BPy_FEdgeSmooth *self ) {
-       Material m( self->fes->material() );
-       return BPy_FrsMaterial_from_Material(m);
+       FrsMaterial m( self->fes->frs_material() );
+       return BPy_FrsMaterial_from_FrsMaterial(m);
 }
 
 PyObject * FEdgeSmooth_setNormal( BPy_FEdgeSmooth *self, PyObject *args ) {
@@ -186,7 +186,7 @@ PyObject * FEdgeSmooth_setMaterialIndex( BPy_FEdgeSmooth *self, PyObject *args )
                Py_RETURN_NONE;
        }
        
-       self->fes->setMaterialIndex( i );
+       self->fes->setFrsMaterialIndex( i );
 
        Py_RETURN_NONE;
 }
index 2aef794617a04dc1df16b6c0c81330310398734c..b719f6df71b8490a615a0b20b054dc5b46ce3ad4 100644 (file)
@@ -134,7 +134,7 @@ PyMODINIT_FUNC UnaryFunction0DMaterial_Init( PyObject *module ) {
 
 int UnaryFunction0DMaterial___init__(BPy_UnaryFunction0DMaterial* self)
 {
-       self->uf0D_material = new UnaryFunction0D<Material>();
+       self->uf0D_material = new UnaryFunction0D<FrsMaterial>();
        self->uf0D_material->py_uf0D = (PyObject *)self;
        return 0;
 }
@@ -165,8 +165,8 @@ PyObject * UnaryFunction0DMaterial___call__( BPy_UnaryFunction0DMaterial *self,
                return NULL;
        }
        
-       Material m( self->uf0D_material->operator()(*( ((BPy_Interface0DIterator *) obj)->if0D_it )) );
-       return BPy_FrsMaterial_from_Material( m );
+       FrsMaterial m( self->uf0D_material->operator()(*( ((BPy_Interface0DIterator *) obj)->if0D_it )) );
+       return BPy_FrsMaterial_from_FrsMaterial( m );
 
 }
 
index 5e932213128bd56821ce0684c82567fe604a1f25..ec4b3e1214d51b72f16762e8e77eb30b4c0cfe84 100644 (file)
@@ -3,7 +3,7 @@
 
 #include "../BPy_UnaryFunction0D.h"
 
-#include "../../scene_graph/Material.h"
+#include "../../scene_graph/FrsMaterial.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -20,7 +20,7 @@ extern PyTypeObject UnaryFunction0DMaterial_Type;
 /*---------------------------Python BPy_UnaryFunction0DMaterial structure definition----------*/
 typedef struct {
        BPy_UnaryFunction0D py_uf0D;
-       UnaryFunction0D<Material> *uf0D_material;
+       UnaryFunction0D<FrsMaterial> *uf0D_material;
 } BPy_UnaryFunction0DMaterial;
 
 /*---------------------------Python BPy_UnaryFunction0DMaterial visible prototypes-----------*/
index 716db397e9495497a8b9ac19d53a9b6913c9f6d5..ed0cecbcfc8c6a1a86d697d2d1a0b044e708456b 100755 (executable)
@@ -40,7 +40,7 @@ void GLDebugRenderer::visitIndexedFaceSet(IndexedFaceSet& iFaceSet)
   
   const real * vertices = iFaceSet.vertices();
   const real * normals = iFaceSet.normals();
-  const Material *const* materials = (const Material**)iFaceSet.materials();
+  const FrsMaterial *const* frs_materials = (const FrsMaterial**)iFaceSet.frs_materials();
   const unsigned *vindices = iFaceSet.vindices();
   const unsigned *nindices = iFaceSet.nindices();
   const unsigned *mindices = iFaceSet.mindices();
@@ -57,13 +57,13 @@ void GLDebugRenderer::visitIndexedFaceSet(IndexedFaceSet& iFaceSet)
     switch(faceStyle[fIndex])
     {
     case IndexedFaceSet::TRIANGLE_STRIP:
-      RenderTriangleStrip(vertices, normals, materials, pvi, pni, pmi, numVertexPerFace[fIndex]);
+      RenderTriangleStrip(vertices, normals, frs_materials, pvi, pni, pmi, numVertexPerFace[fIndex]);
       break;
     case IndexedFaceSet::TRIANGLE_FAN:
-      RenderTriangleFan(vertices, normals, materials, pvi, pni, pmi, numVertexPerFace[fIndex]);
+      RenderTriangleFan(vertices, normals, frs_materials, pvi, pni, pmi, numVertexPerFace[fIndex]);
       break;
     case IndexedFaceSet::TRIANGLES:
-      RenderTriangles(vertices, normals, materials, pvi, pni, pmi, numVertexPerFace[fIndex]);
+      RenderTriangles(vertices, normals, frs_materials, pvi, pni, pmi, numVertexPerFace[fIndex]);
       break;
     }
     pvi += numVertexPerFace[fIndex];
@@ -131,7 +131,7 @@ void GLDebugRenderer::renderBitmapString(real x,
 
 void GLDebugRenderer::RenderTriangleStrip(const real *iVertices, 
                                           const real *iNormals,
-                                          const Material *const* iMaterials, 
+                                          const FrsMaterial *const* iMaterials, 
                                           const unsigned* iVIndices, 
                                           const unsigned* iNIndices,
                                           const unsigned* iMIndices,
@@ -153,7 +153,7 @@ void GLDebugRenderer::RenderTriangleStrip(const real *iVertices,
 
 void GLDebugRenderer::RenderTriangleFan(const real *iVertices, 
                                         const real *iNormals,
-                                        const Material *const* iMaterials, 
+                                        const FrsMaterial *const* iMaterials, 
                                         const unsigned* iVIndices, 
                                         const unsigned* iNIndices,
                                         const unsigned* iMIndices,
@@ -175,7 +175,7 @@ void GLDebugRenderer::RenderTriangleFan(const real *iVertices,
 
 void GLDebugRenderer::RenderTriangles(const real *iVertices, 
                                       const real *iNormals,
-                                      const Material *const* iMaterials, 
+                                      const FrsMaterial *const* iMaterials, 
                                       const unsigned* iVIndices, 
                                       const unsigned* iNIndices,
                                       const unsigned* iMIndices,
index e0f9724964595521fbd7f89668e2342e82c411e6..9111d5067bc7c28451516a47575a2f97b1150a84 100755 (executable)
@@ -109,7 +109,7 @@ protected:
    */
   virtual void RenderTriangleStrip(const real *iVertices, 
                                    const real *iNormals,
-                                   const Material *const* iMaterials, 
+                                   const FrsMaterial *const* iMaterials, 
                                    const unsigned* iVIndices, 
                                    const unsigned* iNIndices,
                                    const unsigned* iMIndices,
@@ -133,7 +133,7 @@ protected:
    */
   virtual void RenderTriangleFan(const real *iVertices, 
                                    const real *iNormals,
-                                   const Material *const*iMaterials, 
+                                   const FrsMaterial *const*iMaterials, 
                                    const unsigned* iVIndices, 
                                    const unsigned* iNIndices,
                                    const unsigned* iMIndices,
@@ -157,7 +157,7 @@ protected:
    */
   virtual void RenderTriangles(const real *iVertices, 
                                    const real *iNormals,
-                                   const Material *const* iMaterials, 
+                                   const FrsMaterial *const* iMaterials, 
                                    const unsigned* iVIndices, 
                                    const unsigned* iNIndices,
                                    const unsigned* iMIndices,
index 792846fa0205a93e7d90088762c7a3f09b981570..ff893484fb5f9b0474af7a67068485c9e70b63c1 100755 (executable)
@@ -21,7 +21,7 @@
 
 #include "GLMonoColorRenderer.h"
 
-void GLMonoColorRenderer::visitMaterial(Material&) {
+void GLMonoColorRenderer::visitFrsMaterial(FrsMaterial&) {
   glColor3f(_r, _g, _b);
 }
 
index d8e3cf536ecc6e5232f24a19bcbedda4c4e21d19..9eb6c8134bbe23ecd1e4e736b06e45b53460571a 100755 (executable)
@@ -45,7 +45,7 @@ class LIB_RENDERING_EXPORT GLMonoColorRenderer : public GLRenderer
   virtual ~GLMonoColorRenderer() {}
 
   VISIT_DECL(DrawingStyle)
-  VISIT_DECL(Material)
+  VISIT_DECL(FrsMaterial)
 
   void setColor(float r, float g, float b, float alpha = 1.f);
 
index 45693413ace41f32719444392aaba7c8332f62e3..678256f72bf6e44eae2a128d86973052f68edc1e 100755 (executable)
@@ -54,7 +54,7 @@ void GLRenderer::visitIndexedFaceSet(IndexedFaceSet& ifs)
   const real * vertices = ifs.vertices();
   const real * normals = ifs.normals();
   const real * texCoords = ifs.texCoords();
-  const Material *const* materials = ifs.materials();
+  const FrsMaterial *const* frs_materials = ifs.frs_materials();
   const unsigned *vindices = ifs.vindices();
   const unsigned *nindices = ifs.nindices();
   const unsigned *mindices = ifs.mindices();
@@ -76,13 +76,13 @@ void GLRenderer::visitIndexedFaceSet(IndexedFaceSet& ifs)
     switch(faceStyle[fIndex])
     {
     case IndexedFaceSet::TRIANGLE_STRIP:
-      RenderTriangleStrip(vertices, normals, materials, texCoords, pvi, pni, pmi, pti, numVertexPerFace[fIndex]);
+      RenderTriangleStrip(vertices, normals, frs_materials, texCoords, pvi, pni, pmi, pti, numVertexPerFace[fIndex]);
       break;
     case IndexedFaceSet::TRIANGLE_FAN:
-      RenderTriangleFan(vertices, normals, materials, texCoords, pvi, pni, pmi, pti, numVertexPerFace[fIndex]);
+      RenderTriangleFan(vertices, normals, frs_materials, texCoords, pvi, pni, pmi, pti, numVertexPerFace[fIndex]);
       break;
     case IndexedFaceSet::TRIANGLES:
-      RenderTriangles(vertices, normals, materials, texCoords, pvi, pni, pmi, pti, numVertexPerFace[fIndex]);
+      RenderTriangles(vertices, normals, frs_materials, texCoords, pvi, pni, pmi, pti, numVertexPerFace[fIndex]);
       break;
     }
     pvi += numVertexPerFace[fIndex];
@@ -153,7 +153,7 @@ void GLRenderer::visitNodeDrawingStyleAfter(NodeDrawingStyle&) {
 
 void GLRenderer::RenderTriangleStrip( const real *iVertices, 
                                      const real *iNormals,
-                                     const Material *const* iMaterials,
+                                     const FrsMaterial *const* iMaterials,
                                      const real *iTexCoords,
                                      const unsigned* iVIndices, 
                                      const unsigned* iNIndices,
@@ -167,7 +167,7 @@ void GLRenderer::RenderTriangleStrip( const real *iVertices,
   {
                if(iMIndices){
                        if(iMIndices[i] != index){
-                               visitMaterial(*(iMaterials[iMIndices[i]]));
+                               visitFrsMaterial(*(iMaterials[iMIndices[i]]));
                                index = iMIndices[i];
                        }
                }
@@ -190,7 +190,7 @@ void GLRenderer::RenderTriangleStrip( const real *iVertices,
 
 void GLRenderer::RenderTriangleFan( const real *iVertices, 
                                     const real *iNormals,
-                                    const Material *const* iMaterials,
+                                    const FrsMaterial *const* iMaterials,
                                     const real *iTexCoords,
                                     const unsigned* iVIndices, 
                                     const unsigned* iNIndices,
@@ -204,7 +204,7 @@ void GLRenderer::RenderTriangleFan( const real *iVertices,
   {
                if(iMIndices){
                        if(iMIndices[i] != index){
-                               visitMaterial(*(iMaterials[iMIndices[i]]));
+                               visitFrsMaterial(*(iMaterials[iMIndices[i]]));
                                index = iMIndices[i];
                        }
                }
@@ -226,7 +226,7 @@ void GLRenderer::RenderTriangleFan( const real *iVertices,
 
 void GLRenderer::RenderTriangles( const real *iVertices, 
                                  const real *iNormals,
-                                 const Material *const* iMaterials,
+                                 const FrsMaterial *const* iMaterials,
                                  const real *iTexCoords,
                                  const unsigned* iVIndices, 
                                  const unsigned* iNIndices,
@@ -240,7 +240,7 @@ void GLRenderer::RenderTriangles( const real *iVertices,
   {
                if(iMIndices){
                        if(iMIndices[i] != index){
-                               visitMaterial(*(iMaterials[iMIndices[i]]));
+                               visitFrsMaterial(*(iMaterials[iMIndices[i]]));
                                index = iMIndices[i];
                        }
                }
@@ -424,7 +424,7 @@ void GLRenderer::visitDrawingStyle(DrawingStyle& iDrawingStyle)
     glDisable(GL_LIGHTING);
 }
 
-void GLRenderer::visitMaterial(Material& m) {
+void GLRenderer::visitFrsMaterial(FrsMaterial& m) {
   const float* diff = m.diffuse();
   const float* amb = m.ambient();
   const float* spec = m.specular();
@@ -438,7 +438,7 @@ void GLRenderer::visitMaterial(Material& m) {
   glMaterialf(GL_FRONT, GL_SHININESS, m.shininess());
 }
 
-void GLRenderer::visitMaterial(const Material& m) {
+void GLRenderer::visitFrsMaterial(const FrsMaterial& m) {
   const float* diff = m.diffuse();
   const float* amb = m.ambient();
   const float* spec = m.specular();
index ddbf082038b4ee3b38b45d815bc47d9b8ff4111e..3769aefb92bff1280c0fd15bb1275f6de2f84eba 100755 (executable)
@@ -67,9 +67,9 @@ class LIB_RENDERING_EXPORT GLRenderer : public SceneVisitor
   VISIT_DECL(VertexRep)
   VISIT_DECL(IndexedFaceSet)
   VISIT_DECL(DrawingStyle)
-  VISIT_DECL(Material)
+  VISIT_DECL(FrsMaterial)
 
-  virtual void visitMaterial(const Material&);
+  virtual void visitFrsMaterial(const FrsMaterial&);
   virtual void visitNodeTransformBefore(NodeTransform&);
   virtual void visitNodeTransformAfter(NodeTransform&);
   virtual void visitNodeDrawingStyleBefore(NodeDrawingStyle&);
@@ -101,7 +101,7 @@ class LIB_RENDERING_EXPORT GLRenderer : public SceneVisitor
    */
   virtual void RenderTriangleStrip(const real *iVertices, 
                                    const real *iNormals,
-                                   const Material *const*iMaterials, 
+                                   const FrsMaterial *const*iMaterials, 
                                    const real *iTexCoords,
                                    const unsigned* iVIndices, 
                                    const unsigned* iNIndices,
@@ -133,7 +133,7 @@ class LIB_RENDERING_EXPORT GLRenderer : public SceneVisitor
    */
   virtual void RenderTriangleFan(const real *iVertices, 
                                  const real *iNormals,
-                                 const Material *const* iMaterials,
+                                 const FrsMaterial *const* iMaterials,
                                  const real *iTexCoords,
                                  const unsigned* iVIndices, 
                                  const unsigned* iNIndices,
@@ -165,7 +165,7 @@ class LIB_RENDERING_EXPORT GLRenderer : public SceneVisitor
    */
   virtual void RenderTriangles(const real *iVertices, 
                                const real *iNormals,
-                               const Material *const* iMaterials, 
+                               const FrsMaterial *const* iMaterials, 
                                const real *iTexCoords,
                                const unsigned* iVIndices, 
                                const unsigned* iNIndices,
index b4a2406c644d48deccefa24ccbdb5a143d246c5e..ca9199740f85422bb9e5dd05a55e4da525a2ed0f 100755 (executable)
@@ -58,7 +58,7 @@ void GLSelectRenderer::visitNodeShape(NodeShape& sn) {
   _current_shape_active = false;
 }
 
-void GLSelectRenderer::visitMaterial(Material& m) {
+void GLSelectRenderer::visitFrsMaterial(FrsMaterial& m) {
   if (_gl_select_rendering)
     return;
 
@@ -79,7 +79,7 @@ void GLSelectRenderer::visitMaterial(Material& m) {
   glMaterialf(GL_FRONT, GL_SHININESS, m.shininess());
 }
 
-void GLSelectRenderer::visitMaterial(const Material& m) {
+void GLSelectRenderer::visitFrsMaterial(const FrsMaterial& m) {
   if (_gl_select_rendering)
     return;
 
@@ -106,7 +106,7 @@ void GLSelectRenderer::visitIndexedFaceSet(IndexedFaceSet& ifs)
   
   const real * vertices = ifs.vertices();
   const real * normals = ifs.normals();
-  const Material *const* materials = ifs.materials();
+  const FrsMaterial *const* frs_materials = ifs.frs_materials();
   const real * texCoords= ifs.texCoords();
   const unsigned *vindices = ifs.vindices();
   const unsigned *nindices = ifs.nindices();
@@ -127,13 +127,13 @@ void GLSelectRenderer::visitIndexedFaceSet(IndexedFaceSet& ifs)
     switch(faceStyle[fIndex])
     {
     case IndexedFaceSet::TRIANGLE_STRIP:
-      RenderTriangleStrip(vertices, normals, materials, texCoords, pvi, pni, pmi, pti, numVertexPerFace[fIndex]);
+      RenderTriangleStrip(vertices, normals, frs_materials, texCoords, pvi, pni, pmi, pti, numVertexPerFace[fIndex]);
       break;
     case IndexedFaceSet::TRIANGLE_FAN:
-      RenderTriangleFan(vertices, normals, materials, texCoords, pvi, pni, pmi, pti, numVertexPerFace[fIndex]);
+      RenderTriangleFan(vertices, normals, frs_materials, texCoords, pvi, pni, pmi, pti, numVertexPerFace[fIndex]);
       break;
     case IndexedFaceSet::TRIANGLES:
-      RenderTriangles(vertices, normals, materials, texCoords, pvi, pni, pmi, pti, numVertexPerFace[fIndex]);
+      RenderTriangles(vertices, normals, frs_materials, texCoords, pvi, pni, pmi, pti, numVertexPerFace[fIndex]);
       break;
     }
     pvi += numVertexPerFace[fIndex];
index bf8a334aebb50b8f849f7bfde01460075f8f6680..2ce8c3f62db589dedbd680e46dc107195605cd20 100755 (executable)
@@ -51,9 +51,9 @@ class LIB_RENDERING_EXPORT GLSelectRenderer : public GLRenderer
   VISIT_DECL(NodeShape)
 
   VISIT_DECL(IndexedFaceSet)
-  VISIT_DECL(Material)
+  VISIT_DECL(FrsMaterial)
 
-  virtual void visitMaterial(const Material&);
+  virtual void visitFrsMaterial(const FrsMaterial&);
   virtual void visitNodeShapeBefore(NodeShape&);
   virtual void visitNodeShapeAfter(NodeShape&);
 
diff --git a/source/blender/freestyle/intern/scene_graph/BlenderFileLoader.cpp b/source/blender/freestyle/intern/scene_graph/BlenderFileLoader.cpp
new file mode 100644 (file)
index 0000000..f35f32a
--- /dev/null
@@ -0,0 +1,360 @@
+#include "BlenderFileLoader.h"
+
+BlenderFileLoader::BlenderFileLoader(Render *re)
+{
+       _re = re;
+  _Scene = NULL;
+  _numFacesRead = 0;
+  _minEdgeSize = DBL_MAX;
+}
+
+BlenderFileLoader::~BlenderFileLoader()
+{
+  _Scene = NULL;
+}
+
+NodeGroup* BlenderFileLoader::Load()
+{
+       ObjectInstanceRen *obi;
+       ObjectRen *obr;
+
+  // creation of the scene root node
+  _Scene = new NodeGroup;
+
+       int id = 0;
+       for(obi= (ObjectInstanceRen *) _re->instancetable.first; obi; obi=obi->next) {
+               obr= obi->obr;
+               insertShapeNode(obr, ++id);
+       }
+
+  //Returns the built scene.
+  return _Scene;
+}
+
+void BlenderFileLoader::insertShapeNode(ObjectRen *obr, int id)
+{
+               VlakRen *vlr;
+       
+       float minBBox[3];
+       float maxBBox[3];
+       
+       NodeTransform *currentMesh = new NodeTransform;
+       NodeShape * shape;
+       
+       // Mesh *mesh = (Mesh *)ob->data;
+       //---------------------
+       // mesh => obr
+       
+       // builds the shape:
+       shape = new NodeShape;
+       
+       // We invert the matrix in order to be able to retrieve the shape's coordinates in its local coordinates system (origin is the iNode pivot)
+       // Lib3dsMatrix M;
+       // lib3ds_matrix_copy(M, mesh->matrix);
+       // lib3ds_matrix_inv(M);
+       //---------------------
+       // M => obr->ob->imat
+       
+       // We compute a normal per vertex and manages the smoothing of the shape:
+       // Lib3dsVector *normalL=(Lib3dsVector*)malloc(3*sizeof(Lib3dsVector)*mesh->faces);
+       // lib3ds_mesh_calculate_normals(mesh, normalL);
+       // mesh_calc_normals(mesh->mvert, mesh->totvert, mesh->mface, mesh->totface, NULL);
+       //---------------------
+       // already calculated and availabe in vlak ?    
+       
+       // We build the rep:
+       IndexedFaceSet *rep;
+       unsigned numFaces = 0;
+       for(int a=0; a < obr->totvlak; a++) {
+               if((a & 255)==0) vlr= obr->vlaknodes[a>>8].vlak;
+               else vlr++;
+
+               if(vlr->v4)
+                       numFaces += 2;
+               else
+                       numFaces++;
+       }
+       
+       unsigned vSize = 3*3*numFaces;
+       float *vertices = new float[vSize];
+       unsigned nSize = vSize;
+       float *normals = new float[nSize];
+       unsigned *numVertexPerFaces = new unsigned[numFaces];
+       vector<FrsMaterial> meshFrsMaterials;
+       
+       IndexedFaceSet::TRIANGLES_STYLE *faceStyle = new IndexedFaceSet::TRIANGLES_STYLE[numFaces];
+       unsigned i;
+       for (i = 0; i <numFaces; i++) {
+         faceStyle[i] = IndexedFaceSet::TRIANGLES;
+         numVertexPerFaces[i] = 3;
+       }
+       
+       unsigned viSize = 3*numFaces;
+       unsigned *VIndices = new unsigned[viSize];
+       unsigned niSize = viSize;
+       unsigned *NIndices = new unsigned[niSize];
+       unsigned *MIndices = new unsigned[viSize]; // Material Indices
+       
+       
+       float *pv = vertices;
+       float *pn = normals;
+       unsigned *pvi = VIndices;
+       unsigned *pni = NIndices;
+       unsigned *pmi = MIndices;
+       
+       unsigned currentIndex = 0;
+       unsigned currentMIndex = 0;
+       
+       FrsMaterial tmpMat;
+       
+       // we want to find the min and max coordinates as we build the rep. 
+       // We initialize the min and max values whith the first vertex.
+       //lib3ds_vector_transform(pvtmp, M, mesh->pointL[mesh->faceL[0].points[0]].pos);
+       float pvtmp[3];
+       pvtmp[0] = obr->vertnodes[0].vert->co[0];
+       pvtmp[1] = obr->vertnodes[0].vert->co[1];
+       pvtmp[2] = obr->vertnodes[0].vert->co[2];
+       
+       MTC_Mat4MulVecfl( obr->ob->imat, pvtmp);
+       
+       minBBox[0] = pvtmp[0];
+       maxBBox[0] = pvtmp[0];
+       minBBox[1] = pvtmp[1];
+       maxBBox[1] = pvtmp[1];
+       minBBox[2] = pvtmp[2];
+       maxBBox[2] = pvtmp[2];
+       
+       int p;
+       real vert[3][3];
+       real norm;
+       for(p=0; p < obr->totvlak; ++p) // we parse the faces of the mesh
+       {
+                       VertRen * fv[3];
+               
+                 // Lib3dsFace *f=&mesh->faceL[p];
+                 // Lib3dsMaterial *mat=0;
+                       if((p & 255)==0) vlr = obr->vlaknodes[p>>8].vlak;
+                       else vlr++;
+                       Material *mat = vlr->mat;
+       
+                       if (mat) 
+                       {
+                           tmpMat.setDiffuse( mat->r, mat->g, mat->b, mat->alpha );
+                           tmpMat.setSpecular( mat->specr, mat->specg, mat->specb, mat->spectra);
+                           float s = 1.0 * (mat->har + 1) / 4 ; // in Blender: [1;511] => in OpenGL: [0;128]
+                           if(s > 128.f)
+                             s = 128.f;
+                           tmpMat.setShininess(s);
+                       }
+         
+                       if(meshFrsMaterials.empty())
+                       {
+                               meshFrsMaterials.push_back(tmpMat);
+                       shape->setFrsMaterial(tmpMat);
+                       } else {
+                       // find if the material is aleady in the list
+                       unsigned i=0;
+                       bool found = false;
+               
+                       for(vector<FrsMaterial>::iterator it=meshFrsMaterials.begin(), itend=meshFrsMaterials.end();
+                               it!=itend;
+                               ++it){
+                                       if(*it == tmpMat){
+                                               currentMIndex = i;
+                                               found = true;
+                                               break;
+                                       }
+                                       ++i;
+                       }
+               
+                       if(!found){
+                               meshFrsMaterials.push_back(tmpMat);
+                               currentMIndex = meshFrsMaterials.size()-1;
+                       }
+                       }
+         
+                       fv[0] = vlr->v1;
+                       fv[1] = vlr->v2;
+                       fv[2] = vlr->v3;
+                       for(i=0; i<3; ++i) // we parse the vertices of the face f
+                       {
+                               unsigned j;
+
+                               //lib3ds_vector_transform(pv, M, mesh->pointL[f->points[i]].pos); //fills the cells of the pv array
+                               for(j=0; j<3; j++)
+                                       pv[j] = fv[i]->co[j];
+                               MTC_Mat4MulVecfl( obr->ob->imat, pv);
+
+                               for(j=0; j<3; j++) // we parse the xyz coordinates of the vertex i
+                               {
+                                       if(minBBox[j] > pv[j])
+                                       minBBox[j] = pv[j];
+
+                                       if(maxBBox[j] < pv[j])
+                                       maxBBox[j] = pv[j];
+
+                                       vert[i][j] = pv[j];
+                               }
+
+                               for(j=0; j<3; j++)
+                                       pn[j] = fv[i]->n[j];
+                       
+                               MTC_Mat4MulVecfl( obr->ob->imat, pn);
+
+                       //lib3ds_normal_transform(pn, M, normalL[3*p+i]); //fills the cells of the pv array
+                       //lib3ds_vector_normalize(pn);
+
+                               *pvi = currentIndex;
+                               *pni = currentIndex;
+                               *pmi = currentMIndex;
+
+                               currentIndex +=3;
+                               pv += 3;
+                               pn += 3;
+                               pvi++;
+                               pni++;
+                               pmi++;
+
+                       }
+
+                       for(i=0; i<3; i++)
+                       {
+                               norm = 0.0;
+                               
+                               for (unsigned j = 0; j < 3; j++)
+                                       norm += (vert[i][j] - vert[(i+1)%3][j])*(vert[i][j] - vert[(i+1)%3][j]);
+               
+                               norm = sqrt(norm);
+                               if(_minEdgeSize > norm)
+                                       _minEdgeSize = norm;
+                       }
+                       
+                       ++_numFacesRead;
+                       
+                       if(vlr->v4){
+                                               fv[0] = vlr->v1;
+                                               fv[1] = vlr->v3;
+                                               fv[2] = vlr->v4;
+                                               for(i=0; i<3; ++i) // we parse the vertices of the face f
+                                               {
+                                                       unsigned j;
+
+                                                       //lib3ds_vector_transform(pv, M, mesh->pointL[f->points[i]].pos); //fills the cells of the pv array
+                                                       for(j=0; j<3; j++)
+                                                               pv[j] = fv[i]->co[j];
+                                                       MTC_Mat4MulVecfl( obr->ob->imat, pv);
+
+                                                       for(j=0; j<3; j++) // we parse the xyz coordinates of the vertex i
+                                                       {
+                                                               if(minBBox[j] > pv[j])
+                                                               minBBox[j] = pv[j];
+
+                                                               if(maxBBox[j] < pv[j])
+                                                               maxBBox[j] = pv[j];
+
+                                                               vert[i][j] = pv[j];
+                                                       }
+
+                                                       for(j=0; j<3; j++)
+                                                               pn[j] = fv[i]->n[j];
+
+                                                       MTC_Mat4MulVecfl( obr->ob->imat, pn);
+
+                                               //lib3ds_normal_transform(pn, M, normalL[3*p+i]); //fills the cells of the pv array
+                                               //lib3ds_vector_normalize(pn);
+
+                                                       *pvi = currentIndex;
+                                                       *pni = currentIndex;
+                                                       *pmi = currentMIndex;
+
+                                                       currentIndex +=3;
+                                                       pv += 3;
+                                                       pn += 3;
+                                                       pvi++;
+                                                       pni++;
+                                                       pmi++;
+
+                                               }
+
+                                               for(i=0; i<3; i++)
+                                               {
+                                                       norm = 0.0;
+
+                                                       for (unsigned j = 0; j < 3; j++)
+                                                               norm += (vert[i][j] - vert[(i+1)%3][j])*(vert[i][j] - vert[(i+1)%3][j]);
+
+                                                       norm = sqrt(norm);
+                                                       if(_minEdgeSize > norm)
+                                                               _minEdgeSize = norm;
+                                               }
+                               
+                                       ++_numFacesRead;
+                       }
+
+       }
+       
+       // We might have several times the same vertex. We want a clean 
+       // shape with no real-vertex. Here, we are making a cleaning 
+       // pass.
+       real *cleanVertices = NULL;
+       unsigned   cvSize;
+       unsigned   *cleanVIndices = NULL;
+       
+       GeomCleaner::CleanIndexedVertexArray(
+         vertices, vSize, 
+         VIndices, viSize,
+         &cleanVertices, &cvSize, 
+         &cleanVIndices);
+       
+       real *cleanNormals = NULL;
+       unsigned   cnSize;
+       unsigned   *cleanNIndices = NULL;
+       
+       GeomCleaner::CleanIndexedVertexArray(
+         normals, nSize, 
+         NIndices, niSize,
+         &cleanNormals, &cnSize, 
+         &cleanNIndices);
+       
+       // format materials array
+       FrsMaterial** marray = new FrsMaterial*[meshFrsMaterials.size()];
+       unsigned mindex=0;
+       for(vector<FrsMaterial>::iterator m=meshFrsMaterials.begin(), mend=meshFrsMaterials.end();
+           m!=mend;
+           ++m){
+         marray[mindex] = new FrsMaterial(*m);
+         ++mindex;
+       }
+       // deallocates memory:
+       delete [] vertices;
+       delete [] normals;
+       delete [] VIndices;
+       delete [] NIndices;
+       
+       // Create the IndexedFaceSet with the retrieved attributes
+       rep = new IndexedFaceSet(cleanVertices, cvSize, 
+                                cleanNormals, cnSize,
+                                marray, meshFrsMaterials.size(),
+                                0, 0,
+                                numFaces, numVertexPerFaces, faceStyle,
+                                cleanVIndices, viSize,
+                                cleanNIndices, niSize,
+                                MIndices, viSize,
+                                0,0,
+                                0);
+       // sets the id of the rep
+       rep->setId(Id(id, 0));
+       
+       const BBox<Vec3r> bbox = BBox<Vec3r>(Vec3r(minBBox[0], minBBox[1], minBBox[2]), 
+                                            Vec3r(maxBBox[0], maxBBox[1], maxBBox[2]));
+       rep->setBBox(bbox);
+       shape->AddRep(rep);
+       
+       Matrix44r M = Matrix44r::identity();
+       currentMesh->setMatrix(M);
+       currentMesh->Translate(0,0,0);
+       
+       currentMesh->AddChild(shape);
+       _Scene->AddChild(currentMesh);
+       
+}
diff --git a/source/blender/freestyle/intern/scene_graph/BlenderFileLoader.h b/source/blender/freestyle/intern/scene_graph/BlenderFileLoader.h
new file mode 100644 (file)
index 0000000..2b038e0
--- /dev/null
@@ -0,0 +1,62 @@
+#ifndef  BLENDER_FILE_LOADER_H
+# define BLENDER_FILE_LOADER_H
+
+# include <string.h>              
+# include <float.h>
+
+# include "../system/FreestyleConfig.h"
+# include "NodeGroup.h"
+# include "NodeTransform.h"
+# include "NodeShape.h"
+# include "IndexedFaceSet.h"
+# include "../geometry/BBox.h"
+# include "../geometry/Geom.h"
+# include "../geometry/GeomCleaner.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+       #include "DNA_material_types.h"
+       #include "DNA_scene_types.h"
+       #include "render_types.h"
+       #include "renderdatabase.h"
+       
+       #include "BKE_mesh.h"
+       #include "BKE_scene.h"
+       #include "MTC_matrixops.h"
+       
+#ifdef __cplusplus
+}
+#endif
+
+
+class NodeGroup;
+
+class LIB_SCENE_GRAPH_EXPORT BlenderFileLoader
+{
+public:
+  /*! Builds a MaxFileLoader */
+       BlenderFileLoader(Render *re);
+  virtual ~BlenderFileLoader();
+
+  /*! Loads the 3D scene and returns a pointer to the scene root node */
+  NodeGroup * Load();
+
+  /*! Gets the number of read faces */
+  inline unsigned int numFacesRead() {return _numFacesRead;}
+
+  /*! Gets the smallest edge size read */
+  inline real minEdgeSize() {return _minEdgeSize;}
+
+protected:
+       void insertShapeNode(ObjectRen *obr, int id);
+
+protected:
+       Render* _re;
+  NodeGroup* _Scene;
+  unsigned _numFacesRead;
+  real _minEdgeSize;
+};
+
+#endif // BLENDER_FILE_LOADER_H
similarity index 87%
rename from source/blender/freestyle/intern/scene_graph/Material.h
rename to source/blender/freestyle/intern/scene_graph/FrsMaterial.h
index 64ae526ccb0b432ea0973ead95350c0cfac4d0db..1cbadab2bd3c268318015f28f7c6ab92ad0c3ca4 100755 (executable)
@@ -1,5 +1,5 @@
 //
-//  Filename         : Material.h
+//  Filename         : FrsMaterial.h
 //  Author(s)        : Stephane Grabli
 //  Purpose          : Class used to handle materials.
 //  Date of creation : 10/10/2002
 //
 ///////////////////////////////////////////////////////////////////////////////
 
-#ifndef  MATERIAL_H
-# define MATERIAL_H
+#ifndef  FRS_MATERIAL_H
+# define FRS_MATERIAL_H
 
 # include "../system/FreestyleConfig.h"
 
 /*! Class defining a material */
-class Material
+class FrsMaterial
 {
 public:
   /*! Default constructor */
-  inline Material();
+  inline FrsMaterial();
   /*! Builds a Material from its diffuse, ambiant, specular, emissive
    *  colors and a shininess coefficient.
    *    \param iDiffuse
@@ -51,16 +51,16 @@ public:
    *    \param iShininess
    *      The shininess coefficient.
    */
-  inline Material(const float *iDiffuse,
+  inline FrsMaterial(const float *iDiffuse,
                   const float *iAmbiant,
                   const float *iSpecular, 
                   const float *iEmission, 
                   const float iShininess);
 
   /*! Copy constructor */
-  inline Material(const Material& m);
+  inline FrsMaterial(const FrsMaterial& m);
   /*! Destructor */
-  virtual ~Material() {}
+  virtual ~FrsMaterial() {}
 
 
   /*! Returns the diffuse color as a 4 float array */
@@ -163,9 +163,9 @@ public:
   inline void setShininess(const float s);
 
   /* operators */
-  inline Material& operator=(const Material& m);
-  inline bool operator!=(const Material& m) const;
-  inline bool operator==(const Material& m) const;
+  inline FrsMaterial& operator=(const FrsMaterial& m);
+  inline bool operator!=(const FrsMaterial& m) const;
+  inline bool operator==(const FrsMaterial& m) const;
 
 private:
 
@@ -178,7 +178,7 @@ private:
 
 };
 
-Material::Material()
+FrsMaterial::FrsMaterial()
 {
   Ambient[0] = Ambient[1] = Ambient[2] = 0.2f;
   Ambient[3] = 1.f;
@@ -195,7 +195,7 @@ Material::Material()
   Shininess = 0.f;
 }
 
-Material::Material(const float *iDiffuse,
+FrsMaterial::FrsMaterial(const float *iDiffuse,
                    const float *iAmbiant,
                    const float *iSpecular, 
                    const float *iEmission, 
@@ -212,7 +212,7 @@ Material::Material(const float *iDiffuse,
   Shininess = iShininess;
 }
 
-Material::Material(const Material& m)
+FrsMaterial::FrsMaterial(const FrsMaterial& m)
 {
   for(int i=0; i<4; i++)
   {
@@ -225,7 +225,7 @@ Material::Material(const Material& m)
   Shininess = m.shininess();
 }
 
-void Material::setDiffuse(const float r, const float g, const float b, const float a)
+void FrsMaterial::setDiffuse(const float r, const float g, const float b, const float a)
 {
   Diffuse[0] = r;
   Diffuse[1] = g;
@@ -233,7 +233,7 @@ void Material::setDiffuse(const float r, const float g, const float b, const flo
   Diffuse[3] = a;
 }
 
-void Material::setSpecular(const float r, const float g, const float b, const float a)
+void FrsMaterial::setSpecular(const float r, const float g, const float b, const float a)
 {
   Specular[0] = r;
   Specular[1] = g;
@@ -241,7 +241,7 @@ void Material::setSpecular(const float r, const float g, const float b, const fl
   Specular[3] = a;
 }
   
-void Material::setAmbient(const float r, const float g, const float b, const float a)
+void FrsMaterial::setAmbient(const float r, const float g, const float b, const float a)
 {
   Ambient[0] = r;
   Ambient[1] = g;
@@ -249,7 +249,7 @@ void Material::setAmbient(const float r, const float g, const float b, const flo
   Ambient[3] = a;
 }
 
-void Material::setEmission(const float r, const float g, const float b, const float a)
+void FrsMaterial::setEmission(const float r, const float g, const float b, const float a)
 {
   Emission[0] = r;
   Emission[1] = g;
@@ -257,12 +257,12 @@ void Material::setEmission(const float r, const float g, const float b, const fl
   Emission[3] = a;
 }
 
-void Material::setShininess(const float s)
+void FrsMaterial::setShininess(const float s)
 {
   Shininess = s;
 }
 
-Material& Material::operator=(const Material& m)
+FrsMaterial& FrsMaterial::operator=(const FrsMaterial& m)
 {
   for(int i=0; i<4; i++)
   {
@@ -277,7 +277,7 @@ Material& Material::operator=(const Material& m)
   return *this;
 }
 
-bool Material::operator!=(const Material& m) const
+bool FrsMaterial::operator!=(const FrsMaterial& m) const
 {
   if(Shininess != m.shininess())
     return true;
@@ -296,9 +296,9 @@ bool Material::operator!=(const Material& m) const
   return false;
 }
 
-bool Material::operator==(const Material& m) const
+bool FrsMaterial::operator==(const FrsMaterial& m) const
 {
   return (!((*this)!=m));
 }
 
-#endif // MATERIAL_H
+#endif // FRS_MATERIAL_H
index 2604484ecd769463974f7452cc92001e14121d09..98872c6c8eaead78e60bdae5afde7e050db2e082 100755 (executable)
@@ -26,7 +26,7 @@ IndexedFaceSet::IndexedFaceSet()
 {
   _Vertices = NULL;
   _Normals = NULL;
-  _Materials = 0;
+  _FrsMaterials = 0;
   _TexCoords = 0;
   _VSize = 0;
   _NSize = 0;
@@ -48,7 +48,7 @@ IndexedFaceSet::IndexedFaceSet()
 
 IndexedFaceSet::IndexedFaceSet( real *iVertices, unsigned iVSize, 
                                 real *iNormals, unsigned iNSize,
-                                Material **iMaterials, unsigned iMSize,
+                                FrsMaterial **iMaterials, unsigned iMSize,
                                 real *iTexCoords, unsigned iTSize,
                                 unsigned iNumFaces, unsigned *iNumVertexPerFace, TRIANGLES_STYLE *iFaceStyle,
                                 unsigned *iVIndices, unsigned iVISize,
@@ -69,11 +69,11 @@ IndexedFaceSet::IndexedFaceSet( real *iVertices, unsigned iVSize,
     memcpy(_Normals, iNormals, iNSize*sizeof(real));
 
     _MSize = iMSize;
-    _Materials = 0;
+    _FrsMaterials = 0;
        if(iMaterials){
-               _Materials = new Material*[_MSize];
+               _FrsMaterials = new FrsMaterial*[_MSize];
                for(unsigned i=0; i<_MSize; ++i)
-                       _Materials[i] = new Material(*(iMaterials[i]));
+                       _FrsMaterials[i] = new FrsMaterial(*(iMaterials[i]));
        }
     _TSize = iTSize;
     _TexCoords = 0;
@@ -119,9 +119,9 @@ IndexedFaceSet::IndexedFaceSet( real *iVertices, unsigned iVSize,
     _Normals = iNormals;
 
     _MSize = iMSize;
-               _Materials = 0;
+               _FrsMaterials = 0;
                if(iMaterials)
-                       _Materials = iMaterials;
+                       _FrsMaterials = iMaterials;
     
     _TSize = iTSize;
     _TexCoords = iTexCoords;
@@ -161,12 +161,12 @@ IndexedFaceSet::IndexedFaceSet( const IndexedFaceSet& iBrother)
 
   _MSize = iBrother.msize();
        if(_MSize){
-               _Materials = new Material*[_MSize];
+               _FrsMaterials = new FrsMaterial*[_MSize];
                for(unsigned i=0; i<_MSize; ++i){
-                       _Materials[i] = new Material(*(iBrother._Materials[i]));
+                       _FrsMaterials[i] = new FrsMaterial(*(iBrother._FrsMaterials[i]));
                }
        }else{
-               _Materials = 0;
+               _FrsMaterials = 0;
        }
 
     _TSize = iBrother.tsize();
@@ -223,12 +223,12 @@ IndexedFaceSet::~IndexedFaceSet()
     _Normals = NULL;
   }
 
-  if(NULL != _Materials)
+  if(NULL != _FrsMaterials)
   {
     for(unsigned i=0; i<_MSize; ++i)
-      delete _Materials[i];
-    delete [] _Materials;
-    _Materials = NULL;
+      delete _FrsMaterials[i];
+    delete [] _FrsMaterials;
+    _FrsMaterials = NULL;
   }
 
   if(NULL != _TexCoords)
index ce0afcd2fd69f98b92ae939d9f6a243b6ec90fd4..41db4db4c42031ce6daf0e15ed955f3ed37409c1 100755 (executable)
@@ -106,7 +106,7 @@ public:
   */
   IndexedFaceSet( real *iVertices, unsigned iVSize, 
                  real *iNormals, unsigned iNSize,
-                  Material **iMaterials, unsigned iMSize,
+                  FrsMaterial **iMaterials, unsigned iMSize,
                   real *iTexCoords, unsigned iTSize,
                  unsigned iNumFaces, unsigned *iNumVertexPerFace, TRIANGLES_STYLE *iFaceStyle,
                  unsigned *iVIndices, unsigned iVISize,
@@ -122,7 +122,7 @@ public:
        void swap(IndexedFaceSet& ioOther){
                std::swap(_Vertices, ioOther._Vertices);
                std::swap(_Normals, ioOther._Normals);
-               std::swap(_Materials, ioOther._Materials);
+               std::swap(_FrsMaterials, ioOther._FrsMaterials);
         std::swap(_TexCoords, ioOther._TexCoords);
 
                std::swap(_VSize, ioOther._VSize);
@@ -171,7 +171,7 @@ public:
   /*! Accessors */
   virtual const real * vertices() const {return _Vertices;}
   virtual const real * normals() const {return _Normals;}
-  virtual const Material*const* materials() const {return _Materials;}
+  virtual const FrsMaterial*const* frs_materials() const {return _FrsMaterials;}
   virtual const real* texCoords() const {return _TexCoords;}
   virtual const unsigned vsize() const {return _VSize;}
   virtual const unsigned nsize() const {return _NSize;}
@@ -193,7 +193,7 @@ public:
 protected:
   real *_Vertices;
   real *_Normals;
-  Material** _Materials;
+  FrsMaterial** _FrsMaterials;
   real *_TexCoords;
   
   unsigned _VSize;
index a6d3b8f872136bd3cfdc1c33c71060c811c1a347..b32fb993c94eddc574f81f3f012702ce145722ca 100755 (executable)
@@ -174,7 +174,7 @@ void MaxFileLoader::RenderNode(Lib3dsNode *iNode)
       unsigned nSize = vSize;
       float *normals = new float[nSize];
       unsigned *numVertexPerFaces = new unsigned[numFaces];
-      vector<Material> meshMaterials;
+      vector<FrsMaterial> meshFrsMaterials;
 
       IndexedFaceSet::TRIANGLES_STYLE *faceStyle = new IndexedFaceSet::TRIANGLES_STYLE[numFaces];
       unsigned i;
@@ -199,7 +199,7 @@ void MaxFileLoader::RenderNode(Lib3dsNode *iNode)
       unsigned currentIndex = 0;
       unsigned currentMIndex = 0;
 
-      Material tmpMat;
+      FrsMaterial tmpMat;
       
       // we want to find the min and max coordinates as we build the rep. 
       // We initialize the min and max values whith the first vertex.
@@ -232,14 +232,14 @@ void MaxFileLoader::RenderNode(Lib3dsNode *iNode)
           tmpMat.setShininess(s);
         }
         
-        if(meshMaterials.empty()){
-          meshMaterials.push_back(tmpMat);
-          shape->setMaterial(tmpMat);
+        if(meshFrsMaterials.empty()){
+          meshFrsMaterials.push_back(tmpMat);
+          shape->setFrsMaterial(tmpMat);
         }else{
           // find if the material is aleady in the list
           unsigned i=0;
           bool found = false;
-          for(vector<Material>::iterator it=meshMaterials.begin(), itend=meshMaterials.end();
+          for(vector<FrsMaterial>::iterator it=meshFrsMaterials.begin(), itend=meshFrsMaterials.end();
           it!=itend;
           ++it){
             if(*it == tmpMat){
@@ -250,8 +250,8 @@ void MaxFileLoader::RenderNode(Lib3dsNode *iNode)
             ++i;
           }
           if(!found){
-            meshMaterials.push_back(tmpMat);
-            currentMIndex = meshMaterials.size()-1;
+            meshFrsMaterials.push_back(tmpMat);
+            currentMIndex = meshFrsMaterials.size()-1;
           }
         }
         
@@ -271,8 +271,8 @@ void MaxFileLoader::RenderNode(Lib3dsNode *iNode)
             vert[i][j] = pv[j];
           }
           
-          for(j=0; j<3; j++)
-            pn[j] = f->normal[j];
+          // for(j=0; j<3; j++)
+          //     pn[j] = f->normal[j];
 
           lib3ds_normal_transform(pn, M, normalL[3*p+i]); //fills the cells of the pv array
           //lib3ds_vector_normalize(pn);
@@ -331,12 +331,12 @@ void MaxFileLoader::RenderNode(Lib3dsNode *iNode)
         &cleanNIndices);
 
       // format materials array
-      Material** marray = new Material*[meshMaterials.size()];
+      FrsMaterial** marray = new FrsMaterial*[meshFrsMaterials.size()];
       unsigned mindex=0;
-      for(vector<Material>::iterator m=meshMaterials.begin(), mend=meshMaterials.end();
+      for(vector<FrsMaterial>::iterator m=meshFrsMaterials.begin(), mend=meshFrsMaterials.end();
           m!=mend;
           ++m){
-        marray[mindex] = new Material(*m);
+        marray[mindex] = new FrsMaterial(*m);
         ++mindex;
       }
       // deallocates memory:
@@ -348,7 +348,7 @@ void MaxFileLoader::RenderNode(Lib3dsNode *iNode)
       // Create the IndexedFaceSet with the retrieved attributes
       rep = new IndexedFaceSet(cleanVertices, cvSize, 
                                cleanNormals, cnSize,
-                               marray, meshMaterials.size(),
+                               marray, meshFrsMaterials.size(),
                                0, 0,
                                numFaces, numVertexPerFaces, faceStyle,
                                cleanVIndices, viSize,
index 2012ef83b9fdf514fd96b81095bc6676ef18ff6b..9083c852d36ff0431860a840038aabceab4cc3c3 100755 (executable)
@@ -41,7 +41,7 @@ NodeShape::~NodeShape()
 void NodeShape::accept(SceneVisitor& v) {
   v.visitNodeShape(*this);
   
-  v.visitMaterial(_Material);
+  v.visitFrsMaterial(_FrsMaterial);
  
   v.visitNodeShapeBefore(*this);
   vector<Rep *>::iterator rep;
index 34b049bfeb5b27f8a1a389770477f7143950fa43..9849d4661b83e8d388d90068478e22690e40d7f8 100755 (executable)
@@ -37,7 +37,7 @@
 # include "Rep.h"
 # include "../geometry/BBox.h"
 # include "../geometry/Geom.h"
-# include "Material.h"
+# include "FrsMaterial.h"
 
 using namespace std;
 using namespace Geometry;
@@ -71,11 +71,11 @@ public:
   virtual void accept(SceneVisitor& v);
 
   /*! Sets the shape material */
-  inline void setMaterial(const Material& iMaterial) { _Material = iMaterial; }
+  inline void setFrsMaterial(const FrsMaterial& iMaterial) { _FrsMaterial = iMaterial; }
 
   /*! accessors */
   /*! returns the shape's material */
-  inline Material& material() { return _Material; }
+  inline FrsMaterial& frs_material() { return _FrsMaterial; }
   inline const vector<Rep*>& shapes() {return _Shapes;}
 
 private:
@@ -83,7 +83,7 @@ private:
   vector<Rep*> _Shapes;
 
   /*! Shape Material */
-  Material _Material;
+  FrsMaterial _FrsMaterial;
 };
 
 #endif // NODESHAPE_H
index 2d0205308b9db5b8c9d8a2a2aaffbba9b9a3b092..94068983596e80e83e41d1553d672786e99ba994 100755 (executable)
@@ -24,7 +24,7 @@
 
 void OrientedLineRep::accept(SceneVisitor& v) {
   Rep::accept(v);
-  if(!material())
+  if(!frs_material())
     v.visitOrientedLineRep(*this);
   else
     v.visitLineRep(*this);
index ee5f2942abf090333099f118d5f7e85e477a7b44..6b213b01ba7d930b5e34645464c5223a0b5ddba0 100755 (executable)
@@ -36,7 +36,7 @@
 # include "../geometry/BBox.h"
 # include "../geometry/Geom.h"
 # include "../system/Precision.h"
-# include "Material.h"
+# include "FrsMaterial.h"
 # include "../system/Id.h"
 
 using namespace Geometry;
@@ -45,33 +45,33 @@ class LIB_SCENE_GRAPH_EXPORT Rep : public BaseObject
 {
 public:
   
-  inline Rep() : BaseObject() {_Id = 0; _Material=0;}
+  inline Rep() : BaseObject() {_Id = 0; _FrsMaterial=0;}
   inline Rep(const Rep& iBrother)
     : BaseObject()
   {
     _Id = iBrother._Id;
-    if(0 == iBrother._Material)
-      _Material = 0;
+    if(0 == iBrother._FrsMaterial)
+      _FrsMaterial = 0;
     else
-      _Material = new Material(*(iBrother._Material));
+      _FrsMaterial = new FrsMaterial(*(iBrother._FrsMaterial));
 
     _BBox = iBrother.bbox();
   }
        inline void swap(Rep& ioOther){
                std::swap(_BBox,ioOther._BBox);
                std::swap(_Id, ioOther._Id);
-               std::swap(_Material,ioOther._Material);
+               std::swap(_FrsMaterial,ioOther._FrsMaterial);
        }
        Rep& operator=(const Rep& iBrother){
                if(&iBrother != this){
                        _Id = iBrother._Id;
-                       if(0 == iBrother._Material)
-                               _Material = 0;
+                       if(0 == iBrother._FrsMaterial)
+                               _FrsMaterial = 0;
                        else{
-                               if(_Material == 0){
-                                       _Material = new Material(*iBrother._Material);
+                               if(_FrsMaterial == 0){
+                                       _FrsMaterial = new FrsMaterial(*iBrother._FrsMaterial);
                                }else{
-                                       (*_Material)=(*(iBrother._Material));
+                                       (*_FrsMaterial)=(*(iBrother._FrsMaterial));
                                }
                                _BBox = iBrother.bbox();
                        }
@@ -80,10 +80,10 @@ public:
        }
   virtual ~Rep() 
   {
-    if(0 != _Material)
+    if(0 != _FrsMaterial)
     {
-      delete _Material;
-      _Material = 0;
+      delete _FrsMaterial;
+      _FrsMaterial = 0;
     }
   }
 
@@ -92,8 +92,8 @@ public:
    *  inherited classes
    */
   virtual void accept(SceneVisitor& v) {
-    if(_Material)
-      v.visitMaterial(*_Material);
+    if(_FrsMaterial)
+      v.visitFrsMaterial(*_FrsMaterial);
     v.visitRep(*this);
   }
 
@@ -108,20 +108,20 @@ public:
   /*! Returns the rep bounding box */
   virtual const BBox<Vec3r>& bbox() const {return _BBox;}
   inline Id getId() const {return _Id;}
-  inline const Material * material() const {return _Material;}
+  inline const FrsMaterial * frs_material() const {return _FrsMaterial;}
 
   /*! Sets the Rep bounding box */
   virtual void setBBox(const BBox<Vec3r>& iBox) {_BBox = iBox;}
   inline void setId(const Id& id) {_Id = id;}
-  inline void setMaterial(const Material& iMaterial) 
+  inline void setFrsMaterial(const FrsMaterial& iMaterial) 
   {
-    _Material = new Material(iMaterial);
+    _FrsMaterial = new FrsMaterial(iMaterial);
   }
 
 private:
   BBox<Vec3r> _BBox;
   Id _Id;
-  Material *_Material;
+  FrsMaterial *_FrsMaterial;
 };
 
 #endif // REP_H
index c57bd2e0f6ec90ff6df14718a6fae49e7e7f266d..5f67b4b44aa660c252b035c437694102a4857ba6 100755 (executable)
@@ -60,7 +60,7 @@ class TriangleRep;
 class VertexRep;
 class IndexedFaceSet;
 class DrawingStyle;
-class Material;
+class FrsMaterial;
 
 class LIB_SCENE_GRAPH_EXPORT SceneVisitor
 {
@@ -92,7 +92,7 @@ public:
   VISIT_COMPLETE_DEF(VertexRep)
   VISIT_COMPLETE_DEF(IndexedFaceSet)
   VISIT_COMPLETE_DEF(DrawingStyle)
-  VISIT_COMPLETE_DEF(Material)
+  VISIT_COMPLETE_DEF(FrsMaterial)
 };
 
 #endif // SCENEVISITOR_H
index 7fbe7e701e960c98707bde90fdaedf7fcc7edd92..ee27e92fa37679f9e9a67a9097bbf8273b59bf53 100755 (executable)
@@ -33,7 +33,7 @@
 # include <deque>
 # include "../system/BaseIterator.h"
 # include "../geometry/Geom.h"
-//# include "../scene_graph/Material.h"
+//# include "../scene_graph/FrsMaterial.h"
 # include "../view_map/Silhouette.h"
 # include "../view_map/SilhouetteGeomEngine.h"
 # include "../view_map/Interface0D.h"
@@ -234,7 +234,7 @@ public:
   inline const Vec3r& point2d() const {return _Point2d;}
   inline const Vec3r& point3d() const {return _Point3d;}
    Vec3r normal() const ;
-   //Material material() const ;
+   //FrsMaterial material() const ;
   // Id shape_id() const ;
    const SShape * shape() const ;
   // float shape_importance() const ;
@@ -392,7 +392,7 @@ public:
    //Vec3r  orientation3d(int iCombination = 0) const ;
   // real curvature2d(point_iterator it) const {return (*it)->curvature2d();}
   // real curvature2d(int iCombination = 0) const ;
-   //Material material() const ;
+   //FrsMaterial material() const ;
    //int qi() const ;
    //   occluder_container::const_iterator occluders_begin() const ;
    //   occluder_container::const_iterator occluders_end() const ;
index 279655c22b799bb022570753b9fc915b87fec710..465e56627749811754641b97435f5218a3078b28 100755 (executable)
@@ -48,8 +48,8 @@ LineRep* StrokeTesselator::Tesselate(Stroke *iStroke)
   }
   else
   {
-    if(_overloadMaterial)
-      line->setMaterial(_Material);
+    if(_overloadFrsMaterial)
+      line->setFrsMaterial(_FrsMaterial);
 
     line->setStyle(LineRep::LINE_STRIP);
 
@@ -75,7 +75,7 @@ NodeGroup* StrokeTesselator::Tesselate(StrokeVertexIterator begin, StrokeVertexI
   NodeShape *tshape = new NodeShape;
   group->AddChild(tshape);
   //tshape->material().setDiffuse(0.f, 0.f, 0.f, 1.f);
-  tshape->setMaterial(_Material);
+  tshape->setFrsMaterial(_FrsMaterial);
 
   for(StrokeVertexIterator c=begin, cend=end;
   c!=cend;
index eaeb73504c97b1bbcb1f9443ef747ce4de8f6a97..1de281734cd473eb32d8b3ed4ecba2ed755e56bb 100755 (executable)
@@ -38,7 +38,7 @@ class StrokeTesselator
 {
 public:
 
-  inline StrokeTesselator() {_Material.setDiffuse(0,0,0,1);_overloadMaterial=false;}
+  inline StrokeTesselator() {_FrsMaterial.setDiffuse(0,0,0,1);_overloadFrsMaterial=false;}
   virtual ~StrokeTesselator() {}
 
   /*! Builds a line rep contained from a Stroke
@@ -54,13 +54,13 @@ public:
 
   
   
-  inline void setMaterial(const Material& iMaterial) {_Material=iMaterial;_overloadMaterial=true;}
-  inline const Material& material() const {return _Material;}
+  inline void setFrsMaterial(const FrsMaterial& iMaterial) {_FrsMaterial=iMaterial;_overloadFrsMaterial=true;}
+  inline const FrsMaterial& frs_material() const {return _FrsMaterial;}
 
 private:
 
-  Material _Material;
-  bool _overloadMaterial;
+  FrsMaterial _FrsMaterial;
+  bool _overloadFrsMaterial;
 };
 
 #endif // STROKETESSELATOR_H
index c868510624cc608fdf230aec24ab7bd0dfded800..1bd6d6f46f10b8cd6e7303e40e6fe1b0e7f8eecb 100755 (executable)
@@ -288,17 +288,17 @@ namespace Functions0D {
     return n;
   }
 
-  Material MaterialF0D::operator()(Interface0DIterator& iter) {
+  FrsMaterial MaterialF0D::operator()(Interface0DIterator& iter) {
     FEdge *fe1, *fe2;
     getFEdges(iter,fe1,fe2);
     
     if(fe1 == 0)
       getFEdges(iter, fe1, fe2);
-    Material mat;
+    FrsMaterial mat;
     if(fe1->isSmooth())
-      mat = ((FEdgeSmooth*)fe1)->material();
+      mat = ((FEdgeSmooth*)fe1)->frs_material();
     else
-      mat = ((FEdgeSharp*)fe1)->bMaterial();
+      mat = ((FEdgeSharp*)fe1)->bFrsMaterial();
     //    const SShape * sshape = getShapeF0D(iter);
     //    return sshape->material();
     return mat;
index 9543e8c34a68ef1cc8a4f1450fa0ed2afc0da264..24d2edac0946f6a853c42d2fc673fb29581fc7ae 100755 (executable)
@@ -34,7 +34,7 @@
 # include "Interface0D.h"
 # include "../geometry/Geom.h"
 # include "../system/Exception.h"
-# include "../scene_graph/Material.h"
+# include "../scene_graph/FrsMaterial.h"
 # include <set>
 # include <vector>
 class FEdge;
@@ -350,7 +350,7 @@ namespace Functions0D {
    *  to deal with this cases in a specific way should implement
    *  its own getMaterial functor.
    */
-  class LIB_VIEW_MAP_EXPORT MaterialF0D : public UnaryFunction0D<Material>
+  class LIB_VIEW_MAP_EXPORT MaterialF0D : public UnaryFunction0D<FrsMaterial>
   {
   public:
     /*! Returns the string "MaterialF0D"*/
@@ -358,7 +358,7 @@ namespace Functions0D {
       return "MaterialF0D";
     }
     /*! the () operator.*/
-    Material operator()(Interface0DIterator& iter);
+    FrsMaterial operator()(Interface0DIterator& iter);
   };
 
   // ShapeIdF0D
index db4f82d369e079210188465bc4f7f1c0df2553e7..7a7d0a51d4b204bf34660d31ddf3d567d938f407 100755 (executable)
@@ -349,12 +349,12 @@ real FEdge::z_discontinuity() const
 //{
 //  return _VertexA->shape()->material();
 //}
-const Material& FEdgeSharp::aMaterial() const {
-  return _VertexA->shape()->material(_aMaterialIndex);
+const FrsMaterial& FEdgeSharp::aFrsMaterial() const {
+  return _VertexA->shape()->frs_material(_aFrsMaterialIndex);
 }
 
-const Material& FEdgeSharp::bMaterial() const {
-  return _VertexA->shape()->material(_bMaterialIndex);
+const FrsMaterial& FEdgeSharp::bFrsMaterial() const {
+  return _VertexA->shape()->frs_material(_bFrsMaterialIndex);
 }
 
                  /**********************************/
@@ -365,6 +365,6 @@ const Material& FEdgeSharp::bMaterial() const {
                   /*                                */
                   /**********************************/
 
-const Material& FEdgeSmooth::material() const {
-  return _VertexA->shape()->material(_MaterialIndex);
+const FrsMaterial& FEdgeSmooth::frs_material() const {
+  return _VertexA->shape()->frs_material(_FrsMaterialIndex);
 }
index 14d934c6791aa63be470e5e756c3fe99fda045c0..6b9ebde57076d2c42cc37d0174d0ca48fbaa98e4 100755 (executable)
@@ -38,7 +38,7 @@
 # include "../system/FreestyleConfig.h"
 # include "../geometry/Geom.h"
 # include "../geometry/BBox.h"
-# include "../scene_graph/Material.h"
+# include "../scene_graph/FrsMaterial.h"
 # include "../geometry/Polygon.h"
 # include "../system/Exception.h"
 # include "Interface0D.h"
@@ -785,24 +785,24 @@ class LIB_VIEW_MAP_EXPORT FEdgeSharp : public FEdge
 protected:
   Vec3r _aNormal; // When following the edge, normal of the right face
   Vec3r _bNormal; // When following the edge, normal of the left face
-  unsigned _aMaterialIndex;
-  unsigned _bMaterialIndex;
+  unsigned _aFrsMaterialIndex;
+  unsigned _bFrsMaterialIndex;
   
 public:
   /*! Default constructor. */
   inline FEdgeSharp() : FEdge(){
-    _aMaterialIndex = _bMaterialIndex = 0;
+    _aFrsMaterialIndex = _bFrsMaterialIndex = 0;
   }
   /*! Builds an FEdgeSharp going from vA to vB. */ 
   inline FEdgeSharp(SVertex *vA, SVertex *vB) : FEdge(vA, vB){
-    _aMaterialIndex = _bMaterialIndex = 0;
+    _aFrsMaterialIndex = _bFrsMaterialIndex = 0;
   }
   /*! Copy constructor. */
   inline FEdgeSharp(FEdgeSharp& iBrother) : FEdge(iBrother){
     _aNormal = iBrother._aNormal;
     _bNormal = iBrother._bNormal;
-    _aMaterialIndex = iBrother._aMaterialIndex;
-    _bMaterialIndex = iBrother._bMaterialIndex;
+    _aFrsMaterialIndex = iBrother._aFrsMaterialIndex;
+    _bFrsMaterialIndex = iBrother._bFrsMaterialIndex;
   }
   /*! Destructor. */
   virtual ~FEdgeSharp() {}
@@ -824,29 +824,29 @@ public:
    *  right of the FEdge. If this FEdge is a border,
    *  it has no Face on its right and therefore, no material.
    */
-  inline unsigned aMaterialIndex() const {return _aMaterialIndex;}
+  inline unsigned aFrsMaterialIndex() const {return _aFrsMaterialIndex;}
   /*! Returns the material of the face lying on the
    *  right of the FEdge. If this FEdge is a border,
    *  it has no Face on its right and therefore, no material.
    */
-  const Material& aMaterial() const ;
+  const FrsMaterial& aFrsMaterial() const ;
   /*! Returns the index of the material of the face lying on the
    *  left of the FEdge.
    */
-  inline unsigned bMaterialIndex() const {return _bMaterialIndex;}
+  inline unsigned bFrsMaterialIndex() const {return _bFrsMaterialIndex;}
   /*! Returns the  material of the face lying on the
    *  left of the FEdge.
    */
-  const Material& bMaterial() const ;
+  const FrsMaterial& bFrsMaterial() const ;
 
   /*! Sets the normal to the face lying on the right of the FEdge. */
   inline void setNormalA(const Vec3r& iNormal) {_aNormal = iNormal;}
   /*! Sets the normal to the face lying on the left of the FEdge. */ 
   inline void setNormalB(const Vec3r& iNormal) {_bNormal = iNormal;}
   /*! Sets the index of the material lying on the right of the FEdge.*/
-  inline void setaMaterialIndex(unsigned i) {_aMaterialIndex = i;}
+  inline void setaFrsMaterialIndex(unsigned i) {_aFrsMaterialIndex = i;}
   /*! Sets the index of the material lying on the left of the FEdge.*/
-  inline void setbMaterialIndex(unsigned i) {_bMaterialIndex = i;}
+  inline void setbFrsMaterialIndex(unsigned i) {_bFrsMaterialIndex = i;}
   
 };
 
@@ -858,7 +858,7 @@ class LIB_VIEW_MAP_EXPORT FEdgeSmooth : public FEdge
 {
 protected:
   Vec3r _Normal;
-  unsigned _MaterialIndex;
+  unsigned _FrsMaterialIndex;
   //  bool _hasVisibilityPoint;
   //  Vec3r _VisibilityPointA;  // The edge on which the visibility will be computed represented 
   //  Vec3r _VisibilityPointB;  // using its 2 extremity points A and B
@@ -868,13 +868,13 @@ public:
   /*! Default constructor. */
   inline FEdgeSmooth() : FEdge(){
     _Face=0;
-    _MaterialIndex = 0;
+    _FrsMaterialIndex = 0;
     _isSmooth = true;
   }
   /*! Builds an FEdgeSmooth going from vA to vB. */  
   inline FEdgeSmooth(SVertex *vA, SVertex *vB) : FEdge(vA, vB){
     _Face=0;
-    _MaterialIndex = 0;
+    _FrsMaterialIndex = 0;
     _isSmooth = true;
 
   }
@@ -882,7 +882,7 @@ public:
   inline FEdgeSmooth(FEdgeSmooth& iBrother) : FEdge(iBrother){
     _Normal = iBrother._Normal;
     _Face = iBrother._Face;
-    _MaterialIndex = iBrother._MaterialIndex;
+    _FrsMaterialIndex = iBrother._FrsMaterialIndex;
     _isSmooth = true;
   }
   /*! Destructor. */
@@ -897,15 +897,15 @@ public:
   /*! Returns the normal to the Face it is running accross. */
   inline const Vec3r& normal() {return _Normal;}
   /*! Returns the index of the material of the face it is running accross. */
-  inline unsigned materialIndex() const {return _MaterialIndex;}
+  inline unsigned frs_materialIndex() const {return _FrsMaterialIndex;}
   /*! Returns the material of the face it is running accross. */
-  const Material& material() const ;
+  const FrsMaterial& frs_material() const ;
 
   inline void setFace(void * iFace) {_Face = iFace;}
   /*! Sets the normal to the Face it is running accross. */
   inline void setNormal(const Vec3r& iNormal) {_Normal = iNormal;}
   /*! Sets the index of the material of the face it is running accross. */
-  inline void setMaterialIndex(unsigned i) {_MaterialIndex = i;}
+  inline void setFrsMaterialIndex(unsigned i) {_FrsMaterialIndex = i;}
 };
                   /**********************************/
                   /*                                */
@@ -927,7 +927,7 @@ private:
   vector<FEdge*>   _edgesList;     // list of all edges
   Id _Id;
   BBox<Vec3r> _BBox;
-  vector<Material> _Materials;  
+  vector<FrsMaterial> _FrsMaterials;  
 
   float _importance;
 
@@ -952,7 +952,7 @@ public:
     userdata = 0;
     _Id = iBrother._Id;
     _BBox = iBrother.bbox();
-    _Materials = iBrother._Materials;
+    _FrsMaterials = iBrother._FrsMaterials;
 
     _importance = iBrother._importance;
 
@@ -1199,13 +1199,13 @@ public:
         newEdge = new FEdgeSmooth((*sv), svB);
         FEdgeSmooth * se = dynamic_cast<FEdgeSmooth*>(newEdge);
         FEdgeSmooth * fes = dynamic_cast<FEdgeSmooth*>(fe);
-        se->setMaterialIndex(fes->materialIndex());
+        se->setFrsMaterialIndex(fes->frs_materialIndex());
       }else{
         newEdge = new FEdgeSharp((*sv), svB);
         FEdgeSharp * se = dynamic_cast<FEdgeSharp*>(newEdge);
         FEdgeSharp * fes = dynamic_cast<FEdgeSharp*>(fe);
-        se->setaMaterialIndex(fes->aMaterialIndex());
-        se->setbMaterialIndex(fes->bMaterialIndex());
+        se->setaFrsMaterialIndex(fes->aFrsMaterialIndex());
+        se->setbFrsMaterialIndex(fes->bFrsMaterialIndex());
       }
         
       newEdge->setNature((fe)->getNature());
@@ -1264,13 +1264,13 @@ public:
         newEdge = new FEdgeSmooth(ioNewVertex, B);
         FEdgeSmooth * se = dynamic_cast<FEdgeSmooth*>(newEdge);
         FEdgeSmooth * fes = dynamic_cast<FEdgeSmooth*>(ioEdge);
-        se->setMaterialIndex(fes->materialIndex());
+        se->setFrsMaterialIndex(fes->frs_materialIndex());
       }else{
         newEdge = new FEdgeSharp(ioNewVertex, B);
         FEdgeSharp * se = dynamic_cast<FEdgeSharp*>(newEdge);
         FEdgeSharp * fes = dynamic_cast<FEdgeSharp*>(ioEdge);
-        se->setaMaterialIndex(fes->aMaterialIndex());
-        se->setbMaterialIndex(fes->bMaterialIndex());
+        se->setaFrsMaterialIndex(fes->aFrsMaterialIndex());
+        se->setbFrsMaterialIndex(fes->bFrsMaterialIndex());
       }
       newEdge->setNature(ioEdge->getNature());
       
@@ -1399,9 +1399,9 @@ public:
   /*! Returns the bounding box of the shape. */
   inline const BBox<Vec3r>& bbox() {return _BBox;}
   /*! Returns the ith material of the shape. */
-  inline const Material& material(unsigned i) const {return _Materials[i];}
+  inline const FrsMaterial& frs_material(unsigned i) const {return _FrsMaterials[i];}
   /*! Returns the list of materials of the Shape. */
-  inline const vector<Material>& materials() const {return _Materials;}
+  inline const vector<FrsMaterial>& frs_materials() const {return _FrsMaterials;}
   inline ViewShape * viewShape() {return _ViewShape;}
   inline float importance() const {return _importance;}
   /*! Returns the Id of the Shape. */
@@ -1411,7 +1411,7 @@ public:
   /*! Sets the Id of the shape.*/
   inline void setId(Id id) {_Id = id;}
   /*! Sets the list of materials for the shape */
-  inline void setMaterials(const vector<Material>& iMaterials) {_Materials = iMaterials;}
+  inline void setFrsMaterials(const vector<FrsMaterial>& iMaterials) {_FrsMaterials = iMaterials;}
   inline void setViewShape(ViewShape *iShape) {_ViewShape = iShape;}
   inline void setImportance(float importance){_importance = importance;}
 };
index 42c39d5795e9081deda05b0df0603a97ca226475..5f7b313aaf6f1496acfc5669cf71b54a16215d37 100755 (executable)
@@ -470,7 +470,7 @@ FEdge * ViewEdgeXBuilder::BuildSmoothFEdge(FEdge *feprevious, const OWXFaceLayer
   fe = new FEdgeSmooth(va, vb);
   fe->setNature(ifl.fl->nature());
   fe->setId(_currentFId);
-  fe->setMaterialIndex(ifl.fl->getFace()->materialIndex());
+  fe->setFrsMaterialIndex(ifl.fl->getFace()->frs_materialIndex());
   fe->setFace(ifl.fl->getFace());
   fe->setNormal(normal);
   fe->setPreviousEdge(feprevious);
@@ -587,17 +587,17 @@ FEdge * ViewEdgeXBuilder::BuildSharpFEdge(FEdge *feprevious, const OWXEdge& iwe)
   unsigned matA(0), matB(0);
   if(iwe.order){
     normalB = (iwe.e->GetbFace()->GetNormal());
-    matB    = (iwe.e->GetbFace()->materialIndex());
+    matB    = (iwe.e->GetbFace()->frs_materialIndex());
     if(!(iwe.e->nature() & Nature::BORDER)) {  
       normalA = (iwe.e->GetaFace()->GetNormal());
-      matA    = (iwe.e->GetaFace()->materialIndex());
+      matA    = (iwe.e->GetaFace()->frs_materialIndex());
     }
   }else{
     normalA = (iwe.e->GetbFace()->GetNormal());
-    matA    = (iwe.e->GetbFace()->materialIndex());
+    matA    = (iwe.e->GetbFace()->frs_materialIndex());
     if(!(iwe.e->nature() & Nature::BORDER)) { 
       normalB = (iwe.e->GetaFace()->GetNormal());
-      matB    = (iwe.e->GetaFace()->materialIndex());
+      matB    = (iwe.e->GetaFace()->frs_materialIndex());
     }
   }
   // Creates the corresponding feature edge
@@ -605,8 +605,8 @@ FEdge * ViewEdgeXBuilder::BuildSharpFEdge(FEdge *feprevious, const OWXEdge& iwe)
   fe = new FEdgeSharp(va, vb);
   fe->setNature(iwe.e->nature());
   fe->setId(_currentFId);
-  fe->setaMaterialIndex(matA);
-  fe->setbMaterialIndex(matB);
+  fe->setaFrsMaterialIndex(matA);
+  fe->setbFrsMaterialIndex(matB);
   fe->setNormalA(normalA);
   fe->setNormalB(normalB);
   fe->setPreviousEdge(feprevious);
index 89e91e4f2c8aa009f5c83b4d1ce80ac5d0d0bfa0..3a4d86ea16f4900bb9f18ad6159d30430e56d50e 100755 (executable)
@@ -56,7 +56,7 @@ void ViewMapBuilder::computeInitialViewEdges(WingedEdge& we)
     // create the embedding
     psShape = new SShape;
     psShape->setId((*it)->GetId());
-    psShape->setMaterials((*it)->materials()); // FIXME
+    psShape->setFrsMaterials((*it)->frs_materials()); // FIXME
 
     // create the view shape
     ViewShape * vshape = new ViewShape(psShape);
index e42a0df042216a072869a5808bb149584a4e002b..f99a574766b1289fb3563d80fbb9786f738cea2c 100755 (executable)
@@ -91,7 +91,7 @@ namespace ViewMapIO {
 
 
     inline
-    int load(istream& in, Material& m) {
+    int load(istream& in, FrsMaterial& m) {
 
       float tmp_array[4];
       int i;
@@ -149,13 +149,13 @@ namespace ViewMapIO {
 
       // -> Material
       READ(size);
-      vector<Material> materials;
-      Material m;
+      vector<FrsMaterial> frs_materials;
+      FrsMaterial m;
       for(i=0; i<size; ++i){
         load(in, m);
-        materials.push_back(m);
+        frs_materials.push_back(m);
       }
-      vs->sshape()->setMaterials(materials);
+      vs->sshape()->setFrsMaterials(frs_materials);
 
       
 
@@ -252,7 +252,7 @@ namespace ViewMapIO {
 
         // Material
         READ(matindex);
-        fesmooth->setMaterialIndex(matindex);
+        fesmooth->setFrsMaterialIndex(matindex);
       }else{
         // aNormal
         load(in, v);
@@ -264,9 +264,9 @@ namespace ViewMapIO {
 
         // Materials 
         READ(matindex);
-        fesharp->setaMaterialIndex(matindex);
+        fesharp->setaFrsMaterialIndex(matindex);
         READ(matindex);
-        fesharp->setbMaterialIndex(matindex);
+        fesharp->setbFrsMaterialIndex(matindex);
       }
       
       unsigned tmp;
@@ -569,7 +569,7 @@ namespace ViewMapIO {
 
 
     inline
-    int save(ostream& out, const Material& m) {
+    int save(ostream& out, const FrsMaterial& m) {
 
       unsigned i;
       
@@ -622,10 +622,10 @@ namespace ViewMapIO {
       //    Not necessary (only used during view map computatiom)
 
       // -> Material
-      unsigned size = vs->sshape()->materials().size();
+      unsigned size = vs->sshape()->frs_materials().size();
       WRITE(size);
       for(unsigned i=0; i<size; ++i)
-        save(out, vs->sshape()->material(i));
+        save(out, vs->sshape()->frs_material(i));
 
       // -> VerticesList (List)
       tmp = vs->sshape()->getVertexList().size();
@@ -704,7 +704,7 @@ namespace ViewMapIO {
         // normal
         save(out, fesmooth->normal());
         // material
-        index = fesmooth->materialIndex();
+        index = fesmooth->frs_materialIndex();
         WRITE(index);
       }else{
         // aNormal
@@ -712,10 +712,10 @@ namespace ViewMapIO {
         // bNormal
         save(out, fesharp->normalB());
         // aMaterial
-        index = fesharp->aMaterialIndex();
+        index = fesharp->aFrsMaterialIndex();
         WRITE(index);
         // bMaterial
-        index = fesharp->bMaterialIndex();
+        index = fesharp->bFrsMaterialIndex();
         WRITE(index);
       }
       
index 2d054d8a0671dcafbad0d957e6a81ff71118e68a..630bfa561f2fcc91f1b4b1278c98e9dda3974c96 100755 (executable)
@@ -49,7 +49,7 @@ class LIB_VIEW_MAP_EXPORT ViewMapTesselator
 {
 public:
 
-  inline ViewMapTesselator() {_nature = Nature::SILHOUETTE | Nature::BORDER | Nature::CREASE;_Material.setDiffuse(0,0,0,1);_overloadMaterial=false;}
+  inline ViewMapTesselator() {_nature = Nature::SILHOUETTE | Nature::BORDER | Nature::CREASE;_FrsMaterial.setDiffuse(0,0,0,1);_overloadFrsMaterial=false;}
   virtual ~ViewMapTesselator() {}
 
   /*! Builds a set of lines rep contained under a 
@@ -71,17 +71,17 @@ public:
 
   
   inline void setNature(Nature::EdgeNature iNature) {_nature = iNature;}
-  inline void setMaterial(const Material& iMaterial) {_Material=iMaterial;_overloadMaterial=true;}
+  inline void setFrsMaterial(const FrsMaterial& iMaterial) {_FrsMaterial=iMaterial;_overloadFrsMaterial=true;}
   inline Nature::EdgeNature nature() {return _nature;}
-  inline const Material& material() const {return _Material;}
+  inline const FrsMaterial& frs_material() const {return _FrsMaterial;}
 
 protected:
   virtual void AddVertexToLine(LineRep *iLine, SVertex *v) = 0;
   
 private:
   Nature::EdgeNature _nature;
-  Material _Material;
-  bool _overloadMaterial;
+  FrsMaterial _FrsMaterial;
+  bool _overloadFrsMaterial;
 };
 
 /*! Class to tesselate the 2D projected silhouette */
@@ -123,8 +123,8 @@ NodeGroup * ViewMapTesselator::Tesselate(ViewEdgesIterator begin, ViewEdgesItera
   NodeGroup *group = new NodeGroup;
   NodeShape *tshape = new NodeShape;
   group->AddChild(tshape);
-  //tshape->material().setDiffuse(0.f, 0.f, 0.f, 1.f);
-  tshape->setMaterial(_Material);
+  //tshape->frs_material().setDiffuse(0.f, 0.f, 0.f, 1.f);
+  tshape->setFrsMaterial(_FrsMaterial);
 
   LineRep* line;
 
@@ -152,8 +152,8 @@ NodeGroup * ViewMapTesselator::Tesselate(ViewEdgesIterator begin, ViewEdgesItera
       //        continue;
       
       line = new OrientedLineRep();
-      if(_overloadMaterial)
-        line->setMaterial(_Material);
+      if(_overloadFrsMaterial)
+        line->setFrsMaterial(_FrsMaterial);
 
       // there might be chains containing a single element
       if(0 == (firstEdge)->nextEdge())
index b480b67b3d8db6d1206292c3f696928e7dc1df7e..95be5f55794f5801214b0cc03610d61ec526210b 100755 (executable)
@@ -254,7 +254,7 @@ WFace::WFace(WFace& iBrother)
   _VerticesNormals = iBrother._VerticesNormals;
   _VerticesTexCoords = iBrother._VerticesTexCoords;
   _Id = iBrother.GetId();
-  _MaterialIndex = iBrother._MaterialIndex;
+  _FrsMaterialIndex = iBrother._FrsMaterialIndex;
   userdata = NULL;
   iBrother.userdata = new facedata;
   ((facedata*)(iBrother.userdata))->_copy = this;
@@ -266,8 +266,8 @@ WFace * WFace::duplicate()
   return clone;
 }
 
-const Material& WFace::material() {
-  return getShape()->material(_MaterialIndex);
+const FrsMaterial& WFace::frs_material() {
+  return getShape()->frs_material(_FrsMaterialIndex);
 }
 
 WOEdge * WFace::MakeEdge(WVertex *v1, WVertex *v2)
@@ -475,7 +475,7 @@ WShape * WShape::duplicate()
 WShape::WShape(WShape& iBrother)
 {
   _Id = iBrother.GetId();
-  _Materials = iBrother._Materials;
+  _FrsMaterials = iBrother._FrsMaterials;
   _meanEdgeSize = iBrother._meanEdgeSize;
   iBrother.bbox(_min, _max);
   vector<WVertex*>& vertexList = iBrother.getVertexList();
@@ -650,7 +650,7 @@ WFace* WShape::MakeFace(vector<WVertex*>& iVertexList, unsigned iMaterial, WFace
 
   int id = _FaceList.size();
 
-  face->setMaterialIndex(iMaterial);
+  face->setFrsMaterialIndex(iMaterial);
 
   // Check whether we have a degenerated face:
 
index ea6c793bdfed98c5b1439a8139a685ec5f5af5a9..9b05b4577a9bed86e9bd2093b053e7af0b58f5d4 100755 (executable)
@@ -34,7 +34,7 @@
 # include <iterator>
 # include "../system/FreestyleConfig.h"
 # include "../geometry/Geom.h"
-# include "../scene_graph/Material.h"
+# include "../scene_graph/FrsMaterial.h"
 
 using namespace std;
 using namespace Geometry;
@@ -495,11 +495,11 @@ protected:
   vector<Vec2r> _VerticesTexCoords;
 
   int   _Id;
-  unsigned _MaterialIndex;
+  unsigned _FrsMaterialIndex;
 
 public:
   void *userdata;
-  inline WFace() {userdata = NULL;_MaterialIndex = 0;}
+  inline WFace() {userdata = NULL;_FrsMaterialIndex = 0;}
   /*! copy constructor */
   WFace(WFace& iBrother);
   virtual WFace * duplicate();
@@ -510,8 +510,8 @@ public:
   inline WOEdge * GetOEdge(int i) {return _OEdgeList[i];}
   inline Vec3r& GetNormal() {return _Normal;}
   inline int    GetId()     {return _Id;}
-  inline unsigned materialIndex() const {return _MaterialIndex;}
-  const Material& material()  ;
+  inline unsigned frs_materialIndex() const {return _FrsMaterialIndex;}
+  const FrsMaterial& frs_material()  ;
 
   /*! The vertex of index i corresponds to the a vertex 
    *  of the edge of index i
@@ -653,7 +653,7 @@ public:
   inline void setNormalList(const vector<Vec3r>& iNormalsList) {_VerticesNormals = iNormalsList;}
   inline void setTexCoordsList(const vector<Vec2r>& iTexCoordsList) {_VerticesTexCoords = iTexCoordsList;}
   inline void setId(int id) {_Id = id;}
-  inline void setMaterialIndex(unsigned iMaterialIndex) {_MaterialIndex = iMaterialIndex;}
+  inline void setFrsMaterialIndex(unsigned iMaterialIndex) {_FrsMaterialIndex = iMaterialIndex;}
 
   /*! designed to build a specialized WEdge 
    *  for use in MakeEdge
@@ -702,7 +702,7 @@ protected:
   static unsigned _SceneCurrentId;
   Vec3r _min;
   Vec3r _max;
-  vector<Material> _Materials;
+  vector<FrsMaterial> _FrsMaterials;
   real _meanEdgeSize;
 
 public:
@@ -749,8 +749,8 @@ public:
   inline vector<WFace*>& GetFaceList() {return _FaceList;}
   inline unsigned GetId() {return _Id;}
   inline void bbox(Vec3r& min, Vec3r& max) {min=_min; max=_max;}
-  inline const Material& material(unsigned i) const  {return _Materials[i];}
-  inline const vector<Material>& materials() const {return _Materials;}
+  inline const FrsMaterial& frs_material(unsigned i) const  {return _FrsMaterials[i];}
+  inline const vector<FrsMaterial>& frs_materials() const {return _FrsMaterials;}
   inline const real getMeanEdgeSize() const {return _meanEdgeSize;}
   /*! modifiers */
   static inline void setCurrentId(const unsigned id) { _SceneCurrentId = id; }
@@ -759,8 +759,8 @@ public:
   inline void setFaceList(const vector<WFace*>& iFaceList) {_FaceList = iFaceList;}
   inline void setId(int id) {_Id = id;}
   inline void setBBox(const Vec3r& min, const Vec3r& max) {_min = min; _max=max;}
-  inline void setMaterial(const Material& material, unsigned i) {_Materials[i]=material;}
-  inline void setMaterials(const vector<Material>& iMaterials) {_Materials = iMaterials;}
+  inline void setFrsMaterial(const FrsMaterial& frs_material, unsigned i) {_FrsMaterials[i]=frs_material;}
+  inline void setFrsMaterials(const vector<FrsMaterial>& iMaterials) {_FrsMaterials = iMaterials;}
 
   /*! designed to build a specialized WFace 
    *  for use in MakeFace
index cccf876db8bb7d2ae84a410574a814b655caf265..9f3da4707e3477f9d7797cefcd3b2c181f399bb6 100755 (executable)
@@ -34,7 +34,7 @@ void WingedEdgeBuilder::visitIndexedFaceSet(IndexedFaceSet& ifs) {
 
 void WingedEdgeBuilder::visitNodeShape(NodeShape& ns) {
   //Sets the current material to iShapeode->material:
-  _current_material = &(ns.material());
+  _current_frs_material = &(ns.frs_material());
 }
 
 void WingedEdgeBuilder::visitNodeTransform(NodeTransform& tn) {
@@ -88,19 +88,19 @@ void WingedEdgeBuilder::buildWShape(WShape& shape, IndexedFaceSet& ifs) {
 
   const IndexedFaceSet::TRIANGLES_STYLE*       faceStyle = ifs.trianglesStyle();
 
-       vector<Material> materials;
+       vector<FrsMaterial> frs_materials;
        if(ifs.msize()){
-               const Material*const* mats = ifs.materials();
+               const FrsMaterial*const* mats = ifs.frs_materials();
                for(unsigned i=0; i<ifs.msize(); ++i)
-                       materials.push_back(*(mats[i]));
-               shape.setMaterials(materials);
+                       frs_materials.push_back(*(mats[i]));
+               shape.setFrsMaterials(frs_materials);
        }
 
-  //  const Material * mat = (ifs.material());
+  //  const FrsMaterial * mat = (ifs.frs_material());
   //  if (mat)
-  //    shape.setMaterial(*mat);
-  //  else if(_current_material)
-  //    shape.setMaterial(*_current_material);
+  //    shape.setFrsMaterial(*mat);
+  //  else if(_current_frs_material)
+  //    shape.setFrsMaterial(*_current_frs_material);
 
   // sets the current WShape to shape
   _current_wshape = &shape;
@@ -126,7 +126,7 @@ void WingedEdgeBuilder::buildWShape(WShape& shape, IndexedFaceSet& ifs) {
     case IndexedFaceSet::TRIANGLE_STRIP:
       buildTriangleStrip(new_vertices,
                         new_normals,
-       materials,
+       frs_materials,
        texCoords,
                         vindices,
                         nindices,
@@ -137,7 +137,7 @@ void WingedEdgeBuilder::buildWShape(WShape& shape, IndexedFaceSet& ifs) {
     case IndexedFaceSet::TRIANGLE_FAN:
       buildTriangleFan(new_vertices,
                       new_normals,
-           materials, 
+           frs_materials, 
            texCoords,
                       vindices,
                       nindices,
@@ -148,7 +148,7 @@ void WingedEdgeBuilder::buildWShape(WShape& shape, IndexedFaceSet& ifs) {
     case IndexedFaceSet::TRIANGLES:
       buildTriangles(new_vertices,
                     new_normals,
-         materials,
+         frs_materials,
          texCoords,
                     vindices,
                     nindices,
@@ -215,7 +215,7 @@ void WingedEdgeBuilder::buildWVertices(WShape& shape,
 
 void WingedEdgeBuilder::buildTriangleStrip( const real *vertices, 
                                                              const real *normals, 
-                                           vector<Material>& iMaterials, 
+                                           vector<FrsMaterial>& iMaterials, 
                                            const real *texCoords, 
                                                              const unsigned *vindices, 
                                                              const unsigned *nindices,
@@ -279,7 +279,7 @@ void WingedEdgeBuilder::buildTriangleStrip( const real *vertices,
 
 void WingedEdgeBuilder::buildTriangleFan( const real *vertices, 
                                                              const real *normals, 
-                                            vector<Material>&  iMaterials, 
+                                            vector<FrsMaterial>&  iMaterials, 
                                             const real *texCoords, 
                                                              const unsigned *vindices, 
                                                              const unsigned *nindices,
@@ -291,7 +291,7 @@ void WingedEdgeBuilder::buildTriangleFan( const real *vertices,
 
 void WingedEdgeBuilder::buildTriangles(const real *vertices, 
                                                              const real *normals, 
-                                            vector<Material>&  iMaterials, 
+                                            vector<FrsMaterial>&  iMaterials, 
                                             const real *texCoords, 
                                                              const unsigned *vindices, 
                                                              const unsigned *nindices,
index fe033f2ea0bf033c7fa375f978c1b06e310d59cb..6bd515aef0b7a52f8e61bf63cce4ac8c9d5ba5a1 100755 (executable)
@@ -44,7 +44,7 @@ class LIB_WINGED_EDGE_EXPORT WingedEdgeBuilder : public SceneVisitor
 
   inline WingedEdgeBuilder() : SceneVisitor() {
     _current_wshape = NULL;
-    _current_material = NULL;
+    _current_frs_material = NULL;
     _current_matrix = NULL;
     _winged_edge = new WingedEdge; // Not deleted by the destructor
   }
@@ -76,8 +76,8 @@ class LIB_WINGED_EDGE_EXPORT WingedEdgeBuilder : public SceneVisitor
     return _current_wshape;
   }
  
-  inline Material*     getCurrentMaterial() {
-    return _current_material;
+  inline FrsMaterial*  getCurrentFrsMaterial() {
+    return _current_frs_material;
   }
 
   inline Matrix44r*    getCurrentMatrix() {
@@ -93,8 +93,8 @@ class LIB_WINGED_EDGE_EXPORT WingedEdgeBuilder : public SceneVisitor
     _current_wshape = wshape;
   }
 
-  inline void setCurrentMaterial(Material* mat) {
-    _current_material = mat;
+  inline void setCurrentFrsMaterial(FrsMaterial* mat) {
+    _current_frs_material = mat;
   }
 
   //  inline void setCurrentMatrix(Matrix44r* matrix) {
@@ -112,7 +112,7 @@ class LIB_WINGED_EDGE_EXPORT WingedEdgeBuilder : public SceneVisitor
 
   void buildTriangleStrip(const real *vertices, 
                          const real *normals, 
-        vector<Material>&  iMaterials, 
+        vector<FrsMaterial>&  iMaterials, 
         const real *texCoords,
                          const unsigned *vindices, 
                          const unsigned *nindices,
@@ -122,7 +122,7 @@ class LIB_WINGED_EDGE_EXPORT WingedEdgeBuilder : public SceneVisitor
 
   void buildTriangleFan(const real *vertices, 
                        const real *normals, 
-      vector<Material>&  iMaterials,
+      vector<FrsMaterial>&  iMaterials,
       const real *texCoords,
                        const unsigned *vindices, 
                        const unsigned *nindices,
@@ -132,7 +132,7 @@ class LIB_WINGED_EDGE_EXPORT WingedEdgeBuilder : public SceneVisitor
 
   void buildTriangles(const real *vertices, 
                      const real *normals, 
-          vector<Material>&  iMaterials,
+          vector<FrsMaterial>&  iMaterials,
           const real *texCoords,
                      const unsigned *vindices, 
                      const unsigned *nindices,
@@ -151,7 +151,7 @@ class LIB_WINGED_EDGE_EXPORT WingedEdgeBuilder : public SceneVisitor
                        real *res);
  
   WShape*              _current_wshape;
-  Material*            _current_material;
+  FrsMaterial*         _current_frs_material;
   WingedEdge*          _winged_edge;
   Matrix44r*           _current_matrix;
   vector<Matrix44r*>   _matrices_stack;
index 888eca414d0b16d2940c0ed79aa8b0afa4126a60..457f4e992c51460e6e5253c4f53f052d715e33b2 100644 (file)
@@ -2209,11 +2209,12 @@ static void freestyleRender(Render *re)
        // set camera
        RE_SetCamera(re, re->scene->camera);
        
-       // set view
-       Mat4Ortho(re->scene->camera->obmat);
-       Mat4Invert(mat, re->scene->camera->obmat);
-       RE_SetView(re, mat);
-       
+       // set up render database
+       if(render_scene_needs_vector(re))
+               RE_Database_FromScene_Vectors(re, re->scene);
+       else
+          RE_Database_FromScene(re, re->scene, 1);
+               
        // Freestyle initialization
        FRS_prepare(re);