basic rendermode inheritance introspection (no more hacky overlay list)

chunk.py

@@ -129,10 +129,6 @@ fluid_blocks = set([8,9,10,11])
 # (glass, half blocks)
 nospawn_blocks = set([20,44])
 
-# overlay rendermodes
-# FIXME hook this into render_modes in setup.py, somehow
-overlay_rendermodes = ['spawn']
-
 class ChunkCorrupt(Exception):
     pass
 

googlemap.py

@@ -23,7 +23,7 @@ from time import strftime, gmtime
 import json
 
 import util
-from chunk import overlay_rendermodes
+from c_overviewer import get_render_mode_inheritance
 
 """
 This module has routines related to generating a Google Maps-based
@@ -97,7 +97,7 @@ class MapGen(object):
         # create generated map type data, from given quadtrees
         maptypedata = map(lambda q: {'label' : q.rendermode.capitalize(),
                                      'path' : q.tiledir,
-                                     'overlay' : q.rendermode in overlay_rendermodes,
+                                     'overlay' : 'overlay' in get_render_mode_inheritance(q.rendermode),
                                      'imgformat' : q.imgformat},
                           self.quadtrees)
         config = config.replace("{maptypedata}", json.dumps(maptypedata))

quadtree.py

@@ -34,6 +34,7 @@ from PIL import Image
 
 import nbt
 import chunk
+from c_overviewer import get_render_mode_inheritance
 from optimizeimages import optimize_image
 import composite
 
@@ -64,7 +65,7 @@ class QuadtreeGen(object):
         self.rendermode = rendermode
         
         # force png renderformat if we're using an overlay mode
-        if rendermode in chunk.overlay_rendermodes:
+        if 'overlay' in get_render_mode_inheritance(rendermode):
             self.imgformat = "png"
 
         # Make the destination dir

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 */
 };
 

src/rendermode-cave.c

@@ -225,6 +225,7 @@ rendermode_cave_draw(void *data, RenderState *state, PyObject *src, PyObject *ma
 
 RenderModeInterface rendermode_cave = {
     "cave", "render only caves in normal mode",
+    &rendermode_normal,
     sizeof(RenderModeCave),
     rendermode_cave_start,
     rendermode_cave_finish,

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,

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,

src/rendermode-normal.c

@@ -221,6 +221,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,

src/rendermode-overlay.c

@@ -128,6 +128,7 @@ rendermode_overlay_draw(void *data, RenderState *state, PyObject *src, PyObject
 
 RenderModeInterface rendermode_overlay = {
     "overlay", "base rendermode for informational overlays",
+    NULL,
     sizeof(RenderModeOverlay),
     rendermode_overlay_start,
     rendermode_overlay_finish,

src/rendermode-spawn.c

@@ -109,6 +109,7 @@ rendermode_spawn_draw(void *data, RenderState *state, PyObject *src, PyObject *m
 
 RenderModeInterface rendermode_spawn = {
     "spawn", "draws a red overlay where monsters can spawn at night",
+    &rendermode_overlay,
     sizeof(RenderModeSpawn),
     rendermode_spawn_start,
     rendermode_spawn_finish,

src/rendermodes.c

@@ -98,5 +98,87 @@ PyObject *get_render_mode_info(PyObject *self, PyObject *args) {
     }
     
     Py_DECREF(info);
+    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;
+    if (!PyArg_ParseTuple(args, "s", &rendermode))
+        return NULL;
+    
+    parents = PyList_New(0);
+    if (!parents)
+        return NULL;
+    
+    RenderModeInterface *iface = 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;
+}

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 */