SubChunk.h

#pragma once
 
#include "mc/_HeaderOutputPredefine.h"
 
// auto generated inclusion list
#include "mc/platform/threading/SpinLockImpl.h"
#include "mc/world/level/block/chunk_volume/SubVolumeViewOf.h"
#include "mc/world/level/chunk/DirtyTicksCounter.h"
#include "mc/world/level/chunk/SubChunkBrightnessStorage.h"
#include "mc/world/level/chunk/SubChunkStorage.h"
#include "mc/world/level/chunk/sub_chunk_storage_unit/PruneType.h"
 
// auto generated forward declare list
// clang-format off
class Block;
class BlockPalette;
class BlockPos;
class BlockVolume;
class IDataInput;
class IDataOutput;
class SubChunkBrightnessStorage;
class SubChunkPos;
struct DeserializationChanges;
// clang-format on
 
struct SubChunk {
public:
    // SubChunk inner types define
    enum class BlockLayer : uchar {
        Standard = 0,
        Extra    = 1,
        Count    = 2,
    };
 
    enum class SubChunkState : int {
        Invalid                    = -1,
        Normal                     = 0,
        IsLightingSystemSubChunk   = 1,
        NeedsRequest               = 2,
        ReceivedResponseFromServer = 3,
        ProcessingSubChunk         = 4,
        WaitingForCacheResponse    = 5,
        ProcessedSubChunk          = 6,
        RequestFinished            = 7,
    };
 
    using Layer = uchar;
 
public:
    // member variables
    // NOLINTBEGIN
    ::ll::TypedStorage<4, 8, ::DirtyTicksCounter>                               mDirtyTicksCounter;
    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::SubChunkBrightnessStorage>>    mSkyLight;
    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::SubChunkBrightnessStorage>>    mBlockLight;
    ::ll::TypedStorage<4, 4, ::SubChunk::SubChunkState>                         mSubChunkState;
    ::ll::TypedStorage<1, 1, bool>                                              mHasMaxSkyLight;
    ::ll::TypedStorage<1, 1, bool>                                              mNeedsInitLighting;
    ::ll::TypedStorage<1, 1, bool>                                              mNeedsClientLighting;
    ::ll::TypedStorage<8, 16, ::std::unique_ptr<::SubChunkStorage<::Block>>[2]> mBlocks;
    ::ll::TypedStorage<8, 16, ::SubChunkStorage<::Block>* [2]>                  mBlocksReadPtr;
    ::ll::TypedStorage<8, 24, ::SpinLockImpl>                                   mWriteLock;
    ::ll::TypedStorage<8, 8, uint64>                                            mHash;
    ::ll::TypedStorage<1, 1, bool>                                              mHashDirty;
    ::ll::TypedStorage<1, 1, schar>                                             mAbsoluteIndex;
    ::ll::TypedStorage<1, 1, bool>                                              mIsReplacementSubChunk;
    ::ll::TypedStorage<1, 1, uchar>                                             mRenderChunkTrackingVersionNumber;
    ::ll::TypedStorage<1, 1, bool>                                              mIsInitialized;
    // NOLINTEND
 
public:
    [[nodiscard]] bool isUniform(::Block const& block) const {
        if (!mBlocksReadPtr[0]->isUniform(block)) {
            return false;
        }
        // The extra layer is optional; a subchunk with only a standard layer is uniform whenever that layer is.
        if (mBlocksReadPtr[1] != nullptr) {
            return mBlocksReadPtr[1]->isUniform(block);
        }
        return true;
    }
 
public:
    // prevent constructor by default
    SubChunk& operator=(SubChunk const&);
    SubChunk(SubChunk const&);
    SubChunk();
 
public:
    // member functions
    // NOLINTBEGIN
    MCNAPI SubChunk(::SubChunk&& rhs);
 
    MCNAPI SubChunk(::Block const* initBlock, bool maxSkyLight, bool maxLight, schar absoluteIndex);
 
#ifdef LL_PLAT_C
    MCNAPI void _createBlockLightStorage();
 
    MCNAPI void _createSkyLightStorage();
#endif
 
#ifdef LL_PLAT_S
    MCNAPI void _resetLight(bool maxSkyLight, bool maxLight);
#endif
 
    MCNAPI void _setBlock(uchar layer, ushort index, ::Block const& block);
 
    MCNAPI void deserialize(
        ::IDataInput&                              stream,
        ::BlockPalette const&                      palette,
        ::SubChunkPos const&                       subChunkPos,
        ::std::optional<::DeserializationChanges*> deserializationChanges
    );
 
    MCNAPI void fetchBlocks(
        ::BlockPos const& subChunkOrigin,
        ::BlockPos const& volumeOrigin,
        short             dimensionMinHeight,
        ::BlockVolume&    volume
    ) const;
 
    MCNAPI void initialize(::Block const* initBlock, bool maxSkyLight, bool maxLight, schar absoluteIndex);
 
#ifdef LL_PLAT_C
    MCAPI bool isPlaceHolderSubChunk() const;
#endif
 
    MCNAPI ::SubChunk& operator=(::SubChunk&& rhs);
 
    MCNAPI void prune(::SubChunkStorageUnit::PruneType pruneType);
 
    MCNAPI ::std::string recalculateHashAndSerialize(bool network);
 
    MCNAPI void reset(::Block const* resetBlock, bool maxSkyLight, bool fullyLit);
 
    MCAPI void serialize(::IDataOutput& stream, bool network) const;
 
#ifdef LL_PLAT_S
    MCNAPI void setBlockLight(ushort index, uchar lightValue);
#endif
 
    MCNAPI void setBlocksToUniform(::Block const& initBlock, bool maxSkyLight, bool fullyLit);
 
    MCNAPI void setFromBlockVolume(
        ::BlockVolume const&                           box,
        short                                          height,
        ::ChunkVolume::SubVolumeViewOf<::Block const*> scratchVolume
    );
 
#ifdef LL_PLAT_C
    MCNAPI void setLight(ushort idx, ::SubChunkBrightnessStorage::LightPair pair);
#endif
 
#ifdef LL_PLAT_S
    MCNAPI void setSkyLight(ushort index, uchar lightValue);
#endif
 
    MCNAPI ~SubChunk();
    // NOLINTEND
 
public:
    // constructor thunks
    // NOLINTBEGIN
    MCNAPI void* $ctor(::SubChunk&& rhs);
 
    MCNAPI void* $ctor(::Block const* initBlock, bool maxSkyLight, bool maxLight, schar absoluteIndex);
    // NOLINTEND
 
public:
    // destructor thunk
    // NOLINTBEGIN
    MCNAPI void $dtor();
    // NOLINTEND
};