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

data/deps/include/OGRE/OgreRenderTargetListener.h

@@ -1,146 +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 __RenderTargetListener_H__
-#define __RenderTargetListener_H__
-
-
-#include "OgrePrerequisites.h"
-
-namespace Ogre {
-
-	/** \addtogroup Core
-	*  @{
-	*/
-	/** \addtogroup RenderSystem
-	*  @{
-	*/
-	/** Struct containing information about a RenderTarget event.
-    */
-    struct RenderTargetEvent
-    {
-        /// The source of the event being raised
-        RenderTarget* source;
-    };
-
-    /** Struct containing information about a RenderTarget Viewport-specific event.
-    */
-    struct RenderTargetViewportEvent
-    {
-        /// The source of the event being raised
-        Viewport* source;
-    };
-
-    /** A interface class defining a listener which can be used to receive
-        notifications of RenderTarget events.
-        @remarks
-            A 'listener' is an interface designed to be called back when
-            particular events are called. This class defines the
-            interface relating to RenderTarget events. In order to receive
-            notifications of RenderTarget events, you should create a subclass of
-            RenderTargetListener and override the methods for which you would like
-            to customise the resulting processing. You should then call
-            RenderTarget::addListener passing an instance of this class.
-            There is no limit to the number of RenderTarget listeners you can register,
-            allowing you to register multiple listeners for different purposes.
-            </p>
-            RenderTarget events occur before and after the target is updated as a whole,
-            and before and after each viewport on that target is updated. Each RenderTarget
-            holds it's own set of listeners, but you can register the same listener on
-            multiple render targets if you like since the event contains details of the
-            originating RenderTarget.
-    */
-    class _OgreExport RenderTargetListener
-    {
-        /*
-        Note that this could have been an abstract class, but I made
-        the explicit choice not to do this, because I wanted to give
-        people the option of only implementing the methods they wanted,
-        rather than having to create 'do nothing' implementations for
-        those they weren't interested in. As such this class follows
-        the 'Adapter' classes in Java rather than pure interfaces.
-        */
-    public:
-		virtual ~RenderTargetListener() {}
-        /** Called just before a RenderTarget is about to be rendered into.
-        @remarks
-            This event is raised just before any of the viewports on the target
-            are rendered to. You can perform manual rendering operations here if
-            you want, but please note that if the Viewport objects attached to this
-            target are set up to clear the background, you will lose whatever you 
-            render. If you want some kind of backdrop in this event
-            you should turn off background clearing off on the viewports, and either
-            clear the viewports yourself in this event handler before doing your rendering
-            or just render over the top if you don't need to.
-        */
-        virtual void preRenderTargetUpdate(const RenderTargetEvent& evt)
-        { (void)evt; }
-
-        /** Called just after a RenderTarget has been rendered to.
-        @remarks
-            This event is called just after all the viewports attached to the target
-            in question have been rendered to. You can perform your own manual rendering
-            commands in this event handler if you like, these will be composited with
-            the contents of the target already there (depending on the material settings 
-            you use etc).
-        */
-        virtual void postRenderTargetUpdate(const RenderTargetEvent& evt)
-        { (void)evt; }
-
-        /* Called just before a Viewport on a RenderTarget is to be updated.
-        @remarks
-            This method is called before each viewport on the RenderTarget is
-            rendered to. You can use this to perform per-viewport settings changes,
-            such as showing / hiding particular overlays.
-        */
-        virtual void preViewportUpdate(const RenderTargetViewportEvent& evt)
-        { (void)evt; }
-
-        /* Called just after a Viewport on a RenderTarget is to be updated.
-        @remarks
-            This method is called after each viewport on the RenderTarget is
-            rendered to. 
-        */
-        virtual void postViewportUpdate(const RenderTargetViewportEvent& evt)
-        { (void)evt; }
-
-		/** Called to notify listener that a Viewport has been added to the 
-			target in question.
-		*/
-		virtual void viewportAdded(const RenderTargetViewportEvent& evt)
-                { (void)evt; }
-		/** Called to notify listener that a Viewport has been removed from the 
-			target in question.
-		*/
-		virtual void viewportRemoved(const RenderTargetViewportEvent& evt)
-                { (void)evt; }
-    };
-	/** @} */
-	/** @} */
-}
-
-#endif

data/deps/include/OGRE/OgreRenderTexture.h

@@ -1,140 +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 __RenderTexture_H__
-#define __RenderTexture_H__
-
-#include "OgrePrerequisites.h"
-
-#include "OgreRenderTarget.h"
-
-namespace Ogre
-{    
-	/** \addtogroup Core
-	*  @{
-	*/
-	/** \addtogroup RenderSystem
-	*  @{
-	*/
-	/** This class represents a RenderTarget that renders to a Texture. There is no 1 on 1
-        relation between Textures and RenderTextures, as there can be multiple 
-        RenderTargets rendering to different mipmaps, faces (for cubemaps) or slices (for 3D textures)
-        of the same Texture.
-    */
-    class _OgreExport RenderTexture: public RenderTarget
-    {
-    public:
-        RenderTexture(HardwarePixelBuffer *buffer, size_t zoffset);
-        virtual ~RenderTexture();
-
-		virtual void copyContentsToMemory(const PixelBox &dst, FrameBuffer buffer);
-		PixelFormat suggestPixelFormat() const;
-
-	protected:
-		HardwarePixelBuffer *mBuffer;
-		size_t mZOffset;
-    };
-
-	/** This class represents a render target that renders to multiple RenderTextures
-		at once. Surfaces can be bound and unbound at will, as long as the following constraints
-		are met:
-		- All bound surfaces have the same size
-		- All bound surfaces have the same bit depth
-		- Target 0 is bound
-	*/
-	class _OgreExport MultiRenderTarget: public RenderTarget
-	{
-	public:
-		MultiRenderTarget(const String &name);
-
-		/** Bind a surface to a certain attachment point.
-            @param attachment	0 .. mCapabilities->getNumMultiRenderTargets()-1
-			@param target		RenderTexture to bind.
-
-			It does not bind the surface and fails with an exception (ERR_INVALIDPARAMS) if:
-			- Not all bound surfaces have the same size
-			- Not all bound surfaces have the same internal format 
-		*/
-
-		virtual void bindSurface(size_t attachment, RenderTexture *target)
-		{
-			for (size_t i = mBoundSurfaces.size(); i <= attachment; ++i)
-			{
-				mBoundSurfaces.push_back(0);
-			}
-			mBoundSurfaces[attachment] = target;
-
-			bindSurfaceImpl(attachment, target);
-		}
-
-
-
-		/** Unbind attachment.
-		*/
-
-		virtual void unbindSurface(size_t attachment)
-		{
-			if (attachment < mBoundSurfaces.size())
-				mBoundSurfaces[attachment] = 0;
-			unbindSurfaceImpl(attachment);
-		}
-
-		/** Error throwing implementation, it's not possible to write a MultiRenderTarget
-			to disk. 
-		*/
-		virtual void copyContentsToMemory(const PixelBox &dst, FrameBuffer buffer);
-
-		/// Irrelevant implementation since cannot copy
-		PixelFormat suggestPixelFormat() const { return PF_UNKNOWN; }
-
-		typedef vector<RenderTexture*>::type BoundSufaceList;
-		/// Get a list of the surfaces which have been bound
-		const BoundSufaceList& getBoundSurfaceList() const { return mBoundSurfaces; }
-
-		/** Get a pointer to a bound surface */
-		RenderTexture* getBoundSurface(size_t index)
-		{
-			assert (index < mBoundSurfaces.size());
-			return mBoundSurfaces[index];
-		}
-
-
-	protected:
-		BoundSufaceList mBoundSurfaces;
-
-		/// implementation of bindSurface, must be provided
-		virtual void bindSurfaceImpl(size_t attachment, RenderTexture *target) = 0;
-		/// implementation of unbindSurface, must be provided
-		virtual void unbindSurfaceImpl(size_t attachment) = 0;
-
-
-	};
-	/** @} */
-	/** @} */
-}
-
-#endif

data/deps/include/OGRE/OgreRenderToVertexBuffer.h

@@ -1,151 +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 __RenderToVertexBuffer_H__
-#define __RenderToVertexBuffer_H__
-
-#include "OgrePrerequisites.h"
-#include "OgreMaterial.h"
-#include "OgreRenderOperation.h"
-
-namespace Ogre {
-	/** \addtogroup Core
-	*  @{
-	*/
-	/** \addtogroup RenderSystem
-	*  @{
-	*/
-	/**
-        An object which renders geometry to a vertex.
-    @remarks
-        This is especially useful together with geometry shaders, as you can
-        render procedural geometry which will get saved to a vertex buffer for
-        reuse later, without regenerating it again. You can also create shaders
-        that run on previous results of those shaders, creating stateful 
-        shaders.
-    */
-    class _OgreExport RenderToVertexBuffer
-    {    
-    public:
-		/** C'tor */
-		RenderToVertexBuffer();
-		/** D'tor */
-        virtual ~RenderToVertexBuffer();
-
-        /**
-            Get the vertex declaration that the pass will output.
-        @remarks
-            Use this object to set the elements of the buffer. Object will calculate
-            buffers on its own. Only one source allowed!
-        */
-        VertexDeclaration* getVertexDeclaration();
-        
-        /**
-            Get the maximum number of vertices that the buffer will hold
-        */
-		unsigned int getMaxVertexCount() const { return mMaxVertexCount; }
-        
-        /**
-            Set the maximum number of vertices that the buffer will hold
-        */
-		void setMaxVertexCount(unsigned int maxVertexCount) { mMaxVertexCount = maxVertexCount; }
-
-        /**
-            What type of primitives does this object generate?
-        */
-		RenderOperation::OperationType getOperationType() const { return mOperationType; }
-
-        /**
-            Set the type of primitives that this object generates
-        */
-		void setOperationType(RenderOperation::OperationType operationType) { mOperationType = operationType; }
-
-        /**
-            Set wether this object resets its buffers each time it updates.
-        */
-		void setResetsEveryUpdate(bool resetsEveryUpdate) { mResetsEveryUpdate = resetsEveryUpdate; }
-
-        /**
-            Does this object reset its buffer each time it updates?
-        */
-		bool getResetsEveryUpdate() const { return mResetsEveryUpdate; }
-
-        /**
-            Get the render operation for this buffer 
-        */
-        virtual void getRenderOperation(RenderOperation& op) = 0;
-
-        /**
-            Update the contents of this vertex buffer by rendering
-        */
-        virtual void update(SceneManager* sceneMgr) = 0;
-
-        /**
-            Reset the vertex buffer to the initial state. In the next update,
-            the source renderable will be used as input.
-        */
-		virtual void reset() { mResetRequested = true; }
-        
-        /**
-            Set the source renderable of this object. During the first (and 
-            perhaps later) update of this object, this object's data will be
-            used as input)
-        */
-		void setSourceRenderable(Renderable* source) { mSourceRenderable = source; }
-
-        /**
-            Get the source renderable of this object
-        */
-		const Renderable* getSourceRenderable() const { return mSourceRenderable; }
-
-        /**
-            Get the material which is used to render the geometry into the
-            vertex buffer.
-        */
-		const MaterialPtr& getRenderToBufferMaterial() { return mMaterial; }
-
-        /**
-            Set the material name which is used to render the geometry into
-            the vertex buffer
-        */
-        void setRenderToBufferMaterialName(const String& materialName);
-    protected:
-        RenderOperation::OperationType mOperationType;
-        bool mResetsEveryUpdate;
-		bool mResetRequested;
-        MaterialPtr mMaterial;
-        Renderable* mSourceRenderable;
-		VertexData* mVertexData;
-		unsigned int mMaxVertexCount;
-    };
-
-	typedef SharedPtr<RenderToVertexBuffer> RenderToVertexBufferSharedPtr;
-	/** @} */
-	/** @} */
-}
-
-#endif

data/deps/include/OGRE/OgreRenderWindow.h

@@ -1,225 +0,0 @@
-/*-------------------------------------------------------------------------
-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-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 __RenderWindow_H__
-#define __RenderWindow_H__
-
-#include "OgrePrerequisites.h"
-
-#include "OgreRenderTarget.h"
-
-namespace Ogre
-{
-	/** \addtogroup Core
-	*  @{
-	*/
-	/** \addtogroup RenderSystem
-	*  @{
-	*/
-	/** Manages the target rendering window.
-        @remarks
-            This class handles a window into which the contents
-            of a scene are rendered. There is a many-to-1 relationship
-            between instances of this class an instance of RenderSystem
-            which controls the rendering of the scene. There may be
-            more than one window in the case of level editor tools etc.
-            This class is abstract since there may be
-            different implementations for different windowing systems.
-        @remarks
-            Instances are created and communicated with by the render system
-            although client programs can get a reference to it from
-            the render system if required for resizing or moving.
-            Note that you can have multiple viewpoints
-            in the window for effects like rear-view mirrors and
-            picture-in-picture views (see Viewport and Camera).
-        @author
-            Steven Streeting
-        @version
-            1.0
-    */
-    class _OgreExport RenderWindow : public RenderTarget
-    {
-
-    public:
-        /** Default constructor.
-        */
-        RenderWindow();
-
-        /** Creates & displays the new window.
-            @param
-                width The width of the window in pixels.
-            @param
-                height The height of the window in pixels.
-            @param
-                colourDepth The colour depth in bits. Ignored if
-                fullScreen is false since the desktop depth is used.
-            @param
-                fullScreen If true, the window fills the screen,
-                with no title bar or border.
-            @param
-                left The x-position of the window. Ignored if
-                fullScreen = true.
-            @param
-                top The y-position of the window. Ignored if
-                fullScreen = true.
-            @param
-                depthBuffer Specify true to include a depth-buffer.
-            @param
-                miscParam A variable number of pointers to platform-specific arguments. The
-                actual requirements must be defined by the implementing subclasses.
-        */
-		virtual void create(const String& name, unsigned int width, unsigned int height,
-	            bool fullScreen, const NameValuePairList *miscParams) = 0;
-
-		/** Alter fullscreen mode options. 
-		@note Nothing will happen unless the settings here are different from the
-			current settings.
-		@param fullScreen Whether to use fullscreen mode or not. 
-		@param width The new width to use
-		@param height The new height to use
-		*/
-		virtual void setFullscreen(bool fullScreen, unsigned int width, unsigned int height)
-                { (void)fullScreen; (void)width; (void)height; }
-        
-        /** Destroys the window.
-        */
-        virtual void destroy(void) = 0;
-
-        /** Alter the size of the window.
-        */
-        virtual void resize(unsigned int width, unsigned int height) = 0;
-
-        /** Notify that the window has been resized
-        @remarks
-            You don't need to call this unless you created the window externally.
-        */
-        virtual void windowMovedOrResized() {}
-
-        /** Reposition the window.
-        */
-        virtual void reposition(int left, int top) = 0;
-
-        /** Indicates whether the window is visible (not minimized or obscured)
-        */
-        virtual bool isVisible(void) const { return true; }
-
-        /** Set the visibility state
-        */
-        virtual void setVisible(bool visible)
-        { (void)visible; }
-
-		/** Indicates whether the window was set to hidden (not displayed)
-		*/
-		virtual bool isHidden(void) const { return false; }
-
-		/** Hide (or show) the window. If called with hidden=true, this
-			will make the window completely invisible to the user.
-		@remarks
-			Setting a window to hidden is useful to create a dummy primary
-			RenderWindow hidden from the user so that you can create and
-			recreate your actual RenderWindows without having to recreate
-			all your resources.
-		*/
-		virtual void setHidden(bool hidden)
-		{ (void)hidden; }
-
-		/** Enable or disable vertical sync for the RenderWindow.
-		*/
-		virtual void setVSyncEnabled(bool vsync)
-		{ (void)vsync; }
-
-		/** Indicates whether vertical sync is activated for the window.
-		*/
-		virtual bool isVSyncEnabled() const { return false; }
-
-		/** Set the vertical sync interval. This indicates the number of vertical retraces to wait for
-		  	before swapping buffers. A value of 1 is the default.
-		*/
-		virtual void setVSyncInterval(unsigned int interval)
-		{ (void)interval; }
-
-		/** Returns the vertical sync interval. 
-		*/
-		virtual unsigned int getVSyncInterval() const { return 1; }
-	    
-
-        /** Overridden from RenderTarget, flags invisible windows as inactive
-        */
-        virtual bool isActive(void) const { return mActive && isVisible(); }
-
-        /** Indicates whether the window has been closed by the user.
-        */
-        virtual bool isClosed(void) const = 0;
-        
-        /** Indicates whether the window is the primary window. The
-        	primary window is special in that it is destroyed when 
-        	ogre is shut down, and cannot be destroyed directly.
-        	This is the case because it holds the context for vertex,
-        	index buffers and textures.
-        */
-        virtual bool isPrimary(void) const;
-
-        /** Returns true if window is running in fullscreen mode.
-        */
-        virtual bool isFullScreen(void) const;
-
-        /** Overloaded version of getMetrics from RenderTarget, including extra details
-            specific to windowing systems.
-        */
-        virtual void getMetrics(unsigned int& width, unsigned int& height, unsigned int& colourDepth, 
-			int& left, int& top);
-
-		/// Override since windows don't usually have alpha
-		PixelFormat suggestPixelFormat() const { return PF_BYTE_RGB; }
-
-        /** Returns true if the window will automatically de-activate itself when it loses focus.
-        */
-        bool isDeactivatedOnFocusChange() const;
-
-        /** Indicates whether the window will automatically deactivate itself when it loses focus.
-          * \param deactivate a value of 'true' will cause the window to deactivate itself when it loses focus.  'false' will allow it to continue to render even when window focus is lost.
-          * \note 'true' is the default behavior.
-          */
-        void setDeactivateOnFocusChange(bool deactivate);
-
-    protected:
-        bool mIsFullScreen;
-        bool mIsPrimary;
-        bool mAutoDeactivatedOnFocusChange;
-        int mLeft;
-        int mTop;
-        
-        /** Indicates that this is the primary window. Only to be called by
-            Ogre::Root
-        */
-        void _setPrimary() { mIsPrimary = true; }
-        
-        friend class Root;
-    };
-	/** @} */
-	/** @} */
-
-} // Namespace
-#endif