Changeset 120 for trunk/VUT/Ogre/src/OgreVisibilityTerrainSceneManager.cpp

Timestamp:

06/06/05 18:55:02 (19 years ago)

Author:

mattausch

Message:

 

File:

• trunk/VUT/Ogre/src/OgreVisibilityTerrainSceneManager.cpp (modified) (6 diffs)

trunk/VUT/Ogre/src/OgreVisibilityTerrainSceneManager.cpp

@@ -15 +15 @@
         GtpVisibility::VisibilityManager *visManager): 
 mVisibilityManager(visManager), 
-mUseDepthPass(false),
 mIsDepthPass(false),
 mShowVisualization(false),
@@ -22 +21 @@
 mVisualizeCulledNodes(false),
 mSkipTransparents(false),
-mDelayRenderTransparents(true)
-{
-        mHierarchyInterface = 
-                new OctreeHierarchyInterface(this, mDestRenderSystem);
-
-    //mDisplayNodes = true;
+mDelayRenderTransparents(true),
+mUseDepthPass(false)
+{
+        mHierarchyInterface = new OctreeHierarchyInterface(this, mDestRenderSystem);
+
+        //mDisplayNodes = true;
         //mShowBoundingBoxes = true;
 
@@ -57 +56 @@
 VisibilityTerrainSceneManager::~VisibilityTerrainSceneManager()
 {
-        delete mHierarchyInterface;
-}
-//-----------------------------------------------------------------------
-Pass *VisibilityTerrainSceneManager::setPass(Pass* pass)
-{
+        if (mHierarchyInterface)
+        {
+                delete mHierarchyInterface;
+                mHierarchyInterface = NULL;
+        }
+}
+//-----------------------------------------------------------------------
+/*Pass *VisibilityTerrainSceneManager::setPass(Pass* pass)
+{
+        static bool myLastUsedVertexProgram = false;
+    static bool myLastUsedFragmentProgram = false;
+
         // set depth fill pass only if depth write enabled
-        Pass *usedPass = (mIsDepthPass && pass->getDepthWriteEnabled() ? mDepthPass : pass);
-
-        if (mIsDepthPass)
-        {
-                //if (pass->isTransparent())    return pass;
-
-                // set vertex program of current pass
-        if (pass->hasVertexProgram() && (pass->getVertexProgramName() != mDepthPass->getVertexProgramName()))
-                {
-                        mDepthPass->setVertexProgram(pass->getVertexProgramName());
-
-                        if (mDepthPass->hasVertexProgram())
-                        {
-                                const GpuProgramPtr& prg = mDepthPass->getVertexProgram();
-                                // Load this program if not done already
-                                if (!prg->isLoaded()) prg->load();
-                                // Copy params
-                                mDepthPass->setVertexProgramParameters(pass->getVertexProgramParameters());
-                        }
-                }
-                else if (mDepthPass->hasVertexProgram())
-                {
-                        mDepthPass->setVertexProgram("");
-                }
-        }
-
-        TerrainSceneManager::setPass(usedPass);
+        Pass *usedPass = pass;
+
+        if (mIsDepthPass && pass->getDepthWriteEnabled())
+        {
+                usedPass = mDepthPass;          
+        }
+
+    if (mIlluminationStage == IRS_RENDER_TO_TEXTURE)
+    {
+        // Derive a special shadow caster pass from this one
+        usedPass = deriveShadowCasterPass(usedPass);
+    }
+    else if (mIlluminationStage == IRS_RENDER_MODULATIVE_PASS)
+    {
+        usedPass = deriveShadowReceiverPass(usedPass);
+    }
+
+        bool passSurfaceAndLightParams = true;
+
+        // take original pass here
+    if (usedPass->hasVertexProgram())
+    {
+        mDestRenderSystem->bindGpuProgram(usedPass->getVertexProgram()->_getBindingDelegate());
+        // bind parameters later since they can be per-object
+        myLastUsedVertexProgram = true;
+        // does the vertex program want surface and light params passed to rendersystem?
+        passSurfaceAndLightParams = usedPass->getVertexProgram()->getPassSurfaceAndLightStates();
+    }
+    else
+    {
+        // Unbind program?
+        if (myLastUsedVertexProgram)
+        {
+            mDestRenderSystem->unbindGpuProgram(GPT_VERTEX_PROGRAM);
+            myLastUsedVertexProgram = false;
+        }
+        // Set fixed-function vertex parameters
+    }
+
+    if (passSurfaceAndLightParams)
+    {
+        // Set surface reflectance properties, only valid if lighting is enabled
+        if (usedPass->getLightingEnabled())
+        {
+            mDestRenderSystem->_setSurfaceParams( 
+                usedPass->getAmbient(), 
+                usedPass->getDiffuse(), 
+                usedPass->getSpecular(), 
+                usedPass->getSelfIllumination(), 
+                usedPass->getShininess(),
+                                usedPass->getVertexColourTracking() );
+        }
+
+        // Dynamic lighting enabled?
+        mDestRenderSystem->setLightingEnabled(usedPass->getLightingEnabled());
+    }
+
+    // Using a fragment program?
+    if (usedPass->hasFragmentProgram())
+    {
+        mDestRenderSystem->bindGpuProgram(
+            usedPass->getFragmentProgram()->_getBindingDelegate());
+        // bind parameters later since they can be per-object
+        myLastUsedFragmentProgram = true;
+    }
+    else
+    {
+        // Unbind program?
+        if (myLastUsedFragmentProgram)
+        {
+            mDestRenderSystem->unbindGpuProgram(GPT_FRAGMENT_PROGRAM);
+            myLastUsedFragmentProgram = false;
+        }
+
+        // Set fixed-function fragment settings
+
+        // Fog (assumes we want pixel fog which is the usual)
+        // New fog params can either be from scene or from material
+        FogMode newFogMode;
+        ColourValue newFogColour;
+        Real newFogStart, newFogEnd, newFogDensity;
+        if (usedPass->getFogOverride())
+        {
+            // New fog params from material
+            newFogMode = usedPass->getFogMode();
+            newFogColour = usedPass->getFogColour();
+            newFogStart = usedPass->getFogStart();
+            newFogEnd = usedPass->getFogEnd();
+            newFogDensity = usedPass->getFogDensity();
+        }
+        else
+        {
+            // New fog params from scene
+            newFogMode = mFogMode;
+            newFogColour = mFogColour;
+            newFogStart = mFogStart;
+            newFogEnd = mFogEnd;
+            newFogDensity = mFogDensity;
+        }
+        mDestRenderSystem->_setFog(newFogMode, newFogColour, newFogDensity, newFogStart, newFogEnd);
+
+        }
+
+    // The rest of the settings are the same no matter whether we use programs or not
+
+    // Set scene blending
+    mDestRenderSystem->_setSceneBlending(
+        usedPass->getSourceBlendFactor(), usedPass->getDestBlendFactor());
+
+
+    // Texture unit settings
+
+    Pass::TextureUnitStateIterator texIter =  usedPass->getTextureUnitStateIterator();
+    size_t unit = 0;
+    while(texIter.hasMoreElements())
+    {
+        TextureUnitState* pTex = texIter.getNext();
+        mDestRenderSystem->_setTextureUnitSettings(unit, *pTex);
+        ++unit;
+    }
+    // Disable remaining texture units
+    mDestRenderSystem->_disableTextureUnitsFrom(usedPass->getNumTextureUnitStates());
+
+    // Set up non-texture related material settings
+    // Depth buffer settings
+    mDestRenderSystem->_setDepthBufferFunction(usedPass->getDepthFunction());
+    mDestRenderSystem->_setDepthBufferCheckEnabled(usedPass->getDepthCheckEnabled());
+    mDestRenderSystem->_setDepthBufferWriteEnabled(usedPass->getDepthWriteEnabled());
+    mDestRenderSystem->_setDepthBias(usedPass->getDepthBias());
+        // Alpha-reject settings
+        mDestRenderSystem->_setAlphaRejectSettings(
+                usedPass->getAlphaRejectFunction(), usedPass->getAlphaRejectValue());
+    // Set colour write mode
+    // Right now we only use on/off, not per-channel
+    bool colWrite = usedPass->getColourWriteEnabled();
+    mDestRenderSystem->_setColourBufferWriteEnabled(colWrite, colWrite, colWrite, colWrite);
+    // Culling mode
+    mDestRenderSystem->_setCullingMode(usedPass->getCullingMode());
+    // Shading
+    mDestRenderSystem->setShadingType(usedPass->getShadingMode());
 
         return usedPass;
-}
+}*/
 //-----------------------------------------------------------------------
 void VisibilityTerrainSceneManager::ShowVisualization(Camera *cam)
@@ -138 +257 @@
 }
 //-----------------------------------------------------------------------
+Pass *VisibilityTerrainSceneManager::setPass(Pass* pass)
+{
+        // setting vertex program is not efficient
+        //Pass *usedPass = ((mIsDepthPass && !pass->hasVertexProgram()) ? mDepthPass : pass);           
+        // set depth fill pass only if depth write enabled
+        Pass *usedPass = (mIsDepthPass && pass->getDepthWriteEnabled() ? mDepthPass : pass);
+        
+        if (mIsDepthPass)
+        {
+                // set vertex program of current pass
+        if (pass->hasVertexProgram())
+                {
+                        mDepthPass->setVertexProgram(pass->getVertexProgramName());
+
+                        if (mDepthPass->hasVertexProgram())
+                        {
+                                const GpuProgramPtr& prg = mDepthPass->getVertexProgram();
+                                // Load this program if not done already
+                                if (!prg->isLoaded())
+                                        prg->load();
+                                // Copy params
+                                mDepthPass->setVertexProgramParameters(pass->getVertexProgramParameters());
+                        }
+                }
+                else if (mDepthPass->hasVertexProgram())
+                {
+                        mDepthPass->setVertexProgram("");
+                }
+        }
+        /*else if (mIsItemBufferPass)
+        {
+                usedPass = mItemBufferPass;
+        }*/
+        SceneManager::setPass(usedPass);
+
+        return usedPass;
+}
+//-----------------------------------------------------------------------
 void VisibilityTerrainSceneManager::_findVisibleObjects(Camera* cam, bool onlyShadowCasters)
 {
@@ -232 +389 @@
                 mIsDepthPass = false;
         }
+
         mSkipTransparents = false;
 
@@ -342 +500 @@
         std::stringstream d;
 
-        d << "Algorithm type: " << mVisibilityManager->GetCullingManagerType() << ", "
+        d << "Depth pass: " << StringConverter::toString(mUseDepthPass) << ", "
+          << "Delay transparents: " << StringConverter::toString(mDelayRenderTransparents) << ", "
+          << "Use optimization: " << StringConverter::toString(mHierarchyInterface->GetUseOptimization()) << ", "
+          << "Algorithm type: " << mVisibilityManager->GetCullingManagerType() << ", "
           << "Hierarchy nodes: " << mNumOctreeNodes << ", " 
           << "Traversed nodes: " << mHierarchyInterface->GetNumTraversedNodes() << ", "