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);
52 static int def_nelem[CMESH_NUM_ATTR] = {3, 3, 3, 2, 4, 4, 4, 2};
54 static int sdr_loc[CMESH_NUM_ATTR] = {0, 1, 2, 3, 4, 5, 6, 7};
55 static int use_custom_sdr_attr;
59 void cmesh_set_attrib_sdrloc(int attr, int loc)
64 int cmesh_get_attrib_sdrloc(int attr)
69 void cmesh_clear_attrib_sdrloc(void)
72 for(i=0; i<CMESH_NUM_ATTR; i++) {
78 struct cmesh *cmesh_alloc(void)
82 if(!(cm = malloc(sizeof *cm))) {
85 if(cmesh_init(cm) == -1) {
92 void cmesh_free(struct cmesh *cm)
98 int cmesh_init(struct cmesh *cm)
102 memset(cm, 0, sizeof *cm);
103 cgm_wcons(cm->cur_val + CMESH_ATTR_COLOR, 1, 1, 1, 1);
105 glGenBuffers(CMESH_NUM_ATTR + 1, cm->buffer_objects);
107 for(i=0; i<CMESH_NUM_ATTR; i++) {
108 if(!(cm->vattr[i].data = dynarr_alloc(0, sizeof(float)))) {
112 cm->vattr[i].vbo = cm->buffer_objects[i];
115 cm->ibo = cm->buffer_objects[CMESH_NUM_ATTR];
116 if(!(cm->idata = dynarr_alloc(0, sizeof *cm->idata))) {
123 void cmesh_destroy(struct cmesh *cm)
129 for(i=0; i<CMESH_NUM_ATTR; i++) {
130 dynarr_free(cm->vattr[i].data);
132 dynarr_free(cm->idata);
134 glDeleteBuffers(CMESH_NUM_ATTR + 1, cm->buffer_objects);
136 glDeleteBuffers(1, &cm->wire_ibo);
140 void cmesh_clear(struct cmesh *cm)
144 for(i=0; i<CMESH_NUM_ATTR; i++) {
145 cm->vattr[i].nelem = 0;
146 cm->vattr[i].vbo_valid = 0;
147 cm->vattr[i].data_valid = 0;
148 cm->vattr[i].data = dynarr_clear(cm->vattr[i].data);
150 cm->ibo_valid = cm->idata_valid = 0;
151 cm->idata = dynarr_clear(cm->idata);
153 cm->wire_ibo_valid = 0;
154 cm->nverts = cm->nfaces = 0;
156 cm->bsph_valid = cm->aabb_valid = 0;
159 int cmesh_clone(struct cmesh *cmdest, struct cmesh *cmsrc)
163 float *varr[CMESH_NUM_ATTR] = {0};
164 unsigned int *iarr = 0;
166 /* do anything that can fail first, before making any changes to cmdest
167 * so we have the option of recovering gracefuly
170 if(!(name = malloc(strlen(cmsrc->name)))) {
173 strcpy(name, cmsrc->name);
175 if(cmesh_indexed(cmsrc)) {
176 num = dynarr_size(cmsrc->idata);
177 if(!(iarr = dynarr_alloc(num, sizeof *iarr))) {
182 for(i=0; i<CMESH_NUM_ATTR; i++) {
183 if(cmesh_has_attrib(cmsrc, i)) {
184 nelem = cmsrc->vattr[i].nelem;
185 num = dynarr_size(cmsrc->vattr[i].data);
186 if(!(varr[i] = dynarr_alloc(num * nelem, sizeof(float)))) {
188 dynarr_free(varr[i]);
199 for(i=0; i<CMESH_NUM_ATTR; i++) {
200 dynarr_free(cmdest->vattr[i].data);
202 if(cmesh_has_attrib(cmsrc, i)) {
203 cmesh_attrib(cmsrc, i); /* force validation of the actual data on the source mesh */
205 nelem = cmsrc->vattr[i].nelem;
206 cmdest->vattr[i].nelem = nelem;
207 num = dynarr_size(cmsrc->vattr[i].data);
208 cmdest->vattr[i].data = varr[i];
209 memcpy(cmdest->vattr[i].data, cmsrc->vattr[i].data, num * nelem * sizeof(float));
210 cmdest->vattr[i].data_valid = 1;
211 cmdest->vattr[i].vbo_valid = 0;
213 memset(cmdest->vattr + i, 0, sizeof cmdest->vattr[i]);
217 dynarr_free(cmdest->idata);
218 if(cmesh_indexed(cmsrc)) {
219 cmesh_index(cmsrc); /* force validation .... */
221 num = dynarr_size(cmsrc->idata);
222 cmdest->idata = iarr;
223 memcpy(cmdest->idata, cmsrc->idata, num * sizeof *cmdest->idata);
224 cmdest->idata_valid = 1;
227 cmdest->idata_valid = cmdest->ibo_valid = 0;
233 cmdest->nverts = cmsrc->nverts;
234 cmdest->nfaces = cmsrc->nfaces;
236 memcpy(cmdest->cur_val, cmsrc->cur_val, sizeof cmdest->cur_val);
238 cmdest->aabb_min = cmsrc->aabb_min;
239 cmdest->aabb_max = cmsrc->aabb_max;
240 cmdest->aabb_valid = cmsrc->aabb_valid;
241 cmdest->bsph_center = cmsrc->bsph_center;
242 cmdest->bsph_radius = cmsrc->bsph_radius;
243 cmdest->bsph_valid = cmsrc->bsph_valid;
248 int cmesh_set_name(struct cmesh *cm, const char *name)
250 int len = strlen(name);
251 char *tmp = malloc(len + 1);
255 memcpy(cm->name, name, len + 1);
259 const char *cmesh_name(struct cmesh *cm)
264 int cmesh_has_attrib(struct cmesh *cm, int attr)
266 if(attr < 0 || attr >= CMESH_NUM_ATTR) {
269 return cm->vattr[attr].vbo_valid | cm->vattr[attr].data_valid;
272 int cmesh_indexed(struct cmesh *cm)
274 return cm->ibo_valid | cm->idata_valid;
277 /* vdata can be 0, in which case only memory is allocated
278 * returns pointer to the attribute array
280 float *cmesh_set_attrib(struct cmesh *cm, int attr, int nelem, unsigned int num,
285 if(attr < 0 || attr >= CMESH_NUM_ATTR) {
288 if(cm->nverts && num != cm->nverts) {
292 if(!(newarr = dynarr_alloc(num * nelem, sizeof *newarr))) {
296 memcpy(newarr, vdata, num * nelem * sizeof *newarr);
301 dynarr_free(cm->vattr[attr].data);
302 cm->vattr[attr].data = newarr;
303 cm->vattr[attr].nelem = nelem;
304 cm->vattr[attr].data_valid = 1;
305 cm->vattr[attr].vbo_valid = 0;
309 float *cmesh_attrib(struct cmesh *cm, int attr)
311 if(attr < 0 || attr >= CMESH_NUM_ATTR) {
314 cm->vattr[attr].vbo_valid = 0;
315 return (float*)cmesh_attrib_ro(cm, attr);
318 const float *cmesh_attrib_ro(struct cmesh *cm, int attr)
323 if(attr < 0 || attr >= CMESH_NUM_ATTR) {
327 if(!cm->vattr[attr].data_valid) {
328 #if GL_ES_VERSION_2_0
331 if(!cm->vattr[attr].vbo_valid) {
335 /* local data copy unavailable, grab the data from the vbo */
336 nelem = cm->vattr[attr].nelem;
337 if(!(tmp = dynarr_resize(cm->vattr[attr].data, cm->nverts * nelem))) {
340 cm->vattr[attr].data = tmp;
342 glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[attr].vbo);
343 tmp = glMapBuffer(GL_ARRAY_BUFFER, GL_READ_ONLY);
344 memcpy(cm->vattr[attr].data, tmp, cm->nverts * nelem * sizeof(float));
345 glUnmapBuffer(GL_ARRAY_BUFFER);
347 cm->vattr[attr].data_valid = 1;
350 return cm->vattr[attr].data;
353 float *cmesh_attrib_at(struct cmesh *cm, int attr, int idx)
355 float *vptr = cmesh_attrib(cm, attr);
356 return vptr ? vptr + idx * cm->vattr[attr].nelem : 0;
359 const float *cmesh_attrib_at_ro(struct cmesh *cm, int attr, int idx)
361 const float *vptr = cmesh_attrib_ro(cm, attr);
362 return vptr ? vptr + idx * cm->vattr[attr].nelem : 0;
365 int cmesh_attrib_count(struct cmesh *cm, int attr)
367 return cmesh_has_attrib(cm, attr) ? cm->nverts : 0;
370 int cmesh_push_attrib(struct cmesh *cm, int attr, float *v)
375 if(!cm->vattr[attr].nelem) {
376 cm->vattr[attr].nelem = def_nelem[attr];
379 cursz = dynarr_size(cm->vattr[attr].data);
380 newsz = cursz + cm->vattr[attr].nelem;
381 if(!(vptr = dynarr_resize(cm->vattr[attr].data, newsz))) {
384 cm->vattr[attr].data = vptr;
387 for(i=0; i<cm->vattr[attr].nelem; i++) {
390 cm->vattr[attr].data_valid = 1;
391 cm->vattr[attr].vbo_valid = 0;
393 if(attr == CMESH_ATTR_VERTEX) {
394 cm->nverts = newsz / cm->vattr[attr].nelem;
399 int cmesh_push_attrib1f(struct cmesh *cm, int attr, float x)
405 return cmesh_push_attrib(cm, attr, v);
408 int cmesh_push_attrib2f(struct cmesh *cm, int attr, float x, float y)
415 return cmesh_push_attrib(cm, attr, v);
418 int cmesh_push_attrib3f(struct cmesh *cm, int attr, float x, float y, float z)
425 return cmesh_push_attrib(cm, attr, v);
428 int cmesh_push_attrib4f(struct cmesh *cm, int attr, float x, float y, float z, float w)
435 return cmesh_push_attrib(cm, attr, v);
438 /* indices can be 0, in which case only memory is allocated
439 * returns pointer to the index array
441 unsigned int *cmesh_set_index(struct cmesh *cm, int num, const unsigned int *indices)
444 int nidx = cm->nfaces * 3;
446 if(nidx && num != nidx) {
450 if(!(tmp = dynarr_alloc(num, sizeof *tmp))) {
454 memcpy(tmp, indices, num * sizeof *tmp);
457 dynarr_free(cm->idata);
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 = dynarr_alloc(nidx, sizeof *cm->idata))) {
488 dynarr_free(cm->idata);
491 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cm->ibo);
492 tmp = glMapBuffer(GL_ELEMENT_ARRAY_BUFFER, GL_READ_ONLY);
493 memcpy(cm->idata, tmp, nidx * sizeof *cm->idata);
494 glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER);
502 int cmesh_index_count(struct cmesh *cm)
504 return cm->nfaces * 3;
507 int cmesh_push_index(struct cmesh *cm, unsigned int idx)
510 if(!(iptr = dynarr_push(cm->idata, &idx))) {
517 cm->nfaces = dynarr_size(cm->idata) / 3;
521 int cmesh_poly_count(struct cmesh *cm)
527 return cm->nverts / 3;
532 /* attr can be -1 to invalidate all attributes */
533 void cmesh_invalidate_vbo(struct cmesh *cm, int attr)
537 if(attr >= CMESH_NUM_ATTR) {
542 for(i=0; i<CMESH_NUM_ATTR; i++) {
543 cm->vattr[i].vbo_valid = 0;
546 cm->vattr[attr].vbo_valid = 0;
550 void cmesh_invalidate_index(struct cmesh *cm)
555 int cmesh_append(struct cmesh *cmdest, struct cmesh *cmsrc)
557 int i, nelem, newsz, origsz, srcsz;
560 unsigned int idxoffs;
562 if(!cmdest->nverts) {
563 return cmesh_clone(cmdest, cmsrc);
566 for(i=0; i<CMESH_NUM_ATTR; i++) {
567 if(cmesh_has_attrib(cmdest, i) && cmesh_has_attrib(cmsrc, i)) {
568 /* force validation of the data arrays */
569 cmesh_attrib(cmdest, i);
570 cmesh_attrib_ro(cmsrc, i);
572 assert(cmdest->vattr[i].nelem == cmsrc->vattr[i].nelem);
573 nelem = cmdest->vattr[i].nelem;
574 origsz = cmdest->nverts * nelem;
575 newsz = cmdest->nverts + cmsrc->nverts * nelem;
577 if(!(vptr = dynarr_resize(cmdest->vattr[i].data, newsz))) {
580 memcpy(vptr + origsz, cmsrc->vattr[i].data, cmsrc->nverts * nelem * sizeof(float));
581 cmdest->vattr[i].data = vptr;
585 if(cmesh_indexed(cmdest)) {
586 assert(cmesh_indexed(cmsrc));
587 /* force validation ... */
589 cmesh_index_ro(cmsrc);
591 idxoffs = cmdest->nverts;
592 origsz = dynarr_size(cmdest->idata);
593 srcsz = dynarr_size(cmsrc->idata);
594 newsz = origsz + srcsz;
596 if(!(iptr = dynarr_resize(cmdest->idata, newsz))) {
599 cmdest->idata = iptr;
601 /* copy and fixup all the new indices */
603 for(i=0; i<srcsz; i++) {
604 *iptr++ = cmsrc->idata[i] + idxoffs;
608 cmdest->wire_ibo_valid = 0;
609 cmdest->aabb_valid = 0;
610 cmdest->bsph_valid = 0;
614 /* assemble a complete vertex by adding all the useful attributes */
615 int cmesh_vertex(struct cmesh *cm, float x, float y, float z)
619 cgm_wcons(cm->cur_val + CMESH_ATTR_VERTEX, x, y, z, 1.0f);
620 cm->vattr[CMESH_ATTR_VERTEX].data_valid = 1;
621 cm->vattr[CMESH_ATTR_VERTEX].nelem = 3;
623 for(i=0; i<CMESH_ATTR_VERTEX; i++) {
624 if(cm->vattr[i].data_valid) {
625 for(j=0; j<cm->vattr[CMESH_ATTR_VERTEX].nelem; j++) {
626 float *tmp = dynarr_push(cm->vattr[i].data, &cm->cur_val[i].x + j);
628 cm->vattr[i].data = tmp;
631 cm->vattr[i].vbo_valid = 0;
632 cm->vattr[i].data_valid = 1;
635 if(cm->idata_valid) {
636 cm->idata = dynarr_clear(cm->idata);
638 cm->ibo_valid = cm->idata_valid = 0;
642 void cmesh_normal(struct cmesh *cm, float nx, float ny, float nz)
644 cgm_wcons(cm->cur_val + CMESH_ATTR_NORMAL, nx, ny, nz, 1.0f);
645 cm->vattr[CMESH_ATTR_NORMAL].nelem = 3;
648 void cmesh_tangent(struct cmesh *cm, float tx, float ty, float tz)
650 cgm_wcons(cm->cur_val + CMESH_ATTR_TANGENT, tx, ty, tz, 1.0f);
651 cm->vattr[CMESH_ATTR_TANGENT].nelem = 3;
654 void cmesh_texcoord(struct cmesh *cm, float u, float v, float w)
656 cgm_wcons(cm->cur_val + CMESH_ATTR_TEXCOORD, u, v, w, 1.0f);
657 cm->vattr[CMESH_ATTR_TEXCOORD].nelem = 3;
660 void cmesh_boneweights(struct cmesh *cm, float w1, float w2, float w3, float w4)
662 cgm_wcons(cm->cur_val + CMESH_ATTR_BONEWEIGHTS, w1, w2, w3, w4);
663 cm->vattr[CMESH_ATTR_BONEWEIGHTS].nelem = 4;
666 void cmesh_boneidx(struct cmesh *cm, int idx1, int idx2, int idx3, int idx4)
668 cgm_wcons(cm->cur_val + CMESH_ATTR_BONEIDX, idx1, idx2, idx3, idx4);
669 cm->vattr[CMESH_ATTR_BONEIDX].nelem = 4;
672 static float *get_vec4(struct cmesh *cm, int attr, int idx, cgm_vec4 *res)
676 cgm_wcons(res, 0, 0, 0, 1);
677 if(!(sptr = cmesh_attrib_at(cm, attr, idx))) {
682 for(i=0; i<cm->vattr[attr].nelem; i++) {
688 static float *get_vec3(struct cmesh *cm, int attr, int idx, cgm_vec3 *res)
692 cgm_vcons(res, 0, 0, 0);
693 if(!(sptr = cmesh_attrib_at(cm, attr, idx))) {
698 for(i=0; i<cm->vattr[attr].nelem; i++) {
704 /* dir_xform can be null, in which case it's calculated from xform */
705 void cmesh_apply_xform(struct cmesh *cm, float *xform, float *dir_xform)
713 for(i=0; i<cm->nverts; i++) {
714 if(!(vptr = get_vec4(cm, CMESH_ATTR_VERTEX, i, &v))) {
717 cgm_wmul_m4v4(&v, xform);
718 for(j=0; j<cm->vattr[CMESH_ATTR_VERTEX].nelem; j++) {
722 if(cmesh_has_attrib(cm, CMESH_ATTR_NORMAL)) {
723 if((vptr = get_vec3(cm, CMESH_ATTR_NORMAL, i, &n))) {
724 cgm_vmul_m3v3(&n, dir_xform);
725 for(j=0; j<cm->vattr[CMESH_ATTR_NORMAL].nelem; j++) {
730 if(cmesh_has_attrib(cm, CMESH_ATTR_TANGENT)) {
731 if((vptr = get_vec3(cm, CMESH_ATTR_TANGENT, i, &t))) {
732 cgm_vmul_m3v3(&t, dir_xform);
733 for(j=0; j<cm->vattr[CMESH_ATTR_TANGENT].nelem; j++) {
741 void cmesh_flip(struct cmesh *cm)
743 cmesh_flip_faces(cm);
744 cmesh_flip_normals(cm);
747 void cmesh_flip_faces(struct cmesh *cm)
749 int i, j, idxnum, vnum, nelem;
750 unsigned int *indices;
753 if(cmesh_indexed(cm)) {
754 if(!(indices = cmesh_index(cm))) {
757 idxnum = cmesh_index_count(cm);
758 for(i=0; i<idxnum; i+=3) {
759 unsigned int tmp = indices[i + 2];
760 indices[i + 2] = indices[i + 1];
761 indices[i + 1] = tmp;
764 if(!(verts = cmesh_attrib(cm, CMESH_ATTR_VERTEX))) {
767 vnum = cmesh_attrib_count(cm, CMESH_ATTR_VERTEX);
768 nelem = cm->vattr[CMESH_ATTR_VERTEX].nelem;
769 for(i=0; i<vnum; i+=3) {
770 for(j=0; j<nelem; j++) {
771 vptr = verts + (i + 1) * nelem + j;
772 float tmp = vptr[nelem];
773 vptr[nelem] = vptr[0];
779 void cmesh_flip_normals(struct cmesh *cm)
782 float *nptr = cmesh_attrib(cm, CMESH_ATTR_NORMAL);
785 num = cm->nverts * cm->vattr[CMESH_ATTR_NORMAL].nelem;
786 for(i=0; i<num; i++) {
792 int cmesh_explode(struct cmesh *cm)
794 int i, j, k, idxnum, nnverts;
795 unsigned int *indices;
797 if(!cmesh_indexed(cm)) return 0;
799 indices = cmesh_index(cm);
802 idxnum = cmesh_index_count(cm);
805 for(i=0; i<CMESH_NUM_ATTR; i++) {
807 float *tmpbuf, *dstptr;
809 if(!cmesh_has_attrib(cm, i)) continue;
811 srcbuf = cmesh_attrib(cm, i);
812 if(!(tmpbuf = dynarr_alloc(nnverts * cm->vattr[i].nelem, sizeof(float)))) {
817 for(j=0; j<idxnum; j++) {
818 unsigned int idx = indices[j];
819 const float *srcptr = srcbuf + idx * cm->vattr[i].nelem;
821 for(k=0; k<cm->vattr[i].nelem; k++) {
822 *dstptr++ = *srcptr++;
826 dynarr_free(cm->vattr[i].data);
827 cm->vattr[i].data = tmpbuf;
828 cm->vattr[i].data_valid = 1;
833 cm->idata = dynarr_clear(cm->idata);
835 cm->nverts = nnverts;
836 cm->nfaces = idxnum / 3;
840 void cmesh_calc_face_normals(struct cmesh *cm)
845 static int pre_draw(struct cmesh *cm)
849 glGetIntegerv(GL_CURRENT_PROGRAM, &cur_sdr);
853 if(!cm->vattr[CMESH_ATTR_VERTEX].vbo_valid) {
857 if(cur_sdr && use_custom_sdr_attr) {
858 if(sdr_loc[CMESH_ATTR_VERTEX] == -1) {
862 for(i=0; i<CMESH_NUM_ATTR; i++) {
864 if(loc >= 0 && cm->vattr[i].vbo_valid) {
865 glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[i].vbo);
866 glVertexAttribPointer(loc, cm->vattr[i].nelem, GL_FLOAT, GL_FALSE, 0, 0);
867 glEnableVertexAttribArray(loc);
871 #ifndef GL_ES_VERSION_2_0
872 glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[CMESH_ATTR_VERTEX].vbo);
873 glVertexPointer(cm->vattr[CMESH_ATTR_VERTEX].nelem, GL_FLOAT, 0, 0);
874 glEnableClientState(GL_VERTEX_ARRAY);
876 if(cm->vattr[CMESH_ATTR_NORMAL].vbo_valid) {
877 glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[CMESH_ATTR_NORMAL].vbo);
878 glNormalPointer(GL_FLOAT, 0, 0);
879 glEnableClientState(GL_NORMAL_ARRAY);
881 if(cm->vattr[CMESH_ATTR_TEXCOORD].vbo_valid) {
882 glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[CMESH_ATTR_TEXCOORD].vbo);
883 glTexCoordPointer(cm->vattr[CMESH_ATTR_TEXCOORD].nelem, GL_FLOAT, 0, 0);
884 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
886 if(cm->vattr[CMESH_ATTR_COLOR].vbo_valid) {
887 glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[CMESH_ATTR_COLOR].vbo);
888 glColorPointer(cm->vattr[CMESH_ATTR_COLOR].nelem, GL_FLOAT, 0, 0);
889 glEnableClientState(GL_COLOR_ARRAY);
891 if(cm->vattr[CMESH_ATTR_TEXCOORD2].vbo_valid) {
892 glClientActiveTexture(GL_TEXTURE1);
893 glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[CMESH_ATTR_TEXCOORD2].vbo);
894 glTexCoordPointer(cm->vattr[CMESH_ATTR_TEXCOORD2].nelem, GL_FLOAT, 0, 0);
895 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
896 glClientActiveTexture(GL_TEXTURE0);
898 #endif /* GL_ES_VERSION_2_0 */
900 glBindBuffer(GL_ARRAY_BUFFER, 0);
904 void cmesh_draw(struct cmesh *cm)
908 if((cur_sdr = pre_draw(cm)) == -1) {
913 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cm->ibo);
914 glDrawElements(GL_TRIANGLES, cm->nfaces * 3, GL_UNSIGNED_INT, 0);
915 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
917 glDrawArrays(GL_TRIANGLES, 0, cm->nverts);
920 post_draw(cm, cur_sdr);
923 static void post_draw(struct cmesh *cm, int cur_sdr)
927 if(cur_sdr && use_custom_sdr_attr) {
928 for(i=0; i<CMESH_NUM_ATTR; i++) {
929 int loc = sdr_loc[i];
930 if(loc >= 0 && cm->vattr[i].vbo_valid) {
931 glDisableVertexAttribArray(loc);
935 #ifndef GL_ES_VERSION_2_0
936 glDisableClientState(GL_VERTEX_ARRAY);
937 if(cm->vattr[CMESH_ATTR_NORMAL].vbo_valid) {
938 glDisableClientState(GL_NORMAL_ARRAY);
940 if(cm->vattr[CMESH_ATTR_TEXCOORD].vbo_valid) {
941 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
943 if(cm->vattr[CMESH_ATTR_COLOR].vbo_valid) {
944 glDisableClientState(GL_COLOR_ARRAY);
946 if(cm->vattr[CMESH_ATTR_TEXCOORD2].vbo_valid) {
947 glClientActiveTexture(GL_TEXTURE1);
948 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
949 glClientActiveTexture(GL_TEXTURE0);
951 #endif /* GL_ES_VERSION_2_0 */
955 void cmesh_draw_wire(struct cmesh *cm, float linesz)
959 if((cur_sdr = pre_draw(cm)) == -1) {
964 nfaces = cmesh_poly_count(cm);
965 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cm->wire_ibo);
966 glDrawElements(GL_LINES, nfaces * 6, GL_UNSIGNED_INT, 0);
967 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
969 post_draw(cm, cur_sdr);
972 void cmesh_draw_vertices(struct cmesh *cm, float ptsz)
975 if((cur_sdr = pre_draw(cm)) == -1) {
979 glPushAttrib(GL_POINT_BIT);
981 glDrawArrays(GL_POINTS, 0, cm->nverts);
984 post_draw(cm, cur_sdr);
987 void cmesh_draw_normals(struct cmesh *cm, float len)
989 #ifndef GL_ES_VERSION_2_0
990 int i, cur_sdr, vert_nelem, norm_nelem;
992 const float *varr, *norm;
994 varr = cmesh_attrib_ro(cm, CMESH_ATTR_VERTEX);
995 norm = cmesh_attrib_ro(cm, CMESH_ATTR_NORMAL);
996 if(!varr || !norm) return;
998 vert_nelem = cm->vattr[CMESH_ATTR_VERTEX].nelem;
999 norm_nelem = cm->vattr[CMESH_ATTR_NORMAL].nelem;
1001 glGetIntegerv(GL_CURRENT_PROGRAM, &cur_sdr);
1002 if(cur_sdr && use_custom_sdr_attr) {
1003 if((loc = sdr_loc[CMESH_ATTR_VERTEX]) < 0) {
1009 for(i=0; i<cm->nverts; i++) {
1010 float x, y, z, endx, endy, endz;
1012 x = varr[i * vert_nelem];
1013 y = varr[i * vert_nelem + 1];
1014 z = varr[i * vert_nelem + 2];
1015 endx = x + norm[i * norm_nelem] * len;
1016 endy = y + norm[i * norm_nelem + 1] * len;
1017 endz = z + norm[i * norm_nelem + 2] * len;
1020 glVertex3f(x, y, z);
1021 glVertex3f(endx, endy, endz);
1023 glVertexAttrib3f(loc, x, y, z);
1024 glVertexAttrib3f(loc, endx, endy, endz);
1028 #endif /* GL_ES_VERSION_2_0 */
1031 void cmesh_draw_tangents(struct cmesh *cm, float len)
1033 #ifndef GL_ES_VERSION_2_0
1034 int i, cur_sdr, vert_nelem, tang_nelem;
1036 const float *varr, *tang;
1038 varr = cmesh_attrib_ro(cm, CMESH_ATTR_VERTEX);
1039 tang = cmesh_attrib_ro(cm, CMESH_ATTR_TANGENT);
1040 if(!varr || !tang) return;
1042 vert_nelem = cm->vattr[CMESH_ATTR_VERTEX].nelem;
1043 tang_nelem = cm->vattr[CMESH_ATTR_TANGENT].nelem;
1045 glGetIntegerv(GL_CURRENT_PROGRAM, &cur_sdr);
1046 if(cur_sdr && use_custom_sdr_attr) {
1047 if((loc = sdr_loc[CMESH_ATTR_VERTEX]) < 0) {
1053 for(i=0; i<cm->nverts; i++) {
1054 float x, y, z, endx, endy, endz;
1056 x = varr[i * vert_nelem];
1057 y = varr[i * vert_nelem + 1];
1058 z = varr[i * vert_nelem + 2];
1059 endx = x + tang[i * tang_nelem] * len;
1060 endy = y + tang[i * tang_nelem + 1] * len;
1061 endz = z + tang[i * tang_nelem + 2] * len;
1064 glVertex3f(x, y, z);
1065 glVertex3f(endx, endy, endz);
1067 glVertexAttrib3f(loc, x, y, z);
1068 glVertexAttrib3f(loc, endx, endy, endz);
1072 #endif /* GL_ES_VERSION_2_0 */
1075 static void update_buffers(struct cmesh *cm)
1079 for(i=0; i<CMESH_NUM_ATTR; i++) {
1080 if(cmesh_has_attrib(cm, i) && !cm->vattr[i].vbo_valid) {
1081 glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[i].vbo);
1082 glBufferData(GL_ARRAY_BUFFER, cm->nverts * cm->vattr[i].nelem * sizeof(float),
1083 cm->vattr[i].data, GL_STATIC_DRAW);
1084 cm->vattr[i].vbo_valid = 1;
1087 glBindBuffer(GL_ARRAY_BUFFER, 0);
1089 if(cm->idata_valid && !cm->ibo_valid) {
1090 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cm->ibo);
1091 glBufferData(GL_ELEMENT_ARRAY_BUFFER, cm->nfaces * 3 * sizeof(unsigned int),
1092 cm->idata, GL_STATIC_DRAW);
1094 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
1098 static void update_wire_ibo(struct cmesh *cm)
1101 unsigned int *wire_idxarr, *dest;
1105 if(cm->wire_ibo_valid) return;
1108 glGenBuffers(1, &cm->wire_ibo);
1110 num_faces = cmesh_poly_count(cm);
1112 if(!(wire_idxarr = malloc(num_faces * 6 * sizeof *wire_idxarr))) {
1118 /* we're dealing with an indexed mesh */
1119 const unsigned int *idxarr = cmesh_index_ro(cm);
1121 for(i=0; i<num_faces; i++) {
1122 *dest++ = idxarr[0];
1123 *dest++ = idxarr[1];
1124 *dest++ = idxarr[1];
1125 *dest++ = idxarr[2];
1126 *dest++ = idxarr[2];
1127 *dest++ = idxarr[0];
1131 /* not an indexed mesh */
1132 for(i=0; i<num_faces; i++) {
1143 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cm->wire_ibo);
1144 glBufferData(GL_ELEMENT_ARRAY_BUFFER, num_faces * 6 * sizeof(unsigned int),
1145 wire_idxarr, GL_STATIC_DRAW);
1147 cm->wire_ibo_valid = 1;
1148 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
1151 static void calc_aabb(struct cmesh *cm)
1155 if(!cmesh_attrib_ro(cm, CMESH_ATTR_VERTEX)) {
1159 cgm_vcons(&cm->aabb_min, FLT_MAX, FLT_MAX, FLT_MAX);
1160 cgm_vcons(&cm->aabb_max, -FLT_MAX, -FLT_MAX, -FLT_MAX);
1162 for(i=0; i<cm->nverts; i++) {
1163 const float *v = cmesh_attrib_at_ro(cm, CMESH_ATTR_VERTEX, i);
1164 for(j=0; j<3; j++) {
1165 if(v[j] < (&cm->aabb_min.x)[j]) {
1166 (&cm->aabb_min.x)[j] = v[j];
1168 if(v[j] > (&cm->aabb_max.x)[j]) {
1169 (&cm->aabb_max.x)[j] = v[j];
1176 void cmesh_aabbox(struct cmesh *cm, cgm_vec3 *vmin, cgm_vec3 *vmax)
1178 if(!cm->aabb_valid) {
1181 *vmin = cm->aabb_min;
1182 *vmax = cm->aabb_max;
1185 static void calc_bsph(struct cmesh *cm)
1190 if(!cmesh_attrib_ro(cm, CMESH_ATTR_VERTEX)) {
1194 cgm_vcons(&cm->bsph_center, 0, 0, 0);
1196 /* first find the center */
1197 for(i=0; i<cm->nverts; i++) {
1198 const float *v = cmesh_attrib_at_ro(cm, CMESH_ATTR_VERTEX, i);
1199 cm->bsph_center.x += v[0];
1200 cm->bsph_center.y += v[1];
1201 cm->bsph_center.z += v[2];
1203 s = 1.0f / (float)cm->nverts;
1204 cm->bsph_center.x *= s;
1205 cm->bsph_center.y *= s;
1206 cm->bsph_center.z *= s;
1208 cm->bsph_radius = 0.0f;
1209 for(i=0; i<cm->nverts; i++) {
1210 const cgm_vec3 *v = (const cgm_vec3*)cmesh_attrib_at_ro(cm, CMESH_ATTR_VERTEX, i);
1211 if((dist_sq = cgm_vdist_sq(v, &cm->bsph_center)) > cm->bsph_radius) {
1212 cm->bsph_radius = dist_sq;
1215 cm->bsph_radius = sqrt(cm->bsph_radius);
1219 float cmesh_bsphere(struct cmesh *cm, cgm_vec3 *center, float *rad)
1221 if(!cm->bsph_valid) {
1224 *center = cm->bsph_center;
1225 *rad = cm->bsph_radius;
1226 return cm->bsph_radius;
1230 void cmesh_texcoord_apply_xform(struct cmesh *cm, float *xform);
1231 void cmesh_texcoord_gen_plane(struct cmesh *cm, cgm_vec3 *norm, cgm_vec3 *tang);
1232 void cmesh_texcoord_gen_box(struct cmesh *cm);
1233 void cmesh_texcoord_gen_cylinder(struct cmesh *cm);
1235 int cmesh_dump(struct cmesh *cm, const char *fname);
1236 int cmesh_dump_file(struct cmesh *cm, FILE *fp);
1237 int cmesh_dump_obj(struct cmesh *cm, const char *fname);
1238 int cmesh_dump_obj_file(struct cmesh *cm, FILE *fp, int voffs);