git.mutantstargoat.com Git - vrlugburz/blob - src/scenefile.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <ctype.h>
   4 #include <assert.h>
   5 #include "cgmath/cgmath.h"
   6 #include "scenefile.h"
   7 #include "rbtree.h"
   8
   9 struct facevertex {
  10         int vidx, tidx, nidx;
  11 };
  12
  13 struct objmtl {
  14         char *name;
  15         cgm_vec3 ka, kd, ks, ke;
  16         float shin;
  17         float alpha;
  18         float ior;
  19         char *map_kd, *map_ke, *map_alpha;
  20         struct objmtl *next;
  21 };
  22
  23 static int proc_facevert(struct mesh *mesh, struct facevertex *fv,
  24                 cgm_vec3 *varr, cgm_vec3 *narr, cgm_vec2 *tarr, struct rbtree *rbtree);
  25
  26 static char *cleanline(char *s);
  27 static char *parse_idx(char *ptr, int *idx, int arrsz);
  28 static char *parse_face_vert(char *ptr, struct facevertex *fv, int numv, int numt, int numn);
  29
  30 static int load_mtllib(struct scenefile *scn, const char *path_prefix, const char *mtlfname);
  31 static void free_mtllist(struct material *mtl);
  32 static void conv_mtl(struct material *mm, struct objmtl *om, const char *path_prefix);
  33
  34 static int cmp_facevert(const void *ap, const void *bp);
  35 static void free_rbnode_key(struct rbnode *n, void *cls);
  36
  37 #define GROW_ARRAY(arr, sz)     \
  38         do { \
  39                 int newsz = (sz) ? (sz) * 2 : 16; \
  40                 void *tmp = realloc(arr, newsz * sizeof *(arr)); \
  41                 if(!tmp) { \
  42                         fprintf(stderr, "failed to grow array to %d\n", newsz); \
  43                         goto fail; \
  44                 } \
  45                 arr = tmp; \
  46                 sz = newsz; \
  47         } while(0)
  48
  49
  50 int load_scenefile(struct scenefile *scn, const char *fname)
  51 {
  52         int i, nlines, res = -1;
  53         FILE *fp;
  54         char buf[256], *line, *ptr, *path_prefix;
  55         int varr_size, varr_max, narr_size, narr_max, tarr_size, tarr_max;
  56         cgm_vec3 v, *varr = 0, *narr = 0;
  57         cgm_vec2 *tarr = 0;
  58         struct facevertex fv[4];
  59         struct mesh *mesh;
  60         struct material *mtl = 0;
  61         char *sep;
  62         struct rbtree *rbtree = 0;
  63
  64         memset(scn, 0, sizeof *scn);
  65
  66         varr_size = varr_max = narr_size = narr_max = tarr_size = tarr_max = 0;
  67         varr = narr = 0;
  68         tarr = 0;
  69
  70         if(!(fp = fopen(fname, "rb"))) {
  71                 fprintf(stderr, "load_scenefile: failed to open %s\n", fname);
  72                 return -1;
  73         }
  74
  75         if(!(rbtree = rb_create(cmp_facevert))) {
  76                 fprintf(stderr, "load_scenefile: failed to create facevertex search tree\n");
  77                 goto fail;
  78         }
  79         rb_set_delete_func(rbtree, free_rbnode_key, 0);
  80
  81         strcpy(buf, fname);
  82         if((sep = strrchr(buf, '/'))) {
  83                 sep[1] = 0;
  84         } else {
  85                 buf[0] = 0;
  86         }
  87         path_prefix = alloca(strlen(buf) + 1);
  88         strcpy(path_prefix, buf);
  89
  90         if(sep) {
  91                 sep = (char*)fname + (sep - buf);
  92         }
  93         if(!(scn->fname = strdup(sep ? sep + 1 : fname))) {
  94                 fprintf(stderr, "failed to allocate scenefile name buffer\n");
  95                 goto fail;
  96         }
  97
  98         if(!(mesh = malloc(sizeof *mesh))) {
  99                 fprintf(stderr, "failed to allocate mesh\n");
 100                 fclose(fp);
 101                 return -1;
 102         }
 103         init_mesh(mesh);
 104
 105         scn->meshlist = 0;
 106         scn->num_meshes = 0;
 107
 108         nlines = 0;
 109         while(fgets(buf, sizeof buf, fp)) {
 110                 nlines++;
 111                 if(!(line = cleanline(buf))) {
 112                         continue;
 113                 }
 114
 115                 switch(line[0]) {
 116                 case 'v':
 117                         v.x = v.y = v.z = 0.0f;
 118                         if(sscanf(line + 2, "%f %f %f", &v.x, &v.y, &v.z) < 2) {
 119                                 break;
 120                         }
 121                         if(isspace(line[1])) {
 122                                 if(varr_size >= varr_max) {
 123                                         GROW_ARRAY(varr, varr_max);
 124                                 }
 125                                 varr[varr_size++] = v;
 126                         } else if(line[1] == 't' && isspace(line[2])) {
 127                                 if(tarr_size >= tarr_max) {
 128                                         GROW_ARRAY(tarr, tarr_max);
 129                                 }
 130                                 tarr[tarr_size++] = *(cgm_vec2*)&v;
 131                         } else if(line[1] == 'n' && isspace(line[2])) {
 132                                 if(narr_size >= narr_max) {
 133                                         GROW_ARRAY(narr, narr_max);
 134                                 }
 135                                 narr[narr_size++] = v;
 136                         }
 137                         break;
 138
 139                 case 'f':
 140                         if(!isspace(line[1])) break;
 141
 142                         ptr = line + 2;
 143
 144                         for(i=0; i<3; i++) {
 145                                 if(!(ptr = parse_face_vert(ptr, fv + i, varr_size, tarr_size, narr_size))) {
 146                                         break;
 147                                 }
 148                                 if(proc_facevert(mesh, fv + i, varr, narr, tarr, rbtree) == -1) {
 149                                         break;
 150                                 }
 151                         }
 152
 153                         if(parse_face_vert(ptr, fv + 3, varr_size, tarr_size, narr_size)) {
 154                                 proc_facevert(mesh, fv, varr, narr, tarr, rbtree);
 155                                 proc_facevert(mesh, fv + 2, varr, narr, tarr, rbtree);
 156                                 proc_facevert(mesh, fv + 3, varr, narr, tarr, rbtree);
 157                         }
 158                         break;
 159
 160                 case 'o':
 161                 case 'g':
 162                         if(mesh->num_verts) {
 163                                 mesh->mtl = mtl;
 164                                 mesh->next = scn->meshlist;
 165                                 scn->meshlist = mesh;
 166                                 scn->num_meshes++;
 167
 168                                 if(!(mesh = malloc(sizeof *mesh))) {
 169                                         fprintf(stderr, "failed to allocate mesh\n");
 170                                         goto fail;
 171                                 }
 172                                 init_mesh(mesh);
 173                         }
 174                         break;
 175
 176                 case 'm':
 177                         if(memcmp(line, "mtllib", 6) == 0 && (line = cleanline(line + 6))) {
 178                                 free_mtllist(scn->mtllist);
 179                                 load_mtllib(scn, path_prefix, line);
 180                         }
 181                         break;
 182
 183                 case 'u':
 184                         if(memcmp(line, "usemtl", 6) == 0 && (line = cleanline(line + 6))) {
 185                                 mtl = scn->mtllist;
 186                                 while(mtl) {
 187                                         if(strcmp(mtl->name, line) == 0) {
 188                                                 break;
 189                                         }
 190                                         mtl = mtl->next;
 191                                 }
 192                         }
 193                         break;
 194
 195                 default:
 196                         break;
 197                 }
 198         }
 199
 200         if(mesh->num_verts) {
 201                 mesh->mtl = mtl;
 202                 mesh->next = scn->meshlist;
 203                 scn->meshlist = mesh;
 204                 scn->num_meshes++;
 205         } else {
 206                 free(mesh);
 207         }
 208         mesh = 0;
 209
 210         printf("load_scenefile %s: loaded %d meshes, %d vertices\n", scn->fname,
 211                         scn->num_meshes, varr_size);
 212
 213         res = 0;
 214
 215         if(0) {
 216 fail:
 217                 free(scn->fname);
 218         }
 219
 220         fclose(fp);
 221         free(mesh);
 222         free(varr);
 223         free(narr);
 224         free(tarr);
 225         rb_free(rbtree);
 226         return res;
 227 }
 228
 229 static int proc_facevert(struct mesh *mesh, struct facevertex *fv,
 230                 cgm_vec3 *varr, cgm_vec3 *narr, cgm_vec2 *tarr, struct rbtree *rbtree)
 231 {
 232         struct rbnode *node;
 233         unsigned int idx, newidx;
 234         struct facevertex *newfv;
 235         struct vertex v;
 236
 237         if((node = rb_find(rbtree, &fv))) {
 238                 idx = (unsigned int)node->data;
 239                 assert(idx < mesh->num_verts);
 240         } else {
 241                 newidx = mesh->num_verts;
 242
 243                 v.pos = varr[fv->vidx];
 244                 if(fv->nidx >= 0) {
 245                         v.norm = narr[fv->nidx];
 246                 }
 247                 if(fv->tidx >= 0) {
 248                         v.tex = tarr[fv->tidx];
 249                 }
 250                 add_mesh_vertex(mesh, &v);
 251                 add_mesh_index(mesh, newidx);
 252         }
 253
 254         if((newfv = malloc(sizeof *newfv))) {
 255                 *newfv = *fv;
 256         }
 257         if(!newfv || rb_insert(rbtree, newfv, (void*)newidx) == -1) {
 258                 fprintf(stderr, "load_scenefile: failed to insert facevertex to rbtree\n");
 259                 free(newfv);
 260                 return -1;
 261         }
 262         return 0;
 263 }
 264
 265 void destroy_scenefile(struct scenefile *scn)
 266 {
 267         struct mesh *m;
 268         while(scn->meshlist) {
 269                 m = scn->meshlist;
 270                 scn->meshlist = scn->meshlist->next;
 271                 free(m);
 272         }
 273 }
 274
 275 static char *cleanline(char *s)
 276 {
 277         char *ptr;
 278
 279         if((ptr = strchr(s, '#'))) *ptr = 0;
 280
 281         while(*s && isspace(*s)) s++;
 282         ptr = s + strlen(s) - 1;
 283         while(ptr >= s && isspace(*ptr)) *ptr-- = 0;
 284
 285         return *s ? s : 0;
 286 }
 287
 288 static char *parse_idx(char *ptr, int *idx, int arrsz)
 289 {
 290         char *endp;
 291         int val = strtol(ptr, &endp, 10);
 292         if(endp == ptr) return 0;
 293
 294         if(val < 0) {   /* convert negative indices */
 295                 *idx = arrsz + val;
 296         } else {
 297                 *idx = val - 1; /* indices in obj are 1-based */
 298         }
 299         return endp;
 300 }
 301
 302 /* possible face-vertex definitions:
 303  * 1. vertex
 304  * 2. vertex/texcoord
 305  * 3. vertex//normal
 306  * 4. vertex/texcoord/normal
 307  */
 308 static char *parse_face_vert(char *ptr, struct facevertex *fv, int numv, int numt, int numn)
 309 {
 310         fv->tidx = fv->nidx = -1;
 311
 312         if(!(ptr = parse_idx(ptr, &fv->vidx, numv)))
 313                 return 0;
 314         if(*ptr != '/') return (!*ptr || isspace(*ptr)) ? ptr : 0;
 315
 316         if(*++ptr == '/') {     /* no texcoord */
 317                 ++ptr;
 318         } else {
 319                 if(!(ptr = parse_idx(ptr, &fv->tidx, numt)))
 320                         return 0;
 321                 if(*ptr != '/') return (!*ptr || isspace(*ptr)) ? ptr : 0;
 322                 ++ptr;
 323         }
 324
 325         if(!(ptr = parse_idx(ptr, &fv->nidx, numn)))
 326                 return 0;
 327         return (!*ptr || isspace(*ptr)) ? ptr : 0;
 328 }
 329
 330 static int load_mtllib(struct scenefile *scn, const char *path_prefix, const char *mtlfname)
 331 {
 332         FILE *fp;
 333         char buf[256], *line;
 334         struct objmtl om;
 335         struct material *mtl = 0;
 336
 337         if(path_prefix && *path_prefix) {
 338                 sprintf(buf, "%s/%s", path_prefix, mtlfname);
 339         } else {
 340                 strcpy(buf, mtlfname);
 341         }
 342
 343         if(!(fp = fopen(buf, "rb"))) {
 344                 return -1;
 345         }
 346
 347         while(fgets(buf, sizeof buf, fp)) {
 348                 if(!(line = cleanline(buf))) {
 349                         continue;
 350                 }
 351
 352                 if(memcmp(line, "newmtl", 6) == 0) {
 353                         if(mtl) {
 354                                 conv_mtl(mtl, &om, path_prefix);
 355                                 mtl->next = scn->mtllist;
 356                                 scn->mtllist = mtl;
 357                         }
 358                         mtl = calloc(1, sizeof *mtl);
 359
 360                         memset(&om, 0, sizeof om);
 361
 362                         if((line = cleanline(line + 6))) {
 363                                 om.name = strdup(line);
 364                         }
 365
 366                 } else if(memcmp(line, "Kd", 2) == 0) {
 367                         sscanf(line + 3, "%f %f %f", &om.kd.x, &om.kd.y, &om.kd.z);
 368                 } else if(memcmp(line, "Ks", 2) == 0) {
 369                         sscanf(line + 3, "%f %f %f", &om.ks.x, &om.ks.y, &om.ks.z);
 370                 } else if(memcmp(line, "Ke", 2) == 0) {
 371                         sscanf(line + 3, "%f %f %f", &om.ke.x, &om.ke.y, &om.ke.z);
 372                 } else if(memcmp(line, "Ni", 2) == 0) {
 373                         om.ior = atof(line + 3);
 374                 } else if(line[0] == 'd' && isspace(line[1])) {
 375                         om.alpha = atof(line + 2);
 376                 } else if(memcmp(line, "map_Kd", 6) == 0) {
 377                         if((line = cleanline(line + 6))) {
 378                                 om.map_kd = strdup(line);
 379                         }
 380                 } else if(memcmp(line, "map_Ke", 6) == 0) {
 381                         if((line = cleanline(line + 6))) {
 382                                 om.map_ke = strdup(line);
 383                         }
 384                 } else if(memcmp(line, "map_d", 5) == 0) {
 385                         if((line = cleanline(line + 5))) {
 386                                 om.map_alpha = strdup(line);
 387                         }
 388                 }
 389         }
 390
 391         if(mtl) {
 392                 conv_mtl(mtl, &om, path_prefix);
 393                 mtl->next = scn->mtllist;
 394                 scn->mtllist = mtl;
 395         }
 396
 397         fclose(fp);
 398         return 0;
 399 }
 400
 401 static void free_mtllist(struct material *mtl)
 402 {
 403         while(mtl) {
 404                 void *tmp = mtl;
 405                 mtl = mtl->next;
 406                 free(tmp);
 407         }
 408 }
 409
 410 static void conv_mtl(struct material *mm, struct objmtl *om, const char *path_prefix)
 411 {
 412         char *fname = 0, *suffix = 0;
 413         int len, prefix_len, maxlen = 0;
 414
 415         memset(mm, 0, sizeof *mm);
 416         mm->name = om->name;
 417         mm->color = om->kd;
 418         mm->spec = om->ks;
 419         mm->shininess = om->shin;
 420
 421         if(om->map_kd && (len = strlen(om->map_kd)) > maxlen) maxlen = len;
 422         if(om->map_ke && (len = strlen(om->map_ke)) > maxlen) maxlen = len;
 423         if(om->map_alpha && (len = strlen(om->map_alpha)) > maxlen) maxlen = len;
 424
 425         if(maxlen) {
 426                 prefix_len = strlen(path_prefix);
 427                 fname = alloca(maxlen + prefix_len + 2);
 428                 suffix = fname + prefix_len;
 429                 strcpy(fname, path_prefix);
 430         }
 431
 432         /*
 433         if(om->map_kd) {
 434                 strcpy(suffix, om->map_kd);
 435                 mm->tex[TEX_DIFFUSE] = get_image(fname);
 436         }
 437         */
 438 }
 439
 440 static int cmp_facevert(const void *ap, const void *bp)
 441 {
 442         const struct facevertex *a = ap;
 443         const struct facevertex *b = bp;
 444
 445         if(a->vidx == b->vidx) {
 446                 if(a->tidx == b->tidx) {
 447                         return a->nidx - b->nidx;
 448                 }
 449                 return a->tidx - b->tidx;
 450         }
 451         return a->vidx - b->vidx;
 452 }
 453
 454 static void free_rbnode_key(struct rbnode *n, void *cls)
 455 {
 456         free(n->key);
 457 }