backups/4jcraft
1
0
Fork 0
mirror of https://github.com/4jcraft/4jcraft.git synced 2026-04-27 18:46:25 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
4jcraft/Minecraft.Client/Platform/PS3/SPU_Tasks/ChunkUpdate/TileRenderer_SPU.cpp
orng 9fe3315112 refactor: remove vec3 tls
2026-03-26 13:37:01 -05:00

7593 lines
278 KiB
C++
Raw Blame History

#include "stdafx.h"
#include "TileRenderer_SPU.h"
#include "LiquidTile_SPU.h"
#include "FireTile_SPU.h"
#include "RailTile_SPU.h"
#include "StemTile_SPU.h"
#include "VineTile_SPU.h"
#include "WaterLilyTile_SPU.h"
#include "BrewingStandTile_SPU.h"
#include "RedStoneDustTile_SPU.h"
#include "DiodeTile_SPU.h"
#include "FenceGateTile_SPU.h"
#include "StairTile_SPU.h"
#include "EggTile_SPU.h"
#include "DoorTile_SPU.h"
#include "FenceTile_SPU.h"
#include "GrassTile_SPU.h"
#include "TreeTile_SPU.h"
#include "WallTile_SPU.h"
#include "QuartzBlockTile_SPU.h"
// #include <string>
#include <math.h>
#include <assert.h>
#ifdef SN_TARGET_PS3_SPU
#include "../Common/spu_assert.h"
#endif
static const float MATH_PI = 3.141592654f;
// #include "../../../../Rendering/GameRenderer.h"
// #include "../../../../Minecraft.h"
// #include "../../../../Textures/Textures.h"
// #include "../../../../../Minecraft.World/Headers/net.minecraft.world.level.h"
// #include "../../../Minecraft.World/net.minecraft.world.level.tile.h"
// #include
// "../../../../../Minecraft.World/Headers/net.minecraft.world.level.material.h"
// #include "../../../../../Minecraft.World/Headers/net.minecraft.h"
// #include "../../../../../Minecraft.World/Headers/net.minecraft.world.h"
// #include "../../../Minecraft.World/net.minecraft.world.level.tile.h"
#include "Tesselator_SPU.h"
#ifdef SN_TARGET_PS3_SPU
#include "Stubs_SPU.h"
#endif // SN_TARGET_PS3_SPU
// #include "../../../../../Minecraft.World/Util/SharedConstants.h"
#include "Facing_SPU.h"
// #include "../../../../Rendering/EntityRenderers/EntityTileRenderer.h"
// #include "../../../../GameState/Options.h"
// #define DISABLE_TESS_FUNCS
#ifdef SN_TARGET_PS3_SPU
class SharedConstants {
public:
static const bool TEXTURE_LIGHTING = true;
static const int WORLD_RESOLUTION = 16;
};
#endif
// #define SN_TARGET_PS3_SPU
bool TileRenderer_SPU::fancy = true;
bool g_ambientOcclusionMax =
false; // minecraft->options->ambientOcclusion >= Options::AO_MAX
const float smallUV = (1.0f / 16.0f);
void TileRenderer_SPU::_init() {
fixedTexture = NULL;
xFlipTexture = false;
noCulling = false;
blsmooth = 1;
applyAmbienceOcclusion = false;
setColor = true;
northFlip = FLIP_NONE;
southFlip = FLIP_NONE;
eastFlip = FLIP_NONE;
westFlip = FLIP_NONE;
upFlip = FLIP_NONE;
downFlip = FLIP_NONE;
tileShapeX0 = 0.0;
tileShapeX1 = 0.0;
tileShapeY0 = 0.0;
tileShapeY1 = 0.0;
tileShapeZ0 = 0.0;
tileShapeZ1 = 0.0;
fixedShape = false;
smoothShapeLighting = false;
// minecraft = Minecraft::GetInstance();
}
TileRenderer_SPU::TileRenderer_SPU(ChunkRebuildData* level) {
this->level = level;
_init();
}
TileRenderer_SPU::TileRenderer_SPU() {
this->level = NULL;
_init();
}
Tesselator_SPU* TileRenderer_SPU::getTesselator() {
Tesselator_SPU* t = &level->m_tesselator;
return t;
}
void TileRenderer_SPU::setFixedTexture(Icon_SPU* fixedTexture) {
this->fixedTexture = fixedTexture;
}
void TileRenderer_SPU::clearFixedTexture() { this->fixedTexture = NULL; }
bool TileRenderer_SPU::hasFixedTexture() { return fixedTexture != NULL; }
void TileRenderer_SPU::setShape(float x0, float y0, float z0, float x1,
float y1, float z1) {
if (!fixedShape) {
tileShapeX0 = x0;
tileShapeX1 = x1;
tileShapeY0 = y0;
tileShapeY1 = y1;
tileShapeZ0 = z0;
tileShapeZ1 = z1;
smoothShapeLighting =
(tileShapeX0 > 0 || tileShapeX1 < 1 || tileShapeY0 > 0 ||
tileShapeY1 < 1 || tileShapeZ0 > 0 || tileShapeZ1 < 1);
}
}
void TileRenderer_SPU::setShape(Tile_SPU* tt) {
if (!fixedShape) {
tileShapeX0 = tt->getShapeX0();
tileShapeX1 = tt->getShapeX1();
tileShapeY0 = tt->getShapeY0();
tileShapeY1 = tt->getShapeY1();
tileShapeZ0 = tt->getShapeZ0();
tileShapeZ1 = tt->getShapeZ1();
smoothShapeLighting =
(tileShapeX0 > 0 || tileShapeX1 < 1 || tileShapeY0 > 0 ||
tileShapeY1 < 1 || tileShapeZ0 > 0 || tileShapeZ1 < 1);
}
}
void TileRenderer_SPU::setFixedShape(float x0, float y0, float z0, float x1,
float y1, float z1) {
tileShapeX0 = x0;
tileShapeX1 = x1;
tileShapeY0 = y0;
tileShapeY1 = y1;
tileShapeZ0 = z0;
tileShapeZ1 = z1;
fixedShape = true;
smoothShapeLighting =
(tileShapeX0 > 0 || tileShapeX1 < 1 || tileShapeY0 > 0 ||
tileShapeY1 < 1 || tileShapeZ0 > 0 || tileShapeZ1 < 1);
}
void TileRenderer_SPU::clearFixedShape() { fixedShape = false; }
void TileRenderer_SPU::tesselateInWorldFixedTexture(
Tile_SPU* tile, int x, int y, int z,
Icon_SPU*
fixedTexture) // 4J renamed to differentiate from tesselateInWorld
{
this->setFixedTexture(fixedTexture);
tesselateInWorld(tile, x, y, z);
this->clearFixedTexture();
}
void TileRenderer_SPU::tesselateInWorldNoCulling(
Tile_SPU* tile, int x, int y, int z, int forceData,
TileEntity* forceEntity) // 4J added forceData, forceEntity param
{
noCulling = true;
tesselateInWorld(tile, x, y, z, forceData);
noCulling = false;
}
bool TileRenderer_SPU::hasRenderer(Tile_SPU* tt) {
int shape = tt->getRenderShape();
bool retVal = false;
switch (shape) {
case Tile_SPU::SHAPE_BLOCK:
case Tile_SPU::SHAPE_WATER:
case Tile_SPU::SHAPE_CACTUS:
case Tile_SPU::SHAPE_STEM:
case Tile_SPU::SHAPE_LILYPAD:
case Tile_SPU::SHAPE_ROWS:
case Tile_SPU::SHAPE_TORCH:
case Tile_SPU::SHAPE_FIRE:
case Tile_SPU::SHAPE_LADDER:
case Tile_SPU::SHAPE_DOOR:
case Tile_SPU::SHAPE_RAIL:
case Tile_SPU::SHAPE_EGG:
case Tile_SPU::SHAPE_VINE:
case Tile_SPU::SHAPE_BREWING_STAND:
case Tile_SPU::SHAPE_CROSS_TEXTURE:
case Tile_SPU::SHAPE_FENCE:
retVal = true;
break;
case Tile_SPU::SHAPE_FENCE_GATE:
case Tile_SPU::SHAPE_RED_DUST:
case Tile_SPU::SHAPE_STAIRS:
case Tile_SPU::SHAPE_DIODE:
case Tile_SPU::SHAPE_LEVER:
case Tile_SPU::SHAPE_BED:
case Tile_SPU::SHAPE_PISTON_BASE:
case Tile_SPU::SHAPE_PISTON_EXTENSION:
case Tile_SPU::SHAPE_IRON_FENCE:
case Tile_SPU::SHAPE_CAULDRON:
case Tile_SPU::SHAPE_PORTAL_FRAME:
retVal = false;
break;
}
return retVal;
}
bool TileRenderer_SPU::tesselateInWorld(
Tile_SPU* tt, int x, int y, int z, int forceData,
TileEntity* forceEntity) // 4J added forceData, forceEntity param
{
Tesselator_SPU* t = getTesselator();
int shape = tt->getRenderShape();
tt->updateShape(level, x, y, z, forceData, forceEntity);
setShape(tt);
t->setMipmapEnable(level->m_tileData.mipmapEnable[tt->id]); // 4J added
bool retVal = false;
switch (shape) {
case Tile_SPU::SHAPE_BLOCK:
retVal = tesselateBlockInWorld(tt, x, y, z);
break;
case Tile_SPU::SHAPE_TREE:
retVal = tesselateTreeInWorld(tt, x, y, z);
break;
case Tile_SPU::SHAPE_QUARTZ:
retVal = tesselateQuartzInWorld(tt, x, y, z);
break;
case Tile_SPU::SHAPE_WATER:
retVal = tesselateWaterInWorld(tt, x, y, z);
break;
case Tile_SPU::SHAPE_CACTUS:
retVal = tesselateCactusInWorld(tt, x, y, z);
break;
case Tile_SPU::SHAPE_CROSS_TEXTURE:
retVal = tesselateCrossInWorld(tt, x, y, z);
break;
case Tile_SPU::SHAPE_STEM:
retVal = tesselateStemInWorld(tt, x, y, z);
break;
case Tile_SPU::SHAPE_LILYPAD:
retVal = tesselateLilypadInWorld((WaterlilyTile_SPU*)tt, x, y, z);
break;
case Tile_SPU::SHAPE_ROWS:
retVal = tesselateRowInWorld(tt, x, y, z);
break;
case Tile_SPU::SHAPE_TORCH:
retVal = tesselateTorchInWorld(tt, x, y, z);
break;
case Tile_SPU::SHAPE_FIRE:
retVal = tesselateFireInWorld((FireTile_SPU*)tt, x, y, z);
break;
case Tile_SPU::SHAPE_RED_DUST:
retVal = tesselateDustInWorld(tt, x, y, z);
break;
case Tile_SPU::SHAPE_LADDER:
retVal = tesselateLadderInWorld(tt, x, y, z);
break;
case Tile_SPU::SHAPE_DOOR:
retVal = tesselateDoorInWorld(tt, x, y, z);
break;
case Tile_SPU::SHAPE_RAIL:
retVal = tesselateRailInWorld((RailTile_SPU*)tt, x, y, z);
break;
case Tile_SPU::SHAPE_STAIRS:
retVal = tesselateStairsInWorld((StairTile_SPU*)tt, x, y, z);
break;
case Tile_SPU::SHAPE_EGG:
retVal = tesselateEggInWorld((EggTile_SPU*)tt, x, y, z);
break;
case Tile_SPU::SHAPE_FENCE:
retVal = tesselateFenceInWorld((FenceTile_SPU*)tt, x, y, z);
break;
case Tile_SPU::SHAPE_WALL:
retVal = tesselateWallInWorld((WallTile_SPU*)tt, x, y, z);
break;
case Tile_SPU::SHAPE_LEVER:
retVal = tesselateLeverInWorld(tt, x, y, z);
break;
case Tile_SPU::SHAPE_TRIPWIRE_SOURCE:
retVal = tesselateTripwireSourceInWorld(tt, x, y, z);
break;
case Tile_SPU::SHAPE_TRIPWIRE:
retVal = tesselateTripwireInWorld(tt, x, y, z);
break;
case Tile_SPU::SHAPE_BED:
retVal = tesselateBedInWorld(tt, x, y, z);
break;
case Tile_SPU::SHAPE_DIODE:
retVal = tesselateDiodeInWorld((DiodeTile_SPU*)tt, x, y, z);
break;
case Tile_SPU::SHAPE_PISTON_BASE:
retVal = tesselatePistonBaseInWorld(tt, x, y, z, false, forceData);
break;
case Tile_SPU::SHAPE_PISTON_EXTENSION:
retVal =
tesselatePistonExtensionInWorld(tt, x, y, z, true, forceData);
break;
case Tile_SPU::SHAPE_IRON_FENCE:
retVal = tesselateThinFenceInWorld((ThinFenceTile*)tt, x, y, z);
break;
case Tile_SPU::SHAPE_VINE:
retVal = tesselateVineInWorld(tt, x, y, z);
break;
case Tile_SPU::SHAPE_FENCE_GATE:
retVal = tesselateFenceGateInWorld((FenceGateTile_SPU*)tt, x, y, z);
break;
case Tile_SPU::SHAPE_CAULDRON:
retVal = tesselateCauldronInWorld((CauldronTile_SPU*)tt, x, y, z);
break;
case Tile_SPU::SHAPE_FLOWER_POT:
retVal = tesselateFlowerPotInWorld((FlowerPotTile_SPU*)tt, x, y, z);
break;
case Tile_SPU::SHAPE_ANVIL:
retVal = tesselateAnvilInWorld((AnvilTile_SPU*)tt, x, y, z);
break;
case Tile_SPU::SHAPE_BREWING_STAND:
retVal = tesselateBrewingStandInWorld((BrewingStandTile_SPU*)tt, x,
y, z);
break;
case Tile_SPU::SHAPE_PORTAL_FRAME:
retVal = tesselateAirPortalFrameInWorld((TheEndPortalFrameTile*)tt,
x, y, z);
break;
case Tile_SPU::SHAPE_COCOA:
retVal = tesselateCocoaInWorld((CocoaTile_SPU*)tt, x, y, z);
break;
};
t->setMipmapEnable(true); // 4J added
return retVal;
}
bool TileRenderer_SPU::tesselateAirPortalFrameInWorld(TheEndPortalFrameTile* tt,
int x, int y, int z) {
#ifdef DISABLE_TESS_FUNCS
int data = level->getData(x, y, z);
int direction = data & 3;
if (direction == Direction::SOUTH) {
upFlip = FLIP_180;
} else if (direction == Direction::EAST) {
upFlip = FLIP_CW;
} else if (direction == Direction::WEST) {
upFlip = FLIP_CCW;
}
if (!TheEndPortalFrameTile::hasEye(data)) {
// EnterCriticalSection( &Tile_SPU::m_csShape );
setShape(0, 0, 0, 1, 13.0f / 16.0f, 1);
tesselateBlockInWorld(tt, x, y, z);
// LeaveCriticalSection( &Tile_SPU::m_csShape );
upFlip = FLIP_NONE;
return true;
}
// EnterCriticalSection( &Tile_SPU::m_csShape );
noCulling = true;
setShape(0, 0, 0, 1, 13.0f / 16.0f, 1);
tesselateBlockInWorld(tt, x, y, z);
setFixedTexture(tt->getEye());
setShape(4.0f / 16.0f, 13.0f / 16.0f, 4.0f / 16.0f, 12.0f / 16.0f, 1,
12.0f / 16.0f);
tesselateBlockInWorld(tt, x, y, z);
noCulling = false;
clearFixedTexture();
// LeaveCriticalSection( &Tile_SPU::m_csShape );
upFlip = FLIP_NONE;
#endif // DISABLE_TESS_FUNCS
return true;
}
bool TileRenderer_SPU::tesselateBedInWorld(Tile_SPU* tt, int x, int y, int z) {
#ifdef DISABLE_TESS_FUNCS
Tesselator_SPU* t = getTesselator();
int data = level->getData(x, y, z);
int direction = BedTile::getDirection(data);
bool isHead = BedTile::isHeadPiece(data);
float c10 = 0.5f;
float c11 = 1.0f;
float c2 = 0.8f;
float c3 = 0.6f;
float r11 = c11;
float g11 = c11;
float b11 = c11;
float r10 = c10;
float r2 = c2;
float r3 = c3;
float g10 = c10;
float g2 = c2;
float g3 = c3;
float b10 = c10;
float b2 = c2;
float b3 = c3;
// 4J - change brought forward from 1.8.2
int centerColor;
float centerBrightness;
if (SharedConstants::TEXTURE_LIGHTING) {
centerColor = tt->getLightColor(level, x, y, z);
} else {
centerBrightness = tt->getBrightness(level, x, y, z);
}
// render wooden underside
{
// 4J - change brought forward from 1.8.2
if (SharedConstants::TEXTURE_LIGHTING) {
t->tex2(centerColor);
t->color(r10, g10, b10);
} else {
t->color(r10 * centerBrightness, g10 * centerBrightness,
b10 * centerBrightness);
}
Icon_SPU* tex = getTexture(tt, level, x, y, z, Facing::DOWN);
float u0 = tex->getU0();
float u1 = tex->getU1();
float v0 = tex->getV0();
float v1 = tex->getV1();
float x0 = x + tileShapeX0;
float x1 = x + tileShapeX1;
float y0 = y + tileShapeY0 + 3.0 / 16.0;
float z0 = z + tileShapeZ0;
float z1 = z + tileShapeZ1;
t->vertexUV(x0, y0, z1, u0, v1);
t->vertexUV(x0, y0, z0, u0, v0);
t->vertexUV(x1, y0, z0, u1, v0);
t->vertexUV(x1, y0, z1, u1, v1);
}
// render bed top
// 4J - change brought forward from 1.8.2
if (SharedConstants::TEXTURE_LIGHTING) {
t->tex2(tt->getLightColor(level, x, y + 1, z));
t->color(r11, g11, b11);
} else {
float brightness = tt->getBrightness(level, x, y + 1, z);
t->color(r11 * brightness, g11 * brightness, b11 * brightness);
}
Icon_SPU* tex = getTexture(tt, level, x, y, z, Facing::UP);
float u0 = tex->getU0();
float u1 = tex->getU1();
float v0 = tex->getV0();
float v1 = tex->getV1();
float topLeftU = u0;
float topRightU = u1;
float topLeftV = v0;
float topRightV = v0;
float bottomLeftU = u0;
float bottomRightU = u1;
float bottomLeftV = v1;
float bottomRightV = v1;
if (direction == Direction::SOUTH) {
// rotate 90 degrees clockwise
topRightU = u0;
topLeftV = v1;
bottomLeftU = u1;
bottomRightV = v0;
} else if (direction == Direction::NORTH) {
// rotate 90 degrees counter-clockwise
topLeftU = u1;
topRightV = v1;
bottomRightU = u0;
bottomLeftV = v0;
} else if (direction == Direction::EAST) {
// rotate 180 degrees
topLeftU = u1;
topRightV = v1;
bottomRightU = u0;
bottomLeftV = v0;
topRightU = u0;
topLeftV = v1;
bottomLeftU = u1;
bottomRightV = v0;
}
float x0 = x + tileShapeX0;
float x1 = x + tileShapeX1;
float y1 = y + tileShapeY1;
float z0 = z + tileShapeZ0;
float z1 = z + tileShapeZ1;
t->vertexUV(x1, y1, z1, bottomLeftU, bottomLeftV);
t->vertexUV(x1, y1, z0, topLeftU, topLeftV);
t->vertexUV(x0, y1, z0, topRightU, topRightV);
t->vertexUV(x0, y1, z1, bottomRightU, bottomRightV);
// determine which edge to skip (the one between foot and head piece)
int skipEdge = Direction::DIRECTION_FACING[direction];
if (isHead) {
skipEdge = Direction::DIRECTION_FACING
[Direction::DIRECTION_OPPOSITE[direction]];
}
// and which edge to x-flip
int flipEdge = Facing::WEST;
switch (direction) {
case Direction::NORTH:
break;
case Direction::SOUTH:
flipEdge = Facing::EAST;
break;
case Direction::EAST:
flipEdge = Facing::NORTH;
break;
case Direction::WEST:
flipEdge = Facing::SOUTH;
break;
}
if ((skipEdge != Facing::NORTH) &&
(noCulling ||
tt->shouldRenderFace(level, x, y, z - 1, Facing::NORTH))) {
if (SharedConstants::TEXTURE_LIGHTING) {
t->tex2(tileShapeZ0 > 0 ? centerColor
: tt->getLightColor(level, x, y, z - 1));
t->color(r2, g2, b2);
} else {
float br = tt->getBrightness(level, x, y, z - 1);
if (tileShapeZ0 > 0) br = centerBrightness;
t->color(r2 * br, g2 * br, b2 * br);
}
xFlipTexture = flipEdge == Facing::NORTH;
renderNorth(tt, x, y, z, getTexture(tt, level, x, y, z, 2));
}
if ((skipEdge != Facing::SOUTH) &&
(noCulling ||
tt->shouldRenderFace(level, x, y, z + 1, Facing::SOUTH))) {
if (SharedConstants::TEXTURE_LIGHTING) {
t->tex2(tileShapeZ1 < 1 ? centerColor
: tt->getLightColor(level, x, y, z + 1));
t->color(r2, g2, b2);
} else {
float br = tt->getBrightness(level, x, y, z + 1);
if (tileShapeZ1 < 1) br = centerBrightness;
t->color(r2 * br, g2 * br, b2 * br);
}
xFlipTexture = flipEdge == Facing::SOUTH;
renderSouth(tt, x, y, z, getTexture(tt, level, x, y, z, 3));
}
if ((skipEdge != Facing::WEST) &&
(noCulling || tt->shouldRenderFace(level, x - 1, y, z, Facing::WEST))) {
if (SharedConstants::TEXTURE_LIGHTING) {
t->tex2(tileShapeZ0 > 0 ? centerColor
: tt->getLightColor(level, x - 1, y, z));
t->color(r3, g3, b3);
} else {
float br = tt->getBrightness(level, x - 1, y, z);
if (tileShapeX0 > 0) br = centerBrightness;
t->color(r3 * br, g3 * br, b3 * br);
}
xFlipTexture = flipEdge == Facing::WEST;
renderWest(tt, x, y, z, getTexture(tt, level, x, y, z, 4));
}
if ((skipEdge != Facing::EAST) &&
(noCulling || tt->shouldRenderFace(level, x + 1, y, z, Facing::EAST))) {
if (SharedConstants::TEXTURE_LIGHTING) {
t->tex2(tileShapeZ1 < 1 ? centerColor
: tt->getLightColor(level, x + 1, y, z));
t->color(r3, g3, b3);
} else {
float br = tt->getBrightness(level, x + 1, y, z);
if (tileShapeX1 < 1) br = centerBrightness;
t->color(r3 * br, g3 * br, b3 * br);
}
xFlipTexture = flipEdge == Facing::EAST;
renderEast(tt, x, y, z, getTexture(tt, level, x, y, z, 5));
}
xFlipTexture = false;
#endif // DISABLE_TESS_FUNCS
return true;
}
bool TileRenderer_SPU::tesselateBrewingStandInWorld(BrewingStandTile_SPU* tt,
int x, int y, int z) {
// EnterCriticalSection( &Tile_SPU::m_csShape );
// bounding box first
setShape(7.0f / 16.0f, 0.0f, 7.0f / 16.0f, 9.0f / 16.0f, 14.0f / 16.0f,
9.0f / 16.0f);
tesselateBlockInWorld(tt, x, y, z);
setFixedTexture(tt->getBaseTexture());
setShape(9.0f / 16.0f, 0.0f, 5.0f / 16.0f, 15.0f / 16.0f, 2 / 16.0f,
11.0f / 16.0f);
tesselateBlockInWorld(tt, x, y, z);
setShape(2.0f / 16.0f, 0.0f, 1.0f / 16.0f, 8.0f / 16.0f, 2 / 16.0f,
7.0f / 16.0f);
tesselateBlockInWorld(tt, x, y, z);
setShape(2.0f / 16.0f, 0.0f, 9.0f / 16.0f, 8.0f / 16.0f, 2 / 16.0f,
15.0f / 16.0f);
tesselateBlockInWorld(tt, x, y, z);
clearFixedTexture();
Tesselator_SPU* t = getTesselator();
float br;
if (SharedConstants::TEXTURE_LIGHTING) {
t->tex2(tt->getLightColor(level, x, y, z));
br = 1;
} else {
br = tt->getBrightness(level, x, y, z);
}
int col = tt->getColor(level, x, y, z);
float r = ((col >> 16) & 0xff) / 255.0f;
float g = ((col >> 8) & 0xff) / 255.0f;
float b = ((col) & 0xff) / 255.0f;
t->color(br * r, br * g, br * b);
Icon_SPU* tex = getTexture(tt, 0, 0);
if (hasFixedTexture()) tex = fixedTexture;
float v0 = tex->getV0();
float v1 = tex->getV1();
int data = level->getData(x, y, z);
for (int arm = 0; arm < 3; arm++) {
float angle = arm * MATH_PI * 2.0f / 3.0f + MATH_PI * 0.5f;
float u0 = tex->getU(8);
float u1 = tex->getU1();
// if (brewEntity != null && brewEntity.getItem(arm) != null)
// {
if ((data & (1 << arm)) != 0) {
u1 = tex->getU0();
}
float x0 = x + 8.0f / 16.0f;
float x1 = x + 8.0f / 16.0f + sin(angle) * 8.0f / 16.0f;
float z0 = z + 8.0f / 16.0f;
float z1 = z + 8.0f / 16.0f + cos(angle) * 8.0f / 16.0f;
t->vertexUV(x0, y + 1.0f, z0, u0, v0);
t->vertexUV(x0, y + 0.0f, z0, u0, v1);
t->vertexUV(x1, y + 0.0f, z1, u1, v1);
t->vertexUV(x1, y + 1.0f, z1, u1, v0);
t->vertexUV(x1, y + 1.0f, z1, u1, v0);
t->vertexUV(x1, y + 0.0f, z1, u1, v1);
t->vertexUV(x0, y + 0.0f, z0, u0, v1);
t->vertexUV(x0, y + 1.0f, z0, u0, v0);
}
tt->updateDefaultShape();
// LeaveCriticalSection( &Tile_SPU::m_csShape );
return true;
}
bool TileRenderer_SPU::tesselateCauldronInWorld(CauldronTile_SPU* tt, int x,
int y, int z) {
#ifdef DISABLE_TESS_FUNCS
// bounding box first
tesselateBlockInWorld(tt, x, y, z);
Tesselator_SPU* t = getTesselator();
float br;
if (SharedConstants::TEXTURE_LIGHTING) {
t->tex2(tt->getLightColor(level, x, y, z));
br = 1;
} else {
br = tt->getBrightness(level, x, y, z);
}
int col = tt->getColor(level, x, y, z);
float r = ((col >> 16) & 0xff) / 255.0f;
float g = ((col >> 8) & 0xff) / 255.0f;
float b = ((col) & 0xff) / 255.0f;
t->color(br * r, br * g, br * b);
// render inside
Icon_SPU* insideTex = tt->getTexture(Facing::NORTH);
const float cWidth =
(2.0f / 16.0f) -
(1.0f /
128.0f); // 4J - Moved by 1/128th (smallest movement possible with our
// vertex storage) to remove gap at edge of cauldron
renderEast(tt, x - 1.0f + cWidth, y, z, insideTex);
renderWest(tt, x + 1.0f - cWidth, y, z, insideTex);
renderSouth(tt, x, y, z - 1.0f + cWidth, insideTex);
renderNorth(tt, x, y, z + 1.0f - cWidth, insideTex);
Icon_SPU* bottomTex =
CauldronTile::getTexture(CauldronTile::TEXTURE_INSIDE);
renderFaceUp(tt, x, y - 1.0f + 4.0f / 16.0f, z, bottomTex);
renderFaceDown(tt, x, y + 1.0f - 12.0f / 16.0f, z, bottomTex);
int waterLevel = level->getData(x, y, z);
if (waterLevel > 0) {
Icon_SPU* liquidTex =
LiquidTile_SPU::getTexture(LiquidTile_SPU::TEXTURE_WATER_STILL);
if (waterLevel > 3) {
waterLevel = 3;
}
renderFaceUp(tt, x, y - 1.0f + (6.0f + waterLevel * 3.0f) / 16.0f, z,
liquidTex);
}
#endif // DISABLE_TESS_FUNCS
return true;
}
bool TileRenderer_SPU::tesselateFlowerPotInWorld(FlowerPotTile_SPU* tt, int x,
int y, int z) {
#ifdef DISABLE_TESS_FUNCS
// bounding box first
tesselateBlockInWorld(tt, x, y, z);
Tesselator* t = Tesselator::getInstance();
float br;
if (SharedConstants::TEXTURE_LIGHTING) {
t->tex2(tt->getLightColor(level, x, y, z));
br = 1;
} else {
br = tt->getBrightness(level, x, y, z);
}
int col = tt->getColor(level, x, y, z);
Icon* tex = getTexture(tt, 0);
float r = ((col >> 16) & 0xff) / 255.0f;
float g = ((col >> 8) & 0xff) / 255.0f;
float b = ((col) & 0xff) / 255.0f;
if (GameRenderer::anaglyph3d) {
float cr = (r * 30 + g * 59 + b * 11) / 100;
float cg = (r * 30 + g * 70) / (100);
float cb = (r * 30 + b * 70) / (100);
r = cr;
g = cg;
b = cb;
}
t->color(br * r, br * g, br * b);
// render inside
float halfWidth = (6.0f / 16.0f) / 2 - 0.001f;
renderEast(tt, x - 0.5f + halfWidth, y, z, tex);
renderWest(tt, x + 0.5f - halfWidth, y, z, tex);
renderSouth(tt, x, y, z - 0.5f + halfWidth, tex);
renderNorth(tt, x, y, z + 0.5f - halfWidth, tex);
renderFaceUp(tt, x, y - 0.5f + halfWidth + 3.0f / 16.0f, z,
getTexture(Tile::dirt));
int type = level->getData(x, y, z);
if (type != 0) {
float xOff = 0;
float yOff = 4;
float zOff = 0;
Tile* plant = NULL;
switch (type) {
case FlowerPotTile::TYPE_FLOWER_RED:
plant = Tile::rose;
break;
case FlowerPotTile::TYPE_FLOWER_YELLOW:
plant = Tile::flower;
break;
case FlowerPotTile::TYPE_MUSHROOM_BROWN:
plant = Tile::mushroom1;
break;
case FlowerPotTile::TYPE_MUSHROOM_RED:
plant = Tile::mushroom2;
break;
}
t->addOffset(xOff / 16.0f, yOff / 16.0f, zOff / 16.0f);
if (plant != NULL) {
tesselateInWorld(plant, x, y, z);
} else {
if (type == FlowerPotTile::TYPE_CACTUS) {
// Force drawing of all faces else the cactus misses faces
// when a block is adjacent
noCulling = true;
float halfSize = 0.25f / 2;
setShape(0.5f - halfSize, 0.0f, 0.5f - halfSize,
0.5f + halfSize, 0.25f, 0.5f + halfSize);
tesselateBlockInWorld(Tile::cactus, x, y, z);
setShape(0.5f - halfSize, 0.25f, 0.5f - halfSize,
0.5f + halfSize, 0.5f, 0.5f + halfSize);
tesselateBlockInWorld(Tile::cactus, x, y, z);
setShape(0.5f - halfSize, 0.5f, 0.5f - halfSize,
0.5f + halfSize, 0.75f, 0.5f + halfSize);
tesselateBlockInWorld(Tile::cactus, x, y, z);
noCulling = false;
setShape(0, 0, 0, 1, 1, 1);
} else if (type == FlowerPotTile::TYPE_SAPLING_DEFAULT) {
tesselateCrossTexture(Tile::sapling, Sapling::TYPE_DEFAULT, x,
y, z, 0.75f);
} else if (type == FlowerPotTile::TYPE_SAPLING_BIRCH) {
tesselateCrossTexture(Tile::sapling, Sapling::TYPE_BIRCH, x, y,
z, 0.75f);
} else if (type == FlowerPotTile::TYPE_SAPLING_EVERGREEN) {
tesselateCrossTexture(Tile::sapling, Sapling::TYPE_EVERGREEN, x,
y, z, 0.75f);
} else if (type == FlowerPotTile::TYPE_SAPLING_JUNGLE) {
tesselateCrossTexture(Tile::sapling, Sapling::TYPE_JUNGLE, x, y,
z, 0.75f);
} else if (type == FlowerPotTile::TYPE_FERN) {
col = Tile::tallgrass->getColor(level, x, y, z);
r = ((col >> 16) & 0xff) / 255.0f;
g = ((col >> 8) & 0xff) / 255.0f;
b = ((col) & 0xff) / 255.0f;
t->color(br * r, br * g, br * b);
tesselateCrossTexture(Tile::tallgrass, TallGrass::FERN, x, y, z,
0.75f);
} else if (type == FlowerPotTile::TYPE_DEAD_BUSH) {
tesselateCrossTexture(Tile::deadBush, TallGrass::FERN, x, y, z,
0.75f);
}
}
t->addOffset(-xOff / 16.0f, -yOff / 16.0f, -zOff / 16.0f);
}
#endif // DISABLE_TESS_FUNCS
return true;
}
bool TileRenderer_SPU::tesselateAnvilInWorld(AnvilTile_SPU* tt, int x, int y,
int z) {
return tesselateAnvilInWorld(tt, x, y, z, level->getData(x, y, z));
}
bool TileRenderer_SPU::tesselateAnvilInWorld(AnvilTile_SPU* tt, int x, int y,
int z, int data) {
#ifdef DISABLE_TESS_FUNCS
Tesselator* t = Tesselator::getInstance();
float br;
if (SharedConstants::TEXTURE_LIGHTING) {
t->tex2(tt->getLightColor(level, x, y, z));
br = 1;
} else {
br = tt->getBrightness(level, x, y, z);
}
int col = tt->getColor(level, x, y, z);
float r = ((col >> 16) & 0xff) / 255.0f;
float g = ((col >> 8) & 0xff) / 255.0f;
float b = ((col) & 0xff) / 255.0f;
if (GameRenderer::anaglyph3d) {
float cr = (r * 30 + g * 59 + b * 11) / 100;
float cg = (r * 30 + g * 70) / (100);
float cb = (r * 30 + b * 70) / (100);
r = cr;
g = cg;
b = cb;
}
t->color(br * r, br * g, br * b);
#endif // DISABLE_TESS_FUNCS
return tesselateAnvilInWorld(tt, x, y, z, data, false);
}
bool TileRenderer_SPU::tesselateAnvilInWorld(AnvilTile_SPU* tt, int x, int y,
int z, int data, bool render) {
#ifdef DISABLE_TESS_FUNCS
int facing = render ? 0 : data & 3;
boolean rotate = false;
float bottom = 0;
switch (facing) {
case Direction::NORTH:
eastFlip = FLIP_CW;
westFlip = FLIP_CCW;
break;
case Direction::SOUTH:
eastFlip = FLIP_CCW;
westFlip = FLIP_CW;
upFlip = FLIP_180;
downFlip = FLIP_180;
break;
case Direction::WEST:
northFlip = FLIP_CW;
southFlip = FLIP_CCW;
upFlip = FLIP_CCW;
downFlip = FLIP_CW;
rotate = true;
break;
case Direction::EAST:
northFlip = FLIP_CCW;
southFlip = FLIP_CW;
upFlip = FLIP_CW;
downFlip = FLIP_CCW;
rotate = true;
break;
}
bottom = tesselateAnvilPiece(tt, x, y, z, AnvilTile::PART_BASE, bottom,
12.0f / 16.0f, 4.0f / 16.0f, 12.0f / 16.0f,
rotate, render, data);
bottom = tesselateAnvilPiece(tt, x, y, z, AnvilTile::PART_JOINT, bottom,
8.0f / 16.0f, 1.0f / 16.0f, 10.0f / 16.0f,
rotate, render, data);
bottom = tesselateAnvilPiece(tt, x, y, z, AnvilTile::PART_COLUMN, bottom,
4.0f / 16.0f, 5.0f / 16.0f, 8.0f / 16.0f,
rotate, render, data);
bottom = tesselateAnvilPiece(tt, x, y, z, AnvilTile::PART_TOP, bottom,
10.0f / 16.0f, 6.0f / 16.0f, 16.0f / 16.0f,
rotate, render, data);
setShape(0, 0, 0, 1, 1, 1);
northFlip = FLIP_NONE;
southFlip = FLIP_NONE;
eastFlip = FLIP_NONE;
westFlip = FLIP_NONE;
upFlip = FLIP_NONE;
downFlip = FLIP_NONE;
#endif // DISABLE_TESS_FUNCS
return true;
}
float TileRenderer_SPU::tesselateAnvilPiece(AnvilTile_SPU* tt, int x, int y,
int z, int part, float bottom,
float width, float height,
float length, bool rotate,
bool render, int data) {
#ifdef DISABLE_TESS_FUNCS
if (rotate) {
float swap = width;
width = length;
length = swap;
}
width /= 2;
length /= 2;
ms_pTileData->anvilPart = part;
setShape(0.5f - width, bottom, 0.5f - length, 0.5f + width, bottom + height,
0.5f + length);
if (render) {
Tesselator* t = Tesselator::getInstance();
t->begin();
t->normal(0, -1, 0);
renderFaceDown(tt, 0, 0, 0, getTexture(tt, 0, data));
t->end();
t->begin();
t->normal(0, 1, 0);
renderFaceUp(tt, 0, 0, 0, getTexture(tt, 1, data));
t->end();
t->begin();
t->normal(0, 0, -1);
renderNorth(tt, 0, 0, 0, getTexture(tt, 2, data));
t->end();
t->begin();
t->normal(0, 0, 1);
renderSouth(tt, 0, 0, 0, getTexture(tt, 3, data));
t->end();
t->begin();
t->normal(-1, 0, 0);
renderWest(tt, 0, 0, 0, getTexture(tt, 4, data));
t->end();
t->begin();
t->normal(1, 0, 0);
renderEast(tt, 0, 0, 0, getTexture(tt, 5, data));
t->end();
} else {
tesselateBlockInWorld(tt, x, y, z);
}
#endif // DISABLE_TESS_FUNCS
return bottom + height;
}
bool TileRenderer_SPU::tesselateTorchInWorld(Tile_SPU* tt, int x, int y,
int z) {
int dir = level->getData(x, y, z);
Tesselator_SPU* t = getTesselator();
if (SharedConstants::TEXTURE_LIGHTING) {
t->tex2(tt->getLightColor(level, x, y, z));
t->color(1.0f, 1.0f, 1.0f);
} else {
float br = tt->getBrightness(level, x, y, z);
if (level->m_tileData.lightEmission[tt->id] > 0) br = 1.0f;
t->color(br, br, br);
}
float r = 0.40f;
float r2 = 0.5f - r;
float h = 0.20f;
if (dir == 1) {
tesselateTorch(tt, (float)x - r2, (float)y + h, (float)z, -r, 0.0f, 0);
} else if (dir == 2) {
tesselateTorch(tt, (float)x + r2, (float)y + h, (float)z, +r, 0.0f, 0);
} else if (dir == 3) {
tesselateTorch(tt, (float)x, (float)y + h, z - r2, 0.0f, -r, 0);
} else if (dir == 4) {
tesselateTorch(tt, (float)x, (float)y + h, (float)z + r2, 0.0f, +r, 0);
} else {
tesselateTorch(tt, (float)x, (float)y, (float)z, 0.0f, 0.0f, 0);
}
return true;
}
bool TileRenderer_SPU::tesselateDiodeInWorld(DiodeTile_SPU* tt, int x, int y,
int z) {
#ifdef DISABLE_TESS_FUNCS
Tesselator_SPU* t = getTesselator();
tesselateDiodeInWorld(
tt, x, y, z, level->getData(x, y, z) & DiodeTile_SPU::DIRECTION_MASK);
return true;
#endif // #ifdef DISABLE_TESS_FUNCS
return false;
}
void TileRenderer_SPU::tesselateDiodeInWorld(DiodeTile_SPU* tt, int x, int y,
int z, int dir) {
#ifdef DISABLE_TESS_FUNCS
// render half-block edges
tesselateBlockInWorld(tt, x, y, z);
Tesselator_SPU* t = getTesselator();
if (SharedConstants::TEXTURE_LIGHTING) {
t->tex2(tt->getLightColor(level, x, y, z));
t->color(1.0f, 1.0f, 1.0f);
} else {
float br = tt->getBrightness(level, x, y, z);
if (level->m_tileData.lightEmission[tt->id] > 0) br = 1.0f;
t->color(br, br, br);
}
int data = level->getData(x, y, z);
// 4J Stu - This block gets moved in a later version, but we don't need that
// yet BEGIN TORCH SECTION
{
int dir = data & DiodeTile_SPU::DIRECTION_MASK;
int delay =
(data & DiodeTile_SPU::DELAY_MASK) >> DiodeTile_SPU::DELAY_SHIFT;
float h = -3.0f / 16.0f;
float transmitterX = 0.0f;
float transmitterZ = 0.0f;
float receiverX = 0.0f;
float receiverZ = 0.0f;
switch (dir) {
case Direction::SOUTH:
receiverZ = -5.0f / 16.0f;
transmitterZ = DiodeTile_SPU::DELAY_RENDER_OFFSETS[delay];
break;
case Direction::NORTH:
receiverZ = 5.0f / 16.0f;
transmitterZ = -DiodeTile_SPU::DELAY_RENDER_OFFSETS[delay];
break;
case Direction::EAST:
receiverX = -5.0f / 16.0f;
transmitterX = DiodeTile_SPU::DELAY_RENDER_OFFSETS[delay];
break;
case Direction::WEST:
receiverX = 5.0f / 16.0f;
transmitterX = -DiodeTile_SPU::DELAY_RENDER_OFFSETS[delay];
break;
}
// render transmitter
tesselateTorch(tt, x + transmitterX, y + h, z + transmitterZ, 0.0f,
0.0f, 0);
// render receiver
tesselateTorch(tt, x + receiverX, y + h, z + receiverZ, 0.0f, 0.0f, 0);
}
// END TORCH SECTION
Icon_SPU* tex = getTexture(tt, Facing::UP, data);
float u0 = tex->getU0();
float u1 = tex->getU1();
float v0 = tex->getV0();
float v1 = tex->getV1();
float r = 2.0f / 16.0f;
float x0 = (float)(x + 1.0f);
float x1 = (float)(x + 1.0f);
float x2 = (float)(x + 0.0f);
float x3 = (float)(x + 0.0f);
float z0 = (float)(z + 0.0f);
float z1 = (float)(z + 1.0f);
float z2 = (float)(z + 1.0f);
float z3 = (float)(z + 0.0f);
float y0 = (float)(y + r);
if (dir == Direction::NORTH) {
// rotate 180 degrees
x0 = x1 = (float)(x + 0.0f);
x2 = x3 = (float)(x + 1.0f);
z0 = z3 = (float)(z + 1.0f);
z1 = z2 = (float)(z + 0.0f);
} else if (dir == Direction::EAST) {
// rotate 90 degrees counter-clockwise
x0 = x3 = (float)(x + 0.0f);
x1 = x2 = (float)(x + 1.0f);
z0 = z1 = (float)(z + 0.0f);
z2 = z3 = (float)(z + 1.0f);
} else if (dir == Direction::WEST) {
// rotate 90 degrees clockwise
x0 = x3 = (float)(x + 1.0f);
x1 = x2 = (float)(x + 0.0f);
z0 = z1 = (float)(z + 1.0f);
z2 = z3 = (float)(z + 0.0f);
}
t->vertexUV(x3, y0, z3, u0, v0);
t->vertexUV(x2, y0, z2, u0, v1);
t->vertexUV(x1, y0, z1, u1, v1);
t->vertexUV(x0, y0, z0, u1, v0);
#endif // #ifdef DISABLE_TESS_FUNCS
}
void TileRenderer_SPU::tesselatePistonBaseForceExtended(
Tile_SPU* tile, int x, int y, int z,
int forceData) // 4J added forceData param
{
#ifdef DISABLE_TESS_FUNCS
noCulling = true;
tesselatePistonBaseInWorld(tile, x, y, z, true, forceData);
noCulling = false;
#endif // DISABLE_TESS_FUNCS
}
bool TileRenderer_SPU::tesselatePistonBaseInWorld(
Tile_SPU* tt, int x, int y, int z, bool forceExtended,
int forceData) // 4J added forceData param
{
#ifdef DISABLE_TESS_FUNCS
int data = (forceData == -1) ? level->getData(x, y, z) : forceData;
bool extended = forceExtended || (data & PistonBaseTile::EXTENDED_BIT) != 0;
int facing = PistonBaseTile::getFacing(data);
const float thickness = PistonBaseTile::PLATFORM_THICKNESS / 16.0f;
// EnterCriticalSection( &Tile_SPU::m_csShape );
if (extended) {
switch (facing) {
case Facing::DOWN:
northFlip = FLIP_180;
southFlip = FLIP_180;
eastFlip = FLIP_180;
westFlip = FLIP_180;
setShape(0.0f, thickness, 0.0f, 1.0f, 1.0f, 1.0f);
break;
case Facing::UP:
setShape(0.0f, 0.0f, 0.0f, 1.0f, 1.0f - thickness, 1.0f);
break;
case Facing::NORTH:
eastFlip = FLIP_CW;
westFlip = FLIP_CCW;
setShape(0.0f, 0.0f, thickness, 1.0f, 1.0f, 1.0f);
break;
case Facing::SOUTH:
eastFlip = FLIP_CCW;
westFlip = FLIP_CW;
upFlip = FLIP_180;
downFlip = FLIP_180;
setShape(0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f - thickness);
break;
case Facing::WEST:
northFlip = FLIP_CW;
southFlip = FLIP_CCW;
upFlip = FLIP_CCW;
downFlip = FLIP_CW;
setShape(thickness, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f);
break;
case Facing::EAST:
northFlip = FLIP_CCW;
southFlip = FLIP_CW;
upFlip = FLIP_CW;
downFlip = FLIP_CCW;
setShape(0.0f, 0.0f, 0.0f, 1.0f - thickness, 1.0f, 1.0f);
break;
}
// weird way of telling the piston to use the
// "inside" texture for the forward-facing edge
((PistonBaseTile*)tt)
->updateShape((float)tileShapeX0, (float)tileShapeY0,
(float)tileShapeZ0, (float)tileShapeX1,
(float)tileShapeY1, (float)tileShapeZ1);
tesselateBlockInWorld(tt, x, y, z);
northFlip = FLIP_NONE;
southFlip = FLIP_NONE;
eastFlip = FLIP_NONE;
westFlip = FLIP_NONE;
upFlip = FLIP_NONE;
downFlip = FLIP_NONE;
((PistonBaseTile*)tt)
->updateShape((float)tileShapeX0, (float)tileShapeY0,
(float)tileShapeZ0, (float)tileShapeX1,
(float)tileShapeY1, (float)tileShapeZ1);
} else {
switch (facing) {
case Facing::DOWN:
northFlip = FLIP_180;
southFlip = FLIP_180;
eastFlip = FLIP_180;
westFlip = FLIP_180;
break;
case Facing::UP:
break;
case Facing::NORTH:
eastFlip = FLIP_CW;
westFlip = FLIP_CCW;
break;
case Facing::SOUTH:
eastFlip = FLIP_CCW;
westFlip = FLIP_CW;
upFlip = FLIP_180;
downFlip = FLIP_180;
break;
case Facing::WEST:
northFlip = FLIP_CW;
southFlip = FLIP_CCW;
upFlip = FLIP_CCW;
downFlip = FLIP_CW;
break;
case Facing::EAST:
northFlip = FLIP_CCW;
southFlip = FLIP_CW;
upFlip = FLIP_CW;
downFlip = FLIP_CCW;
break;
}
tesselateBlockInWorld(tt, x, y, z);
northFlip = FLIP_NONE;
southFlip = FLIP_NONE;
eastFlip = FLIP_NONE;
westFlip = FLIP_NONE;
upFlip = FLIP_NONE;
downFlip = FLIP_NONE;
}
// LeaveCriticalSection( &Tile_SPU::m_csShape );
#endif // DISABLE_TESS_FUNCS
return true;
}
void TileRenderer_SPU::renderPistonArmUpDown(float x0, float x1, float y0,
float y1, float z0, float z1,
float br, float armLengthPixels) {
#ifdef DISABLE_TESS_FUNCS
Icon_SPU* armTex = PistonBaseTile::getTexture(PistonBaseTile::EDGE_TEX);
if (hasFixedTexture()) armTex = fixedTexture;
Tesselator_SPU* t = getTesselator();
// upwards arm
float u00 = armTex->getU0();
float v00 = armTex->getV0();
float u11 = armTex->getU(armLengthPixels);
float v11 = armTex->getV(PistonBaseTile::PLATFORM_THICKNESS);
t->color(br, br, br);
t->vertexUV(x0, y1, z0, u11, v00);
t->vertexUV(x0, y0, z0, u00, v00);
t->vertexUV(x1, y0, z1, u00, v11);
t->vertexUV(x1, y1, z1, u11, v11);
#endif // DISABLE_TESS_FUNCS
}
void TileRenderer_SPU::renderPistonArmNorthSouth(float x0, float x1, float y0,
float y1, float z0, float z1,
float br,
float armLengthPixels) {
#ifdef DISABLE_TESS_FUNCS
Icon_SPU* armTex = PistonBaseTile::getTexture(PistonBaseTile::EDGE_TEX);
if (hasFixedTexture()) armTex = fixedTexture;
Tesselator_SPU* t = getTesselator();
// upwards arm
float u00 = armTex->getU0();
float v00 = armTex->getV0();
float u11 = armTex->getU(armLengthPixels);
float v11 = armTex->getV(PistonBaseTile::PLATFORM_THICKNESS);
t->color(br, br, br);
t->vertexUV(x0, y0, z1, u11, v00);
t->vertexUV(x0, y0, z0, u00, v00);
t->vertexUV(x1, y1, z0, u00, v11);
t->vertexUV(x1, y1, z1, u11, v11);
#endif // DISABLE_TESS_FUNCS
}
void TileRenderer_SPU::renderPistonArmEastWest(float x0, float x1, float y0,
float y1, float z0, float z1,
float br,
float armLengthPixels) {
#ifdef DISABLE_TESS_FUNCS
Icon_SPU* armTex = PistonBaseTile::getTexture(PistonBaseTile::EDGE_TEX);
if (hasFixedTexture()) armTex = fixedTexture;
Tesselator_SPU* t = getTesselator();
// upwards arm
float u00 = armTex->getU0();
float v00 = armTex->getV0();
float u11 = armTex->getU(armLengthPixels);
float v11 = armTex->getV(PistonBaseTile::PLATFORM_THICKNESS);
t->color(br, br, br);
t->vertexUV(x1, y0, z0, u11, v00);
t->vertexUV(x0, y0, z0, u00, v00);
t->vertexUV(x0, y1, z1, u00, v11);
t->vertexUV(x1, y1, z1, u11, v11);
#endif // DISABLE_TESS_FUNCS
}
void TileRenderer_SPU::tesselatePistonArmNoCulling(
Tile_SPU* tile, int x, int y, int z, bool fullArm,
int forceData) // 4J added forceData param
{
#ifdef DISABLE_TESS_FUNCS
noCulling = true;
tesselatePistonExtensionInWorld(tile, x, y, z, fullArm);
noCulling = false;
#endif // DISABLE_TESS_FUNCS
}
bool TileRenderer_SPU::tesselatePistonExtensionInWorld(
Tile_SPU* tt, int x, int y, int z, bool fullArm,
int forceData) // 4J added forceData param
{
#ifdef DISABLE_TESS_FUNCS
int data = (forceData == -1) ? level->getData(x, y, z) : forceData;
int facing = PistonExtensionTile::getFacing(data);
const float thickness = PistonBaseTile::PLATFORM_THICKNESS / 16.0f;
const float leftEdge =
(8.0f - (PistonBaseTile::PLATFORM_THICKNESS / 2.0f)) / 16.0f;
const float rightEdge =
(8.0f + (PistonBaseTile::PLATFORM_THICKNESS / 2.0f)) / 16.0f;
const float br = tt->getBrightness(level, x, y, z);
const float armLength = fullArm ? 1.0f : 0.5f;
const float armLengthPixels = fullArm ? 16.0f : 8.0f;
// EnterCriticalSection( &Tile_SPU::m_csShape );
Tesselator_SPU* t = getTesselator();
switch (facing) {
case Facing::DOWN:
northFlip = FLIP_180;
southFlip = FLIP_180;
eastFlip = FLIP_180;
westFlip = FLIP_180;
setShape(0.0f, 0.0f, 0.0f, 1.0f, thickness, 1.0f);
tesselateBlockInWorld(tt, x, y, z);
t->tex2(getLightColor(
tt, level, x, y,
z)); // 4J added - renderPistonArmDown doesn't set its own tex2
// so just inherited from previous tesselateBlockInWorld
renderPistonArmUpDown(x + leftEdge, x + rightEdge, y + thickness,
y + thickness + armLength, z + rightEdge,
z + rightEdge, br * 0.8f, armLengthPixels);
renderPistonArmUpDown(x + rightEdge, x + leftEdge, y + thickness,
y + thickness + armLength, z + leftEdge,
z + leftEdge, br * 0.8f, armLengthPixels);
renderPistonArmUpDown(x + leftEdge, x + leftEdge, y + thickness,
y + thickness + armLength, z + leftEdge,
z + rightEdge, br * 0.6f, armLengthPixels);
renderPistonArmUpDown(x + rightEdge, x + rightEdge, y + thickness,
y + thickness + armLength, z + rightEdge,
z + leftEdge, br * 0.6f, armLengthPixels);
break;
case Facing::UP:
setShape(0.0f, 1.0f - thickness, 0.0f, 1.0f, 1.0f, 1.0f);
tesselateBlockInWorld(tt, x, y, z);
t->tex2(getLightColor(
tt, level, x, y,
z)); // 4J added - renderPistonArmDown doesn't set its own tex2
// so just inherited from previous tesselateBlockInWorld
renderPistonArmUpDown(x + leftEdge, x + rightEdge,
y - thickness + 1.0f - armLength,
y - thickness + 1.0f, z + rightEdge,
z + rightEdge, br * 0.8f, armLengthPixels);
renderPistonArmUpDown(x + rightEdge, x + leftEdge,
y - thickness + 1.0f - armLength,
y - thickness + 1.0f, z + leftEdge,
z + leftEdge, br * 0.8f, armLengthPixels);
renderPistonArmUpDown(x + leftEdge, x + leftEdge,
y - thickness + 1.0f - armLength,
y - thickness + 1.0f, z + leftEdge,
z + rightEdge, br * 0.6f, armLengthPixels);
renderPistonArmUpDown(x + rightEdge, x + rightEdge,
y - thickness + 1.0f - armLength,
y - thickness + 1.0f, z + rightEdge,
z + leftEdge, br * 0.6f, armLengthPixels);
break;
case Facing::NORTH:
eastFlip = FLIP_CW;
westFlip = FLIP_CCW;
setShape(0.0f, 0.0f, 0.0f, 1.0f, 1.0f, thickness);
tesselateBlockInWorld(tt, x, y, z);
t->tex2(getLightColor(
tt, level, x, y,
z)); // 4J added - renderPistonArmDown doesn't set its own tex2
// so just inherited from previous tesselateBlockInWorld
renderPistonArmNorthSouth(x + leftEdge, x + leftEdge, y + rightEdge,
y + leftEdge, z + thickness,
z + thickness + armLength, br * 0.6f,
armLengthPixels);
renderPistonArmNorthSouth(x + rightEdge, x + rightEdge,
y + leftEdge, y + rightEdge,
z + thickness, z + thickness + armLength,
br * 0.6f, armLengthPixels);
renderPistonArmNorthSouth(x + leftEdge, x + rightEdge, y + leftEdge,
y + leftEdge, z + thickness,
z + thickness + armLength, br * 0.5f,
armLengthPixels);
renderPistonArmNorthSouth(
x + rightEdge, x + leftEdge, y + rightEdge, y + rightEdge,
z + thickness, z + thickness + armLength, br, armLengthPixels);
break;
case Facing::SOUTH:
eastFlip = FLIP_CCW;
westFlip = FLIP_CW;
upFlip = FLIP_180;
downFlip = FLIP_180;
setShape(0.0f, 0.0f, 1.0f - thickness, 1.0f, 1.0f, 1.0f);
tesselateBlockInWorld(tt, x, y, z);
t->tex2(getLightColor(
tt, level, x, y,
z)); // 4J added - renderPistonArmDown doesn't set its own tex2
// so just inherited from previous tesselateBlockInWorld
renderPistonArmNorthSouth(
x + leftEdge, x + leftEdge, y + rightEdge, y + leftEdge,
z - thickness + 1.0f - armLength, z - thickness + 1.0f,
br * 0.6f, armLengthPixels);
renderPistonArmNorthSouth(
x + rightEdge, x + rightEdge, y + leftEdge, y + rightEdge,
z - thickness + 1.0f - armLength, z - thickness + 1.0f,
br * 0.6f, armLengthPixels);
renderPistonArmNorthSouth(
x + leftEdge, x + rightEdge, y + leftEdge, y + leftEdge,
z - thickness + 1.0f - armLength, z - thickness + 1.0f,
br * 0.5f, armLengthPixels);
renderPistonArmNorthSouth(
x + rightEdge, x + leftEdge, y + rightEdge, y + rightEdge,
z - thickness + 1.0f - armLength, z - thickness + 1.0f, br,
armLengthPixels);
break;
case Facing::WEST:
northFlip = FLIP_CW;
southFlip = FLIP_CCW;
upFlip = FLIP_CCW;
downFlip = FLIP_CW;
setShape(0.0f, 0.0f, 0.0f, thickness, 1.0f, 1.0f);
tesselateBlockInWorld(
tt, x, y,
z); // 4J added - renderPistonArmDown doesn't set its own tex2
// so just inherited from previous tesselateBlockInWorld
t->tex2(getLightColor(tt, level, x, y, z));
renderPistonArmEastWest(x + thickness, x + thickness + armLength,
y + leftEdge, y + leftEdge, z + rightEdge,
z + leftEdge, br * 0.5f, armLengthPixels);
renderPistonArmEastWest(x + thickness, x + thickness + armLength,
y + rightEdge, y + rightEdge, z + leftEdge,
z + rightEdge, br, armLengthPixels);
renderPistonArmEastWest(x + thickness, x + thickness + armLength,
y + leftEdge, y + rightEdge, z + leftEdge,
z + leftEdge, br * 0.6f, armLengthPixels);
renderPistonArmEastWest(x + thickness, x + thickness + armLength,
y + rightEdge, y + leftEdge, z + rightEdge,
z + rightEdge, br * 0.6f, armLengthPixels);
break;
case Facing::EAST:
northFlip = FLIP_CCW;
southFlip = FLIP_CW;
upFlip = FLIP_CW;
downFlip = FLIP_CCW;
setShape(1.0f - thickness, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f);
tesselateBlockInWorld(tt, x, y, z);
t->tex2(getLightColor(
tt, level, x, y,
z)); // 4J added - renderPistonArmDown doesn't set its own tex2
// so just inherited from previous tesselateBlockInWorld
renderPistonArmEastWest(x - thickness + 1.0f - armLength,
x - thickness + 1.0f, y + leftEdge,
y + leftEdge, z + rightEdge, z + leftEdge,
br * 0.5f, armLengthPixels);
renderPistonArmEastWest(x - thickness + 1.0f - armLength,
x - thickness + 1.0f, y + rightEdge,
y + rightEdge, z + leftEdge, z + rightEdge,
br, armLengthPixels);
renderPistonArmEastWest(x - thickness + 1.0f - armLength,
x - thickness + 1.0f, y + leftEdge,
y + rightEdge, z + leftEdge, z + leftEdge,
br * 0.6f, armLengthPixels);
renderPistonArmEastWest(x - thickness + 1.0f - armLength,
x - thickness + 1.0f, y + rightEdge,
y + leftEdge, z + rightEdge, z + rightEdge,
br * 0.6f, armLengthPixels);
break;
}
northFlip = FLIP_NONE;
southFlip = FLIP_NONE;
eastFlip = FLIP_NONE;
westFlip = FLIP_NONE;
upFlip = FLIP_NONE;
downFlip = FLIP_NONE;
setShape(0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f);
// LeaveCriticalSection( &Tile_SPU::m_csShape );
#endif // DISABLE_TESS_FUNCS
return true;
}
bool TileRenderer_SPU::tesselateLeverInWorld(Tile_SPU* tt, int x, int y,
int z) {
#ifdef DISABLE_TESS_FUNCS
int data = level->getData(x, y, z);
int dir = data & 7;
bool flipped = (data & 8) > 0;
Tesselator_SPU* t = getTesselator();
bool hadFixed = hasFixedTexture();
if (!hadFixed) this->setFixedTexture(getTexture(Tile_SPU::stoneBrick));
float w1 = 4.0f / 16.0f;
float w2 = 3.0f / 16.0f;
float h = 3.0f / 16.0f;
// EnterCriticalSection( &Tile_SPU::m_csShape );
if (dir == 5) {
setShape(0.5f - w2, 0.0f, 0.5f - w1, 0.5f + w2, h, 0.5f + w1);
} else if (dir == 6) {
setShape(0.5f - w1, 0.0f, 0.5f - w2, 0.5f + w1, h, 0.5f + w2);
} else if (dir == 4) {
setShape(0.5f - w2, 0.5f - w1, 1.0f - h, 0.5f + w2, 0.5f + w1, 1.0f);
} else if (dir == 3) {
setShape(0.5f - w2, 0.5f - w1, 0, 0.5f + w2, 0.5f + w1, h);
} else if (dir == 2) {
setShape(1.0f - h, 0.5f - w1, 0.5f - w2, 1.0f, 0.5f + w1, 0.5f + w2);
} else if (dir == 1) {
setShape(0, 0.5f - w1, 0.5f - w2, h, 0.5f + w1, 0.5f + w2);
} else if (dir == 0) {
setShape(0.5f - w1, 1 - h, 0.5f - w2, 0.5f + w1, 1, 0.5f + w2);
} else if (dir == 7) {
setShape(0.5f - w2, 1 - h, 0.5f - w1, 0.5f + w2, 1, 0.5f + w1);
}
this->tesselateBlockInWorld(tt, x, y, z);
// LeaveCriticalSection( &Tile_SPU::m_csShape );
if (!hadFixed) this->clearFixedTexture();
float br;
if (SharedConstants::TEXTURE_LIGHTING) {
t->tex2(tt->getLightColor(level, x, y, z));
br = 1;
} else {
br = tt->getBrightness(level, x, y, z);
}
if (Tile_SPU::lightEmission[tt->id] > 0) br = 1.0f;
t->color(br, br, br);
Icon_SPU* tex = getTexture(tt, 0);
if (hasFixedTexture()) tex = fixedTexture;
float u0 = tex->getU0();
float v0 = tex->getV0();
float u1 = tex->getU1();
float v1 = tex->getV1();
Vec3* corners[8];
float xv = 1.0f / 16.0f;
float zv = 1.0f / 16.0f;
float yv = 10.0f / 16.0f;
corners[0] = Vec3::newTemp(-xv, -0, -zv);
corners[1] = Vec3::newTemp(+xv, -0, -zv);
corners[2] = Vec3::newTemp(+xv, -0, +zv);
corners[3] = Vec3::newTemp(-xv, -0, +zv);
corners[4] = Vec3::newTemp(-xv, +yv, -zv);
corners[5] = Vec3::newTemp(+xv, +yv, -zv);
corners[6] = Vec3::newTemp(+xv, +yv, +zv);
corners[7] = Vec3::newTemp(-xv, +yv, +zv);
for (int i = 0; i < 8; i++) {
if (flipped) {
corners[i]->z -= 1 / 16.0f;
corners[i]->xRot(40 * PI / 180);
} else {
corners[i]->z += 1 / 16.0f;
corners[i]->xRot(-40 * PI / 180);
}
if (dir == 0 || dir == 7) {
corners[i]->zRot(180 * PI / 180);
}
if (dir == 6 || dir == 0) {
corners[i]->yRot(90 * PI / 180);
}
if (dir > 0 && dir < 5) {
corners[i]->y -= 6 / 16.0f;
corners[i]->xRot(90 * PI / 180);
if (dir == 4) corners[i]->yRot(0 * PI / 180);
if (dir == 3) corners[i]->yRot(180 * PI / 180);
if (dir == 2) corners[i]->yRot(90 * PI / 180);
if (dir == 1) corners[i]->yRot(-90 * PI / 180);
corners[i]->x += x + 0.5;
corners[i]->y += y + 8 / 16.0f;
corners[i]->z += z + 0.5;
} else if (dir == 0 || dir == 7) {
corners[i]->x += x + 0.5;
corners[i]->y += y + 14 / 16.0f;
corners[i]->z += z + 0.5;
} else {
corners[i]->x += x + 0.5;
corners[i]->y += y + 2 / 16.0f;
corners[i]->z += z + 0.5;
}
}
Vec3 *c0 = NULL, *c1 = NULL, *c2 = NULL, *c3 = NULL;
for (int i = 0; i < 6; i++) {
if (i == 0) {
u0 = tex->getU(7);
v0 = tex->getV(6);
u1 = tex->getU(9);
v1 = tex->getV(8);
} else if (i == 2) {
u0 = tex->getU(7);
v0 = tex->getV(6);
u1 = tex->getU(9);
v1 = tex->getV1();
}
if (i == 0) {
c0 = corners[0];
c1 = corners[1];
c2 = corners[2];
c3 = corners[3];
} else if (i == 1) {
c0 = corners[7];
c1 = corners[6];
c2 = corners[5];
c3 = corners[4];
} else if (i == 2) {
c0 = corners[1];
c1 = corners[0];
c2 = corners[4];
c3 = corners[5];
} else if (i == 3) {
c0 = corners[2];
c1 = corners[1];
c2 = corners[5];
c3 = corners[6];
} else if (i == 4) {
c0 = corners[3];
c1 = corners[2];
c2 = corners[6];
c3 = corners[7];
} else if (i == 5) {
c0 = corners[0];
c1 = corners[3];
c2 = corners[7];
c3 = corners[4];
}
t->vertexUV((float)(c0->x), (float)(c0->y), (float)(c0->z), (float)(u0),
(float)(v1));
t->vertexUV((float)(c1->x), (float)(c1->y), (float)(c1->z), (float)(u1),
(float)(v1));
t->vertexUV((float)(c2->x), (float)(c2->y), (float)(c2->z), (float)(u1),
(float)(v0));
t->vertexUV((float)(c3->x), (float)(c3->y), (float)(c3->z), (float)(u0),
(float)(v0));
}
#endif // DISABLE_TESS_FUNCS
return true;
}
bool TileRenderer_SPU::tesselateTripwireSourceInWorld(Tile_SPU* tt, int x,
int y, int z) {
#ifdef DISABLE_TESS_FUNCS
Tesselator* t = Tesselator::getInstance();
int data = level->getData(x, y, z);
int dir = data & TripWireSourceTile::MASK_DIR;
bool attached = (data & TripWireSourceTile::MASK_ATTACHED) ==
TripWireSourceTile::MASK_ATTACHED;
bool powered = (data & TripWireSourceTile::MASK_POWERED) ==
TripWireSourceTile::MASK_POWERED;
bool suspended = !level->isTopSolidBlocking(x, y - 1, z);
bool hadFixed = hasFixedTexture();
if (!hadFixed) this->setFixedTexture(getTexture(Tile::wood));
float boxHeight = 4 / 16.0f;
float boxWidth = 2 / 16.0f;
float boxDepth = 2 / 16.0f;
float boxy0 = 0.3f - boxHeight;
float boxy1 = 0.3f + boxHeight;
if (dir == Direction::NORTH) {
setShape(0.5f - boxWidth, boxy0, 1 - boxDepth, 0.5f + boxWidth, boxy1,
1);
} else if (dir == Direction::SOUTH) {
setShape(0.5f - boxWidth, boxy0, 0, 0.5f + boxWidth, boxy1, boxDepth);
} else if (dir == Direction::WEST) {
setShape(1 - boxDepth, boxy0, 0.5f - boxWidth, 1, boxy1,
0.5f + boxWidth);
} else if (dir == Direction::EAST) {
setShape(0, boxy0, 0.5f - boxWidth, boxDepth, boxy1, 0.5f + boxWidth);
}
this->tesselateBlockInWorld(tt, x, y, z);
if (!hadFixed) this->clearFixedTexture();
float brightness;
if (SharedConstants::TEXTURE_LIGHTING) {
t->tex2(tt->getLightColor(level, x, y, z));
brightness = 1;
} else {
brightness = tt->getBrightness(level, x, y, z);
}
if (Tile::lightEmission[tt->id] > 0) brightness = 1.0f;
t->color(brightness, brightness, brightness);
Icon* tex = getTexture(tt, 0);
if (hasFixedTexture()) tex = fixedTexture;
double u0 = tex->getU0();
double v0 = tex->getV0();
double u1 = tex->getU1();
double v1 = tex->getV1();
Vec3* corners[8];
float stickWidth = 0.75f / 16.0f;
float stickHeight = 0.75f / 16.0f;
float stickLength = 5 / 16.0f;
corners[0] = Vec3::newTemp(-stickWidth, -0, -stickHeight);
corners[1] = Vec3::newTemp(+stickWidth, -0, -stickHeight);
corners[2] = Vec3::newTemp(+stickWidth, -0, +stickHeight);
corners[3] = Vec3::newTemp(-stickWidth, -0, +stickHeight);
corners[4] = Vec3::newTemp(-stickWidth, +stickLength, -stickHeight);
corners[5] = Vec3::newTemp(+stickWidth, +stickLength, -stickHeight);
corners[6] = Vec3::newTemp(+stickWidth, +stickLength, +stickHeight);
corners[7] = Vec3::newTemp(-stickWidth, +stickLength, +stickHeight);
for (int i = 0; i < 8; i++) {
corners[i]->z += 1 / 16.0f;
if (powered) {
corners[i]->xRot(30 * PI / 180);
corners[i]->y -= 7 / 16.0f;
} else if (attached) {
corners[i]->xRot(5 * PI / 180);
corners[i]->y -= 7 / 16.0f;
} else {
corners[i]->xRot(-40 * PI / 180);
corners[i]->y -= 6 / 16.0f;
}
corners[i]->xRot(90 * PI / 180);
if (dir == Direction::NORTH) corners[i]->yRot(0 * PI / 180);
if (dir == Direction::SOUTH) corners[i]->yRot(180 * PI / 180);
if (dir == Direction::WEST) corners[i]->yRot(90 * PI / 180);
if (dir == Direction::EAST) corners[i]->yRot(-90 * PI / 180);
corners[i]->x += x + 0.5;
corners[i]->y += y + 5 / 16.0f;
corners[i]->z += z + 0.5;
}
Vec3 *c0 = NULL, *c1 = NULL, *c2 = NULL, *c3 = NULL;
int stickX0 = 7;
int stickX1 = 9;
int stickY0 = 9;
int stickY1 = 16;
for (int i = 0; i < 6; i++) {
if (i == 0) {
c0 = corners[0];
c1 = corners[1];
c2 = corners[2];
c3 = corners[3];
u0 = tex->getU(stickX0);
v0 = tex->getV(stickY0);
u1 = tex->getU(stickX1);
v1 = tex->getV(stickY0 + 2);
} else if (i == 1) {
c0 = corners[7];
c1 = corners[6];
c2 = corners[5];
c3 = corners[4];
} else if (i == 2) {
c0 = corners[1];
c1 = corners[0];
c2 = corners[4];
c3 = corners[5];
u0 = tex->getU(stickX0);
v0 = tex->getV(stickY0);
u1 = tex->getU(stickX1);
v1 = tex->getV(stickY1);
} else if (i == 3) {
c0 = corners[2];
c1 = corners[1];
c2 = corners[5];
c3 = corners[6];
} else if (i == 4) {
c0 = corners[3];
c1 = corners[2];
c2 = corners[6];
c3 = corners[7];
} else if (i == 5) {
c0 = corners[0];
c1 = corners[3];
c2 = corners[7];
c3 = corners[4];
}
t->vertexUV(c0->x, c0->y, c0->z, u0, v1);
t->vertexUV(c1->x, c1->y, c1->z, u1, v1);
t->vertexUV(c2->x, c2->y, c2->z, u1, v0);
t->vertexUV(c3->x, c3->y, c3->z, u0, v0);
}
float hoopWidth = 1.5f / 16.0f;
float hoopHeight = 1.5f / 16.0f;
float hoopLength = 0.5f / 16.0f;
corners[0] = Vec3::newTemp(-hoopWidth, -0, -hoopHeight);
corners[1] = Vec3::newTemp(+hoopWidth, -0, -hoopHeight);
corners[2] = Vec3::newTemp(+hoopWidth, -0, +hoopHeight);
corners[3] = Vec3::newTemp(-hoopWidth, -0, +hoopHeight);
corners[4] = Vec3::newTemp(-hoopWidth, +hoopLength, -hoopHeight);
corners[5] = Vec3::newTemp(+hoopWidth, +hoopLength, -hoopHeight);
corners[6] = Vec3::newTemp(+hoopWidth, +hoopLength, +hoopHeight);
corners[7] = Vec3::newTemp(-hoopWidth, +hoopLength, +hoopHeight);
for (int i = 0; i < 8; i++) {
corners[i]->z += 3.5f / 16.0f;
if (powered) {
corners[i]->y -= 1.5 / 16.0f;
corners[i]->z -= 2.6 / 16.0f;
corners[i]->xRot(0 * PI / 180);
} else if (attached) {
corners[i]->y += 0.25 / 16.0f;
corners[i]->z -= 2.75 / 16.0f;
corners[i]->xRot(10 * PI / 180);
} else {
corners[i]->xRot(50 * PI / 180);
}
if (dir == Direction::NORTH) corners[i]->yRot(0 * PI / 180);
if (dir == Direction::SOUTH) corners[i]->yRot(180 * PI / 180);
if (dir == Direction::WEST) corners[i]->yRot(90 * PI / 180);
if (dir == Direction::EAST) corners[i]->yRot(-90 * PI / 180);
corners[i]->x += x + 0.5;
corners[i]->y += y + 5 / 16.0f;
corners[i]->z += z + 0.5;
}
int hoopX0 = 5;
int hoopX1 = 11;
int hoopY0 = 3;
int hoopY1 = 9;
for (int i = 0; i < 6; i++) {
if (i == 0) {
c0 = corners[0];
c1 = corners[1];
c2 = corners[2];
c3 = corners[3];
u0 = tex->getU(hoopX0);
v0 = tex->getV(hoopY0);
u1 = tex->getU(hoopX1);
v1 = tex->getV(hoopY1);
} else if (i == 1) {
c0 = corners[7];
c1 = corners[6];
c2 = corners[5];
c3 = corners[4];
} else if (i == 2) {
c0 = corners[1];
c1 = corners[0];
c2 = corners[4];
c3 = corners[5];
u0 = tex->getU(hoopX0);
v0 = tex->getV(hoopY0);
u1 = tex->getU(hoopX1);
v1 = tex->getV(hoopY0 + 2);
} else if (i == 3) {
c0 = corners[2];
c1 = corners[1];
c2 = corners[5];
c3 = corners[6];
} else if (i == 4) {
c0 = corners[3];
c1 = corners[2];
c2 = corners[6];
c3 = corners[7];
} else if (i == 5) {
c0 = corners[0];
c1 = corners[3];
c2 = corners[7];
c3 = corners[4];
}
t->vertexUV(c0->x, c0->y, c0->z, u0, v1);
t->vertexUV(c1->x, c1->y, c1->z, u1, v1);
t->vertexUV(c2->x, c2->y, c2->z, u1, v0);
t->vertexUV(c3->x, c3->y, c3->z, u0, v0);
}
if (attached) {
double hoopBottomY = corners[0]->y;
float width = 0.5f / 16.0f;
float top = 0.5f - (width / 2);
float bottom = top + width;
Icon* wireTex = getTexture(Tile::tripWire);
double wireX0 = tex->getU0();
double wireY0 = tex->getV(attached ? 2 : 0);
double wireX1 = tex->getU1();
double wireY1 = tex->getV(attached ? 4 : 2);
double floating = (suspended ? 3.5f : 1.5f) / 16.0;
brightness = tt->getBrightness(level, x, y, z) * 0.75f;
t->color(brightness, brightness, brightness);
if (dir == Direction::NORTH) {
t->vertexUV(x + top, y + floating, z + 0.25, wireX0, wireY0);
t->vertexUV(x + bottom, y + floating, z + 0.25, wireX0, wireY1);
t->vertexUV(x + bottom, y + floating, z, wireX1, wireY1);
t->vertexUV(x + top, y + floating, z, wireX1, wireY0);
t->vertexUV(x + top, hoopBottomY, z + 0.5, wireX0, wireY0);
t->vertexUV(x + bottom, hoopBottomY, z + 0.5, wireX0, wireY1);
t->vertexUV(x + bottom, y + floating, z + 0.25, wireX1, wireY1);
t->vertexUV(x + top, y + floating, z + 0.25, wireX1, wireY0);
} else if (dir == Direction::SOUTH) {
t->vertexUV(x + top, y + floating, z + 0.75, wireX0, wireY0);
t->vertexUV(x + bottom, y + floating, z + 0.75, wireX0, wireY1);
t->vertexUV(x + bottom, hoopBottomY, z + 0.5, wireX1, wireY1);
t->vertexUV(x + top, hoopBottomY, z + 0.5, wireX1, wireY0);
t->vertexUV(x + top, y + floating, z + 1, wireX0, wireY0);
t->vertexUV(x + bottom, y + floating, z + 1, wireX0, wireY1);
t->vertexUV(x + bottom, y + floating, z + 0.75, wireX1, wireY1);
t->vertexUV(x + top, y + floating, z + 0.75, wireX1, wireY0);
} else if (dir == Direction::WEST) {
t->vertexUV(x, y + floating, z + bottom, wireX0, wireY1);
t->vertexUV(x + 0.25, y + floating, z + bottom, wireX1, wireY1);
t->vertexUV(x + 0.25, y + floating, z + top, wireX1, wireY0);
t->vertexUV(x, y + floating, z + top, wireX0, wireY0);
t->vertexUV(x + 0.25, y + floating, z + bottom, wireX0, wireY1);
t->vertexUV(x + 0.5, hoopBottomY, z + bottom, wireX1, wireY1);
t->vertexUV(x + 0.5, hoopBottomY, z + top, wireX1, wireY0);
t->vertexUV(x + 0.25, y + floating, z + top, wireX0, wireY0);
} else {
t->vertexUV(x + 0.5, hoopBottomY, z + bottom, wireX0, wireY1);
t->vertexUV(x + 0.75, y + floating, z + bottom, wireX1, wireY1);
t->vertexUV(x + 0.75, y + floating, z + top, wireX1, wireY0);
t->vertexUV(x + 0.5, hoopBottomY, z + top, wireX0, wireY0);
t->vertexUV(x + 0.75, y + floating, z + bottom, wireX0, wireY1);
t->vertexUV(x + 1, y + floating, z + bottom, wireX1, wireY1);
t->vertexUV(x + 1, y + floating, z + top, wireX1, wireY0);
t->vertexUV(x + 0.75, y + floating, z + top, wireX0, wireY0);
}
}
#endif // #ifdef DISABLE_TESS_FUNCS
return true;
}
bool TileRenderer_SPU::tesselateTripwireInWorld(Tile_SPU* tt, int x, int y,
int z) {
#ifdef DISABLE_TESS_FUNCS
Tesselator* t = Tesselator::getInstance();
Icon* tex = getTexture(tt, 0);
int data = level->getData(x, y, z);
bool attached =
(data & TripWireTile::MASK_ATTACHED) == TripWireTile::MASK_ATTACHED;
bool suspended =
(data & TripWireTile::MASK_SUSPENDED) == TripWireTile::MASK_SUSPENDED;
if (hasFixedTexture()) tex = fixedTexture;
float brightness;
if (SharedConstants::TEXTURE_LIGHTING) {
t->tex2(tt->getLightColor(level, x, y, z));
}
brightness = tt->getBrightness(level, x, y, z) * 0.75f;
t->color(brightness, brightness, brightness);
double wireX0 = tex->getU0();
double wireY0 = tex->getV(attached ? 2 : 0);
double wireX1 = tex->getU1();
double wireY1 = tex->getV(attached ? 4 : 2);
double floating = (suspended ? 3.5f : 1.5f) / 16.0;
bool w =
TripWireTile::shouldConnectTo(level, x, y, z, data, Direction::WEST);
bool e =
TripWireTile::shouldConnectTo(level, x, y, z, data, Direction::EAST);
bool n =
TripWireTile::shouldConnectTo(level, x, y, z, data, Direction::NORTH);
bool s =
TripWireTile::shouldConnectTo(level, x, y, z, data, Direction::SOUTH);
float width = 0.5f / 16.0f;
float top = 0.5f - (width / 2);
float bottom = top + width;
if (!n && !e && !s && !w) {
n = true;
s = true;
}
if (n) {
t->vertexUV(x + top, y + floating, z + 0.25, wireX0, wireY0);
t->vertexUV(x + bottom, y + floating, z + 0.25, wireX0, wireY1);
t->vertexUV(x + bottom, y + floating, z, wireX1, wireY1);
t->vertexUV(x + top, y + floating, z, wireX1, wireY0);
t->vertexUV(x + top, y + floating, z, wireX1, wireY0);
t->vertexUV(x + bottom, y + floating, z, wireX1, wireY1);
t->vertexUV(x + bottom, y + floating, z + 0.25, wireX0, wireY1);
t->vertexUV(x + top, y + floating, z + 0.25, wireX0, wireY0);
}
if (n || (s && !e && !w)) {
t->vertexUV(x + top, y + floating, z + 0.5, wireX0, wireY0);
t->vertexUV(x + bottom, y + floating, z + 0.5, wireX0, wireY1);
t->vertexUV(x + bottom, y + floating, z + 0.25, wireX1, wireY1);
t->vertexUV(x + top, y + floating, z + 0.25, wireX1, wireY0);
t->vertexUV(x + top, y + floating, z + 0.25, wireX1, wireY0);
t->vertexUV(x + bottom, y + floating, z + 0.25, wireX1, wireY1);
t->vertexUV(x + bottom, y + floating, z + 0.5, wireX0, wireY1);
t->vertexUV(x + top, y + floating, z + 0.5, wireX0, wireY0);
}
if (s || (n && !e && !w)) {
t->vertexUV(x + top, y + floating, z + 0.75, wireX0, wireY0);
t->vertexUV(x + bottom, y + floating, z + 0.75, wireX0, wireY1);
t->vertexUV(x + bottom, y + floating, z + 0.5, wireX1, wireY1);
t->vertexUV(x + top, y + floating, z + 0.5, wireX1, wireY0);
t->vertexUV(x + top, y + floating, z + 0.5, wireX1, wireY0);
t->vertexUV(x + bottom, y + floating, z + 0.5, wireX1, wireY1);
t->vertexUV(x + bottom, y + floating, z + 0.75, wireX0, wireY1);
t->vertexUV(x + top, y + floating, z + 0.75, wireX0, wireY0);
}
if (s) {
t->vertexUV(x + top, y + floating, z + 1, wireX0, wireY0);
t->vertexUV(x + bottom, y + floating, z + 1, wireX0, wireY1);
t->vertexUV(x + bottom, y + floating, z + 0.75, wireX1, wireY1);
t->vertexUV(x + top, y + floating, z + 0.75, wireX1, wireY0);
t->vertexUV(x + top, y + floating, z + 0.75, wireX1, wireY0);
t->vertexUV(x + bottom, y + floating, z + 0.75, wireX1, wireY1);
t->vertexUV(x + bottom, y + floating, z + 1, wireX0, wireY1);
t->vertexUV(x + top, y + floating, z + 1, wireX0, wireY0);
}
if (w) {
t->vertexUV(x, y + floating, z + bottom, wireX0, wireY1);
t->vertexUV(x + 0.25, y + floating, z + bottom, wireX1, wireY1);
t->vertexUV(x + 0.25, y + floating, z + top, wireX1, wireY0);
t->vertexUV(x, y + floating, z + top, wireX0, wireY0);
t->vertexUV(x, y + floating, z + top, wireX0, wireY0);
t->vertexUV(x + 0.25, y + floating, z + top, wireX1, wireY0);
t->vertexUV(x + 0.25, y + floating, z + bottom, wireX1, wireY1);
t->vertexUV(x, y + floating, z + bottom, wireX0, wireY1);
}
if (w || (e && !n && !s)) {
t->vertexUV(x + 0.25, y + floating, z + bottom, wireX0, wireY1);
t->vertexUV(x + 0.5, y + floating, z + bottom, wireX1, wireY1);
t->vertexUV(x + 0.5, y + floating, z + top, wireX1, wireY0);
t->vertexUV(x + 0.25, y + floating, z + top, wireX0, wireY0);
t->vertexUV(x + 0.25, y + floating, z + top, wireX0, wireY0);
t->vertexUV(x + 0.5, y + floating, z + top, wireX1, wireY0);
t->vertexUV(x + 0.5, y + floating, z + bottom, wireX1, wireY1);
t->vertexUV(x + 0.25, y + floating, z + bottom, wireX0, wireY1);
}
if (e || (w && !n && !s)) {
t->vertexUV(x + 0.5, y + floating, z + bottom, wireX0, wireY1);
t->vertexUV(x + 0.75, y + floating, z + bottom, wireX1, wireY1);
t->vertexUV(x + 0.75, y + floating, z + top, wireX1, wireY0);
t->vertexUV(x + 0.5, y + floating, z + top, wireX0, wireY0);
t->vertexUV(x + 0.5, y + floating, z + top, wireX0, wireY0);
t->vertexUV(x + 0.75, y + floating, z + top, wireX1, wireY0);
t->vertexUV(x + 0.75, y + floating, z + bottom, wireX1, wireY1);
t->vertexUV(x + 0.5, y + floating, z + bottom, wireX0, wireY1);
}
if (e) {
t->vertexUV(x + 0.75, y + floating, z + bottom, wireX0, wireY1);
t->vertexUV(x + 1, y + floating, z + bottom, wireX1, wireY1);
t->vertexUV(x + 1, y + floating, z + top, wireX1, wireY0);
t->vertexUV(x + 0.75, y + floating, z + top, wireX0, wireY0);
t->vertexUV(x + 0.75, y + floating, z + top, wireX0, wireY0);
t->vertexUV(x + 1, y + floating, z + top, wireX1, wireY0);
t->vertexUV(x + 1, y + floating, z + bottom, wireX1, wireY1);
t->vertexUV(x + 0.75, y + floating, z + bottom, wireX0, wireY1);
}
#endif // DISABLE_TESS_FUNCS
return true;
}
bool TileRenderer_SPU::tesselateFireInWorld(FireTile_SPU* tt, int x, int y,
int z) {
Tesselator_SPU* t = getTesselator();
Icon_SPU* firstTex = tt->getTextureLayer(0);
Icon_SPU* secondTex = tt->getTextureLayer(1);
Icon_SPU* tex = firstTex;
if (hasFixedTexture()) tex = fixedTexture;
if (SharedConstants::TEXTURE_LIGHTING) {
t->color(1.0f, 1.0f, 1.0f);
t->tex2(tt->getLightColor(level, x, y, z));
} else {
float br = tt->getBrightness(level, x, y, z);
t->color(br, br, br);
}
float u0 = tex->getU0();
float v0 = tex->getV0();
float u1 = tex->getU1();
float v1 = tex->getV1();
float h = 1.4f;
if (level->isSolidBlockingTile(x, y - 1, z) ||
FireTile_SPU::canBurn(level, x, y - 1, z)) {
float x0 = x + 0.5f + 0.2f;
float x1 = x + 0.5f - 0.2f;
float z0 = z + 0.5f + 0.2f;
float z1 = z + 0.5f - 0.2f;
float x0_ = x + 0.5f - 0.3f;
float x1_ = x + 0.5f + 0.3f;
float z0_ = z + 0.5f - 0.3f;
float z1_ = z + 0.5f + 0.3f;
t->vertexUV((float)(x0_), (float)(y + h), (float)(z + 1), (float)(u1),
(float)(v0));
t->vertexUV((float)(x0), (float)(y + 0), (float)(z + 1), (float)(u1),
(float)(v1));
t->vertexUV((float)(x0), (float)(y + 0), (float)(z + 0), (float)(u0),
(float)(v1));
t->vertexUV((float)(x0_), (float)(y + h), (float)(z + 0), (float)(u0),
(float)(v0));
t->vertexUV((float)(x1_), (float)(y + h), (float)(z + 0), (float)(u1),
(float)(v0));
t->vertexUV((float)(x1), (float)(y + 0), (float)(z + 0), (float)(u1),
(float)(v1));
t->vertexUV((float)(x1), (float)(y + 0), (float)(z + 1), (float)(u0),
(float)(v1));
t->vertexUV((float)(x1_), (float)(y + h), (float)(z + 1), (float)(u0),
(float)(v0));
tex = secondTex;
u0 = tex->getU0();
v0 = tex->getV0();
u1 = tex->getU1();
v1 = tex->getV1();
t->vertexUV((float)(x + 1), (float)(y + h), (float)(z1_), (float)(u1),
(float)(v0));
t->vertexUV((float)(x + 1), (float)(y + 0), (float)(z1), (float)(u1),
(float)(v1));
t->vertexUV((float)(x + 0), (float)(y + 0), (float)(z1), (float)(u0),
(float)(v1));
t->vertexUV((float)(x + 0), (float)(y + h), (float)(z1_), (float)(u0),
(float)(v0));
t->vertexUV((float)(x + 0), (float)(y + h), (float)(z0_), (float)(u1),
(float)(v0));
t->vertexUV((float)(x + 0), (float)(y + 0), (float)(z0), (float)(u1),
(float)(v1));
t->vertexUV((float)(x + 1), (float)(y + 0), (float)(z0), (float)(u0),
(float)(v1));
t->vertexUV((float)(x + 1), (float)(y + h), (float)(z0_), (float)(u0),
(float)(v0));
x0 = x + 0.5f - 0.5f;
x1 = x + 0.5f + 0.5f;
z0 = z + 0.5f - 0.5f;
z1 = z + 0.5f + 0.5f;
x0_ = x + 0.5f - 0.4f;
x1_ = x + 0.5f + 0.4f;
z0_ = z + 0.5f - 0.4f;
z1_ = z + 0.5f + 0.4f;
t->vertexUV((float)(x0_), (float)(y + h), (float)(z + 0), (float)(u0),
(float)(v0));
t->vertexUV((float)(x0), (float)(y + 0), (float)(z + 0), (float)(u0),
(float)(v1));
t->vertexUV((float)(x0), (float)(y + 0), (float)(z + 1), (float)(u1),
(float)(v1));
t->vertexUV((float)(x0_), (float)(y + h), (float)(z + 1), (float)(u1),
(float)(v0));
t->vertexUV((float)(x1_), (float)(y + h), (float)(z + 1), (float)(u0),
(float)(v0));
t->vertexUV((float)(x1), (float)(y + 0), (float)(z + 1), (float)(u0),
(float)(v1));
t->vertexUV((float)(x1), (float)(y + 0), (float)(z + 0), (float)(u1),
(float)(v1));
t->vertexUV((float)(x1_), (float)(y + h), (float)(z + 0), (float)(u1),
(float)(v0));
tex = firstTex;
u0 = tex->getU0();
v0 = tex->getV0();
u1 = tex->getU1();
v1 = tex->getV1();
t->vertexUV((float)(x + 0), (float)(y + h), (float)(z1_), (float)(u0),
(float)(v0));
t->vertexUV((float)(x + 0), (float)(y + 0), (float)(z1), (float)(u0),
(float)(v1));
t->vertexUV((float)(x + 1), (float)(y + 0), (float)(z1), (float)(u1),
(float)(v1));
t->vertexUV((float)(x + 1), (float)(y + h), (float)(z1_), (float)(u1),
(float)(v0));
t->vertexUV((float)(x + 1), (float)(y + h), (float)(z0_), (float)(u0),
(float)(v0));
t->vertexUV((float)(x + 1), (float)(y + 0), (float)(z0), (float)(u0),
(float)(v1));
t->vertexUV((float)(x + 0), (float)(y + 0), (float)(z0), (float)(u1),
(float)(v1));
t->vertexUV((float)(x + 0), (float)(y + h), (float)(z0_), (float)(u1),
(float)(v0));
} else {
float r = 0.2f;
float yo = 1 / 16.0f;
if (((x + y + z) & 1) == 1) {
tex = secondTex;
u0 = tex->getU0();
v0 = tex->getV0();
u1 = tex->getU1();
v1 = tex->getV1();
}
if (((x / 2 + y / 2 + z / 2) & 1) == 1) {
float tmp = u1;
u1 = u0;
u0 = tmp;
}
if (FireTile_SPU::canBurn(level, x - 1, y, z)) {
t->vertexUV((float)(x + r), (float)(y + h + yo), (float)(z + 1.0f),
(float)(u1), (float)(v0));
t->vertexUV((float)(x + 0.0f), (float)(y + 0.0f + yo),
(float)(z + 1.0f), (float)(u1), (float)(v1));
t->vertexUV((float)(x + 0.0f), (float)(y + 0.0f + yo),
(float)(z + 0.0f), (float)(u0), (float)(v1));
t->vertexUV((float)(x + r), (float)(y + h + yo), (float)(z + 0.0f),
(float)(u0), (float)(v0));
t->vertexUV((float)(x + r), (float)(y + h + yo), (float)(z + 0.0f),
(float)(u0), (float)(v0));
t->vertexUV((float)(x + 0.0f), (float)(y + 0.0f + yo),
(float)(z + 0.0f), (float)(u0), (float)(v1));
t->vertexUV((float)(x + 0.0f), (float)(y + 0.0f + yo),
(float)(z + 1.0f), (float)(u1), (float)(v1));
t->vertexUV((float)(x + r), (float)(y + h + yo), (float)(z + 1.0f),
(float)(u1), (float)(v0));
}
if (FireTile_SPU::canBurn(level, x + 1, y, z)) {
t->vertexUV((float)(x + 1 - r), (float)(y + h + yo),
(float)(z + 0.0f), (float)(u0), (float)(v0));
t->vertexUV((float)(x + 1 - 0), (float)(y + 0 + yo),
(float)(z + 0.0f), (float)(u0), (float)(v1));
t->vertexUV((float)(x + 1 - 0), (float)(y + 0 + yo),
(float)(z + 1.0f), (float)(u1), (float)(v1));
t->vertexUV((float)(x + 1 - r), (float)(y + h + yo),
(float)(z + 1.0f), (float)(u1), (float)(v0));
t->vertexUV((float)(x + 1.0f - r), (float)(y + h + yo),
(float)(z + 1.0f), (float)(u1), (float)(v0));
t->vertexUV((float)(x + 1.0f - 0.0f), (float)(y + 0.0f + yo),
(float)(z + 1.0f), (float)(u1), (float)(v1));
t->vertexUV((float)(x + 1.0f - 0), (float)(y + 0.0f + yo),
(float)(z + 0.0f), (float)(u0), (float)(v1));
t->vertexUV((float)(x + 1.0f - r), (float)(y + h + yo),
(float)(z + 0.0f), (float)(u0), (float)(v0));
}
if (FireTile_SPU::canBurn(level, x, y, z - 1)) {
t->vertexUV((float)(x + 0.0f), (float)(y + h + yo), (float)(z + r),
(float)(u1), (float)(v0));
t->vertexUV((float)(x + 0.0f), (float)(y + 0.0f + yo),
(float)(z + 0.0f), (float)(u1), (float)(v1));
t->vertexUV((float)(x + 1.0f), (float)(y + 0.0f + yo),
(float)(z + 0.0f), (float)(u0), (float)(v1));
t->vertexUV((float)(x + 1.0f), (float)(y + h + yo), (float)(z + r),
(float)(u0), (float)(v0));
t->vertexUV((float)(x + 1.0f), (float)(y + h + yo), (float)(z + r),
(float)(u0), (float)(v0));
t->vertexUV((float)(x + 1.0f), (float)(y + 0.0f + yo),
(float)(z + 0.0f), (float)(u0), (float)(v1));
t->vertexUV((float)(x + 0.0f), (float)(y + 0.0f + yo),
(float)(z + 0.0f), (float)(u1), (float)(v1));
t->vertexUV((float)(x + 0.0f), (float)(y + h + yo), (float)(z + r),
(float)(u1), (float)(v0));
}
if (FireTile_SPU::canBurn(level, x, y, z + 1)) {
t->vertexUV((float)(x + 1.0f), (float)(y + h + yo),
(float)(z + 1.0f - r), (float)(u0), (float)(v0));
t->vertexUV((float)(x + 1.0f), (float)(y + 0.0f + yo),
(float)(z + 1.0f - 0.0f), (float)(u0), (float)(v1));
t->vertexUV((float)(x + 0.0f), (float)(y + 0.0f + yo),
(float)(z + 1.0f - 0.0f), (float)(u1), (float)(v1));
t->vertexUV((float)(x + 0.0f), (float)(y + h + yo),
(float)(z + 1.0f - r), (float)(u1), (float)(v0));
t->vertexUV((float)(x + 0.0f), (float)(y + h + yo),
(float)(z + 1.0f - r), (float)(u1), (float)(v0));
t->vertexUV((float)(x + 0.0f), (float)(y + 0.0f + yo),
(float)(z + 1.0f - 0.0f), (float)(u1), (float)(v1));
t->vertexUV((float)(x + 1.0f), (float)(y + 0.0f + yo),
(float)(z + 1.0f - 0.0f), (float)(u0), (float)(v1));
t->vertexUV((float)(x + 1.0f), (float)(y + h + yo),
(float)(z + 1.0f - r), (float)(u0), (float)(v0));
}
if (FireTile_SPU::canBurn(level, x, y + 1.0f, z)) {
float x0 = x + 0.5f + 0.5f;
float x1 = x + 0.5f - 0.5f;
float z0 = z + 0.5f + 0.5f;
float z1 = z + 0.5f - 0.5f;
float x0_ = x + 0.5f - 0.5f;
float x1_ = x + 0.5f + 0.5f;
float z0_ = z + 0.5f - 0.5f;
float z1_ = z + 0.5f + 0.5f;
tex = firstTex;
u0 = tex->getU0();
v0 = tex->getV0();
u1 = tex->getU1();
v1 = tex->getV1();
y += 1;
h = -0.2f;
if (((x + y + z) & 1) == 0) {
t->vertexUV((float)(x0_), (float)(y + h), (float)(z + 0),
(float)(u1), (float)(v0));
t->vertexUV((float)(x0), (float)(y + 0), (float)(z + 0),
(float)(u1), (float)(v1));
t->vertexUV((float)(x0), (float)(y + 0), (float)(z + 1),
(float)(u0), (float)(v1));
t->vertexUV((float)(x0_), (float)(y + h), (float)(z + 1),
(float)(u0), (float)(v0));
tex = secondTex;
u0 = tex->getU0();
v0 = tex->getV0();
u1 = tex->getU1();
v1 = tex->getV1();
t->vertexUV((float)(x1_), (float)(y + h), (float)(z + 1.0f),
(float)(u1), (float)(v0));
t->vertexUV((float)(x1), (float)(y + 0.0f), (float)(z + 1.0f),
(float)(u1), (float)(v1));
t->vertexUV((float)(x1), (float)(y + 0.0f), (float)(z + 0),
(float)(u0), (float)(v1));
t->vertexUV((float)(x1_), (float)(y + h), (float)(z + 0),
(float)(u0), (float)(v0));
} else {
t->vertexUV((float)(x + 0.0f), (float)(y + h), (float)(z1_),
(float)(u1), (float)(v0));
t->vertexUV((float)(x + 0.0f), (float)(y + 0.0f), (float)(z1),
(float)(u1), (float)(v1));
t->vertexUV((float)(x + 1.0f), (float)(y + 0.0f), (float)(z1),
(float)(u0), (float)(v1));
t->vertexUV((float)(x + 1.0f), (float)(y + h), (float)(z1_),
(float)(u0), (float)(v0));
tex = secondTex;
u0 = tex->getU0();
v0 = tex->getV0();
u1 = tex->getU1();
v1 = tex->getV1();
t->vertexUV((float)(x + 1.0f), (float)(y + h), (float)(z0_),
(float)(u1), (float)(v0));
t->vertexUV((float)(x + 1.0f), (float)(y + 0.0f), (float)(z0),
(float)(u1), (float)(v1));
t->vertexUV((float)(x + 0.0f), (float)(y + 0.0f), (float)(z0),
(float)(u0), (float)(v1));
t->vertexUV((float)(x + 0.0f), (float)(y + h), (float)(z0_),
(float)(u0), (float)(v0));
}
}
}
return true;
}
bool TileRenderer_SPU::tesselateDustInWorld(Tile_SPU* tt, int x, int y, int z) {
#ifdef DISABLE_TESS_FUNCS
Tesselator_SPU* t = getTesselator();
int data = level->getData(x, y, z);
Icon_SPU* crossTexture = RedStoneDustTile_SPU::getTextureByName(
RedStoneDustTile_SPU::TEXTURE_CROSS);
Icon_SPU* lineTexture = RedStoneDustTile_SPU::getTextureByName(
RedStoneDustTile_SPU::TEXTURE_LINE);
Icon_SPU* crossTextureOverlay = RedStoneDustTile_SPU::getTextureByName(
RedStoneDustTile_SPU::TEXTURE_CROSS_OVERLAY);
Icon_SPU* lineTextureOverlay = RedStoneDustTile_SPU::getTextureByName(
RedStoneDustTile_SPU::TEXTURE_LINE_OVERLAY);
float br;
if (SharedConstants::TEXTURE_LIGHTING) {
t->tex2(tt->getLightColor(level, x, y, z));
br = 1;
} else {
br = tt->getBrightness(level, x, y, z);
}
float pow = (data / 15.0f);
float red = pow * 0.6f + 0.4f;
if (data == 0) red = 0.3f;
float green = pow * pow * 0.7f - 0.5f;
float blue = pow * pow * 0.6f - 0.7f;
if (green < 0) green = 0;
if (blue < 0) blue = 0;
if (SharedConstants::TEXTURE_LIGHTING) {
t->color(red, green, blue);
} else {
t->color(br * red, br * green, br * blue);
}
const float dustOffset = 0.25f / 16.0f;
const float overlayOffset = 0.25f / 16.0f;
bool w = RedStoneDustTile_SPU::shouldConnectTo(level, x - 1, y, z,
Direction::WEST) ||
(!level->isSolidBlockingTile(x - 1, y, z) &&
RedStoneDustTile_SPU::shouldConnectTo(level, x - 1, y - 1, z,
Direction::UNDEFINED));
bool e = RedStoneDustTile_SPU::shouldConnectTo(level, x + 1, y, z,
Direction::EAST) ||
(!level->isSolidBlockingTile(x + 1, y, z) &&
RedStoneDustTile_SPU::shouldConnectTo(level, x + 1, y - 1, z,
Direction::UNDEFINED));
bool n = RedStoneDustTile_SPU::shouldConnectTo(level, x, y, z - 1,
Direction::NORTH) ||
(!level->isSolidBlockingTile(x, y, z - 1) &&
RedStoneDustTile_SPU::shouldConnectTo(level, x, y - 1, z - 1,
Direction::UNDEFINED));
bool s = RedStoneDustTile_SPU::shouldConnectTo(level, x, y, z + 1,
Direction::SOUTH) ||
(!level->isSolidBlockingTile(x, y, z + 1) &&
RedStoneDustTile_SPU::shouldConnectTo(level, x, y - 1, z + 1,
Direction::UNDEFINED));
if (!level->isSolidBlockingTile(x, y + 1, z)) {
if (level->isSolidBlockingTile(x - 1, y, z) &&
RedStoneDustTile_SPU::shouldConnectTo(level, x - 1, y + 1, z,
Direction::UNDEFINED))
w = true;
if (level->isSolidBlockingTile(x + 1, y, z) &&
RedStoneDustTile_SPU::shouldConnectTo(level, x + 1, y + 1, z,
Direction::UNDEFINED))
e = true;
if (level->isSolidBlockingTile(x, y, z - 1) &&
RedStoneDustTile_SPU::shouldConnectTo(level, x, y + 1, z - 1,
Direction::UNDEFINED))
n = true;
if (level->isSolidBlockingTile(x, y, z + 1) &&
RedStoneDustTile_SPU::shouldConnectTo(level, x, y + 1, z + 1,
Direction::UNDEFINED))
s = true;
}
float x0 = (float)(x + 0.0f);
float x1 = (float)(x + 1.0f);
float z0 = (float)(z + 0.0f);
float z1 = (float)(z + 1.0f);
int pic = 0;
if ((w || e) && (!n && !s)) pic = 1;
if ((n || s) && (!e && !w)) pic = 2;
if (pic == 0) {
// if ( e || n || s || w )
int u0 = 0;
int v0 = 0;
int u1 = SharedConstants::WORLD_RESOLUTION;
int v1 = SharedConstants::WORLD_RESOLUTION;
int cutDistance = 5;
if (!w) x0 += cutDistance / (float)SharedConstants::WORLD_RESOLUTION;
if (!w) u0 += cutDistance;
if (!e) x1 -= cutDistance / (float)SharedConstants::WORLD_RESOLUTION;
if (!e) u1 -= cutDistance;
if (!n) z0 += cutDistance / (float)SharedConstants::WORLD_RESOLUTION;
if (!n) v0 += cutDistance;
if (!s) z1 -= cutDistance / (float)SharedConstants::WORLD_RESOLUTION;
if (!s) v1 -= cutDistance;
t->vertexUV((float)(x1), (float)(y + dustOffset), (float)(z1),
crossTexture->getU(u1), crossTexture->getV(v1));
t->vertexUV((float)(x1), (float)(y + dustOffset), (float)(z0),
crossTexture->getU(u1), crossTexture->getV(v0));
t->vertexUV((float)(x0), (float)(y + dustOffset), (float)(z0),
crossTexture->getU(u0), crossTexture->getV(v0));
t->vertexUV((float)(x0), (float)(y + dustOffset), (float)(z1),
crossTexture->getU(u0), crossTexture->getV(v1));
t->color(br, br, br);
t->vertexUV((float)(x1), (float)(y + dustOffset), (float)(z1),
crossTextureOverlay->getU(u1),
crossTextureOverlay->getV(v1));
t->vertexUV((float)(x1), (float)(y + dustOffset), (float)(z0),
crossTextureOverlay->getU(u1),
crossTextureOverlay->getV(v0));
t->vertexUV((float)(x0), (float)(y + dustOffset), (float)(z0),
crossTextureOverlay->getU(u0),
crossTextureOverlay->getV(v0));
t->vertexUV((float)(x0), (float)(y + dustOffset), (float)(z1),
crossTextureOverlay->getU(u0),
crossTextureOverlay->getV(v1));
} else if (pic == 1) {
t->vertexUV((float)(x1), (float)(y + dustOffset), (float)(z1),
lineTexture->getU1(), lineTexture->getV1());
t->vertexUV((float)(x1), (float)(y + dustOffset), (float)(z0),
lineTexture->getU1(), lineTexture->getV0());
t->vertexUV((float)(x0), (float)(y + dustOffset), (float)(z0),
lineTexture->getU0(), lineTexture->getV0());
t->vertexUV((float)(x0), (float)(y + dustOffset), (float)(z1),
lineTexture->getU0(), lineTexture->getV1());
t->color(br, br, br);
t->vertexUV((float)(x1), (float)(y + overlayOffset), (float)(z1),
lineTextureOverlay->getU1(), lineTextureOverlay->getV1());
t->vertexUV((float)(x1), (float)(y + overlayOffset), (float)(z0),
lineTextureOverlay->getU1(), lineTextureOverlay->getV0());
t->vertexUV((float)(x0), (float)(y + overlayOffset), (float)(z0),
lineTextureOverlay->getU0(), lineTextureOverlay->getV0());
t->vertexUV((float)(x0), (float)(y + overlayOffset), (float)(z1),
lineTextureOverlay->getU0(), lineTextureOverlay->getV1());
} else {
t->vertexUV((float)(x1), (float)(y + dustOffset), (float)(z1),
lineTexture->getU1(), lineTexture->getV1());
t->vertexUV((float)(x1), (float)(y + dustOffset), (float)(z0),
lineTexture->getU0(), lineTexture->getV1());
t->vertexUV((float)(x0), (float)(y + dustOffset), (float)(z0),
lineTexture->getU0(), lineTexture->getV0());
t->vertexUV((float)(x0), (float)(y + dustOffset), (float)(z1),
lineTexture->getU1(), lineTexture->getV0());
t->color(br, br, br);
t->vertexUV((float)(x1), (float)(y + overlayOffset), (float)(z1),
lineTextureOverlay->getU1(), lineTextureOverlay->getV1());
t->vertexUV((float)(x1), (float)(y + overlayOffset), (float)(z0),
lineTextureOverlay->getU0(), lineTextureOverlay->getV1());
t->vertexUV((float)(x0), (float)(y + overlayOffset), (float)(z0),
lineTextureOverlay->getU0(), lineTextureOverlay->getV0());
t->vertexUV((float)(x0), (float)(y + overlayOffset), (float)(z1),
lineTextureOverlay->getU1(), lineTextureOverlay->getV0());
}
if (!level->isSolidBlockingTile(x, y + 1, z)) {
const float yStretch = .35f / 16.0f;
if (level->isSolidBlockingTile(x - 1, y, z) &&
level->getTile(x - 1, y + 1, z) == Tile_SPU::redStoneDust_Id) {
t->color(br * red, br * green, br * blue);
t->vertexUV((float)(x + dustOffset), (float)(y + 1 + yStretch),
(float)(z + 1), lineTexture->getU1(),
lineTexture->getV0());
t->vertexUV((float)(x + dustOffset), (float)(y + 0), (float)(z + 1),
lineTexture->getU0(), lineTexture->getV0());
t->vertexUV((float)(x + dustOffset), (float)(y + 0), (float)(z + 0),
lineTexture->getU0(), lineTexture->getV1());
t->vertexUV((float)(x + dustOffset), (float)(y + 1 + yStretch),
(float)(z + 0), lineTexture->getU1(),
lineTexture->getV1());
t->color(br, br, br);
t->vertexUV((float)(x + overlayOffset), (float)(y + 1 + yStretch),
(float)(z + 1), lineTextureOverlay->getU1(),
lineTextureOverlay->getV0());
t->vertexUV((float)(x + overlayOffset), (float)(y + 0),
(float)(z + 1), lineTextureOverlay->getU0(),
lineTextureOverlay->getV0());
t->vertexUV((float)(x + overlayOffset), (float)(y + 0),
(float)(z + 0), lineTextureOverlay->getU0(),
lineTextureOverlay->getV1());
t->vertexUV((float)(x + overlayOffset), (float)(y + 1 + yStretch),
(float)(z + 0), lineTextureOverlay->getU1(),
lineTextureOverlay->getV1());
}
if (level->isSolidBlockingTile(x + 1, y, z) &&
level->getTile(x + 1, y + 1, z) == Tile_SPU::redStoneDust_Id) {
t->color(br * red, br * green, br * blue);
t->vertexUV((float)(x + 1 - dustOffset), (float)(y + 0),
(float)(z + 1), lineTexture->getU0(),
lineTexture->getV1());
t->vertexUV((float)(x + 1 - dustOffset), (float)(y + 1 + yStretch),
(float)(z + 1), lineTexture->getU1(),
lineTexture->getV1());
t->vertexUV((float)(x + 1 - dustOffset), (float)(y + 1 + yStretch),
(float)(z + 0), lineTexture->getU1(),
lineTexture->getV0());
t->vertexUV((float)(x + 1 - dustOffset), (float)(y + 0),
(float)(z + 0), lineTexture->getU0(),
lineTexture->getV0());
t->color(br, br, br);
t->vertexUV((float)(x + 1 - overlayOffset), (float)(y + 0),
(float)(z + 1), lineTextureOverlay->getU0(),
lineTextureOverlay->getV1());
t->vertexUV((float)(x + 1 - overlayOffset),
(float)(y + 1 + yStretch), (float)(z + 1),
lineTextureOverlay->getU1(),
lineTextureOverlay->getV1());
t->vertexUV((float)(x + 1 - overlayOffset),
(float)(y + 1 + yStretch), (float)(z + 0),
lineTextureOverlay->getU1(),
lineTextureOverlay->getV0());
t->vertexUV((float)(x + 1 - overlayOffset), (float)(y + 0),
(float)(z + 0), lineTextureOverlay->getU0(),
lineTextureOverlay->getV0());
}
if (level->isSolidBlockingTile(x, y, z - 1) &&
level->getTile(x, y + 1, z - 1) == Tile_SPU::redStoneDust_Id) {
t->color(br * red, br * green, br * blue);
t->vertexUV((float)(x + 1), (float)(y + 0), (float)(z + dustOffset),
lineTexture->getU0(), lineTexture->getV1());
t->vertexUV((float)(x + 1), (float)(y + 1 + yStretch),
(float)(z + dustOffset), lineTexture->getU1(),
lineTexture->getV1());
t->vertexUV((float)(x + 0), (float)(y + 1 + yStretch),
(float)(z + dustOffset), lineTexture->getU1(),
lineTexture->getV0());
t->vertexUV((float)(x + 0), (float)(y + 0), (float)(z + dustOffset),
lineTexture->getU0(), lineTexture->getV0());
t->color(br, br, br);
t->vertexUV((float)(x + 1), (float)(y + 0),
(float)(z + overlayOffset), lineTextureOverlay->getU0(),
lineTextureOverlay->getV1());
t->vertexUV((float)(x + 1), (float)(y + 1 + yStretch),
(float)(z + overlayOffset), lineTextureOverlay->getU1(),
lineTextureOverlay->getV1());
t->vertexUV((float)(x + 0), (float)(y + 1 + yStretch),
(float)(z + overlayOffset), lineTextureOverlay->getU1(),
lineTextureOverlay->getV0());
t->vertexUV((float)(x + 0), (float)(y + 0),
(float)(z + overlayOffset), lineTextureOverlay->getU0(),
lineTextureOverlay->getV0());
}
if (level->isSolidBlockingTile(x, y, z + 1) &&
level->getTile(x, y + 1, z + 1) == Tile_SPU::redStoneDust_Id) {
t->color(br * red, br * green, br * blue);
t->vertexUV((float)(x + 1), (float)(y + 1 + yStretch),
(float)(z + 1 - dustOffset), lineTexture->getU1(),
lineTexture->getV0());
t->vertexUV((float)(x + 1), (float)(y + 0),
(float)(z + 1 - dustOffset), lineTexture->getU0(),
lineTexture->getV0());
t->vertexUV((float)(x + 0), (float)(y + 0),
(float)(z + 1 - dustOffset), lineTexture->getU0(),
lineTexture->getV1());
t->vertexUV((float)(x + 0), (float)(y + 1 + yStretch),
(float)(z + 1 - dustOffset), lineTexture->getU1(),
lineTexture->getV1());
t->color(br, br, br);
t->vertexUV((float)(x + 1), (float)(y + 1 + yStretch),
(float)(z + 1 - overlayOffset),
lineTextureOverlay->getU1(),
lineTextureOverlay->getV0());
t->vertexUV(
(float)(x + 1), (float)(y + 0), (float)(z + 1 - overlayOffset),
lineTextureOverlay->getU0(), lineTextureOverlay->getV0());
t->vertexUV(
(float)(x + 0), (float)(y + 0), (float)(z + 1 - overlayOffset),
lineTextureOverlay->getU0(), lineTextureOverlay->getV1());
t->vertexUV((float)(x + 0), (float)(y + 1 + yStretch),
(float)(z + 1 - overlayOffset),
lineTextureOverlay->getU1(),
lineTextureOverlay->getV1());
}
}
#endif // #ifdef DISABLE_TESS_FUNCS
return true;
}
bool TileRenderer_SPU::tesselateRailInWorld(RailTile_SPU* tt, int x, int y,
int z) {
Tesselator_SPU* t = getTesselator();
int data = level->getData(x, y, z);
Icon_SPU* tex = getTexture(tt, 0, data);
if (hasFixedTexture()) tex = fixedTexture;
if (tt->isUsesDataBit()) {
data &= RailTile_SPU::RAIL_DIRECTION_MASK;
}
if (SharedConstants::TEXTURE_LIGHTING) {
t->tex2(tt->getLightColor(level, x, y, z));
t->color(1.0f, 1.0f, 1.0f);
} else {
float br = tt->getBrightness(level, x, y, z);
t->color(br, br, br);
}
float u0 = tex->getU0();
float v0 = tex->getV0();
float u1 = tex->getU1();
float v1 = tex->getV1();
float r = 1 / 16.0f;
float x0 = (float)(x + 1);
float x1 = (float)(x + 1);
float x2 = (float)(x + 0);
float x3 = (float)(x + 0);
float z0 = (float)(z + 0);
float z1 = (float)(z + 1);
float z2 = (float)(z + 1);
float z3 = (float)(z + 0);
float y0 = (float)(y + r);
float y1 = (float)(y + r);
float y2 = (float)(y + r);
float y3 = (float)(y + r);
if (data == 1 || data == 2 || data == 3 || data == 7) {
x0 = x3 = (float)(x + 1);
x1 = x2 = (float)(x + 0);
z0 = z1 = (float)(z + 1);
z2 = z3 = (float)(z + 0);
} else if (data == 8) {
x0 = x1 = (float)(x + 0);
x2 = x3 = (float)(x + 1);
z0 = z3 = (float)(z + 1);
z1 = z2 = (float)(z + 0);
} else if (data == 9) {
x0 = x3 = (float)(x + 0);
x1 = x2 = (float)(x + 1);
z0 = z1 = (float)(z + 0);
z2 = z3 = (float)(z + 1);
}
if (data == 2 || data == 4) {
y0 += 1;
y3 += 1;
} else if (data == 3 || data == 5) {
y1 += 1;
y2 += 1;
}
t->vertexUV((float)(x0), (float)(y0), (float)(z0), (float)(u1),
(float)(v0));
t->vertexUV((float)(x1), (float)(y1), (float)(z1), (float)(u1),
(float)(v1));
t->vertexUV((float)(x2), (float)(y2), (float)(z2), (float)(u0),
(float)(v1));
t->vertexUV((float)(x3), (float)(y3), (float)(z3), (float)(u0),
(float)(v0));
t->vertexUV((float)(x3), (float)(y3), (float)(z3), (float)(u0),
(float)(v0));
t->vertexUV((float)(x2), (float)(y2), (float)(z2), (float)(u0),
(float)(v1));
t->vertexUV((float)(x1), (float)(y1), (float)(z1), (float)(u1),
(float)(v1));
t->vertexUV((float)(x0), (float)(y0), (float)(z0), (float)(u1),
(float)(v0));
return true;
}
bool TileRenderer_SPU::tesselateLadderInWorld(Tile_SPU* tt, int x, int y,
int z) {
Tesselator_SPU* t = getTesselator();
Icon_SPU* tex = getTexture(tt, 0);
if (hasFixedTexture()) tex = fixedTexture;
if (SharedConstants::TEXTURE_LIGHTING) {
t->tex2(tt->getLightColor(level, x, y, z));
float br = 1;
t->color(br, br, br);
} else {
float br = tt->getBrightness(level, x, y, z);
t->color(br, br, br);
}
float u0 = tex->getU0();
float v0 = tex->getV0();
float u1 = tex->getU1();
float v1 = tex->getV1();
int face = level->getData(x, y, z);
float o = 0 / 16.0f;
float r = 0.05f;
if (face == 5) {
t->vertexUV((float)(x + r), (float)(y + 1 + o), (float)(z + 1 + o),
(float)(u0), (float)(v0));
t->vertexUV((float)(x + r), (float)(y + 0 - o), (float)(z + 1 + o),
(float)(u0), (float)(v1));
t->vertexUV((float)(x + r), (float)(y + 0 - o), (float)(z + 0 - o),
(float)(u1), (float)(v1));
t->vertexUV((float)(x + r), (float)(y + 1 + o), (float)(z + 0 - o),
(float)(u1), (float)(v0));
}
if (face == 4) {
t->vertexUV((float)(x + 1 - r), (float)(y + 0 - o), (float)(z + 1 + o),
(float)(u1), (float)(v1));
t->vertexUV((float)(x + 1 - r), (float)(y + 1 + o), (float)(z + 1 + o),
(float)(u1), (float)(v0));
t->vertexUV((float)(x + 1 - r), (float)(y + 1 + o), (float)(z + 0 - o),
(float)(u0), (float)(v0));
t->vertexUV((float)(x + 1 - r), (float)(y + 0 - o), (float)(z + 0 - o),
(float)(u0), (float)(v1));
}
if (face == 3) {
t->vertexUV((float)(x + 1 + o), (float)(y + 0 - o), (float)(z + r),
(float)(u1), (float)(v1));
t->vertexUV((float)(x + 1 + o), (float)(y + 1 + o), (float)(z + r),
(float)(u1), (float)(v0));
t->vertexUV((float)(x + 0 - o), (float)(y + 1 + o), (float)(z + r),
(float)(u0), (float)(v0));
t->vertexUV((float)(x + 0 - o), (float)(y + 0 - o), (float)(z + r),
(float)(u0), (float)(v1));
}
if (face == 2) {
t->vertexUV((float)(x + 1 + o), (float)(y + 1 + o), (float)(z + 1 - r),
(float)(u0), (float)(v0));
t->vertexUV((float)(x + 1 + o), (float)(y + 0 - o), (float)(z + 1 - r),
(float)(u0), (float)(v1));
t->vertexUV((float)(x + 0 - o), (float)(y + 0 - o), (float)(z + 1 - r),
(float)(u1), (float)(v1));
t->vertexUV((float)(x + 0 - o), (float)(y + 1 + o), (float)(z + 1 - r),
(float)(u1), (float)(v0));
}
return true;
}
bool TileRenderer_SPU::tesselateVineInWorld(Tile_SPU* tt, int x, int y, int z) {
Tesselator_SPU* t = getTesselator();
Icon_SPU* tex = getTexture(tt, 0);
if (hasFixedTexture()) tex = fixedTexture;
float br = 1;
if (SharedConstants::TEXTURE_LIGHTING) {
t->tex2(tt->getLightColor(level, x, y, z));
} else {
br = tt->getBrightness(level, x, y, z);
}
{
int col = tt->getColor(level, x, y, z);
float r = ((col >> 16) & 0xff) / 255.0f;
float g = ((col >> 8) & 0xff) / 255.0f;
float b = ((col) & 0xff) / 255.0f;
t->color(br * r, br * g, br * b);
}
float u0 = tex->getU0();
float v0 = tex->getV0();
float u1 = tex->getU1();
float v1 = tex->getV1();
float r = 0.05f;
int facings = level->getData(x, y, z);
if ((facings & VineTile_SPU::VINE_WEST) != 0) {
t->vertexUV(x + r, y + 1, z + 1, u0, v0);
t->vertexUV(x + r, y + 0, z + 1, u0, v1);
t->vertexUV(x + r, y + 0, z + 0, u1, v1);
t->vertexUV(x + r, y + 1, z + 0, u1, v0);
t->vertexUV(x + r, y + 1, z + 0, u1, v0);
t->vertexUV(x + r, y + 0, z + 0, u1, v1);
t->vertexUV(x + r, y + 0, z + 1, u0, v1);
t->vertexUV(x + r, y + 1, z + 1, u0, v0);
}
if ((facings & VineTile_SPU::VINE_EAST) != 0) {
t->vertexUV(x + 1 - r, y + 0, z + 1, u1, v1);
t->vertexUV(x + 1 - r, y + 1, z + 1, u1, v0);
t->vertexUV(x + 1 - r, y + 1, z + 0, u0, v0);
t->vertexUV(x + 1 - r, y + 0, z + 0, u0, v1);
t->vertexUV(x + 1 - r, y + 0, z + 0, u0, v1);
t->vertexUV(x + 1 - r, y + 1, z + 0, u0, v0);
t->vertexUV(x + 1 - r, y + 1, z + 1, u1, v0);
t->vertexUV(x + 1 - r, y + 0, z + 1, u1, v1);
}
if ((facings & VineTile_SPU::VINE_NORTH) != 0) {
t->vertexUV(x + 1, y + 0, z + r, u1, v1);
t->vertexUV(x + 1, y + 1, z + r, u1, v0);
t->vertexUV(x + 0, y + 1, z + r, u0, v0);
t->vertexUV(x + 0, y + 0, z + r, u0, v1);
t->vertexUV(x + 0, y + 0, z + r, u0, v1);
t->vertexUV(x + 0, y + 1, z + r, u0, v0);
t->vertexUV(x + 1, y + 1, z + r, u1, v0);
t->vertexUV(x + 1, y + 0, z + r, u1, v1);
}
if ((facings & VineTile_SPU::VINE_SOUTH) != 0) {
t->vertexUV(x + 1, y + 1, z + 1 - r, u0, v0);
t->vertexUV(x + 1, y + 0, z + 1 - r, u0, v1);
t->vertexUV(x + 0, y + 0, z + 1 - r, u1, v1);
t->vertexUV(x + 0, y + 1, z + 1 - r, u1, v0);
t->vertexUV(x + 0, y + 1, z + 1 - r, u1, v0);
t->vertexUV(x + 0, y + 0, z + 1 - r, u1, v1);
t->vertexUV(x + 1, y + 0, z + 1 - r, u0, v1);
t->vertexUV(x + 1, y + 1, z + 1 - r, u0, v0);
}
if (level->isSolidBlockingTile(x, y + 1, z)) {
t->vertexUV(x + 1, y + 1 - r, z + 0, u0, v0);
t->vertexUV(x + 1, y + 1 - r, z + 1, u0, v1);
t->vertexUV(x + 0, y + 1 - r, z + 1, u1, v1);
t->vertexUV(x + 0, y + 1 - r, z + 0, u1, v0);
}
return true;
}
bool TileRenderer_SPU::tesselateThinFenceInWorld(ThinFenceTile* tt, int x,
int y, int z) {
#ifdef DISABLE_TESS_FUNCS
int depth = level->getDepth();
Tesselator_SPU* t = getTesselator();
float br;
if (SharedConstants::TEXTURE_LIGHTING) {
t->tex2(tt->getLightColor(level, x, y, z));
br = 1;
} else {
br = tt->getBrightness(level, x, y, z);
}
int col = tt->getColor(level, x, y, z);
float r = ((col >> 16) & 0xff) / 255.0f;
float g = ((col >> 8) & 0xff) / 255.0f;
float b = ((col) & 0xff) / 255.0f;
if (GameRenderer::anaglyph3d) {
float cr = (r * 30 + g * 59 + b * 11) / 100;
float cg = (r * 30 + g * 70) / (100);
float cb = (r * 30 + b * 70) / (100);
r = cr;
g = cg;
b = cb;
}
t->color(br * r, br * g, br * b);
Icon_SPU* tex;
Icon_SPU* edgeTex;
if (hasFixedTexture()) {
tex = fixedTexture;
edgeTex = fixedTexture;
} else {
int data = level->getData(x, y, z);
tex = getTexture(tt, 0, data);
edgeTex = tt->getEdgeTexture();
}
int xt = tex->getX();
int yt = tex->getY();
float u0 = tex->getU0();
float u1 = tex->getU(8);
float u2 = tex->getU1();
float v0 = tex->getV0();
float v2 = tex->getV1();
int xet = edgeTex->getX();
int yet = edgeTex->getY();
float iu0 = edgeTex->getU(7);
float iu1 = edgeTex->getU(9);
float iv0 = edgeTex->getV0();
float iv1 = edgeTex->getV(8);
float iv2 = edgeTex->getV1();
float x0 = (float)x;
float x1 = x + 0.5f;
float x2 = x + 1.0f;
float z0 = (float)z;
float z1 = z + 0.5f;
float z2 = z + 1.0f;
float ix0 = x + 0.5f - 1.0f / 16.0f;
float ix1 = x + 0.5f + 1.0f / 16.0f;
float iz0 = z + 0.5f - 1.0f / 16.0f;
float iz1 = z + 0.5f + 1.0f / 16.0f;
bool n = tt->attachsTo(level->getTile(x, y, z - 1));
bool s = tt->attachsTo(level->getTile(x, y, z + 1));
bool w = tt->attachsTo(level->getTile(x - 1, y, z));
bool e = tt->attachsTo(level->getTile(x + 1, y, z));
bool up = tt->shouldRenderFace(level, x, y + 1, z, Facing::UP);
bool down = tt->shouldRenderFace(level, x, y - 1, z, Facing::DOWN);
const float noZFightingOffset = 0.01f;
const float noZFightingOffsetB = 0.005;
if ((w && e) || (!w && !e && !n && !s)) {
t->vertexUV(x0, y + 1, z1, u0, v0);
t->vertexUV(x0, y + 0, z1, u0, v2);
t->vertexUV(x2, y + 0, z1, u2, v2);
t->vertexUV(x2, y + 1, z1, u2, v0);
t->vertexUV(x2, y + 1, z1, u0, v0);
t->vertexUV(x2, y + 0, z1, u0, v2);
t->vertexUV(x0, y + 0, z1, u2, v2);
t->vertexUV(x0, y + 1, z1, u2, v0);
if (up) {
// small edge texture
t->vertexUV(x0, y + 1 + noZFightingOffset, iz1, iu1, iv2);
t->vertexUV(x2, y + 1 + noZFightingOffset, iz1, iu1, iv0);
t->vertexUV(x2, y + 1 + noZFightingOffset, iz0, iu0, iv0);
t->vertexUV(x0, y + 1 + noZFightingOffset, iz0, iu0, iv2);
t->vertexUV(x2, y + 1 + noZFightingOffset, iz1, iu1, iv2);
t->vertexUV(x0, y + 1 + noZFightingOffset, iz1, iu1, iv0);
t->vertexUV(x0, y + 1 + noZFightingOffset, iz0, iu0, iv0);
t->vertexUV(x2, y + 1 + noZFightingOffset, iz0, iu0, iv2);
} else {
if (y < (depth - 1) && level->isEmptyTile(x - 1, y + 1, z)) {
t->vertexUV(x0, y + 1 + noZFightingOffset, iz1, iu1, iv1);
t->vertexUV(x1, y + 1 + noZFightingOffset, iz1, iu1, iv2);
t->vertexUV(x1, y + 1 + noZFightingOffset, iz0, iu0, iv2);
t->vertexUV(x0, y + 1 + noZFightingOffset, iz0, iu0, iv1);
t->vertexUV(x1, y + 1 + noZFightingOffset, iz1, iu1, iv1);
t->vertexUV(x0, y + 1 + noZFightingOffset, iz1, iu1, iv2);
t->vertexUV(x0, y + 1 + noZFightingOffset, iz0, iu0, iv2);
t->vertexUV(x1, y + 1 + noZFightingOffset, iz0, iu0, iv1);
}
if (y < (depth - 1) && level->isEmptyTile(x + 1, y + 1, z)) {
t->vertexUV(x1, y + 1 + noZFightingOffset, iz1, iu1, iv0);
t->vertexUV(x2, y + 1 + noZFightingOffset, iz1, iu1, iv1);
t->vertexUV(x2, y + 1 + noZFightingOffset, iz0, iu0, iv1);
t->vertexUV(x1, y + 1 + noZFightingOffset, iz0, iu0, iv0);
t->vertexUV(x2, y + 1 + noZFightingOffset, iz1, iu1, iv0);
t->vertexUV(x1, y + 1 + noZFightingOffset, iz1, iu1, iv1);
t->vertexUV(x1, y + 1 + noZFightingOffset, iz0, iu0, iv1);
t->vertexUV(x2, y + 1 + noZFightingOffset, iz0, iu0, iv0);
}
}
if (down) {
// small edge texture
t->vertexUV(x0, y - noZFightingOffset, iz1, iu1, iv2);
t->vertexUV(x2, y - noZFightingOffset, iz1, iu1, iv0);
t->vertexUV(x2, y - noZFightingOffset, iz0, iu0, iv0);
t->vertexUV(x0, y - noZFightingOffset, iz0, iu0, iv2);
t->vertexUV(x2, y - noZFightingOffset, iz1, iu1, iv2);
t->vertexUV(x0, y - noZFightingOffset, iz1, iu1, iv0);
t->vertexUV(x0, y - noZFightingOffset, iz0, iu0, iv0);
t->vertexUV(x2, y - noZFightingOffset, iz0, iu0, iv2);
} else {
if (y > 1 && level->isEmptyTile(x - 1, y - 1, z)) {
t->vertexUV(x0, y - noZFightingOffset, iz1, iu1, iv1);
t->vertexUV(x1, y - noZFightingOffset, iz1, iu1, iv2);
t->vertexUV(x1, y - noZFightingOffset, iz0, iu0, iv2);
t->vertexUV(x0, y - noZFightingOffset, iz0, iu0, iv1);
t->vertexUV(x1, y - noZFightingOffset, iz1, iu1, iv1);
t->vertexUV(x0, y - noZFightingOffset, iz1, iu1, iv2);
t->vertexUV(x0, y - noZFightingOffset, iz0, iu0, iv2);
t->vertexUV(x1, y - noZFightingOffset, iz0, iu0, iv1);
}
if (y > 1 && level->isEmptyTile(x + 1, y - 1, z)) {
t->vertexUV(x1, y - noZFightingOffset, iz1, iu1, iv0);
t->vertexUV(x2, y - noZFightingOffset, iz1, iu1, iv1);
t->vertexUV(x2, y - noZFightingOffset, iz0, iu0, iv1);
t->vertexUV(x1, y - noZFightingOffset, iz0, iu0, iv0);
t->vertexUV(x2, y - noZFightingOffset, iz1, iu1, iv0);
t->vertexUV(x1, y - noZFightingOffset, iz1, iu1, iv1);
t->vertexUV(x1, y - noZFightingOffset, iz0, iu0, iv1);
t->vertexUV(x2, y - noZFightingOffset, iz0, iu0, iv0);
}
}
} else if (w && !e) {
// half-step towards west
t->vertexUV(x0, y + 1, z1, u0, v0);
t->vertexUV(x0, y + 0, z1, u0, v2);
t->vertexUV(x1, y + 0, z1, u1, v2);
t->vertexUV(x1, y + 1, z1, u1, v0);
t->vertexUV(x1, y + 1, z1, u0, v0);
t->vertexUV(x1, y + 0, z1, u0, v2);
t->vertexUV(x0, y + 0, z1, u1, v2);
t->vertexUV(x0, y + 1, z1, u1, v0);
// small edge texture
if (!s && !n) {
t->vertexUV(x1, y + 1, iz1, iu0, iv0);
t->vertexUV(x1, y + 0, iz1, iu0, iv2);
t->vertexUV(x1, y + 0, iz0, iu1, iv2);
t->vertexUV(x1, y + 1, iz0, iu1, iv0);
t->vertexUV(x1, y + 1, iz0, iu0, iv0);
t->vertexUV(x1, y + 0, iz0, iu0, iv2);
t->vertexUV(x1, y + 0, iz1, iu1, iv2);
t->vertexUV(x1, y + 1, iz1, iu1, iv0);
}
if (up || (y < (depth - 1) && level->isEmptyTile(x - 1, y + 1, z))) {
// small edge texture
t->vertexUV(x0, y + 1 + noZFightingOffset, iz1, iu1, iv1);
t->vertexUV(x1, y + 1 + noZFightingOffset, iz1, iu1, iv2);
t->vertexUV(x1, y + 1 + noZFightingOffset, iz0, iu0, iv2);
t->vertexUV(x0, y + 1 + noZFightingOffset, iz0, iu0, iv1);
t->vertexUV(x1, y + 1 + noZFightingOffset, iz1, iu1, iv1);
t->vertexUV(x0, y + 1 + noZFightingOffset, iz1, iu1, iv2);
t->vertexUV(x0, y + 1 + noZFightingOffset, iz0, iu0, iv2);
t->vertexUV(x1, y + 1 + noZFightingOffset, iz0, iu0, iv1);
}
if (down || (y > 1 && level->isEmptyTile(x - 1, y - 1, z))) {
// small edge texture
t->vertexUV(x0, y - noZFightingOffset, iz1, iu1, iv1);
t->vertexUV(x1, y - noZFightingOffset, iz1, iu1, iv2);
t->vertexUV(x1, y - noZFightingOffset, iz0, iu0, iv2);
t->vertexUV(x0, y - noZFightingOffset, iz0, iu0, iv1);
t->vertexUV(x1, y - noZFightingOffset, iz1, iu1, iv1);
t->vertexUV(x0, y - noZFightingOffset, iz1, iu1, iv2);
t->vertexUV(x0, y - noZFightingOffset, iz0, iu0, iv2);
t->vertexUV(x1, y - noZFightingOffset, iz0, iu0, iv1);
}
} else if (!w && e) {
// half-step towards east
t->vertexUV(x1, y + 1, z1, u1, v0);
t->vertexUV(x1, y + 0, z1, u1, v2);
t->vertexUV(x2, y + 0, z1, u2, v2);
t->vertexUV(x2, y + 1, z1, u2, v0);
t->vertexUV(x2, y + 1, z1, u1, v0);
t->vertexUV(x2, y + 0, z1, u1, v2);
t->vertexUV(x1, y + 0, z1, u2, v2);
t->vertexUV(x1, y + 1, z1, u2, v0);
// small edge texture
if (!s && !n) {
t->vertexUV(x1, y + 1, iz0, iu0, iv0);
t->vertexUV(x1, y + 0, iz0, iu0, iv2);
t->vertexUV(x1, y + 0, iz1, iu1, iv2);
t->vertexUV(x1, y + 1, iz1, iu1, iv0);
t->vertexUV(x1, y + 1, iz1, iu0, iv0);
t->vertexUV(x1, y + 0, iz1, iu0, iv2);
t->vertexUV(x1, y + 0, iz0, iu1, iv2);
t->vertexUV(x1, y + 1, iz0, iu1, iv0);
}
if (up || (y < (depth - 1) && level->isEmptyTile(x + 1, y + 1, z))) {
// small edge texture
t->vertexUV(x1, y + 1 + noZFightingOffset, iz1, iu1, iv0);
t->vertexUV(x2, y + 1 + noZFightingOffset, iz1, iu1, iv1);
t->vertexUV(x2, y + 1 + noZFightingOffset, iz0, iu0, iv1);
t->vertexUV(x1, y + 1 + noZFightingOffset, iz0, iu0, iv0);
t->vertexUV(x2, y + 1 + noZFightingOffset, iz1, iu1, iv0);
t->vertexUV(x1, y + 1 + noZFightingOffset, iz1, iu1, iv1);
t->vertexUV(x1, y + 1 + noZFightingOffset, iz0, iu0, iv1);
t->vertexUV(x2, y + 1 + noZFightingOffset, iz0, iu0, iv0);
}
if (down || (y > 1 && level->isEmptyTile(x + 1, y - 1, z))) {
// small edge texture
t->vertexUV(x1, y - noZFightingOffset, iz1, iu1, iv0);
t->vertexUV(x2, y - noZFightingOffset, iz1, iu1, iv1);
t->vertexUV(x2, y - noZFightingOffset, iz0, iu0, iv1);
t->vertexUV(x1, y - noZFightingOffset, iz0, iu0, iv0);
t->vertexUV(x2, y - noZFightingOffset, iz1, iu1, iv0);
t->vertexUV(x1, y - noZFightingOffset, iz1, iu1, iv1);
t->vertexUV(x1, y - noZFightingOffset, iz0, iu0, iv1);
t->vertexUV(x2, y - noZFightingOffset, iz0, iu0, iv0);
}
}
if ((n && s) || (!w && !e && !n && !s)) {
// straight north-south
t->vertexUV(x1, y + 1, z2, u0, v0);
t->vertexUV(x1, y + 0, z2, u0, v2);
t->vertexUV(x1, y + 0, z0, u2, v2);
t->vertexUV(x1, y + 1, z0, u2, v0);
t->vertexUV(x1, y + 1, z0, u0, v0);
t->vertexUV(x1, y + 0, z0, u0, v2);
t->vertexUV(x1, y + 0, z2, u2, v2);
t->vertexUV(x1, y + 1, z2, u2, v0);
if (up) {
// small edge texture
t->vertexUV(ix1, y + 1 + noZFightingOffset, z2, iu1, iv2);
t->vertexUV(ix1, y + 1 + noZFightingOffset, z0, iu1, iv0);
t->vertexUV(ix0, y + 1 + noZFightingOffset, z0, iu0, iv0);
t->vertexUV(ix0, y + 1 + noZFightingOffset, z2, iu0, iv2);
t->vertexUV(ix1, y + 1 + noZFightingOffset, z0, iu1, iv2);
t->vertexUV(ix1, y + 1 + noZFightingOffset, z2, iu1, iv0);
t->vertexUV(ix0, y + 1 + noZFightingOffset, z2, iu0, iv0);
t->vertexUV(ix0, y + 1 + noZFightingOffset, z0, iu0, iv2);
} else {
if (y < (depth - 1) && level->isEmptyTile(x, y + 1, z - 1)) {
t->vertexUV(ix0, y + 1 + noZFightingOffset, z0, iu1, iv0);
t->vertexUV(ix0, y + 1 + noZFightingOffset, z1, iu1, iv1);
t->vertexUV(ix1, y + 1 + noZFightingOffset, z1, iu0, iv1);
t->vertexUV(ix1, y + 1 + noZFightingOffset, z0, iu0, iv0);
t->vertexUV(ix0, y + 1 + noZFightingOffset, z1, iu1, iv0);
t->vertexUV(ix0, y + 1 + noZFightingOffset, z0, iu1, iv1);
t->vertexUV(ix1, y + 1 + noZFightingOffset, z0, iu0, iv1);
t->vertexUV(ix1, y + 1 + noZFightingOffset, z1, iu0, iv0);
}
if (y < (depth - 1) && level->isEmptyTile(x, y + 1, z + 1)) {
t->vertexUV(ix0, y + 1 + noZFightingOffset, z1, iu0, iv1);
t->vertexUV(ix0, y + 1 + noZFightingOffset, z2, iu0, iv2);
t->vertexUV(ix1, y + 1 + noZFightingOffset, z2, iu1, iv2);
t->vertexUV(ix1, y + 1 + noZFightingOffset, z1, iu1, iv1);
t->vertexUV(ix0, y + 1 + noZFightingOffset, z2, iu0, iv1);
t->vertexUV(ix0, y + 1 + noZFightingOffset, z1, iu0, iv2);
t->vertexUV(ix1, y + 1 + noZFightingOffset, z1, iu1, iv2);
t->vertexUV(ix1, y + 1 + noZFightingOffset, z2, iu1, iv1);
}
}
if (down) {
// small edge texture
t->vertexUV(ix1, y - noZFightingOffset, z2, iu1, iv2);
t->vertexUV(ix1, y - noZFightingOffset, z0, iu1, iv0);
t->vertexUV(ix0, y - noZFightingOffset, z0, iu0, iv0);
t->vertexUV(ix0, y - noZFightingOffset, z2, iu0, iv2);
t->vertexUV(ix1, y - noZFightingOffset, z0, iu1, iv2);
t->vertexUV(ix1, y - noZFightingOffset, z2, iu1, iv0);
t->vertexUV(ix0, y - noZFightingOffset, z2, iu0, iv0);
t->vertexUV(ix0, y - noZFightingOffset, z0, iu0, iv2);
} else {
if (y > 1 && level->isEmptyTile(x, y - 1, z - 1)) {
// north half-step
t->vertexUV(ix0, y - noZFightingOffset, z0, iu1, iv0);
t->vertexUV(ix0, y - noZFightingOffset, z1, iu1, iv1);
t->vertexUV(ix1, y - noZFightingOffset, z1, iu0, iv1);
t->vertexUV(ix1, y - noZFightingOffset, z0, iu0, iv0);
t->vertexUV(ix0, y - noZFightingOffset, z1, iu1, iv0);
t->vertexUV(ix0, y - noZFightingOffset, z0, iu1, iv1);
t->vertexUV(ix1, y - noZFightingOffset, z0, iu0, iv1);
t->vertexUV(ix1, y - noZFightingOffset, z1, iu0, iv0);
}
if (y > 1 && level->isEmptyTile(x, y - 1, z + 1)) {
// south half-step
t->vertexUV(ix0, y - noZFightingOffset, z1, iu0, iv1);
t->vertexUV(ix0, y - noZFightingOffset, z2, iu0, iv2);
t->vertexUV(ix1, y - noZFightingOffset, z2, iu1, iv2);
t->vertexUV(ix1, y - noZFightingOffset, z1, iu1, iv1);
t->vertexUV(ix0, y - noZFightingOffset, z2, iu0, iv1);
t->vertexUV(ix0, y - noZFightingOffset, z1, iu0, iv2);
t->vertexUV(ix1, y - noZFightingOffset, z1, iu1, iv2);
t->vertexUV(ix1, y - noZFightingOffset, z2, iu1, iv1);
}
}
} else if (n && !s) {
// half-step towards north
t->vertexUV(x1, y + 1, z0, u0, v0);
t->vertexUV(x1, y + 0, z0, u0, v2);
t->vertexUV(x1, y + 0, z1, u1, v2);
t->vertexUV(x1, y + 1, z1, u1, v0);
t->vertexUV(x1, y + 1, z1, u0, v0);
t->vertexUV(x1, y + 0, z1, u0, v2);
t->vertexUV(x1, y + 0, z0, u1, v2);
t->vertexUV(x1, y + 1, z0, u1, v0);
// small edge texture
if (!e && !w) {
t->vertexUV(ix0, y + 1, z1, iu0, iv0);
t->vertexUV(ix0, y + 0, z1, iu0, iv2);
t->vertexUV(ix1, y + 0, z1, iu1, iv2);
t->vertexUV(ix1, y + 1, z1, iu1, iv0);
t->vertexUV(ix1, y + 1, z1, iu0, iv0);
t->vertexUV(ix1, y + 0, z1, iu0, iv2);
t->vertexUV(ix0, y + 0, z1, iu1, iv2);
t->vertexUV(ix0, y + 1, z1, iu1, iv0);
}
if (up || (y < (depth - 1) && level->isEmptyTile(x, y + 1, z - 1))) {
// small edge texture
t->vertexUV(ix0, y + 1 + noZFightingOffset, z0, iu1, iv0);
t->vertexUV(ix0, y + 1 + noZFightingOffset, z1, iu1, iv1);
t->vertexUV(ix1, y + 1 + noZFightingOffset, z1, iu0, iv1);
t->vertexUV(ix1, y + 1 + noZFightingOffset, z0, iu0, iv0);
t->vertexUV(ix0, y + 1 + noZFightingOffset, z1, iu1, iv0);
t->vertexUV(ix0, y + 1 + noZFightingOffset, z0, iu1, iv1);
t->vertexUV(ix1, y + 1 + noZFightingOffset, z0, iu0, iv1);
t->vertexUV(ix1, y + 1 + noZFightingOffset, z1, iu0, iv0);
}
if (down || (y > 1 && level->isEmptyTile(x, y - 1, z - 1))) {
// small edge texture
t->vertexUV(ix0, y - noZFightingOffset, z0, iu1, iv0);
t->vertexUV(ix0, y - noZFightingOffset, z1, iu1, iv1);
t->vertexUV(ix1, y - noZFightingOffset, z1, iu0, iv1);
t->vertexUV(ix1, y - noZFightingOffset, z0, iu0, iv0);
t->vertexUV(ix0, y - noZFightingOffset, z1, iu1, iv0);
t->vertexUV(ix0, y - noZFightingOffset, z0, iu1, iv1);
t->vertexUV(ix1, y - noZFightingOffset, z0, iu0, iv1);
t->vertexUV(ix1, y - noZFightingOffset, z1, iu0, iv0);
}
} else if (!n && s) {
// half-step towards south
t->vertexUV(x1, y + 1, z1, u1, v0);
t->vertexUV(x1, y + 0, z1, u1, v2);
t->vertexUV(x1, y + 0, z2, u2, v2);
t->vertexUV(x1, y + 1, z2, u2, v0);
t->vertexUV(x1, y + 1, z2, u1, v0);
t->vertexUV(x1, y + 0, z2, u1, v2);
t->vertexUV(x1, y + 0, z1, u2, v2);
t->vertexUV(x1, y + 1, z1, u2, v0);
// small edge texture
if (!e && !w) {
t->vertexUV(ix1, y + 1, z1, iu0, iv0);
t->vertexUV(ix1, y + 0, z1, iu0, iv2);
t->vertexUV(ix0, y + 0, z1, iu1, iv2);
t->vertexUV(ix0, y + 1, z1, iu1, iv0);
t->vertexUV(ix0, y + 1, z1, iu0, iv0);
t->vertexUV(ix0, y + 0, z1, iu0, iv2);
t->vertexUV(ix1, y + 0, z1, iu1, iv2);
t->vertexUV(ix1, y + 1, z1, iu1, iv0);
}
if (up || (y < (depth - 1) && level->isEmptyTile(x, y + 1, z + 1))) {
// small edge texture
t->vertexUV(ix0, y + 1 + noZFightingOffset, z1, iu0, iv1);
t->vertexUV(ix0, y + 1 + noZFightingOffset, z2, iu0, iv2);
t->vertexUV(ix1, y + 1 + noZFightingOffset, z2, iu1, iv2);
t->vertexUV(ix1, y + 1 + noZFightingOffset, z1, iu1, iv1);
t->vertexUV(ix0, y + 1 + noZFightingOffset, z2, iu0, iv1);
t->vertexUV(ix0, y + 1 + noZFightingOffset, z1, iu0, iv2);
t->vertexUV(ix1, y + 1 + noZFightingOffset, z1, iu1, iv2);
t->vertexUV(ix1, y + 1 + noZFightingOffset, z2, iu1, iv1);
}
if (down || (y > 1 && level->isEmptyTile(x, y - 1, z + 1))) {
// small edge texture
t->vertexUV(ix0, y - noZFightingOffset, z1, iu0, iv1);
t->vertexUV(ix0, y - noZFightingOffset, z2, iu0, iv2);
t->vertexUV(ix1, y - noZFightingOffset, z2, iu1, iv2);
t->vertexUV(ix1, y - noZFightingOffset, z1, iu1, iv1);
t->vertexUV(ix0, y - noZFightingOffset, z2, iu0, iv1);
t->vertexUV(ix0, y - noZFightingOffset, z1, iu0, iv2);
t->vertexUV(ix1, y - noZFightingOffset, z1, iu1, iv2);
t->vertexUV(ix1, y - noZFightingOffset, z2, iu1, iv1);
}
}
#endif // DISABLE_TESS_FUNCS
return true;
}
bool TileRenderer_SPU::tesselateCrossInWorld(Tile_SPU* tt, int x, int y,
int z) {
Tesselator_SPU* t = getTesselator();
float br;
if (SharedConstants::TEXTURE_LIGHTING) {
t->tex2(tt->getLightColor(level, x, y, z));
br = 1;
} else {
br = tt->getBrightness(level, x, y, z);
}
int col = tt->getColor(level, x, y, z);
float r = ((col >> 16) & 0xff) / 255.0f;
float g = ((col >> 8) & 0xff) / 255.0f;
float b = ((col) & 0xff) / 255.0f;
if (isAnaglyph3d()) {
float cr = (r * 30 + g * 59 + b * 11) / 100;
float cg = (r * 30 + g * 70) / (100);
float cb = (r * 30 + b * 70) / (100);
r = cr;
g = cg;
b = cb;
}
t->color(br * r, br * g, br * b);
float xt = (float)x;
float yt = (float)y;
float zt = (float)z;
if (tt->id == Tile_SPU::tallgrass_Id) {
int64_t seed = (x * 3129871) ^ (z * 116129781l) ^ (y);
seed = seed * seed * 42317861 + seed * 11;
xt += ((((seed >> 16) & 0xf) / 15.0f) - 0.5f) * 0.5f;
yt += ((((seed >> 20) & 0xf) / 15.0f) - 1.0f) * 0.2f;
zt += ((((seed >> 24) & 0xf) / 15.0f) - 0.5f) * 0.5f;
}
tesselateCrossTexture(tt, level->getData(x, y, z), xt, yt, zt, 1);
return true;
}
bool TileRenderer_SPU::tesselateStemInWorld(Tile_SPU* _tt, int x, int y,
int z) {
StemTile_SPU* tt = (StemTile_SPU*)_tt;
Tesselator_SPU* t = getTesselator();
float br;
if (SharedConstants::TEXTURE_LIGHTING) {
t->tex2(tt->getLightColor(level, x, y, z));
br = 1;
} else {
br = tt->getBrightness(level, x, y, z);
}
int col = tt->getColor(level, x, y, z);
float r = ((col >> 16) & 0xff) / 255.0f;
float g = ((col >> 8) & 0xff) / 255.0f;
float b = ((col) & 0xff) / 255.0f;
if (isAnaglyph3d()) {
float cr = (r * 30.0f + g * 59.0f + b * 11.0f) / 100.0f;
float cg = (r * 30.0f + g * 70.0f) / (100.0f);
float cb = (r * 30.0f + b * 70.0f) / (100.0f);
r = cr;
g = cg;
b = cb;
}
t->color(br * r, br * g, br * b);
tt->updateShape(level, x, y, z);
int dir = tt->getConnectDir(level, x, y, z);
if (dir < 0) {
tesselateStemTexture(tt, level->getData(x, y, z), tileShapeY1, x,
y - 1 / 16.0f, z);
} else {
tesselateStemTexture(tt, level->getData(x, y, z), 0.5f, x,
y - 1 / 16.0f, z);
tesselateStemDirTexture(tt, level->getData(x, y, z), dir, tileShapeY1,
x, y - 1 / 16.0f, z);
}
return true;
}
bool TileRenderer_SPU::tesselateRowInWorld(Tile_SPU* tt, int x, int y, int z) {
Tesselator_SPU* t = getTesselator();
if (SharedConstants::TEXTURE_LIGHTING) {
t->tex2(tt->getLightColor(level, x, y, z));
t->color(1.0f, 1.0f, 1.0f);
} else {
float br = tt->getBrightness(level, x, y, z);
t->color(br, br, br);
}
tesselateRowTexture(tt, level->getData(x, y, z), x, y - 1.0f / 16.0f, z);
return true;
}
void TileRenderer_SPU::tesselateTorch(Tile_SPU* tt, float x, float y, float z,
float xxa, float zza, int data) {
Tesselator_SPU* t = getTesselator();
Icon_SPU* tex = getTexture(tt, Facing::DOWN, data);
if (hasFixedTexture()) tex = fixedTexture;
float u0 = tex->getU0();
float v0 = tex->getV0();
float u1 = tex->getU1();
float v1 = tex->getV1();
float ut0 = tex->getU(7);
float vt0 = tex->getV(6);
float ut1 = tex->getU(9);
float vt1 = tex->getV(8);
float ub0 = tex->getU(7);
float vb0 = tex->getV(13);
float ub1 = tex->getU(9);
float vb1 = tex->getV(15);
x += 0.5f;
z += 0.5f;
float x0 = x - 0.5f;
float x1 = x + 0.5f;
float z0 = z - 0.5f;
float z1 = z + 0.5f;
float r = 1 / 16.0f;
float h = 10.0f / 16.0f;
t->vertexUV((float)(x + xxa * (1 - h) - r), (float)(y + h),
(float)(z + zza * (1 - h) - r), ut0, vt0);
t->vertexUV((float)(x + xxa * (1 - h) - r), (float)(y + h),
(float)(z + zza * (1 - h) + r), ut0, vt1);
t->vertexUV((float)(x + xxa * (1 - h) + r), (float)(y + h),
(float)(z + zza * (1 - h) + r), ut1, vt1);
t->vertexUV((float)(x + xxa * (1 - h) + r), (float)(y + h),
(float)(z + zza * (1 - h) - r), ut1, vt0);
t->vertexUV((float)(x + r + xxa), (float)y, (float)(z - r + zza), ub1, vb0);
t->vertexUV((float)(x + r + xxa), (float)y, (float)(z + r + zza), ub1, vb1);
t->vertexUV((float)(x - r + xxa), (float)y, (float)(z + r + zza), ub0, vb1);
t->vertexUV((float)(x - r + xxa), (float)y, (float)(z - r + zza), ub0, vb0);
t->vertexUV((float)(x - r), (float)(y + 1), (float)(z0), (float)(u0),
(float)(v0));
t->vertexUV((float)(x - r + xxa), (float)(y + 0), (float)(z0 + zza),
(float)(u0), (float)(v1));
t->vertexUV((float)(x - r + xxa), (float)(y + 0), (float)(z1 + zza),
(float)(u1), (float)(v1));
t->vertexUV((float)(x - r), (float)(y + 1), (float)(z1), (float)(u1),
(float)(v0));
t->vertexUV((float)(x + r), (float)(y + 1), (float)(z1), (float)(u0),
(float)(v0));
t->vertexUV((float)(x + xxa + r), (float)(y + 0), (float)(z1 + zza),
(float)(u0), (float)(v1));
t->vertexUV((float)(x + xxa + r), (float)(y + 0), (float)(z0 + zza),
(float)(u1), (float)(v1));
t->vertexUV((float)(x + r), (float)(y + 1), (float)(z0), (float)(u1),
(float)(v0));
t->vertexUV((float)(x0), (float)(y + 1), (float)(z + r), (float)(u0),
(float)(v0));
t->vertexUV((float)(x0 + xxa), (float)(y + 0), (float)(z + r + zza),
(float)(u0), (float)(v1));
t->vertexUV((float)(x1 + xxa), (float)(y + 0), (float)(z + r + zza),
(float)(u1), (float)(v1));
t->vertexUV((float)(x1), (float)(y + 1), (float)(z + r), (float)(u1),
(float)(v0));
t->vertexUV((float)(x1), (float)(y + 1), (float)(z - r), (float)(u0),
(float)(v0));
t->vertexUV((float)(x1 + xxa), (float)(y + 0), (float)(z - r + zza),
(float)(u0), (float)(v1));
t->vertexUV((float)(x0 + xxa), (float)(y + 0), (float)(z - r + zza),
(float)(u1), (float)(v1));
t->vertexUV((float)(x0), (float)(y + 1), (float)(z - r), (float)(u1),
(float)(v0));
}
void TileRenderer_SPU::tesselateCrossTexture(Tile_SPU* tt, int data, float x,
float y, float z, float scale) {
Tesselator_SPU* t = getTesselator();
Icon_SPU* tex = getTexture(tt, 0, data);
if (hasFixedTexture()) tex = fixedTexture;
float u0 = tex->getU0();
float v0 = tex->getV0();
float u1 = tex->getU1();
float v1 = tex->getV1();
float width = 0.45 * scale;
float x0 = x + 0.5 - width;
float x1 = x + 0.5 + width;
float z0 = z + 0.5 - width;
float z1 = z + 0.5 + width;
t->vertexUV((float)(x0), (float)(y + scale), (float)(z0), (float)(u0),
(float)(v0));
t->vertexUV((float)(x0), (float)(y + 0), (float)(z0), (float)(u0),
(float)(v1));
t->vertexUV((float)(x1), (float)(y + 0), (float)(z1), (float)(u1),
(float)(v1));
t->vertexUV((float)(x1), (float)(y + scale), (float)(z1), (float)(u1),
(float)(v0));
t->vertexUV((float)(x1), (float)(y + scale), (float)(z1), (float)(u0),
(float)(v0));
t->vertexUV((float)(x1), (float)(y + 0), (float)(z1), (float)(u0),
(float)(v1));
t->vertexUV((float)(x0), (float)(y + 0), (float)(z0), (float)(u1),
(float)(v1));
t->vertexUV((float)(x0), (float)(y + scale), (float)(z0), (float)(u1),
(float)(v0));
t->vertexUV((float)(x0), (float)(y + scale), (float)(z1), (float)(u0),
(float)(v0));
t->vertexUV((float)(x0), (float)(y + 0), (float)(z1), (float)(u0),
(float)(v1));
t->vertexUV((float)(x1), (float)(y + 0), (float)(z0), (float)(u1),
(float)(v1));
t->vertexUV((float)(x1), (float)(y + scale), (float)(z0), (float)(u1),
(float)(v0));
t->vertexUV((float)(x1), (float)(y + scale), (float)(z0), (float)(u0),
(float)(v0));
t->vertexUV((float)(x1), (float)(y + 0), (float)(z0), (float)(u0),
(float)(v1));
t->vertexUV((float)(x0), (float)(y + 0), (float)(z1), (float)(u1),
(float)(v1));
t->vertexUV((float)(x0), (float)(y + scale), (float)(z1), (float)(u1),
(float)(v0));
}
void TileRenderer_SPU::tesselateStemTexture(Tile_SPU* tt, int data, float h,
float x, float y, float z) {
// #ifdef DISABLE_TESS_FUNCS
Tesselator_SPU* t = getTesselator();
Icon_SPU* tex = getTexture(tt, 0, data);
if (hasFixedTexture()) tex = fixedTexture;
float u0 = tex->getU0();
float v0 = tex->getV0();
float u1 = tex->getU1();
float v1 = tex->getV(h * SharedConstants::WORLD_RESOLUTION);
float x0 = x + 0.5f - 0.45f;
float x1 = x + 0.5f + 0.45f;
float z0 = z + 0.5f - 0.45f;
float z1 = z + 0.5f + 0.45f;
t->vertexUV(x0, y + h, z0, u0, v0);
t->vertexUV(x0, y + 0, z0, u0, v1);
t->vertexUV(x1, y + 0, z1, u1, v1);
t->vertexUV(x1, y + h, z1, u1, v0);
t->vertexUV(x1, y + h, z1, u0, v0);
t->vertexUV(x1, y + 0, z1, u0, v1);
t->vertexUV(x0, y + 0, z0, u1, v1);
t->vertexUV(x0, y + h, z0, u1, v0);
t->vertexUV(x0, y + h, z1, u0, v0);
t->vertexUV(x0, y + 0, z1, u0, v1);
t->vertexUV(x1, y + 0, z0, u1, v1);
t->vertexUV(x1, y + h, z0, u1, v0);
t->vertexUV(x1, y + h, z0, u0, v0);
t->vertexUV(x1, y + 0, z0, u0, v1);
t->vertexUV(x0, y + 0, z1, u1, v1);
t->vertexUV(x0, y + h, z1, u1, v0);
// #endif // DISABLE_TESS_FUNCS
}
bool TileRenderer_SPU::tesselateLilypadInWorld(WaterlilyTile_SPU* tt, int x,
int y, int z) {
Tesselator_SPU* t = getTesselator();
Icon_SPU* tex = getTexture(tt, Facing::UP);
if (hasFixedTexture()) tex = fixedTexture;
float h = 0.25f / 16.0f;
float u0 = tex->getU0();
float v0 = tex->getV0();
float u1 = tex->getU1();
float v1 = tex->getV1();
int64_t seed = (x * 3129871) ^ (z * 116129781l) ^ (y);
seed = seed * seed * 42317861 + seed * 11;
int dir = (int)((seed >> 16) & 0x3);
t->tex2(tt->getLightColor(level, x, y, z));
float xx = x + 0.5f;
float zz = z + 0.5f;
float c = ((dir & 1) * 0.5f) * (1 - dir / 2 % 2 * 2);
float s = (((dir + 1) & 1) * 0.5f) * (1 - (dir + 1) / 2 % 2 * 2);
t->color(tt->getColor());
t->vertexUV(xx + c - s, y + h, zz + c + s, u0, v0);
t->vertexUV(xx + c + s, y + h, zz - c + s, u1, v0);
t->vertexUV(xx - c + s, y + h, zz - c - s, u1, v1);
t->vertexUV(xx - c - s, y + h, zz + c - s, u0, v1);
t->color((tt->getColor() & 0xfefefe) >> 1);
t->vertexUV(xx - c - s, y + h, zz + c - s, u0, v1);
t->vertexUV(xx - c + s, y + h, zz - c - s, u1, v1);
t->vertexUV(xx + c + s, y + h, zz - c + s, u1, v0);
t->vertexUV(xx + c - s, y + h, zz + c + s, u0, v0);
return true;
}
void TileRenderer_SPU::tesselateStemDirTexture(StemTile_SPU* tt, int data,
int dir, float h, float x,
float y, float z) {
Tesselator_SPU* t = getTesselator();
Icon_SPU* tex = tt->getAngledTexture();
if (hasFixedTexture()) tex = fixedTexture;
float u0 = tex->getU0();
float v0 = tex->getV0();
float u1 = tex->getU1();
float v1 = tex->getV1();
float x0 = x + 0.5f - 0.5f;
float x1 = x + 0.5f + 0.5f;
float z0 = z + 0.5f - 0.5f;
float z1 = z + 0.5f + 0.5f;
float xm = x + 0.5f;
float zm = z + 0.5f;
if ((dir + 1) / 2 % 2 == 1) {
float tmp = u1;
u1 = u0;
u0 = tmp;
}
if (dir < 2) {
t->vertexUV(x0, y + h, zm, u0, v0);
t->vertexUV(x0, y + 0, zm, u0, v1);
t->vertexUV(x1, y + 0, zm, u1, v1);
t->vertexUV(x1, y + h, zm, u1, v0);
t->vertexUV(x1, y + h, zm, u1, v0);
t->vertexUV(x1, y + 0, zm, u1, v1);
t->vertexUV(x0, y + 0, zm, u0, v1);
t->vertexUV(x0, y + h, zm, u0, v0);
} else {
t->vertexUV(xm, y + h, z1, u0, v0);
t->vertexUV(xm, y + 0, z1, u0, v1);
t->vertexUV(xm, y + 0, z0, u1, v1);
t->vertexUV(xm, y + h, z0, u1, v0);
t->vertexUV(xm, y + h, z0, u1, v0);
t->vertexUV(xm, y + 0, z0, u1, v1);
t->vertexUV(xm, y + 0, z1, u0, v1);
t->vertexUV(xm, y + h, z1, u0, v0);
}
}
void TileRenderer_SPU::tesselateRowTexture(Tile_SPU* tt, int data, float x,
float y, float z) {
Tesselator_SPU* t = getTesselator();
Icon_SPU* tex = getTexture(tt, 0, data);
if (hasFixedTexture()) tex = fixedTexture;
float u0 = tex->getU0();
float v0 = tex->getV0();
float u1 = tex->getU1();
float v1 = tex->getV1();
float x0 = x + 0.5f - 0.25f;
float x1 = x + 0.5f + 0.25f;
float z0 = z + 0.5f - 0.5f;
float z1 = z + 0.5f + 0.5f;
t->vertexUV((float)(x0), (float)(y + 1), (float)(z0), (float)(u0),
(float)(v0));
t->vertexUV((float)(x0), (float)(y + 0), (float)(z0), (float)(u0),
(float)(v1));
t->vertexUV((float)(x0), (float)(y + 0), (float)(z1), (float)(u1),
(float)(v1));
t->vertexUV((float)(x0), (float)(y + 1), (float)(z1), (float)(u1),
(float)(v0));
t->vertexUV((float)(x0), (float)(y + 1), (float)(z1), (float)(u0),
(float)(v0));
t->vertexUV((float)(x0), (float)(y + 0), (float)(z1), (float)(u0),
(float)(v1));
t->vertexUV((float)(x0), (float)(y + 0), (float)(z0), (float)(u1),
(float)(v1));
t->vertexUV((float)(x0), (float)(y + 1), (float)(z0), (float)(u1),
(float)(v0));
t->vertexUV((float)(x1), (float)(y + 1), (float)(z1), (float)(u0),
(float)(v0));
t->vertexUV((float)(x1), (float)(y + 0), (float)(z1), (float)(u0),
(float)(v1));
t->vertexUV((float)(x1), (float)(y + 0), (float)(z0), (float)(u1),
(float)(v1));
t->vertexUV((float)(x1), (float)(y + 1), (float)(z0), (float)(u1),
(float)(v0));
t->vertexUV((float)(x1), (float)(y + 1), (float)(z0), (float)(u0),
(float)(v0));
t->vertexUV((float)(x1), (float)(y + 0), (float)(z0), (float)(u0),
(float)(v1));
t->vertexUV((float)(x1), (float)(y + 0), (float)(z1), (float)(u1),
(float)(v1));
t->vertexUV((float)(x1), (float)(y + 1), (float)(z1), (float)(u1),
(float)(v0));
x0 = x + 0.5f - 0.5f;
x1 = x + 0.5f + 0.5f;
z0 = z + 0.5f - 0.25f;
z1 = z + 0.5f + 0.25f;
t->vertexUV((float)(x0), (float)(y + 1), (float)(z0), (float)(u0),
(float)(v0));
t->vertexUV((float)(x0), (float)(y + 0), (float)(z0), (float)(u0),
(float)(v1));
t->vertexUV((float)(x1), (float)(y + 0), (float)(z0), (float)(u1),
(float)(v1));
t->vertexUV((float)(x1), (float)(y + 1), (float)(z0), (float)(u1),
(float)(v0));
t->vertexUV((float)(x1), (float)(y + 1), (float)(z0), (float)(u0),
(float)(v0));
t->vertexUV((float)(x1), (float)(y + 0), (float)(z0), (float)(u0),
(float)(v1));
t->vertexUV((float)(x0), (float)(y + 0), (float)(z0), (float)(u1),
(float)(v1));
t->vertexUV((float)(x0), (float)(y + 1), (float)(z0), (float)(u1),
(float)(v0));
t->vertexUV((float)(x1), (float)(y + 1), (float)(z1), (float)(u0),
(float)(v0));
t->vertexUV((float)(x1), (float)(y + 0), (float)(z1), (float)(u0),
(float)(v1));
t->vertexUV((float)(x0), (float)(y + 0), (float)(z1), (float)(u1),
(float)(v1));
t->vertexUV((float)(x0), (float)(y + 1), (float)(z1), (float)(u1),
(float)(v0));
t->vertexUV((float)(x0), (float)(y + 1), (float)(z1), (float)(u0),
(float)(v0));
t->vertexUV((float)(x0), (float)(y + 0), (float)(z1), (float)(u0),
(float)(v1));
t->vertexUV((float)(x1), (float)(y + 0), (float)(z1), (float)(u1),
(float)(v1));
t->vertexUV((float)(x1), (float)(y + 1), (float)(z1), (float)(u1),
(float)(v0));
}
bool TileRenderer_SPU::tesselateWaterInWorld(Tile_SPU* tt, int x, int y,
int z) {
// 4J Java comment
// TODO: This all needs to change. Somehow.
Tesselator_SPU* t = getTesselator();
int col = tt->getColor(level, x, y, z);
float r = (col >> 16 & 0xff) / 255.0f;
float g = (col >> 8 & 0xff) / 255.0f;
float b = (col & 0xff) / 255.0f;
bool up = tt->shouldRenderFace(level, x, y + 1, z, 1);
bool down = tt->shouldRenderFace(level, x, y - 1, z, 0);
bool dirs[4];
dirs[0] = tt->shouldRenderFace(level, x, y, z - 1, 2);
dirs[1] = tt->shouldRenderFace(level, x, y, z + 1, 3);
dirs[2] = tt->shouldRenderFace(level, x - 1, y, z, 4);
dirs[3] = tt->shouldRenderFace(level, x + 1, y, z, 5);
if (!up && !down && !dirs[0] && !dirs[1] && !dirs[2] && !dirs[3])
return false;
bool changed = false;
float c10 = 0.5f;
float c11 = 1;
float c2 = 0.8f;
float c3 = 0.6f;
float yo0 = 0;
float yo1 = 1;
Material_SPU* m = tt->getMaterial();
int data = level->getData(x, y, z);
float h0 = getWaterHeight(x, y, z, m);
float h1 = getWaterHeight(x, y, z + 1, m);
float h2 = getWaterHeight(x + 1, y, z + 1, m);
float h3 = getWaterHeight(x + 1, y, z, m);
float offs = 0.001f;
// 4J - added. Farm tiles often found beside water, but they consider
// themselves non-solid as they only extend up to 15.0f / 16.0f. If the max
// height of this water is below that level, don't bother rendering sides
// bordering onto farmland.
float maxh = h0;
if (h1 > maxh) maxh = h1;
if (h2 > maxh) maxh = h2;
if (h3 > maxh) maxh = h3;
if (maxh <= (15.0f / 16.0f)) {
if (level->getTile(x, y, z - 1) == Tile_SPU::farmland_Id) {
dirs[0] = false;
}
if (level->getTile(x, y, z + 1) == Tile_SPU::farmland_Id) {
dirs[1] = false;
}
if (level->getTile(x - 1, y, z) == Tile_SPU::farmland_Id) {
dirs[2] = false;
}
if (level->getTile(x + 1, y, z) == Tile_SPU::farmland_Id) {
dirs[3] = false;
}
}
if (noCulling || up) {
changed = true;
Icon_SPU* tex = getTexture(tt, 1, data);
float angle = (float)LiquidTile_SPU::getSlopeAngle(level, x, y, z, m);
if (angle > -999) {
tex = getTexture(tt, 2, data);
}
h0 -= offs;
h1 -= offs;
h2 -= offs;
h3 -= offs;
float u00, u01, u10, u11;
float v00, v01, v10, v11;
if (angle < -999) {
u00 = tex->getU(0);
v00 = tex->getV(0);
u01 = u00;
v01 = tex->getV(SharedConstants::WORLD_RESOLUTION);
u10 = tex->getU(SharedConstants::WORLD_RESOLUTION);
v10 = v01;
u11 = u10;
v11 = v00;
} else {
float s = sinf(angle) * .25f;
float c = cosf(angle) * .25f;
float cc = SharedConstants::WORLD_RESOLUTION * .5f;
u00 = tex->getU(cc + (-c - s) * SharedConstants::WORLD_RESOLUTION);
v00 = tex->getV(cc + (-c + s) * SharedConstants::WORLD_RESOLUTION);
u01 = tex->getU(cc + (-c + s) * SharedConstants::WORLD_RESOLUTION);
v01 = tex->getV(cc + (+c + s) * SharedConstants::WORLD_RESOLUTION);
u10 = tex->getU(cc + (+c + s) * SharedConstants::WORLD_RESOLUTION);
v10 = tex->getV(cc + (+c - s) * SharedConstants::WORLD_RESOLUTION);
u11 = tex->getU(cc + (+c - s) * SharedConstants::WORLD_RESOLUTION);
v11 = tex->getV(cc + (-c - s) * SharedConstants::WORLD_RESOLUTION);
}
float br;
if (SharedConstants::TEXTURE_LIGHTING) {
t->tex2(tt->getLightColor(level, x, y, z));
br = 1;
} else {
br = tt->getBrightness(level, x, y, z);
}
t->color(c11 * br * r, c11 * br * g, c11 * br * b);
t->vertexUV((float)(x + 0.0f), (float)(y + h0), (float)(z + 0.0f), u00,
v00);
t->vertexUV((float)(x + 0.0f), (float)(y + h1), (float)(z + 1.0f), u01,
v01);
t->vertexUV((float)(x + 1.0f), (float)(y + h2), (float)(z + 1.0f), u10,
v10);
t->vertexUV((float)(x + 1.0f), (float)(y + h3), (float)(z + 0.0f), u11,
v11);
}
if (noCulling || down) {
float br;
if (SharedConstants::TEXTURE_LIGHTING) {
t->tex2(tt->getLightColor(level, x, y - 1, z));
br = 1;
} else {
br = tt->getBrightness(level, x, y - 1, z);
}
t->color(c10 * br, c10 * br, c10 * br);
renderFaceDown(tt, x, y + offs, z, getTexture(tt, 0));
changed = true;
}
for (int face = 0; face < 4; face++) {
int xt = x;
int yt = y;
int zt = z;
if (face == 0) zt--;
if (face == 1) zt++;
if (face == 2) xt--;
if (face == 3) xt++;
Icon_SPU* tex = getTexture(tt, face + 2, data);
if (noCulling || dirs[face]) {
float hh0;
float hh1;
float x0, z0, x1, z1;
if (face == 0) {
hh0 = (float)(h0);
hh1 = (float)(h3);
x0 = (float)(x);
x1 = (float)(x + 1);
z0 = (float)(z + offs);
z1 = (float)(z + offs);
} else if (face == 1) {
hh0 = (float)(h2);
hh1 = (float)(h1);
x0 = (float)(x + 1);
x1 = (float)(x);
z0 = (float)(z + 1 - offs);
z1 = (float)(z + 1 - offs);
} else if (face == 2) {
hh0 = (float)(h1);
hh1 = (float)(h0);
x0 = (float)(x + offs);
x1 = (float)(x + offs);
z0 = (float)(z + 1);
z1 = (float)(z);
} else {
hh0 = (float)(h3);
hh1 = (float)(h2);
x0 = (float)(x + 1 - offs);
x1 = (float)(x + 1 - offs);
z0 = (float)(z);
z1 = (float)(z + 1);
}
changed = true;
float u0 = tex->getU(0);
float u1 = tex->getU(SharedConstants::WORLD_RESOLUTION * .5f);
// int yTex = tex->getY();
float v01 =
tex->getV((1 - hh0) * SharedConstants::WORLD_RESOLUTION * .5f);
float v02 =
tex->getV((1 - hh1) * SharedConstants::WORLD_RESOLUTION * .5f);
float v1 = tex->getV(SharedConstants::WORLD_RESOLUTION * .5f);
float br;
if (SharedConstants::TEXTURE_LIGHTING) {
t->tex2(tt->getLightColor(level, xt, yt, zt));
br = 1;
} else {
br = tt->getBrightness(level, xt, yt, zt);
}
if (face < 2)
br *= c2;
else
br *= c3;
t->color(c11 * br * r, c11 * br * g, c11 * br * b);
t->vertexUV((float)(x0), (float)(y + hh0), (float)(z0), (float)(u0),
(float)(v01));
t->vertexUV((float)(x1), (float)(y + hh1), (float)(z1), (float)(u1),
(float)(v02));
t->vertexUV((float)(x1), (float)(y + 0), (float)(z1), (float)(u1),
(float)(v1));
t->vertexUV((float)(x0), (float)(y + 0), (float)(z0), (float)(u0),
(float)(v1));
}
}
tileShapeY0 = yo0;
tileShapeY1 = yo1;
return changed;
}
float TileRenderer_SPU::getWaterHeight(int x, int y, int z, Material_SPU* m) {
int count = 0;
float h = 0;
for (int i = 0; i < 4; i++) {
int xx = x - (i & 1);
int yy = y;
int zz = z - ((i >> 1) & 1);
if (level->getMaterial(xx, yy + 1, zz) == m) {
return 1;
}
Material_SPU* tm = level->getMaterial(xx, yy, zz);
if (tm == m) {
int d = level->getData(xx, yy, zz);
if (d >= 8 || d == 0) {
h += (LiquidTile_SPU::getHeight(d)) * 10;
count += 10;
}
h += LiquidTile_SPU::getHeight(d);
count++;
} else if (!tm->isSolid()) {
h += 1;
count++;
}
}
return 1 - h / count;
}
void TileRenderer_SPU::renderBlock(Tile_SPU* tt, ChunkRebuildData* level, int x,
int y, int z) {
renderBlock(tt, level, x, y, z, 0);
}
void TileRenderer_SPU::renderBlock(Tile_SPU* tt, ChunkRebuildData* level, int x,
int y, int z, int data) {
float c10 = 0.5f;
float c11 = 1;
float c2 = 0.8f;
float c3 = 0.6f;
Tesselator_SPU* t = getTesselator();
t->begin();
if (SharedConstants::TEXTURE_LIGHTING) {
t->tex2(tt->getLightColor(level, x, y, z));
}
float center = SharedConstants::TEXTURE_LIGHTING
? 1
: tt->getBrightness(level, x, y, z);
float br = SharedConstants::TEXTURE_LIGHTING
? 1
: tt->getBrightness(level, x, y - 1, z);
if (br < center) br = center;
t->color(c10 * br, c10 * br, c10 * br);
renderFaceDown(tt, -0.5f, -0.5f, -0.5f, getTexture(tt, 0, data));
br = SharedConstants::TEXTURE_LIGHTING
? 1
: tt->getBrightness(level, x, y + 1, z);
if (br < center) br = center;
t->color(c11 * br, c11 * br, c11 * br);
renderFaceUp(tt, -0.5f, -0.5f, -0.5f, getTexture(tt, 1, data));
br = SharedConstants::TEXTURE_LIGHTING
? 1
: tt->getBrightness(level, x, y, z - 1);
if (br < center) br = center;
t->color(c2 * br, c2 * br, c2 * br);
renderNorth(tt, -0.5f, -0.5f, -0.5f, getTexture(tt, 2, data));
br = SharedConstants::TEXTURE_LIGHTING
? 1
: tt->getBrightness(level, x, y, z + 1);
if (br < center) br = center;
t->color(c2 * br, c2 * br, c2 * br);
renderSouth(tt, -0.5f, -0.5f, -0.5f, getTexture(tt, 3, data));
br = SharedConstants::TEXTURE_LIGHTING
? 1
: tt->getBrightness(level, x - 1, y, z);
if (br < center) br = center;
t->color(c3 * br, c3 * br, c3 * br);
renderWest(tt, -0.5f, -0.5f, -0.5f, getTexture(tt, 4, data));
br = SharedConstants::TEXTURE_LIGHTING
? 1
: tt->getBrightness(level, x + 1, y, z);
if (br < center) br = center;
t->color(c3 * br, c3 * br, c3 * br);
renderEast(tt, -0.5f, -0.5f, -0.5f, getTexture(tt, 5, data));
t->end();
}
bool TileRenderer_SPU::tesselateBlockInWorld(Tile_SPU* tt, int x, int y,
int z) {
int col = tt->getColor(level, x, y, z);
float r = ((col >> 16) & 0xff) / 255.0f;
float g = ((col >> 8) & 0xff) / 255.0f;
float b = ((col) & 0xff) / 255.0f;
if (isAnaglyph3d()) {
float cr = (r * 30 + g * 59 + b * 11) / 100;
float cg = (r * 30 + g * 70) / (100);
float cb = (r * 30 + b * 70) / (100);
r = cr;
g = cg;
b = cb;
}
if (level->m_tileData.lightEmission[tt->id] ==
0) // 4J - TODO/remove (Minecraft::useAmbientOcclusion())
{
if (SharedConstants::TEXTURE_LIGHTING) {
return tesselateBlockInWorldWithAmbienceOcclusionTexLighting(
tt, x, y, z, r, g, b);
} else {
return tesselateBlockInWorldWithAmbienceOcclusionOldLighting(
tt, x, y, z, r, g, b);
}
} else {
return tesselateBlockInWorld(tt, x, y, z, r, g, b);
}
}
bool TileRenderer_SPU::tesselateTreeInWorld(Tile_SPU* tt, int x, int y, int z) {
int data = level->getData(x, y, z);
int facing = data & TreeTile_SPU::MASK_FACING;
if (facing == TreeTile_SPU::FACING_X) {
northFlip = FLIP_CW;
southFlip = FLIP_CW;
upFlip = FLIP_CW;
downFlip = FLIP_CW;
} else if (facing == TreeTile_SPU::FACING_Z) {
eastFlip = FLIP_CW;
westFlip = FLIP_CW;
}
bool result = tesselateBlockInWorld(tt, x, y, z);
eastFlip = 0;
northFlip = 0;
southFlip = 0;
westFlip = 0;
upFlip = 0;
downFlip = 0;
return result;
}
bool TileRenderer_SPU::tesselateQuartzInWorld(Tile_SPU* tt, int x, int y,
int z) {
int data = level->getData(x, y, z);
if (data == QuartzBlockTile_SPU::TYPE_LINES_X) {
northFlip = FLIP_CW;
southFlip = FLIP_CW;
upFlip = FLIP_CW;
downFlip = FLIP_CW;
} else if (data == QuartzBlockTile_SPU::TYPE_LINES_Z) {
eastFlip = FLIP_CW;
westFlip = FLIP_CW;
}
bool result = tesselateBlockInWorld(tt, x, y, z);
eastFlip = 0;
northFlip = 0;
southFlip = 0;
westFlip = 0;
upFlip = 0;
downFlip = 0;
return result;
}
bool TileRenderer_SPU::tesselateCocoaInWorld(CocoaTile_SPU* tt, int x, int y,
int z) {
#ifdef DISABLE_TESS_FUNCS
Tesselator* t = Tesselator::getInstance();
if (SharedConstants::TEXTURE_LIGHTING) {
t->tex2(tt->getLightColor(level, x, y, z));
t->color(1.0f, 1.0f, 1.0f);
} else {
float br = tt->getBrightness(level, x, y, z);
if (Tile::lightEmission[tt->id] > 0) br = 1.0f;
t->color(br, br, br);
}
int data = level->getData(x, y, z);
int dir = DirectionalTile::getDirection(data);
int age = CocoaTile::getAge(data);
Icon* tex = tt->getTextureForAge(age);
int cocoaWidth = 4 + age * 2;
int cocoaHeight = 5 + age * 2;
double us = 15.0 - cocoaWidth;
double ue = 15.0;
double vs = 4.0;
double ve = 4.0 + cocoaHeight;
double u0 = tex->getU(us, true);
double u1 = tex->getU(ue, true);
double v0 = tex->getV(vs, true);
double v1 = tex->getV(ve, true);
double offX = 0;
double offZ = 0;
switch (dir) {
case Direction::NORTH:
offX = 8.0 - cocoaWidth / 2;
offZ = 1.0;
break;
case Direction::SOUTH:
offX = 8.0 - cocoaWidth / 2;
offZ = 15.0 - cocoaWidth;
break;
case Direction::EAST:
offX = 15.0 - cocoaWidth;
offZ = 8.0 - cocoaWidth / 2;
break;
case Direction::WEST:
offX = 1.0;
offZ = 8.0 - cocoaWidth / 2;
break;
}
double x0 = x + offX / 16.0;
double x1 = x + (offX + cocoaWidth) / 16.0;
double y0 = y + (12.0 - cocoaHeight) / 16.0;
double y1 = y + 12.0 / 16.0;
double z0 = z + offZ / 16.0;
double z1 = z + (offZ + cocoaWidth) / 16.0;
// west
{
t->vertexUV(x0, y0, z0, u0, v1);
t->vertexUV(x0, y0, z1, u1, v1);
t->vertexUV(x0, y1, z1, u1, v0);
t->vertexUV(x0, y1, z0, u0, v0);
}
// east
{
t->vertexUV(x1, y0, z1, u0, v1);
t->vertexUV(x1, y0, z0, u1, v1);
t->vertexUV(x1, y1, z0, u1, v0);
t->vertexUV(x1, y1, z1, u0, v0);
}
// north
{
t->vertexUV(x1, y0, z0, u0, v1);
t->vertexUV(x0, y0, z0, u1, v1);
t->vertexUV(x0, y1, z0, u1, v0);
t->vertexUV(x1, y1, z0, u0, v0);
}
// south
{
t->vertexUV(x0, y0, z1, u0, v1);
t->vertexUV(x1, y0, z1, u1, v1);
t->vertexUV(x1, y1, z1, u1, v0);
t->vertexUV(x0, y1, z1, u0, v0);
}
int topWidth = cocoaWidth;
if (age >= 2) {
// special case because the top piece didn't fit
topWidth--;
}
u0 = tex->getU0(true);
u1 = tex->getU(topWidth, true);
v0 = tex->getV0(true);
v1 = tex->getV(topWidth, true);
// top
{
t->vertexUV(x0, y1, z1, u0, v1);
t->vertexUV(x1, y1, z1, u1, v1);
t->vertexUV(x1, y1, z0, u1, v0);
t->vertexUV(x0, y1, z0, u0, v0);
}
// bottom
{
t->vertexUV(x0, y0, z0, u0, v0);
t->vertexUV(x1, y0, z0, u1, v0);
t->vertexUV(x1, y0, z1, u1, v1);
t->vertexUV(x0, y0, z1, u0, v1);
}
// stalk
u0 = tex->getU(12, true);
u1 = tex->getU1(true);
v0 = tex->getV0(true);
v1 = tex->getV(4, true);
offX = 8;
offZ = 0;
switch (dir) {
case Direction::NORTH:
offX = 8.0;
offZ = 0.0;
break;
case Direction::SOUTH:
offX = 8;
offZ = 12;
{
double temp = u0;
u0 = u1;
u1 = temp;
}
break;
case Direction::EAST:
offX = 12.0;
offZ = 8.0;
{
double temp = u0;
u0 = u1;
u1 = temp;
}
break;
case Direction::WEST:
offX = 0.0;
offZ = 8.0;
break;
}
x0 = x + offX / 16.0;
x1 = x + (offX + 4.0) / 16.0;
y0 = y + 12.0 / 16.0;
y1 = y + 16.0 / 16.0;
z0 = z + offZ / 16.0;
z1 = z + (offZ + 4.0) / 16.0;
if (dir == Direction::NORTH || dir == Direction::SOUTH) {
// west
{
t->vertexUV(x0, y0, z0, u1, v1);
t->vertexUV(x0, y0, z1, u0, v1);
t->vertexUV(x0, y1, z1, u0, v0);
t->vertexUV(x0, y1, z0, u1, v0);
}
// east
{
t->vertexUV(x0, y0, z1, u0, v1);
t->vertexUV(x0, y0, z0, u1, v1);
t->vertexUV(x0, y1, z0, u1, v0);
t->vertexUV(x0, y1, z1, u0, v0);
}
} else if (dir == Direction::WEST || dir == Direction::EAST) {
// north
{
t->vertexUV(x1, y0, z0, u0, v1);
t->vertexUV(x0, y0, z0, u1, v1);
t->vertexUV(x0, y1, z0, u1, v0);
t->vertexUV(x1, y1, z0, u0, v0);
}
// south
{
t->vertexUV(x0, y0, z0, u1, v1);
t->vertexUV(x1, y0, z0, u0, v1);
t->vertexUV(x1, y1, z0, u0, v0);
t->vertexUV(x0, y1, z0, u1, v0);
}
}
#endif // DISABLE_TESS_FUNCS
return true;
}
// 4J - brought changes forward from 1.8.2
bool TileRenderer_SPU::tesselateBlockInWorldWithAmbienceOcclusionTexLighting(
Tile_SPU* tt, int pX, int pY, int pZ, float pBaseRed, float pBaseGreen,
float pBaseBlue) {
// 4J - added these faceFlags so we can detect whether this block is going
// to have no visible faces and early out the original code checked
// noCulling and shouldRenderFace directly where faceFlags is used now
int faceFlags = 0;
if (noCulling) {
faceFlags = 0x3f;
} else {
/*#ifdef _DEBUG
if(dynamic_cast<StairTile *>(tt)!=NULL)
{
// stair tile
faceFlags |= tt->shouldRenderFace( level, pX, pY
- 1, pZ, 0 ) ? 0x01 : 0; faceFlags |= tt->shouldRenderFace( level, pX,
pY + 1, pZ, 1 ) ? 0x02 : 0; faceFlags |= tt->shouldRenderFace( level,
pX, pY, pZ - 1, 2 ) ? 0x04 : 0; faceFlags |= tt->shouldRenderFace(
level, pX, pY, pZ + 1, 3 ) ? 0x08 : 0; faceFlags |=
tt->shouldRenderFace( level, pX - 1, pY, pZ, 4 ) ? 0x10 : 0; faceFlags
|= tt->shouldRenderFace( level, pX + 1, pY, pZ, 5 ) ? 0x20 : 0;
printf("Stair tile\n");
}
else
{
faceFlags |= tt->shouldRenderFace( level, pX, pY
- 1, pZ, 0 ) ? 0x01 : 0; faceFlags |= tt->shouldRenderFace( level, pX,
pY + 1, pZ, 1 ) ? 0x02 : 0; faceFlags |= tt->shouldRenderFace( level,
pX, pY, pZ - 1, 2 ) ? 0x04 : 0; faceFlags |= tt->shouldRenderFace(
level, pX, pY, pZ + 1, 3 ) ? 0x08 : 0; faceFlags |=
tt->shouldRenderFace( level, pX - 1, pY, pZ, 4 ) ? 0x10 : 0; faceFlags
|= tt->shouldRenderFace( level, pX + 1, pY, pZ, 5 ) ? 0x20 : 0;
}
#else*/
faceFlags |= tt->shouldRenderFace(level, pX, pY - 1, pZ, 0) ? 0x01 : 0;
faceFlags |= tt->shouldRenderFace(level, pX, pY + 1, pZ, 1) ? 0x02 : 0;
faceFlags |= tt->shouldRenderFace(level, pX, pY, pZ - 1, 2) ? 0x04 : 0;
faceFlags |= tt->shouldRenderFace(level, pX, pY, pZ + 1, 3) ? 0x08 : 0;
faceFlags |= tt->shouldRenderFace(level, pX - 1, pY, pZ, 4) ? 0x10 : 0;
faceFlags |= tt->shouldRenderFace(level, pX + 1, pY, pZ, 5) ? 0x20 : 0;
// #endif
}
if (faceFlags == 0) {
return false;
}
// If we are only rendering the bottom face and we're at the bottom of the
// world, we shouldn't be able to see this - don't render anything
if ((faceFlags == 1) && (pY == 0)) {
return false;
}
applyAmbienceOcclusion = true;
float ll1 = ll000;
float ll2 = ll000;
float ll3 = ll000;
float ll4 = ll000;
bool tint0 = true;
bool tint1 = true;
bool tint2 = true;
bool tint3 = true;
bool tint4 = true;
bool tint5 = true;
ll000 = tt->getShadeBrightness(level, pX, pY, pZ);
// Tile* t2 = Tile::tiles[tt->id];
// if(t2->getShadeBrightness(level->m_pRegion, pX, pY, pZ) != ll000)
// {
// app.DebugPrintf("Failed\n");
// ll000 = tt->getShadeBrightness( level, pX, pY, pZ );
// ll000 = t2->getShadeBrightness(level->m_pRegion, pX, pY, pZ);
// }
llx00 = tt->getShadeBrightness(level, pX - 1, pY, pZ);
ll0y0 = tt->getShadeBrightness(level, pX, pY - 1, pZ);
ll00z = tt->getShadeBrightness(level, pX, pY, pZ - 1);
llX00 = tt->getShadeBrightness(level, pX + 1, pY, pZ);
ll0Y0 = tt->getShadeBrightness(level, pX, pY + 1, pZ);
ll00Z = tt->getShadeBrightness(level, pX, pY, pZ + 1);
// 4J - these changes brought forward from 1.2.3
int centerColor = tt->getLightColor(level, pX, pY, pZ);
int ccx00 = centerColor;
int cc0y0 = centerColor;
int cc00z = centerColor;
int ccX00 = centerColor;
int cc0Y0 = centerColor;
int cc00Z = centerColor;
if (tileShapeY0 <= 0 || !level->isSolidRenderTile(pX, pY - 1, pZ))
cc0y0 = tt->getLightColor(level, pX, pY - 1, pZ);
if (tileShapeY1 >= 1 || !level->isSolidRenderTile(pX, pY + 1, pZ))
cc0Y0 = tt->getLightColor(level, pX, pY + 1, pZ);
if (tileShapeX0 <= 0 || !level->isSolidRenderTile(pX - 1, pY, pZ))
ccx00 = tt->getLightColor(level, pX - 1, pY, pZ);
if (tileShapeX1 >= 1 || !level->isSolidRenderTile(pX + 1, pY, pZ))
ccX00 = tt->getLightColor(level, pX + 1, pY, pZ);
if (tileShapeZ0 <= 0 || !level->isSolidRenderTile(pX, pY, pZ - 1))
cc00z = tt->getLightColor(level, pX, pY, pZ - 1);
if (tileShapeZ1 >= 1 || !level->isSolidRenderTile(pX, pY, pZ + 1))
cc00Z = tt->getLightColor(level, pX, pY, pZ + 1);
Tesselator_SPU* t = getTesselator();
t->tex2(0xf000f);
llTransXY0 =
level->m_tileData.transculent[level->getTile(pX + 1, pY + 1, pZ)];
llTransXy0 =
level->m_tileData.transculent[level->getTile(pX + 1, pY - 1, pZ)];
llTransX0Z =
level->m_tileData.transculent[level->getTile(pX + 1, pY, pZ + 1)];
llTransX0z =
level->m_tileData.transculent[level->getTile(pX + 1, pY, pZ - 1)];
llTransxY0 =
level->m_tileData.transculent[level->getTile(pX - 1, pY + 1, pZ)];
llTransxy0 =
level->m_tileData.transculent[level->getTile(pX - 1, pY - 1, pZ)];
llTransx0z =
level->m_tileData.transculent[level->getTile(pX - 1, pY, pZ - 1)];
llTransx0Z =
level->m_tileData.transculent[level->getTile(pX - 1, pY, pZ + 1)];
llTrans0YZ =
level->m_tileData.transculent[level->getTile(pX, pY + 1, pZ + 1)];
llTrans0Yz =
level->m_tileData.transculent[level->getTile(pX, pY + 1, pZ - 1)];
llTrans0yZ =
level->m_tileData.transculent[level->getTile(pX, pY - 1, pZ + 1)];
llTrans0yz =
level->m_tileData.transculent[level->getTile(pX, pY - 1, pZ - 1)];
if (getTexture(tt) == &Tile_SPU::ms_pTileData->grass_iconTop)
tint0 = tint2 = tint3 = tint4 = tint5 = false;
if (hasFixedTexture()) tint0 = tint2 = tint3 = tint4 = tint5 = false;
if (faceFlags & 0x01) {
if (blsmooth > 0) {
if (tileShapeY0 <= 0)
pY--; // 4J - condition brought forwardEnterCriticalSection
// from 1.2.3
ccxy0 = tt->getLightColor(level, pX - 1, pY, pZ);
cc0yz = tt->getLightColor(level, pX, pY, pZ - 1);
cc0yZ = tt->getLightColor(level, pX, pY, pZ + 1);
ccXy0 = tt->getLightColor(level, pX + 1, pY, pZ);
llxy0 = tt->getShadeBrightness(level, pX - 1, pY, pZ);
ll0yz = tt->getShadeBrightness(level, pX, pY, pZ - 1);
ll0yZ = tt->getShadeBrightness(level, pX, pY, pZ + 1);
llXy0 = tt->getShadeBrightness(level, pX + 1, pY, pZ);
if (llTrans0yz || llTransxy0) {
llxyz = tt->getShadeBrightness(level, pX - 1, pY, pZ - 1);
ccxyz = tt->getLightColor(level, pX - 1, pY, pZ - 1);
} else {
llxyz = llxy0;
ccxyz = ccxy0;
}
if (llTrans0yZ || llTransxy0) {
llxyZ = tt->getShadeBrightness(level, pX - 1, pY, pZ + 1);
ccxyZ = tt->getLightColor(level, pX - 1, pY, pZ + 1);
} else {
llxyZ = llxy0;
ccxyZ = ccxy0;
}
if (llTrans0yz || llTransXy0) {
llXyz = tt->getShadeBrightness(level, pX + 1, pY, pZ - 1);
ccXyz = tt->getLightColor(level, pX + 1, pY, pZ - 1);
} else {
llXyz = llXy0;
ccXyz = ccXy0;
}
if (llTrans0yZ || llTransXy0) {
llXyZ = tt->getShadeBrightness(level, pX + 1, pY, pZ + 1);
ccXyZ = tt->getLightColor(level, pX + 1, pY, pZ + 1);
} else {
llXyZ = llXy0;
ccXyZ = ccXy0;
}
if (tileShapeY0 <= 0)
pY++; // 4J - condition brought forward from 1.2.3
ll1 = (llxyZ + llxy0 + ll0yZ + ll0y0) / 4.0f;
ll4 = (ll0yZ + ll0y0 + llXyZ + llXy0) / 4.0f;
ll3 = (ll0y0 + ll0yz + llXy0 + llXyz) / 4.0f;
ll2 = (llxy0 + llxyz + ll0y0 + ll0yz) / 4.0f;
tc1 = blend(ccxyZ, ccxy0, cc0yZ, cc0y0);
tc4 = blend(cc0yZ, ccXyZ, ccXy0, cc0y0);
tc3 = blend(cc0yz, ccXy0, ccXyz, cc0y0);
tc2 = blend(ccxy0, ccxyz, cc0yz, cc0y0);
} else {
ll1 = ll2 = ll3 = ll4 = ll0y0;
tc1 = tc2 = tc3 = tc4 = ccxy0;
}
c1r = c2r = c3r = c4r = (tint0 ? pBaseRed : 1.0f) * 0.5f;
c1g = c2g = c3g = c4g = (tint0 ? pBaseGreen : 1.0f) * 0.5f;
c1b = c2b = c3b = c4b = (tint0 ? pBaseBlue : 1.0f) * 0.5f;
c1r *= ll1;
c1g *= ll1;
c1b *= ll1;
c2r *= ll2;
c2g *= ll2;
c2b *= ll2;
c3r *= ll3;
c3g *= ll3;
c3b *= ll3;
c4r *= ll4;
c4g *= ll4;
c4b *= ll4;
renderFaceDown(tt, (float)pX, (float)pY, (float)pZ,
getTexture(tt, level, pX, pY, pZ, 0));
}
if (faceFlags & 0x02) {
if (blsmooth > 0) {
if (tileShapeY1 >= 1)
pY++; // 4J - condition brought forward from 1.2.3
ccxY0 = tt->getLightColor(level, pX - 1, pY, pZ);
ccXY0 = tt->getLightColor(level, pX + 1, pY, pZ);
cc0Yz = tt->getLightColor(level, pX, pY, pZ - 1);
cc0YZ = tt->getLightColor(level, pX, pY, pZ + 1);
llxY0 = tt->getShadeBrightness(level, pX - 1, pY, pZ);
llXY0 = tt->getShadeBrightness(level, pX + 1, pY, pZ);
ll0Yz = tt->getShadeBrightness(level, pX, pY, pZ - 1);
ll0YZ = tt->getShadeBrightness(level, pX, pY, pZ + 1);
if (llTrans0Yz || llTransxY0) {
llxYz = tt->getShadeBrightness(level, pX - 1, pY, pZ - 1);
ccxYz = tt->getLightColor(level, pX - 1, pY, pZ - 1);
} else {
llxYz = llxY0;
ccxYz = ccxY0;
}
if (llTrans0Yz || llTransXY0) {
llXYz = tt->getShadeBrightness(level, pX + 1, pY, pZ - 1);
ccXYz = tt->getLightColor(level, pX + 1, pY, pZ - 1);
} else {
llXYz = llXY0;
ccXYz = ccXY0;
}
if (llTrans0YZ || llTransxY0) {
llxYZ = tt->getShadeBrightness(level, pX - 1, pY, pZ + 1);
ccxYZ = tt->getLightColor(level, pX - 1, pY, pZ + 1);
} else {
llxYZ = llxY0;
ccxYZ = ccxY0;
}
if (llTrans0YZ || llTransXY0) {
llXYZ = tt->getShadeBrightness(level, pX + 1, pY, pZ + 1);
ccXYZ = tt->getLightColor(level, pX + 1, pY, pZ + 1);
} else {
llXYZ = llXY0;
ccXYZ = ccXY0;
}
if (tileShapeY1 >= 1)
pY--; // 4J - condition brought forward from 1.2.3
ll4 = (llxYZ + llxY0 + ll0YZ + ll0Y0) / 4.0f;
ll1 = (ll0YZ + ll0Y0 + llXYZ + llXY0) / 4.0f;
ll2 = (ll0Y0 + ll0Yz + llXY0 + llXYz) / 4.0f;
ll3 = (llxY0 + llxYz + ll0Y0 + ll0Yz) / 4.0f;
tc4 = blend(ccxYZ, ccxY0, cc0YZ, cc0Y0);
tc1 = blend(cc0YZ, ccXYZ, ccXY0, cc0Y0);
tc2 = blend(cc0Yz, ccXY0, ccXYz, cc0Y0);
tc3 = blend(ccxY0, ccxYz, cc0Yz, cc0Y0);
} else {
ll1 = ll2 = ll3 = ll4 = ll0Y0;
tc1 = tc2 = tc3 = tc4 = cc0Y0;
}
c1r = c2r = c3r = c4r = (tint1 ? pBaseRed : 1.0f);
c1g = c2g = c3g = c4g = (tint1 ? pBaseGreen : 1.0f);
c1b = c2b = c3b = c4b = (tint1 ? pBaseBlue : 1.0f);
c1r *= ll1;
c1g *= ll1;
c1b *= ll1;
c2r *= ll2;
c2g *= ll2;
c2b *= ll2;
c3r *= ll3;
c3g *= ll3;
c3b *= ll3;
c4r *= ll4;
c4g *= ll4;
c4b *= ll4;
renderFaceUp(tt, (float)pX, (float)pY, (float)pZ,
getTexture(tt, level, pX, pY, pZ, 1));
}
if (faceFlags & 0x04) {
if (blsmooth > 0) {
if (tileShapeZ0 <= 0)
pZ--; // 4J - condition brought forward from 1.2.3
llx0z = tt->getShadeBrightness(level, pX - 1, pY, pZ);
ll0yz = tt->getShadeBrightness(level, pX, pY - 1, pZ);
ll0Yz = tt->getShadeBrightness(level, pX, pY + 1, pZ);
llX0z = tt->getShadeBrightness(level, pX + 1, pY, pZ);
ccx0z = tt->getLightColor(level, pX - 1, pY, pZ);
cc0yz = tt->getLightColor(level, pX, pY - 1, pZ);
cc0Yz = tt->getLightColor(level, pX, pY + 1, pZ);
ccX0z = tt->getLightColor(level, pX + 1, pY, pZ);
if (llTransx0z || llTrans0yz) {
llxyz = tt->getShadeBrightness(level, pX - 1, pY - 1, pZ);
ccxyz = tt->getLightColor(level, pX - 1, pY - 1, pZ);
} else {
llxyz = llx0z;
ccxyz = ccx0z;
}
if (llTransx0z || llTrans0Yz) {
llxYz = tt->getShadeBrightness(level, pX - 1, pY + 1, pZ);
ccxYz = tt->getLightColor(level, pX - 1, pY + 1, pZ);
} else {
llxYz = llx0z;
ccxYz = ccx0z;
}
if (llTransX0z || llTrans0yz) {
llXyz = tt->getShadeBrightness(level, pX + 1, pY - 1, pZ);
ccXyz = tt->getLightColor(level, pX + 1, pY - 1, pZ);
} else {
llXyz = llX0z;
ccXyz = ccX0z;
}
if (llTransX0z || llTrans0Yz) {
llXYz = tt->getShadeBrightness(level, pX + 1, pY + 1, pZ);
ccXYz = tt->getLightColor(level, pX + 1, pY + 1, pZ);
} else {
llXYz = llX0z;
ccXYz = ccX0z;
}
if (tileShapeZ0 <= 0)
pZ++; // 4J - condition brought forward from 1.2.3
#ifdef _XBOX
#pragma message(__LOC__ "ambientOcclusion NEEDS CHANGED FROM A BOOL ")
#endif
if (smoothShapeLighting &&
g_ambientOcclusionMax) // minecraft->options->ambientOcclusion
// >= Options::AO_MAX)
{
float _ll1 = (llx0z + llxYz + ll00z + ll0Yz) / 4.0f;
float _ll2 = (ll00z + ll0Yz + llX0z + llXYz) / 4.0f;
float _ll3 = (ll0yz + ll00z + llXyz + llX0z) / 4.0f;
float _ll4 = (llxyz + llx0z + ll0yz + ll00z) / 4.0f;
ll1 = (float)(_ll1 * tileShapeY1 * (1.0 - tileShapeX0) +
_ll2 * tileShapeY0 * tileShapeX0 +
_ll3 * (1.0 - tileShapeY1) * tileShapeX0 +
_ll4 * (1.0 - tileShapeY1) * (1.0 - tileShapeX0));
ll2 = (float)(_ll1 * tileShapeY1 * (1.0 - tileShapeX1) +
_ll2 * tileShapeY1 * tileShapeX1 +
_ll3 * (1.0 - tileShapeY1) * tileShapeX1 +
_ll4 * (1.0 - tileShapeY1) * (1.0 - tileShapeX1));
ll3 = (float)(_ll1 * tileShapeY0 * (1.0 - tileShapeX1) +
_ll2 * tileShapeY0 * tileShapeX1 +
_ll3 * (1.0 - tileShapeY0) * tileShapeX1 +
_ll4 * (1.0 - tileShapeY0) * (1.0 - tileShapeX1));
ll4 = (float)(_ll1 * tileShapeY0 * (1.0 - tileShapeX0) +
_ll2 * tileShapeY0 * tileShapeX0 +
_ll3 * (1.0 - tileShapeY0) * tileShapeX0 +
_ll4 * (1.0 - tileShapeY0) * (1.0 - tileShapeX0));
int _tc1 = blend(ccx0z, ccxYz, cc0Yz, cc00z);
int _tc2 = blend(cc0Yz, ccX0z, ccXYz, cc00z);
int _tc3 = blend(cc0yz, ccXyz, ccX0z, cc00z);
int _tc4 = blend(ccxyz, ccx0z, cc0yz, cc00z);
tc1 = blend(_tc1, _tc2, _tc3, _tc4,
tileShapeY1 * (1.0 - tileShapeX0),
tileShapeY1 * tileShapeX0,
(1.0 - tileShapeY1) * tileShapeX0,
(1.0 - tileShapeY1) * (1.0 - tileShapeX0));
tc2 = blend(_tc1, _tc2, _tc3, _tc4,
tileShapeY1 * (1.0 - tileShapeX1),
tileShapeY1 * tileShapeX1,
(1.0 - tileShapeY1) * tileShapeX1,
(1.0 - tileShapeY1) * (1.0 - tileShapeX1));
tc3 = blend(_tc1, _tc2, _tc3, _tc4,
tileShapeY0 * (1.0 - tileShapeX1),
tileShapeY0 * tileShapeX1,
(1.0 - tileShapeY0) * tileShapeX1,
(1.0 - tileShapeY0) * (1.0 - tileShapeX1));
tc4 = blend(_tc1, _tc2, _tc3, _tc4,
tileShapeY0 * (1.0 - tileShapeX0),
tileShapeY0 * tileShapeX0,
(1.0 - tileShapeY0) * tileShapeX0,
(1.0 - tileShapeY0) * (1.0 - tileShapeX0));
} else {
ll1 = (llx0z + llxYz + ll00z + ll0Yz) / 4.0f;
ll2 = (ll00z + ll0Yz + llX0z + llXYz) / 4.0f;
ll3 = (ll0yz + ll00z + llXyz + llX0z) / 4.0f;
ll4 = (llxyz + llx0z + ll0yz + ll00z) / 4.0f;
tc1 = blend(ccx0z, ccxYz, cc0Yz, cc00z);
tc2 = blend(cc0Yz, ccX0z, ccXYz, cc00z);
tc3 = blend(cc0yz, ccXyz, ccX0z, cc00z);
tc4 = blend(ccxyz, ccx0z, cc0yz, cc00z);
}
} else {
ll1 = ll2 = ll3 = ll4 = ll00z;
tc1 = tc2 = tc3 = tc4 = cc00z;
}
c1r = c2r = c3r = c4r = (tint2 ? pBaseRed : 1.0f) * 0.8f;
c1g = c2g = c3g = c4g = (tint2 ? pBaseGreen : 1.0f) * 0.8f;
c1b = c2b = c3b = c4b = (tint2 ? pBaseBlue : 1.0f) * 0.8f;
c1r *= ll1;
c1g *= ll1;
c1b *= ll1;
c2r *= ll2;
c2g *= ll2;
c2b *= ll2;
c3r *= ll3;
c3g *= ll3;
c3b *= ll3;
c4r *= ll4;
c4g *= ll4;
c4b *= ll4;
Icon_SPU* tex = getTexture(tt, level, pX, pY, pZ, 2);
renderNorth(tt, (float)pX, (float)pY, (float)pZ, tex);
if (fancy &&
(tex == &Tile_SPU::ms_pTileData->iconData[Tile_SPU::grass_Id] &&
!hasFixedTexture())) {
c1r *= pBaseRed;
c2r *= pBaseRed;
c3r *= pBaseRed;
c4r *= pBaseRed;
c1g *= pBaseGreen;
c2g *= pBaseGreen;
c3g *= pBaseGreen;
c4g *= pBaseGreen;
c1b *= pBaseBlue;
c2b *= pBaseBlue;
c3b *= pBaseBlue;
c4b *= pBaseBlue;
bool prev = t->setMipmapEnable(
false); // 4J added - this is rendering the little bit of grass
// at the top of the side of dirt, don't mipmap it
renderNorth(tt, (float)pX, (float)pY, (float)pZ,
GrassTile_SPU::getSideTextureOverlay());
t->setMipmapEnable(prev);
}
}
if (faceFlags & 0x08) {
if (blsmooth > 0) {
if (tileShapeZ1 >= 1)
pZ++; // 4J - condition brought forward from 1.2.3
llx0Z = tt->getShadeBrightness(level, pX - 1, pY, pZ);
llX0Z = tt->getShadeBrightness(level, pX + 1, pY, pZ);
ll0yZ = tt->getShadeBrightness(level, pX, pY - 1, pZ);
ll0YZ = tt->getShadeBrightness(level, pX, pY + 1, pZ);
ccx0Z = tt->getLightColor(level, pX - 1, pY, pZ);
ccX0Z = tt->getLightColor(level, pX + 1, pY, pZ);
cc0yZ = tt->getLightColor(level, pX, pY - 1, pZ);
cc0YZ = tt->getLightColor(level, pX, pY + 1, pZ);
if (llTransx0Z || llTrans0yZ) {
llxyZ = tt->getShadeBrightness(level, pX - 1, pY - 1, pZ);
ccxyZ = tt->getLightColor(level, pX - 1, pY - 1, pZ);
} else {
llxyZ = llx0Z;
ccxyZ = ccx0Z;
}
if (llTransx0Z || llTrans0YZ) {
llxYZ = tt->getShadeBrightness(level, pX - 1, pY + 1, pZ);
ccxYZ = tt->getLightColor(level, pX - 1, pY + 1, pZ);
} else {
llxYZ = llx0Z;
ccxYZ = ccx0Z;
}
if (llTransX0Z || llTrans0yZ) {
llXyZ = tt->getShadeBrightness(level, pX + 1, pY - 1, pZ);
ccXyZ = tt->getLightColor(level, pX + 1, pY - 1, pZ);
} else {
llXyZ = llX0Z;
ccXyZ = ccX0Z;
}
if (llTransX0Z || llTrans0YZ) {
llXYZ = tt->getShadeBrightness(level, pX + 1, pY + 1, pZ);
ccXYZ = tt->getLightColor(level, pX + 1, pY + 1, pZ);
} else {
llXYZ = llX0Z;
ccXYZ = ccX0Z;
}
if (tileShapeZ1 >= 1)
pZ--; // 4J - condition brought forward from 1.2.3
if (smoothShapeLighting &&
g_ambientOcclusionMax) // minecraft->options->ambientOcclusion
// >= Options::AO_MAX)
{
float _ll1 = (llx0Z + llxYZ + ll00Z + ll0YZ) / 4.0f;
float _ll4 = (ll00Z + ll0YZ + llX0Z + llXYZ) / 4.0f;
float _ll3 = (ll0yZ + ll00Z + llXyZ + llX0Z) / 4.0f;
float _ll2 = (llxyZ + llx0Z + ll0yZ + ll00Z) / 4.0f;
ll1 = (float)(_ll1 * tileShapeY1 * (1.0 - tileShapeX0) +
_ll4 * tileShapeY1 * tileShapeX0 +
_ll3 * (1.0 - tileShapeY1) * tileShapeX0 +
_ll2 * (1.0 - tileShapeY1) * (1.0 - tileShapeX0));
ll2 = (float)(_ll1 * tileShapeY0 * (1.0 - tileShapeX0) +
_ll4 * tileShapeY0 * tileShapeX0 +
_ll3 * (1.0 - tileShapeY0) * tileShapeX0 +
_ll2 * (1.0 - tileShapeY0) * (1.0 - tileShapeX0));
ll3 = (float)(_ll1 * tileShapeY0 * (1.0 - tileShapeX1) +
_ll4 * tileShapeY0 * tileShapeX1 +
_ll3 * (1.0 - tileShapeY0) * tileShapeX1 +
_ll2 * (1.0 - tileShapeY0) * (1.0 - tileShapeX1));
ll4 = (float)(_ll1 * tileShapeY1 * (1.0 - tileShapeX1) +
_ll4 * tileShapeY1 * tileShapeX1 +
_ll3 * (1.0 - tileShapeY1) * tileShapeX1 +
_ll2 * (1.0 - tileShapeY1) * (1.0 - tileShapeX1));
int _tc1 = blend(ccx0Z, ccxYZ, cc0YZ, cc00Z);
int _tc4 = blend(cc0YZ, ccX0Z, ccXYZ, cc00Z);
int _tc3 = blend(cc0yZ, ccXyZ, ccX0Z, cc00Z);
int _tc2 = blend(ccxyZ, ccx0Z, cc0yZ, cc00Z);
tc1 = blend(_tc1, _tc2, _tc3, _tc4,
tileShapeY1 * (1.0 - tileShapeX0),
(1.0 - tileShapeY1) * (1.0 - tileShapeX0),
(1.0 - tileShapeY1) * tileShapeX0,
tileShapeY1 * tileShapeX0);
tc2 = blend(_tc1, _tc2, _tc3, _tc4,
tileShapeY0 * (1.0 - tileShapeX0),
(1.0 - tileShapeY0) * (1.0 - tileShapeX0),
(1.0 - tileShapeY0) * tileShapeX0,
tileShapeY0 * tileShapeX0);
tc3 = blend(_tc1, _tc2, _tc3, _tc4,
tileShapeY0 * (1.0 - tileShapeX1),
(1.0 - tileShapeY0) * (1.0 - tileShapeX1),
(1.0 - tileShapeY0) * tileShapeX1,
tileShapeY0 * tileShapeX1);
tc4 = blend(_tc1, _tc2, _tc3, _tc4,
tileShapeY1 * (1.0 - tileShapeX1),
(1.0 - tileShapeY1) * (1.0 - tileShapeX1),
(1.0 - tileShapeY1) * tileShapeX1,
tileShapeY1 * tileShapeX1);
} else {
ll1 = (llx0Z + llxYZ + ll00Z + ll0YZ) / 4.0f;
ll4 = (ll00Z + ll0YZ + llX0Z + llXYZ) / 4.0f;
ll3 = (ll0yZ + ll00Z + llXyZ + llX0Z) / 4.0f;
ll2 = (llxyZ + llx0Z + ll0yZ + ll00Z) / 4.0f;
tc1 = blend(ccx0Z, ccxYZ, cc0YZ, cc00Z);
tc4 = blend(cc0YZ, ccX0Z, ccXYZ, cc00Z);
tc3 = blend(cc0yZ, ccXyZ, ccX0Z, cc00Z);
tc2 = blend(ccxyZ, ccx0Z, cc0yZ, cc00Z);
}
} else {
ll1 = ll2 = ll3 = ll4 = ll00Z;
tc1 = tc2 = tc3 = tc4 = cc00Z;
}
c1r = c2r = c3r = c4r = (tint3 ? pBaseRed : 1.0f) * 0.8f;
c1g = c2g = c3g = c4g = (tint3 ? pBaseGreen : 1.0f) * 0.8f;
c1b = c2b = c3b = c4b = (tint3 ? pBaseBlue : 1.0f) * 0.8f;
c1r *= ll1;
c1g *= ll1;
c1b *= ll1;
c2r *= ll2;
c2g *= ll2;
c2b *= ll2;
c3r *= ll3;
c3g *= ll3;
c3b *= ll3;
c4r *= ll4;
c4g *= ll4;
c4b *= ll4;
Icon_SPU* tex = getTexture(tt, level, pX, pY, pZ, 3);
renderSouth(tt, (float)pX, (float)pY, (float)pZ,
getTexture(tt, level, pX, pY, pZ, 3));
if (fancy &&
(tex == &Tile_SPU::ms_pTileData->iconData[Tile_SPU::grass_Id] &&
!hasFixedTexture())) {
c1r *= pBaseRed;
c2r *= pBaseRed;
c3r *= pBaseRed;
c4r *= pBaseRed;
c1g *= pBaseGreen;
c2g *= pBaseGreen;
c3g *= pBaseGreen;
c4g *= pBaseGreen;
c1b *= pBaseBlue;
c2b *= pBaseBlue;
c3b *= pBaseBlue;
c4b *= pBaseBlue;
bool prev = t->setMipmapEnable(
false); // 4J added - this is rendering the little bit of grass
// at the top of the side of dirt, don't mipmap it
renderSouth(tt, (float)pX, (float)pY, (float)pZ,
GrassTile_SPU::getSideTextureOverlay());
t->setMipmapEnable(prev);
}
}
if (faceFlags & 0x10) {
if (blsmooth > 0) {
if (tileShapeX0 <= 0)
pX--; // 4J - condition brought forward from 1.2.3
llxy0 = tt->getShadeBrightness(level, pX, pY - 1, pZ);
llx0z = tt->getShadeBrightness(level, pX, pY, pZ - 1);
llx0Z = tt->getShadeBrightness(level, pX, pY, pZ + 1);
llxY0 = tt->getShadeBrightness(level, pX, pY + 1, pZ);
ccxy0 = tt->getLightColor(level, pX, pY - 1, pZ);
ccx0z = tt->getLightColor(level, pX, pY, pZ - 1);
ccx0Z = tt->getLightColor(level, pX, pY, pZ + 1);
ccxY0 = tt->getLightColor(level, pX, pY + 1, pZ);
if (llTransx0z || llTransxy0) {
llxyz = tt->getShadeBrightness(level, pX, pY - 1, pZ - 1);
ccxyz = tt->getLightColor(level, pX, pY - 1, pZ - 1);
} else {
llxyz = llx0z;
ccxyz = ccx0z;
}
if (llTransx0Z || llTransxy0) {
llxyZ = tt->getShadeBrightness(level, pX, pY - 1, pZ + 1);
ccxyZ = tt->getLightColor(level, pX, pY - 1, pZ + 1);
} else {
llxyZ = llx0Z;
ccxyZ = ccx0Z;
}
if (llTransx0z || llTransxY0) {
llxYz = tt->getShadeBrightness(level, pX, pY + 1, pZ - 1);
ccxYz = tt->getLightColor(level, pX, pY + 1, pZ - 1);
} else {
llxYz = llx0z;
ccxYz = ccx0z;
}
if (llTransx0Z || llTransxY0) {
llxYZ = tt->getShadeBrightness(level, pX, pY + 1, pZ + 1);
ccxYZ = tt->getLightColor(level, pX, pY + 1, pZ + 1);
} else {
llxYZ = llx0Z;
ccxYZ = ccx0Z;
}
if (tileShapeX0 <= 0)
pX++; // 4J - condition brought forward from 1.2.3
if (smoothShapeLighting &&
g_ambientOcclusionMax) // minecraft->options->ambientOcclusion
// >= Options::AO_MAX)
{
float _ll4 = (llxy0 + llxyZ + llx00 + llx0Z) / 4.0f;
float _ll1 = (llx00 + llx0Z + llxY0 + llxYZ) / 4.0f;
float _ll2 = (llx0z + llx00 + llxYz + llxY0) / 4.0f;
float _ll3 = (llxyz + llxy0 + llx0z + llx00) / 4.0f;
ll1 = (float)(_ll1 * tileShapeY1 * tileShapeZ1 +
_ll2 * tileShapeY1 * (1.0 - tileShapeZ1) +
_ll3 * (1.0 - tileShapeY1) * (1.0 - tileShapeZ1) +
_ll4 * (1.0 - tileShapeY1) * tileShapeZ1);
ll2 = (float)(_ll1 * tileShapeY1 * tileShapeZ0 +
_ll2 * tileShapeY1 * (1.0 - tileShapeZ0) +
_ll3 * (1.0 - tileShapeY1) * (1.0 - tileShapeZ0) +
_ll4 * (1.0 - tileShapeY1) * tileShapeZ0);
ll3 = (float)(_ll1 * tileShapeY0 * tileShapeZ0 +
_ll2 * tileShapeY0 * (1.0 - tileShapeZ0) +
_ll3 * (1.0 - tileShapeY0) * (1.0 - tileShapeZ0) +
_ll4 * (1.0 - tileShapeY0) * tileShapeZ0);
ll4 = (float)(_ll1 * tileShapeY0 * tileShapeZ1 +
_ll2 * tileShapeY0 * (1.0 - tileShapeZ1) +
_ll3 * (1.0 - tileShapeY0) * (1.0 - tileShapeZ1) +
_ll4 * (1.0 - tileShapeY0) * tileShapeZ1);
int _tc4 = blend(ccxy0, ccxyZ, ccx0Z, ccx00);
int _tc1 = blend(ccx0Z, ccxY0, ccxYZ, ccx00);
int _tc2 = blend(ccx0z, ccxYz, ccxY0, ccx00);
int _tc3 = blend(ccxyz, ccxy0, ccx0z, ccx00);
tc1 = blend(_tc1, _tc2, _tc3, _tc4, tileShapeY1 * tileShapeZ1,
tileShapeY1 * (1.0 - tileShapeZ1),
(1.0 - tileShapeY1) * (1.0 - tileShapeZ1),
(1.0 - tileShapeY1) * tileShapeZ1);
tc2 = blend(_tc1, _tc2, _tc3, _tc4, tileShapeY1 * tileShapeZ0,
tileShapeY1 * (1.0 - tileShapeZ0),
(1.0 - tileShapeY1) * (1.0 - tileShapeZ0),
(1.0 - tileShapeY1) * tileShapeZ0);
tc3 = blend(_tc1, _tc2, _tc3, _tc4, tileShapeY0 * tileShapeZ0,
tileShapeY0 * (1.0 - tileShapeZ0),
(1.0 - tileShapeY0) * (1.0 - tileShapeZ0),
(1.0 - tileShapeY0) * tileShapeZ0);
tc4 = blend(_tc1, _tc2, _tc3, _tc4, tileShapeY0 * tileShapeZ1,
tileShapeY0 * (1.0 - tileShapeZ1),
(1.0 - tileShapeY0) * (1.0 - tileShapeZ1),
(1.0 - tileShapeY0) * tileShapeZ1);
} else {
ll4 = (llxy0 + llxyZ + llx00 + llx0Z) / 4.0f;
ll1 = (llx00 + llx0Z + llxY0 + llxYZ) / 4.0f;
ll2 = (llx0z + llx00 + llxYz + llxY0) / 4.0f;
ll3 = (llxyz + llxy0 + llx0z + llx00) / 4.0f;
tc4 = blend(ccxy0, ccxyZ, ccx0Z, ccx00);
tc1 = blend(ccx0Z, ccxY0, ccxYZ, ccx00);
tc2 = blend(ccx0z, ccxYz, ccxY0, ccx00);
tc3 = blend(ccxyz, ccxy0, ccx0z, ccx00);
}
} else {
ll1 = ll2 = ll3 = ll4 = llx00;
tc1 = tc2 = tc3 = tc4 = ccx00;
}
c1r = c2r = c3r = c4r = (tint4 ? pBaseRed : 1.0f) * 0.6f;
c1g = c2g = c3g = c4g = (tint4 ? pBaseGreen : 1.0f) * 0.6f;
c1b = c2b = c3b = c4b = (tint4 ? pBaseBlue : 1.0f) * 0.6f;
c1r *= ll1;
c1g *= ll1;
c1b *= ll1;
c2r *= ll2;
c2g *= ll2;
c2b *= ll2;
c3r *= ll3;
c3g *= ll3;
c3b *= ll3;
c4r *= ll4;
c4g *= ll4;
c4b *= ll4;
Icon_SPU* tex = getTexture(tt, level, pX, pY, pZ, 4);
renderWest(tt, (float)pX, (float)pY, (float)pZ, tex);
if (fancy &&
(tex == &Tile_SPU::ms_pTileData->iconData[Tile_SPU::grass_Id] &&
!hasFixedTexture())) {
c1r *= pBaseRed;
c2r *= pBaseRed;
c3r *= pBaseRed;
c4r *= pBaseRed;
c1g *= pBaseGreen;
c2g *= pBaseGreen;
c3g *= pBaseGreen;
c4g *= pBaseGreen;
c1b *= pBaseBlue;
c2b *= pBaseBlue;
c3b *= pBaseBlue;
c4b *= pBaseBlue;
bool prev = t->setMipmapEnable(
false); // 4J added - this is rendering the little bit of grass
// at the top of the side of dirt, don't mipmap it
renderWest(tt, (float)pX, (float)pY, (float)pZ,
GrassTile_SPU::getSideTextureOverlay());
t->setMipmapEnable(prev);
}
}
if (faceFlags & 0x20) {
if (blsmooth > 0) {
if (tileShapeX1 >= 1)
pX++; // 4J - condition brought forward from 1.2.3
llXy0 = tt->getShadeBrightness(level, pX, pY - 1, pZ);
llX0z = tt->getShadeBrightness(level, pX, pY, pZ - 1);
llX0Z = tt->getShadeBrightness(level, pX, pY, pZ + 1);
llXY0 = tt->getShadeBrightness(level, pX, pY + 1, pZ);
ccXy0 = tt->getLightColor(level, pX, pY - 1, pZ);
ccX0z = tt->getLightColor(level, pX, pY, pZ - 1);
ccX0Z = tt->getLightColor(level, pX, pY, pZ + 1);
ccXY0 = tt->getLightColor(level, pX, pY + 1, pZ);
if (llTransXy0 || llTransX0z) {
llXyz = tt->getShadeBrightness(level, pX, pY - 1, pZ - 1);
ccXyz = tt->getLightColor(level, pX, pY - 1, pZ - 1);
} else {
llXyz = llX0z;
ccXyz = ccX0z;
}
if (llTransXy0 || llTransX0Z) {
llXyZ = tt->getShadeBrightness(level, pX, pY - 1, pZ + 1);
ccXyZ = tt->getLightColor(level, pX, pY - 1, pZ + 1);
} else {
llXyZ = llX0Z;
ccXyZ = ccX0Z;
}
if (llTransXY0 || llTransX0z) {
llXYz = tt->getShadeBrightness(level, pX, pY + 1, pZ - 1);
ccXYz = tt->getLightColor(level, pX, pY + 1, pZ - 1);
} else {
llXYz = llX0z;
ccXYz = ccX0z;
}
if (llTransXY0 || llTransX0Z) {
llXYZ = tt->getShadeBrightness(level, pX, pY + 1, pZ + 1);
ccXYZ = tt->getLightColor(level, pX, pY + 1, pZ + 1);
} else {
llXYZ = llX0Z;
ccXYZ = ccX0Z;
}
if (tileShapeX1 >= 1)
pX--; // 4J - condition brought forward from 1.2.3
if (smoothShapeLighting &&
g_ambientOcclusionMax) // minecraft->options->ambientOcclusion
// >= Options::AO_MAX)
{
float _ll1 = (llXy0 + llXyZ + llX00 + llX0Z) / 4.0f;
float _ll2 = (llXyz + llXy0 + llX0z + llX00) / 4.0f;
float _ll3 = (llX0z + llX00 + llXYz + llXY0) / 4.0f;
float _ll4 = (llX00 + llX0Z + llXY0 + llXYZ) / 4.0f;
ll1 = (float)(_ll1 * (1.0 - tileShapeY0) * tileShapeZ1 +
_ll2 * (1.0 - tileShapeY0) * (1.0 - tileShapeZ1) +
_ll3 * tileShapeY0 * (1.0 - tileShapeZ1) +
_ll4 * tileShapeY0 * tileShapeZ1);
ll2 = (float)(_ll1 * (1.0 - tileShapeY0) * tileShapeZ0 +
_ll2 * (1.0 - tileShapeY0) * (1.0 - tileShapeZ0) +
_ll3 * tileShapeY0 * (1.0 - tileShapeZ0) +
_ll4 * tileShapeY0 * tileShapeZ0);
ll3 = (float)(_ll1 * (1.0 - tileShapeY1) * tileShapeZ0 +
_ll2 * (1.0 - tileShapeY1) * (1.0 - tileShapeZ0) +
_ll3 * tileShapeY1 * (1.0 - tileShapeZ0) +
_ll4 * tileShapeY1 * tileShapeZ0);
ll4 = (float)(_ll1 * (1.0 - tileShapeY1) * tileShapeZ1 +
_ll2 * (1.0 - tileShapeY1) * (1.0 - tileShapeZ1) +
_ll3 * tileShapeY1 * (1.0 - tileShapeZ1) +
_ll4 * tileShapeY1 * tileShapeZ1);
int _tc1 = blend(ccXy0, ccXyZ, ccX0Z, ccX00);
int _tc4 = blend(ccX0Z, ccXY0, ccXYZ, ccX00);
int _tc3 = blend(ccX0z, ccXYz, ccXY0, ccX00);
int _tc2 = blend(ccXyz, ccXy0, ccX0z, ccX00);
tc1 = blend(_tc1, _tc2, _tc3, _tc4,
(1.0 - tileShapeY0) * tileShapeZ1,
(1.0 - tileShapeY0) * (1.0 - tileShapeZ1),
tileShapeY0 * (1.0 - tileShapeZ1),
tileShapeY0 * tileShapeZ1);
tc2 = blend(_tc1, _tc2, _tc3, _tc4,
(1.0 - tileShapeY0) * tileShapeZ0,
(1.0 - tileShapeY0) * (1.0 - tileShapeZ0),
tileShapeY0 * (1.0 - tileShapeZ0),
tileShapeY0 * tileShapeZ0);
tc3 = blend(_tc1, _tc2, _tc3, _tc4,
(1.0 - tileShapeY1) * tileShapeZ0,
(1.0 - tileShapeY1) * (1.0 - tileShapeZ0),
tileShapeY1 * (1.0 - tileShapeZ0),
tileShapeY1 * tileShapeZ0);
tc4 = blend(_tc1, _tc2, _tc3, _tc4,
(1.0 - tileShapeY1) * tileShapeZ1,
(1.0 - tileShapeY1) * (1.0 - tileShapeZ1),
tileShapeY1 * (1.0 - tileShapeZ1),
tileShapeY1 * tileShapeZ1);
} else {
ll1 = (llXy0 + llXyZ + llX00 + llX0Z) / 4.0f;
ll2 = (llXyz + llXy0 + llX0z + llX00) / 4.0f;
ll3 = (llX0z + llX00 + llXYz + llXY0) / 4.0f;
ll4 = (llX00 + llX0Z + llXY0 + llXYZ) / 4.0f;
tc1 = blend(ccXy0, ccXyZ, ccX0Z, ccX00);
tc4 = blend(ccX0Z, ccXY0, ccXYZ, ccX00);
tc3 = blend(ccX0z, ccXYz, ccXY0, ccX00);
tc2 = blend(ccXyz, ccXy0, ccX0z, ccX00);
}
} else {
ll1 = ll2 = ll3 = ll4 = llX00;
tc1 = tc2 = tc3 = tc4 = ccX00;
}
c1r = c2r = c3r = c4r = (tint5 ? pBaseRed : 1.0f) * 0.6f;
c1g = c2g = c3g = c4g = (tint5 ? pBaseGreen : 1.0f) * 0.6f;
c1b = c2b = c3b = c4b = (tint5 ? pBaseBlue : 1.0f) * 0.6f;
c1r *= ll1;
c1g *= ll1;
c1b *= ll1;
c2r *= ll2;
c2g *= ll2;
c2b *= ll2;
c3r *= ll3;
c3g *= ll3;
c3b *= ll3;
c4r *= ll4;
c4g *= ll4;
c4b *= ll4;
Icon_SPU* tex = getTexture(tt, level, pX, pY, pZ, 5);
renderEast(tt, (float)pX, (float)pY, (float)pZ, tex);
if (fancy &&
(tex == &Tile_SPU::ms_pTileData->iconData[Tile_SPU::grass_Id] &&
!hasFixedTexture())) {
c1r *= pBaseRed;
c2r *= pBaseRed;
c3r *= pBaseRed;
c4r *= pBaseRed;
c1g *= pBaseGreen;
c2g *= pBaseGreen;
c3g *= pBaseGreen;
c4g *= pBaseGreen;
c1b *= pBaseBlue;
c2b *= pBaseBlue;
c3b *= pBaseBlue;
c4b *= pBaseBlue;
bool prev = t->setMipmapEnable(
false); // 4J added - this is rendering the little bit of grass
// at the top of the side of dirt, don't mipmap it
renderEast(tt, (float)pX, (float)pY, (float)pZ,
GrassTile_SPU::getSideTextureOverlay());
t->setMipmapEnable(prev);
}
}
applyAmbienceOcclusion = false;
return true;
}
bool TileRenderer_SPU::tesselateBlockInWorldWithAmbienceOcclusionOldLighting(
Tile_SPU* tt, int pX, int pY, int pZ, float pBaseRed, float pBaseGreen,
float pBaseBlue) {
//
// // 4J - added these faceFlags so we can detect whether this block is
// going to have no visible faces and early out
// // the original code checked noCulling and shouldRenderFace directly
// where faceFlags is used now int faceFlags = 0; if (
// noCulling )
// {
// faceFlags = 0x3f;
// }
// else
// {
// faceFlags |= tt->shouldRenderFace( level, pX, pY - 1, pZ, 0 ) ?
// 0x01 : 0; faceFlags |= tt->shouldRenderFace( level, pX, pY
// + 1, pZ, 1 ) ? 0x02 : 0; faceFlags |=
// tt->shouldRenderFace( level, pX, pY, pZ - 1, 2 ) ? 0x04 : 0;
// faceFlags |= tt->shouldRenderFace( level, pX, pY, pZ + 1, 3 ) ? 0x08 : 0;
// faceFlags |= tt->shouldRenderFace( level, pX - 1, pY, pZ, 4 ) ? 0x10 : 0;
// faceFlags |= tt->shouldRenderFace( level, pX + 1, pY, pZ, 5 ) ? 0x20 : 0;
// }
// if ( faceFlags == 0 )
// {
// return false;
// }
//
// applyAmbienceOcclusion = true;
// float ll1 = ll000;
// float ll2 = ll000;
// float ll3 = ll000;
// float ll4 = ll000;
// bool tint0 = true;
// bool tint1 = true;
// bool tint2 = true;
// bool tint3 = true;
// bool tint4 = true;
// bool tint5 = true;
//
//
// ll000 = tt->getBrightness( level, pX, pY, pZ );
// llx00 = tt->getBrightness( level, pX - 1, pY, pZ );
// ll0y0 = tt->getBrightness( level, pX, pY - 1, pZ );
// ll00z = tt->getBrightness( level, pX, pY, pZ - 1 );
// llX00 = tt->getBrightness( level, pX + 1, pY, pZ );
// ll0Y0 = tt->getBrightness( level, pX, pY + 1, pZ );
// ll00Z = tt->getBrightness( level, pX, pY, pZ + 1 );
//
// llTransXY0 = level->m_tileData.transculent[level->getTile( pX + 1, pY +
// 1, pZ )]; llTransXy0 =
// level->m_tileData.transculent[level->getTile( pX + 1, pY - 1, pZ )];
// llTransX0Z = level->m_tileData.transculent[level->getTile( pX + 1, pY, pZ
// + 1 )]; llTransX0z = level->m_tileData.transculent[level->getTile( pX +
// 1, pY, pZ - 1 )]; llTransxY0 =
// level->m_tileData.transculent[level->getTile( pX
// - 1, pY + 1, pZ )]; llTransxy0 =
// level->m_tileData.transculent[level->getTile( pX - 1, pY - 1, pZ )];
// llTransx0z = level->m_tileData.transculent[level->getTile( pX - 1, pY,
// pZ - 1 )]; llTransx0Z =
// level->m_tileData.transculent[level->getTile( pX
// - 1, pY, pZ + 1 )]; llTrans0YZ =
// level->m_tileData.transculent[level->getTile( pX, pY + 1, pZ + 1 )];
// llTrans0Yz = level->m_tileData.transculent[level->getTile( pX, pY + 1,
// pZ - 1 )]; llTrans0yZ =
// level->m_tileData.transculent[level->getTile( pX, pY - 1, pZ + 1 )];
// llTrans0yz = level->m_tileData.transculent[level->getTile( pX, pY - 1, pZ
// - 1 )];
//
// spu_print("Have to add texture name check here\n");
// if ( getTexture(tt)->getName().compare(L"grass_top") == 0 ) tint0 =
// tint2 = tint3 = tint4 = tint5 = false; if ( hasFixedTexture() ) tint0 =
// tint2 = tint3 = tint4 = tint5 = false;
//
// if ( faceFlags & 0x01 )
// {
// if ( blsmooth > 0 )
// {
// pY--;
//
// llxy0 = tt->getBrightness( level, pX - 1, pY, pZ );
// ll0yz = tt->getBrightness( level, pX, pY, pZ - 1 );
// ll0yZ = tt->getBrightness( level, pX, pY, pZ + 1 );
// llXy0 = tt->getBrightness( level, pX + 1, pY, pZ );
//
// if ( llTrans0yz || llTransxy0 )
// {
// llxyz = tt->getBrightness( level, pX - 1, pY, pZ
// - 1 );
// }
// else
// {
// llxyz = llxy0;
// }
// if ( llTrans0yZ || llTransxy0 )
// {
// llxyZ = tt->getBrightness( level, pX - 1, pY, pZ
// + 1 );
// }
// else
// {
// llxyZ = llxy0;
// }
// if ( llTrans0yz || llTransXy0 )
// {
// llXyz = tt->getBrightness( level, pX + 1, pY, pZ
// - 1 );
// }
// else
// {
// llXyz = llXy0;
// }
// if ( llTrans0yZ || llTransXy0 )
// {
// llXyZ = tt->getBrightness( level, pX + 1, pY, pZ
// + 1 );
// }
// else
// {
// llXyZ = llXy0;
// }
//
// pY++;
// ll1 = ( llxyZ + llxy0 + ll0yZ + ll0y0 ) / 4.0f;
// ll4 = ( ll0yZ + ll0y0 + llXyZ + llXy0 ) / 4.0f;
// ll3 = ( ll0y0 + ll0yz + llXy0 + llXyz ) / 4.0f;
// ll2 = ( llxy0 + llxyz + ll0y0 + ll0yz ) / 4.0f;
// }
// else
// {
// ll1 = ll2 = ll3 = ll4 = ll0y0;
// }
// c1r = c2r = c3r = c4r = ( tint0 ? pBaseRed : 1.0f ) * 0.5f;
// c1g = c2g = c3g = c4g = ( tint0 ? pBaseGreen : 1.0f ) * 0.5f;
// c1b = c2b = c3b = c4b = ( tint0 ? pBaseBlue : 1.0f ) * 0.5f;
// c1r *= ll1;
// c1g *= ll1;
// c1b *= ll1;
// c2r *= ll2;
// c2g *= ll2;
// c2b *= ll2;
// c3r *= ll3;
// c3g *= ll3;
// c3b *= ll3;
// c4r *= ll4;
// c4g *= ll4;
// c4b *= ll4;
//
// renderFaceDown( tt, ( float )pX, ( float )pY, ( float )pZ,
// getTexture( tt, level, pX, pY, pZ, 0 ) );
// }
// if ( faceFlags & 0x02 )
// {
// if ( blsmooth > 0 )
// {
// pY++;
//
// llxY0 = tt->getBrightness( level, pX - 1, pY, pZ );
// llXY0 = tt->getBrightness( level, pX + 1, pY, pZ );
// ll0Yz = tt->getBrightness( level, pX, pY, pZ - 1 );
// ll0YZ = tt->getBrightness( level, pX, pY, pZ + 1 );
//
// if ( llTrans0Yz || llTransxY0 )
// {
// llxYz = tt->getBrightness( level, pX - 1, pY, pZ
// - 1 );
// }
// else
// {
// llxYz = llxY0;
// }
// if ( llTrans0Yz || llTransXY0 )
// {
// llXYz = tt->getBrightness( level, pX + 1, pY, pZ
// - 1 );
// }
// else
// {
// llXYz = llXY0;
// }
// if ( llTrans0YZ || llTransxY0 )
// {
// llxYZ = tt->getBrightness( level, pX - 1, pY, pZ
// + 1 );
// }
// else
// {
// llxYZ = llxY0;
// }
// if ( llTrans0YZ || llTransXY0 )
// {
// llXYZ = tt->getBrightness( level, pX + 1, pY, pZ
// + 1 );
// }
// else
// {
// llXYZ = llXY0;
// }
// pY--;
//
// ll4 = ( llxYZ + llxY0 + ll0YZ + ll0Y0 ) / 4.0f;
// ll1 = ( ll0YZ + ll0Y0 + llXYZ + llXY0 ) / 4.0f;
// ll2 = ( ll0Y0 + ll0Yz + llXY0 + llXYz ) / 4.0f;
// ll3 = ( llxY0 + llxYz + ll0Y0 + ll0Yz ) / 4.0f;
// }
// else
// {
// ll1 = ll2 = ll3 = ll4 = ll0Y0;
// }
// c1r = c2r = c3r = c4r = ( tint1 ? pBaseRed : 1.0f );
// c1g = c2g = c3g = c4g = ( tint1 ? pBaseGreen : 1.0f );
// c1b = c2b = c3b = c4b = ( tint1 ? pBaseBlue : 1.0f );
// c1r *= ll1;
// c1g *= ll1;
// c1b *= ll1;
// c2r *= ll2;
// c2g *= ll2;
// c2b *= ll2;
// c3r *= ll3;
// c3g *= ll3;
// c3b *= ll3;
// c4r *= ll4;
// c4g *= ll4;
// c4b *= ll4;
// renderFaceUp( tt, ( float )pX, ( float )pY, ( float )pZ,
// getTexture( tt, level, pX, pY, pZ, 1 ) );
// }
// if ( faceFlags & 0x04 )
// {
// if ( blsmooth > 0 )
// {
// pZ--;
// llx0z = tt->getBrightness( level, pX - 1, pY, pZ );
// ll0yz = tt->getBrightness( level, pX, pY - 1, pZ );
// ll0Yz = tt->getBrightness( level, pX, pY + 1, pZ );
// llX0z = tt->getBrightness( level, pX + 1, pY, pZ );
//
// if ( llTransx0z || llTrans0yz )
// {
// llxyz = tt->getBrightness( level, pX - 1, pY -
// 1, pZ );
// }
// else
// {
// llxyz = llx0z;
// }
// if ( llTransx0z || llTrans0Yz )
// {
// llxYz = tt->getBrightness( level, pX - 1, pY +
// 1, pZ );
// }
// else
// {
// llxYz = llx0z;
// }
// if ( llTransX0z || llTrans0yz )
// {
// llXyz = tt->getBrightness( level, pX + 1, pY -
// 1, pZ );
// }
// else
// {
// llXyz = llX0z;
// }
// if ( llTransX0z || llTrans0Yz )
// {
// llXYz = tt->getBrightness( level, pX + 1, pY +
// 1, pZ );
// }
// else
// {
// llXYz = llX0z;
// }
// pZ++;
// ll1 = ( llx0z + llxYz + ll00z + ll0Yz ) / 4.0f;
// ll2 = ( ll00z + ll0Yz + llX0z + llXYz ) / 4.0f;
// ll3 = ( ll0yz + ll00z + llXyz + llX0z ) / 4.0f;
// ll4 = ( llxyz + llx0z + ll0yz + ll00z ) / 4.0f;
// }
// else
// {
// ll1 = ll2 = ll3 = ll4 = ll00z;
// }
// c1r = c2r = c3r = c4r = ( tint2 ? pBaseRed : 1.0f ) * 0.8f;
// c1g = c2g = c3g = c4g = ( tint2 ? pBaseGreen : 1.0f ) * 0.8f;
// c1b = c2b = c3b = c4b = ( tint2 ? pBaseBlue : 1.0f ) * 0.8f;
// c1r *= ll1;
// c1g *= ll1;
// c1b *= ll1;
// c2r *= ll2;
// c2g *= ll2;
// c2b *= ll2;
// c3r *= ll3;
// c3g *= ll3;
// c3b *= ll3;
// c4r *= ll4;
// c4g *= ll4;
// c4b *= ll4;
//
// Icon_SPU *tex = getTexture(tt, level, pX, pY, pZ, 2);
// renderNorth( tt, ( float )pX, ( float )pY, ( float )pZ, tex );
//
// if ( fancy && (tex->getName().compare(L"grass_side") == 0) &&
// !hasFixedTexture())
// {
// c1r *= pBaseRed;
// c2r *= pBaseRed;
// c3r *= pBaseRed;
// c4r *= pBaseRed;
// c1g *= pBaseGreen;
// c2g *= pBaseGreen;
// c3g *= pBaseGreen;
// c4g *= pBaseGreen;
// c1b *= pBaseBlue;
// c2b *= pBaseBlue;
// c3b *= pBaseBlue;
// c4b *= pBaseBlue;
// renderNorth( tt, ( float )pX, ( float )pY, ( float )pZ,
// getGrassSideTextureOverlay() );
// }
// }
// if ( faceFlags & 0x08 )
// {
// if ( blsmooth > 0 )
// {
// pZ++;
//
// llx0Z = tt->getBrightness( level, pX - 1, pY, pZ );
// llX0Z = tt->getBrightness( level, pX + 1, pY, pZ );
// ll0yZ = tt->getBrightness( level, pX, pY - 1, pZ );
// ll0YZ = tt->getBrightness( level, pX, pY + 1, pZ );
//
// if ( llTransx0Z || llTrans0yZ )
// {
// llxyZ = tt->getBrightness( level, pX - 1, pY -
// 1, pZ );
// }
// else
// {
// llxyZ = llx0Z;
// }
// if ( llTransx0Z || llTrans0YZ )
// {
// llxYZ = tt->getBrightness( level, pX - 1, pY +
// 1, pZ );
// }
// else
// {
// llxYZ = llx0Z;
// }
// if ( llTransX0Z || llTrans0yZ )
// {
// llXyZ = tt->getBrightness( level, pX + 1, pY -
// 1, pZ );
// }
// else
// {
// llXyZ = llX0Z;
// }
// if ( llTransX0Z || llTrans0YZ )
// {
// llXYZ = tt->getBrightness( level, pX + 1, pY +
// 1, pZ );
// }
// else
// {
// llXYZ = llX0Z;
// }
// pZ--;
// ll1 = ( llx0Z + llxYZ + ll00Z + ll0YZ ) / 4.0f;
// ll4 = ( ll00Z + ll0YZ + llX0Z + llXYZ ) / 4.0f;
// ll3 = ( ll0yZ + ll00Z + llXyZ + llX0Z ) / 4.0f;
// ll2 = ( llxyZ + llx0Z + ll0yZ + ll00Z ) / 4.0f;
// }
// else
// {
// ll1 = ll2 = ll3 = ll4 = ll00Z;
// }
// c1r = c2r = c3r = c4r = ( tint3 ? pBaseRed : 1.0f ) * 0.8f;
// c1g = c2g = c3g = c4g = ( tint3 ? pBaseGreen : 1.0f ) * 0.8f;
// c1b = c2b = c3b = c4b = ( tint3 ? pBaseBlue : 1.0f ) * 0.8f;
// c1r *= ll1;
// c1g *= ll1;
// c1b *= ll1;
// c2r *= ll2;
// c2g *= ll2;
// c2b *= ll2;
// c3r *= ll3;
// c3g *= ll3;
// c3b *= ll3;
// c4r *= ll4;
// c4g *= ll4;
// c4b *= ll4;
// Icon_SPU *tex = getTexture(tt, level, pX, pY, pZ, 3);
// renderSouth( tt, ( float )pX, ( float )pY, ( float )pZ,
// getTexture(tt, level, pX, pY, pZ, 3 ) ); if ( fancy &&
// (tex->getName().compare(L"grass_side") == 0) && !hasFixedTexture() )
// {
// c1r *= pBaseRed;
// c2r *= pBaseRed;
// c3r *= pBaseRed;
// c4r *= pBaseRed;
// c1g *= pBaseGreen;
// c2g *= pBaseGreen;
// c3g *= pBaseGreen;
// c4g *= pBaseGreen;
// c1b *= pBaseBlue;
// c2b *= pBaseBlue;
// c3b *= pBaseBlue;
// c4b *= pBaseBlue;
// renderSouth( tt, ( float )pX, ( float )pY, ( float )pZ,
// getGrassSideTextureOverlay() );
// }
// }
// if ( faceFlags & 0x10 )
// {
// if ( blsmooth > 0 )
// {
// pX--;
// llxy0 = tt->getBrightness( level, pX, pY - 1, pZ );
// llx0z = tt->getBrightness( level, pX, pY, pZ - 1 );
// llx0Z = tt->getBrightness( level, pX, pY, pZ + 1 );
// llxY0 = tt->getBrightness( level, pX, pY + 1, pZ );
//
// if ( llTransx0z || llTransxy0 )
// {
// llxyz = tt->getBrightness( level, pX, pY - 1, pZ
// - 1 );
// }
// else
// {
// llxyz = llx0z;
// }
// if ( llTransx0Z || llTransxy0 )
// {
// llxyZ = tt->getBrightness( level, pX, pY - 1, pZ
// + 1 );
// }
// else
// {
// llxyZ = llx0Z;
// }
// if ( llTransx0z || llTransxY0 )
// {
// llxYz = tt->getBrightness( level, pX, pY + 1, pZ
// - 1 );
// }
// else
// {
// llxYz = llx0z;
// }
// if ( llTransx0Z || llTransxY0 )
// {
// llxYZ = tt->getBrightness( level, pX, pY + 1, pZ
// + 1 );
// }
// else
// {
// llxYZ = llx0Z;
// }
// pX++;
// ll4 = ( llxy0 + llxyZ + llx00 + llx0Z ) / 4.0f;
// ll1 = ( llx00 + llx0Z + llxY0 + llxYZ ) / 4.0f;
// ll2 = ( llx0z + llx00 + llxYz + llxY0 ) / 4.0f;
// ll3 = ( llxyz + llxy0 + llx0z + llx00 ) / 4.0f;
// }
// else
// {
// ll1 = ll2 = ll3 = ll4 = llx00;
// }
// c1r = c2r = c3r = c4r = ( tint4 ? pBaseRed : 1.0f ) * 0.6f;
// c1g = c2g = c3g = c4g = ( tint4 ? pBaseGreen : 1.0f ) * 0.6f;
// c1b = c2b = c3b = c4b = ( tint4 ? pBaseBlue : 1.0f ) * 0.6f;
// c1r *= ll1;
// c1g *= ll1;
// c1b *= ll1;
// c2r *= ll2;
// c2g *= ll2;
// c2b *= ll2;
// c3r *= ll3;
// c3g *= ll3;
// c3b *= ll3;
// c4r *= ll4;
// c4g *= ll4;
// c4b *= ll4;
// Icon_SPU *tex = getTexture(tt, level, pX, pY, pZ, 4);
// renderWest( tt, ( float )pX, ( float )pY, ( float )pZ, tex );
// if ( fancy &&(tex->getName().compare(L"grass_side") == 0) &&
// !hasFixedTexture() )
// {
// c1r *= pBaseRed;
// c2r *= pBaseRed;
// c3r *= pBaseRed;
// c4r *= pBaseRed;
// c1g *= pBaseGreen;
// c2g *= pBaseGreen;
// c3g *= pBaseGreen;
// c4g *= pBaseGreen;
// c1b *= pBaseBlue;
// c2b *= pBaseBlue;
// c3b *= pBaseBlue;
// c4b *= pBaseBlue;
// renderWest( tt, ( float )pX, ( float )pY, ( float )pZ,
// getGrassSideTextureOverlay() );
// }
// }
// if ( faceFlags & 0x20 )
// {
// if ( blsmooth > 0 )
// {
// pX++;
// llXy0 = tt->getBrightness( level, pX, pY - 1, pZ );
// llX0z = tt->getBrightness( level, pX, pY, pZ - 1 );
// llX0Z = tt->getBrightness( level, pX, pY, pZ + 1 );
// llXY0 = tt->getBrightness( level, pX, pY + 1, pZ );
//
// if ( llTransXy0 || llTransX0z )
// {
// llXyz = tt->getBrightness( level, pX, pY - 1, pZ
// - 1 );
// }
// else
// {
// llXyz = llX0z;
// }
// if ( llTransXy0 || llTransX0Z )
// {
// llXyZ = tt->getBrightness( level, pX, pY - 1, pZ
// + 1 );
// }
// else
// {
// llXyZ = llX0Z;
// }
// if ( llTransXY0 || llTransX0z )
// {
// llXYz = tt->getBrightness( level, pX, pY + 1, pZ
// - 1 );
// }
// else
// {
// llXYz = llX0z;
// }
// if ( llTransXY0 || llTransX0Z )
// {
// llXYZ = tt->getBrightness( level, pX, pY + 1, pZ
// + 1 );
// }
// else
// {
// llXYZ = llX0Z;
// }
// pX--;
// ll1 = ( llXy0 + llXyZ + llX00 + llX0Z ) / 4.0f;
// ll4 = ( llX00 + llX0Z + llXY0 + llXYZ ) / 4.0f;
// ll3 = ( llX0z + llX00 + llXYz + llXY0 ) / 4.0f;
// ll2 = ( llXyz + llXy0 + llX0z + llX00 ) / 4.0f;
// }
// else
// {
// ll1 = ll2 = ll3 = ll4 = llX00;
// }
// c1r = c2r = c3r = c4r = ( tint5 ? pBaseRed : 1.0f ) * 0.6f;
// c1g = c2g = c3g = c4g = ( tint5 ? pBaseGreen : 1.0f ) * 0.6f;
// c1b = c2b = c3b = c4b = ( tint5 ? pBaseBlue : 1.0f ) * 0.6f;
// c1r *= ll1;
// c1g *= ll1;
// c1b *= ll1;
// c2r *= ll2;
// c2g *= ll2;
// c2b *= ll2;
// c3r *= ll3;
// c3g *= ll3;
// c3b *= ll3;
// c4r *= ll4;
// c4g *= ll4;
// c4b *= ll4;
//
// Icon_SPU *tex = getTexture(tt, level, pX, pY, pZ, 5);
// renderEast( tt, ( float )pX, ( float )pY, ( float )pZ, tex );
// if ( fancy && (tex->getName().compare(L"grass_side") == 0) &&
// !hasFixedTexture() )
// {
// c1r *= pBaseRed;
// c2r *= pBaseRed;
// c3r *= pBaseRed;
// c4r *= pBaseRed;
// c1g *= pBaseGreen;
// c2g *= pBaseGreen;
// c3g *= pBaseGreen;
// c4g *= pBaseGreen;
// c1b *= pBaseBlue;
// c2b *= pBaseBlue;
// c3b *= pBaseBlue;
// c4b *= pBaseBlue;
// renderEast( tt, ( float )pX, ( float )pY, ( float )pZ,
// getGrassSideTextureOverlay() );
// }
// }
// applyAmbienceOcclusion = false;
//
return true;
}
// 4J - brought forward from 1.8.2
int TileRenderer_SPU::blend(int a, int b, int c, int def) {
if (a == 0) a = def;
if (b == 0) b = def;
if (c == 0) c = def;
return ((a + b + c + def) >> 2) & 0xff00ff;
}
int TileRenderer_SPU::blend(int a, int b, int c, int d, float fa, float fb,
float fc, float fd) {
int top =
(int)((float)((a >> 16) & 0xff) * fa + (float)((b >> 16) & 0xff) * fb +
(float)((c >> 16) & 0xff) * fc + (float)((d >> 16) & 0xff) * fd) &
0xff;
int bottom = (int)((float)(a & 0xff) * fa + (float)(b & 0xff) * fb +
(float)(c & 0xff) * fc + (float)(d & 0xff) * fd) &
0xff;
return (top << 16) | bottom;
}
bool TileRenderer_SPU::tesselateBlockInWorld(Tile_SPU* tt, int x, int y, int z,
float r, float g, float b) {
applyAmbienceOcclusion = false;
Tesselator_SPU* t = getTesselator();
bool changed = false;
float c10 = 0.5f;
float c11 = 1;
float c2 = 0.8f;
float c3 = 0.6f;
float r11 = c11 * r;
float g11 = c11 * g;
float b11 = c11 * b;
float r10 = c10;
float r2 = c2;
float r3 = c3;
float g10 = c10;
float g2 = c2;
float g3 = c3;
float b10 = c10;
float b2 = c2;
float b3 = c3;
if (tt->id != Tile_SPU::grass_Id) {
r10 *= r;
r2 *= r;
r3 *= r;
g10 *= g;
g2 *= g;
g3 *= g;
b10 *= b;
b2 *= b;
b3 *= b;
}
int centerColor = 0;
float centerBrightness = 0.0f;
if (SharedConstants::TEXTURE_LIGHTING) {
centerColor = tt->getLightColor(level, x, y, z);
} else {
centerBrightness = tt->getBrightness(level, x, y, z);
}
if (noCulling || tt->shouldRenderFace(level, x, y - 1, z, Facing::DOWN)) {
if (SharedConstants::TEXTURE_LIGHTING) {
t->tex2(tileShapeY0 > 0 ? centerColor
: tt->getLightColor(level, x, y - 1, z));
t->color(r10, g10, b10);
} else {
float br = tt->getBrightness(level, x, y - 1, z);
t->color(r10 * br, g10 * br, b10 * br);
}
renderFaceDown(tt, x, y, z, getTexture(tt, level, x, y, z, 0));
changed = true;
}
if (noCulling || tt->shouldRenderFace(level, x, y + 1, z, Facing::UP)) {
if (SharedConstants::TEXTURE_LIGHTING) {
t->tex2(tileShapeY1 < 1 ? centerColor
: tt->getLightColor(level, x, y + 1, z));
t->color(r11, g11, b11);
} else {
float br = tt->getBrightness(level, x, y + 1, z);
// spu_print("need to add material settings\n");
// if ( tileShapeY1 != 1 &&
//! tt->material->isLiquid() ) br = centerBrightness;
t->color(r11 * br, g11 * br, b11 * br);
}
renderFaceUp(tt, x, y, z, getTexture(tt, level, x, y, z, 1));
changed = true;
}
if (noCulling || tt->shouldRenderFace(level, x, y, z - 1, Facing::NORTH)) {
if (SharedConstants::TEXTURE_LIGHTING) {
t->tex2(tileShapeZ0 > 0 ? centerColor
: tt->getLightColor(level, x, y, z - 1));
t->color(r2, g2, b2);
} else {
float br = tt->getBrightness(level, x, y, z - 1);
if (tileShapeZ0 > 0) br = centerBrightness;
t->color(r2 * br, g2 * br, b2 * br);
}
Icon_SPU* tex = getTexture(tt, level, x, y, z, 2);
renderNorth(tt, x, y, z, tex);
if (fancy &&
(tex == &Tile_SPU::ms_pTileData->iconData[Tile_SPU::grass_Id] &&
!hasFixedTexture())) {
t->color(r2 * r, g2 * g, b2 * b);
renderNorth(tt, x, y, z, GrassTile_SPU::getSideTextureOverlay());
}
changed = true;
}
if (noCulling || tt->shouldRenderFace(level, x, y, z + 1, Facing::SOUTH)) {
if (SharedConstants::TEXTURE_LIGHTING) {
t->tex2(tileShapeZ1 < 1 ? centerColor
: tt->getLightColor(level, x, y, z + 1));
t->color(r2, g2, b2);
} else {
float br = tt->getBrightness(level, x, y, z + 1);
if (tileShapeZ1 < 1) br = centerBrightness;
t->color(r2 * br, g2 * br, b2 * br);
}
Icon_SPU* tex = getTexture(tt, level, x, y, z, 3);
renderSouth(tt, x, y, z, tex);
if (fancy &&
(tex == &Tile_SPU::ms_pTileData->iconData[Tile_SPU::grass_Id] &&
!hasFixedTexture())) {
t->color(r2 * r, g2 * g, b2 * b);
renderSouth(tt, x, y, z, GrassTile_SPU::getSideTextureOverlay());
}
changed = true;
}
if (noCulling || tt->shouldRenderFace(level, x - 1, y, z, Facing::WEST)) {
if (SharedConstants::TEXTURE_LIGHTING) {
t->tex2(tileShapeX0 > 0 ? centerColor
: tt->getLightColor(level, x - 1, y, z));
t->color(r3, g3, b3);
} else {
float br = tt->getBrightness(level, x - 1, y, z);
if (tileShapeX0 > 0) br = centerBrightness;
t->color(r3 * br, g3 * br, b3 * br);
}
Icon_SPU* tex = getTexture(tt, level, x, y, z, 4);
renderWest(tt, x, y, z, tex);
if (fancy &&
(tex == &Tile_SPU::ms_pTileData->iconData[Tile_SPU::grass_Id] &&
!hasFixedTexture())) {
t->color(r3 * r, g3 * g, b3 * b);
renderWest(tt, x, y, z, GrassTile_SPU::getSideTextureOverlay());
}
changed = true;
}
if (noCulling || tt->shouldRenderFace(level, x + 1, y, z, Facing::EAST)) {
if (SharedConstants::TEXTURE_LIGHTING) {
t->tex2(tileShapeX1 < 1 ? centerColor
: tt->getLightColor(level, x + 1, y, z));
t->color(r3, g3, b3);
} else {
float br = tt->getBrightness(level, x + 1, y, z);
if (tileShapeX1 < 1) br = centerBrightness;
t->color(r3 * br, g3 * br, b3 * br);
}
Icon_SPU* tex = getTexture(tt, level, x, y, z, 5);
renderEast(tt, x, y, z, tex);
if (fancy &&
(tex == &Tile_SPU::ms_pTileData->iconData[Tile_SPU::grass_Id] &&
!hasFixedTexture())) {
t->color(r3 * r, g3 * g, b3 * b);
renderEast(tt, x, y, z, GrassTile_SPU::getSideTextureOverlay());
}
changed = true;
}
return changed;
}
bool TileRenderer_SPU::tesselateCactusInWorld(Tile_SPU* tt, int x, int y,
int z) {
int col = tt->getColor(level, x, y, z);
float r = ((col >> 16) & 0xff) / 255.0f;
float g = ((col >> 8) & 0xff) / 255.0f;
float b = ((col) & 0xff) / 255.0f;
if (isAnaglyph3d()) {
float cr = (r * 30 + g * 59 + b * 11) / 100;
float cg = (r * 30 + g * 70) / (100);
float cb = (r * 30 + b * 70) / (100);
r = cr;
g = cg;
b = cb;
}
return tesselateCactusInWorld(tt, x, y, z, r, g, b);
}
bool TileRenderer_SPU::tesselateCactusInWorld(Tile_SPU* tt, int x, int y, int z,
float r, float g, float b) {
Tesselator_SPU* t = getTesselator();
bool changed = false;
float c10 = 0.5f;
float c11 = 1;
float c2 = 0.8f;
float c3 = 0.6f;
float r10 = c10 * r;
float r11 = c11 * r;
float r2 = c2 * r;
float r3 = c3 * r;
float g10 = c10 * g;
float g11 = c11 * g;
float g2 = c2 * g;
float g3 = c3 * g;
float b10 = c10 * b;
float b11 = c11 * b;
float b2 = c2 * b;
float b3 = c3 * b;
float s = 1 / 16.0f;
float centerBrightness = 0.0f;
int centerColor = 0;
if (SharedConstants::TEXTURE_LIGHTING) {
centerColor = tt->getLightColor(level, x, y, z);
} else {
centerBrightness = tt->getBrightness(level, x, y, z);
}
if (noCulling || tt->shouldRenderFace(level, x, y - 1, z, 0)) {
if (SharedConstants::TEXTURE_LIGHTING) {
t->tex2(tileShapeY0 > 0 ? centerColor
: tt->getLightColor(level, x, y - 1, z));
t->color(r10, g10, b10);
} else {
float br = tt->getBrightness(level, x, y - 1, z);
t->color(r10 * br, g10 * br, b10 * br);
}
renderFaceDown(tt, x, y, z, getTexture(tt, level, x, y, z, 0));
changed = true;
}
if (noCulling || tt->shouldRenderFace(level, x, y + 1, z, 1)) {
if (SharedConstants::TEXTURE_LIGHTING) {
t->tex2(tileShapeY1 < 1 ? centerColor
: tt->getLightColor(level, x, y + 1, z));
t->color(r11, g11, b11);
} else {
float br = tt->getBrightness(level, x, y + 1, z);
if (tileShapeY1 != 1 && !tt->getMaterial()->isLiquid())
br = centerBrightness;
t->color(r11 * br, g11 * br, b11 * br);
}
renderFaceUp(tt, x, y, z, getTexture(tt, level, x, y, z, 1));
changed = true;
}
if (noCulling || tt->shouldRenderFace(level, x, y, z - 1, 2)) {
if (SharedConstants::TEXTURE_LIGHTING) {
t->tex2(tileShapeZ0 > 0 ? centerColor
: tt->getLightColor(level, x, y, z - 1));
t->color(r2, g2, b2);
} else {
float br = tt->getBrightness(level, x, y, z - 1);
if (tileShapeZ0 > 0) br = centerBrightness;
t->color(r2 * br, g2 * br, b2 * br);
}
t->addOffset(0, 0, s);
renderNorth(tt, x, y, z, getTexture(tt, level, x, y, z, 2));
t->addOffset(0, 0, -s);
changed = true;
}
if (noCulling || tt->shouldRenderFace(level, x, y, z + 1, 3)) {
if (SharedConstants::TEXTURE_LIGHTING) {
t->tex2(tileShapeZ1 < 1 ? centerColor
: tt->getLightColor(level, x, y, z + 1));
t->color(r2, g2, b2);
} else {
float br = tt->getBrightness(level, x, y, z + 1);
if (tileShapeZ1 < 1) br = centerBrightness;
t->color(r2 * br, g2 * br, b2 * br);
}
t->addOffset(0, 0, -s);
renderSouth(tt, x, y, z, getTexture(tt, level, x, y, z, 3));
t->addOffset(0, 0, s);
changed = true;
}
if (noCulling || tt->shouldRenderFace(level, x - 1, y, z, 4)) {
if (SharedConstants::TEXTURE_LIGHTING) {
t->tex2(tileShapeX0 > 0 ? centerColor
: tt->getLightColor(level, x - 1, y, z));
t->color(r3, g3, b3);
} else {
float br = tt->getBrightness(level, x - 1, y, z);
if (tileShapeX0 > 0) br = centerBrightness;
t->color(r3 * br, g3 * br, b3 * br);
}
t->addOffset(s, 0, 0);
renderWest(tt, x, y, z, getTexture(tt, level, x, y, z, 4));
t->addOffset(-s, 0, 0);
changed = true;
}
if (noCulling || tt->shouldRenderFace(level, x + 1, y, z, 5)) {
if (SharedConstants::TEXTURE_LIGHTING) {
t->tex2(tileShapeX1 < 1 ? centerColor
: tt->getLightColor(level, x + 1, y, z));
t->color(r3, g3, b3);
} else {
float br = tt->getBrightness(level, x + 1, y, z);
if (tileShapeX1 < 1) br = centerBrightness;
t->color(r3 * br, g3 * br, b3 * br);
}
t->addOffset(-s, 0, 0);
renderEast(tt, x, y, z, getTexture(tt, level, x, y, z, 5));
t->addOffset(s, 0, 0);
changed = true;
}
return changed;
}
bool TileRenderer_SPU::tesselateFenceInWorld(FenceTile_SPU* tt, int x, int y,
int z) {
// #ifdef DISABLE_TESS_FUNCS
bool changed = false;
float a = 6 / 16.0f;
float b = 10 / 16.0f;
// EnterCriticalSection( &Tile_SPU::m_csShape );
setShape(a, 0, a, b, 1, b);
tesselateBlockInWorld(tt, x, y, z);
changed = true;
bool vertical = false;
bool horizontal = false;
if (tt->connectsTo(level, x - 1, y, z) ||
tt->connectsTo(level, x + 1, y, z))
vertical = true;
if (tt->connectsTo(level, x, y, z - 1) ||
tt->connectsTo(level, x, y, z + 1))
horizontal = true;
bool l = tt->connectsTo(level, x - 1, y, z);
bool r = tt->connectsTo(level, x + 1, y, z);
bool u = tt->connectsTo(level, x, y, z - 1);
bool d = tt->connectsTo(level, x, y, z + 1);
if (!vertical && !horizontal) vertical = true;
a = 7 / 16.0f;
b = 9 / 16.0f;
float h0 = 12 / 16.0f;
float h1 = 15 / 16.0f;
float x0 = l ? 0 : a;
float x1 = r ? 1 : b;
float z0 = u ? 0 : a;
float z1 = d ? 1 : b;
if (vertical) {
setShape(x0, h0, a, x1, h1, b);
tesselateBlockInWorld(tt, x, y, z);
changed = true;
}
if (horizontal) {
setShape(a, h0, z0, b, h1, z1);
tesselateBlockInWorld(tt, x, y, z);
changed = true;
}
h0 = 6 / 16.0f;
h1 = 9 / 16.0f;
if (vertical) {
setShape(x0, h0, a, x1, h1, b);
tesselateBlockInWorld(tt, x, y, z);
changed = true;
}
if (horizontal) {
setShape(a, h0, z0, b, h1, z1);
tesselateBlockInWorld(tt, x, y, z);
changed = true;
}
tt->updateShape(level, x, y, z);
// LeaveCriticalSection( &Tile_SPU::m_csShape );
return changed;
// #endif // #ifdef DISABLE_TESS_FUNCS
return false;
}
bool TileRenderer_SPU::tesselateWallInWorld(WallTile_SPU* tt, int x, int y,
int z) {
bool w = tt->connectsTo(level, x - 1, y, z);
bool e = tt->connectsTo(level, x + 1, y, z);
bool n = tt->connectsTo(level, x, y, z - 1);
bool s = tt->connectsTo(level, x, y, z + 1);
bool vertical = (n && s && !w && !e);
bool horizontal = (!n && !s && w && e);
bool emptyAbove = level->isEmptyTile(x, y + 1, z);
if ((!vertical && !horizontal) || !emptyAbove) {
// center post
setShape(.5f - WallTile_SPU::POST_WIDTH, 0,
.5f - WallTile_SPU::POST_WIDTH, .5f + WallTile_SPU::POST_WIDTH,
WallTile_SPU::POST_HEIGHT, .5f + WallTile_SPU::POST_WIDTH);
tesselateBlockInWorld(tt, x, y, z);
if (w) {
setShape(0, 0, .5f - WallTile_SPU::WALL_WIDTH,
.5f - WallTile_SPU::POST_WIDTH, WallTile_SPU::WALL_HEIGHT,
.5f + WallTile_SPU::WALL_WIDTH);
tesselateBlockInWorld(tt, x, y, z);
}
if (e) {
setShape(.5f + WallTile_SPU::POST_WIDTH, 0,
.5f - WallTile_SPU::WALL_WIDTH, 1,
WallTile_SPU::WALL_HEIGHT, .5f + WallTile_SPU::WALL_WIDTH);
tesselateBlockInWorld(tt, x, y, z);
}
if (n) {
setShape(.5f - WallTile_SPU::WALL_WIDTH, 0, 0,
.5f + WallTile_SPU::WALL_WIDTH, WallTile_SPU::WALL_HEIGHT,
.5f - WallTile_SPU::POST_WIDTH);
tesselateBlockInWorld(tt, x, y, z);
}
if (s) {
setShape(.5f - WallTile_SPU::WALL_WIDTH, 0,
.5f + WallTile_SPU::POST_WIDTH,
.5f + WallTile_SPU::WALL_WIDTH, WallTile_SPU::WALL_HEIGHT,
1);
tesselateBlockInWorld(tt, x, y, z);
}
} else if (vertical) {
// north-south wall
setShape(.5f - WallTile_SPU::WALL_WIDTH, 0, 0,
.5f + WallTile_SPU::WALL_WIDTH, WallTile_SPU::WALL_HEIGHT, 1);
tesselateBlockInWorld(tt, x, y, z);
} else {
// west-east wall
setShape(0, 0, .5f - WallTile_SPU::WALL_WIDTH, 1,
WallTile_SPU::WALL_HEIGHT, .5f + WallTile_SPU::WALL_WIDTH);
tesselateBlockInWorld(tt, x, y, z);
}
tt->updateShape(level, x, y, z);
return true;
}
bool TileRenderer_SPU::tesselateEggInWorld(EggTile_SPU* tt, int x, int y,
int z) {
bool changed = false;
// EnterCriticalSection( &Tile_SPU::m_csShape );
int y0 = 0;
for (int i = 0; i < 8; i++) {
int ww = 0;
int hh = 1;
if (i == 0) ww = 2;
if (i == 1) ww = 3;
if (i == 2) ww = 4;
if (i == 3) {
ww = 5;
hh = 2;
}
if (i == 4) {
ww = 6;
hh = 3;
}
if (i == 5) {
ww = 7;
hh = 5;
}
if (i == 6) {
ww = 6;
hh = 2;
}
if (i == 7) ww = 3;
float w = ww / 16.0f;
float yy1 = 1 - (y0 / 16.0f);
float yy0 = 1 - ((y0 + hh) / 16.0f);
y0 += hh;
setShape(0.5f - w, yy0, 0.5f - w, 0.5f + w, yy1, 0.5f + w);
tesselateBlockInWorld(tt, x, y, z);
}
changed = true;
setShape(0, 0, 0, 1, 1, 1);
// LeaveCriticalSection( &Tile_SPU::m_csShape );
return changed;
}
bool TileRenderer_SPU::tesselateFenceGateInWorld(FenceGateTile_SPU* tt, int x,
int y, int z) {
bool changed = true;
#ifdef DISABLE_TESS_FUNCS
int data = level->getData(x, y, z);
bool isOpen = FenceGateTile_SPU::isOpen(data);
int direction = FenceGateTile_SPU::getDirection(data);
float h00 = 6 / 16.0f;
float h01 = 9 / 16.0f;
float h10 = 12 / 16.0f;
float h11 = 15 / 16.0f;
float h20 = 5 / 16.0f;
float h21 = 16 / 16.0f;
// if (((direction == Direction::NORTH || direction == Direction::SOUTH) &&
// level->getTile(x - 1, y, z) == Tile_SPU::cobbleWall_Id &&
// level->getTile(x + 1, y, z) == Tile_SPU::cobbleWall_Id)
// || ((direction == Direction::EAST || direction == Direction::WEST) &&
// level->getTile(x, y, z - 1) == Tile_SPU::cobbleWall_Id &&
// level->getTile(x, y, z + 1) == Tile_SPU::cobbleWall_Id))
//{
// h00 -= 3.0f / 16.0f;
// h01 -= 3.0f / 16.0f;
// h10 -= 3.0f / 16.0f;
// h11 -= 3.0f / 16.0f;
// h20 -= 3.0f / 16.0f;
// h21 -= 3.0f / 16.0f;
// }
noCulling = true;
// EnterCriticalSection( &Tile_SPU::m_csShape );
// edge sticks
if (direction == Direction::EAST || direction == Direction::WEST) {
upFlip = FLIP_CW;
float x0 = 7 / 16.0f;
float x1 = 9 / 16.0f;
float z0 = 0 / 16.0f;
float z1 = 2 / 16.0f;
setShape(x0, h20, z0, x1, h21, z1);
tesselateBlockInWorld(tt, x, y, z);
z0 = 14 / 16.0f;
z1 = 16 / 16.0f;
setShape(x0, h20, z0, x1, h21, z1);
tesselateBlockInWorld(tt, x, y, z);
upFlip = FLIP_NONE;
} else {
float x0 = 0 / 16.0f;
float x1 = 2 / 16.0f;
float z0 = 7 / 16.0f;
float z1 = 9 / 16.0f;
setShape(x0, h20, z0, x1, h21, z1);
tesselateBlockInWorld(tt, x, y, z);
x0 = 14 / 16.0f;
x1 = 16 / 16.0f;
setShape(x0, h20, z0, x1, h21, z1);
tesselateBlockInWorld(tt, x, y, z);
}
if (isOpen) {
if (direction == Direction::NORTH || direction == Direction::SOUTH) {
upFlip = FLIP_CW;
}
if (direction == Direction::EAST) {
const float z00 = 0 / 16.0f;
const float z01 = 2 / 16.0f;
const float z10 = 14 / 16.0f;
const float z11 = 16 / 16.0f;
const float x0 = 9 / 16.0f;
const float x1 = 13 / 16.0f;
const float x2 = 15 / 16.0f;
setShape(x1, h00, z00, x2, h11, z01);
tesselateBlockInWorld(tt, x, y, z);
setShape(x1, h00, z10, x2, h11, z11);
tesselateBlockInWorld(tt, x, y, z);
setShape(x0, h00, z00, x1, h01, z01);
tesselateBlockInWorld(tt, x, y, z);
setShape(x0, h00, z10, x1, h01, z11);
tesselateBlockInWorld(tt, x, y, z);
setShape(x0, h10, z00, x1, h11, z01);
tesselateBlockInWorld(tt, x, y, z);
setShape(x0, h10, z10, x1, h11, z11);
tesselateBlockInWorld(tt, x, y, z);
} else if (direction == Direction::WEST) {
const float z00 = 0 / 16.0f;
const float z01 = 2 / 16.0f;
const float z10 = 14 / 16.0f;
const float z11 = 16 / 16.0f;
const float x0 = 1 / 16.0f;
const float x1 = 3 / 16.0f;
const float x2 = 7 / 16.0f;
setShape(x0, h00, z00, x1, h11, z01);
tesselateBlockInWorld(tt, x, y, z);
setShape(x0, h00, z10, x1, h11, z11);
tesselateBlockInWorld(tt, x, y, z);
setShape(x1, h00, z00, x2, h01, z01);
tesselateBlockInWorld(tt, x, y, z);
setShape(x1, h00, z10, x2, h01, z11);
tesselateBlockInWorld(tt, x, y, z);
setShape(x1, h10, z00, x2, h11, z01);
tesselateBlockInWorld(tt, x, y, z);
setShape(x1, h10, z10, x2, h11, z11);
tesselateBlockInWorld(tt, x, y, z);
} else if (direction == Direction::SOUTH) {
const float x00 = 0 / 16.0f;
const float x01 = 2 / 16.0f;
const float x10 = 14 / 16.0f;
const float x11 = 16 / 16.0f;
const float z0 = 9 / 16.0f;
const float z1 = 13 / 16.0f;
const float z2 = 15 / 16.0f;
setShape(x00, h00, z1, x01, h11, z2);
tesselateBlockInWorld(tt, x, y, z);
setShape(x10, h00, z1, x11, h11, z2);
tesselateBlockInWorld(tt, x, y, z);
setShape(x00, h00, z0, x01, h01, z1);
tesselateBlockInWorld(tt, x, y, z);
setShape(x10, h00, z0, x11, h01, z1);
tesselateBlockInWorld(tt, x, y, z);
setShape(x00, h10, z0, x01, h11, z1);
tesselateBlockInWorld(tt, x, y, z);
setShape(x10, h10, z0, x11, h11, z1);
tesselateBlockInWorld(tt, x, y, z);
} else if (direction == Direction::NORTH) {
const float x00 = 0 / 16.0f;
const float x01 = 2 / 16.0f;
const float x10 = 14 / 16.0f;
const float x11 = 16 / 16.0f;
const float z0 = 1 / 16.0f;
const float z1 = 3 / 16.0f;
const float z2 = 7 / 16.0f;
setShape(x00, h00, z0, x01, h11, z1);
tesselateBlockInWorld(tt, x, y, z);
setShape(x10, h00, z0, x11, h11, z1);
tesselateBlockInWorld(tt, x, y, z);
setShape(x00, h00, z1, x01, h01, z2);
tesselateBlockInWorld(tt, x, y, z);
setShape(x10, h00, z1, x11, h01, z2);
tesselateBlockInWorld(tt, x, y, z);
setShape(x00, h10, z1, x01, h11, z2);
tesselateBlockInWorld(tt, x, y, z);
setShape(x10, h10, z1, x11, h11, z2);
tesselateBlockInWorld(tt, x, y, z);
}
} else {
if (direction == Direction::EAST || direction == Direction::WEST) {
upFlip = FLIP_CW;
float x0 = 7 / 16.0f;
float x1 = 9 / 16.0f;
float z0 = 6 / 16.0f;
float z1 = 8 / 16.0f;
setShape(x0, h00, z0, x1, h11, z1);
tesselateBlockInWorld(tt, x, y, z);
z0 = 8 / 16.0f;
z1 = 10 / 16.0f;
setShape(x0, h00, z0, x1, h11, z1);
tesselateBlockInWorld(tt, x, y, z);
z0 = 10 / 16.0f;
z1 = 14 / 16.0f;
setShape(x0, h00, z0, x1, h01, z1);
tesselateBlockInWorld(tt, x, y, z);
setShape(x0, h10, z0, x1, h11, z1);
tesselateBlockInWorld(tt, x, y, z);
z0 = 2 / 16.0f;
z1 = 6 / 16.0f;
setShape(x0, h00, z0, x1, h01, z1);
tesselateBlockInWorld(tt, x, y, z);
setShape(x0, h10, z0, x1, h11, z1);
tesselateBlockInWorld(tt, x, y, z);
} else {
float x0 = 6 / 16.0f;
float x1 = 8 / 16.0f;
float z0 = 7 / 16.0f;
float z1 = 9 / 16.0f;
setShape(x0, h00, z0, x1, h11, z1);
tesselateBlockInWorld(tt, x, y, z);
x0 = 8 / 16.0f;
x1 = 10 / 16.0f;
setShape(x0, h00, z0, x1, h11, z1);
tesselateBlockInWorld(tt, x, y, z);
x0 = 10 / 16.0f;
x1 = 14 / 16.0f;
setShape(x0, h00, z0, x1, h01, z1);
tesselateBlockInWorld(tt, x, y, z);
setShape(x0, h10, z0, x1, h11, z1);
tesselateBlockInWorld(tt, x, y, z);
x0 = 2 / 16.0f;
x1 = 6 / 16.0f;
setShape(x0, h00, z0, x1, h01, z1);
tesselateBlockInWorld(tt, x, y, z);
setShape(x0, h10, z0, x1, h11, z1);
tesselateBlockInWorld(tt, x, y, z);
}
}
noCulling = false;
upFlip = FLIP_NONE;
setShape(0, 0, 0, 1, 1, 1);
// LeaveCriticalSection( &Tile_SPU::m_csShape );
#endif // #ifdef DISABLE_TESS_FUNCS
return changed;
}
bool TileRenderer_SPU::tesselateStairsInWorld(StairTile_SPU* tt, int x, int y,
int z) {
#ifdef DISABLE_TESS_FUNCS
// EnterCriticalSection( &Tile_SPU::m_csShape );
tt->setBaseShape(level, x, y, z);
setShape(tt);
tesselateBlockInWorld(tt, x, y, z);
bool checkInnerPiece = tt->setStepShape(level, x, y, z);
setShape(tt);
tesselateBlockInWorld(tt, x, y, z);
if (checkInnerPiece) {
if (tt->setInnerPieceShape(level, x, y, z)) {
setShape(tt);
tesselateBlockInWorld(tt, x, y, z);
}
}
// LeaveCriticalSection( &Tile_SPU::m_csShape );
#endif // #ifdef DISABLE_TESS_FUNCS
return true;
}
bool TileRenderer_SPU::tesselateDoorInWorld(Tile_SPU* tt, int x, int y, int z) {
Tesselator_SPU* t = getTesselator();
// skip rendering if the other half of the door is missing,
// to avoid rendering doors that are about to be removed
int data = level->getData(x, y, z);
if ((data & DoorTile_SPU::UPPER_BIT) != 0) {
if (level->getTile(x, y - 1, z) != tt->id) {
return false;
}
} else {
if (level->getTile(x, y + 1, z) != tt->id) {
return false;
}
}
bool changed = false;
float c10 = 0.5f;
float c11 = 1;
float c2 = 0.8f;
float c3 = 0.6f;
int centerColor = 0;
float centerBrightness = 0.0f;
if (SharedConstants::TEXTURE_LIGHTING) {
centerColor = tt->getLightColor(level, x, y, z);
} else {
centerBrightness = tt->getBrightness(level, x, y, z);
}
if (SharedConstants::TEXTURE_LIGHTING) {
t->tex2(tileShapeY0 > 0 ? centerColor
: tt->getLightColor(level, x, y - 1, z));
t->color(c10, c10, c10);
} else {
float br = tt->getBrightness(level, x, y - 1, z);
if (tileShapeY0 > 0) br = centerBrightness;
if (level->m_tileData.lightEmission[tt->id] > 0) br = 1.0f;
t->color(c10 * br, c10 * br, c10 * br);
}
renderFaceDown(tt, x, y, z, getTexture(tt, level, x, y, z, 0));
changed = true;
if (SharedConstants::TEXTURE_LIGHTING) {
t->tex2(tileShapeY1 < 1 ? centerColor
: tt->getLightColor(level, x, y + 1, z));
t->color(c11, c11, c11);
} else {
float br = tt->getBrightness(level, x, y + 1, z);
if (tileShapeY1 < 1) br = centerBrightness;
if (level->m_tileData.lightEmission[tt->id] > 0) br = 1.0f;
t->color(c11 * br, c11 * br, c11 * br);
}
renderFaceUp(tt, x, y, z, getTexture(tt, level, x, y, z, 1));
changed = true;
{
if (SharedConstants::TEXTURE_LIGHTING) {
t->tex2(tileShapeZ0 > 0 ? centerColor
: tt->getLightColor(level, x, y, z - 1));
t->color(c2, c2, c2);
} else {
float br = tt->getBrightness(level, x, y, z - 1);
if (tileShapeZ0 > 0) br = centerBrightness;
if (level->m_tileData.lightEmission[tt->id] > 0) br = 1.0f;
t->color(c2 * br, c2 * br, c2 * br);
}
Icon_SPU* tex = getTexture(tt, level, x, y, z, 2);
renderNorth(tt, x, y, z, tex);
changed = true;
xFlipTexture = false;
}
{
if (SharedConstants::TEXTURE_LIGHTING) {
t->tex2(tileShapeZ1 < 1 ? centerColor
: tt->getLightColor(level, x, y, z + 1));
t->color(c2, c2, c2);
} else {
float br = tt->getBrightness(level, x, y, z + 1);
if (tileShapeZ1 < 1) br = centerBrightness;
if (level->m_tileData.lightEmission[tt->id] > 0) br = 1.0f;
t->color(c2 * br, c2 * br, c2 * br);
}
Icon_SPU* tex = getTexture(tt, level, x, y, z, 3);
renderSouth(tt, x, y, z, tex);
changed = true;
xFlipTexture = false;
}
{
if (SharedConstants::TEXTURE_LIGHTING) {
t->tex2(tileShapeX0 > 0 ? centerColor
: tt->getLightColor(level, x - 1, y, z));
t->color(c3, c3, c3);
} else {
float br = tt->getBrightness(level, x - 1, y, z);
if (tileShapeX0 > 0) br = centerBrightness;
if (level->m_tileData.lightEmission[tt->id] > 0) br = 1.0f;
t->color(c3 * br, c3 * br, c3 * br);
}
Icon_SPU* tex = getTexture(tt, level, x, y, z, 4);
renderWest(tt, x, y, z, tex);
changed = true;
xFlipTexture = false;
}
{
if (SharedConstants::TEXTURE_LIGHTING) {
t->tex2(tileShapeX1 < 1 ? centerColor
: tt->getLightColor(level, x + 1, y, z));
t->color(c3, c3, c3);
} else {
float br = tt->getBrightness(level, x + 1, y, z);
if (tileShapeX1 < 1) br = centerBrightness;
if (level->m_tileData.lightEmission[tt->id] > 0) br = 1.0f;
t->color(c3 * br, c3 * br, c3 * br);
}
Icon_SPU* tex = getTexture(tt, level, x, y, z, 5);
renderEast(tt, x, y, z, tex);
changed = true;
xFlipTexture = false;
}
return changed;
}
void TileRenderer_SPU::renderFaceDown(Tile_SPU* tt, float x, float y, float z,
Icon_SPU* tex) {
Tesselator_SPU* t = getTesselator();
if (hasFixedTexture()) tex = fixedTexture;
float u00 = tex->getU(tileShapeX0 * 16.0f);
float u11 = tex->getU(tileShapeX1 * 16.0f);
float v00 = tex->getV(tileShapeZ0 * 16.0f);
float v11 = tex->getV(tileShapeZ1 * 16.0f);
if (tileShapeX0 < 0 || tileShapeX1 > 1) {
u00 = tex->getU0();
u11 = tex->getU1();
}
if (tileShapeZ0 < 0 || tileShapeZ1 > 1) {
v00 = tex->getV0();
v11 = tex->getV1();
}
float u01 = u11, u10 = u00, v01 = v00, v10 = v11;
if (downFlip == FLIP_CCW) {
u00 = tex->getU(tileShapeZ0 * 16.0f);
v00 =
tex->getV(SharedConstants::WORLD_RESOLUTION - tileShapeX1 * 16.0f);
u11 = tex->getU(tileShapeZ1 * 16.0f);
v11 =
tex->getV(SharedConstants::WORLD_RESOLUTION - tileShapeX0 * 16.0f);
u01 = u11;
u10 = u00;
v01 = v00;
v10 = v11;
u01 = u00;
u10 = u11;
v00 = v11;
v11 = v01;
} else if (downFlip == FLIP_CW) {
// reshape
u00 =
tex->getU(SharedConstants::WORLD_RESOLUTION - tileShapeZ1 * 16.0f);
v00 = tex->getV(tileShapeX0 * 16.0f);
u11 =
tex->getU(SharedConstants::WORLD_RESOLUTION - tileShapeZ0 * 16.0f);
v11 = tex->getV(tileShapeX1 * 16.0f);
// rotate
u01 = u11;
u10 = u00;
v01 = v00;
v10 = v11;
u00 = u01;
u11 = u10;
v01 = v11;
v10 = v00;
} else if (downFlip == FLIP_180) {
u00 =
tex->getU(SharedConstants::WORLD_RESOLUTION - tileShapeX0 * 16.0f);
u11 =
tex->getU(SharedConstants::WORLD_RESOLUTION - tileShapeX1 * 16.0f);
v00 =
tex->getV(SharedConstants::WORLD_RESOLUTION - tileShapeZ0 * 16.0f);
v11 =
tex->getV(SharedConstants::WORLD_RESOLUTION - tileShapeZ1 * 16.0f);
u01 = u11;
u10 = u00;
v01 = v00;
v10 = v11;
}
float x0 = x + tileShapeX0;
float x1 = x + tileShapeX1;
float y0 = y + tileShapeY0;
float z0 = z + tileShapeZ0;
float z1 = z + tileShapeZ1;
if (applyAmbienceOcclusion) {
t->color(c1r, c1g, c1b);
if (SharedConstants::TEXTURE_LIGHTING) t->tex2(tc1);
t->vertexUV((float)(x0), (float)(y0), (float)(z1), (float)(u10),
(float)(v10));
t->color(c2r, c2g, c2b);
if (SharedConstants::TEXTURE_LIGHTING) t->tex2(tc2);
t->vertexUV((float)(x0), (float)(y0), (float)(z0), (float)(u00),
(float)(v00));
t->color(c3r, c3g, c3b);
if (SharedConstants::TEXTURE_LIGHTING) t->tex2(tc3);
t->vertexUV((float)(x1), (float)(y0), (float)(z0), (float)(u01),
(float)(v01));
t->color(c4r, c4g, c4b);
if (SharedConstants::TEXTURE_LIGHTING) t->tex2(tc4);
t->vertexUV((float)(x1), (float)(y0), (float)(z1), (float)(u11),
(float)(v11));
} else {
t->vertexUV((float)(x0), (float)(y0), (float)(z1), (float)(u10),
(float)(v10));
t->vertexUV((float)(x0), (float)(y0), (float)(z0), (float)(u00),
(float)(v00));
t->vertexUV((float)(x1), (float)(y0), (float)(z0), (float)(u01),
(float)(v01));
t->vertexUV((float)(x1), (float)(y0), (float)(z1), (float)(u11),
(float)(v11));
}
}
void TileRenderer_SPU::renderFaceUp(Tile_SPU* tt, float x, float y, float z,
Icon_SPU* tex) {
Tesselator_SPU* t = getTesselator();
if (hasFixedTexture()) tex = fixedTexture;
float u00 = tex->getU(tileShapeX0 * 16.0f);
float u11 = tex->getU(tileShapeX1 * 16.0f);
float v00 = tex->getV(tileShapeZ0 * 16.0f);
float v11 = tex->getV(tileShapeZ1 * 16.0f);
if (tileShapeX0 < 0 || tileShapeX1 > 1) {
u00 = tex->getU0();
u11 = tex->getU1();
}
if (tileShapeZ0 < 0 || tileShapeZ1 > 1) {
v00 = tex->getV0();
v11 = tex->getV1();
}
float u01 = u11, u10 = u00, v01 = v00, v10 = v11;
if (upFlip == FLIP_CW) {
u00 = tex->getU(tileShapeZ0 * 16.0f);
v00 =
tex->getV(SharedConstants::WORLD_RESOLUTION - tileShapeX1 * 16.0f);
u11 = tex->getU(tileShapeZ1 * 16.0f);
v11 =
tex->getV(SharedConstants::WORLD_RESOLUTION - tileShapeX0 * 16.0f);
u01 = u11;
u10 = u00;
v01 = v00;
v10 = v11;
u01 = u00;
u10 = u11;
v00 = v11;
v11 = v01;
} else if (upFlip == FLIP_CCW) {
// reshape
u00 =
tex->getU(SharedConstants::WORLD_RESOLUTION - tileShapeZ1 * 16.0f);
v00 = tex->getV(tileShapeX0 * 16.0f);
u11 =
tex->getU(SharedConstants::WORLD_RESOLUTION - tileShapeZ0 * 16.0f);
v11 = tex->getV(tileShapeX1 * 16.0f);
// rotate
u01 = u11;
u10 = u00;
v01 = v00;
v10 = v11;
u00 = u01;
u11 = u10;
v01 = v11;
v10 = v00;
} else if (upFlip == FLIP_180) {
u00 =
tex->getU(SharedConstants::WORLD_RESOLUTION - tileShapeX0 * 16.0f);
u11 =
tex->getU(SharedConstants::WORLD_RESOLUTION - tileShapeX1 * 16.0f);
v00 =
tex->getV(SharedConstants::WORLD_RESOLUTION - tileShapeZ0 * 16.0f);
v11 =
tex->getV(SharedConstants::WORLD_RESOLUTION - tileShapeZ1 * 16.0f);
u01 = u11;
u10 = u00;
v01 = v00;
v10 = v11;
}
float x0 = x + tileShapeX0;
float x1 = x + tileShapeX1;
float y1 = y + tileShapeY1;
float z0 = z + tileShapeZ0;
float z1 = z + tileShapeZ1;
if (applyAmbienceOcclusion) {
t->color(c1r, c1g, c1b);
if (SharedConstants::TEXTURE_LIGHTING) t->tex2(tc1);
t->vertexUV((float)(x1), (float)(y1), (float)(z1), (float)(u11),
(float)(v11));
t->color(c2r, c2g, c2b);
if (SharedConstants::TEXTURE_LIGHTING) t->tex2(tc2);
t->vertexUV((float)(x1), (float)(y1), (float)(z0), (float)(u01),
(float)(v01));
t->color(c3r, c3g, c3b);
if (SharedConstants::TEXTURE_LIGHTING) t->tex2(tc3);
t->vertexUV((float)(x0), (float)(y1), (float)(z0), (float)(u00),
(float)(v00));
t->color(c4r, c4g, c4b);
if (SharedConstants::TEXTURE_LIGHTING) t->tex2(tc4);
t->vertexUV((float)(x0), (float)(y1), (float)(z1), (float)(u10),
(float)(v10));
} else {
t->vertexUV((float)(x1), (float)(y1), (float)(z1), (float)(u11),
(float)(v11));
t->vertexUV((float)(x1), (float)(y1), (float)(z0), (float)(u01),
(float)(v01));
t->vertexUV((float)(x0), (float)(y1), (float)(z0), (float)(u00),
(float)(v00));
t->vertexUV((float)(x0), (float)(y1), (float)(z1), (float)(u10),
(float)(v10));
}
}
void TileRenderer_SPU::renderNorth(Tile_SPU* tt, float x, float y, float z,
Icon_SPU* tex) {
Tesselator_SPU* t = getTesselator();
if (hasFixedTexture()) tex = fixedTexture;
float u00 = tex->getU(tileShapeX0 * 16.0f);
float u11 = tex->getU(tileShapeX1 * 16.0f);
float v00 =
tex->getV(SharedConstants::WORLD_RESOLUTION - tileShapeY1 * 16.0f);
float v11 =
tex->getV(SharedConstants::WORLD_RESOLUTION - tileShapeY0 * 16.0f);
if (xFlipTexture) {
float tmp = u00;
u00 = u11;
u11 = tmp;
}
if (tileShapeX0 < 0 || tileShapeX1 > 1) {
u00 = tex->getU0();
u11 = tex->getU1();
}
if (tileShapeY0 < 0 || tileShapeY1 > 1) {
v00 = tex->getV0();
v11 = tex->getV1();
}
float u01 = u11, u10 = u00, v01 = v00, v10 = v11;
if (northFlip == FLIP_CCW) {
u00 = tex->getU(tileShapeY0 * 16.0f);
v00 =
tex->getV(SharedConstants::WORLD_RESOLUTION - tileShapeX0 * 16.0f);
u11 = tex->getU(tileShapeY1 * 16.0f);
v11 =
tex->getV(SharedConstants::WORLD_RESOLUTION - tileShapeX1 * 16.0f);
u01 = u11;
u10 = u00;
v01 = v00;
v10 = v11;
u01 = u00;
u10 = u11;
v00 = v11;
v11 = v01;
} else if (northFlip == FLIP_CW) {
// reshape
u00 =
tex->getU(SharedConstants::WORLD_RESOLUTION - tileShapeY1 * 16.0f);
v00 = tex->getV(tileShapeX1 * 16.0f);
u11 =
tex->getU(SharedConstants::WORLD_RESOLUTION - tileShapeY0 * 16.0f);
v11 = tex->getV(tileShapeX0 * 16.0f);
// rotate
u01 = u11;
u10 = u00;
v01 = v00;
v10 = v11;
u00 = u01;
u11 = u10;
v01 = v11;
v10 = v00;
} else if (northFlip == FLIP_180) {
u00 =
tex->getU(SharedConstants::WORLD_RESOLUTION - tileShapeX0 * 16.0f);
u11 =
tex->getU(SharedConstants::WORLD_RESOLUTION - tileShapeX1 * 16.0f);
v00 = tex->getV(tileShapeY1 * 16.0f);
v11 = tex->getV(tileShapeY0 * 16.0f);
u01 = u11;
u10 = u00;
v01 = v00;
v10 = v11;
}
float x0 = x + tileShapeX0;
float x1 = x + tileShapeX1;
float y0 = y + tileShapeY0;
float y1 = y + tileShapeY1;
float z0 = z + tileShapeZ0;
if (applyAmbienceOcclusion) {
t->color(c1r, c1g, c1b);
if (SharedConstants::TEXTURE_LIGHTING) t->tex2(tc1);
t->vertexUV((float)(x0), (float)(y1), (float)(z0), (float)(u01),
(float)(v01));
t->color(c2r, c2g, c2b);
if (SharedConstants::TEXTURE_LIGHTING) t->tex2(tc2);
t->vertexUV((float)(x1), (float)(y1), (float)(z0), (float)(u00),
(float)(v00));
t->color(c3r, c3g, c3b);
if (SharedConstants::TEXTURE_LIGHTING) t->tex2(tc3);
t->vertexUV((float)(x1), (float)(y0), (float)(z0), (float)(u10),
(float)(v10));
t->color(c4r, c4g, c4b);
if (SharedConstants::TEXTURE_LIGHTING) t->tex2(tc4);
t->vertexUV((float)(x0), (float)(y0), (float)(z0), (float)(u11),
(float)(v11));
} else {
t->vertexUV((float)(x0), (float)(y1), (float)(z0), (float)(u01),
(float)(v01));
t->vertexUV((float)(x1), (float)(y1), (float)(z0), (float)(u00),
(float)(v00));
t->vertexUV((float)(x1), (float)(y0), (float)(z0), (float)(u10),
(float)(v10));
t->vertexUV((float)(x0), (float)(y0), (float)(z0), (float)(u11),
(float)(v11));
}
}
void TileRenderer_SPU::renderSouth(Tile_SPU* tt, float x, float y, float z,
Icon_SPU* tex) {
Tesselator_SPU* t = getTesselator();
if (hasFixedTexture()) tex = fixedTexture;
float u00 = tex->getU(tileShapeX0 * 16.0f);
float u11 = tex->getU(tileShapeX1 * 16.0f);
float v00 =
tex->getV(SharedConstants::WORLD_RESOLUTION - tileShapeY1 * 16.0f);
float v11 =
tex->getV(SharedConstants::WORLD_RESOLUTION - tileShapeY0 * 16.0f);
if (xFlipTexture) {
float tmp = u00;
u00 = u11;
u11 = tmp;
}
if (tileShapeX0 < 0 || tileShapeX1 > 1) {
u00 = tex->getU0();
u11 = tex->getU1();
}
if (tileShapeY0 < 0 || tileShapeY1 > 1) {
v00 = tex->getV0();
v11 = tex->getV1();
}
float u01 = u11, u10 = u00, v01 = v00, v10 = v11;
if (southFlip == FLIP_CW) {
u00 = tex->getU(tileShapeY0 * 16.0f);
v11 =
tex->getV(SharedConstants::WORLD_RESOLUTION - tileShapeX0 * 16.0f);
u11 = tex->getU(tileShapeY1 * 16.0f);
v00 =
tex->getV(SharedConstants::WORLD_RESOLUTION - tileShapeX1 * 16.0f);
u01 = u11;
u10 = u00;
v01 = v00;
v10 = v11;
u01 = u00;
u10 = u11;
v00 = v11;
v11 = v01;
} else if (southFlip == FLIP_CCW) {
// reshape
u00 =
tex->getU(SharedConstants::WORLD_RESOLUTION - tileShapeY1 * 16.0f);
v00 = tex->getV(tileShapeX0 * 16.0f);
u11 =
tex->getU(SharedConstants::WORLD_RESOLUTION - tileShapeY0 * 16.0f);
v11 = tex->getV(tileShapeX1 * 16.0f);
// rotate
u01 = u11;
u10 = u00;
v01 = v00;
v10 = v11;
u00 = u01;
u11 = u10;
v01 = v11;
v10 = v00;
} else if (southFlip == FLIP_180) {
u00 =
tex->getU(SharedConstants::WORLD_RESOLUTION - tileShapeX0 * 16.0f);
u11 =
tex->getU(SharedConstants::WORLD_RESOLUTION - tileShapeX1 * 16.0f);
v00 = tex->getV(tileShapeY1 * 16.0f);
v11 = tex->getV(tileShapeY0 * 16.0f);
u01 = u11;
u10 = u00;
v01 = v00;
v10 = v11;
}
float x0 = x + tileShapeX0;
float x1 = x + tileShapeX1;
float y0 = y + tileShapeY0;
float y1 = y + tileShapeY1;
float z1 = z + tileShapeZ1;
if (applyAmbienceOcclusion) {
t->color(c1r, c1g, c1b);
if (SharedConstants::TEXTURE_LIGHTING) t->tex2(tc1);
t->vertexUV((float)(x0), (float)(y1), (float)(z1), (float)(u00),
(float)(v00));
t->color(c2r, c2g, c2b);
if (SharedConstants::TEXTURE_LIGHTING) t->tex2(tc2);
t->vertexUV((float)(x0), (float)(y0), (float)(z1), (float)(u10),
(float)(v10));
t->color(c3r, c3g, c3b);
if (SharedConstants::TEXTURE_LIGHTING) t->tex2(tc3);
t->vertexUV((float)(x1), (float)(y0), (float)(z1), (float)(u11),
(float)(v11));
t->color(c4r, c4g, c4b);
if (SharedConstants::TEXTURE_LIGHTING) t->tex2(tc4);
t->vertexUV((float)(x1), (float)(y1), (float)(z1), (float)(u01),
(float)(v01));
} else {
t->vertexUV((float)(x0), (float)(y1), (float)(z1), (float)(u00),
(float)(v00));
t->vertexUV((float)(x0), (float)(y0), (float)(z1), (float)(u10),
(float)(v10));
t->vertexUV((float)(x1), (float)(y0), (float)(z1), (float)(u11),
(float)(v11));
t->vertexUV((float)(x1), (float)(y1), (float)(z1), (float)(u01),
(float)(v01));
}
}
void TileRenderer_SPU::renderWest(Tile_SPU* tt, float x, float y, float z,
Icon_SPU* tex) {
Tesselator_SPU* t = getTesselator();
if (hasFixedTexture()) tex = fixedTexture;
float u00 = tex->getU(tileShapeZ0 * 16.0f);
float u11 = tex->getU(tileShapeZ1 * 16.0f);
float v00 =
tex->getV(SharedConstants::WORLD_RESOLUTION - tileShapeY1 * 16.0f);
float v11 =
tex->getV(SharedConstants::WORLD_RESOLUTION - tileShapeY0 * 16.0f);
if (xFlipTexture) {
float tmp = u00;
u00 = u11;
u11 = tmp;
}
if (tileShapeZ0 < 0 || tileShapeZ1 > 1) {
u00 = tex->getU0();
u11 = tex->getU1();
}
if (tileShapeY0 < 0 || tileShapeY1 > 1) {
v00 = tex->getV0();
v11 = tex->getV1();
}
float u01 = u11, u10 = u00, v01 = v00, v10 = v11;
if (westFlip == FLIP_CW) {
u00 = tex->getU(tileShapeY0 * 16.0f);
v00 =
tex->getV(SharedConstants::WORLD_RESOLUTION - tileShapeZ1 * 16.0f);
u11 = tex->getU(tileShapeY1 * 16.0f);
v11 =
tex->getV(SharedConstants::WORLD_RESOLUTION - tileShapeZ0 * 16.0f);
u01 = u11;
u10 = u00;
v01 = v00;
v10 = v11;
u01 = u00;
u10 = u11;
v00 = v11;
v11 = v01;
} else if (westFlip == FLIP_CCW) {
// reshape
u00 =
tex->getU(SharedConstants::WORLD_RESOLUTION - tileShapeY1 * 16.0f);
v00 = tex->getV(tileShapeZ0 * 16.0f);
u11 =
tex->getU(SharedConstants::WORLD_RESOLUTION - tileShapeY0 * 16.0f);
v11 = tex->getV(tileShapeZ1 * 16.0f);
// rotate
u01 = u11;
u10 = u00;
v01 = v00;
v10 = v11;
u00 = u01;
u11 = u10;
v01 = v11;
v10 = v00;
} else if (westFlip == FLIP_180) {
u00 =
tex->getU(SharedConstants::WORLD_RESOLUTION - tileShapeZ0 * 16.0f);
u11 =
tex->getU(SharedConstants::WORLD_RESOLUTION - tileShapeZ1 * 16.0f);
v00 = tex->getV(tileShapeY1 * 16.0f);
v11 = tex->getV(tileShapeY0 * 16.0f);
u01 = u11;
u10 = u00;
v01 = v00;
v10 = v11;
}
float x0 = x + tileShapeX0;
float y0 = y + tileShapeY0;
float y1 = y + tileShapeY1;
float z0 = z + tileShapeZ0;
float z1 = z + tileShapeZ1;
if (applyAmbienceOcclusion) {
t->color(c1r, c1g, c1b);
if (SharedConstants::TEXTURE_LIGHTING) t->tex2(tc1);
t->vertexUV((float)(x0), (float)(y1), (float)(z1), (float)(u01),
(float)(v01));
t->color(c2r, c2g, c2b);
if (SharedConstants::TEXTURE_LIGHTING) t->tex2(tc2);
t->vertexUV((float)(x0), (float)(y1), (float)(z0), (float)(u00),
(float)(v00));
t->color(c3r, c3g, c3b);
if (SharedConstants::TEXTURE_LIGHTING) t->tex2(tc3);
t->vertexUV((float)(x0), (float)(y0), (float)(z0), (float)(u10),
(float)(v10));
t->color(c4r, c4g, c4b);
if (SharedConstants::TEXTURE_LIGHTING) t->tex2(tc4);
t->vertexUV((float)(x0), (float)(y0), (float)(z1), (float)(u11),
(float)(v11));
} else {
t->vertexUV((float)(x0), (float)(y1), (float)(z1), (float)(u01),
(float)(v01));
t->vertexUV((float)(x0), (float)(y1), (float)(z0), (float)(u00),
(float)(v00));
t->vertexUV((float)(x0), (float)(y0), (float)(z0), (float)(u10),
(float)(v10));
t->vertexUV((float)(x0), (float)(y0), (float)(z1), (float)(u11),
(float)(v11));
}
}
void TileRenderer_SPU::renderEast(Tile_SPU* tt, float x, float y, float z,
Icon_SPU* tex) {
Tesselator_SPU* t = getTesselator();
if (hasFixedTexture()) tex = fixedTexture;
float u00 = tex->getU(tileShapeZ0 * 16.0f);
float u11 = tex->getU(tileShapeZ1 * 16.0f);
float v00 =
tex->getV(SharedConstants::WORLD_RESOLUTION - tileShapeY1 * 16.0f);
float v11 =
tex->getV(SharedConstants::WORLD_RESOLUTION - tileShapeY0 * 16.0f);
if (xFlipTexture) {
float tmp = u00;
u00 = u11;
u11 = tmp;
}
if (tileShapeZ0 < 0 || tileShapeZ1 > 1) {
u00 = tex->getU0();
u11 = tex->getU1();
}
if (tileShapeY0 < 0 || tileShapeY1 > 1) {
v00 = tex->getV0();
v11 = tex->getV1();
}
float u01 = u11, u10 = u00, v01 = v00, v10 = v11;
if (eastFlip == FLIP_CCW) {
u00 = tex->getU(tileShapeY0 * 16.0f);
v00 =
tex->getV(SharedConstants::WORLD_RESOLUTION - tileShapeZ0 * 16.0f);
u11 = tex->getU(tileShapeY1 * 16.0f);
v11 =
tex->getV(SharedConstants::WORLD_RESOLUTION - tileShapeZ1 * 16.0f);
u01 = u11;
u10 = u00;
v01 = v00;
v10 = v11;
u01 = u00;
u10 = u11;
v00 = v11;
v11 = v01;
} else if (eastFlip == FLIP_CW) {
// reshape
u00 =
tex->getU(SharedConstants::WORLD_RESOLUTION - tileShapeY1 * 16.0f);
v00 = tex->getV(tileShapeZ1 * 16.0f);
u11 =
tex->getU(SharedConstants::WORLD_RESOLUTION - tileShapeY0 * 16.0f);
v11 = tex->getV(tileShapeZ0 * 16.0f);
// rotate
u01 = u11;
u10 = u00;
v01 = v00;
v10 = v11;
u00 = u01;
u11 = u10;
v01 = v11;
v10 = v00;
} else if (eastFlip == FLIP_180) {
u00 =
tex->getU(SharedConstants::WORLD_RESOLUTION - tileShapeZ0 * 16.0f);
u11 =
tex->getU(SharedConstants::WORLD_RESOLUTION - tileShapeZ1 * 16.0f);
v00 = tex->getV(tileShapeY1 * 16.0f);
v11 = tex->getV(tileShapeY0 * 16.0f);
u01 = u11;
u10 = u00;
v01 = v00;
v10 = v11;
}
float x1 = x + tileShapeX1;
float y0 = y + tileShapeY0;
float y1 = y + tileShapeY1;
float z0 = z + tileShapeZ0;
float z1 = z + tileShapeZ1;
if (applyAmbienceOcclusion) {
t->color(c1r, c1g, c1b);
if (SharedConstants::TEXTURE_LIGHTING) t->tex2(tc1);
t->vertexUV((float)(x1), (float)(y0), (float)(z1), (float)(u10),
(float)(v10));
t->color(c2r, c2g, c2b);
if (SharedConstants::TEXTURE_LIGHTING) t->tex2(tc2);
t->vertexUV((float)(x1), (float)(y0), (float)(z0), (float)(u11),
(float)(v11));
t->color(c3r, c3g, c3b);
if (SharedConstants::TEXTURE_LIGHTING) t->tex2(tc3);
t->vertexUV((float)(x1), (float)(y1), (float)(z0), (float)(u01),
(float)(v01));
t->color(c4r, c4g, c4b);
if (SharedConstants::TEXTURE_LIGHTING) t->tex2(tc4);
t->vertexUV((float)(x1), (float)(y1), (float)(z1), (float)(u00),
(float)(v00));
} else {
t->vertexUV((float)(x1), (float)(y0), (float)(z1), (float)(u10),
(float)(v10));
t->vertexUV((float)(x1), (float)(y0), (float)(z0), (float)(u11),
(float)(v11));
t->vertexUV((float)(x1), (float)(y1), (float)(z0), (float)(u01),
(float)(v01));
t->vertexUV((float)(x1), (float)(y1), (float)(z1), (float)(u00),
(float)(v00));
}
}
bool TileRenderer_SPU::canRender(int renderShape) {
if (renderShape == Tile_SPU::SHAPE_BLOCK) return true;
if (renderShape == Tile_SPU::SHAPE_TREE) return true;
if (renderShape == Tile_SPU::SHAPE_QUARTZ) return true;
if (renderShape == Tile_SPU::SHAPE_CACTUS) return true;
if (renderShape == Tile_SPU::SHAPE_STAIRS) return true;
if (renderShape == Tile_SPU::SHAPE_FENCE) return true;
if (renderShape == Tile_SPU::SHAPE_EGG) return true;
if (renderShape == Tile_SPU::SHAPE_ENTITYTILE_ANIMATED) return true;
if (renderShape == Tile_SPU::SHAPE_FENCE_GATE) return true;
if (renderShape == Tile_SPU::SHAPE_PISTON_BASE) return true;
if (renderShape == Tile_SPU::SHAPE_PORTAL_FRAME) return true;
if (renderShape == Tile_SPU::SHAPE_WALL) return true;
if (renderShape == Tile_SPU::SHAPE_ANVIL) return true;
return false;
}
Icon_SPU* TileRenderer_SPU::getTexture(Tile_SPU* tile, ChunkRebuildData* level,
int x, int y, int z, int face) {
return getTextureOrMissing(tile->getTexture(level, x, y, z, face));
}
Icon_SPU* TileRenderer_SPU::getTexture(Tile_SPU* tile, int face, int data) {
return getTextureOrMissing(tile->getTexture(face, data));
}
Icon_SPU* TileRenderer_SPU::getTexture(Tile_SPU* tile, int face) {
return getTextureOrMissing(tile->getTexture(face));
}
Icon_SPU* TileRenderer_SPU::getTexture(Tile_SPU* tile) {
return getTextureOrMissing(tile->getTexture(Facing::UP));
}
Icon_SPU* TileRenderer_SPU::getTextureOrMissing(Icon_SPU* Icon_SPU) {
if (Icon_SPU == NULL) {
assert(0);
// return
// minecraft->textures->getMissingIcon_SPU(Icon_SPU::TYPE_TERRAIN);
}
return Icon_SPU;
}
Reference in a new issue View git blame Copy permalink