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

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <assert.h>
   4 #include "opengl.h"
   5 #include "cmesh.h"
   6
   7
   8 struct cmesh_vattrib {
   9         int nelem;      /* num elements per attribute [1, 4] */
  10         float *data;    /* dynarr */
  11         unsigned int vbo;
  12         int vbo_valid, data_valid;
  13 };
  14
  15
  16 struct cmesh {
  17         char *name;
  18         unsigned int nverts, nfaces;
  19
  20         /* current value for each attribute for the immediate mode interface */
  21         cgm_vec4 cur_val[CMESH_NUM_ATTR];
  22
  23         unsigned int buffer_objects[CMESH_NUM_ATTR + 1];
  24         struct cmesh_vattrib vattr[CMESH_NUM_ATTR];
  25
  26         unsigned int *idata;    /* dynarr */
  27         unsigned int ibo;
  28         int ibo_valid, idata_valid;
  29
  30         /* index buffer for wireframe rendering (constructed on demand) */
  31         unsigned int wire_ibo;
  32         int wire_ibo_valid;
  33
  34         /* axis-aligned bounding box */
  35         cgm_vec3 aabb_min, aabb_max;
  36         int aabb_valid;
  37         /* bounding sphere */
  38         cgm_vec3 bsph_center;
  39         float bsph_radius;
  40         int bsph_valid;
  41 };
  42
  43 static int sdr_loc[CMESH_NUM_ATTR] = {0, 1, 2, 3, 4, 5, 6, 7};
  44
  45
  46 /* global state */
  47 void cmesh_set_attrib_sdrloc(int attr, int loc)
  48 {
  49         sdr_loc[attr] = loc;
  50 }
  51
  52 int cmesh_get_attrib_sdrloc(int attr)
  53 {
  54         return sdr_loc[attr];
  55 }
  56
  57 void cmesh_clear_attrib_sdrloc(void)
  58 {
  59         int i;
  60         for(i=0; i<CMESH_NUM_ATTR; i++) {
  61                 sdr_loc[i] = -1;
  62         }
  63 }
  64
  65 /* mesh functions */
  66 struct cmesh *cmesh_alloc(void)
  67 {
  68         struct cmesh *cm;
  69
  70         if(!(cm = malloc(sizeof *cm))) {
  71                 return 0;
  72         }
  73         if(cmesh_init(cm) == -1) {
  74                 free(cm);
  75                 return 0;
  76         }
  77         return cm;
  78 }
  79
  80 void cmesh_free(struct cmesh *cm)
  81 {
  82         cmesh_destroy(cm);
  83         free(cm);
  84 }
  85
  86 int cmesh_init(struct cmesh *cm)
  87 {
  88         int i;
  89
  90         memset(cm, 0, sizeof *cm);
  91         cgm_wcons(cm->cur_val + CMESH_ATTR_COLOR, 1, 1, 1, 1);
  92
  93         glGenBuffers(CMESH_NUM_ATTR + 1, cm->buffer_objects);
  94
  95         for(i=0; i<CMESH_NUM_ATTR; i++) {
  96                 if(!(cm->vattr[i].data = dynarr_alloc(0, sizeof(float)))) {
  97                         cmesh_destroy(cm);
  98                         return -1;
  99                 }
 100                 cm->vattr[i].vbo = cm->buffer_objects[i];
 101         }
 102
 103         cm->ibo = cm->buffer_objects[CMESH_NUM_ATTR];
 104         if(!(cm->idata = dynarr_alloc(0, sizeof *cm->idata))) {
 105                 cmesh_destroy(cm);
 106                 return -1;
 107         }
 108         return 0;
 109 }
 110
 111 void cmesh_destroy(struct cmesh *cm)
 112 {
 113         int i;
 114
 115         free(cm->name);
 116
 117         for(i=0; i<CMESH_NUM_ATTR; i++) {
 118                 dynarr_free(cm->vattr[i].data);
 119         }
 120         dynarr_free(cm->idata);
 121
 122         glDeleteBuffers(CMESH_NUM_ATTR + 1, cm->buffer_objects);
 123         if(cm->wire_ibo) {
 124                 glDeleteBuffers(1, &cm->wire_ibo);
 125         }
 126 }
 127
 128 void cmesh_clear(struct cmesh *cm)
 129 {
 130         int i;
 131
 132         for(i=0; i<CMESH_NUM_ATTR; i++) {
 133                 cm->vattr[i].nelem = 0;
 134                 cm->vattr[i].vbo_valid = 0;
 135                 cm->vattr[i].data_valid = 0;
 136                 cm->vattr[i].data = dynarr_clear(cm->vattr[i].data);
 137         }
 138         cm->ibo_valid = cm->idata_valid = 0;
 139         cm->idata = dynarr_clear(cm->idata);
 140
 141         cm->wire_ibo_valid = 0;
 142         cm->nverts = cm->nfaces = 0;
 143
 144         cm->bsph_valid = cm->aabb_valid = 0;
 145 }
 146
 147 int cmesh_clone(struct cmesh *cmdest, struct cmesh *cmsrc)
 148 {
 149         int i, num, nelem;
 150         char *name = 0;
 151         float *varr[CMESH_NUM_ATTR] = {0};
 152         unsigned int *iarr = 0;
 153
 154         /* do anything that can fail first, before making any changes to cmdest
 155          * so we have the option of recovering gracefuly
 156          */
 157         if(cmsrc->name) {
 158                 if(!(name = malloc(strlen(cmsrc->name)))) {
 159                         return -1;
 160                 }
 161                 strcpy(name, cmsrc->name);
 162         }
 163         if(cmesh_indexed(cmsrc)) {
 164                 num = dynarr_size(cmsrc->idata);
 165                 if(!(iarr = dynarr_alloc(num, sizeof *iarr))) {
 166                         free(name);
 167                         return -1;
 168                 }
 169         }
 170         for(i=0; i<CMESH_NUM_ATTR; i++) {
 171                 if(cmesh_has_attrib(cmsrc, i)) {
 172                         nelem = cmsrc->vattr[i].nelem;
 173                         num = dynarr_size(cmsrc->vattr[i].data);
 174                         if(!(varr[i] = dynarr_alloc(num * nelem, sizeof(float)))) {
 175                                 while(--i >= 0) {
 176                                         dynarr_free(varr[i]);
 177                                 }
 178                                 dynarr_free(iarr);
 179                                 free(name);
 180                                 return -1;
 181                         }
 182                 }
 183         }
 184
 185         cmesh_clear(cmdest);
 186
 187         for(i=0; i<CMESH_NUM_ATTR; i++) {
 188                 dynarr_free(cmdest->vattr[i].data);
 189
 190                 if(cmesh_has_attrib(cmsrc, i)) {
 191                         cmesh_attrib(cmsrc, i); /* force validation of the actual data on the source mesh */
 192
 193                         nelem = cmsrc->vattr[i].nelem;
 194                         cmdest->vattr[i].nelem = nelem;
 195                         num = dynarr_size(cmsrc->vattr[i].data);
 196                         cmdest->vattr[i].data = varr[i];
 197                         memcpy(cmdest->vattr[i].data, cmsrc->vattr[i].data, num * nelem * sizeof(float));
 198                         cmdest->vattr[i].data_valid = 1;
 199                         cmdest->vattr[i].vbo_valid = 0;
 200                 } else {
 201                         memset(cmdest->vattr + i, 0, sizeof cmdest->vattr[i]);
 202                 }
 203         }
 204
 205         dynarr_free(cmdest->idata);
 206         if(cmesh_indexed(cmsrc)) {
 207                 cmesh_index(cmsrc);     /* force validation .... */
 208
 209                 num = dynarr_size(cmsrc->idata);
 210                 cmdest->idata = iarr;
 211                 memcpy(cmdest->idata, cmsrc->idata, num * sizeof *cmdest->idata);
 212                 cmdest->idata_valid = 1;
 213         } else {
 214                 cmdest->idata = 0;
 215                 cmdest->idata_valid = cmdest->ibo_valid = 0;
 216         }
 217
 218         free(cmdest->name);
 219         cmdest->name = name;
 220
 221         cmdest->nverts = cmsrc->nverts;
 222         cmdest->nfaces = cmsrc->nfaces;
 223
 224         memcpy(cmdest->cur_val, cmsrc->cur_val, sizeof cmdest->cur_val);
 225
 226         cmdest->aabb_min = cmsrc->aabb_min;
 227         cmdest->aabb_max = cmsrc->aabb_max;
 228         cmdest->aabb_valid = cmsrc->aabb_valid;
 229         cmdest->bsph_center = cmsrc->bsph_center;
 230         cmdest->bsph_radius = cmsrc->bsph_radius;
 231         cmdest->bsph_valid = cmsrc->bsph_valid;
 232
 233         return 0;
 234 }
 235
 236 int cmesh_set_name(struct cmesh *cm, const char *name)
 237 {
 238         int len = strlen(name);
 239         char *tmp = malloc(len + 1);
 240         if(!tmp) return -1;
 241         free(cm->name);
 242         cm->name = tmp;
 243         memcpy(cm->name, name, len + 1);
 244         return 0;
 245 }
 246
 247 const char *cmesh_name(struct cmesh *cm)
 248 {
 249         return cm->name;
 250 }
 251
 252 int cmesh_has_attrib(struct cmesh *cm, int attr)
 253 {
 254         if(attr < 0 || attr >= CMESH_NUM_ATTR) {
 255                 return 0;
 256         }
 257         return cm->vattr[attr].vbo_valid | cm->vattr[attr].data_valid;
 258 }
 259
 260 int cmesh_indexed(struct cmesh *cm)
 261 {
 262         return cm->ibo_valid | cm->idata_valid;
 263 }
 264
 265 /* vdata can be 0, in which case only memory is allocated
 266  * returns pointer to the attribute array
 267  */
 268 float *cmesh_set_attrib(struct cmesh *cm, int attr, int nelem, unsigned int num,
 269                 const float *vdata)
 270 {
 271         float *newarr;
 272
 273         if(attr < 0 || attr >= CMESH_NUM_ATTR) {
 274                 return 0;
 275         }
 276         if(cm->nverts && num != cm->nverts) {
 277                 return 0;
 278         }
 279
 280         if(!(newarr = dynarr_alloc(num * nelem, sizeof *newarr))) {
 281                 return 0;
 282         }
 283         if(vdata) {
 284                 memcpy(newarr, vdata, num * nelem * sizeof *newarr);
 285         }
 286
 287         cm->nverts = num;
 288
 289         dynarr_free(cm->vattr[attr].data);
 290         cm->vattr[attr].data = newarr;
 291         cm->vattr[attr].nelem = nelem;
 292         cm->vattr[attr].data_valid = 1;
 293         cm->vattr[attr].vbo_valid = 0;
 294         return newarr;
 295 }
 296
 297 float *cmesh_attrib(struct cmesh *cm, int attr)
 298 {
 299         if(attr < 0 || attr >= CMESH_NUM_ATTR) {
 300                 return 0;
 301         }
 302         cm->vattr[attr].vbo_valid = 0;
 303         return (float*)cmesh_attrib_ro(cm, attr);
 304 }
 305
 306 const float *cmesh_attrib_ro(struct cmesh *cm, int attr)
 307 {
 308         float *tmp;
 309         int nelem;
 310
 311         if(attr < 0 || attr >= CMESH_NUM_ATTR) {
 312                 return 0;
 313         }
 314
 315         if(!cm->vattr[attr].data_valid) {
 316 #if GL_ES_VERSION_2_0
 317                 return 0;
 318 #else
 319                 if(!cm->vattr[attr].vbo_valid) {
 320                         return 0;
 321                 }
 322
 323                 /* local data copy unavailable, grab the data from the vbo */
 324                 nelem = cm->vattr[attr].nelem;
 325                 if(!(tmp = dynarr_resize(cm->vattr[attr].data, cm->nverts * nelem))) {
 326                         return 0;
 327                 }
 328                 cm->vattr[attr].data = tmp;
 329
 330                 glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[attr].vbo);
 331                 tmp = glMapBuffer(GL_ARRAY_BUFFER, GL_READ_ONLY);
 332                 memcpy(cm->vattr[attr].data, tmp, cm->nverts * nelem * sizeof(float));
 333                 glUnmapBuffer(GL_ARRAY_BUFFER);
 334
 335                 cm->vattr[attr].data_valid = 1;
 336 #endif
 337         }
 338         return cm->vattr[attr].data;
 339 }
 340
 341 float *cmesh_attrib_at(struct cmesh *cm, int attr, int idx)
 342 {
 343         float *vptr = cmesh_attrib(cm, attr);
 344         return vptr ? vptr + idx * cm->vattr[attr].nelem : 0;
 345 }
 346
 347 const float *cmesh_attrib_at_ro(struct cmesh *cm, int attr, int idx)
 348 {
 349         const float *vptr = cmesh_attrib_ro(cm, attr);
 350         return vptr ? vptr + idx * cm->vattr[attr].nelem : 0;
 351 }
 352
 353 int cmesh_attrib_count(struct cmesh *cm, int attr)
 354 {
 355         return cmesh_has_attrib(cm, attr) ? cm->nverts : 0;
 356 }
 357
 358 /* indices can be 0, in which case only memory is allocated
 359  * returns pointer to the index array
 360  */
 361 unsigned int *cmesh_set_index(struct cmesh *cm, int num, const unsigned int *indices)
 362 {
 363         unsigned int *tmp;
 364         int nidx = cm->nfaces * 3;
 365
 366         if(nidx && num != nidx) {
 367                 return 0;
 368         }
 369
 370         if(!(tmp = dynarr_alloc(num, sizeof *tmp))) {
 371                 return 0;
 372         }
 373         if(indices) {
 374                 memcpy(tmp, indices, num * sizeof *tmp);
 375         }
 376
 377         dynarr_free(cm->idata);
 378         cm->idata = tmp;
 379         cm->idata_valid = 1;
 380         cm->ibo_valid = 0;
 381         return tmp;
 382 }
 383
 384 unsigned int *cmesh_index(struct cmesh *cm)
 385 {
 386         cm->ibo_valid = 0;
 387         return (unsigned int*)cmesh_index_ro(cm);
 388 }
 389
 390 const unsigned int *cmesh_index_ro(struct cmesh *cm)
 391 {
 392         int nidx;
 393         unsigned int *tmp;
 394
 395         if(!cm->idata_valid) {
 396 #if GL_ES_VERSION_2_0
 397                 return 0;
 398 #else
 399                 if(!cm->ibo_valid) {
 400                         return 0;
 401                 }
 402
 403                 /* local copy is unavailable, grab the data from the ibo */
 404                 nidx = cm->nfaces * 3;
 405                 if(!(tmp = dynarr_alloc(nidx, sizeof *cm->idata))) {
 406                         return 0;
 407                 }
 408                 dynarr_free(cm->idata);
 409                 cm->idata = tmp;
 410
 411                 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cm->ibo);
 412                 tmp = glMapBuffer(GL_ELEMENT_ARRAY_BUFFER, GL_READ_ONLY);
 413                 memcpy(cm->idata, tmp, nidx * sizeof *cm->idata);
 414                 glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER);
 415
 416                 cm->idata_valid = 1;
 417 #endif
 418         }
 419         return cm->idata;
 420 }
 421
 422 int cmesh_index_count(struct cmesh *cm)
 423 {
 424         return cm->nfaces * 3;
 425 }
 426
 427 int get_poly_count(struct cmesh *cm)
 428 {
 429         if(cm->nfaces) {
 430                 return cm->nfaces;
 431         }
 432         if(cm->nverts) {
 433                 return cm->nverts / 3;
 434         }
 435         return 0;
 436 }
 437
 438 /* attr can be -1 to invalidate all attributes */
 439 void cmesh_invalidate_vbo(struct cmesh *cm, int attr)
 440 {
 441         int i;
 442
 443         if(attr >= CMESH_NUM_ATTR) {
 444                 return;
 445         }
 446
 447         if(attr < 0) {
 448                 for(i=0; i<CMESH_NUM_ATTR; i++) {
 449                         cm->vattr[i].vbo_valid = 0;
 450                 }
 451         } else {
 452                 cm->vattr[attr].vbo_valid = 0;
 453         }
 454 }
 455
 456 void cmesh_invalidate_index(struct cmesh *cm)
 457 {
 458         cm->ibo_valid = 0;
 459 }
 460
 461 int cmesh_append(struct cmesh *cmdest, struct cmesh *cmsrc)
 462 {
 463         int i, nelem, newsz, origsz, srcsz;
 464         float *vptr;
 465         unsigned int *iptr;
 466         unsigned int idxoffs;
 467
 468         if(!cmdest->nverts) {
 469                 return cmesh_clone(cmdest, cmsrc);
 470         }
 471
 472         for(i=0; i<CMESH_NUM_ATTR; i++) {
 473                 if(cmesh_has_attrib(cmdest, i) && cmesh_has_attrib(cmsrc, i)) {
 474                         /* force validation of the data arrays */
 475                         cmesh_attrib(cmdest, i);
 476                         cmesh_attrib_ro(cmsrc, i);
 477
 478                         assert(cmdest->vattr[i].nelem == cmsrc->vattr[i].nelem);
 479                         nelem = cmdest->vattr[i].nelem;
 480                         origsz = cmdest->nverts * nelem;
 481                         newsz = cmdest->nverts + cmsrc->nverts * nelem;
 482
 483                         if(!(vptr = dynarr_resize(cmdest->vattr[i].data, newsz))) {
 484                                 return -1;
 485                         }
 486                         memcpy(vptr + origsz, cmsrc->vattr[i].data, cmsrc->nverts * nelem * sizeof(float));
 487                         cmdest->vattr[i].data = vptr;
 488                 }
 489         }
 490
 491         if(cmesh_indexed(cmdest)) {
 492                 assert(cmesh_indexed(cmsrc));
 493                 /* force validation ... */
 494                 cmesh_index(cmdest);
 495                 cmesh_index_ro(cmsrc);
 496
 497                 idxoffs = cmdest->nverts;
 498                 origsz = dynarr_size(cmdest->idata);
 499                 srcsz = dynarr_size(cmsrc->idata);
 500                 newsz = origsz + srcsz;
 501
 502                 if(!(iptr = dynarr_resize(cmdest->idata, newsz))) {
 503                         return -1;
 504                 }
 505                 cmdest->idata = iptr;
 506
 507                 /* copy and fixup all the new indices */
 508                 iptr += origsz;
 509                 for(i=0; i<srcsz; i++) {
 510                         *iptr++ = cmsrc->idata[i] + idxoffs;
 511                 }
 512         }
 513
 514         cmdest->wire_ibo_valid = 0;
 515         cmdest->aabb_valid = 0;
 516         cmdest->bsph_valid = 0;
 517         return 0;
 518 }
 519
 520 /* assemble a complete vertex by adding all the useful attributes */
 521 int cmesh_vertex(struct cmesh *cm, float x, float y, float z)
 522 {
 523         int i, j;
 524
 525         cgm_wcons(cm->cur_val + CMESH_ATTR_VERTEX, x, y, z, 1.0f);
 526         cm->vattr[CMESH_ATTR_VERTEX].data_valid = 1;
 527         cm->vattr[CMESH_ATTR_VERTEX].nelem = 3;
 528
 529         for(i=0; i<CMESH_ATTR_VERTEX; i++) {
 530                 if(cm->vattr[i].data_valid) {
 531                         for(j=0; j<cm->vattr[CMESH_ATTR_VERTEX].nelem; j++) {
 532                                 float *tmp = dynarr_push(cm->vattr[i].data, &cm->cur_val[i].x + j);
 533                                 if(!tmp) return -1;
 534                                 cm->vattr[i].data = tmp;
 535                         }
 536                 }
 537                 cm->vattr[i].vbo_valid = 0;
 538                 cm->vattr[i].data_valid = 1;
 539         }
 540
 541         if(cm->idata_valid) {
 542                 cm->idata = dynarr_clear(cm->idata);
 543         }
 544         cm->ibo_valid = cm->idata_valid = 0;
 545         return 0;
 546 }
 547
 548 void cmesh_normal(struct cmesh *cm, float nx, float ny, float nz)
 549 {
 550         cgm_wcons(cm->cur_val + CMESH_ATTR_NORMAL, nx, ny, nz, 1.0f);
 551         cm->vattr[CMESH_ATTR_NORMAL].nelem = 3;
 552 }
 553
 554 void cmesh_tangent(struct cmesh *cm, float tx, float ty, float tz)
 555 {
 556         cgm_wcons(cm->cur_val + CMESH_ATTR_TANGENT, tx, ty, tz, 1.0f);
 557         cm->vattr[CMESH_ATTR_TANGENT].nelem = 3;
 558 }
 559
 560 void cmesh_texcoord(struct cmesh *cm, float u, float v, float w)
 561 {
 562         cgm_wcons(cm->cur_val + CMESH_ATTR_TEXCOORD, u, v, w, 1.0f);
 563         cm->vattr[CMESH_ATTR_TEXCOORD].nelem = 3;
 564 }
 565
 566 void cmesh_boneweights(struct cmesh *cm, float w1, float w2, float w3, float w4)
 567 {
 568         cgm_wcons(cm->cur_val + CMESH_ATTR_BONEWEIGHTS, w1, w2, w3, w4);
 569         cm->vattr[CMESH_ATTR_BONEWEIGHTS].nelem = 4;
 570 }
 571
 572 void cmesh_boneidx(struct cmesh *cm, int idx1, int idx2, int idx3, int idx4)
 573 {
 574         cgm_wcons(cm->cur_val + CMESH_ATTR_BONEIDX, idx1, idx2, idx3, idx4);
 575         cm->vattr[CMESH_ATTR_BONEIDX].nelem = 4;
 576 }
 577
 578 static float *get_vec4(struct cmesh *cm, int attr, int idx, cgm_vec4 *res)
 579 {
 580         int i;
 581         float *sptr, *dptr;
 582         cgm_wcons(res, 0, 0, 0, 1);
 583         if(!(sptr = cmesh_attrib_at(cm, attr, idx))) {
 584                 return 0;
 585         }
 586         dptr = &res->x;
 587
 588         for(i=0; i<cm->vattr[attr].nelem; i++) {
 589                 *dptr++ = sptr[i];
 590         }
 591         return sptr;
 592 }
 593
 594 static float *get_vec3(struct cmesh *cm, int attr, int idx, cgm_vec3 *res)
 595 {
 596         int i;
 597         float *sptr, *dptr;
 598         cgm_vcons(res, 0, 0, 0);
 599         if(!(sptr = cmesh_attrib_at(cm, attr, idx))) {
 600                 return 0;
 601         }
 602         dptr = &res->x;
 603
 604         for(i=0; i<cm->vattr[attr].nelem; i++) {
 605                 *dptr++ = sptr[i];
 606         }
 607         return sptr;
 608 }
 609
 610 /* dir_xform can be null, in which case it's calculated from xform */
 611 void cmesh_apply_xform(struct cmesh *cm, float *xform, float *dir_xform)
 612 {
 613         unsigned int i;
 614         int j;
 615         cgm_vec4 v;
 616         cgm_vec3 n, t;
 617         float *vptr;
 618
 619         for(i=0; i<cm->nverts; i++) {
 620                 if(!(vptr = get_vec4(cm, CMESH_ATTR_VERTEX, i, &v))) {
 621                         return;
 622                 }
 623                 cgm_wmul_m4v4(&v, xform);
 624                 for(j=0; j<cm->vattr[CMESH_ATTR_VERTEX].nelem; j++) {
 625                         *vptr++ = (&v.x)[j];
 626                 }
 627
 628                 if(cmesh_has_attrib(cm, CMESH_ATTR_NORMAL)) {
 629                         if((vptr = get_vec3(cm, CMESH_ATTR_NORMAL, i, &n))) {
 630                                 cgm_vmul_m3v3(&n, dir_xform);
 631                                 for(j=0; j<cm->vattr[CMESH_ATTR_NORMAL].nelem; j++) {
 632                                         *vptr++ = (&n.x)[j];
 633                                 }
 634                         }
 635                 }
 636                 if(cmesh_has_attrib(cm, CMESH_ATTR_TANGENT)) {
 637                         if((vptr = get_vec3(cm, CMESH_ATTR_TANGENT, i, &t))) {
 638                                 cgm_vmul_m3v3(&t, dir_xform);
 639                                 for(j=0; j<cm->vattr[CMESH_ATTR_TANGENT].nelem; j++) {
 640                                         *vptr++ = (&t.x)[j];
 641                                 }
 642                         }
 643                 }
 644         }
 645 }
 646
 647 void cmesh_flip(struct cmesh *cm)
 648 {
 649         cmesh_flip_faces(cm);
 650         cmesh_flip_normals(cm);
 651 }
 652
 653 void cmesh_flip_faces(struct cmesh *cm)
 654 {
 655 }
 656 void cmesh_flip_normals(struct cmesh *cm)
 657 {
 658 }
 659
 660 void cmesh_explode(struct cmesh *cm);   /* undo all vertex sharing */
 661
 662 /* this is only guaranteed to work on an exploded mesh */
 663 void cmesh_calc_face_normals(struct cmesh *cm);
 664
 665 void cmesh_draw(struct cmesh *cm);
 666 void cmesh_draw_wire(struct cmesh *cm, float linesz);
 667 void cmesh_draw_vertices(struct cmesh *cm, float ptsz);
 668 void cmesh_draw_normals(struct cmesh *cm, float len);
 669 void cmesh_draw_tangents(struct cmesh *cm, float len);
 670
 671 /* get the bounding box in local space. The result will be cached and subsequent
 672  * calls will return the same box. The cache gets invalidated by any functions that
 673  * can affect the vertex data
 674  */
 675 void cmesh_aabbox(struct cmesh *cm, cgm_vec3 *vmin, cgm_vec3 *vmax);
 676
 677 /* get the bounding sphere in local space. The result will be cached ... see above */
 678 float cmesh_bsphere(struct cmesh *cm, cgm_vec3 *center, float *rad);
 679
 680 /* texture coordinate manipulation */
 681 void cmesh_texcoord_apply_xform(struct cmesh *cm, float *xform);
 682 void cmesh_texcoord_gen_plane(struct cmesh *cm, cgm_vec3 *norm, cgm_vec3 *tang);
 683 void cmesh_texcoord_gen_box(struct cmesh *cm);
 684 void cmesh_texcoord_gen_cylinder(struct cmesh *cm);
 685
 686 int cmesh_dump(struct cmesh *cm, const char *fname);
 687 int cmesh_dump_file(struct cmesh *cm, FILE *fp);
 688 int cmesh_dump_obj(struct cmesh *cm, const char *fname);
 689 int cmesh_dump_obj_file(struct cmesh *cm, FILE *fp, int voffs);