/Users/craigcornelius/Projects/SPRING Mac Release 0.2/object.h

Go to the documentation of this file.

// $Id: object.h,v 1.160 2006/02/28 03:20:19 hawaii Exp $
// $Copyright: (c)2001 National Biocomputation Center, Stanford University $

#ifndef Object_Header
#define Object_Header

#include "glui.h"

#include "nodearray.h"
#include "edgearray.h"
#include "facearray.h"
#include "tetraarray.h"
#include "sensor.h"
#include "reallocablearray.h"
#include "geometryreplicator.h"
#include "boundingsphere.h"
#include "boundingbox.h"
#include "displaymode.h"
#include "socket.h"
#include "timer.h"
#include "util.h"
#include "texture.h"

class ObjectArray;
class Sensor;
class BoundingSphereNode;


typedef struct{
    Node* node;
    double test;
} testCell;

typedef struct {                // BOUNDING_SPHERE collision detection 
    BoundingSphereLeaf* mySphere;
    BoundingSphereLeaf* otherSphere;
    Object* colObj;             // seems to always be unused???
    Point3D int_pt;
    double near1;               // these are parameters for nearest point of 2 edges
    double near2;
    double dist;                // and distance between 2 edges
} Collision_pair;

typedef struct CollisionBoxPairStruct {         // AABB collision detection
        BoundingBox* myCollisionBox;
        BoundingBox* otherCollisionBox;
} CollisionBoxPair;

typedef struct {
    int                 node_index; // node index to rotate around
    int         sensor_index;
    Point3D     rotation_vector; // vector to rotate around
    double      max_open; // maxiumum rotation to open around this vector
    double      max_closed; // maximum rotation to close around this vector
    int                 colors_pos[3]; // what color in the nodearray do this rotation
    int                 colors_neg[3]; // what color in the nodearray do this rotation
} hinge;

typedef struct {
        Point3D hingeVector;                    // vector to rotate around
        int hingeNodeIndex;                             // index of a node in the hinge (needs to be tied to other obj)
        int     moveHingeNodeIndex;                     // index of a node which is not in the hinge
        Point3D hingeAngleVector;               // 0 degree vector used for min/max angle
        float minHingeAngle;                    // minimum angle in respect to moveHingeNodeIndex & hingeAngleVector
        float maxHingeAngle;                    // maximum angle in respect to moveHingeNodeIndex & hingeAngleVector
} RigidHinge;


class Object {
public:
    // most objects are physical (obey lighting),some are virtual (thread,cursor)
    Object();
    ~Object();
    static const char* rcsid;
    static int debug;
    
    // useful enums
    enum object_type {nodes_only, edges_only, faces_only, tetras_only};
    enum dynamics_type {rest, rigid, deformable, articulate, button};
    enum behavior_type {none, grabbing, cutting, deleting, poking, 
                ablating, cauterizing, coloring, quisar_test, dilating, beating, fluid};
    enum numerical_method {euler, euler_ordered, runge, runge_4thorder, quasi,
        quasi_ordered, bogus, FSA, FSAF};
    enum collision_extent_type {no_collisions, external, 
        internal, internal_external};
        enum collision_force_type {normal_force, penetration_depth_force};
    enum texture_env_mode {modulate, blend, decal, replace};
    enum texture_wrap_st {repeat, clamp};
    enum texture_min_mag_filter {linear, nearest};
    
    // Collisions
    void setCollisionExtent(collision_extent_type extent);
    collision_extent_type getCollisionExtent();
        void setCollisionForce(collision_force_type collision_force_) { collision_force = collision_force_; }
        collision_force_type getCollisionForce() { return collision_force; }
        ReallocableArray<Face*> getCollisionFaces() { return collision_faces; }

        void ConstructCollisions();
        void DestructCollisions();
    void ResetCollisions();
    void DetectCollisions(Object* other_obj);
    void MarkCollisions();
    void ResolveCollisions();
    bool CollidesWith(Object* other_obj);

    Point3D CalculateForce(Face* myFace, Face* otherFace);
    void addEverythingToUpdateList();
    
        // BOUNDING_SPHERE_CD stuff
    BoundingSphereNode* getBoundingSphereRoot();
                void setBoundingSphereRoot(BoundingSphereNode* rt);
                
    void CreateSphereTree();
    void DestroySphereTree();
    
    void addToSphereTree(Face* face);
    void removeFromSphereTree(Face* face);
        void addToSphereTree(Tetra* tetra);
    void removeFromSphereTree(Tetra* tetra);
    
        void removeFromCollisionPairs(Face* me);
        void removeFromCollisionPairs(Tetra* me);
    
    void addToUpdateList(Edge* addedge);
    void addToUpdateList(Face* addface);
    void addToUpdateList(Tetra* addtetra);
    
    int ResolveFaceFaceCollisions(Collision_pair* c_p, 
        Point3D* this_haptic_force_p);
    void ResolveEdgeEdgeCollisions(Collision_pair* c_p);
    
    int  getNumTotalCollisions();
    void findNodeNodeCollisions(Object* other);
    void findNodeEdgeCollisions(Object* other);
    void findNodeFaceCollisions(Object* other);
    void findNodeTetraCollisions(Object* other);
    void findEdgeEdgeCollisions(Object* other);
    void findEdgeFaceCollisions(Object* other);
    void findEdgeTetraCollisions(Object* other);
    void findFaceFaceCollisions(Object* other);
    void findFaceTetraCollisions(Object* other);
    void findTetraTetraCollisions(Object* other);

        void CollisionPairAdd(Collision_pair pair);
        int CollisionPairGetNumElements();
        Collision_pair CollisionPairGet(int i);
    
        // AABB_CD collision detection algorithm
        BoundingBox* getBoundingBoxRoot() { return boundingBoxRoot; }
        void setBoundingBoxRoot(BoundingBox* boundingBoxRoot_) { boundingBoxRoot = boundingBoxRoot_; }
        bool isDoBoundingBoxRootUpdate() { return doBoundingBoxRootUpdate; }
        void setDoBoundingBoxRootUpdate(bool doUpdate_) { doBoundingBoxRootUpdate = doUpdate_; }
        int getMaxLevelCollisionCheck() { return maxLevelCollisionCheck; }
        void setMaxLevelCollisionCheck(int maxLevel_) { maxLevelCollisionCheck = maxLevel_; }

    //
    // startup stuff
    //
    void Init(ObjectArray* objectarray_in, char* name);
    
    //
    // links to nodearray, edgearray, facearray
    //
    NodeArray* getNodeArray() { return(&nodearray); }
    EdgeArray* getEdgeArray() { return(&edgearray); }
    FaceArray* getFaceArray() { return(&facearray); }
        TetraArray* getTetraArray() { return(&tetraarray); }
    
    //
    // File I/O Routines
    //
    int Read(char* filename);
    int Read(char* dirname_part, char* filename_part);
    int ReadAmira(FILE *fp);
    int ReadMesh(FILE* fp);
    int ReadSMF(FILE* fp);
    int ReadOBJ(FILE* fp);
    int ReadSOBJ(FILE* fp);       // Spring-OBJ -> to create object internally already defined, such as sphere
    int ReadFRD(FILE* fp);
    int ReadVRML(FILE* fp, int create_subobjects=1);
                int ReadVRMLObject(FILE* fp, Matrix original_xform, int create_subobjects=1, int is_vrml2=0);
    int ReadCyberware(FILE* fp);
    void ParseAttribute(char* line);    // for reading in .desc file attributes
    
    //
    
    // Spontaneous generation routines
    //
    
    void CreateThread(double length, double node_spacing, int orientation, 
        Point3D offset, double edgethresh_in = 0.10, int first_seg = 0);
    void CreateEdgeRing(Point3D center, double radius, int numedges,
                                double edgethresh_in);
    void CreateTestLine(int num_segs, double length, Point3D offset,int fix_end);
    void CreateEquiMesh(int numlevels, double edgelength);
    void CreateTube(char orientation, int num_radii, int num_rings, double radius, 
        double length, Point3D offset, int diag1 = 0, int diag2 = 0,
        int fix_num = 0, double inner_radius = -1.0,
        int cross1 = 0, int cross2 = 0, int capped = 0,
        double sc1 = 1.0, double sc2 = 1.0, double rl_out = -1.0, 
        double rl_in = -1.0, double rl_betw = -1.0);
    int CreateSphere(int numlayers, double radius, double inner = -1.0);
    void CreatePlane(double x_length, double y_length, int x_steps, int y_steps,
        Point3D offset, char orientation = 'z');
    void CreateForcep(double length, double width);
    void CreateHexSurfaceDeformedMenu(void);
    void CreateHexSurfaceDeformed(void);
    void CreateEndoscope(double length);
    void CreateNeedle(double length, double width, Point3D offset);
    void CreateGrabby(double length, double width, Point3D offset);
    void CreateCutterTool(float scalefactor);
    void CreatePlaneTool(double width, double height, Point3D offset);
    void CreateBox(double width, double height, double depth);
    void CreateBox2(int xlayers, int ylayers, int zlayers, double length,
        int outlayers, double sc_out=0, double sc_in=0);
    void CreateNodeCloud(int num_nodes, int radius, Point3D offset);
    
    // 
    //Generally Useful Stuff
    //
    int uses_viagra;
    
    Node* closest_node;                            // closest node of object we are affecting
    int being_grabbed;                             // are we currently being grabbed?
    float prev_grabbing_activation;    // activation for sensor when we tried to grab last

    char* getName();
        char* getPath();    // returns the path if available
    char* getChildName(void);
    void setName(char* new_name);
        void setPath(char* filepath);  // sets the file path excl. filename to the file if any
    void setChildName(char* new_child_name);

    // used by FSA algorithm
    double getTime();
    void resetTimer();  
    
    ObjectArray* getObjectArray();
    
    void setType(object_type t);
    object_type getType();
    Point3D getCenter();
    double getRadius();
    
    void Select();
    void Unselect();
    
    void SetVisible(int on);
    int  isVisible();
    
    int IsAScreen;
    
    //
    // bounding box and sphere stuff, old
    //
    int intersectsBoundingSphere(Object* test_obj);
    void getBoundingBox(Point3D* min_p, Point3D* max_p);
    int intersectsBoundingBox(Object *obj, double e=0.0);
    double distanceToBoundingBox(Point3D pt);
    
    // 
    // texture stuff
    //
    void setTexture(char* filename = NULL);  // NULL = use name of object.rgb
    void setTextureCoords(Node::texture_coord_type t);
    unsigned char* getTexture();
    void moveTexture(Point3D translation, Point3D scaling);
    texture_wrap_st getTextureWrap() { return texture_wrap; }
    void setTextureWrap(texture_wrap_st texture_wrap_) { texture_wrap = texture_wrap_; }

    //
    // object properties
    // 
    dynamics_type getDynamics();
    void setDynamics(dynamics_type d);

    double getEdgeThresh();

    behavior_type getBehavior();
    void setBehavior(behavior_type b);
    
    numerical_method getNumMethod();
    void setNumMethod(numerical_method n);
    
    void setAmbientColor(float red, float green, float blue, float alpha);
    float* getAmbientColor();
    void setDiffuseColor(float red, float green, float blue, float alpha);
    float* getDiffuseColor();
    void setSpecularColor(float red, float green, float blue, float alpha);
    float* getSpecularColor();
    void setShininess(float s);
    float* getShininess();
    
    void setBackAmbientColor(float red, float green, float blue, float alpha);
    float* getBackAmbientColor();
    void setBackDiffuseColor(float red, float green, float blue, float alpha);
    float* getBackDiffuseColor();
    void setBackSpecularColor(float red, float green, float blue, float alpha);
    float* getBackSpecularColor();
    void setBackShininess(float s);
    float* getBackShininess();
    
    DisplayMode getDisplayMode();
    void setDisplayMode(DisplayMode dm_in);

        void setObjectWeight(double w);
        double getObjectWeight();
    
    // label stuff
    void setLabelOffset(float new_lo);
    
    void PrintInfo();
    friend ostream& operator<<(ostream& os, Object& o);
    
    //
    // Core functionality
    //
    void getPosAngle(Point3D* pos_p, Point3D* rot_p);
    
    double getVolume();
    double getSurfaceArea();
    
    void setExtrusionParameters(double exlength, int Nb_ex, int extype, 
        int algo, int facesOutside, int facesLayers, int fixLastLayer,
        int Nb_face_surf, int Nb_pts_surf, int Nb_edge_surf);
        void getExtrusionParameters(double* exlength, int* Nb_ex, int* extype, 
        int* algo, int* facesOutside, int* facesLayers, int* fixLastLayer,
        int* Nb_face_surf, int* Nb_pts_surf, int* Nb_edge_surf);
    int getNb_Face_Surf();
    
    void ForceDisplayUpdate();
    
    void flipFaces();
    
    void Update();
    void tipUpdate();   // for keeping track of motion delta
    
    int getGroupNumber();
    void setGroupNumber(int group);
    
    // drawing
    void Draw();
    void DrawGeometry();
    void DrawBoundingBox();
    void DrawLabel();
        void DrawPrincipalAxes();
    void GeometryReplicate(GeometryReplicator* gr);
    
    Node* findClosestNode(Point3D pt);
    double findClosestNodesBetweenObjects(Object* other_obj, Node** our_node_p,
        Node** other_node_p);
    
    void ShrinkWrap(Object* other_obj);
    
    void ElasticAdjustment(ObjectArray* universe_p, Object* current_object);
    
    void TieNode0(Object* other_obj);
    void TieObject(Object* other_obj);
    
    void Join(Object* other_obj);
    void MergeSubparts(double dist);
    
    void ExtrusionMenu(void);
    void PerformExtrusion(int glui_p);
    void Extrusion(Object* obj);
    
    // exporting
    void SaveAsAmira(ostream& os);
    void SaveAsMesh(ostream& os);
    void SaveAsFRD(ostream& os);
    void SaveAsSMF(ostream& os);
    void SaveAsDXF(ostream& os);
    void SaveAsVRML1(ostream& os);
    void SaveAsVRML2(ostream& os);
    void SaveAsSTL(ostream& os);
    
    // behaviors/collisions
    void HandleBehavior();
        void HandleInteractiveBehavior();
        void HandleSpontaneousBehavior();
        void setDoDeformOnlyOnGrab(int i);
        void PreserveVolume();
    
    // movement/repositioning
    void CenterObject();
    void Move(Point3D motion_vector);
    
    // coloring/subobjects
    int ColorConnectedComponents();
    int SpreadOutColor();
    void ResetColors(int color = 0);
    void SplitColor(Object* tool);
    void SplitPieces();
    void DeleteNodesOfColor(int color);
    void ColorFacesUsingMarkers(int color, Node** markers, int nummarkers);
    void FillInColors(int color);
    void FixNodesOfColor(int color);
    void ColorNodesWithinBoundingBox(Point3D min, Point3D max, int color);
    
    void ReflectMesh(int axis, double value);
    
    // path ops
    int WalkGreedyPathUsingNodes(Node* start, Node* end, Node** path, int max);
    void DuplicatePath(Node** path, int num_nodes_on_path);
    void ColorPath(int color, Node** path, int num_nodes_on_path);
    
    void SanityCheck();
    void Cleanup();
    
    double CumulativeDistanceBetweenObjects(Object* obj_p);
    
    void RegisterToGivenObject(Object* obj_p);
    
    void Scale(double value);
    void ScaleByNormal(double value);
    
    void ReorderFacesBasedOnViewer();
    void Refresh();
    void Spread(double kx, double ky, double kz);
    void Translate(double kx, double ky, double kz);
    void Rotate90() {nodearray.rotate90();}
    void Rotate(int axis = 0, double t = PI/2);
    
    // 
    // Functions for objects attached to sensors
    //
    void LinkToSensor(Sensor* sensor_p); // object is linked to given sensor
    int isLinked();    // is the object linked to a sensor?
    Sensor* getSensor();
    Point3D getSensorOffset();
    void setSensorOffset(Point3D offset); // sensor pos w.r.t. center of obj
    
    // for grabbing
    Point3D getTip();
    void setTip(int index);
    Point3D getTipDelta();

        // for fluids (to set the fluid height over ground level 0)
        double getHeight();
        void setHeight(double height);

    // for having subparts move separately
    int getLinkedPart();
    void setLinkedPart(int lp);
    
    // for hinges
    Point3D getHingePoint();
    void setHingePoint(Point3D p);
    void setMaxOpen(Point3D angles);
    void setMaxClosed(Point3D angles);
    void addToHinges(int si, int ai, Point3D r, double maxopen, double maxclosed, 
        int col0, int col1, int col2);
    
        // for rigid object hinges
        RigidHinge* getRigidHinge();
        void setRigidHinge(RigidHinge* newRigidHinge);
        float getRigidHingeAngle(); 

    // link subpart only
    void LinkSubpartToSensor(int subpart, Sensor* sensor_p); 
    
    // for transforming an object's parts
    void xformHingedObject();
    void xformObject();
        void xformCopies(ReallocableArray<Point3D> &tempnodepos, ReallocableArray<int> tempnodecol, int part, Matrix m, 
        Point3D center_offset, Point3D origin);
    
    
    // 
    // DECIMATION
    //
    static int TestCompare(const void* entry1, const void* entry2);
    void Decimation(int typeOfDecimation, int amountOfDecimation, double value);
    void Triangulate1(int n, Node* polygon[], Point3D normal, int faceIndex[]);
    void TriRecurse(int n, Node* polyInit[], Node* poly[], int labels[], 
        Point3D normal, int faceIndex[], int* numFace_p, int* test);
                double EdgeStats();
                void EdgeCollapse(double limit);
    
    // 
    // CUTTING
    //
    void CutUsingMarkers(Node** markers, int nummarkers);
    void CuttingByDeleting(Object *cutter);
    
    void        addToCuttingFaces(Face* face);
    Face* getCuttingFace(int index);
    int         numCuttingFaces();
    int         isACuttingFace(Face* you);
    
    void        addToCuttingEdges(Edge* edge);
    Edge* getCuttingEdge(int index);
    int         numCuttingEdges();
    int         isACuttingEdge(Edge* you);
    
    void        addToCutPath(Node* intersection);
    void        clearCutPath();
    int         numCutPath();
    Node* getCutPathNode(int index);
    
    int testEdge(Point3D entPt, Edge* myedge, Edge* you, int test);
    int testFace(Face* myface, Edge* you);
    
    int inCollisionWithMyCuttingEdges(Edge* other_edge);        
    int inCollisionWithMyCuttingEdges(Face* other_face);        
    int inCollisionWithMyCuttingFaces(Edge* other_edge);        
    int inCollisionWithMyCuttingFaces(Face* other_face);        
    
    void        addToLastFaces(Face* me);
    Face* getLastFace(int index);
    int         numLastFacesInCollision();      
    int         isInLastFaces(Face* me);        
    
    int testEdges(Face* me, Edge* you, int test);
    
    int updateFaceCutter(Face* me, Edge* you, int test);
    int moveFaceCutter(Face* me, Edge* you, int test);   
    int finishFace(Face* me);
    int CutFace(Face* me,int v[], int caseIdx);
    
    void        addToLastTetras(Tetra* me);
    Tetra*      getLastTetra(int index);
    int         numLastTetrasInCollision();     
    int         isInLastTetras(Tetra* me);      
    
    int updateTetraCutter(Tetra* me, Edge* you, int test);
    int moveTetraCutter(Tetra* me, Edge* you, int test);
    
    int finishTetra(Tetra* me);
    int CutTetra(Tetra* me, int v[], int caseIdx);
    
    
    // 
    //Menus
    //
    void Menu();
    
protected:
    ObjectArray* objectarray_p;
    
    enum {NAME_LENGTH = 1024};
    enum {PATH_LENGTH = 1024};
    char name[NAME_LENGTH];
        char path[PATH_LENGTH];      // path to file if any (needed for texture loading)
    char child_name[NAME_LENGTH];
    
    object_type              type;
    dynamics_type            dynamics;
    double                   edgethresh; // thickness of edges
    behavior_type            behavior;
    numerical_method         nummethod;
    texture_env_mode         texture_mode;
    texture_wrap_st          texture_wrap;
    texture_min_mag_filter   texture_filter;
    collision_extent_type    collision_extent;
        collision_force_type     collision_force;   // type of force returned by this object
        ReallocableArray<Face*>  collision_faces;   // list of collisionfaces if any
        int                      being_modified;
    

    // my bounding sphere (BOUNDING_SPHERE_CD)
    BoundingSphereNode* boundingSphereRoot;
    int                         num_total_collisions;
    ReallocableArray<Face*>     cutting_faces;
    ReallocableArray<Edge*>     cutting_edges;
    ReallocableArray<Face*>         last_faces_in_collision;
    ReallocableArray<Tetra*>    last_tetras_in_collision;
    
        // Bounding box (for AABB_CD collision detection algorithm)
        BoundingBox* boundingBoxRoot;
        bool doBoundingBoxRootUpdate;
        int maxLevelCollisionCheck;                             // maximum level to check for collisions
        ReallocableArray<CollisionBoxPair>* collisionBoxPairs;

        // Info about a possibly connected sensor (does not apply to all objects)
    Sensor* sensor_p;          // what sensor we're linked to
    Point3D sensor_offset;     // sensor position on object w.r.t center
    int     linked_part;       // part of this object linked to the sensor

    // used by FSA algorithm
    Timer timer;
    
    ReallocableArray<hinge> hinges;     // for new-type hinged objects
    
    ReallocableArray<Node*> cutPath;

        // Bounding sphere collision pairs
        ReallocableArray<Collision_pair> collision_pairs;

    // for hinges on rigid objects (Chris) - used in nodearray.updateRigidNodes()
        RigidHinge* rigidHinge;

    // graphics stuff
    int visible;                  // is this object visible?
    int selected;                 // is this object selected?
    
    // for grabbing
    int tip_node;                            
    Point3D oldtip;
    Point3D tipdelta;     // for keeping track of object's motion
    Point3D oldbase;
    Point3D basedelta;    // for keeping track of object's motion
        int do_deform_only_on_grab;  // only deform when grabbed
        
        int do_preserve_volume; //volume preservation after deformation
    double original_volume;

    // for fluids (to set the fluid height over ground)
        double height;

    // Extrusion stuff
    int objextrusions;    // number of layers produced by the extrusion function
    int Nb_pts_surf, Nb_edge_surf, Nb_face_surf; // #s before any extrusion
    double exlength;
    int Nb_ex, extype, algo, facesOutside, facesLayers, fixLastLayer;
    
    // Hex surface stuff
    Point3D offset; int orient; double length; int n_width; double defcoef;
    
    // texture stuff
    unsigned char* texture;
    iPoint3D texture_size;
    
    // objects keep their own data now
    NodeArray nodearray;
    EdgeArray edgearray;
    FaceArray facearray;
    TetraArray tetraarray;
    
    // material properties
    float mat_ambient[4];
    float mat_diffuse[4];
    float mat_specular[4];
    float mat_shininess[1];
    
    float back_mat_ambient[4];
    float back_mat_diffuse[4];
    float back_mat_specular[4];
    float back_mat_shininess[1];
    
    float drawover_amount;
    float label_offset;
                //mass distribution
                double object_weight;
    
    // now we belong to a group
    int group_number;
    
    // for display-list graphics
    int dl_needs_refresh;
    int dl_id;
    DisplayMode display_mode;
    DisplayMode last_display_mode;
    
    // internal functions
    void set_default_material_properties();
    
    // menu callbacks and vars
    double new_mass, new_spring, new_damp, new_FSA;
    static void MSDChangedCB(int obj_p_in);
    
    static void TextureCoordCB(int obj_p_in);
    static void TextureModeCB(int obj_p_in);
    static void TextureWrapCB(int obj_p_in);
    static void TextureFilterCB(int obj_p_in);
    
    static void MenuValueChangedCB(int obj_p_in);
    static void TissueTypeCB(int obj_p_in);
    static void DampTypeCB(int obj_p_in);
    
    // We want to know the force that will result of a given node was in an
    // other position- used by the ForceGrid networked haptics stuff
    Point3D *what_force_if(Node *n, Point3D *p);
        
        // Pointer to current GLUI menu, if any
        GLUI*   current_attribute_menu;
};

inline void Object::getBoundingBox(Point3D* min_p, Point3D* max_p)
{ nodearray.getBoundingBox(min_p, max_p); }

inline char* Object::getName()
{ return(name); }

inline char* Object::getPath()
{ return(path); }

inline char* Object::getChildName()
{ return(child_name); }

inline void Object::setName(char* new_name)
{ strncpy(name, new_name, NAME_LENGTH); }

inline void Object::setPath(char* new_path)
{ strncpy(path, new_path, PATH_LENGTH); }

inline void Object::setChildName(char* new_child_name)
{ strncpy(child_name, new_child_name, NAME_LENGTH); }

inline double Object::getTime()
{ return(timer.GetElapsedTime()); }

inline void Object::resetTimer()
{ timer.Reset(); }

inline Object::object_type Object::getType()
{ return(type); }

inline void Object::setType(Object::object_type t)
{ type = t; }

inline ObjectArray* Object::getObjectArray()
{ return(objectarray_p); }

inline double Object::getRadius()
{ return(nodearray.getRadius()); }

inline Point3D Object::getCenter()
{ return(nodearray.getCenter()); }

inline Object::dynamics_type Object::getDynamics()
{ return(dynamics); }

inline void Object::setDynamics(dynamics_type d)
{ dynamics = d; }

inline double Object::getEdgeThresh()
{ return(edgethresh); }

inline Object::behavior_type Object::getBehavior()
{ return(behavior); }

inline void Object::setBehavior(behavior_type b)
{ behavior = b; }

inline Object::numerical_method Object::getNumMethod()
{ return(nummethod); }

inline void Object::setNumMethod(numerical_method n)
{ nummethod = n; }

inline float* Object::getAmbientColor()
{ return(mat_ambient); }

inline float* Object::getDiffuseColor()
{ return(mat_diffuse); }

inline float* Object::getSpecularColor()
{ return(mat_specular); }

inline float* Object::getShininess()
{ return(mat_shininess); }

inline float* Object::getBackAmbientColor()
{ return(back_mat_ambient); }

inline float* Object::getBackDiffuseColor()
{ return(back_mat_diffuse); }

inline float* Object::getBackSpecularColor()
{ return(back_mat_specular); }

inline float* Object::getBackShininess()
{ return(back_mat_shininess); }

inline int Object::isLinked()
{ return(sensor_p != NULL); }

inline Sensor* Object::getSensor()
{ return(sensor_p); }

inline Point3D Object::getSensorOffset()
{ return(sensor_offset); }

inline void Object::setSensorOffset(Point3D offset)
{ sensor_offset = offset; }

inline Point3D Object::getTip()
{ return( nodearray.getNode(tip_node)->p ); }

inline void Object::setTip(int index)
{ tip_node = index; }

inline Point3D Object::getTipDelta()
{ return(tipdelta); }

inline unsigned char* Object::getTexture()
{ return(texture); }

inline void Object::Select()
{ selected = 1; }

inline void Object::Unselect()
{ selected = 0; }

inline void Object::SetVisible(int on)
{ visible = on; }

inline int Object::isVisible()
{ return(visible); }

inline void Object::ForceDisplayUpdate()
{ dl_needs_refresh = 1; }

inline void Object::setLabelOffset(float new_lo)
{ label_offset = new_lo; }

inline Object::collision_extent_type Object::getCollisionExtent()
{ return(collision_extent); }

inline void Object::setCollisionExtent(collision_extent_type extent)
{ collision_extent = extent;}

inline int Object::getNumTotalCollisions()
{ return(num_total_collisions); }

inline void Object::CollisionPairAdd(Collision_pair pair)
{ collision_pairs.Append(pair); }

inline int Object::CollisionPairGetNumElements()
{ return collision_pairs.NumElements(); }

inline Collision_pair Object::CollisionPairGet(int i)
{ return collision_pairs[i]; }

inline BoundingSphereNode* Object::getBoundingSphereRoot()
{ return(boundingSphereRoot); }

inline void Object::setBoundingSphereRoot(BoundingSphereNode* rt)
{ boundingSphereRoot = rt; }

inline int Object::getLinkedPart()
{ return(linked_part); }

inline void Object::setLinkedPart(int lp)
{ linked_part = lp; }
 
inline DisplayMode Object::getDisplayMode()
{ return display_mode; }

inline void Object::setDisplayMode(DisplayMode dm_in)
{ display_mode = dm_in; }

inline int Object::getGroupNumber()
{ return group_number; }

inline void Object::setGroupNumber(int group)
{ group_number = group; }

inline void Object::Rotate(int axis, double t) 
{ 
    nodearray.rotate(axis,t);   
    nodearray.computeStats(); 
    dl_needs_refresh = 1;
}

inline Face* Object::getLastFace(int f)
{return(last_faces_in_collision[f]);}

inline int Object::numLastFacesInCollision()
{ return(last_faces_in_collision.NumElements()); }

inline  Face* Object::getCuttingFace(int index)
{ return(cutting_faces[index]); }

inline void Object::setObjectWeight(double w)
{ object_weight = w; }

inline double Object::getObjectWeight()
{ return object_weight; }

inline void Object::setDoDeformOnlyOnGrab(int i)
{ do_deform_only_on_grab = i; }

inline double Object::getHeight() 
{ return height; }

inline void Object::setHeight(double newHeight) 
{ height = newHeight; }

inline RigidHinge* Object::getRigidHinge()
{ return rigidHinge; }

inline void Object::setRigidHinge(RigidHinge* newRigidHinge)
{ rigidHinge = newRigidHinge; }

inline float Object::getRigidHingeAngle() { 
  Node* moveHingeNode = getNodeArray()->getNode(rigidHinge->moveHingeNodeIndex);
  Node* hingeNode = getNodeArray()->getNode(rigidHinge->hingeNodeIndex);
  Point3D currentVector = moveHingeNode->p - hingeNode->p;
  currentVector.Normalize();
  float currentAngle = rigidHinge->hingeAngleVector.Angle(currentVector);
  Point3D currentDirectionNormal = rigidHinge->hingeAngleVector.Cross(currentVector);
  currentDirectionNormal.Normalize();
  float currentDirectionDotProduct = currentDirectionNormal.Dot(rigidHinge->hingeVector);
  if (currentDirectionDotProduct < 0) {
    currentAngle = -currentAngle;
  }
  return currentAngle;
}


#endif

---