Using Linux style VAOs

CMakeLists.txt

@@ -10,8 +10,8 @@ set(CMAKE_C_STANDARD_REQUIRED ON)
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules)
 
 if(NOT DEFINED DUSK_TARGET_SYSTEM)
-  set(DUSK_TARGET_SYSTEM "linux")
-  # set(DUSK_TARGET_SYSTEM "psp")
+  # set(DUSK_TARGET_SYSTEM "linux")
+  set(DUSK_TARGET_SYSTEM "psp")
 endif()
 
 # Prep cache

src/dusksdl2/CMakeLists.txt

@@ -11,10 +11,12 @@ target_compile_definitions(${DUSK_TARGET_NAME}
 
 # Libs
 find_package(SDL2 REQUIRED)
+find_package(OpenGL REQUIRED)
 
 target_link_libraries(${DUSK_TARGET_NAME}
   PUBLIC
     SDL2::SDL2
+    OpenGL::GL
 )
 
 

src/dusksdl2/display/render.c

@@ -16,8 +16,37 @@
 
 SDL_Window *RENDER_WINDOW;
 SDL_Renderer *RENDER_RENDERER;
+SDL_GLContext RENDER_GL_CONTEXT;
 bool_t RENDER_RUNNING;
 
+// Add VAO and VBO handles
+static GLuint TRIANGLE_VAO = 0;
+static GLuint TRIANGLE_VBO = 0;
+
+// Shader handles
+static GLuint TRIANGLE_SHADER_PROGRAM = 0;
+static GLuint TRIANGLE_VERTEX_SHADER = 0;
+static GLuint TRIANGLE_FRAGMENT_SHADER = 0;
+
+// Vertex and Fragment shader sources
+static const char* TRIANGLE_VERTEX_SHADER_SRC =
+  "#version 130\n"
+  "in vec2 position;\n"
+  "in vec3 color;\n"
+  "out vec3 vColor;\n"
+  "void main() {\n"
+  "  vColor = color;\n"
+  "  gl_Position = vec4(position, 0.0, 1.0);\n"
+  "}\n";
+
+static const char* TRIANGLE_FRAGMENT_SHADER_SRC =
+  "#version 130\n"
+  "in vec3 vColor;\n"
+  "out vec4 fragColor;\n"
+  "void main() {\n"
+  "  fragColor = vec4(vColor, 1.0);\n"
+  "}\n";
+
 errorret_t renderInit(void) {
   // Init SDL 
   uint32_t flags = SDL_INIT_VIDEO;
@@ -33,35 +62,110 @@ errorret_t renderInit(void) {
     );
   }
 
-  // Create window.
+  // Set OpenGL attributes (optional, adjust as needed)
+  SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
+  SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);
+  SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_COMPATIBILITY);
+  SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
+
+  // Create window with OpenGL flag.
   RENDER_WINDOW = SDL_CreateWindow(
     "DuskSDL2",
     SDL_WINDOWPOS_UNDEFINED,
     SDL_WINDOWPOS_UNDEFINED,
     RENDER_WINDOW_WIDTH_DEFAULT,
     RENDER_WINDOW_HEIGHT_DEFAULT,
-    SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI
+    SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI | SDL_WINDOW_OPENGL
   );
   if(!RENDER_WINDOW) {
     errorThrow("SDL_CreateWindow failed: %s", SDL_GetError());
   }
 
-  // Create renderer
-  RENDER_RENDERER = SDL_CreateRenderer(
-    RENDER_WINDOW,
-    -1,
-    SDL_RENDERER_ACCELERATED
-  );
-  if(!RENDER_RENDERER) {
-    errorThrow("SDL_CreateRenderer failed: %s", SDL_GetError());
+  // Create OpenGL context
+  RENDER_GL_CONTEXT = SDL_GL_CreateContext(RENDER_WINDOW);
+  if(!RENDER_GL_CONTEXT) {
+    errorThrow("SDL_GL_CreateContext failed: %s", SDL_GetError());
   }
 
+  // Enable VSync (optional)
+  SDL_GL_SetSwapInterval(1);
+
+  // No SDL_Renderer needed for OpenGL, set to NULL
+  RENDER_RENDERER = NULL;
+
+  // Disable GL crap we don't need
+  glDisable(GL_DEPTH_TEST);
+  glDisable(GL_CULL_FACE);
+  glDisable(GL_BLEND);
+  glDisable(GL_LIGHTING);// PSP defaults this on?
+
+  // --- Compile and link shaders ---
+  GLint success;
+  char infoLog[512];
+
+  // Vertex shader
+  TRIANGLE_VERTEX_SHADER = glCreateShader(GL_VERTEX_SHADER);
+  glShaderSource(TRIANGLE_VERTEX_SHADER, 1, &TRIANGLE_VERTEX_SHADER_SRC, NULL);
+  glCompileShader(TRIANGLE_VERTEX_SHADER);
+  glGetShaderiv(TRIANGLE_VERTEX_SHADER, GL_COMPILE_STATUS, &success);
+  if(!success) {
+    glGetShaderInfoLog(TRIANGLE_VERTEX_SHADER, 512, NULL, infoLog);
+    errorThrow("Vertex shader compilation failed: %s", infoLog);
+  }
+
+  // Fragment shader
+  TRIANGLE_FRAGMENT_SHADER = glCreateShader(GL_FRAGMENT_SHADER);
+  glShaderSource(TRIANGLE_FRAGMENT_SHADER, 1, &TRIANGLE_FRAGMENT_SHADER_SRC, NULL);
+  glCompileShader(TRIANGLE_FRAGMENT_SHADER);
+  glGetShaderiv(TRIANGLE_FRAGMENT_SHADER, GL_COMPILE_STATUS, &success);
+  if(!success) {
+    glGetShaderInfoLog(TRIANGLE_FRAGMENT_SHADER, 512, NULL, infoLog);
+    errorThrow("Fragment shader compilation failed: %s", infoLog);
+  }
+
+  // Shader program
+  TRIANGLE_SHADER_PROGRAM = glCreateProgram();
+  glAttachShader(TRIANGLE_SHADER_PROGRAM, TRIANGLE_VERTEX_SHADER);
+  glAttachShader(TRIANGLE_SHADER_PROGRAM, TRIANGLE_FRAGMENT_SHADER);
+  glBindAttribLocation(TRIANGLE_SHADER_PROGRAM, 0, "position");
+  glBindAttribLocation(TRIANGLE_SHADER_PROGRAM, 1, "color");
+  glLinkProgram(TRIANGLE_SHADER_PROGRAM);
+  glGetProgramiv(TRIANGLE_SHADER_PROGRAM, GL_LINK_STATUS, &success);
+  if(!success) {
+    glGetProgramInfoLog(TRIANGLE_SHADER_PROGRAM, 512, NULL, infoLog);
+    errorThrow("Shader program linking failed: %s", infoLog);
+  }
+
+  // --- VAO/VBO Setup for Triangle ---
+  GLfloat triangleVertices[] = {
+    // Positions      // Colors
+    -0.5f, -0.5f,     1.0f, 0.0f, 0.0f, // Red
+     0.5f, -0.5f,     0.0f, 1.0f, 0.0f, // Green
+     0.0f,  0.5f,     0.0f, 0.0f, 1.0f  // Blue
+  };
+
+  glGenVertexArrays(1, &TRIANGLE_VAO);
+  glGenBuffers(1, &TRIANGLE_VBO);
+
+  glBindVertexArray(TRIANGLE_VAO);
+  glBindBuffer(GL_ARRAY_BUFFER, TRIANGLE_VBO);
+  glBufferData(GL_ARRAY_BUFFER, sizeof(triangleVertices), triangleVertices, GL_STATIC_DRAW);
+
+  // Attribute pointers
+  glEnableVertexAttribArray(0); // position
+  glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), (GLvoid*)0);
+  glEnableVertexAttribArray(1); // color
+  glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), (GLvoid*)(2 * sizeof(GLfloat)));
+
+  glBindBuffer(GL_ARRAY_BUFFER, 0);
+  glBindVertexArray(0);
+
   // Create back buffer.
-  renderBackBufferInit();
+  // renderBackBufferInit();
   
   // Init other things
-  renderTextInit();
-  renderSceneInit();
+  // renderTextInit();
+  // renderSceneInit();
   
   // Mark ready.
   RENDER_RUNNING = true;
@@ -83,31 +187,48 @@ errorret_t renderDraw(void) {
   }
 
   // Bind the backbuffer
-  renderBackBufferBind();
+  // renderBackBufferBind();
 
   // Draw everything
-  renderSceneDraw();
-  renderConsoleDraw();
+  // renderSceneDraw();
+  // renderConsoleDraw();
 
   // Unbind the backbuffer
-  renderBackBufferUnbind();
-  renderBackBufferDraw();
+  // renderBackBufferUnbind();
+  // renderBackBufferDraw();
+  
+  glClearColor(0.392f, 0.584f, 0.929f, 1.0f);
+  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
-  // Draw things that render above the back buffer quad.
+  // --- Draw Triangle using VAO/VBO and shader ---
+  glUseProgram(TRIANGLE_SHADER_PROGRAM);
+  glBindVertexArray(TRIANGLE_VAO);
+  glDrawArrays(GL_TRIANGLES, 0, 3);
+  glBindVertexArray(0);
+  glUseProgram(0);
 
-  // Present the renderer
-  SDL_RenderPresent(RENDER_RENDERER);
+  // Present the renderer (swap OpenGL buffers)
+  SDL_GL_SwapWindow(RENDER_WINDOW);
 
   errorOk();
 }
 
 errorret_t renderDispose(void) {
-  renderTextDispose();
-  renderSceneDispose();
-  
-  renderBackBufferDispose();
+  // renderTextDispose();
+  // renderSceneDispose();
+  // renderBackBufferDispose();
 
-  SDL_DestroyRenderer(RENDER_RENDERER);
+  // Delete shader program and shaders
+  if(TRIANGLE_SHADER_PROGRAM) glDeleteProgram(TRIANGLE_SHADER_PROGRAM);
+  if(TRIANGLE_VERTEX_SHADER) glDeleteShader(TRIANGLE_VERTEX_SHADER);
+  if(TRIANGLE_FRAGMENT_SHADER) glDeleteShader(TRIANGLE_FRAGMENT_SHADER);
+
+  // Delete VAO and VBO
+  if(TRIANGLE_VBO) glDeleteBuffers(1, &TRIANGLE_VBO);
+  if(TRIANGLE_VAO) glDeleteVertexArrays(1, &TRIANGLE_VAO);
+
+  // Destroy OpenGL context
+  SDL_GL_DeleteContext(RENDER_GL_CONTEXT);
   SDL_DestroyWindow(RENDER_WINDOW);
   SDL_Quit();
 

src/dusksdl2/dusksdl2.h

@@ -7,4 +7,9 @@
 
 #pragma once
 #include "dusk.h"
-#include <SDL2/SDL.h>
+#include <SDL2/SDL.h>
+
+#define GL_GLEXT_PROTOTYPES
+#include <GL/gl.h>
+#include <GL/glext.h>
+