Changeset 2844 for GTP


Ignore:
Timestamp:
07/17/08 17:21:39 (16 years ago)
Author:
mattausch
Message:

lod starting to work

Location:
GTP/trunk/App/Demos/Vis/FriendlyCulling
Files:
18 edited

Legend:

Unmodified
Added
Removed

  • GTP/trunk/App/Demos/Vis/FriendlyCulling/src/Camera.cpp

    r2838 r2844  
    5454        mViewOrientation = mBaseOrientation; 
    5555 
    56         cout << "right: " << right << endl; 
     56        /*cout << "right: " << right << endl; 
    5757        cout << "up:    " << up << endl; 
    5858        cout << "dir:   " << direction << endl; 
     59        */ 
    5960} 
    6061 
    … …  
    248249        } 
    249250 
    250         cout<<"here2 " << DotProd(h1, Vector3(0, 1, 0)) << " " << mPitch << endl; 
    251251        CalculateFromPitchAndYaw(); 
    252252} 

  • GTP/trunk/App/Demos/Vis/FriendlyCulling/src/LODInfo.h

    r2839 r2844  
    1010/** Class representing information about an LOD level. 
    1111*/ 
    12 struct LODInfo 
     12struct LODLevel 
    1313{ 
    1414public: 
     15         
     16        LODLevel(float squaredDist): mSquaredDistance(squaredDist) {} 
     17 
     18 
    1519        /// distance of this LOD level 
    1620        float mSquaredDistance; 

  • GTP/trunk/App/Demos/Vis/FriendlyCulling/src/Material.cpp

    r2825 r2844  
    2525        mTexture = NULL; 
    2626        mAlphaTestEnabled = false; 
     27        mCullFaceEnabled = true; 
    2728 
    2829        mAmbientColor = RgbaColor(0.2f, 0.2f, 0.2f, 1.0f); 
    … …  
    6263void Material::Render(RenderState *state) 
    6364{ 
    64         state->SetState(mTexture != NULL, mAlphaTestEnabled); 
     65        state->SetState(mTexture != NULL, mAlphaTestEnabled, mCullFaceEnabled); 
    6566 
    6667        if (mTexture) 

  • GTP/trunk/App/Demos/Vis/FriendlyCulling/src/Material.h

    r2822 r2844  
    6464         
    6565        inline void SetAlphaTestEnabled(bool alpha) { mAlphaTestEnabled = alpha; } 
     66        inline void SetCullFaceEnabled(bool cull) { mCullFaceEnabled = cull; } 
     67 
    6668        inline bool IsAlphaTestEnabled() const { return mAlphaTestEnabled; }  
     69        inline bool IsCullFaceEnabled() const { return mCullFaceEnabled; }  
     70 
    6771        /** Renders this material. 
    6872        */ 
    … …  
    8892 
    8993        bool mAlphaTestEnabled; 
     94        bool mCullFaceEnabled; 
    9095        /// the assciated texture 
    9196        Texture *mTexture; 

  • GTP/trunk/App/Demos/Vis/FriendlyCulling/src/RenderQueue.cpp

    r2842 r2844  
    1515 
    1616 
    17 inline static bool CompDist2(RenderQueueBucket *b1, RenderQueueBucket *b2) 
     17inline static bool CompDist(RenderQueueBucket *b1, RenderQueueBucket *b2) 
    1818{ 
    1919        return (b1->mMinDistance < b2->mMinDistance); 
    … …  
    2626mMinSizeForSorting(3), 
    2727mCamera(NULL), 
    28 mSize(0) 
     28mNumEntries(0) 
    2929{ 
    3030} 
    … …  
    3535mMinSizeForSorting(3), 
    3636mCamera(cam), 
    37 mSize(0) 
     37mNumEntries(0) 
    3838{ 
    3939} 
    … …  
    5858                return false; 
    5959 
     60        if (mat->IsCullFaceEnabled() != mBuckets[idx]->mAlphaTestEnabled) 
     61                return false; 
     62 
    6063        const bool hasTexture = (mat->GetTexture() != NULL); 
    6164 
    … …  
    7881void RenderQueue::Enqueue(SceneEntity *entity) 
    7982{ 
    80         static ShapeContainer shapes; 
    81         shapes.clear(); 
    82  
    83         entity->GetCurrentLODLevel(shapes); 
    84  
    85         ShapeContainer::const_iterator sit, sit_end = shapes.end(); 
    86  
    87         for (sit = shapes.begin(); sit != sit_end; ++ sit) 
     83        ShapeContainer::iterator sit, sit_end; 
     84 
     85        entity->GetCurrentLODLevel(sit, sit_end); 
     86 
     87        for (; sit != sit_end; ++ sit) 
    8888        { 
    8989                Enqueue(*sit); 
    … …  
    9595{ 
    9696        RenderQueueBucket *bucket; 
    97         ++ mSize; 
     97        ++ mNumEntries; 
    9898         
    9999        if (shape->mRenderQueueBucket) 
    … …  
    117117                { 
    118118                        RenderQueueBucket *bucket = new RenderQueueBucket(); 
     119                        bucket->mMinDistance = -1; 
    119120 
    120121                        Material *mat = shape->GetMaterial(); 
    121122 
    122123                        bucket->mAlphaTestEnabled = mat->IsAlphaTestEnabled(); 
     124                        bucket->mCullFaceEnabled = mat->IsCullFaceEnabled(); 
    123125 
    124126                        const bool hasTexture = (mat->GetTexture() != NULL); 
    … …  
    131133                        mBuckets.push_back(bucket); 
    132134 
    133                         // assume that the incoming nodes are ordered by distance => set min dist 
    134                         // on first incoming node 
    135                         Vector3 v = shape->GetTransformedBoundingBox().Center() - mCamera->GetPosition(); 
    136                         const float dist = SqrMagnitude(v); 
    137                         mBuckets[i]->mMinDistance = dist; 
    138  
    139135                        //cout << "num buckets: " << (int)mBuckets.size() << endl; 
    140136                } 
    … …  
    144140        } 
    145141 
     142        if (bucket->mMinDistance < -0.5f) 
     143        { 
     144                // assume that the incoming nodes are ordered by distance  
     145                // => set min dist on first incoming node 
     146                const Vector3 v = shape->GetTransformedBoundingBox().Center() - mCamera->GetPosition(); 
     147                 
     148                const float dist = SqrMagnitude(v); 
     149                bucket->mMinDistance = dist; 
     150        } 
     151 
    146152        bucket->mShapes.push_back(shape); 
    147153} 
    … …  
    151157{ 
    152158        for (size_t i = 0; i < mBuckets.size(); ++ i) 
     159        { 
     160                mBuckets[i]->mMinDistance = -1; 
    153161                mBuckets[i]->mShapes.clear(); 
    154  
    155         mSize = 0; 
     162        } 
     163 
     164        mNumEntries = 0; 
    156165} 
    157166 
    … …  
    210219{ 
    211220        // sort buckets itself 
    212         sort(mBuckets.begin(), mBuckets.end(), CompDist2); 
     221        sort(mBuckets.begin(), mBuckets.end(), CompDist); 
    213222} 
    214223 

  • GTP/trunk/App/Demos/Vis/FriendlyCulling/src/RenderQueue.h

    r2842 r2844  
    2525        bool mHasTexture; 
    2626        bool mAlphaTestEnabled; 
     27        bool mCullFaceEnabled; 
    2728 
    2829        /// minimal distance to the camera 
    … …  
    6061        */ 
    6162        void SetCamera(Camera *cam); 
    62         /** Returns the number entities currently in the queue. 
     63        /** Returns the number of entries currently in the queue. 
    6364        */ 
    64         inline int GetSize() const { return (int)mSize; } 
     65        inline int GetSize() const { return (int)mNumEntries; } 
    6566        /** Renders and clears the queue. 
    6667        */ 
    … …  
    9596        std::vector<RenderQueueBucket *> mBuckets; 
    9697 
    97         int mSize; 
     98        int mNumEntries; 
    9899}; 
    99100 

  • GTP/trunk/App/Demos/Vis/FriendlyCulling/src/RenderState.cpp

    r2825 r2844  
    1818RenderState::RenderState(): 
    1919mAlphaTestEnabled(false),  
     20mCullFaceEnabled(true),  
    2021mTexturesEnabled(false),  
    2122mMode(RENDER), 
    … …  
    5152                glDepthMask(GL_FALSE); 
    5253 
    53                 SetState(false, false); 
     54                SetState(false, false, false); 
    5455        } 
    5556        else // mode returns to render 
    … …  
    7778 
    7879         
    79 void RenderState::SetState(bool texturing, bool alphaTest) 
     80void RenderState::SetState(bool texturing, bool alphaTest, bool cullFace) 
    8081{ 
     82        if (mCullFaceEnabled && !cullFace)  
     83        { 
     84                mCullFaceEnabled = false; 
     85                glDisable(GL_CULL_FACE); 
     86        } 
     87        else if (!mCullFaceEnabled && cullFace) 
     88        { 
     89                mCullFaceEnabled = true; 
     90                glEnable(GL_CULL_FACE); 
     91        } 
     92 
    8193        if (mAlphaTestEnabled && !alphaTest)  
    8294        { 
    … …  
    122134        mCurrentVboId = -1; 
    123135 
    124         SetState(false, false); 
     136        SetState(false, false, false); 
    125137        SetState(RENDER); 
    126138} 

  • GTP/trunk/App/Demos/Vis/FriendlyCulling/src/RenderState.h

    r2825 r2844  
    4444        /** Sets the current render state. 
    4545        */ 
    46         void SetState(bool texturing, bool alphaTest); 
     46        void SetState(bool texturing, bool alphaTest, bool cullFace); 
    4747        /** Returns wether we are in query or render mode 
    4848        */ 
    … …  
    7474 
    7575        bool mAlphaTestEnabled; 
     76        bool mCullFaceEnabled; 
    7677        bool mTexturesEnabled; 
    7778 

  • GTP/trunk/App/Demos/Vis/FriendlyCulling/src/RenderTraverser.cpp

    r2842 r2844  
    109109                { 
    110110                        SceneEntity *ent = entities[i]; 
     111                        ent->UpdateLODs(mCamera); 
    111112                         
    112113                        mStats.mNumRenderedTriangles += ent->CountNumTriangles(); 

  • GTP/trunk/App/Demos/Vis/FriendlyCulling/src/ResourceManager.cpp

    r2842 r2844  
    1010#include "Transform3.h" 
    1111#include "Shape.h" 
     12#include "LODInfo.h" 
    1213 
    1314 
    … …  
    3334SceneEntity *ResourceManager::LoadSceneEntity(igzstream &str) 
    3435{        
    35         // shape 
    36         int shapeId; 
    37         str.read(reinterpret_cast<char *>(&shapeId), sizeof(int)); 
    38  
    39         Geometry *geom = mGeometryTable[shapeId]; 
    40         Material *mat = mMaterialTable[shapeId]; 
    41  
    42  
    4336        bool hasTrafo; 
    4437        str.read(reinterpret_cast<char *>(&hasTrafo), sizeof(bool)); 
    … …  
    6053        Transform3 *trafo = new Transform3(m); 
    6154        mTrafos.push_back(trafo); 
    62          
    63         // use instancing 
     55 
    6456        sceneGeom = new SceneEntity(trafo); 
    6557 
    66         // create shape 
    67         Shape *shape = new Shape(geom, mat, sceneGeom); 
    68         mShapes.push_back(shape); 
    69  
    70         sceneGeom->AddShape(shape); 
     58        /////////////// 
     59        //-- load lod levels 
     60 
     61        int numLODs; 
     62        str.read(reinterpret_cast<char *>(&numLODs), sizeof(int)); 
     63 
     64        //if (numLODs > 1) cout << "numlods: " << numLODs << endl; 
     65        for (int i = 0; i < numLODs; ++ i) 
     66        { 
     67                float distance; 
     68                str.read(reinterpret_cast<char *>(&distance), sizeof(float)); 
     69 
     70                int numShapes; 
     71                str.read(reinterpret_cast<char *>(&numShapes), sizeof(int)); 
     72 
     73                //if (numLODs > 1) cout << "dist: " << distance << " shapes: " << numShapes; 
     74 
     75                LODLevel *lodLevel = new LODLevel(distance); 
     76 
     77                for (int j = 0; j < numShapes; ++ j) 
     78                { 
     79                        int shapeId; 
     80                        str.read(reinterpret_cast<char *>(&shapeId), sizeof(int)); 
     81 
     82                        //if (numLODs > 1) cout << " id " << shapeId; 
     83                         
     84                        Geometry *geom = mGeometryTable[shapeId]; 
     85                        Material *mat = mMaterialTable[shapeId]; 
     86 
     87                        // create shape 
     88                        Shape *shape = new Shape(geom, mat, sceneGeom); 
     89                         
     90                        mShapes.push_back(shape); 
     91 
     92                        sceneGeom->AddShape(shape); 
     93                        lodLevel->mShapes.push_back(shape); 
     94                } 
     95 
     96                //if (numLODs > 1) cout << endl; 
     97 
     98                sceneGeom->AddLODLevel(lodLevel); 
     99        } 
    71100 
    72101        return sceneGeom; 
    … …  
    90119                str.read(texname, sizeof(char) * texnameSize); 
    91120 
    92                 //cout << "loading texture " << texname << " with len " << texnameSize << " id: " << id << endl; 
    93121                Texture *tex = new Texture(model_path + texname); 
    94122 
    … …  
    135163         
    136164        str.read(reinterpret_cast<char *>(&mat->mAlphaTestEnabled), sizeof(bool)); 
     165 
     166        //str.read(reinterpret_cast<char *>(&mat->mCullFaceEnabled), sizeof(bool)); 
    137167 
    138168        // material 

  • GTP/trunk/App/Demos/Vis/FriendlyCulling/src/ResourceManager.h

    r2842 r2844  
    3434        */ 
    3535        bool Load(const std::string &filename, SceneEntityContainer &geometry); 
     36        SceneEntityContainer mSceneEntities; 
    3637 
    3738protected: 
    … …  
    5657        std::vector<Transform3 *> mTrafos; 
    5758         
    58         SceneEntityContainer mSceneEntities; 
    5959        ShapeContainer mShapes; 
    6060}; 

  • GTP/trunk/App/Demos/Vis/FriendlyCulling/src/SceneEntity.cpp

    r2842 r2844  
    11#include "SceneEntity.h" 
    2 #include "glInterface.h" 
    32#include "Geometry.h" 
    43#include "Material.h" 
    54#include "RenderState.h" 
    65#include "Shape.h" 
     6#include "Transform3.h" 
     7#include "Camera.h" 
     8 
     9#include "glInterface.h" 
    710#include <Cg/cg.h> 
    811#include <Cg/cgGL.h> 
    … …  
    1619 
    1720 
    18 SceneEntity::SceneEntity(Transform3 *trafo): mTransform(trafo) 
     21SceneEntity::SceneEntity(Transform3 *trafo):  
     22mTransform(trafo), mCurrentLODLevel(0) 
    1923{ 
     24        mBox.Initialize(); 
    2025} 
    2126 
    … …  
    2631 
    2732 
    28 void SceneEntity::GetCurrentLODLevel(ShapeContainer &shapes) 
     33void SceneEntity::UpdateLODs(Camera *cam) 
    2934{ 
    30         ShapeContainer::const_iterator sit, sit_end; 
     35        const Vector3 pos = GetTransformedBoundingBox().Center(); 
    3136 
    32         if (mLODInfos.empty()) 
     37        const float distance = SqrDistance(pos, cam->GetPosition()); 
     38 
     39        mCurrentLODLevel = 0; 
     40 
     41        int l = (int)mLODLevels.size(); 
     42 
     43        for (int i = 0; i < l; ++ i) 
    3344        { 
    34                 sit = mShapes.begin(); sit_end = mShapes.end(); 
     45                LODLevel *lod = mLODLevels[i]; 
     46 
     47                if (lod->mSquaredDistance > distance) 
     48                        break; 
     49 
     50                mCurrentLODLevel = i; 
    3551        } 
    3652 
    37         float mDistance = 0.0f; 
     53        /*if (mLODLevels.size() > 1) 
     54        { 
     55                Debug << "dist: " << distance << " numshapes: " << mLODLevels[mCurrentLODLevel]->mShapes.size() << " lod: " << mCurrentLODLevel << " of " << mLODLevels.size() << endl; 
     56        }*/ 
     57} 
    3858 
    39         int i = 0; 
     59void SceneEntity::GetCurrentLODLevel(ShapeContainer::iterator &start,  
     60                                                                         ShapeContainer::iterator &end) 
     61{ 
     62        start = mLODLevels[mCurrentLODLevel]->mShapes.begin();  
     63        end = mLODLevels[mCurrentLODLevel]->mShapes.end(); 
     64} 
    4065 
    41         LODInfoContainer::const_iterator lid, lid_end = mLODInfos.end(); 
    4266 
    43         for (lid = mLODInfos.begin(); lid != lid_end; ++ lid) 
    44         { 
    45                 LODInfo *lodInfo = *lid; 
     67void SceneEntity::GetLODLevel(int level,  
     68                                                          ShapeContainer::iterator &start,  
     69                                                          ShapeContainer::iterator &end) 
     70{ 
     71        LODLevel *lod = mLODLevels[level]; 
    4672 
    47                 if (lodInfo->mSquaredDistance > mDistance) 
    48                 { 
    49                         sit = lodInfo->mShapes.begin();  
    50                         sit_end = lodInfo->mShapes.end(); 
    51                         break; 
    52                 } 
    53         } 
    54  
    55         for (; sit != sit_end; ++ sit) 
    56         { 
    57                 shapes.push_back(*sit); 
    58         } 
     73        start = lod->mShapes.begin(); 
     74        end = lod->mShapes.end(); 
    5975} 
    6076 
    … …  
    6278void SceneEntity::Render(RenderState *state) 
    6379{ 
    64         //if (mMaterial) mMaterial->Render(state); 
    65         float mDistance = 0.0f; 
     80        ShapeContainer::iterator sit, sit_end; 
    6681 
    67         static ShapeContainer shapes; 
    68         shapes.clear(); 
     82        /*if (mShapes.size() > 8) 
     83        { 
     84                sit = mShapes.begin() + 6; 
     85                sit_end = mShapes.begin() + 6; 
     86        } 
     87        else*/ 
     88                GetCurrentLODLevel(sit, sit_end); 
    6989 
    70         GetCurrentLODLevel(shapes); 
    71  
    72         ShapeContainer::const_iterator sit, sit_end = shapes.end(); 
    73  
    74         for (sit = shapes.begin(); sit != sit_end; ++ sit) 
     90        //if (mShapes.size() > 1) 
     91                //mShapes[0]->Render(state); 
     92        for (; sit != sit_end; ++ sit) 
    7593        { 
    7694                (*sit)->Render(state); 
    … …  
    82100{ 
    83101        mShapes.push_back(shape); 
     102        mBox.Include(shape->GetBoundingBox()); 
    84103} 
    85104 
    … …  
    103122 
    104123 
    105 int SceneEntity::CountNumTriangles() 
     124int SceneEntity::CountNumTriangles(int lodLevel) 
    106125{ 
    107126        int numTriangles = 0; 
    108         static ShapeContainer shapes; 
    109         shapes.clear(); 
     127         
     128        ShapeContainer::iterator sit, sit_end; 
    110129 
    111         GetCurrentLODLevel(shapes); 
     130        if (lodLevel == -1) 
     131        { 
     132                GetCurrentLODLevel(sit, sit_end); 
     133        } 
     134        else 
     135        { 
     136                GetLODLevel(lodLevel, sit, sit_end); 
     137        } 
    112138 
    113         ShapeContainer::const_iterator sit, sit_end = shapes.end(); 
    114139 
    115         for (sit = shapes.begin(); sit != sit_end; ++ sit) 
     140        for (; sit != sit_end; ++ sit) 
    116141        { 
    117142                numTriangles += (*sit)->GetGeometry()->GetNumTriangles(); 
    … …  
    122147 
    123148 
     149AxisAlignedBox3 SceneEntity::GetTransformedBoundingBox() const 
     150{ 
     151        Matrix4x4 *mat = mTransform->GetMatrix(); 
     152 
     153        if (!mat) 
     154                return mBox; 
     155 
     156        return Transform(mBox, *mat); 
    124157} 
     158 
     159 
     160AxisAlignedBox3 SceneEntity::GetBoundingBox() const 
     161{ 
     162        return mBox; 
     163} 
     164 
     165} 

  • GTP/trunk/App/Demos/Vis/FriendlyCulling/src/SceneEntity.h

    r2842 r2844  
    1818class RenderState; 
    1919class Transform3; 
     20class Camera; 
    2021 
    2122 
    … …  
    4950        */ 
    5051        void SetTransform(Transform3 *trafo); 
    51         /** Returns the transformed bounding box. 
    52         */ 
    53         //AxisAlignedBox3 GetBoundingBox() const; 
    5452        /** set frame where we last rendered this node 
    5553        */ 
    … …  
    6159        */ 
    6260        inline Transform3 *GetTransform() const  { return mTransform; } 
     61        /** Counts number of triangles in this entity using the specified lod level 
     62                with 0 being the highest or the current lod level (if the argument is -1). 
     63        */ 
     64        int CountNumTriangles(int lodLevel = 0); 
     65        /** Returns the bounding box. 
     66        */ 
     67        AxisAlignedBox3 GetBoundingBox() const; 
     68        /** Returns the transformed bounding box. 
     69        */ 
     70        AxisAlignedBox3 GetTransformedBoundingBox() const; 
     71         
    6372 
    64         void GetCurrentLODLevel(ShapeContainer &shapes); 
    6573 
    66         int CountNumTriangles(); 
     74        //////////////// 
    6775 
     76        /** Internally updates current lod level. 
     77        */ 
     78        void UpdateLODs(Camera *cam); 
     79        /** Returns shapes of specified lod level 
     80        */ 
     81        void GetLODLevel(int level, ShapeContainer::iterator &start, ShapeContainer::iterator &end); 
     82        /** Returns shapes of current lod level 
     83        */ 
     84        void GetCurrentLODLevel(ShapeContainer::iterator &start, ShapeContainer::iterator &end); 
     85        /** Adds a new lod level. 
     86        */ 
     87        void AddLODLevel(LODLevel *lod) { mLODLevels.push_back(lod); } 
     88        /** Returns numbers of lod levels. 
     89        */ 
     90        int GetNumLODLevels() const { return (int)mLODLevels.size(); } 
    6891 
    6992protected: 
    7093 
    71  
     94        AxisAlignedBox3 mBox; 
    7295        /// transform matrix  
    7396        Transform3 *mTransform; 
    7497        /// Stores information about the LOD levels 
    75         LODInfoContainer mLODInfos; 
     98        LODLevelContainer mLODLevels; 
    7699        /// the renderable shapes 
    77100        ShapeContainer mShapes; 
    78101        /// when this entity was last rendered 
    79102        int mLastRendered; 
     103 
     104        int mCurrentLODLevel; 
    80105}; 
    81106 

  • GTP/trunk/App/Demos/Vis/FriendlyCulling/src/Shape.cpp

    r2842 r2844  
    5555AxisAlignedBox3 Shape::GetTransformedBoundingBox() const 
    5656{ 
    57         AxisAlignedBox3 box = mGeometry->GetBoundingBox(); 
    5857        Matrix4x4 *mat = mParent->GetTransform()->GetMatrix(); 
    5958 
    60         if (mat) Transform(box, *mat); 
     59        if (!mat) 
     60                return mGeometry->GetBoundingBox(); 
    6161 
    62         return box; 
     62        return Transform(mGeometry->GetBoundingBox(), *mat); 
    6363} 
    6464 

  • GTP/trunk/App/Demos/Vis/FriendlyCulling/src/Vector3.h

    r2782 r2844  
    314314inline float SqrMagnitude(const Vector3 &v)  
    315315{ 
    316   return v.x * v.x + v.y * v.y + v.z * v.z; 
     316        return v.x * v.x + v.y * v.y + v.z * v.z; 
    317317} 
    318318 
    … …  
    320320inline float Distance(const Vector3 &v1, const Vector3 &v2) 
    321321{ 
    322   return sqrtf(sqrt(v1.x - v2.x) + sqrt(v1.y - v2.y) + sqrt(v1.z - v2.z)); 
     322        //return sqrtf(sqrt(v1.x - v2.x) + sqrt(v1.y - v2.y) + sqrt(v1.z - v2.z)); 
     323        return Magnitude(v1 - v2); 
    323324} 
    324325 
    … …  
    326327inline float SqrDistance(const Vector3 &v1, const Vector3 &v2) 
    327328{ 
    328   return sqrt(v1.x - v2.x) + sqrt(v1.y - v2.y) + sqrt(v1.z - v2.z); 
     329        //return sqrt(v1.x - v2.x) + sqrt(v1.y - v2.y) + sqrt(v1.z - v2.z); 
     330        return SqrMagnitude(v1 - v2); 
    329331} 
    330332 
    … …  
    332334inline Vector3 Normalize(const Vector3 &A) 
    333335{ 
    334   return A * (1.0f / Magnitude(A)); 
     336        return A * (1.0f / Magnitude(A)); 
    335337} 
    336338 
    … …  
    338340inline float DotProd(const Vector3 &A, const Vector3 &B) 
    339341{ 
    340   return A.x * B.x + A.y * B.y + A.z * B.z; 
     342        return A.x * B.x + A.y * B.y + A.z * B.z; 
    341343} 
    342344 

  • GTP/trunk/App/Demos/Vis/FriendlyCulling/src/chcdemo.cpp

    r2843 r2844  
    854854        //glEnable(GL_ALPHA_TEST); 
    855855        glDisable(GL_ALPHA_TEST); 
    856         glAlphaFunc(GL_GEQUAL, 0.5f); 
     856        glAlphaFunc(GL_GEQUAL, 0.8f); 
    857857 
    858858        glFrontFace(GL_CCW); 
    … …  
    11951195 
    11961196 
     1197        /*state.Reset(); 
     1198        state.SetState(RenderState::RENDER); 
     1199         
     1200        glEnableClientState(GL_VERTEX_ARRAY); 
     1201        glEnableClientState(GL_NORMAL_ARRAY); 
     1202 
     1203        for (int i = 0; i < loader->mSceneEntities.size(); ++ i) 
     1204        { 
     1205                SceneEntity *ent = loader->mSceneEntities[i]; 
     1206 
     1207                ent->UpdateLODs(camera); 
     1208                ent->Render(&state); 
     1209        }*/ 
     1210 
    11971211        // actually render the scene geometry using one of the specified algorithms 
    11981212        traverser->RenderScene(); 

  • GTP/trunk/App/Demos/Vis/FriendlyCulling/src/common.h

    r2839 r2844  
    497497typedef std::vector<Shape *> ShapeContainer; 
    498498 
    499 struct LODInfo; 
    500 typedef std::vector<LODInfo *> LODInfoContainer; 
    501  
    502 } 
    503  
    504 #endif 
    505  
    506  
    507  
    508  
    509  
    510  
    511  
    512  
     499struct LODLevel; 
     500typedef std::vector<LODLevel *> LODLevelContainer; 
     501 
     502} 
     503 
     504#endif 
     505 
     506 
     507 
     508 
     509 
     510 
     511 
     512 
Note: See TracChangeset for help on using the changeset viewer.