git.mutantstargoat.com Git - dosdemo/blob - src/mesh.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <math.h>
   4 #include "mesh.h"
   5 #include "3dgfx.h"
   6
   7 int load_mesh(struct g3d_mesh *mesh, const char *fname)
   8 {
   9         return -1;      /* TODO */
  10 }
  11
  12 static struct {
  13         struct g3d_vertex *varr;
  14         const float *xform;
  15 } zsort_cls;
  16
  17 static int zsort_cmp(const void *aptr, const void *bptr)
  18 {
  19         const float *m = zsort_cls.xform;
  20
  21         const struct g3d_vertex *va = (const struct g3d_vertex*)aptr;
  22         const struct g3d_vertex *vb = (const struct g3d_vertex*)bptr;
  23
  24         float za = m[2] * va->x + m[6] * va->y + m[10] * va->z + m[14];
  25         float zb = m[2] * vb->x + m[6] * vb->y + m[10] * vb->z + m[14];
  26
  27         ++va;
  28         ++vb;
  29
  30         za += m[2] * va->x + m[6] * va->y + m[10] * va->z + m[14];
  31         zb += m[2] * vb->x + m[6] * vb->y + m[10] * vb->z + m[14];
  32
  33         return za - zb;
  34 }
  35
  36 static int zsort_indexed_cmp(const void *aptr, const void *bptr)
  37 {
  38         const int16_t *a = (const int16_t*)aptr;
  39         const int16_t *b = (const int16_t*)bptr;
  40
  41         const float *m = zsort_cls.xform;
  42
  43         const struct g3d_vertex *va = zsort_cls.varr + a[0];
  44         const struct g3d_vertex *vb = zsort_cls.varr + b[0];
  45
  46         float za = m[2] * va->x + m[6] * va->y + m[10] * va->z + m[14];
  47         float zb = m[2] * vb->x + m[6] * vb->y + m[10] * vb->z + m[14];
  48
  49         va = zsort_cls.varr + a[2];
  50         vb = zsort_cls.varr + b[2];
  51
  52         za += m[2] * va->x + m[6] * va->y + m[10] * va->z + m[14];
  53         zb += m[2] * vb->x + m[6] * vb->y + m[10] * vb->z + m[14];
  54
  55         return za - zb;
  56 }
  57
  58
  59 void zsort_mesh(struct g3d_mesh *m)
  60 {
  61         zsort_cls.varr = m->varr;
  62         zsort_cls.xform = g3d_get_matrix(G3D_MODELVIEW, 0);
  63
  64         if(m->iarr) {
  65                 int nfaces = m->icount / m->prim;
  66                 qsort(m->iarr, nfaces, m->prim * sizeof *m->iarr, zsort_indexed_cmp);
  67         } else {
  68                 int nfaces = m->vcount / m->prim;
  69                 qsort(m->varr, nfaces, m->prim * sizeof *m->varr, zsort_cmp);
  70         }
  71 }
  72
  73
  74 void draw_mesh(struct g3d_mesh *mesh)
  75 {
  76         if(mesh->iarr) {
  77                 g3d_draw_indexed(mesh->prim, mesh->varr, mesh->vcount, mesh->iarr, mesh->icount);
  78         } else {
  79                 g3d_draw(mesh->prim, mesh->varr, mesh->vcount);
  80         }
  81 }
  82
  83
  84 #define NORMAL(vp, x, y, z) do { vp->nx = x; vp->ny = y; vp->nz = z; } while(0)
  85 #define COLOR(vp, cr, cg, cb) do { vp->r = cr; vp->g = cg; vp->b = cb; } while(0)
  86 #define TEXCOORD(vp, tu, tv) do { vp->u = tu; vp->v = tv; } while(0)
  87 #define VERTEX(vp, vx, vy, vz) \
  88         do { \
  89                 vp->x = vx; vp->y = vy; vp->z = vz; vp->w = 1.0f; \
  90                 ++vp; \
  91         } while(0)
  92
  93 int gen_cube(struct g3d_mesh *mesh, float sz, int sub)
  94 {
  95         struct g3d_vertex *vptr;
  96         float hsz = sz / 2.0;
  97
  98         mesh->prim = G3D_QUADS;
  99         mesh->iarr = 0;
 100         mesh->icount = 0;
 101
 102         mesh->vcount = 24;
 103         if(!(mesh->varr = malloc(mesh->vcount * sizeof *mesh->varr))) {
 104                 return -1;
 105         }
 106         vptr = mesh->varr;
 107
 108         /* -Z */
 109         NORMAL(vptr, 0, 0, -1);
 110         COLOR(vptr, 255, 0, 255);
 111         VERTEX(vptr, hsz, -hsz, -hsz);
 112         VERTEX(vptr, -hsz, -hsz, -hsz);
 113         VERTEX(vptr, -hsz, hsz, -hsz);
 114         VERTEX(vptr, hsz, hsz, -hsz);
 115         /* -Y */
 116         NORMAL(vptr, 0, -1, 0);
 117         COLOR(vptr, 0, 255, 255);
 118         VERTEX(vptr, -hsz, -hsz, -hsz);
 119         VERTEX(vptr, hsz, -hsz, -hsz);
 120         VERTEX(vptr, hsz, -hsz, hsz);
 121         VERTEX(vptr, -hsz, -hsz, hsz);
 122         /* -X */
 123         NORMAL(vptr, -1, 0, 0);
 124         COLOR(vptr, 255, 255, 0);
 125         VERTEX(vptr, -hsz, -hsz, -hsz);
 126         VERTEX(vptr, -hsz, -hsz, hsz);
 127         VERTEX(vptr, -hsz, hsz, hsz);
 128         VERTEX(vptr, -hsz, hsz, -hsz);
 129         /* +X */
 130         NORMAL(vptr, 1, 0, 0);
 131         COLOR(vptr, 255, 0, 0);
 132         VERTEX(vptr, hsz, -hsz, hsz);
 133         VERTEX(vptr, hsz, -hsz, -hsz);
 134         VERTEX(vptr, hsz, hsz, -hsz);
 135         VERTEX(vptr, hsz, hsz, hsz);
 136         /* +Y */
 137         NORMAL(vptr, 0, 1, 0);
 138         COLOR(vptr, 0, 255, 0);
 139         VERTEX(vptr, -hsz, hsz, hsz);
 140         VERTEX(vptr, hsz, hsz, hsz);
 141         VERTEX(vptr, hsz, hsz, -hsz);
 142         VERTEX(vptr, -hsz, hsz, -hsz);
 143         /* +Z */
 144         NORMAL(vptr, 0, 0, 1);
 145         COLOR(vptr, 0, 0, 255);
 146         VERTEX(vptr, -hsz, -hsz, hsz);
 147         VERTEX(vptr, hsz, -hsz, hsz);
 148         VERTEX(vptr, hsz, hsz, hsz);
 149         VERTEX(vptr, -hsz, hsz, hsz);
 150
 151         return 0;
 152 }
 153
 154 static void torusvec(float *res, float theta, float phi, float mr, float rr)
 155 {
 156         float rx, ry, rz;
 157         theta = -theta;
 158
 159         rx = -cos(phi) * rr + mr;
 160         ry = sin(phi) * rr;
 161         rz = 0.0f;
 162
 163         res[0] = rx * sin(theta) + rz * cos(theta);
 164         res[1] = ry;
 165         res[2] = -rx * cos(theta) + rz * sin(theta);
 166 }
 167
 168 int gen_torus(struct g3d_mesh *mesh, float rad, float ringrad, int usub, int vsub)
 169 {
 170         int i, j;
 171         int nfaces, uverts, vverts;
 172         struct g3d_vertex *vptr;
 173         int16_t *iptr;
 174
 175         mesh->prim = G3D_QUADS;
 176
 177         if(usub < 4) usub = 4;
 178         if(vsub < 2) vsub = 2;
 179
 180         uverts = usub + 1;
 181         vverts = vsub + 1;
 182
 183         mesh->vcount = uverts * vverts;
 184         nfaces = usub * vsub;
 185         mesh->icount = nfaces * 4;
 186
 187         printf("generating torus with %d faces (%d vertices)\n", nfaces, mesh->vcount);
 188
 189         if(!(mesh->varr = malloc(mesh->vcount * sizeof *mesh->varr))) {
 190                 return -1;
 191         }
 192         if(!(mesh->iarr = malloc(mesh->icount * sizeof *mesh->iarr))) {
 193                 return -1;
 194         }
 195         vptr = mesh->varr;
 196         iptr = mesh->iarr;
 197
 198         for(i=0; i<uverts; i++) {
 199                 float u = (float)i / (float)(uverts - 1);
 200                 float theta = u * 2.0 * M_PI;
 201                 float rcent[3];
 202
 203                 torusvec(rcent, theta, 0, rad, 0);
 204
 205                 for(j=0; j<vverts; j++) {
 206                         float v = (float)j / (float)(vverts - 1);
 207                         float phi = v * 2.0 * M_PI;
 208                         int chess = (i & 1) == (j & 1);
 209
 210                         torusvec(&vptr->x, theta, phi, rad, ringrad);
 211
 212                         vptr->nx = (vptr->x - rcent[0]) / ringrad;
 213                         vptr->ny = (vptr->y - rcent[1]) / ringrad;
 214                         vptr->nz = (vptr->z - rcent[2]) / ringrad;
 215                         vptr->u = u;
 216                         vptr->v = v;
 217                         vptr->r = chess ? 255 : 64;
 218                         vptr->g = 128;
 219                         vptr->b = chess ? 64 : 255;
 220                         ++vptr;
 221
 222                         if(i < usub && j < vsub) {
 223                                 int idx = i * vverts + j;
 224                                 *iptr++ = idx;
 225                                 *iptr++ = idx + 1;
 226                                 *iptr++ = idx + vverts + 1;
 227                                 *iptr++ = idx + vverts;
 228                         }
 229                 }
 230         }
 231         return 0;
 232 }
 233