prosperon/source/engine/texture.c

408 lines
8.6 KiB
C

#include "texture.h"
#include "log.h"
#include "render.h"
#include "sokol/sokol_gfx.h"
#include <math.h>
#include <stb_ds.h>
#include <stb_image.h>
#include "gifdec.h"
#include "resources.h"
#define STB_IMAGE_RESIZE_IMPLEMENTATION
#include "stb_image_resize.h"
#include <stdio.h>
#define QOI_IMPLEMENTATION
#include "qoi.h"
struct glrect ST_UNIT = {0.f, 1.f, 0.f, 1.f};
static struct {
char *key;
struct Texture *value;
} *texhash = NULL;
struct Texture *tex_default;
struct Texture *texture_notex() {
return texture_pullfromfile("icons/no_tex.png");
}
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;
}
int gif_nframes(const char *path)
{
long rawlen;
unsigned char *raw = slurp_file(path, &rawlen);
char *ext = strrchr(path,'.');
int frames = 0; /* default here is also the error code */
FILE *f = fmemopen(raw, rawlen, "r");
gd_GIF *gif = gd_open_gif_f(f);
if (!gif) goto fin;
while (gd_get_frame(gif)) frames++;
fin:
gd_close_gif(gif);
free(raw);
return frames;
}
/* If an empty string or null is put for path, loads default texture */
struct Texture *texture_pullfromfile(const char *path) {
if (!path) return texture_notex();
int index = shgeti(texhash, path);
if (index != -1)
return texhash[index].value;
YughInfo("Loading texture %s.", path);
struct Texture *tex = calloc(1, sizeof(*tex));
tex->opts.sprite = 1;
tex->opts.mips = 0;
tex->opts.gamma = 0;
tex->opts.wrapx = 1;
tex->opts.wrapy = 1;
int n;
long rawlen;
unsigned char *raw = slurp_file(path, &rawlen);
unsigned char *data;
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")) {
FILE *f = fmemopen(raw, rawlen, "r");
gd_GIF *gif = gd_open_gif_f(f);
int frames = 0;
while (gd_get_frame(gif))
frames++;
gd_rewind(gif);
int frame = 0;
uint8_t gifbuf[gif->width*gif->height*3];
data = malloc(gif->width*gif->height*4*frames);
while (gd_get_frame(gif)) {
gd_render_frame(gif, gifbuf);
uint8_t black[4] = {0,0,0,0};
for (int p = 0; p < gif->height*gif->width; p++) {
int offset = (p*4)+(frame*gif->width*gif->height*4);
if (gd_is_bgcolor(gif, gifbuf+(p*3)))
memcpy(data+offset, black, 4*sizeof(uint8_t));
else {
memcpy(data+offset, gifbuf+(p*3), 3*sizeof(uint8_t));
data[offset+3] = 255;
}
}
frame++;
}
tex->width = gif->width;
tex->height = gif->height*frames;
gd_close_gif(gif);
fclose(f);
/*
int *delays;
int frames;
data = stbi_load_gif_from_memory(raw, rawlen, &delays, &tex->width, &tex->height, &frames, &n, 4);
*/
} else {
data = stbi_load_from_memory(raw, rawlen, &tex->width, &tex->height, &n, 4);
}
free(raw);
if (data == NULL) {
YughError("STBI failed to load file %s with message: %s\nOpening default instead.", path, stbi_failure_reason());
return texture_notex();
}
unsigned int nw = next_pow2(tex->width);
unsigned int nh = next_pow2(tex->height);
tex->data = data;
int filter;
if (tex->opts.sprite) {
filter = SG_FILTER_NEAREST;
} else {
filter = SG_FILTER_LINEAR;
}
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(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
});
if (shlen(texhash) == 0)
sh_new_arena(texhash);
shput(texhash, path, tex);
return tex;
}
void texture_sync(const char *path) {
YughWarn("Need to implement texture sync.");
}
char *tex_get_path(struct Texture *tex) {
for (int i = 0; i < shlen(texhash); i++) {
if (tex == texhash[i].value) {
YughInfo("Found key %s", texhash[i].key);
return texhash[i].key;
}
}
return "";
}
struct Texture *texture_loadfromfile(const char *path) {
struct Texture *new = texture_pullfromfile(path);
/*
if (new->id == 0) {
glGenTextures(1, &new->id);
//tex_gpu_load(new);
YughInfo("Loaded texture path %s", path);
}
*/
return new;
}
void tex_gpu_reload(struct Texture *tex) {
tex_gpu_free(tex);
// tex_gpu_load(tex);
}
void anim_calc(struct anim2d *anim) {
anim->size[0] = anim->anim->tex->width * st_s_w(anim->anim->st_frames[anim->frame]);
anim->size[1] = anim->anim->tex->height * st_s_h(anim->anim->st_frames[anim->frame]);
}
void anim_incr(struct anim2d *anim) {
anim->frame = (anim->frame + 1) % arrlen(anim->anim->st_frames);
if (!anim->anim->loop && anim->frame == arrlen(anim->anim->st_frames))
anim_pause(anim);
anim_calc(anim);
}
void anim_decr(struct anim2d *anim) {
anim->frame = (anim->frame + arrlen(anim->anim->st_frames) - 1) % arrlen(anim->anim->st_frames);
anim_calc(anim);
}
struct glrect anim_get_rect(struct anim2d *anim) {
return anim->anim->st_frames[anim->frame];
}
void anim_setframe(struct anim2d *anim, int frame) {
anim->frame = frame;
anim_calc(anim);
}
struct TexAnim *anim2d_from_tex(const char *path, int frames, int fps) {
struct TexAnim *anim = malloc(sizeof(*anim));
anim->tex = texture_loadfromfile(path);
texanim_fromframes(anim, frames);
anim->ms = (float)1 / fps;
return anim;
}
void texanim_fromframes(struct TexAnim *anim, int frames) {
if (anim->st_frames) {
free(anim->st_frames);
}
arrsetlen(anim->st_frames, frames);
float width = (float)1 / frames;
for (int i = 0; i < frames; i++) {
anim->st_frames[i].s0 = width * i;
anim->st_frames[i].s1 = width * (i + 1);
anim->st_frames[i].t0 = 0.f;
anim->st_frames[i].t1 = 1.f;
}
}
void tex_gpu_free(struct Texture *tex) {
/*
if (tex->id != 0) {
glDeleteTextures(1, &tex->id);
tex->id = 0;
}
*/
}
int anim_frames(struct TexAnim *a) {
return arrlen(a->st_frames);
}
struct glrect tex_get_rect(struct Texture *tex) {
return ST_UNIT;
}
cpVect tex_get_dimensions(struct Texture *tex) {
if (!tex) return cpvzero;
cpVect d;
d.x = tex->width;
d.y = tex->height;
return d;
}
void tex_bind(struct Texture *tex) {
/* glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, tex->id);
glBindTexture(GL_TEXTURE_2D_ARRAY, tex->id);
*/
}
/********************** ANIM2D ****************/
void anim_load(struct anim2d *anim, const char *path) {
anim->anim = &texture_pullfromfile(path)->anim;
anim->anim->tex->opts.animation = 1;
anim_stop(anim);
anim_play(anim);
}
void anim_play(struct anim2d *anim) {
if (anim->playing)
return;
if (anim->frame == anim_frames(anim->anim))
anim->frame = 0;
anim->playing = 1;
if (anim->timer == NULL)
anim->timer = id2timer(timer_make(1.f / anim->anim->ms, anim_incr, anim, 0, 0));
else
timerr_settime(anim->timer, 1.f / anim->anim->ms);
timer_start(anim->timer);
}
void anim_stop(struct anim2d *anim) {
if (!anim->playing)
return;
anim->playing = 0;
anim->frame = 0;
anim->pausetime = 0;
timer_stop(anim->timer);
}
void anim_pause(struct anim2d *anim) {
if (!anim->playing)
return;
anim->playing = 0;
timer_pause(anim->timer);
}
void anim_fwd(struct anim2d *anim) {
anim_incr(anim);
}
void anim_bkwd(struct anim2d *anim) {
anim_decr(anim);
}
float st_s_w(struct glrect st) {
return (st.s1 - st.s0);
}
float st_s_h(struct glrect st) {
return (st.t1 - st.t0);
}