3 * upkg: tool for manipulating Unreal Tournament packages.
4 * Copyright © 2020, 2022 Nick Bowler
6 * This program is free software: you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation, either version 3 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program. If not, see <https://www.gnu.org/licenses/>.
27 #include <uobject/loadable.h>
28 #include <uobject/exportable.h>
33 #include <uobject/uobject.h>
34 #include <engine/texture.h>
36 /* Hack to work around broken type parsing in GOB2. */
37 typedef float engine_mesh_vertex[3];
39 struct engine_mesh_face {
41 unsigned short verts[3];
42 unsigned short texture;
47 class Engine:Mesh from U:Object (dynamic)
48 (interface U:Object:Loadable)
49 (interface U:Object:Exportable)
51 private struct upkg_file pkg_file;
53 protected long vert_base;
54 protected long vert_num;
55 protected long tri_base;
56 protected long tri_num;
57 protected long conn_base;
58 protected long conn_num;
59 protected long vlink_base;
60 protected long vlink_num;
62 protected engine_mesh_vertex *vertices;
63 protected struct engine_mesh_face *faces;
65 protected long num_textures = 0;
66 protected Engine:Texture **textures destroy {
68 for (i = 0; i < self->num_textures; i++) {
70 g_object_unref(textures[i]);
75 private int skip_array(struct UObject *uo, long *nent, long entsz,
76 unsigned char *buf, size_t buflen)
78 struct upkg_file *f = uo->pkg_file;
79 unsigned long buf_offset = f->offset - buflen;
80 unsigned char mybuf[9];
85 buf_offset = f->offset;
86 buflen = upkg_export_read(f, mybuf, sizeof mybuf);
90 if (f->pkg->version >= 62) {
93 skip = unpack_32_le(buf);
97 pos += (sz = upkg_decode_index(nent, buf+pos, buflen-pos));
100 if (*nent > SIZE_MAX / entsz) {
101 u_warn(uo, "bogus array size");
104 sz = (size_t)*nent * entsz;
106 if (f->pkg->version >= 62 && sz != skip - f->base - buf_offset - pos) {
107 u_warn(uo, "array skip does not match array size");
111 if (upkg_export_seek(f, buf_offset + pos + sz, SEEK_SET) != 0)
117 private size_t fill_buf(struct upkg_file *f, unsigned char *buf,
118 size_t pos, size_t buflen)
120 size_t rc, rem = buflen - pos;
122 memmove(buf, buf+pos, rem);
123 rem += upkg_export_read(f, buf+rem, buflen-rem);
127 private int load_vertices(Self *self)
129 struct upkg_file *f = &self->_priv->pkg_file;
130 unsigned char buf[100];
134 if (upkg_export_seek(f, self->vert_base, SEEK_SET) != 0)
137 buflen = upkg_export_read(f, buf, sizeof buf);
138 pos = upkg_decode_index(&n, buf, buflen);
139 g_return_val_if_fail(pos && n == self->vert_num, -1);
141 if (self->vert_num > SIZE_MAX / sizeof self->vertices[0]) {
142 u_err(self, "failed to allocate memory");
146 self->vertices = malloc(self->vert_num * sizeof self->vertices[0]);
147 if (!self->vertices) {
148 u_err(self, "failed to allocate memory");
152 for (i = 0; i < n; i++) {
153 unsigned long vertex;
155 if (buflen - pos < 4) {
156 buflen = self_fill_buf(f, buf, pos, buflen);
160 if (buflen - pos < 4) {
161 u_err(self, "failed to read vertex data");
162 free(self->vertices);
166 vertex = unpack_32_le(buf+pos); pos += 4;
167 self->vertices[i][0] = (vertex & 0x7ff) / 8.0;
168 if (self->vertices[i][0] >= 128)
169 self->vertices[i][0] -= 256;
171 self->vertices[i][1] = ((vertex >> 11) & 0x7ff) / 8.0;
172 if (self->vertices[i][1] >= 128)
173 self->vertices[i][1] -= 256;
175 self->vertices[i][2] = ((vertex >> 22) & 0x3ff) / 4.0;
176 if (self->vertices[i][2] >= 128)
177 self->vertices[i][2] -= 256;
183 private int load_faces(Self *self)
185 struct upkg_file *f = &self->_priv->pkg_file;
186 unsigned char buf[100];
190 if (upkg_export_seek(f, self->tri_base, SEEK_SET) != 0)
193 buflen = upkg_export_read(f, buf, sizeof buf);
194 pos = upkg_decode_index(&n, buf, buflen);
195 g_return_val_if_fail(pos && n == self->tri_num, -1);
197 if (self->tri_num > SIZE_MAX / sizeof self->faces[0]) {
198 u_err(self, "failed to allocate memory");
202 self->faces = malloc(self->tri_num * sizeof self->faces[0]);
204 u_err(self, "failed to allocate memory");
208 for (i = 0; i < n; i++) {
209 struct engine_mesh_face *face = &self->faces[i];
213 if (buflen - pos < 20) {
214 buflen = self_fill_buf(f, buf, pos, buflen);
218 if (buflen - pos < 20)
221 for (j = 0; j < 3; j++) {
222 face->verts[j] = unpack_16_le(buf + pos + 2*j);
223 if (face->verts[j] >= self->vert_num)
226 face->uv[j][0] = buf[pos + 6 + 2*j] / 255.0;
227 face->uv[j][1] = 1 - buf[pos + 7 + 2*j] / 255.0;
230 face->flags = unpack_32_le(buf+pos+12);
232 tmp = unpack_32_le(buf+pos+16);
233 if (tmp > USHRT_MAX || tmp >= self->num_textures)
242 u_err(self, "failed to read triangle data");
248 interface U:Object:Loadable
249 private int load(U:Object *uo)
251 Self *self = SELF(uo);
253 if (self_load_vertices(self) != 0) {
254 u_err(self, "error loading vertex data");
258 if (self_load_faces(self) != 0) {
259 u_err(self, "error loading face data");
260 free(self->vertices);
267 interface U:Object:Loadable
268 private void unload(U:Object *uo)
270 Self *self = SELF(uo);
271 free(self->vertices);
275 interface U:Object:Exportable
276 private int export_name(U:Object *uo, char *buf, size_t n)
278 return snprintf(buf, n, "%s.obj", uo->pkg_file->name);
281 private int uv_compar(const void *a_, const void *b_)
283 const float *a = a_, *b = b_;
297 interface U:Object:Exportable
298 private int export(U:Object *uo, FILE *f)
300 Self *self = SELF(uo);
304 float (*uv_work)[2] = NULL;
307 long last_texture = -1;
309 if (fprintf(f, "mtllib %s.mtl\n", uo->pkg_file->name) < 0)
312 if (fprintf(f, "# %ld vertices\n", self->vert_num) < 0)
315 for (i = 0; i < self->vert_num; i++) {
316 float *v = self->vertices[i];
318 if (fprintf(f, "v %f %f %f\n", v[0], v[1], v[2]) < 0)
322 /* Optimize UV maps */
323 uv_work = malloc(3 * self->tri_num * sizeof uv_work[0]);
325 u_warn(uo, "failed to allocate memory");
326 uv_num = 3 * self->tri_num;
328 for (i = 0; i < self->tri_num; i++) {
331 for (j = 0; j < 3; j++) {
332 uv_work[3*i+j][0] = self->faces[i].uv[j][0];
333 uv_work[3*i+j][1] = self->faces[i].uv[j][1];
336 qsort(uv_work, 3 * self->tri_num, sizeof uv_work[0],
339 for (i = 0; i < 3 * self->tri_num; i++) {
340 if (i > 0 && !self_uv_compar(uv_work[i-1], uv_work[i]))
343 memmove(uv_work[uv_num], uv_work[i], sizeof uv_work[0]);
348 if (fprintf(f, "# %ld texture coords\n", uv_num) < 0)
351 for (i = 0; i < uv_num; i++) {
357 uv = self->faces[i/3].uv[i%3];
359 if (fprintf(f, "vt %f %f\n", uv[0], uv[1]) < 0)
363 if (fprintf(f, "# %ld triangles\n", self->tri_num) < 0)
366 for (i = 0; i < self->tri_num; i++) {
367 struct engine_mesh_face *face = &self->faces[i];
368 unsigned long uv_idx[3];
371 if (face->texture != last_texture) {
372 UObject *t = U_OBJECT(self->textures[face->texture]);
374 if (t && fprintf(f, "usemtl %s\n", t->pkg_name) < 0)
377 last_texture = face->texture;
380 for (j = 0; j < 3; j++) {
384 result = bsearch(&face->uv[j], uv_work,
385 uv_num, sizeof uv_work[0],
387 g_return_val_if_fail(result, -1);
389 uv_idx[j] = result - &uv_work[0] + 1;
391 uv_idx[j] = 3ul*i+j+1;
395 rc = fprintf(f, "f %lu/%lu %lu/%lu %lu/%lu\n",
396 face->verts[0]+1lu, uv_idx[0],
397 face->verts[1]+1lu, uv_idx[1],
398 face->verts[2]+1lu, uv_idx[2]);
410 deserialize_animations(Self *self, unsigned char *buf, size_t *bufsz)
412 struct upkg_file *f = U_OBJECT(self)->pkg_file;
413 size_t rc, buflen, pos = 0;
414 long i, j, anim_count;
416 buflen = upkg_export_read(f, buf, *bufsz);
417 pos += (rc = upkg_decode_index(&anim_count, buf, buflen));
421 for (i = 0; i < anim_count; i++) {
426 pos += (rc = upkg_decode_index(&x, buf+pos, buflen-pos));
429 s = upkg_get_name(f->pkg, x);
434 pos += (rc = upkg_decode_index(&x, buf+pos, buflen-pos));
438 /* Start/end frame */
444 pos += (rc = upkg_decode_index(&nfuncs, buf+pos, buflen-pos));
448 for (j = 0; j < nfuncs; j++) {
449 if (buflen - pos < 13) {
450 buflen = self_fill_buf(f, buf, pos, buflen);
460 rc = upkg_decode_index(&x, buf+pos, buflen-pos);
471 buflen = self_fill_buf(f, buf, pos, buflen);
476 memmove(buf, buf+pos, buflen-pos);
482 private int deserialize_textures(Self *self, unsigned char *buf, size_t bufsz)
484 struct upkg_file *f = U_OBJECT(self)->pkg_file;
485 size_t rc, buflen, pos = 0;
488 buflen = upkg_export_read(f, buf, bufsz);
489 pos += (rc = upkg_decode_index(&idx, buf, buflen));
490 if (rc == 0 || idx < 0 || idx > SIZE_MAX / sizeof self->textures[0]) {
491 u_warn(self, "invalid texture count");
494 self->num_textures = idx;
496 self->textures = malloc(self->num_textures * sizeof self->textures[0]);
497 if (!self->textures) {
498 u_warn(self, "failed to allocate memory");
502 for (i = 0; i < self->num_textures; i++) {
506 buflen = self_fill_buf(f, buf, pos, buflen);
510 pos += (rc = upkg_decode_index(&idx, buf+pos, buflen-pos));
512 u_warn(self, "invalid texture reference");
513 } else if (idx == 0) {
514 /* Seems these lists start with null references, ignore... */
516 obj = u_object_get_by_link(G_OBJECT(self), idx);
518 u_warn(self, "failed to load texture %ld %ld", idx);
521 self->textures[i] = ENGINE_TEXTURE(obj);
524 if (upkg_export_seek(f, (long)pos - (long)buflen, SEEK_CUR) != 0)
530 override (U:Object) int deserialize(U:Object *uo)
532 Self *self = SELF(uo);
533 struct upkg_file *f = uo->pkg_file;
534 const size_t sphere_sz = 12 + 4 * (f->pkg->version >= 62);
535 size_t buflen, pos = 0;
538 unsigned char buf[50];
542 buflen = upkg_export_read(f, buf, sizeof buf);
545 if (buflen - pos < 25)
549 /* Bounding sphere */
550 if (buflen - pos < sphere_sz)
554 self->vert_base = pos + 4*(f->pkg->version >= 61);
555 if (self_skip_array(uo, &self->vert_num, 4, buf+pos, buflen-pos) != 0) {
556 u_err(uo, "invalid vertex array");
560 self->tri_base = f->offset + 4*(f->pkg->version >= 61);
561 if (self_skip_array(uo, &self->tri_num, 20, NULL, 0) != 0) {
562 u_err(uo, "invalid triangle array");
566 if (self_deserialize_animations(self, buf, &buflen) != 0) {
570 self->conn_base = f->offset - buflen;
571 if (self_skip_array(uo, &self->conn_num, 8, buf, buflen) != 0) {
572 u_err(uo, "invalid connection array");
576 buflen = upkg_export_read(f, buf, sizeof buf);
579 /* Another bounding box? */
580 if (buflen - pos < 25)
584 /* Another bounding sphere? */
585 if (buflen - pos < sphere_sz)
589 self->vlink_base = f->offset - (buflen - pos);
590 if (self_skip_array(uo, &self->vlink_num, 4, buf+pos, buflen-pos)) {
591 u_err(uo, "invalid vertex link array");
595 if (self_deserialize_textures(self, buf, buflen) != 0) {
599 /* More bounding boxes!? */
600 buflen = upkg_export_read(f, buf, 5);
601 pos = upkg_decode_index(&idx, buf, buflen);
602 if (pos == 0 || idx < 0 || idx > LONG_MAX / 25) {
603 u_err(uo, "invalid bounding box array");
607 if (upkg_export_seek(f, (long)pos - 5 + idx * 25, SEEK_CUR) != 0)
610 /* More bounding spheres!? */
611 buflen = upkg_export_read(f, buf, 5);
612 pos = upkg_decode_index(&idx, buf, buflen);
613 if (pos == 0 || idx < 0 || idx > LONG_MAX / 16) {
614 u_err(uo, "invalid bounding sphere array");
618 if (upkg_export_seek(f, (long)pos - 5 + idx * sphere_sz, SEEK_CUR) != 0)
621 self->_priv->pkg_file = *f;