Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: downloads/OgreMain/include/OgreMovableObject.h @ 5

Last change on this file since 5 was 5, checked in by anonymous, 17 years ago

=hoffentlich gehts jetzt

File size: 23.6 KB
Line 
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-2006 Torus Knot Software Ltd
8Also see acknowledgements in Readme.html
9
10This program is free software; you can redistribute it and/or modify it under
11the terms of the GNU Lesser General Public License as published by the Free Software
12Foundation; either version 2 of the License, or (at your option) any later
13version.
14
15This program is distributed in the hope that it will be useful, but WITHOUT
16ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
17FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
18
19You should have received a copy of the GNU Lesser General Public License along with
20this program; if not, write to the Free Software Foundation, Inc., 59 Temple
21Place - Suite 330, Boston, MA 02111-1307, USA, or go to
22http://www.gnu.org/copyleft/lesser.txt.
23
24You may alternatively use this source under the terms of a specific version of
25the OGRE Unrestricted License provided you have obtained such a license from
26Torus Knot Software Ltd.
27-----------------------------------------------------------------------------
28*/
29
30#ifndef __MovableObject_H__
31#define __MovableObject_H__
32
33// Precompiler options
34#include "OgrePrerequisites.h"
35#include "OgreRenderQueue.h"
36#include "OgreAxisAlignedBox.h"
37#include "OgreSphere.h"
38#include "OgreShadowCaster.h"
39#include "OgreFactoryObj.h"
40#include "OgreAnimable.h"
41#include "OgreAny.h"
42#include "OgreUserDefinedObject.h"
43
44namespace Ogre {
45
46        // Forward declaration
47        class MovableObjectFactory;
48
49    /** Abstract class definining a movable object in a scene.
50        @remarks
51            Instances of this class are discrete, relatively small, movable objects
52            which are attached to SceneNode objects to define their position.
53    */
54    class _OgreExport MovableObject : public ShadowCaster, public AnimableObject
55    {
56    public:
57        /** Listener which gets called back on MovableObject events.
58        */
59        class _OgreExport Listener
60        {
61        public:
62            Listener(void) {}
63            virtual ~Listener() {}
64            /** MovableObject is being destroyed */
65            virtual void objectDestroyed(MovableObject*) {}
66            /** MovableObject has been attached to a node */
67            virtual void objectAttached(MovableObject*) {}
68            /** MovableObject has been detached from a node */
69            virtual void objectDetached(MovableObject*) {}
70            /** MovableObject has been moved */
71            virtual void objectMoved(MovableObject*) {}
72            /** Called when the movable object of the camera to be used for rendering.
73            @returns
74                true if allows queue for rendering, false otherwise.
75            */
76            virtual bool objectRendering(const MovableObject*, const Camera*) { return true; }
77            /** Called when the movable object needs to query a light list.
78            @remarks
79                If you want to customize light finding for this object, you should override
80                                this method and hook into MovableObject via MovableObject::setListener.
81                                Be aware that the default method caches results within a frame to
82                                prevent unnecessary recalculation, so if you override this you
83                                should provide your own cacheing to maintain performance.
84                        @note
85                                If you use texture shadows, there is an additional restriction -
86                                since the lights which should have shadow textures rendered for
87                                them are determined based on the entire frustum, and not per-object,
88                                it is important that the lights returned at the start of this
89                                list (up to the number of shadow textures available) are the same
90                                lights that were used to generate the shadow textures,
91                                and they are in the same order (particularly for additive effects).
92            @returns
93                A pointer to a light list if you populated the light list yourself, or
94                NULL to fall back on the default finding process.
95            */
96            virtual const LightList* objectQueryLights(const MovableObject*) { return 0; }
97        };
98
99    protected:
100                /// Name of this object
101                String mName;
102                /// Creator of this object (if created by a factory)
103                MovableObjectFactory* mCreator;
104                /// SceneManager holding this object (if applicable)
105                SceneManager* mManager;
106        /// node to which this object is attached
107        Node* mParentNode;
108        bool mParentIsTagPoint;
109        /// Is this object visible?
110        bool mVisible;
111                /// Upper distance to still render
112                Real mUpperDistance;
113                Real mSquaredUpperDistance;
114                /// Hidden because of distance?
115                bool mBeyondFarDistance;
116                /// User defined link to another object / value / whatever
117                Any mUserAny;
118        /// The render queue to use when rendering this object
119        uint8 mRenderQueueID;
120                /// Flags whether the RenderQueue's default should be used.
121                bool mRenderQueueIDSet;
122        /// Flags determining whether this object is included / excluded from scene queries
123        uint32 mQueryFlags;
124        /// Flags determining whether this object is visible (compared to SceneManager mask)
125        uint32 mVisibilityFlags;
126        /// Cached world AABB of this object
127        mutable AxisAlignedBox mWorldAABB;
128                // Cached world bounding sphere
129                mutable Sphere mWorldBoundingSphere;
130        /// World space AABB of this object's dark cap
131        mutable AxisAlignedBox mWorldDarkCapBounds;
132        /// Does this object cast shadows?
133        bool mCastShadows;
134
135        /// Does rendering this object disabled by listener?
136        bool mRenderingDisabled;
137        /// MovableObject listener - only one allowed (no list) for size & performance reasons. */
138        Listener* mListener;
139
140        /// List of lights for this object
141        mutable LightList mLightList;
142        /// The last frame that this light list was updated in
143        mutable ulong mLightListUpdated;
144
145                // Static members
146                /// Default query flags
147                static uint32 msDefaultQueryFlags;
148                /// Default visibility flags
149                static uint32 msDefaultVisibilityFlags;
150
151
152
153    public:
154        /// Constructor
155        MovableObject();
156
157                /// Named constructor
158                MovableObject(const String& name);
159        /** Virtual destructor - read Scott Meyers if you don't know why this is needed.
160        */
161        virtual ~MovableObject();
162
163                /** Notify the object of it's creator (internal use only) */
164                virtual void _notifyCreator(MovableObjectFactory* fact) { mCreator = fact; }
165                /** Get the creator of this object, if any (internal use only) */
166                virtual MovableObjectFactory*  _getCreator(void) const { return mCreator; }
167                /** Notify the object of it's manager (internal use only) */
168                virtual void _notifyManager(SceneManager* man) { mManager = man; }
169                /** Get the manager of this object, if any (internal use only) */
170                virtual SceneManager* _getManager(void) const { return mManager; }
171
172        /** Returns the name of this object. */
173                virtual const String& getName(void) const { return mName; }
174
175        /** Returns the type name of this object. */
176        virtual const String& getMovableType(void) const = 0;
177
178        /** Returns the node to which this object is attached.
179        @remarks
180            A MovableObject may be attached to either a SceneNode or to a TagPoint,
181            the latter case if it's attached to a bone on an animated entity.
182            Both are Node subclasses so this method will return either.
183        */
184        virtual Node* getParentNode(void) const;
185
186        /** Returns the scene node to which this object is attached.
187        @remarks
188            A MovableObject may be attached to either a SceneNode or to a TagPoint,
189            the latter case if it's attached to a bone on an animated entity.
190            This method will return the scene node of the parent entity
191            if the latter is true.
192        */
193        virtual SceneNode* getParentSceneNode(void) const;
194
195        /** Internal method called to notify the object that it has been attached to a node.
196        */
197        virtual void _notifyAttached(Node* parent, bool isTagPoint = false);
198
199        /** Returns true if this object is attached to a SceneNode or TagPoint. */
200        virtual bool isAttached(void) const;
201
202        /** Returns true if this object is attached to a SceneNode or TagPoint,
203                        and this SceneNode / TagPoint is currently in an active part of the
204                        scene graph. */
205        virtual bool isInScene(void) const;
206
207        /** Internal method called to notify the object that it has been moved.
208        */
209        virtual void _notifyMoved(void);
210
211                /** Internal method to notify the object of the camera to be used for the next rendering operation.
212            @remarks
213                Certain objects may want to do specific processing based on the camera position. This method notifies
214                them incase they wish to do this.
215        */
216        virtual void _notifyCurrentCamera(Camera* cam);
217
218        /** Retrieves the local axis-aligned bounding box for this object.
219            @remarks
220                This bounding box is in local coordinates.
221        */
222        virtual const AxisAlignedBox& getBoundingBox(void) const = 0;
223
224                /** Retrieves the radius of the origin-centered bounding sphere
225                         for this object.
226                */
227                virtual Real getBoundingRadius(void) const = 0;
228
229        /** Retrieves the axis-aligned bounding box for this object in world coordinates. */
230        virtual const AxisAlignedBox& getWorldBoundingBox(bool derive = false) const;
231                /** Retrieves the worldspace bounding sphere for this object. */
232        virtual const Sphere& getWorldBoundingSphere(bool derive = false) const;
233        /** Internal method by which the movable object must add Renderable subclass instances to the rendering queue.
234            @remarks
235                The engine will call this method when this object is to be rendered. The object must then create one or more
236                Renderable subclass instances which it places on the passed in Queue for rendering.
237        */
238        virtual void _updateRenderQueue(RenderQueue* queue) = 0;
239
240        /** Tells this object whether to be visible or not, if it has a renderable component.
241                @note An alternative approach of making an object invisible is to detach it
242                        from it's SceneNode, or to remove the SceneNode entirely.
243                        Detaching a node means that structurally the scene graph changes.
244                        Once this change has taken place, the objects / nodes that have been
245                        removed have less overhead to the visbility detection pass than simply
246                        making the object invisible, so if you do this and leave the objects
247                        out of the tree for a long time, it's faster. However, the act of
248                        detaching / reattaching nodes is in itself more expensive than
249                        setting an object visibility flag, since in the latter case
250                        structural changes are not made. Therefore, small or frequent visbility
251                        changes are best done using this method; large or more longer term
252                        changes are best done by detaching.
253                */
254        virtual void setVisible(bool visible);
255
256        /** Gets this object whether to be visible or not, if it has a renderable component.
257        @remarks
258            Returns the value set by MovableObject::setVisible only.
259        */
260        virtual bool getVisible(void) const;
261
262        /** Returns whether or not this object is supposed to be visible or not.
263                @remarks
264                        Takes into account both upper rendering distance and visible flag.
265                */
266        virtual bool isVisible(void) const;
267
268                /** Sets the distance at which the object is no longer rendered.
269                @param dist Distance beyond which the object will not be rendered
270                        (the default is 0, which means objects are always rendered).
271                */
272                virtual void setRenderingDistance(Real dist) { 
273                        mUpperDistance = dist; 
274                        mSquaredUpperDistance = mUpperDistance * mUpperDistance;
275                }
276
277                /** Gets the distance at which batches are no longer rendered. */
278                virtual Real getRenderingDistance(void) const { return mUpperDistance; }
279
280        /** Call this to associate your own custom user object instance with this MovableObject.
281        @remarks
282            By simply making your game / application object a subclass of UserDefinedObject, you
283            can establish a link between an OGRE instance of MovableObject and your own application
284            classes. Call this method to establish the link.
285        */
286        virtual void setUserObject(UserDefinedObject* obj) { mUserAny = Any(obj); }
287        /** Retrieves a pointer to a custom application object associated with this movable by an earlier
288            call to setUserObject.
289        */
290        virtual UserDefinedObject* getUserObject(void) 
291                { 
292                        return mUserAny.isEmpty() ? 0 : any_cast<UserDefinedObject*>(mUserAny); 
293                }
294
295                /** Sets any kind of user value on this object.
296                @remarks
297                        This method allows you to associate any user value you like with
298                        this MovableObject. This can be a pointer back to one of your own
299                        classes for instance.
300                @note This value is shared with setUserObject so don't use both!
301                */
302                virtual void setUserAny(const Any& anything) { mUserAny = anything; }
303
304                /** Retrieves the custom user value associated with this object.
305                */
306                virtual const Any& getUserAny(void) const { return mUserAny; }
307
308        /** Sets the render queue group this entity will be rendered through.
309        @remarks
310            Render queues are grouped to allow you to more tightly control the ordering
311            of rendered objects. If you do not call this method, all Entity objects default
312            to the default queue (RenderQueue::getDefaultQueueGroup), which is fine for most objects. You may want to alter this
313            if you want this entity to always appear in front of other objects, e.g. for
314            a 3D menu system or such.
315        @par
316            See RenderQueue for more details.
317        @param queueID Enumerated value of the queue group to use.
318        */
319        virtual void setRenderQueueGroup(uint8 queueID);
320
321        /** Gets the queue group for this entity, see setRenderQueueGroup for full details. */
322        virtual uint8 getRenderQueueGroup(void) const;
323
324                /// return the full transformation of the parent sceneNode or the attachingPoint node
325                virtual const Matrix4& _getParentNodeFullTransform(void) const;
326
327        /** Sets the query flags for this object.
328        @remarks
329            When performing a scene query, this object will be included or excluded according
330            to flags on the object and flags on the query. This is a bitwise value, so only when
331            a bit on these flags is set, will it be included in a query asking for that flag. The
332            meaning of the bits is application-specific.
333        */
334        virtual void setQueryFlags(uint32 flags) { mQueryFlags = flags; }
335
336        /** As setQueryFlags, except the flags passed as parameters are appended to the
337        existing flags on this object. */
338        virtual void addQueryFlags(uint32 flags) { mQueryFlags |= flags; }
339           
340        /** As setQueryFlags, except the flags passed as parameters are removed from the
341        existing flags on this object. */
342        virtual void removeQueryFlags(unsigned long flags) { mQueryFlags &= ~flags; }
343       
344        /// Returns the query flags relevant for this object
345        virtual uint32 getQueryFlags(void) const { return mQueryFlags; }
346
347                /** Set the default query flags for all future MovableObject instances.
348                */
349                static void setDefaultQueryFlags(uint32 flags) { msDefaultQueryFlags = flags; }
350
351                /** Get the default query flags for all future MovableObject instances.
352                */
353                static uint32 getDefaultQueryFlags() { return msDefaultQueryFlags; }
354
355               
356        /** Sets the visiblity flags for this object.
357        @remarks
358                        As well as a simple true/false value for visibility (as seen in setVisible),
359                        you can also set visiblity flags which when 'and'ed with the SceneManager's
360                        visibility mask can also make an object invisible.
361        */
362        virtual void setVisibilityFlags(uint32 flags) { mVisibilityFlags = flags; }
363
364        /** As setVisibilityFlags, except the flags passed as parameters are appended to the
365        existing flags on this object. */
366        virtual void addVisibilityFlags(uint32 flags) { mVisibilityFlags |= flags; }
367           
368        /** As setVisibilityFlags, except the flags passed as parameters are removed from the
369        existing flags on this object. */
370        virtual void removeVisibilityFlags(uint32 flags) { mVisibilityFlags &= ~flags; }
371       
372        /// Returns the visibility flags relevant for this object
373        virtual uint32 getVisibilityFlags(void) const { return mVisibilityFlags; }
374
375                /** Set the default visibility flags for all future MovableObject instances.
376                */
377                static void setDefaultVisibilityFlags(uint32 flags) { msDefaultVisibilityFlags = flags; }
378               
379                /** Get the default visibility flags for all future MovableObject instances.
380                */
381                static uint32 getDefaultVisibilityFlags() { return msDefaultVisibilityFlags; }
382
383        /** Sets a listener for this object.
384        @remarks
385            Note for size and performance reasons only one listener per object
386            is allowed.
387        */
388        virtual void setListener(Listener* listener) { mListener = listener; }
389
390        /** Gets the current listener for this object.
391        */
392        virtual Listener* getListener(void) const { return mListener; }
393
394        /** Gets a list of lights, ordered relative to how close they are to this movable object.
395        @remarks
396            By default, this method gives the listener a chance to populate light list first,
397            if there is no listener or Listener::objectQueryLights returns NULL, it'll
398            query the light list from parent entity if it is present, or returns
399            SceneNode::findLights if it has parent scene node, otherwise it just returns
400            an empty list.
401        @par
402            The object internally caches the light list, so it will recalculate
403                        it only when object is moved, or lights that affect the frustum have
404                        been changed (@see SceneManager::_getLightsDirtyCounter),
405            but if listener exists, it will be called each time, so the listener
406                        should implement their own cache mechanism to optimise performance.
407        @par
408            This method can be useful when implementing Renderable::getLights in case
409            the renderable is a part of the movable.
410        @returns The list of lights use to lighting this object.
411        */
412        virtual const LightList& queryLights(void) const;
413
414                /// Define a default implementation of method from ShadowCaster which implements no shadows
415        EdgeData* getEdgeList(void) { return NULL; }
416                /// Define a default implementation of method from ShadowCaster which implements no shadows
417                bool hasEdgeList(void) { return false; }
418        /// Define a default implementation of method from ShadowCaster which implements no shadows
419        ShadowRenderableListIterator getShadowVolumeRenderableIterator(
420            ShadowTechnique shadowTechnique, const Light* light, 
421            HardwareIndexBufferSharedPtr* indexBuffer, 
422            bool extrudeVertices, Real extrusionDist, unsigned long flags = 0);
423               
424        /** Overridden member from ShadowCaster. */
425        const AxisAlignedBox& getLightCapBounds(void) const;
426        /** Overridden member from ShadowCaster. */
427        const AxisAlignedBox& getDarkCapBounds(const Light& light, Real dirLightExtrusionDist) const;
428        /** Sets whether or not this object will cast shadows.
429        @remarks
430        This setting simply allows you to turn on/off shadows for a given object.
431        An object will not cast shadows unless the scene supports it in any case
432        (see SceneManager::setShadowTechnique), and also the material which is
433        in use must also have shadow casting enabled. By default all entities cast
434        shadows. If, however, for some reason you wish to disable this for a single
435        object then you can do so using this method.
436        @note This method normally refers to objects which block the light, but
437        since Light is also a subclass of MovableObject, in that context it means
438        whether the light causes shadows itself.
439        */
440        void setCastShadows(bool enabled) { mCastShadows = enabled; }
441        /** Returns whether shadow casting is enabled for this object. */
442        bool getCastShadows(void) const { return mCastShadows; }
443        /** Get the distance to extrude for a point/spot light */
444        Real getPointExtrusionDistance(const Light* l) const;
445                /** Get the 'type flags' for this MovableObject.
446                @remarks
447                        A type flag identifies the type of the MovableObject as a bitpattern.
448                        This is used for categorical inclusion / exclusion in SceneQuery
449                        objects. By default, this method returns all ones for objects not
450                        created by a MovableObjectFactory (hence always including them);
451                        otherwise it returns the value assigned to the MovableObjectFactory.
452                        Custom objects which don't use MovableObjectFactory will need to
453                        override this if they want to be included in queries.
454                */
455                virtual uint32 getTypeFlags(void) const;
456
457
458
459
460
461    };
462
463        /** Interface definition for a factory class which produces a certain
464                kind of MovableObject, and can be registered with Root in order
465                to allow all clients to produce new instances of this object, integrated
466                with the standard Ogre processing.
467        */
468        class _OgreExport MovableObjectFactory
469        {
470        protected:
471                /// Type flag, allocated if requested
472                unsigned long mTypeFlag;
473
474                /// Internal implementation of create method - must be overridden
475                virtual MovableObject* createInstanceImpl(
476                        const String& name, const NameValuePairList* params = 0) = 0;
477        public:
478                MovableObjectFactory() : mTypeFlag(0xFFFFFFFF) {}
479                virtual ~MovableObjectFactory() {}
480                /// Get the type of the object to be created
481                virtual const String& getType(void) const = 0;
482
483                /** Create a new instance of the object.
484                @param name The name of the new object
485                @param manager The SceneManager instance that will be holding the
486                        instance once created.
487                @param params Name/value pair list of additional parameters required to
488                        construct the object (defined per subtype). Optional.
489                */
490                virtual MovableObject* createInstance(
491                        const String& name, SceneManager* manager, 
492                        const NameValuePairList* params = 0);
493                /** Destroy an instance of the object */
494                virtual void destroyInstance(MovableObject* obj) = 0;
495
496                /** Does this factory require the allocation of a 'type flag', used to
497                        selectively include / exclude this type from scene queries?
498                @remarks
499                        The default implementation here is to return 'false', ie not to
500                        request a unique type mask from Root. For objects that
501                        never need to be excluded in SceneQuery results, that's fine, since
502                        the default implementation of MovableObject::getTypeFlags is to return
503                        all ones, hence matching any query type mask. However, if you want the
504                        objects created by this factory to be filterable by queries using a
505                        broad type, you have to give them a (preferably unique) type mask -
506                        and given that you don't know what other MovableObject types are
507                        registered, Root will allocate you one.
508                */
509                virtual bool requestTypeFlags(void) const { return false; }
510                /** Notify this factory of the type mask to apply.
511                @remarks
512                        This should normally only be called by Root in response to
513                        a 'true' result from requestTypeMask. However, you can actually use
514                        it yourself if you're careful; for example to assign the same mask
515                        to a number of different types of object, should you always wish them
516                        to be treated the same in queries.
517                */
518                void _notifyTypeFlags(unsigned long flag) { mTypeFlag = flag; }
519
520                /** Gets the type flag for this factory.
521                @remarks
522                        A type flag is like a query flag, except that it applies to all instances
523                        of a certain type of object.
524                */
525                unsigned long getTypeFlags(void) const { return mTypeFlag; }
526
527        };
528
529}
530#endif
Note: See TracBrowser for help on using the repository browser.