Cleaning up some spaces that were used instead of tabs

Source/BansheeCore/Include/BsCReflectionProbe.h

@@ -6,7 +6,7 @@
 #include "BsReflectionProbe.h"
 #include "BsComponent.h"
 
-namespace bs 
+namespace bs
 {
 	/** @addtogroup Components
 	 *  @{
@@ -17,58 +17,58 @@ namespace bs
 	 *
 	 * Wraps ReflectionProbe as a Component.
 	 */
-    class BS_CORE_EXPORT CReflectionProbe : public Component
-    {
-    public:
+	class BS_CORE_EXPORT CReflectionProbe : public Component
+	{
+	public:
 		CReflectionProbe(const HSceneObject& parent);
 		virtual ~CReflectionProbe();
 
-	    /** @copydoc ReflectionProbe::getType */
+		/** @copydoc ReflectionProbe::getType */
 		ReflectionProbeType getType() const { return mInternal->getType(); }
 
-	    /** @copydoc ReflectionProbe::setType */
+		/** @copydoc ReflectionProbe::setType */
 		void setType(ReflectionProbeType type) { mInternal->setType(type); }
 
-	    /** @copydoc ReflectionProbe::getRadius */
+		/** @copydoc ReflectionProbe::getRadius */
 		float getRadius() const { return mInternal->getRadius(); }
 
-	    /** @copydoc ReflectionProbe::setRadius  */
+		/** @copydoc ReflectionProbe::setRadius  */
 		void setRadius(float radius) { mInternal->setRadius(radius); }
 
-	    /** @copydoc ReflectionProbe::getExtents */
+		/** @copydoc ReflectionProbe::getExtents */
 		Vector3 getExtents() const { return mInternal->getExtents(); }
 
-	    /** @copydoc ReflectionProbe::setExtents */
+		/** @copydoc ReflectionProbe::setExtents */
 		void setExtents(const Vector3& extents) { mInternal->setExtents(extents); }
 
-        /** Retrieves transition distance set by setTransitionDistance(). */
-        float getTransitionDistance() const { return mInternal->getTransitionDistance(); }
+		/** Retrieves transition distance set by setTransitionDistance(). */
+		float getTransitionDistance() const { return mInternal->getTransitionDistance(); }
 
-        /** @copydoc ReflectionProbe::setTransitionDistance */
-        void setTransitionDistance(float distance) { mInternal->setTransitionDistance(distance); }
+		/** @copydoc ReflectionProbe::setTransitionDistance */
+		void setTransitionDistance(float distance) { mInternal->setTransitionDistance(distance); }
 
-        /** @copydoc ReflectionProbe::getCustomTexture */
-        HTexture getCustomTexture() const { return mInternal->getCustomTexture(); }
+		/** @copydoc ReflectionProbe::getCustomTexture */
+		HTexture getCustomTexture() const { return mInternal->getCustomTexture(); }
 
-        /** @copydoc ReflectionProbe::setCustomTexture */
-        void setCustomTexture(const HTexture& texture) { mInternal->setCustomTexture(texture); }
+		/** @copydoc ReflectionProbe::setCustomTexture */
+		void setCustomTexture(const HTexture& texture) { mInternal->setCustomTexture(texture); }
 
-	    /** @copydoc ReflectionProbe::getBounds */
+		/** @copydoc ReflectionProbe::getBounds */
 		Sphere getBounds() const;
 
-        /** @copydoc ReflectionProbe::generate */
-        void generate() { mInternal->generate(); }
+		/** @copydoc ReflectionProbe::generate */
+		void generate() { mInternal->generate(); }
 
-		/** @name Internal 
+		/** @name Internal
 		 *  @{
 		 */
 
-	    /**	Returns the reflection probe that this component wraps. */
+		/**	Returns the reflection probe that this component wraps. */
 		SPtr<ReflectionProbe> _getReflectionProbe() const { return mInternal; }
 
 		/** @} */
 
-    protected:
+	protected:
 		mutable SPtr<ReflectionProbe> mInternal;
 
 		/************************************************************************/
@@ -77,10 +77,10 @@ namespace bs
 	protected:
 		friend class SceneObject;
 
-	    /** @copydoc Component::onInitialized */
+		/** @copydoc Component::onInitialized */
 		void onInitialized() override;
 
-	    /** @copydoc Component::onDestroyed */
+		/** @copydoc Component::onDestroyed */
 		void onDestroyed() override;
 
 		/** @copydoc Component::update */
@@ -96,7 +96,7 @@ namespace bs
 
 	protected:
 		CReflectionProbe(); // Serialization only
-     };
+	};
 
-	 /** @} */
+	/** @} */
 }

Source/BansheeCore/Include/BsSkybox.h

@@ -23,9 +23,9 @@ namespace bs
 	class BS_CORE_EXPORT SkyboxBase
 	{
 	public:
-        SkyboxBase();
+		SkyboxBase();
 		virtual ~SkyboxBase() { }
-        
+
 		/**	Checks whether the skybox should be used or not. */
 		bool getIsActive() const { return mIsActive; }
 
@@ -35,9 +35,9 @@ namespace bs
 		/** Returns an identifier that uniquely identifies the skybox. */
 		const String& getUUID() const { return mUUID; }
 
-		/** 
-		 * Marks the simulation thread object as dirty and notifies the system its data should be synced with its core 
-		 * thread counterpart. 
+		/**
+		 * Marks the simulation thread object as dirty and notifies the system its data should be synced with its core
+		 * thread counterpart.
 		 */
 		virtual void _markCoreDirty(SkyboxDirtyFlag flags = SkyboxDirtyFlag::Everything) { }
 
@@ -53,10 +53,10 @@ namespace bs
 		typedef typename TTextureType<Core>::Type TextureType;
 
 	public:
-        TSkybox();
+		TSkybox();
 		virtual ~TSkybox() { }
 
-		/** 
+		/**
 		 * Assigns an environment map to use for sampling skybox radiance. Must be a cube-map texture, and should ideally
 		 * contain HDR data.
 		 */
@@ -87,7 +87,7 @@ namespace bs
 		static SPtr<Skybox> create();
 
 	protected:
-        Skybox();
+		Skybox();
 
 		/** @copydoc CoreObject::createCore */
 		SPtr<ct::CoreObject> createCore() const override;
@@ -109,23 +109,23 @@ namespace bs
 
 	namespace ct
 	{
-	/** Core thread usable version of a bs::Skybox */
-	class BS_CORE_EXPORT Skybox : public CoreObject, public TSkybox<true>
-	{
-	public:
-		~Skybox();
+		/** Core thread usable version of a bs::Skybox */
+		class BS_CORE_EXPORT Skybox : public CoreObject, public TSkybox<true>
+		{
+		public:
+			~Skybox();
 
-	protected:
-		friend class bs::Skybox;
+		protected:
+			friend class bs::Skybox;
 
-        Skybox();
+			Skybox();
 
-		/** @copydoc CoreObject::initialize */
-		void initialize() override;
+			/** @copydoc CoreObject::initialize */
+			void initialize() override;
 
-		/** @copydoc CoreObject::syncToCore */
-		void syncToCore(const CoreSyncData& data) override;
-	};
+			/** @copydoc CoreObject::syncToCore */
+			void syncToCore(const CoreSyncData& data) override;
+		};
 	}
 
 	/** @} */

Source/BansheeEngine/Include/BsRendererUtility.h

@@ -71,7 +71,6 @@ namespace bs { namespace ct
 		 */
 		void draw(const SPtr<MeshBase>& mesh, const SubMesh& subMesh, UINT32 numInstances = 1);
 
-
 		/**
 		 * Draws the specified mesh with an additional vertex buffer containing morph shape vertices.
 		 *

Source/RenderBeast/Include/BsLightRendering.h

@@ -84,16 +84,16 @@ namespace bs { namespace ct
 
 		/** Binds the material for rendering, sets up parameters and executes it. */
 		void execute(const SPtr<RenderTargets>& gbuffer, const SPtr<GpuParamBlockBuffer>& perCamera, 
-                     const SPtr<Texture>& preintegratedGF, bool noLighting);
+			const SPtr<Texture>& preintegratedGF, bool noLighting);
 
 		/** Binds all the active lights. */
 		void setLights(const GPULightData& lightData);
 
-        /** Binds all the active reflection probes. */
-        void setReflectionProbes(const GPUReflProbeData& probeData, const SPtr<Texture>& reflectionCubemaps);
+		/** Binds all the active reflection probes. */
+		void setReflectionProbes(const GPUReflProbeData& probeData, const SPtr<Texture>& reflectionCubemaps);
 
-        /** Binds the sky reflection. If no sky reflection set to null. */
-        void setSkyReflections(const SPtr<Texture>& skyReflections);
+		/** Binds the sky reflection. If no sky reflection set to null. */
+		void setSkyReflections(const SPtr<Texture>& skyReflections);
 
 		/** 
 		 * Generates a 2D 2-channel texture containing a pre-integrated G and F factors of the microfactet BRDF. This is an
@@ -116,10 +116,10 @@ namespace bs { namespace ct
 		GpuParamTexture mGBufferC;
 		GpuParamTexture mGBufferDepth;
 
-        GpuParamTexture mSkyCubemapTexParam;
-        GpuParamTexture mReflectionProbeCubemapsParam;
-        GpuParamTexture mPreintegratedEnvBRDFParam;
-        GpuParamBuffer mReflectionProbesParam;
+		GpuParamTexture mSkyCubemapTexParam;
+		GpuParamTexture mReflectionProbeCubemapsParam;
+		GpuParamTexture mPreintegratedEnvBRDFParam;
+		GpuParamBuffer mReflectionProbesParam;
 
 		Vector3I mLightOffsets;
 		GpuParamBuffer mLightBufferParam;
@@ -127,7 +127,7 @@ namespace bs { namespace ct
 		GpuParamBuffer mOutputBufferParam;
 
 		SPtr<GpuParamBlockBuffer> mParamBuffer;
-        SPtr<GpuParamBlockBuffer> mReflectionsParamBuffer;
+		SPtr<GpuParamBlockBuffer> mReflectionsParamBuffer;
 	};
 
 	/** Interface implemented by all versions of TTiledDeferredLightingMat<T>. */
@@ -136,18 +136,18 @@ namespace bs { namespace ct
 	public:
 		virtual ~ITiledDeferredLightingMat() {}
 
-        /** @copydoc TiledDeferredLighting::execute() */
+		/** @copydoc TiledDeferredLighting::execute() */
 		virtual void execute(const SPtr<RenderTargets>& gbuffer, const SPtr<GpuParamBlockBuffer>& perCamera, 
-                             const SPtr<Texture>& preintegratedGF, bool noLighting) = 0;
+			const SPtr<Texture>& preintegratedGF, bool noLighting) = 0;
 
-        /** @copydoc TiledDeferredLighting::setLights() */
+		/** @copydoc TiledDeferredLighting::setLights() */
 		virtual void setLights(const GPULightData& lightData) = 0;
 
-        /** @copydoc TiledDeferredLighting::setReflectionProbes() */
-        virtual void setReflectionProbes(const GPUReflProbeData& probeData, const SPtr<Texture>& reflectionCubemaps) = 0;
+		/** @copydoc TiledDeferredLighting::setReflectionProbes() */
+		virtual void setReflectionProbes(const GPUReflProbeData& probeData, const SPtr<Texture>& reflectionCubemaps) = 0;
 
-        /** @copydoc TiledDeferredLighting::setSkyReflections() */
-        virtual void setSkyReflections(const SPtr<Texture>& skyReflections) = 0;
+		/** @copydoc TiledDeferredLighting::setSkyReflections() */
+		virtual void setSkyReflections(const SPtr<Texture>& skyReflections) = 0;
 	};
 
 	/** Shader that performs a lighting pass over data stored in the Gbuffer. */
@@ -161,39 +161,39 @@ namespace bs { namespace ct
 
 		/** @copydoc ITiledDeferredLightingMat::execute() */
 		void execute(const SPtr<RenderTargets>& gbuffer, const SPtr<GpuParamBlockBuffer>& perCamera, 
-                     const SPtr<Texture>& preintegratedGF, bool noLighting) override;
+			const SPtr<Texture>& preintegratedGF, bool noLighting) override;
 
-        /** @copydoc ITiledDeferredLightingMat::setLights() */
+		/** @copydoc ITiledDeferredLightingMat::setLights() */
 		void setLights(const GPULightData& lightData) override;
 
-        /** @copydoc ITiledDeferredLightingMat::setReflectionProbes() */
-        void setReflectionProbes(const GPUReflProbeData& probeData, const SPtr<Texture>& reflectionCubemaps) override;
+		/** @copydoc ITiledDeferredLightingMat::setReflectionProbes() */
+		void setReflectionProbes(const GPUReflProbeData& probeData, const SPtr<Texture>& reflectionCubemaps) override;
 
-        /** @copydoc ITiledDeferredLightingMat::setSkyReflections() */
-        void setSkyReflections(const SPtr<Texture>& skyReflections) override;
+		/** @copydoc ITiledDeferredLightingMat::setSkyReflections() */
+		void setSkyReflections(const SPtr<Texture>& skyReflections) override;
 	private:
 		TiledDeferredLighting mInternal;
 	};
 
-    /** Contains instances for all types of tile deferred lighting materials. */
-    class TiledDeferredLightingMaterials
-    {
-    public:
-        TiledDeferredLightingMaterials();
-        ~TiledDeferredLightingMaterials();
-
-        /**
-         * Returns a version of the tile-deferred lighting material that matches the parameters.
-         * 
-         * @param[in]   msaa                Number of samples per pixel.
-         * @param[in]   fixedReflColor      If true reflection probes will not be evaluated and instead a fixed color will
-         *                                  be returned instead. Useful when rendering reflection probes.
-         */
-        ITiledDeferredLightingMat* get(UINT32 msaa, bool fixedReflColor);
-
-    private:
-        ITiledDeferredLightingMat* mInstances[8];
-    };
+	/** Contains instances for all types of tile deferred lighting materials. */
+	class TiledDeferredLightingMaterials
+	{
+	public:
+		TiledDeferredLightingMaterials();
+		~TiledDeferredLightingMaterials();
+
+		/**
+		 * Returns a version of the tile-deferred lighting material that matches the parameters.
+		 * 
+		 * @param[in]   msaa				Number of samples per pixel.
+		 * @param[in]   fixedReflColor		If true reflection probes will not be evaluated and instead a fixed color will
+		 *									be returned instead. Useful when rendering reflection probes.
+		 */
+		ITiledDeferredLightingMat* get(UINT32 msaa, bool fixedReflColor);
+
+	private:
+		ITiledDeferredLightingMat* mInstances[8];
+	};
 
 	BS_PARAM_BLOCK_BEGIN(FlatFramebufferToTextureParamDef)
 		BS_PARAM_BLOCK_ENTRY(Vector2I, gFramebufferSize)

Source/RenderBeast/Include/BsRenderBeast.h

@@ -128,14 +128,14 @@ namespace bs
 		/** @copydoc Renderer::notifyReflectionProbeRemoved */
 		void notifyReflectionProbeRemoved(ReflectionProbe* probe) override;
 
-        /** @copydoc Renderer::notifySkyboxAdded */
-        void notifySkyboxAdded(Skybox* skybox) override;
+		/** @copydoc Renderer::notifySkyboxAdded */
+		void notifySkyboxAdded(Skybox* skybox) override;
 
-        /** @copydoc Renderer::notifySkyboxTextureChanged */
-        void notifySkyboxTextureChanged(Skybox* skybox) override;
+		/** @copydoc Renderer::notifySkyboxTextureChanged */
+		void notifySkyboxTextureChanged(Skybox* skybox) override;
 
-        /** @copydoc Renderer::notifySkyboxRemoved */
-        void notifySkyboxRemoved(Skybox* skybox) override;
+		/** @copydoc Renderer::notifySkyboxRemoved */
+		void notifySkyboxRemoved(Skybox* skybox) override;
 
 		/** 
 		 * Updates (or adds) renderer specific data for the specified camera. Should be called whenever camera properties
@@ -246,16 +246,16 @@ namespace bs
 		SPtr<RenderBeastOptions> mCoreOptions;
 
 		DefaultMaterial* mDefaultMaterial;
-        TiledDeferredLightingMaterials* mTiledDeferredLightingMats;
+		TiledDeferredLightingMaterials* mTiledDeferredLightingMats;
 		FlatFramebufferToTextureMat* mFlatFramebufferToTextureMat;
 		SkyboxMat<false>* mSkyboxMat;
 		SkyboxMat<true>* mSkyboxSolidColorMat;
 
-        Skybox* mSkybox;
-        SPtr<Texture> mSkyboxTexture;
-        SPtr<Texture> mSkyboxFilteredReflections;
+		Skybox* mSkybox;
+		SPtr<Texture> mSkyboxTexture;
+		SPtr<Texture> mSkyboxFilteredReflections;
 
-        SPtr<Texture> mPreintegratedEnvBRDF;
+		SPtr<Texture> mPreintegratedEnvBRDF;
 		GPULightData* mGPULightData;
 		GPUReflProbeData* mGPUReflProbeData;
 		LightGrid* mLightGrid;

Source/RenderBeast/Include/BsRendererCamera.h

@@ -95,7 +95,7 @@ namespace bs { namespace ct
 		bool noLighting : 1;
 		bool triggerCallbacks : 1;
 		bool runPostProcessing : 1;
-        bool renderingReflections : 1;
+		bool renderingReflections : 1;
 
 		UINT64 visibleLayers;
 		ConvexVolume cullFrustum;
@@ -178,8 +178,8 @@ namespace bs { namespace ct
 		/** Returns the number of samples per pixel to render. */
 		UINT32 getNumSamples() const { return mViewDesc.target.numSamples; }
 
-        /** Returns true if the current view is being used to render reflection probes. */
-        bool isRenderingReflections() const { return mViewDesc.renderingReflections; }
+		/** Returns true if the current view is being used to render reflection probes. */
+		bool isRenderingReflections() const { return mViewDesc.renderingReflections; }
 
 		/** Returns the scene camera this object is based of. This can be null for manually constructed renderer cameras. */
 		const Camera* getSceneCamera() const { return mViewDesc.sceneCamera; }

Source/RenderBeast/Source/BsLightRendering.cpp

@@ -40,11 +40,11 @@ namespace bs { namespace ct
 	}
 
 	GPULightData::GPULightData()
-		:mNumLights {}
+		:mNumLights{}
 	{ }
 
 	void GPULightData::setLights(const Vector<LightData>& lightData, UINT32 numDirLights, UINT32 numRadialLights,
-				   UINT32 numSpotLights)
+									UINT32 numSpotLights)
 	{
 		mNumLights[0] = numDirLights;
 		mNumLights[1] = numRadialLights;
@@ -85,8 +85,8 @@ namespace bs { namespace ct
 
 	const UINT32 TiledDeferredLighting::TILE_SIZE = 16;
 
-	TiledDeferredLighting::TiledDeferredLighting(const SPtr<Material>& material, const SPtr<GpuParamsSet>& paramsSet, 
-												 UINT32 sampleCount)
+	TiledDeferredLighting::TiledDeferredLighting(const SPtr<Material>& material, const SPtr<GpuParamsSet>& paramsSet,
+													UINT32 sampleCount)
 		:mSampleCount(sampleCount), mMaterial(material), mParamsSet(paramsSet), mLightOffsets()
 	{
 		SPtr<GpuParams> params = mParamsSet->getGpuParams();
@@ -106,7 +106,7 @@ namespace bs { namespace ct
 
 		params->getBufferParam(GPT_COMPUTE_PROGRAM, "gLights", mLightBufferParam);
 
-		if(params->hasLoadStoreTexture(GPT_COMPUTE_PROGRAM, "gOutput"))
+		if (params->hasLoadStoreTexture(GPT_COMPUTE_PROGRAM, "gOutput"))
 			params->getLoadStoreTextureParam(GPT_COMPUTE_PROGRAM, "gOutput", mOutputTextureParam);
 
 		if (params->hasBuffer(GPT_COMPUTE_PROGRAM, "gOutput"))
@@ -115,19 +115,19 @@ namespace bs { namespace ct
 		mParamBuffer = gTiledLightingParamDef.createBuffer();
 		mParamsSet->setParamBlockBuffer("Params", mParamBuffer, true);
 
-        // Reflections
-        params->getTextureParam(GPT_COMPUTE_PROGRAM, "gSkyCubemapTex", mSkyCubemapTexParam);
-        params->getTextureParam(GPT_COMPUTE_PROGRAM, "gReflProbeCubmaps", mReflectionProbeCubemapsParam);
-        params->getTextureParam(GPT_COMPUTE_PROGRAM, "gPreintegratedEnvBRDF", mPreintegratedEnvBRDFParam);
+		// Reflections
+		params->getTextureParam(GPT_COMPUTE_PROGRAM, "gSkyCubemapTex", mSkyCubemapTexParam);
+		params->getTextureParam(GPT_COMPUTE_PROGRAM, "gReflProbeCubmaps", mReflectionProbeCubemapsParam);
+		params->getTextureParam(GPT_COMPUTE_PROGRAM, "gPreintegratedEnvBRDF", mPreintegratedEnvBRDFParam);
 
-        params->getBufferParam(GPT_COMPUTE_PROGRAM, "gReflectionProbes", mReflectionProbesParam);
+		params->getBufferParam(GPT_COMPUTE_PROGRAM, "gReflectionProbes", mReflectionProbesParam);
 
-        mReflectionsParamBuffer = gReflProbeParamsParamDef.createBuffer();
-        mParamsSet->setParamBlockBuffer("ReflProbeParams", mReflectionsParamBuffer);
+		mReflectionsParamBuffer = gReflProbeParamsParamDef.createBuffer();
+		mParamsSet->setParamBlockBuffer("ReflProbeParams", mReflectionsParamBuffer);
 	}
 
-	void TiledDeferredLighting::execute(const SPtr<RenderTargets>& gbuffer, const SPtr<GpuParamBlockBuffer>& perCamera, 
-        const SPtr<Texture>& preintegratedGF, bool noLighting)
+	void TiledDeferredLighting::execute(const SPtr<RenderTargets>& gbuffer, const SPtr<GpuParamBlockBuffer>& perCamera,
+										const SPtr<Texture>& preintegratedGF, bool noLighting)
 	{
 		Vector2I framebufferSize;
 		framebufferSize[0] = gbuffer->getWidth();
@@ -148,14 +148,14 @@ namespace bs { namespace ct
 			gTiledLightingParamDef.gLightOffsets.set(mParamBuffer, mLightOffsets);
 		}
 		mParamBuffer->flushToGPU();
-        mReflectionsParamBuffer->flushToGPU();
+		mReflectionsParamBuffer->flushToGPU();
 
 		mGBufferA.set(gbuffer->getTextureA());
 		mGBufferB.set(gbuffer->getTextureB());
 		mGBufferC.set(gbuffer->getTextureC());
 		mGBufferDepth.set(gbuffer->getTextureDepth());
 
-        mPreintegratedEnvBRDFParam.set(preintegratedGF);
+		mPreintegratedEnvBRDFParam.set(preintegratedGF);
 
 		mParamsSet->setParamBlockBuffer("PerCamera", perCamera, true);
 
@@ -192,35 +192,35 @@ namespace bs { namespace ct
 		mLightOffsets[2] = mLightOffsets[1] + lightData.getNumSpotLights();
 	}
 
-    void TiledDeferredLighting::setReflectionProbes(const GPUReflProbeData& probeData, 
-                                                    const SPtr<Texture>& reflectionCubemaps)
+	void TiledDeferredLighting::setReflectionProbes(const GPUReflProbeData& probeData,
+													const SPtr<Texture>& reflectionCubemaps)
 	{
-        mReflectionProbesParam.set(probeData.getProbeBuffer());
-        mReflectionProbeCubemapsParam.set(reflectionCubemaps);
+		mReflectionProbesParam.set(probeData.getProbeBuffer());
+		mReflectionProbeCubemapsParam.set(reflectionCubemaps);
 
-        gReflProbeParamsParamDef.gNumProbes.set(mReflectionsParamBuffer, probeData.getNumProbes());
+		gReflProbeParamsParamDef.gNumProbes.set(mReflectionsParamBuffer, probeData.getNumProbes());
 
-        UINT32 maxMip = 0;
-        if (reflectionCubemaps != nullptr)
-            maxMip = reflectionCubemaps->getProperties().getNumMipmaps();
+		UINT32 maxMip = 0;
+		if (reflectionCubemaps != nullptr)
+			maxMip = reflectionCubemaps->getProperties().getNumMipmaps();
 
-        gReflProbeParamsParamDef.gReflCubemapNumMips.set(mReflectionsParamBuffer, maxMip);
+		gReflProbeParamsParamDef.gReflCubemapNumMips.set(mReflectionsParamBuffer, maxMip);
 	}
 
-    void TiledDeferredLighting::setSkyReflections(const SPtr<Texture>& skyReflections)
+	void TiledDeferredLighting::setSkyReflections(const SPtr<Texture>& skyReflections)
 	{
-        mSkyCubemapTexParam.set(skyReflections);
-
-        UINT32 skyReflectionsAvailable = 0;
-        UINT32 maxMip = 0;
-        if (skyReflections != nullptr)
-        {
-            maxMip = skyReflections->getProperties().getNumMipmaps();
-            skyReflectionsAvailable = 1;
-        }
-
-        gReflProbeParamsParamDef.gSkyCubemapNumMips.set(mReflectionsParamBuffer, maxMip);
-        gReflProbeParamsParamDef.gSkyCubemapAvailable.set(mReflectionsParamBuffer, skyReflectionsAvailable);
+		mSkyCubemapTexParam.set(skyReflections);
+
+		UINT32 skyReflectionsAvailable = 0;
+		UINT32 maxMip = 0;
+		if (skyReflections != nullptr)
+		{
+			maxMip = skyReflections->getProperties().getNumMipmaps();
+			skyReflectionsAvailable = 1;
+		}
+
+		gReflProbeParamsParamDef.gSkyCubemapNumMips.set(mReflectionsParamBuffer, maxMip);
+		gReflProbeParamsParamDef.gSkyCubemapAvailable.set(mReflectionsParamBuffer, skyReflectionsAvailable);
 	}
 
 	// Reverse bits functions used for Hammersley sequence
@@ -276,7 +276,7 @@ namespace bs { namespace ct
 		desc.format = PF_FLOAT16_RG;
 		desc.width = 128;
 		desc.height = 32;
-		
+
 		SPtr<Texture> texture = Texture::create(desc);
 		PixelData pixelData = texture->lock(GBL_WRITE_ONLY_DISCARD);
 
@@ -320,10 +320,10 @@ namespace bs { namespace ct
 					float NoL = std::max(L.z, 0.0f); // N assumed (0, 0, 1)
 					float NoH = std::max(H.z, 0.0f); // N assumed (0, 0, 1)
 
-					// Set second part of the split sum integral is split into two parts:
-					//   F0*I[G * (1 - (1 - v.h)^5) * cos(theta)] + I[G * (1 - v.h)^5 * cos(theta)] (F0 * scale + bias)
+														// Set second part of the split sum integral is split into two parts:
+														//   F0*I[G * (1 - (1 - v.h)^5) * cos(theta)] + I[G * (1 - v.h)^5 * cos(theta)] (F0 * scale + bias)
 
-					// We calculate the fresnel scale (1 - (1 - v.h)^5) and bias ((1 - v.h)^5) parts
+														// We calculate the fresnel scale (1 - (1 - v.h)^5) and bias ((1 - v.h)^5) parts
 					float fc = pow(1.0f - VoH, 5.0f);
 					float fresnelScale = 1.0f - fc;
 					float fresnelOffset = fc;
@@ -342,11 +342,11 @@ namespace bs { namespace ct
 				scale /= NumSamples;
 				offset /= NumSamples;
 
-                Color color;
-                color.r = Math::clamp01(scale);
-                color.g = Math::clamp01(offset);
+				Color color;
+				color.r = Math::clamp01(scale);
+				color.g = Math::clamp01(offset);
 
-                pixelData.setColorAt(color, x, y);
+				pixelData.setColorAt(color, x, y);
 			}
 		}
 
@@ -367,12 +367,12 @@ namespace bs { namespace ct
 	{
 		defines.set("TILE_SIZE", TiledDeferredLighting::TILE_SIZE);
 		defines.set("MSAA_COUNT", MSAA_COUNT);
-        defines.set("FIXED_REFLECTION_COLOR", FixedReflColor);
+		defines.set("FIXED_REFLECTION_COLOR", FixedReflColor);
 	}
 
 	template<int MSAA_COUNT, bool FixedReflColor>
 	void TTiledDeferredLightingMat<MSAA_COUNT, FixedReflColor>::execute(const SPtr<RenderTargets>& gbuffer,
-         const SPtr<GpuParamBlockBuffer>& perCamera, const SPtr<Texture>& preintegratedGF, bool noLighting)
+																		const SPtr<GpuParamBlockBuffer>& perCamera, const SPtr<Texture>& preintegratedGF, bool noLighting)
 	{
 		mInternal.execute(gbuffer, perCamera, preintegratedGF, noLighting);
 	}
@@ -383,62 +383,62 @@ namespace bs { namespace ct
 		mInternal.setLights(lightData);
 	}
 
-    template<int MSAA_COUNT, bool FixedReflColor>
-    void TTiledDeferredLightingMat<MSAA_COUNT, FixedReflColor>::setReflectionProbes(const GPUReflProbeData& probeData, const SPtr<Texture>& reflectionCubemaps)
+	template<int MSAA_COUNT, bool FixedReflColor>
+	void TTiledDeferredLightingMat<MSAA_COUNT, FixedReflColor>::setReflectionProbes(const GPUReflProbeData& probeData, const SPtr<Texture>& reflectionCubemaps)
+	{
+		mInternal.setReflectionProbes(probeData, reflectionCubemaps);
+	}
+
+	template<int MSAA_COUNT, bool FixedReflColor>
+	void TTiledDeferredLightingMat<MSAA_COUNT, FixedReflColor>::setSkyReflections(const SPtr<Texture>& skyReflections)
+	{
+		mInternal.setSkyReflections(skyReflections);
+	}
+
+	TiledDeferredLightingMaterials::TiledDeferredLightingMaterials()
 	{
-        mInternal.setReflectionProbes(probeData, reflectionCubemaps);
+		mInstances[0] = bs_new<TTiledDeferredLightingMat<1, false>>();
+		mInstances[1] = bs_new<TTiledDeferredLightingMat<2, false>>();
+		mInstances[2] = bs_new<TTiledDeferredLightingMat<4, false>>();
+		mInstances[3] = bs_new<TTiledDeferredLightingMat<8, false>>();
+
+		mInstances[4] = bs_new<TTiledDeferredLightingMat<1, true>>();
+		mInstances[5] = bs_new<TTiledDeferredLightingMat<2, true>>();
+		mInstances[6] = bs_new<TTiledDeferredLightingMat<4, true>>();
+		mInstances[7] = bs_new<TTiledDeferredLightingMat<8, true>>();
 	}
 
-    template<int MSAA_COUNT, bool FixedReflColor>
-    void TTiledDeferredLightingMat<MSAA_COUNT, FixedReflColor>::setSkyReflections(const SPtr<Texture>& skyReflections)
+	TiledDeferredLightingMaterials::~TiledDeferredLightingMaterials()
 	{
-        mInternal.setSkyReflections(skyReflections);
+		for (UINT32 i = 0; i < 8; i++)
+			bs_delete(mInstances[i]);
 	}
 
-    TiledDeferredLightingMaterials::TiledDeferredLightingMaterials()
-    {
-        mInstances[0] = bs_new<TTiledDeferredLightingMat<1, false>>();
-        mInstances[1] = bs_new<TTiledDeferredLightingMat<2, false>>();
-        mInstances[2] = bs_new<TTiledDeferredLightingMat<4, false>>();
-        mInstances[3] = bs_new<TTiledDeferredLightingMat<8, false>>();
-
-        mInstances[4] = bs_new<TTiledDeferredLightingMat<1, true>>();
-        mInstances[5] = bs_new<TTiledDeferredLightingMat<2, true>>();
-        mInstances[6] = bs_new<TTiledDeferredLightingMat<4, true>>();
-        mInstances[7] = bs_new<TTiledDeferredLightingMat<8, true>>();
-    }
-
-    TiledDeferredLightingMaterials::~TiledDeferredLightingMaterials()
-    {
-        for (UINT32 i = 0; i < 8; i++)
-            bs_delete(mInstances[i]);
-    }
-
-    ITiledDeferredLightingMat* TiledDeferredLightingMaterials::get(UINT32 msaa, bool fixedReflColor)
-    {
-        if(!fixedReflColor)
-        {
-            if (msaa == 1)
-                return mInstances[0];
-            else if (msaa == 2)
-                return mInstances[1];
-            else if (msaa == 4)
-                return mInstances[2];
-            else
-                return mInstances[3];
-        }
-        else
-        {
-            if (msaa == 1)
-                return mInstances[4];
-            else if (msaa == 2)
-                return mInstances[5];
-            else if (msaa == 4)
-                return mInstances[6];
-            else
-                return mInstances[7];
-        }
-    }
+	ITiledDeferredLightingMat* TiledDeferredLightingMaterials::get(UINT32 msaa, bool fixedReflColor)
+	{
+		if (!fixedReflColor)
+		{
+			if (msaa == 1)
+				return mInstances[0];
+			else if (msaa == 2)
+				return mInstances[1];
+			else if (msaa == 4)
+				return mInstances[2];
+			else
+				return mInstances[3];
+		}
+		else
+		{
+			if (msaa == 1)
+				return mInstances[4];
+			else if (msaa == 2)
+				return mInstances[5];
+			else if (msaa == 4)
+				return mInstances[6];
+			else
+				return mInstances[7];
+		}
+	}
 
 	FlatFramebufferToTextureParamDef gFlatFramebufferToTextureParamDef;