src/engine/texture.gob

   1 %alltop{
   2 /*
   3  *  upkg: tool for manipulating Unreal Tournament packages.
   4  *  Copyright © 2009-2011 Nick Bowler
   5  *
   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.
  10  *
  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.
  15  *
  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/>.
  18  */
  19 %}
  20
  21 %{
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <uobject/loadable.h>
  26 #include <uobject/exportable.h>
  27 #include <engine/palette.h>
  28 #include "pack.h"
  29 #include "pcx.h"
  30 %}
  31
  32 %h{
  33 #include <uobject/uobject.h>
  34
  35 struct engine_texture_data {
  36         unsigned long width, height;
  37
  38         unsigned long datalen;
  39         unsigned char data[];
  40 };
  41
  42 %}
  43
  44 %{
  45 struct engine_texture_data *decode_mipmap(UObject *uo)
  46 {
  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];
  52         long datalen;
  53
  54         buflen = upkg_export_read(f, buf, sizeof buf);
  55         if (f->pkg->version >= 63) {
  56                 /*
  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
  60                  * property below.
  61                  */
  62                 if (pos + 4 > buflen)
  63                         return NULL;
  64                 end_offset = unpack_32_le(buf);
  65                 pos += 4;
  66         }
  67
  68         rc = upkg_decode_index(&datalen, buf+pos, buflen-pos);
  69         if (rc == 0 || datalen < 0)
  70                 return NULL;
  71         pos += rc;
  72
  73         data = malloc(sizeof *data + datalen);
  74         if (!data)
  75                 return NULL;
  76         data->datalen = datalen;
  77
  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)
  80                 goto err_free;
  81         rc = upkg_export_read(f, data->data, data->datalen);
  82         if (rc != data->datalen)
  83                 goto err_free;
  84
  85         /* At this point, the current file offset should match the one recorded
  86          * above. */
  87         if (f->pkg->version >= 63 && end_offset != (f->base + f->offset)) {
  88                 u_err(uo, "mipmap end offset does not match data size");
  89                 goto err_free;
  90         }
  91
  92         /* Read in the remaining fields */
  93         buflen = upkg_export_read(f, buf, 10);
  94         if (buflen < 10)
  95                 goto err_free;
  96
  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. */
 101
 102         return data;
 103 err_free:
 104         free(data);
 105         return NULL;
 106 }
 107 %}
 108
 109 class Engine:Texture from U:Object (dynamic)
 110         (interface U:Object:Exportable)
 111         (interface U:Object:Loadable)
 112 {
 113         private unsigned USize;
 114         private unsigned UClamp;
 115         private unsigned UBits;
 116         private unsigned VSize;
 117         private unsigned VClamp;
 118         private unsigned VBits;
 119
 120         private Engine:Palette *Palette;
 121         private Engine:Texture *DetailTexture;
 122
 123         private struct engine_texture_data **mipmap_data;
 124         private unsigned char mipmap_count;
 125
 126         interface U:Object:Loadable
 127         private int load(U:Object *uo)
 128         {
 129                 struct engine_texture_data **data;
 130                 Self *self = SELF(uo);
 131
 132                 if (upkg_export_seek(uo->pkg_file, 0, SEEK_SET) != 0)
 133                         return -1;
 134
 135                 data = malloc(self->_priv->mipmap_count * sizeof *data);
 136                 if (!data)
 137                         return -1;
 138
 139                 for (int i = 0; i < self->_priv->mipmap_count; i++) {
 140                         data[i] = decode_mipmap(uo);
 141                         if (!data[i]) {
 142                                 u_err(uo, "error decoding mipmap level %d", i);
 143
 144                                 /* Unwind the allocations. */
 145                                 for (; i >= 0; i--)
 146                                         free(data[i]);
 147                                 free(data);
 148                                 return -1;
 149                         }
 150                 }
 151
 152                 self->_priv->mipmap_data = data;
 153                 return 0;
 154         }
 155
 156         interface U:Object:Loadable
 157         private void unload(U:Object *uo)
 158         {
 159                 Self *self = SELF(uo);
 160
 161                 for (int i = 0; i < self->_priv->mipmap_count; i++)
 162                         free(self->_priv->mipmap_data[i]);
 163                 free(self->_priv->mipmap_data);
 164                 self->_priv->mipmap_data = NULL;
 165         }
 166
 167         interface U:Object:Exportable
 168         private int export_name(U:Object *uo, char *buf, size_t n)
 169         {
 170                 return snprintf(buf, n, "%s.pcx", uo->pkg_file->name);
 171         }
 172
 173         interface U:Object:Exportable
 174         private int export(U:Object *uo, FILE *f)
 175         {
 176                 Self *self = SELF(uo);
 177                 struct engine_texture_data *data;
 178                 struct pcx_head head;
 179
 180                 if (!self->_priv->mipmap_data || !self->_priv->Palette)
 181                         return -1;
 182                 data = self->_priv->mipmap_data[0];
 183
 184                 head.width  = data->width;
 185                 head.height = data->height;
 186
 187                 if (pcx_init_header(&head) != 0)
 188                         return -1;
 189                 if (fwrite(head.encoded, sizeof head.encoded, 1, f) != 1)
 190                         return -1;
 191
 192                 for (unsigned i = 0; i < head.height; i++) {
 193                         if (pcx_write_scanline(&head, data->data+i*data->width,
 194                                                f) != 0) {
 195                                 return -1;
 196                         }
 197                 }
 198
 199                 if (pcx_write_palette(self->_priv->Palette, f) != 0)
 200                         return -1;
 201
 202                 return 0;
 203         }
 204
 205         override (U:Object) int deserialize(U:Object *uo)
 206         {
 207                 struct upkg_file *f = uo->pkg_file;
 208                 Self *self = SELF(uo);
 209
 210                 PARENT_HANDLER(uo);
 211
 212                 if (upkg_export_read(f, &self->_priv->mipmap_count, 1) != 1)
 213                         return -1;
 214                 if (self->_priv->mipmap_count == 0)
 215                         return -1;
 216
 217                 f->base += 1;
 218                 f->len  -= 1;
 219                 upkg_export_seek(f, 0, SEEK_SET);
 220
 221                 return 0;
 222         }
 223
 224         property UINT USize
 225                 ( nick = "USize"
 226                 , blurb = "Width of the texture."
 227                 , minimum = 0
 228                 , maximum = 2048
 229                 , default_value = 0
 230                 , link
 231                 );
 232         property UINT UClamp
 233                 ( nick = "UClamp"
 234                 , blurb = "???"
 235                 , minimum = 0
 236                 , maximum = 2048
 237                 , default_value = 0
 238                 , link
 239                 );
 240         property UINT UBits
 241                 ( nick = "UBits"
 242                 , blurb = "???"
 243                 , minimum = 0
 244                 , maximum = 64
 245                 , default_value = 0
 246                 , link
 247                 );
 248         property UINT VSize
 249                 ( nick = "VSize"
 250                 , blurb = "Height of the texture."
 251                 , minimum = 0
 252                 , maximum = 2048
 253                 , default_value = 0
 254                 , link
 255                 );
 256         property UINT VClamp
 257                 ( nick = "VClamp"
 258                 , blurb = "???"
 259                 , minimum = 0
 260                 , maximum = 2048
 261                 , default_value = 0
 262                 , link
 263                 );
 264         property UINT VBits
 265                 ( nick = "VBits"
 266                 , blurb = "???"
 267                 , minimum = 0
 268                 , maximum = 64
 269                 , default_value = 0
 270                 , link
 271                 );
 272
 273         property OBJECT Palette
 274                 ( nick = "Palette"
 275                 , blurb = "Reference to the texture's palette."
 276                 , object_type = Engine:Palette
 277                 , link
 278                 );
 279
 280         property OBJECT DetailTexture
 281                 ( nick = "Detail Texture"
 282                 , blurb = "Reference to the corresponding detail texture."
 283                 , object_type = Engine:Texture
 284                 , link
 285                 );
 286 }