VoxelWorld.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "voxel/Chunk.h"
#include "voxel/CubeTypeRegistry.h"
#include "voxel/FaceDir.h"
#include "voxel/Frustum.h"
#include "voxel/VoxelPack.h"
 
#include "procgen/heightmap/TerrainStreaming.h"
#include <cmath>
#include <cstdint>
#include <functional>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace eve::procgen {
class TerrainSampler;
}
 
namespace eve::graphics {
class Graphics;
class Texture;
}  // namespace eve::graphics
 
namespace eve::data {
class ByteData;
}  // namespace eve::data
 
namespace eve::thread {
class Job;
}
 
namespace eve::voxel {
 
struct StreamStats {
    int created = 0;  // chunks allocated + filled this pass
    int evicted = 0;  // chunks unloaded outside the radius
    int pending = 0;  // still missing inside the radius after this pass
};
 
struct DrawBatch {
    const Chunk *chunk = nullptr;
    FaceDir dir = FaceDir::PosX;
    const uint32_t *packed = nullptr;
    const uint32_t *ao = nullptr;
    int count = 0;
};
 
class EVENGINE_API_DOMAINS VoxelWorld {
public:
    VoxelWorld();
    ~VoxelWorld();
    explicit VoxelWorld(const CubeTypeRegistry &types);
 
    Chunk *getOrCreateChunk(int cx, int cy, int cz);
    Chunk *getChunk(int cx, int cy, int cz);
    const Chunk *getChunk(int cx, int cy, int cz) const;
    bool hasChunk(int cx, int cy, int cz) const;
    void removeChunk(int cx, int cy, int cz);
    void clear();
 
    int getChunkCount() const { return int(chunks_.size()); }
    uint64_t getRevision() const { return revision_; }
 
    int unloadChunksOutside(int centerX, int centerY, int centerZ, int radiusChunks);
 
    void setStreamCacheChunks(int extraChunks);
    int getStreamCacheChunks() const { return streamCacheChunks_; }
 
    StreamStats streamAround(int centerX, int centerY, int centerZ, int radiusChunks,
                             const std::function<void(Chunk &, int, int, int)> &generator = {},
                             int maxCreates = 0);
 
    void setTerrainParams(uint32_t seed, uint8_t top, uint8_t sub, uint8_t stone, float baseHeight, float amplitude,
                          float scale);
 
    void setTerrainParam(const std::string &key, float value);
 
    void disableTerrain();
    bool terrainEnabled() const { return terrainEnabled_ || terrainAssetEnabled_; }
 
    bool loadTerrainAsset(data::ByteData *bytes, float heightOffset = 0.f, float heightScale = 1.f);
    procgen::TerrainStreamStats streamTerrainAssetAround(int worldX, int worldZ, int radiusChunks,
                                                          int maxLoads = 0);
    void setTerrainAssetMaterials(uint8_t vegetation, uint8_t sand, uint8_t snow,
                                  uint8_t alpine, uint8_t riverbed);
    int getTerrainAssetResidentCount() const { return terrainAsset_.getResidentCount(); }
 
    int terrainHeightAt(int wx, int wz) const;
 
    void serializeWorld(std::vector<uint8_t> &out) const;
    bool deserializeWorld(const uint8_t *data, size_t size);
 
    data::ByteData *saveWorld() const;
    bool loadWorld(data::ByteData *bytes);
 
    int remeshDirty(int maxThreads = 0, int maxChunks = 0);
    int getDirtyCount() const;
    int getInflightStreamCount() const;
 
    void selectVisible(const float *viewProj16, float eyeX, float eyeY, float eyeZ, float viewRange,
                       bool faceCull = true);
 
    int getVisibleBatchCount() const { return int(visible_.size()); }
    const DrawBatch &getVisibleBatch(int index) const { return visible_[size_t(index)]; }
 
    int getVisibleChunkCount() const { return int(visibleChunkKeys_.size()); }
    void getVisibleChunkCoord(int index, int &cx, int &cy, int &cz) const;
    int getVisibleRectCount() const;
 
    void drawVisible(graphics::Graphics *gfx, graphics::Texture *atlas, int tilesPerRow = 16);
 
    uint8_t getVoxel(int wx, int wy, int wz) const;
    void setVoxel(int wx, int wy, int wz, uint8_t texId);
 
    bool raycast(float ox, float oy, float oz, float dx, float dy, float dz, float maxDist,
                 int &hitX, int &hitY, int &hitZ, int &prevX, int &prevY, int &prevZ,
                 int &faceX, int &faceY, int &faceZ) const;
 
    bool raycastScript(float ox, float oy, float oz, float dx, float dy, float dz, float maxDist);
    bool lastRaycastHit() const { return raycastHit_; }
    int lastRaycastHitX() const { return raycastHitX_; }
    int lastRaycastHitY() const { return raycastHitY_; }
    int lastRaycastHitZ() const { return raycastHitZ_; }
    int lastRaycastPrevX() const { return raycastPrevX_; }
    int lastRaycastPrevY() const { return raycastPrevY_; }
    int lastRaycastPrevZ() const { return raycastPrevZ_; }
    int lastRaycastFaceX() const { return raycastFaceX_; }
    int lastRaycastFaceY() const { return raycastFaceY_; }
    int lastRaycastFaceZ() const { return raycastFaceZ_; }
 
    void setVoxelByName(int wx, int wy, int wz, const std::string &name, int orientation = 0);
 
    std::string getCubeTypeName(int wx, int wy, int wz) const;
    uint8_t getCubeTypeTex(int wx, int wy, int wz, const std::string &faceDir) const;
 
    const CubeTypeRegistry &cubeTypes() const { return types_; }
 
private:
    static int floorDiv(int v) {
        return v >= 0 ? (v >> 5) : -(((-v - 1) >> 5) + 1);
    }
 
    static uint64_t key(int cx, int cy, int cz) {
        const uint64_t ux = uint64_t(uint32_t(cx) & 0x1FFFFFu);
        const uint64_t uy = uint64_t(uint32_t(cy) & 0x1FFFFFu);
        const uint64_t uz = uint64_t(uint32_t(cz) & 0x1FFFFFu);
        return ux | (uy << 21) | (uz << 42);
    }
 
    static void unpackKey(uint64_t k, int &cx, int &cy, int &cz) {
        auto signExtend21 = [](uint32_t v) -> int {
            if (v & 0x100000u) return int(v | 0xFFE00000u);
            return int(v);
        };
        cx = signExtend21(uint32_t(k & 0x1FFFFFu));
        cy = signExtend21(uint32_t((k >> 21) & 0x1FFFFFu));
        cz = signExtend21(uint32_t((k >> 42) & 0x1FFFFFu));
    }
 
    static uint8_t chunkNeighborSampler(void *userData, int chunkX, int chunkY, int chunkZ,
                                        int localX, int localY, int localZ);
 
    void markNeighborChunksDirty(int cx, int cy, int cz, int lx, int ly, int lz);
    uint8_t terrainSurfaceAt(int wx, int wz) const;
    void fillChunkTerrain(Chunk &chunk, int nx, int ny, int nz) const;
    void remeshChunks(const std::vector<Chunk *> &chunks, int maxThreads);
    void waitStreamJobs();
    void reapRetiredStreamJobs();
    void restoreRetiredInside(int centerX, int centerY, int centerZ, int radiusChunks);
    bool isStreamJob(int cx, int cy, int cz) const;
    int harvestStreamJobs(int centerX, int centerY, int centerZ, int radiusChunks, int maxHarvest);
    void dropStreamJobsOutside(int centerX, int centerY, int centerZ, int radiusChunks);
 
    struct StreamJob {
        int cx = 0;
        int cy = 0;
        int cz = 0;
        std::unique_ptr<Chunk> chunk;
        thread::Job *job = nullptr;
    };
 
    std::vector<StreamJob> inflight_;
    std::vector<StreamJob> retired_;
 
    std::unordered_map<uint64_t, std::unique_ptr<Chunk>> chunks_;
    int streamCacheChunks_ = 0;
    uint64_t revision_ = 0;
    std::vector<DrawBatch> visible_;
    std::vector<uint64_t> visibleChunkKeys_;
    CubeTypeRegistry types_;
    std::unique_ptr<procgen::TerrainSampler>             terrainSampler_;
    uint8_t terrainTop_ = 1;
    uint8_t terrainSub_ = 2;
    uint8_t terrainStone_ = 3;
    uint8_t terrainSand_ = 0;  // 0 = 沙滩带关闭
    float sandLevel_ = 0.f;    // 归一化采样高度阈值；≤0 关闭
    float terrainBase_ = 8.f;
    float terrainAmplitude_ = 14.f;
    bool terrainEnabled_ = false;
    procgen::TerrainStreamingCache terrainAsset_;
    bool terrainAssetEnabled_ = false;
    float terrainAssetOffset_ = 0.f;
    float terrainAssetScale_ = 1.f;
    uint8_t terrainVegetation_ = 1;
    uint8_t terrainAssetSand_ = 1;
    uint8_t terrainSnow_ = 1;
    uint8_t terrainAlpine_ = 3;
    uint8_t terrainRiverbed_ = 2;
 
    bool raycastHit_ = false;
    int raycastHitX_ = 0;
    int raycastHitY_ = 0;
    int raycastHitZ_ = 0;
    int raycastPrevX_ = 0;
    int raycastPrevY_ = 0;
    int raycastPrevZ_ = 0;
    int raycastFaceX_ = 0;
    int raycastFaceY_ = 0;
    int raycastFaceZ_ = 0;
};
 
}  // namespace eve::voxel