YourWishes/dusk
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Pull shader code into main #1

Merged
YourWishes merged 4 commits from shader into main 2026-03-22 15:46:37 +00:00
Conversation 0 Commits 4 Files Changed 41 +303 -140
11 changed files with 303 additions and 140 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit 66ebcb1608 - Show all commits

1
cmake/targets/linux.cmake
View File

@@ -30,7 +30,6 @@ target_compile_definitions(${DUSK_LIBRARY_TARGET_NAME} PUBLIC
DUSK_OPENGL DUSK_OPENGL
DUSK_LINUX DUSK_LINUX
DUSK_DISPLAY_SIZE_DYNAMIC DUSK_DISPLAY_SIZE_DYNAMIC
DUSK_OPENGL_SHADER
DUSK_DISPLAY_WIDTH_DEFAULT=640 DUSK_DISPLAY_WIDTH_DEFAULT=640
DUSK_DISPLAY_HEIGHT_DEFAULT=480 DUSK_DISPLAY_HEIGHT_DEFAULT=480
DUSK_DISPLAY_SCREEN_HEIGHT=240 DUSK_DISPLAY_SCREEN_HEIGHT=240

1
cmake/targets/psp.cmake
View File

@@ -36,6 +36,7 @@ target_compile_definitions(${DUSK_LIBRARY_TARGET_NAME} PUBLIC
DUSK_PSP DUSK_PSP
DUSK_INPUT_GAMEPAD DUSK_INPUT_GAMEPAD
DUSK_PLATFORM_ENDIAN_LITTLE DUSK_PLATFORM_ENDIAN_LITTLE
DUSK_OPENGL_LEGACY
DUSK_DISPLAY_WIDTH=480 DUSK_DISPLAY_WIDTH=480
DUSK_DISPLAY_HEIGHT=272 DUSK_DISPLAY_HEIGHT=272
) )

70
src/dusk/display/display.c
View File

@@ -17,6 +17,8 @@
#include "util/memory.h" #include "util/memory.h"
#include "util/string.h" #include "util/string.h"
#include "asset/asset.h" #include "asset/asset.h"
#include "display/shader/shaderunlit.h"
#include "time/time.h"
display_t DISPLAY = { 0 }; display_t DISPLAY = { 0 };
@@ -27,6 +29,7 @@ errorret_t displayInit(void) {
errorChain(displayPlatformInit()); errorChain(displayPlatformInit());
#endif #endif
errorChain(shaderInit(&SHADER_UNLIT, &SHADER_UNLIT_DEFINITION));
errorChain(quadInit()); errorChain(quadInit());
errorChain(frameBufferInitBackBuffer()); errorChain(frameBufferInitBackBuffer());
errorChain(spriteBatchInit()); errorChain(spriteBatchInit());
@@ -52,7 +55,71 @@ errorret_t displayUpdate(void) {
SCREEN.background SCREEN.background
); );
errorCatch(errorPrint(sceneRender())); errorChain(shaderBind(&SHADER_UNLIT));
mat4 proj;
glm_mat4_identity(proj);
glm_ortho(0.0f, (float_t)SCREEN.width, (float_t)SCREEN.height, 0.0f, -1.0f, 1.0f, proj);
mat4 view;
glm_mat4_identity(view);
mat4 model;
glm_mat4_identity(model);
glm_translate(model, (vec3){
sinf(TIME.time * 10.0f) * 30.0f + 100.0f,
cosf(TIME.time * 10.0f) * 50.0f + 100.0f,
0.0f
});
errorChain(shaderSetMatrix(&SHADER_UNLIT, SHADER_UNLIT_PROJECTION, proj));
errorChain(shaderSetMatrix(&SHADER_UNLIT, SHADER_UNLIT_VIEW, view));
errorChain(shaderSetMatrix(&SHADER_UNLIT, SHADER_UNLIT_MODEL, model));
meshvertex_t verts[6] = {
{
.pos = { 0.0f, 0.0f, 0.0f },
.uv = { 0.0f, 0.0f },
.color = COLOR_WHITE
},
{
.pos = { 100.0f, 0.0f, 0.0f },
.uv = { 1.0f, 0.0f },
.color = COLOR_WHITE
},
{
.pos = { 100.0f, 100.0f, 0.0f },
.uv = { 1.0f, 1.0f },
.color = COLOR_WHITE
},
{
.pos = { 100.0f, 100.0f, 0.0f },
.uv = { 1.0f, 1.0f },
.color = COLOR_WHITE
},
{
.pos = { 0.0f, 100.0f, 0.0f },
.uv = { 0.0f, 1.0f },
.color = COLOR_WHITE
},
{
.pos = { 0.0f, 0.0f, 0.0f },
.uv = { 0.0f, 0.0f },
.color = COLOR_WHITE
}
};
mesh_t mesh;
meshInit(&mesh, MESH_PRIMITIVE_TYPE_TRIANGLES, 6, verts);
meshDraw(&mesh, 0, -1);
meshDispose(&mesh);
// errorCatch(errorPrint(sceneRender()));
// Render UI // Render UI
// uiRender(); // uiRender();
@@ -69,6 +136,7 @@ errorret_t displayUpdate(void) {
} }
errorret_t displayDispose(void) { errorret_t displayDispose(void) {
errorChain(shaderDispose(&SHADER_UNLIT));
errorChain(spriteBatchDispose()); errorChain(spriteBatchDispose());
screenDispose(); screenDispose();
errorChain(textDispose()); errorChain(textDispose());

1
src/dusk/display/shader/shaderunlit.h
View File

@@ -13,3 +13,4 @@
#define SHADER_UNLIT_MODEL "u_Model" #define SHADER_UNLIT_MODEL "u_Model"
extern shaderdefinition_t SHADER_UNLIT_DEFINITION; extern shaderdefinition_t SHADER_UNLIT_DEFINITION;
static shader_t SHADER_UNLIT;

4
src/duskgl/display/displaygl.c
View File

@@ -8,6 +8,8 @@
#include "displaygl.h" #include "displaygl.h"
errorret_t displayOpenGLInit(void) { errorret_t displayOpenGLInit(void) {
glDisable(GL_CULL_FACE); glDisable(GL_CULL_FACE);
// glDisable(GL_LIGHTING);// PSP defaults this on? // glDisable(GL_LIGHTING);// PSP defaults this on?
// glShadeModel(GL_SMOOTH); // Fixes color on PSP? // glShadeModel(GL_SMOOTH); // Fixes color on PSP?
@@ -29,7 +31,5 @@ errorret_t displayOpenGLInit(void) {
// glEnableClientState(GL_VERTEX_ARRAY); // glEnableClientState(GL_VERTEX_ARRAY);
// errorChain(errorGLCheck()); // errorChain(errorGLCheck());
errorChain(shaderInit(&testShader, &SHADER_UNLIT_DEFINITION));
errorOk(); errorOk();
} }

3
src/duskgl/display/displaygl.h
View File

@@ -7,9 +7,6 @@
#pragma once #pragma once
#include "error/errorgl.h" #include "error/errorgl.h"
#include "display/shader/shaderunlit.h"
static shadergl_t testShader;
/** /**
* Initializes the OpenGL specific contexts for rendering. * Initializes the OpenGL specific contexts for rendering.

132
src/duskgl/display/mesh/meshgl.c
View File

@@ -21,7 +21,74 @@ errorret_t meshInitGL(
mesh->primitiveType = primitiveType; mesh->primitiveType = primitiveType;
mesh->vertexCount = vertexCount; mesh->vertexCount = vertexCount;
mesh->vertices = vertices;
#ifdef DUSK_OPENGL_LEGACY
mesh->vertices = vertices;
#else
// Generate Vertex Buffer Object
glGenBuffers(1, &mesh->vboId);
errorChain(errorGLCheck());
glBindBuffer(GL_ARRAY_BUFFER, mesh->vboId);
errorChain(errorGLCheck());
glBufferData(
GL_ARRAY_BUFFER,
vertexCount * sizeof(meshvertex_t),
vertices,
GL_STATIC_DRAW
);
errorChain(errorGLCheck());
// Generate Vertex Array Object
glGenVertexArrays(1, &mesh->vaoId);
errorChain(errorGLCheck());
glBindVertexArray(mesh->vaoId);
errorChain(errorGLCheck());
glBindBuffer(GL_ARRAY_BUFFER, mesh->vboId);
errorChain(errorGLCheck());
// Set up vertex attribute pointers
glVertexAttribPointer(
0,
MESH_VERTEX_POS_SIZE,
GL_FLOAT,
GL_FALSE,
sizeof(meshvertex_t),
(const GLvoid*)offsetof(meshvertex_t, pos)
);
errorChain(errorGLCheck());
glEnableVertexAttribArray(0);
errorChain(errorGLCheck());
glVertexAttribPointer(
1,
MESH_VERTEX_UV_SIZE,
GL_FLOAT,
GL_FALSE,
sizeof(meshvertex_t),
(const GLvoid*)offsetof(meshvertex_t, uv)
);
errorChain(errorGLCheck());
glEnableVertexAttribArray(1);
errorChain(errorGLCheck());
glVertexAttribPointer(
2,
sizeof(color_t) / sizeof(GLubyte),
GL_UNSIGNED_BYTE,
GL_TRUE,
sizeof(meshvertex_t),
(const GLvoid*)offsetof(meshvertex_t, color)
);
errorChain(errorGLCheck());
glEnableVertexAttribArray(2);
errorChain(errorGLCheck());
// Unbind VAO and VBO to prevent accidental modification
glBindBuffer(GL_ARRAY_BUFFER, 0);
errorChain(errorGLCheck());
glBindVertexArray(0);
errorChain(errorGLCheck());
#endif
errorOk(); errorOk();
} }
@@ -31,30 +98,40 @@ errorret_t meshDrawGL(
const int32_t offset, const int32_t offset,
const int32_t count const int32_t count
) { ) {
// PSP style pointer legacy OpenGL #ifdef DUSK_OPENGL_LEGACY
const GLsizei stride = sizeof(meshvertex_t); // Legacy pointer style rendering
const GLsizei stride = sizeof(meshvertex_t);
// glColorPointer( glColorPointer(
// sizeof(color4b_t), sizeof(color4b_t),
// GL_UNSIGNED_BYTE, GL_UNSIGNED_BYTE,
// stride, stride,
// (const GLvoid*)&mesh->vertices[offset].color (const GLvoid*)&mesh->vertices[offset].color
// ); );
// glTexCoordPointer( glTexCoordPointer(
// MESH_VERTEX_UV_SIZE, MESH_VERTEX_UV_SIZE,
// GL_FLOAT, GL_FLOAT,
// stride, stride,
// (const GLvoid*)&mesh->vertices[offset].uv (const GLvoid*)&mesh->vertices[offset].uv
// ); );
// glVertexPointer( glVertexPointer(
// MESH_VERTEX_POS_SIZE, MESH_VERTEX_POS_SIZE,
// GL_FLOAT, GL_FLOAT,
// stride, stride,
// (const GLvoid*)&mesh->vertices[offset].pos (const GLvoid*)&mesh->vertices[offset].pos
// ); );
// glDrawArrays(mesh->primitiveType, offset, count); glDrawArrays(mesh->primitiveType, offset, count);
// errorChain(errorGLCheck()); errorChain(errorGLCheck());
#else
// Modern VAO/VBO rendering
glBindVertexArray(mesh->vaoId);
errorChain(errorGLCheck());
glDrawArrays(mesh->primitiveType, offset, count);
errorChain(errorGLCheck());
glBindVertexArray(0);
errorChain(errorGLCheck());
#endif
errorOk(); errorOk();
} }
@@ -64,6 +141,13 @@ int32_t meshGetVertexCountGL(const meshgl_t *mesh) {
} }
errorret_t meshDisposeGL(meshgl_t *mesh) { errorret_t meshDisposeGL(meshgl_t *mesh) {
// No dynamic resources to free for this mesh implementation #ifdef DUSK_OPENGL_LEGACY
// No dynamic resources to free for this mesh implementation
#else
glDeleteBuffers(1, &mesh->vboId);
errorChain(errorGLCheck());
glDeleteVertexArrays(1, &mesh->vaoId);
errorChain(errorGLCheck());
#endif
errorOk(); errorOk();
} }

8
src/duskgl/display/mesh/meshgl.h
View File

@@ -16,9 +16,15 @@ typedef enum {
} meshprimitivetypegl_t; } meshprimitivetypegl_t;
typedef struct { typedef struct {
const meshvertex_t *vertices;
int32_t vertexCount; int32_t vertexCount;
meshprimitivetypegl_t primitiveType; meshprimitivetypegl_t primitiveType;
#ifdef DUSK_OPENGL_LEGACY
const meshvertex_t *vertices;
#else
GLuint vaoId;
GLuint vboId;
#endif
} meshgl_t; } meshgl_t;
/** /**

196
src/duskgl/display/shader/shadergl.c
View File

@@ -12,116 +12,120 @@
errorret_t shaderInitGL(shadergl_t *shader, const shaderdefinitiongl_t *def) { errorret_t shaderInitGL(shadergl_t *shader, const shaderdefinitiongl_t *def) {
assertNotNull(shader, "Shader cannot be null"); assertNotNull(shader, "Shader cannot be null");
assertNotNull(def, "Shader definition cannot be null"); assertNotNull(def, "Shader definition cannot be null");
memoryZero(shader, sizeof(shadergl_t)); memoryZero(shader, sizeof(shadergl_t));
// Create vertex shader #ifdef DUSK_OPENGL_LEGACY
shader->vertexShaderId = glCreateShader(GL_VERTEX_SHADER); // No initialization needed for legacy shader
errorret_t err = errorGLCheck(); errorOk();
errorChain(err); #else
// Create vertex shader
glShaderSource(shader->vertexShaderId, 1, &def->vert, NULL); shader->vertexShaderId = glCreateShader(GL_VERTEX_SHADER);
err = errorGLCheck(); errorret_t err = errorGLCheck();
if(err.code != ERROR_OK) {
glDeleteShader(shader->vertexShaderId);
errorChain(err); errorChain(err);
}
glCompileShader(shader->vertexShaderId); glShaderSource(shader->vertexShaderId, 1, &def->vert, NULL);
err = errorGLCheck(); err = errorGLCheck();
if(err.code != ERROR_OK) { if(err.code != ERROR_OK) {
glDeleteShader(shader->vertexShaderId); glDeleteShader(shader->vertexShaderId);
errorChain(err); errorChain(err);
} }
GLint ok = 0; glCompileShader(shader->vertexShaderId);
glGetShaderiv(shader->vertexShaderId, GL_COMPILE_STATUS, &ok); err = errorGLCheck();
if(!ok) { if(err.code != ERROR_OK) {
GLchar log[1024]; glDeleteShader(shader->vertexShaderId);
glGetShaderInfoLog(shader->vertexShaderId, sizeof(log), NULL, log); errorChain(err);
glDeleteShader(shader->vertexShaderId); }
errorThrow("Vertex shader compilation failed: %s", log);
}
// Create fragment shader GLint ok = 0;
shader->fragmentShaderId = glCreateShader(GL_FRAGMENT_SHADER); glGetShaderiv(shader->vertexShaderId, GL_COMPILE_STATUS, &ok);
err = errorGLCheck(); if(!ok) {
if(err.code != ERROR_OK) { GLchar log[1024];
glDeleteShader(shader->vertexShaderId); glGetShaderInfoLog(shader->vertexShaderId, sizeof(log), NULL, log);
errorChain(err); glDeleteShader(shader->vertexShaderId);
} errorThrow("Vertex shader compilation failed: %s", log);
}
glShaderSource(shader->fragmentShaderId, 1, &def->frag, NULL); // Create fragment shader
err = errorGLCheck(); shader->fragmentShaderId = glCreateShader(GL_FRAGMENT_SHADER);
if(err.code != ERROR_OK) { err = errorGLCheck();
glDeleteShader(shader->vertexShaderId); if(err.code != ERROR_OK) {
glDeleteShader(shader->fragmentShaderId); glDeleteShader(shader->vertexShaderId);
errorChain(err); errorChain(err);
} }
glCompileShader(shader->fragmentShaderId); glShaderSource(shader->fragmentShaderId, 1, &def->frag, NULL);
err = errorGLCheck(); err = errorGLCheck();
if(err.code != ERROR_OK) { if(err.code != ERROR_OK) {
glDeleteShader(shader->vertexShaderId); glDeleteShader(shader->vertexShaderId);
glDeleteShader(shader->fragmentShaderId); glDeleteShader(shader->fragmentShaderId);
errorChain(err); errorChain(err);
} }
glGetShaderiv(shader->fragmentShaderId, GL_COMPILE_STATUS, &ok); glCompileShader(shader->fragmentShaderId);
if(!ok) { err = errorGLCheck();
GLchar log[1024]; if(err.code != ERROR_OK) {
glGetShaderInfoLog(shader->fragmentShaderId, sizeof(log), NULL, log); glDeleteShader(shader->vertexShaderId);
glDeleteShader(shader->vertexShaderId); glDeleteShader(shader->fragmentShaderId);
glDeleteShader(shader->fragmentShaderId); errorChain(err);
errorThrow("Fragment shader compilation failed: %s", log); }
}
// Create shader program glGetShaderiv(shader->fragmentShaderId, GL_COMPILE_STATUS, &ok);
shader->shaderProgramId = glCreateProgram(); if(!ok) {
err = errorGLCheck(); GLchar log[1024];
if(err.code != ERROR_OK) { glGetShaderInfoLog(shader->fragmentShaderId, sizeof(log), NULL, log);
glDeleteShader(shader->vertexShaderId); glDeleteShader(shader->vertexShaderId);
glDeleteShader(shader->fragmentShaderId); glDeleteShader(shader->fragmentShaderId);
errorChain(err); errorThrow("Fragment shader compilation failed: %s", log);
} }
glAttachShader(shader->shaderProgramId, shader->vertexShaderId); // Create shader program
err = errorGLCheck(); shader->shaderProgramId = glCreateProgram();
if(err.code != ERROR_OK) { err = errorGLCheck();
glDeleteProgram(shader->shaderProgramId); if(err.code != ERROR_OK) {
glDeleteShader(shader->vertexShaderId); glDeleteShader(shader->vertexShaderId);
glDeleteShader(shader->fragmentShaderId); glDeleteShader(shader->fragmentShaderId);
errorChain(err); errorChain(err);
} }
glAttachShader(shader->shaderProgramId, shader->fragmentShaderId); glAttachShader(shader->shaderProgramId, shader->vertexShaderId);
err = errorGLCheck(); err = errorGLCheck();
if(err.code != ERROR_OK) { if(err.code != ERROR_OK) {
glDeleteProgram(shader->shaderProgramId); glDeleteProgram(shader->shaderProgramId);
glDeleteShader(shader->vertexShaderId); glDeleteShader(shader->vertexShaderId);
glDeleteShader(shader->fragmentShaderId); glDeleteShader(shader->fragmentShaderId);
errorChain(err); errorChain(err);
} }
glLinkProgram(shader->shaderProgramId); glAttachShader(shader->shaderProgramId, shader->fragmentShaderId);
err = errorGLCheck(); err = errorGLCheck();
if(err.code != ERROR_OK) { if(err.code != ERROR_OK) {
glDeleteProgram(shader->shaderProgramId); glDeleteProgram(shader->shaderProgramId);
glDeleteShader(shader->vertexShaderId); glDeleteShader(shader->vertexShaderId);
glDeleteShader(shader->fragmentShaderId); glDeleteShader(shader->fragmentShaderId);
errorChain(err); errorChain(err);
} }
ok = 0; glLinkProgram(shader->shaderProgramId);
glGetProgramiv(shader->shaderProgramId, GL_LINK_STATUS, &ok); err = errorGLCheck();
if(!ok) { if(err.code != ERROR_OK) {
GLchar log[1024]; glDeleteProgram(shader->shaderProgramId);
glGetProgramInfoLog(shader->shaderProgramId, sizeof(log), NULL, log); glDeleteShader(shader->vertexShaderId);
glDeleteProgram(shader->shaderProgramId); glDeleteShader(shader->fragmentShaderId);
glDeleteShader(shader->vertexShaderId); errorChain(err);
glDeleteShader(shader->fragmentShaderId); }
errorThrow("Shader program linking failed: %s", log);
} ok = 0;
glGetProgramiv(shader->shaderProgramId, GL_LINK_STATUS, &ok);
if(!ok) {
GLchar log[1024];
glGetProgramInfoLog(shader->shaderProgramId, sizeof(log), NULL, log);
glDeleteProgram(shader->shaderProgramId);
glDeleteShader(shader->vertexShaderId);
glDeleteShader(shader->fragmentShaderId);
errorThrow("Shader program linking failed: %s", log);
}
#endif
errorOk(); errorOk();
} }

18
src/duskgl/display/shader/shadergl.h
View File

@@ -9,14 +9,22 @@
#include "error/errorgl.h" #include "error/errorgl.h"
typedef struct { typedef struct {
GLuint shaderProgramId; #ifdef DUSK_OPENGL_LEGACY
GLuint vertexShaderId; void *nothing;
GLuint fragmentShaderId; #else
GLuint shaderProgramId;
GLuint vertexShaderId;
GLuint fragmentShaderId;
#endif
} shadergl_t; } shadergl_t;
typedef struct { typedef struct {
const char_t *vert; #ifdef DUSK_OPENGL_LEGACY
const char_t *frag; void *nothing;
#else
const char_t *vert;
const char_t *frag;
#endif
} shaderdefinitiongl_t; } shaderdefinitiongl_t;
/** /**

7
src/duskgl/display/shader/shaderunlitgl.c
View File

@@ -11,22 +11,17 @@ shaderdefinition_t SHADER_UNLIT_DEFINITION = {
.vert = .vert =
"#version 330 core\n" "#version 330 core\n"
"layout(location = 0) in vec3 aPos;\n" "layout(location = 0) in vec3 aPos;\n"
"layout(location = 1) in vec2 aTexCoord;\n"
"uniform mat4 u_Proj;\n" "uniform mat4 u_Proj;\n"
"uniform mat4 u_View;\n" "uniform mat4 u_View;\n"
"uniform mat4 u_Model;\n" "uniform mat4 u_Model;\n"
"out vec2 v_TexCoord;\n"
"void main() {\n" "void main() {\n"
" gl_Position = u_Proj * u_View * u_Model * vec4(aPos, 1.0);\n" " gl_Position = u_Proj * u_View * u_Model * vec4(aPos, 1.0);\n"
" v_TexCoord = aTexCoord;\n"
"}\n", "}\n",
.frag = .frag =
"#version 330 core\n" "#version 330 core\n"
"in vec2 v_TexCoord;\n"
"out vec4 FragColor;\n" "out vec4 FragColor;\n"
"uniform sampler2D u_Texture;\n"
"void main() {\n" "void main() {\n"
" FragColor = texture(u_Texture, v_TexCoord);\n" " FragColor = vec4(1.0, 0.0, 0.0, 1.0);\n"
"}\n" "}\n"
}; };