From: John Tsiombikas Date: Fri, 9 Jun 2023 20:22:54 +0000 (+0300) Subject: foo X-Git-Url: http://git.mutantstargoat.com/user/nuclear/?a=commitdiff_plain;h=f0f09a5f3f76fd4207e4d2d71f29f876b2b379f7;p=retroray foo --- diff --git a/src/app.c b/src/app.c index 9db63b0..b7e2bdb 100644 --- a/src/app.c +++ b/src/app.c @@ -52,6 +52,7 @@ struct font *uifont; uint32_t *framebuf; +struct scene *scn; /* available screens */ #define MAX_SCREENS 8 @@ -93,6 +94,10 @@ int app_init(void) rtk_setup(&guigfx); + if(!(scn = create_scene())) { + return -1; + } + /* initialize screens */ screens[num_screens++] = &scr_model; screens[num_screens++] = &scr_rend; @@ -141,6 +146,8 @@ void app_shutdown(void) gaw_sw_destroy(); #endif + free_scene(scn); + cleanup_logger(); } diff --git a/src/app.h b/src/app.h index 96e6659..52b5d96 100644 --- a/src/app.h +++ b/src/app.h @@ -20,6 +20,7 @@ along with this program. If not, see . #include "sizeint.h" #include "logger.h" +#include "scene.h" enum { KEY_ESC = 27, @@ -72,6 +73,8 @@ extern struct font *uifont; extern uint32_t *framebuf; +extern struct scene *scn; + int app_init(void); void app_shutdown(void); diff --git a/src/cmesh.c b/src/cmesh.c new file mode 100644 index 0000000..9e9833e --- /dev/null +++ b/src/cmesh.c @@ -0,0 +1,1877 @@ +#include +#include +#include +#include +#include +#include +#include "gaw/gaw.h" +#include "cmesh.h" + +#define USE_DLIST + + +struct cmesh_vattrib { + int nelem; /* num elements per attribute [1, 4] */ + float *data; + unsigned int count; /* number of floats in data */ +#ifdef USE_VBO + unsigned int vbo; + int vbo_valid; +#endif + int 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; +#ifdef USE_VBO + unsigned int ibo; + int ibo_valid; +#endif + int idata_valid; +#ifdef USE_DLIST + int dlist; +#endif + +#ifdef USE_VBO + /* index buffer for wireframe rendering (constructed on demand) */ + unsigned int wire_ibo; + int wire_ibo_valid; +#endif + + /* 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, const struct cmesh *cmsrc, struct submesh *sub); +static int pre_draw(const struct cmesh *cm, int start); +static void post_draw(const struct cmesh *cm, int cur_sdr); +static void update_buffers(struct cmesh *cm); +#ifdef USE_VBO +static void update_wire_ibo(struct cmesh *cm); +#endif +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}; + +#ifdef USE_SDR +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); + +#ifdef USE_VBO + 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]; +#endif + 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); + +#ifdef USE_VBO + glDeleteBuffers(CMESH_NUM_ATTR + 1, cm->buffer_objects); + if(cm->wire_ibo) { + glDeleteBuffers(1, &cm->wire_ibo); + } +#endif +#ifdef USE_DLIST + if(cm->dlist) { + /*glDeleteList(cm->dlist, 1);*/ + gaw_free_compiled(cm->dlist); + } +#endif +} + +void cmesh_clear(struct cmesh *cm) +{ + int i; + + for(i=0; ivattr[i].nelem = 0; +#ifdef USE_VBO + cm->vattr[i].vbo_valid = 0; + cm->vattr[i].data_valid = 0; +#endif + free(cm->vattr[i].data); + cm->vattr[i].data = 0; + cm->vattr[i].count = 0; + } +#ifdef USE_VBO + cm->ibo_valid = 0; +#endif + cm->idata_valid = 0; + free(cm->idata); + cm->idata = 0; + cm->icount = 0; + +#ifdef USE_VBO + cm->wire_ibo_valid = 0; +#endif + cm->nverts = cm->nfaces = 0; + +#ifdef USE_DLIST + if(cm->dlist) { + /*glDeleteList(cm->dlist, 1);*/ + gaw_free_compiled(cm->dlist); + } +#endif + + cm->bsph_valid = cm->aabb_valid = 0; + + cmesh_clear_submeshes(cm); +} + +int cmesh_clone(struct cmesh *cmdest, const struct cmesh *cmsrc) +{ + return clone(cmdest, cmsrc, 0); +} + +static int clone(struct cmesh *cmdest, const 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)) { + /* force validation of the actual data on the source mesh */ + cmesh_attrib((struct cmesh*)cmsrc, i); + + nelem = cmsrc->vattr[i].nelem; + cmdest->vattr[i].nelem = nelem; + cmdest->vattr[i].data = varr[i]; + cmdest->vattr[i].count = vcount * nelem; + vptr = cmsrc->vattr[i].data + vstart * nelem; + memcpy(cmdest->vattr[i].data, vptr, vcount * nelem * sizeof(float)); + cmdest->vattr[i].data_valid = 1; +#ifdef USE_VBO + cmdest->vattr[i].vbo_valid = 0; +#endif + } else { + memset(cmdest->vattr + i, 0, sizeof cmdest->vattr[i]); + } + } + + if(cmesh_indexed(cmsrc)) { + /* force validation .... */ + cmesh_index((struct cmesh*)cmsrc); + + 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 = 0; +#ifdef USE_VBO + cmdest->ibo_valid = 0; +#endif + } + + 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(const struct cmesh *cm) +{ + return cm->name; +} + +int cmesh_has_attrib(const struct cmesh *cm, int attr) +{ + if(attr < 0 || attr >= CMESH_NUM_ATTR) { + return 0; + } +#ifdef USE_VBO + return cm->vattr[attr].vbo_valid | cm->vattr[attr].data_valid; +#else + return cm->vattr[attr].data_valid; +#endif +} + +int cmesh_indexed(const struct cmesh *cm) +{ +#ifdef USE_VBO + return cm->ibo_valid | cm->idata_valid; +#else + return cm->idata_valid; +#endif +} + +/* 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; +#ifdef USE_VBO + cm->vattr[attr].vbo_valid = 0; +#endif +#ifdef USE_DLIST + if(cm->dlist) { + gaw_free_compiled(cm->dlist); + cm->dlist = 0; + } +#endif + return newarr; +} + +float *cmesh_attrib(struct cmesh *cm, int attr) +{ + if(attr < 0 || attr >= CMESH_NUM_ATTR) { + return 0; + } +#ifdef USE_VBO + cm->vattr[attr].vbo_valid = 0; +#endif +#ifdef USE_DLIST + if(cm->dlist) { + gaw_free_compiled(cm->dlist); + cm->dlist = 0; + } +#endif + return (float*)cmesh_attrib_ro(cm, attr); +} + +const float *cmesh_attrib_ro(const struct cmesh *cm, int attr) +{ + if(attr < 0 || attr >= CMESH_NUM_ATTR) { + return 0; + } + + if(!cm->vattr[attr].data_valid) { +#if GL_ES_VERSION_2_0 || !defined(USE_VBO) + return 0; +#else + void *tmp; + int nelem; + struct cmesh *m = (struct cmesh*)cm; + + if(!m->vattr[attr].vbo_valid) { + return 0; + } + + /* local data copy unavailable, grab the data from the vbo */ + nelem = m->vattr[attr].nelem; + if(!(m->vattr[attr].data = malloc(m->nverts * nelem * sizeof(float)))) { + return 0; + } + m->vattr[attr].count = m->nverts * nelem; + + glBindBuffer(GL_ARRAY_BUFFER, m->vattr[attr].vbo); + tmp = glMapBuffer(GL_ARRAY_BUFFER, GL_READ_ONLY); + memcpy(m->vattr[attr].data, tmp, m->nverts * nelem * sizeof(float)); + glUnmapBuffer(GL_ARRAY_BUFFER); + + m->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(const 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(const struct cmesh *cm, int attr) +{ + return cmesh_has_attrib(cm, attr) ? cm->nverts : 0; +} + +int cmesh_attrib_nelem(const struct cmesh *cm, int attr) +{ + return cmesh_has_attrib(cm, attr) ? cm->vattr[attr].nelem : 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; +#ifdef USE_VBO + cm->vattr[attr].vbo_valid = 0; +#endif +#ifdef USE_DLIST + if(cm->dlist) { + gaw_free_compiled(cm->dlist); + cm->dlist = 0; + } +#endif + + 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; +#ifdef USE_VBO + cm->ibo_valid = 0; +#endif +#ifdef USE_DLIST + if(cm->dlist) { + gaw_free_compiled(cm->dlist); + cm->dlist = 0; + } +#endif + return tmp; +} + +unsigned int *cmesh_index(struct cmesh *cm) +{ +#ifdef USE_VBO + cm->ibo_valid = 0; +#endif +#ifdef USE_DLIST + if(cm->dlist) { + gaw_free_compiled(cm->dlist); + cm->dlist = 0; + } +#endif + return (unsigned int*)cmesh_index_ro(cm); +} + +const unsigned int *cmesh_index_ro(const struct cmesh *cm) +{ + if(!cm->idata_valid) { +#if GL_ES_VERSION_2_0 || !defined(USE_VBO) + return 0; +#else + int nidx; + unsigned int *tmp; + struct cmesh *m = (struct cmesh*)cm; + + if(!m->ibo_valid) { + return 0; + } + + /* local copy is unavailable, grab the data from the ibo */ + nidx = m->nfaces * 3; + if(!(tmp = malloc(nidx * sizeof *m->idata))) { + return 0; + } + free(m->idata); + m->idata = tmp; + m->icount = nidx; + + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m->ibo); + tmp = glMapBuffer(GL_ELEMENT_ARRAY_BUFFER, GL_READ_ONLY); + memcpy(m->idata, tmp, nidx * sizeof *m->idata); + glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER); + + m->idata_valid = 1; +#endif + } + return cm->idata; +} + +int cmesh_index_count(const 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; +#ifdef USE_VBO + cm->ibo_valid = 0; +#endif +#ifdef USE_DLIST + if(cm->dlist) { + gaw_free_compiled(cm->dlist); + cm->dlist = 0; + } +#endif + + cm->nfaces = cm->icount / 3; + return 0; +} + +int cmesh_poly_count(const 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) +{ +#ifdef USE_VBO + 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; + } +#endif +#ifdef USE_DLIST + if(cm->dlist) { + gaw_free_compiled(cm->dlist); + cm->dlist = 0; + } +#endif +} + +void cmesh_invalidate_index(struct cmesh *cm) +{ +#ifdef USE_VBO + cm->ibo_valid = 0; +#endif +#ifdef USE_DLIST + if(cm->dlist) { + gaw_free_compiled(cm->dlist); + cm->dlist = 0; + } +#endif +} + +int cmesh_append(struct cmesh *cmdest, const 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->nverts += cmsrc->nverts; + cmdest->nfaces += cmsrc->nfaces; + +#ifdef USE_VBO + cmdest->wire_ibo_valid = 0; +#endif + 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(const 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(const struct cmesh *cm) +{ + return cm->subcount; +} + +static struct submesh *get_submesh(const 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, const 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; + + 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].nelem > 0) { + cmesh_push_attrib(cm, i, &cm->cur_val[i].x); + } + } + + if(cm->idata_valid) { + free(cm->idata); + cm->idata = 0; + cm->icount = 0; + } +#ifdef USE_VBO + cm->ibo_valid = 0; +#endif + 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; + + if(!dir_xform) { + dir_xform = xform; + } + + 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; + } + +#ifdef USE_VBO + cm->ibo_valid = 0; +#endif +#ifdef USE_DLIST + if(cm->dlist) { + gaw_free_compiled(cm->dlist); + cm->dlist = 0; + } +#endif + 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(const struct cmesh *cm, int start) +{ + int cur_sdr; + +#ifdef USE_SDR + int i, loc; + glGetIntegerv(GL_CURRENT_PROGRAM, &cur_sdr); +#else + cur_sdr = 0; +#endif + + update_buffers((struct cmesh*)cm); + +#ifdef USE_VBO + if(!cm->vattr[CMESH_ATTR_VERTEX].vbo_valid) { + return -1; + } + +#ifdef USE_SDR + 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 { +#endif /* USE_SDR */ +#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 */ +#ifdef USE_SDR + } +#endif + glBindBuffer(GL_ARRAY_BUFFER, 0); + +#else /* !USE_VBO */ + +#ifdef USE_DLIST + if(cm->dlist && !start) { + return cur_sdr; + } +#endif + { + const struct cmesh_vattrib *vattr; + + vattr = cm->vattr + CMESH_ATTR_VERTEX; + gaw_vertex_array(vattr->nelem, 0, vattr->data + start * vattr->nelem); + + vattr = cm->vattr + CMESH_ATTR_NORMAL; + if(vattr->data_valid) { + gaw_normal_array(0, vattr->data + start * 3); + } + + vattr = cm->vattr + CMESH_ATTR_TEXCOORD; + if(vattr->data_valid) { + gaw_texcoord_array(vattr->nelem, 0, vattr->data + start * vattr->nelem); + } + + vattr = cm->vattr + CMESH_ATTR_COLOR; + if(vattr->data_valid) { + gaw_color_array(vattr->nelem, 0, vattr->data + start * vattr->nelem); + } + } +#endif /* !USE_VBO */ + return cur_sdr; +} + +void cmesh_draw(const struct cmesh *cm) +{ + int cur_sdr; + + if((cur_sdr = pre_draw(cm, 0)) == -1) { + return; + } + +#ifdef USE_VBO + 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); + } +#else +#ifdef USE_DLIST + if(cm->dlist) { + gaw_draw_compiled(cm->dlist); + } else +#endif + if(cm->idata_valid) { + /*glDrawElements(GL_TRIANGLES, cm->nfaces * 3, GL_UNSIGNED_INT, cm->idata);*/ + gaw_draw_indexed(GAW_TRIANGLES, cm->idata, cm->nfaces * 3); + } else { + /*glDrawArrays(GL_TRIANGLES, 0, cm->nverts);*/ + gaw_draw(GAW_TRIANGLES, cm->nverts); + } +#endif + + post_draw(cm, cur_sdr); +} + +void cmesh_draw_range(const struct cmesh *cm, int start, int count) +{ + int cur_sdr; + + if((cur_sdr = pre_draw(cm, start)) == -1) { + return; + } + +#ifdef USE_VBO + 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); + } +#else + if(cm->idata_valid) { + gaw_draw_indexed(GAW_TRIANGLES, cm->idata + start, count); + } else { + gaw_draw(GAW_TRIANGLES, count); + } +#endif + + post_draw(cm, cur_sdr); +} + +void cmesh_draw_submesh(const 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(const struct cmesh *cm, int cur_sdr) +{ +#ifdef USE_VBO +#ifdef USE_SDR + if(cur_sdr && use_custom_sdr_attr) { + int i; + for(i=0; i= 0 && cm->vattr[i].vbo_valid) { + glDisableVertexAttribArray(loc); + } + } + } else { +#endif /* USE_SDR */ +#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 */ +#ifdef USE_SDR + } +#endif +#else /* !USE_VBO */ + gaw_vertex_array(0, 0, 0); + gaw_normal_array(0, 0); + gaw_texcoord_array(0, 0, 0); + gaw_color_array(0, 0, 0); +#endif +} + +void cmesh_draw_wire(const struct cmesh *cm, float linesz) +{ +#ifdef USE_VBO + int cur_sdr, nfaces; + + if((cur_sdr = pre_draw(cm, 0)) == -1) { + return; + } + update_wire_ibo((struct cmesh*)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); +#endif +} + +void cmesh_draw_vertices(const struct cmesh *cm, float ptsz) +{ + int cur_sdr; + if((cur_sdr = pre_draw(cm, 0)) == -1) { + return; + } + + /* + glPushAttrib(GL_POINT_BIT); + glPointSize(ptsz); + glDrawArrays(GL_POINTS, 0, cm->nverts); + glPopAttrib(); + */ + gaw_draw(GAW_POINTS, cm->nverts); + + post_draw(cm, cur_sdr); +} + +void cmesh_draw_normals(const struct cmesh *cm, float len) +{ +#ifndef GL_ES_VERSION_2_0 + int i, vert_nelem, norm_nelem; +#ifdef USE_SDR + int cur_sdr, loc = -1; +#endif + 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; + +#ifdef USE_SDR + glGetIntegerv(GL_CURRENT_PROGRAM, &cur_sdr); + if(cur_sdr && use_custom_sdr_attr) { + if((loc = sdr_loc[CMESH_ATTR_VERTEX]) < 0) { + return; + } + } +#endif + + gaw_begin(GAW_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; + +#ifdef USE_SDR + if(loc == -1) { +#endif + gaw_vertex3f(x, y, z); + gaw_vertex3f(endx, endy, endz); +#ifdef USE_SDR + } else { + glVertexAttrib3f(loc, x, y, z); + glVertexAttrib3f(loc, endx, endy, endz); + } +#endif + } + gaw_end(); +#endif /* GL_ES_VERSION_2_0 */ +} + +void cmesh_draw_tangents(const struct cmesh *cm, float len) +{ +#ifndef GL_ES_VERSION_2_0 + int i, vert_nelem, tang_nelem; +#ifdef USE_SDR + int cur_sdr, loc = -1; +#endif + 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; + +#ifdef USE_SDR + glGetIntegerv(GL_CURRENT_PROGRAM, &cur_sdr); + if(cur_sdr && use_custom_sdr_attr) { + if((loc = sdr_loc[CMESH_ATTR_VERTEX]) < 0) { + return; + } + } +#endif + + gaw_begin(GAW_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; + +#ifdef USE_SDR + if(loc == -1) { +#endif + gaw_vertex3f(x, y, z); + gaw_vertex3f(endx, endy, endz); +#ifdef USE_SDR + } else { + glVertexAttrib3f(loc, x, y, z); + glVertexAttrib3f(loc, endx, endy, endz); + } +#endif + } + gaw_end(); +#endif /* GL_ES_VERSION_2_0 */ +} + +static void update_buffers(struct cmesh *cm) +{ +#ifdef USE_VBO + 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); + } + +#elif defined(USE_DLIST) + static int updating; + + if(!cm->dlist && !updating) { + int dlist = gaw_compile_begin(); + updating = 1; + cmesh_draw(cm); + updating = 0; + gaw_compile_end(); + cm->dlist = dlist; + } +#endif +} + +#ifdef USE_VBO +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); +} +#endif /* USE_VBO */ + +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(const struct cmesh *cm, cgm_vec3 *vmin, cgm_vec3 *vmax) +{ + if(!cm->aabb_valid) { + calc_aabb((struct cmesh*)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(const struct cmesh *cm, cgm_vec3 *center, float *rad) +{ + if(!cm->bsph_valid) { + calc_bsph((struct cmesh*)cm); + } + if(center) *center = cm->bsph_center; + if(rad) *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(const 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(const 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, const struct cmesh *cmsrc); + +int cmesh_set_name(struct cmesh *cm, const char *name); +const char *cmesh_name(const struct cmesh *cm); + +int cmesh_has_attrib(const struct cmesh *cm, int attr); +int cmesh_indexed(const 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(const 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(const struct cmesh *cm, int attr, int idx); +int cmesh_attrib_count(const struct cmesh *cm, int attr); +int cmesh_attrib_nelem(const 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(const struct cmesh *cm); /* doesn't invalidate */ +int cmesh_index_count(const struct cmesh *cm); +int cmesh_push_index(struct cmesh *cm, unsigned int idx); + +int cmesh_poly_count(const 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, const 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(const struct cmesh *cm, const char *name); +int cmesh_submesh_count(const struct cmesh *cm); +int cmesh_clone_submesh(struct cmesh *cmdest, const 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(const struct cmesh *cm); +void cmesh_draw_range(const struct cmesh *cm, int start, int count); +void cmesh_draw_submesh(const struct cmesh *cm, int subidx); /* XXX only for indexed meshes currently */ +void cmesh_draw_wire(const struct cmesh *cm, float linesz); +void cmesh_draw_vertices(const struct cmesh *cm, float ptsz); +void cmesh_draw_normals(const struct cmesh *cm, float len); +void cmesh_draw_tangents(const 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(const 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(const 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(const struct cmesh *cm, const char *fname); +int cmesh_dump_file(const struct cmesh *cm, FILE *fp); +int cmesh_dump_obj(const struct cmesh *cm, const char *fname); +int cmesh_dump_obj_file(const struct cmesh *cm, FILE *fp, int voffs); + + + +#endif /* CMESH_H_ */ diff --git a/src/darray.c b/src/darray.c index 225d3a0..7065645 100644 --- a/src/darray.c +++ b/src/darray.c @@ -1,5 +1,5 @@ /* -Deep Runner - 6dof shooter game for the SGI O2. +RetroRay - integrated standalone vintage modeller/renderer Copyright (C) 2023 John Tsiombikas This program is free software: you can redistribute it and/or modify diff --git a/src/darray.h b/src/darray.h index ddfddf6..ab56fb1 100644 --- a/src/darray.h +++ b/src/darray.h @@ -1,5 +1,5 @@ /* -Deep Runner - 6dof shooter game for the SGI O2. +RetroRay - integrated standalone vintage modeller/renderer Copyright (C) 2023 John Tsiombikas This program is free software: you can redistribute it and/or modify diff --git a/src/gaw/polyfill.c b/src/gaw/polyfill.c index 15c06fb..f0355c1 100644 --- a/src/gaw/polyfill.c +++ b/src/gaw/polyfill.c @@ -56,27 +56,27 @@ void (*fillfunc[])(struct pvertex*, int) = { polyfill_add_tex_flat, polyfill_add_tex_gouraud, 0, 0, 0, 0, 0, 0, 0, 0, 0, - polyfill_wire, + polyfill_wire_zbuf, polyfill_flat_zbuf, polyfill_gouraud_zbuf, 0, - polyfill_tex_wire, + polyfill_tex_wire_zbuf, polyfill_tex_flat_zbuf, polyfill_tex_gouraud_zbuf, 0, - polyfill_alpha_wire, + polyfill_alpha_wire_zbuf, polyfill_alpha_flat_zbuf, polyfill_alpha_gouraud_zbuf, 0, - polyfill_alpha_tex_wire, + polyfill_alpha_tex_wire_zbuf, polyfill_alpha_tex_flat_zbuf, polyfill_alpha_tex_gouraud_zbuf, 0, - polyfill_add_wire, + polyfill_add_wire_zbuf, polyfill_add_flat_zbuf, polyfill_add_gouraud_zbuf, 0, - polyfill_add_tex_wire, + polyfill_add_tex_wire_zbuf, polyfill_add_tex_flat_zbuf, polyfill_add_tex_gouraud_zbuf, 0, 0, 0, 0, 0, 0, 0, 0, 0 @@ -139,27 +139,7 @@ void polyfill(int mode, struct pvertex *verts, int nverts) void polyfill_wire(struct pvertex *verts, int nverts) { - /* - int i, x0, y0, x1, y1; - struct pvertex *v = verts; - uint32_t color = PACK_RGB(v->r, v->g, v->b); - - for(i=0; ix >> 8; - y0 = v->y >> 8; - ++v; - x1 = v->x >> 8; - y1 = v->y >> 8; - if(clip_line(&x0, &y0, &x1, &y1, 0, 0, pfill_fb.width, pfill_fb.height)) { - draw_line(x0, y0, x1, y1, color); - } - } - x0 = verts[0].x >> 8; - y0 = verts[0].y >> 8; - if(clip_line(&x1, &y1, &x0, &y0, 0, 0, pfill_fb.width, pfill_fb.height)) { - draw_line(x1, y1, x0, y0, color); - } - */ + draw_line(verts); } void polyfill_tex_wire(struct pvertex *verts, int nverts) @@ -187,6 +167,37 @@ void polyfill_add_tex_wire(struct pvertex *verts, int nverts) polyfill_wire(verts, nverts); /* TODO */ } +void polyfill_wire_zbuf(struct pvertex *verts, int nverts) +{ + draw_line_zbuf(verts); +} + +void polyfill_tex_wire_zbuf(struct pvertex *verts, int nverts) +{ + polyfill_wire_zbuf(verts, nverts); /* TODO */ +} + +void polyfill_alpha_wire_zbuf(struct pvertex *verts, int nverts) +{ + polyfill_wire_zbuf(verts, nverts); /* TODO */ +} + +void polyfill_alpha_tex_wire_zbuf(struct pvertex *verts, int nverts) +{ + polyfill_wire_zbuf(verts, nverts); /* TODO */ +} + +void polyfill_add_wire_zbuf(struct pvertex *verts, int nverts) +{ + polyfill_wire_zbuf(verts, nverts); /* TODO */ +} + +void polyfill_add_tex_wire_zbuf(struct pvertex *verts, int nverts) +{ + polyfill_wire_zbuf(verts, nverts); /* TODO */ +} + + #define VNEXT(p) (((p) == vlast) ? varr : (p) + 1) #define VPREV(p) ((p) == varr ? vlast : (p) - 1) #define VSUCC(p, side) ((side) == 0 ? VNEXT(p) : VPREV(p)) @@ -470,3 +481,79 @@ void draw_line(struct pvertex *verts) } } } + +void draw_line_zbuf(struct pvertex *verts) +{ + int32_t x0, y0, x1, y1, z0, z1, z, dz, zslope; + int i, dx, dy, x_inc, y_inc, error; + uint32_t *fb = pfill_fb.pixels; + uint32_t *zptr; + uint32_t color = PACK_RGB(verts[0].r, verts[0].g, verts[0].b); + + x0 = verts[0].x >> 8; + y0 = verts[0].y >> 8; + x1 = verts[1].x >> 8; + y1 = verts[1].y >> 8; + z0 = verts[0].z; + z1 = verts[1].z; + + fb += y0 * pfill_fb.width + x0; + zptr = pfill_zbuf + y0 * pfill_fb.width + x0; + + dx = x1 - x0; + dy = y1 - y0; + dz = z1 - z0; + + if(dx >= 0) { + x_inc = 1; + } else { + x_inc = -1; + dx = -dx; + } + if(dy >= 0) { + y_inc = pfill_fb.width; + } else { + y_inc = -pfill_fb.width; + dy = -dy; + } + + if(dx > dy) { + zslope = dx ? (dz << 8) / dx : 0; + error = dy * 2 - dx; + for(i=0; i<=dx; i++) { + if(z <= *zptr) { + *fb = color; + *zptr = z; + } + if(error >= 0) { + error -= dx * 2; + fb += y_inc; + zptr += y_inc; + } + error += dy * 2; + fb += x_inc; + + zptr += x_inc; + z += zslope; + } + } else { + zslope = dy ? (dz << 8) / dy : 0; + error = dx * 2 - dy; + for(i=0; i<=dy; i++) { + if(z <= *zptr) { + *fb = color; + *zptr = z; + } + if(error >= 0) { + error -= dy * 2; + fb += x_inc; + zptr += x_inc; + } + error += dx * 2; + fb += y_inc; + + zptr += y_inc; + z += zslope; + } + } +} diff --git a/src/gaw/polyfill.h b/src/gaw/polyfill.h index fe24d82..e9aa6bb 100644 --- a/src/gaw/polyfill.h +++ b/src/gaw/polyfill.h @@ -138,19 +138,27 @@ void polyfill_add_gouraud(struct pvertex *verts, int nverts); void polyfill_add_tex_wire(struct pvertex *verts, int nverts); void polyfill_add_tex_flat(struct pvertex *verts, int nverts); void polyfill_add_tex_gouraud(struct pvertex *verts, int nverts); + +void polyfill_wire_zbuf(struct pvertex *verts, int nverts); void polyfill_flat_zbuf(struct pvertex *verts, int nverts); void polyfill_gouraud_zbuf(struct pvertex *verts, int nverts); +void polyfill_tex_wire_zbuf(struct pvertex *verts, int nverts); void polyfill_tex_flat_zbuf(struct pvertex *verts, int nverts); void polyfill_tex_gouraud_zbuf(struct pvertex *verts, int nverts); +void polyfill_alpha_wire_zbuf(struct pvertex *verts, int nverts); void polyfill_alpha_flat_zbuf(struct pvertex *verts, int nverts); void polyfill_alpha_gouraud_zbuf(struct pvertex *verts, int nverts); +void polyfill_alpha_tex_wire_zbuf(struct pvertex *verts, int nverts); void polyfill_alpha_tex_flat_zbuf(struct pvertex *verts, int nverts); void polyfill_alpha_tex_gouraud_zbuf(struct pvertex *verts, int nverts); +void polyfill_add_wire_zbuf(struct pvertex *verts, int nverts); void polyfill_add_flat_zbuf(struct pvertex *verts, int nverts); void polyfill_add_gouraud_zbuf(struct pvertex *verts, int nverts); +void polyfill_add_tex_wire_zbuf(struct pvertex *verts, int nverts); void polyfill_add_tex_flat_zbuf(struct pvertex *verts, int nverts); void polyfill_add_tex_gouraud_zbuf(struct pvertex *verts, int nverts); void draw_line(struct pvertex *verts); +void draw_line_zbuf(struct pvertex *verts); #endif /* POLYFILL_H_ */ diff --git a/src/meshgen.c b/src/meshgen.c new file mode 100644 index 0000000..b9e394f --- /dev/null +++ b/src/meshgen.c @@ -0,0 +1,904 @@ +#include +#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 + vverts; + *idxarr++ = idx; + *idxarr++ = idx + vverts + 1; + } + + 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 + vverts; + *idxarr++ = idx; + *idxarr++ = idx + vverts + 1; + } + + 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..d42ad96 --- /dev/null +++ b/src/meshload.c @@ -0,0 +1,399 @@ +#include +#include +#include +#include +#include "cmesh.h" +#include "sizeint.h" + +#ifdef USE_ASSIMP +#include +#include +#include +#include +#include +#else +#include "darray.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 = darr_alloc(0, sizeof *varr)) || + !(narr = darr_alloc(0, sizeof *narr)) || + !(tarr = darr_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 = darr_push_impl(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 = darr_push_impl(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 = darr_push_impl(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 = darr_size(varr); + int tsz = darr_size(tarr); + int nsz = darr_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 = (unsigned int)(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); + darr_free(varr); + darr_free(narr); + darr_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/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/rtk.c b/src/rtk.c index bdfca65..88ce5af 100644 --- a/src/rtk.c +++ b/src/rtk.c @@ -11,6 +11,10 @@ static void draw_button(rtk_widget *w); static void draw_checkbox(rtk_widget *w); static void draw_separator(rtk_widget *w); + +static rtk_widget *hover, *focused, *pressed; + + void rtk_setup(rtk_draw_ops *drawop) { gfx = *drawop; @@ -510,6 +514,7 @@ static void abs_pos(rtk_widget *w, int *xpos, int *ypos) } #define COL_BG 0xff666666 +#define COL_BGHL 0xff808080 #define COL_LBEV 0xffaaaaaa #define COL_SBEV 0xff222222 #define COL_TEXT 0xff000000 @@ -585,7 +590,7 @@ static void draw_button(rtk_widget *w) abs_pos(w, &rect.x, &rect.y); if(rect.width > 2 && rect.height > 2) { - draw_frame(&rect, FRM_OUTSET); + draw_frame(&rect, w->any.flags & PRESS ? FRM_INSET : FRM_OUTSET); rect.x++; rect.y++; @@ -593,9 +598,10 @@ static void draw_button(rtk_widget *w) rect.height -= 2; } - gfx.fill(&rect, COL_BG); + gfx.fill(&rect, w->any.flags & HOVER ? COL_BGHL : COL_BG); if(w->bn.icon) { - gfx.blit(rect.x + OFFS, rect.y + OFFS, w->bn.icon); + int offs = w->any.flags & PRESS ? PAD + 1 : PAD; + gfx.blit(rect.x + offs, rect.y + offs, w->bn.icon); } else { gfx.fill(&rect, 0xff802020); } @@ -632,3 +638,104 @@ static void draw_separator(rtk_widget *w) draw_frame(&rect, FRM_INSET); } + + +static int hittest(rtk_widget *w, int x, int y) +{ + if(x < w->any.x || y < w->any.y) return 0; + if(x >= w->any.x + w->any.width) return 0; + if(y >= w->any.y + w->any.height) return 0; + return 1; +} + +static void sethover(rtk_widget *w) +{ + if(hover == w) return; + + if(hover) { + hover->any.flags &= ~HOVER; + } + hover = w; + if(w) { + w->any.flags |= HOVER; + } +} + +static void setpress(rtk_widget *w) +{ + if(pressed == w) return; + + if(pressed) { + pressed->any.flags &= ~PRESS; + } + pressed = w; + if(w) { + w->any.flags |= PRESS; + } +} + +static void click(rtk_widget *w, int x, int y) +{ + switch(w->type) { + case RTK_CHECKBOX: + w->any.value ^= 1; + case RTK_BUTTON: + if(w->any.cbfunc) { + w->any.cbfunc(w, w->any.cbcls); + } + break; + + default: + break; + } +} + +int rtk_input_key(rtk_widget *w, int key, int press) +{ + return 0; +} + +int rtk_input_mbutton(rtk_widget *w, int bn, int press, int x, int y) +{ + if(!hittest(w, x, y)) { + return 0; + } + + if(press) { + if(hover && hittest(hover, x, y)) { + setpress(hover); + } + } else { + if(pressed && hittest(pressed, x, y)) { + click(pressed, x, y); + } + setpress(0); + } + + return 1; +} + +int rtk_input_mmotion(rtk_widget *w, int x, int y) +{ + rtk_widget *c; + + if(!hittest(w, x, y)) { + int res = hover ? 1 : 0; + sethover(0); + return res; + } + + sethover(w); + + if(w->type == RTK_WIN) { + c = w->win.clist; + while(c) { + if(hittest(c, x, y)) { + return rtk_input_mmotion(c, x, y); + } + c = c->any.next; + } + } + + return 1; +} diff --git a/src/rtk.h b/src/rtk.h index 15b6c79..cdb128e 100644 --- a/src/rtk.h +++ b/src/rtk.h @@ -6,6 +6,7 @@ enum { RTK_ANY, RTK_WIN, RTK_BUTTON, RTK_LABEL, RTK_CHECKBOX, RTK_SLIDER, RTK_SE /* window layout */ enum { RTK_NONE, RTK_VBOX, RTK_HBOX }; +typedef struct rtk_screen rtk_screen; typedef union rtk_widget rtk_widget; typedef struct rtk_icon rtk_icon; typedef struct rtk_iconsheet rtk_iconsheet; @@ -36,7 +37,6 @@ typedef void (*rtk_callback)(rtk_widget*, void*); void rtk_setup(rtk_draw_ops *drawop); /* widget functions */ - rtk_widget *rtk_create_widget(void); void rtk_free_widget(rtk_widget *w); @@ -84,5 +84,9 @@ rtk_icon *rtk_lookup_icon(rtk_iconsheet *is, const char *name); void rtk_draw_widget(rtk_widget *w); +/* input events */ +int rtk_input_key(rtk_widget *w, int key, int press); +int rtk_input_mbutton(rtk_widget *w, int bn, int press, int x, int y); +int rtk_input_mmotion(rtk_widget *w, int x, int y); #endif /* RTK_H_ */ diff --git a/src/rtk_impl.h b/src/rtk_impl.h index 9afa913..5e65ac2 100644 --- a/src/rtk_impl.h +++ b/src/rtk_impl.h @@ -8,6 +8,8 @@ enum { VISIBLE = 0x001, ENABLED = 0x002, + HOVER = 0x010, + PRESS = 0x020, GEOMCHG = 0x100, DIRTY = 0x200 }; diff --git a/src/scene.c b/src/scene.c new file mode 100644 index 0000000..4f78861 --- /dev/null +++ b/src/scene.c @@ -0,0 +1,136 @@ +/* +RetroRay - integrated standalone vintage modeller/renderer +Copyright (C) 2023 John Tsiombikas + +This program is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program. If not, see . +*/ +#include +#include "scene.h" +#include "darray.h" +#include "logger.h" + +struct scene *create_scene(void) +{ + struct scene *scn; + + if(!(scn = malloc(sizeof *scn))) { + errormsg("failed to allocate scene\n"); + return 0; + } + scn->objects = darr_alloc(0, sizeof *scn->objects); + + return scn; +} + +void free_scene(struct scene *scn) +{ + int i; + + if(!scn) return; + + for(i=0; iobjects); i++) { + free_object(scn->objects[i]); + } + darr_free(scn->objects); + free(scn); +} + +int scn_add_object(struct scene *scn, struct object *obj) +{ + darr_push(scn->objects, &obj); + return 0; +} + +int scn_num_objects(struct scene *scn) +{ + return darr_size(scn->objects); +} + +struct object *create_object(int type) +{ + struct object *obj; + struct sphere *sph; + char buf[32]; + static int objid; + + if(!(obj = malloc(sizeof *obj))) { + errormsg("failed to allocate object\n"); + return 0; + } + obj->type = type; + + cgm_vcons(&obj->pos, 0, 0, 0); + cgm_qcons(&obj->rot, 0, 0, 0, 1); + cgm_vcons(&obj->scale, 1, 1, 1); + cgm_vcons(&obj->pivot, 0, 0, 0); + cgm_midentity(obj->xform); + + switch(type) { + case OBJ_SPHERE: + sph = (struct sphere*)obj; + sph->rad = 1.0f; + sprintf(buf, "sphere%03d", objid); + break; + + default: + sprintf(buf, "object%03d", objid); + break; + } + + set_object_name(obj, buf); + objid++; + return obj; +} + +void free_object(struct object *obj) +{ + if(!obj) return; + + free(obj->name); + free(obj); +} + +int set_object_name(struct object *obj, const char *name) +{ + char *str = strdup(name); + if(!str) return -1; + + free(obj->name); + obj->name = str; + return 0; +} + +void calc_object_matrix(struct object *obj) +{ + int i; + float rmat[16]; + float *mat = obj->xform; + + cgm_mtranslation(mat, obj->pivot.x, obj->pivot.y, obj->pivot.z); + cgm_mrotation_quat(rmat, &obj->rot); + + for(i=0; i<3; i++) { + mat[i] = rmat[i]; + mat[4 + i] = rmat[4 + i]; + mat[8 + i] = rmat[8 + i]; + } + + mat[0] *= obj->scale.x; mat[4] *= obj->scale.y; mat[8] *= obj->scale.z; mat[12] += obj->pos.x; + mat[1] *= obj->scale.x; mat[5] *= obj->scale.y; mat[9] *= obj->scale.z; mat[13] += obj->pos.y; + mat[2] *= obj->scale.x; mat[6] *= obj->scale.y; mat[10] *= obj->scale.z; mat[14] += obj->pos.z; + + cgm_mpretranslate(mat, -obj->pivot.x, -obj->pivot.y, -obj->pivot.z); + + /* that's basically: pivot * rotation * translation * scaling * -pivot */ +} diff --git a/src/scene.h b/src/scene.h new file mode 100644 index 0000000..a1e81c2 --- /dev/null +++ b/src/scene.h @@ -0,0 +1,61 @@ +/* +RetroRay - integrated standalone vintage modeller/renderer +Copyright (C) 2023 John Tsiombikas + +This program is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program. If not, see . +*/ +#ifndef SCENE_H_ +#define SCENE_H_ + +#include "cgmath/cgmath.h" + +enum { + OBJ_NULL, + OBJ_SPHERE +}; + +#define OBJ_COMMON_ATTR \ + int type; \ + char *name; \ + cgm_vec3 pos, scale, pivot; \ + cgm_quat rot; \ + float xform[16] + +struct object { + OBJ_COMMON_ATTR; +}; + +struct sphere { + OBJ_COMMON_ATTR; + float rad; +}; + +struct scene { + struct object **objects; /* darr */ +}; + +struct scene *create_scene(void); +void free_scene(struct scene *scn); + +int scn_add_object(struct scene *scn, struct object *obj); +int scn_num_objects(struct scene *scn); + +struct object *create_object(int type); +void free_object(struct object *obj); + +int set_object_name(struct object *obj, const char *name); + +void calc_object_matrix(struct object *obj); + +#endif /* SCENE_H_ */ diff --git a/src/scr_mod.c b/src/scr_mod.c index 12d0d1e..8107650 100644 --- a/src/scr_mod.c +++ b/src/scr_mod.c @@ -18,12 +18,15 @@ along with this program. If not, see . #include "gaw/gaw.h" #include "app.h" #include "rtk.h" +#include "scene.h" +#include "cmesh.h" +#include "meshgen.h" enum { TBN_NEW, TBN_OPEN, TBN_SAVE, TBN_SEP1, - TBN_SEL, TBN_MOVE, TBL_ROT, TBN_SCALE, TBN_SEP2, - TBL_ADD, TBL_RM, TBN_SEP3, - TBN_MTL, TBN_REND, TBL_VIEWREND, TBN_SEP4, TBL_CFG, + TBN_SEL, TBN_MOVE, TBN_ROT, TBN_SCALE, TBN_SEP2, + TBN_ADD, TBN_RM, TBN_SEP3, + TBN_MTL, TBN_REND, TBN_VIEWREND, TBN_SEP4, TBN_CFG, NUM_TOOL_BUTTONS }; @@ -55,7 +58,7 @@ static void mdl_mouse(int bn, int press, int x, int y); static void mdl_motion(int x, int y); static void draw_grid(void); - +static void tbn_callback(rtk_widget *w, void *cls); struct app_screen scr_model = { "modeller", @@ -68,6 +71,8 @@ struct app_screen scr_model = { static rtk_widget *toolbar; static rtk_iconsheet *icons; +static struct cmesh *mesh_sph; + static float cam_theta, cam_phi = 20, cam_dist = 8; @@ -101,19 +106,32 @@ static int mdl_init(void) if(!(w = rtk_create_iconbutton(toolbar, tbn_icons[i], 0))) { return -1; } + rtk_set_callback(w, tbn_callback, (void*)i); } } + + if(!(mesh_sph = cmesh_alloc())) { + errormsg("failed to allocate sphere vis mesh\n"); + return -1; + } + gen_sphere(mesh_sph, 1.0f, 16, 8, 1.0f, 1.0f); return 0; } static void mdl_destroy(void) { + cmesh_free(mesh_sph); rtk_free_iconsheet(icons); } static int mdl_start(void) { gaw_clear_color(0.125, 0.125, 0.125, 1); + + gaw_enable(GAW_DEPTH_TEST); + gaw_enable(GAW_CULL_FACE); + gaw_enable(GAW_LIGHTING); + gaw_enable(GAW_LIGHT0); return 0; } @@ -123,6 +141,8 @@ static void mdl_stop(void) static void mdl_display(void) { + int i, num; + gaw_clear(GAW_COLORBUF | GAW_DEPTHBUF); rtk_draw_widget(toolbar); @@ -137,23 +157,55 @@ static void mdl_display(void) draw_grid(); + gaw_poly_wire(); + + num = scn_num_objects(scn); + for(i=0; iobjects[i]; + struct sphere *sph; + + calc_object_matrix(obj); + gaw_push_matrix(); + gaw_mult_matrix(obj->xform); + + switch(obj->type) { + case OBJ_SPHERE: + sph = (struct sphere*)obj; + gaw_scale(sph->rad, sph->rad, sph->rad); + cmesh_draw(mesh_sph); + break; + + default: + break; + } + + gaw_pop_matrix(); + } + + gaw_poly_gouraud(); + gaw_viewport(0, 0, win_width, win_height); } static void draw_grid(void) { + gaw_save(); + gaw_disable(GAW_LIGHTING); + gaw_begin(GAW_LINES); gaw_color3f(0.5, 0, 0); - gaw_vertex4f(0, 0, 0, 1); - gaw_vertex4f(-100, 0, 0, 1); - gaw_vertex4f(0, 0, 0, 1); - gaw_vertex4f(100, 0, 0, 1); + gaw_vertex3f(0, 0, 0); + gaw_vertex3f(-100, 0, 0); + gaw_vertex3f(0, 0, 0); + gaw_vertex3f(100, 0, 0); gaw_color3f(0, 0.5, 0); - gaw_vertex4f(0, 0, 0, 1); - gaw_vertex4f(0, 0, -100, 1); - gaw_vertex4f(0, 0, 0, 1); - gaw_vertex4f(0, 0, 100, 1); + gaw_vertex3f(0, 0, 0); + gaw_vertex3f(0, 0, -100); + gaw_vertex3f(0, 0, 0); + gaw_vertex3f(0, 0, 100); gaw_end(); + + gaw_restore(); } static void mdl_reshape(int x, int y) @@ -169,16 +221,39 @@ static void mdl_reshape(int x, int y) static void mdl_keyb(int key, int press) { + if(rtk_input_key(toolbar, key, press)) { + app_redisplay(); + return; + } } +static int vpdrag; + static void mdl_mouse(int bn, int press, int x, int y) { + if(!vpdrag && rtk_input_mbutton(toolbar, bn, press, x, y)) { + app_redisplay(); + return; + } + + if(press) { + vpdrag |= (1 << bn); + } else { + vpdrag &= ~(1 << bn); + } } static void mdl_motion(int x, int y) { - int dx = x - mouse_x; - int dy = y - mouse_y; + int dx, dy; + + if(!vpdrag && rtk_input_mmotion(toolbar, x, y)) { + app_redisplay(); + return; + } + + dx = x - mouse_x; + dy = y - mouse_y; if((dx | dy) == 0) return; @@ -196,3 +271,27 @@ static void mdl_motion(int x, int y) app_redisplay(); } } + +static void add_sphere(void) +{ + struct object *obj; + + if(!(obj = create_object(OBJ_SPHERE))) { + return; + } + scn_add_object(scn, obj); +} + +static void tbn_callback(rtk_widget *w, void *cls) +{ + int id = (intptr_t)cls; + + switch(id) { + case TBN_ADD: + add_sphere(); + break; + + default: + break; + } +}