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

Apply patch to update C# wraper. Fixes issue 184.

Browse Source
This commit is contained in:
castano
2014-06-11 21:02:04 +00:00
parent f705b2eaa1
commit ac87eefa6d
7 changed files with 260 additions and 152 deletions
Download Patch File Download Diff File Expand all files Collapse all files

146
src/nvtt/nvtt_wrapper.cpp
View File

@ -25,207 +25,269 @@
#include "nvtt.h"
#include "nvtt_wrapper.h"
#include "OutputOptions.h"
// An OutputHandler that sets and calls function pointers, rather than
// requiring interfaces to derive from OutputHandler itself
struct HandlerProxy : public nvtt::OutputHandler
{
public:
HandlerProxy() {}
nvttBeginImageHandler beginImageHandler;
nvttOutputHandler writeDataHandler;
nvttEndImageHandler endImageHandler;
virtual void beginImage(int size, int width, int height, int depth, int face, int miplevel)
{
if (beginImageHandler != NULL)
{
beginImageHandler(size, width, height, depth, face, miplevel);
}
}
virtual bool writeData(const void * data, int size)
{
if (writeDataHandler != NULL)
{
return writeDataHandler(data, size);
}
return false;
}
virtual void endImage()
{
if (endImageHandler != NULL)
{
endImageHandler();
}
}
};
// InputOptions class.
NvttInputOptions * nvttCreateInputOptions()
{
return new nvtt::InputOptions();
return new nvtt::InputOptions();
}
void nvttDestroyInputOptions(NvttInputOptions * inputOptions)
{
delete inputOptions;
delete inputOptions;
}
void nvttSetInputOptionsTextureLayout(NvttInputOptions * inputOptions, NvttTextureType type, int w, int h, int d)
{
inputOptions->setTextureLayout((nvtt::TextureType)type, w, h, d);
inputOptions->setTextureLayout((nvtt::TextureType)type, w, h, d);
}
void nvttResetInputOptionsTextureLayout(NvttInputOptions * inputOptions)
{
inputOptions->resetTextureLayout();
inputOptions->resetTextureLayout();
}
NvttBoolean nvttSetInputOptionsMipmapData(NvttInputOptions * inputOptions, const void * data, int w, int h, int d, int face, int mipmap)
{
return (NvttBoolean)inputOptions->setMipmapData(data, w, h, d, face, mipmap);
return (NvttBoolean)inputOptions->setMipmapData(data, w, h, d, face, mipmap);
}
void nvttSetInputOptionsFormat(NvttInputOptions * inputOptions, NvttInputFormat format)
{
inputOptions->setFormat((nvtt::InputFormat)format);
inputOptions->setFormat((nvtt::InputFormat)format);
}
void nvttSetInputOptionsAlphaMode(NvttInputOptions * inputOptions, NvttAlphaMode alphaMode)
{
inputOptions->setAlphaMode((nvtt::AlphaMode)alphaMode);
inputOptions->setAlphaMode((nvtt::AlphaMode)alphaMode);
}
void nvttSetInputOptionsGamma(NvttInputOptions * inputOptions, float inputGamma, float outputGamma)
{
inputOptions->setGamma(inputGamma, outputGamma);
inputOptions->setGamma(inputGamma, outputGamma);
}
void nvttSetInputOptionsWrapMode(NvttInputOptions * inputOptions, NvttWrapMode mode)
{
inputOptions->setWrapMode((nvtt::WrapMode)mode);
inputOptions->setWrapMode((nvtt::WrapMode)mode);
}
void nvttSetInputOptionsMipmapFilter(NvttInputOptions * inputOptions, NvttMipmapFilter filter)
{
inputOptions->setMipmapFilter((nvtt::MipmapFilter)filter);
inputOptions->setMipmapFilter((nvtt::MipmapFilter)filter);
}
void nvttSetInputOptionsMipmapGeneration(NvttInputOptions * inputOptions, NvttBoolean enabled, int maxLevel)
{
inputOptions->setMipmapGeneration(enabled != NVTT_False, maxLevel);
inputOptions->setMipmapGeneration(enabled != NVTT_False, maxLevel);
}
void nvttSetInputOptionsKaiserParameters(NvttInputOptions * inputOptions, float width, float alpha, float stretch)
{
inputOptions->setKaiserParameters(width, alpha, stretch);
inputOptions->setKaiserParameters(width, alpha, stretch);
}
void nvttSetInputOptionsNormalMap(NvttInputOptions * inputOptions, NvttBoolean b)
{
inputOptions->setNormalMap(b != NVTT_False);
inputOptions->setNormalMap(b != NVTT_False);
}
void nvttSetInputOptionsConvertToNormalMap(NvttInputOptions * inputOptions, NvttBoolean convert)
{
inputOptions->setConvertToNormalMap(convert != NVTT_False);
inputOptions->setConvertToNormalMap(convert != NVTT_False);
}
void nvttSetInputOptionsHeightEvaluation(NvttInputOptions * inputOptions, float redScale, float greenScale, float blueScale, float alphaScale)
{
inputOptions->setHeightEvaluation(redScale, greenScale, blueScale, alphaScale);
inputOptions->setHeightEvaluation(redScale, greenScale, blueScale, alphaScale);
}
void nvttSetInputOptionsNormalFilter(NvttInputOptions * inputOptions, float small, float medium, float big, float large)
{
inputOptions->setNormalFilter(small, medium, big, large);
inputOptions->setNormalFilter(small, medium, big, large);
}
void nvttSetInputOptionsNormalizeMipmaps(NvttInputOptions * inputOptions, NvttBoolean b)
{
inputOptions->setNormalizeMipmaps(b != NVTT_False);
inputOptions->setNormalizeMipmaps(b != NVTT_False);
}
void nvttSetInputOptionsMaxExtents(NvttInputOptions * inputOptions, int dim)
{
inputOptions->setMaxExtents(dim);
inputOptions->setMaxExtents(dim);
}
void nvttSetInputOptionsRoundMode(NvttInputOptions * inputOptions, NvttRoundMode mode)
{
inputOptions->setRoundMode((nvtt::RoundMode)mode);
inputOptions->setRoundMode((nvtt::RoundMode)mode);
}
// CompressionOptions class.
NvttCompressionOptions * nvttCreateCompressionOptions()
{
return new nvtt::CompressionOptions();
return new nvtt::CompressionOptions();
}
void nvttDestroyCompressionOptions(NvttCompressionOptions * compressionOptions)
{
delete compressionOptions;
delete compressionOptions;
}
void nvttSetCompressionOptionsFormat(NvttCompressionOptions * compressionOptions, NvttFormat format)
{
compressionOptions->setFormat((nvtt::Format)format);
compressionOptions->setFormat((nvtt::Format)format);
}
void nvttSetCompressionOptionsQuality(NvttCompressionOptions * compressionOptions, NvttQuality quality)
{
compressionOptions->setQuality((nvtt::Quality)quality);
compressionOptions->setQuality((nvtt::Quality)quality);
}
void nvttSetCompressionOptionsColorWeights(NvttCompressionOptions * compressionOptions, float red, float green, float blue, float alpha)
{
compressionOptions->setColorWeights(red, green, blue, alpha);
compressionOptions->setColorWeights(red, green, blue, alpha);
}
/*void nvttEnableCompressionOptionsCudaCompression(NvttCompressionOptions * compressionOptions, NvttBoolean enable)
{
compressionOptions->enableCudaCompression(enable != NVTT_False);
compressionOptions->enableCudaCompression(enable != NVTT_False);
}*/
void nvttSetCompressionOptionsPixelFormat(NvttCompressionOptions * compressionOptions, unsigned int bitcount, unsigned int rmask, unsigned int gmask, unsigned int bmask, unsigned int amask)
{
compressionOptions->setPixelFormat(bitcount, rmask, gmask, bmask, amask);
compressionOptions->setPixelFormat(bitcount, rmask, gmask, bmask, amask);
}
void nvttSetCompressionOptionsQuantization(NvttCompressionOptions * compressionOptions, NvttBoolean colorDithering, NvttBoolean alphaDithering, NvttBoolean binaryAlpha, int alphaThreshold)
{
compressionOptions->setQuantization(colorDithering != NVTT_False, alphaDithering != NVTT_False, binaryAlpha != NVTT_False, alphaThreshold);
compressionOptions->setQuantization(colorDithering != NVTT_False, alphaDithering != NVTT_False, binaryAlpha != NVTT_False, alphaThreshold);
}
// OutputOptions class.
NvttOutputOptions * nvttCreateOutputOptions()
{
return new nvtt::OutputOptions();
nvtt::OutputOptions * outputOptions = new nvtt::OutputOptions();
HandlerProxy * handlerProxy = new HandlerProxy();
outputOptions->m.wrapperProxy = handlerProxy;
return outputOptions;
}
void nvttDestroyOutputOptions(NvttOutputOptions * outputOptions)
{
delete outputOptions;
HandlerProxy * handlerProxy = (HandlerProxy *)outputOptions->m.wrapperProxy;
delete handlerProxy;
delete outputOptions;
}
void nvttSetOutputOptionsFileName(NvttOutputOptions * outputOptions, const char * fileName)
{
outputOptions->setFileName(fileName);
outputOptions->setFileName(fileName);
}
void nvttSetOutputOptionsOutputHeader(NvttOutputOptions * outputOptions, NvttBoolean b)
{
outputOptions->setOutputHeader(b != NVTT_False);
outputOptions->setOutputHeader(b != NVTT_False);
}
/*
void nvttSetOutputOptionsErrorHandler(NvttOutputOptions * outputOptions, nvttErrorHandler errorHandler)
{
outputOptions->setErrorHandler(errorHandler);
}
void nvttSetOutputOptionsOutputHandler(NvttOutputOptions * outputOptions, nvttOutputHandler outputHandler, nvttImageHandler imageHandler)
{
outputOptions->setErrorHandler(errorHandler);
}
*/
void nvttSetOutputOptionsOutputHandler(NvttOutputOptions * outputOptions, nvttBeginImageHandler beginImageHandler, nvttOutputHandler writeDataHandler, nvttEndImageHandler endImageHandler)
{
HandlerProxy * handler = (HandlerProxy *)outputOptions->m.wrapperProxy;
handler->beginImageHandler = beginImageHandler;
handler->writeDataHandler = writeDataHandler;
handler->endImageHandler = endImageHandler;
if(beginImageHandler == NULL && writeDataHandler == NULL && endImageHandler == NULL)
{
outputOptions->setOutputHandler(NULL);
}
else
{
outputOptions->setOutputHandler(handler);
}
}
// Compressor class.
NvttCompressor * nvttCreateCompressor()
{
return new nvtt::Compressor();
return new nvtt::Compressor();
}
void nvttDestroyCompressor(NvttCompressor * compressor)
{
delete compressor;
delete compressor;
}
NvttBoolean nvttCompress(const NvttCompressor * compressor, const NvttInputOptions * inputOptions, const NvttCompressionOptions * compressionOptions, const NvttOutputOptions * outputOptions)
{
return (NvttBoolean)compressor->process(*inputOptions, *compressionOptions, *outputOptions);
return (NvttBoolean)compressor->process(*inputOptions, *compressionOptions, *outputOptions);
}
int nvttEstimateSize(const NvttCompressor * compressor, const NvttInputOptions * inputOptions, const NvttCompressionOptions * compressionOptions)
{
return compressor->estimateSize(*inputOptions, *compressionOptions);
return compressor->estimateSize(*inputOptions, *compressionOptions);
}
// Global functions.
const char * nvttErrorString(NvttError e)
{
return nvtt::errorString((nvtt::Error)e);
return nvtt::errorString((nvtt::Error)e);
}
unsigned int nvttVersion()
{
return nvtt::version();
return nvtt::version();
}