diff options
Diffstat (limited to 'Minecraft.Client/PS3/SPU_Tasks/ChunkUpdate/TileRenderer_SPU.cpp')
| -rw-r--r-- | Minecraft.Client/PS3/SPU_Tasks/ChunkUpdate/TileRenderer_SPU.cpp | 7635 |
1 files changed, 7635 insertions, 0 deletions
diff --git a/Minecraft.Client/PS3/SPU_Tasks/ChunkUpdate/TileRenderer_SPU.cpp b/Minecraft.Client/PS3/SPU_Tasks/ChunkUpdate/TileRenderer_SPU.cpp new file mode 100644 index 00000000..ab9b2c94 --- /dev/null +++ b/Minecraft.Client/PS3/SPU_Tasks/ChunkUpdate/TileRenderer_SPU.cpp @@ -0,0 +1,7635 @@ +#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 "GameRenderer.h" +// #include "Minecraft.h" +// #include "Textures.h" +// #include "..\Minecraft.World\net.minecraft.world.level.h" +// #include "..\..\..\Minecraft.World\net.minecraft.world.level.tile.h" +// #include "..\Minecraft.World\net.minecraft.world.level.material.h" +// #include "..\Minecraft.World\net.minecraft.h" +// #include "..\Minecraft.World\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\SharedConstants.h" +#include "Facing_SPU.h" + +// #include "EntityTileRenderer.h" +// #include "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; +}
\ No newline at end of file |