optimized blob exhibit

[laserbrain_demo] / src / blobs / metasurf.c

diff --git a/src/blobs/metasurf.c b/src/blobs/metasurf.c
index 0298e05..31efcf4 100644 (file)
--- a/src/blobs/metasurf.c
+++ b/src/blobs/metasurf.c
@@ -85,11 +85,11 @@ void msurf_set_inside(struct metasurface *ms, int inside)
 {
        switch(inside) {
        case MSURF_GREATER:
-               msurf_disable(ms, MSURF_FLIP);
+               msurf_enable(ms, MSURF_FLIP);
                break;
 
        case MSURF_LESS:
-               msurf_enable(ms, MSURF_FLIP);
+               msurf_disable(ms, MSURF_FLIP);
                break;
 
        default:
@@ -245,16 +245,11 @@ static void process_cell(struct metasurface *ms, int xcell, int ycell, int zcell
        slice_size = ms->res[0] * ms->res[1];
        cellptr = ms->voxels + slice_size * zcell + ms->res[0] * ycell + xcell;
 
-       val[0] = *cellptr;
-       val[1] = *(cellptr + 1);
-       val[2] = *(cellptr + 1 + ms->res[0]);
-       val[3] = *(cellptr + ms->res[0]);
-       cellptr += slice_size;
-       val[4] = *cellptr;
-       val[5] = *(cellptr + 1);
-       val[6] = *(cellptr + 1 + ms->res[0]);
-       val[7] = *(cellptr + ms->res[0]);
-       cellptr -= slice_size;
+#define GRIDOFFS(x, y, z)      ((z) * slice_size + (y) * ms->res[0] + (x))
+
+       for(i=0; i<8; i++) {
+               val[i] = cellptr[GRIDOFFS(offs[i][0], offs[i][1], offs[i][2])];
+       }
 
        code = mc_bitcode(val, ms->thres);
        if(ms->flags & MSURF_FLIP) {
@@ -266,22 +261,22 @@ static void process_cell(struct metasurface *ms, int xcell, int ycell, int zcell
 
        /* calculate normals at the 8 corners */
        for(i=0; i<8; i++) {
-               float *ptr = cellptr + offs[i][2] * slice_size + offs[i][1] * ms->res[0] + offs[i][0];
+               float *ptr = cellptr + GRIDOFFS(offs[i][0], offs[i][1], offs[i][2]);
 
                if(xcell < ms->res[0] - 1) {
-                       dfdx[i] = *(ptr + 1) - *ptr;
+                       dfdx[i] = ptr[GRIDOFFS(1, 0, 0)] - *ptr;
                } else {
-                       dfdx[i] = *ptr - *(ptr - 1);
+                       dfdx[i] = *ptr - ptr[GRIDOFFS(-1, 0, 0)];
                }
                if(ycell < ms->res[1] - 1) {
-                       dfdy[i] = *(ptr + ms->res[0]) - *ptr;
+                       dfdy[i] = ptr[GRIDOFFS(0, 1, 0)] - *ptr;
                } else {
-                       dfdy[i] = *ptr - *(ptr - ms->res[0]);
+                       dfdy[i] = *ptr - ptr[GRIDOFFS(0, -1, 0)];
                }
                if(zcell < ms->res[2] - 1) {
-                       dfdz[i] = *(ptr + slice_size) - *ptr;
+                       dfdz[i] = ptr[GRIDOFFS(0, 0, 1)] - *ptr;
                } else {
-                       dfdz[i] = *ptr - *(ptr - slice_size);
+                       dfdz[i] = *ptr - ptr[GRIDOFFS(0, 0, -1)];
                }
        }