summaryrefslogtreecommitdiffstats
path: root/Tools/QtBiomeVisualiser/ChunkSource.cpp
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--Tools/QtBiomeVisualiser/ChunkSource.cpp421
1 files changed, 421 insertions, 0 deletions
diff --git a/Tools/QtBiomeVisualiser/ChunkSource.cpp b/Tools/QtBiomeVisualiser/ChunkSource.cpp
new file mode 100644
index 000000000..bebf89a0a
--- /dev/null
+++ b/Tools/QtBiomeVisualiser/ChunkSource.cpp
@@ -0,0 +1,421 @@
+#include "Globals.h"
+#include "ChunkSource.h"
+#include <QThread>
+#include "src/Generating/BioGen.h"
+#include "src/StringCompression.h"
+#include "src/WorldStorage/FastNBT.h"
+#include "inifile/iniFile.h"
+
+
+
+
+
+/** Map for converting biome values to colors. Initialized from biomeColors[]. */
+static uchar biomeToColor[256 * 4];
+
+/** Map for converting biome values to colors. Used to initialize biomeToColor[].*/
+static struct
+{
+ EMCSBiome m_Biome;
+ uchar m_Color[3];
+} biomeColors[] =
+{
+ { biOcean, { 0x00, 0x00, 0x70 }, },
+ { biPlains, { 0x8d, 0xb3, 0x60 }, },
+ { biDesert, { 0xfa, 0x94, 0x18 }, },
+ { biExtremeHills, { 0x60, 0x60, 0x60 }, },
+ { biForest, { 0x05, 0x66, 0x21 }, },
+ { biTaiga, { 0x0b, 0x66, 0x59 }, },
+ { biSwampland, { 0x2f, 0xff, 0xda }, },
+ { biRiver, { 0x30, 0x30, 0xaf }, },
+ { biHell, { 0x7f, 0x00, 0x00 }, },
+ { biSky, { 0x00, 0x7f, 0xff }, },
+ { biFrozenOcean, { 0xa0, 0xa0, 0xdf }, },
+ { biFrozenRiver, { 0xa0, 0xa0, 0xff }, },
+ { biIcePlains, { 0xff, 0xff, 0xff }, },
+ { biIceMountains, { 0xa0, 0xa0, 0xa0 }, },
+ { biMushroomIsland, { 0xff, 0x00, 0xff }, },
+ { biMushroomShore, { 0xa0, 0x00, 0xff }, },
+ { biBeach, { 0xfa, 0xde, 0x55 }, },
+ { biDesertHills, { 0xd2, 0x5f, 0x12 }, },
+ { biForestHills, { 0x22, 0x55, 0x1c }, },
+ { biTaigaHills, { 0x16, 0x39, 0x33 }, },
+ { biExtremeHillsEdge, { 0x7f, 0x8f, 0x7f }, },
+ { biJungle, { 0x53, 0x7b, 0x09 }, },
+ { biJungleHills, { 0x2c, 0x42, 0x05 }, },
+
+ { biJungleEdge, { 0x62, 0x8b, 0x17 }, },
+ { biDeepOcean, { 0x00, 0x00, 0x30 }, },
+ { biStoneBeach, { 0xa2, 0xa2, 0x84 }, },
+ { biColdBeach, { 0xfa, 0xf0, 0xc0 }, },
+ { biBirchForest, { 0x30, 0x74, 0x44 }, },
+ { biBirchForestHills, { 0x1f, 0x5f, 0x32 }, },
+ { biRoofedForest, { 0x40, 0x51, 0x1a }, },
+ { biColdTaiga, { 0x31, 0x55, 0x4a }, },
+ { biColdTaigaHills, { 0x59, 0x7d, 0x72 }, },
+ { biMegaTaiga, { 0x59, 0x66, 0x51 }, },
+ { biMegaTaigaHills, { 0x59, 0x66, 0x59 }, },
+ { biExtremeHillsPlus, { 0x50, 0x70, 0x50 }, },
+ { biSavanna, { 0xbd, 0xb2, 0x5f }, },
+ { biSavannaPlateau, { 0xa7, 0x9d, 0x64 }, },
+ { biMesa, { 0xd9, 0x45, 0x15 }, },
+ { biMesaPlateauF, { 0xb0, 0x97, 0x65 }, },
+ { biMesaPlateau, { 0xca, 0x8c, 0x65 }, },
+
+ // M variants:
+ { biSunflowerPlains, { 0xb5, 0xdb, 0x88 }, },
+ { biDesertM, { 0xff, 0xbc, 0x40 }, },
+ { biExtremeHillsM, { 0x88, 0x88, 0x88 }, },
+ { biFlowerForest, { 0x2d, 0x8e, 0x49 }, },
+ { biTaigaM, { 0x33, 0x8e, 0x81 }, },
+ { biSwamplandM, { 0x07, 0xf9, 0xb2 }, },
+ { biIcePlainsSpikes, { 0xb4, 0xdc, 0xdc }, },
+ { biJungleM, { 0x7b, 0xa3, 0x31 }, },
+ { biJungleEdgeM, { 0x62, 0x8b, 0x17 }, },
+ { biBirchForestM, { 0x58, 0x9c, 0x6c }, },
+ { biBirchForestHillsM, { 0x47, 0x87, 0x5a }, },
+ { biRoofedForestM, { 0x68, 0x79, 0x42 }, },
+ { biColdTaigaM, { 0x24, 0x3f, 0x36 }, },
+ { biMegaSpruceTaiga, { 0x45, 0x4f, 0x3e }, },
+ { biMegaSpruceTaigaHills, { 0x45, 0x4f, 0x4e }, },
+ { biExtremeHillsPlusM, { 0x78, 0x98, 0x78 }, },
+ { biSavannaM, { 0xe5, 0xda, 0x87 }, },
+ { biSavannaPlateauM, { 0xa7, 0x9d, 0x74 }, },
+ { biMesaBryce, { 0xff, 0x6d, 0x3d }, },
+ { biMesaPlateauFM, { 0xd8, 0xbf, 0x8d }, },
+ { biMesaPlateauM, { 0xf2, 0xb4, 0x8d }, },
+} ;
+
+
+
+
+
+static class BiomeColorsInitializer
+{
+public:
+ BiomeColorsInitializer(void)
+ {
+ // Reset all colors to gray:
+ for (size_t i = 0; i < ARRAYCOUNT(biomeToColor); i++)
+ {
+ biomeToColor[i] = 0x7f;
+ }
+
+ // Set known biomes to their colors:
+ for (size_t i = 0; i < ARRAYCOUNT(biomeColors); i++)
+ {
+ uchar * color = &biomeToColor[4 * biomeColors[i].m_Biome];
+ color[0] = biomeColors[i].m_Color[2];
+ color[1] = biomeColors[i].m_Color[1];
+ color[2] = biomeColors[i].m_Color[0];
+ color[3] = 0xff;
+ }
+ }
+} biomeColorInitializer;
+
+
+
+
+
+/** Converts biomes in an array into the chunk image data. */
+static void biomesToImage(cChunkDef::BiomeMap & a_Biomes, Chunk::Image & a_Image)
+{
+ // Make sure the two arrays are of the same size, compile-time.
+ // Note that a_Image is actually 4 items per pixel, so the array is 4 times bigger:
+ static const char Check1[4 * ARRAYCOUNT(a_Biomes) - ARRAYCOUNT(a_Image) + 1] = {};
+ static const char Check2[ARRAYCOUNT(a_Image) - 4 * ARRAYCOUNT(a_Biomes) + 1] = {};
+
+ // Convert the biomes into color:
+ for (size_t i = 0; i < ARRAYCOUNT(a_Biomes); i++)
+ {
+ a_Image[4 * i + 0] = biomeToColor[4 * a_Biomes[i] + 0];
+ a_Image[4 * i + 1] = biomeToColor[4 * a_Biomes[i] + 1];
+ a_Image[4 * i + 2] = biomeToColor[4 * a_Biomes[i] + 2];
+ a_Image[4 * i + 3] = biomeToColor[4 * a_Biomes[i] + 3];
+ }
+}
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+// BioGenSource:
+
+BioGenSource::BioGenSource(cIniFilePtr a_IniFile) :
+ m_IniFile(a_IniFile),
+ m_Mtx(QMutex::Recursive)
+{
+ reload();
+}
+
+
+
+
+
+void BioGenSource::getChunkBiomes(int a_ChunkX, int a_ChunkZ, ChunkPtr a_DestChunk)
+{
+ cChunkDef::BiomeMap biomes;
+ {
+ QMutexLocker lock(&m_Mtx);
+ m_BiomeGen->GenBiomes(a_ChunkX, a_ChunkZ, biomes);
+ }
+ Chunk::Image img;
+ biomesToImage(biomes, img);
+ a_DestChunk->setImage(img);
+}
+
+
+
+
+
+void BioGenSource::reload()
+{
+ int seed = m_IniFile->GetValueSetI("Generator", "Seed", 0);
+ bool unused = false;
+ QMutexLocker lock(&m_Mtx);
+ m_BiomeGen.reset(cBiomeGen::CreateBiomeGen(*m_IniFile, seed, unused));
+}
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+// AnvilSource::AnvilFile
+
+class AnvilSource::AnvilFile
+{
+public:
+ /** Coordinates of the region file. */
+ int m_RegionX, m_RegionZ;
+
+ /** True iff the file contains proper data. */
+ bool m_IsValid;
+
+
+
+ /** Creates a new instance with the specified region coords. Reads the file header. */
+ AnvilFile(int a_RegionX, int a_RegionZ, const AString & a_WorldPath) :
+ m_RegionX(a_RegionX),
+ m_RegionZ(a_RegionZ),
+ m_IsValid(false)
+ {
+ readFile(Printf("%s/r.%d.%d.mca", a_WorldPath.c_str(), a_RegionX, a_RegionZ));
+ }
+
+
+
+ /** Returns the compressed data of the specified chunk.
+ Returns an empty string when chunk not present. */
+ AString getChunkData(int a_ChunkX, int a_ChunkZ)
+ {
+ if (!m_IsValid)
+ {
+ return "";
+ }
+
+ // Translate to local coords:
+ int RelChunkX = a_ChunkX - m_RegionX * 32;
+ int RelChunkZ = a_ChunkZ - m_RegionZ * 32;
+ ASSERT((RelChunkX >= 0) && (RelChunkX < 32));
+ ASSERT((RelChunkZ >= 0) && (RelChunkZ < 32));
+
+ // Get the chunk data location:
+ UInt32 chunkOffset = m_Header[RelChunkX + 32 * RelChunkZ] >> 8;
+ UInt32 numChunkSectors = m_Header[RelChunkX + 32 * RelChunkZ] & 0xff;
+ if ((chunkOffset < 2) || (numChunkSectors == 0))
+ {
+ return "";
+ }
+
+ // Get the real data size:
+ const char * chunkData = m_FileData.data() + chunkOffset * 4096;
+ UInt32 chunkSize = GetBEInt(chunkData);
+ if ((chunkSize < 2) || (chunkSize / 4096 > numChunkSectors))
+ {
+ // Bad data, bail out
+ return "";
+ }
+
+ // Check the compression method:
+ if (chunkData[4] != 2)
+ {
+ // Chunk is in an unknown compression
+ return "";
+ }
+ chunkSize--;
+
+ // Read the chunk data:
+ return m_FileData.substr(chunkOffset * 4096 + 5, chunkSize);
+ }
+
+protected:
+ AString m_FileData;
+ UInt32 m_Header[2048];
+
+
+ /** Reads the whole specified file contents and parses the header. */
+ void readFile(const AString & a_FileName)
+ {
+ // Read the entire file:
+ m_FileData = cFile::ReadWholeFile(a_FileName);
+ if (m_FileData.size() < sizeof(m_Header))
+ {
+ return;
+ }
+
+ // Parse the header - change endianness:
+ const char * hdr = m_FileData.data();
+ for (size_t i = 0; i < ARRAYCOUNT(m_Header); i++)
+ {
+ m_Header[i] = GetBEInt(hdr + 4 * i);
+ }
+ m_IsValid = true;
+ }
+};
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+// AnvilSource:
+
+AnvilSource::AnvilSource(QString a_WorldRegionFolder) :
+ m_WorldRegionFolder(a_WorldRegionFolder)
+{
+}
+
+
+
+
+
+void AnvilSource::getChunkBiomes(int a_ChunkX, int a_ChunkZ, ChunkPtr a_DestChunk)
+{
+ // Load the compressed data:
+ AString compressedChunkData = getCompressedChunkData(a_ChunkX, a_ChunkZ);
+ if (compressedChunkData.empty())
+ {
+ return;
+ }
+
+ // Uncompress the chunk data:
+ AString uncompressed;
+ int res = InflateString(compressedChunkData.data(), compressedChunkData.size(), uncompressed);
+ if (res != Z_OK)
+ {
+ return;
+ }
+
+ // Parse the NBT data:
+ cParsedNBT nbt(uncompressed.data(), uncompressed.size());
+ if (!nbt.IsValid())
+ {
+ return;
+ }
+
+ // Get the biomes out of the NBT:
+ int Level = nbt.FindChildByName(0, "Level");
+ if (Level < 0)
+ {
+ return;
+ }
+ cChunkDef::BiomeMap biomeMap;
+ int mcsBiomes = nbt.FindChildByName(Level, "MCSBiomes");
+ if ((mcsBiomes >= 0) && (nbt.GetDataLength(mcsBiomes) == sizeof(biomeMap)))
+ {
+ // Convert the biomes from BigEndian to platform native numbers:
+ const char * beBiomes = nbt.GetData(mcsBiomes);
+ for (size_t i = 0; i < ARRAYCOUNT(biomeMap); i++)
+ {
+ biomeMap[i] = (EMCSBiome)GetBEInt(beBiomes + 4 * i);
+ }
+ // Render the biomes:
+ Chunk::Image img;
+ biomesToImage(biomeMap, img);
+ a_DestChunk->setImage(img);
+ return;
+ }
+
+ // MCS biomes not found, load Vanilla biomes instead:
+ int biomes = nbt.FindChildByName(Level, "Biomes");
+ if ((biomes < 0) || (nbt.GetDataLength(biomes) != ARRAYCOUNT(biomeMap)))
+ {
+ return;
+ }
+ // Convert the biomes from Vanilla to EMCSBiome:
+ const char * vanillaBiomes = nbt.GetData(biomes);
+ for (size_t i = 0; i < ARRAYCOUNT(biomeMap); i++)
+ {
+ biomeMap[i] = EMCSBiome(vanillaBiomes[i]);
+ }
+ // Render the biomes:
+ Chunk::Image img;
+ biomesToImage(biomeMap, img);
+ a_DestChunk->setImage(img);
+}
+
+
+
+
+
+void AnvilSource::reload()
+{
+ // Remove all files from the cache:
+ QMutexLocker lock(&m_Mtx);
+ m_Files.clear();
+}
+
+
+
+
+
+void AnvilSource::chunkToRegion(int a_ChunkX, int a_ChunkZ, int & a_RegionX, int & a_RegionZ)
+{
+ a_RegionX = a_ChunkX >> 5;
+ a_RegionZ = a_ChunkZ >> 5;
+}
+
+
+
+
+
+AString AnvilSource::getCompressedChunkData(int a_ChunkX, int a_ChunkZ)
+{
+ return getAnvilFile(a_ChunkX, a_ChunkZ)->getChunkData(a_ChunkX, a_ChunkZ);
+}
+
+
+
+
+
+AnvilSource::AnvilFilePtr AnvilSource::getAnvilFile(int a_ChunkX, int a_ChunkZ)
+{
+ int RegionX, RegionZ;
+ chunkToRegion(a_ChunkX, a_ChunkZ, RegionX, RegionZ);
+
+ // Search the cache for the file:
+ QMutexLocker lock(&m_Mtx);
+ for (auto itr = m_Files.cbegin(), end = m_Files.cend(); itr != end; ++itr)
+ {
+ if (((*itr)->m_RegionX == RegionX) && ((*itr)->m_RegionZ == RegionZ))
+ {
+ // Found the file in the cache, move it to front and return it:
+ AnvilFilePtr file(*itr);
+ m_Files.erase(itr);
+ m_Files.push_front(file);
+ return file;
+ }
+ }
+
+ // File not in cache, create it:
+ AnvilFilePtr file(new AnvilFile(RegionX, RegionZ, m_WorldRegionFolder.toStdString()));
+ m_Files.push_front(file);
+ return file;
+}
+
+
+
+
+
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-05 11:03:45 +0100