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

Fix errors in new implementation of InputOptions.

Browse Source 
Output cube map faces in DDS order. Fixes issue 147.
pull/216/head
castano 14 years ago
parent 5225f4810f
commit c1204bfb66
10 changed files with 697 additions and 938 deletions
Show Stats Download Patch File Download Diff File

28
src/nvimage/FloatImage.cpp
Unescape Escape View File

@ -129,16 +129,19 @@ Image * FloatImage::createImageGammaCorrect(float gamma/*= 2.2f*/) const
return img.release();
}
/// Allocate a 2d float image of the given format and the given extents.
/// Allocate a 2D float image of the given format and the given extents.
void FloatImage::allocate(uint c, uint w, uint h)
{
free();
if (m_componentNum != c || m_width != w || m_height != h)
{
free();
m_width = w;
m_height = h;
m_componentNum = c;
m_count = w * h * c;
m_mem = malloc<float>(m_count);
m_width = w;
m_height = h;
m_componentNum = c;
m_count = w * h * c;
m_mem = malloc<float>(m_count);
}
}
/// Free the image, but don't clear the members.
@ -1034,16 +1037,9 @@ void FloatImage::scaleAlphaToCoverage(float desiredCoverage, float alphaRef, int
FloatImage* FloatImage::clone() const
{
FloatImage* copy = new FloatImage();
copy->m_width = m_width;
copy->m_height = m_height;
copy->m_componentNum = m_componentNum;
copy->m_count = m_count;
if(m_mem)
{
copy->allocate(m_componentNum, m_width, m_height);
memcpy(copy->m_mem, m_mem, m_count * sizeof(float));
}
copy->allocate(m_componentNum, m_width, m_height);
memcpy(copy->m_mem, m_mem, m_count * sizeof(float));
return copy;
}

239
src/nvtt/Context.cpp
Unescape Escape View File

@ -52,59 +52,10 @@
#include "nvcore/Memory.h"
#include "nvcore/Ptr.h"
using namespace nv;
using namespace nvtt;
namespace
{
static int blockSize(Format format)
{
if (format == Format_DXT1 || format == Format_DXT1a || format == Format_DXT1n) {
return 8;
}
else if (format == Format_DXT3) {
return 16;
}
else if (format == Format_DXT5 || format == Format_DXT5n) {
return 16;
}
else if (format == Format_BC4) {
return 8;
}
else if (format == Format_BC5) {
return 16;
}
else if (format == Format_CTX1) {
return 8;
}
else if (format == Format_BC6) {
return 16;
}
else if (format == Format_BC7) {
return 16;
}
return 0;
}
static int computeImageSize(uint w, uint h, uint d, uint bitCount, uint alignment, Format format)
{
if (format == Format_RGBA) {
return d * h * computePitch(w, bitCount, alignment);
}
else {
// @@ Handle 3D textures. DXT and VTC have different behaviors.
return ((w + 3) / 4) * ((h + 3) / 4) * blockSize(format);
}
}
} // namespace
Compressor::Compressor() : m(*new Compressor::Private())
{
@ -166,12 +117,12 @@ bool Compressor::process(const InputOptions & inputOptions, const CompressionOpt
int Compressor::estimateSize(const InputOptions & inputOptions, const CompressionOptions & compressionOptions) const
{
// @@ Compute w, h, mipmapCount based on inputOptions settings.
const int w = 0;
const int h = 0;
const int d = 1;
int mipmapCount = 1;
int w = inputOptions.m.width;
int h = inputOptions.m.height;
int d = inputOptions.m.depth;
getTargetExtent(w, h, d, inputOptions.m.maxExtent, inputOptions.m.roundMode, inputOptions.m.textureType);
int mipmapCount = countMipmaps(w, h, d);
return inputOptions.m.faceCount * estimateSize(w, h, d, mipmapCount, compressionOptions);
}
@ -179,7 +130,7 @@ int Compressor::estimateSize(const InputOptions & inputOptions, const Compressio
// TexImage API.
bool Compressor::outputHeader(const TexImage & tex, int mipmapCount, const CompressionOptions & compressionOptions, const OutputOptions & outputOptions) const
{
return m.outputHeader(tex, mipmapCount, compressionOptions.m, outputOptions.m);
return m.outputHeader(TextureType_2D, tex.width(), tex.height(), tex.depth(), mipmapCount, tex.isNormalMap(), compressionOptions.m, outputOptions.m);
}
bool Compressor::compress(const TexImage & tex, const CompressionOptions & compressionOptions, const OutputOptions & outputOptions) const
@ -192,9 +143,8 @@ int Compressor::estimateSize(const TexImage & tex, int mipmapCount, const Compre
const int w = tex.width();
const int h = tex.height();
const int d = tex.depth();
const int faceCount = tex.faceCount();
return faceCount * estimateSize(w, h, d, mipmapCount, compressionOptions);
return estimateSize(w, h, d, mipmapCount, compressionOptions);
}
@ -244,7 +194,6 @@ bool Compressor::Private::compress(const InputOptions::Private & inputOptions, c
}
nvtt::TexImage img;
img.setTextureType(inputOptions.textureType);
img.setWrapMode(inputOptions.wrapMode);
img.setAlphaMode(inputOptions.alphaMode);
img.setNormalMap(inputOptions.isNormalMap);
@ -254,108 +203,112 @@ bool Compressor::Private::compress(const InputOptions::Private & inputOptions, c
int h = inputOptions.height;
int d = inputOptions.depth;
for (int f = 0; f < faceCount; f++)
{
img.setImage2D(inputOptions.inputFormat, w, h, f, inputOptions.images[f]);
}
// To linear space.
if (!inputOptions.isNormalMap) {
img.toLinear(inputOptions.inputGamma);
}
// Resize input.
img.resize(inputOptions.maxExtent, inputOptions.roundMode, ResizeFilter_Box);
nv::getTargetExtent(w, h, d, inputOptions.maxExtent, inputOptions.roundMode, inputOptions.textureType);
// If the extents have not change we can use source images for the mipmaps.
bool canUseSourceImages = (img.width() == w && img.height() == h);
// If the extents have not changed, then we can use source images for all mipmaps.
bool canUseSourceImages = (inputOptions.width == w && inputOptions.height == h && inputOptions.depth == d);
int mipmapCount = 1;
if (inputOptions.generateMipmaps) {
mipmapCount = img.countMipmaps();
mipmapCount = countMipmaps(w, h, d);
if (inputOptions.maxLevel > 0) mipmapCount = min(mipmapCount, inputOptions.maxLevel);
}
if (!outputHeader(img, mipmapCount, compressionOptions, outputOptions))
if (!outputHeader(inputOptions.textureType, w, h, d, mipmapCount, img.isNormalMap(), compressionOptions, outputOptions))
{
return false;
}
nvtt::TexImage tmp = img;
if (!inputOptions.isNormalMap) {
tmp.toGamma(inputOptions.outputGamma);
}
// @@ Fix order of cubemap faces!
// Output images.
for (int f = 0; f < faceCount; f++)
{
img.setImage2D(inputOptions.inputFormat, inputOptions.width, inputOptions.height, inputOptions.images[f]);
// To normal map.
if (inputOptions.convertToNormalMap) {
img.toGreyScale(inputOptions.heightFactors.x, inputOptions.heightFactors.y, inputOptions.heightFactors.z, inputOptions.heightFactors.w);
img.toNormalMap(inputOptions.bumpFrequencyScale.x, inputOptions.bumpFrequencyScale.y, inputOptions.bumpFrequencyScale.z, inputOptions.bumpFrequencyScale.w);
}
quantize(tmp, compressionOptions);
compress(tmp, compressionOptions, outputOptions);
// To linear space.
if (!img.isNormalMap()) {
img.toLinear(inputOptions.inputGamma);
}
for (int m = 1; m < mipmapCount; m++) {
w = max(1, w/2);
h = max(1, h/2);
d = max(1, d/2);
// Resize input.
img.resize(w, h, ResizeFilter_Box);
nvtt::TexImage tmp = img;
if (!img.isNormalMap()) {
tmp.toGamma(inputOptions.outputGamma);
}
int size = computeImageSize(w, h, d, compressionOptions.bitcount, compressionOptions.pitchAlignment, compressionOptions.format);
outputOptions.beginImage(size, w, h, d, 0, m);
outputOptions.beginImage(size, w, h, d, f, 0);
quantize(tmp, compressionOptions);
compress(tmp, compressionOptions, outputOptions);
bool useSourceImages = false;
if (canUseSourceImages) {
useSourceImages = true;
for (int f = 0; f < faceCount; f++) {
int idx = m * faceCount + f;
for (int m = 1; m < mipmapCount; m++) {
w = max(1, w/2);
h = max(1, h/2);
d = max(1, d/2);
int size = computeImageSize(w, h, d, compressionOptions.bitcount, compressionOptions.pitchAlignment, compressionOptions.format);
outputOptions.beginImage(size, w, h, d, f, m);
int idx = m * faceCount + f;
bool useSourceImages = false;
if (canUseSourceImages) {
useSourceImages = true;
if (inputOptions.images[idx] == NULL) { // One face is missing in this mipmap level.
useSourceImages = false;
canUseSourceImages = false; // If one level is missing, ignore the following source images.
break;
}
}
}
if (useSourceImages) {
for (int f = 0; f < faceCount; f++) {
int idx = m * faceCount + f;
img.setImage2D(inputOptions.inputFormat, w, h, f, inputOptions.images[idx]);
}
}
else {
if (inputOptions.mipmapFilter == MipmapFilter_Kaiser) {
float params[2] = { inputOptions.kaiserStretch, inputOptions.kaiserAlpha };
img.buildNextMipmap(MipmapFilter_Kaiser, inputOptions.kaiserWidth, params);
if (useSourceImages) {
img.setImage2D(inputOptions.inputFormat, w, h, inputOptions.images[idx]);
}
else {
img.buildNextMipmap(inputOptions.mipmapFilter);
if (inputOptions.mipmapFilter == MipmapFilter_Kaiser) {
float params[2] = { inputOptions.kaiserStretch, inputOptions.kaiserAlpha };
img.buildNextMipmap(MipmapFilter_Kaiser, inputOptions.kaiserWidth, params);
}
else {
img.buildNextMipmap(inputOptions.mipmapFilter);
}
}
}
nvDebugCheck(img.width() == w);
nvDebugCheck(img.height() == h);
nvDebugCheck(img.width() == w);
nvDebugCheck(img.height() == h);
if (inputOptions.isNormalMap) {
if (inputOptions.normalizeMipmaps) {
img.normalizeNormalMap();
if (img.isNormalMap()) {
if (inputOptions.normalizeMipmaps) {
img.normalizeNormalMap();
}
tmp = img;
}
else {
tmp = img;
tmp.toGamma(inputOptions.outputGamma);
}
tmp = img;
}
else {
tmp = img;
tmp.toGamma(inputOptions.outputGamma);
}
quantize(tmp, compressionOptions);
compress(tmp, compressionOptions, outputOptions);
};
quantize(tmp, compressionOptions);
compress(tmp, compressionOptions, outputOptions);
}
}
return true;
}
bool Compressor::Private::compress(const TexImage & tex, const CompressionOptions::Private & compressionOptions, const OutputOptions::Private & outputOptions) const
{
foreach(i, tex.m->imageArray) {
FloatImage * image = tex.m->imageArray[i];
if (!compress(tex.alphaMode(), tex.width(), tex.height(), tex.depth(), image->channel(0), compressionOptions, outputOptions)) {
return false;
}
if (!compress(tex.alphaMode(), tex.width(), tex.height(), tex.depth(), tex.data(), compressionOptions, outputOptions)) {
return false;
}
return true;
}
@ -414,9 +367,9 @@ bool Compressor::Private::quantize(TexImage & img, const CompressionOptions::Pri
}
bool Compressor::Private::outputHeader(const TexImage & tex, int mipmapCount, const CompressionOptions::Private & compressionOptions, const OutputOptions::Private & outputOptions) const
bool Compressor::Private::outputHeader(nvtt::TextureType textureType, int w, int h, int d, int mipmapCount, bool isNormalMap, const CompressionOptions::Private & compressionOptions, const OutputOptions::Private & outputOptions) const
{
if (tex.width() <= 0 || tex.height() <= 0 || tex.depth() <= 0 || mipmapCount <= 0)
if (w <= 0 || h <= 0 || d <= 0 || mipmapCount <= 0)
{
outputOptions.error(Error_InvalidInput);
return false;
@ -434,19 +387,19 @@ bool Compressor::Private::outputHeader(const TexImage & tex, int mipmapCount, co
header.setUserVersion(outputOptions.version);
if (tex.textureType() == TextureType_2D) {
if (textureType == TextureType_2D) {
header.setTexture2D();
}
else if (tex.textureType() == TextureType_Cube) {
else if (textureType == TextureType_Cube) {
header.setTextureCube();
}
/*else if (tex.textureType() == TextureType_3D) {
/*else if (textureType == TextureType_3D) {
header.setTexture3D();
header.setDepth(tex.depth());
header.setDepth(d);
}*/
header.setWidth(tex.width());
header.setHeight(tex.height());
header.setWidth(w);
header.setHeight(h);
header.setMipmapCount(mipmapCount);
bool supported = true;
@ -490,7 +443,7 @@ bool Compressor::Private::outputHeader(const TexImage & tex, int mipmapCount, co
if (compressionOptions.format == Format_DXT1 || compressionOptions.format == Format_DXT1a || compressionOptions.format == Format_DXT1n) {
header.setDX10Format(70); // DXGI_FORMAT_BC1_TYPELESS
if (compressionOptions.format == Format_DXT1a) header.setHasAlphaFlag(true);
if (tex.isNormalMap()) header.setNormalFlag(true);
if (isNormalMap) header.setNormalFlag(true);
}
else if (compressionOptions.format == Format_DXT3) {
header.setDX10Format(73); // DXGI_FORMAT_BC2_TYPELESS
@ -500,21 +453,21 @@ bool Compressor::Private::outputHeader(const TexImage & tex, int mipmapCount, co
}
else if (compressionOptions.format == Format_DXT5n) {
header.setDX10Format(76); // DXGI_FORMAT_BC3_TYPELESS
if (tex.isNormalMap()) header.setNormalFlag(true);
if (isNormalMap) header.setNormalFlag(true);
}
else if (compressionOptions.format == Format_BC4) {
header.setDX10Format(79); // DXGI_FORMAT_BC4_TYPELESS
}
else if (compressionOptions.format == Format_BC5) {
header.setDX10Format(82); // DXGI_FORMAT_BC5_TYPELESS
if (tex.isNormalMap()) header.setNormalFlag(true);
if (isNormalMap) header.setNormalFlag(true);
}
else if (compressionOptions.format == Format_BC6) {
header.setDX10Format(94); // DXGI_FORMAT_BC6H_TYPELESS
}
else if (compressionOptions.format == Format_BC7) {
header.setDX10Format(97); // DXGI_FORMAT_BC7_TYPELESS
if (tex.isNormalMap()) header.setNormalFlag(true);
if (isNormalMap) header.setNormalFlag(true);
}
else {
supported = false;
@ -526,7 +479,7 @@ bool Compressor::Private::outputHeader(const TexImage & tex, int mipmapCount, co
if (compressionOptions.format == Format_RGBA)
{
// Get output bit count.
header.setPitch(computePitch(tex.width(), compressionOptions.getBitCount(), compressionOptions.pitchAlignment));
header.setPitch(computePitch(w, compressionOptions.getBitCount(), compressionOptions.pitchAlignment));
if (compressionOptions.pixelType == PixelType_Float)
{
@ -591,11 +544,11 @@ bool Compressor::Private::outputHeader(const TexImage & tex, int mipmapCount, co
}
else
{
header.setLinearSize(computeImageSize(tex.width(), tex.height(), tex.depth(), compressionOptions.bitcount, compressionOptions.pitchAlignment, compressionOptions.format));
header.setLinearSize(computeImageSize(w, h, d, compressionOptions.bitcount, compressionOptions.pitchAlignment, compressionOptions.format));
if (compressionOptions.format == Format_DXT1 || compressionOptions.format == Format_DXT1a || compressionOptions.format == Format_DXT1n) {
header.setFourCC('D', 'X', 'T', '1');
if (tex.isNormalMap()) header.setNormalFlag(true);
if (isNormalMap) header.setNormalFlag(true);
}
else if (compressionOptions.format == Format_DXT3) {
header.setFourCC('D', 'X', 'T', '3');
@ -605,7 +558,7 @@ bool Compressor::Private::outputHeader(const TexImage & tex, int mipmapCount, co
}
else if (compressionOptions.format == Format_DXT5n) {
header.setFourCC('D', 'X', 'T', '5');
if (tex.isNormalMap()) {
if (isNormalMap) {
header.setNormalFlag(true);
header.setSwizzleCode('A', '2', 'D', '5');
//header.setSwizzleCode('x', 'G', 'x', 'R');
@ -616,7 +569,7 @@ bool Compressor::Private::outputHeader(const TexImage & tex, int mipmapCount, co
}
else if (compressionOptions.format == Format_BC5) {
header.setFourCC('A', 'T', 'I', '2');
if (tex.isNormalMap()) {
if (isNormalMap) {
header.setNormalFlag(true);
header.setSwizzleCode('A', '2', 'X', 'Y');
}
@ -626,11 +579,11 @@ bool Compressor::Private::outputHeader(const TexImage & tex, int mipmapCount, co
}
else if (compressionOptions.format == Format_BC7) {
header.setFourCC('Z', 'O', 'L', 'A');
if (tex.isNormalMap()) header.setNormalFlag(true);
if (isNormalMap) header.setNormalFlag(true);
}
else if (compressionOptions.format == Format_CTX1) {
header.setFourCC('C', 'T', 'X', '1');
if (tex.isNormalMap()) header.setNormalFlag(true);
if (isNormalMap) header.setNormalFlag(true);
}
else {
supported = false;

4
src/nvtt/Context.h
Unescape Escape View File

@ -49,8 +49,8 @@ namespace nvtt
bool quantize(TexImage & tex, const CompressionOptions::Private & compressionOptions) const;
bool outputHeader(const TexImage & tex, int mipmapCount, const CompressionOptions::Private & compressionOptions, const OutputOptions::Private & outputOptions) const;
bool outputHeader(const InputOptions::Private & inputOptions, const CompressionOptions::Private & compressionOptions, const OutputOptions::Private & outputOptions) const;
bool outputHeader(nvtt::TextureType textureType, int w, int h, int d, int mipmapCount, bool isNormalMap, const CompressionOptions::Private & compressionOptions, const OutputOptions::Private & outputOptions) const;
//bool outputHeader(const InputOptions::Private & inputOptions, const CompressionOptions::Private & compressionOptions, const OutputOptions::Private & outputOptions) const;
nv::CompressorInterface * chooseCpuCompressor(const CompressionOptions::Private & compressionOptions) const;
nv::CompressorInterface * chooseGpuCompressor(const CompressionOptions::Private & compressionOptions) const;

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

@ -143,36 +143,12 @@ void InputOptions::setTextureLayout(TextureType type, int width, int height, int
m.depth = depth;
// Allocate images.
m.faceCount = (type == TextureType_2D) ? 1 : 6;
m.faceCount = (type == TextureType_Cube) ? 6 : 1;
m.mipmapCount = countMipmaps(width, height, depth);
m.imageCount = m.mipmapCount * m.faceCount;
m.images = new void *[m.imageCount];
memset(m.images, 0, sizeof(void *) * m.imageCount);
/*for (uint f = 0; f < m.faceCount; f++)
{
uint w = width;
uint h = height;
uint d = depth;
for (uint mipLevel = 0; mipLevel < m.mipmapCount; mipLevel++)
{
Private::InputImage & img = m.images[f * m.mipmapCount + mipLevel];
img.width = w;
img.height = h;
img.depth = d;
img.mipLevel = mipLevel;
img.face = f;
img.uint8data = NULL;
img.floatdata = NULL;
w = max(1U, w / 2);
h = max(1U, h / 2);
d = max(1U, d / 2);
}
}*/
}
@ -180,6 +156,11 @@ void InputOptions::resetTextureLayout()
{
if (m.images != NULL)
{
// Delete images.
for (int i = 0; i < m.imageCount; i++) {
free(m.images[i]);
}
// Delete image array.
delete [] m.images;
m.images = NULL;
@ -240,7 +221,7 @@ bool InputOptions::setMipmapData(const void * data, int width, int height, int d
return false;
}
m.images[idx] = new uint8[imageSize];
m.images[idx] = realloc(m.images[idx], imageSize);
if (m.images[idx] == NULL) {
// Out of memory.
return false;

78
src/nvtt/OutputOptions.cpp
Unescape Escape View File

@ -28,27 +28,27 @@ using namespace nvtt;
OutputOptions::OutputOptions() : m(*new OutputOptions::Private())
{
reset();
reset();
}
OutputOptions::~OutputOptions()
{
// Cleanup output handler.
setOutputHandler(NULL);
// Cleanup output handler.
setOutputHandler(NULL);
delete &m;
delete &m;
}
/// Set default output options.
void OutputOptions::reset()
{
m.fileName.reset();
m.fileName.reset();
m.outputHandler = NULL;
m.errorHandler = NULL;
m.outputHandler = NULL;
m.errorHandler = NULL;
m.outputHeader = true;
m.container = Container_DDS;
m.outputHeader = true;
m.container = Container_DDS;
m.version = 0;
}
@ -56,78 +56,78 @@ void OutputOptions::reset()
/// Set output file name.
void OutputOptions::setFileName(const char * fileName)
{
if (!m.fileName.isNull())
{
if (!m.fileName.isNull())
{
// To close the file and avoid leak.
delete m.outputHandler;
}
delete m.outputHandler;
}
m.fileName = fileName;
m.outputHandler = NULL;
m.fileName = fileName;
m.outputHandler = NULL;
DefaultOutputHandler * oh = new DefaultOutputHandler(fileName);
if (!oh->stream.isError())
{
m.outputHandler = oh;
}
DefaultOutputHandler * oh = new DefaultOutputHandler(fileName);
if (!oh->stream.isError())
{
m.outputHandler = oh;
}
}
/// Set output handler.
void OutputOptions::setOutputHandler(OutputHandler * outputHandler)
{
if (!m.fileName.isNull())
{
delete m.outputHandler;
m.fileName.reset();
}
m.outputHandler = outputHandler;
if (!m.fileName.isNull())
{
delete m.outputHandler;
m.fileName.reset();
}
m.outputHandler = outputHandler;
}
/// Set error handler.
void OutputOptions::setErrorHandler(ErrorHandler * errorHandler)
{
m.errorHandler = errorHandler;
m.errorHandler = errorHandler;
}
/// Set output header.
void OutputOptions::setOutputHeader(bool outputHeader)
{
m.outputHeader = outputHeader;
m.outputHeader = outputHeader;
}
/// Set container.
void OutputOptions::setContainer(Container container)
{
m.container = container;
m.container = container;
}
/// Set user version.
void OutputOptions::setUserVersion(int version)
{
m.version = version;
m.version = version;
}
bool OutputOptions::Private::hasValidOutputHandler() const
{
if (!fileName.isNull())
{
return outputHandler != NULL;
}
return true;
if (!fileName.isNull())
{
return outputHandler != NULL;
}
return true;
}
void OutputOptions::Private::beginImage(int size, int width, int height, int depth, int face, int miplevel) const
{
if (outputHandler != NULL) outputHandler->beginImage(size, width, height, depth, face, miplevel);
if (outputHandler != NULL) outputHandler->beginImage(size, width, height, depth, face, miplevel);
}
bool OutputOptions::Private::writeData(const void * data, int size) const
{
return outputHandler == NULL || outputHandler->writeData(data, size);
return outputHandler == NULL || outputHandler->writeData(data, size);
}
void OutputOptions::Private::error(Error e) const
{
if (errorHandler != NULL) errorHandler->error(e);
if (errorHandler != NULL) errorHandler->error(e);
}

1178
src/nvtt/TexImage.cpp
View File

File diff suppressed because it is too large Load Diff

21
src/nvtt/TexImage.h
Unescape Escape View File

@ -49,7 +49,7 @@ namespace nvtt
alphaMode = AlphaMode_None;
isNormalMap = false;
imageArray.resize(1, NULL);
image = NULL;
}
Private(const Private & p) : RefCounted() // Copy ctor. inits refcount to 0.
{
@ -60,17 +60,11 @@ namespace nvtt
alphaMode = p.alphaMode;
isNormalMap = p.isNormalMap;
imageArray.reserve(p.imageArray.count());
foreach(i, p.imageArray) {
imageArray.append(p.imageArray[i]->clone());
}
image = p.image->clone();
}
~Private()
{
const uint count = imageArray.count();
for (uint i = 0; i < count; i++) {
delete imageArray[i];
}
delete image;
}
TextureType type;
@ -78,11 +72,16 @@ namespace nvtt
AlphaMode alphaMode;
bool isNormalMap;
nv::Array<nv::FloatImage *> imageArray;
nv::FloatImage * image;
};
} // nvtt namespace
namespace nv {
uint countMipmaps(uint w, uint h, uint d);
uint computeImageSize(uint w, uint h, uint d, uint bitCount, uint alignment, nvtt::Format format);
void getTargetExtent(int & w, int & h, int & d, int maxExtent, nvtt::RoundMode roundMode, nvtt::TextureType textureType);
}
#endif // NVTT_TEXIMAGE_H

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

@ -28,30 +28,30 @@ using namespace nvtt;
/// Return a string for the given error.
const char * nvtt::errorString(Error e)
{
switch(e)
{
case Error_Unknown:
return "Unknown error";
case Error_InvalidInput:
return "Invalid input";
case Error_UnsupportedFeature:
return "Unsupported feature";
case Error_CudaError:
return "CUDA error";
case Error_FileOpen:
return "Error opening file";
case Error_FileWrite:
return "Error writing through output handler";
switch(e)
{
case Error_Unknown:
return "Unknown error";
case Error_InvalidInput:
return "Invalid input";
case Error_UnsupportedFeature:
return "Unsupported feature";
case Error_CudaError:
return "CUDA error";
case Error_FileOpen:
return "Error opening file";
case Error_FileWrite:
return "Error writing through output handler";
case Error_UnsupportedOutputFormat:
return "The container file does not support the selected output format";
}
return "Invalid error";
}
return "Invalid error";
}
/// Return NVTT version.
unsigned int nvtt::version()
{
return NVTT_VERSION;
return NVTT_VERSION;
}

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

@ -379,29 +379,28 @@ namespace nvtt
NVTT_API void operator=(const TexImage & tex);
// Texture parameters.
NVTT_API void setTextureType(TextureType type);
NVTT_API void setWrapMode(WrapMode mode);
NVTT_API void setAlphaMode(AlphaMode alphaMode);
NVTT_API void setNormalMap(bool isNormalMap);
// Accessors.
// Queries.
NVTT_API int width() const;
NVTT_API int height() const;
NVTT_API int depth() const;
NVTT_API int faceCount() const;
NVTT_API TextureType textureType() const;
NVTT_API WrapMode wrapMode() const;
NVTT_API AlphaMode alphaMode() const;
NVTT_API bool isNormalMap() const;
NVTT_API int countMipmaps() const;
NVTT_API float alphaTestCoverage(float alphaRef = 0.5) const;
NVTT_API float average(int channel) const;
NVTT_API const float * data() const;
// Texture data.
NVTT_API bool load(const char * fileName);
NVTT_API bool save(const char * fileName) const;
NVTT_API bool setImage2D(InputFormat format, int w, int h, int idx, const void * data);
NVTT_API bool setImage2D(InputFormat format, int w, int h, int idx, const void * r, const void * g, const void * b, const void * a);
NVTT_API bool setImage2D(Format format, Decoder decoder, int w, int h, int idx, const void * data);
NVTT_API bool setImage2D(InputFormat format, int w, int h, const void * data);
NVTT_API bool setImage2D(InputFormat format, int w, int h, const void * r, const void * g, const void * b, const void * a);
NVTT_API bool setImage2D(Format format, Decoder decoder, int w, int h, const void * data);
// Resizing methods.
NVTT_API void resize(int w, int h, ResizeFilter filter);
@ -452,7 +451,6 @@ namespace nvtt
private:
void detach();
friend struct Compressor::Private;
struct Private;
Private * m;

4
src/nvtt/tests/testsuite.cpp
Unescape Escape View File

@ -463,8 +463,8 @@ int main(int argc, char *argv[])
context.process(inputOptions, compressionOptions, outputOptions);
timer.stop();
printf(" Time: \t%.3f sec\n", float(timer.elapsed()) / 1000);
totalTime += float(timer.elapsed()) / 1000;
printf(" Time: \t%.3f sec\n", timer.elapsed());
totalTime += timer.elapsed();
AutoPtr<Image> img_out( outputHandler.decompress(s_imageSets[set].format, decoder) );

Write Preview
Loading…
Cancel
Save