Changeset 121 for trunk/VUT


Ignore:
Timestamp:
06/08/05 17:44:48 (20 years ago)
Author:
mattausch
Message:
 
Location:
trunk/VUT
Files:
11 edited

Legend:

Unmodified
Added
Removed

  • trunk/VUT/Ogre/include/OgrePlatformHierarchyInterface.h

    r120 r121  
    8787        bool GetUseOptimization(); 
    8888 
     89        /** true if bounding box query is currently active. */ 
     90    bool IsBoundingBoxQuery(); 
     91 
    8992protected: 
    9093        /** materials for visualizing frustum and query culled nodes */ 
    … …  
    129132        bool mOnlyShadowCasters; 
    130133        bool mLeaveTransparentsInQueue; 
     134        bool mIsBoundingBoxQuery; 
    131135}; 
    132136 

  • trunk/VUT/Ogre/include/OgreVisibilityTerrainSceneManager.h

    r119 r121  
    5959        void WriteLog(); 
    6060 
    61         /** Override pass so we can do the z-fail pass */ 
     61        /** Override pass so we can do the z-fail pass.  
     62        */ 
    6263        Pass* setPass(Pass* pass); 
     64 
     65        /** Override from SceneManager so we can skip all but first pass for depth pass.  
     66        */ 
     67        bool validatePassForRendering(Pass* pass); 
    6368 
    6469protected: 

  • trunk/VUT/Ogre/resources/VisibilityDemo.overlay

    r120 r121  
    306306                        caption [F2] Show / Hide stats 
    307307                } 
     308                element TextArea(Example/Visibility/Help/AppStateInfo): Example/Visibility/Templates/BasicText 
     309                { 
     310                        left 5 
     311                        top 85 
     312                        width 180 
     313                        height 30 
     314                        caption [F3] Toggle between interactive / recorded walkthrough 
     315                } 
    308316                element TextArea(Example/Visibility/Help/RecordedInfo): Example/Visibility/Templates/BasicText 
    309317                { 
    … …  
    312320                        width 180 
    313321                        height 30 
    314                         caption [F3] Start / End frame recording 
    315                 } 
    316                 element TextArea(Example/Visibility/Help/AppStateInfo): Example/Visibility/Templates/BasicText 
    317                 { 
    318                         left 5 
    319                         top 85 
    320                         width 180 
    321                         height 30 
    322                         caption [F4] Toggle between interactive / recorded walkthrough 
     322                        caption [F4] Start / End frame recording 
    323323                } 
    324324                element TextArea(Example/Visibility/Help/ScreenshotsInfo): Example/Visibility/Templates/BasicText 

  • trunk/VUT/Ogre/src/OgrePlatformHierarchyInterface.cpp

    r120 r121  
    99//----------------------------------------------------------------------- 
    1010PlatformHierarchyInterface::PlatformHierarchyInterface(SceneManager *sm, RenderSystem *rsys): 
    11 mSceneManager(sm), mRenderSystem(rsys), mSolidBoundingBox(NULL), 
    12 mCamera(NULL), mCullCamera(NULL), mOnlyShadowCasters(false), mLeaveTransparentsInQueue(false) 
     11mSceneManager(sm), mRenderSystem(rsys), mSolidBoundingBox(NULL), mCamera(NULL),  
     12mCullCamera(NULL), mOnlyShadowCasters(false), mLeaveTransparentsInQueue(false), 
     13mIsBoundingBoxQuery(false) 
    1314{ 
    1415} 
    … …  
    8687         
    8788        // set no depth write, no color, no lighting material 
    88         //mSceneManager->setPass(solidBox->getTechnique()->getPass(0)); 
    89         SetOcclusionPass(); 
     89        mSceneManager->setPass(solidBox->getTechnique()->getPass(0)); 
     90        //SetOcclusionPass(); 
    9091 
    9192        solidBox->SetupBoundingBoxVertices(*box); 
    … …  
    130131{ 
    131132        GtpVisibility::HierarchyInterface::InitFrame(root); 
     133         
    132134        mPreviousNode = NULL; 
    133135        mLeaveTransparentsInQueue = leaveTransparentsInQueue; 
    134         SetCamera(cam); 
    135  
    136         if (cullCam) 
    137         { 
    138                 SetCullCamera(cullCam); 
    139         } 
    140         else 
    141         { 
    142                 SetCullCamera(cam); 
    143         } 
    144  
     136 
     137        mCamera = cam; 
     138        mCullCamera = cullCam ? cullCam : cam; 
     139 
     140        if (mCullCamera != mCamera) 
     141                LogManager::getSingleton().logMessage("cullcamera is not camera!"); 
     142 
     143        // create materials for node visualization 
    145144        CreateNodeVizMaterials(); 
    146145} 
    … …  
    186185        else 
    187186        { 
     187                mIsBoundingBoxQuery = true; 
    188188                //LogManager::getSingleton().logMessage("render box\n"); 
    189189                RenderBoundingBox(GetBoundingBox(node)); 
     190 
     191                mIsBoundingBoxQuery = false; 
    190192        } 
    191193 
    … …  
    238240        return mUseOptimization; 
    239241} 
     242//----------------------------------------------------------------------- 
     243bool PlatformHierarchyInterface::IsBoundingBoxQuery() 
     244{ 
     245        return mIsBoundingBoxQuery; 
     246} 
    240247} // namespace Ogre 

  • trunk/VUT/Ogre/src/OgreSceneContentGenerator.cpp

    r112 r121  
    160160        char objName[100]; 
    161161 
    162         if(!ifstr.is_open()) 
     162        if (!ifstr.is_open()) 
    163163                return false; 
    164164 
    … …  
    177177                                        orientation.getRoll().valueDegrees());*/ 
    178178 
    179                 (void)GenerateSceneObject(position, orientation, objName); 
     179                GenerateSceneObject(position, orientation, objName); 
    180180                 
    181                 std::stringstream d; 
    182                 d << StringConverter::toString(position) << " " << StringConverter::toString(orientation); 
    183                 LogManager::getSingleton().logMessage(d.str()); 
     181                //std::stringstream d; d << StringConverter::toString(position) << " " << StringConverter::toString(orientation); 
     182                //LogManager::getSingleton().logMessage(d.str()); 
    184183        } 
    185184        ifstr.close(); 

  • trunk/VUT/Ogre/src/OgreVisibilityOctreeSceneManager.cpp

    r120 r121  
    249249        // for delayed rendering: transparents, overlay  
    250250        clearSpecialCaseRenderQueues(); 
    251         SceneManager::_renderVisibleObjects(); 
     251        OctreeSceneManager::_renderVisibleObjects(); 
    252252         
    253253        WriteLog(); // write out stats 

  • trunk/VUT/Ogre/src/OgreVisibilitySceneManagerDll.cpp

    r120 r121  
    5757 
    5858        heightmapTerrainPageSource = new HeightmapTerrainPageSource(); 
    59         visibilityTerrainPlugin->registerPageSource("Heightmap", heightmapTerrainPageSource); 
    60  
    6159         
    6260        // Register 
    … …  
    6462        Root::getSingleton().setSceneManager(ST_EXTERIOR_CLOSE, visibilityTerrainPlugin); 
    6563        //Root::getSingleton().setSceneManager(ST_GENERIC, occlusionDotPlugin); 
     64 
     65        visibilityTerrainPlugin->registerPageSource("Heightmap", heightmapTerrainPageSource); 
    6666} 
    6767//----------------------------------------------------------------------- 
    68 extern "C" void dllStopPlugin(void) 
     68extern "C" void dllStopPlugin() 
    6969{ 
    7070        delete heightmapTerrainPageSource; 
    71    
     71 
    7272        delete visibilityOctreePlugin; 
    7373        delete visibilityTerrainPlugin; 
    7474        //delete occlusionDotPlugin; 
    75  
     75         
    7676        delete visManager; 
    7777        delete visEnv; 
    7878} 
     79//----------------------------------------------------------------------- 
     80extern "C" void dllShutdownPlugin() 
     81{ 
     82        visibilityTerrainPlugin->shutdown(); 
     83        heightmapTerrainPageSource->shutdown(); 
     84} 
    7985 
    8086} //namespace Ogre 

  • trunk/VUT/Ogre/src/OgreVisibilityTerrainSceneManager.cpp

    r120 r121  
    6363} 
    6464//----------------------------------------------------------------------- 
    65 /*Pass *VisibilityTerrainSceneManager::setPass(Pass* pass) 
    66 { 
    67         static bool myLastUsedVertexProgram = false; 
    68     static bool myLastUsedFragmentProgram = false; 
    69  
    70         // set depth fill pass only if depth write enabled 
    71         Pass *usedPass = pass; 
    72  
    73         if (mIsDepthPass && pass->getDepthWriteEnabled()) 
    74         { 
    75                 usedPass = mDepthPass;           
    76         } 
    77  
    78     if (mIlluminationStage == IRS_RENDER_TO_TEXTURE) 
    79     { 
    80         // Derive a special shadow caster pass from this one 
    81         usedPass = deriveShadowCasterPass(usedPass); 
    82     } 
    83     else if (mIlluminationStage == IRS_RENDER_MODULATIVE_PASS) 
    84     { 
    85         usedPass = deriveShadowReceiverPass(usedPass); 
    86     } 
    87  
    88         bool passSurfaceAndLightParams = true; 
    89  
    90         // take original pass here 
    91     if (usedPass->hasVertexProgram()) 
    92     { 
    93         mDestRenderSystem->bindGpuProgram(usedPass->getVertexProgram()->_getBindingDelegate()); 
    94         // bind parameters later since they can be per-object 
    95         myLastUsedVertexProgram = true; 
    96         // does the vertex program want surface and light params passed to rendersystem? 
    97         passSurfaceAndLightParams = usedPass->getVertexProgram()->getPassSurfaceAndLightStates(); 
    98     } 
    99     else 
    100     { 
    101         // Unbind program? 
    102         if (myLastUsedVertexProgram) 
    103         { 
    104             mDestRenderSystem->unbindGpuProgram(GPT_VERTEX_PROGRAM); 
    105             myLastUsedVertexProgram = false; 
    106         } 
    107         // Set fixed-function vertex parameters 
    108     } 
    109  
    110     if (passSurfaceAndLightParams) 
    111     { 
    112         // Set surface reflectance properties, only valid if lighting is enabled 
    113         if (usedPass->getLightingEnabled()) 
    114         { 
    115             mDestRenderSystem->_setSurfaceParams(  
    116                 usedPass->getAmbient(),  
    117                 usedPass->getDiffuse(),  
    118                 usedPass->getSpecular(),  
    119                 usedPass->getSelfIllumination(),  
    120                 usedPass->getShininess(), 
    121                                 usedPass->getVertexColourTracking() ); 
    122         } 
    123  
    124         // Dynamic lighting enabled? 
    125         mDestRenderSystem->setLightingEnabled(usedPass->getLightingEnabled()); 
    126     } 
    127  
    128     // Using a fragment program? 
    129     if (usedPass->hasFragmentProgram()) 
    130     { 
    131         mDestRenderSystem->bindGpuProgram( 
    132             usedPass->getFragmentProgram()->_getBindingDelegate()); 
    133         // bind parameters later since they can be per-object 
    134         myLastUsedFragmentProgram = true; 
    135     } 
    136     else 
    137     { 
    138         // Unbind program? 
    139         if (myLastUsedFragmentProgram) 
    140         { 
    141             mDestRenderSystem->unbindGpuProgram(GPT_FRAGMENT_PROGRAM); 
    142             myLastUsedFragmentProgram = false; 
    143         } 
    144  
    145         // Set fixed-function fragment settings 
    146  
    147         // Fog (assumes we want pixel fog which is the usual) 
    148         // New fog params can either be from scene or from material 
    149         FogMode newFogMode; 
    150         ColourValue newFogColour; 
    151         Real newFogStart, newFogEnd, newFogDensity; 
    152         if (usedPass->getFogOverride()) 
    153         { 
    154             // New fog params from material 
    155             newFogMode = usedPass->getFogMode(); 
    156             newFogColour = usedPass->getFogColour(); 
    157             newFogStart = usedPass->getFogStart(); 
    158             newFogEnd = usedPass->getFogEnd(); 
    159             newFogDensity = usedPass->getFogDensity(); 
    160         } 
    161         else 
    162         { 
    163             // New fog params from scene 
    164             newFogMode = mFogMode; 
    165             newFogColour = mFogColour; 
    166             newFogStart = mFogStart; 
    167             newFogEnd = mFogEnd; 
    168             newFogDensity = mFogDensity; 
    169         } 
    170         mDestRenderSystem->_setFog(newFogMode, newFogColour, newFogDensity, newFogStart, newFogEnd); 
    171  
    172         } 
    173  
    174     // The rest of the settings are the same no matter whether we use programs or not 
    175  
    176     // Set scene blending 
    177     mDestRenderSystem->_setSceneBlending( 
    178         usedPass->getSourceBlendFactor(), usedPass->getDestBlendFactor()); 
    179  
    180  
    181     // Texture unit settings 
    182  
    183     Pass::TextureUnitStateIterator texIter =  usedPass->getTextureUnitStateIterator(); 
    184     size_t unit = 0; 
    185     while(texIter.hasMoreElements()) 
    186     { 
    187         TextureUnitState* pTex = texIter.getNext(); 
    188         mDestRenderSystem->_setTextureUnitSettings(unit, *pTex); 
    189         ++unit; 
    190     } 
    191     // Disable remaining texture units 
    192     mDestRenderSystem->_disableTextureUnitsFrom(usedPass->getNumTextureUnitStates()); 
    193  
    194     // Set up non-texture related material settings 
    195     // Depth buffer settings 
    196     mDestRenderSystem->_setDepthBufferFunction(usedPass->getDepthFunction()); 
    197     mDestRenderSystem->_setDepthBufferCheckEnabled(usedPass->getDepthCheckEnabled()); 
    198     mDestRenderSystem->_setDepthBufferWriteEnabled(usedPass->getDepthWriteEnabled()); 
    199     mDestRenderSystem->_setDepthBias(usedPass->getDepthBias()); 
    200         // Alpha-reject settings 
    201         mDestRenderSystem->_setAlphaRejectSettings( 
    202                 usedPass->getAlphaRejectFunction(), usedPass->getAlphaRejectValue()); 
    203     // Set colour write mode 
    204     // Right now we only use on/off, not per-channel 
    205     bool colWrite = usedPass->getColourWriteEnabled(); 
    206     mDestRenderSystem->_setColourBufferWriteEnabled(colWrite, colWrite, colWrite, colWrite); 
    207     // Culling mode 
    208     mDestRenderSystem->_setCullingMode(usedPass->getCullingMode()); 
    209     // Shading 
    210     mDestRenderSystem->setShadingType(usedPass->getShadingMode()); 
    211  
    212         return usedPass; 
    213 }*/ 
    214 //----------------------------------------------------------------------- 
    21565void VisibilityTerrainSceneManager::ShowVisualization(Camera *cam) 
    21666{ 
    21767        // add player camera for visualization purpose 
    218         try { 
     68        try  
     69        { 
    21970                Camera *c; 
    22071                if ((c = getCamera("PlayerCam")) != NULL) 
    … …  
    22374                }    
    22475    } 
    225     catch(...) 
     76    catch (...) 
    22677    { 
    22778        // ignore 
    … …  
    24192                for (NodeList::iterator it = mVisible.begin(); it != mVisible.end(); ++it) 
    24293                { 
    243                          
    24494                        if (mRenderNodesForViz) 
    24595                        { 
    24696                                getRenderQueue()->addRenderable(*it); 
     97 
    24798                                // addbounding boxes instead of node itself 
    24899                                //(*it)->_addBoundingBoxToQueue(getRenderQueue()); 
    … …  
    250101                        if (mRenderNodesContentForViz)  
    251102                        { 
    252                                 (*it)->_addToRenderQueue(cam, getRenderQueue(), false); 
     103                                (*it)->_myAddToRenderQueue(cam, getRenderQueue(), false); 
    253104                        } 
    254105                } 
    255         } 
    256          
     106        }        
    257107} 
    258108//----------------------------------------------------------------------- 
    259109Pass *VisibilityTerrainSceneManager::setPass(Pass* pass) 
    260110{ 
    261         // setting vertex program is not efficient 
    262         //Pass *usedPass = ((mIsDepthPass && !pass->hasVertexProgram()) ? mDepthPass : pass);            
     111        //Pass *usedPass = ((mIsDepthPass && !pass->hasVertexProgram()) ? mDepthPass : pass); // setting vertex program is not efficient 
     112         
    263113        // set depth fill pass only if depth write enabled 
    264         Pass *usedPass = (mIsDepthPass && pass->getDepthWriteEnabled() ? mDepthPass : pass); 
     114        Pass *usedPass = (mIsDepthPass && !mHierarchyInterface->IsBoundingBoxQuery() ? mDepthPass : pass); 
     115                 
     116        IlluminationRenderStage savedStage = mIlluminationStage;  
     117         
     118        // set illumination stage to NONE so no shadow material is used  
     119        // for depth pass or for occlusion query 
     120        if (mIsDepthPass || mHierarchyInterface->IsBoundingBoxQuery()) 
     121        { 
     122                mIlluminationStage = IRS_NONE; 
     123        } 
    265124         
    266125        if (mIsDepthPass) 
    … …  
    286145                } 
    287146        } 
    288         /*else if (mIsItemBufferPass) 
    289         { 
    290                 usedPass = mItemBufferPass; 
    291         }*/ 
    292         SceneManager::setPass(usedPass); 
    293  
    294         return usedPass; 
     147        //else if (mIsItemBufferPass) {usedPass = mItemBufferPass;} 
     148         
     149        Pass *result = SceneManager::setPass(usedPass); 
     150 
     151        // reset illumination stage 
     152        mIlluminationStage = savedStage; 
     153 
     154        return result; 
    295155} 
    296156//----------------------------------------------------------------------- 
    … …  
    302162                ShowVisualization(cam); 
    303163        } 
    304         else  
    305         { 
    306                 mVisible.clear(); 
    307             mBoxes.clear(); 
    308                  
    309                 // if there is no depth pass => 
    310                 // we interleave identification and rendering of objects  
    311                 // in _renderVisibibleObjects 
    312  
    313                 // only shadow casters will be rendered in shadow texture pass 
    314                 mHierarchyInterface->SetOnlyShadowCasters(onlyShadowCasters); 
    315         } 
     164         
     165        mVisible.clear(); 
     166        mBoxes.clear(); 
     167         
     168        //TerrainSceneManager::_findVisibleObjects(cam, onlyShadowCasters);              
     169 
     170        // if there is no depth pass => 
     171        // we interleave identification and rendering of objects  
     172        // in _renderVisibibleObjects 
     173 
     174        // only shadow casters will be rendered in shadow texture pass 
     175        mHierarchyInterface->SetOnlyShadowCasters(onlyShadowCasters); 
     176 
     177        bool leaveTransparentsInQueue = mDelayRenderTransparents && !mUseDepthPass; 
     178 
     179        // possible two cameras (one for culling, one for rendering) 
     180        mHierarchyInterface->InitFrame(mOctree, cam, //mCameraInProgress,  
     181                                                mCullCamera ? getCamera("CullCamera") : NULL, 
     182                                                leaveTransparentsInQueue); 
    316183} 
    317184//----------------------------------------------------------------------- 
    318185void VisibilityTerrainSceneManager::_renderVisibleObjects() 
    319186{ 
    320         // create material for depth pass 
    321         InitDepthPass(); 
    322  
    323187        // visualization: apply standard rendering 
    324188        if (mShowVisualization) 
    … …  
    327191                return; 
    328192        } 
    329  
     193         
     194        // create material for depth pass 
     195        InitDepthPass(); 
    330196 
    331197        //-- hierarchical culling 
    … …  
    333199        // overlay) must be identified and rendered one after another 
    334200 
    335         bool leaveTransparentsInQueue = mDelayRenderTransparents && !mUseDepthPass; 
    336  
    337         // possible two cameras (one for culling, one for rendering) 
    338         mHierarchyInterface->InitFrame(mOctree, mCameraInProgress,  
    339                                                         mCullCamera ? getCamera("CullCamera") : NULL, 
    340                                                         leaveTransparentsInQueue); 
    341  
    342         // call initframe to reset culling manager stats 
     201        // frame initialisation to reset culling manager stats 
    343202        mVisibilityManager->GetCullingManager()->InitFrame(mVisualizeCulledNodes); 
    344203         
    … …  
    351210        setSpecialCaseRenderQueueMode(SceneManager::SCRQM_INCLUDE); 
    352211 
    353         SceneManager::_renderVisibleObjects(); 
     212        TerrainSceneManager::_renderVisibleObjects(); 
    354213 
    355214 
    … …  
    396255        // for delayed rendering: transparents, overlay  
    397256        clearSpecialCaseRenderQueues(); 
    398         SceneManager::_renderVisibleObjects(); 
    399  
     257        TerrainSceneManager::_renderVisibleObjects(); 
     258 
     259        getRenderQueue()->clear(); 
    400260        //WriteLog(); // write out stats 
    401261} 
    … …  
    517377            bool doLightIteration, const LightList* manualLightList) 
    518378{ 
     379        // for correct rendering, transparents must be rendered after hierarchical culling 
    519380        if (!mSkipTransparents) 
    520381        { 
    … …  
    522383        } 
    523384} 
     385//----------------------------------------------------------------------- 
     386bool VisibilityTerrainSceneManager::validatePassForRendering(Pass* pass) 
     387{ 
     388        // skip all but first pass if we are doing the depth pass 
     389        if (mIsDepthPass && pass->getIndex() > 0) 
     390        { 
     391                return false; 
     392        } 
     393        return SceneManager::validatePassForRendering(pass); 
     394} 
    524395 
    525396} // namespace Ogre 

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

    r120 r121  
    3737                                                                           TerrainContentGenerator *sceneGenerator, 
    3838                                                                           Camera *vizCamera, 
    39                                                                            SceneNode *camNode):  
     39                                                                           SceneNode *camNode, 
     40                                                                           Light *sunLight):  
    4041mCamera(cam), 
    4142mWindow(win), 
    … …  
    7778mShowHelp(false), 
    7879mDisplayCameraDetails(false), 
    79 mVisualizeCulledNodes(false) 
     80mVisualizeCulledNodes(false), 
     81mSunLight(sunLight) 
    8082{ 
    8183        mInputDevice = PlatformManager::getSingleton().createInputReader(); 
    … …  
    403405                writeFrames(); 
    404406                 
    405                 //-- write out stats 
     407                //-- write out stats for recorded walkthrough 
    406408                std::stringstream d; 
    407409                d << "Algorithm: " << mCurrentAlgorithmCaptions[mCurrentAlgorithm] << "\n" 
    … …  
    637639        mUseShadows = !mUseShadows; 
    638640 
    639         //mSunLight->setCastShadows(mUseShadows); 
     641        mSunLight->setCastShadows(mUseShadows); 
    640642 
    641643        if (mUseShadows) 
    … …  
    783785        KEY_PRESSED(KC_F2, 0.3, toggleShowStats()); 
    784786        KEY_PRESSED(KC_F3, 0.3, nextAppState()); 
    785          
    786         KEY_PRESSED(KC_F10, 0.3, toggleRecord()); 
     787        KEY_PRESSED(KC_F4, 0.3, toggleRecord()); 
     788 
    787789        KEY_PRESSED(KC_F11, 0.3, takeScreenShot()); 
    788790        KEY_PRESSED(KC_F12, 0.3, mTerrainContentGenerator->WriteObjects(objects_out_filename)); 

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

    r120 r121  
    2525   TerrainMouseQueryListener(RenderWindow* win, Camera* cam, SceneManager *sceneManager,  
    2626                CEGUI::Renderer *renderer, TerrainContentGenerator *contentGenerator, Camera *vizCamera, 
    27                 SceneNode *camNode); 
     27                SceneNode *camNode, Light *sunLight); 
    2828 
    2929   ~TerrainMouseQueryListener(); 
    … …  
    8484 
    8585   
    86  
    8786    // Constructor takes a RenderWindow because it uses that to determine input context 
    8887    //ExampleFrameListener(RenderWindow* win, Camera* cam, bool useBufferedInputKeys = false, bool useBufferedInputMouse = false) 
    … …  
    200199        Overlay* mHelpOverlay; 
    201200        Overlay* mCullStatsOverlay; 
     201 
     202        Light *mSunLight; 
    202203}; 
    203204 

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

    r120 r121  
    120120 
    121121        // Floor plane 
    122         /*Plane plane; 
     122        /* 
     123        Plane plane; 
    123124        plane.normal = Vector3::UNIT_Y; 
    124125        plane.d = -60; 
    … …  
    129130        pPlaneEnt->setMaterialName("Examples/Rockwall"); 
    130131        pPlaneEnt->setCastShadows(true); 
    131         mSceneMgr->getRootSceneNode()->createChildSceneNode()->attachObject(pPlaneEnt);*/ 
     132        mSceneMgr->getRootSceneNode()->createChildSceneNode()->attachObject(pPlaneEnt); 
     133        */ 
    132134 
    133135        if (mRoot->getRenderSystem()->getCapabilities()->hasCapability(RSC_HWRENDER_TO_TEXTURE)) 
    … …  
    191193{ 
    192194        mTerrainFrameListener = new TerrainMouseQueryListener(mWindow, mCamera, mSceneMgr,  
    193                 mGUIRenderer, mTerrainContentGenerator, mVizCamera, mCamNode); 
     195                mGUIRenderer, mTerrainContentGenerator, mVizCamera, mCamNode, mSunLight); 
    194196         
    195197        mRoot->addFrameListener(mTerrainFrameListener); 
Note: See TracChangeset for help on using the changeset viewer.