Raimon @ quifisraimon
c0faf074fe
- [FIX] El buffer en que es guardaba l'arxiu de text dels shaders no s'alliberava. - [NEW] Traça per a vore - [NEW] Millors logs de errors de shaders - [NEW] Afegit mode 'consola' per a quan s'executa desde consola sense entorn gràfic
313 lines
12 KiB
C++
313 lines
12 KiB
C++
#if BACKEND == SDL3
|
|
|
|
#include "backends/backend.h"
|
|
#include "state.h"
|
|
#include "mini/file/file.h"
|
|
#include "mini/win/win.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
|
|
|
|
void checkGLError() {
|
|
GLenum err = glGetError();
|
|
if (err != GL_NO_ERROR) {
|
|
fprintf(stderr, "OpenGL error 0x%04X\n", err);
|
|
|
|
// Mapeo rápido de los errores más comunes de OpenGL
|
|
while (err != GL_NO_ERROR) {
|
|
const char* errStr = "";
|
|
switch (err) {
|
|
case GL_INVALID_ENUM: errStr = "GL_INVALID_ENUM"; break;
|
|
case GL_INVALID_VALUE: errStr = "GL_INVALID_STRING/VALUE"; break;
|
|
case GL_INVALID_OPERATION: errStr = "GL_INVALID_OPERATION"; break;
|
|
case GL_OUT_OF_MEMORY: errStr = "GL_OUT_OF_MEMORY"; break;
|
|
case GL_INVALID_FRAMEBUFFER_OPERATION: errStr = "GL_INVALID_FRAMEBUFFER_OPERATION"; break;
|
|
default: errStr = "UNKNOWN_ERROR"; break;
|
|
}
|
|
fprintf(stderr, " -> Código de error: %s (0x%04X)\n", errStr, err);
|
|
err = glGetError();
|
|
}
|
|
::exit(1);
|
|
}
|
|
}
|
|
|
|
#define GL_CHECK(stmt) do { \
|
|
stmt; \
|
|
checkGLError(#stmt, __FILE__, __LINE__); \
|
|
} while (0)
|
|
|
|
namespace backend
|
|
{
|
|
namespace shader
|
|
{
|
|
GLuint programId = 0;
|
|
SDL_Point win_size = {640, 480};
|
|
SDL_FPoint tex_size = {320, 240};
|
|
bool can_use_opengl = false;
|
|
bool enabled = false;
|
|
const char *vShaderSource = nullptr;
|
|
const char *fShaderSource = nullptr;
|
|
|
|
|
|
#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)
|
|
{
|
|
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);
|
|
|
|
GLint linkStatus = GL_FALSE;
|
|
glGetProgramiv(programId, GL_LINK_STATUS, &linkStatus);
|
|
|
|
if (linkStatus != GL_TRUE)
|
|
{
|
|
std::cout << "Error en el enlazado (Linking) del programa!" << std::endl;
|
|
GLint logLen = 0;
|
|
glGetProgramiv(programId, GL_INFO_LOG_LENGTH, &logLen);
|
|
if (logLen > 0)
|
|
{
|
|
char* log = (char*)malloc(logLen);
|
|
glGetProgramInfoLog(programId, logLen, &logLen, log);
|
|
std::cout << "Program Link Log:\n" << log << std::endl;
|
|
free(log);
|
|
}
|
|
glDeleteProgram(programId);
|
|
programId = 0;
|
|
}
|
|
}
|
|
if (vtxShaderId) glDeleteShader(vtxShaderId);
|
|
if (fragShaderId) glDeleteShader(fragShaderId);
|
|
return programId;
|
|
}
|
|
|
|
void quit()
|
|
{
|
|
programId = 0;
|
|
can_use_opengl = false;
|
|
//using_opengl = false;
|
|
}
|
|
|
|
void reinit()
|
|
{
|
|
if (!vShaderSource) return;
|
|
|
|
SDL_GetWindowSize(video::window, &win_size.x, &win_size.y);
|
|
SDL_GetTextureSize(video::tex_shader, &tex_size.x, &tex_size.y);
|
|
|
|
SDL_PropertiesID props = SDL_GetTextureProperties(video::tex_shader);
|
|
int access = SDL_GetNumberProperty(props, SDL_PROP_TEXTURE_ACCESS_NUMBER, -1);
|
|
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(backend::video::renderer);
|
|
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;
|
|
}
|
|
gl_extensions_initialized = true;
|
|
}
|
|
#endif
|
|
|
|
// Compilar el shader
|
|
int filesize;
|
|
char *vshaderfile = mini::file::getfilebuffer(vShaderSource, filesize, true);
|
|
|
|
if (!vshaderfile) {
|
|
can_use_opengl = false;
|
|
return;
|
|
}
|
|
|
|
char *fshaderfile = nullptr;
|
|
if (fShaderSource) { fshaderfile = mini::file::getfilebuffer(fShaderSource, filesize, true); }
|
|
|
|
programId = compileProgram(vshaderfile, fshaderfile);
|
|
|
|
if (vshaderfile) free(vshaderfile);
|
|
if (fshaderfile) free(fshaderfile);
|
|
} else {
|
|
std::cout << "WARNING: El driver del renderer no es OpenGL." << std::endl;
|
|
can_use_opengl = false;
|
|
return;
|
|
}
|
|
can_use_opengl = true;
|
|
}
|
|
|
|
void init(const char* vshader, const char* fshader)
|
|
{
|
|
vShaderSource = vshader;
|
|
fShaderSource = fshader;
|
|
programId = 0;
|
|
can_use_opengl = false;
|
|
//using_opengl = false;
|
|
reinit();
|
|
}
|
|
|
|
void enable() { enabled = true; }
|
|
void disable() { enabled = false; }
|
|
|
|
void render()
|
|
{
|
|
SDL_FlushRenderer(backend::video::renderer);
|
|
SDL_SetRenderTarget(backend::video::renderer, NULL);
|
|
SDL_SetRenderDrawColor(backend::video::renderer, 0, 0, 0, 255);
|
|
SDL_RenderClear(backend::video::renderer);
|
|
SDL_FlushRenderer(backend::video::renderer);
|
|
|
|
if (can_use_opengl && enabled)
|
|
{
|
|
GLint oldProgramId;
|
|
if (programId != 0)
|
|
{
|
|
glGetIntegerv(GL_CURRENT_PROGRAM, &oldProgramId);
|
|
glUseProgram(programId);
|
|
}
|
|
|
|
glEnable(GL_TEXTURE_2D);
|
|
glActiveTexture(GL_TEXTURE0);
|
|
glBindTexture(GL_TEXTURE_2D, 1);
|
|
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);
|
|
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(backend::video::window);
|
|
|
|
if (programId != 0) glUseProgram(oldProgramId);
|
|
|
|
} else {
|
|
SDL_RenderTexture(backend::video::renderer, backend::video::tex_shader, NULL, &backend::video::dest_rect);
|
|
SDL_RenderPresent(backend::video::renderer);
|
|
}
|
|
checkGLError();
|
|
//GLenum error = glGetError();
|
|
//if (error != GL_NO_ERROR) {
|
|
// printf("GLERROR!\n"); ::exit(1);
|
|
//}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
|
|
|
|
#endif |