OgreSceneQuery.h
Go to the documentation of this file.
1 /*
2 -----------------------------------------------------------------------------
3 This source file is part of OGRE
4  (Object-oriented Graphics Rendering Engine)
5 For the latest info, see http://www.ogre3d.org/
6 
7 Copyright (c) 2000-2013 Torus Knot Software Ltd
8 
9 Permission is hereby granted, free of charge, to any person obtaining a copy
10 of this software and associated documentation files (the "Software"), to deal
11 in the Software without restriction, including without limitation the rights
12 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
13 copies of the Software, and to permit persons to whom the Software is
14 furnished to do so, subject to the following conditions:
15 
16 The above copyright notice and this permission notice shall be included in
17 all copies or substantial portions of the Software.
18 
19 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
22 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25 THE SOFTWARE.
26 -----------------------------------------------------------------------------
27 */
28 #ifndef __SceneQuery_H__
29 #define __SceneQuery_H__
30 
31 #include "OgrePrerequisites.h"
32 #include "OgreAxisAlignedBox.h"
33 #include "OgreSphere.h"
34 #include "OgreRay.h"
35 #include "OgreRenderOperation.h"
36 #include "OgrePlaneBoundedVolume.h"
37 #include "OgreHeaderPrefix.h"
38 
39 namespace Ogre {
40 
41  // forward declaration
42  class SceneQueryListener;
75  {
76  public:
93  WFT_RENDER_OPERATION
94  };
95 
109  struct WorldFragment {
117  void* geometry;
120 
121  };
122  protected:
128 
129  public:
132  virtual ~SceneQuery();
133 
143  virtual void setQueryMask(uint32 mask);
145  virtual uint32 getQueryMask(void) const;
146 
155  virtual void setQueryTypeMask(uint32 mask);
157  virtual uint32 getQueryTypeMask(void) const;
158 
169  virtual void setWorldFragmentType(enum WorldFragmentType wft);
170 
173 
176  {return &mSupportedWorldFragments;}
177 
178 
179  };
180 
188  {
189  public:
190  virtual ~SceneQueryListener() { }
196  virtual bool queryResult(MovableObject* object) = 0;
202  virtual bool queryResult(SceneQuery::WorldFragment* fragment) = 0;
203 
204  };
205 
210  {
215  };
216 
224  : public SceneQuery, public SceneQueryListener
225  {
226  protected:
228  public:
231  virtual ~RegionSceneQuery();
240  virtual SceneQueryResult& execute(void);
241 
249  virtual void execute(SceneQueryListener* listener) = 0;
250 
254  virtual SceneQueryResult& getLastResults(void) const;
261  virtual void clearResults(void);
262 
267  };
268 
271  {
272  protected:
274  public:
277 
279  void setBox(const AxisAlignedBox& box);
280 
282  const AxisAlignedBox& getBox(void) const;
283 
284  };
285 
288  {
289  protected:
291  public:
293  virtual ~SphereSceneQuery();
295  void setSphere(const Sphere& sphere);
296 
298  const Sphere& getSphere() const;
299 
300  };
301 
305  {
306  protected:
308  public:
312  void setVolumes(const PlaneBoundedVolumeList& volumes);
313 
316 
317  };
318 
319 
320  /*
322  class _OgreExport PyramidSceneQuery : public RegionSceneQuery
323  {
324  public:
325  PyramidSceneQuery(SceneManager* mgr);
326  virtual ~PyramidSceneQuery();
327  };
328  */
329 
336  {
337  public:
345  virtual bool queryResult(MovableObject* obj, Real distance) = 0;
346 
353  virtual bool queryResult(SceneQuery::WorldFragment* fragment, Real distance) = 0;
354 
355  };
356 
359  {
367  bool operator < (const RaySceneQueryResultEntry& rhs) const
368  {
369  return this->distance < rhs.distance;
370  }
371 
372  };
374 
377  {
378  protected:
383 
384  public:
386  virtual ~RaySceneQuery();
388  virtual void setRay(const Ray& ray);
390  virtual const Ray& getRay(void) const;
409  virtual void setSortByDistance(bool sort, ushort maxresults = 0);
411  virtual bool getSortByDistance(void) const;
414  virtual ushort getMaxResults(void) const;
423  virtual RaySceneQueryResult& execute(void);
424 
432  virtual void execute(RaySceneQueryListener* listener) = 0;
433 
444  virtual void clearResults(void);
445 
447  bool queryResult(MovableObject* obj, Real distance);
449  bool queryResult(SceneQuery::WorldFragment* fragment, Real distance);
450 
451 
452 
453 
454  };
455 
462  {
463  public:
471  virtual bool queryResult(MovableObject* first, MovableObject* second) = 0;
472 
479  virtual bool queryResult(MovableObject* movable, SceneQuery::WorldFragment* fragment) = 0;
480 
481  /* NB there are no results for world fragments intersecting other world fragments;
482  it is assumed that world geometry is either static or at least that self-intersections
483  are irrelevant or dealt with elsewhere (such as the custom scene manager) */
484 
485 
486  };
487 
488  typedef std::pair<MovableObject*, MovableObject*> SceneQueryMovableObjectPair;
489  typedef std::pair<MovableObject*, SceneQuery::WorldFragment*> SceneQueryMovableObjectWorldFragmentPair;
494  {
499 
500 
501 
502  };
503 
514  {
515  protected:
517  public:
520 
530 
538  virtual void execute(IntersectionSceneQueryListener* listener) = 0;
539 
550  virtual void clearResults(void);
551 
553  bool queryResult(MovableObject* first, MovableObject* second);
556  };
557 
561 }
562 
563 #include "OgreHeaderSuffix.h"
564 
565 #endif
OgreHeaderSuffix.h
Ogre::AxisAlignedBoxSceneQuery::~AxisAlignedBoxSceneQuery
virtual ~AxisAlignedBoxSceneQuery()
Ogre::SceneQuery::mParentSceneMgr
SceneManager * mParentSceneMgr
Definition: OgreSceneQuery.h:123
Ogre::SceneQuery::WorldFragment::planes
list< Plane >::type * planes
Planes bounding a convex region, only applicable for WFT_PLANE_BOUNDED_REGION.
Definition: OgreSceneQuery.h:115
Ogre::SceneQuery::WorldFragmentType
WorldFragmentType
This type can be used by collaborating applications & SceneManagers to agree on the type of world geo...
Definition: OgreSceneQuery.h:83
Ogre::SphereSceneQuery::SphereSceneQuery
SphereSceneQuery(SceneManager *mgr)
Ogre::SceneQuery
A class for performing queries on a scene.
Definition: OgreSceneQuery.h:75
Ogre::SceneQuery::WFT_CUSTOM_GEOMETRY
@ WFT_CUSTOM_GEOMETRY
Custom geometry as defined by the SceneManager.
Definition: OgreSceneQuery.h:91
Ogre::AllocatedObject
Superclass for all objects that wish to use custom memory allocators when their new / delete operator...
Definition: OgreMemoryAllocatedObject.h:59
Ogre
Definition: OgreAndroidLogListener.h:35
Ogre::SphereSceneQuery::setSphere
void setSphere(const Sphere &sphere)
Sets the sphere which is to be used for this query.
Ogre::SceneQuery::WFT_SINGLE_INTERSECTION
@ WFT_SINGLE_INTERSECTION
Return a single intersection point (typically RaySceneQuery only)
Definition: OgreSceneQuery.h:89
Ogre::RaySceneQuery::getLastResults
virtual RaySceneQueryResult & getLastResults(void)
Gets the results of the last query that was run using this object, provided the query was executed us...
Ogre::RaySceneQuery::RaySceneQuery
RaySceneQuery(SceneManager *mgr)
Ogre::RegionSceneQuery::execute
virtual void execute(SceneQueryListener *listener)=0
Executes the query and returns each match through a listener interface.
Ogre::RaySceneQuery::setRay
virtual void setRay(const Ray &ray)
Sets the ray which is to be used for this query.
Ogre::ushort
unsigned short ushort
Definition: OgrePrerequisites.h:113
Ogre::IntersectionSceneQuery::execute
virtual IntersectionSceneQueryResult & execute(void)
Executes the query, returning the results back in one list.
Ogre::set
Definition: OgrePrerequisites.h:520
Ogre::IntersectionSceneQueryListener::~IntersectionSceneQueryListener
virtual ~IntersectionSceneQueryListener()
Definition: OgreSceneQuery.h:464
Ogre::SceneQuery::WFT_NONE
@ WFT_NONE
Return no world geometry hits at all.
Definition: OgreSceneQuery.h:85
Ogre::RaySceneQuery::~RaySceneQuery
virtual ~RaySceneQuery()
Ogre::IntersectionSceneQueryListener::queryResult
virtual bool queryResult(MovableObject *movable, SceneQuery::WorldFragment *fragment)=0
Called when a movable intersects a world fragment.
Ogre::SceneQueryListener
This optional class allows you to receive per-result callbacks from SceneQuery executions instead of ...
Definition: OgreSceneQuery.h:188
Ogre::RegionSceneQuery::execute
virtual SceneQueryResult & execute(void)
Executes the query, returning the results back in one list.
Ogre::SceneQuery::getSupportedWorldFragmentTypes
virtual const set< WorldFragmentType >::type * getSupportedWorldFragmentTypes(void) const
Returns the types of world fragments this query supports.
Definition: OgreSceneQuery.h:175
Ogre::SphereSceneQuery
Specialises the SceneQuery class for querying within a sphere.
Definition: OgreSceneQuery.h:288
Ogre::RaySceneQueryListener::~RaySceneQueryListener
virtual ~RaySceneQueryListener()
Definition: OgreSceneQuery.h:338
Ogre::AxisAlignedBoxSceneQuery::setBox
void setBox(const AxisAlignedBox &box)
Sets the size of the box you wish to query.
Ogre::PlaneBoundedVolumeListSceneQuery::getVolumes
const PlaneBoundedVolumeList & getVolumes() const
Gets the volume which is being used for this query.
OgreRay.h
Ogre::SceneQueryResult::worldFragments
SceneQueryResultWorldFragmentList worldFragments
List of world fragments.
Definition: OgreSceneQuery.h:214
Ogre::SceneQuery::WorldFragment::fragmentType
WorldFragmentType fragmentType
The type of this world fragment.
Definition: OgreSceneQuery.h:111
Ogre::RaySceneQuery::getSortByDistance
virtual bool getSortByDistance(void) const
Gets whether the results are sorted by distance.
Ogre::RegionSceneQuery::RegionSceneQuery
RegionSceneQuery(SceneManager *mgr)
Standard constructor, should be called by SceneManager.
Ogre::MovableObject
Abstract class defining a movable object in a scene.
Definition: OgreMovableObject.h:61
Ogre::SphereSceneQuery::~SphereSceneQuery
virtual ~SphereSceneQuery()
Ogre::SceneQueryMovableWorldFragmentIntersectionList
list< SceneQueryMovableObjectWorldFragmentPair >::type SceneQueryMovableWorldFragmentIntersectionList
Definition: OgreSceneQuery.h:491
Ogre::IntersectionSceneQuery
Separate SceneQuery class to query for pairs of objects which are possibly intersecting one another.
Definition: OgreSceneQuery.h:514
Ogre::IntersectionSceneQueryResult::movables2world
SceneQueryMovableWorldFragmentIntersectionList movables2world
List of movable / world intersections.
Definition: OgreSceneQuery.h:498
Ogre::uint32
unsigned int uint32
Definition: OgrePlatform.h:359
Ogre::SceneQueryResultWorldFragmentList
list< SceneQuery::WorldFragment * >::type SceneQueryResultWorldFragmentList
Definition: OgreSceneQuery.h:207
Ogre::AxisAlignedBoxSceneQuery
Specialises the SceneQuery class for querying within an axis aligned box.
Definition: OgreSceneQuery.h:271
Ogre::PlaneBoundedVolumeListSceneQuery::setVolumes
void setVolumes(const PlaneBoundedVolumeList &volumes)
Sets the volume which is to be used for this query.
Ogre::SceneQuery::setWorldFragmentType
virtual void setWorldFragmentType(enum WorldFragmentType wft)
Tells the query what kind of world geometry to return from queries; often the full renderable geometr...
Ogre::SceneQuery::getQueryTypeMask
virtual uint32 getQueryTypeMask(void) const
Returns the current mask for this query.
Ogre::RegionSceneQuery::queryResult
bool queryResult(MovableObject *first)
Self-callback in order to deal with execute which returns collection.
Ogre::SceneQuery::mWorldFragmentType
WorldFragmentType mWorldFragmentType
Definition: OgreSceneQuery.h:127
Ogre::RaySceneQueryListener::queryResult
virtual bool queryResult(MovableObject *obj, Real distance)=0
Called when a movable objects intersects the ray.
Ogre::SceneQueryListener::queryResult
virtual bool queryResult(SceneQuery::WorldFragment *fragment)=0
Called when a WorldFragment is returned by a query.
Ogre::IntersectionSceneQuery::queryResult
bool queryResult(MovableObject *first, MovableObject *second)
Self-callback in order to deal with execute which returns collection.
Ogre::RaySceneQueryResultEntry::worldFragment
SceneQuery::WorldFragment * worldFragment
The world fragment, or NULL if this is not a fragment result.
Definition: OgreSceneQuery.h:365
Ogre::SceneQuery::SceneQuery
SceneQuery(SceneManager *mgr)
Standard constructor, should be called by SceneManager.
Ogre::SceneQuery::getWorldFragmentType
virtual WorldFragmentType getWorldFragmentType(void) const
Gets the current world fragment types to be returned from the query.
Ogre::SceneQueryListener::queryResult
virtual bool queryResult(MovableObject *object)=0
Called when a MovableObject is returned by a query.
Ogre::RaySceneQueryResultEntry::distance
Real distance
Distance along the ray.
Definition: OgreSceneQuery.h:361
Ogre::IntersectionSceneQueryListener::queryResult
virtual bool queryResult(MovableObject *first, MovableObject *second)=0
Called when 2 movable objects intersect one another.
Ogre::RaySceneQueryResult
vector< RaySceneQueryResultEntry >::type RaySceneQueryResult
Definition: OgreSceneQuery.h:373
Ogre::IntersectionSceneQuery::~IntersectionSceneQuery
virtual ~IntersectionSceneQuery()
OgreRenderOperation.h
OgreHeaderPrefix.h
Ogre::list
Definition: OgrePrerequisites.h:506
Ogre::list::type
std::list< T, A > type
Definition: OgrePrerequisites.h:508
Ogre::SceneManager
Manages the organisation and rendering of a 'scene' i.e.
Definition: OgreSceneManager.h:144
Ogre::IntersectionSceneQueryResult
Holds the results of an intersection scene query (pair values).
Definition: OgreSceneQuery.h:494
Ogre::RaySceneQuery::queryResult
bool queryResult(MovableObject *obj, Real distance)
Self-callback in order to deal with execute which returns collection.
OgreSphere.h
Ogre::SceneQuery::~SceneQuery
virtual ~SceneQuery()
OgrePrerequisites.h
Ogre::SceneQueryMovableObjectWorldFragmentPair
std::pair< MovableObject *, SceneQuery::WorldFragment * > SceneQueryMovableObjectWorldFragmentPair
Definition: OgreSceneQuery.h:489
Ogre::RaySceneQuery::mResult
RaySceneQueryResult mResult
Definition: OgreSceneQuery.h:382
Ogre::AxisAlignedBoxSceneQuery::AxisAlignedBoxSceneQuery
AxisAlignedBoxSceneQuery(SceneManager *mgr)
Ogre::RaySceneQuery::execute
virtual RaySceneQueryResult & execute(void)
Executes the query, returning the results back in one list.
Ogre::SceneQueryMovableIntersectionList
list< SceneQueryMovableObjectPair >::type SceneQueryMovableIntersectionList
Definition: OgreSceneQuery.h:490
Ogre::RegionSceneQuery
Abstract class defining a query which returns single results from a region.
Definition: OgreSceneQuery.h:225
Ogre::IntersectionSceneQueryResult::movables2movables
SceneQueryMovableIntersectionList movables2movables
List of movable / movable intersections (entities, particle systems etc)
Definition: OgreSceneQuery.h:496
Ogre::AxisAlignedBox
A 3D box aligned with the x/y/z axes.
Definition: OgreAxisAlignedBox.h:55
_OgreExport
#define _OgreExport
Definition: OgrePlatform.h:257
Ogre::PlaneBoundedVolumeListSceneQuery::~PlaneBoundedVolumeListSceneQuery
virtual ~PlaneBoundedVolumeListSceneQuery()
Ogre::RegionSceneQuery::mLastResult
SceneQueryResult * mLastResult
Definition: OgreSceneQuery.h:227
Ogre::RaySceneQuery::mRay
Ray mRay
Definition: OgreSceneQuery.h:379
Ogre::RaySceneQuery::mMaxResults
ushort mMaxResults
Definition: OgreSceneQuery.h:381
Ogre::RaySceneQueryResultEntry
This struct allows a single comparison of result data no matter what the type.
Definition: OgreSceneQuery.h:359
Ogre::SceneQuery::mSupportedWorldFragments
set< WorldFragmentType >::type mSupportedWorldFragments
Definition: OgreSceneQuery.h:126
Ogre::Sphere
A sphere primitive, mostly used for bounds checking.
Definition: OgreSphere.h:52
Ogre::SphereSceneQuery::mSphere
Sphere mSphere
Definition: OgreSceneQuery.h:290
Ogre::SphereSceneQuery::getSphere
const Sphere & getSphere() const
Gets the sphere which is being used for this query.
Ogre::RegionSceneQuery::clearResults
virtual void clearResults(void)
Clears the results of the last query execution.
Ogre::SceneQueryListener::~SceneQueryListener
virtual ~SceneQueryListener()
Definition: OgreSceneQuery.h:190
Ogre::RaySceneQuery
Specialises the SceneQuery class for querying along a ray.
Definition: OgreSceneQuery.h:377
Ogre::IntersectionSceneQueryListener
Alternative listener class for dealing with IntersectionSceneQuery.
Definition: OgreSceneQuery.h:462
Ogre::SceneQueryResultMovableList
list< MovableObject * >::type SceneQueryResultMovableList
Definition: OgreSceneQuery.h:206
Ogre::PlaneBoundedVolumeListSceneQuery
Specialises the SceneQuery class for querying within a plane-bounded volume.
Definition: OgreSceneQuery.h:305
Ogre::RaySceneQuery::setSortByDistance
virtual void setSortByDistance(bool sort, ushort maxresults=0)
Sets whether the results of this query will be sorted by distance along the ray.
Ogre::SceneQuery::mQueryMask
uint32 mQueryMask
Definition: OgreSceneQuery.h:124
Ogre::IntersectionSceneQuery::getLastResults
virtual IntersectionSceneQueryResult & getLastResults(void) const
Gets the results of the last query that was run using this object, provided the query was executed us...
Ogre::RaySceneQuery::execute
virtual void execute(RaySceneQueryListener *listener)=0
Executes the query and returns each match through a listener interface.
Ogre::RaySceneQueryResultEntry::movable
MovableObject * movable
The movable, or NULL if this is not a movable result.
Definition: OgreSceneQuery.h:363
Ogre::RaySceneQueryListener
Alternative listener class for dealing with RaySceneQuery.
Definition: OgreSceneQuery.h:336
Ogre::SceneQuery::WorldFragment::renderOp
RenderOperation * renderOp
General render operation structure, fallback if nothing else is available.
Definition: OgreSceneQuery.h:119
Ogre::SceneQuery::setQueryMask
virtual void setQueryMask(uint32 mask)
Sets the mask for results of this query.
Ogre::IntersectionSceneQuery::mLastResult
IntersectionSceneQueryResult * mLastResult
Definition: OgreSceneQuery.h:516
Ogre::RegionSceneQuery::getLastResults
virtual SceneQueryResult & getLastResults(void) const
Gets the results of the last query that was run using this object, provided the query was executed us...
Ogre::SceneQuery::WorldFragment
Represents part of the world geometry that is a result of a SceneQuery.
Definition: OgreSceneQuery.h:109
Ogre::IntersectionSceneQuery::IntersectionSceneQuery
IntersectionSceneQuery(SceneManager *mgr)
Ogre::RegionSceneQuery::~RegionSceneQuery
virtual ~RegionSceneQuery()
Ogre::RaySceneQuery::queryResult
bool queryResult(SceneQuery::WorldFragment *fragment, Real distance)
Self-callback in order to deal with execute which returns collection.
Ogre::SceneQuery::getQueryMask
virtual uint32 getQueryMask(void) const
Returns the current mask for this query.
Ogre::Real
float Real
Software floating point type.
Definition: OgrePrerequisites.h:70
Ogre::PlaneBoundedVolumeList
vector< PlaneBoundedVolume >::type PlaneBoundedVolumeList
Definition: OgrePlaneBoundedVolume.h:128
Ogre::RaySceneQuery::getRay
virtual const Ray & getRay(void) const
Gets the ray which is to be used for this query.
Ogre::RaySceneQueryListener::queryResult
virtual bool queryResult(SceneQuery::WorldFragment *fragment, Real distance)=0
Called when a world fragment is intersected by the ray.
Ogre::RaySceneQuery::clearResults
virtual void clearResults(void)
Clears the results of the last query execution.
OgreAxisAlignedBox.h
Ogre::SceneQuery::WorldFragment::geometry
void * geometry
Custom geometry block, only applicable for WFT_CUSTOM_GEOMETRY.
Definition: OgreSceneQuery.h:117
Ogre::IntersectionSceneQuery::clearResults
virtual void clearResults(void)
Clears the results of the last query execution.
Ogre::AxisAlignedBoxSceneQuery::mAABB
AxisAlignedBox mAABB
Definition: OgreSceneQuery.h:273
Ogre::SceneQueryResult
Holds the results of a scene query.
Definition: OgreSceneQuery.h:210
Ogre::vector
Definition: OgrePrerequisites.h:492
Ogre::SceneQuery::setQueryTypeMask
virtual void setQueryTypeMask(uint32 mask)
Sets the type mask for results of this query.
Ogre::Ray
Representation of a ray in space, i.e.
Definition: OgreRay.h:47
Ogre::RegionSceneQuery::queryResult
bool queryResult(SceneQuery::WorldFragment *fragment)
Self-callback in order to deal with execute which returns collection.
Ogre::SceneQuery::WorldFragment::singleIntersection
Vector3 singleIntersection
Single intersection point, only applicable for WFT_SINGLE_INTERSECTION.
Definition: OgreSceneQuery.h:113
Ogre::operator<
bool operator<(SharedPtr< T > const &a, SharedPtr< U > const &b)
Definition: OgreSharedPtr.h:326
Ogre::AxisAlignedBoxSceneQuery::getBox
const AxisAlignedBox & getBox(void) const
Gets the box which is being used for this query.
Ogre::RaySceneQuery::mSortByDistance
bool mSortByDistance
Definition: OgreSceneQuery.h:380
OgrePlaneBoundedVolume.h
Ogre::Vector3
Standard 3-dimensional vector.
Definition: OgreVector3.h:52
Ogre::SceneQuery::WFT_PLANE_BOUNDED_REGION
@ WFT_PLANE_BOUNDED_REGION
Return pointers to convex plane-bounded regions.
Definition: OgreSceneQuery.h:87
Ogre::RenderOperation
'New' rendering operation using vertex buffers.
Definition: OgreRenderOperation.h:45
Ogre::IntersectionSceneQuery::execute
virtual void execute(IntersectionSceneQueryListener *listener)=0
Executes the query and returns each match through a listener interface.
Ogre::RaySceneQuery::getMaxResults
virtual ushort getMaxResults(void) const
Gets the maximum number of results returned from the query (only relevant if results are being sorted...
Ogre::SceneQueryResult::movables
SceneQueryResultMovableList movables
List of movable objects in the query (entities, particle systems etc)
Definition: OgreSceneQuery.h:212
Ogre::SceneQueryMovableObjectPair
std::pair< MovableObject *, MovableObject * > SceneQueryMovableObjectPair
Definition: OgreSceneQuery.h:488
Ogre::SceneQuery::mQueryTypeMask
uint32 mQueryTypeMask
Definition: OgreSceneQuery.h:125
Ogre::PlaneBoundedVolumeListSceneQuery::PlaneBoundedVolumeListSceneQuery
PlaneBoundedVolumeListSceneQuery(SceneManager *mgr)
Ogre::PlaneBoundedVolumeListSceneQuery::mVolumes
PlaneBoundedVolumeList mVolumes
Definition: OgreSceneQuery.h:307
Ogre::IntersectionSceneQuery::queryResult
bool queryResult(MovableObject *movable, SceneQuery::WorldFragment *fragment)
Self-callback in order to deal with execute which returns collection.

Copyright © 2012 Torus Knot Software Ltd
Creative Commons License
This work is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License.