CGenericObject.h

Go to the documentation of this file.

//==============================================================================
/*
    Software License Agreement (BSD License)
    Copyright (c) 2003-2016, CHAI3D.
    (www.chai3d.org)

    All rights reserved.

    Redistribution and use in source and binary forms, with or without
    modification, are permitted provided that the following conditions
    are met:

    * Redistributions of source code must retain the above copyright
    notice, this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above
    copyright notice, this list of conditions and the following
    disclaimer in the documentation and/or other materials provided
    with the distribution.

    * Neither the name of CHAI3D nor the names of its contributors may
    be used to endorse or promote products derived from this software
    without specific prior written permission.

    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
    FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
    COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
    BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
    LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
    LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
    ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
    POSSIBILITY OF SUCH DAMAGE. 

    \author    <http://www.chai3d.org>
    \author    Francois Conti
    \author    Dan Morris
    \version   3.2.0 $Rev: 2014 $
*/
//==============================================================================

//------------------------------------------------------------------------------
#ifndef CGenericObjectH
#define CGenericObjectH
//------------------------------------------------------------------------------
#include "collisions/CCollisionBasics.h"
#include "effects/CGenericEffect.h"
#include "forces/CInteractionBasics.h"
#include "graphics/CDraw3D.h"
#include "graphics/CColor.h"
#include "graphics/CDisplayList.h"
#include "graphics/CRenderOptions.h"
#include "materials/CMaterial.h"
#include "materials/CNormalMap.h"
#include "math/CMaths.h"
#include "math/CTransform.h"
#include "system/CGenericType.h"
//------------------------------------------------------------------------------
#include <vector>
#include <list>
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
namespace chai3d {
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
class cGenericCollision;
class cGenericForceAlgorithm;
class cMultiMesh;
class cShaderProgram;
class cInteractionRecorder;
//------------------------------------------------------------------------------
typedef std::shared_ptr<cShaderProgram> cShaderProgramPtr;
//------------------------------------------------------------------------------

//==============================================================================
//==============================================================================

//==============================================================================
//==============================================================================
class cGenericObject : public cGenericType
{
    friend class cMultiMesh;

    //--------------------------------------------------------------------------
    // CONSTRUCTOR & DESTRUCTOR:
    //--------------------------------------------------------------------------

public:

    cGenericObject();

    virtual ~cGenericObject();


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - GENERAL
    //--------------------------------------------------------------------------

public:

    virtual void setEnabled(bool a_enabled,  const bool a_affectChildren = false);

    bool getEnabled() const { return (m_enabled); }


    //-----------------------------------------------------------------------
    // PUBLIC METHODS - COPY:
    //-----------------------------------------------------------------------

public:

    virtual cGenericObject* copy(const bool a_duplicateMaterialData = false,
        const bool a_duplicateTextureData = false, 
        const bool a_duplicateMeshData = false,
        const bool a_buildCollisionDetector = true) { return (NULL); }


    //-----------------------------------------------------------------------
    // PUBLIC METHODS - TRANSLATION AND ORIENTATION:
    //-----------------------------------------------------------------------

public:

    virtual void setLocalPos(const cVector3d& a_localPos)
    {
        m_localPos = a_localPos;
    }

#ifdef C_USE_EIGEN
    void setLocalPos(const Eigen::Vector3d& a_localPos)
    {
        setLocalPos(cVector3d(a_localPos[0], a_localPos[1], a_localPos[2]));
    }
#endif

    void setLocalPos(const double a_x = 0.0,
        const double a_y = 0.0, 
        const double a_z = 0.0)
    {
        setLocalPos(cVector3d(a_x, a_y, a_z));
    }

    inline cVector3d getLocalPos() const { return (m_localPos); }

    inline cVector3d getGlobalPos() const { return (m_globalPos); }

    virtual void setLocalRot(const cMatrix3d& a_localRot)
    {
        m_localRot = a_localRot;
    }

#ifdef C_USE_EIGEN
    inline void setLocalRot(const Eigen::Matrix3d a_localRot)
    {
        cMatrix3d localRot;
        localRot.copyfrom(a_localRot);
        setLocalRot(localRot);
    }
#endif

    inline cMatrix3d getLocalRot() const { return (m_localRot); }

    inline cMatrix3d getGlobalRot() const { return (m_globalRot); }

    inline void setLocalTransform(const cTransform& a_transform) 
    {
        setLocalPos(a_transform.getLocalPos());
        setLocalRot(a_transform.getLocalRot());
    }

    inline cTransform getLocalTransform() { return (cTransform(m_localPos, m_localRot)); }

    inline cTransform getGlobalTransform() { return (cTransform(m_globalPos, m_globalRot)); }

    void translate(const cVector3d& a_translation);

    void translate(const double a_x, 
        const double a_y, 
        const double a_z = 0.0);

    void rotateAboutLocalAxisRad(const cVector3d& a_axis, const double a_angleRad);

    inline void rotateAboutLocalAxisDeg(const cVector3d& a_axis,
        const double a_angleDeg) 
    { 
        rotateAboutLocalAxisRad(a_axis, cDegToRad(a_angleDeg)); 
    }

    inline void rotateAboutLocalAxisRad(const double a_axisX,
        const double a_axisY, 
        const double a_axisZ, 
        const double a_angleRad) 
    { 
        rotateAboutLocalAxisRad(cVector3d(a_axisX, a_axisY, a_axisZ), a_angleRad);
    }

    inline void rotateAboutLocalAxisDeg(const double a_axisX,
        const double a_axisY, 
        const double a_axisZ, 
        const double a_angleDeg) 
    { 
        rotateAboutLocalAxisRad(cVector3d(a_axisX, a_axisY, a_axisZ), cDegToRad(a_angleDeg));
    }

    void rotateAboutGlobalAxisRad(const cVector3d& a_axis, const double a_angleRad);

    inline void rotateAboutGlobalAxisDeg(const cVector3d& a_axis, const double a_angleDeg) 
    { 
        rotateAboutGlobalAxisRad(a_axis, cDegToRad(a_angleDeg)); 
    }

    inline void rotateAboutGlobalAxisRad(const double a_axisX,
        const double a_axisY, 
        const double a_axisZ, 
        const double a_angleRad) 
    { 
        rotateAboutGlobalAxisRad(cVector3d(a_axisX, a_axisY, a_axisZ), a_angleRad);
    }

    inline void rotateAboutGlobalAxisDeg(const double a_axisX, 
        const double a_axisY, 
        const double a_axisZ, 
        const double a_angleDeg) 
    { 
        rotateAboutGlobalAxisRad(cVector3d(a_axisX, a_axisY, a_axisZ), cDegToRad(a_angleDeg)); 
    }

    void rotateExtrinsicEulerAnglesRad(const double& a_angleRad1,
        const double& a_angleRad2,
        const double& a_angleRad3,
        const cEulerOrder a_eulerOrder);

    void rotateExtrinsicEulerAnglesDeg(const double& a_angleDeg1,
        const double& a_angleDeg2,
        const double& a_angleDeg3,
        const cEulerOrder a_eulerOrder) 
    { 
        rotateExtrinsicEulerAnglesRad(cDegToRad(a_angleDeg1), cDegToRad(a_angleDeg2), cDegToRad(a_angleDeg3), a_eulerOrder); 
    }

    void rotateIntrinsicEulerAnglesRad(const double& a_angleRad1,
        const double& a_angleRad2,
        const double& a_angleRad3,
        const cEulerOrder a_eulerOrder);

    void rotateIntrinsicEulerAnglesDeg(const double& a_angleDeg1,
        const double& a_angleDeg2,
        const double& a_angleDeg3,
        const cEulerOrder a_eulerOrder) 
    { 
        rotateIntrinsicEulerAnglesRad(cDegToRad(a_angleDeg1), cDegToRad(a_angleDeg2), cDegToRad(a_angleDeg3), a_eulerOrder); 
    }


    //-----------------------------------------------------------------------
    // PUBLIC METHODS - COMPUTING GLOBAL POSITIONS:
    //-----------------------------------------------------------------------

public:

    virtual void computeGlobalPositions(const bool a_frameOnly = true,
        const cVector3d& a_globalPos = cVector3d(0.0, 0.0, 0.0),
        const cMatrix3d& a_globalRot = cIdentity3d());

    void computeGlobalPositionsFromRoot(const bool a_frameOnly = true);


    //-----------------------------------------------------------------------
    // PUBLIC METHODS - HAPTIC EFFECTS:
    //-----------------------------------------------------------------------

public:

    bool addEffect(cGenericEffect* a_effect);

    bool removeEffect(cGenericEffect* a_effect);
    
    void deleteAllEffects();

    bool createEffectMagnetic();

    bool deleteEffectMagnetic();

    bool createEffectStickSlip();

    bool deleteEffectStickSlip();

    bool createEffectSurface();

    bool deleteEffectSurface();

    bool createEffectVibration();

    bool deleteEffectVibration();

    bool createEffectViscosity();

    bool deleteEffectViscosity();

    
    //-----------------------------------------------------------------------
    // PUBLIC METHODS - HAPTIC PROPERTIES:
    //-----------------------------------------------------------------------

public:

    virtual void setHapticEnabled(const bool a_hapticEnabled, const bool a_affectChildren = true);

    inline bool getHapticEnabled() const { return (m_hapticEnabled); }

    virtual void setStiffness(const double a_stiffness, const bool a_affectChildren = true);

    virtual void setFriction(double a_staticFriction, 
        double a_dynamicFriction, 
        const bool a_affectChildren = true);


    //-----------------------------------------------------------------------
    // PUBLIC METHODS - GRAPHIC PROPERTIES:
    //-----------------------------------------------------------------------

public:

    virtual void setShowEnabled(const bool a_show, const bool a_affectChildren = true);

    inline bool getShowEnabled() const { return (m_showEnabled); }

    virtual void setWireMode(const bool a_showWireMode, const bool a_affectChildren = false);

    inline bool getWireMode() const { return (m_triangleMode == GL_LINE); }

    virtual void setUseCulling(const bool a_useCulling, const bool a_affectChildren = false);

    inline bool getUseCulling() const { return (m_cullingEnabled); }


    //-----------------------------------------------------------------------
    // PUBLIC METHODS - TRANSPARENCY:
    //-----------------------------------------------------------------------

    virtual void setUseTransparency(const bool a_useTransparency, const bool a_affectChildren = false);

    inline bool getUseTransparency() const { return m_useTransparency; }

    virtual void setTransparencyLevel(const float a_level,
        const bool a_applyToVertices = false,
        const bool a_applyToTextures = false,
        const bool a_affectChildren = false);


    //-----------------------------------------------------------------------
    // PUBLIC METHODS - DISPLAY LISTS:
    //-----------------------------------------------------------------------

public:

    virtual void setUseDisplayList(const bool a_useDisplayList, const bool a_affectChildren = false);

    inline bool getUseDisplayList() const { return (m_useDisplayList); }

    virtual void markForUpdate(const bool a_affectChildren = false);


    //-----------------------------------------------------------------------
    // PUBLIC METHODS - VERTEX COLORS:
    //-----------------------------------------------------------------------

public:

    virtual void setUseVertexColors(const bool a_useColors, const bool a_affectChildren = false);

    inline bool getUseVertexColors() const { return (m_useVertexColors); }


    //-----------------------------------------------------------------------
    // PUBLIC METHODS - MATERIAL PROPERTIES:
    //-----------------------------------------------------------------------

public:

    virtual void setUseMaterial(const bool a_useMaterial, const bool a_affectChildren = false);

    inline bool getUseMaterial() const { return (m_useMaterialProperty); }

    virtual void setMaterial(cMaterialPtr a_material, const bool a_affectChildren = false);

    virtual void setMaterial(cMaterial& a_material, const bool a_affectChildren = false);

    virtual void backupMaterialColors(const bool a_affectChildren = false);

    virtual void restoreMaterialColors(const bool a_affectChildren = false);


    //--------------------------------------------------------------------------
    // PUBLIC METHODS - TEXTURE PROPERTIES:
    //-----------------------------------------------------------------------

public:

    virtual void setUseTexture(const bool a_useTexture, const bool a_affectChildren = false);

    inline bool getUseTexture() const { return (m_useTextureMapping); }

    virtual void setTexture(cTexture1dPtr a_texture, const bool a_affectChildren = false);


    //-----------------------------------------------------------------------
    // PUBLIC METHODS - SHADERS:
    //-----------------------------------------------------------------------

public:

    virtual void setShaderProgram(cShaderProgramPtr a_shaderProgram, const bool a_affectChildren = false);

    virtual cShaderProgramPtr getShaderProgram() { return (m_shaderProgram); }


    //-----------------------------------------------------------------------
    // PUBLIC MEMBERS - BOUNDARY BOX:
    //-----------------------------------------------------------------------

public:

    static cColorf s_boundaryBoxColor;


    //-----------------------------------------------------------------------
    // PUBLIC METHODS - BOUNDARY BOX:
    //-----------------------------------------------------------------------

public:

    virtual void setShowBoundaryBox(const bool a_showBoundaryBox, const bool a_affectChildren = false);

    inline bool getShowBoundaryBox() const { return (m_showBoundaryBox); }

    inline cVector3d getBoundaryMin() const { return (m_boundaryBoxMin); }

    inline cVector3d getBoundaryMax() const { return (m_boundaryBoxMax); }

    inline cVector3d getBoundaryCenter() const { return (m_boundaryBoxMax + m_boundaryBoxMin)/2.0; }

    inline bool getBoundaryBoxEmpty() { return (m_boundaryBoxEmpty); }

    virtual void computeBoundaryBox(const bool a_includeChildren = true);


    //-----------------------------------------------------------------------
    // PUBLIC METHODS - REFERENCE FRAME REPRESENTATION:
    //-----------------------------------------------------------------------

public:

    virtual void setShowFrame(const bool a_showFrame, const bool a_affectChildren  = false);

    inline bool getShowFrame(void) const { return (m_showFrame); }

    virtual void setFrameSize(const double a_size = 1.0, const bool a_affectChildren = false);

    inline double getFrameSize() const { return (m_frameSize); }


    //-----------------------------------------------------------------------
    // PUBLIC METHODS - COLLISION DETECTION:
    //-----------------------------------------------------------------------

public:

    void setCollisionDetector(cGenericCollision* a_collisionDetector) { m_collisionDetector = a_collisionDetector; }

    inline cGenericCollision* getCollisionDetector() const { return (m_collisionDetector); }

    virtual void deleteCollisionDetector(const bool a_affectChildren = false);

    virtual bool computeCollisionDetection(const cVector3d& a_segmentPointA,
        const cVector3d& a_segmentPointB,
        cCollisionRecorder& a_recorder,
        cCollisionSettings& a_settings);

    virtual void setShowCollisionDetector(const bool a_showCollisionDetector, const bool a_affectChildren = false);

    inline bool getShowCollisionDetector() { return (m_showCollisionDetector); }

    virtual void setCollisionDetectorProperties(unsigned int a_displayDepth, 
        cColorf& a_color, 
        const bool a_affectChildren = false);


    //-----------------------------------------------------------------------
    // PUBLIC METHODS - SCENE GRAPH:
    //-----------------------------------------------------------------------

public:

    inline void setParent(cGenericObject* a_parent) { m_parent = a_parent; }

    inline cGenericObject* getParent() const { return (m_parent); }

    inline void setOwner(cGenericObject* a_owner) { m_owner = a_owner; }

    inline cGenericObject* getOwner() { return (m_owner); }

    inline cGenericObject* getChild(const unsigned int a_index) const { return (m_children[a_index]); }

    bool addChild(cGenericObject* a_object);

    bool removeChild(cGenericObject* a_object);

    bool removeFromGraph();

    bool deleteChild(cGenericObject *a_object);

    void clearAllChildren();

    void deleteAllChildren();

    inline unsigned int getNumChildren() { return ((unsigned int)m_children.size()); }

    inline unsigned int getNumDescendants(bool a_includeCurrentObject = false);


    //-----------------------------------------------------------------------
    // PUBLIC METHODS - GHOSTING:
    //-----------------------------------------------------------------------

public:

    void setGhostEnabled(bool a_ghostEnabled) { m_ghostEnabled = a_ghostEnabled; }

    bool getGhostEnabled() { return (m_ghostEnabled); }


    //-----------------------------------------------------------------------
    // PUBLIC METHODS - GEOMETRY:
    //-----------------------------------------------------------------------

public:

    virtual void scale(const double& a_scaleFactor, const bool a_affectChildren = true);


    //-----------------------------------------------------------------------
    // PUBLIC MEMBERS - PROPERTIES:
    //-----------------------------------------------------------------------

public: 

    std::string m_name;

    cMaterialPtr m_material;

    cTexture1dPtr m_texture;

    cNormalMapPtr m_normalMap;


    //-----------------------------------------------------------------------
    // PUBLIC MEMBERS - CUSTOM USER DATA:
    //-----------------------------------------------------------------------

public:

    int m_userTag;

    void* m_userData;

    std::string m_userName;

    cGenericObject* m_userExternalObject;


    //-----------------------------------------------------------------------
    // PROTECTED MEMBERS - SCENEGRAPH:
    //-----------------------------------------------------------------------

protected:

    cGenericObject* m_parent;

    cGenericObject* m_owner;

    std::vector<cGenericObject*> m_children;


    //-----------------------------------------------------------------------
    // PROTECTED MEMBERS - POSITION & ORIENTATION:
    //-----------------------------------------------------------------------

protected:

    cVector3d m_localPos;

    cVector3d m_globalPos;

    cMatrix3d m_localRot;

    cMatrix3d m_globalRot;

    cVector3d m_prevGlobalPos;

    cMatrix3d m_prevGlobalRot;


    //-----------------------------------------------------------------------
    // PROTECTED MEMBERS - BOUNDARY BOX
    //-----------------------------------------------------------------------

protected:

    cVector3d m_boundaryBoxMin;

    cVector3d m_boundaryBoxMax;

    bool m_boundaryBoxEmpty;


    //-----------------------------------------------------------------------
    // PROTECTED MEMBERS - FRAME REPRESENTATION [X,Y,Z]:
    //-----------------------------------------------------------------------

protected:

    double m_frameSize;

    double m_frameThicknessScale;


    //-----------------------------------------------------------------------
    // PROTECTED MEMBERS - GENERAL OPTIONS:
    //-----------------------------------------------------------------------

protected:

    bool m_enabled;

    bool m_showEnabled;

    bool m_hapticEnabled;

    bool m_ghostEnabled;

    bool m_showFrame;

    bool m_showBoundaryBox;

    bool m_showCollisionDetector;

    bool m_useTextureMapping;

    bool m_useMaterialProperty;

    bool m_useVertexColors;

    bool m_useDisplayList;

    cDisplayList m_displayList;

    int m_triangleMode;

    bool m_useTransparency;

    bool m_cullingEnabled;

    static cMaterialPtr s_defaultMaterial;

    cShaderProgramPtr m_shaderProgram;

    cTransform m_frameGL;


    //-----------------------------------------------------------------------
    // PROTECTED MEMBERS - COLLISION DETECTION:
    //-----------------------------------------------------------------------

protected:

    cGenericCollision* m_collisionDetector;


    //-----------------------------------------------------------------------
    // PROTECTED MEMBERS - HAPTIC EFFECTS AND INTERACTIONS:
    //-----------------------------------------------------------------------

protected:

    std::vector<cGenericEffect*> m_effects;


    //-----------------------------------------------------------------------
    // PROTECTED VIRTUAL METHODS:
    //-----------------------------------------------------------------------

protected:

    virtual void render(cRenderOptions& a_options);

    virtual void updateGlobalPositions(const bool a_frameOnly) {};

    virtual void updateBoundaryBox() {};

    virtual void scaleObject(const double& a_scaleFactor) { m_boundaryBoxMin.mul(a_scaleFactor); m_boundaryBoxMax.mul(a_scaleFactor);}

    virtual void computeLocalInteraction(const cVector3d& a_toolPos,
        const cVector3d& a_toolVel,
        const unsigned int a_IDN);

    virtual cVector3d computeOtherInteractions(const cVector3d& a_toolPos,
        const cVector3d& a_toolVel,
        const unsigned int a_IDN,
        cInteractionRecorder& a_interactions) { return cVector3d(0,0,0); }

    virtual bool computeOtherCollisionDetection(cVector3d& a_segmentPointA,
        cVector3d& a_segmentPointB,
        cCollisionRecorder& a_recorder,
        cCollisionSettings& a_settings) {return(false);}


    //-----------------------------------------------------------------------
    // PROTECTED METHODS:
    //-----------------------------------------------------------------------

protected:

    void copyGenericObjectProperties(cGenericObject* a_objDest, 
        const bool a_duplicateMaterialData,
        const bool a_duplicateTextureData, 
        const bool a_duplicateMeshData,
        const bool a_buildCollisionDetector);


    //-----------------------------------------------------------------------
    // PUBLIC MEMBERS - INTERACTIONS:
    //-----------------------------------------------------------------------

public: 

    cVector3d m_interactionPoint;

    cVector3d m_interactionNormal;

    bool m_interactionInside;


    //-----------------------------------------------------------------------
    // PUBLIC MEMBERS - GENERAL
    //-----------------------------------------------------------------------

public:

    virtual void renderSceneGraph(cRenderOptions& a_options);

    virtual void adjustCollisionSegment(cVector3d& a_segmentPointA, cVector3d& a_segmentPointAadjusted);

    virtual cVector3d computeInteractions(const cVector3d& a_toolPos,
        const cVector3d& a_toolVel,
        const unsigned int a_IDN,
        cInteractionRecorder& a_interactions);
};

//------------------------------------------------------------------------------
} // namespace chai3d
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
#endif
//------------------------------------------------------------------------------