GroomInstance.h

浏览该文件的文档.

#pragma once
 
#include "common/Result.h"
#include "graphics/hair/ClusterGrid.h"
#include "graphics/hair/GroomAsset.h"
#include "graphics/hair/Guides.h"
#include "graphics/hair/Procedural.h"
#include "graphics/hair/Simulation.h"
 
#include <cstdint>
#include <vector>
 
#include <glm/mat4x4.hpp>
#include <glm/vec3.hpp>
 
namespace eve::graphics {
 
class Graphics;
class Mesh;
class Shader;
class Texture;
 
namespace hair {
 
class EVENGINE_API_BACKENDS GroomInstance {
public:
    explicit GroomInstance(Graphics *gfx);
    ~GroomInstance();
 
    GroomInstance(const GroomInstance &) = delete;
    GroomInstance &operator=(const GroomInstance &) = delete;
 
    [[nodiscard]] Result<void> setAsset(const GroomAsset &asset);
 
    [[nodiscard]] Result<void> bakeProceduralPlane(float sizeX, float sizeZ,
                                                   const ProceduralParams &params = {});
 
    [[nodiscard]] Result<void> bakeProceduralMesh(const float *posXYZ, const float *nrmXYZ,
                                                  int vertexCount, const uint32_t *indices,
                                                  int indexCount,
                                                  const ProceduralParams &params = {});
 
    void setForcedLod(int lod);
    [[nodiscard]] int getForcedLod() const;
 
    void setScreenSize(float screenSize);
    [[nodiscard]] float getScreenSize() const;
 
    void setWidthScale(float scale);
    [[nodiscard]] float getWidthScale() const;
 
    void setSideHint(float x, float y, float z);
 
    void setClusterCullingEnabled(bool enabled);
    [[nodiscard]] bool isClusterCullingEnabled() const;
 
    [[nodiscard]] Result<void> updateVisibility(const float *viewProj16);
 
    void setMarschnerLobes(float r, float tt, float trt);
    [[nodiscard]] float getMarschnerR() const;
    [[nodiscard]] float getMarschnerTT() const;
    [[nodiscard]] float getMarschnerTRT() const;
 
    void setSelfShadow(float strength, float bias, float rootAo);
    [[nodiscard]] float getSelfShadowStrength() const;
    [[nodiscard]] float getSelfShadowBias() const;
    [[nodiscard]] float getRootAoStrength() const;
 
    [[nodiscard]] Result<void> rebuild();
 
    [[nodiscard]] Result<void> enableGuideSimulation(const GuideSimParams &params = {},
                                                     float guideFraction = 0.15f,
                                                     InterpolationMode mode = InterpolationMode::Offset);
 
    [[nodiscard]] Result<void> disableGuideSimulation();
 
    [[nodiscard]] bool isGuideSimulationEnabled() const;
    void setGuideSimParams(const GuideSimParams &params);
    [[nodiscard]] const GuideSimParams &getGuideSimParams() const;
 
    [[nodiscard]] Result<void> update(float dt);
 
    void draw(const glm::mat4 &model);
    void draw();
 
    [[nodiscard]] Mesh *getMesh() const;
    [[nodiscard]] Shader *getShader() const;
    [[nodiscard]] Texture *getTexture() const;
    [[nodiscard]] int getCurveCount() const;
    [[nodiscard]] int getPointCount() const;
    [[nodiscard]] size_t getGroupCount() const;
    [[nodiscard]] int getActiveLodIndex() const;
    [[nodiscard]] int getActiveRepresentation() const;
    [[nodiscard]] size_t getClusterCount() const;
    [[nodiscard]] int getVisibleCurveCount() const;
 
private:
    struct GroupCullState {
        ClusterGrid clusters;
        std::vector<uint32_t> visibleCurves;
        bool hasVisibility = false;
    };
 
    struct GroupSimState {
        GuideSimulator simulator;
        StrandsDatas restStrands;
        StrandsDatas restGuides;
        std::vector<StrandGuideWeights> weights;
        StrandsDatas deformedStrands;
        bool active = false;
    };
 
    [[nodiscard]] Result<void> bakeFromStrands(StrandsDatas strands, const char *debugName);
    [[nodiscard]] const GroomGroup *primaryGroup() const;
    [[nodiscard]] size_t resolveLodIndex(const GroomGroup &group) const;
    [[nodiscard]] StrandsDatas decimatedStrands(const StrandsDatas &src, float curveFraction) const;
    [[nodiscard]] Result<void> rebuildClusterGrids();
    [[nodiscard]] Result<void> ensureDrawResources();
    [[nodiscard]] Result<void> setupGuideSimulation(float guideFraction, InterpolationMode mode);
    void clearGuideSimulation();
    void applyShadingParams();
 
    Graphics *gfx_ = nullptr;
    GroomAsset asset_;
    std::vector<GroupCullState> groupCull_;
    std::vector<GroupSimState> groupSim_;
    Mesh *mesh_ = nullptr;
    Shader *shader_ = nullptr;
    Texture *texture_ = nullptr;
    int forcedLod_ = -1;
    int activeLodIndex_ = 0;
    Representation activeRepresentation_ = Representation::None;
    float screenSize_ = 1.f;
    float widthScale_ = 1.f;
    float clusterCellSize_ = 0.15f;
    float marschnerR_ = 1.f;
    float marschnerTT_ = 0.45f;
    float marschnerTRT_ = 0.25f;
    float selfShadowStrength_ = 0.35f;
    float selfShadowBias_ = 0.25f;
    float rootAoStrength_ = 0.3f;
    float guideFraction_ = 0.15f;
    GuideSimParams guideSimParams_{};
    InterpolationMode guideInterpMode_ = InterpolationMode::Offset;
    bool clusterCulling_ = false;
    bool guideSimEnabled_ = false;
    glm::vec3 sideHint_{1.f, 0.f, 0.f};
    glm::mat4 lastModel_{1.f};
};
 
}  // namespace hair
}  // namespace eve::graphics