improved texture handling; noise functions

source/engine/jsffi.c

@@ -46,6 +46,9 @@
 #include "timer.h"
 #include <sys/resource.h>
 
+#define STB_PERLIN_IMPLEMENTATION
+#include "stb_perlin.h"
+
 #if (defined(_WIN32) || defined(__WIN32__))
 #include <direct.h>
 #define mkdir(x,y) _mkdir(x)
@@ -2649,7 +2652,8 @@ JSC_SCALL(texture_save, texture_save(js2texture(self), str));
 
 JSC_CCALL(texture_blit,
   texture *tex = js2texture(self);
-  texture_blit(js2texture(self), js2texture(argv[0]), js2number(argv[1]), js2number(argv[2]), js2number(argv[3]), js2number(argv[4])))
+  texture_blit(js2texture(self), js2texture(argv[0]), js2rect(argv[1]), js2rect(argv[2]), js2boolean(argv[3]));
+)
 
 JSC_CCALL(texture_getid,
   texture *tex = js2texture(self);
@@ -3155,7 +3159,7 @@ JSC_SCALL(os_texture_swap,
 )
 
 JSC_CCALL(os_make_tex_data,
-  ret = texture2js(texture_empty(js2number(argv[0]), js2number(argv[1]), js2number(argv[2])))
+  ret = texture2js(texture_empty(js2number(argv[0]), js2number(argv[1])))
 )
 
 JSC_CCALL(os_make_font,
@@ -3395,7 +3399,32 @@ JSC_CCALL(os_rectpack,
   }
 )
 
+JSC_CCALL(os_perlin,
+  HMM_Vec3 coord = js2vec3(argv[0]);
+  HMM_Vec3 wrap = js2vec3(argv[2]);
+  return number2js(stb_perlin_noise3_seed(coord.x, coord.y, coord.z, wrap.x, wrap.y, wrap.z, js2number(argv[1])));
+)
+
+JSC_CCALL(os_ridge,
+  HMM_Vec3 c = js2vec3(argv[0]);
+  return number2js(stb_perlin_ridge_noise3(c.x, c.y, c.z, js2number(argv[1]), js2number(argv[2]), js2number(argv[3]), js2number(argv[4])));
+)
+
+JSC_CCALL(os_fbm,
+  HMM_Vec3 c = js2vec3(argv[0]);
+  return number2js(stb_perlin_fbm_noise3(c.x, c.y, c.z, js2number(argv[1]), js2number(argv[2]), js2number(argv[3])));
+)
+
+JSC_CCALL(os_turbulence,
+  HMM_Vec3 c = js2vec3(argv[0]);
+  return number2js(stb_perlin_turbulence_noise3(c.x, c.y, c.z, js2number(argv[1]), js2number(argv[2]), js2number(argv[3])));  
+)
+
 static const JSCFunctionListEntry js_os_funcs[] = {
+  MIST_FUNC_DEF(os, turbulence, 4),
+  MIST_FUNC_DEF(os, fbm, 4),
+  MIST_FUNC_DEF(os, ridge, 5),
+  MIST_FUNC_DEF(os, perlin, 3),
   MIST_FUNC_DEF(os, rectpack, 3),
   MIST_FUNC_DEF(os, cwd, 0),
   MIST_FUNC_DEF(os, rusage, 0),

source/engine/texture.c

@@ -21,6 +21,103 @@
 
 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--;
@@ -60,6 +157,14 @@ int mip_wh(int w, int h, int *mw, int *mh, int lvl)
   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;
@@ -113,56 +218,14 @@ struct texture *texture_from_file(const char *path) {
   }
   free(raw);
 
-  if (data == NULL)
+  if (data == NULL) {
+    free(tex);
     return NULL;
-  
-  tex->data = data;
-  tex->vram = tex->width*tex->height*4;
-  
-  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 };
-    tex->vram += w*h*4;
-    
-    mipw = w;
-    miph = h;
   }
 
-  tex->id = sg_make_image(&(sg_image_desc){
+  tex->data = data;
-    .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++)
+  texture_load_gpu(tex);
-    free(mipdata[i]);
-
-  free(tex->data);
-  tex->data = NULL;
     
   return tex;
 }
@@ -179,23 +242,14 @@ void texture_free(texture *tex)
   free(tex);
 }
 
-struct texture *texture_empty(int w, int h, int n)
+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;
-  sg_image_data sgdata;
+  texture_load_gpu(tex);
-  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;
 }
 
@@ -206,52 +260,14 @@ struct texture *texture_fromdata(void *raw, long size)
   int n;
   void *data = stbi_load_from_memory(raw, size, &tex->width, &tex->height, &n, 4);
 
-  if (data == NULL)
+  if (data == NULL) {
-    NULL;
+    free(tex);
-
+    return NULL;
-  unsigned int nw = next_pow2(tex->width);
+  }
-  unsigned int nh = next_pow2(tex->height);
 
   tex->data = data;
 
-  sg_image_data sg_img_data;
+  texture_load_gpu(tex);
-  
-  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;
 }
@@ -301,105 +317,182 @@ void texture_save(texture *tex, const char *file)
     stbi_write_jpg(file, tex->width, tex->height, 4, tex->data, 5);
 }
 
-// all coordinates start at bottom left
+// copy texture src to dest
-// src and dest, width, height are pixel buffers and their widths and heights
+// sx and sy are the destination coordinates to copy to
-// sx the x coordinate of the destination to copy to
-// sy the y coordinate of the destination to copy to
 // sw the width of the destination to take in pixels
 // sh the height of the destination to take in pixels
-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) {
+int texture_blit(texture *src, texture *dst, rect srcrect, rect dstrect, int tile) {
-//  if (sx + sw > dest_width) return;
+  if (!src || !dst || !src->data || !dst->data) return 0;
-//  if (sy + sh > dest_height) return;
 
-  for (int x = 0; x < sw; x++) {
+  float scaleX = srcrect.w / dstrect.w;
-    for (int y = 0; y < sh; y++) {
+  float scaleY = srcrect.h / dstrect.h;
-      int src_index = ((y * src_width) + x ) * 4;
-      int dest_index = ((y + sy) * dest_width) + (x + sx);
-      dest_index *= 4;
 
-      // Calculate the alpha value for the source pixel
+  if (srcrect.x < 0 || srcrect.y < 0 || srcrect.x + srcrect.w > src->width ||
-      uint8_t src_alpha = src[src_index + 3];
+    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
+  }
 
-      // Calculate the alpha value for the destination pixel
+  for (int dstY = 0; dstY < dstrect.h; ++dstY) {
-      uint8_t dest_alpha = dest[dest_index + 3];
+    for (int dstX = 0; dstX < dstrect.w; ++dstX) {
+      int srcX;
+      int srcY;
       
-      // Calculate the resulting alpha value
+      if (tile) {
-      uint8_t result_alpha = src_alpha + (255 - src_alpha) * dest_alpha / 255;
+        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);
+      }
       
-      // Calculate the resulting RGB values
+      int srcIndex = (srcY * src->width + srcX) * 4;
-      uint8_t result_red = (src[src_index + 0] * src_alpha + dest[dest_index + 0] * (255 - src_alpha) * dest_alpha / 255) / result_alpha;
+      int dstIndex = ((dstrect.y + dstY) * dst->width + (dstrect.x + dstX)) * 4;
-      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
+      rgba srccolor = get_pixel(src->data, srcIndex);
-      dest[dest_index + 0] = result_red;
+      rgba dstcolor = get_pixel(dst->data, dstIndex);
-      dest[dest_index + 1] = result_green;
+      write_pixel(dst->data, dstIndex, blend_colors(srccolor, dstcolor));
-      dest[dest_index + 2] = result_blue;
-      dest[dest_index + 3] = result_alpha;
     }
   }
+
+  return 1;
+}
+
+int texture_fill_rect(texture *tex, int x, int y, int w, int h, struct rgba color)
+{
+  if (!tex || !tex->data) return 0;
+
+  int x_end = x+w;
+  int y_end = y+h;
+
+  if (x < 0 || y < 0 || x_end > tex->width || y_end > tex->height) return 0;
+
+  for (int j = y; j < y_end; ++j)
+    for (int i = x; i < x_end; ++i)
+      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;
+  }
 }
 
-// Function to draw source image pixels on top of a destination image
+texture *texture_scale(texture *tex, int width, int height)
-// x,y are the pixel coordinates in the destination image, w,h are the amount of pixels to take from the src image.
-void texture_blit(texture *dest, texture *src, int x, int y, int w, int h) {
-  if (!dest->data || !src->data) return;
-  blit_image(src->data, dest->data, src->width, src->height, dest->width, dest->height, x, y, w, h);
-}
-
-void texture_flip(texture *tex, int y)
 {
+  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;
 }
 
-static int p[512] = {151,160,137,91,90,15,
+int texture_flip(texture *tex, int y)
-   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;
+  if (!tex || !tex->data) return -1;
-  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   ), 
+  int width = tex->width;
-                                     grad(p[BA  ], x-1, y  , z   )),
+  int height = tex->height;
-                             lerp(u, grad(p[AB  ], x  , y-1, z   ), 
+
-                                     grad(p[BB  ], x-1, y-1, z   ))),
+  if (y) {
-                     lerp(v, lerp(u, grad(p[AA+1], x  , y  , z-1 ), 
+    for (int row = 0; row < height / 2; ++row) {
-                                     grad(p[BA+1], x-1, y  , z-1 )), 
+      for (int col = 0; col < width; ++col) {
-                             lerp(u, grad(p[AB+1], x  , y-1, z-1 ),
+        unsigned char *top = &tex->data[(row*width+col)*4];
-                                     grad(p[BB+1], x-1, y-1, z-1 ))));  
+        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;
+  }
+}
+
+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);
+  }
 }

source/engine/texture.h

@@ -43,13 +43,20 @@ typedef struct img_sampler{
 } img_sampler;
 
 texture *texture_from_file(const char *path);
+texture *texture_fromdata(void *raw, long size);
+texture *texture_empty(int width, int height); // Make an empty texture
+texture *texture_dup(texture *tex); // return an identical texture
+texture *texture_scale(texture *tex, int width, int height); // dup and scale the texture
+
 void texture_free(texture *tex);
-struct texture *texture_fromdata(void *raw, long size);
+void texture_offload(texture *tex); // Remove the data from this texture
-texture *texture_empty(int width, int height, int n);
+void texture_load_gpu(texture *tex); // Upload this data to the GPU if it isn't already there. Replace it if it is.
-void texture_blit(texture *dest, texture *src, int x, int y, int w, int h);
+
-void texture_flip(texture *tex, int y);
+int texture_write_pixel(texture *tex, int x, int y, struct rgba color);
+int texture_fill_rect(texture *tex, int x, int y, int w, int h, struct rgba color);
+int texture_blit(texture *dst, texture *src, struct rect dstrect, struct rect srcrect, int tile); // copies src into dst, using their respective squares, scaling if necessary
+int texture_flip(texture *tex, int y);
+
 void texture_save(texture *tex, const char *file); // save the texture data to the given file
 
-double perlin(double x, double y, double z);
-
 #endif