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

Some progress with full DXT1a support.

Browse Source 
Move quantization settings to compression options.
2.0
castano 17 years ago
parent f3a73e3de5
commit 2903886498
8 changed files with 96 additions and 149 deletions
Show Stats Download Patch File Download Diff File

31
src/nvtt/CompressDXT.cpp
Unescape Escape View File

@ -225,6 +225,37 @@ void nv::compressDXT1(const Image * image, const OutputOptions::Private & output
}
void nv::compressDXT1a(const Image * image, const OutputOptions::Private & outputOptions, const CompressionOptions::Private & compressionOptions)
{
const uint w = image->width();
const uint h = image->height();
ColorBlock rgba;
BlockDXT1 block;
doPrecomputation();
for (uint y = 0; y < h; y += 4) {
for (uint x = 0; x < w; x += 4) {
rgba.init(image, x, y);
// Compress color.
squish::WeightedClusterFit fit(&colours, squish::kDxt1);
squish::ClusterFit fit(&colours, squish::kDxt1);
fit.setMetric(compressionOptions.colorWeight.x(), compressionOptions.colorWeight.y(), compressionOptions.colorWeight.z());
fit.Compress(&block);
// @@ Use iterative cluster fit algorithm to improve error in highest quality mode.
if (outputOptions.outputHandler != NULL) {
outputOptions.outputHandler->writeData(&block, sizeof(block));
}
}
}
}
void nv::compressDXT3(const Image * image, const OutputOptions::Private & outputOptions, const CompressionOptions::Private & compressionOptions)
{
const uint w = image->width();

1
src/nvtt/CompressDXT.h
Unescape Escape View File

@ -45,6 +45,7 @@ namespace nv
// Normal compressors.
void compressDXT1(const Image * image, const nvtt::OutputOptions::Private & outputOptions, const nvtt::CompressionOptions::Private & compressionOptions);
void compressDXT1a(const Image * image, const nvtt::OutputOptions::Private & outputOptions, const nvtt::CompressionOptions::Private & compressionOptions);
void compressDXT3(const Image * image, const nvtt::OutputOptions::Private & outputOptions, const nvtt::CompressionOptions::Private & compressionOptions);
void compressDXT5(const Image * image, const nvtt::OutputOptions::Private & outputOptions, const nvtt::CompressionOptions::Private & compressionOptions);
void compressDXT5n(const Image * image, const nvtt::OutputOptions::Private & outputOptions, const nvtt::CompressionOptions::Private & compressionOptions);

22
src/nvtt/CompressionOptions.cpp
Unescape Escape View File

@ -49,11 +49,17 @@ void CompressionOptions::reset()
m.quality = Quality_Normal;
m.colorWeight.set(1.0f, 1.0f, 1.0f);
m.useCuda = true;
m.bitcount = 32;
m.bmask = 0x000000FF;
m.gmask = 0x0000FF00;
m.rmask = 0x00FF0000;
m.amask = 0xFF000000;
m.enableColorDithering = false;
m.enableAlphaDithering = false;
m.binaryAlpha = false;
m.alphaThreshold = 127;
}
@ -134,3 +140,19 @@ void CompressionOptions::setExternalCompressor(const char * name)
m.externalCompressor = name;
}
/// Set quantization options.
/// @warning Do not enable dithering unless you know what you are doing. Quantization
/// introduces errors. It's better to let the compressor quantize the result to
/// minimize the error, instead of quantizing the data before handling it to
/// the compressor.
void CompressionOptions::setQuantization(bool colorDithering, bool alphaDithering, bool binaryAlpha, int alphaThreshold/*= 127*/)
{
nvCheck(alphaThreshold >= 0 && alphaThreshold < 256);
m.enableColorDithering = colorDithering;
m.enableAlphaDithering = alphaDithering;
m.binaryAlpha = binaryAlpha;
m.alphaThreshold = alphaThreshold;
}

9
src/nvtt/CompressionOptions.h
Unescape Escape View File

@ -36,10 +36,11 @@ namespace nvtt
Format format;
Quality quality;
float errorThreshold;
float errorThreshold; // deprecated.
nv::Vector3 colorWeight;
// Pixel format description.
uint bitcount;
uint rmask;
uint gmask;
@ -49,6 +50,12 @@ namespace nvtt
bool useCuda;
nv::String externalCompressor;
// Quantization.
bool enableColorDithering;
bool enableAlphaDithering;
bool binaryAlpha;
int alphaThreshold; // reference value used for binary alpha quantization.
};
} // nvtt namespace

20
src/nvtt/InputOptions.cpp
Unescape Escape View File

@ -94,11 +94,6 @@ void InputOptions::reset()
m.textureType = TextureType_2D;
m.inputFormat = InputFormat_BGRA_8UB;
m.enableColorDithering = false;
m.enableAlphaDithering = false;
m.binaryAlpha = false;
m.alphaThreshold = 127;
m.alphaMode = AlphaMode_Transparency;
m.inputGamma = 2.2f;
@ -262,21 +257,6 @@ void InputOptions::setKaiserParameters(float width, float alpha, float stretch)
m.kaiserStretch = stretch;
}
/// Set quantization options.
/// @warning Do not enable dithering unless you know what you are doing. Quantization
/// introduces errors. It's better to let the compressor quantize the result to
/// minimize the error, instead of quantizing the data before handling it to
/// the compressor.
void InputOptions::setQuantization(bool colorDithering, bool alphaDithering, bool binaryAlpha, int alphaThreshold/*= 127*/)
{
nvCheck(alphaThreshold >= 0 && alphaThreshold < 256);
m.enableColorDithering = colorDithering;
m.enableAlphaDithering = alphaDithering;
m.binaryAlpha = binaryAlpha;
m.alphaThreshold = alphaThreshold;
}
/// Indicate whether input is a normal map or not.
void InputOptions::setNormalMap(bool b)
{

6
src/nvtt/InputOptions.h
Unescape Escape View File

@ -49,12 +49,6 @@ namespace nvtt
struct Image;
Image * images;
// Quantization.
bool enableColorDithering;
bool enableAlphaDithering;
bool binaryAlpha;
int alphaThreshold; // reference value used for binary alpha quantization.
// Gamma conversion.
float inputGamma;
float outputGamma;

154
src/nvtt/nvtt.cpp
Unescape Escape View File

@ -216,8 +216,21 @@ static bool compressMipmap(const Image * image, const OutputOptions::Private & o
}
else if (compressionOptions.format == Format_DXT1a)
{
// @@ Only fast compression mode for now.
fastCompressDXT1a(image, outputOptions);
if (compressionOptions.quality == Quality_Fastest)
{
fastCompressDXT1a(image, outputOptions);
}
else
{
if (compressionOptions.useCuda && nv::cuda::isHardwarePresent())
{
/*cuda*/compressDXT1a(image, outputOptions);
}
else
{
compressDXT1a(image, outputOptions);
}
}
}
else if (compressionOptions.format == Format_DXT3)
{
@ -351,37 +364,37 @@ static FloatImage * createMipmap(const FloatImage * floatImage, const InputOptio
// Quantize the input image to the precision of the output format.
static void quantize(Image * img, const InputOptions::Private & inputOptions, Format format)
static void quantize(Image * img, const CompressionOptions::Private & compressionOptions)
{
if (inputOptions.enableColorDithering)
if (compressionOptions.enableColorDithering)
{
if (format >= Format_DXT1 && format <= Format_DXT5)
if (compressionOptions.format >= Format_DXT1 && compressionOptions.format <= Format_DXT5)
{
Quantize::FloydSteinberg_RGB16(img);
}
}
if (inputOptions.binaryAlpha)
if (compressionOptions.binaryAlpha)
{
if (inputOptions.enableAlphaDithering)
if (compressionOptions.enableAlphaDithering)
{
Quantize::FloydSteinberg_BinaryAlpha(img, inputOptions.alphaThreshold);
Quantize::FloydSteinberg_BinaryAlpha(img, compressionOptions.alphaThreshold);
}
else
{
Quantize::BinaryAlpha(img, inputOptions.alphaThreshold);
Quantize::BinaryAlpha(img, compressionOptions.alphaThreshold);
}
}
else
{
if (inputOptions.enableAlphaDithering)
if (compressionOptions.enableAlphaDithering)
{
if (format == Format_DXT3)
if (compressionOptions.format == Format_DXT3)
{
Quantize::Alpha4(img);
}
else if (format == Format_DXT1a)
else if (compressionOptions.format == Format_DXT1a)
{
Quantize::BinaryAlpha(img, inputOptions.alphaThreshold);
Quantize::BinaryAlpha(img, compressionOptions.alphaThreshold);
}
}
}
@ -575,8 +588,11 @@ static bool compressMipmaps(uint f, const InputOptions::Private & inputOptions,
}
ImagePair pair;
for (uint m = 0; m < inputOptions.mipmapCount; m++)
const uint mipmapCount = inputOptions.realMipmapCount();
nvDebugCheck(mipmapCount > 0);
for (uint m = 0; m < mipmapCount; m++)
{
if (outputOptions.outputHandler)
{
@ -594,7 +610,7 @@ static bool compressMipmaps(uint f, const InputOptions::Private & inputOptions,
pair.toFixed(inputOptions);
// @@ Quantization should be done in compressMipmap! @@ It should not modify the input image!!!
quantize(pair.fixedImage(), inputOptions, compressionOptions.format);
quantize(pair.fixedImage(), compressionOptions);
compressMipmap(pair.fixedImage(), outputOptions, compressionOptions);
@ -609,10 +625,6 @@ static bool compressMipmaps(uint f, const InputOptions::Private & inputOptions,
static bool compress(const InputOptions::Private & inputOptions, const OutputOptions::Private & outputOptions, const CompressionOptions::Private & compressionOptions)
{
// Make sure enums match.
@ -629,9 +641,6 @@ static bool compress(const InputOptions::Private & inputOptions, const OutputOpt
inputOptions.computeTargetExtents();
uint mipmapCount = inputOptions.realMipmapCount();
nvDebugCheck(mipmapCount > 0);
// Output DDS header.
outputHeader(inputOptions, outputOptions, compressionOptions);
@ -641,105 +650,6 @@ static bool compress(const InputOptions::Private & inputOptions, const OutputOpt
{
return false;
}
/*
Image * lastImage = NULL;
AutoPtr<FloatImage> floatImage(NULL);
uint w = inputOptions.targetWidth;
uint h = inputOptions.targetHeight;
uint d = inputOptions.targetDepth;
for (uint m = 0; m < mipmapCount; m++)
{
if (outputOptions.outputHandler)
{
int size = computeImageSize(w, h, bitCount, format);
outputOptions.outputHandler->mipmap(size, w, h, d, f, m);
}
// @@ Write a more sofisticated get input image, that:
// - looks for the nearest image in the input mipmap chain, resizes it to desired extents.
// - uses previous floating point image, if available.
// - uses previous byte image if available.
int idx = f * inputOptions.mipmapCount + m;
InputOptions::Private::Image & mipmap = inputOptions.images[idx];
// @@ Prescale not implemented yet.
nvCheck(w == mipmap.width);
nvCheck(h == mipmap.height);
nvCheck(d == mipmap.depth);
Image * img = NULL; // Image to compress.
if (mipmap.data != NULL) // Mipmap provided.
{
// Convert to normal map.
if (inputOptions.convertToNormalMap)
{
// Scale height factor by 1 / 2 ^ m
Vector4 heightScale = inputOptions.heightFactors / float(1 << m);
floatImage = createNormalMap(mipmap.data.ptr(), (FloatImage::WrapMode)inputOptions.wrapMode, heightScale, inputOptions.bumpFrequencyScale);
}
else
{
lastImage = img = mipmap.data.ptr();
// Delete float image.
floatImage = NULL;
}
}
else // Create mipmap from last.
{
if (m == 0) {
// First mipmap missing.
if (outputOptions.errorHandler != NULL) outputOptions.errorHandler->error(Error_InvalidInput);
return false;
}
if (floatImage == NULL)
{
nvDebugCheck(lastImage != NULL);
floatImage = toFloatImage(lastImage, inputOptions);
}
// Create mipmap.
floatImage = createMipmap(floatImage.ptr(), inputOptions);
}
if (floatImage != NULL)
{
// Convert to fixed.
img = toFixedImage(floatImage.ptr(), inputOptions);
}
// @@ Where to do the color transform?
// - Color transform may not be linear, so we cannot do before computing mipmaps.
// - Should be done in linear space, that is, after gamma correction.
// @@ Error! gamma correction is not performed when mipmap data provided. (only if inputGamma != outputGamma)
// @@ This code is too complicated, too prone to erros, and hard to understand. Must be simplified!
// @@ Quantization should be done in compressMipmap!
quantize(img, inputOptions, format);
compressMipmap(img, outputOptions, compressionOptions);
if (img != mipmap.data)
{
delete img;
}
// Compute extents of next mipmap:
w = max(1U, w / 2);
h = max(1U, h / 2);
d = max(1U, d / 2);
}
*/
}
outputOptions.closeFile();

2
src/nvtt/nvtt.h
Unescape Escape View File

@ -100,6 +100,8 @@ namespace nvtt
// Set color mask to describe the RGB/RGBA format.
NVTT_API void setPixelFormat(unsigned int bitcount, unsigned int rmask, unsigned int gmask, unsigned int bmask, unsigned int amask);
NVTT_API void setQuantization(bool colorDithering, bool alphaDithering, bool binaryAlpha, int alphaThreshold/*= 127*/);
//private:
struct Private;
Private & m;

Write Preview
Loading…
Cancel
Save