Material.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/Result.h"
#include "graphics/BlendMode.h"
#include "graphics/Mesh.h"
#include "graphics/PbrSurface.h"
#include "graphics/Shader.h"
#include "graphics/SurfaceMode.h"
#include "graphics/Texture.h"
 
#include <map>
#include <string>
 
namespace eve::graphics {
 
class Graphics;
 
enum class MaterialVirtualTextureMode { Conventional, AtlasPageTable };
 
class EVENGINE_API_BACKENDS Material {
public:
    static constexpr int kMaxPartsHint = 8;
 
    Material()  = default;
    ~Material() = default;
 
    Material(const Material&)            = delete;
    Material& operator=(const Material&) = delete;
 
    void        setShadingModel(const std::string& model);
    std::string getShadingModel() const { return shadingModel_; }
 
    [[nodiscard]] Result<void> setPbrSurface(const PbrSurface& surface);
    PbrSurface pbrSurface() const {
        auto s  = pbr_;
        s.unlit = shadingModel_ == "unlit";
        return s;
    }
    bool hasPbrSurface() const { return pbrEnabled_; }
 
    [[nodiscard]] Result<void> setFoliageTranslucency(float red, float green, float blue, float intensity,
                                                      float strength, float normalDistortion, float scattering,
                                                      float direct, float ambient, float shadow);
    [[nodiscard]] Result<void> setFoliageWind(Texture* motionTexture, Texture* noiseTexture, float directionX,
                                              float directionZ, float strength, float bending, float bendingSpeed,
                                              float branch, float branchSpeed, float flutter, float flutterSpeed,
                                              float fadeDistance, float bendFactor);
    [[nodiscard]] Result<void> setFoliageWindTime(float seconds);
    void setAlbedoTexture(Texture* texture) { pbr_.textures[0].texture = texture; }
    Texture* getAlbedoTexture() const { return pbr_.textures[0].texture; }
 
    void setNormalTexture(Texture* texture) { pbr_.textures[2].texture = texture; }
    Texture* getNormalTexture() const { return pbr_.textures[2].texture; }
 
    void     setHeightTexture(Texture* texture) { height_ = texture; }
    Texture* getHeightTexture() const { return height_; }
 
    [[nodiscard]] eve::Result<void> setVirtualTexture(Texture* albedoAtlas, Texture* normalAtlas, Texture* pageTable,
                                                      int pageCountX, int pageCountY, int atlasSlotsX, int atlasSlotsY,
                                                      float borderFraction);
 
    void clearVirtualTexture();
    MaterialVirtualTextureMode virtualTextureMode() const {
        return virtualTextureEnabled_ ? MaterialVirtualTextureMode::AtlasPageTable
                                      : MaterialVirtualTextureMode::Conventional;
    }
 
    void setShader(Shader* shader) { shader_ = shader; }
    Shader* getShader() const { return shader_; }
 
    void  setTint(float r, float g, float b, float a = 1.f);
    float getTintR() const { return r_; }
    float getTintG() const { return g_; }
    float getTintB() const { return b_; }
    float getTintA() const { return a_; }
 
    void  setMetallic(float metallic);
    float getMetallic() const { return metallic_; }
 
    void  setRoughness(float roughness);
    float getRoughness() const { return roughness_; }
 
    void  setTexCellBomb(float cellScale, float strength, float rotAmount = 1.f);
    float getTexCellBombScale() const { return texBombScale_; }
    float getTexCellBombStrength() const { return texBombStrength_; }
    float getTexCellBombRotation() const { return texBombRot_; }
 
    void  setParallax(float scale, float minLayers = 8.f, float maxLayers = 32.f);
    float getParallaxScale() const { return parallaxScale_; }
    float getParallaxMinLayers() const { return parallaxMinLayers_; }
    float getParallaxMaxLayers() const { return parallaxMaxLayers_; }
 
    void setReceiveLight(bool receive) { receiveLight_ = receive; }
    bool getReceiveLight() const { return receiveLight_ && shadingModel_ != "unlit"; }
 
    void setCastShadow(bool cast) { castShadow_ = cast; }
    bool getCastShadow() const { return castShadow_; }
 
    void setReceiveShadow(bool receive) { receiveShadow_ = receive; }
    bool getReceiveShadow() const { return receiveShadow_; }
 
    void setCastOcclusion(bool cast) { castOcclusion_ = cast; }
    bool getCastOcclusion() const { return castOcclusion_; }
 
    void setHair(bool hair);
    bool getHair() const { return isHair_; }
 
    bool  hasParam(const std::string& name) const;
    void  setFloat(const std::string& name, float value);
    float getFloat(const std::string& name) const;
 
    [[nodiscard]] Result<void> bind(Graphics& gfx) const;
 
    Shader* effectiveShader() const;
 
    bool isTransparentHair() const;
 
    void        setSurfaceMode(const std::string& mode);
    std::string getSurfaceMode() const;
    SurfaceMode surfaceMode() const { return surfaceMode_; }
    void        setAlphaCutoff(float cutoff);
    float       getAlphaCutoff() const { return alphaCutoff_; }
    void        setBlendMode(const std::string& mode);
    std::string getBlendMode() const;
    BlendMode   blendMode() const { return blendMode_; }
    void        setDepthWrite(bool enabled) { depthWrite_ = enabled; }
    bool        getDepthWrite() const { return depthWrite_; }
    void        setDoubleSided(bool enabled) { doubleSided_ = enabled; }
    bool        getDoubleSided() const { return doubleSided_; }
    void setCameraFacing(bool enabled) { cameraFacing_ = enabled; }
    bool getCameraFacing() const { return cameraFacing_; }
    void setSortPriority(int priority) { sortPriority_ = priority; }
    int  getSortPriority() const { return sortPriority_; }
    void        setAlphaTechnique(const std::string& technique);
    std::string getAlphaTechnique() const { return alphaTechnique_; }
 
private:
    PbrSurface                   pbr_;
    bool                         pbrEnabled_   = false;
    std::string                  shadingModel_ = "pbr";
    Texture*                     height_       = nullptr;
    Shader*                      shader_       = nullptr;
    float                        r_ = 1.f, g_ = 1.f, b_ = 1.f, a_ = 1.f;
    float                        metallic_              = 0.f;
    float                        roughness_             = 0.45f;
    float                        texBombScale_          = 4.f;
    float                        texBombStrength_       = 0.f;
    float                        texBombRot_            = 1.f;
    float                        parallaxScale_         = 0.f;
    float                        parallaxMinLayers_     = 8.f;
    float                        parallaxMaxLayers_     = 32.f;
    bool                         receiveLight_          = true;
    bool                         castShadow_            = true;
    bool                         receiveShadow_         = true;
    bool                         castOcclusion_         = true;
    bool                         isHair_                = false;
    SurfaceMode                  surfaceMode_           = SurfaceMode::Opaque;
    BlendMode                    blendMode_             = BlendMode::Alpha;
    float                        alphaCutoff_           = 0.5f;
    bool                         depthWrite_            = false;
    bool                         doubleSided_           = false;
    bool                         cameraFacing_          = false;
    int                          sortPriority_          = 0;
    std::string                  alphaTechnique_        = "cutoff";
    bool                         virtualTextureEnabled_ = false;
    int                          virtualPageCountX_     = 0;
    int                          virtualPageCountY_     = 0;
    int                          virtualAtlasSlotsX_    = 0;
    int                          virtualAtlasSlotsY_    = 0;
    float                        virtualBorderFraction_ = 0.f;
    std::map<std::string, float> params_;
};
 
struct ModelPart {
    std::string name;
    Mesh*       mesh     = nullptr;
    Material*   material = nullptr;
    int  sortPriority    = 0;
    bool hasSortPriority = false;
};
 
}  // namespace eve::graphics