Refator pass 1

src/display/texture.c

@@ -0,0 +1,184 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "texture.h"
+#include "assert/assert.h"
+#include "util/memory.h"
+#include "util/math.h"
+#include "display/palette/palettelist.h"
+
+const texture_t *TEXTURE_BOUND = NULL;
+
+void textureInit(
+  texture_t *texture,
+  const int32_t width,
+  const int32_t height,
+  const textureformat_t format,
+  const texturedata_t data
+) {
+  assertNotNull(texture, "Texture cannot be NULL");
+  assertTrue(width > 0 && height > 0, "width/height must be greater than 0");
+
+  memoryZero(texture, sizeof(texture_t));
+  texture->width = width;
+  texture->height = height;
+
+  #if PSP
+    assertTrue(
+      width == mathNextPowTwo(width),
+      "Width must be powers of 2 for PSP"
+    );
+    assertTrue(
+      height == mathNextPowTwo(height),
+      "Height must be powers of 2 for PSP"
+    );
+  #endif
+
+  #if DISPLAY_SDL2
+    glGenTextures(1, &texture->id);
+    glBindTexture(GL_TEXTURE_2D, texture->id);
+
+    switch(format) {
+      case TEXTURE_FORMAT_RGBA:
+        glTexImage2D(
+          GL_TEXTURE_2D, 0, format, width, height, 0,
+          format, GL_UNSIGNED_BYTE, (void*)data.rgba.colors
+        );
+        break;
+
+      case TEXTURE_FORMAT_ALPHA:
+        glTexImage2D(
+          GL_TEXTURE_2D, 0, format, width, height, 0,
+          format, GL_UNSIGNED_BYTE, (void*)data.alpha.data
+        );
+        break;
+
+      case TEXTURE_FORMAT_PALETTE:
+        assertNotNull(data.palette.data, "Palette texture data cannot be NULL");
+        assertTrue(
+          data.palette.palette < PALETTE_LIST_COUNT,
+          "Palette index out of range"
+        );
+
+        // Get and validate the palette.
+        const palette_t *pal = PALETTE_LIST[data.palette.palette];
+        assertNotNull(pal, "Palette cannot be NULL");
+        GLenum err = glGetError();
+        if (err != GL_NO_ERROR) {
+          assertUnreachable("GL Error before setting color table");
+        }
+
+        // Do we support paletted textures?
+        bool_t havePalTex = false;
+
+        #if PSP
+          havePalTex = true;
+        #else
+          GLint mask = 0;
+          glGetIntegerv(GL_CONTEXT_PROFILE_MASK, &mask);
+          if(mask & GL_CONTEXT_CORE_PROFILE_BIT) {
+            GLint n=0; glGetIntegerv(GL_NUM_EXTENSIONS, &n);
+            for (GLint i=0; i<n; ++i) {
+              const char* e = (const char*)glGetStringi(GL_EXTENSIONS, i);
+              if (e && strcmp(e, "GL_EXT_paletted_texture")==0) { havePalTex = true; break; }
+            }
+          } else {
+            const char* ext = (const char*)glGetString(GL_EXTENSIONS);
+            havePalTex = ext && strstr(ext, "GL_EXT_paletted_texture");
+          }
+        #endif
+
+        if(!havePalTex) {
+          // Not supported, convert to RGBA using lookup
+          color_t formatted[width * height];
+          for(int32_t i = 0; i < width * height; i++) {
+            uint8_t index = data.palette.data[i];
+            assertTrue(
+              index < pal->colorCount,
+              "Palette index out of range"
+            );
+            formatted[i] = pal->colors[index];
+          }
+          glTexImage2D(
+            GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0,
+            GL_RGBA, GL_UNSIGNED_BYTE, (void*)formatted
+          );
+        } else {
+          // Supported.
+          #if PSP
+            // PSP requires the color table itself to be a power of two
+            assertTrue(
+              pal->colorCount == mathNextPowTwo(pal->colorCount),
+              "Palette color count must be a power of 2 for PSP"
+            );
+          #endif
+
+          glTexImage2D(
+            GL_TEXTURE_2D,
+            0, GL_COLOR_INDEX8_EXT,
+            width, height,
+            0, GL_COLOR_INDEX8_EXT,
+            GL_UNSIGNED_BYTE, (void*)data.palette.data
+          );
+
+          glColorTableEXT(
+            GL_TEXTURE_2D, GL_RGBA, pal->colorCount, GL_RGBA,
+            GL_UNSIGNED_BYTE, (const void*)pal->colors
+          );
+        }
+
+        break;
+
+      default:
+        assertUnreachable("Unknown texture format");
+        break;
+    }
+
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    
+    glBindTexture(GL_TEXTURE_2D, 0);
+  #endif
+}
+
+void textureBind(const texture_t *texture) {
+  if(TEXTURE_BOUND == texture) return;
+
+  if(texture == NULL) {
+    #if DISPLAY_SDL2
+      glDisable(GL_TEXTURE_2D);
+    #endif
+    TEXTURE_BOUND = NULL;
+    return;
+  }
+
+  assertTrue(
+    texture->id != 0,
+    "Texture ID must not be 0"
+  );
+  assertTrue(
+    texture->width > 0 && texture->height > 0,
+    "Texture width and height must be greater than 0"
+  );
+
+  #if DISPLAY_SDL2
+    glEnable(GL_TEXTURE_2D);
+    glBindTexture(GL_TEXTURE_2D, texture->id);
+  #endif
+  TEXTURE_BOUND = texture;
+}
+
+void textureDispose(texture_t *texture) {
+  assertNotNull(texture, "Texture cannot be NULL");
+  assertTrue(texture->id != 0, "Texture ID must not be 0");
+
+  #if DISPLAY_SDL2
+    glDeleteTextures(1, &texture->id);
+  #endif
+}