[Bf-blender-cvs] SVN commit: /data/svn/bf-blender [16462] trunk/blender/source/blender/imbuf /intern/dds: This is patch:

Kent Mein mein at cs.umn.edu
Wed Sep 10 17:07:20 CEST 2008


Revision: 16462
          http://projects.blender.org/plugins/scmsvn/viewcvs.php?view=rev&root=bf-blender&revision=16462
Author:   sirdude
Date:     2008-09-10 17:07:20 +0200 (Wed, 10 Sep 2008)

Log Message:
-----------
This is patch:
[#15135] imbuf DDS support: sync to nvidia texture tools revision 602 + fix for ATI2 compressed normal maps

It just updates the dds stuff.

Provided by Amorilia

Kent

Revision Links:
--------------
    http://projects.blender.org/plugins/scmsvn/viewcvs.php?view=rev&root=bf-blender&revision=602

Modified Paths:
--------------
    trunk/blender/source/blender/imbuf/intern/dds/ColorBlock.cpp
    trunk/blender/source/blender/imbuf/intern/dds/ColorBlock.h
    trunk/blender/source/blender/imbuf/intern/dds/DirectDrawSurface.cpp
    trunk/blender/source/blender/imbuf/intern/dds/DirectDrawSurface.h
    trunk/blender/source/blender/imbuf/intern/dds/dds_api.cpp

Modified: trunk/blender/source/blender/imbuf/intern/dds/ColorBlock.cpp
===================================================================
--- trunk/blender/source/blender/imbuf/intern/dds/ColorBlock.cpp	2008-09-10 13:02:58 UTC (rev 16461)
+++ trunk/blender/source/blender/imbuf/intern/dds/ColorBlock.cpp	2008-09-10 15:07:20 UTC (rev 16462)
@@ -53,6 +53,14 @@
 {
 }
 
+/// Init the color block from an array of colors.
+ColorBlock::ColorBlock(const uint * linearImage)
+{
+	for(uint i = 0; i < 16; i++) {
+		color(i) = Color32(linearImage[i]);
+	}
+}
+
 /// Init the color block with the contents of the given block.
 ColorBlock::ColorBlock(const ColorBlock & block)
 {
@@ -125,9 +133,12 @@
 /// Returns true if the block has a single color.
 bool ColorBlock::isSingleColor() const
 {
+	Color32 mask(0xFF, 0xFF, 0xFF, 0x00);
+	uint u = m_color[0].u & mask.u;
+	
 	for(int i = 1; i < 16; i++)
 	{
-		if (m_color[0] != m_color[i])
+		if (u != (m_color[i].u & mask.u))
 		{
 			return false;
 		}
@@ -136,6 +147,30 @@
 	return true;
 }
 
+/// Returns true if the block has a single color, ignoring transparent pixels.
+bool ColorBlock::isSingleColorNoAlpha() const
+{
+	Color32 c;
+	int i;
+	for(i = 0; i < 16; i++)
+	{
+		if (m_color[i].a != 0) c = m_color[i];
+	}
+
+	Color32 mask(0xFF, 0xFF, 0xFF, 0x00);
+	uint u = c.u & mask.u;
+
+	for(; i < 16; i++)
+	{
+		if (u != (m_color[i].u & mask.u))
+		{
+			return false;
+		}
+	}
+	
+	return true;
+}
+
 /// Count number of unique colors in this color block.
 uint ColorBlock::countUniqueColors() const
 {

Modified: trunk/blender/source/blender/imbuf/intern/dds/ColorBlock.h
===================================================================
--- trunk/blender/source/blender/imbuf/intern/dds/ColorBlock.h	2008-09-10 13:02:58 UTC (rev 16461)
+++ trunk/blender/source/blender/imbuf/intern/dds/ColorBlock.h	2008-09-10 15:07:20 UTC (rev 16462)
@@ -41,6 +41,7 @@
 struct ColorBlock
 {
 	ColorBlock();
+	ColorBlock(const uint * linearImage);
 	ColorBlock(const ColorBlock & block);
 	ColorBlock(const Image * img, uint x, uint y);
 	
@@ -51,6 +52,7 @@
 	void splatY();
 	
 	bool isSingleColor() const;
+	bool isSingleColorNoAlpha() const;
 	uint countUniqueColors() const;
 	Color32 averageColor() const;
 	bool hasAlpha() const;

Modified: trunk/blender/source/blender/imbuf/intern/dds/DirectDrawSurface.cpp
===================================================================
--- trunk/blender/source/blender/imbuf/intern/dds/DirectDrawSurface.cpp	2008-09-10 13:02:58 UTC (rev 16461)
+++ trunk/blender/source/blender/imbuf/intern/dds/DirectDrawSurface.cpp	2008-09-10 15:07:20 UTC (rev 16462)
@@ -80,6 +80,10 @@
 static const uint FOURCC_ATI1 = MAKEFOURCC('A', 'T', 'I', '1');
 static const uint FOURCC_ATI2 = MAKEFOURCC('A', 'T', 'I', '2');
 
+static const uint FOURCC_A2XY = MAKEFOURCC('A', '2', 'X', 'Y');
+	
+static const uint FOURCC_DX10 = MAKEFOURCC('D', 'X', '1', '0');
+
 // 32 bit RGB formats.
 static const uint D3DFMT_R8G8B8 = 20;
 static const uint D3DFMT_A8R8G8B8 = 21;
@@ -279,6 +283,144 @@
 		D3D10_RESOURCE_DIMENSION_TEXTURE3D = 4,
 	};
 
+
+	const char * getDxgiFormatString(DXGI_FORMAT dxgiFormat)
+	{
+#define CASE(format) case DXGI_FORMAT_##format: return #format
+		switch(dxgiFormat)
+		{
+			CASE(UNKNOWN);
+			
+			CASE(R32G32B32A32_TYPELESS);
+			CASE(R32G32B32A32_FLOAT);
+			CASE(R32G32B32A32_UINT);
+			CASE(R32G32B32A32_SINT);
+			
+			CASE(R32G32B32_TYPELESS);
+			CASE(R32G32B32_FLOAT);
+			CASE(R32G32B32_UINT);
+			CASE(R32G32B32_SINT);
+			
+			CASE(R16G16B16A16_TYPELESS);
+			CASE(R16G16B16A16_FLOAT);
+			CASE(R16G16B16A16_UNORM);
+			CASE(R16G16B16A16_UINT);
+			CASE(R16G16B16A16_SNORM);
+			CASE(R16G16B16A16_SINT);
+			
+			CASE(R32G32_TYPELESS);
+			CASE(R32G32_FLOAT);
+			CASE(R32G32_UINT);
+			CASE(R32G32_SINT);
+			
+			CASE(R32G8X24_TYPELESS);
+			CASE(D32_FLOAT_S8X24_UINT);
+			CASE(R32_FLOAT_X8X24_TYPELESS);
+			CASE(X32_TYPELESS_G8X24_UINT);
+			
+			CASE(R10G10B10A2_TYPELESS);
+			CASE(R10G10B10A2_UNORM);
+			CASE(R10G10B10A2_UINT);
+			
+			CASE(R11G11B10_FLOAT);
+			
+			CASE(R8G8B8A8_TYPELESS);
+			CASE(R8G8B8A8_UNORM);
+			CASE(R8G8B8A8_UNORM_SRGB);
+			CASE(R8G8B8A8_UINT);
+			CASE(R8G8B8A8_SNORM);
+			CASE(R8G8B8A8_SINT);
+			
+			CASE(R16G16_TYPELESS);
+			CASE(R16G16_FLOAT);
+			CASE(R16G16_UNORM);
+			CASE(R16G16_UINT);
+			CASE(R16G16_SNORM);
+			CASE(R16G16_SINT);
+			
+			CASE(R32_TYPELESS);
+			CASE(D32_FLOAT);
+			CASE(R32_FLOAT);
+			CASE(R32_UINT);
+			CASE(R32_SINT);
+			
+			CASE(R24G8_TYPELESS);
+			CASE(D24_UNORM_S8_UINT);
+			CASE(R24_UNORM_X8_TYPELESS);
+			CASE(X24_TYPELESS_G8_UINT);
+			
+			CASE(R8G8_TYPELESS);
+			CASE(R8G8_UNORM);
+			CASE(R8G8_UINT);
+			CASE(R8G8_SNORM);
+			CASE(R8G8_SINT);
+			
+			CASE(R16_TYPELESS);
+			CASE(R16_FLOAT);
+			CASE(D16_UNORM);
+			CASE(R16_UNORM);
+			CASE(R16_UINT);
+			CASE(R16_SNORM);
+			CASE(R16_SINT);
+			
+			CASE(R8_TYPELESS);
+			CASE(R8_UNORM);
+			CASE(R8_UINT);
+			CASE(R8_SNORM);
+			CASE(R8_SINT);
+			CASE(A8_UNORM);
+
+			CASE(R1_UNORM);
+		
+			CASE(R9G9B9E5_SHAREDEXP);
+			
+			CASE(R8G8_B8G8_UNORM);
+			CASE(G8R8_G8B8_UNORM);
+
+			CASE(BC1_TYPELESS);
+			CASE(BC1_UNORM);
+			CASE(BC1_UNORM_SRGB);
+		
+			CASE(BC2_TYPELESS);
+			CASE(BC2_UNORM);
+			CASE(BC2_UNORM_SRGB);
+		
+			CASE(BC3_TYPELESS);
+			CASE(BC3_UNORM);
+			CASE(BC3_UNORM_SRGB);
+		
+			CASE(BC4_TYPELESS);
+			CASE(BC4_UNORM);
+			CASE(BC4_SNORM);
+		
+			CASE(BC5_TYPELESS);
+			CASE(BC5_UNORM);
+			CASE(BC5_SNORM);
+
+			CASE(B5G6R5_UNORM);
+			CASE(B5G5R5A1_UNORM);
+			CASE(B8G8R8A8_UNORM);
+			CASE(B8G8R8X8_UNORM);
+
+			default: 
+				return "UNKNOWN";
+		}
+#undef CASE
+	}
+	
+	const char * getD3d10ResourceDimensionString(D3D10_RESOURCE_DIMENSION resourceDimension)
+	{
+		switch(resourceDimension)
+		{
+			default:
+			case D3D10_RESOURCE_DIMENSION_UNKNOWN: return "UNKNOWN";
+			case D3D10_RESOURCE_DIMENSION_BUFFER: return "BUFFER";
+			case D3D10_RESOURCE_DIMENSION_TEXTURE1D: return "TEXTURE1D";
+			case D3D10_RESOURCE_DIMENSION_TEXTURE2D: return "TEXTURE2D";
+			case D3D10_RESOURCE_DIMENSION_TEXTURE3D: return "TEXTURE3D";
+		}
+	}
+
 /*** implementation ***/
 
 void mem_read(Stream & mem, DDSPixelFormat & pf)
@@ -451,7 +593,16 @@
 	// set fourcc pixel format.
 	this->pf.flags = DDPF_FOURCC;
 	this->pf.fourcc = MAKEFOURCC(c0, c1, c2, c3);
-	this->pf.bitcount = 0;
+
+	if (this->pf.fourcc == FOURCC_ATI2)
+	{
+		this->pf.bitcount = FOURCC_A2XY;
+	}
+	else
+	{
+		this->pf.bitcount = 0;
+	}
+	
 	this->pf.rmask = 0;
 	this->pf.gmask = 0;
 	this->pf.bmask = 0;
@@ -508,7 +659,8 @@
 
 void DDSHeader::setDX10Format(uint format)
 {
-	this->pf.flags = 0;
+	//this->pf.flags = 0;
+	this->pf.fourcc = FOURCC_DX10;
 	this->header10.dxgiFormat = format;
 }
 
@@ -520,12 +672,18 @@
 
 bool DDSHeader::hasDX10Header() const
 {
-	return this->pf.flags == 0;
+	return this->pf.fourcc == FOURCC_DX10;  // @@ This is according to AMD
+	//return this->pf.flags == 0;             // @@ This is according to MS
 }
 
 DirectDrawSurface::DirectDrawSurface(unsigned char *mem, uint size) : stream(mem, size), header()
 {
 	mem_read(stream, header);
+
+	// some ATI2 compressed normal maps do not have their
+	// normal flag set, so force it here (the original nvtt don't do
+	// this, but the decompressor has a -forcenormal flag)
+	if (header.pf.fourcc == FOURCC_ATI2) header.setNormalFlag(true);
 }
 
 DirectDrawSurface::~DirectDrawSurface()
@@ -539,7 +697,7 @@
 		return false;
 	}
 	
-	const uint required = (DDSD_WIDTH|DDSD_HEIGHT|DDSD_CAPS|DDSD_PIXELFORMAT);
+	const uint required = (DDSD_WIDTH|DDSD_HEIGHT/*|DDSD_CAPS|DDSD_PIXELFORMAT*/);
 	if( (header.flags & required) != required ) {
 		return false;
 	}
@@ -560,42 +718,48 @@
 
 bool DirectDrawSurface::isSupported() const
 {
-	if (header.pf.flags & DDPF_FOURCC)
+	if (header.hasDX10Header())
 	{
-		if (header.pf.fourcc != FOURCC_DXT1 &&
-		    header.pf.fourcc != FOURCC_DXT2 &&
-		    header.pf.fourcc != FOURCC_DXT3 &&
-		    header.pf.fourcc != FOURCC_DXT4 &&
-		    header.pf.fourcc != FOURCC_DXT5 &&
-		    header.pf.fourcc != FOURCC_RXGB &&
-		    header.pf.fourcc != FOURCC_ATI1 &&
-		    header.pf.fourcc != FOURCC_ATI2)
+	}
+	else
+	{
+		if (header.pf.flags & DDPF_FOURCC)
 		{
-			// Unknown fourcc code.
+			if (header.pf.fourcc != FOURCC_DXT1 &&
+			    header.pf.fourcc != FOURCC_DXT2 &&
+			    header.pf.fourcc != FOURCC_DXT3 &&
+			    header.pf.fourcc != FOURCC_DXT4 &&
+			    header.pf.fourcc != FOURCC_DXT5 &&
+			    header.pf.fourcc != FOURCC_RXGB &&
+			    header.pf.fourcc != FOURCC_ATI1 &&
+			    header.pf.fourcc != FOURCC_ATI2)
+			{
+				// Unknown fourcc code.
+				return false;
+			}
+		}
+		else if (header.pf.flags & DDPF_RGB)
+		{
+			// All RGB formats are supported now.
+		}
+		else
+		{
 			return false;
 		}
-	}
-	else if (header.pf.flags & DDPF_RGB)
-	{
-		// All RGB formats are supported now.
-	}
-	else
-	{
-		return false;
-	}
+		
+		if (isTextureCube() && (header.caps.caps2 & DDSCAPS2_CUBEMAP_ALL_FACES) != DDSCAPS2_CUBEMAP_ALL_FACES)
+		{
+			// Cubemaps must contain all faces.
+			return false;
+		}
 	
-	if (isTextureCube() && (header.caps.caps2 & DDSCAPS2_CUBEMAP_ALL_FACES) != DDSCAPS2_CUBEMAP_ALL_FACES)
-	{
-		// Cubemaps must contain all faces.
-		return false;
+		if (isTexture3D())
+		{
+			// @@ 3D textures not supported yet.
+			return false;
+		}
 	}
 	
-	if (isTexture3D())
-	{
-		// @@ 3D textures not supported yet.
-		return false;
-	}
-	
 	return true;
 }
 
@@ -641,14 +805,37 @@
 	}
 }
 
+bool DirectDrawSurface::isTexture1D() const
+{
+	if (header.hasDX10Header())
+	{
+		return header.header10.resourceDimension == D3D10_RESOURCE_DIMENSION_TEXTURE1D;
+	}
+	return false;
+}
+
 bool DirectDrawSurface::isTexture2D() const
 {
-	return !isTexture3D() && !isTextureCube();
+	if (header.hasDX10Header())
+	{
+		return header.header10.resourceDimension == D3D10_RESOURCE_DIMENSION_TEXTURE2D;
+	}
+	else
+	{
+		return !isTexture3D() && !isTextureCube();
+	}
 }
 
 bool DirectDrawSurface::isTexture3D() const
 {
+	if (header.hasDX10Header())
+	{
+		return header.header10.resourceDimension == D3D10_RESOURCE_DIMENSION_TEXTURE3D;
+	}
+	else
+	{
 	return (header.caps.caps2 & DDSCAPS2_VOLUME) != 0;
+	}
 }
 
 bool DirectDrawSurface::isTextureCube() const
@@ -656,6 +843,11 @@
 	return (header.caps.caps2 & DDSCAPS2_CUBEMAP) != 0;
 }
 
+void DirectDrawSurface::setNormalFlag(bool b)
+{
+	header.setNormalFlag(b);
+}
+
 void DirectDrawSurface::mipmap(Image * img, uint face, uint mipmap)
 {
 	stream.seek(offset(face, mipmap));
@@ -709,7 +901,13 @@
 		return;
 	}
 
-	if (header.pf.amask != 0)
+	// set image format: RGB or ARGB

@@ Diff output truncated at 10240 characters. @@




More information about the Bf-blender-cvs mailing list