ruby-ogre 0.0.1-x86-linux

data/deps/include/OGRE/OgreRay.h

@@ -0,0 +1,122 @@
+/*
+-----------------------------------------------------------------------------
+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 __Ray_H_
+#define __Ray_H_
+
+// Precompiler options
+#include "OgrePrerequisites.h"
+
+#include "OgreVector3.h"
+#include "OgrePlaneBoundedVolume.h"
+
+namespace Ogre {
+
+	/** \addtogroup Core
+	*  @{
+	*/
+	/** \addtogroup Math
+	*  @{
+	*/
+	/** Representation of a ray in space, i.e. a line with an origin and direction. */
+    class _OgreExport Ray
+    {
+    protected:
+        Vector3 mOrigin;
+        Vector3 mDirection;
+    public:
+        Ray():mOrigin(Vector3::ZERO), mDirection(Vector3::UNIT_Z) {}
+        Ray(const Vector3& origin, const Vector3& direction)
+            :mOrigin(origin), mDirection(direction) {}
+
+        /** Sets the origin of the ray. */
+        void setOrigin(const Vector3& origin) {mOrigin = origin;} 
+        /** Gets the origin of the ray. */
+        const Vector3& getOrigin(void) const {return mOrigin;} 
+
+        /** Sets the direction of the ray. */
+        void setDirection(const Vector3& dir) {mDirection = dir;} 
+        /** Gets the direction of the ray. */
+        const Vector3& getDirection(void) const {return mDirection;} 
+
+		/** Gets the position of a point t units along the ray. */
+		Vector3 getPoint(Real t) const { 
+			return Vector3(mOrigin + (mDirection * t));
+		}
+		
+		/** Gets the position of a point t units along the ray. */
+		Vector3 operator*(Real t) const { 
+			return getPoint(t);
+		}
+
+		/** Tests whether this ray intersects the given plane. 
+		@return A pair structure where the first element indicates whether
+			an intersection occurs, and if true, the second element will
+			indicate the distance along the ray at which it intersects. 
+			This can be converted to a point in space by calling getPoint().
+		*/
+		std::pair<bool, Real> intersects(const Plane& p) const
+		{
+			return Math::intersects(*this, p);
+		}
+        /** Tests whether this ray intersects the given plane bounded volume. 
+        @return A pair structure where the first element indicates whether
+        an intersection occurs, and if true, the second element will
+        indicate the distance along the ray at which it intersects. 
+        This can be converted to a point in space by calling getPoint().
+        */
+        std::pair<bool, Real> intersects(const PlaneBoundedVolume& p) const
+        {
+            return Math::intersects(*this, p.planes, p.outside == Plane::POSITIVE_SIDE);
+        }
+		/** Tests whether this ray intersects the given sphere. 
+		@return A pair structure where the first element indicates whether
+			an intersection occurs, and if true, the second element will
+			indicate the distance along the ray at which it intersects. 
+			This can be converted to a point in space by calling getPoint().
+		*/
+		std::pair<bool, Real> intersects(const Sphere& s) const
+		{
+			return Math::intersects(*this, s);
+		}
+		/** Tests whether this ray intersects the given box. 
+		@return A pair structure where the first element indicates whether
+			an intersection occurs, and if true, the second element will
+			indicate the distance along the ray at which it intersects. 
+			This can be converted to a point in space by calling getPoint().
+		*/
+		std::pair<bool, Real> intersects(const AxisAlignedBox& box) const
+		{
+			return Math::intersects(*this, box);
+		}
+
+    };
+	/** @} */
+	/** @} */
+
+}
+#endif

data/deps/include/OGRE/OgreRectangle.h

@@ -0,0 +1,77 @@
+/*
+-----------------------------------------------------------------------------
+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 _Rectangle_H__
+#define _Rectangle_H__
+
+#include "OgrePrerequisites.h"
+
+namespace Ogre {
+
+	/** \addtogroup Core
+	*  @{
+	*/
+	/** \addtogroup General
+	*  @{
+	*/
+
+    struct _OgreExport Rectangle
+    {
+        Real left;
+        Real top;
+        Real right;
+        Real bottom;
+
+        inline bool inside(Real x, Real y) const { return x >= left && x <= right && y >= top && y <= bottom; }
+    };
+
+    /** Geometric intersection of two rectanglar regions.
+     *
+     * @remarks Calculates the geometric intersection of two rectangular
+     * regions.  Rectangle coordinates must be ([0-N], [0-N]), such that
+     * (0,0) is in the upper left hand corner.
+     *
+     * If the two input rectangles do not intersect, then the result will be
+     * a degenerate rectangle, i.e. left >= right or top >= bottom, or both.
+     */
+    inline Rectangle intersect(const Rectangle& lhs, const Rectangle& rhs)
+    {
+        Rectangle r;
+
+        r.left   = lhs.left   > rhs.left   ? lhs.left   : rhs.left;
+        r.top    = lhs.top    > rhs.top    ? lhs.top    : rhs.top;
+        r.right  = lhs.right  < rhs.right  ? lhs.right  : rhs.right;
+        r.bottom = lhs.bottom < rhs.bottom ? lhs.bottom : rhs.bottom;
+
+        return r;
+    }
+	/** @} */
+	/** @} */
+
+}
+
+#endif // _Rectangle_H__

data/deps/include/OGRE/OgreRectangle2D.h

@@ -0,0 +1,101 @@
+/*
+-----------------------------------------------------------------------------
+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 _Rectangle2D_H__
+#define _Rectangle2D_H__
+
+#include "OgrePrerequisites.h"
+
+#include "OgreSimpleRenderable.h"
+
+namespace Ogre {
+
+	/** \addtogroup Core
+	*  @{
+	*/
+	/** \addtogroup Scene
+	*  @{
+	*/
+	/** Allows the rendering of a simple 2D rectangle
+    This class renders a simple 2D rectangle; this rectangle has no depth and
+    therefore is best used with specific render queue and depth settings,
+    like RENDER_QUEUE_BACKGROUND and 'depth_write off' for backdrops, and 
+    RENDER_QUEUE_OVERLAY and 'depth_check off' for fullscreen quads.
+    */
+    class _OgreExport Rectangle2D : public SimpleRenderable
+    {
+    protected:
+        /** Override this method to prevent parent transforms (rotation,translation,scale)
+        */
+        void getWorldTransforms( Matrix4* xform ) const;
+
+        void _initRectangle2D(bool includeTextureCoords, Ogre::HardwareBuffer::Usage vBufUsage);
+
+    public:
+
+        Rectangle2D(bool includeTextureCoordinates = false, HardwareBuffer::Usage vBufUsage = HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY);
+        Rectangle2D(const String& name, bool includeTextureCoordinates = false, HardwareBuffer::Usage vBufUsage = HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY);
+        ~Rectangle2D();
+
+        /** Sets the corners of the rectangle, in relative coordinates.
+        @param
+        left Left position in screen relative coordinates, -1 = left edge, 1.0 = right edge
+        @param top Top position in screen relative coordinates, 1 = top edge, -1 = bottom edge
+        @param right Right position in screen relative coordinates
+        @param bottom Bottom position in screen relative coordinates
+		@param updateAABB Tells if you want to recalculate the AABB according to 
+		the new corners. If false, the axis aligned bounding box will remain identical.
+        */
+        void setCorners(Real left, Real top, Real right, Real bottom, bool updateAABB = true);
+
+		/** Sets the normals of the rectangle
+		*/
+		void setNormals(const Ogre::Vector3 &topLeft, const Ogre::Vector3 &bottomLeft, const Ogre::Vector3 &topRight, const Ogre::Vector3 &bottomRight);
+
+		/** Sets the UVs of the rectangle
+		@remarks
+		Doesn't do anything if the rectangle wasn't built with texture coordinates
+		*/
+		void setUVs( const Ogre::Vector2 &topLeft, const Ogre::Vector2 &bottomLeft,
+					 const Ogre::Vector2 &topRight, const Ogre::Vector2 &bottomRight);
+
+		void setDefaultUVs();
+
+        Real getSquaredViewDepth(const Camera* cam) const
+        { (void)cam; return 0; }
+
+        Real getBoundingRadius(void) const { return 0; }
+
+    };
+	/** @} */
+	/** @} */
+
+}// namespace
+
+#endif
+
+

data/deps/include/OGRE/OgreRenderObjectListener.h

@@ -0,0 +1,64 @@
+/*
+-----------------------------------------------------------------------------
+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 __RenderObjectListener_H__
+#define __RenderObjectListener_H__
+
+#include "OgrePrerequisites.h"
+#include "OgreRenderable.h"
+#include "OgrePass.h"
+
+namespace Ogre {
+
+	class Pass;
+	class Renderable;
+
+    /** Abstract interface which classes must implement if they wish to receive
+        events from the scene manager when single object is about to be rendered. 
+    */
+	class _OgreExport RenderObjectListener
+	{
+	public:
+		virtual ~RenderObjectListener() {}
+		/** Event raised when render single object started.
+		@remarks
+		This method is called by the SceneManager.
+		@param pass The renderable that is going to be rendered.
+		@param pass The pass which was set.
+		@param source The auto parameter source used within this render call.
+		@pLightList The light list in use.
+		@suppressRenderStateChanges True if render state changes should be suppressed.
+		*/
+		virtual void notifyRenderSingleObject(Renderable* rend, const Pass* pass, const AutoParamDataSource* source, 
+			const LightList* pLightList, bool suppressRenderStateChanges) = 0;
+	};
+
+
+}
+
+#endif
+

data/deps/include/OGRE/OgreRenderOperation.h

@@ -0,0 +1,100 @@
+/*
+-----------------------------------------------------------------------------
+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 _RenderOperation_H__
+#define _RenderOperation_H__
+
+#include "OgrePrerequisites.h"
+#include "OgreVertexIndexData.h"
+
+namespace Ogre {
+
+
+	/** \addtogroup Core
+	*  @{
+	*/
+	/** \addtogroup RenderSystem
+	*  @{
+	*/
+	/** 'New' rendering operation using vertex buffers. */
+	class _OgrePrivate RenderOperation {
+	public:
+		/// The rendering operation type to perform
+		enum OperationType {
+			/// A list of points, 1 vertex per point
+            OT_POINT_LIST = 1,
+			/// A list of lines, 2 vertices per line
+            OT_LINE_LIST = 2,
+			/// A strip of connected lines, 1 vertex per line plus 1 start vertex
+            OT_LINE_STRIP = 3,
+			/// A list of triangles, 3 vertices per triangle
+            OT_TRIANGLE_LIST = 4,
+			/// A strip of triangles, 3 vertices for the first triangle, and 1 per triangle after that 
+            OT_TRIANGLE_STRIP = 5,
+			/// A fan of triangles, 3 vertices for the first triangle, and 1 per triangle after that
+            OT_TRIANGLE_FAN = 6
+        };
+
+		/// Vertex source data
+		VertexData *vertexData;
+
+		/// The type of operation to perform
+		OperationType operationType;
+
+		/** Specifies whether to use indexes to determine the vertices to use as input. If false, the vertices are
+		 simply read in sequence to define the primitives. If true, indexes are used instead to identify vertices
+		 anywhere in the buffer, and allowing vertices to be used more than once.
+	   	 If true, then the indexBuffer, indexStart and numIndexes properties must be valid. */
+		bool useIndexes;
+
+		/// Index data - only valid if useIndexes is true
+		IndexData *indexData;
+		/// Debug pointer back to renderable which created this
+		const Renderable* srcRenderable;
+
+		/// The number of instances for the render operation - this option is supported 
+		/// in only a part of the render systems.
+		size_t numberOfInstances;
+
+        /** A flag to indicate that it is possible for this operation to use a global
+            vertex instance buffer if available.*/
+        bool useGlobalInstancingVertexBufferIsAvailable;
+
+        RenderOperation() :
+            vertexData(0), operationType(OT_TRIANGLE_LIST), useIndexes(true),
+                indexData(0), srcRenderable(0), numberOfInstances(1),
+                useGlobalInstancingVertexBufferIsAvailable(true) {}
+
+
+	};
+	/** @} */
+	/** @} */
+}
+
+
+
+#endif