ported spawn render mode to C

setup.py

@@ -45,7 +45,7 @@ except AttributeError:
 
 
 c_overviewer_files = ['src/main.c', 'src/composite.c', 'src/iterate.c']
-c_overviewer_files += ['src/rendermodes.c', 'src/rendermode-normal.c', 'src/rendermode-lighting.c', 'src/rendermode-night.c']
+c_overviewer_files += ['src/rendermodes.c', 'src/rendermode-normal.c', 'src/rendermode-lighting.c', 'src/rendermode-night.c', 'src/rendermode-spawn.c']
 setup_kwargs['ext_modules'].append(Extension('c_overviewer', c_overviewer_files, include_dirs=['.', numpy_include], extra_link_args=["/MANIFEST"] if platform.system() == "Windows" else []))
 # tell build_ext to build the extension in-place
 # (NOT in build/)

src/rendermode-lighting.c

@@ -25,8 +25,9 @@ static float calculate_darkness(unsigned char skylight, unsigned char blocklight
 }
 
 /* loads the appropriate light data for the given (possibly non-local)
-   coordinates, and returns a black_coeff */
+   coordinates, and returns a black_coeff
-static inline float
+   this is exposed, so other (derived) rendermodes can use it */
+inline float
 get_lighting_coefficient(RenderModeLighting *self, RenderState *state, int x, int y, int z) {
     /* placeholders for later data arrays, coordinates */
     PyObject *blocks = NULL;

src/rendermode-spawn.c

@@ -0,0 +1,124 @@
+/*
+ * 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>
+
+static int
+rendermode_spawn_start(void *data, RenderState *state) {
+    /* first, chain up */
+    int ret = rendermode_night.start(data, state);
+    if (ret != 0)
+        return ret;
+    
+    /* now do custom initializations */
+    RenderModeSpawn* 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");
+    
+    return 0;
+}
+
+static void
+rendermode_spawn_finish(void *data, RenderState *state) {
+    /* first free all *our* stuff */
+    RenderModeSpawn* self = (RenderModeSpawn *)data;    
+    
+    Py_DECREF(self->solid_blocks);
+    Py_DECREF(self->nospawn_blocks);
+    Py_DECREF(self->fluid_blocks);
+    
+    /* now, chain up */
+    rendermode_night.finish(data, state);
+}
+
+static int
+rendermode_spawn_occluded(void *data, RenderState *state) {
+    /* no special occlusion here */
+    return rendermode_night.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);
+    } else {
+        darkness = get_lighting_coefficient((RenderModeLighting *)self, state, x, y, z+1);
+    }
+    
+    /* 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;
+    }
+}
+
+RenderModeInterface rendermode_spawn = {
+    sizeof(RenderModeSpawn),
+    rendermode_spawn_start,
+    rendermode_spawn_finish,
+    rendermode_spawn_occluded,
+    rendermode_spawn_draw,
+};

src/rendermodes.c

@@ -29,6 +29,8 @@ RenderModeInterface *get_render_mode(RenderState *state) {
         iface = &rendermode_lighting;
     } else if (strcmp(rendermode, "night") == 0) {
         iface = &rendermode_night;
+    } else if (strcmp(rendermode, "spawn") == 0) {
+        iface = &rendermode_spawn;
     }
     
     Py_DECREF(rendermode_py);

src/rendermodes.h

@@ -82,6 +82,7 @@ typedef struct {
     float (*calculate_darkness)(unsigned char, unsigned char);
 } RenderModeLighting;
 extern RenderModeInterface rendermode_lighting;
+inline float get_lighting_coefficient(RenderModeLighting *self, RenderState *state, int x, int y, int z);
 
 /* NIGHT */
 typedef struct {
@@ -90,4 +91,16 @@ typedef struct {
 } RenderModeNight;
 extern RenderModeInterface rendermode_night;
 
+/* SPAWN */
+typedef struct {
+    /* inherits from night */
+    RenderModeNight parent;
+    
+    /* used to figure out which blocks are spawnable */
+    PyObject *solid_blocks, *nospawn_blocks, *fluid_blocks;
+    /* replacement for black_color */
+    PyObject *red_color;
+} RenderModeSpawn;
+extern RenderModeInterface rendermode_spawn;
+
 #endif /* __RENDERMODES_H_INCLUDED__ */