VoxelWorld.h

浏览该文件的文档.

#pragma once
 
#include "voxel/Chunk.h"
#include "voxel/CubeTypeRegistry.h"
#include "voxel/FaceDir.h"
#include "voxel/Frustum.h"
#include "voxel/VoxelPack.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 IGraphics3D;
class Texture;
}  // namespace eve::graphics
 
namespace eve::data {
class ByteData;
}  // namespace eve::data
 
namespace eve::voxel {
 
struct StreamStats {
    int created = 0;  // chunks allocated + filled this pass
    int evicted = 0;  // chunks unloaded outside the radius
};
 
struct DrawBatch {
    const Chunk *chunk = nullptr;
    FaceDir dir = FaceDir::PosX;
    const uint32_t *packed = nullptr;
    const uint32_t *ao = nullptr;
    int count = 0;
};
 
class VoxelWorld {
public:
    VoxelWorld() = default;
    ~VoxelWorld();
    explicit VoxelWorld(const CubeTypeRegistry &types) : types_(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()); }
 
    int unloadChunksOutside(int centerX, int centerY, int centerZ, int radiusChunks);
 
    StreamStats streamAround(int centerX, int centerY, int centerZ, int radiusChunks,
                             const std::function<void(Chunk &, int, int, int)> &generator = {});
 
    void setTerrainParams(uint32_t seed, uint8_t top, uint8_t sub, uint8_t stone, float baseHeight, float amplitude,
                          float scale);
    void disableTerrain() { terrainEnabled_ = false; }
    bool terrainEnabled() const { return terrainEnabled_; }
 
    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);
 
    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::IGraphics3D *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);
 
    std::unordered_map<uint64_t, std::unique_ptr<Chunk>> chunks_;
    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;
    float terrainBase_ = 8.f;
    float terrainAmplitude_ = 14.f;
    bool terrainEnabled_ = false;
 
    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