Removed a lot of extra code from prerequisites

CamelotRenderer/CmApplication.cpp

@@ -32,7 +32,7 @@ namespace CamelotEngine
 		//renderSystem->setAmbientLight(1.0f, 1.0f, 1.0f);
 		renderSystem->setLightingEnabled(false);
 
-		mCamera = new Ogre::Camera("SimpleCam", nullptr);
+		mCamera = new Ogre::Camera("SimpleCam");
 		mCamera->setPosition(Ogre::Vector3(0,0,80));
 		mCamera->lookAt(Ogre::Vector3(0,0,-300));
 		mCamera->setNearClipDistance(5);

CamelotRenderer/OgreCamera.cpp

@@ -42,13 +42,11 @@ namespace Ogre {
 
     String Camera::msMovableType = "Camera";
     //-----------------------------------------------------------------------
-    Camera::Camera( const String& name, SceneManager* sm)
+    Camera::Camera( const String& name)
         : Frustum(name),
-		mSceneMgr(sm),
 		mOrientation(Quaternion::IDENTITY),
 		mPosition(Vector3::ZERO),
 		mSceneDetail(PM_SOLID),
-		mAutoTrackTarget(0),
 		mAutoTrackOffset(Vector3::ZERO),
 		mSceneLodFactor(1.0f),
 		mSceneLodFactorInv(1.0f),
@@ -87,13 +85,6 @@ namespace Ogre {
 			(*i)->cameraDestroyed(this);
 		}
     }
-    //-----------------------------------------------------------------------
-    SceneManager* Camera::getSceneManager(void) const
-    {
-        return mSceneMgr;
-    }
-
-
     //-----------------------------------------------------------------------
     void Camera::setPolygonMode(PolygonMode sd)
     {
@@ -541,30 +532,6 @@ namespace Ogre {
     {
         return msMovableType;
     }
-    //-----------------------------------------------------------------------
-    void Camera::setAutoTracking(bool enabled, SceneNode* target, 
-        const Vector3& offset)
-    {
-        if (enabled)
-        {
-            assert (target != 0 && "target cannot be a null pointer if tracking is enabled");
-            mAutoTrackTarget = target;
-            mAutoTrackOffset = offset;
-        }
-        else
-        {
-            mAutoTrackTarget = 0;
-        }
-    }
-    //-----------------------------------------------------------------------
-    void Camera::_autoTrack(void)
-    {
-        // NB assumes that all scene nodes have been updated
-        if (mAutoTrackTarget)
-        {
-            //lookAt(mAutoTrackTarget->_getDerivedPosition() + mAutoTrackOffset);
-        }
-    }
     //-----------------------------------------------------------------------
 	void Camera::setLodBias(Real factor)
 	{

CamelotRenderer/OgreCamera.h

@@ -105,9 +105,6 @@ namespace Ogre {
 
 		};
     protected:
-        /// Scene manager responsible for the scene
-        SceneManager *mSceneMgr;
-
         /// Camera orientation, quaternion style
         Quaternion mOrientation;
 
@@ -139,8 +136,6 @@ namespace Ogre {
         /// Shared class-level name for Movable type
         static String msMovableType;
 
-        /// SceneNode which this Camera will automatically track
-        SceneNode* mAutoTrackTarget;
         /// Tracking offset for fine tuning
         Vector3 mAutoTrackOffset;
 
@@ -198,7 +193,7 @@ namespace Ogre {
     public:
         /** Standard constructor.
         */
-        Camera( const String& name, SceneManager* sm);
+        Camera( const String& name);
 
         /** Standard destructor.
         */
@@ -209,10 +204,6 @@ namespace Ogre {
 		/// Remove a listener to this camera
 		virtual void removeListener(Listener* l);
 
-        /** Returns a pointer to the SceneManager this camera is rendering through.
-        */
-        SceneManager* getSceneManager(void) const;
-
         /** Sets the level of rendering detail required from this camera.
             @remarks
                 Each camera is set to render at full detail by default, that is
@@ -403,29 +394,6 @@ namespace Ogre {
         /** Overridden from MovableObject */
         const String& getMovableType(void) const;
 
-        /** Enables / disables automatic tracking of a SceneNode.
-        @remarks
-            If you enable auto-tracking, this Camera will automatically rotate to
-            look at the target SceneNode every frame, no matter how 
-            it or SceneNode move. This is handy if you want a Camera to be focused on a
-            single object or group of objects. Note that by default the Camera looks at the 
-            origin of the SceneNode, if you want to tweak this, e.g. if the object which is
-            attached to this target node is quite big and you want to point the camera at
-            a specific point on it, provide a vector in the 'offset' parameter and the 
-            camera's target point will be adjusted.
-        @param enabled If true, the Camera will track the SceneNode supplied as the next 
-            parameter (cannot be null). If false the camera will cease tracking and will
-            remain in it's current orientation.
-        @param target Pointer to the SceneNode which this Camera will track. Make sure you don't
-            delete this SceneNode before turning off tracking (e.g. SceneManager::clearScene will
-            delete it so be careful of this). Can be null if and only if the enabled param is false.
-        @param offset If supplied, the camera targets this point in local space of the target node
-            instead of the origin of the target node. Good for fine tuning the look at point.
-        */
-        void setAutoTracking(bool enabled, SceneNode* target = 0, 
-            const Vector3& offset = Vector3::ZERO);
-
-
 		/** Sets the level-of-detail factor for this Camera.
 		@remarks
 			This method can be used to influence the overall level of detail of the scenes 
@@ -487,11 +455,6 @@ namespace Ogre {
 		/** Internal method for OGRE to use for LOD calculations. */
 		Real _getLodBiasInverse(void) const;
 
-
-        /** Internal method used by OGRE to update auto-tracking cameras. */
-        void _autoTrack(void);
-
-
         /** Sets the viewing window inside of viewport.
         @remarks
         This method can be used to set a subset of the viewport as the rendering
@@ -511,10 +474,6 @@ namespace Ogre {
 
         /** Overridden from MovableObject */
         Real getBoundingRadius(void) const;
-		/** Get the auto tracking target for this camera, if any. */
-        SceneNode* getAutoTrackTarget(void) const { return mAutoTrackTarget; }
-		/** Get the auto tracking offset for this camera, if it is auto tracking. */
-		const Vector3& getAutoTrackOffset(void) const { return mAutoTrackOffset; }
 		
         /** Get the last viewport which was attached to this camera. 
         @note This is not guaranteed to be the only viewport which is

CamelotRenderer/OgreColourValue.cpp

@@ -371,7 +371,7 @@ namespace Ogre {
 
 		*brightness = vMax;
 
-		if (Math::RealEqual(delta, 0.0f, 1e-6))
+		if (Math::RealEqual(delta, 0.0f, 1e-6f))
 		{
 			// grey
 			*hue = 0;

CamelotRenderer/OgreD3D9HLSLProgram.cpp

@@ -121,6 +121,8 @@ namespace Ogre {
 		default:
 			assert(false); // Unsupported profile
 		}
+
+		return "";
 	}
 
     //-----------------------------------------------------------------------
@@ -535,6 +537,11 @@ namespace Ogre {
 		return mpMicroCode;
 	}
 
+	const String D3D9HLSLProgram::getTarget(void) const
+	{
+		return gpuProgramProfileToHLSLProfile(mProfile);
+	}
+
     //-----------------------------------------------------------------------
     D3D9HLSLProgram::D3D9HLSLProgram()
         : HighLevelGpuProgram()

CamelotRenderer/OgreD3D9HLSLProgram.h

@@ -158,7 +158,7 @@ namespace Ogre {
         /** Sets the shader target to compile down to, e.g. 'vs_1_1'. */
         void setTarget(const String& target);
         /** Gets the shader target to compile down to, e.g. 'vs_1_1'. */
-        const String& getTarget(void) const { return ""; }
+        const String getTarget(void) const;
         /** Sets the preprocessor defines use to compile the program. */
         void setPreprocessorDefines(const String& defines) { mPreprocessorDefines = defines; }
         /** Sets the preprocessor defines use to compile the program. */

CamelotRenderer/OgreD3D9RenderWindow.cpp

@@ -221,8 +221,8 @@ namespace Ogre
 				int screenh = monitorInfo.rcWork.bottom - monitorInfo.rcWork.top;
 
 				// clamp window dimensions to screen size
-				int outerw = (winWidth < screenw)? winWidth : screenw;
-				int outerh = (winHeight < screenh)? winHeight : screenh;
+				int outerw = (int(winWidth) < screenw)? int(winWidth) : screenw;
+				int outerh = (int(winHeight) < screenh)? int(winHeight) : screenh;
 
 				if (left == INT_MAX)
 					left = monitorInfo.rcWork.left + (screenw - outerw) / 2;
@@ -467,8 +467,8 @@ namespace Ogre
 			LONG screenh = monitorInfo.rcWork.bottom - monitorInfo.rcWork.top;
 
 
-			int left = screenw > winWidth ? ((screenw - winWidth) / 2) : 0;
-			int top = screenh > winHeight ? ((screenh - winHeight) / 2) : 0;
+			int left = screenw > int(winWidth) ? ((screenw - int(winWidth)) / 2) : 0;
+			int top = screenh > int(winHeight) ? ((screenh - int(winHeight)) / 2) : 0;
 			SetWindowPos(mHWnd, HWND_NOTOPMOST, left, top, winWidth, winHeight,
 				SWP_DRAWFRAME | SWP_FRAMECHANGED | SWP_NOACTIVATE);
 

CamelotRenderer/OgreFrustum.cpp

@@ -41,7 +41,7 @@ THE SOFTWARE.
 namespace Ogre {
 
     String Frustum::msMovableType = "Frustum";
-    const Real Frustum::INFINITE_FAR_PLANE_ADJUST = 0.00001;
+    const Real Frustum::INFINITE_FAR_PLANE_ADJUST = 0.00001f;
     //-----------------------------------------------------------------------
     Frustum::Frustum(const String& name) : 
         mProjType(PT_PERSPECTIVE), 

CamelotRenderer/OgreMath.cpp

@@ -244,14 +244,14 @@ namespace Ogre
 		// Note we don't care about normalisation here since sign is all we need
 		// It means we don't have to worry about magnitude of cross products either
 		dot[0] = v1.crossProduct(v2);
-		zeroDot[0] = Math::RealEqual(dot[0], 0.0f, 1e-3);
+		zeroDot[0] = Math::RealEqual(dot[0], 0.0f, 1e-3f);
 
 
 		v1 = c - b;
 		v2 = p - b;
 
 		dot[1] = v1.crossProduct(v2);
-		zeroDot[1] = Math::RealEqual(dot[1], 0.0f, 1e-3);
+		zeroDot[1] = Math::RealEqual(dot[1], 0.0f, 1e-3f);
 
 		// Compare signs (ignore colinear / coincident points)
 		if(!zeroDot[0] && !zeroDot[1] 
@@ -264,7 +264,7 @@ namespace Ogre
 		v2 = p - c;
 
 		dot[2] = v1.crossProduct(v2);
-		zeroDot[2] = Math::RealEqual(dot[2], 0.0f, 1e-3);
+		zeroDot[2] = Math::RealEqual(dot[2], 0.0f, 1e-3f);
 		// Compare signs (ignore colinear / coincident points)
 		if((!zeroDot[0] && !zeroDot[2] 
 			&& Math::Sign(dot[0]) != Math::Sign(dot[2])) ||
@@ -292,14 +292,14 @@ namespace Ogre
 		// Note we don't care about normalisation here since sign is all we need
 		// It means we don't have to worry about magnitude of cross products either
         dot[0] = v1.crossProduct(v2).dotProduct(normal);
-		zeroDot[0] = Math::RealEqual(dot[0], 0.0f, 1e-3);
+		zeroDot[0] = Math::RealEqual(dot[0], 0.0f, 1e-3f);
 
 
         v1 = c - b;
         v2 = p - b;
 
 		dot[1] = v1.crossProduct(v2).dotProduct(normal);
-		zeroDot[1] = Math::RealEqual(dot[1], 0.0f, 1e-3);
+		zeroDot[1] = Math::RealEqual(dot[1], 0.0f, 1e-3f);
 
 		// Compare signs (ignore colinear / coincident points)
 		if(!zeroDot[0] && !zeroDot[1] 
@@ -312,7 +312,7 @@ namespace Ogre
         v2 = p - c;
 
 		dot[2] = v1.crossProduct(v2).dotProduct(normal);
-		zeroDot[2] = Math::RealEqual(dot[2], 0.0f, 1e-3);
+		zeroDot[2] = Math::RealEqual(dot[2], 0.0f, 1e-3f);
 		// Compare signs (ignore colinear / coincident points)
 		if((!zeroDot[0] && !zeroDot[2] 
 			&& Math::Sign(dot[0]) != Math::Sign(dot[2])) ||

CamelotRenderer/OgreMatrix3.cpp

@@ -33,10 +33,10 @@ THE SOFTWARE.
 
 namespace Ogre
 {
-    const Real Matrix3::EPSILON = 1e-06;
+    const Real Matrix3::EPSILON = 1e-06f;
     const Matrix3 Matrix3::ZERO(0,0,0,0,0,0,0,0,0);
     const Matrix3 Matrix3::IDENTITY(1,0,0,0,1,0,0,0,1);
-    const Real Matrix3::ms_fSvdEpsilon = 1e-04;
+    const Real Matrix3::ms_fSvdEpsilon = 1e-04f;
     const unsigned int Matrix3::ms_iSvdMaxIterations = 32;
 
     //-----------------------------------------------------------------------
@@ -801,8 +801,8 @@ namespace Ogre
         // This yields the assertions c[0] < 0 and c[2]*c[2] >= 3*c[1].
 
         // quick out for uniform scale (triple root)
-        const Real fOneThird = 1.0/3.0;
-        const Real fEpsilon = 1e-06;
+        const Real fOneThird = 1.0f/3.0f;
+        const Real fEpsilon = 1e-06f;
         Real fDiscr = afCoeff[2]*afCoeff[2] - 3.0f*afCoeff[1];
         if ( fDiscr <= fEpsilon )
             return -fOneThird*afCoeff[2];

CamelotRenderer/OgrePlatformInformation.h

@@ -116,85 +116,6 @@ namespace Ogre {
 #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__

CamelotRenderer/OgrePrerequisites.h

@@ -120,43 +120,10 @@ namespace Ogre {
 // Allows use of pointers in header files without including individual .h
 // so decreases dependencies between files
     class Angle;
-    class Animation;
-    class AnimationState;
-    class AnimationStateSet;
-    class AnimationTrack;
-    class Archive;
-    class ArchiveFactory;
-    class ArchiveManager;
-    class AutoParamDataSource;
     class AxisAlignedBox;
-    class AxisAlignedBoxSceneQuery;
-    class Billboard;
-    class BillboardChain;
-    class BillboardSet;
-    class Bone;
     class Camera;
-    class Codec;
     class ColourValue;
-    class ConfigDialog;
-    template <typename T> class Controller;
-    template <typename T> class ControllerFunction;
-    class ControllerManager;
-    template <typename T> class ControllerValue;
-	class DefaultWorkQueue;
     class Degree;
-    class DynLib;
-    class DynLibManager;
-    class EdgeData;
-    class EdgeListBuilder;
-    class Entity;
-    class ErrorDialog;
-    class ExternalTextureSourceManager;
-    class Factory;
-    class Font;
-    class FontPtr;
-    class FontManager;
-    struct FrameEvent;
-    class FrameListener;
     class Frustum;
     class GpuProgram;
     class GpuProgramManager;
@@ -169,144 +136,34 @@ namespace Ogre {
 	class HighLevelGpuProgramManager;
 	class HighLevelGpuProgramFactory;
     class IndexData;
-    class IntersectionSceneQuery;
-    class IntersectionSceneQueryListener;
-    class Image;
-    class KeyFrame;
-    class Light;
-    class Log;
-    class LogManager;
-	class ManualResourceLoader;
-	class ManualObject;
-    class Material;
-    class MaterialPtr;
-    class MaterialManager;
     class Math;
     class Matrix3;
     class Matrix4;
-    class MemoryManager;
-    class Mesh;
-    class MeshPtr;
-    class MeshSerializer;
-    class MeshSerializerImpl;
-    class MeshManager;
-    class MovableObject;
-    class MovablePlane;
-    class Node;
-	class NodeAnimationTrack;
-	class NodeKeyFrame;
-	class NumericAnimationTrack;
-	class NumericKeyFrame;
-    class Overlay;
-    class OverlayContainer;
-    class OverlayElement;
-    class OverlayElementFactory;
-    class OverlayManager;
-    class Particle;
-    class ParticleAffector;
-    class ParticleAffectorFactory;
-    class ParticleEmitter;
-    class ParticleEmitterFactory;
-    class ParticleSystem;
-    class ParticleSystemManager;
-    class ParticleSystemRenderer;
-    class ParticleSystemRendererFactory;
-    class ParticleVisualData;
     class Pass;
-    class PatchMesh;
-    class PixelBox;
     class Plane;
-    class PlaneBoundedVolume;
-	class Plugin;
-    class Pose;
-    class ProgressiveMesh;
-    class Profile;
-	class Profiler;
     class Quaternion;
 	class Radian;
     class Ray;
-    class RaySceneQuery;
-    class RaySceneQueryListener;
-    class Renderable;
-    class RenderPriorityGroup;
-    class RenderQueue;
-    class RenderQueueGroup;
-	class RenderQueueInvocation;
-	class RenderQueueInvocationSequence;
-    class RenderQueueListener;
-	class RenderObjectListener;
     class RenderSystem;
     class RenderSystemCapabilities;
-    class RenderSystemCapabilitiesManager;
-    class RenderSystemCapabilitiesSerializer;
     class RenderTarget;
-    class RenderTargetListener;
     class RenderTexture;
 	class MultiRenderTarget;
     class RenderWindow;
     class RenderOperation;
-    class Resource;
-	class ResourceBackgroundQueue;
-	class ResourceGroupManager;
-    class ResourceManager;
-    class RibbonTrail;
-	class Root;
-    class SceneManager;
-    class SceneManagerEnumerator;
-    class SceneNode;
-    class SceneQuery;
-    class SceneQueryListener;
-	class ScriptCompiler;
-	class ScriptCompilerManager;
-	class ScriptLoader;
-    class Serializer;
-    class ShadowCaster;
-    class ShadowRenderable;
-	class ShadowTextureManager;
-    class SimpleRenderable;
-    class SimpleSpline;
-    class Skeleton;
-    class SkeletonPtr;
-    class SkeletonInstance;
-    class SkeletonManager;
     class Sphere;
-    class SphereSceneQuery;
-	class StaticGeometry;
-	class StreamSerialiser;
     class StringConverter;
     class StringInterface;
-    class SubEntity;
-    class SubMesh;
-	class TagPoint;
-    class Technique;
-	class TempBlendedBufferInfo;
-	class ExternalTextureSource;
     class TextureUnitState;
     class Texture;
     class TextureManager;
-    class TransformKeyFrame;
-	class Timer;
-	class UserObjectBindings;
     class Vector2;
     class Vector3;
     class Vector4;
     class Viewport;
-	class VertexAnimationTrack;
     class VertexBufferBinding;
     class VertexData;
     class VertexDeclaration;
-	class VertexMorphKeyFrame;
-    class WireBoundingBox;
-	class WorkQueue;
-    class Compositor;
-    class CompositorManager;
-    class CompositorChain;
-    class CompositorInstance;
-	class CompositorLogic;
-    class CompositionTechnique;
-    class CompositionPass;
-    class CompositionTargetPass;
-	class CustomCompositionPass;
 }
 
 /* Include all the standard header *after* all the configuration

CamelotRenderer/OgreQuaternion.cpp

@@ -41,7 +41,7 @@ THE SOFTWARE.
 
 namespace Ogre {
 
-    const Real Quaternion::ms_fEpsilon = 1e-03;
+    const Real Quaternion::ms_fEpsilon = 1e-03f;
     const Quaternion Quaternion::ZERO(0.0,0.0,0.0,0.0);
     const Quaternion Quaternion::IDENTITY(1.0,0.0,0.0,0.0);
 

CamelotRenderer/OgreRenderOperation.h

@@ -73,16 +73,10 @@ namespace Ogre {
 
 		/// Index data - only valid if useIndexes is true
 		IndexData *indexData;
-		/// Debug pointer back to renderable which created this
-		const Renderable* srcRenderable;
-
-
 
         RenderOperation() :
             vertexData(0), operationType(OT_TRIANGLE_LIST), useIndexes(true),
-                indexData(0), srcRenderable(0) {}
-
-
+                indexData(0) {}
 	};
 	/** @} */
 	/** @} */

CamelotRenderer/OgreTextureManager.cpp

@@ -57,7 +57,7 @@ namespace Ogre {
     }
     //-----------------------------------------------------------------------
     TexturePtr TextureManager::create(TextureType texType, uint width, uint height, uint depth, int numMipmaps,
-        PixelFormat format, int usage, ManualResourceLoader* loader, bool hwGamma, 
+        PixelFormat format, int usage, bool hwGamma, 
 		uint fsaa, const String& fsaaHint)
     {
         TexturePtr ret = TexturePtr(createImpl());

CamelotRenderer/OgreTextureManager.h

@@ -109,7 +109,7 @@ namespace Ogre {
 				not support it.
         */
         TexturePtr create(TextureType texType, uint width, uint height, uint depth, 
-			int num_mips, PixelFormat format, int usage = TU_DEFAULT, ManualResourceLoader* loader = 0,
+			int num_mips, PixelFormat format, int usage = TU_DEFAULT,
 			bool hwGammaCorrection = false, uint fsaa = 0, const String& fsaaHint = StringUtil::BLANK);
 			
         /** Create a manual texture with a depth of 1 (not loaded from a file).
@@ -155,11 +155,11 @@ namespace Ogre {
 				not support it.
         */
         TexturePtr create(TextureType texType, uint width, uint height, int num_mips,
-            PixelFormat format, int usage = TU_DEFAULT, ManualResourceLoader* loader = 0,
+            PixelFormat format, int usage = TU_DEFAULT,
 			bool hwGammaCorrection = false, uint fsaa = 0, const String& fsaaHint = StringUtil::BLANK)
 		{
 			return create(texType, width, height, 1, 
-				num_mips, format, usage, loader, hwGammaCorrection, fsaa, fsaaHint);
+				num_mips, format, usage, hwGammaCorrection, fsaa, fsaaHint);
 		}
 
         /** Sets preferred bit depth for integer pixel format textures.

CamelotRenderer/OgreTextureUnitState.cpp

@@ -60,7 +60,6 @@ namespace Ogre {
 		, mBindingType(BT_FRAGMENT)
 		, mContentType(CONTENT_NAMED)
 		, mParent(parent)
-		, mAnimController(0)
     {
 		mColourBlendMode.blendType = LBT_COLOUR;
 		mAlphaBlendMode.operation = LBX_MODULATE;
@@ -75,7 +74,6 @@ namespace Ogre {
     TextureUnitState::TextureUnitState(Pass* parent, const TextureUnitState& oth )
     {
         mParent = parent;
-        mAnimController = 0;
         *this = oth;
     }
 
@@ -109,7 +107,6 @@ namespace Ogre {
 		, mBindingType(BT_FRAGMENT)
 		, mContentType(CONTENT_NAMED)
 		, mParent(parent)
-		, mAnimController(0)
     {
 		mColourBlendMode.blendType = LBT_COLOUR;
 		mAlphaBlendMode.operation = LBX_MODULATE;
@@ -132,7 +129,6 @@ namespace Ogre {
     TextureUnitState & TextureUnitState::operator = ( 
         const TextureUnitState &oth )
     {
-        assert(mAnimController == 0);
         assert(mEffects.empty());
 
         // copy basic members (int's, real's)
@@ -146,11 +142,6 @@ namespace Ogre {
         mTextureNameAlias = oth.mTextureNameAlias;
 		mCompositorRefName = oth.mCompositorRefName;
 		mCompositorRefTexName = oth.mCompositorRefTexName;
-        // Can't sharing controllers with other TUS, reset to null to avoid potential bug.
-        for (EffectMap::iterator j = mEffects.begin(); j != mEffects.end(); ++j)
-        {
-            j->second.controller = 0;
-        }
 
         // Load immediately if Material loaded
         if (isLoaded())

CamelotRenderer/OgreTextureUnitState.h

@@ -163,7 +163,6 @@ namespace Ogre {
             Real frequency;
             Real phase;
             Real amplitude;
-            Controller<Real>* controller;
             const Frustum* frustum;
         };
 
@@ -989,10 +988,6 @@ namespace Ogre {
 		/** Set the texture pointer for a given frame (internal use only!). */
 		void _setTexturePtr(const TexturePtr& texptr, size_t frame);
 
-		/** Gets the animation controller (as created because of setAnimatedTexture)
-			if it exists.
-		*/
-		Controller<Real>* _getAnimController() const { return mAnimController; }
 protected:
         // State
         /// The current animation frame.
@@ -1064,7 +1059,6 @@ protected:
         // preserving even if assign from others
         //
         Pass* mParent;
-        Controller<Real>* mAnimController;
         //-----------------------------------------------------------------------------
 
 

CamelotRenderer/OgreViewport.cpp

@@ -52,7 +52,6 @@ namespace Ogre {
         , mShowSkies(true)
 		, mShowShadows(true)
 		, mVisibilityMask(0xFFFFFFFF)
-		, mRQSequence(0)
 		, mMaterialSchemeName("NotUsedInPort")
 		, mIsAutoUpdated(true)
     {
@@ -302,31 +301,6 @@ namespace Ogre {
         return mShowShadows;
     }
 	//-----------------------------------------------------------------------
-	void Viewport::setRenderQueueInvocationSequenceName(const String& sequenceName)
-	{
-		mRQSequenceName = sequenceName;
-		if (mRQSequenceName.empty())
-		{
-			mRQSequence = 0;
-		}
-		else
-		{
-			// TODO PORT - Not sure if this is needed but I might need to enable it later once I have rendersystem running? (Probably not)
-			//mRQSequence =
-			//	Root::getSingleton().getRenderQueueInvocationSequence(mRQSequenceName);
-		}
-	}
-	//-----------------------------------------------------------------------
-	const String& Viewport::getRenderQueueInvocationSequenceName(void) const
-	{
-		return mRQSequenceName;
-	}
-	//-----------------------------------------------------------------------
-	RenderQueueInvocationSequence* Viewport::_getRenderQueueInvocationSequence(void)
-	{
-		return mRQSequence;
-	}
-	//-----------------------------------------------------------------------
     void Viewport::pointOrientedToScreen(const Vector2 &v, int orientationMode, Vector2 &outv)
     {
         pointOrientedToScreen(v.x, v.y, orientationMode, outv.x, outv.y);

CamelotRenderer/OgreViewport.h

@@ -322,24 +322,6 @@ namespace Ogre {
 		*/
 		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,
@@ -362,9 +344,6 @@ namespace Ogre {
         bool mShowSkies;
 		bool mShowShadows;
 		uint32 mVisibilityMask;
-		// Render queue invocation sequence name
-		String mRQSequenceName;
-		RenderQueueInvocationSequence* mRQSequence;
 		/// Material scheme
 		String mMaterialSchemeName;
         /// Viewport orientation mode

CamelotRenderer/RenderSystemGL/Source/OgreGLRenderSystem.cpp

@@ -572,7 +572,7 @@ namespace Ogre {
 		{
 			GLint vSize[2];
 			glGetIntegerv(GL_POINT_SIZE_RANGE,vSize);
-			rsc->setMaxPointSize(vSize[1]);
+			rsc->setMaxPointSize((Ogre::Real)vSize[1]);
 		}
 
 		// Vertex texture fetching
@@ -2065,8 +2065,8 @@ namespace Ogre {
 		Real tanThetaX = tanThetaY * aspect; //Math::Tan(thetaX);
 		Real half_w = tanThetaX * nearPlane;
 		Real half_h = tanThetaY * nearPlane;
-		Real iw = 1.0 / half_w;
-		Real ih = 1.0 / half_h;
+		Real iw = 1.0f / half_w;
+		Real ih = 1.0f / half_h;
 		Real q;
 		if (farPlane == 0)
 		{
@@ -2074,7 +2074,7 @@ namespace Ogre {
 		}
 		else
 		{
-			q = 2.0 / (farPlane - nearPlane);
+			q = 2.0f / (farPlane - nearPlane);
 		}
 		dest = Matrix4::ZERO;
 		dest[0][0] = iw;