OctaCore/src/engine/texture.cc

4088 lines
130 KiB
C++

// texture.cpp: texture slot management
#include "texture.hh"
#include <ctime>
#include <algorithm>
#include <zlib.h>
#include <sauerlib/encoding.hh>
#include <sauerlib/endian.hh>
#include <shared/command.hh>
#include <shared/igame.hh>
#include <shared/gzstream.hh>
#include <shared/rwops.hh>
#include <shared/zip.hh>
#include "command.hh" // identflags
#include "console.hh" /* conoutf */
#include "light.hh"
#include "main.hh" // initwarning, loadprogress, renderprogress, screenw/h, renderedframe, fatal, multiplayer
#include "material.hh"
#include "octaedit.hh"
#include "octarender.hh"
#include "rendergl.hh"
#include "rendersky.hh"
#include "shader.hh"
#include "world.hh"
#ifdef __APPLE__
#include "SDL2_image/SDL_image.h"
#else
#include "SDL_image.h"
#endif
static bool loaddds(const char *filename, ImageData &image, int force = 0);
#ifndef SDL_IMAGE_VERSION_ATLEAST
#define SDL_IMAGE_VERSION_ATLEAST(X, Y, Z) \
(SDL_VERSIONNUM(SDL_IMAGE_MAJOR_VERSION, SDL_IMAGE_MINOR_VERSION, SDL_IMAGE_PATCHLEVEL) >= SDL_VERSIONNUM(X, Y, Z))
#endif
template<int BPP> static void halvetexture(uchar * RESTRICT src, uint sw, uint sh, uint stride, uchar * RESTRICT dst)
{
for(uchar *yend = &src[sh*stride]; src < yend;)
{
for(uchar *xend = &src[sw*BPP], *xsrc = src; xsrc < xend; xsrc += 2*BPP, dst += BPP)
{
loopi(BPP) dst[i] = (uint(xsrc[i]) + uint(xsrc[i+BPP]) + uint(xsrc[stride+i]) + uint(xsrc[stride+i+BPP]))>>2;
}
src += 2*stride;
}
}
template<int BPP> static void shifttexture(uchar * RESTRICT src, uint sw, uint sh, uint stride, uchar * RESTRICT dst, uint dw, uint dh)
{
uint wfrac = sw/dw, hfrac = sh/dh, wshift = 0, hshift = 0;
while(dw<<wshift < sw) wshift++;
while(dh<<hshift < sh) hshift++;
uint tshift = wshift + hshift;
for(uchar *yend = &src[sh*stride]; src < yend;)
{
for(uchar *xend = &src[sw*BPP], *xsrc = src; xsrc < xend; xsrc += wfrac*BPP, dst += BPP)
{
uint t[BPP] = {0};
for(uchar *ycur = xsrc, *xend = &ycur[wfrac*BPP], *yend = &src[hfrac*stride];
ycur < yend;
ycur += stride, xend += stride)
{
for(uchar *xcur = ycur; xcur < xend; xcur += BPP)
loopi(BPP) t[i] += xcur[i];
}
loopi(BPP) dst[i] = t[i] >> tshift;
}
src += hfrac*stride;
}
}
template<int BPP> static void scaletexture(uchar * RESTRICT src, uint sw, uint sh, uint stride, uchar * RESTRICT dst, uint dw, uint dh)
{
uint wfrac = (sw<<12)/dw, hfrac = (sh<<12)/dh, darea = dw*dh, sarea = sw*sh;
int over, under;
for(over = 0; (darea>>over) > sarea; over++);
for(under = 0; (darea<<under) < sarea; under++);
uint cscale = std::clamp(under, over - 12, 12),
ascale = std::clamp(12 + under - over, 0, 24),
dscale = ascale + 12 - cscale,
area = ((ullong)darea<<ascale)/sarea;
dw *= wfrac;
dh *= hfrac;
for(uint y = 0; y < dh; y += hfrac)
{
const uint yn = y + hfrac - 1, yi = y>>12, h = (yn>>12) - yi, ylow = ((yn|(-int(h)>>24))&0xFFFU) + 1 - (y&0xFFFU), yhigh = (yn&0xFFFU) + 1;
const uchar *ysrc = &src[yi*stride];
for(uint x = 0; x < dw; x += wfrac, dst += BPP)
{
const uint xn = x + wfrac - 1, xi = x>>12, w = (xn>>12) - xi, xlow = ((w+0xFFFU)&0x1000U) - (x&0xFFFU), xhigh = (xn&0xFFFU) + 1;
const uchar *xsrc = &ysrc[xi*BPP], *xend = &xsrc[w*BPP];
uint t[BPP] = {0};
for(const uchar *xcur = &xsrc[BPP]; xcur < xend; xcur += BPP)
loopi(BPP) t[i] += xcur[i];
loopi(BPP) t[i] = (ylow*(t[i] + ((xsrc[i]*xlow + xend[i]*xhigh)>>12)))>>cscale;
if(h)
{
xsrc += stride;
xend += stride;
for(uint hcur = h; --hcur; xsrc += stride, xend += stride)
{
uint c[BPP] = {0};
for(const uchar *xcur = &xsrc[BPP]; xcur < xend; xcur += BPP)
loopi(BPP) c[i] += xcur[i];
loopi(BPP) t[i] += ((c[i]<<12) + xsrc[i]*xlow + xend[i]*xhigh)>>cscale;
}
uint c[BPP] = {0};
for(const uchar *xcur = &xsrc[BPP]; xcur < xend; xcur += BPP)
loopi(BPP) c[i] += xcur[i];
loopi(BPP) t[i] += (yhigh*(c[i] + ((xsrc[i]*xlow + xend[i]*xhigh)>>12)))>>cscale;
}
loopi(BPP) dst[i] = (t[i] * area)>>dscale;
}
}
}
static void scaletexture(uchar * RESTRICT src, uint sw, uint sh, uint bpp, uint pitch, uchar * RESTRICT dst, uint dw, uint dh)
{
if(sw == dw*2 && sh == dh*2)
{
switch(bpp)
{
case 1: return halvetexture<1>(src, sw, sh, pitch, dst);
case 2: return halvetexture<2>(src, sw, sh, pitch, dst);
case 3: return halvetexture<3>(src, sw, sh, pitch, dst);
case 4: return halvetexture<4>(src, sw, sh, pitch, dst);
}
}
else if(sw < dw || sh < dh || sw&(sw-1) || sh&(sh-1) || dw&(dw-1) || dh&(dh-1))
{
switch(bpp)
{
case 1: return scaletexture<1>(src, sw, sh, pitch, dst, dw, dh);
case 2: return scaletexture<2>(src, sw, sh, pitch, dst, dw, dh);
case 3: return scaletexture<3>(src, sw, sh, pitch, dst, dw, dh);
case 4: return scaletexture<4>(src, sw, sh, pitch, dst, dw, dh);
}
}
else
{
switch(bpp)
{
case 1: return shifttexture<1>(src, sw, sh, pitch, dst, dw, dh);
case 2: return shifttexture<2>(src, sw, sh, pitch, dst, dw, dh);
case 3: return shifttexture<3>(src, sw, sh, pitch, dst, dw, dh);
case 4: return shifttexture<4>(src, sw, sh, pitch, dst, dw, dh);
}
}
}
static void reorientnormals(uchar * RESTRICT src, int sw, int sh, int bpp, int stride, uchar * RESTRICT dst, bool flipx, bool flipy, bool swapxy)
{
int stridex = bpp, stridey = bpp;
if(swapxy) stridex *= sh; else stridey *= sw;
if(flipx) { dst += (sw-1)*stridex; stridex = -stridex; }
if(flipy) { dst += (sh-1)*stridey; stridey = -stridey; }
uchar *srcrow = src;
loopi(sh)
{
for(uchar *curdst = dst, *src = srcrow, *end = &srcrow[sw*bpp]; src < end;)
{
uchar nx = *src++, ny = *src++;
if(flipx) nx = 255-nx;
if(flipy) ny = 255-ny;
if(swapxy) swap(nx, ny);
curdst[0] = nx;
curdst[1] = ny;
curdst[2] = *src++;
if(bpp > 3) curdst[3] = *src++;
curdst += stridex;
}
srcrow += stride;
dst += stridey;
}
}
template<int BPP>
static inline void reorienttexture(uchar * RESTRICT src, int sw, int sh, int stride, uchar * RESTRICT dst, bool flipx, bool flipy, bool swapxy)
{
int stridex = BPP, stridey = BPP;
if(swapxy) stridex *= sh; else stridey *= sw;
if(flipx) { dst += (sw-1)*stridex; stridex = -stridex; }
if(flipy) { dst += (sh-1)*stridey; stridey = -stridey; }
uchar *srcrow = src;
loopi(sh)
{
for(uchar *curdst = dst, *src = srcrow, *end = &srcrow[sw*BPP]; src < end;)
{
loopk(BPP) curdst[k] = *src++;
curdst += stridex;
}
srcrow += stride;
dst += stridey;
}
}
static void reorienttexture(uchar * RESTRICT src, int sw, int sh, int bpp, int stride, uchar * RESTRICT dst, bool flipx, bool flipy, bool swapxy)
{
switch(bpp)
{
case 1: return reorienttexture<1>(src, sw, sh, stride, dst, flipx, flipy, swapxy);
case 2: return reorienttexture<2>(src, sw, sh, stride, dst, flipx, flipy, swapxy);
case 3: return reorienttexture<3>(src, sw, sh, stride, dst, flipx, flipy, swapxy);
case 4: return reorienttexture<4>(src, sw, sh, stride, dst, flipx, flipy, swapxy);
}
}
static void reorients3tc(GLenum format, int blocksize, int w, int h, uchar *src, uchar *dst, bool flipx, bool flipy, bool swapxy, bool normals = false)
{
int bx1 = 0, by1 = 0, bx2 = min(w, 4), by2 = min(h, 4), bw = (w+3)/4, bh = (h+3)/4, stridex = blocksize, stridey = blocksize;
if(swapxy) stridex *= bw; else stridey *= bh;
if(flipx) { dst += (bw-1)*stridex; stridex = -stridex; bx1 += 4-bx2; bx2 = 4; }
if(flipy) { dst += (bh-1)*stridey; stridey = -stridey; by1 += 4-by2; by2 = 4; }
loopi(bh)
{
for(uchar *curdst = dst, *end = &src[bw*blocksize]; src < end; src += blocksize, curdst += stridex)
{
if(format == GL_COMPRESSED_RGBA_S3TC_DXT3_EXT)
{
ullong salpha = lilswap(*(const ullong *)src), dalpha = 0;
uint xmask = flipx ? 15 : 0, ymask = flipy ? 15 : 0, xshift = 2, yshift = 4;
if(swapxy) swap(xshift, yshift);
for(int y = by1; y < by2; y++) for(int x = bx1; x < bx2; x++)
{
dalpha |= ((salpha&15) << (((xmask^x)<<xshift) + ((ymask^y)<<yshift)));
salpha >>= 4;
}
*(ullong *)curdst = lilswap(dalpha);
src += 8;
curdst += 8;
}
else if(format == GL_COMPRESSED_RGBA_S3TC_DXT5_EXT)
{
uchar alpha1 = src[0], alpha2 = src[1];
ullong salpha = lilswap(*(const ushort *)&src[2]) + ((ullong)lilswap(*(const uint *)&src[4]) << 16), dalpha = 0;
uint xmask = flipx ? 7 : 0, ymask = flipy ? 7 : 0, xshift = 0, yshift = 2;
if(swapxy) swap(xshift, yshift);
for(int y = by1; y < by2; y++) for(int x = bx1; x < bx2; x++)
{
dalpha |= ((salpha&7) << (3*((xmask^x)<<xshift) + ((ymask^y)<<yshift)));
salpha >>= 3;
}
curdst[0] = alpha1;
curdst[1] = alpha2;
*(ushort *)&curdst[2] = lilswap(ushort(dalpha));
*(ushort *)&curdst[4] = lilswap(ushort(dalpha>>16));
*(ushort *)&curdst[6] = lilswap(ushort(dalpha>>32));
src += 8;
curdst += 8;
}
ushort color1 = lilswap(*(const ushort *)src), color2 = lilswap(*(const ushort *)&src[2]);
uint sbits = lilswap(*(const uint *)&src[4]);
if(normals)
{
ushort ncolor1 = color1, ncolor2 = color2;
if(flipx)
{
ncolor1 = (ncolor1 & ~0xF800) | (0xF800 - (ncolor1 & 0xF800));
ncolor2 = (ncolor2 & ~0xF800) | (0xF800 - (ncolor2 & 0xF800));
}
if(flipy)
{
ncolor1 = (ncolor1 & ~0x7E0) | (0x7E0 - (ncolor1 & 0x7E0));
ncolor2 = (ncolor2 & ~0x7E0) | (0x7E0 - (ncolor2 & 0x7E0));
}
if(swapxy)
{
ncolor1 = (ncolor1 & 0x1F) | (((((ncolor1 >> 11) & 0x1F) * 0x3F) / 0x1F) << 5) | (((((ncolor1 >> 5) & 0x3F) * 0x1F) / 0x3F) << 11);
ncolor2 = (ncolor2 & 0x1F) | (((((ncolor2 >> 11) & 0x1F) * 0x3F) / 0x1F) << 5) | (((((ncolor2 >> 5) & 0x3F) * 0x1F) / 0x3F) << 11);
}
if(color1 <= color2 && ncolor1 > ncolor2) { color1 = ncolor2; color2 = ncolor1; }
else { color1 = ncolor1; color2 = ncolor2; }
}
uint dbits = 0, xmask = flipx ? 3 : 0, ymask = flipy ? 3 : 0, xshift = 1, yshift = 3;
if(swapxy) swap(xshift, yshift);
for(int y = by1; y < by2; y++) for(int x = bx1; x < bx2; x++)
{
dbits |= ((sbits&3) << (((xmask^x)<<xshift) + ((ymask^y)<<yshift)));
sbits >>= 2;
}
*(ushort *)curdst = lilswap(color1);
*(ushort *)&curdst[2] = lilswap(color2);
*(uint *)&curdst[4] = lilswap(dbits);
if(blocksize > 8) { src -= 8; curdst -= 8; }
}
dst += stridey;
}
}
static void reorientrgtc(GLenum format, int blocksize, int w, int h, uchar *src, uchar *dst, bool flipx, bool flipy, bool swapxy)
{
int bx1 = 0, by1 = 0, bx2 = min(w, 4), by2 = min(h, 4), bw = (w+3)/4, bh = (h+3)/4, stridex = blocksize, stridey = blocksize;
if(swapxy) stridex *= bw; else stridey *= bh;
if(flipx) { dst += (bw-1)*stridex; stridex = -stridex; bx1 += 4-bx2; bx2 = 4; }
if(flipy) { dst += (bh-1)*stridey; stridey = -stridey; by1 += 4-by2; by2 = 4; }
stridex -= blocksize;
loopi(bh)
{
for(uchar *curdst = dst, *end = &src[bw*blocksize]; src < end; curdst += stridex)
{
loopj(blocksize/8)
{
uchar val1 = src[0], val2 = src[1];
ullong sval = lilswap(*(const ushort *)&src[2]) + ((ullong)lilswap(*(const uint *)&src[4] )<< 16), dval = 0;
uint xmask = flipx ? 7 : 0, ymask = flipy ? 7 : 0, xshift = 0, yshift = 2;
if(swapxy) swap(xshift, yshift);
for(int y = by1; y < by2; y++) for(int x = bx1; x < bx2; x++)
{
dval |= ((sval&7) << (3*((xmask^x)<<xshift) + ((ymask^y)<<yshift)));
sval >>= 3;
}
curdst[0] = val1;
curdst[1] = val2;
*(ushort *)&curdst[2] = lilswap(ushort(dval));
*(ushort *)&curdst[4] = lilswap(ushort(dval>>16));
*(ushort *)&curdst[6] = lilswap(ushort(dval>>32));
src += 8;
curdst += 8;
}
}
dst += stridey;
}
}
#define writetex(t, body) do \
{ \
uchar *dstrow = t.data; \
loop(y, t.h) \
{ \
for(uchar *dst = dstrow, *end = &dstrow[t.w*t.bpp]; dst < end; dst += t.bpp) \
{ \
body; \
} \
dstrow += t.pitch; \
} \
} while(0)
#define readwritetex(t, s, body) do \
{ \
uchar *dstrow = t.data, *srcrow = s.data; \
loop(y, t.h) \
{ \
for(uchar *dst = dstrow, *src = srcrow, *end = &srcrow[s.w*s.bpp]; src < end; dst += t.bpp, src += s.bpp) \
{ \
body; \
} \
dstrow += t.pitch; \
srcrow += s.pitch; \
} \
} while(0)
#define read2writetex(t, s1, src1, s2, src2, body) do \
{ \
uchar *dstrow = t.data, *src1row = s1.data, *src2row = s2.data; \
loop(y, t.h) \
{ \
for(uchar *dst = dstrow, *end = &dstrow[t.w*t.bpp], *src1 = src1row, *src2 = src2row; dst < end; dst += t.bpp, src1 += s1.bpp, src2 += s2.bpp) \
{ \
body; \
} \
dstrow += t.pitch; \
src1row += s1.pitch; \
src2row += s2.pitch; \
} \
} while(0)
#define readwritergbtex(t, s, body) \
{ \
if(t.bpp >= 3) readwritetex(t, s, body); \
else \
{ \
ImageData rgb(t.w, t.h, 3); \
read2writetex(rgb, t, orig, s, src, { dst[0] = dst[1] = dst[2] = orig[0]; body; }); \
t.replace(rgb); \
} \
}
static void forcergbimage(ImageData &s)
{
if(s.bpp >= 3) return;
ImageData d(s.w, s.h, 3);
readwritetex(d, s, { dst[0] = dst[1] = dst[2] = src[0]; });
s.replace(d);
}
#define readwritergbatex(t, s, body) \
{ \
if(t.bpp >= 4) { readwritetex(t, s, body); } \
else \
{ \
ImageData rgba(t.w, t.h, 4); \
if(t.bpp==3) read2writetex(rgba, t, orig, s, src, { dst[0] = orig[0]; dst[1] = orig[1]; dst[2] = orig[2]; body; }); \
else read2writetex(rgba, t, orig, s, src, { dst[0] = dst[1] = dst[2] = orig[0]; body; }); \
t.replace(rgba); \
} \
}
#if 0
static void forcergbaimage(ImageData &s)
{
if(s.bpp >= 4) return;
ImageData d(s.w, s.h, 4);
if(s.bpp==3) readwritetex(d, s, { dst[0] = src[0]; dst[1] = src[1]; dst[2] = src[2]; });
else readwritetex(d, s, { dst[0] = dst[1] = dst[2] = src[0]; });
s.replace(d);
}
#endif
static void swizzleimage(ImageData &s)
{
if(s.bpp==2)
{
ImageData d(s.w, s.h, 4);
readwritetex(d, s, { dst[0] = dst[1] = dst[2] = src[0]; dst[3] = src[1]; });
s.replace(d);
}
else if(s.bpp==1)
{
ImageData d(s.w, s.h, 3);
readwritetex(d, s, { dst[0] = dst[1] = dst[2] = src[0]; });
s.replace(d);
}
}
static void scaleimage(ImageData &s, int w, int h)
{
ImageData d(w, h, s.bpp);
scaletexture(s.data, s.w, s.h, s.bpp, s.pitch, d.data, w, h);
s.replace(d);
}
static void texreorient(ImageData &s, bool flipx, bool flipy, bool swapxy, int type = TEX_DIFFUSE)
{
ImageData d(swapxy ? s.h : s.w, swapxy ? s.w : s.h, s.bpp, s.levels, s.align, s.compressed);
switch(s.compressed)
{
case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
{
uchar *dst = d.data, *src = s.data;
loopi(s.levels)
{
reorients3tc(s.compressed, s.bpp, max(s.w>>i, 1), max(s.h>>i, 1), src, dst, flipx, flipy, swapxy, type==TEX_NORMAL);
src += s.calclevelsize(i);
dst += d.calclevelsize(i);
}
break;
}
case GL_COMPRESSED_RED_RGTC1:
case GL_COMPRESSED_RG_RGTC2:
case GL_COMPRESSED_LUMINANCE_LATC1_EXT:
case GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT:
{
uchar *dst = d.data, *src = s.data;
loopi(s.levels)
{
reorientrgtc(s.compressed, s.bpp, max(s.w>>i, 1), max(s.h>>i, 1), src, dst, flipx, flipy, swapxy);
src += s.calclevelsize(i);
dst += d.calclevelsize(i);
}
break;
}
default:
if(type==TEX_NORMAL && s.bpp >= 3) reorientnormals(s.data, s.w, s.h, s.bpp, s.pitch, d.data, flipx, flipy, swapxy);
else reorienttexture(s.data, s.w, s.h, s.bpp, s.pitch, d.data, flipx, flipy, swapxy);
break;
}
s.replace(d);
}
extern const texrotation texrotations[8] =
{
{ false, false, false }, // 0: default
{ false, true, true }, // 1: 90 degrees
{ true, true, false }, // 2: 180 degrees
{ true, false, true }, // 3: 270 degrees
{ true, false, false }, // 4: flip X
{ false, true, false }, // 5: flip Y
{ false, false, true }, // 6: transpose
{ true, true, true }, // 7: flipped transpose
};
static void texrotate(ImageData &s, int numrots, int type = TEX_DIFFUSE)
{
if(numrots>=1 && numrots<=7)
{
const texrotation &r = texrotations[numrots];
texreorient(s, r.flipx, r.flipy, r.swapxy, type);
}
}
static void texoffset(ImageData &s, int xoffset, int yoffset)
{
xoffset = max(xoffset, 0);
xoffset %= s.w;
yoffset = max(yoffset, 0);
yoffset %= s.h;
if(!xoffset && !yoffset) return;
ImageData d(s.w, s.h, s.bpp);
uchar *src = s.data;
loop(y, s.h)
{
uchar *dst = (uchar *)d.data+((y+yoffset)%d.h)*d.pitch;
memcpy(dst+xoffset*s.bpp, src, (s.w-xoffset)*s.bpp);
memcpy(dst, src+(s.w-xoffset)*s.bpp, xoffset*s.bpp);
src += s.pitch;
}
s.replace(d);
}
static void texcrop(ImageData &s, int x, int y, int w, int h)
{
x = std::clamp(x, 0, s.w);
y = std::clamp(y, 0, s.h);
w = min(w < 0 ? s.w : w, s.w - x);
h = min(h < 0 ? s.h : h, s.h - y);
if(!w || !h) return;
ImageData d(w, h, s.bpp);
uchar *src = s.data + y*s.pitch + x*s.bpp, *dst = d.data;
loop(y, h)
{
memcpy(dst, src, w*s.bpp);
src += s.pitch;
dst += d.pitch;
}
s.replace(d);
}
static void texmad(ImageData &s, const vec &mul, const vec &add)
{
if(s.bpp < 3 && (mul.x != mul.y || mul.y != mul.z || add.x != add.y || add.y != add.z))
swizzleimage(s);
int maxk = min(int(s.bpp), 3);
writetex(s,
loopk(maxk) dst[k] = uchar(std::clamp(dst[k]*mul[k] + 255*add[k], 0.0f, 255.0f));
);
}
static void texcolorify(ImageData &s, const vec &color, vec weights)
{
if(s.bpp < 3) return;
if(weights.iszero()) weights = vec(0.21f, 0.72f, 0.07f);
writetex(s,
float lum = dst[0]*weights.x + dst[1]*weights.y + dst[2]*weights.z;
loopk(3) dst[k] = uchar(std::clamp(lum*color[k], 0.0f, 255.0f));
);
}
static void texcolormask(ImageData &s, const vec &color1, const vec &color2)
{
if(s.bpp < 4) return;
ImageData d(s.w, s.h, 3);
readwritetex(d, s,
vec color;
color.lerp(color2, color1, src[3]/255.0f);
loopk(3) dst[k] = uchar(std::clamp(color[k]*src[k], 0.0f, 255.0f));
);
s.replace(d);
}
static void texdup(ImageData &s, int srcchan, int dstchan)
{
if(srcchan==dstchan || max(srcchan, dstchan) >= s.bpp) return;
writetex(s, dst[dstchan] = dst[srcchan]);
}
static void texmix(ImageData &s, int c1, int c2, int c3, int c4)
{
int numchans = c1 < 0 ? 0 : (c2 < 0 ? 1 : (c3 < 0 ? 2 : (c4 < 0 ? 3 : 4)));
if(numchans <= 0) return;
ImageData d(s.w, s.h, numchans);
readwritetex(d, s,
switch(numchans)
{
case 4: dst[3] = src[c4];
case 3: dst[2] = src[c3];
case 2: dst[1] = src[c2];
case 1: dst[0] = src[c1];
}
);
s.replace(d);
}
static void texgrey(ImageData &s)
{
if(s.bpp <= 2) return;
ImageData d(s.w, s.h, s.bpp >= 4 ? 2 : 1);
if(s.bpp >= 4)
{
readwritetex(d, s,
dst[0] = src[0];
dst[1] = src[3];
);
}
else
{
readwritetex(d, s, dst[0] = src[0]);
}
s.replace(d);
}
static void texpremul(ImageData &s)
{
switch(s.bpp)
{
case 2:
writetex(s,
dst[0] = uchar((uint(dst[0])*uint(dst[1]))/255);
);
break;
case 4:
writetex(s,
uint alpha = dst[3];
dst[0] = uchar((uint(dst[0])*alpha)/255);
dst[1] = uchar((uint(dst[1])*alpha)/255);
dst[2] = uchar((uint(dst[2])*alpha)/255);
);
break;
}
}
static void texagrad(ImageData &s, float x2, float y2, float x1, float y1)
{
if(s.bpp != 2 && s.bpp != 4) return;
y1 = 1 - y1;
y2 = 1 - y2;
float minx = 1, miny = 1, maxx = 1, maxy = 1;
if(x1 != x2)
{
minx = (0 - x1) / (x2 - x1);
maxx = (1 - x1) / (x2 - x1);
}
if(y1 != y2)
{
miny = (0 - y1) / (y2 - y1);
maxy = (1 - y1) / (y2 - y1);
}
float dx = (maxx - minx)/max(s.w-1, 1),
dy = (maxy - miny)/max(s.h-1, 1),
cury = miny;
for(uchar *dstrow = s.data + s.bpp - 1, *endrow = dstrow + s.h*s.pitch; dstrow < endrow; dstrow += s.pitch)
{
float curx = minx;
for(uchar *dst = dstrow, *end = &dstrow[s.w*s.bpp]; dst < end; dst += s.bpp)
{
dst[0] = uchar(dst[0]*std::clamp(curx, 0.0f, 1.0f)*std::clamp(cury, 0.0f, 1.0f));
curx += dx;
}
cury += dy;
}
}
static void texblend(ImageData &d, ImageData &s, ImageData &m)
{
if(s.w != d.w || s.h != d.h) scaleimage(s, d.w, d.h);
if(m.w != d.w || m.h != d.h) scaleimage(m, d.w, d.h);
if(&s == &m)
{
if(s.bpp == 2)
{
if(d.bpp >= 3) swizzleimage(s);
}
else if(s.bpp == 4)
{
if(d.bpp < 3) swizzleimage(d);
}
else return;
if(d.bpp < 3) readwritetex(d, s,
int srcblend = src[1];
int dstblend = 255 - srcblend;
dst[0] = uchar((dst[0]*dstblend + src[0]*srcblend)/255);
);
else readwritetex(d, s,
int srcblend = src[3];
int dstblend = 255 - srcblend;
dst[0] = uchar((dst[0]*dstblend + src[0]*srcblend)/255);
dst[1] = uchar((dst[1]*dstblend + src[1]*srcblend)/255);
dst[2] = uchar((dst[2]*dstblend + src[2]*srcblend)/255);
);
}
else
{
if(s.bpp < 3)
{
if(d.bpp >= 3) swizzleimage(s);
}
else if(d.bpp < 3) swizzleimage(d);
if(d.bpp < 3) read2writetex(d, s, src, m, mask,
int srcblend = mask[0];
int dstblend = 255 - srcblend;
dst[0] = uchar((dst[0]*dstblend + src[0]*srcblend)/255);
);
else read2writetex(d, s, src, m, mask,
int srcblend = mask[0];
int dstblend = 255 - srcblend;
dst[0] = uchar((dst[0]*dstblend + src[0]*srcblend)/255);
dst[1] = uchar((dst[1]*dstblend + src[1]*srcblend)/255);
dst[2] = uchar((dst[2]*dstblend + src[2]*srcblend)/255);
);
}
}
VAR(hwtexsize, 1, 0, 0);
VAR(hwcubetexsize, 1, 0, 0);
VAR(hwmaxaniso, 1, 0, 0);
VAR(hwtexunits, 1, 0, 0);
VAR(hwvtexunits, 1, 0, 0);
VARFP(maxtexsize, 0, 0, 1<<12, initwarning("texture quality", INIT_LOAD));
VARFP(reducefilter, 0, 1, 1, initwarning("texture quality", INIT_LOAD));
VARFP(texreduce, 0, 0, 12, initwarning("texture quality", INIT_LOAD));
VARFP(texcompress, 0, 1536, 1<<12, initwarning("texture quality", INIT_LOAD));
VARFP(texcompressquality, -1, -1, 1, setuptexcompress());
VARF(trilinear, 0, 1, 1, initwarning("texture filtering", INIT_LOAD));
VARF(bilinear, 0, 1, 1, initwarning("texture filtering", INIT_LOAD));
VARFP(aniso, 0, 0, 16, initwarning("texture filtering", INIT_LOAD));
extern int usetexcompress;
void setuptexcompress()
{
if(!usetexcompress) return;
GLenum hint = GL_DONT_CARE;
switch(texcompressquality)
{
case 1: hint = GL_NICEST; break;
case 0: hint = GL_FASTEST; break;
}
glHint(GL_TEXTURE_COMPRESSION_HINT, hint);
}
static GLenum compressedformat(GLenum format, int w, int h, int force = 0)
{
if(usetexcompress && texcompress && force >= 0 && (force || max(w, h) >= texcompress)) switch(format)
{
case GL_R3_G3_B2:
case GL_RGB5:
case GL_RGB565:
case GL_RGB8:
case GL_RGB: return usetexcompress > 1 ? GL_COMPRESSED_RGB_S3TC_DXT1_EXT : GL_COMPRESSED_RGB;
case GL_RGB5_A1: return usetexcompress > 1 ? GL_COMPRESSED_RGBA_S3TC_DXT1_EXT : GL_COMPRESSED_RGBA;
case GL_RGBA: return usetexcompress > 1 ? GL_COMPRESSED_RGBA_S3TC_DXT5_EXT : GL_COMPRESSED_RGBA;
case GL_RED:
case GL_R8: return hasRGTC ? (usetexcompress > 1 ? GL_COMPRESSED_RED_RGTC1 : GL_COMPRESSED_RED) : (usetexcompress > 1 ? GL_COMPRESSED_RGB_S3TC_DXT1_EXT : GL_COMPRESSED_RGB);
case GL_RG:
case GL_RG8: return hasRGTC ? (usetexcompress > 1 ? GL_COMPRESSED_RG_RGTC2 : GL_COMPRESSED_RG) : (usetexcompress > 1 ? GL_COMPRESSED_RGBA_S3TC_DXT5_EXT : GL_COMPRESSED_RGBA);
case GL_LUMINANCE:
case GL_LUMINANCE8: return hasLATC ? (usetexcompress > 1 ? GL_COMPRESSED_LUMINANCE_LATC1_EXT : GL_COMPRESSED_LUMINANCE) : (usetexcompress > 1 ? GL_COMPRESSED_RGB_S3TC_DXT1_EXT : GL_COMPRESSED_RGB);
case GL_LUMINANCE_ALPHA:
case GL_LUMINANCE8_ALPHA8: return hasLATC ? (usetexcompress > 1 ? GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT : GL_COMPRESSED_LUMINANCE_ALPHA) : (usetexcompress > 1 ? GL_COMPRESSED_RGBA_S3TC_DXT5_EXT : GL_COMPRESSED_RGBA);
}
return format;
}
static GLenum uncompressedformat(GLenum format)
{
switch(format)
{
case GL_COMPRESSED_ALPHA:
return GL_ALPHA;
case GL_COMPRESSED_LUMINANCE:
case GL_COMPRESSED_LUMINANCE_LATC1_EXT:
return GL_LUMINANCE;
case GL_COMPRESSED_LUMINANCE_ALPHA:
case GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT:
return GL_LUMINANCE_ALPHA;
case GL_COMPRESSED_RED:
case GL_COMPRESSED_RED_RGTC1:
return GL_RED;
case GL_COMPRESSED_RG:
case GL_COMPRESSED_RG_RGTC2:
return GL_RG;
case GL_COMPRESSED_RGB:
case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
return GL_RGB;
case GL_COMPRESSED_RGBA:
case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
return GL_RGBA;
}
return GL_FALSE;
}
static int formatsize(GLenum format)
{
switch(format)
{
case GL_RED:
case GL_LUMINANCE:
case GL_ALPHA: return 1;
case GL_RG:
case GL_LUMINANCE_ALPHA: return 2;
case GL_RGB: return 3;
case GL_RGBA: return 4;
default: return 4;
}
}
static GLenum sizedformat(GLenum format)
{
switch(format)
{
case GL_RED: return GL_R8;
case GL_RG: return GL_RG8;
case GL_RGB: return GL_RGB8;
case GL_RGBA: return GL_RGBA8;
}
return format;
}
VARFP(usenp2, 0, 1, 1, initwarning("texture quality", INIT_LOAD));
static void resizetexture(int w, int h, bool mipmap, bool canreduce, GLenum target, int compress, int &tw, int &th)
{
int hwlimit = target==GL_TEXTURE_CUBE_MAP ? hwcubetexsize : hwtexsize,
sizelimit = mipmap && maxtexsize ? min(maxtexsize, hwlimit) : hwlimit;
if(compress > 0 && !usetexcompress)
{
w = max(w/compress, 1);
h = max(h/compress, 1);
}
if(canreduce && texreduce)
{
w = max(w>>texreduce, 1);
h = max(h>>texreduce, 1);
}
w = min(w, sizelimit);
h = min(h, sizelimit);
if(!usenp2 && target!=GL_TEXTURE_RECTANGLE && (w&(w-1) || h&(h-1)))
{
tw = th = 1;
while(tw < w) tw *= 2;
while(th < h) th *= 2;
if(w < tw - tw/4) tw /= 2;
if(h < th - th/4) th /= 2;
}
else
{
tw = w;
th = h;
}
}
static GLuint mipmapfbo[2] = { 0, 0 };
void cleanupmipmaps()
{
if(mipmapfbo[0]) { glDeleteFramebuffers_(2, mipmapfbo); memset(mipmapfbo, 0, sizeof(mipmapfbo)); }
}
VARFP(gpumipmap, 0, 1, 1, cleanupmipmaps());
static void uploadtexture(int tnum, GLenum target, GLenum internal, int tw, int th, GLenum format, GLenum type, const void *pixels, int pw, int ph, int pitch, bool mipmap, bool prealloc)
{
int bpp = formatsize(format), row = 0, rowalign = 0;
if(!pitch) pitch = pw*bpp;
uchar *buf = nullptr;
if(pw!=tw || ph!=th)
{
buf = new uchar[tw*th*bpp];
scaletexture((uchar *)pixels, pw, ph, bpp, pitch, buf, tw, th);
}
else if(tw*bpp != pitch)
{
row = pitch/bpp;
rowalign = texalign(pixels, pitch, 1);
while(rowalign > 0 && ((row*bpp + rowalign - 1)/rowalign)*rowalign != pitch) rowalign >>= 1;
if(!rowalign)
{
row = 0;
buf = new uchar[tw*th*bpp];
loopi(th) memcpy(&buf[i*tw*bpp], &((uchar *)pixels)[i*pitch], tw*bpp);
}
}
bool shouldgpumipmap = pixels && mipmap && max(tw, th) > 1 && gpumipmap && hasFBB && !uncompressedformat(internal);
for(int level = 0, align = 0, mw = tw, mh = th;; level++)
{
uchar *src = buf ? buf : (uchar *)pixels;
if(buf) pitch = mw*bpp;
int srcalign = row > 0 ? rowalign : texalign(src, pitch, 1);
if(align != srcalign) glPixelStorei(GL_UNPACK_ALIGNMENT, align = srcalign);
if(row > 0) glPixelStorei(GL_UNPACK_ROW_LENGTH, row);
if(!prealloc) glTexImage2D(target, level, internal, mw, mh, 0, format, type, src);
else if(src) glTexSubImage2D(target, level, 0, 0, mw, mh, format, type, src);
if(row > 0) glPixelStorei(GL_UNPACK_ROW_LENGTH, row = 0);
if(!mipmap || shouldgpumipmap || max(mw, mh) <= 1) break;
int srcw = mw, srch = mh;
if(mw > 1) mw /= 2;
if(mh > 1) mh /= 2;
if(src)
{
if(!buf) buf = new uchar[mw*mh*bpp];
scaletexture(src, srcw, srch, bpp, pitch, buf, mw, mh);
}
}
if(buf) delete[] buf;
if(shouldgpumipmap)
{
GLint fbo = 0;
if(!inbetweenframes || drawtex) glGetIntegerv(GL_FRAMEBUFFER_BINDING, &fbo);
if(!prealloc) for(int level = 1, mw = tw, mh = th; max(mw, mh) > 1; level++)
{
if(mw > 1) mw /= 2;
if(mh > 1) mh /= 2;
glTexImage2D(target, level, internal, mw, mh, 0, format, type, nullptr);
}
if(!mipmapfbo[0]) glGenFramebuffers_(2, mipmapfbo);
glBindFramebuffer_(GL_READ_FRAMEBUFFER, mipmapfbo[0]);
glBindFramebuffer_(GL_DRAW_FRAMEBUFFER, mipmapfbo[1]);
for(int level = 1, mw = tw, mh = th; max(mw, mh) > 1; level++)
{
int srcw = mw, srch = mh;
if(mw > 1) mw /= 2;
if(mh > 1) mh /= 2;
glFramebufferTexture2D_(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, target, tnum, level - 1);
glFramebufferTexture2D_(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, target, tnum, level);
glBlitFramebuffer_(0, 0, srcw, srch, 0, 0, mw, mh, GL_COLOR_BUFFER_BIT, GL_LINEAR);
}
glFramebufferTexture2D_(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, target, 0, 0);
glFramebufferTexture2D_(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, target, 0, 0);
glBindFramebuffer_(GL_FRAMEBUFFER, fbo);
}
}
static void uploadcompressedtexture(GLenum target, GLenum subtarget, GLenum format, int w, int h, const uchar *data, int align, int blocksize, int levels, bool mipmap, bool prealloc)
{
int hwlimit = target==GL_TEXTURE_CUBE_MAP ? hwcubetexsize : hwtexsize,
sizelimit = levels > 1 && maxtexsize ? min(maxtexsize, hwlimit) : hwlimit;
int level = 0;
loopi(levels)
{
int size = ((w + align-1)/align) * ((h + align-1)/align) * blocksize;
if(w <= sizelimit && h <= sizelimit)
{
if(prealloc) glCompressedTexSubImage2D_(subtarget, level, 0, 0, w, h, format, size, data);
else glCompressedTexImage2D_(subtarget, level, format, w, h, 0, size, data);
level++;
if(!mipmap) break;
}
if(max(w, h) <= 1) break;
if(w > 1) w /= 2;
if(h > 1) h /= 2;
data += size;
}
}
static GLenum textarget(GLenum subtarget)
{
switch(subtarget)
{
case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
return GL_TEXTURE_CUBE_MAP;
}
return subtarget;
}
static const GLint *swizzlemask(GLenum format)
{
static const GLint luminance[4] = { GL_RED, GL_RED, GL_RED, GL_ONE };
static const GLint luminancealpha[4] = { GL_RED, GL_RED, GL_RED, GL_GREEN };
switch(format)
{
case GL_RED: return luminance;
case GL_RG: return luminancealpha;
}
return nullptr;
}
static void setuptexparameters(int tnum, const void *pixels, int clamp, int filter, GLenum format, GLenum target, bool swizzle)
{
glBindTexture(target, tnum);
glTexParameteri(target, GL_TEXTURE_WRAP_S, clamp&1 ? GL_CLAMP_TO_EDGE : (clamp&0x100 ? GL_MIRRORED_REPEAT : GL_REPEAT));
glTexParameteri(target, GL_TEXTURE_WRAP_T, clamp&2 ? GL_CLAMP_TO_EDGE : (clamp&0x200 ? GL_MIRRORED_REPEAT : GL_REPEAT));
if(target==GL_TEXTURE_3D) glTexParameteri(target, GL_TEXTURE_WRAP_R, clamp&4 ? GL_CLAMP_TO_EDGE : (clamp&0x400 ? GL_MIRRORED_REPEAT : GL_REPEAT));
if(target==GL_TEXTURE_2D && hasAF && min(aniso, hwmaxaniso) > 0 && filter > 1) glTexParameteri(target, GL_TEXTURE_MAX_ANISOTROPY_EXT, min(aniso, hwmaxaniso));
glTexParameteri(target, GL_TEXTURE_MAG_FILTER, filter && bilinear ? GL_LINEAR : GL_NEAREST);
glTexParameteri(target, GL_TEXTURE_MIN_FILTER,
filter > 1 ?
(trilinear ?
(bilinear ? GL_LINEAR_MIPMAP_LINEAR : GL_NEAREST_MIPMAP_LINEAR) :
(bilinear ? GL_LINEAR_MIPMAP_NEAREST : GL_NEAREST_MIPMAP_NEAREST)) :
(filter && bilinear ? GL_LINEAR : GL_NEAREST));
if(swizzle && hasTRG && hasTSW)
{
const GLint *mask = swizzlemask(format);
if(mask) glTexParameteriv(target, GL_TEXTURE_SWIZZLE_RGBA, mask);
}
}
static GLenum textype(GLenum &component, GLenum &format)
{
GLenum type = GL_UNSIGNED_BYTE;
switch(component)
{
case GL_R16F:
case GL_R32F:
if(!format) format = GL_RED;
type = GL_FLOAT;
break;
case GL_RG16F:
case GL_RG32F:
if(!format) format = GL_RG;
type = GL_FLOAT;
break;
case GL_RGB16F:
case GL_RGB32F:
case GL_R11F_G11F_B10F:
if(!format) format = GL_RGB;
type = GL_FLOAT;
break;
case GL_RGBA16F:
case GL_RGBA32F:
if(!format) format = GL_RGBA;
type = GL_FLOAT;
break;
case GL_DEPTH_COMPONENT16:
case GL_DEPTH_COMPONENT24:
case GL_DEPTH_COMPONENT32:
if(!format) format = GL_DEPTH_COMPONENT;
break;
case GL_DEPTH_STENCIL:
case GL_DEPTH24_STENCIL8:
if(!format) format = GL_DEPTH_STENCIL;
type = GL_UNSIGNED_INT_24_8;
break;
case GL_R8:
case GL_R16:
case GL_COMPRESSED_RED:
case GL_COMPRESSED_RED_RGTC1:
if(!format) format = GL_RED;
break;
case GL_RG8:
case GL_RG16:
case GL_COMPRESSED_RG:
case GL_COMPRESSED_RG_RGTC2:
if(!format) format = GL_RG;
break;
case GL_R3_G3_B2:
case GL_RGB5:
case GL_RGB565:
case GL_RGB8:
case GL_RGB16:
case GL_RGB10:
case GL_COMPRESSED_RGB:
case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
if(!format) format = GL_RGB;
break;
case GL_RGBA4:
case GL_RGB5_A1:
case GL_RGBA8:
case GL_RGBA16:
case GL_RGB10_A2:
case GL_COMPRESSED_RGBA:
case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
if(!format) format = GL_RGBA;
break;
case GL_LUMINANCE8:
case GL_LUMINANCE16:
case GL_COMPRESSED_LUMINANCE:
case GL_COMPRESSED_LUMINANCE_LATC1_EXT:
if(!format) format = GL_LUMINANCE;
break;
case GL_LUMINANCE8_ALPHA8:
case GL_LUMINANCE16_ALPHA16:
case GL_COMPRESSED_LUMINANCE_ALPHA:
case GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT:
if(!format) format = GL_LUMINANCE_ALPHA;
break;
case GL_ALPHA8:
case GL_ALPHA16:
case GL_COMPRESSED_ALPHA:
if(!format) format = GL_ALPHA;
break;
case GL_RGB8UI:
case GL_RGB16UI:
case GL_RGB32UI:
case GL_RGB8I:
case GL_RGB16I:
case GL_RGB32I:
if(!format) format = GL_RGB_INTEGER;
break;
case GL_RGBA8UI:
case GL_RGBA16UI:
case GL_RGBA32UI:
case GL_RGBA8I:
case GL_RGBA16I:
case GL_RGBA32I:
if(!format) format = GL_RGBA_INTEGER;
break;
case GL_R8UI:
case GL_R16UI:
case GL_R32UI:
case GL_R8I:
case GL_R16I:
case GL_R32I:
if(!format) format = GL_RED_INTEGER;
break;
case GL_RG8UI:
case GL_RG16UI:
case GL_RG32UI:
case GL_RG8I:
case GL_RG16I:
case GL_RG32I:
if(!format) format = GL_RG_INTEGER;
break;
}
if(!format) format = component;
return type;
}
static int miplevels(int n)
{
int levels = 1;
for(; n > 1; n /= 2) levels++;
return levels;
}
void createtexture(int tnum, int w, int h, const void *pixels, int clamp, int filter, GLenum component, GLenum subtarget, int pw, int ph, int pitch, bool resize, GLenum format, bool swizzle)
{
GLenum target = textarget(subtarget), type = textype(component, format);
if(!pw) pw = w;
if(!ph) ph = h;
int tw = w, th = h;
bool mipmap = filter > 1;
if(resize && pixels)
{
resizetexture(w, h, mipmap, false, target, 0, tw, th);
if(mipmap) component = compressedformat(component, tw, th);
}
bool prealloc = !resize && hasTS && hasTRG && hasTSW && !uncompressedformat(component);
if(filter >= 0 && clamp >= 0)
{
setuptexparameters(tnum, pixels, clamp, filter, format, target, swizzle);
if(prealloc) glTexStorage2D_(target, mipmap ? miplevels(max(tw, th)) : 1, sizedformat(component), tw, th);
}
uploadtexture(tnum, subtarget, component, tw, th, format, type, pixels, pw, ph, pitch, mipmap, prealloc);
}
static void createcompressedtexture(int tnum, int w, int h, const uchar *data, int align, int blocksize, int levels, int clamp, int filter, GLenum format, GLenum subtarget, bool swizzle = false)
{
GLenum target = textarget(subtarget);
bool mipmap = filter > 1, prealloc = hasTS && hasTRG && hasTSW;
if(filter >= 0 && clamp >= 0)
{
setuptexparameters(tnum, data, clamp, filter, format, target, swizzle);
if(prealloc) glTexStorage2D_(target, mipmap ? miplevels(max(w, h)) : 1, format, w, h);
}
uploadcompressedtexture(target, subtarget, format, w, h, data, align, blocksize, levels, mipmap, prealloc);
}
void create3dtexture(int tnum, int w, int h, int d, const void *pixels, int clamp, int filter, GLenum component, GLenum target, bool swizzle)
{
GLenum format = GL_FALSE, type = textype(component, format);
if(filter >= 0 && clamp >= 0) setuptexparameters(tnum, pixels, clamp, filter, format, target, swizzle);
glTexImage3D_(target, 0, component, w, h, d, 0, format, type, pixels);
}
static hashnameset<Texture> textures;
Texture *notexture = nullptr; // used as default, ensured to be loaded
static GLenum texformat(int bpp, bool swizzle = false)
{
switch(bpp)
{
case 1: return hasTRG && (hasTSW || !glcompat || !swizzle) ? GL_RED : GL_LUMINANCE;
case 2: return hasTRG && (hasTSW || !glcompat || !swizzle) ? GL_RG : GL_LUMINANCE_ALPHA;
case 3: return GL_RGB;
case 4: return GL_RGBA;
default: return 0;
}
}
static bool alphaformat(GLenum format)
{
switch(format)
{
case GL_ALPHA:
case GL_LUMINANCE_ALPHA:
case GL_RG:
case GL_RGBA:
return true;
default:
return false;
}
}
int texalign(const void *data, int w, int bpp)
{
int stride = w*bpp;
if(stride&1) return 1;
if(stride&2) return 2;
return 4;
}
bool floatformat(GLenum format)
{
switch(format)
{
case GL_R16F:
case GL_R32F:
case GL_RG16F:
case GL_RG32F:
case GL_RGB16F:
case GL_RGB32F:
case GL_R11F_G11F_B10F:
case GL_RGBA16F:
case GL_RGBA32F:
return true;
default:
return false;
}
}
static Texture *newtexture(Texture *t, const char *rname, ImageData &s, int clamp = 0, bool mipit = true, bool canreduce = false, bool transient = false, int compress = 0)
{
if(!t)
{
char *key = newstring(rname);
t = &textures[key];
t->name = key;
}
t->clamp = clamp;
t->mipmap = mipit;
t->type = Texture::IMAGE;
if(transient) t->type |= Texture::TRANSIENT;
if(clamp&0x300) t->type |= Texture::MIRROR;
if(!s.data)
{
t->type |= Texture::STUB;
t->w = t->h = t->xs = t->ys = t->bpp = 0;
return t;
}
bool swizzle = !(clamp&0x10000);
GLenum format;
if(s.compressed)
{
format = uncompressedformat(s.compressed);
t->bpp = formatsize(format);
t->type |= Texture::COMPRESSED;
}
else
{
format = texformat(s.bpp, swizzle);
t->bpp = s.bpp;
if(swizzle && hasTRG && !hasTSW && swizzlemask(format))
{
swizzleimage(s);
format = texformat(s.bpp, swizzle);
t->bpp = s.bpp;
}
}
if(alphaformat(format)) t->type |= Texture::ALPHA;
t->w = t->xs = s.w;
t->h = t->ys = s.h;
int filter = !canreduce || reducefilter ? (mipit ? 2 : 1) : 0;
glGenTextures(1, &t->id);
if(s.compressed)
{
uchar *data = s.data;
int levels = s.levels, level = 0;
if(canreduce && texreduce) loopi(min(texreduce, s.levels-1))
{
data += s.calclevelsize(level++);
levels--;
if(t->w > 1) t->w /= 2;
if(t->h > 1) t->h /= 2;
}
int sizelimit = mipit && maxtexsize ? min(maxtexsize, hwtexsize) : hwtexsize;
while(t->w > sizelimit || t->h > sizelimit)
{
data += s.calclevelsize(level++);
levels--;
if(t->w > 1) t->w /= 2;
if(t->h > 1) t->h /= 2;
}
createcompressedtexture(t->id, t->w, t->h, data, s.align, s.bpp, levels, clamp, filter, s.compressed, GL_TEXTURE_2D, swizzle);
}
else
{
resizetexture(t->w, t->h, mipit, canreduce, GL_TEXTURE_2D, compress, t->w, t->h);
GLenum component = compressedformat(format, t->w, t->h, compress);
createtexture(t->id, t->w, t->h, s.data, clamp, filter, component, GL_TEXTURE_2D, t->xs, t->ys, s.pitch, false, format, swizzle);
}
return t;
}
#ifdef SAUERLIB_BIG_ENDIAN
#define RGBAMASKS 0xff000000, 0x00ff0000, 0x0000ff00, 0x000000ff
#define RGBMASKS 0xff0000, 0x00ff00, 0x0000ff, 0
#else
#define RGBAMASKS 0x000000ff, 0x0000ff00, 0x00ff0000, 0xff000000
#define RGBMASKS 0x0000ff, 0x00ff00, 0xff0000, 0
#endif
static SDL_Surface *wrapsurface(void *data, int width, int height, int bpp)
{
switch(bpp)
{
case 3: return SDL_CreateRGBSurfaceFrom(data, width, height, 8*bpp, bpp*width, RGBMASKS);
case 4: return SDL_CreateRGBSurfaceFrom(data, width, height, 8*bpp, bpp*width, RGBAMASKS);
}
return nullptr;
}
static SDL_Surface *creatergbsurface(SDL_Surface *os)
{
SDL_Surface *ns = SDL_CreateRGBSurface(SDL_SWSURFACE, os->w, os->h, 24, RGBMASKS);
if(ns) SDL_BlitSurface(os, nullptr, ns, nullptr);
SDL_FreeSurface(os);
return ns;
}
static SDL_Surface *creatergbasurface(SDL_Surface *os)
{
SDL_Surface *ns = SDL_CreateRGBSurface(SDL_SWSURFACE, os->w, os->h, 32, RGBAMASKS);
if(ns)
{
SDL_SetSurfaceBlendMode(os, SDL_BLENDMODE_NONE);
SDL_BlitSurface(os, nullptr, ns, nullptr);
}
SDL_FreeSurface(os);
return ns;
}
static bool checkgrayscale(SDL_Surface *s)
{
// gray scale images have 256 levels, no colorkey, and the palette is a ramp
if(s->format->palette)
{
if(s->format->palette->ncolors != 256 || SDL_GetColorKey(s, nullptr) >= 0) return false;
const SDL_Color *colors = s->format->palette->colors;
loopi(256) if(colors[i].r != i || colors[i].g != i || colors[i].b != i) return false;
}
return true;
}
static SDL_Surface *fixsurfaceformat(SDL_Surface *s)
{
if(!s) return nullptr;
if(!s->pixels || min(s->w, s->h) <= 0 || s->format->BytesPerPixel <= 0)
{
SDL_FreeSurface(s);
return nullptr;
}
static const uint rgbmasks[] = { RGBMASKS }, rgbamasks[] = { RGBAMASKS };
switch(s->format->BytesPerPixel)
{
case 1:
if(!checkgrayscale(s)) return SDL_GetColorKey(s, nullptr) >= 0 ? creatergbasurface(s) : creatergbsurface(s);
break;
case 3:
if(s->format->Rmask != rgbmasks[0] || s->format->Gmask != rgbmasks[1] || s->format->Bmask != rgbmasks[2])
return creatergbsurface(s);
break;
case 4:
if(s->format->Rmask != rgbamasks[0] || s->format->Gmask != rgbamasks[1] || s->format->Bmask != rgbamasks[2] || s->format->Amask != rgbamasks[3])
return s->format->Amask ? creatergbasurface(s) : creatergbsurface(s);
break;
}
return s;
}
static void texflip(ImageData &s)
{
ImageData d(s.w, s.h, s.bpp);
uchar *dst = d.data, *src = &s.data[s.pitch*s.h];
loopi(s.h)
{
src -= s.pitch;
memcpy(dst, src, s.bpp*s.w);
dst += d.pitch;
}
s.replace(d);
}
static void texnormal(ImageData &s, int emphasis)
{
ImageData d(s.w, s.h, 3);
uchar *src = s.data, *dst = d.data;
loop(y, s.h) loop(x, s.w)
{
vec normal(0.0f, 0.0f, 255.0f/emphasis);
normal.x += src[y*s.pitch + ((x+s.w-1)%s.w)*s.bpp];
normal.x -= src[y*s.pitch + ((x+1)%s.w)*s.bpp];
normal.y += src[((y+s.h-1)%s.h)*s.pitch + x*s.bpp];
normal.y -= src[((y+1)%s.h)*s.pitch + x*s.bpp];
normal.normalize();
*dst++ = uchar(127.5f + normal.x*127.5f);
*dst++ = uchar(127.5f + normal.y*127.5f);
*dst++ = uchar(127.5f + normal.z*127.5f);
}
s.replace(d);
}
template<int n, int bpp, bool normals>
static void blurtexture(int w, int h, uchar *dst, const uchar *src, int margin)
{
static const int weights3x3[9] =
{
0x10, 0x20, 0x10,
0x20, 0x40, 0x20,
0x10, 0x20, 0x10
};
static const int weights5x5[25] =
{
0x05, 0x05, 0x09, 0x05, 0x05,
0x05, 0x0A, 0x14, 0x0A, 0x05,
0x09, 0x14, 0x28, 0x14, 0x09,
0x05, 0x0A, 0x14, 0x0A, 0x05,
0x05, 0x05, 0x09, 0x05, 0x05
};
const int *mat = n > 1 ? weights5x5 : weights3x3;
int mstride = 2*n + 1,
mstartoffset = n*(mstride + 1),
stride = bpp*w,
startoffset = n*bpp,
nextoffset1 = stride + mstride*bpp,
nextoffset2 = stride - mstride*bpp;
src += margin*(stride + bpp);
for(int y = margin; y < h-margin; y++)
{
for(int x = margin; x < w-margin; x++)
{
int dr = 0, dg = 0, db = 0;
const uchar *p = src - startoffset;
const int *m = mat + mstartoffset;
for(int t = y; t >= y-n; t--, p -= nextoffset1, m -= mstride)
{
if(t < 0) p += stride;
int a = 0;
if(n > 1) { a += m[-2]; if(x >= 2) { dr += p[0] * a; dg += p[1] * a; db += p[2] * a; a = 0; } p += bpp; }
a += m[-1]; if(x >= 1) { dr += p[0] * a; dg += p[1] * a; db += p[2] * a; a = 0; } p += bpp;
int cr = p[0], cg = p[1], cb = p[2]; a += m[0]; dr += cr * a; dg += cg * a; db += cb * a; p += bpp;
if(x+1 < w) { cr = p[0]; cg = p[1]; cb = p[2]; } dr += cr * m[1]; dg += cg * m[1]; db += cb * m[1]; p += bpp;
if(n > 1) { if(x+2 < w) { cr = p[0]; cg = p[1]; cb = p[2]; } dr += cr * m[2]; dg += cg * m[2]; db += cb * m[2]; p += bpp; }
}
p = src - startoffset + stride;
m = mat + mstartoffset + mstride;
for(int t = y+1; t <= y+n; t++, p += nextoffset2, m += mstride)
{
if(t >= h) p -= stride;
int a = 0;
if(n > 1) { a += m[-2]; if(x >= 2) { dr += p[0] * a; dg += p[1] * a; db += p[2] * a; a = 0; } p += bpp; }
a += m[-1]; if(x >= 1) { dr += p[0] * a; dg += p[1] * a; db += p[2] * a; a = 0; } p += bpp;
int cr = p[0], cg = p[1], cb = p[2]; a += m[0]; dr += cr * a; dg += cg * a; db += cb * a; p += bpp;
if(x+1 < w) { cr = p[0]; cg = p[1]; cb = p[2]; } dr += cr * m[1]; dg += cg * m[1]; db += cb * m[1]; p += bpp;
if(n > 1) { if(x+2 < w) { cr = p[0]; cg = p[1]; cb = p[2]; } dr += cr * m[2]; dg += cg * m[2]; db += cb * m[2]; p += bpp; }
}
if(normals)
{
vec v(dr-0x7F80, dg-0x7F80, db-0x7F80);
float mag = 127.5f/v.magnitude();
dst[0] = uchar(v.x*mag + 127.5f);
dst[1] = uchar(v.y*mag + 127.5f);
dst[2] = uchar(v.z*mag + 127.5f);
}
else
{
dst[0] = dr>>8;
dst[1] = dg>>8;
dst[2] = db>>8;
}
if(bpp > 3) dst[3] = src[3];
dst += bpp;
src += bpp;
}
src += 2*margin*bpp;
}
}
static void blurtexture(int n, int bpp, int w, int h, uchar *dst, const uchar *src, int margin = 0)
{
switch((std::clamp(n, 1, 2)<<4) | bpp)
{
case 0x13: blurtexture<1, 3, false>(w, h, dst, src, margin); break;
case 0x23: blurtexture<2, 3, false>(w, h, dst, src, margin); break;
case 0x14: blurtexture<1, 4, false>(w, h, dst, src, margin); break;
case 0x24: blurtexture<2, 4, false>(w, h, dst, src, margin); break;
}
}
#if 0
static void blurnormals(int n, int w, int h, bvec *dst, const bvec *src, int margin = 0)
{
switch(std::clamp(n, 1, 2))
{
case 1: blurtexture<1, 3, true>(w, h, dst->v, src->v, margin); break;
case 2: blurtexture<2, 3, true>(w, h, dst->v, src->v, margin); break;
}
}
#endif
static void texblur(ImageData &s, int n, int r)
{
if(s.bpp < 3) return;
loopi(r)
{
ImageData d(s.w, s.h, s.bpp);
blurtexture(n, s.bpp, s.w, s.h, d.data, s.data);
s.replace(d);
}
}
static bool canloadsurface(const char *name)
{
stream *f = openfile(name, "rb");
if(!f) return false;
delete f;
return true;
}
static SDL_Surface *loadsurface(const char *name)
{
SDL_Surface *s = nullptr;
stream *z = openzipfile(name, "rb");
if(z)
{
SDL_RWops *rw = stream_rwops(z);
if(rw)
{
const char *ext = strrchr(name, '.');
if(ext) ++ext;
s = IMG_LoadTyped_RW(rw, 0, ext);
SDL_FreeRW(rw);
}
delete z;
}
if(!s) s = IMG_Load(findfile(name, "rb"));
return fixsurfaceformat(s);
}
static vec parsevec(const char *arg)
{
vec v(0, 0, 0);
int i = 0;
for(; arg[0] && (!i || arg[0]=='/') && i<3; arg += strcspn(arg, "/,><"), i++)
{
if(i) arg++;
v[i] = atof(arg);
}
if(i==1) v.y = v.z = v.x;
return v;
}
VAR(usedds, 0, 1, 1);
VAR(dbgdds, 0, 0, 1);
VAR(scaledds, 0, 2, 4);
static bool texturedata(ImageData &d, const char *tname, bool msg = true, int *compress = nullptr, int *wrap = nullptr, const char *tdir = nullptr, int ttype = TEX_DIFFUSE)
{
const char *cmds = nullptr, *file = tname;
if(tname[0]=='<')
{
cmds = tname;
file = strrchr(tname, '>');
if(!file) { if(msg) conoutf(CON_ERROR, "could not load texture %s", tname); return false; }
file++;
}
string pname;
if(tdir)
{
formatstring(pname, "%s/%s", tdir, file);
file = path(pname);
}
bool raw = !usedds || !compress, dds = false;
for(const char *pcmds = cmds; pcmds;)
{
#define PARSETEXCOMMANDS(cmds) \
const char *cmd = nullptr, *end = nullptr, *arg[4] = { nullptr, nullptr, nullptr, nullptr }; \
cmd = &cmds[1]; \
end = strchr(cmd, '>'); \
if(!end) break; \
cmds = strchr(cmd, '<'); \
size_t len = strcspn(cmd, ":,><"); \
loopi(4) \
{ \
arg[i] = strchr(i ? arg[i-1] : cmd, i ? ',' : ':'); \
if(!arg[i] || arg[i] >= end) arg[i] = ""; \
else arg[i]++; \
}
#define COPYTEXARG(dst, src) copystring(dst, stringslice(src, strcspn(src, ":,><")))
PARSETEXCOMMANDS(pcmds);
if(matchstring(cmd, len, "dds")) dds = true;
else if(matchstring(cmd, len, "thumbnail")) raw = true;
else if(matchstring(cmd, len, "stub")) return canloadsurface(file);
}
if(msg) renderprogress(loadprogress, file);
int flen = strlen(file);
if(flen >= 4 && (!strcasecmp(file + flen - 4, ".dds") || (dds && !raw)))
{
string dfile;
copystring(dfile, file);
memcpy(dfile + flen - 4, ".dds", 4);
if(!loaddds(dfile, d, raw ? 1 : (dds ? 0 : -1)) && (!dds || raw))
{
if(msg) conoutf(CON_ERROR, "could not load texture %s", dfile);
return false;
}
if(d.data && !d.compressed && !dds && compress) *compress = scaledds;
}
if(!d.data)
{
SDL_Surface *s = loadsurface(file);
if(!s) { if(msg) conoutf(CON_ERROR, "could not load texture %s", file); return false; }
int bpp = s->format->BitsPerPixel;
if(bpp%8 || !texformat(bpp/8)) { SDL_FreeSurface(s); conoutf(CON_ERROR, "texture must be 8, 16, 24, or 32 bpp: %s", file); return false; }
if(max(s->w, s->h) > (1<<12)) { SDL_FreeSurface(s); conoutf(CON_ERROR, "texture size exceeded %dx%d pixels: %s", 1<<12, 1<<12, file); return false; }
d.wrap(s);
}
while(cmds)
{
PARSETEXCOMMANDS(cmds);
if(d.compressed) goto compressed;
if(matchstring(cmd, len, "mad")) texmad(d, parsevec(arg[0]), parsevec(arg[1]));
else if(matchstring(cmd, len, "colorify")) texcolorify(d, parsevec(arg[0]), parsevec(arg[1]));
else if(matchstring(cmd, len, "colormask")) texcolormask(d, parsevec(arg[0]), *arg[1] ? parsevec(arg[1]) : vec(1, 1, 1));
else if(matchstring(cmd, len, "normal"))
{
int emphasis = atoi(arg[0]);
texnormal(d, emphasis > 0 ? emphasis : 3);
}
else if(matchstring(cmd, len, "dup")) texdup(d, atoi(arg[0]), atoi(arg[1]));
else if(matchstring(cmd, len, "offset")) texoffset(d, atoi(arg[0]), atoi(arg[1]));
else if(matchstring(cmd, len, "rotate")) texrotate(d, atoi(arg[0]), ttype);
else if(matchstring(cmd, len, "reorient")) texreorient(d, atoi(arg[0])>0, atoi(arg[1])>0, atoi(arg[2])>0, ttype);
else if(matchstring(cmd, len, "crop")) texcrop(d, atoi(arg[0]), atoi(arg[1]), *arg[2] ? atoi(arg[2]) : -1, *arg[3] ? atoi(arg[3]) : -1);
else if(matchstring(cmd, len, "mix")) texmix(d, *arg[0] ? atoi(arg[0]) : -1, *arg[1] ? atoi(arg[1]) : -1, *arg[2] ? atoi(arg[2]) : -1, *arg[3] ? atoi(arg[3]) : -1);
else if(matchstring(cmd, len, "grey")) texgrey(d);
else if(matchstring(cmd, len, "blur"))
{
int emphasis = atoi(arg[0]), repeat = atoi(arg[1]);
texblur(d, emphasis > 0 ? std::clamp(emphasis, 1, 2) : 1, repeat > 0 ? repeat : 1);
}
else if(matchstring(cmd, len, "premul")) texpremul(d);
else if(matchstring(cmd, len, "agrad")) texagrad(d, atof(arg[0]), atof(arg[1]), atof(arg[2]), atof(arg[3]));
else if(matchstring(cmd, len, "blend"))
{
ImageData src, mask;
string srcname, maskname;
COPYTEXARG(srcname, arg[0]);
COPYTEXARG(maskname, arg[1]);
if(srcname[0] && texturedata(src, srcname, false, nullptr, nullptr, tdir, ttype) && (!maskname[0] || texturedata(mask, maskname, false, nullptr, nullptr, tdir, ttype)))
texblend(d, src, maskname[0] ? mask : src);
}
else if(matchstring(cmd, len, "thumbnail"))
{
int w = atoi(arg[0]), h = atoi(arg[1]);
if(w <= 0 || w > (1<<12)) w = 64;
if(h <= 0 || h > (1<<12)) h = w;
if(d.w > w || d.h > h) scaleimage(d, w, h);
}
else if(matchstring(cmd, len, "compress") || matchstring(cmd, len, "dds"))
{
int scale = atoi(arg[0]);
if(scale <= 0) scale = scaledds;
if(compress) *compress = scale;
}
else if(matchstring(cmd, len, "nocompress"))
{
if(compress) *compress = -1;
}
else
compressed:
if(matchstring(cmd, len, "mirror"))
{
if(wrap) *wrap |= 0x300;
}
else if(matchstring(cmd, len, "noswizzle"))
{
if(wrap) *wrap |= 0x10000;
}
}
return true;
}
static inline bool texturedata(ImageData &d, Slot &slot, Slot::Tex &tex, bool msg = true, int *compress = nullptr, int *wrap = nullptr)
{
return texturedata(d, tex.name, msg, compress, wrap, slot.texturedir(), tex.type);
}
uchar *loadalphamask(Texture *t)
{
if(t->alphamask) return t->alphamask;
if(!(t->type&Texture::ALPHA)) return nullptr;
ImageData s;
if(!texturedata(s, t->name, false) || !s.data || s.compressed) return nullptr;
t->alphamask = new uchar[s.h * ((s.w+7)/8)];
uchar *srcrow = s.data, *dst = t->alphamask-1;
loop(y, s.h)
{
uchar *src = srcrow+s.bpp-1;
loop(x, s.w)
{
int offset = x%8;
if(!offset) *++dst = 0;
if(*src) *dst |= 1<<offset;
src += s.bpp;
}
srcrow += s.pitch;
}
return t->alphamask;
}
Texture *textureload(const char *name, int clamp, bool mipit, bool msg)
{
string tname;
copystring(tname, name);
Texture *t = textures.access(path(tname));
if(t) return t;
int compress = 0;
ImageData s;
if(texturedata(s, tname, msg, &compress, &clamp)) return newtexture(nullptr, tname, s, clamp, mipit, false, false, compress);
return notexture;
}
bool settexture(const char *name, int clamp)
{
Texture *t = textureload(name, clamp, true, false);
glBindTexture(GL_TEXTURE_2D, t->id);
return t != notexture;
}
vector<VSlot *> vslots;
vector<Slot *> slots;
Slot dummyslot;
VSlot dummyvslot(&dummyslot);
DecalSlot dummydecalslot;
static MatSlot materialslots[(MATF_VOLUME|MATF_INDEX)+1];
static vector<DecalSlot *> decalslots;
static Slot *defslot = nullptr;
const char *Slot::name() const { return tempformatstring("slot %d", index); }
MatSlot::MatSlot() : Slot(int(this - materialslots)), VSlot(this) {}
const char *MatSlot::name() const { return tempformatstring("material slot %s", findmaterialname(Slot::index)); }
const char *DecalSlot::name() const { return tempformatstring("decal slot %d", Slot::index); }
static void texturereset(int *n)
{
if(!(identflags&IDF_OVERRIDDEN) && !game::allowedittoggle()) return;
defslot = nullptr;
resetslotshader();
int limit = std::clamp(*n, 0, slots.length());
for(int i = limit; i < slots.length(); i++)
{
Slot *s = slots[i];
for(VSlot *vs = s->variants; vs; vs = vs->next) vs->slot = &dummyslot;
delete s;
}
slots.setsize(limit);
while(vslots.length())
{
VSlot *vs = vslots.last();
if(vs->slot != &dummyslot || vs->changed) break;
delete vslots.pop();
}
}
COMMAND(texturereset, "i");
static void materialreset()
{
if(!(identflags&IDF_OVERRIDDEN) && !game::allowedittoggle()) return;
defslot = nullptr;
loopi((MATF_VOLUME|MATF_INDEX)+1) materialslots[i].reset();
}
COMMAND(materialreset, "");
static void decalreset(int *n)
{
if(!(identflags&IDF_OVERRIDDEN) && !game::allowedittoggle()) return;
defslot = nullptr;
resetslotshader();
decalslots.deletecontents(*n);
}
COMMAND(decalreset, "i");
static int compactedvslots = 0, compactvslotsprogress = 0, clonedvslots = 0;
static bool markingvslots = false;
void clearslots()
{
defslot = nullptr;
resetslotshader();
slots.deletecontents();
vslots.deletecontents();
loopi((MATF_VOLUME|MATF_INDEX)+1) materialslots[i].reset();
decalslots.deletecontents();
clonedvslots = 0;
}
static void assignvslot(VSlot &vs);
static inline void assignvslotlayer(VSlot &vs)
{
if(vs.layer && vslots.inrange(vs.layer) && vslots[vs.layer]->index < 0) assignvslot(*vslots[vs.layer]);
if(vs.detail && vslots.inrange(vs.detail) && vslots[vs.detail]->index < 0) assignvslot(*vslots[vs.detail]);
}
static void assignvslot(VSlot &vs)
{
vs.index = compactedvslots++;
assignvslotlayer(vs);
}
void compactvslot(int &index)
{
if(vslots.inrange(index))
{
VSlot &vs = *vslots[index];
if(vs.index < 0) assignvslot(vs);
if(!markingvslots) index = vs.index;
}
}
void compactvslot(VSlot &vs)
{
if(vs.index < 0) assignvslot(vs);
}
void compactvslots(cube *c, int n)
{
if((compactvslotsprogress++&0xFFF)==0) renderprogress(min(float(compactvslotsprogress)/allocnodes, 1.0f), markingvslots ? "marking slots..." : "compacting slots...");
loopi(n)
{
if(c[i].children) compactvslots(c[i].children);
else loopj(6) if(vslots.inrange(c[i].texture[j]))
{
VSlot &vs = *vslots[c[i].texture[j]];
if(vs.index < 0) assignvslot(vs);
if(!markingvslots) c[i].texture[j] = vs.index;
}
}
}
int compactvslots(bool cull)
{
defslot = nullptr;
clonedvslots = 0;
markingvslots = cull;
compactedvslots = 0;
compactvslotsprogress = 0;
loopv(vslots) vslots[i]->index = -1;
if(cull)
{
int numdefaults = min(int(NUMDEFAULTSLOTS), slots.length());
loopi(numdefaults) slots[i]->variants->index = compactedvslots++;
loopi(numdefaults) assignvslotlayer(*slots[i]->variants);
}
else
{
loopv(slots) slots[i]->variants->index = compactedvslots++;
loopv(slots) assignvslotlayer(*slots[i]->variants);
loopv(vslots)
{
VSlot &vs = *vslots[i];
if(!vs.changed && vs.index < 0) { markingvslots = true; break; }
}
}
compactvslots(worldroot);
int total = compactedvslots;
compacteditvslots();
loopv(vslots)
{
VSlot *vs = vslots[i];
if(vs->changed) continue;
while(vs->next)
{
if(vs->next->index < 0) vs->next = vs->next->next;
else vs = vs->next;
}
}
if(markingvslots)
{
markingvslots = false;
compactedvslots = 0;
compactvslotsprogress = 0;
int lastdiscard = 0;
loopv(vslots)
{
VSlot &vs = *vslots[i];
if(vs.changed || (vs.index < 0 && !vs.next)) vs.index = -1;
else
{
if(!cull) while(lastdiscard < i)
{
VSlot &ds = *vslots[lastdiscard++];
if(!ds.changed && ds.index < 0) ds.index = compactedvslots++;
}
vs.index = compactedvslots++;
}
}
compactvslots(worldroot);
total = compactedvslots;
compacteditvslots();
}
compactmruvslots();
loopv(vslots)
{
VSlot &vs = *vslots[i];
if(vs.index >= 0)
{
if(vs.layer && vslots.inrange(vs.layer)) vs.layer = vslots[vs.layer]->index;
if(vs.detail && vslots.inrange(vs.detail)) vs.detail = vslots[vs.detail]->index;
}
}
if(cull)
{
loopvrev(slots) if(slots[i]->variants->index < 0) delete slots.remove(i);
loopv(slots) slots[i]->index = i;
}
loopv(vslots)
{
while(vslots[i]->index >= 0 && vslots[i]->index != i)
swap(vslots[i], vslots[vslots[i]->index]);
}
for(int i = compactedvslots; i < vslots.length(); i++) delete vslots[i];
vslots.setsize(compactedvslots);
return total;
}
ICOMMAND(compactvslots, "i", (int *cull),
{
extern int nompedit;
if(nompedit && multiplayer()) return;
compactvslots(*cull!=0);
allchanged();
});
static void clampvslotoffset(VSlot &dst, Slot *slot = nullptr)
{
if(!slot) slot = dst.slot;
if(slot && slot->sts.inrange(0))
{
if(!slot->loaded) slot->load();
Texture *t = slot->sts[0].t;
int xs = t->xs, ys = t->ys;
if(t->type & Texture::MIRROR) { xs *= 2; ys *= 2; }
if(texrotations[dst.rotation].swapxy) swap(xs, ys);
dst.offset.x %= xs; if(dst.offset.x < 0) dst.offset.x += xs;
dst.offset.y %= ys; if(dst.offset.y < 0) dst.offset.y += ys;
}
else dst.offset.max(0);
}
static void propagatevslot(VSlot &dst, const VSlot &src, int diff, bool edit = false)
{
if(diff & (1<<VSLOT_SHPARAM)) loopv(src.params) dst.params.add(src.params[i]);
if(diff & (1<<VSLOT_SCALE)) dst.scale = src.scale;
if(diff & (1<<VSLOT_ROTATION))
{
dst.rotation = src.rotation;
if(edit && !dst.offset.iszero()) clampvslotoffset(dst);
}
if(diff & (1<<VSLOT_OFFSET))
{
dst.offset = src.offset;
if(edit) clampvslotoffset(dst);
}
if(diff & (1<<VSLOT_SCROLL)) dst.scroll = src.scroll;
if(diff & (1<<VSLOT_LAYER)) dst.layer = src.layer;
if(diff & (1<<VSLOT_ALPHA))
{
dst.alphafront = src.alphafront;
dst.alphaback = src.alphaback;
}
if(diff & (1<<VSLOT_COLOR)) dst.colorscale = src.colorscale;
if(diff & (1<<VSLOT_REFRACT))
{
dst.refractscale = src.refractscale;
dst.refractcolor = src.refractcolor;
}
if(diff & (1<<VSLOT_DETAIL)) dst.detail = src.detail;
}
static void propagatevslot(VSlot *root, int changed)
{
for(VSlot *vs = root->next; vs; vs = vs->next)
{
int diff = changed & ~vs->changed;
if(diff) propagatevslot(*vs, *root, diff);
}
}
static void mergevslot(VSlot &dst, const VSlot &src, int diff, Slot *slot = nullptr)
{
if(diff & (1<<VSLOT_SHPARAM)) loopv(src.params)
{
const SlotShaderParam &sp = src.params[i];
loopvj(dst.params)
{
SlotShaderParam &dp = dst.params[j];
if(sp.name == dp.name)
{
memcpy(dp.val, sp.val, sizeof(dp.val));
goto nextparam;
}
}
dst.params.add(sp);
nextparam:;
}
if(diff & (1<<VSLOT_SCALE))
{
dst.scale = std::clamp(dst.scale*src.scale, 1/8.0f, 8.0f);
}
if(diff & (1<<VSLOT_ROTATION))
{
dst.rotation = std::clamp(dst.rotation + src.rotation, 0, 7);
if(!dst.offset.iszero()) clampvslotoffset(dst, slot);
}
if(diff & (1<<VSLOT_OFFSET))
{
dst.offset.add(src.offset);
clampvslotoffset(dst, slot);
}
if(diff & (1<<VSLOT_SCROLL)) dst.scroll.add(src.scroll);
if(diff & (1<<VSLOT_LAYER)) dst.layer = src.layer;
if(diff & (1<<VSLOT_ALPHA))
{
dst.alphafront = src.alphafront;
dst.alphaback = src.alphaback;
}
if(diff & (1<<VSLOT_COLOR)) dst.colorscale.mul(src.colorscale);
if(diff & (1<<VSLOT_REFRACT))
{
dst.refractscale *= src.refractscale;
dst.refractcolor.mul(src.refractcolor);
}
if(diff & (1<<VSLOT_DETAIL)) dst.detail = src.detail;
}
void mergevslot(VSlot &dst, const VSlot &src, const VSlot &delta)
{
dst.changed = src.changed | delta.changed;
propagatevslot(dst, src, (1<<VSLOT_NUM)-1);
mergevslot(dst, delta, delta.changed, src.slot);
}
static VSlot *reassignvslot(Slot &owner, VSlot *vs)
{
vs->reset();
owner.variants = vs;
while(vs)
{
vs->slot = &owner;
vs->linked = false;
vs = vs->next;
}
return owner.variants;
}
static VSlot *emptyvslot(Slot &owner)
{
int offset = 0;
loopvrev(slots) if(slots[i]->variants) { offset = slots[i]->variants->index + 1; break; }
for(int i = offset; i < vslots.length(); i++) if(!vslots[i]->changed) return reassignvslot(owner, vslots[i]);
return vslots.add(new VSlot(&owner, vslots.length()));
}
VSlot &Slot::emptyvslot()
{
return *::emptyvslot(*this);
}
static bool comparevslot(const VSlot &dst, const VSlot &src, int diff)
{
if(diff & (1<<VSLOT_SHPARAM))
{
if(src.params.length() != dst.params.length()) return false;
loopv(src.params)
{
const SlotShaderParam &sp = src.params[i], &dp = dst.params[i];
if(sp.name != dp.name || memcmp(sp.val, dp.val, sizeof(sp.val))) return false;
}
}
if(diff & (1<<VSLOT_SCALE) && dst.scale != src.scale) return false;
if(diff & (1<<VSLOT_ROTATION) && dst.rotation != src.rotation) return false;
if(diff & (1<<VSLOT_OFFSET) && dst.offset != src.offset) return false;
if(diff & (1<<VSLOT_SCROLL) && dst.scroll != src.scroll) return false;
if(diff & (1<<VSLOT_LAYER) && dst.layer != src.layer) return false;
if(diff & (1<<VSLOT_ALPHA) && (dst.alphafront != src.alphafront || dst.alphaback != src.alphaback)) return false;
if(diff & (1<<VSLOT_COLOR) && dst.colorscale != src.colorscale) return false;
if(diff & (1<<VSLOT_REFRACT) && (dst.refractscale != src.refractscale || dst.refractcolor != src.refractcolor)) return false;
if(diff & (1<<VSLOT_DETAIL) && dst.detail != src.detail) return false;
return true;
}
void packvslot(vector<uchar> &buf, const VSlot &src)
{
if(src.changed & (1<<VSLOT_SHPARAM))
{
loopv(src.params)
{
const SlotShaderParam &p = src.params[i];
buf.put(VSLOT_SHPARAM);
sendstring(p.name, buf);
loopj(4) putfloat(buf, p.val[j]);
}
}
if(src.changed & (1<<VSLOT_SCALE))
{
buf.put(VSLOT_SCALE);
putfloat(buf, src.scale);
}
if(src.changed & (1<<VSLOT_ROTATION))
{
buf.put(VSLOT_ROTATION);
putint(buf, src.rotation);
}
if(src.changed & (1<<VSLOT_OFFSET))
{
buf.put(VSLOT_OFFSET);
putint(buf, src.offset.x);
putint(buf, src.offset.y);
}
if(src.changed & (1<<VSLOT_SCROLL))
{
buf.put(VSLOT_SCROLL);
putfloat(buf, src.scroll.x);
putfloat(buf, src.scroll.y);
}
if(src.changed & (1<<VSLOT_LAYER))
{
buf.put(VSLOT_LAYER);
putuint(buf, vslots.inrange(src.layer) && !vslots[src.layer]->changed ? src.layer : 0);
}
if(src.changed & (1<<VSLOT_ALPHA))
{
buf.put(VSLOT_ALPHA);
putfloat(buf, src.alphafront);
putfloat(buf, src.alphaback);
}
if(src.changed & (1<<VSLOT_COLOR))
{
buf.put(VSLOT_COLOR);
putfloat(buf, src.colorscale.r);
putfloat(buf, src.colorscale.g);
putfloat(buf, src.colorscale.b);
}
if(src.changed & (1<<VSLOT_REFRACT))
{
buf.put(VSLOT_REFRACT);
putfloat(buf, src.refractscale);
putfloat(buf, src.refractcolor.r);
putfloat(buf, src.refractcolor.g);
putfloat(buf, src.refractcolor.b);
}
if(src.changed & (1<<VSLOT_DETAIL))
{
buf.put(VSLOT_DETAIL);
putuint(buf, vslots.inrange(src.detail) && !vslots[src.detail]->changed ? src.detail : 0);
}
buf.put(0xFF);
}