Changeset 80


Ignore:
Timestamp:
05/03/05 16:59:56 (20 years ago)
Author:
mattausch
Message:
 
Location:
trunk/VUT/work/TestCullingTerrain
Files:
3 edited
2 moved

Legend:

Unmodified
Added
Removed

  • trunk/VUT/work/TestCullingTerrain/SceneContentGenerator.cpp

    r77 r80  
    11/** 
    22    \file  
    3         TerrainContentGenerator.cpp 
     3        SceneContentGenerator.cpp 
    44    \brief 
    5         Creates content for the terrain. 
     5        Creates content for a scene. 
    66*/ 
    7 #include "TerrainContentGenerator.h" 
     7#include "SceneContentGenerator.h" 
    88#include <windows.h> 
    9 /********************************************/ 
    10 /*  TerrainContentGenerator implementation  */ 
    11 /********************************************/ 
     9 
     10namespace Ogre { 
     11 
     12/*******************************************************/ 
     13/*     SceneContentGenerator implementation            */ 
     14/*******************************************************/ 
     15 
    1216//----------------------------------------------------------------------- 
    13 TerrainContentGenerator::TerrainContentGenerator(SceneManager *sm) 
     17SceneContentGenerator::SceneContentGenerator(SceneManager *sm): 
     18mSceneMgr(sm), mCount(0), 
     19mMinPos(Vector3(-70.0f, -70.0f, 0.0f)), 
     20mMaxPos(Vector3(70.0f, 70.0f, 600.0f)),  
     21mMinAngle(Vector3(0.0f, 0.0f, 0.0f)), 
     22mMaxAngle(Vector3(360, 360, 360)) 
    1423{ 
    15         mSceneMgr = sm; 
    16         mRayQueryExecutor = new RayQueryExecutor(sm); 
    17  
    18         mMinPos = Vector3(-500.0f, 5000.0f, -500.0f); 
    19         mMaxPos = Vector3(500.0f, 5000.0f, 500.0f); 
    20  
    21         mMinAngle = 0; 
    22         mMaxAngle = 360; 
    23  
    24         mCount = 0; 
    2524} 
    2625//----------------------------------------------------------------------- 
    27 TerrainContentGenerator::~TerrainContentGenerator() 
     26void SceneContentGenerator::GenerateScene(int numObjects, const String &objName) 
    2827{ 
    29         delete mRayQueryExecutor; 
    30 } 
    31 //----------------------------------------------------------------------- 
    32 void TerrainContentGenerator::generateScene(int numObjects, const String &meshName) 
    33 { 
     28        // initialise random generator 
    3429        srand (time(0)); 
    3530         
    … …  
    3732        Vector3 translationRatio; 
    3833 
    39         for(int i=0; i < numObjects; ++i) 
     34        int currentCount = mCount; 
     35        int limit = 0; 
     36 
     37        //-- create random values between zero and one 
     38        while ((mCount - currentCount < numObjects) && (limit < 50000)) 
    4039        { 
    4140                rotationRatio.x = rand() / (float) RAND_MAX; 
    … …  
    4746                translationRatio.z = rand() / (float) RAND_MAX; 
    4847 
    49                 generateSceneObject(translationRatio, rotationRatio, i, meshName); 
     48                // Setup the ray scene query 
     49                Vector3 rotation = mMinAngle + rotationRatio * (mMaxAngle - mMinAngle); 
     50                Vector3 position = mMinPos + translationRatio * (mMaxPos - mMinPos); 
     51 
     52                (void)GenerateSceneObject(position, rotation, objName); 
     53                ++limit; // just in case: to avoid endless loop 
    5054        } 
    5155} 
    5256//----------------------------------------------------------------------- 
    53 void TerrainContentGenerator::generateSceneObject(const Vector3 &translationRatio,  
    54                                          const Vector3 &rotationRatio, const int idx, const String& entName) 
     57SceneNode *SceneContentGenerator::GenerateSceneObject(const Vector3 &position,  
     58                                         const Vector3 &rotation, const String& objName) 
    5559{ 
    56         // Setup the ray scene query 
    57         Real rotation = mMinAngle + rotationRatio.x * (mMaxAngle - mMinAngle); 
    58         Vector3 position = mMinPos + translationRatio * (mMaxPos - mMinPos); 
     60        char name[25]; 
     61        sprintf(name, "Entity%d", mCount++); 
     62                 
     63        Entity *ent = mSceneMgr->createEntity(name, objName); 
     64                 
     65        SceneNode *currentObject = mSceneMgr->getRootSceneNode()-> 
     66                createChildSceneNode(String(name) + "Node", position); 
    5967 
    60         Vector3 queryResult; 
     68        currentObject->attachObject(ent); 
     69        currentObject->setScale(0.1f, 0.1f, 0.1f); 
     70                 
     71        currentObject->yaw(Degree(rotation.x)); 
     72        currentObject->pitch(Degree(rotation.y)); 
     73        currentObject->roll(Degree(rotation.z)); 
    6174 
     75        return currentObject; 
     76         
     77        /* 
    6278        char msg[100]; 
    63         sprintf(msg, "pos: %3.3f %3.3f %3.3f\n", position.x, position.y, position.z); 
     79        sprintf(msg, "pos: %3.3f %3.3f %3.3f, newpos: %3.3f %3.3f %3.3f\n",  
     80                position.x, position.y, position.z, queryResult.x, queryResult.y, queryResult.z); 
    6481 
    65         if (mRayQueryExecutor->executeRayQuery(&queryResult, position, Vector3::NEGATIVE_UNIT_Y)) 
    66         { 
    67                 char name[16]; 
    68                 sprintf(name, "%s%d", entName.c_str(), mCount++); 
    69                 OutputDebugString("Creating new object "); OutputDebugString(msg); 
    70  
    71                 Entity *ent = mSceneMgr->createEntity(name, entName); 
    72                 SceneNode *currentObject = mSceneMgr->getRootSceneNode()-> 
    73                         createChildSceneNode(String(name) + "Node", queryResult); 
    74  
    75                 currentObject->attachObject(ent); 
    76                 currentObject->setScale(0.1f, 0.1f, 0.1f); 
    77                 currentObject->setPosition(position); 
    78         } 
    79         else 
    80         { 
    81                 OutputDebugString(msg); 
    82         } 
    83 } 
    84 /****************************************/ 
    85 /*  RayQueryExecutor implementation     */ 
    86 /****************************************/ 
    87 //----------------------------------------------------------------------- 
    88 RayQueryExecutor::RayQueryExecutor(SceneManager *sm) 
    89 { 
    90         mRaySceneQuery = sm->createRayQuery(Ray()); 
     82        OutputDebugString(msg); 
     83        */ 
    9184} 
    9285//----------------------------------------------------------------------- 
    93 RayQueryExecutor::~RayQueryExecutor() 
     86void SceneContentGenerator::SetMinAngle(Vector3 minAngle) 
    9487{ 
    95         delete mRaySceneQuery; 
     88        mMinAngle = minAngle; 
    9689} 
    9790//----------------------------------------------------------------------- 
    98 bool RayQueryExecutor::executeRayQuery(Vector3 *result, const Vector3 &pos, const Vector3 &dir) 
     91void SceneContentGenerator::SetMaxAngle(Vector3 maxAngle) 
    9992{ 
    100         return executeRayQuery(result, Ray(pos, dir)); 
     93        mMaxAngle = maxAngle; 
     94} 
     95//----------------------------------------------------------------------- 
     96void SceneContentGenerator::SetMinPos(Vector3 minPos) 
     97{ 
     98        mMinPos = minPos; 
     99} 
     100//----------------------------------------------------------------------- 
     101void SceneContentGenerator::SetMaxPos(Vector3 maxPos) 
     102{ 
     103        mMaxPos = maxPos; 
    101104} 
    102105 
    103 bool RayQueryExecutor::executeRayQuery(Vector3 *result, const Ray &ray) 
    104 { 
    105     mRaySceneQuery->setRay(ray); 
    106  
    107     // Perform the scene query 
    108     RaySceneQueryResult &queryResult = mRaySceneQuery->execute(); 
    109     RaySceneQueryResult::iterator it = queryResult.begin(); 
    110  
    111         if (it != queryResult.end() && it->worldFragment) 
    112         { 
    113                 SceneQuery::WorldFragment* wf = it->worldFragment; 
    114  
    115                 *result = wf->singleIntersection;  
    116                 return true; 
    117         } 
    118  
    119         return false; 
    120 } 
     106} // namespace Ogre 

  • trunk/VUT/work/TestCullingTerrain/SceneContentGenerator.h

    r75 r80  
    1 /** 
    2     \file  
    3         TerrainContentGenerator.h 
     1#ifndef _SCENECONTENTGENERATOR_H__ 
     2#define _SCENECONTENTGENERATOR_H__ 
     3 
     4#include <OgrePrerequisites.h> 
     5#include <OgreMath.h> 
     6#include <Ogre.h> 
     7 
     8namespace Ogre { 
     9 
     10/** Class which fills a scene with content in a random fashion. 
    411*/ 
    5 #include "ExampleApplication.h" 
    6  
    7 /** Class which executes a simple ray query. 
    8 */ 
    9 class RayQueryExecutor 
     12class SceneContentGenerator 
    1013{ 
    1114public: 
    12         RayQueryExecutor(SceneManager *sm); 
    13         ~RayQueryExecutor(); 
     15        SceneContentGenerator(SceneManager *sm); 
    1416         
    15         bool executeRayQuery(Vector3 *result, const Vector3 &pos, const Vector3 &dir); 
    16         bool RayQueryExecutor::executeRayQuery( Vector3 *result, const Ray &ray); 
     17        /** Generates scene object in a random fashion. 
     18                @param number of objects to generate 
     19                @param objName the name of the mesh to be generated 
     20        */ 
     21        void GenerateScene(int numObjects, const String &objName); 
     22        /** Generates a new object in the scene using ray scene queries  
     23                and inserts it into scene hierarchy. 
     24                @param position position where the object is created 
     25                @param rotation rotation angle applied locally to object 
     26                @objName the name of the object entity 
     27                @returns scene object if it was successfully created, NULL otherwise 
     28        */ 
     29        SceneNode *GenerateSceneObject(const Vector3 &position,  
     30                const Vector3 &rotation, const String &objName); 
    1731 
    18 protected: 
    19         RaySceneQuery *mRaySceneQuery; 
    20 }; 
    21 /** Class which fills a terrain with content in a random way. 
    22 */ 
    23 class TerrainContentGenerator 
    24 { 
    25 public: 
    26         TerrainContentGenerator(SceneManager *sm); 
    27         ~TerrainContentGenerator(); 
    28         /** Generates a the scene hierarchy with random values . 
    29                 @param number of objects to generate 
    30                 @param the name of the mesh to be generated 
    31         */ 
    32         void generateScene(int numObjects, const String &meshName); 
    33         /** Generates a new scene object  
    34                 @param tranlationRatio ratio between minimal and maximal possible translation 
    35                 @param rotationRatio ratio between minimal and maximal possible rotation 
    36                 @idx the index of the new object 
    37                 @entName the name of the object entity 
    38         */ 
    39         void generateSceneObject(const Vector3 &translationRatio, const Vector3 &rotationRatio,  
    40                                                          const int idx, const String &entName); 
    41  
     32        void SetMinAngle(Vector3 minAngle); 
     33        void SetMaxAngle(Vector3 maxAngle); 
     34        void SetMinPos(Vector3 minPos); 
     35        void SetMaxPos(Vector3 maxPos); 
     36         
    4237protected: 
    4338 
    44         Real mMinAngle; 
    45         Real mMaxAngle; 
     39        Vector3 mMinAngle; 
     40        Vector3 mMaxAngle; 
    4641        Vector3 mMaxPos; 
    4742        Vector3 mMinPos; 
    48  
    49         RayQueryExecutor *mRayQueryExecutor; 
     43         
    5044        SceneManager *mSceneMgr; 
    5145        int mCount;             // The number of objects on the screen 
    5246}; 
    5347 
     48} // namespace Ogre 
     49 
     50#endif // SCENECONTENTGENERATOR_H_ 

  • trunk/VUT/work/TestCullingTerrain/TestCullingTerrain.vcproj

    r74 r80  
    122122                        UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"> 
    123123                        <File 
     124                                RelativePath=".\SceneContentGenerator.cpp"> 
     125                        </File> 
     126                        <File 
    124127                                RelativePath=".\TerrainContentGenerator.cpp"> 
    125128                        </File> 
    … …  
    133136                        UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"> 
    134137                        <File 
     138                                RelativePath=".\SceneContentGenerator.h"> 
     139                        </File> 
     140                        <File 
    135141                                RelativePath=".\TerrainContentGenerator.h"> 
    136142                        </File> 

  • trunk/VUT/work/TestCullingTerrain/TestCullingTerrainApplication.cpp

    r76 r80  
    2020 
    2121 
    22 /************************************************/ 
    23 /* TestCullingTerrainApplication implementation */ 
    24 /************************************************/ 
     22/*******************************************************/ 
     23/*     TestCullingTerrainApplication implementation    */ 
     24/*******************************************************/ 
    2525TestCullingTerrainApplication::~TestCullingTerrainApplication() 
    2626{ 
    27         delete mTerrainContentGenerator; 
     27        delete mSceneContentGenerator; 
    2828} 
    2929//----------------------------------------------------------------------- 
    … …  
    9191        // CEGUI setup 
    9292        setupGui(); 
    93  
    94         mTerrainContentGenerator = new TerrainContentGenerator(mSceneMgr); 
    95         mTerrainContentGenerator->generateScene(300, "robot.mesh"); 
    96 } 
    97 //----------------------------------------------------------------------- 
    98 void TestCullingTerrainApplication::setupGui( void ) 
     93        // HACK: necessary to call once before the content creation for 
     94        // terrain initialisation 
     95        mSceneMgr->_renderScene(mCamera, mWindow->getViewport(0), true); 
     96 
     97        mSceneContentGenerator = new TerrainContentGenerator(mSceneMgr); 
     98        mSceneContentGenerator->GenerateScene(300, "robot.mesh"); 
     99        // no limitations now: the user can set objects also on peaks 
     100        mSceneContentGenerator->SetMaxHeight(5000);  
     101} 
     102//----------------------------------------------------------------------- 
     103void TestCullingTerrainApplication::setupGui() 
    99104{ 
    100105         mGUIRenderer = new CEGUI::OgreCEGUIRenderer(mWindow, Ogre::RENDER_QUEUE_OVERLAY,  
    … …  
    111116} 
    112117//----------------------------------------------------------------------- 
    113 void TestCullingTerrainApplication::createFrameListener(void) 
    114 { 
    115         mFrameListener= new MouseQueryListener(mWindow, mCamera, mSceneMgr, mGUIRenderer); 
     118void TestCullingTerrainApplication::createFrameListener() 
     119{ 
     120        mFrameListener= new MouseQueryListener(mWindow, mCamera, mSceneMgr,  
     121                mGUIRenderer, mSceneContentGenerator); 
    116122        mFrameListener->showDebugOverlay(true); 
    117123        mRoot->addFrameListener(mFrameListener); 
    118124} 
    119125//----------------------------------------------------------------------- 
    120 void TestCullingTerrainApplication::chooseSceneManager(void) 
     126void TestCullingTerrainApplication::chooseSceneManager() 
    121127{ 
    122128        mSceneMgr = mRoot->getSceneManager(ST_EXTERIOR_CLOSE); 
    123129} 
    124  
    125130/***********************************************/ 
    126 /* MouseQueryListener implementation           */ 
     131/*      MouseQueryListener implementation      */ 
    127132/***********************************************/ 
    128133//----------------------------------------------------------------------- 
    129134MouseQueryListener::MouseQueryListener(RenderWindow* win, Camera* cam,  
    130135                                                                           SceneManager *sceneManager,  
    131                                                                            CEGUI::Renderer *renderer):  
     136                                                                           CEGUI::Renderer *renderer, 
     137                                                                           TerrainContentGenerator *sceneGenerator):  
    132138ExampleFrameListener(win, cam, false, true), mGUIRenderer(renderer),  
    133139mShutdownRequested(false) 
    … …  
    138144        mRMouseDown = false; 
    139145        mSceneMgr = sceneManager; 
     146        mSceneContentGenerator = sceneGenerator; 
    140147 
    141148    // Reduce move speed 
    … …  
    195202 
    196203                 // Setup the ray scene query 
    197          Ray mouseRay = mCamera->getCameraToViewportRay( e->getX(), e->getY() ); 
     204         Ray mouseRay = mCamera->getCameraToViewportRay(e->getX(), e->getY()); 
    198205    
    199206                 Vector3 queryResult; 
    200          // Get results, create a node/entity on the position 
    201                  if(mRayQueryExecutor->executeRayQuery(&queryResult, mouseRay)) 
    202          { 
    203                          char name[16]; 
    204              sprintf(name, "Robot%d", mCount++); 
    205  
    206              Entity *ent = mSceneMgr->createEntity(name, "robot.mesh"); 
    207              mCurrentObject = mSceneMgr->getRootSceneNode()-> 
    208                                  createChildSceneNode(String(name) + "Node", queryResult); 
    209              mCurrentObject->attachObject(ent); 
    210              mCurrentObject->setScale(0.1f, 0.1f, 0.1f); 
    211                           
    212          } 
    213  
     207                  
     208                 // Get results, create a node/entity on the position 
     209                 mCurrentObject = mSceneContentGenerator->GenerateSceneObject( 
     210                         mouseRay.getOrigin(), mouseRay.getDirection(), "robot.mesh"); 
     211                 
    214212         mLMouseDown = true;  
    215213     } 
    … …  
    249247                 if(mRayQueryExecutor->executeRayQuery(&queryResult, mouseRay)) 
    250248                 { 
    251                          mCurrentObject->setPosition(queryResult); 
     249                         if(mCurrentObject) 
     250                                 mCurrentObject->setPosition(queryResult); 
    252251                 } 
    253252     } 

  • trunk/VUT/work/TestCullingTerrain/TestCullingTerrainApplication.h

    r75 r80  
    3030 
    3131    MouseQueryListener(RenderWindow* win, Camera* cam, SceneManager *sceneManager,  
    32                 CEGUI::Renderer *renderer); 
     32                CEGUI::Renderer *renderer, TerrainContentGenerator *contentGenerator); 
    3333 
    34  
    35     ~MouseQueryListener( ); 
     34    ~MouseQueryListener(); 
    3635 
    3736        bool frameStarted(const FrameEvent& evt); 
    … …  
    8786 
    8887        RayQueryExecutor *mRayQueryExecutor; 
     88        TerrainContentGenerator *mSceneContentGenerator; 
    8989}; 
    9090 
    … …  
    111111        Vector3 mMaxAngle; 
    112112 
    113         TerrainContentGenerator *mTerrainContentGenerator; 
     113        TerrainContentGenerator *mSceneContentGenerator; 
    114114 
    115115private: 
Note: See TracChangeset for help on using the changeset viewer.