Changeset 2756 for GTP


Ignore:
Timestamp:
06/13/08 18:06:32 (17 years ago)
Author:
mattausch
Message:
 
Location:
GTP/trunk/App/Demos/Vis/CHC_revisited
Files:
16 edited

Legend:

Unmodified
Added
Removed

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

    r2755 r2756  
    22#include "Matrix4x4.h" 
    33#include "Geometry.h" 
     4#include "SceneEntity.h" 
    45#include "Material.h" 
     6#include "Texture.h" 
    57//#include "gzstream.h" 
    68 
    … …  
    6668 
    6769 
    68 //SceneEntity *BinaryLoader::LoadShape(igzstream &str) 
    69 SceneEntity *BinaryLoader::LoadShape(ifstream &str) 
     70//SceneEntity *BinaryLoader::LoadSceneEntity(igzstream &str) 
     71SceneEntity *BinaryLoader::LoadSceneEntity(ifstream &str) 
    7072{        
    7173        Geometry *geom = LoadGeometry(str); 
    7274        Material *mat = LoadMaterial(str); 
    73  
    74         Matrix4x4 *m; 
    75         SceneEntity *sceneGeom = new SceneEntity(geom, m, mat); 
     75        Matrix4x4 *trafo = NULL;//IdentityMatrix(); 
     76 
     77        SceneEntity *sceneGeom = new SceneEntity(geom, mat, trafo); 
    7678 
    7779        return sceneGeom; 
    … …  
    8284Material *BinaryLoader::LoadMaterial(ifstream &str) 
    8385{ 
     86        // default material 
    8487        Material *mat = new Material(); 
    85 /*       
     88         
    8689        // texture 
    8790        int texnameSize; 
    … …  
    9194        if (texnameSize) 
    9295        { 
    93                 TextureAttributes *texAttr; 
    9496                char *texname = new char[texnameSize]; 
    95                 str.read(texname, sizeof(char) * texnameSize); 
    96  
    97                 Texture *tex = get_texture(texname, texAttr); 
    98                 app->setTexture(tex); 
    99                 app->setTextureAttributes(texAttr); 
    100         } 
     97                str.read(texname, sizeof(char) *texnameSize); 
     98 
     99 
     100                cout << "loading texture " << texname << " with len " << texnameSize << endl; 
     101                Texture *tex = new Texture(texname); 
     102                 
     103                mat->SetTexture(tex); 
     104        } 
     105        else 
     106                cout << "no texture " << texnameSize << endl; 
    101107 
    102108        // material 
    103         char hasMaterial; 
     109        /*char hasMaterial; 
    104110        str.read(&hasMaterial, sizeof(char)); 
    105111         
    … …  
    137143Geometry *BinaryLoader::LoadGeometry(ifstream &str) 
    138144{ 
    139 /* 
     145        Vector3 *vertices; 
     146        Vector3 *normals; 
     147        float *texcoords; 
     148 
     149 
     150        ////////////// 
     151        //-- read in vertices 
     152 
    140153        int vertexCount; 
    141         int stripCount; 
    142  
    143         Point3f *vertices; 
    144         Vector3f *normals = NULL; 
    145         Point2f *texCoords = NULL; 
    146  
    147         int *stripIndexCounts; 
    148         int *indices; 
    149         int *normalIndices; 
    150  
    151         // todo 
    152         int colorCount = 0; 
    153         int normalCount = 0; 
    154         int texCount = 0; 
    155  
    156         int format; 
    157  
    158         // read in format 
    159         str.read(reinterpret_cast<char *>(&format), sizeof(int)); 
    160          
    161         format = IndexedTriangleStripArray::COORDINATES  
    162                 | IndexedTriangleStripArray::NORMALS 
    163                 ; 
    164  
    165         //OUT1("new format: " << format); 
    166  
     154        str.read(reinterpret_cast<char *>(&vertexCount), sizeof(int)); 
     155         
    167156        // end of file reached 
    168157        if (str.eof()) 
    169158                return NULL; 
    170159 
    171  
    172         ////////////// 
    173         // read in vertices 
    174          
    175         str.read(reinterpret_cast<char *>(&vertexCount), sizeof(int)); 
    176          
    177         vertices = new Point3f[vertexCount]; 
    178     str.read(reinterpret_cast<char *>(vertices), sizeof(Point3f) * vertexCount); 
    179  
    180  
    181         ///////////////// 
    182         // read in strip counters 
    183          
    184         str.read(reinterpret_cast<char *>(&stripCount), sizeof(int)); 
    185  
    186         stripIndexCounts = new int[stripCount]; 
    187     str.read(reinterpret_cast<char *>(stripIndexCounts), sizeof(int) * stripCount); 
    188  
    189  
    190         ////////// 
    191         // read in indices 
    192  
    193         int indexCount; 
    194         str.read(reinterpret_cast<char *>(&indexCount), sizeof(int)); 
    195         indices = new int[indexCount]; 
    196     str.read(reinterpret_cast<char *>(indices), sizeof(int) * indexCount); 
    197  
    198  
    199         /////////////// 
    200         // read in normals 
    201          
    202         str.read(reinterpret_cast<char *>(&normalCount), sizeof(int)); 
    203  
    204         if (normalCount) 
    205         { 
    206                 normals = new Vector3f[normalCount]; 
    207                 str.read(reinterpret_cast<char *>(normals), sizeof(Vector3f) * normalCount); 
    208                 normalIndices = new int[indexCount]; 
    209                 str.read(reinterpret_cast<char *>(normalIndices), sizeof(int) * indexCount); 
    210         } 
    211  
    212  
    213         ////////////// 
    214         // read in texCoords 
    215          
    216         str.read(reinterpret_cast<char *>(&texCount), sizeof(int)); 
    217         if (texCount) 
    218         { 
    219                 texCoords = new Point2f[texCount]; 
    220                 str.read(reinterpret_cast<char *>(texCoords), sizeof(Point2f) * texCount); 
    221         } 
    222          
    223         IndexedTriangleStripArray *geom =  
    224                 new IndexedTriangleStripArray(vertexCount,  
    225                                                                           normalCount,  
    226                                                                           texCount,  
    227                                                                           colorCount,  
    228                                                                           format,  
    229                                                                           indexCount,  
    230                                                                           stripIndexCounts,  
    231                                                                           stripCount); 
    232  
    233         geom->setCoordinates(0, vertices, vertexCount); 
    234         geom->setCoordinateIndices(0, indices, indexCount); 
    235  
    236  
    237         if (texCount) 
    238         { 
    239                 geom->setTextureCoordinateIndices(0, indices, indexCount); 
    240                 geom->setTextureCoordinates(0, texCoords, texCount); 
    241         } 
    242  
    243         if (normalCount) 
    244         { 
    245                 geom->setNormals(0, normals, normalCount); 
    246                 geom->setNormalIndices(0, normalIndices, indexCount); 
    247         } 
    248          
    249  
    250         /////// 
    251         //-- cleanup 
    252  
    253         DELAPTR(stripIndexCounts); 
    254         DELAPTR(vertices); 
    255         DELAPTR(normals);  
    256         DELAPTR(texCoords); 
    257         DELAPTR(indices); 
    258         DELAPTR(normalIndices); 
    259  
    260          
    261         return geom;  
    262         */ 
    263 return 0; 
     160        cout << "vertexcount: " << vertexCount << endl; 
     161 
     162        vertices = new Vector3[vertexCount]; 
     163    str.read(reinterpret_cast<char *>(vertices), sizeof(Vector3) * vertexCount); 
     164         
     165        normals = new Vector3[vertexCount]; 
     166        str.read(reinterpret_cast<char *>(normals), sizeof(Vector3) * vertexCount); 
     167 
     168        int texCoordCount; 
     169        str.read(reinterpret_cast<char *>(&texCoordCount), sizeof(int)); 
     170 
     171        if (texCoordCount) 
     172        { 
     173                cout << "loading texcoords of size " << texCoordCount << endl; 
     174                texcoords = new float[texCoordCount * 2]; 
     175                str.read(reinterpret_cast<char *>(texcoords), sizeof(float) * vertexCount * 2); 
     176        } 
     177        else 
     178                texcoords = NULL; 
     179 
     180        for (int i = 0; i < vertexCount; i += 3) 
     181        { 
     182                Triangle3 tri(vertices[i], vertices[i + 1], vertices[i + 2]); 
     183                Vector3 n = tri.GetNormal(); 
     184 
     185                normals[i + 0] = n; 
     186                normals[i + 1] = n; 
     187                normals[i + 2] = n; 
     188        } 
     189 
     190        return new Geometry(vertices, normals, texcoords, vertexCount); 
    264191} 
    265192 
    … …  
    267194bool BinaryLoader::Load(const std::string &filename, SceneEntityContainer &geometry) 
    268195{ 
    269 #if 0 
    270         clear_textures(); // clear the texture table 
    271  
    272         BranchGroup *root = new BranchGroup(); 
    273         //root->setName("start"); 
    274         igzstream str(filename.c_str());//, ios::binary); 
    275          
    276         if (!str.is_open()) 
     196        //clear_textures(); // clear the texture table 
     197 
     198        //igzstream str(filename.c_str());//, ios::binary); 
     199        ifstream istr(filename.c_str(), ios::binary); 
     200         
     201        if (!istr.is_open()) 
    277202                return false; 
    278203 
    279204        // #shapes 
    280205        int shapeCount; 
    281         str.read(reinterpret_cast<char *>(&shapeCount), sizeof(int)); 
     206        istr.read(reinterpret_cast<char *>(&shapeCount), sizeof(int)); 
    282207 
    283208        int progress = 0; 
    284209 
    285         GeometryProcessor geomConv(500000, NULL); 
    286  
    287210        for (int i = 0; i < shapeCount; ++ i) 
    288211        { 
    289                 Shape3D *shape = LoadShape(str); 
    290  
    291                 vector<Shape3D *> newShapes; 
    292                 ShapePair shapePair = ShapePair(shape, -1); 
    293  
    294                 // check, if this node actually contains any geometry 
    295                 CalcNumTrianglesVisitor triangleVisitor; 
    296                 triangleVisitor.Apply(shape); 
    297                 const int numTriangles = triangleVisitor.GetNumTriangles(); 
    298  
    299                 // the shape should be subdivided => replace old shape 
    300                 if (geomConv.SubdivideShape(newShapes, shapePair, numTriangles)) 
    301                 { 
    302                         OUT1("triangleCount: " << numTriangles  << " => subdividing to " << newShapes.size() << " shapes");                      
    303                         delete shape;//shape->unref(); 
    304                 } 
    305                 else 
    306                 { 
    307                         newShapes.push_back(shape); 
    308                 } 
    309  
    310                 VisibilityGroup * visGrp = new VisibilityGroup(); 
    311                 root->addChild(visGrp); 
    312  
    313                 for (size_t j = 0; j < newShapes.size(); ++ j) 
    314                 { 
    315                         Shape3D *sh = newShapes[j]; 
    316                         visGrp->addChild(sh); 
    317                 } 
    318  
    319                 int p = i * 100 / shapeCount; 
     212                SceneEntity *ent = LoadSceneEntity(istr); 
     213                geometry.push_back(ent); 
     214                 
     215                int p = (i + 1) * 100 / shapeCount; 
    320216                 
    321217                if (p >= progress) 
    322218                { 
    323                         OUT1("% loaded: " << p); 
     219                        cout << "% loaded: " << p << endl; 
    324220                        progress += 10; 
    325221                } 
    326222        } 
    327223 
    328         OUT1("bin loading finished"); 
    329  
    330         return root; 
    331 #endif 
    332 } 
    333  
    334 } 
     224        cout << "bin loading finished" << endl; 
     225 
     226        return true; 
     227} 
     228 
     229} 

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

    r2755 r2756  
    2626protected: 
    2727         
    28         SceneEntity *LoadShape(std::ifstream &str); 
     28        SceneEntity *LoadSceneEntity(std::ifstream &str); 
    2929        Material *LoadMaterial(std::ifstream &str); 
    3030        Geometry *LoadGeometry(std::ifstream &str); 

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

    r2755 r2756  
    1010#include "glInterface.h" 
    1111#include "Triangle3.h" 
    12  
     12#include "SceneEntity.h" 
     13#include "Geometry.h" 
    1314 
    1415namespace CHCDemo 
    … …  
    557558 
    558559 
    559 /* 
    560560void Bvh::ComputeIds() 
    561561{ 
    562         // collect all nodes, also the nodes from local bvh 
    563         // warning: root nodes local bvh are not in there, as they  
    564         // are equivalent geometry bvh leaves 
     562        // collect all nodes 
    565563        BvhNodeContainer nodes; 
    566         CollectAllNodes(mRoot, nodes); 
     564        CollectNodes(mRoot, nodes); 
    567565 
    568566        // assign ids to all nodes of the "regular" hierarchy 
    569567        int i = 0; 
    570         HierarchyNodeContainer::const_iterator lit, lit_end = nodes.end(); 
     568        BvhNodeContainer::const_iterator lit, lit_end = nodes.end(); 
    571569 
    572570        for (lit = nodes.begin(); lit != lit_end; ++ lit, ++ i) 
    … …  
    575573        } 
    576574} 
    577 */ 
     575 
    578576 
    579577void Bvh::PrepareVertices() 
    … …  
    819817 
    820818        for (int i = node->mFirst; i <= node->mLast; ++ i) 
    821         { 
    822819                numTriangles += mGeometry[i]->GetGeometry()->CountTriangles(); 
    823         } 
    824  
     820         
    825821        return numTriangles; 
    826822} 
    827823 
    828824 
    829 float Bvh::GetGeometryArea(BvhNode *node) const 
     825float Bvh::GetArea(BvhNode *node) const 
    830826{ 
    831827        return node->mArea; 

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

    r2755 r2756  
    44#define __BVH_H 
    55 
    6 #include "Geometry.h" 
     6#include "common.h" 
     7#include "Vector3.h" 
     8#include "AxisAlignedBox3.h" 
     9//#include "SceneEntity.h" 
    710 
    811 
    … …  
    436439public: 
    437440 
     441        /** Destructor. 
     442        */ 
     443        ~Bvh(); 
    438444        /** Returns number of bvh nodes. 
    439445        */ 
    440         inline int GetNumNodes() const {return mNumNodes;} 
     446        inline int GetNumNodes() const { return mNumNodes; } 
    441447        /** Returns number of bvh leaves. 
    442448        */ 
    443         inline int GetNumLeaves() const {return mNumNodes / 2 + 1;} 
     449        inline int GetNumLeaves() const { return mNumNodes / 2 + 1;} 
    444450        /** Returns root node of the bvh. 
    445451        */ 
    … …  
    505511        */ 
    506512        int CountTriangles(BvhNode *node) const; 
    507         /** Returns area of the geometry contained in the node. 
    508         */ 
    509         float GetGeometryArea(BvhNode *node) const; 
     513        /** Returns area of the the node. 
     514        */ 
     515        float GetArea(BvhNode *node) const; 
     516        /** Compute unique ids for the nodes. 
     517        */ 
     518        void ComputeIds(); 
    510519 
    511520 
    … …  
    534543        */ 
    535544        Bvh(); 
    536         /** Destructor. 
    537         */ 
    538         ~Bvh(); 
    539  
     545         
    540546 
    541547        ///////////// 

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

    r2755 r2756  
    2929        mDirection.Normalize(); 
    3030 
    31         Vector3 side = CrossProd(Vector3(0,1,0), mDirection); 
    32         mUp = Normalize(CrossProd(side, mDirection)); 
    33         mRight = Normalize(CrossProd(mDirection, mUp)); 
     31        Vector3 side = CrossProd(Vector3(0, 1, 0), mDirection); 
     32        mUp = -Normalize(CrossProd(side, mDirection)); 
     33        mRight = -Normalize(CrossProd(mDirection, mUp)); 
    3434 
    3535        float k = tan(mFovy/2); 
    … …  
    5555void Camera::LookInBox(const AxisAlignedBox3 &box) 
    5656{ 
    57         mDirection = Vector3(0,0,1); 
     57        mDirection = Vector3(0, 0, 1); 
    5858        mPosition = box.Center(); 
     59        mPosition.y += 50; 
    5960 
    6061        Precompute(); 
    … …  
    6465void Camera::LookAtBox(const AxisAlignedBox3 &box) 
    6566{ 
    66         mDirection = box.Max() - box.Min(); 
    67         mPosition = box.Min() - mDirection; 
     67        mDirection = box.Min() - box.Max(); 
     68        mPosition = box.Max() - mDirection; 
    6869 
    6970        Precompute(); 
    … …  
    152153 
    153154 
     155void Camera::SetupCameraView() 
     156{ 
     157        glLoadIdentity(); 
     158        gluLookAt(mPosition.x, mPosition.y, mPosition.z, 
     159                  mPosition.x + mDirection.x, mPosition.y + mDirection.y, mPosition.z + mDirection.z,  
     160                          mUp.x, mUp.y, mUp.z); 
     161 
     162        //std::cout << "dir: " << mDirection << " pos: " << mPosition << " up: " << mUp << std::endl; 
    154163} 
    155164 
     165 
     166} 
     167 

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

    r2755 r2756  
    4949        inline float GetAspect() const { return (float) mWidth / mHeight; } 
    5050 
     51        void SetupCameraView(); 
    5152        void GetProjectionMatrix(Matrix4x4 &mat); 
    5253        void GetModelViewMatrix(Matrix4x4 &mat); 

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

    r2755 r2756  
    11#include "Geometry.h" 
    22#include "Triangle3.h" 
     3#include "glInterface.h" 
    34 
    45 
    … …  
    67{ 
    78 
    8 Geometry::Geometry(const TriangleContainer &triangles) 
    9 {} 
    10  
    11  
    12 SceneEntity::SceneEntity(Geometry *geometry,  
    13                                                  Matrix4x4 *trafo,  
    14                                                  Material *mat): 
    15 mGeometry(geometry), mTransform(trafo), mMaterial(mat) 
     9Geometry::Geometry(Vector3 *vertices,  
     10                                   Vector3 *normals, 
     11                                   float *texcoords, 
     12                                   int numVertices): 
     13mVertices(vertices),  
     14mNormals(normals),  
     15mTexCoords(texcoords), 
     16mNumVertices(numVertices),  
     17mVboId(-1) 
    1618{ 
     19        Prepare(); 
    1720} 
    1821 
    1922 
    20 void SceneEntity::Render() 
     23void Geometry::Prepare() 
    2124{ 
     25        CalcBoundingBox(); 
     26 
     27        int dataSize = mNumVertices * 6; 
     28 
     29        if (mTexCoords) 
     30                dataSize += mNumVertices * 2; 
     31         
     32        float *data = new float[dataSize]; 
     33 
     34        for (int i = 0; i < mNumVertices; ++ i) 
     35        { 
     36                ((Vector3 *)data)[i] = mVertices[i]; 
     37                ((Vector3 *)data)[i + mNumVertices] = mNormals[i]; 
     38        } 
     39 
     40        if (mTexCoords) 
     41        { 
     42                for (int i = 0; i < mNumVertices * 2; ++ i) 
     43                        data[mNumVertices * 6 + i] = mTexCoords[i]; 
     44        } 
     45 
     46        glGenBuffersARB(1, &mVboId); 
     47         
     48        glBindBufferARB(GL_ARRAY_BUFFER_ARB, mVboId); 
     49 
     50        glVertexPointer(3, GL_FLOAT, 0, (char *)NULL); 
     51        glNormalPointer(GL_FLOAT, 0, (char *)NULL + mNumVertices * sizeof(Vector3)); 
     52 
     53        if (mTexCoords) 
     54        { 
     55                glTexCoordPointer(2, GL_FLOAT, 0, (char *)NULL + 2 * mNumVertices * sizeof(Vector3)); 
     56        } 
     57        glBufferDataARB(GL_ARRAY_BUFFER_ARB,  
     58                            dataSize * sizeof(float),  
     59                            (float *)data,  
     60                                        GL_STATIC_DRAW_ARB); 
     61 
     62        glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0); 
     63 
     64        // data handled by graphics driver from now on 
     65        delete [] data; 
    2266} 
    2367 
    2468 
    25 void SceneEntity::SetGeometry(Geometry *geom) 
     69void Geometry::Render() 
    2670{ 
    27         mGeometry = geom; 
     71        glBindBufferARB(GL_ARRAY_BUFFER_ARB, mVboId); 
     72 
     73        glVertexPointer(3, GL_FLOAT, 0, (char *)NULL);   
     74        glNormalPointer(GL_FLOAT, 0, (char *)NULL + mNumVertices * sizeof(Vector3)); 
     75 
     76        if (mTexCoords) 
     77                glTexCoordPointer(2, GL_FLOAT, 0, (char *)NULL + 2 * mNumVertices * sizeof(Vector3)); 
     78 
     79        // don't render first degenerate index 
     80        glDrawArrays(GL_TRIANGLES, 0, mNumVertices); 
    2881} 
    2982 
    3083 
    31 void SceneEntity::SetTransformation(Matrix4x4 *trafo) 
     84void Geometry::CalcBoundingBox() 
    3285{ 
    33         mTransform = trafo; 
     86        mBoundingBox.Initialize(); 
     87 
     88        for (int i = 0; i < mNumVertices; ++ i) 
     89        { 
     90                mBoundingBox.Include(mVertices[i]); 
     91        } 
    3492} 
    3593 
    3694 
    37 void SceneEntity::SetMaterial(Material *mat) 
    38 { 
    39         mMaterial = mat; 
    40 } 
    41  
    42  
    43 const AxisAlignedBox3& SceneEntity::GetBoundingVolume() 
     95const AxisAlignedBox3& Geometry::GetBoundingBox() const 
    4496{ 
    4597        return mBoundingBox; 
    … …  
    4799 
    48100 
    49 void SceneEntity::SetLastVisited(int lastVisited) 
    50 { 
    51         mLastVisited = lastVisited; 
    52101} 
    53  
    54  
    55 int SceneEntity::GetLastVisited() const 
    56 { 
    57         return mLastVisited; 
    58 } 
    59  
    60  
    61 } 

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

    r2755 r2756  
    1010{ 
    1111 
    12 class Material; 
    13  
    14  
    15  
    1612/** Represents drawable geometry consisting of triangles 
    1713*/ 
    … …  
    1915{ 
    2016public: 
    21         /** Constructor taking a triangle container. 
     17        /** Constructor taking an array of triangles. 
    2218        */ 
    23         Geometry(const TriangleContainer &triangles); 
     19        Geometry(Vector3 *vertices, Vector3 *normals, float *texcoords, int numVertices); 
     20        /** Render the geometry 
     21        */ 
     22        void Render(); 
    2423 
    25         int CountTriangles() const { return (int)mTriangles.size(); } 
     24        int CountTriangles() const { return mNumVertices / 3; } 
    2625 
     26        inline bool HasTexture() const { return mTexCoords != NULL; } 
     27        const AxisAlignedBox3& GetBoundingBox() const; 
    2728 
    2829protected: 
    2930 
     31        void CalcBoundingBox(); 
     32        /** Prepare vbos for rendering 
     33        */ 
     34        void Prepare(); 
     35 
     36 
     37        ////////// 
     38 
     39        unsigned int mVboId; 
     40 
     41        Vector3 *mVertices; 
     42 
     43        Vector3 *mNormals; 
     44 
     45        float *mTexCoords; 
     46 
     47        int mNumVertices; 
     48 
    3049        AxisAlignedBox3 mBoundingBox; 
    31         TriangleContainer mTriangles; 
    3250}; 
    3351 
    34  
    35 /** Class representing a scene entity. 
    36     A scene entity basicly consists of geometry, transformation, and a material 
    37 */ 
    38 class SceneEntity 
    39 { 
    40 public: 
    41  
    42         /** Create scene entity. 
    43         */ 
    44         SceneEntity(Geometry *geometry, Matrix4x4 *trafo, Material *mat); 
    45         /** Renders this geometry. 
    46         */ 
    47         void Render();   
    48         /** Set pointer to the geometry 
    49         */ 
    50         void SetGeometry(Geometry *geom); 
    51         /** See set 
    52         */ 
    53         Geometry *GetGeometry() const { return mGeometry; } 
    54         /** Set pointer to the geometry 
    55         */ 
    56         void SetTransformation(Matrix4x4 *trafo); 
    57         /** Set pointer to the material 
    58         */ 
    59         void SetMaterial(Material *mat); 
    60         /** Returns the transformed bounding box. 
    61         */ 
    62         const AxisAlignedBox3& GetBoundingVolume(); 
    63         /** set frame where we last visitied this node 
    64         */ 
    65         void SetLastVisited(int lastVisited); 
    66         /** returns frame where we last visited this node 
    67         */ 
    68         int GetLastVisited() const; 
    69  
    70  
    71 protected: 
    72  
    73         /// transform matrix  
    74         Matrix4x4 *mTransform; 
    75         Geometry *mGeometry; 
    76         Material *mMaterial; 
    77  
    78         AxisAlignedBox3 mBoundingBox; 
    79          
    80         int mLastVisited; 
    81 }; 
    8252 
    8353} 

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

    r2755 r2756  
    11#include "common.h" 
    22#include "Material.h" 
     3#include "Texture.h" 
     4#include "glInterface.h" 
     5 
    36 
    47namespace CHCDemo 
    58{ 
    69 
    7 RgbColor RandomColor(const float a, const float b) 
     10RgbColor RandomColor(float a, float b) 
    811{ 
    912        return RgbColor(a + Random(b), a + Random(b), a + Random(b)); 
    … …  
    1114 
    1215 
    13   
    14 Material::Material(): mId(0) 
    15 {} 
    16    
     16void Material::InitMaterial() 
     17{ 
     18        mTexture = NULL; 
    1719 
    18 Material::Material(const int id): mId(id) 
    19 { 
     20        mAmbientColor = RgbColor(0, 0, 0); 
     21        mDiffuseColor = RgbColor(1, 1, 1); 
     22        mSpecularColor = RgbColor(0, 0, 0); 
    2023} 
    2124 
    2225 
    23 Material::Material(const RgbColor &color):mDiffuseColor(color), 
     26Material::Material(): mId(0) 
     27{ 
     28        InitMaterial(); 
     29} 
     30 
     31 
     32Material::Material(int id):  
     33mId(id) 
     34{ 
     35        InitMaterial(); 
     36} 
     37 
     38 
     39Material::Material(const RgbColor &color): 
     40mDiffuseColor(color), 
    2441mAmbientColor(color), 
    25 mSpecularColor(0,0,0), mId(0) 
     42mSpecularColor(0, 0, 0),  
     43mId(0), 
     44mTexture(NULL) 
    2645{ 
    2746} 
    … …  
    4564} 
    4665 
     66 
     67void Material::Render() 
     68{ 
     69        if (mTexture) 
     70                mTexture->Bind(); 
     71        else 
     72                glBindTexture(GL_TEXTURE_2D, 0); 
     73 
     74        glMaterialfv(GL_FRONT, GL_AMBIENT, (float *)&mAmbientColor.r); 
     75        glMaterialfv(GL_FRONT, GL_DIFFUSE, (float *)&mDiffuseColor.r); 
     76        glMaterialfv(GL_FRONT, GL_SPECULAR, (float *)&mSpecularColor.r); 
    4777} 
     78 
     79 
     80} 

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

    r2755 r2756  
    66{ 
    77 
     8class Texture; 
    89 
    910class RgbColor  
    … …  
    5455  Material(); 
    5556   
    56   Material(const int id); 
     57  Material(int id); 
    5758 
    5859  Material(const RgbColor &color); 
    … …  
    6364  friend Material RandomMaterial(); 
    6465 
     66  Texture *GetTexture() const { return mTexture; } 
     67 
     68  void SetTexture(Texture *texture) { mTexture = texture; } 
     69  /** Renders this material. 
     70  */ 
     71  void Render(); 
     72 
    6573protected: 
    6674 
    67         // unique material id 
     75        /** Initialize the material with default values 
     76        */ 
     77        void InitMaterial(); 
     78 
     79        /// unique material id 
    6880        int mId; 
     81        /// the assciated texture 
     82        Texture *mTexture; 
    6983}; 
    7084 

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

    r2751 r2756  
    88{ 
    99 
    10  
    1110class Vector3; 
    12  
    1311 
    1412 

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

    r2753 r2756  
    77 
    88 
     9namespace CHCDemo 
     10{ 
     11 
    912// Forward-declare some other classes. 
    1013class Matrix4x4; 
    1114 
    12  
    13 namespace CHCDemo 
    14 { 
    1515 
    1616/** Vector class. 

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

    r2755 r2756  
    4141                                Name="VCCLCompilerTool" 
    4242                                Optimization="0" 
    43                                 AdditionalIncludeDirectories="GL" 
     43                                AdditionalIncludeDirectories="Devil/include;GL" 
    4444                                PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE" 
    4545                                MinimalRebuild="true" 
    … …  
    6363                        <Tool 
    6464                                Name="VCLinkerTool" 
    65                                 AdditionalDependencies="glut32.lib glew32s.lib glew32.lib" 
     65                                AdditionalDependencies="glut32.lib glew32s.lib glew32.lib DevIL.lib ILUT.lib" 
    6666                                LinkIncremental="2" 
    67                                 AdditionalLibraryDirectories="GL" 
     67                                AdditionalLibraryDirectories="GL;Devil/lib" 
    6868                                GenerateDebugInformation="true" 
    6969                                SubSystem="1" 
    … …  
    126126                                OmitFramePointers="true" 
    127127                                EnableFiberSafeOptimizations="true" 
    128                                 AdditionalIncludeDirectories="GL" 
     128                                AdditionalIncludeDirectories="GL;Devil/include" 
    129129                                PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE" 
    130130                                RuntimeLibrary="2" 
    … …  
    147147                        <Tool 
    148148                                Name="VCLinkerTool" 
    149                                 AdditionalDependencies="glut32.lib glew32s.lib glew32.lib" 
     149                                AdditionalDependencies="glut32.lib glew32s.lib glew32.lib DevIL.lib ILUT.lib" 
    150150                                LinkIncremental="1" 
    151                                 AdditionalLibraryDirectories="GL" 
    152                                 GenerateDebugInformation="true" 
     151                                AdditionalLibraryDirectories="GL;Devil/lib" 
     152                                GenerateDebugInformation="false" 
    153153                                SubSystem="1" 
    154154                                OptimizeReferences="2" 
    … …  
    186186        <Files> 
    187187                <Filter 
    188                         Name="Source Files" 
    189                         Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx" 
    190                         UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}" 
    191                         > 
    192                         <File 
    193                                 RelativePath=".\Bvh.cpp" 
    194                                 > 
    195                         </File> 
    196                         <File 
    197                                 RelativePath=".\Camera.cpp" 
    198                                 > 
    199                         </File> 
    200                         <File 
    201                                 RelativePath=".\chcdemo.cpp" 
    202                                 > 
    203                         </File> 
    204                         <File 
    205                                 RelativePath=".\Geometry.cpp" 
    206                                 > 
    207                         </File> 
    208                         <File 
    209                                 RelativePath=".\Material.cpp" 
    210                                 > 
    211                         </File> 
    212                         <File 
    213                                 RelativePath=".\OcclusionQuery.cpp" 
    214                                 > 
    215                         </File> 
    216                 </Filter> 
    217                 <Filter 
    218                         Name="Header Files" 
    219                         Filter="h;hpp;hxx;hm;inl;inc;xsd" 
    220                         UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}" 
    221                         > 
    222                         <File 
    223                                 RelativePath=".\Bvh.h" 
    224                                 > 
    225                         </File> 
    226                         <File 
    227                                 RelativePath=".\Camera.h" 
    228                                 > 
    229                         </File> 
    230                         <File 
    231                                 RelativePath=".\Geometry.h" 
    232                                 > 
    233                         </File> 
    234                         <File 
    235                                 RelativePath=".\Material.h" 
    236                                 > 
    237                         </File> 
    238                         <File 
    239                                 RelativePath=".\OcclusionQuery.h" 
    240                                 > 
    241                         </File> 
    242                 </Filter> 
    243                 <Filter 
    244188                        Name="utils" 
    245189                        > 
    … …  
    324268                        Name="traversal" 
    325269                        > 
    326                         <File 
    327                                 RelativePath=".\CHCPlusPlusTraverser.cpp" 
    328                                 > 
    329                         </File> 
    330                         <File 
    331                                 RelativePath=".\CHCPlusPlusTraverser.h" 
    332                                 > 
    333                         </File> 
    334                         <File 
    335                                 RelativePath=".\CHCTraverser.cpp" 
    336                                 > 
    337                         </File> 
    338                         <File 
    339                                 RelativePath=".\CHCTraverser.h" 
    340                                 > 
    341                         </File> 
    342                         <File 
    343                                 RelativePath=".\FrustumCullingTraverser.cpp" 
    344                                 > 
    345                         </File> 
    346                         <File 
    347                                 RelativePath=".\FrustumCullingTraverser.h" 
    348                                 > 
    349                         </File> 
    350                         <File 
    351                                 RelativePath=".\RenderTraverser.cpp" 
    352                                 > 
    353                         </File> 
    354                         <File 
    355                                 RelativePath=".\RenderTraverser.h" 
    356                                 > 
    357                         </File> 
    358                         <File 
    359                                 RelativePath=".\StopAndWaitTraverser.cpp" 
    360                                 > 
    361                         </File> 
    362                         <File 
    363                                 RelativePath=".\StopAndWaitTraverser.h" 
    364                                 > 
    365                         </File> 
     270                        <Filter 
     271                                Name="Header Files" 
     272                                > 
     273                                <File 
     274                                        RelativePath=".\CHCPlusPlusTraverser.h" 
     275                                        > 
     276                                </File> 
     277                                <File 
     278                                        RelativePath=".\CHCTraverser.h" 
     279                                        > 
     280                                </File> 
     281                                <File 
     282                                        RelativePath=".\FrustumCullingTraverser.h" 
     283                                        > 
     284                                </File> 
     285                                <File 
     286                                        RelativePath=".\RenderTraverser.h" 
     287                                        > 
     288                                </File> 
     289                                <File 
     290                                        RelativePath=".\StopAndWaitTraverser.h" 
     291                                        > 
     292                                </File> 
     293                        </Filter> 
     294                        <Filter 
     295                                Name="Source Files" 
     296                                > 
     297                                <File 
     298                                        RelativePath=".\CHCPlusPlusTraverser.cpp" 
     299                                        > 
     300                                </File> 
     301                                <File 
     302                                        RelativePath=".\CHCTraverser.cpp" 
     303                                        > 
     304                                </File> 
     305                                <File 
     306                                        RelativePath=".\FrustumCullingTraverser.cpp" 
     307                                        > 
     308                                </File> 
     309                                <File 
     310                                        RelativePath=".\RenderTraverser.cpp" 
     311                                        > 
     312                                </File> 
     313                                <File 
     314                                        RelativePath=".\StopAndWaitTraverser.cpp" 
     315                                        > 
     316                                </File> 
     317                        </Filter> 
     318                </Filter> 
     319                <Filter 
     320                        Name="render" 
     321                        > 
     322                        <Filter 
     323                                Name="Header Files" 
     324                                Filter="h;hpp;hxx;hm;inl;inc;xsd" 
     325                                UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}" 
     326                                > 
     327                                <File 
     328                                        RelativePath=".\Bvh.h" 
     329                                        > 
     330                                </File> 
     331                                <File 
     332                                        RelativePath=".\Camera.h" 
     333                                        > 
     334                                </File> 
     335                                <File 
     336                                        RelativePath=".\Geometry.h" 
     337                                        > 
     338                                </File> 
     339                                <File 
     340                                        RelativePath=".\Material.h" 
     341                                        > 
     342                                </File> 
     343                                <File 
     344                                        RelativePath=".\OcclusionQuery.h" 
     345                                        > 
     346                                </File> 
     347                                <File 
     348                                        RelativePath=".\SceneEntity.h" 
     349                                        > 
     350                                </File> 
     351                                <File 
     352                                        RelativePath=".\Texture.h" 
     353                                        > 
     354                                </File> 
     355                        </Filter> 
     356                        <Filter 
     357                                Name="Source Files" 
     358                                Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx" 
     359                                UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}" 
     360                                > 
     361                                <File 
     362                                        RelativePath=".\Bvh.cpp" 
     363                                        > 
     364                                </File> 
     365                                <File 
     366                                        RelativePath=".\Camera.cpp" 
     367                                        > 
     368                                </File> 
     369                                <File 
     370                                        RelativePath=".\chcdemo.cpp" 
     371                                        > 
     372                                </File> 
     373                                <File 
     374                                        RelativePath=".\Geometry.cpp" 
     375                                        > 
     376                                </File> 
     377                                <File 
     378                                        RelativePath=".\Material.cpp" 
     379                                        > 
     380                                </File> 
     381                                <File 
     382                                        RelativePath=".\OcclusionQuery.cpp" 
     383                                        > 
     384                                </File> 
     385                                <File 
     386                                        RelativePath=".\SceneEntity.cpp" 
     387                                        > 
     388                                </File> 
     389                                <File 
     390                                        RelativePath=".\Texture.cpp" 
     391                                        > 
     392                                </File> 
     393                        </Filter> 
    366394                </Filter> 
    367395                <File 

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

    r2753 r2756  
    11// occquery.cpp : Defines the entry point for the console application. 
    22// 
    3 #if TOIMPLEMENT 
    4  
    53#include <math.h> 
    64#include <time.h> 
     5#include "common.h" 
    76#include "glInterface.h" 
    87#include "RenderTraverser.h" 
    9  
    10  
    11  
    12 bool arbQuerySupport = false; 
    13 bool nvQuerySupport = false; 
    14  
    15 double nearDist = 0.1; // eye near plane distance 
     8#include "SceneEntity.h" 
     9#include "Vector3.h" 
     10#include "Matrix4x4.h" 
     11#include "BinaryLoader.h" 
     12#include "Bvh.h" 
     13#include "Camera.h" 
     14#include "Geometry.h" 
     15 
     16 
     17using namespace std; 
     18using namespace CHCDemo; 
     19 
     20 
     21 
     22/// the renderable scene geometry 
     23SceneEntityContainer sceneEntities; 
     24// traverses and renders the hierarchy 
     25RenderTraverser *traverser; 
     26/// the hierarchy 
     27Bvh *bvh; 
     28/// the scene camera 
     29Camera *camera; 
     30/// the scene bounding box 
     31AxisAlignedBox3 sceneBox; 
     32 
     33// eye near plane distance 
     34float nearDist = 0.1f;  
    1635int winWidth, winHeight; 
    17 int objectType = Geometry::TEAPOT; 
    18 int nextObjectType = objectType; 
    1936 
    2037float visZoomFactor = 1.5f; 
    … …  
    2643bool showCreateParams = false; 
    2744 
    28 // traverses and renders the hierarchy 
    29 RenderTraverser traverser; 
    30  
    31 Vector3 eyePos = {0.0, 0.0, 3.0};  // eye position  
    32 Vector3 viewDir = {0.0, 0.0, -1.0};  // eye view dir  
    33 Vector3 lightDir = {0.0, 0.0, 1.0};  // light dir  
     45 
     46Vector3 eyePos = Vector3(0.0f, 0.0f, 3.0f);    // eye position  
     47Vector3 viewDir = Vector3(0.0f, 0.0f, -1.0f);  // eye view dir  
     48Vector3 lightDir = Vector3(0.0f, 0.0f, 1.0f);  // light dir  
    3449 
    3550Matrix4x4 eyeView; // eye view matrix 
    … …  
    4156//mouse navigation state 
    4257int xEyeBegin, yEyeBegin, yMotionBegin, verticalMotionBegin, horizontalMotionBegin = 0; 
    43 int renderMode = RenderTraverser::RENDER_COHERENT; 
     58//int renderMode = RenderTraverser::RENDER_COHERENT; 
    4459 
    4560// relative size of an object 
    … …  
    5166 
    5267// this defines the volume where objects can be drawn 
    53 Vector3 minTranslation = {-2.5f, -2.5f, -3.0f}; 
    54 Vector3 maxTranslation = {2.5f, 2.5f, -3.0 - zLength}; 
     68Vector3 minTranslation(-2.5f, -2.5f, -3.0f); 
     69Vector3 maxTranslation(2.5f, 2.5f, -3.0 - zLength); 
    5570 
    5671const float minAngle = 0; 
    … …  
    6277int renderTimesValid = 0; 
    6378 
    64 typedef vector<Geometry *> GeometryList; 
    65 GeometryList geometry; 
    66  
    6779bool useOptimization = true; 
    68 bool useArbQueries = false; 
     80 
    6981 
    7082Vector3 amb[2]; 
    … …  
    7284Vector3 spec[2]; 
    7385 
     86void InitExtensions(void); 
     87void DisplayVisualization(); 
     88void InitGLstate(void); 
     89void CleanUp(void); 
     90void SetupEyeView(void); 
     91void UpdateEyeMtx(void); 
     92 
     93 
    7494void begin2D(void); 
    7595void end2D(void); 
    76 void output(const int x, const int y, const char *string); 
    77 void initGLstate(void); 
    78 void keyboard(const unsigned char c, const int x, const int y); 
     96void output(int x, int y, const char *string); 
     97void keyboard(const unsigned char c, int x, int y); 
    7998void drawHelpMessage(void); 
    8099void drawStatistics(void); 
    81100void display(void); 
    82 void special(const int c, const int x, const int y); 
    83 void reshape(const int w, const int h); 
     101void special(int c, int x, int y); 
     102void reshape(int w, int h); 
    84103void mouse(int button, int state, int x, int y); 
    85 void initExtensions(void); 
    86104void leftMotion(int x, int y); 
    87 //void rightMotion(int x, int y); 
    88105void middleMotion(int x, int y); 
    89106void drawEyeView(void); 
    90 void setupEyeView(void); 
    91107void setupVisView(void); 
    92 void updateEyeMtx(void); 
    93108long calcRenderTime(void); 
    94109void resetTimer(void); 
    95 void cleanUp(void); 
    96 void calcDecimalPoint(string &str, int d); 
    97  
    98 HierarchyNode* generateHierarchy(int numObjects); 
    99 Geometry *generateGeometry(Vector3 translateRatio, float xRotRatio,  
    100                                                    float yRotRatio, float zRotRatio, int materialIdx); 
    101 void displayVisualization(); 
    102  
    103 void deleteGeometry(); 
    104  
    105 #endif 
     110void calcDecimalPoint(std::string &str, int d); 
     111 
     112 
     113 
     114void SetupProjection(int w, int h, float angle, const AxisAlignedBox3 &sceneBox) 
     115{ 
     116        glViewport(0, 0, w, h); 
     117        glMatrixMode(GL_PROJECTION); 
     118        glLoadIdentity(); 
     119 
     120        gluPerspective(angle, 1.0, 1.0f, 2.0 * Magnitude(sceneBox.Diagonal())); 
     121        glMatrixMode(GL_MODELVIEW); 
     122} 
     123 
    106124 
    107125int main(int argc, char* argv[]) 
    108126{ 
    109 #if 0 
    110         glutInitWindowSize(800,600); 
    111         glutInit(&argc,argv); 
     127        glutInitWindowSize(800, 600); 
     128        glutInit(&argc, argv); 
    112129        glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH); 
    113          
     130 
    114131        glutCreateWindow("Coherent Hierarchical Culling"); 
    115132 
    … …  
    120137        glutMouseFunc(mouse); 
    121138        glutIdleFunc(display); 
    122         initExtensions(); 
    123         initGLstate(); 
    124  
    125         leftMotion(0,0); 
    126         middleMotion(0,0); 
    127          
    128         HierarchyNode *hierarchy = generateHierarchy(numObjects); 
    129         traverser.SetHierarchy(hierarchy); 
     139         
     140        InitExtensions(); 
     141        InitGLstate(); 
     142 
     143        leftMotion(0, 0); 
     144        middleMotion(0, 0); 
     145 
     146        BinaryLoader loader; 
     147 
     148        const string filename("house_test.dem"); 
     149        //const string filename("city.dem"); 
     150 
     151        camera = new Camera(800, 600); 
     152 
     153        if (loader.Load(filename, sceneEntities)) 
     154                cout << "scene " << filename << " loaded" << endl; 
     155        else 
     156                cerr << "loading scene " << filename << " failed" << endl; 
     157 
     158        sceneBox.Initialize(); 
     159 
     160        SceneEntityContainer::const_iterator it, it_end = sceneEntities.end(); 
     161 
     162        for (it = sceneEntities.begin(); it != it_end; ++ it) 
     163                sceneBox.Include((*it)->GetBoundingBox()); 
     164 
     165        Debug << "scene box: " << sceneBox << endl; 
     166 
     167        SetupProjection(800, 600, 60, sceneBox); 
     168        camera->LookAtBox(sceneBox); 
     169        //camera->LookInBox(sceneBox); 
     170        //camera->SetPosition(Vector3(0, 0, -3)); 
     171        //camera->SetDirection(Vector3(0, 0, 1)); 
    130172 
    131173        /// initialise rendertime array 
    … …  
    136178 
    137179        // clean up 
    138         cleanUp(); 
    139 #endif 
     180        CleanUp(); 
     181 
    140182        return 0; 
    141183} 
    142184 
    143 #if 0 
    144 void initGLstate(void)  
    145 { 
    146         glClearColor(0.6, 0.6, 0.8, 1.0); 
     185 
     186void InitGLstate(void)  
     187{ 
     188        glClearColor(0.0f, 1.0f, 0.0f, 0.0); 
    147189         
    148190        glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 
    149191        glPixelStorei(GL_PACK_ALIGNMENT,1);  
    150192         
    151         glDepthRange(0.0, 1.0); 
    152         glClearDepth(1.0); 
    153193        glDepthFunc(GL_LESS); 
    154194 
    155195        glEnable(GL_LIGHTING); 
    156196        glEnable(GL_LIGHT0); 
    157  
     197        //glDisable(GL_LIGHTING); 
     198 
     199        glColor3f(1.0f, 0.0f, 0.0f); 
    158200        glShadeModel(GL_SMOOTH); 
    159201         
    160         GLfloat ambient[] = { 0.0, 0.0, 0.0, 1.0 }; 
    161         GLfloat diffuse[] = { 1.0, 1.0, 1.0, 1.0 }; 
    162         GLfloat specular[] = { 1.0, 1.0, 1.0, 1.0 }; 
    163         GLfloat position[] = { 0.0, 3.0, 3.0, 0.0 }; 
     202        GLfloat ambient[] = {0.5, 0.5, 0.5, 1.0}; 
     203        GLfloat diffuse[] = {1.0, 1.0, 1.0, 1.0}; 
     204        GLfloat specular[] = {1.0, 1.0, 1.0, 1.0}; 
     205        GLfloat position[] = {0.0, 3.0, 3.0, 0.0}; 
    164206     
    165         GLfloat lmodel_ambient[] = { 0.2, 0.2, 0.2, 1.0 }; 
    166         GLfloat local_view[] = { 0.0 }; 
     207        GLfloat lmodel_ambient[] = {0.2, 0.2, 0.2, 1.0}; 
     208        GLfloat local_view[] = {0.0}; 
    167209 
    168210        glLightfv(GL_LIGHT0, GL_AMBIENT, ambient); 
    … …  
    179221        glCullFace(GL_BACK); 
    180222        glEnable(GL_CULL_FACE); 
    181          
    182         glClearColor(0.2, 0.2, 0.8, 0.0); 
    183  
    184         setupVisView(); 
     223        //glDisable(GL_CULL_FACE); 
     224         
     225        GLfloat ambientColor[] = {0.5, 0.5, 0.5, 1.0}; 
     226        GLfloat diffuseColor[] = {1.0, 0.0, 0.0, 1.0}; 
     227        GLfloat specularColor[] = {1.0, 1.0, 1.0, 1.0}; 
     228 
     229        glMaterialfv(GL_FRONT, GL_AMBIENT, ambientColor); 
     230        glMaterialfv(GL_FRONT, GL_DIFFUSE, diffuseColor); 
     231        glMaterialfv(GL_FRONT, GL_SPECULAR, specularColor); 
     232 
     233        glColor3f(1.0f, 0.0f, 0.0f); 
     234        //setupVisView(); 
    185235} 
    186236 
    … …  
    226276        }; 
    227277         
    228         int i; 
     278         
    229279        int x = 40, y = 42; 
     280 
    230281        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 
    231282        glEnable(GL_BLEND); 
    232         glColor4f(0.0,1.0,0.0,0.2);  // 20% green.  
     283        glColor4f(0.0f, 1.0f , 0.0f, 0.2f);  // 20% green.  
    233284 
    234285        // Drawn clockwise because the flipped Y axis flips CCW and CW.  
    … …  
    237288        glDisable(GL_BLEND); 
    238289         
    239  
    240         glColor3f(1.0,1.0,1.0); 
    241         for(i = 0; message[i] != 0; i++) { 
    242                 if(message[i][0] == '\0') { 
     290        glColor3f(1.0f, 1.0f, 1.0f); 
     291         
     292        for(int i = 0; message[i] != 0; i++)  
     293        { 
     294                if(message[i][0] == '\0')  
     295                { 
    243296                        y += 7; 
    244                 } else { 
    245                         output(x,y,message[i]); 
     297                }  
     298                else  
     299                { 
     300                        output(x, y, message[i]); 
    246301                        y += 14; 
    247302                } 
    … …  
    250305} 
    251306 
    252 // generates a teapot, all parameters between zero and one 
    253 Geometry *generateGeometry(Vector3 translationRatio, float xRotRatio,  
    254                                                    float yRotRatio, float zRotRatio, int materialIdx) 
    255 { 
    256         float xRot = minAngle + xRotRatio * (maxAngle - minAngle); 
    257         float yRot = minAngle + yRotRatio * (maxAngle - minAngle); 
    258         float zRot = minAngle + zRotRatio * (maxAngle - minAngle); 
    259  
    260         Vector3 translation; 
    261         translation[0] = minTranslation[0] + translationRatio[0] * (maxTranslation[0] - minTranslation[0]); 
    262         translation[1] = minTranslation[1] + translationRatio[1] * (maxTranslation[1] - minTranslation[1]); 
    263         translation[2] = minTranslation[2] + translationRatio[2] * (maxTranslation[2] - minTranslation[2]); 
    264  
    265         Geometry *result = new Geometry(translation, xRot, yRot, zRot, objectSize, objectType); 
    266  
    267         result->SetAmbientColor(amb[materialIdx][0], amb[materialIdx][1], amb[materialIdx][2]); 
    268         result->SetDiffuseColor(dif[materialIdx][0], dif[materialIdx][1], dif[materialIdx][2]); 
    269         result->SetSpecularColor(spec[materialIdx][0], spec[materialIdx][1], spec[materialIdx][2]); 
    270  
    271         return result; 
    272 } 
    273  
    274 // generates a the scene hierarchy with random values 
    275 HierarchyNode* generateHierarchy(int numObjects) 
    276 { 
    277     HierarchyNode *hierarchy = new HierarchyNode(); 
    278  
    279         // initialise materials 
    280         copyVector3Values(amb[0], 0.0215, 0.1745, 0.0215); 
    281         copyVector3Values(dif[0], 0.727811, 0.633, 0.6); 
    282         copyVector3Values(spec[0], 0.633, 0.727811, 0.633); 
    283  
    284         copyVector3Values(amb[1], 0.1745, 0.01175, 0.01175); 
    285         copyVector3Values(dif[1], 0.61424, 0.04136, 0.04136); 
    286         copyVector3Values(spec[1], 0.727811, 0.626959, 0.626959); 
    287  
    288         srand (time (0)); 
    289          
    290         printf("generating geometry with random position and orientation ... "); 
    291  
    292         for(int i=0; i < numObjects; i++) 
    293         { 
    294                 float xRotRatio = rand() / (float) RAND_MAX; 
    295                 float yRotRatio = rand() / (float) RAND_MAX; 
    296                 float zRotRatio = rand() / (float) RAND_MAX; 
    297  
    298                 Vector3 translationRatio = {rand() / (float) RAND_MAX,  
    299                                                                         rand() / (float) RAND_MAX,  
    300                                                                         rand() / (float) RAND_MAX}; 
    301  
    302                 int materialIdx = int(2 * rand() / (float) RAND_MAX); 
    303                          
    304                 Geometry *geo = generateGeometry(translationRatio, xRotRatio,  
    305                                                                              yRotRatio, zRotRatio, materialIdx); 
    306                 hierarchy->AddGeometry(geo); 
    307  
    308                 // put into global geometry list for later deletion 
    309                 geometry.push_back(geo); 
    310         } 
    311  
    312         printf("finished\n"); 
    313         printf("generating new kd-tree hierarchy ... "); 
    314         HierarchyNode::InitKdTree(hierarchy); 
    315         hierarchy->GenerateKdTree(); 
    316         printf("finished\n"); 
    317  
    318         return hierarchy; 
    319 } 
    320  
    321  
    322 void updateEyeMtx(void)  
    323 { 
    324         const Vector3 up = {0.0, 1.0, 0.0}; 
     307 
     308void UpdateEyeMtx(void)  
     309{ 
     310        /*const Vector3 up(0.0, 1.0, 0.0); 
    325311 
    326312        look(eyeView, eyePos, viewDir, up); 
    327313        mult(eyeProjView, eyeProjection, eyeView); //eyeProjView = eyeProjection*eyeView 
    328314        invert(invEyeProjView, eyeProjView); //invert matrix 
    329 } 
    330  
    331  
    332 void setupEyeView(void) 
    333 { 
    334         glMatrixMode(GL_PROJECTION); 
    335         glLoadMatrixd(eyeProjection); 
    336  
     315        */ 
     316} 
     317 
     318 
     319void SetupEyeView(void) 
     320{ 
     321        SetupProjection(800,600,60,sceneBox); 
    337322        glMatrixMode(GL_MODELVIEW); 
    338         glLoadMatrixd(eyeView); 
     323        camera->SetupCameraView(); 
     324 
     325/*      glMatrixMode(GL_PROJECTION); 
     326        glLoadMatrixf((float *)eyeProjection.x); 
     327 
     328        glMatrixMode(GL_MODELVIEW); 
     329        glLoadMatrixf((float *)eyeView.x); 
     330        */ 
    339331} 
    340332 
    … …  
    353345        char msg8[100]; 
    354346 
     347/* 
    355348        sprintf_s(msg2, "Traversed: %4d, frustum culled: %4d, query culled: %4d (of %d nodes)", 
    356349                        traverser.GetNumTraversedNodes(), traverser.GetNumFrustumCulledNodes(), 
    357350                        traverser.GetNumQueryCulledNodes(),  
    358351                        traverser.GetHierarchy()->GetNumHierarchyNodes()); 
    359          
     352 
    360353        char *optstr[2] = {"", ", using optimization"}; 
    361354        char *querystr[2] = {"NV", "ARB"}; 
    … …  
    384377        sprintf_s(msg7, "Next object type: %s", objectTypeStr[nextObjectType]); 
    385378        sprintf_s(msg8, "Next object size: %3.3f", objectSize); 
     379*/ 
    386380 
    387381        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 
    388382 
    389         updateEyeMtx(); // bring eye modelview matrix up-to-date 
    390         setupEyeView(); 
    391  
     383        // bring eye modelview matrix up-to-date 
     384        UpdateEyeMtx();  
     385        SetupEyeView(); 
     386 
     387        glEnableClientState(GL_VERTEX_ARRAY); 
     388        glEnableClientState(GL_NORMAL_ARRAY); 
     389 
     390        bool usesTextures = false; 
     391 
     392        SceneEntityContainer::const_iterator sit, sit_end = sceneEntities.end(); 
     393 
     394        for (sit = sceneEntities.begin(); sit != sit_end; ++ sit) 
     395        { 
     396                SceneEntity *entity = *sit; 
     397 
     398                if (!usesTextures && entity->GetGeometry()->HasTexture()) 
     399                { 
     400                        glEnable(GL_TEXTURE_2D); 
     401                        glEnableClientState(GL_TEXTURE_COORD_ARRAY); 
     402                        usesTextures = true; 
     403                } 
     404                else if (usesTextures && !entity->GetGeometry()->HasTexture()) 
     405                { 
     406                        glDisable(GL_TEXTURE_2D); 
     407                        glDisableClientState(GL_TEXTURE_COORD_ARRAY); 
     408                        usesTextures = false; 
     409                } 
     410 
     411                entity->Render(); 
     412        } 
     413 
     414        glDisableClientState(GL_VERTEX_ARRAY); 
     415        glDisableClientState(GL_NORMAL_ARRAY); 
     416 
     417        glDisable(GL_TEXTURE_2D); 
     418        glDisableClientState(GL_TEXTURE_COORD_ARRAY); 
     419 
     420        /* 
    392421        traverser.SetViewpoint(eyePos); 
    393422        traverser.SetProjViewMatrix(eyeProjView); 
    394423        traverser.Render(renderMode); 
    395  
    396424        // cycle through rendertime array 
    397425        renderTimes[renderTimesIdx] = traverser.GetRenderTime(); 
    … …  
    402430 
    403431        if(visMode) 
    404         { 
    405432                displayVisualization(); 
    406         } 
     433        */ 
     434 
    407435         
    408436        begin2D(); 
     437         
    409438        if(showHelp) 
     439        {        
    410440                drawHelpMessage(); 
     441        } 
    411442        else 
    412443        { 
    413444                glColor3f(1.0,1.0,1.0); 
    414                 output(10,winHeight-10, msg[renderMode]); 
     445                //output(10, winHeight-10, msg[renderMode]); 
    415446 
    416447                if(showStatistics) 
    … …  
    428459                } 
    429460        } 
     461 
    430462        end2D(); 
    431463 
    … …  
    437469void keyboard(const unsigned char c, const int x, const int y)  
    438470{ 
    439         int threshold; 
    440         HierarchyNode *hierarchy; 
     471        //int threshold; 
     472        //HierarchyNode *hierarchy; 
    441473 
    442474        switch(c)  
    … …  
    446478                break; 
    447479        case 32: //space 
    448                 renderMode = (renderMode + 1) % RenderTraverser::NUM_RENDERMODES; 
     480         
     481                //      renderMode = (renderMode + 1) % RenderTraverser::NUM_RENDERMODES; 
    449482                 
    450483                resetTimer(); 
    451                 traverser.Render(renderMode);           // render once so stats are updated 
     484                //traverser.Render(renderMode);         // render once so stats are updated 
    452485                break; 
    453486        case 'h': 
    … …  
    458491        case 'V': 
    459492                showBoundingVolumes = !showBoundingVolumes; 
    460                 HierarchyNode::SetRenderBoundingVolume(showBoundingVolumes); 
     493                //HierarchyNode::SetRenderBoundingVolume(showBoundingVolumes); 
    461494                break; 
    462495        case 's': 
    … …  
    465498                break; 
    466499        case '+': 
    467                 threshold = traverser.GetVisibilityThreshold() + 10; 
    468                 traverser.SetVisibilityThreshold(threshold); 
     500                //threshold = traverser.GetVisibilityThreshold() + 10; 
     501                //traverser.SetVisibilityThreshold(threshold); 
    469502                break; 
    470503        case '-': 
    471                 threshold = traverser.GetVisibilityThreshold() - 10; 
    472                 if(threshold < 0) threshold = 0; 
    473  
    474                 traverser.SetVisibilityThreshold(threshold);             
     504                //threshold = traverser.GetVisibilityThreshold() - 10; 
     505                //if(threshold < 0) threshold = 0; 
     506 
     507                //traverser.SetVisibilityThreshold(threshold);           
    475508                break; 
    476509        case '1': 
    … …  
    495528        case 'G': 
    496529                useOptimization = !useOptimization; 
    497                 traverser.SetUseOptimization(useOptimization); 
    498                 break; 
    499         case 'n': 
    500         case 'N': 
    501                 useArbQueries = !useArbQueries; 
    502                 traverser.SetUseArbQueries(useArbQueries); 
    503                 break; 
     530                //traverser.SetUseOptimization(useOptimization); 
     531                break; 
     532                /* 
    504533        case 'c': 
    505534        case 'C':        
    506                  
    507535                hierarchy = traverser.GetHierarchy(); 
    508536                // delete old hierarchy 
    509                 if(hierarchy) delete hierarchy;  
     537                if (hierarchy) delete hierarchy;  
    510538                deleteGeometry(); 
    511539 
    … …  
    522550                resetTimer(); 
    523551                break; 
    524  
     552                */ 
    525553        default: 
    526554                return; 
    … …  
    534562{ 
    535563        // used to avoid vertical motion with the keys 
    536         Vector3 hvec = {viewDir[0], 0, viewDir[2]}; 
     564        Vector3 hvec = Vector3(viewDir[0], 0, viewDir[2]); 
    537565         
    538566        switch(c)  
    … …  
    542570                break; 
    543571        case GLUT_KEY_F2: 
    544                 numNextObjects -= 100; 
    545                 if(numNextObjects < 100) numNextObjects = 100; 
     572                //numNextObjects -= 100; 
     573                //if(numNextObjects < 100) numNextObjects = 100; 
    546574                break; 
    547575        case GLUT_KEY_F3: 
    548         numNextObjects += 100; 
     576       // numNextObjects += 100; 
    549577                break; 
    550578        case GLUT_KEY_F4: 
    … …  
    563591                break; 
    564592        case GLUT_KEY_F8: 
    565                 nextObjectType = (nextObjectType + 1) % Geometry::NUM_OBJECTS; 
     593                //nextObjectType = (nextObjectType + 1) % Geometry::NUM_OBJECTS; 
    566594                break; 
    567595        case GLUT_KEY_LEFT: 
    568                 rotateVectorY(viewDir, 0.2); 
     596        //      rotateVectorY(viewDir, 0.2); 
    569597                break; 
    570598        case GLUT_KEY_RIGHT: 
    571                 rotateVectorY(viewDir, -0.2); 
     599                //rotateVectorY(viewDir, -0.2); 
    572600                break; 
    573601        case GLUT_KEY_UP: 
    574                 linCombVector3(eyePos, eyePos, hvec, 0.6); 
     602        //      linCombVector3(eyePos, eyePos, hvec, 0.6); 
    575603                break; 
    576604        case GLUT_KEY_DOWN: 
    577                 linCombVector3(eyePos, eyePos, hvec, -0.6); 
     605                //linCombVector3(eyePos, eyePos, hvec, -0.6); 
    578606                break; 
    579607        default: 
    … …  
    598626        if(w) winAspectRatio = (double) h / (double) w; 
    599627 
    600         perspectiveDeg(eyeProjection, 60.0, 1.0/winAspectRatio, nearDist, 150.0); 
     628        //perspectiveDeg(eyeProjection, 60.0, 1.0/winAspectRatio, nearDist, 150.0); 
    601629 
    602630        glutPostRedisplay(); 
    … …  
    631659        static double eyeXAngle = 0.0; 
    632660        // not move in the vertical direction 
    633         Vector3 horView = {viewDir[0], 0, viewDir[2]}; 
    634          
    635         eyeXAngle = 0.6 *  PI * (xEyeBegin - x) / 180.0; 
     661        Vector3 horView = Vector3(viewDir[0], 0, viewDir[2]); 
     662         
     663        eyeXAngle = 0.6 *  M_PI * (xEyeBegin - x) / 180.0; 
     664 
     665        /* 
    636666        linCombVector3(eyePos, eyePos, horView, (yMotionBegin - y) * 0.1); 
    637667         
    … …  
    640670        xEyeBegin = x; 
    641671        yMotionBegin = y; 
    642  
     672        */ 
    643673        glutPostRedisplay(); 
    644674} 
    … …  
    649679        // the 90 degree rotated view vector  
    650680        // y zero so we don't move in the vertical 
    651         Vector3 rVec = {viewDir[0], 0, viewDir[2]}; 
    652          
    653         rotateVectorY(rVec, PI / 2.0); 
     681        Vector3 rVec = Vector3(viewDir[0], 0, viewDir[2]); 
     682         
     683        /*rotateVectorY(rVec, PI / 2.0); 
    654684        linCombVector3(eyePos, eyePos, rVec, (horizontalMotionBegin - x) * 0.1); 
    655685         
    … …  
    658688        horizontalMotionBegin = x; 
    659689        verticalMotionBegin = y; 
    660  
     690*/ 
    661691        glutPostRedisplay(); 
    662692} 
    663693 
    664694 
    665 void initExtensions(void)  
     695void InitExtensions(void)  
    666696{ 
    667697        GLenum err = glewInit(); 
     698 
    668699        if (GLEW_OK != err)  
    669700        { 
    … …  
    672703                exit(1); 
    673704        } 
    674  
    675         if (GLEW_ARB_occlusion_query)  
    676                 arbQuerySupport = true; 
    677          
    678         if (GLEW_NV_occlusion_query)  
    679                 nvQuerySupport = true; 
    680          
    681  
    682         if  (!arbQuerySupport && !nvQuerySupport) 
    683         { 
    684                 printf("I require the GL_ARB_occlusion_query or the GL_NV_occlusion_query OpenGL extension to work.\n"); 
     705        if  (!GLEW_ARB_occlusion_query) 
     706        { 
     707                printf("I require the GL_ARB_occlusion_query to work.\n"); 
    685708                exit(1); 
    686709        } 
    … …  
    729752} 
    730753 
    731 // explicitly deletes geometry generated for hierarchy  
    732 // (deleting the hierarchy does not delete the geometry) 
    733 void deleteGeometry() 
    734 { 
    735         for (GeometryList::iterator it = geometry.begin(); it != geometry.end(); it++) 
    736                 if(*it) delete (*it); 
    737          
    738         geometry.clear(); 
    739 } 
    740  
    741754// displays the visualisation of the kd tree node culling 
    742755void displayVisualization() 
    … …  
    753766        glViewport(winWidth / 2, winHeight / 2, winWidth, winHeight); 
    754767        glPushMatrix(); 
    755         glLoadMatrixd(visView); 
     768        glLoadMatrixf((float *)visView.x); 
    756769         
    757770        glClear(GL_DEPTH_BUFFER_BIT); 
    758771 
    759772        // --- visualization of the occlusion culling 
    760         HierarchyNode::SetRenderBoundingVolume(true); 
     773        /*HierarchyNode::SetRenderBoundingVolume(true); 
    761774        traverser.RenderVisualization(); 
    762775        HierarchyNode::SetRenderBoundingVolume(showBoundingVolumes); 
    763  
     776*/ 
    764777        glPopMatrix(); 
    765778        glViewport(0, 0, winWidth, winHeight); 
    766779} 
    767780 
    768 /** 
    769         sets up view matrix in order to get a good position  
     781/** Sets up view matrix in order to get a good position  
    770782        for viewing the kd tree node culling 
    771783*/ 
    772784void setupVisView() 
    773785{ 
    774         const Vector3 up = {0.0, 1.0, 0.0}; 
    775          
    776         Vector3 visPos = {24, 23, -6}; 
     786        const Vector3 up(0.0, 1.0, 0.0); 
     787         
     788        Vector3 visPos(24, 23, -6); 
    777789         
    778790        visPos[0] *= visZoomFactor;  
    … …  
    780792        visPos[2] *= visZoomFactor; 
    781793 
    782         Vector3 visDir = {-1.3,-1,-1}; 
    783          
    784         normalize(visDir); 
    785         look(visView, visPos, visDir, up); 
     794        Vector3 visDir = Vector3(-1.3, -1, -1); 
     795         
     796        //normalize(visDir); 
     797        //look(visView, visPos, visDir, up); 
    786798} 
    787799 
    … …  
    810822 
    811823// cleanup routine after the main loop 
    812 void cleanUp() 
    813 { 
    814         if(traverser.GetHierarchy())  
    815                 delete traverser.GetHierarchy(); 
    816  
    817         deleteGeometry(); 
    818  
    819         Geometry::CleanUp(); 
     824void CleanUp() 
     825{ 
     826        CLEAR_CONTAINER(sceneEntities); 
     827        DEL_PTR(traverser); 
     828 
     829        DEL_PTR(bvh); 
    820830} 
    821831 
    … …  
    846856        } 
    847857} 
    848  
    849 #endif 

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

    r2753 r2756  
    3535 
    3636 
     37 
    3738Real Random(Real max) 
    3839{ 
    … …  
    5758} 
    5859 
    59 void 
    60 Randomize(const unsigned int seed) 
    61 { 
    62   srand(seed); 
     60 
     61void Randomize(const unsigned int seed) 
     62{ 
     63        srand(seed); 
    6364} 
    6465 
    … …  
    299300} 
    300301 
    301  
    302 #if TOIMPLEMENT 
    303  
    304 bool 
    305 CreateDir(char *dir) 
    306 { 
    307 #ifdef _MSC_VER 
    308         HANDLE fFile; // File Handle 
    309         WIN32_FIND_DATA fileinfo; // File Information Structure 
    310         int n = strlen(dir) - 1; 
    311  
    312         if (dir[n] == '\\' || dir[n] == '/') 
    313                 dir[n]=0; 
    314  
    315         fFile = FindFirstFile(dir, &fileinfo); 
    316  
    317         // if the file exists and it is a directory 
    318         if (fileinfo.dwFileAttributes == FILE_ATTRIBUTE_DIRECTORY) { 
    319                 // Directory Exists close file and return 
    320                 FindClose(fFile); 
    321                 return true; 
    322         } 
    323  
    324         FindClose(fFile); 
    325  
    326         // Now lets cycle through the String Array and create each directory in turn 
    327         if (CreateDirectory(dir, 0)) { 
    328                 SetFileAttributes(dir, FILE_ATTRIBUTE_NORMAL); 
    329                 return true; 
    330         } else { 
    331                 char *temp = GetPath(dir); 
    332  
    333                 if (strcmp(temp, dir)!=0) { 
    334                         CreateDir(temp); 
    335                         if (CreateDirectory(dir, 0)) { 
    336                                 SetFileAttributes(dir, FILE_ATTRIBUTE_NORMAL); 
    337                                 return true; 
    338                         } 
    339                 } 
    340                 delete temp; 
    341         } 
    342         Debug << "cannot create directory " << dir << endl; 
    343 #endif 
    344         return false; 
    345 } 
    346  
    347  
    348 #endif 
    349  
    350 } 
     302} 

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

    r2755 r2756  
    285285 
    286286Real Random(Real max); 
    287 int  Random(int max); 
     287int Random(int max); 
    288288void Randomize(); 
    289 void 
    290 Randomize(const unsigned int seed); 
     289void Randomize(unsigned int seed); 
    291290 
    292291 
    … …  
    473472typedef std::queue<OcclusionQuery *> QueryQueue; 
    474473 
    475 } 
    476  
    477 #endif 
    478  
    479  
    480  
    481  
    482  
    483  
    484  
    485  
     474static std::ofstream Debug("debug.log"); 
     475 
     476} 
     477 
     478#endif 
     479 
     480 
     481 
     482 
     483 
     484 
     485 
     486 
Note: See TracChangeset for help on using the changeset viewer.