Merge branch 'dtt-c-render' into overlays

Conflicts:
	overviewer.py
	setup.py

src/endian.c

@@ -23,7 +23,7 @@
 
 static int endianness = UNKNOWN_ENDIAN;
 
-void init_endian() {
+void init_endian(void) {
     /* figure out what our endianness is! */
     short word = 0x0001;
     char* byte = (char*)(&word);

src/main.c

@@ -22,6 +22,10 @@ static PyMethodDef COverviewerMethods[] = {
      "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"},
     {NULL, NULL, 0, NULL}       /* Sentinel */
 };
 

src/rendermode-lighting.c

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

src/rendermode-night.c

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

src/rendermode-normal.c

@@ -164,6 +164,7 @@ rendermode_normal_draw(void *data, RenderState *state, PyObject *src, PyObject *
 }
 
 RenderModeInterface rendermode_normal = {
+    "normal", "nothing special, just render the blocks",
     sizeof(RenderModeNormal),
     rendermode_normal_start,
     rendermode_normal_finish,

src/rendermode-overlay.c

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

src/rendermode-spawn.c

@@ -105,6 +105,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",
     sizeof(RenderModeSpawn),
     rendermode_spawn_start,
     rendermode_spawn_finish,

src/rendermodes.c

@@ -18,21 +18,84 @@
 #include "overviewer.h"
 #include <string.h>
 
+/* list of all render modes, ending in NULL
+   all of these will be available to the user, so DON'T include modes
+   that are only useful as a base for other modes. */
+static RenderModeInterface *render_modes[] = {
+    &rendermode_normal,
+    &rendermode_lighting,
+    &rendermode_night,
+    &rendermode_spawn,
+    NULL
+};
+
 /* decides which render mode to use */
 RenderModeInterface *get_render_mode(RenderState *state) {
-    /* default: normal */
-    RenderModeInterface *iface = &rendermode_normal;
+    unsigned int i;
+    /* default: NULL --> an error */
+    RenderModeInterface *iface = NULL;
     PyObject *rendermode_py = PyObject_GetAttrString(state->self, "rendermode");
     const char *rendermode = PyString_AsString(rendermode_py);
     
-    if (strcmp(rendermode, "lighting") == 0) {
-        iface = &rendermode_lighting;
-    } else if (strcmp(rendermode, "night") == 0) {
-        iface = &rendermode_night;
-    } else if (strcmp(rendermode, "spawn") == 0) {
-        iface = &rendermode_spawn;
+    for (i = 0; render_modes[i] != NULL; i++) {
+        if (strcmp(render_modes[i]->name, rendermode) == 0) {
+            iface = render_modes[i];
+            break;
+        }
     }
     
     Py_DECREF(rendermode_py);
     return iface;
 }
+
+/* bindings for python -- get all the rendermode names */
+PyObject *get_render_modes(PyObject *self, PyObject *args) {
+    PyObject *modes;
+    unsigned int i;
+    if (!PyArg_ParseTuple(args, ""))
+        return NULL;
+    
+    modes = PyList_New(0);
+    if (modes == NULL)
+        return NULL;
+    
+    for (i = 0; render_modes[i] != NULL; i++) {
+        PyObject *name = PyString_FromString(render_modes[i]->name);
+        PyList_Append(modes, name);
+        Py_DECREF(name);
+    }
+    
+    return modes;
+}
+
+/* more bindings -- return info for a given rendermode name */
+PyObject *get_render_mode_info(PyObject *self, PyObject *args) {
+    const char* rendermode;
+    PyObject *info;
+    unsigned int i;
+    if (!PyArg_ParseTuple(args, "s", &rendermode))
+        return NULL;
+    
+    info = PyDict_New();
+    if (info == NULL)
+        return NULL;
+    
+    for (i = 0; render_modes[i] != NULL; i++) {
+        if (strcmp(render_modes[i]->name, rendermode) == 0) {
+            PyObject *tmp;
+            
+            tmp = PyString_FromString(render_modes[i]->name);
+            PyDict_SetItemString(info, "name", tmp);
+            Py_DECREF(tmp);
+            
+            tmp = PyString_FromString(render_modes[i]->description);
+            PyDict_SetItemString(info, "description", tmp);
+            Py_DECREF(tmp);
+            
+            return info;
+        }
+    }
+    
+    Py_DECREF(info);
+    Py_RETURN_NONE;
+}

src/rendermodes.h

@@ -29,7 +29,7 @@
  *         (see rendermode-night.c for a simple example derived from
  *          the "lighting" mode)
  *
- *     * add a condition to get_render_mode() in rendermodes.c
+ *     * add your mode to the list in rendermodes.c
  */
 
 #ifndef __RENDERMODES_H_INCLUDED__
@@ -39,6 +39,11 @@
 
 /* rendermode interface */
 typedef struct {
+    /* the name of this mode */
+    const char* name;
+    /* the short description of this render mode */
+    const char* description;
+    
     /* the size of the local storage for this rendermode */
     unsigned int data_size;
     
@@ -53,6 +58,9 @@ typedef struct {
 
 /* 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);
 
 /* individual rendermode interface declarations follow */