git.mutantstargoat.com Git - dosdemo/blob - src/3dgfx/meshload.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <ctype.h>
   4 #include <assert.h>
   5 #include "mesh.h"
   6 #include "dynarr.h"
   7 #include "rbtree.h"
   8 #include "3dgfx.h"
   9 #include "util.h"
  10
  11 typedef struct { float x, y; } vec2_t;
  12 typedef struct { float x, y, z; } vec3_t;
  13 typedef struct { float x, y, z, w; } vec4_t;
  14
  15
  16 struct vertex_pos_color {
  17         float x, y, z;
  18         float r, g, b, a;
  19 };
  20
  21 struct facevertex {
  22         int vidx, tidx, nidx;
  23 };
  24
  25 static char *clean_line(char *s);
  26 static char *parse_face_vert(char *ptr, struct facevertex *fv, int numv, int numt, int numn);
  27 static int cmp_facevert(const void *ap, const void *bp);
  28 static void free_rbnode_key(struct rbnode *n, void *cls);
  29
  30 /* merge of different indices per attribute happens during face processing.
  31  *
  32  * A triplet of (vertex index/texcoord index/normal index) is used as the key
  33  * to search in a balanced binary search tree for vertex buffer index assigned
  34  * to the same triplet if it has been encountered before. That index is
  35  * appended to the index buffer.
  36  *
  37  * If a particular triplet has not been encountered before, a new g3d_vertex is
  38  * appended to the vertex buffer. The index of this new vertex is appended to
  39  * the index buffer, and also inserted into the tree for future searches.
  40  */
  41 int load_mesh(struct g3d_mesh *mesh, const char *fname)
  42 {
  43         int i, line_num = 0, result = -1;
  44         int found_quad = 0;
  45         FILE *fp = 0;
  46         char buf[256];
  47         struct vertex_pos_color *varr = 0;
  48         vec3_t *narr = 0;
  49         vec2_t *tarr = 0;
  50         struct rbtree *rbtree = 0;
  51
  52         if(!(fp = fopen(fname, "rb"))) {
  53                 fprintf(stderr, "load_mesh: failed to open file: %s\n", fname);
  54                 goto err;
  55         }
  56
  57         if(!(rbtree = rb_create(cmp_facevert))) {
  58                 fprintf(stderr, "load_mesh: failed to create facevertex binary search tree\n");
  59                 goto err;
  60         }
  61         rb_set_delete_func(rbtree, free_rbnode_key, 0);
  62
  63         if(!(mesh->varr = dynarr_alloc(0, sizeof *mesh->varr)) ||
  64                         !(mesh->iarr = dynarr_alloc(0, sizeof *mesh->iarr))) {
  65                 fprintf(stderr, "load_mesh: failed to allocate resizable mesh arrays\n");
  66                 goto err;
  67         }
  68         if(!(varr = dynarr_alloc(0, sizeof *varr)) ||
  69                         !(narr = dynarr_alloc(0, sizeof *narr)) ||
  70                         !(tarr = dynarr_alloc(0, sizeof *tarr))) {
  71                 fprintf(stderr, "load_mesh: failed to allocate resizable vertex array\n");
  72                 goto err;
  73         }
  74
  75         while(fgets(buf, sizeof buf, fp)) {
  76                 char *line = clean_line(buf);
  77                 ++line_num;
  78
  79                 if(!*line) continue;
  80
  81                 switch(line[0]) {
  82                 case 'v':
  83                         if(isspace(line[1])) {
  84                                 /* vertex */
  85                                 struct vertex_pos_color v;
  86                                 int num;
  87
  88                                 num = sscanf(line + 2, "%f %f %f %f %f %f %f", &v.x, &v.y, &v.z, &v.r, &v.g, &v.b, &v.a);
  89                                 if(num < 3) {
  90                                         fprintf(stderr, "%s:%d: invalid vertex definition: \"%s\"\n", fname, line_num, line);
  91                                         goto err;
  92                                 }
  93                                 switch(num) {
  94                                 case 3:
  95                                         v.r = 1.0f;
  96                                 case 4:
  97                                         v.g = 1.0f;
  98                                 case 5:
  99                                         v.b = 1.0f;
 100                                 case 6:
 101                                         v.a = 1.0f;
 102                                 }
 103                                 if(!(varr = dynarr_push(varr, &v))) {
 104                                         fprintf(stderr, "load_mesh: failed to resize vertex buffer\n");
 105                                         goto err;
 106                                 }
 107
 108                         } else if(line[1] == 't' && isspace(line[2])) {
 109                                 /* texcoord */
 110                                 vec2_t tc;
 111                                 if(sscanf(line + 3, "%f %f", &tc.x, &tc.y) != 2) {
 112                                         fprintf(stderr, "%s:%d: invalid texcoord definition: \"%s\"\n", fname, line_num, line);
 113                                         goto err;
 114                                 }
 115                                 tc.y = 1.0f - tc.y;
 116                                 if(!(tarr = dynarr_push(tarr, &tc))) {
 117                                         fprintf(stderr, "load_mesh: failed to resize texcoord buffer\n");
 118                                         goto err;
 119                                 }
 120
 121                         } else if(line[1] == 'n' && isspace(line[2])) {
 122                                 /* normal */
 123                                 vec3_t norm;
 124                                 if(sscanf(line + 3, "%f %f %f", &norm.x, &norm.y, &norm.z) != 3) {
 125                                         fprintf(stderr, "%s:%d: invalid normal definition: \"%s\"\n", fname, line_num, line);
 126                                         goto err;
 127                                 }
 128                                 if(!(narr = dynarr_push(narr, &norm))) {
 129                                         fprintf(stderr, "load_mesh: failed to resize normal buffer\n");
 130                                         goto err;
 131                                 }
 132                         }
 133                         break;
 134
 135                 case 'f':
 136                         if(isspace(line[1])) {
 137                                 /* face */
 138                                 char *ptr = line + 2;
 139                                 struct facevertex fv;
 140                                 struct rbnode *node;
 141                                 int vsz = dynarr_size(varr);
 142                                 int tsz = dynarr_size(tarr);
 143                                 int nsz = dynarr_size(narr);
 144
 145                                 for(i=0; i<4; i++) {
 146                                         if(!(ptr = parse_face_vert(ptr, &fv, vsz, tsz, nsz))) {
 147                                                 if(i < 3 || found_quad) {
 148                                                         fprintf(stderr, "%s:%d: invalid face definition: \"%s\"\n", fname, line_num, line);
 149                                                         goto err;
 150                                                 } else {
 151                                                         break;
 152                                                 }
 153                                         }
 154
 155                                         if((node = rb_find(rbtree, &fv))) {
 156                                                 uint16_t idx = (int)(intptr_t)node->data;
 157                                                 if(!(mesh->iarr = dynarr_push(mesh->iarr, &idx))) {
 158                                                         fprintf(stderr, "load_mesh: failed to resize index array\n");
 159                                                         goto err;
 160                                                 }
 161                                         } else {
 162                                                 uint16_t newidx = dynarr_size(mesh->varr);
 163                                                 struct g3d_vertex v;
 164                                                 struct facevertex *newfv;
 165
 166                                                 v.x = varr[fv.vidx].x;
 167                                                 v.y = varr[fv.vidx].y;
 168                                                 v.z = varr[fv.vidx].z;
 169                                                 v.w = 1.0f;
 170                                                 v.r = cround64(varr[fv.vidx].r * 255.0);
 171                                                 v.g = cround64(varr[fv.vidx].g * 255.0);
 172                                                 v.b = cround64(varr[fv.vidx].b * 255.0);
 173                                                 v.a = cround64(varr[fv.vidx].a * 255.0);
 174                                                 if(fv.tidx >= 0) {
 175                                                         v.u = tarr[fv.tidx].x;
 176                                                         v.v = tarr[fv.tidx].y;
 177                                                 } else {
 178                                                         v.u = v.x;
 179                                                         v.v = v.y;
 180                                                 }
 181                                                 if(fv.nidx >= 0) {
 182                                                         v.nx = narr[fv.nidx].x;
 183                                                         v.ny = narr[fv.nidx].y;
 184                                                         v.nz = narr[fv.nidx].z;
 185                                                 } else {
 186                                                         v.nx = v.ny = 0.0f;
 187                                                         v.nz = 1.0f;
 188                                                 }
 189
 190                                                 if(!(mesh->varr = dynarr_push(mesh->varr, &v))) {
 191                                                         fprintf(stderr, "load_mesh: failed to resize combined vertex array\n");
 192                                                         goto err;
 193                                                 }
 194                                                 if(!(mesh->iarr = dynarr_push(mesh->iarr, &newidx))) {
 195                                                         fprintf(stderr, "load_mesh: failed to resize index array\n");
 196                                                         goto err;
 197                                                 }
 198
 199                                                 if((newfv = malloc(sizeof *newfv))) {
 200                                                         *newfv = fv;
 201                                                 }
 202                                                 if(!newfv || rb_insert(rbtree, newfv, (void*)(intptr_t)newidx) == -1) {
 203                                                         fprintf(stderr, "load_mesh: failed to insert facevertex to the binary search tree\n");
 204                                                         goto err;
 205                                                 }
 206                                         }
 207                                 }
 208                                 if(i > 3) found_quad = 1;
 209                         }
 210                         break;
 211
 212                 default:
 213                         break;
 214                 }
 215         }
 216
 217         mesh->prim = found_quad ? G3D_QUADS : G3D_TRIANGLES;
 218         mesh->vcount = dynarr_size(mesh->varr);
 219         mesh->icount = dynarr_size(mesh->iarr);
 220         mesh->varr = dynarr_finalize(mesh->varr);
 221         mesh->iarr = dynarr_finalize(mesh->iarr);
 222         result = 0;     /* success */
 223
 224         printf("loaded %s mesh: %s: %d vertices, %d faces\n", found_quad ? "quad" : "triangle",
 225                         fname, mesh->vcount, mesh->icount / mesh->prim);
 226
 227 err:
 228         if(fp) fclose(fp);
 229         dynarr_free(varr);
 230         dynarr_free(narr);
 231         dynarr_free(tarr);
 232         if(result == -1) {
 233                 dynarr_free(mesh->varr);
 234                 dynarr_free(mesh->iarr);
 235         }
 236         rb_free(rbtree);
 237         return result;
 238 }
 239
 240 int save_mesh(struct g3d_mesh *mesh, const char *fname)
 241 {
 242         int i, fvcount;
 243         FILE *fp;
 244
 245         if(!(fp = fopen(fname, "wb"))) {
 246                 fprintf(stderr, "save_mesh: failed to open %s for writing\n", fname);
 247                 return -1;
 248         }
 249         fprintf(fp, "# Wavefront OBJ file shoved in your FACE by Mindlapse. Deal with it\n");
 250
 251         for(i=0; i<mesh->vcount; i++) {
 252                 struct g3d_vertex *v = mesh->varr + i;
 253                 fprintf(fp, "v %f %f %f %f %f %f %f\n", v->x, v->y, v->z, v->r / 255.0f, v->g / 255.0f,
 254                                 v->b / 255.0f, v->a / 255.0f);
 255         }
 256         for(i=0; i<mesh->vcount; i++) {
 257                 fprintf(fp, "vn %f %f %f\n", mesh->varr[i].nx, mesh->varr[i].ny, mesh->varr[i].nz);
 258         }
 259         for(i=0; i<mesh->vcount; i++) {
 260                 fprintf(fp, "vt %f %f\n", mesh->varr[i].u, mesh->varr[i].v);
 261         }
 262
 263         fvcount = mesh->prim;
 264         for(i=0; i<mesh->icount; i++) {
 265                 int idx = mesh->iarr[i] + 1;
 266
 267                 if(fvcount == mesh->prim) {
 268                         fprintf(fp, "\nf");
 269                         fvcount = 0;
 270                 }
 271                 fprintf(fp, " %d/%d/%d", idx, idx, idx);
 272                 ++fvcount;
 273         }
 274         fprintf(fp, "\n");
 275
 276         fclose(fp);
 277         return 0;
 278 }
 279
 280 static char *clean_line(char *s)
 281 {
 282         char *end;
 283
 284         while(*s && isspace(*s)) ++s;
 285         if(!*s) return 0;
 286
 287         end = s;
 288         while(*end && *end != '#') ++end;
 289         *end = 0;
 290
 291         while(end > s && isspace(*end)) --end;
 292         *end = 0;
 293
 294         return s;
 295 }
 296
 297 static char *parse_idx(char *ptr, int *idx, int arrsz)
 298 {
 299         char *endp;
 300         int val = strtol(ptr, &endp, 10);
 301         if(endp == ptr) return 0;
 302
 303         if(val < 0) {   /* convert negative indices */
 304                 *idx = arrsz + val;
 305         } else {
 306                 *idx = val - 1; /* indices in obj are 1-based */
 307         }
 308         return endp;
 309 }
 310
 311 /* possible face-vertex definitions:
 312  * 1. vertex
 313  * 2. vertex/texcoord
 314  * 3. vertex//normal
 315  * 4. vertex/texcoord/normal
 316  */
 317 static char *parse_face_vert(char *ptr, struct facevertex *fv, int numv, int numt, int numn)
 318 {
 319         if(!(ptr = parse_idx(ptr, &fv->vidx, numv)))
 320                 return 0;
 321         if(*ptr != '/') return (!*ptr || isspace(*ptr)) ? ptr : 0;
 322
 323         if(*++ptr == '/') {     /* no texcoord */
 324                 fv->tidx = -1;
 325                 ++ptr;
 326         } else {
 327                 if(!(ptr = parse_idx(ptr, &fv->tidx, numt)))
 328                         return 0;
 329                 if(*ptr != '/') return (!*ptr || isspace(*ptr)) ? ptr : 0;
 330                 ++ptr;
 331         }
 332
 333         if(!(ptr = parse_idx(ptr, &fv->nidx, numn)))
 334                 return 0;
 335         return (!*ptr || isspace(*ptr)) ? ptr : 0;
 336 }
 337
 338 static int cmp_facevert(const void *ap, const void *bp)
 339 {
 340         const struct facevertex *a = ap;
 341         const struct facevertex *b = bp;
 342
 343         if(a->vidx == b->vidx) {
 344                 if(a->tidx == b->tidx) {
 345                         return a->nidx - b->nidx;
 346                 }
 347                 return a->tidx - b->tidx;
 348         }
 349         return a->vidx - b->vidx;
 350 }
 351
 352 static void free_rbnode_key(struct rbnode *n, void *cls)
 353 {
 354         free(n->key);
 355 }