JailDoctor/dilemmaker
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source 
- Fent proves de visualització
- Afegits un parell de bocetos
This commit is contained in:
Raimon Zamora
2025-11-03 16:29:24 +01:00
parent 68f5b2ff0f
commit 3c56cd59f8
9 changed files with 36 additions and 399 deletions
Download Patch File Download Diff File Expand all files Collapse all files

59
source/japi/draw.cpp
View File

@@ -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_SetTextureScaleMode(sdl_shadertex, SDL_SCALEMODE_NEAREST);
// sdl_shadertex = SDL_CreateTexture(sdl_renderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_TARGET, window_width, window_height);
// 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);
}
}

6
source/japi/draw.h
View File

@@ -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();

3
source/japi/game.cpp
View File

@@ -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);
}

277
source/japi/shader.cpp
View File

@@ -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); }
}
}

48
source/japi/shader.h
View File

@@ -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();
}

9
source/main.cpp
View File

@@ -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;
}

33
source/rooms.cpp
View File

@@ -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::fillrect(48, 32, 512+32, 256+32);
draw::setViewport(64, 48, 512, 256);
draw::draw(0, 0, 256, 128, 0, 0, 2);
//draw::color(room.border);
//draw::fillrect(48, 32, 512+32, 256+32);
//draw::setViewport(64, 48, 512, 256);
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);
draw::rect(x, y, 34, 18);
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);
}
}