drewcassidy/nvidia-texture-tools
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge changes from the-witness.

Browse Source
This commit is contained in:
castano 2011-01-08 04:54:06 +00:00
parent 993e853a5f
commit 5f8cd22cdb
22 changed files with 401 additions and 194 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/nvcore/Array.h
View File

@ -446,6 +446,14 @@ namespace nv
return *this; return *this;
} }
// Release ownership of allocated memory and returns pointer to it.
T * release() {
T * tmp = m_buffer;
m_buffer = NULL;
m_size = 0;
m_buffer_size = 0;
return tmp;
}
/// Array serialization. /// Array serialization.
friend Stream & operator<< ( Stream & s, Array<T> & p ) friend Stream & operator<< ( Stream & s, Array<T> & p )

110
src/nvcore/Debug.cpp
View File

@ -199,65 +199,65 @@ namespace
nvDebug( "\nDumping stacktrace:\n" ); nvDebug( "\nDumping stacktrace:\n" );
// Resolve PC to function names // Resolve PC to function names
for (int i = start; i < size; i++) for (int i = start; i < size; i++)
{ {
// Check for end of stack walk // Check for end of stack walk
DWORD64 ip = (DWORD64)trace[i]; DWORD64 ip = (DWORD64)trace[i];
if (ip == NULL) if (ip == NULL)
break; break;
// Get function name // Get function name
#define MAX_STRING_LEN (512) #define MAX_STRING_LEN (512)
unsigned char byBuffer[sizeof(IMAGEHLP_SYMBOL64) + MAX_STRING_LEN] = { 0 }; unsigned char byBuffer[sizeof(IMAGEHLP_SYMBOL64) + MAX_STRING_LEN] = { 0 };
IMAGEHLP_SYMBOL64 * pSymbol = (IMAGEHLP_SYMBOL64*)byBuffer; IMAGEHLP_SYMBOL64 * pSymbol = (IMAGEHLP_SYMBOL64*)byBuffer;
pSymbol->SizeOfStruct = sizeof(IMAGEHLP_SYMBOL64); pSymbol->SizeOfStruct = sizeof(IMAGEHLP_SYMBOL64);
pSymbol->MaxNameLength = MAX_STRING_LEN; pSymbol->MaxNameLength = MAX_STRING_LEN;
DWORD64 dwDisplacement; DWORD64 dwDisplacement;
if (SymGetSymFromAddr64(hProcess, ip, &dwDisplacement, pSymbol))
{
pSymbol->Name[MAX_STRING_LEN-1] = 0;
/*
// Make the symbol readable for humans
UnDecorateSymbolName( pSym->Name, lpszNonUnicodeUnDSymbol, BUFFERSIZE,
UNDNAME_COMPLETE |
UNDNAME_NO_THISTYPE |
UNDNAME_NO_SPECIAL_SYMS |
UNDNAME_NO_MEMBER_TYPE |
UNDNAME_NO_MS_KEYWORDS |
UNDNAME_NO_ACCESS_SPECIFIERS );
*/
// pSymbol->Name
const char * pFunc = pSymbol->Name;
// Get file/line number
IMAGEHLP_LINE64 theLine = { 0 };
theLine.SizeOfStruct = sizeof(theLine);
if (SymGetSymFromAddr64(hProcess, ip, &dwDisplacement, pSymbol)) DWORD dwDisplacement;
{ if (!SymGetLineFromAddr64(hProcess, ip, &dwDisplacement, &theLine))
pSymbol->Name[MAX_STRING_LEN-1] = 0; {
nvDebug("unknown(%08X) : %s\n", (uint32)ip, pFunc);
/* }
// Make the symbol readable for humans else
UnDecorateSymbolName( pSym->Name, lpszNonUnicodeUnDSymbol, BUFFERSIZE, {
UNDNAME_COMPLETE | /*
UNDNAME_NO_THISTYPE | const char* pFile = strrchr(theLine.FileName, '\\');
UNDNAME_NO_SPECIAL_SYMS | if ( pFile == NULL ) pFile = theLine.FileName;
UNDNAME_NO_MEMBER_TYPE | else pFile++;
UNDNAME_NO_MS_KEYWORDS | */
UNDNAME_NO_ACCESS_SPECIFIERS ); const char * pFile = theLine.FileName;
*/
int line = theLine.LineNumber;
// pSymbol->Name
const char * pFunc = pSymbol->Name; nvDebug("%s(%d) : %s\n", pFile, line, pFunc);
}
// Get file/line number }
IMAGEHLP_LINE64 theLine = { 0 };
theLine.SizeOfStruct = sizeof(theLine);
DWORD dwDisplacement;
if (!SymGetLineFromAddr64(hProcess, ip, &dwDisplacement, &theLine))
{
nvDebug("unknown(%08X) : %s\n", (uint32)ip, pFunc);
}
else
{
/*
const char* pFile = strrchr(theLine.FileName, '\\');
if ( pFile == NULL ) pFile = theLine.FileName;
else pFile++;
*/
const char * pFile = theLine.FileName;
int line = theLine.LineNumber;
nvDebug("%s(%d) : %s\n", pFile, line, pFunc);
}
} }
}
} }

60
src/nvcore/HashMap.h
View File

@ -400,6 +400,66 @@ namespace nv
} }
#endif #endif
// These two functions are not tested:
// By default we serialize the key-value pairs compactly.
friend Stream & operator<< (Stream & s, HashMap<T, U, H, E> & map)
{
int entry_count = map.entry_count;
s << entry_count;
if (s.isLoading()) {
map.clear();
map.entry_count = entry_count;
map.size_mask = nextPowerOfTwo(entry_count) - 1;
map.table = malloc<Entry>(map.size_mask + 1);
for (int i = 0; i <= map.size_mask; i++) {
map.table[i].next_in_chain = -2; // mark empty
}
T key;
U value;
for (int i = 0; i < entry_count; i++) {
s << key << value;
map.add(key, value);
}
}
else {
foreach(i, map) {
s << map[i].key << map[i].value;
}
}
return s;
}
// This requires more storage, but saves us from rehashing the elements.
friend Stream & rawSerialize(Stream & s, HashMap<T, U, H, E> & map)
{
if (s.isLoading()) {
map.clear();
}
s << map.size_mask;
if (map.size_mask != -1) {
s << map.entry_count;
if (s.isLoading()) {
map.table = new Entry[map.size_mask+1];
}
for (int i = 0; i <= map.size_mask; i++) {
Entry & e = map.table[i];
s << e.next_in_chain << e.hash_value;
s << e.key;
s << e.value;
}
}
return s;
}
private: private:

33
src/nvcore/StdStream.h
View File

@ -6,6 +6,7 @@
#include "nvcore.h" #include "nvcore.h"
#include "Stream.h" #include "Stream.h"
#include "Array.h"
#include <stdio.h> // fopen #include <stdio.h> // fopen
#include <string.h> // memcpy #include <string.h> // memcpy
@ -308,6 +309,38 @@ namespace nv
}; };
/// Buffer output stream.
class NVCORE_CLASS BufferOutputStream : public Stream
{
NV_FORBID_COPY(BufferOutputStream);
public:
BufferOutputStream(Array<uint8> & buffer) : m_buffer(buffer) { }
virtual uint serialize( void * data, uint len )
{
nvDebugCheck(data != NULL);
m_buffer.append((uint8 *)data, len);
return len;
}
virtual void seek( uint pos ) { /*Not implemented*/ }
virtual uint tell() const { return m_buffer.size(); }
virtual uint size() const { return m_buffer.size(); }
virtual bool isError() const { return false; }
virtual void clearError() {}
virtual bool isAtEnd() const { return true; }
virtual bool isSeekable() const { return false; }
virtual bool isLoading() const { return false; }
virtual bool isSaving() const { return true; }
private:
Array<uint8> & m_buffer;
};
/// Protected input stream. /// Protected input stream.
class NVCORE_CLASS ProtectedStream : public Stream class NVCORE_CLASS ProtectedStream : public Stream
{ {

22
src/nvcore/Utils.h
View File

@ -95,21 +95,21 @@ namespace nv
} }
inline uint sdbmHash(const void * data_in, uint size, uint h = 5381)
{
const uint8 * data = (const uint8 *) data_in;
uint i = 0;
while (i < size) {
h = (h << 16) + (h << 6) - h + (uint) data[i++];
}
return h;
}
// Some hash functors: // Some hash functors:
template <typename Key> struct Hash template <typename Key> struct Hash
{ {
inline uint sdbm_hash(const void * data_in, uint size, uint h = 5381) const
{
const uint8 * data = (const uint8 *) data_in;
uint i = 0;
while (i < size) {
h = (h << 16) + (h << 6) - h + (uint) data[i++];
}
return h;
}
uint operator()(const Key & k) const { uint operator()(const Key & k) const {
return sdbm_hash(&k, sizeof(Key)); return sdbmHash(&k, sizeof(Key));
} }
}; };
template <> struct Hash<int> template <> struct Hash<int>

2
src/nvcore/nvcore.h
View File

@ -153,6 +153,8 @@ typedef uint32 uint;
#define NV_STRING2(x) #x #define NV_STRING2(x) #x
#define NV_STRING(x) NV_STRING2(x) #define NV_STRING(x) NV_STRING2(x)
#define NV_ARRAY_SIZE(x) (sizeof(x)/sizeof((x)[0]))
#if 1 #if 1
#if NV_CC_MSVC #if NV_CC_MSVC
#define NV_MESSAGE(x) message(__FILE__ "(" NV_STRING(__LINE__) ") : " x) #define NV_MESSAGE(x) message(__FILE__ "(" NV_STRING(__LINE__) ") : " x)

70
src/nvimage/DirectDrawSurface.cpp
View File

@ -44,17 +44,19 @@ using namespace nv;
const uint nv::FOURCC_NVTT = MAKEFOURCC('N', 'V', 'T', 'T'); const uint nv::FOURCC_NVTT = MAKEFOURCC('N', 'V', 'T', 'T');
const uint nv::FOURCC_DDS = MAKEFOURCC('D', 'D', 'S', ' ');
const uint nv::FOURCC_DXT1 = MAKEFOURCC('D', 'X', 'T', '1');
const uint nv::FOURCC_DXT2 = MAKEFOURCC('D', 'X', 'T', '2');
const uint nv::FOURCC_DXT3 = MAKEFOURCC('D', 'X', 'T', '3');
const uint nv::FOURCC_DXT4 = MAKEFOURCC('D', 'X', 'T', '4');
const uint nv::FOURCC_DXT5 = MAKEFOURCC('D', 'X', 'T', '5');
const uint nv::FOURCC_RXGB = MAKEFOURCC('R', 'X', 'G', 'B');
const uint nv::FOURCC_ATI1 = MAKEFOURCC('A', 'T', 'I', '1');
const uint nv::FOURCC_ATI2 = MAKEFOURCC('A', 'T', 'I', '2');
namespace namespace
{ {
static const uint FOURCC_DDS = MAKEFOURCC('D', 'D', 'S', ' ');
static const uint FOURCC_DXT1 = MAKEFOURCC('D', 'X', 'T', '1');
static const uint FOURCC_DXT2 = MAKEFOURCC('D', 'X', 'T', '2');
static const uint FOURCC_DXT3 = MAKEFOURCC('D', 'X', 'T', '3');
static const uint FOURCC_DXT4 = MAKEFOURCC('D', 'X', 'T', '4');
static const uint FOURCC_DXT5 = MAKEFOURCC('D', 'X', 'T', '5');
static const uint FOURCC_RXGB = MAKEFOURCC('R', 'X', 'G', 'B');
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_A2XY = MAKEFOURCC('A', '2', 'X', 'Y');
@ -133,7 +135,10 @@ namespace
static const uint DDPF_PALETTEINDEXED8 = 0x00000020U; static const uint DDPF_PALETTEINDEXED8 = 0x00000020U;
static const uint DDPF_LUMINANCE = 0x00020000U; static const uint DDPF_LUMINANCE = 0x00020000U;
static const uint DDPF_ALPHAPREMULT = 0x00008000U; static const uint DDPF_ALPHAPREMULT = 0x00008000U;
static const uint DDPF_NORMAL = 0x80000000U; // @@ Custom nv flag.
// Custom NVTT flags.
static const uint DDPF_NORMAL = 0x80000000U;
static const uint DDPF_SRGB = 0x40000000U;
// DX10 formats. // DX10 formats.
enum DXGI_FORMAT enum DXGI_FORMAT
@ -522,24 +527,26 @@ namespace
static const uint s_d3dFormatCount = sizeof(s_d3dFormats) / sizeof(s_d3dFormats[0]); static const uint s_d3dFormatCount = sizeof(s_d3dFormats) / sizeof(s_d3dFormats[0]);
static uint findD3D9Format(uint bitcount, uint rmask, uint gmask, uint bmask, uint amask) } // namespace
{
for (uint i = 0; i < s_d3dFormatCount; i++)
{
if (s_d3dFormats[i].bitcount == bitcount &&
s_d3dFormats[i].rmask == rmask &&
s_d3dFormats[i].gmask == gmask &&
s_d3dFormats[i].bmask == bmask &&
s_d3dFormats[i].amask == amask)
{
return s_d3dFormats[i].format;
}
}
return 0; uint nv::findD3D9Format(uint bitcount, uint rmask, uint gmask, uint bmask, uint amask)
{
for (int i = 0; i < s_d3dFormatCount; i++)
{
if (s_d3dFormats[i].bitcount == bitcount &&
s_d3dFormats[i].rmask == rmask &&
s_d3dFormats[i].gmask == gmask &&
s_d3dFormats[i].bmask == bmask &&
s_d3dFormats[i].amask == amask)
{
return s_d3dFormats[i].format;
}
} }
} // namespace return 0;
}
DDSHeader::DDSHeader() DDSHeader::DDSHeader()
{ {
@ -755,6 +762,12 @@ void DDSHeader::setNormalFlag(bool b)
else this->pf.flags &= ~DDPF_NORMAL; else this->pf.flags &= ~DDPF_NORMAL;
} }
void DDSHeader::setSrgbFlag(bool b)
{
if (b) this->pf.flags |= DDPF_SRGB;
else this->pf.flags &= ~DDPF_SRGB;
}
void DDSHeader::setHasAlphaFlag(bool b) void DDSHeader::setHasAlphaFlag(bool b)
{ {
if (b) this->pf.flags |= DDPF_ALPHAPIXELS; if (b) this->pf.flags |= DDPF_ALPHAPIXELS;
@ -831,6 +844,11 @@ bool DDSHeader::isNormalMap() const
return (pf.flags & DDPF_NORMAL) != 0; return (pf.flags & DDPF_NORMAL) != 0;
} }
bool DDSHeader::isSrgb() const
{
return (pf.flags & DDPF_SRGB) != 0;
}
bool DDSHeader::hasAlpha() const bool DDSHeader::hasAlpha() const
{ {
return (pf.flags & DDPF_ALPHAPIXELS) != 0; return (pf.flags & DDPF_ALPHAPIXELS) != 0;
@ -1160,7 +1178,7 @@ void * DirectDrawSurface::readData(uint * sizePtr)
void * data = new unsigned char [size]; void * data = new unsigned char [size];
size = stream->serialize(data, size); size = stream->serialize(data, size);
nvDebugCheck(uint(size) == *sizePtr); nvDebugCheck(size == *sizePtr);
return data; return data;
} }

13
src/nvimage/DirectDrawSurface.h
View File

@ -34,6 +34,17 @@ namespace nv
struct ColorBlock; struct ColorBlock;
extern const uint FOURCC_NVTT; extern const uint FOURCC_NVTT;
extern const uint FOURCC_DDS;
extern const uint FOURCC_DXT1;
extern const uint FOURCC_DXT2;
extern const uint FOURCC_DXT3;
extern const uint FOURCC_DXT4;
extern const uint FOURCC_DXT5;
extern const uint FOURCC_RXGB;
extern const uint FOURCC_ATI1;
extern const uint FOURCC_ATI2;
extern uint findD3D9Format(uint bitcount, uint rmask, uint gmask, uint bmask, uint amask);
struct NVIMAGE_CLASS DDSPixelFormat struct NVIMAGE_CLASS DDSPixelFormat
{ {
@ -101,6 +112,7 @@ namespace nv
void setPixelFormat(uint bitcount, uint rmask, uint gmask, uint bmask, uint amask); void setPixelFormat(uint bitcount, uint rmask, uint gmask, uint bmask, uint amask);
void setDX10Format(uint format); void setDX10Format(uint format);
void setNormalFlag(bool b); void setNormalFlag(bool b);
void setSrgbFlag(bool b);
void setHasAlphaFlag(bool b); void setHasAlphaFlag(bool b);
void setUserVersion(int version); void setUserVersion(int version);
@ -111,6 +123,7 @@ namespace nv
uint toolVersion() const; uint toolVersion() const;
uint userVersion() const; uint userVersion() const;
bool isNormalMap() const; bool isNormalMap() const;
bool isSrgb() const;
bool hasAlpha() const; bool hasAlpha() const;
uint d3d9Format() const; uint d3d9Format() const;
}; };

80
src/nvimage/PixelFormat.h
View File

@ -33,47 +33,47 @@ namespace nv
namespace PixelFormat namespace PixelFormat
{ {
// Convert component @a c having @a inbits to the returned value having @a outbits. // Convert component @a c having @a inbits to the returned value having @a outbits.
inline uint convert(uint c, uint inbits, uint outbits) inline uint convert(uint c, uint inbits, uint outbits)
{ {
if (inbits == 0) if (inbits == 0)
{ {
return 0; return 0;
} }
else if (inbits >= outbits) else if (inbits >= outbits)
{ {
// truncate // truncate
return c >> (inbits - outbits); return c >> (inbits - outbits);
} }
else else
{ {
// bitexpand // bitexpand
return (c << (outbits - inbits)) | convert(c, inbits, outbits - inbits); return (c << (outbits - inbits)) | convert(c, inbits, outbits - inbits);
} }
} }
// Get pixel component shift and size given its mask. // Get pixel component shift and size given its mask.
inline void maskShiftAndSize(uint mask, uint * shift, uint * size) inline void maskShiftAndSize(uint mask, uint * shift, uint * size)
{ {
if (!mask) if (!mask)
{ {
*shift = 0; *shift = 0;
*size = 0; *size = 0;
return; return;
} }
*shift = 0; *shift = 0;
while((mask & 1) == 0) { while((mask & 1) == 0) {
++(*shift); ++(*shift);
mask >>= 1; mask >>= 1;
} }
*size = 0; *size = 0;
while((mask & 1) == 1) { while((mask & 1) == 1) {
++(*size); ++(*size);
mask >>= 1; mask >>= 1;
} }
} }
inline float quantizeCeil(float f, int inbits, int outbits) inline float quantizeCeil(float f, int inbits, int outbits)
{ {

3
src/nvmath/Box.h
View File

@ -27,6 +27,9 @@ namespace nv
/// Init ctor. /// Init ctor.
Box(Vector3::Arg mins, Vector3::Arg maxs) : minCorner(mins), maxCorner(maxs) { } Box(Vector3::Arg mins, Vector3::Arg maxs) : minCorner(mins), maxCorner(maxs) { }
// Assignment operator.
Box & operator=(const Box & b) { minCorner = b.minCorner; maxCorner = b.maxCorner; return *this; }
// Cast operators. // Cast operators.
operator const float * () const { return reinterpret_cast<const float *>(this); } operator const float * () const { return reinterpret_cast<const float *>(this); }

2
src/nvmath/Fitting.cpp
View File

@ -66,7 +66,7 @@ Vector3 nv::Fit::computeCentroid(int n, const Vector3 *__restrict points)
Vector3 nv::Fit::computeCentroid(int n, const Vector3 *__restrict points, const float *__restrict weights, Vector3::Arg metric) Vector3 nv::Fit::computeCentroid(int n, const Vector3 *__restrict points, const float *__restrict weights, Vector3::Arg metric)
{ {
Vector3 centroid(0.0f ); Vector3 centroid(0.0f);
float total = 0.0f; float total = 0.0f;
for (int i = 0; i < n; i++) for (int i = 0; i < n; i++)

4
src/nvmath/Half.cpp
View File

@ -496,10 +496,12 @@ nv::fast_half_to_float( uint16 h )
const uint32 h_f_s_pos_offset = _uint32_li( 0x00000010 ); const uint32 h_f_s_pos_offset = _uint32_li( 0x00000010 );
const uint32 h_f_e_pos_offset = _uint32_li( 0x0000000d ); const uint32 h_f_e_pos_offset = _uint32_li( 0x0000000d );
const uint32 h_f_bias_offset = _uint32_li( 0x0001c000 ); const uint32 h_f_bias_offset = _uint32_li( 0x0001c000 );
const uint32 f_e_mask = _uint32_li( 0x7f800000 );
const uint32 f_m_mask = _uint32_li( 0x007fffff ); const uint32 f_m_mask = _uint32_li( 0x007fffff );
const uint32 h_f_e_denorm_bias = _uint32_li( 0x0000007e ); const uint32 h_f_e_denorm_bias = _uint32_li( 0x0000007e );
const uint32 h_f_m_denorm_sa_bias = _uint32_li( 0x00000008 ); const uint32 h_f_m_denorm_sa_bias = _uint32_li( 0x00000008 );
const uint32 f_e_pos = _uint32_li( 0x00000017 ); const uint32 f_e_pos = _uint32_li( 0x00000017 );
const uint32 h_e_mask_minus_one = _uint32_li( 0x00007bff );
const uint32 h_e = _uint32_and( h, h_e_mask ); const uint32 h_e = _uint32_and( h, h_e_mask );
const uint32 h_m = _uint32_and( h, h_m_mask ); const uint32 h_m = _uint32_and( h, h_m_mask );
const uint32 h_s = _uint32_and( h, h_s_mask ); const uint32 h_s = _uint32_and( h, h_s_mask );
@ -515,8 +517,10 @@ nv::fast_half_to_float( uint16 h )
const uint32 f_m_denorm = _uint32_and( h_f_m, f_m_mask ); const uint32 f_m_denorm = _uint32_and( h_f_m, f_m_mask );
const uint32 f_e_denorm = _uint32_sll( f_e_denorm_unpacked, f_e_pos ); const uint32 f_e_denorm = _uint32_sll( f_e_denorm_unpacked, f_e_pos );
const uint32 f_em_denorm = _uint32_or( f_e_denorm, f_m_denorm ); const uint32 f_em_denorm = _uint32_or( f_e_denorm, f_m_denorm );
const uint32 f_em_nan = _uint32_or( f_e_mask, f_m );
const uint32 is_e_eqz_msb = _uint32_dec( h_e ); const uint32 is_e_eqz_msb = _uint32_dec( h_e );
const uint32 is_m_nez_msb = _uint32_neg( h_m ); const uint32 is_m_nez_msb = _uint32_neg( h_m );
const uint32 is_e_flagged_msb = _uint32_sub( h_e_mask_minus_one, h_e );
const uint32 is_zero_msb = _uint32_andc( is_e_eqz_msb, is_m_nez_msb ); const uint32 is_zero_msb = _uint32_andc( is_e_eqz_msb, is_m_nez_msb );
const uint32 is_denorm_msb = _uint32_and( is_m_nez_msb, is_e_eqz_msb ); const uint32 is_denorm_msb = _uint32_and( is_m_nez_msb, is_e_eqz_msb );
const uint32 is_zero = _uint32_ext( is_zero_msb ); const uint32 is_zero = _uint32_ext( is_zero_msb );

13
src/nvmath/Matrix.h
View File

@ -33,6 +33,8 @@ namespace nv
void operator+=(const Matrix3 & m); void operator+=(const Matrix3 & m);
void operator-=(const Matrix3 & m); void operator-=(const Matrix3 & m);
float determinant() const;
private: private:
scalar m_data[9]; scalar m_data[9];
}; };
@ -179,6 +181,17 @@ namespace nv
return mul(a, b); return mul(a, b);
} }
inline float Matrix3::determinant() const
{
return
get(0,0) * get(1,1) * get(2,2) +
get(0,1) * get(1,2) * get(2,0) +
get(0,2) * get(1,0) * get(2,1) -
get(0,2) * get(1,1) * get(2,0) -
get(0,1) * get(1,0) * get(2,2) -
get(0,0) * get(1,2) * get(2,1);
}
/// 4x4 transformation matrix. /// 4x4 transformation matrix.

69
src/nvtt/CompressionOptions.cpp
View File

@ -24,6 +24,7 @@
#include "nvtt.h" #include "nvtt.h"
#include "CompressionOptions.h" #include "CompressionOptions.h"
#include "nvimage/DirectDrawSurface.h"
using namespace nv; using namespace nv;
using namespace nvtt; using namespace nvtt;
@ -92,10 +93,10 @@ void CompressionOptions::setQuality(Quality quality)
/// perception more than a 7%. A better choice in my opinion is (3, 4, 2). /// perception more than a 7%. A better choice in my opinion is (3, 4, 2).
void CompressionOptions::setColorWeights(float red, float green, float blue, float alpha/*=1.0f*/) void CompressionOptions::setColorWeights(float red, float green, float blue, float alpha/*=1.0f*/)
{ {
// float total = red + green + blue; // float total = red + green + blue;
// float x = red / total; // float x = red / total;
// float y = green / total; // float y = green / total;
// m.colorWeight.set(x, y, 1.0f - x - y); // m.colorWeight.set(x, y, 1.0f - x - y);
m.colorWeight.set(red, green, blue, alpha); m.colorWeight.set(red, green, blue, alpha);
} }
@ -185,4 +186,64 @@ void CompressionOptions::setQuantization(bool colorDithering, bool alphaDitherin
} }
// Translate to and from D3D formats.
unsigned int CompressionOptions::d3d9Format() const
{
if (m.format == Format_RGB) {
if (m.pixelType == PixelType_UnsignedNorm) {
uint bitcount = m.bitcount;
uint rmask = m.rmask;
uint gmask = m.gmask;
uint bmask = m.bmask;
uint amask = m.amask;
if (bitcount == 0) {
bitcount = m.rsize + m.gsize + m.bsize + m.asize;
rmask = ((1 << m.rsize) - 1) << (m.asize + m.bsize + m.gsize);
gmask = ((1 << m.gsize) - 1) << (m.asize + m.bsize);
bmask = ((1 << m.bsize) - 1) << m.asize;
amask = ((1 << m.asize) - 1) << 0;
}
if (bitcount <= 32) {
return nv::findD3D9Format(bitcount, rmask, gmask, bmask, amask);
}
}
return 0;
}
else {
uint d3d9_formats[] = {
0, // Format_RGB,
FOURCC_DXT1, // Format_DXT1
FOURCC_DXT1, // Format_DXT1a
FOURCC_DXT3, // Format_DXT3
FOURCC_DXT5, // Format_DXT5
FOURCC_DXT5, // Format_DXT5n
FOURCC_ATI1, // Format_BC4
FOURCC_ATI2, // Format_BC5
FOURCC_DXT1, // Format_DXT1n
0, // Format_CTX1
0, // Format_BC6
0, // Format_BC7
0, // Format_RGBE
};
return d3d9_formats[m.format];
}
}
/*
bool CompressionOptions::setDirect3D9Format(unsigned int format)
{
}
unsigned int CompressionOptions::dxgiFormat() const
{
}
bool CompressionOptions::setDXGIFormat(unsigned int format)
{
}
*/

34
src/nvtt/CompressorDX9.cpp
View File

@ -144,23 +144,23 @@ void NormalCompressorDXT1::compressBlock(ColorSet & set, nvtt::AlphaMode alphaMo
} }
} }
#else #else
void NormalCompressorDXT1::compressBlock(ColorBlock & rgba, nvtt::AlphaMode alphaMode, const nvtt::CompressionOptions::Private & compressionOptions, void * output) void NormalCompressorDXT1::compressBlock(ColorBlock & rgba, nvtt::AlphaMode alphaMode, const nvtt::CompressionOptions::Private & compressionOptions, void * output)
{ {
nvsquish::WeightedClusterFit fit; nvsquish::WeightedClusterFit fit;
fit.SetMetric(compressionOptions.colorWeight.x, compressionOptions.colorWeight.y, compressionOptions.colorWeight.z); fit.SetMetric(compressionOptions.colorWeight.x, compressionOptions.colorWeight.y, compressionOptions.colorWeight.z);
if (rgba.isSingleColor()) if (rgba.isSingleColor())
{ {
BlockDXT1 * block = new(output) BlockDXT1; BlockDXT1 * block = new(output) BlockDXT1;
OptimalCompress::compressDXT1(rgba.color(0), block); OptimalCompress::compressDXT1(rgba.color(0), block);
} }
else else
{ {
nvsquish::ColourSet colours((uint8 *)rgba.colors(), 0); nvsquish::ColourSet colours((uint8 *)rgba.colors(), 0);
fit.SetColourSet(&colours, nvsquish::kDxt1); fit.SetColourSet(&colours, nvsquish::kDxt1);
fit.Compress(output); fit.Compress(output);
} }
} }
#endif #endif
void NormalCompressorDXT1a::compressBlock(ColorBlock & rgba, nvtt::AlphaMode alphaMode, const nvtt::CompressionOptions::Private & compressionOptions, void * output) void NormalCompressorDXT1a::compressBlock(ColorBlock & rgba, nvtt::AlphaMode alphaMode, const nvtt::CompressionOptions::Private & compressionOptions, void * output)

5
src/nvtt/CompressorRGB.cpp
View File

@ -110,7 +110,10 @@ namespace
{ {
nvDebugCheck(alignment >= 1); nvDebugCheck(alignment >= 1);
flush(); flush();
putBits(0, ((size_t)ptr % alignment) * 8); int remainder = (size_t)ptr % alignment;
if (remainder != 0) {
putBits(0, (alignment - remainder) * 8);
}
} }
uint8 * ptr; uint8 * ptr;

44
src/nvtt/Context.cpp
View File

@ -571,7 +571,7 @@ bool Compressor::Private::outputHeader(nvtt::TextureType textureType, int w, int
header.setSwizzleCode('A', '2', 'X', 'Y'); header.setSwizzleCode('A', '2', 'X', 'Y');
} }
} }
else if (compressionOptions.format == Format_BC6) { else if (compressionOptions.format == Format_BC6) { // @@ This is not supported by D3DX. Always use DX10 header with BC6-7 formats.
header.setFourCC('Z', 'O', 'H', ' '); header.setFourCC('Z', 'O', 'H', ' ');
} }
else if (compressionOptions.format == Format_BC7) { else if (compressionOptions.format == Format_BC7) {
@ -586,6 +586,8 @@ bool Compressor::Private::outputHeader(nvtt::TextureType textureType, int w, int
supported = false; supported = false;
} }
} }
if (outputOptions.srgb) header.setSrgbFlag(true);
} }
if (!supported) if (!supported)
@ -595,9 +597,6 @@ bool Compressor::Private::outputHeader(nvtt::TextureType textureType, int w, int
return false; return false;
} }
// Swap bytes if necessary.
header.swapBytes();
uint headerSize = 128; uint headerSize = 128;
if (header.hasDX10Header()) if (header.hasDX10Header())
{ {
@ -605,6 +604,9 @@ bool Compressor::Private::outputHeader(nvtt::TextureType textureType, int w, int
headerSize = 128 + 20; headerSize = 128 + 20;
} }
// Swap bytes if necessary.
header.swapBytes();
bool writeSucceed = outputOptions.writeData(&header, headerSize); bool writeSucceed = outputOptions.writeData(&header, headerSize);
if (!writeSucceed) if (!writeSucceed)
{ {
@ -796,37 +798,3 @@ CompressorInterface * Compressor::Private::chooseGpuCompressor(const Compression
return NULL; return NULL;
} }
/*
int Compressor::Private::estimateSize(const InputOptions::Private & inputOptions, const CompressionOptions::Private & compressionOptions) const
{
const Format format = compressionOptions.format;
const uint bitCount = compressionOptions.getBitCount();
const uint pitchAlignment = compressionOptions.pitchAlignment;
uint mipmapCount, width, height, depth;
inputOptions.computeExtents(&mipmapCount, &width, &height, &depth);
int size = 0;
for (uint f = 0; f < inputOptions.faceCount; f++)
{
uint w = inputOptions.targetWidth;
uint h = inputOptions.targetHeight;
uint d = inputOptions.targetDepth;
for (uint m = 0; m < mipmapCount; m++)
{
size += computeImageSize(w, h, d, bitCount, pitchAlignment, format);
// Compute extents of next mipmap:
w = max(1U, w / 2);
h = max(1U, h / 2);
d = max(1U, d / 2);
}
}
return size;
}
*/

7
src/nvtt/OutputOptions.cpp
View File

@ -51,6 +51,7 @@ void OutputOptions::reset()
m.outputHeader = true; m.outputHeader = true;
m.container = Container_DDS; m.container = Container_DDS;
m.version = 0; m.version = 0;
m.srgb = false;
} }
@ -108,6 +109,12 @@ void OutputOptions::setUserVersion(int version)
m.version = version; m.version = version;
} }
/// Set SRGB flag.
void OutputOptions::setSrgbFlag(bool b)
{
m.srgb = b;
}
bool OutputOptions::Private::hasValidOutputHandler() const bool OutputOptions::Private::hasValidOutputHandler() const
{ {
if (!fileName.isNull()) if (!fileName.isNull())

1
src/nvtt/OutputOptions.h
View File

@ -66,6 +66,7 @@ namespace nvtt
bool outputHeader; bool outputHeader;
Container container; Container container;
int version; int version;
bool srgb;
bool hasValidOutputHandler() const; bool hasValidOutputHandler() const;

5
src/nvtt/TexImage.cpp
View File

@ -234,6 +234,11 @@ void TexImage::setNormalMap(bool isNormalMap)
} }
} }
bool TexImage::isNull() const
{
return m->image == NULL;
}
int TexImage::width() const int TexImage::width() const
{ {
if (m->image != NULL) return m->image->width(); if (m->image != NULL) return m->image->width();

8
src/nvtt/nvtt.h
View File

@ -147,6 +147,12 @@ namespace nvtt
NVTT_API void setPitchAlignment(int pitchAlignment); NVTT_API void setPitchAlignment(int pitchAlignment);
NVTT_API void setQuantization(bool colorDithering, bool alphaDithering, bool binaryAlpha, int alphaThreshold = 127); NVTT_API void setQuantization(bool colorDithering, bool alphaDithering, bool binaryAlpha, int alphaThreshold = 127);
// Translate to and from D3D formats.
NVTT_API unsigned int d3d9Format() const;
//NVTT_API bool setD3D9Format(unsigned int format);
//NVTT_API unsigned int dxgiFormat() const;
//NVTT_API bool setDxgiFormat(unsigned int format);
}; };
/* /*
@ -329,6 +335,7 @@ namespace nvtt
NVTT_API void setOutputHeader(bool outputHeader); NVTT_API void setOutputHeader(bool outputHeader);
NVTT_API void setContainer(Container container); NVTT_API void setContainer(Container container);
NVTT_API void setUserVersion(int version); NVTT_API void setUserVersion(int version);
NVTT_API void setSrgbFlag(bool b);
}; };
typedef void Task(void * context, int id); typedef void Task(void * context, int id);
@ -392,6 +399,7 @@ namespace nvtt
NVTT_API void setNormalMap(bool isNormalMap); NVTT_API void setNormalMap(bool isNormalMap);
// Queries. // Queries.
NVTT_API bool isNull() const;
NVTT_API int width() const; NVTT_API int width() const;
NVTT_API int height() const; NVTT_API int height() const;
NVTT_API int depth() const; NVTT_API int depth() const;

2
src/nvtt/tools/compress.cpp
View File

@ -451,7 +451,7 @@ int main(int argc, char *argv[])
} }
// Block compressed textures with mipmaps must be powers of two. // Block compressed textures with mipmaps must be powers of two.
//if (!noMipmaps && format != nvtt::Format_RGB) if (!noMipmaps && format != nvtt::Format_RGB)
{ {
inputOptions.setRoundMode(nvtt::RoundMode_ToNearestPowerOfTwo); inputOptions.setRoundMode(nvtt::RoundMode_ToNearestPowerOfTwo);
} }