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

data/deps/include/OGRE/OgrePlatformInformation.h

@@ -1,202 +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 __PlatformInformation_H__
-#define __PlatformInformation_H__
-
-#include "OgrePrerequisites.h"
-
-namespace Ogre {
-//
-// TODO: Puts following macros into OgrePlatform.h?
-//
-
-/* Initial CPU stuff to set.
-*/
-#define OGRE_CPU_UNKNOWN    0
-#define OGRE_CPU_X86        1
-#define OGRE_CPU_PPC        2
-#define OGRE_CPU_ARM        3
-
-/* Find CPU type
-*/
-#if (defined(_MSC_VER) && (defined(_M_IX86) || defined(_M_X64))) || \
-    (defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__)))
-#   define OGRE_CPU OGRE_CPU_X86
-
-#elif OGRE_PLATFORM == OGRE_PLATFORM_APPLE && defined(__BIG_ENDIAN__)
-#   define OGRE_CPU OGRE_CPU_PPC
-#elif OGRE_PLATFORM == OGRE_PLATFORM_APPLE
-#	define OGRE_CPU OGRE_CPU_X86
-#elif OGRE_PLATFORM == OGRE_PLATFORM_APPLE_IOS && (defined(__i386__) || defined(__x86_64__))
-#	define OGRE_CPU OGRE_CPU_X86
-#elif defined(__arm__)
-#	define OGRE_CPU OGRE_CPU_ARM
-#else
-#   define OGRE_CPU OGRE_CPU_UNKNOWN
-#endif
-
-/* Find how to declare aligned variable.
-*/
-#if OGRE_COMPILER == OGRE_COMPILER_MSVC
-#   define OGRE_ALIGNED_DECL(type, var, alignment)  __declspec(align(alignment)) type var
-
-#elif (OGRE_COMPILER == OGRE_COMPILER_GNUC) || (OGRE_COMPILER == OGRE_COMPILER_CLANG)
-#   define OGRE_ALIGNED_DECL(type, var, alignment)  type var __attribute__((__aligned__(alignment)))
-
-#else
-#   define OGRE_ALIGNED_DECL(type, var, alignment)  type var
-#endif
-
-/** Find perfect alignment (should supports SIMD alignment if SIMD available)
-*/
-#if OGRE_CPU == OGRE_CPU_X86
-#   define OGRE_SIMD_ALIGNMENT  16
-
-#else
-#   define OGRE_SIMD_ALIGNMENT  16
-#endif
-
-/* Declare variable aligned to SIMD alignment.
-*/
-#define OGRE_SIMD_ALIGNED_DECL(type, var)   OGRE_ALIGNED_DECL(type, var, OGRE_SIMD_ALIGNMENT)
-
-/* Define whether or not Ogre compiled with SSE supports.
-*/
-#if   OGRE_DOUBLE_PRECISION == 0 && OGRE_CPU == OGRE_CPU_X86 && OGRE_COMPILER == OGRE_COMPILER_MSVC && \
-    OGRE_PLATFORM != OGRE_PLATFORM_NACL
-#   define __OGRE_HAVE_SSE  1
-#elif OGRE_DOUBLE_PRECISION == 0 && OGRE_CPU == OGRE_CPU_X86 && (OGRE_COMPILER == OGRE_COMPILER_GNUC || OGRE_COMPILER == OGRE_COMPILER_CLANG) && \
-      OGRE_PLATFORM != OGRE_PLATFORM_APPLE_IOS && OGRE_PLATFORM != OGRE_PLATFORM_NACL
-#   define __OGRE_HAVE_SSE  1
-#endif
-
-/* Define whether or not Ogre compiled with VFP supports.
- */
-#if OGRE_DOUBLE_PRECISION == 0 && OGRE_CPU == OGRE_CPU_ARM && (OGRE_COMPILER == OGRE_COMPILER_GNUC || OGRE_COMPILER == OGRE_COMPILER_CLANG) && defined(__ARM_ARCH_6K__) && defined(__VFP_FP__)
-#   define __OGRE_HAVE_VFP  1
-#endif
-
-/* Define whether or not Ogre compiled with NEON supports.
- */
-#if OGRE_DOUBLE_PRECISION == 0 && OGRE_CPU == OGRE_CPU_ARM && (OGRE_COMPILER == OGRE_COMPILER_GNUC || OGRE_COMPILER == OGRE_COMPILER_CLANG) && defined(__ARM_ARCH_7A__) && defined(__ARM_NEON__)
-#   define __OGRE_HAVE_NEON  1
-#endif
-
-#ifndef __OGRE_HAVE_SSE
-#   define __OGRE_HAVE_SSE  0
-#endif
-
-#ifndef __OGRE_HAVE_VFP
-#   define __OGRE_HAVE_VFP  0
-#endif
-
-#ifndef __OGRE_HAVE_NEON
-#   define __OGRE_HAVE_NEON  0
-#endif
-    
-	/** \addtogroup Core
-	*  @{
-	*/
-	/** \addtogroup General
-	*  @{
-	*/
-
-
-    /** Class which provides the run-time platform information Ogre runs on.
-        @remarks
-            Ogre is designed to be platform-independent, but some platform
-            and run-time environment specific optimised functions are built-in
-            to maximise performance, and those special optimised routines are
-            need to determine run-time environment for select variant executing
-            path.
-        @par
-            This class manages that provides a couple of functions to determine
-            platform information of the run-time environment.
-        @note
-            This class is supposed to use by advanced user only.
-    */
-    class _OgreExport PlatformInformation
-    {
-    public:
-
-        /// Enum describing the different CPU features we want to check for, platform-dependent
-        enum CpuFeatures
-        {
-#if OGRE_CPU == OGRE_CPU_X86
-            CPU_FEATURE_SSE         = 1 << 0,
-            CPU_FEATURE_SSE2        = 1 << 1,
-            CPU_FEATURE_SSE3        = 1 << 2,
-            CPU_FEATURE_MMX         = 1 << 3,
-            CPU_FEATURE_MMXEXT      = 1 << 4,
-            CPU_FEATURE_3DNOW       = 1 << 5,
-            CPU_FEATURE_3DNOWEXT    = 1 << 6,
-            CPU_FEATURE_CMOV        = 1 << 7,
-            CPU_FEATURE_TSC         = 1 << 8,
-            CPU_FEATURE_FPU         = 1 << 9,
-            CPU_FEATURE_PRO         = 1 << 10,
-            CPU_FEATURE_HTT         = 1 << 11,
-#elif OGRE_CPU == OGRE_CPU_ARM
-            CPU_FEATURE_VFP         = 1 << 12,
-            CPU_FEATURE_NEON        = 1 << 13,
-#endif
-
-            CPU_FEATURE_NONE        = 0
-        };
-
-        /** Gets a string of the CPU identifier.
-        @note
-            Actual detecting are performs in the first time call to this function,
-            and then all future calls with return internal cached value.
-        */
-        static const String& getCpuIdentifier(void);
-
-        /** Gets a or-masked of enum CpuFeatures that are supported by the CPU.
-        @note
-            Actual detecting are performs in the first time call to this function,
-            and then all future calls with return internal cached value.
-        */
-        static uint getCpuFeatures(void);
-
-		/** Gets whether a specific feature is supported by the CPU.
-		@note
-			Actual detecting are performs in the first time call to this function,
-			and then all future calls with return internal cached value.
-		*/
-		static bool hasCpuFeature(CpuFeatures feature);
-
-
-		/** Write the CPU information to the passed in Log */
-		static void log(Log* pLog);
-
-    };
-	/** @} */
-	/** @} */
-
-}
-
-#endif  // __PlatformInformation_H__

data/deps/include/OGRE/OgrePlugin.h

@@ -1,139 +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 __OGREPLUGIN_H__
-#define __OGREPLUGIN_H__
-
-#include "OgrePrerequisites.h"
-
-namespace Ogre
-{
-	/** \addtogroup Core
-	*  @{
-	*/
-	/** \addtogroup General
-	*  @{
-	*/
-	/** Class defining a generic OGRE plugin.
-	@remarks
-		OGRE is very plugin-oriented and you can customise much of its behaviour
-		by registering new plugins, dynamically if you are using dynamic linking.
-		This class abstracts the generic interface that all plugins must support.
-		Within the implementations of this interface, the plugin must call other
-		OGRE classes in order to register the detailed customisations it is
-		providing, e.g. registering a new SceneManagerFactory, a new
-		MovableObjectFactory, or a new RenderSystem.
-	@par
-		Plugins can be linked statically or dynamically. If they are linked
-		dynamically (ie the plugin is in a DLL or Shared Object file), then you
-		load the plugin by calling the Root::loadPlugin method (or some other
-		mechanism which leads to that call, e.g. plugins.cfg), passing the name of
-		the DLL. OGRE will then call a global init function on that DLL, and it
-		will be expected to register one or more Plugin implementations using
-		Root::installPlugin. The procedure is very similar if you use a static
-		linked plugin, except that you simply instantiate the Plugin implementation
-		yourself and pass it to Root::installPlugin.
-	@note
-		Lifecycle of a Plugin instance is very important. The Plugin instance must
-		remain valid until the Plugin is uninstalled. Here are the things you
-		must bear in  mind:
-		<ul><li>If your plugin is in a DLL:
-		<ul><li>Create the Plugin instance and call Root::installPlugin in dllStartPlugin</li>
-		<li>Call Root::uninstallPlugin, then delete it in dllStopPlugin</li></ul>
-		<li>If your plugin is statically linked in your app:
-		<ul><li>Create the Plugin anytime you like</li>
-		<li>Call Root::installPlugin any time whilst Root is valid</li>
-		<li>Call Root::uninstallPlugin if you like so long as Root is valid. However,
-			it will be done for you when Root is destroyed, so the Plugin instance must
-			still be valid at that point if you haven't manually uninstalled it.</li></ul>
-		</ul>
-		The install and uninstall methods will be called when the plugin is
-		installed or uninstalled. The initialise and shutdown will be called when
-		there is a system initialisation or shutdown, e.g. when Root::initialise 
-		or Root::shutdown are called.
-	*/
-	class _OgreExport Plugin : public PluginAlloc
-	{
-	public:
-		Plugin() {}
-		virtual ~Plugin() {}
-
-		/** Get the name of the plugin. 
-		@remarks An implementation must be supplied for this method to uniquely
-			identify the plugin.
-		*/
-		virtual const String& getName() const = 0;
-
-		/** Perform the plugin initial installation sequence. 
-		@remarks An implementation must be supplied for this method. It must perform
-		the startup tasks necessary to install any rendersystem customisations 
-		or anything else that is not dependent on system initialisation, ie
-		only dependent on the core of Ogre. It must not perform any
-		operations that would create rendersystem-specific objects at this stage,
-		that should be done in initialise().
-		*/
-		virtual void install() = 0;
-
-		/** Perform any tasks the plugin needs to perform on full system
-			initialisation.
-		@remarks An implementation must be supplied for this method. It is called 
-			just after the system is fully initialised (either after Root::initialise
-			if a window is created then, or after the first window is created)
-			and therefore all rendersystem functionality is available at this
-			time. You can use this hook to create any resources which are 
-			dependent on a rendersystem or have rendersystem-specific implementations.
-		*/
-		virtual void initialise() = 0;
-
-		/** Perform any tasks the plugin needs to perform when the system is shut down.
-		@remarks An implementation must be supplied for this method.
-		This method is called just before key parts of the system are unloaded, 
-		such as rendersystems being shut down. You should use this hook to free up 
-		resources and decouple custom objects from the OGRE system, whilst all the
-		instances of other plugins (e.g. rendersystems) still exist.
-		*/
-		virtual void shutdown() = 0;
-
-		/** Perform the final plugin uninstallation sequence. 
-		@remarks An implementation must be supplied for this method. It must perform
-		the cleanup tasks which haven't already been performed in shutdown()
-		(e.g. final deletion of custom instances, if you kept them around incase
-		the system was reinitialised). At this stage you cannot be sure what other
-		plugins are still loaded or active. It must therefore not perform any
-		operations that would reference any rendersystem-specific objects - those
-		should have been sorted out in the 'shutdown' method.
-		*/
-		virtual void uninstall() = 0;
-	};
-	/** @} */
-	/** @} */
-
-}
-
-#endif
-
-

data/deps/include/OGRE/OgrePolygon.h

@@ -1,145 +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
-Copyright (c) 2006 Matthias Fink, netAllied GmbH <matthias.fink@web.de>								
-
-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 __Polygon_H__
-#define __Polygon_H__
-
-#include "OgrePrerequisites.h"
-#include "OgreVector3.h"
-
-
-namespace Ogre
-{
-
-
-	/** \addtogroup Core
-	*  @{
-	*/
-	/** \addtogroup Math
-	*  @{
-	*/
-	/** The class represents a polygon in 3D space.
-	@remarks
-		It is made up of 3 or more vertices in a single plane, listed in 
-		counter-clockwise order.
-	*/
-	class _OgreExport Polygon
-	{
-
-	public:
-		typedef vector<Vector3>::type				VertexList;
-
-		typedef multimap<Vector3, Vector3>::type		EdgeMap;
-		typedef std::pair< Vector3, Vector3>		Edge;
-
-	protected:
-		VertexList		mVertexList;
-		mutable Vector3	mNormal;
-		mutable bool	mIsNormalSet;
-		/** Updates the normal.
-		*/
-		void updateNormal(void) const;
-
-
-	public:
-		Polygon();
-		~Polygon();
-		Polygon( const Polygon& cpy );
-
-		/** Inserts a vertex at a specific position.
-		@note Vertices must be coplanar.
-		*/
-		void insertVertex(const Vector3& vdata, size_t vertexIndex);
-		/** Inserts a vertex at the end of the polygon.
-		@note Vertices must be coplanar.
-		*/
-		void insertVertex(const Vector3& vdata);
-
-		/** Returns a vertex.
-		*/
-		const Vector3& getVertex(size_t vertex) const;
-
-		/** Sets a specific vertex of a polygon.
-		@note Vertices must be coplanar.
-		*/
-		void setVertex(const Vector3& vdata, size_t vertexIndex);
-
-		/** Removes duplicate vertices from a polygon.
-		*/
-		void removeDuplicates(void);
-
-		/** Vertex count.
-		*/
-		size_t getVertexCount(void) const;
-
-		/** Returns the polygon normal.
-		*/
-		const Vector3& getNormal(void) const;
-
-		/** Deletes a specific vertex.
-		*/
-		void deleteVertex(size_t vertex);
-
-		/** Determines if a point is inside the polygon.
-		@remarks
-			A point is inside a polygon if it is both on the polygon's plane, 
-			and within the polygon's bounds. Polygons are assumed to be convex
-			and planar.
-		*/
-		bool isPointInside(const Vector3& point) const;
-
-		/** Stores the edges of the polygon in ccw order.
-			The vertices are copied so the user has to take the 
-			deletion into account.
-		*/
-		void storeEdges(EdgeMap *edgeMap) const;
-
-		/** Resets the object.
-		*/
-		void reset(void);
-
-		/** Determines if the current object is equal to the compared one.
-		*/
-		bool operator == (const Polygon& rhs) const;
-
-		/** Determines if the current object is not equal to the compared one.
-		*/
-		bool operator != (const Polygon& rhs) const
-		{ return !( *this == rhs ); }
-
-		/** Prints out the polygon data.
-		*/
-		_OgreExport friend std::ostream& operator<< ( std::ostream& strm, const Polygon& poly );
-
-	};
-	/** @} */
-	/** @} */
-
-}
-
-#endif