- [WIP] Solventant el problema dels shaders

source/backends/SDL3/shader.cpp

@@ -30,6 +30,9 @@ namespace backend
         SDL_FPoint tex_size = {320, 240};
         bool can_use_opengl = false;
         bool using_opengl = false;
+        const char *vShaderSource = nullptr;
+        const char *fShaderSource = nullptr;
+
 
         #ifndef __APPLE__
 
@@ -148,17 +151,26 @@ namespace backend
             return programId;
         }
 
-        void init(const char* vshader, const char* fshader)
+        void quit()
         {
-            int filesize;
+            programId = 0;
-            char *vshaderfile = mini::file::getfilebuffer(vshader, filesize, true);
+            can_use_opengl = false;
+            using_opengl = false;
+        }
 
-            char *fshaderfile = nullptr;
+        void reinit()
-            if (fshader) { fshaderfile = mini::file::getfilebuffer(fshader, filesize, true); }
+        {
+            if (!vShaderSource) return;
 
             SDL_GetWindowSize(video::window, &win_size.x, &win_size.y);
             SDL_GetTextureSize(video::tex_shader, &tex_size.x, &tex_size.y);
 
+            int filesize;
+            char *vshaderfile = mini::file::getfilebuffer(vShaderSource, filesize, true);
+            
+            char *fshaderfile = nullptr;
+            if (fShaderSource) { fshaderfile = mini::file::getfilebuffer(fShaderSource, filesize, true); }
+
             SDL_PropertiesID props = SDL_GetTextureProperties(video::tex_shader);
             int access = SDL_GetNumberProperty(props, SDL_PROP_TEXTURE_ACCESS_NUMBER, -1);
             if (access != SDL_TEXTUREACCESS_TARGET) {
@@ -190,7 +202,16 @@ namespace backend
                 return;
             }
             can_use_opengl = true;
-            return;
+        }
+
+        void init(const char* vshader, const char* fshader)
+        {
+            vShaderSource = vshader;
+            fShaderSource = fshader;
+            programId = 0;
+            can_use_opengl = false;
+            using_opengl = false;
+            reinit();
         }
 
         void enable() { if (can_use_opengl) using_opengl = true; }
@@ -216,7 +237,7 @@ namespace backend
                 glEnable(GL_TEXTURE_2D);
                 glActiveTexture(GL_TEXTURE0);
                 glBindTexture(GL_TEXTURE_2D, 1);
-                glViewport(0, 0, win_size.x, win_size.y);
+                glViewport(backend::video::dest_rect.x, backend::video::dest_rect.y, backend::video::dest_rect.w, backend::video::dest_rect.h);
                 
                 glBegin(GL_TRIANGLE_STRIP);
                     glTexCoord2f(0.0f, 0.0f);
@@ -234,7 +255,7 @@ namespace backend
                 if (programId != 0) glUseProgram(oldProgramId);
 
             } else {
-                SDL_RenderTexture(backend::video::renderer, backend::video::tex_shader, NULL, NULL);
+                SDL_RenderTexture(backend::video::renderer, backend::video::tex_shader, NULL, &backend::video::dest_rect);
                 SDL_RenderPresent(backend::video::renderer);
             }
             if (glGetError()) { printf("GLERROR!\n"); ::exit(1); }

source/backends/SDL3/state.h

@@ -11,6 +11,7 @@ namespace backend
         extern SDL_Renderer *renderer;
         extern SDL_Texture  *tex_back;
         extern SDL_Texture  *tex_shader;
+        extern SDL_FRect    dest_rect;
     }
 
     namespace input

source/backends/SDL3/video.cpp

@@ -6,6 +6,7 @@
 #include "mini/surf/surf.h"
 #include "mini/pal/pal.h"
 #include "mini/shader/shader.h"
+#include "other/log.h"
 
 namespace backend
 {
@@ -16,6 +17,9 @@ namespace backend
         SDL_Texture     *tex_back       { nullptr };
         SDL_Texture     *tex_shader     { nullptr };
 
+        int             fullscreen_scale;
+        SDL_FRect       dest_rect;
+
         void init() {
             const auto &title = mini::win::state.title;
             const auto &width = mini::win::state.width;
@@ -27,8 +31,9 @@ namespace backend
             const SDL_DisplayMode *dm = SDL_GetDesktopDisplayMode(SDL_GetPrimaryDisplay());
             while ( width * zoom > dm->w || height * zoom > dm->h) zoom--;
 
+            const int z = mini::win::state.fullscreen ? 1 : zoom;
             // Crear SDL_Window i SDL_Renderer
-            window = SDL_CreateWindow(title, width*zoom, height*zoom, SDL_WINDOW_OPENGL|(mini::win::state.fullscreen?SDL_WINDOW_FULLSCREEN:0));
+            window = SDL_CreateWindow(title, width*z, height*z, SDL_WINDOW_OPENGL|(mini::win::state.fullscreen?SDL_WINDOW_FULLSCREEN:0));
             SDL_SetHint(SDL_HINT_RENDER_DRIVER, "opengl");
             renderer = SDL_CreateRenderer(window, NULL);
             SDL_SetRenderVSync(renderer, SDL_RENDERER_VSYNC_DISABLED);
@@ -41,11 +46,44 @@ namespace backend
             SDL_SetTextureScaleMode(tex_back, SDL_SCALEMODE_NEAREST);
 
             // Crear textura shaders i inicialitzar shaders
-            tex_shader = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_TARGET, width*zoom, height*zoom);
+            int w = width*z;
+            int h = height*z;
+            if (mini::win::state.fullscreen) {
+                fullscreen_scale = SDL_min(dm->w/width, dm->h/height);
+                w = width * fullscreen_scale;
+                h = height * fullscreen_scale;
+                log_msg(LOG_INFO, "fullscreen_scale: %i\n", fullscreen_scale);
+            }
+            tex_shader = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_TARGET, w, h);
             SDL_SetTextureScaleMode(tex_shader, SDL_SCALEMODE_NEAREST);
+
+            int ww, wh;
+            SDL_GetWindowSize(window, &ww, &wh);
+            printf("window: %ix%i\n", ww, wh);
+
+            if (mini::win::state.fullscreen)        
+            {
+                dest_rect.w = width * fullscreen_scale;
+                dest_rect.h = height * fullscreen_scale;
+                dest_rect.x = (dm->w - dest_rect.w)/2;
+                dest_rect.y = (dm->h - dest_rect.h)/2;
+
+                printf("width: %i, height: %i\n", width, height);
+                printf("screen: %ix%i\n", dm->w, dm->h);
+                printf("dest_rect: (%i,%i)-(%i,%i)\n", (int)dest_rect.x, (int)dest_rect.y, (int)dest_rect.w, (int)dest_rect.h);
+            }
+            else
+            {
+                dest_rect.x = dest_rect.y = 0;
+                dest_rect.w = width * zoom;
+                dest_rect.h = height * zoom;
+                printf("dest_rect: (%i,%i)-(%i,%i)\n", (int)dest_rect.x, (int)dest_rect.y, (int)dest_rect.w, (int)dest_rect.h);
+            }
+            shader::reinit();
         }
 
         void quit() {
+            shader::quit();
             SDL_DestroyTexture(tex_shader);
             SDL_DestroyTexture(tex_back);
             SDL_DestroyRenderer(renderer);
@@ -65,6 +103,13 @@ namespace backend
             uint8_t *p = s.p;
             for (uint32_t i=0;i<s.size;++i) pixels[i] = mini::pal::palette[p[i]];
             SDL_UnlockTexture(tex_back);
+
+            if (mini::win::state.fullscreen)
+            {
+                SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
+                SDL_RenderClear(renderer);
+            }
+
             SDL_RenderTexture(renderer, tex_back, NULL, NULL); //NEW
 
             backend::shader::render();

source/backends/backend.h

@@ -36,6 +36,8 @@ namespace backend
     namespace shader
     {
         void init(const char* vshader, const char* fshader);
+        void reinit();
+        void quit();
         void enable();
         void disable();
         void render();