Main Page Namespace List Class Hierarchy Alphabetical List Compound List File List Namespace Members Compound Members File Members Related Pages

# OgreSceneManager.h

Go to the documentation of this file.

    00001 /*-------------------------------------------------------------------------
    00002 This source file is a part of OGRE
    00003 (Object-oriented Graphics Rendering Engine)
    00004
    00005 For the latest info, see http://www.ogre3d.org/
    00006
    00007 Copyright © 2000-2002 The OGRE Team
    00008 Also see acknowledgements in Readme.html
    00009
    00010 This library is free software; you can redistribute it and/or modify it
    00011 under the terms of the GNU Lesser General Public License (LGPL) as
    00012 published by the Free Software Foundation; either version 2.1 of the
    00013 License, or (at your option) any later version.
    00014
    00015 This library is distributed in the hope that it will be useful, but
    00016 WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
    00017 or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
    00018 License for more details.
    00019
    00020 You should have received a copy of the GNU Lesser General Public License
    00021 along with this library; if not, write to the Free Software Foundation,
    00022 Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA or go to
    00023 http://www.gnu.org/copyleft/lesser.txt
    00024 -------------------------------------------------------------------------*/
    00025 #ifndef __SceneManager_H__
    00026 #define __SceneManager_H__
    00027
    00028 // Precompiler options
    00029 #include "OgrePrerequisites.h"
    00030
    00031 #include "OgreString.h"
    00032 #include "OgreSceneNode.h"
    00033 #include "OgrePlane.h"
    00034 #include "OgreQuaternion.h"
    00035 #include "OgreColourValue.h"
    00036 #include "OgreCommon.h"
    00037 #include "OgreRenderQueue.h"
    00038 #include "OgreDataChunk.h"
    00039 #include "OgreAnimationState.h"
    00040 #include "OgreSceneQuery.h"
    00041 #include "OgreAutoParamDataSource.h"
    00042 #include "OgreAnimationState.h"
    00043 #include "OgreRenderQueue.h"
    00044 #include "OgreRenderQueueSortingGrouping.h"
    00045 #include "OgreRectangle2D.h"
    00046
    00047 namespace Ogre {
    00048
    00050     struct ViewPoint
    00051     {
    00052         Vector3 position;
    00053         Quaternion orientation;
    00054     };
    00055
    00056     // Forward declarations
    00057     class DefaultIntersectionSceneQuery;
    00058     class DefaultRaySceneQuery;
    00059     class DefaultSphereSceneQuery;
    00060     class DefaultAxisAlignedBoxSceneQuery;
    00061
    00077     class _OgreExport SceneManager
    00078     {
    00079         friend class DefaultIntersectionSceneQuery;
    00080         friend class DefaultRaySceneQuery;
    00081         friend class DefaultSphereSceneQuery;
    00082         friend class DefaultAxisAlignedBoxSceneQuery;
    00083         friend class DefaultPlaneBoundedVolumeListSceneQuery;
    00084     public:
    00087         struct materialLess
    00088         {
    00089             _OgreExport bool operator()(const Material* x, const Material* y) const;
    00090         };
    00092         struct lightLess
    00093         {
    00094             _OgreExport bool operator()(const Light* a, const Light* b) const;
    00095         };
    00096
    00098         enum IlluminationRenderStage
    00099         {
    00101             IRS_NONE,
    00103             IRS_AMBIENT,
    00105             IRS_PER_LIGHT,
    00107             IRS_DECAL,
    00109             IRS_RENDER_TO_TEXTURE,
    00111             IRS_RENDER_MODULATIVE_PASS
    00112         };
    00113
    00114     protected:
    00115
    00117         RenderQueue* mRenderQueue;
    00118
    00120         ColourValue mAmbientLight;
    00121
    00123         RenderSystem *mDestRenderSystem;
    00124
    00125         typedef std::map<std::string, Camera*, std::less<std::string> > CameraList;
    00126
    00129         CameraList mCameras;
    00130
    00131         typedef std::map<std::string, Light*, std::less<std::string> > SceneLightList;
    00132
    00135         SceneLightList mLights;
    00136
    00137
    00138         typedef std::map<std::string, Entity*, std::less<std::string> > EntityList;
    00139
    00142         EntityList mEntities;
    00143
    00144         typedef std::map<std::string, BillboardSet*, std::less<std::string> > BillboardSetList;
    00145
    00148         BillboardSetList mBillboardSets;
    00149
    00150         typedef std::map<String, SceneNode*> SceneNodeList;
    00151
    00158         SceneNodeList mSceneNodes;
    00159
    00161         Camera* mCameraInProgress;
    00163         Viewport* mCurrentViewport;
    00164
    00166         SceneNode* mSceneRoot;
    00167
    00169         typedef std::set<SceneNode*> AutoTrackingSceneNodes;
    00170         AutoTrackingSceneNodes mAutoTrackingSceneNodes;
    00171
    00172         // Sky params
    00173         // Sky plane
    00174         Entity* mSkyPlaneEntity;
    00175         Entity* mSkyDomeEntity[5];
    00176         Entity* mSkyBoxEntity[6];
    00177
    00178         SceneNode* mSkyPlaneNode;
    00179         SceneNode* mSkyDomeNode;
    00180         SceneNode* mSkyBoxNode;
    00181
    00182         bool mSkyPlaneEnabled;
    00183         bool mSkyPlaneDrawFirst;
    00184         Plane mSkyPlane;
    00185         // Sky box
    00186         bool mSkyBoxEnabled;
    00187         bool mSkyBoxDrawFirst;
    00188         Quaternion mSkyBoxOrientation;
    00189         // Sky dome
    00190         bool mSkyDomeEnabled;
    00191         bool mSkyDomeDrawFirst;
    00192         Quaternion mSkyDomeOrientation;
    00193         // Fog
    00194         FogMode mFogMode;
    00195         ColourValue mFogColour;
    00196         Real mFogStart;
    00197         Real mFogEnd;
    00198         Real mFogDensity;
    00199
    00204         virtual void initRenderQueue(void);
    00206         virtual RenderQueue* getRenderQueue(void);
    00214         virtual Pass* setPass(Pass* pass);
    00216         Pass* mShadowCasterPlainBlackPass;
    00218         Pass* mShadowReceiverPass;
    00228         Pass* deriveShadowCasterPass(Pass* pass);
    00237         Pass* deriveShadowReceiverPass(Pass* pass);
    00238
    00245         bool validatePassForRendering(Pass* pass);
    00246
    00253         bool validateRenderableForRendering(Pass* pass, Renderable* rend);
    00254
    00255         enum BoxPlane
    00256         {
    00257             BP_FRONT = 0,
    00258             BP_BACK = 1,
    00259             BP_LEFT = 2,
    00260             BP_RIGHT = 3,
    00261             BP_UP = 4,
    00262             BP_DOWN = 5
    00263         };
    00264
    00265         /* Internal utility method for creating the planes of a skybox.
    00266         */
    00267         Mesh* createSkyboxPlane(
    00268             BoxPlane bp,
    00269             Real distance,
    00270             const Quaternion& orientation);
    00271
    00272         /* Internal utility method for creating the planes of a skydome.
    00273         */
    00274         Mesh* createSkydomePlane(
    00275             BoxPlane bp,
    00276             Real curvature, Real tiling, Real distance,
    00277             const Quaternion& orientation,
    00278             int xsegments = 16, int ysegments = 16, int ySegmentsToKeep = -1);
    00279
    00280         // Flag indicating whether SceneNodes will be rendered as a set of 3 axes
    00281         bool mDisplayNodes;
    00282
    00284         typedef std::map<String, Animation*> AnimationList;
    00285         AnimationList mAnimationsList;
    00286         AnimationStateSet mAnimationStates;
    00287
    00290         void useRenderableViewProjMode(Renderable* pRend);
    00291
    00293         bool mCamChanged;
    00294
    00295         typedef std::vector<RenderQueueListener*> RenderQueueListenerList;
    00296         RenderQueueListenerList mRenderQueueListeners;
    00297
    00299         bool fireRenderQueueStarted(RenderQueueGroupID id);
    00301         bool fireRenderQueueEnded(RenderQueueGroupID id);
    00302
    00304         virtual void setViewport(Viewport *vp);
    00305
    00307         bool mShowBoundingBoxes;
    00308
    00321         virtual void renderSingleObject(Renderable* rend, Pass* pass, bool doLightIteration,
    00322             const LightList* manualLightList = 0);
    00323
    00325         AutoParamDataSource mAutoParamDataSource;
    00326
    00327         ShadowTechnique mShadowTechnique;
    00328         bool mDebugShadows;
    00329         ColourValue mShadowColour;
    00330         Pass* mShadowDebugPass;
    00331         Pass* mShadowStencilPass;
    00332         Pass* mShadowModulativePass;
    00333         bool mShadowMaterialInitDone;
    00334         LightList mLightsAffectingFrustum;
    00335         HardwareIndexBufferSharedPtr mShadowIndexBuffer;
    00336         size_t mShadowIndexBufferSize;
    00337         Rectangle2D* mFullScreenQuad;
    00338         Real mShadowDirLightExtrudeDist;
    00339         IlluminationRenderStage mIlluminationStage;
    00340         unsigned short mShadowTextureSize;
    00341         unsigned short mShadowTextureCount;
    00342         typedef std::vector<RenderTexture*> ShadowTextureList;
    00343         ShadowTextureList mShadowTextures;
    00344         RenderTexture* mCurrentShadowTexture;
    00345         bool mShadowUseInfiniteFarPlane;
    00352         virtual void findLightsAffectingFrustum(const Camera* camera);
    00354         virtual void initShadowVolumeMaterials(void);
    00356         virtual void createShadowTextures(unsigned short size, unsigned short count);
    00358         virtual void prepareShadowTextures(Camera* cam, Viewport* vp);
    00359
    00365         virtual void renderShadowVolumesToStencil(const Light* light, const Camera* cam);
    00371         virtual void setShadowVolumeStencilState(bool secondpass, bool zfail, bool twosided);
    00373         void renderSingleShadowVolumeToStencil(ShadowRenderable* sr, bool zfail, bool stencil2sided, const LightList* manualLightList, bool bSecondPass);
    00374         typedef std::vector<ShadowCaster*> ShadowCasterList;
    00375         ShadowCasterList mShadowCasterList;
    00376         SphereSceneQuery* mShadowCasterSphereQuery;
    00377         AxisAlignedBoxSceneQuery* mShadowCasterAABBQuery;
    00378         Real mShadowFarDist;
    00379         Real mShadowFarDistSquared;
    00380         Real mShadowTextureOffset; // proportion of texture offset in view direction e.g. 0.4
    00381         Real mShadowTextureFadeStart; // as a proportion e.g. 0.6
    00382         Real mShadowTextureFadeEnd; // as a proportion e.g. 0.9
    00383         GpuProgramParametersSharedPtr mInfiniteExtrusionParams;
    00384         GpuProgramParametersSharedPtr mFiniteExtrusionParams;
    00385
    00387         class _OgreExport ShadowCasterSceneQueryListener : public SceneQueryListener
    00388         {
    00389         protected:
    00390             ShadowCasterList* mCasterList;
    00391             bool mIsLightInFrustum;
    00392             const PlaneBoundedVolumeList* mLightClipVolumeList;
    00393             const Camera* mCamera;
    00394             const Light* mLight;
    00395             Real mFarDistSquared;
    00396         public:
    00397             ShadowCasterSceneQueryListener() : mCasterList(0),
    00398                 mIsLightInFrustum(false), mLightClipVolumeList(0),
    00399                 mCamera(0) {}
    00400             // Prepare the listener for use with a set of parameters
    00401             void prepare(bool lightInFrustum,
    00402                 const PlaneBoundedVolumeList* lightClipVolumes,
    00403                 const Light* light, const Camera* cam, ShadowCasterList* casterList,
    00404                 Real farDistSquared)
    00405             {
    00406                 mCasterList = casterList;
    00407                 mIsLightInFrustum = lightInFrustum;
    00408                 mLightClipVolumeList = lightClipVolumes;
    00409                 mCamera = cam;
    00410                 mLight = light;
    00411                 mFarDistSquared = farDistSquared;
    00412             }
    00413             bool queryResult(MovableObject* object);
    00414             bool queryResult(SceneQuery::WorldFragment* fragment);
    00415         };
    00416
    00417         ShadowCasterSceneQueryListener mShadowCasterQueryListener;
    00418
    00425         virtual const ShadowCasterList& findShadowCastersForLight(const Light* light,
    00426             const Camera* camera);
    00429         virtual void renderQueueGroupObjects(RenderQueueGroup* group);
    00431         virtual void renderBasicQueueGroupObjects(RenderQueueGroup* pGroup);
    00433         virtual void renderAdditiveStencilShadowedQueueGroupObjects(RenderQueueGroup* group);
    00435         virtual void renderModulativeStencilShadowedQueueGroupObjects(RenderQueueGroup* group);
    00437         virtual void renderTextureShadowCasterQueueGroupObjects(RenderQueueGroup* group);
    00439         virtual void renderTextureShadowReceiverQueueGroupObjects(RenderQueueGroup* group);
    00441         virtual void renderModulativeTextureShadowedQueueGroupObjects(RenderQueueGroup* group);
    00443         virtual void renderObjects(const RenderPriorityGroup::SolidRenderablePassMap& objs,
    00444             bool doLightIteration, const LightList* manualLightList = 0);
    00446         virtual void renderObjects(const RenderPriorityGroup::TransparentRenderablePassList& objs,
    00447             bool doLightIteration, const LightList* manualLightList = 0);
    00453         virtual void renderTransparentShadowCasterObjects(const RenderPriorityGroup::TransparentRenderablePassList& objs,
    00454             bool doLightIteration, const LightList* manualLightList = 0);
    00455
    00456     public:
    00459         SceneManager();
    00460
    00463         virtual ~SceneManager();
    00464
    00472         virtual Camera* createCamera(const String& name);
    00473
    00476         virtual Camera* getCamera(const String& name);
    00477
    00486         virtual void removeCamera(Camera *cam);
    00487
    00493         virtual void removeCamera(const String& name);
    00494
    00497         virtual void removeAllCameras(void);
    00498
    00509         virtual Light* createLight(const String& name);
    00510
    00513         virtual Light* getLight(const String& name);
    00514
    00519         virtual void removeLight(const String& name);
    00520
    00525         virtual void removeLight(Light* light);
    00528         virtual void removeAllLights(void);
    00529
    00549         virtual void _populateLightList(const Vector3& position, Real radius, LightList& destList);
    00550
    00554         virtual Material* createMaterial(const String& name);
    00555
    00586         virtual Material* getDefaultMaterialSettings(void);
    00587
    00590         virtual Material* getMaterial(const String& name);
    00591
    00598         virtual Material* getMaterial(int handle);
    00599
    00616         virtual SceneNode* createSceneNode(void);
    00617
    00632         virtual SceneNode* createSceneNode(const String& name);
    00633
    00640         virtual void destroySceneNode(const String& name);
    00641
    00657         virtual SceneNode* getRootSceneNode(void) const;
    00658
    00665         virtual SceneNode* getSceneNode(const String& name) const;
    00666
    00674         virtual Entity* createEntity(const String& entityName, const String& meshName);
    00675
    00682         enum PrefabType {
    00683             PT_PLANE
    00684         };
    00685
    00692         virtual Entity* createEntity(const String& entityName, PrefabType ptype);
    00694         virtual Entity* getEntity(const String& name);
    00695
    00704         virtual void removeEntity(Entity* ent);
    00705
    00714         virtual void removeEntity(const String& name);
    00715
    00725         virtual void removeAllEntities(void);
    00726
    00732         virtual void clearScene(void);
    00733
    00746         void setAmbientLight(const ColourValue& colour);
    00747
    00750         const ColourValue& getAmbientLight(void) const;
    00751
    00767         virtual void setWorldGeometry(const String& filename);
    00768
    00783         virtual ViewPoint getSuggestedViewpoint(bool random = false);
    00784
    00798         virtual bool setOption( const String& strKey, const void* pValue ) { return false; }
    00799
    00813         virtual bool getOption( const String& strKey, void* pDestValue ) { return false; }
    00814
    00824         virtual bool hasOption( const String& strKey ) const { return false; }
    00839         virtual bool getOptionValues( const String& strKey, std::list<SDDataChunk>& refValueList ) { return false; }
    00840
    00847         virtual bool getOptionKeys( std::list<String>& refKeys ) { return false; }
    00848
    00857         virtual void _updateSceneGraph(Camera* cam);
    00858
    00870         virtual void _findVisibleObjects(Camera* cam, bool onlyShadowCasters);
    00871
    00876         virtual void _applySceneAnimations(void);
    00877
    00880         virtual void _renderVisibleObjects(void);
    00881
    00895         virtual void _renderScene(Camera* camera, Viewport* vp, bool includeOverlays);
    00896
    00900         virtual void _queueSkiesForRendering(Camera* cam);
    00901
    00902
    00903
    00912         virtual void _setDestinationRenderSystem(RenderSystem* sys);
    00913
    00964         virtual void setSkyPlane(
    00965             bool enable,
    00966             const Plane& plane, const String& materialName, Real scale = 1000,
    00967             Real tiling = 10, bool drawFirst = true, Real bow = 0,
    00968             int xsegments = 1, int ysegments = 1);
    00969
    01009         virtual void setSkyBox(
    01010             bool enable, const String& materialName, Real distance = 5000,
    01011             bool drawFirst = true, const Quaternion& orientation = Quaternion::IDENTITY );
    01012
    01066         virtual void setSkyDome(
    01067             bool enable, const String& materialName, Real curvature = 10,
    01068             Real tiling = 8, Real distance = 4000, bool drawFirst = true,
    01069             const Quaternion& orientation = Quaternion::IDENTITY,
    01070             int xsegments = 16, int ysegments = 16, int ysegments_keep = -1);
    01071
    01096         void setFog(
    01097             FogMode mode = FOG_NONE, const ColourValue& colour = ColourValue::White,
    01098             Real expDensity = 0.001, Real linearStart = 0.0, Real linearEnd = 1.0);
    01099
    01102         virtual FogMode getFogMode(void) const;
    01103
    01106         virtual const ColourValue& getFogColour(void) const;
    01107
    01110         virtual Real getFogStart(void) const;
    01111
    01114         virtual Real getFogEnd(void) const;
    01115
    01118         virtual Real getFogDensity(void) const;
    01119
    01120
    01138         virtual BillboardSet* createBillboardSet(const String& name, unsigned int poolSize = 20);
    01139
    01142         virtual BillboardSet* getBillboardSet(const String& name);
    01143
    01150         virtual void removeBillboardSet(BillboardSet* set);
    01151
    01158         virtual void removeBillboardSet(const String& name);
    01159
    01169         virtual void removeAllBillboardSets(void);
    01170
    01178         virtual void setDisplaySceneNodes(bool display);
    01179
    01200         virtual Animation* createAnimation(const String& name, Real length);
    01201
    01203         virtual Animation* getAnimation(const String& name) const;
    01204
    01210         virtual void destroyAnimation(const String& name);
    01211
    01213         virtual void destroyAllAnimations(void);
    01214
    01238         virtual AnimationState* createAnimationState(const String& animName);
    01239
    01241         virtual AnimationState* getAnimationState(const String& animName);
    01242
    01248         virtual void destroyAnimationState(const String& name);
    01249
    01251         virtual void destroyAllAnimationStates(void);
    01252
    01276         virtual void manualRender(RenderOperation* rend, Pass* pass, Viewport* vp,
    01277             const Matrix4& worldMatrix, const Matrix4& viewMatrix, const Matrix4& projMatrix,
    01278             bool doBeginEndFrame = false) ;
    01279
    01293         virtual Overlay* createOverlay(const String& name, ushort zorder = 100);
    01294
    01296         virtual Overlay* getOverlay(const String& name);
    01297
    01299         virtual void destroyOverlay(const String& name);
    01300
    01302         virtual void destroyAllOverlays(void);
    01303
    01307         virtual void addRenderQueueListener(RenderQueueListener* newListener);
    01308
    01310         virtual void removeRenderQueueListener(RenderQueueListener* delListener);
    01311
    01313         void showBoundingBoxes(bool bShow);
    01314
    01316         bool getShowBoundingBoxes() const;
    01317
    01319         void _notifyAutotrackingSceneNode(SceneNode* node, bool autoTrack);
    01320
    01321
    01334         virtual AxisAlignedBoxSceneQuery*
    01335             createAABBQuery(const AxisAlignedBox& box, unsigned long mask = 0xFFFFFFFF);
    01348         virtual SphereSceneQuery*
    01349             createSphereQuery(const Sphere& sphere, unsigned long mask = 0xFFFFFFFF);
    01362         virtual PlaneBoundedVolumeListSceneQuery*
    01363             createPlaneBoundedVolumeQuery(const PlaneBoundedVolumeList& volumes, unsigned long mask = 0xFFFFFFFF);
    01364
    01365
    01378         virtual RaySceneQuery*
    01379             createRayQuery(const Ray& ray, unsigned long mask = 0xFFFFFFFF);
    01380         //PyramidSceneQuery* createPyramidQuery(const Pyramid& p, unsigned long mask = 0xFFFFFFFF);
    01392         virtual IntersectionSceneQuery*
    01393             createIntersectionQuery(unsigned long mask = 0xFFFFFFFF);
    01394
    01396         virtual void destroyQuery(SceneQuery* query);
    01397
    01398         typedef MapIterator<SceneLightList> LightIterator;
    01399         typedef MapIterator<EntityList> EntityIterator;
    01400         typedef MapIterator<CameraList> CameraIterator;
    01401         typedef MapIterator<BillboardSetList> BillboardSetIterator;
    01402         typedef MapIterator<AnimationList> AnimationIterator;
    01403
    01405         LightIterator getLightIterator(void) {
    01406             return LightIterator(mLights.begin(), mLights.end());
    01407         }
    01409         EntityIterator getEntityIterator(void) {
    01410             return EntityIterator(mEntities.begin(), mEntities.end());
    01411         }
    01413         CameraIterator getCameraIterator(void) {
    01414             return CameraIterator(mCameras.begin(), mCameras.end());
    01415         }
    01417         BillboardSetIterator getBillboardSetIterator(void) {
    01418             return BillboardSetIterator(mBillboardSets.begin(), mBillboardSets.end());
    01419         }
    01421         AnimationIterator getAnimationIterator(void) {
    01422             return AnimationIterator(mAnimationsList.begin(), mAnimationsList.end());
    01423         }
    01425         AnimationStateIterator getAnimationStateIterator(void) {
    01426             return AnimationStateIterator(mAnimationStates.begin(), mAnimationStates.end());
    01427         }
    01428
    01461         virtual void setShadowTechnique(ShadowTechnique technique);
    01462
    01464         virtual ShadowTechnique getShadowTechnique(void) const { return mShadowTechnique; }
    01465
    01467         virtual void setShowDebugShadows(bool debug) { mDebugShadows = debug; }
    01469         virtual bool getShowDebugShadows(void ) const { return mDebugShadows; }
    01470
    01477         virtual void setShadowColour(const ColourValue& colour);
    01484         virtual const ColourValue& getShadowColour(void) const;
    01496         virtual void setShadowDirectionalLightExtrusionDistance(Real dist);
    01499         virtual Real getShadowDirectionalLightExtrusionDistance(void) const;
    01515         virtual void setShadowFarDistance(Real distance);
    01519         virtual Real getShadowFarDistance(void) const
    01520         { return mShadowFarDist; }
    01521
    01547         virtual void setShadowIndexBufferSize(size_t size);
    01549         virtual size_t getShadowIndexBufferSize(void) const
    01550         { return mShadowIndexBufferSize; }
    01557         virtual void setShadowTextureSize(unsigned short size);
    01559         unsigned short getShadowTextureSize(void) const {return mShadowTextureSize; }
    01567         virtual void setShadowTextureCount(unsigned short count);
    01569         unsigned short getShadowTextureCount(void) const {return mShadowTextureCount; }
    01576         virtual void setShadowTextureSettings(unsigned short size, unsigned short count);
    01591         virtual void setShadowDirLightTextureOffset(Real offset) { mShadowTextureOffset = offset;}
    01599         virtual void setShadowTextureFadeStart(Real fadeStart)
    01600         { mShadowTextureFadeStart = fadeStart; }
    01608         virtual void setShadowTextureFadeEnd(Real fadeEnd)
    01609         { mShadowTextureFadeEnd = fadeEnd; }
    01610
    01647         virtual void setShadowUseInfiniteFarPlane(bool enable) {
    01648             mShadowUseInfiniteFarPlane = enable; }
    01649
    01650     };
    01651
    01653     class _OgreExport DefaultIntersectionSceneQuery :
    01654         public IntersectionSceneQuery
    01655     {
    01656     public:
    01657         DefaultIntersectionSceneQuery(SceneManager* creator);
    01658         ~DefaultIntersectionSceneQuery();
    01659
    01661         void execute(IntersectionSceneQueryListener* listener);
    01662     };
    01663
    01665     class _OgreExport DefaultRaySceneQuery : public RaySceneQuery
    01666     {
    01667     public:
    01668         DefaultRaySceneQuery(SceneManager* creator);
    01669         ~DefaultRaySceneQuery();
    01670
    01672         void execute(RaySceneQueryListener* listener);
    01673     };
    01675     class _OgreExport DefaultSphereSceneQuery : public SphereSceneQuery
    01676     {
    01677     public:
    01678         DefaultSphereSceneQuery(SceneManager* creator);
    01679         ~DefaultSphereSceneQuery();
    01680
    01682         void execute(SceneQueryListener* listener);
    01683     };
    01685     class _OgreExport DefaultPlaneBoundedVolumeListSceneQuery : public PlaneBoundedVolumeListSceneQuery
    01686     {
    01687     public:
    01688         DefaultPlaneBoundedVolumeListSceneQuery(SceneManager* creator);
    01689         ~DefaultPlaneBoundedVolumeListSceneQuery();
    01690
    01692         void execute(SceneQueryListener* listener);
    01693     };
    01695     class _OgreExport DefaultAxisAlignedBoxSceneQuery : public AxisAlignedBoxSceneQuery
    01696     {
    01697     public:
    01698         DefaultAxisAlignedBoxSceneQuery(SceneManager* creator);
    01699         ~DefaultAxisAlignedBoxSceneQuery();
    01700
    01702         void execute(SceneQueryListener* listener);
    01703     };
    01704
    01705
    01706
    01707 } // Namespace
    01708
    01709
    01710
    01711 #endif

Copyright © 2002-2003 by The OGRE Team
Last modified Sun Nov 28 19:48:44 2004