Initial implementation of ReignEngine HLL

ReignEngine is the 3D rendering engine used in Toushin Toshi III, and is
the predecessor of the 3D engines for Rance Quest, Rance 9, Evenicle,
etc.

This implements minimal functionality to be able to draw the first 3D
dungeon scene. Many important parts such as motion and lighting are not
implemented yet.

include/plugin.h

@@ -17,9 +17,11 @@
 #ifndef SYSTEM4_PLUGIN_H
 #define SYSTEM4_PLUGIN_H
 
+struct sact_sprite;
+
 struct draw_plugin {
 	const char *name;
-	void (*update)(struct draw_plugin *);
+	void (*update)(struct sact_sprite *);
 };
 
 #endif /* SYSTEM4_PLUGIN_H */

include/reign.h

@@ -0,0 +1,97 @@
+/* Copyright (C) 2022 kichikuou <KichikuouChrome@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://gnu.org/licenses/>.
+ */
+
+#ifndef SYSTEM4_REIGN_H
+#define SYSTEM4_REIGN_H
+
+#define RE_MAX_INSTANCES 32
+
+#include <cglm/types.h>
+
+#include "plugin.h"
+
+struct RE_options {
+	int anti_aliasing;
+	int wait_vsync;
+};
+extern struct RE_options RE_options;
+
+struct RE_camera {
+	vec3 pos;
+	float pitch, roll, yaw;  // in degrees
+};
+
+struct RE_plugin {
+	struct draw_plugin plugin;
+	int sprite;
+	struct RE_instance *instances[RE_MAX_INSTANCES];
+	struct archive *aar;
+	struct RE_renderer *renderer;
+	struct RE_camera camera;
+	mat4 proj_transform;
+
+	// Settings.
+	int render_mode;
+	int shadow_mode;
+	int bump_mode;
+	int bloom_mode;
+	int glare_mode;
+	int fog_mode;
+	int specular_mode;
+	int light_map_mode;
+	int soft_fog_edge_mode;
+	int ssao_mode;
+	int vertex_blend_mode;
+	int shader_precision_mode;
+	int texture_filter_mode;
+	bool use_power2_texture;
+	int shadow_map_resolution_level;
+	int texture_resolution_level;
+	float global_ambient_r;
+	float global_ambient_g;
+	float global_ambient_b;
+	float post_effect_filter_y;
+	float post_effect_filter_cb;
+	float post_effect_filter_cr;
+};
+
+struct RE_instance {
+	struct RE_plugin *plugin;
+	struct model *model;
+	int type;
+	vec3 pos;
+	float pitch, roll, yaw;  // in degrees
+	vec3 vec;
+	vec3 scale;
+	bool draw;
+	bool local_transform_needs_update;
+	mat4 local_transform;
+};
+
+struct RE_plugin *RE_plugin_new(void);
+void RE_plugin_free(struct RE_plugin *plugin);
+bool RE_plugin_bind(struct RE_plugin *plugin, int sprite);
+bool RE_plugin_unbind(struct RE_plugin *plugin);
+bool RE_set_projection(struct RE_plugin *plugin, float width, float height, float near, float far, float deg);
+int RE_create_instance(struct RE_plugin *plugin);
+bool RE_release_instance(struct RE_plugin *plugin, int instance);
+
+bool RE_instance_load(struct RE_instance *instance, const char *name);
+
+void RE_render(struct sact_sprite *sp);
+void RE_debug_print(struct RE_plugin *p);
+
+#endif /* SYSTEM4_REIGN_H */

shaders/reign.f.glsl

@@ -0,0 +1,25 @@
+/* Copyright (C) 2022 kichikuou <KichikuouChrome@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://gnu.org/licenses/>.
+ */
+
+uniform sampler2D tex;
+
+in vec2 tex_coord;
+out vec4 frag_color;
+
+void main() {
+        // TODO: Implement lighting.
+        frag_color = texture(tex, tex_coord);
+}

shaders/reign.v.glsl

@@ -0,0 +1,29 @@
+/* Copyright (C) 2022 kichikuou <KichikuouChrome@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://gnu.org/licenses/>.
+ */
+
+uniform mat4 local_transform;
+uniform mat4 view_transform;
+uniform mat4 proj_transform;
+
+in vec3 vertex_pos;
+in vec3 vertex_normal;
+in vec2 vertex_uv;
+out vec2 tex_coord;
+
+void main() {
+        gl_Position = proj_transform * view_transform * local_transform * vec4(vertex_pos, 1.0);
+        tex_coord = vertex_uv;
+}

src/3d/3d_internal.h

@@ -0,0 +1,138 @@
+/* Copyright (C) 2022 kichikuou <KichikuouChrome@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://gnu.org/licenses/>.
+ */
+
+#ifndef SYSTEM4_3D_3D_INTERNAL_H
+#define SYSTEM4_3D_3D_INTERNAL_H
+
+#include <cglm/types.h>
+
+#include "system4/archive.h"
+
+#include "gfx/gl.h"
+#include "gfx/gfx.h"
+
+struct model {
+	char *name;
+	int nr_meshes;
+	struct mesh *meshes;
+	int nr_materials;
+	struct material *materials;
+};
+
+struct mesh {
+	GLuint vao;
+	GLuint attr_buffer;
+	int nr_vertices;
+	int material;
+};
+
+struct material {
+	GLuint color_map;
+	bool opaque;
+};
+
+struct RE_renderer {
+	struct shader shader;
+	GLuint depth_buffer;
+
+	// Uniform variable locations
+	GLint local_transform;
+	GLint proj_transform;
+
+	// Attribute variable locations
+	GLint vertex_normal;
+	GLint vertex_uv;
+};
+
+// model.c
+
+struct model *model_load(struct archive *aar, const char *path, struct RE_renderer *renderer);
+void model_free(struct model *model);
+
+// renderer.c
+
+struct RE_renderer *RE_renderer_new(struct texture *texture);
+void RE_renderer_free(struct RE_renderer *r);
+
+// parser.c
+
+struct pol {
+	int32_t version;
+	uint32_t nr_materials;
+	struct pol_material_group *materials;
+	uint32_t nr_meshes;
+	struct pol_mesh **meshes;
+	uint32_t nr_bones;
+	struct pol_bone *bones;
+};
+
+enum pol_texture_type {
+	COLOR_MAP = 1,
+	MAX_TEXTURE_TYPE
+};
+
+struct pol_material {
+	char *name;
+	char *textures[MAX_TEXTURE_TYPE];
+};
+
+struct pol_material_group {
+	struct pol_material m;
+	uint32_t nr_children;
+	struct pol_material *children;
+};
+
+struct pol_mesh {
+	char *name;
+	uint32_t material;
+	uint32_t nr_vertices;
+	struct pol_vertex *vertices;
+	uint32_t nr_uvs;
+	vec2 *uvs;
+	uint32_t nr_triangles;
+	struct pol_triangle *triangles;
+};
+
+struct pol_vertex {
+	vec3 pos;
+	uint32_t nr_weights;
+	struct pol_bone_weight *weights;
+};
+
+struct pol_bone_weight {
+	uint32_t bone;
+	float weight;
+};
+
+struct pol_triangle {
+	uint32_t vert_index[3];
+	uint32_t uv_index[3];
+	vec3 normals[3];
+	uint32_t material;  // index in the material group
+};
+
+struct pol_bone {
+	char *name;
+	uint32_t id;
+	int32_t parent;
+	vec3 pos;
+	versor rotq;
+};
+
+struct pol *pol_parse(uint8_t *data, size_t size);
+void pol_free(struct pol *pol);
+
+#endif /* SYSTEM4_3D_3D_INTERNAL_H */

src/3d/model.c

@@ -0,0 +1,209 @@
+/* Copyright (C) 2022 kichikuou <KichikuouChrome@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://gnu.org/licenses/>.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <cglm/cglm.h>
+
+#include "system4.h"
+#include "system4/aar.h"
+#include "system4/cg.h"
+
+#include "3d_internal.h"
+#include "reign.h"
+
+struct vertex {
+	GLfloat pos[3];
+	GLfloat normal[3];
+	GLfloat uv[2];
+};
+
+static bool init_material(struct material *material, const struct pol_material *m, struct archive *aar, const char *path)
+{
+	if (!m->textures[COLOR_MAP]) {
+		WARNING("No color texture");
+		return false;
+	}
+	char *texture_path = xmalloc(strlen(path) + strlen(m->textures[COLOR_MAP]) + 2);
+	sprintf(texture_path, "%s\\%s", path, m->textures[COLOR_MAP]);
+	struct archive_data *dfile = archive_get_by_name(aar, texture_path);
+	if (!dfile) {
+		WARNING("cannot load texture %s", texture_path);
+		free(texture_path);
+		return false;
+	}
+	struct cg *cg = cg_load_data(dfile);
+	archive_free_data(dfile);
+	if (!cg) {
+		WARNING("cg_load_data failed: %s", texture_path);
+		free(texture_path);
+		return false;
+	}
+	free(texture_path);
+
+	glGenTextures(1, &material->color_map);
+	glBindTexture(GL_TEXTURE_2D, material->color_map);
+	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, cg->metrics.w, cg->metrics.h, 0, GL_RGBA, GL_UNSIGNED_BYTE, cg->pixels);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+	glGenerateMipmap(GL_TEXTURE_2D);
+	glBindTexture(GL_TEXTURE_2D, 0);
+	material->opaque = !cg->metrics.has_alpha;
+
+	cg_free(cg);
+	return true;
+}
+
+static void destroy_material(struct material *material)
+{
+	if (material->color_map)
+		glDeleteTextures(1, &material->color_map);
+}
+
+static void add_mesh(struct model *model, struct pol_mesh *m, int material_index, int material, struct RE_renderer *r)
+{
+	struct vertex *buf = xmalloc(m->nr_triangles * 3 * sizeof(struct vertex));
+	int v = 0;
+	for (uint32_t i = 0; i < m->nr_triangles; i++) {
+		struct pol_triangle *t = &m->triangles[i];
+		if (material_index >= 0 && t->material != (uint32_t)material_index)
+			continue;
+		for (int j = 0; j < 3; j++) {
+			glm_vec3_copy(m->vertices[t->vert_index[j]].pos, buf[v].pos);
+			glm_vec3_copy(t->normals[j], buf[v].normal);
+			glm_vec2_copy(m->uvs[t->uv_index[j]], buf[v].uv);
+			v++;
+		}
+	}
+	if (v == 0) {
+		free(buf);
+		return;
+	}
+	model->meshes = xrealloc_array(model->meshes, model->nr_meshes, model->nr_meshes + 1, sizeof(struct mesh));
+	struct mesh *mesh = &model->meshes[model->nr_meshes++];
+	mesh->material = material;
+	mesh->nr_vertices = v;
+
+	glGenVertexArrays(1, &mesh->vao);
+	glBindVertexArray(mesh->vao);
+	glGenBuffers(1, &mesh->attr_buffer);
+	glBindBuffer(GL_ARRAY_BUFFER, mesh->attr_buffer);
+
+	glEnableVertexAttribArray(r->shader.vertex);
+	glVertexAttribPointer(r->shader.vertex, 3, GL_FLOAT, GL_FALSE, sizeof(struct vertex), (const void *)0);
+	glEnableVertexAttribArray(r->vertex_normal);
+	glVertexAttribPointer(r->vertex_normal, 3, GL_FLOAT, GL_TRUE, sizeof(struct vertex), (const void *)offsetof(struct vertex, normal));
+	glEnableVertexAttribArray(r->vertex_uv);
+	glVertexAttribPointer(r->vertex_uv, 2, GL_FLOAT, GL_FALSE, sizeof(struct vertex), (const void *)offsetof(struct vertex, uv));
+	glBufferData(GL_ARRAY_BUFFER, mesh->nr_vertices * sizeof(struct vertex), buf, GL_STATIC_DRAW);
+
+	glBindVertexArray(0);
+	glBindBuffer(GL_ARRAY_BUFFER, 0);
+
+	free(buf);
+}
+
+static void destroy_mesh(struct mesh *mesh)
+{
+	glDeleteVertexArrays(1, &mesh->vao);
+	glDeleteBuffers(1, &mesh->attr_buffer);
+}
+
+struct model *model_load(struct archive *aar, const char *path, struct RE_renderer *r)
+{
+	if (path[0] == '\0')
+		return NULL;
+
+	const char *basename = strrchr(path, '\\');
+	basename = basename ? basename + 1 : path;
+	char *polname = xmalloc(strlen(path) + strlen(basename) + 6);
+	sprintf(polname, "%s\\%s.POL", path, basename);
+
+	struct archive_data *dfile = archive_get_by_name(aar, polname);
+	if (!dfile) {
+		WARNING("%s: not found", polname);
+		free(polname);
+		return NULL;
+	}
+
+	struct pol *pol = pol_parse(dfile->data, dfile->size);
+	archive_free_data(dfile);
+	if (!pol) {
+		WARNING("%s: parse error", polname);
+		free(polname);
+		return NULL;
+	}
+
+	struct model *model = xcalloc(1, sizeof(struct model));
+	model->name = polname;
+
+	// Materials
+	int *material_offsets = xmalloc(pol->nr_materials * sizeof(int));
+	for (uint32_t i = 0; i < pol->nr_materials; i++) {
+		material_offsets[i] = model->nr_materials;
+		if (pol->materials[i].nr_children)
+			model->nr_materials += pol->materials[i].nr_children;
+		else
+			model->nr_materials++;
+	}
+	model->materials = xcalloc(model->nr_materials, sizeof(struct material));
+	for (uint32_t i = 0; i < pol->nr_materials; i++) {
+		if (pol->materials[i].nr_children == 0) {
+			init_material(&model->materials[material_offsets[i]],
+				      &pol->materials[i].m, aar, path);
+			continue;
+		}
+		for (uint32_t j = 0; j < pol->materials[i].nr_children; j++) {
+			init_material(&model->materials[material_offsets[i] + j],
+				      &pol->materials[i].children[j], aar, path);
+		}
+	}
+
+	// Meshes
+	for (uint32_t i = 0; i < pol->nr_meshes; i++) {
+		if (!pol->meshes[i])
+			continue;
+		struct pol_material_group *mg = &pol->materials[pol->meshes[i]->material];
+		int m_off = material_offsets[pol->meshes[i]->material];
+		if (mg->nr_children == 0) {
+			add_mesh(model, pol->meshes[i], -1, m_off, r);
+			continue;
+		}
+		for (uint32_t j = 0; j < mg->nr_children; j++) {
+			add_mesh(model, pol->meshes[i], j, m_off + j, r);
+		}
+	}
+
+	free(material_offsets);
+	pol_free(pol);
+	return model;
+}
+
+void model_free(struct model *model)
+{
+	for (int i = 0; i < model->nr_meshes; i++)
+		destroy_mesh(&model->meshes[i]);
+	free(model->meshes);
+
+	for (int i = 0; i < model->nr_materials; i++)
+		destroy_material(&model->materials[i]);
+	free(model->materials);
+
+	free(model->name);
+	free(model);
+}

src/3d/parser.c

@@ -0,0 +1,286 @@
+/* Copyright (C) 2022 kichikuou <KichikuouChrome@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://gnu.org/licenses/>.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <cglm/cglm.h>
+
+#include "system4.h"
+#include "system4/buffer.h"
+
+#include "3d_internal.h"
+
+#define METERS_PER_INCH 0.0254
+
+static char *read_cstring(struct buffer *r)
+{
+	char *s = strdup(buffer_strdata(r));
+	buffer_skip(r, strlen(s) + 1);
+	return s;
+}
+
+static void read_position(struct buffer *r, vec3 v)
+{
+	// left->right handed system
+	v[0] = buffer_read_float(r) * METERS_PER_INCH;
+	v[1] = buffer_read_float(r) * METERS_PER_INCH;
+	v[2] = -buffer_read_float(r) * METERS_PER_INCH;
+}
+
+static void read_direction(struct buffer *r, vec3 v)
+{
+	// left->right handed system
+	v[0] = buffer_read_float(r);
+	v[1] = buffer_read_float(r);
+	v[2] = -buffer_read_float(r);
+}
+
+static void read_quaternion(struct buffer *r, versor q)
+{
+	// left->right handed system
+	float w = buffer_read_float(r);
+	float x = -buffer_read_float(r);
+	float y = -buffer_read_float(r);
+	float z = buffer_read_float(r);
+	glm_quat_init(q, x, y, z, w);
+}
+
+static void parse_material(struct buffer *r, struct pol_material *m)
+{
+	m->name = read_cstring(r);
+
+	int nr_textures = buffer_read_int32(r);
+	for (int i = 0; i < nr_textures; i++) {
+		char *filename = read_cstring(r);
+		int type = buffer_read_int32(r);
+		if ((unsigned)type < MAX_TEXTURE_TYPE) {
+			m->textures[type] = filename;
+		} else {
+			WARNING("invalid texture type %d", type);
+			free(filename);
+		}
+	}
+}
+
+static void destroy_material(struct pol_material *m)
+{
+	free(m->name);
+	for (int i = 0; i < MAX_TEXTURE_TYPE; i++)
+		free(m->textures[i]);
+}
+
+static void parse_material_group(struct buffer *r, struct pol_material_group *mg)
+{
+	parse_material(r, &mg->m);
+
+	mg->nr_children = buffer_read_int32(r);
+	if (mg->nr_children > 0) {
+		mg->children = xcalloc(mg->nr_children, sizeof(struct pol_material));
+		for (uint32_t i = 0; i < mg->nr_children; i++) {
+			parse_material(r, &mg->children[i]);
+		}
+	}
+}
+
+static void destroy_material_group(struct pol_material_group *mg)
+{
+	destroy_material(&mg->m);
+	if (mg->children) {
+		for (uint32_t i = 0; i < mg->nr_children; i++)
+			destroy_material(&mg->children[i]);
+		free(mg->children);
+	}
+}
+
+static void parse_vertex(struct buffer *r, int pol_version, struct pol_vertex *v)
+{
+	read_position(r, v->pos);
+	v->nr_weights = pol_version == 1 ? buffer_read_int32(r) : buffer_read_u16(r);
+	if (v->nr_weights) {
+		v->weights = xcalloc(v->nr_weights, sizeof(struct pol_bone_weight));
+		for (uint32_t i = 0; i < v->nr_weights; i++) {
+			v->weights[i].bone = pol_version == 1 ? buffer_read_int32(r) : buffer_read_u16(r);
+			v->weights[i].weight = buffer_read_float(r);
+		}
+	}
+}
+
+static void destroy_vertex(struct pol_vertex *v)
+{
+	if (v->weights)
+		free(v->weights);
+}
+
+static void parse_triangle(struct buffer *r, int unknowns_length, struct pol_triangle *t)
+{
+	t->vert_index[0] = buffer_read_int32(r);
+	t->vert_index[1] = buffer_read_int32(r);
+	t->vert_index[2] = buffer_read_int32(r);
+	t->uv_index[0] = buffer_read_int32(r);
+	t->uv_index[1] = buffer_read_int32(r);
+	t->uv_index[2] = buffer_read_int32(r);
+
+	buffer_skip(r, unknowns_length);
+
+	read_direction(r, t->normals[0]);
+	read_direction(r, t->normals[1]);
+	read_direction(r, t->normals[2]);
+	t->material = buffer_read_int32(r);
+}
+
+static struct pol_mesh *parse_mesh(struct buffer *r, int pol_version)
+{
+	int type = buffer_read_int32(r);
+	if (type != 0) {
+		if (type != -1)
+			WARNING("unknown mesh type: %d", type);
+		return NULL;
+	}
+	struct pol_mesh *mesh = xcalloc(1, sizeof(struct pol_mesh));
+	mesh->name = read_cstring(r);
+	mesh->material = buffer_read_int32(r);
+
+	mesh->nr_vertices = buffer_read_int32(r);
+	mesh->vertices = xcalloc(mesh->nr_vertices, sizeof(struct pol_vertex));
+	for (uint32_t i = 0; i < mesh->nr_vertices; i++) {
+		parse_vertex(r, pol_version, &mesh->vertices[i]);
+	}
+
+	mesh->nr_uvs = buffer_read_int32(r);
+	mesh->uvs = xcalloc(mesh->nr_uvs, sizeof(vec2));
+	for (uint32_t i = 0; i < mesh->nr_uvs; i++) {
+		mesh->uvs[i][0] = buffer_read_float(r);
+		mesh->uvs[i][1] = buffer_read_float(r);
+	}
+
+	int triangle_unknowns_length = 12;
+
+	int nr_unknown_f64s = buffer_read_int32(r);
+	if (nr_unknown_f64s) {
+		buffer_skip(r, nr_unknown_f64s * 8);
+		triangle_unknowns_length += 12;
+	}
+
+	if (pol_version == 1) {
+		int nr_unknown_vecs = buffer_read_int32(r);
+		buffer_skip(r, nr_unknown_vecs * 12);
+	} else {
+		int nr_unknown_ints = buffer_read_int32(r);
+		buffer_skip(r, nr_unknown_ints * 4);
+		int nr_unknown_bytes = buffer_read_int32(r);
+		if (nr_unknown_bytes) {
+			buffer_skip(r, nr_unknown_bytes);
+			triangle_unknowns_length += 12;
+		}
+	}
+
+	mesh->nr_triangles = buffer_read_int32(r);
+	mesh->triangles = xcalloc(mesh->nr_triangles, sizeof(struct pol_triangle));
+	for (uint32_t i = 0; i < mesh->nr_triangles; i++) {
+		parse_triangle(r, triangle_unknowns_length, &mesh->triangles[i]);
+	}
+
+	if (pol_version == 1) {
+		if (buffer_read_int32(r) != 1)
+			WARNING("unexpected mesh footer");
+		if (buffer_read_int32(r) != 0)
+			WARNING("unexpected mesh footer");
+	}
+
+	return mesh;
+}
+
+static void free_mesh(struct pol_mesh *mesh)
+{
+	if (!mesh)
+		return;
+	free(mesh->name);
+	for (uint32_t i = 0; i < mesh->nr_vertices; i++)
+		destroy_vertex(&mesh->vertices[i]);
+	free(mesh->vertices);
+	free(mesh->uvs);
+	free(mesh->triangles);
+	free(mesh);
+}
+
+static void parse_bone(struct buffer *r, struct pol_bone *bone)
+{
+	bone->name = read_cstring(r);
+	bone->id = buffer_read_int32(r);
+	bone->parent = buffer_read_int32(r);
+	read_position(r, bone->pos);
+	read_quaternion(r, bone->rotq);
+}
+
+static void destroy_bone(struct pol_bone *bone)
+{
+	free(bone->name);
+}
+
+struct pol *pol_parse(uint8_t *data, size_t size)
+{
+	struct buffer r;
+	buffer_init(&r, data, size);
+	if (memcmp(buffer_strdata(&r), "POL\0", 4))
+		return NULL;
+	buffer_skip(&r, 4);
+
+	struct pol *pol = xcalloc(1, sizeof(struct pol));
+	pol->version = buffer_read_int32(&r);
+	if (pol->version != 1 && pol->version != 2) {
+		WARNING("unknown POL version: %d", pol->version);
+		free(pol);
+		return NULL;
+	}
+	pol->nr_materials = buffer_read_int32(&r);
+	pol->materials = xcalloc(pol->nr_materials, sizeof(struct pol_material_group));
+	for (uint32_t i = 0; i < pol->nr_materials; i++) {
+		parse_material_group(&r, &pol->materials[i]);
+	}
+
+	pol->nr_meshes = buffer_read_int32(&r);
+	pol->meshes = xcalloc(pol->nr_meshes, sizeof(struct pol_mesh *));
+	for (uint32_t i = 0; i < pol->nr_meshes; i++) {
+		pol->meshes[i] = parse_mesh(&r, pol->version);
+	}
+
+	pol->nr_bones = buffer_read_int32(&r);
+	if (pol->nr_bones) {
+		pol->bones = xcalloc(pol->nr_bones, sizeof(struct pol_bone));
+		for (uint32_t i = 0; i < pol->nr_bones; i++) {
+			parse_bone(&r, &pol->bones[i]);
+		}
+	}
+
+	if (buffer_remaining(&r) != 0) {
+		WARNING("extra data at end");
+	}
+	return pol;
+}
+
+void pol_free(struct pol *pol)
+{
+	for (uint32_t i = 0; i < pol->nr_materials; i++)
+		destroy_material_group(&pol->materials[i]);
+	free(pol->materials);
+	for (uint32_t i = 0; i < pol->nr_meshes; i++)
+		free_mesh(pol->meshes[i]);
+	free(pol->meshes);
+	for (uint32_t i = 0; i < pol->nr_bones; i++)
+		destroy_bone(&pol->bones[i]);
+	free(pol->bones);
+	free(pol);
+}

src/3d/reign.c

@@ -0,0 +1,166 @@
+/* Copyright (C) 2022 kichikuou <KichikuouChrome@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://gnu.org/licenses/>.
+ */
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <cglm/cglm.h>
+
+#include "system4.h"
+#include "system4/aar.h"
+
+#include "3d_internal.h"
+#include "reign.h"
+#include "sact.h"
+#include "xsystem4.h"
+
+static struct RE_instance *create_instance(struct RE_plugin *plugin)
+{
+	struct RE_instance *instance = xcalloc(1, sizeof(struct RE_instance));
+	instance->plugin = plugin;
+	instance->scale[0] = 1.0;
+	instance->scale[1] = 1.0;
+	instance->scale[2] = 1.0;
+	glm_mat4_identity(instance->local_transform);
+	return instance;
+}
+
+static void free_instance(struct RE_instance *instance)
+{
+	if (instance->model)
+		model_free(instance->model);
+	free(instance);
+}
+
+struct RE_plugin *RE_plugin_new(void)
+{
+	char *aar_path = gamedir_path("Data/ReignData.red");
+	int error = ARCHIVE_SUCCESS;
+	struct archive *aar = (struct archive *)aar_open(aar_path, ARCHIVE_MMAP, &error);
+	if (error == ARCHIVE_FILE_ERROR) {
+		WARNING("aar_open(\"%s\"): %s", display_utf0(aar_path), strerror(errno));
+	} else if (error == ARCHIVE_BAD_ARCHIVE_ERROR) {
+		WARNING("aar_open(\"%s\"): invalid AAR archive", display_utf0(aar_path));
+	}
+	free(aar_path);
+	if (!aar)
+		return NULL;
+
+	struct RE_plugin *plugin = xcalloc(1, sizeof(struct RE_plugin));
+	plugin->plugin.name = "ReignEngine";
+	plugin->plugin.update = RE_render;
+	plugin->aar = aar;
+	return plugin;
+}
+
+void RE_plugin_free(struct RE_plugin *plugin)
+{
+	for (int i = 0; i < RE_MAX_INSTANCES; i++) {
+		if (plugin->instances[i])
+			free_instance(plugin->instances[i]);
+	}
+	archive_free(plugin->aar);
+	if (plugin->renderer)
+		RE_renderer_free(plugin->renderer);
+	free(plugin);
+}
+
+bool RE_plugin_bind(struct RE_plugin *plugin, int sprite)
+{
+	struct sact_sprite *sp = sact_try_get_sprite(sprite);
+	if (!sp)
+		return false;
+	plugin->renderer = RE_renderer_new(sprite_get_texture(sp));
+	plugin->sprite = sprite;
+	sprite_bind_plugin(sp, &plugin->plugin);
+	return true;
+}
+
+bool RE_plugin_unbind(struct RE_plugin *plugin)
+{
+	if (!plugin || !plugin->renderer)
+		return false;
+	struct sact_sprite *sp = sact_try_get_sprite(plugin->sprite);
+	if (sp)
+		sprite_bind_plugin(sp, NULL);
+	RE_renderer_free(plugin->renderer);
+	plugin->renderer = NULL;
+	plugin->sprite = 0;
+	return true;
+}
+
+bool RE_set_projection(struct RE_plugin *plugin, float width, float height, float near, float far, float deg)
+{
+	if (!plugin)
+		return false;
+	glm_perspective(glm_rad(deg), width / height, near, far, plugin->proj_transform);
+	return true;
+}
+
+int RE_create_instance(struct RE_plugin *plugin)
+{
+	if (!plugin)
+		return -1;
+	for (int i = 0; i < RE_MAX_INSTANCES; i++) {
+		if (!plugin->instances[i]) {
+			plugin->instances[i] = create_instance(plugin);
+			return i;
+		}
+	}
+	WARNING("too many instances");
+	return -1;
+}
+
+bool RE_release_instance(struct RE_plugin *plugin, int instance)
+{
+	if (!plugin || !plugin->instances[instance])
+		return false;
+	free_instance(plugin->instances[instance]);
+	plugin->instances[instance] = NULL;
+	return true;
+}
+
+bool RE_instance_load(struct RE_instance *instance, const char *name)
+{
+	if (!instance)
+		return false;
+	if (instance->model)
+		model_free(instance->model);
+	instance->model = model_load(instance->plugin->aar, name, instance->plugin->renderer);
+	return !!instance->model;
+}
+
+void RE_debug_print(struct RE_plugin *p)
+{
+	printf("camera = { x: %f, y: %f, z: %f, pitch: %f, roll: %f, yaw: %f }",
+	       p->camera.pos[0], p->camera.pos[1], p->camera.pos[2],
+	       p->camera.pitch, p->camera.roll, p->camera.yaw);
+
+	for (int i = 0; i < RE_MAX_INSTANCES; i++) {
+		struct RE_instance *inst = p->instances[i];
+		if (!inst || !inst->model)
+			continue;
+		printf("[%d] = {", i);
+		printf("  name: \"%s\",", inst->model->name);
+		printf("  type: %d,", inst->type);
+		printf("  draw: %d,", inst->draw);
+		printf("  pos: { x: %f, y: %f, z: %f },", inst->pos[0], inst->pos[1], inst->pos[2]);
+		printf("  vec: { x: %f, y: %f, z: %f },", inst->vec[0], inst->vec[1], inst->vec[2]);
+		printf("  scale: { x: %f, y: %f, z: %f },", inst->scale[0], inst->scale[1], inst->scale[2]);
+		printf("}");
+	}
+}

src/3d/renderer.c

@@ -0,0 +1,152 @@
+/* Copyright (C) 2022 kichikuou <KichikuouChrome@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://gnu.org/licenses/>.
+ */
+
+#include <cglm/cglm.h>
+
+#include "system4.h"
+
+#include "3d_internal.h"
+#include "reign.h"
+#include "sact.h"
+
+struct RE_renderer *RE_renderer_new(struct texture *texture)
+{
+	struct RE_renderer *r = xcalloc(1, sizeof(struct RE_renderer));
+
+	gfx_load_shader(&r->shader, "shaders/reign.v.glsl", "shaders/reign.f.glsl");
+	r->local_transform = glGetUniformLocation(r->shader.program, "local_transform");
+	r->proj_transform = glGetUniformLocation(r->shader.program, "proj_transform");
+	r->vertex_normal = glGetAttribLocation(r->shader.program, "vertex_normal");
+	r->vertex_uv = glGetAttribLocation(r->shader.program, "vertex_uv");
+
+	glGenRenderbuffers(1, &r->depth_buffer);
+	glBindRenderbuffer(GL_RENDERBUFFER, r->depth_buffer);
+	glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, texture->w, texture->h);
+	glBindRenderbuffer(GL_RENDERBUFFER, 0);
+
+	return r;
+}
+
+void RE_renderer_free(struct RE_renderer *r)
+{
+	glDeleteProgram(r->shader.program);
+	glDeleteRenderbuffers(1, &r->depth_buffer);
+	free(r);
+}
+
+static void calc_view_matrix(struct RE_camera *camera, mat4 out)
+{
+	vec3 front = { 0.0, 0.0, -1.0 };
+	vec3 euler = {
+		glm_rad(camera->pitch),
+		glm_rad(camera->yaw),
+		glm_rad(camera->roll)
+	};
+	mat4 rot;
+	glm_euler(euler, rot);
+	glm_mat4_mulv3(rot, front, 0.0, front);
+	vec3 up = {0.0, 1.0, 0.0};
+	glm_look(camera->pos, front, up, out);
+}
+
+static void update_local_transform(struct RE_instance *inst)
+{
+	vec3 euler = {
+		glm_rad(inst->pitch),
+		glm_rad(inst->yaw),
+		glm_rad(inst->roll)
+	};
+	mat4 rot;
+	glm_euler(euler, rot);
+
+	glm_translate_make(inst->local_transform, inst->pos);
+	glm_mat4_mul(inst->local_transform, rot, inst->local_transform);
+	glm_scale(inst->local_transform, inst->scale);
+
+	inst->local_transform_needs_update = false;
+}
+
+static void render_instance(struct RE_instance *inst, struct RE_renderer *r, mat4 view_transform, mat4 proj_transform)
+{
+	if (!inst->draw || !inst->model)
+		return;
+
+	if (inst->local_transform_needs_update)
+		update_local_transform(inst);
+
+	glUseProgram(r->shader.program);
+	glUniformMatrix4fv(r->shader.view_transform, 1, GL_FALSE, view_transform[0]);
+	glUniformMatrix4fv(r->proj_transform, 1, GL_FALSE, proj_transform[0]);
+	glUniformMatrix4fv(r->local_transform, 1, GL_FALSE, inst->local_transform[0]);
+
+	struct model *model = inst->model;
+	for (int i = 0; i < model->nr_meshes; i++) {
+		struct mesh *mesh = &model->meshes[i];
+		glActiveTexture(GL_TEXTURE0);
+		glBindTexture(GL_TEXTURE_2D, model->materials[mesh->material].color_map);
+		glUniform1i(r->shader.texture, 0);
+
+		glBindVertexArray(mesh->vao);
+		glDrawArrays(GL_TRIANGLES, 0, mesh->nr_vertices);
+		glBindVertexArray(0);
+		glBindTexture(GL_TEXTURE_2D, 0);
+	}
+
+	glUseProgram(0);
+}
+
+void RE_render(struct sact_sprite *sp)
+{
+	struct RE_plugin *plugin = (struct RE_plugin *)sp->plugin;
+	struct RE_renderer *r = plugin->renderer;
+	if (!r)
+		return;
+	sprite_dirty(sp);
+	struct texture *texture = sprite_get_texture(sp);
+
+	GLuint fbo = gfx_set_framebuffer(GL_DRAW_FRAMEBUFFER, texture, 0, 0, texture->w, texture->h);
+	glFramebufferRenderbuffer(GL_DRAW_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, r->depth_buffer);
+	if (glCheckFramebufferStatus(GL_DRAW_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
+		ERROR("Incomplete framebuffer");
+
+	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+	glEnable(GL_DEPTH_TEST);
+	glEnable(GL_CULL_FACE);
+
+	mat4 view_transform;
+	calc_view_matrix(&plugin->camera, view_transform);
+
+	// Tweak the projection transform so that the rendering result is vertically
+	// flipped. If we render the scene normally, the resulting image will be
+	// bottom-up (the first pixel is at the bottom-left), but we want a top-down
+	// image (the first pixel is at the top-left). This changes the coordinate
+	// system from right-handed to left-handed, we also need to reverse the
+	// winding order.
+	plugin->proj_transform[1][1] *= -1;
+	glFrontFace(GL_CW);
+
+	for (int i = 0; i < RE_MAX_INSTANCES; i++) {
+		if (plugin->instances[i])
+			render_instance(plugin->instances[i], r, view_transform, plugin->proj_transform);
+	}
+
+	plugin->proj_transform[1][1] *= -1;
+	glFrontFace(GL_CCW);
+	glDisable(GL_DEPTH_TEST);
+	glDisable(GL_CULL_FACE);
+	glFramebufferRenderbuffer(GL_DRAW_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, 0);
+	gfx_reset_framebuffer(GL_DRAW_FRAMEBUFFER, fbo);
+}

src/dungeon/dungeon.c

@@ -45,7 +45,7 @@
 #define M_PI (3.14159265358979323846)
 #endif
 
-static void dungeon_render(struct draw_plugin *plugin);
+static void dungeon_render(struct sact_sprite *sp);
 
 struct dungeon_context *dungeon_context_create(enum draw_dungeon_version version, int surface)
 {
@@ -257,12 +257,11 @@ static void model_view_matrix(struct camera *camera, mat4 out)
 	glm_lookat(eye, camera->pos, up, out);
 }
 
-static void dungeon_render(struct draw_plugin *plugin)
+static void dungeon_render(struct sact_sprite *sp)
 {
-	struct dungeon_context *ctx = (struct dungeon_context *)plugin;
+	struct dungeon_context *ctx = (struct dungeon_context *)sp->plugin;
 	if (!ctx->loaded || !ctx->draw_enabled)
 		return;
-	struct sact_sprite *sp = sact_get_sprite(ctx->surface);
 	sprite_dirty(sp);
 	struct texture *texture = sprite_get_texture(sp);
 

src/ffi.c

@@ -338,6 +338,7 @@ extern struct static_library lib_OutputLog;
 extern struct static_library lib_PassRegister;
 extern struct static_library lib_PlayDemo;
 extern struct static_library lib_PlayMovie;
+extern struct static_library lib_ReignEngine;
 extern struct static_library lib_SACT2;
 extern struct static_library lib_SACTDX;
 extern struct static_library lib_SengokuRanceFont;
@@ -401,6 +402,7 @@ static struct static_library *static_libraries[] = {
 	&lib_PassRegister,
 	&lib_PlayDemo,
 	&lib_PlayMovie,
+	&lib_ReignEngine,
 	&lib_SACT2,
 	&lib_SACTDX,
 	&lib_SengokuRanceFont,

src/meson.build

@@ -31,6 +31,11 @@ xsystem4 = [version_h,
             'video.c',
             'vm.c',
 
+            '3d/model.c',
+            '3d/parser.c',
+            '3d/reign.c',
+            '3d/renderer.c',
+
             'dungeon/dgn.c',
             'dungeon/dtx.c',
             'dungeon/dungeon.c',
@@ -98,6 +103,7 @@ xsystem4 = [version_h,
             'hll/PassRegister.c',
             'hll/PlayDemo.c',
             'hll/PlayMovie.c',
+            'hll/ReignEngine.c',
             'hll/SACT2.c',
             'hll/SengokuRanceFont.c',
             'hll/SoundFilePlayer.c',

src/sprite.c

@@ -338,7 +338,7 @@ void sprite_call_plugins(void)
 {
 	struct sact_sprite *sp;
 	LIST_FOREACH(sp, &sprites_with_plugins, entry) {
-		sp->plugin->update(sp->plugin);
+		sp->plugin->update(sp);
 	}
 }