#include <stdio.h>
#include <stdlib.h>
+#include <float.h>
+#include <assert.h>
#include "opengl.h"
#include "cmesh.h"
+#include "logger.h"
struct cmesh_vattrib {
int nelem; /* num elements per attribute [1, 4] */
- float *data; /* dynarr */
+ float *data;
+ unsigned int count;
unsigned int vbo;
int vbo_valid, data_valid;
};
unsigned int buffer_objects[CMESH_NUM_ATTR + 1];
struct cmesh_vattrib vattr[CMESH_NUM_ATTR];
- unsigned int *idata; /* dynarr */
+ unsigned int *idata;
+ unsigned int icount;
unsigned int ibo;
int ibo_valid, idata_valid;
int bsph_valid;
};
+
+static int pre_draw(struct cmesh *cm);
+static void post_draw(struct cmesh *cm, int cur_sdr);
+static void update_buffers(struct cmesh *cm);
+static void update_wire_ibo(struct cmesh *cm);
+static void calc_aabb(struct cmesh *cm);
+static void calc_bsph(struct cmesh *cm);
+
+static int def_nelem[CMESH_NUM_ATTR] = {3, 3, 3, 2, 4, 4, 4, 2};
+
static int sdr_loc[CMESH_NUM_ATTR] = {0, 1, 2, 3, 4, 5, 6, 7};
+static int use_custom_sdr_attr;
/* global state */
glGenBuffers(CMESH_NUM_ATTR + 1, cm->buffer_objects);
for(i=0; i<CMESH_NUM_ATTR; i++) {
- if(!(cm->vattr[i].data = dynarr_alloc(0, sizeof(float)))) {
- cmesh_destroy(cm);
- return -1;
- }
- cm->vattr[i].vbo = buffer_objects[i];
+ cm->vattr[i].vbo = cm->buffer_objects[i];
}
- cm->ibo = buffer_objects[CMESH_NUM_ATTR];
- if(!(cm->idata = dynarr_alloc(0, sizeof *cm->idata))) {
- cmesh_destroy(cm);
- return -1;
- }
+ cm->ibo = cm->buffer_objects[CMESH_NUM_ATTR];
return 0;
}
free(cm->name);
for(i=0; i<CMESH_NUM_ATTR; i++) {
- dynarr_free(cm->vattr[i].data);
+ free(cm->vattr[i].data);
}
- dynarr_free(cm->idata);
+ free(cm->idata);
glDeleteBuffers(CMESH_NUM_ATTR + 1, cm->buffer_objects);
if(cm->wire_ibo) {
cm->vattr[i].nelem = 0;
cm->vattr[i].vbo_valid = 0;
cm->vattr[i].data_valid = 0;
- cm->vattr[i].data = dynarr_clear(cm->vattr[i].data);
+ free(cm->vattr[i].data);
+ cm->vattr[i].data = 0;
+ cm->vattr[i].count = 0;
}
cm->ibo_valid = cm->idata_valid = 0;
- cm->idata = dynarr_clear(cm->idata);
+ free(cm->idata);
+ cm->idata = 0;
+ cm->icount = 0;
cm->wire_ibo_valid = 0;
cm->nverts = cm->nfaces = 0;
int cmesh_clone(struct cmesh *cmdest, struct cmesh *cmsrc)
{
- int i, num, nelem;
+ int i, nelem;
char *name = 0;
float *varr[CMESH_NUM_ATTR] = {0};
unsigned int *iarr = 0;
strcpy(name, cmsrc->name);
}
if(cmesh_indexed(cmsrc)) {
- num = dynarr_size(cmsrc->idata);
- if(!(iarr = dynarr_alloc(num, sizeof *iarr))) {
+ if(!(iarr = malloc(cmsrc->icount * sizeof *iarr))) {
free(name);
return -1;
}
for(i=0; i<CMESH_NUM_ATTR; i++) {
if(cmesh_has_attrib(cmsrc, i)) {
nelem = cmsrc->vattr[i].nelem;
- num = dynarr_size(cmsrc->vattr[i].data);
- if(!(varr[i] = dynarr_alloc(num * nelem, sizeof(float)))) {
+ if(!(varr[i] = malloc(cmsrc->vattr[i].count * nelem * sizeof(float)))) {
while(--i >= 0) {
- dynarr_free(varr[i]);
+ free(varr[i]);
}
- dynarr_free(iarr);
+ free(iarr);
free(name);
return -1;
}
cmesh_clear(cmdest);
for(i=0; i<CMESH_NUM_ATTR; i++) {
- dynarr_free(cmdest->vattr[i].data);
+ free(cmdest->vattr[i].data);
if(cmesh_has_attrib(cmsrc, i)) {
cmesh_attrib(cmsrc, i); /* force validation of the actual data on the source mesh */
nelem = cmsrc->vattr[i].nelem;
- cmdest->vattr[i].nelem = nelem
- num = dynarr_size(cmsrc->vattr[i].data);
+ cmdest->vattr[i].nelem = nelem;
cmdest->vattr[i].data = varr[i];
- memcpy(cmdest->vattr[i].data, cmsrc->vattr[i].data, num * nelem * sizeof(float));
+ cmdest->vattr[i].count = cmsrc->vattr[i].count;
+ memcpy(cmdest->vattr[i].data, cmsrc->vattr[i].data, cmsrc->vattr[i].count * nelem * sizeof(float));
cmdest->vattr[i].data_valid = 1;
cmdest->vattr[i].vbo_valid = 0;
} else {
}
}
- dynarr_free(cmdest->idata);
+ free(cmdest->idata);
if(cmesh_indexed(cmsrc)) {
cmesh_index(cmsrc); /* force validation .... */
- num = dynarr_size(cmsrc->idata);
cmdest->idata = iarr;
- memcpy(cmdest->idata, cmsrc->idata, num * sizeof *cmdest->idata);
+ cmdest->icount = cmsrc->icount;
+ memcpy(cmdest->idata, cmsrc->idata, cmsrc->icount * sizeof *cmdest->idata);
cmdest->idata_valid = 1;
} else {
cmdest->idata = 0;
return 0;
}
- if(!(newarr = dynarr_alloc(num * nelem, sizeof *newarr))) {
+ if(!(newarr = malloc(num * nelem * sizeof *newarr))) {
return 0;
}
- if(data) {
+ if(vdata) {
memcpy(newarr, vdata, num * nelem * sizeof *newarr);
}
cm->nverts = num;
- dynarr_free(cm->vattr[attr].data);
+ free(cm->vattr[attr].data);
cm->vattr[attr].data = newarr;
+ cm->vattr[attr].count = num * nelem;
cm->vattr[attr].nelem = nelem;
cm->vattr[attr].data_valid = 1;
cm->vattr[attr].vbo_valid = 0;
const float *cmesh_attrib_ro(struct cmesh *cm, int attr)
{
- float *tmp;
+ void *tmp;
int nelem;
if(attr < 0 || attr >= CMESH_NUM_ATTR) {
/* local data copy unavailable, grab the data from the vbo */
nelem = cm->vattr[attr].nelem;
- if(!(tmp = dynarr_resize(cm->vattr[attr].data, cm->nverts * nelem))) {
+ if(!(cm->vattr[attr].data = malloc(cm->nverts * nelem * sizeof(float)))) {
return 0;
}
- cm->vattr[attr].data = tmp;
+ cm->vattr[attr].count = cm->nverts * nelem;
- glBindBuffer(GL_ARRAY_BUFFER, vattr[attr].vbo);
+ glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[attr].vbo);
tmp = glMapBuffer(GL_ARRAY_BUFFER, GL_READ_ONLY);
memcpy(cm->vattr[attr].data, tmp, cm->nverts * nelem * sizeof(float));
glUnmapBuffer(GL_ARRAY_BUFFER);
return cm->vattr[attr].data;
}
+float *cmesh_attrib_at(struct cmesh *cm, int attr, int idx)
+{
+ float *vptr = cmesh_attrib(cm, attr);
+ return vptr ? vptr + idx * cm->vattr[attr].nelem : 0;
+}
+
+const float *cmesh_attrib_at_ro(struct cmesh *cm, int attr, int idx)
+{
+ const float *vptr = cmesh_attrib_ro(cm, attr);
+ return vptr ? vptr + idx * cm->vattr[attr].nelem : 0;
+}
+
int cmesh_attrib_count(struct cmesh *cm, int attr)
{
return cmesh_has_attrib(cm, attr) ? cm->nverts : 0;
}
+int cmesh_push_attrib(struct cmesh *cm, int attr, float *v)
+{
+ float *vptr;
+ int i, cursz, newsz;
+
+ if(!cm->vattr[attr].nelem) {
+ cm->vattr[attr].nelem = def_nelem[attr];
+ }
+
+ cursz = cm->vattr[attr].count;
+ newsz = cursz + cm->vattr[attr].nelem;
+ if(!(vptr = realloc(cm->vattr[attr].data, newsz * sizeof(float)))) {
+ return -1;
+ }
+ cm->vattr[attr].data = vptr;
+ cm->vattr[attr].count = newsz;
+ vptr += cursz;
+
+ for(i=0; i<cm->vattr[attr].nelem; i++) {
+ *vptr++ = *v++;
+ }
+ cm->vattr[attr].data_valid = 1;
+ cm->vattr[attr].vbo_valid = 0;
+
+ if(attr == CMESH_ATTR_VERTEX) {
+ cm->nverts = newsz / cm->vattr[attr].nelem;
+ }
+ return 0;
+}
+
+int cmesh_push_attrib1f(struct cmesh *cm, int attr, float x)
+{
+ float v[4];
+ v[0] = x;
+ v[1] = v[2] = 0.0f;
+ v[3] = 1.0f;
+ return cmesh_push_attrib(cm, attr, v);
+}
+
+int cmesh_push_attrib2f(struct cmesh *cm, int attr, float x, float y)
+{
+ float v[4];
+ v[0] = x;
+ v[1] = y;
+ v[2] = 0.0f;
+ v[3] = 1.0f;
+ return cmesh_push_attrib(cm, attr, v);
+}
+
+int cmesh_push_attrib3f(struct cmesh *cm, int attr, float x, float y, float z)
+{
+ float v[4];
+ v[0] = x;
+ v[1] = y;
+ v[2] = z;
+ v[3] = 1.0f;
+ return cmesh_push_attrib(cm, attr, v);
+}
+
+int cmesh_push_attrib4f(struct cmesh *cm, int attr, float x, float y, float z, float w)
+{
+ float v[4];
+ v[0] = x;
+ v[1] = y;
+ v[2] = z;
+ v[3] = w;
+ return cmesh_push_attrib(cm, attr, v);
+}
+
/* indices can be 0, in which case only memory is allocated
* returns pointer to the index array
*/
return 0;
}
- if(!(tmp = dynarr_alloc(num, sizeof *tmp))) {
+ if(!(tmp = malloc(num * sizeof *tmp))) {
return 0;
}
if(indices) {
memcpy(tmp, indices, num * sizeof *tmp);
}
- dynarr_free(cm->idata);
+ free(cm->idata);
cm->idata = tmp;
+ cm->icount = num;
cm->idata_valid = 1;
cm->ibo_valid = 0;
return tmp;
/* local copy is unavailable, grab the data from the ibo */
nidx = cm->nfaces * 3;
- if(!(tmp = dynarr_alloc(nidx, sizeof *cm->idata))) {
+ if(!(tmp = malloc(nidx * sizeof *cm->idata))) {
return 0;
}
- dynarr_free(cm->idata);
+ free(cm->idata);
cm->idata = tmp;
+ cm->icount = nidx;
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cm->ibo);
tmp = glMapBuffer(GL_ELEMENT_ARRAY_BUFFER, GL_READ_ONLY);
glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER);
cm->idata_valid = 1;
+#endif
}
return cm->idata;
}
return cm->nfaces * 3;
}
-int get_poly_count(struct cmesh *cm)
+int cmesh_push_index(struct cmesh *cm, unsigned int idx)
+{
+ unsigned int *iptr;
+ unsigned int cur_sz = cm->icount;
+ if(!(iptr = realloc(cm->idata, (cur_sz + 1) * sizeof *iptr))) {
+ return -1;
+ }
+ iptr[cur_sz] = idx;
+ cm->idata = iptr;
+ cm->icount = cur_sz + 1;
+ cm->idata_valid = 1;
+ cm->ibo_valid = 0;
+
+ cm->nfaces = cm->icount / 3;
+ return 0;
+}
+
+int cmesh_poly_count(struct cmesh *cm)
{
if(cm->nfaces) {
return cm->nfaces;
int cmesh_append(struct cmesh *cmdest, struct cmesh *cmsrc)
{
- int i, nelem, nidx, newsz, origsz;
+ int i, nelem, newsz, origsz, srcsz;
float *vptr;
unsigned int *iptr;
unsigned int idxoffs;
}
for(i=0; i<CMESH_NUM_ATTR; i++) {
- if(cmesh_has_attrib(cmdest) && cmesh_has_attrib(cmsrc)) {
+ if(cmesh_has_attrib(cmdest, i) && cmesh_has_attrib(cmsrc, i)) {
/* force validation of the data arrays */
cmesh_attrib(cmdest, i);
- cmesh_attrib_ro(cmsrc, id);
+ cmesh_attrib_ro(cmsrc, i);
assert(cmdest->vattr[i].nelem == cmsrc->vattr[i].nelem);
nelem = cmdest->vattr[i].nelem;
origsz = cmdest->nverts * nelem;
newsz = cmdest->nverts + cmsrc->nverts * nelem;
- if(!(vptr = dynarr_resize(cmdest->vattr[i].data, newsz))) {
+ if(!(vptr = realloc(cmdest->vattr[i].data, newsz * sizeof *vptr))) {
return -1;
}
memcpy(vptr + origsz, cmsrc->vattr[i].data, cmsrc->nverts * nelem * sizeof(float));
cmdest->vattr[i].data = vptr;
+ cmdest->vattr[i].count = newsz;
}
}
cmesh_index(cmdest);
cmesh_index_ro(cmsrc);
- idxoff = cmdest->nverts;
- origsz = dynarr_size(cmdest->idata);
- srcsz = dynarr_size(cmsrc->idata);
+ idxoffs = cmdest->nverts;
+ origsz = cmdest->icount;
+ srcsz = cmsrc->icount;
newsz = origsz + srcsz;
- if(!(iptr = dynarr_resize(cmdest->idata, newsz))) {
+ if(!(iptr = realloc(cmdest->idata, newsz * sizeof *iptr))) {
return -1;
}
cmdest->idata = iptr;
+ cmdest->icount = newsz;
/* copy and fixup all the new indices */
iptr += origsz;
cmdest->wire_ibo_valid = 0;
cmdest->aabb_valid = 0;
cmdest->bsph_valid = 0;
+ return 0;
}
/* assemble a complete vertex by adding all the useful attributes */
cm->vattr[CMESH_ATTR_VERTEX].data_valid = 1;
cm->vattr[CMESH_ATTR_VERTEX].nelem = 3;
- for(i=0; i<CMESH_ATTR_VERTEX; i++) {
+ for(i=0; i<CMESH_NUM_ATTR; i++) {
if(cm->vattr[i].data_valid) {
- for(j=0; j<cm->vattr[CMESH_ATTR_VERTEX].nelem; j++) {
- float *tmp = dynarr_push(cm->vattr[i].data, cur_val[i] + j);
- if(!tmp) return -1;
- cm->vattr[i].data = tmp;
+ int newsz = cm->vattr[i].count + cm->vattr[i].nelem;
+ float *tmp = realloc(cm->vattr[i].data, newsz * sizeof *tmp);
+ if(!tmp) return -1;
+ tmp += cm->vattr[i].count;
+
+ cm->vattr[i].data = tmp;
+ cm->vattr[i].count = newsz;
+
+ for(j=0; j<cm->vattr[i].nelem; j++) {
+ *tmp++ = *(&cm->cur_val[i].x + j);
}
}
cm->vattr[i].vbo_valid = 0;
}
if(cm->idata_valid) {
- cm->idata = dynarr_clear(cm->idata);
+ free(cm->idata);
+ cm->idata = 0;
+ cm->icount = 0;
}
cm->ibo_valid = cm->idata_valid = 0;
return 0;
cm->vattr[CMESH_ATTR_BONEIDX].nelem = 4;
}
+static float *get_vec4(struct cmesh *cm, int attr, int idx, cgm_vec4 *res)
+{
+ int i;
+ float *sptr, *dptr;
+ cgm_wcons(res, 0, 0, 0, 1);
+ if(!(sptr = cmesh_attrib_at(cm, attr, idx))) {
+ return 0;
+ }
+ dptr = &res->x;
+
+ for(i=0; i<cm->vattr[attr].nelem; i++) {
+ *dptr++ = sptr[i];
+ }
+ return sptr;
+}
+
+static float *get_vec3(struct cmesh *cm, int attr, int idx, cgm_vec3 *res)
+{
+ int i;
+ float *sptr, *dptr;
+ cgm_vcons(res, 0, 0, 0);
+ if(!(sptr = cmesh_attrib_at(cm, attr, idx))) {
+ return 0;
+ }
+ dptr = &res->x;
+
+ for(i=0; i<cm->vattr[attr].nelem; i++) {
+ *dptr++ = sptr[i];
+ }
+ return sptr;
+}
+
/* dir_xform can be null, in which case it's calculated from xform */
-void cmesh_apply_xform(struct cmesh *cm, float *xform, float *dir_xform);
+void cmesh_apply_xform(struct cmesh *cm, float *xform, float *dir_xform)
+{
+ unsigned int i;
+ int j;
+ cgm_vec4 v;
+ cgm_vec3 n, t;
+ float *vptr;
-void cmesh_flip(struct cmesh *cm); /* flip faces (winding) and normals */
-void cmesh_flip_faces(struct cmesh *cm);
-void cmesh_flip_normals(struct cmesh *cm);
+ for(i=0; i<cm->nverts; i++) {
+ if(!(vptr = get_vec4(cm, CMESH_ATTR_VERTEX, i, &v))) {
+ return;
+ }
+ cgm_wmul_m4v4(&v, xform);
+ for(j=0; j<cm->vattr[CMESH_ATTR_VERTEX].nelem; j++) {
+ *vptr++ = (&v.x)[j];
+ }
-void cmesh_explode(struct cmesh *cm); /* undo all vertex sharing */
+ if(cmesh_has_attrib(cm, CMESH_ATTR_NORMAL)) {
+ if((vptr = get_vec3(cm, CMESH_ATTR_NORMAL, i, &n))) {
+ cgm_vmul_m3v3(&n, dir_xform);
+ for(j=0; j<cm->vattr[CMESH_ATTR_NORMAL].nelem; j++) {
+ *vptr++ = (&n.x)[j];
+ }
+ }
+ }
+ if(cmesh_has_attrib(cm, CMESH_ATTR_TANGENT)) {
+ if((vptr = get_vec3(cm, CMESH_ATTR_TANGENT, i, &t))) {
+ cgm_vmul_m3v3(&t, dir_xform);
+ for(j=0; j<cm->vattr[CMESH_ATTR_TANGENT].nelem; j++) {
+ *vptr++ = (&t.x)[j];
+ }
+ }
+ }
+ }
+}
-/* this is only guaranteed to work on an exploded mesh */
-void cmesh_calc_face_normals(struct cmesh *cm);
+void cmesh_flip(struct cmesh *cm)
+{
+ cmesh_flip_faces(cm);
+ cmesh_flip_normals(cm);
+}
-void cmesh_draw(struct cmesh *cm);
-void cmesh_draw_wire(struct cmesh *cm, float linesz);
-void cmesh_draw_vertices(struct cmesh *cm, float ptsz);
-void cmesh_draw_normals(struct cmesh *cm, float len);
-void cmesh_draw_tangents(struct cmesh *cm, float len);
+void cmesh_flip_faces(struct cmesh *cm)
+{
+ int i, j, idxnum, vnum, nelem;
+ unsigned int *indices;
+ float *verts, *vptr;
-/* get the bounding box in local space. The result will be cached and subsequent
- * calls will return the same box. The cache gets invalidated by any functions that
- * can affect the vertex data
- */
-void cmesh_aabbox(struct cmesh *cm, cgm_vec3 *vmin, cgm_vec3 *vmax);
+ if(cmesh_indexed(cm)) {
+ if(!(indices = cmesh_index(cm))) {
+ return;
+ }
+ idxnum = cmesh_index_count(cm);
+ for(i=0; i<idxnum; i+=3) {
+ unsigned int tmp = indices[i + 2];
+ indices[i + 2] = indices[i + 1];
+ indices[i + 1] = tmp;
+ }
+ } else {
+ if(!(verts = cmesh_attrib(cm, CMESH_ATTR_VERTEX))) {
+ return;
+ }
+ vnum = cmesh_attrib_count(cm, CMESH_ATTR_VERTEX);
+ nelem = cm->vattr[CMESH_ATTR_VERTEX].nelem;
+ for(i=0; i<vnum; i+=3) {
+ for(j=0; j<nelem; j++) {
+ vptr = verts + (i + 1) * nelem + j;
+ float tmp = vptr[nelem];
+ vptr[nelem] = vptr[0];
+ vptr[0] = tmp;
+ }
+ }
+ }
+}
+void cmesh_flip_normals(struct cmesh *cm)
+{
+ int i, num;
+ float *nptr = cmesh_attrib(cm, CMESH_ATTR_NORMAL);
+ if(!nptr) return;
+
+ num = cm->nverts * cm->vattr[CMESH_ATTR_NORMAL].nelem;
+ for(i=0; i<num; i++) {
+ *nptr = -*nptr;
+ nptr++;
+ }
+}
+
+int cmesh_explode(struct cmesh *cm)
+{
+ int i, j, k, idxnum, nnverts;
+ unsigned int *indices;
+
+ if(!cmesh_indexed(cm)) return 0;
+
+ indices = cmesh_index(cm);
+ assert(indices);
+
+ idxnum = cmesh_index_count(cm);
+ nnverts = idxnum;
+
+ for(i=0; i<CMESH_NUM_ATTR; i++) {
+ const float *srcbuf;
+ float *tmpbuf, *dstptr;
+
+ if(!cmesh_has_attrib(cm, i)) continue;
+
+ srcbuf = cmesh_attrib(cm, i);
+ if(!(tmpbuf = malloc(nnverts * cm->vattr[i].nelem * sizeof(float)))) {
+ return -1;
+ }
+ dstptr = tmpbuf;
+
+ for(j=0; j<idxnum; j++) {
+ unsigned int idx = indices[j];
+ const float *srcptr = srcbuf + idx * cm->vattr[i].nelem;
+
+ for(k=0; k<cm->vattr[i].nelem; k++) {
+ *dstptr++ = *srcptr++;
+ }
+ }
+
+ free(cm->vattr[i].data);
+ cm->vattr[i].data = tmpbuf;
+ cm->vattr[i].count = nnverts * cm->vattr[i].nelem;
+ cm->vattr[i].data_valid = 1;
+ }
+
+ cm->ibo_valid = 0;
+ cm->idata_valid = 0;
+ free(cm->idata);
+ cm->idata = 0;
+ cm->icount = 0;
+
+ cm->nverts = nnverts;
+ cm->nfaces = idxnum / 3;
+ return 0;
+}
+
+void cmesh_calc_face_normals(struct cmesh *cm)
+{
+ /* TODO */
+}
+
+static int pre_draw(struct cmesh *cm)
+{
+ int i, loc, cur_sdr;
+
+ glGetIntegerv(GL_CURRENT_PROGRAM, &cur_sdr);
+
+ update_buffers(cm);
+
+ if(!cm->vattr[CMESH_ATTR_VERTEX].vbo_valid) {
+ return -1;
+ }
+
+ if(cur_sdr && use_custom_sdr_attr) {
+ if(sdr_loc[CMESH_ATTR_VERTEX] == -1) {
+ return -1;
+ }
+
+ for(i=0; i<CMESH_NUM_ATTR; i++) {
+ loc = sdr_loc[i];
+ if(loc >= 0 && cm->vattr[i].vbo_valid) {
+ glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[i].vbo);
+ glVertexAttribPointer(loc, cm->vattr[i].nelem, GL_FLOAT, GL_FALSE, 0, 0);
+ glEnableVertexAttribArray(loc);
+ }
+ }
+ } else {
+#ifndef GL_ES_VERSION_2_0
+ glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[CMESH_ATTR_VERTEX].vbo);
+ glVertexPointer(cm->vattr[CMESH_ATTR_VERTEX].nelem, GL_FLOAT, 0, 0);
+ glEnableClientState(GL_VERTEX_ARRAY);
+
+ if(cm->vattr[CMESH_ATTR_NORMAL].vbo_valid) {
+ glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[CMESH_ATTR_NORMAL].vbo);
+ glNormalPointer(GL_FLOAT, 0, 0);
+ glEnableClientState(GL_NORMAL_ARRAY);
+ }
+ if(cm->vattr[CMESH_ATTR_TEXCOORD].vbo_valid) {
+ glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[CMESH_ATTR_TEXCOORD].vbo);
+ glTexCoordPointer(cm->vattr[CMESH_ATTR_TEXCOORD].nelem, GL_FLOAT, 0, 0);
+ glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+ }
+ if(cm->vattr[CMESH_ATTR_COLOR].vbo_valid) {
+ glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[CMESH_ATTR_COLOR].vbo);
+ glColorPointer(cm->vattr[CMESH_ATTR_COLOR].nelem, GL_FLOAT, 0, 0);
+ glEnableClientState(GL_COLOR_ARRAY);
+ }
+ if(cm->vattr[CMESH_ATTR_TEXCOORD2].vbo_valid) {
+ glClientActiveTexture(GL_TEXTURE1);
+ glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[CMESH_ATTR_TEXCOORD2].vbo);
+ glTexCoordPointer(cm->vattr[CMESH_ATTR_TEXCOORD2].nelem, GL_FLOAT, 0, 0);
+ glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+ glClientActiveTexture(GL_TEXTURE0);
+ }
+#endif /* GL_ES_VERSION_2_0 */
+ }
+ glBindBuffer(GL_ARRAY_BUFFER, 0);
+ return cur_sdr;
+}
+
+void cmesh_draw(struct cmesh *cm)
+{
+ int cur_sdr;
+
+ if((cur_sdr = pre_draw(cm)) == -1) {
+ return;
+ }
+
+ if(cm->ibo_valid) {
+ glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cm->ibo);
+ glDrawElements(GL_TRIANGLES, cm->nfaces * 3, GL_UNSIGNED_INT, 0);
+ glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+ } else {
+ glDrawArrays(GL_TRIANGLES, 0, cm->nverts);
+ }
+
+ post_draw(cm, cur_sdr);
+}
+
+static void post_draw(struct cmesh *cm, int cur_sdr)
+{
+ int i;
+
+ if(cur_sdr && use_custom_sdr_attr) {
+ for(i=0; i<CMESH_NUM_ATTR; i++) {
+ int loc = sdr_loc[i];
+ if(loc >= 0 && cm->vattr[i].vbo_valid) {
+ glDisableVertexAttribArray(loc);
+ }
+ }
+ } else {
+#ifndef GL_ES_VERSION_2_0
+ glDisableClientState(GL_VERTEX_ARRAY);
+ if(cm->vattr[CMESH_ATTR_NORMAL].vbo_valid) {
+ glDisableClientState(GL_NORMAL_ARRAY);
+ }
+ if(cm->vattr[CMESH_ATTR_TEXCOORD].vbo_valid) {
+ glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+ }
+ if(cm->vattr[CMESH_ATTR_COLOR].vbo_valid) {
+ glDisableClientState(GL_COLOR_ARRAY);
+ }
+ if(cm->vattr[CMESH_ATTR_TEXCOORD2].vbo_valid) {
+ glClientActiveTexture(GL_TEXTURE1);
+ glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+ glClientActiveTexture(GL_TEXTURE0);
+ }
+#endif /* GL_ES_VERSION_2_0 */
+ }
+}
+
+void cmesh_draw_wire(struct cmesh *cm, float linesz)
+{
+ int cur_sdr, nfaces;
+
+ if((cur_sdr = pre_draw(cm)) == -1) {
+ return;
+ }
+ update_wire_ibo(cm);
+
+ nfaces = cmesh_poly_count(cm);
+ glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cm->wire_ibo);
+ glDrawElements(GL_LINES, nfaces * 6, GL_UNSIGNED_INT, 0);
+ glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+
+ post_draw(cm, cur_sdr);
+}
+
+void cmesh_draw_vertices(struct cmesh *cm, float ptsz)
+{
+ int cur_sdr;
+ if((cur_sdr = pre_draw(cm)) == -1) {
+ return;
+ }
+
+ glPushAttrib(GL_POINT_BIT);
+ glPointSize(ptsz);
+ glDrawArrays(GL_POINTS, 0, cm->nverts);
+ glPopAttrib();
+
+ post_draw(cm, cur_sdr);
+}
+
+void cmesh_draw_normals(struct cmesh *cm, float len)
+{
+#ifndef GL_ES_VERSION_2_0
+ int i, cur_sdr, vert_nelem, norm_nelem;
+ int loc = -1;
+ const float *varr, *norm;
+
+ varr = cmesh_attrib_ro(cm, CMESH_ATTR_VERTEX);
+ norm = cmesh_attrib_ro(cm, CMESH_ATTR_NORMAL);
+ if(!varr || !norm) return;
+
+ vert_nelem = cm->vattr[CMESH_ATTR_VERTEX].nelem;
+ norm_nelem = cm->vattr[CMESH_ATTR_NORMAL].nelem;
+
+ glGetIntegerv(GL_CURRENT_PROGRAM, &cur_sdr);
+ if(cur_sdr && use_custom_sdr_attr) {
+ if((loc = sdr_loc[CMESH_ATTR_VERTEX]) < 0) {
+ return;
+ }
+ }
+
+ glBegin(GL_LINES);
+ for(i=0; i<cm->nverts; i++) {
+ float x, y, z, endx, endy, endz;
+
+ x = varr[i * vert_nelem];
+ y = varr[i * vert_nelem + 1];
+ z = varr[i * vert_nelem + 2];
+ endx = x + norm[i * norm_nelem] * len;
+ endy = y + norm[i * norm_nelem + 1] * len;
+ endz = z + norm[i * norm_nelem + 2] * len;
+
+ if(loc == -1) {
+ glVertex3f(x, y, z);
+ glVertex3f(endx, endy, endz);
+ } else {
+ glVertexAttrib3f(loc, x, y, z);
+ glVertexAttrib3f(loc, endx, endy, endz);
+ }
+ }
+ glEnd();
+#endif /* GL_ES_VERSION_2_0 */
+}
+
+void cmesh_draw_tangents(struct cmesh *cm, float len)
+{
+#ifndef GL_ES_VERSION_2_0
+ int i, cur_sdr, vert_nelem, tang_nelem;
+ int loc = -1;
+ const float *varr, *tang;
+
+ varr = cmesh_attrib_ro(cm, CMESH_ATTR_VERTEX);
+ tang = cmesh_attrib_ro(cm, CMESH_ATTR_TANGENT);
+ if(!varr || !tang) return;
+
+ vert_nelem = cm->vattr[CMESH_ATTR_VERTEX].nelem;
+ tang_nelem = cm->vattr[CMESH_ATTR_TANGENT].nelem;
+
+ glGetIntegerv(GL_CURRENT_PROGRAM, &cur_sdr);
+ if(cur_sdr && use_custom_sdr_attr) {
+ if((loc = sdr_loc[CMESH_ATTR_VERTEX]) < 0) {
+ return;
+ }
+ }
+
+ glBegin(GL_LINES);
+ for(i=0; i<cm->nverts; i++) {
+ float x, y, z, endx, endy, endz;
+
+ x = varr[i * vert_nelem];
+ y = varr[i * vert_nelem + 1];
+ z = varr[i * vert_nelem + 2];
+ endx = x + tang[i * tang_nelem] * len;
+ endy = y + tang[i * tang_nelem + 1] * len;
+ endz = z + tang[i * tang_nelem + 2] * len;
+
+ if(loc == -1) {
+ glVertex3f(x, y, z);
+ glVertex3f(endx, endy, endz);
+ } else {
+ glVertexAttrib3f(loc, x, y, z);
+ glVertexAttrib3f(loc, endx, endy, endz);
+ }
+ }
+ glEnd();
+#endif /* GL_ES_VERSION_2_0 */
+}
+
+static void update_buffers(struct cmesh *cm)
+{
+ int i;
+
+ for(i=0; i<CMESH_NUM_ATTR; i++) {
+ if(cmesh_has_attrib(cm, i) && !cm->vattr[i].vbo_valid) {
+ glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[i].vbo);
+ glBufferData(GL_ARRAY_BUFFER, cm->nverts * cm->vattr[i].nelem * sizeof(float),
+ cm->vattr[i].data, GL_STATIC_DRAW);
+ cm->vattr[i].vbo_valid = 1;
+ }
+ }
+ glBindBuffer(GL_ARRAY_BUFFER, 0);
+
+ if(cm->idata_valid && !cm->ibo_valid) {
+ glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cm->ibo);
+ glBufferData(GL_ELEMENT_ARRAY_BUFFER, cm->nfaces * 3 * sizeof(unsigned int),
+ cm->idata, GL_STATIC_DRAW);
+ cm->ibo_valid = 1;
+ glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+ }
+}
-/* get the bounding sphere in local space. The result will be cached ... see above */
-float cmesh_bsphere(struct cmesh *cm, cgm_vec3 *center, float *rad);
+static void update_wire_ibo(struct cmesh *cm)
+{
+ int i, num_faces;
+ unsigned int *wire_idxarr, *dest;
+
+ update_buffers(cm);
+
+ if(cm->wire_ibo_valid) return;
+
+ if(!cm->wire_ibo) {
+ glGenBuffers(1, &cm->wire_ibo);
+ }
+ num_faces = cmesh_poly_count(cm);
+
+ if(!(wire_idxarr = malloc(num_faces * 6 * sizeof *wire_idxarr))) {
+ return;
+ }
+ dest = wire_idxarr;
+
+ if(cm->ibo_valid) {
+ /* we're dealing with an indexed mesh */
+ const unsigned int *idxarr = cmesh_index_ro(cm);
+
+ for(i=0; i<num_faces; i++) {
+ *dest++ = idxarr[0];
+ *dest++ = idxarr[1];
+ *dest++ = idxarr[1];
+ *dest++ = idxarr[2];
+ *dest++ = idxarr[2];
+ *dest++ = idxarr[0];
+ idxarr += 3;
+ }
+ } else {
+ /* not an indexed mesh */
+ for(i=0; i<num_faces; i++) {
+ int vidx = i * 3;
+ *dest++ = vidx;
+ *dest++ = vidx + 1;
+ *dest++ = vidx + 1;
+ *dest++ = vidx + 2;
+ *dest++ = vidx + 2;
+ *dest++ = vidx;
+ }
+ }
+
+ glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cm->wire_ibo);
+ glBufferData(GL_ELEMENT_ARRAY_BUFFER, num_faces * 6 * sizeof(unsigned int),
+ wire_idxarr, GL_STATIC_DRAW);
+ free(wire_idxarr);
+ cm->wire_ibo_valid = 1;
+ glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+}
+
+static void calc_aabb(struct cmesh *cm)
+{
+ int i, j;
+
+ if(!cmesh_attrib_ro(cm, CMESH_ATTR_VERTEX)) {
+ return;
+ }
-/* texture coordinate manipulation */
+ cgm_vcons(&cm->aabb_min, FLT_MAX, FLT_MAX, FLT_MAX);
+ cgm_vcons(&cm->aabb_max, -FLT_MAX, -FLT_MAX, -FLT_MAX);
+
+ for(i=0; i<cm->nverts; i++) {
+ const float *v = cmesh_attrib_at_ro(cm, CMESH_ATTR_VERTEX, i);
+ for(j=0; j<3; j++) {
+ if(v[j] < (&cm->aabb_min.x)[j]) {
+ (&cm->aabb_min.x)[j] = v[j];
+ }
+ if(v[j] > (&cm->aabb_max.x)[j]) {
+ (&cm->aabb_max.x)[j] = v[j];
+ }
+ }
+ }
+ cm->aabb_valid = 1;
+}
+
+void cmesh_aabbox(struct cmesh *cm, cgm_vec3 *vmin, cgm_vec3 *vmax)
+{
+ if(!cm->aabb_valid) {
+ calc_aabb(cm);
+ }
+ *vmin = cm->aabb_min;
+ *vmax = cm->aabb_max;
+}
+
+static void calc_bsph(struct cmesh *cm)
+{
+ int i;
+ float s, dist_sq;
+
+ if(!cmesh_attrib_ro(cm, CMESH_ATTR_VERTEX)) {
+ return;
+ }
+
+ cgm_vcons(&cm->bsph_center, 0, 0, 0);
+
+ /* first find the center */
+ for(i=0; i<cm->nverts; i++) {
+ const float *v = cmesh_attrib_at_ro(cm, CMESH_ATTR_VERTEX, i);
+ cm->bsph_center.x += v[0];
+ cm->bsph_center.y += v[1];
+ cm->bsph_center.z += v[2];
+ }
+ s = 1.0f / (float)cm->nverts;
+ cm->bsph_center.x *= s;
+ cm->bsph_center.y *= s;
+ cm->bsph_center.z *= s;
+
+ cm->bsph_radius = 0.0f;
+ for(i=0; i<cm->nverts; i++) {
+ const cgm_vec3 *v = (const cgm_vec3*)cmesh_attrib_at_ro(cm, CMESH_ATTR_VERTEX, i);
+ if((dist_sq = cgm_vdist_sq(v, &cm->bsph_center)) > cm->bsph_radius) {
+ cm->bsph_radius = dist_sq;
+ }
+ }
+ cm->bsph_radius = sqrt(cm->bsph_radius);
+ cm->bsph_valid = 1;
+}
+
+float cmesh_bsphere(struct cmesh *cm, cgm_vec3 *center, float *rad)
+{
+ if(!cm->bsph_valid) {
+ calc_bsph(cm);
+ }
+ *center = cm->bsph_center;
+ *rad = cm->bsph_radius;
+ return cm->bsph_radius;
+}
+
+/* TODO */
void cmesh_texcoord_apply_xform(struct cmesh *cm, float *xform);
void cmesh_texcoord_gen_plane(struct cmesh *cm, cgm_vec3 *norm, cgm_vec3 *tang);
void cmesh_texcoord_gen_box(struct cmesh *cm);
void cmesh_texcoord_gen_cylinder(struct cmesh *cm);
-int cmesh_dump(struct cmesh *cm, const char *fname);
-int cmesh_dump_file(struct cmesh *cm, FILE *fp);
-int cmesh_dump_obj(struct cmesh *cm, const char *fname);
-int cmesh_dump_obj_file(struct cmesh *cm, FILE *fp, int voffs);
+int cmesh_dump(struct cmesh *cm, const char *fname)
+{
+ FILE *fp = fopen(fname, "wb");
+ if(fp) {
+ int res = cmesh_dump_file(cm, fp);
+ fclose(fp);
+ return res;
+ }
+ return -1;
+}
+
+int cmesh_dump_file(struct cmesh *cm, FILE *fp)
+{
+ static const char *label[] = { "pos", "nor", "tan", "tex", "col", "bw", "bid", "tex2" };
+ static const char *elemfmt[] = { 0, " %s(%g)", " %s(%g, %g)", " %s(%g, %g, %g)", " %s(%g, %g, %g, %g)", 0 };
+ int i, j;
+
+ if(!cmesh_has_attrib(cm, CMESH_ATTR_VERTEX)) {
+ return -1;
+ }
+
+ fprintf(fp, "VERTEX ATTRIBUTES\n");
+
+ for(i=0; i<cm->nverts; i++) {
+ fprintf(fp, "%5u:", i);
+ for(j=0; j<CMESH_NUM_ATTR; j++) {
+ if(cmesh_has_attrib(cm, j)) {
+ const float *v = cmesh_attrib_at_ro(cm, j, i);
+ int nelem = cm->vattr[j].nelem;
+ fprintf(fp, elemfmt[nelem], label[j], v[0], nelem > 1 ? v[1] : 0.0f,
+ nelem > 2 ? v[2] : 0.0f, nelem > 3 ? v[3] : 0.0f);
+ }
+ }
+ fputc('\n', fp);
+ }
+
+ if(cmesh_indexed(cm)) {
+ const unsigned int *idx = cmesh_index_ro(cm);
+ int numidx = cmesh_index_count(cm);
+ int numtri = numidx / 3;
+ assert(numidx % 3 == 0);
+
+ fprintf(fp, "FACES\n");
+
+ for(i=0; i<numtri; i++) {
+ fprintf(fp, "%5d: %d %d %d\n", i, idx[0], idx[1], idx[2]);
+ idx += 3;
+ }
+ }
+ return 0;
+}
+
+int cmesh_dump_obj(struct cmesh *cm, const char *fname)
+{
+ FILE *fp = fopen(fname, "wb");
+ if(fp) {
+ int res = cmesh_dump_obj_file(cm, fp, 0);
+ fclose(fp);
+ return res;
+ }
+ return -1;
+}
+
+#define HAS_VN 1
+#define HAS_VT 2
+
+int cmesh_dump_obj_file(struct cmesh *cm, FILE *fp, int voffs)
+{
+ static const char *fmtstr[] = {" %u", " %u//%u", " %u/%u", " %u/%u/%u"};
+ int i, j, num, nelem;
+ unsigned int aflags = 0;
+
+ if(!cmesh_has_attrib(cm, CMESH_ATTR_VERTEX)) {
+ return -1;
+ }
+
+
+ nelem = cm->vattr[CMESH_ATTR_VERTEX].nelem;
+ if((num = cm->vattr[CMESH_ATTR_VERTEX].count) != cm->nverts * nelem) {
+ warning_log("vertex array size (%d) != nverts (%d)\n", num, cm->nverts);
+ }
+ for(i=0; i<cm->nverts; i++) {
+ const float *v = cmesh_attrib_at_ro(cm, CMESH_ATTR_VERTEX, i);
+ fprintf(fp, "v %f %f %f\n", v[0], nelem > 1 ? v[1] : 0.0f, nelem > 2 ? v[2] : 0.0f);
+ }
+
+ if(cmesh_has_attrib(cm, CMESH_ATTR_NORMAL)) {
+ aflags |= HAS_VN;
+ nelem = cm->vattr[CMESH_ATTR_NORMAL].nelem;
+ if((num = cm->vattr[CMESH_ATTR_NORMAL].count) != cm->nverts * nelem) {
+ warning_log("normal array size (%d) != nverts (%d)\n", num, cm->nverts);
+ }
+ for(i=0; i<cm->nverts; i++) {
+ const float *v = cmesh_attrib_at_ro(cm, CMESH_ATTR_NORMAL, i);
+ fprintf(fp, "vn %f %f %f\n", v[0], nelem > 1 ? v[1] : 0.0f, nelem > 2 ? v[2] : 0.0f);
+ }
+ }
+
+ if(cmesh_has_attrib(cm, CMESH_ATTR_TEXCOORD)) {
+ aflags |= HAS_VT;
+ nelem = cm->vattr[CMESH_ATTR_TEXCOORD].nelem;
+ if((num = cm->vattr[CMESH_ATTR_TEXCOORD].count) != cm->nverts * nelem) {
+ warning_log("texcoord array size (%d) != nverts (%d)\n", num, cm->nverts);
+ }
+ for(i=0; i<cm->nverts; i++) {
+ const float *v = cmesh_attrib_at_ro(cm, CMESH_ATTR_TEXCOORD, i);
+ fprintf(fp, "vt %f %f\n", v[0], nelem > 1 ? v[1] : 0.0f);
+ }
+ }
+
+ if(cmesh_indexed(cm)) {
+ const unsigned int *idxptr = cmesh_index_ro(cm);
+ int numidx = cmesh_index_count(cm);
+ int numtri = numidx / 3;
+ assert(numidx % 3 == 0);
+
+ for(i=0; i<numtri; i++) {
+ fputc('f', fp);
+ for(j=0; j<3; j++) {
+ unsigned int idx = *idxptr++ + 1 + voffs;
+ fprintf(fp, fmtstr[aflags], idx, idx, idx);
+ }
+ fputc('\n', fp);
+ }
+ } else {
+ int numtri = cm->nverts / 3;
+ unsigned int idx = 1 + voffs;
+ for(i=0; i<numtri; i++) {
+ fputc('f', fp);
+ for(j=0; j<3; j++) {
+ fprintf(fp, fmtstr[aflags], idx, idx, idx);
+ ++idx;
+ }
+ fputc('\n', fp);
+ }
+ }
+ return 0;
+}
projects / vrtris / blobdiff