11 struct cmesh_vattrib {
12 int nelem; /* num elements per attribute [1, 4] */
14 unsigned int count; /* number of floats in data */
16 int vbo_valid, data_valid;
19 /* istart,icount are valid only when the mesh is indexed, otherwise icount is 0.
20 * vstart,vcount are define the submesh for non-indexed meshes.
21 * For indexed meshes, vstart,vcount denote the range of vertices used by each
26 int nfaces; /* derived from either icount or vcount */
34 unsigned int nverts, nfaces;
36 struct submesh *sublist, *subtail;
39 /* current value for each attribute for the immediate mode interface */
40 cgm_vec4 cur_val[CMESH_NUM_ATTR];
42 unsigned int buffer_objects[CMESH_NUM_ATTR + 1];
43 struct cmesh_vattrib vattr[CMESH_NUM_ATTR];
48 int ibo_valid, idata_valid;
50 /* index buffer for wireframe rendering (constructed on demand) */
51 unsigned int wire_ibo;
54 /* axis-aligned bounding box */
55 cgm_vec3 aabb_min, aabb_max;
64 static int clone(struct cmesh *cmdest, const struct cmesh *cmsrc, struct submesh *sub);
65 static int pre_draw(const struct cmesh *cm);
66 static void post_draw(const struct cmesh *cm, int cur_sdr);
67 static void update_buffers(struct cmesh *cm);
68 static void update_wire_ibo(struct cmesh *cm);
69 static void calc_aabb(struct cmesh *cm);
70 static void calc_bsph(struct cmesh *cm);
72 static int def_nelem[CMESH_NUM_ATTR] = {3, 3, 3, 2, 4, 4, 4, 2};
74 static int sdr_loc[CMESH_NUM_ATTR] = {0, 1, 2, 3, 4, 5, 6, 7};
75 static int use_custom_sdr_attr;
79 void cmesh_set_attrib_sdrloc(int attr, int loc)
84 int cmesh_get_attrib_sdrloc(int attr)
89 void cmesh_clear_attrib_sdrloc(void)
92 for(i=0; i<CMESH_NUM_ATTR; i++) {
98 struct cmesh *cmesh_alloc(void)
102 if(!(cm = malloc(sizeof *cm))) {
105 if(cmesh_init(cm) == -1) {
112 void cmesh_free(struct cmesh *cm)
118 int cmesh_init(struct cmesh *cm)
122 memset(cm, 0, sizeof *cm);
123 cgm_wcons(cm->cur_val + CMESH_ATTR_COLOR, 1, 1, 1, 1);
125 glGenBuffers(CMESH_NUM_ATTR + 1, cm->buffer_objects);
127 for(i=0; i<CMESH_NUM_ATTR; i++) {
128 cm->vattr[i].vbo = cm->buffer_objects[i];
131 cm->ibo = cm->buffer_objects[CMESH_NUM_ATTR];
135 void cmesh_destroy(struct cmesh *cm)
141 for(i=0; i<CMESH_NUM_ATTR; i++) {
142 free(cm->vattr[i].data);
146 cmesh_clear_submeshes(cm);
148 glDeleteBuffers(CMESH_NUM_ATTR + 1, cm->buffer_objects);
150 glDeleteBuffers(1, &cm->wire_ibo);
154 void cmesh_clear(struct cmesh *cm)
158 for(i=0; i<CMESH_NUM_ATTR; i++) {
159 cm->vattr[i].nelem = 0;
160 cm->vattr[i].vbo_valid = 0;
161 cm->vattr[i].data_valid = 0;
162 free(cm->vattr[i].data);
163 cm->vattr[i].data = 0;
164 cm->vattr[i].count = 0;
166 cm->ibo_valid = cm->idata_valid = 0;
171 cm->wire_ibo_valid = 0;
172 cm->nverts = cm->nfaces = 0;
174 cm->bsph_valid = cm->aabb_valid = 0;
176 cmesh_clear_submeshes(cm);
179 int cmesh_clone(struct cmesh *cmdest, const struct cmesh *cmsrc)
181 return clone(cmdest, cmsrc, 0);
184 static int clone(struct cmesh *cmdest, const struct cmesh *cmsrc, struct submesh *sub)
186 int i, nelem, vstart, vcount, istart, icount;
187 char *srcname, *name = 0;
188 float *varr[CMESH_NUM_ATTR] = {0};
190 unsigned int *iptr, *iarr = 0;
192 /* try do anything that can fail first, before making any changes to cmdest
193 * so we have the option of recovering gracefuly
196 srcname = sub ? sub->name : cmsrc->name;
198 if(!(name = malloc(strlen(srcname) + 1))) {
201 strcpy(name, srcname);
205 vstart = sub->vstart;
206 vcount = sub->vcount;
207 istart = sub->istart;
208 icount = sub->icount;
211 vcount = cmsrc->nverts;
212 icount = cmsrc->icount;
215 if(cmesh_indexed(cmsrc)) {
216 if(!(iarr = malloc(icount * sizeof *iarr))) {
222 for(i=0; i<CMESH_NUM_ATTR; i++) {
223 if(cmesh_has_attrib(cmsrc, i)) {
224 nelem = cmsrc->vattr[i].nelem;
225 if(!(varr[i] = malloc(vcount * nelem * sizeof(float)))) {
236 /* from this point forward nothing can fail */
239 for(i=0; i<CMESH_NUM_ATTR; i++) {
240 free(cmdest->vattr[i].data);
242 if(cmesh_has_attrib(cmsrc, i)) {
243 /* force validation of the actual data on the source mesh */
244 cmesh_attrib((struct cmesh*)cmsrc, i);
246 nelem = cmsrc->vattr[i].nelem;
247 cmdest->vattr[i].nelem = nelem;
248 cmdest->vattr[i].data = varr[i];
249 cmdest->vattr[i].count = vcount * nelem;
250 vptr = cmsrc->vattr[i].data + vstart * nelem;
251 memcpy(cmdest->vattr[i].data, vptr, vcount * nelem * sizeof(float));
252 cmdest->vattr[i].data_valid = 1;
253 cmdest->vattr[i].vbo_valid = 0;
255 memset(cmdest->vattr + i, 0, sizeof cmdest->vattr[i]);
259 if(cmesh_indexed(cmsrc)) {
260 /* force validation .... */
261 cmesh_index((struct cmesh*)cmsrc);
263 cmdest->idata = iarr;
264 cmdest->icount = icount;
266 /* need to offset all vertex indices by -vstart */
267 iptr = cmsrc->idata + istart;
268 for(i=0; i<icount; i++) {
269 cmdest->idata[i] = *iptr++ - vstart;
272 memcpy(cmdest->idata, cmsrc->idata + istart, icount * sizeof *cmdest->idata);
274 cmdest->idata_valid = 1;
277 cmdest->idata_valid = cmdest->ibo_valid = 0;
283 cmdest->nverts = cmsrc->nverts;
284 cmdest->nfaces = sub ? sub->nfaces : cmsrc->nfaces;
286 memcpy(cmdest->cur_val, cmsrc->cur_val, sizeof cmdest->cur_val);
288 cmdest->aabb_min = cmsrc->aabb_min;
289 cmdest->aabb_max = cmsrc->aabb_max;
290 cmdest->aabb_valid = cmsrc->aabb_valid;
291 cmdest->bsph_center = cmsrc->bsph_center;
292 cmdest->bsph_radius = cmsrc->bsph_radius;
293 cmdest->bsph_valid = cmsrc->bsph_valid;
295 /* copy sublist only if we're not cloning a submesh */
297 struct submesh *sm, *n, *head = 0, *tail = 0;
301 if(!(n = malloc(sizeof *n)) || !(name = malloc(strlen(sm->name) + 1))) {
306 strcpy(name, sm->name);
321 cmdest->sublist = head;
322 cmdest->subtail = tail;
323 cmdest->subcount = cmsrc->subcount;
329 int cmesh_set_name(struct cmesh *cm, const char *name)
331 int len = strlen(name);
332 char *tmp = malloc(len + 1);
336 memcpy(cm->name, name, len + 1);
340 const char *cmesh_name(const struct cmesh *cm)
345 int cmesh_has_attrib(const struct cmesh *cm, int attr)
347 if(attr < 0 || attr >= CMESH_NUM_ATTR) {
350 return cm->vattr[attr].vbo_valid | cm->vattr[attr].data_valid;
353 int cmesh_indexed(const struct cmesh *cm)
355 return cm->ibo_valid | cm->idata_valid;
358 /* vdata can be 0, in which case only memory is allocated
359 * returns pointer to the attribute array
361 float *cmesh_set_attrib(struct cmesh *cm, int attr, int nelem, unsigned int num,
366 if(attr < 0 || attr >= CMESH_NUM_ATTR) {
369 if(cm->nverts && num != cm->nverts) {
373 if(!(newarr = malloc(num * nelem * sizeof *newarr))) {
377 memcpy(newarr, vdata, num * nelem * sizeof *newarr);
382 free(cm->vattr[attr].data);
383 cm->vattr[attr].data = newarr;
384 cm->vattr[attr].count = num * nelem;
385 cm->vattr[attr].nelem = nelem;
386 cm->vattr[attr].data_valid = 1;
387 cm->vattr[attr].vbo_valid = 0;
391 float *cmesh_attrib(struct cmesh *cm, int attr)
393 if(attr < 0 || attr >= CMESH_NUM_ATTR) {
396 cm->vattr[attr].vbo_valid = 0;
397 return (float*)cmesh_attrib_ro(cm, attr);
400 const float *cmesh_attrib_ro(const struct cmesh *cm, int attr)
405 if(attr < 0 || attr >= CMESH_NUM_ATTR) {
409 if(!cm->vattr[attr].data_valid) {
410 #if GL_ES_VERSION_2_0
413 struct cmesh *m = (struct cmesh*)cm;
415 if(!m->vattr[attr].vbo_valid) {
419 /* local data copy unavailable, grab the data from the vbo */
420 nelem = m->vattr[attr].nelem;
421 if(!(m->vattr[attr].data = malloc(m->nverts * nelem * sizeof(float)))) {
424 m->vattr[attr].count = m->nverts * nelem;
426 glBindBuffer(GL_ARRAY_BUFFER, m->vattr[attr].vbo);
427 tmp = glMapBuffer(GL_ARRAY_BUFFER, GL_READ_ONLY);
428 memcpy(m->vattr[attr].data, tmp, m->nverts * nelem * sizeof(float));
429 glUnmapBuffer(GL_ARRAY_BUFFER);
431 m->vattr[attr].data_valid = 1;
434 return cm->vattr[attr].data;
437 float *cmesh_attrib_at(struct cmesh *cm, int attr, int idx)
439 float *vptr = cmesh_attrib(cm, attr);
440 return vptr ? vptr + idx * cm->vattr[attr].nelem : 0;
443 const float *cmesh_attrib_at_ro(const struct cmesh *cm, int attr, int idx)
445 const float *vptr = cmesh_attrib_ro(cm, attr);
446 return vptr ? vptr + idx * cm->vattr[attr].nelem : 0;
449 int cmesh_attrib_count(const struct cmesh *cm, int attr)
451 return cmesh_has_attrib(cm, attr) ? cm->nverts : 0;
454 int cmesh_attrib_nelem(const struct cmesh *cm, int attr)
456 return cmesh_has_attrib(cm, attr) ? cm->vattr[attr].nelem : 0;
459 int cmesh_push_attrib(struct cmesh *cm, int attr, float *v)
464 if(!cm->vattr[attr].nelem) {
465 cm->vattr[attr].nelem = def_nelem[attr];
468 cursz = cm->vattr[attr].count;
469 newsz = cursz + cm->vattr[attr].nelem;
470 if(!(vptr = realloc(cm->vattr[attr].data, newsz * sizeof(float)))) {
473 cm->vattr[attr].data = vptr;
474 cm->vattr[attr].count = newsz;
477 for(i=0; i<cm->vattr[attr].nelem; i++) {
480 cm->vattr[attr].data_valid = 1;
481 cm->vattr[attr].vbo_valid = 0;
483 if(attr == CMESH_ATTR_VERTEX) {
484 cm->nverts = newsz / cm->vattr[attr].nelem;
489 int cmesh_push_attrib1f(struct cmesh *cm, int attr, float x)
495 return cmesh_push_attrib(cm, attr, v);
498 int cmesh_push_attrib2f(struct cmesh *cm, int attr, float x, float y)
505 return cmesh_push_attrib(cm, attr, v);
508 int cmesh_push_attrib3f(struct cmesh *cm, int attr, float x, float y, float z)
515 return cmesh_push_attrib(cm, attr, v);
518 int cmesh_push_attrib4f(struct cmesh *cm, int attr, float x, float y, float z, float w)
525 return cmesh_push_attrib(cm, attr, v);
528 /* indices can be 0, in which case only memory is allocated
529 * returns pointer to the index array
531 unsigned int *cmesh_set_index(struct cmesh *cm, int num, const unsigned int *indices)
534 int nidx = cm->nfaces * 3;
536 if(nidx && num != nidx) {
540 if(!(tmp = malloc(num * sizeof *tmp))) {
544 memcpy(tmp, indices, num * sizeof *tmp);
550 cm->nfaces = num / 3;
556 unsigned int *cmesh_index(struct cmesh *cm)
559 return (unsigned int*)cmesh_index_ro(cm);
562 const unsigned int *cmesh_index_ro(const struct cmesh *cm)
567 if(!cm->idata_valid) {
568 #if GL_ES_VERSION_2_0
571 struct cmesh *m = (struct cmesh*)cm;
577 /* local copy is unavailable, grab the data from the ibo */
578 nidx = m->nfaces * 3;
579 if(!(tmp = malloc(nidx * sizeof *m->idata))) {
586 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m->ibo);
587 tmp = glMapBuffer(GL_ELEMENT_ARRAY_BUFFER, GL_READ_ONLY);
588 memcpy(m->idata, tmp, nidx * sizeof *m->idata);
589 glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER);
597 int cmesh_index_count(const struct cmesh *cm)
599 return cm->nfaces * 3;
602 int cmesh_push_index(struct cmesh *cm, unsigned int idx)
605 unsigned int cur_sz = cm->icount;
606 if(!(iptr = realloc(cm->idata, (cur_sz + 1) * sizeof *iptr))) {
611 cm->icount = cur_sz + 1;
615 cm->nfaces = cm->icount / 3;
619 int cmesh_poly_count(const struct cmesh *cm)
625 return cm->nverts / 3;
630 /* attr can be -1 to invalidate all attributes */
631 void cmesh_invalidate_vbo(struct cmesh *cm, int attr)
635 if(attr >= CMESH_NUM_ATTR) {
640 for(i=0; i<CMESH_NUM_ATTR; i++) {
641 cm->vattr[i].vbo_valid = 0;
644 cm->vattr[attr].vbo_valid = 0;
648 void cmesh_invalidate_index(struct cmesh *cm)
653 int cmesh_append(struct cmesh *cmdest, const struct cmesh *cmsrc)
655 int i, nelem, newsz, origsz, srcsz;
658 unsigned int idxoffs;
660 if(!cmdest->nverts) {
661 return cmesh_clone(cmdest, cmsrc);
664 for(i=0; i<CMESH_NUM_ATTR; i++) {
665 if(cmesh_has_attrib(cmdest, i) && cmesh_has_attrib(cmsrc, i)) {
666 /* force validation of the data arrays */
667 cmesh_attrib(cmdest, i);
668 cmesh_attrib_ro(cmsrc, i);
670 assert(cmdest->vattr[i].nelem == cmsrc->vattr[i].nelem);
671 nelem = cmdest->vattr[i].nelem;
672 origsz = cmdest->nverts * nelem;
673 newsz = (cmdest->nverts + cmsrc->nverts) * nelem;
675 if(!(vptr = realloc(cmdest->vattr[i].data, newsz * sizeof *vptr))) {
678 memcpy(vptr + origsz, cmsrc->vattr[i].data, cmsrc->nverts * nelem * sizeof(float));
679 cmdest->vattr[i].data = vptr;
680 cmdest->vattr[i].count = newsz;
684 if(cmesh_indexed(cmdest)) {
685 assert(cmesh_indexed(cmsrc));
686 /* force validation ... */
688 cmesh_index_ro(cmsrc);
690 idxoffs = cmdest->nverts;
691 origsz = cmdest->icount;
692 srcsz = cmsrc->icount;
693 newsz = origsz + srcsz;
695 if(!(iptr = realloc(cmdest->idata, newsz * sizeof *iptr))) {
698 cmdest->idata = iptr;
699 cmdest->icount = newsz;
701 /* copy and fixup all the new indices */
703 for(i=0; i<srcsz; i++) {
704 *iptr++ = cmsrc->idata[i] + idxoffs;
708 cmdest->nverts += cmsrc->nverts;
709 cmdest->nfaces += cmsrc->nfaces;
711 cmdest->wire_ibo_valid = 0;
712 cmdest->aabb_valid = 0;
713 cmdest->bsph_valid = 0;
717 void cmesh_clear_submeshes(struct cmesh *cm)
723 cm->sublist = cm->sublist->next;
731 int cmesh_submesh(struct cmesh *cm, const char *name, int fstart, int fcount)
734 unsigned int minv = UINT_MAX, maxv = 0;
738 if(fstart < 0 || fcount < 1 || fstart + fcount > cm->nfaces) {
742 if(!(sm = malloc(sizeof *sm)) || !(sm->name = malloc(strlen(name) + 1))) {
746 strcpy(sm->name, name);
749 if(cmesh_indexed(cm)) {
750 sm->istart = fstart * 3;
751 sm->icount = fcount * 3;
753 /* find out which vertices are used by this submesh */
754 iptr = cm->idata + sm->istart;
755 for(i=0; i<sm->icount; i++) {
756 unsigned int vidx = *iptr++;
757 if(vidx < minv) minv = vidx;
758 if(vidx > maxv) maxv = vidx;
761 sm->vcount = maxv - minv + 1;
763 sm->istart = sm->icount = 0;
764 sm->vstart = fstart * 3;
765 sm->vcount = fcount * 3;
770 cm->subtail->next = sm;
773 cm->sublist = cm->subtail = sm;
779 int cmesh_remove_submesh(struct cmesh *cm, int idx)
781 struct submesh dummy;
782 struct submesh *prev, *sm;
784 if(idx >= cm->subcount) {
788 dummy.next = cm->sublist;
791 while(prev->next && idx-- > 0) {
795 if(!(sm = prev->next)) return -1;
797 prev->next = sm->next;
801 if(cm->subtail == sm) {
806 assert(cm->subcount >= 0);
809 cm->sublist = cm->subtail = 0;
811 cm->sublist = dummy.next;
816 int cmesh_find_submesh(const struct cmesh *cm, const char *name)
819 struct submesh *sm = cm->sublist;
821 if(strcmp(sm->name, name) == 0) {
822 assert(idx <= cm->subcount);
831 int cmesh_submesh_count(const struct cmesh *cm)
836 static struct submesh *get_submesh(const struct cmesh *m, int idx)
838 struct submesh *sm = m->sublist;
839 while(sm && --idx >= 0) {
845 int cmesh_clone_submesh(struct cmesh *cmdest, const struct cmesh *cm, int subidx)
849 if(!(sub = get_submesh(cm, subidx))) {
852 return clone(cmdest, cm, sub);
856 /* assemble a complete vertex by adding all the useful attributes */
857 int cmesh_vertex(struct cmesh *cm, float x, float y, float z)
861 cgm_wcons(cm->cur_val + CMESH_ATTR_VERTEX, x, y, z, 1.0f);
862 cm->vattr[CMESH_ATTR_VERTEX].data_valid = 1;
863 cm->vattr[CMESH_ATTR_VERTEX].nelem = 3;
865 for(i=0; i<CMESH_NUM_ATTR; i++) {
866 if(cm->vattr[i].nelem > 0) {
867 cmesh_push_attrib(cm, i, &cm->cur_val[i].x);
871 if(cm->idata_valid) {
876 cm->ibo_valid = cm->idata_valid = 0;
880 void cmesh_normal(struct cmesh *cm, float nx, float ny, float nz)
882 cgm_wcons(cm->cur_val + CMESH_ATTR_NORMAL, nx, ny, nz, 1.0f);
883 cm->vattr[CMESH_ATTR_NORMAL].nelem = 3;
886 void cmesh_tangent(struct cmesh *cm, float tx, float ty, float tz)
888 cgm_wcons(cm->cur_val + CMESH_ATTR_TANGENT, tx, ty, tz, 1.0f);
889 cm->vattr[CMESH_ATTR_TANGENT].nelem = 3;
892 void cmesh_texcoord(struct cmesh *cm, float u, float v, float w)
894 cgm_wcons(cm->cur_val + CMESH_ATTR_TEXCOORD, u, v, w, 1.0f);
895 cm->vattr[CMESH_ATTR_TEXCOORD].nelem = 3;
898 void cmesh_boneweights(struct cmesh *cm, float w1, float w2, float w3, float w4)
900 cgm_wcons(cm->cur_val + CMESH_ATTR_BONEWEIGHTS, w1, w2, w3, w4);
901 cm->vattr[CMESH_ATTR_BONEWEIGHTS].nelem = 4;
904 void cmesh_boneidx(struct cmesh *cm, int idx1, int idx2, int idx3, int idx4)
906 cgm_wcons(cm->cur_val + CMESH_ATTR_BONEIDX, idx1, idx2, idx3, idx4);
907 cm->vattr[CMESH_ATTR_BONEIDX].nelem = 4;
910 static float *get_vec4(struct cmesh *cm, int attr, int idx, cgm_vec4 *res)
914 cgm_wcons(res, 0, 0, 0, 1);
915 if(!(sptr = cmesh_attrib_at(cm, attr, idx))) {
920 for(i=0; i<cm->vattr[attr].nelem; i++) {
926 static float *get_vec3(struct cmesh *cm, int attr, int idx, cgm_vec3 *res)
930 cgm_vcons(res, 0, 0, 0);
931 if(!(sptr = cmesh_attrib_at(cm, attr, idx))) {
936 for(i=0; i<cm->vattr[attr].nelem; i++) {
942 /* dir_xform can be null, in which case it's calculated from xform */
943 void cmesh_apply_xform(struct cmesh *cm, float *xform, float *dir_xform)
955 for(i=0; i<cm->nverts; i++) {
956 if(!(vptr = get_vec4(cm, CMESH_ATTR_VERTEX, i, &v))) {
959 cgm_wmul_m4v4(&v, xform);
960 for(j=0; j<cm->vattr[CMESH_ATTR_VERTEX].nelem; j++) {
964 if(cmesh_has_attrib(cm, CMESH_ATTR_NORMAL)) {
965 if((vptr = get_vec3(cm, CMESH_ATTR_NORMAL, i, &n))) {
966 cgm_vmul_m3v3(&n, dir_xform);
967 for(j=0; j<cm->vattr[CMESH_ATTR_NORMAL].nelem; j++) {
972 if(cmesh_has_attrib(cm, CMESH_ATTR_TANGENT)) {
973 if((vptr = get_vec3(cm, CMESH_ATTR_TANGENT, i, &t))) {
974 cgm_vmul_m3v3(&t, dir_xform);
975 for(j=0; j<cm->vattr[CMESH_ATTR_TANGENT].nelem; j++) {
983 void cmesh_flip(struct cmesh *cm)
985 cmesh_flip_faces(cm);
986 cmesh_flip_normals(cm);
989 void cmesh_flip_faces(struct cmesh *cm)
991 int i, j, idxnum, vnum, nelem;
992 unsigned int *indices;
995 if(cmesh_indexed(cm)) {
996 if(!(indices = cmesh_index(cm))) {
999 idxnum = cmesh_index_count(cm);
1000 for(i=0; i<idxnum; i+=3) {
1001 unsigned int tmp = indices[i + 2];
1002 indices[i + 2] = indices[i + 1];
1003 indices[i + 1] = tmp;
1006 if(!(verts = cmesh_attrib(cm, CMESH_ATTR_VERTEX))) {
1009 vnum = cmesh_attrib_count(cm, CMESH_ATTR_VERTEX);
1010 nelem = cm->vattr[CMESH_ATTR_VERTEX].nelem;
1011 for(i=0; i<vnum; i+=3) {
1012 for(j=0; j<nelem; j++) {
1013 vptr = verts + (i + 1) * nelem + j;
1014 float tmp = vptr[nelem];
1015 vptr[nelem] = vptr[0];
1021 void cmesh_flip_normals(struct cmesh *cm)
1024 float *nptr = cmesh_attrib(cm, CMESH_ATTR_NORMAL);
1027 num = cm->nverts * cm->vattr[CMESH_ATTR_NORMAL].nelem;
1028 for(i=0; i<num; i++) {
1034 int cmesh_explode(struct cmesh *cm)
1036 int i, j, k, idxnum, nnverts;
1037 unsigned int *indices;
1039 if(!cmesh_indexed(cm)) return 0;
1041 indices = cmesh_index(cm);
1044 idxnum = cmesh_index_count(cm);
1047 for(i=0; i<CMESH_NUM_ATTR; i++) {
1048 const float *srcbuf;
1049 float *tmpbuf, *dstptr;
1051 if(!cmesh_has_attrib(cm, i)) continue;
1053 srcbuf = cmesh_attrib(cm, i);
1054 if(!(tmpbuf = malloc(nnverts * cm->vattr[i].nelem * sizeof(float)))) {
1059 for(j=0; j<idxnum; j++) {
1060 unsigned int idx = indices[j];
1061 const float *srcptr = srcbuf + idx * cm->vattr[i].nelem;
1063 for(k=0; k<cm->vattr[i].nelem; k++) {
1064 *dstptr++ = *srcptr++;
1068 free(cm->vattr[i].data);
1069 cm->vattr[i].data = tmpbuf;
1070 cm->vattr[i].count = nnverts * cm->vattr[i].nelem;
1071 cm->vattr[i].data_valid = 1;
1075 cm->idata_valid = 0;
1080 cm->nverts = nnverts;
1081 cm->nfaces = idxnum / 3;
1085 void cmesh_calc_face_normals(struct cmesh *cm)
1090 static int pre_draw(const struct cmesh *cm)
1092 int i, loc, cur_sdr;
1094 glGetIntegerv(GL_CURRENT_PROGRAM, &cur_sdr);
1096 update_buffers((struct cmesh*)cm);
1098 if(!cm->vattr[CMESH_ATTR_VERTEX].vbo_valid) {
1102 if(cur_sdr && use_custom_sdr_attr) {
1103 if(sdr_loc[CMESH_ATTR_VERTEX] == -1) {
1107 for(i=0; i<CMESH_NUM_ATTR; i++) {
1109 if(loc >= 0 && cm->vattr[i].vbo_valid) {
1110 glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[i].vbo);
1111 glVertexAttribPointer(loc, cm->vattr[i].nelem, GL_FLOAT, GL_FALSE, 0, 0);
1112 glEnableVertexAttribArray(loc);
1116 #ifndef GL_ES_VERSION_2_0
1117 glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[CMESH_ATTR_VERTEX].vbo);
1118 glVertexPointer(cm->vattr[CMESH_ATTR_VERTEX].nelem, GL_FLOAT, 0, 0);
1119 glEnableClientState(GL_VERTEX_ARRAY);
1121 if(cm->vattr[CMESH_ATTR_NORMAL].vbo_valid) {
1122 glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[CMESH_ATTR_NORMAL].vbo);
1123 glNormalPointer(GL_FLOAT, 0, 0);
1124 glEnableClientState(GL_NORMAL_ARRAY);
1126 if(cm->vattr[CMESH_ATTR_TEXCOORD].vbo_valid) {
1127 glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[CMESH_ATTR_TEXCOORD].vbo);
1128 glTexCoordPointer(cm->vattr[CMESH_ATTR_TEXCOORD].nelem, GL_FLOAT, 0, 0);
1129 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
1131 if(cm->vattr[CMESH_ATTR_COLOR].vbo_valid) {
1132 glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[CMESH_ATTR_COLOR].vbo);
1133 glColorPointer(cm->vattr[CMESH_ATTR_COLOR].nelem, GL_FLOAT, 0, 0);
1134 glEnableClientState(GL_COLOR_ARRAY);
1136 if(cm->vattr[CMESH_ATTR_TEXCOORD2].vbo_valid) {
1137 glClientActiveTexture(GL_TEXTURE1);
1138 glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[CMESH_ATTR_TEXCOORD2].vbo);
1139 glTexCoordPointer(cm->vattr[CMESH_ATTR_TEXCOORD2].nelem, GL_FLOAT, 0, 0);
1140 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
1141 glClientActiveTexture(GL_TEXTURE0);
1143 #endif /* GL_ES_VERSION_2_0 */
1145 glBindBuffer(GL_ARRAY_BUFFER, 0);
1149 void cmesh_draw(const struct cmesh *cm)
1153 if((cur_sdr = pre_draw(cm)) == -1) {
1158 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cm->ibo);
1159 glDrawElements(GL_TRIANGLES, cm->nfaces * 3, GL_UNSIGNED_INT, 0);
1160 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
1162 glDrawArrays(GL_TRIANGLES, 0, cm->nverts);
1165 post_draw(cm, cur_sdr);
1168 void cmesh_draw_range(const struct cmesh *cm, int start, int count)
1172 if((cur_sdr = pre_draw(cm)) == -1) {
1177 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cm->ibo);
1178 glDrawElements(GL_TRIANGLES, count, GL_UNSIGNED_INT, (void*)(intptr_t)(start * 4));
1179 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
1181 glDrawArrays(GL_TRIANGLES, start, count);
1184 post_draw(cm, cur_sdr);
1187 void cmesh_draw_submesh(const struct cmesh *cm, int subidx)
1189 struct submesh *sm = cm->sublist;
1191 while(sm && subidx-- > 0) {
1197 cmesh_draw_range(cm, sm->istart, sm->icount);
1199 cmesh_draw_range(cm, sm->vstart, sm->vcount);
1203 static void post_draw(const struct cmesh *cm, int cur_sdr)
1207 if(cur_sdr && use_custom_sdr_attr) {
1208 for(i=0; i<CMESH_NUM_ATTR; i++) {
1209 int loc = sdr_loc[i];
1210 if(loc >= 0 && cm->vattr[i].vbo_valid) {
1211 glDisableVertexAttribArray(loc);
1215 #ifndef GL_ES_VERSION_2_0
1216 glDisableClientState(GL_VERTEX_ARRAY);
1217 if(cm->vattr[CMESH_ATTR_NORMAL].vbo_valid) {
1218 glDisableClientState(GL_NORMAL_ARRAY);
1220 if(cm->vattr[CMESH_ATTR_TEXCOORD].vbo_valid) {
1221 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
1223 if(cm->vattr[CMESH_ATTR_COLOR].vbo_valid) {
1224 glDisableClientState(GL_COLOR_ARRAY);
1226 if(cm->vattr[CMESH_ATTR_TEXCOORD2].vbo_valid) {
1227 glClientActiveTexture(GL_TEXTURE1);
1228 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
1229 glClientActiveTexture(GL_TEXTURE0);
1231 #endif /* GL_ES_VERSION_2_0 */
1235 void cmesh_draw_wire(const struct cmesh *cm, float linesz)
1237 int cur_sdr, nfaces;
1239 if((cur_sdr = pre_draw(cm)) == -1) {
1242 update_wire_ibo((struct cmesh*)cm);
1244 nfaces = cmesh_poly_count(cm);
1245 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cm->wire_ibo);
1246 glDrawElements(GL_LINES, nfaces * 6, GL_UNSIGNED_INT, 0);
1247 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
1249 post_draw(cm, cur_sdr);
1252 void cmesh_draw_vertices(const struct cmesh *cm, float ptsz)
1255 if((cur_sdr = pre_draw(cm)) == -1) {
1259 glPushAttrib(GL_POINT_BIT);
1261 glDrawArrays(GL_POINTS, 0, cm->nverts);
1264 post_draw(cm, cur_sdr);
1267 void cmesh_draw_normals(const struct cmesh *cm, float len)
1269 #ifndef GL_ES_VERSION_2_0
1270 int i, cur_sdr, vert_nelem, norm_nelem;
1272 const float *varr, *norm;
1274 varr = cmesh_attrib_ro(cm, CMESH_ATTR_VERTEX);
1275 norm = cmesh_attrib_ro(cm, CMESH_ATTR_NORMAL);
1276 if(!varr || !norm) return;
1278 vert_nelem = cm->vattr[CMESH_ATTR_VERTEX].nelem;
1279 norm_nelem = cm->vattr[CMESH_ATTR_NORMAL].nelem;
1281 glGetIntegerv(GL_CURRENT_PROGRAM, &cur_sdr);
1282 if(cur_sdr && use_custom_sdr_attr) {
1283 if((loc = sdr_loc[CMESH_ATTR_VERTEX]) < 0) {
1289 for(i=0; i<cm->nverts; i++) {
1290 float x, y, z, endx, endy, endz;
1292 x = varr[i * vert_nelem];
1293 y = varr[i * vert_nelem + 1];
1294 z = varr[i * vert_nelem + 2];
1295 endx = x + norm[i * norm_nelem] * len;
1296 endy = y + norm[i * norm_nelem + 1] * len;
1297 endz = z + norm[i * norm_nelem + 2] * len;
1300 glVertex3f(x, y, z);
1301 glVertex3f(endx, endy, endz);
1303 glVertexAttrib3f(loc, x, y, z);
1304 glVertexAttrib3f(loc, endx, endy, endz);
1308 #endif /* GL_ES_VERSION_2_0 */
1311 void cmesh_draw_tangents(const struct cmesh *cm, float len)
1313 #ifndef GL_ES_VERSION_2_0
1314 int i, cur_sdr, vert_nelem, tang_nelem;
1316 const float *varr, *tang;
1318 varr = cmesh_attrib_ro(cm, CMESH_ATTR_VERTEX);
1319 tang = cmesh_attrib_ro(cm, CMESH_ATTR_TANGENT);
1320 if(!varr || !tang) return;
1322 vert_nelem = cm->vattr[CMESH_ATTR_VERTEX].nelem;
1323 tang_nelem = cm->vattr[CMESH_ATTR_TANGENT].nelem;
1325 glGetIntegerv(GL_CURRENT_PROGRAM, &cur_sdr);
1326 if(cur_sdr && use_custom_sdr_attr) {
1327 if((loc = sdr_loc[CMESH_ATTR_VERTEX]) < 0) {
1333 for(i=0; i<cm->nverts; i++) {
1334 float x, y, z, endx, endy, endz;
1336 x = varr[i * vert_nelem];
1337 y = varr[i * vert_nelem + 1];
1338 z = varr[i * vert_nelem + 2];
1339 endx = x + tang[i * tang_nelem] * len;
1340 endy = y + tang[i * tang_nelem + 1] * len;
1341 endz = z + tang[i * tang_nelem + 2] * len;
1344 glVertex3f(x, y, z);
1345 glVertex3f(endx, endy, endz);
1347 glVertexAttrib3f(loc, x, y, z);
1348 glVertexAttrib3f(loc, endx, endy, endz);
1352 #endif /* GL_ES_VERSION_2_0 */
1355 static void update_buffers(struct cmesh *cm)
1359 for(i=0; i<CMESH_NUM_ATTR; i++) {
1360 if(cmesh_has_attrib(cm, i) && !cm->vattr[i].vbo_valid) {
1361 glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[i].vbo);
1362 glBufferData(GL_ARRAY_BUFFER, cm->nverts * cm->vattr[i].nelem * sizeof(float),
1363 cm->vattr[i].data, GL_STATIC_DRAW);
1364 cm->vattr[i].vbo_valid = 1;
1367 glBindBuffer(GL_ARRAY_BUFFER, 0);
1369 if(cm->idata_valid && !cm->ibo_valid) {
1370 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cm->ibo);
1371 glBufferData(GL_ELEMENT_ARRAY_BUFFER, cm->nfaces * 3 * sizeof(unsigned int),
1372 cm->idata, GL_STATIC_DRAW);
1374 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
1378 static void update_wire_ibo(struct cmesh *cm)
1381 unsigned int *wire_idxarr, *dest;
1385 if(cm->wire_ibo_valid) return;
1388 glGenBuffers(1, &cm->wire_ibo);
1390 num_faces = cmesh_poly_count(cm);
1392 if(!(wire_idxarr = malloc(num_faces * 6 * sizeof *wire_idxarr))) {
1398 /* we're dealing with an indexed mesh */
1399 const unsigned int *idxarr = cmesh_index_ro(cm);
1401 for(i=0; i<num_faces; i++) {
1402 *dest++ = idxarr[0];
1403 *dest++ = idxarr[1];
1404 *dest++ = idxarr[1];
1405 *dest++ = idxarr[2];
1406 *dest++ = idxarr[2];
1407 *dest++ = idxarr[0];
1411 /* not an indexed mesh */
1412 for(i=0; i<num_faces; i++) {
1423 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cm->wire_ibo);
1424 glBufferData(GL_ELEMENT_ARRAY_BUFFER, num_faces * 6 * sizeof(unsigned int),
1425 wire_idxarr, GL_STATIC_DRAW);
1427 cm->wire_ibo_valid = 1;
1428 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
1431 static void calc_aabb(struct cmesh *cm)
1435 if(!cmesh_attrib_ro(cm, CMESH_ATTR_VERTEX)) {
1439 cgm_vcons(&cm->aabb_min, FLT_MAX, FLT_MAX, FLT_MAX);
1440 cgm_vcons(&cm->aabb_max, -FLT_MAX, -FLT_MAX, -FLT_MAX);
1442 for(i=0; i<cm->nverts; i++) {
1443 const float *v = cmesh_attrib_at_ro(cm, CMESH_ATTR_VERTEX, i);
1444 for(j=0; j<3; j++) {
1445 if(v[j] < (&cm->aabb_min.x)[j]) {
1446 (&cm->aabb_min.x)[j] = v[j];
1448 if(v[j] > (&cm->aabb_max.x)[j]) {
1449 (&cm->aabb_max.x)[j] = v[j];
1456 void cmesh_aabbox(const struct cmesh *cm, cgm_vec3 *vmin, cgm_vec3 *vmax)
1458 if(!cm->aabb_valid) {
1459 calc_aabb((struct cmesh*)cm);
1461 *vmin = cm->aabb_min;
1462 *vmax = cm->aabb_max;
1465 static void calc_bsph(struct cmesh *cm)
1470 if(!cmesh_attrib_ro(cm, CMESH_ATTR_VERTEX)) {
1474 cgm_vcons(&cm->bsph_center, 0, 0, 0);
1476 /* first find the center */
1477 for(i=0; i<cm->nverts; i++) {
1478 const float *v = cmesh_attrib_at_ro(cm, CMESH_ATTR_VERTEX, i);
1479 cm->bsph_center.x += v[0];
1480 cm->bsph_center.y += v[1];
1481 cm->bsph_center.z += v[2];
1483 s = 1.0f / (float)cm->nverts;
1484 cm->bsph_center.x *= s;
1485 cm->bsph_center.y *= s;
1486 cm->bsph_center.z *= s;
1488 cm->bsph_radius = 0.0f;
1489 for(i=0; i<cm->nverts; i++) {
1490 const cgm_vec3 *v = (const cgm_vec3*)cmesh_attrib_at_ro(cm, CMESH_ATTR_VERTEX, i);
1491 if((dist_sq = cgm_vdist_sq(v, &cm->bsph_center)) > cm->bsph_radius) {
1492 cm->bsph_radius = dist_sq;
1495 cm->bsph_radius = sqrt(cm->bsph_radius);
1499 float cmesh_bsphere(const struct cmesh *cm, cgm_vec3 *center, float *rad)
1501 if(!cm->bsph_valid) {
1502 calc_bsph((struct cmesh*)cm);
1504 if(center) *center = cm->bsph_center;
1505 if(rad) *rad = cm->bsph_radius;
1506 return cm->bsph_radius;
1510 void cmesh_texcoord_apply_xform(struct cmesh *cm, float *xform);
1511 void cmesh_texcoord_gen_plane(struct cmesh *cm, cgm_vec3 *norm, cgm_vec3 *tang);
1512 void cmesh_texcoord_gen_box(struct cmesh *cm);
1513 void cmesh_texcoord_gen_cylinder(struct cmesh *cm);
1515 int cmesh_dump(const struct cmesh *cm, const char *fname)
1517 FILE *fp = fopen(fname, "wb");
1519 int res = cmesh_dump_file(cm, fp);
1526 int cmesh_dump_file(const struct cmesh *cm, FILE *fp)
1528 static const char *label[] = { "pos", "nor", "tan", "tex", "col", "bw", "bid", "tex2" };
1529 static const char *elemfmt[] = { 0, " %s(%g)", " %s(%g, %g)", " %s(%g, %g, %g)", " %s(%g, %g, %g, %g)", 0 };
1532 if(!cmesh_has_attrib(cm, CMESH_ATTR_VERTEX)) {
1536 fprintf(fp, "VERTEX ATTRIBUTES\n");
1538 for(i=0; i<cm->nverts; i++) {
1539 fprintf(fp, "%5u:", i);
1540 for(j=0; j<CMESH_NUM_ATTR; j++) {
1541 if(cmesh_has_attrib(cm, j)) {
1542 const float *v = cmesh_attrib_at_ro(cm, j, i);
1543 int nelem = cm->vattr[j].nelem;
1544 fprintf(fp, elemfmt[nelem], label[j], v[0], nelem > 1 ? v[1] : 0.0f,
1545 nelem > 2 ? v[2] : 0.0f, nelem > 3 ? v[3] : 0.0f);
1551 if(cmesh_indexed(cm)) {
1552 const unsigned int *idx = cmesh_index_ro(cm);
1553 int numidx = cmesh_index_count(cm);
1554 int numtri = numidx / 3;
1555 assert(numidx % 3 == 0);
1557 fprintf(fp, "FACES\n");
1559 for(i=0; i<numtri; i++) {
1560 fprintf(fp, "%5d: %d %d %d\n", i, idx[0], idx[1], idx[2]);
1567 int cmesh_dump_obj(const struct cmesh *cm, const char *fname)
1569 FILE *fp = fopen(fname, "wb");
1571 int res = cmesh_dump_obj_file(cm, fp, 0);
1581 int cmesh_dump_obj_file(const struct cmesh *cm, FILE *fp, int voffs)
1583 static const char *fmtstr[] = {" %u", " %u//%u", " %u/%u", " %u/%u/%u"};
1584 int i, j, num, nelem;
1585 unsigned int aflags = 0;
1586 const struct submesh *sub = cm->sublist;
1588 if(!cmesh_has_attrib(cm, CMESH_ATTR_VERTEX)) {
1593 nelem = cm->vattr[CMESH_ATTR_VERTEX].nelem;
1594 if((num = cm->vattr[CMESH_ATTR_VERTEX].count) != cm->nverts * nelem) {
1595 fprintf(stderr, "vertex array size (%d) != nverts (%d)\n", num, cm->nverts);
1597 for(i=0; i<cm->nverts; i++) {
1598 const float *v = cmesh_attrib_at_ro(cm, CMESH_ATTR_VERTEX, i);
1599 fprintf(fp, "v %f %f %f\n", v[0], nelem > 1 ? v[1] : 0.0f, nelem > 2 ? v[2] : 0.0f);
1602 if(cmesh_has_attrib(cm, CMESH_ATTR_NORMAL)) {
1604 nelem = cm->vattr[CMESH_ATTR_NORMAL].nelem;
1605 if((num = cm->vattr[CMESH_ATTR_NORMAL].count) != cm->nverts * nelem) {
1606 fprintf(stderr, "normal array size (%d) != nverts (%d)\n", num, cm->nverts);
1608 for(i=0; i<cm->nverts; i++) {
1609 const float *v = cmesh_attrib_at_ro(cm, CMESH_ATTR_NORMAL, i);
1610 fprintf(fp, "vn %f %f %f\n", v[0], nelem > 1 ? v[1] : 0.0f, nelem > 2 ? v[2] : 0.0f);
1614 if(cmesh_has_attrib(cm, CMESH_ATTR_TEXCOORD)) {
1616 nelem = cm->vattr[CMESH_ATTR_TEXCOORD].nelem;
1617 if((num = cm->vattr[CMESH_ATTR_TEXCOORD].count) != cm->nverts * nelem) {
1618 fprintf(stderr, "texcoord array size (%d) != nverts (%d)\n", num, cm->nverts);
1620 for(i=0; i<cm->nverts; i++) {
1621 const float *v = cmesh_attrib_at_ro(cm, CMESH_ATTR_TEXCOORD, i);
1622 fprintf(fp, "vt %f %f\n", v[0], nelem > 1 ? v[1] : 0.0f);
1626 if(cmesh_indexed(cm)) {
1627 const unsigned int *idxptr = cmesh_index_ro(cm);
1628 int numidx = cmesh_index_count(cm);
1629 int numtri = numidx / 3;
1630 assert(numidx % 3 == 0);
1632 for(i=0; i<numtri; i++) {
1633 if(sub && sub->istart <= *idxptr) {
1634 fprintf(fp, "o %s\n", sub->name);
1639 for(j=0; j<3; j++) {
1640 unsigned int idx = *idxptr++ + 1 + voffs;
1641 fprintf(fp, fmtstr[aflags], idx, idx, idx);
1646 int numtri = cm->nverts / 3;
1647 unsigned int idx = 1 + voffs;
1648 for(i=0; i<numtri; i++) {
1649 if(sub && sub->vstart == idx - 1) {
1650 fprintf(fp, "o %s\n", sub->name);
1655 for(j=0; j<3; j++) {
1656 fprintf(fp, fmtstr[aflags], idx, idx, idx);