early triangle-drawing code

agrif · agrif · commit 711648c6d4fe · 2012-12-18T11:57:29.000-05:00
diff --git a/oil-backend-cpu.c b/oil-backend-cpu.c
@@ -2,16 +2,27 @@
 #include "oil-image-private.h"
 #include "oil-backend-private.h"
 
+typedef struct {
+    unsigned short *depth_buffer;
+} CPUPriv;
+
 /* like (a * b + 127) / 255), but fast */
 #define MULDIV255(a, b, tmp)                                \
 	(tmp = (a) * (b) + 128, ((((tmp) >> 8) + (tmp)) >> 8))
 
 static void oil_backend_cpu_new(OILImage *im) {
-    /* nothing to do */
+    /* add our data struct. FIXME fail if any of these are NULL */
+    CPUPriv *priv;
+    priv = im->backend_data = malloc(sizeof(CPUPriv));
+    priv->depth_buffer = NULL;
 }
 
 static void oil_backend_cpu_free(OILImage *im) {
-    /* nothing to do */
+    /* free our data struct */
+    CPUPriv *priv = im->backend_data;
+    if (priv->depth_buffer)
+        free(priv->depth_buffer);
+    free(priv);
 }
 
 static void oil_backend_cpu_load(OILImage *im) {
@@ -73,10 +84,125 @@ static int oil_backend_cpu_composite(OILImage *im, OILImage *src, unsigned char
     return 1;
 }
 
+/* draws a triangle on the destination image, multiplicatively!
+ * used for smooth lighting
+ * (excuse the ridiculous number of parameters!)
+ *
+ * Algorithm adapted from _Fundamentals_of_Computer_Graphics_
+ * by Peter Shirley, Michael Ashikhmin
+ * (or at least, the version poorly reproduced here:
+ *  http://www.gidforums.com/t-20838.html )
+ */
+
+static inline void draw_triangle(OILImage *im, int inclusive, OILVertex v0, OILVertex v1, OILVertex v2, OILTriangleFlags flags) {
+    CPUPriv *priv = im->backend_data;
+    /* ranges of pixels that are affected */
+    int xmin, xmax, ymin, ymax;
+    /* constant coefficients for alpha, beta, gamma */
+    int a12, a20, a01;
+    int b12, b20, b01;
+    int c12, c20, c01;
+    /* constant normalizers for alpha, beta, gamma */
+    float alpha_norm, beta_norm, gamma_norm;
+    /* temporary variables */
+    /*int tmp;*/
+    /* iteration variables */
+    int x, y;
+    
+    /* if we need to, initialize the depth buffer */
+    if (flags & OIL_DEPTH_TEST && priv->depth_buffer == NULL) {
+        priv->depth_buffer = calloc(im->width * im->height, sizeof(unsigned short));
+    }
+    
+    /* set up draw ranges */
+    xmin = OIL_MIN((int)(v0.x), OIL_MIN((int)(v1.x), (int)(v2.x)));
+    ymin = OIL_MIN((int)(v0.y), OIL_MIN((int)(v1.y), (int)(v2.y)));
+    xmax = OIL_MAX((int)(v0.x), OIL_MAX((int)(v1.x), (int)(v2.x))) + 1;
+    ymax = OIL_MAX((int)(v0.y), OIL_MAX((int)(v1.y), (int)(v2.y))) + 1;
+    
+    xmin = OIL_MAX(xmin, 0);
+    ymin = OIL_MAX(ymin, 0);
+    xmax = OIL_MIN(xmax, im->width);
+    ymax = OIL_MIN(ymax, im->height);
+    
+    /* setup coefficients */
+    a12 = (int)(v1.y) - (int)(v2.y); b12 = (int)(v2.x) - (int)(v1.x); c12 = ((int)(v1.x) * (int)(v2.y)) - ((int)(v2.x) * (int)(v1.y));
+    a20 = (int)(v2.y) - (int)(v0.y); b20 = (int)(v0.x) - (int)(v2.x); c20 = ((int)(v2.x) * (int)(v0.y)) - ((int)(v0.x) * (int)(v2.y));
+    a01 = (int)(v0.y) - (int)(v1.y); b01 = (int)(v1.x) - (int)(v0.x); c01 = ((int)(v0.x) * (int)(v1.y)) - ((int)(v1.x) * (int)(v0.y));
+    
+    /* setup normalizers */
+    alpha_norm = 1.0f / ((a12 * (int)(v0.x)) + (b12 * (int)(v0.y)) + c12);
+    beta_norm  = 1.0f / ((a20 * (int)(v1.x)) + (b20 * (int)(v1.y)) + c20);
+    gamma_norm = 1.0f / ((a01 * (int)(v2.x)) + (b01 * (int)(v2.y)) + c01);
+    
+    /* iterate over the destination rect */
+    for (y = ymin; y < ymax; y++) {
+        OILPixel *out = &(im->data[y * im->width + xmin]);
+        
+        for (x = xmin; x < xmax; x++) {
+            float alpha, beta, gamma;
+            alpha = alpha_norm * ((a12 * x) + (b12 * y) + c12);
+            beta  = beta_norm  * ((a20 * x) + (b20 * y) + c20);
+            gamma = gamma_norm * ((a01 * x) + (b01 * y) + c01);
+            
+            if (alpha >= 0 && beta >= 0 && gamma >= 0 &&
+                (inclusive || (alpha * beta * gamma > 0))) {
+                if (flags & OIL_DEPTH_TEST) {
+                    int depth = alpha * v0.z + beta * v1.z + gamma * v2.z;
+                    unsigned short *dbuffer = &(priv->depth_buffer[y * im->width + x]);
+                    if (depth >= *dbuffer) {
+                        /* write to our buffer */
+                        *dbuffer = depth;
+                    } else {
+                        /* skip this, it's behind something */
+                        out++;
+                        continue;
+                    }
+                }
+                out->r = alpha * v0.color.r + beta * v1.color.r + gamma * v2.color.r;
+                out->g = alpha * v0.color.g + beta * v1.color.g + gamma * v2.color.g;
+                out->b = alpha * v0.color.b + beta * v1.color.b + gamma * v2.color.b;
+                out->a = 255; /* FIXME */
+            }
+            
+            out++;
+        }
+    }
+}
+
+static void oil_backend_cpu_draw_triangles(OILImage *im, OILMatrix *matrix, OILVertex *vertices, unsigned int *indices, unsigned int indices_length, OILTriangleFlags flags) {
+    OILMatrix realmat;
+    unsigned int i;
+    
+    /* first we need to take the given matrix which yields [-1, 1] coordinates
+       to something that gives pixel x/y coordinates
+       also, invert Y because we want +Y to be up in 3D.
+       finally, we need [-1, 1] Z to map to [0, 2^16 - 1] for depth buffer */
+    oil_matrix_set_identity(&realmat);
+    oil_matrix_scale(&realmat, im->width/2.0f, -(im->height/2.0f), (0xffff/2.0));
+    oil_matrix_translate(&realmat, 1.0f, -1.0f, 1.0f);
+    oil_matrix_multiply(&realmat, &realmat, matrix);
+    
+    
+    for (i = 0; i < indices_length; i += 3) {
+        OILVertex v0, v1, v2;
+        v0 = vertices[indices[i]];
+        v1 = vertices[indices[i + 1]];
+        v2 = vertices[indices[i + 2]];
+        
+        oil_matrix_transform(&realmat, &(v0.x), &(v0.y), &(v0.z));
+        oil_matrix_transform(&realmat, &(v1.x), &(v1.y), &(v1.z));
+        oil_matrix_transform(&realmat, &(v2.x), &(v2.y), &(v2.z));
+                
+        draw_triangle(im, 1, v0, v1, v2, flags);
+    }
+}
+
 OILBackend oil_backend_cpu = {
     oil_backend_cpu_new,
     oil_backend_cpu_free,
     oil_backend_cpu_load,
     oil_backend_cpu_save,
     oil_backend_cpu_composite,
+    oil_backend_cpu_draw_triangles,
 };
diff --git a/oil-backend-debug.c b/oil-backend-debug.c
@@ -30,10 +30,16 @@ static int oil_backend_debug_composite(OILImage *im, OILImage *src, unsigned cha
     return oil_backend_cpu.composite(im, src, alpha, dx, dy, sx, sy, xsize, ysize);
 }
 
+static void oil_backend_debug_draw_triangles(OILImage *im, OILMatrix *matrix, OILVertex *vertices, unsigned int *indices, unsigned int indices_length, OILTriangleFlags flags) {
+    printf("draw_triangles(%p, %p, %p, %p, %i, %i)\n", im, matrix, vertices, indices, indices_length, flags);
+    oil_backend_cpu.draw_triangles(im, matrix, vertices, indices, indices_length, flags);
+}
+
 OILBackend oil_backend_debug = {
     oil_backend_debug_new,
     oil_backend_debug_free,
     oil_backend_debug_load,
     oil_backend_debug_save,
     oil_backend_debug_composite,
+    oil_backend_debug_draw_triangles,
 };
diff --git a/oil-backend-private.h b/oil-backend-private.h
@@ -17,6 +17,8 @@ typedef struct {
     
     /* do a composite. */
     int (*composite)(OILImage *im, OILImage *src, unsigned char alpha, int dx, int dy, unsigned int sx, unsigned int sy, unsigned int xsize, unsigned int ysize);
+    /* draw triangles */
+    void (*draw_triangles)(OILImage *im, OILMatrix *matrix, OILVertex *vertices, unsigned int *indices, unsigned int indices_length, OILTriangleFlags flags);
 } OILBackend;
 
 extern OILBackend *oil_backend;
diff --git a/oil-image-private.h b/oil-image-private.h
@@ -11,6 +11,7 @@ struct _OILImage {
     int locked;
     
     OILBackend *backend;
+    void *backend_data;
 };
 
 #endif /* __OIL_IMAGE_PRIVATE_H_INCLUDED__ */
diff --git a/oil-image.c b/oil-image.c
@@ -206,3 +206,12 @@ int oil_image_composite(OILImage *im, OILImage *src, unsigned char alpha, int dx
     /* and finally, call back into the backend if there is work to do */
     return im->backend->composite(im, src, alpha, dx, dy, sx, sy, xsize, ysize);
 }
+
+void oil_image_draw_triangles(OILImage *im, OILMatrix *matrix, OILVertex *vertices, unsigned int *indices, unsigned int indices_length, OILTriangleFlags flags) {
+    /* all of these are unhandleable */
+    if (!im || !vertices || !matrix || !indices || indices_length % 3 != 0)
+        return;
+    
+    /* ok now that that's out of the way, throw it to the backend */
+    im->backend->draw_triangles(im, matrix, vertices, indices, indices_length, flags);
+}
diff --git a/oil-matrix.c b/oil-matrix.c
@@ -55,6 +55,16 @@ int oil_matrix_is_zero(const OILMatrix *matrix)
     return 1;
 }
 
+void oil_matrix_transform(const OILMatrix *matrix, float *x, float *y, float *z) {
+    float ox, oy, oz;
+    ox = matrix->data[0][0] * (*x) + matrix->data[0][1] * (*y) + matrix->data[0][2] * (*z) + matrix->data[0][3];
+    oy = matrix->data[1][0] * (*x) + matrix->data[1][1] * (*y) + matrix->data[1][2] * (*z) + matrix->data[1][3];
+    oz = matrix->data[2][0] * (*x) + matrix->data[2][1] * (*y) + matrix->data[2][2] * (*z) + matrix->data[2][3];
+    *x = ox;
+    *y = oy;
+    *z = oz;
+}
+
 /* result == a is allowed, result == b is not */
 
 void oil_matrix_add(OILMatrix *result, const OILMatrix *a, const OILMatrix *b) {
diff --git a/oil-python.c b/oil-python.c
@@ -577,7 +577,7 @@ static PyObject *PyOILImage_composite(PyOILImage *self, PyObject *args) {
     int dx = 0, dy = 0;
     unsigned int sx = 0, sy = 0, xsize = 0, ysize = 0;
 
-    if (!PyArg_ParseTuple(args, "O!biiIIII", &PyOILImageType, &src, &alpha, &dx, &dy, &sx, &sy, &xsize, &ysize)) {
+    if (!PyArg_ParseTuple(args, "O!|biiIIII", &PyOILImageType, &src, &alpha, &dx, &dy, &sx, &sy, &xsize, &ysize)) {
         return NULL;
     }
     
@@ -589,6 +589,83 @@ static PyObject *PyOILImage_composite(PyOILImage *self, PyObject *args) {
     Py_RETURN_NONE;
 }
 
+static PyObject *PyOILImage_draw_triangles(PyOILImage *self, PyObject *args) {
+    unsigned int i;
+    PyOILMatrix *matrix = NULL;
+    PyObject *pyvertices = NULL;
+    PyObject *pyindices = NULL;
+    OILVertex *vertices = NULL;
+    unsigned int vertices_length = 0;
+    unsigned int *indices = NULL;
+    unsigned int indices_length = 0;
+    
+    if (!PyArg_ParseTuple(args, "O!OO", &PyOILMatrixType, &matrix, &pyvertices, &pyindices)) {
+        return NULL;
+    }
+    
+    pyvertices = PySequence_Fast(pyvertices, "vertices are not a sequence");
+    if (pyvertices)
+        pyindices = PySequence_Fast(pyindices, "indices are not a sequence");
+    if (!pyvertices || !pyindices) {
+        Py_XDECREF(pyvertices);
+        Py_XDECREF(pyindices);
+        return NULL;
+    }
+    
+    vertices_length = PySequence_Fast_GET_SIZE(pyvertices);
+    vertices = malloc(sizeof(OILVertex) * vertices_length);
+    indices_length = PySequence_Fast_GET_SIZE(pyindices);
+    indices = malloc(sizeof(unsigned int) * indices_length);
+    if (!vertices || !indices) {
+        if (vertices)
+            free(vertices);
+        if (indices)
+            free(indices);
+        Py_DECREF(pyvertices);
+        Py_DECREF(pyindices);
+        PyErr_SetString(PyExc_RuntimeError, "out of memory");
+        return NULL;
+    }
+    
+    for (i = 0; i < vertices_length; i++) {
+        PyObject *vert = PySequence_Fast_GET_ITEM(pyvertices, i);
+        if (!PyArg_ParseTuple(vert, "fff(bbbb)", &(vertices[i].x), &(vertices[i].y), &(vertices[i].z), &(vertices[i].color.r), &(vertices[i].color.g), &(vertices[i].color.b), &(vertices[i].color.a))) {
+            free(vertices);
+            free(indices);
+            Py_DECREF(pyvertices);
+            Py_DECREF(pyindices);
+            PyErr_SetString(PyExc_ValueError, "vertex has invalid form");
+            return NULL;
+        }
+    }
+    
+    for (i = 0; i < indices_length; i++) {
+        PyObject *pyindex = PySequence_Fast_GET_ITEM(pyindices, i);
+        pyindex = PyNumber_Index(pyindex);
+        if (!pyindex) {
+            free(vertices);
+            free(indices);
+            Py_DECREF(pyvertices);
+            Py_DECREF(pyindices);
+            PyErr_SetString(PyExc_ValueError, "index is not valid");
+            return NULL;
+        }
+        
+        indices[i] = PyInt_AsLong(pyindex);
+        Py_DECREF(pyindex);
+    }
+    
+    Py_DECREF(pyvertices);
+    Py_DECREF(pyindices);
+    
+    /* FIXME flags! */
+    oil_image_draw_triangles(self->im, &(matrix->matrix), vertices, indices, indices_length, OIL_DEPTH_TEST);
+    
+    free(vertices);
+    free(indices);
+    Py_RETURN_NONE;
+}
+
 static PyMethodDef PyOILImage_methods[] = {
     {"load", (PyCFunction)PyOILImage_load, METH_VARARGS | METH_CLASS,
      "Load the given path name into an Image object."},
@@ -598,6 +675,8 @@ static PyMethodDef PyOILImage_methods[] = {
      "Return a (width, height) tuple."},
     {"composite", (PyCFunction)PyOILImage_composite, METH_VARARGS,
      "Composite another image on top of this one."},
+    {"draw_triangles", (PyCFunction)PyOILImage_draw_triangles, METH_VARARGS,
+     "Draw 3D triangles on top of the image."},
     {NULL, NULL, 0, NULL}
 };
 
diff --git a/oil.h b/oil.h
@@ -32,6 +32,7 @@ void oil_matrix_set_identity(OILMatrix *matrix);
 void oil_matrix_set_data(OILMatrix *matrix, const float *data);
 int oil_matrix_is_identity(const OILMatrix *matrix);
 int oil_matrix_is_zero(const OILMatrix *matrix);
+void oil_matrix_transform(const OILMatrix *matrix, float *x, float *y, float *z);
 /* result == a is allowed, result == b is not */
 void oil_matrix_add(OILMatrix *result, const OILMatrix *a, const OILMatrix *b);
 void oil_matrix_subtract(OILMatrix *result, const OILMatrix *a, const OILMatrix *b);
@@ -65,6 +66,15 @@ typedef struct {
     unsigned int palette_size;
 } OILFormatOptions;
 
+typedef struct {
+    float x, y, z;
+    OILPixel color;
+} OILVertex;
+
+typedef enum {
+    OIL_DEPTH_TEST = 0x1,
+} OILTriangleFlags;
+
 OILImage *oil_image_new(unsigned int width, unsigned int height);
 void oil_image_free(OILImage *im);
 OILImage *oil_image_load(const char *path);
@@ -77,5 +87,6 @@ OILPixel *oil_image_lock(OILImage *im);
 void oil_image_unlock(OILImage *im);
 
 int oil_image_composite(OILImage *im, OILImage *src, unsigned char alpha, int dx, int dy, unsigned int sx, unsigned int sy, unsigned int xsize, unsigned int ysize);
+void oil_image_draw_triangles(OILImage *im, OILMatrix *matrix, OILVertex *vertices, unsigned int *indices, unsigned int indices_length, OILTriangleFlags flags);
 
 #endif /* __OIL_H_INCLUDED__ */
