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