falsycat/LEFTONE
Archived
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

[RELEASE] u22-v04

Browse Source 
This version is submitted for U22 final presentation. (squashed 158 commits)
This commit is contained in:
falsycat
2020-10-09 00:00:00 +00:00
parent 84c3a02b9a
commit 80b3b82332
277 changed files with 12154 additions and 13836 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
core/loshader/CMakeLists.txt
View File

@@ -9,12 +9,17 @@ add_library(loshader
ground.c
hud_bar.c
hud_text.c
instanced.c
menu_background.c
menu_stance.c
menu_text.c
particle.c
pixsort.c
popup_text.c
posteffect.c
set.c
single.c
text.c
uniblock.c
)
target_any_sources(loshader
@@ -45,6 +50,10 @@ target_any_sources(loshader
menu_stance.fshader
menu_text.vshader
menu_text.fshader
particle.vshader
particle.fshader
popup_text.vshader
popup_text.fshader
pixsort.vshader
pixsort.fshader
posteffect.vshader

97
core/loshader/backwall.c
View File

@@ -2,26 +2,16 @@
#include <assert.h>
#include <stddef.h>
#include <stdint.h>
#include "util/gleasy/buffer.h"
#include "util/gleasy/program.h"
#include "util/math/vector.h"
#include "util/memory/memory.h"
#include "./single.h"
#include "./uniblock.h"
/* resources */
#include "anysrc/header.shader.h"
#include "anysrc/backwall.vshader.h"
#include "anysrc/backwall.fshader.h"
#include "core/loshader/anysrc/header.shader.h"
#include "core/loshader/anysrc/backwall.vshader.h"
#include "core/loshader/anysrc/backwall.fshader.h"
struct loshader_backwall_drawer_t {
const loshader_backwall_program_t* prog;
const loshader_uniblock_t* uniblock;
gleasy_buffer_uniform_t param;
};
#define PRIMITIVE_COUNT_ 6
#pragma pack(push, 1)
typedef struct {
@@ -29,65 +19,29 @@ typedef struct {
float prev_type;
float transition;
} loshader_backwall_drawer_internal_param_t;
_Static_assert(
sizeof(float)*3 ==
sizeof(loshader_backwall_drawer_internal_param_t));
#pragma pack(pop)
#define LOSHADER_BACKWALL_UNIBLOCK_INDEX 0
#define LOSHADER_BACKWALL_PARAM_INDEX 1
_Static_assert(
sizeof(float)*3 ==
sizeof(loshader_backwall_drawer_internal_param_t),
"recheck the type has no padding");
#define LOSHADER_BACKWALL_PRIMITIVE_COUNT 6
void loshader_backwall_drawer_initialize(
loshader_backwall_drawer_t* drawer,
const loshader_uniblock_t* uniblock) {
assert(drawer != NULL);
assert(uniblock != NULL);
void loshader_backwall_program_initialize(loshader_backwall_program_t* prog) {
assert(prog != NULL);
*prog = gleasy_program_new(
const gleasy_program_t prog = gleasy_program_new(
loshader_header_shader_, sizeof(loshader_header_shader_),
loshader_backwall_vshader_, sizeof(loshader_backwall_vshader_),
loshader_backwall_fshader_, sizeof(loshader_backwall_fshader_));
const GLuint uniblock = glGetUniformBlockIndex(*prog, "uniblock");
assert(glGetError() == GL_NO_ERROR);
glUniformBlockBinding(*prog, uniblock, LOSHADER_BACKWALL_UNIBLOCK_INDEX);
const GLuint param = glGetUniformBlockIndex(*prog, "param");
assert(glGetError() == GL_NO_ERROR);
glUniformBlockBinding(*prog, param, LOSHADER_BACKWALL_PARAM_INDEX);
}
void loshader_backwall_program_deinitialize(loshader_backwall_program_t* prog) {
assert(prog != NULL);
glDeleteProgram(*prog);
}
loshader_backwall_drawer_t* loshader_backwall_drawer_new(
const loshader_backwall_program_t* prog,
const loshader_uniblock_t* uniblock) {
assert(prog != NULL);
assert(uniblock != NULL);
loshader_backwall_drawer_t* drawer = memory_new(sizeof(*drawer));
*drawer = (typeof(*drawer)) {
.prog = prog,
.uniblock = uniblock,
};
glGenBuffers(1, &drawer->param);
glBindBuffer(GL_UNIFORM_BUFFER, drawer->param);
glBufferData(GL_UNIFORM_BUFFER,
sizeof(loshader_backwall_drawer_internal_param_t), NULL, GL_DYNAMIC_DRAW);
return drawer;
}
void loshader_backwall_drawer_delete(loshader_backwall_drawer_t* drawer) {
if (drawer == NULL) return;
glDeleteBuffers(1, &drawer->param);
memory_delete(drawer);
loshader_single_drawer_initialize(
&drawer->super,
prog,
uniblock,
sizeof(loshader_backwall_drawer_internal_param_t));
}
void loshader_backwall_drawer_set_param(
@@ -101,18 +55,11 @@ void loshader_backwall_drawer_set_param(
.prev_type = param->prev_type,
.transition = param->transition,
};
glBindBuffer(GL_UNIFORM_BUFFER, drawer->param);
glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(p), &p);
loshader_single_drawer_set_param(&drawer->super, &p);
}
void loshader_backwall_drawer_draw(const loshader_backwall_drawer_t* drawer) {
assert(drawer != NULL);
glUseProgram(*drawer->prog);
loshader_uniblock_bind(drawer->uniblock, LOSHADER_BACKWALL_UNIBLOCK_INDEX);
glBindBufferBase(GL_UNIFORM_BUFFER,
LOSHADER_BACKWALL_PARAM_INDEX, drawer->param);
glDrawArrays(GL_TRIANGLES, 0, LOSHADER_BACKWALL_PRIMITIVE_COUNT);
loshader_single_drawer_draw(&drawer->super, PRIMITIVE_COUNT_);
}

32
core/loshader/backwall.h
View File

@@ -2,14 +2,12 @@
#include <stddef.h>
#include "util/gleasy/program.h"
#include "./single.h"
#include "./uniblock.h"
typedef gleasy_program_t loshader_backwall_program_t;
struct loshader_backwall_drawer_t;
typedef struct loshader_backwall_drawer_t loshader_backwall_drawer_t;
typedef struct {
loshader_single_drawer_t super;
} loshader_backwall_drawer_t;
typedef enum {
LOSHADER_BACKWALL_TYPE_WHITE = 0,
@@ -28,25 +26,13 @@ typedef struct {
} loshader_backwall_drawer_param_t;
void
loshader_backwall_program_initialize(
loshader_backwall_program_t* prog
loshader_backwall_drawer_initialize(
loshader_backwall_drawer_t* drawer,
const loshader_uniblock_t* uniblock
);
void
loshader_backwall_program_deinitialize(
loshader_backwall_program_t* prog
);
loshader_backwall_drawer_t*
loshader_backwall_drawer_new(
const loshader_backwall_program_t* prog,
const loshader_uniblock_t* uniblock
);
void
loshader_backwall_drawer_delete(
loshader_backwall_drawer_t* drawer
);
#define loshader_backwall_drawer_deinitialize(drawer) \
loshader_single_drawer_deinitialize(&(drawer)->super)
void
loshader_backwall_drawer_set_param(

168
core/loshader/bullet.c
View File

@@ -11,32 +11,22 @@
#include "util/gleasy/buffer.h"
#include "util/gleasy/program.h"
#include "util/math/vector.h"
#include "util/memory/memory.h"
#include "./uniblock.h"
/* resources */
#include "anysrc/header.shader.h"
#include "anysrc/bullet.vshader.h"
#include "anysrc/bullet.fshader.h"
#include "core/loshader/anysrc/header.shader.h"
#include "core/loshader/anysrc/bullet.vshader.h"
#include "core/loshader/anysrc/bullet.fshader.h"
#define LOSHADER_BULLET_VSHADER_IN_BULLET_ID 0
#define LOSHADER_BULLET_VSHADER_IN_POS 1
#define LOSHADER_BULLET_VSHADER_IN_SIZE 2
#define LOSHADER_BULLET_VSHADER_IN_THETA 3
#define LOSHADER_BULLET_VSHADER_IN_TIME 4
#define LOSHADER_BULLET_VSHADER_IN_COLOR 5
#define VSHADER_IN_BULLET_ID_ 0
#define VSHADER_IN_POS_ 1
#define VSHADER_IN_SIZE_ 2
#define VSHADER_IN_THETA_ 3
#define VSHADER_IN_TIME_ 4
#define VSHADER_IN_COLOR_ 5
struct loshader_bullet_drawer_t {
const loshader_bullet_program_t* prog;
const loshader_uniblock_t* uniblock;
GLuint vao;
gleasy_buffer_array_t instances;
size_t instances_reserved;
size_t instances_length;
};
#define PRIMITIVE_COUNT_ 6
#pragma pack(push, 1)
typedef struct {
@@ -51,102 +41,45 @@ typedef struct {
} loshader_bullet_drawer_internal_instance_t;
#pragma pack(pop)
#define LOSHADER_BULLET_UNIBLOCK_INDEX 0
void loshader_bullet_drawer_initialize(
loshader_bullet_drawer_t* drawer,
const loshader_uniblock_t* uniblock) {
assert(drawer != NULL);
assert(uniblock != NULL);
#define LOSHADER_BULLET_PRIMITIVE_COUNT 6
static void loshader_bullet_program_setup_vao_(
gleasy_buffer_array_t instances) {
assert(instances != 0);
glBindBuffer(GL_ARRAY_BUFFER, instances);
# define enable_attrib_(NAME, name, dim, type) do { \
glEnableVertexAttribArray(LOSHADER_BULLET_VSHADER_IN_##NAME); \
glVertexAttribPointer( \
LOSHADER_BULLET_VSHADER_IN_##NAME, dim, type, GL_FALSE, \
sizeof(loshader_bullet_drawer_internal_instance_t), \
NULL + offsetof(loshader_bullet_drawer_internal_instance_t, name)); \
glVertexAttribDivisor(LOSHADER_BULLET_VSHADER_IN_##NAME, 1); \
} while (0)
enable_attrib_(BULLET_ID, bullet_id, 1, GL_UNSIGNED_SHORT);
enable_attrib_(POS, pos, 2, GL_FLOAT);
enable_attrib_(SIZE, size, 2, GL_FLOAT);
enable_attrib_(THETA, theta, 1, GL_FLOAT);
enable_attrib_(TIME, time, 1, GL_FLOAT);
enable_attrib_(COLOR, color, 4, GL_FLOAT);
# undef enable_attrib_
}
void loshader_bullet_program_initialize(loshader_bullet_program_t* prog) {
assert(prog != NULL);
*prog = gleasy_program_new(
const gleasy_program_t prog = gleasy_program_new(
loshader_header_shader_, sizeof(loshader_header_shader_),
loshader_bullet_vshader_, sizeof(loshader_bullet_vshader_),
loshader_bullet_fshader_, sizeof(loshader_bullet_fshader_));
const GLuint uniblock = glGetUniformBlockIndex(*prog, "uniblock");
assert(glGetError() == GL_NO_ERROR);
loshader_instanced_drawer_initialize(
&drawer->super,
prog,
uniblock,
sizeof(loshader_bullet_drawer_internal_instance_t));
glUniformBlockBinding(*prog, uniblock, LOSHADER_BULLET_UNIBLOCK_INDEX);
}
glBindVertexArray(drawer->super.vao);
glBindBuffer(GL_ARRAY_BUFFER, drawer->super.instances);
void loshader_bullet_program_deinitialize(loshader_bullet_program_t* prog) {
assert(prog != NULL);
# define enable_(index, var, dim, type) do { \
glEnableVertexAttribArray(index); \
glVertexAttribPointer( \
index, dim, type, GL_FALSE, \
sizeof(loshader_bullet_drawer_internal_instance_t), \
NULL + offsetof(loshader_bullet_drawer_internal_instance_t, var)); \
glVertexAttribDivisor(index, 1); \
} while (0)
glDeleteProgram(*prog);
}
enable_(VSHADER_IN_BULLET_ID_, bullet_id, 1, GL_UNSIGNED_SHORT);
loshader_bullet_drawer_t* loshader_bullet_drawer_new(
const loshader_bullet_program_t* prog,
const loshader_uniblock_t* uniblock) {
assert(prog != NULL);
assert(uniblock != NULL);
enable_(VSHADER_IN_POS_, pos, 2, GL_FLOAT);
enable_(VSHADER_IN_SIZE_, size, 2, GL_FLOAT);
enable_(VSHADER_IN_THETA_, theta, 1, GL_FLOAT);
enable_(VSHADER_IN_TIME_, time, 1, GL_FLOAT);
loshader_bullet_drawer_t* drawer = memory_new(sizeof(*drawer));
*drawer = (typeof(*drawer)) {
.prog = prog,
.uniblock = uniblock,
};
enable_(VSHADER_IN_COLOR_, color, 4, GL_FLOAT);
glCreateVertexArrays(1, &drawer->vao);
glBindVertexArray(drawer->vao);
glGenBuffers(1, &drawer->instances);
loshader_bullet_program_setup_vao_(drawer->instances);
return drawer;
}
void loshader_bullet_drawer_delete(loshader_bullet_drawer_t* drawer) {
assert(drawer != NULL);
glDeleteBuffers(1, &drawer->instances);
glDeleteVertexArrays(1, &drawer->vao);
memory_delete(drawer);
}
void loshader_bullet_drawer_clear(
loshader_bullet_drawer_t* drawer, size_t reserve) {
assert(drawer != NULL);
assert(reserve > 0);
drawer->instances_length = 0;
if (drawer->instances_reserved < reserve) {
glBindBuffer(GL_ARRAY_BUFFER, drawer->instances);
glBufferData(GL_ARRAY_BUFFER,
reserve * sizeof(loshader_bullet_drawer_internal_instance_t),
NULL, GL_DYNAMIC_DRAW);
drawer->instances_reserved = reserve;
}
# undef enable_
}
void loshader_bullet_drawer_add_instance(
@@ -155,11 +88,6 @@ void loshader_bullet_drawer_add_instance(
assert(drawer != NULL);
assert(instance != NULL);
if (drawer->instances_length >= drawer->instances_reserved) {
fprintf(stderr, "bullet drawer instance overflow\n");
abort();
}
const loshader_bullet_drawer_internal_instance_t insta = {
.bullet_id = instance->bullet_id,
.pos = instance->pos,
@@ -168,24 +96,14 @@ void loshader_bullet_drawer_add_instance(
.time = instance->time,
.color = instance->color,
};
const size_t offset = drawer->instances_length * sizeof(insta);
glBindBuffer(GL_ARRAY_BUFFER, drawer->instances);
glBufferSubData(GL_ARRAY_BUFFER, offset, sizeof(insta), &insta);
++drawer->instances_length;
if (!loshader_instanced_drawer_add_instance(&drawer->super, &insta)) {
fprintf(stderr, "bullet drawer overflow\n");
abort();
}
}
void loshader_bullet_drawer_draw(const loshader_bullet_drawer_t* drawer) {
assert(drawer != NULL);
if (drawer->instances_length == 0) return;
glUseProgram(*drawer->prog);
glBindVertexArray(drawer->vao);
loshader_uniblock_bind(drawer->uniblock, LOSHADER_BULLET_UNIBLOCK_INDEX);
glDrawArraysInstanced(GL_TRIANGLES,
0, LOSHADER_BULLET_PRIMITIVE_COUNT, drawer->instances_length);
loshader_instanced_drawer_draw(&drawer->super, PRIMITIVE_COUNT_);
}

38
core/loshader/bullet.h
View File

@@ -2,15 +2,14 @@
#include <stddef.h>
#include "util/gleasy/program.h"
#include "util/math/vector.h"
#include "./instanced.h"
#include "./uniblock.h"
typedef gleasy_program_t loshader_bullet_program_t;
struct loshader_bullet_drawer_t;
typedef struct loshader_bullet_drawer_t loshader_bullet_drawer_t;
typedef struct {
loshader_instanced_drawer_t super;
} loshader_bullet_drawer_t;
typedef enum {
LOSHADER_BULLET_ID_LIGHT = 0,
@@ -30,31 +29,16 @@ typedef struct {
} loshader_bullet_drawer_instance_t;
void
loshader_bullet_program_initialize(
loshader_bullet_program_t* prog
loshader_bullet_drawer_initialize(
loshader_bullet_drawer_t* drawer,
const loshader_uniblock_t* uniblock
);
void
loshader_bullet_program_deinitialize(
loshader_bullet_program_t* prog
);
#define loshader_bullet_drawer_deinitialize(drawer) \
loshader_instanced_drawer_deinitialize(&(drawer)->super)
loshader_bullet_drawer_t*
loshader_bullet_drawer_new(
const loshader_bullet_program_t* prog,
const loshader_uniblock_t* uniblock
);
void
loshader_bullet_drawer_delete(
loshader_bullet_drawer_t* drawer
);
void
loshader_bullet_drawer_clear(
loshader_bullet_drawer_t* drawer,
size_t reserve
);
#define loshader_bullet_drawer_clear(drawer, reserve) \
loshader_instanced_drawer_clear(&(drawer)->super, reserve)
void
loshader_bullet_drawer_add_instance(

188
core/loshader/character.c
View File

@@ -11,36 +11,26 @@
#include "util/gleasy/buffer.h"
#include "util/gleasy/program.h"
#include "util/math/vector.h"
#include "util/memory/memory.h"
#include "./instanced.h"
#include "./uniblock.h"
/* resources */
#include "anysrc/header.shader.h"
#include "anysrc/character.vshader.h"
#include "anysrc/character.fshader.h"
#include "core/loshader/anysrc/header.shader.h"
#include "core/loshader/anysrc/character.vshader.h"
#include "core/loshader/anysrc/character.fshader.h"
#define LOSHADER_CHARACTER_VSHADER_IN_CHARACTER_ID 0
#define LOSHADER_CHARACTER_VSHADER_IN_FROM_MOTION_ID 1
#define LOSHADER_CHARACTER_VSHADER_IN_TO_MOTION_ID 2
#define LOSHADER_CHARACTER_VSHADER_IN_MOTION_TIME 3
#define LOSHADER_CHARACTER_VSHADER_IN_MARKER 4
#define LOSHADER_CHARACTER_VSHADER_IN_MARKER_OFFSET 5
#define LOSHADER_CHARACTER_VSHADER_IN_POS 6
#define LOSHADER_CHARACTER_VSHADER_IN_SIZE 7
#define LOSHADER_CHARACTER_VSHADER_IN_COLOR 8
#define VSHADER_IN_CHARACTER_ID_ 0
#define VSHADER_IN_FROM_MOTION_ID_ 1
#define VSHADER_IN_TO_MOTION_ID_ 2
#define VSHADER_IN_MOTION_TIME_ 3
#define VSHADER_IN_MARKER_ 4
#define VSHADER_IN_MARKER_OFFSET_ 5
#define VSHADER_IN_POS_ 6
#define VSHADER_IN_SIZE_ 7
#define VSHADER_IN_COLOR_ 8
struct loshader_character_drawer_t {
const loshader_character_program_t* prog;
const loshader_uniblock_t* uniblock;
GLuint vao;
gleasy_buffer_array_t instances;
size_t instances_reserved;
size_t instances_length;
};
#define PRIMITIVE_COUNT_ 54
#pragma pack(push, 1)
typedef struct {
@@ -59,105 +49,46 @@ typedef struct {
} loshader_character_drawer_internal_instance_t;
#pragma pack(pop)
#define LOSHADER_CHARACTER_UNIBLOCK_INDEX 0
void loshader_character_drawer_initialize(
loshader_character_drawer_t* drawer, const loshader_uniblock_t* uniblock) {
assert(drawer != NULL);
assert(uniblock != NULL);
#define LOSHADER_CHARACTER_PRIMITIVE_COUNT 54
static void loshader_character_program_setup_vao_(
const loshader_character_program_t* prog, gleasy_buffer_array_t instances) {
assert(prog != NULL);
assert(instances != 0);
glBindBuffer(GL_ARRAY_BUFFER, instances);
# define enable_attrib_(NAME, name, dim, type) do { \
glEnableVertexAttribArray(LOSHADER_CHARACTER_VSHADER_IN_##NAME); \
glVertexAttribPointer( \
LOSHADER_CHARACTER_VSHADER_IN_##NAME, dim, type, GL_FALSE, \
sizeof(loshader_character_drawer_internal_instance_t), \
NULL + offsetof(loshader_character_drawer_internal_instance_t, name)); \
glVertexAttribDivisor(LOSHADER_CHARACTER_VSHADER_IN_##NAME, 1); \
} while (0)
enable_attrib_(CHARACTER_ID, character_id, 1, GL_UNSIGNED_SHORT);
enable_attrib_(FROM_MOTION_ID, from_motion_id, 1, GL_UNSIGNED_SHORT);
enable_attrib_(TO_MOTION_ID, to_motion_id, 1, GL_UNSIGNED_SHORT);
enable_attrib_(MOTION_TIME, motion_time, 1, GL_FLOAT);
enable_attrib_(MARKER, marker, 1, GL_FLOAT);
enable_attrib_(MARKER_OFFSET, marker_offset, 2, GL_FLOAT);
enable_attrib_(POS, pos, 2, GL_FLOAT);
enable_attrib_(SIZE, size, 2, GL_FLOAT);
enable_attrib_(COLOR, color, 4, GL_FLOAT);
# undef enable_attrib_
}
void loshader_character_program_initialize(loshader_character_program_t* prog) {
assert(prog != NULL);
*prog = gleasy_program_new(
gleasy_program_t prog = gleasy_program_new(
loshader_header_shader_, sizeof(loshader_header_shader_),
loshader_character_vshader_, sizeof(loshader_character_vshader_),
loshader_character_fshader_, sizeof(loshader_character_fshader_));
const GLuint uniblock = glGetUniformBlockIndex(*prog, "uniblock");
assert(glGetError() == GL_NO_ERROR);
loshader_instanced_drawer_initialize(
&drawer->super,
prog,
uniblock,
sizeof(loshader_character_drawer_internal_instance_t));
glUniformBlockBinding(*prog, uniblock, LOSHADER_CHARACTER_UNIBLOCK_INDEX);
}
glBindVertexArray(drawer->super.vao);
glBindBuffer(GL_ARRAY_BUFFER, drawer->super.instances);
void loshader_character_program_deinitialize(
loshader_character_program_t* prog) {
assert(prog != NULL);
# define enable_(index, var, dim, type) do { \
glEnableVertexAttribArray(index); \
glVertexAttribPointer( \
index, dim, type, GL_FALSE, \
sizeof(loshader_character_drawer_internal_instance_t), \
NULL + offsetof(loshader_character_drawer_internal_instance_t, var)); \
glVertexAttribDivisor(index, 1); \
} while (0)
glDeleteProgram(*prog);
}
enable_(VSHADER_IN_CHARACTER_ID_, character_id, 1, GL_UNSIGNED_SHORT);
enable_(VSHADER_IN_FROM_MOTION_ID_, from_motion_id, 1, GL_UNSIGNED_SHORT);
enable_(VSHADER_IN_TO_MOTION_ID_, to_motion_id, 1, GL_UNSIGNED_SHORT);
enable_(VSHADER_IN_MOTION_TIME_, motion_time, 1, GL_FLOAT);
enable_(VSHADER_IN_MARKER_, marker, 1, GL_FLOAT);
enable_(VSHADER_IN_MARKER_OFFSET_, marker_offset, 2, GL_FLOAT);
loshader_character_drawer_t* loshader_character_drawer_new(
const loshader_character_program_t* prog,
const loshader_uniblock_t* uniblock) {
assert(prog != NULL);
assert(uniblock != NULL);
enable_(VSHADER_IN_POS_, pos, 2, GL_FLOAT);
enable_(VSHADER_IN_SIZE_, size, 2, GL_FLOAT);
enable_(VSHADER_IN_COLOR_, color, 4, GL_FLOAT);
loshader_character_drawer_t* drawer = memory_new(sizeof(*drawer));
*drawer = (typeof(*drawer)) {
.prog = prog,
.uniblock = uniblock,
};
glGenBuffers(1, &drawer->instances);
glCreateVertexArrays(1, &drawer->vao);
glBindVertexArray(drawer->vao);
loshader_character_program_setup_vao_(drawer->prog, drawer->instances);
return drawer;
}
void loshader_character_drawer_delete(loshader_character_drawer_t* drawer) {
if (drawer == NULL) return;
glDeleteBuffers(1, &drawer->instances);
glDeleteVertexArrays(1, &drawer->vao);
memory_delete(drawer);
}
void loshader_character_drawer_clear(
loshader_character_drawer_t* drawer, size_t reserve) {
assert(drawer != NULL);
assert(reserve > 0);
drawer->instances_length = 0;
if (drawer->instances_reserved < reserve) {
glBindBuffer(GL_ARRAY_BUFFER, drawer->instances);
glBufferData(GL_ARRAY_BUFFER,
reserve * sizeof(loshader_character_drawer_internal_instance_t),
NULL, GL_DYNAMIC_DRAW);
drawer->instances_reserved = reserve;
}
# undef enable_
}
void loshader_character_drawer_add_instance(
@@ -166,40 +97,25 @@ void loshader_character_drawer_add_instance(
assert(drawer != NULL);
assert(instance != NULL);
if (drawer->instances_length >= drawer->instances_reserved) {
fprintf(stderr, "character drawer instance overflow\n");
abort();
}
const loshader_character_drawer_internal_instance_t insta = {
.character_id = instance->character_id,
.from_motion_id = instance->from_motion_id,
.to_motion_id = instance->to_motion_id,
.motion_time = instance->motion_time,
.from_motion_id = instance->motion.from,
.to_motion_id = instance->motion.to,
.motion_time = instance->motion.time,
.marker = instance->marker,
.marker_offset = instance->marker_offset,
.pos = instance->pos,
.size = instance->size,
.color = instance->color,
};
const size_t offset = drawer->instances_length * sizeof(insta);
glBindBuffer(GL_ARRAY_BUFFER, drawer->instances);
glBufferSubData(GL_ARRAY_BUFFER, offset, sizeof(insta), &insta);
++drawer->instances_length;
if (!loshader_instanced_drawer_add_instance(&drawer->super, &insta)) {
fprintf(stderr, "character drawer overflow\n");
abort();
}
}
void loshader_character_drawer_draw(const loshader_character_drawer_t* drawer) {
assert(drawer != NULL);
if (drawer->instances_length == 0) return;
glUseProgram(*drawer->prog);
glBindVertexArray(drawer->vao);
loshader_uniblock_bind(drawer->uniblock, LOSHADER_CHARACTER_UNIBLOCK_INDEX);
glDrawArraysInstanced(GL_TRIANGLES,
0, LOSHADER_CHARACTER_PRIMITIVE_COUNT, drawer->instances_length);
loshader_instanced_drawer_draw(&drawer->super, PRIMITIVE_COUNT_);
}

48
core/loshader/character.h
View File

@@ -3,15 +3,14 @@
#include <stddef.h>
#include <stdint.h>
#include "util/gleasy/program.h"
#include "util/math/vector.h"
#include "./instanced.h"
#include "./uniblock.h"
typedef gleasy_program_t loshader_character_program_t;
struct loshader_character_drawer_t;
typedef struct loshader_character_drawer_t loshader_character_drawer_t;
typedef struct {
loshader_instanced_drawer_t super;
} loshader_character_drawer_t;
typedef enum {
LOSHADER_CHARACTER_ID_PLAYER = 0,
@@ -34,9 +33,11 @@ typedef enum {
typedef struct {
loshader_character_id_t character_id;
uint32_t from_motion_id;
uint32_t to_motion_id;
float motion_time;
struct {
loshader_character_motion_id_t from;
loshader_character_motion_id_t to;
float time;
} motion;
float marker;
vec2_t marker_offset;
@@ -47,32 +48,17 @@ typedef struct {
} loshader_character_drawer_instance_t;
void
loshader_character_program_initialize(
loshader_character_program_t* prog
);
void
loshader_character_program_deinitialize(
loshader_character_program_t* prog
);
loshader_character_drawer_t* /* OWNERSHIP */
loshader_character_drawer_new(
const loshader_character_program_t* prog,
const loshader_uniblock_t* uniblock
);
void
loshader_character_drawer_delete(
loshader_character_drawer_t* drawer /* OWNERSHIP */
);
void
loshader_character_drawer_clear(
loshader_character_drawer_initialize(
loshader_character_drawer_t* drawer,
size_t reserve
const loshader_uniblock_t* uniblock
);
#define loshader_character_drawer_deinitialize(drawer) \
loshader_instanced_drawer_deinitialize(&(drawer)->super)
#define loshader_character_drawer_clear(drawer, reserve) \
loshader_instanced_drawer_clear(&(drawer)->super, reserve)
void
loshader_character_drawer_add_instance(
loshader_character_drawer_t* drawer,

4
core/loshader/character.vshader
View File

@@ -105,6 +105,9 @@ vec2 cavia_stand1(void) {
);
return gl_VertexID < verts.length()? verts[gl_VertexID]: vec2(0.);
}
vec2 cavia_stand2(void) {
return cavia_stand1()*vec2(1., .95) + vec2(0., -.05);
}
vec2 cavia_walk(void) {
const vec2[] verts = vec2[](
vec2( 0.06, 1.00), vec2(-0.16, 0.72), vec2( 0.36, 0.58),
@@ -176,6 +179,7 @@ vec2 cavia_down(void) {
vec2 cavia(in float motion_id) {
return
(motion_id == 0.)? cavia_stand1():
(motion_id == 1.)? cavia_stand2():
(motion_id == 2.)? cavia_walk():
(motion_id == 3.)? cavia_attack1():
(motion_id == 4.)? cavia_attack2():

96
core/loshader/cinescope.c
View File

@@ -4,89 +4,46 @@
#include <stddef.h>
#include <stdint.h>
#include "util/gleasy/buffer.h"
#include "util/gleasy/program.h"
#include "util/math/vector.h"
#include "util/memory/memory.h"
#include "./single.h"
#include "./uniblock.h"
/* resources */
#include "anysrc/header.shader.h"
#include "anysrc/cinescope.vshader.h"
#include "anysrc/cinescope.fshader.h"
#include "core/loshader/anysrc/header.shader.h"
#include "core/loshader/anysrc/cinescope.vshader.h"
#include "core/loshader/anysrc/cinescope.fshader.h"
struct loshader_cinescope_drawer_t {
const loshader_cinescope_program_t* prog;
const loshader_uniblock_t* uniblock;
gleasy_buffer_uniform_t param;
};
#define PRIMITIVE_COUNT_ 12
#pragma pack(push, 1)
typedef struct {
vec4_t color;
float size;
} loshader_cinescope_drawer_internal_param_t;
_Static_assert(
sizeof(float)*5 ==
sizeof(loshader_cinescope_drawer_internal_param_t));
#pragma pack(pop)
#define LOSHADER_CINESCOPE_UNIBLOCK_INDEX 0
#define LOSHADER_CINESCOPE_PARAM_INDEX 1
_Static_assert(
sizeof(float)*5 ==
sizeof(loshader_cinescope_drawer_internal_param_t),
"recheck the type has no padding");
#define LOSHADER_CINESCOPE_PRIMITIVE_COUNT 12
void loshader_cinescope_drawer_initialize(
loshader_cinescope_drawer_t* drawer,
const loshader_uniblock_t* uniblock) {
assert(drawer != NULL);
assert(uniblock != NULL);
void loshader_cinescope_program_initialize(loshader_cinescope_program_t* prog) {
assert(prog != NULL);
*prog = gleasy_program_new(
loshader_header_shader_, sizeof(loshader_header_shader_),
const gleasy_program_t prog = gleasy_program_new(
loshader_header_shader_, sizeof(loshader_header_shader_),
loshader_cinescope_vshader_, sizeof(loshader_cinescope_vshader_),
loshader_cinescope_fshader_, sizeof(loshader_cinescope_fshader_));
const GLuint uniblock = glGetUniformBlockIndex(*prog, "uniblock");
assert(glGetError() == GL_NO_ERROR);
glUniformBlockBinding(*prog, uniblock, LOSHADER_CINESCOPE_UNIBLOCK_INDEX);
const GLuint param = glGetUniformBlockIndex(*prog, "param");
assert(glGetError() == GL_NO_ERROR);
glUniformBlockBinding(*prog, param, LOSHADER_CINESCOPE_PARAM_INDEX);
}
void loshader_cinescope_program_deinitialize(loshader_cinescope_program_t* prog) {
assert(prog != NULL);
glDeleteProgram(*prog);
}
loshader_cinescope_drawer_t* loshader_cinescope_drawer_new(
const loshader_cinescope_program_t* prog,
const loshader_uniblock_t* uniblock) {
assert(prog != NULL);
assert(uniblock != NULL);
loshader_cinescope_drawer_t* drawer = memory_new(sizeof(*drawer));
*drawer = (typeof(*drawer)) {
.prog = prog,
.uniblock = uniblock,
};
glGenBuffers(1, &drawer->param);
glBindBuffer(GL_UNIFORM_BUFFER, drawer->param);
glBufferData(GL_UNIFORM_BUFFER,
sizeof(loshader_cinescope_drawer_internal_param_t), NULL, GL_DYNAMIC_DRAW);
return drawer;
}
void loshader_cinescope_drawer_delete(loshader_cinescope_drawer_t* drawer) {
if (drawer == NULL) return;
glDeleteBuffers(1, &drawer->param);
memory_delete(drawer);
loshader_single_drawer_initialize(
&drawer->super,
prog,
uniblock,
sizeof(loshader_cinescope_drawer_internal_param_t));
}
void loshader_cinescope_drawer_set_param(
@@ -99,18 +56,11 @@ void loshader_cinescope_drawer_set_param(
.size = param->size,
.color = param->color,
};
glBindBuffer(GL_UNIFORM_BUFFER, drawer->param);
glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(p), &p);
loshader_single_drawer_set_param(&drawer->super, &p);
}
void loshader_cinescope_drawer_draw(const loshader_cinescope_drawer_t* drawer) {
assert(drawer != NULL);
glUseProgram(*drawer->prog);
loshader_uniblock_bind(drawer->uniblock, LOSHADER_CINESCOPE_UNIBLOCK_INDEX);
glBindBufferBase(GL_UNIFORM_BUFFER,
LOSHADER_CINESCOPE_PARAM_INDEX, drawer->param);
glDrawArrays(GL_TRIANGLES, 0, LOSHADER_CINESCOPE_PRIMITIVE_COUNT);
loshader_single_drawer_draw(&drawer->super, PRIMITIVE_COUNT_);
}

33
core/loshader/cinescope.h
View File

@@ -1,14 +1,15 @@
#pragma once
#include "util/gleasy/program.h"
#include <stddef.h>
#include "util/math/vector.h"
#include "./single.h"
#include "./uniblock.h"
typedef gleasy_program_t loshader_cinescope_program_t;
struct loshader_cinescope_drawer_t;
typedef struct loshader_cinescope_drawer_t loshader_cinescope_drawer_t;
typedef struct {
loshader_single_drawer_t super;
} loshader_cinescope_drawer_t;
typedef struct {
float size;
@@ -16,25 +17,13 @@ typedef struct {
} loshader_cinescope_drawer_param_t;
void
loshader_cinescope_program_initialize(
loshader_cinescope_program_t* prog
loshader_cinescope_drawer_initialize(
loshader_cinescope_drawer_t* drawer,
const loshader_uniblock_t* uniblock
);
void
loshader_cinescope_program_deinitialize(
loshader_cinescope_program_t* prog
);
loshader_cinescope_drawer_t*
loshader_cinescope_drawer_new(
const loshader_cinescope_program_t* prog,
const loshader_uniblock_t* uniblock
);
void
loshader_cinescope_drawer_delete(
loshader_cinescope_drawer_t* drawer
);
#define loshader_cinescope_drawer_deinitialize(drawer) \
loshader_single_drawer_deinitialize(&(drawer)->super)
void
loshader_cinescope_drawer_set_param(

167
core/loshader/combat_ring.c
View File

@@ -7,34 +7,24 @@
#include <GL/glew.h>
#include "util/gleasy/buffer.h"
#include "util/gleasy/program.h"
#include "util/math/algorithm.h"
#include "util/math/constant.h"
#include "util/math/vector.h"
#include "util/memory/memory.h"
#include "./instanced.h"
#include "./uniblock.h"
/* resources */
#include "anysrc/header.shader.h"
#include "anysrc/combat_ring.vshader.h"
#include "anysrc/combat_ring.fshader.h"
#include "core/loshader/anysrc/header.shader.h"
#include "core/loshader/anysrc/combat_ring.vshader.h"
#include "core/loshader/anysrc/combat_ring.fshader.h"
#define LOSHADER_COMBAT_RING_VSHADER_IN_RANGE 0
#define LOSHADER_COMBAT_RING_VSHADER_IN_PERIOD 1
#define LOSHADER_COMBAT_RING_VSHADER_IN_COLOR 2
#define VSHADER_IN_RANGE_ 0
#define VSHADER_IN_PERIOD_ 1
#define VSHADER_IN_COLOR_ 2
struct loshader_combat_ring_drawer_t {
const loshader_combat_ring_program_t* prog;
const loshader_uniblock_t* uniblock;
GLuint vao;
gleasy_buffer_array_t instances;
size_t instances_reserved;
size_t instances_length;
};
#define PRIMITIVE_COUNT_ 6
#pragma pack(push, 1)
typedef struct {
@@ -44,102 +34,41 @@ typedef struct {
} loshader_combat_ring_drawer_internal_instance_t;
#pragma pack(pop)
#define LOSHADER_COMBAT_RING_UNIBLOCK_INDEX 0
void loshader_combat_ring_drawer_initialize(
loshader_combat_ring_drawer_t* drawer,
const loshader_uniblock_t* uniblock) {
assert(drawer != NULL);
assert(uniblock != NULL);
#define LOSHADER_COMBAT_RING_PRIMITIVE_COUNT 6
static void loshader_combat_ring_program_setup_vao_(
gleasy_buffer_array_t instances) {
assert(instances != 0);
glBindBuffer(GL_ARRAY_BUFFER, instances);
glEnableVertexAttribArray(LOSHADER_COMBAT_RING_VSHADER_IN_RANGE);
glVertexAttribPointer(
LOSHADER_COMBAT_RING_VSHADER_IN_RANGE, 1, GL_FLOAT, GL_FALSE,
sizeof(loshader_combat_ring_drawer_internal_instance_t),
NULL + offsetof(loshader_combat_ring_drawer_internal_instance_t, range));
glVertexAttribDivisor(LOSHADER_COMBAT_RING_VSHADER_IN_RANGE, 1);
glEnableVertexAttribArray(LOSHADER_COMBAT_RING_VSHADER_IN_PERIOD);
glVertexAttribPointer(
LOSHADER_COMBAT_RING_VSHADER_IN_PERIOD, 2, GL_FLOAT, GL_FALSE,
sizeof(loshader_combat_ring_drawer_internal_instance_t),
NULL + offsetof(loshader_combat_ring_drawer_internal_instance_t, period));
glVertexAttribDivisor(LOSHADER_COMBAT_RING_VSHADER_IN_PERIOD, 1);
glEnableVertexAttribArray(LOSHADER_COMBAT_RING_VSHADER_IN_COLOR);
glVertexAttribPointer(
LOSHADER_COMBAT_RING_VSHADER_IN_COLOR, 4, GL_FLOAT, GL_FALSE,
sizeof(loshader_combat_ring_drawer_internal_instance_t),
NULL + offsetof(loshader_combat_ring_drawer_internal_instance_t, color));
glVertexAttribDivisor(LOSHADER_COMBAT_RING_VSHADER_IN_COLOR, 1);
}
void loshader_combat_ring_program_initialize(
loshader_combat_ring_program_t* prog) {
assert(prog != NULL);
*prog = gleasy_program_new(
const gleasy_program_t prog = gleasy_program_new(
loshader_header_shader_, sizeof(loshader_header_shader_),
loshader_combat_ring_vshader_, sizeof(loshader_combat_ring_vshader_),
loshader_combat_ring_fshader_, sizeof(loshader_combat_ring_fshader_));
const GLuint uniblock = glGetUniformBlockIndex(*prog, "uniblock");
assert(glGetError() == GL_NO_ERROR);
loshader_instanced_drawer_initialize(
&drawer->super,
prog,
uniblock,
sizeof(loshader_combat_ring_drawer_internal_instance_t));
glUniformBlockBinding(*prog, uniblock, LOSHADER_COMBAT_RING_UNIBLOCK_INDEX);
}
glBindVertexArray(drawer->super.vao);
glBindBuffer(GL_ARRAY_BUFFER, drawer->super.instances);
void loshader_combat_ring_program_deinitialize(
loshader_combat_ring_program_t* prog) {
assert(prog != NULL);
# define enable_(index, var, dim, type) do { \
glEnableVertexAttribArray(index); \
glVertexAttribPointer( \
index, dim, type, GL_FALSE, \
sizeof(loshader_combat_ring_drawer_internal_instance_t), \
NULL + \
offsetof(loshader_combat_ring_drawer_internal_instance_t, var)); \
glVertexAttribDivisor(index, 1); \
} while (0)
glDeleteProgram(*prog);
}
enable_(VSHADER_IN_RANGE_, range, 1, GL_FLOAT);
enable_(VSHADER_IN_PERIOD_, period, 2, GL_FLOAT);
enable_(VSHADER_IN_COLOR_, color, 4, GL_FLOAT);
loshader_combat_ring_drawer_t* loshader_combat_ring_drawer_new(
const loshader_combat_ring_program_t* prog,
const loshader_uniblock_t* uniblock) {
assert(prog != NULL);
assert(uniblock != NULL);
loshader_combat_ring_drawer_t* drawer = memory_new(sizeof(*drawer));
*drawer = (typeof(*drawer)) {
.prog = prog,
.uniblock = uniblock,
};
glCreateVertexArrays(1, &drawer->vao);
glBindVertexArray(drawer->vao);
glGenBuffers(1, &drawer->instances);
loshader_combat_ring_program_setup_vao_(drawer->instances);
return drawer;
}
void loshader_combat_ring_drawer_delete(loshader_combat_ring_drawer_t* drawer) {
if (drawer == NULL) return;
glDeleteBuffers(1, &drawer->instances);
glDeleteVertexArrays(1, &drawer->vao);
memory_delete(drawer);
}
void loshader_combat_ring_drawer_clear(
loshader_combat_ring_drawer_t* drawer, size_t reserve) {
assert(drawer != NULL);
drawer->instances_length = 0;
if (drawer->instances_reserved < reserve) {
glBindBuffer(GL_ARRAY_BUFFER, drawer->instances);
glBufferData(GL_ARRAY_BUFFER,
reserve * sizeof(loshader_combat_ring_drawer_internal_instance_t),
NULL, GL_DYNAMIC_DRAW);
drawer->instances_reserved = reserve;
}
# undef enable_
}
void loshader_combat_ring_drawer_add_instance(
@@ -148,36 +77,20 @@ void loshader_combat_ring_drawer_add_instance(
assert(drawer != NULL);
assert(instance != NULL);
if (drawer->instances_length >= drawer->instances_reserved) {
fprintf(stderr, "combat ring drawer instance overflow\n");
abort();
}
const size_t offset = drawer->instances_length *
sizeof(loshader_combat_ring_drawer_internal_instance_t);
const loshader_combat_ring_drawer_internal_instance_t i = {
const loshader_combat_ring_drawer_internal_instance_t insta = {
.range = instance->range,
.period = vec2(instance->start, instance->end),
.color = instance->color,
};
glBindBuffer(GL_ARRAY_BUFFER, drawer->instances);
glBufferSubData(GL_ARRAY_BUFFER, offset, sizeof(i), &i);
++drawer->instances_length;
if (!loshader_instanced_drawer_add_instance(&drawer->super, &insta)) {
fprintf(stderr, "combat ring drawer overflow\n");
abort();
}
}
void loshader_combat_ring_drawer_draw(
const loshader_combat_ring_drawer_t* drawer) {
assert(drawer != NULL);
if (drawer->instances_length == 0) return;
glUseProgram(*drawer->prog);
glBindVertexArray(drawer->vao);
loshader_uniblock_bind(drawer->uniblock, LOSHADER_COMBAT_RING_UNIBLOCK_INDEX);
glDrawArraysInstanced(GL_TRIANGLES,
0, LOSHADER_COMBAT_RING_PRIMITIVE_COUNT, drawer->instances_length);
loshader_instanced_drawer_draw(&drawer->super, PRIMITIVE_COUNT_);
}

42
core/loshader/combat_ring.h
View File

@@ -1,16 +1,13 @@
#pragma once
#include <stddef.h>
#include "util/gleasy/program.h"
#include "util/math/vector.h"
#include "./instanced.h"
#include "./uniblock.h"
typedef gleasy_program_t loshader_combat_ring_program_t;
struct loshader_combat_ring_drawer_t;
typedef struct loshader_combat_ring_drawer_t loshader_combat_ring_drawer_t;
typedef struct {
loshader_instanced_drawer_t super;
} loshader_combat_ring_drawer_t;
typedef struct {
float range;
@@ -20,32 +17,17 @@ typedef struct {
} loshader_combat_ring_drawer_instance_t;
void
loshader_combat_ring_program_initialize(
loshader_combat_ring_program_t* prog
);
void
loshader_combat_ring_program_deinitialize(
loshader_combat_ring_program_t* prog
);
loshader_combat_ring_drawer_t* /* OWNERSHIP */
loshader_combat_ring_drawer_new(
const loshader_combat_ring_program_t* prog,
const loshader_uniblock_t* uniblock
);
void
loshader_combat_ring_drawer_delete(
loshader_combat_ring_drawer_t* drawer /* OWNERSHIP */
);
void
loshader_combat_ring_drawer_clear(
loshader_combat_ring_drawer_initialize(
loshader_combat_ring_drawer_t* drawer,
size_t reserve
const loshader_uniblock_t* uniblock
);
#define loshader_combat_ring_drawer_deinitialize(drawer) \
loshader_instanced_drawer_deinitialize(&(drawer)->super)
#define loshader_combat_ring_drawer_clear(drawer, reserve) \
loshader_instanced_drawer_clear(&(drawer)->super, reserve)
void
loshader_combat_ring_drawer_add_instance(
loshader_combat_ring_drawer_t* drawer,

87
core/loshader/event_line.c
View File

@@ -1,91 +1,32 @@
#include "./event_line.h"
#include <assert.h>
#include <stddef.h>
#include "util/gleasy/program.h"
#include "util/gleasy/texture.h"
#include "util/glyphas/block.h"
#include "util/glyphas/drawer.h"
#include "./text.h"
#include "./uniblock.h"
/* resources */
#include "anysrc/header.shader.h"
#include "anysrc/event_line.vshader.h"
#include "anysrc/event_line.fshader.h"
#include "core/loshader/anysrc/header.shader.h"
#include "core/loshader/anysrc/event_line.vshader.h"
#include "core/loshader/anysrc/event_line.fshader.h"
#define LOSHADER_EVENT_LINE_UNIBLOCK_INDEX 0
#define UNIBLOCK_INDEX_ 0
void loshader_event_line_program_initialize(
loshader_event_line_program_t* prog) {
assert(prog != NULL);
void loshader_event_line_drawer_initialize(
loshader_event_line_drawer_t* drawer,
const loshader_uniblock_t* uniblock,
gleasy_texture_2d_t tex) {
assert(drawer != NULL);
assert(uniblock != NULL);
assert(tex != 0);
*prog = gleasy_program_new(
const gleasy_program_t prog = gleasy_program_new(
loshader_header_shader_, sizeof(loshader_header_shader_),
loshader_event_line_vshader_, sizeof(loshader_event_line_vshader_),
loshader_event_line_fshader_, sizeof(loshader_event_line_fshader_));
const GLuint uniblock = glGetUniformBlockIndex(*prog, "uniblock");
assert(glGetError() == GL_NO_ERROR);
glUniformBlockBinding(*prog, uniblock, LOSHADER_EVENT_LINE_UNIBLOCK_INDEX);
}
void loshader_event_line_program_deinitialize(
loshader_event_line_program_t* prog) {
assert(prog != NULL);
glDeleteProgram(*prog);
}
void loshader_event_line_drawer_initialize(
loshader_event_line_drawer_t* drawer,
const loshader_event_line_program_t* prog,
const loshader_uniblock_t* uniblock,
gleasy_texture_2d_t tex) {
assert(drawer != NULL);
assert(prog != NULL);
assert(uniblock != NULL);
assert(tex != 0);
*drawer = (typeof(*drawer)) {
.prog = prog,
.uniblock = uniblock,
.tex = tex,
.glyphas = glyphas_drawer_new(),
};
}
void loshader_event_line_drawer_deinitialize(
loshader_event_line_drawer_t* drawer) {
assert(drawer != NULL);
glyphas_drawer_delete(drawer->glyphas);
}
void loshader_event_line_drawer_clear(
loshader_event_line_drawer_t* drawer, size_t reserve) {
assert(drawer != NULL);
assert(reserve > 0);
glyphas_drawer_clear(drawer->glyphas, drawer->tex, reserve);
}
void loshader_event_line_drawer_add_block(
loshader_event_line_drawer_t* drawer, const glyphas_block_t* block) {
assert(drawer != NULL);
assert(block != NULL);
glyphas_drawer_add_block(drawer->glyphas, block);
}
void loshader_event_line_drawer_draw(const loshader_event_line_drawer_t* drawer) {
assert(drawer != NULL);
glUseProgram(*drawer->prog);
loshader_uniblock_bind(drawer->uniblock, LOSHADER_EVENT_LINE_UNIBLOCK_INDEX);
glyphas_drawer_draw(drawer->glyphas);
loshader_text_drawer_initialize(&drawer->super, prog, uniblock, tex);
}

62
core/loshader/event_line.h
View File

@@ -1,63 +1,29 @@
#pragma once
#include <stddef.h>
#include "util/gleasy/program.h"
#include "util/gleasy/texture.h"
#include "util/glyphas/block.h"
#include "util/glyphas/drawer.h"
#include "./text.h"
#include "./uniblock.h"
typedef gleasy_program_t loshader_event_line_program_t;
typedef struct {
/* injected deps */
const loshader_event_line_program_t* prog;
const loshader_uniblock_t* uniblock;
gleasy_texture_2d_t tex;
/* owned objects */
glyphas_drawer_t* glyphas;
loshader_text_drawer_t super;
} loshader_event_line_drawer_t;
void
loshader_event_line_program_initialize(
loshader_event_line_program_t* prog
);
void
loshader_event_line_program_deinitialize(
loshader_event_line_program_t* prog
);
void
loshader_event_line_drawer_initialize(
loshader_event_line_drawer_t* drawer,
const loshader_event_line_program_t* prog,
const loshader_uniblock_t* uniblock,
gleasy_texture_2d_t tex
);
void
loshader_event_line_drawer_deinitialize(
loshader_event_line_drawer_t* drawer
);
void
loshader_event_line_drawer_clear(
loshader_event_line_drawer_t* drawer,
size_t reserve
const loshader_uniblock_t* uniblock,
gleasy_texture_2d_t tex
);
void
loshader_event_line_drawer_add_block(
loshader_event_line_drawer_t* drawer,
const glyphas_block_t* block
);
#define loshader_event_line_drawer_deinitialize(drawer) \
loshader_text_drawer_deinitialize(&(drawer)->super)
void
loshader_event_line_drawer_draw(
const loshader_event_line_drawer_t* drawer
);
#define loshader_event_line_drawer_clear(drawer, reserve) \
loshader_text_drawer_clear(&(drawer)->super, reserve)
#define loshader_event_line_drawer_add_block(drawer, block) \
loshader_text_drawer_add_block(&(drawer)->super, block)
#define loshader_event_line_drawer_draw(drawer) \
loshader_text_drawer_draw(&(drawer)->super)

99
core/loshader/fog.c
View File

@@ -1,29 +1,21 @@
#include "./fog.h"
#include <assert.h>
#include <stddef.h>
#include <stdint.h>
#include "util/gleasy/buffer.h"
#include "util/gleasy/program.h"
#include "util/math/vector.h"
#include "util/memory/memory.h"
#include "core/locommon/position.h"
#include "./single.h"
#include "./uniblock.h"
/* resources */
#include "anysrc/header.shader.h"
#include "anysrc/fog.vshader.h"
#include "anysrc/fog.fshader.h"
#include "core/loshader/anysrc/header.shader.h"
#include "core/loshader/anysrc/fog.vshader.h"
#include "core/loshader/anysrc/fog.fshader.h"
struct loshader_fog_drawer_t {
const loshader_fog_program_t* prog;
const loshader_uniblock_t* uniblock;
gleasy_buffer_uniform_t param;
};
#define PRIMITIVE_COUNT_ 6
#pragma pack(push, 1)
typedef struct {
@@ -35,65 +27,29 @@ typedef struct {
vec4_t bounds_pos;
vec2_t bounds_size;
} loshader_fog_drawer_internal_param_t;
_Static_assert(
sizeof(float)*10 ==
sizeof(loshader_fog_drawer_internal_param_t));
#pragma pack(pop)
#define LOSHADER_FOG_UNIBLOCK_INDEX 0
#define LOSHADER_FOG_PARAM_INDEX 1
_Static_assert(
sizeof(float)*10 ==
sizeof(loshader_fog_drawer_internal_param_t),
"recheck the type has no padding");
#define LOSHADER_FOG_PRIMITIVE_COUNT 6
void loshader_fog_program_initialize(loshader_fog_program_t* prog) {
assert(prog != NULL);
*prog = gleasy_program_new(
loshader_header_shader_, sizeof(loshader_header_shader_),
loshader_fog_vshader_, sizeof(loshader_fog_vshader_),
loshader_fog_fshader_, sizeof(loshader_fog_fshader_));
const GLuint uniblock = glGetUniformBlockIndex(*prog, "uniblock");
assert(glGetError() == GL_NO_ERROR);
glUniformBlockBinding(*prog, uniblock, LOSHADER_FOG_UNIBLOCK_INDEX);
const GLuint param = glGetUniformBlockIndex(*prog, "param");
assert(glGetError() == GL_NO_ERROR);
glUniformBlockBinding(*prog, param, LOSHADER_FOG_PARAM_INDEX);
}
void loshader_fog_program_deinitialize(loshader_fog_program_t* prog) {
assert(prog != NULL);
glDeleteProgram(*prog);
}
loshader_fog_drawer_t* loshader_fog_drawer_new(
const loshader_fog_program_t* prog,
const loshader_uniblock_t* uniblock) {
assert(prog != NULL);
void loshader_fog_drawer_initialize(
loshader_fog_drawer_t* drawer,
const loshader_uniblock_t* uniblock) {
assert(drawer != NULL);
assert(uniblock != NULL);
loshader_fog_drawer_t* drawer = memory_new(sizeof(*drawer));
*drawer = (typeof(*drawer)) {
.prog = prog,
.uniblock = uniblock,
};
const gleasy_program_t prog = gleasy_program_new(
loshader_header_shader_, sizeof(loshader_header_shader_),
loshader_fog_vshader_, sizeof(loshader_fog_vshader_),
loshader_fog_fshader_, sizeof(loshader_fog_fshader_));
glGenBuffers(1, &drawer->param);
glBindBuffer(GL_UNIFORM_BUFFER, drawer->param);
glBufferData(GL_UNIFORM_BUFFER,
sizeof(loshader_fog_drawer_internal_param_t), NULL, GL_DYNAMIC_DRAW);
return drawer;
}
void loshader_fog_drawer_delete(loshader_fog_drawer_t* drawer) {
if (drawer == NULL) return;
glDeleteBuffers(1, &drawer->param);
memory_delete(drawer);
loshader_single_drawer_initialize(
&drawer->super,
prog,
uniblock,
sizeof(loshader_fog_drawer_internal_param_t));
}
void loshader_fog_drawer_set_param(
@@ -114,18 +70,11 @@ void loshader_fog_drawer_set_param(
param->bounds_pos.fract.y),
.bounds_size = param->bounds_size,
};
glBindBuffer(GL_UNIFORM_BUFFER, drawer->param);
glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(p), &p);
loshader_single_drawer_set_param(&drawer->super, &p);
}
void loshader_fog_drawer_draw(const loshader_fog_drawer_t* drawer) {
assert(drawer != NULL);
glUseProgram(*drawer->prog);
loshader_uniblock_bind(drawer->uniblock, LOSHADER_FOG_UNIBLOCK_INDEX);
glBindBufferBase(GL_UNIFORM_BUFFER,
LOSHADER_FOG_PARAM_INDEX, drawer->param);
glDrawArrays(GL_TRIANGLES, 0, LOSHADER_FOG_PRIMITIVE_COUNT);
loshader_single_drawer_draw(&drawer->super, PRIMITIVE_COUNT_);
}

2
core/loshader/fog.fshader
View File

@@ -73,7 +73,7 @@ vec4 bounds_fog(void) {
vec2 pos;
pos.x = (p.bounds_pos.x - uni.pos.x) + (p.bounds_pos.z - uni.pos.z);
pos.y = (p.bounds_pos.y - uni.pos.y) + (p.bounds_pos.y - uni.pos.y);
pos.y = (p.bounds_pos.y - uni.pos.y) + (p.bounds_pos.w - uni.pos.w);
pos = (uni.proj * uni.cam * vec4(pos, 0., 1.)).xy;
vec2 size = (uni.proj * uni.cam * vec4(p.bounds_size, 0., 0.)).xy;

31
core/loshader/fog.h
View File

@@ -1,14 +1,15 @@
#pragma once
#include "util/gleasy/program.h"
#include "util/math/vector.h"
#include "core/locommon/position.h"
#include "./single.h"
#include "./uniblock.h"
typedef gleasy_program_t loshader_fog_program_t;
typedef struct loshader_fog_drawer_t loshader_fog_drawer_t;
typedef struct {
loshader_single_drawer_t super;
} loshader_fog_drawer_t;
typedef enum {
LOSHADER_FOG_TYPE_NONE = 0,
@@ -27,25 +28,13 @@ typedef struct {
} loshader_fog_drawer_param_t;
void
loshader_fog_program_initialize(
loshader_fog_program_t* prog
loshader_fog_drawer_initialize(
loshader_fog_drawer_t* drawer,
const loshader_uniblock_t* uniblock
);
void
loshader_fog_program_deinitialize(
loshader_fog_program_t* prog
);
loshader_fog_drawer_t*
loshader_fog_drawer_new(
const loshader_fog_program_t* prog,
const loshader_uniblock_t* uniblock
);
void
loshader_fog_drawer_delete(
loshader_fog_drawer_t* drawer
);
#define loshader_fog_drawer_deinitialize(drawer) \
loshader_single_drawer_deinitialize(&(drawer)->super)
void
loshader_fog_drawer_set_param(

160
core/loshader/ground.c
View File

@@ -1,42 +1,25 @@
#include "./ground.h"
#include <assert.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <GL/glew.h>
#include "util/math/algorithm.h"
#include "util/math/matrix.h"
#include "util/math/vector.h"
#include "util/memory/memory.h"
#include "util/gleasy/buffer.h"
#include "util/gleasy/program.h"
#include "./instanced.h"
#include "./uniblock.h"
/* resources */
#include "anysrc/header.shader.h"
#include "anysrc/ground.vshader.h"
#include "anysrc/ground.fshader.h"
#include "core/loshader/anysrc/header.shader.h"
#include "core/loshader/anysrc/ground.vshader.h"
#include "core/loshader/anysrc/ground.fshader.h"
#define LOSHADER_GROUND_VSHADER_IN_GROUND_ID 0
#define LOSHADER_GROUND_VSHADER_IN_POS 1
#define LOSHADER_GROUND_VSHADER_IN_SIZE 2
#define VSHADER_IN_GROUND_ID_ 0
#define VSHADER_IN_POS_ 1
#define VSHADER_IN_SIZE_ 2
struct loshader_ground_drawer_t {
const loshader_ground_program_t* prog;
const loshader_uniblock_t* uniblock;
GLuint vao;
gleasy_buffer_array_t instances;
size_t instances_reserved;
size_t instances_length;
};
#define PRIMITIVE_COUNT_ 6
#pragma pack(push, 1)
typedef struct {
@@ -47,90 +30,40 @@ typedef struct {
} loshader_ground_drawer_internal_instance_t;
#pragma pack(pop)
#define LOSHADER_GROUND_UNIBLOCK_INDEX 0
void loshader_ground_drawer_initialize(
loshader_ground_drawer_t* drawer,
const loshader_uniblock_t* uniblock) {
assert(drawer != NULL);
assert(uniblock != NULL);
#define LOSHADER_GROUND_PRIMITIVE_COUNT 6
static void loshader_ground_program_setup_vao_(
gleasy_buffer_array_t instances) {
assert(instances != 0);
glBindBuffer(GL_ARRAY_BUFFER, instances);
# define enable_attrib_(NAME, name, dim, type) do { \
glEnableVertexAttribArray(LOSHADER_GROUND_VSHADER_IN_##NAME); \
glVertexAttribPointer( \
LOSHADER_GROUND_VSHADER_IN_##NAME, \
dim, type, GL_FALSE, sizeof(loshader_ground_drawer_internal_instance_t), \
NULL + offsetof(loshader_ground_drawer_internal_instance_t, name)); \
glVertexAttribDivisor(LOSHADER_GROUND_VSHADER_IN_##NAME, 1); \
} while (0)
enable_attrib_(GROUND_ID, ground_id, 1, GL_UNSIGNED_SHORT);
enable_attrib_(POS, pos, 2, GL_FLOAT);
enable_attrib_(SIZE, size, 2, GL_FLOAT);
# undef enable_attrib_
}
void loshader_ground_program_initialize(loshader_ground_program_t* prog) {
*prog = gleasy_program_new(
const gleasy_program_t prog = gleasy_program_new(
loshader_header_shader_, sizeof(loshader_header_shader_),
loshader_ground_vshader_, sizeof(loshader_ground_vshader_),
loshader_ground_fshader_, sizeof(loshader_ground_fshader_));
const GLuint uniblock = glGetUniformBlockIndex(*prog, "uniblock");
assert(glGetError() == GL_NO_ERROR);
loshader_instanced_drawer_initialize(
&drawer->super,
prog,
uniblock,
sizeof(loshader_ground_drawer_internal_instance_t));
glUniformBlockBinding(*prog, uniblock, LOSHADER_GROUND_UNIBLOCK_INDEX);
}
void loshader_ground_program_deinitialize(loshader_ground_program_t* prog) {
assert(prog != NULL);
glBindVertexArray(drawer->super.vao);
glBindBuffer(GL_ARRAY_BUFFER, drawer->super.instances);
glDeleteProgram(*prog);
}
# define enable_(index, var, dim, type) do { \
glEnableVertexAttribArray(index); \
glVertexAttribPointer( \
index, dim, type, GL_FALSE, \
sizeof(loshader_ground_drawer_internal_instance_t), \
NULL + offsetof(loshader_ground_drawer_internal_instance_t, var)); \
glVertexAttribDivisor(index, 1); \
} while (0)
loshader_ground_drawer_t* loshader_ground_drawer_new(
const loshader_ground_program_t* prog,
const loshader_uniblock_t* uniblock) {
assert(prog != NULL);
assert(uniblock != NULL);
enable_(VSHADER_IN_GROUND_ID_, ground_id, 1, GL_UNSIGNED_SHORT);
enable_(VSHADER_IN_POS_, pos, 2, GL_FLOAT);
enable_(VSHADER_IN_SIZE_, size, 2, GL_FLOAT);
loshader_ground_drawer_t* drawer = memory_new(sizeof(*drawer));
*drawer = (typeof(*drawer)) {
.prog = prog,
.uniblock = uniblock,
};
glCreateVertexArrays(1, &drawer->vao);
glBindVertexArray(drawer->vao);
glGenBuffers(1, &drawer->instances);
loshader_ground_program_setup_vao_(drawer->instances);
return drawer;
}
void loshader_ground_drawer_delete(loshader_ground_drawer_t* drawer) {
if (drawer == NULL) return;
glDeleteBuffers(1, &drawer->instances);
glDeleteVertexArrays(1, &drawer->vao);
memory_delete(drawer);
}
void loshader_ground_drawer_clear(
loshader_ground_drawer_t* drawer, size_t reserve) {
assert(drawer != NULL);
drawer->instances_length = 0;
if (drawer->instances_reserved < reserve) {
glBindBuffer(GL_ARRAY_BUFFER, drawer->instances);
glBufferData(GL_ARRAY_BUFFER,
reserve * sizeof(loshader_ground_drawer_instance_t),
NULL, GL_DYNAMIC_DRAW);
drawer->instances_reserved = reserve;
}
# undef enable_
}
void loshader_ground_drawer_add_instance(
@@ -139,36 +72,19 @@ void loshader_ground_drawer_add_instance(
assert(drawer != NULL);
assert(instance != NULL);
if (drawer->instances_length >= drawer->instances_reserved) {
fprintf(stderr, "ground drawer instance overflow\n");
abort();
}
const loshader_ground_drawer_internal_instance_t inst = {
.ground_id = instance->ground_id,
.pos = instance->pos,
.size = instance->size,
};
glBindBuffer(GL_ARRAY_BUFFER, drawer->instances);
glBufferSubData(GL_ARRAY_BUFFER,
drawer->instances_length*sizeof(inst), sizeof(inst), &inst);
++drawer->instances_length;
if (!loshader_instanced_drawer_add_instance(&drawer->super, &inst)) {
fprintf(stderr, "ground drawer instance overflow\n");
abort();
}
}
void loshader_ground_drawer_draw(const loshader_ground_drawer_t* drawer) {
assert(drawer != NULL);
if (drawer->instances_length == 0) return;
glUseProgram(*drawer->prog);
glBindVertexArray(drawer->vao);
loshader_uniblock_bind(
drawer->uniblock, LOSHADER_GROUND_UNIBLOCK_INDEX);
glDrawArraysInstanced(GL_TRIANGLES,
0, LOSHADER_GROUND_PRIMITIVE_COUNT, drawer->instances_length);
loshader_instanced_drawer_draw(&drawer->super, PRIMITIVE_COUNT_);
}

39
core/loshader/ground.h
View File

@@ -1,16 +1,14 @@
#pragma once
#include <stddef.h>
#include "util/gleasy/program.h"
#include "util/math/vector.h"
#include "./instanced.h"
#include "./uniblock.h"
typedef gleasy_program_t loshader_ground_program_t;
struct loshader_ground_drawer_t;
typedef struct loshader_ground_drawer_t loshader_ground_drawer_t;
typedef struct {
loshader_instanced_drawer_t super;
} loshader_ground_drawer_t;
typedef enum {
LOSHADER_GROUND_ID_ISLAND = 0,
@@ -24,31 +22,16 @@ typedef struct {
} loshader_ground_drawer_instance_t;
void
loshader_ground_program_initialize(
loshader_ground_program_t* prog
loshader_ground_drawer_initialize(
loshader_ground_drawer_t* drawer,
const loshader_uniblock_t* uniblock
);
void
loshader_ground_program_deinitialize(
loshader_ground_program_t* prog
);
#define loshader_ground_drawer_deinitialize(drawer) \
loshader_instanced_drawer_deinitialize(&(drawer)->super)
loshader_ground_drawer_t*
loshader_ground_drawer_new(
const loshader_ground_program_t* prog,
const loshader_uniblock_t* uniblock
);
void
loshader_ground_drawer_delete(
loshader_ground_drawer_t* drawer
);
void
loshader_ground_drawer_clear(
loshader_ground_drawer_t* drawer,
size_t reserve
);
#define loshader_ground_drawer_clear(drawer, reserve) \
loshader_instanced_drawer_clear(&(drawer)->super, reserve)
void
loshader_ground_drawer_add_instance(

172
core/loshader/hud_bar.c
View File

@@ -1,41 +1,28 @@
#include "./hud_bar.h"
#include <assert.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <GL/glew.h>
#include "util/gleasy/buffer.h"
#include "util/gleasy/program.h"
#include "util/math/vector.h"
#include "util/memory/memory.h"
#include "./instanced.h"
#include "./uniblock.h"
/* resources */
#include "anysrc/header.shader.h"
#include "anysrc/hud_bar.vshader.h"
#include "anysrc/hud_bar.fshader.h"
#include "core/loshader/anysrc/header.shader.h"
#include "core/loshader/anysrc/hud_bar.vshader.h"
#include "core/loshader/anysrc/hud_bar.fshader.h"
#define LOSHADER_HUD_BAR_VSHADER_IN_POS 0
#define LOSHADER_HUD_BAR_VSHADER_IN_SIZE 1
#define LOSHADER_HUD_BAR_VSHADER_IN_BGCOLOR 2
#define LOSHADER_HUD_BAR_VSHADER_IN_FGCOLOR 3
#define LOSHADER_HUD_BAR_VSHADER_IN_VALUE 4
#define LOSHADER_HUD_BAR_VSHADER_IN_PREV_VALUE 5
#define VSHADER_IN_POS_ 0
#define VSHADER_IN_SIZE_ 1
#define VSHADER_IN_BGCOLOR_ 2
#define VSHADER_IN_FGCOLOR_ 3
#define VSHADER_IN_VALUE_ 4
#define VSHADER_IN_PREV_VALUE_ 5
struct loshader_hud_bar_drawer_t {
const loshader_hud_bar_program_t* prog;
const loshader_uniblock_t* uniblock;
GLuint vao;
gleasy_buffer_array_t instances;
size_t instances_reserved;
size_t instances_length;
};
#define PRIMITIVE_COUNT_ 18
#pragma pack(push, 1)
typedef struct {
@@ -50,99 +37,43 @@ typedef struct {
} loshader_hud_bar_drawer_internal_instance_t;
#pragma pack(pop)
#define LOSHADER_HUD_BAR_UNIBLOCK_INDEX 0
void loshader_hud_bar_drawer_initialize(
loshader_hud_bar_drawer_t* drawer,
const loshader_uniblock_t* uniblock) {
assert(drawer != NULL);
assert(uniblock != NULL);
#define LOSHADER_HUD_BAR_PRIMITIVE_COUNT 18
static void loshader_hud_bar_program_setup_vao_(
gleasy_buffer_array_t instances) {
assert(instances != 0);
glBindBuffer(GL_ARRAY_BUFFER, instances);
# define enable_attrib_(NAME, name, dim, type) do { \
glEnableVertexAttribArray(LOSHADER_HUD_BAR_VSHADER_IN_##NAME); \
glVertexAttribPointer( \
LOSHADER_HUD_BAR_VSHADER_IN_##NAME, dim, type, GL_FALSE, \
sizeof(loshader_hud_bar_drawer_internal_instance_t), \
NULL + offsetof(loshader_hud_bar_drawer_internal_instance_t, name)); \
glVertexAttribDivisor(LOSHADER_HUD_BAR_VSHADER_IN_##NAME, 1); \
} while (0)
enable_attrib_(POS, pos, 2, GL_FLOAT);
enable_attrib_(SIZE, size, 2, GL_FLOAT);
enable_attrib_(BGCOLOR, bgcolor, 4, GL_FLOAT);
enable_attrib_(FGCOLOR, fgcolor, 4, GL_FLOAT);
enable_attrib_(VALUE, value, 1, GL_FLOAT);
enable_attrib_(PREV_VALUE, prev_value, 1, GL_FLOAT);
# undef enable_attrib_
}
void loshader_hud_bar_program_initialize(loshader_hud_bar_program_t* prog) {
assert(prog != NULL);
*prog = gleasy_program_new(
const gleasy_program_t prog = gleasy_program_new(
loshader_header_shader_, sizeof(loshader_header_shader_),
loshader_hud_bar_vshader_, sizeof(loshader_hud_bar_vshader_),
loshader_hud_bar_fshader_, sizeof(loshader_hud_bar_fshader_));
const GLuint uniblock = glGetUniformBlockIndex(*prog, "uniblock");
assert(glGetError() == GL_NO_ERROR);
glUniformBlockBinding(*prog, uniblock, LOSHADER_HUD_BAR_UNIBLOCK_INDEX);
}
loshader_instanced_drawer_initialize(
&drawer->super,
prog,
uniblock,
sizeof(loshader_hud_bar_drawer_internal_instance_t));
void loshader_hud_bar_program_deinitialize(loshader_hud_bar_program_t* prog) {
assert(prog != NULL);
glBindVertexArray(drawer->super.vao);
glBindBuffer(GL_ARRAY_BUFFER, drawer->super.instances);
glDeleteProgram(*prog);
}
# define enable_(index, var, dim, type) do { \
glEnableVertexAttribArray(index); \
glVertexAttribPointer( \
index, dim, type, GL_FALSE, \
sizeof(loshader_hud_bar_drawer_internal_instance_t), \
NULL + offsetof(loshader_hud_bar_drawer_internal_instance_t, var)); \
glVertexAttribDivisor(index, 1); \
} while (0)
loshader_hud_bar_drawer_t* loshader_hud_bar_drawer_new(
const loshader_hud_bar_program_t* prog,
const loshader_uniblock_t* uniblock) {
assert(prog != NULL);
assert(uniblock != NULL);
enable_(VSHADER_IN_POS_, pos, 2, GL_FLOAT);
enable_(VSHADER_IN_SIZE_, size, 2, GL_FLOAT);
enable_(VSHADER_IN_BGCOLOR_, bgcolor, 4, GL_FLOAT);
enable_(VSHADER_IN_FGCOLOR_, fgcolor, 4, GL_FLOAT);
enable_(VSHADER_IN_VALUE_, value, 1, GL_FLOAT);
enable_(VSHADER_IN_PREV_VALUE_, prev_value, 1, GL_FLOAT);
loshader_hud_bar_drawer_t* drawer = memory_new(sizeof(*drawer));
*drawer = (typeof(*drawer)) {
.prog = prog,
.uniblock = uniblock,
};
glCreateVertexArrays(1, &drawer->vao);
glBindVertexArray(drawer->vao);
glGenBuffers(1, &drawer->instances);
loshader_hud_bar_program_setup_vao_(drawer->instances);
return drawer;
}
void loshader_hud_bar_drawer_delete(loshader_hud_bar_drawer_t* drawer) {
if (drawer == NULL) return;
glDeleteBuffers(1, &drawer->instances);
glDeleteVertexArrays(1, &drawer->vao);
memory_delete(drawer);
}
void loshader_hud_bar_drawer_clear(
loshader_hud_bar_drawer_t* drawer, size_t reserve) {
assert(drawer != NULL);
assert(reserve > 0);
drawer->instances_length = 0;
if (drawer->instances_reserved < reserve) {
glBindBuffer(GL_ARRAY_BUFFER, drawer->instances);
glBufferData(GL_ARRAY_BUFFER,
sizeof(loshader_hud_bar_drawer_internal_instance_t) * reserve,
NULL, GL_DYNAMIC_DRAW);
drawer->instances_reserved = reserve;
}
# undef enable_
}
void loshader_hud_bar_drawer_add_instance(
@@ -151,11 +82,6 @@ void loshader_hud_bar_drawer_add_instance(
assert(drawer != NULL);
assert(instance != NULL);
if (drawer->instances_length >= drawer->instances_reserved) {
fprintf(stderr, "hud bar drawer instance overflow\n");
abort();
}
const loshader_hud_bar_drawer_internal_instance_t insta = {
.pos = instance->pos,
.size = instance->size,
@@ -164,24 +90,14 @@ void loshader_hud_bar_drawer_add_instance(
.value = instance->value,
.prev_value = instance->prev_value,
};
const size_t offset = drawer->instances_length * sizeof(insta);
glBindBuffer(GL_ARRAY_BUFFER, drawer->instances);
glBufferSubData(GL_ARRAY_BUFFER, offset, sizeof(insta), &insta);
++drawer->instances_length;
if (!loshader_instanced_drawer_add_instance(&drawer->super, &insta)) {
fprintf(stderr, "hud bar drawer instance overflow\n");
abort();
}
}
void loshader_hud_bar_drawer_draw(const loshader_hud_bar_drawer_t* drawer) {
assert(drawer != NULL);
if (drawer->instances_length == 0) return;
glUseProgram(*drawer->prog);
glBindVertexArray(drawer->vao);
loshader_uniblock_bind(drawer->uniblock, LOSHADER_HUD_BAR_UNIBLOCK_INDEX);
glDrawArraysInstanced(GL_TRIANGLES,
0, LOSHADER_HUD_BAR_PRIMITIVE_COUNT, drawer->instances_length);
loshader_instanced_drawer_draw(&drawer->super, PRIMITIVE_COUNT_);
}

40
core/loshader/hud_bar.h
View File

@@ -1,14 +1,13 @@
#pragma once
#include "util/gleasy/program.h"
#include "util/math/vector.h"
#include "./instanced.h"
#include "./uniblock.h"
typedef gleasy_program_t loshader_hud_bar_program_t;
struct loshader_hud_bar_drawer_t;
typedef struct loshader_hud_bar_drawer_t loshader_hud_bar_drawer_t;
typedef struct {
loshader_instanced_drawer_t super;
} loshader_hud_bar_drawer_t;
typedef struct {
vec2_t pos;
@@ -22,32 +21,17 @@ typedef struct {
} loshader_hud_bar_drawer_instance_t;
void
loshader_hud_bar_program_initialize(
loshader_hud_bar_program_t* prog
);
void
loshader_hud_bar_program_deinitialize(
loshader_hud_bar_program_t* prog
);
loshader_hud_bar_drawer_t* /* OWNERSHIP */
loshader_hud_bar_drawer_new(
const loshader_hud_bar_program_t* prog,
const loshader_uniblock_t* uniblock
);
void
loshader_hud_bar_drawer_delete(
loshader_hud_bar_drawer_t* drawer /* OWNERSHIP */
);
void
loshader_hud_bar_drawer_clear(
loshader_hud_bar_drawer_initialize(
loshader_hud_bar_drawer_t* drawer,
size_t reserve
const loshader_uniblock_t* uniblock
);
#define loshader_hud_bar_drawer_deinitialize(drawer) \
loshader_instanced_drawer_deinitialize(&(drawer)->super)
#define loshader_hud_bar_drawer_clear(drawer, reserve) \
loshader_instanced_drawer_clear(&(drawer)->super, reserve)
void
loshader_hud_bar_drawer_add_instance(
loshader_hud_bar_drawer_t* drawer,

87
core/loshader/hud_text.c
View File

@@ -1,95 +1,42 @@
#include "./hud_text.h"
#include <assert.h>
#include <stddef.h>
#include "util/gleasy/program.h"
#include "util/gleasy/texture.h"
#include "util/glyphas/block.h"
#include "util/glyphas/drawer.h"
#include "./text.h"
#include "./uniblock.h"
/* resources */
#include "anysrc/header.shader.h"
#include "anysrc/hud_text.vshader.h"
#include "anysrc/hud_text.fshader.h"
#include "core/loshader/anysrc/header.shader.h"
#include "core/loshader/anysrc/hud_text.vshader.h"
#include "core/loshader/anysrc/hud_text.fshader.h"
#define LOSHADER_HUD_TEXT_UNIFORM_ALPHA 1
#define UNIFORM_ALPHA_ 1 /* 0 is used by the super class */
#define LOSHADER_HUD_TEXT_UNIBLOCK_INDEX 0
void loshader_hud_text_drawer_initialize(
loshader_hud_text_drawer_t* drawer,
const loshader_uniblock_t* uniblock,
gleasy_texture_2d_t tex) {
assert(drawer != NULL);
assert(uniblock != NULL);
assert(tex != 0);
void loshader_hud_text_program_initialize(loshader_hud_text_program_t* prog) {
assert(prog != NULL);
*prog = gleasy_program_new(
const gleasy_program_t prog = gleasy_program_new(
loshader_header_shader_, sizeof(loshader_header_shader_),
loshader_hud_text_vshader_, sizeof(loshader_hud_text_vshader_),
loshader_hud_text_fshader_, sizeof(loshader_hud_text_fshader_));
const GLuint uniblock = glGetUniformBlockIndex(*prog, "uniblock");
assert(glGetError() == GL_NO_ERROR);
glUniformBlockBinding(*prog, uniblock, LOSHADER_HUD_TEXT_UNIBLOCK_INDEX);
}
void loshader_hud_text_program_deinitialize(loshader_hud_text_program_t* prog) {
assert(prog != NULL);
glDeleteProgram(*prog);
}
void loshader_hud_text_drawer_initialize(
loshader_hud_text_drawer_t* drawer,
const loshader_hud_text_program_t* prog,
const loshader_uniblock_t* uniblock,
gleasy_texture_2d_t tex) {
assert(drawer != NULL);
assert(prog != NULL);
assert(uniblock != NULL);
assert(tex != 0);
*drawer = (typeof(*drawer)) {
.prog = prog,
.uniblock = uniblock,
.tex = tex,
.glyphas = glyphas_drawer_new(),
.alpha = 1,
};
}
void loshader_hud_text_drawer_deinitialize(
loshader_hud_text_drawer_t* drawer) {
assert(drawer != NULL);
glyphas_drawer_delete(drawer->glyphas);
}
void loshader_hud_text_drawer_clear(
loshader_hud_text_drawer_t* drawer, size_t reserve) {
assert(drawer != NULL);
assert(reserve > 0);
glyphas_drawer_clear(drawer->glyphas, drawer->tex, reserve);
}
void loshader_hud_text_drawer_add_block(
loshader_hud_text_drawer_t* drawer, const glyphas_block_t* block) {
assert(drawer != NULL);
assert(block != NULL);
glyphas_drawer_add_block(drawer->glyphas, block);
loshader_text_drawer_initialize(&drawer->super, prog, uniblock, tex);
}
void loshader_hud_text_drawer_draw(const loshader_hud_text_drawer_t* drawer) {
assert(drawer != NULL);
glUseProgram(*drawer->prog);
glUseProgram(drawer->super.prog);
glUniform1f(UNIFORM_ALPHA_, drawer->alpha);
loshader_uniblock_bind(drawer->uniblock, LOSHADER_HUD_TEXT_UNIBLOCK_INDEX);
glUniform1f(LOSHADER_HUD_TEXT_UNIFORM_ALPHA, drawer->alpha);
glyphas_drawer_draw(drawer->glyphas);
loshader_text_drawer_draw_without_use_program(&drawer->super);
}

58
core/loshader/hud_text.h
View File

@@ -1,64 +1,32 @@
#pragma once
#include <stddef.h>
#include "util/gleasy/program.h"
#include "util/gleasy/texture.h"
#include "util/glyphas/block.h"
#include "util/glyphas/drawer.h"
#include "./text.h"
#include "./uniblock.h"
typedef gleasy_program_t loshader_hud_text_program_t;
typedef struct {
/* injected deps */
const loshader_hud_text_program_t* prog;
const loshader_uniblock_t* uniblock;
loshader_text_drawer_t super;
gleasy_texture_2d_t tex;
/* owned objects */
glyphas_drawer_t* glyphas;
/* public params */
/* public mutable params */
float alpha;
} loshader_hud_text_drawer_t;
void
loshader_hud_text_program_initialize(
loshader_hud_text_program_t* prog
);
void
loshader_hud_text_program_deinitialize(
loshader_hud_text_program_t* prog
);
void
loshader_hud_text_drawer_initialize(
loshader_hud_text_drawer_t* drawer,
const loshader_hud_text_program_t* prog,
const loshader_uniblock_t* uniblock,
gleasy_texture_2d_t tex
);
void
loshader_hud_text_drawer_deinitialize(
loshader_hud_text_drawer_t* drawer
);
void
loshader_hud_text_drawer_clear(
loshader_hud_text_drawer_t* drawer,
size_t reserve
const loshader_uniblock_t* uniblock,
gleasy_texture_2d_t tex
);
void
loshader_hud_text_drawer_add_block(
loshader_hud_text_drawer_t* drawer,
const glyphas_block_t* block
);
#define loshader_hud_text_drawer_deinitialize(drawer) \
loshader_text_drawer_deinitialize(&(drawer)->super)
#define loshader_hud_text_drawer_clear(drawer, reserve) \
loshader_text_drawer_clear(&(drawer)->super, reserve)
#define loshader_hud_text_drawer_add_block(drawer, block) \
loshader_text_drawer_add_block(&(drawer)->super, block)
void
loshader_hud_text_drawer_draw(

92
core/loshader/instanced.c Normal file
View File

@@ -0,0 +1,92 @@
#include "./instanced.h"
#include <assert.h>
#include <stdbool.h>
#include <stddef.h>
#include <GL/glew.h>
#include "util/gleasy/buffer.h"
#include "util/gleasy/program.h"
#include "./uniblock.h"
#define UNIBLOCK_INDEX_ 0
void loshader_instanced_drawer_initialize(
loshader_instanced_drawer_t* drawer,
gleasy_program_t prog,
const loshader_uniblock_t* uniblock,
size_t instance_size) {
assert(drawer != NULL);
assert(uniblock != NULL);
assert(instance_size > 0);
const GLuint uniblock_index = glGetUniformBlockIndex(prog, "uniblock");
assert(glGetError() == GL_NO_ERROR);
glUniformBlockBinding(prog, uniblock_index, UNIBLOCK_INDEX_);
*drawer = (typeof(*drawer)) {
.prog = prog,
.uniblock = uniblock,
.instance_size = instance_size,
};
glCreateVertexArrays(1, &drawer->vao);
glGenBuffers(1, &drawer->instances);
}
void loshader_instanced_drawer_deinitialize(
loshader_instanced_drawer_t* drawer) {
assert(drawer != NULL);
glDeleteVertexArrays(1, &drawer->vao);
glDeleteBuffers(1, &drawer->instances);
glDeleteProgram(drawer->prog);
}
void loshader_instanced_drawer_clear(
loshader_instanced_drawer_t* drawer, size_t reserve) {
assert(drawer != NULL);
assert(reserve > 0);
drawer->instances_length = 0;
if (drawer->instances_reserved < reserve) {
glBindBuffer(GL_ARRAY_BUFFER, drawer->instances);
glBufferData(GL_ARRAY_BUFFER,
reserve*drawer->instance_size, NULL, GL_DYNAMIC_DRAW);
drawer->instances_reserved = reserve;
}
}
bool loshader_instanced_drawer_add_instance(
loshader_instanced_drawer_t* drawer, const void* instance) {
assert(drawer != NULL);
assert(instance != NULL);
if (drawer->instances_length >= drawer->instances_reserved) {
return false;
}
const size_t offset = drawer->instances_length*drawer->instance_size;
glBindBuffer(GL_ARRAY_BUFFER, drawer->instances);
glBufferSubData(GL_ARRAY_BUFFER, offset, drawer->instance_size, instance);
++drawer->instances_length;
return true;
}
void loshader_instanced_drawer_draw(
const loshader_instanced_drawer_t* drawer, size_t primitives) {
assert(drawer != NULL);
if (primitives == 0 || drawer->instances_length == 0) return;
glUseProgram(drawer->prog);
glBindVertexArray(drawer->vao);
loshader_uniblock_bind(drawer->uniblock, UNIBLOCK_INDEX_);
glDrawArraysInstanced(GL_TRIANGLES, 0, primitives, drawer->instances_length);
}

55
core/loshader/instanced.h Normal file
View File

@@ -0,0 +1,55 @@
#pragma once
#include <stdbool.h>
#include <stddef.h>
#include <GL/glew.h>
#include "util/gleasy/buffer.h"
#include "util/gleasy/program.h"
#include "./uniblock.h"
typedef struct {
gleasy_program_t prog;
const loshader_uniblock_t* uniblock;
GLuint vao;
size_t instance_size;
gleasy_buffer_array_t instances;
size_t instances_reserved;
size_t instances_length;
} loshader_instanced_drawer_t;
void
loshader_instanced_drawer_initialize(
loshader_instanced_drawer_t* drawer,
gleasy_program_t prog, /* OWNERSHIP */
const loshader_uniblock_t* uniblock,
size_t instance_size
);
void
loshader_instanced_drawer_deinitialize(
loshader_instanced_drawer_t* drawer
);
void
loshader_instanced_drawer_clear(
loshader_instanced_drawer_t* drawer,
size_t reserve
);
bool
loshader_instanced_drawer_add_instance(
loshader_instanced_drawer_t* drawer,
const void* instance
);
void
loshader_instanced_drawer_draw(
const loshader_instanced_drawer_t* drawer,
size_t primitives
);

85
core/loshader/menu_background.c
View File

@@ -1,36 +1,30 @@
#include "./menu_background.h"
#include <assert.h>
#include <GL/glew.h>
#include <stddef.h>
#include "util/gleasy/program.h"
#include "util/math/algorithm.h"
#include "util/memory/memory.h"
#include "./single.h"
#include "./uniblock.h"
/* resources */
#include "anysrc/header.shader.h"
#include "anysrc/menu_background.vshader.h"
#include "anysrc/menu_background.fshader.h"
#include "core/loshader/anysrc/header.shader.h"
#include "core/loshader/anysrc/menu_background.vshader.h"
#include "core/loshader/anysrc/menu_background.fshader.h"
#define LOSHADER_MENU_BACKGROUND_UNIFORM_ALPHA 0
#define UNIFORM_ALPHA_ 0
struct loshader_menu_background_drawer_t {
const loshader_menu_background_program_t* prog;
const loshader_uniblock_t* uniblock;
#define PRIMITIVE_COUNT_ 6
float alpha;
};
void loshader_menu_background_drawer_initialize(
loshader_menu_background_drawer_t* drawer,
const loshader_uniblock_t* uniblock) {
assert(drawer != NULL);
assert(uniblock != NULL);
#define LOSHADER_MENU_BACKGROUND_UNIBLOCK_INDEX 0
void loshader_menu_background_program_initialize(
loshader_menu_background_program_t* prog) {
assert(prog != NULL);
*prog = gleasy_program_new(
const gleasy_program_t prog = gleasy_program_new(
loshader_header_shader_,
sizeof(loshader_header_shader_),
loshader_menu_background_vshader_,
@@ -38,60 +32,19 @@ void loshader_menu_background_program_initialize(
loshader_menu_background_fshader_,
sizeof(loshader_menu_background_fshader_));
const GLuint uniblock = glGetUniformBlockIndex(*prog, "uniblock");
assert(glGetError() == GL_NO_ERROR);
glUniformBlockBinding(
*prog, uniblock, LOSHADER_MENU_BACKGROUND_UNIBLOCK_INDEX);
}
void loshader_menu_background_program_deinitialize(
loshader_menu_background_program_t* prog) {
assert(prog != NULL);
glDeleteProgram(*prog);
}
loshader_menu_background_drawer_t* loshader_menu_background_drawer_new(
const loshader_menu_background_program_t* prog,
const loshader_uniblock_t* uniblock) {
assert(prog != NULL);
assert(uniblock != NULL);
loshader_menu_background_drawer_t* drawer = memory_new(sizeof(*drawer));
*drawer = (typeof(*drawer)) {
.prog = prog,
.uniblock = uniblock,
};
return drawer;
}
void loshader_menu_background_drawer_delete(
loshader_menu_background_drawer_t* drawer) {
if (drawer == NULL) return;
memory_delete(drawer);
}
void loshader_menu_background_drawer_set_alpha(
loshader_menu_background_drawer_t* drawer, float alpha) {
assert(drawer != NULL);
assert(MATH_FLOAT_VALID(alpha));
drawer->alpha = alpha;
loshader_single_drawer_initialize(&drawer->super, prog, uniblock, 0);
}
void loshader_menu_background_drawer_draw(
const loshader_menu_background_drawer_t* drawer) {
assert(drawer != NULL);
assert(MATH_FLOAT_VALID(drawer->alpha));
if (drawer->alpha == 0) return;
glUseProgram(*drawer->prog);
glUseProgram(drawer->super.prog);
glUniform1f(UNIFORM_ALPHA_, drawer->alpha);
loshader_uniblock_bind(
drawer->uniblock, LOSHADER_MENU_BACKGROUND_UNIBLOCK_INDEX);
glUniform1f(LOSHADER_MENU_BACKGROUND_UNIFORM_ALPHA, drawer->alpha);
glDrawArrays(GL_TRIANGLES, 0, 6);
loshader_single_drawer_draw_without_use_program(
&drawer->super, PRIMITIVE_COUNT_);
}

39
core/loshader/menu_background.h
View File

@@ -2,42 +2,25 @@
#include "util/gleasy/program.h"
#include "./single.h"
#include "./uniblock.h"
typedef gleasy_program_t loshader_menu_background_program_t;
typedef struct {
loshader_single_drawer_t super;
struct loshader_menu_background_drawer_t;
typedef
struct loshader_menu_background_drawer_t
loshader_menu_background_drawer_t;
/* public mutable params */
float alpha;
} loshader_menu_background_drawer_t;
void
loshader_menu_background_program_initialize(
loshader_menu_background_program_t* prog
);
void
loshader_menu_background_program_deinitialize(
loshader_menu_background_program_t* prog
);
loshader_menu_background_drawer_t*
loshader_menu_background_drawer_new(
const loshader_menu_background_program_t* prog,
const loshader_uniblock_t* uniblock
);
void
loshader_menu_background_drawer_delete(
loshader_menu_background_drawer_t* drawer
);
void
loshader_menu_background_drawer_set_alpha(
loshader_menu_background_drawer_initialize(
loshader_menu_background_drawer_t* drawer,
float alpha
const loshader_uniblock_t* uniblock
);
#define loshader_menu_background_drawer_deinitialize(drawer) \
loshader_single_drawer_deinitialize(&(drawer)->super)
void
loshader_menu_background_drawer_draw(
const loshader_menu_background_drawer_t* drawer

168
core/loshader/menu_stance.c
View File

@@ -7,34 +7,23 @@
#include <GL/glew.h>
#include "util/gleasy/buffer.h"
#include "util/gleasy/program.h"
#include "util/math/vector.h"
#include "util/memory/memory.h"
#include "./instanced.h"
#include "./uniblock.h"
/* resources */
#include "anysrc/header.shader.h"
#include "anysrc/menu_stance.vshader.h"
#include "anysrc/menu_stance.fshader.h"
#include "core/loshader/anysrc/header.shader.h"
#include "core/loshader/anysrc/menu_stance.vshader.h"
#include "core/loshader/anysrc/menu_stance.fshader.h"
#define LOSHADER_MENU_STANCE_VSHADER_IN_ID 0
#define LOSHADER_MENU_STANCE_VSHADER_IN_POS 1
#define LOSHADER_MENU_STANCE_VSHADER_IN_SIZE 2
#define LOSHADER_MENU_STANCE_VSHADER_IN_ALPHA 3
#define LOSHADER_MENU_STANCE_VSHADER_IN_HIGHLIGHT 4
#define VSHADER_IN_ID_ 0
#define VSHADER_IN_POS_ 1
#define VSHADER_IN_SIZE_ 2
#define VSHADER_IN_ALPHA_ 3
struct loshader_menu_stance_drawer_t {
const loshader_menu_stance_program_t* prog;
const loshader_uniblock_t* uniblock;
GLuint vao;
gleasy_buffer_array_t instances;
size_t instances_length;
size_t instances_reserved;
};
#define PRIMITIVE_COUNT_ 60
#pragma pack(push, 1)
typedef struct {
@@ -42,104 +31,44 @@ typedef struct {
vec2_t pos;
vec2_t size;
float alpha;
float highlight;
} loshader_menu_stance_drawer_internal_instance_t;
#pragma pack(pop)
#define LOSHADER_MENU_STANCE_UNIBLOCK_INDEX 0
#define LOSHADER_MENU_STANCE_PRIMITIVE_COUNT 60
void loshader_menu_stance_drawer_initialize(
loshader_menu_stance_drawer_t* drawer,
const loshader_uniblock_t* uniblock) {
assert(drawer != NULL);
assert(uniblock != NULL);
static void loshader_menu_stance_program_setup_vao_(
gleasy_buffer_array_t instances) {
assert(instances != 0);
glBindBuffer(GL_ARRAY_BUFFER, instances);
# define enable_attrib_(NAME, name, dim, type) do { \
glEnableVertexAttribArray(LOSHADER_MENU_STANCE_VSHADER_IN_##NAME); \
glVertexAttribPointer( \
LOSHADER_MENU_STANCE_VSHADER_IN_##NAME, dim, type, GL_FALSE, \
sizeof(loshader_menu_stance_drawer_internal_instance_t), \
NULL + offsetof(loshader_menu_stance_drawer_internal_instance_t, name)); \
glVertexAttribDivisor(LOSHADER_MENU_STANCE_VSHADER_IN_##NAME, 1); \
} while (0)
enable_attrib_(ID, id, 1, GL_UNSIGNED_BYTE);
enable_attrib_(POS, pos, 2, GL_FLOAT);
enable_attrib_(SIZE, size, 2, GL_FLOAT);
enable_attrib_(ALPHA, alpha, 1, GL_FLOAT);
enable_attrib_(HIGHLIGHT, highlight, 1, GL_FLOAT);
# undef enable_attrib_
}
void loshader_menu_stance_program_initialize(
loshader_menu_stance_program_t* prog) {
assert(prog != NULL);
*prog = gleasy_program_new(
const gleasy_program_t prog = gleasy_program_new(
loshader_header_shader_, sizeof(loshader_header_shader_),
loshader_menu_stance_vshader_, sizeof(loshader_menu_stance_vshader_),
loshader_menu_stance_fshader_, sizeof(loshader_menu_stance_fshader_));
const GLuint uniblock = glGetUniformBlockIndex(*prog, "uniblock");
assert(glGetError() == GL_NO_ERROR);
glUniformBlockBinding(*prog, uniblock, LOSHADER_MENU_STANCE_UNIBLOCK_INDEX);
}
loshader_instanced_drawer_initialize(
&drawer->super,
prog,
uniblock,
sizeof(loshader_menu_stance_drawer_internal_instance_t));
void loshader_menu_stance_program_deinitialize(
loshader_menu_stance_program_t* prog) {
assert(prog != NULL);
glBindVertexArray(drawer->super.vao);
glBindBuffer(GL_ARRAY_BUFFER, drawer->super.instances);
glDeleteProgram(*prog);
}
# define enable_(index, var, dim, type) do { \
glEnableVertexAttribArray(index); \
glVertexAttribPointer( \
index, dim, type, GL_FALSE, \
sizeof(loshader_menu_stance_drawer_internal_instance_t), \
NULL + offsetof(loshader_menu_stance_drawer_internal_instance_t, var)); \
glVertexAttribDivisor(index, 1); \
} while (0)
loshader_menu_stance_drawer_t* loshader_menu_stance_drawer_new(
const loshader_menu_stance_program_t* prog,
const loshader_uniblock_t* uniblock) {
assert(prog != NULL);
assert(uniblock != NULL);
enable_(VSHADER_IN_ID_, id, 1, GL_UNSIGNED_BYTE);
enable_(VSHADER_IN_POS_, pos, 2, GL_FLOAT);
enable_(VSHADER_IN_SIZE_, size, 2, GL_FLOAT);
enable_(VSHADER_IN_ALPHA_, alpha, 1, GL_FLOAT);
loshader_menu_stance_drawer_t* drawer = memory_new(sizeof(*drawer));
*drawer = (typeof(*drawer)) {
.prog = prog,
.uniblock = uniblock,
};
glCreateVertexArrays(1, &drawer->vao);
glBindVertexArray(drawer->vao);
glGenBuffers(1, &drawer->instances);
loshader_menu_stance_program_setup_vao_(drawer->instances);
return drawer;
}
void loshader_menu_stance_drawer_delete(
loshader_menu_stance_drawer_t* drawer) {
assert(drawer != NULL);
glDeleteBuffers(1, &drawer->instances);
glDeleteVertexArrays(1, &drawer->vao);
memory_delete(drawer);
}
void loshader_menu_stance_drawer_clear(
loshader_menu_stance_drawer_t* drawer, size_t reserve) {
assert(drawer != NULL);
assert(reserve > 0);
drawer->instances_length = 0;
if (drawer->instances_reserved < reserve) {
glBindBuffer(GL_ARRAY_BUFFER, drawer->instances);
glBufferData(GL_ARRAY_BUFFER,
reserve * sizeof(loshader_menu_stance_drawer_internal_instance_t),
NULL, GL_DYNAMIC_DRAW);
drawer->instances_reserved = reserve;
}
# undef enable_
}
void loshader_menu_stance_drawer_add_instance(
@@ -148,38 +77,21 @@ void loshader_menu_stance_drawer_add_instance(
assert(drawer != NULL);
assert(instance != NULL);
if (drawer->instances_length >= drawer->instances_reserved) {
fprintf(stderr, "menu stance drawer instance overflow\n");
abort();
}
const loshader_menu_stance_drawer_internal_instance_t insta = {
.id = instance->id,
.pos = instance->pos,
.size = instance->size,
.alpha = instance->alpha,
.highlight = instance->highlight,
};
const size_t offset = drawer->instances_length * sizeof(insta);
glBindBuffer(GL_ARRAY_BUFFER, drawer->instances);
glBufferSubData(GL_ARRAY_BUFFER, offset, sizeof(insta), &insta);
++drawer->instances_length;
if (!loshader_instanced_drawer_add_instance(&drawer->super, &insta)) {
fprintf(stderr, "menu stance drawer overflow\n");
abort();
}
}
void loshader_menu_stance_drawer_draw(
const loshader_menu_stance_drawer_t* drawer) {
assert(drawer != NULL);
if (drawer->instances_length == 0) return;
glUseProgram(*drawer->prog);
glBindVertexArray(drawer->vao);
loshader_uniblock_bind(
drawer->uniblock, LOSHADER_MENU_STANCE_UNIBLOCK_INDEX);
glDrawArraysInstanced(GL_TRIANGLES,
0, LOSHADER_MENU_STANCE_PRIMITIVE_COUNT, drawer->instances_length);
loshader_instanced_drawer_draw(&drawer->super, PRIMITIVE_COUNT_);
}

44
core/loshader/menu_stance.h
View File

@@ -1,16 +1,13 @@
#pragma once
#include <stddef.h>
#include "util/gleasy/program.h"
#include "util/math/vector.h"
#include "./instanced.h"
#include "./uniblock.h"
typedef gleasy_program_t loshader_menu_stance_program_t;
struct loshader_menu_stance_drawer_t;
typedef struct loshader_menu_stance_drawer_t loshader_menu_stance_drawer_t;
typedef struct {
loshader_instanced_drawer_t super;
} loshader_menu_stance_drawer_t;
typedef enum {
LOSHADER_MENU_STANCE_ID_EMPTY = 0,
@@ -18,6 +15,7 @@ typedef enum {
LOSHADER_MENU_STANCE_ID_REVOLUTIONER = 2,
LOSHADER_MENU_STANCE_ID_UNFINISHER = 3,
LOSHADER_MENU_STANCE_ID_PHILOSOPHER = 4,
LOSHADER_MENU_STANCE_ID_BETRAYER = 0, /* NOT IMPELEMENTED */
} loshader_menu_stance_id_t;
typedef struct {
@@ -26,36 +24,20 @@ typedef struct {
vec2_t pos;
vec2_t size;
float alpha;
float highlight;
} loshader_menu_stance_drawer_instance_t;
void
loshader_menu_stance_program_initialize(
loshader_menu_stance_program_t* prog
);
void
loshader_menu_stance_program_deinitialize(
loshader_menu_stance_program_t* prog
);
loshader_menu_stance_drawer_t*
loshader_menu_stance_drawer_new(
const loshader_menu_stance_program_t* prog,
const loshader_uniblock_t* uniblock
);
void
loshader_menu_stance_drawer_delete(
loshader_menu_stance_drawer_t* drawer
);
void
loshader_menu_stance_drawer_clear(
loshader_menu_stance_drawer_initialize(
loshader_menu_stance_drawer_t* drawer,
size_t reserve
const loshader_uniblock_t* uniblock
);
#define loshader_menu_stance_drawer_deinitialize(drawer) \
loshader_instanced_drawer_deinitialize(&(drawer)->super)
#define loshader_menu_stance_drawer_clear(drawer, reserve) \
loshader_instanced_drawer_clear(&(drawer)->super, reserve)
void
loshader_menu_stance_drawer_add_instance(
loshader_menu_stance_drawer_t* drawer,

4
core/loshader/menu_stance.vshader
View File

@@ -2,7 +2,6 @@ layout (location = 0) in float i_id;
layout (location = 1) in vec2 i_pos;
layout (location = 2) in vec2 i_size;
layout (location = 3) in float i_alpha;
layout (location = 4) in float i_highlight;
out float v_id;
out vec2 v_uv;
@@ -88,6 +87,5 @@ void main(void) {
v_id = i_id;
v_alpha = i_alpha;
float s = i_highlight*.2 + 1.;
gl_Position = vec4(v_uv*i_size*s + i_pos, 0., 1.);
gl_Position = vec4(v_uv*i_size + i_pos, 0., 1.);
}

87
core/loshader/menu_text.c
View File

@@ -1,97 +1,42 @@
#include "./menu_text.h"
#include <assert.h>
#include <stddef.h>
#include "util/gleasy/program.h"
#include "util/gleasy/texture.h"
#include "util/glyphas/block.h"
#include "util/glyphas/drawer.h"
#include "./text.h"
#include "./uniblock.h"
/* resources */
#include "anysrc/header.shader.h"
#include "anysrc/menu_text.vshader.h"
#include "anysrc/menu_text.fshader.h"
#include "core/loshader/anysrc/header.shader.h"
#include "core/loshader/anysrc/menu_text.vshader.h"
#include "core/loshader/anysrc/menu_text.fshader.h"
#define LOSHADER_MENU_TEXT_UNIFORM_ALPHA 1
#define LOSHADER_MENU_TEXT_UNIBLOCK_INDEX 0
void loshader_menu_text_program_initialize(
loshader_menu_text_program_t* prog) {
assert(prog != NULL);
*prog = gleasy_program_new(
loshader_header_shader_, sizeof(loshader_header_shader_),
loshader_menu_text_vshader_, sizeof(loshader_menu_text_vshader_),
loshader_menu_text_fshader_, sizeof(loshader_menu_text_fshader_));
const GLuint uniblock = glGetUniformBlockIndex(*prog, "uniblock");
assert(glGetError() == GL_NO_ERROR);
glUniformBlockBinding(*prog, uniblock, LOSHADER_MENU_TEXT_UNIBLOCK_INDEX);
}
void loshader_menu_text_program_deinitialize(
loshader_menu_text_program_t* prog) {
assert(prog != NULL);
glDeleteProgram(*prog);
}
#define UNIFORM_ALPHA_ 1 /* 0 is used by the super class */
void loshader_menu_text_drawer_initialize(
loshader_menu_text_drawer_t* drawer,
const loshader_menu_text_program_t* prog,
const loshader_uniblock_t* uniblock,
gleasy_texture_2d_t tex) {
loshader_menu_text_drawer_t* drawer,
const loshader_uniblock_t* uniblock,
gleasy_texture_2d_t tex) {
assert(drawer != NULL);
assert(prog != NULL);
assert(uniblock != NULL);
assert(tex != 0);
*drawer = (typeof(*drawer)) {
.prog = prog,
.uniblock = uniblock,
.tex = tex,
const gleasy_program_t prog = gleasy_program_new(
loshader_header_shader_, sizeof(loshader_header_shader_),
loshader_menu_text_vshader_, sizeof(loshader_menu_text_vshader_),
loshader_menu_text_fshader_, sizeof(loshader_menu_text_fshader_));
.glyphas = glyphas_drawer_new(),
.alpha = 1,
};
}
void loshader_menu_text_drawer_deinitialize(
loshader_menu_text_drawer_t* drawer) {
assert(drawer != NULL);
glyphas_drawer_delete(drawer->glyphas);
}
void loshader_menu_text_drawer_clear(
loshader_menu_text_drawer_t* drawer, size_t reserve) {
assert(drawer != NULL);
assert(reserve > 0);
glyphas_drawer_clear(drawer->glyphas, drawer->tex, reserve);
}
void loshader_menu_text_drawer_add_block(
loshader_menu_text_drawer_t* drawer, const glyphas_block_t* block) {
assert(drawer != NULL);
assert(block != NULL);
glyphas_drawer_add_block(drawer->glyphas, block);
loshader_text_drawer_initialize(&drawer->super, prog, uniblock, tex);
}
void loshader_menu_text_drawer_draw(const loshader_menu_text_drawer_t* drawer) {
assert(drawer != NULL);
glUseProgram(*drawer->prog);
glUseProgram(drawer->super.prog);
glUniform1f(UNIFORM_ALPHA_, drawer->alpha);
loshader_uniblock_bind(drawer->uniblock, LOSHADER_MENU_TEXT_UNIBLOCK_INDEX);
glUniform1f(LOSHADER_MENU_TEXT_UNIFORM_ALPHA, drawer->alpha);
glyphas_drawer_draw(drawer->glyphas);
loshader_text_drawer_draw_without_use_program(&drawer->super);
}

56
core/loshader/menu_text.h
View File

@@ -1,64 +1,34 @@
#pragma once
#include <stddef.h>
#include "util/gleasy/program.h"
#include "util/gleasy/texture.h"
#include "util/glyphas/block.h"
#include "util/glyphas/drawer.h"
#include "./text.h"
#include "./uniblock.h"
typedef gleasy_program_t loshader_menu_text_program_t;
typedef struct {
/* injected deps */
const loshader_menu_text_program_t* prog;
const loshader_uniblock_t* uniblock;
loshader_text_drawer_t super;
gleasy_texture_2d_t tex;
/* owned objects */
glyphas_drawer_t* glyphas;
/* public params */
/* public mutable params */
float alpha;
} loshader_menu_text_drawer_t;
void
loshader_menu_text_program_initialize(
loshader_menu_text_program_t* prog
);
void
loshader_menu_text_program_deinitialize(
loshader_menu_text_program_t* prog
);
void
loshader_menu_text_drawer_initialize(
loshader_menu_text_drawer_t* drawer,
const loshader_menu_text_program_t* prog,
const loshader_uniblock_t* uniblock,
gleasy_texture_2d_t tex
);
void
loshader_menu_text_drawer_deinitialize(
loshader_menu_text_drawer_t* drawer
);
void
loshader_menu_text_drawer_clear(
loshader_menu_text_drawer_t* drawer,
size_t reserve
const loshader_uniblock_t* uniblock,
gleasy_texture_2d_t tex
);
void
loshader_menu_text_drawer_add_block(
loshader_menu_text_drawer_t* drawer,
const glyphas_block_t* block
);
#define loshader_menu_text_drawer_deinitialize(drawer) \
loshader_text_drawer_deinitialize(&(drawer)->super)
#define loshader_menu_text_drawer_clear(drawer, reserve) \
loshader_text_drawer_clear(&(drawer)->super, reserve)
#define loshader_menu_text_drawer_add_block(drawer, block) \
loshader_text_drawer_add_block(&(drawer)->super, block)
void
loshader_menu_text_drawer_draw(

99
core/loshader/particle.c Normal file
View File

@@ -0,0 +1,99 @@
#include "./particle.h"
#include <assert.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <GL/glew.h>
#include "util/gleasy/program.h"
#include "util/math/vector.h"
#include "./instanced.h"
#include "./uniblock.h"
/* resources */
#include "core/loshader/anysrc/header.shader.h"
#include "core/loshader/anysrc/particle.vshader.h"
#include "core/loshader/anysrc/particle.fshader.h"
#define VSHADER_IN_PARTICLE_ID_ 0
#define VSHADER_IN_POS_ 1
#define VSHADER_IN_SIZE_ 2
#define VSHADER_IN_COLOR_ 3
#define VSHADER_IN_TIME_ 4
#define PRIMITIVE_COUNT_ 6
#pragma pack(push, 1)
typedef struct {
uint16_t particle_id;
vec2_t pos;
vec2_t size;
vec4_t color;
float time;
} loshader_particle_drawer_internal_instance_t;
#pragma pack(pop)
void loshader_particle_drawer_initialize(
loshader_particle_drawer_t* drawer,
const loshader_uniblock_t* uniblock) {
assert(drawer != NULL);
assert(uniblock != NULL);
const gleasy_program_t prog = gleasy_program_new(
loshader_header_shader_, sizeof(loshader_header_shader_),
loshader_particle_vshader_, sizeof(loshader_particle_vshader_),
loshader_particle_fshader_, sizeof(loshader_particle_fshader_));
loshader_instanced_drawer_initialize(
&drawer->super,
prog,
uniblock,
sizeof(loshader_particle_drawer_internal_instance_t));
glBindVertexArray(drawer->super.vao);
glBindBuffer(GL_ARRAY_BUFFER, drawer->super.instances);
# define enable_(index, var, dim, type) do { \
glEnableVertexAttribArray(index); \
glVertexAttribPointer( \
index, dim, type, GL_FALSE, \
sizeof(loshader_particle_drawer_internal_instance_t), \
NULL + offsetof(loshader_particle_drawer_internal_instance_t, var)); \
glVertexAttribDivisor(index, 1); \
} while (0)
enable_(VSHADER_IN_PARTICLE_ID_, particle_id, 1, GL_UNSIGNED_SHORT);
enable_(VSHADER_IN_POS_, pos, 2, GL_FLOAT);
enable_(VSHADER_IN_SIZE_, size, 2, GL_FLOAT);
enable_(VSHADER_IN_COLOR_, color, 4, GL_FLOAT);
enable_(VSHADER_IN_TIME_, time, 1, GL_FLOAT);
# undef enable_
}
void loshader_particle_drawer_add_instance(
loshader_particle_drawer_t* drawer,
const loshader_particle_drawer_instance_t* instance) {
assert(drawer != NULL);
assert(instance != NULL);
const loshader_particle_drawer_internal_instance_t inst = {
.particle_id = instance->particle_id,
.pos = instance->pos,
.size = instance->size,
};
if (!loshader_instanced_drawer_add_instance(&drawer->super, &inst)) {
fprintf(stderr, "particle drawer instance overflow\n");
abort();
}
}
void loshader_particle_drawer_draw(const loshader_particle_drawer_t* drawer) {
assert(drawer != NULL);
loshader_instanced_drawer_draw(&drawer->super, PRIMITIVE_COUNT_);
}

9
core/loshader/particle.fshader Normal file
View File

@@ -0,0 +1,9 @@
in vec2 v_uv;
in vec4 v_color;
in float v_time;
out vec4 o_color;
void main(void) {
o_color = vec4(0., 0., 0., 1.);
}

52
core/loshader/particle.h Normal file
View File

@@ -0,0 +1,52 @@
#pragma once
#include <stddef.h>
#include <stdint.h>
#include "util/math/vector.h"
#include "./instanced.h"
#include "./uniblock.h"
typedef struct {
loshader_instanced_drawer_t super;
} loshader_particle_drawer_t;
typedef enum {
LOSHADER_PARTICLE_ID_PLAYER = 0,
LOSHADER_PARTICLE_ID_ENCEPHALON = 1,
LOSHADER_PARTICLE_ID_CAVIA = 2,
LOSHADER_PARTICLE_ID_SCIENTIST = 3,
LOSHADER_PARTICLE_ID_WARDER = 4,
} loshader_particle_id_t;
typedef struct {
loshader_particle_id_t particle_id;
vec2_t pos;
vec2_t size;
vec4_t color;
float time;
} loshader_particle_drawer_instance_t;
void
loshader_particle_drawer_initialize(
loshader_particle_drawer_t* drawer,
const loshader_uniblock_t* uniblock
);
#define loshader_particle_drawer_deinitialize(drawer) \
loshader_instanced_drawer_deinitialize(&(drawer)->super)
#define loshader_particle_drawer_clear(drawer, reserve) \
loshader_instanced_drawer_clear(&(drawer)->super, reserve)
void
loshader_particle_drawer_add_instance(
loshader_particle_drawer_t* drawer,
const loshader_particle_drawer_instance_t* instance
);
void
loshader_particle_drawer_draw(
const loshader_particle_drawer_t* drawer
);

17
core/loshader/particle.vshader Normal file
View File

@@ -0,0 +1,17 @@
layout (location = 0) in float i_particle_id;
layout (location = 1) in vec2 i_pos;
layout (location = 2) in vec2 i_size;
layout (location = 3) in vec4 i_color;
layout (location = 4) in float i_time;
out vec2 v_uv;
out vec4 v_color;
out float v_time;
void main(void) {
v_uv = vec2(0.);
v_color = i_color;
v_time = i_time;
gl_Position = vec4(0.);
}

90
core/loshader/pixsort.c
View File

@@ -9,96 +9,54 @@
#include "util/gleasy/framebuffer.h"
#include "util/gleasy/program.h"
#include "util/math/algorithm.h"
#include "util/memory/memory.h"
#include "./single.h"
#include "./uniblock.h"
/* resources */
#include "anysrc/header.shader.h"
#include "anysrc/pixsort.vshader.h"
#include "anysrc/pixsort.fshader.h"
#include "core/loshader/anysrc/header.shader.h"
#include "core/loshader/anysrc/pixsort.vshader.h"
#include "core/loshader/anysrc/pixsort.fshader.h"
#define LOSHADER_PIXSORT_UNIFORM_SRC 0
#define LOSHADER_PIXSORT_UNIFORM_INTENSITY 1
#define UNIFORM_SRC_ 0
#define UNIFORM_INTENSITY_ 1
#define LOSHADER_PIXSORT_UNIBLOCK_INDEX 0
#define PRIMITIVE_COUNT_ 6
struct loshader_pixsort_drawer_t {
const loshader_pixsort_program_t* prog;
const loshader_uniblock_t* uniblock;
void loshader_pixsort_drawer_initialize(
loshader_pixsort_drawer_t* drawer,
const loshader_uniblock_t* uniblock,
const gleasy_framebuffer_t* fb) {
assert(drawer != NULL);
assert(uniblock != NULL);
assert(fb != NULL);
const gleasy_framebuffer_t* fb;
*drawer = (typeof(*drawer)) {
.fb = fb,
};
float intensity;
};
void loshader_pixsort_program_initialize(
loshader_pixsort_program_t* prog) {
assert(prog != NULL);
*prog = gleasy_program_new(
const gleasy_program_t prog = gleasy_program_new(
loshader_header_shader_, sizeof(loshader_header_shader_),
loshader_pixsort_vshader_, sizeof(loshader_pixsort_vshader_),
loshader_pixsort_fshader_, sizeof(loshader_pixsort_fshader_));
const GLuint uniblock = glGetUniformBlockIndex(*prog, "uniblock");
assert(glGetError() == GL_NO_ERROR);
glUniformBlockBinding(*prog, uniblock, LOSHADER_PIXSORT_UNIBLOCK_INDEX);
}
void loshader_pixsort_program_deinitialize(
loshader_pixsort_program_t* prog) {
assert(prog != NULL);
glDeleteProgram(*prog);
}
loshader_pixsort_drawer_t* loshader_pixsort_drawer_new(
const loshader_pixsort_program_t* prog,
const loshader_uniblock_t* uniblock,
const gleasy_framebuffer_t* fb) {
assert(prog != NULL);
assert(uniblock != NULL);
assert(fb != NULL);
loshader_pixsort_drawer_t* drawer = memory_new(sizeof(*drawer));
*drawer = (typeof(*drawer)) {
.prog = prog,
.uniblock = uniblock,
.fb = fb,
};
return drawer;
}
void loshader_pixsort_drawer_delete(loshader_pixsort_drawer_t* drawer) {
if (drawer == NULL) return;
memory_delete(drawer);
}
void loshader_pixsort_drawer_set_intensity(
loshader_pixsort_drawer_t* drawer,
float intensity) {
assert(drawer != NULL);
assert(MATH_FLOAT_VALID(intensity));
drawer->intensity = intensity;
loshader_single_drawer_initialize(&drawer->super, prog, uniblock, 0);
}
void loshader_pixsort_drawer_draw(
const loshader_pixsort_drawer_t* drawer) {
assert(drawer != NULL);
glUseProgram(*drawer->prog);
glUseProgram(drawer->super.prog);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, drawer->fb->colorbuf);
glUniform1i(LOSHADER_PIXSORT_UNIFORM_SRC, 0);
glUniform1f(LOSHADER_PIXSORT_UNIFORM_INTENSITY, drawer->intensity);
glUniform1i(UNIFORM_SRC_, 0);
glUniform1f(UNIFORM_INTENSITY_, drawer->intensity);
glDrawArrays(GL_TRIANGLES, 0, 6);
loshader_single_drawer_draw_without_use_program(
&drawer->super, PRIMITIVE_COUNT_);
}
bool loshader_pixsort_drawer_is_skippable(

2
core/loshader/pixsort.fshader
View File

@@ -5,7 +5,7 @@ in vec2 v_uv;
out vec4 o_color;
const int N = 2;
const int N = 4;
const int S = 20;
float luminance(in vec4 col) {

42
core/loshader/pixsort.h
View File

@@ -1,44 +1,28 @@
#pragma once
#include <stddef.h>
#include "util/gleasy/framebuffer.h"
#include "util/gleasy/program.h"
#include "./single.h"
#include "./uniblock.h"
typedef gleasy_program_t loshader_pixsort_program_t;
typedef struct {
loshader_single_drawer_t super;
const gleasy_framebuffer_t* fb;
struct loshader_pixsort_drawer_t;
typedef struct loshader_pixsort_drawer_t loshader_pixsort_drawer_t;
/* public mutable params */
float intensity;
} loshader_pixsort_drawer_t;
void
loshader_pixsort_program_initialize(
loshader_pixsort_program_t* prog
loshader_pixsort_drawer_initialize(
loshader_pixsort_drawer_t* drawer,
const loshader_uniblock_t* uniblock,
const gleasy_framebuffer_t* fb
);
void
loshader_pixsort_program_deinitialize(
loshader_pixsort_program_t* prog
);
loshader_pixsort_drawer_t* /* OWNERSHIP */
loshader_pixsort_drawer_new(
const loshader_pixsort_program_t* prog,
const loshader_uniblock_t* uniblock,
const gleasy_framebuffer_t* fb
);
void
loshader_pixsort_drawer_delete(
loshader_pixsort_drawer_t* drawer /* OWNERSHIP */
);
void
loshader_pixsort_drawer_set_intensity(
loshader_pixsort_drawer_t* drawer,
float intensity
);
#define loshader_pixsort_drawer_deinitialize(drawer) \
loshader_single_drawer_deinitialize(&(drawer)->super)
void
loshader_pixsort_drawer_draw(

44
core/loshader/popup_text.c Normal file
View File

@@ -0,0 +1,44 @@
#include "./popup_text.h"
#include <assert.h>
#include <stddef.h>
#include "util/gleasy/program.h"
#include "util/gleasy/texture.h"
#include "util/glyphas/drawer.h"
#include "./text.h"
#include "./uniblock.h"
/* resources */
#include "core/loshader/anysrc/header.shader.h"
#include "core/loshader/anysrc/popup_text.vshader.h"
#include "core/loshader/anysrc/popup_text.fshader.h"
#define UNIFORM_ALPHA_ 1 /* 0 is used by the super class */
void loshader_popup_text_drawer_initialize(
loshader_popup_text_drawer_t* drawer,
const loshader_uniblock_t* uniblock,
gleasy_texture_2d_t tex) {
assert(drawer != NULL);
assert(uniblock != NULL);
assert(tex != 0);
const gleasy_program_t prog = gleasy_program_new(
loshader_header_shader_, sizeof(loshader_header_shader_),
loshader_popup_text_vshader_, sizeof(loshader_popup_text_vshader_),
loshader_popup_text_fshader_, sizeof(loshader_popup_text_fshader_));
loshader_text_drawer_initialize(&drawer->super, prog, uniblock, tex);
}
void loshader_popup_text_drawer_draw(
const loshader_popup_text_drawer_t* drawer) {
assert(drawer != NULL);
glUseProgram(drawer->super.prog);
glUniform1f(UNIFORM_ALPHA_, drawer->alpha);
loshader_text_drawer_draw_without_use_program(&drawer->super);
}

35
core/loshader/popup_text.fshader Normal file
View File

@@ -0,0 +1,35 @@
layout (location = 0) uniform sampler2D u_tex;
layout (location = 1) uniform float u_alpha;
in vec2 v_dp;
in vec2 v_uv;
in vec4 v_color;
out vec4 o_color;
float rand(in vec2 p) {
/* https://qiita.com/shimacpyon/items/d15dee44a0b8b3883f76 */
return fract(sin(dot(p ,vec2(12.9898,78.233))) * 43758.5453);
}
float noise(vec2 x) {
/* https://www.shadertoy.com/view/4dS3Wd */
vec2 i = floor(x);
vec2 f = fract(x);
float a = rand(i);
float b = rand(i + vec2(1.0, 0.0));
float c = rand(i + vec2(0.0, 1.0));
float d = rand(i + vec2(1.0, 1.0));
vec2 u = f * f * (3.0 - 2.0 * f);
return mix(a, b, u.x) + (c - a) * u.y * (1.0 - u.x) + (d - b) * u.x * u.y;
}
void main(void) {
float t = 1.-pow(1.-u_alpha, 4.);
float a = texture(u_tex, v_uv).r;
a *= step(noise(v_dp*10.), t);
o_color = vec4(v_color.rgb, v_color.a*a*t);
}

36
core/loshader/popup_text.h Normal file
View File

@@ -0,0 +1,36 @@
#pragma once
#include "util/gleasy/texture.h"
#include "./text.h"
#include "./uniblock.h"
typedef gleasy_program_t loshader_popup_text_program_t;
typedef struct {
loshader_text_drawer_t super;
/* public mutable params */
float alpha;
} loshader_popup_text_drawer_t;
void
loshader_popup_text_drawer_initialize(
loshader_popup_text_drawer_t* drawer,
const loshader_uniblock_t* uniblock,
gleasy_texture_2d_t tex
);
#define loshader_popup_text_drawer_deinitialize(drawer) \
loshader_text_drawer_deinitialize(&(drawer)->super)
#define loshader_popup_text_drawer_clear(drawer, reserve) \
loshader_text_drawer_clear(&(drawer)->super, reserve)
#define loshader_popup_text_drawer_add_block(drawer, block) \
loshader_text_drawer_add_block(&(drawer)->super, block)
void
loshader_popup_text_drawer_draw(
const loshader_popup_text_drawer_t* drawer
);

43
core/loshader/popup_text.vshader Normal file
View File

@@ -0,0 +1,43 @@
layout (location = 1) uniform float u_alpha;
layout (location = 0) in vec2 i_pos;
layout (location = 1) in vec2 i_size;
layout (location = 2) in vec2 i_uv_pos;
layout (location = 3) in vec2 i_uv_size;
layout (location = 4) in vec4 i_color;
out vec2 v_dp;
out vec2 v_uv;
out vec4 v_color;
const float RANDOM_POS = .1;
float rand(in vec2 p) {
/* https://qiita.com/shimacpyon/items/d15dee44a0b8b3883f76 */
return fract(sin(dot(p ,vec2(12.9898,78.233))) * 43758.5453);
}
void main(void) {
const vec2[] verts = vec2[](
vec2( 0., 0.), vec2( 0., -1.), vec2( 1., -1.),
vec2( 0., 0.), vec2( 1., -1.), vec2( 1., 0.)
);
vec2 seed = i_pos + float(gl_InstanceID);
vec2 rpos = 1.-vec2(rand(seed.xy), rand(seed.yx))*2.;
rpos.x /= 8.;
rpos.y = -abs(rpos.y);
float t = pow(1.-u_alpha, 4.);
rpos *= t*RANDOM_POS;
vec2 p = gl_VertexID < verts.length()? verts[gl_VertexID]: vec2(0.);
vec2 dp = p*i_size + i_pos+rpos;
gl_Position = vec4(dp, 0, 1);
v_dp = dp;
v_uv = p*i_uv_size + i_uv_pos;
v_color = i_color;
}

141
core/loshader/posteffect.c
View File

@@ -16,96 +16,55 @@
#include "./uniblock.h"
/* resources */
#include "anysrc/header.shader.h"
#include "anysrc/posteffect.vshader.h"
#include "anysrc/posteffect.fshader.h"
#include "core/loshader/anysrc/header.shader.h"
#include "core/loshader/anysrc/posteffect.vshader.h"
#include "core/loshader/anysrc/posteffect.fshader.h"
#define LOSHADER_POSTEFFECT_UNIFORM_SRC 0
#define UNIFORM_SRC_ 0
struct loshader_posteffect_drawer_t {
const loshader_posteffect_program_t* prog;
const loshader_uniblock_t* uniblock;
const gleasy_framebuffer_t* fb;
gleasy_buffer_uniform_t param;
};
#define PRIMITIVE_COUNT_ 6
#pragma pack(push, 1)
typedef struct {
float whole_blur;
float raster;
float distortion_amnesia;
float distortion_radial;
float distortion_urgent;
float raster_whole;
float radial_displacement;
float amnesia_displacement;
float radial_fade;
float brightness;
} loshader_posteffect_drawer_param_internal_t;
_Static_assert(
sizeof(float)*6 ==
sizeof(loshader_posteffect_drawer_param_internal_t));
float aberration_radial;
float blur_whole;
float brightness_whole;
float fade_radial;
} loshader_posteffect_drawer_internal_param_t;
#pragma pack(pop)
#define LOSHADER_POSTEFFECT_UNIBLOCK_INDEX 0
#define LOSHADER_POSTEFFECT_PARAM_INDEX 1
_Static_assert(
sizeof(float)*8 ==
sizeof(loshader_posteffect_drawer_internal_param_t),
"recheck the type has no padding");
void loshader_posteffect_program_initialize(
loshader_posteffect_program_t* prog) {
assert(prog != NULL);
void loshader_posteffect_drawer_initialize(
loshader_posteffect_drawer_t* drawer,
const loshader_uniblock_t* uniblock,
const gleasy_framebuffer_t* fb) {
assert(drawer != NULL);
assert(uniblock != NULL);
assert(fb != NULL);
*prog = gleasy_program_new(
*drawer = (typeof(*drawer)) {
.fb = fb,
};
const gleasy_program_t prog = gleasy_program_new(
loshader_header_shader_, sizeof(loshader_header_shader_),
loshader_posteffect_vshader_, sizeof(loshader_posteffect_vshader_),
loshader_posteffect_fshader_, sizeof(loshader_posteffect_fshader_));
const GLuint uniblock = glGetUniformBlockIndex(*prog, "uniblock");
assert(glGetError() == GL_NO_ERROR);
glUniformBlockBinding(*prog, uniblock, LOSHADER_POSTEFFECT_UNIBLOCK_INDEX);
const GLuint param = glGetUniformBlockIndex(*prog, "param");
assert(glGetError() == GL_NO_ERROR);
glUniformBlockBinding(*prog, param, LOSHADER_POSTEFFECT_PARAM_INDEX);
}
void loshader_posteffect_program_deinitialize(
loshader_posteffect_program_t* prog) {
assert(prog != NULL);
glDeleteProgram(*prog);
}
loshader_posteffect_drawer_t* loshader_posteffect_drawer_new(
const loshader_posteffect_program_t* prog,
const loshader_uniblock_t* uniblock,
const gleasy_framebuffer_t* fb) {
assert(prog != NULL);
assert(uniblock != NULL);
assert(fb != NULL);
loshader_posteffect_drawer_t* drawer = memory_new(sizeof(*drawer));
*drawer = (typeof(*drawer)) {
.prog = prog,
.uniblock = uniblock,
.fb = fb,
};
glGenBuffers(1, &drawer->param);
glBindBuffer(GL_UNIFORM_BUFFER, drawer->param);
glBufferData(GL_UNIFORM_BUFFER,
sizeof(loshader_posteffect_drawer_param_internal_t),
NULL,
GL_DYNAMIC_DRAW);
return drawer;
}
void loshader_posteffect_drawer_delete(loshader_posteffect_drawer_t* drawer) {
if (drawer == NULL) return;
glDeleteBuffers(1, &drawer->param);
memory_delete(drawer);
loshader_single_drawer_initialize(
&drawer->super,
prog,
uniblock,
sizeof(loshader_posteffect_drawer_internal_param_t));
}
void loshader_posteffect_drawer_set_param(
@@ -114,31 +73,29 @@ void loshader_posteffect_drawer_set_param(
assert(drawer != NULL);
assert(param != NULL);
const loshader_posteffect_drawer_param_internal_t p = {
.whole_blur = param->whole_blur,
.raster = param->raster,
.radial_displacement = param->radial_displacement,
.amnesia_displacement = param->amnesia_displacement,
.radial_fade = param->radial_fade,
.brightness = param->brightness,
const loshader_posteffect_drawer_internal_param_t p = {
.distortion_amnesia = param->distortion_amnesia,
.distortion_radial = param->distortion_radial,
.distortion_urgent = param->distortion_urgent,
.raster_whole = param->raster_whole,
.aberration_radial = param->aberration_radial,
.blur_whole = param->blur_whole,
.brightness_whole = param->brightness_whole,
.fade_radial = param->fade_radial,
};
glBindBuffer(GL_UNIFORM_BUFFER, drawer->param);
glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(p), &p);
loshader_single_drawer_set_param(&drawer->super, &p);
}
void loshader_posteffect_drawer_draw(
const loshader_posteffect_drawer_t* drawer) {
assert(drawer != NULL);
glUseProgram(*drawer->prog);
loshader_uniblock_bind(drawer->uniblock, LOSHADER_POSTEFFECT_UNIBLOCK_INDEX);
glBindBufferBase(GL_UNIFORM_BUFFER,
LOSHADER_POSTEFFECT_PARAM_INDEX, drawer->param);
glUseProgram(drawer->super.prog);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, drawer->fb->colorbuf);
glUniform1i(LOSHADER_POSTEFFECT_UNIFORM_SRC, 0);
glUniform1i(UNIFORM_SRC_, 0);
glDrawArrays(GL_TRIANGLES, 0, 6);
loshader_single_drawer_draw_without_use_program(
&drawer->super, PRIMITIVE_COUNT_);
}

112
core/loshader/posteffect.fshader
View File

@@ -1,21 +1,22 @@
layout (location = 0) uniform sampler2D u_src;
layout(std140) uniform param {
float whole_blur;
float raster;
float distortion_amnesia;
float distortion_radial;
float distortion_urgent;
float raster_whole;
float radial_displacement;
float amnesia_displacement;
float radial_fade;
float brightness;
float aberration_radial;
float blur_whole;
float brightness_whole;
float fade_radial;
} p;
in vec2 v_uv;
out vec4 o_color;
/* ---- utilities ---- */
float atan2(in vec2 p){
return p.x == 0. ? sign(p.y)*PI/2. : atan(p.y, p.x);
}
@@ -29,7 +30,7 @@ float rand(in vec2 p) {
/* https://thebookofshaders.com/13/?lan=jp */
return fract(sin(dot(p.xy, vec2(12.9898, 78.233)))*43758.5453123);
}
float noise (in vec2 _st) {
float noise(in vec2 _st) {
/* https://thebookofshaders.com/13/?lan=jp*/
vec2 i = floor(_st);
vec2 f = fract(_st);
@@ -46,7 +47,7 @@ float noise (in vec2 _st) {
(c - a)* u.y * (1.0 - u.x) +
(d - b) * u.x * u.y;
}
float fbm (in vec2 _st) {
float fbm(in vec2 _st) {
/* https://thebookofshaders.com/13/?lan=jp*/
const float octaves = 5;
@@ -63,42 +64,46 @@ float fbm (in vec2 _st) {
return v;
}
vec2 radial_displacement(in vec2 polar) {
float intensity = p.radial_displacement + 1.;
float r = polar.x;
/* ---- distortion effects ---- */
void distortion_amnesia(inout vec2 uv) {
vec2 a = abs(uv);
float i = p.distortion_amnesia*(1.-pow(max(a.x, a.y), 2.));
uv += (fbm(uv)-.5)*i;
}
void distortion_radial(inout vec2 polar) {
float i = p.distortion_radial + 1.;
const float sqrt2 = sqrt(2.);
r = (1. - pow(abs(1. - r/sqrt2), intensity))*sqrt2 / intensity;
return vec2(r, polar.y);
polar.x = (1. - pow(abs(1. - polar.x/sqrt2), i))*sqrt2 / i;
}
vec2 amnesia_displacement(in vec2 uv) {
vec2 auv = abs(uv);
float intensity = p.amnesia_displacement*(1.-pow(max(auv.x, auv.y), 2.));
return uv + fbm(uv)*intensity - intensity/2.;
void distortion_urgent(inout vec2 polar) {
float i = p.distortion_urgent;
polar.x += pow(polar.x, 2.)*sin(polar.y*20.)*.2*i;
polar.x /= i+1.;
}
void raster_whole(inout vec2 uv) {
uv.x += sin(v_uv.y*PI*2./uni.aa*5.)*.05*p.raster_whole;
}
float radial_fade(in float len) {
float intensity = p.radial_fade;
return clamp(1. - intensity * max(len - (1.-intensity), 0.), 0., 1.);
}
vec4 chromatic_aberration(in vec2 uv) {
/* ---- color effects ---- */
void aberration_radial(inout vec4 color, in vec2 uv) {
float a = length(v_uv)/sqrt(2.);
vec2 e = 1./uni.resolution*a;
vec2 e = 4./uni.resolution*pow(a, 4.)*p.aberration_radial;
return vec4(
color = vec4(
texture(u_src, uv+e).r,
texture(u_src, uv).g,
color.g,
texture(u_src, uv-e).b,
1.);
}
void blur_whole(inout vec4 color, in vec2 uv) {
if (p.blur_whole <= 0.) return;
vec4 blur(in vec2 uv) {
vec2 e1 = vec2(1./uni.resolution.x, 0.);
vec2 e2 = vec2(0., 1./uni.resolution.y);
vec4 color =
vec4 neighbors =
texture(u_src, uv+e1+.0) +
texture(u_src, uv+e1+e2) +
texture(u_src, uv+.0+e2) +
@@ -107,33 +112,44 @@ vec4 blur(in vec2 uv) {
texture(u_src, uv-e1-e2) +
texture(u_src, uv+.0-e2) +
texture(u_src, uv+e1-e2);
return color/8.;
color = mix(color, neighbors/8., p.blur_whole);
}
void contrast_whole(inout vec4 color) {
color = pow(color, vec4(1.4));
}
void monochromize_whole(inout vec4 color) {
color = min(color, vec4(max(color.r, max(color.g, color.b)))*.95);
}
void brightness_whole(inout vec4 color) {
color *= p.brightness_whole;
}
void fade_radial(inout vec4 color, in vec2 polar) {
float i = p.fade_radial;
color.rgb *= clamp(1.-i*max(polar.x-(1.-i), 0.), 0., 1.);
}
void main(void) {
vec2 uv = v_uv;
/* transformation */
/* distortion effect */
distortion_amnesia(uv);
vec2 polar = to_polar(uv);
polar = radial_displacement(polar);
distortion_radial(polar);
distortion_urgent(polar);
uv = to_rectangular(polar);
uv = amnesia_displacement(uv);
uv.x += sin(v_uv.y*PI*2./uni.aa*5.)*.05*p.raster;
raster_whole(uv);
/* pixel manipulation */
/* color effect */
uv = (uv+1.)/2.;
vec4 color = chromatic_aberration(uv);
o_color = texture(u_src, uv);
if (p.whole_blur > 0.) color = mix(color, blur(uv), p.whole_blur);
aberration_radial(o_color, uv);
blur_whole(o_color, uv);
/* blending */
float a = radial_fade(polar.x);
o_color = mix(vec4(0., 0., 0., 1), color, a);
/* color manip */
o_color = pow(o_color, vec4(1.4));
o_color = min(o_color, vec4(max(o_color.r, max(o_color.g, o_color.b)))*.95);
o_color *= p.brightness;
contrast_whole(o_color);
monochromize_whole(o_color);
brightness_whole(o_color);
fade_radial(o_color, polar);
}

53
core/loshader/posteffect.h
View File

@@ -1,49 +1,38 @@
#pragma once
#include <stddef.h>
#include "util/gleasy/framebuffer.h"
#include "util/gleasy/program.h"
#include "./single.h"
#include "./uniblock.h"
typedef gleasy_program_t loshader_posteffect_program_t;
struct loshader_posteffect_drawer_t;
typedef struct loshader_posteffect_drawer_t loshader_posteffect_drawer_t;
typedef struct {
loshader_single_drawer_t super;
const gleasy_framebuffer_t* fb;
} loshader_posteffect_drawer_t;
typedef struct {
float whole_blur;
float raster;
/* distortion effect */
float distortion_amnesia;
float distortion_radial;
float distortion_urgent;
float raster_whole;
float radial_displacement;
float amnesia_displacement;
float radial_fade;
float brightness;
/* color effect */
float aberration_radial;
float blur_whole;
float brightness_whole;
float fade_radial;
} loshader_posteffect_drawer_param_t;
void
loshader_posteffect_program_initialize(
loshader_posteffect_program_t* prog
loshader_posteffect_drawer_initialize(
loshader_posteffect_drawer_t* drawer,
const loshader_uniblock_t* uniblock,
const gleasy_framebuffer_t* fb
);
void
loshader_posteffect_program_deinitialize(
loshader_posteffect_program_t* prog
);
loshader_posteffect_drawer_t* /* OWNERSHIP */
loshader_posteffect_drawer_new(
const loshader_posteffect_program_t* prog,
const loshader_uniblock_t* uniblock,
const gleasy_framebuffer_t* fb
);
void
loshader_posteffect_drawer_delete(
loshader_posteffect_drawer_t* drawer /* OWNERSHIP */
);
#define loshader_posteffect_drawer_deinitialize(drawer) \
loshader_single_drawer_deinitialize(&(drawer)->super)
void
loshader_posteffect_drawer_set_param(

211
core/loshader/set.c
View File

@@ -3,8 +3,6 @@
#include <assert.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <GL/glew.h>
@@ -13,6 +11,8 @@
#include "util/math/algorithm.h"
#include "util/math/vector.h"
#include "core/locommon/screen.h"
#include "./backwall.h"
#include "./bullet.h"
#include "./character.h"
@@ -26,170 +26,128 @@
#include "./menu_background.h"
#include "./menu_stance.h"
#include "./menu_text.h"
#include "./particle.h"
#include "./pixsort.h"
#include "./popup_text.h"
#include "./posteffect.h"
#include "./uniblock.h"
void loshader_set_initialize(
loshader_set_t* set,
int32_t width,
int32_t height,
const vec2_t* dpi,
int32_t max_msaa) {
loshader_set_t* set,
const locommon_screen_t* screen,
int32_t max_msaa) {
assert(set != NULL);
assert(width > 0);
assert(height > 0);
assert(vec2_valid(dpi));
assert(locommon_screen_valid(screen));
assert(max_msaa > 0);
*set = (typeof(*set)) {
.resolution = vec2(width, height),
.dpi = *dpi,
};
*set = (typeof(*set)) {0};
set->uniblock = loshader_uniblock_new();
loshader_uniblock_update_display_param(set->uniblock, &set->resolution, dpi);
loshader_uniblock_initialize(&set->uniblock, screen);
int max_samples;
glGetIntegerv(GL_MAX_COLOR_TEXTURE_SAMPLES, &max_samples);
gleasy_framebuffer_initialize(
&set->framebuffer, width, height, MATH_MIN(max_samples, max_msaa));
&set->framebuffer,
screen->resolution.x,
screen->resolution.y,
MATH_MIN(max_samples, max_msaa));
/* TODO(catfoot): atlas size should depend on DPI. */
set->tex = (typeof(set->tex)) {
.hud_text = gleasy_atlas_new(GL_RED, 1024, 1024, true),
.popup_text = gleasy_atlas_new(GL_RED, 1024, 1024, true),
.menu_text = gleasy_atlas_new(GL_RED, 1024, 1024, true),
.event_line = gleasy_atlas_new(GL_RED, 1024, 1024, true),
};
loshader_backwall_program_initialize(&set->program.backwall);
loshader_ground_program_initialize(&set->program.ground);
loshader_character_program_initialize(&set->program.character);
loshader_bullet_program_initialize(&set->program.bullet);
loshader_fog_program_initialize(&set->program.fog);
loshader_pixsort_program_initialize(&set->program.pixsort);
loshader_posteffect_program_initialize(&set->program.posteffect);
loshader_hud_bar_program_initialize(&set->program.hud_bar);
loshader_hud_text_program_initialize(&set->program.hud_text);
loshader_menu_background_program_initialize(&set->program.menu_background);
loshader_menu_text_program_initialize(&set->program.menu_text);
loshader_menu_stance_program_initialize(&set->program.menu_stance);
loshader_combat_ring_program_initialize(&set->program.combat_ring);
loshader_cinescope_program_initialize(&set->program.cinescope);
loshader_event_line_program_initialize(&set->program.event_line);
set->drawer = (typeof(set->drawer)) {
.backwall = loshader_backwall_drawer_new(
&set->program.backwall, set->uniblock),
.ground = loshader_ground_drawer_new(
&set->program.ground, set->uniblock),
.character = loshader_character_drawer_new(
&set->program.character, set->uniblock),
.bullet = loshader_bullet_drawer_new(
&set->program.bullet, set->uniblock),
.fog = loshader_fog_drawer_new(
&set->program.fog, set->uniblock),
.pixsort = loshader_pixsort_drawer_new(
&set->program.pixsort, set->uniblock, &set->framebuffer),
.posteffect = loshader_posteffect_drawer_new(
&set->program.posteffect, set->uniblock, &set->framebuffer),
.hud_bar = loshader_hud_bar_drawer_new(
&set->program.hud_bar, set->uniblock),
.menu_background = loshader_menu_background_drawer_new(
&set->program.menu_background, set->uniblock),
.menu_stance = loshader_menu_stance_drawer_new(
&set->program.menu_stance, set->uniblock),
.combat_ring = loshader_combat_ring_drawer_new(
&set->program.combat_ring, set->uniblock),
.cinescope = loshader_cinescope_drawer_new(
&set->program.cinescope, set->uniblock),
};
loshader_backwall_drawer_initialize(&set->drawer.backwall, &set->uniblock);
loshader_ground_drawer_initialize(&set->drawer.ground, &set->uniblock);
loshader_character_drawer_initialize(&set->drawer.character, &set->uniblock);
loshader_bullet_drawer_initialize(&set->drawer.bullet, &set->uniblock);
loshader_particle_drawer_initialize(&set->drawer.particle, &set->uniblock);
loshader_fog_drawer_initialize(&set->drawer.fog, &set->uniblock);
loshader_pixsort_drawer_initialize(
&set->drawer.pixsort, &set->uniblock, &set->framebuffer);
loshader_posteffect_drawer_initialize(
&set->drawer.posteffect, &set->uniblock, &set->framebuffer);
loshader_hud_bar_drawer_initialize(&set->drawer.hud_bar, &set->uniblock);
loshader_menu_background_drawer_initialize(
&set->drawer.menu_background, &set->uniblock);
loshader_menu_stance_drawer_initialize(
&set->drawer.menu_stance, &set->uniblock);
loshader_combat_ring_drawer_initialize(
&set->drawer.combat_ring, &set->uniblock);
loshader_cinescope_drawer_initialize(&set->drawer.cinescope, &set->uniblock);
loshader_hud_text_drawer_initialize(
&set->drawer.hud_text,
&set->program.hud_text,
set->uniblock,
&set->uniblock,
gleasy_atlas_get_texture(set->tex.hud_text));
loshader_popup_text_drawer_initialize(
&set->drawer.popup_text,
&set->uniblock,
gleasy_atlas_get_texture(set->tex.popup_text));
loshader_menu_text_drawer_initialize(
&set->drawer.menu_text,
&set->program.menu_text,
set->uniblock,
&set->uniblock,
gleasy_atlas_get_texture(set->tex.menu_text));
loshader_event_line_drawer_initialize(
&set->drawer.event_line,
&set->program.event_line,
set->uniblock,
&set->uniblock,
gleasy_atlas_get_texture(set->tex.event_line));
}
void loshader_set_deinitialize(loshader_set_t* set) {
assert(set != NULL);
loshader_backwall_drawer_delete(set->drawer.backwall);
loshader_ground_drawer_delete(set->drawer.ground);
loshader_character_drawer_delete(set->drawer.character);
loshader_bullet_drawer_delete(set->drawer.bullet);
loshader_fog_drawer_delete(set->drawer.fog);
loshader_pixsort_drawer_delete(set->drawer.pixsort);
loshader_posteffect_drawer_delete(set->drawer.posteffect);
loshader_hud_bar_drawer_delete(set->drawer.hud_bar);
loshader_backwall_drawer_deinitialize(&set->drawer.backwall);
loshader_ground_drawer_deinitialize(&set->drawer.ground);
loshader_character_drawer_deinitialize(&set->drawer.character);
loshader_bullet_drawer_deinitialize(&set->drawer.bullet);
loshader_particle_drawer_deinitialize(&set->drawer.particle);
loshader_fog_drawer_deinitialize(&set->drawer.fog);
loshader_pixsort_drawer_deinitialize(&set->drawer.pixsort);
loshader_posteffect_drawer_deinitialize(&set->drawer.posteffect);
loshader_hud_bar_drawer_deinitialize(&set->drawer.hud_bar);
loshader_hud_text_drawer_deinitialize(&set->drawer.hud_text);
loshader_menu_background_drawer_delete(set->drawer.menu_background);
loshader_popup_text_drawer_deinitialize(&set->drawer.popup_text);
loshader_menu_background_drawer_deinitialize(&set->drawer.menu_background);
loshader_menu_text_drawer_deinitialize(&set->drawer.menu_text);
loshader_menu_stance_drawer_delete(set->drawer.menu_stance);
loshader_combat_ring_drawer_delete(set->drawer.combat_ring);
loshader_cinescope_drawer_delete(set->drawer.cinescope);
loshader_menu_stance_drawer_deinitialize(&set->drawer.menu_stance);
loshader_combat_ring_drawer_deinitialize(&set->drawer.combat_ring);
loshader_cinescope_drawer_deinitialize(&set->drawer.cinescope);
loshader_event_line_drawer_deinitialize(&set->drawer.event_line);
loshader_backwall_program_deinitialize(&set->program.backwall);
loshader_ground_program_deinitialize(&set->program.ground);
loshader_character_program_deinitialize(&set->program.character);
loshader_bullet_program_deinitialize(&set->program.bullet);
loshader_fog_program_deinitialize(&set->program.fog);
loshader_pixsort_program_deinitialize(&set->program.pixsort);
loshader_posteffect_program_deinitialize(&set->program.posteffect);
loshader_hud_bar_program_deinitialize(&set->program.hud_bar);
loshader_hud_text_program_deinitialize(&set->program.hud_text);
loshader_menu_background_program_deinitialize(&set->program.menu_background);
loshader_menu_text_program_deinitialize(&set->program.menu_text);
loshader_menu_stance_program_deinitialize(&set->program.menu_stance);
loshader_combat_ring_program_deinitialize(&set->program.combat_ring);
loshader_cinescope_program_deinitialize(&set->program.cinescope);
loshader_event_line_program_deinitialize(&set->program.event_line);
gleasy_atlas_delete(set->tex.hud_text);
gleasy_atlas_delete(set->tex.popup_text);
gleasy_atlas_delete(set->tex.menu_text);
gleasy_atlas_delete(set->tex.event_line);
loshader_uniblock_delete(set->uniblock);
loshader_uniblock_deinitialize(&set->uniblock);
gleasy_framebuffer_deinitialize(&set->framebuffer);
}
void loshader_set_clear_all(loshader_set_t* set) {
assert(set != NULL);
loshader_ground_drawer_clear(set->drawer.ground, 256);
loshader_character_drawer_clear(set->drawer.character, 256);
loshader_bullet_drawer_clear(set->drawer.bullet, 256);
set->drawer.hud_text.alpha = 0;
set->drawer.menu_background.alpha = 0;
set->drawer.menu_text.alpha = 0;
loshader_hud_bar_drawer_clear(set->drawer.hud_bar, 16);
loshader_ground_drawer_clear(&set->drawer.ground, 256);
loshader_character_drawer_clear(&set->drawer.character, 256);
loshader_bullet_drawer_clear(&set->drawer.bullet, 256);
loshader_particle_drawer_clear(&set->drawer.particle, 256);
loshader_hud_bar_drawer_clear(&set->drawer.hud_bar, 16);
loshader_hud_text_drawer_clear(&set->drawer.hud_text, 256);
loshader_menu_background_drawer_set_alpha(set->drawer.menu_background, 0);
loshader_popup_text_drawer_clear(&set->drawer.popup_text, 256);
loshader_menu_text_drawer_clear(&set->drawer.menu_text, 512);
loshader_menu_stance_drawer_clear(set->drawer.menu_stance, 16);
loshader_combat_ring_drawer_clear(set->drawer.combat_ring, 8);
loshader_menu_stance_drawer_clear(&set->drawer.menu_stance, 16);
loshader_combat_ring_drawer_clear(&set->drawer.combat_ring, 8);
loshader_event_line_drawer_clear(&set->drawer.event_line, 256);
}
@@ -203,18 +161,19 @@ void loshader_set_draw_all(const loshader_set_t* set) {
glEnable(GL_MULTISAMPLE);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
loshader_backwall_drawer_draw(set->drawer.backwall);
loshader_ground_drawer_draw(set->drawer.ground);
loshader_character_drawer_draw(set->drawer.character);
loshader_bullet_drawer_draw(set->drawer.bullet);
loshader_fog_drawer_draw(set->drawer.fog);
loshader_backwall_drawer_draw(&set->drawer.backwall);
loshader_ground_drawer_draw(&set->drawer.ground);
loshader_character_drawer_draw(&set->drawer.character);
loshader_bullet_drawer_draw(&set->drawer.bullet);
loshader_particle_drawer_draw(&set->drawer.particle);
loshader_fog_drawer_draw(&set->drawer.fog);
gleasy_framebuffer_flush(&set->framebuffer);
/* ---- path 2: pixsort ---- */
if (!loshader_pixsort_drawer_is_skippable(set->drawer.pixsort)) {
if (!loshader_pixsort_drawer_is_skippable(&set->drawer.pixsort)) {
gleasy_framebuffer_bind(&set->framebuffer);
loshader_pixsort_drawer_draw(set->drawer.pixsort);
loshader_pixsort_drawer_draw(&set->drawer.pixsort);
gleasy_framebuffer_flush(&set->framebuffer);
}
@@ -224,18 +183,19 @@ void loshader_set_draw_all(const loshader_set_t* set) {
glDisable(GL_BLEND);
glDisable(GL_MULTISAMPLE);
loshader_posteffect_drawer_draw(set->drawer.posteffect);
loshader_posteffect_drawer_draw(&set->drawer.posteffect);
glEnable(GL_BLEND);
glEnable(GL_MULTISAMPLE);
loshader_hud_bar_drawer_draw(set->drawer.hud_bar);
loshader_hud_bar_drawer_draw(&set->drawer.hud_bar);
loshader_hud_text_drawer_draw(&set->drawer.hud_text);
loshader_menu_background_drawer_draw(set->drawer.menu_background);
loshader_popup_text_drawer_draw(&set->drawer.popup_text);
loshader_menu_background_drawer_draw(&set->drawer.menu_background);
loshader_menu_text_drawer_draw(&set->drawer.menu_text);
loshader_menu_stance_drawer_draw(set->drawer.menu_stance);
loshader_combat_ring_drawer_draw(set->drawer.combat_ring);
loshader_cinescope_drawer_draw(set->drawer.cinescope);
loshader_menu_stance_drawer_draw(&set->drawer.menu_stance);
loshader_combat_ring_drawer_draw(&set->drawer.combat_ring);
loshader_cinescope_drawer_draw(&set->drawer.cinescope);
loshader_event_line_drawer_draw(&set->drawer.event_line);
gleasy_framebuffer_flush_to_other(&set->framebuffer, 0);
@@ -245,6 +205,7 @@ void loshader_set_drop_cache(loshader_set_t* set) {
assert(set != NULL);
gleasy_atlas_clear(set->tex.hud_text);
gleasy_atlas_clear(set->tex.popup_text);
gleasy_atlas_clear(set->tex.menu_text);
gleasy_atlas_clear(set->tex.event_line);
}

68
core/loshader/set.h
View File

@@ -6,6 +6,8 @@
#include "util/gleasy/framebuffer.h"
#include "util/math/vector.h"
#include "core/locommon/screen.h"
#include "./backwall.h"
#include "./bullet.h"
#include "./character.h"
@@ -19,67 +21,49 @@
#include "./menu_background.h"
#include "./menu_stance.h"
#include "./menu_text.h"
#include "./particle.h"
#include "./pixsort.h"
#include "./popup_text.h"
#include "./posteffect.h"
#include "./uniblock.h"
typedef struct {
gleasy_framebuffer_t framebuffer;
loshader_uniblock_t* uniblock;
loshader_uniblock_t uniblock;
struct {
gleasy_atlas_t* hud_text;
gleasy_atlas_t* popup_text;
gleasy_atlas_t* menu_text;
gleasy_atlas_t* event_line;
} tex;
struct {
loshader_backwall_program_t backwall;
loshader_ground_program_t ground;
loshader_character_program_t character;
loshader_bullet_program_t bullet;
loshader_fog_program_t fog;
loshader_pixsort_program_t pixsort;
loshader_posteffect_program_t posteffect;
loshader_hud_bar_program_t hud_bar;
loshader_hud_text_program_t hud_text;
loshader_menu_background_program_t menu_background;
loshader_menu_text_program_t menu_text;
loshader_menu_stance_program_t menu_stance;
loshader_combat_ring_program_t combat_ring;
loshader_cinescope_program_t cinescope;
loshader_event_line_program_t event_line;
} program;
struct {
loshader_backwall_drawer_t* backwall;
loshader_ground_drawer_t* ground;
loshader_character_drawer_t* character;
loshader_bullet_drawer_t* bullet;
loshader_fog_drawer_t* fog;
loshader_pixsort_drawer_t* pixsort;
loshader_posteffect_drawer_t* posteffect;
loshader_hud_bar_drawer_t* hud_bar;
loshader_hud_text_drawer_t hud_text;
loshader_menu_background_drawer_t* menu_background;
loshader_menu_text_drawer_t menu_text;
loshader_menu_stance_drawer_t* menu_stance;
loshader_combat_ring_drawer_t* combat_ring;
loshader_cinescope_drawer_t* cinescope;
loshader_event_line_drawer_t event_line;
loshader_backwall_drawer_t backwall;
loshader_ground_drawer_t ground;
loshader_character_drawer_t character;
loshader_bullet_drawer_t bullet;
loshader_particle_drawer_t particle;
loshader_fog_drawer_t fog;
loshader_pixsort_drawer_t pixsort;
loshader_posteffect_drawer_t posteffect;
loshader_hud_bar_drawer_t hud_bar;
loshader_hud_text_drawer_t hud_text;
loshader_popup_text_drawer_t popup_text;
loshader_menu_background_drawer_t menu_background;
loshader_menu_text_drawer_t menu_text;
loshader_menu_stance_drawer_t menu_stance;
loshader_combat_ring_drawer_t combat_ring;
loshader_cinescope_drawer_t cinescope;
loshader_event_line_drawer_t event_line;
} drawer;
vec2_t resolution;
vec2_t dpi;
} loshader_set_t;
void
loshader_set_initialize(
loshader_set_t* set,
int32_t width,
int32_t height,
const vec2_t* dpi,
int32_t max_msaa
loshader_set_t* set,
const locommon_screen_t* screen,
int32_t max_msaa
);
void

91
core/loshader/single.c Normal file
View File

@@ -0,0 +1,91 @@
#include "./single.h"
#include <assert.h>
#include <stddef.h>
#include <stdint.h>
#include <GL/glew.h>
#include "util/gleasy/buffer.h"
#include "util/gleasy/program.h"
#include "./uniblock.h"
#define UNIBLOCK_INDEX_ 0
#define PARAM_INDEX_ 1
void loshader_single_drawer_initialize(
loshader_single_drawer_t* drawer,
gleasy_program_t prog,
const loshader_uniblock_t* uniblock,
size_t param_size) {
assert(drawer != NULL);
assert(uniblock != NULL);
const GLuint uniblock_index = glGetUniformBlockIndex(prog, "uniblock");
assert(glGetError() == GL_NO_ERROR);
glUniformBlockBinding(prog, uniblock_index, UNIBLOCK_INDEX_);
if (param_size > 0) {
const GLuint param_index = glGetUniformBlockIndex(prog, "param");
assert(glGetError() == GL_NO_ERROR);
glUniformBlockBinding(prog, param_index, PARAM_INDEX_);
}
*drawer = (typeof(*drawer)) {
.prog = prog,
.uniblock = uniblock,
.param_size = param_size,
};
if (param_size > 0) {
glGenBuffers(1, &drawer->param);
glBindBuffer(GL_UNIFORM_BUFFER, drawer->param);
glBufferData(GL_UNIFORM_BUFFER, param_size, NULL, GL_DYNAMIC_DRAW);
}
}
void loshader_single_drawer_deinitialize(loshader_single_drawer_t* drawer) {
assert(drawer != NULL);
if (drawer->param_size > 0) {
glDeleteBuffers(1, &drawer->param);
}
glDeleteProgram(drawer->prog);
}
void loshader_single_drawer_set_param(
loshader_single_drawer_t* drawer, const void* ptr) {
assert(drawer != NULL);
assert(drawer->param_size > 0);
assert(ptr != NULL);
glBindBuffer(GL_UNIFORM_BUFFER, drawer->param);
glBufferSubData(GL_UNIFORM_BUFFER, 0, drawer->param_size, ptr);
}
void loshader_single_drawer_draw(
const loshader_single_drawer_t* drawer, size_t primitives) {
assert(drawer != NULL);
if (primitives == 0) return;
glUseProgram(drawer->prog);
loshader_single_drawer_draw_without_use_program(drawer, primitives);
}
void loshader_single_drawer_draw_without_use_program(
const loshader_single_drawer_t* drawer, size_t primitives) {
assert(drawer != NULL);
if (primitives == 0) return;
loshader_uniblock_bind(drawer->uniblock, UNIBLOCK_INDEX_);
if (drawer->param_size > 0) {
glBindBufferBase(GL_UNIFORM_BUFFER, PARAM_INDEX_, drawer->param);
}
glDrawArrays(GL_TRIANGLES, 0, primitives);
}

48
core/loshader/single.h Normal file
View File

@@ -0,0 +1,48 @@
#pragma once
#include <stddef.h>
#include <stdint.h>
#include "util/gleasy/buffer.h"
#include "util/gleasy/program.h"
#include "./uniblock.h"
typedef struct {
gleasy_program_t prog;
const loshader_uniblock_t* uniblock;
gleasy_buffer_uniform_t param;
size_t param_size;
} loshader_single_drawer_t;
void
loshader_single_drawer_initialize(
loshader_single_drawer_t* drawer,
gleasy_program_t prog, /* OWNERSHIP */
const loshader_uniblock_t* uniblock,
size_t param_size
);
void
loshader_single_drawer_deinitialize(
loshader_single_drawer_t* drawer
);
void
loshader_single_drawer_set_param(
loshader_single_drawer_t* drawer,
const void* ptr
);
void
loshader_single_drawer_draw(
const loshader_single_drawer_t* drawer,
size_t primitives
);
void
loshader_single_drawer_draw_without_use_program(
const loshader_single_drawer_t* drawer,
size_t primitives
);

55
core/loshader/text.c Normal file
View File

@@ -0,0 +1,55 @@
#include "./text.h"
#include <assert.h>
#include "util/gleasy/program.h"
#include "util/gleasy/texture.h"
#include "util/glyphas/drawer.h"
#include "./uniblock.h"
#define UNIBLOCK_INDEX_ 0
void loshader_text_drawer_initialize(
loshader_text_drawer_t* drawer,
gleasy_program_t prog,
const loshader_uniblock_t* uniblock,
gleasy_texture_2d_t tex) {
assert(drawer != NULL);
assert(prog != 0);
assert(uniblock != NULL);
assert(tex != 0);
const GLuint uniblock_index = glGetUniformBlockIndex(prog, "uniblock");
assert(glGetError() == GL_NO_ERROR);
glUniformBlockBinding(prog, uniblock_index, UNIBLOCK_INDEX_);
*drawer = (typeof(*drawer)) {
.prog = prog,
.uniblock = uniblock,
};
glyphas_drawer_initialize(&drawer->super, tex);
}
void loshader_text_drawer_deinitialize(
loshader_text_drawer_t* drawer) {
assert(drawer != NULL);
glyphas_drawer_deinitialize(&drawer->super);
glDeleteProgram(drawer->prog);
}
void loshader_text_drawer_draw(const loshader_text_drawer_t* drawer) {
assert(drawer != NULL);
glUseProgram(drawer->prog);
loshader_text_drawer_draw_without_use_program(drawer);
}
void loshader_text_drawer_draw_without_use_program(
const loshader_text_drawer_t* drawer) {
assert(drawer != NULL);
loshader_uniblock_bind(drawer->uniblock, UNIBLOCK_INDEX_);
glyphas_drawer_draw(&drawer->super);
}

44
core/loshader/text.h Normal file
View File

@@ -0,0 +1,44 @@
#pragma once
#include "util/gleasy/program.h"
#include "util/gleasy/texture.h"
#include "util/glyphas/drawer.h"
#include "./uniblock.h"
typedef struct {
glyphas_drawer_t super;
gleasy_program_t prog;
const loshader_uniblock_t* uniblock;
float alpha;
} loshader_text_drawer_t;
void
loshader_text_drawer_initialize(
loshader_text_drawer_t* drawer,
gleasy_program_t prog, /* OWNERSHIP */
const loshader_uniblock_t* uniblock,
gleasy_texture_2d_t tex
);
void
loshader_text_drawer_deinitialize(
loshader_text_drawer_t* drawer
);
#define loshader_text_drawer_clear(drawer, reserve) \
glyphas_drawer_clear(&(drawer)->super, reserve)
#define loshader_text_drawer_add_block(drawer, block) \
glyphas_drawer_add_block(&(drawer)->super, block)
void
loshader_text_drawer_draw(
const loshader_text_drawer_t* drawer
);
void
loshader_text_drawer_draw_without_use_program(
const loshader_text_drawer_t* drawer
);

63
core/loshader/uniblock.c
View File

@@ -11,13 +11,11 @@
#include "util/math/algorithm.h"
#include "util/math/vector.h"
#include "util/math/matrix.h"
#include "util/memory/memory.h"
#include "core/locommon/position.h"
#include "core/locommon/screen.h"
struct loshader_uniblock_t {
gleasy_buffer_uniform_t buf;
};
#define AA_ .00001f
#pragma pack(push, 1)
typedef struct {
@@ -34,7 +32,8 @@ typedef struct {
} loshader_uniblock_internal_t;
_Static_assert(
sizeof(float)*5 + 12 + sizeof(float)*37 ==
sizeof(loshader_uniblock_internal_t));
sizeof(loshader_uniblock_internal_t),
"recheck the type has no padding");
#pragma pack(pop)
bool loshader_uniblock_param_valid(const loshader_uniblock_param_t* param) {
@@ -46,42 +45,25 @@ bool loshader_uniblock_param_valid(const loshader_uniblock_param_t* param) {
MATH_FLOAT_VALID(param->time);
}
loshader_uniblock_t* loshader_uniblock_new(void) {
loshader_uniblock_t* uni = memory_new(sizeof(*uni));
*uni = (typeof(*uni)) {0};
void loshader_uniblock_initialize(
loshader_uniblock_t* uni, const locommon_screen_t* screen) {
assert(uni != NULL);
assert(locommon_screen_valid(screen));
*uni = (typeof(*uni)) {
.screen = screen,
};
glGenBuffers(1, &uni->buf);
glBindBuffer(GL_UNIFORM_BUFFER, uni->buf);
glBufferData(GL_UNIFORM_BUFFER,
sizeof(loshader_uniblock_internal_t), NULL, GL_DYNAMIC_DRAW);
return uni;
}
void loshader_uniblock_delete(loshader_uniblock_t* uni) {
if (uni == NULL) return;
void loshader_uniblock_deinitialize(loshader_uniblock_t* uni) {
assert(uni != NULL);
glDeleteBuffers(1, &uni->buf);
memory_delete(uni);
}
void loshader_uniblock_update_display_param(
loshader_uniblock_t* uni, const vec2_t* resolution, const vec2_t* dpi) {
assert(uni != NULL);
assert(vec2_valid(resolution));
assert(vec2_valid(dpi));
const loshader_uniblock_internal_t internal = {
.resolution = *resolution,
.dpi = *dpi,
.aa = MATH_MAX(dpi->x, dpi->y) / 100000,
};
static const size_t size =
offsetof(loshader_uniblock_internal_t, aa) + sizeof(internal.aa);
glBindBuffer(GL_UNIFORM_BUFFER, uni->buf);
glBufferSubData(GL_UNIFORM_BUFFER, 0, size, &internal);
}
void loshader_uniblock_update_param(
@@ -97,17 +79,16 @@ void loshader_uniblock_update_param(
param->pos.fract.y);
const loshader_uniblock_internal_t internal = {
.proj = param->proj,
.camera = param->cam,
.pos = pos,
.time = param->time,
.resolution = uni->screen->resolution,
.dpi = uni->screen->dpi,
.aa = MATH_MAX(uni->screen->dpi.x, uni->screen->dpi.y) * AA_,
.proj = param->proj,
.camera = param->cam,
.pos = pos,
.time = param->time,
};
static const size_t offset = offsetof(loshader_uniblock_internal_t, proj);
glBindBuffer(GL_UNIFORM_BUFFER, uni->buf);
glBufferSubData(GL_UNIFORM_BUFFER,
offset, sizeof(internal)-offset, &internal.proj);
glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(internal), &internal);
}
void loshader_uniblock_bind(const loshader_uniblock_t* uni, GLuint index) {

27
core/loshader/uniblock.h
View File

@@ -4,13 +4,18 @@
#include <GL/glew.h>
#include "util/gleasy/buffer.h"
#include "util/math/vector.h"
#include "util/math/matrix.h"
#include "core/locommon/position.h"
#include "core/locommon/screen.h"
struct loshader_uniblock_t;
typedef struct loshader_uniblock_t loshader_uniblock_t;
typedef struct {
const locommon_screen_t* screen;
gleasy_buffer_uniform_t buf;
} loshader_uniblock_t;
typedef struct {
mat4_t proj;
@@ -26,21 +31,15 @@ loshader_uniblock_param_valid(
const loshader_uniblock_param_t* param
);
loshader_uniblock_t* /* OWNERSHIP */
loshader_uniblock_new(
void
void
loshader_uniblock_initialize(
loshader_uniblock_t* uni,
const locommon_screen_t* screen
);
void
loshader_uniblock_delete(
loshader_uniblock_t* uni /* OWNERSHIP */
);
void
loshader_uniblock_update_display_param(
loshader_uniblock_t* uni,
const vec2_t* resolution,
const vec2_t* dpi
loshader_uniblock_deinitialize(
loshader_uniblock_t* uni
);
void