OgreSceneQuery.h

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
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 __SceneQuery_H__
#define __SceneQuery_H__

#include "OgrePrerequisites.h"
#include "OgreAxisAlignedBox.h"
#include "OgreSphere.h"
#include "OgreRay.h"
#include "OgreRenderOperation.h"
#include "OgrePlaneBoundedVolume.h"

namespace Ogre {

    // forward declaration
    class SceneQueryListener;
    class _OgreExport SceneQuery
    {
    public:
        enum WorldFragmentType {
            WFT_NONE,
            WFT_PLANE_BOUNDED_REGION,
            WFT_SINGLE_INTERSECTION,
            WFT_CUSTOM_GEOMETRY,
            WFT_RENDER_OPERATION
        };

        struct WorldFragment {
            WorldFragmentType fragmentType;
            Vector3 singleIntersection;
            std::list<Plane>* planes;
            void* geometry;
            RenderOperation* renderOp;
            
        };
    protected:
        SceneManager* mParentSceneMgr;
        unsigned long mQueryMask;
        std::set<WorldFragmentType> mSupportedWorldFragments;
        WorldFragmentType mWorldFragmentType;
    
    public:
        SceneQuery(SceneManager* mgr);
        virtual ~SceneQuery();

        virtual void setQueryMask(unsigned long mask);
        virtual unsigned long getQueryMask(void) const;

        virtual void setWorldFragmentType(enum WorldFragmentType wft);

        virtual WorldFragmentType getWorldFragmentType(void) const;

        virtual const std::set<WorldFragmentType>* getSupportedWorldFragmentTypes(void) const
            {return &mSupportedWorldFragments;}

        
    };

    class _OgreExport SceneQueryListener
    {
    public:
        virtual ~SceneQueryListener() { }
        virtual bool queryResult(MovableObject* object) = 0;
        virtual bool queryResult(SceneQuery::WorldFragment* fragment) = 0;

    };

    typedef std::list<MovableObject*> SceneQueryResultMovableList;
    typedef std::list<SceneQuery::WorldFragment*> SceneQueryResultWorldFragmentList;
    struct _OgreExport SceneQueryResult
    {
        SceneQueryResultMovableList movables;
        SceneQueryResultWorldFragmentList worldFragments;
    };

    class _OgreExport RegionSceneQuery
        : public SceneQuery, public SceneQueryListener
    {
    protected:
        SceneQueryResult* mLastResult;
    public:
        RegionSceneQuery(SceneManager* mgr);
        virtual ~RegionSceneQuery();
        virtual SceneQueryResult& execute(void);

        virtual void execute(SceneQueryListener* listener) = 0;
        
        virtual SceneQueryResult& getLastResults(void) const;
        virtual void clearResults(void);

        bool queryResult(MovableObject* first);
        bool queryResult(SceneQuery::WorldFragment* fragment);
    };

    class _OgreExport AxisAlignedBoxSceneQuery : public RegionSceneQuery
    {
    protected:
        AxisAlignedBox mAABB;
    public:
        AxisAlignedBoxSceneQuery(SceneManager* mgr);
        virtual ~AxisAlignedBoxSceneQuery();

        void setBox(const AxisAlignedBox& box);

        const AxisAlignedBox& getBox(void) const;

    };

    class _OgreExport SphereSceneQuery : public RegionSceneQuery
    {
    protected:
        Sphere mSphere;
    public:
        SphereSceneQuery(SceneManager* mgr);
        virtual ~SphereSceneQuery();
        void setSphere(const Sphere& sphere);

        const Sphere& getSphere() const;

    };

    class _OgreExport PlaneBoundedVolumeListSceneQuery : public RegionSceneQuery
    {
    protected:
        PlaneBoundedVolumeList mVolumes;
    public:
        PlaneBoundedVolumeListSceneQuery(SceneManager* mgr);
        virtual ~PlaneBoundedVolumeListSceneQuery();
        void setVolumes(const PlaneBoundedVolumeList& volumes);

        const PlaneBoundedVolumeList& getVolumes() const;

    };


    /*
    class _OgreExport PyramidSceneQuery : public RegionSceneQuery
    {
    public:
        PyramidSceneQuery(SceneManager* mgr);
        virtual ~PyramidSceneQuery();
    };
    */

    class _OgreExport RaySceneQueryListener 
    {
    public:
        virtual ~RaySceneQueryListener() { }
        virtual bool queryResult(MovableObject* obj, Real distance) = 0;

        virtual bool queryResult(SceneQuery::WorldFragment* fragment, Real distance) = 0;

    };
      
    struct _OgreExport RaySceneQueryResultEntry
    {
        Real distance;
        MovableObject* movable;
        SceneQuery::WorldFragment* worldFragment;
        bool operator < (const RaySceneQueryResultEntry& rhs) const
        {
            return this->distance < rhs.distance;
        }

    };
    typedef std::list<RaySceneQueryResultEntry> RaySceneQueryResult;

    class _OgreExport RaySceneQuery : public SceneQuery, public RaySceneQueryListener
    {
    protected:
        Ray mRay;
        bool mSortByDistance;
        ushort mMaxResults;
        RaySceneQueryResult* mLastResult;

    public:
        RaySceneQuery(SceneManager* mgr);
        virtual ~RaySceneQuery();
        virtual void setRay(const Ray& ray);
        virtual const Ray& getRay(void) const;
        virtual void setSortByDistance(bool sort, ushort maxresults = 0);
        virtual bool getSortByDistance(void) const;
        virtual ushort getMaxResults(void) const;
        virtual RaySceneQueryResult& execute(void);

        virtual void execute(RaySceneQueryListener* listener) = 0;

        virtual RaySceneQueryResult& getLastResults(void) const;
        virtual void clearResults(void);

        bool queryResult(MovableObject* obj, Real distance);
        bool queryResult(SceneQuery::WorldFragment* fragment, Real distance);




    };

    class _OgreExport IntersectionSceneQueryListener 
    {
    public:
        virtual ~IntersectionSceneQueryListener() { }
        virtual bool queryResult(MovableObject* first, MovableObject* second) = 0;

        virtual bool queryResult(MovableObject* movable, SceneQuery::WorldFragment* fragment) = 0;

        /* NB there are no results for world fragments intersecting other world fragments;
           it is assumed that world geometry is either static or at least that self-intersections
           are irrelevant or dealt with elsewhere (such as the custom scene manager) */
        
    
    };
        
    typedef std::pair<MovableObject*, MovableObject*> SceneQueryMovableObjectPair;
    typedef std::pair<MovableObject*, SceneQuery::WorldFragment*> SceneQueryMovableObjectWorldFragmentPair;
    typedef std::list<SceneQueryMovableObjectPair> SceneQueryMovableIntersectionList;
    typedef std::list<SceneQueryMovableObjectWorldFragmentPair> SceneQueryMovableWorldFragmentIntersectionList;
    struct _OgreExport IntersectionSceneQueryResult
    {
        SceneQueryMovableIntersectionList movables2movables;
        SceneQueryMovableWorldFragmentIntersectionList movables2world;
        
        

    };

    class _OgreExport IntersectionSceneQuery
        : public SceneQuery, public IntersectionSceneQueryListener 
    {
    protected:
        IntersectionSceneQueryResult* mLastResult;
    public:
        IntersectionSceneQuery(SceneManager* mgr);
        virtual ~IntersectionSceneQuery();

        virtual IntersectionSceneQueryResult& execute(void);

        virtual void execute(IntersectionSceneQueryListener* listener) = 0;

        virtual IntersectionSceneQueryResult& getLastResults(void) const;
        virtual void clearResults(void);

        bool queryResult(MovableObject* first, MovableObject* second);
        bool queryResult(MovableObject* movable, SceneQuery::WorldFragment* fragment);
    };
    

}
    


#endif

---

Copyright © 2000-2005 by The OGRE Team

This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Sun Feb 12 12:59:52 2006