From: John Tsiombikas Date: Sun, 1 Jan 2023 03:50:33 +0000 (+0200) Subject: initial commit X-Git-Url: http://git.mutantstargoat.com/user/nuclear/?p=meshfrac;a=commitdiff_plain;h=3266468aa891bea6bda03f64ecba7da2a29d09c3 initial commit --- 3266468aa891bea6bda03f64ecba7da2a29d09c3 diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..9f15460 --- /dev/null +++ b/.gitignore @@ -0,0 +1,5 @@ +*.o +*.d +*.swp +*.a +meshfrac diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..1c5ee86 --- /dev/null +++ b/Makefile @@ -0,0 +1,24 @@ +src = $(wildcard src/*.c) +obj = $(src:.c=.o) +dep = $(src:.c=.d) +bin = meshfrac +liba = lib$(bin).a + +CFLAGS = -pedantic -Wall -g -Isrc -MMD +LDFLAGS = $(liba) -lGL -lglut -l:libGLEW.a -lm + +$(bin): main.o $(liba) + $(CC) -o $@ $< $(LDFLAGS) + +$(liba): $(obj) + $(AR) rcs $(liba) $(obj) + +-include $(dep) + +.PHONY: clean +clean: + $(RM) $(obj) $(bin) $(liba) + +.PHONY: cleandep +cleandep: + $(RM) $(dep) diff --git a/main.c b/main.c new file mode 100644 index 0000000..07e67c3 --- /dev/null +++ b/main.c @@ -0,0 +1,205 @@ +#include +#include +#include +#include "opengl.h" +#include +#include +#include "cmesh.h" +#include "meshgen.h" +#include "sdr.h" + +static const char *vsdr_src = + "varying vec3 v_norm, v_ldir, v_vdir;\n" + "void main()\n" + "{\n" + " gl_Position = ftransform();\n" + " vec3 vpos = (gl_ModelViewMatrix * gl_Vertex).xyz;\n" + " v_vdir = -vpos;\n" + " v_norm = gl_NormalMatrix * gl_Normal;\n" + " v_ldir = gl_LightSource[0].position.xyz - vpos;\n" + "}\n"; + +static const char *psdr_src = + "varying vec3 v_norm, v_ldir, v_vdir;\n" + "void main()\n" + "{\n" + " vec3 n = normalize(v_norm);\n" + " vec3 v = normalize(v_vdir);\n" + " vec3 l = normalize(v_ldir);\n" + " vec3 h = normalize(v + l);\n" + " float ndotl = max(dot(n, l), 0.0);\n" + " float ndoth = max(dot(n, h), 0.0);\n" + " float spec = pow(ndoth, gl_FrontMaterial.shininess);\n" + " vec3 dcol = gl_FrontMaterial.diffuse.rgb * ndotl;\n" + " vec3 scol = gl_FrontMaterial.specular.rgb * spec;\n" + " gl_FragColor = vec4(dcol + scol, 1.0);\n" + "}\n"; + +static int init(void); +static void cleanup(void); +static void display(void); +static void reshape(int x, int y); +static void keydown(unsigned char key, int x, int y); +static void mouse(int bn, int st, int x, int y); +static void motion(int x, int y); + +static int win_width, win_height; +static cgm_vec3 view_pos; +static float view_theta, view_phi = 0.6, view_dist = 8; +static float proj_mat[16], view_mat[16]; +static int bnstate[8]; +static int mx, my; + +static struct cmesh *mesh; +static unsigned int sdr; + +int main(int argc, char **argv) +{ + glutInit(&argc, argv); + glutInitWindowSize(1280, 800); + glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE); + glutCreateWindow("meshfrac"); + + glutDisplayFunc(display); + glutReshapeFunc(reshape); + glutKeyboardFunc(keydown); + glutMouseFunc(mouse); + glutMotionFunc(motion); + + if(init() == -1) { + return 1; + } + atexit(cleanup); + + glutMainLoop(); + return 0; +} + +static int init(void) +{ + unsigned int vsdr, psdr; + float diffuse[] = {0.2, 0.3, 0.8, 1}; + float specular[] = {0.8, 0.8, 0.8, 1}; +#ifdef __glew_h__ + glewInit(); +#endif + + if(!(vsdr = create_vertex_shader(vsdr_src))) { + return -1; + } + if(!(psdr = create_pixel_shader(psdr_src))) { + free_shader(vsdr); + return -1; + } + if(!(sdr = create_program_link(vsdr, psdr, 0))) { + free_shader(vsdr); + free_shader(psdr); + return -1; + } + + glEnable(GL_CULL_FACE); + glEnable(GL_DEPTH_TEST); + glEnable(GL_LIGHTING); + glEnable(GL_LIGHT0); + + glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, diffuse); + glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, specular); + glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 60); + + bind_program(sdr); + + mesh = cmesh_alloc(); + gen_torus(mesh, 2, 0.8, 24, 12, 1, 1); + + return 0; +} + +static void cleanup(void) +{ + cmesh_free(mesh); + free_program(sdr); +} + +static void display(void) +{ + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + + cgm_mtranslation(view_mat, 0, 0, -view_dist); + cgm_mprerotate_x(view_mat, view_phi); + cgm_mprerotate_y(view_mat, view_theta); + cgm_mpretranslate(view_mat, -view_pos.x, -view_pos.y, -view_pos.z); + glMatrixMode(GL_MODELVIEW); + glLoadMatrixf(view_mat); + + cmesh_draw(mesh); + + assert(glGetError() == GL_NO_ERROR); + glutSwapBuffers(); +} + +static void reshape(int x, int y) +{ + win_width = x; + win_height = y; + glViewport(0, 0, x, y); + + cgm_mperspective(proj_mat, cgm_deg_to_rad(50), (float)x / y, 0.5, 500.0); + glMatrixMode(GL_PROJECTION); + glLoadMatrixf(proj_mat); +} + +static void keydown(unsigned char key, int x, int y) +{ + switch(key) { + case 27: + exit(0); + } +} + +static void mouse(int bn, int st, int x, int y) +{ + int bidx = bn - GLUT_LEFT_BUTTON; + if(bidx < 8) { + bnstate[bidx] = st == GLUT_DOWN; + } + mx = x; + my = y; +} + +static void motion(int x, int y) +{ + int dx = x - mx; + int dy = y - my; + mx = x; + my = y; + + if(!(dx | dy)) return; + + if(bnstate[0]) { + view_theta += cgm_deg_to_rad(dx * 0.5); + view_phi += cgm_deg_to_rad(dy * 0.5); + if(view_phi < -M_PI / 2) view_phi = -M_PI / 2; + if(view_phi > M_PI / 2) view_phi = M_PI / 2; + glutPostRedisplay(); + } + if(bnstate[1]) { + cgm_vec3 up, right; + + up.x = -sin(view_theta) * sin(view_phi); + up.y = -cos(view_phi); + up.z = cos(view_theta) * sin(view_phi); + right.x = cos(view_theta); + right.y = 0; + right.z = sin(view_theta); + + view_pos.x -= (right.x * dx + up.x * dy) * 0.01; + view_pos.y -= up.y * dy * 0.01; + view_pos.z -= (right.z * dx + up.z * dy) * 0.01; + glutPostRedisplay(); + } + if(bnstate[2]) { + view_dist += dy * 0.1; + if(view_dist < 0) view_dist = 0; + glutPostRedisplay(); + } +} diff --git a/src/cmesh.c b/src/cmesh.c new file mode 100644 index 0000000..71f58af --- /dev/null +++ b/src/cmesh.c @@ -0,0 +1,1631 @@ +#include +#include +#include +#include +#include +#include +#include "opengl.h" +#include "cmesh.h" + + +struct cmesh_vattrib { + int nelem; /* num elements per attribute [1, 4] */ + float *data; + unsigned int count; + unsigned int vbo; + int vbo_valid, data_valid; +}; + +/* istart,icount are valid only when the mesh is indexed, otherwise icount is 0. + * vstart,vcount are define the submesh for non-indexed meshes. + * For indexed meshes, vstart,vcount denote the range of vertices used by each + * submesh. + */ +struct submesh { + char *name; + int nfaces; /* derived from either icount or vcount */ + int istart, icount; + int vstart, vcount; + struct submesh *next; +}; + +struct cmesh { + char *name; + unsigned int nverts, nfaces; + + struct submesh *sublist; + int subcount; + + /* current value for each attribute for the immediate mode interface */ + cgm_vec4 cur_val[CMESH_NUM_ATTR]; + + unsigned int buffer_objects[CMESH_NUM_ATTR + 1]; + struct cmesh_vattrib vattr[CMESH_NUM_ATTR]; + + unsigned int *idata; + unsigned int icount; + unsigned int ibo; + int ibo_valid, idata_valid; + + /* index buffer for wireframe rendering (constructed on demand) */ + unsigned int wire_ibo; + int wire_ibo_valid; + + /* axis-aligned bounding box */ + cgm_vec3 aabb_min, aabb_max; + int aabb_valid; + /* bounding sphere */ + cgm_vec3 bsph_center; + float bsph_radius; + int bsph_valid; +}; + + +static int clone(struct cmesh *cmdest, struct cmesh *cmsrc, struct submesh *sub); +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 */ +void cmesh_set_attrib_sdrloc(int attr, int loc) +{ + sdr_loc[attr] = loc; +} + +int cmesh_get_attrib_sdrloc(int attr) +{ + return sdr_loc[attr]; +} + +void cmesh_clear_attrib_sdrloc(void) +{ + int i; + for(i=0; icur_val + CMESH_ATTR_COLOR, 1, 1, 1, 1); + + glGenBuffers(CMESH_NUM_ATTR + 1, cm->buffer_objects); + + for(i=0; ivattr[i].vbo = cm->buffer_objects[i]; + } + + cm->ibo = cm->buffer_objects[CMESH_NUM_ATTR]; + return 0; +} + +void cmesh_destroy(struct cmesh *cm) +{ + int i; + + free(cm->name); + + for(i=0; ivattr[i].data); + } + free(cm->idata); + + cmesh_clear_submeshes(cm); + + glDeleteBuffers(CMESH_NUM_ATTR + 1, cm->buffer_objects); + if(cm->wire_ibo) { + glDeleteBuffers(1, &cm->wire_ibo); + } +} + +void cmesh_clear(struct cmesh *cm) +{ + int i; + + for(i=0; ivattr[i].nelem = 0; + cm->vattr[i].vbo_valid = 0; + cm->vattr[i].data_valid = 0; + free(cm->vattr[i].data); + cm->vattr[i].data = 0; + cm->vattr[i].count = 0; + } + cm->ibo_valid = cm->idata_valid = 0; + free(cm->idata); + cm->idata = 0; + cm->icount = 0; + + cm->wire_ibo_valid = 0; + cm->nverts = cm->nfaces = 0; + + cm->bsph_valid = cm->aabb_valid = 0; + + cmesh_clear_submeshes(cm); +} + +int cmesh_clone(struct cmesh *cmdest, struct cmesh *cmsrc) +{ + return clone(cmdest, cmsrc, 0); +} + +static int clone(struct cmesh *cmdest, struct cmesh *cmsrc, struct submesh *sub) +{ + int i, nelem, vstart, vcount, istart, icount; + char *srcname, *name = 0; + float *varr[CMESH_NUM_ATTR] = {0}; + float *vptr; + unsigned int *iptr, *iarr = 0; + + /* try do anything that can fail first, before making any changes to cmdest + * so we have the option of recovering gracefuly + */ + + srcname = sub ? sub->name : cmsrc->name; + if(srcname) { + if(!(name = malloc(strlen(srcname) + 1))) { + return -1; + } + strcpy(name, srcname); + } + + if(sub) { + vstart = sub->vstart; + vcount = sub->vcount; + istart = sub->istart; + icount = sub->icount; + } else { + vstart = istart = 0; + vcount = cmsrc->nverts; + icount = cmsrc->icount; + } + + if(cmesh_indexed(cmsrc)) { + if(!(iarr = malloc(icount * sizeof *iarr))) { + free(name); + return -1; + } + } + + for(i=0; ivattr[i].nelem; + if(!(varr[i] = malloc(vcount * nelem * sizeof(float)))) { + while(--i >= 0) { + free(varr[i]); + } + free(iarr); + free(name); + return -1; + } + } + } + + /* from this point forward nothing can fail */ + cmesh_clear(cmdest); + + for(i=0; ivattr[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; + cmdest->vattr[i].data = varr[i]; + cmdest->vattr[i].count = vcount; + vptr = cmsrc->vattr[i].data + vstart * nelem; + memcpy(cmdest->vattr[i].data, vptr, vcount * nelem * sizeof(float)); + cmdest->vattr[i].data_valid = 1; + cmdest->vattr[i].vbo_valid = 0; + } else { + memset(cmdest->vattr + i, 0, sizeof cmdest->vattr[i]); + } + } + + if(cmesh_indexed(cmsrc)) { + cmesh_index(cmsrc); /* force validation .... */ + + cmdest->idata = iarr; + cmdest->icount = icount; + if(sub) { + /* need to offset all vertex indices by -vstart */ + iptr = cmsrc->idata + istart; + for(i=0; iidata[i] = *iptr++ - vstart; + } + } else { + memcpy(cmdest->idata, cmsrc->idata + istart, icount * sizeof *cmdest->idata); + } + cmdest->idata_valid = 1; + } else { + cmdest->idata = 0; + cmdest->idata_valid = cmdest->ibo_valid = 0; + } + + free(cmdest->name); + cmdest->name = name; + + cmdest->nverts = cmsrc->nverts; + cmdest->nfaces = sub ? sub->nfaces : cmsrc->nfaces; + + memcpy(cmdest->cur_val, cmsrc->cur_val, sizeof cmdest->cur_val); + + cmdest->aabb_min = cmsrc->aabb_min; + cmdest->aabb_max = cmsrc->aabb_max; + cmdest->aabb_valid = cmsrc->aabb_valid; + cmdest->bsph_center = cmsrc->bsph_center; + cmdest->bsph_radius = cmsrc->bsph_radius; + cmdest->bsph_valid = cmsrc->bsph_valid; + + /* copy sublist only if we're not cloning a submesh */ + if(!sub) { + struct submesh *sm, *n, *head = 0, *tail = 0; + + sm = cmsrc->sublist; + while(sm) { + if(!(n = malloc(sizeof *n)) || !(name = malloc(strlen(sm->name) + 1))) { + free(n); + sm = sm->next; + continue; + } + strcpy(name, sm->name); + *n = *sm; + n->name = name; + n->next = 0; + + if(head) { + tail->next = n; + tail = n; + } else { + head = tail = n; + } + + sm = sm->next; + } + + cmdest->sublist = head; + cmdest->subcount = cmsrc->subcount; + } + + return 0; +} + +int cmesh_set_name(struct cmesh *cm, const char *name) +{ + int len = strlen(name); + char *tmp = malloc(len + 1); + if(!tmp) return -1; + free(cm->name); + cm->name = tmp; + memcpy(cm->name, name, len + 1); + return 0; +} + +const char *cmesh_name(struct cmesh *cm) +{ + return cm->name; +} + +int cmesh_has_attrib(struct cmesh *cm, int attr) +{ + if(attr < 0 || attr >= CMESH_NUM_ATTR) { + return 0; + } + return cm->vattr[attr].vbo_valid | cm->vattr[attr].data_valid; +} + +int cmesh_indexed(struct cmesh *cm) +{ + return cm->ibo_valid | cm->idata_valid; +} + +/* vdata can be 0, in which case only memory is allocated + * returns pointer to the attribute array + */ +float *cmesh_set_attrib(struct cmesh *cm, int attr, int nelem, unsigned int num, + const float *vdata) +{ + float *newarr; + + if(attr < 0 || attr >= CMESH_NUM_ATTR) { + return 0; + } + if(cm->nverts && num != cm->nverts) { + return 0; + } + + if(!(newarr = malloc(num * nelem * sizeof *newarr))) { + return 0; + } + if(vdata) { + memcpy(newarr, vdata, num * nelem * sizeof *newarr); + } + + cm->nverts = num; + + 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; + return newarr; +} + +float *cmesh_attrib(struct cmesh *cm, int attr) +{ + if(attr < 0 || attr >= CMESH_NUM_ATTR) { + return 0; + } + cm->vattr[attr].vbo_valid = 0; + return (float*)cmesh_attrib_ro(cm, attr); +} + +const float *cmesh_attrib_ro(struct cmesh *cm, int attr) +{ + void *tmp; + int nelem; + + if(attr < 0 || attr >= CMESH_NUM_ATTR) { + return 0; + } + + if(!cm->vattr[attr].data_valid) { +#if GL_ES_VERSION_2_0 + return 0; +#else + if(!cm->vattr[attr].vbo_valid) { + return 0; + } + + /* local data copy unavailable, grab the data from the vbo */ + nelem = cm->vattr[attr].nelem; + if(!(cm->vattr[attr].data = malloc(cm->nverts * nelem * sizeof(float)))) { + return 0; + } + cm->vattr[attr].count = cm->nverts * nelem; + + 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); + + cm->vattr[attr].data_valid = 1; +#endif + } + 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; ivattr[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 + */ +unsigned int *cmesh_set_index(struct cmesh *cm, int num, const unsigned int *indices) +{ + unsigned int *tmp; + int nidx = cm->nfaces * 3; + + if(nidx && num != nidx) { + return 0; + } + + if(!(tmp = malloc(num * sizeof *tmp))) { + return 0; + } + if(indices) { + memcpy(tmp, indices, num * sizeof *tmp); + } + + free(cm->idata); + cm->idata = tmp; + cm->icount = num; + cm->nfaces = num / 3; + cm->idata_valid = 1; + cm->ibo_valid = 0; + return tmp; +} + +unsigned int *cmesh_index(struct cmesh *cm) +{ + cm->ibo_valid = 0; + return (unsigned int*)cmesh_index_ro(cm); +} + +const unsigned int *cmesh_index_ro(struct cmesh *cm) +{ + int nidx; + unsigned int *tmp; + + if(!cm->idata_valid) { +#if GL_ES_VERSION_2_0 + return 0; +#else + if(!cm->ibo_valid) { + return 0; + } + + /* local copy is unavailable, grab the data from the ibo */ + nidx = cm->nfaces * 3; + if(!(tmp = malloc(nidx * sizeof *cm->idata))) { + return 0; + } + 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); + memcpy(cm->idata, tmp, nidx * sizeof *cm->idata); + glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER); + + cm->idata_valid = 1; +#endif + } + return cm->idata; +} + +int cmesh_index_count(struct cmesh *cm) +{ + return cm->nfaces * 3; +} + +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; + } + if(cm->nverts) { + return cm->nverts / 3; + } + return 0; +} + +/* attr can be -1 to invalidate all attributes */ +void cmesh_invalidate_vbo(struct cmesh *cm, int attr) +{ + int i; + + if(attr >= CMESH_NUM_ATTR) { + return; + } + + if(attr < 0) { + for(i=0; ivattr[i].vbo_valid = 0; + } + } else { + cm->vattr[attr].vbo_valid = 0; + } +} + +void cmesh_invalidate_index(struct cmesh *cm) +{ + cm->ibo_valid = 0; +} + +int cmesh_append(struct cmesh *cmdest, struct cmesh *cmsrc) +{ + int i, nelem, newsz, origsz, srcsz; + float *vptr; + unsigned int *iptr; + unsigned int idxoffs; + + if(!cmdest->nverts) { + return cmesh_clone(cmdest, cmsrc); + } + + for(i=0; ivattr[i].nelem == cmsrc->vattr[i].nelem); + nelem = cmdest->vattr[i].nelem; + origsz = cmdest->nverts * nelem; + newsz = cmdest->nverts + cmsrc->nverts * nelem; + + 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; + } + } + + if(cmesh_indexed(cmdest)) { + assert(cmesh_indexed(cmsrc)); + /* force validation ... */ + cmesh_index(cmdest); + cmesh_index_ro(cmsrc); + + idxoffs = cmdest->nverts; + origsz = cmdest->icount; + srcsz = cmsrc->icount; + newsz = origsz + srcsz; + + 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; + for(i=0; iidata[i] + idxoffs; + } + } + + cmdest->wire_ibo_valid = 0; + cmdest->aabb_valid = 0; + cmdest->bsph_valid = 0; + return 0; +} + +void cmesh_clear_submeshes(struct cmesh *cm) +{ + struct submesh *sm; + + while(cm->sublist) { + sm = cm->sublist; + cm->sublist = cm->sublist->next; + free(sm->name); + free(sm); + } + cm->subcount = 0; +} + +int cmesh_submesh(struct cmesh *cm, const char *name, int fstart, int fcount) +{ + int i; + unsigned int minv = UINT_MAX, maxv = 0; + unsigned int *iptr; + struct submesh *sm; + + if(fstart < 0 || fcount < 1 || fstart + fcount > cm->nfaces) { + return -1; + } + + if(!(sm = malloc(sizeof *sm)) || !(sm->name = malloc(strlen(name) + 1))) { + free(sm); + return -1; + } + strcpy(sm->name, name); + sm->nfaces = fcount; + + if(cmesh_indexed(cm)) { + sm->istart = fstart * 3; + sm->icount = fcount * 3; + + /* find out which vertices are used by this submesh */ + iptr = cm->idata + sm->istart; + for(i=0; iicount; i++) { + unsigned int vidx = *iptr++; + if(vidx < minv) minv = vidx; + if(vidx > maxv) maxv = vidx; + } + sm->vstart = minv; + sm->vcount = maxv - minv + 1; + } else { + sm->istart = sm->icount = 0; + sm->vstart = fstart * 3; + sm->vcount = fcount * 3; + } + + sm->next = cm->sublist; + cm->sublist = sm; + cm->subcount++; + return 0; +} + +int cmesh_remove_submesh(struct cmesh *cm, int idx) +{ + struct submesh dummy; + struct submesh *prev, *sm; + + if(idx >= cm->subcount) { + return -1; + } + + dummy.next = cm->sublist; + prev = &dummy; + + while(prev->next && idx-- > 0) { + prev = prev->next; + } + + if(!(sm = prev->next)) return -1; + + prev->next = sm->next; + free(sm->name); + free(sm); + + cm->subcount--; + assert(cm->subcount >= 0); + + cm->sublist = dummy.next; + return 0; +} + +int cmesh_find_submesh(struct cmesh *cm, const char *name) +{ + int idx = 0; + struct submesh *sm = cm->sublist; + while(sm) { + if(strcmp(sm->name, name) == 0) { + assert(idx <= cm->subcount); + return idx; + } + idx++; + sm = sm->next; + } + return -1; +} + +int cmesh_submesh_count(struct cmesh *cm) +{ + return cm->subcount; +} + +static struct submesh *get_submesh(struct cmesh *m, int idx) +{ + struct submesh *sm = m->sublist; + while(sm && --idx >= 0) { + sm = sm->next; + } + return sm; +} + +int cmesh_clone_submesh(struct cmesh *cmdest, struct cmesh *cm, int subidx) +{ + struct submesh *sub; + + if(!(sub = get_submesh(cm, subidx))) { + return -1; + } + return clone(cmdest, cm, sub); +} + + +/* assemble a complete vertex by adding all the useful attributes */ +int cmesh_vertex(struct cmesh *cm, float x, float y, float z) +{ + int i, j; + + cgm_wcons(cm->cur_val + CMESH_ATTR_VERTEX, x, y, z, 1.0f); + cm->vattr[CMESH_ATTR_VERTEX].data_valid = 1; + cm->vattr[CMESH_ATTR_VERTEX].nelem = 3; + + for(i=0; ivattr[i].data_valid) { + 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; jvattr[i].nelem; j++) { + *tmp++ = *(&cm->cur_val[i].x + j); + } + } + cm->vattr[i].vbo_valid = 0; + cm->vattr[i].data_valid = 1; + } + + if(cm->idata_valid) { + free(cm->idata); + cm->idata = 0; + cm->icount = 0; + } + cm->ibo_valid = cm->idata_valid = 0; + return 0; +} + +void cmesh_normal(struct cmesh *cm, float nx, float ny, float nz) +{ + cgm_wcons(cm->cur_val + CMESH_ATTR_NORMAL, nx, ny, nz, 1.0f); + cm->vattr[CMESH_ATTR_NORMAL].nelem = 3; +} + +void cmesh_tangent(struct cmesh *cm, float tx, float ty, float tz) +{ + cgm_wcons(cm->cur_val + CMESH_ATTR_TANGENT, tx, ty, tz, 1.0f); + cm->vattr[CMESH_ATTR_TANGENT].nelem = 3; +} + +void cmesh_texcoord(struct cmesh *cm, float u, float v, float w) +{ + cgm_wcons(cm->cur_val + CMESH_ATTR_TEXCOORD, u, v, w, 1.0f); + cm->vattr[CMESH_ATTR_TEXCOORD].nelem = 3; +} + +void cmesh_boneweights(struct cmesh *cm, float w1, float w2, float w3, float w4) +{ + cgm_wcons(cm->cur_val + CMESH_ATTR_BONEWEIGHTS, w1, w2, w3, w4); + cm->vattr[CMESH_ATTR_BONEWEIGHTS].nelem = 4; +} + +void cmesh_boneidx(struct cmesh *cm, int idx1, int idx2, int idx3, int idx4) +{ + cgm_wcons(cm->cur_val + CMESH_ATTR_BONEIDX, idx1, idx2, idx3, idx4); + 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; ivattr[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; ivattr[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) +{ + unsigned int i; + int j; + cgm_vec4 v; + cgm_vec3 n, t; + float *vptr; + + for(i=0; inverts; i++) { + if(!(vptr = get_vec4(cm, CMESH_ATTR_VERTEX, i, &v))) { + return; + } + cgm_wmul_m4v4(&v, xform); + for(j=0; jvattr[CMESH_ATTR_VERTEX].nelem; j++) { + *vptr++ = (&v.x)[j]; + } + + 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; jvattr[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; jvattr[CMESH_ATTR_TANGENT].nelem; j++) { + *vptr++ = (&t.x)[j]; + } + } + } + } +} + +void cmesh_flip(struct cmesh *cm) +{ + cmesh_flip_faces(cm); + cmesh_flip_normals(cm); +} + +void cmesh_flip_faces(struct cmesh *cm) +{ + int i, j, idxnum, vnum, nelem; + unsigned int *indices; + float *verts, *vptr; + + if(cmesh_indexed(cm)) { + if(!(indices = cmesh_index(cm))) { + return; + } + idxnum = cmesh_index_count(cm); + for(i=0; ivattr[CMESH_ATTR_VERTEX].nelem; + for(i=0; inverts * cm->vattr[CMESH_ATTR_NORMAL].nelem; + for(i=0; ivattr[i].nelem * sizeof(float)))) { + return -1; + } + dstptr = tmpbuf; + + for(j=0; jvattr[i].nelem; + + for(k=0; kvattr[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= 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); +} + +void cmesh_draw_range(struct cmesh *cm, int start, int count) +{ + 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, count, GL_UNSIGNED_INT, (void*)(intptr_t)(start * 4)); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); + } else { + glDrawArrays(GL_TRIANGLES, start, count); + } + + post_draw(cm, cur_sdr); +} + +void cmesh_draw_submesh(struct cmesh *cm, int subidx) +{ + struct submesh *sm = cm->sublist; + + while(sm && subidx-- > 0) { + sm = sm->next; + } + if(!sm) return; + + if(sm->icount) { + cmesh_draw_range(cm, sm->istart, sm->icount); + } else { + cmesh_draw_range(cm, sm->vstart, sm->vcount); + } +} + +static void post_draw(struct cmesh *cm, int cur_sdr) +{ + int i; + + if(cur_sdr && use_custom_sdr_attr) { + for(i=0; i= 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; inverts; 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; inverts; 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; ivattr[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); + } +} + +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; iwire_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; + } + + 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; inverts; 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; inverts; 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; inverts; 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) +{ + 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; inverts; i++) { + fprintf(fp, "%5u:", i); + for(j=0; jvattr[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; ivattr[CMESH_ATTR_VERTEX].nelem; + if((num = cm->vattr[CMESH_ATTR_VERTEX].count) != cm->nverts * nelem) { + fprintf(stderr, "vertex array size (%d) != nverts (%d)\n", num, cm->nverts); + } + for(i=0; inverts; 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) { + fprintf(stderr, "normal array size (%d) != nverts (%d)\n", num, cm->nverts); + } + for(i=0; inverts; 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) { + fprintf(stderr, "texcoord array size (%d) != nverts (%d)\n", num, cm->nverts); + } + for(i=0; inverts; 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; inverts / 3; + unsigned int idx = 1 + voffs; + for(i=0; i +#include "cgmath/cgmath.h" + +enum { + CMESH_ATTR_VERTEX, + CMESH_ATTR_NORMAL, + CMESH_ATTR_TANGENT, + CMESH_ATTR_TEXCOORD, + CMESH_ATTR_COLOR, + CMESH_ATTR_BONEWEIGHTS, + CMESH_ATTR_BONEIDX, + CMESH_ATTR_TEXCOORD2, + + CMESH_NUM_ATTR +}; + +struct cmesh; + +/* global state */ +void cmesh_set_attrib_sdrloc(int attr, int loc); +int cmesh_get_attrib_sdrloc(int attr); +void cmesh_clear_attrib_sdrloc(void); + +/* mesh functions */ +struct cmesh *cmesh_alloc(void); +void cmesh_free(struct cmesh *cm); + +int cmesh_init(struct cmesh *cm); +void cmesh_destroy(struct cmesh *cm); + +void cmesh_clear(struct cmesh *cm); +int cmesh_clone(struct cmesh *cmdest, struct cmesh *cmsrc); + +int cmesh_set_name(struct cmesh *cm, const char *name); +const char *cmesh_name(struct cmesh *cm); + +int cmesh_has_attrib(struct cmesh *cm, int attr); +int cmesh_indexed(struct cmesh *cm); + +/* vdata can be 0, in which case only memory is allocated + * returns pointer to the attribute array + */ +float *cmesh_set_attrib(struct cmesh *cm, int attr, int nelem, unsigned int num, + const float *vdata); +float *cmesh_attrib(struct cmesh *cm, int attr); /* invalidates VBO */ +const float *cmesh_attrib_ro(struct cmesh *cm, int attr); /* doesn't invalidate */ +float *cmesh_attrib_at(struct cmesh *cm, int attr, int idx); +const float *cmesh_attrib_at_ro(struct cmesh *cm, int attr, int idx); +int cmesh_attrib_count(struct cmesh *cm, int attr); +int cmesh_push_attrib(struct cmesh *cm, int attr, float *v); +int cmesh_push_attrib1f(struct cmesh *cm, int attr, float x); +int cmesh_push_attrib2f(struct cmesh *cm, int attr, float x, float y); +int cmesh_push_attrib3f(struct cmesh *cm, int attr, float x, float y, float z); +int cmesh_push_attrib4f(struct cmesh *cm, int attr, float x, float y, float z, float w); + +/* indices can be 0, in which case only memory is allocated + * returns pointer to the index array + */ +unsigned int *cmesh_set_index(struct cmesh *cm, int num, const unsigned int *indices); +unsigned int *cmesh_index(struct cmesh *cm); /* invalidates IBO */ +const unsigned int *cmesh_index_ro(struct cmesh *cm); /* doesn't invalidate */ +int cmesh_index_count(struct cmesh *cm); +int cmesh_push_index(struct cmesh *cm, unsigned int idx); + +int cmesh_poly_count(struct cmesh *cm); + +/* attr can be -1 to invalidate all attributes */ +void cmesh_invalidate_vbo(struct cmesh *cm, int attr); +void cmesh_invalidate_ibo(struct cmesh *cm); + +int cmesh_append(struct cmesh *cmdest, struct cmesh *cmsrc); + +/* submeshes */ +void cmesh_clear_submeshes(struct cmesh *cm); +/* a submesh is defined as a consecutive range of faces */ +int cmesh_submesh(struct cmesh *cm, const char *name, int fstart, int fcount); +int cmesh_remove_submesh(struct cmesh *cm, int idx); +int cmesh_find_submesh(struct cmesh *cm, const char *name); +int cmesh_submesh_count(struct cmesh *cm); +int cmesh_clone_submesh(struct cmesh *cmdest, struct cmesh *cm, int subidx); + +/* immediate-mode style mesh construction interface */ +int cmesh_vertex(struct cmesh *cm, float x, float y, float z); +void cmesh_normal(struct cmesh *cm, float nx, float ny, float nz); +void cmesh_tangent(struct cmesh *cm, float tx, float ty, float tz); +void cmesh_texcoord(struct cmesh *cm, float u, float v, float w); +void cmesh_boneweights(struct cmesh *cm, float w1, float w2, float w3, float w4); +void cmesh_boneidx(struct cmesh *cm, int idx1, int idx2, int idx3, int idx4); + +/* 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_flip(struct cmesh *cm); /* flip faces (winding) and normals */ +void cmesh_flip_faces(struct cmesh *cm); +void cmesh_flip_normals(struct cmesh *cm); + +int cmesh_explode(struct cmesh *cm); /* undo all vertex sharing */ + +/* this is only guaranteed to work on an exploded mesh */ +void cmesh_calc_face_normals(struct cmesh *cm); + +void cmesh_draw(struct cmesh *cm); +void cmesh_draw_range(struct cmesh *cm, int start, int count); +void cmesh_draw_submesh(struct cmesh *cm, int subidx); /* XXX only for indexed meshes currently */ +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); + +/* 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); + +/* 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); + +/* texture coordinate manipulation */ +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); + +/* FILE I/O */ +int cmesh_load(struct cmesh *cm, const char *fname); + +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); + + + +#endif /* CMESH_H_ */ diff --git a/src/darray.c b/src/darray.c new file mode 100644 index 0000000..5abbf66 --- /dev/null +++ b/src/darray.c @@ -0,0 +1,121 @@ +#include +#include +#include +#include "darray.h" +#include "util.h" + +/* The array descriptor keeps auxilliary information needed to manipulate + * the dynamic array. It's allocated adjacent to the array buffer. + */ +struct arrdesc { + int nelem, szelem; + int max_elem; + int bufsz; /* not including the descriptor */ +}; + +#define DESC(x) ((struct arrdesc*)((char*)(x) - sizeof(struct arrdesc))) + +void *darr_alloc(int elem, int szelem) +{ + struct arrdesc *desc; + + desc = malloc_nf(elem * szelem + sizeof *desc); + desc->nelem = desc->max_elem = elem; + desc->szelem = szelem; + desc->bufsz = elem * szelem; + return (char*)desc + sizeof *desc; +} + +void darr_free(void *da) +{ + if(da) { + free(DESC(da)); + } +} + +void *darr_resize_impl(void *da, int elem) +{ + int newsz; + struct arrdesc *desc; + + if(!da) return 0; + desc = DESC(da); + + newsz = desc->szelem * elem; + desc = realloc_nf(desc, newsz + sizeof *desc); + + desc->nelem = desc->max_elem = elem; + desc->bufsz = newsz; + return (char*)desc + sizeof *desc; +} + +int darr_empty(void *da) +{ + return DESC(da)->nelem ? 0 : 1; +} + +int darr_size(void *da) +{ + return DESC(da)->nelem; +} + + +void *darr_clear_impl(void *da) +{ + return darr_resize_impl(da, 0); +} + +/* stack semantics */ +void *darr_push_impl(void *da, void *item) +{ + struct arrdesc *desc; + int nelem; + + desc = DESC(da); + nelem = desc->nelem; + + if(nelem >= desc->max_elem) { + /* need to resize */ + int newsz = desc->max_elem ? desc->max_elem * 2 : 1; + + da = darr_resize_impl(da, newsz); + desc = DESC(da); + desc->nelem = nelem; + } + + if(item) { + memcpy((char*)da + desc->nelem * desc->szelem, item, desc->szelem); + } + desc->nelem++; + return da; +} + +void *darr_pop_impl(void *da) +{ + struct arrdesc *desc; + int nelem; + + desc = DESC(da); + nelem = desc->nelem; + + if(!nelem) return da; + + if(nelem <= desc->max_elem / 3) { + /* reclaim space */ + int newsz = desc->max_elem / 2; + + da = darr_resize_impl(da, newsz); + desc = DESC(da); + desc->nelem = nelem; + } + desc->nelem--; + + return da; +} + +void *darr_finalize(void *da) +{ + struct arrdesc *desc = DESC(da); + memmove(desc, da, desc->bufsz); + return desc; +} diff --git a/src/darray.h b/src/darray.h new file mode 100644 index 0000000..154672c --- /dev/null +++ b/src/darray.h @@ -0,0 +1,50 @@ +#ifndef DYNAMIC_ARRAY_H_ +#define DYNAMIC_ARRAY_H_ + +void *darr_alloc(int elem, int szelem); +void darr_free(void *da); +void *darr_resize_impl(void *da, int elem); +#define darr_resize(da, elem) do { (da) = darr_resize_impl(da, elem); } while(0) + +int darr_empty(void *da); +int darr_size(void *da); + +void *darr_clear_impl(void *da); +#define darr_clear(da) do { (da) = darr_clear_impl(da); } while(0) + +/* stack semantics */ +void *darr_push_impl(void *da, void *item); +#define darr_push(da, item) do { (da) = darr_push_impl(da, item); } while(0) +#define darr_pushi(da, val) do { int v = val; (da) = darr_push_impl(da, &v); } while(0) +#define darr_pushf(da, val) do { float v = val; (da) = darr_push_impl(da, &v); } while(0) +void *darr_pop_impl(void *da); +#define darr_pop(da) do { (da) = darr_pop_impl(da); } while(0) + +/* Finalize the array. No more resizing is possible after this call. + * Use free() instead of dynarr_free() to deallocate a finalized array. + * Returns pointer to the finalized array. + * Complexity: O(n) + */ +void *darr_finalize(void *da); + +/* utility macros to push characters to a string. assumes and maintains + * the invariant that the last element is always a zero + */ +#define darr_strpush(da, c) \ + do { \ + char cnull = 0, ch = (char)(c); \ + (da) = dynarr_pop_impl(da); \ + (da) = dynarr_push_impl((da), &ch); \ + (da) = dynarr_push_impl((da), &cnull); \ + } while(0) + +#define darr_strpop(da) \ + do { \ + char cnull = 0; \ + (da) = dynarr_pop_impl(da); \ + (da) = dynarr_pop_impl(da); \ + (da) = dynarr_push_impl((da), &cnull); \ + } while(0) + + +#endif /* DYNAMIC_ARRAY_H_ */ diff --git a/src/dynarr.c b/src/dynarr.c new file mode 100644 index 0000000..59bbf8c --- /dev/null +++ b/src/dynarr.c @@ -0,0 +1,141 @@ +/* dynarr - dynamic resizable C array data structure + * author: John Tsiombikas + * license: public domain + */ +#include +#include +#include +#include "dynarr.h" + +/* The array descriptor keeps auxilliary information needed to manipulate + * the dynamic array. It's allocated adjacent to the array buffer. + */ +struct arrdesc { + int nelem, szelem; + int max_elem; + int bufsz; /* not including the descriptor */ +}; + +#define DESC(x) ((struct arrdesc*)((char*)(x) - sizeof(struct arrdesc))) + +void *dynarr_alloc(int elem, int szelem) +{ + struct arrdesc *desc; + + if(!(desc = malloc(elem * szelem + sizeof *desc))) { + return 0; + } + desc->nelem = desc->max_elem = elem; + desc->szelem = szelem; + desc->bufsz = elem * szelem; + return (char*)desc + sizeof *desc; +} + +void dynarr_free(void *da) +{ + if(da) { + free(DESC(da)); + } +} + +void *dynarr_resize(void *da, int elem) +{ + int newsz; + void *tmp; + struct arrdesc *desc; + + if(!da) return 0; + desc = DESC(da); + + newsz = desc->szelem * elem; + + if(!(tmp = realloc(desc, newsz + sizeof *desc))) { + return 0; + } + desc = tmp; + + desc->nelem = desc->max_elem = elem; + desc->bufsz = newsz; + return (char*)desc + sizeof *desc; +} + +int dynarr_empty(void *da) +{ + return DESC(da)->nelem ? 0 : 1; +} + +int dynarr_size(void *da) +{ + return DESC(da)->nelem; +} + + +void *dynarr_clear(void *da) +{ + return dynarr_resize(da, 0); +} + +/* stack semantics */ +void *dynarr_push(void *da, void *item) +{ + struct arrdesc *desc; + int nelem; + + desc = DESC(da); + nelem = desc->nelem; + + if(nelem >= desc->max_elem) { + /* need to resize */ + struct arrdesc *tmp; + int newsz = desc->max_elem ? desc->max_elem * 2 : 1; + + if(!(tmp = dynarr_resize(da, newsz))) { + fprintf(stderr, "failed to resize\n"); + return da; + } + da = tmp; + desc = DESC(da); + desc->nelem = nelem; + } + + if(item) { + memcpy((char*)da + desc->nelem * desc->szelem, item, desc->szelem); + } + desc->nelem++; + return da; +} + +void *dynarr_pop(void *da) +{ + struct arrdesc *desc; + int nelem; + + desc = DESC(da); + nelem = desc->nelem; + + if(!nelem) return da; + + if(nelem <= desc->max_elem / 3) { + /* reclaim space */ + struct arrdesc *tmp; + int newsz = desc->max_elem / 2; + + if(!(tmp = dynarr_resize(da, newsz))) { + fprintf(stderr, "failed to resize\n"); + return da; + } + da = tmp; + desc = DESC(da); + desc->nelem = nelem; + } + desc->nelem--; + + return da; +} + +void *dynarr_finalize(void *da) +{ + struct arrdesc *desc = DESC(da); + memmove(desc, da, desc->bufsz); + return desc; +} diff --git a/src/dynarr.h b/src/dynarr.h new file mode 100644 index 0000000..8690b5a --- /dev/null +++ b/src/dynarr.h @@ -0,0 +1,80 @@ +/* dynarr - dynamic resizable C array data structure + * author: John Tsiombikas + * license: public domain + */ +#ifndef DYNARR_H_ +#define DYNARR_H_ + +/* usage example: + * ------------- + * int *arr = dynarr_alloc(0, sizeof *arr); + * + * int x = 10; + * arr = dynarr_push(arr, &x); + * x = 5; + * arr = dynarr_push(arr, &x); + * x = 42; + * arr = dynarr_push(arr, &x); + * + * for(i=0; i +#include "meshgen.h" +#include "cmesh.h" +#include "darray.h" + +/* -------- sphere -------- */ + +#define SURAD(u) ((u) * 2.0 * M_PI) +#define SVRAD(v) ((v) * M_PI) + +static void sphvec(cgm_vec3 *v, float theta, float phi) +{ + v->x = sin(theta) * sin(phi); + v->y = cos(phi); + v->z = cos(theta) * sin(phi); +} + +void gen_sphere(struct cmesh *mesh, float rad, int usub, int vsub, float urange, float vrange) +{ + int i, j, uverts, vverts, num_verts, num_quads, num_tri, idx; + unsigned int *idxarr; + float u, v, du, dv, phi, theta; + cgm_vec3 *varr, *narr, *tarr, pos, v0, v1; + cgm_vec2 *uvarr; + + if(urange == 0.0f || vrange == 0.0f) return; + + if(usub < 4) usub = 4; + if(vsub < 2) vsub = 2; + + uverts = usub + 1; + vverts = vsub + 1; + + num_verts = uverts * vverts; + num_quads = usub * vsub; + num_tri = num_quads * 2; + + cmesh_clear(mesh); + varr = (cgm_vec3*)cmesh_set_attrib(mesh, CMESH_ATTR_VERTEX, 3, num_verts, 0); + narr = (cgm_vec3*)cmesh_set_attrib(mesh, CMESH_ATTR_NORMAL, 3, num_verts, 0); + tarr = (cgm_vec3*)cmesh_set_attrib(mesh, CMESH_ATTR_TANGENT, 3, num_verts, 0); + uvarr = (cgm_vec2*)cmesh_set_attrib(mesh, CMESH_ATTR_TEXCOORD2, 2, num_verts, 0); + idxarr = (unsigned int*)cmesh_set_index(mesh, num_tri * 3, 0); + + du = urange / (float)(uverts - 1); + dv = vrange / (float)(vverts - 1); + + u = 0.0; + for(i=0; ix = u / urange; + uvarr->y = v / vrange; + uvarr++; + + if(i < usub && j < vsub) { + idx = i * vverts + j; + *idxarr++ = idx; + *idxarr++ = idx + 1; + *idxarr++ = idx + vverts + 1; + + *idxarr++ = idx; + *idxarr++ = idx + vverts + 1; + *idxarr++ = idx + vverts; + } + + v += dv; + } + u += du; + } +} + +/* ------ geosphere ------ */ +#define PHI 1.618034 + +static cgm_vec3 icosa_pt[] = { + {PHI, 1, 0}, + {-PHI, 1, 0}, + {PHI, -1, 0}, + {-PHI, -1, 0}, + {1, 0, PHI}, + {1, 0, -PHI}, + {-1, 0, PHI}, + {-1, 0, -PHI}, + {0, PHI, 1}, + {0, -PHI, 1}, + {0, PHI, -1}, + {0, -PHI, -1} +}; +enum { P11, P12, P13, P14, P21, P22, P23, P24, P31, P32, P33, P34 }; +static int icosa_idx[] = { + P11, P31, P21, + P11, P22, P33, + P13, P21, P32, + P13, P34, P22, + P12, P23, P31, + P12, P33, P24, + P14, P32, P23, + P14, P24, P34, + + P11, P33, P31, + P12, P31, P33, + P13, P32, P34, + P14, P34, P32, + + P21, P13, P11, + P22, P11, P13, + P23, P12, P14, + P24, P14, P12, + + P31, P23, P21, + P32, P21, P23, + P33, P22, P24, + P34, P24, P22 +}; + +static void geosphere(cgm_vec3 *verts, cgm_vec3 *v1, cgm_vec3 *v2, cgm_vec3 *v3, int iter) +{ + cgm_vec3 v12, v23, v31; + + if(!iter) { + darr_push(verts, v1); + darr_push(verts, v2); + darr_push(verts, v3); + return; + } + + v12 = *v1; + cgm_vadd(&v12, v2); + cgm_vnormalize(&v12); + v23 = *v2; + cgm_vadd(&v23, v3); + cgm_vnormalize(&v23); + v31 = *v3; + cgm_vadd(&v31, v1); + cgm_vnormalize(&v31); + + geosphere(verts, v1, &v12, &v31, iter - 1); + geosphere(verts, v2, &v23, &v12, iter - 1); + geosphere(verts, v3, &v31, &v23, iter - 1); + geosphere(verts, &v12, &v23, &v31, iter - 1); +} + +void gen_geosphere(struct cmesh *mesh, float rad, int subdiv, int hemi) +{ + int i, j, num_verts, num_tri, vidx; + cgm_vec3 v[3], *verts; + cgm_vec3 *varr, *narr, *tarr, v0, v1; + cgm_vec2 *uvarr; + float theta, phi; + + num_tri = (sizeof icosa_idx / sizeof *icosa_idx) / 3; + + verts = darr_alloc(0, sizeof *verts); + for(i=0; ix = 0.5 * theta / M_PI + 0.5; + uvarr->y = phi / M_PI; + uvarr++; + } +} + +/* -------- torus ----------- */ +static void torusvec(cgm_vec3 *v, float theta, float phi, float mr, float rr) +{ + float rx, ry, rz; + + theta = -theta; + + rx = -cos(phi) * rr + mr; + ry = sin(phi) * rr; + rz = 0.0; + + v->x = rx * sin(theta) + rz * cos(theta); + v->y = ry; + v->z = -rx * cos(theta) + rz * sin(theta); +} + +void gen_torus(struct cmesh *mesh, float mainrad, float ringrad, int usub, int vsub, float urange, float vrange) +{ + int i, j, uverts, vverts, num_verts, num_quads, num_tri, idx; + unsigned int *idxarr; + cgm_vec3 *varr, *narr, *tarr, vprev, pos, cent; + cgm_vec2 *uvarr; + float u, v, du, dv, theta, phi; + + if(usub < 4) usub = 4; + if(vsub < 2) vsub = 2; + + uverts = usub + 1; + vverts = vsub + 1; + + num_verts = uverts * vverts; + num_quads = usub * vsub; + num_tri = num_quads * 2; + + cmesh_clear(mesh); + varr = (cgm_vec3*)cmesh_set_attrib(mesh, CMESH_ATTR_VERTEX, 3, num_verts, 0); + narr = (cgm_vec3*)cmesh_set_attrib(mesh, CMESH_ATTR_NORMAL, 3, num_verts, 0); + tarr = (cgm_vec3*)cmesh_set_attrib(mesh, CMESH_ATTR_TANGENT, 3, num_verts, 0); + uvarr = (cgm_vec2*)cmesh_set_attrib(mesh, CMESH_ATTR_TEXCOORD, 2, num_verts, 0); + idxarr = (unsigned int*)cmesh_set_index(mesh, num_tri * 3, 0); + + du = urange / (float)(uverts - 1); + dv = vrange / (float)(vverts - 1); + + u = 0.0; + for(i=0; ix = u * urange; + uvarr->y = v * vrange; + uvarr++; + + if(i < usub && j < vsub) { + idx = i * vverts + j; + *idxarr++ = idx; + *idxarr++ = idx + 1; + *idxarr++ = idx + vverts + 1; + + *idxarr++ = idx; + *idxarr++ = idx + vverts + 1; + *idxarr++ = idx + vverts; + } + + v += dv; + } + u += du; + } +} + +/* -------- cylinder -------- */ + +static void cylvec(cgm_vec3 *v, float theta, float height) +{ + v->x = sin(theta); + v->y = height; + v->z = cos(theta); +} + +void gen_cylinder(struct cmesh *mesh, float rad, float height, int usub, int vsub, int capsub, float urange, float vrange) +{ + int i, j, uverts, vverts, num_body_verts, num_body_quads, num_body_tri, idx; + int capvverts, num_cap_verts, num_cap_quads, num_cap_tri, num_verts, num_tri; + cgm_vec3 *varr, *narr, *tarr, pos, vprev, tang; + cgm_vec2 *uvarr; + float y, u, v, du, dv, theta, r; + unsigned int *idxarr, vidx[4]; + + if(usub < 4) usub = 4; + if(vsub < 1) vsub = 1; + + uverts = usub + 1; + vverts = vsub + 1; + + num_body_verts = uverts * vverts; + num_body_quads = usub * vsub; + num_body_tri = num_body_quads * 2; + + capvverts = capsub ? capsub + 1 : 0; + num_cap_verts = uverts * capvverts; + num_cap_quads = usub * capsub; + num_cap_tri = num_cap_quads * 2; + + num_verts = num_body_verts + num_cap_verts * 2; + num_tri = num_body_tri + num_cap_tri * 2; + + cmesh_clear(mesh); + varr = (cgm_vec3*)cmesh_set_attrib(mesh, CMESH_ATTR_VERTEX, 3, num_verts, 0); + narr = (cgm_vec3*)cmesh_set_attrib(mesh, CMESH_ATTR_NORMAL, 3, num_verts, 0); + tarr = (cgm_vec3*)cmesh_set_attrib(mesh, CMESH_ATTR_TANGENT, 3, num_verts, 0); + uvarr = (cgm_vec2*)cmesh_set_attrib(mesh, CMESH_ATTR_TEXCOORD, 2, num_verts, 0); + idxarr = (unsigned int*)cmesh_set_index(mesh, num_tri * 3, 0); + + du = urange / (float)(uverts - 1); + dv = vrange / (float)(vverts - 1); + + u = 0.0f; + for(i=0; ix = u * urange; + uvarr->y = v * vrange; + uvarr++; + + if(i < usub && j < vsub) { + idx = i * vverts + j; + + *idxarr++ = idx; + *idxarr++ = idx + vverts + 1; + *idxarr++ = idx + 1; + + *idxarr++ = idx; + *idxarr++ = idx + vverts; + *idxarr++ = idx + vverts + 1; + } + + v += dv; + } + u += du; + } + + + /* now the cap! */ + if(!capsub) { + return; + } + + dv = 1.0 / (float)(capvverts - 1); + + u = 0.0; + for(i=0; ix = u * urange; + uvarr->y = v; + uvarr++; + + pos.y = -height / 2.0; + *varr++ = pos; + cgm_vcons(narr++, 0, -1, 0); + cgm_vcons(tarr++, -tang.x, -tang.y, -tang.z); + uvarr->x = u * urange; + uvarr->y = v; + uvarr++; + + if(i < usub && j < capsub) { + idx = num_body_verts + (i * capvverts + j) * 2; + + vidx[0] = idx; + vidx[1] = idx + capvverts * 2; + vidx[2] = idx + (capvverts + 1) * 2; + vidx[3] = idx + 2; + + *idxarr++ = vidx[0]; + *idxarr++ = vidx[2]; + *idxarr++ = vidx[1]; + *idxarr++ = vidx[0]; + *idxarr++ = vidx[3]; + *idxarr++ = vidx[2]; + + *idxarr++ = vidx[0] + 1; + *idxarr++ = vidx[1] + 1; + *idxarr++ = vidx[2] + 1; + *idxarr++ = vidx[0] + 1; + *idxarr++ = vidx[2] + 1; + *idxarr++ = vidx[3] + 1; + } + + v += dv; + } + u += du; + } +} + +/* -------- cone -------- */ + +static void conevec(cgm_vec3 *v, float theta, float y, float height) +{ + float scale = 1.0f - y / height; + v->x = sin(theta) * scale; + v->y = y; + v->z = cos(theta) * scale; +} + +void gen_cone(struct cmesh *mesh, float rad, float height, int usub, int vsub, int capsub, float urange, float vrange) +{ + int i, j, uverts, vverts, num_body_verts, num_body_quads, num_body_tri, idx; + int capvverts, num_cap_verts, num_cap_quads, num_cap_tri, num_verts, num_tri; + cgm_vec3 *varr, *narr, *tarr, pos, vprev, tang, bitang; + cgm_vec2 *uvarr; + unsigned int *idxarr, vidx[4]; + float u, v, du, dv, theta, y, r; + + if(usub < 4) usub = 4; + if(vsub < 1) vsub = 1; + + uverts = usub + 1; + vverts = vsub + 1; + + num_body_verts = uverts * vverts; + num_body_quads = usub * vsub; + num_body_tri = num_body_quads * 2; + + capvverts = capsub ? capsub + 1 : 0; + num_cap_verts = uverts * capvverts; + num_cap_quads = usub * capsub; + num_cap_tri = num_cap_quads * 2; + + num_verts = num_body_verts + num_cap_verts; + num_tri = num_body_tri + num_cap_tri; + + cmesh_clear(mesh); + varr = (cgm_vec3*)cmesh_set_attrib(mesh, CMESH_ATTR_VERTEX, 3, num_verts, 0); + narr = (cgm_vec3*)cmesh_set_attrib(mesh, CMESH_ATTR_NORMAL, 3, num_verts, 0); + tarr = (cgm_vec3*)cmesh_set_attrib(mesh, CMESH_ATTR_TANGENT, 3, num_verts, 0); + uvarr = (cgm_vec2*)cmesh_set_attrib(mesh, CMESH_ATTR_TEXCOORD, 2, num_verts, 0); + idxarr = (unsigned int*)cmesh_set_index(mesh, num_tri * 3, 0); + + du = urange / (float)(uverts - 1); + dv = vrange / (float)(vverts - 1); + + u = 0.0; + for(i=0; ix = u * urange; + uvarr->y = v * vrange; + uvarr++; + + if(i < usub && j < vsub) { + idx = i * vverts + j; + + *idxarr++ = idx; + *idxarr++ = idx + vverts + 1; + *idxarr++ = idx + 1; + + *idxarr++ = idx; + *idxarr++ = idx + vverts; + *idxarr++ = idx + vverts + 1; + } + + v += dv; + } + u += du; + } + + + /* now the bottom cap! */ + if(!capsub) { + return; + } + + dv = 1.0 / (float)(capvverts - 1); + + u = 0.0; + for(i=0; ix = u * urange; + uvarr->y = v; + uvarr++; + + if(i < usub && j < capsub) { + idx = num_body_verts + i * capvverts + j; + + vidx[0] = idx; + vidx[1] = idx + capvverts; + vidx[2] = idx + (capvverts + 1); + vidx[3] = idx + 1; + + *idxarr++ = vidx[0]; + *idxarr++ = vidx[1]; + *idxarr++ = vidx[2]; + *idxarr++ = vidx[0]; + *idxarr++ = vidx[2]; + *idxarr++ = vidx[3]; + } + + v += dv; + } + u += du; + } +} + + +/* -------- plane -------- */ + +void gen_plane(struct cmesh *mesh, float width, float height, int usub, int vsub) +{ + gen_heightmap(mesh, width, height, usub, vsub, 0, 0); +} + + +/* ----- heightmap ------ */ + +void gen_heightmap(struct cmesh *mesh, float width, float height, int usub, int vsub, float (*hf)(float, float, void*), void *hfdata) +{ + int i, j, uverts, vverts, num_verts, num_quads, num_tri, idx; + cgm_vec3 *varr, *narr, *tarr, normal, tang, bitan; + cgm_vec2 *uvarr; + unsigned int *idxarr; + float u, v, du, dv, x, y, z, u1z, v1z; + + if(usub < 1) usub = 1; + if(vsub < 1) vsub = 1; + + cmesh_clear(mesh); + + uverts = usub + 1; + vverts = vsub + 1; + num_verts = uverts * vverts; + + num_quads = usub * vsub; + num_tri = num_quads * 2; + + varr = (cgm_vec3*)cmesh_set_attrib(mesh, CMESH_ATTR_VERTEX, 3, num_verts, 0); + narr = (cgm_vec3*)cmesh_set_attrib(mesh, CMESH_ATTR_NORMAL, 3, num_verts, 0); + tarr = (cgm_vec3*)cmesh_set_attrib(mesh, CMESH_ATTR_TANGENT, 3, num_verts, 0); + uvarr = (cgm_vec2*)cmesh_set_attrib(mesh, CMESH_ATTR_TEXCOORD, 2, num_verts, 0); + idxarr = (unsigned int*)cmesh_set_index(mesh, num_tri * 3, 0); + + du = 1.0f / (float)usub; + dv = 1.0f / (float)vsub; + + u = 0.0f; + for(i=0; ix = u; + uvarr->y = v; + uvarr++; + + if(i < usub && j < vsub) { + idx = i * vverts + j; + + *idxarr++ = idx; + *idxarr++ = idx + vverts + 1; + *idxarr++ = idx + 1; + + *idxarr++ = idx; + *idxarr++ = idx + vverts; + *idxarr++ = idx + vverts + 1; + } + + v += dv; + } + u += du; + } +} + +/* ----- box ------ */ +void gen_box(struct cmesh *mesh, float xsz, float ysz, float zsz, int usub, int vsub) +{ + static const float face_angles[][2] = { + {0, 0}, + {M_PI / 2.0, 0}, + {M_PI, 0}, + {3.0 * M_PI / 2.0, 0}, + {0, M_PI / 2.0}, + {0, -M_PI / 2.0} + }; + int i; + float xform[16], scale[16], idmat[16]; + struct cmesh *m; + + if(usub < 1) usub = 1; + if(vsub < 1) vsub = 1; + + cmesh_clear(mesh); + + for(i=0; i<6; i++) { + m = cmesh_alloc(); + gen_plane(m, 1, 1, usub, vsub); + cgm_mtranslation(xform, 0, 0, 0.5f); + cgm_mrotate_euler(xform, face_angles[i][1], face_angles[i][0], 0.0f, CGM_EULER_XYZ); + cmesh_apply_xform(m, xform, 0); + + cmesh_append(mesh, m); + cmesh_free(m); + } + + cgm_mscaling(scale, xsz, ysz, zsz); + cgm_midentity(idmat); + cmesh_apply_xform(mesh, scale, idmat); +} + + +static inline void rev_vert(cgm_vec3 *res, float u, float v, cgm_vec2 (*rf)(float, float, void*), void *cls) +{ + cgm_vec2 pos = rf(u, v, cls); + + float angle = u * 2.0 * M_PI; + res->x = pos.x * cos(angle); + res->y = pos.y; + res->z = pos.x * sin(angle); +} + +/* ------ surface of revolution ------- */ +void gen_revol(struct cmesh *mesh, int usub, int vsub, cgm_vec2 (*rfunc)(float, float, void*), + cgm_vec2 (*nfunc)(float, float, void*), void *cls) +{ + int i, j, uverts, vverts, num_verts, num_quads, num_tri, idx; + cgm_vec3 *varr, *narr, *tarr, pos, nextu, nextv, tang, normal, bitan; + cgm_vec2 *uvarr; + unsigned int *idxarr; + float u, v, du, dv, new_v; + + if(!rfunc) return; + if(usub < 3) usub = 3; + if(vsub < 1) vsub = 1; + + cmesh_clear(mesh); + + uverts = usub + 1; + vverts = vsub + 1; + num_verts = uverts * vverts; + + num_quads = usub * vsub; + num_tri = num_quads * 2; + + varr = (cgm_vec3*)cmesh_set_attrib(mesh, CMESH_ATTR_VERTEX, 3, num_verts, 0); + narr = (cgm_vec3*)cmesh_set_attrib(mesh, CMESH_ATTR_NORMAL, 3, num_verts, 0); + tarr = (cgm_vec3*)cmesh_set_attrib(mesh, CMESH_ATTR_TANGENT, 3, num_verts, 0); + uvarr = (cgm_vec2*)cmesh_set_attrib(mesh, CMESH_ATTR_TEXCOORD, 2, num_verts, 0); + idxarr = (unsigned int*)cmesh_set_index(mesh, num_tri * 3, 0); + + du = 1.0f / (float)(uverts - 1); + dv = 1.0f / (float)(vverts - 1); + + u = 0.0f; + for(i=0; i 0.5f ? v - dv * 0.25f : v + dv * 0.25f; + rev_vert(&nextu, fmod(u + du, 1.0f), new_v, rfunc, cls); + tang = nextu; + cgm_vsub(&tang, &pos); + } + + if(nfunc) { + rev_vert(&normal, u, v, nfunc, cls); + } else { + rev_vert(&nextv, u, v + dv, rfunc, cls); + bitan = nextv; + cgm_vsub(&bitan, &pos); + if(cgm_vlength_sq(&bitan) < 1e-6f) { + rev_vert(&nextv, u, v - dv, rfunc, cls); + bitan = pos; + cgm_vsub(&bitan, &nextv); + } + + cgm_vcross(&normal, &tang, &bitan); + } + cgm_vnormalize(&normal); + cgm_vnormalize(&tang); + + *varr++ = pos; + *narr++ = normal; + *tarr++ = tang; + uvarr->x = u; + uvarr->y = v; + uvarr++; + + if(i < usub && j < vsub) { + idx = i * vverts + j; + + *idxarr++ = idx; + *idxarr++ = idx + vverts + 1; + *idxarr++ = idx + 1; + + *idxarr++ = idx; + *idxarr++ = idx + vverts; + *idxarr++ = idx + vverts + 1; + } + + v += dv; + } + u += du; + } +} + +static inline void sweep_vert(cgm_vec3 *res, float u, float v, float height, + cgm_vec2 (*sf)(float, float, void*), void *cls) +{ + cgm_vec2 pos = sf(u, v, cls); + + res->x = pos.x; + res->y = v * height; + res->z = pos.y; +} + +/* ---- sweep shape along a path ---- */ +void gen_sweep(struct cmesh *mesh, float height, int usub, int vsub, + cgm_vec2 (*sfunc)(float, float, void*), void *cls) +{ + int i, j, uverts, vverts, num_verts, num_quads, num_tri, idx; + cgm_vec3 *varr, *narr, *tarr, pos, nextu, nextv, tang, bitan, normal; + cgm_vec2 *uvarr; + unsigned int *idxarr; + float u, v, du, dv, new_v; + + if(!sfunc) return; + if(usub < 3) usub = 3; + if(vsub < 1) vsub = 1; + + cmesh_clear(mesh); + + uverts = usub + 1; + vverts = vsub + 1; + num_verts = uverts * vverts; + + num_quads = usub * vsub; + num_tri = num_quads * 2; + + varr = (cgm_vec3*)cmesh_set_attrib(mesh, CMESH_ATTR_VERTEX, 3, num_verts, 0); + narr = (cgm_vec3*)cmesh_set_attrib(mesh, CMESH_ATTR_NORMAL, 3, num_verts, 0); + tarr = (cgm_vec3*)cmesh_set_attrib(mesh, CMESH_ATTR_TANGENT, 3, num_verts, 0); + uvarr = (cgm_vec2*)cmesh_set_attrib(mesh, CMESH_ATTR_TEXCOORD, 2, num_verts, 0); + idxarr = (unsigned int*)cmesh_set_index(mesh, num_tri * 3, 0); + + du = 1.0f / (float)(uverts - 1); + dv = 1.0f / (float)(vverts - 1); + + u = 0.0f; + for(i=0; i 0.5f ? v - dv * 0.25f : v + dv * 0.25f; + sweep_vert(&nextu, fmod(u + du, 1.0f), new_v, height, sfunc, cls); + tang = nextu; + cgm_vsub(&tang, &pos); + } + + sweep_vert(&nextv, u, v + dv, height, sfunc, cls); + bitan = nextv; + cgm_vsub(&bitan, &pos); + if(cgm_vlength_sq(&bitan) < 1e-6f) { + sweep_vert(&nextv, u, v - dv, height, sfunc, cls); + bitan = pos; + cgm_vsub(&bitan, &nextv); + } + + cgm_vcross(&normal, &tang, &bitan); + cgm_vnormalize(&normal); + cgm_vnormalize(&tang); + + *varr++ = pos; + *narr++ = normal; + *tarr++ = tang; + uvarr->x = u; + uvarr->y = v; + uvarr++; + + if(i < usub && j < vsub) { + idx = i * vverts + j; + + *idxarr++ = idx; + *idxarr++ = idx + vverts + 1; + *idxarr++ = idx + 1; + + *idxarr++ = idx; + *idxarr++ = idx + vverts; + *idxarr++ = idx + vverts + 1; + } + + v += dv; + } + u += du; + } +} diff --git a/src/meshgen.h b/src/meshgen.h new file mode 100644 index 0000000..f945462 --- /dev/null +++ b/src/meshgen.h @@ -0,0 +1,26 @@ +#ifndef CMESHGEN_H_ +#define CMESHGEN_H_ + +#include "cmesh.h" + +void gen_sphere(struct cmesh *mesh, float rad, int usub, int vsub, float urange, float vrange); +void gen_geosphere(struct cmesh *mesh, float rad, int subdiv, int hemi); +void gen_torus(struct cmesh *mesh, float mainrad, float ringrad, int usub, int vsub, + float urange, float vrange); +void gen_cylinder(struct cmesh *mesh, float rad, float height, int usub, int vsub, + int capsub, float urange, float vrange); +void gen_cone(struct cmesh *mesh, float rad, float height, int usub, int vsub, + int capsub, float urange, float vrange); +void gen_plane(struct cmesh *mesh, float width, float height, int usub, int vsub); +void gen_heightmap(struct cmesh *mesh, float width, float height, int usub, int vsub, + float (*hf)(float, float, void*), void *hfdata); +void gen_box(struct cmesh *mesh, float xsz, float ysz, float zsz, int usub, int vsub); + +void gen_revol(struct cmesh *mesh, int usub, int vsub, cgm_vec2 (*rfunc)(float, float, void*), + cgm_vec2 (*nfunc)(float, float, void*), void *cls); + +/* callback args: (float u, float v, void *cls) -> Vec2 XZ offset u,v in [0, 1] */ +void gen_sweep(struct cmesh *mesh, float height, int usub, int vsub, + cgm_vec2 (*sfunc)(float, float, void*), void *cls); + +#endif /* CMESHGEN_H_ */ diff --git a/src/meshload.c b/src/meshload.c new file mode 100644 index 0000000..1665c7c --- /dev/null +++ b/src/meshload.c @@ -0,0 +1,399 @@ +#include +#include +#include +#include +#include +#include "cmesh.h" + +#ifdef USE_ASSIMP +#include +#include +#include +#include +#include +#else +#include "dynarr.h" +#include "rbtree.h" +#endif + + +#ifdef USE_ASSIMP + +static int add_mesh(struct cmesh *mesh, struct aiMesh *aimesh); + +#define AIPPFLAGS \ + (aiProcess_JoinIdenticalVertices | aiProcess_PreTransformVertices | \ + aiProcess_Triangulate | aiProcess_SortByPType | aiProcess_FlipUVs) + +int cmesh_load(struct cmesh *mesh, const char *fname) +{ + int i; + const struct aiScene *aiscn; + + if(!(aiscn = aiImportFile(fname, AIPPFLAGS))) { + fprintf(stderr, "failed to open mesh file: %s\n", fname); + return -1; + } + + for(i=0; i<(int)aiscn->mNumMeshes; i++) { + add_mesh(mesh, aiscn->mMeshes[i]); + } + + aiReleaseImport(aiscn); + return 0; +} + +static int add_mesh(struct cmesh *mesh, struct aiMesh *aim) +{ + int i, j, voffs, foffs; + + voffs = cmesh_attrib_count(mesh, CMESH_ATTR_VERTEX); + foffs = cmesh_poly_count(mesh); + + for(i=0; imNumVertices; i++) { + struct aiVector3D *v = aim->mVertices + i; + cmesh_push_attrib3f(mesh, CMESH_ATTR_VERTEX, v->x, v->y, v->z); + + if(aim->mNormals) { + v = aim->mNormals + i; + cmesh_push_attrib3f(mesh, CMESH_ATTR_NORMAL, v->x, v->y, v->z); + } + if(aim->mTangents) { + v = aim->mTangents + i; + cmesh_push_attrib3f(mesh, CMESH_ATTR_TANGENT, v->x, v->y, v->z); + } + if(aim->mColors[0]) { + struct aiColor4D *col = aim->mColors[0] + i; + cmesh_push_attrib4f(mesh, CMESH_ATTR_COLOR, col->r, col->g, col->b, col->a); + } + if(aim->mTextureCoords[0]) { + v = aim->mTextureCoords[0] + i; + cmesh_push_attrib2f(mesh, CMESH_ATTR_TEXCOORD, v->x, v->y); + } + if(aim->mTextureCoords[1]) { + v = aim->mTextureCoords[1] + i; + cmesh_push_attrib2f(mesh, CMESH_ATTR_TEXCOORD2, v->x, v->y); + } + } + + if(aim->mFaces) { + for(i=0; imNumFaces; i++) { + assert(aim->mFaces[i].mNumIndices == 3); + for(j=0; j<3; j++) { + cmesh_push_index(mesh, aim->mFaces[i].mIndices[j] + voffs); + } + } + cmesh_submesh(mesh, aim->mName.data, foffs, aim->mNumFaces); + } + return 0; +} + +#else + +struct vertex_pos { + float x, y, z; +}; + +struct facevertex { + int vidx, tidx, nidx; +}; + +static char *clean_line(char *s); +static char *parse_face_vert(char *ptr, struct facevertex *fv, int numv, int numt, int numn); +static int cmp_facevert(const void *ap, const void *bp); +static void free_rbnode_key(struct rbnode *n, void *cls); + +/* merge of different indices per attribute happens during face processing. + * + * A triplet of (vertex index/texcoord index/normal index) is used as the key + * to search in a balanced binary search tree for vertex buffer index assigned + * to the same triplet if it has been encountered before. That index is + * appended to the index buffer. + * + * If a particular triplet has not been encountered before, a new vertex is + * appended to the vertex buffer. The index of this new vertex is appended to + * the index buffer, and also inserted into the tree for future searches. + */ +int cmesh_load(struct cmesh *mesh, const char *fname) +{ + int i, line_num = 0, result = -1; + int found_quad = 0; + FILE *fp = 0; + char buf[256]; + struct vertex_pos *varr = 0; + cgm_vec3 *narr = 0; + cgm_vec2 *tarr = 0; + struct rbtree *rbtree = 0; + char *subname = 0; + int substart = 0, subcount = 0; + + if(!(fp = fopen(fname, "rb"))) { + fprintf(stderr, "load_mesh: failed to open file: %s\n", fname); + goto err; + } + + if(!(rbtree = rb_create(cmp_facevert))) { + fprintf(stderr, "load_mesh: failed to create facevertex binary search tree\n"); + goto err; + } + rb_set_delete_func(rbtree, free_rbnode_key, 0); + + if(!(varr = dynarr_alloc(0, sizeof *varr)) || + !(narr = dynarr_alloc(0, sizeof *narr)) || + !(tarr = dynarr_alloc(0, sizeof *tarr))) { + fprintf(stderr, "load_mesh: failed to allocate resizable vertex array\n"); + goto err; + } + + while(fgets(buf, sizeof buf, fp)) { + char *line = clean_line(buf); + ++line_num; + + if(!*line) continue; + + switch(line[0]) { + case 'v': + if(isspace(line[1])) { + /* vertex */ + struct vertex_pos v; + int num; + + num = sscanf(line + 2, "%f %f %f", &v.x, &v.y, &v.z); + if(num < 3) { + fprintf(stderr, "%s:%d: invalid vertex definition: \"%s\"\n", fname, line_num, line); + goto err; + } + if(!(varr = dynarr_push(varr, &v))) { + fprintf(stderr, "load_mesh: failed to resize vertex buffer\n"); + goto err; + } + + } else if(line[1] == 't' && isspace(line[2])) { + /* texcoord */ + cgm_vec2 tc; + if(sscanf(line + 3, "%f %f", &tc.x, &tc.y) != 2) { + fprintf(stderr, "%s:%d: invalid texcoord definition: \"%s\"\n", fname, line_num, line); + goto err; + } + tc.y = 1.0f - tc.y; + if(!(tarr = dynarr_push(tarr, &tc))) { + fprintf(stderr, "load_mesh: failed to resize texcoord buffer\n"); + goto err; + } + + } else if(line[1] == 'n' && isspace(line[2])) { + /* normal */ + cgm_vec3 norm; + if(sscanf(line + 3, "%f %f %f", &norm.x, &norm.y, &norm.z) != 3) { + fprintf(stderr, "%s:%d: invalid normal definition: \"%s\"\n", fname, line_num, line); + goto err; + } + if(!(narr = dynarr_push(narr, &norm))) { + fprintf(stderr, "load_mesh: failed to resize normal buffer\n"); + goto err; + } + } + break; + + case 'f': + if(isspace(line[1])) { + /* face */ + char *ptr = line + 2; + struct facevertex fv; + struct rbnode *node; + int vsz = dynarr_size(varr); + int tsz = dynarr_size(tarr); + int nsz = dynarr_size(narr); + + for(i=0; i<4; i++) { + if(!(ptr = parse_face_vert(ptr, &fv, vsz, tsz, nsz))) { + if(i < 3 || found_quad) { + fprintf(stderr, "%s:%d: invalid face definition: \"%s\"\n", fname, line_num, line); + goto err; + } else { + break; + } + } + + if((node = rb_find(rbtree, &fv))) { + unsigned int idx = (intptr_t)node->data; + assert(idx < cmesh_attrib_count(mesh, CMESH_ATTR_VERTEX)); + if(cmesh_push_index(mesh, idx) == -1) { + fprintf(stderr, "load_mesh: failed to resize index array\n"); + goto err; + } + subcount++; /* inc number of submesh indices, in case we have submeshes */ + } else { + unsigned int newidx = cmesh_attrib_count(mesh, CMESH_ATTR_VERTEX); + struct facevertex *newfv; + struct vertex_pos *vptr = varr + fv.vidx; + + if(cmesh_push_attrib3f(mesh, CMESH_ATTR_VERTEX, vptr->x, vptr->y, vptr->z) == -1) { + fprintf(stderr, "load_mesh: failed to resize vertex array\n"); + goto err; + } + if(fv.nidx >= 0) { + float nx = narr[fv.nidx].x; + float ny = narr[fv.nidx].y; + float nz = narr[fv.nidx].z; + if(cmesh_push_attrib3f(mesh, CMESH_ATTR_NORMAL, nx, ny, nz) == -1) { + fprintf(stderr, "load_mesh: failed to resize normal array\n"); + goto err; + } + } + if(fv.tidx >= 0) { + float tu = tarr[fv.tidx].x; + float tv = tarr[fv.tidx].y; + if(cmesh_push_attrib2f(mesh, CMESH_ATTR_TEXCOORD, tu, tv) == -1) { + fprintf(stderr, "load_mesh: failed to resize texcoord array\n"); + goto err; + } + } + + if(cmesh_push_index(mesh, newidx) == -1) { + fprintf(stderr, "load_mesh: failed to resize index array\n"); + goto err; + } + subcount++; /* inc number of submesh indices, in case we have submeshes */ + + if((newfv = malloc(sizeof *newfv))) { + *newfv = fv; + } + if(!newfv || rb_insert(rbtree, newfv, (void*)(intptr_t)newidx) == -1) { + fprintf(stderr, "load_mesh: failed to insert facevertex to the binary search tree\n"); + goto err; + } + } + } + if(i > 3) found_quad = 1; + } + break; + + case 'o': + if(subcount > 0) { + printf("adding submesh: %s\n", subname); + cmesh_submesh(mesh, subname, substart / 3, subcount / 3); + } + free(subname); + if((subname = malloc(strlen(line)))) { + strcpy(subname, clean_line(line + 2)); + } + substart += subcount; + subcount = 0; + break; + + default: + break; + } + } + + if(subcount > 0) { + /* don't add the final submesh if we never found another. an obj file with a + * single 'o' for the whole list of faces, is a single mesh without submeshes + */ + if(cmesh_submesh_count(mesh) > 0) { + printf("adding submesh: %s\n", subname); + cmesh_submesh(mesh, subname, substart / 3, subcount / 3); + } else { + /* ... but use the 'o' name as the name of the mesh instead of the filename */ + if(subname && *subname) { + cmesh_set_name(mesh, subname); + } + } + } + + result = 0; /* success */ + + printf("loaded %s mesh: %s (%d submeshes): %d vertices, %d faces\n", + found_quad ? "quad" : "triangle", fname, cmesh_submesh_count(mesh), + cmesh_attrib_count(mesh, CMESH_ATTR_VERTEX), cmesh_poly_count(mesh)); + +err: + if(fp) fclose(fp); + dynarr_free(varr); + dynarr_free(narr); + dynarr_free(tarr); + rb_free(rbtree); + free(subname); + return result; +} + + +static char *clean_line(char *s) +{ + char *end; + + while(*s && isspace(*s)) ++s; + if(!*s) return 0; + + end = s; + while(*end && *end != '#') ++end; + *end-- = 0; + + while(end > s && isspace(*end)) { + *end-- = 0; + } + + return s; +} + +static char *parse_idx(char *ptr, int *idx, int arrsz) +{ + char *endp; + int val = strtol(ptr, &endp, 10); + if(endp == ptr) return 0; + + if(val < 0) { /* convert negative indices */ + *idx = arrsz + val; + } else { + *idx = val - 1; /* indices in obj are 1-based */ + } + return endp; +} + +/* possible face-vertex definitions: + * 1. vertex + * 2. vertex/texcoord + * 3. vertex//normal + * 4. vertex/texcoord/normal + */ +static char *parse_face_vert(char *ptr, struct facevertex *fv, int numv, int numt, int numn) +{ + if(!(ptr = parse_idx(ptr, &fv->vidx, numv))) + return 0; + if(*ptr != '/') return (!*ptr || isspace(*ptr)) ? ptr : 0; + + if(*++ptr == '/') { /* no texcoord */ + fv->tidx = -1; + ++ptr; + } else { + if(!(ptr = parse_idx(ptr, &fv->tidx, numt))) + return 0; + if(*ptr != '/') return (!*ptr || isspace(*ptr)) ? ptr : 0; + ++ptr; + } + + if(!(ptr = parse_idx(ptr, &fv->nidx, numn))) + return 0; + return (!*ptr || isspace(*ptr)) ? ptr : 0; +} + +static int cmp_facevert(const void *ap, const void *bp) +{ + const struct facevertex *a = ap; + const struct facevertex *b = bp; + + if(a->vidx == b->vidx) { + if(a->tidx == b->tidx) { + return a->nidx - b->nidx; + } + return a->tidx - b->tidx; + } + return a->vidx - b->vidx; +} + +static void free_rbnode_key(struct rbnode *n, void *cls) +{ + free(n->key); +} +#endif diff --git a/src/opengl.h b/src/opengl.h new file mode 100644 index 0000000..6cda1d2 --- /dev/null +++ b/src/opengl.h @@ -0,0 +1,33 @@ +#ifndef OPENGL_H_ +#define OPENGL_H_ + +#ifdef HAVE_CONFIG_H_ +#include "config.h" +#endif + +#if defined(IPHONE) || defined(__IPHONE__) +#include + +#define glClearDepth glClearDepthf +#define GLDEF +#include "sanegl.h" + +#elif defined(ANDROID) +#include +#include +#define GLDEF +#include "sanegl.h" + +#else + +#include + +#ifdef __APPLE__ +#include +#else +#include +#endif /* __APPLE__ */ + +#endif /* IPHONE */ + +#endif /* OPENGL_H_ */ diff --git a/src/rbtree.c b/src/rbtree.c new file mode 100644 index 0000000..765e542 --- /dev/null +++ b/src/rbtree.c @@ -0,0 +1,518 @@ +/* +rbtree - simple balanced binary search tree (red-black tree) library. +Copyright (C) 2011-2014 John Tsiombikas + +rbtree is free software, feel free to use, modify, and redistribute it, under +the terms of the 3-clause BSD license. See COPYING for details. +*/ +#include +#include +#include +#include +#include "rbtree.h" + +#define INT2PTR(x) ((void*)(intptr_t)(x)) +#define PTR2INT(x) ((int)(intptr_t)(x)) + +struct rbtree { + struct rbnode *root; + + rb_alloc_func_t alloc; + rb_free_func_t free; + + rb_cmp_func_t cmp; + rb_del_func_t del; + void *del_cls; + + struct rbnode *rstack, *iter; +}; + +static int cmpaddr(const void *ap, const void *bp); +static int cmpint(const void *ap, const void *bp); + +static int count_nodes(struct rbnode *node); +static void del_tree(struct rbnode *node, void (*delfunc)(struct rbnode*, void*), void *cls); +static struct rbnode *insert(struct rbtree *rb, struct rbnode *tree, void *key, void *data); +static struct rbnode *delete(struct rbtree *rb, struct rbnode *tree, void *key); +/*static struct rbnode *find(struct rbtree *rb, struct rbnode *node, void *key);*/ +static void traverse(struct rbnode *node, void (*func)(struct rbnode*, void*), void *cls); + +struct rbtree *rb_create(rb_cmp_func_t cmp_func) +{ + struct rbtree *rb; + + if(!(rb = malloc(sizeof *rb))) { + return 0; + } + if(rb_init(rb, cmp_func) == -1) { + free(rb); + return 0; + } + return rb; +} + +void rb_free(struct rbtree *rb) +{ + rb_destroy(rb); + free(rb); +} + + +int rb_init(struct rbtree *rb, rb_cmp_func_t cmp_func) +{ + memset(rb, 0, sizeof *rb); + + if(!cmp_func) { + rb->cmp = cmpaddr; + } else if(cmp_func == RB_KEY_INT) { + rb->cmp = cmpint; + } else if(cmp_func == RB_KEY_STRING) { + rb->cmp = (rb_cmp_func_t)strcmp; + } else { + rb->cmp = cmp_func; + } + + rb->alloc = malloc; + rb->free = free; + return 0; +} + +void rb_destroy(struct rbtree *rb) +{ + del_tree(rb->root, rb->del, rb->del_cls); +} + +void rb_set_allocator(struct rbtree *rb, rb_alloc_func_t alloc, rb_free_func_t free) +{ + rb->alloc = alloc; + rb->free = free; +} + + +void rb_set_compare_func(struct rbtree *rb, rb_cmp_func_t func) +{ + rb->cmp = func; +} + +void rb_set_delete_func(struct rbtree *rb, rb_del_func_t func, void *cls) +{ + rb->del = func; + rb->del_cls = cls; +} + + +void rb_clear(struct rbtree *rb) +{ + del_tree(rb->root, rb->del, rb->del_cls); + rb->root = 0; +} + +int rb_copy(struct rbtree *dest, struct rbtree *src) +{ + struct rbnode *node; + + rb_clear(dest); + rb_begin(src); + while((node = rb_next(src))) { + if(rb_insert(dest, node->key, node->data) == -1) { + return -1; + } + } + return 0; +} + +int rb_size(struct rbtree *rb) +{ + return count_nodes(rb->root); +} + +int rb_insert(struct rbtree *rb, void *key, void *data) +{ + rb->root = insert(rb, rb->root, key, data); + rb->root->red = 0; + return 0; +} + +int rb_inserti(struct rbtree *rb, int key, void *data) +{ + rb->root = insert(rb, rb->root, INT2PTR(key), data); + rb->root->red = 0; + return 0; +} + + +int rb_delete(struct rbtree *rb, void *key) +{ + if((rb->root = delete(rb, rb->root, key))) { + rb->root->red = 0; + } + return 0; +} + +int rb_deletei(struct rbtree *rb, int key) +{ + if((rb->root = delete(rb, rb->root, INT2PTR(key)))) { + rb->root->red = 0; + } + return 0; +} + + +struct rbnode *rb_find(struct rbtree *rb, void *key) +{ + struct rbnode *node = rb->root; + + while(node) { + int cmp = rb->cmp(key, node->key); + if(cmp == 0) { + return node; + } + node = cmp < 0 ? node->left : node->right; + } + return 0; +} + +struct rbnode *rb_findi(struct rbtree *rb, int key) +{ + return rb_find(rb, INT2PTR(key)); +} + + +void rb_foreach(struct rbtree *rb, void (*func)(struct rbnode*, void*), void *cls) +{ + traverse(rb->root, func, cls); +} + + +struct rbnode *rb_root(struct rbtree *rb) +{ + return rb->root; +} + +void rb_begin(struct rbtree *rb) +{ + rb->rstack = 0; + rb->iter = rb->root; +} + +#define push(sp, x) ((x)->next = (sp), (sp) = (x)) +#define pop(sp) ((sp) = (sp)->next) +#define top(sp) (sp) + +struct rbnode *rb_next(struct rbtree *rb) +{ + struct rbnode *res = 0; + + while(rb->rstack || rb->iter) { + if(rb->iter) { + push(rb->rstack, rb->iter); + rb->iter = rb->iter->left; + } else { + rb->iter = top(rb->rstack); + pop(rb->rstack); + res = rb->iter; + rb->iter = rb->iter->right; + break; + } + } + return res; +} + +void *rb_node_key(struct rbnode *node) +{ + return node ? node->key : 0; +} + +int rb_node_keyi(struct rbnode *node) +{ + return node ? PTR2INT(node->key) : 0; +} + +void *rb_node_data(struct rbnode *node) +{ + return node ? node->data : 0; +} + +void rb_node_setdata(struct rbnode *node, void *data) +{ + node->data = data; +} + +static int cmpaddr(const void *ap, const void *bp) +{ + return ap < bp ? -1 : (ap > bp ? 1 : 0); +} + +static int cmpint(const void *ap, const void *bp) +{ + return PTR2INT(ap) - PTR2INT(bp); +} + + +/* ---- left-leaning 2-3 red-black implementation ---- */ + +/* helper prototypes */ +static int is_red(struct rbnode *tree); +static void color_flip(struct rbnode *tree); +static struct rbnode *rot_left(struct rbnode *a); +static struct rbnode *rot_right(struct rbnode *a); +static struct rbnode *find_min(struct rbnode *tree); +static struct rbnode *del_min(struct rbtree *rb, struct rbnode *tree); +/*static struct rbnode *move_red_right(struct rbnode *tree);*/ +static struct rbnode *move_red_left(struct rbnode *tree); +static struct rbnode *fix_up(struct rbnode *tree); + +static int count_nodes(struct rbnode *node) +{ + if(!node) + return 0; + + return 1 + count_nodes(node->left) + count_nodes(node->right); +} + +static void del_tree(struct rbnode *node, rb_del_func_t delfunc, void *cls) +{ + if(!node) + return; + + del_tree(node->left, delfunc, cls); + del_tree(node->right, delfunc, cls); + + if(delfunc) { + delfunc(node, cls); + } + free(node); +} + +static struct rbnode *insert(struct rbtree *rb, struct rbnode *tree, void *key, void *data) +{ + int cmp; + + if(!tree) { + struct rbnode *node = rb->alloc(sizeof *node); + node->red = 1; + node->key = key; + node->data = data; + node->left = node->right = 0; + return node; + } + + cmp = rb->cmp(key, tree->key); + + if(cmp < 0) { + tree->left = insert(rb, tree->left, key, data); + } else if(cmp > 0) { + tree->right = insert(rb, tree->right, key, data); + } else { + if(rb->del) { + /* The key passed in was allocated in a way that would be cleaned by the + * user-supplied delete function. We can't just assign the data and ignore + * key in this case, or we'll leak memory. But we also can't make a dummy + * node and pass that to rb->del, because it might also expect to free data. + * So we must instead delete the existing node's contents, and use the new ones. + */ + rb->del(tree, rb->del_cls); + tree->key = key; + } + tree->data = data; + } + + /* fix right-leaning reds */ + if(is_red(tree->right)) { + tree = rot_left(tree); + } + /* fix two reds in a row */ + if(is_red(tree->left) && is_red(tree->left->left)) { + tree = rot_right(tree); + } + + /* if 4-node, split it by color inversion */ + if(is_red(tree->left) && is_red(tree->right)) { + color_flip(tree); + } + + return tree; +} + +static struct rbnode *delete(struct rbtree *rb, struct rbnode *tree, void *key) +{ + int cmp; + + if(!tree) { + return 0; + } + + cmp = rb->cmp(key, tree->key); + + if(cmp < 0) { + if(!is_red(tree->left) && !is_red(tree->left->left)) { + tree = move_red_left(tree); + } + tree->left = delete(rb, tree->left, key); + } else { + /* need reds on the right */ + if(is_red(tree->left)) { + tree = rot_right(tree); + } + + /* found it at the bottom (XXX what certifies left is null?) */ + if(cmp == 0 && !tree->right) { + if(rb->del) { + rb->del(tree, rb->del_cls); + } + rb->free(tree); + return 0; + } + + if(!is_red(tree->right) && !is_red(tree->right->left)) { + tree = move_red_left(tree); + } + + if(key == tree->key) { + struct rbnode *rmin = find_min(tree->right); + tree->key = rmin->key; + tree->data = rmin->data; + tree->right = del_min(rb, tree->right); + } else { + tree->right = delete(rb, tree->right, key); + } + } + + return fix_up(tree); +} + +/*static struct rbnode *find(struct rbtree *rb, struct rbnode *node, void *key) +{ + int cmp; + + if(!node) + return 0; + + if((cmp = rb->cmp(key, node->key)) == 0) { + return node; + } + return find(rb, cmp < 0 ? node->left : node->right, key); +}*/ + +static void traverse(struct rbnode *node, void (*func)(struct rbnode*, void*), void *cls) +{ + if(!node) + return; + + traverse(node->left, func, cls); + func(node, cls); + traverse(node->right, func, cls); +} + +/* helpers */ + +static int is_red(struct rbnode *tree) +{ + return tree && tree->red; +} + +static void color_flip(struct rbnode *tree) +{ + tree->red = !tree->red; + tree->left->red = !tree->left->red; + tree->right->red = !tree->right->red; +} + +static struct rbnode *rot_left(struct rbnode *a) +{ + struct rbnode *b = a->right; + a->right = b->left; + b->left = a; + b->red = a->red; + a->red = 1; + return b; +} + +static struct rbnode *rot_right(struct rbnode *a) +{ + struct rbnode *b = a->left; + a->left = b->right; + b->right = a; + b->red = a->red; + a->red = 1; + return b; +} + +static struct rbnode *find_min(struct rbnode *tree) +{ + if(!tree) + return 0; + + while(tree->left) { + tree = tree->left; + } + return tree; +} + +static struct rbnode *del_min(struct rbtree *rb, struct rbnode *tree) +{ + if(!tree->left) { + if(rb->del) { + rb->del(tree->left, rb->del_cls); + } + rb->free(tree->left); + return 0; + } + + /* make sure we've got red (3/4-nodes) at the left side so we can delete at the bottom */ + if(!is_red(tree->left) && !is_red(tree->left->left)) { + tree = move_red_left(tree); + } + tree->left = del_min(rb, tree->left); + + /* fix right-reds, red-reds, and split 4-nodes on the way up */ + return fix_up(tree); +} + +#if 0 +/* push a red link on this node to the right */ +static struct rbnode *move_red_right(struct rbnode *tree) +{ + /* flipping it makes both children go red, so we have a red to the right */ + color_flip(tree); + + /* if after the flip we've got a red-red situation to the left, fix it */ + if(is_red(tree->left->left)) { + tree = rot_right(tree); + color_flip(tree); + } + return tree; +} +#endif + +/* push a red link on this node to the left */ +static struct rbnode *move_red_left(struct rbnode *tree) +{ + /* flipping it makes both children go red, so we have a red to the left */ + color_flip(tree); + + /* if after the flip we've got a red-red on the right-left, fix it */ + if(is_red(tree->right->left)) { + tree->right = rot_right(tree->right); + tree = rot_left(tree); + color_flip(tree); + } + return tree; +} + +static struct rbnode *fix_up(struct rbnode *tree) +{ + /* fix right-leaning */ + if(is_red(tree->right)) { + tree = rot_left(tree); + } + /* change invalid red-red pairs into a proper 4-node */ + if(is_red(tree->left) && is_red(tree->left->left)) { + tree = rot_right(tree); + } + /* split 4-nodes */ + if(is_red(tree->left) && is_red(tree->right)) { + color_flip(tree); + } + return tree; +} diff --git a/src/rbtree.h b/src/rbtree.h new file mode 100644 index 0000000..dada0dc --- /dev/null +++ b/src/rbtree.h @@ -0,0 +1,79 @@ +/* +rbtree - simple balanced binary search tree (red-black tree) library. +Copyright (C) 2011-2014 John Tsiombikas + +rbtree is free software, feel free to use, modify, and redistribute it, under +the terms of the 3-clause BSD license. See COPYING for details. +*/ +#ifndef RBTREE_H_ +#define RBTREE_H_ + +struct rbtree; + + +struct rbnode { + void *key, *data; + int red; + struct rbnode *left, *right; + struct rbnode *next; /* for iterator stack */ +}; + + +typedef void *(*rb_alloc_func_t)(size_t); +typedef void (*rb_free_func_t)(void*); + +typedef int (*rb_cmp_func_t)(const void*, const void*); +typedef void (*rb_del_func_t)(struct rbnode*, void*); + +#define RB_KEY_ADDR (rb_cmp_func_t)(0) +#define RB_KEY_INT (rb_cmp_func_t)(1) +#define RB_KEY_STRING (rb_cmp_func_t)(3) + + +#ifdef __cplusplus +extern "C" { +#endif + +struct rbtree *rb_create(rb_cmp_func_t cmp_func); +void rb_free(struct rbtree *rb); + +int rb_init(struct rbtree *rb, rb_cmp_func_t cmp_func); +void rb_destroy(struct rbtree *rb); + +void rb_set_allocator(struct rbtree *rb, rb_alloc_func_t alloc, rb_free_func_t free); +void rb_set_compare_func(struct rbtree *rb, rb_cmp_func_t func); +void rb_set_delete_func(struct rbtree *rb, rb_del_func_t func, void *cls); +/* TODO add user deep copy function */ + +void rb_clear(struct rbtree *rb); +int rb_copy(struct rbtree *dest, struct rbtree *src); + +int rb_size(struct rbtree *rb); + +int rb_insert(struct rbtree *rb, void *key, void *data); +int rb_inserti(struct rbtree *rb, int key, void *data); + +int rb_delete(struct rbtree *rb, void *key); +int rb_deletei(struct rbtree *rb, int key); + +struct rbnode *rb_find(struct rbtree *rb, void *key); +struct rbnode *rb_findi(struct rbtree *rb, int key); + +void rb_foreach(struct rbtree *rb, void (*func)(struct rbnode*, void*), void *cls); + +struct rbnode *rb_root(struct rbtree *rb); + +void rb_begin(struct rbtree *rb); +struct rbnode *rb_next(struct rbtree *rb); + +void *rb_node_key(struct rbnode *node); +int rb_node_keyi(struct rbnode *node); +void *rb_node_data(struct rbnode *node); +void rb_node_setdata(struct rbnode *node, void *data); + +#ifdef __cplusplus +} +#endif + + +#endif /* RBTREE_H_ */ diff --git a/src/sdr.c b/src/sdr.c new file mode 100644 index 0000000..0152a6e --- /dev/null +++ b/src/sdr.c @@ -0,0 +1,562 @@ +#include +#include +#include +#include +#include +#include +#include "opengl.h" + +#if defined(unix) || defined(__unix__) +#include +#include +#endif /* unix */ + +#include "sdr.h" + +static const char *sdrtypestr(unsigned int sdrtype); +static int sdrtypeidx(unsigned int sdrtype); + + +unsigned int create_vertex_shader(const char *src) +{ + return create_shader(src, GL_VERTEX_SHADER); +} + +unsigned int create_pixel_shader(const char *src) +{ + return create_shader(src, GL_FRAGMENT_SHADER); +} + +unsigned int create_tessctl_shader(const char *src) +{ +#ifdef GL_TESS_CONTROL_SHADER + return create_shader(src, GL_TESS_CONTROL_SHADER); +#else + return 0; +#endif +} + +unsigned int create_tesseval_shader(const char *src) +{ +#ifdef GL_TESS_EVALUATION_SHADER + return create_shader(src, GL_TESS_EVALUATION_SHADER); +#else + return 0; +#endif +} + +unsigned int create_geometry_shader(const char *src) +{ +#ifdef GL_GEOMETRY_SHADER + return create_shader(src, GL_GEOMETRY_SHADER); +#else + return 0; +#endif +} + +unsigned int create_shader(const char *src, unsigned int sdr_type) +{ + unsigned int sdr; + int success, info_len; + char *info_str = 0; + const char *src_str[3], *header, *footer; + int src_str_count = 0; + GLenum err; + + if((header = get_shader_header(sdr_type))) { + src_str[src_str_count++] = header; + } + src_str[src_str_count++] = src; + if((footer = get_shader_footer(sdr_type))) { + src_str[src_str_count++] = footer; + } + + sdr = glCreateShader(sdr_type); + assert(glGetError() == GL_NO_ERROR); + glShaderSource(sdr, src_str_count, src_str, 0); + err = glGetError(); + assert(err == GL_NO_ERROR); + glCompileShader(sdr); + assert(glGetError() == GL_NO_ERROR); + + glGetShaderiv(sdr, GL_COMPILE_STATUS, &success); + assert(glGetError() == GL_NO_ERROR); + glGetShaderiv(sdr, GL_INFO_LOG_LENGTH, &info_len); + assert(glGetError() == GL_NO_ERROR); + + if(info_len) { + if((info_str = malloc(info_len + 1))) { + glGetShaderInfoLog(sdr, info_len, 0, info_str); + assert(glGetError() == GL_NO_ERROR); + info_str[info_len] = 0; + } + } + + if(success) { + fprintf(stderr, info_str ? "done: %s\n" : "done\n", info_str); + } else { + fprintf(stderr, info_str ? "failed: %s\n" : "failed\n", info_str); + glDeleteShader(sdr); + sdr = 0; + } + + free(info_str); + return sdr; +} + +void free_shader(unsigned int sdr) +{ + glDeleteShader(sdr); +} + +unsigned int load_vertex_shader(const char *fname) +{ + return load_shader(fname, GL_VERTEX_SHADER); +} + +unsigned int load_pixel_shader(const char *fname) +{ + return load_shader(fname, GL_FRAGMENT_SHADER); +} + +unsigned int load_tessctl_shader(const char *fname) +{ +#ifdef GL_TESS_CONTROL_SHADER + return load_shader(fname, GL_TESS_CONTROL_SHADER); +#else + return 0; +#endif +} + +unsigned int load_tesseval_shader(const char *fname) +{ +#ifdef GL_TESS_EVALUATION_SHADER + return load_shader(fname, GL_TESS_EVALUATION_SHADER); +#else + return 0; +#endif +} + +unsigned int load_geometry_shader(const char *fname) +{ +#ifdef GL_GEOMETRY_SHADER + return load_shader(fname, GL_GEOMETRY_SHADER); +#else + return 0; +#endif +} + +unsigned int load_shader(const char *fname, unsigned int sdr_type) +{ + unsigned int sdr; + size_t filesize; + FILE *fp; + char *src; + + if(!(fp = fopen(fname, "rb"))) { + fprintf(stderr, "failed to open shader %s: %s\n", fname, strerror(errno)); + return 0; + } + + fseek(fp, 0, SEEK_END); + filesize = ftell(fp); + fseek(fp, 0, SEEK_SET); + + if(!(src = malloc(filesize + 1))) { + fclose(fp); + return 0; + } + fread(src, 1, filesize, fp); + src[filesize] = 0; + fclose(fp); + + fprintf(stderr, "compiling %s shader: %s... ", sdrtypestr(sdr_type), fname); + sdr = create_shader(src, sdr_type); + + free(src); + return sdr; +} + + +/* ---- gpu programs ---- */ + +unsigned int create_program(void) +{ + unsigned int prog = glCreateProgram(); + assert(glGetError() == GL_NO_ERROR); + return prog; +} + +unsigned int create_program_link(unsigned int sdr0, ...) +{ + unsigned int prog, sdr; + va_list ap; + + if(!(prog = create_program())) { + return 0; + } + + attach_shader(prog, sdr0); + if(glGetError()) { + return 0; + } + + va_start(ap, sdr0); + while((sdr = va_arg(ap, unsigned int))) { + attach_shader(prog, sdr); + if(glGetError()) { + return 0; + } + } + va_end(ap); + + if(link_program(prog) == -1) { + free_program(prog); + return 0; + } + return prog; +} + +unsigned int create_program_load(const char *vfile, const char *pfile) +{ + unsigned int vs = 0, ps = 0; + + if(vfile && *vfile && !(vs = load_vertex_shader(vfile))) { + return 0; + } + if(pfile && *pfile && !(ps = load_pixel_shader(pfile))) { + return 0; + } + return create_program_link(vs, ps, 0); +} + +void free_program(unsigned int sdr) +{ + glDeleteProgram(sdr); +} + +void attach_shader(unsigned int prog, unsigned int sdr) +{ + int err; + + if(prog && sdr) { + assert(glGetError() == GL_NO_ERROR); + glAttachShader(prog, sdr); + if((err = glGetError()) != GL_NO_ERROR) { + fprintf(stderr, "failed to attach shader %u to program %u (err: 0x%x)\n", sdr, prog, err); + abort(); + } + } +} + +int link_program(unsigned int prog) +{ + int linked, info_len, retval = 0; + char *info_str = 0; + + glLinkProgram(prog); + assert(glGetError() == GL_NO_ERROR); + glGetProgramiv(prog, GL_LINK_STATUS, &linked); + assert(glGetError() == GL_NO_ERROR); + glGetProgramiv(prog, GL_INFO_LOG_LENGTH, &info_len); + assert(glGetError() == GL_NO_ERROR); + + if(info_len) { + if((info_str = malloc(info_len + 1))) { + glGetProgramInfoLog(prog, info_len, 0, info_str); + assert(glGetError() == GL_NO_ERROR); + info_str[info_len] = 0; + } + } + + if(linked) { + fprintf(stderr, info_str ? "linking done: %s\n" : "linking done\n", info_str); + } else { + fprintf(stderr, info_str ? "linking failed: %s\n" : "linking failed\n", info_str); + retval = -1; + } + + free(info_str); + return retval; +} + +int bind_program(unsigned int prog) +{ + GLenum err; + + glUseProgram(prog); + if(prog && (err = glGetError()) != GL_NO_ERROR) { + /* maybe the program is not linked, try linking first */ + if(err == GL_INVALID_OPERATION) { + if(link_program(prog) == -1) { + return -1; + } + glUseProgram(prog); + return glGetError() == GL_NO_ERROR ? 0 : -1; + } + return -1; + } + return 0; +} + +/* ugly but I'm not going to write the same bloody code over and over */ +#define BEGIN_UNIFORM_CODE \ + int loc, curr_prog; \ + glGetIntegerv(GL_CURRENT_PROGRAM, &curr_prog); \ + if((unsigned int)curr_prog != prog && bind_program(prog) == -1) { \ + return -1; \ + } \ + if((loc = glGetUniformLocation(prog, name)) != -1) + +#define END_UNIFORM_CODE \ + if((unsigned int)curr_prog != prog) { \ + bind_program(curr_prog); \ + } \ + return loc == -1 ? -1 : 0 + +int get_uniform_loc(unsigned int prog, const char *name) +{ + int loc, curr_prog; + glGetIntegerv(GL_CURRENT_PROGRAM, &curr_prog); + if((unsigned int)curr_prog != prog && bind_program(prog) == -1) { + return -1; + } + loc = glGetUniformLocation(prog, name); + if((unsigned int)curr_prog != prog) { + bind_program(curr_prog); + } + return loc; +} + +int set_uniform_int(unsigned int prog, const char *name, int val) +{ + BEGIN_UNIFORM_CODE { + glUniform1i(loc, val); + } + END_UNIFORM_CODE; +} + +int set_uniform_float(unsigned int prog, const char *name, float val) +{ + BEGIN_UNIFORM_CODE { + glUniform1f(loc, val); + } + END_UNIFORM_CODE; +} + +int set_uniform_float2(unsigned int prog, const char *name, float x, float y) +{ + BEGIN_UNIFORM_CODE { + glUniform2f(loc, x, y); + } + END_UNIFORM_CODE; +} + +int set_uniform_float3(unsigned int prog, const char *name, float x, float y, float z) +{ + BEGIN_UNIFORM_CODE { + glUniform3f(loc, x, y, z); + } + END_UNIFORM_CODE; +} + +int set_uniform_float4(unsigned int prog, const char *name, float x, float y, float z, float w) +{ + BEGIN_UNIFORM_CODE { + glUniform4f(loc, x, y, z, w); + } + END_UNIFORM_CODE; +} + +int set_uniform_matrix4(unsigned int prog, const char *name, const float *mat) +{ + BEGIN_UNIFORM_CODE { + glUniformMatrix4fv(loc, 1, GL_FALSE, mat); + } + END_UNIFORM_CODE; +} + +int set_uniform_matrix4_transposed(unsigned int prog, const char *name, const float *mat) +{ + BEGIN_UNIFORM_CODE { + glUniformMatrix4fv(loc, 1, GL_TRUE, mat); + } + END_UNIFORM_CODE; +} + +int get_attrib_loc(unsigned int prog, const char *name) +{ + int loc, curr_prog; + + glGetIntegerv(GL_CURRENT_PROGRAM, &curr_prog); + if((unsigned int)curr_prog != prog && bind_program(prog) == -1) { + return -1; + } + + loc = glGetAttribLocation(prog, (char*)name); + + if((unsigned int)curr_prog != prog) { + bind_program(curr_prog); + } + return loc; +} + +void set_attrib_float3(int attr_loc, float x, float y, float z) +{ + glVertexAttrib3f(attr_loc, x, y, z); +} + +/* ---- shader composition ---- */ +struct string { + char *text; + int len; +}; + +#define NUM_SHADER_TYPES 5 +static struct string header[NUM_SHADER_TYPES]; +static struct string footer[NUM_SHADER_TYPES]; + +static void clear_string(struct string *str) +{ + free(str->text); + str->text = 0; + str->len = 0; +} + +static void append_string(struct string *str, const char *s) +{ + int len, newlen; + char *newstr; + + if(!s || !*s) return; + + len = strlen(s); + newlen = str->len + len; + if(!(newstr = malloc(newlen + 2))) { /* leave space for a possible newline */ + fprintf(stderr, "shader composition: failed to append string of size %d\n", len); + abort(); + } + + if(str->text) { + memcpy(newstr, str->text, str->len); + } + memcpy(newstr + str->len, s, len + 1); + + if(s[len - 1] != '\n') { + newstr[newlen] = '\n'; + newstr[newlen + 1] = 0; + } + + free(str->text); + str->text = newstr; + str->len = newlen; +} + +void clear_shader_header(unsigned int type) +{ + if(type) { + int idx = sdrtypeidx(type); + clear_string(&header[idx]); + } else { + int i; + for(i=0; i"; +} + +static int sdrtypeidx(unsigned int sdrtype) +{ + switch(sdrtype) { + case GL_VERTEX_SHADER: + return 0; + case GL_FRAGMENT_SHADER: + return 1; + case GL_TESS_CONTROL_SHADER: + return 2; + case GL_TESS_EVALUATION_SHADER: + return 3; + case GL_GEOMETRY_SHADER: + return 4; + default: + break; + } + return 0; +} diff --git a/src/sdr.h b/src/sdr.h new file mode 100644 index 0000000..7bf2389 --- /dev/null +++ b/src/sdr.h @@ -0,0 +1,68 @@ +#ifndef SDR_H_ +#define SDR_H_ + +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + +/* ---- shaders ---- */ +unsigned int create_vertex_shader(const char *src); +unsigned int create_pixel_shader(const char *src); +unsigned int create_tessctl_shader(const char *src); +unsigned int create_tesseval_shader(const char *src); +unsigned int create_geometry_shader(const char *src); +unsigned int create_shader(const char *src, unsigned int sdr_type); +void free_shader(unsigned int sdr); + +unsigned int load_vertex_shader(const char *fname); +unsigned int load_pixel_shader(const char *fname); +unsigned int load_tessctl_shader(const char *fname); +unsigned int load_tesseval_shader(const char *fname); +unsigned int load_geometry_shader(const char *fname); +unsigned int load_shader(const char *src, unsigned int sdr_type); + +int add_shader(const char *fname, unsigned int sdr); +int remove_shader(const char *fname); + +/* ---- gpu programs ---- */ +unsigned int create_program(void); +unsigned int create_program_link(unsigned int sdr0, ...); +unsigned int create_program_load(const char *vfile, const char *pfile); +void free_program(unsigned int sdr); + +void attach_shader(unsigned int prog, unsigned int sdr); +int link_program(unsigned int prog); +int bind_program(unsigned int prog); + +int get_uniform_loc(unsigned int prog, const char *name); + +int set_uniform_int(unsigned int prog, const char *name, int val); +int set_uniform_float(unsigned int prog, const char *name, float val); +int set_uniform_float2(unsigned int prog, const char *name, float x, float y); +int set_uniform_float3(unsigned int prog, const char *name, float x, float y, float z); +int set_uniform_float4(unsigned int prog, const char *name, float x, float y, float z, float w); +int set_uniform_matrix4(unsigned int prog, const char *name, const float *mat); +int set_uniform_matrix4_transposed(unsigned int prog, const char *name, const float *mat); + +int get_attrib_loc(unsigned int prog, const char *name); +void set_attrib_float3(int attr_loc, float x, float y, float z); + +/* ---- shader composition ---- */ + +/* clear shader header/footer text. + * pass the shader type to clear, or 0 to clear all types */ +void clear_shader_header(unsigned int type); +void clear_shader_footer(unsigned int type); +/* append text to the header/footer of a specific shader type + * or use type 0 to add it to all shade types */ +void add_shader_header(unsigned int type, const char *s); +void add_shader_footer(unsigned int type, const char *s); +/* get the current header/footer text for a specific shader type */ +const char *get_shader_header(unsigned int type); +const char *get_shader_footer(unsigned int type); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif /* SDR_H_ */ diff --git a/src/util.c b/src/util.c new file mode 100644 index 0000000..7be1859 --- /dev/null +++ b/src/util.c @@ -0,0 +1,54 @@ +#include +#include +#include +#include "util.h" + +void *malloc_nf_impl(size_t sz, const char *file, int line) +{ + void *p; + if(!(p = malloc(sz))) { + fprintf(stderr, "%s:%d failed to allocate %lu bytes\n", file, line, (unsigned long)sz); + abort(); + } + return p; +} + +void *calloc_nf_impl(size_t num, size_t sz, const char *file, int line) +{ + void *p; + if(!(p = calloc(num, sz))) { + fprintf(stderr, "%s:%d failed to allocate %lu bytes\n", file, line, (unsigned long)(sz * num)); + abort(); + } + return p; +} + +void *realloc_nf_impl(void *p, size_t sz, const char *file, int line) +{ + if(!(p = realloc(p, sz))) { + fprintf(stderr, "%s:%d failed to realloc %lu bytes\n", file, line, (unsigned long)sz); + abort(); + } + return p; +} + +char *strdup_nf_impl(const char *s, const char *file, int line) +{ + char *res; + if(!(res = strdup(s))) { + fprintf(stderr, "%s:%d failed to duplicate string\n", file, line); + abort(); + } + return res; +} + + +int match_prefix(const char *str, const char *prefix) +{ + while(*str && *prefix) { + if(*str++ != *prefix++) { + return 0; + } + } + return *prefix ? 0 : 1; +} diff --git a/src/util.h b/src/util.h new file mode 100644 index 0000000..3633a3f --- /dev/null +++ b/src/util.h @@ -0,0 +1,30 @@ +#ifndef UTIL_H_ +#define UTIL_H_ + +#include +#include + +#if defined(__WATCOMC__) || defined(_WIN32) +#include +#else +#if !defined(__FreeBSD__) && !defined(__OpenBSD__) +#include +#endif +#endif + +#ifdef _MSC_VER +#define strcasecmp(s, k) stricmp(s, k) +#endif + +#define malloc_nf(sz) malloc_nf_impl(sz, __FILE__, __LINE__) +void *malloc_nf_impl(size_t sz, const char *file, int line); +#define calloc_nf(num, sz) calloc_nf_impl(num, sz, __FILE__, __LINE__) +void *calloc_nf_impl(size_t num, size_t sz, const char *file, int line); +#define realloc_nf(p, sz) realloc_nf_impl(p, sz, __FILE__, __LINE__) +void *realloc_nf_impl(void *p, size_t sz, const char *file, int line); +#define strdup_nf(s) strdup_nf_impl(s, __FILE__, __LINE__) +char *strdup_nf_impl(const char *s, const char *file, int line); + +int match_prefix(const char *str, const char *prefix); + +#endif /* UTIL_H_ */