From 5475f3526299563f30e5141cb69816eaac4123fc Mon Sep 17 00:00:00 2001 From: castano Date: Thu, 31 Jan 2008 09:17:32 +0000 Subject: [PATCH] Some cleanup. --- src/nvtt/Compressor.cpp | 185 ++++++++++++++++++++++++++------------ src/nvtt/Compressor.h | 5 +- src/nvtt/InputOptions.cpp | 15 +++- src/nvtt/InputOptions.h | 10 ++- src/nvtt/nvtt.cpp | 6 +- 5 files changed, 152 insertions(+), 69 deletions(-) diff --git a/src/nvtt/Compressor.cpp b/src/nvtt/Compressor.cpp index 036e23e..5d340df 100644 --- a/src/nvtt/Compressor.cpp +++ b/src/nvtt/Compressor.cpp @@ -92,7 +92,70 @@ namespace return ((w + 3) / 4) * ((h + 3) / 4) * blockSize(format); } } - + + // Mipmap could be: + // - a pointer to an input image. + // - a fixed point image. + // - a floating point image. + struct Mipmap + { + Mipmap() : m_inputImage(NULL) {} + ~Mipmap() {} + + // Reference input image. + void set(const InputOptions::Private & inputOptions, uint f, uint m) + { + m_inputImage = inputOptions.image(f, m); + m_fixedImage = NULL; + m_floatImage = NULL; + } + + // Assign and take ownership of given image. + void set(FloatImage * image) + { + m_inputImage = NULL; + m_fixedImage = NULL; + m_floatImage = image; + } + + // Assign and take ownership of given image. + void set(Image * image) + { + m_inputImage = NULL; + m_fixedImage = image; + m_floatImage = NULL; + } + + + const FloatImage * asFloatImage() const + { + return m_floatImage.ptr(); + } + + const Image * asFixedImage() const + { + if (m_inputImage != NULL) + { + return m_inputImage; + } + return m_fixedImage.ptr(); + } + + /*void toFixed(const InputOptions::Private & inputOptions) + { + if (m_floatImage != NULL) + { + // Convert to fixed. + m_fixedImage = toFixedImage(m_floatImage.ptr(), inputOptions); + } + }*/ + + private: + const Image * m_inputImage; + AutoPtr m_fixedImage; + AutoPtr m_floatImage; + }; + } // namespace @@ -162,17 +225,17 @@ bool Compressor::Private::compress(const InputOptions::Private & inputOptions, c inputOptions.computeTargetExtents(); // Output DDS header. - if (!outputHeader(inputOptions, outputOptions, compressionOptions)) + if (!outputHeader(inputOptions, compressionOptions, outputOptions)) { return false; } for (uint f = 0; f < inputOptions.faceCount; f++) { - /*if (!compressMipmaps(f, inputOptions, outputOptions, compressionOptions)) + if (!compressMipmaps(f, inputOptions, compressionOptions, outputOptions)) { return false; - }*/ + } } outputOptions.closeFile(); @@ -182,7 +245,7 @@ bool Compressor::Private::compress(const InputOptions::Private & inputOptions, c // Output DDS header. -bool Compressor::Private::outputHeader(const InputOptions::Private & inputOptions, const OutputOptions::Private & outputOptions, const CompressionOptions::Private & compressionOptions) const +bool Compressor::Private::outputHeader(const InputOptions::Private & inputOptions, const CompressionOptions::Private & compressionOptions, const OutputOptions::Private & outputOptions) const { // Output DDS header. if (outputOptions.outputHandler == NULL || !outputOptions.outputHeader) @@ -262,7 +325,64 @@ bool Compressor::Private::outputHeader(const InputOptions::Private & inputOption return writeSucceed; } -// @@ compressMipmaps... + +bool Compressor::Private::compressMipmaps(uint f, const InputOptions::Private & inputOptions, const CompressionOptions::Private & compressionOptions, const OutputOptions::Private & outputOptions) const +{ + uint w = inputOptions.targetWidth; + uint h = inputOptions.targetHeight; + uint d = inputOptions.targetDepth; + /* + int inputImageIdx = findMipmap(inputOptions, f, 0, w, h, d); + if (inputImageIdx == -1) + { + // First mipmap missing. + if (outputOptions.errorHandler != NULL) outputOptions.errorHandler->error(Error_InvalidInput); + return false; + } + + ImagePair pair; + */ + + Mipmap mipmap; + // Mipmap could be: + // - a pointer to an input image. + // - a fixed point image. + // - a floating point image. + + const uint mipmapCount = inputOptions.realMipmapCount(); + nvDebugCheck(mipmapCount > 0); + + for (uint m = 0; m < mipmapCount; m++) + { + if (outputOptions.outputHandler) + { + int size = computeImageSize(w, h, d, compressionOptions.bitcount, compressionOptions.format); + outputOptions.outputHandler->mipmap(size, w, h, d, f, m); + } + /* + inputImageIdx = findImage(inputOptions, f, w, h, d, inputImageIdx, &pair); + + // @@ 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. + + + pair.toFixed(inputOptions); + + // @@ Quantization should be done in compressMipmap! @@ It should not modify the input image!!! + quantize(pair.fixedImage(), compressionOptions); + + compressMipmap(pair.fixedImage(), outputOptions, compressionOptions); + */ + + // Compute extents of next mipmap: + w = max(1U, w / 2); + h = max(1U, h / 2); + d = max(1U, d / 2); + } + + return true; +} #if 0 @@ -546,60 +666,9 @@ static int findImage(const InputOptions::Private & inputOptions, uint f, uint w, return bestIdx; // @@ ??? } - -static bool compressMipmaps(uint f, const InputOptions::Private & inputOptions, const OutputOptions::Private & outputOptions, const CompressionOptions::Private & compressionOptions) -{ - uint w = inputOptions.targetWidth; - uint h = inputOptions.targetHeight; - uint d = inputOptions.targetDepth; - - int inputImageIdx = findMipmap(inputOptions, f, 0, w, h, d); - if (inputImageIdx == -1) - { - // First mipmap missing. - if (outputOptions.errorHandler != NULL) outputOptions.errorHandler->error(Error_InvalidInput); - return false; - } - - ImagePair pair; - - const uint mipmapCount = inputOptions.realMipmapCount(); - nvDebugCheck(mipmapCount > 0); - - for (uint m = 0; m < mipmapCount; m++) - { - if (outputOptions.outputHandler) - { - int size = computeImageSize(w, h, compressionOptions.bitcount, compressionOptions.format); - outputOptions.outputHandler->mipmap(size, w, h, d, f, m); - } - - inputImageIdx = findImage(inputOptions, f, w, h, d, inputImageIdx, &pair); - - // @@ 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. - - - pair.toFixed(inputOptions); - - // @@ Quantization should be done in compressMipmap! @@ It should not modify the input image!!! - quantize(pair.fixedImage(), compressionOptions); - - compressMipmap(pair.fixedImage(), outputOptions, compressionOptions); - - // Compute extents of next mipmap: - w = max(1U, w / 2); - h = max(1U, h / 2); - d = max(1U, d / 2); - } - - return true; -} - #endif // 0 -bool Compressor::Private::compressMipmap(const Image * image, const OutputOptions::Private & outputOptions, const CompressionOptions::Private & compressionOptions) const +bool Compressor::Private::compressMipmap(const Image * image, const CompressionOptions::Private & compressionOptions, const OutputOptions::Private & outputOptions) const { nvDebugCheck(image != NULL); diff --git a/src/nvtt/Compressor.h b/src/nvtt/Compressor.h index 5e6ddc3..6f9b2dc 100644 --- a/src/nvtt/Compressor.h +++ b/src/nvtt/Compressor.h @@ -43,8 +43,9 @@ namespace nvtt private: - bool outputHeader(const InputOptions::Private & inputOptions, const OutputOptions::Private & outputOptions, const CompressionOptions::Private & compressionOptions) const; - bool compressMipmap(const nv::Image * image, const OutputOptions::Private & outputOptions, const CompressionOptions::Private & compressionOptions) const; + bool outputHeader(const InputOptions::Private & inputOptions, const CompressionOptions::Private & compressionOptions, const OutputOptions::Private & outputOptions) const; + bool compressMipmaps(uint f, const InputOptions::Private & inputOptions, const CompressionOptions::Private & compressionOptions, const OutputOptions::Private & outputOptions) const; + bool compressMipmap(const nv::Image * image, const CompressionOptions::Private & compressionOptions, const OutputOptions::Private & outputOptions) const; public: diff --git a/src/nvtt/InputOptions.cpp b/src/nvtt/InputOptions.cpp index 459ae57..1ebab63 100644 --- a/src/nvtt/InputOptions.cpp +++ b/src/nvtt/InputOptions.cpp @@ -144,7 +144,7 @@ void InputOptions::setTextureLayout(TextureType type, int width, int height, int m.faceCount = (type == TextureType_Cube) ? 6 : 1; m.imageCount = m.mipmapCount * m.faceCount; - m.images = new Private::Image[m.imageCount]; + m.images = new Private::InputImage[m.imageCount]; for(uint f = 0; f < m.faceCount; f++) { @@ -154,7 +154,7 @@ void InputOptions::setTextureLayout(TextureType type, int width, int height, int for (uint mipLevel = 0; mipLevel < m.mipmapCount; mipLevel++) { - Private::Image & img = m.images[f * m.mipmapCount + mipLevel]; + Private::InputImage & img = m.images[f * m.mipmapCount + mipLevel]; img.width = w; img.height = h; img.depth = d; @@ -381,3 +381,14 @@ int InputOptions::Private::realMipmapCount() const } +const Image * InputOptions::Private::image(uint face, uint mipmap) const +{ + nvDebugCheck(face < faceCount); + nvDebugCheck(mipmap < mipmapCount); + + const InputImage & image = this->images[face * mipmapCount + mipmap]; + nvDebugCheck(image.face == face); + nvDebugCheck(image.mipLevel == mipmap); + + return image.data.ptr(); +} diff --git a/src/nvtt/InputOptions.h b/src/nvtt/InputOptions.h index d2f3f66..8964d06 100644 --- a/src/nvtt/InputOptions.h +++ b/src/nvtt/InputOptions.h @@ -46,8 +46,8 @@ namespace nvtt uint mipmapCount; uint imageCount; - struct Image; - Image * images; + struct InputImage; + InputImage * images; // Gamma conversion. float inputGamma; @@ -88,12 +88,14 @@ namespace nvtt int realMipmapCount() const; + const nv::Image * image(uint face, uint mipmap) const; + }; // Internal image structure. - struct InputOptions::Private::Image + struct InputOptions::Private::InputImage { - Image() {} + InputImage() {} int mipLevel; int face; diff --git a/src/nvtt/nvtt.cpp b/src/nvtt/nvtt.cpp index 3c20b44..80b73a8 100644 --- a/src/nvtt/nvtt.cpp +++ b/src/nvtt/nvtt.cpp @@ -410,7 +410,7 @@ static void quantize(Image * img, const CompressionOptions::Private & compressio // Process the input, convert to normal map, normalize, or convert to linear space. static FloatImage * processInput(const InputOptions::Private & inputOptions, int idx) { - const InputOptions::Private::Image & mipmap = inputOptions.images[idx]; + const InputOptions::Private::InputImage & mipmap = inputOptions.images[idx]; if (inputOptions.convertToNormalMap) { @@ -499,7 +499,7 @@ static int findMipmap(const InputOptions::Private & inputOptions, uint f, int fi for (int m = firstMipmap; m < int(inputOptions.mipmapCount); m++) { int idx = f * inputOptions.mipmapCount + m; - const InputOptions::Private::Image & mipmap = inputOptions.images[idx]; + const InputOptions::Private::InputImage & mipmap = inputOptions.images[idx]; if (mipmap.width >= int(w) && mipmap.height >= int(h) && mipmap.depth >= int(d)) { @@ -527,7 +527,7 @@ static int findImage(const InputOptions::Private & inputOptions, uint f, uint w, nvDebugCheck(pair != NULL); int bestIdx = findMipmap(inputOptions, f, inputImageIdx, w, h, d); - const InputOptions::Private::Image & mipmap = inputOptions.images[bestIdx]; + const InputOptions::Private::InputImage & mipmap = inputOptions.images[bestIdx]; if (mipmap.width == w && mipmap.height == h && mipmap.depth == d) {