From 0b24efeb005e293a026f2ac8666020cea8316578 Mon Sep 17 00:00:00 2001 From: "madmaxoft@gmail.com" Date: Wed, 14 Mar 2012 20:56:09 +0000 Subject: Split chunk data into separate arrays; decoupled most sources from cChunk.h dependency git-svn-id: http://mc-server.googlecode.com/svn/trunk@411 0a769ca7-a7f5-676a-18bf-c427514a06d6 --- source/ChunkDef.h | 320 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 320 insertions(+) create mode 100644 source/ChunkDef.h (limited to 'source/ChunkDef.h') diff --git a/source/ChunkDef.h b/source/ChunkDef.h new file mode 100644 index 000000000..38dfcd7b4 --- /dev/null +++ b/source/ChunkDef.h @@ -0,0 +1,320 @@ + +// ChunkDef.h + +// Interfaces to helper types for chunk definitions. Most modules want to include this instead of cChunk.h + + + + + +#pragma once + +#include "Vector3i.h" + + + + + +/** This is really only a placeholder to be used in places where we need to "make up" a chunk's Y coord. +It will help us when the new chunk format comes out and we need to patch everything up for compatibility. +*/ +#define ZERO_CHUNK_Y 0 + +// Used to smoothly convert to new axis ordering. One will be removed when deemed stable. +#define AXIS_ORDER_YZX 1 // Original (1.1-) +#define AXIS_ORDER_XZY 2 // New (1.2+) +#define AXIS_ORDER AXIS_ORDER_XZY + + + + + +// fwd +class cBlockEntity; +class cEntity; +class cClientHandle; +class cBlockEntity; + +typedef std::list cEntityList; +typedef std::list cBlockEntityList; + + + + +/// The datatype used by blockdata, metadata, blocklight and skylight +typedef char BLOCKTYPE; + + + + + +/// Constants used throughout the code, useful typedefs and utility functions +class cChunkDef +{ +public: + static const int Width = 16; + static const int Height = 256; + static const int NumBlocks = Width * Height * Width; + static const int BlockDataSize = NumBlocks * 2 + (NumBlocks / 2); // 2.5 * numblocks + + // Offsets to individual components in the joined blockdata array + static const int MetaOffset = NumBlocks; + static const int LightOffset = MetaOffset + NumBlocks / 2; + static const int SkyLightOffset = LightOffset + NumBlocks / 2; + + static const unsigned int INDEX_OUT_OF_RANGE = 0xffffffff; + + typedef unsigned char HeightMap[Width * Width]; + + + /// Converts absolute block coords into relative (chunk + block) coords: + inline static void AbsoluteToRelative(/* in-out */ int & a_X, int & a_Y, int & a_Z, /* out */ int & a_ChunkX, int & a_ChunkZ ) + { + BlockToChunk(a_X, a_Y, a_Z, a_ChunkX, a_ChunkZ); + + a_X = a_X - a_ChunkX * Width; + a_Z = a_Z - a_ChunkZ * Width; + } + + + /// Converts absolute block coords to chunk coords: + inline static void BlockToChunk( int a_X, int a_Y, int a_Z, int & a_ChunkX, int & a_ChunkZ ) + { + (void)a_Y; + a_ChunkX = a_X / Width; + if ((a_X < 0) && (a_X % Width != 0)) + { + a_ChunkX--; + } + a_ChunkZ = a_Z / cChunkDef::Width; + if ((a_Z < 0) && (a_Z % Width != 0)) + { + a_ChunkZ--; + } + } + + + inline static unsigned int MakeIndex(int x, int y, int z ) + { + if( x < cChunkDef::Width && x > -1 && y < cChunkDef::Height && y > -1 && z < cChunkDef::Width && z > -1 ) + { + return MakeIndexNoCheck(x, y, z); + } + return INDEX_OUT_OF_RANGE; + } + + + inline static unsigned int MakeIndexNoCheck(int x, int y, int z) + { + #if AXIS_ORDER == AXIS_ORDER_XZY + // For some reason, NOT using the Horner schema is faster. Weird. + return x + (z * cChunkDef::Width) + (y * cChunkDef::Width * cChunkDef::Width); // 1.2 is XZY + #elif AXIS_ORDER == AXIS_ORDER_YZX + return y + (z * cChunkDef::Width) + (x * cChunkDef::Height * cChunkDef::Width); // 1.1 is YZX + #endif + } + + + inline static Vector3i IndexToCoordinate( unsigned int index ) + { + #if AXIS_ORDER == AXIS_ORDER_XZY + return Vector3i( // 1.2 + index % cChunkDef::Width, // X + index / (cChunkDef::Width * cChunkDef::Width), // Y + (index / cChunkDef::Width) % cChunkDef::Width // Z + ); + #elif AXIS_ORDER == AXIS_ORDER_YZX + return Vector3i( // 1.1 + index / (cChunkDef::Height * cChunkDef::Width), // X + index % cChunkDef::Height, // Y + (index / cChunkDef::Height) % cChunkDef::Width // Z + ); + #endif + } + + + static BLOCKTYPE GetNibble(BLOCKTYPE * a_Buffer, int a_BlockIdx) + { + if ((a_BlockIdx > -1) && (a_BlockIdx < cChunkDef::NumBlocks)) + { + return (a_Buffer[a_BlockIdx / 2] >> ((a_BlockIdx & 1) * 4)) & 0x0f; + } + return 0; + } + + + static BLOCKTYPE GetNibble(BLOCKTYPE * a_Buffer, int x, int y, int z) + { + if ((x < Width) && (x > -1) && (y < Height) && (y > -1) && (z < Width) && (z > -1)) + { + int Index = MakeIndexNoCheck(x, y, z); + return (a_Buffer[Index / 2] >> ((Index & 1) * 4)) & 0x0f; + } + return 0; + } + + + static void SetNibble(BLOCKTYPE * a_Buffer, int a_BlockIdx, BLOCKTYPE a_Nibble) + { + if ((a_BlockIdx > -1) && (a_BlockIdx < cChunkDef::NumBlocks)) + { + a_Buffer[a_BlockIdx / 2] = ( + (a_Buffer[a_BlockIdx / 2] & (0xf0 >> ((a_BlockIdx & 1) * 4))) | // The untouched nibble + ((a_Nibble & 0x0f) << ((a_BlockIdx & 1) * 4)) // The nibble being set + ); + } + } + + + static void SetNibble(BLOCKTYPE * a_Buffer, int x, int y, int z, BLOCKTYPE a_Nibble) + { + if ((x < cChunkDef::Width) && (x > -1) && (y < cChunkDef::Height) && (y > -1) && (z < cChunkDef::Width) && (z > -1)) + { + int Index = MakeIndexNoCheck(x, y, z); + a_Buffer[Index / 2] = ( + (a_Buffer[Index / 2] & (0xf0 >> ((Index & 1) * 4))) | // The untouched nibble + ((a_Nibble & 0x0f) << ((Index & 1) * 4)) // The nibble being set + ); + } + } + + + inline static BLOCKTYPE GetNibble(BLOCKTYPE * a_Buffer, const Vector3i & a_BlockPos ) + { + return GetNibble( a_Buffer, a_BlockPos.x, a_BlockPos.y, a_BlockPos.z ); + } + + + inline static void SetNibble(BLOCKTYPE * a_Buffer, const Vector3i & a_BlockPos, char a_Value ) + { + SetNibble( a_Buffer, a_BlockPos.x, a_BlockPos.y, a_BlockPos.z, a_Value ); + } + +} ; + + + + + +/** Interface class used for getting data out of a chunk using the GetAllData() function. +Implementation must use the pointers immediately and NOT store any of them for later use +The virtual methods are called in the same order as they're declared here. +*/ +class cChunkDataCallback abstract +{ +public: + /// Called once to provide heightmap data + virtual void HeightMap(const cChunkDef::HeightMap * a_HeightMap) {}; + + /// Called once to export block types + virtual void BlockTypes (const BLOCKTYPE * a_Type) {}; + + /// Called once to export block meta + virtual void BlockMeta (const BLOCKTYPE * a_Meta) {}; + + /// Called once to export block light + virtual void BlockLight (const BLOCKTYPE * a_Meta) {}; + + /// Called once to export sky light + virtual void BlockSkyLight(const BLOCKTYPE * a_Meta) {}; + + /// Called for each entity in the chunk + virtual void Entity(cEntity * a_Entity) {}; + + /// Called for each blockentity in the chunk + virtual void BlockEntity(cBlockEntity * a_Entity) {}; +} ; + + + + + +/** A simple implementation of the cChunkDataCallback interface that collects all block data into a single buffer +*/ +class cChunkDataCollector : + public cChunkDataCallback +{ +protected: + BLOCKTYPE m_BlockData[cChunkDef::BlockDataSize]; + + virtual void BlockTypes(const BLOCKTYPE * a_BlockTypes) override + { + memcpy(m_BlockData, a_BlockTypes, cChunkDef::NumBlocks); + } + + + virtual void BlockMeta(const BLOCKTYPE * a_BlockMeta) override + { + memcpy(m_BlockData + cChunkDef::NumBlocks, a_BlockMeta, cChunkDef::NumBlocks / 2); + } + + + virtual void BlockLight(const BLOCKTYPE * a_BlockLight) override + { + memcpy(m_BlockData + 3 * cChunkDef::NumBlocks / 2, a_BlockLight, cChunkDef::NumBlocks / 2); + } + + + virtual void BlockSkyLight(const BLOCKTYPE * a_BlockSkyLight) override + { + memcpy(m_BlockData + 2 * cChunkDef::NumBlocks, a_BlockSkyLight, cChunkDef::NumBlocks / 2); + } +} ; + + + + + +/** Interface class used for comparing clients of two chunks. +Used primarily for entity moving while both chunks are locked. +*/ +class cClientDiffCallback +{ +public: + /// Called for clients that are in Chunk1 and not in Chunk2, + virtual void Removed(cClientHandle * a_Client) = 0; + + /// Called for clients that are in Chunk2 and not in Chunk1. + virtual void Added(cClientHandle * a_Client) = 0; +} ; + + + + + +struct sSetBlock +{ + int x, y, z; + int ChunkX, ChunkZ; + char BlockType, BlockMeta; + + sSetBlock( int a_X, int a_Y, int a_Z, char a_BlockType, char a_BlockMeta ); // absolute block position +}; + +typedef std::list< sSetBlock > sSetBlockList; + + + + + +class cChunkCoords +{ +public: + int m_ChunkX; + int m_ChunkY; + int m_ChunkZ; + + cChunkCoords(int a_ChunkX, int a_ChunkY, int a_ChunkZ) : m_ChunkX(a_ChunkX), m_ChunkY(a_ChunkY), m_ChunkZ(a_ChunkZ) {} + + bool operator == (const cChunkCoords & a_Other) const + { + return ((m_ChunkX == a_Other.m_ChunkX) && (m_ChunkY == a_Other.m_ChunkY) && (m_ChunkZ == a_Other.m_ChunkZ)); + } +} ; + +typedef std::list cChunkCoordsList; + + + + + -- cgit v1.2.3