13 struct cmesh_vattrib {
14 int nelem; /* num elements per attribute [1, 4] */
16 unsigned int count; /* number of floats in data */
24 /* istart,icount are valid only when the mesh is indexed, otherwise icount is 0.
25 * vstart,vcount are define the submesh for non-indexed meshes.
26 * For indexed meshes, vstart,vcount denote the range of vertices used by each
31 int nfaces; /* derived from either icount or vcount */
39 unsigned int nverts, nfaces;
41 struct submesh *sublist;
44 /* current value for each attribute for the immediate mode interface */
45 cgm_vec4 cur_val[CMESH_NUM_ATTR];
47 unsigned int buffer_objects[CMESH_NUM_ATTR + 1];
48 struct cmesh_vattrib vattr[CMESH_NUM_ATTR];
62 /* index buffer for wireframe rendering (constructed on demand) */
63 unsigned int wire_ibo;
67 /* axis-aligned bounding box */
68 cgm_vec3 aabb_min, aabb_max;
77 static int clone(struct cmesh *cmdest, const struct cmesh *cmsrc, struct submesh *sub);
78 static int pre_draw(const struct cmesh *cm, int start);
79 static void post_draw(const struct cmesh *cm, int cur_sdr);
80 static void update_buffers(struct cmesh *cm);
82 static void update_wire_ibo(struct cmesh *cm);
84 static void calc_aabb(struct cmesh *cm);
85 static void calc_bsph(struct cmesh *cm);
87 static int def_nelem[CMESH_NUM_ATTR] = {3, 3, 3, 2, 4, 4, 4, 2};
90 static int sdr_loc[CMESH_NUM_ATTR] = {0, 1, 2, 3, 4, 5, 6, 7};
91 static int use_custom_sdr_attr;
95 void cmesh_set_attrib_sdrloc(int attr, int loc)
100 int cmesh_get_attrib_sdrloc(int attr)
102 return sdr_loc[attr];
105 void cmesh_clear_attrib_sdrloc(void)
108 for(i=0; i<CMESH_NUM_ATTR; i++) {
115 struct cmesh *cmesh_alloc(void)
119 if(!(cm = malloc(sizeof *cm))) {
122 if(cmesh_init(cm) == -1) {
129 void cmesh_free(struct cmesh *cm)
135 int cmesh_init(struct cmesh *cm)
141 memset(cm, 0, sizeof *cm);
142 cgm_wcons(cm->cur_val + CMESH_ATTR_COLOR, 1, 1, 1, 1);
145 glGenBuffers(CMESH_NUM_ATTR + 1, cm->buffer_objects);
147 for(i=0; i<CMESH_NUM_ATTR; i++) {
148 cm->vattr[i].vbo = cm->buffer_objects[i];
151 cm->ibo = cm->buffer_objects[CMESH_NUM_ATTR];
156 void cmesh_destroy(struct cmesh *cm)
162 for(i=0; i<CMESH_NUM_ATTR; i++) {
163 free(cm->vattr[i].data);
167 cmesh_clear_submeshes(cm);
170 glDeleteBuffers(CMESH_NUM_ATTR + 1, cm->buffer_objects);
172 glDeleteBuffers(1, &cm->wire_ibo);
177 /*glDeleteList(cm->dlist, 1);*/
178 gaw_free_compiled(cm->dlist);
183 void cmesh_clear(struct cmesh *cm)
187 for(i=0; i<CMESH_NUM_ATTR; i++) {
188 cm->vattr[i].nelem = 0;
190 cm->vattr[i].vbo_valid = 0;
191 cm->vattr[i].data_valid = 0;
193 free(cm->vattr[i].data);
194 cm->vattr[i].data = 0;
195 cm->vattr[i].count = 0;
206 cm->wire_ibo_valid = 0;
208 cm->nverts = cm->nfaces = 0;
212 /*glDeleteList(cm->dlist, 1);*/
213 gaw_free_compiled(cm->dlist);
217 cm->bsph_valid = cm->aabb_valid = 0;
219 cmesh_clear_submeshes(cm);
222 int cmesh_clone(struct cmesh *cmdest, const struct cmesh *cmsrc)
224 return clone(cmdest, cmsrc, 0);
227 static int clone(struct cmesh *cmdest, const struct cmesh *cmsrc, struct submesh *sub)
229 int i, nelem, vstart, vcount, istart, icount;
230 char *srcname, *name = 0;
231 float *varr[CMESH_NUM_ATTR] = {0};
233 unsigned int *iptr, *iarr = 0;
235 /* try do anything that can fail first, before making any changes to cmdest
236 * so we have the option of recovering gracefuly
239 srcname = sub ? sub->name : cmsrc->name;
241 if(!(name = malloc(strlen(srcname) + 1))) {
244 strcpy(name, srcname);
248 vstart = sub->vstart;
249 vcount = sub->vcount;
250 istart = sub->istart;
251 icount = sub->icount;
254 vcount = cmsrc->nverts;
255 icount = cmsrc->icount;
258 if(cmesh_indexed(cmsrc)) {
259 if(!(iarr = malloc(icount * sizeof *iarr))) {
265 for(i=0; i<CMESH_NUM_ATTR; i++) {
266 if(cmesh_has_attrib(cmsrc, i)) {
267 nelem = cmsrc->vattr[i].nelem;
268 if(!(varr[i] = malloc(vcount * nelem * sizeof(float)))) {
279 /* from this point forward nothing can fail */
282 for(i=0; i<CMESH_NUM_ATTR; i++) {
283 free(cmdest->vattr[i].data);
285 if(cmesh_has_attrib(cmsrc, i)) {
286 /* force validation of the actual data on the source mesh */
287 cmesh_attrib((struct cmesh*)cmsrc, i);
289 nelem = cmsrc->vattr[i].nelem;
290 cmdest->vattr[i].nelem = nelem;
291 cmdest->vattr[i].data = varr[i];
292 cmdest->vattr[i].count = vcount * nelem;
293 vptr = cmsrc->vattr[i].data + vstart * nelem;
294 memcpy(cmdest->vattr[i].data, vptr, vcount * nelem * sizeof(float));
295 cmdest->vattr[i].data_valid = 1;
297 cmdest->vattr[i].vbo_valid = 0;
300 memset(cmdest->vattr + i, 0, sizeof cmdest->vattr[i]);
304 if(cmesh_indexed(cmsrc)) {
305 /* force validation .... */
306 cmesh_index((struct cmesh*)cmsrc);
308 cmdest->idata = iarr;
309 cmdest->icount = icount;
311 /* need to offset all vertex indices by -vstart */
312 iptr = cmsrc->idata + istart;
313 for(i=0; i<icount; i++) {
314 cmdest->idata[i] = *iptr++ - vstart;
317 memcpy(cmdest->idata, cmsrc->idata + istart, icount * sizeof *cmdest->idata);
319 cmdest->idata_valid = 1;
322 cmdest->idata_valid = 0;
324 cmdest->ibo_valid = 0;
331 cmdest->nverts = cmsrc->nverts;
332 cmdest->nfaces = sub ? sub->nfaces : cmsrc->nfaces;
334 memcpy(cmdest->cur_val, cmsrc->cur_val, sizeof cmdest->cur_val);
336 cmdest->aabb_min = cmsrc->aabb_min;
337 cmdest->aabb_max = cmsrc->aabb_max;
338 cmdest->aabb_valid = cmsrc->aabb_valid;
339 cmdest->bsph_center = cmsrc->bsph_center;
340 cmdest->bsph_radius = cmsrc->bsph_radius;
341 cmdest->bsph_valid = cmsrc->bsph_valid;
343 /* copy sublist only if we're not cloning a submesh */
345 struct submesh *sm, *n, *head = 0, *tail = 0;
349 if(!(n = malloc(sizeof *n)) || !(name = malloc(strlen(sm->name) + 1))) {
354 strcpy(name, sm->name);
369 cmdest->sublist = head;
370 cmdest->subcount = cmsrc->subcount;
376 int cmesh_set_name(struct cmesh *cm, const char *name)
378 int len = strlen(name);
379 char *tmp = malloc(len + 1);
383 memcpy(cm->name, name, len + 1);
387 const char *cmesh_name(const struct cmesh *cm)
392 int cmesh_has_attrib(const struct cmesh *cm, int attr)
394 if(attr < 0 || attr >= CMESH_NUM_ATTR) {
398 return cm->vattr[attr].vbo_valid | cm->vattr[attr].data_valid;
400 return cm->vattr[attr].data_valid;
404 int cmesh_indexed(const struct cmesh *cm)
407 return cm->ibo_valid | cm->idata_valid;
409 return cm->idata_valid;
413 /* vdata can be 0, in which case only memory is allocated
414 * returns pointer to the attribute array
416 float *cmesh_set_attrib(struct cmesh *cm, int attr, int nelem, unsigned int num,
421 if(attr < 0 || attr >= CMESH_NUM_ATTR) {
424 if(cm->nverts && num != cm->nverts) {
428 if(!(newarr = malloc(num * nelem * sizeof *newarr))) {
432 memcpy(newarr, vdata, num * nelem * sizeof *newarr);
437 free(cm->vattr[attr].data);
438 cm->vattr[attr].data = newarr;
439 cm->vattr[attr].count = num * nelem;
440 cm->vattr[attr].nelem = nelem;
441 cm->vattr[attr].data_valid = 1;
443 cm->vattr[attr].vbo_valid = 0;
447 gaw_free_compiled(cm->dlist);
454 float *cmesh_attrib(struct cmesh *cm, int attr)
456 if(attr < 0 || attr >= CMESH_NUM_ATTR) {
460 cm->vattr[attr].vbo_valid = 0;
464 gaw_free_compiled(cm->dlist);
468 return (float*)cmesh_attrib_ro(cm, attr);
471 const float *cmesh_attrib_ro(const struct cmesh *cm, int attr)
473 if(attr < 0 || attr >= CMESH_NUM_ATTR) {
477 if(!cm->vattr[attr].data_valid) {
478 #if GL_ES_VERSION_2_0 || !defined(USE_VBO)
483 struct cmesh *m = (struct cmesh*)cm;
485 if(!m->vattr[attr].vbo_valid) {
489 /* local data copy unavailable, grab the data from the vbo */
490 nelem = m->vattr[attr].nelem;
491 if(!(m->vattr[attr].data = malloc(m->nverts * nelem * sizeof(float)))) {
494 m->vattr[attr].count = m->nverts * nelem;
496 glBindBuffer(GL_ARRAY_BUFFER, m->vattr[attr].vbo);
497 tmp = glMapBuffer(GL_ARRAY_BUFFER, GL_READ_ONLY);
498 memcpy(m->vattr[attr].data, tmp, m->nverts * nelem * sizeof(float));
499 glUnmapBuffer(GL_ARRAY_BUFFER);
501 m->vattr[attr].data_valid = 1;
504 return cm->vattr[attr].data;
507 float *cmesh_attrib_at(struct cmesh *cm, int attr, int idx)
509 float *vptr = cmesh_attrib(cm, attr);
510 return vptr ? vptr + idx * cm->vattr[attr].nelem : 0;
513 const float *cmesh_attrib_at_ro(const struct cmesh *cm, int attr, int idx)
515 const float *vptr = cmesh_attrib_ro(cm, attr);
516 return vptr ? vptr + idx * cm->vattr[attr].nelem : 0;
519 int cmesh_attrib_count(const struct cmesh *cm, int attr)
521 return cmesh_has_attrib(cm, attr) ? cm->nverts : 0;
524 int cmesh_attrib_nelem(const struct cmesh *cm, int attr)
526 return cmesh_has_attrib(cm, attr) ? cm->vattr[attr].nelem : 0;
529 int cmesh_push_attrib(struct cmesh *cm, int attr, float *v)
534 if(!cm->vattr[attr].nelem) {
535 cm->vattr[attr].nelem = def_nelem[attr];
538 cursz = cm->vattr[attr].count;
539 newsz = cursz + cm->vattr[attr].nelem;
540 if(!(vptr = realloc(cm->vattr[attr].data, newsz * sizeof(float)))) {
543 cm->vattr[attr].data = vptr;
544 cm->vattr[attr].count = newsz;
547 for(i=0; i<cm->vattr[attr].nelem; i++) {
550 cm->vattr[attr].data_valid = 1;
552 cm->vattr[attr].vbo_valid = 0;
556 gaw_free_compiled(cm->dlist);
561 if(attr == CMESH_ATTR_VERTEX) {
562 cm->nverts = newsz / cm->vattr[attr].nelem;
567 int cmesh_push_attrib1f(struct cmesh *cm, int attr, float x)
573 return cmesh_push_attrib(cm, attr, v);
576 int cmesh_push_attrib2f(struct cmesh *cm, int attr, float x, float y)
583 return cmesh_push_attrib(cm, attr, v);
586 int cmesh_push_attrib3f(struct cmesh *cm, int attr, float x, float y, float z)
593 return cmesh_push_attrib(cm, attr, v);
596 int cmesh_push_attrib4f(struct cmesh *cm, int attr, float x, float y, float z, float w)
603 return cmesh_push_attrib(cm, attr, v);
606 /* indices can be 0, in which case only memory is allocated
607 * returns pointer to the index array
609 unsigned int *cmesh_set_index(struct cmesh *cm, int num, const unsigned int *indices)
612 int nidx = cm->nfaces * 3;
614 if(nidx && num != nidx) {
618 if(!(tmp = malloc(num * sizeof *tmp))) {
622 memcpy(tmp, indices, num * sizeof *tmp);
628 cm->nfaces = num / 3;
635 gaw_free_compiled(cm->dlist);
642 unsigned int *cmesh_index(struct cmesh *cm)
649 gaw_free_compiled(cm->dlist);
653 return (unsigned int*)cmesh_index_ro(cm);
656 const unsigned int *cmesh_index_ro(const struct cmesh *cm)
658 if(!cm->idata_valid) {
659 #if GL_ES_VERSION_2_0 || !defined(USE_VBO)
664 struct cmesh *m = (struct cmesh*)cm;
670 /* local copy is unavailable, grab the data from the ibo */
671 nidx = m->nfaces * 3;
672 if(!(tmp = malloc(nidx * sizeof *m->idata))) {
679 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m->ibo);
680 tmp = glMapBuffer(GL_ELEMENT_ARRAY_BUFFER, GL_READ_ONLY);
681 memcpy(m->idata, tmp, nidx * sizeof *m->idata);
682 glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER);
690 int cmesh_index_count(const struct cmesh *cm)
692 return cm->nfaces * 3;
695 int cmesh_push_index(struct cmesh *cm, unsigned int idx)
698 unsigned int cur_sz = cm->icount;
699 if(!(iptr = realloc(cm->idata, (cur_sz + 1) * sizeof *iptr))) {
704 cm->icount = cur_sz + 1;
711 gaw_free_compiled(cm->dlist);
716 cm->nfaces = cm->icount / 3;
720 int cmesh_poly_count(const struct cmesh *cm)
726 return cm->nverts / 3;
731 /* attr can be -1 to invalidate all attributes */
732 void cmesh_invalidate_vbo(struct cmesh *cm, int attr)
737 if(attr >= CMESH_NUM_ATTR) {
742 for(i=0; i<CMESH_NUM_ATTR; i++) {
743 cm->vattr[i].vbo_valid = 0;
746 cm->vattr[attr].vbo_valid = 0;
751 gaw_free_compiled(cm->dlist);
757 void cmesh_invalidate_index(struct cmesh *cm)
764 gaw_free_compiled(cm->dlist);
770 int cmesh_append(struct cmesh *cmdest, const struct cmesh *cmsrc)
772 int i, nelem, newsz, origsz, srcsz;
775 unsigned int idxoffs;
777 if(!cmdest->nverts) {
778 return cmesh_clone(cmdest, cmsrc);
781 for(i=0; i<CMESH_NUM_ATTR; i++) {
782 if(cmesh_has_attrib(cmdest, i) && cmesh_has_attrib(cmsrc, i)) {
783 /* force validation of the data arrays */
784 cmesh_attrib(cmdest, i);
785 cmesh_attrib_ro(cmsrc, i);
787 assert(cmdest->vattr[i].nelem == cmsrc->vattr[i].nelem);
788 nelem = cmdest->vattr[i].nelem;
789 origsz = cmdest->nverts * nelem;
790 newsz = (cmdest->nverts + cmsrc->nverts) * nelem;
792 if(!(vptr = realloc(cmdest->vattr[i].data, newsz * sizeof *vptr))) {
795 memcpy(vptr + origsz, cmsrc->vattr[i].data, cmsrc->nverts * nelem * sizeof(float));
796 cmdest->vattr[i].data = vptr;
797 cmdest->vattr[i].count = newsz;
801 if(cmesh_indexed(cmdest)) {
802 assert(cmesh_indexed(cmsrc));
803 /* force validation ... */
805 cmesh_index_ro(cmsrc);
807 idxoffs = cmdest->nverts;
808 origsz = cmdest->icount;
809 srcsz = cmsrc->icount;
810 newsz = origsz + srcsz;
812 if(!(iptr = realloc(cmdest->idata, newsz * sizeof *iptr))) {
815 cmdest->idata = iptr;
816 cmdest->icount = newsz;
818 /* copy and fixup all the new indices */
820 for(i=0; i<srcsz; i++) {
821 *iptr++ = cmsrc->idata[i] + idxoffs;
825 cmdest->nverts += cmsrc->nverts;
826 cmdest->nfaces += cmsrc->nfaces;
829 cmdest->wire_ibo_valid = 0;
831 cmdest->aabb_valid = 0;
832 cmdest->bsph_valid = 0;
836 void cmesh_clear_submeshes(struct cmesh *cm)
842 cm->sublist = cm->sublist->next;
849 int cmesh_submesh(struct cmesh *cm, const char *name, int fstart, int fcount)
852 unsigned int minv = UINT_MAX, maxv = 0;
856 if(fstart < 0 || fcount < 1 || fstart + fcount > cm->nfaces) {
860 if(!(sm = malloc(sizeof *sm)) || !(sm->name = malloc(strlen(name) + 1))) {
864 strcpy(sm->name, name);
867 if(cmesh_indexed(cm)) {
868 sm->istart = fstart * 3;
869 sm->icount = fcount * 3;
871 /* find out which vertices are used by this submesh */
872 iptr = cm->idata + sm->istart;
873 for(i=0; i<sm->icount; i++) {
874 unsigned int vidx = *iptr++;
875 if(vidx < minv) minv = vidx;
876 if(vidx > maxv) maxv = vidx;
879 sm->vcount = maxv - minv + 1;
881 sm->istart = sm->icount = 0;
882 sm->vstart = fstart * 3;
883 sm->vcount = fcount * 3;
886 sm->next = cm->sublist;
892 int cmesh_remove_submesh(struct cmesh *cm, int idx)
894 struct submesh dummy;
895 struct submesh *prev, *sm;
897 if(idx >= cm->subcount) {
901 dummy.next = cm->sublist;
904 while(prev->next && idx-- > 0) {
908 if(!(sm = prev->next)) return -1;
910 prev->next = sm->next;
915 assert(cm->subcount >= 0);
917 cm->sublist = dummy.next;
921 int cmesh_find_submesh(const struct cmesh *cm, const char *name)
924 struct submesh *sm = cm->sublist;
926 if(strcmp(sm->name, name) == 0) {
927 assert(idx <= cm->subcount);
936 int cmesh_submesh_count(const struct cmesh *cm)
941 static struct submesh *get_submesh(const struct cmesh *m, int idx)
943 struct submesh *sm = m->sublist;
944 while(sm && --idx >= 0) {
950 int cmesh_clone_submesh(struct cmesh *cmdest, const struct cmesh *cm, int subidx)
954 if(!(sub = get_submesh(cm, subidx))) {
957 return clone(cmdest, cm, sub);
961 /* assemble a complete vertex by adding all the useful attributes */
962 int cmesh_vertex(struct cmesh *cm, float x, float y, float z)
966 cgm_wcons(cm->cur_val + CMESH_ATTR_VERTEX, x, y, z, 1.0f);
967 cm->vattr[CMESH_ATTR_VERTEX].data_valid = 1;
968 cm->vattr[CMESH_ATTR_VERTEX].nelem = 3;
970 for(i=0; i<CMESH_NUM_ATTR; i++) {
971 if(cm->vattr[i].nelem > 0) {
972 cmesh_push_attrib(cm, i, &cm->cur_val[i].x);
976 if(cm->idata_valid) {
988 void cmesh_normal(struct cmesh *cm, float nx, float ny, float nz)
990 cgm_wcons(cm->cur_val + CMESH_ATTR_NORMAL, nx, ny, nz, 1.0f);
991 cm->vattr[CMESH_ATTR_NORMAL].nelem = 3;
994 void cmesh_tangent(struct cmesh *cm, float tx, float ty, float tz)
996 cgm_wcons(cm->cur_val + CMESH_ATTR_TANGENT, tx, ty, tz, 1.0f);
997 cm->vattr[CMESH_ATTR_TANGENT].nelem = 3;
1000 void cmesh_texcoord(struct cmesh *cm, float u, float v, float w)
1002 cgm_wcons(cm->cur_val + CMESH_ATTR_TEXCOORD, u, v, w, 1.0f);
1003 cm->vattr[CMESH_ATTR_TEXCOORD].nelem = 3;
1006 void cmesh_boneweights(struct cmesh *cm, float w1, float w2, float w3, float w4)
1008 cgm_wcons(cm->cur_val + CMESH_ATTR_BONEWEIGHTS, w1, w2, w3, w4);
1009 cm->vattr[CMESH_ATTR_BONEWEIGHTS].nelem = 4;
1012 void cmesh_boneidx(struct cmesh *cm, int idx1, int idx2, int idx3, int idx4)
1014 cgm_wcons(cm->cur_val + CMESH_ATTR_BONEIDX, idx1, idx2, idx3, idx4);
1015 cm->vattr[CMESH_ATTR_BONEIDX].nelem = 4;
1018 static float *get_vec4(struct cmesh *cm, int attr, int idx, cgm_vec4 *res)
1022 cgm_wcons(res, 0, 0, 0, 1);
1023 if(!(sptr = cmesh_attrib_at(cm, attr, idx))) {
1028 for(i=0; i<cm->vattr[attr].nelem; i++) {
1034 static float *get_vec3(struct cmesh *cm, int attr, int idx, cgm_vec3 *res)
1038 cgm_vcons(res, 0, 0, 0);
1039 if(!(sptr = cmesh_attrib_at(cm, attr, idx))) {
1044 for(i=0; i<cm->vattr[attr].nelem; i++) {
1050 /* dir_xform can be null, in which case it's calculated from xform */
1051 void cmesh_apply_xform(struct cmesh *cm, float *xform, float *dir_xform)
1063 for(i=0; i<cm->nverts; i++) {
1064 if(!(vptr = get_vec4(cm, CMESH_ATTR_VERTEX, i, &v))) {
1067 cgm_wmul_m4v4(&v, xform);
1068 for(j=0; j<cm->vattr[CMESH_ATTR_VERTEX].nelem; j++) {
1069 *vptr++ = (&v.x)[j];
1072 if(cmesh_has_attrib(cm, CMESH_ATTR_NORMAL)) {
1073 if((vptr = get_vec3(cm, CMESH_ATTR_NORMAL, i, &n))) {
1074 cgm_vmul_m3v3(&n, dir_xform);
1075 for(j=0; j<cm->vattr[CMESH_ATTR_NORMAL].nelem; j++) {
1076 *vptr++ = (&n.x)[j];
1080 if(cmesh_has_attrib(cm, CMESH_ATTR_TANGENT)) {
1081 if((vptr = get_vec3(cm, CMESH_ATTR_TANGENT, i, &t))) {
1082 cgm_vmul_m3v3(&t, dir_xform);
1083 for(j=0; j<cm->vattr[CMESH_ATTR_TANGENT].nelem; j++) {
1084 *vptr++ = (&t.x)[j];
1091 void cmesh_flip(struct cmesh *cm)
1093 cmesh_flip_faces(cm);
1094 cmesh_flip_normals(cm);
1097 void cmesh_flip_faces(struct cmesh *cm)
1099 int i, j, idxnum, vnum, nelem;
1100 unsigned int *indices;
1101 float *verts, *vptr;
1103 if(cmesh_indexed(cm)) {
1104 if(!(indices = cmesh_index(cm))) {
1107 idxnum = cmesh_index_count(cm);
1108 for(i=0; i<idxnum; i+=3) {
1109 unsigned int tmp = indices[i + 2];
1110 indices[i + 2] = indices[i + 1];
1111 indices[i + 1] = tmp;
1114 if(!(verts = cmesh_attrib(cm, CMESH_ATTR_VERTEX))) {
1117 vnum = cmesh_attrib_count(cm, CMESH_ATTR_VERTEX);
1118 nelem = cm->vattr[CMESH_ATTR_VERTEX].nelem;
1119 for(i=0; i<vnum; i+=3) {
1120 for(j=0; j<nelem; j++) {
1121 vptr = verts + (i + 1) * nelem + j;
1122 float tmp = vptr[nelem];
1123 vptr[nelem] = vptr[0];
1129 void cmesh_flip_normals(struct cmesh *cm)
1132 float *nptr = cmesh_attrib(cm, CMESH_ATTR_NORMAL);
1135 num = cm->nverts * cm->vattr[CMESH_ATTR_NORMAL].nelem;
1136 for(i=0; i<num; i++) {
1142 int cmesh_explode(struct cmesh *cm)
1144 int i, j, k, idxnum, nnverts;
1145 unsigned int *indices;
1147 if(!cmesh_indexed(cm)) return 0;
1149 indices = cmesh_index(cm);
1152 idxnum = cmesh_index_count(cm);
1155 for(i=0; i<CMESH_NUM_ATTR; i++) {
1156 const float *srcbuf;
1157 float *tmpbuf, *dstptr;
1159 if(!cmesh_has_attrib(cm, i)) continue;
1161 srcbuf = cmesh_attrib(cm, i);
1162 if(!(tmpbuf = malloc(nnverts * cm->vattr[i].nelem * sizeof(float)))) {
1167 for(j=0; j<idxnum; j++) {
1168 unsigned int idx = indices[j];
1169 const float *srcptr = srcbuf + idx * cm->vattr[i].nelem;
1171 for(k=0; k<cm->vattr[i].nelem; k++) {
1172 *dstptr++ = *srcptr++;
1176 free(cm->vattr[i].data);
1177 cm->vattr[i].data = tmpbuf;
1178 cm->vattr[i].count = nnverts * cm->vattr[i].nelem;
1179 cm->vattr[i].data_valid = 1;
1187 gaw_free_compiled(cm->dlist);
1191 cm->idata_valid = 0;
1196 cm->nverts = nnverts;
1197 cm->nfaces = idxnum / 3;
1201 void cmesh_calc_face_normals(struct cmesh *cm)
1206 static int pre_draw(const struct cmesh *cm, int start)
1212 glGetIntegerv(GL_CURRENT_PROGRAM, &cur_sdr);
1217 update_buffers((struct cmesh*)cm);
1220 if(!cm->vattr[CMESH_ATTR_VERTEX].vbo_valid) {
1225 if(cur_sdr && use_custom_sdr_attr) {
1226 if(sdr_loc[CMESH_ATTR_VERTEX] == -1) {
1230 for(i=0; i<CMESH_NUM_ATTR; i++) {
1232 if(loc >= 0 && cm->vattr[i].vbo_valid) {
1233 glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[i].vbo);
1234 glVertexAttribPointer(loc, cm->vattr[i].nelem, GL_FLOAT, GL_FALSE, 0, 0);
1235 glEnableVertexAttribArray(loc);
1239 #endif /* USE_SDR */
1240 #ifndef GL_ES_VERSION_2_0
1241 glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[CMESH_ATTR_VERTEX].vbo);
1242 glVertexPointer(cm->vattr[CMESH_ATTR_VERTEX].nelem, GL_FLOAT, 0, 0);
1243 glEnableClientState(GL_VERTEX_ARRAY);
1245 if(cm->vattr[CMESH_ATTR_NORMAL].vbo_valid) {
1246 glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[CMESH_ATTR_NORMAL].vbo);
1247 glNormalPointer(GL_FLOAT, 0, 0);
1248 glEnableClientState(GL_NORMAL_ARRAY);
1250 if(cm->vattr[CMESH_ATTR_TEXCOORD].vbo_valid) {
1251 glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[CMESH_ATTR_TEXCOORD].vbo);
1252 glTexCoordPointer(cm->vattr[CMESH_ATTR_TEXCOORD].nelem, GL_FLOAT, 0, 0);
1253 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
1255 if(cm->vattr[CMESH_ATTR_COLOR].vbo_valid) {
1256 glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[CMESH_ATTR_COLOR].vbo);
1257 glColorPointer(cm->vattr[CMESH_ATTR_COLOR].nelem, GL_FLOAT, 0, 0);
1258 glEnableClientState(GL_COLOR_ARRAY);
1260 if(cm->vattr[CMESH_ATTR_TEXCOORD2].vbo_valid) {
1261 glClientActiveTexture(GL_TEXTURE1);
1262 glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[CMESH_ATTR_TEXCOORD2].vbo);
1263 glTexCoordPointer(cm->vattr[CMESH_ATTR_TEXCOORD2].nelem, GL_FLOAT, 0, 0);
1264 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
1265 glClientActiveTexture(GL_TEXTURE0);
1267 #endif /* GL_ES_VERSION_2_0 */
1271 glBindBuffer(GL_ARRAY_BUFFER, 0);
1273 #else /* !USE_VBO */
1276 if(cm->dlist && !start) {
1281 const struct cmesh_vattrib *vattr;
1283 vattr = cm->vattr + CMESH_ATTR_VERTEX;
1284 gaw_vertex_array(vattr->nelem, 0, vattr->data + start * vattr->nelem);
1286 vattr = cm->vattr + CMESH_ATTR_NORMAL;
1287 if(vattr->data_valid) {
1288 gaw_normal_array(0, vattr->data + start * 3);
1291 vattr = cm->vattr + CMESH_ATTR_TEXCOORD;
1292 if(vattr->data_valid) {
1293 gaw_texcoord_array(vattr->nelem, 0, vattr->data + start * vattr->nelem);
1296 vattr = cm->vattr + CMESH_ATTR_COLOR;
1297 if(vattr->data_valid) {
1298 gaw_color_array(vattr->nelem, 0, vattr->data + start * vattr->nelem);
1301 #endif /* !USE_VBO */
1305 void cmesh_draw(const struct cmesh *cm)
1309 if((cur_sdr = pre_draw(cm, 0)) == -1) {
1315 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cm->ibo);
1316 glDrawElements(GL_TRIANGLES, cm->nfaces * 3, GL_UNSIGNED_INT, 0);
1317 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
1319 glDrawArrays(GL_TRIANGLES, 0, cm->nverts);
1324 gaw_draw_compiled(cm->dlist);
1327 if(cm->idata_valid) {
1328 /*glDrawElements(GL_TRIANGLES, cm->nfaces * 3, GL_UNSIGNED_INT, cm->idata);*/
1329 gaw_draw_indexed(GAW_TRIANGLES, cm->idata, cm->nfaces * 3);
1331 /*glDrawArrays(GL_TRIANGLES, 0, cm->nverts);*/
1332 gaw_draw(GAW_TRIANGLES, cm->nverts);
1336 post_draw(cm, cur_sdr);
1339 void cmesh_draw_range(const struct cmesh *cm, int start, int count)
1343 if((cur_sdr = pre_draw(cm, start)) == -1) {
1349 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cm->ibo);
1350 glDrawElements(GL_TRIANGLES, count, GL_UNSIGNED_INT, (void*)(intptr_t)(start * 4));
1351 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
1353 glDrawArrays(GL_TRIANGLES, start, count);
1356 if(cm->idata_valid) {
1357 gaw_draw_indexed(GAW_TRIANGLES, cm->idata + start, count);
1359 gaw_draw(GAW_TRIANGLES, count);
1363 post_draw(cm, cur_sdr);
1366 void cmesh_draw_submesh(const struct cmesh *cm, int subidx)
1368 struct submesh *sm = cm->sublist;
1370 while(sm && subidx-- > 0) {
1376 cmesh_draw_range(cm, sm->istart, sm->icount);
1378 cmesh_draw_range(cm, sm->vstart, sm->vcount);
1382 static void post_draw(const struct cmesh *cm, int cur_sdr)
1386 if(cur_sdr && use_custom_sdr_attr) {
1388 for(i=0; i<CMESH_NUM_ATTR; i++) {
1389 int loc = sdr_loc[i];
1390 if(loc >= 0 && cm->vattr[i].vbo_valid) {
1391 glDisableVertexAttribArray(loc);
1395 #endif /* USE_SDR */
1396 #ifndef GL_ES_VERSION_2_0
1397 glDisableClientState(GL_VERTEX_ARRAY);
1398 if(cm->vattr[CMESH_ATTR_NORMAL].vbo_valid) {
1399 glDisableClientState(GL_NORMAL_ARRAY);
1401 if(cm->vattr[CMESH_ATTR_TEXCOORD].vbo_valid) {
1402 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
1404 if(cm->vattr[CMESH_ATTR_COLOR].vbo_valid) {
1405 glDisableClientState(GL_COLOR_ARRAY);
1407 if(cm->vattr[CMESH_ATTR_TEXCOORD2].vbo_valid) {
1408 glClientActiveTexture(GL_TEXTURE1);
1409 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
1410 glClientActiveTexture(GL_TEXTURE0);
1412 #endif /* GL_ES_VERSION_2_0 */
1416 #else /* !USE_VBO */
1417 gaw_vertex_array(0, 0, 0);
1418 gaw_normal_array(0, 0);
1419 gaw_texcoord_array(0, 0, 0);
1420 gaw_color_array(0, 0, 0);
1424 void cmesh_draw_wire(const struct cmesh *cm, float linesz)
1427 int cur_sdr, nfaces;
1429 if((cur_sdr = pre_draw(cm, 0)) == -1) {
1432 update_wire_ibo((struct cmesh*)cm);
1434 nfaces = cmesh_poly_count(cm);
1435 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cm->wire_ibo);
1436 glDrawElements(GL_LINES, nfaces * 6, GL_UNSIGNED_INT, 0);
1437 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
1439 post_draw(cm, cur_sdr);
1443 void cmesh_draw_vertices(const struct cmesh *cm, float ptsz)
1446 if((cur_sdr = pre_draw(cm, 0)) == -1) {
1451 glPushAttrib(GL_POINT_BIT);
1453 glDrawArrays(GL_POINTS, 0, cm->nverts);
1456 gaw_draw(GAW_POINTS, cm->nverts);
1458 post_draw(cm, cur_sdr);
1461 void cmesh_draw_normals(const struct cmesh *cm, float len)
1463 #ifndef GL_ES_VERSION_2_0
1464 int i, vert_nelem, norm_nelem;
1466 int cur_sdr, loc = -1;
1468 const float *varr, *norm;
1470 varr = cmesh_attrib_ro(cm, CMESH_ATTR_VERTEX);
1471 norm = cmesh_attrib_ro(cm, CMESH_ATTR_NORMAL);
1472 if(!varr || !norm) return;
1474 vert_nelem = cm->vattr[CMESH_ATTR_VERTEX].nelem;
1475 norm_nelem = cm->vattr[CMESH_ATTR_NORMAL].nelem;
1478 glGetIntegerv(GL_CURRENT_PROGRAM, &cur_sdr);
1479 if(cur_sdr && use_custom_sdr_attr) {
1480 if((loc = sdr_loc[CMESH_ATTR_VERTEX]) < 0) {
1486 gaw_begin(GAW_LINES);
1487 for(i=0; i<cm->nverts; i++) {
1488 float x, y, z, endx, endy, endz;
1490 x = varr[i * vert_nelem];
1491 y = varr[i * vert_nelem + 1];
1492 z = varr[i * vert_nelem + 2];
1493 endx = x + norm[i * norm_nelem] * len;
1494 endy = y + norm[i * norm_nelem + 1] * len;
1495 endz = z + norm[i * norm_nelem + 2] * len;
1500 gaw_vertex3f(x, y, z);
1501 gaw_vertex3f(endx, endy, endz);
1504 glVertexAttrib3f(loc, x, y, z);
1505 glVertexAttrib3f(loc, endx, endy, endz);
1510 #endif /* GL_ES_VERSION_2_0 */
1513 void cmesh_draw_tangents(const struct cmesh *cm, float len)
1515 #ifndef GL_ES_VERSION_2_0
1516 int i, vert_nelem, tang_nelem;
1518 int cur_sdr, loc = -1;
1520 const float *varr, *tang;
1522 varr = cmesh_attrib_ro(cm, CMESH_ATTR_VERTEX);
1523 tang = cmesh_attrib_ro(cm, CMESH_ATTR_TANGENT);
1524 if(!varr || !tang) return;
1526 vert_nelem = cm->vattr[CMESH_ATTR_VERTEX].nelem;
1527 tang_nelem = cm->vattr[CMESH_ATTR_TANGENT].nelem;
1530 glGetIntegerv(GL_CURRENT_PROGRAM, &cur_sdr);
1531 if(cur_sdr && use_custom_sdr_attr) {
1532 if((loc = sdr_loc[CMESH_ATTR_VERTEX]) < 0) {
1538 gaw_begin(GAW_LINES);
1539 for(i=0; i<cm->nverts; i++) {
1540 float x, y, z, endx, endy, endz;
1542 x = varr[i * vert_nelem];
1543 y = varr[i * vert_nelem + 1];
1544 z = varr[i * vert_nelem + 2];
1545 endx = x + tang[i * tang_nelem] * len;
1546 endy = y + tang[i * tang_nelem + 1] * len;
1547 endz = z + tang[i * tang_nelem + 2] * len;
1552 gaw_vertex3f(x, y, z);
1553 gaw_vertex3f(endx, endy, endz);
1556 glVertexAttrib3f(loc, x, y, z);
1557 glVertexAttrib3f(loc, endx, endy, endz);
1562 #endif /* GL_ES_VERSION_2_0 */
1565 static void update_buffers(struct cmesh *cm)
1569 for(i=0; i<CMESH_NUM_ATTR; i++) {
1570 if(cmesh_has_attrib(cm, i) && !cm->vattr[i].vbo_valid) {
1571 glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[i].vbo);
1572 glBufferData(GL_ARRAY_BUFFER, cm->nverts * cm->vattr[i].nelem * sizeof(float),
1573 cm->vattr[i].data, GL_STATIC_DRAW);
1574 cm->vattr[i].vbo_valid = 1;
1577 glBindBuffer(GL_ARRAY_BUFFER, 0);
1579 if(cm->idata_valid && !cm->ibo_valid) {
1580 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cm->ibo);
1581 glBufferData(GL_ELEMENT_ARRAY_BUFFER, cm->nfaces * 3 * sizeof(unsigned int),
1582 cm->idata, GL_STATIC_DRAW);
1584 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
1587 #elif defined(USE_DLIST)
1588 static int updating;
1590 if(!cm->dlist && !updating) {
1591 int dlist = gaw_compile_begin();
1602 static void update_wire_ibo(struct cmesh *cm)
1605 unsigned int *wire_idxarr, *dest;
1609 if(cm->wire_ibo_valid) return;
1612 glGenBuffers(1, &cm->wire_ibo);
1614 num_faces = cmesh_poly_count(cm);
1616 if(!(wire_idxarr = malloc(num_faces * 6 * sizeof *wire_idxarr))) {
1622 /* we're dealing with an indexed mesh */
1623 const unsigned int *idxarr = cmesh_index_ro(cm);
1625 for(i=0; i<num_faces; i++) {
1626 *dest++ = idxarr[0];
1627 *dest++ = idxarr[1];
1628 *dest++ = idxarr[1];
1629 *dest++ = idxarr[2];
1630 *dest++ = idxarr[2];
1631 *dest++ = idxarr[0];
1635 /* not an indexed mesh */
1636 for(i=0; i<num_faces; i++) {
1647 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cm->wire_ibo);
1648 glBufferData(GL_ELEMENT_ARRAY_BUFFER, num_faces * 6 * sizeof(unsigned int),
1649 wire_idxarr, GL_STATIC_DRAW);
1651 cm->wire_ibo_valid = 1;
1652 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
1654 #endif /* USE_VBO */
1656 static void calc_aabb(struct cmesh *cm)
1660 if(!cmesh_attrib_ro(cm, CMESH_ATTR_VERTEX)) {
1664 cgm_vcons(&cm->aabb_min, FLT_MAX, FLT_MAX, FLT_MAX);
1665 cgm_vcons(&cm->aabb_max, -FLT_MAX, -FLT_MAX, -FLT_MAX);
1667 for(i=0; i<cm->nverts; i++) {
1668 const float *v = cmesh_attrib_at_ro(cm, CMESH_ATTR_VERTEX, i);
1669 for(j=0; j<3; j++) {
1670 if(v[j] < (&cm->aabb_min.x)[j]) {
1671 (&cm->aabb_min.x)[j] = v[j];
1673 if(v[j] > (&cm->aabb_max.x)[j]) {
1674 (&cm->aabb_max.x)[j] = v[j];
1681 void cmesh_aabbox(const struct cmesh *cm, cgm_vec3 *vmin, cgm_vec3 *vmax)
1683 if(!cm->aabb_valid) {
1684 calc_aabb((struct cmesh*)cm);
1686 *vmin = cm->aabb_min;
1687 *vmax = cm->aabb_max;
1690 static void calc_bsph(struct cmesh *cm)
1695 if(!cmesh_attrib_ro(cm, CMESH_ATTR_VERTEX)) {
1699 cgm_vcons(&cm->bsph_center, 0, 0, 0);
1701 /* first find the center */
1702 for(i=0; i<cm->nverts; i++) {
1703 const float *v = cmesh_attrib_at_ro(cm, CMESH_ATTR_VERTEX, i);
1704 cm->bsph_center.x += v[0];
1705 cm->bsph_center.y += v[1];
1706 cm->bsph_center.z += v[2];
1708 s = 1.0f / (float)cm->nverts;
1709 cm->bsph_center.x *= s;
1710 cm->bsph_center.y *= s;
1711 cm->bsph_center.z *= s;
1713 cm->bsph_radius = 0.0f;
1714 for(i=0; i<cm->nverts; i++) {
1715 const cgm_vec3 *v = (const cgm_vec3*)cmesh_attrib_at_ro(cm, CMESH_ATTR_VERTEX, i);
1716 if((dist_sq = cgm_vdist_sq(v, &cm->bsph_center)) > cm->bsph_radius) {
1717 cm->bsph_radius = dist_sq;
1720 cm->bsph_radius = sqrt(cm->bsph_radius);
1724 float cmesh_bsphere(const struct cmesh *cm, cgm_vec3 *center, float *rad)
1726 if(!cm->bsph_valid) {
1727 calc_bsph((struct cmesh*)cm);
1729 if(center) *center = cm->bsph_center;
1730 if(rad) *rad = cm->bsph_radius;
1731 return cm->bsph_radius;
1735 void cmesh_texcoord_apply_xform(struct cmesh *cm, float *xform);
1736 void cmesh_texcoord_gen_plane(struct cmesh *cm, cgm_vec3 *norm, cgm_vec3 *tang);
1737 void cmesh_texcoord_gen_box(struct cmesh *cm);
1738 void cmesh_texcoord_gen_cylinder(struct cmesh *cm);
1740 int cmesh_dump(const struct cmesh *cm, const char *fname)
1742 FILE *fp = fopen(fname, "wb");
1744 int res = cmesh_dump_file(cm, fp);
1751 int cmesh_dump_file(const struct cmesh *cm, FILE *fp)
1753 static const char *label[] = { "pos", "nor", "tan", "tex", "col", "bw", "bid", "tex2" };
1754 static const char *elemfmt[] = { 0, " %s(%g)", " %s(%g, %g)", " %s(%g, %g, %g)", " %s(%g, %g, %g, %g)", 0 };
1757 if(!cmesh_has_attrib(cm, CMESH_ATTR_VERTEX)) {
1761 fprintf(fp, "VERTEX ATTRIBUTES\n");
1763 for(i=0; i<cm->nverts; i++) {
1764 fprintf(fp, "%5u:", i);
1765 for(j=0; j<CMESH_NUM_ATTR; j++) {
1766 if(cmesh_has_attrib(cm, j)) {
1767 const float *v = cmesh_attrib_at_ro(cm, j, i);
1768 int nelem = cm->vattr[j].nelem;
1769 fprintf(fp, elemfmt[nelem], label[j], v[0], nelem > 1 ? v[1] : 0.0f,
1770 nelem > 2 ? v[2] : 0.0f, nelem > 3 ? v[3] : 0.0f);
1776 if(cmesh_indexed(cm)) {
1777 const unsigned int *idx = cmesh_index_ro(cm);
1778 int numidx = cmesh_index_count(cm);
1779 int numtri = numidx / 3;
1780 assert(numidx % 3 == 0);
1782 fprintf(fp, "FACES\n");
1784 for(i=0; i<numtri; i++) {
1785 fprintf(fp, "%5d: %d %d %d\n", i, idx[0], idx[1], idx[2]);
1792 int cmesh_dump_obj(const struct cmesh *cm, const char *fname)
1794 FILE *fp = fopen(fname, "wb");
1796 int res = cmesh_dump_obj_file(cm, fp, 0);
1806 int cmesh_dump_obj_file(const struct cmesh *cm, FILE *fp, int voffs)
1808 static const char *fmtstr[] = {" %u", " %u//%u", " %u/%u", " %u/%u/%u"};
1809 int i, j, num, nelem;
1810 unsigned int aflags = 0;
1812 if(!cmesh_has_attrib(cm, CMESH_ATTR_VERTEX)) {
1817 nelem = cm->vattr[CMESH_ATTR_VERTEX].nelem;
1818 if((num = cm->vattr[CMESH_ATTR_VERTEX].count) != cm->nverts * nelem) {
1819 fprintf(stderr, "vertex array size (%d) != nverts (%d)\n", num, cm->nverts);
1821 for(i=0; i<cm->nverts; i++) {
1822 const float *v = cmesh_attrib_at_ro(cm, CMESH_ATTR_VERTEX, i);
1823 fprintf(fp, "v %f %f %f\n", v[0], nelem > 1 ? v[1] : 0.0f, nelem > 2 ? v[2] : 0.0f);
1826 if(cmesh_has_attrib(cm, CMESH_ATTR_NORMAL)) {
1828 nelem = cm->vattr[CMESH_ATTR_NORMAL].nelem;
1829 if((num = cm->vattr[CMESH_ATTR_NORMAL].count) != cm->nverts * nelem) {
1830 fprintf(stderr, "normal array size (%d) != nverts (%d)\n", num, cm->nverts);
1832 for(i=0; i<cm->nverts; i++) {
1833 const float *v = cmesh_attrib_at_ro(cm, CMESH_ATTR_NORMAL, i);
1834 fprintf(fp, "vn %f %f %f\n", v[0], nelem > 1 ? v[1] : 0.0f, nelem > 2 ? v[2] : 0.0f);
1838 if(cmesh_has_attrib(cm, CMESH_ATTR_TEXCOORD)) {
1840 nelem = cm->vattr[CMESH_ATTR_TEXCOORD].nelem;
1841 if((num = cm->vattr[CMESH_ATTR_TEXCOORD].count) != cm->nverts * nelem) {
1842 fprintf(stderr, "texcoord array size (%d) != nverts (%d)\n", num, cm->nverts);
1844 for(i=0; i<cm->nverts; i++) {
1845 const float *v = cmesh_attrib_at_ro(cm, CMESH_ATTR_TEXCOORD, i);
1846 fprintf(fp, "vt %f %f\n", v[0], nelem > 1 ? v[1] : 0.0f);
1850 if(cmesh_indexed(cm)) {
1851 const unsigned int *idxptr = cmesh_index_ro(cm);
1852 int numidx = cmesh_index_count(cm);
1853 int numtri = numidx / 3;
1854 assert(numidx % 3 == 0);
1856 for(i=0; i<numtri; i++) {
1858 for(j=0; j<3; j++) {
1859 unsigned int idx = *idxptr++ + 1 + voffs;
1860 fprintf(fp, fmtstr[aflags], idx, idx, idx);
1865 int numtri = cm->nverts / 3;
1866 unsigned int idx = 1 + voffs;
1867 for(i=0; i<numtri; i++) {
1869 for(j=0; j<3; j++) {
1870 fprintf(fp, fmtstr[aflags], idx, idx, idx);