DX9 and DX11 working with new pixel format layouts

CamelotD3D11RenderSystem/Source/CmD3D11Mappings.cpp

@@ -494,7 +494,7 @@ namespace CamelotFramework
 		case DXGI_FORMAT_R11G11B10_FLOAT	:
 			return PF_UNKNOWN;
 		case DXGI_FORMAT_R8G8B8A8_TYPELESS	:
-			return PF_R8G8B8A8;
+			return PF_UNKNOWN;
 		case DXGI_FORMAT_R8G8B8A8_UNORM	:
 			return PF_R8G8B8A8;
 		case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB	:
@@ -616,7 +616,7 @@ namespace CamelotFramework
 		case DXGI_FORMAT_B8G8R8A8_UNORM	:
 			return PF_B8G8R8A8;
 		case DXGI_FORMAT_B8G8R8X8_UNORM	:
-			return PF_UNKNOWN;
+			return PF_B8G8R8X8;
 		default:
 			return PF_UNKNOWN;
 		}
@@ -644,6 +644,8 @@ namespace CamelotFramework
 			return DXGI_FORMAT_R8G8B8A8_UNORM;
 		case PF_B8G8R8A8:
 			return DXGI_FORMAT_B8G8R8A8_UNORM;
+		case PF_B8G8R8X8:
+			return DXGI_FORMAT_B8G8R8X8_UNORM;
 		case PF_FLOAT16_R:
 			return DXGI_FORMAT_R16_FLOAT;
 		case PF_FLOAT16_RG:
@@ -694,8 +696,20 @@ namespace CamelotFramework
 		{
 		case PF_FLOAT16_RGB:
 			return PF_FLOAT16_RGBA;
-		case PF_FLOAT32_RGB:
-			return PF_FLOAT32_RGBA;
+		case PF_R8G8B8:
+			return PF_R8G8B8A8;
+		case PF_B8G8R8:
+			return PF_R8G8B8A8;
+		case PF_A8R8G8B8:
+			return PF_R8G8B8A8;
+		case PF_A8B8G8R8:
+			return PF_B8G8R8A8;
+		case PF_X8R8G8B8:
+			return PF_R8G8B8A8;
+		case PF_X8B8G8R8:
+			return PF_B8G8R8X8;
+		case PF_R8G8B8X8:
+			return PF_B8G8R8X8;
 		case PF_UNKNOWN:
 		default:
 			return PF_R8G8B8A8;

CamelotD3D9Renderer/Source/CmD3D9Mappings.cpp

@@ -466,29 +466,27 @@ namespace CamelotFramework
 	{
 		switch(d3dPF)
 		{
-		case D3DFMT_L8:
-			return PF_R8;
 		case D3DFMT_R8G8B8:
-			return PF_R8G8B8;
-		case D3DFMT_X8R8G8B8:
-			return PF_X8R8G8B8;
+			return PF_B8G8R8;
 		case D3DFMT_A8R8G8B8:
-			return PF_A8R8G8B8;
-		case D3DFMT_X8B8G8R8:
-			return PF_X8B8G8R8;
+			return PF_B8G8R8A8;
 		case D3DFMT_A8B8G8R8:
-			return PF_A8B8G8R8;
+			return PF_R8G8B8A8;
+		case D3DFMT_X8B8G8R8:
+			return PF_R8G8B8X8;
+		case D3DFMT_X8R8G8B8:
+			return PF_B8G8R8X8;
 		case D3DFMT_R16F:
 			return PF_FLOAT16_R;
 		case D3DFMT_A16B16G16R16F:
 			return PF_FLOAT16_RGBA;
 		case D3DFMT_R32F:
 			return PF_FLOAT32_R;
-		case D3DFMT_G32R32F:
+		case D3DFMT_G32R32F: // TODO - For some reason G and R are flipped in DX9 which might not be compatible with other render systems directly
 			return PF_FLOAT32_RG;
 		case D3DFMT_A32B32G32R32F:
 			return PF_FLOAT32_RGBA;
-		case D3DFMT_G16R16F:
+		case D3DFMT_G16R16F: // TODO - For some reason G and R are flipped in DX9 which might not be compatible with other render systems directly
 			return PF_FLOAT16_RG;
 		case D3DFMT_DXT1:
 			return PF_DXT1;
@@ -513,20 +511,22 @@ namespace CamelotFramework
 	/****************************************************************************************/
 	D3DFORMAT D3D9Mappings::_getPF(PixelFormat camelotPf)
 	{
+		// DX9 uses different format semantics than most render systems, where most significant bit is signified by the
+		// first channel letter. For example in RGBA8 format, R is most-significant byte. Which is why most formats map to their
+		// reverse version in-engine as seen below.
+		// (This is not the case for floating point formats, EXCEPT for green-red one)
 		switch(camelotPf)
 		{
-		case PF_R8:
-			return D3DFMT_L8;
-		case PF_R8G8B8:
+		case PF_B8G8R8:
 			return D3DFMT_R8G8B8;
-		case PF_A8R8G8B8:
+		case PF_B8G8R8A8:
 			return D3DFMT_A8R8G8B8;
-		case PF_A8B8G8R8:
+		case PF_R8G8B8A8:
 			return D3DFMT_A8B8G8R8;
-		case PF_X8R8G8B8:
-			return D3DFMT_X8R8G8B8;
-		case PF_X8B8G8R8:
+		case PF_R8G8B8X8:
 			return D3DFMT_X8B8G8R8;
+		case PF_B8G8R8X8:
+			return D3DFMT_X8R8G8B8;
 		case PF_FLOAT16_R:
 			return D3DFMT_R16F;
 		case PF_FLOAT16_RG:
@@ -570,10 +570,16 @@ namespace CamelotFramework
 
 		switch(enginePF)
 		{
-		case PF_B8G8R8:
-			return PF_R8G8B8;
-		case PF_B8G8R8A8:
-			return PF_A8R8G8B8;
+		case PF_R8:
+			return PF_B8G8R8;
+		case PF_R8G8:
+			return PF_B8G8R8;
+		case PF_A8R8G8B8:
+			return PF_B8G8R8A8;
+		case PF_A8B8G8R8:
+			return PF_R8G8B8A8;
+		case PF_R8G8B8:
+			return PF_B8G8R8;
 		case PF_FLOAT16_RGB:
 			return PF_FLOAT16_RGBA;
 		case PF_FLOAT32_RGB:
@@ -582,7 +588,7 @@ namespace CamelotFramework
 			return PF_D24S8;
 		case PF_UNKNOWN:
 		default:
-			return PF_A8R8G8B8;
+			return PF_B8G8R8A8;
 		}
 	}
 

CamelotD3D9Renderer/Source/CmD3D9Texture.cpp

@@ -365,6 +365,7 @@ namespace CamelotFramework
 		// determine wich D3D9 pixel format we'll use
 		HRESULT hr;
 		D3DFORMAT d3dPF = _chooseD3DFormat(d3d9Device);
+		mFormat = D3D9Mappings::_getPF(d3dPF);
 
 		// let's D3DX check the corrected pixel format
 		hr = D3DXCheckTextureRequirements(d3d9Device, NULL, NULL, NULL, 0, &d3dPF, mD3DPool);
@@ -539,6 +540,7 @@ namespace CamelotFramework
 		// determine wich D3D9 pixel format we'll use
 		HRESULT hr;
 		D3DFORMAT d3dPF = _chooseD3DFormat(d3d9Device);
+		mFormat = D3D9Mappings::_getPF(d3dPF);
 
 		// let's D3DX check the corrected pixel format
 		hr = D3DXCheckCubeTextureRequirements(d3d9Device, NULL, NULL, 0, &d3dPF, mD3DPool);
@@ -645,6 +647,8 @@ namespace CamelotFramework
 		// determine which D3D9 pixel format we'll use
 		HRESULT hr;
 		D3DFORMAT d3dPF = _chooseD3DFormat(d3d9Device);
+		mFormat = D3D9Mappings::_getPF(d3dPF);
+
 		// let's D3DX check the corrected pixel format
 		hr = D3DXCheckVolumeTextureRequirements(d3d9Device, NULL, NULL, NULL, NULL, 0, &d3dPF, mD3DPool);
 

CamelotFreeImgImporter/Source/CmFreeImgImporter.cpp

@@ -287,8 +287,6 @@ namespace CamelotFramework
 		case FIT_RGBAF:
 			format = PF_FLOAT32_RGBA;
 			break;
-
-
 		};
 
 		unsigned char* srcData = FreeImage_GetBits(fiBitmap);

CamelotUtility/Include/CmPixelData.h

@@ -33,6 +33,12 @@ namespace CamelotFramework
         /// 32-bit pixel format, 8 bits for blue, 8 bits for green, 8 bits for red
         /// like PF_A8B8G8R8, but alpha will get discarded
         PF_X8B8G8R8 = 10,
+		/// 32-bit pixel format, 8 bits for red, 8 bits for green, 8 bits for blue
+		/// like PF_R8G8B8A8, but alpha will get discarded
+		PF_R8G8B8X8 = 11,
+		/// 32-bit pixel format, 8 bits for blue, 8 bits for green, 8 bits for red
+		/// like PF_B8G8R8A8, but alpha will get discarded
+		PF_B8G8R8X8 = 12,
 		/// 3 byte pixel format, 1 byte for red, 1 byte for green, 1 byte for blue
 		PF_BYTE_RGB = PF_R8G8B8,
 		/// 3 byte pixel format, 1 byte for blue, 1 byte for green, 1 byte for red
@@ -42,41 +48,41 @@ namespace CamelotFramework
 		/// 4 byte pixel format, 1 byte for red, 1 byte for green, 1 byte for blue, and one byte for alpha
 		PF_BYTE_RGBA = PF_R8G8B8A8,      
         /// DDS (DirectDraw Surface) DXT1 format
-        PF_DXT1 = 11,
+        PF_DXT1 = 13,
         /// DDS (DirectDraw Surface) DXT2 format
-        PF_DXT2 = 12,
+        PF_DXT2 = 14,
         /// DDS (DirectDraw Surface) DXT3 format
-        PF_DXT3 = 13,
+        PF_DXT3 = 15,
         /// DDS (DirectDraw Surface) DXT4 format
-        PF_DXT4 = 14,
+        PF_DXT4 = 16,
         /// DDS (DirectDraw Surface) DXT5 format
-        PF_DXT5 = 15,
+        PF_DXT5 = 17,
 		// 16-bit pixel format, 16 bits (float) for red
-        PF_FLOAT16_R = 16,
+        PF_FLOAT16_R = 18,
 		// 32-bit, 2-channel s10e5 floating point pixel format, 16-bit red, 16-bit green
-		PF_FLOAT16_RG = 17,
+		PF_FLOAT16_RG = 19,
         // 48-bit pixel format, 16 bits (float) for red, 16 bits (float) for green, 16 bits (float) for blue
-        PF_FLOAT16_RGB = 18,
+        PF_FLOAT16_RGB = 20,
         // 64-bit pixel format, 16 bits (float) for red, 16 bits (float) for green, 16 bits (float) for blue, 16 bits (float) for alpha
-        PF_FLOAT16_RGBA = 19,
+        PF_FLOAT16_RGBA = 21,
 		// 32-bit pixel format, 32 bits (float) for red
-        PF_FLOAT32_R = 20,
+        PF_FLOAT32_R = 22,
 		// 64-bit, 2-channel floating point pixel format, 32-bit red, 32-bit green
-		PF_FLOAT32_RG = 21,
+		PF_FLOAT32_RG = 23,
         // 96-bit pixel format, 32 bits (float) for red, 32 bits (float) for green, 32 bits (float) for blue
-        PF_FLOAT32_RGB = 22,
+        PF_FLOAT32_RGB = 24,
         // 128-bit pixel format, 32 bits (float) for red, 32 bits (float) for green, 32 bits (float) for blue, 32 bits (float) for alpha
-        PF_FLOAT32_RGBA = 23,
+        PF_FLOAT32_RGBA = 25,
 		// Depth stencil, 32bit depth, 8bit stencil + 24 unused
-		PF_D32_S8X24 = 24,
+		PF_D32_S8X24 = 26,
 		// Depth stencil, 24bit depth + 8bit stencil
-		PF_D24S8 = 25,
+		PF_D24S8 = 27,
 		// Depth, 32bits
-		PF_D32 = 26,
+		PF_D32 = 28,
 		// Depth, 16bits
-		PF_D16 = 27,
+		PF_D16 = 29,
 		// Number of pixel formats currently defined
-        PF_COUNT = 28
+        PF_COUNT = 30
     };
 	typedef vector<PixelFormat>::type PixelFormatList;
 

CamelotUtility/Source/CmPixelUtil.cpp

@@ -395,7 +395,8 @@ namespace CamelotFramework {
 		/* rbits, gbits, bbits, abits */
 		8, 0, 0, 0,
 		/* Masks and shifts */
-		0xFF, 0, 0, 0, 0, 0, 0, 0
+		0x000000FF, 0, 0, 0, 
+		0, 0, 0, 0
 		},
 		//-----------------------------------------------------------------------
 		{"PF_R8G8",
@@ -408,8 +409,8 @@ namespace CamelotFramework {
 		/* rbits, gbits, bbits, abits */
 		8, 8, 0, 0,
 		/* Masks and shifts */
-		0xFF, 0x00FF, 0, 0, 
-		16, 8, 0, 0
+		0x000000FF, 0x0000FF00, 0, 0, 
+		0, 8, 0, 0
 		},
 	//-----------------------------------------------------------------------
         {"PF_R8G8B8",
@@ -422,8 +423,8 @@ namespace CamelotFramework {
         /* rbits, gbits, bbits, abits */
         8, 8, 8, 0,
         /* Masks and shifts */
-        0xFF0000, 0x00FF00, 0x0000FF, 0,
-        16, 8, 0, 0
+        0x000000FF, 0x0000FF00, 0x00FF0000, 0,
+        0, 8, 16, 0
         },
 	//-----------------------------------------------------------------------
         {"PF_B8G8R8",
@@ -436,8 +437,8 @@ namespace CamelotFramework {
         /* rbits, gbits, bbits, abits */
         8, 8, 8, 0,
         /* Masks and shifts */
-        0x0000FF, 0x00FF00, 0xFF0000, 0,
-        0, 8, 16, 0
+        0x00FF0000, 0x0000FF00, 0x000000FF, 0,
+        16, 8, 0, 0
         },
 	//-----------------------------------------------------------------------
         {"PF_A8R8G8B8",
@@ -450,8 +451,8 @@ namespace CamelotFramework {
         /* rbits, gbits, bbits, abits */
         8, 8, 8, 8,
         /* Masks and shifts */
-        0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000,
-        16, 8, 0, 24
+        0x0000FF00, 0x00FF0000, 0xFF000000, 0x000000FF,
+        8, 16, 24, 0
         },
 	//-----------------------------------------------------------------------
         {"PF_A8B8G8R8",
@@ -464,8 +465,8 @@ namespace CamelotFramework {
         /* rbits, gbits, bbits, abits */
         8, 8, 8, 8,
         /* Masks and shifts */
-        0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000,
-        0, 8, 16, 24,
+        0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF,
+        24, 16, 8, 0,
         },
 	//-----------------------------------------------------------------------
         {"PF_B8G8R8A8",
@@ -478,8 +479,8 @@ namespace CamelotFramework {
         /* rbits, gbits, bbits, abits */
         8, 8, 8, 8,
         /* Masks and shifts */
-        0x0000FF00, 0x00FF0000, 0xFF000000, 0x000000FF,
-        8, 16, 24, 0
+        0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000,
+        16, 8, 0, 24
         },
 	//-----------------------------------------------------------------------
 		{"PF_R8G8B8A8",
@@ -492,8 +493,8 @@ namespace CamelotFramework {
 		/* rbits, gbits, bbits, abits */
 		8, 8, 8, 8,
 		/* Masks and shifts */
-		0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF,
-		24, 16, 8, 0
+		0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000,
+		0, 8, 16, 24
 		},
 	//-----------------------------------------------------------------------
 		{"PF_X8R8G8B8",
@@ -506,8 +507,8 @@ namespace CamelotFramework {
 		/* rbits, gbits, bbits, abits */
 		8, 8, 8, 0,
 		/* Masks and shifts */
-		0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000,
-		16, 8, 0, 24
+		0x0000FF00, 0x00FF0000, 0xFF000000, 0x000000FF,
+		8, 16, 24, 0
 		},
 	//-----------------------------------------------------------------------
 		{"PF_X8B8G8R8",
@@ -520,8 +521,36 @@ namespace CamelotFramework {
 		/* rbits, gbits, bbits, abits */
 		8, 8, 8, 0,
 		/* Masks and shifts */
+		0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF,
+		24, 16, 8, 0
+		},
+	//-----------------------------------------------------------------------
+		{"PF_B8G8R8X8",
+		/* Bytes per element */
+		4,
+		/* Flags */
+		PFF_HASALPHA | PFF_NATIVEENDIAN,
+		/* Component type and count */
+		PCT_BYTE, 3,
+		/* rbits, gbits, bbits, abits */
+		8, 8, 8, 0,
+		/* Masks and shifts */
+		0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000,
+		16, 8, 0, 0
+		},
+	//-----------------------------------------------------------------------
+		{"PF_R8G8B8X8",
+		/* Bytes per element */
+		4,
+		/* Flags */
+		PFF_HASALPHA | PFF_NATIVEENDIAN,
+		/* Component type and count */
+		PCT_BYTE, 3,
+		/* rbits, gbits, bbits, abits */
+		8, 8, 8, 0,
+		/* Masks and shifts */
 		0x000000FF, 0x0000FF00, 0x00FF0000, 0xFF000000,
-		0, 8, 16, 24
+		0, 8, 16, 0
 		},
 	//-----------------------------------------------------------------------
         {"PF_DXT1",