- Llevat el tema dels shaders, que aci no fa falta

- Fent proves de visualització
- Afegits un parell de bocetos

source/japi/draw.cpp

@@ -2,7 +2,7 @@
 #include <SDL3/SDL.h>
 #include "gif.h"
 #include "file.h"
-#include "shader.h"
+//#include "shader.h"
 
 namespace draw
 {
@@ -14,7 +14,7 @@ namespace draw
     SDL_Window      *sdl_window     {nullptr};  // La finestra de SDL
     SDL_Renderer    *sdl_renderer   {nullptr};  // El renderer de SDL
     SDL_Texture     *sdl_texture    {nullptr};  // La textura de SDL a la que pintarem la nostra superficie "screen" i que despres volcarem a pantalla
-    SDL_Texture     *sdl_shadertex  {nullptr};  // La textura de SDL per al shader
+    //SDL_Texture     *sdl_shadertex  {nullptr};  // La textura de SDL per al shader
 
     static int      screen_zoom = 1;
     static bool     screen_fullscreen = false;
@@ -104,10 +104,10 @@ namespace draw
             exit(1);
         }
 
-        sdl_shadertex = SDL_CreateTexture(sdl_renderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_TARGET, window_width, window_height);
+//        sdl_shadertex = SDL_CreateTexture(sdl_renderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_TARGET, window_width, window_height);
-        SDL_SetTextureScaleMode(sdl_shadertex, SDL_SCALEMODE_NEAREST);
+//        SDL_SetTextureScaleMode(sdl_shadertex, SDL_SCALEMODE_NEAREST);
 
-        loadShader();
+//        loadShader();
     }
 
     void destroyDisplay()
@@ -235,50 +235,6 @@ namespace draw
         file::setConfigValueBool("fullscreen", screen_fullscreen);
     }
 
-    void loadShader()
-    {
-        char *buffer = nullptr;
-        if (screen_shader) {
-            int size;
-            buffer = file::getFileBuffer(screen_shader, size, true);
-        }
-        shader::setAspectRatio(3.0f/4.0f);
-        shader::init(sdl_window, sdl_shadertex, buffer);
-        if (buffer) free(buffer);
-    }
-
-    void setShader(const char* shader_file)
-    {
-        if (screen_shader) free(screen_shader);
-        screen_shader = (char*)malloc(strlen(shader_file)+1);
-        strcpy(screen_shader, shader_file);
-        loadShader();
-        if (file::getConfigValueBool("shader_enabled", false)) enableShader();
-    }
-
-    void enableShader()
-    {
-        shader_enabled = true;
-        shader::enable();
-        //destroyDisplay();
-        //createDisplay();
-        file::setConfigValueBool("shader_enabled", shader_enabled);
-    }
-
-    void disableShader()
-    {
-        shader_enabled = false;
-        shader::disable();
-        //destroyDisplay();
-        //createDisplay();
-        file::setConfigValueBool("shader_enabled", shader_enabled);
-    }
-
-    void toggleShader()
-    {
-        shader_enabled ? disableShader() : enableShader();
-    }
-
     void hideCursor()
     {
         screen_cursor = false;
@@ -719,13 +675,12 @@ namespace draw
         // Desbloquejem la textura
         SDL_UnlockTexture(sdl_texture);
 
-        SDL_SetRenderTarget(sdl_renderer, sdl_shadertex);
+        SDL_SetRenderTarget(sdl_renderer, nullptr);
         // Pintem la textura a pantalla
         SDL_RenderTexture(sdl_renderer, sdl_texture, NULL, NULL);
 
         // I ho presentem
-        shader::render();
+        SDL_RenderPresent(sdl_renderer);
-        //SDL_RenderPresent(sdl_renderer);
     }
     
 }

source/japi/draw.h

@@ -40,12 +40,6 @@ namespace draw
     bool getFullscreen();
     void setFullscreen(const bool value);
 
-    void loadShader();
-    void setShader(const char* shader_file);
-    void enableShader();
-    void disableShader();
-    void toggleShader();
-
     void hideCursor();
     void showCursor();
     

source/japi/game.cpp

@@ -94,9 +94,6 @@ int main(int argc, char *argv[])
                     case SDL_SCANCODE_F3:
                         draw::setFullscreen(!draw::getFullscreen());
                         break;
-                    case SDL_SCANCODE_F4:
-                        draw::toggleShader();
-                        break;
                     default:
                         input::updateKeypressed(e.key.scancode);
                 }

source/japi/shader.cpp

@@ -1,277 +0,0 @@
-#include "shader.h"
-
-#include <iostream>
-
-#ifdef __APPLE__
-#include "CoreFoundation/CoreFoundation.h"
-#include <OpenGL/OpenGL.h>
-
-#if ESSENTIAL_GL_PRACTICES_SUPPORT_GL3
-#include <OpenGL/gl3.h>
-#else
-#include <OpenGL/gl.h>
-#endif //!ESSENTIAL_GL_PRACTICES_SUPPORT_GL3
-#else
-#include <SDL3/SDL_opengl.h>
-#include <SDL3/SDL_opengl_glext.h>
-#endif
-
-namespace shader
-{
-    SDL_Window *win = nullptr;
-    SDL_Renderer *renderer = nullptr;
-    GLuint programId = 0;
-    SDL_Texture* backBuffer = nullptr;
-    SDL_FRect window = {0, 0, 640, 480};
-    SDL_FPoint tex_size = {320, 240};
-    float aspect_ratio = 1;
-    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;
-    PFNGLUNIFORM2FPROC glUniform2f;
-
-    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");
-        glUniform2f = (PFNGLUNIFORM2FPROC)SDL_GL_GetProcAddress("glUniform2f");
-
-        return glCreateShader && glShaderSource && glCompileShader && glGetShaderiv && 
-            glGetShaderInfoLog && glDeleteShader && glAttachShader && glCreateProgram &&
-            glDeleteProgram && glLinkProgram && glValidateProgram && glGetProgramiv &&
-            glGetProgramInfoLog && glUseProgram && glGetUniformLocation && glUniform2f;
-    }
-
-    #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)
-    {
-        GLuint programId = 0;
-        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 bool init(SDL_Window* win, SDL_Texture* backBuffer, const char* vertexShader, const char* fragmentShader)
-    {
-        shader::win = win;
-        shader::renderer = SDL_GetRenderer(win);
-        shader::backBuffer = backBuffer;
-        int w, h;
-        SDL_GetWindowSize(win, &w, &h);
-
-        if (w * aspect_ratio > h)  {
-            window.y = 0;
-            window.h = h;
-            window.w = h/aspect_ratio;
-            window.x = (w - window.w)/2;
-        } else {
-            window.x = 0;
-            window.w = w;
-            window.h = w*aspect_ratio;
-            window.y = (h - window.h)/2;
-        }
-
-        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;
-            exit(1);
-        }
-
-        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;
-            }
-            programId = compileProgram(vertexShader, fragmentShader);
-        } else {
-            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];
-
-    void enable() { if (can_use_opengl) using_opengl = true; }
-    void disable() { using_opengl = false; }
-
-    void setAspectRatio(const float ratio)
-    {
-        aspect_ratio = ratio;
-    }
-
-    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;
-            if (programId != 0)
-            {
-                glGetIntegerv(GL_CURRENT_PROGRAM, &oldProgramId);
-                glUseProgram(programId);
-            }
-
-            //GLint loc = glGetUniformLocation(programId, "TextureSize");
-            //glUniform2f(loc, 320, 256);
-
-            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(window.x, window.y, window.w, window.h);
-            
-            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, &window);
-            SDL_RenderPresent(renderer);
-        }
-        int glerror = glGetError();
-        if (glerror) { printf("GLERROR: %i\n", glerror); exit(1); }
-    }
-}

source/japi/shader.h

@@ -1,48 +0,0 @@
-#pragma once
-
-#include <SDL3/SDL.h>
-
-// TIPS:
-// =======================================================================
-// Abans de crear el renderer, cridar a la següent funció:
-//
-//   SDL_SetHint(SDL_HINT_RENDER_DRIVER, "opengl");
-//
-// Aixó li diu que volem un renderer que use especificament opengl. A més,
-// al crear el renderer li tenim que dir que el volem que use acceeració
-// per hardware, i que soporte render a textura. Per exemple:
-//
-//   SDL_Renderer *ren = SDL_CreateRenderer(win, -1, SDL_RENDERER_ACCELERATED |
-//                                                   SDL_RENDERER_TARGETTEXTURE);
-//
-// Per altra part, al crear la textura tenim que definir que puga ser target
-// de renderitzat (SDL_TEXTUREACCESS_TARGET), per exemple:
-//
-// 	 SDL_Texture *tex = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_ARGB8888,
-//		                                  SDL_TEXTUREACCESS_TARGET, 320, 240);
-//
-// Els shaders li'ls passem com una cadena, som nosaltres els que s'encarreguem
-// de carregarlos de disc, amb fopen, ifstream, jfile o el que vullgues.
-// Si els tens en un std::string, passa-li-la com "cadena.c_str()".
-// 
-// Poden ser els dos el mateix arxiu, com fa libRetro, jo desde dins ja fique
-// els defines necessaris. Si es el mateix arxiu, pots no ficar el quart paràmetre.
-//
-// Els shaders de libRetro no funcionen directament, hi ha que fer algunes modificacions.
-//
-// El pintat final de la teua escena l'has de fer com si "backBuffer" fora la pantalla.
-//
-// Ah! una cosa mes: al compilar, en Linux afegir "-lGL", en Windows afegir "-lopengl32".
-// En Mac ni idea
-
-namespace shader
-{
-    const bool init(SDL_Window* win, SDL_Texture* backBuffer,
-                    const char* vertexShader, const char* fragmentShader=nullptr);
-
-    void setAspectRatio(const float ratio);
-    void enable();
-    void disable();
-
-    void render();
-}

source/main.cpp

@@ -8,7 +8,7 @@ bool loop();
 
 void game::init()
 {
-    draw::init("DILEMMAKER v0.1", 640, 480, 1, false);
+    draw::init("DILEMMAKER v0.1", 320, 240, 2, false);
     game::setState(loop);
     enemies::load();
     rooms::load();
@@ -17,12 +17,15 @@ void game::init()
 
 bool loop()
 {
-    //draw::cls(0);
+    draw::cls(4);
+    draw::setTrans(255);
     //rooms::drawFullMap();
+    
     rooms::draw();
     draw::color(COLOR_BRIGHT_BLACK);
-    for (int i=0; i<=32; ++i) draw::vline(64+i*16, 48, 256);
+    /*for (int i=0; i<=32; ++i) draw::vline(64+i*16, 48, 256);
     for (int i=0; i<=16; ++i) draw::hline(64, 48+i*16, 512);
+    */
     draw::render();
     return true;
 }

source/rooms.cpp

@@ -229,7 +229,7 @@ namespace rooms
                     tile--;
                     room.thumbnail->pixels[x+y*32] = pixels[tile%24][tile/24];
                 } else {
-                    room.thumbnail->pixels[x+y*32] = room.bgColor;
+                    room.thumbnail->pixels[x+y*32] = room.bgColor!=0 ? room.bgColor : 1;
                 }
             }
         }
@@ -300,12 +300,12 @@ namespace rooms
                 std::cout << std::endl;
             }
         }*/
-        room_t &room = rooms["01"];
+        /*room_t &room = rooms["01"];
         for (int y=0; y<16; ++y) {
             for (int x=0; x<32; ++x)
                 std::cout << std::to_string(room.tiles[x][y]) << ",";
             std::cout << std::endl;
-        }
+        }*/
     }
 
     void draw()
@@ -343,30 +343,43 @@ namespace rooms
         draw::setDestination(nullptr);
         draw::setSource(map_surface);
         draw::cls(COLOR_BRIGHT_BLACK);
-        draw::color(room.border);
+        //draw::color(room.border);
-        draw::fillrect(48, 32, 512+32, 256+32);
+        //draw::fillrect(48, 32, 512+32, 256+32);
-        draw::setViewport(64, 48, 512, 256);
+        //draw::setViewport(64, 48, 512, 256);
-        draw::draw(0, 0, 256, 128, 0, 0, 2);
+        draw::setViewport(32, 24, 256, 128);
+        draw::draw(0, 0);
         draw::resetViewport();
 
         //draw::setSource(room.thumbnail);
         //draw::draw();
     }
 
+    uint8_t blinking = 0;
     void drawFullMap()
     {
+        blinking = (blinking+1)%16;
         for (auto &item : rooms)
         {
             auto room = item.second;
             int x = ((full_map_x-room.map_x)*38)-1;
             int y = ((full_map_y-room.map_y)*22)-1;
             draw::resetViewport();
-            draw::color(COLOR_WHITE);
+
+            if (item.first == "01") {
+                draw::color(blinking);
+                draw::rect(x-1, y-1, 36, 20);
+                draw::color(COLOR_BLACK);
                 draw::rect(x, y, 34, 18);
+            } else {
+                draw::color(COLOR_WHITE);
+                draw::rect(x+1, y+1, 34, 18);
+                draw::color(COLOR_BLACK);
+                draw::rect(x, y, 34, 18);
+            }
             draw::setSource(room.thumbnail);
             draw::draw(x+1, y+1, 32, 16, 0, 0);
+
             if (room.roomUp != "0") draw::fillrect(x+15, y-4, 4, 4);
-            //if (room.roomDown != "0") draw::fillrect(x+15, y+16, 4, 4);
             if (room.roomLeft != "0") draw::fillrect(x-4, y+7, 4, 4);
         }
     }