Code refactored; Non dynamic random fill filter skeleton added

src/fgt/filter_physics/DynamicMeshSubFilter.cpp

@@ -0,0 +1,37 @@
+#include "DynamicMeshSubFilter.h"
+
+DynamicMeshSubFilter::DynamicMeshSubFilter() : m_steps(-1), m_seconds(-1), m_stepSize(0.01), m_stepsPerSecond(1.0f/m_stepSize) {
+}
+
+void DynamicMeshSubFilter::initParameterSet(QAction* action,MeshDocument& md, RichParameterSet & par){
+    par.addParam(new RichInt("seconds", 1, "Simulation interval in seconds", "Physics simulation interval in seconds"));
+    par.addParam(new RichDynamicFloat("timeline", 0, 0, 100, "Timeline %", "Physics simulation is run"));
+}
+
+bool DynamicMeshSubFilter::applyFilter(QAction* filter, MeshDocument &md, RichParameterSet& par, vcg::CallBackPos* cb){
+    if(configurationHasChanged(md, par))
+        initialize(md, par);
+
+    return true;
+}
+
+bool DynamicMeshSubFilter::configurationHasChanged(MeshDocument& md, RichParameterSet& par){
+    bool changed = m_seconds != par.getInt("seconds");
+
+    if(md.size() == m_files.size())
+        for(int i = 0; i < m_files.size(); i++)
+            changed |= m_files.at(i) != md.getMesh(i)->fileName;
+    else
+        changed = true;
+
+    m_files.clear();
+    for(int i = 0; i < md.size(); i++)
+        m_files.push_back(md.getMesh(i)->fileName);
+
+    m_seconds = par.getInt("seconds");
+    return changed;
+}
+
+void DynamicMeshSubFilter::initialize(MeshDocument&, RichParameterSet&){
+    m_steps = m_seconds / m_stepSize;
+}

src/fgt/filter_physics/DynamicMeshSubFilter.h

@@ -0,0 +1,29 @@
+#ifndef DYNAMICMESHSUBFILTER_H
+#define DYNAMICMESHSUBFILTER_H
+
+#include "MeshSubFilter.h"
+
+class DynamicMeshSubFilter : public MeshSubFilter{
+public:
+    DynamicMeshSubFilter();
+    virtual void initParameterSet(QAction* action,MeshDocument& md, RichParameterSet & par);
+    virtual bool applyFilter(QAction* filter, MeshDocument &md, RichParameterSet& par, vcg::CallBackPos* cb);
+
+protected:
+    typedef std::vector<vcg::Matrix44f> LayerTransformations;
+    typedef std::vector<LayerTransformations> LayersTransformations;
+
+    virtual void initialize(MeshDocument&, RichParameterSet&);
+    virtual bool configurationHasChanged(MeshDocument& md, RichParameterSet& par);
+
+    int m_steps;
+    int m_seconds;
+    const float m_stepSize;
+    const unsigned int m_stepsPerSecond;
+    LayersTransformations m_layersTrans;
+
+private:
+    std::vector<std::string> m_files;
+};
+
+#endif // DYNAMICMESHSUBFILTER_H

src/fgt/filter_physics/GravitySubFilter.cpp

@@ -4,7 +4,7 @@ GravitySubFilter::GravitySubFilter() : m_currentSceneryLayer(-1){
 }
 
 void GravitySubFilter::initParameterSet(QAction* action,MeshDocument& md, RichParameterSet& par){
-    MeshSubFilter::initParameterSet(action, md, par);
+    DynamicMeshSubFilter::initParameterSet(action, md, par);
 
     QStringList layers;
     for(int i = 1; i <= md.size(); i++){
@@ -14,7 +14,7 @@ void GravitySubFilter::initParameterSet(QAction* action,MeshDocument& md, RichPa
 }
 
 bool GravitySubFilter::applyFilter(QAction* filter, MeshDocument &md, RichParameterSet& par, vcg::CallBackPos* cb){
-    MeshSubFilter::applyFilter(filter, md, par, cb);
+    DynamicMeshSubFilter::applyFilter(filter, md, par, cb);
 
     int currentStep  = (par.getDynamicFloat("timeline") * m_steps) / 100;
 
@@ -24,14 +24,14 @@ bool GravitySubFilter::applyFilter(QAction* filter, MeshDocument &md, RichParame
     return true;
 }
 
-bool GravitySubFilter::configurationHasChanged(RichParameterSet& par){
-    bool changed = MeshSubFilter::configurationHasChanged(par) || m_currentSceneryLayer != par.getEnum("layers");
+bool GravitySubFilter::configurationHasChanged(MeshDocument& md, RichParameterSet& par){
+    bool changed = DynamicMeshSubFilter::configurationHasChanged(md, par) || m_currentSceneryLayer != par.getEnum("layers");
     m_currentSceneryLayer = par.getEnum("layers");
     return changed;
 }
 
 void GravitySubFilter::initialize(MeshDocument& md, RichParameterSet& par){
-    MeshSubFilter::initialize(md, par);
+    DynamicMeshSubFilter::initialize(md, par);
 
     static float gravity[3] = {0.0f, -9.8f, 0.0f};
     m_engine.clear();
@@ -43,6 +43,10 @@ void GravitySubFilter::initialize(MeshDocument& md, RichParameterSet& par){
     m_layersTrans.clear();
     m_layersTrans.resize(md.size());
 
+    for(int i = 0; i < m_layersTrans.size(); i++){
+        m_layersTrans[i].reserve(m_steps);
+    }
+
     for(int i = 0; i <= m_steps; i++){
         for(int j = 0; j < md.size(); j++){
             m_layersTrans[j].push_back(m_engine.getTransformationMatrix(*md.getMesh(j)));

src/fgt/filter_physics/GravitySubFilter.h

@@ -5,10 +5,10 @@
 #ifndef GRAVITYSUBFILTER_H
 #define GRAVITYSUBFILTER_H
 
-#include "MeshSubFilter.h"
+#include "DynamicMeshSubFilter.h"
 #include "ODEFacade.h"
 
-class GravitySubFilter : public MeshSubFilter{
+class GravitySubFilter : public DynamicMeshSubFilter{
 public:
     GravitySubFilter();
 
@@ -17,7 +17,7 @@ public:
 
 protected:
     virtual void initialize(MeshDocument&, RichParameterSet&);
-    virtual bool configurationHasChanged(RichParameterSet& par);
+    virtual bool configurationHasChanged(MeshDocument& md, RichParameterSet& par);
 
 private:
     int m_currentSceneryLayer;

src/fgt/filter_physics/MeshSubFilter.h

@@ -11,25 +11,12 @@
 #include <vcg/math/matrix44.h>
 
 #include <vector>
+#include <string>
 
 class MeshSubFilter{
 public:
-    MeshSubFilter();
-    virtual void initParameterSet(QAction* action,MeshDocument& md, RichParameterSet & par);
-    virtual bool applyFilter(QAction* filter, MeshDocument &md, RichParameterSet& par, vcg::CallBackPos* cb);
-
-protected:
-    typedef std::vector<vcg::Matrix44f> LayerTransformations;
-    typedef std::vector<LayerTransformations> LayersTransformations;
-
-    virtual void initialize(MeshDocument&, RichParameterSet&);
-    virtual bool configurationHasChanged(RichParameterSet& par);
-
-    int m_steps;
-    int m_seconds;
-    const float m_stepSize;
-    const unsigned int m_stepsPerSecond;
-    LayersTransformations m_layersTrans;
+    virtual void initParameterSet(QAction* action,MeshDocument& md, RichParameterSet & par) = 0;
+    virtual bool applyFilter(QAction* filter, MeshDocument &md, RichParameterSet& par, vcg::CallBackPos* cb) = 0;
 };
 
 #endif // MESHSUBFILTER_H

src/fgt/filter_physics/ODEFacade.cpp

@@ -23,6 +23,9 @@ void ODEFacade::initialize(){
 	m_world = dWorldCreate();
 	m_space = dSimpleSpaceCreate(0);
         m_contactGroup = dJointGroupCreate(m_maxContacts);
+
+        /*dWorldSetCFM(m_world, 0.001f);
+        dWorldSetERP(m_world, 0.9f);*/
 }
 
 void ODEFacade::clear(){
@@ -99,6 +102,7 @@ void ODEFacade::setAsRigidBody(MeshModel& mesh, bool isRigidBody){
         dMassSetParameters(&m_registeredMeshes[index()].second->mass, inertia.Mass(),
                            inertia.CenterOfMass()[0], inertia.CenterOfMass()[1], inertia.CenterOfMass()[2],
                            IT[0][0], IT[1][1], IT[2][2], IT[0][1], IT[0][2], IT[1][2]);
+        dBodySetMass(m_registeredMeshes[index()].second->body, &m_registeredMeshes[index()].second->mass);
 
     }
 
@@ -173,6 +177,12 @@ void ODEFacade::collisionCallback(dGeomID o1, dGeomID o2){
         contacts[i].surface.bounce = 0.1;
         contacts[i].surface.bounce_vel = 0.1;
         contacts[i].surface.soft_cfm = 0.01;
+        /*contacts[i].surface.mode = dContactBounce | dContactSoftCFM;
+        contacts[i].surface.mu = dInfinity;
+        contacts[i].surface.mu2 = 0;
+        contacts[i].surface.bounce = 0.1;
+        contacts[i].surface.bounce_vel = 0.1;
+        contacts[i].surface.soft_cfm = 0.01;*/
     }
 
     int collisions = dCollide(o1, o2, m_maxContacts, &contacts[0].geom, sizeof(dContact));

src/fgt/filter_physics/RandomDropFilter.cpp

@@ -11,7 +11,7 @@ RandomDropFilter::RandomDropFilter() : m_randomLayer(-1), m_dropRate(-1), m_dist
 }
 
 void RandomDropFilter::initParameterSet(QAction* action,MeshDocument& md, RichParameterSet & par){
-    MeshSubFilter::initParameterSet(action, md, par);
+    DynamicMeshSubFilter::initParameterSet(action, md, par);
 
     QStringList layers;
     for(int i = 1; i <= md.size(); i++){
@@ -24,7 +24,7 @@ void RandomDropFilter::initParameterSet(QAction* action,MeshDocument& md, RichPa
 }
 
 bool RandomDropFilter::applyFilter(QAction* filter, MeshDocument &md, RichParameterSet& par, vcg::CallBackPos* cb){
-    MeshSubFilter::applyFilter(filter, md, par, cb);
+    DynamicMeshSubFilter::applyFilter(filter, md, par, cb);
 
     int currentStep  = (par.getDynamicFloat("timeline") * m_steps) / m_stepsPerSecond;
     int randomObjects = m_seconds/m_dropRate;
@@ -43,7 +43,7 @@ bool RandomDropFilter::applyFilter(QAction* filter, MeshDocument &md, RichParame
 }
 
 void RandomDropFilter::initialize(MeshDocument& md, RichParameterSet& par){
-    MeshSubFilter::initialize(md, par);
+    DynamicMeshSubFilter::initialize(md, par);
 
     static float gravity[3] = {0.0f, -9.8f, 0.0f};
     m_engine.clear();
@@ -67,6 +67,10 @@ void RandomDropFilter::initialize(MeshDocument& md, RichParameterSet& par){
     m_layersTrans.clear();
     m_layersTrans.resize(md.size());
 
+    for(int i = 0; i < m_layersTrans.size(); i++){
+        m_layersTrans[i].reserve(m_steps);
+    }
+
     for(int i = 0; i <= m_steps; i++){
         int currentRndObject = md.size() - randomObjects + i/(m_stepsPerSecond*m_dropRate);
 
@@ -99,8 +103,8 @@ void RandomDropFilter::addRandomObject(MeshDocument& md){
     meshCopy->visible = false;
 }
 
-bool RandomDropFilter::configurationHasChanged(RichParameterSet& par){
-    bool changed = MeshSubFilter::configurationHasChanged(par) ||
+bool RandomDropFilter::configurationHasChanged(MeshDocument& md, RichParameterSet& par){
+    bool changed = DynamicMeshSubFilter::configurationHasChanged(md, par) ||
                    m_randomLayer != par.getEnum("randomLayer") ||
                    m_distance != par.getFloat("distance") ||
                    m_dropRate != par.getInt("dropRate");

src/fgt/filter_physics/RandomDropFilter.h

@@ -5,10 +5,10 @@
 #ifndef RANDOMDROPFILTER_H
 #define RANDOMDROPFILTER_H
 
-#include "MeshSubFilter.h"
+#include "DynamicMeshSubFilter.h"
 #include "ODEFacade.h"
 
-class RandomDropFilter : public MeshSubFilter{
+class RandomDropFilter : public DynamicMeshSubFilter{
 public:
     RandomDropFilter();
 
@@ -17,7 +17,7 @@ public:
 
 protected:
     virtual void initialize(MeshDocument&, RichParameterSet&);
-    virtual bool configurationHasChanged(RichParameterSet& par);
+    virtual bool configurationHasChanged(MeshDocument& md, RichParameterSet& par);
     virtual void addRandomObject(MeshDocument& md);
 
 private:

src/fgt/filter_physics/RandomFillFilter.cpp

@@ -0,0 +1,27 @@
+#include "RandomFillFilter.h"
+
+#include <vcg/complex/trimesh/append.h>
+
+using namespace std;
+
+void RandomFillFilter::initParameterSet(QAction* action,MeshDocument& md, RichParameterSet & par){
+    QStringList layers;
+    for(int i = 1; i <= md.size(); i++){
+        layers.push_back(QString::number(i));
+    }
+
+    par.addParam(new RichInt("seconds", 1, "Simulation interval in seconds", "Physics simulation interval in seconds"));
+    par.addParam(new RichEnum("randomLayer", 0, layers, "Random object layer", "Select the layer that contains the object that will spawn randomly"));
+    par.addParam(new RichInt("dropRate", 2, "Drop rate", "The drop rate"));
+}
+
+bool RandomFillFilter::applyFilter(QAction* filter, MeshDocument &md, RichParameterSet& par, vcg::CallBackPos* cb){
+    return true;
+}
+
+void RandomFillFilter::addRandomObject(MeshDocument& md){
+    MeshModel* meshCopy = md.addNewMesh("randomMesh");
+    vcg::tri::Append<CMeshO,CMeshO>::Mesh(meshCopy->cm, md.getMesh(m_randomLayer)->cm, false, true);
+    meshCopy->cm.Tr = md.getMesh(m_randomLayer)->cm.Tr;
+    meshCopy->visible = false;
+}

src/fgt/filter_physics/RandomFillFilter.h

@@ -0,0 +1,22 @@
+#ifndef RANDOMFILLFILTER_H
+#define RANDOMFILLFILTER_H
+
+#include "MeshSubFilter.h"
+#include "ODEFacade.h"
+
+class RandomFillFilter : public MeshSubFilter{
+public:
+    virtual void initParameterSet(QAction* action,MeshDocument& md, RichParameterSet & par);
+    virtual bool applyFilter(QAction* filter, MeshDocument &md, RichParameterSet& par, vcg::CallBackPos* cb);
+
+protected:
+    virtual void addRandomObject(MeshDocument& md);
+
+private:
+    int m_randomLayer;
+    int m_fillLayer;
+    int m_dropRate;
+    ODEFacade m_engine;
+};
+
+#endif // RANDOMFILLFILTER_H

src/fgt/filter_physics/filter_physics.cpp

@@ -9,6 +9,7 @@ using namespace vcg;
 FilterPhysics::FilterPhysics(){
     typeList << FP_PHYSICS_GRAVITY;
     typeList << FP_PHYSICS_RNDDROP;
+    typeList << FP_PHYSICS_RNDFILL;
     
     FilterIDType tt;
     foreach(tt , types())
@@ -24,6 +25,8 @@ FilterPhysics::~FilterPhysics(){
         return QString("Physics gravity demo");
     case FP_PHYSICS_RNDDROP:
         return QString("Physics random drop demo");
+    case FP_PHYSICS_RNDFILL:
+        return QString("Physics random fill demo");
     default:
         assert(0);
         break;
@@ -35,6 +38,8 @@ FilterPhysics::~FilterPhysics(){
         return QString("Runs a physics gravity simulation on a set of meshes");
     case FP_PHYSICS_RNDDROP:
         return QString("Runs a random physics gravity simulation on a set of meshes");
+    case FP_PHYSICS_RNDFILL:
+        return QString("Runs a random physics mesh fill simulation");
     default:
         assert(0);
         break;
@@ -49,6 +54,8 @@ void FilterPhysics::initParameterSet(QAction* action,MeshDocument& md, RichParam
     case FP_PHYSICS_RNDDROP:
         m_rndDropFilter.initParameterSet(action, md, par);
         break;
+    case FP_PHYSICS_RNDFILL:
+        m_rndFillFilter.initParameterSet(action, md, par);
     default:
         break;
     }
@@ -62,6 +69,9 @@ bool FilterPhysics::applyFilter(QAction* action, MeshDocument &md, RichParameter
     case FP_PHYSICS_RNDDROP:
         return m_rndDropFilter.applyFilter(action, md, par, cb);
         break;
+    case FP_PHYSICS_RNDFILL:
+        return m_rndFillFilter.applyFilter(action, md, par, cb);
+        break;
     default:
         break;
     }

src/fgt/filter_physics/filter_physics.h

@@ -8,6 +8,7 @@
 #include "ODEFacade.h"
 #include "GravitySubFilter.h"
 #include "RandomDropFilter.h"
+#include "RandomFillFilter.h"
 
 #include <QObject>
 #include <QStringList>
@@ -22,7 +23,7 @@ class FilterPhysics : public QObject, public MeshFilterInterface
     Q_INTERFACES(MeshFilterInterface)
 
     public:
-    enum {FP_PHYSICS_GRAVITY, FP_PHYSICS_RNDDROP} ;
+    enum {FP_PHYSICS_GRAVITY, FP_PHYSICS_RNDDROP, FP_PHYSICS_RNDFILL} ;
 
     FilterPhysics();
     ~FilterPhysics();
@@ -42,6 +43,7 @@ class FilterPhysics : public QObject, public MeshFilterInterface
     private:
     GravitySubFilter m_gravityFilter;
     RandomDropFilter m_rndDropFilter;
+    RandomFillFilter m_rndFillFilter;
 };
 
 #endif

src/fgt/filter_physics/filter_physics.pro

@@ -5,12 +5,15 @@ HEADERS = filter_physics.h \
     PhysicsEngineFacade.h \
     MeshSubFilter.h \
     GravitySubFilter.h \
-    RandomDropFilter.h
+    RandomDropFilter.h \
+    RandomFillFilter.h \
+    DynamicMeshSubFilter.h
 SOURCES = filter_physics.cpp \
     ODEFacade.cpp \
     GravitySubFilter.cpp \
-    MeshSubFilter.cpp \
-    RandomDropFilter.cpp
+    RandomDropFilter.cpp \
+    RandomFillFilter.cpp \
+    DynamicMeshSubFilter.cpp
 TARGET = filter_physics
 CONFIG += x86
 LIBS += -L/usr/local/lib \