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

data/deps/include/OGRE/OgreNumerics.h

@@ -1,66 +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 __NumericSolvers_H__
-#define __NumericSolvers_H__
-
-#include "OgrePrerequisites.h"
-
-
-namespace Ogre {
-
-	/** \addtogroup Core
-	*  @{
-	*/
-	/** \addtogroup Math
-	*  @{
-	*/
-	/** Real type for numeric solvers */
-	typedef double PreciseReal;
-
-
-    /** Provides numeric solvers for Ogre
-        @remarks
-            Handles linear algebra numerics.
-    */
-	class _OgreExport NumericSolver
-	{
-	public:
-		/** Solves a full rank NxN linear system of equations 
-		    @remarks
-			   This implements a naive Gaussian elimination algorithm.
-			   The algorithm is destructive, so there are side effects in coeff and col.
-	    */
-		static bool solveNxNLinearSysDestr(int n, PreciseReal **coeff, PreciseReal *col);
-	};
-	/** @} */
-	/** @} */
-
-}
-
-#endif

data/deps/include/OGRE/OgreOptimisedUtil.h

@@ -1,232 +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 __OptimisedUtil_H__
-#define __OptimisedUtil_H__
-
-#include "OgrePrerequisites.h"
-#include "OgreEdgeListBuilder.h"
-#include <cstddef>
-
-namespace Ogre {
-
-	/** \addtogroup Core
-	*  @{
-	*/
-	/** \addtogroup Math
-	*  @{
-	*/
-	/** Utility class for provides optimised functions.
-    @note
-        This class are supposed used by internal engine only.
-    */
-    class _OgreExport OptimisedUtil
-    {
-    private:
-        /// Privated copy constructor, to prevent misuse
-        OptimisedUtil(const OptimisedUtil& rhs); /* do nothing, should not use */
-        /// Privated operator=, to prevent misuse
-        OptimisedUtil& operator=(const OptimisedUtil& rhs); /* do not use */
-
-    protected:
-        /// Store a pointer to the implementation
-        static OptimisedUtil* msImplementation;
-
-        /// Detect best implementation based on run-time environment
-        static OptimisedUtil* _detectImplementation(void);
-
-    public:
-        // Default constructor
-        OptimisedUtil(void) {}
-        // Destructor
-        virtual ~OptimisedUtil() {}
-
-        /** Gets the implementation of this class.
-        @note
-            Don't cache the pointer returned by this function, it'll change due
-            run-time environment detection to pick up the best implementation.
-        */
-        static OptimisedUtil* getImplementation(void) { return msImplementation; }
-
-        /** Performs software vertex skinning.
-        @param srcPosPtr Pointer to source position buffer.
-        @param destPosPtr Pointer to destination position buffer.
-        @param srcNormPtr Pointer to source normal buffer, if NULL,
-            means blend position only.
-        @param destNormPtr Pointer to destination normal buffer, it's
-            ignored if srcNormPtr is NULL.
-        @param blendWeightPtr Pointer to blend weight buffer.
-        @param blendIndexPtr Pointer to blend index buffer.
-        @param blendMatrices An array of pointer of blend matrix, the matrix
-            must be aligned to SIMD alignment, but not necessary for the array
-            itself.
-        @param srcPosStride The stride of source position in bytes.
-        @param destPosStride The stride of destination position in bytes.
-        @param srcNormStride The stride of source normal in bytes,
-            it's ignored if srcNormPtr is NULL.
-        @param destNormStride The stride of destination normal in bytes,
-            it's ignored if srcNormPtr is NULL.
-        @param blendWeightStride The stride of blend weight buffer in bytes.
-        @param blendIndexStride The stride of blend index buffer in bytes.
-        @param numWeightsPerVertex Number of blend weights per-vertex, as well
-            as for blend indices.
-        @param numVertices Number of vertices to blend.
-        */
-        virtual void softwareVertexSkinning(
-            const float *srcPosPtr, float *destPosPtr,
-            const float *srcNormPtr, float *destNormPtr,
-            const float *blendWeightPtr, const unsigned char* blendIndexPtr,
-            const Matrix4* const* blendMatrices,
-            size_t srcPosStride, size_t destPosStride,
-            size_t srcNormStride, size_t destNormStride,
-            size_t blendWeightStride, size_t blendIndexStride,
-            size_t numWeightsPerVertex,
-            size_t numVertices) = 0;
-
-        /** Performs a software vertex morph, of the kind used for
-            morph animation although it can be used for other purposes. 
-        @remarks
-            This function will linearly interpolate positions between two
-            source buffers, into a third buffer.
-        @param t Parametric distance between the start and end positions
-        @param srcPos1 Pointer to buffer for the start positions
-        @param srcPos2 Pointer to buffer for the end positions
-        @param dstPos Pointer to buffer for the destination positions
-		@param pos1VSize, pos2VSize, dstVSize Vertex sizes in bytes of each of the 3 buffers referenced
-        @param numVertices Number of vertices to morph, which agree with
-            the number in start, end and destination buffer. Bear in mind
-            three floating-point values per vertex
-        */
-        virtual void softwareVertexMorph(
-            Real t,
-            const float *srcPos1, const float *srcPos2,
-            float *dstPos,
-			size_t pos1VSize, size_t pos2VSize, size_t dstVSize, 
-            size_t numVertices,
-			bool morphNormals) = 0;
-
-        /** Concatenate an affine matrix to an array of affine matrices.
-        @note
-            An affine matrix is a 4x4 matrix with row 3 equal to (0, 0, 0, 1),
-            e.g. no projective coefficients.
-        @param baseMatrix The matrix used as first operand.
-        @param srcMatrices An array of matrix used as second operand.
-        @param dstMatrices An array of matrix to store matrix concatenate results.
-        @param numMatrices Number of matrices in the array.
-        */
-        virtual void concatenateAffineMatrices(
-            const Matrix4& baseMatrix,
-            const Matrix4* srcMatrices,
-            Matrix4* dstMatrices,
-            size_t numMatrices) = 0;
-
-        /** Calculate the face normals for the triangles based on position
-            information.
-        @param positions Pointer to position information, which packed in
-            (x, y, z) format, indexing by vertex index in the triangle. No
-            alignment requests.
-        @param triangles The triangles need to calculate face normal, the vertex
-            positions is indexed by vertex index to position information.
-        @param faceNormals The array of Vector4 used to store triangles face normal,
-            Must be aligned to SIMD alignment.
-        @param numTriangles Number of triangles to calculate face normal.
-        */
-        virtual void calculateFaceNormals(
-            const float *positions,
-            const EdgeData::Triangle *triangles,
-            Vector4 *faceNormals,
-            size_t numTriangles) = 0;
-
-        /** Calculate the light facing state of the triangle's face normals
-        @remarks
-            This is normally the first stage of calculating a silhouette, i.e.
-            establishing which tris are facing the light and which are facing
-            away.
-        @param lightPos 4D position of the light in object space, note that
-            for directional lights (which have no position), the w component
-            is 0 and the x/y/z position are the direction.
-        @param faceNormals An array of face normals for the triangles, the face
-            normal are unit vector orthogonal to the triangles, plus distance
-            from origin. This array must be aligned to SIMD alignment.
-        @param lightFacings An array of flags for store light facing state
-            results, the result flag is true if corresponding face normal facing
-            the light, false otherwise. This array no alignment requires.
-        @param numFaces Number of face normals to calculate.
-        */
-        virtual void calculateLightFacing(
-            const Vector4& lightPos,
-            const Vector4* faceNormals,
-            char* lightFacings,
-            size_t numFaces) = 0;
-
-        /** Extruding vertices by a fixed distance based on light position.
-        @param lightPos 4D light position, when w=0.0f this represents a
-            directional light, otherwise, w must be equal to 1.0f, which
-            represents a point light.
-        @param extrudeDist The distance to extrude.
-        @param srcPositions Pointer to source vertex's position buffer, which
-            the position is a 3D vector packed in xyz format. No SIMD alignment
-            requirement but loss performance for unaligned data.
-        @param destPositions Pointer to destination vertex's position buffer,
-            which the position is a 3D vector packed in xyz format. No SIMD
-            alignment requirement but loss performance for unaligned data.
-        @param numVertices Number of vertices need to extruding, which agree
-            with source and destination buffers.
-        */
-        virtual void extrudeVertices(
-            const Vector4& lightPos,
-            Real extrudeDist,
-            const float* srcPositions,
-            float* destPositions,
-            size_t numVertices) = 0;
-    };
-
-    /** Returns raw offseted of the given pointer.
-    @note
-        The offset are in bytes, no matter what type of the pointer.
-    */
-    template <class T>
-    static FORCEINLINE T* rawOffsetPointer(T* ptr, ptrdiff_t offset)
-    {
-        return (T*)((char*)(ptr) + offset);
-    }
-
-    /** Advance the pointer with raw offset.
-    @note
-        The offset are in bytes, no matter what type of the pointer.
-    */
-    template <class T>
-    static FORCEINLINE void advanceRawPointer(T*& ptr, ptrdiff_t offset)
-    {
-        ptr = rawOffsetPointer(ptr, offset);
-    }
-	/** @} */
-	/** @} */
-
-}
-
-#endif  // __OptimisedUtil_H__

data/deps/include/OGRE/OgreOverlay.h

@@ -1,280 +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 __Overlay_H__
-#define __Overlay_H__
-
-#include "OgrePrerequisites.h"
-#include "OgreSceneNode.h"
-#include "OgreIteratorWrappers.h"
-#include "OgreMatrix4.h"
-
-namespace Ogre {
-
-
-	/** \addtogroup Core
-	*  @{
-	*/
-	/** \addtogroup Overlays
-	*  @{
-	*/
-	/** Represents a layer which is rendered on top of the 'normal' scene contents.
-    @remarks
-        An overlay is a container for visual components (2D and 3D) which will be 
-        rendered after the main scene in order to composite heads-up-displays, menus
-        or other layers on top of the contents of the scene.
-    @par
-        An overlay always takes up the entire size of the viewport, although the 
-        components attached to it do not have to. An overlay has no visual element
-        in itself, it it merely a container for visual elements.
-    @par
-        Overlays are created by calling OverlayManager::create, or by defining them
-        in special text scripts (.overlay files). As many overlays
-        as you like can be defined; after creation an overlay is hidden i.e. not
-        visible until you specifically enable it by calling 'show'. This allows you to have multiple
-        overlays predefined (menus etc) which you make visible only when you want.
-        It is possible to have multiple overlays enabled at once; in this case the
-        relative 'zorder' parameter of the overlays determine which one is displayed
-        on top.
-    @par
-        By default overlays are rendered into all viewports. This is fine when you only
-        have fullscreen viewports, but if you have picture-in-picture views, you probably
-        don't want the overlay displayed in the smaller viewports. You turn this off for 
-        a specific viewport by calling the Viewport::setDisplayOverlays method.
-    */
-	class _OgreExport Overlay : public OverlayAlloc
-    {
-
-    public:
-              typedef list<OverlayContainer*>::type OverlayContainerList;
-    protected:
-        String mName;
-        /// Internal root node, used as parent for 3D objects
-        SceneNode* mRootNode;
-        // 2D elements
-        // OverlayContainers, linked list for easy sorting by zorder later
-        // Not a map because sort can be saved since changes infrequent (unlike render queue)
-        OverlayContainerList m2DElements;
-
-        // Degrees of rotation around center
-        Radian mRotate;
-        // Scroll values, offsets
-        Real mScrollX, mScrollY;
-        // Scale values
-        Real mScaleX, mScaleY;
-
-        mutable Matrix4 mTransform;
-        mutable bool mTransformOutOfDate;
-        bool mTransformUpdated;
-        ulong mZOrder;
-        bool mVisible;
-		bool mInitialised;
-		String mOrigin;
-        /** Internal lazy update method. */
-        void updateTransform(void) const;
-		/** Internal method for initialising an overlay */
-		void initialise(void);
-		/** Internal method for updating container elements' Z-ordering */
-		void assignZOrders(void);
-
-    public:
-        /// Constructor: do not call direct, use OverlayManager::create
-        Overlay(const String& name);
-        virtual ~Overlay();
-
-
-	    OverlayContainer* getChild(const String& name);
-
-        /** Gets the name of this overlay. */
-        const String& getName(void) const;
-        /** Alters the ZOrder of this overlay. 
-        @remarks
-            Values between 0 and 650 are valid here.
-        */
-        void setZOrder(ushort zorder);
-        /** Gets the ZOrder of this overlay. */
-        ushort getZOrder(void) const;
-
-        /** Gets whether the overlay is displayed or not. */
-        bool isVisible(void) const;
-
-		/** Gets whether the overlay is initialised or not. */
-		bool isInitialised(void) const { return mInitialised; }
-
-		/** Shows the overlay if it was hidden. */
-        void show(void);
-
-        /** Hides the overlay if it was visible. */
-        void hide(void);
-
-        /** Adds a 2D 'container' to the overlay.
-        @remarks
-            Containers are created and managed using the OverlayManager. A container
-            could be as simple as a square panel, or something more complex like
-            a grid or tree view. Containers group collections of other elements,
-            giving them a relative coordinate space and a common z-order.
-            If you want to attach a GUI widget to an overlay, you have to do it via
-            a container.
-        @param cont Pointer to a container to add, created using OverlayManager.
-        */
-        void add2D(OverlayContainer* cont);
-
-
-        /** Removes a 2D container from the overlay. 
-        @remarks
-            NOT FAST. Consider OverlayElement::hide.
-        */
-        void remove2D(OverlayContainer* cont);
-
-        /** Adds a node capable of holding 3D objects to the overlay.
-        @remarks    
-            Although overlays are traditionally associated with 2D elements, there 
-            are reasons why you might want to attach 3D elements to the overlay too.
-            For example, if you wanted to have a 3D cockpit, which was overlaid with a
-            HUD, then you would create 2 overlays, one with a 3D object attached for the
-            cockpit, and one with the HUD elements attached (the zorder of the HUD 
-            overlay would be higher than the cockpit to ensure it was always on top).
-        @par    
-            A SceneNode can have any number of 3D objects attached to it. SceneNodes
-            are usually created using SceneManager::createSceneNode, but in this case
-			you should create a standard SceneNode instance <b>manually</b>; this is
-			because these scene nodes are not managed by the SceneManager and some custom
-			SceneManager plugins will rely on specialist behaviour the overlay does not
-			support. By attaching a SceneNode to an overlay, you indicate that:<OL>
-            <LI>You want the contents of this node to only appear when the overlay is active</LI>
-            <LI>You want the node to inherit a coordinate space relative to the camera,
-                rather than relative to the root scene node</LI>
-            <LI>You want these objects to be rendered after the contents of the main scene
-                to ensure they are rendered on top</LI>
-            </OL>
-            One major consideration when using 3D objects in overlays is the behaviour of 
-            the depth buffer. Overlays should use materials with depth checking off, to ensure
-            that their contents are always displayed on top of the main scene (to do 
-            otherwise would result in objects 'poking through' the overlay). The problem
-            with using 3D objects is that if they are concave, or self-overlap, then you
-            can get artefacts because of the lack of depth buffer checking. So you should 
-            ensure that any 3D objects you us in the overlay are convex, and don't overlap
-            each other. If they must overlap, split them up and put them in 2 overlays.
-			Alternatively, use a 2D element underneath them which will clear the depth buffer
-			values underneath ready for the 3D element to be rendered correctly.
-        */
-        void add3D(SceneNode* node);
-
-        /** Removes a 3D element from the overlay. */
-        void remove3D(SceneNode* node);
-
-        /** Clears the overlay of all attached items. */
-        void clear();
-
-        /** Sets the scrolling factor of this overlay.
-        @remarks
-            You can use this to set an offset to be used to scroll an 
-            overlay around the screen.
-        @param x Horizontal scroll value, where 0 = normal, -0.5 = scroll so that only
-            the right half the screen is visible etc
-        @param y Vertical scroll value, where 0 = normal, 0.5 = scroll down by half 
-            a screen etc.
-        */
-        void setScroll(Real x, Real y);
-
-        /** Gets the current X scroll value */
-        Real getScrollX(void) const;
-
-        /** Gets the current Y scroll value */
-        Real getScrollY(void) const;
-
-        /** Scrolls the overlay by the offsets provided.
-        @remarks
-            This method moves the overlay by the amounts provided. As with
-            other methods on this object, a full screen width / height is represented
-            by the value 1.0.
-        */
-        void scroll(Real xoff, Real yoff);
-
-        /** Sets the rotation applied to this overlay.*/
-        void setRotate(const Radian& angle);
-
-        /** Gets the rotation applied to this overlay, in degrees.*/
-        const Radian &getRotate(void) const { return mRotate; }
-
-        /** Adds the passed in angle to the rotation applied to this overlay. */
-        void rotate(const Radian& angle);
-
-        /** Sets the scaling factor of this overlay.
-        @remarks
-            You can use this to set an scale factor to be used to zoom an 
-            overlay.
-        @param x Horizontal scale value, where 1.0 = normal, 0.5 = half size etc
-        @param y Vertical scale value, where 1.0 = normal, 0.5 = half size etc
-        */
-        void setScale(Real x, Real y);
-
-        /** Gets the current X scale value */
-        Real getScaleX(void) const;
-
-        /** Gets the current Y scale value */
-        Real getScaleY(void) const;
-
-        /** Used to transform the overlay when scrolling, scaling etc. */
-        void _getWorldTransforms(Matrix4* xform) const;
-
-        /** Internal method to put the overlay contents onto the render queue. */
-        void _findVisibleObjects(Camera* cam, RenderQueue* queue);
-
-        /** This returns a OverlayElement at position x,y. */
-		virtual OverlayElement* findElementAt(Real x, Real y);
-
-        /** Returns an iterator over all 2D elements in this manager.
-        @remarks
-            VectorIterator is actually a too generic name, since it also works for lists.
-        */
-        typedef VectorIterator<OverlayContainerList> Overlay2DElementsIterator ;
-        Overlay2DElementsIterator get2DElementsIterator ()
-        {
-            return Overlay2DElementsIterator (m2DElements.begin(), m2DElements.end());
-        }
-		/** Get the origin of this overlay, e.g. a script file name.
-		@remarks
-			This property will only contain something if the creator of
-			this overlay chose to populate it. Script loaders are advised
-			to populate it.
-		*/
-		const String& getOrigin(void) const { return mOrigin; }
-		/// Notify this overlay of it's origin
-		void _notifyOrigin(const String& origin) { mOrigin = origin; }
-
-
-    };
-	/** @} */
-	/** @} */
-
-}
-
-
-#endif
-