OgreOctreeSceneManager.h

Go to the documentation of this file.

/***************************************************************************
octreescenemanager.h  -  description
-------------------
begin                : Fri Sep 27 2002
copyright            : (C) 2002 by Jon Anderson
email                : janders@users.sf.net
***************************************************************************/

/*
-----------------------------------------------------------------------------
This source file is part of OGRE
(Object-oriented Graphics Rendering Engine)
For the latest info, see http://www.ogre3d.org/

Copyright (c) 2000-2005 The OGRE Team
Also see acknowledgements in Readme.html

This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.

This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt.
-----------------------------------------------------------------------------
*/

#ifndef OCTREESCENEMANAGER_H
#define OCTREESCENEMANAGER_H

#include "OgreSceneManager.h"
#include "OgreRenderOperation.h"
#include "OgreSphere.h"

#include <list>
#include <algorithm>

#include <OgreOctree.h>


namespace Ogre
{

class OctreeNode;

class OctreeCamera;
class OctreeIntersectionSceneQuery;
class OctreeRaySceneQuery;
class OctreeSphereSceneQuery;
class OctreeAxisAlignedBoxSceneQuery;
class OctreePlaneBoundedVolumeListSceneQuery;


typedef std::list < WireBoundingBox * > BoxList;
typedef std::list < unsigned long > ColorList;
//typedef std::list < SceneNode * > SceneNodeList;


class OctreeSceneManager : public SceneManager
{
    friend class OctreeIntersectionSceneQuery;
    friend class OctreeRaySceneQuery;
    friend class OctreeSphereSceneQuery;
    friend class OctreeAxisAlignedBoxSceneQuery;
    friend class OctreePlaneBoundedVolumeListSceneQuery;

public:
    static int intersect_call;
    OctreeSceneManager(const String& name);
    OctreeSceneManager(const String& name, AxisAlignedBox &box, int max_depth );
    ~OctreeSceneManager();

    const String& getTypeName(void) const;

    void init( AxisAlignedBox &box, int d );

    virtual SceneNode * createSceneNode ( void );
    virtual SceneNode * createSceneNode ( const String &name );
    virtual Camera * createCamera( const String &name );

    virtual void destroySceneNode( const String &name );



    virtual void _updateSceneGraph( Camera * cam );
    virtual void _findVisibleObjects ( Camera * cam, bool onlyShadowCasters );

    virtual void _alertVisibleObjects( void );

    void walkOctree( OctreeCamera *, RenderQueue *, Octree *, bool foundvisible,
                     bool onlyShadowCasters);

    void _updateOctreeNode( OctreeNode * );
    void _removeOctreeNode( OctreeNode * );
    void _addOctreeNode( OctreeNode *, Octree *octree, int depth = 0 );

    void findNodesIn( const AxisAlignedBox &box, std::list < SceneNode * > &list, SceneNode *exclude = 0 );

    void findNodesIn( const Sphere &sphere, std::list < SceneNode * > &list, SceneNode *exclude = 0 );

    void findNodesIn( const PlaneBoundedVolume &volume, std::list < SceneNode * > &list, SceneNode *exclude=0 );

    void findNodesIn( const Ray &ray, std::list < SceneNode * > &list, SceneNode *exclude=0 );

    void setShowBoxes( bool b )
    {
        mShowBoxes = b;
    };

    void setUseCullCamera( bool b )
    {
        mCullCamera = b;
    };

    void setLooseOctree( bool b )
    {
        mLoose = b;
    };


    void resize( const AxisAlignedBox &box );

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

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

    AxisAlignedBoxSceneQuery* OctreeSceneManager::createAABBQuery(const AxisAlignedBox& box, unsigned long mask);
    SphereSceneQuery* OctreeSceneManager::createSphereQuery(const Sphere& sphere, unsigned long mask);
    PlaneBoundedVolumeListSceneQuery* createPlaneBoundedVolumeQuery(const PlaneBoundedVolumeList& volumes, unsigned long mask);
    RaySceneQuery* createRayQuery(const Ray& ray, unsigned long mask);
    IntersectionSceneQuery* createIntersectionQuery(unsigned long mask);


protected:


    NodeList mVisible;

    Octree *mOctree;

    BoxList mBoxes;

    int mNumObjects;

    int mMaxDepth;
    AxisAlignedBox mBox;

    bool mShowBoxes;

    bool mCullCamera;


    bool mLoose;

    Real mCorners[ 24 ];
    static unsigned long mColors[ 8 ];
    static unsigned short mIndexes[ 24 ];

    Matrix4 mScaleFactor;

};

class OctreeSceneManagerFactory : public SceneManagerFactory
{
protected:
    void initMetaData(void) const;
public:
    OctreeSceneManagerFactory() {}
    ~OctreeSceneManagerFactory() {}
    static const String FACTORY_TYPE_NAME;
    SceneManager* createInstance(const String& instanceName);
    void destroyInstance(SceneManager* instance);
};



}

#endif

---

Copyright © 2000-2005 by The OGRE Team

This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Sun Mar 12 14:37:45 2006