john/prosperon
1
0
Fork 0
Code Issues Pull requests Actions Releases Activity
prosperon/source/engine/texture.c

516 lines
13 KiB
C
Raw Blame History

#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};
static inline void write_pixel(unsigned char *data, int idx, rgba color)
{
data[idx] = color.r;
data[idx+1] = color.g;
data[idx+2] = color.b;
data[idx+3] = color.a;
}
static inline rgba get_pixel(unsigned char *data, int idx)
{
rgba color;
color.r = data[idx];
color.g = data[idx+1];
color.b = data[idx+2];
color.a = data[idx+3];
return color;
}
static inline unsigned char c_clamp(float value) { return (unsigned char) fmaxf(0.0f, fminf(255.0f, roundf(value))); }
static inline rgba blend_colors(rgba a, rgba b)
{
float a_a = a.a / 255.0f;
float b_a = b.a / 255.0f;
float out_a = a_a + b_a * (1.0f - a_a);
rgba result;
if (out_a == 0.0f) {
result.r = result.g = result.b = result.a = 0;
return result;
}
// Use the c_clamp function to safely clamp the values within the range [0, 255]
result.r = c_clamp(((a.r * a_a) + (b.r * b_a * (1.0f - a_a))) / out_a);
result.g = c_clamp(((a.g * a_a) + (b.g * b_a * (1.0f - a_a))) / out_a);
result.b = c_clamp(((a.b * a_a) + (b.b * b_a * (1.0f - a_a))) / out_a);
result.a = c_clamp(out_a * 255.0f);
return result;
}
static inline rgba additive_blend(rgba a, rgba b) {
rgba result;
result.r = c_clamp(a.r + b.r);
result.g = c_clamp(a.g + b.g);
result.b = c_clamp(a.b + b.b);
result.a = c_clamp((a.a + b.a) * 0.5f); // Blend alpha channels evenly
return result;
}
static inline rgba subtractive_blend(rgba a, rgba b) {
rgba result;
result.r = c_clamp(a.r - b.r);
result.g = c_clamp(a.g - b.g);
result.b = c_clamp(a.b - b.b);
result.a = c_clamp((a.a + b.a) * 0.5f); // Blend alpha channels evenly
return result;
}
static inline rgba multiplicative_blend(rgba a, rgba b) {
rgba result;
result.r = c_clamp((a.r * b.r) / 255.0f);
result.g = c_clamp((a.g * b.g) / 255.0f);
result.b = c_clamp((a.b * b.b) / 255.0f);
result.a = c_clamp((a.a + b.a) * 0.5f); // Blend alpha channels evenly
return result;
}
static inline rgba dodge_blend(rgba a, rgba b) {
rgba result;
result.r = c_clamp(a.r == 255 ? 255 : (b.r * 255) / (255 - a.r));
result.g = c_clamp(a.g == 255 ? 255 : (b.g * 255) / (255 - a.g));
result.b = c_clamp(a.b == 255 ? 255 : (b.b * 255) / (255 - a.b));
result.a = c_clamp((a.a + b.a) * 0.5f); // Blend alpha channels evenly
return result;
}
static inline rgba burn_blend(rgba a, rgba b) {
rgba result;
result.r = c_clamp(a.r == 0 ? 0 : 255 - ((255 - b.r) * 255) / a.r);
result.g = c_clamp(a.g == 0 ? 0 : 255 - ((255 - b.g) * 255) / a.g);
result.b = c_clamp(a.b == 0 ? 0 : 255 - ((255 - b.b) * 255) / a.b);
result.a = c_clamp((a.a + b.a) * 0.5f); // Blend alpha channels evenly
return result;
}
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;
}
void texture_offload(texture *tex)
{
if (tex->data) {
free(tex->data);
tex->data = NULL;
}
}
/* 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) {
free(tex);
return NULL;
}
tex->data = data;
texture_load_gpu(tex);
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);
if (tex->simgui.id)
simgui_destroy_image(tex->simgui);
free(tex);
}
struct texture *texture_empty(int w, int h)
{
int n = 4;
texture *tex = calloc(1,sizeof(*tex));
tex->data = calloc(w*h*n, sizeof(unsigned char));
tex->width = w;
tex->height = h;
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) {
free(tex);
return NULL;
}
tex->data = data;
texture_load_gpu(tex);
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)
{
if (!tex->data) return;
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);
}
// copy texture src to dest
// sx and sy are the destination coordinates to copy to
// sw the width of the destination to take in pixels
// sh the height of the destination to take in pixels
int texture_blit(texture *dst, texture *src, rect dstrect, rect srcrect, int tile) {
// if (!src || !dst || !src->data || !dst->data) return 0;
float scaleX = srcrect.w / dstrect.w;
float scaleY = srcrect.h / dstrect.h;
/* if (srcrect.x < 0 || srcrect.y < 0 || srcrect.x + srcrect.w > src->width ||
dstrect.x < 0 || dstrect.y < 0 || dstrect.x + dstrect.w > dst->width ||
srcrect.y + srcrect.h > src->height || dstrect.y + dstrect.h > dst->height) {
return false; // Rectangles exceed texture bounds
}*/
for (int dstY = 0; dstY < dstrect.h; ++dstY) {
for (int dstX = 0; dstX < dstrect.w; ++dstX) {
int srcX;
int srcY;
if (tile) {
srcX = srcrect.x + (dstX % (int)srcrect.w);
srcY = srcrect.y + (dstY % (int)srcrect.h);
} else {
srcX = srcrect.x + (int)(dstX * scaleX);
srcY = srcrect.y + (int)(dstY * scaleY);
}
int srcIndex = (srcY * src->width + srcX) * 4;
int dstIndex = ((dstrect.y + dstY) * dst->width + (dstrect.x + dstX)) * 4;
rgba srccolor = get_pixel(src->data, srcIndex);
rgba dstcolor = get_pixel(dst->data, dstIndex);
rgba color = blend_colors(srccolor, dstcolor);
write_pixel(dst->data, dstIndex, color);
}
}
return 1;
}
int texture_fill_rect(texture *tex, struct rect rect, struct rgba color)
{
if (!tex || !tex->data) return 0;
int x_end = rect.x+rect.w;
int y_end = rect.y+rect.h;
if (rect.x < 0 || rect.y < 0 || x_end > tex->width || y_end > tex->height) return 0;
for (int j = rect.y; j < y_end; ++j)
for (int i = rect.x; i < x_end; ++i) {
int index = (j*tex->width+i)*4;
write_pixel(tex->data, index, color);
}
return 1;
}
void swap_pixels(unsigned char *p1, unsigned char *p2) {
for (int i = 0; i < 4; ++i) {
unsigned char tmp = p1[i];
p1[i] = p2[i];
p2[i] = tmp;
}
}
texture *texture_scale(texture *tex, int width, int height)
{
texture *new = calloc(1, sizeof(*new));
new->width = width;
new->height = height;
new->data = malloc(4*width*height);
stbir_resize_uint8_linear(tex->data, tex->width, tex->height, 0, new->data, width, height, 0, 4);
return new;
}
int texture_flip(texture *tex, int y)
{
if (!tex || !tex->data) return -1;
int width = tex->width;
int height = tex->height;
if (y) {
for (int row = 0; row < height / 2; ++row) {
for (int col = 0; col < width; ++col) {
unsigned char *top = tex->data+((row*width+col)*4);
unsigned char *bottom = tex->data+(((height-row-1)*width+col)*4);
swap_pixels(top,bottom);
}
}
} else {
for (int row = 0; row < height; ++row) {
for (int col = 0; col < width / 2; ++col) {
unsigned char *left = tex->data+((row*width+col)*4);
unsigned char *right = tex->data+((row*width+(width-col-1))*4);
swap_pixels(left,right);
}
}
}
return 0;
}
int texture_write_pixel(texture *tex, int x, int y, rgba color)
{
if (x < 0 || x >= tex->width || y < 0 || y >= tex->height) return 0;
int i = (y * tex->width + x) * 4;
write_pixel(tex->data, i, color);
return 1;
}
texture *texture_dup(texture *tex)
{
texture *new = calloc(1, sizeof(*new));
*new = *tex;
new->data = malloc(new->width*new->height*4);
memcpy(new->data, tex->data, new->width*new->height*4*sizeof(new->data));
return new;
}
sg_image_data tex_img_data(texture *tex, int mipmaps)
{
if (!mipmaps) {
sg_image_data sg_img_data = {0};
sg_img_data.subimage[0][0] = (sg_range) {.ptr = tex->data, .size = tex->width*tex->height*4};
return sg_img_data;
}
sg_image_data sg_img_data = {0};
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 = tex->data, .size = mipw*miph*4 };
unsigned char *mipdata[mips];
mipdata[0] = tex->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 };
tex->vram += w*h*4;
mipw = w;
miph = h;
}
}
int texture_fill(texture *tex, struct rgba color)
{
if (!tex || !tex->data) return 0; // Ensure valid texture and pixel data
// Loop through every pixel in the texture
for (int y = 0; y < tex->height; ++y) {
for (int x = 0; x < tex->width; ++x) {
int index = (y * tex->width + x) * 4;
write_pixel(tex->data, index, color);
}
}
return 1;
}
void texture_load_gpu(texture *tex)
{
if (!tex->data) return;
if (tex->id.id == 0) {
// Doesn't exist, so make a new one
sg_image_data img_data = tex_img_data(tex, 0);
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 = img_data
});
} else {
// Simple update
sg_image_data img_data = tex_img_data(tex,0);
sg_update_image(tex->id, &img_data);
}
}
Reference in a new issue View git blame Copy permalink