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