Merge branch 'master' into py-package

Conflicts:
	overviewer_core/data/config.js
	overviewer_core/data/web_assets/functions.js
	overviewer_core/data/web_assets/style.css
	setup.py
	web_assets/overviewer.css
	web_assets/style.css

overviewer_core/src/composite.c

@@ -273,7 +273,8 @@ alpha_over_wrap(PyObject *self, PyObject *args)
  * also, it multiplies instead of doing an over operation
  */
 PyObject *
-tint_with_mask(PyObject *dest, unsigned char sr, unsigned char sg, unsigned char sb,
+tint_with_mask(PyObject *dest, unsigned char sr, unsigned char sg,
+               unsigned char sb, unsigned char sa,
                PyObject *mask, int dx, int dy, int xsize, int ysize) {
     /* libImaging handles */
     Imaging imDest, imMask;
@@ -332,9 +333,11 @@ tint_with_mask(PyObject *dest, unsigned char sr, unsigned char sg, unsigned char
                 out++;
                 *out = MULDIV255(*out, sb, tmp1);
                 out++;
+                *out = MULDIV255(*out, sa, tmp1);
+                out++;
             } else if (*inmask == 0) {
                 /* do nothing -- source is fully transparent */
-                out += 3;
+                out += 4;
             } else {
                 /* general case */
                 
@@ -345,9 +348,10 @@ tint_with_mask(PyObject *dest, unsigned char sr, unsigned char sg, unsigned char
                 out++;
                 *out = MULDIV255(*out, (255 - *inmask) + MULDIV255(sb, *inmask, tmp1), tmp2);
                 out++;
+                *out = MULDIV255(*out, (255 - *inmask) + MULDIV255(sa, *inmask, tmp1), tmp2);
+                out++;
             }
 
-            out++;
             inmask += mask_stride;
         }
     }

overviewer_core/src/iterate.c

@@ -155,7 +155,12 @@ generate_pseudo_data(RenderState *state, unsigned char ancilData) {
     int x = state->x, y = state->y, z = state->z;
     unsigned char data = 0;
     
-    if (state->block == 9) { /* water */
+    if (state->block == 2) { /* grass */
+        /* return 0x10 if grass is covered in snow */
+        if (z < 127 && getArrayByte3D(state->blocks, x, y, z+1) == 78)
+            return 0x10;
+        return ancilData;
+    } else if (state->block == 9) { /* water */
         /* an aditional bit for top is added to the 4 bits of check_adjacent_blocks */
         if ((ancilData == 0) || (ancilData >= 10)) { /* static water, only top, and unkown ancildata values */
             data = 16;
@@ -207,9 +212,75 @@ generate_pseudo_data(RenderState *state, unsigned char ancilData) {
         if ((above_level_data & 0x08)) { /* draw top right going up redstonewire */
             final_data = final_data | 0x10;
         }
-        return final_data;        
+        return final_data;
+
+    } else if (state-> block == 54) { /* chests */
+        /* the top 2 bits are used to store the type of chest
+         * (single or double), the 2 bottom bits are used for 
+         * orientation, look textures.py for more information. */
+
+        /* if placed alone chests always face west, return 0 to make a 
+         * chest facing west */
+        unsigned char chest_data = 0, air_data = 0, final_data = 0;
+
+        /* search for chests */
+        chest_data = check_adjacent_blocks(state, x, y, z, 54);
+
+        /* search for air */
+        air_data = check_adjacent_blocks(state, x, y, z, 0);
+
+        if (chest_data == 1) { /* another chest in the east */
+            final_data = final_data | 0x8; /* only can face to north or south */
+            if ( (air_data & 0x2) == 2 ) {
+                final_data = final_data | 0x1; /* facing north */
+            } else {
+                final_data = final_data | 0x3; /* facing south */
+            }
+
+        } else if (chest_data == 2) { /* in the north */
+            final_data = final_data | 0x4; /* only can face to east or west */
+            if ( !((air_data & 0x4) == 4) ) { /* 0 = west */
+                final_data = final_data | 0x2; /* facing east */
+            }
+
+        } else if (chest_data == 4) { /*in the west */
+            final_data = final_data | 0x4;
+            if ( (air_data & 0x2) == 2 ) {
+                final_data = final_data | 0x1; /* facing north */
+            } else {
+                final_data = final_data | 0x3; /* facing south */
+            }
+
+        } else if (chest_data == 8) { /*in the south */
+            final_data = final_data | 0x8;
+            if ( !((air_data & 0x4) == 4) ) {
+                final_data = final_data | 0x2; /* facing east */
+            }
+
+        } else if (chest_data == 0) {
+            /* Single chest, determine the orientation */
+            if ( ((air_data & 0x8) == 0) && ((air_data & 0x2) == 2)  ) { /* block in +x and no block in -x */
+                final_data = final_data | 0x1; /* facing north */
+
+            } else if ( ((air_data & 0x2) == 0) && ((air_data & 0x8) == 8)) {
+                final_data = final_data | 0x3;
+
+            } else if ( ((air_data & 0x4) == 0) && ((air_data & 0x1) == 1)) {
+                final_data = final_data | 0x2;
+            } /* else, facing west, value = 0 */
+
+        } else {
+            /* more than one adjacent chests! render as normal chest */
+            return 0;
+        }
+
+        return final_data;
+
+    } else if (state->block == 90) {
+        return check_adjacent_blocks(state, x, y, z, state->block);
     }
 
+
     return 0;
 
 }
@@ -329,7 +400,7 @@ chunk_render(PyObject *self, PyObject *args) {
                     PyObject *tmp;
                     
                     unsigned char ancilData = getArrayByte3D(blockdata_expanded, state.x, state.y, state.z);
-                    if ((state.block == 85) || (state.block == 9) || (state.block == 55)) {
+                    if ((state.block == 85) || (state.block == 9) || (state.block == 55) || (state.block == 54) || (state.block == 2) || (state.block == 90)) {
                         ancilData = generate_pseudo_data(&state, ancilData);
                     }
                     

overviewer_core/src/main.c

@@ -25,14 +25,24 @@ PyObject *get_extension_version(PyObject *self, PyObject *args) {
 static PyMethodDef COverviewerMethods[] = {
     {"alpha_over", alpha_over_wrap, METH_VARARGS,
      "alpha over composite function"},
+    
     {"render_loop", chunk_render, METH_VARARGS,
      "Renders stuffs"},
+    
     {"get_render_modes", get_render_modes, METH_VARARGS,
      "returns available render modes"},
     {"get_render_mode_info", get_render_mode_info, METH_VARARGS,
      "returns info for a particular render mode"},
+    {"get_render_mode_parent", get_render_mode_parent, METH_VARARGS,
+     "returns parent for a particular render mode"},
+    {"get_render_mode_inheritance", get_render_mode_inheritance, METH_VARARGS,
+     "returns inheritance chain for a particular render mode"},
+    {"get_render_mode_children", get_render_mode_children, METH_VARARGS,
+     "returns (direct) children for a particular render mode"},
+    
     {"extension_version", get_extension_version, METH_VARARGS, 
         "Returns the extension version"},
+    
     {NULL, NULL, 0, NULL}       /* Sentinel */
 };
 

overviewer_core/src/overviewer.h

@@ -26,7 +26,7 @@
 
 // increment this value if you've made a change to the c extesion
 // and want to force users to rebuild
-#define OVERVIEWER_EXTENSION_VERSION 3
+#define OVERVIEWER_EXTENSION_VERSION 5
 
 /* Python PIL, and numpy headers */
 #include <Python.h>
@@ -48,7 +48,8 @@ PyObject *alpha_over(PyObject *dest, PyObject *src, PyObject *mask,
 PyObject *alpha_over_full(PyObject *dest, PyObject *src, PyObject *mask, float overall_alpha,
                           int dx, int dy, int xsize, int ysize);
 PyObject *alpha_over_wrap(PyObject *self, PyObject *args);
-PyObject *tint_with_mask(PyObject *dest, unsigned char sr, unsigned char sg, unsigned char sb,
+PyObject *tint_with_mask(PyObject *dest, unsigned char sr, unsigned char sg,
+                         unsigned char sb, unsigned char sa,
                          PyObject *mask, int dx, int dy, int xsize, int ysize);
 
 /* in iterate.c */

overviewer_core/src/rendermode-cave.c

@@ -0,0 +1,234 @@
+/* 
+ * This file is part of the Minecraft Overviewer.
+ *
+ * Minecraft Overviewer 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.
+ *
+ * Minecraft Overviewer 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 the Overviewer.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "overviewer.h"
+#include <math.h>
+//~ 
+//~ /* figures out the black_coeff from a given skylight and blocklight, used in
+   //~ lighting calculations -- note this is *different* from the one in
+   //~ rendermode-lighting.c (the "skylight - 11" part) */
+//~ static float calculate_darkness(unsigned char skylight, unsigned char blocklight) {
+    //~ return 1.0f - powf(0.8f, 15.0 - MAX(blocklight, skylight - 11));
+//~ }
+
+static int
+rendermode_cave_occluded(void *data, RenderState *state) {
+    int x = state->x, y = state->y, z = state->z, dz = 0;
+    RenderModeCave* self;
+    self = (RenderModeCave *)data;
+
+    /* check if the block is touching skylight */
+    if (z != 127) { 
+        
+        if (getArrayByte3D(self->skylight, x, y, z+1) != 0) {
+            return 1;
+        }
+
+        if ((x == 15)) {
+            if  (self->up_right_skylight != Py_None) {
+                if (getArrayByte3D(self->up_right_skylight, 0, y, z) != 0) {
+                    return 1;
+                }
+            }
+        } else {
+            if (getArrayByte3D(self->skylight, x+1, y, z) != 0) {
+                return 1;
+            }
+        }
+        
+        if (x == 0) {
+            if  (self->left_skylight != Py_None) {
+                if (getArrayByte3D(self->left_skylight, 15, y, z) != 0) {
+                    return 1;
+                }
+            }
+        } else {
+            if (getArrayByte3D(self->skylight, x-1, y, z) != 0) {
+                return 1;
+            }
+        }
+
+        if (y == 15) {
+            if  (self->right_skylight != Py_None) {
+                if (getArrayByte3D(self->right_skylight, 0, y, z) != 0) {
+                    return 1;
+                }
+            }
+        } else {
+            if (getArrayByte3D(self->skylight, x, y+1, z) != 0) {
+                return 1;
+            }
+        }
+
+        if (y == 0) {
+            if  (self->up_left_skylight != Py_None) {
+                if (getArrayByte3D(self->up_left_skylight, 15, y, z) != 0) {
+                    return 1;
+                }
+            }
+        } else {
+            if (getArrayByte3D(self->skylight, x, y-1, z) != 0) {
+                return 1;
+            }
+        }
+
+        /* check for normal occlusion */
+        /* use ajacent chunks, if not you get blocks spreaded in chunk edges */
+        if ( (x == 0) && (y != 15) ) {
+            if (state->left_blocks != Py_None) {
+                if (!is_transparent(getArrayByte3D(state->left_blocks, 15, y, z)) &&
+                    !is_transparent(getArrayByte3D(state->blocks, x, y, z+1)) &&
+                    !is_transparent(getArrayByte3D(state->blocks, x, y+1, z))) {
+                    return 1;
+                }
+            } else {
+                return 1;
+            }
+        }
+        
+        if ( (x != 0) && (y == 15) ) {
+            if (state->right_blocks != Py_None) {
+                if (!is_transparent(getArrayByte3D(state->blocks, x-1, y, z)) &&
+                    !is_transparent(getArrayByte3D(state->right_blocks, x, 0, z)) &&
+                    !is_transparent(getArrayByte3D(state->blocks, x, y, z+1))) {
+                    return 1;
+                }
+            } else {
+                return 1;
+            }
+        }
+        
+        if ( (x == 0) && (y == 15) ) {
+            if ((state->left_blocks != Py_None) &&
+                (state->right_blocks != Py_None)) {
+                if (!is_transparent(getArrayByte3D(state->left_blocks, 15, y, z)) &&
+                    !is_transparent(getArrayByte3D(state->right_blocks, x, 0, z)) &&
+                    !is_transparent(getArrayByte3D(state->blocks, x, y, z+1))) {
+                    return 1;
+                }
+            } else {
+                return 1;
+            }
+        }
+        
+        if ( (x != 0) && (y != 15) &&
+            !is_transparent(getArrayByte3D(state->blocks, x-1, y, z)) &&
+            !is_transparent(getArrayByte3D(state->blocks, x, y, z+1)) &&
+            !is_transparent(getArrayByte3D(state->blocks, x, y+1, z))) {
+            return 1;
+        }
+
+    } else { /* if z == 127 skip */
+        return 1;
+    }
+
+    /* check for lakes and seas and don't render them */
+    /* at this point of the code the block has no skylight
+     * and is not occluded, but a deep sea can fool these
+     * 2 tests */
+    
+    if ((getArrayByte3D(state->blocks, x, y, z) == 9) ||
+        (getArrayByte3D(state->blocks, x, y, z+1) == 9)) {
+
+        for (dz = z+1; dz < 127; dz++) { /* go up and check for skylight */
+            if (getArrayByte3D(self->skylight, x, y, dz) != 0) {
+                return 1;
+            }
+            if (getArrayByte3D(state->blocks, x, y, dz) != 9) {
+            /* we are out of the water! and there's no skylight
+             * , i.e. is a cave lake or something similar */
+                return 0;
+            }
+        }
+    }
+        
+
+    return 0;
+}
+
+static int
+rendermode_cave_start(void *data, RenderState *state) {
+    RenderModeCave* self;
+    int ret;
+    self = (RenderModeCave *)data;
+
+    /* first, chain up */
+    ret = rendermode_normal.start(data, state);
+    if (ret != 0)
+        return ret;
+
+    /* if there's skylight we are in the surface! */
+    self->skylight = PyObject_GetAttrString(state->self, "skylight");
+    self->left_skylight = PyObject_GetAttrString(state->self, "left_skylight");
+    self->right_skylight = PyObject_GetAttrString(state->self, "right_skylight");
+    self->up_left_skylight = PyObject_GetAttrString(state->self, "up_left_skylight");
+    self->up_right_skylight = PyObject_GetAttrString(state->self, "up_right_skylight");
+
+    /* colors for tinting */
+    self->depth_colors = PyObject_GetAttrString(state->chunk, "depth_colors");
+
+
+    return 0;
+}
+
+static void
+rendermode_cave_finish(void *data, RenderState *state) {
+    RenderModeCave* self;
+    self = (RenderModeCave *)data;
+
+    Py_DECREF(self->skylight);
+    Py_DECREF(self->left_skylight);
+    Py_DECREF(self->right_skylight);
+    Py_DECREF(self->up_left_skylight);
+    Py_DECREF(self->up_right_skylight);
+
+    Py_DECREF(self->depth_colors);
+
+    rendermode_normal.finish(data, state);
+}
+
+static void
+rendermode_cave_draw(void *data, RenderState *state, PyObject *src, PyObject *mask) {
+    RenderModeCave* self;
+    int z, r, g, b;
+    self = (RenderModeCave *)data;
+
+    z = state->z;
+    r = 0, g = 0, b = 0;
+
+    /* draw the normal block */
+    rendermode_normal.draw(data, state, src, mask);
+
+    /* get the colors and tint and tint */
+    /* TODO TODO   for a nether mode there isn't tinting! */
+    r = PyInt_AsLong(PyList_GetItem(self->depth_colors, 0 + z*3));
+    g = PyInt_AsLong(PyList_GetItem(self->depth_colors, 1 + z*3));
+    b = PyInt_AsLong(PyList_GetItem(self->depth_colors, 2 + z*3));
+
+    tint_with_mask(state->img, r, g, b, 255, mask, state->imgx, state->imgy, 0, 0);
+
+}
+
+RenderModeInterface rendermode_cave = {
+    "cave", "render only caves in normal mode",
+    &rendermode_normal,
+    sizeof(RenderModeCave),
+    rendermode_cave_start,
+    rendermode_cave_finish,
+    rendermode_cave_occluded,
+    rendermode_cave_draw,
+};

overviewer_core/src/rendermode-lighting.c

@@ -229,6 +229,7 @@ rendermode_lighting_draw(void *data, RenderState *state, PyObject *src, PyObject
 
 RenderModeInterface rendermode_lighting = {
     "lighting", "draw shadows from the lighting data",
+    &rendermode_normal,
     sizeof(RenderModeLighting),
     rendermode_lighting_start,
     rendermode_lighting_finish,

overviewer_core/src/rendermode-night.c

@@ -61,6 +61,7 @@ rendermode_night_draw(void *data, RenderState *state, PyObject *src, PyObject *m
 
 RenderModeInterface rendermode_night = {
     "night", "like \"lighting\", except at night",
+    &rendermode_lighting,
     sizeof(RenderModeNight),
     rendermode_night_start,
     rendermode_night_finish,

overviewer_core/src/rendermode-normal.c

@@ -120,17 +120,8 @@ rendermode_normal_draw(void *data, RenderState *state, PyObject *src, PyObject *
     RenderModeNormal *self = (RenderModeNormal *)data;
     
     /* first, check to see if we should use biome-compatible src, mask */
-    if (self->biome_data) {
-        switch (state->block) {
-        case 2:
-            src = mask = self->grass_texture;
-            break;
-        case 18:
-            src = mask = self->leaf_texture;
-            break;
-        default:
-            break;
-        };
+    if (self->biome_data && state->block == 18) {
+        src = mask = self->leaf_texture;
     }
     
     /* draw the block! */
@@ -147,9 +138,12 @@ rendermode_normal_draw(void *data, RenderState *state, PyObject *src, PyObject *
         
         switch (state->block) {
         case 2:
-            /* grass */
+            /* grass -- skip for snowgrass */
+            if (state->z < 127 && getArrayByte3D(state->blocks, state->x, state->y, state->z+1) == 78)
+                break;
             color = PySequence_GetItem(self->grasscolor, index);
-            facemask = self->facemask_top;
+            facemask = self->grass_texture;
+            alpha_over(state->img, self->grass_texture, self->grass_texture, state->imgx, state->imgy, 0, 0);
             break;
         case 18:
             /* leaves */
@@ -169,7 +163,7 @@ rendermode_normal_draw(void *data, RenderState *state, PyObject *src, PyObject *
             b = PyInt_AsLong(PyTuple_GET_ITEM(color, 2));
             Py_DECREF(color);
 
-            tint_with_mask(state->img, r, g, b, facemask, state->imgx, state->imgy, 0, 0);
+            tint_with_mask(state->img, r, g, b, 255, facemask, state->imgx, state->imgy, 0, 0);
         }
     }
 
@@ -183,7 +177,7 @@ rendermode_normal_draw(void *data, RenderState *state, PyObject *src, PyObject *
         int increment=0;
         if (state->block == 44)  // half-step
             increment=6;
-        else if (state->block == 78) // snow
+        else if ((state->block == 78) || (state->block == 93) || (state->block == 94)) // snow, redstone repeaters (on and off)
             increment=9;
 
         if ((state->x == 15) && (state->up_right_blocks != Py_None)) {
@@ -221,6 +215,7 @@ rendermode_normal_draw(void *data, RenderState *state, PyObject *src, PyObject *
 
 RenderModeInterface rendermode_normal = {
     "normal", "nothing special, just render the blocks",
+    NULL,
     sizeof(RenderModeNormal),
     rendermode_normal_start,
     rendermode_normal_finish,

overviewer_core/src/rendermode-overlay.c

@@ -0,0 +1,137 @@
+/* 
+ * This file is part of the Minecraft Overviewer.
+ *
+ * Minecraft Overviewer 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.
+ *
+ * Minecraft Overviewer 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 the Overviewer.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "overviewer.h"
+
+static void get_color(void *data, RenderState *state,
+                      unsigned char *r, unsigned char *g, unsigned char *b, unsigned char *a) {
+    *r = 200;
+    *g = 200;
+    *b = 255;
+    *a = 155;
+}
+
+static int
+rendermode_overlay_start(void *data, RenderState *state) {
+    PyObject *facemasks_py;
+    RenderModeOverlay *self = (RenderModeOverlay *)data;
+    
+    facemasks_py = PyObject_GetAttrString(state->chunk, "facemasks");
+    /* borrowed reference, needs to be incref'd if we keep it */
+    self->facemask_top = PyTuple_GetItem(facemasks_py, 0);
+    Py_INCREF(self->facemask_top);
+    Py_DECREF(facemasks_py);
+    
+    self->white_color = PyObject_GetAttrString(state->chunk, "white_color");
+    
+    self->solid_blocks = PyObject_GetAttrString(state->chunk, "solid_blocks");
+    self->fluid_blocks = PyObject_GetAttrString(state->chunk, "fluid_blocks");
+    
+    self->get_color = get_color;
+    
+    return 0;
+}
+
+static void
+rendermode_overlay_finish(void *data, RenderState *state) {
+    RenderModeOverlay *self = (RenderModeOverlay *)data;
+    
+    Py_DECREF(self->facemask_top);
+    Py_DECREF(self->white_color);
+    Py_DECREF(self->solid_blocks);
+    Py_DECREF(self->fluid_blocks);
+}
+
+static int
+rendermode_overlay_occluded(void *data, RenderState *state) {
+    int x = state->x, y = state->y, z = state->z;
+    
+    if ( (x != 0) && (y != 15) && (z != 127) &&
+         !is_transparent(getArrayByte3D(state->blocks, x-1, y, z)) &&
+         !is_transparent(getArrayByte3D(state->blocks, x, y, z+1)) &&
+         !is_transparent(getArrayByte3D(state->blocks, x, y+1, z))) {
+        return 1;
+    }
+    
+    return 0;
+}
+
+static void
+rendermode_overlay_draw(void *data, RenderState *state, PyObject *src, PyObject *mask) {
+    RenderModeOverlay *self = (RenderModeOverlay *)data;
+    unsigned char r, g, b, a;
+    PyObject *top_block_py, *block_py;
+    
+    // exactly analogous to edge-line code for these special blocks
+    int increment=0;
+    if (state->block == 44)  // half-step
+        increment=6;
+    else if (state->block == 78) // snow
+        increment=9;
+    
+    /* clear the draw space -- set alpha to 0 within mask */
+    tint_with_mask(state->img, 255, 255, 255, 0, mask, state->imgx, state->imgy, 0, 0);
+
+    /* skip rendering the overlay if we can't see it */
+    if (state->z != 127) {
+        unsigned char top_block = getArrayByte3D(state->blocks, state->x, state->y, state->z+1);
+        if (!is_transparent(top_block)) {
+            return;
+        }
+        
+        /* check to be sure this block is solid/fluid */
+        top_block_py = PyInt_FromLong(top_block);
+        if (PySequence_Contains(self->solid_blocks, top_block_py) ||
+            PySequence_Contains(self->fluid_blocks, top_block_py)) {
+            
+            /* top block is fluid or solid, skip drawing */
+            Py_DECREF(top_block_py);
+            return;
+        }
+        Py_DECREF(top_block_py);
+    }
+    
+    /* check to be sure this block is solid/fluid */
+    block_py = PyInt_FromLong(state->block);
+    if (!PySequence_Contains(self->solid_blocks, block_py) &&
+        !PySequence_Contains(self->fluid_blocks, block_py)) {
+        
+        /* not fluid or solid, skip drawing the overlay */
+        Py_DECREF(block_py);
+        return;
+    }
+    Py_DECREF(block_py);
+
+    /* get our color info */
+    self->get_color(data, state, &r, &g, &b, &a);
+    
+    /* do the overlay */
+    if (a > 0) {
+        alpha_over(state->img, self->white_color, self->facemask_top, state->imgx, state->imgy + increment, 0, 0);
+        tint_with_mask(state->img, r, g, b, a, self->facemask_top, state->imgx, state->imgy + increment, 0, 0);
+    }
+}
+
+RenderModeInterface rendermode_overlay = {
+    "overlay", "base rendermode for informational overlays",
+    NULL,
+    sizeof(RenderModeOverlay),
+    rendermode_overlay_start,
+    rendermode_overlay_finish,
+    rendermode_overlay_occluded,
+    rendermode_overlay_draw,
+};

overviewer_core/src/rendermode-spawn.c

@@ -18,21 +18,66 @@
 #include "overviewer.h"
 #include <math.h>
 
+static void get_color(void *data, RenderState *state,
+                      unsigned char *r, unsigned char *g, unsigned char *b, unsigned char *a) {
+    
+    RenderModeSpawn* self = (RenderModeSpawn *)data;
+    int x = state->x, y = state->y, z = state->z;
+    int z_light = z + 1;
+    unsigned char blocklight, skylight;
+    PyObject *block_py;
+    
+    /* set a nice, pretty red color */
+    *r = 229;
+    *g = 36;
+    *b = 38;
+    
+    /* default to no overlay, until told otherwise */
+    *a = 0;
+    
+    block_py = PyInt_FromLong(state->block);
+    if (PySequence_Contains(self->nospawn_blocks, block_py)) {
+        /* nothing can spawn on this */
+        Py_DECREF(block_py);
+        return;
+    }
+    Py_DECREF(block_py);
+    
+    blocklight = getArrayByte3D(self->blocklight, x, y, MIN(127, z_light));
+    
+    /* if we're at the top, force 15 (brightest!) skylight */
+    if (z_light == 128) {
+        skylight = 15;
+    } else {
+        skylight = getArrayByte3D(self->skylight, x, y, z_light);
+    }
+    
+    if (MAX(blocklight, skylight) <= 7) {
+        /* hostile mobs spawn in daylight */
+        *a = 240;
+    } else if (MAX(blocklight, skylight - 11) <= 7) {
+        /* hostile mobs spawn at night */
+        *a = 150;
+    }
+}
+
 static int
 rendermode_spawn_start(void *data, RenderState *state) {
     RenderModeSpawn* self;
 
     /* first, chain up */
-    int ret = rendermode_night.start(data, state);
+    int ret = rendermode_overlay.start(data, state);
     if (ret != 0)
         return ret;
     
     /* now do custom initializations */
     self = (RenderModeSpawn *)data;
-    self->solid_blocks = PyObject_GetAttrString(state->chunk, "solid_blocks");
     self->nospawn_blocks = PyObject_GetAttrString(state->chunk, "nospawn_blocks");
-    self->fluid_blocks = PyObject_GetAttrString(state->chunk, "fluid_blocks");
-    self->red_color = PyObject_GetAttrString(state->chunk, "red_color");
+    self->blocklight = PyObject_GetAttrString(state->self, "blocklight");
+    self->skylight = PyObject_GetAttrString(state->self, "skylight");
+    
+    /* setup custom color */
+    self->parent.get_color = get_color;
     
     return 0;
 }
@@ -40,85 +85,31 @@ rendermode_spawn_start(void *data, RenderState *state) {
 static void
 rendermode_spawn_finish(void *data, RenderState *state) {
     /* first free all *our* stuff */
-    RenderModeSpawn* self = (RenderModeSpawn *)data;    
+    RenderModeSpawn* self = (RenderModeSpawn *)data;
     
-    Py_DECREF(self->solid_blocks);
     Py_DECREF(self->nospawn_blocks);
-    Py_DECREF(self->fluid_blocks);
+    Py_DECREF(self->blocklight);
+    Py_DECREF(self->skylight);
     
     /* now, chain up */
-    rendermode_night.finish(data, state);
+    rendermode_overlay.finish(data, state);
 }
 
 static int
 rendermode_spawn_occluded(void *data, RenderState *state) {
     /* no special occlusion here */
-    return rendermode_night.occluded(data, state);
+    return rendermode_overlay.occluded(data, state);
 }
 
 static void
 rendermode_spawn_draw(void *data, RenderState *state, PyObject *src, PyObject *mask) {
-    /* different versions of self (spawn, lighting) */
-    RenderModeSpawn* self = (RenderModeSpawn *)data;
-    RenderModeLighting *lighting = (RenderModeLighting *)self;
-    
-    int x = state->x, y = state->y, z = state->z;
-    PyObject *old_black_color = NULL;
-    
-    /* figure out the appropriate darkness:
-       this block for transparents, the block above for non-transparent */
-    float darkness = 0.0;
-    if (is_transparent(state->block)) {
-        darkness = get_lighting_coefficient((RenderModeLighting *)self, state, x, y, z, NULL);
-    } else {
-        darkness = get_lighting_coefficient((RenderModeLighting *)self, state, x, y, z+1, NULL);
-    }
-    
-    /* if it's dark enough... */
-    if (darkness > 0.8) {
-        PyObject *block_py = PyInt_FromLong(state->block);
-        
-        /* make sure it's solid */
-        if (PySequence_Contains(self->solid_blocks, block_py)) {
-            int spawnable = 1;
-            
-            /* not spawnable if its in the nospawn list */
-            if (PySequence_Contains(self->nospawn_blocks, block_py))
-                spawnable = 0;
-            
-            /* check the block above for solid or fluid */
-            if (spawnable && z != 127) {
-                PyObject *top_block_py = PyInt_FromLong(getArrayByte3D(state->blocks, x, y, z+1));
-                if (PySequence_Contains(self->solid_blocks, top_block_py) ||
-                    PySequence_Contains(self->fluid_blocks, top_block_py)) {
-                    
-                    spawnable = 0;
-                }
-                
-                Py_DECREF(top_block_py);
-            }
-            
-            /* if we passed all the checks, replace black_color with red_color */
-            if (spawnable) {
-                old_black_color = lighting->black_color;
-                lighting->black_color = self->red_color;
-            }
-        }
-        
-        Py_DECREF(block_py);
-    }
-    
     /* draw normally */
-    rendermode_night.draw(data, state, src, mask);
-    
-    /* reset black_color, if needed */
-    if (old_black_color != NULL) {
-        lighting->black_color = old_black_color;
-    }
+    rendermode_overlay.draw(data, state, src, mask);
 }
 
 RenderModeInterface rendermode_spawn = {
-    "spawn", "draws red where monsters can spawn at night",
+    "spawn", "draws a red overlay where monsters can spawn at night",
+    &rendermode_overlay,
     sizeof(RenderModeSpawn),
     rendermode_spawn_start,
     rendermode_spawn_finish,

overviewer_core/src/rendermodes.c

@@ -26,6 +26,7 @@ static RenderModeInterface *render_modes[] = {
     &rendermode_lighting,
     &rendermode_night,
     &rendermode_spawn,
+    &rendermode_cave,
     NULL
 };
 
@@ -97,5 +98,87 @@ PyObject *get_render_mode_info(PyObject *self, PyObject *args) {
     }
     
     Py_DECREF(info);
-    Py_RETURN_NONE;
+    return PyErr_Format(PyExc_ValueError, "invalid rendermode: \"%s\"", rendermode);
+}
+
+/* bindings -- get parent's name */
+PyObject *get_render_mode_parent(PyObject *self, PyObject *args) {
+    const char *rendermode;
+    unsigned int i;
+    if (!PyArg_ParseTuple(args, "s", &rendermode))
+        return NULL;
+    
+    for (i = 0; render_modes[i] != NULL; i++) {
+        if (strcmp(render_modes[i]->name, rendermode) == 0) {
+            if (render_modes[i]->parent) {
+                /* has parent */
+                return PyString_FromString(render_modes[i]->parent->name);
+            } else {
+                /* no parent */
+                Py_RETURN_NONE;
+            }
+        }
+    }
+    
+    return PyErr_Format(PyExc_ValueError, "invalid rendermode: \"%s\"", rendermode);
+}
+
+/* bindings -- get list of inherited parents */
+PyObject *get_render_mode_inheritance(PyObject *self, PyObject *args) {
+    const char *rendermode;
+    PyObject *parents;
+    unsigned int i;
+    RenderModeInterface *iface = NULL;
+    if (!PyArg_ParseTuple(args, "s", &rendermode))
+        return NULL;
+    
+    parents = PyList_New(0);
+    if (!parents)
+        return NULL;
+    
+    for (i = 0; render_modes[i] != NULL; i++) {
+        if (strcmp(render_modes[i]->name, rendermode) == 0) {
+            iface = render_modes[i];
+            break;
+        }
+    }
+    
+    if (!iface) {
+        Py_DECREF(parents);
+        return PyErr_Format(PyExc_ValueError, "invalid rendermode: \"%s\"", rendermode);
+    }
+    
+    while (iface) {
+        PyObject *name = PyString_FromString(iface->name);
+        PyList_Append(parents, name);
+        Py_DECREF(name);
+        
+        iface = iface->parent;
+    }
+    
+    PyList_Reverse(parents);
+    return parents;
+}
+
+/* bindings -- get list of (direct) children */
+PyObject *get_render_mode_children(PyObject *self, PyObject *args) {
+    const char *rendermode;
+    PyObject *children;
+    unsigned int i;
+    if (!PyArg_ParseTuple(args, "s", &rendermode))
+        return NULL;
+    
+    children = PyList_New(0);
+    if (!children)
+        return NULL;
+    
+    for (i = 0; render_modes[i] != NULL; i++) {
+        if (render_modes[i]->parent && strcmp(render_modes[i]->parent->name, rendermode) == 0) {
+            PyObject *child_name = PyString_FromString(render_modes[i]->name);
+            PyList_Append(children, child_name);
+            Py_DECREF(child_name);
+        }
+    }
+    
+    return children;
 }

overviewer_core/src/rendermodes.h

@@ -38,12 +38,15 @@
 #include <Python.h>
 
 /* rendermode interface */
-typedef struct {
+typedef struct _RenderModeInterface RenderModeInterface;
+struct _RenderModeInterface {
     /* the name of this mode */
     const char* name;
     /* the short description of this render mode */
     const char* description;
     
+    /* the rendermode this is derived from, or NULL */
+    RenderModeInterface *parent;
     /* the size of the local storage for this rendermode */
     unsigned int data_size;
     
@@ -54,13 +57,16 @@ typedef struct {
     int (*occluded)(void *, RenderState *);
     /* last two arguments are img and mask, from texture lookup */
     void (*draw)(void *, RenderState *, PyObject *, PyObject *);
-} RenderModeInterface;
+};
 
 /* figures out the render mode to use from the given ChunkRenderer */
 RenderModeInterface *get_render_mode(RenderState *state);
 /* python bindings */
 PyObject *get_render_modes(PyObject *self, PyObject *args);
 PyObject *get_render_mode_info(PyObject *self, PyObject *args);
+PyObject *get_render_mode_parent(PyObject *self, PyObject *args);
+PyObject *get_render_mode_inheritance(PyObject *self, PyObject *args);
+PyObject *get_render_mode_children(PyObject *self, PyObject *args);
 
 /* individual rendermode interface declarations follow */
 
@@ -79,6 +85,20 @@ typedef struct {
 } RenderModeNormal;
 extern RenderModeInterface rendermode_normal;
 
+/* OVERLAY */
+typedef struct {
+    /* top facemask and white color image, for drawing overlays */
+    PyObject *facemask_top, *white_color;
+    /* only show overlay on top of solid or fluid blocks */
+    PyObject *solid_blocks, *fluid_blocks;
+    /* can be overridden in derived classes to control
+       overlay alpha and color
+       last four vars are r, g, b, a out */
+    void (*get_color)(void *, RenderState *,
+                      unsigned char *, unsigned char *, unsigned char *, unsigned char *);
+} RenderModeOverlay;
+extern RenderModeInterface rendermode_overlay;
+
 /* LIGHTING */
 typedef struct {
     /* inherits from normal render mode */
@@ -109,14 +129,31 @@ extern RenderModeInterface rendermode_night;
 
 /* SPAWN */
 typedef struct {
-    /* inherits from night */
-    RenderModeNight parent;
+    /* inherits from overlay */
+    RenderModeOverlay parent;
     
     /* used to figure out which blocks are spawnable */
-    PyObject *solid_blocks, *nospawn_blocks, *fluid_blocks;
-    /* replacement for black_color */
-    PyObject *red_color;
+    PyObject *nospawn_blocks;
+    PyObject *skylight, *blocklight;
 } RenderModeSpawn;
 extern RenderModeInterface rendermode_spawn;
 
+/* CAVE */
+typedef struct {
+    /* render blocks with lighting mode */
+    RenderModeNormal parent;
+
+    /* data used to know where the surface is */
+    PyObject *skylight;
+    PyObject *left_skylight;
+    PyObject *right_skylight;
+    PyObject *up_left_skylight;
+    PyObject *up_right_skylight;
+
+    /* colors used for tinting */
+    PyObject *depth_colors;
+    
+} RenderModeCave;
+extern RenderModeInterface rendermode_cave;
+
 #endif /* __RENDERMODES_H_INCLUDED__ */