Changeset 2751 for GTP


Ignore:
Timestamp:
06/10/08 13:15:59 (17 years ago)
Author:
mattausch
Message:
 
Location:
GTP/trunk/App/Demos/Vis/CHC_revisited
Files:
2 added
20 edited

Legend:

Unmodified
Added
Removed

  • GTP/trunk/App/Demos/Vis/CHC_revisited/AxisAlignedBox3.cpp

    r2747 r2751  
    66using namespace std; 
    77 
    8 //namespace CHCDemo 
    9 //{ 
    10  
    11 // AxisAlignedBox3 implementations 
     8namespace CHCDemo 
     9{ 
    1210 
    1311// Overload << operator for C++-style output 
    … …  
    2725                >> A.mMax.x >> a >> A.mMax.y >> a >> A.mMax.z >> a; 
    2826} 
     27 
     28 
     29AxisAlignedBox3::AxisAlignedBox3()  
     30{ } 
     31 
     32 
     33AxisAlignedBox3::AxisAlignedBox3(const Vector3 &nMin, const Vector3 &nMax) 
     34: mMin(nMin), mMax(nMax) 
     35{} 
     36 
    2937 
    3038 
    … …  
    246254                ext.x * ext.z + 
    247255                ext.y * ext.z); 
     256} 
     257 
     258 
     259float AxisAlignedBox3::GetVolume() const  
     260{ 
     261        return (mMax.x - mMin.x) * (mMax.y - mMin.y) * (mMax.z - mMin.z); 
    248262} 
    249263 
    … …  
    947961        Vector3 size = Size(); 
    948962 
    949         return GetRandomPoint(Vector3(RandomValue(0.0f, 1.0f), 
    950                                   RandomValue(0.0f, 1.0f), 
    951                                                                   RandomValue(0.0f, 1.0f))); 
    952 } 
    953  
    954  
    955 Vector3 AxisAlignedBox3::GetRandomPoint(const Vector3 &r) const 
    956 { 
    957         return mMin + Size()*r; 
     963        return mMin + Vector3(RandomValue(0.0f, 1.0f), 
     964                                  RandomValue(0.0f, 1.0f), 
     965                                                  RandomValue(0.0f, 1.0f)) * Size(); 
    958966} 
    959967 
    … …  
    10041012} 
    10051013 
    1006 //} 
    1007  
     1014 
     1015Vector3 AxisAlignedBox3::GetVertex(const int N) const  
     1016{ 
     1017        Vector3 v; 
     1018        GetVertex(N, v); 
     1019 
     1020        return v; 
     1021} 
     1022 
     1023 
     1024float AxisAlignedBox3::GetExtent(int face) const  
     1025{ 
     1026        if (face < 3) 
     1027                return mMin[face]; 
     1028        else 
     1029                        return mMax[face - 3]; 
     1030} 
     1031 
     1032 
     1033} 
     1034 

  • GTP/trunk/App/Demos/Vis/CHC_revisited/AxisAlignedBox3.h

    r2749 r2751  
    1010 
    1111 
    12 //namespace CHCDemo 
    13 //{ 
     12namespace CHCDemo 
     13{ 
    1414 
    1515struct Triangle3; 
    1616 
    1717/** Axis alignedd box class. 
    18 This is a box in 3-space, defined by min and max 
    19 corner vectors.  Many useful operations are defined 
    20 on this 
     18    This is a box in 3-space, defined by min and max 
     19        corner vectors.  Many useful operations are defined. 
    2120*/ 
    2221class AxisAlignedBox3 
    … …  
    2524public: 
    2625 
    27         // Constructors. 
    28         AxisAlignedBox3() { } 
    29  
    30         AxisAlignedBox3(const Vector3 &nMin, const Vector3 &nMax) 
    31         { 
    32                 mMin = nMin; mMax = nMax; 
    33         } 
    34  
     26        /////////// 
     27        //-- Constructors. 
     28 
     29        AxisAlignedBox3(); 
     30 
     31        AxisAlignedBox3(const Vector3 &nMin, const Vector3 &nMax); 
    3532        /** initialization to the non existing bounding box 
    3633        */ 
    … …  
    131128        */ 
    132129        void Translate(const Vector3 &shift); 
    133  
    134130        /** Returns the square of the minimal and maximal distance to  
    135         a point on the box. 
    136         */ 
    137         void 
    138                 GetSqrDistances(const Vector3 &point, 
    139                 float &minDistance, 
    140                 float &maxDistance 
    141                 ) const; 
    142  
    143  
    144  
    145         Vector3 GetRandomPoint(const Vector3 &r) const; 
     131            a point on the box. 
     132        */ 
     133        void GetSqrDistances(const Vector3 &point,  
     134                                 float &minDistance, 
     135                                                 float &maxDistance) const; 
     136        /** return random point in box. 
     137        */ 
    146138        Vector3 GetRandomPoint() const; 
    147  
    148         Vector3 GetPoint(const Vector3 &p) const  
    149         { 
    150                 return mMin + p*Size();  
    151         } 
    152  
    153  
    154 protected: 
    155         Vector3 mMin, mMax; 
    156  
    157 public: 
    158  
    159         // Returns the smallest axis-aligned box that includes all points 
    160         // inside the two given boxes. 
    161         friend inline AxisAlignedBox3 Union(const AxisAlignedBox3 &x, 
    162                 const AxisAlignedBox3 &y); 
    163  
    164         // Returns the intersection of two axis-aligned boxes. 
    165         friend inline AxisAlignedBox3 Intersect(const AxisAlignedBox3 &x, 
    166                 const AxisAlignedBox3 &y); 
    167  
    168         // Given 4x4 matrix, transform the current box to new one. 
    169         friend inline AxisAlignedBox3 Transform(const AxisAlignedBox3 &box, 
    170                 const Matrix4x4 &tform); 
    171  
    172  
    173         // returns true when two boxes are completely equal 
    174         friend inline int operator== (const AxisAlignedBox3 &A,  
    175                 const AxisAlignedBox3 &B); 
    176  
    177         virtual float SurfaceArea() const; 
    178         virtual float GetVolume() const  
    179         { 
    180                 return (mMax.x - mMin.x) * (mMax.y - mMin.y) * (mMax.z - mMin.z); 
    181         } 
     139        /** Returns surface area of the box. 
     140        */ 
     141        float SurfaceArea() const; 
     142        /** Returns volume of the box. 
     143        */ 
     144        float GetVolume() const; 
    182145 
    183146        // Six faces are distuinguished by their name. 
    … …  
    194157 
    195158        // For edge .. number <0..11> returns two incident vertices 
    196         void GetEdge(const int edge, Vector3 *a, Vector3 *b) const; 
     159        void GetEdge(int edge, Vector3 *a, Vector3 *b) const; 
    197160 
    198161        // Compute the coordinates of one vertex of the box for 0/1 in each axis 
    … …  
    203166        // x,y,z are either 0 or 1; (0 .. lower coordinate, 1 .. large coordinate) 
    204167        // (xmin,ymin, zmin) .. N = 0, (xmax, ymax, zmax) .. N= 7 
    205         void GetVertex(const int N, Vector3 &vertex) const; 
    206  
    207         Vector3 GetVertex(const int N) const { 
    208                 Vector3 v; 
    209                 GetVertex(N, v); 
    210                 return v; 
    211         } 
    212  
    213         // Returns 1, if the box includes on arbitrary face a given box 
     168        void GetVertex(int N, Vector3 &vertex) const; 
     169 
     170        Vector3 GetVertex(int N) const; 
     171        /** get the extent of face. 
     172        */ 
     173        float GetExtent(int face) const;  
     174        /** Returns 1, if the box includes on arbitrary face a given box 
     175        */ 
    214176        int IsPiercedByBox(const AxisAlignedBox3 &box, int &axis) const; 
    215  
    216177 
    217178        int GetFaceVisibilityMask(const Vector3 &position) const; 
    … …  
    219180        */ 
    220181        //Plane3 GetPlane(const int face) const; 
    221  
    222  
    223182        /** Returns vertex indices of edge. 
    224183        */ 
    … …  
    226185 
    227186 
    228         // get the extent of face 
    229         float GetExtent(const int &face) const  
    230         { 
    231                 if (face < 3) 
    232                         return mMin[face]; 
    233                 else 
    234                         return mMax[face - 3]; 
    235         } 
     187 
     188        //////////// 
     189        //-- friend functions 
     190 
     191        // Returns the smallest axis-aligned box that includes all points 
     192        // inside the two given boxes. 
     193        friend inline AxisAlignedBox3 Union(const AxisAlignedBox3 &x, 
     194                                                const AxisAlignedBox3 &y); 
     195 
     196        // Returns the intersection of two axis-aligned boxes. 
     197        friend inline AxisAlignedBox3 Intersect(const AxisAlignedBox3 &x, 
     198                                                    const AxisAlignedBox3 &y); 
     199 
     200        // Given 4x4 matrix, transform the current box to new one. 
     201        friend inline AxisAlignedBox3 Transform(const AxisAlignedBox3 &box, 
     202                                                    const Matrix4x4 &tform); 
     203 
     204 
     205        // returns true when two boxes are completely equal 
     206        friend inline int operator== (const AxisAlignedBox3 &A,  
     207                                          const AxisAlignedBox3 &B); 
     208 
     209        // input and output operator with stream 
     210        friend std::ostream& operator<<(std::ostream &s, const AxisAlignedBox3 &A); 
     211        friend std::istream& operator>>(std::istream &s, AxisAlignedBox3 &A); 
     212 
     213 
    236214 
    237215        // The vertices that form boundaries of the projected bounding box 
    … …  
    272250        static const int fsvertices[27][9]; 
    273251 
    274         // input and output operator with stream 
    275         friend std::ostream& operator<<(std::ostream &s, const AxisAlignedBox3 &A); 
    276         friend std::istream& operator>>(std::istream &s, AxisAlignedBox3 &A); 
     252protected: 
     253 
     254        Vector3 mMin, mMax; 
     255 
    277256}; 
    278257 
    … …  
    385364 
    386365 
    387 //} 
     366} 
    388367 
    389368 

  • GTP/trunk/App/Demos/Vis/CHC_revisited/Bvh.cpp

    r2746 r2751  
    1313#include "Viewer.h" 
    1414 
    15  
    1615#include <fstream> 
    1716#include <iostream> 
    1817#include <iomanip> 
    1918 
     19 
     20 
     21namespace CHCDemo 
     22{ 
     23 
    2024#define INVALID_TEST ((unsigned int)-1) 
    21 #define MAX_FLOAT 1e20f 
    2225 
    2326#define TYPE_INTERIOR -2 
    … …  
    324327float Bvh::SelectPlaneSah(BvhLeaf *leaf, int &axis, float &minCost) 
    325328{ 
    326         minCost = MAX_FLOAT; 
     329        minCost = MAXFLOAT; 
    327330        float bestPos = minCost; 
    328331        int bestAxis = 0; 
    … …  
    584587                        pos = SelectPlaneSah(leaf, axis, cost); 
    585588 
    586                         if (pos != MAX_FLOAT) 
     589                        if (pos != MAXFLOAT) 
    587590                        { 
    588591                                split = SortTriangles(leaf, axis, pos); 
    589592                        } 
    590593 
    591                         if ((pos == MAX_FLOAT) || (split == leaf->mLast)) 
     594                        if ((pos == MAXFLOAT) || (split == leaf->mLast)) 
    592595                        { 
    593596                                split = -1; 
    … …  
    608611                                pos = SelectPlaneSah(leaf, axis, cost); 
    609612 
    610                                 if (pos != MAX_FLOAT) 
     613                                if (pos != MAXFLOAT) 
    611614                                        split = SortTriangles(leaf, axis, pos); 
    612615                                else 
    … …  
    25902593}  
    25912594 
     2595} 
     2596 
    25922597#endif 

  • GTP/trunk/App/Demos/Vis/CHC_revisited/Bvh.h

    r2746 r2751  
    33#ifndef __BVH_H 
    44#define __BVH_H 
     5 
    56 
    67#if TOIMPLEMENT 
    … …  
    1213#include "HierarchyNode.h" 
    1314#include "FlexibleHeap.h" 
     15 
     16 
     17 
     18namespace CHCDemo 
     19{ 
    1420 
    1521 
    … …  
    894900}; 
    895901 
     902} 
     903 
    896904#endif 
    897905#endif // __BVH_H 

  • GTP/trunk/App/Demos/Vis/CHC_revisited/Geometry.cpp

    r2746 r2751  
     1#if 0 
     2 
     3 
    14#include "Geometry.h" 
    25#include "glInterface.h" 
    … …  
    58 
    69#include <math.h> 
     10 
     11 
     12namespace CHCDemo  
     13{ 
    714 
    815#define NO_LIST    -1 
    … …  
    547554        glFrontFace(GL_CCW); 
    548555} 
     556 
     557} 
     558 
     559#endif 

  • GTP/trunk/App/Demos/Vis/CHC_revisited/Geometry.h

    r2746 r2751  
    22#define GEOMETRY_H 
    33 
    4 extern "C" 
     4 
     5namespace CHCDemo  
    56{ 
    6         #include "MathStuff.h" 
    7 } 
    87 
    9 /** Represents a drawable geometry. It can draw simple objects (teapot, 
    10         torus, shere. It also contains the object transformation and  
    11         the material .An AAB is used as bouning volume. 
     8/** Represents drawable geometry consisting of triangles 
    129*/ 
    1310class Geometry 
    1411{ 
    1512public: 
    16         Geometry(); 
    17         Geometry(Vector3 translation, float xRot, float yRot, float zRot, float scale, int objectType); 
    18         //! Renders this geometry 
    19         void Render(); 
    20         //! sets rotations in degree : executed in the order x, y, and z rotation 
    21         void SetRotations(float xRot, float yRot, float zRot); 
    22         //! sets the rotation matrix 
    23         void SetTranslation(Vector3 translation); 
    24         //! a uniform scale 
    25         void SetScale(float scale); 
    26         //! returns current scale 
    27         float GetScale(); 
    28  
    29         //! returns translation 
    30         void GetTranslation(Vector3 translation); 
    31         //! returns rotation 
    32         void GetRotations(float &xRot, float &yRot, float &zRot); 
    33  
    34         //! Set pointer to the material 
    35         void SetMaterial(Material *mat); 
    36         //! Returns the bounding box 
    37         const AABox& GetBoundingVolume(); 
    38         //! last visited flag, important for rendering each geometry only once 
    39         void SetLastVisited(int lastVisited); 
    40         //! returns lastvisited flag 
    41         int GetLastVisited(); 
    42         // --- sets the object type to one of teapot, torus, sphere 
    43         void SetObjectType(int type); 
    44  
    45          
    46          
    47         static int sDisplayList[NUM_OBJECTS]; 
    48          
    49         //! cleans static members 
    50         static void CleanUp(); 
    51         //! returns the triangle count of the specified object type 
    52         static int CountTriangles(int objectType); 
    53         //! initialises display lists 
    54         static void ResetLists();  
     13        /** Constructor taking a triangle container. 
     14        */ 
     15        Geometry(const TriangleContainer &triangles); 
    5516 
    5617protected: 
    5718 
    58         //! generates the display list this a object 
    59         void GenerateList(); 
     19        AxisAlignedBox3 mBoundingBox; 
     20        TriangleContainer mTriangles; 
     21} 
    6022 
    61         //! calculates accumulated transformation matrix 
    62         void CalcTransform(); 
    63         //! applies tranformations 
    64         void Transform(); 
    6523 
    66         // --- statistics 
    67         static int CountTorusTriangles(); 
    68         static int CountSphereTriangles(); 
    69         static int CountTeapotTriangles(); 
     24/** Class representing a scene entity. 
     25    A scene entity basicly consists of geometry, transformation, and a material 
     26*/ 
     27class SceneEntity 
     28{ 
     29        /** Create scene entity. 
     30        */ 
     31        SceneEntity(Geometry *geometry, Matrix4x4 *trafo, Material *mat); 
     32        /** Renders this geometry. 
     33        */ 
     34        void Render();   
     35        /** Set pointer to the geometry 
     36        */ 
     37        void SetGeometry(Geometry *geom); 
     38        /** Set pointer to the geometry 
     39        */ 
     40        void SetTransformation(const Matrix4x4 *trafo); 
     41        /** Set pointer to the material 
     42        */ 
     43        void SetMaterial(Material *mat); 
     44        /** Returns the transformed bounding box. 
     45        */ 
     46        const AxisAlignedBox3& GetBoundingVolume(); 
     47        /** set frame where we last visitied this node 
     48        */ 
     49        void SetLastVisited(int lastVisited); 
     50        /** returns frame where we last visited this node 
     51        */ 
     52        int GetLastVisited() const; 
    7053 
    71         //! 
    72         static void CreateTorus(float innerRadius, float outerRadius, int precision); 
     54protected: 
    7355 
    74         //! calculates the bounding volume of this geometry 
    75         void CalcBoundingVolume(); 
    76         // the size of the bounging box is calculated using the radius of the sphere 
    77         void CalcSphereBoundingVolume(); 
    78         // the standard bounding volume calculation having an array of vertices 
    79         void CalcBoundingVolume(float *vertices, const int num_vertices); 
     56        /// transform matrix  
     57        Matrix4x4 *mTransform; 
     58        Geometry *mGeometry; 
     59        Material *mMaterial; 
    8060 
    81         // initialises static members 
    82         static bool Init(); 
    83  
    84         // --- drawing routines 
    85         static void RenderTeapot(); 
    86         static void RenderSphere(); 
    87         static void RenderTorus(); 
    88  
    89         // --- transformations 
    90         float mXRotation; 
    91         float mYRotation; 
    92         float mZRotation; 
    93          
    94         float mScale; 
    95  
    96         Vector3 mTranslation; 
    97          
    98         //! accumulated transform matrix  
    99         Matrix4x4 mTransform; 
    100  
    101         // --- material 
    102         float mAmbientColor[3]; 
    103         float mDiffuseColor[3]; 
    104         float mSpecularColor[3]; 
    105  
    106         AABox mBoundingBox; 
    107         //! type of the rendered object (teapot, sphere ...) 
    108         int mObjectType; 
     61        AxisAlignedBox3 mBoundingBox; 
    10962         
    11063        int mLastVisited; 
    111  
    112         // --- static members 
    113  
    114         static bool sIsInitialised; 
    115  
    116         static float const sphere_radius; 
    117          
    118         static int num_torus_indices; 
    119         static int num_torus_vertices; 
    120         static int num_torus_normals; 
    121  
    122         static float *torus_vertices; 
    123         static float *torus_normals; 
    124         static int *torus_indices; 
    125  
    126         static const int torus_precision; 
    127         static const int sphere_precision; 
    128         static const float torus_inner_radius; 
    129         static const float torus_outer_radius; 
    13064}; 
    13165 
    132  
     66} 
    13367#endif // GEOMETRY_H 

  • GTP/trunk/App/Demos/Vis/CHC_revisited/Material.cpp

    r2747 r2751  
    22#include "Material.h" 
    33 
    4 //namespace CHCDemo 
    5 //{ 
     4namespace CHCDemo 
     5{ 
    66 
    77RgbColor RandomColor(const float a, const float b) 
    … …  
    2222} 
    2323 
    24  
    25  
    26 //} 
     24} 

  • GTP/trunk/App/Demos/Vis/CHC_revisited/Material.h

    r2747 r2751  
    22#define __MATERIAL_H 
    33 
    4 //namespace CHCDemo  
    5 //{ 
    64 
     5namespace CHCDemo  
     6{ 
    77 
    88class RgbColor  
    … …  
    8080extern Material RandomMaterial(); 
    8181 
    82 //} 
     82} 
    8383 
    8484#endif 

  • GTP/trunk/App/Demos/Vis/CHC_revisited/Matrix4x4.cpp

    r2746 r2751  
    66using namespace std; 
    77 
    8 //namespace GtpVisibilityPreprocessor { 
     8namespace CHCDemo  
     9{ 
     10 
     11Matrix4x4::Matrix4x4() 
     12{} 
    913 
    1014 
    … …  
    8589        x[3][3] = x44; 
    8690} 
     91 
     92 
     93float Matrix4x4::Det3x3() const  
     94{ 
     95        return (x[0][0]*x[1][1]*x[2][2] + \ 
     96                x[1][0]*x[2][1]*x[0][2] + \ 
     97                x[2][0]*x[0][1]*x[1][2] - \ 
     98                x[2][0]*x[1][1]*x[0][2] - \ 
     99                x[0][0]*x[2][1]*x[1][2] - \ 
     100                x[1][0]*x[0][1]*x[2][2]); 
     101} 
     102 
    87103 
    88104 
    … …  
    167183} 
    168184 
     185 
    169186// Invert the given matrix using the above inversion routine. 
    170 Matrix4x4 
    171 Invert(const Matrix4x4& M) 
     187Matrix4x4 Invert(const Matrix4x4& M) 
    172188{ 
    173189        Matrix4x4 InvertMe = M; 
    … …  
    178194 
    179195// Transpose the matrix. 
    180 void 
    181 Matrix4x4::Transpose() 
     196void Matrix4x4::Transpose() 
    182197{ 
    183198        for (int i = 0; i < 4; i++) 
    … …  
    190205} 
    191206 
     207 
    192208// Transpose the given matrix using the transpose routine above. 
    193 Matrix4x4 
    194 Transpose(const Matrix4x4& M) 
     209Matrix4x4 Transpose(const Matrix4x4& M) 
    195210{ 
    196211        Matrix4x4 TransposeMe = M; 
    … …  
    199214} 
    200215 
     216 
    201217// Construct an identity matrix. 
    202 Matrix4x4 
    203 IdentityMatrix() 
     218Matrix4x4 IdentityMatrix() 
    204219{ 
    205220        Matrix4x4 M; 
    … …  
    211226} 
    212227 
     228 
    213229// Construct a zero matrix. 
    214 Matrix4x4 
    215 ZeroMatrix() 
     230Matrix4x4 ZeroMatrix() 
    216231{ 
    217232        Matrix4x4 M; 
    … …  
    635650} 
    636651 
    637 //} 
     652} 

  • GTP/trunk/App/Demos/Vis/CHC_revisited/Matrix4x4.h

    r2746 r2751  
    55 
    66 
    7 //namespace GtpVisibilityPreprocessor { 
     7namespace CHCDemo  
     8{ 
     9 
    810 
    911class Vector3; 
    … …  
    1416{ 
    1517public: 
    16         float x[4][4]; // first index is column [x], the second is row [y] 
    17  
    18         Matrix4x4() { } 
    19  
    20         // here xXY - 'X' is row, and 'Y' is column - classical mathematical notation 
     18        /** Default constructor initialising nothig. 
     19        */ 
     20        Matrix4x4(); 
     21        /** here xXY - 'X' is row, and 'Y' is column - classical mathematical notation 
     22        */ 
    2123        Matrix4x4(float x11, float x12, float x13, float x14, 
    22                 float x21, float x22, float x23, float x24, 
    23                 float x31, float x32, float x33, float x34, 
    24                 float x41, float x42, float x43, float x44); 
    25  
     24                      float x21, float x22, float x23, float x24, 
     25                          float x31, float x32, float x33, float x34, 
     26                          float x41, float x42, float x43, float x44); 
     27        /** Constructor setting the columns of the 3x3 part of the matrix. 
     28        */ 
    2629        Matrix4x4(const Vector3 &a, const Vector3 &b, const Vector3 &c); 
    2730 
    2831 
    29         // Assignment operators 
     32        //////////////// 
     33        //-- Assignment operators 
     34 
    3035        Matrix4x4& operator+= (const Matrix4x4 &A);     // add-to 
    3136        Matrix4x4& operator-= (const Matrix4x4 &A);     // subtract-from 
    … …  
    3338        Matrix4x4& operator*= (float A);                // scale by scalar 
    3439 
    35         // Fundamental operations 
    36         /// Invert the matrix .. returns 0 = regular 
     40 
     41        //////////////// 
     42        //-- Fundamental operations 
     43 
     44        /** Invert the matrix .. returns 0 = regular 
     45        */ 
    3746        int Invert();            
    38         /// Transpose the matrix 
     47        /** Transpose the matrix 
     48        */ 
    3949        void Transpose();        
     50        /** Sets the columns of the 3x3 part of the matrix. 
     51        */ 
     52        void SetColumns(const Vector3 &a, const Vector3 &b, const Vector3 &c); 
    4053 
    41         void 
    42                 SetColumns(const Vector3 &a, const Vector3 &b, const Vector3 &c); 
    43  
    44         float Det3x3() const { 
    45                 return (x[0][0]*x[1][1]*x[2][2] + \ 
    46                         x[1][0]*x[2][1]*x[0][2] + \ 
    47                         x[2][0]*x[0][1]*x[1][2] - \ 
    48                         x[2][0]*x[1][1]*x[0][2] - \ 
    49                         x[0][0]*x[2][1]*x[1][2] - \ 
    50                         x[1][0]*x[0][1]*x[2][2]); 
    51         } 
     54        float Det3x3() const; 
    5255 
    5356 
    54         friend Matrix4x4 Invert(const Matrix4x4 &M);    // Invert a given matrix 
    55         friend Matrix4x4 Transpose(const Matrix4x4 &M); // Transpose a given matrix 
     57        //////////// 
     58        //-- members 
    5659 
    57         // Create various types of matrix. 
     60        float x[4][4]; // first index is column [x], the second is row [y] 
     61 
     62 
     63        //////////////////// 
     64 
     65        // Invert a given matrix 
     66        friend Matrix4x4 Invert(const Matrix4x4 &M); 
     67        // Transpose a given matrix 
     68        friend Matrix4x4 Transpose(const Matrix4x4 &M);  
     69 
     70 
     71        /////////// 
     72        //-- Create various types of matrix. 
     73 
    5874        friend Matrix4x4 IdentityMatrix(); 
    5975        friend Matrix4x4 ZeroMatrix(); 
    … …  
    94110        friend Vector3 GetTranslation(const Matrix4x4 &M); 
    95111 
    96         // Construct rotation description according VRML'97 specification 
    97         //  const CVector4D SFRotation(void) const; 
    98  
    99  
    100  
    101112        // Overloaded output operator. 
    102113        friend std::ostream& operator<< (std::ostream &s, const Matrix4x4 &M); 
    103114}; 
    104115 
    105 // forward declaration 
     116 
     117///////// 
     118//-- forward declaration 
     119 
     120 
    106121Matrix4x4 IdentityMatrix(); 
    107 Matrix4x4 Invert(const Matrix4x4 &M);   // Invert a given matrix 
    108 Matrix4x4 Transpose(const Matrix4x4 &M);        // Transpose a given matrix 
    109  
    110 // Create various types of matrix. 
     122Matrix4x4 Invert(const Matrix4x4 &M);    
     123Matrix4x4 Transpose(const Matrix4x4 &M);         
    111124Matrix4x4 IdentityMatrix(); 
    112125Matrix4x4 ZeroMatrix(); 
    … …  
    116129Matrix4x4 RotationZMatrix(float Angle); 
    117130Matrix4x4 RotationYPRMatrix(float Yaw, float Pitch, float Roll); 
    118 // about axis 'axis' by angle 'Angle' 
    119131Matrix4x4 RotationAxisMatrix(const Vector3 &axis, float Angle); 
    120 // create the rotation matrix that rotates 'vecFrom' to 'vecTo' 
    121132Matrix4x4 RotationVectorsMatrix(const Vector3 &vecFrom, 
    122133                                                                const Vector3 &vecTo); 
    123  
    124134Matrix4x4 ScaleMatrix(float X, float Y, float Z); 
    125135Matrix4x4 GenRotation(const Vector3 &x, const Vector3 &y, 
    … …  
    127137Matrix4x4 QuadricMatrix(float a, float b, float c, float d, float e, 
    128138                                                float f, float g, float h, float j, float k); 
    129 // returns matrix for transforming normal 
    130139Matrix4x4 NormalTransformMatrix(const Matrix4x4 &M); 
    131  
    132140Matrix4x4 MirrorX(); 
    133141Matrix4x4 MirrorY(); 
    134142Matrix4x4 MirrorZ(); 
    135143Matrix4x4 RotationOnly(const Matrix4x4 &x); 
    136  
    137 // Binary operators 
    138144Matrix4x4 operator+ (const Matrix4x4 &A, const Matrix4x4 &B); 
    139145Matrix4x4 operator- (const Matrix4x4 &A, const Matrix4x4 &B); 
    140146Matrix4x4 operator* (const Matrix4x4 &A, float B); 
    141147Matrix4x4 operator* (const Matrix4x4 &A, const Matrix4x4 &B); 
    142  
    143 // friends returning Vector3 
    144148Vector3 operator*(const Matrix4x4 &M, const Vector3 &v); 
    145149Vector3 RotateOnly(const Matrix4x4 &M, const Vector3 &v); 
    … …  
    148152 
    149153 
    150 //} 
    151  
     154} 
    152155 
    153156 

  • GTP/trunk/App/Demos/Vis/CHC_revisited/RenderTraverser.h

    r2746 r2751  
    11#ifndef RENDERTRAVERSER_H 
    22#define RENDERTRAVERSER_H 
     3 
     4 
    35 
    46#if TOIMPLEMENT 
    … …  
    1012#include <stack> 
    1113 
    12  
     14namespace CHCDemo 
     15{ 
    1316 
    1417typedef stack<HierarchyNode *> TraversalStack; 
    … …  
    131134        bool mUseOptimization; 
    132135}; 
     136 
     137} 
     138 
    133139#endif 
     140 
     141 
    134142#endif // RENDERTRAVERSER_H 

  • GTP/trunk/App/Demos/Vis/CHC_revisited/Timers.cpp

    r2642 r2751  
    107107   
    108108#else 
    109    
    110   if (hasHRTimer == 1) { 
    111     LARGE_INTEGER counter; 
    112     QueryPerformanceCounter(&counter); 
    113     // return in usec 
    114     return (long) (1000000*counter.QuadPart/(hrFreq.QuadPart)); 
    115   } else { 
    116     static struct _timeb mtime; 
    117     _ftime(&mtime); 
    118      
    119     return 1000*(1000*mtime.time + mtime.millitm); 
    120   } 
     109 
     110        if (hasHRTimer == 1)  
     111        { 
     112                LARGE_INTEGER counter; 
     113                QueryPerformanceCounter(&counter); 
     114                // return in usec 
     115                return (long) (1000000*counter.QuadPart/(hrFreq.QuadPart)); 
     116        } else { 
     117                static struct _timeb mtime; 
     118                _ftime(&mtime); 
     119 
     120                return 1000 * (1000 * mtime.time + mtime.millitm); 
     121        } 
    121122#endif 
    122123} 
    … …  
    138139  time_t t; 
    139140  time(&t); 
     141 
    140142  return ctime(&t); 
    141143} 

  • GTP/trunk/App/Demos/Vis/CHC_revisited/Timers.h

    r2746 r2751  
    1818 
    1919/** Example of usage: 
    20 see timers.h for diffirent possibilities of what is really measured.. 
     20see timers.h for diffirent possibilities of what is really measured. 
    2121 
    2222 

  • GTP/trunk/App/Demos/Vis/CHC_revisited/Triangle3.cpp

    r2750 r2751  
    11#include "Triangle3.h" 
    2 #include "Ray.h" 
    3 #include "SimpleRay.h" 
    42#include "AxisAlignedBox3.h" 
    5 #include "Containers.h" 
    6 #include "Polygon3.h" 
     3#include "common.h" 
     4#include "Plane3.h" 
    75 
    86 
    97using namespace std; 
    108 
    11 namespace GtpVisibilityPreprocessor { 
     9 
     10namespace CHCDemo { 
    1211 
    1312         
    … …  
    2524} 
    2625 
    27  
    28 float Triangle3::GetSpatialAngle(const Vector3 &point) const 
    29 { 
    30         return 0.0f; 
    31 } 
    32  
    33  
    34 int 
    35 Triangle3::CastRay(const Ray &ray, 
    36                    float &t, 
    37                    const float nearestT, 
    38                    Vector3 &normal) const 
    39 { 
    40   ////////////// 
    41   // specialised triangle ray casting version 
    42   // using ray-plane intersection 
    43    
    44   // get triangle edge vectors and plane normal 
    45   const Vector3 u = mVertices[0] - mVertices[1]; 
    46   const Vector3 v = mVertices[2] - mVertices[1]; 
    47    
    48   // cross product 
    49   normal = Normalize(CrossProd(v, u)); 
    50    
    51   // ray direction vector 
    52   const Vector3 dir = ray.GetDir(); 
    53   const Vector3 w0 = ray.GetLoc() - mVertices[1]; 
    54    
    55   // params to calc ray-plane intersect 
    56   const float a = -DotProd(normal, w0); 
    57   const float b = DotProd(normal, dir); 
    58    
    59   // check for division by zero 
    60   if (fabs(b) < Limits::Small)  
    61     {    
    62       // ray is parallel to triangle plane 
    63       if (a == 0) 
    64         { 
    65           // ray lies in triangle plane 
    66           return Ray::INTERSECTION_OUT_OF_LIMITS; 
    67         } 
    68       else 
    69         { 
    70           // ray disjoint from plane 
    71           return Ray::NO_INTERSECTION; 
    72         } 
    73     } 
    74  
    75   // distance from origin of ray to plane 
    76   t = a / b; 
    77    
    78   if (t <= Limits::Small) // ray goes away from triangle 
    79     { 
    80       return Ray::INTERSECTION_OUT_OF_LIMITS; 
    81     } 
    82   // already found nearer intersection 
    83   else if ((ray.GetType() == Ray::LOCAL_RAY) && (t >= nearestT)) 
    84     { 
    85       return Ray::NO_INTERSECTION; 
    86     } 
    87    
    88   ///////////////// 
    89     //-- found intersection point 
    90   //-- check if it is inside triangle 
    91    
    92   const Vector3 pt = ray.GetLoc() + t * dir;  
    93 #if GTP_DEBUG 
    94   if (!pt.CheckValidity()) 
    95     { 
    96       cout << "tr: " << *this << endl; 
    97       cout << "v: " << pt << " t: " << t << " a: " << a << " b: " << b << " n: " << normal << endl; 
    98     } 
    99 #endif 
    100   const Vector3 w = pt - mVertices[1]; 
    101    
    102   const float uu = DotProd(u, u); 
    103   const float uv = DotProd(u, v); 
    104   const float vv = DotProd(v, v); 
    105    
    106   const float wu = DotProd(w, u); 
    107   const float wv = DotProd(w, v); 
    108    
    109    
    110   const float D = uv * uv - uu * vv; 
    111    
    112   // get and test parametric coords 
    113   const float s = (uv * wv - vv * wu) / D; 
    114    
    115   if ((s < -Limits::Small) || (s > 1.0f + Limits::Small)) // pt is outside triangle 
    116     {    
    117       return Ray::NO_INTERSECTION; 
    118     } 
    119    
    120   const float s2 = (uv * wu - uu * wv) / D; 
    121    
    122   if ((s2 < -Limits::Small) || ((s + s2) > 1.0f + Limits::Small)) // pt is outside triangle 
    123     {    
    124       return Ray::NO_INTERSECTION; 
    125     } 
    126    
    127   return Ray::INTERSECTION; // I is in T 
    128 } 
    129  
    130  
    131 int 
    132 Triangle3::CastSimpleRay(const SimpleRay &ray, 
    133                          float &t, 
    134                          const float nearestT) const 
    135 { 
    136   ////////////// 
    137   // specialised triangle ray casting version 
    138   // using ray-plane intersection 
    139    
    140   // get triangle edge vectors and plane normal 
    141   const Vector3 u = mVertices[0] - mVertices[1]; 
    142   const Vector3 v = mVertices[2] - mVertices[1]; 
    143  
    144   // cross product 
    145   const Vector3 normal = Normalize(CrossProd(v, u)); 
    146  
    147   // ray direction vector 
    148   const Vector3 dir = ray.mDirection; 
    149   const Vector3 w0 = ray.mOrigin - mVertices[1]; 
    150  
    151   // params to calc ray-plane intersect 
    152   const float a = -DotProd(normal, w0); 
    153   const float b = DotProd(normal, dir); 
    154  
    155   // check for division by zero 
    156   if (fabs(b) < Limits::Small)  
    157   {    
    158     // ray is parallel to triangle plane 
    159     if (a == 0) 
    160     { 
    161       // ray lies in triangle plane 
    162       return Ray::INTERSECTION_OUT_OF_LIMITS; 
    163     } 
    164     else { 
    165       // ray disjoint from plane 
    166       return Ray::NO_INTERSECTION; 
    167     } 
    168   } 
    169  
    170   // distance from origin of ray to plane 
    171   t = a / b; 
    172  
    173   if (t <= Limits::Small) // ray goes away from triangle 
    174   { 
    175     return Ray::INTERSECTION_OUT_OF_LIMITS; 
    176   } 
    177  
    178   // already found nearer intersection 
    179   if (t > nearestT + 1e-5) 
    180   { 
    181     return Ray::NO_INTERSECTION; 
    182   } 
    183  
    184   ///////////////// 
    185   //-- found intersection point 
    186   //-- check if it is inside triangle 
    187    
    188   const Vector3 pt = ray.mOrigin + t * dir;  
    189 #if GTP_DEBUG 
    190   if (!pt.CheckValidity()) 
    191   { 
    192     cout << "tr: " << *this << endl; 
    193     cout << "v: " << pt << " t: " << t << " a: " << a << " b: " << b << " n: " << normal << endl; 
    194   } 
    195 #endif 
    196   const Vector3 w = pt - mVertices[1]; 
    197  
    198   const float uu = DotProd(u, u); 
    199   const float uv = DotProd(u, v); 
    200   const float vv = DotProd(v, v); 
    201      
    202   const float wu = DotProd(w, u); 
    203   const float wv = DotProd(w, v); 
    204    
    205    
    206   const float D = uv * uv - uu * vv; 
    207    
    208   // get and test parametric coords 
    209   const float s = (uv * wv - vv * wu) / D; 
    210    
    211   if ((s < -Limits::Small) || 
    212       (s > 1.0f + Limits::Small)) // pt is outside triangle 
    213   {      
    214     return Ray::NO_INTERSECTION; 
    215   } 
    216  
    217   const float s2 = (uv * wu - uu * wv) / D; 
    218    
    219   if ((s2 < -Limits::Small) || 
    220       ((s + s2) > 1.0f + Limits::Small)) // pt is outside triangle 
    221   {      
    222     return Ray::NO_INTERSECTION; 
    223   } 
    224    
    225   return Ray::INTERSECTION; // I is in T 
    226 } 
    227    
    22826 
    22927AxisAlignedBox3 Triangle3::GetBoundingBox() const 
    … …  
    28280        // compute distance from plane 
    28381        for (int i = 0; i < 3; ++ i) 
    284         { 
    28582                side[i] = plane.Side(mVertices[i], Limits::Small); 
    286         } 
    28783 
    28884        ///// 
    … …  
    324120                        { 
    325121                                intersectA = mVertices[i] + t * (mVertices[i_2] - mVertices[i]); 
    326                          
    327122                                foundA = true; 
    328123                        } 
    … …  
    330125                        { 
    331126                                intersectB = mVertices[i] + t * (mVertices[i_2] - mVertices[i]); 
    332                          
    333127                                return true; 
    334128                        } 

  • GTP/trunk/App/Demos/Vis/CHC_revisited/Triangle3.h

    r2750 r2751  
    55 
    66 
    7 namespace GtpVisibilityPreprocessor { 
     7namespace CHCDemo  
     8{ 
    89 
    910class AxisAlignedBox3; 
    10 class Ray; 
    11 struct SimpleRay; 
    1211class Plane3; 
     12 
    1313 
    1414struct Triangle3  
    … …  
    2626 
    2727        float GetArea() const; 
    28  
    29         /// returns bounding box around this triangle 
     28        /** returns bounding box around this triangle 
     29        */ 
    3030        AxisAlignedBox3 GetBoundingBox() const; 
    31  
    32         /// Casts ray into this triangle. Returns hit 
    33         int CastRay(const Ray &ray, float &t, const float nearestT, Vector3 &normal) const; 
    34  
    35         int CastSimpleRay(const SimpleRay &ray, float &t, const float nearestT) const; 
    36    
    37         friend std::ostream& operator<< (std::ostream &s, const Triangle3 &A); 
    38         friend std::istream& operator>> (std::istream &s, Triangle3 &A); 
    39  
    4031        /** Checks if this triangle is ill-defined. 
    4132        */ 
    4233        bool CheckValidity() const; 
    43  
    4434        /** Intersects triangle with plane, returns intersection points 
    4535                if intersection is happening. 
    … …  
    5040                                                          Vector3 &intersectA,  
    5141                                                          Vector3 &intersectB) const; 
     42 
     43           
     44        friend std::ostream& operator<< (std::ostream &s, const Triangle3 &A); 
     45        friend std::istream& operator>> (std::istream &s, Triangle3 &A); 
     46 
    5247 
    5348        /////////////////// 

  • GTP/trunk/App/Demos/Vis/CHC_revisited/Vector3.cpp

    r2746 r2751  
    55 
    66 
    7 //namespace CHCDemo 
    8 //{ 
     7namespace CHCDemo 
     8{ 
    99 
    1010// Given min a vector to minimize and a candidate vector, replace 
    … …  
    263263                sinTheta*cos(fi)); 
    264264 
    265         Matrix4x4 m = RotationVectorsMatrix( 
    266                 normal, 
    267                 Vector3(0,1,0)); 
     265        Matrix4x4 m = RotationVectorsMatrix(normal, Vector3(0,1,0)); 
    268266        Matrix4x4 mi = Invert(m); 
    269         m = m*RotationVectorsMatrix( 
    270                 Vector3(0,1,0), 
    271                 Normalize(dir))*mi; 
     267 
     268        m = m*RotationVectorsMatrix(Vector3(0, 1, 0), Normalize(dir)) * mi; 
    272269 
    273270        return TransformNormal(m, normal); 
    … …  
    282279        return !(isnan(x) || isnan(y) || isnan(z)); 
    283280#endif   
    284         //return ((x != x) || (y != y) || (z != z)); 
    285 } 
    286  
    287 //} 
     281} 
     282 
     283} 

  • GTP/trunk/App/Demos/Vis/CHC_revisited/Vector3.h

    r2746 r2751  
    1111 
    1212 
     13namespace CHCDemo 
     14{ 
    1315 
    1416/** Vector class. 
    … …  
    358360 
    359361        if (signedAngle < 0) 
    360                 return 2 * PI + signedAngle; 
     362                return 2 * M_PI + signedAngle; 
    361363 
    362364        return signedAngle; 
    … …  
    530532 
    531533 
    532  
    533 //} 
     534} 
    534535 
    535536#endif 

  • GTP/trunk/App/Demos/Vis/CHC_revisited/chc_revisited.vcproj

    r2746 r2751  
    4646                                BasicRuntimeChecks="3" 
    4747                                RuntimeLibrary="3" 
     48                                RuntimeTypeInfo="false" 
    4849                                UsePrecompiledHeader="0" 
    4950                                WarningLevel="3" 
    … …  
    119120                        <Tool 
    120121                                Name="VCCLCompilerTool" 
     122                                InlineFunctionExpansion="2" 
     123                                EnableIntrinsicFunctions="true" 
     124                                FavorSizeOrSpeed="1" 
     125                                OmitFramePointers="true" 
     126                                EnableFiberSafeOptimizations="true" 
    121127                                AdditionalIncludeDirectories="GL" 
    122128                                PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE" 
    123129                                RuntimeLibrary="2" 
     130                                RuntimeTypeInfo="false" 
    124131                                UsePrecompiledHeader="0" 
    125132                                WarningLevel="3" 
    … …  
    182189                        > 
    183190                        <File 
    184                                 RelativePath=".\AxisAlignedBox3.cpp" 
    185                                 > 
    186                         </File> 
    187                         <File 
    188                                 RelativePath=".\common.cpp" 
    189                                 > 
    190                         </File> 
    191                         <File 
    192                                 RelativePath=".\HierarchyNode.cpp" 
    193                                 > 
    194                         </File> 
    195                         <File 
    196                                 RelativePath=".\Material.cpp" 
    197                                 > 
    198                         </File> 
    199                         <File 
    200                                 RelativePath=".\Matrix4x4.cpp" 
     191                                RelativePath=".\Bvh.cpp" 
     192                                > 
     193                        </File> 
     194                        <File 
     195                                RelativePath=".\Geometry.cpp" 
    201196                                > 
    202197                        </File> 
    203198                        <File 
    204199                                RelativePath=".\occquery.cpp" 
    205                                 > 
    206                         </File> 
    207                         <File 
    208                                 RelativePath=".\RenderTraverser.cpp" 
    209                                 > 
    210                         </File> 
    211                         <File 
    212                                 RelativePath=".\Timers.cpp" 
    213200                                > 
    214201                        </File> 
    … …  
    220207                        > 
    221208                        <File 
     209                                RelativePath=".\Bvh.h" 
     210                                > 
     211                        </File> 
     212                        <File 
     213                                RelativePath=".\Geometry.h" 
     214                                > 
     215                        </File> 
     216                        <File 
     217                                RelativePath=".\Material.h" 
     218                                > 
     219                        </File> 
     220                </Filter> 
     221                <Filter 
     222                        Name="utils" 
     223                        > 
     224                        <File 
     225                                RelativePath=".\AxisAlignedBox3.cpp" 
     226                                > 
     227                        </File> 
     228                        <File 
    222229                                RelativePath=".\AxisAlignedBox3.h" 
    223230                                > 
    224231                        </File> 
    225232                        <File 
    226                                 RelativePath=".\Bvh.cpp" 
    227                                 > 
    228                         </File> 
    229                         <File 
    230                                 RelativePath=".\Bvh.h" 
     233                                RelativePath=".\common.cpp" 
    231234                                > 
    232235                        </File> 
    … …  
    240243                        </File> 
    241244                        <File 
    242                                 RelativePath=".\Material.h" 
     245                                RelativePath=".\Material.cpp" 
     246                                > 
     247                        </File> 
     248                        <File 
     249                                RelativePath=".\Matrix4x4.cpp" 
    243250                                > 
    244251                        </File> 
    … …  
    248255                        </File> 
    249256                        <File 
     257                                RelativePath=".\Plane3.cpp" 
     258                                > 
     259                        </File> 
     260                        <File 
     261                                RelativePath=".\Plane3.h" 
     262                                > 
     263                        </File> 
     264                        <File 
     265                                RelativePath=".\Timers.cpp" 
     266                                > 
     267                        </File> 
     268                        <File 
     269                                RelativePath=".\Timers.h" 
     270                                > 
     271                        </File> 
     272                        <File 
     273                                RelativePath=".\Triangle3.cpp" 
     274                                > 
     275                        </File> 
     276                        <File 
     277                                RelativePath=".\Triangle3.h" 
     278                                > 
     279                        </File> 
     280                        <File 
     281                                RelativePath=".\Vector3.cpp" 
     282                                > 
     283                        </File> 
     284                        <File 
     285                                RelativePath=".\Vector3.h" 
     286                                > 
     287                        </File> 
     288                </Filter> 
     289                <Filter 
     290                        Name="traversal" 
     291                        > 
     292                        <File 
     293                                RelativePath=".\RenderTraverser.cpp" 
     294                                > 
     295                        </File> 
     296                        <File 
    250297                                RelativePath=".\RenderTraverser.h" 
    251                                 > 
    252                         </File> 
    253                         <File 
    254                                 RelativePath=".\Timers.h" 
    255                                 > 
    256                         </File> 
    257                         <File 
    258                                 RelativePath=".\Vector3.cpp" 
    259                                 > 
    260                         </File> 
    261                         <File 
    262                                 RelativePath=".\Vector3.h" 
    263298                                > 
    264299                        </File> 

  • GTP/trunk/App/Demos/Vis/CHC_revisited/common.cpp

    r2746 r2751  
    2525using namespace std; 
    2626 
    27 //namespace CHCDemo { 
     27 
     28namespace CHCDemo  
     29{ 
    2830 
    2931 
    … …  
    337339#endif 
    338340 
    339 //} 
     341} 

  • GTP/trunk/App/Demos/Vis/CHC_revisited/common.h

    r2746 r2751  
    1 /** 
    2  
    3 This file contains various macros, templates and constants for the ERS system. 
    4  
    5 @author Jiri Bittner 
     1/** This file contains various macros, templates and constants for the ERS system. 
     2    @author Jiri Bittner 
    63*/ 
    74 
    … …  
    1916 
    2017 
    21 //namespace GtpVisibilityPreprocessor { 
    22  
     18namespace CHCDemo  
     19{ 
     20 
     21struct Triangle3; 
    2322   
    2423#if defined(_MSC_VER) 
    … …  
    5453#include <values.h> 
    5554#else // __WATCOMC__ 
    56 #define M_PI        3.14159265358979323846 
     55#define M_PI        3.14159265358979323846F 
    5756#define MAXFLOAT    3.40282347e+37F 
    5857#endif // __WATCOMC__ 
    … …  
    119118#endif // NULL 
    120119 
    121 //ostream& operator<<(ostream &s,const BaseC &c); 
    122  
    123120typedef float Real; 
    124121typedef unsigned char byte; 
    125122 
    126 //#ifndef FALSE 
    127 //#define FALSE 0 
    128 //#define TRUE !0 
    129 //#endif 
    130  
    131 #ifndef __GNUG__ 
    132 // typedef int bool; 
    133 #endif 
    134123 
    135124#ifndef getch 
    … …  
    137126#endif 
    138127 
    139  
    140128#define TRASH 1.0e-5 
    141129 
    142 #ifndef PI 
    143 #define PI    3.14159265358979323846f 
    144 #endif 
    145  
    146 #define MIN_FLOAT -1e30f 
    147 #define MAX_FLOAT  1e30f 
    148  
    149  
    150 // tolerance value for polygon area 
    151 #define AREA_LIMIT 0.0001f 
    152  
     130// delete a pointer and set to NULL 
    153131#ifndef DEL_PTR 
    154132#define DEL_PTR(ptr) do {if (ptr) {        \ 
    … …  
    157135                     while (0) 
    158136#endif 
     137 
     138 
    159139// Clears a container (i.e., a vector of pointers) and deletes the pointers 
    160 #if 0 
    161140#ifndef CLEAR_CONTAINER 
    162 #define CLEAR_CONTAINER(co) do { while (!(co).empty()) {   \ 
    163                                                            DEL_PTR((co).back());     \ 
    164                                                                    (co).pop_back();}}      \ 
    165                                                         while (0) 
    166 #endif 
    167  
    168 #else 
    169  
    170 #ifndef CLEAR_CONTAINER 
    171 #define CLEAR_CONTAINER(co) do { for (int _i = 0; _i < (int)(co).size(); ++ _i) { \ 
     141#define CLEAR_CONTAINER(co) do { for (size_t _i = 0; _i < (int)(co).size(); ++ _i) { \ 
    172142        DEL_PTR((co)[_i]);} \ 
    173143        (co).clear(); } \ 
    … …  
    175145#endif 
    176146 
    177 #endif 
    178  
    179  
    180 inline 
    181 int signum(const Real a, const Real thresh = TRASH) 
     147 
     148inline int signum(const Real a, const Real thresh = TRASH) 
    182149{ 
    183150  if (a>thresh) 
    … …  
    320287inline Real Deg2Rad(const Real a) 
    321288{ 
    322    return a * (PI / 180.0f); 
     289   return a * (M_PI / 180.0f); 
    323290} 
    324291 
    325292inline Real Rad2Deg(const Real a) { 
    326   return a*(180.0f/PI); 
     293  return a * (180.0f/M_PI); 
    327294} 
    328295   
    … …  
    335302 
    336303 
    337 // ------------------------------------------------------------------- 
    338 // Limits. 
    339 //  This class encapsulates all the concessions to Realing-point 
    340 //  error made by ray tracers. 
    341 // ------------------------------------------------------------------- 
    342  
    343 class Limits { 
     304/** Limits. 
     305    This class encapsulates all the concessions to Realing-point 
     306        error made by ray tracers. 
     307*/ 
     308class Limits  
     309{ 
    344310public: 
    345   // This is the number used to reject too-close intersections. 
    346   // The default value is 1.0. 
    347   static Real Threshold; 
    348  
    349   // This is a "small" number.  Less than this number is assumed to 
    350   // be 0, when such things matter. 
    351   // The default value is 0.1. 
    352   static Real Small; 
    353  
    354   // This is an impractically "large" number, used for intersection 
    355   // parameters out to infinity (e.g. the span resulting from an 
    356   // FindAllIntersections operation on a plane). 
    357   // The default value is 100000. 
    358   static Real Infinity; 
     311        // This is the number used to reject too-close intersections. 
     312        // The default value is 1.0. 
     313        static Real Threshold; 
     314 
     315        // This is a "small" number.  Less than this number is assumed to 
     316        // be 0, when such things matter. 
     317        // The default value is 0.1. 
     318        static Real Small; 
     319 
     320        // This is an impractically "large" number, used for intersection 
     321        // parameters out to infinity (e.g. the span resulting from an 
     322        // FindAllIntersections operation on a plane). 
     323        // The default value is 100000. 
     324        static Real Infinity; 
    359325}; 
    360326 
    … …  
    488454 
    489455 
    490 //} 
    491  
    492 #endif 
    493  
    494  
    495  
    496  
    497  
    498  
    499  
    500  
     456typedef std::vector<Triangle3> TriangleContainer; 
     457 
     458} 
     459 
     460#endif 
     461 
     462 
     463 
     464 
     465 
     466 
     467 
     468 
Note: See TracChangeset for help on using the changeset viewer.