PixelWorldPhysics.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/Result.h"
#include "physics/PhysicsLink.h"
#include "pixelworld/PixelWorld.h"
 
#include <cstdint>
#include <memory>
#include <vector>
 
namespace eve::physics {
class World;
}
 
namespace eve::pixelworld_physics {
 
struct FragmentCollisionRect {
    int x = 0;
    int y = 0;
    int width = 0;
    int height = 0;
};
 
struct FragmentBodyConfig {
    float density = 1.0f;
    float friction = 0.4f;
    float restitution = 0.05f;
    std::uint32_t maximumFixtures = 256;
};
 
enum class FragmentSettleDisposition : std::uint8_t { StillAwake, Rasterized };
 
struct FragmentSettleReceipt {
    FragmentSettleDisposition disposition = FragmentSettleDisposition::StillAwake;
    std::uint64_t fragmentId = 0;
    std::uint32_t cellsRasterized = 0;
    int quarterTurns = 0;
};
 
struct TerrainCollisionSyncReceipt {
    std::uint64_t sourceRevision = 0;
    std::uint32_t chunksRebuilt = 0;
    std::uint32_t fixturesCreated = 0;
    std::uint32_t bodiesRemoved = 0;
};
 
struct TerrainCollisionContour {
    std::vector<float> vertices;
    bool loop = false;
};
 
struct PixelTerrainContact {
    bool hit = false;
    eve::pixelworld::MaterialId material = eve::pixelworld::MaterialId::Air;
    int cellX = 0;
    int cellY = 0;
    float pointX = 0.f;
    float pointY = 0.f;
    float normalX = 0.f;
    float normalY = 0.f;
    float depth = 0.f;
    float fraction = 0.f;
};
 
[[nodiscard]] EVENGINE_API_DOMAINS eve::Result<std::vector<TerrainCollisionContour>> extractTerrainContours(
    const eve::pixelworld::PixelWorld& pixelWorld, int chunkX, int chunkY, std::uint32_t maximumVertices = 4096);
 
[[nodiscard]] EVENGINE_API_DOMAINS eve::Result<PixelTerrainContact> probeTerrainCircle(
    const eve::pixelworld::PixelWorld& pixelWorld, float centerX, float centerY, float radius,
    std::uint32_t maximumCells = 4096);
 
[[nodiscard]] EVENGINE_API_DOMAINS eve::Result<PixelTerrainContact> sweepTerrainCircle(
    const eve::pixelworld::PixelWorld& pixelWorld, float startX, float startY, float endX, float endY, float radius,
    std::uint32_t maximumCells = 16384);
 
class EVENGINE_API_DOMAINS PixelFragmentBody {
public:
    ~PixelFragmentBody() = default;
    PixelFragmentBody(PixelFragmentBody&&) noexcept = default;
    PixelFragmentBody& operator=(PixelFragmentBody&&) noexcept = default;
    PixelFragmentBody(const PixelFragmentBody&) = delete;
    PixelFragmentBody& operator=(const PixelFragmentBody&) = delete;
 
    [[nodiscard]] static eve::Result<std::unique_ptr<PixelFragmentBody>> create(
        eve::physics::World& world, eve::pixelworld::PixelFragment fragment,
        FragmentBodyConfig config = {});
 
    [[nodiscard]] const std::vector<FragmentCollisionRect>& collisionRects() const noexcept;
    [[nodiscard]] std::uint64_t fragmentId() const noexcept;
    [[nodiscard]] eve::physics::PhysicsLink physicsLink() const noexcept;
    [[nodiscard]] bool isRasterized() const noexcept;
 
    [[nodiscard]] eve::Result<FragmentSettleReceipt> settleIfSleeping(
        eve::physics::World& physicsWorld, eve::pixelworld::PixelWorld& pixelWorld);
 
    [[nodiscard]] eve::Result<void> releasePhysics(eve::physics::World& physicsWorld);
 
private:
    PixelFragmentBody(eve::pixelworld::PixelFragment fragment, eve::physics::PhysicsLink link,
                      std::vector<FragmentCollisionRect> rectangles);
 
    eve::pixelworld::PixelFragment fragment_;
    eve::physics::PhysicsLink link_;
    std::vector<FragmentCollisionRect> rectangles_;
    bool rasterized_ = false;
    bool physicsReleased_ = false;
};
 
class EVENGINE_API_DOMAINS PixelTerrainCollisionCache {
public:
    PixelTerrainCollisionCache();
    ~PixelTerrainCollisionCache();
    PixelTerrainCollisionCache(PixelTerrainCollisionCache&&) noexcept;
    PixelTerrainCollisionCache& operator=(PixelTerrainCollisionCache&&) noexcept;
    PixelTerrainCollisionCache(const PixelTerrainCollisionCache&) = delete;
    PixelTerrainCollisionCache& operator=(const PixelTerrainCollisionCache&) = delete;
 
    [[nodiscard]] eve::Result<TerrainCollisionSyncReceipt> sync(
        eve::physics::World& physicsWorld, const eve::pixelworld::PixelWorld& pixelWorld,
        std::uint32_t maximumFixturesPerChunk = 256);
 
    [[nodiscard]] eve::Result<void> clearPhysics(eve::physics::World& physicsWorld);
    [[nodiscard]] std::uint64_t sourceRevision() const noexcept;
    [[nodiscard]] std::size_t bodyCount() const noexcept;
 
private:
    struct Impl;
    std::unique_ptr<Impl> impl_;
};
 
}  // namespace eve::pixelworld_physics