voxelcoreprojects/voxelcore
1
0
Fork 0
mirror of https://github.com/MihailRis/voxelcore.git synced 2026-10-05 19:11:50 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 5

Merge branch 'main' of https://github.com/MihailRis/VoxelEngine-Cpp

Browse source
This commit is contained in:
clasher113 2026-02-28 18:35:02 +02:00
commit 13eca72753
7 changed files with 112 additions and 90 deletions
Download patch file Download diff file Expand all files Collapse all files

3
res/modules/internal/bytearray.lua
View file

@ -261,7 +261,8 @@ local function create_FFIview_class(name, typename, typesize)
return function()
i = i + 1
if i <= self.bytes.size / typesize then
return i, self.ptr[i - 1]
local ptr = FFI.cast(ptrtype, self.bytes.bytes)
return i, ptr[i - 1]
end
end
end

110
src/audio/AL/ALAudio.cpp
View file

@ -47,6 +47,7 @@ static LPALDELETEEFFECTS alDeleteEffects = nullptr;
static LPALISEFFECT alIsEffect = nullptr;
static LPALEFFECTI alEffecti = nullptr;
static LPALEFFECTF alEffectf = nullptr;
static LPALGETEFFECTF alGetEffectf = nullptr;
static LPALGENFILTERS alGenFilters = nullptr;
static LPALDELETEFILTERS alDeleteFilters = nullptr;
static LPALISFILTER alIsFilter = nullptr;
@ -562,6 +563,7 @@ static bool request_efx_ext_functions() {
&& get_proc_address("alIsEffect", alIsEffect)
&& get_proc_address("alEffecti", alEffecti)
&& get_proc_address("alEffectf", alEffectf)
&& get_proc_address("alGetEffectf", alGetEffectf)
&& get_proc_address("alGenFilters", alGenFilters)
&& get_proc_address("alDeleteFilters", alDeleteFilters)
&& get_proc_address("alIsFilter", alIsFilter)
@ -799,77 +801,73 @@ void ALAudio::setAcoustics(Acoustics acoustics) {
alAuxiliaryEffectSloti(effectSlots[0], AL_EFFECTSLOT_EFFECT, 0);
return;
}
auto setEffectValue = [](int effect, ALenum param, float value, float min, float max) {
const float smoothFactor = 0.5f;
value = glm::clamp(value, min, max);
float prevValue = 0.0f;
alGetEffectf(effect, param, &prevValue);
AL_CHECK(alEffectf(
effect,
param,
glm::clamp(
prevValue * (1.0f - smoothFactor) + value * smoothFactor,
min,
max
)
));
};
int reverbEffect = effects[REVERB_EFFECT];
AL_CHECK(alEffectf(
setEffectValue(
reverbEffect,
AL_REVERB_GAIN,
glm::clamp(glm::min(acoustics.reverbGain, 0.8f) *
acoustics.reverbGain *
(1.0f - glm::min(1.0f, acoustics.reverbAbsorption)),
AL_REVERB_MIN_GAIN,
AL_REVERB_MAX_GAIN)
));
AL_CHECK(alEffectf(
AL_REVERB_MIN_GAIN,
AL_REVERB_MAX_GAIN
);
setEffectValue(
reverbEffect,
AL_REVERB_REFLECTIONS_DELAY,
glm::clamp(
acoustics.reverbReflectionsDelay,
AL_REVERB_MIN_REFLECTIONS_DELAY,
AL_REVERB_MAX_REFLECTIONS_DELAY
)
));
AL_CHECK(alEffectf(
acoustics.reverbReflectionsDelay,
AL_REVERB_MIN_REFLECTIONS_DELAY,
AL_REVERB_MAX_REFLECTIONS_DELAY
);
setEffectValue(
reverbEffect,
AL_REVERB_LATE_REVERB_DELAY,
glm::clamp(
acoustics.reverbLateReflectionsDelay,
AL_REVERB_MIN_LATE_REVERB_DELAY,
AL_REVERB_MAX_LATE_REVERB_DELAY
)
));
AL_CHECK(alEffectf(
acoustics.reverbLateReflectionsDelay,
AL_REVERB_MIN_LATE_REVERB_DELAY,
AL_REVERB_MAX_LATE_REVERB_DELAY
);
setEffectValue(
reverbEffect,
AL_REVERB_DECAY_TIME,
glm::clamp(
acoustics.reverbDecayTime,
AL_REVERB_MIN_DECAY_TIME,
AL_REVERB_MAX_DECAY_TIME
)
));
AL_CHECK(alEffectf(
acoustics.reverbDecayTime,
AL_REVERB_MIN_DECAY_TIME,
AL_REVERB_MAX_DECAY_TIME
);
setEffectValue(
reverbEffect,
AL_REVERB_ROOM_ROLLOFF_FACTOR,
glm::clamp(
acoustics.reverbRoomRolloff,
AL_REVERB_MIN_ROOM_ROLLOFF_FACTOR,
AL_REVERB_MAX_ROOM_ROLLOFF_FACTOR
)
));
AL_CHECK(alEffectf(
acoustics.reverbRoomRolloff,
AL_REVERB_MIN_ROOM_ROLLOFF_FACTOR,
AL_REVERB_MAX_ROOM_ROLLOFF_FACTOR
);
setEffectValue(
reverbEffect,
AL_REVERB_REFLECTIONS_GAIN,
glm::clamp(
glm::pow(acoustics.reverbGain, 2.0f),
AL_REVERB_MIN_REFLECTIONS_GAIN,
AL_REVERB_MAX_REFLECTIONS_GAIN
)
));
AL_CHECK(alEffectf(
glm::pow(acoustics.reverbGain, 2.0f),
AL_REVERB_MIN_REFLECTIONS_GAIN,
AL_REVERB_MAX_REFLECTIONS_GAIN
);
setEffectValue(
reverbEffect,
AL_REVERB_LATE_REVERB_GAIN,
glm::clamp(
glm::pow(acoustics.reverbGain, 2.0f),
AL_REVERB_MIN_LATE_REVERB_GAIN,
AL_REVERB_MAX_LATE_REVERB_GAIN
)
));
AL_CHECK(alEffectf(
reverbEffect,
AL_REVERB_DECAY_HFRATIO,
glm::clamp(
1.0f - acoustics.reverbAbsorption,
AL_REVERB_MIN_DECAY_HFRATIO,
AL_REVERB_MAX_DECAY_HFRATIO
)
));
glm::pow(acoustics.reverbGain, 2.0f),
AL_REVERB_MIN_LATE_REVERB_GAIN,
AL_REVERB_MAX_LATE_REVERB_GAIN
);
alAuxiliaryEffectSloti(effectSlots[0], AL_EFFECTSLOT_EFFECT, reverbEffect);
}

41
src/graphics/render/Decorator.cpp
View file

@ -1,29 +1,30 @@
#include "Decorator.hpp"
#include "ParticlesRenderer.hpp"
#include "WorldRenderer.hpp"
#include "TextsRenderer.hpp"
#include "TextNote.hpp"
#include "assets/Assets.hpp"
#include "assets/assets_util.hpp"
#include "assets/Assets.hpp"
#include "audio/audio.hpp"
#include "content/Content.hpp"
#include "voxels/Chunks.hpp"
#include "voxels/Chunk.hpp"
#include "voxels/Block.hpp"
#include "world/Level.hpp"
#include "window/Camera.hpp"
#include "objects/Player.hpp"
#include "objects/Players.hpp"
#include "objects/Entities.hpp"
#include "objects/Entity.hpp"
#include "logic/LevelController.hpp"
#include "util/stringutil.hpp"
#include "debug/Logger.hpp"
#include "engine/Engine.hpp"
#include "engine/EnginePaths.hpp"
#include "io/io.hpp"
#include "audio/audio.hpp"
#include "logic/LevelController.hpp"
#include "maths/util.hpp"
#include "debug/Logger.hpp"
#include "objects/Entities.hpp"
#include "objects/Entity.hpp"
#include "objects/Player.hpp"
#include "objects/Players.hpp"
#include "ParticlesRenderer.hpp"
#include "settings.hpp"
#include "TextNote.hpp"
#include "TextsRenderer.hpp"
#include "util/stringutil.hpp"
#include "voxels/Block.hpp"
#include "voxels/Chunk.hpp"
#include "voxels/Chunks.hpp"
#include "window/Camera.hpp"
#include "world/Level.hpp"
#include "WorldRenderer.hpp"
namespace fs = std::filesystem;
@ -48,6 +49,7 @@ Decorator::Decorator(
)
: level(*controller.getLevel()),
assets(assets),
settings(engine.getSettings()),
player(player),
renderer(renderer) {
controller.getBlocksController()->listenBlockInteraction(
@ -90,6 +92,9 @@ void Decorator::addParticles(const Block& def, const glm::ivec3& pos) {
}
void Decorator::updateAcoustics(const Camera& camera) {
if (!settings.audio.acousticEffects.get()) {
return;
}
audio::Acoustics acoustics {};
util::PseudoRandom random(34621U);

2
src/graphics/render/Decorator.hpp
View file

@ -20,10 +20,12 @@ class LevelController;
class WorldRenderer;
struct Weather;
struct WeatherPreset;
struct EngineSettings;
class Decorator {
const Level& level;
const Assets& assets;
const EngineSettings& settings;
Player& player;
WorldRenderer& renderer;
std::unordered_map<glm::ivec3, uint64_t> blockEmitters;

2
src/graphics/render/ModelBatch.cpp
View file

@ -135,7 +135,7 @@ void ModelBatch::setLightsOffset(const glm::vec3& offset) {
void ModelBatch::setTexture(const std::string& name,
const texture_names_map* varTextures) {
if (varTextures && name.at(0) == '$') {
if (varTextures && !name.empty() && name.at(0) == '$') {
const auto& found = varTextures->find(name);
if (found == varTextures->end()) {
return batch->setTexture(nullptr);

38
src/logic/BlocksController.cpp
View file

@ -16,6 +16,11 @@
#include "world/World.hpp"
#include "objects/Player.hpp"
#include "objects/Players.hpp"
#include "util/random.hpp"
#include <random>
static inline constexpr int CHUNK_RANDOM_TICK_SEGMENTS = 4;
BlocksController::BlocksController(const Level& level, Lighting* lighting)
: level(level),
@ -150,20 +155,36 @@ void BlocksController::onBlocksTick(int tickid, int parts) {
}
void BlocksController::randomTick(
const Chunk& chunk, int segments, const ContentIndices* indices
const Chunk& chunk, const ContentIndices* indices
) {
const int segments = CHUNK_RANDOM_TICK_SEGMENTS;
const int segheight = CHUNK_H / segments;
static std::array<int, CHUNK_VOL / segments> randomPattern;
static bool randomPatternInitialized = false;
if (!randomPatternInitialized) {
randomPatternInitialized = true;
for (int i = 0; i < randomPattern.size(); i++) {
randomPattern[i] = i;
}
auto randomDevice = std::random_device{};
auto randomEngine =
util::seeded_random_engine<std::mt19937_64>(randomDevice);
std::shuffle(randomPattern.begin(), randomPattern.end(), randomEngine);
}
for (int s = 0; s < segments; s++) {
for (int i = 0; i < 4; i++) {
int repetions = 4;
for (int i = 0; i < repetions; i++) {
int segmentY = s * segheight;
if (segmentY > chunk.top) {
if (segmentY > chunk.top) {
break;
}
int bx = random.rand() % CHUNK_W;
int by = random.rand() % segheight + segmentY;
int bz = random.rand() % CHUNK_D;
const voxel& vox = chunk.voxels[vox_index(bx, by, bz)];
size_t index = randomPattern[(s * repetions + i + randomTickId) % randomPattern.size()];
int bx = index % CHUNK_W;
int bz = (index / CHUNK_W) % CHUNK_D;
int by = (index / (CHUNK_W * CHUNK_D)) + segmentY;
const voxel& vox = chunk.voxels[index + segmentY * CHUNK_W * CHUNK_D];
auto& block = indices->blocks.require(vox.id);
if (block.rt.funcsset.randupdate) {
scripting::random_update_block(
@ -184,7 +205,6 @@ void BlocksController::randomTick(int tickid, int parts, uint padding) {
const auto& chunks = *player->chunks;
int width = chunks.getWidth();
int height = chunks.getHeight();
int segments = 4;
for (uint z = padding; z < height - padding; z++) {
for (uint x = padding; x < width - padding; x++) {
@ -200,7 +220,7 @@ void BlocksController::randomTick(int tickid, int parts, uint padding) {
continue;
}
chunk->lastRandomTickId = randomTickId;
randomTick(*chunk, segments, indices);
randomTick(*chunk, indices);
}
}
}

6
src/logic/BlocksController.hpp
View file

@ -3,7 +3,6 @@
#include <functional>
#include <glm/glm.hpp>
#include "maths/fastmaths.hpp"
#include "typedefs.hpp"
#include "util/Clock.hpp"
#include "voxels/voxel.hpp"
@ -31,7 +30,6 @@ class BlocksController {
util::Clock randTickClock;
util::Clock blocksTickClock;
util::Clock worldTickClock;
FastRandom random {};
std::vector<OnBlockInteraction> blockInteractionCallbacks;
uint64_t randomTickId = 0;
public:
@ -47,9 +45,7 @@ public:
);
void update(float delta, uint padding);
void randomTick(
const Chunk& chunk, int segments, const ContentIndices* indices
);
void randomTick(const Chunk& chunk, const ContentIndices* indices);
void randomTick(int tickid, int parts, uint padding);
void onBlocksTick(int tickid, int parts);
int64_t createBlockInventory(int x, int y, int z);