fog

[voxscape] / src / voxscape.c

diff --git a/src/voxscape.c b/src/voxscape.c
index 28a02bf..60d80a0 100644 (file)
--- a/src/voxscape.c
+++ b/src/voxscape.c
@@ -6,6 +6,7 @@
 #include <assert.h>
 #include <imago2.h>
 #include "voxscape.h"
+#include "lut.h"
 
 enum {
        SLICELEN        = 1
@@ -21,6 +22,7 @@ struct voxscape {
        uint32_t *fb;
        int fbwidth, fbheight;
        int *coltop;
+       int horizon;
 
        /* view */
        int32_t x, y, angle;
@@ -32,6 +34,9 @@ struct voxscape {
        int32_t *slicelen;
        int proj_dist;
 
+       int zfog;       /* fog start Z (0: no fog) */
+       int fogcolor[3];
+
        unsigned int valid;
 };
 
@@ -65,7 +70,7 @@ struct voxscape *vox_create(int xsz, int ysz)
                vox->xshift++;
        }
 
-       vox->vheight = 50;
+       vox->vheight = 80;
        vox->proj_dist = 4;     /* TODO */
 
        return vox;
@@ -75,7 +80,7 @@ struct voxscape *vox_open(const char *hfile, const char *cfile)
 {
        unsigned char *hpix;
        uint32_t *cpix;
-       int width, height, cwidth, cheight;
+       int i, width, height, cwidth, cheight;
        struct voxscape *vox;
 
        if(!(hpix = img_load_pixels(hfile, &width, &height, IMG_FMT_GREY8))) {
@@ -99,8 +104,12 @@ struct voxscape *vox_open(const char *hfile, const char *cfile)
                img_free_pixels(cpix);
                return 0;
        }
+
        memcpy(vox->height, hpix, width * height);
-       memcpy(vox->color, cpix, width * height * sizeof *vox->color);
+
+       for(i=0; i<width*height; i++) {
+               vox->color[i] = cpix[i] & 0xffffff;     /* discard alpha */
+       }
 
        img_free_pixels(hpix);
        img_free_pixels(cpix);
@@ -119,7 +128,24 @@ void vox_free(struct voxscape *vox)
        free(vox);
 }
 
-void vox_framebuf(struct voxscape *vox, int xres, int yres, uint32_t *fb)
+void vox_fog(struct voxscape *vox, int zstart, uint32_t color)
+{
+       vox->zfog = zstart;
+
+       vox->fogcolor[0] = color >> 16;
+       vox->fogcolor[1] = (color >> 8) & 0xff;
+       vox->fogcolor[2] = color & 0xff;
+}
+
+int vox_height(struct voxscape *vox, int32_t x, int32_t y)
+{
+       int tx = (x >> 16) & vox->xmask;
+       int ty = (y >> 16) & vox->ymask;
+
+       return vox->height[(ty << vox->xshift) + tx];
+}
+
+void vox_framebuf(struct voxscape *vox, int xres, int yres, uint32_t *fb, int horizon)
 {
        if(xres != vox->fbwidth) {
                free(vox->coltop);
@@ -131,14 +157,19 @@ void vox_framebuf(struct voxscape *vox, int xres, int yres, uint32_t *fb)
        vox->fb = fb;
        vox->fbwidth = xres;
        vox->fbheight = yres;
+       vox->horizon = horizon >= 0 ? horizon : vox->fbheight / 2;
 }
 
-void vox_view(struct voxscape *vox, int32_t x, int32_t y, int32_t angle)
+void vox_view(struct voxscape *vox, int32_t x, int32_t y, int h, int32_t angle)
 {
+       if(h < 0) {
+               h = vox_height(vox, x, y) - h;
+       }
+
        vox->x = x;
        vox->y = y;
+       vox->vheight = h;
        vox->angle = angle;
-       /* TODO precalc stuff */
 
        vox->valid &= ~SLICELEN;
 }
@@ -179,17 +210,12 @@ void vox_begin(struct voxscape *vox)
 {
        int i;
 
-       /*
-       for(i=0; i<vox->fbwidth; i++) {
-               vox->coltop[i] = vox->fbheight;
-       }
-       */
        memset(vox->coltop, 0, vox->fbwidth * sizeof *vox->coltop);
 
        if(!(vox->valid & SLICELEN)) {
                float theta = (float)vox->fov * M_PI / 360.0f;  /* half angle */
                for(i=0; i<vox->nslices; i++) {
-                       vox->slicelen[i] = (int32_t)((vox->znear + i) * tan(theta) * 10.0f * 65536.0f);
+                       vox->slicelen[i] = (int32_t)((vox->znear + i) * tan(theta) * 4.0f * 65536.0f);
                }
                vox->valid |= SLICELEN;
        }
@@ -197,22 +223,31 @@ void vox_begin(struct voxscape *vox)
 
 void vox_render_slice(struct voxscape *vox, int n)
 {
-       int i, j, tx, ty, hval, colstart, colheight;
-       int32_t x, y, len, xstep;
+       int i, j, tx, ty, hval, colstart, colheight, z, r, g, b;
+       int32_t x, y, len, xstep, ystep, fog;
        uint32_t color;
        uint32_t *fbptr;
 
-       len = vox->slicelen[n];
-       xstep = len / vox->fbwidth;
+       if(vox->zfog > 0 && n > vox->zfog) {
+               fog = ((n - vox->zfog) << 8) / (vox->zfar - vox->zfog);
+       } else {
+               fog = 0;
+       }
 
-       x = vox->x - xstep * (vox->fbwidth >> 1);
-       y = vox->y + ((vox->znear + n) << 16);
+       z = vox->znear + n;
+
+       len = vox->slicelen[n] >> 8;
+       xstep = ((COS(vox->angle) >> 8) * len) / vox->fbwidth;
+       ystep = ((SIN(vox->angle) >> 8) * len) / vox->fbwidth;
+
+       x = vox->x - SIN(vox->angle) * z - xstep * (vox->fbwidth >> 1);
+       y = vox->y + COS(vox->angle) * z - ystep * (vox->fbwidth >> 1);
        for(i=0; i<vox->fbwidth; i++) {
                tx = (x >> 16) & vox->xmask;
                ty = (y >> 16) & vox->ymask;
 
-               hval = vox->height[(ty << vox->xshift) + tx] - 80;
-               hval = hval * 80 / (vox->znear + n) + 250;
+               hval = vox->height[(ty << vox->xshift) + tx] - vox->vheight;
+               hval = hval * 160 / (vox->znear + n) + vox->horizon;
                if(hval > vox->fbheight) hval = vox->fbheight;
                if(hval > vox->coltop[i]) {
                        color = vox->color[(ty << vox->xshift) + tx];
@@ -220,6 +255,16 @@ void vox_render_slice(struct voxscape *vox, int n)
                        colheight = hval - vox->coltop[i];
                        fbptr = vox->fb + colstart * vox->fbwidth + i;
 
+                       if(fog > 0) {
+                               r = color >> 16;
+                               g = (color >> 8) & 0xff;
+                               b = color & 0xff;
+                               r = ((r << 8) + (vox->fogcolor[0] - r) * fog) >> 8;
+                               g = ((g << 8) + (vox->fogcolor[1] - g) * fog) >> 8;
+                               b = ((b << 8) + (vox->fogcolor[2] - b) * fog) >> 8;
+                               color = (r << 16) | (g << 8) | b;
+                       }
+
                        for(j=0; j<colheight; j++) {
                                *fbptr = color;
                                fbptr += vox->fbwidth;
@@ -228,6 +273,22 @@ void vox_render_slice(struct voxscape *vox, int n)
                }
 
                x += xstep;
+               y += ystep;
+       }
+}
+
+void vox_sky_solid(struct voxscape *vox, uint32_t color)
+{
+       int i, j, colheight;
+       uint32_t *fbptr;
+
+       for(i=0; i<vox->fbwidth; i++) {
+               fbptr = vox->fb + i;
+               colheight = vox->fbheight - vox->coltop[i];
+               for(j=0; j<colheight; j++) {
+                       *fbptr = color;
+                       fbptr += vox->fbwidth;
+               }
        }
 }
 
@@ -235,7 +296,7 @@ void vox_sky_grad(struct voxscape *vox, uint32_t chor, uint32_t ctop)
 {
        int i, j, colheight, t;
        int r0, g0, b0, r1, g1, b1, r, g, b;
-       int d = vox->fbheight - 250;
+       int d = vox->fbheight - vox->horizon;
        uint32_t *grad, *fbptr;
 
        grad = alloca(vox->fbheight * sizeof *grad);