ruby-ogre 0.0.1-x86-linux

data/deps/include/OGRE/OgreViewport.h

@@ -0,0 +1,433 @@
+/*
+-----------------------------------------------------------------------------
+This source file is part of OGRE
+    (Object-oriented Graphics Rendering Engine)
+For the latest info, see http://www.ogre3d.org/
+
+Copyright (c) 2000-2012 Torus Knot Software Ltd
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+-----------------------------------------------------------------------------
+*/
+#ifndef __Viewport_H__
+#define __Viewport_H__
+
+#include "OgrePrerequisites.h"
+#include "OgreCommon.h"
+#include "OgreColourValue.h"
+#include "OgreFrustum.h"
+
+namespace Ogre {
+	/** \addtogroup Core
+	*  @{
+	*/
+	/** \addtogroup RenderSystem
+	*  @{
+	*/
+	/** An abstraction of a viewport, i.e. a rendering region on a render
+        target.
+        @remarks
+            A viewport is the meeting of a camera and a rendering surface -
+            the camera renders the scene from a viewpoint, and places its
+            results into some subset of a rendering target, which may be the
+            whole surface or just a part of the surface. Each viewport has a
+            single camera as source and a single target as destination. A
+            camera only has 1 viewport, but a render target may have several.
+            A viewport also has a Z-order, i.e. if there is more than one
+            viewport on a single render target and they overlap, one must
+            obscure the other in some predetermined way.
+    */
+	class _OgreExport Viewport : public ViewportAlloc
+    {
+    public:
+		/** Listener interface so you can be notified of Viewport changes. */
+		class _OgreExport Listener
+		{
+		public:
+			virtual ~Listener() {}
+
+			/** Notification of when a new camera is set to target listening Viewport. */
+			virtual void viewportCameraChanged(Viewport* viewport) {}
+
+			/** Notification of when target listening Viewport's dimensions changed. */
+			virtual void viewportDimensionsChanged(Viewport* viewport) {}
+
+			/** Notification of when target listening Viewport's is destroyed. */
+			virtual void viewportDestroyed(Viewport* viewport) {}
+		};
+
+        /** The usual constructor.
+            @param
+                cam Pointer to a camera to be the source for the image.
+            @param
+                target Pointer to the render target to be the destination
+                for the rendering.
+            @param
+                left
+            @param
+                top
+            @param
+                width
+            @param
+                height
+                Dimensions of the viewport, expressed as a value between
+                0 and 1. This allows the dimensions to apply irrespective of
+                changes in the target's size: e.g. to fill the whole area,
+                values of 0,0,1,1 are appropriate.
+            @param
+                ZOrder Relative Z-order on the target. Lower = further to
+                the front.
+        */
+        Viewport(
+            Camera* camera,
+            RenderTarget* target,
+            Real left, Real top,
+            Real width, Real height,
+            int ZOrder);
+
+        /** Default destructor.
+        */
+        virtual ~Viewport();
+
+        /** Notifies the viewport of a possible change in dimensions.
+            @remarks
+                Used by the target to update the viewport's dimensions
+                (usually the result of a change in target size).
+            @note
+                Internal use by Ogre only.
+        */
+        void _updateDimensions(void);
+
+        /** Instructs the viewport to updates its contents.
+        */
+        void update(void);
+		
+		/** Instructs the viewport to clear itself, without performing an update.
+		 @remarks
+			You would not normally call this method when updating the viewport, 
+			since the viewport usually clears itself when updating anyway (@see 
+		    Viewport::setClearEveryFrame). However, if you wish you have the
+			option of manually clearing the frame buffer (or elements of it)
+		    using this method.
+		 @param buffers Bitmask identifying which buffer elements to clear
+		 @param colour The colour value to clear to, if FBT_COLOUR is included
+		 @param depth The depth value to clear to, if FBT_DEPTH is included
+		 @param stencil The stencil value to clear to, if FBT_STENCIL is included
+		*/
+		void clear(unsigned int buffers = FBT_COLOUR | FBT_DEPTH,
+				   const ColourValue& colour = ColourValue::Black, 
+				   Real depth = 1.0f, unsigned short stencil = 0);
+
+        /** Retrieves a pointer to the render target for this viewport.
+        */
+        RenderTarget* getTarget(void) const;
+
+        /** Retrieves a pointer to the camera for this viewport.
+        */
+        Camera* getCamera(void) const;
+
+        /** Sets the camera to use for rendering to this viewport. */
+        void setCamera(Camera* cam);
+
+        /** Gets the Z-Order of this viewport. */
+		int getZOrder(void) const;
+		/** Gets one of the relative dimensions of the viewport,
+            a value between 0.0 and 1.0.
+        */
+        Real getLeft(void) const;
+
+        /** Gets one of the relative dimensions of the viewport, a value
+            between 0.0 and 1.0.
+        */
+        Real getTop(void) const;
+
+        /** Gets one of the relative dimensions of the viewport, a value
+            between 0.0 and 1.0.
+        */
+
+        Real getWidth(void) const;
+        /** Gets one of the relative dimensions of the viewport, a value
+            between 0.0 and 1.0.
+        */
+
+        Real getHeight(void) const;
+        /** Gets one of the actual dimensions of the viewport, a value in
+            pixels.
+        */
+
+        int getActualLeft(void) const;
+        /** Gets one of the actual dimensions of the viewport, a value in
+            pixels.
+        */
+
+        int getActualTop(void) const;
+        /** Gets one of the actual dimensions of the viewport, a value in
+            pixels.
+        */
+        int getActualWidth(void) const;
+        /** Gets one of the actual dimensions of the viewport, a value in
+            pixels.
+        */
+
+        int getActualHeight(void) const;
+
+        /** Sets the dimensions (after creation).
+            @param
+                left
+            @param
+                top
+            @param
+                width
+            @param
+                height Dimensions relative to the size of the target,
+                represented as real values between 0 and 1. i.e. the full
+                target area is 0, 0, 1, 1.
+        */
+        void setDimensions(Real left, Real top, Real width, Real height);
+
+        /** Set the orientation mode of the viewport.
+        */
+        void setOrientationMode(OrientationMode orientationMode, bool setDefault = true);
+
+        /** Get the orientation mode of the viewport.
+        */
+        OrientationMode getOrientationMode() const;
+
+        /** Set the initial orientation mode of viewports.
+        */
+        static void setDefaultOrientationMode(OrientationMode orientationMode);
+
+        /** Get the initial orientation mode of viewports.
+        */
+        static OrientationMode getDefaultOrientationMode();
+
+        /** Sets the initial background colour of the viewport (before
+            rendering).
+        */
+        void setBackgroundColour(const ColourValue& colour);
+
+        /** Gets the background colour.
+        */
+        const ColourValue& getBackgroundColour(void) const;
+
+		/** Sets the initial depth buffer value of the viewport (before
+            rendering). Default is 1
+        */
+        void setDepthClear( Real depth );
+
+        /** Gets the default depth buffer value to which the viewport is cleared.
+        */
+        Real getDepthClear(void) const;
+
+        /** Determines whether to clear the viewport before rendering.
+		@remarks
+			You can use this method to set which buffers are cleared
+			(if any) before rendering every frame.
+        @param clear Whether or not to clear any buffers
+		@param buffers One or more values from FrameBufferType denoting
+			which buffers to clear, if clear is set to true. Note you should
+			not clear the stencil buffer here unless you know what you're doing.
+         */
+        void setClearEveryFrame(bool clear, unsigned int buffers = FBT_COLOUR | FBT_DEPTH);
+
+        /** Determines if the viewport is cleared before every frame.
+        */
+        bool getClearEveryFrame(void) const;
+
+		/** Gets which buffers are to be cleared each frame. */
+        unsigned int getClearBuffers(void) const;
+
+		/** Sets whether this viewport should be automatically updated 
+			if Ogre's rendering loop or RenderTarget::update is being used.
+        @remarks
+            By default, if you use Ogre's own rendering loop (Root::startRendering)
+            or call RenderTarget::update, all viewports are updated automatically.
+            This method allows you to control that behaviour, if for example you 
+			have a viewport which you only want to update periodically.
+        @param autoupdate If true, the viewport is updated during the automatic
+            render loop or when RenderTarget::update() is called. If false, the 
+            viewport is only updated when its update() method is called explicitly.
+        */
+		void setAutoUpdated(bool autoupdate);
+		/** Gets whether this viewport is automatically updated if 
+			Ogre's rendering loop or RenderTarget::update is being used.
+        */
+		bool isAutoUpdated() const;
+
+		/** Set the material scheme which the viewport should use.
+		@remarks
+			This allows you to tell the system to use a particular
+			material scheme when rendering this viewport, which can 
+			involve using different techniques to render your materials.
+		@see Technique::setSchemeName
+		*/
+		void setMaterialScheme(const String& schemeName)
+		{ mMaterialSchemeName = schemeName; }
+		
+		/** Get the material scheme which the viewport should use.
+		*/
+		const String& getMaterialScheme(void) const
+		{ return mMaterialSchemeName; }
+
+		/** Access to actual dimensions (based on target size).
+        */
+        void getActualDimensions(
+            int &left, int &top, int &width, int &height ) const;
+
+        bool _isUpdated(void) const;
+        void _clearUpdatedFlag(void);
+
+        /** Gets the number of rendered faces in the last update.
+        */
+        unsigned int _getNumRenderedFaces(void) const;
+
+        /** Gets the number of rendered batches in the last update.
+        */
+        unsigned int _getNumRenderedBatches(void) const;
+
+        /** Tells this viewport whether it should display Overlay objects.
+        @remarks
+            Overlay objects are layers which appear on top of the scene. They are created via
+            SceneManager::createOverlay and every viewport displays these by default.
+            However, you probably don't want this if you're using multiple viewports,
+            because one of them is probably a picture-in-picture which is not supposed to
+            have overlays of it's own. In this case you can turn off overlays on this viewport
+            by calling this method.
+        @param enabled If true, any overlays are displayed, if false they are not.
+        */
+        void setOverlaysEnabled(bool enabled);
+
+        /** Returns whether or not Overlay objects (created in the SceneManager) are displayed in this
+            viewport. */
+        bool getOverlaysEnabled(void) const;
+
+        /** Tells this viewport whether it should display skies.
+        @remarks
+            Skies are layers which appear on background of the scene. They are created via
+            SceneManager::setSkyBox, SceneManager::setSkyPlane and SceneManager::setSkyDome and
+            every viewport displays these by default. However, you probably don't want this if
+            you're using multiple viewports, because one of them is probably a picture-in-picture
+            which is not supposed to have skies of it's own. In this case you can turn off skies
+            on this viewport by calling this method.
+        @param enabled If true, any skies are displayed, if false they are not.
+        */
+        void setSkiesEnabled(bool enabled);
+
+        /** Returns whether or not skies (created in the SceneManager) are displayed in this
+            viewport. */
+        bool getSkiesEnabled(void) const;
+
+        /** Tells this viewport whether it should display shadows.
+        @remarks
+            This setting enables you to disable shadow rendering for a given viewport. The global
+			shadow technique set on SceneManager still controls the type and nature of shadows,
+			but this flag can override the setting so that no shadows are rendered for a given
+			viewport to save processing time where they are not required.
+        @param enabled If true, any shadows are displayed, if false they are not.
+        */
+        void setShadowsEnabled(bool enabled);
+
+        /** Returns whether or not shadows (defined in the SceneManager) are displayed in this
+            viewport. */
+        bool getShadowsEnabled(void) const;
+
+
+		/** Sets a per-viewport visibility mask.
+		@remarks
+			The visibility mask is a way to exclude objects from rendering for
+			a given viewport. For each object in the frustum, a check is made
+			between this mask and the objects visibility flags 
+			(@see MovableObject::setVisibilityFlags), and if a binary 'and'
+			returns zero, the object will not be rendered.
+		*/
+		void setVisibilityMask(uint32 mask) { mVisibilityMask = mask; }
+
+		/** Gets a per-viewport visibility mask.
+		@see Viewport::setVisibilityMask
+		*/
+		uint getVisibilityMask(void) const { return mVisibilityMask; }
+
+		/** Sets the use of a custom RenderQueueInvocationSequence for
+			rendering this target.
+		@remarks
+			RenderQueueInvocationSequence instances are managed through Root. By
+			setting this, you are indicating that you wish this RenderTarget to
+			be updated using a custom sequence of render queue invocations, with
+			potentially customised ordering and render state options. You should
+			create the named sequence through Root first, then set the name here.
+		@param The name of the RenderQueueInvocationSequence to use. If you
+			specify a blank string, behaviour will return to the default render
+			queue management.
+		*/
+		virtual void setRenderQueueInvocationSequenceName(const String& sequenceName);
+		/** Gets the name of the render queue invocation sequence for this target. */
+		virtual const String& getRenderQueueInvocationSequenceName(void) const;
+		/// Get the invocation sequence - will return null if using standard
+		RenderQueueInvocationSequence* _getRenderQueueInvocationSequence(void);
+
+        /** Convert oriented input point coordinates to screen coordinates. */
+        void pointOrientedToScreen(const Vector2 &v, int orientationMode, Vector2 &outv);
+        void pointOrientedToScreen(Real orientedX, Real orientedY, int orientationMode,
+                                   Real &screenX, Real &screenY);
+
+		/// Add a listener to this camera
+		void addListener(Listener* l);
+		/// Remove a listener to this camera
+		void removeListener(Listener* l);
+
+    protected:
+        Camera* mCamera;
+        RenderTarget* mTarget;
+        // Relative dimensions, irrespective of target dimensions (0..1)
+        float mRelLeft, mRelTop, mRelWidth, mRelHeight;
+        // Actual dimensions, based on target dimensions
+        int mActLeft, mActTop, mActWidth, mActHeight;
+        /// ZOrder
+        int mZOrder;
+        /// Background options
+        ColourValue mBackColour;
+		Real mDepthClearValue;
+        bool mClearEveryFrame;
+		unsigned int mClearBuffers;
+        bool mUpdated;
+        bool mShowOverlays;
+        bool mShowSkies;
+		bool mShowShadows;
+		uint32 mVisibilityMask;
+		// Render queue invocation sequence name
+		String mRQSequenceName;
+		RenderQueueInvocationSequence* mRQSequence;
+		/// Material scheme
+		String mMaterialSchemeName;
+        /// Viewport orientation mode
+        OrientationMode mOrientationMode;
+        static OrientationMode mDefaultOrientationMode;
+
+		/// Automatic rendering on/off
+		bool mIsAutoUpdated;
+
+		typedef vector<Listener*>::type ListenerList;
+		ListenerList mListeners;
+    };
+	/** @} */
+	/** @} */
+
+}
+
+#endif

data/deps/include/OGRE/OgreWindowEventUtilities.h

@@ -0,0 +1,186 @@
+/*
+-----------------------------------------------------------------------------
+This source file is part of OGRE
+    (Object-oriented Graphics Rendering Engine)
+For the latest info, see http://www.ogre3d.org/
+
+Copyright (c) 2000-2012 Torus Knot Software Ltd
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+-----------------------------------------------------------------------------
+*/
+#ifndef __OgreWindowEventUtils_H__
+#define __OgreWindowEventUtils_H__
+
+#include "OgrePrerequisites.h"
+#include "OgrePlatform.h"
+
+#if OGRE_PLATFORM == OGRE_PLATFORM_WIN32
+#  define WIN32_LEAN_AND_MEAN
+#  if !defined(NOMINMAX) && defined(_MSC_VER)
+#	define NOMINMAX // required to stop windows.h messing up std::min
+#  endif
+#  include <windows.h>
+#elif OGRE_PLATFORM == OGRE_PLATFORM_APPLE && !defined(__LP64__)
+#  include <Carbon/Carbon.h>
+#endif
+
+
+
+namespace Ogre
+{
+	/** \addtogroup Core
+	*  @{
+	*/
+	/** \addtogroup RenderSystem
+	*  @{
+	*/
+	/**
+	@remarks
+		Callback class used to send out window events to client app
+	*/
+	class _OgreExport WindowEventListener
+	{
+	public:
+		virtual ~WindowEventListener() {}
+
+		/**
+		@remarks
+			Window has moved position
+		@param rw
+			The RenderWindow which created this events
+		*/
+		virtual void windowMoved(RenderWindow* rw)
+                { (void)rw; }
+
+		/**
+		@remarks
+			Window has resized
+		@param rw
+			The RenderWindow which created this events
+		*/
+		virtual void windowResized(RenderWindow* rw)
+                { (void)rw; }
+
+		/**
+		@remarks
+			Window is closing (Only triggered if user pressed the [X] button)
+		@param rw
+			The RenderWindow which created this events
+		@return True will close the window(default).
+		*/
+		virtual bool windowClosing(RenderWindow* rw)
+		{ (void)rw; return true; }
+
+		/**
+		@remarks
+			Window has been closed (Only triggered if user pressed the [X] button)
+		@param rw
+			The RenderWindow which created this events
+		@note
+			The window has not actually close yet when this event triggers. It's only closed after
+			all windowClosed events are triggered. This allows apps to deinitialise properly if they
+			have services that needs the window to exist when deinitialising.
+		*/
+		virtual void windowClosed(RenderWindow* rw)
+                { (void)rw; }
+
+		/**
+		@remarks
+			Window has lost/gained focus
+		@param rw
+			The RenderWindow which created this events
+		*/
+		virtual void windowFocusChange(RenderWindow* rw)
+                { (void)rw; }
+	};
+
+	/**
+	@remarks
+		Utility class to handle Window Events/Pumping/Messages
+	*/
+	class _OgreExport WindowEventUtilities
+	{
+	public:
+		/**
+		@remarks
+			Call this once per frame if not using Root:startRendering(). This will update all registered
+			RenderWindows (If using external Windows, you can optionally register those yourself)
+		*/
+		static void messagePump();
+
+		/**
+		@remarks
+			Add a listener to listen to renderwindow events (multiple listener's per renderwindow is fine)
+			The same listener can listen to multiple windows, as the Window Pointer is sent along with
+			any messages.
+		@param window
+			The RenderWindow you are interested in monitoring
+		@param listner
+			Your callback listener
+		*/
+		static void addWindowEventListener( RenderWindow* window, WindowEventListener* listener );
+
+		/**
+		@remarks
+			Remove previously added listener
+		@param window
+			The RenderWindow you registered with
+		@param listner
+			The listener registered
+		*/
+		static void removeWindowEventListener( RenderWindow* window, WindowEventListener* listener );
+
+		/**
+		@remarks
+			Called by RenderWindows upon creation for Ogre generated windows. You are free to add your
+			external windows here too if needed.
+		@param window
+			The RenderWindow to monitor
+		*/
+		static void _addRenderWindow(RenderWindow* window);
+
+		/**
+		@remarks
+			Called by RenderWindows upon creation for Ogre generated windows. You are free to add your
+			external windows here too if needed.
+		@param window
+			The RenderWindow to remove from list
+		*/
+		static void _removeRenderWindow(RenderWindow* window);
+
+#if OGRE_PLATFORM == OGRE_PLATFORM_WIN32
+		//! Internal winProc (RenderWindow's use this when creating the Win32 Window)
+		static LRESULT CALLBACK _WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
+#elif OGRE_PLATFORM == OGRE_PLATFORM_APPLE && !defined __OBJC__ && !defined(__LP64__)
+        //! Internal UPP Window Handler (RenderWindow's use this when creating the OS X Carbon Window
+        static OSStatus _CarbonWindowHandler(EventHandlerCallRef nextHandler, EventRef event, void* wnd);
+#endif
+
+		//These are public only so GLXProc can access them without adding Xlib headers header
+		typedef multimap<RenderWindow*, WindowEventListener*>::type WindowEventListeners;
+		static WindowEventListeners _msListeners;
+
+		typedef vector<RenderWindow*>::type Windows;
+		static Windows _msWindows;
+	};
+	/** @} */
+	/** @} */
+}
+#endif

data/deps/include/OGRE/OgreWireBoundingBox.h

@@ -0,0 +1,87 @@
+/*
+-----------------------------------------------------------------------------
+This source file is part of OGRE
+    (Object-oriented Graphics Rendering Engine)
+For the latest info, see http://www.ogre3d.org/
+
+Copyright (c) 2000-2012 Torus Knot Software Ltd
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+-----------------------------------------------------------------------------
+*/
+#ifndef _WireBoundingBox_H__
+#define _WireBoundingBox_H__
+
+#include "OgrePrerequisites.h"
+
+#include "OgreSimpleRenderable.h"
+
+namespace Ogre {
+
+	/** \addtogroup Core
+	*  @{
+	*/
+	/** \addtogroup Scene
+	*  @{
+	*/
+	/** Allows the rendering of a wireframe bounding box.
+        @remarks
+            This class builds a wireframe renderable from a given aabb. A pointer to this class can be
+			added to a render queue to display the bounding box of an object.
+    */
+	class _OgreExport WireBoundingBox : public SimpleRenderable
+	{
+    protected:
+        /** Override this method to prevent parent transforms (rotation,translation,scale)
+        */
+		void getWorldTransforms( Matrix4* xform ) const;
+		
+        /** Builds the wireframe line list.
+        */
+		void setupBoundingBoxVertices(const AxisAlignedBox& aab);
+
+        Real mRadius;
+
+		void _initWireBoundingBox();
+
+	public:
+			
+		WireBoundingBox();
+		WireBoundingBox(const String& name);
+		~WireBoundingBox();
+
+        /** Builds the wireframe line list.
+            @param
+                aabb bounding box to build a wireframe from.
+        */
+		void setupBoundingBox(const AxisAlignedBox& aabb);
+
+		Real getSquaredViewDepth(const Camera* cam) const;
+
+        Real getBoundingRadius(void) const { return mRadius; }
+
+	};
+	/** @} */
+	/** @} */
+
+}// namespace
+
+#endif
+
+