home *** CD-ROM | disk | FTP | other *** search
/ VRML Tools for 3D Cyberspace / VRML_Tools_For_3D_Cyberspace.iso / amber / include / geometry.hpp < prev    next >
Encoding:
C/C++ Source or Header  |  1996-07-01  |  7.1 KB  |  277 lines
  1. //**********************************************************************
  2. //  DIVE Laboratories, Inc.
  3. //  Copyright(c) 1995
  4. //  All rights reserved.
  5. //  FILE:   GEOMETRY.HPP
  6. //
  7. //  DESCRIPTION
  8. //  This file provides the function prototypes for the geometryClass
  9. //
  10. //  Author: M. Doucet
  11. //
  12. //  Modification History:
  13. //  6/13/95    Created
  14. //
  15. //**********************************************************************
  16. #ifndef _GEOMETRY_HPP
  17. #define _GEOMETRY_HPP
  18.  
  19. #include "quat.hpp"
  20. #include "vector.hpp"
  21. #include "matrix.hpp"
  22. #include "scc_ray.hpp"
  23. #include "primset.hpp"
  24.  
  25. #ifndef AMBERRT
  26. #include "material.hpp"
  27. #endif
  28.  
  29. class staticCollisionClass;  
  30. class intxMsgClass;
  31. class geoStateClass;
  32. class universeClass;
  33. class geometryPrivateClass;
  34. class indexedSetClass;
  35. class coneNodeClass;
  36. class cubeNodeClass;
  37. class sphereNodeClass;
  38. class cylinderNodeClass;
  39. class WWWInlineClass;
  40. class pointClass;
  41. class lineClass;
  42. class polygonClass;
  43.  
  44. class geometryClass {
  45.  
  46.     friend class staticCollisionClass;
  47.     friend class collisionServerClass;
  48.     friend class universeClass;
  49.     friend class lightPrivateClass;
  50.     friend class universePrivateClass;
  51.     friend class geometryPrivateClass;
  52.     friend class indexedSetClass;
  53.     friend class coneNodeClass;
  54.     friend class cubeNodeClass;
  55.     friend class sphereNodeClass;
  56.     friend class cylinderNodeClass;
  57.     friend class WWWInlineClass;
  58.     friend class lineClass;
  59.     friend class pointClass;
  60.     friend class polygonClass;
  61.  
  62. private:
  63.  
  64.     geometryPrivateClass *data;
  65.  
  66.     void outputAsVRML(FILE *fp, int tabStops, flagType isChild=FALSE);
  67.     void outputAsWTK(FILE *fp, flagType isChild=FALSE);
  68.     void computeHierarchyBounds();
  69.  
  70. public:
  71.  
  72.     // Kinematic data
  73.     kinematicClass     *kine;
  74.  
  75.     // Collision detection utilities:
  76.     int    intxCheckRadius( rayClass *ray, float& iDistance );
  77.     int    intxCheckBBox( V3 fromPos, V3 toPos, float& iDistance );
  78.     intxMsgClass* intxCheckPoly( V3 fromPos, V3 toPos, long qID  );
  79.     intxMsgClass* intxCheck2(V3 fPos,V3 tPos,int polyFlag,Vres& minRange );
  80.  
  81.     //BDG 03/08/96
  82.     void    setCollisionStatus( int status, int propagate=TRUE );
  83.  
  84.     // Geometry Sets
  85.     geoPrimSetClass     lineSet;
  86.     geoPrimSetClass     polySet;
  87.     geoPrimSetClass     pointSet;
  88.  
  89.     // Level Of Detail Functions
  90.     //
  91.     void addLOD(geometryClass *g, Vres range);
  92.  
  93.     // Hierarchy functions
  94.     //
  95.     void addChild(geometryClass *child, flagType relativePQ=TRUE);
  96.     void removeChild(geometryClass *child, flagType relativePQ=TRUE);
  97.     int  getNumChildren();
  98.     void removeFromParent();
  99.     void removeAllChildren();
  100.     geometryClass *getParent();
  101.     geometryClass *getTopParent();
  102.     geometryClass *getChild(char *name);
  103.  
  104.     // Geometry construction
  105.     //
  106.     int          addVertex(vertexClass *v);
  107.     vertexClass *getVertex(int index);
  108.     void         getVertexPos(int index, V3 pos);
  109.     sLinkClass  *getVertexList();
  110.  
  111.  
  112.     // Add new primitives whose vertices ARE currently
  113.     // part of the geometry.  If you want the vertices
  114.     // added, set "hasNewVertices" to TRUE.
  115.     void addPoint(pointClass *p, int hasNewVertex=FALSE);
  116.     void addLine(lineClass *l, int hasNewVertices=FALSE);
  117.     void addPolygon(polygonClass *p, int hasNewVertices=FALSE);
  118.  
  119.     // Simple primitive retrieval
  120.     //
  121.     pointClass         *getPoint(int index);
  122.     lineClass         *getLine(int index);
  123.     polygonClass     *getPolygon(int index);
  124.  
  125.     // Primitive editing
  126.     void removePoint(pointClass *p);
  127.     void removeLine(lineClass *l);
  128.     void removePolygon(polygonClass *p);
  129.  
  130.     // Visibility
  131.     void setVisibility(int flag, flagType propagate=FALSE);
  132.     int  getVisibility();
  133.  
  134.     // Extents (local and hierarchy)
  135.     void getExtents(V3 ext);
  136.     void getHierarchyExtents(V3 ext);
  137.     void getHierarchyBounds(V3 pos, V3 ext);
  138.  
  139.     // Scaling
  140.     void stretch(V3 vals);
  141.     void scale(Vres s);
  142.     void getScaling(V3 vals);
  143.  
  144.     // Position Functions
  145.     //
  146.     void getPosition(V3 pos);
  147.     void setPosition(V3 pos);
  148.     void setPosition(Vres Xpos, Vres Ypos, Vres Zpos );
  149.     void setPosition(positionClass p);
  150.     void getPosition(positionClass &p);
  151.     void translate(vectorClass delta, frameEnum frame=_LOCAL);
  152.     void translate(vectorClass *delta, frameEnum frame=_LOCAL);
  153.  
  154.     // Rotation pivot points in world coordinates
  155.     //
  156.     void getPivot(V3 pos);
  157.     void setPivot(V3 pos);
  158.     void setPivot(pivotXenum Xpivot = _XCENTER,
  159.                   pivotYenum Ypivot = _YCENTER,
  160.                   pivotZenum Zpivot = _ZCENTER);
  161.  
  162.      // Rotations
  163.     //
  164.     void rotate(int axis, Vres rads);
  165.     void rotate(vectorClass *axis, Vres rads);
  166.  
  167.     // Orientation Functions
  168.     //
  169.     void initOrientation();
  170.     void setOrientation(quatClass q);
  171.     void getOrientation(quatClass &q);
  172.     void setEulerOrientation(V3 angle);
  173.     void getEulerOrientation(V3 angle);
  174.  
  175.      // Alignment
  176.     //
  177.      void alignAxis(int axis, vectorClass *v);
  178.     void getAxis(int axis, V3 vals);
  179.     void getAxis(int axis, vectorClass &vec);
  180.  
  181.     // Creating a bounding box
  182.     //
  183.     void           createBoundingBox(flagType propagate=FALSE);
  184.     void           setBoundingBoxVisibility(int flag);
  185.     geometryClass *getBoundingBox();
  186.  
  187.     // Miscellaneous functions
  188.     //
  189.     int    getNumPolygonsInHierarchy();
  190.     int    getNumPolygons();
  191.     int     getNumLines();
  192.     int    getNumPoints();
  193.     int    getNumVertices();
  194.     Vres      getRadius();
  195.     void   setNormalOverride(int flag);
  196.     void   updateNormals();
  197.     int    getId();
  198.     void   setData(void *pt);
  199.     void  *getData();
  200.     void   localToWorldPos(V3 in, V3 out);
  201.     void   worldToLocalPos(V3 in, V3 out);
  202.     void   complete();
  203.     int    isComplete();
  204.  
  205.     // Picking Functions
  206.     int rayPickPoly(V3 from, V3 to);
  207.  
  208.     // Picking Functions
  209.     flagType rayPickGeo(V3 from, V3 to);
  210.  
  211.     // Local action functions
  212.     //
  213.     void addAction (ACTIONFUNCPTR func, int rate=1, int phase=1);
  214.     void removeAction(ACTIONFUNCPTR func);
  215.  
  216.     void  setName(char *nm);
  217.     char *getName();
  218.     char *getFilename();
  219.  
  220.     void setAllColor(F4 col);
  221.     void getAllColor(F4 col);
  222.  
  223. #ifndef AMBERRT
  224.     void setTexture(textureClass *t, int mode);
  225.     void setMaterial(materialClass *m);
  226.     void setMaterial(char *name);
  227.     materialClass *getMaterial();
  228. #endif
  229.  
  230.     // Adding geometry to universe
  231.     //
  232.     void addTo(universeClass *univ);
  233.  
  234.     // File Saving
  235.     //
  236.     void save(char *filename, fileEnumType fileType=_NFF_FILE);
  237.  
  238.     // Collistion Detection
  239.     //
  240.     void     setCollisionState(int flag, int dynamic=TRUE, flagType propagate=FALSE);
  241.     int      getCollisionState();
  242.     void     setCollisionMode( int type, flagType propagate=FALSE );
  243.     int      getCollisionMode( void );
  244.     flagType isDynamic( void );
  245.  
  246.     void setKinematic(flagType isKinematic=TRUE);
  247.  
  248.     // Geometry Combining
  249.     void operator+=(geometryClass *g);
  250.     void add(geometryClass *g);
  251.     void flattenHierarchy();
  252.  
  253.     // Render functions
  254.     void                enableState(int state);
  255.     void                disableState(int state);
  256.     int                 getState();
  257.  
  258.     void                    setPolyRenderAs(polyAsEnum as);
  259.     polyAsEnum            getPolyRenderAs();
  260.  
  261.     void                    setPolyFill(polyFillEnum fill);
  262.     polyFillEnum       getPolyFill();
  263.  
  264.     void                     setPolyShading(polyShadingEnum shading);
  265.     polyShadingEnum     getPolyShading();
  266.  
  267.     // Constructors & Destructors
  268.     //
  269.     geometryClass(char *filename, 
  270.                       int createBBox=TRUE, int collisionOn=FALSE);
  271.     geometryClass();
  272.     ~geometryClass();
  273.  
  274. };
  275.  
  276. #endif
  277.