3 * upkg: tool for manipulating Unreal Tournament packages.
4 * Copyright © 2009-2011 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 <http://www.gnu.org/licenses/>.
25 #include <uobject/loadable.h>
26 #include <uobject/exportable.h>
27 #include <engine/palette.h>
33 #include <uobject/uobject.h>
35 struct engine_texture_data {
36 unsigned long width, height;
38 unsigned long datalen;
45 struct engine_texture_data *decode_mipmap(UObject *uo)
47 struct upkg_file *f = uo->pkg_file;
48 struct engine_texture_data *data;
49 size_t rc, pos = 0, buflen;
50 unsigned long end_offset;
51 unsigned char buf[32];
54 buflen = upkg_export_read(f, buf, sizeof buf);
55 if (uo->pkg->version >= 63) {
57 * There's an offset to the end of the image data here; not
58 * clear why it's useful since it's implied by the very next
59 * field anyway. However, we will nevertheless validate this
64 end_offset = unpack_32_le(buf);
68 rc = upkg_decode_index(&datalen, buf+pos, buflen-pos);
69 if (rc == 0 || datalen < 0)
73 data = malloc(sizeof *data + datalen);
76 data->datalen = datalen;
78 /* Rewind to the start of the image data, and slurp it in. */
79 if (upkg_export_seek(f, -(long)(buflen-pos), SEEK_CUR) != 0)
81 rc = upkg_export_read(f, data->data, data->datalen);
82 if (rc != data->datalen)
85 /* At this point, the current file offset should match the one recorded
87 if (uo->pkg->version >= 63 && end_offset != (f->base + f->offset)) {
88 u_err(uo, "mipmap end offset does not match data size");
92 /* Read in the remaining fields */
93 buflen = upkg_export_read(f, buf, 10);
97 data->width = unpack_32_le(buf+0);
98 data->height = unpack_32_le(buf+4);
99 /* Last 2 bytes seem to be simply the base-2 log of width/height for
100 * whatever reason. Ignore them for now. */
109 class Engine:Texture from U:Object (dynamic)
110 (interface U:Object:Exportable)
111 (interface U:Object:Loadable)
113 private unsigned USize;
114 private unsigned UClamp;
115 private unsigned UBits;
116 private unsigned VSize;
117 private unsigned VClamp;
118 private unsigned VBits;
120 private Engine:Palette *Palette;
122 private struct engine_texture_data **mipmap_data;
123 private unsigned char mipmap_count;
125 interface U:Object:Loadable
126 private int load(U:Object *uo)
128 struct engine_texture_data **data;
129 Self *self = SELF(uo);
131 if (upkg_export_seek(uo->pkg_file, 0, SEEK_SET) != 0)
134 data = malloc(self->_priv->mipmap_count * sizeof *data);
138 for (int i = 0; i < self->_priv->mipmap_count; i++) {
139 data[i] = decode_mipmap(uo);
141 u_err(uo, "error decoding mipmap level %d", i);
143 /* Unwind the allocations. */
151 self->_priv->mipmap_data = data;
155 interface U:Object:Loadable
156 private void unload(U:Object *uo)
158 Self *self = SELF(uo);
160 for (int i = 0; i < self->_priv->mipmap_count; i++)
161 free(self->_priv->mipmap_data[i]);
162 free(self->_priv->mipmap_data);
163 self->_priv->mipmap_data = NULL;
166 interface U:Object:Exportable
167 private int export_name(U:Object *uo, char *buf, size_t n)
169 return snprintf(buf, n, "%s.pcx", uo->pkg_file->name);
172 interface U:Object:Exportable
173 private int export(U:Object *uo, FILE *f)
175 Self *self = SELF(uo);
176 struct engine_texture_data *data;
177 struct pcx_head head;
179 if (!self->_priv->mipmap_data || !self->_priv->Palette)
181 data = self->_priv->mipmap_data[0];
183 head.width = data->width;
184 head.height = data->height;
186 if (pcx_init_header(&head) != 0)
188 if (fwrite(head.encoded, sizeof head.encoded, 1, f) != 1)
191 for (unsigned i = 0; i < head.height; i++) {
192 if (pcx_write_scanline(&head, data->data+i*data->width,
198 if (pcx_write_palette(self->_priv->Palette, f) != 0)
204 override (U:Object) int deserialize(U:Object *uo)
206 struct upkg_file *f = uo->pkg_file;
207 Self *self = SELF(uo);
211 if (upkg_export_read(f, &self->_priv->mipmap_count, 1) != 1)
213 if (self->_priv->mipmap_count == 0)
218 upkg_export_seek(f, 0, SEEK_SET);
225 , blurb = "Width of the texture."
249 , blurb = "Height of the texture."
272 property OBJECT Palette
274 , blurb = "Reference to the texture's palette."
275 , object_type = Engine:Palette