[voxscape] / src / voxscape.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <math.h>
#include <imago2.h>
#include "voxscape.h"

enum {
        SLICELEN        = 1
};

struct voxscape {
        int xsz, ysz;
        unsigned char *height;
        uint32_t *color;
        int xshift, xmask, ymask;

        /* framebuffer */
        uint32_t *fb;
        int fbwidth, fbheight;
        int *coltop;

        /* view */
        int32_t x, y, angle;
        int vheight;

        /* projection */
        int fov, znear, zfar;
        int nslices;
        int32_t *slicelen;
        int proj_dist;

        unsigned int valid;
};

struct voxscape *vox_create(int xsz, int ysz)
{
        struct voxscape *vox;

        if(!(vox = calloc(1, sizeof *vox))) {
                return 0;
        }
        if(!(vox->height = calloc(1, xsz * ysz))) {
                fprintf(stderr, "vox_create: failed to allocate %dx%d heightmap\n", xsz, ysz);
                free(vox);
                return 0;
        }
        if(!(vox->color = calloc(xsz * ysz, sizeof *vox->color))) {
                fprintf(stderr, "vox_create: failed to allocate %dx%d color map\n", xsz, ysz);
                free(vox->height);
                free(vox);
                return 0;
        }
        vox->xsz = xsz;
        vox->ysz = ysz;

        vox->xmask = vox->xsz - 1;
        vox->ymask = vox->ysz - 1;

        vox->xshift = -1;
        while(xsz) {
                xsz >>= 1;
                vox->xshift++;
        }

        vox->proj_dist = 2;     /* TODO */

        return vox;
}

struct voxscape *vox_open(const char *hfile, const char *cfile)
{
        unsigned char *hpix;
        uint32_t *cpix;
        int width, height, cwidth, cheight;
        struct voxscape *vox;

        if(!(hpix = img_load_pixels(hfile, &width, &height, IMG_FMT_GREY8))) {
                fprintf(stderr, "vox_open: failed to load heightmap: %s\n", hfile);
                return 0;
        }
        if(!(cpix = img_load_pixels(cfile, &cwidth, &cheight, IMG_FMT_RGBA32))) {
                fprintf(stderr, "vox_open: failed to load color map: %s\n", cfile);
                img_free_pixels(hpix);
                return 0;
        }
        if(cwidth != width || cheight != height) {
                img_free_pixels(hpix);
                img_free_pixels(cpix);
                fprintf(stderr, "vox_open: %s and %s have different dimensions\n", hfile, cfile);
                return 0;
        }

        if(!(vox = vox_create(width, height))) {
                img_free_pixels(hpix);
                img_free_pixels(cpix);
                return 0;
        }
        memcpy(vox->height, hpix, width * height);
        memcpy(vox->color, cpix, width * height * sizeof *vox->color);

        img_free_pixels(hpix);
        img_free_pixels(cpix);

        return vox;
}

void vox_free(struct voxscape *vox)
{
        if(!vox) return;

        free(vox->color);
        free(vox->height);
        free(vox->coltop);
        free(vox->slicelen);
        free(vox);
}

void vox_framebuf(struct voxscape *vox, int xres, int yres, uint32_t *fb)
{
        if(xres != vox->fbwidth) {
                free(vox->coltop);
                if(!(vox->coltop = malloc(xres * sizeof *vox->coltop))) {
                        fprintf(stderr, "vox_framebuf: failed to allocate column table (%d)\n", xres);
                        return;
                }
        }
        vox->fb = fb;
        vox->fbwidth = xres;
        vox->fbheight = yres;
}

void vox_view(struct voxscape *vox, int32_t x, int32_t y, int32_t angle)
{
        vox->x = x;
        vox->y = y;
        vox->angle = angle;
        /* TODO precalc stuff */

        vox->valid &= ~SLICELEN;
}

void vox_proj(struct voxscape *vox, int fov, int znear, int zfar)
{
        vox->fov = fov;
        vox->znear = znear;
        vox->zfar = zfar;

        vox->nslices = vox->zfar - vox->znear;
        free(vox->slicelen);
        if(!(vox->slicelen = malloc(vox->nslices * sizeof *vox->slicelen))) {
                fprintf(stderr, "vox_proj: failed to allocate slice length table (%d)\n", vox->nslices);
                return;
        }

        vox->valid &= ~SLICELEN;
}

/* algorithm:
 * calculate extents of horizontal equidistant line from the viewer based on fov
 * for each column step along this line and compute height for each pixel
 * fill the visible (top) part of each column
 */

void vox_render(struct voxscape *vox)
{
        int i;

        vox_begin(vox);
        for(i=0; i<vox->nslices; i++) {
                vox_render_slice(vox, i);
        }
}

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->angle * M_PI / 360.0f;        /* half angle */
                for(i=0; i<vox->nslices; i++) {
                        vox->slicelen[i] = (int32_t)((vox->znear + i) * tan(theta) * 2.0f * 65536.0f);
                }
                vox->valid |= SLICELEN;
        }
}

void vox_render_slice(struct voxscape *vox, int n)
{
        int i, j, tx, ty, hval, colstart, colheight;
        int32_t x, y, len, xstep;
        uint32_t color;
        uint32_t *fbptr;

        len = vox->slicelen[n];
        xstep = len / vox->fbwidth;

        x = vox->x - xstep * (vox->fbwidth >> 1);
        y = vox->y + (vox->znear << 16);
        for(i=0; i<vox->fbwidth; i++) {
                tx = (x >> 16) & vox->xmask;
                ty = (y >> 16) & vox->ymask;

                hval = (vox->height[(ty << vox->xshift) + tx] - vox->vheight) * vox->proj_dist / y;
                if(hval > vox->coltop[i]) {
                        color = vox->color[(ty << vox->xshift) + tx];
                        colstart = vox->fbheight - 1 - hval;
                        colheight = hval - vox->coltop[i];
                        fbptr = vox->fb + colstart * vox->fbwidth + i;

                        for(j=0; j<colheight; j++) {
                                *fbptr = color;
                                fbptr += vox->fbwidth;
                        }
                }

                x += xstep;
        }
}