D:/CHAI3D/build-2-0-0/2.0.0/win32/src/scenegraph/CGenericObject.h

Go to the documentation of this file.

//===========================================================================
/*
    This file is part of the CHAI 3D visualization and haptics libraries.
    Copyright (C) 2003-2009 by CHAI 3D. All rights reserved.

    This library is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License("GPL") version 2
    as published by the Free Software Foundation.

    For using the CHAI 3D libraries with software that can not be combined
    with the GNU GPL, and for taking advantage of the additional benefits
    of our support services, please contact CHAI 3D about acquiring a
    Professional Edition License.

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

//---------------------------------------------------------------------------
#ifndef CGenericObjectH
#define CGenericObjectH
//---------------------------------------------------------------------------
#include "math/CMaths.h"
#include "graphics/CDraw3D.h"
#include "graphics/CColor.h"
#include "graphics/CMacrosGL.h"
#include "graphics/CMaterial.h"
#include "graphics/CTexture2D.h"
#include "collisions/CCollisionBasics.h"
#include "forces/CInteractionBasics.h"
#include "effects/CGenericEffect.h"
#include "extras/CGenericType.h"
//---------------------------------------------------------------------------
#include <typeinfo>
#include <vector>
#include <list>
//---------------------------------------------------------------------------
using std::vector;
//---------------------------------------------------------------------------
class cTriangle;
class cGenericCollision;
class cGenericPointForceAlgo;
class cMesh;
//---------------------------------------------------------------------------
// TYPE DEFINITION
//---------------------------------------------------------------------------
typedef enum {
  CHAI_RENDER_MODE_RENDER_ALL = 0,
  CHAI_RENDER_MODE_NON_TRANSPARENT_ONLY,
  CHAI_RENDER_MODE_TRANSPARENT_BACK_ONLY,
  CHAI_RENDER_MODE_TRANSPARENT_FRONT_ONLY
} chai_render_modes;
//---------------------------------------------------------------------------

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

//===========================================================================
//===========================================================================
class cGenericObject : public cGenericType
{

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

    cGenericObject();

    virtual ~cGenericObject();


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

    void setPos(const cVector3d& a_pos)
    {
        m_localPos = a_pos;
    }

    void setPos(const double a_x, const double a_y, const double a_z)
    {
        m_localPos.set(a_x, a_y, a_z);
    }

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

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

    inline void setRot(const cMatrix3d& a_rot)
    {
        m_localRot = a_rot;
    }

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

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

    void translate(const cVector3d& a_translation);

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

    void rotate(const cMatrix3d& a_rotation);

    void rotate(const cVector3d& a_axis, const double a_angle);


        //-----------------------------------------------------------------------
    // METHODS - GLOBAL / LOCAL POSITIONS:
        //-----------------------------------------------------------------------

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

    void computeGlobalCurrentObjectOnly(const bool a_frameOnly = true);

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


        //-----------------------------------------------------------------------
    // METHODS - INTERACTIONS, FORCES AND EFFECTS:
        //-----------------------------------------------------------------------

    // Descend through child objects to compute interactions for all cGenericEffects.
    cVector3d computeInteractions(const cVector3d& a_toolPos,
                                  const cVector3d& a_toolVel,
                                  const unsigned int a_IDN,
                                  cInteractionRecorder& a_interactions,
                                  cInteractionSettings& a_interactionSettings);

    cVector3d m_interactionProjectedPoint;

    bool m_interactionInside;

    vector<cGenericEffect*> m_effects;

    void addEffect(cGenericEffect* a_newEffect);


        //-----------------------------------------------------------------------
    // METHODS - HAPTIC PROPERTIES:
        //-----------------------------------------------------------------------
    void setStiffness(double a_stiffness, const bool a_affectChildren=0);

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


        //-----------------------------------------------------------------------
    // METHODS - GRAPHICS:
        //-----------------------------------------------------------------------

    cMaterial m_material;

    cTexture2D* m_texture;

    void setShowEnabled(const bool a_show, const bool a_affectChildren = false);

    bool getShowEnabled() const { return (m_show); }

    void setHapticEnabled(const bool a_hapticEnabled, const bool a_affectChildren = false);

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

    void setShowTree(const bool a_showTree, const bool a_affectChildren = false);

    bool getShowTree() const { return (m_showTree); }

    void setTreeColor(const cColorf& a_treeColor, const bool a_affectChildren  = false);

    cColorf getTreeColor() const { return (m_treeColor); }

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

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

    void setShowBox(const bool iShowBox, const bool iAffectChildren = false);

    bool getShowBox() const { return (m_showBox); }

    void setBoxColor(const cColorf& a_boxColor, const bool a_affectChildren = false);

    cColorf getBoxColor() const { return (m_boundaryBoxColor); }

    void setShowCollisionTree(const bool a_showCollisionTree, const bool a_affectChildren = false);

    bool getShowCollisionTree() { return (m_showCollisionTree); }

    virtual void onDisplayReset(const bool a_affectChildren = true);

    virtual void finalize(const bool a_affectChildren = true);

    virtual void unfinalize(const bool a_affectChildren = true);

    virtual void renderSceneGraph(const int a_renderMode=CHAI_RENDER_MODE_RENDER_ALL);


    //-----------------------------------------------------------------------
    // METHODS - GRAPHIC RENDERING:
    //-----------------------------------------------------------------------

    void setMaterial(cMaterial& a_mat, const bool a_affectChildren=false, const bool a_applyPhysicalParmetersOnly=false);

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

    void setTransparencyRenderMode(const bool a_useMultipassTransparency, const bool a_affectChildren=true);

    bool getMultipassTransparencyEnabled() const { return m_useMultipassTransparency; }

    void setUseTransparency(const bool a_useTransparency, const bool a_affectChildren=true);

    bool getUseTransparency() const { return m_useTransparency; }

    void setWireMode(const bool a_showWireMode, const bool a_affectChildren=true);

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

    void setUseCulling(const bool a_useCulling, const bool a_affectChildren=true);

    bool getUseCulling() const { return m_cullingEnabled; }

    void setUseVertexColors(const bool a_useColors, const bool a_affectChildren=true);

        bool getUseVertexColors() const { return m_useVertexColors; }

    void setUseMaterial(const bool a_useMaterial, const bool a_affectChildren=true);

    bool getUseMaterial() const { return m_useMaterialProperty; }

    void setUseTexture(const bool a_useTexture, const bool a_affectChildren=true);

    bool getUseTexture() const { return m_useTextureMapping; }

    void setTexture(cTexture2D* a_texture, const bool a_affectChildren=0);

    cTexture2D* getTexture() const { return(m_texture); }


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

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

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

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

    void computeBoundaryBox(const bool a_includeChildren=true);


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

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

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


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

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

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

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

    void deleteCollisionDetector(const bool a_affectChildren = false);

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

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


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

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

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

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

    void addChild(cGenericObject* a_object);

    bool removeChild(cGenericObject* a_object);

    bool containsChild(cGenericObject* a_object, bool a_includeChildren=false);

    bool deleteChild(cGenericObject *a_object);

    void clearAllChildren();

    void deleteAllChildren();

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

    unsigned int getNumDescendants(bool a_includeCurrentObject=false);

    void enumerateChildren(std::list<cGenericObject*>& a_childList, bool a_includeCurrentObject=true);

    inline bool removeFromGraph()
    {
        if (m_parent) return m_parent->removeChild(this);
        else return false;
    }

        void setAsGhost(bool a_ghostStatus);

        bool getAsGhost() { return (m_ghostStatus); }


        //-----------------------------------------------------------------------
    // METHODS - LINKS TO EXTERNALS:
        //-----------------------------------------------------------------------

    void setExternalParent(cGenericType* a_externalParent, const bool a_affectChildren = false);

    inline cGenericType* getExternalParent() { return (m_externalParent); }

    void setSuperParent(cGenericObject* a_superParent, const bool a_affectChildren = false);

    inline cGenericObject* getSuperParent() { return (m_superParent); }


        //-----------------------------------------------------------------------
    // METHODS - SCALING:
        //-----------------------------------------------------------------------

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

    void scale(const cVector3d& a_scaleFactors, const bool a_includeChildren = true);


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

    int m_tag;

    virtual void setTag(const int a_tag, const bool a_affectChildren=0);

    void* m_userData;

    virtual void setUserData(void* a_data, const bool a_affectChildren=0);

    char m_objectName[CHAI_SIZE_NAME];

    virtual void setName(const char* a_name, const bool a_affectChildren=0);


  protected:

        //-----------------------------------------------------------------------
    // MEMBERS - SCENE GRAPH:
        //-----------------------------------------------------------------------

    cGenericObject* m_parent;

    vector<cGenericObject*> m_children;

        bool m_ghostStatus;


        //-----------------------------------------------------------------------
    // MEMBERS - LINKS TO EXTERNALS:
        //-----------------------------------------------------------------------

    cGenericType* m_externalParent;

    cGenericObject* m_superParent;


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

    cVector3d m_localPos;

    cVector3d m_globalPos;

    cMatrix3d m_localRot;

    cMatrix3d m_globalRot;

    cVector3d m_prevLocalPos;

    cMatrix3d m_prevLocalRot;


        //-----------------------------------------------------------------------
    // MEMBERS - DYNAMIC OBJECTS:
        //-----------------------------------------------------------------------

    cVector3d m_prevGlobalPos;

    cMatrix3d m_prevGlobalRot;


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

    cVector3d m_boundaryBoxMin;

    cVector3d m_boundaryBoxMax;


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

    double m_frameSize;

    double m_frameThicknessScale;


        //-----------------------------------------------------------------------
    // MEMBERS - GRAPHICS:
        //-----------------------------------------------------------------------

    bool m_show;

    bool m_hapticEnabled;

    bool m_showFrame;

    bool m_showBox;

    bool m_showTree;

    bool m_showCollisionTree;

    cColorf m_treeColor;

    cColorf m_boundaryBoxColor;

    bool m_useTextureMapping;

    bool m_useMaterialProperty;

    bool m_useVertexColors;

    int m_triangleMode;

    bool m_useTransparency;

    bool m_useMultipassTransparency;

    bool m_cullingEnabled;


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

    cGenericCollision* m_collisionDetector;


        //-----------------------------------------------------------------------
    // GENERAL VIRTUAL METHODS::
        //-----------------------------------------------------------------------

    virtual void render(const int a_renderMode=CHAI_RENDER_MODE_RENDER_ALL);

    virtual void updateGlobalPositions(const bool a_frameOnly) {};

    virtual void updateBoundaryBox() {};

    virtual void scaleObject(const cVector3d& a_scaleFactors) {};

    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,
                                               cInteractionSettings& a_interactionSettings) { return cVector3d(0,0,0); }

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


        //-----------------------------------------------------------------------
    // MEMBERS - OPEN GL:
        //-----------------------------------------------------------------------

    cMatrixGL m_frameGL;
};


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

---

CHAI3D 2.0.0 documentation
Please address any questions to support@chai3d.org
(C) 2003-2009 - CHAI 3D
All Rights Reserved.