KD_API KDImageATX KD_APIENTRY kdDXTCompressBufferATX(const void *buffer, KDint32 width, KDint32 height, KDint32 comptype, KDint32 levels)
{
_KDImageATX *image = (_KDImageATX *)kdMalloc(sizeof(_KDImageATX));
if(image == KD_NULL)
{
kdSetError(KD_ENOMEM);
return KD_NULL;
}
image->levels = levels;
image->width = width;
image->height = height;
switch(comptype)
{
case(KD_DXTCOMP_TYPE_DXT1_ATX):
{
image->format = KD_IMAGE_FORMAT_DXT1_ATX;
image->alpha = KD_FALSE;
break;
}
case(KD_DXTCOMP_TYPE_DXT1A_ATX):
{
kdFree(image);
kdSetError(KD_EINVAL);
return KD_NULL;
}
case(KD_DXTCOMP_TYPE_DXT3_ATX):
{
kdFree(image);
kdSetError(KD_EINVAL);
return KD_NULL;
}
case(KD_DXTCOMP_TYPE_DXT5_ATX):
{
image->format = KD_IMAGE_FORMAT_DXT5_ATX;
image->alpha = KD_TRUE;
break;
}
default:
{
kdFree(image);
kdSetError(KD_EINVAL);
return KD_NULL;
}
}
image->bpp = image->alpha ? 16 : 8;
image->size = (KDsize)image->width * (KDsize)image->height * (KDsize)(image->bpp / 8);
KDint _width = image->width;
KDint _height = image->height;
for(KDint i = 0; i < image->levels; i++)
{
_width >>= 1;
_height >>= 1;
image->size += (KDsize)_width * (KDsize)_height * (KDsize)(image->bpp / 8);
}
image->buffer = kdMalloc(image->size);
if(image->buffer == KD_NULL)
{
kdFree(image);
kdSetError(KD_ENOMEM);
return KD_NULL;
}
_width = image->width;
_height = image->height;
KDint channels = (image->alpha ? 4 : 3);
for(KDint i = 0; i <= image->levels; i++)
{
KDsize size = (KDsize)_width * (KDsize)_height * (KDsize)channels;
if(size)
{
void *tmp = kdMalloc(size);
if((_width == image->width) && (_height == image->height))
{
kdMemcpy(tmp, buffer, size);
}
else
{
stbir_resize_uint8(buffer, image->width, image->height, 0, tmp, _width, _height, 0, channels);
}
for(KDint y = 0; y < _height; y += 4)
{
for(KDint x = 0; x < _width; x += 4)
{
KDuint8 block[64];
__kdExtractBlock(tmp, x, y, _width, _height, block);
stb_compress_dxt_block(image->buffer, block, image->alpha, STB_DXT_NORMAL);
image->buffer += image->bpp;
}
}
kdFree(tmp);
}
_width >>= 1;
_height >>= 1;
}
return image;
}
static bool TextureCompressQDM(LPDIRECT3DTEXTURE *base, LPDIRECT3DTEXTURE *norm, int minlevel) {
LPDIRECT3DTEXTURE baset;
LPDIRECT3DTEXTURE normt;
RESOURCEINFO based, baseo;
RESOURCEINFO normd, normo;
TextureInfoLevel(*base, baseo, 0);
TextureInfoLevel(*norm, normo, 0);
#if 0
/* Converts a height map into a normal map. The (x,y,z)
* components of each normal are mapped to the (r,g,b)
* channels of the output texture.
*/
HRESULT D3DXComputeNormalMap(
__out LPDIRECT3DTEXTURE pTexture,
__in LPDIRECT3DTEXTURE pSrcTexture,
__in const PALETTEENTRY *pSrcPalette,
__in DWORD Flags,
__in DWORD Channel,
__in FLOAT Amplitude
);
#endif
/* they have to have the same dimension */
if ((baseo.Width != normo.Width ) ||
(baseo.Height != normo.Height))
return false;
/* convert to ARGB8 (TODO: support at least the 16bit formats as well) */
if ((baseo.Format != TEXFMT_A8B8G8R8) && baseo.Format = TEXFMT_A8R8G8B8, !TextureConvert(baseo, base, false))
return false;
if ((normo.Format != TEXFMT_A8B8G8R8) && normo.Format = TEXFMT_A8R8G8B8, !TextureConvert(normo, norm, true))
return false;
/* create the textures */
int levels = TextureCalcMip(baseo.Width, baseo.Height, minlevel);
int flags = squish::kColourIterativeClusterFit | squish::kBtc3;
#ifdef DX11
ULONG *bases;
ULONG *norms;
DWORD basel = 1;
DWORD norml = 1;
DWORD level = max(basel, norml);
#else
/* create the textures */
pD3DDevice->CreateTexture(baseo.Width, baseo.Height, levels, 0, D3DFMT_DXT5, D3DPOOL_SYSTEMMEM, &baset, NULL);
pD3DDevice->CreateTexture(normo.Width, normo.Height, levels, 0, D3DFMT_DXT5, D3DPOOL_SYSTEMMEM, &normt, NULL);
/* damit */
if (!baset || !normt) {
if (baset) baset->Release();
if (normt) normt->Release();
return false;
}
ULONG bPch, *bases = TextureLock(*base, &bPch, 0);
ULONG nPch, *norms = TextureLock(*norm, &nPch, 0);
DWORD basel = baset->GetLevelCount();
DWORD norml = normt->GetLevelCount();
DWORD level = max(basel, norml);
#endif
for (unsigned int l = 0; l < level; l++) {
/* square dimension of this surface-level */
/* square area of this surface-level */
int lv = (1 << l);
int av = lv * lv;
TextureInfoLevel(baset, based, l);
TextureInfoLevel(normt, normd, l);
ULONG sPch, *baser = TextureLock(baset, l, &sPch, true);
ULONG nPch, *normr = TextureLock(normt, l, &nPch, true);
ULONG *sBase = (ULONG *)bases;
ULONG *sNorm = (ULONG *)norms;
ULONG *dBase = (ULONG *)baser;
ULONG *dNorm = (ULONG *)normr;
/* loop over 4x4-blocks of this level (DXT5) */
for (unsigned int y = 0; y < based.Height; y += TY) {
if (!(y & 0x3F)) {
// logrf("line processed %d/%d of level %d/%d\r", y, based.Height, l, level);
// PollProgress();
}
for (unsigned int x = 0; x < based.Width; x += TX) {
UTYPE bBase[2][TY][TX];
ULONG bNorm[2][TY][TX];
type fBase[2][TY][TX][DIM];
float fNorm[2][TY][TX][DIM];
/* generate this level's 4x4-block from the original surface */
for (int ly = 0; ly < TY; ly += 1)
for (int lx = 0; lx < TX; lx += 1) {
type bs[DIM] = {0}; int yl = ((y + ly) << l);
/*ng ns[DIM] = {0*/ int xl = ((x + lx) << l);
float nn[DIM] = {0.0f};
/* access all pixels this level's 4x4-block represents in
* the full dimension original surface (high quality mip-mapping)
*/
for (int oy = 0; oy < lv; oy += 1)
for (int ox = 0; ox < lv; ox += 1) {
/* assume seamless tiling: wrap pixels around */
int posx = (xl + ox) % baseo.Width;
int posy = (yl + oy) % baseo.Height;
ULONG &b = sBase[(posy * sPch) + posx];
ULONG &n = sNorm[(posy * nPch) + posx];
/* transfer heightmap into the normal-map (overwrite) */
if (LODed)
n = (n & 0x00FFFFFF) + (b & 0xFF000000);
{ static const f<TCOMPRESS_RGBH> fmt; Accu(bs, b); }
{ static const f<TCOMPRESS_XYZD> fmt; Accu(nn, n); }
// AccuRGBM<ACCUMODE_LINEAR>(bs, b, level, l, colorgamma); // += and max
#if defined(NORMALS_INTEGER)
// AccuXYZD<ACCUMODE_SCALE >(ns, n, level, l, NORMALS_SCALEBYLEVEL); // +=
#else
// AccuXYZD<ACCUMODE_SCALE >(nn, n, level, l, NORMALS_SCALEBYLEVEL); // +=
#endif
}
/* build average of each channel */
{ const int format = TCOMPRESS_RGBH; Norm(fBase[0][ly][lx], bs, av, levels, l); }
{ const int format = TCOMPRESS_XYZD; Norm(fNorm[0][ly][lx], nn, av, levels, l); }
// NormRGBM<TRGTMODE_CODING_RGB >(fBase[0][ly][lx], bs, av, colorgammainv);
#if defined(NORMALS_INTEGER)
// NormXYZD<TRGTMODE_CODING_DXDYdZt | TRGTNORM_CUBESPACE>(fNorm[0][ly][lx], ns, av);
#else
// NormXYZD<TRGTMODE_CODING_DXDYdZt | TRGTNORM_CUBESPACE>(fNorm[0][ly][lx], nn, av);
#endif
}
type br[DIM] = {0};
/*ng nr[DIM] = {0*/
float rn[DIM] = {0.0f};
/* analyze this level's 4x4-block */
for (int ly = 0; ly < TY; ly += 1)
for (int lx = 0; lx < TX; lx += 1) {
{ const int format = TCOMPRESS_RGBH; Look(fBase[0][ly][lx], br); }
{ const int format = TCOMPRESS_XYZD; Look(fNorm[0][ly][lx], rn); }
// LookRGBH<TRGTMODE_CODING_RGB >(fBase[0][ly][lx], br);
#if defined(NORMALS_INTEGER)
// LookXYZD<TRGTMODE_CODING_DXDYdZt | TRGTNORM_CUBESPACE>(fNorm[0][ly][lx], nr);
#else
// LookXYZD<TRGTMODE_CODING_DXDYdZt | TRGTNORM_CUBESPACE>(fNorm[0][ly][lx], rn);
#endif
}
/* generate this level's 4x4-block from the original surface */
for (int ly = 0; ly < TY; ly += 1)
for (int lx = 0; lx < TX; lx += 1) {
/* build average of each channel an join */
UTYPE b;
ULONG n;
{ const int format = TCOMPRESS_RGBH;
Code(fBase[0][ly][lx], br, (TCOMPRESS_CHANNELS(format) +
(TCOMPRESS_GREYS (format) ? 2 : 0)) == 2 ? 8 :
(TCOMPRESS_SWIZZL (format) ? 6 : 5)); }
{ const int format = TCOMPRESS_XYZD;
Code(fNorm[0][ly][lx], rn, (TCOMPRESS_CHANNELS(format) +
(TCOMPRESS_GREYS (format) ? 2 : 0)) == 2 ? 8 :
(TCOMPRESS_SWIZZL (format) ? 6 : 5)); }
{ const int format = TCOMPRESS_RGBH; b = Join(fBase[0][ly][lx], br); }
{ const int format = TCOMPRESS_XYZD; n = Join(fNorm[0][ly][lx], rn); }
// CodeRGBH<TRGTMODE_CODING_RGB >(fBase[0][ly][lx], br);
#if defined(NORMALS_INTEGER)
// CodeXYZD<TRGTMODE_CODING_DXDYdZt | TRGTNORM_CUBESPACE, TCOMPRESS_SWIZZL(format) ? 6 : 5>(fNorm[0][ly][lx], nr);
#else
// CodeXYZD<TRGTMODE_CODING_DXDYdZt | TRGTNORM_CUBESPACE, TCOMPRESS_SWIZZL(format) ? 6 : 5>(fNorm[0][ly][lx], rn);
#endif
// b = JoinRGBH<TRGTMODE_CODING_RGB >(fBase[0][ly][lx], br);
#if defined(NORMALS_INTEGER)
// n = JoinXYZD<TRGTMODE_CODING_DXDYdZt | TRGTNORM_CUBESPACE>(fNorm[0][ly][lx], nr);
#else
// n = JoinXYZD<TRGTMODE_CODING_DXDYdZt | TRGTNORM_CUBESPACE>(fNorm[0][ly][lx], rn);
#endif
/* write the result ABGR */
bBase[0][ly][lx] = b;
bNorm[0][ly][lx] = n;
}
/* compress to DXT5 */
#if 0
stb_compress_dxt_block((unsigned char *)dBase, (unsigned char *)bBase[0], true, STB_DXT_DITHER | STB_DXT_HIGHQUAL);
stb_compress_dxt_block((unsigned char *)dNorm, (unsigned char *)bNorm[0], true, STB_DXT_NORMAL | STB_DXT_HIGHQUAL);
#else
squish::Compress((unsigned char *)bBase[0], dBase, flags + squish::kColourMetricPerceptual);
squish::Compress((unsigned char *)bNorm[0], dNorm, flags + squish::kColourMetricUniform);
#endif
/* advance pointer of compressed blocks */
dBase += (128 / 32);
dNorm += (128 / 32);
#if 0
for (int ly = 0; ly < TY; ly += 1)
for (int lx = 0; lx < TX; lx += 1) {
dBase[((y + ly) * bPch) + (x + lx)] = bBase[0][ly][lx];
dNorm[((y + ly) * nPch) + (x + lx)] = bNorm[0][ly][lx];
}
#endif
}
}
TextureUnlock(baset, l);
TextureUnlock(normt, l);
}
TextureUnlock((*base), 0);
TextureUnlock((*norm), 0);
(*base)->Release();
(*norm)->Release();
(*base) = baset;
(*norm) = normt;
return true;
}
