Add konmodel tool to convert glTF to kmdl

1 files changed, 652 insertions, 0 deletions

diff --git a/kon/konmodel.c b/kon/konmodel.c
new file mode 100644
index 0000000..389d16c
--- /dev/null
+++ b/kon/konmodel.c
@@ -0,0 +1,652 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * konmodel.c
+ *
+ * Copyright (c) 2026 KonAki
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#include "konmodel.h"
+
+/*** definition ***/
+
+#define KON_MODEL_VERSION 1
+#define KON_MODEL_MAX_COUNT (1 << 24)
+
+/*** reading ***/
+
+typedef struct kon_cursor {
+	const uint8_t *data;
+	size_t size, at;
+	int bad;
+} kon_cursor_t;
+
+static const uint8_t *kon_take_(kon_cursor_t *c, size_t n) {
+	const uint8_t *p;
+
+	if (c->bad || n > c->size - c->at) {
+		c->bad = 1;
+		return NULL;
+	}
+	p = c->data + c->at;
+	c->at += n;
+	return p;
+}
+
+static uint32_t kon_readU32_(kon_cursor_t *c) {
+	const uint8_t *p = kon_take_(c, 4);
+	if (!p) return 0;
+	return (uint32_t)p[0] | (uint32_t)p[1] << 8 | (uint32_t)p[2] << 16 | (uint32_t)p[3] << 24;
+}
+
+static float kon_readFloat_(kon_cursor_t *c) {
+	uint32_t u = kon_readU32_(c);
+	float f;
+	memcpy(&f, &u, sizeof f);
+	return f;
+}
+
+static void kon_readFloats_(kon_cursor_t *c, float *out, size_t n) {
+	size_t i;
+	for (i = 0; i < n; i++) out[i] = kon_readFloat_(c);
+}
+
+static void kon_readName_(kon_cursor_t *c, char *out, size_t n) {
+	const uint8_t *p = kon_take_(c, n);
+	if (!p) return;
+	memcpy(out, p, n);
+	out[n - 1] = 0;
+}
+
+/* the count has to fit in what is left of the file, so a bad count can't make a huge allocation */
+static int kon_countFits_(const kon_cursor_t *c, uint32_t count, size_t each) {
+	if (count > KON_MODEL_MAX_COUNT) return 0;
+	return (size_t)count * each <= c->size - c->at;
+}
+
+static void *kon_alloc_(kon_model_t *model, size_t count, size_t each) {
+	void *p;
+
+	if (count == 0) return NULL;
+	p = calloc(count, each);
+	if (p) model->bytes += count * each;
+	return p;
+}
+
+static int kon_validFloat_(float f) {
+	return f == f && f > -1e30f && f < 1e30f;
+}
+
+static int kon_readMaterial_(kon_cursor_t *c, kon_modelMaterial_t *m) {
+	uint32_t filter;
+
+	kon_readName_(c, m->texture, KON_MODEL_TEXTURE_SIZE);
+	m->color = kon_readU32_(c);
+	filter = kon_readU32_(c);
+	m->filter = filter ? KON_FILTER_LINEAR : KON_FILTER_NEAREST;
+	return !c->bad;
+}
+
+static int kon_readMesh_(kon_cursor_t *c, kon_model_t *model, kon_modelMesh_t *mesh) {
+	uint32_t material = kon_readU32_(c), vertexCount = kon_readU32_(c), triangleCount = kon_readU32_(c), skinned = kon_readU32_(c);
+	int i;
+
+	if (c->bad || material >= (uint32_t)model->materialCount || skinned > 1) return 0;
+	if (vertexCount == 0 || vertexCount > 65535 || triangleCount == 0) return 0;
+	if (!kon_countFits_(c, vertexCount, 32 + (skinned ? 20 : 0))) return 0;
+	if (!kon_countFits_(c, triangleCount, 6)) return 0;
+	if (skinned && model->boneCount == 0) return 0;
+
+	mesh->material = (int)material;
+	mesh->vertexCount = (int)vertexCount;
+	mesh->triangleCount = (int)triangleCount;
+	mesh->vertices = kon_alloc_(model, vertexCount, sizeof *mesh->vertices);
+	mesh->indices = kon_alloc_(model, (size_t)triangleCount * 3, sizeof *mesh->indices);
+	if (skinned) {
+		mesh->joints = kon_alloc_(model, (size_t)vertexCount * 4, 1);
+		mesh->weights = kon_alloc_(model, (size_t)vertexCount * 4, sizeof *mesh->weights);
+		if (!mesh->joints || !mesh->weights) return 0;
+	}
+	if (!mesh->vertices || !mesh->indices) return 0;
+
+	for (i = 0; i < mesh->vertexCount; i++) {
+		float f[8];
+		kon_readFloats_(c, f, 8);
+		if (c->bad) return 0;
+		for (int k = 0; k < 8; k++) if (!kon_validFloat_(f[k])) return 0;
+		mesh->vertices[i].position = KON_VEC3(f[0], f[1], f[2]);
+		mesh->vertices[i].normal = KON_VEC3(f[3], f[4], f[5]);
+		mesh->vertices[i].uv = (kon_vec2_t){f[6], f[7]};
+	}
+	if (skinned) {
+		for (i = 0; i < mesh->vertexCount; i++) {
+			const uint8_t *j = kon_take_(c, 4);
+			if (!j) return 0;
+			for (int k = 0; k < 4; k++) {
+				float w = kon_readFloat_(c);
+				if (!kon_validFloat_(w) || j[k] >= model->boneCount) return 0;
+				mesh->joints[i * 4 + k] = j[k];
+				mesh->weights[i * 4 + k] = w;
+			}
+		}
+	}
+	for (i = 0; i < mesh->triangleCount * 3; i++) {
+		const uint8_t *p = kon_take_(c, 2);
+		if (!p) return 0;
+		mesh->indices[i] = (uint16_t)(p[0] | p[1] << 8);
+		if (mesh->indices[i] >= mesh->vertexCount) return 0;
+	}
+	return 1;
+}
+
+static int kon_readBone_(kon_cursor_t *c, kon_modelBone_t *bone, int index) {
+	float f[26];
+	uint32_t parent;
+	int i;
+
+	kon_readName_(c, bone->name, KON_MODEL_NAME_SIZE);
+	parent = kon_readU32_(c);
+	kon_readFloats_(c, f, 26);
+	if (c->bad) return 0;
+	for (i = 0; i < 26; i++) if (!kon_validFloat_(f[i])) return 0;
+	bone->parent = (int)parent;
+	if (parent == 0xFFFFFFFFu) bone->parent = -1;
+	else if (parent >= (uint32_t)index) return 0;
+	memcpy(bone->inverseBind.m, f, 16 * sizeof(float));
+	bone->position = KON_VEC3(f[16], f[17], f[18]);
+	bone->rotation = (kon_vec4_t){f[19], f[20], f[21], f[22]};
+	bone->scale = KON_VEC3(f[23], f[24], f[25]);
+	return 1;
+}
+
+static int kon_readClip_(kon_cursor_t *c, kon_model_t *model, kon_modelClip_t *clip) {
+	uint32_t channelCount;
+	int i;
+
+	kon_readName_(c, clip->name, KON_MODEL_NAME_SIZE);
+	clip->duration = kon_readFloat_(c);
+	channelCount = kon_readU32_(c);
+	if (c->bad || !kon_validFloat_(clip->duration) || clip->duration < 0.0f) return 0;
+	if (!kon_countFits_(c, channelCount, 12)) return 0;
+
+	clip->channels = kon_alloc_(model, channelCount, sizeof *clip->channels);
+	if (channelCount && !clip->channels) return 0;
+	clip->channelCount = (int)channelCount;
+
+	for (i = 0; i < clip->channelCount; i++) {
+		kon_modelChannel_t *ch = &clip->channels[i];
+		uint32_t bone = kon_readU32_(c), kind = kon_readU32_(c), keyCount = kon_readU32_(c);
+		int width, k;
+
+		ch->path = (int)(kind & 0xFF);
+		ch->step = (int)((kind >> 8) & 1);
+		if (c->bad || bone >= (uint32_t)model->boneCount || ch->path > KON_MODEL_SCALE || (kind >> 9)) return 0;
+		width = ch->path == KON_MODEL_ROTATION ? 4 : 3;
+		if (keyCount == 0 || !kon_countFits_(c, keyCount, 4 + (size_t)width * 4)) return 0;
+		ch->bone = (int)bone;
+		ch->keyCount = (int)keyCount;
+		ch->times = kon_alloc_(model, keyCount, sizeof(float));
+		ch->values = kon_alloc_(model, (size_t)keyCount * width, sizeof(float));
+		if (!ch->times || !ch->values) return 0;
+		kon_readFloats_(c, ch->times, keyCount);
+		kon_readFloats_(c, ch->values, (size_t)keyCount * width);
+		if (c->bad) return 0;
+		for (k = 0; k < ch->keyCount; k++) {
+			if (!kon_validFloat_(ch->times[k]) || (k && ch->times[k] < ch->times[k - 1])) return 0;
+		}
+		for (k = 0; k < ch->keyCount * width; k++) if (!kon_validFloat_(ch->values[k])) return 0;
+	}
+	return 1;
+}
+
+kon_model_t *kon_modelLoad(const uint8_t *data, size_t size) {
+	kon_cursor_t c = {data, size, 0, 0};
+	kon_model_t *model;
+	const uint8_t *magic;
+	uint32_t version, materials, meshes, bones, clips;
+	int i, maxVertices = 0;
+
+	if (!data) return NULL;
+	magic = kon_take_(&c, 4);
+	if (!magic || memcmp(magic, "KMDL", 4) != 0) return NULL;
+	version = kon_readU32_(&c);
+	materials = kon_readU32_(&c);
+	meshes = kon_readU32_(&c);
+	bones = kon_readU32_(&c);
+	clips = kon_readU32_(&c);
+	if (c.bad || version != KON_MODEL_VERSION || bones > KON_MODEL_MAX_BONES) return NULL;
+	if (!kon_countFits_(&c, materials, 72) || !kon_countFits_(&c, meshes, 16)) return NULL;
+	if (!kon_countFits_(&c, bones, 32 + 4 + 104) || !kon_countFits_(&c, clips, 40)) return NULL;
+
+	model = calloc(1, sizeof *model);
+	if (!model) return NULL;
+	model->bytes = sizeof *model;
+	model->materialCount = (int)materials;
+	model->meshCount = (int)meshes;
+	model->boneCount = (int)bones;
+	model->clipCount = (int)clips;
+	model->materials = kon_alloc_(model, materials, sizeof *model->materials);
+	model->meshes = kon_alloc_(model, meshes, sizeof *model->meshes);
+	model->bones = kon_alloc_(model, bones, sizeof *model->bones);
+	model->clips = kon_alloc_(model, clips, sizeof *model->clips);
+	if ((materials && !model->materials) || (meshes && !model->meshes) || (bones && !model->bones) || (clips && !model->clips)) goto fail;
+
+	for (i = 0; i < model->materialCount; i++) if (!kon_readMaterial_(&c, &model->materials[i])) goto fail;
+	for (i = 0; i < model->boneCount; i++) if (!kon_readBone_(&c, &model->bones[i], i)) goto fail;
+	for (i = 0; i < model->meshCount; i++) {
+		if (!kon_readMesh_(&c, model, &model->meshes[i])) goto fail;
+		if (model->meshes[i].vertexCount > maxVertices) maxVertices = model->meshes[i].vertexCount;
+	}
+	for (i = 0; i < model->clipCount; i++) if (!kon_readClip_(&c, model, &model->clips[i])) goto fail;
+
+	model->scratch = kon_alloc_(model, (size_t)maxVertices, sizeof *model->scratch);
+	if (maxVertices && !model->scratch) goto fail;
+	model->scratchCount = maxVertices;
+	return model;
+
+fail:
+	kon_modelFree(model);
+	return NULL;
+}
+
+void kon_modelFree(kon_model_t *model) {
+	int i, j;
+
+	if (!model) return;
+	for (i = 0; i < model->meshCount; i++) {
+		free(model->meshes[i].vertices);
+		free(model->meshes[i].indices);
+		free(model->meshes[i].joints);
+		free(model->meshes[i].weights);
+	}
+	for (i = 0; i < model->clipCount; i++) {
+		for (j = 0; j < model->clips[i].channelCount; j++) {
+			free(model->clips[i].channels[j].times);
+			free(model->clips[i].channels[j].values);
+		}
+		free(model->clips[i].channels);
+	}
+	free(model->materials);
+	free(model->meshes);
+	free(model->bones);
+	free(model->clips);
+	free(model->scratch);
+	free(model);
+}
+
+/*** assets ***/
+
+static void *kon_modelAssetLoad_(const uint8_t *data, size_t size, size_t *bytes) {
+	kon_model_t *model = kon_modelLoad(data, size);
+	if (model) *bytes = model->bytes;
+	return model;
+}
+
+static void kon_modelAssetUnload_(void *object) {
+	kon_modelFree((kon_model_t *)object);
+}
+
+static const kon_assetLoader_t kon_modelLoader_ = {"model", ".kmdl", kon_modelAssetLoad_, kon_modelAssetUnload_};
+
+int kon_modelRegister(kon_assets_t *assets) {
+	return kon_assetsRegister(assets, &kon_modelLoader_);
+}
+
+void kon_modelBindTextures(kon_model_t *model, kon_assets_t *assets) {
+	int i;
+
+	if (!model || !assets) return;
+	for (i = 0; i < model->materialCount; i++) {
+		kon_modelMaterial_t *m = &model->materials[i];
+		if (!m->texture[0] || m->image) continue;
+		if (!kon_assetGet(assets, m->texture)) continue;
+		m->image = kon_assetImage(assets, m->texture);
+		if (!m->image) kon_assetRelease(assets, m->texture);
+	}
+}
+
+void kon_modelUnbindTextures(kon_model_t *model, kon_assets_t *assets) {
+	int i;
+
+	if (!model || !assets) return;
+	for (i = 0; i < model->materialCount; i++) {
+		kon_modelMaterial_t *m = &model->materials[i];
+		if (m->image) kon_assetRelease(assets, m->texture);
+		m->image = NULL;
+	}
+}
+
+/*** animation ***/
+
+int kon_modelFindBone(const kon_model_t *model, const char *name) {
+	int i;
+
+	if (!model || !name) return -1;
+	for (i = 0; i < model->boneCount; i++) if (strcmp(model->bones[i].name, name) == 0) return i;
+	return -1;
+}
+
+int kon_modelFindClip(const kon_model_t *model, const char *name) {
+	int i;
+
+	if (!model || !name) return -1;
+	for (i = 0; i < model->clipCount; i++) if (strcmp(model->clips[i].name, name) == 0) return i;
+	return -1;
+}
+
+static kon_vec4_t kon_quatSlerp_(kon_vec4_t a, kon_vec4_t b, float t) {
+	float dot = a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w;
+	float wa, wb, len;
+	kon_vec4_t r;
+
+	if (dot < 0.0f) {
+		dot = -dot;
+		b = (kon_vec4_t){-b.x, -b.y, -b.z, -b.w};
+	}
+	if (dot > 0.9995f) {
+		wa = 1.0f - t;
+		wb = t;
+	} else {
+		float angle = acosf(dot), s = sinf(angle);
+		wa = sinf((1.0f - t) * angle) / s;
+		wb = sinf(t * angle) / s;
+	}
+	r = (kon_vec4_t){wa * a.x + wb * b.x, wa * a.y + wb * b.y, wa * a.z + wb * b.z, wa * a.w + wb * b.w};
+	len = sqrtf(r.x * r.x + r.y * r.y + r.z * r.z + r.w * r.w);
+	if (len > 0.0f) r = (kon_vec4_t){r.x / len, r.y / len, r.z / len, r.w / len};
+	return r;
+}
+
+static kon_mat4_t kon_composeTRS_(kon_vec3_t p, kon_vec4_t q, kon_vec3_t s) {
+	float len = sqrtf(q.x * q.x + q.y * q.y + q.z * q.z + q.w * q.w);
+	float x, y, z, w;
+	kon_mat4_t r = kon_mat4Identity();
+
+	if (len > 0.0f) {
+		x = q.x / len; y = q.y / len; z = q.z / len; w = q.w / len;
+	} else {
+		x = y = z = 0.0f; w = 1.0f;
+	}
+	r.m[0] = (1.0f - 2.0f * (y * y + z * z)) * s.x;
+	r.m[1] = 2.0f * (x * y + z * w) * s.x;
+	r.m[2] = 2.0f * (x * z - y * w) * s.x;
+	r.m[4] = 2.0f * (x * y - z * w) * s.y;
+	r.m[5] = (1.0f - 2.0f * (x * x + z * z)) * s.y;
+	r.m[6] = 2.0f * (y * z + x * w) * s.y;
+	r.m[8] = 2.0f * (x * z + y * w) * s.z;
+	r.m[9] = 2.0f * (y * z - x * w) * s.z;
+	r.m[10] = (1.0f - 2.0f * (x * x + y * y)) * s.z;
+	r.m[12] = p.x; r.m[13] = p.y; r.m[14] = p.z;
+	return r;
+}
+
+/* finds the pair of keys around time and how far between them it is. before the first or after the last key it holds that key */
+static void kon_findKeys_(const kon_modelChannel_t *ch, float time, int *k0, int *k1, float *t) {
+	int lo = 0, hi = ch->keyCount - 1;
+
+	if (time <= ch->times[0]) { *k0 = *k1 = 0; *t = 0.0f; return; }
+	if (time >= ch->times[hi]) { *k0 = *k1 = hi; *t = 0.0f; return; }
+	while (hi - lo > 1) {
+		int mid = (lo + hi) / 2;
+		if (ch->times[mid] <= time) lo = mid; else hi = mid;
+	}
+	*k0 = lo;
+	*k1 = hi;
+	*t = (time - ch->times[lo]) / (ch->times[hi] - ch->times[lo]);
+}
+
+void kon_modelSample(const kon_model_t *model, int clip, float time, int loop, kon_mat4_t *skin) {
+	kon_vec3_t position[KON_MODEL_MAX_BONES], scale[KON_MODEL_MAX_BONES];
+	kon_vec4_t rotation[KON_MODEL_MAX_BONES];
+	kon_mat4_t global[KON_MODEL_MAX_BONES];
+	int i;
+
+	if (!model || !skin) return;
+	for (i = 0; i < model->boneCount; i++) {
+		position[i] = model->bones[i].position;
+		rotation[i] = model->bones[i].rotation;
+		scale[i] = model->bones[i].scale;
+	}
+
+	if (clip >= 0 && clip < model->clipCount) {
+		const kon_modelClip_t *c = &model->clips[clip];
+
+		if (!(time == time)) time = 0.0f;
+		if (c->duration > 0.0f) {
+			if (loop) {
+				time = fmodf(time, c->duration);
+				if (time < 0.0f) time += c->duration;
+			} else if (time > c->duration) {
+				time = c->duration;
+			}
+		}
+		if (time < 0.0f) time = 0.0f;
+
+		for (i = 0; i < c->channelCount; i++) {
+			const kon_modelChannel_t *ch = &c->channels[i];
+			int k0, k1;
+			float t;
+
+			kon_findKeys_(ch, time, &k0, &k1, &t);
+			if (ch->step) t = 0.0f;
+			if (ch->path == KON_MODEL_ROTATION) {
+				const float *a = &ch->values[k0 * 4], *b = &ch->values[k1 * 4];
+				rotation[ch->bone] = kon_quatSlerp_((kon_vec4_t){a[0], a[1], a[2], a[3]}, (kon_vec4_t){b[0], b[1], b[2], b[3]}, t);
+			} else {
+				const float *a = &ch->values[k0 * 3], *b = &ch->values[k1 * 3];
+				kon_vec3_t v = kon_vec3Lerp(KON_VEC3(a[0], a[1], a[2]), KON_VEC3(b[0], b[1], b[2]), t);
+				if (ch->path == KON_MODEL_POSITION) position[ch->bone] = v; else scale[ch->bone] = v;
+			}
+		}
+	}
+
+	for (i = 0; i < model->boneCount; i++) {
+		kon_mat4_t local = kon_composeTRS_(position[i], rotation[i], scale[i]);
+		int parent = model->bones[i].parent;
+		global[i] = parent >= 0 ? kon_mat4Mul(global[parent], local) : local;
+		skin[i] = kon_mat4Mul(global[i], model->bones[i].inverseBind);
+	}
+}
+
+/*** drawing ***/
+
+static kon_vec3_t kon_mat4MulDirection_(const kon_mat4_t *m, kon_vec3_t v) {
+	return KON_VEC3(m->m[0] * v.x + m->m[4] * v.y + m->m[8] * v.z,
+			m->m[1] * v.x + m->m[5] * v.y + m->m[9] * v.z,
+			m->m[2] * v.x + m->m[6] * v.y + m->m[10] * v.z);
+}
+
+static void kon_skinMesh_(const kon_modelMesh_t *mesh, const kon_mat4_t *skin, kon_vertex_t *out) {
+	int i, k;
+
+	for (i = 0; i < mesh->vertexCount; i++) {
+		const kon_vertex_t *v = &mesh->vertices[i];
+		kon_vec3_t p = KON_VEC3_ZERO, n = KON_VEC3_ZERO;
+		float total = 0.0f;
+
+		for (k = 0; k < 4; k++) {
+			float w = mesh->weights[i * 4 + k];
+			const kon_mat4_t *m = &skin[mesh->joints[i * 4 + k]];
+			if (w == 0.0f) continue;
+			p = kon_vec3Add(p, kon_vec3Scale(kon_mat4MulPoint(*m, v->position), w));
+			n = kon_vec3Add(n, kon_vec3Scale(kon_mat4MulDirection_(m, v->normal), w));
+			total += w;
+		}
+		out[i].uv = v->uv;
+		if (total > 0.0f) {
+			out[i].position = p;
+			out[i].normal = kon_vec3Normalize(n);
+		} else {
+			out[i].position = v->position;
+			out[i].normal = v->normal;
+		}
+	}
+}
+
+void kon_modelDraw(kon_framebuffer_t *fb, kon_mat4_t viewProjection, kon_mat4_t world, kon_model_t *model, const kon_mat4_t *skin, const kon_light_t *light, kon_renderFlags_t flags) {
+	int i;
+
+	if (!fb || !model) return;
+	for (i = 0; i < model->meshCount; i++) {
+		const kon_modelMesh_t *mesh = &model->meshes[i];
+		const kon_modelMaterial_t *source = &model->materials[mesh->material];
+		kon_material_t material;
+		kon_mesh_t draw;
+
+		material.texture = source->image;
+		material.color = source->color;
+		material.filter = source->filter;
+		draw.indices = mesh->indices;
+		draw.triangleCount = mesh->triangleCount;
+		draw.vertices = mesh->vertices;
+		if (skin && mesh->weights) {
+			kon_skinMesh_(mesh, skin, model->scratch);
+			draw.vertices = model->scratch;
+		}
+		kon_drawMesh(fb, viewProjection, world, &draw, &material, light, flags);
+	}
+}
+
+/*** writing ***/
+
+#ifdef KONMODEL_WRITER
+
+typedef struct kon_sink {
+	uint8_t *data;
+	size_t size, capacity;
+	int bad;
+} kon_sink_t;
+
+static void kon_put_(kon_sink_t *s, const void *src, size_t n) {
+	if (s->bad) return;
+	if (s->size + n > s->capacity) {
+		size_t capacity = s->capacity ? s->capacity : 1024;
+		uint8_t *grown;
+		while (capacity < s->size + n) capacity *= 2;
+		grown = realloc(s->data, capacity);
+		if (!grown) { s->bad = 1; return; }
+		s->data = grown;
+		s->capacity = capacity;
+	}
+	memcpy(s->data + s->size, src, n);
+	s->size += n;
+}
+
+static void kon_putU32_(kon_sink_t *s, uint32_t v) {
+	uint8_t b[4] = {(uint8_t)v, (uint8_t)(v >> 8), (uint8_t)(v >> 16), (uint8_t)(v >> 24)};
+	kon_put_(s, b, 4);
+}
+
+static void kon_putFloat_(kon_sink_t *s, float f) {
+	uint32_t u;
+	memcpy(&u, &f, sizeof u);
+	kon_putU32_(s, u);
+}
+
+static void kon_putName_(kon_sink_t *s, const char *name, size_t n) {
+	char buffer[KON_MODEL_TEXTURE_SIZE];
+	size_t length;
+
+	memset(buffer, 0, sizeof buffer);
+	length = strlen(name);
+	if (length > n - 1) length = n - 1;
+	memcpy(buffer, name, length);
+	kon_put_(s, buffer, n);
+}
+
+uint8_t *kon_modelSerialize(const kon_model_t *model, size_t *size) {
+	kon_sink_t s = {NULL, 0, 0, 0};
+	int i, j, k;
+
+	if (!model) return NULL;
+	kon_put_(&s, "KMDL", 4);
+	kon_putU32_(&s, KON_MODEL_VERSION);
+	kon_putU32_(&s, (uint32_t)model->materialCount);
+	kon_putU32_(&s, (uint32_t)model->meshCount);
+	kon_putU32_(&s, (uint32_t)model->boneCount);
+	kon_putU32_(&s, (uint32_t)model->clipCount);
+
+	for (i = 0; i < model->materialCount; i++) {
+		kon_putName_(&s, model->materials[i].texture, KON_MODEL_TEXTURE_SIZE);
+		kon_putU32_(&s, model->materials[i].color);
+		kon_putU32_(&s, model->materials[i].filter == KON_FILTER_LINEAR);
+	}
+	for (i = 0; i < model->boneCount; i++) {
+		const kon_modelBone_t *b = &model->bones[i];
+		kon_putName_(&s, b->name, KON_MODEL_NAME_SIZE);
+		kon_putU32_(&s, b->parent < 0 ? 0xFFFFFFFFu : (uint32_t)b->parent);
+		for (k = 0; k < 16; k++) kon_putFloat_(&s, b->inverseBind.m[k]);
+		kon_putFloat_(&s, b->position.x); kon_putFloat_(&s, b->position.y); kon_putFloat_(&s, b->position.z);
+		kon_putFloat_(&s, b->rotation.x); kon_putFloat_(&s, b->rotation.y); kon_putFloat_(&s, b->rotation.z); kon_putFloat_(&s, b->rotation.w);
+		kon_putFloat_(&s, b->scale.x); kon_putFloat_(&s, b->scale.y); kon_putFloat_(&s, b->scale.z);
+	}
+	for (i = 0; i < model->meshCount; i++) {
+		const kon_modelMesh_t *m = &model->meshes[i];
+		int skinned = m->joints && m->weights;
+		kon_putU32_(&s, (uint32_t)m->material);
+		kon_putU32_(&s, (uint32_t)m->vertexCount);
+		kon_putU32_(&s, (uint32_t)m->triangleCount);
+		kon_putU32_(&s, (uint32_t)skinned);
+		for (j = 0; j < m->vertexCount; j++) {
+			const kon_vertex_t *v = &m->vertices[j];
+			kon_putFloat_(&s, v->position.x); kon_putFloat_(&s, v->position.y); kon_putFloat_(&s, v->position.z);
+			kon_putFloat_(&s, v->normal.x); kon_putFloat_(&s, v->normal.y); kon_putFloat_(&s, v->normal.z);
+			kon_putFloat_(&s, v->uv.x); kon_putFloat_(&s, v->uv.y);
+		}
+		if (skinned) {
+			for (j = 0; j < m->vertexCount; j++) {
+				kon_put_(&s, &m->joints[j * 4], 4);
+				for (k = 0; k < 4; k++) kon_putFloat_(&s, m->weights[j * 4 + k]);
+			}
+		}
+		for (j = 0; j < m->triangleCount * 3; j++) {
+			uint8_t b[2] = {(uint8_t)m->indices[j], (uint8_t)(m->indices[j] >> 8)};
+			kon_put_(&s, b, 2);
+		}
+	}
+	for (i = 0; i < model->clipCount; i++) {
+		const kon_modelClip_t *c = &model->clips[i];
+		kon_putName_(&s, c->name, KON_MODEL_NAME_SIZE);
+		kon_putFloat_(&s, c->duration);
+		kon_putU32_(&s, (uint32_t)c->channelCount);
+		for (j = 0; j < c->channelCount; j++) {
+			const kon_modelChannel_t *ch = &c->channels[j];
+			int width = ch->path == KON_MODEL_ROTATION ? 4 : 3;
+			kon_putU32_(&s, (uint32_t)ch->bone);
+			kon_putU32_(&s, (uint32_t)ch->path | (uint32_t)(ch->step != 0) << 8);
+			kon_putU32_(&s, (uint32_t)ch->keyCount);
+			for (k = 0; k < ch->keyCount; k++) kon_putFloat_(&s, ch->times[k]);
+			for (k = 0; k < ch->keyCount * width; k++) kon_putFloat_(&s, ch->values[k]);
+		}
+	}
+
+	if (s.bad) {
+		free(s.data);
+		return NULL;
+	}
+	*size = s.size;
+	return s.data;
+}
+
+#endif