home *** CD-ROM | disk | FTP | other *** search
/ VRML Tools for 3D Cyberspace / VRML_Tools_For_3D_Cyberspace.iso / amber / include / shapes.hpp < prev    next >
Encoding:
C/C++ Source or Header  |  1996-07-01  |  6.2 KB  |  325 lines

  1. //**********************************************************************
  2. //  DIVE Laboratories, Inc.
  3. //  Copyright(c) 1995
  4. //  All rights reserved.
  5. //  FILE:   SHAPES.HPP
  6. //
  7. //  DESCRIPTION
  8. //  This file provides the classe definitions for all amber shapes
  9. //
  10. //  Author: M. Doucet
  11. //
  12. //  Modification History:
  13. //  8/2/95    Created
  14. //
  15. //**********************************************************************
  16. #ifndef _SHAPES_HPP
  17. #define _SHAPES_HPP
  18.  
  19. #include "vrtypes.hpp"
  20. #include "geometry.hpp"
  21.  
  22. #ifndef AMBERRT
  23. #include "texture.hpp"
  24. #endif
  25.  
  26. //---------------------------------------------------------------------
  27. //  This is the class definition for the cubeClass.
  28. //
  29. class cubeClass : public geometryClass {
  30.  
  31. //  Private Data
  32.  
  33. //  Protected Data
  34.  
  35. //  Public Data
  36.  
  37. public:
  38.  
  39.  
  40. //  Constructor Functions
  41.  
  42.     cubeClass(float lx,
  43.                float ly,
  44.                float lz,
  45.                int addToUniv=TRUE,
  46.                int createBBox=TRUE);
  47.  
  48.  
  49. //  Destructor Function
  50.  
  51.     ~cubeClass();
  52.  
  53. };
  54. //---------------------------------------------------------------------
  55. //  This is the class definition for the cylinderClass.
  56. //
  57. class cylinderClass : public geometryClass {
  58.  
  59. //  Private Data
  60.  
  61. //  Protected Data
  62.  
  63. //  Public Data
  64.  
  65. private:
  66.  
  67.     int nTess, doBottom, doTop, doBothSides;
  68.  
  69. public:
  70.  
  71. #ifndef AMBERRT
  72.      void applyTexture(textureClass *tex, 
  73.                        int outside = TRUE,
  74.                        int bottom  = TRUE,
  75.                       int top     = TRUE,
  76.                       int inside  = TRUE);
  77. #endif
  78.  
  79. //  Constructor Functions
  80.  
  81.     cylinderClass(float radius,
  82.                   float height,
  83.                   int tess = 6,
  84.                   float taper = 0.0,
  85.                   int bottom = TRUE,
  86.                   int top = TRUE,
  87.                   int bothsides=FALSE,
  88.                   int addToUniv=TRUE,
  89.                   int createBBox=TRUE);
  90.  
  91. //  Destructor Function
  92.  
  93.     ~cylinderClass(); 
  94.  
  95. };
  96.  
  97. //---------------------------------------------------------------------
  98. //  This is the class definition for the coneClass.
  99. //
  100. class coneClass : public geometryClass {
  101.  
  102. //  Private Data
  103.  
  104. //  Protected Data
  105.  
  106. //  Public Data
  107. private:
  108.  
  109.     int nTess, doBottom, doBothSides;
  110.  
  111. public:
  112.  
  113. #ifndef AMBERRT
  114.      void applyTexture(textureClass *tex, 
  115.                        int outside = TRUE,
  116.                        int bottom  = TRUE,
  117.                       int inside  = TRUE);
  118. #endif
  119. //  Constructor Functions
  120.  
  121.     coneClass(float radius,
  122.               float height,
  123.               int tess = 6,
  124.               int bottom = FALSE,
  125.               int bothsides=TRUE,
  126.               int addToUniv=TRUE,
  127.               int createBBox=TRUE);
  128.  
  129.  
  130. //  Destructor Function
  131.  
  132.     ~coneClass();
  133.  
  134. };
  135.  
  136. //---------------------------------------------------------------------
  137. //  This is the class definition for the sphereClass.
  138. //
  139. class sphereClass : public geometryClass {
  140.  
  141. //  Private Data
  142. private:
  143.  
  144.     int nTess, doBothSides;
  145.  
  146. //  Protected Data
  147.  
  148. //  Public Data
  149.  
  150. public:
  151.  
  152. #ifndef AMBERRT
  153.      void applyTexture(textureClass *tex, 
  154.                        int outside = TRUE,
  155.                       int inside  = FALSE);
  156. #endif
  157.  
  158. //  Constructor Functions
  159.  
  160.     sphereClass(float radius,
  161.                 int nlat,
  162.                 int nlong,
  163.                 int bothsides=FALSE,
  164.                 int addToUniv=TRUE,
  165.                 int createBBox=TRUE);
  166.  
  167.  
  168. //  Destructor Function
  169.  
  170.     ~sphereClass();
  171.  
  172. };
  173.  
  174. //---------------------------------------------------------------------
  175. //  This is the class definition for the hemisphereClass.
  176. //
  177. class hemisphereClass : public geometryClass {
  178.  
  179. //  Private Data
  180.  
  181. //  Protected Data
  182.  
  183. //  Public Data
  184.  
  185. public:
  186.  
  187.  
  188. //  Constructor Functions
  189.  
  190.     hemisphereClass(float radius,
  191.                      int nlat,
  192.                         int nlong,
  193.                      int bottom = FALSE,
  194.                     int bothsides=TRUE,
  195.                     int addToUniv=TRUE,
  196.                     int createBBox=TRUE);
  197.  
  198.  
  199. //  Destructor Function
  200.  
  201.     ~hemisphereClass();
  202.  
  203. };
  204. //---------------------------------------------------------------------
  205. //  This is the class definition for the arcClass.
  206. //
  207. class arcClass : public geometryClass {
  208.  
  209. //  Private Data
  210.  
  211. //  Protected Data
  212.  
  213. //  Public Data
  214.  
  215. public:
  216.  
  217.  
  218. //  Constructor Functions
  219.  
  220.     arcClass(float radius,
  221.               float width,
  222.               int segments,
  223.               float sweep,
  224.               int bothsides=TRUE,
  225.               int addToUniv=TRUE,
  226.               int createBBox=TRUE);
  227.  
  228. //  Destructor Function
  229.     ~arcClass();
  230.  
  231. };
  232.  
  233. //---------------------------------------------------------------------
  234. //  This is the class definition for the gridClass.
  235. //
  236. class gridClass : public geometryClass {
  237.  
  238. //  Private Data
  239.  
  240. //  Protected Data
  241.  
  242. //  Public Data
  243.  
  244. public:
  245.  
  246.  
  247. //  Constructor Functions
  248.  
  249.     gridClass(float length,
  250.               int   xSegments,
  251.               int   zSegments,
  252.               int   bothsides=TRUE,
  253.               int   addToUniv=TRUE,
  254.               int   createBBox=TRUE);
  255.  
  256.  
  257. //  Destructor Function
  258.  
  259.     ~gridClass();
  260.  
  261. };
  262.  
  263. //---------------------------------------------------------------------
  264. //  This is the class definition for the circleClass.
  265. //
  266. class circleClass : public geometryClass {
  267.  
  268. //  Private Data
  269.  
  270. //  Protected Data
  271.  
  272. //  Public Data
  273.  
  274. public:
  275.  
  276.  
  277. //  Constructor Functions
  278.  
  279.     circleClass(float radius,
  280.                 int segments,
  281.                 int bothsides=TRUE,
  282.                 int addToUniv=TRUE,
  283.                 int createBBox=TRUE);
  284.  
  285.  
  286. //  Destructor Function
  287.  
  288.     ~circleClass();
  289.  
  290. };
  291.  
  292. //---------------------------------------------------------------------
  293. //  This is the class definition for the torusClass.
  294. //
  295. class torusClass : public geometryClass {
  296.  
  297. //  Private Data
  298.  
  299. //  Protected Data
  300.  
  301. //  Public Data
  302.  
  303. public:
  304.  
  305.  
  306. //  Constructor Functions
  307.  
  308.     torusClass(float radius,
  309.                      float width,
  310.                int   segments,
  311.                     int   sides,
  312.                int   bothsides = TRUE,
  313.                int   addToUniv=TRUE,
  314.                int   createBBox=TRUE);
  315.  
  316.  
  317. //  Destructor Function
  318.  
  319.     ~torusClass();
  320.  
  321. };
  322.  
  323.  
  324. #endif
  325.