EVEngine/Fluids_8cpp_source.html

#include "fluids/Fluids.h"


#include "common/SquirrelBinding.h"

#include "fluids/FluidGpuKernels.h"

#include "fluids/VolumeFluid.h"

#include "fluids/VolumeFluidBindings.h"

#include "fluids/VolumeFluidCodec.h"

#include "fluids/VolumeFluidDiffuse.h"

#include "gpgpu/ComputeShader.h"

#include "gpgpu/Gpgpu.h"

#include "gpgpu/GpuBuffer.h"

#include "gpgpu/Sequence.h"

#include "image/ImageData.h"


#include <algorithm>

#include <cmath>

#include <cstdint>

#include <cstring>

#include <exception>

#include <simplesquirrel/simplesquirrel.hpp>

#include <utility>


namespace eve::fluids {

namespace {


constexpr int kPushCount       = 0;

constexpr int kPushDt          = 1;

constexpr int kPushRadius      = 2;

constexpr int kPushH           = 3;

constexpr int kPushRestDensity = 4;

constexpr int kPushGravityX    = 5;

constexpr int kPushGravityY    = 6;

constexpr int kPushGravityZ    = 7;

constexpr int kPushViscosity   = 8;

constexpr int kPushYield       = 9;

constexpr int kPushCohesion    = 10;

constexpr int kPushAdhesion    = 11;

constexpr int kPushDamping     = 12;

constexpr int kPushMaxVelocity = 13;

constexpr int kPushGridResX    = 14;

constexpr int kPushGridResY    = 15;

constexpr int kPushGridResZ    = 16;

constexpr int kPushGridOriginX = 17;

constexpr int kPushGridOriginY = 18;

constexpr int kPushGridOriginZ = 19;

constexpr int kPushGridCell    = 20;

constexpr int kPushSdfResX     = 21;

constexpr int kPushSdfResY     = 22;

constexpr int kPushSdfResZ     = 23;

constexpr int kPushSdfOriginX  = 24;

constexpr int kPushSdfOriginY  = 25;

constexpr int kPushSdfOriginZ  = 26;

constexpr int kPushSdfCell     = 27;

constexpr int kPushIterations  = 28;

constexpr int kPushMode        = 29;

constexpr int kPushTime        = 30;

constexpr int kPushPbf         = 31;


int groupsFor(int count, int localSize = 64) { return (count + localSize - 1) / localSize; }


}  // namespace


FluidSimulator::FluidSimulator(int maxParticles, const FluidParams& params, bool preferGpu)

    : sim_(maxParticles, params), preferGpu_(preferGpu) {}


FluidSimulator::~FluidSimulator() {

    delete seq_;

    delete shAdvance_;

    delete shIntegrate_;

    delete shApply_;

    delete shDelta_;

    delete shDensityLambda_;

    delete shBuild_;

    delete shClear_;

    delete stageDens_;

    delete stageVel_;

    delete stagePos_;

    delete bufSdf_;

    delete bufGrad_;

    delete bufLambda_;

    delete bufDens_;

    delete bufNext_;

    delete bufHead_;

    delete bufVel_;

    delete bufPos_;

}


void FluidSimulator::setSdf(const MeshSdf& sdf) {

    sim_.setSdf(sdf);

    grid_     = SimGrid::make(sdf, sim_.params().supportRadius);

    sdfDirty_ = true;

    if (gpuOk_) {

        // Grid and SDF buffers depend on the field; rebuild them.

        delete seq_;

        delete shAdvance_;

        delete shIntegrate_;

        delete shApply_;

        delete shDelta_;

        delete shDensityLambda_;

        delete shBuild_;

        delete shClear_;

        delete stageDens_;

        delete stageVel_;

        delete stagePos_;

        delete bufSdf_;

        delete bufGrad_;

        delete bufLambda_;

        delete bufDens_;

        delete bufNext_;

        delete bufHead_;

        delete bufVel_;

        delete bufPos_;

        shClear_ = shBuild_ = shDensityLambda_ = shDelta_ = shApply_ = shIntegrate_ = shAdvance_ = nullptr;

        bufPos_ = bufVel_ = bufHead_ = bufNext_ = bufDens_ = bufLambda_ = bufGrad_ = bufSdf_ = nullptr;

        stagePos_ = stageVel_ = stageDens_ = nullptr;

        seq_                               = nullptr;

        gpuOk_                             = false;

        ensureGpu();

    }

}


int FluidSimulator::spawnDrop(const glm::vec3& center, float radius, int count) {

    return sim_.spawnDrop(center, radius, count);

}


void FluidSimulator::step(float dt) { stepSolver(dt, std::max(1, sim_.params().iterations)); }


void FluidSimulator::stepSolver(float dt, int substeps) {

    if (sim_.particleCount() <= 0) return;

    if (preferGpu_ && !gpuOk_) ensureGpu();

    if (!gpuOk_) {

        sim_.step(dt, substeps);

        return;

    }


    const int   iters = std::max(1, substeps);

    const float sub   = dt / float(iters);


    seq_->begin();

    uploadParticles();

    const int pbf = std::max(0, sim_.params().pbfIterations);

    for (int it = 0; it < iters; ++it) {

        setCommonConstants(shClear_, sub);

        seq_->recordDispatch(shClear_, groupsFor(grid_.cellCount()));

        setCommonConstants(shBuild_, sub);

        seq_->recordDispatch(shBuild_, groupsFor(sim_.maxParticles()));

        setCommonConstants(shIntegrate_, sub);

        seq_->recordDispatch(shIntegrate_, groupsFor(sim_.maxParticles()));

        setCommonConstants(shAdvance_, sub);

        seq_->recordDispatch(shAdvance_, groupsFor(sim_.maxParticles()));

        for (int k = 0; k < pbf; ++k) {

            setCommonConstants(shClear_, sub);

            seq_->recordDispatch(shClear_, groupsFor(grid_.cellCount()));

            setCommonConstants(shBuild_, sub);

            seq_->recordDispatch(shBuild_, groupsFor(sim_.maxParticles()));

            setCommonConstants(shDensityLambda_, sub);

            seq_->recordDispatch(shDensityLambda_, groupsFor(sim_.maxParticles()));

            setCommonConstants(shDelta_, sub);

            seq_->recordDispatch(shDelta_, groupsFor(sim_.maxParticles()));

            setCommonConstants(shApply_, sub);

            seq_->recordDispatch(shApply_, groupsFor(sim_.maxParticles()));

        }

    }

    downloadParticles();

    seq_->submit();


    // Update the CPU mirror so reads reflect GPU state.

    std::vector<float> posF(size_t(sim_.maxParticles()) * 4u);

    std::vector<float> velF(size_t(sim_.maxParticles()) * 4u);

    std::vector<float> densF(size_t(sim_.maxParticles()), 0.f);

    stagePos_->downloadBytes(posF.data(), uint64_t(posF.size()) * sizeof(float));

    stageVel_->downloadBytes(velF.data(), uint64_t(velF.size()) * sizeof(float));

    stageDens_->downloadBytes(densF.data(), uint64_t(densF.size()) * sizeof(float));

    std::vector<FluidParticle>& cpu = sim_.particles();

    for (int i = 0; i < sim_.particleCount(); ++i) {

        const size_t b     = size_t(i) * 4u;

        cpu[size_t(i)].pos = glm::vec3(posF[b], posF[b + 1], posF[b + 2]);

        cpu[size_t(i)].vel = glm::vec3(velF[b], velF[b + 1], velF[b + 2]);

    }

    std::vector<float>& dens = sim_.densities();

    for (int i = 0; i < sim_.particleCount(); ++i) dens[size_t(i)] = densF[size_t(i)];

}


eve::Result<void> FluidSimulator::step(const eve::SimulationStep&              stepValue,

                                       const eve::physics::SimulationSettings& settings) {

    auto valid = eve::physics::detail::validateSimulationStep(stepValue, settings, observation_);

    if (!valid) return valid;

    auto next = eve::physics::detail::advanceSimulationObservation(observation_, stepValue);

    if (!next) return eve::Result<void>::failure(next.status());


    try {

        if (preferGpu_ && !gpuOk_) {

            bool available = false;

            try {

                available = ensureGpu();

            } catch (...) {

                available = false;

            }

            if (!available) {

                backendFallback_        = true;

                backendSelectionStatus_ = eve::Status(

                    eve::StatusCode::Applied,

                    {eve::Diagnostic::warning(

                        eve::DiagnosticCode::Unsupported, "Fluid GPGPU accelerator unavailable; CPU reference selected",

                        "fluids.simulationBackend", {{"selected", "cpu"}, {"fallback", "explicit"}})});

            }

        }

        stepSolver(static_cast<float>(stepValue.delta.seconds()), settings.subStepCount);

    } catch (const std::exception& error) {

        return eve::Result<void>::failure(eve::Diagnostic::error(

            eve::DiagnosticCode::Failed, std::string("Fluid simulation step failed: ") + error.what(),

            "fluids.simulationBackend.step"));

    } catch (...) {

        return eve::Result<void>::failure(eve::Diagnostic::error(

            eve::DiagnosticCode::Failed, "Fluid simulation step failed with an unknown exception",

            "fluids.simulationBackend.step"));

    }

    observation_ = std::move(next).takeValue();

    return eve::Result<void>::success(eve::Status::success(eve::StatusCode::Applied));

}


eve::Result<void> FluidSimulator::restoreObservation(const eve::physics::SimulationObservation& observation) {

    auto valid =

        eve::physics::detail::validateSimulationObservation(observation, "fluids.simulationBackend.restoreObservation");

    if (!valid) return valid;

    observation_ = observation;

    return eve::Result<void>::success(eve::Status::success(eve::StatusCode::Applied));

}


void FluidSimulator::readPositions(std::vector<glm::vec3>& out) const {

    out.clear();

    out.reserve(size_t(sim_.particleCount()));

    for (int i = 0; i < sim_.particleCount(); ++i) out.push_back(sim_.particles()[size_t(i)].pos);

}


void FluidSimulator::readDensities(std::vector<float>& out) const {

    out.clear();

    out.reserve(size_t(sim_.particleCount()));

    for (int i = 0; i < sim_.particleCount(); ++i) out.push_back(sim_.densities()[size_t(i)]);

}


void FluidSimulator::setGravity(float x, float y, float z) { sim_.params().gravity = glm::vec3(x, y, z); }


void FluidSimulator::setViscosity(float viscosity) { sim_.params().viscosity = viscosity; }

void FluidSimulator::setCohesion(float cohesion) { sim_.params().cohesion = cohesion; }

void FluidSimulator::setAdhesion(float adhesion) { sim_.params().adhesion = adhesion; }

void FluidSimulator::setPbfIterations(int passes) { sim_.params().pbfIterations = std::max(0, passes); }

void FluidSimulator::setDamping(float damping) { sim_.params().damping = damping; }

void FluidSimulator::setParticleRadius(float radius) { sim_.params().particleRadius = std::max(1e-4f, radius); }


void FluidSimulator::setSupportRadius(float h) {

    sim_.params().supportRadius = std::max(1e-4f, h);

    grid_                       = SimGrid::make(sim_.sdf(), sim_.params().supportRadius);

}


void FluidSimulator::setSdfSphere(float cx, float cy, float cz, float radius, int res) {

    setSdf(MeshSdf::makeSphere(glm::vec3(cx, cy, cz), radius, glm::ivec3(res, res, res)));

}


bool FluidSimulator::ensureGpu() {

    if (gpuOk_) return true;

    gpgpu_ = eve::gpgpu::Gpgpu::create();

    if (!gpgpu_ || !gpgpu_->isAvailable()) return false;

    if (sim_.sdf().voxelCount() <= 0) return false;


    const int max = sim_.maxParticles();

    try {

        shClear_         = gpgpu_->newShader(kFluidClearGrid);

        shBuild_         = gpgpu_->newShader(kFluidBuildGrid);

        shDensityLambda_ = gpgpu_->newShader(kFluidDensityLambda);

        shDelta_         = gpgpu_->newShader(kFluidComputeDelta);

        shApply_         = gpgpu_->newShader(kFluidApplyDelta);

        shIntegrate_     = gpgpu_->newShader(kFluidIntegrate);

        shAdvance_       = gpgpu_->newShader(kFluidApplyDelta);

        bufPos_          = gpgpu_->newBuffer(max * 4 * int(sizeof(float)), "storage");

        bufVel_          = gpgpu_->newBuffer(max * 4 * int(sizeof(float)), "storage");

        bufHead_         = gpgpu_->newBuffer(grid_.cellCount() * int(sizeof(int)), "storage");

        bufNext_         = gpgpu_->newBuffer(max * int(sizeof(int)), "storage");

        bufDens_         = gpgpu_->newBuffer(max * int(sizeof(float)), "storage");

        bufLambda_       = gpgpu_->newBuffer(max * int(sizeof(float)), "storage");

        bufGrad_         = gpgpu_->newBuffer(max * 4 * int(sizeof(float)), "storage");

        bufSdf_          = gpgpu_->newBuffer(sim_.sdf().voxelCount() * int(sizeof(float)), "storage");

        stagePos_        = gpgpu_->newBuffer(max * 4 * int(sizeof(float)), "staging");

        stageVel_        = gpgpu_->newBuffer(max * 4 * int(sizeof(float)), "staging");

        stageDens_       = gpgpu_->newBuffer(max * int(sizeof(float)), "staging");

        seq_             = gpgpu_->newSequence();

    } catch (...) {

        return false;

    }

    if (!seq_ || !seq_->isAvailable()) return false;


    gpuOk_ = true;  // uploadSdf() guards on gpuOk_; set it before uploading.

    uploadSdf();

    shClear_->bindBuffer(2, bufHead_);

    shBuild_->bindBuffer(0, bufPos_);

    shBuild_->bindBuffer(2, bufHead_);

    shBuild_->bindBuffer(3, bufNext_);

    shDensityLambda_->bindBuffer(0, bufPos_);

    shDensityLambda_->bindBuffer(2, bufHead_);

    shDensityLambda_->bindBuffer(3, bufNext_);

    shDensityLambda_->bindBuffer(4, bufDens_);

    shDensityLambda_->bindBuffer(6, bufLambda_);

    shDensityLambda_->bindBuffer(7, bufGrad_);

    shDelta_->bindBuffer(0, bufPos_);

    shDelta_->bindBuffer(2, bufHead_);

    shDelta_->bindBuffer(3, bufNext_);

    shDelta_->bindBuffer(6, bufLambda_);

    shDelta_->bindBuffer(7, bufGrad_);

    shApply_->bindBuffer(0, bufPos_);

    shApply_->bindBuffer(1, bufVel_);

    shApply_->bindBuffer(2, bufHead_);

    shApply_->bindBuffer(3, bufNext_);

    shApply_->bindBuffer(7, bufGrad_);

    shApply_->bindBuffer(5, bufSdf_);

    shIntegrate_->bindBuffer(0, bufPos_);

    shIntegrate_->bindBuffer(1, bufVel_);

    shIntegrate_->bindBuffer(2, bufHead_);

    shIntegrate_->bindBuffer(3, bufNext_);

    shIntegrate_->bindBuffer(5, bufSdf_);

    shIntegrate_->bindBuffer(7, bufGrad_);

    shAdvance_->bindBuffer(0, bufPos_);

    shAdvance_->bindBuffer(1, bufVel_);

    shAdvance_->bindBuffer(5, bufSdf_);

    shAdvance_->bindBuffer(7, bufGrad_);

    return true;

}


void FluidSimulator::uploadSdf() {

    if (!gpuOk_ || !bufSdf_ || !sdfDirty_) return;

    const std::vector<float>& dist = sim_.sdf().distances;

    bufSdf_->writeFloat32s(dist.data(), int(dist.size()));

    sdfDirty_ = false;

}


void FluidSimulator::uploadParticles() {

    if (!gpuOk_) return;

    const int          max = sim_.maxParticles();

    std::vector<float> posF(size_t(max) * 4u, 0.f);

    std::vector<float> velF(size_t(max) * 4u, 0.f);

    const auto&        particles = sim_.particles();

    for (int i = 0; i < sim_.particleCount(); ++i) {

        const size_t b = size_t(i) * 4u;

        posF[b]        = particles[size_t(i)].pos.x;

        posF[b + 1]    = particles[size_t(i)].pos.y;

        posF[b + 2]    = particles[size_t(i)].pos.z;

        velF[b]        = particles[size_t(i)].vel.x;

        velF[b + 1]    = particles[size_t(i)].vel.y;

        velF[b + 2]    = particles[size_t(i)].vel.z;

    }

    seq_->recordUpload(bufPos_, posF.data(), uint64_t(posF.size()) * sizeof(float));

    seq_->recordUpload(bufVel_, velF.data(), uint64_t(velF.size()) * sizeof(float));

}


void FluidSimulator::downloadParticles() {

    if (!gpuOk_) return;

    const int max = sim_.maxParticles();

    seq_->recordDownload(bufPos_, stagePos_, uint64_t(size_t(max) * 4u) * sizeof(float));

    seq_->recordDownload(bufVel_, stageVel_, uint64_t(size_t(max) * 4u) * sizeof(float));

    seq_->recordDownload(bufDens_, stageDens_, uint64_t(size_t(max)) * sizeof(float));

}


void FluidSimulator::setCommonConstants(gpgpu::ComputeShader* shader, float dt) {

    if (!shader) return;

    const FluidParams& p = sim_.params();

    shader->setFloat(kPushCount, float(sim_.particleCount()));

    shader->setFloat(kPushDt, dt);

    shader->setFloat(kPushRadius, p.particleRadius);

    shader->setFloat(kPushH, p.supportRadius);

    shader->setFloat(kPushRestDensity, p.restDensity);

    shader->setFloat(kPushGravityX, p.gravity.x);

    shader->setFloat(kPushGravityY, p.gravity.y);

    shader->setFloat(kPushGravityZ, p.gravity.z);

    shader->setFloat(kPushViscosity, p.viscosity);

    shader->setFloat(kPushYield, p.yieldStress);

    shader->setFloat(kPushCohesion, p.cohesion);

    shader->setFloat(kPushAdhesion, p.adhesion);

    shader->setFloat(kPushDamping, p.damping);

    shader->setFloat(kPushMaxVelocity, p.maxVelocity);

    shader->setFloat(kPushGridResX, float(grid_.dims.x));

    shader->setFloat(kPushGridResY, float(grid_.dims.y));

    shader->setFloat(kPushGridResZ, float(grid_.dims.z));

    shader->setFloat(kPushGridOriginX, grid_.origin.x);

    shader->setFloat(kPushGridOriginY, grid_.origin.y);

    shader->setFloat(kPushGridOriginZ, grid_.origin.z);

    shader->setFloat(kPushGridCell, grid_.cellSize);

    shader->setFloat(kPushSdfResX, float(sim_.sdf().dims.x));

    shader->setFloat(kPushSdfResY, float(sim_.sdf().dims.y));

    shader->setFloat(kPushSdfResZ, float(sim_.sdf().dims.z));

    shader->setFloat(kPushSdfOriginX, sim_.sdf().origin.x);

    shader->setFloat(kPushSdfOriginY, sim_.sdf().origin.y);

    shader->setFloat(kPushSdfOriginZ, sim_.sdf().origin.z);

    shader->setFloat(kPushSdfCell, sim_.sdf().cellSize);

    shader->setFloat(kPushIterations, float(p.iterations));

    shader->setFloat(kPushMode, 0.f);

    if (shader == shAdvance_) shader->setFloat(kPushMode, 1.f);

    shader->setFloat(kPushTime, 0.f);

    shader->setFloat(kPushPbf, float(p.pbfIterations));

}


Fluids::Fluids()  = default;

Fluids::~Fluids() = default;


Module_IMPL(Fluids, new Fluids());


FluidSimulator* Fluids::newSimulator(int maxParticles) {

    auto            sim = std::make_unique<FluidSimulator>(maxParticles, FluidParams{}, true);

    FluidSimulator* raw = sim.get();

    simulators_.push_back(std::move(sim));

    return raw;

}


int Fluids::getSimulatorCount() const { return int(simulators_.size()); }


FluidSurfaceRenderer* Fluids::newSurfaceRenderer(int width, int height) {

    FluidSurfaceParams params;

    params.width              = std::clamp(width, 8, 1024);

    params.height             = std::clamp(height, 8, 1024);

    auto                  r   = std::make_unique<FluidSurfaceRenderer>(params, true);

    FluidSurfaceRenderer* raw = r.get();

    renderers_.push_back(std::move(r));

    return raw;

}


int Fluids::getRendererCount() const { return int(renderers_.size()); }


void Fluids::expose(ssq::Table& table) {

    auto cls = table.addClass(name, Fluids::create, false);

    expose(cls);

    cls.addFunc("fluidRendererSettingsDefaults", [vm = table.getHandle()](Fluids*) {

        return eve::script::projectStatusResult(vm, eve::Status::success(),

                                                encodeFluidRendererSettings(FluidRendererSettings{}));

    });

    exposeVolumeFluidType(table);


    auto sim = table.addClass<FluidSimulator>(

        "FluidSim", std::function<FluidSimulator*()>([]() -> FluidSimulator* { return nullptr; }), true);

    sim.addFunc("setSdfSphere", &FluidSimulator::setSdfSphere);

    sim.addFunc("setGravity", &FluidSimulator::setGravity);

    sim.addFunc("setViscosity", &FluidSimulator::setViscosity);

    sim.addFunc("setCohesion", &FluidSimulator::setCohesion);

    sim.addFunc("setAdhesion", &FluidSimulator::setAdhesion);

    sim.addFunc("setPbfIterations", &FluidSimulator::setPbfIterations);

    sim.addFunc("setDamping", &FluidSimulator::setDamping);

    sim.addFunc("setParticleRadius", &FluidSimulator::setParticleRadius);

    sim.addFunc("setSupportRadius", &FluidSimulator::setSupportRadius);

    sim.addFunc("spawnDrop", &FluidSimulator::spawnDrop);

    sim.addFunc("step", static_cast<void (FluidSimulator::*)(float)>(&FluidSimulator::step));

    sim.addFunc("getParticleCount", &FluidSimulator::getParticleCount);

    sim.addFunc("getMaxParticles", &FluidSimulator::getMaxParticles);

    sim.addFunc("usingGpu", &FluidSimulator::usingGpu);


    auto surf = table.addClass<FluidSurfaceRenderer>(

        "FluidSurface", std::function<FluidSurfaceRenderer*()>([]() -> FluidSurfaceRenderer* { return nullptr; }),

        true);

    surf.addFunc("render", &FluidSurfaceRenderer::renderFrom);

    surf.addFunc("renderVolume",

                 [](FluidSurfaceRenderer* renderer, VolumeFluid* solver) { renderer->renderVolume(*solver); });

    surf.addFunc("renderVolumeInterpolated", [vm = table.getHandle()](FluidSurfaceRenderer* renderer,

                                                                      VolumeFluid* solver, float alpha) {

        if (!solver)

            return eve::script::projectResult(

                vm, eve::Result<void>::failure(eve::Diagnostic::error(

                        eve::DiagnosticCode::InvalidArgument, "Missing volume fluid", "fluids.surface.interpolation")));

        return eve::script::projectResult(vm, renderer->renderVolumeInterpolated(*solver, alpha));

    });

    surf.addFunc("renderVolumeColorOnly",

                 [](FluidSurfaceRenderer* renderer, VolumeFluid* solver) { renderer->renderVolumeColorOnly(*solver); });

    surf.addFunc("renderGasVolume", [vm = table.getHandle()](FluidSurfaceRenderer* renderer, VolumeFluid* solver,

                                                             float absorption) {

        if (!solver)

            return eve::script::projectResult(

                vm, eve::Result<void>::failure(eve::Diagnostic::error(eve::DiagnosticCode::InvalidArgument,

                                                                      "Missing volume fluid", "fluids.surface.gas")));

        return eve::script::projectResult(vm, renderer->renderGasVolume(*solver, absorption));

    });

    surf.addFunc("renderVolumeWithoutSurface", [vm = table.getHandle()](FluidSurfaceRenderer* renderer,

                                                                        VolumeFluid* solver, float absorption) {

        if (!solver)

            return eve::script::projectResult(

                vm, eve::Result<void>::failure(eve::Diagnostic::error(

                        eve::DiagnosticCode::InvalidArgument, "Missing volume fluid", "fluids.surface.volume-cloud")));

        return eve::script::projectResult(vm, renderer->renderVolumeWithoutSurface(*solver, absorption));

    });

    surf.addFunc(

        "renderConfiguredVolume", [vm = table.getHandle()](FluidSurfaceRenderer* renderer, VolumeFluid* solver) {

            if (!solver)

                return eve::script::projectResult(vm, eve::Result<void>::failure(eve::Diagnostic::error(

                                                          eve::DiagnosticCode::InvalidArgument, "Missing volume fluid",

                                                          "fluids.surface.configured-volume")));

            return eve::script::projectResult(vm, renderer->renderConfiguredVolume(*solver));

        });

    surf.addFunc("prepare", [vm = table.getHandle()](FluidSurfaceRenderer* renderer) {

        return eve::script::projectResult(vm, renderer->prepare());

    });

    surf.addFunc("copyToTexture", [vm = table.getHandle()](FluidSurfaceRenderer* renderer, graphics::Graphics* graphics,

                                                           graphics::Texture* texture) {

        return eve::script::projectResult(vm, renderer->copyToTexture(graphics, texture));

    });

    surf.addFunc("renderVolumeColorToTexture", [vm = table.getHandle()](

                                                   FluidSurfaceRenderer* renderer, VolumeFluid* solver,

                                                   graphics::Graphics* graphics, graphics::Texture* texture) {

        if (!solver)

            return eve::script::projectResult(vm, eve::Result<void>::failure(eve::Diagnostic::error(

                                                      eve::DiagnosticCode::InvalidArgument, "Missing volume fluid",

                                                      "fluids.surface.renderVolumeColorToTexture")));

        return eve::script::projectResult(vm, renderer->renderVolumeColorToTexture(*solver, graphics, texture));

    });

    surf.addFunc("compositeDiffuse", [vm = table.getHandle()](FluidSurfaceRenderer* renderer, VolumeFluidDiffuse* pool,

                                                              float radius, float opacity, float fadeSeconds) {

        if (!pool)

            return eve::script::projectResult(

                vm, eve::Result<void>::failure(eve::Diagnostic::error(

                        eve::DiagnosticCode::InvalidArgument, "Missing diffuse pool", "fluids.surface.diffuse")));

        return eve::script::projectResult(vm, renderer->compositeDiffuse(*pool, radius, opacity, fadeSeconds));

    });

    surf.addFunc("configureFoam",

                 [vm = table.getHandle()](FluidSurfaceRenderer* renderer, bool enabled, int downsample) {

                     return eve::script::projectResult(vm, renderer->configureFoam(enabled, downsample));

                 });

    surf.addFunc("compositeSceneRefraction", [vm = table.getHandle()](FluidSurfaceRenderer* renderer,

                                                                      image::ImageData* scene, float distortion,

                                                                      float absorption) {

        if (!scene || scene->getFormat() != "RGBA8" || scene->getWidth() != renderer->getWidth() ||

            scene->getHeight() != renderer->getHeight())

            return eve::script::projectResult(

                vm, eve::Result<void>::failure(eve::Diagnostic::error(eve::DiagnosticCode::InvalidArgument,

                                                                      "Refraction requires matching RGBA8 scene image",

                                                                      "fluids.surface.refraction")));

        return eve::script::projectResult(

            vm, renderer->compositeSceneRefraction(

                    std::span<const uint8_t>(static_cast<const uint8_t*>(scene->getData()), scene->getSize()),

                    distortion, absorption));

    });

    surf.addFunc("configureRefraction", [vm = table.getHandle()](FluidSurfaceRenderer* renderer, float transparency,

                                                                 float absorption, float coefficient, int downsample) {

        return eve::script::projectResult(

            vm, renderer->configureRefraction(transparency, absorption, coefficient, downsample));

    });

    surf.addFunc("configureRefractionEnabled", [vm = table.getHandle()](FluidSurfaceRenderer* renderer, bool enabled) {

        return eve::script::projectResult(vm, renderer->configureRefractionEnabled(enabled));

    });

    surf.addFunc("compositeConfiguredSceneRefraction", [vm = table.getHandle()](FluidSurfaceRenderer* renderer,

                                                                                image::ImageData*     scene) {

        if (!scene || scene->getFormat() != "RGBA8" || scene->getWidth() != renderer->getWidth() ||

            scene->getHeight() != renderer->getHeight())

            return eve::script::projectResult(vm, eve::Result<void>::failure(eve::Diagnostic::error(

                                                      eve::DiagnosticCode::InvalidArgument,

                                                      "Configured refraction requires matching RGBA8 scene image",

                                                      "fluids.surface.configuredRefraction")));

        return eve::script::projectResult(vm, renderer->compositeConfiguredSceneRefraction(std::span<const uint8_t>(

                                                  static_cast<const uint8_t*>(scene->getData()), scene->getSize())));

    });

    surf.addFunc("configureSurfaceBlend",

                 [vm = table.getHandle()](FluidSurfaceRenderer* renderer, int source, int destination) {

                     return eve::script::projectResult(vm, renderer->configureSurfaceBlend(source, destination));

                 });

    surf.addFunc("configureParticleBlend", [vm = table.getHandle()](FluidSurfaceRenderer* renderer, int source,

                                                                    int destination, bool depthWrite) {

        return eve::script::projectResult(vm, renderer->configureParticleBlend(source, destination, depthWrite));

    });

    surf.addFunc("compositeConfiguredSurfaceBlend", [vm = table.getHandle()](FluidSurfaceRenderer* renderer,

                                                                             image::ImageData*     scene) {

        if (!scene || scene->getFormat() != "RGBA8" || scene->getWidth() != renderer->getWidth() ||

            scene->getHeight() != renderer->getHeight())

            return eve::script::projectResult(

                vm, eve::Result<void>::failure(eve::Diagnostic::error(

                        eve::DiagnosticCode::InvalidArgument,

                        "Configured surface blend requires matching RGBA8 scene image", "fluids.surface.blend")));

        return eve::script::projectResult(vm, renderer->compositeConfiguredSurfaceBlend(std::span<const uint8_t>(

                                                  static_cast<const uint8_t*>(scene->getData()), scene->getSize())));

    });

    surf.addFunc("setMode", &FluidSurfaceRenderer::setMode);

    surf.addFunc(

        "configureSurface", [vm = table.getHandle()](FluidSurfaceRenderer* renderer, float thicknessScale,

                                                     float thicknessCutoff, float depthFalloff, int smoothIterations) {

            return eve::script::projectResult(

                vm, renderer->configureSurface(thicknessScale, thicknessCutoff, depthFalloff, smoothIterations));

        });

    surf.addFunc("configureSurfaceEnabled", [vm = table.getHandle()](FluidSurfaceRenderer* renderer, bool enabled) {

        return eve::script::projectResult(vm, renderer->configureSurfaceEnabled(enabled));

    });

    surf.addFunc("configureRendererSettings",

                 [vm = table.getHandle()](FluidSurfaceRenderer* renderer, ssq::Object object) {

                     auto value = eve::script::valueFromSquirrel(object);

                     if (!value) return eve::script::projectResult(vm, eve::Result<void>::failure(value.status()));

                     auto settings = decodeFluidRendererSettings(value.value());

                     if (!settings)

                         return eve::script::projectResult(vm, eve::Result<void>::failure(settings.status()));

                     return eve::script::projectResult(vm, renderer->configureRendererSettings(settings.value()));

                 });

    surf.addFunc("rendererSettings", [vm = table.getHandle()](FluidSurfaceRenderer* renderer) {

        return eve::script::projectStatusResult(vm, eve::Status::success(),

                                                encodeFluidRendererSettings(renderer->rendererSettings()));

    });

    surf.addFunc("configureSurfaceBlurRadius", [vm = table.getHandle()](FluidSurfaceRenderer* renderer, float radius) {

        return eve::script::projectResult(vm, renderer->configureSurfaceBlurRadius(radius));

    });

    surf.addFunc("configureMaterial", [vm = table.getHandle()](

                                          FluidSurfaceRenderer* renderer, bool lighting, float smoothness,

                                          float metalness, float ambientMultiplier, float reflection, float opacity) {

        return eve::script::projectResult(

            vm, renderer->configureMaterial(lighting, smoothness, metalness, ambientMultiplier, reflection, opacity));

    });

    surf.addFunc("configureReflection", [vm = table.getHandle()](FluidSurfaceRenderer* renderer, bool enabled) {

        return eve::script::projectResult(vm, renderer->configureReflection(enabled));

    });

    surf.addFunc("configureColors", [vm = table.getHandle()](FluidSurfaceRenderer* renderer, float br, float bg,

                                                             float bb, float rr, float rg, float rb) {

        return eve::script::projectResult(vm, renderer->configureColors({br, bg, bb}, {rr, rg, rb}));

    });

    surf.addFunc("configureAnisotropy", [vm = table.getHandle()](FluidSurfaceRenderer* renderer, bool enabled) {

        return eve::script::projectResult(vm, renderer->configureAnisotropy(enabled));

    });

    surf.addFunc("configureSurfaceDownsample", [vm = table.getHandle()](FluidSurfaceRenderer* renderer, int factor) {

        return eve::script::projectResult(vm, renderer->configureSurfaceDownsample(factor));

    });

    surf.addFunc("configureThicknessDownsample", [vm = table.getHandle()](FluidSurfaceRenderer* renderer, int factor) {

        return eve::script::projectResult(vm, renderer->configureThicknessDownsample(factor));

    });

    surf.addFunc("configureProjection", [vm = table.getHandle()](FluidSurfaceRenderer* renderer, bool orthographic,

                                                                 float verticalHalfSize) {

        return eve::script::projectResult(vm, renderer->configureProjection(orthographic, verticalHalfSize));

    });

    surf.addFunc("setCamera", &FluidSurfaceRenderer::setCamera);

    surf.addFunc("setCameraXYZ",

                 [](FluidSurfaceRenderer* renderer, float ex, float ey, float ez, float tx, float ty, float tz,

                    float fov) { renderer->setCamera({ex, ey, ez}, {tx, ty, tz}, {0.f, 1.f, 0.f}, fov); });

    surf.addFunc("getWidth", &FluidSurfaceRenderer::getWidth);

    surf.addFunc("getHeight", &FluidSurfaceRenderer::getHeight);

    surf.addFunc("usingGpu", &FluidSurfaceRenderer::usingGpu);

    surf.addFunc("writePpm", &FluidSurfaceRenderer::writePpm);

    surf.addFunc("copyToImage", [vm = table.getHandle()](FluidSurfaceRenderer* renderer, image::ImageData* image) {

        if (!image || image->getFormat() != "RGBA8" || image->getWidth() != renderer->getWidth() ||

            image->getHeight() != renderer->getHeight() || image->getSize() != renderer->color().size())

            return eve::script::projectResult(

                vm, eve::Result<void>::failure(eve::Diagnostic::error(eve::DiagnosticCode::InvalidArgument,

                                                                      "Fluid output requires matching RGBA8 image",

                                                                      "fluids.copyToImage")));

        std::memcpy(image->getData(), renderer->color().data(), renderer->color().size());

        return eve::script::projectResult(vm, eve::Result<void>::success());

    });

}


void Fluids::expose(ssq::Class& cls) {

    exposeVolumeFluidFactory(cls);

    cls.addFunc("getName", &Fluids::getName);

    cls.addFunc("newSimulator", &Fluids::newSimulator);

    cls.addFunc("getSimulatorCount", &Fluids::getSimulatorCount);

    cls.addFunc("newSurfaceRenderer", &Fluids::newSurfaceRenderer);

    cls.addFunc("getRendererCount", &Fluids::getRendererCount);

}


}  // namespace eve::fluids

y
float y
Definition AnimClip.cpp:738

x
float x
Definition AnimClip.cpp:738

z
float z
Definition AnimClip.cpp:738

cx
float cx
Definition CardTypes.cpp:33

cy
float cy
Definition CardTypes.cpp:34

ComputeShader.h

p
glm::vec4 p[6]
Definition DecalManager.cpp:20

vm
HSQUIRRELVM vm
Definition ECS.cpp:20

cls
HSQOBJECT cls
Definition ECS.cpp:21

FluidGpuKernels.h

Fluids.h

max
Vec3 max
Definition GeometryCollectionCooker.cpp:23

center
Vec3 center
Definition GeometryCollectionCooker.cpp:48

Gpgpu.h

GpuBuffer.h

image
vk::UniqueImage image
Definition GraphicsShaderResources.cpp:14

r
double r
Definition GtsMeshSimplifier.cpp:12

h
int h
Definition ImageData.cpp:690

ImageData.h

height
std::uint32_t height
Definition ImageImporter.cpp:14

width
std::uint32_t width
Definition ImageImporter.cpp:13

name
std::string name
Definition McpScriptTools.cpp:40

valid
bool valid
Definition McpServer.cpp:430

b
MeleePoint3 b
Definition MeleeHit.cpp:41

Module_IMPL
#define Module_IMPL(ModuleName, newExpr)
Definition Module.h:26

error
std::string error
Definition Package.cpp:60

radius
float radius
Definition PlacementSystem.cpp:42

shader
Shader * shader
Definition RenderSystem3D.cpp:679

lighting
Lighting3DPack lighting
Definition RenderSystem3D.cpp:636

Sequence.h

count
std::uint32_t count
Definition SourceTiff.cpp:24

SquirrelBinding.h
The single Squirrel projection for common Result, Status and Value.

settings
TerrainThermalSettings settings
Definition TerrainGenerationSession.cpp:95

opacity
float opacity
Definition TileConfig.cpp:785

source
const UnitySourceAsset & source
Definition UnityVegetationPreset.cpp:29

VolumeFluidBindings.h

VolumeFluidCodec.h

VolumeFluidDiffuse.h

VolumeFluid.h

eve::Diagnostic::warning
static Diagnostic warning(DiagnosticCode code, std::string message, std::string path={}, DiagnosticDetails details={}, std::string source={})
Construct a warning diagnostic.
Definition Diagnostic.h:134

eve::Diagnostic::error
static Diagnostic error(DiagnosticCode code, std::string message, std::string path={}, DiagnosticDetails details={}, std::string source={})
Construct an error diagnostic with the standard error severity.
Definition Diagnostic.h:125

eve::Duration::seconds
double seconds() const noexcept
Return this duration as seconds for legacy/presentation APIs.
Definition Time.cpp:28

eve::Result
Move-only operation result carrying either a value or Status.
Definition Result.h:155

eve::Result::success
static Result success(T value)
Construct a successful result owning value.
Definition Result.h:164

eve::Result::failure
static Result failure(Status status)
Construct a failed result from a structured status.
Definition Result.h:175

eve::Status
Structured status and zero or more diagnostics for an operation.
Definition Status.h:68

eve::Status::success
static Status success(StatusCode code=StatusCode::Ok)
Construct a successful status with an explicit non-error outcome.
Definition Status.h:81

eve::fluids::FluidSimulation::maxParticles
int maxParticles() const
Max particles.
Definition FluidSimulation.h:97

eve::fluids::FluidSimulation::setSdf
void setSdf(const MeshSdf &sdf)
Replace the collision surface. Particles keep their state.
Definition FluidSimulation.cpp:41

eve::fluids::FluidSimulation::spawnDrop
int spawnDrop(const glm::vec3 &center, float radius, int count)
Spawn a roughly spherical drop of particles near the surface.
Definition FluidSimulation.cpp:52

eve::fluids::FluidSimulation::params
FluidParams & params()
Params.
Definition FluidSimulation.h:117

eve::fluids::FluidSimulation::particleCount
int particleCount() const
Particle count.
Definition FluidSimulation.h:93

eve::fluids::FluidSimulation::particles
const std::vector< FluidParticle > & particles() const
Particles.
Definition FluidSimulation.h:101

eve::fluids::FluidSimulation::sdf
const MeshSdf & sdf() const
Sdf.
Definition FluidSimulation.h:68

eve::fluids::FluidSimulation::densities
const std::vector< float > & densities() const
Densities.
Definition FluidSimulation.h:109

eve::fluids::FluidSimulation::step
void step(float dt)
Advance the simulation by dt seconds (params.iterations substeps).
Definition FluidSimulation.cpp:80

eve::fluids::FluidSimulator
GPU-backed surface fluid simulator (falls back to the CPU solver).
Definition Fluids.h:44

eve::fluids::FluidSimulator::restoreObservation
eve::Result< void > restoreObservation(const eve::physics::SimulationObservation &observation) override
Restores tick/progress metadata after an owner-level restore.
Definition Fluids.cpp:222

eve::fluids::FluidSimulator::setParticleRadius
void setParticleRadius(float radius)
Set particle radius (support radius is unchanged).
Definition Fluids.cpp:249

eve::fluids::FluidSimulator::setViscosity
void setViscosity(float viscosity)
Set XSPH viscosity strength.
Definition Fluids.cpp:244

eve::fluids::FluidSimulator::setSdf
void setSdf(const MeshSdf &sdf)
Replace the collision surface (re-uploads the SDF on the GPU path).
Definition Fluids.cpp:88

eve::fluids::FluidSimulator::readPositions
void readPositions(std::vector< glm::vec3 > &out) const
Copy live particle positions out (CPU mirror; GPU path downloads).
Definition Fluids.cpp:230

eve::fluids::FluidSimulator::observation
eve::physics::SimulationObservation observation() const noexcept override
Returns completed tick/time observables.
Definition Fluids.h:82

eve::fluids::FluidSimulator::FluidSimulator
FluidSimulator(int maxParticles, const FluidParams &params, bool preferGpu)
Fluid simulator.
Definition Fluids.cpp:63

eve::fluids::FluidSimulator::setPbfIterations
void setPbfIterations(int passes)
Set PBF density-constraint passes per substep.
Definition Fluids.cpp:247

eve::fluids::FluidSimulator::usingGpu
bool usingGpu() const
Using gpu.
Definition Fluids.h:113

eve::fluids::FluidSimulator::step
void step(float dt)
Advance the simulation by dt seconds.
Definition Fluids.cpp:126

eve::fluids::FluidSimulator::sdf
const MeshSdf & sdf() const
Sdf.
Definition Fluids.h:64

eve::fluids::FluidSimulator::setSdfSphere
void setSdfSphere(float cx, float cy, float cz, float radius, int res)
Convenience: bake a sphere SDF around the origin.
Definition Fluids.cpp:255

eve::fluids::FluidSimulator::spawnDrop
int spawnDrop(const glm::vec3 &center, float radius, int count)
Spawn a drop of particles near the surface.
Definition Fluids.cpp:122

eve::fluids::FluidSimulator::setDamping
void setDamping(float damping)
Set linear air damping.
Definition Fluids.cpp:248

eve::fluids::FluidSimulator::setAdhesion
void setAdhesion(float adhesion)
Set fluid-surface adhesion strength.
Definition Fluids.cpp:246

eve::fluids::FluidSimulator::setSupportRadius
void setSupportRadius(float h)
Set SPH support radius.
Definition Fluids.cpp:250

eve::fluids::FluidSimulator::getParticleCount
int getParticleCount() const
Returns the particle count.
Definition Fluids.h:105

eve::fluids::FluidSimulator::~FluidSimulator
~FluidSimulator()
Fluid simulator.
Definition Fluids.cpp:66

eve::fluids::FluidSimulator::readDensities
void readDensities(std::vector< float > &out) const
Copy per-particle densities out (CPU mirror).
Definition Fluids.cpp:236

eve::fluids::FluidSimulator::setGravity
void setGravity(float x, float y, float z)
Set the gravity vector.
Definition Fluids.cpp:242

eve::fluids::FluidSimulator::getMaxParticles
int getMaxParticles() const
Returns the max particles.
Definition Fluids.h:109

eve::fluids::FluidSimulator::setCohesion
void setCohesion(float cohesion)
Set Akinci-style fluid-fluid cohesion strength.
Definition Fluids.cpp:245

eve::fluids::FluidSurfaceRenderer
Buffer-level screen-space fluid renderer.
Definition FluidSurfaceRenderer.h:103

eve::fluids::FluidSurfaceRenderer::setMode
void setMode(int mode)
Switch shading: 0 water, 1 mud.
Definition FluidSurfaceRenderer.h:419

eve::fluids::FluidSurfaceRenderer::renderFrom
void renderFrom(FluidSimulator *sim)
Script-friendly wrapper: render(*sim) with a null check.
Definition FluidSurfaceRenderer.cpp:129

eve::fluids::Fluids
Fluids module — factory + script binding.
Definition Fluids.h:203

eve::fluids::Fluids::Fluids
Fluids()
Fluids.

eve::fluids::Fluids::~Fluids
~Fluids() override
Fluids.

eve::fluids::Fluids::getSimulatorCount
int getSimulatorCount() const
Returns the simulator count.
Definition Fluids.cpp:411

eve::fluids::Fluids::getRendererCount
int getRendererCount() const
Returns the renderer count.
Definition Fluids.cpp:423

eve::fluids::Fluids::newSurfaceRenderer
FluidSurfaceRenderer * newSurfaceRenderer(int width=160, int height=160)
Create a screen-space fluid renderer.
Definition Fluids.cpp:413

eve::fluids::Fluids::newSimulator
FluidSimulator * newSimulator(int maxParticles=8192)
Create a surface fluid simulator.
Definition Fluids.cpp:404

eve::fluids::MeshSdf
Uniform signed-distance voxel field over a box.
Definition FluidSdf.h:28

eve::fluids::MeshSdf::dims
glm::ivec3 dims
Voxel resolution along each axis.
Definition FluidSdf.h:35

eve::fluids::MeshSdf::cellSize
float cellSize
World-space size of one voxel.
Definition FluidSdf.h:33

eve::fluids::MeshSdf::origin
glm::vec3 origin
World-space position of voxel (0,0,0).
Definition FluidSdf.h:31

eve::fluids::MeshSdf::distances
std::vector< float > distances
Signed distances, dims.x * dims.y * dims.z floats.
Definition FluidSdf.h:37

eve::fluids::MeshSdf::makeSphere
static MeshSdf makeSphere(const glm::vec3 &center, float radius, const glm::ivec3 &dims)
Bake an analytic sphere into the field.
Definition FluidSdf.cpp:130

eve::fluids::MeshSdf::voxelCount
int voxelCount() const
Voxel count.
Definition FluidSdf.cpp:87

eve::gpgpu::ComputeShader::bindBuffer
virtual void bindBuffer(int binding, GpuBuffer *buffer)=0
Bind a storage buffer to set=0 binding. binding in [0, kMaxBindings).

eve::gpgpu::Gpgpu::newShader
ComputeShader * newShader(const std::string &source)
Compatibility-only raw-owning shader factory (Vulkan: GLSL; WebGPU: WGSL). Vulkan delegates to the ch...
Definition Gpgpu.cpp:324

eve::gpgpu::Gpgpu::isAvailable
bool isAvailable() const
True when the active Graphics backend can run compute (device initialized).
Definition Gpgpu.cpp:284

eve::gpgpu::Gpgpu::newBuffer
GpuBuffer * newBuffer(int byteSize, const std::string &usage="storage")
Allocate a GPU buffer. usage: "storage" (SSBO, device-local) | "staging" (host-visible transfer).
Definition Gpgpu.cpp:372

eve::gpgpu::Gpgpu::newSequence
Sequence * newSequence()
Create a Kompute-style command Sequence: record buffer transfers and compute dispatches into one comm...
Definition Gpgpu.cpp:384

eve::gpgpu::GpuBuffer::writeFloat32s
virtual void writeFloat32s(const float *data, int count, int startIndex=0)=0
Bulk float upload/download (one transfer). startIndex is in floats.

eve::gpgpu::GpuBuffer::downloadBytes
virtual void downloadBytes(void *dst, uint64_t nbytes, uint64_t srcOffset=0) const =0
Downloads bytes.

eve::gpgpu::Sequence::recordUpload
void recordUpload(GpuBuffer *dst, const void *src, uint64_t nbytes, uint64_t dstOffset=0)
Record upload.
Definition Sequence.cpp:77

eve::gpgpu::Sequence::recordDownload
void recordDownload(GpuBuffer *src, GpuBuffer *staging, uint64_t nbytes, uint64_t srcOffset=0)
Record download.
Definition Sequence.cpp:82

eve::gpgpu::Sequence::submit
void submit()
Submit.
Definition Sequence.cpp:92

eve::gpgpu::Sequence::recordDispatch
void recordDispatch(ComputeShader *shader, int groupsX, int groupsY=1, int groupsZ=1)
Record dispatch.
Definition Sequence.cpp:87

eve::gpgpu::Sequence::begin
void begin()
Begins begin.
Definition Sequence.cpp:75

eve::gpgpu::Sequence::isAvailable
bool isAvailable() const
True when available.
Definition Sequence.cpp:66

params
std::vector< ParamSpec > params
Definition MeshModifierGraph.cpp:29

eve::fluids
GLSL compute kernels for the GPU surface-flow solver.
Definition FluidTarget.h:12

eve::fluids::kFluidClearGrid
const char * kFluidClearGrid
Zero the linked-list cell heads.
Definition FluidGpuKernels.h:39

eve::fluids::kFluidComputeDelta
const char * kFluidComputeDelta
Accumulate PBF position deltas into the (reused) grad buffer.
Definition FluidGpuKernels.h:165

eve::fluids::kFluidApplyDelta
const char * kFluidApplyDelta
Apply PBF deltas and re-project onto the SDF surface.
Definition FluidGpuKernels.h:228

eve::fluids::exposeVolumeFluidType
void exposeVolumeFluidType(ssq::Table &table)
Registers the script-owned volume-fluid class on the VM thread.
Definition VolumeFluidBindings.cpp:4

eve::fluids::kFluidDensityLambda
const char * kFluidDensityLambda
Density, gradient sum and PBF lambda in one pass (mirror computeDensitiesAndGrads + computeLambdas).
Definition FluidGpuKernels.h:87

eve::fluids::kFluidIntegrate
const char * kFluidIntegrate
Viscosity + cohesion + adhesion + gravity + integration + SDF projection.
Definition FluidGpuKernels.h:331

eve::fluids::kFluidBuildGrid
const char * kFluidBuildGrid
Insert every particle into its grid cell (linked list via atomicExchange).
Definition FluidGpuKernels.h:58

eve::fluids::exposeVolumeFluidFactory
void exposeVolumeFluidFactory(ssq::Class &cls)
Registers volume-fluid factories on the existing Fluids class.
Definition VolumeFluidFactoryBindings.cpp:7

eve::rpg::table
std::unordered_map< std::string, SkillDefinition > & table()
Definition Skill.cpp:65

eve::script::projectResult
ssq::Table projectResult(HSQUIRRELVM vm, Result< void > &&result)
Consume and project a void native Result using the common schema.
Definition SquirrelBinding.cpp:470

eve::tensor::glsl_detail::groupsFor
int groupsFor(int count)
Groups for.
Definition KernelGen.cpp:105

eve::DiagnosticCode::InvalidArgument
@ InvalidArgument

eve::DiagnosticCode::Unsupported
@ Unsupported

eve::DiagnosticCode::Failed
@ Failed

eve::StatusCode::Applied
@ Applied

enabled
bool enabled
Definition Settlement.cpp:31

eve::SimulationStep
One deterministic fixed-step emitted by SimulationClock.
Definition Time.h:158

eve::SimulationStep::delta
Duration delta
Fixed simulation duration for this step.
Definition Time.h:162

eve::fluids::FluidParams
Tuning knobs of one fluid simulation.
Definition FluidMath.h:26

eve::fluids::FluidParams::damping
float damping
Linear air damping applied each substep.
Definition FluidMath.h:44

eve::fluids::FluidParams::supportRadius
float supportRadius
SPH support radius h (kernel cutoff), typically 4x particleRadius.
Definition FluidMath.h:30

eve::fluids::FluidParams::particleRadius
float particleRadius
Resting particle radius in world units.
Definition FluidMath.h:28

eve::fluids::FluidParams::adhesion
float adhesion
Fluid-surface adhesion strength (contact angle / sticking).
Definition FluidMath.h:42

eve::fluids::FluidParams::pbfIterations
int pbfIterations
PBF density-constraint relaxation passes per substep.
Definition FluidMath.h:50

eve::fluids::FluidParams::cohesion
float cohesion
Fluid-fluid cohesion strength (droplet formation).
Definition FluidMath.h:40

eve::fluids::FluidParams::iterations
int iterations
Solver substeps per call to step(dt).
Definition FluidMath.h:48

eve::fluids::FluidParams::viscosity
float viscosity
XSPH viscosity strength (0 = inviscid).
Definition FluidMath.h:36

eve::fluids::FluidParams::gravity
glm::vec3 gravity
Gravity vector in world units / s^2.
Definition FluidMath.h:34

eve::fluids::FluidSurfaceParams
Camera + reconstruction tuning for the SSF pipeline.
Definition FluidSurfaceRenderer.h:61

eve::fluids::FluidSurfaceParams::width
int width
Definition FluidSurfaceRenderer.h:71

eve::fluids::SimGrid::make
static SimGrid make(const MeshSdf &sdf, float cellSize)
Build a grid covering the SDF domain plus one cell of padding.
Definition FluidSimulation.cpp:9

eve::fluids::SimGrid::cellSize
float cellSize
Cell size in world units (== SPH support radius).
Definition FluidSimulation.h:31

eve::fluids::SimGrid::cellCount
int cellCount() const
Cell count.
Definition FluidSimulation.cpp:19

eve::fluids::SimGrid::origin
glm::vec3 origin
World position of cell (0,0,0).
Definition FluidSimulation.h:27

eve::fluids::SimGrid::dims
glm::ivec3 dims
Cell counts per axis.
Definition FluidSimulation.h:29

eve::physics::SimulationObservation
Observable backend progress shared by CPU and accelerator providers.
Definition SimulationBackend.h:136

eve::physics::SimulationSettings
Validated solver policy for one simulation step.
Definition SimulationBackend.h:120