john/prosperon
1
0
Fork 0
Code Issues Pull requests Actions Releases Activity

sokol sprite render

Browse source
This commit is contained in:
John Alanbrook 2023-05-04 22:07:00 +00:00
parent 1408c05103
commit ae0f41539b
25 changed files with 338 additions and 352 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
Makefile
View file

@ -83,7 +83,7 @@ ifeq ($(OS), WIN32)
EXT = .exe
else
LINKER_FLAGS = $(QFLAGS) -L/usr/local/lib -rdynamic
ELIBS = engine pthread yughc glfw3 tcc quickjs c m dl
ELIBS = engine pthread yughc glfw3 tcc quickjs c m dl GL
CLIBS =
endif

11
source/engine/3d/mesh.c
View file

@ -16,7 +16,7 @@ void DrawMesh(struct mesh *mesh, struct shader *shader)
uint32_t heightNr = 1;
for (int i = 0; i < (mesh->te - mesh->textures); i++) {
glActiveTexture(GL_TEXTURE0 + i); // active proper texture unit before binding
// glActiveTexture(GL_TEXTURE0 + i); // active proper texture unit before binding
// retrieve texture number (the N in diffuse_textureN)
char number = 0;
// TODO: malloc every single frame ... nope! Change to stack
@ -50,8 +50,6 @@ void DrawMesh(struct mesh *mesh, struct shader *shader)
void DrawMeshAgain(struct mesh *mesh)
{
glDrawElements(GL_TRIANGLES, (mesh->ie - mesh->indices),
GL_UNSIGNED_INT, 0);
}
struct mesh *MakeMesh(struct Vertex *vertices, struct Vertex *ve,
@ -72,6 +70,7 @@ struct mesh *MakeMesh(struct Vertex *vertices, struct Vertex *ve,
void setupmesh(struct mesh *mesh)
{
/*
// create buffers/arrays
glGenVertexArrays(1, &mesh->VAO);
glGenBuffers(1, &mesh->VBO);
@ -112,13 +111,15 @@ void setupmesh(struct mesh *mesh)
// Bone ids
glEnableVertexAttribArray(5);
/* glVertexAttribPointer(5, 4, GL_INT, GL_FALSE, sizeof(struct Vertex), offsetof(struct Vertex,
glVertexAttribPointer(5, 4, GL_INT, GL_FALSE, sizeof(struct Vertex), offsetof(struct Vertex,
m_BoneIDs
[MAX_BONE_INFLUENCE]));
*/
// Weights
glEnableVertexAttribArray(6);
// glVertexAttribPointer(6, 4, GL_FLOAT, GL_FALSE, sizeof(struct Vertex), offsetof(struct Vertex, m_Weights));
glBindVertexArray(0);
*/
}

17
source/engine/3d/skybox.c
View file

@ -53,8 +53,8 @@ static const float skyboxVertices[216] = {
struct mSkybox *MakeSkybox(const char *cubemap)
{
struct mSkybox *newskybox =
(struct mSkybox *) malloc(sizeof(struct mSkybox));
/*
struct mSkybox *newskybox = malloc(sizeof(struct mSkybox));
newskybox->shader = MakeShader("skyvert.glsl", "skyfrag.glsl");
shader_compile(newskybox->shader);
@ -63,24 +63,24 @@ struct mSkybox *MakeSkybox(const char *cubemap)
glGenBuffers(1, &newskybox->VBO);
glBindVertexArray(newskybox->VAO);
glBindBuffer(GL_ARRAY_BUFFER, newskybox->VBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(skyboxVertices), &skyboxVertices,
GL_STATIC_DRAW);
glBufferData(GL_ARRAY_BUFFER, sizeof(skyboxVertices), &skyboxVertices, GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float),
(void *) 0);
shader_use(newskybox->shader);
shader_setint(newskybox->shader, "skybox", 0);
*/
/*
const char *faces[6] =
{ "right.jpg", "left.jpg", "top.jpg", "bottom.jpg", "front.jpg",
"back.jpg"
};
*/
/*
glGenTextures(1, &newskybox->id);
glBindTexture(GL_TEXTURE_CUBE_MAP, newskybox->id);
*/
/*char buf[100] = { '\0' };*/
for (int i = 0; i < 6; i++) {
@ -94,7 +94,7 @@ struct mSkybox *MakeSkybox(const char *cubemap)
2048, 0, GL_RGB, GL_UNSIGNED_BYTE, data->pixels);
*/
}
/*
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S,
@ -106,11 +106,13 @@ struct mSkybox *MakeSkybox(const char *cubemap)
return newskybox;
*/
}
void skybox_draw(const struct mSkybox *skybox,
const struct mCamera *camera)
{
/*
shader_use(skybox->shader);
mfloat_t view[16] = { 0.f };
@ -123,4 +125,5 @@ void skybox_draw(const struct mSkybox *skybox,
glBindTexture(GL_TEXTURE_CUBE_MAP, skybox->id);
glDrawArrays(GL_TRIANGLES, 0, 36);
glBindVertexArray(0);
*/
}

9
source/engine/datastream.c
View file

@ -18,18 +18,22 @@ struct shader *vid_shader;
static void ds_update_texture(uint32_t unit, uint32_t texture, plm_plane_t * plane)
{
/*
glActiveTexture(unit);
glBindTexture(GL_TEXTURE_2D, texture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, plane->width, plane->height, 0, GL_RED, GL_UNSIGNED_BYTE, plane->data);
*/
}
static void render_frame(plm_t * mpeg, plm_frame_t * frame, void *user)
{
struct datastream *ds = user;
shader_use(ds->shader);
/*
ds_update_texture(GL_TEXTURE0, ds->texture_y, &frame->y);
ds_update_texture(GL_TEXTURE1, ds->texture_cb, &frame->cb);
ds_update_texture(GL_TEXTURE2, ds->texture_cr, &frame->cr);
*/
}
static void render_audio(plm_t * mpeg, plm_samples_t * samples, void *user)
@ -45,11 +49,13 @@ static void render_audio(plm_t * mpeg, plm_samples_t * samples, void *user)
struct Texture *ds_maketexture(struct datastream *ds)
{
/*
struct Texture *new = malloc(sizeof(*new));
new->id = ds->texture_cb;
new->width = 500;
new->height = 500;
return new;
*/
}
void ds_openvideo(struct datastream *ds, const char *video, const char *adriver)
@ -110,6 +116,7 @@ void ds_openvideo(struct datastream *ds, const char *video, const char *adriver)
struct datastream *MakeDatastream()
{
struct datastream *newds = malloc(sizeof(*newds));
/*
if (!vid_shader) vid_shader = MakeShader("videovert.glsl", "videofrag.glsl");
newds->shader = vid_shader;
@ -137,7 +144,7 @@ struct datastream *MakeDatastream()
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
shader_setint(newds->shader, "texture_cr", 2);
*/
return newds;
}

39
source/engine/debug/debugdraw.c
View file

@ -9,6 +9,7 @@
#include "window.h"
#include "2dphysics.h"
#include "stb_ds.h"
#include "sokol/sokol_gfx.h"
static uint32_t circleVBO;
static uint32_t circleVAO;
@ -22,15 +23,26 @@ static uint32_t rectVBO;
static uint32_t rectVAO;
static struct shader *rectShader;
typedef struct {
float proj[16];
float res[2];
} circle_ubo;
void debugdraw_init()
{
circleShader = MakeShader("circlevert.glsl", "circlefrag.glsl");
shader_setUBO(circleShader, "Projection", 0);
shader_setUBO(circleShader, "Resolution", 0);
glGenBuffers(1, &circleVBO);
glGenVertexArrays(1, &circleVAO);
// circleShader = MakeShader("shaders/circlevert.glsl", "shaders/circlefrag.glsl");
sg_shader csg = sg_make_shader(&(sg_shader_desc){
.vs.source = slurp_text("shaders/circlevert.glsl"),
.fs.source = slurp_text("shaders/circlefrag.glsl"),
.vs.uniform_blocks[0] = {
.size = sizeof(circle_ubo),
.uniforms = {
[0] = { .name = "proj", .type = SG_UNIFORMTYPE_MAT4 },
[1] = { .name = "res", .type = SG_UNIFORMTYPE_FLOAT2 },
}
}
});
/*
float gridverts[] = {
-1.f, -1.f,
1.f, -1.f,
@ -52,6 +64,7 @@ void debugdraw_init()
shader_setUBO(rectShader, "Projection", 0);
glGenBuffers(1, &rectVBO);
glGenVertexArrays(1, &rectVAO);
*/
}
void draw_line(int x1, int y1, int x2, int y2, float *color)
@ -138,7 +151,7 @@ void draw_edge(cpVect *points, int n, struct color color, int thickness)
shader_use(rectShader);
shader_setvec3(rectShader, "linecolor", col);
/*
if (thickness <= 1) {
// glLineStipple(1, 0x00FF);
// glEnable(GL_LINE_STIPPLE);
@ -182,11 +195,12 @@ void draw_edge(cpVect *points, int n, struct color color, int thickness)
glDrawArrays(GL_LINE_LOOP,0,n*2);
}
*/
}
void draw_circle(int x, int y, float radius, int pixels, float *color, int fill)
{
shader_use(circleShader);
/* shader_use(circleShader);
float verts[] = {
x - radius, y - radius, -1, -1,
@ -208,6 +222,7 @@ void draw_circle(int x, int y, float radius, int pixels, float *color, int fill)
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, NULL);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
*/
}
void draw_rect(int x, int y, int w, int h, float *color)
@ -241,7 +256,7 @@ void draw_arrow(struct cpVect start, struct cpVect end, struct color color, int
void draw_grid(int width, int span)
{
shader_use(gridShader);
/* shader_use(gridShader);
shader_setint(gridShader, "thickness", width);
shader_setint(gridShader, "span", span);
@ -254,6 +269,7 @@ void draw_grid(int width, int span)
glBindVertexArray(gridVAO);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
*/
}
void draw_point(int x, int y, float r, float *color)
@ -275,7 +291,7 @@ void draw_points(struct cpVect *points, int n, float size, float *color)
void draw_poly(float *points, int n, float *color)
{
shader_use(rectShader);
/* shader_use(rectShader);
shader_setvec3(rectShader, "linecolor", color);
glBindBuffer(GL_ARRAY_BUFFER, rectVBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(float) * n * 2, points, GL_DYNAMIC_DRAW);
@ -289,6 +305,7 @@ void draw_poly(float *points, int n, float *color)
shader_setfloat(rectShader, "alpha", 1.f);
glDrawArrays(GL_LINE_LOOP, 0, n);
*/
}
void draw_polyvec(cpVect *points, int n, float *color)

11
source/engine/debug/log.c
View file

@ -86,14 +86,3 @@ void log_cat(FILE *f) {
YughInfo(out);
}
}
void FlushGLErrors()
{
GLenum glErr = GL_NO_ERROR;
glErr = glGetError();
while (glErr != GL_NO_ERROR) {
YughLog(0, 3,
"GL Error: %d", glErr);
glErr = glGetError();
}
}

2
source/engine/debug/log.h
View file

@ -32,8 +32,6 @@ extern int logLevel;
void mYughLog(int category, int priority, int line, const char *file, const char *message, ...);
void FlushGLErrors();
void log_setfile(char *file);
void log_cat(FILE *f);
void log_print(const char *str);

126
source/engine/font.c
View file

@ -16,11 +16,9 @@
#include "stb_rect_pack.h"
#include "stb_image_write.h"
static uint32_t VBO = 0;
static uint32_t VAO = 0;
struct sFont *font;
static struct shader *shader;
static sg_shader fontshader;
unsigned char *slurp_file(const char *filename) {
FILE *f = fopen(filename, "rb");
@ -30,7 +28,8 @@ unsigned char *slurp_file(const char *filename) {
fseek(f, 0, SEEK_END);
long fsize = ftell(f);
fseek(f, 0, SEEK_SET);
unsigned char *slurp = malloc(fsize);
unsigned char *slurp = malloc(fsize+1);
fread(slurp,fsize,1,f);
fclose(f);
return slurp;
@ -64,25 +63,46 @@ int slurp_write(const char *txt, const char *filename)
return 0;
}
static sg_bindings bind_text;
static sg_pipeline pipe_text;
void font_init(struct shader *textshader) {
shader = textshader;
shader_use(shader);
fontshader = sg_make_shader(&(sg_shader_desc){
.vs.source = slurp_text("shaders/textvert.glsl"),
.fs.source = slurp_text("shaders/textfrag.glsl"),
.vs.uniform_blocks[0] = {
.size = sizeof(float)*16,
.uniforms = {
[0] = { .name = "projection", .type = SG_UNIFORMTYPE_MAT4 }
}
},
glGenBuffers(1, &VBO);
glGenVertexArrays(1, &VAO);
.fs.uniform_blocks[0] = {
.size = sizeof(float)*3+sizeof(int),
.uniforms = {
[0] = { .name = "textColor", .type = SG_UNIFORMTYPE_FLOAT3 },
[1] = { .name = "invert", .type = SG_UNIFORMTYPE_INT }
}
}
});
glBindVertexArray(VAO);
pipe_text = sg_make_pipeline(&(sg_pipeline_desc){
.shader = fontshader,
.layout = {
.attrs = { [0].format = SG_VERTEXFORMAT_FLOAT4 }
},
.primitive_type = SG_PRIMITIVETYPE_TRIANGLE_STRIP,
.label = "text pipeline"
});
glBindBuffer(GL_ARRAY_BUFFER, VBO);
bind_text.vertex_buffers[0] = sg_make_buffer(&(sg_buffer_desc){
.size = sizeof(float)*16,
.type = SG_BUFFERTYPE_VERTEXBUFFER,
.usage = SG_USAGE_STREAM
});
glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, NULL);
glEnableVertexAttribArray(0);
glBindVertexArray(0);
// Default font
//font = MakeFont("teenytinypixels.ttf", 30);
font = MakeFont("LessPerfectDOSVGA.ttf", 16);
}
@ -102,14 +122,7 @@ struct sFont *MakeFont(const char *fontfile, int height)
char fontpath[256];
snprintf(fontpath, 256, "fonts/%s", fontfile);
FILE *f = fopen(fontpath, "rb");
fseek(f, 0, SEEK_END);
long fsize = ftell(f);
fseek(f, 0, SEEK_SET);
unsigned char *ttf_buffer = malloc(fsize+1);
fread(ttf_buffer, fsize, 1, f);
fclose(f);
unsigned char *ttf_buffer = slurp_file(fontpath);
unsigned char *bitmap = malloc(packsize*packsize);
stbtt_packedchar glyphs[95];
@ -127,16 +140,19 @@ struct sFont *MakeFont(const char *fontfile, int height)
YughError("Failed to make font %s", fontfile);
}
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glGenTextures(1, &newfont->texID);
glBindTexture(GL_TEXTURE_2D, newfont->texID);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, packsize, packsize, 0, GL_RED, GL_UNSIGNED_BYTE, bitmap);
//glGenerateMipmap(GL_TEXTURE_2D);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
newfont->texID = sg_make_image(&(sg_image_desc){
.type = SG_IMAGETYPE_2D,
.width = packsize,
.height = packsize,
.pixel_format = SG_PIXELFORMAT_R8,
.usage = SG_USAGE_IMMUTABLE,
.min_filter = SG_FILTER_NEAREST,
.mag_filter = SG_FILTER_NEAREST,
.data.subimage[0][0] = {
.ptr = bitmap,
.size = packsize*packsize
}
});
free(ttf_buffer);
free(bitmap);
@ -211,7 +227,7 @@ void sdrawCharacter(struct Character c, mfloat_t cursor[2], float scale, struct
/* Check if the vertex is off screen */
if (verts[5] < 0 || verts[10] < 0 || verts[0] > window_i(0)->width || verts[1] > window_i(0)->height)
return;
/*
if (drawcaret == curchar) {
draw_char_box(c, cursor, scale, color);
shader_use(shader);
@ -223,34 +239,34 @@ void sdrawCharacter(struct Character c, mfloat_t cursor[2], float scale, struct
}
*/
shader_setvec3(shader, "textColor", shadowcolor);
glBufferData(GL_ARRAY_BUFFER, sizeof(verts), verts, GL_STREAM_DRAW);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
sg_update_buffer(bind_text.vertex_buffers[0], verts);
sg_draw(0,4,1);
offset[0] = 1;
offset[1] = -1;
fill_charverts(verts, cursor, scale, c, offset);
glBufferData(GL_ARRAY_BUFFER, sizeof(verts), verts, GL_STREAM_DRAW);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
sg_update_buffer(bind_text.vertex_buffers[0], verts);
sg_draw(0,4,1);
offset[1] = 1;
fill_charverts(verts, cursor, scale, c, offset);
glBufferData(GL_ARRAY_BUFFER, sizeof(verts), verts, GL_STREAM_DRAW);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
sg_update_buffer(bind_text.vertex_buffers[0], verts);
sg_draw(0,4,1);
offset[0] = -1;
offset[1] = -1;
fill_charverts(verts, cursor, scale, c, offset);
glBufferData(GL_ARRAY_BUFFER, sizeof(verts), verts, GL_STREAM_DRAW);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
fill_charverts(verts, cursor, scale, c, offset);
sg_update_buffer(bind_text.vertex_buffers[0], verts);
sg_draw(0,4,1);
offset[0] = offset[1] = 0;
fill_charverts(verts, cursor, scale, c, offset);
shader_setvec3(shader, "textColor", color);
glBufferData(GL_ARRAY_BUFFER, sizeof(verts), verts, GL_STREAM_DRAW);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
sg_update_buffer(bind_text.vertex_buffers[0], verts);
sg_draw(0,4,1);
}
void text_settype(struct sFont *mfont)
@ -266,13 +282,9 @@ int renderText(const char *text, mfloat_t pos[2], float scale, mfloat_t color[3]
mfloat_t cursor[2] = { 0.f };
cursor[0] = pos[0];
cursor[1] = pos[1];
shader_use(shader);
shader_setvec3(shader, "textColor", color);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, font->texID);
glBindVertexArray(VAO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, len*16*sizeof(float)*2, NULL, GL_STREAM_DRAW); /* x2 on the size for the outline pass */
sg_apply_pipeline(pipe_text);
sg_apply_bindings(&bind_text);
sg_apply_uniforms(SG_SHADERSTAGE_FS,0,color);
const unsigned char *line, *wordstart, *drawstart;
line = drawstart = (unsigned char*)text;
@ -330,7 +342,5 @@ int renderText(const char *text, mfloat_t pos[2], float scale, mfloat_t color[3]
draw_char_box(font->Characters[69], cursor, scale, color);
}
// glDrawArrays(GL_TRIANGLE_STRIP, 0, 4*2);
return cursor[1] - pos[1];
}

3
source/engine/font.h
View file

@ -3,6 +3,7 @@
#include "mathc.h"
#include "texture.h"
#include "sokol/sokol_gfx.h"
struct shader;
struct window;
@ -20,7 +21,7 @@ struct sFont {
uint32_t fontTexture;
uint32_t height;
struct Character Characters[127];
uint32_t texID;
sg_image texID;
};
void font_init(struct shader *s);

2
source/engine/nuke.c
View file

@ -96,9 +96,11 @@ int nuke_btn(const char *lbl) {
}
void nuke_img(char *path) {
/*
struct Texture *t = texture_pullfromfile(path);
nk_layout_row_static(ctx, t->height, t->width, 1);
nk_image(ctx, nk_image_id(t->id));
*/
}
void nuke_property_int(const char *lbl, int min, int *val, int max, int step) {

93
source/engine/openglrender.c
View file

@ -52,15 +52,8 @@ bool renderReflection = true;
struct gameobject *selectedobject = NULL;
char objectName[200] = { '\0' }; // object name buffer
GLuint debugColorPickBO = 0;
GLuint debugColorPickTEX = 0;
struct sprite *tsprite = NULL;
static unsigned int projUBO;
void debug_draw_phys(int draw) {
debugDrawPhysics = draw;
}
@ -70,6 +63,9 @@ void opengl_rendermode(enum RenderMode r)
renderMode = r;
}
sg_pipeline mainpip;
sg_pass_action pass_action = {0};
void openglInit()
{
if (!mainwin) {
@ -83,16 +79,13 @@ void openglInit()
animSpriteShader = MakeShader("animspritevert.glsl", "animspritefrag.glsl");
textShader = MakeShader("textvert.glsl", "textfrag.glsl");
shader_use(textShader);
shader_setint(textShader, "text", 0);
font_init(textShader);
sprite_initialize();
debugdraw_init();
glClearColor(editorClearColor[0], editorClearColor[1], editorClearColor[2], editorClearColor[3]);
//glEnable(GL_CULL_FACE);
/*
glCullFace(GL_BACK);
glEnable(GL_BLEND);
@ -107,14 +100,7 @@ void openglInit()
shader_setUBO(spriteShader, "Projection", 0);
shader_setUBO(textShader, "Projection", 0);
shader_setUBO(animSpriteShader, "Projection", 0);
/*
glGenBuffers(1,&resUBO);
glBindBuffer(GL_UNIFORM_BUFFER, resUBO);
glBufferData(GL_UNIFORM_BUFFER, sizeof(float)*2, NULL, GL_DYNAMIC_DRAW);
glBindBufferRange(GL_UNIFORM_BUFFER, 0, resUBO, 0, sizeof(float)*2);
glBindBuffer(GL_UNIFORM_BUFFER,0);
*/
*/
}
@ -132,13 +118,13 @@ float cam_zoom() { return zoom; }
void add_zoom(float val) { zoom = val; }
mfloat_t projection[16] = {0.f};
void openglRender(struct window *window)
{
glCullFace(GL_BACK);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
sg_begin_default_pass(&pass_action, window->width, window->height);
//////////// 2D projection
mfloat_t projection[16] = { 0.f };
cpVect pos = cam_pos();
mat4_ortho(projection, pos.x - zoom*window->width/2,
@ -152,55 +138,30 @@ void openglRender(struct window *window)
0,
window->height, -1.f, 1.f);
// Clear color and depth
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
glBindBuffer(GL_UNIFORM_BUFFER, projUBO);
glBufferSubData(GL_UNIFORM_BUFFER, 0, 64, projection);
/*
float res[2] = {window->width, window->height};
glBindBuffer(GL_UNIFORM_BUFFER, resUBO);
glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(float)*2, res);
*/
/* Game sprites */
switch (renderMode) {
case LIT:
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
shader_use(spriteShader);
break;
case WIREFRAME:
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
shader_use(wireframeShader);
break;
};
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
sprite_draw_all();
// sprite_draw_all();
gui_draw_img("pill1.png", 200, 200);
// renderText("TEST RENDER", {100,100}, 1.f, {1.f,1.f,1.f}, 0,-1);
/* UI Elements & Debug elements */
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glDisable(GL_DEPTH_TEST);
// glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
// glDisable(GL_DEPTH_TEST);
//// DEBUG
if (debugDrawPhysics)
gameobject_draw_debugs();
// if (debugDrawPhysics)
// gameobject_draw_debugs();
call_debugs();
// call_debugs();
////// TEXT && GUI
glBindBuffer(GL_UNIFORM_BUFFER, projUBO);
glBufferSubData(GL_UNIFORM_BUFFER, 0, 64, ui_projection);
// glBindBuffer(GL_UNIFORM_BUFFER, projUBO);
// glBufferSubData(GL_UNIFORM_BUFFER, 0, 64, ui_projection);
call_gui();
// call_gui();
nuke_start();
call_nk_gui();
nuke_end();
}
void BindUniformBlock(GLuint shaderID, const char *bufferName, GLuint bufferBind)
{
glUniformBlockBinding(shaderID, glGetUniformBlockIndex(shaderID, bufferName), bufferBind);
// nuke_start();
// call_nk_gui();
// nuke_end();
sg_end_pass();
sg_commit();
}

8
source/engine/openglrender.h
View file

@ -1,8 +1,6 @@
#ifndef OPENGL_RENDER_H
#define OPENGL_RENDER_H
#include "render.h"
struct mCamera;
struct window;
@ -13,6 +11,8 @@ extern struct sprite *tsprite;
extern int renderMode;
extern float projection[16];
extern float gridScale;
extern float smallGridUnit;
extern float bigGridUnit;
@ -24,7 +24,7 @@ extern float gridOpacity;
extern float editorFOV;
extern float shadowLookahead;
extern char objectName[];
extern GLuint debugColorPickBO;
extern int debugColorPickBO;
extern struct gameobject *selectedobject;
@ -47,8 +47,6 @@ void openglRender3d(struct window *window, struct mCamera *camera);
void debug_draw_phys(int draw);
void BindUniformBlock(GLuint shaderID, const char *bufferName, GLuint bufferBind);
void set_cam_body(cpBody *body);
cpVect cam_pos();
float cam_zoom();

1
source/engine/render.h
View file

@ -2,7 +2,6 @@
#define RENDER_H
#define GLFW_INCLUDE_NONE
#include <glad/gl.h>
#include <GLFW/glfw3.h>
#endif

57
source/engine/shader.c
View file

@ -9,6 +9,7 @@
#include "resources.h"
#include "stb_ds.h"
#include "timer.h"
#include "font.h"
#include "time.h"
@ -29,8 +30,9 @@ struct shader *MakeShader(const char *vertpath, const char *fragpath)
return &arrlast(shaders);
}
int shader_compile_error(GLuint shader)
int shader_compile_error(int shader)
{
/*
GLint success = 0;
GLchar infoLog[ERROR_BUFFER] = { '\0' };
@ -41,10 +43,12 @@ int shader_compile_error(GLuint shader)
YughLog(0, LOG_ERROR, "Shader compilation error.\nLog: %s", infoLog);
return 1;
*/
}
int shader_link_error(GLuint shader)
int shader_link_error(int shader)
{
/*
GLint success = 0;
GLchar infoLog[ERROR_BUFFER] = { '\0' };
@ -55,9 +59,10 @@ int shader_link_error(GLuint shader)
YughLog(0, LOG_ERROR, "Shader link error.\nLog: %s", infoLog);
return 1;
*/
}
GLuint load_shader_from_file(const char *path, int type)
int load_shader_from_file(const char *path, int type)
{
char spath[MAXPATH] = {'\0'};
@ -77,7 +82,7 @@ GLuint load_shader_from_file(const char *path, int type)
fclose(f);
/*
GLuint id = glCreateShader(type);
const char *code = buf;
glShaderSource(id, 1, &code, NULL);
@ -88,32 +93,36 @@ GLuint load_shader_from_file(const char *path, int type)
}
free(buf);
return id;
*/
}
void shader_compile(struct shader *shader)
{
YughInfo("Making shader with %s and %s.", shader->vertpath, shader->fragpath);
char spath[MAXPATH];
sprintf(spath,"%s%s", "shaders/", shader->vertpath);
const char *vsrc = slurp_text(spath);
sprintf(spath, "%s%s", "shaders/", shader->fragpath);
const char *fsrc = slurp_text(spath);
GLuint vert = load_shader_from_file(shader->vertpath, GL_VERTEX_SHADER);
GLuint frag = load_shader_from_file(shader->fragpath, GL_FRAGMENT_SHADER);
shader->id = glCreateProgram();
glAttachShader(shader->id, vert);
glAttachShader(shader->id, frag);
glLinkProgram(shader->id);
shader_link_error(shader->id);
glDeleteShader(vert);
glDeleteShader(frag);
shader->shd = sg_make_shader(&(sg_shader_desc){
.vs.source = vsrc,
.fs.source = fsrc,
.label = shader->vertpath,
});
free(vsrc);
free(fsrc);
}
void shader_use(struct shader *shader)
{
glUseProgram(shader->id);
// glUseProgram(shader->id);
}
/*
void shader_setbool(struct shader *shader, const char *name, int val)
{
glUniform1i(glGetUniformLocation(shader->id, name), val);
@ -134,10 +143,6 @@ void shader_setvec2(struct shader *shader, const char *name, mfloat_t val[2])
glUniform2fv(glGetUniformLocation(shader->id, name), 1, val);
}
void shader_setvec3(struct shader *shader, const char *name, mfloat_t val[3])
{
glUniform3fv(glGetUniformLocation(shader->id, name), 1, val);
}
void shader_setvec4(struct shader *shader, const char *name, mfloat_t val[4])
{
@ -164,10 +169,18 @@ void shader_setUBO(struct shader *shader, const char *name, unsigned int index)
glUniformBlockBinding(shader->id, glGetUniformBlockIndex(shader->id, name), index);
}
*/
void shader_compile_all()
{
for (int i = 0; i < arrlen(shaders); i++)
shader_compile(&shaders[i]);
}
void shader_setvec3(struct shader *shader, const char *name, mfloat_t val[3])
{
// glUniform3fv(glGetUniformLocation(shader->id, name), 1, val);
}
void shader_setmat4(struct shader *shader, const char *name, mfloat_t val[16])
{
// glUniformMatrix4fv(glGetUniformLocation(shader->id, name), 1, GL_FALSE, val);
}

7
source/engine/shader.h
View file

@ -2,9 +2,10 @@
#define SHADER_H
#include "mathc.h"
#include "sokol/sokol_gfx.h"
struct shader {
unsigned int id;
sg_shader shd;
const char *vertpath;
const char *fragpath;
};
@ -13,7 +14,7 @@ void shader_compile_all();
struct shader *MakeShader(const char *vertpath, const char *fragpath);
void shader_compile(struct shader *shader);
void shader_use(struct shader *shader);
/*
void shader_setbool(struct shader *shader, const char *name, int val);
void shader_setint(struct shader *shader, const char *name, int val);
void shader_setfloat(struct shader *shader, const char *name, float val);
@ -26,5 +27,5 @@ void shader_setmat3(struct shader *shader, const char *name, mfloat_t val[9]);
void shader_setmat4(struct shader *shader, const char *name, mfloat_t val[16]);
void shader_setUBO(struct shader *shader, const char *name, unsigned int index);
*/
#endif

97
source/engine/sprite.c
View file

@ -19,6 +19,9 @@ static int first = -1;
static uint32_t VBO;
sg_pipeline pip_sprite;
sg_bindings bind_sprite;
int make_sprite(int go)
{
struct sprite sprite = {
@ -82,6 +85,9 @@ void sprite_io(struct sprite *sprite, FILE *f, int read)
void sprite_draw_all()
{
YughWarn("Applying sprite pipeline");
sg_apply_pipeline(pip_sprite);
static struct sprite **layers[5];
for (int i = 0; i < 5; i++)
@ -108,30 +114,58 @@ void sprite_settex(struct sprite *sprite, struct Texture *tex)
sprite_setframe(sprite, &ST_UNIT);
}
static uint32_t VAO = 0;
sg_shader shader_sprite;
void sprite_initialize()
{
glGenBuffers(1, &VBO);
glGenVertexArrays(1, &VAO);
shader_sprite = sg_make_shader(&(sg_shader_desc){
.vs.source = slurp_text("shaders/spritevert.glsl"),
.fs.source = slurp_text("shaders/spritefrag.glsl"),
.vs.uniform_blocks[0] = {
.size = 64,
.layout = SG_UNIFORMLAYOUT_STD140,
.uniforms = { [0] = { .name = "mpv", .type = SG_UNIFORMTYPE_MAT4 }}
},
glBindVertexArray(VAO);
.fs.images[0] = {
.name = "image",
.image_type = SG_IMAGETYPE_2D,
.sampler_type = SG_SAMPLERTYPE_FLOAT,
},
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, NULL);
glEnableVertexAttribArray(0);
.fs.uniform_blocks[0] = {
.size = 12,
.uniforms = { [0] = { .name = "spriteColor", .type = SG_UNIFORMTYPE_FLOAT3 }}
}
});
pip_sprite = sg_make_pipeline(&(sg_pipeline_desc){
.shader = shader_sprite,
.layout = {
.attrs = {
[0].format=SG_VERTEXFORMAT_FLOAT4
}
},
.primitive_type = SG_PRIMITIVETYPE_TRIANGLE_STRIP,
.label = "sprite pipeline"
});
bind_sprite.vertex_buffers[0] = sg_make_buffer(&(sg_buffer_desc){
.size = sizeof(float)*16,
.type = SG_BUFFERTYPE_VERTEXBUFFER,
.usage = SG_USAGE_STREAM,
.label = "sprite vertex buffer",
});
}
void tex_draw(struct Texture *tex, float pos[2], float angle, float size[2], float offset[2], struct glrect r, mfloat_t color[3]) {
mfloat_t model[16] = { 0.f };
void tex_draw(struct Texture *tex, float pos[2], float angle, float size[2], float offset[2], struct glrect r, float color[3]) {
float model[16] = { 0.f };
mfloat_t r_model[16] = { 0.f };
mfloat_t s_model[16] = { 0.f };
memcpy(model, UNITMAT4, sizeof(UNITMAT4));
memcpy(r_model, UNITMAT4, sizeof(UNITMAT4));
memcpy(s_model, UNITMAT4, sizeof(UNITMAT4));
mfloat_t t_scale[2] = { tex->width * st_s_w(r), tex->height * st_s_h(r) };
mfloat_t t_offset[2] = { offset[0] * t_scale[0] * size[0], offset[1] * t_scale[1] * size[1]};
mfloat_t t_scale[2] = { tex->width * st_s_w(r) * size[0], tex->height * st_s_h(r) * size[1] };
mfloat_t t_offset[2] = { offset[0] * t_scale[0] * size[0], offset[1] * t_scale[1] * size[1]};
mat4_translate_vec2(model, t_offset);
@ -141,27 +175,26 @@ void tex_draw(struct Texture *tex, float pos[2], float angle, float size[2], flo
mat4_multiply(model, r_model, model);
mat4_translate_vec2(model, pos);
shader_setmat4(spriteShader, "model", model);
shader_setvec3(spriteShader, "spriteColor", color);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, tex->id);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
mat4_multiply(model, projection,model);
float vertices[] = {
0.f, 0.f, r.s0, r.t1,
size[0], 0.f, r.s1, r.t1,
0.f, size[1], r.s0, r.t0,
size[0], size[1], r.s1, r.t0
1, 0.f, r.s1, r.t1,
0.f, 1, r.s0, r.t0,
1.f, 1.f, r.s1, r.t0
};
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STREAM_DRAW);
bind_sprite.fs_images[0] = tex->id;
sg_update_buffer(bind_sprite.vertex_buffers[0], SG_RANGE_REF(vertices));
sg_apply_bindings(&bind_sprite);
glBindVertexArray(VAO);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
sg_apply_uniforms(SG_SHADERSTAGE_VS, 0, SG_RANGE_REF(model));
float c[3];
for (int i = 0; i < 3; i++) c[i] = color[i];
sg_apply_uniforms(SG_SHADERSTAGE_FS, 0, SG_RANGE_REF(c));
glBindVertexArray(0);
sg_draw(0,4,1);
}
void sprite_draw(struct sprite *sprite)
@ -184,12 +217,12 @@ void sprite_setanim(struct sprite *sprite, struct TexAnim *anim, int frame)
}
void gui_draw_img(const char *img, float x, float y) {
shader_use(spriteShader);
sg_apply_pipeline(pip_sprite);
struct Texture *tex = texture_loadfromfile(img);
float pos[2] = {x, y};
float size[2] = {1.f, 1.f};
float offset[2] = { 0.f, 0.f };
float white[3] = {1.f,1.f,1.f};
float white[3] = {0.3f,1.f,1.f};
tex_draw(tex, pos, 0.f, size, offset, tex_get_rect(tex), white);
}
@ -209,7 +242,7 @@ void video_draw(struct datastream *stream, mfloat_t position[2], mfloat_t size[2
shader_setmat4(vid_shader, "model", model);
shader_setvec3(vid_shader, "spriteColor", color);
/*
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, stream->texture_y);
glActiveTexture(GL_TEXTURE1);
@ -219,4 +252,6 @@ void video_draw(struct datastream *stream, mfloat_t position[2], mfloat_t size[2
// TODO: video bind VAO
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
*/
}

110
source/engine/texture.c
View file

@ -7,7 +7,7 @@
#include "log.h"
#include <math.h>
#include "util.h"
#include "parson.h"
#include "sokol/sokol_gfx.h"
struct glrect ST_UNIT = { 0.f, 1.f, 0.f, 1.f };
@ -47,54 +47,32 @@ struct Texture *texture_pullfromfile(const char *path)
}
tex->data = data;
glGenTextures(1, &tex->id);
int filter;
if (tex->opts.sprite) {
if (tex->opts.mips)
filter = SG_FILTER_NEAREST_MIPMAP_NEAREST;
else
filter = SG_FILTER_NEAREST;
} else {
if (tex->opts.mips)
filter = SG_FILTER_LINEAR_MIPMAP_LINEAR;
else
filter = SG_FILTER_LINEAR;
}
glBindTexture(GL_TEXTURE_2D, tex->id);
GLenum fmt;
switch (n) {
case 1:
fmt = GL_RED;
break;
case 2:
fmt = GL_RG;
break;
case 3:
fmt = GL_RGB;
break;
case 4:
fmt = GL_RGBA;
break;
}
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, tex->width, tex->height, 0, fmt, GL_UNSIGNED_BYTE, data);
if (tex->opts.mips)
glGenerateMipmap(GL_TEXTURE_2D);
if (tex->opts.sprite) {
if (tex->opts.mips) {
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST_MIPMAP_NEAREST);
} else {
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
}
} else {
if (tex->opts.mips) {
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR);
} else {
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
}
}
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
tex->id = sg_make_image(&(sg_image_desc){
.type = SG_IMAGETYPE_2D,
.width = tex->width,
.height = tex->height,
.usage = SG_USAGE_IMMUTABLE,
.min_filter = filter,
.mag_filter = filter,
.data.subimage[0][0] = {
.ptr = data,
.size = tex->width*tex->height*4
}
});
if (shlen(texhash) == 0)
sh_new_arena(texhash);
@ -106,32 +84,7 @@ struct Texture *texture_pullfromfile(const char *path)
void texture_sync(const char *path)
{
struct Texture *tex = texture_pullfromfile(path);
glBindTexture(GL_TEXTURE_2D, tex->id);
if (tex->opts.mips)
glGenerateMipmap(GL_TEXTURE_2D);
if (tex->opts.sprite) {
if (tex->opts.mips) {
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST_MIPMAP_NEAREST);
} else {
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
}
} else {
if (tex->opts.mips) {
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR);
} else {
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
}
}
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
YughWarn("Need to implement texture sync.");
}
char *tex_get_path(struct Texture *tex) {
@ -148,7 +101,7 @@ char *tex_get_path(struct Texture *tex) {
struct Texture *texture_loadfromfile(const char *path)
{
struct Texture *new = texture_pullfromfile(path);
/*
if (new->id == 0) {
glGenTextures(1, &new->id);
@ -156,7 +109,7 @@ struct Texture *texture_loadfromfile(const char *path)
YughInfo("Loaded texture path %s", path);
}
*/
return new;
}
@ -230,10 +183,12 @@ void texanim_fromframes(struct TexAnim *anim, int frames)
void tex_gpu_free(struct Texture *tex)
{
/*
if (tex->id != 0) {
glDeleteTextures(1, &tex->id);
tex->id = 0;
}
*/
}
int anim_frames(struct TexAnim *a)
@ -257,9 +212,10 @@ cpVect tex_get_dimensions(struct Texture *tex)
void tex_bind(struct Texture *tex)
{
glActiveTexture(GL_TEXTURE0);
/* glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, tex->id);
glBindTexture(GL_TEXTURE_2D_ARRAY, tex->id);
*/
}
/********************** ANIM2D ****************/

4
source/engine/texture.h
View file

@ -3,6 +3,8 @@
#include "timer.h"
#include <chipmunk/chipmunk.h>
#include "sokol/sokol_gfx.h"
#define TEX_SPEC 0
#define TEX_NORM 1
@ -58,7 +60,7 @@ struct TextureOptions {
/* Represents an actual texture on the GPU */
struct Texture {
unsigned int id; /* ID reference for the GPU memory location of the texture */
sg_image id; /* ID reference for the GPU memory location of the texture */
int width;
int height;
unsigned char *data;

21
source/engine/window.c
View file

@ -79,6 +79,13 @@ struct window *MakeSDLWindow(const char *name, int width, int height, uint32_t f
GLFWwindow *sharewin = mainwin == NULL ? NULL : mainwin->window;
if (sharewin) return sharewin;
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR,3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR,3);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GLFW_TRUE);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
struct window w = {
.width = width,
.height = height,
@ -92,12 +99,12 @@ struct window *MakeSDLWindow(const char *name, int width, int height, uint32_t f
}
glfwMakeContextCurrent(w.window);
int version = gladLoadGL(glfwGetProcAddress);
if (!version) {
YughError("Failed to initialize OpenGL context.");
exit(1);
}
YughInfo("Loaded OpenGL %d.%d", GLAD_VERSION_MAJOR(version), GLAD_VERSION_MINOR(version));
// int version = gladLoadGL(glfwGetProcAddress);
// if (!version) {
// YughError("Failed to initialize OpenGL context.");
// exit(1);
// }
YughInfo("Loaded OpenGL %d.%d", 3,3);
glfwSwapInterval(1);
// Set callbacks
@ -107,7 +114,7 @@ struct window *MakeSDLWindow(const char *name, int width, int height, uint32_t f
glfwSetWindowFocusCallback(w.window, window_focus_callback);
glfwSetKeyCallback(w.window, win_key_callback);
nuke_init(&w);
// nuke_init(&w);
arrput(windows, w);

36
source/engine/yugine.c
View file

@ -1,11 +1,5 @@
#include "yugine.h"
#define SOKOL_IMPL
#define SOKOL_GLCORE33
#include "sokol/sokol_gfx.h"
#include "render.h"
#include "camera.h"
#include "window.h"
@ -37,6 +31,13 @@
#include "string.h"
#define SOKOL_TRACE_HOOKS
#define SOKOL_GFX_IMPL
#define SOKOL_GLCORE33
#include "sokol/sokol_gfx.h"
int physOn = 0;
double renderlag = 0;
@ -63,18 +64,7 @@ int fps;
#define SIM_PLAY 1
#define SIM_PAUSE 2
#define SIM_STEP 3
/*
int __builtin_clz(unsigned int a)
{
int to;
__asm__ __volatile__(
"bsr %edi, %eax\n\t"
"xor $31, %eax\n\t"
: "=&a"(to));
return to;
}
*/
void print_stacktrace()
{
void *ents[512];
@ -117,6 +107,11 @@ void compile_script(const char *file)
fclose(f);
}
void sg_logging(const char *tag, uint32_t lvl, uint32_t id, const char *msg, uint32_t line, const char *file, void *data)
{
mYughLog(0, 1, line, file, "tag: %s, msg: %s", tag, msg);
}
int main(int argc, char **args) {
int logout = 1;
ed = 1;
@ -202,6 +197,13 @@ int main(int argc, char **args) {
YughInfo("Refresh rate is %d", vidmode->refreshRate);
renderMS = 1.0/vidmode->refreshRate;
sg_setup(&(sg_desc){
.logger = {
.func = sg_logging,
.user_data = NULL,
},
});
input_init();
openglInit();

2
source/scripts/engine.js
View file

@ -1731,7 +1731,7 @@ var camera2d = gameobject.clone("camera2d", {
});
win_make(Game.title, Game.resolution[0], Game.resolution[1]);
win_icon("icon.png");
//win_icon("icon.png");
/* Default objects */
gameobject.clone("polygon2d", {

15
source/shaders/circlevert.glsl
View file

@ -2,18 +2,11 @@
layout (location = 0) in vec4 vertex;
out vec2 coords;
layout (std140) uniform Projection
{
mat4 projection;
};
layout (std140) uniform Resolution
{
vec2 resolution;
};
uniform mat4 proj;
uniform vec2 res;
void main()
{
gl_Position = projection * vec4(vertex.xy, 0.0, 1.0);
coords = vertex.zw;;
gl_Position = proj * vec4(vertex.xy, 0.0, 1.0);
coords = vertex.zw;
}

1
source/shaders/spritefrag.glsl
View file

@ -1,7 +1,6 @@
#version 330 core
in vec2 texcoords;
out vec4 color;
uniform sampler2D image;
uniform vec3 spriteColor;

11
source/shaders/spritevert.glsl
View file

@ -2,15 +2,10 @@
layout (location = 0) in vec4 vertex;
out vec2 texcoords;
layout (std140) uniform Projection
{
mat4 projection;
};
uniform mat4 model;
uniform mat4 mpv;
void main()
{
texcoords = vertex.zw;
gl_Position = projection * model * vec4(vertex.xy, 0.0, 1.0);
}
gl_Position = mpv * vec4(vertex.xy, 0.0, 1.0);
}

5
source/shaders/textvert.glsl
View file

@ -2,10 +2,7 @@
layout (location = 0) in vec4 vertex; // <vec2 pos, vec2 tex>
out vec2 TexCoords;
layout (std140) uniform Projection
{
mat4 projection;
};
uniform mat4 projection;
void main()
{