10 int nelem; /* num elements per attribute [1, 4] */
11 float *data; /* dynarr */
13 int vbo_valid, data_valid;
19 unsigned int nverts, nfaces;
21 /* current value for each attribute for the immediate mode interface */
22 cgm_vec4 cur_val[CMESH_NUM_ATTR];
24 unsigned int buffer_objects[CMESH_NUM_ATTR + 1];
25 struct cmesh_vattrib vattr[CMESH_NUM_ATTR];
27 unsigned int *idata; /* dynarr */
29 int ibo_valid, idata_valid;
31 /* index buffer for wireframe rendering (constructed on demand) */
32 unsigned int wire_ibo;
35 /* axis-aligned bounding box */
36 cgm_vec3 aabb_min, aabb_max;
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);
53 static int sdr_loc[CMESH_NUM_ATTR] = {0, 1, 2, 3, 4, 5, 6, 7};
54 static int use_custom_sdr_attr;
58 void cmesh_set_attrib_sdrloc(int attr, int loc)
63 int cmesh_get_attrib_sdrloc(int attr)
68 void cmesh_clear_attrib_sdrloc(void)
71 for(i=0; i<CMESH_NUM_ATTR; i++) {
77 struct cmesh *cmesh_alloc(void)
81 if(!(cm = malloc(sizeof *cm))) {
84 if(cmesh_init(cm) == -1) {
91 void cmesh_free(struct cmesh *cm)
97 int cmesh_init(struct cmesh *cm)
101 memset(cm, 0, sizeof *cm);
102 cgm_wcons(cm->cur_val + CMESH_ATTR_COLOR, 1, 1, 1, 1);
104 glGenBuffers(CMESH_NUM_ATTR + 1, cm->buffer_objects);
106 for(i=0; i<CMESH_NUM_ATTR; i++) {
107 if(!(cm->vattr[i].data = dynarr_alloc(0, sizeof(float)))) {
111 cm->vattr[i].vbo = cm->buffer_objects[i];
114 cm->ibo = cm->buffer_objects[CMESH_NUM_ATTR];
115 if(!(cm->idata = dynarr_alloc(0, sizeof *cm->idata))) {
122 void cmesh_destroy(struct cmesh *cm)
128 for(i=0; i<CMESH_NUM_ATTR; i++) {
129 dynarr_free(cm->vattr[i].data);
131 dynarr_free(cm->idata);
133 glDeleteBuffers(CMESH_NUM_ATTR + 1, cm->buffer_objects);
135 glDeleteBuffers(1, &cm->wire_ibo);
139 void cmesh_clear(struct cmesh *cm)
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);
149 cm->ibo_valid = cm->idata_valid = 0;
150 cm->idata = dynarr_clear(cm->idata);
152 cm->wire_ibo_valid = 0;
153 cm->nverts = cm->nfaces = 0;
155 cm->bsph_valid = cm->aabb_valid = 0;
158 int cmesh_clone(struct cmesh *cmdest, struct cmesh *cmsrc)
162 float *varr[CMESH_NUM_ATTR] = {0};
163 unsigned int *iarr = 0;
165 /* do anything that can fail first, before making any changes to cmdest
166 * so we have the option of recovering gracefuly
169 if(!(name = malloc(strlen(cmsrc->name)))) {
172 strcpy(name, cmsrc->name);
174 if(cmesh_indexed(cmsrc)) {
175 num = dynarr_size(cmsrc->idata);
176 if(!(iarr = dynarr_alloc(num, sizeof *iarr))) {
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)))) {
187 dynarr_free(varr[i]);
198 for(i=0; i<CMESH_NUM_ATTR; i++) {
199 dynarr_free(cmdest->vattr[i].data);
201 if(cmesh_has_attrib(cmsrc, i)) {
202 cmesh_attrib(cmsrc, i); /* force validation of the actual data on the source mesh */
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;
212 memset(cmdest->vattr + i, 0, sizeof cmdest->vattr[i]);
216 dynarr_free(cmdest->idata);
217 if(cmesh_indexed(cmsrc)) {
218 cmesh_index(cmsrc); /* force validation .... */
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;
226 cmdest->idata_valid = cmdest->ibo_valid = 0;
232 cmdest->nverts = cmsrc->nverts;
233 cmdest->nfaces = cmsrc->nfaces;
235 memcpy(cmdest->cur_val, cmsrc->cur_val, sizeof cmdest->cur_val);
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;
247 int cmesh_set_name(struct cmesh *cm, const char *name)
249 int len = strlen(name);
250 char *tmp = malloc(len + 1);
254 memcpy(cm->name, name, len + 1);
258 const char *cmesh_name(struct cmesh *cm)
263 int cmesh_has_attrib(struct cmesh *cm, int attr)
265 if(attr < 0 || attr >= CMESH_NUM_ATTR) {
268 return cm->vattr[attr].vbo_valid | cm->vattr[attr].data_valid;
271 int cmesh_indexed(struct cmesh *cm)
273 return cm->ibo_valid | cm->idata_valid;
276 /* vdata can be 0, in which case only memory is allocated
277 * returns pointer to the attribute array
279 float *cmesh_set_attrib(struct cmesh *cm, int attr, int nelem, unsigned int num,
284 if(attr < 0 || attr >= CMESH_NUM_ATTR) {
287 if(cm->nverts && num != cm->nverts) {
291 if(!(newarr = dynarr_alloc(num * nelem, sizeof *newarr))) {
295 memcpy(newarr, vdata, num * nelem * sizeof *newarr);
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;
308 float *cmesh_attrib(struct cmesh *cm, int attr)
310 if(attr < 0 || attr >= CMESH_NUM_ATTR) {
313 cm->vattr[attr].vbo_valid = 0;
314 return (float*)cmesh_attrib_ro(cm, attr);
317 const float *cmesh_attrib_ro(struct cmesh *cm, int attr)
322 if(attr < 0 || attr >= CMESH_NUM_ATTR) {
326 if(!cm->vattr[attr].data_valid) {
327 #if GL_ES_VERSION_2_0
330 if(!cm->vattr[attr].vbo_valid) {
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))) {
339 cm->vattr[attr].data = tmp;
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);
346 cm->vattr[attr].data_valid = 1;
349 return cm->vattr[attr].data;
352 float *cmesh_attrib_at(struct cmesh *cm, int attr, int idx)
354 float *vptr = cmesh_attrib(cm, attr);
355 return vptr ? vptr + idx * cm->vattr[attr].nelem : 0;
358 const float *cmesh_attrib_at_ro(struct cmesh *cm, int attr, int idx)
360 const float *vptr = cmesh_attrib_ro(cm, attr);
361 return vptr ? vptr + idx * cm->vattr[attr].nelem : 0;
364 int cmesh_attrib_count(struct cmesh *cm, int attr)
366 return cmesh_has_attrib(cm, attr) ? cm->nverts : 0;
369 int cmesh_push_attrib(struct cmesh *cm, int attr, float *v)
373 int cursz = dynarr_size(cm->vattr[attr].data);
374 int newsz = cursz + cm->vattr[attr].nelem;
376 if(!(vptr = dynarr_resize(cm->vattr[attr].data, newsz))) {
379 cm->vattr[attr].data = vptr;
381 for(i=0; i<cm->vattr[attr].nelem; i++) {
384 cm->vattr[attr].vbo_valid = 0;
388 int cmesh_push_attrib1f(struct cmesh *cm, int attr, float x)
394 return cmesh_push_attrib(cm, attr, v);
397 int cmesh_push_attrib2f(struct cmesh *cm, int attr, float x, float y)
404 return cmesh_push_attrib(cm, attr, v);
407 int cmesh_push_attrib3f(struct cmesh *cm, int attr, float x, float y, float z)
414 return cmesh_push_attrib(cm, attr, v);
417 int cmesh_push_attrib4f(struct cmesh *cm, int attr, float x, float y, float z, float w)
424 return cmesh_push_attrib(cm, attr, v);
427 /* indices can be 0, in which case only memory is allocated
428 * returns pointer to the index array
430 unsigned int *cmesh_set_index(struct cmesh *cm, int num, const unsigned int *indices)
433 int nidx = cm->nfaces * 3;
435 if(nidx && num != nidx) {
439 if(!(tmp = dynarr_alloc(num, sizeof *tmp))) {
443 memcpy(tmp, indices, num * sizeof *tmp);
446 dynarr_free(cm->idata);
453 unsigned int *cmesh_index(struct cmesh *cm)
456 return (unsigned int*)cmesh_index_ro(cm);
459 const unsigned int *cmesh_index_ro(struct cmesh *cm)
464 if(!cm->idata_valid) {
465 #if GL_ES_VERSION_2_0
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))) {
477 dynarr_free(cm->idata);
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);
491 int cmesh_index_count(struct cmesh *cm)
493 return cm->nfaces * 3;
496 int cmesh_push_index(struct cmesh *cm, unsigned int idx)
499 if(!(iptr = dynarr_push(cm->idata, &idx))) {
506 int cmesh_poly_count(struct cmesh *cm)
512 return cm->nverts / 3;
517 /* attr can be -1 to invalidate all attributes */
518 void cmesh_invalidate_vbo(struct cmesh *cm, int attr)
522 if(attr >= CMESH_NUM_ATTR) {
527 for(i=0; i<CMESH_NUM_ATTR; i++) {
528 cm->vattr[i].vbo_valid = 0;
531 cm->vattr[attr].vbo_valid = 0;
535 void cmesh_invalidate_index(struct cmesh *cm)
540 int cmesh_append(struct cmesh *cmdest, struct cmesh *cmsrc)
542 int i, nelem, newsz, origsz, srcsz;
545 unsigned int idxoffs;
547 if(!cmdest->nverts) {
548 return cmesh_clone(cmdest, cmsrc);
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);
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;
562 if(!(vptr = dynarr_resize(cmdest->vattr[i].data, newsz))) {
565 memcpy(vptr + origsz, cmsrc->vattr[i].data, cmsrc->nverts * nelem * sizeof(float));
566 cmdest->vattr[i].data = vptr;
570 if(cmesh_indexed(cmdest)) {
571 assert(cmesh_indexed(cmsrc));
572 /* force validation ... */
574 cmesh_index_ro(cmsrc);
576 idxoffs = cmdest->nverts;
577 origsz = dynarr_size(cmdest->idata);
578 srcsz = dynarr_size(cmsrc->idata);
579 newsz = origsz + srcsz;
581 if(!(iptr = dynarr_resize(cmdest->idata, newsz))) {
584 cmdest->idata = iptr;
586 /* copy and fixup all the new indices */
588 for(i=0; i<srcsz; i++) {
589 *iptr++ = cmsrc->idata[i] + idxoffs;
593 cmdest->wire_ibo_valid = 0;
594 cmdest->aabb_valid = 0;
595 cmdest->bsph_valid = 0;
599 /* assemble a complete vertex by adding all the useful attributes */
600 int cmesh_vertex(struct cmesh *cm, float x, float y, float z)
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;
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);
613 cm->vattr[i].data = tmp;
616 cm->vattr[i].vbo_valid = 0;
617 cm->vattr[i].data_valid = 1;
620 if(cm->idata_valid) {
621 cm->idata = dynarr_clear(cm->idata);
623 cm->ibo_valid = cm->idata_valid = 0;
627 void cmesh_normal(struct cmesh *cm, float nx, float ny, float nz)
629 cgm_wcons(cm->cur_val + CMESH_ATTR_NORMAL, nx, ny, nz, 1.0f);
630 cm->vattr[CMESH_ATTR_NORMAL].nelem = 3;
633 void cmesh_tangent(struct cmesh *cm, float tx, float ty, float tz)
635 cgm_wcons(cm->cur_val + CMESH_ATTR_TANGENT, tx, ty, tz, 1.0f);
636 cm->vattr[CMESH_ATTR_TANGENT].nelem = 3;
639 void cmesh_texcoord(struct cmesh *cm, float u, float v, float w)
641 cgm_wcons(cm->cur_val + CMESH_ATTR_TEXCOORD, u, v, w, 1.0f);
642 cm->vattr[CMESH_ATTR_TEXCOORD].nelem = 3;
645 void cmesh_boneweights(struct cmesh *cm, float w1, float w2, float w3, float w4)
647 cgm_wcons(cm->cur_val + CMESH_ATTR_BONEWEIGHTS, w1, w2, w3, w4);
648 cm->vattr[CMESH_ATTR_BONEWEIGHTS].nelem = 4;
651 void cmesh_boneidx(struct cmesh *cm, int idx1, int idx2, int idx3, int idx4)
653 cgm_wcons(cm->cur_val + CMESH_ATTR_BONEIDX, idx1, idx2, idx3, idx4);
654 cm->vattr[CMESH_ATTR_BONEIDX].nelem = 4;
657 static float *get_vec4(struct cmesh *cm, int attr, int idx, cgm_vec4 *res)
661 cgm_wcons(res, 0, 0, 0, 1);
662 if(!(sptr = cmesh_attrib_at(cm, attr, idx))) {
667 for(i=0; i<cm->vattr[attr].nelem; i++) {
673 static float *get_vec3(struct cmesh *cm, int attr, int idx, cgm_vec3 *res)
677 cgm_vcons(res, 0, 0, 0);
678 if(!(sptr = cmesh_attrib_at(cm, attr, idx))) {
683 for(i=0; i<cm->vattr[attr].nelem; i++) {
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)
698 for(i=0; i<cm->nverts; i++) {
699 if(!(vptr = get_vec4(cm, CMESH_ATTR_VERTEX, i, &v))) {
702 cgm_wmul_m4v4(&v, xform);
703 for(j=0; j<cm->vattr[CMESH_ATTR_VERTEX].nelem; j++) {
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++) {
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++) {
726 void cmesh_flip(struct cmesh *cm)
728 cmesh_flip_faces(cm);
729 cmesh_flip_normals(cm);
732 void cmesh_flip_faces(struct cmesh *cm)
734 int i, j, idxnum, vnum, nelem;
735 unsigned int *indices;
738 if(cmesh_indexed(cm)) {
739 if(!(indices = cmesh_index(cm))) {
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;
749 if(!(verts = cmesh_attrib(cm, CMESH_ATTR_VERTEX))) {
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];
764 void cmesh_flip_normals(struct cmesh *cm)
767 float *nptr = cmesh_attrib(cm, CMESH_ATTR_NORMAL);
770 num = cm->nverts * cm->vattr[CMESH_ATTR_NORMAL].nelem;
771 for(i=0; i<num; i++) {
777 int cmesh_explode(struct cmesh *cm)
779 int i, j, k, idxnum, nnverts;
780 unsigned int *indices;
782 if(!cmesh_indexed(cm)) return 0;
784 indices = cmesh_index(cm);
787 idxnum = cmesh_index_count(cm);
790 for(i=0; i<CMESH_NUM_ATTR; i++) {
792 float *tmpbuf, *dstptr;
794 if(!cmesh_has_attrib(cm, i)) continue;
796 srcbuf = cmesh_attrib(cm, i);
797 if(!(tmpbuf = dynarr_alloc(nnverts * cm->vattr[i].nelem, sizeof(float)))) {
802 for(j=0; j<idxnum; j++) {
803 unsigned int idx = indices[j];
804 const float *srcptr = srcbuf + idx * cm->vattr[i].nelem;
806 for(k=0; k<cm->vattr[i].nelem; k++) {
807 *dstptr++ = *srcptr++;
811 dynarr_free(cm->vattr[i].data);
812 cm->vattr[i].data = tmpbuf;
813 cm->vattr[i].data_valid = 1;
818 cm->idata = dynarr_clear(cm->idata);
820 cm->nverts = nnverts;
821 cm->nfaces = idxnum / 3;
825 void cmesh_calc_face_normals(struct cmesh *cm)
830 static int pre_draw(struct cmesh *cm)
834 glGetIntegerv(GL_CURRENT_PROGRAM, &cur_sdr);
838 if(!cm->vattr[CMESH_ATTR_VERTEX].vbo_valid) {
842 if(cur_sdr && use_custom_sdr_attr) {
843 if(sdr_loc[CMESH_ATTR_VERTEX] == -1) {
847 for(i=0; i<CMESH_NUM_ATTR; 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);
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);
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);
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);
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);
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);
883 #endif /* GL_ES_VERSION_2_0 */
885 glBindBuffer(GL_ARRAY_BUFFER, 0);
889 void cmesh_draw(struct cmesh *cm)
893 if((cur_sdr = pre_draw(cm)) == -1) {
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);
902 glDrawArrays(GL_TRIANGLES, 0, cm->nverts);
905 post_draw(cm, cur_sdr);
908 static void post_draw(struct cmesh *cm, int cur_sdr)
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);
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);
925 if(cm->vattr[CMESH_ATTR_TEXCOORD].vbo_valid) {
926 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
928 if(cm->vattr[CMESH_ATTR_COLOR].vbo_valid) {
929 glDisableClientState(GL_COLOR_ARRAY);
931 if(cm->vattr[CMESH_ATTR_TEXCOORD2].vbo_valid) {
932 glClientActiveTexture(GL_TEXTURE1);
933 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
934 glClientActiveTexture(GL_TEXTURE0);
936 #endif /* GL_ES_VERSION_2_0 */
940 void cmesh_draw_wire(struct cmesh *cm, float linesz)
944 if((cur_sdr = pre_draw(cm)) == -1) {
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);
954 post_draw(cm, cur_sdr);
957 void cmesh_draw_vertices(struct cmesh *cm, float ptsz)
960 if((cur_sdr = pre_draw(cm)) == -1) {
964 glPushAttrib(GL_POINT_BIT);
966 glDrawArrays(GL_POINTS, 0, cm->nverts);
969 post_draw(cm, cur_sdr);
972 void cmesh_draw_normals(struct cmesh *cm, float len)
974 #ifndef GL_ES_VERSION_2_0
975 int i, cur_sdr, vert_nelem, norm_nelem;
977 const float *varr, *norm;
979 varr = cmesh_attrib_ro(cm, CMESH_ATTR_VERTEX);
980 norm = cmesh_attrib_ro(cm, CMESH_ATTR_NORMAL);
981 if(!varr || !norm) return;
983 vert_nelem = cm->vattr[CMESH_ATTR_VERTEX].nelem;
984 norm_nelem = cm->vattr[CMESH_ATTR_NORMAL].nelem;
986 glGetIntegerv(GL_CURRENT_PROGRAM, &cur_sdr);
987 if(cur_sdr && use_custom_sdr_attr) {
988 if((loc = sdr_loc[CMESH_ATTR_VERTEX]) < 0) {
994 for(i=0; i<cm->nverts; i++) {
995 float x, y, z, endx, endy, endz;
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;
1005 glVertex3f(x, y, z);
1006 glVertex3f(endx, endy, endz);
1008 glVertexAttrib3f(loc, x, y, z);
1009 glVertexAttrib3f(loc, endx, endy, endz);
1013 #endif /* GL_ES_VERSION_2_0 */
1016 void cmesh_draw_tangents(struct cmesh *cm, float len)
1018 #ifndef GL_ES_VERSION_2_0
1019 int i, cur_sdr, vert_nelem, tang_nelem;
1021 const float *varr, *tang;
1023 varr = cmesh_attrib_ro(cm, CMESH_ATTR_VERTEX);
1024 tang = cmesh_attrib_ro(cm, CMESH_ATTR_TANGENT);
1025 if(!varr || !tang) return;
1027 vert_nelem = cm->vattr[CMESH_ATTR_VERTEX].nelem;
1028 tang_nelem = cm->vattr[CMESH_ATTR_TANGENT].nelem;
1030 glGetIntegerv(GL_CURRENT_PROGRAM, &cur_sdr);
1031 if(cur_sdr && use_custom_sdr_attr) {
1032 if((loc = sdr_loc[CMESH_ATTR_VERTEX]) < 0) {
1038 for(i=0; i<cm->nverts; i++) {
1039 float x, y, z, endx, endy, endz;
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;
1049 glVertex3f(x, y, z);
1050 glVertex3f(endx, endy, endz);
1052 glVertexAttrib3f(loc, x, y, z);
1053 glVertexAttrib3f(loc, endx, endy, endz);
1057 #endif /* GL_ES_VERSION_2_0 */
1060 static void update_buffers(struct cmesh *cm)
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;
1072 glBindBuffer(GL_ARRAY_BUFFER, 0);
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);
1079 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
1083 static void update_wire_ibo(struct cmesh *cm)
1086 unsigned int *wire_idxarr, *dest;
1090 if(cm->wire_ibo_valid) return;
1093 glGenBuffers(1, &cm->wire_ibo);
1095 num_faces = cmesh_poly_count(cm);
1097 if(!(wire_idxarr = malloc(num_faces * 6 * sizeof *wire_idxarr))) {
1103 /* we're dealing with an indexed mesh */
1104 const unsigned int *idxarr = cmesh_index_ro(cm);
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];
1116 /* not an indexed mesh */
1117 for(i=0; i<num_faces; i++) {
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);
1132 cm->wire_ibo_valid = 1;
1133 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
1136 static void calc_aabb(struct cmesh *cm)
1140 if(!cmesh_attrib_ro(cm, CMESH_ATTR_VERTEX)) {
1144 cgm_vcons(&cm->aabb_min, FLT_MAX, FLT_MAX, FLT_MAX);
1145 cgm_vcons(&cm->aabb_max, -FLT_MAX, -FLT_MAX, -FLT_MAX);
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];
1153 if(v[j] > (&cm->aabb_max.x)[j]) {
1154 (&cm->aabb_max.x)[j] = v[j];
1161 void cmesh_aabbox(struct cmesh *cm, cgm_vec3 *vmin, cgm_vec3 *vmax)
1163 if(!cm->aabb_valid) {
1166 *vmin = cm->aabb_min;
1167 *vmax = cm->aabb_max;
1170 static void calc_bsph(struct cmesh *cm)
1175 if(!cmesh_attrib_ro(cm, CMESH_ATTR_VERTEX)) {
1179 cgm_vcons(&cm->bsph_center, 0, 0, 0);
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];
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;
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;
1200 cm->bsph_radius = sqrt(cm->bsph_radius);
1204 float cmesh_bsphere(struct cmesh *cm, cgm_vec3 *center, float *rad)
1206 if(!cm->bsph_valid) {
1209 *center = cm->bsph_center;
1210 *rad = cm->bsph_radius;
1211 return cm->bsph_radius;
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);
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);