static void cl_gecko_linktexture( clgecko_t *instance ) {
// TODO: assert that instance->texture == NULL
instance->texture = R_LoadTexture2D( cl_geckotexturepool, instance->name,
instance->texWidth, instance->texHeight, NULL, TEXTYPE_BGRA, TEXF_ALPHA | TEXF_PERSISTENT, -1, NULL );
R_MakeTextureDynamic( instance->texture, cl_gecko_updatecallback, instance );
CL_LinkDynTexture( instance->name, instance->texture );
}
//extern qboolean r_loadfog;
static void r_explosion_start(void)
{
int x, y;
static unsigned char noise1[128][128], noise2[128][128], noise3[128][128], data[128][128][4];
explosiontexturepool = R_AllocTexturePool();
explosiontexture = NULL;
//explosiontexturefog = NULL;
fractalnoise(&noise1[0][0], 128, 32);
fractalnoise(&noise2[0][0], 128, 4);
fractalnoise(&noise3[0][0], 128, 4);
for (y = 0;y < 128;y++)
{
for (x = 0;x < 128;x++)
{
int j, r, g, b, a;
j = (noise1[y][x] * noise2[y][x]) * 3 / 256 - 128;
r = (j * 512) / 256;
g = (j * 256) / 256;
b = (j * 128) / 256;
a = noise3[y][x] * 3 - 128;
data[y][x][2] = bound(0, r, 255);
data[y][x][1] = bound(0, g, 255);
data[y][x][0] = bound(0, b, 255);
data[y][x][3] = bound(0, a, 255);
}
}
explosiontexture = R_LoadTexture2D(explosiontexturepool, "explosiontexture", 128, 128, &data[0][0][0], TEXTYPE_BGRA, TEXF_MIPMAP | TEXF_ALPHA | TEXF_FORCELINEAR, -1, NULL);
// if (r_loadfog)
// {
// for (y = 0;y < 128;y++)
// for (x = 0;x < 128;x++)
// data[y][x][0] = data[y][x][1] = data[y][x][2] = 255;
// explosiontexturefog = R_LoadTexture2D(explosiontexturepool, "explosiontexture_fog", 128, 128, &data[0][0][0], TEXTYPE_BGRA, TEXF_MIPMAP | TEXF_ALPHA | TEXF_FORCELINEAR, NULL);
// }
// note that explosions survive the restart
}
static void r_lightningbeams_setuptexture(void)
{
#if 0
#define BEAMWIDTH 128
#define BEAMHEIGHT 64
#define PATHPOINTS 8
int i, j, px, py, nearestpathindex, imagenumber;
float particlex, particley, particlexv, particleyv, dx, dy, s, maxpathstrength;
unsigned char *pixels;
int *image;
struct lightningpathnode_s
{
float x, y, strength;
}
path[PATHPOINTS], temppath;
image = Mem_Alloc(tempmempool, BEAMWIDTH * BEAMHEIGHT * sizeof(int));
pixels = Mem_Alloc(tempmempool, BEAMWIDTH * BEAMHEIGHT * sizeof(unsigned char[4]));
for (imagenumber = 0, maxpathstrength = 0.0339476;maxpathstrength < 0.5;imagenumber++, maxpathstrength += 0.01)
{
for (i = 0;i < PATHPOINTS;i++)
{
path[i].x = lhrandom(0, 1);
path[i].y = lhrandom(0.2, 0.8);
path[i].strength = lhrandom(0, 1);
}
for (i = 0;i < PATHPOINTS;i++)
{
for (j = i + 1;j < PATHPOINTS;j++)
{
if (path[j].x < path[i].x)
{
temppath = path[j];
path[j] = path[i];
path[i] = temppath;
}
}
}
particlex = path[0].x;
particley = path[0].y;
particlexv = lhrandom(0, 0.02);
particlexv = lhrandom(-0.02, 0.02);
memset(image, 0, BEAMWIDTH * BEAMHEIGHT * sizeof(int));
for (i = 0;i < 65536;i++)
{
for (nearestpathindex = 0;nearestpathindex < PATHPOINTS;nearestpathindex++)
if (path[nearestpathindex].x > particlex)
break;
nearestpathindex %= PATHPOINTS;
dx = path[nearestpathindex].x + lhrandom(-0.01, 0.01);dx = bound(0, dx, 1) - particlex;if (dx < 0) dx += 1;
dy = path[nearestpathindex].y + lhrandom(-0.01, 0.01);dy = bound(0, dy, 1) - particley;
s = path[nearestpathindex].strength / sqrt(dx*dx+dy*dy);
particlexv = particlexv /* (1 - lhrandom(0.08, 0.12))*/ + dx * s;
particleyv = particleyv /* (1 - lhrandom(0.08, 0.12))*/ + dy * s;
particlex += particlexv * maxpathstrength;particlex -= (int) particlex;
particley += particleyv * maxpathstrength;particley = bound(0, particley, 1);
px = particlex * BEAMWIDTH;
py = particley * BEAMHEIGHT;
if (px >= 0 && py >= 0 && px < BEAMWIDTH && py < BEAMHEIGHT)
image[py*BEAMWIDTH+px] += 16;
}
for (py = 0;py < BEAMHEIGHT;py++)
{
for (px = 0;px < BEAMWIDTH;px++)
{
pixels[(py*BEAMWIDTH+px)*4+2] = bound(0, image[py*BEAMWIDTH+px] * 1.0f, 255.0f);
pixels[(py*BEAMWIDTH+px)*4+1] = bound(0, image[py*BEAMWIDTH+px] * 1.0f, 255.0f);
pixels[(py*BEAMWIDTH+px)*4+0] = bound(0, image[py*BEAMWIDTH+px] * 1.0f, 255.0f);
pixels[(py*BEAMWIDTH+px)*4+3] = 255;
}
}
Image_WriteTGABGRA(va(vabuf, sizeof(vabuf), "lightningbeam%i.tga", imagenumber), BEAMWIDTH, BEAMHEIGHT, pixels);
}
r_lightningbeamtexture = R_LoadTexture2D(r_lightningbeamtexturepool, "lightningbeam", BEAMWIDTH, BEAMHEIGHT, pixels, TEXTYPE_BGRA, TEXF_FORCELINEAR, NULL);
Mem_Free(pixels);
Mem_Free(image);
#else
#define BEAMWIDTH 64
#define BEAMHEIGHT 128
float r, g, b, intensity, fx, width, center;
int x, y;
unsigned char *data, *noise1, *noise2;
data = (unsigned char *)Mem_Alloc(tempmempool, BEAMWIDTH * BEAMHEIGHT * 4);
noise1 = (unsigned char *)Mem_Alloc(tempmempool, BEAMHEIGHT * BEAMHEIGHT);
noise2 = (unsigned char *)Mem_Alloc(tempmempool, BEAMHEIGHT * BEAMHEIGHT);
fractalnoise(noise1, BEAMHEIGHT, BEAMHEIGHT / 8);
fractalnoise(noise2, BEAMHEIGHT, BEAMHEIGHT / 16);
for (y = 0;y < BEAMHEIGHT;y++)
{
width = 0.15;//((noise1[y * BEAMHEIGHT] * (1.0f / 256.0f)) * 0.1f + 0.1f);
center = (noise1[y * BEAMHEIGHT + (BEAMHEIGHT / 2)] / 256.0f) * (1.0f - width * 2.0f) + width;
for (x = 0;x < BEAMWIDTH;x++, fx++)
{
fx = (((float) x / BEAMWIDTH) - center) / width;
intensity = 1.0f - sqrt(fx * fx);
if (intensity > 0)
intensity = pow(intensity, 2) * ((noise2[y * BEAMHEIGHT + x] * (1.0f / 256.0f)) * 0.33f + 0.66f);
intensity = bound(0, intensity, 1);
r = intensity * 1.0f;
g = intensity * 1.0f;
b = intensity * 1.0f;
data[(y * BEAMWIDTH + x) * 4 + 2] = (unsigned char)(bound(0, r, 1) * 255.0f);
data[(y * BEAMWIDTH + x) * 4 + 1] = (unsigned char)(bound(0, g, 1) * 255.0f);
data[(y * BEAMWIDTH + x) * 4 + 0] = (unsigned char)(bound(0, b, 1) * 255.0f);
data[(y * BEAMWIDTH + x) * 4 + 3] = (unsigned char)255;
}
}
r_lightningbeamtexture = R_SkinFrame_LoadInternalBGRA("lightningbeam", TEXF_FORCELINEAR, data, BEAMWIDTH, BEAMHEIGHT, false);
Mem_Free(noise1);
Mem_Free(noise2);
Mem_Free(data);
#endif
}
