RenderChunkCoordinator.h

#pragma once
 
#include "mc/_HeaderOutputPredefine.h"
 
// auto generated inclusion list
#include "mc/deps/game_refs/OwnerPtr.h"
#include "mc/world/level/BlockChangedEventTarget.h"
#include "mc/world/level/LevelListener.h"
#include "mc/world/level/SubChunkPos.h"
#include "mc/world/level/dimension/DimensionType.h"
 
// auto generated forward declare list
// clang-format off
class Actor;
class Block;
class BlockPos;
class BlockSource;
class ChunkSource;
class IRenderChunkGarbage;
class Level;
class LevelChunk;
class LevelRenderer;
class LevelRendererCamera;
class RenderChunkCoordinatorProxy;
class RenderChunkPerformanceData;
class RenderChunkShared;
struct ActorBlockSyncMessage;
struct BlockActorBlockSyncMessage;
// clang-format on
 
class RenderChunkCoordinator : public ::LevelListener {
public:
    // RenderChunkCoordinator inner types declare
    // clang-format off
    struct DirtyChunkData;
    // clang-format on
 
    // RenderChunkCoordinator inner types define
    struct DirtyChunkData {};
 
    using RenderChunkMapType = ::std::unordered_map<::SubChunkPos, ::std::weak_ptr<::RenderChunkShared>>;
 
public:
    // member variables
    // NOLINTBEGIN
    ::ll::TypedStorage<4, 4, float> mSweepAndPruneRatio;
    ::ll::TypedStorage<
        8,
        8,
        ::std::_List_const_iterator<::std::_List_val<
            ::std::_List_simple_types<::std::pair<::SubChunkPos const, ::std::weak_ptr<::RenderChunkShared>>>>>>
        mSweepAndPruneIterator;
    ::ll::TypedStorage<8, 64, ::std::unordered_map<::SubChunkPos, ::std::weak_ptr<::RenderChunkShared>>>
                                                                     mRenderChunkSharedMap;
    ::ll::TypedStorage<8, 8, ::Level&>                               mLevel;
    ::ll::TypedStorage<8, 8, ::LevelRenderer&>                       mLevelRenderer;
    ::ll::TypedStorage<8, 24, ::std::vector<::LevelRendererCamera*>> mLevelRendererCameraListenerList;
    ::ll::TypedStorage<4, 4, ::DimensionType>                        mDimensionId;
    ::ll::TypedStorage<8, 64, ::std::unordered_map<::SubChunkPos, ::RenderChunkCoordinator::DirtyChunkData>>
        mVisibilityDirtyRenderChunkMap;
    ::ll::TypedStorage<8, 64, ::std::unordered_map<::SubChunkPos, ::std::vector<::ActorBlockSyncMessage>>>
        mRenderChunkChangedEntityNotificationMap;
    ::ll::TypedStorage<8, 64, ::std::unordered_map<::SubChunkPos, ::std::vector<::BlockActorBlockSyncMessage>>>
        mRenderChunkChangedBlockEntityNotificationMap;
    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::RenderChunkCoordinatorProxy>> mProxy;
    ::ll::TypedStorage<8, 16, ::OwnerPtr<::RenderChunkPerformanceData>>        mRenderChunkPerformanceRegistry;
    ::ll::TypedStorage<8, 16, ::std::shared_ptr<::IRenderChunkGarbage>>        mGarbage;
    // NOLINTEND
 
public:
    // prevent constructor by default
    RenderChunkCoordinator& operator=(RenderChunkCoordinator const&);
    RenderChunkCoordinator(RenderChunkCoordinator const&);
    RenderChunkCoordinator();
 
public:
    // virtual functions
    // NOLINTBEGIN
    virtual ~RenderChunkCoordinator() /*override*/;
 
    virtual void onChunkLoaded(::ChunkSource& lc, ::LevelChunk&) /*override*/;
 
    virtual void onSubChunkLoaded(
        ::ChunkSource& lc,
        ::LevelChunk&  absoluteSubChunkIndex,
        short          subChunkVisibilityChanged,
        bool
    ) /*override*/;
 
    virtual void onBrightnessChanged(::BlockSource& source, ::BlockPos const& pos) /*override*/;
 
    virtual void onAreaChanged(::BlockSource& source, ::BlockPos const& min, ::BlockPos const& max) /*override*/;
 
    virtual void onBlockChanged(
        ::BlockSource&                 source,
        ::BlockPos const&              pos,
        uint                           layer,
        ::Block const&                 block,
        ::Block const&                 oldBlock,
        int                            updateFlags,
        ::ActorBlockSyncMessage const* syncMsg,
        ::BlockChangedEventTarget      eventTarget,
        ::Actor*                       blockChangeSource
    ) /*override*/;
    // NOLINTEND
 
public:
    // member functions
    // NOLINTBEGIN
    MCAPI RenderChunkCoordinator(::Level& level, ::LevelRenderer& levelRenderer, ::DimensionType dimensionID);
 
    MCAPI void _handleVisibilityUpdates();
 
    MCAPI void _launchVisibilityRebuild(::std::shared_ptr<::RenderChunkShared>& renderChunkShared);
 
    MCAPI void _setAllDirty(bool immediate, bool changesVisibility);
 
    MCAPI void
    _setDirty(::BlockPos const& min, ::BlockPos const& max, bool immediate, bool changesVisibility, bool canInterlock);
 
    MCAPI void addLevelRendererCameraListener(::LevelRendererCamera* levelRendererCamera);
 
    MCAPI ::std::shared_ptr<::RenderChunkShared> getOrCreateChunkAtPos(::SubChunkPos const& pos);
 
    MCFOLD ::RenderChunkCoordinatorProxy* getProxy();
 
    MCAPI uint64 getRenderChunkGeometryFaceMetadataMemoryUsed() const;
 
    MCAPI void preRenderTick();
 
    MCAPI void rebuildAllRenderChunkGeometry();
 
    MCAPI void relightAllRenderChunkGeometry();
 
    MCAPI void removeLevelRendererCameraListener(::LevelRendererCamera* levelRendererCamera);
 
    MCAPI void tick();
    // NOLINTEND
 
public:
    // static functions
    // NOLINTBEGIN
    MCAPI static bool shouldSetBlockAsDirty(
        ::BlockPos const& pos,
        ::Block const&    block,
        ::Block const&    oldBlock,
        ::BlockPos&       min,
        ::BlockPos&       max,
        bool&             changesVisibility
    );
    // NOLINTEND
 
public:
    // constructor thunks
    // NOLINTBEGIN
    MCAPI void* $ctor(::Level& level, ::LevelRenderer& levelRenderer, ::DimensionType dimensionID);
    // NOLINTEND
 
public:
    // destructor thunk
    // NOLINTBEGIN
    MCAPI void $dtor();
    // NOLINTEND
 
public:
    // virtual function thunks
    // NOLINTBEGIN
    MCAPI void $onChunkLoaded(::ChunkSource& lc, ::LevelChunk&);
 
    MCAPI void
    $onSubChunkLoaded(::ChunkSource& lc, ::LevelChunk& absoluteSubChunkIndex, short subChunkVisibilityChanged, bool);
 
    MCAPI void $onBrightnessChanged(::BlockSource& source, ::BlockPos const& pos);
 
    MCAPI void $onAreaChanged(::BlockSource& source, ::BlockPos const& min, ::BlockPos const& max);
 
    MCAPI void $onBlockChanged(
        ::BlockSource&                 source,
        ::BlockPos const&              pos,
        uint                           layer,
        ::Block const&                 block,
        ::Block const&                 oldBlock,
        int                            updateFlags,
        ::ActorBlockSyncMessage const* syncMsg,
        ::BlockChangedEventTarget      eventTarget,
        ::Actor*                       blockChangeSource
    );
    // NOLINTEND
 
public:
    // vftables
    // NOLINTBEGIN
    MCNAPI static void** $vftable();
    // NOLINTEND
};