10 struct cmesh_vattrib {
11 int nelem; /* num elements per attribute [1, 4] */
15 int vbo_valid, data_valid;
21 unsigned int nverts, nfaces;
23 /* current value for each attribute for the immediate mode interface */
24 cgm_vec4 cur_val[CMESH_NUM_ATTR];
26 unsigned int buffer_objects[CMESH_NUM_ATTR + 1];
27 struct cmesh_vattrib vattr[CMESH_NUM_ATTR];
32 int ibo_valid, idata_valid;
34 /* index buffer for wireframe rendering (constructed on demand) */
35 unsigned int wire_ibo;
38 /* axis-aligned bounding box */
39 cgm_vec3 aabb_min, aabb_max;
48 static int pre_draw(struct cmesh *cm);
49 static void post_draw(struct cmesh *cm, int cur_sdr);
50 static void update_buffers(struct cmesh *cm);
51 static void update_wire_ibo(struct cmesh *cm);
52 static void calc_aabb(struct cmesh *cm);
53 static void calc_bsph(struct cmesh *cm);
55 static int def_nelem[CMESH_NUM_ATTR] = {3, 3, 3, 2, 4, 4, 4, 2};
57 static int sdr_loc[CMESH_NUM_ATTR] = {0, 1, 2, 3, 4, 5, 6, 7};
58 static int use_custom_sdr_attr;
62 void cmesh_set_attrib_sdrloc(int attr, int loc)
67 int cmesh_get_attrib_sdrloc(int attr)
72 void cmesh_clear_attrib_sdrloc(void)
75 for(i=0; i<CMESH_NUM_ATTR; i++) {
81 struct cmesh *cmesh_alloc(void)
85 if(!(cm = malloc(sizeof *cm))) {
88 if(cmesh_init(cm) == -1) {
95 void cmesh_free(struct cmesh *cm)
101 int cmesh_init(struct cmesh *cm)
105 memset(cm, 0, sizeof *cm);
106 cgm_wcons(cm->cur_val + CMESH_ATTR_COLOR, 1, 1, 1, 1);
108 glGenBuffers(CMESH_NUM_ATTR + 1, cm->buffer_objects);
110 for(i=0; i<CMESH_NUM_ATTR; i++) {
111 cm->vattr[i].vbo = cm->buffer_objects[i];
114 cm->ibo = cm->buffer_objects[CMESH_NUM_ATTR];
118 void cmesh_destroy(struct cmesh *cm)
124 for(i=0; i<CMESH_NUM_ATTR; i++) {
125 free(cm->vattr[i].data);
129 glDeleteBuffers(CMESH_NUM_ATTR + 1, cm->buffer_objects);
131 glDeleteBuffers(1, &cm->wire_ibo);
135 void cmesh_clear(struct cmesh *cm)
139 for(i=0; i<CMESH_NUM_ATTR; i++) {
140 cm->vattr[i].nelem = 0;
141 cm->vattr[i].vbo_valid = 0;
142 cm->vattr[i].data_valid = 0;
143 free(cm->vattr[i].data);
144 cm->vattr[i].data = 0;
145 cm->vattr[i].count = 0;
147 cm->ibo_valid = cm->idata_valid = 0;
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 if(!(iarr = malloc(cmsrc->icount * sizeof *iarr))) {
180 for(i=0; i<CMESH_NUM_ATTR; i++) {
181 if(cmesh_has_attrib(cmsrc, i)) {
182 nelem = cmsrc->vattr[i].nelem;
183 if(!(varr[i] = malloc(cmsrc->vattr[i].count * nelem * sizeof(float)))) {
196 for(i=0; i<CMESH_NUM_ATTR; i++) {
197 free(cmdest->vattr[i].data);
199 if(cmesh_has_attrib(cmsrc, i)) {
200 cmesh_attrib(cmsrc, i); /* force validation of the actual data on the source mesh */
202 nelem = cmsrc->vattr[i].nelem;
203 cmdest->vattr[i].nelem = nelem;
204 cmdest->vattr[i].data = varr[i];
205 cmdest->vattr[i].count = cmsrc->vattr[i].count;
206 memcpy(cmdest->vattr[i].data, cmsrc->vattr[i].data, cmsrc->vattr[i].count * nelem * sizeof(float));
207 cmdest->vattr[i].data_valid = 1;
208 cmdest->vattr[i].vbo_valid = 0;
210 memset(cmdest->vattr + i, 0, sizeof cmdest->vattr[i]);
215 if(cmesh_indexed(cmsrc)) {
216 cmesh_index(cmsrc); /* force validation .... */
218 cmdest->idata = iarr;
219 cmdest->icount = cmsrc->icount;
220 memcpy(cmdest->idata, cmsrc->idata, cmsrc->icount * sizeof *cmdest->idata);
221 cmdest->idata_valid = 1;
224 cmdest->idata_valid = cmdest->ibo_valid = 0;
230 cmdest->nverts = cmsrc->nverts;
231 cmdest->nfaces = cmsrc->nfaces;
233 memcpy(cmdest->cur_val, cmsrc->cur_val, sizeof cmdest->cur_val);
235 cmdest->aabb_min = cmsrc->aabb_min;
236 cmdest->aabb_max = cmsrc->aabb_max;
237 cmdest->aabb_valid = cmsrc->aabb_valid;
238 cmdest->bsph_center = cmsrc->bsph_center;
239 cmdest->bsph_radius = cmsrc->bsph_radius;
240 cmdest->bsph_valid = cmsrc->bsph_valid;
245 int cmesh_set_name(struct cmesh *cm, const char *name)
247 int len = strlen(name);
248 char *tmp = malloc(len + 1);
252 memcpy(cm->name, name, len + 1);
256 const char *cmesh_name(struct cmesh *cm)
261 int cmesh_has_attrib(struct cmesh *cm, int attr)
263 if(attr < 0 || attr >= CMESH_NUM_ATTR) {
266 return cm->vattr[attr].vbo_valid | cm->vattr[attr].data_valid;
269 int cmesh_indexed(struct cmesh *cm)
271 return cm->ibo_valid | cm->idata_valid;
274 /* vdata can be 0, in which case only memory is allocated
275 * returns pointer to the attribute array
277 float *cmesh_set_attrib(struct cmesh *cm, int attr, int nelem, unsigned int num,
282 if(attr < 0 || attr >= CMESH_NUM_ATTR) {
285 if(cm->nverts && num != cm->nverts) {
289 if(!(newarr = malloc(num * nelem * sizeof *newarr))) {
293 memcpy(newarr, vdata, num * nelem * sizeof *newarr);
298 free(cm->vattr[attr].data);
299 cm->vattr[attr].data = newarr;
300 cm->vattr[attr].count = num * nelem;
301 cm->vattr[attr].nelem = nelem;
302 cm->vattr[attr].data_valid = 1;
303 cm->vattr[attr].vbo_valid = 0;
307 float *cmesh_attrib(struct cmesh *cm, int attr)
309 if(attr < 0 || attr >= CMESH_NUM_ATTR) {
312 cm->vattr[attr].vbo_valid = 0;
313 return (float*)cmesh_attrib_ro(cm, attr);
316 const float *cmesh_attrib_ro(struct cmesh *cm, int attr)
321 if(attr < 0 || attr >= CMESH_NUM_ATTR) {
325 if(!cm->vattr[attr].data_valid) {
326 #if GL_ES_VERSION_2_0
329 if(!cm->vattr[attr].vbo_valid) {
333 /* local data copy unavailable, grab the data from the vbo */
334 nelem = cm->vattr[attr].nelem;
335 if(!(cm->vattr[attr].data = malloc(cm->nverts * nelem * sizeof(float)))) {
338 cm->vattr[attr].count = cm->nverts * nelem;
340 glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[attr].vbo);
341 tmp = glMapBuffer(GL_ARRAY_BUFFER, GL_READ_ONLY);
342 memcpy(cm->vattr[attr].data, tmp, cm->nverts * nelem * sizeof(float));
343 glUnmapBuffer(GL_ARRAY_BUFFER);
345 cm->vattr[attr].data_valid = 1;
348 return cm->vattr[attr].data;
351 float *cmesh_attrib_at(struct cmesh *cm, int attr, int idx)
353 float *vptr = cmesh_attrib(cm, attr);
354 return vptr ? vptr + idx * cm->vattr[attr].nelem : 0;
357 const float *cmesh_attrib_at_ro(struct cmesh *cm, int attr, int idx)
359 const float *vptr = cmesh_attrib_ro(cm, attr);
360 return vptr ? vptr + idx * cm->vattr[attr].nelem : 0;
363 int cmesh_attrib_count(struct cmesh *cm, int attr)
365 return cmesh_has_attrib(cm, attr) ? cm->nverts : 0;
368 int cmesh_push_attrib(struct cmesh *cm, int attr, float *v)
373 if(!cm->vattr[attr].nelem) {
374 cm->vattr[attr].nelem = def_nelem[attr];
377 cursz = cm->vattr[attr].count;
378 newsz = cursz + cm->vattr[attr].nelem;
379 if(!(vptr = realloc(cm->vattr[attr].data, newsz * sizeof(float)))) {
382 cm->vattr[attr].data = vptr;
383 cm->vattr[attr].count = newsz;
386 for(i=0; i<cm->vattr[attr].nelem; i++) {
389 cm->vattr[attr].data_valid = 1;
390 cm->vattr[attr].vbo_valid = 0;
392 if(attr == CMESH_ATTR_VERTEX) {
393 cm->nverts = newsz / cm->vattr[attr].nelem;
398 int cmesh_push_attrib1f(struct cmesh *cm, int attr, float x)
404 return cmesh_push_attrib(cm, attr, v);
407 int cmesh_push_attrib2f(struct cmesh *cm, int attr, float x, float y)
414 return cmesh_push_attrib(cm, attr, v);
417 int cmesh_push_attrib3f(struct cmesh *cm, int attr, float x, float y, float z)
424 return cmesh_push_attrib(cm, attr, v);
427 int cmesh_push_attrib4f(struct cmesh *cm, int attr, float x, float y, float z, float w)
434 return cmesh_push_attrib(cm, attr, v);
437 /* indices can be 0, in which case only memory is allocated
438 * returns pointer to the index array
440 unsigned int *cmesh_set_index(struct cmesh *cm, int num, const unsigned int *indices)
443 int nidx = cm->nfaces * 3;
445 if(nidx && num != nidx) {
449 if(!(tmp = malloc(num * sizeof *tmp))) {
453 memcpy(tmp, indices, num * sizeof *tmp);
464 unsigned int *cmesh_index(struct cmesh *cm)
467 return (unsigned int*)cmesh_index_ro(cm);
470 const unsigned int *cmesh_index_ro(struct cmesh *cm)
475 if(!cm->idata_valid) {
476 #if GL_ES_VERSION_2_0
483 /* local copy is unavailable, grab the data from the ibo */
484 nidx = cm->nfaces * 3;
485 if(!(tmp = malloc(nidx * sizeof *cm->idata))) {
492 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cm->ibo);
493 tmp = glMapBuffer(GL_ELEMENT_ARRAY_BUFFER, GL_READ_ONLY);
494 memcpy(cm->idata, tmp, nidx * sizeof *cm->idata);
495 glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER);
503 int cmesh_index_count(struct cmesh *cm)
505 return cm->nfaces * 3;
508 int cmesh_push_index(struct cmesh *cm, unsigned int idx)
511 unsigned int cur_sz = cm->icount;
512 if(!(iptr = realloc(cm->idata, (cur_sz + 1) * sizeof *iptr))) {
517 cm->icount = cur_sz + 1;
521 cm->nfaces = cm->icount / 3;
525 int cmesh_poly_count(struct cmesh *cm)
531 return cm->nverts / 3;
536 /* attr can be -1 to invalidate all attributes */
537 void cmesh_invalidate_vbo(struct cmesh *cm, int attr)
541 if(attr >= CMESH_NUM_ATTR) {
546 for(i=0; i<CMESH_NUM_ATTR; i++) {
547 cm->vattr[i].vbo_valid = 0;
550 cm->vattr[attr].vbo_valid = 0;
554 void cmesh_invalidate_index(struct cmesh *cm)
559 int cmesh_append(struct cmesh *cmdest, struct cmesh *cmsrc)
561 int i, nelem, newsz, origsz, srcsz;
564 unsigned int idxoffs;
566 if(!cmdest->nverts) {
567 return cmesh_clone(cmdest, cmsrc);
570 for(i=0; i<CMESH_NUM_ATTR; i++) {
571 if(cmesh_has_attrib(cmdest, i) && cmesh_has_attrib(cmsrc, i)) {
572 /* force validation of the data arrays */
573 cmesh_attrib(cmdest, i);
574 cmesh_attrib_ro(cmsrc, i);
576 assert(cmdest->vattr[i].nelem == cmsrc->vattr[i].nelem);
577 nelem = cmdest->vattr[i].nelem;
578 origsz = cmdest->nverts * nelem;
579 newsz = cmdest->nverts + cmsrc->nverts * nelem;
581 if(!(vptr = realloc(cmdest->vattr[i].data, newsz * sizeof *vptr))) {
584 memcpy(vptr + origsz, cmsrc->vattr[i].data, cmsrc->nverts * nelem * sizeof(float));
585 cmdest->vattr[i].data = vptr;
586 cmdest->vattr[i].count = newsz;
590 if(cmesh_indexed(cmdest)) {
591 assert(cmesh_indexed(cmsrc));
592 /* force validation ... */
594 cmesh_index_ro(cmsrc);
596 idxoffs = cmdest->nverts;
597 origsz = cmdest->icount;
598 srcsz = cmsrc->icount;
599 newsz = origsz + srcsz;
601 if(!(iptr = realloc(cmdest->idata, newsz * sizeof *iptr))) {
604 cmdest->idata = iptr;
605 cmdest->icount = newsz;
607 /* copy and fixup all the new indices */
609 for(i=0; i<srcsz; i++) {
610 *iptr++ = cmsrc->idata[i] + idxoffs;
614 cmdest->wire_ibo_valid = 0;
615 cmdest->aabb_valid = 0;
616 cmdest->bsph_valid = 0;
620 /* assemble a complete vertex by adding all the useful attributes */
621 int cmesh_vertex(struct cmesh *cm, float x, float y, float z)
625 cgm_wcons(cm->cur_val + CMESH_ATTR_VERTEX, x, y, z, 1.0f);
626 cm->vattr[CMESH_ATTR_VERTEX].data_valid = 1;
627 cm->vattr[CMESH_ATTR_VERTEX].nelem = 3;
629 for(i=0; i<CMESH_NUM_ATTR; i++) {
630 if(cm->vattr[i].data_valid) {
631 int newsz = cm->vattr[i].count + cm->vattr[i].nelem;
632 float *tmp = realloc(cm->vattr[i].data, newsz * sizeof *tmp);
634 tmp += cm->vattr[i].count;
636 cm->vattr[i].data = tmp;
637 cm->vattr[i].count = newsz;
639 for(j=0; j<cm->vattr[i].nelem; j++) {
640 *tmp++ = *(&cm->cur_val[i].x + j);
643 cm->vattr[i].vbo_valid = 0;
644 cm->vattr[i].data_valid = 1;
647 if(cm->idata_valid) {
652 cm->ibo_valid = cm->idata_valid = 0;
656 void cmesh_normal(struct cmesh *cm, float nx, float ny, float nz)
658 cgm_wcons(cm->cur_val + CMESH_ATTR_NORMAL, nx, ny, nz, 1.0f);
659 cm->vattr[CMESH_ATTR_NORMAL].nelem = 3;
662 void cmesh_tangent(struct cmesh *cm, float tx, float ty, float tz)
664 cgm_wcons(cm->cur_val + CMESH_ATTR_TANGENT, tx, ty, tz, 1.0f);
665 cm->vattr[CMESH_ATTR_TANGENT].nelem = 3;
668 void cmesh_texcoord(struct cmesh *cm, float u, float v, float w)
670 cgm_wcons(cm->cur_val + CMESH_ATTR_TEXCOORD, u, v, w, 1.0f);
671 cm->vattr[CMESH_ATTR_TEXCOORD].nelem = 3;
674 void cmesh_boneweights(struct cmesh *cm, float w1, float w2, float w3, float w4)
676 cgm_wcons(cm->cur_val + CMESH_ATTR_BONEWEIGHTS, w1, w2, w3, w4);
677 cm->vattr[CMESH_ATTR_BONEWEIGHTS].nelem = 4;
680 void cmesh_boneidx(struct cmesh *cm, int idx1, int idx2, int idx3, int idx4)
682 cgm_wcons(cm->cur_val + CMESH_ATTR_BONEIDX, idx1, idx2, idx3, idx4);
683 cm->vattr[CMESH_ATTR_BONEIDX].nelem = 4;
686 static float *get_vec4(struct cmesh *cm, int attr, int idx, cgm_vec4 *res)
690 cgm_wcons(res, 0, 0, 0, 1);
691 if(!(sptr = cmesh_attrib_at(cm, attr, idx))) {
696 for(i=0; i<cm->vattr[attr].nelem; i++) {
702 static float *get_vec3(struct cmesh *cm, int attr, int idx, cgm_vec3 *res)
706 cgm_vcons(res, 0, 0, 0);
707 if(!(sptr = cmesh_attrib_at(cm, attr, idx))) {
712 for(i=0; i<cm->vattr[attr].nelem; i++) {
718 /* dir_xform can be null, in which case it's calculated from xform */
719 void cmesh_apply_xform(struct cmesh *cm, float *xform, float *dir_xform)
727 for(i=0; i<cm->nverts; i++) {
728 if(!(vptr = get_vec4(cm, CMESH_ATTR_VERTEX, i, &v))) {
731 cgm_wmul_m4v4(&v, xform);
732 for(j=0; j<cm->vattr[CMESH_ATTR_VERTEX].nelem; j++) {
736 if(cmesh_has_attrib(cm, CMESH_ATTR_NORMAL)) {
737 if((vptr = get_vec3(cm, CMESH_ATTR_NORMAL, i, &n))) {
738 cgm_vmul_m3v3(&n, dir_xform);
739 for(j=0; j<cm->vattr[CMESH_ATTR_NORMAL].nelem; j++) {
744 if(cmesh_has_attrib(cm, CMESH_ATTR_TANGENT)) {
745 if((vptr = get_vec3(cm, CMESH_ATTR_TANGENT, i, &t))) {
746 cgm_vmul_m3v3(&t, dir_xform);
747 for(j=0; j<cm->vattr[CMESH_ATTR_TANGENT].nelem; j++) {
755 void cmesh_flip(struct cmesh *cm)
757 cmesh_flip_faces(cm);
758 cmesh_flip_normals(cm);
761 void cmesh_flip_faces(struct cmesh *cm)
763 int i, j, idxnum, vnum, nelem;
764 unsigned int *indices;
767 if(cmesh_indexed(cm)) {
768 if(!(indices = cmesh_index(cm))) {
771 idxnum = cmesh_index_count(cm);
772 for(i=0; i<idxnum; i+=3) {
773 unsigned int tmp = indices[i + 2];
774 indices[i + 2] = indices[i + 1];
775 indices[i + 1] = tmp;
778 if(!(verts = cmesh_attrib(cm, CMESH_ATTR_VERTEX))) {
781 vnum = cmesh_attrib_count(cm, CMESH_ATTR_VERTEX);
782 nelem = cm->vattr[CMESH_ATTR_VERTEX].nelem;
783 for(i=0; i<vnum; i+=3) {
784 for(j=0; j<nelem; j++) {
785 vptr = verts + (i + 1) * nelem + j;
786 float tmp = vptr[nelem];
787 vptr[nelem] = vptr[0];
793 void cmesh_flip_normals(struct cmesh *cm)
796 float *nptr = cmesh_attrib(cm, CMESH_ATTR_NORMAL);
799 num = cm->nverts * cm->vattr[CMESH_ATTR_NORMAL].nelem;
800 for(i=0; i<num; i++) {
806 int cmesh_explode(struct cmesh *cm)
808 int i, j, k, idxnum, nnverts;
809 unsigned int *indices;
811 if(!cmesh_indexed(cm)) return 0;
813 indices = cmesh_index(cm);
816 idxnum = cmesh_index_count(cm);
819 for(i=0; i<CMESH_NUM_ATTR; i++) {
821 float *tmpbuf, *dstptr;
823 if(!cmesh_has_attrib(cm, i)) continue;
825 srcbuf = cmesh_attrib(cm, i);
826 if(!(tmpbuf = malloc(nnverts * cm->vattr[i].nelem * sizeof(float)))) {
831 for(j=0; j<idxnum; j++) {
832 unsigned int idx = indices[j];
833 const float *srcptr = srcbuf + idx * cm->vattr[i].nelem;
835 for(k=0; k<cm->vattr[i].nelem; k++) {
836 *dstptr++ = *srcptr++;
840 free(cm->vattr[i].data);
841 cm->vattr[i].data = tmpbuf;
842 cm->vattr[i].count = nnverts * cm->vattr[i].nelem;
843 cm->vattr[i].data_valid = 1;
852 cm->nverts = nnverts;
853 cm->nfaces = idxnum / 3;
857 void cmesh_calc_face_normals(struct cmesh *cm)
862 static int pre_draw(struct cmesh *cm)
866 glGetIntegerv(GL_CURRENT_PROGRAM, &cur_sdr);
870 if(!cm->vattr[CMESH_ATTR_VERTEX].vbo_valid) {
874 if(cur_sdr && use_custom_sdr_attr) {
875 if(sdr_loc[CMESH_ATTR_VERTEX] == -1) {
879 for(i=0; i<CMESH_NUM_ATTR; i++) {
881 if(loc >= 0 && cm->vattr[i].vbo_valid) {
882 glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[i].vbo);
883 glVertexAttribPointer(loc, cm->vattr[i].nelem, GL_FLOAT, GL_FALSE, 0, 0);
884 glEnableVertexAttribArray(loc);
888 #ifndef GL_ES_VERSION_2_0
889 glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[CMESH_ATTR_VERTEX].vbo);
890 glVertexPointer(cm->vattr[CMESH_ATTR_VERTEX].nelem, GL_FLOAT, 0, 0);
891 glEnableClientState(GL_VERTEX_ARRAY);
893 if(cm->vattr[CMESH_ATTR_NORMAL].vbo_valid) {
894 glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[CMESH_ATTR_NORMAL].vbo);
895 glNormalPointer(GL_FLOAT, 0, 0);
896 glEnableClientState(GL_NORMAL_ARRAY);
898 if(cm->vattr[CMESH_ATTR_TEXCOORD].vbo_valid) {
899 glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[CMESH_ATTR_TEXCOORD].vbo);
900 glTexCoordPointer(cm->vattr[CMESH_ATTR_TEXCOORD].nelem, GL_FLOAT, 0, 0);
901 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
903 if(cm->vattr[CMESH_ATTR_COLOR].vbo_valid) {
904 glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[CMESH_ATTR_COLOR].vbo);
905 glColorPointer(cm->vattr[CMESH_ATTR_COLOR].nelem, GL_FLOAT, 0, 0);
906 glEnableClientState(GL_COLOR_ARRAY);
908 if(cm->vattr[CMESH_ATTR_TEXCOORD2].vbo_valid) {
909 glClientActiveTexture(GL_TEXTURE1);
910 glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[CMESH_ATTR_TEXCOORD2].vbo);
911 glTexCoordPointer(cm->vattr[CMESH_ATTR_TEXCOORD2].nelem, GL_FLOAT, 0, 0);
912 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
913 glClientActiveTexture(GL_TEXTURE0);
915 #endif /* GL_ES_VERSION_2_0 */
917 glBindBuffer(GL_ARRAY_BUFFER, 0);
921 void cmesh_draw(struct cmesh *cm)
925 if((cur_sdr = pre_draw(cm)) == -1) {
930 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cm->ibo);
931 glDrawElements(GL_TRIANGLES, cm->nfaces * 3, GL_UNSIGNED_INT, 0);
932 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
934 glDrawArrays(GL_TRIANGLES, 0, cm->nverts);
937 post_draw(cm, cur_sdr);
940 static void post_draw(struct cmesh *cm, int cur_sdr)
944 if(cur_sdr && use_custom_sdr_attr) {
945 for(i=0; i<CMESH_NUM_ATTR; i++) {
946 int loc = sdr_loc[i];
947 if(loc >= 0 && cm->vattr[i].vbo_valid) {
948 glDisableVertexAttribArray(loc);
952 #ifndef GL_ES_VERSION_2_0
953 glDisableClientState(GL_VERTEX_ARRAY);
954 if(cm->vattr[CMESH_ATTR_NORMAL].vbo_valid) {
955 glDisableClientState(GL_NORMAL_ARRAY);
957 if(cm->vattr[CMESH_ATTR_TEXCOORD].vbo_valid) {
958 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
960 if(cm->vattr[CMESH_ATTR_COLOR].vbo_valid) {
961 glDisableClientState(GL_COLOR_ARRAY);
963 if(cm->vattr[CMESH_ATTR_TEXCOORD2].vbo_valid) {
964 glClientActiveTexture(GL_TEXTURE1);
965 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
966 glClientActiveTexture(GL_TEXTURE0);
968 #endif /* GL_ES_VERSION_2_0 */
972 void cmesh_draw_wire(struct cmesh *cm, float linesz)
976 if((cur_sdr = pre_draw(cm)) == -1) {
981 nfaces = cmesh_poly_count(cm);
982 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cm->wire_ibo);
983 glDrawElements(GL_LINES, nfaces * 6, GL_UNSIGNED_INT, 0);
984 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
986 post_draw(cm, cur_sdr);
989 void cmesh_draw_vertices(struct cmesh *cm, float ptsz)
992 if((cur_sdr = pre_draw(cm)) == -1) {
996 glPushAttrib(GL_POINT_BIT);
998 glDrawArrays(GL_POINTS, 0, cm->nverts);
1001 post_draw(cm, cur_sdr);
1004 void cmesh_draw_normals(struct cmesh *cm, float len)
1006 #ifndef GL_ES_VERSION_2_0
1007 int i, cur_sdr, vert_nelem, norm_nelem;
1009 const float *varr, *norm;
1011 varr = cmesh_attrib_ro(cm, CMESH_ATTR_VERTEX);
1012 norm = cmesh_attrib_ro(cm, CMESH_ATTR_NORMAL);
1013 if(!varr || !norm) return;
1015 vert_nelem = cm->vattr[CMESH_ATTR_VERTEX].nelem;
1016 norm_nelem = cm->vattr[CMESH_ATTR_NORMAL].nelem;
1018 glGetIntegerv(GL_CURRENT_PROGRAM, &cur_sdr);
1019 if(cur_sdr && use_custom_sdr_attr) {
1020 if((loc = sdr_loc[CMESH_ATTR_VERTEX]) < 0) {
1026 for(i=0; i<cm->nverts; i++) {
1027 float x, y, z, endx, endy, endz;
1029 x = varr[i * vert_nelem];
1030 y = varr[i * vert_nelem + 1];
1031 z = varr[i * vert_nelem + 2];
1032 endx = x + norm[i * norm_nelem] * len;
1033 endy = y + norm[i * norm_nelem + 1] * len;
1034 endz = z + norm[i * norm_nelem + 2] * len;
1037 glVertex3f(x, y, z);
1038 glVertex3f(endx, endy, endz);
1040 glVertexAttrib3f(loc, x, y, z);
1041 glVertexAttrib3f(loc, endx, endy, endz);
1045 #endif /* GL_ES_VERSION_2_0 */
1048 void cmesh_draw_tangents(struct cmesh *cm, float len)
1050 #ifndef GL_ES_VERSION_2_0
1051 int i, cur_sdr, vert_nelem, tang_nelem;
1053 const float *varr, *tang;
1055 varr = cmesh_attrib_ro(cm, CMESH_ATTR_VERTEX);
1056 tang = cmesh_attrib_ro(cm, CMESH_ATTR_TANGENT);
1057 if(!varr || !tang) return;
1059 vert_nelem = cm->vattr[CMESH_ATTR_VERTEX].nelem;
1060 tang_nelem = cm->vattr[CMESH_ATTR_TANGENT].nelem;
1062 glGetIntegerv(GL_CURRENT_PROGRAM, &cur_sdr);
1063 if(cur_sdr && use_custom_sdr_attr) {
1064 if((loc = sdr_loc[CMESH_ATTR_VERTEX]) < 0) {
1070 for(i=0; i<cm->nverts; i++) {
1071 float x, y, z, endx, endy, endz;
1073 x = varr[i * vert_nelem];
1074 y = varr[i * vert_nelem + 1];
1075 z = varr[i * vert_nelem + 2];
1076 endx = x + tang[i * tang_nelem] * len;
1077 endy = y + tang[i * tang_nelem + 1] * len;
1078 endz = z + tang[i * tang_nelem + 2] * len;
1081 glVertex3f(x, y, z);
1082 glVertex3f(endx, endy, endz);
1084 glVertexAttrib3f(loc, x, y, z);
1085 glVertexAttrib3f(loc, endx, endy, endz);
1089 #endif /* GL_ES_VERSION_2_0 */
1092 static void update_buffers(struct cmesh *cm)
1096 for(i=0; i<CMESH_NUM_ATTR; i++) {
1097 if(cmesh_has_attrib(cm, i) && !cm->vattr[i].vbo_valid) {
1098 glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[i].vbo);
1099 glBufferData(GL_ARRAY_BUFFER, cm->nverts * cm->vattr[i].nelem * sizeof(float),
1100 cm->vattr[i].data, GL_STATIC_DRAW);
1101 cm->vattr[i].vbo_valid = 1;
1104 glBindBuffer(GL_ARRAY_BUFFER, 0);
1106 if(cm->idata_valid && !cm->ibo_valid) {
1107 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cm->ibo);
1108 glBufferData(GL_ELEMENT_ARRAY_BUFFER, cm->nfaces * 3 * sizeof(unsigned int),
1109 cm->idata, GL_STATIC_DRAW);
1111 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
1115 static void update_wire_ibo(struct cmesh *cm)
1118 unsigned int *wire_idxarr, *dest;
1122 if(cm->wire_ibo_valid) return;
1125 glGenBuffers(1, &cm->wire_ibo);
1127 num_faces = cmesh_poly_count(cm);
1129 if(!(wire_idxarr = malloc(num_faces * 6 * sizeof *wire_idxarr))) {
1135 /* we're dealing with an indexed mesh */
1136 const unsigned int *idxarr = cmesh_index_ro(cm);
1138 for(i=0; i<num_faces; i++) {
1139 *dest++ = idxarr[0];
1140 *dest++ = idxarr[1];
1141 *dest++ = idxarr[1];
1142 *dest++ = idxarr[2];
1143 *dest++ = idxarr[2];
1144 *dest++ = idxarr[0];
1148 /* not an indexed mesh */
1149 for(i=0; i<num_faces; i++) {
1160 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cm->wire_ibo);
1161 glBufferData(GL_ELEMENT_ARRAY_BUFFER, num_faces * 6 * sizeof(unsigned int),
1162 wire_idxarr, GL_STATIC_DRAW);
1164 cm->wire_ibo_valid = 1;
1165 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
1168 static void calc_aabb(struct cmesh *cm)
1172 if(!cmesh_attrib_ro(cm, CMESH_ATTR_VERTEX)) {
1176 cgm_vcons(&cm->aabb_min, FLT_MAX, FLT_MAX, FLT_MAX);
1177 cgm_vcons(&cm->aabb_max, -FLT_MAX, -FLT_MAX, -FLT_MAX);
1179 for(i=0; i<cm->nverts; i++) {
1180 const float *v = cmesh_attrib_at_ro(cm, CMESH_ATTR_VERTEX, i);
1181 for(j=0; j<3; j++) {
1182 if(v[j] < (&cm->aabb_min.x)[j]) {
1183 (&cm->aabb_min.x)[j] = v[j];
1185 if(v[j] > (&cm->aabb_max.x)[j]) {
1186 (&cm->aabb_max.x)[j] = v[j];
1193 void cmesh_aabbox(struct cmesh *cm, cgm_vec3 *vmin, cgm_vec3 *vmax)
1195 if(!cm->aabb_valid) {
1198 *vmin = cm->aabb_min;
1199 *vmax = cm->aabb_max;
1202 static void calc_bsph(struct cmesh *cm)
1207 if(!cmesh_attrib_ro(cm, CMESH_ATTR_VERTEX)) {
1211 cgm_vcons(&cm->bsph_center, 0, 0, 0);
1213 /* first find the center */
1214 for(i=0; i<cm->nverts; i++) {
1215 const float *v = cmesh_attrib_at_ro(cm, CMESH_ATTR_VERTEX, i);
1216 cm->bsph_center.x += v[0];
1217 cm->bsph_center.y += v[1];
1218 cm->bsph_center.z += v[2];
1220 s = 1.0f / (float)cm->nverts;
1221 cm->bsph_center.x *= s;
1222 cm->bsph_center.y *= s;
1223 cm->bsph_center.z *= s;
1225 cm->bsph_radius = 0.0f;
1226 for(i=0; i<cm->nverts; i++) {
1227 const cgm_vec3 *v = (const cgm_vec3*)cmesh_attrib_at_ro(cm, CMESH_ATTR_VERTEX, i);
1228 if((dist_sq = cgm_vdist_sq(v, &cm->bsph_center)) > cm->bsph_radius) {
1229 cm->bsph_radius = dist_sq;
1232 cm->bsph_radius = sqrt(cm->bsph_radius);
1236 float cmesh_bsphere(struct cmesh *cm, cgm_vec3 *center, float *rad)
1238 if(!cm->bsph_valid) {
1241 *center = cm->bsph_center;
1242 *rad = cm->bsph_radius;
1243 return cm->bsph_radius;
1247 void cmesh_texcoord_apply_xform(struct cmesh *cm, float *xform);
1248 void cmesh_texcoord_gen_plane(struct cmesh *cm, cgm_vec3 *norm, cgm_vec3 *tang);
1249 void cmesh_texcoord_gen_box(struct cmesh *cm);
1250 void cmesh_texcoord_gen_cylinder(struct cmesh *cm);
1252 int cmesh_dump(struct cmesh *cm, const char *fname)
1254 FILE *fp = fopen(fname, "wb");
1256 int res = cmesh_dump_file(cm, fp);
1263 int cmesh_dump_file(struct cmesh *cm, FILE *fp)
1265 static const char *label[] = { "pos", "nor", "tan", "tex", "col", "bw", "bid", "tex2" };
1266 static const char *elemfmt[] = { 0, " %s(%g)", " %s(%g, %g)", " %s(%g, %g, %g)", " %s(%g, %g, %g, %g)", 0 };
1269 if(!cmesh_has_attrib(cm, CMESH_ATTR_VERTEX)) {
1273 fprintf(fp, "VERTEX ATTRIBUTES\n");
1275 for(i=0; i<cm->nverts; i++) {
1276 fprintf(fp, "%5u:", i);
1277 for(j=0; j<CMESH_NUM_ATTR; j++) {
1278 if(cmesh_has_attrib(cm, j)) {
1279 const float *v = cmesh_attrib_at_ro(cm, j, i);
1280 int nelem = cm->vattr[j].nelem;
1281 fprintf(fp, elemfmt[nelem], label[j], v[0], nelem > 1 ? v[1] : 0.0f,
1282 nelem > 2 ? v[2] : 0.0f, nelem > 3 ? v[3] : 0.0f);
1288 if(cmesh_indexed(cm)) {
1289 const unsigned int *idx = cmesh_index_ro(cm);
1290 int numidx = cmesh_index_count(cm);
1291 int numtri = numidx / 3;
1292 assert(numidx % 3 == 0);
1294 fprintf(fp, "FACES\n");
1296 for(i=0; i<numtri; i++) {
1297 fprintf(fp, "%5d: %d %d %d\n", i, idx[0], idx[1], idx[2]);
1304 int cmesh_dump_obj(struct cmesh *cm, const char *fname)
1306 FILE *fp = fopen(fname, "wb");
1308 int res = cmesh_dump_obj_file(cm, fp, 0);
1318 int cmesh_dump_obj_file(struct cmesh *cm, FILE *fp, int voffs)
1320 static const char *fmtstr[] = {" %u", " %u//%u", " %u/%u", " %u/%u/%u"};
1321 int i, j, num, nelem;
1322 unsigned int aflags = 0;
1324 if(!cmesh_has_attrib(cm, CMESH_ATTR_VERTEX)) {
1329 nelem = cm->vattr[CMESH_ATTR_VERTEX].nelem;
1330 if((num = cm->vattr[CMESH_ATTR_VERTEX].count) != cm->nverts * nelem) {
1331 warning_log("vertex array size (%d) != nverts (%d)\n", num, cm->nverts);
1333 for(i=0; i<cm->nverts; i++) {
1334 const float *v = cmesh_attrib_at_ro(cm, CMESH_ATTR_VERTEX, i);
1335 fprintf(fp, "v %f %f %f\n", v[0], nelem > 1 ? v[1] : 0.0f, nelem > 2 ? v[2] : 0.0f);
1338 if(cmesh_has_attrib(cm, CMESH_ATTR_NORMAL)) {
1340 nelem = cm->vattr[CMESH_ATTR_NORMAL].nelem;
1341 if((num = cm->vattr[CMESH_ATTR_NORMAL].count) != cm->nverts * nelem) {
1342 warning_log("normal array size (%d) != nverts (%d)\n", num, cm->nverts);
1344 for(i=0; i<cm->nverts; i++) {
1345 const float *v = cmesh_attrib_at_ro(cm, CMESH_ATTR_NORMAL, i);
1346 fprintf(fp, "vn %f %f %f\n", v[0], nelem > 1 ? v[1] : 0.0f, nelem > 2 ? v[2] : 0.0f);
1350 if(cmesh_has_attrib(cm, CMESH_ATTR_TEXCOORD)) {
1352 nelem = cm->vattr[CMESH_ATTR_TEXCOORD].nelem;
1353 if((num = cm->vattr[CMESH_ATTR_TEXCOORD].count) != cm->nverts * nelem) {
1354 warning_log("texcoord array size (%d) != nverts (%d)\n", num, cm->nverts);
1356 for(i=0; i<cm->nverts; i++) {
1357 const float *v = cmesh_attrib_at_ro(cm, CMESH_ATTR_TEXCOORD, i);
1358 fprintf(fp, "vt %f %f\n", v[0], nelem > 1 ? v[1] : 0.0f);
1362 if(cmesh_indexed(cm)) {
1363 const unsigned int *idxptr = cmesh_index_ro(cm);
1364 int numidx = cmesh_index_count(cm);
1365 int numtri = numidx / 3;
1366 assert(numidx % 3 == 0);
1368 for(i=0; i<numtri; i++) {
1370 for(j=0; j<3; j++) {
1371 unsigned int idx = *idxptr++ + 1 + voffs;
1372 fprintf(fp, fmtstr[aflags], idx, idx, idx);
1377 int numtri = cm->nverts / 3;
1378 unsigned int idx = 1 + voffs;
1379 for(i=0; i<numtri; i++) {
1381 for(j=0; j<3; j++) {
1382 fprintf(fp, fmtstr[aflags], idx, idx, idx);