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
 122         private struct engine_texture_data **mipmap_data;
 123         private unsigned char mipmap_count;
 124
 125         interface U:Object:Loadable
 126         private int load(U:Object *uo)
 127         {
 128                 struct engine_texture_data **data;
 129                 Self *self = SELF(uo);
 130
 131                 if (upkg_export_seek(uo->pkg_file, 0, SEEK_SET) != 0)
 132                         return -1;
 133
 134                 data = malloc(self->_priv->mipmap_count * sizeof *data);
 135                 if (!data)
 136                         return -1;
 137
 138                 for (int i = 0; i < self->_priv->mipmap_count; i++) {
 139                         data[i] = decode_mipmap(uo);
 140                         if (!data[i]) {
 141                                 u_err(uo, "error decoding mipmap level %d", i);
 142
 143                                 /* Unwind the allocations. */
 144                                 for (; i >= 0; i--)
 145                                         free(data[i]);
 146                                 free(data);
 147                                 return -1;
 148                         }
 149                 }
 150
 151                 self->_priv->mipmap_data = data;
 152                 return 0;
 153         }
 154
 155         interface U:Object:Loadable
 156         private void unload(U:Object *uo)
 157         {
 158                 Self *self = SELF(uo);
 159
 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;
 164         }
 165
 166         interface U:Object:Exportable
 167         private int export_name(U:Object *uo, char *buf, size_t n)
 168         {
 169                 return snprintf(buf, n, "%s.pcx", uo->pkg_file->name);
 170         }
 171
 172         interface U:Object:Exportable
 173         private int export(U:Object *uo, FILE *f)
 174         {
 175                 Self *self = SELF(uo);
 176                 struct engine_texture_data *data;
 177                 struct pcx_head head;
 178
 179                 if (!self->_priv->mipmap_data || !self->_priv->Palette)
 180                         return -1;
 181                 data = self->_priv->mipmap_data[0];
 182
 183                 head.width  = data->width;
 184                 head.height = data->height;
 185
 186                 if (pcx_init_header(&head) != 0)
 187                         return -1;
 188                 if (fwrite(head.encoded, sizeof head.encoded, 1, f) != 1)
 189                         return -1;
 190
 191                 for (unsigned i = 0; i < head.height; i++) {
 192                         if (pcx_write_scanline(&head, data->data+i*data->width,
 193                                                f) != 0) {
 194                                 return -1;
 195                         }
 196                 }
 197
 198                 if (pcx_write_palette(self->_priv->Palette, f) != 0)
 199                         return -1;
 200
 201                 return 0;
 202         }
 203
 204         override (U:Object) int deserialize(U:Object *uo)
 205         {
 206                 struct upkg_file *f = uo->pkg_file;
 207                 Self *self = SELF(uo);
 208
 209                 PARENT_HANDLER(uo);
 210
 211                 if (upkg_export_read(f, &self->_priv->mipmap_count, 1) != 1)
 212                         return -1;
 213                 if (self->_priv->mipmap_count == 0)
 214                         return -1;
 215
 216                 f->base += 1;
 217                 f->len  -= 1;
 218                 upkg_export_seek(f, 0, SEEK_SET);
 219
 220                 return 0;
 221         }
 222
 223         property UINT USize
 224                 ( nick = "USize"
 225                 , blurb = "Width of the texture."
 226                 , minimum = 0
 227                 , maximum = 2048
 228                 , default_value = 0
 229                 , link
 230                 );
 231         property UINT UClamp
 232                 ( nick = "UClamp"
 233                 , blurb = "???"
 234                 , minimum = 0
 235                 , maximum = 2048
 236                 , default_value = 0
 237                 , link
 238                 );
 239         property UINT UBits
 240                 ( nick = "UBits"
 241                 , blurb = "???"
 242                 , minimum = 0
 243                 , maximum = 64
 244                 , default_value = 0
 245                 , link
 246                 );
 247         property UINT VSize
 248                 ( nick = "VSize"
 249                 , blurb = "Height of the texture."
 250                 , minimum = 0
 251                 , maximum = 2048
 252                 , default_value = 0
 253                 , link
 254                 );
 255         property UINT VClamp
 256                 ( nick = "VClamp"
 257                 , blurb = "???"
 258                 , minimum = 0
 259                 , maximum = 2048
 260                 , default_value = 0
 261                 , link
 262                 );
 263         property UINT VBits
 264                 ( nick = "VBits"
 265                 , blurb = "???"
 266                 , minimum = 0
 267                 , maximum = 64
 268                 , default_value = 0
 269                 , link
 270                 );
 271
 272         property OBJECT Palette
 273                 ( nick = "Palette"
 274                 , blurb = "Reference to the texture's palette."
 275                 , object_type = Engine:Palette
 276                 , link
 277                 );
 278 }