OgreSceneManager.h

Go to the documentation of this file.

/*-------------------------------------------------------------------------
This source file is a part of OGRE
(Object-oriented Graphics Rendering Engine)

For the latest info, see http://www.ogre3d.org/

Copyright (c) 2000-2006 Torus Knot Software Ltd
Also see acknowledgements in Readme.html

This library is free software; you can redistribute it and/or modify it
under the terms of the GNU Lesser General Public License (LGPL) as 
published by the Free Software Foundation; either version 2.1 of the 
License, or (at your option) any later version.

This library 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 library; 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

You may alternatively use this source under the terms of a specific version of
the OGRE Unrestricted License provided you have obtained such a license from
Torus Knot Software Ltd.
-------------------------------------------------------------------------*/
#ifndef __SceneManager_H__
#define __SceneManager_H__

// Precompiler options
#include "OgrePrerequisites.h"

#include "OgreString.h"
#include "OgreSceneNode.h"
#include "OgrePlane.h"
#include "OgreQuaternion.h"
#include "OgreColourValue.h"
#include "OgreCommon.h"
#include "OgreSceneQuery.h"
#include "OgreAutoParamDataSource.h"
#include "OgreAnimationState.h"
#include "OgreRenderQueue.h"
#include "OgreRenderQueueSortingGrouping.h"
#include "OgreRectangle2D.h"
#include "OgrePixelFormat.h"
#include "OgreResourceGroupManager.h"
#include "OgreTexture.h"
#include "OgreShadowCameraSetup.h"
#include "OgreShadowTextureManager.h"
#include "OgreCamera.h"
#include "OgreInstancedGeometry.h"

namespace Ogre {

    struct ViewPoint
    {
        Vector3 position;
        Quaternion orientation;
    };

    // Forward declarations
    class DefaultIntersectionSceneQuery;
    class DefaultRaySceneQuery;
    class DefaultSphereSceneQuery;
    class DefaultAxisAlignedBoxSceneQuery;

    struct VisibleObjectsBoundsInfo
    {
        AxisAlignedBox aabb;
        AxisAlignedBox receiverAabb;
        Real minDistance;
        Real maxDistance;

        VisibleObjectsBoundsInfo()
        {
            reset();
        }

        void reset()
        {
            aabb.setNull();
            receiverAabb.setNull();
            minDistance = std::numeric_limits<Real>::infinity();
            maxDistance = 0;
        }

        void merge(const AxisAlignedBox& boxBounds, const Sphere& sphereBounds, 
            const Camera* cam, bool receiver=true)
        {
            aabb.merge(boxBounds);
            if (receiver)
                receiverAabb.merge(boxBounds);
            Real camDistToCenter = 
                (cam->getDerivedPosition() - sphereBounds.getCenter()).length();
            minDistance = (std::min)(minDistance, (std::max)((Real)0, camDistToCenter - sphereBounds.getRadius()));
            maxDistance = (std::max)(maxDistance, camDistToCenter + sphereBounds.getRadius());
        }


    };

    class _OgreExport SceneManager : public SceneMgtAlloc
    {
    public:
        static uint32 WORLD_GEOMETRY_TYPE_MASK;
        static uint32 ENTITY_TYPE_MASK;
        static uint32 FX_TYPE_MASK;
        static uint32 STATICGEOMETRY_TYPE_MASK;
        static uint32 LIGHT_TYPE_MASK;
        static uint32 FRUSTUM_TYPE_MASK;
        static uint32 USER_TYPE_MASK_LIMIT;
        struct materialLess
        {
            _OgreExport bool operator()(const Material* x, const Material* y) const;
        };
        struct lightLess
        {
            _OgreExport bool operator()(const Light* a, const Light* b) const;
        };

        enum IlluminationRenderStage
        {
            IRS_NONE,
            IRS_RENDER_TO_TEXTURE,
            IRS_RENDER_RECEIVER_PASS
        };

        enum SpecialCaseRenderQueueMode
        {
            SCRQM_INCLUDE,
            SCRQM_EXCLUDE
        };

        struct SkyDomeGenParameters
        {
            Real skyDomeCurvature;
            Real skyDomeTiling;
            Real skyDomeDistance;
            int skyDomeXSegments; 
            int skyDomeYSegments;
            int skyDomeYSegments_keep;
        };

        struct SkyPlaneGenParameters
        {
            Real skyPlaneScale;
            Real skyPlaneTiling; 
            Real skyPlaneBow; 
            int skyPlaneXSegments; 
            int skyPlaneYSegments; 
        };

        struct SkyBoxGenParameters
        {
            Real skyBoxDistance;
        };

        class Listener
        {
        public:
            Listener() {}
            virtual ~Listener() {}

            virtual void preFindVisibleObjects(SceneManager* source, 
                IlluminationRenderStage irs, Viewport* v) = 0;
            virtual void postFindVisibleObjects(SceneManager* source, 
                IlluminationRenderStage irs, Viewport* v) = 0;

            virtual void shadowTexturesUpdated(size_t numberOfShadowTextures) = 0;

            virtual void shadowTextureCasterPreViewProj(Light* light, 
                Camera* camera, size_t iteration) = 0;
            virtual void shadowTextureReceiverPreViewProj(Light* light, 
                Frustum* frustum) = 0;

            virtual bool sortLightsAffectingFrustum(LightList& lightList) { return false; }



        };

    protected:

        virtual SceneNode* createSceneNodeImpl(void);
        virtual SceneNode* createSceneNodeImpl(const String& name);

        String mName;

        RenderQueue* mRenderQueue;

        ColourValue mAmbientLight;

        RenderSystem *mDestRenderSystem;

        typedef std::map<String, Camera* > CameraList;

        CameraList mCameras;

        typedef std::map<String, StaticGeometry* > StaticGeometryList;
        StaticGeometryList mStaticGeometryList;
        typedef std::map<String, InstancedGeometry* > InstancedGeometryList;
        InstancedGeometryList mInstancedGeometryList;

        typedef std::map<String, SceneNode*> SceneNodeList;

        SceneNodeList mSceneNodes;

        Camera* mCameraInProgress;
        Viewport* mCurrentViewport;

        SceneNode* mSceneRoot;

        typedef std::set<SceneNode*> AutoTrackingSceneNodes;
        AutoTrackingSceneNodes mAutoTrackingSceneNodes;

        // Sky params
        // Sky plane
        Entity* mSkyPlaneEntity;
        Entity* mSkyDomeEntity[5];
        ManualObject* mSkyBoxObj;

        SceneNode* mSkyPlaneNode;
        SceneNode* mSkyDomeNode;
        SceneNode* mSkyBoxNode;

        // Sky plane
        bool mSkyPlaneEnabled;
        uint8 mSkyPlaneRenderQueue;
        Plane mSkyPlane;
        SkyPlaneGenParameters mSkyPlaneGenParameters;
        // Sky box
        bool mSkyBoxEnabled;
        uint8 mSkyBoxRenderQueue;
        Quaternion mSkyBoxOrientation;
        SkyBoxGenParameters mSkyBoxGenParameters;
        // Sky dome
        bool mSkyDomeEnabled;
        uint8 mSkyDomeRenderQueue;
        Quaternion mSkyDomeOrientation;
        SkyDomeGenParameters mSkyDomeGenParameters;

        // Fog
        FogMode mFogMode;
        ColourValue mFogColour;
        Real mFogStart;
        Real mFogEnd;
        Real mFogDensity;

        typedef std::set<uint8> SpecialCaseRenderQueueList;
        SpecialCaseRenderQueueList mSpecialCaseQueueList;
        SpecialCaseRenderQueueMode mSpecialCaseQueueMode;
        uint8 mWorldGeometryRenderQueue;
        
        unsigned long mLastFrameNumber;
        Matrix4 mTempXform[256];
        bool mResetIdentityView;
        bool mResetIdentityProj;

        bool mNormaliseNormalsOnScale;
        bool mFlipCullingOnNegativeScale;
        CullingMode mPassCullingMode;

    protected:

        typedef std::map< const Camera*, VisibleObjectsBoundsInfo> CamVisibleObjectsMap;
        CamVisibleObjectsMap mCamVisibleObjectsMap; 

        typedef std::map< const Camera*, const Light* > ShadowCamLightMapping;
        ShadowCamLightMapping mShadowCamLightMapping;

        size_t mShadowTextureCountPerType[3];

        std::vector<size_t> mShadowTextureIndexLightList;

        struct _OgreExport LightInfo
        {
            Light* light;       // Just a pointer for comparison, the light might destroyed for some reason
            int type;           // Use int instead of Light::LightTypes to avoid header file dependence
            Real range;         // Sets to zero if directional light
            Vector3 position;   // Sets to zero if directional light

            bool operator== (const LightInfo& rhs) const
            {
                return light == rhs.light && type == rhs.type &&
                    range == rhs.range && position == rhs.position;
            }

            bool operator!= (const LightInfo& rhs) const
            {
                return !(*this == rhs);
            }
        };

        typedef std::vector<LightInfo> LightInfoList;

        LightList mLightsAffectingFrustum;
        LightInfoList mCachedLightInfos;
        LightInfoList mTestLightInfos; // potentially new list
        ulong mLightsDirtyCounter;

        typedef std::map<String, MovableObject*> MovableObjectMap;
        struct MovableObjectCollection
        {
            MovableObjectMap map;
            OGRE_MUTEX(mutex)
        };
        typedef std::map<String, MovableObjectCollection*> MovableObjectCollectionMap;
        MovableObjectCollectionMap mMovableObjectCollectionMap;
        MovableObjectCollection* getMovableObjectCollection(const String& typeName);
        const MovableObjectCollection* getMovableObjectCollection(const String& typeName) const;
        OGRE_MUTEX(mMovableObjectCollectionMapMutex)

        
        virtual void initRenderQueue(void);
        Pass* mShadowCasterPlainBlackPass;
        Pass* mShadowReceiverPass;
        virtual const Pass* deriveShadowCasterPass(const Pass* pass);
        virtual const Pass* deriveShadowReceiverPass(const Pass* pass);
    
        virtual bool validatePassForRendering(const Pass* pass);

        virtual bool validateRenderableForRendering(const Pass* pass, const Renderable* rend);

        enum BoxPlane
        {
            BP_FRONT = 0,
            BP_BACK = 1,
            BP_LEFT = 2,
            BP_RIGHT = 3,
            BP_UP = 4,
            BP_DOWN = 5
        };

        /* Internal utility method for creating the planes of a skybox.
        */
        virtual MeshPtr createSkyboxPlane(
            BoxPlane bp,
            Real distance,
            const Quaternion& orientation,
            const String& groupName);

        /* Internal utility method for creating the planes of a skydome.
        */
        virtual MeshPtr createSkydomePlane(
            BoxPlane bp,
            Real curvature, Real tiling, Real distance,
            const Quaternion& orientation,
            int xsegments, int ysegments, int ySegmentsToKeep, 
            const String& groupName);

        // Flag indicating whether SceneNodes will be rendered as a set of 3 axes
        bool mDisplayNodes;

        typedef std::map<String, Animation*> AnimationList;
        AnimationList mAnimationsList;
        OGRE_MUTEX(mAnimationsListMutex)
        AnimationStateSet mAnimationStates;


        virtual void useRenderableViewProjMode(const Renderable* pRend);
        
        virtual void resetViewProjMode(void);

        typedef std::vector<RenderQueueListener*> RenderQueueListenerList;
        RenderQueueListenerList mRenderQueueListeners;

        typedef std::vector<Listener*> ListenerList;
        ListenerList mListeners;
        virtual bool fireRenderQueueStarted(uint8 id, const String& invocation);
        virtual bool fireRenderQueueEnded(uint8 id, const String& invocation);

        virtual void fireShadowTexturesUpdated(size_t numberOfShadowTextures);
        virtual void fireShadowTexturesPreCaster(Light* light, Camera* camera, size_t iteration);
        virtual void fireShadowTexturesPreReceiver(Light* light, Frustum* f);
        virtual void firePreFindVisibleObjects(Viewport* v);
        virtual void firePostFindVisibleObjects(Viewport* v);
        virtual void setViewport(Viewport *vp);

        bool mShowBoundingBoxes;      

        virtual void renderVisibleObjectsDefaultSequence(void);
        virtual void renderVisibleObjectsCustomSequence(RenderQueueInvocationSequence* s);
        virtual void prepareRenderQueue(void);


        virtual void renderSingleObject(Renderable* rend, const Pass* pass, 
            bool lightScissoringClipping, bool doLightIteration, const LightList* manualLightList = 0);

        virtual AutoParamDataSource* createAutoParamDataSource(void) const
        {
            return OGRE_NEW AutoParamDataSource();
        }

        AutoParamDataSource* mAutoParamDataSource;

        ShadowTechnique mShadowTechnique;
        bool mDebugShadows;
        ColourValue mShadowColour;
        Pass* mShadowDebugPass;
        Pass* mShadowStencilPass;
        Pass* mShadowModulativePass;
        bool mShadowMaterialInitDone;
        HardwareIndexBufferSharedPtr mShadowIndexBuffer;
        size_t mShadowIndexBufferSize;
        Rectangle2D* mFullScreenQuad;
        Real mShadowDirLightExtrudeDist;
        IlluminationRenderStage mIlluminationStage;
        ShadowTextureConfigList mShadowTextureConfigList;
        bool mShadowTextureConfigDirty;
        ShadowTextureList mShadowTextures;
        TexturePtr mNullShadowTexture;
        typedef std::vector<Camera*> ShadowTextureCameraList;
        ShadowTextureCameraList mShadowTextureCameras;
        Texture* mCurrentShadowTexture;
        bool mShadowUseInfiniteFarPlane;
        bool mShadowCasterRenderBackFaces;
        bool mShadowAdditiveLightClip;
        struct LightClippingInfo
        {
            RealRect scissorRect;
            PlaneList clipPlanes;
            bool scissorValid;
            unsigned long clipPlanesValid;
            LightClippingInfo() : scissorValid(false), clipPlanesValid(false) {}

        };
        typedef std::map<Light*, LightClippingInfo> LightClippingInfoMap;
        LightClippingInfoMap mLightClippingInfoMap;
        unsigned long mLightClippingInfoMapFrameNumber;

        ShadowCameraSetupPtr mDefaultShadowCameraSetup;

        struct lightsForShadowTextureLess
        {
            _OgreExport bool operator()(const Light* l1, const Light* l2) const;
        };


        virtual void findLightsAffectingFrustum(const Camera* camera);
        virtual void initShadowVolumeMaterials(void);
        virtual void ensureShadowTexturesCreated();
        virtual void destroyShadowTextures(void);
        virtual void prepareShadowTextures(Camera* cam, Viewport* vp);

        virtual void renderShadowVolumesToStencil(const Light* light, const Camera* cam, 
            bool calcScissor);
        virtual void setShadowVolumeStencilState(bool secondpass, bool zfail, bool twosided);
        void renderShadowVolumeObjects(ShadowCaster::ShadowRenderableListIterator iShadowRenderables,
            Pass* pass, const LightList *manualLightList, unsigned long flags,
            bool secondpass, bool zfail, bool twosided);
        typedef std::vector<ShadowCaster*> ShadowCasterList;
        ShadowCasterList mShadowCasterList;
        SphereSceneQuery* mShadowCasterSphereQuery;
        AxisAlignedBoxSceneQuery* mShadowCasterAABBQuery;
        Real mDefaultShadowFarDist;
        Real mDefaultShadowFarDistSquared;
        Real mShadowTextureOffset; // proportion of texture offset in view direction e.g. 0.4
        Real mShadowTextureFadeStart; // as a proportion e.g. 0.6
        Real mShadowTextureFadeEnd; // as a proportion e.g. 0.9
        bool mShadowTextureSelfShadow;
        Pass* mShadowTextureCustomCasterPass;
        Pass* mShadowTextureCustomReceiverPass;
        String mShadowTextureCustomCasterVertexProgram;
        String mShadowTextureCustomReceiverVertexProgram;
        String mShadowTextureCustomReceiverFragmentProgram;
        GpuProgramParametersSharedPtr mShadowTextureCustomCasterVPParams;
        GpuProgramParametersSharedPtr mShadowTextureCustomReceiverVPParams;
        GpuProgramParametersSharedPtr mShadowTextureCustomReceiverFPParams;

        uint32 mVisibilityMask;
        bool mFindVisibleObjects;

        bool mSuppressRenderStateChanges;
        bool mSuppressShadows;


        GpuProgramParametersSharedPtr mInfiniteExtrusionParams;
        GpuProgramParametersSharedPtr mFiniteExtrusionParams;

        class _OgreExport ShadowCasterSceneQueryListener : public SceneQueryListener, public SceneMgtAlloc
        {
        protected:
            SceneManager* mSceneMgr;
            ShadowCasterList* mCasterList;
            bool mIsLightInFrustum;
            const PlaneBoundedVolumeList* mLightClipVolumeList;
            const Camera* mCamera;
            const Light* mLight;
            Real mFarDistSquared;
        public:
            ShadowCasterSceneQueryListener(SceneManager* sm) : mSceneMgr(sm),
                mCasterList(0), mIsLightInFrustum(false), mLightClipVolumeList(0), 
                mCamera(0) {}
            // Prepare the listener for use with a set of parameters  
            void prepare(bool lightInFrustum, 
                const PlaneBoundedVolumeList* lightClipVolumes, 
                const Light* light, const Camera* cam, ShadowCasterList* casterList, 
                Real farDistSquared) 
            {
                mCasterList = casterList;
                mIsLightInFrustum = lightInFrustum;
                mLightClipVolumeList = lightClipVolumes;
                mCamera = cam;
                mLight = light;
                mFarDistSquared = farDistSquared;
            }
            bool queryResult(MovableObject* object);
            bool queryResult(SceneQuery::WorldFragment* fragment);
        };

        ShadowCasterSceneQueryListener* mShadowCasterQueryListener;

        virtual const ShadowCasterList& findShadowCastersForLight(const Light* light, 
            const Camera* camera);
        virtual void renderBasicQueueGroupObjects(RenderQueueGroup* pGroup, 
            QueuedRenderableCollection::OrganisationMode om);
        virtual void renderAdditiveStencilShadowedQueueGroupObjects(RenderQueueGroup* group, 
            QueuedRenderableCollection::OrganisationMode om);
        virtual void renderModulativeStencilShadowedQueueGroupObjects(RenderQueueGroup* group, 
            QueuedRenderableCollection::OrganisationMode om);
        virtual void renderTextureShadowCasterQueueGroupObjects(RenderQueueGroup* group, 
            QueuedRenderableCollection::OrganisationMode om);
        virtual void renderTextureShadowReceiverQueueGroupObjects(RenderQueueGroup* group, 
            QueuedRenderableCollection::OrganisationMode om);
        virtual void renderModulativeTextureShadowedQueueGroupObjects(RenderQueueGroup* group, 
            QueuedRenderableCollection::OrganisationMode om);

        virtual void renderAdditiveTextureShadowedQueueGroupObjects(RenderQueueGroup* group, 
            QueuedRenderableCollection::OrganisationMode om);
        virtual void renderObjects(const QueuedRenderableCollection& objs, 
            QueuedRenderableCollection::OrganisationMode om, bool lightScissoringClipping,
            bool doLightIteration, const LightList* manualLightList = 0);
        virtual void renderTransparentShadowCasterObjects(const QueuedRenderableCollection& objs, 
            QueuedRenderableCollection::OrganisationMode om, bool lightScissoringClipping,
            bool doLightIteration, const LightList* manualLightList = 0);

        virtual void updateRenderQueueSplitOptions(void);
        virtual void updateRenderQueueGroupSplitOptions(RenderQueueGroup* group, 
            bool suppressShadows, bool suppressRenderState);

        virtual ClipResult buildAndSetScissor(const LightList& ll, const Camera* cam);
        virtual void buildScissor(const Light* l, const Camera* cam, RealRect& rect);
        virtual void resetScissor();
        virtual ClipResult buildAndSetLightClip(const LightList& ll);
        virtual void buildLightClip(const Light* l, PlaneList& planes);
        virtual void resetLightClip();
        virtual void checkCachedLightClippingInfo();

        class _OgreExport SceneMgrQueuedRenderableVisitor : public QueuedRenderableVisitor
        {
        protected:
            const Pass* mUsedPass;
        public:
            SceneMgrQueuedRenderableVisitor() 
                :transparentShadowCastersMode(false) {}
            ~SceneMgrQueuedRenderableVisitor() {}
            void visit(Renderable* r);
            bool visit(const Pass* p);
            void visit(RenderablePass* rp);

            SceneManager* targetSceneMgr;
            bool transparentShadowCastersMode;
            bool autoLights;
            const LightList* manualLightList;
            bool scissoring;

        };
        friend class SceneMgrQueuedRenderableVisitor;
        SceneMgrQueuedRenderableVisitor* mActiveQueuedRenderableVisitor;
        SceneMgrQueuedRenderableVisitor mDefaultQueuedRenderableVisitor;

        bool mCameraRelativeRendering;
        Matrix4 mCachedViewMatrix;
        Vector3 mCameraRelativePosition;

    public:
        SceneManager(const String& instanceName);

        virtual ~SceneManager();


        OGRE_MUTEX(sceneGraphMutex)

        
        const String& getName(void) const { return mName; }

        virtual const String& getTypeName(void) const = 0;

        virtual Camera* createCamera(const String& name);

        virtual Camera* getCamera(const String& name) const;

        virtual bool hasCamera(const String& name) const;

        virtual void destroyCamera(Camera *cam);

        virtual void destroyCamera(const String& name);

        virtual void destroyAllCameras(void);

        virtual Light* createLight(const String& name);

        virtual Light* getLight(const String& name) const;

        virtual bool hasLight(const String& name) const;

        virtual const PlaneList& getLightClippingPlanes(Light* l);

        virtual const RealRect& getLightScissorRect(Light* l, const Camera* cam);

        virtual void destroyLight(const String& name);

        virtual void destroyLight(Light* light);
        virtual void destroyAllLights(void);

        virtual void _notifyLightsDirty(void);

        ulong _getLightsDirtyCounter(void) const { return mLightsDirtyCounter; }

        virtual const LightList& _getLightsAffectingFrustum(void) const;

        virtual void _populateLightList(const Vector3& position, Real radius, LightList& destList);


        virtual SceneNode* createSceneNode(void);

        virtual SceneNode* createSceneNode(const String& name);

        virtual void destroySceneNode(const String& name);

        virtual void destroySceneNode(SceneNode* sn);
        virtual SceneNode* getRootSceneNode(void);

        virtual SceneNode* getSceneNode(const String& name) const;

        virtual bool hasSceneNode(const String& name) const;


        virtual Entity* createEntity(const String& entityName, const String& meshName);

        enum PrefabType {
            PT_PLANE,
            PT_CUBE,
            PT_SPHERE
        };

        virtual Entity* createEntity(const String& entityName, PrefabType ptype);
        virtual Entity* getEntity(const String& name) const;
        virtual bool hasEntity(const String& name) const;

        virtual void destroyEntity(Entity* ent);

        virtual void destroyEntity(const String& name);

        virtual void destroyAllEntities(void);

        virtual ManualObject* createManualObject(const String& name);
        virtual ManualObject* getManualObject(const String& name) const;
        virtual bool hasManualObject(const String& name) const;

        virtual void destroyManualObject(ManualObject* obj);
        virtual void destroyManualObject(const String& name);
        virtual void destroyAllManualObjects(void);
        virtual BillboardChain* createBillboardChain(const String& name);
        virtual BillboardChain* getBillboardChain(const String& name) const;
        virtual bool hasBillboardChain(const String& name) const;

        virtual void destroyBillboardChain(BillboardChain* obj);
        virtual void destroyBillboardChain(const String& name);
        virtual void destroyAllBillboardChains(void);       
        virtual RibbonTrail* createRibbonTrail(const String& name);
        virtual RibbonTrail* getRibbonTrail(const String& name) const;
        virtual bool hasRibbonTrail(const String& name) const;

        virtual void destroyRibbonTrail(RibbonTrail* obj);
        virtual void destroyRibbonTrail(const String& name);
        virtual void destroyAllRibbonTrails(void);      

        virtual ParticleSystem* createParticleSystem(const String& name,
            const String& templateName);
        virtual ParticleSystem* createParticleSystem(const String& name,
            size_t quota = 500, 
            const String& resourceGroup = ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
        virtual ParticleSystem* getParticleSystem(const String& name) const;
        virtual bool hasParticleSystem(const String& name) const;

        virtual void destroyParticleSystem(ParticleSystem* obj);
        virtual void destroyParticleSystem(const