prosperon/source/engine/render.c

407 lines
9.6 KiB
C
Raw Normal View History

#include "render.h"
2021-11-30 21:29:18 -06:00
2023-05-12 13:22:05 -05:00
#include "config.h"
#include "datastream.h"
2021-11-30 21:29:18 -06:00
#include "debugdraw.h"
2023-05-12 13:22:05 -05:00
#include "font.h"
#include "gameobject.h"
2021-11-30 21:29:18 -06:00
#include "log.h"
2023-05-12 13:22:05 -05:00
#include "sprite.h"
2023-12-29 19:08:53 -06:00
#include "particle.h"
2023-05-12 13:22:05 -05:00
#include "window.h"
#include "model.h"
#include "stb_ds.h"
#include "resources.h"
2023-09-12 00:02:57 -05:00
#include "yugine.h"
#include "sokol/sokol_app.h"
2024-03-03 16:49:34 -06:00
#define SOKOL_GLUE_IMPL
#include "sokol/sokol_glue.h"
2023-11-22 03:51:43 -06:00
#include "stb_image_write.h"
2023-05-12 13:22:05 -05:00
#include "box.sglsl.h"
#include "shadow.sglsl.h"
2023-09-11 15:07:36 -05:00
#include "sokol/sokol_gfx.h"
2024-03-03 16:49:34 -06:00
#include "sokol_gfx_ext.h"
2023-09-12 00:02:57 -05:00
2024-04-01 08:13:57 -05:00
#include "crt.sglsl.h"
2023-09-11 15:07:36 -05:00
#include "msf_gif.h"
2024-03-20 16:48:03 -05:00
HMM_Vec2 campos = {0,0};
float camzoom = 1;
2023-09-12 00:02:57 -05:00
static struct {
2024-03-03 16:49:34 -06:00
sg_swapchain swap;
2023-09-12 00:02:57 -05:00
sg_pipeline pipe;
sg_bindings bind;
sg_shader shader;
sg_image img;
sg_image depth;
} sg_gif;
2024-04-01 08:13:57 -05:00
static struct {
sg_pipeline pipe;
sg_bindings bind;
sg_shader shader;
} sg_crt;
2023-09-12 07:56:40 -05:00
static struct {
int w;
int h;
int cpf;
int depth;
double timer;
double spf;
int rec;
uint8_t *buffer;
2023-09-12 07:56:40 -05:00
} gif;
2023-09-11 15:07:36 -05:00
MsfGifState gif_state = {};
2023-09-12 00:02:57 -05:00
void gif_rec_start(int w, int h, int cpf, int bitdepth)
2023-09-11 15:07:36 -05:00
{
2023-09-12 07:56:40 -05:00
gif.w = w;
gif.h = h;
gif.depth = bitdepth;
msf_gif_begin(&gif_state, gif.w, gif.h);
gif.cpf = cpf;
gif.spf = cpf/100.0;
gif.rec = 1;
gif.timer = apptime();
2023-09-12 07:56:40 -05:00
if (gif.buffer) free(gif.buffer);
gif.buffer = malloc(gif.w*gif.h*4);
2023-09-12 00:02:57 -05:00
sg_destroy_image(sg_gif.img);
sg_destroy_image(sg_gif.depth);
sg_gif.img = sg_make_image(&(sg_image_desc){
.render_target = true,
2023-09-12 07:56:40 -05:00
.width = gif.w,
.height = gif.h,
.pixel_format = SG_PIXELFORMAT_RGBA8,
2023-09-25 08:21:02 -05:00
.label = "gif rt",
2023-09-12 00:02:57 -05:00
});
sg_gif.depth = sg_make_image(&(sg_image_desc){
.render_target = true,
2023-09-12 07:56:40 -05:00
.width = gif.w,
.height = gif.h,
2023-09-25 08:21:02 -05:00
.label = "gif depth",
2023-09-12 00:02:57 -05:00
});
2024-03-03 16:49:34 -06:00
sg_gif.swap = sglue_swapchain();
2023-09-11 15:07:36 -05:00
}
void gif_rec_end(const char *path)
2023-09-11 15:07:36 -05:00
{
if (!gif.rec) return;
2023-09-12 07:56:40 -05:00
MsfGifResult gif_res = msf_gif_end(&gif_state);
if (gif_res.data) {
2023-09-11 15:07:36 -05:00
FILE *f = fopen(path, "wb");
2023-09-12 07:56:40 -05:00
fwrite(gif_res.data, gif_res.dataSize, 1, f);
2023-09-11 15:07:36 -05:00
fclose(f);
}
2023-09-12 07:56:40 -05:00
msf_gif_free(gif_res);
gif.rec = 0;
2023-09-11 15:07:36 -05:00
}
void capture_screen(int x, int y, int w, int h, const char *path)
2023-11-22 03:51:43 -06:00
{
int n = 4;
void *data = malloc(w*h*n);
sg_query_pixels(0,0,w,h,1,data,w*h*sizeof(char)*n);
// sg_query_image_pixels(crt_post.img, crt_post.bind.fs.samplers[0], data, w*h*4);
stbi_write_png("cap.png", w, h, n, data, n*w);
// stbi_write_bmp("cap.bmp", w, h, n, data);
free(data);
}
#include "sokol/sokol_app.h"
2023-05-12 13:22:05 -05:00
#include "HandmadeMath.h"
2022-12-22 16:58:06 -06:00
2023-05-24 20:45:50 -05:00
struct rgba editorClearColor = {35,60,92,255};
2021-11-30 21:29:18 -06:00
2023-05-04 17:07:00 -05:00
sg_pass_action pass_action = {0};
2023-05-12 13:22:05 -05:00
static struct {
sg_pass_action pass_action;
2024-04-03 00:44:08 -05:00
2023-05-12 13:22:05 -05:00
sg_pass pass;
sg_pipeline pipe;
sg_shader shader;
} sg_shadow;
void trace_apply_pipeline(sg_pipeline pip, void *data)
{
// YughSpam("Applying pipeline %u %s.", pip, sg_query_pipeline_desc(pip).label);
}
2024-04-09 16:48:15 -05:00
void trace_begin_pass(sg_pass pass, const sg_pass_action *action, void *data)
{
2024-04-09 16:48:15 -05:00
// YughSpam("Begin pass %s", pass.label);
}
2024-04-09 16:48:15 -05:00
#define SG_TRACE_SET(NAME) \
void trace_alloc_##NAME (sg_##NAME id, void *data) \
{ \
sg_##NAME##_desc desc = sg_query_##NAME##_desc(id); \
YughSpam("Alloc " #NAME " %d [%s]", id, desc.label); \
} \
\
void trace_dealloc_##NAME(sg_##NAME id, void *data) \
{ \
sg_##NAME##_desc desc = sg_query_##NAME##_desc(id); \
YughSpam("Dealloc " #NAME " %d [%s]", id, desc.label); \
} \
\
void trace_make_##NAME(sg_##NAME##_desc *desc, void *data) \
{ \
YughSpam("Make " #NAME " [%s]", desc->label); \
} \
\
void trace_destroy_##NAME(sg_##NAME id, void *data) \
{ \
sg_##NAME##_desc desc = sg_query_##NAME##_desc(id); \
YughSpam("Destroy " #NAME " %d [%s]", id, desc.label); \
} \
\
void trace_init_##NAME(sg_##NAME id, sg_##NAME##_desc *desc, void *data) \
{ \
YughSpam("Init " #NAME " %d [%s]", id, desc->label); \
} \
\
void trace_uninit_##NAME(sg_##NAME id, void *data) \
{ \
sg_##NAME##_desc desc = sg_query_##NAME##_desc(id); \
YughSpam("Init " #NAME " %d [%s]", id, desc.label); \
} \
\
void trace_fail_##NAME(sg_##NAME id, void *data) \
{ \
sg_##NAME##_desc desc = sg_query_##NAME##_desc(id); \
YughError("Failed " #NAME " %d: %s", id, desc.label); \
} \
SG_TRACE_SET(buffer)
SG_TRACE_SET(image)
SG_TRACE_SET(sampler)
SG_TRACE_SET(shader)
SG_TRACE_SET(pipeline)
SG_TRACE_SET(attachments)
#define SG_HOOK_SET(NAME) \
.alloc_##NAME = trace_alloc_##NAME, \
.dealloc_##NAME = trace_dealloc_##NAME, \
.init_##NAME = trace_init_##NAME, \
.uninit_##NAME = trace_uninit_##NAME, \
.fail_##NAME = trace_fail_##NAME, \
.destroy_##NAME = trace_destroy_##NAME, \
.make_##NAME = trace_make_##NAME \
void trace_append_buffer(sg_buffer id, sg_range *data, void *user)
{
2024-04-09 16:48:15 -05:00
sg_buffer_desc desc = sg_query_buffer_desc(id);
YughSpam("Appending buffer %d [%s]", id, desc.label);
2023-09-25 08:21:02 -05:00
}
2023-05-24 20:45:50 -05:00
static sg_trace_hooks hooks = {
.apply_pipeline = trace_apply_pipeline,
.begin_pass = trace_begin_pass,
2024-04-09 16:48:15 -05:00
SG_HOOK_SET(buffer),
SG_HOOK_SET(image),
SG_HOOK_SET(shader),
SG_HOOK_SET(sampler),
SG_HOOK_SET(pipeline),
SG_HOOK_SET(attachments),
.append_buffer = trace_append_buffer
2023-05-24 20:45:50 -05:00
};
void render_init() {
2024-03-13 16:30:55 -05:00
mainwin.size = (HMM_Vec2){sapp_width(), sapp_height()};
sg_setup(&(sg_desc){
2024-03-03 16:49:34 -06:00
.environment = sglue_environment(),
.logger = { .func = sg_logging },
.buffer_pool_size = 1024
});
2023-05-24 20:45:50 -05:00
sg_trace_hooks hh = sg_install_trace_hooks(&hooks);
font_init();
2023-05-12 13:22:05 -05:00
debugdraw_init();
sprite_initialize();
model_init();
2023-05-24 20:45:50 -05:00
sg_color c;
rgba2floats((float*)&c, editorClearColor);
2024-03-03 16:49:34 -06:00
2023-05-12 13:22:05 -05:00
pass_action = (sg_pass_action){
2024-03-03 16:49:34 -06:00
.colors[0] = {.load_action = SG_LOADACTION_CLEAR, .clear_value = c},
2023-05-12 13:22:05 -05:00
};
2024-04-01 08:13:57 -05:00
sg_gif.shader = sg_make_shader(box_shader_desc(sg_query_backend()));
2023-09-12 00:02:57 -05:00
sg_gif.pipe = sg_make_pipeline(&(sg_pipeline_desc){
.shader = sg_gif.shader,
.layout = {
.attrs = {
[0].format = SG_VERTEXFORMAT_FLOAT2,
2024-04-01 08:13:57 -05:00
[1].format = SG_VERTEXFORMAT_FLOAT2
2023-09-12 00:02:57 -05:00
}
},
.colors[0].pixel_format = SG_PIXELFORMAT_RGBA8,
.label = "gif pipe",
2023-09-12 00:02:57 -05:00
});
2023-05-12 13:22:05 -05:00
float crt_quad[] = {
-1, 1, 0, 1,
-1, -1, 0, 0,
1, -1, 1, 0,
-1, 1, 0, 1,
1, -1, 1, 0,
1, 1, 1, 1
};
2024-04-01 08:13:57 -05:00
float gif_quad[] = {
-1, 1, 0, 1,
-1, -1, 0, 0,
1, -1, 1, 0,
-1, 1, 0, 1,
1, -1, 1, 0,
1, 1, 1, 1
};
sg_gif.bind.vertex_buffers[0] = sg_make_buffer(&(sg_buffer_desc){
.size = sizeof(gif_quad),
.data = gif_quad,
2024-04-09 16:48:15 -05:00
.label = "gif vert buffer",
});
sg_gif.bind.fs.samplers[0] = sg_make_sampler(&(sg_sampler_desc){});
2024-04-01 08:13:57 -05:00
sg_crt.shader = sg_make_shader(crt_shader_desc(sg_query_backend()));
sg_crt.pipe = sg_make_pipeline(&(sg_pipeline_desc){
.shader = sg_crt.shader,
.layout = {
.attrs = {
[0].format = SG_VERTEXFORMAT_FLOAT2,
[1].format = SG_VERTEXFORMAT_FLOAT2
}
},
.primitive_type = SG_PRIMITIVETYPE_TRIANGLE_STRIP,
});
sg_crt.bind.vertex_buffers[0] = sg_make_buffer(&(sg_buffer_desc){
.size = sizeof(crt_quad),
.type = SG_BUFFERTYPE_VERTEXBUFFER,
2024-04-09 16:48:15 -05:00
.usage = SG_USAGE_IMMUTABLE,
2024-04-10 16:21:46 -05:00
.data = SG_RANGE(crt_quad),
2024-04-09 16:48:15 -05:00
.label = "crt vert buffer",
2024-04-01 08:13:57 -05:00
});
2023-05-24 20:45:50 -05:00
}
HMM_Mat4 projection = {0.f};
HMM_Mat4 hudproj = {0.f};
2024-03-27 15:00:59 -05:00
HMM_Mat4 useproj = {0};
2023-05-04 17:07:00 -05:00
2023-05-12 13:22:05 -05:00
HMM_Vec3 dirl_pos = {4, 100, 20};
2022-06-30 10:31:23 -05:00
#define MODE_STRETCH 0
#define MODE_KEEP 1
#define MODE_WIDTH 2
#define MODE_HEIGHT 3
#define MODE_EXPAND 4
#define MODE_FULL 5
2024-03-20 16:48:03 -05:00
void openglRender(struct window *window, gameobject *cam, float zoom) {
2024-03-18 14:27:52 -05:00
sg_swapchain sch = sglue_swapchain();
sg_begin_pass(&(sg_pass){
.action = pass_action,
.swapchain = sglue_swapchain(),
.label = "window pass"
});
2024-03-13 16:30:55 -05:00
HMM_Vec2 usesize = window->rendersize;
switch(window->mode) {
case MODE_STRETCH:
2024-03-13 16:30:55 -05:00
sg_apply_viewportf(0,0,window->size.x,window->size.y,1);
break;
case MODE_WIDTH:
2024-03-13 16:30:55 -05:00
sg_apply_viewportf(0, window->top, window->size.x, window->psize.y,1); // keep width
break;
case MODE_HEIGHT:
2024-03-13 16:30:55 -05:00
sg_apply_viewportf(window->left,0,window->psize.x, window->size.y,1); // keep height
break;
case MODE_KEEP:
2024-03-13 16:30:55 -05:00
sg_apply_viewportf(0,0,window->rendersize.x, window->rendersize.y, 1); // no scaling
break;
case MODE_EXPAND:
2024-03-13 16:30:55 -05:00
if (window->aspect < window->raspect)
sg_apply_viewportf(0, window->top, window->size.x, window->psize.y,1); // keep width
else
2024-03-13 16:30:55 -05:00
sg_apply_viewportf(window->left,0,window->psize.x, window->size.y,1); // keep height
break;
case MODE_FULL:
2024-03-13 16:30:55 -05:00
usesize = window->size;
2024-03-09 18:22:06 -06:00
break;
}
// 2D projection
2024-03-20 16:48:03 -05:00
campos = go_pos(cam);
camzoom = zoom;
2023-05-12 13:22:05 -05:00
2023-12-04 13:38:37 -06:00
projection = HMM_Orthographic_LH_NO(
2024-03-20 16:48:03 -05:00
campos.x - camzoom * usesize.x / 2,
campos.x + camzoom * usesize.x / 2,
campos.y - camzoom * usesize.y / 2,
campos.y + camzoom * usesize.y / 2, -10000.f, 10000.f);
2024-03-13 16:30:55 -05:00
hudproj = HMM_Orthographic_LH_ZO(0, usesize.x, 0, usesize.y, -1.f, 1.f);
2023-05-12 13:22:05 -05:00
2024-03-03 16:49:34 -06:00
/* if (gif.rec && (apptime() - gif.timer) > gif.spf) {
sg_begin_pass(&(sg_pass){
.action = pass_action,
.swapchain = sg_gif.swap
});
2023-09-12 00:02:57 -05:00
sg_apply_pipeline(sg_gif.pipe);
sg_apply_bindings(&sg_gif.bind);
2023-09-12 00:02:57 -05:00
sg_draw(0,6,1);
sg_end_pass();
gif.timer = apptime();
sg_query_image_pixels(sg_gif.img, crt_post.bind.fs.samplers[0], gif.buffer, gif.w*gif.h*4);
2023-09-12 07:56:40 -05:00
msf_gif_frame(&gif_state, gif.buffer, gif.cpf, gif.depth, gif.w * -4);
2023-09-12 00:02:57 -05:00
}
2024-03-03 16:49:34 -06:00
*/
2021-11-30 21:29:18 -06:00
}
2023-05-24 20:45:50 -05:00
struct boundingbox cwh2bb(HMM_Vec2 c, HMM_Vec2 wh) {
struct boundingbox bb = {
.t = c.Y + wh.Y/2,
.b = c.Y - wh.Y/2,
.r = c.X + wh.X/2,
.l = c.X - wh.X/2
};
return bb;
}
float *rgba2floats(float *r, struct rgba c)
{
r[0] = (float)c.r / RGBA_MAX;
r[1] = (float)c.g / RGBA_MAX;
r[2] = (float)c.b / RGBA_MAX;
r[3] = (float)c.a / RGBA_MAX;
return r;
}
sg_blend_state blend_trans = {
.enabled = true,
.src_factor_rgb = SG_BLENDFACTOR_SRC_ALPHA,
.dst_factor_rgb = SG_BLENDFACTOR_ONE_MINUS_SRC_ALPHA,
.src_factor_alpha = SG_BLENDFACTOR_SRC_ALPHA,
.dst_factor_alpha = SG_BLENDFACTOR_ONE_MINUS_SRC_ALPHA
};