- [WIP] Reestructuració: Fase 1 acabada

source/jshader.cpp

@@ -16,238 +16,241 @@
 #include <SDL3/SDL_opengl_glext.h>
 #endif
 
-namespace shader
+namespace mini
 {
-    SDL_Window *win = nullptr;
+    namespace shader
-    SDL_Renderer *renderer = nullptr;
-    GLuint programId = 0;
-    SDL_Texture* backBuffer = nullptr;
-    SDL_Point win_size = {640, 480};
-    SDL_FPoint tex_size = {320, 240};
-    bool can_use_opengl = false;
-    bool using_opengl = false;
-    GLuint texture_number;
-    GLuint nose;
-
-    #ifndef __APPLE__
-
-    // I'm avoiding the use of GLEW or some extensions handler, but that 
-    // doesn't mean you should...
-    PFNGLCREATESHADERPROC glCreateShader;
-    PFNGLSHADERSOURCEPROC glShaderSource;
-    PFNGLCOMPILESHADERPROC glCompileShader;
-    PFNGLGETSHADERIVPROC glGetShaderiv;
-    PFNGLGETSHADERINFOLOGPROC glGetShaderInfoLog;
-    PFNGLDELETESHADERPROC glDeleteShader;
-    PFNGLATTACHSHADERPROC glAttachShader;
-    PFNGLCREATEPROGRAMPROC glCreateProgram;
-    PFNGLDELETEPROGRAMPROC glDeleteProgram;
-    PFNGLLINKPROGRAMPROC glLinkProgram;
-    PFNGLVALIDATEPROGRAMPROC glValidateProgram;
-    PFNGLGETPROGRAMIVPROC glGetProgramiv;
-    PFNGLGETPROGRAMINFOLOGPROC glGetProgramInfoLog;
-    PFNGLUSEPROGRAMPROC glUseProgram;
-    PFNGLGETUNIFORMLOCATIONPROC glGetUniformLocation;
-    PFNGLACTIVETEXTUREPROC glActiveTexture;
-
-
-    bool initGLExtensions() {
-        glCreateShader = (PFNGLCREATESHADERPROC)SDL_GL_GetProcAddress("glCreateShader");
-        glShaderSource = (PFNGLSHADERSOURCEPROC)SDL_GL_GetProcAddress("glShaderSource");
-        glCompileShader = (PFNGLCOMPILESHADERPROC)SDL_GL_GetProcAddress("glCompileShader");
-        glGetShaderiv = (PFNGLGETSHADERIVPROC)SDL_GL_GetProcAddress("glGetShaderiv");
-        glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)SDL_GL_GetProcAddress("glGetShaderInfoLog");
-        glDeleteShader = (PFNGLDELETESHADERPROC)SDL_GL_GetProcAddress("glDeleteShader");
-        glAttachShader = (PFNGLATTACHSHADERPROC)SDL_GL_GetProcAddress("glAttachShader");
-        glCreateProgram = (PFNGLCREATEPROGRAMPROC)SDL_GL_GetProcAddress("glCreateProgram");
-        glDeleteProgram = (PFNGLDELETEPROGRAMPROC)SDL_GL_GetProcAddress("glDeleteProgram");
-        glLinkProgram = (PFNGLLINKPROGRAMPROC)SDL_GL_GetProcAddress("glLinkProgram");
-        glValidateProgram = (PFNGLVALIDATEPROGRAMPROC)SDL_GL_GetProcAddress("glValidateProgram");
-        glGetProgramiv = (PFNGLGETPROGRAMIVPROC)SDL_GL_GetProcAddress("glGetProgramiv");
-        glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)SDL_GL_GetProcAddress("glGetProgramInfoLog");
-        glUseProgram = (PFNGLUSEPROGRAMPROC)SDL_GL_GetProcAddress("glUseProgram");
-        glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)SDL_GL_GetProcAddress("glGetUniformLocation");
-        glActiveTexture = (PFNGLACTIVETEXTUREPROC)SDL_GL_GetProcAddress("glActiveTexture");
-
-        return glCreateShader && glShaderSource && glCompileShader && glGetShaderiv && 
-            glGetShaderInfoLog && glDeleteShader && glAttachShader && glCreateProgram &&
-            glDeleteProgram && glLinkProgram && glValidateProgram && glGetProgramiv &&
-            glGetProgramInfoLog && glUseProgram && glGetUniformLocation;
-    }
-
-    #endif
-
-    GLuint compileShader(const char* source, GLuint shaderType) {
-        // Create ID for shader
-        GLuint result = glCreateShader(shaderType);
-        // Add define depending on shader type
-        const char *sources[2] = { shaderType==GL_VERTEX_SHADER?"#define VERTEX\n":"#define FRAGMENT\n", source };
-        // Define shader text
-        glShaderSource(result, 2, sources, NULL);
-        // Compile shader
-        glCompileShader(result);
-
-        //Check vertex shader for errors
-        GLint shaderCompiled = GL_FALSE;
-        glGetShaderiv( result, GL_COMPILE_STATUS, &shaderCompiled );
-        if (shaderCompiled != GL_TRUE)
-        {
-            std::cout << "Error en la compilación: " << result << "!" << std::endl;
-            GLint logLength;
-            glGetShaderiv(result, GL_INFO_LOG_LENGTH, &logLength);
-            if (logLength > 0)
-            {
-                GLchar *log = (GLchar*)malloc(logLength);
-                glGetShaderInfoLog(result, logLength, &logLength, log);
-                std::cout << "Shader compile log:" << log << std::endl;
-                //std::cout << source << std::endl;
-                free(log);
-            }
-            glDeleteShader(result);
-            result = 0;
-        }
-        return result;
-    }
-
-    GLuint compileProgram(const char* vertexShaderSource, const char* fragmentShaderSource)
     {
+        SDL_Window *win = nullptr;
+        SDL_Renderer *renderer = nullptr;
         GLuint programId = 0;
-        GLuint vtxShaderId, fragShaderId;
+        SDL_Texture* backBuffer = nullptr;
+        SDL_Point win_size = {640, 480};
+        SDL_FPoint tex_size = {320, 240};
+        bool can_use_opengl = false;
+        bool using_opengl = false;
+        GLuint texture_number;
+        GLuint nose;
 
-        if (programId != 0) glDeleteProgram(programId);
+        #ifndef __APPLE__
-        programId = glCreateProgram();
+
+        // I'm avoiding the use of GLEW or some extensions handler, but that 
+        // doesn't mean you should...
+        PFNGLCREATESHADERPROC glCreateShader;
+        PFNGLSHADERSOURCEPROC glShaderSource;
+        PFNGLCOMPILESHADERPROC glCompileShader;
+        PFNGLGETSHADERIVPROC glGetShaderiv;
+        PFNGLGETSHADERINFOLOGPROC glGetShaderInfoLog;
+        PFNGLDELETESHADERPROC glDeleteShader;
+        PFNGLATTACHSHADERPROC glAttachShader;
+        PFNGLCREATEPROGRAMPROC glCreateProgram;
+        PFNGLDELETEPROGRAMPROC glDeleteProgram;
+        PFNGLLINKPROGRAMPROC glLinkProgram;
+        PFNGLVALIDATEPROGRAMPROC glValidateProgram;
+        PFNGLGETPROGRAMIVPROC glGetProgramiv;
+        PFNGLGETPROGRAMINFOLOGPROC glGetProgramInfoLog;
+        PFNGLUSEPROGRAMPROC glUseProgram;
+        PFNGLGETUNIFORMLOCATIONPROC glGetUniformLocation;
+        PFNGLACTIVETEXTUREPROC glActiveTexture;
 
 
-        vtxShaderId = compileShader(vertexShaderSource, GL_VERTEX_SHADER);
+        bool initGLExtensions() {
-        fragShaderId = compileShader(fragmentShaderSource?fragmentShaderSource:vertexShaderSource, GL_FRAGMENT_SHADER);
+            glCreateShader = (PFNGLCREATESHADERPROC)SDL_GL_GetProcAddress("glCreateShader");
+            glShaderSource = (PFNGLSHADERSOURCEPROC)SDL_GL_GetProcAddress("glShaderSource");
+            glCompileShader = (PFNGLCOMPILESHADERPROC)SDL_GL_GetProcAddress("glCompileShader");
+            glGetShaderiv = (PFNGLGETSHADERIVPROC)SDL_GL_GetProcAddress("glGetShaderiv");
+            glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)SDL_GL_GetProcAddress("glGetShaderInfoLog");
+            glDeleteShader = (PFNGLDELETESHADERPROC)SDL_GL_GetProcAddress("glDeleteShader");
+            glAttachShader = (PFNGLATTACHSHADERPROC)SDL_GL_GetProcAddress("glAttachShader");
+            glCreateProgram = (PFNGLCREATEPROGRAMPROC)SDL_GL_GetProcAddress("glCreateProgram");
+            glDeleteProgram = (PFNGLDELETEPROGRAMPROC)SDL_GL_GetProcAddress("glDeleteProgram");
+            glLinkProgram = (PFNGLLINKPROGRAMPROC)SDL_GL_GetProcAddress("glLinkProgram");
+            glValidateProgram = (PFNGLVALIDATEPROGRAMPROC)SDL_GL_GetProcAddress("glValidateProgram");
+            glGetProgramiv = (PFNGLGETPROGRAMIVPROC)SDL_GL_GetProcAddress("glGetProgramiv");
+            glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)SDL_GL_GetProcAddress("glGetProgramInfoLog");
+            glUseProgram = (PFNGLUSEPROGRAMPROC)SDL_GL_GetProcAddress("glUseProgram");
+            glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)SDL_GL_GetProcAddress("glGetUniformLocation");
+            glActiveTexture = (PFNGLACTIVETEXTUREPROC)SDL_GL_GetProcAddress("glActiveTexture");
 
-        if(vtxShaderId && fragShaderId)
+            return glCreateShader && glShaderSource && glCompileShader && glGetShaderiv && 
-        {
+                glGetShaderInfoLog && glDeleteShader && glAttachShader && glCreateProgram &&
-            // Associate shader with program
+                glDeleteProgram && glLinkProgram && glValidateProgram && glGetProgramiv &&
-            glAttachShader(programId, vtxShaderId);
+                glGetProgramInfoLog && glUseProgram && glGetUniformLocation;
-            glAttachShader(programId, fragShaderId);
+        }
-            glLinkProgram(programId);
-            glValidateProgram(programId);
 
-            // Check the status of the compile/link
+        #endif
-            GLint logLen;
+
-            glGetProgramiv(programId, GL_INFO_LOG_LENGTH, &logLen);
+        GLuint compileShader(const char* source, GLuint shaderType) {
-            if (logLen > 0)
+            // Create ID for shader
+            GLuint result = glCreateShader(shaderType);
+            // Add define depending on shader type
+            const char *sources[2] = { shaderType==GL_VERTEX_SHADER?"#define VERTEX\n":"#define FRAGMENT\n", source };
+            // Define shader text
+            glShaderSource(result, 2, sources, NULL);
+            // Compile shader
+            glCompileShader(result);
+
+            //Check vertex shader for errors
+            GLint shaderCompiled = GL_FALSE;
+            glGetShaderiv( result, GL_COMPILE_STATUS, &shaderCompiled );
+            if (shaderCompiled != GL_TRUE)
             {
-                char* log = (char*) malloc(logLen * sizeof(char));
+                std::cout << "Error en la compilación: " << result << "!" << std::endl;
-                // Show any errors as appropriate
+                GLint logLength;
-                glGetProgramInfoLog(programId, logLen, &logLen, log);
+                glGetShaderiv(result, GL_INFO_LOG_LENGTH, &logLength);
-                std::cout << "Prog Info Log: " << std::endl << log << std::endl;
+                if (logLength > 0)
-                free(log);
+                {
+                    GLchar *log = (GLchar*)malloc(logLength);
+                    glGetShaderInfoLog(result, logLength, &logLength, log);
+                    std::cout << "Shader compile log:" << log << std::endl;
+                    //std::cout << source << std::endl;
+                    free(log);
+                }
+                glDeleteShader(result);
+                result = 0;
             }
+            return result;
         }
-        if (vtxShaderId) glDeleteShader(vtxShaderId);
-        if (fragShaderId) glDeleteShader(fragShaderId);
-        return programId;
-    }
 
-    const bool init(SDL_Window* win, SDL_Texture* backBuffer, const char* vertexShader, const char* fragmentShader)
+        GLuint compileProgram(const char* vertexShaderSource, const char* fragmentShaderSource)
-    {
-        shader::win = win;
-        shader::renderer = SDL_GetRenderer(win);
-        shader::backBuffer = backBuffer;
-        SDL_GetWindowSize(win, &win_size.x, &win_size.y);
-        SDL_GetTextureSize(backBuffer, &tex_size.x, &tex_size.y);
-        //printf("tex size: %fx%f\n", tex_size.x, tex_size.y);
-        SDL_PropertiesID props = SDL_GetTextureProperties(backBuffer);
-        texture_number = SDL_GetNumberProperty(props, SDL_PROP_TEXTURE_OPENGL_TEXTURE_NUMBER, -1);
-        //printf("texture number: %i\n", texture_number);
-        int access = SDL_GetNumberProperty(props, SDL_PROP_TEXTURE_ACCESS_NUMBER, -1);
-        nose = SDL_GetNumberProperty(props, SDL_PROP_TEXTURE_OPENGL_TEXTURE_TARGET_NUMBER, -1);
-        //printf("texture target number: %i\n", nose);
-
-        if (access != SDL_TEXTUREACCESS_TARGET)
         {
-            std::cout << "ERROR FATAL: La textura per al render ha de tindre SDL_TEXTUREACCESS_TARGET definit." << std::endl;
+            GLuint programId = 0;
-            exit(1);
+            GLuint vtxShaderId, fragShaderId;
+
+            if (programId != 0) glDeleteProgram(programId);
+            programId = glCreateProgram();
+            
+
+            vtxShaderId = compileShader(vertexShaderSource, GL_VERTEX_SHADER);
+            fragShaderId = compileShader(fragmentShaderSource?fragmentShaderSource:vertexShaderSource, GL_FRAGMENT_SHADER);
+
+            if(vtxShaderId && fragShaderId)
+            {
+                // Associate shader with program
+                glAttachShader(programId, vtxShaderId);
+                glAttachShader(programId, fragShaderId);
+                glLinkProgram(programId);
+                glValidateProgram(programId);
+
+                // Check the status of the compile/link
+                GLint logLen;
+                glGetProgramiv(programId, GL_INFO_LOG_LENGTH, &logLen);
+                if (logLen > 0)
+                {
+                    char* log = (char*) malloc(logLen * sizeof(char));
+                    // Show any errors as appropriate
+                    glGetProgramInfoLog(programId, logLen, &logLen, log);
+                    std::cout << "Prog Info Log: " << std::endl << log << std::endl;
+                    free(log);
+                }
+            }
+            if (vtxShaderId) glDeleteShader(vtxShaderId);
+            if (fragShaderId) glDeleteShader(fragShaderId);
+            return programId;
         }
 
-        const char * renderer_name = SDL_GetRendererName(renderer);
+        const bool init(SDL_Window* win, SDL_Texture* backBuffer, const char* vertexShader, const char* fragmentShader)
-        //printf("rendererInfo.name: %s\n", renderer_name);
+        {
+            shader::win = win;
+            shader::renderer = SDL_GetRenderer(win);
+            shader::backBuffer = backBuffer;
+            SDL_GetWindowSize(win, &win_size.x, &win_size.y);
+            SDL_GetTextureSize(backBuffer, &tex_size.x, &tex_size.y);
+            //printf("tex size: %fx%f\n", tex_size.x, tex_size.y);
+            SDL_PropertiesID props = SDL_GetTextureProperties(backBuffer);
+            texture_number = SDL_GetNumberProperty(props, SDL_PROP_TEXTURE_OPENGL_TEXTURE_NUMBER, -1);
+            //printf("texture number: %i\n", texture_number);
+            int access = SDL_GetNumberProperty(props, SDL_PROP_TEXTURE_ACCESS_NUMBER, -1);
+            nose = SDL_GetNumberProperty(props, SDL_PROP_TEXTURE_OPENGL_TEXTURE_TARGET_NUMBER, -1);
+            //printf("texture target number: %i\n", nose);
 
-        if(!strncmp(renderer_name, "opengl", 6)) {
+            if (access != SDL_TEXTUREACCESS_TARGET)
-#ifndef __APPLE__
+            {
-            static bool gl_extensions_initialized = false;
+                std::cout << "ERROR FATAL: La textura per al render ha de tindre SDL_TEXTUREACCESS_TARGET definit." << std::endl;
-            if (!gl_extensions_initialized) {
+                exit(1);
-                if (!initGLExtensions()) {
+            }
-                    std::cout << "WARNING: No s'han pogut inicialitzar les extensions d'OpenGL!" << std::endl;
+
+            const char * renderer_name = SDL_GetRendererName(renderer);
+            //printf("rendererInfo.name: %s\n", renderer_name);
+
+            if(!strncmp(renderer_name, "opengl", 6)) {
+    #ifndef __APPLE__
+                static bool gl_extensions_initialized = false;
+                if (!gl_extensions_initialized) {
+                    if (!initGLExtensions()) {
+                        std::cout << "WARNING: No s'han pogut inicialitzar les extensions d'OpenGL!" << std::endl;
+                        can_use_opengl = false;
+                        return false;
+                    }
+                    gl_extensions_initialized = true;
+                }
+    #endif
+                // Compilar el shader y dejarlo listo para usar.
+                if (!vertexShader) {
                     can_use_opengl = false;
                     return false;
                 }
-                gl_extensions_initialized = true;
+                programId = compileProgram(vertexShader, fragmentShader);
-            }
+            } else {
-#endif
+                std::cout << "WARNING: El driver del renderer no es OpenGL." << std::endl;
-            // Compilar el shader y dejarlo listo para usar.
-            if (!vertexShader) {
                 can_use_opengl = false;
                 return false;
             }
-            programId = compileProgram(vertexShader, fragmentShader);
+            can_use_opengl = true;
-        } else {
+            return true;
-            std::cout << "WARNING: El driver del renderer no es OpenGL." << std::endl;
-            can_use_opengl = false;
-            return false;
         }
-        can_use_opengl = true;
-        return true;
-    }
 
-    unsigned char pixels[512*240*4];
+        unsigned char pixels[512*240*4];
 
-    void enable() { if (can_use_opengl) using_opengl = true; }
+        void enable() { if (can_use_opengl) using_opengl = true; }
-    void disable() { using_opengl = false; }
+        void disable() { using_opengl = false; }
 
-    void render()
+        void render()
-    {
-        SDL_FlushRenderer(renderer);
-        SDL_SetRenderTarget(renderer, NULL);
-        SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
-        SDL_RenderClear(renderer);
-        SDL_FlushRenderer(renderer);
-
-        if (using_opengl)
         {
-            GLint oldProgramId;
+            SDL_FlushRenderer(renderer);
-            if (programId != 0)
+            SDL_SetRenderTarget(renderer, NULL);
+            SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
+            SDL_RenderClear(renderer);
+            SDL_FlushRenderer(renderer);
+
+            if (using_opengl)
             {
-                glGetIntegerv(GL_CURRENT_PROGRAM, &oldProgramId);
+                GLint oldProgramId;
-                glUseProgram(programId);
+                if (programId != 0)
+                {
+                    glGetIntegerv(GL_CURRENT_PROGRAM, &oldProgramId);
+                    glUseProgram(programId);
+                }
+
+                glEnable(GL_TEXTURE_2D);
+                glActiveTexture(GL_TEXTURE0);
+                glBindTexture(GL_TEXTURE_2D, 1);
+                //glGetTexImage(GL_TEXTURE_2D, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8, pixels);
+                //if (glGetError()) { printf("GLGETERROR!\n"); exit(1);}
+                //GLint param;
+                //glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &param);
+                //printf("tex width: %i\n", param);
+                glViewport(0, 0, win_size.x, win_size.y);
+                
+                glBegin(GL_TRIANGLE_STRIP);
+                    glTexCoord2f(0.0f, 0.0f);
+                    glVertex2f(-1.0f, -1.0f);
+                    glTexCoord2f(tex_size.x, 0.0f);
+                    glVertex2f(1.0f, -1.0f);
+                    glTexCoord2f(0.0f, tex_size.y);
+                    glVertex2f(-1.0f, 1.0f);
+                    glTexCoord2f(tex_size.x, tex_size.y);
+                    glVertex2f(1.0f, 1.0f);
+                glEnd();
+
+                SDL_GL_SwapWindow(win);
+
+                if (programId != 0) glUseProgram(oldProgramId);
+
+            } else {
+                SDL_RenderTexture(renderer, backBuffer, NULL, NULL);
+                SDL_RenderPresent(renderer);
             }
-
+            if (glGetError()) { printf("GLERROR!\n"); exit(1); }
-            glEnable(GL_TEXTURE_2D);
-            glActiveTexture(GL_TEXTURE0);
-            glBindTexture(GL_TEXTURE_2D, 1);
-            //glGetTexImage(GL_TEXTURE_2D, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8, pixels);
-            //if (glGetError()) { printf("GLGETERROR!\n"); exit(1);}
-            //GLint param;
-            //glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &param);
-            //printf("tex width: %i\n", param);
-            glViewport(0, 0, win_size.x, win_size.y);
-            
-            glBegin(GL_TRIANGLE_STRIP);
-                glTexCoord2f(0.0f, 0.0f);
-                glVertex2f(-1.0f, -1.0f);
-                glTexCoord2f(tex_size.x, 0.0f);
-                glVertex2f(1.0f, -1.0f);
-                glTexCoord2f(0.0f, tex_size.y);
-                glVertex2f(-1.0f, 1.0f);
-                glTexCoord2f(tex_size.x, tex_size.y);
-                glVertex2f(1.0f, 1.0f);
-            glEnd();
-
-            SDL_GL_SwapWindow(win);
-
-            if (programId != 0) glUseProgram(oldProgramId);
-
-        } else {
-            SDL_RenderTexture(renderer, backBuffer, NULL, NULL);
-            SDL_RenderPresent(renderer);
         }
-        if (glGetError()) { printf("GLERROR!\n"); exit(1); }
     }
 }

source/jshader.h

@@ -35,14 +35,17 @@
 // Ah! una cosa mes: al compilar, en Linux afegir "-lGL", en Windows afegir "-lopengl32".
 // En Mac ni idea
 
-namespace shader
+namespace mini
 {
-    const bool init(SDL_Window* win, SDL_Texture* backBuffer,
+    namespace shader
-                    const char* vertexShader, const char* fragmentShader=nullptr);
+    {
+        const bool init(SDL_Window* win, SDL_Texture* backBuffer,
+                        const char* vertexShader, const char* fragmentShader=nullptr);
 
                         
-    void enable();
+        //void enable();
-    void disable();
+        //void disable();
 
-    void render();
+        void render();
+    }
 }

source/lua.h

@@ -4,7 +4,7 @@ namespace mini
 {
     namespace lua
     {
-        bool runnning();
+        bool running();
         void init(const char* main_lua_file = "main.lua");
         void quit();
         void cleanup();

source/main.cpp

@@ -3,23 +3,25 @@
 uint16_t ants = 0xc936;
 float t = 0;
 
+using namespace mini;
+
 void exception_loop() {
     //if (t==0) t= time();
-    if (time()-t > 0.25) {
+    if (sys::time()-t > 0.25) {
-        t = time();
+        t = sys::time();
-        clip();
+        view::clip::reset();
-        origin(0,0);
+        view::origin::set(0,0);
-        setdest(0);
+        surf::target::set(0);
-        settrans(255);
+        pal::trans::set(255);
-        setcolor(0,0xffffff00);
+        pal::color::set(0,0xffffff00);
-        setcolor(1,0xff000000);
+        pal::color::set(1,0xff000000);
-        const int w=scrw();
+        const int w=win::res::getw();
-        const int h=scrh();
+        const int h=win::res::geth();
         mini::draw::mode::set(0);
         mini::draw::rect(0,0,w,h,1);
         mini::draw::rect(1,1,w-2,h-2,1);
         mini::draw::mode::set(1);
-        fillp(ants);
+        draw::pattern::set(ants);
         mini::draw::rect(0,0,w,h,0);
         mini::draw::rect(1,1,w-2,h-2,0);
         ants = (ants<<12) | (ants>>4);

source/mini.h

@@ -1,16 +1,9 @@
 #pragma once
-
 #include <SDL3/SDL.h>
-
 #include "version.h"
 
-
-
 void exception_loop();
 
-int scrw();
-int scrh();
-
 void raisewindow();
 
 namespace mini
@@ -59,33 +52,40 @@ namespace mini
             uint8_t geth();
             void set(int w, int h);
         }
-
     }
-}
 
+    namespace pal
+    {
+        uint32_t *load(const char* filename, uint16_t *palsize=NULL);
+        void set(uint32_t *pal);
+        namespace color {
+            void set(uint8_t index, uint32_t color);
+            uint32_t get(uint8_t index);
+        }
+        namespace trans {
+            void set(uint8_t index);
+            uint8_t get();
+        }
+        namespace subpal {
+            uint8_t set(uint8_t index, uint8_t color);
+            void reset();
+        }
+    }
 
-void shader_init(const char* vshader, const char* fshader);
+    namespace view
-void shader_enable();
+    {
-void shader_disable();
+        namespace clip {
+            void set(int x, int y, int w, int h);
+            void reset();
+        }
 
-uint8_t loadfont(const char *filename);
+        namespace origin {
-uint8_t getfont();
+            void set(int x, int y);
-void setfont(uint8_t font);
+            int getx();
-uint8_t getfontspacing();
+            int gety();
-void setfontspacing(uint8_t spacing);
+        }
+    }
 
-
-uint32_t *loadpal(const char* filename, uint16_t *palsize=NULL);
-void setpal(uint32_t *pal);
-void setcolor(uint8_t index, uint32_t color);
-uint32_t getcolor(uint8_t index);
-void settrans(uint8_t index);
-uint8_t gettrans();
-uint8_t subpal(uint8_t index, uint8_t color);
-void reset_subpal();
-
-namespace mini
-{
     namespace draw
     {
         void line(int x0, int y0, int x1, int y1, uint8_t color);
@@ -103,84 +103,150 @@ namespace mini
         void oval(int x0, int y0, int x1, int y1, uint8_t color);
         void ovalf(int x0, int y0, int x1, int y1, uint8_t color);
 
+        namespace pattern {
+            void set(uint16_t pat, bool transparent = false);
+        }
+
+        void surf(int sx, int sy, int sw, int sh, int dx, int dy, int dw=0, int dh=0, bool flip_x = false, bool flip_y = false, bool invert = false);
+        void surfrot(int sx, int sy, int sw, int sh, int dx, int dy, int dw, int dh, bool flip_x, bool flip_y, float angle_deg);
+
+        void text(const char *str, int x, int y, uint8_t color);
+
         namespace mode
         {
             void set(uint8_t mode);
         }
     }
+
+    namespace shader
+    {
+        void init(const char* vshader, const char* fshader);
+        void enable();
+        void disable();
+    }
+
+    namespace audio
+    {
+        namespace music
+        {
+            void play(const char *filename, const int loop=-1);
+            void pause();
+            void resume();
+            void stop(const int t=1000);
+            namespace pos {
+                void set(float value);
+                float get();
+            }
+            namespace enable {
+                void set(const bool value);
+                const bool get();
+            }
+        }
+
+        namespace sound
+        {
+            int load(const char *filename);
+            void free(int soundfile);
+            int play(int soundfile, const int volume=-1);
+            void stop(int soundchannel);
+            namespace enable {
+                void set(const bool value);
+                const bool get();
+            }
+        }
+    }
+
+    namespace sys
+    {
+        float delta();
+        float time();
+        bool beat(int16_t i);
+
+        int getfps();
+
+        namespace update {
+            void set(const int value, const int t=0);
+            int get();
+        }
+
+        void exit();
+    }
+
+    namespace win
+    {
+        namespace zoom {
+            void set(const int value);
+            int get();
+        }
+
+        namespace fullscreen {
+            void set(const bool value);
+            bool get();
+        }
+
+        namespace cursor {
+            void set(const bool value);
+            bool get();
+        }
+
+        namespace res {
+            void set(const int w, const int h);
+            int getw();
+            int geth();
+        }
+    }
+
+    namespace config
+    {
+        namespace key {
+            void set(const char* key, const char* value);
+            const char *get(const char* key);
+        }
+
+        const char *folder();
+    }
+
+    namespace font
+    {
+        uint8_t load(const char *filename);
+
+        namespace current {
+            void set(uint8_t font);
+            uint8_t get();
+        }
+
+        namespace spacing {
+            void set(uint8_t spacing);
+            uint8_t get();
+        }
+    }
+
+    namespace mouse
+    {
+        int posx();
+        int posy();
+        int wheel();
+        bool down(uint8_t i);
+        bool press(uint8_t i);
+        bool dblclick();
+        void discard();
+        bool inside(int x, int y, int w, int h);
+    }
+
+    namespace key
+    {
+        bool down(uint8_t i);
+        bool press(uint8_t i);
+        int press();
+        bool any();
+        void text(const bool enable);
+        const char *utf8char();
+    }
+
+    namespace pad
+    {
+        bool down(int8_t i);
+        bool press(int8_t i);
+        int press();
+    }
 }
-
-
-void fillp(uint16_t pat, bool transparent = false);
-
-void print(const char *str, int x, int y, uint8_t color);
-
-void clip(int x, int y, int w, int h);
-void clip();
-void origin(int x, int y);
-int camx();
-int camy();
-
-uint8_t sget(int x, int y);
-
-void blit(int sx, int sy, int sw, int sh, int dx, int dy, int dw=0, int dh=0, bool flip_x = false, bool flip_y = false, bool invert = false);
-void blit_r(int sx, int sy, int sw, int sh, int dx, int dy, int dw, int dh, bool flip_x, bool flip_y, float angle_deg);
-
-bool btn(uint8_t i);
-int wbtnp();
-bool btnp(uint8_t i);
-bool anykey();
-void textenable(const bool enable);
-const char *textinput();
-
-bool pad(int8_t i);
-bool padp(int8_t i);
-int wpad();
-
-int mousex();
-int mousey();
-int mwheel();
-bool mbtn(uint8_t i);
-bool mbtnp(uint8_t i);
-bool doubleclick();
-void mdiscard();
-bool minside(int x, int y, int w, int h);
-
-float time();
-float delta();
-bool beat(int16_t i);
-
-int getfps();
-
-void playmusic(const char *filename, const int loop=-1);
-void pausemusic();
-void resumemusic();
-void stopmusic(const int t=1000);
-void musicpos(float value);
-float musicpos();
-void enablemusic(const bool value);
-const bool ismusicenabled();
-
-int loadsound(const char *filename);
-void freesound(int soundfile);
-int playsound(int soundfile, const int volume=-1);
-void stopsound(int soundchannel);
-void enablesound(const bool value);
-const bool issoundenabled();
-
-int getzoom();
-void setzoom(const int value);
-void setres(const int w, const int h);
-bool getfullscreen();
-void setfullscreen(const bool value);
-bool getcursor();
-void setcursor(const bool value);
-
-const char *getconfig(const char* key);
-void setconfig(const char* key, const char* value);
-const char *configfolder();
-
-void setupdatemode(const int value, const int t=0);
-int getupdatemode();
-
-void exit();