ruby-ogre 0.0.5-x86-linux → 0.1.0-x86-linux

data/deps/include/OGRE/OgreVertexIndexData.h

@@ -1,323 +0,0 @@
-/*
------------------------------------------------------------------------------
-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 __VertexIndexData_H__
-#define __VertexIndexData_H__
-
-#include "OgrePrerequisites.h"
-#include "OgreHardwareVertexBuffer.h"
-#include "OgreHardwareIndexBuffer.h"
-
-namespace Ogre {
-	/** \addtogroup Core
-	*  @{
-	*/
-	/** \addtogroup RenderSystem
-	*  @{
-	*/
-
-	/// Define a list of usage flags
-	typedef vector<HardwareBuffer::Usage>::type BufferUsageList;
-
-
-	/** Summary class collecting together vertex source information. */
-	class _OgreExport VertexData : public VertexDataAlloc
-	{
-    private:
-        /// Protected copy constructor, to prevent misuse
-        VertexData(const VertexData& rhs); /* do nothing, should not use */
-        /// Protected operator=, to prevent misuse
-        VertexData& operator=(const VertexData& rhs); /* do not use */
-
-		HardwareBufferManagerBase* mMgr;
-    public:
-		/** Constructor.
-		@note 
-			This constructor creates the VertexDeclaration and VertexBufferBinding
-			automatically, and arranges for their deletion afterwards.
-		@param mgr Optional HardwareBufferManager from which to create resources
-		*/
-        VertexData(HardwareBufferManagerBase* mgr = 0);
-		/** Constructor.
-		@note 
-		This constructor receives the VertexDeclaration and VertexBufferBinding
-		from the caller, and as such does not arrange for their deletion afterwards, 
-		the caller remains responsible for that.
-		@param dcl The VertexDeclaration to use
-		@param bind The VertexBufferBinding to use
-		*/
-		VertexData(VertexDeclaration* dcl, VertexBufferBinding* bind);
-        ~VertexData();
-
-		/** Declaration of the vertex to be used in this operation. 
-		@remarks Note that this is created for you on construction.
-		*/
-		VertexDeclaration* vertexDeclaration;
-		/** The vertex buffer bindings to be used. 
-		@remarks Note that this is created for you on construction.
-		*/
-		VertexBufferBinding* vertexBufferBinding;
-		/// Whether this class should delete the declaration and binding
-		bool mDeleteDclBinding;
-		/// The base vertex index to start from
-		size_t vertexStart;
-		/// The number of vertices used in this operation
-		size_t vertexCount;
-
-
-		/// Struct used to hold hardware morph / pose vertex data information
-		struct HardwareAnimationData
-		{
-			unsigned short targetBufferIndex;
-			Real parametric;
-		};
-		typedef vector<HardwareAnimationData>::type HardwareAnimationDataList;
-		/// VertexElements used for hardware morph / pose animation
-		HardwareAnimationDataList hwAnimationDataList;
-		/// Number of hardware animation data items used
-		size_t hwAnimDataItemsUsed;
-		
-		/** Clones this vertex data, potentially including replicating any vertex buffers.
-		@param copyData Whether to create new vertex buffers too or just reference the existing ones
-		@param mgr If supplied, the buffer manager through which copies should be made
-		@remarks The caller is expected to delete the returned pointer when ready
-		*/
-		VertexData* clone(bool copyData = true, HardwareBufferManagerBase* mgr = 0) const;
-
-        /** Modifies the vertex data to be suitable for use for rendering shadow geometry.
-        @remarks
-            Preparing vertex data to generate a shadow volume involves firstly ensuring that the 
-            vertex buffer containing the positions is a standalone vertex buffer,
-            with no other components in it. This method will therefore break apart any existing
-            vertex buffers if position is sharing a vertex buffer. 
-            Secondly, it will double the size of this vertex buffer so that there are 2 copies of 
-            the position data for the mesh. The first half is used for the original, and the second 
-            half is used for the 'extruded' version. The vertex count used to render will remain 
-            the same though, so as not to add any overhead to regular rendering of the object.
-            Both copies of the position are required in one buffer because shadow volumes stretch 
-            from the original mesh to the extruded version. 
-        @par
-            It's important to appreciate that this method can fundamentally change the structure of your
-            vertex buffers, although in reality they will be new buffers. As it happens, if other 
-            objects are using the original buffers then they will be unaffected because the reference
-            counting will keep them intact. However, if you have made any assumptions about the 
-            structure of the vertex data in the buffers of this object, you may have to rethink them.
-        */
-        void prepareForShadowVolume(void);
-
-        /** Additional shadow volume vertex buffer storage. 
-        @remarks
-            This additional buffer is only used where we have prepared this VertexData for
-            use in shadow volume construction, and where the current render system supports
-            vertex programs. This buffer contains the 'w' vertex position component which will
-            be used by that program to differentiate between extruded and non-extruded vertices.
-            This 'w' component cannot be included in the original position buffer because
-            DirectX does not allow 4-component positions in the fixed-function pipeline, and the original
-            position buffer must still be usable for fixed-function rendering.
-        @par    
-            Note that we don't store any vertex declaration or vertex buffer binding here because this
-            can be reused in the shadow algorithm.
-        */
-        HardwareVertexBufferSharedPtr hardwareShadowVolWBuffer;
-
-
-		/** Reorganises the data in the vertex buffers according to the 
-			new vertex declaration passed in. Note that new vertex buffers
-			are created and written to, so if the buffers being referenced 
-			by this vertex data object are also used by others, then the 
-			original buffers will not be damaged by this operation.
-			Once this operation has completed, the new declaration 
-			passed in will overwrite the current one.
-		@param newDeclaration The vertex declaration which will be used
-			for the reorganised buffer state. Note that the new declaration
-			must not include any elements which do not already exist in the 
-			current declaration; you can drop elements by 
-			excluding them from the declaration if you wish, however.
-		@param bufferUsages Vector of usage flags which indicate the usage options
-			for each new vertex buffer created. The indexes of the entries must correspond
-			to the buffer binding values referenced in the declaration.
-		@param mgr Optional pointer to the manager to use to create new declarations
-			and buffers etc. If not supplied, the HardwareBufferManager singleton will be used
-		*/
-		void reorganiseBuffers(VertexDeclaration* newDeclaration, const BufferUsageList& bufferUsage, 
-			HardwareBufferManagerBase* mgr = 0);
-
-		/** Reorganises the data in the vertex buffers according to the 
-			new vertex declaration passed in. Note that new vertex buffers
-			are created and written to, so if the buffers being referenced 
-			by this vertex data object are also used by others, then the 
-			original buffers will not be damaged by this operation.
-			Once this operation has completed, the new declaration 
-			passed in will overwrite the current one.
-            This version of the method derives the buffer usages from the existing
-            buffers, by using the 'most flexible' usage from the equivalent sources.
-		@param newDeclaration The vertex declaration which will be used
-			for the reorganised buffer state. Note that the new delcaration
-			must not include any elements which do not already exist in the 
-			current declaration; you can drop elements by 
-			excluding them from the declaration if you wish, however.
-		@param mgr Optional pointer to the manager to use to create new declarations
-			and buffers etc. If not supplied, the HardwareBufferManager singleton will be used
-		*/
-		void reorganiseBuffers(VertexDeclaration* newDeclaration, HardwareBufferManagerBase* mgr = 0);
-
-        /** Remove any gaps in the vertex buffer bindings.
-        @remarks
-            This is useful if you've removed elements and buffers from this vertex
-            data and want to remove any gaps in the vertex buffer bindings. This
-            method is mainly useful when reorganising vertex data manually.
-        @note
-            This will cause binding index of the elements in the vertex declaration
-            to be altered to new binding index.
-        */
-        void closeGapsInBindings(void);
-
-        /** Remove all vertex buffers that never used by the vertex declaration.
-        @remarks
-            This is useful if you've removed elements from the vertex declaration
-            and want to unreference buffers that never used any more. This method
-            is mainly useful when reorganising vertex data manually.
-        @note
-            This also remove any gaps in the vertex buffer bindings.
-        */
-        void removeUnusedBuffers(void);
-
-		/** Convert all packed colour values (VET_COLOUR_*) in buffers used to
-			another type.
-		@param srcType The source colour type to assume if the ambiguous VET_COLOUR
-			is encountered.
-		@param destType The destination colour type, must be VET_COLOUR_ABGR or
-			VET_COLOUR_ARGB.
-		*/
-		void convertPackedColour(VertexElementType srcType, VertexElementType destType);
-
-
-		/** Allocate elements to serve a holder of morph / pose target data 
-			for hardware morphing / pose blending.
-		@remarks
-			This method will allocate the given number of 3D texture coordinate 
-			sets for use as a morph target or target pose offset (3D position).
-			These elements will be saved in hwAnimationDataList.
-			It will also assume that the source of these new elements will be new
-			buffers which are not bound at this time, so will start the sources to 
-			1 higher than the current highest binding source. The caller is
-			expected to bind these new buffers when appropriate. For morph animation
-			the original position buffer will be the 'from' keyframe data, whilst
-			for pose animation it will be the original vertex data.
-			If normals are animated, then twice the number of 3D texture coordinates are required
-		 @return The number of sets that were supported
-		*/
-		ushort allocateHardwareAnimationElements(ushort count, bool animateNormals);
-
-
-
-	};
-
-	/** Summary class collecting together index data source information. */
-	class _OgreExport IndexData : public IndexDataAlloc
-	{
-    protected:
-        /// Protected copy constructor, to prevent misuse
-        IndexData(const IndexData& rhs); /* do nothing, should not use */
-        /// Protected operator=, to prevent misuse
-        IndexData& operator=(const IndexData& rhs); /* do not use */
-    public:
-        IndexData();
-        ~IndexData();
-		/// pointer to the HardwareIndexBuffer to use, must be specified if useIndexes = true
-		HardwareIndexBufferSharedPtr indexBuffer;
-
-		/// index in the buffer to start from for this operation
-		size_t indexStart;
-
-		/// The number of indexes to use from the buffer
-		size_t indexCount;
-
-		/** Clones this index data, potentially including replicating the index buffer.
-		@param copyData Whether to create new buffers too or just reference the existing ones
-		@param mgr If supplied, the buffer manager through which copies should be made
-		@remarks The caller is expected to delete the returned pointer when finished
-		*/
-		IndexData* clone(bool copyData = true, HardwareBufferManagerBase* mgr = 0) const;
-
-		/** Re-order the indexes in this index data structure to be more
-			vertex cache friendly; that is to re-use the same vertices as close
-			together as possible. 
-		@remarks
-			Can only be used for index data which consists of triangle lists.
-			It would in fact be pointless to use it on triangle strips or fans
-			in any case.
-		*/
-		void optimiseVertexCacheTriList(void);
-	
-	};
-
-	/** Vertex cache profiler.
-	@remarks
-		Utility class for evaluating the effectiveness of the use of the vertex
-		cache by a given index buffer.
-	*/
-	class _OgreExport VertexCacheProfiler : public BufferAlloc
-    {
-		public:
-			enum CacheType {
-				FIFO, LRU
-			};
-
-			VertexCacheProfiler(unsigned int cachesize = 16, CacheType cachetype = FIFO )
-				: size ( cachesize ), type ( cachetype ), tail (0), buffersize (0), hit (0), miss (0)
-			{
-				cache = OGRE_ALLOC_T(uint32, size, MEMCATEGORY_GEOMETRY);
-			}
-
-			~VertexCacheProfiler()
-			{
-				OGRE_FREE(cache, MEMCATEGORY_GEOMETRY);
-			}
-
-			void profile(const HardwareIndexBufferSharedPtr& indexBuffer);
-			void reset() { hit = 0; miss = 0; tail = 0; buffersize = 0; }
-			void flush() { tail = 0; buffersize = 0; }
-
-			unsigned int getHits() { return hit; }
-			unsigned int getMisses() { return miss; }
-			unsigned int getSize() { return size; }
-		private:
-			unsigned int size;
-			uint32 *cache;
-			CacheType type;
-
-			unsigned int tail, buffersize;
-			unsigned int hit, miss;
-
-			bool inCache(unsigned int index);
-	};
-	/** @} */
-	/** @} */
-}
-#endif
-

data/deps/include/OGRE/OgreViewport.h

@@ -1,433 +0,0 @@
-/*
------------------------------------------------------------------------------
-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