DecalManager.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include <glm/mat4x4.hpp>
 
#include <cstdint>
#include <string>
#include <vector>
 
namespace eve::graphics {
class Graphics;
class Texture;
}  // namespace eve::graphics
 
namespace eve::decal {
 
struct DecalInstance {
    int id = 0;
    float x = 0.f, y = 0.f, z = 0.f;
    float nx = 0.f, ny = 1.f, nz = 0.f;
    float yaw = 0.f;  // random rotation around the surface normal
    float size = 0.5f;
    float depth = 0.15f;
    float age = 0.f;        // seconds since spawn
    float lifetime = 0.f;   // 0 = persistent
    float fadeIn = 0.f;
    float fadeOut = 0.f;
    graphics::Texture *albedo = nullptr;
    graphics::Texture *normal = nullptr;
    graphics::Texture *params = nullptr;
    float uvRect[4] = {0.f, 0.f, 1.f, 1.f};
    float normalStrength = 0.f;
    float roughnessStrength = 0.f;
    float metalStrength = 0.f;
    float emissiveStrength = 0.f;
    int blendMode = 0;       // 0 = premultiplied over, 1 = additive (emissive)
    int projectionMode = 0;  // 0 = planar, 1 = triplanar, 2 = spherical, 3 = world-aligned
    float blendSharpness = 4.f;
    float parallaxScale = 0.f;
    float parallaxMinLayers = 8.f;
    float parallaxMaxLayers = 24.f;
    float edgeFadeWidth = 0.06f;
    std::string kind;  // quota group ("blood", "dirt", ...)
};
 
enum class DecalProjectionStatus : std::uint8_t {
    Applied = 0,
    UnknownId = 1,
    InvalidMode = 2,
    InvalidSharpness = 3,
};
 
enum class DecalParallaxStatus : std::uint8_t {
    Applied = 0,
    UnknownId = 1,
    InvalidScale = 2,
    InvalidLayers = 3,
};
 
enum class DecalEdgeFadeStatus : std::uint8_t {
    Applied = 0,
    UnknownId = 1,
    InvalidWidth = 2,
};
 
class EVENGINE_API_WORLD DecalManager {
public:
    static DecalManager &inst();
 
    int project(float x, float y, float z, float nx, float ny, float nz,
                graphics::Texture *albedo, const std::string &kind, float size, float depth,
                bool randomYaw, int seed, float fadeIn, float lifetime, float fadeOut,
                float normalStrength, float roughnessStrength, float metalStrength,
                float emissiveStrength);
 
    bool remove(int id);
    [[nodiscard]] bool contains(int id) const;
    void clearAll();
    int count() const;
    bool setStrength(int id, float normalStrength, float roughnessStrength, float metalStrength,
                     float emissiveStrength);
    bool setUvRect(int id, float x, float y, float w, float h);
    bool setTextures(int id, graphics::Texture *normal, graphics::Texture *params);
    bool setBlend(int id, const std::string &mode);
    [[nodiscard]] DecalProjectionStatus setProjection(int id, const std::string &mode,
                                                      float blendSharpness = 4.f);
    [[nodiscard]] DecalParallaxStatus setParallax(int id, float scale, float minLayers = 8.f,
                                                 float maxLayers = 24.f);
    [[nodiscard]] DecalEdgeFadeStatus setEdgeFade(int id, float width);
 
    int replace(int previousId, DecalInstance candidate);
 
    void setLimit(const std::string &kind, int limit);
 
    void update(float dt);
 
    void drawAll(graphics::Graphics &gfx, float eyeX, float eyeY, float eyeZ,
                 const glm::mat4 &viewProj, float aspect);
 
    std::vector<DecalInstance> &instances() { return decals_; }
    const std::vector<DecalInstance> &instances() const { return decals_; }
 
private:
    DecalManager() = default;
    ~DecalManager() = default;
    DecalManager(const DecalManager &) = delete;
    DecalManager &operator=(const DecalManager &) = delete;
 
    int nextId_ = 1;
    std::vector<DecalInstance> decals_;
    struct KindLimit {
        std::string kind;
        int limit = 0;  // 0 = unlimited
    };
    std::vector<KindLimit> limits_;
    int limitFor(const std::string &kind) const;
};
 
}  // namespace eve::decal