#include <SDL2/SDL.h>
#include <glad/glad.h>
#define MINIAUDIO_IMPLEMENTATION
#include "miniaudio.h"
#include <stdio.h>
#include <ft2build.h>
#include FT_FREETYPE_H
#include <stdint.h>
typedef uint8_t u8;
typedef uint16_t u16;
typedef uint32_t u32;
typedef uint64_t u64;
typedef int8_t s8;
typedef int16_t s16;
typedef int32_t s32;
typedef int64_t s64;
typedef float r32;
typedef double r64;
typedef u8 b8;
#include "memory/arena.h"
#include "math.h"
struct Str256 {
char buffer[256];
u32 size;
};
void str_init(Str256 *str) {
memset(str->buffer, 0, 256*sizeof(unsigned char));
str->size = 0;
}
Str256 str256(const char *cstr) {
Str256 str;
str_init(&str);
u32 size = strlen(cstr);
memcpy((void*)str.buffer, (void*)cstr, size);
str.size = size;
return str;
}
void str_pushc(Str256 *str, char c) {
if (str->size + 1 > 256) {
return;
}
str->buffer[str->size] = c;
str->size++;
}
void str_push256(Str256 *str, Str256 to_push) {
u32 available_space = 256 - str->size;
SDL_assert(available_space >= to_push.size);
memcpy((void*)&str->buffer[str->size], (void*)to_push.buffer, to_push.size);
str->size += to_push.size;
}
void str_clear(Str256 *str) {
memset(str->buffer, 0, str->size * sizeof(unsigned char));
str->size = 0;
}
enum PMoveState {
NO_MOVE = 0,
MOVE = 1,
FALL_MOVE = 2,
};
enum PlatformKey {
PK_NIL = 0,
PK_W = 1,
PK_A = 2,
PK_S = 3,
PK_D = 4,
};
struct TextChar {
s64 advance;
Vec2 size;
Vec2 bearing;
};
struct TextState {
u32 pixel_size;
u32 texture_atlas_id;
u32 sp;
u32 vao;
u32 vbo;
u32 chunk_size;
s32* char_indexes;
Mat4* transforms;
TextChar* char_map;
};
#define BATCH_SIZE 2000
#define KB(x) (1024 * (x))
#define MB(x) (1024 * KB((x)))
#define GB(x) (1024 * MB((x)))
#include "array/array.cpp"
struct Rect {
Vec2 tl;
Vec2 br;
Vec2 size;
Vec3 position;
};
#define PLAYER_COLORS Vec3{0.45f, 0.8f, 0.2f}
#define OBSTACLE_COLORS Vec3{0.0f, 0.0f, 0.0f}
#define GOAL_COLORS Vec3{1.0f, 0.0f, 0.0f}
#define PLAYER_Z -1.0f
#define OBSTACLE_Z -2.0f
#define GOAL_Z -3.0f
enum ENTITY_TYPE {
PLAYER = 0,
OBSTACLE = 1,
GOAL = 2
};
struct Entity {
// @todo: set a base resolution and design the game elements around it
u32 id;
ENTITY_TYPE type;
// raw property values in pixels
Vec3 raw_position;
Vec2 raw_size;
// these properties will have scaling applied
Vec3 position;
Vec2 size;
Rect bounds;
};
struct EntityInfo {
u32 id;
u32 index; // index into Level->Entities array
};
struct EntityInfoArr {
EntityInfo *buffer;
u32 size;
u32 capacity;
};
#define LEVEL_MAX_ENTITIES 100
const int level_count = 2;
static const char* base_level_path = "./levels/";
static const char *level_names[20] = {
"level0.txt",
"level1.txt",
};
struct Level0x1 {
u32 version = 0x1;
u32 entity_count;
Entity *entities;
};
typedef struct Level0x1 Level;
struct GLRenderer {
// colored quad
b8 cq_init;
u32 cq_sp;
u32 cq_vao;
// camera
b8 cam_update;
Vec3 preset_up_dir;
Vec3 cam_pos;
Vec3 cam_look;
Mat4 cam_view;
Mat4 cam_proj;
// Batched cq
// batching buffer
u32 cq_batch_sp;
u32 cq_batch_vao;
u32 cq_batch_vbo;
u32 cq_batch_count;
r32_array cq_pos_batch;
r32_array cq_mvp_batch;
r32_array cq_color_batch;
// ui text
TextState ui_text;
};
struct Controller {
b8 move_up;
b8 move_down;
b8 move_left;
b8 move_right;
b8 jump;
b8 toggle_gravity;
};
struct FrameTimer {
u64 tCurr;
u64 tPrev;
r64 tDeltaMS;
r64 tDelta;
u64 tFreq;
};
FrameTimer frametimer() {
FrameTimer res = {};
res.tFreq = SDL_GetPerformanceFrequency();
res.tCurr = SDL_GetPerformanceCounter();
res.tPrev = res.tCurr;
res.tDelta = (r64)(res.tCurr - res.tPrev) / (r64)res.tFreq;
res.tDeltaMS = res.tDelta * 1000.0f;
return res;
}
void update_frame_timer(FrameTimer *ft) {
ft->tPrev = ft->tCurr;
ft->tCurr = SDL_GetPerformanceCounter();
ft->tDelta = (r64)(ft->tCurr - ft->tPrev) / (r64)ft->tFreq;
ft->tDeltaMS = ft->tDelta * 1000.0f;
}
void enforce_frame_rate(FrameTimer *ft, u32 target) {
r64 target_frametime = SDL_floor(
1000.0f/(r64)target
);
while(ft->tDeltaMS < target_frametime) {
ft->tCurr = SDL_GetPerformanceCounter();
ft->tDelta = (r64)(ft->tCurr - ft->tPrev) / ft->tFreq;
ft->tDeltaMS = ft->tDelta * 1000.0f;
// pass time
continue;
}
}
struct GameState {
// the default size the game is designed around
Vec2 world_size;
Vec2 screen_size;
// the scaling factor to increase/decrease size of game assets
Vec2 render_scale;
// the smallest size a unit can be. This scales with render_scale
Vec2 atom_size;
// level
// 0: in progress, 1: complete
b8 level_state;
u32 level_index;
Str256 level_name;
Level game_level;
Entity player;
EntityInfo goal;
EntityInfoArr obstacles;
};
Rect rect(Vec3 position, Vec2 size) {
Rect r = {0};
r.tl.x = position.x - size.x;
r.tl.y = position.y + size.y;
r.br.x = position.x + size.x;
r.br.y = position.y - size.y;
return r;
}
void level_load(GameState *state, Arena *level_arena, Str256 level_path) {
// @step: initialise
arena_clear(level_arena);
memset(&state->game_level, 0, sizeof(Level));
state->level_state = 0;
size_t fsize;
char* level_data = (char*)SDL_LoadFile(level_path.buffer, &fsize);
SDL_assert(fsize != 0);
u32 feature_flag = 0;
u32 entity_flag = 0;
u32 entity_id_counter = 0;
Str256 level_property;
str_init(&level_property);
Entity level_entity;
b8 is_comment = 0;
u32 prop_flag = 0;
u32 sub_prop_flag = 0;
// @note: just decide beforehand, that a level should allow (AT MAX) 100 elements
// this should be way overkill
state->game_level.entities = (Entity*)arena_alloc(level_arena, LEVEL_MAX_ENTITIES*sizeof(Entity));
for (int i = 0; i < fsize; i++) {
char ele = level_data[i];
// handling comments in level file
if (ele == '#') {
is_comment = true;
continue;
}
if (ele == '\n' && is_comment) {
is_comment = false;
continue;
}
if (is_comment) {
continue;
}
if (ele == ' ' || ele == '\n') {
switch (prop_flag) {
case 0: {
state->game_level.version = strtol(level_property.buffer, NULL, 16);
str_clear(&level_property);
prop_flag++;
continue;
} break;
case 1: {
level_entity.id = entity_id_counter;
switch (sub_prop_flag) {
case 0: {
// type
level_entity.type = (ENTITY_TYPE)strtol(level_property.buffer, NULL, 10);
// set z index based off of entity type
if (level_entity.type == PLAYER) {
level_entity.raw_position.z = PLAYER_Z;
} else if (level_entity.type == OBSTACLE) {
level_entity.raw_position.z = OBSTACLE_Z;
} else if (level_entity.type == GOAL) {
level_entity.raw_position.z = GOAL_Z;
}
} break;
case 1: {
// posx
level_entity.raw_position.x = strtol(level_property.buffer, NULL, 10);
} break;
case 2: {
// posy
level_entity.raw_position.y = strtol(level_property.buffer, NULL, 10);
} break;
case 3: {
// sizex
level_entity.raw_size.x = strtol(level_property.buffer, NULL, 10);
} break;
case 4: {
// sizey
level_entity.raw_size.y = strtol(level_property.buffer, NULL, 10);
} break;
default: {
} break;
}
str_clear(&level_property);
sub_prop_flag++;
if (ele == '\n') {
state->game_level.entities[state->game_level.entity_count] = level_entity;
state->game_level.entity_count++;
entity_id_counter++;
sub_prop_flag = 0;
memset(&level_entity, 0, sizeof(Entity));
}
SDL_assert(state->game_level.entity_count <= LEVEL_MAX_ENTITIES);
continue;
}
default: {
} break;
}
}
str_pushc(&level_property, ele);
}
// @function: load_entities_info and scale
state->obstacles.buffer = (EntityInfo*)arena_alloc(level_arena, state->game_level.entity_count*sizeof(EntityInfo));
state->obstacles.size = 0;
state->obstacles.capacity = state->game_level.entity_count;
for (u32 i = 0; i < state->game_level.entity_count; i++) {
Entity e = state->game_level.entities[i];
e.position = e.raw_position;
e.size = e.raw_size * state->atom_size * state->render_scale.x;
e.bounds = rect(e.position, e.size);
switch (e.type) {
case PLAYER: {
state->player = e;
} break;
case OBSTACLE: {
EntityInfo o;
o.id = e.id;
o.index = i;
state->obstacles.buffer[state->obstacles.size] = o;
state->obstacles.size++;
} break;
case GOAL: {
EntityInfo o;
o.id = e.id;
o.index = i;
state->goal = o;
} break;
default: {
} break;
}
state->game_level.entities[i] = e;
}
SDL_free(level_data);
}
u32 gl_shader_program(char* vs, char* fs)
{
int status;
char info_log[512];
// =============
// vertex shader
u32 vertex_shader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vertex_shader, 1, &vs, NULL);
glCompileShader(vertex_shader);
glGetShaderiv(vertex_shader, GL_COMPILE_STATUS, &status);
if (status == 0)
{
glGetShaderInfoLog(vertex_shader, 512, NULL, info_log);
printf("== ERROR: Vertex Shader Compilation Failed ==\n");
printf("%s\n", info_log);
}
// ===============
// fragment shader
u32 fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragment_shader, 1, &fs, NULL);
glCompileShader(fragment_shader);
glGetShaderiv(fragment_shader, GL_COMPILE_STATUS, &status);
if (status == 0)
{
glGetShaderInfoLog(fragment_shader, 512, NULL, info_log);
printf("== ERROR: Fragment Shader Compilation Failed ==\n");
printf("%s\n", info_log);
}
// ==============
// shader program
u32 shader_program = glCreateProgram();
glAttachShader(shader_program, vertex_shader);
glAttachShader(shader_program, fragment_shader);
glLinkProgram(shader_program);
glGetProgramiv(shader_program, GL_LINK_STATUS, &status);
if(status == 0)
{
glGetProgramInfoLog(shader_program, 512, NULL, info_log);
printf("== ERROR: Shader Program Linking Failed\n");
printf("%s\n", info_log);
}
glDeleteShader(vertex_shader);
glDeleteShader(fragment_shader);
return shader_program;
}
u32 gl_shader_program_from_path(const char* vspath, const char* fspath)
{
size_t read_count;
char* vs = (char*)SDL_LoadFile(vspath, &read_count);
if (read_count == 0)
{
printf("Error! Failed to read vertex shader file at path %s\n", vspath);
return 0;
}
char* fs = (char*)SDL_LoadFile(fspath, &read_count);
if (read_count == 0)
{
printf("Error! Failed to read fragment shader file at path %s\n", vspath);
return 0;
}
u32 shader_program = gl_shader_program(vs, fs);
SDL_free(vs);
SDL_free(fs);
return shader_program;
}
u32 gl_setup_colored_quad(u32 sp)
{
// @todo: make this use index buffer maybe?
r32 vertices[] = {
-1.0f, -1.0f, 0.0f, // bottom-left
1.0f, -1.0f, 0.0f, // bottom-right
1.0f, 1.0f, 0.0f, // top-right
1.0f, 1.0f, 0.0f, // top-right
-1.0f, 1.0f, 0.0f, // top-left
-1.0f, -1.0f, 0.0f, // bottom-left
};
u32 vao, vbo;
glGenVertexArrays(1, &vao);
glGenBuffers(1, &vbo);
glBindVertexArray(vao);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), &vertices, GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(r32), (void*)0);
glBindVertexArray(0);
// now return or store the vao, vbo state somewhere
return vao;
}
void gl_setup_colored_quad_optimized(
GLRenderer* renderer,
u32 sp
) {
// @todo: make this use index buffer maybe?
glGenVertexArrays(1, &renderer->cq_batch_vao);
glGenBuffers(1, &renderer->cq_batch_vbo);
glBindVertexArray(renderer->cq_batch_vao);
glBindBuffer(GL_ARRAY_BUFFER, renderer->cq_batch_vbo);
glBufferData(
GL_ARRAY_BUFFER, (
renderer->cq_pos_batch.capacity + renderer->cq_color_batch.capacity
) * sizeof(r32), NULL, GL_DYNAMIC_DRAW
);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 4 * sizeof(r32), (void*)0);
glEnableVertexAttribArray(1);
glVertexAttribPointer(
1, 3, GL_FLOAT, GL_FALSE,
3 * sizeof(r32), (void*)(renderer->cq_pos_batch.capacity*sizeof(r32))
);
glBindVertexArray(0);
}
void gl_cq_flush(GLRenderer* renderer) {
glUseProgram(renderer->cq_batch_sp);
glEnable(GL_DEPTH_TEST);
glUniformMatrix4fv(
glGetUniformLocation(renderer->cq_batch_sp, "View"),
1, GL_FALSE, (renderer->cam_view).buffer
);
glUniformMatrix4fv(
glGetUniformLocation(renderer->cq_batch_sp, "Projection"),
1, GL_FALSE, (renderer->cam_proj).buffer
);
glBindBuffer(GL_ARRAY_BUFFER, renderer->cq_batch_vbo);
// fill batch data
// position batch
glBufferSubData(
GL_ARRAY_BUFFER,
0,
renderer->cq_pos_batch.capacity*sizeof(r32),
renderer->cq_pos_batch.buffer
);
// color batch
glBufferSubData(
GL_ARRAY_BUFFER,
renderer->cq_pos_batch.capacity*sizeof(r32),
renderer->cq_color_batch.capacity*sizeof(r32),
(void*)renderer->cq_color_batch.buffer
);
glBindVertexArray(renderer->cq_batch_vao);
glDrawArrays(GL_TRIANGLES, 0, renderer->cq_batch_count*6);
array_clear(&renderer->cq_pos_batch);
array_clear(&renderer->cq_color_batch);
renderer->cq_batch_count = 0;
}
void gl_draw_colored_quad_optimized(
GLRenderer* renderer,
Vec3 position,
Vec2 size,
Vec3 color
) {
Vec4 vertices[6] = {
Vec4{-1.0f, -1.0f, 0.0f, 1.0f},// bottom-left
Vec4{ 1.0f, -1.0f, 0.0f, 1.0f},// bottom-right
Vec4{ 1.0f, 1.0f, 0.0f, 1.0f},// top-right
Vec4{ 1.0f, 1.0f, 0.0f, 1.0f},// top-right
Vec4{-1.0f, 1.0f, 0.0f, 1.0f},// top-left
Vec4{-1.0f, -1.0f, 0.0f, 1.0f} // bottom-left
};
// setting quad size
Mat4 model = diag4m(1.0);
Mat4 scale = scaling_matrix4m(size.x, size.y, 0.0f);
model = multiply4m(scale, model);
// setting quad position
Mat4 translation = translation_matrix4m(position.x, position.y, position.z);
model = multiply4m(translation, model);
Vec4 model_pos;
model_pos = multiply4mv(model, vertices[0]);
vertices[0] = model_pos;
model_pos = multiply4mv(model, vertices[1]);
vertices[1] = model_pos;
model_pos = multiply4mv(model, vertices[2]);
vertices[2] = model_pos;
model_pos = multiply4mv(model, vertices[3]);
vertices[3] = model_pos;
model_pos = multiply4mv(model, vertices[4]);
vertices[4] = model_pos;
model_pos = multiply4mv(model, vertices[5]);
vertices[5] = model_pos;
array_insert(&renderer->cq_pos_batch, vertices[0].data, 4);
array_insert(&renderer->cq_pos_batch, vertices[1].data, 4);
array_insert(&renderer->cq_pos_batch, vertices[2].data, 4);
array_insert(&renderer->cq_pos_batch, vertices[3].data, 4);
array_insert(&renderer->cq_pos_batch, vertices[4].data, 4);
array_insert(&renderer->cq_pos_batch, vertices[5].data, 4);
// initialise color to be per vertex to allow batching
array_insert(&renderer->cq_color_batch, color.data, 3);
array_insert(&renderer->cq_color_batch, color.data, 3);
array_insert(&renderer->cq_color_batch, color.data, 3);
array_insert(&renderer->cq_color_batch, color.data, 3);
array_insert(&renderer->cq_color_batch, color.data, 3);
array_insert(&renderer->cq_color_batch, color.data, 3);
renderer->cq_batch_count++;
if(renderer->cq_batch_count == BATCH_SIZE) {
gl_cq_flush(renderer);
}
}
void gl_draw_colored_quad(
GLRenderer* renderer,
Vec3 position,
Vec2 size,
Vec3 color
) {
glEnable(GL_DEPTH_TEST);
glUseProgram(renderer->cq_sp);
if (renderer->cq_init == 0)
{
glUniformMatrix4fv(
glGetUniformLocation(renderer->cq_sp, "Projection"),
1, GL_FALSE, (renderer->cam_proj).buffer
);
renderer->cq_init = 1;
}
// setting quad size
Mat4 model = diag4m(1.0);
Mat4 scale = scaling_matrix4m(size.x, size.y, 0.0f);
model = multiply4m(scale, model);
// setting quad position
Mat4 translation = translation_matrix4m(position.x, position.y, position.z);
model = multiply4m(translation, model);
// setting color
glUniform3fv(glGetUniformLocation(renderer->cq_sp, "Color"), 1, color.data);
glUniformMatrix4fv(
glGetUniformLocation(renderer->cq_sp, "Model"),
1, GL_FALSE, model.buffer
);
glUniformMatrix4fv(
glGetUniformLocation(renderer->cq_sp, "View"),
1, GL_FALSE, (renderer->cam_view).buffer
);
glBindVertexArray(renderer->cq_vao);
glDrawArrays(GL_TRIANGLES, 0, 6);
}
void gl_setup_text(TextState* state, FT_Face font_face)
{
FT_Set_Pixel_Sizes(font_face, state->pixel_size, state->pixel_size);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glGenTextures(1, &(state->texture_atlas_id));
glBindTexture(GL_TEXTURE_2D_ARRAY, state->texture_atlas_id);
// generate texture
glTexImage3D(
GL_TEXTURE_2D_ARRAY,
0,
GL_R8,
state->pixel_size,
state->pixel_size,
128,
0,
GL_RED,
GL_UNSIGNED_BYTE,
0
);
// generate characters
for (u32 c = 0; c < 128; c++)
{
if (FT_Load_Char(font_face, c, FT_LOAD_RENDER))
{
printf("ERROR :: Freetype failed to load glyph: %c", c);
}
else
{
glTexSubImage3D(
GL_TEXTURE_2D_ARRAY,
0,
0, 0, // x, y offset
int(c),
font_face->glyph->bitmap.width,
font_face->glyph->bitmap.rows,
1,
GL_RED,
GL_UNSIGNED_BYTE,
font_face->glyph->bitmap.buffer
);
// set texture options
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
TextChar tc;
tc.size = Vec2{
(r32)font_face->glyph->bitmap.width,
(r32)font_face->glyph->bitmap.rows
};
tc.bearing = Vec2{
(r32)font_face->glyph->bitmap_left,
(r32)font_face->glyph->bitmap_top
};
tc.advance = font_face->glyph->advance.x;
state->char_map[c] = tc;
}
}
glBindTexture(GL_TEXTURE_2D_ARRAY, 0);
// @note: this data is used for GL_TRIANGLE_STRIP
// as such the order for vertices for this is AntiCW -> CW -> AntiCW
// that can be seen in this array as it goes from ACW -> CW
r32 vertices[] = {
0.0f, 1.0f,
0.0f, 0.0f,
1.0f, 1.0f,
1.0f, 0.0f
};
glGenVertexArrays(1, &(state->vao));
glGenBuffers(1, &(state->vbo));
glBindVertexArray(state->vao);
glBindBuffer(GL_ARRAY_BUFFER, state->vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindVertexArray(0);
}
void gl_render_text(GLRenderer *renderer, char* text, Vec2 position, r32 size, Vec3 color)
{
glDisable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glUseProgram(renderer->ui_text.sp);
glUniformMatrix4fv(glGetUniformLocation(renderer->ui_text.sp, "View"),
1, GL_FALSE, renderer->cam_view.buffer);
glUniformMatrix4fv(glGetUniformLocation(renderer->ui_text.sp, "Projection"),
1, GL_FALSE, renderer->cam_proj.buffer);
glUniform3fv(glGetUniformLocation(renderer->ui_text.sp, "TextColor"), 1, color.data);
glBindVertexArray(renderer->ui_text.vao);
glBindTexture(GL_TEXTURE_2D_ARRAY, renderer->ui_text.texture_atlas_id);
glBindBuffer(GL_ARRAY_BUFFER, renderer->ui_text.vbo);
glActiveTexture(GL_TEXTURE0);
u32 running_index = 0;
r32 startx = position.x;
r32 starty = position.y;
r32 linex = startx;
r32 scale = size/renderer->ui_text.pixel_size;
memset(renderer->ui_text.transforms, 0, renderer->ui_text.chunk_size);
memset(renderer->ui_text.char_indexes, 0, renderer->ui_text.chunk_size);
char *char_iter = text;
while (*char_iter != '\0')
{
TextChar render_char = renderer->ui_text.char_map[*char_iter];
if (*char_iter == '\n')
{
linex = startx;
starty = starty - (render_char.size.y * 1.5 * scale);
}
else if (*char_iter == ' ')
{
linex += (render_char.advance >> 6) * scale;
}
else
{
r32 xpos = linex + (scale * render_char.bearing.x);
r32 ypos = starty - (renderer->ui_text.pixel_size - render_char.bearing.y) * scale;
r32 w = scale * renderer->ui_text.pixel_size;
r32 h = scale * renderer->ui_text.pixel_size;
Mat4 sm = scaling_matrix4m(w, h, 0);
Mat4 tm = translation_matrix4m(xpos, ypos, 0);
Mat4 model = multiply4m(tm, sm);
renderer->ui_text.transforms[running_index] = model;
renderer->ui_text.char_indexes[running_index] = int(*char_iter);
linex += (render_char.advance >> 6) * scale;
running_index++;
if (running_index > renderer->ui_text.chunk_size - 1)
{
r32 transform_loc = glGetUniformLocation(renderer->ui_text.sp, "LetterTransforms");
glUniformMatrix4fv(transform_loc, renderer->ui_text.chunk_size,
GL_FALSE, &(renderer->ui_text.transforms[0].buffer[0]));
r32 texture_map_loc = glGetUniformLocation(renderer->ui_text.sp, "TextureMap");
glUniform1iv(texture_map_loc, renderer->ui_text.chunk_size, renderer->ui_text.char_indexes);
glDrawArraysInstanced(GL_TRIANGLE_STRIP, 0, 4, renderer->ui_text.chunk_size);
running_index = 0;
memset(renderer->ui_text.transforms, 0, renderer->ui_text.chunk_size);
memset(renderer->ui_text.char_indexes, 0, renderer->ui_text.chunk_size);
}
}
char_iter++;
}
if (running_index > 0)
{
u32 render_count = running_index < renderer->ui_text.chunk_size ? running_index : renderer->ui_text.chunk_size;
r32 transform_loc = glGetUniformLocation(renderer->ui_text.sp, "LetterTransforms");
glUniformMatrix4fv(transform_loc, render_count,
GL_FALSE, &(renderer->ui_text.transforms[0].buffer[0]));
r32 texture_map_loc = glGetUniformLocation(renderer->ui_text.sp, "TextureMap");
glUniform1iv(texture_map_loc, render_count, renderer->ui_text.char_indexes);
glDrawArraysInstanced(GL_TRIANGLE_STRIP, 0, 4, render_count);
running_index = 0;
memset(renderer->ui_text.transforms, 0, render_count);
memset(renderer->ui_text.char_indexes, 0, render_count);
}
}
Vec2 get_move_dir(Controller c) {
Vec2 dir = {};
if (c.move_up) {
dir.y = 1.0f;
}
if (c.move_down) {
dir.y = -1.0f;
}
if (c.move_left) {
dir.x = -1.0f;
}
if (c.move_right) {
dir.x = 1.0f;
}
return dir;
}
void update_camera(GLRenderer *renderer) {
if (renderer->cam_update == true) {
renderer->cam_view = camera_create4m(
renderer->cam_pos,
add3v(renderer->cam_pos, renderer->cam_look),
renderer->preset_up_dir
);
renderer->cam_update = false;
}
}
Vec3 get_world_position_from_percent(GameState state, Vec3 v) {
Vec3 world_pos = v;
world_pos.x = state.render_scale.x*state.world_size.x*v.x/100.0f;
world_pos.y = state.render_scale.y*state.world_size.y*v.y/100.0f;
return world_pos;
}
Vec2 get_screen_position_from_percent(GameState state, Vec2 v) {
Vec2 screen_pos = v;
screen_pos.x = state.render_scale.x*state.screen_size.x*v.x/100.0f;
screen_pos.y = state.render_scale.y*state.screen_size.y*v.y/100.0f;
return screen_pos;
}
Vec3 get_screen_position_from_percent(GameState state, Vec3 v) {
Vec3 screen_pos = v;
screen_pos.x = state.render_scale.x*state.screen_size.x*v.x/100.0f;
screen_pos.y = state.render_scale.y*state.screen_size.y*v.y/100.0f;
return screen_pos;
}
int main(int argc, char* argv[])
{
u32 base_scr_width = 1024;
u32 base_scr_height = 768;
u32 scr_width = 1280;
u32 scr_height = 960;
if (SDL_Init(SDL_INIT_VIDEO) != 0)
{
printf("Error initialising SDL2: %s\n", SDL_GetError());
return -1;
}
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 4);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 5);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
SDL_Window* window = SDL_CreateWindow("simple platformer",
SDL_WINDOWPOS_UNDEFINED,
SDL_WINDOWPOS_UNDEFINED,
scr_width, scr_height,
SDL_WINDOW_OPENGL);
SDL_GLContext context = SDL_GL_CreateContext(window);
if (!context)
{
printf("ERROR :: OpenGL context creation failed: %s\n", SDL_GetError());
return -1;
}
// load glad
if (!gladLoadGLLoader((GLADloadproc)SDL_GL_GetProcAddress)) {
printf("ERROR :: Failed to initialize Glad\n");
return -1;
}
// vsync controls: 0 = OFF | 1 = ON (Default)
SDL_GL_SetSwapInterval(0);
GLRenderer renderer;
memset(&renderer, 0, sizeof(GLRenderer));
u32 pos_ele_count = BATCH_SIZE * 4*6;
u32 color_ele_count = BATCH_SIZE * 3*6;
// 1GB <= (((1b*1024)kb*1024)mb*1024)mb
size_t mem_size = GB(1);
void* batch_memory = calloc(mem_size, sizeof(r32));
Arena batch_arena;
arena_init(&batch_arena, (unsigned char*)batch_memory, mem_size*sizeof(r32));
array_init(&batch_arena, &(renderer.cq_pos_batch), pos_ele_count);
array_init(&batch_arena, &(renderer.cq_color_batch), color_ele_count);
u32 quad_sp = gl_shader_program_from_path(
"./source/shaders/colored_quad.vs.glsl",
"./source/shaders/colored_quad.fs.glsl"
);
u32 ui_text_sp = gl_shader_program_from_path(
"./source/shaders/ui_text.vs.glsl",
"./source/shaders/ui_text.fs.glsl"
);
u32 cq_batch_sp = gl_shader_program_from_path(
"./source/shaders/cq_batched.vs.glsl",
"./source/shaders/cq_batched.fs.glsl"
);
u32 quad_vao = gl_setup_colored_quad(quad_sp);
renderer.cq_sp = quad_sp;
renderer.cq_vao = quad_vao;
renderer.cq_batch_sp = cq_batch_sp;
gl_setup_colored_quad_optimized(&renderer, cq_batch_sp);
r32 render_scale = 1.0f; //(r32)scr_width / (r32)base_scr_width;
// ==========
// setup text
// 1. setup free type library stuff
FT_Library ft_lib;
FT_Face roboto_font_face;
if (FT_Init_FreeType(&ft_lib))
{
printf("ERROR :: Could not init freetype library\n");
return -1;
}
FT_Error error = FT_New_Face(
ft_lib,
"assets/fonts/Roboto.ttf",
0, &roboto_font_face
);
if (error == FT_Err_Unknown_File_Format)
{
printf("ERROR :: Font Loading Failed. The font format is unsupported\n");
return -1;
}
else if (error)
{
printf("ERROR :: Font Loading Failed. Unknown error code: %d\n", error);
return -1;
}
// 2. setup gl text
// @note: we only support 128 characters, which is the basic ascii set
renderer.ui_text.chunk_size = 32;
renderer.ui_text.pixel_size = 32*render_scale;
renderer.ui_text.sp = ui_text_sp;
renderer.ui_text.transforms = (Mat4*)malloc(
renderer.ui_text.chunk_size*sizeof(Mat4)
);
renderer.ui_text.char_indexes = (s32*)malloc(
renderer.ui_text.chunk_size*sizeof(s32)
);
renderer.ui_text.char_map = (TextChar*)malloc(
128*sizeof(TextChar)
);
gl_setup_text(&(renderer.ui_text), roboto_font_face);
// ============
// setup camera
Vec3 preset_up_dir = Vec3{0.0f, 1.0f, 0.0f};
renderer.preset_up_dir = preset_up_dir;
renderer.cam_update = false;
renderer.cam_pos = Vec3{0.0f, 0.0f, 1.0f};
renderer.cam_look = camera_look_around(TO_RAD(0.0f), -TO_RAD(90.0f));
renderer.cam_view = camera_create4m(
renderer.cam_pos,
add3v(renderer.cam_pos, renderer.cam_look), renderer.preset_up_dir
);
renderer.cam_proj = orthographic4m(
0.0f, (r32)scr_width*render_scale,
0.0f, (r32)scr_height*render_scale,
0.1f, 10.0f
);
// @section: gameplay variables
r32 motion_scale = 2.0f;
r32 fall_accelx = 3.0f*motion_scale;
r32 move_accelx = 4.0f*motion_scale;
r32 freefall_accel = -11.8f*motion_scale;
r32 jump_force = 6.5f*motion_scale;
r32 effective_force = 0.0f;
Vec2 player_velocity = Vec2{0.0f, 0.0f};
Vec2 p_move_dir = Vec2{0.0f, 0.0f};
// direction in which player is effectively travelling
Vec2 p_motion_dir = Vec2{0.0f, 0.0f};
// @thinking: level object handling
// there should be a most smallest supported unit
// smallest_size: 16x16
// object placement should be in pixels
// in order to scale to different resolutions it should be multiplied by
// scaling factor
Vec2 atom_size = Vec2{32.0f, 32.0f};
GameState state = {0};
state.atom_size = atom_size;
state.world_size = Vec2{(r32)scr_width, (r32)scr_height};
state.screen_size = Vec2{(r32)scr_width, (r32)scr_height};
state.render_scale = vec2(render_scale);
// @section: level elements
// @step: init_level_arena
size_t max_level_entities = 255;
size_t arena_mem_size = GB(1);
void* level_mem = malloc(arena_mem_size);
Arena level_arena;
size_t arena_size = max_level_entities*(sizeof(Entity) + sizeof(EntityInfo));
arena_init(&level_arena, (unsigned char*)level_mem, arena_size);
Str256 base = str256(base_level_path);
Str256 _level_name = str256(level_names[state.level_index]);
Str256 level_path = base;
str_push256(&level_path, _level_name);
level_load(&state, &level_arena, level_path);
// gameplay camera movement stuff
Vec2 cam_lt_limit = {0};
Vec2 cam_rb_limit = {0};
cam_lt_limit = get_screen_position_from_percent(
state, Vec2{30.0f, 70.0f}
);
cam_rb_limit = get_screen_position_from_percent(
state, Vec2{70.0f, 30.0f}
);
Controller controller = {0};
r32 key_down_time[5] = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f};
b8 is_key_down_x = false;
// gravity calculations
b8 collidex = 0;
b8 collidey = 0;
b8 is_gravity = 0;
b8 game_running = 1;
FrameTimer timer = frametimer();
// @section: audio_setup
ma_result result;
ma_engine engine;
result = ma_engine_init(NULL, &engine);
if (result != MA_SUCCESS) {
SDL_Log("Failed to initialise audio engine\n");
return -1;
}
// @resume: playing around with audio
ma_sound sound;
const char *sound_path = "assets/audio/Click_Soft_01.mp3";
result = ma_sound_init_from_file(&engine, sound_path, 0, NULL, NULL, &sound);
if (result != MA_SUCCESS) {
SDL_Log("Failed to load sound: %s\n", sound_path);
return -1;
}
//ma_sound_set_pitch(&sound, 1.5f);
//ma_sound_set_looping(&sound, 1);
while (game_running)
{
controller.jump = 0;
controller.toggle_gravity = 0;
SDL_Event ev;
while(SDL_PollEvent(&ev))
{
switch(ev.type)
{
case (SDL_QUIT):
{
game_running = 0;
} break;
case (SDL_KEYDOWN):
{
if (ev.key.keysym.sym == SDLK_w)
{
controller.move_up = 1;
}
if (ev.key.keysym.sym == SDLK_a)
{
controller.move_left = 1;
key_down_time[PK_A] = timer.tCurr;
}
if (ev.key.keysym.sym == SDLK_s)
{
controller.move_down = 1;
}
if (ev.key.keysym.sym == SDLK_d)
{
controller.move_right = 1;
key_down_time[PK_D] = timer.tCurr;
}
if (ev.key.keysym.sym == SDLK_SPACE)
{
controller.jump = 1;
}
if (ev.key.keysym.sym == SDLK_g)
{
controller.toggle_gravity = 1;
}
// @todo: fix this janky manual camera movement
if (ev.key.keysym.sym == SDLK_F5)
{
level_load(&state, &level_arena, level_path);
renderer.cam_update = true;
}
if (ev.key.keysym.sym == SDLK_LEFT)
{
renderer.cam_pos.x -= 20.0f * state.render_scale.x;
renderer.cam_update = true;
}
if (ev.key.keysym.sym == SDLK_RIGHT)
{
renderer.cam_pos.x += 20.0f * state.render_scale.x;
renderer.cam_update = true;
}
if (ev.key.keysym.sym == SDLK_UP)
{
renderer.cam_pos.y += 20.0f * state.render_scale.x;
renderer.cam_update = true;
}
if (ev.key.keysym.sym == SDLK_DOWN)
{
renderer.cam_pos.y -= 20.0f * state.render_scale.x;
renderer.cam_update = true;
}
if (renderer.cam_update) {
renderer.cam_view = camera_create4m(
renderer.cam_pos,
add3v(renderer.cam_pos, renderer.cam_look),
renderer.preset_up_dir
);
renderer.cam_update = false;
}
} break;
case (SDL_KEYUP):
{
if (ev.key.keysym.sym == SDLK_w)
{
controller.move_up = 0;
}
if (ev.key.keysym.sym == SDLK_a)
{
controller.move_left = 0;
key_down_time[PK_A] = 0.0f;
}
if (ev.key.keysym.sym == SDLK_s)
{
controller.move_down = 0;
}
if (ev.key.keysym.sym == SDLK_d)
{
controller.move_right = 0;
key_down_time[PK_D] = 0.0f;
}
} break;
default:
{
break;
}
}
}
// @section: state based loading
if (state.level_state == 1) {
state.level_index = clampi(state.level_index+1, 0, level_count-1);
Str256 _level_name = str256(level_names[state.level_index]);
Str256 level_path = base;
str_push256(&level_path, _level_name);
level_load(&state, &level_arena, level_path);
}
// @section: input processing
if (controller.toggle_gravity)
{
is_gravity = !is_gravity;
player_velocity = Vec2{0.0f, 0.0f};
p_move_dir.x = 0.0f;
effective_force = 0.0f;
p_motion_dir = {0};
}
if (controller.move_up)
{
p_move_dir.y = 1.0f;
}
if (controller.move_down)
{
p_move_dir.y = -1.0f;
}
PlatformKey horizontal_move = PK_NIL;
is_key_down_x = false;
if (
key_down_time[PK_A] != 0.0f ||
key_down_time[PK_D] != 0.0f
) {
horizontal_move = (
key_down_time[PK_A] > key_down_time[PK_D] ? PK_A : PK_D
);
}
if (horizontal_move == PK_A && controller.move_left)
{
p_move_dir.x = -1.0f;
is_key_down_x = true;
}
if (horizontal_move == PK_D && controller.move_right)
{
p_move_dir.x = 1.0f;
is_key_down_x = true;
}
// @section: gravity
Vec2 pd_1 = Vec2{0.0f, 0.0f};
p_motion_dir = {0};
if (collidey)
{
player_velocity.y = 0.0f;
}
if (collidex)
{
player_velocity.x = 0.0f;
}
if (is_gravity)
{
// @section: game_movement
// calculate force acting on player
if (collidey) {
// @note: can I reduce the states here like I did in the falling case
// without separate checks
if (collidex) {
effective_force = 0.0f;
} else if (is_key_down_x) {
r32 updated_force = (
effective_force + p_move_dir.x*move_accelx*timer.tDelta
);
updated_force = clampf(
updated_force, -move_accelx, move_accelx
);
effective_force = updated_force;
} else {
r32 friction = 0.0f;
if (effective_force > 0.0f) {
friction = -move_accelx*timer.tDelta;
} else if (effective_force < 0.0f) {
friction = move_accelx*timer.tDelta;
}
r32 updated_force = effective_force + friction;
effective_force = (
ABS(updated_force) < 0.5f ?
0.0f : updated_force
);
}
} else {
r32 smoothing_force = effective_force;
r32 net_force = 0.0f;
r32 active_force = 0.0f;
if (!collidex) {
net_force = effective_force;
if (controller.jump) {
// @step: if in the air and jumping in a different direction
// allow more immediate feeling force, instead of the jump adding into net_force
// which gives off, more of a floaty feeling.
r32 threshed_force = roundf(net_force);
b8 move_dir_different = (threshed_force >= 0 && p_move_dir.x < 0) || (threshed_force <= 0 && p_move_dir.x > 0);
if (move_dir_different) {
active_force = p_move_dir.x*fall_accelx/2.0f;
net_force = active_force;
}
} else {
if (is_key_down_x) {
// player is slowing down, in that case, we allow this movement.
b8 move_dir_opposite = (net_force > 0 && p_move_dir.x < 0) || (net_force < 0 && p_move_dir.x > 0);
if (move_dir_opposite || ABS(net_force) < fall_accelx*0.15f)
{
active_force = p_move_dir.x*fall_accelx*timer.tDelta;
net_force = clampf(net_force + active_force, -fall_accelx, fall_accelx);
}
}
if (ABS(net_force) >= fall_accelx) {
// @note: air resistance
// (arbitrary force in opposite direction to reduce speed)
// reason: seems that it would work well for the case where
// player moves from platform move to free_fall
// since the max speed in respective stages is different this can
// function as a speed smoother, without too many checks and
// explicit checking
b8 is_force_pos = effective_force > 0.0f;
b8 is_force_neg = effective_force < 0.0f;
r32 friction = 0.0f;
if (is_force_pos) {
friction = -fall_accelx*timer.tDelta;
} else if (is_force_neg) {
friction = fall_accelx*timer.tDelta;
}
net_force += friction;
}
}
}
effective_force = net_force;
}
{
// horizontal motion setting
r32 dx1 = effective_force;
if ( dx1 == 0.0f ) {
p_move_dir.x = 0.0f;
}
if (dx1 < 0.0f) {
p_motion_dir.x = -1.0f;
} else if (dx1 > 0.0f) {
p_motion_dir.x = 1.0f;
}
player_velocity.x = dx1;
pd_1.x = dx1;
}
{
// vertical motion when falling
r32 dy1 = player_velocity.y;
dy1 = dy1 + freefall_accel*timer.tDelta;
if (controller.jump) {
dy1 = jump_force;
if (!collidey) {
// if we are in the air, the jump force is 75% of normal
dy1 = jump_force * 0.75f;
}
}
if (dy1 < 0.0f) {
p_motion_dir.y = -1.0f;
} else if (dy1 > 0.0f) {
p_motion_dir.y = 1.0f;
}
player_velocity.y = dy1;
pd_1.y = dy1;
}
}
else
{
// @no_clip_movement
Vec2 dir = get_move_dir(controller);
pd_1 = dir * 8.0f * render_scale;
if (pd_1.x < 0.0f) {
p_motion_dir.x = -1.0f;
} else if (pd_1.x > 0.0f) {
p_motion_dir.x = 1.0f;
}
if (pd_1.y < 0.0f) {
p_motion_dir.y = -1.0f;
} else if (pd_1.y > 0.0f) {
p_motion_dir.y = 1.0f;
}
}
// @section: collision
Vec3 next_player_position;
next_player_position.x = state.player.position.x + pd_1.x;
next_player_position.y = state.player.position.y + pd_1.y;
Rect player_next = rect(next_player_position, state.player.size);
b8 is_collide_x = 0;
b8 is_collide_y = 0;
for (u32 i = 0; i < state.obstacles.size; i++) {
// @step: check_obstacle_collisions
// @func: check_if_player_colliding_with_target
u32 index = state.obstacles.buffer[i].index;
Entity e = state.game_level.entities[index];
Rect target = e.bounds;
b8 t_collide_x = 0;
// need to adjust player position in case of vertical collisions
// so need to check which player side collides
b8 t_collide_bottom = 0;
b8 t_collide_top = 0;
r32 prev_top = state.player.bounds.tl.y;
r32 prev_left = state.player.bounds.tl.x;
r32 prev_bottom = state.player.bounds.br.y;
r32 prev_right = state.player.bounds.br.x;
r32 p_top = player_next.tl.y;
r32 p_left = player_next.tl.x;
r32 p_bottom = player_next.br.y;
r32 p_right = player_next.br.x;
r32 t_left = target.tl.x;
r32 t_top = target.tl.y;
r32 t_right = target.br.x;
r32 t_bottom = target.br.y;
b8 prev_collide_x = !(prev_left > t_right || prev_right < t_left);
b8 new_collide_target_top = (p_bottom < t_top && p_top > t_top);
b8 new_collide_target_bottom = (p_top > t_bottom && p_bottom < t_bottom);
if (prev_collide_x && new_collide_target_top) {
t_collide_top = 1;
}
if (prev_collide_x && new_collide_target_bottom) {
t_collide_bottom = 1;
}
b8 prev_collide_y = !(prev_top < t_bottom || prev_bottom > t_top);
b8 new_collide_x = !(p_right < t_left || p_left > t_right);
if (prev_collide_y && new_collide_x) {
t_collide_x = 1;
}
// @func: update_player_positions_if_sides_colliding
if (t_collide_top) {
state.player.position.y -= (prev_bottom - t_top - 0.1f);
} else if (t_collide_bottom) {
state.player.position.y += (t_bottom - prev_top - 0.1f);
}
is_collide_x = is_collide_x || t_collide_x;
is_collide_y = is_collide_y || t_collide_top || t_collide_bottom;
}
if (!is_collide_x) {
if (p_motion_dir.x != 0.0f) {
renderer.cam_update = true;
}
state.player.position.x = next_player_position.x;
}
if (!is_collide_y) {
if (p_motion_dir.y != 0.0f) {
renderer.cam_update = true;
}
state.player.position.y = next_player_position.y;
}
// check collision with goal
if (!is_collide_x && !is_collide_y) {
Entity goal = state.game_level.entities[state.goal.index];
Rect target = goal.bounds;
b8 t_collide_x = 0;
// need to adjust player position in case of vertical collisions
// so need to check which player side collides
b8 t_collide_bottom = 0;
b8 t_collide_top = 0;
r32 prev_top = state.player.bounds.tl.y;
r32 prev_left = state.player.bounds.tl.x;
r32 prev_bottom = state.player.bounds.br.y;
r32 prev_right = state.player.bounds.br.x;
r32 p_top = player_next.tl.y;
r32 p_left = player_next.tl.x;
r32 p_bottom = player_next.br.y;
r32 p_right = player_next.br.x;
r32 t_left = target.tl.x;
r32 t_top = target.tl.y;
r32 t_right = target.br.x;
r32 t_bottom = target.br.y;
b8 prev_collide_x = !(prev_left > t_right || prev_right < t_left);
b8 new_collide_yb = (p_bottom < t_top && p_top > t_top);
b8 new_collide_yt = (p_top > t_bottom && p_bottom < t_bottom);
if (prev_collide_x && new_collide_yb) {
t_collide_top = 1;
}
if (prev_collide_x && new_collide_yt) {
t_collide_bottom = 1;
}
b8 prev_collide_y = !(prev_top < t_bottom || prev_bottom > t_top);
b8 new_collide_x = !(p_right < t_left || p_left > t_right);
if (prev_collide_y && new_collide_x) {
t_collide_x = 1;
}
state.level_state = t_collide_x || t_collide_top || t_collide_bottom;
}
state.player.bounds = rect(state.player.position, state.player.size);
collidex = is_collide_x;
collidey = is_collide_y;
// @func: update_camera
if (renderer.cam_update == true) {
renderer.cam_update = false;
Vec2 player_screen = state.player.position.v2() - renderer.cam_pos.v2();
if (player_screen.x <= cam_lt_limit.x && p_motion_dir.x == -1) {
renderer.cam_pos.x += pd_1.x;
renderer.cam_update = true;
}
if (player_screen.y >= cam_lt_limit.y && p_motion_dir.y == 1) {
renderer.cam_pos.y += pd_1.y;
renderer.cam_update = true;
}
if (player_screen.x >= cam_rb_limit.x && p_motion_dir.x == 1) {
renderer.cam_pos.x += pd_1.x;
renderer.cam_update = true;
}
if (player_screen.y <= cam_rb_limit.y && p_motion_dir.y == -1) {
renderer.cam_pos.y += pd_1.y;
renderer.cam_update = true;
}
if (renderer.cam_update == true) {
renderer.cam_view = camera_create4m(
renderer.cam_pos,
add3v(renderer.cam_pos, renderer.cam_look),
renderer.preset_up_dir
);
renderer.cam_update = false;
}
}
// output
// @section: audio
if (controller.jump) {
ma_sound_start(&sound);
}
glClearColor(0.8f, 0.5f, 0.7f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// @section: rendering
// render_player
gl_draw_colored_quad_optimized(
&renderer,
state.player.position,
state.player.size,
Vec3{1.0f, 0.0f, 0.0f});
// render_goal
{
Entity goal = state.game_level.entities[state.goal.index];
gl_draw_colored_quad_optimized(
&renderer,
Vec3{goal.position.x, goal.position.y, -3.0f},
goal.size,
Vec3{ 0.93f, 0.7f, 0.27f });
}
// render_obstacles
for (int i = 0; i < state.obstacles.size; i++) {
u32 index = state.obstacles.buffer[i].index;
Entity entity = state.game_level.entities[index];
gl_draw_colored_quad_optimized(
&renderer,
Vec3{entity.position.x, entity.position.y, -2.0f},
entity.size,
Vec3{1.0f, 1.0f, 1.0f}
);
}
gl_cq_flush(&renderer);
array_clear(&renderer.cq_pos_batch);
array_clear(&renderer.cq_color_batch);
renderer.cq_batch_count = 0;
// render ui text
char level_state_output[50];
sprintf(level_state_output, "is level clear = %d", state.level_state);
gl_render_text(
&renderer,
level_state_output,
Vec2{600.0f, 900.0f},
28.0f,
Vec3{0.0f, 0.0f, 0.0f});
if (is_collide_x || is_collide_y)
{
gl_render_text(&renderer,
"is colliding",
Vec2{500.0f, 700.0f}, // position
28.0f, // size
Vec3{0.0f, 0.0f, 0.0f}); // color
char movedir_output[50];
sprintf(movedir_output, "move_dir = %f", p_move_dir.x);
gl_render_text(&renderer,
movedir_output,
Vec2{500.0f, 60.0f}, // position
28.0f, // size
Vec3{0.0f, 0.0f, 0.0f}); // color
char speed_output[50];
sprintf(speed_output, "%f pps", player_velocity.x);
gl_render_text(&renderer,
speed_output,
Vec2{500.0f, 100.0f}, // position
28.0f, // size
Vec3{0.0f, 0.0f, 0.0f}); // color
}
char fmt_buffer[50];
sprintf(fmt_buffer, "frametime: %f", timer.tDelta);
gl_render_text(&renderer,
fmt_buffer,
Vec2{900.0f, 90.0f}, // position
28.0f*render_scale, // size
Vec3{0.0f, 0.0f, 0.0f}); // color
SDL_GL_SwapWindow(window);
update_frame_timer(&timer);
enforce_frame_rate(&timer, 60);
}
ma_engine_uninit(&engine);
free(level_mem);
free(batch_memory);
free(renderer.ui_text.transforms);
free(renderer.ui_text.char_indexes);
free(renderer.ui_text.char_map);
SDL_GL_DeleteContext(context);
SDL_DestroyWindow(window);
SDL_Quit();
return 0;
}