source: GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/include/OgreKdTreeSceneManager.h @ 1182

/*
-----------------------------------------------------------------------------
This source file is part of the GameTools Project
http://www.gametools.org

Author: Martin Szydlowski
-----------------------------------------------------------------------------
*/

#ifndef _KdTreeSceneManager_H__
#define _KdTreeSceneManager_H__

#include <OgreKdTreeHierarchyInterface.h>
#include <OgreSceneManager.h>
#include <VisibilityManager.h>
#include "OgreKdTree.h"

#define KDTREE_MAX_DEPTH 20

namespace Ogre
{
        class KdTreeSceneNode;
        class WireBoundingBox;
        //typedef std::list < WireBoundingBox * > WBBList;

        class KdTreeSceneManager : public SceneManager
        {
        public:
                KdTreeSceneManager(const String& name, GtpVisibility::VisibilityManager *vm);
                ~KdTreeSceneManager(void);

                virtual const String& getTypeName(void) const;


                /************************************************************************/
                /* Functions overridden form SceneManager for KdTree                    */
                /************************************************************************/

                /** Override from SceneManager to create SceneNodes as instance of KdTreeSceneNode
                */
                virtual SceneNode* createSceneNode(void);
                /** Override from SceneManager to create SceneNodes as instance of KdTreeSceneNode
                */
                virtual SceneNode* createSceneNode(const String& name);

                /** Override from Scenemanager, employ kd-tree based culling or CHC
                */
                virtual void _findVisibleObjects(Camera *cam, bool onlyShadowCasters);

                virtual bool setOption(const String& strKey, const void* pValue);
                virtual bool getOption(const String& strKey, void* pDestValue);

                bool getOptionValues(const String & key, StringVector &refValueList);
                bool getOptionKeys(StringVector &refKeys);

                /** Overide from scene manager to destroy kdtree properly (before the scene graph is destroyed)
                */
                virtual void clearScene()
                {
                        // DEBUG
                        //if (mKdTree)
                        //      mKdTree->dump();

                        // must happen before actual scene is cleared
                        OGRE_DELETE(mKdTree);

                        SceneManager::clearScene();
                }

                /************************************************************************/
                /* Functions overridden from SceneManager for CHC                       */
                /************************************************************************/

                /** Override from SceneManager so that sub entities can be assigned an id for item buffer.
                */
                Entity* createEntity(const String& entityName, const String& meshName);

                /** Override from scene manager to set up culling manager
                */
                virtual void _updateSceneGraph(Camera* cam);

                /** Override from SceneManager, employ normal rendering or CHC
                */
                virtual void _renderVisibleObjects();

                /** Override pass so we can do the z-fail pass.
                */
                const Pass* _setPass(Pass* pass);

                /** Render a queue group. 
                Override so we can handle delayed rendering of transparent objects
                */
                void renderBasicQueueGroupObjects(RenderQueueGroup* pGroup, 
                        QueuedRenderableCollection::OrganisationMode om);

                /** Override from scene manager
                */
                void _renderQueueGroupObjects(RenderQueueGroup* pGroup,
                        QueuedRenderableCollection::OrganisationMode om);

                /** Override from SceneManager so we can skip all but first pass for depth pass. 
                */
                bool validatePassForRendering(Pass* pass);

                /** Override from SceneManager because idontknow
                */
                void renderAdditiveStencilShadowedQueueGroupObjects(RenderQueueGroup* pGroup,
                        QueuedRenderableCollection::OrganisationMode om);
                void renderModulativeStencilShadowedQueueGroupObjects(RenderQueueGroup* pGroup,
                        QueuedRenderableCollection::OrganisationMode om);


                /************************************************************************/
                /* Functions which are specific to the KdTree                           */
                /************************************************************************/
                
                /** Update the KdTree with the node (more or less disabled now)
                */
                virtual void _updateNode(KdTreeSceneNode *node); // TODO: 

                /** Show or hide the bounding boxes of KdTree nodes - obsolete, use options
                */
                virtual void setShowBoxes(bool showboxes);
                /** Tell if show boxes is enabled - obsolete, use options
                */
                virtual bool getShowBoxes(void) const;

                /************************************************************************/
                /* Functions for CHC                                                    */
                /************************************************************************/

                /** Render a list of scenenodes
                */
                virtual void _renderNodes(const KdRenderableList& nodelist, Camera * cam,
                        bool onlyShadowCasters, int leavePassesInQueue);

                /** Sets the visibility manager.
                @param visManager the visibility manager
                */
                void setVisibilityManager(GtpVisibility::VisibilityManager *visManager);
                /** See set.
                */
                GtpVisibility::VisibilityManager *getVisibilityManager();

                /** Returns pointer to visibility manager.
                */
                GtpVisibility::VisibilityManager *GetVisibilityManager();

                /** Returns hierarchy interface.
                */
                KdTreeHierarchyInterface *GetHierarchyInterface();

                /** Creates material for depth pass, e.g., a pass that only fills the depth buffer. 
                */
                void InitDepthPass();
                /** Creates material for item buffer. 
                */
                void InitItemBufferPass();
                /** Fills render queue so that a visualization can be rendered. 
                */
                void PrepareVisualization(Camera *cam);
                /** Initialises necessary parameters for hierarchical visibility culling.
                */
                void InitVisibilityCulling(Camera *cam);

                /** Writes out stats into the Ogre log file.
                */
                void WriteLog();



        protected:
                /************************************************************************/
                /* CHC-specific options & members                                       */
                /************************************************************************/
                // pointer to the visibility manager
                GtpVisibility::VisibilityManager *mVisibilityManager;

                // the hierarchy interface for CHC
                KdTreeHierarchyInterface *mHierarchyInterface;

                // if hierarchical culling is currently in use
                bool mIsHierarchicalCulling;

                // if a visualization of the hierarchical culling is shown
                bool mShowVisualization;
                
                // if the culled nodes are indicated in the visualization
                bool mVisualizeCulledNodes;

                // consecutive number for sub-entities
                int mCurrentEntityId;

                // flag for passes which should not be deleted from queue during first traversal
                int mLeavePassesInQueue;

                // if symbols for the nodes are shown in the visualization
                bool mRenderNodesForViz;
                // if content of the nodes is shown in the visualization
                bool mRenderNodesContentForViz;
                /// render transparents after the hierarchical traversal
                bool mDelayRenderTransparents;
                
                // if transparent object are considered for item buffer visibility
                bool mRenderTransparentsForItemBuffer;
                // Always execute the vertex program of a pass, e.g., for the depth pass or item buffer
                bool mExecuteVertexProgramForAllPasses;

                // the depth pass (no lighting, just filling the depth buffer)
                Pass *mDepthPass;
                // use a depth pass (i.e., fill only the depth buffer in the first pass)
                bool mUseDepthPass;
                // flag indicating if we currently render the depth pass
                bool mIsDepthPassPhase;
                // if depth write should be enabled
                bool mEnableDepthWrite;
                // if transparents are skipped during rendering
                bool mSkipTransparents;

                // the item buffer pass (render items color-coded)
                Pass *mItemBufferPass;
                // if we use an item buffer for rendering (i.e., object ids as color codes
                bool mUseItemBuffer;
                // if we currently render the item buffer 
                bool mIsItemBufferPhase;

                /************************************************************************/
                /* Kd-Tree specific options & members                                   */
                /************************************************************************/
                // maximum depth of the kdtree
                int mMaxDepth;

                // the kdtree which holds the scene
                KdTree *mKdTree;

                // if bounding boxes of kdtree nodes are shown
                bool mShowBoxes;

                // the method/algorithm used when rendering the scene
                KdTree::RenderMethod mRenderMethod;

                // the method of building the tree
                KdTree::BuildMethod mBuildMethod;
#ifdef KDTREE_DEBUG
                // bounding boxes of kd nodes will be highlighted on this level of the kd tree
                int mHighlighLevel;
                // if all bounding boxes shall be displayed, not only the highlighted level
                bool mShowAllBoxes;
#endif
        };



        /// Factory for KdTreeSceneManager
        class KdTreeSceneManagerFactory : public SceneManagerFactory
        {
        protected:
                void initMetaData(void) const;
                GtpVisibility::VisibilityManager *visManager;
        public:
                KdTreeSceneManagerFactory(GtpVisibility::VisibilityManager * vm)
                {
                        visManager = vm;
                };
                ~KdTreeSceneManagerFactory(void) {};
                /// Factory type name
                static const String FACTORY_TYPE_NAME;
                SceneManager* createInstance(const String& instanceName);
                void destroyInstance(SceneManager* instance);
        };

} // namespace Ogre

#endif // _KdTreeSceneManager_H__