Shader.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include <array>
#include <cstddef>
#include <cstdint>
#include <map>
#include <string>
#include <vector>
#include "common/Result.h"
#include "graphics/BlendMode.h"
#include "graphics/MeshShaderRasterState.h"
 
#include <glm/mat4x4.hpp>
 
namespace eve::graphics {
class Texture;
namespace vulkan {
class Graphics;
}
 
class EVENGINE_API_BACKENDS Shader {
public:
    static constexpr int kMaxFloats = 32;
    static constexpr std::size_t kMaxMeshTextures = 4;
    static constexpr uint32_t kPushConstantBytes = uint32_t(kMaxFloats * sizeof(float));
 
    enum class Kind { eSprite2D, eMesh3D };
 
    enum ShaderType {
        eCompute,
        eVertex,
        eFragment,
        eGeometry,
        eTessCtrl,
        eTessEval
    };
 
    Shader();
    ~Shader();
 
    Shader(const Shader &) = delete;
    Shader &operator=(const Shader &) = delete;
 
    Kind getKind() const { return kind_; }
    void setKind(Kind k) { kind_ = k; }
 
    void setXray(bool x) { isXray_ = x; }
    bool isXray() const { return isXray_; }
 
    BlendMode meshBlend = BlendMode::Opaque;
    bool meshDepthWrite = true;
    bool meshDoubleSided = true;
    const MeshShaderRasterState &meshRasterState() const noexcept { return meshRaster_; }
 
    int declareFloat(const std::string &name);
    int declareVec2(const std::string &name);
    int declareVec3(const std::string &name);
    int declareVec4(const std::string &name);
    int declareMatrix(const std::string &name);
 
    void sendFloat(const std::string &name, float x);
    void sendVec2(const std::string &name, float x, float y);
    void sendVec3(const std::string &name, float x, float y, float z);
    void sendVec4(const std::string &name, float x, float y, float z, float w);
    void sendMatrix(const std::string &name, const glm::mat4 &m);
 
    int sendToVar(const std::string &name, const void *data, size_t size);
    int getFromVar(const std::string &name, void *data, size_t size) const;
 
    bool hasUniform(const std::string &name) const;
    int getUniformIndex(const std::string &name) const;
    int getUniformFloatCount(const std::string &name) const;
 
    const float *pushConstantData() const { return floats_.data(); }
    void     setPushConstantBlock(const std::array<float, kMaxFloats> &values) noexcept;
    uint32_t pushConstantSize() const { return uint32_t(usedFloats_ * sizeof(float)); }
    int usedFloats() const { return usedFloats_; }
 
    [[nodiscard]] Result<void> setMeshTexture(std::size_t slot, Texture *texture);
    Texture *meshTexture(std::size_t slot) const {
        return slot < meshTextures_.size() ? meshTextures_[slot] : nullptr;
    }
 
    const std::vector<uint32_t> &vertexSpirv() const { return vertSpv_; }
    const std::vector<uint32_t> &fragmentSpirv() const { return fragSpv_; }
 
    void setSpirv(std::vector<uint32_t> vert, std::vector<uint32_t> frag) {
        vertSpv_ = std::move(vert);
        fragSpv_ = std::move(frag);
    }
 
    void *gpuHandle = nullptr;
 
private:
    friend class vulkan::Graphics;
    MeshShaderRasterState meshRaster_;
    struct Uniform {
        int index = 0;
        int floatCount = 0;
    };
 
    int declareUniform(const std::string &name, int floatCount);
    Uniform *findUniform(const std::string &name);
    const Uniform *findUniform(const std::string &name) const;
 
    Kind kind_ = Kind::eSprite2D;
    bool isXray_ = false;
    std::vector<uint32_t> vertSpv_;
    std::vector<uint32_t> fragSpv_;
    std::map<std::string, Uniform> uniforms_;
    std::array<float, kMaxFloats> floats_{};
    std::array<Texture *, kMaxMeshTextures> meshTextures_{};
    int usedFloats_ = 0;
};
 
}  // namespace eve::graphics