Changeset 657 for OGRE/trunk/ogre_changes

Timestamp:

02/20/06 19:06:03 (19 years ago)

Author:

mattausch

Message:

added ogre dependencies and patched ogre sources

Location:

OGRE/trunk/ogre_changes

Files:

• OgreMain/include/OgreFrustum.h (modified) (1 diff)
• OgreMain/include/OgreHardwareOcclusionQuery.h (modified) (3 diffs)
• OgreMain/include/OgreRenderQueueSortingGrouping.h (modified) (2 diffs)
• OgreMain/include/OgreRenderSystem.h (modified) (7 diffs)
• OgreMain/include/OgreSceneManager.h (modified) (8 diffs)
• OgreMain/src/OgreRenderSystem.cpp (modified) (4 diffs)
• OgreMain/src/OgreSceneManager.cpp (modified) (21 diffs)
• OgreMain/src/OgreSceneNode.cpp (modified) (4 diffs)
• Plugins/OctreeSceneManager/include/OgreTerrainRenderable.h (modified) (2 diffs)
• Plugins/OctreeSceneManager/src/OgreOctreeSceneManager.cpp (modified) (9 diffs)
• Plugins/OctreeSceneManager/src/OgreTerrainRenderable.cpp (modified) (5 diffs)
• RenderSystems/Direct3D7/include/OgreD3D7RenderWindow.h (modified) (2 diffs)
• RenderSystems/Direct3D7/include/OgreD3D7Texture.h (modified) (3 diffs)
• RenderSystems/Direct3D7/src/OgreD3D7RenderWindow.cpp (modified) (9 diffs)
• RenderSystems/Direct3D9/include/OgreD3D9HardwareOcclusionQuery.h (modified) (5 diffs)
• RenderSystems/Direct3D9/include/OgreD3D9Texture.h (modified) (4 diffs)
• RenderSystems/Direct3D9/src/OgreD3D9HardwareOcclusionQuery.cpp (modified) (1 diff)
• RenderSystems/Direct3D9/src/OgreD3D9RenderWindow.cpp (modified) (5 diffs)
• RenderSystems/GL/include/OgreGLHardwareOcclusionQuery.h (modified) (3 diffs)
• RenderSystems/GL/include/OgreGLTexture.h (modified) (2 diffs)
• RenderSystems/GL/src/OgreGLHardwareOcclusionQuery.cpp (modified) (2 diffs)
• RenderSystems/GL/src/OgreGLRenderSystem.cpp (modified) (18 diffs)
• RenderSystems/GL/src/OgreGLTexture.cpp (modified) (7 diffs)
• RenderSystems/GL/src/OgreWin32Window.cpp (modified) (2 diffs)

OGRE/trunk/ogre_changes/OgreMain/include/OgreFrustum.h

@@ -445 +445 @@
                 /** Disables any custom near clip plane. */
                 virtual void disableCustomNearClipPlane(void);
+                /** Is a custom near clip plane in use? */
+                virtual bool isCustomNearClipPlaneEnabled(void) const 
+                { return mObliqueDepthProjection; }
                 
 

OGRE/trunk/ogre_changes/OgreMain/include/OgreHardwareOcclusionQuery.h

@@ -46 +46 @@
   *
   * @author Lee Sandberg
+  * Updated on 4/8/2005 by Tuan Kuranes email: tuan.kuranes@free.fr
   */
 class _OgreExport HardwareOcclusionQuery
@@ -82 +83 @@
           *                             UINT    m_uintNumberOfPixelsVisable;
           *                             pullOcclusionQuery( &m_dwNumberOfPixelsVisable );
-          *                             You may not get the result directlly after the first pass or frame.
-          *                             Objects not visable must be tested every frame, visable objects may be tested less freqvent.
+          *                             You may not get the result directly after the first pass or frame.
+          *                             Objects not visible must be tested every frame, visible objects may be tested less frequently.
           *                     
           */
@@ -112 +113 @@
           *   
           * @Remarks This function allows you to set how often the hardware occlusion really are sent to the driver
-          * if you set it to 0 every hw occlusion test is acctually made. If you set it to 1 only the half of your queries are sent 
-          * for all visable objects. 2 will result in 25% of all queries to acctualy be sent. 
-          * New and none visable objects will be tested all the time.
-          * This functionality is here because this class can keep track on visable and none visable objects for you.
+          * if you set it to 0 every hardware occlusion test is actually made. If you set it to 1 only the half of your queries are sent 
+          * for all visible objects. 2 will result in 25% of all queries to actually be sent. 
+          * New and none visible objects will be tested all the time.
+          * This functionality is here because this class can keep track on visible and none visible objects for you.
           * Once you you set the SkipRate for any hardware occlusion instance it effects all others.
           */

OGRE/trunk/ogre_changes/OgreMain/include/OgreRenderQueueSortingGrouping.h

@@ -316 +316 @@
         }
 
-        /** Clears this group of renderables. 
-        @remarks
-            Doesn't delete any priority groups, just empties them. Saves on 
+       /** Clears this group of renderables. 
+        @param destroy
+            If false, doesn't delete any priority groups, just empties them. Saves on 
             memory deallocations since the chances are rougly the same kinds of 
-            renderables are going to be sent to the queue again next time.
-        */
-        void clear(void)
+            renderables are going to be sent to the queue again next time. If
+                        true, completely destroys.
+        */
+        void clear(bool destroy = false)
         {
             PriorityMap::iterator i, iend;
@@ -328 +329 @@
             for (i = mPriorityGroups.begin(); i != iend; ++i)
             {
-                i->second->clear();
-            }
-
-        }
+                                if (destroy)
+                                        delete i->second;
+                                else
+                                        i->second->clear();
+            }
+
+                        if (destroy)
+                                mPriorityGroups.clear();
+
+        }
+
 #ifdef GTP_VISIBILITY_MODIFIED_OGRE     
                 void clear(int passes)

OGRE/trunk/ogre_changes/OgreMain/include/OgreRenderSystem.h

@@ -42 +42 @@
 #include "OgreGpuProgram.h"
 #include "OgrePlane.h"
+#include "OgreIteratorWrappers.h"
 
 namespace Ogre
@@ -173 +174 @@
         virtual void setConfigOption(const String &name, const String &value) = 0;
 
-                virtual HardwareOcclusionQuery* createHardwareOcclusionQuery() = 0;
+                /** Create an object for performing hardware occlusion queries. 
+                */
+                virtual HardwareOcclusionQuery* createHardwareOcclusionQuery(void) = 0;
+
+                /** Destroy a hardware occlusion query object. 
+                */
+                virtual void destroyHardwareOcclusionQuery(HardwareOcclusionQuery *hq);
 
         /** Validates the options set for the rendering system, returning a message if there are problems.
@@ -295 +302 @@
                                 Description: External window handle, for embedding the OGRE context
                                 Values: positive integer for W32 (HWND handle)
-                                        posint:posint:posint for GLX (display:screen:windowHandle)
+                                        poslong:posint:poslong (display*:screen:windowHandle) or
+                                        poslong:posint:poslong:poslong (display*:screen:windowHandle:XVisualInfo*) for GLX
                                 Default: 0 (None)
                                 **
@@ -301 +309 @@
                                 Description: Parent window handle, for embedding the OGRE context
                                 Values: positive integer for W32 (HWND handle)
-                                        posint:posint:posint for GLX (display:screen:windowHandle)
+                                        poslong:posint:poslong for GLX (display*:screen:windowHandle)
                                 Default: 0 (None)
                                 **
@@ -392 +400 @@
         virtual RenderTarget * detachRenderTarget( const String &name );
 
+                /// Iterator over RenderTargets
+                typedef MapIterator<Ogre::RenderTargetMap> RenderTargetIterator;
+
+                /** Returns a specialised MapIterator over all render targets attached to the RenderSystem. */
+                virtual RenderTargetIterator getRenderTargetIterator(void) {
+                        return RenderTargetIterator( mRenderTargets.begin(), mRenderTargets.end() );
+                }
         /** Returns a description of an error code.
         */
@@ -947 +962 @@
         virtual Real getMaximumDepthInputValue(void) = 0;
 
+                /** Defines a listener on the custom events that this render system 
+                        can raise.
+                @see RenderSystem::addListener
+                */
+                class _OgreExport Listener
+                {
+                public:
+                        Listener() {}
+                        virtual ~Listener() {}
+
+                        /** A rendersystem-specific event occurred.
+                        @param eventName The name of the event which has occurred
+                        @param parameters A list of parameters that may belong to this event,
+                                may be null if there are no parameters
+                        */
+                        virtual void eventOccurred(const String& eventName, 
+                                const NameValuePairList* parameters = 0) = 0;
+                };
+                /** Adds a listener to the custom events that this render system can raise.
+                @remarks
+                        Some render systems have quite specific, internally generated events 
+                        that the application may wish to be notified of. Many applications
+                        don't have to worry about these events, and can just trust OGRE to 
+                        handle them, but if you want to know, you can add a listener here.
+                @par
+                        Events are raised very generically by string name. Perhaps the most 
+                        common example of a render system specific event is the loss and 
+                        restoration of a device in DirectX; which OGRE deals with, but you 
+                        may wish to know when it happens. 
+                @see RenderSystem::getRenderSystemEvents
+                */
+                virtual void addListener(Listener* l);
+                /** Remove a listener to the custom events that this render system can raise.
+                */
+                virtual void removeListener(Listener* l);
+
+                /** Gets a list of the rendersystem specific events that this rendersystem
+                        can raise.
+                @see RenderSystem::addListener
+                */
+                virtual const StringVector& getRenderSystemEvents(void) const { return mEventNames; }
     protected:
 
@@ -984 +1040 @@
 
         bool mInvertVertexWinding;
+
+                /// List of names of events this rendersystem may raise
+                StringVector mEventNames;
+
+                /// Internal method for firing a rendersystem event
+                virtual void fireEvent(const String& name, const NameValuePairList* params = 0);
+
+                typedef std::list<Listener*> ListenerList;
+                ListenerList mEventListeners;
+
+                typedef std::list<HardwareOcclusionQuery*> HardwareOcclusionQueryList;
+                HardwareOcclusionQueryList mHwOcclusionQueries;
+
+
     };
 }

OGRE/trunk/ogre_changes/OgreMain/include/OgreSceneManager.h

@@ -271 +271 @@
         */
         virtual void initRenderQueue(void);
-        /** Retrieves the internal render queue. */
-        virtual RenderQueue* getRenderQueue(void);
-
         /** Internal method for setting up the renderstate for a rendering pass.
             @param
@@ -282 +279 @@
         */
         virtual Pass* setPass(Pass* pass);
-
         /// A pass designed to let us render shadow colour on white for texture shadows
         Pass* mShadowCasterPlainBlackPass;
@@ -429 +425 @@
         virtual void createShadowTextures(unsigned short size, unsigned short count, 
                         PixelFormat fmt);
+        /// Internal method for destroying shadow textures (texture-based shadows)
+        virtual void destroyShadowTextures(void);
         /// Internal method for preparing shadow textures ready for use in a regular render
         virtual void prepareShadowTextures(Camera* cam, Viewport* vp);
@@ -582 +580 @@
 
         /** Removes (and destroys) all cameras from the scene.
+            @remarks
+                Some cameras are internal created to dealing with texture shadow,
+                their aren't supposed to destroy outside. So, while you are using
+                texture shadow, don't call this method, or you can set the shadow
+                technique other than texture-based, which will destroy all internal
+                created shadow cameras and textures.
         */
         virtual void removeAllCameras(void);
@@ -1025 +1029 @@
             const String& groupName = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
 
+                /** Return whether a key plane is enabled */
+                virtual bool isSkyPlaneEnabled(void) const { return mSkyPlaneEnabled; }
+
+                /** Get the sky plane node, if enabled. */
+                virtual SceneNode* getSkyPlaneNode(void) { return mSkyPlaneNode; }              
+
         /** Enables / disables a 'sky box' i.e. a 6-sided box at constant
             distance from the camera representing the sky.
@@ -1070 +1080 @@
             bool drawFirst = true, const Quaternion& orientation = Quaternion::IDENTITY,
             const String& groupName = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
+
+                /** Return whether a skybox is enabled */
+                virtual bool isSkyBoxEnabled(void) const { return mSkyBoxEnabled; }
+
+                /** Get the skybox node, if enabled. */
+                virtual SceneNode* getSkyBoxNode(void) const { return mSkyBoxNode; }
 
         /** Enables / disables a 'sky dome' i.e. an illusion of a curved sky.
@@ -1132 +1148 @@
             int xsegments = 16, int ysegments = 16, int ysegments_keep = -1,
             const String& groupName = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
+
+                /** Return whether a skydome is enabled */
+                virtual bool isSkyDomeEnabled(void) const { return mSkyDomeEnabled; }
+
+                /** Get the sky dome node, if enabled. */
+                virtual SceneNode* getSkyDomeNode(void) { return mSkyDomeNode; }                
 
         /** Sets the fogging mode applied to the scene.
@@ -1340 +1362 @@
             const Matrix4& worldMatrix, const Matrix4& viewMatrix, const Matrix4& projMatrix, 
             bool doBeginEndFrame = false) ;
+
+        /** Retrieves the internal render queue, for advanced users only.
+        @remarks
+            The render queue is mainly used internally to manage the scene object 
+                        rendering queue, it also exports some methods to allow advanced users 
+                        to configure the behavior of rendering process.
+            Most methods provided by RenderQueue are supposed to be used 
+                        internally only, you should reference to the RenderQueue API for 
+                        more information. Do not access this directly unless you know what 
+                        you are doing.
+        */
+        virtual RenderQueue* getRenderQueue(void);
 
         /** Registers a new RenderQueueListener which will be notified when render queues

OGRE/trunk/ogre_changes/OgreMain/src/OgreRenderSystem.cpp

@@ -40 +40 @@
 #include "OgreMaterial.h"
 #include "OgreTimer.h"
+#include "OgreHardwareOcclusionQuery.h"
 
 namespace Ogre {
@@ -69 +70 @@
     {
         shutdown();
+                delete mCapabilities;
+                mCapabilities = 0;
     }
     //-----------------------------------------------------------------------
@@ -324 +327 @@
     void RenderSystem::shutdown(void)
     {
+                // Remove occlusion queries
+                for (HardwareOcclusionQueryList::iterator i = mHwOcclusionQueries.begin();
+                        i != mHwOcclusionQueries.end(); ++i)
+                {
+                        delete *i;
+                }
+                mHwOcclusionQueries.clear();
+
         // Remove all the render targets.
                 // (destroy primary target last since others may depend on it)
@@ -416 +427 @@
         }
     }
+        //-----------------------------------------------------------------------
+        void RenderSystem::addListener(Listener* l)
+        {
+                mEventListeners.push_back(l);
+        }
+        //-----------------------------------------------------------------------
+        void RenderSystem::removeListener(Listener* l)
+        {
+                mEventListeners.remove(l);
+        }
+        //-----------------------------------------------------------------------
+        void RenderSystem::fireEvent(const String& name, const NameValuePairList* params)
+        {
+                for(ListenerList::iterator i = mEventListeners.begin(); 
+                        i != mEventListeners.end(); ++i)
+                {
+                        (*i)->eventOccurred(name, params);
+                }
+        }
+        //-----------------------------------------------------------------------
+        void RenderSystem::destroyHardwareOcclusionQuery( HardwareOcclusionQuery *hq)
+        {
+                for (HardwareOcclusionQueryList::iterator i = mHwOcclusionQueries.begin();
+                        i != mHwOcclusionQueries.end(); ++i)
+                {
+                        if (*i == hq)
+                        {
+                                delete *i;
+                                mHwOcclusionQueries.erase(i);
+                                break;
+                        }
+                }
+        }
+
 }
 

OGRE/trunk/ogre_changes/OgreMain/src/OgreSceneManager.cpp

@@ -375 +375 @@
     // Subclasses could do something smarter
     destList.clear();
-    Real squaredRadius = radius * radius;
 
     SceneLightList::iterator i, iend;
@@ -396 +395 @@
                 // only add in-range lights
                 Real range = lt->getAttenuationRange();
-                if ((lt->tempSquareDist - squaredRadius) <= (range * range))
+                Real maxDist = range + radius;
+                if (lt->tempSquareDist <= Math::Sqr(maxDist))
                 {
                     destList.push_back(lt);
@@ -554 +554 @@
     mSkyBoxEnabled = mSkyPlaneEnabled = mSkyDomeEnabled = false; 
 
+        // Clear render queue, empty completely
+        if (mRenderQueue)
+                mRenderQueue->clear(true);
+
 }
 //-----------------------------------------------------------------------
@@ -593 +597 @@
     AutoTrackingSceneNodes::iterator ai, aiend;
     aiend = mAutoTrackingSceneNodes.end();
-    for (ai = mAutoTrackingSceneNodes.begin(); ai != aiend; ++ai)
-    {
-        SceneNode* n = *ai;
+    for (ai = mAutoTrackingSceneNodes.begin(); ai != aiend; )
+    {
+                // Pre-increment incase we delete
+                AutoTrackingSceneNodes::iterator curri = ai++;
+        SceneNode* n = *curri;
         // Tracking this node
         if (n->getAutoTrackTarget() == i->second)
@@ -601 +607 @@
             // turn off, this will notify SceneManager to remove
             n->setAutoTracking(false);
-            // no need to reset iterator since set erase does not invalidate
         }
         // node is itself a tracker
         else if (n == i->second)
         {
-            mAutoTrackingSceneNodes.erase(ai);
+            mAutoTrackingSceneNodes.erase(curri);
         }
     }
@@ -814 +819 @@
     if (thisFrameNumber != lastFrameNumber)
     {
+        // Update controllers 
+        ControllerManager::getSingleton().updateAllControllers();
         // Update animations
         _applySceneAnimations();
-        // Update controllers 
-        ControllerManager::getSingleton().updateAllControllers();
         lastFrameNumber = thisFrameNumber;
     }
@@ -868 +873 @@
     }
 
+    // Tell params about viewport
+    mAutoParamDataSource.setCurrentViewport(vp);
     // Set the viewport
     setViewport(vp);
@@ -1409 +1416 @@
             {
                 // Someone requested we skip this queue
-                continue;
+                break;
             }
 
@@ -1713 +1720 @@
             mShadowReceiverPass->_load();
 
-            if (l->getCastShadows() && pGroup->getShadowsEnabled())
+            if (l->getCastShadows())
             {
                 renderTextureShadowReceiverQueueGroupObjects(pGroup);
@@ -1876 +1883 @@
         {
             // Ordinary pass
+            if (pGroup->getShadowsEnabled())
             renderModulativeTextureShadowedQueueGroupObjects(pGroup);
+                        else
+                                renderBasicQueueGroupObjects(pGroup);
         }
     }
@@ -2118 +2128 @@
 {
     mAmbientLight = colour;
-    mDestRenderSystem->setAmbientLight(colour.r, colour.g, colour.b);
 }
 //-----------------------------------------------------------------------
@@ -2656 +2665 @@
     {
         createShadowTextures(mShadowTextureSize, mShadowTextureCount, mShadowTextureFormat);
+    }
+    else
+    {
+        // Destroy shadow textures to optimise resource usage
+        destroyShadowTextures();
     }
 
@@ -2764 +2778 @@
         const Vector3* corners = camera->getWorldSpaceCorners();
         Vector3 min, max;
-        Vector3 extrude = light->getDirection() * -mShadowDirLightExtrudeDist;
+        Vector3 extrude = light->getDerivedDirection() * -mShadowDirLightExtrudeDist;
         // do first corner
         min = max = corners[0];
@@ -2792 +2806 @@
     else
     {
-        Sphere s(light->getPosition(), light->getAttenuationRange());
+        Sphere s(light->getDerivedPosition(), light->getAttenuationRange());
         // eliminate early if camera cannot see light sphere
         if (camera->isVisible(s))
@@ -2875 +2889 @@
         {
             mShadowDebugPass = matDebug->getTechnique(0)->getPass(0);
+
+            if (mDestRenderSystem->getCapabilities()->hasCapability(RSC_VERTEX_PROGRAM))
+            {
+                mInfiniteExtrusionParams = mShadowDebugPass->getVertexProgramParameters();
+            }
         }
     }
@@ -2915 +2934 @@
         {
             mShadowStencilPass = matStencil->getTechnique(0)->getPass(0);
+
+            if (mDestRenderSystem->getCapabilities()->hasCapability(RSC_VERTEX_PROGRAM))
+            {
+                mFiniteExtrusionParams = mShadowStencilPass->getVertexProgramParameters();
+            }
         }
     }
@@ -3029 +3053 @@
 Pass* SceneManager::deriveShadowCasterPass(Pass* pass)
 {
+        Pass* retPass = 0;
     switch (mShadowTechnique)
     {
     case SHADOWTYPE_TEXTURE_MODULATIVE:
-                if (mShadowTextureCustomCasterPass)
+                retPass = mShadowTextureCustomCasterPass ? 
+                        mShadowTextureCustomCasterPass : mShadowCasterPlainBlackPass;
+
+
+                // Special case alpha-blended passes
+                if ((pass->getSourceBlendFactor() == SBF_SOURCE_ALPHA && 
+                        pass->getDestBlendFactor() == SBF_ONE_MINUS_SOURCE_ALPHA) 
+                        || pass->getAlphaRejectFunction() != CMPF_ALWAYS_PASS)
                 {
-                        // Caster pass has been customised
+                        // Alpha blended passes must retain their transparency
+                        retPass->setAlphaRejectSettings(pass->getAlphaRejectFunction(), 
+                                pass->getAlphaRejectValue());
+                        retPass->setSceneBlending(pass->getSourceBlendFactor(), pass->getDestBlendFactor());
+                        retPass->getParent()->getParent()->setTransparencyCastsShadows(true);
+
+                        // So we allow the texture units, but override the colour functions
+                        // Copy texture state, shift up one since 0 is shadow texture
+                        size_t origPassTUCount = pass->getNumTextureUnitStates();
+                        for (size_t t = 0; t < origPassTUCount; ++t)
+                        {
+                                TextureUnitState* tex;
+                                if (retPass->getNumTextureUnitStates() <= t)
+                                {
+                                        tex = retPass->createTextureUnitState();
+                                }
+                                else
+                                {
+                                        tex = retPass->getTextureUnitState(t);
+                                }
+                                // copy base state
+                                (*tex) = *(pass->getTextureUnitState(t));
+                                // override colour function
+                                tex->setColourOperationEx(LBX_SOURCE1, LBS_MANUAL, LBS_CURRENT,
+                                        mShadowColour);
+
+                        }
+                        // Remove any extras
+                        while (retPass->getNumTextureUnitStates() > origPassTUCount)
+                        {
+                                retPass->removeTextureUnitState(origPassTUCount);
+                        }
+
+                }
+                else
+                {
+                        // reset
+                        retPass->setSceneBlending(SBF_ONE, SBF_ZERO);
+                        retPass->setAlphaRejectFunction(CMPF_ALWAYS_PASS);
+                        while (retPass->getNumTextureUnitStates() > 0)
+                        {
+                                retPass->removeTextureUnitState(0);
+                        }
+                }
+
+                // Propagate culling modes
+                retPass->setCullingMode(pass->getCullingMode());
+                retPass->setManualCullingMode(pass->getManualCullingMode());
+
 
                         if (!pass->getShadowCasterVertexProgramName().empty())
                         {
                                 // Have to merge the shadow caster vertex program in
-                                mShadowTextureCustomCasterPass->setVertexProgram(
+                        retPass->setVertexProgram(
                                         pass->getShadowCasterVertexProgramName());
-                                const GpuProgramPtr& prg = mShadowTextureCustomCasterPass->getVertexProgram();
+                        const GpuProgramPtr& prg = retPass->getVertexProgram();
                                 // Load this program if not done already
                                 if (!prg->isLoaded())
                                         prg->load();
                                 // Copy params
-                                mShadowTextureCustomCasterPass->setVertexProgramParameters(
+                        retPass->setVertexProgramParameters(
                                         pass->getShadowCasterVertexProgramParameters());
+                        if (retPass == mShadowTextureCustomCasterPass)
+                        {
                                 // mark that we've overridden the standard
                                 mShadowTextureCasterVPDirty = true;
+                        }
                                 // Also have to hack the light autoparams, that is done later
                         }
-                        else if (mShadowTextureCasterVPDirty)
+                else 
+                {
+                        retPass->setVertexProgram(StringUtil::BLANK);
+                        if (mShadowTextureCasterVPDirty)
                         {
                                 // reset
@@ -3065 +3151 @@
                                 mShadowTextureCasterVPDirty = false;
                         }
-                        return mShadowTextureCustomCasterPass;
                 }
-                else
-                {
-                        // Standard pass
-                        if (pass->hasVertexProgram())
-                        {
-                                // Have to merge the shadow caster vertex program in
-                                // This may in fact be blank, in which case it falls back on 
-                                // fixed function
-                                mShadowCasterPlainBlackPass->setVertexProgram(
-                                        pass->getShadowCasterVertexProgramName());
-                                // Did this result in a new vertex program?
-                                if (mShadowCasterPlainBlackPass->hasVertexProgram())
-                                {
-                                        const GpuProgramPtr& prg = mShadowCasterPlainBlackPass->getVertexProgram();
-                                        // Load this program if not done already
-                                        if (!prg->isLoaded())
-                                                prg->load();
-                                        // Copy params
-                                        mShadowCasterPlainBlackPass->setVertexProgramParameters(
-                                                pass->getShadowCasterVertexProgramParameters());
-                                }
-                                // Also have to hack the light autoparams, that is done later
-                        }
-                        else if (mShadowCasterPlainBlackPass->hasVertexProgram())
-                        {
-                                // reset
-                                mShadowCasterPlainBlackPass->setVertexProgram("");
-                        }
-                        return mShadowCasterPlainBlackPass;
-                }
+                return retPass;
     default:
         return pass;
@@ -3301 +3357 @@
         {
         ShadowCaster* caster = *si;
-                bool zfailAlgo = false;
+                bool zfailAlgo = camera->isCustomNearClipPlaneEnabled();
                 unsigned long flags = 0;
 
@@ -3705 +3761 @@
 
     // destroy existing
-    ShadowTextureList::iterator i, iend;
-    iend = mShadowTextures.end();
-    for (i = mShadowTextures.begin(); i != iend; ++i)
-    {
-        RenderTexture* r = *i;
-        // remove camera and destroy texture
-        removeCamera(r->getViewport(0)->getCamera());
-        mDestRenderSystem->destroyRenderTexture(r->getName());
-    }
-    mShadowTextures.clear();
+        destroyShadowTextures();
 
     // Recreate shadow textures
@@ -3762 +3809 @@
 
     }
+}
+//---------------------------------------------------------------------
+void SceneManager::destroyShadowTextures(void)
+{
+    ShadowTextureList::iterator i, iend;
+    iend = mShadowTextures.end();
+    for (i = mShadowTextures.begin(); i != iend; ++i)
+    {
+        RenderTexture* r = *i;
+        // remove camera and destroy texture
+        removeCamera(r->getViewport(0)->getCamera());
+        mDestRenderSystem->destroyRenderTexture(r->getName());
+    }
+    mShadowTextures.clear();
 }
 //---------------------------------------------------------------------

OGRE/trunk/ogre_changes/OgreMain/src/OgreSceneNode.cpp

@@ -296 +296 @@
             {
                 SceneNode* sceneChild = static_cast<SceneNode*>(child->second);
-                sceneChild->_findVisibleObjects(cam, queue, includeChildren, displayNodes);
+                sceneChild->_findVisibleObjects(cam, queue, includeChildren, 
+                                        displayNodes, onlyShadowCasters);
             }
         }
@@ -391 +392 @@
         ChildNodeMap::iterator i, iend;
         iend = mChildren.end();
-        for (i = mChildren.begin(); i != iend; ++i)
+        for (i = mChildren.begin(); i != iend;)
         {
             SceneNode* sn = static_cast<SceneNode*>(i->second);
+                        // increment iterator before destroying (iterator invalidated by 
+                        // SceneManager::destroySceneNode because it causes removal from parent)
+                        ++i;
             sn->removeAndDestroyAllChildren();
             sn->getCreator()->destroySceneNode(sn->getName());
@@ -482 +486 @@
         if (vec == Vector3::ZERO) return;
 
-        // Adjust vector so that it is relative to local Z
-        Vector3 zAdjustVec;
-        if (localDirectionVector == Vector3::NEGATIVE_UNIT_Z)
-        {
-            zAdjustVec = -vec;
-        }
-        else
-        {
-            Quaternion localToUnitZ = localDirectionVector.getRotationTo(Vector3::UNIT_Z);
-            zAdjustVec = localToUnitZ * vec;
-        }
-        zAdjustVec.normalise();
-
+        // The direction we want the local direction point to
+        Vector3 targetDir = vec.normalisedCopy();
+
+        // Transform target direction to world space
+        switch (relativeTo)
+        {
+        case TS_PARENT:
+            if (mParent)
+                targetDir = mParent->_getDerivedOrientation() * targetDir;
+            break;
+        case TS_LOCAL:
+            targetDir = _getDerivedOrientation() * targetDir;
+            break;
+        }
+
+        // Calculate target orientation relative to world space
         Quaternion targetOrientation;
         if( mYawFixed )
         {
-            Vector3 xVec = mYawFixedAxis.crossProduct( zAdjustVec );
+            // Calculate the quaternion for rotate local Z to target direction
+            Vector3 xVec = mYawFixedAxis.crossProduct(targetDir);
             xVec.normalise();
-
-            Vector3 yVec = zAdjustVec.crossProduct( xVec );
+            Vector3 yVec = targetDir.crossProduct(xVec);
             yVec.normalise();
+            Quaternion unitZToTarget = Quaternion(xVec, yVec, targetDir);
             
-            targetOrientation.FromAxes( xVec, yVec, zAdjustVec );
+            if (localDirectionVector == Vector3::NEGATIVE_UNIT_Z)
+            {
+                // Specail case for avoid calculate 180 degree turn
+                targetOrientation =
+                    Quaternion(-unitZToTarget.y, -unitZToTarget.z, unitZToTarget.w, unitZToTarget.x);
         }
         else
         {
-
-            // Get axes from current quaternion
-            Vector3 axes[3];
-            _getDerivedOrientation().ToAxes(axes);
-            Quaternion rotQuat;
-            if ( (axes[2]+zAdjustVec).squaredLength() <  0.00005f)
+                // Calculate the quaternion for rotate local direction to target direction
+                Quaternion localToUnitZ = localDirectionVector.getRotationTo(Vector3::UNIT_Z);
+                targetOrientation = unitZToTarget * localToUnitZ;
+            }
+            }
+            else
             {
+            const Quaternion& currentOrient = _getDerivedOrientation();
+
+            // Get current local direction relative to world space
+            Vector3 currentDir = currentOrient * localDirectionVector;
+
+            if ((currentDir+targetDir).squaredLength() < 0.00005f)
+        {
                 // Oops, a 180 degree turn (infinite possible rotation axes)
                 // Default to yaw i.e. use current UP
-                rotQuat.FromAngleAxis(Radian(Math::PI), axes[1]);
-            }
-            else
-            {
+                targetOrientation =
+                    Quaternion(-currentOrient.y, -currentOrient.z, currentOrient.w, currentOrient.x);
+        }
+        else
+        {
                 // Derive shortest arc to new direction
-                rotQuat = axes[2].getRotationTo(zAdjustVec);
-
-            }
-            targetOrientation = rotQuat * mOrientation;
-        }
-
-        if (relativeTo == TS_LOCAL || !mParent)
-        {
+                Quaternion rotQuat = currentDir.getRotationTo(targetDir);
+                targetOrientation = rotQuat * currentOrient;
+            }
+        }
+
+        // Set target orientation, transformed to parent space
+        if (mParent)
+            setOrientation(mParent->_getDerivedOrientation().UnitInverse() * targetOrientation);
+        else
             setOrientation(targetOrientation);
-        }
-        else
-        {
-            if (relativeTo == TS_PARENT)
-            {
-                setOrientation(targetOrientation * mParent->getOrientation().Inverse());
-            }
-            else if (relativeTo == TS_WORLD)
-            {
-                setOrientation(targetOrientation * mParent->_getDerivedOrientation().Inverse());
-            }
-        }
-
-
     }
     //-----------------------------------------------------------------------
@@ -550 +557 @@
         const Vector3& localDirectionVector)
     {
-        this->setDirection(targetPoint - _getDerivedPosition(), relativeTo, 
-            localDirectionVector);
+        // Calculate ourself origin relative to the given transform space
+        Vector3 origin;
+        switch (relativeTo)
+        {
+        default:    // Just in case
+        case TS_WORLD:
+            origin = _getDerivedPosition();
+            break;
+        case TS_PARENT:
+            origin = mPosition;
+            break;
+        case TS_LOCAL:
+            origin = Vector3::ZERO;
+            break;
+        }
+
+        setDirection(targetPoint - origin, relativeTo, localDirectionVector);
     }
     //-----------------------------------------------------------------------

OGRE/trunk/ogre_changes/Plugins/OctreeSceneManager/include/OgreTerrainRenderable.h

@@ -290 +290 @@
 
         /** Overridden from MovableObject */
-        Real getBoundingRadius(void) const { return 0; /* not needed */ }
+        Real getBoundingRadius(void) const { return mBoundingRadius; }
 
         /** @copydoc Renderable::getLights */
@@ -383 +383 @@
         /// Connection to tiles four neighbours
         TerrainRenderable *mNeighbors [ 4 ];
+        /// Whether light list need to re-calculate
+        mutable bool mLightListDirty;
+        /// Cached light list
+        mutable LightList mLightList;
+        /// The bounding radius of this tile
+        Real mBoundingRadius;
         /// Bounding box of this tile
         AxisAlignedBox mBounds;

OGRE/trunk/ogre_changes/Plugins/OctreeSceneManager/src/OgreOctreeSceneManager.cpp

@@ -536 +536 @@
 SceneNode * OctreeSceneManager::createSceneNode( const String &name )
 {
+    // Check name not used
+    if (mSceneNodes.find(name) != mSceneNodes.end())
+    {
+        OGRE_EXCEPT(
+            Exception::ERR_DUPLICATE_ITEM,
+            "A scene node with the name " + name + " already exists",
+            "OctreeSceneManager::createSceneNode" );
+    }
     OctreeNode * on = new OctreeNode( this, name );
     mSceneNodes[ on->getName() ] = on;
@@ -548 +556 @@
 void OctreeSceneManager::_alertVisibleObjects( void )
 {
+    OGRE_EXCEPT( Exception::UNIMPLEMENTED_FEATURE,
+        "Function doesn't do as advertised",
+        "OctreeSceneManager::_alertVisibleObjects" );
+
     NodeList::iterator it = mVisible.begin();
 
@@ -570 +582 @@
 
         if ( c != 0 )
-            cam = getCamera( "CullCamera" );
+            cam = c;
     }
 
@@ -680 +692 @@
         }
 
-        if ( octant -> mChildren[ 0 ][ 0 ][ 0 ] != 0 )
-            walkOctree( camera, queue, octant -> mChildren[ 0 ][ 0 ][ 0 ], ( v == OctreeCamera::FULL ), onlyShadowCasters );
-
-        if ( octant -> mChildren[ 1 ][ 0 ][ 0 ] != 0 )
-            walkOctree( camera, queue, octant -> mChildren[ 1 ][ 0 ][ 0 ], ( v == OctreeCamera::FULL ), onlyShadowCasters );
-
-        if ( octant -> mChildren[ 0 ][ 1 ][ 0 ] != 0 )
-            walkOctree( camera, queue, octant -> mChildren[ 0 ][ 1 ][ 0 ], ( v == OctreeCamera::FULL ), onlyShadowCasters );
-
-        if ( octant -> mChildren[ 1 ][ 1 ][ 0 ] != 0 )
-            walkOctree( camera, queue, octant -> mChildren[ 1 ][ 1 ][ 0 ], ( v == OctreeCamera::FULL ), onlyShadowCasters );
-
-        if ( octant -> mChildren[ 0 ][ 0 ][ 1 ] != 0 )
-            walkOctree( camera, queue, octant -> mChildren[ 0 ][ 0 ][ 1 ], ( v == OctreeCamera::FULL ), onlyShadowCasters );
-
-        if ( octant -> mChildren[ 1 ][ 0 ][ 1 ] != 0 )
-            walkOctree( camera, queue, octant -> mChildren[ 1 ][ 0 ][ 1 ], ( v == OctreeCamera::FULL ), onlyShadowCasters );
-
-        if ( octant -> mChildren[ 0 ][ 1 ][ 1 ] != 0 )
-            walkOctree( camera, queue, octant -> mChildren[ 0 ][ 1 ][ 1 ], ( v == OctreeCamera::FULL ), onlyShadowCasters );
-
-        if ( octant -> mChildren[ 1 ][ 1 ][ 1 ] != 0 )
-            walkOctree( camera, queue, octant -> mChildren[ 1 ][ 1 ][ 1 ], ( v == OctreeCamera::FULL ), onlyShadowCasters );
+        Octree* child;
+        bool childfoundvisible = (v == OctreeCamera::FULL);
+        if ( (child = octant -> mChildren[ 0 ][ 0 ][ 0 ]) != 0 )
+            walkOctree( camera, queue, child, childfoundvisible, onlyShadowCasters );
+
+        if ( (child = octant -> mChildren[ 1 ][ 0 ][ 0 ]) != 0 )
+            walkOctree( camera, queue, child, childfoundvisible, onlyShadowCasters );
+
+        if ( (child = octant -> mChildren[ 0 ][ 1 ][ 0 ]) != 0 )
+            walkOctree( camera, queue, child, childfoundvisible, onlyShadowCasters );
+
+        if ( (child = octant -> mChildren[ 1 ][ 1 ][ 0 ]) != 0 )
+            walkOctree( camera, queue, child, childfoundvisible, onlyShadowCasters );
+
+        if ( (child = octant -> mChildren[ 0 ][ 0 ][ 1 ]) != 0 )
+            walkOctree( camera, queue, child, childfoundvisible, onlyShadowCasters );
+
+        if ( (child = octant -> mChildren[ 1 ][ 0 ][ 1 ]) != 0 )
+            walkOctree( camera, queue, child, childfoundvisible, onlyShadowCasters );
+
+        if ( (child = octant -> mChildren[ 0 ][ 1 ][ 1 ]) != 0 )
+            walkOctree( camera, queue, child, childfoundvisible, onlyShadowCasters );
+
+        if ( (child = octant -> mChildren[ 1 ][ 1 ][ 1 ]) != 0 )
+            walkOctree( camera, queue, child, childfoundvisible, onlyShadowCasters );
 
     }
@@ -754 +768 @@
         }
 
-
-
-        if ( octant -> mChildren[ 0 ][ 0 ][ 0 ] != 0 )
-                _findNodes( t, list, exclude, full, octant -> mChildren[ 0 ][ 0 ][ 0 ] );
-
-        if ( octant -> mChildren[ 1 ][ 0 ][ 0 ] != 0 )
-                _findNodes( t, list, exclude, full, octant -> mChildren[ 1 ][ 0 ][ 0 ] );
-
-        if ( octant -> mChildren[ 0 ][ 1 ][ 0 ] != 0 )
-                _findNodes( t, list, exclude, full, octant -> mChildren[ 0 ][ 1 ][ 0 ] );
-
-        if ( octant -> mChildren[ 1 ][ 1 ][ 0 ] != 0 )
-                _findNodes( t, list, exclude, full, octant -> mChildren[ 1 ][ 1 ][ 0 ] );
-
-        if ( octant -> mChildren[ 0 ][ 0 ][ 1 ] != 0 )
-                _findNodes( t, list, exclude, full, octant -> mChildren[ 0 ][ 0 ][ 1 ] );
-
-        if ( octant -> mChildren[ 1 ][ 0 ][ 1 ] != 0 )
-                _findNodes( t, list, exclude, full, octant -> mChildren[ 1 ][ 0 ][ 1 ] );
-
-        if ( octant -> mChildren[ 0 ][ 1 ][ 1 ] != 0 )
-                _findNodes( t, list, exclude, full, octant -> mChildren[ 0 ][ 1 ][ 1 ] );
-
-        if ( octant -> mChildren[ 1 ][ 1 ][ 1 ] != 0 )
-                _findNodes( t, list, exclude, full, octant -> mChildren[ 1 ][ 1 ][ 1 ] );
+        Octree* child;
+
+        if ( (child=octant -> mChildren[ 0 ][ 0 ][ 0 ]) != 0 )
+                _findNodes( t, list, exclude, full, child );
+
+        if ( (child=octant -> mChildren[ 1 ][ 0 ][ 0 ]) != 0 )
+                _findNodes( t, list, exclude, full, child );
+
+        if ( (child=octant -> mChildren[ 0 ][ 1 ][ 0 ]) != 0 )
+                _findNodes( t, list, exclude, full, child );
+
+        if ( (child=octant -> mChildren[ 1 ][ 1 ][ 0 ]) != 0 )
+                _findNodes( t, list, exclude, full, child );
+
+        if ( (child=octant -> mChildren[ 0 ][ 0 ][ 1 ]) != 0 )
+                _findNodes( t, list, exclude, full, child );
+
+        if ( (child=octant -> mChildren[ 1 ][ 0 ][ 1 ]) != 0 )
+                _findNodes( t, list, exclude, full, child );
+
+        if ( (child=octant -> mChildren[ 0 ][ 1 ][ 1 ]) != 0 )
+                _findNodes( t, list, exclude, full, child );
+
+        if ( (child=octant -> mChildren[ 1 ][ 1 ][ 1 ]) != 0 )
+                _findNodes( t, list, exclude, full, child );
 
 }
@@ -827 +841 @@
         }
 
-
-
-        if ( octant -> mChildren[ 0 ][ 0 ][ 0 ] != 0 )
-                _findNodes( t, list, exclude, full, octant -> mChildren[ 0 ][ 0 ][ 0 ] );
-
-        if ( octant -> mChildren[ 1 ][ 0 ][ 0 ] != 0 )
-                _findNodes( t, list, exclude, full, octant -> mChildren[ 1 ][ 0 ][ 0 ] );
-
-        if ( octant -> mChildren[ 0 ][ 1 ][ 0 ] != 0 )
-                _findNodes( t, list, exclude, full, octant -> mChildren[ 0 ][ 1 ][ 0 ] );
-
-        if ( octant -> mChildren[ 1 ][ 1 ][ 0 ] != 0 )
-                _findNodes( t, list, exclude, full, octant -> mChildren[ 1 ][ 1 ][ 0 ] );
-
-        if ( octant -> mChildren[ 0 ][ 0 ][ 1 ] != 0 )
-                _findNodes( t, list, exclude, full, octant -> mChildren[ 0 ][ 0 ][ 1 ] );
-
-        if ( octant -> mChildren[ 1 ][ 0 ][ 1 ] != 0 )
-                _findNodes( t, list, exclude, full, octant -> mChildren[ 1 ][ 0 ][ 1 ] );
-
-        if ( octant -> mChildren[ 0 ][ 1 ][ 1 ] != 0 )
-                _findNodes( t, list, exclude, full, octant -> mChildren[ 0 ][ 1 ][ 1 ] );
-
-        if ( octant -> mChildren[ 1 ][ 1 ][ 1 ] != 0 )
-                _findNodes( t, list, exclude, full, octant -> mChildren[ 1 ][ 1 ][ 1 ] );
+        Octree* child;
+
+        if ( (child=octant -> mChildren[ 0 ][ 0 ][ 0 ]) != 0 )
+                _findNodes( t, list, exclude, full, child );
+
+        if ( (child=octant -> mChildren[ 1 ][ 0 ][ 0 ]) != 0 )
+                _findNodes( t, list, exclude, full, child );
+
+        if ( (child=octant -> mChildren[ 0 ][ 1 ][ 0 ]) != 0 )
+                _findNodes( t, list, exclude, full, child );
+
+        if ( (child=octant -> mChildren[ 1 ][ 1 ][ 0 ]) != 0 )
+                _findNodes( t, list, exclude, full, child );
+
+        if ( (child=octant -> mChildren[ 0 ][ 0 ][ 1 ]) != 0 )
+                _findNodes( t, list, exclude, full, child );
+
+        if ( (child=octant -> mChildren[ 1 ][ 0 ][ 1 ]) != 0 )
+                _findNodes( t, list, exclude, full, child );
+
+        if ( (child=octant -> mChildren[ 0 ][ 1 ][ 1 ]) != 0 )
+                _findNodes( t, list, exclude, full, child );
+
+        if ( (child=octant -> mChildren[ 1 ][ 1 ][ 1 ]) != 0 )
+                _findNodes( t, list, exclude, full, child );
 
 }
@@ -901 +915 @@
         }
 
-
-
-        if ( octant -> mChildren[ 0 ][ 0 ][ 0 ] != 0 )
-                _findNodes( t, list, exclude, full, octant -> mChildren[ 0 ][ 0 ][ 0 ] );
-
-        if ( octant -> mChildren[ 1 ][ 0 ][ 0 ] != 0 )
-                _findNodes( t, list, exclude, full, octant -> mChildren[ 1 ][ 0 ][ 0 ] );
-
-        if ( octant -> mChildren[ 0 ][ 1 ][ 0 ] != 0 )
-                _findNodes( t, list, exclude, full, octant -> mChildren[ 0 ][ 1 ][ 0 ] );
-
-        if ( octant -> mChildren[ 1 ][ 1 ][ 0 ] != 0 )
-                _findNodes( t, list, exclude, full, octant -> mChildren[ 1 ][ 1 ][ 0 ] );
-
-        if ( octant -> mChildren[ 0 ][ 0 ][ 1 ] != 0 )
-                _findNodes( t, list, exclude, full, octant -> mChildren[ 0 ][ 0 ][ 1 ] );
-
-        if ( octant -> mChildren[ 1 ][ 0 ][ 1 ] != 0 )
-                _findNodes( t, list, exclude, full, octant -> mChildren[ 1 ][ 0 ][ 1 ] );
-
-        if ( octant -> mChildren[ 0 ][ 1 ][ 1 ] != 0 )
-                _findNodes( t, list, exclude, full, octant -> mChildren[ 0 ][ 1 ][ 1 ] );
-
-        if ( octant -> mChildren[ 1 ][ 1 ][ 1 ] != 0 )
-                _findNodes( t, list, exclude, full, octant -> mChildren[ 1 ][ 1 ][ 1 ] );
+        Octree* child;
+
+        if ( (child=octant -> mChildren[ 0 ][ 0 ][ 0 ]) != 0 )
+                _findNodes( t, list, exclude, full, child );
+
+        if ( (child=octant -> mChildren[ 1 ][ 0 ][ 0 ]) != 0 )
+                _findNodes( t, list, exclude, full, child );
+
+        if ( (child=octant -> mChildren[ 0 ][ 1 ][ 0 ]) != 0 )
+                _findNodes( t, list, exclude, full, child );
+
+        if ( (child=octant -> mChildren[ 1 ][ 1 ][ 0 ]) != 0 )
+                _findNodes( t, list, exclude, full, child );
+
+        if ( (child=octant -> mChildren[ 0 ][ 0 ][ 1 ]) != 0 )
+                _findNodes( t, list, exclude, full, child );
+
+        if ( (child=octant -> mChildren[ 1 ][ 0 ][ 1 ]) != 0 )
+                _findNodes( t, list, exclude, full, child );
+
+        if ( (child=octant -> mChildren[ 0 ][ 1 ][ 1 ]) != 0 )
+                _findNodes( t, list, exclude, full, child );
+
+        if ( (child=octant -> mChildren[ 1 ][ 1 ][ 1 ]) != 0 )
+                _findNodes( t, list, exclude, full, child );
 
 }
@@ -974 +988 @@
         }
 
-
-
-        if ( octant -> mChildren[ 0 ][ 0 ][ 0 ] != 0 )
-                _findNodes( t, list, exclude, full, octant -> mChildren[ 0 ][ 0 ][ 0 ] );
-
-        if ( octant -> mChildren[ 1 ][ 0 ][ 0 ] != 0 )
-                _findNodes( t, list, exclude, full, octant -> mChildren[ 1 ][ 0 ][ 0 ] );
-
-        if ( octant -> mChildren[ 0 ][ 1 ][ 0 ] != 0 )
-                _findNodes( t, list, exclude, full, octant -> mChildren[ 0 ][ 1 ][ 0 ] );
-
-        if ( octant -> mChildren[ 1 ][ 1 ][ 0 ] != 0 )
-                _findNodes( t, list, exclude, full, octant -> mChildren[ 1 ][ 1 ][ 0 ] );
-
-        if ( octant -> mChildren[ 0 ][ 0 ][ 1 ] != 0 )
-                _findNodes( t, list, exclude, full, octant -> mChildren[ 0 ][ 0 ][ 1 ] );
-
-        if ( octant -> mChildren[ 1 ][ 0 ][ 1 ] != 0 )
-                _findNodes( t, list, exclude, full, octant -> mChildren[ 1 ][ 0 ][ 1 ] );
-
-        if ( octant -> mChildren[ 0 ][ 1 ][ 1 ] != 0 )
-                _findNodes( t, list, exclude, full, octant -> mChildren[ 0 ][ 1 ][ 1 ] );
-
-        if ( octant -> mChildren[ 1 ][ 1 ][ 1 ] != 0 )
-                _findNodes( t, list, exclude, full, octant -> mChildren[ 1 ][ 1 ][ 1 ] );
+        Octree* child;
+
+        if ( (child=octant -> mChildren[ 0 ][ 0 ][ 0 ]) != 0 )
+                _findNodes( t, list, exclude, full, child );
+
+        if ( (child=octant -> mChildren[ 1 ][ 0 ][ 0 ]) != 0 )
+                _findNodes( t, list, exclude, full, child );
+
+        if ( (child=octant -> mChildren[ 0 ][ 1 ][ 0 ]) != 0 )
+                _findNodes( t, list, exclude, full, child );
+
+        if ( (child=octant -> mChildren[ 1 ][ 1 ][ 0 ]) != 0 )
+                _findNodes( t, list, exclude, full, child );
+
+        if ( (child=octant -> mChildren[ 0 ][ 0 ][ 1 ]) != 0 )
+                _findNodes( t, list, exclude, full, child );
+
+        if ( (child=octant -> mChildren[ 1 ][ 0 ][ 1 ]) != 0 )
+                _findNodes( t, list, exclude, full, child );
+
+        if ( (child=octant -> mChildren[ 0 ][ 1 ][ 1 ]) != 0 )
+                _findNodes( t, list, exclude, full, child );
+
+        if ( (child=octant -> mChildren[ 1 ][ 1 ][ 1 ]) != 0 )
+                _findNodes( t, list, exclude, full, child );
 
 }
@@ -1038 +1052 @@
 
     mOctree->mBox = box;
+
+        const Vector3 min = box.getMinimum();
+        const Vector3 max = box.getMaximum();
+        mOctree->mHalfSize = ( max - min ) * 0.5f;
 
     it = nodes.begin();

OGRE/trunk/ogre_changes/Plugins/OctreeSceneManager/src/OgreTerrainRenderable.cpp

@@ -77 +77 @@
 
         mInit = false;
+        mLightListDirty = true;
                 MovableObject::mCastShadows = false;
 
@@ -251 +252 @@
             ( startz * msOptions->scale.z + (endz - 1) * msOptions->scale.z ) / 2 );
 
+        mBoundingRadius =
+            std::max(max - min,
+                std::max((endx - 1 - startx) * msOptions->scale.x,
+                         (endz - 1 - startz) * msOptions->scale.z)) / 2;
+
         // Create delta buffer list if required to morph
         if (msOptions->lodMorph)
@@ -344 +350 @@
 
                 Vector3 cpos = cam -> getDerivedPosition();
-        Vector3 diff = mCenter - cpos;
+        const AxisAlignedBox& aabb = getWorldBoundingBox(true);
+        Vector3 diff(0, 0, 0);
+        diff.makeFloor(cpos - aabb.getMinimum());
+        diff.makeCeil(cpos - aabb.getMaximum());
 
         Real L = diff.squaredLength();
@@ -443 +452 @@
     void TerrainRenderable::_updateRenderQueue( RenderQueue* queue )
     {
+        // Notify need to calculate light list when our sending to render queue
+        mLightListDirty = true;
+
         queue->addRenderable( this );
     }
@@ -994 +1006 @@
     const LightList& TerrainRenderable::getLights(void) const
     {
-        return getParentSceneNode()->findLights(this->getBoundingRadius());
+        if (mLightListDirty)
+        {
+            getParentSceneNode()->getCreator()->_populateLightList(
+                mCenter, this->getBoundingRadius(), mLightList);
+            mLightListDirty = false;
+        }
+        return mLightList;
     }
     //-----------------------------------------------------------------------

OGRE/trunk/ogre_changes/RenderSystems/Direct3D7/include/OgreD3D7RenderWindow.h

@@ -119 +119 @@
         */
         void writeContentsToFile(const String& filename);
-
+        // DirectDraw Methods
+                void createDDSurfaces(void);
+                void releaseDDSurfaces(void);
+                void restoreDDSurfaces(void);
+                void createDepthBuffer(void);
 #ifdef GTP_VISIBILITY_MODIFIED_OGRE
                 uchar *getBufferContents(int &dimx, int &dimy);
@@ -159 +163 @@
         LPDIRECT3DDEVICE7 mlpD3DDevice;
 
-        // DirectDraw Methods
-        void createDDSurfaces(void);
-        void releaseDDSurfaces(void);
-        void restoreDDSurfaces(void);
-        void createDepthBuffer(void);
 
         // Method for dealing with resize / move & 3d library

OGRE/trunk/ogre_changes/RenderSystems/Direct3D7/include/OgreD3D7Texture.h

@@ -53 +53 @@
         LPDIRECTDRAWSURFACE7 getDDSurface(void);
 
-        /// @copydoc Texture::createInternalResources
-        void createInternalResources(void);
-
                 /// @copydoc Texture::getBuffer
                 HardwarePixelBufferSharedPtr getBuffer(size_t face, size_t mipmap);
@@ -63 +60 @@
                 static PixelFormat closestD3DXFormat( PixelFormat format );
                 static bool OgreFormat_to_DDPixelFormat( PixelFormat format, DDPIXELFORMAT & out );
+
+                /// Restore this texture from a lost device
+                void restoreFromLostDevice(void);
+
     protected:
         IDirect3DDevice7 * mD3DDevice;       ///< A pointer to the Direct3D device.
@@ -71 +72 @@
                 typedef std::vector<HardwarePixelBufferSharedPtr> SurfaceList;
                 SurfaceList                                             mSurfaceList;
+                /// Are we restoring from a lost device?
+                bool mRestoring;
+
         
 
         /// @copydoc Resource::loadImpl
         void loadImpl(void);
-        /// @copydoc Resource::unloadImpl
-        void unloadImpl(void);
+                /// @copydoc Texture::createInternalResourcesImpl
+                void createInternalResourcesImpl(void);
+        /// @copydoc Resource::freeInternalResourcesImpl
+        void freeInternalResourcesImpl(void);
                 
                 void createSurface2D(void);

OGRE/trunk/ogre_changes/RenderSystems/Direct3D7/src/OgreD3D7RenderWindow.cpp

@@ -96 +96 @@
                 break;
 
-            case WM_MOVE:
-                // Move messages need to be tracked to update the screen rects
-                // used for blitting the backbuffer to the primary.
-                if(win->mActive && win->mReady)
-                    win->windowMovedOrResized();
-                break;
-
             case WM_ENTERSIZEMOVE:
                 // Prevent rendering while moving / sizing
@@ -113 +106 @@
                 break;
 
+            case WM_MOVE:
             case WM_SIZE:
                 // Check to see if we are losing or gaining our window. Set the
@@ -391 +385 @@
     void D3D7RenderWindow::swapBuffers(bool waitForVSync)
     {
+                if (!mlpDDSFront)
+                        return;
+
         HRESULT hr;
         DWORD flags;
@@ -423 +420 @@
             {
                 // Restore surfaces
-                restoreDDSurfaces();
+                //restoreDDSurfaces();
             }
             else if (FAILED(hr))
@@ -539 +536 @@
         ddscaps.dwCaps = DDSCAPS_ZBUFFER;
 
+                if (!mlpDDSBack->IsLost())
+                {
         LPDIRECTDRAWSURFACE7 zBufSurface;
 
@@ -546 +545 @@
         zBufSurface->Release();
         zBufSurface->Release();
+                }
 
         // Release std buffers
@@ -563 +563 @@
 
             if( FAILED( hr ) )
+                        {
+                                if (hr == DDERR_WRONGMODE)
+                                {
+                                        // Fullscreen exclusive mode problem
+                                        // Need to release & recreate
+                                        releaseDDSurfaces();
+                                        createDDSurfaces();
+                                        createDepthBuffer();
+                                        return;
+                                }
+                                else
+                                {
+                                        char szBuffer[512];
+                                        D3DXGetErrorString( hr, 512, szBuffer );
                 OGRE_EXCEPT( 
                     Exception::ERR_INTERNAL_ERROR, 
-                    "Error restoring lost primary surface.", 
+                                                "Error restoring lost primary surface." + String(szBuffer), 
                     "D3D7RenderWindow - restoreDDSurfaces" );
         }
+                        }
+        }
 
         if( mlpDDSBack->IsLost() )
@@ -574 +590 @@
 
             if( FAILED( hr ) )
+                        {
+                                char szBuffer[512];
+                                D3DXGetErrorString( hr, 512, szBuffer );
                 OGRE_EXCEPT( 
                     Exception::ERR_INTERNAL_ERROR, 
-                    "Error restoring lost back buffer surface.", 
+                    "Error restoring lost back buffer surface." + String(szBuffer), 
                     "D3D7RenderWindow - restoreDDSurfaces" );
         }
+    }
     }
 
@@ -592 +612 @@
         ClientToScreen( mHWnd, (POINT*)&rcCheck.left );
         ClientToScreen( mHWnd, (POINT*)&rcCheck.right );
+
+                if ((rcCheck.right - rcCheck.left) == 0 ||
+                        (rcCheck.bottom - rcCheck.top) == 0)
+                {
+                        return;
+                }
 
         // Has the window resized? If so, we need to recreate surfaces

OGRE/trunk/ogre_changes/RenderSystems/Direct3D9/include/OgreD3D9HardwareOcclusionQuery.h

@@ -34 +34 @@
 
 // If you use multiple rendering passes you can test only the first pass and all other passes don't have to be rendered 
-        // if the first pass resultet has too few pixels visible.
+        // if the first pass results has too few pixels visible.
 
-// Be sure to render all occlluder first and whats out so the RenderQue don't switch places on 
+        // Be sure to render all occluder first and whats out so the RenderQue don't switch places on 
 // the occluding objects and the tested objects because it thinks it's more effective..
 
@@ -46 +46 @@
         *
         * Updated on 12/7/2004 by Chris McGuirk
+        * Updated on 4/8/2005 by Tuan Kuranes email: tuan.kuranes@free.fr
   */
 class D3D9HardwareOcclusionQuery : public HardwareOcclusionQuery
@@ -73 +74 @@
                 bool pullOcclusionQuery( unsigned int* NumOfFragments, const HW_OCCLUSIONQUERY flag = HWOCCLUSIONQUERY_FLUSH);
                 unsigned int getLastQuerysPixelcount() { return mPixelCount; }
+        bool isStillOutstanding(void);
 
                 // These functions are optional, it's a simple filter that simply skips some hardware occlusion tests on visible objects only
@@ -82 +84 @@
           *   
                 * Remarks This function allows you to set how often the hardware occlusion query is sent to the driver
-          * if you set it to 0 every hw occlusion test is acctually made. If you set it to 1 only the half of your queries are sent 
-                * 2 will result in 25% of all queries to acctualy be sent. 
+                * if you set it to 0 every hardware occlusion test is actually made. If you set it to 1 only the half of your queries are sent 
+                * 2 will result in 25% of all queries to factually be sent. 
                 * This functionality is here because this class can keep track on visible and none visible objects for you.
           * Once you you set the SkipRate for any hardware occlusion instance it effects all others.
           */
 
-                void setSkipRate( int skip ) { mSkipInterval = skip; }                  // Using 2 only 50 % of the tests are actully made and 3 results in only 33% of the tests. So on.
+                void setSkipRate( int skip ) { mSkipInterval = skip; }                  // Using 2 only 50 % of the tests are actually made and 3 results in only 33% of the tests. So on.
                 int      getSkipRate() { return mSkipInterval; } 
 
@@ -105 +107 @@
                 int                                     mSkipInterval;
                 bool                            mHasOcclusionSupport;
+                bool                            mIsQueryResultStillOutstanding;
 };
 

OGRE/trunk/ogre_changes/RenderSystems/Direct3D9/include/OgreD3D9Texture.h

@@ -68 +68 @@
                 /// device capabilities pointer
                 D3DCAPS9                                                mDevCaps;
-        // Auto-generated mipmaps?
-        bool                            mAutoGenMipmaps;
                 // Dynamic textures?
                 bool                            mDynamicTextures;
@@ -95 +93 @@
                 D3DFORMAT _chooseD3DFormat();
 
-                /// internal method, free D3D9 resources
-                void _freeResources();
+                /// @copydoc Texture::createInternalResourcesImpl
+                void createInternalResourcesImpl(void);
+                /// free internal resources
+                void freeInternalResourcesImpl(void);
                 /// internal method, set Texture class source image protected attributes
                 void _setSrcAttributes(unsigned long width, unsigned long height, unsigned long depth, PixelFormat format);
@@ -116 +116 @@
                 /// internal method, create D3D9HardwarePixelBuffers for every face and
                 /// mipmap level. This method must be called after the D3D texture object was created
-                void _createSurfaceList(bool updateOldList=false);
+                void _createSurfaceList(void);
 
         /// overriden from Resource
         void loadImpl();
-        /// overriden from Resource
-        void unloadImpl();
         public:
                 /// constructor 
@@ -135 +133 @@
                 void loadImage( const Image &img );
 
-        /// @copydoc Texture::createInternalResources
-        void createInternalResources(void);
 
                 /// @copydoc Texture::getBuffer

OGRE/trunk/ogre_changes/RenderSystems/Direct3D9/src/OgreD3D9HardwareOcclusionQuery.cpp

@@ -113 +113 @@
         // This version of pullOcclusionQuery causes the DX9 API/Driver to not flush all commands to the 3D card
 // to allow a fast result from the query, but the batching of API calls to the card will be normal. 
-        // But the query wont be processed until the card recives the query in the next batch.
+        // But the query wont be processed until the card receives the query in the next batch.
 // Note: OpenGL dosn't use this flag at all so the application running OpenGL won't display any different behaviour.
 //--

OGRE/trunk/ogre_changes/RenderSystems/Direct3D9/src/OgreD3D9RenderWindow.cpp

@@ -110 +110 @@
         D3D9RenderWindow::~D3D9RenderWindow()
         {
-                // access and update device through driver, realse only primary
-                if (!mIsSwapChain) 
-                {
-                        LPDIRECT3DDEVICE9 mpD3DDevice = mDriver->getD3DDevice();
-                        SAFE_RELEASE( mpD3DDevice );
-                        mDriver->setD3DDevice( NULL );
-                }
+                destroyD3DResources();
         }
 
@@ -342 +336 @@
                 md3dpp.BackBufferHeight                 = mHeight;
 
-#ifdef GTP_VISIBILITY_MODIFIED_OGRE
-        //md3dpp.Flags |= D3DPRESENTFLAG_LOCKABLE_BACKBUFFER;
-#endif
                 if (mVSync)
                         md3dpp.PresentationInterval = D3DPRESENT_INTERVAL_ONE;
@@ -493 +484 @@
                         // ignore depth buffer, access device through driver
                         mpRenderZBuffer = 0;
-                        LPDIRECT3DDEVICE9 mpD3DDevice = mDriver->getD3DDevice();
-                        SAFE_RELEASE(mpD3DDevice);
-                        mDriver->setD3DDevice(NULL);
                 }
         }
@@ -727 +715 @@
                 }
 
-                if (!mIsFullScreen)
-                {
-                        POINT pt={0, 0};
+                D3DLOCKED_RECT lockedRect;
+                if(mIsFullScreen)
+                {
+                        if (FAILED(hr = pTempSurf->LockRect(&lockedRect, NULL, 
+                        D3DLOCK_READONLY | D3DLOCK_NOSYSLOCK)))
+                        {
+                                OGRE_EXCEPT(hr, "can't lock rect!", "D3D9RenderWindow::writeContentsToFile");
+                        } 
+                }
+                else
+                {
                         RECT srcRect;
                         GetWindowRect(mHWnd, &srcRect);
@@ -735 +731 @@
                         desc.Width = srcRect.right - srcRect.left;
                         desc.Height = srcRect.bottom - srcRect.top;
-                        desc.Format = D3DFMT_A8R8G8B8;         // this is what we get from the screen, so stick with it
-
-                        // NB we can't lock the back buffer direct because it's no created that way
-                        // and to do so hits performance, so copy to another surface
-                        // Must be the same format as the source surface
-                        if (FAILED(hr = mpD3DDevice->CreateOffscreenPlainSurface(
-                                                        desc.Width, 
-                                                        desc.Height, 
-                                                        desc.Format, 
-                                                        D3DPOOL_DEFAULT, 
-                                                        &pSurf,
-                                                        NULL)))
-                        {
-                                SAFE_RELEASE(pSurf);
-                                OGRE_EXCEPT(hr, "Cannot create offscreen buffer 2!", "D3D9RenderWindow::writeContentsToFile");
-                        }
-
-                        // Copy
-                        if (FAILED(hr = mpD3DDevice->UpdateSurface(pTempSurf, &srcRect, pSurf, &pt)))
-                        {
-                                SAFE_RELEASE(pTempSurf);
-                                SAFE_RELEASE(pSurf);
-                                OGRE_EXCEPT(hr, "Cannot update surface!", "D3D9RenderWindow::writeContentsToFile");
-                        }
-
-                        SAFE_RELEASE(pTempSurf);
-                        pTempSurf = pSurf;
-                        pSurf = NULL;
-                }
-
-                D3DLOCKED_RECT lockedRect;
-                if (FAILED(hr = pTempSurf->LockRect(&lockedRect, NULL, 
+
+                        if (FAILED(hr = pTempSurf->LockRect(&lockedRect, &srcRect, 
+
                         D3DLOCK_READONLY | D3DLOCK_NOSYSLOCK)))
                 {
                         OGRE_EXCEPT(hr, "can't lock rect!", "D3D9RenderWindow::writeContentsToFile");
                 } 
+                }
 
         ImageCodec::ImageData *imgData = new ImageCodec::ImageData();

OGRE/trunk/ogre_changes/RenderSystems/GL/include/OgreGLHardwareOcclusionQuery.h

@@ -53 +53 @@
 
 // If you use multiple rendering passes you can test only the first pass and all other passes don't have to be rendered 
-// if the first pass resultet has too few pixels visable.
+// if the first pass result has too few pixels visible.
 
-// Be sure to render all occlluder first and whats out so the RenderQue don't switch places on 
+// Be sure to render all occluder first and whats out so the RenderQue don't switch places on 
 // the occluding objects and the tested objects because it thinks it's more effective..
 
@@ -64 +64 @@
   *
   * @author Lee Sandberg email: lee@abcmedia.se
+  * Updated on 4/8/2005 by Tuan Kuranes email: tuan.kuranes@free.fr
   */
 
@@ -91 +92 @@
         unsigned int getLastQuerysPixelcount() { return mPixelCount; }
 
-        // This functions are optional, it's a simple filter that simply skipps some hardware occlusion tests on visable objects only
-        // It's easy to use if you don't have to keep track on which objects are visable (can be skipped) and what objects arn't visable..
-        // (None visable objects and object you introduce for the first time have allways to be tested allthough the cheepest possible 
-        // LOD (Level Of Detail) mesh and material wize). 
+        // This functions are optional, it's a simple filter that simply skips some hardware occlusion tests on visible objects only
+        // It's easy to use if you don't have to keep track on which objects are visible (can be skipped) and what objects arn't visible..
+        // (None visible objects and object you introduce for the first time have always to be tested although the cheapest possible 
+        // LOD (Level Of Detail) mesh and material wise). 
 
         /**
           *   
           * Remarks This function allows you to set how often the hardware occlusion really sent to the driver
-          * if you set it to 0 every hw occlusion test is acctually made. If you set it to 2 only 50% of your queries are sent. 
-          * for all visable objects. 3 will result in 33% of all queries to acctualy be sent and so on. 
-          * New and none visable objects will be tested all the time.
-          * This functionality is here because this class can keep track on visable and none visable objects for you.
+          * if you set it to 0 every hardware occlusion test is actually made. If you set it to 2 only 50% of your queries are sent. 
+          * for all visible objects. 3 will result in 33% of all queries to actually be sent and so on. 
+          * New and none visible objects will be tested all the time.
+          * This functionality is here because this class can keep track on visible and none visible objects for you.
           * Once you you set the SkipRate for any hardware occlusion instance it effects all others.
           */
 
-        void setSkipRate( int skip ) { mSkipInterval = skip; }          // Using 2 only 50 % of the tests are actully made and 3 results in only 33% of the tests. So on.
+        void setSkipRate( int skip ) { mSkipInterval = skip; }          // Using 2 only 50 % of the tests are actually made and 3 results in only 33% of the tests. So on.
         int      getSkipRate() { return mSkipInterval; } 
 

OGRE/trunk/ogre_changes/RenderSystems/GL/include/OgreGLTexture.h

@@ -46 +46 @@
         virtual ~GLTexture();      
 
-        /// @copydoc Texture::createInternalResources
-        void createInternalResources(void);
                 void loadImage( const Image& img );
         void createRenderTexture();
@@ -61 +59 @@
 
     protected:
+                /// @copydoc Texture::createInternalResourcesImpl
+                void createInternalResourcesImpl(void);
         /// @copydoc Resource::loadImpl
         void loadImpl(void);
-        /// @copydoc Resource::unloadImpl
-        void unloadImpl(void);
+        /// @copydoc Resource::freeInternalResourcesImpl
+        void freeInternalResourcesImpl(void);
 
                 /** internal method, create GLHardwarePixelBuffers for every face and

OGRE/trunk/ogre_changes/RenderSystems/GL/src/OgreGLHardwareOcclusionQuery.cpp

@@ -38 +38 @@
   * Updated on 12/7/2004 by Chris McGuirk
   * - Implemented ARB_occlusion_query
+  * Updated on 4/8/2005 by Tuan Kuranes email: tuan.kuranes@free.fr
   */
 
@@ -154 +155 @@
 #endif // GTP_VIBILITY_MODIFIED_OGRE
 }
+
+

OGRE/trunk/ogre_changes/RenderSystems/GL/src/OgreGLRenderSystem.cpp

@@ -257 +257 @@
             delete mTextureManager;
 
-        delete mCapabilities;
         delete mGLSupport;
     }
@@ -894 +893 @@
             case Light::LT_SPOTLIGHT:
                 glLightf( gl_index, GL_SPOT_CUTOFF, 0.5f * lt->getSpotlightOuterAngle().valueDegrees() );
+                glLightf(gl_index, GL_SPOT_EXPONENT, lt->getSpotlightFalloff());
                 break;
             default:
@@ -1090 +1090 @@
                         if(!tex.isNull())
                                 glBindTexture( mTextureTypes[stage], tex->getGLID() );
-
+                        else
+                                glBindTexture( mTextureTypes[stage], static_cast<GLTextureManager*>(mTextureManager)->getWarningTextureID() );
         }
         else
@@ -1238 +1239 @@
 
             // Set scale and translation matrix for projective textures
-            projectionBias = Matrix4::ZERO;
-            projectionBias[0][0] = 0.5; projectionBias[1][1] = -0.5; 
-            projectionBias[2][2] = 1.0; projectionBias[0][3] = 0.5; 
-            projectionBias[1][3] = 0.5; projectionBias[3][3] = 1.0;
+            projectionBias = Matrix4::CLIPSPACE2DTOIMAGESPACE;
 
             projectionBias = projectionBias * frustum->getProjectionMatrix();
@@ -1260 +1258 @@
         switch(tam)
         {
+        default:
         case TextureUnitState::TAM_WRAP:
             type = GL_REPEAT;
@@ -1295 +1294 @@
                         mat[12] = mat[8];
                         mat[13] = mat[9];
+            mat[8] = 0;
+            mat[9] = 0;
                 }
 //        mat[14] = mat[10];
@@ -1312 +1313 @@
         glMatrixMode(GL_TEXTURE);
 
+        // Load this matrix in
+        glLoadMatrixf(mat);
+
         if (mUseAutoTextureMatrix)
         {
-            // Load auto matrix in
-            glLoadMatrixf(mAutoTextureMatrix);
-            // Concat new matrix
-            glMultMatrixf(mat);
-
-        }
-        else
-        {
-            // Just load this matrix
-            glLoadMatrixf(mat);
+            // Concat auto matrix
+            glMultMatrixf(mAutoTextureMatrix);
         }
 
@@ -1403 +1399 @@
               h = vp->getActualHeight();
               x = vp->getActualLeft();
-              y = target->getHeight() - vp->getActualTop() - h;
-  
+              y = vp->getActualTop();
+              if (!target->requiresTextureFlipping())
+              {
+                  // Convert "upper-left" corner to "lower-left"
+                  y = target->getHeight() - h - y;
+              }
               glViewport(x, y, w, h);
   
@@ -2344 +2344 @@
             glDisableVertexAttribArrayARB_ptr(1); // disable weights
         }
-
+        glColor4f(1,1,1,1);
         glSecondaryColor3fEXT_ptr(0.0f, 0.0f, 0.0f);
 
@@ -2415 +2415 @@
             const Plane& plane = clipPlanes[i];
 
-            if (i >= GL_MAX_CLIP_PLANES)
+            if (i >= 6/*GL_MAX_CLIP_PLANES*/)
             {
                 OGRE_EXCEPT(0, "Unable to set clip plane", 
@@ -2424 +2424 @@
             clipPlane[1] = plane.normal.y;
             clipPlane[2] = plane.normal.z;
-            clipPlane[3] = -plane.d;
+            clipPlane[3] = plane.d;
 
             glClipPlane(clipPlaneId, clipPlane);
@@ -2440 +2440 @@
         size_t top, size_t right, size_t bottom)
     {
+        // If request texture flipping, use "upper-left", otherwise use "lower-left"
+        bool flipping = mActiveRenderTarget->requiresTextureFlipping();
         //  GL measures from the bottom, not the top
         size_t targetHeight = mActiveRenderTarget->getHeight();
@@ -2450 +2452 @@
             // NB GL uses width / height rather than right / bottom
             x = left;
+            if (flipping)
+                y = top;
+            else
             y = targetHeight - bottom;
             w = right - left;
@@ -2462 +2467 @@
             h = mActiveViewport->getActualHeight();
             x = mActiveViewport->getActualLeft();
+            if (flipping)
+                y = mActiveViewport->getActualTop();
+            else
             y = targetHeight - mActiveViewport->getActualTop() - h;
             glScissor(x, y, w, h);
@@ -2575 +2583 @@
     HardwareOcclusionQuery* GLRenderSystem::createHardwareOcclusionQuery(void)
     {
-        return new GLHardwareOcclusionQuery(); 
+        GLHardwareOcclusionQuery* ret = new GLHardwareOcclusionQuery(); 
+                mHwOcclusionQueries.push_back(ret);
+                return ret;
     }
     //---------------------------------------------------------------------
@@ -2639 +2649 @@
     }
     //---------------------------------------------------------------------
+    void GLRenderSystem::_switchContext(GLContext *context)
+    {
+        // Unbind GPU programs and rebind to new context later, because
+        // scene manager treat render system as ONE 'context' ONLY, and it
+        // cached the GPU programs using state.
+        if (mCurrentVertexProgram)
+            mCurrentVertexProgram->unbindProgram();
+        if (mCurrentFragmentProgram)
+            mCurrentFragmentProgram->unbindProgram();
+
+        // It's ready to switching
+            mCurrentContext->endCurrent();
+        mCurrentContext = context;
+        mCurrentContext->setCurrent();
+        
+            // Check if the context has already done one-time initialisation
+        if(!mCurrentContext->getInitialized()) 
+        {
+               _oneTimeContextInitialization();
+               mCurrentContext->setInitialized();
+            }
+
+        // Rebind GPU programs to new context
+        if (mCurrentVertexProgram)
+            mCurrentVertexProgram->bindProgram();
+        if (mCurrentFragmentProgram)
+            mCurrentFragmentProgram->bindProgram();
+
+        // Must reset depth/colour write mask to according with user desired, otherwise,
+        // clearFrameBuffer would be wrong because the value we are recorded may be
+        // difference with the really state stored in GL context.
+        glDepthMask(mDepthWrite);
+        glColorMask(mColourWrite[0], mColourWrite[1], mColourWrite[2], mColourWrite[3]);
+
+    }
+    //---------------------------------------------------------------------
     void GLRenderSystem::_setRenderTarget(RenderTarget *target)
     {
@@ -2645 +2691 @@
         ContextMap::iterator i = mContextMap.find(target);
         if(i != mContextMap.end() && mCurrentContext != i->second) {
-            mCurrentContext->endCurrent();
-            mCurrentContext = i->second;
-            // Check if the context has already done one-time initialisation
-            if(!mCurrentContext->getInitialized()) {
-               _oneTimeContextInitialization();
-               mCurrentContext->setInitialized();
-            }
-            mCurrentContext->setCurrent();
+            _switchContext(i->second);
         }
     }
@@ -2669 +2708 @@
             // we set the main context to 0.
             if(mCurrentContext != mMainContext) {
-                mCurrentContext->endCurrent();
-                mCurrentContext = mMainContext;
-                mCurrentContext->setCurrent();
+                _switchContext(mMainContext);
             } else {
                 mMainContext = 0;

OGRE/trunk/ogre_changes/RenderSystems/GL/src/OgreGLTexture.cpp

@@ -69 +69 @@
         // have to call this here reather than in Resource destructor
         // since calling virtual methods in base destructors causes crash
+                if (mIsLoaded)
+                {
         unload(); 
+    }
+                else
+                {
+                        freeInternalResources();
+                }
     }
 
@@ -90 +97 @@
 
         //* Creation / loading methods ********************************************
-        void GLTexture::createInternalResources(void)
+        void GLTexture::createInternalResourcesImpl(void)
     {
                 // Adjust requested parameters to capabilities
@@ -131 +138 @@
                 // Zero means create mip levels until 1x1
                 size_t maxMips = GLPixelUtil::getMaxMipmaps(mWidth, mHeight, mDepth, mFormat);
+                mNumMipmaps = mNumRequestedMipmaps;
                 if(mNumMipmaps>maxMips)
                         mNumMipmaps = maxMips;
@@ -144 +152 @@
                 
                 // If we can do automip generation and the user desires this, do so
+                mMipmapsHardwareGenerated = 
+                        Root::getSingleton().getRenderSystem()->getCapabilities()->hasCapability(RSC_AUTOMIPMAP);
                 if((mUsage & TU_AUTOMIPMAP) &&
-                    mNumMipmaps &&
-                        Root::getSingleton().getRenderSystem()->getCapabilities()->hasCapability(RSC_AUTOMIPMAP))
+                    mNumRequestedMipmaps && mMipmapsHardwareGenerated)
         {
             glTexParameteri( getGLTextureTarget(), GL_GENERATE_MIPMAP, GL_TRUE );
@@ -242 +251 @@
                 // Get final internal format
                 mFormat = getBuffer(0,0)->getFormat();
-                mIsLoaded = true;
         }
         
@@ -326 +334 @@
         //*************************************************************************
     
-    void GLTexture::unloadImpl()
+    void GLTexture::freeInternalResourcesImpl()
     {
                 mSurfaceList.clear();
@@ -337 +345 @@
         {
                 mSurfaceList.clear();
-                // Make our understanding of the number of mips matches the GL one
-                glBindTexture( getGLTextureTarget(), mTextureID );
-                GLint value;
-                glGetTexParameteriv( getGLTextureTarget(), GL_TEXTURE_MAX_LEVEL, &value );
-                mNumMipmaps = value;
                 
                 // For all faces and mipmaps, store surfaces as HardwarePixelBufferSharedPtr
                 bool wantGeneratedMips = (mUsage & TU_AUTOMIPMAP)!=0;
-                bool canMip = Root::getSingleton().getRenderSystem()->getCapabilities()->hasCapability(RSC_AUTOMIPMAP);
                 
                 // Do mipmapping in software? (uses GLU) For some cards, this is still needed. Of course,
                 // only when mipmap generation is desired.
-                bool doSoftware = wantGeneratedMips && !canMip && getNumMipmaps(); 
+                bool doSoftware = wantGeneratedMips && !mMipmapsHardwareGenerated && getNumMipmaps(); 
                 
                 for(int face=0; face<getNumFaces(); face++)

OGRE/trunk/ogre_changes/RenderSystems/GL/src/OgreWin32Window.cpp

@@ -226 +226 @@
                     }
 
+                HDC old_hdc = wglGetCurrentDC();
+                HGLRC old_context = wglGetCurrentContext();
+
                         RECT rc;
                 // top and left represent outer window position
@@ -255 +258 @@
                 
                 wglSwapIntervalEXT(vsync? 1 : 0);
+
+        if (old_context)
+        {
+            // Restore old context
+                    if (!wglMakeCurrent(old_hdc, old_context))
+                            OGRE_EXCEPT(0, "wglMakeCurrent() failed", "Win32Window::create");
+
+            // Share lists with old context
+                    if (!wglShareLists(old_context, mGlrc))
+                            OGRE_EXCEPT(0, "wglShareLists() failed", " Win32Window::create");
+        }
 
         // Create RenderSystem context