2021-11-30 21:29:18 -06:00
|
|
|
#include "sprite.h"
|
|
|
|
|
|
|
|
#include "gameobject.h"
|
2022-11-19 17:13:57 -06:00
|
|
|
#include "log.h"
|
2023-05-12 13:22:05 -05:00
|
|
|
#include "render.h"
|
|
|
|
#include "stb_ds.h"
|
|
|
|
#include "texture.h"
|
2023-11-09 16:44:33 -06:00
|
|
|
#include "HandmadeMath.h"
|
2021-11-30 21:29:18 -06:00
|
|
|
|
2023-09-15 03:37:07 -05:00
|
|
|
#include "sprite.sglsl.h"
|
|
|
|
#include "9slice.sglsl.h"
|
|
|
|
|
2024-03-13 03:51:44 -05:00
|
|
|
static sprite **sprites = NULL;
|
2021-11-30 21:29:18 -06:00
|
|
|
|
2023-06-05 10:32:45 -05:00
|
|
|
static sg_shader shader_sprite;
|
2023-05-12 13:22:05 -05:00
|
|
|
static sg_pipeline pip_sprite;
|
|
|
|
static sg_bindings bind_sprite;
|
|
|
|
|
2023-05-31 14:52:30 -05:00
|
|
|
struct sprite_vert {
|
|
|
|
HMM_Vec2 pos;
|
2023-06-06 15:49:55 -05:00
|
|
|
HMM_Vec2 uv;
|
2023-05-31 14:52:30 -05:00
|
|
|
struct rgba color;
|
2023-11-21 01:07:50 -06:00
|
|
|
struct rgba emissive;
|
2023-05-31 14:52:30 -05:00
|
|
|
};
|
|
|
|
|
2023-06-07 08:41:09 -05:00
|
|
|
static int num_spriteverts = 5000;
|
|
|
|
|
2023-06-05 10:32:45 -05:00
|
|
|
static sg_shader slice9_shader;
|
|
|
|
static sg_pipeline slice9_pipe;
|
|
|
|
static sg_bindings slice9_bind;
|
|
|
|
static float slice9_points[8] = {
|
|
|
|
0.0, 0.0,
|
|
|
|
0.0, 1.0,
|
|
|
|
1.0, 0.0,
|
|
|
|
1.0, 1.0
|
|
|
|
};
|
|
|
|
struct slice9_vert {
|
|
|
|
HMM_Vec2 pos;
|
|
|
|
struct uv_n uv;
|
|
|
|
unsigned short border[4];
|
|
|
|
HMM_Vec2 scale;
|
|
|
|
struct rgba color;
|
|
|
|
};
|
|
|
|
|
2024-03-13 03:51:44 -05:00
|
|
|
sprite *sprite_make()
|
|
|
|
{
|
|
|
|
sprite *sp = calloc(sizeof(*sp), 1);
|
|
|
|
sp->pos = (HMM_Vec2){0,0};
|
|
|
|
sp->scale = (HMM_Vec2){1,1};
|
|
|
|
sp->angle = 0;
|
|
|
|
sp->color = color_white;
|
|
|
|
sp->emissive = color_clear;
|
2023-12-11 16:59:59 -06:00
|
|
|
sp->go = NULL;
|
2024-03-21 21:07:24 -05:00
|
|
|
sp->tex = NULL;
|
2024-03-13 03:51:44 -05:00
|
|
|
sp->frame = ST_UNIT;
|
|
|
|
sp->drawmode = DRAW_SIMPLE;
|
|
|
|
sp->enabled = 1;
|
|
|
|
sp->parallax = 1;
|
|
|
|
|
|
|
|
arrpush(sprites,sp);
|
|
|
|
|
|
|
|
return sp;
|
2023-01-13 08:05:36 -06:00
|
|
|
}
|
|
|
|
|
2024-03-13 03:51:44 -05:00
|
|
|
void sprite_free(sprite *sprite)
|
|
|
|
{
|
|
|
|
free(sprite);
|
|
|
|
for (int i = arrlen(sprites)-1; i >= 0; i--)
|
|
|
|
if (sprites[i] == sprite) {
|
|
|
|
arrdelswap(sprites,i);
|
|
|
|
return;
|
|
|
|
}
|
2021-11-30 21:29:18 -06:00
|
|
|
}
|
|
|
|
|
2023-08-31 17:23:24 -05:00
|
|
|
static int sprite_count = 0;
|
2023-05-07 19:47:49 -05:00
|
|
|
|
2023-12-18 17:12:05 -06:00
|
|
|
void sprite_flush() { sprite_count = 0; }
|
2022-08-26 11:38:35 -05:00
|
|
|
|
2024-03-13 03:51:44 -05:00
|
|
|
int sprite_sort(sprite **sa, sprite **sb)
|
2023-11-21 01:07:50 -06:00
|
|
|
{
|
2024-03-13 03:51:44 -05:00
|
|
|
sprite *a = *sa;
|
|
|
|
sprite *b = *sb;
|
|
|
|
struct gameobject *goa = a->go;
|
|
|
|
struct gameobject *gob= b->go;
|
|
|
|
if (!goa && !gob) return 0;
|
|
|
|
if (!goa) return -1;
|
|
|
|
if (!gob) return 1;
|
2023-11-21 01:07:50 -06:00
|
|
|
if (goa->drawlayer > gob->drawlayer) return 1;
|
2024-04-03 00:44:08 -05:00
|
|
|
if (gob->drawlayer > goa->drawlayer) return -1;
|
|
|
|
if (*sa > *sb) return 1;
|
2023-11-21 01:07:50 -06:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
void sprite_draw_all() {
|
2024-03-13 03:51:44 -05:00
|
|
|
if (arrlen(sprites) == 0) return;
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
sg_apply_pipeline(pip_sprite);
|
2024-03-27 15:00:59 -05:00
|
|
|
sg_apply_uniforms(SG_SHADERSTAGE_VS, 0, SG_RANGE_REF(useproj));
|
2023-02-10 14:31:59 -06:00
|
|
|
|
2024-03-13 03:51:44 -05:00
|
|
|
qsort(sprites, arrlen(sprites), sizeof(*sprites), sprite_sort);
|
2024-03-27 15:00:59 -05:00
|
|
|
|
2024-04-02 07:41:46 -05:00
|
|
|
for (int i = 0; i < arrlen(sprites); i++) {
|
|
|
|
if (!sprites[i]->enabled) continue;
|
2024-03-13 03:51:44 -05:00
|
|
|
sprite_draw(sprites[i]);
|
2024-04-02 07:41:46 -05:00
|
|
|
}
|
2022-01-19 16:43:21 -06:00
|
|
|
}
|
2021-11-30 21:29:18 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
void sprite_initialize() {
|
2023-09-15 03:37:07 -05:00
|
|
|
shader_sprite = sg_make_shader(sprite_shader_desc(sg_query_backend()));
|
2023-05-04 17:07:00 -05:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
pip_sprite = sg_make_pipeline(&(sg_pipeline_desc){
|
2023-05-04 17:07:00 -05:00
|
|
|
.shader = shader_sprite,
|
|
|
|
.layout = {
|
2023-05-12 13:22:05 -05:00
|
|
|
.attrs = {
|
2023-05-31 14:52:30 -05:00
|
|
|
[0].format = SG_VERTEXFORMAT_FLOAT2,
|
2024-03-26 07:53:36 -05:00
|
|
|
[1].format = SG_VERTEXFORMAT_FLOAT2,
|
|
|
|
[2].format = SG_VERTEXFORMAT_UBYTE4N,
|
|
|
|
[3].format = SG_VERTEXFORMAT_UBYTE4N}},
|
2023-05-04 17:07:00 -05:00
|
|
|
.primitive_type = SG_PRIMITIVETYPE_TRIANGLE_STRIP,
|
2023-05-24 20:45:50 -05:00
|
|
|
.label = "sprite pipeline",
|
2023-11-21 01:07:50 -06:00
|
|
|
.colors[0].blend = blend_trans,
|
2023-05-24 20:45:50 -05:00
|
|
|
});
|
2023-05-04 17:07:00 -05:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
bind_sprite.vertex_buffers[0] = sg_make_buffer(&(sg_buffer_desc){
|
2023-06-07 08:41:09 -05:00
|
|
|
.size = sizeof(struct sprite_vert) * num_spriteverts,
|
2023-05-04 17:07:00 -05:00
|
|
|
.type = SG_BUFFERTYPE_VERTEXBUFFER,
|
|
|
|
.usage = SG_USAGE_STREAM,
|
|
|
|
.label = "sprite vertex buffer",
|
2023-05-12 13:22:05 -05:00
|
|
|
});
|
2023-09-15 03:37:07 -05:00
|
|
|
bind_sprite.fs.samplers[0] = sg_make_sampler(&(sg_sampler_desc){});
|
2023-06-05 10:32:45 -05:00
|
|
|
|
2023-09-15 03:37:07 -05:00
|
|
|
slice9_shader = sg_make_shader(slice9_shader_desc(sg_query_backend()));
|
2023-06-05 10:32:45 -05:00
|
|
|
|
|
|
|
slice9_pipe = sg_make_pipeline(&(sg_pipeline_desc){
|
|
|
|
.shader = slice9_shader,
|
|
|
|
.layout = {
|
|
|
|
.attrs = {
|
|
|
|
[0].format = SG_VERTEXFORMAT_FLOAT2,
|
2024-03-26 07:53:36 -05:00
|
|
|
[1].format = SG_VERTEXFORMAT_FLOAT2,
|
|
|
|
[2].format = SG_VERTEXFORMAT_USHORT4N,
|
|
|
|
[3].format = SG_VERTEXFORMAT_FLOAT2,
|
|
|
|
[4].format = SG_VERTEXFORMAT_UBYTE4N
|
2023-06-05 10:32:45 -05:00
|
|
|
}},
|
|
|
|
.primitive_type = SG_PRIMITIVETYPE_TRIANGLE_STRIP,
|
|
|
|
});
|
|
|
|
|
|
|
|
slice9_bind.vertex_buffers[0] = sg_make_buffer(&(sg_buffer_desc){
|
|
|
|
.size = sizeof(struct slice9_vert) * 100,
|
|
|
|
.type = SG_BUFFERTYPE_VERTEXBUFFER,
|
|
|
|
.usage = SG_USAGE_STREAM,
|
|
|
|
});
|
2022-12-29 11:27:41 -06:00
|
|
|
}
|
2021-11-30 21:29:18 -06:00
|
|
|
|
2024-03-13 03:51:44 -05:00
|
|
|
void tex_draw(struct texture *tex, HMM_Mat3 m, struct rect r, struct rgba color, int wrap, HMM_Vec2 wrapoffset, HMM_Vec2 wrapscale, struct rgba emissive, float parallax) {
|
2023-05-31 14:52:30 -05:00
|
|
|
struct sprite_vert verts[4];
|
2024-03-13 03:51:44 -05:00
|
|
|
float w = tex->width*r.w;
|
|
|
|
float h = tex->height*r.h;
|
2023-05-31 14:52:30 -05:00
|
|
|
|
|
|
|
HMM_Vec2 sposes[4] = {
|
2024-03-13 03:51:44 -05:00
|
|
|
{0,0},
|
|
|
|
{w,0},
|
|
|
|
{0,h},
|
2023-12-04 13:38:37 -06:00
|
|
|
{w,h}
|
2023-05-31 17:33:04 -05:00
|
|
|
};
|
2022-12-29 11:27:41 -06:00
|
|
|
|
2023-05-31 14:52:30 -05:00
|
|
|
for (int i = 0; i < 4; i++) {
|
2023-11-21 01:07:50 -06:00
|
|
|
verts[i].pos = mat_t_pos(m, sposes[i]);
|
2023-05-31 14:52:30 -05:00
|
|
|
verts[i].color = color;
|
2023-11-21 01:07:50 -06:00
|
|
|
verts[i].emissive = emissive;
|
2023-05-31 14:52:30 -05:00
|
|
|
}
|
2023-05-07 19:47:49 -05:00
|
|
|
|
2023-12-27 14:16:43 -06:00
|
|
|
if (wrap) {
|
2024-03-13 03:51:44 -05:00
|
|
|
r.w *= wrapscale.x;
|
|
|
|
r.h *= wrapscale.y;
|
2023-12-27 14:16:43 -06:00
|
|
|
}
|
|
|
|
|
2024-03-13 03:51:44 -05:00
|
|
|
verts[0].uv.X = r.x;
|
|
|
|
verts[0].uv.Y = r.y+r.h;
|
|
|
|
verts[1].uv.X = r.x+r.w;
|
|
|
|
verts[1].uv.Y = r.y+r.h;
|
|
|
|
verts[2].uv.X = r.x;
|
|
|
|
verts[2].uv.Y = r.y;
|
|
|
|
verts[3].uv.X = r.x+r.w;
|
|
|
|
verts[3].uv.Y = r.y;
|
2023-05-31 17:33:04 -05:00
|
|
|
|
2023-09-15 03:37:07 -05:00
|
|
|
bind_sprite.fs.images[0] = tex->id;
|
|
|
|
|
2023-05-31 14:52:30 -05:00
|
|
|
sg_append_buffer(bind_sprite.vertex_buffers[0], SG_RANGE_REF(verts));
|
2023-05-12 13:22:05 -05:00
|
|
|
sg_apply_bindings(&bind_sprite);
|
2022-12-29 17:44:19 -06:00
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
sg_draw(sprite_count * 4, 4, 1);
|
|
|
|
sprite_count++;
|
2022-12-24 13:18:06 -06:00
|
|
|
}
|
|
|
|
|
2024-03-13 03:51:44 -05:00
|
|
|
transform2d sprite2t(sprite *s)
|
|
|
|
{
|
|
|
|
return (transform2d){
|
|
|
|
.pos = s->pos,
|
|
|
|
.scale = s->scale,
|
|
|
|
.angle = s->angle
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2023-05-12 13:22:05 -05:00
|
|
|
void sprite_draw(struct sprite *sprite) {
|
2023-12-12 08:46:27 -06:00
|
|
|
if (!sprite->tex) return;
|
2024-03-13 03:51:44 -05:00
|
|
|
transform2d t;
|
|
|
|
if (!sprite->go) t = t2d_unit;
|
|
|
|
else t = go2t(sprite->go);
|
|
|
|
|
2024-03-20 16:48:03 -05:00
|
|
|
t.pos.x += (campos.x - (campos.x/sprite->parallax));
|
|
|
|
t.pos.y += (campos.y - (campos.y/sprite->parallax));
|
2024-01-01 07:44:43 -06:00
|
|
|
HMM_Mat3 m = transform2d2mat(t);
|
2024-03-13 03:51:44 -05:00
|
|
|
HMM_Mat3 sm = transform2d2mat(sprite2t(sprite));
|
|
|
|
tex_draw(sprite->tex, HMM_MulM3(m,sm), sprite->frame, sprite->color, sprite->drawmode, (HMM_Vec2){0,0}, sprite->scale, sprite->emissive, sprite->parallax);
|
2023-01-18 17:15:36 -06:00
|
|
|
}
|
|
|
|
|
2024-03-26 07:53:36 -05:00
|
|
|
void gui_draw_img(texture *tex, transform2d t, int wrap, HMM_Vec2 wrapoffset, float wrapscale, struct rgba color) {
|
2024-03-27 15:00:59 -05:00
|
|
|
sg_apply_pipeline(pip_sprite);
|
|
|
|
sg_apply_uniforms(SG_SHADERSTAGE_VS, 0, SG_RANGE_REF(useproj));
|
2024-03-04 11:15:55 -06:00
|
|
|
tex_draw(tex, transform2d2mat(t), ST_UNIT, color, wrap, wrapoffset, (HMM_Vec2){wrapscale,wrapscale}, (struct rgba){0,0,0,0}, 0);
|
2022-12-24 13:18:06 -06:00
|
|
|
}
|
2024-03-27 15:00:59 -05:00
|
|
|
|
|
|
|
void slice9_draw(texture *tex, transform2d *t, HMM_Vec4 border, struct rgba color)
|
|
|
|
{
|
|
|
|
|
|
|
|
}
|