OGRE  1.9.0
OgreSceneQuery.h
Go to the documentation of this file.
1/*
2-----------------------------------------------------------------------------
3This source file is part of OGRE
4 (Object-oriented Graphics Rendering Engine)
5For the latest info, see http://www.ogre3d.org/
6
7Copyright (c) 2000-2014 Torus Knot Software Ltd
8
9Permission is hereby granted, free of charge, to any person obtaining a copy
10of this software and associated documentation files (the "Software"), to deal
11in the Software without restriction, including without limitation the rights
12to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
13copies of the Software, and to permit persons to whom the Software is
14furnished to do so, subject to the following conditions:
15
16The above copyright notice and this permission notice shall be included in
17all copies or substantial portions of the Software.
18
19THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
22AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25THE 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"
37#include "OgreHeaderPrefix.h"
38
39namespace Ogre {
40
41 // forward declaration
42 class SceneQueryListener;
75 {
76 public:
93 WFT_RENDER_OPERATION
94 };
95
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
170
173
176 {return &mSupportedWorldFragments;}
177
178
179 };
180
188 {
189 public:
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:
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:
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;
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
556 };
557
561}
562
563#include "OgreHeaderSuffix.h"
564
565#endif
#define _OgreExport
Superclass for all objects that wish to use custom memory allocators when their new / delete operator...
Specialises the SceneQuery class for querying within an axis aligned box.
const AxisAlignedBox & getBox(void) const
Gets the box which is being used for this query.
void setBox(const AxisAlignedBox &box)
Sets the size of the box you wish to query.
AxisAlignedBoxSceneQuery(SceneManager *mgr)
A 3D box aligned with the x/y/z axes.
Alternative listener class for dealing with IntersectionSceneQuery.
virtual bool queryResult(MovableObject *first, MovableObject *second)=0
Called when 2 movable objects intersect one another.
virtual bool queryResult(MovableObject *movable, SceneQuery::WorldFragment *fragment)=0
Called when a movable intersects a world fragment.
Separate SceneQuery class to query for pairs of objects which are possibly intersecting one another.
bool queryResult(MovableObject *first, MovableObject *second)
Self-callback in order to deal with execute which returns collection.
virtual IntersectionSceneQueryResult & execute(void)
Executes the query, returning the results back in one list.
IntersectionSceneQuery(SceneManager *mgr)
virtual IntersectionSceneQueryResult & getLastResults(void) const
Gets the results of the last query that was run using this object, provided the query was executed us...
virtual void clearResults(void)
Clears the results of the last query execution.
IntersectionSceneQueryResult * mLastResult
virtual void execute(IntersectionSceneQueryListener *listener)=0
Executes the query and returns each match through a listener interface.
bool queryResult(MovableObject *movable, SceneQuery::WorldFragment *fragment)
Self-callback in order to deal with execute which returns collection.
Abstract class defining a movable object in a scene.
Specialises the SceneQuery class for querying within a plane-bounded volume.
PlaneBoundedVolumeListSceneQuery(SceneManager *mgr)
void setVolumes(const PlaneBoundedVolumeList &volumes)
Sets the volume which is to be used for this query.
const PlaneBoundedVolumeList & getVolumes() const
Gets the volume which is being used for this query.
Alternative listener class for dealing with RaySceneQuery.
virtual bool queryResult(SceneQuery::WorldFragment *fragment, Real distance)=0
Called when a world fragment is intersected by the ray.
virtual bool queryResult(MovableObject *obj, Real distance)=0
Called when a movable objects intersects the ray.
Specialises the SceneQuery class for querying along a ray.
RaySceneQuery(SceneManager *mgr)
virtual void setSortByDistance(bool sort, ushort maxresults=0)
Sets whether the results of this query will be sorted by distance along the ray.
virtual void setRay(const Ray &ray)
Sets the ray which is to be used for this query.
RaySceneQueryResult mResult
virtual bool getSortByDistance(void) const
Gets whether the results are sorted by distance.
bool queryResult(MovableObject *obj, Real distance)
Self-callback in order to deal with execute which returns collection.
virtual RaySceneQueryResult & execute(void)
Executes the query, returning the results back in one list.
virtual const Ray & getRay(void) const
Gets the ray which is to be used for this query.
virtual RaySceneQueryResult & getLastResults(void)
Gets the results of the last query that was run using this object, provided the query was executed us...
bool queryResult(SceneQuery::WorldFragment *fragment, Real distance)
Self-callback in order to deal with execute which returns collection.
virtual ~RaySceneQuery()
virtual ushort getMaxResults(void) const
Gets the maximum number of results returned from the query (only relevant if results are being sorted...
virtual void clearResults(void)
Clears the results of the last query execution.
virtual void execute(RaySceneQueryListener *listener)=0
Executes the query and returns each match through a listener interface.
Representation of a ray in space, i.e.
Definition OgreRay.h:47
Abstract class defining a query which returns single results from a region.
virtual void clearResults(void)
Clears the results of the last query execution.
virtual void execute(SceneQueryListener *listener)=0
Executes the query and returns each match through a listener interface.
bool queryResult(MovableObject *first)
Self-callback in order to deal with execute which returns collection.
virtual SceneQueryResult & getLastResults(void) const
Gets the results of the last query that was run using this object, provided the query was executed us...
virtual SceneQueryResult & execute(void)
Executes the query, returning the results back in one list.
SceneQueryResult * mLastResult
RegionSceneQuery(SceneManager *mgr)
Standard constructor, should be called by SceneManager.
bool queryResult(SceneQuery::WorldFragment *fragment)
Self-callback in order to deal with execute which returns collection.
'New' rendering operation using vertex buffers.
Manages the organisation and rendering of a 'scene' i.e.
This optional class allows you to receive per-result callbacks from SceneQuery executions instead of ...
virtual bool queryResult(MovableObject *object)=0
Called when a MovableObject is returned by a query.
virtual bool queryResult(SceneQuery::WorldFragment *fragment)=0
Called when a WorldFragment is returned by a query.
A class for performing queries on a scene.
WorldFragmentType
This type can be used by collaborating applications & SceneManagers to agree on the type of world geo...
@ WFT_SINGLE_INTERSECTION
Return a single intersection point (typically RaySceneQuery only)
@ WFT_PLANE_BOUNDED_REGION
Return pointers to convex plane-bounded regions.
@ WFT_NONE
Return no world geometry hits at all.
@ WFT_CUSTOM_GEOMETRY
Custom geometry as defined by the SceneManager.
SceneManager * mParentSceneMgr
virtual ~SceneQuery()
virtual uint32 getQueryTypeMask(void) const
Returns the current mask for this query.
SceneQuery(SceneManager *mgr)
Standard constructor, should be called by SceneManager.
virtual const set< WorldFragmentType >::type * getSupportedWorldFragmentTypes(void) const
Returns the types of world fragments this query supports.
WorldFragmentType mWorldFragmentType
set< WorldFragmentType >::type mSupportedWorldFragments
virtual void setQueryTypeMask(uint32 mask)
Sets the type mask for results of this query.
virtual WorldFragmentType getWorldFragmentType(void) const
Gets the current world fragment types to be returned from the query.
virtual void setQueryMask(uint32 mask)
Sets the mask for results of this query.
virtual void setWorldFragmentType(enum WorldFragmentType wft)
Tells the query what kind of world geometry to return from queries; often the full renderable geometr...
virtual uint32 getQueryMask(void) const
Returns the current mask for this query.
Specialises the SceneQuery class for querying within a sphere.
const Sphere & getSphere() const
Gets the sphere which is being used for this query.
SphereSceneQuery(SceneManager *mgr)
void setSphere(const Sphere &sphere)
Sets the sphere which is to be used for this query.
A sphere primitive, mostly used for bounds checking.
Definition OgreSphere.h:52
Standard 3-dimensional vector.
Definition OgreVector3.h:52
vector< PlaneBoundedVolume >::type PlaneBoundedVolumeList
vector< RaySceneQueryResultEntry >::type RaySceneQueryResult
list< SceneQueryMovableObjectWorldFragmentPair >::type SceneQueryMovableWorldFragmentIntersectionList
std::pair< MovableObject *, MovableObject * > SceneQueryMovableObjectPair
list< MovableObject * >::type SceneQueryResultMovableList
list< SceneQuery::WorldFragment * >::type SceneQueryResultWorldFragmentList
list< SceneQueryMovableObjectPair >::type SceneQueryMovableIntersectionList
std::pair< MovableObject *, SceneQuery::WorldFragment * > SceneQueryMovableObjectWorldFragmentPair
float Real
Software floating point type.
unsigned int uint32
unsigned short ushort
Holds the results of an intersection scene query (pair values).
SceneQueryMovableWorldFragmentIntersectionList movables2world
List of movable / world intersections.
SceneQueryMovableIntersectionList movables2movables
List of movable / movable intersections (entities, particle systems etc)
This struct allows a single comparison of result data no matter what the type.
MovableObject * movable
The movable, or NULL if this is not a movable result.
SceneQuery::WorldFragment * worldFragment
The world fragment, or NULL if this is not a fragment result.
Real distance
Distance along the ray.
Holds the results of a scene query.
SceneQueryResultMovableList movables
List of movable objects in the query (entities, particle systems etc)
SceneQueryResultWorldFragmentList worldFragments
List of world fragments.
Represents part of the world geometry that is a result of a SceneQuery.
RenderOperation * renderOp
General render operation structure, fallback if nothing else is available.
WorldFragmentType fragmentType
The type of this world fragment.
list< Plane >::type * planes
Planes bounding a convex region, only applicable for WFT_PLANE_BOUNDED_REGION.
Vector3 singleIntersection
Single intersection point, only applicable for WFT_SINGLE_INTERSECTION.
void * geometry
Custom geometry block, only applicable for WFT_CUSTOM_GEOMETRY.
std::list< T, A > type
std::set< T, P, A > type
std::vector< T, A > type