1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
|
#pragma once
using namespace std;
class DataLayer;
class TileEntity;
class Random;
class ChunkSource;
class EntitySelector;
#include "SparseLightStorage.h"
#include "CompressedTileStorage.h"
#include "SparseDataStorage.h"
#include "LightLayer.h"
#include "Entity.h"
#include "Level.h"
#define SHARING_ENABLED
class TileCompressData_SPU;
#if 0//__PSVITA__
#define _ENTITIES_RW_SECTION
#endif
class LevelChunk
{
friend class TileCompressData_SPU;
friend class LevelRenderer;
public:
byteArray biomes; // 4J Stu - Made public
static constexpr int ENTITY_BLOCKS_LENGTH = Level::maxBuildHeight/16;
static constexpr int BLOCKS_LENGTH = Level::CHUNK_TILE_COUNT; // 4J added
static bool touchedSky;
enum EColumnFlag
{
eColumnFlag_recheck = 1,
eColumnFlag_biomeOk = 2,
eColumnFlag_biomeHasSnow = 4,
eColumnFlag_biomeHasRain = 8,
};
// byteArray blocks;
// 4J - actual storage for blocks is now private with public methods to access it
private:
CompressedTileStorage *lowerBlocks; // 0 - 127
CompressedTileStorage *upperBlocks; // 128 - 255
public:
bool isRenderChunkEmpty(int y);
void setBlockData(byteArray data); // Set block data to that passed in in the input array of size 32768
void getBlockData(byteArray data); // Sets data in passed in array of size 32768, from the block data in this chunk
int getBlocksAllocatedSize(int *count0, int *count1, int *count2, int *count4, int *count8);
bool loaded;
unsigned char rainHeights[16*16]; // 4J - optimisation brought forward from 1.8.2 (was int arrayb in java though)
unsigned char columnFlags[16*8]; // 4J - lighting update brought forward from 1.8.2, was a bool array but now mixed with other flags in our version, and stored in nybbles
Level *level;
// 4J - actual storage for data is now private with public methods to access it
private:
SparseDataStorage *lowerData; // 0 - 127
SparseDataStorage *upperData; // 128 - 255
public:
void setDataData(byteArray data); // Set data to that passed in in the input array of size 32768
void getDataData(byteArray data); // Sets data in passed in array of size 16384, from the data in this chunk
// DataLayer *data;
private:
// 4J - actual storage for sky & block lights is now private with new methods to be able to access it.
SparseLightStorage *lowerSkyLight; // 0 - 127
SparseLightStorage *upperSkyLight; // 128 - 255
SparseLightStorage *lowerBlockLight; // 0 - 127
SparseLightStorage *upperBlockLight; // 128 - 255
public:
void getSkyLightData(byteArray data); // Get a byte array of length 16384 ( 128 x 16 x 16 x 0.5 ), containing sky light data. Ordering same as java version.
void getBlockLightData(byteArray data); // Get a byte array of length 16384 ( 128 x 16 x 16 x 0.5 ), containing block light data. Ordering same as java version.
void setSkyLightData(byteArray data); // Set sky light data to data passed in input byte array of length 16384. This data must be in original (java version) order
void setBlockLightData(byteArray data); // Set block light data to data passed in input byte array of length 16384. This data must be in original (java version) order
void setSkyLightDataAllBright(); // Set sky light data to be all fully lit
bool isLowerBlockStorageCompressed();
int isLowerBlockLightStorageCompressed();
int isLowerDataStorageCompressed();
void writeCompressedBlockData(DataOutputStream *dos);
void writeCompressedDataData(DataOutputStream *dos);
void writeCompressedSkyLightData(DataOutputStream *dos);
void writeCompressedBlockLightData(DataOutputStream *dos);
void readCompressedBlockData(DataInputStream *dis);
void readCompressedDataData(DataInputStream *dis);
void readCompressedSkyLightData(DataInputStream *dis);
void readCompressedBlockLightData(DataInputStream *dis);
byteArray heightmap;
int minHeight;
int x, z;
private:
bool hasGapsToCheck;
public:
unordered_map<TilePos, shared_ptr<TileEntity>, TilePosKeyHash, TilePosKeyEq> tileEntities;
vector<shared_ptr<Entity> > **entityBlocks;
static const int sTerrainPopulatedFromHere = 2;
static const int sTerrainPopulatedFromW = 4;
static const int sTerrainPopulatedFromS = 8;
static const int sTerrainPopulatedFromSW = 16;
static const int sTerrainPopulatedAllAffecting = 30; // All the post-processing that can actually place tiles in this chunk are complete
static const int sTerrainPopulatedFromNW = 32;
static const int sTerrainPopulatedFromN = 64;
static const int sTerrainPopulatedFromNE = 128;
static const int sTerrainPopulatedFromE = 256;
static const int sTerrainPopulatedFromSE = 512;
static const int sTerrainPopulatedAllNeighbours = 1022; // The post-processing passes of all neighbours to this chunk are complete
static const int sTerrainPostPostProcessed = 1024; // This chunk has been post-post-processed, which is only done when all neighbours have been post-processed
short terrainPopulated; // 4J - changed from bool to bitfield within short
short *serverTerrainPopulated; // 4J added
void setUnsaved(bool unsaved); // 4J added
protected:
// 4J Stu - Stopped this being private so we can add some more logic to it
bool m_unsaved;
public:
bool dontSave;
bool lastSaveHadEntities;
#ifdef SHARING_ENABLED
bool sharingTilesAndData; // 4J added
#endif
bool emissiveAdded; // 4J added
void stopSharingTilesAndData(); // 4J added
virtual void reSyncLighting(); // 4J added
void startSharingTilesAndData(int forceMs = 0); // 4J added
int64_t lastUnsharedTime; // 4J added
int64_t lastSaveTime;
bool seenByPlayer;
int lowestHeightmap;
int64_t inhabitedTime;
#ifdef _LARGE_WORLDS
bool m_bUnloaded;
CompoundTag *m_unloadedEntitiesTag;
#endif
//static const int LIGHT_CHECK_MAX_POS = NUM_SECTIONS * 16 * 16;
private:
int checkLightPosition;
public:
virtual void init(Level *level, int x, int z);
LevelChunk(Level *level, int x, int z);
LevelChunk(Level *level, byteArray blocks, int x, int z);
LevelChunk(Level *level, int x, int z, LevelChunk *lc);
~LevelChunk();
virtual bool isAt(int x, int z);
virtual int getHeightmap(int x, int z);
int getHighestSectionPosition();
virtual void recalcBlockLights();
virtual void recalcHeightmapOnly();
virtual void recalcHeightmap();
virtual void lightLava();
private:
void lightGaps(int x, int z);
// 4J - changes for lighting brought forward from 1.8.2
public:
void recheckGaps(bool bForce = false); // 4J - added parameter, made public
private:
void lightGap(int x, int z, int source);
void lightGap(int x, int z, int y1, int y2);
void recalcHeight(int x, int yStart, int z);
public:
virtual int getTileLightBlock(int x, int y, int z);
virtual int getTile(int x, int y, int z);
virtual bool setTileAndData(int x, int y, int z, int _tile, int _data);
virtual bool setTile(int x, int y, int z, int _tile);
virtual int getData(int x, int y, int z);
virtual bool setData(int x, int y, int z, int val, int mask, bool *maskedBitsChanged); // 4J added mask
virtual int getBrightness(LightLayer::variety layer, int x, int y, int z);
virtual void getNeighbourBrightnesses(int *brightnesses, LightLayer::variety layer, int x, int y, int z); // 4J added
virtual void setBrightness(LightLayer::variety layer, int x, int y, int z, int brightness);
virtual int getRawBrightness(int x, int y, int z, int skyDampen);
virtual void addEntity(shared_ptr<Entity> e);
virtual void addRidingEntities(shared_ptr<Entity> rider, CompoundTag *riderTag);
virtual void removeEntity(shared_ptr<Entity> e);
virtual void removeEntity(shared_ptr<Entity> e, int yc);
virtual bool isSkyLit(int x, int y, int z);
virtual void skyBrightnessChanged();
virtual shared_ptr<TileEntity> getTileEntity(int x, int y, int z);
virtual void addTileEntity(shared_ptr<TileEntity> te);
virtual void setTileEntity(int x, int y, int z, shared_ptr<TileEntity> tileEntity);
virtual void removeTileEntity(int x, int y, int z);
virtual void load();
virtual void unload(bool unloadTileEntities) ; // 4J - added parameter
virtual bool containsPlayer(); // 4J - added
#ifdef _LARGE_WORLDS
virtual bool isUnloaded();
#endif
virtual void markUnsaved();
virtual void getEntities(shared_ptr<Entity> except, AABB *bb, vector<shared_ptr<Entity> > &es, const EntitySelector *selector);
virtual void getEntitiesOfClass(const type_info& ec, AABB *bb, vector<shared_ptr<Entity> > &es, const EntitySelector *selector);
virtual int countEntities();
virtual bool shouldSave(bool force);
virtual int getBlocksAndData(byteArray *data, int x0, int y0, int z0, int x1, int y1, int z1, int p, bool includeLighting = true); // 4J - added includeLighting parameter
static void tileUpdatedCallback(int x, int y, int z, void *param, int yparam); // 4J added
virtual int setBlocksAndData(byteArray data, int x0, int y0, int z0, int x1, int y1, int z1, int p, bool includeLighting = true); // 4J - added includeLighting parameter
virtual bool testSetBlocksAndData(byteArray data, int x0, int y0, int z0, int x1, int y1, int z1, int p); // 4J added
virtual void setCheckAllLight();
virtual Random *getRandom(int64_t l);
virtual bool isEmpty();
virtual void attemptCompression();
#ifdef SHARING_ENABLED
static CRITICAL_SECTION m_csSharing; // 4J added
#endif
// 4J added
#ifdef _ENTITIES_RW_SECTION
static CRITICAL_RW_SECTION m_csEntities; // AP - we're using a RW critical so we can do multiple reads without contention
#else
static CRITICAL_SECTION m_csEntities;
#endif
static CRITICAL_SECTION m_csTileEntities; // 4J added
static void staticCtor();
void checkPostProcess(ChunkSource *source, ChunkSource *parent, int x, int z);
void checkChests(ChunkSource *source, int x, int z ); // 4J added
int getTopRainBlock(int x, int z); // 4J - optimisation brought forward from 1.8.2
void tick(); // 4J - lighting change brought forward from 1.8.2
ChunkPos *getPos();
bool isYSpaceEmpty(int y1, int y2);
void reloadBiomes(); // 4J added
virtual Biome *getBiome(int x, int z, BiomeSource *biomeSource);
byteArray getBiomes();
void setBiomes(byteArray biomes);
bool biomeHasRain(int x, int z); // 4J added
bool biomeHasSnow(int x, int z); // 4J added
private:
void updateBiomeFlags(int x, int z); // 4J added
public:
void compressLighting(); // 4J added
void compressBlocks(); // 4J added
void compressData(); // 4J added
int getHighestNonEmptyY();
byteArray getReorderedBlocksAndData(int x, int y, int z, int xs, int &ys, int zs);
static void reorderBlocksAndDataToXZY(int y0, int xs, int ys, int zs, byteArray *data);
#ifdef LIGHT_COMPRESSION_STATS
int getBlockLightPlanesLower() { return lowerBlockLight->count; }
int getSkyLightPlanesLower() { return lowerSkyLight->count; }
int getBlockLightPlanesUpper() { return upperBlockLight->count; }
int getSkyLightPlanesUpper() { return upperSkyLight->count; }
#endif
#ifdef DATA_COMPRESSION_STATS
int getDataPlanes() { return data->count; }
#endif
};
|
