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