git.mutantstargoat.com Git - vrtris/blob - src/cmesh.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <float.h>
   4 #include <assert.h>
   5 #include "opengl.h"
   6 #include "cmesh.h"
   7 #include "logger.h"
   8
   9
  10 struct cmesh_vattrib {
  11         int nelem;      /* num elements per attribute [1, 4] */
  12         float *data;    /* dynarr */
  13         unsigned int vbo;
  14         int vbo_valid, data_valid;
  15 };
  16
  17
  18 struct cmesh {
  19         char *name;
  20         unsigned int nverts, nfaces;
  21
  22         /* current value for each attribute for the immediate mode interface */
  23         cgm_vec4 cur_val[CMESH_NUM_ATTR];
  24
  25         unsigned int buffer_objects[CMESH_NUM_ATTR + 1];
  26         struct cmesh_vattrib vattr[CMESH_NUM_ATTR];
  27
  28         unsigned int *idata;    /* dynarr */
  29         unsigned int ibo;
  30         int ibo_valid, idata_valid;
  31
  32         /* index buffer for wireframe rendering (constructed on demand) */
  33         unsigned int wire_ibo;
  34         int wire_ibo_valid;
  35
  36         /* axis-aligned bounding box */
  37         cgm_vec3 aabb_min, aabb_max;
  38         int aabb_valid;
  39         /* bounding sphere */
  40         cgm_vec3 bsph_center;
  41         float bsph_radius;
  42         int bsph_valid;
  43 };
  44
  45
  46 static int pre_draw(struct cmesh *cm);
  47 static void post_draw(struct cmesh *cm, int cur_sdr);
  48 static void update_buffers(struct cmesh *cm);
  49 static void update_wire_ibo(struct cmesh *cm);
  50 static void calc_aabb(struct cmesh *cm);
  51 static void calc_bsph(struct cmesh *cm);
  52
  53 static int def_nelem[CMESH_NUM_ATTR] = {3, 3, 3, 2, 4, 4, 4, 2};
  54
  55 static int sdr_loc[CMESH_NUM_ATTR] = {0, 1, 2, 3, 4, 5, 6, 7};
  56 static int use_custom_sdr_attr;
  57
  58
  59 /* global state */
  60 void cmesh_set_attrib_sdrloc(int attr, int loc)
  61 {
  62         sdr_loc[attr] = loc;
  63 }
  64
  65 int cmesh_get_attrib_sdrloc(int attr)
  66 {
  67         return sdr_loc[attr];
  68 }
  69
  70 void cmesh_clear_attrib_sdrloc(void)
  71 {
  72         int i;
  73         for(i=0; i<CMESH_NUM_ATTR; i++) {
  74                 sdr_loc[i] = -1;
  75         }
  76 }
  77
  78 /* mesh functions */
  79 struct cmesh *cmesh_alloc(void)
  80 {
  81         struct cmesh *cm;
  82
  83         if(!(cm = malloc(sizeof *cm))) {
  84                 return 0;
  85         }
  86         if(cmesh_init(cm) == -1) {
  87                 free(cm);
  88                 return 0;
  89         }
  90         return cm;
  91 }
  92
  93 void cmesh_free(struct cmesh *cm)
  94 {
  95         cmesh_destroy(cm);
  96         free(cm);
  97 }
  98
  99 int cmesh_init(struct cmesh *cm)
 100 {
 101         int i;
 102
 103         memset(cm, 0, sizeof *cm);
 104         cgm_wcons(cm->cur_val + CMESH_ATTR_COLOR, 1, 1, 1, 1);
 105
 106         glGenBuffers(CMESH_NUM_ATTR + 1, cm->buffer_objects);
 107
 108         for(i=0; i<CMESH_NUM_ATTR; i++) {
 109                 if(!(cm->vattr[i].data = dynarr_alloc(0, sizeof(float)))) {
 110                         cmesh_destroy(cm);
 111                         return -1;
 112                 }
 113                 cm->vattr[i].vbo = cm->buffer_objects[i];
 114         }
 115
 116         cm->ibo = cm->buffer_objects[CMESH_NUM_ATTR];
 117         if(!(cm->idata = dynarr_alloc(0, sizeof *cm->idata))) {
 118                 cmesh_destroy(cm);
 119                 return -1;
 120         }
 121         return 0;
 122 }
 123
 124 void cmesh_destroy(struct cmesh *cm)
 125 {
 126         int i;
 127
 128         free(cm->name);
 129
 130         for(i=0; i<CMESH_NUM_ATTR; i++) {
 131                 dynarr_free(cm->vattr[i].data);
 132         }
 133         dynarr_free(cm->idata);
 134
 135         glDeleteBuffers(CMESH_NUM_ATTR + 1, cm->buffer_objects);
 136         if(cm->wire_ibo) {
 137                 glDeleteBuffers(1, &cm->wire_ibo);
 138         }
 139 }
 140
 141 void cmesh_clear(struct cmesh *cm)
 142 {
 143         int i;
 144
 145         for(i=0; i<CMESH_NUM_ATTR; i++) {
 146                 cm->vattr[i].nelem = 0;
 147                 cm->vattr[i].vbo_valid = 0;
 148                 cm->vattr[i].data_valid = 0;
 149                 cm->vattr[i].data = dynarr_clear(cm->vattr[i].data);
 150         }
 151         cm->ibo_valid = cm->idata_valid = 0;
 152         cm->idata = dynarr_clear(cm->idata);
 153
 154         cm->wire_ibo_valid = 0;
 155         cm->nverts = cm->nfaces = 0;
 156
 157         cm->bsph_valid = cm->aabb_valid = 0;
 158 }
 159
 160 int cmesh_clone(struct cmesh *cmdest, struct cmesh *cmsrc)
 161 {
 162         int i, num, nelem;
 163         char *name = 0;
 164         float *varr[CMESH_NUM_ATTR] = {0};
 165         unsigned int *iarr = 0;
 166
 167         /* do anything that can fail first, before making any changes to cmdest
 168          * so we have the option of recovering gracefuly
 169          */
 170         if(cmsrc->name) {
 171                 if(!(name = malloc(strlen(cmsrc->name)))) {
 172                         return -1;
 173                 }
 174                 strcpy(name, cmsrc->name);
 175         }
 176         if(cmesh_indexed(cmsrc)) {
 177                 num = dynarr_size(cmsrc->idata);
 178                 if(!(iarr = dynarr_alloc(num, sizeof *iarr))) {
 179                         free(name);
 180                         return -1;
 181                 }
 182         }
 183         for(i=0; i<CMESH_NUM_ATTR; i++) {
 184                 if(cmesh_has_attrib(cmsrc, i)) {
 185                         nelem = cmsrc->vattr[i].nelem;
 186                         num = dynarr_size(cmsrc->vattr[i].data);
 187                         if(!(varr[i] = dynarr_alloc(num * nelem, sizeof(float)))) {
 188                                 while(--i >= 0) {
 189                                         dynarr_free(varr[i]);
 190                                 }
 191                                 dynarr_free(iarr);
 192                                 free(name);
 193                                 return -1;
 194                         }
 195                 }
 196         }
 197
 198         cmesh_clear(cmdest);
 199
 200         for(i=0; i<CMESH_NUM_ATTR; i++) {
 201                 dynarr_free(cmdest->vattr[i].data);
 202
 203                 if(cmesh_has_attrib(cmsrc, i)) {
 204                         cmesh_attrib(cmsrc, i); /* force validation of the actual data on the source mesh */
 205
 206                         nelem = cmsrc->vattr[i].nelem;
 207                         cmdest->vattr[i].nelem = nelem;
 208                         num = dynarr_size(cmsrc->vattr[i].data);
 209                         cmdest->vattr[i].data = varr[i];
 210                         memcpy(cmdest->vattr[i].data, cmsrc->vattr[i].data, num * nelem * sizeof(float));
 211                         cmdest->vattr[i].data_valid = 1;
 212                         cmdest->vattr[i].vbo_valid = 0;
 213                 } else {
 214                         memset(cmdest->vattr + i, 0, sizeof cmdest->vattr[i]);
 215                 }
 216         }
 217
 218         dynarr_free(cmdest->idata);
 219         if(cmesh_indexed(cmsrc)) {
 220                 cmesh_index(cmsrc);     /* force validation .... */
 221
 222                 num = dynarr_size(cmsrc->idata);
 223                 cmdest->idata = iarr;
 224                 memcpy(cmdest->idata, cmsrc->idata, num * sizeof *cmdest->idata);
 225                 cmdest->idata_valid = 1;
 226         } else {
 227                 cmdest->idata = 0;
 228                 cmdest->idata_valid = cmdest->ibo_valid = 0;
 229         }
 230
 231         free(cmdest->name);
 232         cmdest->name = name;
 233
 234         cmdest->nverts = cmsrc->nverts;
 235         cmdest->nfaces = cmsrc->nfaces;
 236
 237         memcpy(cmdest->cur_val, cmsrc->cur_val, sizeof cmdest->cur_val);
 238
 239         cmdest->aabb_min = cmsrc->aabb_min;
 240         cmdest->aabb_max = cmsrc->aabb_max;
 241         cmdest->aabb_valid = cmsrc->aabb_valid;
 242         cmdest->bsph_center = cmsrc->bsph_center;
 243         cmdest->bsph_radius = cmsrc->bsph_radius;
 244         cmdest->bsph_valid = cmsrc->bsph_valid;
 245
 246         return 0;
 247 }
 248
 249 int cmesh_set_name(struct cmesh *cm, const char *name)
 250 {
 251         int len = strlen(name);
 252         char *tmp = malloc(len + 1);
 253         if(!tmp) return -1;
 254         free(cm->name);
 255         cm->name = tmp;
 256         memcpy(cm->name, name, len + 1);
 257         return 0;
 258 }
 259
 260 const char *cmesh_name(struct cmesh *cm)
 261 {
 262         return cm->name;
 263 }
 264
 265 int cmesh_has_attrib(struct cmesh *cm, int attr)
 266 {
 267         if(attr < 0 || attr >= CMESH_NUM_ATTR) {
 268                 return 0;
 269         }
 270         return cm->vattr[attr].vbo_valid | cm->vattr[attr].data_valid;
 271 }
 272
 273 int cmesh_indexed(struct cmesh *cm)
 274 {
 275         return cm->ibo_valid | cm->idata_valid;
 276 }
 277
 278 /* vdata can be 0, in which case only memory is allocated
 279  * returns pointer to the attribute array
 280  */
 281 float *cmesh_set_attrib(struct cmesh *cm, int attr, int nelem, unsigned int num,
 282                 const float *vdata)
 283 {
 284         float *newarr;
 285
 286         if(attr < 0 || attr >= CMESH_NUM_ATTR) {
 287                 return 0;
 288         }
 289         if(cm->nverts && num != cm->nverts) {
 290                 return 0;
 291         }
 292
 293         if(!(newarr = dynarr_alloc(num * nelem, sizeof *newarr))) {
 294                 return 0;
 295         }
 296         if(vdata) {
 297                 memcpy(newarr, vdata, num * nelem * sizeof *newarr);
 298         }
 299
 300         cm->nverts = num;
 301
 302         dynarr_free(cm->vattr[attr].data);
 303         cm->vattr[attr].data = newarr;
 304         cm->vattr[attr].nelem = nelem;
 305         cm->vattr[attr].data_valid = 1;
 306         cm->vattr[attr].vbo_valid = 0;
 307         return newarr;
 308 }
 309
 310 float *cmesh_attrib(struct cmesh *cm, int attr)
 311 {
 312         if(attr < 0 || attr >= CMESH_NUM_ATTR) {
 313                 return 0;
 314         }
 315         cm->vattr[attr].vbo_valid = 0;
 316         return (float*)cmesh_attrib_ro(cm, attr);
 317 }
 318
 319 const float *cmesh_attrib_ro(struct cmesh *cm, int attr)
 320 {
 321         float *tmp;
 322         int nelem;
 323
 324         if(attr < 0 || attr >= CMESH_NUM_ATTR) {
 325                 return 0;
 326         }
 327
 328         if(!cm->vattr[attr].data_valid) {
 329 #if GL_ES_VERSION_2_0
 330                 return 0;
 331 #else
 332                 if(!cm->vattr[attr].vbo_valid) {
 333                         return 0;
 334                 }
 335
 336                 /* local data copy unavailable, grab the data from the vbo */
 337                 nelem = cm->vattr[attr].nelem;
 338                 if(!(tmp = dynarr_resize(cm->vattr[attr].data, cm->nverts * nelem))) {
 339                         return 0;
 340                 }
 341                 cm->vattr[attr].data = tmp;
 342
 343                 glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[attr].vbo);
 344                 tmp = glMapBuffer(GL_ARRAY_BUFFER, GL_READ_ONLY);
 345                 memcpy(cm->vattr[attr].data, tmp, cm->nverts * nelem * sizeof(float));
 346                 glUnmapBuffer(GL_ARRAY_BUFFER);
 347
 348                 cm->vattr[attr].data_valid = 1;
 349 #endif
 350         }
 351         return cm->vattr[attr].data;
 352 }
 353
 354 float *cmesh_attrib_at(struct cmesh *cm, int attr, int idx)
 355 {
 356         float *vptr = cmesh_attrib(cm, attr);
 357         return vptr ? vptr + idx * cm->vattr[attr].nelem : 0;
 358 }
 359
 360 const float *cmesh_attrib_at_ro(struct cmesh *cm, int attr, int idx)
 361 {
 362         const float *vptr = cmesh_attrib_ro(cm, attr);
 363         return vptr ? vptr + idx * cm->vattr[attr].nelem : 0;
 364 }
 365
 366 int cmesh_attrib_count(struct cmesh *cm, int attr)
 367 {
 368         return cmesh_has_attrib(cm, attr) ? cm->nverts : 0;
 369 }
 370
 371 int cmesh_push_attrib(struct cmesh *cm, int attr, float *v)
 372 {
 373         float *vptr;
 374         int i, cursz, newsz;
 375
 376         if(!cm->vattr[attr].nelem) {
 377                 cm->vattr[attr].nelem = def_nelem[attr];
 378         }
 379
 380         cursz = dynarr_size(cm->vattr[attr].data);
 381         newsz = cursz + cm->vattr[attr].nelem;
 382         if(!(vptr = dynarr_resize(cm->vattr[attr].data, newsz))) {
 383                 return -1;
 384         }
 385         cm->vattr[attr].data = vptr;
 386         vptr += cursz;
 387
 388         for(i=0; i<cm->vattr[attr].nelem; i++) {
 389                 *vptr++ = *v++;
 390         }
 391         cm->vattr[attr].data_valid = 1;
 392         cm->vattr[attr].vbo_valid = 0;
 393
 394         if(attr == CMESH_ATTR_VERTEX) {
 395                 cm->nverts = newsz / cm->vattr[attr].nelem;
 396         }
 397         return 0;
 398 }
 399
 400 int cmesh_push_attrib1f(struct cmesh *cm, int attr, float x)
 401 {
 402         float v[4];
 403         v[0] = x;
 404         v[1] = v[2] = 0.0f;
 405         v[3] = 1.0f;
 406         return cmesh_push_attrib(cm, attr, v);
 407 }
 408
 409 int cmesh_push_attrib2f(struct cmesh *cm, int attr, float x, float y)
 410 {
 411         float v[4];
 412         v[0] = x;
 413         v[1] = y;
 414         v[2] = 0.0f;
 415         v[3] = 1.0f;
 416         return cmesh_push_attrib(cm, attr, v);
 417 }
 418
 419 int cmesh_push_attrib3f(struct cmesh *cm, int attr, float x, float y, float z)
 420 {
 421         float v[4];
 422         v[0] = x;
 423         v[1] = y;
 424         v[2] = z;
 425         v[3] = 1.0f;
 426         return cmesh_push_attrib(cm, attr, v);
 427 }
 428
 429 int cmesh_push_attrib4f(struct cmesh *cm, int attr, float x, float y, float z, float w)
 430 {
 431         float v[4];
 432         v[0] = x;
 433         v[1] = y;
 434         v[2] = z;
 435         v[3] = w;
 436         return cmesh_push_attrib(cm, attr, v);
 437 }
 438
 439 /* indices can be 0, in which case only memory is allocated
 440  * returns pointer to the index array
 441  */
 442 unsigned int *cmesh_set_index(struct cmesh *cm, int num, const unsigned int *indices)
 443 {
 444         unsigned int *tmp;
 445         int nidx = cm->nfaces * 3;
 446
 447         if(nidx && num != nidx) {
 448                 return 0;
 449         }
 450
 451         if(!(tmp = dynarr_alloc(num, sizeof *tmp))) {
 452                 return 0;
 453         }
 454         if(indices) {
 455                 memcpy(tmp, indices, num * sizeof *tmp);
 456         }
 457
 458         dynarr_free(cm->idata);
 459         cm->idata = tmp;
 460         cm->idata_valid = 1;
 461         cm->ibo_valid = 0;
 462         return tmp;
 463 }
 464
 465 unsigned int *cmesh_index(struct cmesh *cm)
 466 {
 467         cm->ibo_valid = 0;
 468         return (unsigned int*)cmesh_index_ro(cm);
 469 }
 470
 471 const unsigned int *cmesh_index_ro(struct cmesh *cm)
 472 {
 473         int nidx;
 474         unsigned int *tmp;
 475
 476         if(!cm->idata_valid) {
 477 #if GL_ES_VERSION_2_0
 478                 return 0;
 479 #else
 480                 if(!cm->ibo_valid) {
 481                         return 0;
 482                 }
 483
 484                 /* local copy is unavailable, grab the data from the ibo */
 485                 nidx = cm->nfaces * 3;
 486                 if(!(tmp = dynarr_alloc(nidx, sizeof *cm->idata))) {
 487                         return 0;
 488                 }
 489                 dynarr_free(cm->idata);
 490                 cm->idata = tmp;
 491
 492                 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cm->ibo);
 493                 tmp = glMapBuffer(GL_ELEMENT_ARRAY_BUFFER, GL_READ_ONLY);
 494                 memcpy(cm->idata, tmp, nidx * sizeof *cm->idata);
 495                 glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER);
 496
 497                 cm->idata_valid = 1;
 498 #endif
 499         }
 500         return cm->idata;
 501 }
 502
 503 int cmesh_index_count(struct cmesh *cm)
 504 {
 505         return cm->nfaces * 3;
 506 }
 507
 508 int cmesh_push_index(struct cmesh *cm, unsigned int idx)
 509 {
 510         unsigned int *iptr;
 511         if(!(iptr = dynarr_push(cm->idata, &idx))) {
 512                 return -1;
 513         }
 514         cm->idata = iptr;
 515         cm->idata_valid = 1;
 516         cm->ibo_valid = 0;
 517
 518         cm->nfaces = dynarr_size(cm->idata) / 3;
 519         return 0;
 520 }
 521
 522 int cmesh_poly_count(struct cmesh *cm)
 523 {
 524         if(cm->nfaces) {
 525                 return cm->nfaces;
 526         }
 527         if(cm->nverts) {
 528                 return cm->nverts / 3;
 529         }
 530         return 0;
 531 }
 532
 533 /* attr can be -1 to invalidate all attributes */
 534 void cmesh_invalidate_vbo(struct cmesh *cm, int attr)
 535 {
 536         int i;
 537
 538         if(attr >= CMESH_NUM_ATTR) {
 539                 return;
 540         }
 541
 542         if(attr < 0) {
 543                 for(i=0; i<CMESH_NUM_ATTR; i++) {
 544                         cm->vattr[i].vbo_valid = 0;
 545                 }
 546         } else {
 547                 cm->vattr[attr].vbo_valid = 0;
 548         }
 549 }
 550
 551 void cmesh_invalidate_index(struct cmesh *cm)
 552 {
 553         cm->ibo_valid = 0;
 554 }
 555
 556 int cmesh_append(struct cmesh *cmdest, struct cmesh *cmsrc)
 557 {
 558         int i, nelem, newsz, origsz, srcsz;
 559         float *vptr;
 560         unsigned int *iptr;
 561         unsigned int idxoffs;
 562
 563         if(!cmdest->nverts) {
 564                 return cmesh_clone(cmdest, cmsrc);
 565         }
 566
 567         for(i=0; i<CMESH_NUM_ATTR; i++) {
 568                 if(cmesh_has_attrib(cmdest, i) && cmesh_has_attrib(cmsrc, i)) {
 569                         /* force validation of the data arrays */
 570                         cmesh_attrib(cmdest, i);
 571                         cmesh_attrib_ro(cmsrc, i);
 572
 573                         assert(cmdest->vattr[i].nelem == cmsrc->vattr[i].nelem);
 574                         nelem = cmdest->vattr[i].nelem;
 575                         origsz = cmdest->nverts * nelem;
 576                         newsz = cmdest->nverts + cmsrc->nverts * nelem;
 577
 578                         if(!(vptr = dynarr_resize(cmdest->vattr[i].data, newsz))) {
 579                                 return -1;
 580                         }
 581                         memcpy(vptr + origsz, cmsrc->vattr[i].data, cmsrc->nverts * nelem * sizeof(float));
 582                         cmdest->vattr[i].data = vptr;
 583                 }
 584         }
 585
 586         if(cmesh_indexed(cmdest)) {
 587                 assert(cmesh_indexed(cmsrc));
 588                 /* force validation ... */
 589                 cmesh_index(cmdest);
 590                 cmesh_index_ro(cmsrc);
 591
 592                 idxoffs = cmdest->nverts;
 593                 origsz = dynarr_size(cmdest->idata);
 594                 srcsz = dynarr_size(cmsrc->idata);
 595                 newsz = origsz + srcsz;
 596
 597                 if(!(iptr = dynarr_resize(cmdest->idata, newsz))) {
 598                         return -1;
 599                 }
 600                 cmdest->idata = iptr;
 601
 602                 /* copy and fixup all the new indices */
 603                 iptr += origsz;
 604                 for(i=0; i<srcsz; i++) {
 605                         *iptr++ = cmsrc->idata[i] + idxoffs;
 606                 }
 607         }
 608
 609         cmdest->wire_ibo_valid = 0;
 610         cmdest->aabb_valid = 0;
 611         cmdest->bsph_valid = 0;
 612         return 0;
 613 }
 614
 615 /* assemble a complete vertex by adding all the useful attributes */
 616 int cmesh_vertex(struct cmesh *cm, float x, float y, float z)
 617 {
 618         int i, j;
 619
 620         cgm_wcons(cm->cur_val + CMESH_ATTR_VERTEX, x, y, z, 1.0f);
 621         cm->vattr[CMESH_ATTR_VERTEX].data_valid = 1;
 622         cm->vattr[CMESH_ATTR_VERTEX].nelem = 3;
 623
 624         for(i=0; i<CMESH_ATTR_VERTEX; i++) {
 625                 if(cm->vattr[i].data_valid) {
 626                         for(j=0; j<cm->vattr[CMESH_ATTR_VERTEX].nelem; j++) {
 627                                 float *tmp = dynarr_push(cm->vattr[i].data, &cm->cur_val[i].x + j);
 628                                 if(!tmp) return -1;
 629                                 cm->vattr[i].data = tmp;
 630                         }
 631                 }
 632                 cm->vattr[i].vbo_valid = 0;
 633                 cm->vattr[i].data_valid = 1;
 634         }
 635
 636         if(cm->idata_valid) {
 637                 cm->idata = dynarr_clear(cm->idata);
 638         }
 639         cm->ibo_valid = cm->idata_valid = 0;
 640         return 0;
 641 }
 642
 643 void cmesh_normal(struct cmesh *cm, float nx, float ny, float nz)
 644 {
 645         cgm_wcons(cm->cur_val + CMESH_ATTR_NORMAL, nx, ny, nz, 1.0f);
 646         cm->vattr[CMESH_ATTR_NORMAL].nelem = 3;
 647 }
 648
 649 void cmesh_tangent(struct cmesh *cm, float tx, float ty, float tz)
 650 {
 651         cgm_wcons(cm->cur_val + CMESH_ATTR_TANGENT, tx, ty, tz, 1.0f);
 652         cm->vattr[CMESH_ATTR_TANGENT].nelem = 3;
 653 }
 654
 655 void cmesh_texcoord(struct cmesh *cm, float u, float v, float w)
 656 {
 657         cgm_wcons(cm->cur_val + CMESH_ATTR_TEXCOORD, u, v, w, 1.0f);
 658         cm->vattr[CMESH_ATTR_TEXCOORD].nelem = 3;
 659 }
 660
 661 void cmesh_boneweights(struct cmesh *cm, float w1, float w2, float w3, float w4)
 662 {
 663         cgm_wcons(cm->cur_val + CMESH_ATTR_BONEWEIGHTS, w1, w2, w3, w4);
 664         cm->vattr[CMESH_ATTR_BONEWEIGHTS].nelem = 4;
 665 }
 666
 667 void cmesh_boneidx(struct cmesh *cm, int idx1, int idx2, int idx3, int idx4)
 668 {
 669         cgm_wcons(cm->cur_val + CMESH_ATTR_BONEIDX, idx1, idx2, idx3, idx4);
 670         cm->vattr[CMESH_ATTR_BONEIDX].nelem = 4;
 671 }
 672
 673 static float *get_vec4(struct cmesh *cm, int attr, int idx, cgm_vec4 *res)
 674 {
 675         int i;
 676         float *sptr, *dptr;
 677         cgm_wcons(res, 0, 0, 0, 1);
 678         if(!(sptr = cmesh_attrib_at(cm, attr, idx))) {
 679                 return 0;
 680         }
 681         dptr = &res->x;
 682
 683         for(i=0; i<cm->vattr[attr].nelem; i++) {
 684                 *dptr++ = sptr[i];
 685         }
 686         return sptr;
 687 }
 688
 689 static float *get_vec3(struct cmesh *cm, int attr, int idx, cgm_vec3 *res)
 690 {
 691         int i;
 692         float *sptr, *dptr;
 693         cgm_vcons(res, 0, 0, 0);
 694         if(!(sptr = cmesh_attrib_at(cm, attr, idx))) {
 695                 return 0;
 696         }
 697         dptr = &res->x;
 698
 699         for(i=0; i<cm->vattr[attr].nelem; i++) {
 700                 *dptr++ = sptr[i];
 701         }
 702         return sptr;
 703 }
 704
 705 /* dir_xform can be null, in which case it's calculated from xform */
 706 void cmesh_apply_xform(struct cmesh *cm, float *xform, float *dir_xform)
 707 {
 708         unsigned int i;
 709         int j;
 710         cgm_vec4 v;
 711         cgm_vec3 n, t;
 712         float *vptr;
 713
 714         for(i=0; i<cm->nverts; i++) {
 715                 if(!(vptr = get_vec4(cm, CMESH_ATTR_VERTEX, i, &v))) {
 716                         return;
 717                 }
 718                 cgm_wmul_m4v4(&v, xform);
 719                 for(j=0; j<cm->vattr[CMESH_ATTR_VERTEX].nelem; j++) {
 720                         *vptr++ = (&v.x)[j];
 721                 }
 722
 723                 if(cmesh_has_attrib(cm, CMESH_ATTR_NORMAL)) {
 724                         if((vptr = get_vec3(cm, CMESH_ATTR_NORMAL, i, &n))) {
 725                                 cgm_vmul_m3v3(&n, dir_xform);
 726                                 for(j=0; j<cm->vattr[CMESH_ATTR_NORMAL].nelem; j++) {
 727                                         *vptr++ = (&n.x)[j];
 728                                 }
 729                         }
 730                 }
 731                 if(cmesh_has_attrib(cm, CMESH_ATTR_TANGENT)) {
 732                         if((vptr = get_vec3(cm, CMESH_ATTR_TANGENT, i, &t))) {
 733                                 cgm_vmul_m3v3(&t, dir_xform);
 734                                 for(j=0; j<cm->vattr[CMESH_ATTR_TANGENT].nelem; j++) {
 735                                         *vptr++ = (&t.x)[j];
 736                                 }
 737                         }
 738                 }
 739         }
 740 }
 741
 742 void cmesh_flip(struct cmesh *cm)
 743 {
 744         cmesh_flip_faces(cm);
 745         cmesh_flip_normals(cm);
 746 }
 747
 748 void cmesh_flip_faces(struct cmesh *cm)
 749 {
 750         int i, j, idxnum, vnum, nelem;
 751         unsigned int *indices;
 752         float *verts, *vptr;
 753
 754         if(cmesh_indexed(cm)) {
 755                 if(!(indices = cmesh_index(cm))) {
 756                         return;
 757                 }
 758                 idxnum = cmesh_index_count(cm);
 759                 for(i=0; i<idxnum; i+=3) {
 760                         unsigned int tmp = indices[i + 2];
 761                         indices[i + 2] = indices[i + 1];
 762                         indices[i + 1] = tmp;
 763                 }
 764         } else {
 765                 if(!(verts = cmesh_attrib(cm, CMESH_ATTR_VERTEX))) {
 766                         return;
 767                 }
 768                 vnum = cmesh_attrib_count(cm, CMESH_ATTR_VERTEX);
 769                 nelem = cm->vattr[CMESH_ATTR_VERTEX].nelem;
 770                 for(i=0; i<vnum; i+=3) {
 771                         for(j=0; j<nelem; j++) {
 772                                 vptr = verts + (i + 1) * nelem + j;
 773                                 float tmp = vptr[nelem];
 774                                 vptr[nelem] = vptr[0];
 775                                 vptr[0] = tmp;
 776                         }
 777                 }
 778         }
 779 }
 780 void cmesh_flip_normals(struct cmesh *cm)
 781 {
 782         int i, num;
 783         float *nptr = cmesh_attrib(cm, CMESH_ATTR_NORMAL);
 784         if(!nptr) return;
 785
 786         num = cm->nverts * cm->vattr[CMESH_ATTR_NORMAL].nelem;
 787         for(i=0; i<num; i++) {
 788                 *nptr = -*nptr;
 789                 nptr++;
 790         }
 791 }
 792
 793 int cmesh_explode(struct cmesh *cm)
 794 {
 795         int i, j, k, idxnum, nnverts;
 796         unsigned int *indices;
 797
 798         if(!cmesh_indexed(cm)) return 0;
 799
 800         indices = cmesh_index(cm);
 801         assert(indices);
 802
 803         idxnum = cmesh_index_count(cm);
 804         nnverts = idxnum;
 805
 806         for(i=0; i<CMESH_NUM_ATTR; i++) {
 807                 const float *srcbuf;
 808                 float *tmpbuf, *dstptr;
 809
 810                 if(!cmesh_has_attrib(cm, i)) continue;
 811
 812                 srcbuf = cmesh_attrib(cm, i);
 813                 if(!(tmpbuf = dynarr_alloc(nnverts * cm->vattr[i].nelem, sizeof(float)))) {
 814                         return -1;
 815                 }
 816                 dstptr = tmpbuf;
 817
 818                 for(j=0; j<idxnum; j++) {
 819                         unsigned int idx = indices[j];
 820                         const float *srcptr = srcbuf + idx * cm->vattr[i].nelem;
 821
 822                         for(k=0; k<cm->vattr[i].nelem; k++) {
 823                                 *dstptr++ = *srcptr++;
 824                         }
 825                 }
 826
 827                 dynarr_free(cm->vattr[i].data);
 828                 cm->vattr[i].data = tmpbuf;
 829                 cm->vattr[i].data_valid = 1;
 830         }
 831
 832         cm->ibo_valid = 0;
 833         cm->idata_valid = 0;
 834         cm->idata = dynarr_clear(cm->idata);
 835
 836         cm->nverts = nnverts;
 837         cm->nfaces = idxnum / 3;
 838         return 0;
 839 }
 840
 841 void cmesh_calc_face_normals(struct cmesh *cm)
 842 {
 843         /* TODO */
 844 }
 845
 846 static int pre_draw(struct cmesh *cm)
 847 {
 848         int i, loc, cur_sdr;
 849
 850         glGetIntegerv(GL_CURRENT_PROGRAM, &cur_sdr);
 851
 852         update_buffers(cm);
 853
 854         if(!cm->vattr[CMESH_ATTR_VERTEX].vbo_valid) {
 855                 return -1;
 856         }
 857
 858         if(cur_sdr && use_custom_sdr_attr) {
 859                 if(sdr_loc[CMESH_ATTR_VERTEX] == -1) {
 860                         return -1;
 861                 }
 862
 863                 for(i=0; i<CMESH_NUM_ATTR; i++) {
 864                         loc = sdr_loc[i];
 865                         if(loc >= 0 && cm->vattr[i].vbo_valid) {
 866                                 glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[i].vbo);
 867                                 glVertexAttribPointer(loc, cm->vattr[i].nelem, GL_FLOAT, GL_FALSE, 0, 0);
 868                                 glEnableVertexAttribArray(loc);
 869                         }
 870                 }
 871         } else {
 872 #ifndef GL_ES_VERSION_2_0
 873                 glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[CMESH_ATTR_VERTEX].vbo);
 874                 glVertexPointer(cm->vattr[CMESH_ATTR_VERTEX].nelem, GL_FLOAT, 0, 0);
 875                 glEnableClientState(GL_VERTEX_ARRAY);
 876
 877                 if(cm->vattr[CMESH_ATTR_NORMAL].vbo_valid) {
 878                         glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[CMESH_ATTR_NORMAL].vbo);
 879                         glNormalPointer(GL_FLOAT, 0, 0);
 880                         glEnableClientState(GL_NORMAL_ARRAY);
 881                 }
 882                 if(cm->vattr[CMESH_ATTR_TEXCOORD].vbo_valid) {
 883                         glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[CMESH_ATTR_TEXCOORD].vbo);
 884                         glTexCoordPointer(cm->vattr[CMESH_ATTR_TEXCOORD].nelem, GL_FLOAT, 0, 0);
 885                         glEnableClientState(GL_TEXTURE_COORD_ARRAY);
 886                 }
 887                 if(cm->vattr[CMESH_ATTR_COLOR].vbo_valid) {
 888                         glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[CMESH_ATTR_COLOR].vbo);
 889                         glColorPointer(cm->vattr[CMESH_ATTR_COLOR].nelem, GL_FLOAT, 0, 0);
 890                         glEnableClientState(GL_COLOR_ARRAY);
 891                 }
 892                 if(cm->vattr[CMESH_ATTR_TEXCOORD2].vbo_valid) {
 893                         glClientActiveTexture(GL_TEXTURE1);
 894                         glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[CMESH_ATTR_TEXCOORD2].vbo);
 895                         glTexCoordPointer(cm->vattr[CMESH_ATTR_TEXCOORD2].nelem, GL_FLOAT, 0, 0);
 896                         glEnableClientState(GL_TEXTURE_COORD_ARRAY);
 897                         glClientActiveTexture(GL_TEXTURE0);
 898                 }
 899 #endif  /* GL_ES_VERSION_2_0 */
 900         }
 901         glBindBuffer(GL_ARRAY_BUFFER, 0);
 902         return cur_sdr;
 903 }
 904
 905 void cmesh_draw(struct cmesh *cm)
 906 {
 907         int cur_sdr;
 908
 909         if((cur_sdr = pre_draw(cm)) == -1) {
 910                 return;
 911         }
 912
 913         if(cm->ibo_valid) {
 914                 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cm->ibo);
 915                 glDrawElements(GL_TRIANGLES, cm->nfaces * 3, GL_UNSIGNED_INT, 0);
 916                 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
 917         } else {
 918                 glDrawArrays(GL_TRIANGLES, 0, cm->nverts);
 919         }
 920
 921         post_draw(cm, cur_sdr);
 922 }
 923
 924 static void post_draw(struct cmesh *cm, int cur_sdr)
 925 {
 926         int i;
 927
 928         if(cur_sdr && use_custom_sdr_attr) {
 929                 for(i=0; i<CMESH_NUM_ATTR; i++) {
 930                         int loc = sdr_loc[i];
 931                         if(loc >= 0 && cm->vattr[i].vbo_valid) {
 932                                 glDisableVertexAttribArray(loc);
 933                         }
 934                 }
 935         } else {
 936 #ifndef GL_ES_VERSION_2_0
 937                 glDisableClientState(GL_VERTEX_ARRAY);
 938                 if(cm->vattr[CMESH_ATTR_NORMAL].vbo_valid) {
 939                         glDisableClientState(GL_NORMAL_ARRAY);
 940                 }
 941                 if(cm->vattr[CMESH_ATTR_TEXCOORD].vbo_valid) {
 942                         glDisableClientState(GL_TEXTURE_COORD_ARRAY);
 943                 }
 944                 if(cm->vattr[CMESH_ATTR_COLOR].vbo_valid) {
 945                         glDisableClientState(GL_COLOR_ARRAY);
 946                 }
 947                 if(cm->vattr[CMESH_ATTR_TEXCOORD2].vbo_valid) {
 948                         glClientActiveTexture(GL_TEXTURE1);
 949                         glDisableClientState(GL_TEXTURE_COORD_ARRAY);
 950                         glClientActiveTexture(GL_TEXTURE0);
 951                 }
 952 #endif  /* GL_ES_VERSION_2_0 */
 953         }
 954 }
 955
 956 void cmesh_draw_wire(struct cmesh *cm, float linesz)
 957 {
 958         int cur_sdr, nfaces;
 959
 960         if((cur_sdr = pre_draw(cm)) == -1) {
 961                 return;
 962         }
 963         update_wire_ibo(cm);
 964
 965         nfaces = cmesh_poly_count(cm);
 966         glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cm->wire_ibo);
 967         glDrawElements(GL_LINES, nfaces * 6, GL_UNSIGNED_INT, 0);
 968         glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
 969
 970         post_draw(cm, cur_sdr);
 971 }
 972
 973 void cmesh_draw_vertices(struct cmesh *cm, float ptsz)
 974 {
 975         int cur_sdr;
 976         if((cur_sdr = pre_draw(cm)) == -1) {
 977                 return;
 978         }
 979
 980         glPushAttrib(GL_POINT_BIT);
 981         glPointSize(ptsz);
 982         glDrawArrays(GL_POINTS, 0, cm->nverts);
 983         glPopAttrib();
 984
 985         post_draw(cm, cur_sdr);
 986 }
 987
 988 void cmesh_draw_normals(struct cmesh *cm, float len)
 989 {
 990 #ifndef GL_ES_VERSION_2_0
 991         int i, cur_sdr, vert_nelem, norm_nelem;
 992         int loc = -1;
 993         const float *varr, *norm;
 994
 995         varr = cmesh_attrib_ro(cm, CMESH_ATTR_VERTEX);
 996         norm = cmesh_attrib_ro(cm, CMESH_ATTR_NORMAL);
 997         if(!varr || !norm) return;
 998
 999         vert_nelem = cm->vattr[CMESH_ATTR_VERTEX].nelem;
1000         norm_nelem = cm->vattr[CMESH_ATTR_NORMAL].nelem;
1001
1002         glGetIntegerv(GL_CURRENT_PROGRAM, &cur_sdr);
1003         if(cur_sdr && use_custom_sdr_attr) {
1004                 if((loc = sdr_loc[CMESH_ATTR_VERTEX]) < 0) {
1005                         return;
1006                 }
1007         }
1008
1009         glBegin(GL_LINES);
1010         for(i=0; i<cm->nverts; i++) {
1011                 float x, y, z, endx, endy, endz;
1012
1013                 x = varr[i * vert_nelem];
1014                 y = varr[i * vert_nelem + 1];
1015                 z = varr[i * vert_nelem + 2];
1016                 endx = x + norm[i * norm_nelem] * len;
1017                 endy = y + norm[i * norm_nelem + 1] * len;
1018                 endz = z + norm[i * norm_nelem + 2] * len;
1019
1020                 if(loc == -1) {
1021                         glVertex3f(x, y, z);
1022                         glVertex3f(endx, endy, endz);
1023                 } else {
1024                         glVertexAttrib3f(loc, x, y, z);
1025                         glVertexAttrib3f(loc, endx, endy, endz);
1026                 }
1027         }
1028         glEnd();
1029 #endif  /* GL_ES_VERSION_2_0 */
1030 }
1031
1032 void cmesh_draw_tangents(struct cmesh *cm, float len)
1033 {
1034 #ifndef GL_ES_VERSION_2_0
1035         int i, cur_sdr, vert_nelem, tang_nelem;
1036         int loc = -1;
1037         const float *varr, *tang;
1038
1039         varr = cmesh_attrib_ro(cm, CMESH_ATTR_VERTEX);
1040         tang = cmesh_attrib_ro(cm, CMESH_ATTR_TANGENT);
1041         if(!varr || !tang) return;
1042
1043         vert_nelem = cm->vattr[CMESH_ATTR_VERTEX].nelem;
1044         tang_nelem = cm->vattr[CMESH_ATTR_TANGENT].nelem;
1045
1046         glGetIntegerv(GL_CURRENT_PROGRAM, &cur_sdr);
1047         if(cur_sdr && use_custom_sdr_attr) {
1048                 if((loc = sdr_loc[CMESH_ATTR_VERTEX]) < 0) {
1049                         return;
1050                 }
1051         }
1052
1053         glBegin(GL_LINES);
1054         for(i=0; i<cm->nverts; i++) {
1055                 float x, y, z, endx, endy, endz;
1056
1057                 x = varr[i * vert_nelem];
1058                 y = varr[i * vert_nelem + 1];
1059                 z = varr[i * vert_nelem + 2];
1060                 endx = x + tang[i * tang_nelem] * len;
1061                 endy = y + tang[i * tang_nelem + 1] * len;
1062                 endz = z + tang[i * tang_nelem + 2] * len;
1063
1064                 if(loc == -1) {
1065                         glVertex3f(x, y, z);
1066                         glVertex3f(endx, endy, endz);
1067                 } else {
1068                         glVertexAttrib3f(loc, x, y, z);
1069                         glVertexAttrib3f(loc, endx, endy, endz);
1070                 }
1071         }
1072         glEnd();
1073 #endif  /* GL_ES_VERSION_2_0 */
1074 }
1075
1076 static void update_buffers(struct cmesh *cm)
1077 {
1078         int i;
1079
1080         for(i=0; i<CMESH_NUM_ATTR; i++) {
1081                 if(cmesh_has_attrib(cm, i) && !cm->vattr[i].vbo_valid) {
1082                         glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[i].vbo);
1083                         glBufferData(GL_ARRAY_BUFFER, cm->nverts * cm->vattr[i].nelem * sizeof(float),
1084                                         cm->vattr[i].data, GL_STATIC_DRAW);
1085                         cm->vattr[i].vbo_valid = 1;
1086                 }
1087         }
1088         glBindBuffer(GL_ARRAY_BUFFER, 0);
1089
1090         if(cm->idata_valid && !cm->ibo_valid) {
1091                 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cm->ibo);
1092                 glBufferData(GL_ELEMENT_ARRAY_BUFFER, cm->nfaces * 3 * sizeof(unsigned int),
1093                                 cm->idata, GL_STATIC_DRAW);
1094                 cm->ibo_valid = 1;
1095                 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
1096         }
1097 }
1098
1099 static void update_wire_ibo(struct cmesh *cm)
1100 {
1101         int i, num_faces;
1102         unsigned int *wire_idxarr, *dest;
1103
1104         update_buffers(cm);
1105
1106         if(cm->wire_ibo_valid) return;
1107
1108         if(!cm->wire_ibo) {
1109                 glGenBuffers(1, &cm->wire_ibo);
1110         }
1111         num_faces = cmesh_poly_count(cm);
1112
1113         if(!(wire_idxarr = malloc(num_faces * 6 * sizeof *wire_idxarr))) {
1114                 return;
1115         }
1116         dest = wire_idxarr;
1117
1118         if(cm->ibo_valid) {
1119                 /* we're dealing with an indexed mesh */
1120                 const unsigned int *idxarr = cmesh_index_ro(cm);
1121
1122                 for(i=0; i<num_faces; i++) {
1123                         *dest++ = idxarr[0];
1124                         *dest++ = idxarr[1];
1125                         *dest++ = idxarr[1];
1126                         *dest++ = idxarr[2];
1127                         *dest++ = idxarr[2];
1128                         *dest++ = idxarr[0];
1129                         idxarr += 3;
1130                 }
1131         } else {
1132                 /* not an indexed mesh */
1133                 for(i=0; i<num_faces; i++) {
1134                         int vidx = i * 3;
1135                         *dest++ = vidx;
1136                         *dest++ = vidx + 1;
1137                         *dest++ = vidx + 1;
1138                         *dest++ = vidx + 2;
1139                         *dest++ = vidx + 2;
1140                         *dest++ = vidx;
1141                 }
1142         }
1143
1144         glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cm->wire_ibo);
1145         glBufferData(GL_ELEMENT_ARRAY_BUFFER, num_faces * 6 * sizeof(unsigned int),
1146                         wire_idxarr, GL_STATIC_DRAW);
1147         free(wire_idxarr);
1148         cm->wire_ibo_valid = 1;
1149         glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
1150 }
1151
1152 static void calc_aabb(struct cmesh *cm)
1153 {
1154         int i, j;
1155
1156         if(!cmesh_attrib_ro(cm, CMESH_ATTR_VERTEX)) {
1157                 return;
1158         }
1159
1160         cgm_vcons(&cm->aabb_min, FLT_MAX, FLT_MAX, FLT_MAX);
1161         cgm_vcons(&cm->aabb_max, -FLT_MAX, -FLT_MAX, -FLT_MAX);
1162
1163         for(i=0; i<cm->nverts; i++) {
1164                 const float *v = cmesh_attrib_at_ro(cm, CMESH_ATTR_VERTEX, i);
1165                 for(j=0; j<3; j++) {
1166                         if(v[j] < (&cm->aabb_min.x)[j]) {
1167                                 (&cm->aabb_min.x)[j] = v[j];
1168                         }
1169                         if(v[j] > (&cm->aabb_max.x)[j]) {
1170                                 (&cm->aabb_max.x)[j] = v[j];
1171                         }
1172                 }
1173         }
1174         cm->aabb_valid = 1;
1175 }
1176
1177 void cmesh_aabbox(struct cmesh *cm, cgm_vec3 *vmin, cgm_vec3 *vmax)
1178 {
1179         if(!cm->aabb_valid) {
1180                 calc_aabb(cm);
1181         }
1182         *vmin = cm->aabb_min;
1183         *vmax = cm->aabb_max;
1184 }
1185
1186 static void calc_bsph(struct cmesh *cm)
1187 {
1188         int i;
1189         float s, dist_sq;
1190
1191         if(!cmesh_attrib_ro(cm, CMESH_ATTR_VERTEX)) {
1192                 return;
1193         }
1194
1195         cgm_vcons(&cm->bsph_center, 0, 0, 0);
1196
1197         /* first find the center */
1198         for(i=0; i<cm->nverts; i++) {
1199                 const float *v = cmesh_attrib_at_ro(cm, CMESH_ATTR_VERTEX, i);
1200                 cm->bsph_center.x += v[0];
1201                 cm->bsph_center.y += v[1];
1202                 cm->bsph_center.z += v[2];
1203         }
1204         s = 1.0f / (float)cm->nverts;
1205         cm->bsph_center.x *= s;
1206         cm->bsph_center.y *= s;
1207         cm->bsph_center.z *= s;
1208
1209         cm->bsph_radius = 0.0f;
1210         for(i=0; i<cm->nverts; i++) {
1211                 const cgm_vec3 *v = (const cgm_vec3*)cmesh_attrib_at_ro(cm, CMESH_ATTR_VERTEX, i);
1212                 if((dist_sq = cgm_vdist_sq(v, &cm->bsph_center)) > cm->bsph_radius) {
1213                         cm->bsph_radius = dist_sq;
1214                 }
1215         }
1216         cm->bsph_radius = sqrt(cm->bsph_radius);
1217         cm->bsph_valid = 1;
1218 }
1219
1220 float cmesh_bsphere(struct cmesh *cm, cgm_vec3 *center, float *rad)
1221 {
1222         if(!cm->bsph_valid) {
1223                 calc_bsph(cm);
1224         }
1225         *center = cm->bsph_center;
1226         *rad = cm->bsph_radius;
1227         return cm->bsph_radius;
1228 }
1229
1230 /* TODO */
1231 void cmesh_texcoord_apply_xform(struct cmesh *cm, float *xform);
1232 void cmesh_texcoord_gen_plane(struct cmesh *cm, cgm_vec3 *norm, cgm_vec3 *tang);
1233 void cmesh_texcoord_gen_box(struct cmesh *cm);
1234 void cmesh_texcoord_gen_cylinder(struct cmesh *cm);
1235
1236 int cmesh_dump(struct cmesh *cm, const char *fname)
1237 {
1238         FILE *fp = fopen(fname, "wb");
1239         if(fp) {
1240                 int res = cmesh_dump_file(cm, fp);
1241                 fclose(fp);
1242                 return res;
1243         }
1244         return -1;
1245 }
1246
1247 int cmesh_dump_file(struct cmesh *cm, FILE *fp)
1248 {
1249         static const char *label[] = { "pos", "nor", "tan", "tex", "col", "bw", "bid", "tex2" };
1250         static const char *elemfmt[] = { 0, " %s(%g)", " %s(%g, %g)", " %s(%g, %g, %g)", " %s(%g, %g, %g, %g)", 0 };
1251         int i, j;
1252
1253         if(!cmesh_has_attrib(cm, CMESH_ATTR_VERTEX)) {
1254                 return -1;
1255         }
1256
1257         fprintf(fp, "VERTEX ATTRIBUTES\n");
1258
1259         for(i=0; i<cm->nverts; i++) {
1260                 fprintf(fp, "%5u:", i);
1261                 for(j=0; j<CMESH_NUM_ATTR; j++) {
1262                         if(cmesh_has_attrib(cm, j)) {
1263                                 const float *v = cmesh_attrib_at_ro(cm, j, i);
1264                                 int nelem = cm->vattr[j].nelem;
1265                                 fprintf(fp, elemfmt[nelem], label[j], v[0], nelem > 1 ? v[1] : 0.0f,
1266                                                 nelem > 2 ? v[2] : 0.0f, nelem > 3 ? v[3] : 0.0f);
1267                         }
1268                 }
1269                 fputc('\n', fp);
1270         }
1271
1272         if(cmesh_indexed(cm)) {
1273                 const unsigned int *idx = cmesh_index_ro(cm);
1274                 int numidx = cmesh_index_count(cm);
1275                 int numtri = numidx / 3;
1276                 assert(numidx % 3 == 0);
1277
1278                 fprintf(fp, "FACES\n");
1279
1280                 for(i=0; i<numtri; i++) {
1281                         fprintf(fp, "%5d: %d %d %d\n", i, idx[0], idx[1], idx[2]);
1282                         idx += 3;
1283                 }
1284         }
1285         return 0;
1286 }
1287
1288 int cmesh_dump_obj(struct cmesh *cm, const char *fname)
1289 {
1290         FILE *fp = fopen(fname, "wb");
1291         if(fp) {
1292                 int res = cmesh_dump_obj_file(cm, fp, 0);
1293                 fclose(fp);
1294                 return res;
1295         }
1296         return -1;
1297 }
1298
1299 int cmesh_dump_obj_file(struct cmesh *cm, FILE *fp, int voffs)
1300 {
1301         int i, j, num, nelem;
1302
1303         if(!cmesh_has_attrib(cm, CMESH_ATTR_VERTEX)) {
1304                 return -1;
1305         }
1306
1307
1308         nelem = cm->vattr[CMESH_ATTR_VERTEX].nelem;
1309         if((num = dynarr_size(cm->vattr[CMESH_ATTR_VERTEX].data)) != cm->nverts * nelem) {
1310                 warning_log("vertex array size (%d) != nverts (%d)\n", num, cm->nverts);
1311         }
1312         for(i=0; i<cm->nverts; i++) {
1313                 const float *v = cmesh_attrib_at_ro(cm, CMESH_ATTR_VERTEX, i);
1314                 fprintf(fp, "v %f %f %f\n", v[0], nelem > 1 ? v[1] : 0.0f, nelem > 2 ? v[2] : 0.0f);
1315         }
1316
1317         if(cmesh_has_attrib(cm, CMESH_ATTR_NORMAL)) {
1318                 nelem = cm->vattr[CMESH_ATTR_NORMAL].nelem;
1319                 if((num = dynarr_size(cm->vattr[CMESH_ATTR_NORMAL].data)) != cm->nverts * nelem) {
1320                         warning_log("normal array size (%d) != nverts (%d)\n", num, cm->nverts);
1321                 }
1322                 for(i=0; i<cm->nverts; i++) {
1323                         const float *v = cmesh_attrib_at_ro(cm, CMESH_ATTR_NORMAL, i);
1324                         fprintf(fp, "vn %f %f %f\n", v[0], nelem > 1 ? v[1] : 0.0f, nelem > 2 ? v[2] : 0.0f);
1325                 }
1326         }
1327
1328         if(cmesh_has_attrib(cm, CMESH_ATTR_TEXCOORD)) {
1329                 nelem = cm->vattr[CMESH_ATTR_TEXCOORD].nelem;
1330                 if((num = dynarr_size(cm->vattr[CMESH_ATTR_TEXCOORD].data)) != cm->nverts * nelem) {
1331                         warning_log("texcoord array size (%d) != nverts (%d)\n", num, cm->nverts);
1332                 }
1333                 for(i=0; i<cm->nverts; i++) {
1334                         const float *v = cmesh_attrib_at_ro(cm, CMESH_ATTR_TEXCOORD, i);
1335                         fprintf(fp, "vt %f %f\n", v[0], nelem > 1 ? v[1] : 0.0f);
1336                 }
1337         }
1338
1339         if(cmesh_indexed(cm)) {
1340                 const unsigned int *idxptr = cmesh_index_ro(cm);
1341                 int numidx = cmesh_index_count(cm);
1342                 int numtri = numidx / 3;
1343                 assert(numidx % 3 == 0);
1344
1345                 for(i=0; i<numtri; i++) {
1346                         fputc('f', fp);
1347                         for(j=0; j<3; j++) {
1348                                 unsigned int idx = *idxptr++ + 1 + voffs;
1349                                 fprintf(fp, " %u/%u/%u", idx, idx, idx);
1350                         }
1351                         fputc('\n', fp);
1352                 }
1353         } else {
1354                 int numtri = cm->nverts / 3;
1355                 unsigned int idx = 1 + voffs;
1356                 for(i=0; i<numtri; i++) {
1357                         fputc('f', fp);
1358                         for(j=0; j<3; j++) {
1359                                 fprintf(fp, " %u/%u/%u", idx, idx, idx);
1360                                 ++idx;
1361                         }
1362                         fputc('\n', fp);
1363                 }
1364         }
1365         return 0;
1366 }