392 lines
12 KiB
C
392 lines
12 KiB
C
#include "texture.h"
|
|
|
|
#include "log.h"
|
|
#include "render.h"
|
|
#include "sokol/sokol_gfx.h"
|
|
#include <math.h>
|
|
#include <stb_image.h>
|
|
#include <stb_image_write.h>
|
|
|
|
#include "resources.h"
|
|
|
|
#include "stb_image_resize2.h"
|
|
|
|
#include <stdio.h>
|
|
|
|
#include "qoi.h"
|
|
|
|
#ifndef NSVG
|
|
#include "nanosvgrast.h"
|
|
#endif
|
|
|
|
struct rect ST_UNIT = {0.f, 0.f, 1.f, 1.f};
|
|
|
|
unsigned int next_pow2(unsigned int v)
|
|
{
|
|
v--;
|
|
v |= v >> 1;
|
|
v |= v >> 2;
|
|
v |= v >> 4;
|
|
v |= v >> 8;
|
|
v |= v >> 16;
|
|
v++;
|
|
return v;
|
|
}
|
|
|
|
int mip_levels(int width, int height)
|
|
{
|
|
int levels = 0;
|
|
|
|
while (width > 1 || height > 1)
|
|
{
|
|
width >>= 1;
|
|
height >>= 1;
|
|
levels++;
|
|
}
|
|
return levels;
|
|
}
|
|
|
|
int mip_wh(int w, int h, int *mw, int *mh, int lvl)
|
|
{
|
|
w >>= lvl;
|
|
h >>= lvl;
|
|
|
|
if (w == 0 && h == 0)
|
|
return 1;
|
|
|
|
*mw = w ? w : 1;
|
|
*mh = h ? h : 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* If an empty string or null is put for path, loads default texture */
|
|
struct texture *texture_from_file(const char *path) {
|
|
if (!path) return NULL;
|
|
|
|
size_t rawlen;
|
|
unsigned char *raw = slurp_file(path, &rawlen);
|
|
|
|
if (!raw) return NULL;
|
|
|
|
unsigned char *data;
|
|
|
|
struct texture *tex = calloc(1, sizeof(*tex));
|
|
|
|
int n;
|
|
|
|
char *ext = strrchr(path, '.');
|
|
|
|
if (!strcmp(ext, ".qoi")) {
|
|
qoi_desc qoi;
|
|
data = qoi_decode(raw, rawlen, &qoi, 4);
|
|
tex->width = qoi.width;
|
|
tex->height = qoi.height;
|
|
n = qoi.channels;
|
|
} else if (!strcmp(ext, ".gif")) {
|
|
data = stbi_load_gif_from_memory(raw, rawlen, &tex->delays, &tex->width, &tex->height, &tex->frames, &n, 4);
|
|
int *dd = tex->delays;
|
|
tex->delays = NULL;
|
|
arrsetlen(tex->delays, tex->frames);
|
|
for (int i = 0; i < tex->frames; i++) tex->delays[i] = dd[i];
|
|
free(dd);
|
|
tex->height *= tex->frames;
|
|
} else if (!strcmp(ext, ".svg")) {
|
|
#ifndef NSVG
|
|
NSVGimage *svg = nsvgParse(raw, "px", 96);
|
|
struct NSVGrasterizer *rast = nsvgCreateRasterizer();
|
|
n=4;
|
|
tex->width=100;
|
|
tex->height=100;
|
|
float scale = tex->width/svg->width;
|
|
|
|
data = malloc(tex->width*tex->height*n);
|
|
nsvgRasterize(rast, svg, 0, 0, scale, data, tex->width, tex->height, tex->width*n);
|
|
free(svg);
|
|
free(rast);
|
|
#else
|
|
YughWarn("Prosperon was built without SVG capabilities.");
|
|
return;
|
|
#endif
|
|
} else {
|
|
data = stbi_load_from_memory(raw, rawlen, &tex->width, &tex->height, &n, 4);
|
|
}
|
|
free(raw);
|
|
|
|
if (data == NULL)
|
|
return NULL;
|
|
|
|
tex->data = data;
|
|
|
|
unsigned int nw = next_pow2(tex->width);
|
|
unsigned int nh = next_pow2(tex->height);
|
|
|
|
sg_image_data sg_img_data;
|
|
sg_img_data.subimage[0][0] = (sg_range){.ptr = data, .size=tex->width*tex->height*4};
|
|
|
|
int mips = mip_levels(tex->width, tex->height)+1;
|
|
|
|
int mipw, miph;
|
|
mipw = tex->width;
|
|
miph = tex->height;
|
|
|
|
sg_img_data.subimage[0][0] = (sg_range){ .ptr = data, .size = mipw*miph*4 };
|
|
|
|
unsigned char *mipdata[mips];
|
|
mipdata[0] = data;
|
|
|
|
for (int i = 1; i < mips; i++) {
|
|
int w, h, mipw, miph;
|
|
mip_wh(tex->width, tex->height, &mipw, &miph, i-1); // mipw miph are previous iteration
|
|
mip_wh(tex->width, tex->height, &w, &h, i);
|
|
mipdata[i] = malloc(w * h * 4);
|
|
stbir_resize_uint8_linear(mipdata[i-1], mipw, miph, 0, mipdata[i], w, h, 0, 4);
|
|
sg_img_data.subimage[0][i] = (sg_range){ .ptr = mipdata[i], .size = w*h*4 };
|
|
|
|
mipw = w;
|
|
miph = h;
|
|
}
|
|
|
|
tex->id = sg_make_image(&(sg_image_desc){
|
|
.type = SG_IMAGETYPE_2D,
|
|
.width = tex->width,
|
|
.height = tex->height,
|
|
.usage = SG_USAGE_IMMUTABLE,
|
|
.num_mipmaps = mips,
|
|
.data = sg_img_data
|
|
});
|
|
|
|
for (int i = 1; i < mips; i++)
|
|
free(mipdata[i]);
|
|
|
|
return tex;
|
|
}
|
|
|
|
void texture_free(texture *tex)
|
|
{
|
|
if (!tex) return;
|
|
if (tex->data)
|
|
free(tex->data);
|
|
if (tex->delays) arrfree(tex->delays);
|
|
sg_destroy_image(tex->id);
|
|
free(tex);
|
|
}
|
|
|
|
struct texture *texture_empty(int w, int h, int n)
|
|
{
|
|
texture *tex = calloc(1,sizeof(*tex));
|
|
tex->data = calloc(w*h*n, sizeof(unsigned char));
|
|
tex->width = w;
|
|
tex->height = h;
|
|
sg_image_data sgdata;
|
|
sgdata.subimage[0][0] = (sg_range){.ptr = tex->data, .size = w*h*4};
|
|
tex->id = sg_make_image(&(sg_image_desc){
|
|
.type = SG_IMAGETYPE_2D,
|
|
.width = tex->width,
|
|
.height = tex->height,
|
|
.usage = SG_USAGE_IMMUTABLE,
|
|
.num_mipmaps = 1,
|
|
.data = sgdata,
|
|
});
|
|
|
|
return tex;
|
|
}
|
|
|
|
struct texture *texture_fromdata(void *raw, long size)
|
|
{
|
|
struct texture *tex = calloc(1, sizeof(*tex));
|
|
|
|
int n;
|
|
void *data = stbi_load_from_memory(raw, size, &tex->width, &tex->height, &n, 4);
|
|
|
|
if (data == NULL)
|
|
NULL;
|
|
|
|
unsigned int nw = next_pow2(tex->width);
|
|
unsigned int nh = next_pow2(tex->height);
|
|
|
|
tex->data = data;
|
|
|
|
sg_image_data sg_img_data;
|
|
|
|
int mips = mip_levels(tex->width, tex->height)+1;
|
|
|
|
YughInfo("Has %d mip levels, from wxh %dx%d, pow2 is %ux%u.", mips, tex->width, tex->height,nw,nh);
|
|
|
|
int mipw, miph;
|
|
mipw = tex->width;
|
|
miph = tex->height;
|
|
|
|
sg_img_data.subimage[0][0] = (sg_range){ .ptr = data, .size = mipw*miph*4 };
|
|
|
|
unsigned char *mipdata[mips];
|
|
mipdata[0] = data;
|
|
|
|
for (int i = 1; i < mips; i++) {
|
|
int w, h, mipw, miph;
|
|
mip_wh(tex->width, tex->height, &mipw, &miph, i-1); /* mipw miph are previous iteration */
|
|
mip_wh(tex->width, tex->height, &w, &h, i);
|
|
mipdata[i] = malloc(w * h * 4);
|
|
stbir_resize_uint8_linear(mipdata[i-1], mipw, miph, 0, mipdata[i], w, h, 0, 4);
|
|
sg_img_data.subimage[0][i] = (sg_range){ .ptr = mipdata[i], .size = w*h*4 };
|
|
|
|
mipw = w;
|
|
miph = h;
|
|
}
|
|
|
|
tex->id = sg_make_image(&(sg_image_desc){
|
|
.type = SG_IMAGETYPE_2D,
|
|
.width = tex->width,
|
|
.height = tex->height,
|
|
.usage = SG_USAGE_IMMUTABLE,
|
|
.num_mipmaps = mips,
|
|
.data = sg_img_data
|
|
});
|
|
|
|
for (int i = 1; i < mips; i++)
|
|
free(mipdata[i]);
|
|
|
|
return tex;
|
|
}
|
|
|
|
static double fade (double t) { return t*t*t*(t*(t*6-15)+10); }
|
|
double grad (int hash, double x, double y, double z)
|
|
{
|
|
int h = hash&15;
|
|
double u = h<8 ? x : y;
|
|
double v = h<4 ? y : h==12||h==14 ? x : z;
|
|
return ((h&1) == 0 ? u : -u) + ((h&2) == 0 ? v : -v);
|
|
/* alt */
|
|
/* switch(hash & 0xF)
|
|
{
|
|
case 0x0: return x + y;
|
|
case 0x1: return -x + y;
|
|
case 0x2: return x - y;
|
|
case 0x3: return -x - y;
|
|
case 0x4: return x + z;
|
|
case 0x5: return -x + z;
|
|
case 0x6: return x - z;
|
|
case 0x7: return -x - z;
|
|
case 0x8: return y + z;
|
|
case 0x9: return -y + z;
|
|
case 0xA: return y - z;
|
|
case 0xB: return -y - z;
|
|
case 0xC: return y + x;
|
|
case 0xD: return -y + z;
|
|
case 0xE: return y - x;
|
|
case 0xF: return -y - z;
|
|
default: return 0; // never happens
|
|
}*/
|
|
}
|
|
|
|
void texture_save(texture *tex, const char *file)
|
|
{
|
|
char *ext = strrchr(file, '.');
|
|
if (!strcmp(ext, ".png"))
|
|
stbi_write_png(file, tex->width, tex->height, 4, tex->data, 4*tex->width);
|
|
else if (!strcmp(ext, ".bmp"))
|
|
stbi_write_bmp(file, tex->width, tex->height, 4, tex->data);
|
|
else if (!strcmp(ext, ".tga"))
|
|
stbi_write_tga(file, tex->width, tex->height, 4, tex->data);
|
|
else if (!strcmp(ext, ".jpg") || !strcmp(ext, ".jpeg"))
|
|
stbi_write_jpg(file, tex->width, tex->height, 4, tex->data, 5);
|
|
}
|
|
|
|
void blit_image(uint8_t* src, uint8_t* dest, int src_width, int src_height, int dest_width, int dest_height, int sx, int sy, int sw, int sh) {
|
|
if (sx + sw > dest_width) return;
|
|
if (sy + sh > dest_height) return;
|
|
int src_stride = src_width * 4;
|
|
int dest_stride = dest_width * 4;
|
|
|
|
for (int y = 0; y < sw; y++) {
|
|
for (int x = 0; x < sh; x++) {
|
|
int src_index = (y * src_stride) + (x * 4);
|
|
int dest_index = ((y + sy) * dest_stride) + ((x + sx) * 4);
|
|
|
|
// Calculate the alpha value for the source pixel
|
|
uint8_t src_alpha = src[src_index + 3];
|
|
|
|
// Calculate the alpha value for the destination pixel
|
|
uint8_t dest_alpha = dest[dest_index + 3];
|
|
|
|
// Calculate the resulting alpha value
|
|
uint8_t result_alpha = src_alpha + (255 - src_alpha) * dest_alpha / 255;
|
|
|
|
// Calculate the resulting RGB values
|
|
uint8_t result_red = (src[src_index + 0] * src_alpha + dest[dest_index + 0] * (255 - src_alpha) * dest_alpha / 255) / result_alpha;
|
|
uint8_t result_green = (src[src_index + 1] * src_alpha + dest[dest_index + 1] * (255 - src_alpha) * dest_alpha / 255) / result_alpha;
|
|
uint8_t result_blue = (src[src_index + 2] * src_alpha + dest[dest_index + 2] * (255 - src_alpha) * dest_alpha / 255) / result_alpha;
|
|
|
|
// Set the resulting pixel values
|
|
dest[dest_index + 0] = result_red;
|
|
dest[dest_index + 1] = result_green;
|
|
dest[dest_index + 2] = result_blue;
|
|
dest[dest_index + 3] = result_alpha;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
// Function to draw source image pixels on top of a destination image
|
|
void texture_blit(texture *dest, texture *src, int x, int y, int w, int h) {
|
|
blit_image(src->data, dest->data, src->width, src->height, dest->height, dest->width, x, y, w, h);
|
|
}
|
|
|
|
void texture_flip(texture *tex, int y)
|
|
{
|
|
|
|
}
|
|
|
|
static int p[512] = {151,160,137,91,90,15,
|
|
131,13,201,95,96,53,194,233,7,225,140,36,103,30,69,142,8,99,37,240,21,10,23,
|
|
190, 6,148,247,120,234,75,0,26,197,62,94,252,219,203,117,35,11,32,57,177,33,
|
|
88,237,149,56,87,174,20,125,136,171,168, 68,175,74,165,71,134,139,48,27,166,
|
|
77,146,158,231,83,111,229,122,60,211,133,230,220,105,92,41,55,46,245,40,244,
|
|
102,143,54, 65,25,63,161, 1,216,80,73,209,76,132,187,208, 89,18,169,200,196,
|
|
135,130,116,188,159,86,164,100,109,198,173,186, 3,64,52,217,226,250,124,123,
|
|
5,202,38,147,118,126,255,82,85,212,207,206,59,227,47,16,58,17,182,189,28,42,
|
|
223,183,170,213,119,248,152, 2,44,154,163, 70,221,153,101,155,167, 43,172,9,
|
|
129,22,39,253, 19,98,108,110,79,113,224,232,178,185, 112,104,218,246,97,228,
|
|
251,34,242,193,238,210,144,12,191,179,162,241, 81,51,145,235,249,14,239,107,
|
|
49,192,214, 31,181,199,106,157,184, 84,204,176,115,121,50,45,127, 4,150,254,
|
|
138,236,205,93,222,114,67,29,24,72,243,141,128,195,78,66,215,61,156,180,
|
|
151,160,137,91,90,15,
|
|
131,13,201,95,96,53,194,233,7,225,140,36,103,30,69,142,8,99,37,240,21,10,23,
|
|
190, 6,148,247,120,234,75,0,26,197,62,94,252,219,203,117,35,11,32,57,177,33,
|
|
88,237,149,56,87,174,20,125,136,171,168, 68,175,74,165,71,134,139,48,27,166,
|
|
77,146,158,231,83,111,229,122,60,211,133,230,220,105,92,41,55,46,245,40,244,
|
|
102,143,54, 65,25,63,161, 1,216,80,73,209,76,132,187,208, 89,18,169,200,196,
|
|
135,130,116,188,159,86,164,100,109,198,173,186, 3,64,52,217,226,250,124,123,
|
|
5,202,38,147,118,126,255,82,85,212,207,206,59,227,47,16,58,17,182,189,28,42,
|
|
223,183,170,213,119,248,152, 2,44,154,163, 70,221,153,101,155,167, 43,172,9,
|
|
129,22,39,253, 19,98,108,110,79,113,224,232,178,185, 112,104,218,246,97,228,
|
|
251,34,242,193,238,210,144,12,191,179,162,241, 81,51,145,235,249,14,239,107,
|
|
49,192,214, 31,181,199,106,157,184, 84,204,176,115,121,50,45,127, 4,150,254,
|
|
138,236,205,93,222,114,67,29,24,72,243,141,128,195,78,66,215,61,156,180
|
|
};
|
|
|
|
double perlin(double x, double y, double z)
|
|
{
|
|
int X = (int)floor(x)&255;
|
|
int Y = (int)floor(y)&255;
|
|
int Z = (int)floor(z)&255;
|
|
x -= floor(x);
|
|
y -= floor(y);
|
|
z -= floor(z);
|
|
double u = fade(x),
|
|
v = fade(y),
|
|
w = fade(z);
|
|
int A = p[X ]+Y, AA = p[A]+Z, AB = p[A+1]+Z,
|
|
B = p[X+1]+Y, BA = p[B]+Z, BB = p[B+1]+Z;
|
|
|
|
return lerp(w, lerp(v, lerp(u, grad(p[AA ], x , y , z ),
|
|
grad(p[BA ], x-1, y , z )),
|
|
lerp(u, grad(p[AB ], x , y-1, z ),
|
|
grad(p[BB ], x-1, y-1, z ))),
|
|
lerp(v, lerp(u, grad(p[AA+1], x , y , z-1 ),
|
|
grad(p[BA+1], x-1, y , z-1 )),
|
|
lerp(u, grad(p[AB+1], x , y-1, z-1 ),
|
|
grad(p[BB+1], x-1, y-1, z-1 ))));
|
|
}
|