home *** CD-ROM | disk | FTP | other *** search
/ CD-ROM User 1995 January / CDuser6Jan95.iso / WING / DUMB3D.HP_ / DUMB3D.HP
Text File  |  1994-06-19  |  10KB  |  441 lines
  1. /**************************************************************************
  2.     dumb3d.hpp - A simple linear algebra library for 3D.
  3.  
  4.     History:
  5.         08/09/93 Checker    Created
  6.  **************************************************************************/
  7. /**************************************************************************
  8.  
  9.    THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
  10.    KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  11.    IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR
  12.    PURPOSE.
  13.  
  14.    Copyright (c) 1993  Microsoft Corporation.  All Rights Reserved.
  15.  
  16.  **************************************************************************/
  17.  
  18. #if !defined(DUMB3D_HPP)
  19. #define DUMB3D_HPP
  20.  
  21. /*----------------------------------------------------------------------------
  22.  
  23. dumb3d.hpp
  24.  
  25. This header contains the declarations for the dumb3d.dll functions.  Dumb3D
  26. is a quick hack to get some 3D stuff running.  Don't expect much.
  27.  
  28. */
  29.  
  30.  
  31. // real type
  32.  
  33. typedef float real;
  34.  
  35.  
  36. #define M_PI            3.14159265358979323846
  37.  
  38.  
  39. // forward declarations
  40.  
  41. class point_4;
  42. class vector_4;
  43. class matrix_4x4;
  44.  
  45. // cbh! add normal_4 as a type
  46.  
  47. /*----------------------------------------------------------------------------
  48.  
  49. globally useful functions.
  50.  
  51. */
  52.  
  53. inline vector_4 operator-( point_4 const &Operand1, point_4 const &Operand2 );
  54.  
  55. inline vector_4 operator+( vector_4 const &Operand1,
  56.         vector_4 const &Operand2 );
  57.  
  58. inline vector_4 operator-( vector_4 const &Operand1,
  59.         vector_4 const &Operand2 );
  60.  
  61. inline vector_4 operator*( vector_4 const &Multiplicand,
  62.         real const &Multiplier );
  63.  
  64. inline vector_4 operator*( real const &Multiplier,
  65.         vector_4 const &Multiplicand );
  66.         
  67. inline point_4 operator+( point_4 const &Operand1, vector_4 const &Operand2 );
  68. inline point_4 operator-( point_4 const &Operand1, vector_4 const &Operand2 );
  69. inline point_4 operator+( vector_4 const &Operand2, point_4 const &Operand1 );
  70.  
  71. inline vector_4 operator-( vector_4 const &Operand1 );
  72.  
  73. inline vector_4 CrossProduct( vector_4 const &Operand1,
  74.         vector_4 const &Operand2 );
  75.  
  76. inline real DotProduct( vector_4 const &Operand1, vector_4 const &Operand2 );
  77.  
  78. matrix_4x4 operator*( matrix_4x4 const &Multiplicand,
  79.         matrix_4x4 const &Multiplier );
  80.  
  81. vector_4 operator*( matrix_4x4 const &Multiplicand,
  82.         vector_4 const &Multiplier );
  83.  
  84. point_4 operator*( matrix_4x4 const &Multiplicand,
  85.         point_4 const &Multiplier );
  86.  
  87.  
  88.  
  89.  
  90. /*----------------------------------------------------------------------------
  91.  
  92. quadruple.  base class for homogeneous vectors and points.
  93.  
  94. quick hack to save typing
  95.  
  96. */
  97.  
  98. class quadruple
  99. {
  100. public:
  101.  
  102.     inline real GetElement( int Row ) const;
  103.  
  104.     inline real GetX( void ) const;
  105.     inline real GetY( void ) const;
  106.     inline real GetZ( void ) const;
  107.     inline real GetW( void ) const;
  108.  
  109.     inline void SetElement( int Row, real Value );
  110.  
  111.     inline void SetX( real Value );
  112.     inline void SetY( real Value );
  113.     inline void SetZ( real Value );
  114.     inline void SetW( real Value );
  115.  
  116.  
  117. protected:
  118.  
  119.     inline quadruple( void );
  120.     inline quadruple( real X, real Y, real Z, real W );
  121.     inline quadruple( quadruple const & );
  122.     inline quadruple &operator=( quadruple const & );
  123.     
  124.     real aElements[4];
  125. };
  126.  
  127.  
  128. /*----------------------------------------------------------------------------
  129.  
  130. point_4.  This class represents a homogeneous 3D point.
  131.  
  132. */
  133.  
  134. class point_4 :
  135.     public quadruple
  136. {
  137. public:
  138.  
  139.     inline point_4( void );
  140.     inline point_4( real X, real Y, real Z );
  141.  
  142.     inline void Homogenize( void );
  143. };
  144.  
  145. /*----------------------------------------------------------------------------
  146.  
  147. vector_4.  This class represents a homogeneous 3D vector.
  148.  
  149. */
  150.  
  151. class vector_4 :
  152.     public quadruple
  153. {
  154. public:
  155.  
  156.     inline vector_4( void );
  157.     inline vector_4( real X, real Y, real Z );
  158.  
  159.     vector_4 &Normalize( void );
  160. };
  161.  
  162.  
  163.  
  164. /*----------------------------------------------------------------------------
  165.  
  166. matrix_4x4.  This class represents row major 4x4 homogeneous matrices.
  167.  
  168. */
  169.  
  170. class matrix_4x4
  171. {
  172. public:
  173.  
  174.     matrix_4x4( void );
  175.  
  176.     matrix_4x4 &ConcatenateXRotation( real Degrees );
  177.     matrix_4x4 &ConcatenateYRotation( real Degrees );
  178.     matrix_4x4 &ConcatenateZRotation( real Degrees );
  179.  
  180.     matrix_4x4 &ConcatenateXTranslation( real Distance );
  181.     matrix_4x4 &ConcatenateYTranslation( real Distance );
  182.     matrix_4x4 &ConcatenateZTranslation( real Distance );
  183.  
  184.     inline real GetElement( int Row, int Column ) const;
  185.     inline matrix_4x4 &SetElement( int Row, int Column, real Value );
  186.  
  187.     
  188. protected:
  189.  
  190.     enum do_not_initialize { DoNotInitialize };
  191.  
  192.     inline matrix_4x4( do_not_initialize );
  193.  
  194.     real aElements[4][4];
  195. };
  196.  
  197. /*----------------------------------------------------------------------------
  198.  
  199. view transform.
  200.  
  201. */
  202.  
  203. class view_transform :
  204.     public matrix_4x4
  205. {
  206. public:
  207.  
  208.     view_transform( point_4 const &Viewpoint, vector_4 const &ViewDirection,
  209.         vector_4 const &Up );
  210. };
  211.  
  212.  
  213. /*----------------------------------------------------------------------------
  214.  
  215. inline function definitions.
  216.  
  217. */
  218.  
  219.  
  220. inline vector_4 operator-( point_4 const &Operand1, point_4 const &Operand2 )
  221. {
  222.     return vector_4(Operand1.GetX() - Operand2.GetX(),
  223.                     Operand1.GetY() - Operand2.GetY(),
  224.                     Operand1.GetZ() - Operand2.GetZ());
  225. }
  226.  
  227. inline vector_4 operator+( vector_4 const &Operand1,
  228.         vector_4 const &Operand2 )
  229. {
  230.     return vector_4(Operand1.GetX() + Operand2.GetX(),
  231.                     Operand1.GetY() + Operand2.GetY(),
  232.                     Operand1.GetZ() + Operand2.GetZ());
  233. }
  234.  
  235. inline vector_4 operator-( vector_4 const &Operand1,
  236.         vector_4 const &Operand2 )
  237. {
  238.     return vector_4(Operand1.GetX() - Operand2.GetX(),
  239.                     Operand1.GetY() - Operand2.GetY(),
  240.                     Operand1.GetZ() - Operand2.GetZ());
  241. }
  242.  
  243. inline vector_4 operator-( vector_4 const &Operand1 )
  244. {
  245.     return vector_4(-Operand1.GetX(),-Operand1.GetY(),-Operand1.GetZ());
  246. }
  247.  
  248. inline vector_4 operator*( vector_4 const &Multiplicand,
  249.         real const &Multiplier )
  250. {
  251.     return vector_4(Multiplicand.GetX() * Multiplier,
  252.                     Multiplicand.GetY() * Multiplier,
  253.                     Multiplicand.GetZ() * Multiplier);
  254. }
  255.  
  256. inline vector_4 operator*( real const &Multiplier,
  257.         vector_4 const &Multiplicand ) 
  258. {
  259.     return vector_4(Multiplicand.GetX() * Multiplier,
  260.                     Multiplicand.GetY() * Multiplier,
  261.                     Multiplicand.GetZ() * Multiplier);
  262. }
  263.         
  264. inline point_4 operator+( point_4 const &Operand1, vector_4 const &Operand2 )
  265. {
  266.     return point_4(Operand1.GetX() + Operand2.GetX(),
  267.                     Operand1.GetY() + Operand2.GetY(),
  268.                     Operand1.GetZ() + Operand2.GetZ());
  269. }
  270.  
  271. inline point_4 operator-( point_4 const &Operand1, vector_4 const &Operand2 )
  272. {
  273.     return point_4(Operand1.GetX() - Operand2.GetX(),
  274.                     Operand1.GetY() - Operand2.GetY(),
  275.                     Operand1.GetZ() - Operand2.GetZ());
  276. }
  277.  
  278. inline point_4 operator+( vector_4 const &Operand1, point_4 const &Operand2 )
  279. {
  280.     return Operand2 + Operand1;
  281. }
  282.  
  283. inline vector_4 CrossProduct( vector_4 const &Operand1,
  284.         vector_4 const &Operand2 )
  285. {
  286.     real X = Operand1.GetY() * Operand2.GetZ() -
  287.                 Operand1.GetZ() * Operand2.GetY();
  288.     real Y = Operand1.GetZ() * Operand2.GetX() -
  289.                 Operand1.GetX() * Operand2.GetZ();
  290.     real Z = Operand1.GetX() * Operand2.GetY() -
  291.                 Operand1.GetY() * Operand2.GetX();
  292.  
  293.     return vector_4(X,Y,Z);
  294. }
  295.  
  296. inline real DotProduct( vector_4 const &Operand1, vector_4 const &Operand2 )
  297. {
  298.     return Operand1.GetX() * Operand2.GetX() +
  299.             Operand1.GetY() * Operand2.GetY() +
  300.             Operand1.GetZ() * Operand2.GetZ();
  301. }
  302.  
  303.  
  304. inline real quadruple::GetElement( int Row ) const
  305. {
  306.     return aElements[Row];
  307. }
  308.  
  309. inline real quadruple::GetX( void ) const
  310. {
  311.     return aElements[0];
  312. }
  313.  
  314. inline real quadruple::GetY( void ) const
  315. {
  316.     return aElements[1];
  317. }
  318.  
  319. inline real quadruple::GetZ( void ) const
  320. {
  321.     return aElements[2];
  322. }
  323.  
  324. inline real quadruple::GetW( void ) const
  325. {
  326.     return aElements[3];
  327. }
  328.  
  329. inline void quadruple::SetElement( int Row, real Value )
  330. {
  331.     aElements[Row] = Value;
  332. }
  333.  
  334. inline void quadruple::SetX( real Value )
  335. {
  336.     aElements[0] = Value;
  337. }
  338.  
  339. inline void quadruple::SetY( real Value )
  340. {
  341.     aElements[1] =