PhysicsCapabilities.cpp

浏览该文件的文档.

#include "common/CameraObstruction.h"
#include "common/Capability.h"
#include "common/PhysicsQuery.h"
#include "common/ProcgenWorldQuery.h"
#include "physics/ArtifactProvider.h"
#include "physics/Physics.h"
#include "physics/TargetingLineOfSightAdapter.h"
#include "physics/World.h"
#include "sensing/LineOfSightRouter.h"
#include "physics/World3D.h"
 
#include <algorithm>
#include <string>
#include <vector>
 
namespace eve::physics {
namespace {
 
class PhysicsQueryImpl final : public eve::IPhysicsQuery {
public:
    int newWorld(float gravityX, float gravityY) override {
        auto *ph = eve::ModuleManager::getInstance<Physics>("Physics");
        if (!ph) return -1;
        auto *w = ph->newWorld(gravityX, gravityY);
        if (!w) return -1;
        worlds_.push_back(w);
        return static_cast<int>(worlds_.size()) - 1;
    }
 
    int worldCount() override {
        int n = 0;
        for (auto *w : worlds_)
            if (w) ++n;
        return n;
    }
 
    bool worldGravity(int id, float *gx, float *gy) override {
        auto *w = world(id);
        if (!w) return false;
        if (gx) *gx = w->getGravityX();
        if (gy) *gy = w->getGravityY();
        return true;
    }
 
    bool rayCast(int id, float x1, float y1, float x2, float y2, RayHitInfo *out) override {
        auto *w = world(id);
        if (!w || !out) return false;
        w->rayCast(x1, y1, x2, y2);
        out->hit = w->hasRayHit();
        if (out->hit) {
            out->bodyId = w->getRayHitBodyId();
            out->x = w->getRayHitX();
            out->y = w->getRayHitY();
            out->normalX = w->getRayHitNormalX();
            out->normalY = w->getRayHitNormalY();
            out->fraction = w->getRayHitFraction();
        }
        return true;
    }
 
    bool removeWorld(int id) override {
        if (id < 0 || static_cast<size_t>(id) >= worlds_.size()) return false;
        delete worlds_[static_cast<size_t>(id)];
        worlds_[static_cast<size_t>(id)] = nullptr;
        return true;
    }
 
private:
    World *world(int id) const {
        if (id < 0 || static_cast<size_t>(id) >= worlds_.size()) return nullptr;
        return worlds_[static_cast<size_t>(id)];
    }
 
    std::vector<World *> worlds_;
};
 
class CameraObstructionQueryImpl final : public eve::ICameraObstructionQuery {
public:
    void add(World3D* world, std::weak_ptr<const void> lifetime) {
        std::erase_if(worlds_, [](const RegisteredWorld& entry) { return entry.lifetime.expired(); });
        const auto found = std::find_if(worlds_.begin(), worlds_.end(),
                                        [world](const RegisteredWorld& entry) { return entry.world == world; });
        if (world && found == worlds_.end()) worlds_.push_back({world, std::move(lifetime)});
    }
 
    bool sphereCast(float fromX, float fromY, float fromZ, float toX, float toY, float toZ,
                    float radius, uint64_t maskBits, int ignoredBodyId,
                    eve::CameraObstructionHit* out) override {
        if (out) *out = eve::CameraObstructionHit{};
        if (!out) return false;
        for (const RegisteredWorld& entry : worlds_) {
            auto     lifetime = entry.lifetime.lock();
            World3D* world    = entry.world;
            if (!lifetime || !world || !world->isValid()) continue;
            CameraSphereHit3D hit;
            if (!world->sphereCast(fromX, fromY, fromZ, toX, toY, toZ, radius, maskBits,
                                   ignoredBodyId, &hit))
                continue;
            if (!out->hit || hit.fraction < out->fraction) {
                out->hit = true;
                out->bodyId = hit.bodyId;
                out->fraction = hit.fraction;
                out->x = hit.x;
                out->y = hit.y;
                out->z = hit.z;
                out->normalX = hit.nx;
                out->normalY = hit.ny;
                out->normalZ = hit.nz;
            }
        }
        return out->hit;
    }
 
private:
    struct RegisteredWorld {
        World3D*                  world = nullptr;
        std::weak_ptr<const void> lifetime;
    };
 
    std::vector<RegisteredWorld> worlds_;
};
 
CameraObstructionQueryImpl& cameraObstructionQuery();
 
class ProcgenWorldQueryImpl final : public eve::IProcgenWorldQuery {
public:
    eve::Result<eve::ProcgenSurfaceHit> projectDown(float x, float z, float maxY, float minY,
                                                    std::uint64_t maskBits) override {
        eve::ProcgenSurfaceHit output;
        eve::CameraObstructionHit hit;
        const bool found = cameraObstructionQuery().sphereCast(
            x, maxY, z, x, minY, z, 0.f, maskBits, -1, &hit);
        if (!found) return eve::Result<eve::ProcgenSurfaceHit>::success(output);
        output.hit = true;
        output.objectId = hit.bodyId;
        output.x = hit.x;
        output.y = hit.y;
        output.z = hit.z;
        output.normalX = hit.normalX;
        output.normalY = hit.normalY;
        output.normalZ = hit.normalZ;
        return eve::Result<eve::ProcgenSurfaceHit>::success(output);
    }
};
 
CameraObstructionQueryImpl& cameraObstructionQuery() {
    static CameraObstructionQueryImpl impl;
    return impl;
}
 
TargetingLineOfSightAdapter& targetingLineOfSightAdapter() {
    static TargetingLineOfSightAdapter impl;
    return impl;
}
 
}  // namespace
 
void registerPhysicsCapabilities() {
    static PhysicsQueryImpl impl;
    static ProcgenWorldQueryImpl procgenWorldQuery;
    eve::cap::provide<eve::IPhysicsQuery>(&impl);
    eve::cap::provide<eve::IProcgenWorldQuery>(&procgenWorldQuery);
    eve::cap::provide<eve::ICameraObstructionQuery>(&cameraObstructionQuery());
    // Claim World3D through the sensing router rather than owning the single-slot
    // `ILineOfSightQuery` capability: a grid board can then claim its own space without the two
    // providers replacing each other by load order. `ensureLineOfSightRouter` reports Conflict
    // when some other provider already holds the capability; that registration is left alone on
    // purpose, so this adapter simply does not take part and the project keeps its own provider.
    auto router = eve::sensing::ensureLineOfSightRouter();
    if (router)
        router.value()
            ->addProvider(eve::sensing::CoordinateSpace::World3D, &targetingLineOfSightAdapter())
            .ignore("physics line-of-sight space claim was refused");
    registerPhysicsArtifactProvider();
}
 
void registerCameraObstructionWorld(World3D* world) {
    if (world) cameraObstructionQuery().add(world, world->queryLifetime_);
}
eve::Result<void> registerTargetingLineOfSightWorld(World3D* world) {
    return targetingLineOfSightAdapter().addWorld(world);
}
 
}  // namespace eve::physics