VisualModelImpl.h

Go to the documentation of this file.

/******************************************************************************
*       SOFA, Simulation Open-Framework Architecture, version 1.0 beta 3      *
*                (c) 2006-2008 MGH, INRIA, USTL, UJF, CNRS                    *
*                                                                             *
* This library is free software; you can redistribute it and/or modify it     *
* under the terms of the GNU Lesser General Public License as published by    *
* the Free Software Foundation; either version 2.1 of the License, or (at     *
* your option) any later version.                                             *
*                                                                             *
* This library is distributed in the hope that it will be useful, but WITHOUT *
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or       *
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License *
* for more details.                                                           *
*                                                                             *
* You should have received a copy of the GNU Lesser General Public License    *
* along with this library; if not, write to the Free Software Foundation,     *
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA.          *
*******************************************************************************
*                               SOFA :: Modules                               *
*                                                                             *
* Authors: The SOFA Team and external contributors (see Authors.txt)          *
*                                                                             *
* Contact information: contact@sofa-framework.org                             *
******************************************************************************/
#ifndef SOFA_COMPONENT_VISUALMODEL_VISUALMODELIMPL_H
#define SOFA_COMPONENT_VISUALMODEL_VISUALMODELIMPL_H

#include <string>
#include <sofa/core/VisualModel.h>
#include <sofa/core/componentmodel/behavior/MappedModel.h>
#include <sofa/core/componentmodel/topology/BaseMeshTopology.h>
#include <sofa/defaulttype/Vec.h>
#include <sofa/defaulttype/VecTypes.h>
#include <sofa/defaulttype/RigidTypes.h>
#include <sofa/helper/io/Mesh.h>

#include <map>

namespace sofa
{

namespace component
{

namespace visualmodel
{

using namespace sofa::defaulttype;


class RigidMappedModel : public core::componentmodel::behavior::MappedModel< Rigid3fTypes >
{
public:
    VecCoord xforms;
    bool xformsModified;

    RigidMappedModel()
    : xformsModified(false)
    {
    }

    const VecCoord* getX()  const { return &xforms; }
    const VecDeriv* getV()  const { return NULL; }

    VecCoord* getX()  { xformsModified = true; return &xforms;   }
    VecDeriv* getV()  { return NULL; }

    const VecCoord* getRigidX()  const { return getX(); }
    VecCoord* getRigidX()  { return getX(); }
};

class ExtVec3fMappedModel : public core::componentmodel::behavior::MappedModel< ExtVec3fTypes >
{
public:
    ResizableExtVector<Coord>* inputVertices;
    bool modified; 

    ExtVec3fMappedModel()
    : inputVertices(NULL), modified(false)
    {
    }

    const VecCoord* getX()  const { return inputVertices; }
    const VecDeriv* getV()  const { return NULL; }

    VecCoord* getX()  { modified = true; return inputVertices; }
    VecDeriv* getV()  { return NULL; }

    const VecCoord* getVecX()  const { return getX(); }
    VecCoord* getVecX()  { return getX(); }
};

class VisualModelImpl : public core::VisualModel, public ExtVec3fMappedModel, public RigidMappedModel
{
protected:
    // use types from ExtVec3fTypes

    typedef ExtVec3fTypes::Real Real;
    typedef ExtVec3fTypes::Coord Coord;
    typedef ExtVec3fTypes::VecCoord VecCoord;
    typedef ExtVec3fTypes::Deriv Deriv;
    typedef ExtVec3fTypes::VecDeriv VecDeriv;


    typedef Vec<2, float> TexCoord;
    typedef helper::fixed_array<int, 3> Triangle;
    typedef helper::fixed_array<int, 4> Quad;
    //typedef helper::fixed_array<int, 4> Tetrahedron;

    //ResizableExtVector<Coord>* inputVertices;

    bool useTopology; 
    int lastMeshRev; 
    bool useNormals; 
    bool castShadow; 

    sofa::core::componentmodel::topology::BaseMeshTopology* _topology;

/*     Data< ResizableExtVector<Coord> > vertices; */
    DataPtr< ResizableExtVector<Coord> > field_vertices;
    ResizableExtVector<Coord> vertices;

    DataPtr< ResizableExtVector<Coord> > field_vnormals;
    ResizableExtVector<Coord> vnormals;
    DataPtr< ResizableExtVector<TexCoord> > field_vtexcoords;
    ResizableExtVector<TexCoord> vtexcoords;

    DataPtr< ResizableExtVector<Triangle> > field_triangles;
    ResizableExtVector<Triangle> triangles;
    DataPtr< ResizableExtVector<Quad> > field_quads;
    ResizableExtVector<Quad> quads;

    ResizableExtVector<int> vertPosIdx;

    ResizableExtVector<int> vertNormIdx;

    float scaleTex;
    Data< std::string > filename;
    Data< std::string > texturename;
    Data< Vector3 > translation;
    Data< Vector3 > rotation;
    Data< SReal > scale;

    Vec3f bbox[2];

    virtual void internalDraw()
    {}

public:
    Data< sofa::helper::io::Mesh::Material > material;

    VisualModelImpl();

    ~VisualModelImpl();

    void parse(core::objectmodel::BaseObjectDescription* arg);

    bool isTransparent();

    void drawVisual();
    void drawTransparent();
    void drawShadow();

    virtual bool loadTexture(const std::string& /*filename*/) { return false; }

    bool load(const std::string& filename, const std::string& loader, const std::string& textureName);

    void applyTranslation(const double dx, const double dy, const double dz);
    //Apply Rotation from Euler angles (in degree!)
    void applyRotation (const double rx, const double ry, const double rz);
    void applyRotation(const Quat q);
    void applyScale(const double s);
    void applyUVTranslation(const double dU, const double dV);
    void applyUVScale(const double su, const double sv);

    void flipFaces();

    void setFilename(std::string s){filename.setValue(s);}
    std::string getFilename(){return filename.getValue();}
    
    void setColor(float r, float g, float b, float a);
    void setColor(std::string color);

    void setUseNormals(bool val) { useNormals = val;  }
    bool getUseNormals() const   { return useNormals; }

    void setCastShadow(bool val) { castShadow = val;  }
    bool getCastShadow() const   { return castShadow; }

    void setMesh(helper::io::Mesh &m, bool tex=false);
    bool isUsingTopology() const {return useTopology;};

    ResizableExtVector<Coord> * getVertices() {return &vertices;}
    void setVertices(ResizableExtVector<Coord> * x){vertices = *x;}
    ResizableExtVector<Triangle> * getTriangles() {return &triangles;}
    void setTriangles(ResizableExtVector<Triangle> * t){triangles = *t;}

    virtual void computePositions();
    virtual void computeMesh();
    virtual void computeNormals();
    virtual void computeBBox();

    virtual void updateVisual();

    // handle topological changes
    virtual void handleTopologyChange();

    void init();

    void initVisual();

    bool addBBox(double* minBBox, double* maxBBox);

    //const VecCoord* getX()  const; // { return &x;   }
    //const VecDeriv* getV()  const { return NULL; }

    //VecCoord* getX(); //  { return &x;   }
    //VecDeriv* getV()  { return NULL; }

    virtual void exportOBJ(std::string name, std::ostream* out, std::ostream* mtl, int& vindex, int& nindex, int& tindex);

    virtual std::string getTemplateName() const
    {
        return ExtVec3fMappedModel::getTemplateName();
    }

    static std::string templateName(const VisualModelImpl* p = NULL)
    {
        return ExtVec3fMappedModel::templateName(p);
    }
};

//typedef Vec<3,GLfloat> GLVec3f;
//typedef ExtVectorTypes<GLVec3f,GLVec3f> GLExtVec3fTypes;

} // namespace visualmodel

} // namespace component

} // namespace sofa

#endif