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

Rendering working

Browse Source
This commit is contained in:
Dominic Masters
2024-10-04 21:51:38 -05:00
parent c1345218a3
commit 69672cf8a6
15 changed files with 394 additions and 12 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/dawn/game.c
View File

@ -12,8 +12,6 @@
#include "rpg/world/maps/testmap.h"
#include "ui/textbox.h"
#include <font8x8_basic.h>
map_t MAP;
game_t GAME;

2
src/dawn/rpg/entity/entity.c
View File

@ -114,7 +114,7 @@ void entityWalk(entity_t *entity, const uint8_t dir) {
entity->y = newY;
entity->state = ENTITY_STATE_WALKING;
entity->walk.time = 0.0f;
entity->walk.time = 0.1f;
}
void entityPositionSet(entity_t *entity, const uint16_t x, const uint16_t y) {

2
src/dawnopengl/display/CMakeLists.txt
View File

@ -5,6 +5,7 @@
# Subdirs
add_subdirectory(shaders)
add_subdirectory(primitives)
# Sources
target_sources(${DAWN_TARGET_NAME}
@ -16,4 +17,5 @@ target_sources(${DAWN_TARGET_NAME}
font.c
texture.c
textureframebuffer.c
colorgl.c
)

13
src/dawnopengl/display/colorgl.c Normal file
View File

@ -0,0 +1,13 @@
/**
* Copyright (c) 2023 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#include "colorgl.h"
#include "assert/assert.h"
void color4fCopy(const color4f_t src, color4f_t dest) {
memcpy(dest, src, sizeof(color4f_t));
}

8
src/dawnopengl/display/colorgl.h
View File

@ -57,3 +57,11 @@ typedef color4f_t color_t;
#define COLOR4F_TRANSPARENT_BLACK COLOR4F(0, 0, 0, 0)
#define COLOR4F_TRANSPARENT_WHITE COLOR4F(1, 1, 1, 0)
#define COLOR4F_TRANSPARENT COLOR4F_TRANSPARENT_BLACK
/**
* Copies a color.
*
* @param src Source color.
* @param dest Destination color.
*/
void color4fCopy(const color4f_t src, color4f_t dest);

94
src/dawnopengl/display/display.c
View File

@ -12,25 +12,117 @@
#include "display/font.h"
#include "display/mesh.h"
#include "display/frame.h"
#include "display/primitives/quad.h"
#include "time.h"
mesh_t FRAMEBUFFER_MESH;
void displayInit() {
simpleTexturedShaderInit();
fontInit();
frameInit();
meshInit(&FRAMEBUFFER_MESH);
meshCreateBuffers(
&FRAMEBUFFER_MESH,
FRAME_WIDTH * FRAME_HEIGHT * PRIMITIVE_QUAD_VERTICE_COUNT,
FRAME_WIDTH * FRAME_HEIGHT * PRIMITIVE_QUAD_INDICE_COUNT
);
}
void displayUpdate() {
frameUpdate();
size_t quadIndex = 0;
vec4_t uvs;
vec4_t positions;
uint8_t color;
color4f_t glColor;
for(uint32_t x = 0; x < FRAME_WIDTH; x++) {
for(uint32_t y = 0; y < FRAME_HEIGHT; y++) {
char_t c = FRAME_BUFFER[y * FRAME_WIDTH + x];
if(c == '\0' || c == ' ') continue;
color = FRAME_COLOR[y * FRAME_WIDTH + x];
switch(color) {
case COLOR_BLACK:
color4fCopy(COLOR4F_BLACK, glColor);
break;
case COLOR_RED:
color4fCopy(COLOR4F_RED, glColor);
break;
case COLOR_GREEN:
color4fCopy(COLOR4F_GREEN, glColor);
break;
case COLOR_BLUE:
color4fCopy(COLOR4F_BLUE, glColor);
break;
case COLOR_YELLOW:
color4fCopy(COLOR4F_YELLOW, glColor);
break;
case COLOR_MAGENTA:
color4fCopy(COLOR4F_MAGENTA, glColor);
break;
case COLOR_CYAN:
color4fCopy(COLOR4F_CYAN, glColor);
break;
case COLOR_WHITE:
color4fCopy(COLOR4F_WHITE, glColor);
break;
default:
assertUnreachable("Unknown color: %d", color);
break;
}
fontCharGetUV(c, uvs);
positions[0] = x * 8;
positions[1] = y * 8;
positions[2] = positions[0] + 8;
positions[3] = positions[1] + 8;
primitiveQuadBuffer(
&FRAMEBUFFER_MESH,
(vec2_t){positions[0], positions[1]},
(vec2_t){positions[2], positions[3]},
(vec2_t){uvs[0], uvs[1]},
(vec2_t){uvs[2], uvs[3]},
glColor,
quadIndex * PRIMITIVE_QUAD_VERTICE_COUNT,
quadIndex * PRIMITIVE_QUAD_INDICE_COUNT
);
quadIndex++;
}
}
backBufferBind();
backBufferClear();
mat4_t view, projection, model;
glm_mat4_identity(projection);
glm_ortho(0.0f, (float_t)BACK_BUFFER_WIDTH, (float_t)BACK_BUFFER_HEIGHT, 0.0f, 0.0f, 1.0f, projection);
simpleTexturedShaderSetProjection(projection);
glm_mat4_identity(view);
glm_lookat((vec3_t){0.0f, 0.0f, 1.0f}, (vec3_t){0.0f, 0.0f, 0.0f}, (vec3_t){0.0f, 1.0f, 0.0f}, view);
simpleTexturedShaderSetView(view);
glm_mat4_identity(model);
simpleTexturedShaderSetModel(model);
simpleTexturedShaderBind();
simpleTexturedShaderSetTexture(&FONT.texture);
simpleTexturedShaderSetColor(COLOR4F_WHITE);
meshDraw(
&FRAMEBUFFER_MESH,
MESH_DRAW_MODE_TRIANGLES,
0, quadIndex * PRIMITIVE_QUAD_INDICE_COUNT
);
}
void displayDispose() {
simpleTexturedShaderDispose();
fontDispose();
meshDispose(&FRAMEBUFFER_MESH);
}

46
src/dawnopengl/display/font.c
View File

@ -6,7 +6,11 @@
*/
#include "font.h"
#include <font8x8.h>
#ifndef FONT8X8_BASIC_H
#include <font8x8_basic.h>
#define FONT8X8_BASIC_H
#endif
font_t FONT;
@ -15,14 +19,50 @@ void fontInit() {
// font is uint8_t[8] * count of chars
size_t charCount = sizeof(font8x8_basic) / 8;
size_t totalPixels = charCount * 8 * 8;
int32_t width = (int32_t)(totalPixels / 8);
int32_t height = 8;
int32_t totalPixels = charCount * 8 * 8;
textureInit(
&FONT.texture,
totalPixels / 8, 8,
width,
height,
TEXTURE_FORMAT_R,
TEXTURE_DATA_FORMAT_UNSIGNED_BYTE
);
FONT.texture.filterModeMag = TEXTURE_FILTER_MODE_NEAREST;
FONT.texture.filterModeMin = TEXTURE_FILTER_MODE_NEAREST;
uint8_t *pixels = (uint8_t*)malloc(totalPixels);
for(size_t i = 0; i < charCount; i++) {
for(size_t y = 0; y < 8; y++) {
for(size_t x = 0; x < 8; x++) {
uint8_t bit = (font8x8_basic[i][y] >> x) & 1;
pixels[(i * 8) + (y * 8 * charCount) + x] = bit * 255;
}
}
}
textureBuffer(&FONT.texture, pixels);
free(pixels);
}
void fontCharGetUV(const char_t c, vec4_t out) {
size_t charCount = sizeof(font8x8_basic) / 8;
int32_t index = (int32_t)c;
if(index >= charCount) index = 0;
int32_t x = index % charCount;
int32_t y = 0;
float_t width = (float_t)FONT.texture.width;
float_t height = (float_t)FONT.texture.height;
out[0] = (float_t)x * (8.0f / width);
out[1] = (float_t)y * (8.0f / height);
out[2] = out[0] + (8.0f / width);
out[3] = out[1] + (8.0f / height);
}
void fontDispose() {

8
src/dawnopengl/display/font.h
View File

@ -19,6 +19,14 @@ extern font_t FONT;
*/
void fontInit();
/**
* Gets the UV coordinates for a character.
*
* @param c Character to get UV coordinates for.
* @return UV coordinates for the character.
*/
void fontCharGetUV(const char_t c, vec4_t out);
/**
* Disposes of the render font.
*/

65
src/dawnopengl/display/mesh.c
View File

@ -46,6 +46,7 @@ void meshCreateBuffers(
size_t sizePos = sizeof(vec3_t) * verticeCount;
size_t sizeInds = sizeof(meshindice_t) * indiceCount;
size_t sizeCoords = sizeof(vec2_t) * verticeCount;
size_t sizeColors = sizeof(color4f_t) * verticeCount;
// Generate vertex array, I don't think I need to do this tbh.
glGenVertexArrays(1, &mesh->vertexArray);
@ -74,8 +75,9 @@ void meshCreateBuffers(
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mesh->indexBuffer);
assertNoGLError();
glBufferData(GL_ARRAY_BUFFER, sizePos+sizeCoords, 0, GL_DYNAMIC_DRAW);
glBufferData(GL_ARRAY_BUFFER, sizePos+sizeCoords+sizeColors, 0, GL_DYNAMIC_DRAW);
assertNoGLError();
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeInds, 0, GL_DYNAMIC_DRAW);
assertNoGLError();
@ -99,6 +101,16 @@ void meshCreateBuffers(
assertNoGLError();
glEnableVertexAttribArray(1);
assertNoGLError();
offset += sizeCoords;
glVertexAttribPointer(
2, sizeof(color4f_t) / sizeof(float_t),
GL_FLOAT, GL_FALSE,
0, (void *)offset
);
assertNoGLError();
glEnableVertexAttribArray(2);
assertNoGLError();
}
void meshDestroyBuffers(mesh_t *mesh) {
@ -207,6 +219,47 @@ void meshBufferCoordinates(
assertNoGLError();
}
void meshBufferColors(
const mesh_t *mesh,
const color4f_t *colors,
const size_t position,
const size_t count
) {
assertNotNull(mesh, "meshBufferColors: Mesh cannot be null");
assertNotNull(
colors,
"meshBufferColors: Colors cannot be null"
);
assertTrue(
position >= 0 && position < mesh->verticeCount,
"meshBufferColors: Position must be within range"
);
assertTrue(
position+count <= mesh->verticeCount,
"meshBufferColors: Position + count must be within range"
);
assertTrue(
count > 0,
"meshBufferColors: Count must be greater than zero"
);
size_t offsetColors = (
(sizeof(vec3_t) * mesh->verticeCount) +
(sizeof(vec2_t) * mesh->verticeCount) +
(sizeof(color4f_t) * position)
);
glBindBuffer(GL_ARRAY_BUFFER, mesh->vertexBuffer);
assertNoGLError();
glBufferSubData(
GL_ARRAY_BUFFER,
offsetColors,
sizeof(color4f_t) * count,
(void*)colors
);
assertNoGLError();
}
void meshBufferIndices(
const mesh_t *mesh,
const meshindice_t *indices,
@ -293,6 +346,16 @@ void meshDraw(
glEnableVertexAttribArray(1);
assertNoGLError();
offset += sizeof(vec2_t) * mesh->verticeCount;
glVertexAttribPointer(
2, sizeof(color4f_t) / sizeof(float_t),
GL_FLOAT, GL_FALSE,
0, (void*)offset
);
assertNoGLError();
glEnableVertexAttribArray(2);
assertNoGLError();
// Render the elements.
glDrawElements(
mode,

16
src/dawnopengl/display/mesh.h
View File

@ -8,6 +8,7 @@
#pragma once
#include "dawn.h"
#include "dawnopengl.h"
#include "colorgl.h"
extern int32_t MESH_ACTIVE_COUNT;
@ -96,6 +97,21 @@ void meshBufferCoordinates(
const size_t count
);
/**
* Write colors to the mesh.
*
* @param mesh Mesh to write to.
* @param colors Array of colors to write.
* @param position Position, within the buffer, to write to.
* @param count How many colors are in the array.
*/
void meshBufferColors(
const mesh_t *mesh,
const color4f_t *colors,
const size_t position,
const size_t count
);
/**
* Write indices to the mesh.
*

10
src/dawnopengl/display/primitives/CMakeLists.txt Normal file
View File

@ -0,0 +1,10 @@
# Copyright (c) 2023 Dominic Masters
#
# This software is released under the MIT License.
# https://opensource.org/licenses/MIT
# Sources
target_sources(${DAWN_TARGET_NAME}
PRIVATE
quad.c
)

76
src/dawnopengl/display/primitives/quad.c Normal file
View File

@ -0,0 +1,76 @@
/**
* Copyright (c) 2023 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#include "quad.h"
void primitiveQuadBuffer(
mesh_t *mesh,
const vec2_t xy0,
const vec2_t xy1,
const vec2_t uv0,
const vec2_t uv1,
const color4f_t color,
const size_t verticeIndex,
const size_t indiceIndex
) {
meshBufferPositions(
mesh,
(vec3_t[]){
{ xy0[0], xy0[1], 0.0f },
{ xy1[0], xy0[1], 0.0f },
{ xy1[0], xy1[1], 0.0f },
{ xy0[0], xy1[1], 0.0f }
},
verticeIndex,
PRIMITIVE_QUAD_VERTICE_COUNT
);
primitiveQuadBufferCoordinates(mesh, uv0, uv1, verticeIndex);
meshBufferIndices(
mesh,
(meshindice_t[]){
verticeIndex + 0, verticeIndex + 1, verticeIndex + 2,
verticeIndex + 2, verticeIndex + 3, verticeIndex + 0
},
indiceIndex,
PRIMITIVE_QUAD_INDICE_COUNT
);
color4f_t colors[PRIMITIVE_QUAD_VERTICE_COUNT];
color4fCopy(color, colors[0]);
color4fCopy(color, colors[1]);
color4fCopy(color, colors[2]);
color4fCopy(color, colors[3]);
meshBufferColors(
mesh,
colors,
verticeIndex,
PRIMITIVE_QUAD_VERTICE_COUNT
);
}
void primitiveQuadBufferCoordinates(
mesh_t *mesh,
const vec2_t uv0,
const vec2_t uv1,
int32_t verticeIndex
) {
meshBufferCoordinates(
mesh,
(vec2_t[]){
{ uv0[0], uv0[1] },
{ uv1[0], uv0[1] },
{ uv1[0], uv1[1] },
{ uv0[0], uv1[1] }
},
verticeIndex,
PRIMITIVE_QUAD_VERTICE_COUNT
);
}

50
src/dawnopengl/display/primitives/quad.h Normal file
View File

@ -0,0 +1,50 @@
/**
* Copyright (c) 2023 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "display/mesh.h"
#define PRIMITIVE_QUAD_VERTICE_COUNT 4
#define PRIMITIVE_QUAD_INDICE_COUNT 6
/**
* Buffers a quad into the mesh.
*
* @param mesh The mesh to buffer into.
* @param xy0 The first xy coordinate.
* @param xy1 The second xy coordinate.
* @param uv0 The first uv coordinate.
* @param uv1 The second uv coordinate.
* @param color The color of the quad.
* @param verticeIndex The vertice index to start at.
* @param indiceIndex The indice index to start at.
*/
void primitiveQuadBuffer(
mesh_t *mesh,
const vec2_t xy0,
const vec2_t xy1,
const vec2_t uv0,
const vec2_t uv1,
const color4f_t color,
const size_t verticeIndex,
const size_t indiceIndex
);
/**
* Buffers quad uv coordinates into the mesh.
*
* @param mesh The mesh to buffer into.
* @param uv0 The first uv coordinate.
* @param uv1 The second uv coordinate.
* @param verticeIndex The vertice index to start at.
*/
void primitiveQuadBufferCoordinates(
mesh_t *mesh,
const vec2_t uv0,
const vec2_t uv1,
int32_t verticeIndex
);

8
src/dawnopengl/display/shaders/simpletexturedshader.c
View File

@ -16,24 +16,30 @@ void simpleTexturedShaderInit() {
"#version 330 core\n"
"layout (location = 0) in vec3 aPos;\n"
"layout (location = 1) in vec2 aTexCoord;\n"
"layout (location = 2) in vec4 aColor;\n"
"uniform mat4 u_Projection;\n"
"uniform mat4 u_View;\n"
"uniform mat4 u_Model;\n"
"out vec2 o_TextCoord;\n"
"out vec4 v_Color;\n"
"void main() {\n"
"gl_Position = u_Projection * u_View * u_Model * vec4(aPos, 1.0);\n"
"o_TextCoord = vec2(aTexCoord.x, aTexCoord.y);\n"
"v_Color = aColor;\n"
"}",
// Fragment Shader
"#version 330 core\n"
"in vec2 o_TextCoord;\n"
"in vec4 v_Color;\n"
"out vec4 o_Color;\n"
"uniform vec4 u_Color;\n"
"uniform bool u_HasTexture;\n"
"uniform sampler2D u_Text;\n"
"void main() {\n"
"if(u_HasTexture) {\n"
"o_Color = texture(u_Text, o_TextCoord) * u_Color;\n"
"vec4 texColor = texture(u_Text, o_TextCoord);\n"
"if(texColor.r < 0.1) discard;\n"
"o_Color = u_Color * v_Color * vec4(1.0, 1.0, 1.0, texColor.r);\n"
"} else {\n"
"o_Color = u_Color;"
"}\n"

4
src/dawnterm/display/frame.h
View File

@ -8,8 +8,8 @@
#pragma once
#include "display/color.h"
#define FRAME_WIDTH 320/8
#define FRAME_HEIGHT 240/8
#define FRAME_WIDTH 640/8
#define FRAME_HEIGHT 480/8
extern char_t FRAME_BUFFER[FRAME_HEIGHT * FRAME_WIDTH];