taisei/src/stagedraw.c

/*
 * This software is licensed under the terms of the MIT License.
 * See COPYING for further information.
 * ---
 * Copyright (c) 2011-2024, Lukas Weber <laochailan@web.de>.
 * Copyright (c) 2012-2024, Andrei Alexeyev <akari@taisei-project.org>.
 */

#include "stagedraw.h"

#include "entity.h"
#include "events.h"
#include "global.h"
#include "replay/struct.h"
#include "resource/postprocess.h"
#include "stageobjects.h"
#include "stagetext.h"
#include "util/env.h"
#include "util/fbmgr.h"
#include "util/graphics.h"
#include "video.h"

#ifdef DEBUG
	#define GRAPHS_DEFAULT 1
	#define OBJPOOLSTATS_DEFAULT 0
#else
	#define GRAPHS_DEFAULT 0
	#define OBJPOOLSTATS_DEFAULT 0
#endif

#define SPELL_INTRO_DURATION 120
#define SPELL_INTRO_TIME_FACTOR 0.8

static struct {
	struct {
		ShaderProgram *shader;
		Font *font;

		struct {
			Color active;
			Color inactive;
			Color dark;
			Color label;
			Color label_power;
			Color label_value;
			Color label_graze;
			Color label_voltage;
		} color;
	} hud_text;

	struct {
		ShaderProgram *fxaa;
	} shaders;

	PostprocessShader *viewport_pp;
	FBPair fb_pairs[NUM_FBPAIRS];
	FBPair powersurge_fbpair;
	FBPair *current_postprocess_fbpair;

	ManagedFramebufferGroup *mfb_group;
	StageDrawEvents events;

	struct {
		float alpha;
		float target_alpha;
	} clear_screen;

	bool framerate_graphs;
	bool objpool_stats;

	#ifdef DEBUG
		Sprite dummy;
	#endif
} stagedraw = {
	.hud_text.color = {
		// NOTE: premultiplied alpha
		.active        = { 1.00, 1.00, 1.00, 1.00 },
		.inactive      = { 0.50, 0.50, 0.50, 0.70 },
		.dark          = { 0.30, 0.30, 0.30, 0.70 },
		.label         = { 1.00, 1.00, 1.00, 1.00 },
		.label_power   = { 1.00, 0.50, 0.50, 1.00 },
		.label_value   = { 0.30, 0.60, 1.00, 1.00 },
		.label_graze   = { 0.50, 1.00, 0.50, 1.00 },
		.label_voltage = { 0.80, 0.50, 1.00, 1.00 },
	}
};

bool stage_draw_is_initialized(void) {
	return stagedraw.mfb_group;
}

static double fb_scale(void) {
	float vp_width, vp_height;
	video_get_viewport_size(&vp_width, &vp_height);
	return (double)vp_height / SCREEN_H;
}

static void set_fb_size(StageFBPair fb_id, int *w, int *h, float scale_worst, float scale_best) {
	double scale = fb_scale();

	if(fb_id == FBPAIR_FG_AUX || fb_id == FBPAIR_BG_AUX) {
		scale_worst *= 0.5;
	}

	int pp_qual = config_get_int(CONFIG_POSTPROCESS);

	// We might lerp between these in the future
	if(pp_qual < 2) {
		scale *= scale_worst;
	} else {
		scale *= scale_best;
	}

	log_debug("%u %f %f %f %i", fb_id, scale, scale_worst, scale_best, pp_qual);

	switch(fb_id) {
		case FBPAIR_BG:
			scale *= config_get_float(CONFIG_BG_QUALITY);
			// fallthrough

		default:
			scale *= config_get_float(CONFIG_FG_QUALITY);
			break;
	}

	scale = max(0.1, scale);
	*w = round(VIEWPORT_W * scale);
	*h = round(VIEWPORT_H * scale);
}

typedef struct StageFramebufferResizeParams {
	struct { float worst, best; } scale;
	StageFBPair scaling_base;
	int refs;
} StageFramebufferResizeParams;

static void stage_framebuffer_resize_strategy(void *userdata, IntExtent *out_dimensions, FloatRect *out_viewport) {
	StageFramebufferResizeParams *rp = userdata;
	set_fb_size(rp->scaling_base, &out_dimensions->w, &out_dimensions->h, rp->scale.worst, rp->scale.best);
	*out_viewport = (FloatRect) { 0, 0, out_dimensions->w, out_dimensions->h };
}

static void stage_framebuffer_resize_strategy_cleanup(void *userdata) {
	StageFramebufferResizeParams *rp = userdata;
	if(--rp->refs <= 0) {
		mem_free(rp);
	}
}

static bool stage_draw_event(SDL_Event *e, void *arg) {
	if(!IS_TAISEI_EVENT(e->type)) {
		return false;
	}

	switch(TAISEI_EVENT(e->type)) {
		case TE_FRAME: {
			fapproach_p(&stagedraw.clear_screen.alpha, stagedraw.clear_screen.target_alpha, 0.01);
			break;
		}
	}

	return false;
}

static void stage_draw_fbpair_create(
	FBPair *pair,
	int num_attachments,
	FBAttachmentConfig *attachments,
	const StageFramebufferResizeParams *resize_params,
	const char *name
) {
	StageFramebufferResizeParams *rp = memdup(resize_params, sizeof(*resize_params));
	rp->refs = 2;

	FramebufferConfig fbconf = { 0 };
	fbconf.attachments = attachments;
	fbconf.num_attachments = num_attachments;
	fbconf.resize_strategy.resize_func = stage_framebuffer_resize_strategy;
	fbconf.resize_strategy.userdata = rp;
	fbconf.resize_strategy.cleanup_func = stage_framebuffer_resize_strategy_cleanup;
	fbmgr_group_fbpair_create(stagedraw.mfb_group, name, &fbconf, pair);
}

static void stage_draw_setup_framebuffers(void) {
	FBAttachmentConfig a[2], *a_color, *a_depth;
	memset(a, 0, sizeof(a));

	a_color = &a[0];
	a_depth = &a[1];

	a_color->attachment = FRAMEBUFFER_ATTACH_COLOR0;
	a_depth->attachment = FRAMEBUFFER_ATTACH_DEPTH;

	StageFramebufferResizeParams rp_fg =     { .scaling_base = FBPAIR_FG,     .scale.best = 1, .scale.worst = 1 };
	StageFramebufferResizeParams rp_fg_aux = { .scaling_base = FBPAIR_FG_AUX, .scale.best = 1, .scale.worst = 1 };
	StageFramebufferResizeParams rp_bg =     { .scaling_base = FBPAIR_BG,     .scale.best = 1, .scale.worst = 1 };
	StageFramebufferResizeParams rp_bg_aux = { .scaling_base = FBPAIR_BG_AUX, .scale.best = 1, .scale.worst = 1 };

	// Set up some parameters shared by all attachments
	TextureParams tex_common = {
		.filter.min = TEX_FILTER_LINEAR,
		.filter.mag = TEX_FILTER_LINEAR,
		.wrap.s = TEX_WRAP_MIRROR,
		.wrap.t = TEX_WRAP_MIRROR,
	};

	memcpy(&a_color->tex_params, &tex_common, sizeof(tex_common));
	memcpy(&a_depth->tex_params, &tex_common, sizeof(tex_common));

	a_depth->tex_params.type = TEX_TYPE_DEPTH;

	// Foreground: 1 RGB texture per FB
	a_color->tex_params.type = TEX_TYPE_RGB_16;
	stage_draw_fbpair_create(stagedraw.fb_pairs + FBPAIR_FG, 1, a, &rp_fg, "Stage FG");

	// Foreground auxiliary: 1 RGBA texture per FB
	a_color->tex_params.type = TEX_TYPE_RGBA_8;
	stage_draw_fbpair_create(stagedraw.fb_pairs + FBPAIR_FG_AUX, 1, a, &rp_fg_aux, "Stage FG AUX");

	// Background: 1 HDR RGBA texture + depth per FB
	a_color->tex_params.type = TEX_TYPE_RGBA_16_FLOAT;
	stage_draw_fbpair_create(stagedraw.fb_pairs + FBPAIR_BG, 2, a, &rp_bg, "Stage BG");

	// Background auxiliary: 1 RGBA texture per FB
	a_color->tex_params.type = TEX_TYPE_RGBA_8;
	stage_draw_fbpair_create(stagedraw.fb_pairs + FBPAIR_BG_AUX, 1, a, &rp_bg_aux, "Stage BG AUX");

	// CAUTION: should be at least 16-bit, lest the feedback shader do an oopsie!
	a_color->tex_params.type = TEX_TYPE_RGBA_16;
	stagedraw.powersurge_fbpair.front = stage_add_background_framebuffer("Powersurge effect FB 1", 0.125, 0.25, 1, a);
	stagedraw.powersurge_fbpair.back  = stage_add_background_framebuffer("Powersurge effect FB 2", 0.125, 0.25, 1, a);
}

static Framebuffer *add_custom_framebuffer(
	const char *label,
	StageFBPair fbtype,
	float scale_worst,
	float scale_best,
	uint num_attachments,
	FBAttachmentConfig attachments[num_attachments]
) {
	StageFramebufferResizeParams rp = { 0 };
	rp.scaling_base = fbtype;
	rp.scale.worst = scale_worst;
	rp.scale.best = scale_best;

	FramebufferConfig fbconf = { 0 };
	fbconf.attachments = attachments;
	fbconf.num_attachments = num_attachments;
	fbconf.resize_strategy.resize_func = stage_framebuffer_resize_strategy;
	fbconf.resize_strategy.userdata = memdup(&rp, sizeof(rp));
	fbconf.resize_strategy.cleanup_func = stage_framebuffer_resize_strategy_cleanup;
	return fbmgr_group_framebuffer_create(stagedraw.mfb_group, label, &fbconf);
}

Framebuffer *stage_add_foreground_framebuffer(const char *label, float scale_worst, float scale_best, uint num_attachments, FBAttachmentConfig attachments[num_attachments]) {
	return add_custom_framebuffer(label, FBPAIR_FG, scale_worst, scale_best, num_attachments, attachments);
}

Framebuffer *stage_add_background_framebuffer(const char *label, float scale_worst, float scale_best, uint num_attachments, FBAttachmentConfig attachments[num_attachments]) {
	return add_custom_framebuffer(label, FBPAIR_BG, scale_worst, scale_best, num_attachments, attachments);
}

Framebuffer *stage_add_static_framebuffer(const char *label, uint num_attachments, FBAttachmentConfig attachments[num_attachments]) {
	FramebufferConfig fbconf = { 0 };
	fbconf.attachments = attachments;
	fbconf.num_attachments = num_attachments;
	return fbmgr_group_framebuffer_create(stagedraw.mfb_group, label, &fbconf);
}

static void stage_draw_destroy_framebuffers(void) {
	fbmgr_group_destroy(stagedraw.mfb_group);
	stagedraw.mfb_group = NULL;
}

void stage_draw_preload(ResourceGroup *rg) {
	res_group_preload(rg, RES_POSTPROCESS, RESF_OPTIONAL,
		"viewport",
	NULL);

	res_group_preload(rg, RES_SPRITE, RESF_DEFAULT,
		"hud/heart",
		"hud/star",
		"star",
	NULL);

	res_group_preload(rg, RES_TEXTURE, RESF_DEFAULT,
		"powersurge_flow",
		"titletransition",
		"hud",
	NULL);

	res_group_preload(rg, RES_MODEL, RESF_DEFAULT,
		"hud",
	NULL);

	res_group_preload(rg, RES_SHADER_PROGRAM, RESF_DEFAULT,
		"ingame_menu",
		"powersurge_effect",
		"powersurge_feedback",
		"sprite_circleclipped_indicator",
		"text_hud",
		"text_stagetext",

		// TODO: Maybe don't preload this if FXAA is disabled.
		// But then we also have to handle the edge case of it being enabled later mid-game.
		"fxaa",

		#ifdef DEBUG
		"sprite_filled_circle",
		#endif
	NULL);

	res_group_preload(rg, RES_FONT, RESF_DEFAULT,
		"mono",
		"small",
		"monosmall",
	NULL);

	if(stage_is_demo_mode()) {
		res_group_preload(rg, RES_SHADER_PROGRAM, RESF_DEFAULT,
			"text_demo",
		NULL);
	}

	stagedraw.framerate_graphs = env_get("TAISEI_FRAMERATE_GRAPHS", GRAPHS_DEFAULT);
	stagedraw.objpool_stats = env_get("TAISEI_OBJPOOL_STATS", OBJPOOLSTATS_DEFAULT);

	if(stagedraw.framerate_graphs) {
		res_group_preload(rg, RES_SHADER_PROGRAM, RESF_DEFAULT,
			"graph",
		NULL);
	}

	if(stagedraw.objpool_stats) {
		res_group_preload(rg, RES_FONT, RESF_DEFAULT,
			"monotiny",
		NULL);
	}
}

void stage_draw_init(void) {
	stagedraw.mfb_group = fbmgr_group_create();

	stagedraw.viewport_pp = res_get_data(RES_POSTPROCESS, "viewport", RESF_OPTIONAL);
	stagedraw.hud_text.shader = res_shader("text_hud");
	stagedraw.hud_text.font = res_font("standard");
	stagedraw.shaders.fxaa = res_shader("fxaa");

	r_shader_standard();

	#ifdef DEBUG
	stagedraw.dummy.tex = res_sprite("star")->tex;
	stagedraw.dummy.w = 1;
	stagedraw.dummy.h = 1;
	#endif

	stage_draw_setup_framebuffers();

	stagedraw.clear_screen.alpha = 0;
	stagedraw.clear_screen.target_alpha = 0;

	events_register_handler(&(EventHandler) {
		stage_draw_event, NULL, EPRIO_SYSTEM,
	});

	COEVENT_INIT_ARRAY(stagedraw.events);
}

void stage_draw_shutdown(void) {
	COEVENT_CANCEL_ARRAY(stagedraw.events);
	events_unregister_handler(stage_draw_event);
	stage_draw_destroy_framebuffers();
}

FBPair *stage_get_fbpair(StageFBPair id) {
	assert(id >= 0 && id < NUM_FBPAIRS);
	return stagedraw.fb_pairs + id;
}

FBPair *stage_get_postprocess_fbpair(void) {
	return NOT_NULL(stagedraw.current_postprocess_fbpair);
}

static void stage_draw_collision_areas(void) {
#ifdef DEBUG
	static bool enabled, keystate_saved;
	bool keystate = gamekeypressed(KEY_HITAREAS);

	if(keystate ^ keystate_saved) {
		if(keystate) {
			enabled = !enabled;
		}

		keystate_saved = keystate;
	}

	if(!enabled) {
		return;
	}

	r_shader("sprite_filled_circle");
	r_uniform_vec4("color_inner", 0, 0, 0, 1);
	r_uniform_vec4("color_outer", 1, 1, 1, 0.1);

	for(Projectile *p = global.projs.first; p; p = p->next) {
		cmplx gsize = projectile_graze_size(p);

		if(re(gsize)) {
			r_draw_sprite(&(SpriteParams) {
				.color = RGB(0, 0.5, 0.5),
				.sprite_ptr = &stagedraw.dummy,
				.pos = { re(p->pos), im(p->pos) },
				.rotation.angle = p->angle + M_PI/2,
				.scale = { .x = re(gsize), .y = im(gsize) },
				.blend = BLEND_SUB,
			});
		}
	}

	r_flush_sprites();
	r_uniform_vec4("color_inner", 0.0, 1.0, 0.0, 0.75);
	r_uniform_vec4("color_outer", 0.0, 0.5, 0.5, 0.75);

	for(Projectile *p = global.projs.first; p; p = p->next) {
		r_draw_sprite(&(SpriteParams) {
			.sprite_ptr = &stagedraw.dummy,
			.pos = { re(p->pos), im(p->pos) },
			.rotation.angle = p->angle + M_PI/2,
			.scale = { .x = re(p->collision_size), .y = im(p->collision_size) },
			.blend = BLEND_ALPHA,
		});
	}

	for(Enemy *e = global.enemies.first; e; e = e->next) {
		float hurt_radius = enemy_get_hurt_radius(e);

		if(hurt_radius > 0) {
			r_draw_sprite(&(SpriteParams) {
				.sprite_ptr = &stagedraw.dummy,
				.pos = { re(e->pos), im(e->pos) },
				.scale = { .x = hurt_radius * 2, .y = hurt_radius * 2 },
				.blend = BLEND_ALPHA,
			});
		}
	}

	if(global.boss && boss_is_player_collision_active(global.boss)) {
		r_draw_sprite(&(SpriteParams) {
			.sprite_ptr = &stagedraw.dummy,
			.pos = { re(global.boss->pos), im(global.boss->pos) },
			.scale = { .x = BOSS_HURT_RADIUS * 2, .y = BOSS_HURT_RADIUS * 2 },
			.blend = BLEND_ALPHA,
		});
	}

	r_draw_sprite(&(SpriteParams) {
		.sprite_ptr = &stagedraw.dummy,
		.pos = { re(global.plr.pos), im(global.plr.pos) },
		.scale.both = 2, // NOTE: actual player is a singular point
	});

	// TODO: perhaps handle lasers somehow

	r_flush_sprites();
#endif
}

static void apply_shader_rules(ShaderRule *shaderrules, FBPair *fbos) {
	if(!shaderrules) {
		return;
	}

	for(ShaderRule *rule = shaderrules; *rule; ++rule) {
		r_framebuffer(fbos->back);

		if((*rule)(fbos->front)) {
			fbpair_swap(fbos);
		}
	}

	return;
}

static void draw_wall_of_text(float f, const char *txt) {
	Sprite spr;
	TextBBox bbox;

	char buf[strlen(txt) + 4];
	memcpy(buf, txt, sizeof(buf) - 4);
	memcpy(buf + sizeof(buf) - 4, " ~ ", 4);

	text_render(buf, res_font("standard"), &spr, &bbox);

	// FIXME: The shader currently assumes that the sprite takes up the entire texture.
	// If it could handle any arbitrary sprite, then text_render wouldn't have to resize
	// the texture per every new string of text.

	float w = VIEWPORT_W;
	float h = VIEWPORT_H;

	r_mat_mv_push();
	r_mat_mv_translate(w/2, h/2, 0);
	r_mat_mv_scale(w, h, 1.0);

	uint tw, th;
	r_texture_get_size(spr.tex, 0, &tw, &th);

	r_shader("spellcard_walloftext");
	r_uniform_float("w", spr.tex_area.w);
	r_uniform_float("h", spr.tex_area.h);
	r_uniform_float("ratio", h/w);
	r_uniform_vec2("origin", re(global.boss->pos)/h, im(global.boss->pos)/w); // what the fuck?
	r_uniform_float("t", f);
	r_uniform_sampler("tex", spr.tex);
	r_draw_quad();
	r_shader_standard();

	r_mat_mv_pop();
}

static void draw_spellbg(int t) {
	Boss *b = global.boss;

	r_state_push();
	b->current->draw_rule(b, t);
	r_state_pop();

	if(b->current->type == AT_ExtraSpell) {
		draw_extraspell_bg(b, t);
	}

	float scale = 1;

	if(t < 0) {
		scale = 1.0 - t/attacktype_start_delay(b->current->type);
	}

	r_draw_sprite(&(SpriteParams) {
		.sprite_ptr = res_sprite("boss_spellcircle0"),
		.shader_ptr = res_shader("sprite_default"),
		.pos = { re(b->pos), im(b->pos) },
		.rotation.angle = global.frames * 7.0 * DEG2RAD,
		.rotation.vector = { 0, 0, -1 },
		.scale.both = scale,
	});
}

static void draw_spellbg_overlay(int t) {
	Boss *b = global.boss;

	float delay = attacktype_start_delay(b->current->type);
	float f = (ATTACK_START_DELAY - t) / (delay + ATTACK_START_DELAY);

	if(f > 0<