separated normal and lighting render modes

src/iterate.c

@@ -17,9 +17,6 @@
 
 #include "overviewer.h"
 
-/* available render modes */
-extern RenderModeInterface rendermode_normal;
-
 static PyObject *textures = NULL;
 static PyObject *chunk_mod = NULL;
 static PyObject *blockmap = NULL;
@@ -82,8 +79,7 @@ chunk_render(PyObject *self, PyObject *args) {
     state.chunk = chunk_mod;
     
     /* set up the render mode */
-    /* FIXME deciding on correct rendermode */
-    RenderModeInterface *rendermode = &rendermode_normal;
+    RenderModeInterface *rendermode = get_render_mode(&state);
     void* rm_data = malloc(rendermode->data_size);
     if (rendermode->start) {
         if (rendermode->start(rm_data, &state)) {

src/overviewer.h

@@ -59,6 +59,11 @@ typedef struct {
     unsigned char block;
     PyObject *blocks;
 } RenderState;
+int init_chunk_render(void);
+int is_transparent(unsigned char b);
+PyObject *chunk_render(PyObject *self, PyObject *args);
+
+/* in rendermode.c */
 typedef struct {
     /* the size of the local storage for this rendermode */
     unsigned int data_size;
@@ -71,8 +76,7 @@ typedef struct {
     /* last two arguments are img and mask, from texture lookup */
     void (*draw)(void *, RenderState *, PyObject *, PyObject *);
 } RenderModeInterface;
-int init_chunk_render(void);
-int is_transparent(unsigned char b);
-PyObject *chunk_render(PyObject *self, PyObject *args);
+/* figures out the render mode to use from the given ChunkRenderer */
+RenderModeInterface *get_render_mode(RenderState *state);
 
 #endif /* __OVERVIEWER_H_INCLUDED__ */

src/rendermodes.c

@@ -17,12 +17,75 @@
 
 #include "overviewer.h"
 
+/*
+ * ========================
+ * == NORMAL rendermode ===
+ * ========================
+ */
+
+typedef struct {
+    /* normal mode does not have any special data, so just use a dummy int
+       this way, normal mode is just like any other type of render mode */
+    int dummy;
+} RenderModeNormal;
+
+static int
+rendermode_normal_start(void *data, RenderState *state) {
+    /* do nothing */
+    return 0;
+}
+
+static void
+rendermode_normal_finish(void *data, RenderState *state) {
+    /* do nothing */
+}
+
+static int
+rendermode_normal_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_normal_draw(void *data, RenderState *state, PyObject *src, PyObject *mask) {
+    alpha_over(state->img, src, mask, state->imgx, state->imgy, 0, 0);
+}
+
+RenderModeInterface rendermode_normal = {
+    sizeof(RenderModeNormal),
+    rendermode_normal_start,
+    rendermode_normal_finish,
+    rendermode_normal_occluded,
+    rendermode_normal_draw,
+};
+
+/*
+ * ===========================
+ * === LIGHTING rendermode ===
+ * ===========================
+ */
+
+typedef struct {
+    /* inherits from normal render mode */
+    RenderModeNormal parent;
+    
+    PyObject *black_color, *facemasks_py;
+    PyObject *facemasks[3];
+} RenderModeLighting;
+
 /* shades the drawn block with the given facemask/black_color, based on the
    lighting results from (x, y, z) */
 static inline void
 do_shading_for_face(PyObject *chunk, int x, int y, int z, PyObject *facemask, PyObject *black_color,
-                    PyObject *img, int imgx, int imgy)
-{
+                    PyObject *img, int imgx, int imgy) {
     // returns new references
     PyObject* light_tup = PyObject_CallMethod(chunk, "get_lighting_coefficient", "iii", x, y, z);
     PyObject *black_coeff_py = PySequence_GetItem(light_tup, 0);
@@ -48,21 +111,14 @@ do_shading_for_face(PyObject *chunk, int x, int y, int z, PyObject *facemask, Py
     }
 }
 
-typedef struct {
-    int lighting;
-    PyObject *black_color, *facemasks_py;
-    PyObject *facemasks[3];
-} RenderModeNormal;
-
 static int
-rendermode_normal_start(void *data, RenderState *state) {
-    RenderModeNormal* self = (RenderModeNormal *)data;
+rendermode_lighting_start(void *data, RenderState *state) {
+    /* first, chain up */
+    int ret = rendermode_normal_start(data, state);
+    if (ret != 0)
+        return ret;
     
-    PyObject *quadtree = PyObject_GetAttrString(state->self, "quadtree");
-    PyObject *lighting_py = PyObject_GetAttrString(quadtree, "lighting");
-    self->lighting = PyObject_IsTrue(lighting_py);
-    Py_DECREF(lighting_py);
-    Py_DECREF(quadtree);
+    RenderModeLighting* self = (RenderModeLighting *)data;
     
     self->black_color = PyObject_GetAttrString(state->chunk, "black_color");
     self->facemasks_py = PyObject_GetAttrString(state->chunk, "facemasks");
@@ -75,31 +131,22 @@ rendermode_normal_start(void *data, RenderState *state) {
 }
 
 static void
-rendermode_normal_finish(void *data, RenderState *state) {
-    RenderModeNormal *self = (RenderModeNormal *)data;
+rendermode_lighting_finish(void *data, RenderState *state) {
+    RenderModeLighting *self = (RenderModeLighting *)data;
     
     Py_DECREF(self->black_color);
     Py_DECREF(self->facemasks_py);
-}
     
-static int
-rendermode_normal_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;
+    /* now chain up */
+    rendermode_normal_finish(data, state);
 }
 
 static void
-rendermode_normal_draw(void *data, RenderState *state, PyObject *src, PyObject *mask)
-{
-    RenderModeNormal* self = (RenderModeNormal *)data;
+rendermode_lighting_draw(void *data, RenderState *state, PyObject *src, PyObject *mask) {
+    /* first, chain up */
+    rendermode_normal_draw(data, state, src, mask);
+    
+    RenderModeLighting* self = (RenderModeLighting *)data;
     
     PyObject *chunk = state->self;
     int x = state->x, y = state->y, z = state->z;
@@ -107,9 +154,6 @@ rendermode_normal_draw(void *data, RenderState *state, PyObject *src, PyObject *
     PyObject *black_color = self->black_color, *img = state->img;
     int imgx = state->imgx, imgy = state->imgy;
     
-    alpha_over(img, src, mask, imgx, imgy, 0, 0);
-    
-    if (self->lighting) {
     // FIXME whole-block shading for transparent blocks
     do_shading_for_face(chunk, x, y, z+1, facemasks[0], black_color,
                         img, imgx, imgy);
@@ -117,14 +161,27 @@ rendermode_normal_draw(void *data, RenderState *state, PyObject *src, PyObject *
                         img, imgx, imgy);
     do_shading_for_face(chunk, x, y+1, z, facemasks[2], black_color,
                         img, imgx, imgy);
-    }
-
 }
 
-RenderModeInterface rendermode_normal = {
-    sizeof(RenderModeNormal),
-    rendermode_normal_start,
-    rendermode_normal_finish,
+RenderModeInterface rendermode_lighting = {
+    sizeof(RenderModeLighting),
+    rendermode_lighting_start,
+    rendermode_lighting_finish,
+    /* no special occlusion for lighting */
     rendermode_normal_occluded,
-    rendermode_normal_draw,
+    rendermode_lighting_draw,
 };
+
+/* putting it all together */
+RenderModeInterface *get_render_mode(RenderState *state)
+{
+    /* default: normal */
+    RenderModeInterface *iface = &rendermode_normal;
+    PyObject *quadtree = PyObject_GetAttrString(state->self, "quadtree");
+    PyObject *lighting = PyObject_GetAttrString(quadtree, "lighting");
+    
+    if (PyObject_IsTrue(lighting))
+        iface = &rendermode_lighting;
+    
+    return iface;
+}