uint32_t *framebuf;
+struct scene *scn;
/* available screens */
#define MAX_SCREENS 8
rtk_setup(&guigfx);
+ if(!(scn = create_scene())) {
+ return -1;
+ }
+
/* initialize screens */
screens[num_screens++] = &scr_model;
screens[num_screens++] = &scr_rend;
gaw_sw_destroy();
#endif
+ free_scene(scn);
+
cleanup_logger();
}
#include "sizeint.h"
#include "logger.h"
+#include "scene.h"
enum {
KEY_ESC = 27,
extern uint32_t *framebuf;
+extern struct scene *scn;
+
int app_init(void);
void app_shutdown(void);
--- /dev/null
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <limits.h>
+#include <float.h>
+#include <assert.h>
+#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; i<CMESH_NUM_ATTR; i++) {
+ sdr_loc[i] = -1;
+ }
+}
+#endif /* USE_SDR */
+
+/* mesh functions */
+struct cmesh *cmesh_alloc(void)
+{
+ struct cmesh *cm;
+
+ if(!(cm = malloc(sizeof *cm))) {
+ return 0;
+ }
+ if(cmesh_init(cm) == -1) {
+ free(cm);
+ return 0;
+ }
+ return cm;
+}
+
+void cmesh_free(struct cmesh *cm)
+{
+ cmesh_destroy(cm);
+ free(cm);
+}
+
+int cmesh_init(struct cmesh *cm)
+{
+#ifdef USE_VBO
+ int i;
+#endif
+
+ memset(cm, 0, sizeof *cm);
+ cgm_wcons(cm->cur_val + CMESH_ATTR_COLOR, 1, 1, 1, 1);
+
+#ifdef USE_VBO
+ glGenBuffers(CMESH_NUM_ATTR + 1, cm->buffer_objects);
+
+ for(i=0; i<CMESH_NUM_ATTR; i++) {
+ cm->vattr[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; i<CMESH_NUM_ATTR; i++) {
+ free(cm->vattr[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; i<CMESH_NUM_ATTR; i++) {
+ cm->vattr[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; i<CMESH_NUM_ATTR; i++) {
+ if(cmesh_has_attrib(cmsrc, i)) {
+ nelem = cmsrc->vattr[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; i<CMESH_NUM_ATTR; i++) {
+ free(cmdest->vattr[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; i<icount; i++) {
+ cmdest->idata[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; i<cm->vattr[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; i<CMESH_NUM_ATTR; i++) {
+ cm->vattr[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; i<CMESH_NUM_ATTR; i++) {
+ if(cmesh_has_attrib(cmdest, i) && cmesh_has_attrib(cmsrc, i)) {
+ /* force validation of the data arrays */
+ cmesh_attrib(cmdest, i);
+ cmesh_attrib_ro(cmsrc, i);
+
+ assert(cmdest->vattr[i].nelem == cmsrc->vattr[i].nelem);
+ nelem = cmdest->vattr[i].nelem;
+ origsz = cmdest->nverts * nelem;
+ newsz = (cmdest->nverts + cmsrc->nverts) * nelem;
+
+ if(!(vptr = 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; i<srcsz; i++) {
+ *iptr++ = cmsrc->idata[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; i<sm->icount; 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; i<CMESH_NUM_ATTR; i++) {
+ if(cm->vattr[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; i<cm->vattr[attr].nelem; i++) {
+ *dptr++ = sptr[i];
+ }
+ return sptr;
+}
+
+static float *get_vec3(struct cmesh *cm, int attr, int idx, cgm_vec3 *res)
+{
+ int i;
+ float *sptr, *dptr;
+ cgm_vcons(res, 0, 0, 0);
+ if(!(sptr = cmesh_attrib_at(cm, attr, idx))) {
+ return 0;
+ }
+ dptr = &res->x;
+
+ for(i=0; i<cm->vattr[attr].nelem; i++) {
+ *dptr++ = sptr[i];
+ }
+ return sptr;
+}
+
+/* dir_xform can be null, in which case it's calculated from xform */
+void cmesh_apply_xform(struct cmesh *cm, float *xform, float *dir_xform)
+{
+ unsigned int i;
+ int j;
+ cgm_vec4 v;
+ cgm_vec3 n, t;
+ float *vptr;
+
+ if(!dir_xform) {
+ dir_xform = xform;
+ }
+
+ for(i=0; i<cm->nverts; i++) {
+ if(!(vptr = get_vec4(cm, CMESH_ATTR_VERTEX, i, &v))) {
+ return;
+ }
+ cgm_wmul_m4v4(&v, xform);
+ for(j=0; j<cm->vattr[CMESH_ATTR_VERTEX].nelem; j++) {
+ *vptr++ = (&v.x)[j];
+ }
+
+ if(cmesh_has_attrib(cm, CMESH_ATTR_NORMAL)) {
+ if((vptr = get_vec3(cm, CMESH_ATTR_NORMAL, i, &n))) {
+ cgm_vmul_m3v3(&n, dir_xform);
+ for(j=0; j<cm->vattr[CMESH_ATTR_NORMAL].nelem; j++) {
+ *vptr++ = (&n.x)[j];
+ }
+ }
+ }
+ if(cmesh_has_attrib(cm, CMESH_ATTR_TANGENT)) {
+ if((vptr = get_vec3(cm, CMESH_ATTR_TANGENT, i, &t))) {
+ cgm_vmul_m3v3(&t, dir_xform);
+ for(j=0; j<cm->vattr[CMESH_ATTR_TANGENT].nelem; j++) {
+ *vptr++ = (&t.x)[j];
+ }
+ }
+ }
+ }
+}
+
+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; i<idxnum; i+=3) {
+ unsigned int tmp = indices[i + 2];
+ indices[i + 2] = indices[i + 1];
+ indices[i + 1] = tmp;
+ }
+ } else {
+ if(!(verts = cmesh_attrib(cm, CMESH_ATTR_VERTEX))) {
+ return;
+ }
+ vnum = cmesh_attrib_count(cm, CMESH_ATTR_VERTEX);
+ nelem = cm->vattr[CMESH_ATTR_VERTEX].nelem;
+ for(i=0; i<vnum; i+=3) {
+ for(j=0; j<nelem; j++) {
+ vptr = verts + (i + 1) * nelem + j;
+ float tmp = vptr[nelem];
+ vptr[nelem] = vptr[0];
+ vptr[0] = tmp;
+ }
+ }
+ }
+}
+void cmesh_flip_normals(struct cmesh *cm)
+{
+ int i, num;
+ float *nptr = cmesh_attrib(cm, CMESH_ATTR_NORMAL);
+ if(!nptr) return;
+
+ num = cm->nverts * cm->vattr[CMESH_ATTR_NORMAL].nelem;
+ for(i=0; i<num; i++) {
+ *nptr = -*nptr;
+ nptr++;
+ }
+}
+
+int cmesh_explode(struct cmesh *cm)
+{
+ int i, j, k, idxnum, nnverts;
+ unsigned int *indices;
+
+ if(!cmesh_indexed(cm)) return 0;
+
+ indices = cmesh_index(cm);
+ assert(indices);
+
+ idxnum = cmesh_index_count(cm);
+ nnverts = idxnum;
+
+ for(i=0; i<CMESH_NUM_ATTR; i++) {
+ const float *srcbuf;
+ float *tmpbuf, *dstptr;
+
+ if(!cmesh_has_attrib(cm, i)) continue;
+
+ srcbuf = cmesh_attrib(cm, i);
+ if(!(tmpbuf = malloc(nnverts * cm->vattr[i].nelem * sizeof(float)))) {
+ return -1;
+ }
+ dstptr = tmpbuf;
+
+ for(j=0; j<idxnum; j++) {
+ unsigned int idx = indices[j];
+ const float *srcptr = srcbuf + idx * cm->vattr[i].nelem;
+
+ for(k=0; k<cm->vattr[i].nelem; k++) {
+ *dstptr++ = *srcptr++;
+ }
+ }
+
+ free(cm->vattr[i].data);
+ cm->vattr[i].data = tmpbuf;
+ cm->vattr[i].count = nnverts * cm->vattr[i].nelem;
+ cm->vattr[i].data_valid = 1;
+ }
+
+#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<CMESH_NUM_ATTR; i++) {
+ loc = sdr_loc[i];
+ if(loc >= 0 && cm->vattr[i].vbo_valid) {
+ glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[i].vbo);
+ glVertexAttribPointer(loc, cm->vattr[i].nelem, GL_FLOAT, GL_FALSE, 0, 0);
+ glEnableVertexAttribArray(loc);
+ }
+ }
+ } else {
+#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<CMESH_NUM_ATTR; i++) {
+ int loc = sdr_loc[i];
+ if(loc >= 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; i<cm->nverts; i++) {
+ float x, y, z, endx, endy, endz;
+
+ x = varr[i * vert_nelem];
+ y = varr[i * vert_nelem + 1];
+ z = varr[i * vert_nelem + 2];
+ endx = x + norm[i * norm_nelem] * len;
+ endy = y + norm[i * norm_nelem + 1] * len;
+ endz = z + norm[i * norm_nelem + 2] * len;
+
+#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; i<cm->nverts; i++) {
+ float x, y, z, endx, endy, endz;
+
+ x = varr[i * vert_nelem];
+ y = varr[i * vert_nelem + 1];
+ z = varr[i * vert_nelem + 2];
+ endx = x + tang[i * tang_nelem] * len;
+ endy = y + tang[i * tang_nelem + 1] * len;
+ endz = z + tang[i * tang_nelem + 2] * len;
+
+#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; i<CMESH_NUM_ATTR; i++) {
+ if(cmesh_has_attrib(cm, i) && !cm->vattr[i].vbo_valid) {
+ glBindBuffer(GL_ARRAY_BUFFER, cm->vattr[i].vbo);
+ glBufferData(GL_ARRAY_BUFFER, cm->nverts * cm->vattr[i].nelem * sizeof(float),
+ cm->vattr[i].data, GL_STATIC_DRAW);
+ cm->vattr[i].vbo_valid = 1;
+ }
+ }
+ glBindBuffer(GL_ARRAY_BUFFER, 0);
+
+ if(cm->idata_valid && !cm->ibo_valid) {
+ glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cm->ibo);
+ glBufferData(GL_ELEMENT_ARRAY_BUFFER, cm->nfaces * 3 * sizeof(unsigned int),
+ cm->idata, GL_STATIC_DRAW);
+ cm->ibo_valid = 1;
+ glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+ }
+
+#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; i<num_faces; i++) {
+ *dest++ = idxarr[0];
+ *dest++ = idxarr[1];
+ *dest++ = idxarr[1];
+ *dest++ = idxarr[2];
+ *dest++ = idxarr[2];
+ *dest++ = idxarr[0];
+ idxarr += 3;
+ }
+ } else {
+ /* not an indexed mesh */
+ for(i=0; i<num_faces; i++) {
+ int vidx = i * 3;
+ *dest++ = vidx;
+ *dest++ = vidx + 1;
+ *dest++ = vidx + 1;
+ *dest++ = vidx + 2;
+ *dest++ = vidx + 2;
+ *dest++ = vidx;
+ }
+ }
+
+ glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cm->wire_ibo);
+ glBufferData(GL_ELEMENT_ARRAY_BUFFER, num_faces * 6 * sizeof(unsigned int),
+ wire_idxarr, GL_STATIC_DRAW);
+ free(wire_idxarr);
+ cm->wire_ibo_valid = 1;
+ glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+}
+#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; i<cm->nverts; i++) {
+ const float *v = cmesh_attrib_at_ro(cm, CMESH_ATTR_VERTEX, i);
+ for(j=0; j<3; j++) {
+ if(v[j] < (&cm->aabb_min.x)[j]) {
+ (&cm->aabb_min.x)[j] = v[j];
+ }
+ if(v[j] > (&cm->aabb_max.x)[j]) {
+ (&cm->aabb_max.x)[j] = v[j];
+ }
+ }
+ }
+ cm->aabb_valid = 1;
+}
+
+void cmesh_aabbox(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; i<cm->nverts; i++) {
+ const float *v = cmesh_attrib_at_ro(cm, CMESH_ATTR_VERTEX, i);
+ cm->bsph_center.x += v[0];
+ cm->bsph_center.y += v[1];
+ cm->bsph_center.z += v[2];
+ }
+ s = 1.0f / (float)cm->nverts;
+ cm->bsph_center.x *= s;
+ cm->bsph_center.y *= s;
+ cm->bsph_center.z *= s;
+
+ cm->bsph_radius = 0.0f;
+ for(i=0; i<cm->nverts; i++) {
+ const cgm_vec3 *v = (const cgm_vec3*)cmesh_attrib_at_ro(cm, CMESH_ATTR_VERTEX, i);
+ if((dist_sq = cgm_vdist_sq(v, &cm->bsph_center)) > cm->bsph_radius) {
+ cm->bsph_radius = dist_sq;
+ }
+ }
+ cm->bsph_radius = sqrt(cm->bsph_radius);
+ cm->bsph_valid = 1;
+}
+
+float cmesh_bsphere(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; i<cm->nverts; i++) {
+ fprintf(fp, "%5u:", i);
+ for(j=0; j<CMESH_NUM_ATTR; j++) {
+ if(cmesh_has_attrib(cm, j)) {
+ const float *v = cmesh_attrib_at_ro(cm, j, i);
+ int nelem = cm->vattr[j].nelem;
+ fprintf(fp, elemfmt[nelem], label[j], v[0], nelem > 1 ? v[1] : 0.0f,
+ nelem > 2 ? v[2] : 0.0f, nelem > 3 ? v[3] : 0.0f);
+ }
+ }
+ fputc('\n', fp);
+ }
+
+ if(cmesh_indexed(cm)) {
+ const unsigned int *idx = cmesh_index_ro(cm);
+ int numidx = cmesh_index_count(cm);
+ int numtri = numidx / 3;
+ assert(numidx % 3 == 0);
+
+ fprintf(fp, "FACES\n");
+
+ for(i=0; i<numtri; i++) {
+ fprintf(fp, "%5d: %d %d %d\n", i, idx[0], idx[1], idx[2]);
+ idx += 3;
+ }
+ }
+ return 0;
+}
+
+int cmesh_dump_obj(const struct cmesh *cm, const char *fname)
+{
+ FILE *fp = fopen(fname, "wb");
+ if(fp) {
+ int res = cmesh_dump_obj_file(cm, fp, 0);
+ fclose(fp);
+ return res;
+ }
+ return -1;
+}
+
+#define HAS_VN 1
+#define HAS_VT 2
+
+int cmesh_dump_obj_file(const struct cmesh *cm, FILE *fp, int voffs)
+{
+ static const char *fmtstr[] = {" %u", " %u//%u", " %u/%u", " %u/%u/%u"};
+ int i, j, num, nelem;
+ unsigned int aflags = 0;
+
+ if(!cmesh_has_attrib(cm, CMESH_ATTR_VERTEX)) {
+ return -1;
+ }
+
+
+ nelem = cm->vattr[CMESH_ATTR_VERTEX].nelem;
+ if((num = cm->vattr[CMESH_ATTR_VERTEX].count) != cm->nverts * nelem) {
+ fprintf(stderr, "vertex array size (%d) != nverts (%d)\n", num, cm->nverts);
+ }
+ for(i=0; i<cm->nverts; i++) {
+ const float *v = cmesh_attrib_at_ro(cm, CMESH_ATTR_VERTEX, i);
+ fprintf(fp, "v %f %f %f\n", v[0], nelem > 1 ? v[1] : 0.0f, nelem > 2 ? v[2] : 0.0f);
+ }
+
+ if(cmesh_has_attrib(cm, CMESH_ATTR_NORMAL)) {
+ aflags |= HAS_VN;
+ nelem = cm->vattr[CMESH_ATTR_NORMAL].nelem;
+ if((num = cm->vattr[CMESH_ATTR_NORMAL].count) != cm->nverts * nelem) {
+ fprintf(stderr, "normal array size (%d) != nverts (%d)\n", num, cm->nverts);
+ }
+ for(i=0; i<cm->nverts; i++) {
+ const float *v = cmesh_attrib_at_ro(cm, CMESH_ATTR_NORMAL, i);
+ fprintf(fp, "vn %f %f %f\n", v[0], nelem > 1 ? v[1] : 0.0f, nelem > 2 ? v[2] : 0.0f);
+ }
+ }
+
+ if(cmesh_has_attrib(cm, CMESH_ATTR_TEXCOORD)) {
+ aflags |= HAS_VT;
+ nelem = cm->vattr[CMESH_ATTR_TEXCOORD].nelem;
+ if((num = cm->vattr[CMESH_ATTR_TEXCOORD].count) != cm->nverts * nelem) {
+ fprintf(stderr, "texcoord array size (%d) != nverts (%d)\n", num, cm->nverts);
+ }
+ for(i=0; i<cm->nverts; i++) {
+ const float *v = cmesh_attrib_at_ro(cm, CMESH_ATTR_TEXCOORD, i);
+ fprintf(fp, "vt %f %f\n", v[0], nelem > 1 ? v[1] : 0.0f);
+ }
+ }
+
+ if(cmesh_indexed(cm)) {
+ const unsigned int *idxptr = cmesh_index_ro(cm);
+ int numidx = cmesh_index_count(cm);
+ int numtri = numidx / 3;
+ assert(numidx % 3 == 0);
+
+ for(i=0; i<numtri; i++) {
+ fputc('f', fp);
+ for(j=0; j<3; j++) {
+ unsigned int idx = *idxptr++ + 1 + voffs;
+ fprintf(fp, fmtstr[aflags], idx, idx, idx);
+ }
+ fputc('\n', fp);
+ }
+ } else {
+ int numtri = cm->nverts / 3;
+ unsigned int idx = 1 + voffs;
+ for(i=0; i<numtri; i++) {
+ fputc('f', fp);
+ for(j=0; j<3; j++) {
+ fprintf(fp, fmtstr[aflags], idx, idx, idx);
+ ++idx;
+ }
+ fputc('\n', fp);
+ }
+ }
+ return 0;
+}
--- /dev/null
+#ifndef CMESH_H_
+#define CMESH_H_
+
+#include <stdio.h>
+#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_ */
/*
-Deep Runner - 6dof shooter game for the SGI O2.
+RetroRay - integrated standalone vintage modeller/renderer
Copyright (C) 2023 John Tsiombikas <nuclear@mutantstargoat.com>
This program is free software: you can redistribute it and/or modify
/*
-Deep Runner - 6dof shooter game for the SGI O2.
+RetroRay - integrated standalone vintage modeller/renderer
Copyright (C) 2023 John Tsiombikas <nuclear@mutantstargoat.com>
This program is free software: you can redistribute it and/or modify
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
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; i<nverts - 1; i++) {
- x0 = v->x >> 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)
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))
}
}
}
+
+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;
+ }
+ }
+}
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_ */
--- /dev/null
+#include <stdio.h>
+#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; i<uverts; i++) {
+ theta = u * 2.0 * M_PI;
+
+ v = 0.0;
+ for(j=0; j<vverts; j++) {
+ phi = v * M_PI;
+
+ sphvec(&pos, theta, phi);
+
+ *narr++ = pos;
+ cgm_vscale(&pos, rad);
+ *varr++ = pos;
+ sphvec(&v0, theta - 0.1f, (float)M_PI / 2.0f);
+ sphvec(&v1, theta + 0.1f, (float)M_PI / 2.0f);
+ cgm_vsub(&v1, &v0);
+ cgm_vnormalize(&v1);
+ *tarr++ = v1;
+ uvarr->x = 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; i<num_tri; i++) {
+ for(j=0; j<3; j++) {
+ vidx = icosa_idx[i * 3 + j];
+ v[j] = icosa_pt[vidx];
+ cgm_vnormalize(v + j);
+ }
+
+ if(hemi && (v[0].y < 0.0 || v[1].y < 0.0 || v[2].y < 0.0)) {
+ continue;
+ }
+
+ geosphere(verts, v, v + 1, v + 2, subdiv);
+ }
+
+ num_verts = darr_size(verts);
+
+ 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);
+
+ for(i=0; i<num_verts; i++) {
+ *varr = verts[i];
+ cgm_vscale(varr++, rad);
+ *narr++ = verts[i];
+
+ theta = atan2(verts[i].z, verts[i].x);
+ phi = acos(verts[i].y);
+
+ sphvec(&v0, theta - 0.1f, (float)M_PI / 2.0f);
+ sphvec(&v1, theta + 0.1f, (float)M_PI / 2.0f);
+ cgm_vsub(&v1, &v0);
+ cgm_vnormalize(&v1);
+ *tarr++ = v1;
+
+ uvarr->x = 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; i<uverts; i++) {
+ theta = u * 2.0 * M_PI;
+
+ v = 0.0;
+ for(j=0; j<vverts; j++) {
+ phi = v * 2.0 * M_PI;
+
+ torusvec(&pos, theta, phi, mainrad, ringrad);
+ torusvec(¢, theta, phi, mainrad, 0.0);
+
+ *varr++ = pos;
+ *narr = pos;
+ cgm_vsub(narr, ¢);
+ cgm_vscale(narr, 1.0f / ringrad);
+ narr++;
+
+ torusvec(&vprev, theta - 0.1f, phi, mainrad, ringrad);
+ torusvec(tarr, theta + 0.1f, phi, mainrad, ringrad);
+ cgm_vsub(tarr, &vprev);
+ cgm_vnormalize(tarr);
+ tarr++;
+
+ uvarr->x = 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; i<uverts; i++) {
+ theta = SURAD(u);
+
+ v = 0.0f;
+ for(j=0; j<vverts; j++) {
+ y = (v - 0.5) * height;
+ cylvec(&pos, theta, y);
+
+ cgm_vcons(varr++, pos.x * rad, pos.y, pos.z * rad);
+ cgm_vcons(narr++, pos.x, 0.0f, pos.z);
+ cylvec(&vprev, theta - 0.1f, 0.0f);
+ cylvec(tarr, theta + 0.1f, 0.0f);
+ cgm_vsub(tarr, &vprev);
+ cgm_vnormalize(tarr++);
+ uvarr->x = 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; i<uverts; i++) {
+ theta = SURAD(u);
+
+ v = 0.0;
+ for(j=0; j<capvverts; j++) {
+ r = v * rad;
+
+ cylvec(&pos, theta, height / 2.0f);
+ cgm_vscale(&pos, r);
+ pos.y = height / 2.0;
+ cylvec(&vprev, theta - 0.1f, 0.0f);
+ cylvec(&tang, theta + 0.1f, 0.0f);
+ cgm_vsub(&tang, &vprev);
+ cgm_vnormalize(&tang);
+
+ *varr++ = pos;
+ cgm_vcons(narr++, 0, 1, 0);
+ *tarr++ = tang;
+ uvarr->x = 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; i<uverts; i++) {
+ theta = SURAD(u);
+
+ v = 0.0;
+ for(j=0; j<vverts; j++) {
+ y = v * height;
+ conevec(&pos, theta, y, height);
+
+ conevec(&vprev, theta - 0.1f, 0.0f, height);
+ conevec(&tang, theta + 0.1f, 0.0f, height);
+ cgm_vsub(&tang, &vprev);
+ cgm_vnormalize(&tang);
+ conevec(&bitang, theta, y + 0.1f, height);
+ cgm_vsub(&bitang, &pos);
+ cgm_vnormalize(&bitang);
+
+ cgm_vcons(varr++, pos.x * rad, pos.y, pos.z * rad);
+ cgm_vcross(narr++, &tang, &bitang);
+ *tarr++ = tang;
+ uvarr->x = 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; i<uverts; i++) {
+ theta = SURAD(u);
+
+ v = 0.0;
+ for(j=0; j<capvverts; j++) {
+ r = v * rad;
+
+ conevec(&pos, theta, 0.0f, height);
+ cgm_vscale(&pos, r);
+ cylvec(&vprev, theta - 0.1f, 0.0f);
+ cylvec(&tang, theta + 0.1f, 0.0f);
+ cgm_vsub(&tang, &vprev);
+ cgm_vnormalize(&tang);
+
+ *varr++ = pos;
+ cgm_vcons(narr++, 0, -1, 0);
+ *tarr++ = tang;
+ uvarr->x = 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; i<uverts; i++) {
+ v = 0.0;
+ for(j=0; j<vverts; j++) {
+ x = (u - 0.5) * width;
+ y = (v - 0.5) * height;
+ z = hf ? hf(u, v, hfdata) : 0.0;
+
+ cgm_vcons(&normal, 0, 0, 1);
+ if(hf) {
+ u1z = hf(u + du, v, hfdata);
+ v1z = hf(u, v + dv, hfdata);
+
+ cgm_vcons(&tang, du * width, 0, u1z - z);
+ cgm_vcons(&bitan, 0, dv * height, v1z - z);
+ cgm_vcross(&normal, &tang, &bitan);
+ cgm_vnormalize(&normal);
+ }
+
+ cgm_vcons(varr++, x, y, z);
+ *narr++ = normal;
+ cgm_vcons(tarr++, 1, 0, 0);
+ 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;
+ }
+}
+
+/* ----- 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<uverts; i++) {
+ v = 0.0f;
+ for(j=0; j<vverts; j++) {
+ rev_vert(&pos, u, v, rfunc, cls);
+
+ rev_vert(&nextu, fmod(u + du, 1.0), v, rfunc, cls);
+ tang = nextu;
+ cgm_vsub(&tang, &pos);
+ if(cgm_vlength_sq(&tang) < 1e-6) {
+ new_v = v > 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<uverts; i++) {
+ v = 0.0f;
+ for(j=0; j<vverts; j++) {
+ sweep_vert(&pos, u, v, height, sfunc, cls);
+
+ sweep_vert(&nextu, fmod(u + du, 1.0), v, height, sfunc, cls);
+ tang = nextu;
+ cgm_vsub(&tang, &pos);
+ if(cgm_vlength_sq(&tang) < 1e-6f) {
+ new_v = v > 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;
+ }
+}
--- /dev/null
+#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_ */
--- /dev/null
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <assert.h>
+#include "cmesh.h"
+#include "sizeint.h"
+
+#ifdef USE_ASSIMP
+#include <assimp/cimport.h>
+#include <assimp/postprocess.h>
+#include <assimp/mesh.h>
+#include <assimp/scene.h>
+#include <assimp/types.h>
+#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; i<aim->mNumVertices; 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; i<aim->mNumFaces; 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
--- /dev/null
+/*
+rbtree - simple balanced binary search tree (red-black tree) library.
+Copyright (C) 2011-2014 John Tsiombikas <nuclear@member.fsf.org>
+
+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 <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#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;
+}
--- /dev/null
+/*
+rbtree - simple balanced binary search tree (red-black tree) library.
+Copyright (C) 2011-2014 John Tsiombikas <nuclear@member.fsf.org>
+
+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_ */
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;
}
#define COL_BG 0xff666666
+#define COL_BGHL 0xff808080
#define COL_LBEV 0xffaaaaaa
#define COL_SBEV 0xff222222
#define COL_TEXT 0xff000000
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++;
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);
}
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;
+}
/* 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;
void rtk_setup(rtk_draw_ops *drawop);
/* widget functions */
-
rtk_widget *rtk_create_widget(void);
void rtk_free_widget(rtk_widget *w);
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_ */
enum {
VISIBLE = 0x001,
ENABLED = 0x002,
+ HOVER = 0x010,
+ PRESS = 0x020,
GEOMCHG = 0x100,
DIRTY = 0x200
};
--- /dev/null
+/*
+RetroRay - integrated standalone vintage modeller/renderer
+Copyright (C) 2023 John Tsiombikas <nuclear@mutantstargoat.com>
+
+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 <https://www.gnu.org/licenses/>.
+*/
+#include <stdlib.h>
+#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; i<darr_size(scn->objects); 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 */
+}
--- /dev/null
+/*
+RetroRay - integrated standalone vintage modeller/renderer
+Copyright (C) 2023 John Tsiombikas <nuclear@mutantstargoat.com>
+
+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 <https://www.gnu.org/licenses/>.
+*/
+#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_ */
#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
};
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",
static rtk_widget *toolbar;
static rtk_iconsheet *icons;
+static struct cmesh *mesh_sph;
+
static float cam_theta, cam_phi = 20, cam_dist = 8;
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;
}
static void mdl_display(void)
{
+ int i, num;
+
gaw_clear(GAW_COLORBUF | GAW_DEPTHBUF);
rtk_draw_widget(toolbar);
draw_grid();
+ gaw_poly_wire();
+
+ num = scn_num_objects(scn);
+ for(i=0; i<num; i++) {
+ struct object *obj = scn->objects[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)
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;
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;
+ }
+}
projects / retroray / commitdiff