Renamed FSAA->multisampling

CamelotCore/Include/CmRenderTarget.h

@@ -64,16 +64,16 @@ namespace BansheeEngine
 		UINT32 getColorDepth() const { return mColorDepth; }
 
 		/**
-		 * @brief	Returns full screen antialiasing amount. Meaning of this value
-		 *			depends on anti-aliasing type used.
+		 * @brief	Gets the number of samples used for multisampling.
+		 *			(0 if multisampling is not used).
 		 */
-		UINT32 getFSAA() const { return mFSAA; }
+		UINT32 getMultisampleCount() const { return mMultisampleCount; }
 
 		/**
-		 * @brief	Returns a hint used for telling render system what type of 
-		 *			antialiasing to use.
+		 * @brief	Get a render-system specific hint used for determining
+		 *			multisampling type.
 		 */
-		const String& getFSAAHint() const { return mFSAAHint; }
+		const String& getMultisampleHint() const { return mMultisampleHint; }
 
 		/**
 		 * @brief	Returns true if the render target will wait for vertical sync 
@@ -170,7 +170,7 @@ namespace BansheeEngine
         bool mActive;
 		bool mHwGamma;
 		bool mVSync;
-		UINT32 mFSAA;
-		String mFSAAHint;
+		UINT32 mMultisampleCount;
+		String mMultisampleHint;
     };
 }

CamelotCore/Include/CmRenderTexture.h

@@ -34,14 +34,14 @@ namespace BansheeEngine
 		 * @param	height				Height of the render texture, in pixels.
 		 * @param	format				Pixel format used by the texture color surface.
 		 * @param	hwGamma				Should the written pixels be gamma corrected.
-		 * @param	fsaa				Amount of full screen anti-aliasing the render texture supports.
-		 * @param	fsaaHint			Hint about what type of anti-aliasing the render texture supports.
+		 * @param	multisampleCount	If higher than 1, texture containing multiple samples per pixel is created.
+		 * @param	multisampleHint		Hint about what kind of multisampling to use. Render system specific.
 		 * @param	createDepth			Should a depth/stencil surface be created along with the color surface.
 		 * @param	depthStencilFormat	Format used by the depth stencil surface, if one is created.
 		 */
 		static RenderTexturePtr create(TextureType textureType, UINT32 width, UINT32 height, 
-			PixelFormat format = PF_R8G8B8A8, bool hwGamma = false, UINT32 fsaa = 0, const String& fsaaHint = "", 
-			bool createDepth = true, PixelFormat depthStencilFormat = PF_D24S8);
+			PixelFormat format = PF_R8G8B8A8, bool hwGamma = false, UINT32 multisampleCount = 0, 
+			const String& multisampleHint = "", bool createDepth = true, PixelFormat depthStencilFormat = PF_D24S8);
 
 		/**
 		 * @copydoc RenderTarget::isWindow.

CamelotCore/Include/CmRenderWindow.h

@@ -26,7 +26,7 @@ namespace BansheeEngine
 			:width(0), height(0), fullscreen(false)
 			, vsync(false), vsyncInterval(1), hidden(false)
 			, displayFrequency(60), colorDepth(32), depthBuffer(true)
-			, FSAA(0), FSAAHint(""), gamma(false), left(-1), top(-1)
+			, multisampleCount(0), multisampleHint(""), gamma(false), left(-1), top(-1)
 			, title(""), border(WindowBorder::Normal), outerDimensions(false), enableDoubleClick(true)
 			, monitorIndex(-1), toolWindow(false), modal(false)
 		{ }
@@ -40,8 +40,8 @@ namespace BansheeEngine
 		UINT32 displayFrequency; /**< Display frequency of the screen to use in hertz. */
 		UINT32 colorDepth; /**< Depth of the color buffer in bits. This is the size of a single pixel in color buffer. */
 		bool depthBuffer; /**< Should the window be created with a depth/stencil buffer. */
-		UINT32 FSAA; /**< Amount of full-screen anti-aliasing. Usually means number of samples per pixel. */
-		String FSAAHint; /**< Hint to the render system as to which anti-aliasing method to use. */
+		UINT32 multisampleCount; /**< If higher than 1, texture containing multiple samples per pixel is created. */
+		String multisampleHint; /**< Hint about what kind of multisampling to use. Render system specific. */
 		bool gamma; /**< Should the written color pixels be gamma corrected before write. */
 		INT32 left; /**< Window origin on X axis in pixels. -1 == screen center. */
 		INT32 top; /**< Window origin on Y axis in pixels. -1 == screen center. */

CamelotCore/Include/CmTexture.h

@@ -72,18 +72,20 @@ namespace BansheeEngine
 		virtual bool isHardwareGammaEnabled() const { return mHwGamma; }
 
 		/**
-		 * @brief	Get the level of multisample AA to be used.
+		 * @brief	Gets the number of samples used for multisampling.
+		 *			(0 if multisampling is not used).
 		 *
 		 * @note	Thread safe.
 		 */
-		virtual UINT32 getFSAA() const { return mFSAA; }
+		virtual UINT32 getMultisampleCount() const { return mMultisampleCount; }
 
 		/**
-		 * @brief	Get the multisample AA hint.
+		 * @brief	Get a render-system specific hint used for determining
+		 *			multisampling type.
 		 *
 		 * @note	Thread safe.
 		 */
-		virtual const String& getFSAAHint() const { return mFSAAHint; }
+		virtual const String& getMultisampleHint() const { return mMultisampleHint; }
 
         /**
          * @brief	Returns the height of the texture.
@@ -280,12 +282,12 @@ namespace BansheeEngine
 		 * @param	usage				Describes how we plan on using the texture in the pipeline.
 		 * @param	hwGammaCorrection	If true the texture data is assumed to have been gamma corrected and will be
 		 *								converted back to linear space when sampled on GPU.
-		 * @param	fsaa				If higher than 1, texture containing multiple samples per pixel is created.
-		 * @param	fsaaHint			Hint about what kind of multisampling to use. Render system specific.
+		 * @param	multisampleCount	If higher than 1, texture containing multiple samples per pixel is created.
+		 * @param	multisampleHint		Hint about what kind of multisampling to use. Render system specific.
 		 */
 		static HTexture create(TextureType texType, UINT32 width, UINT32 height, UINT32 depth,
 			int numMips, PixelFormat format, int usage = TU_DEFAULT,
-			bool hwGammaCorrection = false, UINT32 fsaa = 0, const String& fsaaHint = StringUtil::BLANK);
+			bool hwGammaCorrection = false, UINT32 multisampleCount = 0, const String& multisampleHint = StringUtil::BLANK);
 
 
 		/**
@@ -299,12 +301,12 @@ namespace BansheeEngine
 		 * @param	usage				Describes how we plan on using the texture in the pipeline.
 		 * @param	hwGammaCorrection	If true the texture data is assumed to have been gamma corrected and will be
 		 *								converted back to linear space when sampled on GPU.
-		 * @param	fsaa				If higher than 1, texture containing multiple samples per pixel is created.
-		 * @param	fsaaHint			Hint about what kind of multisampling to use. Render system specific.
+		 * @param	multisampleCount	If higher than 1, texture containing multiple samples per pixel is created.
+		 * @param	multisampleHint		Hint about what kind of multisampling to use. Render system specific.
 		 */
 		static HTexture create(TextureType texType, UINT32 width, UINT32 height, int numMips,
 			PixelFormat format, int usage = TU_DEFAULT,
-			bool hwGammaCorrection = false, UINT32 fsaa = 0, const String& fsaaHint = StringUtil::BLANK);
+			bool hwGammaCorrection = false, UINT32 multisampleCount = 0, const String& multisampleHint = StringUtil::BLANK);
 
 		/**
 		 * @copydoc	create
@@ -313,7 +315,7 @@ namespace BansheeEngine
 		 */
 		static TexturePtr _createPtr(TextureType texType, UINT32 width, UINT32 height, UINT32 depth,
 			int num_mips, PixelFormat format, int usage = TU_DEFAULT,
-			bool hwGammaCorrection = false, UINT32 fsaa = 0, const String& fsaaHint = StringUtil::BLANK);
+			bool hwGammaCorrection = false, UINT32 multisampleCount = 0, const String& multisampleHint = StringUtil::BLANK);
 
 		/**
 		 * @copydoc	create
@@ -322,7 +324,7 @@ namespace BansheeEngine
 		 */
 		static TexturePtr _createPtr(TextureType texType, UINT32 width, UINT32 height, int num_mips,
 			PixelFormat format, int usage = TU_DEFAULT,
-			bool hwGammaCorrection = false, UINT32 fsaa = 0, const String& fsaaHint = StringUtil::BLANK);
+			bool hwGammaCorrection = false, UINT32 multisampleCount = 0, const String& multisampleHint = StringUtil::BLANK);
 
 	protected:
 		/************************************************************************/
@@ -363,7 +365,7 @@ namespace BansheeEngine
 		 * @copydoc	GpuResource::initialize
 		 */
 		void initialize(TextureType textureType, UINT32 width, UINT32 height, UINT32 depth, UINT32 numMipmaps, 
-			PixelFormat format, int usage, bool hwGamma, UINT32 fsaa, const String& fsaaHint);
+			PixelFormat format, int usage, bool hwGamma, UINT32 multisampleCount, const String& multisampleHint);
 
 		/**
 		 * @copydoc	lock
@@ -392,8 +394,8 @@ namespace BansheeEngine
 
 		UINT32 mNumMipmaps; // Immutable
 		bool mHwGamma; // Immutable
-		UINT32 mFSAA; // Immutable
-		String mFSAAHint; // Immutable
+		UINT32 mMultisampleCount; // Immutable
+		String mMultisampleHint; // Immutable
 
 		TextureType mTextureType; // Immutable
 		PixelFormat mFormat; // Immutable

CamelotCore/Include/CmTextureManager.h

@@ -26,17 +26,17 @@ namespace BansheeEngine
 		 */
         TexturePtr createTexture(TextureType texType, UINT32 width, UINT32 height, UINT32 depth, 
 			int numMips, PixelFormat format, int usage = TU_DEFAULT, bool hwGammaCorrection = false, 
-			UINT32 fsaa = 0, const String& fsaaHint = StringUtil::BLANK);
+			UINT32 multisampleCount = 0, const String& multisampleHint = StringUtil::BLANK);
 			
 		/**
 		 * @copydoc	Texture::create(TextureType, UINT32, UINT32, int, PixelFormat, int, bool, UINT32, const String&)
 		 */
 		TexturePtr createTexture(TextureType texType, UINT32 width, UINT32 height, int numMips,
-            PixelFormat format, int usage = TU_DEFAULT, bool hwGammaCorrection = false, UINT32 fsaa = 0, 
-			const String& fsaaHint = StringUtil::BLANK)
+			PixelFormat format, int usage = TU_DEFAULT, bool hwGammaCorrection = false, UINT32 multisampleCount = 0,
+			const String& multisampleHint = StringUtil::BLANK)
 		{
 			return createTexture(texType, width, height, 1, 
-				numMips, format, usage, hwGammaCorrection, fsaa, fsaaHint);
+				numMips, format, usage, hwGammaCorrection, multisampleCount, multisampleHint);
 		}
 
 		/**
@@ -57,15 +57,15 @@ namespace BansheeEngine
 		 * @param	format				Format of the pixels.
 		 * @param	hwGamma				If true, any color data will be gamma corrected before being written
 		 *								into the texture.
-		 * @param	fsaa				If higher than 1, texture containing multiple samples per pixel is created.
-		 * @param	fsaaHint			Hint about what kind of multisampling to use. Render system specific.
+		 * @param	multisampleCount	If higher than 1, texture containing multiple samples per pixel is created.
+		 * @param	multisampleHint		Hint about what kind of multisampling to use. Render system specific.
 		 * @param	createDepth			Determines will a depth/stencil buffer of the same size as the color buffer be created
 		 *								for the render texture.
 		 * @param	depthStencilFormat	Format of the depth/stencil buffer if enabled.
 		 */
 		virtual RenderTexturePtr createRenderTexture(TextureType textureType, UINT32 width, UINT32 height, 
-			PixelFormat format = PF_R8G8B8A8, bool hwGamma = false, UINT32 fsaa = 0, const String& fsaaHint = "", 
-			bool createDepth = true, PixelFormat depthStencilFormat = PF_D24S8);
+			PixelFormat format = PF_R8G8B8A8, bool hwGamma = false, UINT32 multisampleCount = 0, 
+			const String& multisampleHint = "", bool createDepth = true, PixelFormat depthStencilFormat = PF_D24S8);
 
 		/**
 		 * @brief	Creates a RenderTexture using the description struct.

CamelotCore/Include/CmTextureRTTI.h

@@ -22,8 +22,8 @@ namespace BansheeEngine
 		CM_SETGET_MEMBER(mDepth, UINT32, Texture)
 		CM_SETGET_MEMBER(mNumMipmaps, UINT32, Texture)
 		CM_SETGET_MEMBER(mHwGamma, bool, Texture)
-		CM_SETGET_MEMBER(mFSAA, UINT32, Texture)
-		CM_SETGET_MEMBER(mFSAAHint, String, Texture)
+		CM_SETGET_MEMBER(mMultisampleCount, UINT32, Texture)
+		CM_SETGET_MEMBER(mMultisampleHint, String, Texture)
 		CM_SETGET_MEMBER(mTextureType, TextureType, Texture)
 		CM_SETGET_MEMBER(mFormat, PixelFormat, Texture)
 		CM_SETGET_MEMBER(mUsage, INT32, Texture)
@@ -75,8 +75,8 @@ namespace BansheeEngine
 			CM_ADD_PLAINFIELD(mDepth, 4, TextureRTTI)
 			CM_ADD_PLAINFIELD(mNumMipmaps, 5, TextureRTTI)
 			CM_ADD_PLAINFIELD(mHwGamma, 6, TextureRTTI)
-			CM_ADD_PLAINFIELD(mFSAA, 7, TextureRTTI)
-			CM_ADD_PLAINFIELD(mFSAAHint, 8, TextureRTTI)
+			CM_ADD_PLAINFIELD(mMultisampleCount, 7, TextureRTTI)
+			CM_ADD_PLAINFIELD(mMultisampleHint, 8, TextureRTTI)
 			CM_ADD_PLAINFIELD(mTextureType, 9, TextureRTTI)
 			CM_ADD_PLAINFIELD(mFormat, 10, TextureRTTI)
 			CM_ADD_PLAINFIELD(mUsage, 11, TextureRTTI)
@@ -103,7 +103,7 @@ namespace BansheeEngine
 			// in mRTTIData.
 			texture->initialize(texture->getTextureType(), texture->getWidth(), texture->getHeight(), texture->getDepth(), 
 				texture->getNumMipmaps(), texture->getFormat(), texture->getUsage(), texture->isHardwareGammaEnabled(), 
-				texture->getFSAA(), texture->getFSAAHint());
+				texture->getMultisampleCount(), texture->getMultisampleHint());
 
 			Vector<PixelDataPtr>* pixelData = any_cast<Vector<PixelDataPtr>*>(texture->mRTTIData);
 			for(size_t i = 0; i < pixelData->size(); i++)

CamelotCore/Source/CmMultiRenderTexture.cpp

@@ -45,8 +45,8 @@ namespace BansheeEngine
 					mColorDepth = BansheeEngine::PixelUtil::getNumElemBits(texture->getFormat());
 					mActive = true;
 					mHwGamma = texture->isHardwareGammaEnabled();
-					mFSAA = texture->getFSAA();
-					mFSAAHint = texture->getFSAAHint();
+					mMultisampleCount = texture->getMultisampleCount();
+					mMultisampleHint = texture->getMultisampleHint();
 
 					colorSurfacePropertiesSet = true;
 				}
@@ -99,13 +99,13 @@ namespace BansheeEngine
 
 			if(mColorSurfaces[i]->getTexture()->getWidth() != firstSurfaceDesc->getTexture()->getWidth() ||
 				mColorSurfaces[i]->getTexture()->getHeight() != firstSurfaceDesc->getTexture()->getHeight() ||
-				mColorSurfaces[i]->getTexture()->getFSAA() != firstSurfaceDesc->getTexture()->getFSAA() ||
-				mColorSurfaces[i]->getTexture()->getFSAAHint() != firstSurfaceDesc->getTexture()->getFSAAHint())
+				mColorSurfaces[i]->getTexture()->getMultisampleCount() != firstSurfaceDesc->getTexture()->getMultisampleCount() ||
+				mColorSurfaces[i]->getTexture()->getMultisampleHint() != firstSurfaceDesc->getTexture()->getMultisampleHint())
 			{
 				String errorInfo = "\nWidth: " + toString(mColorSurfaces[i]->getTexture()->getWidth()) + "/" + toString(firstSurfaceDesc->getTexture()->getWidth());
 				errorInfo += "\nHeight: " + toString(mColorSurfaces[i]->getTexture()->getHeight()) + "/" + toString(firstSurfaceDesc->getTexture()->getHeight());
-				errorInfo += "\nFSAA: " + toString(mColorSurfaces[i]->getTexture()->getFSAA()) + "/" + toString(firstSurfaceDesc->getTexture()->getFSAA());
-				errorInfo += "\nFSAAHint: " + mColorSurfaces[i]->getTexture()->getFSAAHint() + "/" + firstSurfaceDesc->getTexture()->getFSAAHint();
+				errorInfo += "\nMultisample Count: " + toString(mColorSurfaces[i]->getTexture()->getMultisampleCount()) + "/" + toString(firstSurfaceDesc->getTexture()->getMultisampleCount());
+				errorInfo += "\nMultisample Hint: " + mColorSurfaces[i]->getTexture()->getMultisampleHint() + "/" + firstSurfaceDesc->getTexture()->getMultisampleHint();
 
 				CM_EXCEPT(InvalidParametersException, "Provided texture and depth stencil buffer don't match!" + errorInfo);
 			}
@@ -134,13 +134,13 @@ namespace BansheeEngine
 
 		if(mDepthStencilSurface->getTexture()->getWidth() != firstSurfaceDesc->getTexture()->getWidth() ||
 			mDepthStencilSurface->getTexture()->getHeight() != firstSurfaceDesc->getTexture()->getHeight() ||
-			mDepthStencilSurface->getTexture()->getFSAA() != firstSurfaceDesc->getTexture()->getFSAA() ||
-			mDepthStencilSurface->getTexture()->getFSAAHint() != firstSurfaceDesc->getTexture()->getFSAAHint())
+			mDepthStencilSurface->getTexture()->getMultisampleCount() != firstSurfaceDesc->getTexture()->getMultisampleCount() ||
+			mDepthStencilSurface->getTexture()->getMultisampleHint() != firstSurfaceDesc->getTexture()->getMultisampleHint())
 		{
 			String errorInfo = "\nWidth: " + toString(mDepthStencilSurface->getTexture()->getWidth()) + "/" + toString(firstSurfaceDesc->getTexture()->getWidth());
 			errorInfo += "\nHeight: " + toString(mDepthStencilSurface->getTexture()->getHeight()) + "/" + toString(firstSurfaceDesc->getTexture()->getHeight());
-			errorInfo += "\nFSAA: " + toString(mDepthStencilSurface->getTexture()->getFSAA()) + "/" + toString(firstSurfaceDesc->getTexture()->getFSAA());
-			errorInfo += "\nFSAAHint: " + mDepthStencilSurface->getTexture()->getFSAAHint() + "/" + firstSurfaceDesc->getTexture()->getFSAAHint();
+			errorInfo += "\nMultisample Count: " + toString(mDepthStencilSurface->getTexture()->getMultisampleCount()) + "/" + toString(firstSurfaceDesc->getTexture()->getMultisampleCount());
+			errorInfo += "\nMultisample Hint: " + mDepthStencilSurface->getTexture()->getMultisampleHint() + "/" + firstSurfaceDesc->getTexture()->getMultisampleHint();
 
 			CM_EXCEPT(InvalidParametersException, "Provided texture and depth stencil buffer don't match!" + errorInfo);
 		}

CamelotCore/Source/CmRenderTarget.cpp

@@ -6,7 +6,7 @@
 namespace BansheeEngine 
 {
     RenderTarget::RenderTarget()
-		:mActive(true), mHwGamma(false), mVSync(false), mFSAA(0),
+		:mActive(true), mHwGamma(false), mVSync(false), mMultisampleCount(0),
 		mWidth(0), mHeight(0), mColorDepth(0), mPriority(0)
     {
     }

CamelotCore/Source/CmRenderTexture.cpp

@@ -19,10 +19,11 @@ namespace BansheeEngine
 	}
 
 	RenderTexturePtr RenderTexture::create(TextureType textureType, UINT32 width, UINT32 height, 
-		PixelFormat format, bool hwGamma, UINT32 fsaa, const String& fsaaHint, 
+		PixelFormat format, bool hwGamma, UINT32 multisampleCount, const String& multisampleHint, 
 		bool createDepth, PixelFormat depthStencilFormat)
 	{
-		return TextureManager::instance().createRenderTexture(textureType, width, height, format, hwGamma, fsaa, fsaaHint, createDepth, depthStencilFormat);
+		return TextureManager::instance().createRenderTexture(textureType, width, height, format, hwGamma, 
+			multisampleCount, multisampleHint, createDepth, depthStencilFormat);
 	}
 
 	void RenderTexture::destroy_internal()
@@ -53,8 +54,8 @@ namespace BansheeEngine
 			mColorDepth = BansheeEngine::PixelUtil::getNumElemBits(texture->getFormat());
 			mActive = true;
 			mHwGamma = texture->isHardwareGammaEnabled();
-			mFSAA = texture->getFSAA();
-			mFSAAHint = texture->getFSAAHint();
+			mMultisampleCount = texture->getMultisampleCount();
+			mMultisampleHint = texture->getMultisampleHint();
 		}
 
 		if(desc.depthStencilSurface.texture != nullptr)
@@ -107,13 +108,13 @@ namespace BansheeEngine
 
 		if(mColorSurface->getTexture()->getWidth() != mDepthStencilSurface->getTexture()->getWidth() ||
 			mColorSurface->getTexture()->getHeight() != mDepthStencilSurface->getTexture()->getHeight() ||
-			mColorSurface->getTexture()->getFSAA() != mDepthStencilSurface->getTexture()->getFSAA() ||
-			mColorSurface->getTexture()->getFSAAHint() != mDepthStencilSurface->getTexture()->getFSAAHint())
+			mColorSurface->getTexture()->getMultisampleCount() != mDepthStencilSurface->getTexture()->getMultisampleCount() ||
+			mColorSurface->getTexture()->getMultisampleHint() != mDepthStencilSurface->getTexture()->getMultisampleHint())
 		{
 			String errorInfo = "\nWidth: " + toString(mColorSurface->getTexture()->getWidth()) + "/" + toString(mDepthStencilSurface->getTexture()->getWidth());
 			errorInfo += "\nHeight: " + toString(mColorSurface->getTexture()->getHeight()) + "/" + toString(mDepthStencilSurface->getTexture()->getHeight());
-			errorInfo += "\nFSAA: " + toString(mColorSurface->getTexture()->getFSAA()) + "/" + toString(mDepthStencilSurface->getTexture()->getFSAA());
-			errorInfo += "\nFSAAHint: " + mColorSurface->getTexture()->getFSAAHint() + "/" + mDepthStencilSurface->getTexture()->getFSAAHint();
+			errorInfo += "\nMultisample Count: " + toString(mColorSurface->getTexture()->getMultisampleCount()) + "/" + toString(mDepthStencilSurface->getTexture()->getMultisampleCount());
+			errorInfo += "\nMultisample Hint: " + mColorSurface->getTexture()->getMultisampleHint() + "/" + mDepthStencilSurface->getTexture()->getMultisampleHint();
 
 			CM_EXCEPT(InvalidParametersException, "Provided texture and depth stencil buffer don't match!" + errorInfo);
 		}

CamelotCore/Source/CmTexture.cpp

@@ -12,14 +12,14 @@ namespace BansheeEngine
 {
     Texture::Texture()
         :mHeight(32), mWidth(32), mDepth(1), mNumMipmaps(0),
-		 mHwGamma(false), mFSAA(0), mTextureType(TEX_TYPE_2D), 
+		 mHwGamma(false), mMultisampleCount(0), mTextureType(TEX_TYPE_2D), 
 		 mFormat(PF_UNKNOWN), mUsage(TU_DEFAULT)
     {
         
     }
 
 	void Texture::initialize(TextureType textureType, UINT32 width, UINT32 height, UINT32 depth, UINT32 numMipmaps, 
-		PixelFormat format, int usage, bool hwGamma, UINT32 fsaa, const String& fsaaHint)
+		PixelFormat format, int usage, bool hwGamma, UINT32 multisampleCount, const String& multisampleHint)
 	{
 		mTextureType = textureType;
 		mWidth = width;
@@ -28,8 +28,8 @@ namespace BansheeEngine
 		mNumMipmaps = numMipmaps;
 		mUsage = usage;
 		mHwGamma = hwGamma;
-		mFSAA = fsaa;
-		mFSAAHint = fsaaHint;
+		mMultisampleCount = multisampleCount;
+		mMultisampleHint = multisampleHint;
 
 		// Adjust format if required
 		mFormat = TextureManager::instance().getNativeFormat(mTextureType, format, mUsage);
@@ -293,35 +293,35 @@ namespace BansheeEngine
 	/* 								STATICS	                      			*/
 	/************************************************************************/
 	HTexture Texture::create(TextureType texType, UINT32 width, UINT32 height, UINT32 depth, 
-		int num_mips, PixelFormat format, int usage, bool hwGammaCorrection, UINT32 fsaa, const String& fsaaHint)
+		int num_mips, PixelFormat format, int usage, bool hwGammaCorrection, UINT32 multisampleCount, const String& multisampleHint)
 	{
 		TexturePtr texturePtr = _createPtr(texType, 
-			width, height, depth, num_mips, format, usage, hwGammaCorrection, fsaa, fsaaHint);
+			width, height, depth, num_mips, format, usage, hwGammaCorrection, multisampleCount, multisampleHint);
 
 		return static_resource_cast<Texture>(gResources()._createResourceHandle(texturePtr));
 	}
 	
 	HTexture Texture::create(TextureType texType, UINT32 width, UINT32 height, 
-		int num_mips, PixelFormat format, int usage, bool hwGammaCorrection, UINT32 fsaa, const String& fsaaHint)
+		int num_mips, PixelFormat format, int usage, bool hwGammaCorrection, UINT32 multisampleCount, const String& multisampleHint)
 	{
 		TexturePtr texturePtr = _createPtr(texType, 
-			width, height, num_mips, format, usage, hwGammaCorrection, fsaa, fsaaHint);
+			width, height, num_mips, format, usage, hwGammaCorrection, multisampleCount, multisampleHint);
 
 		return static_resource_cast<Texture>(gResources()._createResourceHandle(texturePtr));
 	}
 
 	TexturePtr Texture::_createPtr(TextureType texType, UINT32 width, UINT32 height, UINT32 depth, 
-		int num_mips, PixelFormat format, int usage, bool hwGammaCorrection, UINT32 fsaa, const String& fsaaHint)
+		int num_mips, PixelFormat format, int usage, bool hwGammaCorrection, UINT32 multisampleCount, const String& multisampleHint)
 	{
 		return TextureManager::instance().createTexture(texType, 
-			width, height, depth, num_mips, format, usage, hwGammaCorrection, fsaa, fsaaHint);
+			width, height, depth, num_mips, format, usage, hwGammaCorrection, multisampleCount, multisampleHint);
 	}
 
 	TexturePtr Texture::_createPtr(TextureType texType, UINT32 width, UINT32 height, 
-		int num_mips, PixelFormat format, int usage, bool hwGammaCorrection, UINT32 fsaa, const String& fsaaHint)
+		int num_mips, PixelFormat format, int usage, bool hwGammaCorrection, UINT32 multisampleCount, const String& multisampleHint)
 	{
 		return TextureManager::instance().createTexture(texType, 
-			width, height, num_mips, format, usage, hwGammaCorrection, fsaa, fsaaHint);
+			width, height, num_mips, format, usage, hwGammaCorrection, multisampleCount, multisampleHint);
 	}
 
 	const HTexture& Texture::dummy()

CamelotCore/Source/CmTextureManager.cpp

@@ -37,12 +37,11 @@ namespace BansheeEngine
 	}
 
     TexturePtr TextureManager::createTexture(TextureType texType, UINT32 width, UINT32 height, UINT32 depth, int numMipmaps,
-        PixelFormat format, int usage, bool hwGamma, 
-		UINT32 fsaa, const String& fsaaHint)
+        PixelFormat format, int usage, bool hwGamma, UINT32 multisampleCount, const String& multisampleHint)
     {
         TexturePtr ret = createTextureImpl();
 		ret->_setThisPtr(ret);
-		ret->initialize(texType, width, height, depth, static_cast<size_t>(numMipmaps), format, usage, hwGamma, fsaa, fsaaHint);
+		ret->initialize(texType, width, height, depth, static_cast<size_t>(numMipmaps), format, usage, hwGamma, multisampleCount, multisampleHint);
 
 		return ret;
     }
@@ -56,15 +55,15 @@ namespace BansheeEngine
 	}
 
 	RenderTexturePtr TextureManager::createRenderTexture(TextureType textureType, UINT32 width, UINT32 height, 
-			PixelFormat format, bool hwGamma, UINT32 fsaa, const String& fsaaHint, 
+			PixelFormat format, bool hwGamma, UINT32 multisampleCount, const String& multisampleHint, 
 			bool createDepth, PixelFormat depthStencilFormat)
 	{
-		TexturePtr texture = createTexture(textureType, width, height, 0, format, TU_RENDERTARGET, hwGamma, fsaa, fsaaHint);
+		TexturePtr texture = createTexture(textureType, width, height, 0, format, TU_RENDERTARGET, hwGamma, multisampleCount, multisampleHint);
 
 		TexturePtr depthStencil = nullptr;
 		if(createDepth)
 		{
-			depthStencil = createTexture(TEX_TYPE_2D, width, height, 0, depthStencilFormat, TU_DEPTHSTENCIL, false, fsaa, fsaaHint);
+			depthStencil = createTexture(TEX_TYPE_2D, width, height, 0, depthStencilFormat, TU_DEPTHSTENCIL, false, multisampleCount, multisampleHint);
 		}
 
 		RENDER_TEXTURE_DESC desc;

CamelotD3D11RenderSystem/Include/CmD3D11RenderSystem.h

@@ -80,7 +80,7 @@ namespace BansheeEngine
 		/* 				Internal use by DX11 RenderSystem only                  */
 		/************************************************************************/
 
-		void determineFSAASettings(UINT32 fsaa, const String& fsaaHint, DXGI_FORMAT format, DXGI_SAMPLE_DESC* outFSAASettings);
+		void determineMultisampleSettings(UINT32 multisampleCount, const String& multisampleHint, DXGI_FORMAT format, DXGI_SAMPLE_DESC* outputSampleDesc);
 		bool checkTextureFilteringSupported(TextureType ttype, PixelFormat format, int usage);
 
 		IDXGIFactory* getDXGIFactory() const { return mDXGIFactory; }

CamelotD3D11RenderSystem/Include/CmD3D11RenderWindow.h

@@ -121,7 +121,7 @@ namespace BansheeEngine
 		bool mClosed;
 		bool mIsChild;
 
-		DXGI_SAMPLE_DESC mFSAAType;
+		DXGI_SAMPLE_DESC mMultisampleType;
 		bool mVSync;
 		UINT32 mVSyncInterval;
 

CamelotD3D11RenderSystem/Source/CmD3D11RenderSystem.cpp

@@ -881,18 +881,18 @@ namespace BansheeEngine
 		// Do nothing
 	}
 
-	void D3D11RenderSystem::determineFSAASettings(UINT32 fsaa, const String& fsaaHint, DXGI_FORMAT format, DXGI_SAMPLE_DESC* outFSAASettings)
+	void D3D11RenderSystem::determineMultisampleSettings(UINT32 multisampleCount, const String& multisampleHint, DXGI_FORMAT format, DXGI_SAMPLE_DESC* outputSampleDesc)
 	{
 		bool ok = false;
-		bool qualityHint = fsaaHint.find("Quality") != String::npos;
-		size_t origFSAA = fsaa;
+		bool qualityHint = multisampleHint.find("Quality") != String::npos;
+		size_t origCount = multisampleCount;
 		bool tryCSAA = false;
 		// NVIDIA, prefer CSAA if available for 8+
 		// it would be tempting to use getCapabilities()->getVendor() == GPU_NVIDIA but
 		// if this is the first window, caps will not be initialised yet
 		
 		if (mActiveD3DDriver->getAdapterIdentifier().VendorId == 0x10DE && 
-			fsaa >= 8)
+			multisampleCount >= 8)
 		{
 			tryCSAA	 = true;
 		}
@@ -903,53 +903,53 @@ namespace BansheeEngine
 			if (tryCSAA)
 			{
 				// see http://developer.nvidia.com/object/coverage-sampled-aa.html
-				switch(fsaa)
+				switch(multisampleCount)
 				{
 				case 8:
 					if (qualityHint)
 					{
-						outFSAASettings->Count = 8;
-						outFSAASettings->Quality = 8;
+						outputSampleDesc->Count = 8;
+						outputSampleDesc->Quality = 8;
 					}
 					else
 					{
-						outFSAASettings->Count = 4;
-						outFSAASettings->Quality = 8;
+						outputSampleDesc->Count = 4;
+						outputSampleDesc->Quality = 8;
 					}
 					break;
 				case 16:
 					if (qualityHint)
 					{
-						outFSAASettings->Count = 8;
-						outFSAASettings->Quality = 16;
+						outputSampleDesc->Count = 8;
+						outputSampleDesc->Quality = 16;
 					}
 					else
 					{
-						outFSAASettings->Count = 4;
-						outFSAASettings->Quality = 16;
+						outputSampleDesc->Count = 4;
+						outputSampleDesc->Quality = 16;
 					}
 					break;
 				}
 			}
 			else // !CSAA
 			{
-				outFSAASettings->Count = fsaa == 0 ? 1 : fsaa;
-				outFSAASettings->Quality = 0;
+				outputSampleDesc->Count = multisampleCount == 0 ? 1 : multisampleCount;
+				outputSampleDesc->Quality = 0;
 			}
 
 
 			HRESULT hr;
 			UINT outQuality;
-			hr = mDevice->getD3D11Device()->CheckMultisampleQualityLevels(format, outFSAASettings->Count, &outQuality);
+			hr = mDevice->getD3D11Device()->CheckMultisampleQualityLevels(format, outputSampleDesc->Count, &outQuality);
 
-			if (SUCCEEDED(hr) && (!tryCSAA || outQuality > outFSAASettings->Quality))
+			if (SUCCEEDED(hr) && (!tryCSAA || outQuality > outputSampleDesc->Quality))
 			{
 				ok = true;
 			}
 			else
 			{
 				// downgrade
-				if (tryCSAA && fsaa == 8)
+				if (tryCSAA && multisampleCount == 8)
 				{
 					// for CSAA, we'll try downgrading with quality mode at all samples.
 					// then try without quality, then drop CSAA
@@ -964,17 +964,17 @@ namespace BansheeEngine
 						tryCSAA = false;
 					}
 					// return to original requested samples
-					fsaa = static_cast<UINT32>(origFSAA);
+					multisampleCount = static_cast<UINT32>(origCount);
 				}
 				else
 				{
 					// drop samples
-					--fsaa;
+					--multisampleCount;
 
-					if (fsaa == 1)
+					if (multisampleCount == 1)
 					{
-						// ran out of options, no FSAA
-						fsaa = 0;
+						// ran out of options, no multisampling
+						multisampleCount = 0;
 						ok = true;
 					}
 				}

CamelotD3D11RenderSystem/Source/CmD3D11RenderWindow.cpp

@@ -37,10 +37,10 @@ namespace BansheeEngine
 
 	void D3D11RenderWindow::initialize_internal()
 	{
-		mFSAAType.Count = 1;
-		mFSAAType.Quality = 0;
-		mFSAA = 0;
-		mFSAAHint = "";
+		mMultisampleType.Count = 1;
+		mMultisampleType.Quality = 0;
+		mMultisampleCount = 0;
+		mMultisampleHint = "";
 		mVSync = false;
 		mVSyncInterval = 1;
 		HWND parentHWnd = 0;
@@ -622,9 +622,9 @@ namespace BansheeEngine
 		mSwapChainDesc.Windowed				= !mIsFullScreen;
 
 		D3D11RenderSystem* rs = static_cast<D3D11RenderSystem*>(RenderSystem::instancePtr());
-		rs->determineFSAASettings(mFSAA, mFSAAHint, format, &mFSAAType);
-		mSwapChainDesc.SampleDesc.Count = mFSAAType.Count;
-		mSwapChainDesc.SampleDesc.Quality = mFSAAType.Quality;
+		rs->determineMultisampleSettings(mMultisampleCount, mMultisampleHint, format, &mMultisampleType);
+		mSwapChainDesc.SampleDesc.Count = mMultisampleType.Count;
+		mSwapChainDesc.SampleDesc.Quality = mMultisampleType.Quality;
 
 		HRESULT hr;
 
@@ -665,7 +665,7 @@ namespace BansheeEngine
 		ZeroMemory( &RTVDesc, sizeof(RTVDesc) );
 
 		RTVDesc.Format = BBDesc.Format;
-		RTVDesc.ViewDimension = mFSAA ? D3D11_RTV_DIMENSION_TEXTURE2DMS : D3D11_RTV_DIMENSION_TEXTURE2D;
+		RTVDesc.ViewDimension = mMultisampleCount ? D3D11_RTV_DIMENSION_TEXTURE2DMS : D3D11_RTV_DIMENSION_TEXTURE2D;
 		RTVDesc.Texture2D.MipSlice = 0;
 		hr = mDevice.getD3D11Device()->CreateRenderTargetView(mBackBuffer, &RTVDesc, &mRenderTargetView);
 
@@ -676,7 +676,7 @@ namespace BansheeEngine
 		}
 
 		mDepthStencilBuffer = TextureManager::instance().createTexture(TEX_TYPE_2D, 
-			BBDesc.Width, BBDesc.Height, 0, PF_D24S8, TU_DEPTHSTENCIL, false, mFSAA, mFSAAHint);
+			BBDesc.Width, BBDesc.Height, 0, PF_D24S8, TU_DEPTHSTENCIL, false, mMultisampleCount, mMultisampleHint);
 
 		if(mDepthStencilView != nullptr)
 		{

CamelotD3D11RenderSystem/Source/CmD3D11Texture.cpp

@@ -313,7 +313,7 @@ namespace BansheeEngine
 
 			DXGI_SAMPLE_DESC sampleDesc;
 			D3D11RenderSystem* rs = static_cast<D3D11RenderSystem*>(RenderSystem::instancePtr());
-			rs->determineFSAASettings(mFSAA, mFSAAHint, d3dPF, &sampleDesc);
+			rs->determineMultisampleSettings(mMultisampleCount, mMultisampleHint, d3dPF, &sampleDesc);
 			desc.SampleDesc		= sampleDesc;
 
 			if(getTextureType() == TEX_TYPE_CUBE_MAP)
@@ -330,7 +330,7 @@ namespace BansheeEngine
 
 			DXGI_SAMPLE_DESC sampleDesc;
 			D3D11RenderSystem* rs = static_cast<D3D11RenderSystem*>(RenderSystem::instancePtr());
-			rs->determineFSAASettings(mFSAA, mFSAAHint, d3dPF, &sampleDesc);
+			rs->determineMultisampleSettings(mMultisampleCount, mMultisampleHint, d3dPF, &sampleDesc);
 			desc.SampleDesc		= sampleDesc;
 
 			if(getTextureType() == TEX_TYPE_CUBE_MAP)
@@ -400,7 +400,7 @@ namespace BansheeEngine
 
 			if((mUsage & TU_RENDERTARGET) != 0)
 			{
-				if(mFSAA > 0)
+				if(mMultisampleCount > 0)
 				{
 					mSRVDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DMS;
 					mSRVDesc.Texture2D.MostDetailedMip = 0;
@@ -442,7 +442,7 @@ namespace BansheeEngine
 		}
 		else
 		{
-			if(mFSAA > 0)
+			if(mMultisampleCount > 0)
 				mDimension = D3D11_SRV_DIMENSION_TEXTURE2DMS;
 			else
 				mDimension = D3D11_SRV_DIMENSION_TEXTURE2D;

CamelotD3D11RenderSystem/Source/CmD3D11TextureView.cpp

@@ -55,7 +55,7 @@ namespace BansheeEngine
 		case TEX_TYPE_2D:
 			desc.Texture2D.MipLevels = numMips;
 			desc.Texture2D.MostDetailedMip = mostDetailMip;
-			if(texture->getFSAA() > 0)
+			if(texture->getMultisampleCount() > 0)
 				desc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DMS;
 			else
 				desc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
@@ -104,7 +104,7 @@ namespace BansheeEngine
 			break;
 		case TEX_TYPE_2D:
 			desc.Texture2D.MipSlice = mostDetailMip;
-			if(texture->getFSAA() > 0)
+			if(texture->getMultisampleCount() > 0)
 				desc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DMS;
 			else
 				desc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D;
@@ -191,7 +191,7 @@ namespace BansheeEngine
 			break;
 		case TEX_TYPE_2D:
 			desc.Texture2D.MipSlice = mostDetailMip;
-			if(texture->getFSAA() > 0)
+			if(texture->getMultisampleCount() > 0)
 				desc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2DMS;
 			else
 				desc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;

CamelotD3D9Renderer/Include/CmD3D9PixelBuffer.h

@@ -28,7 +28,7 @@ namespace BansheeEngine
 
 		/// Call this to associate a D3D surface or volume with this pixel buffer
 		void bind(IDirect3DDevice9* dev, IDirect3DSurface9* mSurface,
-			bool writeGamma, UINT32 fsaa, const String& srcName, IDirect3DBaseTexture9* mipTex);
+			bool writeGamma, UINT32 multisampleCount, const String& srcName, IDirect3DBaseTexture9* mipTex);
 		void bind(IDirect3DDevice9* dev, IDirect3DVolume9* mVolume, IDirect3DBaseTexture9* mipTex);
 		/// Internal function to update mipmaps on update of level 0
 		void genMipmaps(IDirect3DBaseTexture9* mipTex);

CamelotD3D9Renderer/Include/CmD3D9RenderSystem.h

@@ -150,8 +150,7 @@ namespace BansheeEngine
 		static IDirect3DDevice9* getResourceCreationDevice(UINT index);
 		static IDirect3DDevice9* getActiveD3D9Device();
 
-		/// Take in some requested FSAA settings and output supported D3D settings
-		void determineFSAASettings(IDirect3DDevice9* d3d9Device, UINT32 fsaa, const String& fsaaHint, D3DFORMAT d3dPixelFormat, 
+		void determineMultisampleSettings(IDirect3DDevice9* d3d9Device, UINT32 multisampleCount, const String& multisampleHint, D3DFORMAT d3dPixelFormat,
 			bool fullScreen, D3DMULTISAMPLE_TYPE *outMultisampleType, DWORD *outMultisampleQuality) const;
 
 		void registerWindow(RenderWindow& renderWindow);
@@ -203,7 +202,6 @@ namespace BansheeEngine
 
 		/// return anisotropy level
 		DWORD _getCurrentAnisotropy(UINT32 unit);
-		/// check if a FSAA is supported
 		bool _checkMultiSampleQuality(D3DMULTISAMPLE_TYPE type, DWORD *outQuality, D3DFORMAT format, UINT adapterNum, D3DDEVTYPE deviceType, BOOL fullScreen);
 		
         D3D9HLSLProgramFactory* mHLSLProgramFactory;

CamelotD3D9Renderer/Include/CmD3D9RenderWindow.h

@@ -148,8 +148,8 @@ namespace BansheeEngine
 		HWND						mHWnd;					// Win32 Window handle		
 		bool						mIsExternal;			// window not created by Ogre
 		bool						mClosed;				// Is this window destroyed.			
-		D3DMULTISAMPLE_TYPE			mFSAAType;				// AA type.
-		DWORD						mFSAAQuality;			// AA quality.
+		D3DMULTISAMPLE_TYPE			mMultisampleType;		// AA type.
+		DWORD						mMultisampleQuality;	// AA quality.
 		UINT						mDisplayFrequency;		// Display frequency.
 		bool						mVSync;					// Use vertical sync or not.
 		unsigned int				mVSyncInterval;		

CamelotD3D9Renderer/Include/CmD3D9Texture.h

@@ -22,8 +22,8 @@ namespace BansheeEngine
 			IDirect3DVolumeTexture9* pVolumeTex;
 			/// actual texture pointer
 			IDirect3DBaseTexture9* pBaseTex;
-			/// Optional FSAA surface
-			IDirect3DSurface9* pFSAASurface;
+			/// Optional multisample surface
+			IDirect3DSurface9* pMultisampleSurface;
 			/// Optional depth stencil surface
 			IDirect3DSurface9* pDepthStencilSurface;
 		};
@@ -189,7 +189,7 @@ namespace BansheeEngine
 		bool mHwGammaReadSupported;
 		/// Is hardware gamma supported (write)?
 		bool mHwGammaWriteSupported;
-		D3DMULTISAMPLE_TYPE mFSAAType;
-		DWORD mFSAAQuality;
+		D3DMULTISAMPLE_TYPE mMultisampleType;
+		DWORD mMultisampleQuality;
     };
 }

CamelotD3D9Renderer/Source/CmD3D9PixelBuffer.cpp

@@ -103,7 +103,7 @@ namespace BansheeEngine
 	}
 
 	void D3D9PixelBuffer::bind(IDirect3DDevice9* dev, IDirect3DSurface9* surface, bool writeGamma, 
-		UINT32 fsaa, const String& srcName, IDirect3DBaseTexture9* mipTex)
+		UINT32 multisampleCount, const String& srcName, IDirect3DBaseTexture9* mipTex)
 	{
 		D3D9_DEVICE_ACCESS_CRITICAL_SECTION
 

CamelotD3D9Renderer/Source/CmD3D9RenderSystem.cpp

@@ -2254,13 +2254,13 @@ namespace BansheeEngine
 		}
 	}
 
-	void D3D9RenderSystem::determineFSAASettings(IDirect3DDevice9* d3d9Device,
-		UINT32 fsaa, const String& fsaaHint, D3DFORMAT d3dPixelFormat, 
+	void D3D9RenderSystem::determineMultisampleSettings(IDirect3DDevice9* d3d9Device,
+		UINT32 multisampleCount, const String& multisampleHint, D3DFORMAT d3dPixelFormat, 
 		bool fullScreen, D3DMULTISAMPLE_TYPE *outMultisampleType, DWORD *outMultisampleQuality) const
 	{
 		bool ok = false;
-		bool qualityHint = fsaaHint.find("Quality") != String::npos;
-		UINT32 origFSAA = fsaa;
+		bool qualityHint = multisampleHint.find("Quality") != String::npos;
+		UINT32 origCount = multisampleCount;
 
 		D3D9DriverList* driverList = getDirect3DDrivers();
 		D3D9Driver* deviceDriver = mActiveD3DDriver;
@@ -2282,7 +2282,7 @@ namespace BansheeEngine
 		// it would be tempting to use getCapabilities()->getVendor() == GPU_NVIDIA but
 		// if this is the first window, caps will not be initialised yet
 		if (deviceDriver->getAdapterIdentifier().VendorId == 0x10DE && 
-			fsaa >= 8)
+			multisampleCount >= 8)
 		{
 			tryCSAA	 = true;
 		}
@@ -2293,7 +2293,7 @@ namespace BansheeEngine
 			if (tryCSAA)
 			{
 				// see http://developer.nvidia.com/object/coverage-sampled-aa.html
-				switch(fsaa)
+				switch(multisampleCount)
 				{
 				case 8:
 					if (qualityHint)
@@ -2323,7 +2323,7 @@ namespace BansheeEngine
 			}
 			else // !CSAA
 			{
-				*outMultisampleType = (D3DMULTISAMPLE_TYPE)fsaa;
+				*outMultisampleType = (D3DMULTISAMPLE_TYPE)multisampleCount;
 				*outMultisampleQuality = 0;
 			}
 
@@ -2346,7 +2346,7 @@ namespace BansheeEngine
 			else
 			{
 				// downgrade
-				if (tryCSAA && fsaa == 8)
+				if (tryCSAA && multisampleCount == 8)
 				{
 					// for CSAA, we'll try downgrading with quality mode at all samples.
 					// then try without quality, then drop CSAA
@@ -2361,17 +2361,17 @@ namespace BansheeEngine
 						tryCSAA = false;
 					}
 					// return to original requested samples
-					fsaa = origFSAA;
+					multisampleCount = origCount;
 				}
 				else
 				{
 					// drop samples
-					--fsaa;
+					--multisampleCount;
 
-					if (fsaa == 1)
+					if (multisampleCount == 1)
 					{
-						// ran out of options, no FSAA
-						fsaa = 0;
+						// ran out of options, no multisampling
+						multisampleCount = 0;
 						ok = true;
 					}
 				}

CamelotD3D9Renderer/Source/CmD3D9RenderWindow.cpp

@@ -32,9 +32,9 @@ namespace BansheeEngine
 	{
 		HINSTANCE hInst = mInstance;
 
-		mFSAAType = D3DMULTISAMPLE_NONE;
-		mFSAAQuality = 0;
-		mFSAA = mDesc.FSAA;
+		mMultisampleType = D3DMULTISAMPLE_NONE;
+		mMultisampleQuality = 0;
+		mMultisampleCount = mDesc.multisampleCount;
 		mVSync = mDesc.vsync;
 		mVSyncInterval = mDesc.vsyncInterval;
 
@@ -630,15 +630,15 @@ namespace BansheeEngine
 
 		D3D9RenderSystem* rsys = static_cast<D3D9RenderSystem*>(BansheeEngine::RenderSystem::instancePtr());
 
-		D3DMULTISAMPLE_TYPE fsaaType;
-		DWORD fsaaQuality;
+		D3DMULTISAMPLE_TYPE multisampleType;
+		DWORD multisampleQuality;
 
-		rsys->determineFSAASettings(mDevice->getD3D9Device(),
-			mFSAA, mFSAAHint, presentParams->BackBufferFormat, mIsFullScreen, 
-			&fsaaType, &fsaaQuality);
+		rsys->determineMultisampleSettings(mDevice->getD3D9Device(),
+			mMultisampleCount, mMultisampleHint, presentParams->BackBufferFormat, mIsFullScreen, 
+			&multisampleType, &multisampleQuality);
 
-		presentParams->MultiSampleType = fsaaType;
-		presentParams->MultiSampleQuality = (fsaaQuality == 0) ? 0 : fsaaQuality;
+		presentParams->MultiSampleType = multisampleType;
+		presentParams->MultiSampleQuality = (multisampleQuality == 0) ? 0 : multisampleQuality;
 	}
 
 	IDirect3DDevice9* D3D9RenderWindow::_getD3D9Device() const

CamelotD3D9Renderer/Source/CmD3D9Texture.cpp

@@ -15,8 +15,8 @@ namespace BansheeEngine
 	
     D3D9Texture::D3D9Texture()
         :Texture(), mD3DPool(D3DPOOL_MANAGED), mDynamicTextures(false),
-		mHwGammaReadSupported(false), mHwGammaWriteSupported(false), mFSAAType(D3DMULTISAMPLE_NONE),
-		mFSAAQuality(0), mIsBindableAsShaderResource(true)
+		mHwGammaReadSupported(false), mHwGammaWriteSupported(false), mMultisampleType(D3DMULTISAMPLE_NONE),
+		mMultisampleQuality(0), mIsBindableAsShaderResource(true)
 	{ }
 	
 	D3D9Texture::~D3D9Texture()
@@ -231,7 +231,7 @@ namespace BansheeEngine
 		textureResources->pCubeTex = nullptr;
 		textureResources->pVolumeTex = nullptr;
 		textureResources->pBaseTex = nullptr;
-		textureResources->pFSAASurface = nullptr;
+		textureResources->pMultisampleSurface = nullptr;
 		textureResources->pDepthStencilSurface = nullptr;
 
 		mMapDeviceToTextureResources[d3d9Device] = textureResources;
@@ -256,7 +256,7 @@ namespace BansheeEngine
 		SAFE_RELEASE(textureResources->pNormTex);
 		SAFE_RELEASE(textureResources->pCubeTex);
 		SAFE_RELEASE(textureResources->pVolumeTex);
-		SAFE_RELEASE(textureResources->pFSAASurface);
+		SAFE_RELEASE(textureResources->pMultisampleSurface);
 		SAFE_RELEASE(textureResources->pDepthStencilSurface);
 	}
 	
@@ -336,16 +336,16 @@ namespace BansheeEngine
 				mHwGammaWriteSupported = canUseHardwareGammaCorrection(d3d9Device, usage, D3DRTYPE_TEXTURE, d3dPF, true);
 		}
 
-		// Check FSAA level
+		// Check multisample level
 		if ((mUsage & TU_RENDERTARGET) != 0 || (mUsage & TU_DEPTHSTENCIL) != 0)
 		{
 			D3D9RenderSystem* rsys = static_cast<D3D9RenderSystem*>(BansheeEngine::RenderSystem::instancePtr());
-			rsys->determineFSAASettings(d3d9Device, mFSAA, mFSAAHint, d3dPF, false, &mFSAAType, &mFSAAQuality);
+			rsys->determineMultisampleSettings(d3d9Device, mMultisampleCount, mMultisampleHint, d3dPF, false, &mMultisampleType, &mMultisampleQuality);
 		}
 		else
 		{
-			mFSAAType = D3DMULTISAMPLE_NONE;
-			mFSAAQuality = 0;
+			mMultisampleType = D3DMULTISAMPLE_NONE;
+			mMultisampleQuality = 0;
 		}
 
 		D3D9Device* device = D3D9RenderSystem::getDeviceManager()->getDeviceFromD3D9Device(d3d9Device);
@@ -367,19 +367,19 @@ namespace BansheeEngine
 		else
 			textureResources = allocateTextureResources(d3d9Device);
 
-		if ((mUsage & TU_RENDERTARGET) != 0 && (mFSAAType != D3DMULTISAMPLE_NONE))
+		if ((mUsage & TU_RENDERTARGET) != 0 && (mMultisampleType != D3DMULTISAMPLE_NONE))
 		{
 			// Create AA surface
 			HRESULT hr = d3d9Device->CreateRenderTarget(mWidth, mHeight, d3dPF, 
-				mFSAAType, mFSAAQuality,
+				mMultisampleType, mMultisampleQuality,
 				TRUE, // TODO - Possible performance issues? Need to check
-				&textureResources->pFSAASurface, NULL);
+				&textureResources->pMultisampleSurface, NULL);
 
 			if (FAILED(hr))
 				CM_EXCEPT(RenderingAPIException, "Unable to create AA render target: " + String(DXGetErrorDescription(hr)));
 
 			D3DSURFACE_DESC desc;
-			hr = textureResources->pFSAASurface->GetDesc(&desc);
+			hr = textureResources->pMultisampleSurface->GetDesc(&desc);
 			if (FAILED(hr))
 			{
 				destroy_internal();
@@ -390,11 +390,11 @@ namespace BansheeEngine
 
 			mIsBindableAsShaderResource = true; // Cannot bind AA surfaces
 		}
-		else if ((mUsage & TU_DEPTHSTENCIL) != 0 && (mFSAAType != D3DMULTISAMPLE_NONE))
+		else if ((mUsage & TU_DEPTHSTENCIL) != 0 && (mMultisampleType != D3DMULTISAMPLE_NONE))
 		{
 			// Create AA depth stencil surface
 			HRESULT hr = d3d9Device->CreateDepthStencilSurface(mWidth, mHeight, d3dPF, 
-				mFSAAType, mFSAAQuality,
+				mMultisampleType, mMultisampleQuality,
 				TRUE, // TODO - Possible performance issues? Need to check
 				&textureResources->pDepthStencilSurface, NULL);
 
@@ -489,8 +489,8 @@ namespace BansheeEngine
 		}
 
 		// No multisampling on cube textures
-		mFSAAType = D3DMULTISAMPLE_NONE;
-		mFSAAQuality = 0;
+		mMultisampleType = D3DMULTISAMPLE_NONE;
+		mMultisampleQuality = 0;
 
 		D3D9Device* device = D3D9RenderSystem::getDeviceManager()->getDeviceFromD3D9Device(d3d9Device);
 		const D3DCAPS9& deviceCaps = device->getD3D9DeviceCaps();			
@@ -826,17 +826,17 @@ namespace BansheeEngine
 		IDirect3DSurface9* surface = nullptr;
 		IDirect3DVolume9* volume = nullptr;
 
-		if((mUsage & TU_RENDERTARGET) != 0 && (mFSAAType != D3DMULTISAMPLE_NONE))
+		if((mUsage & TU_RENDERTARGET) != 0 && (mMultisampleType != D3DMULTISAMPLE_NONE))
 		{
-			assert(textureResources->pFSAASurface);
+			assert(textureResources->pMultisampleSurface);
 			assert(getTextureType() == TEX_TYPE_2D);
 
 			D3D9PixelBuffer* currPixelBuffer = static_cast<D3D9PixelBuffer*>(mSurfaceList[0].get());
 
-			currPixelBuffer->bind(d3d9Device, textureResources->pFSAASurface,
-				mHwGammaWriteSupported, mFSAA, "", textureResources->pBaseTex);
+			currPixelBuffer->bind(d3d9Device, textureResources->pMultisampleSurface,
+				mHwGammaWriteSupported, mMultisampleCount, "", textureResources->pBaseTex);
 		}
-		else if((mUsage & TU_DEPTHSTENCIL) != 0 && (mFSAAType != D3DMULTISAMPLE_NONE))
+		else if((mUsage & TU_DEPTHSTENCIL) != 0 && (mMultisampleType != D3DMULTISAMPLE_NONE))
 		{
 			assert(textureResources->pDepthStencilSurface);
 			assert(getTextureType() == TEX_TYPE_2D);
@@ -844,7 +844,7 @@ namespace BansheeEngine
 			D3D9PixelBuffer* currPixelBuffer = static_cast<D3D9PixelBuffer*>(mSurfaceList[0].get());
 
 			currPixelBuffer->bind(d3d9Device, textureResources->pDepthStencilSurface,
-				mHwGammaWriteSupported, mFSAA, "", textureResources->pBaseTex);
+				mHwGammaWriteSupported, mMultisampleCount, "", textureResources->pBaseTex);
 		}
 		else
 		{
@@ -871,7 +871,7 @@ namespace BansheeEngine
 					D3D9PixelBuffer* currPixelBuffer = static_cast<D3D9PixelBuffer*>(mSurfaceList[mip].get());
 
 					currPixelBuffer->bind(d3d9Device, surface,
-						mHwGammaWriteSupported, mFSAA, "", textureResources->pBaseTex);
+						mHwGammaWriteSupported, mMultisampleCount, "", textureResources->pBaseTex);
 
 					surface->Release();			
 				}
@@ -891,7 +891,7 @@ namespace BansheeEngine
 						D3D9PixelBuffer* currPixelBuffer = static_cast<D3D9PixelBuffer*>(mSurfaceList[idx].get());
 
 						currPixelBuffer->bind(d3d9Device, surface,
-							mHwGammaWriteSupported, mFSAA, "", textureResources->pBaseTex);
+							mHwGammaWriteSupported, mMultisampleCount, "", textureResources->pBaseTex);
 
 						surface->Release();				
 					}				

CamelotGLRenderer/Include/CmGLFrameBufferObject.h

@@ -52,7 +52,7 @@ namespace BansheeEngine
     class CM_RSGL_EXPORT GLFrameBufferObject
     {
     public:
-        GLFrameBufferObject(UINT32 fsaa);
+        GLFrameBufferObject(UINT32 multisampleCount);
         ~GLFrameBufferObject();
 
         /** Bind a surface to a certain attachment point.

CamelotGLRenderer/Include/CmGLPixelBuffer.h

@@ -83,7 +83,7 @@ namespace BansheeEngine
     public:
         /** Texture constructor */
 		GLTextureBuffer(const String &baseName, GLenum target, GLuint id, GLint face, 
-			GLint level, GpuBufferUsage usage, bool softwareMipmap, bool writeGamma, UINT32 fsaa);
+			GLint level, GpuBufferUsage usage, bool softwareMipmap, bool writeGamma, UINT32 multisampleCount);
         ~GLTextureBuffer();
         
         /// @copydoc HardwarePixelBuffer::bindToFramebuffer

CamelotGLRenderer/Include/CmWin32GLSupport.h

@@ -47,7 +47,7 @@ namespace BansheeEngine
 		// Allowed video modes
 		Vector<DEVMODE> mDevModes;
 		Win32Window *mInitialWindow;
-		Vector<int> mFSAALevels;
+		Vector<int> mMultisampleLevels;
 		bool mHasPixelFormatARB;
         bool mHasMultisample;
 		bool mHasHardwareGamma;

CamelotGLRenderer/Source/CmGLFrameBufferObject.cpp

@@ -33,8 +33,8 @@ THE SOFTWARE.
 
 namespace BansheeEngine 
 {
-    GLFrameBufferObject::GLFrameBufferObject(UINT32 fsaa)
-		:mNumSamples(fsaa)
+    GLFrameBufferObject::GLFrameBufferObject(UINT32 multisampleCount)
+		:mNumSamples(multisampleCount)
     {
         /// Generate framebuffer object
         glGenFramebuffersEXT(1, &mFB);

CamelotGLRenderer/Source/CmGLMultiRenderTexture.cpp

@@ -19,7 +19,7 @@ namespace BansheeEngine
 		if(mFB != nullptr)
 			cm_delete(mFB);
 
-		mFB = cm_new<GLFrameBufferObject, PoolAlloc>(mFSAA);
+		mFB = cm_new<GLFrameBufferObject, PoolAlloc>(mMultisampleCount);
 
 		for(size_t i = 0; i < mColorSurfaces.size(); i++)
 		{
@@ -31,7 +31,7 @@ namespace BansheeEngine
 					mColorSurfaces[i]->getDesc().mostDetailMip);
 
 				GLSurfaceDesc surfaceDesc;
-				surfaceDesc.numSamples = mFSAA;
+				surfaceDesc.numSamples = mMultisampleCount;
 				surfaceDesc.zoffset = 0;
 				surfaceDesc.buffer = colorBuffer;
 

CamelotGLRenderer/Source/CmGLPixelBuffer.cpp

@@ -36,8 +36,7 @@ THE SOFTWARE.
 namespace BansheeEngine 
 {
 	GLPixelBuffer::GLPixelBuffer(UINT32 inWidth, UINT32 inHeight, UINT32 inDepth,
-					PixelFormat inFormat,
-					GpuBufferUsage usage):
+					PixelFormat inFormat, GpuBufferUsage usage):
 		  PixelBuffer(inWidth, inHeight, inDepth, inFormat, usage, false),
 		  mBuffer(inWidth, inHeight, inDepth, inFormat),
 		  mGLInternalFormat(GL_NONE)
@@ -125,7 +124,7 @@ namespace BansheeEngine
 
 	GLTextureBuffer::GLTextureBuffer(const String &baseName, GLenum target, GLuint id, 
 									 GLint face, GLint level, GpuBufferUsage usage, bool crappyCard, 
-									 bool writeGamma, UINT32 fsaa):
+									 bool writeGamma, UINT32 multisampleCount):
 		GLPixelBuffer(0, 0, 0, PF_UNKNOWN, usage),
 		mTarget(target), mFaceTarget(0), mTextureID(id), mFace(face), mLevel(level),
 		mSoftwareMipmap(crappyCard)

CamelotGLRenderer/Source/CmGLRenderSystem.cpp

@@ -1689,13 +1689,13 @@ namespace BansheeEngine
 
 		TextureManager::startUp<GLTextureManager>(std::ref(*mGLSupport));
 
-		// Check for FSAA
+		// Check for multisample support
 		// Enable the extension if it was enabled by the GLSupport
 		if (mGLSupport->checkExtension("GL_ARB_multisample"))
 		{
-			int fsaa_active = false;
-			glGetIntegerv(GL_SAMPLE_BUFFERS_ARB, (GLint*)&fsaa_active);
-			if (fsaa_active)
+			int multisampleActive = false;
+			glGetIntegerv(GL_SAMPLE_BUFFERS_ARB, (GLint*)&multisampleActive);
+			if (multisampleActive)
 			{
 				glEnable(GL_MULTISAMPLE_ARB);
 			}

CamelotGLRenderer/Source/CmGLRenderTexture.cpp

@@ -55,10 +55,10 @@ namespace BansheeEngine
 		if(mFB != nullptr)
 			cm_delete<PoolAlloc>(mFB);
 
-		mFB = cm_new<GLFrameBufferObject, PoolAlloc>(mFSAA);
+		mFB = cm_new<GLFrameBufferObject, PoolAlloc>(mMultisampleCount);
 
 		GLSurfaceDesc surfaceDesc;
-		surfaceDesc.numSamples = mFSAA;
+		surfaceDesc.numSamples = mMultisampleCount;
 		surfaceDesc.zoffset = 0;
 
 		GLTexture* glTexture = static_cast<GLTexture*>(mColorSurface->getTexture().get());

CamelotGLRenderer/Source/CmGLTexture.cpp

@@ -116,16 +116,16 @@ namespace BansheeEngine {
 				CM_EXCEPT(InvalidParametersException, "Cannot use a compressed format for a depth stencil target.");
 		}
 
-		if((mUsage & TU_RENDERTARGET) != 0 && mTextureType == TEX_TYPE_2D && mFSAA > 0)
+		if((mUsage & TU_RENDERTARGET) != 0 && mTextureType == TEX_TYPE_2D && mMultisampleCount > 0)
 		{
-			glTexImage2DMultisample(GL_TEXTURE_2D, mFSAA, format,
+			glTexImage2DMultisample(GL_TEXTURE_2D, mMultisampleCount, format,
 				width, height, GL_FALSE);
 		}
 		else if((mUsage & TU_DEPTHSTENCIL) != 0)
 		{
-			if(mFSAA > 0)
+			if(mMultisampleCount > 0)
 			{
-				glTexImage2DMultisample(GL_TEXTURE_2D, mFSAA, format,
+				glTexImage2DMultisample(GL_TEXTURE_2D, mMultisampleCount, format,
 					width, height, GL_FALSE);
 			}
 			else
@@ -208,7 +208,7 @@ namespace BansheeEngine {
             case TEX_TYPE_1D:
                 return GL_TEXTURE_1D;
             case TEX_TYPE_2D:
-				if(mFSAA > 0)
+				if(mMultisampleCount > 0)
 					return GL_TEXTURE_2D_MULTISAMPLE;
 				else
 					return GL_TEXTURE_2D;
@@ -290,7 +290,7 @@ namespace BansheeEngine {
 			for(UINT32 mip=0; mip<=getNumMipmaps(); mip++)
 			{
                 GLPixelBuffer *buf = cm_new<GLTextureBuffer, PoolAlloc>("", getGLTextureTarget(), mTextureID, face, mip,
-						static_cast<GpuBufferUsage>(mUsage), false, mHwGamma, mFSAA);
+						static_cast<GpuBufferUsage>(mUsage), false, mHwGamma, mMultisampleCount);
 				mSurfaceList.push_back(cm_shared_ptr<GLPixelBuffer, PoolAlloc>(buf));
                 
                 /// Check for error

CamelotGLRenderer/Source/CmWin32GLSupport.cpp

@@ -236,10 +236,10 @@ namespace BansheeEngine
                             wglGetProcAddress("wglGetPixelFormatAttribivARB");
                         if (_wglGetPixelFormatAttribivARB(hdc, formats[i], 0, 1, &query, &samples))
                         {
-                            mFSAALevels.push_back(samples);
+                            mMultisampleLevels.push_back(samples);
                         }
                     }
-                    remove_duplicates(mFSAALevels);
+                    remove_duplicates(mMultisampleLevels);
                 }
 			}
 			

CamelotGLRenderer/Source/CmWin32Window.cpp

@@ -277,32 +277,32 @@ namespace BansheeEngine
 
 		if (!mIsExternalGLControl)
 		{
-			int testFsaa = mFSAA;
+			int testMultisample = mMultisampleCount;
 			bool testHwGamma = mDesc.gamma;
-			bool formatOk = mGLSupport.selectPixelFormat(mHDC, mColorDepth, testFsaa, testHwGamma);
+			bool formatOk = mGLSupport.selectPixelFormat(mHDC, mColorDepth, testMultisample, testHwGamma);
 			if (!formatOk)
 			{
-				if (mFSAA > 0)
+				if (mMultisampleCount > 0)
 				{
-					// try without FSAA
-					testFsaa = 0;
-					formatOk = mGLSupport.selectPixelFormat(mHDC, mColorDepth, testFsaa, testHwGamma);
+					// try without multisampling
+					testMultisample = 0;
+					formatOk = mGLSupport.selectPixelFormat(mHDC, mColorDepth, testMultisample, testHwGamma);
 				}
 
 				if (!formatOk && mDesc.gamma)
 				{
 					// try without sRGB
 					testHwGamma = false;
-					testFsaa = mFSAA;
-					formatOk = mGLSupport.selectPixelFormat(mHDC, mColorDepth, testFsaa, testHwGamma);
+					testMultisample = mMultisampleCount;
+					formatOk = mGLSupport.selectPixelFormat(mHDC, mColorDepth, testMultisample, testHwGamma);
 				}
 
-				if (!formatOk && mDesc.gamma && (mFSAA > 0))
+				if (!formatOk && mDesc.gamma && (mMultisampleCount > 0))
 				{
 					// try without both
 					testHwGamma = false;
-					testFsaa = 0;
-					formatOk = mGLSupport.selectPixelFormat(mHDC, mColorDepth, testFsaa, testHwGamma);
+					testMultisample = 0;
+					formatOk = mGLSupport.selectPixelFormat(mHDC, mColorDepth, testMultisample, testHwGamma);
 				}
 
 				if (!formatOk)
@@ -312,7 +312,7 @@ namespace BansheeEngine
 			// record what gamma option we used in the end
 			// this will control enabling of sRGB state flags when used
 			mHwGamma = testHwGamma;
-			mFSAA = testFsaa;
+			mMultisampleCount = testMultisample;
 		}
 		
 		mActive = true;

Polish.txt

@@ -18,9 +18,6 @@ Finish GPUProfiler:
 When initializing a render window I don't have an option to use exact refresh rate (i.e. in RENDER_WINDOW_DESC)
  - Likely use a VideoMode you can create manually
 
-Add a better way of specifying FSAA (and don't call it FSAA because it's multisampling)
- - fsaaHint is useless in most cases. Add an Enum instead.
-
 I should be able to specify resolution when going to windowed mode
  - Maybe just store the windowed and fullscreen resolutions separately and restore automatically?
 
@@ -35,10 +32,6 @@ In DX9 render window I have disabled top most style.
 DISREGARD MONITOR INDEX ON DX9
  - It's not trivial and its not worth wasting time on a deprecated system
 
-LATER:
- Add ability to change FSAA on RenderWindow.
-  - Maybe later. OpenGL requires window to be re-created for it to change I think. As SetPixelFormat is allowed to be called just once per window
-
  -----------------------------
 
  Refactor: