MeshEffectRenderer.h

浏览该文件的文档.

#pragma once
 
#include "common/Result.h"
#include "graphics/Color.h"
#include "stylize/MeshVfxBatchSubmission.h"
#include "stylize/MeshEffect.h"
#include "stylize/MeshParticleEmitter.h"
#include "stylize/TrailEffect.h"
 
#include <glm/mat4x4.hpp>
 
#include <cstdint>
#include <span>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace eve::graphics {
class Graphics;
class Mesh;
class Shader;
class Texture;
}
 
namespace eve::stylize {
 
struct MeshEffectDrawSource {
    MeshEffectTargetHandle target;
    graphics::Mesh* mesh = nullptr;
    graphics::Texture* albedo = nullptr;
    glm::mat4 model{1.f};
    graphics::Color tint{1.f};
};
 
struct MeshParticleDrawSource {
    graphics::Mesh* mesh = nullptr;
    graphics::Texture* albedo = nullptr;
    MeshParticleInstance instance;
};
 
struct TrailUploadData {
    std::vector<float> positions;
    std::vector<float> normals;
    std::vector<float> uvs;
    std::vector<std::uint32_t> indices;
};
 
enum class MeshEffectSubmitStatus { Drawn, SkippedInactive, SkippedEmpty };
 
struct MeshVfxRendererCommand {
    enum class Kind : std::uint8_t { Overlay, Trail, Particle };
 
    std::uint64_t stableInstanceId = 0;
    Kind kind = Kind::Overlay;
    MeshEffectInstance* effect = nullptr;
    MeshEffectDrawSource overlay;
    TrailMeshSnapshot trail;
    glm::mat4 trailModel{1.f};
    graphics::Color trailTint{1.f};
    MeshParticleDrawSource particle;
};
 
struct MeshParticleRenderInputs {
    std::vector<MeshVfxLodCandidate> lodCandidates;
    std::vector<MeshVfxRenderItem> renderItems;
    std::vector<MeshVfxRendererCommand> commands;
};
 
[[nodiscard]] EVENGINE_API_WORLD MeshParticleRenderInputs buildMeshParticleRenderInputs(
    std::span<const MeshParticleInstance> instances, MeshEffectInstance* effect, graphics::Mesh* mesh,
    graphics::Texture* albedo, const MeshVfxBatchKey& key, std::uint64_t emitterStableId,
    const glm::vec3& cameraPosition, float projectionScalePixels, float maximumDistance, std::int32_t priority = 0);
 
[[nodiscard]] EVENGINE_API_WORLD eve::Result<TrailUploadData> prepareTrailUpload(const TrailMeshSnapshot& snapshot);
 
class EVENGINE_API_WORLD MeshEffectRenderer final : public IMeshVfxBatchSink {
public:
    explicit MeshEffectRenderer(graphics::Graphics& graphics) noexcept;
 
    MeshEffectRenderer(const MeshEffectRenderer&) = delete;
    MeshEffectRenderer& operator=(const MeshEffectRenderer&) = delete;
 
    [[nodiscard]] eve::Result<MeshEffectSubmitStatus> submitOverlay(
        MeshEffectInstance& effect, const MeshEffectDrawSource& source);
 
    [[nodiscard]] eve::Result<MeshEffectSubmitStatus> submitTrail(
        MeshEffectInstance& effect, const TrailMeshSnapshot& snapshot,
        const glm::mat4& model = glm::mat4(1.f), const graphics::Color& tint = graphics::Color(1.f));
 
    [[nodiscard]] eve::Result<MeshEffectSubmitStatus> submitParticle(
        MeshEffectInstance& effect, const MeshParticleDrawSource& source);
 
    [[nodiscard]] eve::Result<MeshVfxSubmissionReport> submitQueue(
        const MeshVfxRenderQueue& queue, std::span<const MeshVfxRendererCommand> commands);
 
    MeshVfxSubmitStatus beginBatch(const MeshVfxBatchKey& key) override;
 
    MeshVfxSubmitStatus submitDraw(const MeshVfxBatchedDraw& draw) override;
 
    MeshVfxSubmitStatus endBatch() override;
 
    [[nodiscard]] graphics::Mesh* trailMesh() const noexcept { return trailMesh_; }
 
private:
    graphics::Shader* shaderFor(MeshEffectInstance& effect);
 
    graphics::Graphics& graphics_;
    graphics::Mesh* trailMesh_ = nullptr;
    std::unordered_map<std::string, graphics::Shader*> shaders_;
    std::unordered_map<std::uint64_t, const MeshVfxRendererCommand*> activeCommands_;
    bool batchActive_ = false;
};
 
}  // namespace eve::stylize