mirror of
https://github.com/MihailRis/voxelcore.git
synced 2026-11-20 09:29:44 +00:00
refactor ChunksController::loadVisible
This commit is contained in:
parent
2ec58d1a14
commit
7fcf049a72
3 changed files with 165 additions and 76 deletions
|
|
@ -1,5 +1,6 @@
|
|||
#include "ChunksController.hpp"
|
||||
|
||||
#include <algorithm>
|
||||
#include <limits.h>
|
||||
#include <memory>
|
||||
|
||||
|
|
@ -8,7 +9,6 @@
|
|||
#include "graphics/core/Mesh.hpp"
|
||||
#include "lighting/Lighting.hpp"
|
||||
#include "maths/voxmaths.hpp"
|
||||
#include "util/timeutil.hpp"
|
||||
#include "objects/Player.hpp"
|
||||
#include "voxels/Block.hpp"
|
||||
#include "voxels/Chunk.hpp"
|
||||
|
|
@ -18,9 +18,16 @@
|
|||
#include "world/LevelEvents.hpp"
|
||||
#include "world/World.hpp"
|
||||
#include "world/generator/WorldGenerator.hpp"
|
||||
#include "debug/Logger.hpp"
|
||||
|
||||
const uint MAX_WORK_PER_FRAME = 128;
|
||||
const uint MIN_SURROUNDING = 9;
|
||||
const float WORK_UNITS_PER_SPEED_SECOND = 600.0f;
|
||||
const float MAX_SECONDS_LIMIT = 0.25f;
|
||||
const int CREATE_CHUNK_COST = 2;
|
||||
const int BUILD_LIGHTS_COST = 4;
|
||||
|
||||
static debug::Logger logger("chunks-control");
|
||||
|
||||
ChunksController::ChunksController(Level& level)
|
||||
: level(level),
|
||||
|
|
@ -33,12 +40,13 @@ ChunksController::ChunksController(Level& level)
|
|||
ChunksController::~ChunksController() = default;
|
||||
|
||||
void ChunksController::update(
|
||||
int64_t maxDuration,
|
||||
float delta,
|
||||
int loadSpeed,
|
||||
int loadDistance,
|
||||
uint padding,
|
||||
Player& player,
|
||||
bool isLocalPlayer
|
||||
) const {
|
||||
) {
|
||||
const auto& position = player.getPosition();
|
||||
int centerX = floordiv<CHUNK_W>(glm::floor(position.x));
|
||||
int centerY = floordiv<CHUNK_D>(glm::floor(position.z));
|
||||
|
|
@ -50,18 +58,89 @@ void ChunksController::update(
|
|||
return;
|
||||
}
|
||||
|
||||
int64_t mcstotal = 0;
|
||||
auto& chunks = *player.chunks;
|
||||
auto& state = states[player.getId()];
|
||||
syncState(state, chunks, padding);
|
||||
|
||||
for (uint i = 0; i < MAX_WORK_PER_FRAME; i++) {
|
||||
timeutil::Timer timer;
|
||||
if (loadVisible(player, padding, isLocalPlayer)) {
|
||||
int64_t mcs = timer.stop();
|
||||
if (mcstotal + mcs < maxDuration * 1000) {
|
||||
mcstotal += mcs;
|
||||
continue;
|
||||
float rate = loadSpeed * WORK_UNITS_PER_SPEED_SECOND;
|
||||
state.budget = std::min(
|
||||
state.budget + rate * delta, rate * MAX_SECONDS_LIMIT
|
||||
);
|
||||
for (uint i = 0; i < MAX_WORK_PER_FRAME && state.budget > 0.0f; i++) {
|
||||
int cost = loadVisible(state, player, isLocalPlayer);
|
||||
if (cost == 0) {
|
||||
state.budget = 0.0f;
|
||||
break;
|
||||
}
|
||||
state.budget -= cost;
|
||||
}
|
||||
state.chunksCount = chunks.getChunksCount();
|
||||
}
|
||||
|
||||
void ChunksController::syncState(
|
||||
LoadingState& state, Chunks& chunks, uint padding
|
||||
) const {
|
||||
int sizeX = chunks.getWidth();
|
||||
int sizeY = chunks.getHeight();
|
||||
bool layoutChanged = state.width != sizeX || state.height != sizeY ||
|
||||
state.padding != padding;
|
||||
bool moved = state.offsetX != chunks.getOffsetX() ||
|
||||
state.offsetZ != chunks.getOffsetY();
|
||||
|
||||
if (layoutChanged) {
|
||||
state.width = sizeX;
|
||||
state.height = sizeY;
|
||||
state.padding = padding;
|
||||
state.order.clear();
|
||||
|
||||
int pad = static_cast<int>(padding);
|
||||
int minDistance = ((sizeX - pad * 2) / 2) * ((sizeY - pad * 2) / 2);
|
||||
std::vector<std::pair<int, int>> cells;
|
||||
for (int z = pad; z < sizeY - pad; z++) {
|
||||
for (int x = pad; x < sizeX - pad; x++) {
|
||||
int lx = x - sizeX / 2;
|
||||
int lz = z - sizeY / 2;
|
||||
int distance = lx * lx + lz * lz;
|
||||
if (distance < minDistance) {
|
||||
cells.emplace_back(distance, z * sizeX + x);
|
||||
}
|
||||
}
|
||||
}
|
||||
std::sort(cells.begin(), cells.end());
|
||||
state.order.reserve(cells.size());
|
||||
for (const auto& [_, index] : cells) {
|
||||
state.order.push_back(index);
|
||||
}
|
||||
}
|
||||
if (layoutChanged || moved) {
|
||||
removeFarChunks(chunks);
|
||||
state.offsetX = chunks.getOffsetX();
|
||||
state.offsetZ = chunks.getOffsetY();
|
||||
}
|
||||
if (layoutChanged || moved || state.chunksCount != chunks.getChunksCount()) {
|
||||
state.loadIndex = 0;
|
||||
state.lightIndex = 0;
|
||||
state.lightsDirty = true;
|
||||
state.chunksCount = chunks.getChunksCount();
|
||||
}
|
||||
}
|
||||
|
||||
void ChunksController::removeFarChunks(Chunks& chunks) const {
|
||||
int sizeX = chunks.getWidth();
|
||||
int sizeY = chunks.getHeight();
|
||||
int maxDistance = (sizeX / 2) * (sizeY / 2);
|
||||
const auto& buffer = chunks.getChunks();
|
||||
for (int z = 0; z < sizeY; z++) {
|
||||
for (int x = 0; x < sizeX; x++) {
|
||||
if (buffer[z * sizeX + x] == nullptr) {
|
||||
continue;
|
||||
}
|
||||
int lx = x - sizeX / 2;
|
||||
int lz = z - sizeY / 2;
|
||||
if (lx * lx + lz * lz >= maxDistance) {
|
||||
chunks.remove(x + chunks.getOffsetX(), z + chunks.getOffsetY());
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -81,68 +160,49 @@ bool ChunksController::isInLoadingZone(
|
|||
return distance < minDistance;
|
||||
}
|
||||
|
||||
bool ChunksController::loadVisible(
|
||||
const Player& player, uint padding, bool isLocalPlayer
|
||||
int ChunksController::loadVisible(
|
||||
LoadingState& state, const Player& player, bool isLocalPlayer
|
||||
) const {
|
||||
auto& chunks = *player.chunks;
|
||||
const auto& buffer = chunks.getChunks();
|
||||
const auto& order = state.order;
|
||||
|
||||
while (state.loadIndex < order.size() &&
|
||||
buffer[order[state.loadIndex]] != nullptr) {
|
||||
state.loadIndex++;
|
||||
}
|
||||
|
||||
if (isLocalPlayer && state.lightsDirty) {
|
||||
while (state.lightIndex < state.loadIndex) {
|
||||
const auto& chunk = buffer[order[state.lightIndex]];
|
||||
if (chunk && chunk->flags.loaded && !chunk->flags.lighted) {
|
||||
break;
|
||||
}
|
||||
state.lightIndex++;
|
||||
}
|
||||
for (size_t i = state.lightIndex; i < state.loadIndex; i++) {
|
||||
const auto& chunk = buffer[order[i]];
|
||||
if (chunk && chunk->flags.loaded && !chunk->flags.lighted &&
|
||||
buildLights(player, chunk)) {
|
||||
return BUILD_LIGHTS_COST;
|
||||
}
|
||||
}
|
||||
state.lightsDirty = false;
|
||||
}
|
||||
|
||||
if (state.loadIndex >= order.size() || !player.isLoadingChunks()) {
|
||||
return 0;
|
||||
}
|
||||
int index = order[state.loadIndex];
|
||||
int sizeX = chunks.getWidth();
|
||||
int sizeY = chunks.getHeight();
|
||||
|
||||
int nearX = 0;
|
||||
int nearZ = 0;
|
||||
bool assigned = false;
|
||||
int minDistance = ((sizeX - padding * 2) / 2) * ((sizeY - padding * 2) / 2);
|
||||
int maxDistance = ((sizeX) / 2) * ((sizeY) / 2);
|
||||
for (uint z = 0; z < sizeY; z++) {
|
||||
for (uint x = 0; x < sizeX; x++) {
|
||||
int index = z * sizeX + x;
|
||||
int lx = x - sizeX / 2;
|
||||
int lz = z - sizeY / 2;
|
||||
int distance = (lx * lx + lz * lz);
|
||||
auto& chunk = chunks.getChunks()[index];
|
||||
if (chunk != nullptr) {
|
||||
if (distance >= maxDistance) {
|
||||
chunks.remove(
|
||||
x + chunks.getOffsetX(), z + chunks.getOffsetY()
|
||||
);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
}
|
||||
}
|
||||
for (uint z = padding; z < sizeY - padding; z++) {
|
||||
for (uint x = padding; x < sizeX - padding; x++) {
|
||||
int index = z * sizeX + x;
|
||||
int lx = x - sizeX / 2;
|
||||
int lz = z - sizeY / 2;
|
||||
int distance = (lx * lx + lz * lz);
|
||||
auto& chunk = chunks.getChunks()[index];
|
||||
if (chunk != nullptr) {
|
||||
if (chunk->flags.loaded && !chunk->flags.lighted) {
|
||||
if (isLocalPlayer && buildLights(player, chunk)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
if (distance < minDistance) {
|
||||
minDistance = distance;
|
||||
nearX = x;
|
||||
nearZ = z;
|
||||
assigned = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const auto& chunk = chunks.getChunks()[nearZ * sizeX + nearX];
|
||||
if (chunk != nullptr || !assigned || !player.isLoadingChunks()) {
|
||||
return false;
|
||||
}
|
||||
int offsetX = chunks.getOffsetX();
|
||||
int offsetY = chunks.getOffsetY();
|
||||
createChunk(player, nearX + offsetX, nearZ + offsetY);
|
||||
return true;
|
||||
createChunk(
|
||||
player,
|
||||
index % sizeX + chunks.getOffsetX(),
|
||||
index / sizeX + chunks.getOffsetY()
|
||||
);
|
||||
state.loadIndex++;
|
||||
state.lightsDirty = true;
|
||||
return CREATE_CHUNK_COST;
|
||||
}
|
||||
|
||||
bool ChunksController::buildLights(
|
||||
|
|
|
|||
|
|
@ -1,6 +1,8 @@
|
|||
#pragma once
|
||||
|
||||
#include <memory>
|
||||
#include <unordered_map>
|
||||
#include <vector>
|
||||
|
||||
#include "typedefs.hpp"
|
||||
|
||||
|
|
@ -14,11 +16,35 @@ class WorldGenerator;
|
|||
/// @brief ChunksController manages chunks dynamic loading/unloading
|
||||
class ChunksController {
|
||||
private:
|
||||
struct LoadingState {
|
||||
int width = 0;
|
||||
int height = 0;
|
||||
uint padding = 0;
|
||||
|
||||
int offsetX = 0;
|
||||
int offsetZ = 0;
|
||||
|
||||
size_t chunksCount = 0;
|
||||
std::vector<int> order;
|
||||
size_t loadIndex = 0;
|
||||
size_t lightIndex = 0;
|
||||
bool lightsDirty = true;
|
||||
|
||||
float budget = 0.0f;
|
||||
};
|
||||
|
||||
Level& level;
|
||||
std::unique_ptr<WorldGenerator> generator;
|
||||
std::unordered_map<u64id_t, LoadingState> states;
|
||||
|
||||
void syncState(LoadingState& state, Chunks& chunks, uint padding) const;
|
||||
void removeFarChunks(Chunks& chunks) const;
|
||||
|
||||
/// @brief Process one chunk: load it or calculate lights for it
|
||||
bool loadVisible(const Player& player, uint padding, bool isLocalPlayer) const;
|
||||
/// @return work units spent, 0 if there is nothing to do
|
||||
int loadVisible(
|
||||
LoadingState& state, const Player& player, bool isLocalPlayer
|
||||
) const;
|
||||
bool buildLights(const Player& player, const std::shared_ptr<Chunk>& chunk) const;
|
||||
void createChunk(const Player& player, int x, int y) const;
|
||||
public:
|
||||
|
|
@ -27,14 +53,16 @@ public:
|
|||
ChunksController(Level& level);
|
||||
~ChunksController();
|
||||
|
||||
/// @param maxDuration milliseconds reserved for chunks loading
|
||||
/// @param delta frame time in seconds
|
||||
/// @param loadSpeed chunks loading speed
|
||||
void update(
|
||||
int64_t maxDuration,
|
||||
float delta,
|
||||
int loadSpeed,
|
||||
int loadDistance,
|
||||
uint padding,
|
||||
Player& player,
|
||||
bool isLocalPlayer
|
||||
) const;
|
||||
);
|
||||
|
||||
bool isInLoadingZone(const Player& player, uint padding, int x, int z) const;
|
||||
|
||||
|
|
|
|||
|
|
@ -63,7 +63,7 @@ LevelController::LevelController(
|
|||
player->chunks->configure(
|
||||
std::floor(position.x), std::floor(position.z), 1
|
||||
);
|
||||
chunks->update(16, 1, 0, *player, player.get() == clientPlayer);
|
||||
chunks->update(1.0f, 16, 1, 0, *player, player.get() == clientPlayer);
|
||||
if (player->chunks->get(
|
||||
std::floor(position.x), 0, std::floor(position.z)
|
||||
)) {
|
||||
|
|
@ -89,6 +89,7 @@ void LevelController::update(float delta, bool pause) {
|
|||
settings.chunks.loadDistance.get() + settings.chunks.padding.get()
|
||||
);
|
||||
chunks->update(
|
||||
delta,
|
||||
settings.chunks.loadSpeed.get(),
|
||||
settings.chunks.loadDistance.get(),
|
||||
settings.chunks.padding.get(),
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue