235 lines
7.7 KiB
C
235 lines
7.7 KiB
C
/*
|
|
* This file is part of the Minecraft Overviewer.
|
|
*
|
|
* Minecraft Overviewer is free software: you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License as published
|
|
* by the Free Software Foundation, either version 3 of the License, or (at
|
|
* your option) any later version.
|
|
*
|
|
* Minecraft Overviewer is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
|
|
* Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along
|
|
* with the Overviewer. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "overviewer.h"
|
|
#include <math.h>
|
|
//~
|
|
//~ /* figures out the black_coeff from a given skylight and blocklight, used in
|
|
//~ lighting calculations -- note this is *different* from the one in
|
|
//~ rendermode-lighting.c (the "skylight - 11" part) */
|
|
//~ static float calculate_darkness(unsigned char skylight, unsigned char blocklight) {
|
|
//~ return 1.0f - powf(0.8f, 15.0 - MAX(blocklight, skylight - 11));
|
|
//~ }
|
|
|
|
static int
|
|
rendermode_cave_occluded(void *data, RenderState *state) {
|
|
int x = state->x, y = state->y, z = state->z, dz = 0;
|
|
RenderModeCave* self;
|
|
self = (RenderModeCave *)data;
|
|
|
|
/* check if the block is touching skylight */
|
|
if (z != 127) {
|
|
|
|
if (getArrayByte3D(self->skylight, x, y, z+1) != 0) {
|
|
return 1;
|
|
}
|
|
|
|
if ((x == 15)) {
|
|
if (self->up_right_skylight != Py_None) {
|
|
if (getArrayByte3D(self->up_right_skylight, 0, y, z) != 0) {
|
|
return 1;
|
|
}
|
|
}
|
|
} else {
|
|
if (getArrayByte3D(self->skylight, x+1, y, z) != 0) {
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
if (x == 0) {
|
|
if (self->left_skylight != Py_None) {
|
|
if (getArrayByte3D(self->left_skylight, 15, y, z) != 0) {
|
|
return 1;
|
|
}
|
|
}
|
|
} else {
|
|
if (getArrayByte3D(self->skylight, x-1, y, z) != 0) {
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
if (y == 15) {
|
|
if (self->right_skylight != Py_None) {
|
|
if (getArrayByte3D(self->right_skylight, 0, y, z) != 0) {
|
|
return 1;
|
|
}
|
|
}
|
|
} else {
|
|
if (getArrayByte3D(self->skylight, x, y+1, z) != 0) {
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
if (y == 0) {
|
|
if (self->up_left_skylight != Py_None) {
|
|
if (getArrayByte3D(self->up_left_skylight, 15, y, z) != 0) {
|
|
return 1;
|
|
}
|
|
}
|
|
} else {
|
|
if (getArrayByte3D(self->skylight, x, y-1, z) != 0) {
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
/* check for normal occlusion */
|
|
/* use ajacent chunks, if not you get blocks spreaded in chunk edges */
|
|
if ( (x == 0) && (y != 15) ) {
|
|
if (state->left_blocks != Py_None) {
|
|
if (!is_transparent(getArrayByte3D(state->left_blocks, 15, y, z)) &&
|
|
!is_transparent(getArrayByte3D(state->blocks, x, y, z+1)) &&
|
|
!is_transparent(getArrayByte3D(state->blocks, x, y+1, z))) {
|
|
return 1;
|
|
}
|
|
} else {
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
if ( (x != 0) && (y == 15) ) {
|
|
if (state->right_blocks != Py_None) {
|
|
if (!is_transparent(getArrayByte3D(state->blocks, x-1, y, z)) &&
|
|
!is_transparent(getArrayByte3D(state->right_blocks, x, 0, z)) &&
|
|
!is_transparent(getArrayByte3D(state->blocks, x, y, z+1))) {
|
|
return 1;
|
|
}
|
|
} else {
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
if ( (x == 0) && (y == 15) ) {
|
|
if ((state->left_blocks != Py_None) &&
|
|
(state->right_blocks != Py_None)) {
|
|
if (!is_transparent(getArrayByte3D(state->left_blocks, 15, y, z)) &&
|
|
!is_transparent(getArrayByte3D(state->right_blocks, x, 0, z)) &&
|
|
!is_transparent(getArrayByte3D(state->blocks, x, y, z+1))) {
|
|
return 1;
|
|
}
|
|
} else {
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
if ( (x != 0) && (y != 15) &&
|
|
!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;
|
|
}
|
|
|
|
} else { /* if z == 127 skip */
|
|
return 1;
|
|
}
|
|
|
|
/* check for lakes and seas and don't render them */
|
|
/* at this point of the code the block has no skylight
|
|
* and is not occluded, but a deep sea can fool these
|
|
* 2 tests */
|
|
|
|
if ((getArrayByte3D(state->blocks, x, y, z) == 9) ||
|
|
(getArrayByte3D(state->blocks, x, y, z+1) == 9)) {
|
|
|
|
for (dz = z+1; dz < 127; dz++) { /* go up and check for skylight */
|
|
if (getArrayByte3D(self->skylight, x, y, dz) != 0) {
|
|
return 1;
|
|
}
|
|
if (getArrayByte3D(state->blocks, x, y, dz) != 9) {
|
|
/* we are out of the water! and there's no skylight
|
|
* , i.e. is a cave lake or something similar */
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
rendermode_cave_start(void *data, RenderState *state) {
|
|
RenderModeCave* self;
|
|
int ret;
|
|
self = (RenderModeCave *)data;
|
|
|
|
/* first, chain up */
|
|
ret = rendermode_normal.start(data, state);
|
|
if (ret != 0)
|
|
return ret;
|
|
|
|
/* if there's skylight we are in the surface! */
|
|
self->skylight = PyObject_GetAttrString(state->self, "skylight");
|
|
self->left_skylight = PyObject_GetAttrString(state->self, "left_skylight");
|
|
self->right_skylight = PyObject_GetAttrString(state->self, "right_skylight");
|
|
self->up_left_skylight = PyObject_GetAttrString(state->self, "up_left_skylight");
|
|
self->up_right_skylight = PyObject_GetAttrString(state->self, "up_right_skylight");
|
|
|
|
/* colors for tinting */
|
|
self->depth_colors = PyObject_GetAttrString(state->chunk, "depth_colors");
|
|
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
rendermode_cave_finish(void *data, RenderState *state) {
|
|
RenderModeCave* self;
|
|
self = (RenderModeCave *)data;
|
|
|
|
Py_DECREF(self->skylight);
|
|
Py_DECREF(self->left_skylight);
|
|
Py_DECREF(self->right_skylight);
|
|
Py_DECREF(self->up_left_skylight);
|
|
Py_DECREF(self->up_right_skylight);
|
|
|
|
Py_DECREF(self->depth_colors);
|
|
|
|
rendermode_normal.finish(data, state);
|
|
}
|
|
|
|
static void
|
|
rendermode_cave_draw(void *data, RenderState *state, PyObject *src, PyObject *mask, PyObject *mask_light) {
|
|
RenderModeCave* self;
|
|
int z, r, g, b;
|
|
self = (RenderModeCave *)data;
|
|
|
|
z = state->z;
|
|
r = 0, g = 0, b = 0;
|
|
|
|
/* draw the normal block */
|
|
rendermode_normal.draw(data, state, src, mask, mask_light);
|
|
|
|
/* get the colors and tint and tint */
|
|
/* TODO TODO for a nether mode there isn't tinting! */
|
|
r = PyInt_AsLong(PyList_GetItem(self->depth_colors, 0 + z*3));
|
|
g = PyInt_AsLong(PyList_GetItem(self->depth_colors, 1 + z*3));
|
|
b = PyInt_AsLong(PyList_GetItem(self->depth_colors, 2 + z*3));
|
|
|
|
tint_with_mask(state->img, r, g, b, 255, mask, state->imgx, state->imgy, 0, 0);
|
|
|
|
}
|
|
|
|
RenderModeInterface rendermode_cave = {
|
|
"cave", "render only caves in normal mode",
|
|
&rendermode_normal,
|
|
sizeof(RenderModeCave),
|
|
rendermode_cave_start,
|
|
rendermode_cave_finish,
|
|
rendermode_cave_occluded,
|
|
rendermode_cave_draw,
|
|
};
|