66a9306a29
Please see the TODO comments in iterate.c None of the lighting, spawning, night, or cave modes work with this version.
374 lines
11 KiB
C
374 lines
11 KiB
C
#include <Python.h>
|
|
|
|
#include <numpy/arrayobject.h>
|
|
#include <Imaging.h>
|
|
|
|
|
|
/* like (a * b + 127) / 255), but much faster on most platforms
|
|
from PIL's _imaging.c */
|
|
#define MULDIV255(a, b, tmp) \
|
|
(tmp = (a) * (b) + 128, ((((tmp) >> 8) + (tmp)) >> 8))
|
|
|
|
typedef struct
|
|
{
|
|
PyObject_HEAD
|
|
Imaging image;
|
|
} ImagingObject;
|
|
|
|
// macro for getting blockID from a chunk of memory
|
|
#define getBlock(blockThing, x,y,z) blockThing[ y + ( z * 128 + ( x * 128 * 16) ) ]
|
|
|
|
static inline int isTransparent(unsigned char b) {
|
|
// TODO expand this to include all transparent blocks
|
|
return b == 0;
|
|
|
|
}
|
|
|
|
|
|
static Imaging imaging_python_to_c(PyObject* obj)
|
|
{
|
|
PyObject* im;
|
|
Imaging image;
|
|
|
|
/* first, get the 'im' attribute */
|
|
im = PyObject_GetAttrString(obj, "im");
|
|
if (!im)
|
|
return NULL;
|
|
|
|
/* make sure 'im' is the right type */
|
|
if (strcmp(im->ob_type->tp_name, "ImagingCore") != 0)
|
|
{
|
|
/* it's not -- raise an error and exit */
|
|
PyErr_SetString(PyExc_TypeError, "image attribute 'im' is not a core Imaging type");
|
|
return NULL;
|
|
}
|
|
|
|
image = ((ImagingObject*)im)->image;
|
|
Py_DECREF(im);
|
|
return image;
|
|
}
|
|
|
|
|
|
|
|
// TODO refact iterate.c and _composite.c so share implementations
|
|
static PyObject* alpha_over(PyObject* dest, PyObject* t, int imgx, int imgy)
|
|
{
|
|
/* raw input python variables */
|
|
PyObject * src, * mask;
|
|
/* libImaging handles */
|
|
Imaging imDest, imSrc, imMask;
|
|
/* cached blend properties */
|
|
int src_has_alpha, mask_offset, mask_stride;
|
|
/* destination position and size */
|
|
int dx, dy, xsize, ysize;
|
|
/* source position */
|
|
int sx, sy;
|
|
/* iteration variables */
|
|
unsigned int x, y, i;
|
|
/* temporary calculation variables */
|
|
int tmp1, tmp2, tmp3;
|
|
|
|
src = PyTuple_GET_ITEM(t, 0);
|
|
mask = PyTuple_GET_ITEM(t, 1);
|
|
if (mask == Py_None) {
|
|
printf("mask is none\n");
|
|
Py_INCREF(mask);
|
|
mask = src;
|
|
}
|
|
//if (!PyArg_ParseTuple(args, "OOOO", &dest, &src, &pos, &mask))
|
|
// return NULL;
|
|
|
|
imDest = imaging_python_to_c(dest);
|
|
imSrc = imaging_python_to_c(src);
|
|
imMask = imaging_python_to_c(mask);
|
|
|
|
//printf("alpha1\n");
|
|
if (!imDest || !imSrc || !imMask) {
|
|
PyErr_SetString(PyExc_ValueError, "dest, src, or mask is missing");
|
|
return NULL;
|
|
}
|
|
//printf("alpha2\n");
|
|
|
|
/* check the various image modes, make sure they make sense */
|
|
if (strcmp(imDest->mode, "RGBA") != 0)
|
|
{
|
|
PyErr_SetString(PyExc_ValueError, "given destination image does not have mode \"RGBA\"");
|
|
return NULL;
|
|
}
|
|
|
|
if (strcmp(imSrc->mode, "RGBA") != 0 && strcmp(imSrc->mode, "RGB") != 0)
|
|
{
|
|
PyErr_SetString(PyExc_ValueError, "given source image does not have mode \"RGBA\" or \"RGB\"");
|
|
return NULL;
|
|
}
|
|
|
|
if (strcmp(imMask->mode, "RGBA") != 0 && strcmp(imMask->mode, "L") != 0)
|
|
{
|
|
PyErr_SetString(PyExc_ValueError, "given mask image does not have mode \"RGBA\" or \"L\"");
|
|
return NULL;
|
|
}
|
|
|
|
/* make sure mask size matches src size */
|
|
if (imSrc->xsize != imMask->xsize || imSrc->ysize != imMask->ysize)
|
|
{
|
|
PyErr_SetString(PyExc_ValueError, "mask and source image sizes do not match");
|
|
return NULL;
|
|
}
|
|
|
|
//printf("alpha3\n");
|
|
/* set up flags for the src/mask type */
|
|
src_has_alpha = (imSrc->pixelsize == 4 ? 1 : 0);
|
|
/* how far into image the first alpha byte resides */
|
|
mask_offset = (imMask->pixelsize == 4 ? 3 : 0);
|
|
/* how many bytes to skip to get to the next alpha byte */
|
|
mask_stride = imMask->pixelsize;
|
|
|
|
//printf("alpha4\n");
|
|
/* destination position read */
|
|
//if (!PyArg_ParseTuple(pos, "iiii", &dx, &dy, &xsize, &ysize))
|
|
//{
|
|
// PyErr_SetString(PyExc_TypeError, "given blend destination rect is not valid");
|
|
// return NULL;
|
|
//}
|
|
dx = imgx;
|
|
dy = imgy;
|
|
|
|
xsize = imSrc->xsize;
|
|
ysize = imSrc->ysize;
|
|
//printf("xsize/ysize %d/%d\n", xsize, ysize);
|
|
|
|
//printf("alpha5\n");
|
|
|
|
/* set up the source position, size and destination position */
|
|
/* handle negative dest pos */
|
|
if (dx < 0)
|
|
{
|
|
sx = -dx;
|
|
dx = 0;
|
|
} else {
|
|
sx = 0;
|
|
}
|
|
|
|
if (dy < 0)
|
|
{
|
|
sy = -dy;
|
|
dy = 0;
|
|
} else {
|
|
sy = 0;
|
|
}
|
|
|
|
/* set up source dimensions */
|
|
xsize -= sx;
|
|
ysize -= sy;
|
|
|
|
//printf("imDest->xsize=%d imDest->yize=%d\n", imDest->xsize, imDest->ysize);
|
|
|
|
/* clip dimensions, if needed */
|
|
if (dx + xsize > imDest->xsize)
|
|
xsize = imDest->xsize - dx;
|
|
if (dy + ysize > imDest->ysize)
|
|
ysize = imDest->ysize - dy;
|
|
|
|
/* check that there remains any blending to be done */
|
|
if (xsize <= 0 || ysize <= 0)
|
|
{
|
|
/* nothing to do, return */
|
|
Py_INCREF(dest);
|
|
return dest;
|
|
}
|
|
|
|
for (y = 0; y < ysize; y++)
|
|
{
|
|
UINT8* out = (UINT8*) imDest->image[dy + y] + dx*4;
|
|
UINT8* outmask = (UINT8*) imDest->image[dy + y] + dx*4 + 3;
|
|
UINT8* in = (UINT8*) imSrc->image[sy + y] + sx*(imSrc->pixelsize);
|
|
UINT8* inmask = (UINT8*) imMask->image[sy + y] + sx*mask_stride + mask_offset;
|
|
|
|
for (x = 0; x < xsize; x++)
|
|
{
|
|
/* special cases */
|
|
if (*inmask == 255 || *outmask == 0)
|
|
{
|
|
*outmask = *inmask;
|
|
|
|
*out = *in;
|
|
out++, in++;
|
|
*out = *in;
|
|
out++, in++;
|
|
*out = *in;
|
|
out++, in++;
|
|
} else if (*inmask == 0) {
|
|
/* do nothing -- source is fully transparent */
|
|
out += 3;
|
|
in += 3;
|
|
} else {
|
|
/* general case */
|
|
int alpha = *inmask + MULDIV255(*outmask, 255 - *inmask, tmp1);
|
|
for (i = 0; i < 3; i++)
|
|
{
|
|
/* general case */
|
|
*out = MULDIV255(*in, *inmask, tmp1) + MULDIV255(MULDIV255(*out, *outmask, tmp2), 255 - *inmask, tmp3);
|
|
*out = (*out * 255) / alpha;
|
|
out++, in++;
|
|
}
|
|
|
|
*outmask = alpha;
|
|
}
|
|
|
|
out++;
|
|
if (src_has_alpha)
|
|
in++;
|
|
outmask += 4;
|
|
inmask += mask_stride;
|
|
}
|
|
}
|
|
|
|
Py_INCREF(dest);
|
|
return dest;
|
|
}
|
|
|
|
|
|
|
|
// TODO triple check this to make sure reference counting is correct
|
|
static PyObject*
|
|
chunk_render(PyObject *self, PyObject *args) {
|
|
|
|
PyObject *chunk;
|
|
PyObject *blockdata_expanded;
|
|
int xoff, yoff;
|
|
PyObject *img;
|
|
|
|
if (!PyArg_ParseTuple(args, "OOiiO", &chunk, &img, &xoff, &yoff, &blockdata_expanded))
|
|
return Py_BuildValue("i", "-1");
|
|
|
|
// tuple
|
|
PyObject *imgsize = PyObject_GetAttrString(img, "size");
|
|
|
|
PyObject *imgsize0_py = PySequence_GetItem(imgsize, 0);
|
|
PyObject *imgsize1_py = PySequence_GetItem(imgsize, 1);
|
|
Py_DECREF(imgsize);
|
|
|
|
int imgsize0 = PyInt_AsLong(imgsize0_py);
|
|
int imgsize1 = PyInt_AsLong(imgsize1_py);
|
|
Py_DECREF(imgsize0_py);
|
|
Py_DECREF(imgsize1_py);
|
|
|
|
|
|
// get the block data directly from numpy:
|
|
PyObject *blocks_py = PyObject_GetAttrString(chunk, "blocks");
|
|
char *blocks = PyArray_BYTES(blocks_py);
|
|
Py_DECREF(blocks_py);
|
|
|
|
//PyObject *left_blocks = PyObject_GetAttrString(chunk, "left_blocks");
|
|
//PyObject *right_blocks = PyObject_GetAttrString(chunk, "right_blocks");
|
|
//PyObject *transparent_blocks = PyObject_GetAttrString(chunk, "transparent_blocks");
|
|
|
|
PyObject *textures = PyImport_ImportModule("textures");
|
|
|
|
// TODO can these be global static? these don't change during program execution
|
|
PyObject *blockmap = PyObject_GetAttrString(textures, "blockmap");
|
|
PyObject *special_blocks = PyObject_GetAttrString(textures, "special_blocks");
|
|
PyObject *specialblockmap = PyObject_GetAttrString(textures, "specialblockmap");
|
|
|
|
Py_DECREF(textures);
|
|
|
|
//printf("render_loop\n");
|
|
|
|
int imgx, imgy;
|
|
int x, y, z;
|
|
for (x = 15; x > -1; x--) {
|
|
for (y = 0; y < 16; y++) {
|
|
imgx = xoff + x*12 + y*12;
|
|
imgy = yoff - x*6 + y*6 + 1632; // 1632 == 128*12 + 16*12//2
|
|
for (z = 0; z < 128; z++) {
|
|
//printf("c/imgx/%d\n", imgx);
|
|
//printf("c/imgy/%d\n", imgy);
|
|
if ((imgx >= imgsize0 + 24) || (imgx <= -24)) {
|
|
imgy -= 12; // NOTE: we need to do this at every continue
|
|
continue;
|
|
}
|
|
if ((imgy >= imgsize1 + 24) || (imgy <= -24)) {
|
|
imgy -= 12;
|
|
continue;
|
|
}
|
|
|
|
// get blockid
|
|
unsigned char block = getBlock(blocks, x, z, y); // Note the order: x,z,y
|
|
if (block == 0) {
|
|
imgy -= 12;
|
|
continue;
|
|
}
|
|
//printf("checking blockid %hhu\n", block);
|
|
PyObject *blockid = PyInt_FromLong(block); // TODO figure out how to DECREF this easily, instead at every 'continue'.
|
|
|
|
|
|
if ( (x != 0) && (y != 15) && (z != 127) &&
|
|
!isTransparent(getBlock(blocks, x-1, z, y)) &&
|
|
!isTransparent(getBlock(blocks, x, z+1, y)) &&
|
|
!isTransparent(getBlock(blocks, x, z, y+1)) ) {
|
|
imgy -= 12;
|
|
continue;
|
|
}
|
|
|
|
|
|
if (!PySequence_Contains(special_blocks, blockid)) {
|
|
//t = textures.blockmap[blockid]
|
|
PyObject *t = PyList_GetItem(blockmap, block);
|
|
// PyList_GetItem returns borrowed ref
|
|
if (t == Py_None) {
|
|
printf("t == Py_None. blockid=%d\n", block);
|
|
imgy -= 12;
|
|
continue;
|
|
|
|
}
|
|
|
|
// note that this version of alpha_over has a different signature than the
|
|
// version in _composite.c
|
|
alpha_over(img, t, imgx, imgy );
|
|
|
|
} else {
|
|
// this should be a pointer to a unsigned char
|
|
void* ancilData_p = PyArray_GETPTR3(blockdata_expanded, x, y, z);
|
|
unsigned char ancilData = *((unsigned char*)ancilData_p);
|
|
if (block == 85) { // fence. skip the generate_pseudo_ancildata for now
|
|
imgy -= 12;
|
|
continue;
|
|
}
|
|
PyObject *tmp = PyTuple_New(2);
|
|
|
|
Py_INCREF(blockid); // because SetItem steals
|
|
PyTuple_SetItem(tmp, 0, blockid);
|
|
PyTuple_SetItem(tmp, 1, PyInt_FromLong(ancilData));
|
|
PyObject *t = PyDict_GetItem(specialblockmap, tmp); // this is a borrowed reference. no need to decref
|
|
Py_DECREF(tmp);
|
|
if (t != NULL)
|
|
alpha_over(img, t, imgx, imgy );
|
|
imgy -= 12;
|
|
continue;
|
|
}
|
|
imgy -= 12;
|
|
}
|
|
}
|
|
}
|
|
|
|
Py_DECREF(blockmap);
|
|
Py_DECREF(special_blocks);
|
|
Py_DECREF(specialblockmap);
|
|
|
|
return Py_BuildValue("i",2);
|
|
}
|
|
|
|
static PyMethodDef IterateMethods[] = {
|
|
{"render_loop", chunk_render, METH_VARARGS,
|
|
"Renders stuffs"},
|
|
{NULL, NULL, 0, NULL} /* Sentinel */
|
|
};
|
|
|
|
|
|
PyMODINIT_FUNC
|
|
init_iterate(void)
|
|
{
|
|
(void) Py_InitModule("_iterate", IterateMethods);
|
|
import_array(); // for numpy
|
|
}
|