Graphics.h

浏览该文件的文档.

#pragma once
 
#include <assimp/matrix4x4.h>
#include <cstdint>
#include <glm/glm.hpp>
#include <memory>
#include <optional>
#include <string>
#include <vector>
#include "common/Module.h"
#include "common/WindowSurfaceHost.h"
#include "graphics/BlendMode.h"
#include "graphics/Canvas.h"
#include "graphics/Color.h"
#include "graphics/Font.h"
#include "graphics/IGraphics2D.h"
#include "graphics/IGraphics3D.h"
#include "graphics/IPostFX.h"
#include "graphics/IResourceFactory.h"
 
struct aiMesh;
 
namespace eve::graphics {
 
class AmbientOcclusion;
class AntiAliasing;
class Camera3D;
class Drawable;
class GBuffer;
class GlobalIllumination;
class GrassField;
class Material;
class Mesh;
class Outline;
class Quad;
class RenderControl;
class ScreenSpaceReflection;
class Shader;
class Texture;
class Volumetric;
class Water;
class Waterfall;
struct ClusteredLightingUpload;
struct Lighting2DUBO;
struct Lighting3DPack;
struct ShadowUpload;
struct TextureCreateInfo;
struct TextureSampler;
 
class Graphics : public Module,
                 public Canvas,
                 public IWindowSurfaceHost,
                 public IGraphics2D,
                 public IGraphics3D,
                 public IResourceFactory,
                 public IPostFX {
public:
    Module_REG(Graphics);
    Graphics();
    ~Graphics() override;
 
    virtual void reset();
 
    virtual void clearScreen();
    virtual void setBackgroundColorRGBA(float r, float g, float b, float a = 1.f);
    virtual void drawSolidRectRGBA(float x, float y, float w, float h, float r, float g, float b, float a = 1.f);
    virtual void drawTexturedRectRGBA(Texture *texture, float x, float y, float w, float h, float r, float g, float b,
                                      float a = 1.f);
    Texture *newTextureFromImageData(image::ImageData *data, bool repeatU = false,
                                     bool repeatV = false);
    Texture *newTextureFromImageData(image::ImageData *data, const TextureCreateInfo &info);
 
    Texture *newTextureWithSampler(image::ImageData *data, bool repeatU, bool repeatV,
                                   bool generateMipmaps, float maxAnisotropy,
                                   const std::string &filter, const std::string &mipmap,
                                   float lodBias = 0.f);
 
    virtual void setTextureSamplerParams(Texture *texture, const std::string &filter, const std::string &mipmap,
                                         float maxAnisotropy, float lodBias);
 
    virtual void present() = 0;
 
    virtual std::string getBackendName() const = 0;
 
    virtual bool supportsGBufferPost() const { return true; }
 
    virtual void initWithWindow(void *nativeWindow) = 0;
 
    virtual void setViewportSize(int width, int height, int pixelwidth, int pixelheight) = 0;
 
    int getWidth() const { return width; }
    int getHeight() const { return height; }
    int getPixelWidth() const { return pixelWidth; }
    int getPixelHeight() const { return pixelHeight; }
 
    double getCurrentDPIScale() const {
        return (width > 0) ? double(pixelWidth) / double(width) : 1.0;
    }
    double getScreenDPIScale() const { return getCurrentDPIScale(); }
 
    virtual void drawSolidRect(float x, float y, float w, float h, const Color &color,
                               BlendMode blend = BlendMode::Alpha) = 0;
 
    virtual void drawSolidRectRotated(float cx, float cy, float w, float h, float degrees,
                                      const Color &color,
                                      BlendMode blend = BlendMode::Alpha) = 0;
 
    virtual Texture *newTexture(int width, int height, const uint8_t *rgba, bool repeatU = false,
                                bool repeatV = false) = 0;
 
    virtual Texture *newTexture(int width, int height, const uint8_t *rgba,
                                const TextureCreateInfo &info) = 0;
 
    virtual Texture *newCubemap(int faceSize, const uint8_t *rgbaFaces) = 0;
 
    virtual Texture *newCubemap(int faceSize, const uint8_t *rgbaFaces,
                                const TextureCreateInfo &info) = 0;
 
    virtual Texture *newTexture(image::ImageData *data) = 0;
 
    virtual Texture *newTexture(image::ImageData *data, const TextureCreateInfo &info) = 0;
 
    virtual void setTextureSampler(Texture *texture, const TextureSampler &sampler) = 0;
 
    virtual float getMaxAnisotropy() const = 0;
 
    virtual Texture *newTextureFromFile(const std::string &filename) = 0;
    Texture *newTextureFromFileRepeated(const std::string &filename, bool repeatU, bool repeatV);
 
    virtual bool reloadTextureFromFile(const std::string &filename) = 0;
 
    virtual bool releaseTexture(Texture *texture) {
        (void)texture;
        return false;
    }
 
    virtual void drawTexturedRect(Texture *texture, float x, float y, float w, float h,
                                  const Color &color) = 0;
 
    virtual void drawTexturedRectShader(Texture *texture, Shader *shader, float x, float y, float w,
                                        float h, const Color &color) = 0;
 
    virtual void drawTexturedRectUV(Texture *texture, float x, float y, float w, float h, float u0,
                                    float v0, float u1, float v1, const Color &color) = 0;
 
    virtual void drawTexturedRectShaderUV(Texture *texture, Shader *shader, float x, float y,
                                          float w, float h, float u0, float v0, float u1, float v1,
                                          const Color &color, bool rotatedUV = false,
                                          BlendMode blend = BlendMode::Alpha) = 0;
 
    virtual void drawTexturedRectShaderUVRotated(Texture *texture, Shader *shader, float cx,
                                                 float cy, float w, float h, float degrees,
                                                 float u0, float v0, float u1, float v1,
                                                 const Color &color, bool rotatedUV = false,
                                                 BlendMode blend = BlendMode::Alpha) = 0;
 
    virtual void drawTexturedRectShaderDepth(Texture *color, Texture *depth, Shader *shader,
                                             float x, float y, float w, float h,
                                             const Color &tint) = 0;
 
    virtual void drawTexturedRectLitUV(Texture *albedo, Texture *normal, float x, float y, float w,
                                       float h, float u0, float v0, float u1, float v1,
                                       const Color &color) = 0;
 
    virtual void setLighting2D(const Lighting2DUBO &ubo) = 0;
 
    Quad *newQuad(int x, int y, int w, int h);
 
    virtual Mesh *newMeshFromAssimp(const ::aiMesh &mesh) = 0;
 
    virtual Mesh *newMeshFromAssimp(const ::aiMesh &mesh, const aiMatrix4x4 &worldTransform) = 0;
 
    virtual Mesh *newMeshFromArrays(const float *posXYZ, const float *nrmXYZ, const float *uvST,
                                    int vertexCount, const uint32_t *indices, int indexCount) = 0;
 
    virtual bool updateMeshVertices(Mesh *mesh, const float *posXYZ, const float *nrmXYZ,
                                    const float *uvST, int vertexCount, const uint32_t *indices,
                                    int indexCount) = 0;
 
    virtual bool bakeMeshMorph(Mesh *mesh) = 0;
 
    virtual Mesh *newMeshSphere(int slices = 32, int stacks = 16) = 0;
 
    virtual Mesh *newMeshCylinder(int slices = 32, int stacks = 1, bool caps = true) = 0;
 
    Mesh *newMeshCube(float size = 1.f);
 
    virtual bool releaseMesh(Mesh *mesh) {
        (void)mesh;
        return false;
    }
 
    virtual void render3D();
    virtual void renderScene3DToCanvas(Canvas *canvas, Camera3D *camera);
    virtual void setDirectionalLight(float dx, float dy, float dz, float r = 1.f, float g = 1.f, float b = 1.f);
 
    virtual void drawScene3DRGBA(float x, float y, float w, float h, float r = 1.f, float g = 1.f, float b = 1.f,
                                 float a = 1.f);
    void drawScene3D(float x, float y, float w, float h) {
        drawScene3DRGBA(x, y, w, h, 1.f, 1.f, 1.f, 1.f);
    }
 
    virtual void drawCanvasRGBA(Canvas *canvas, float x, float y, float w, float h, float r = 1.f, float g = 1.f,
                                float b = 1.f, float a = 1.f);
    void drawCanvas(Canvas *canvas, float x, float y, float w, float h) {
        drawCanvasRGBA(canvas, x, y, w, h, 1.f, 1.f, 1.f, 1.f);
    }
 
    virtual void pushValidationScope() = 0;
    virtual void popValidationScope() = 0;
 
    Material *newMaterial();
 
    RenderControl *getRenderControl();
 
    virtual void beginGBufferPass(int width, int height) = 0;
    virtual void drawMeshGBuffer(Mesh *mesh, const glm::mat4 &mvp, const glm::mat4 &model,
                                 float nearZ, float farZ, Texture *albedo = nullptr,
                                 float tintR = 1.f, float tintG = 1.f, float tintB = 1.f) = 0;
    virtual void drawMeshGBufferAlpha(Mesh *mesh, const glm::mat4 &mvp, const glm::mat4 &model,
                                      float nearZ, float farZ, Texture *albedo = nullptr,
                                      float tintR = 1.f, float tintG = 1.f,
                                      float tintB = 1.f) = 0;
    virtual void endGBufferPass() = 0;
 
    virtual void begin3DFrame() = 0;
 
    virtual void begin3DFrameToCanvas(Canvas *canvas) = 0;
    virtual void end3DFrameToCanvas() = 0;
 
    virtual void setMesh3DViewProj(const glm::mat4 &viewProj) = 0;
 
    virtual void setMesh3DView(const glm::mat4 &view) = 0;
 
    virtual void setMesh3DClip(float nearZ, float farZ) = 0;
 
    virtual Texture *getSceneColorTexture() { return nullptr; }
 
    struct EntityIdDraw {
        Mesh *mesh = nullptr;
        glm::mat4 model{1.f};
        glm::vec4 idColor{0.f, 0.f, 0.f, 1.f};
    };
    virtual image::ImageData *renderEntityIdMask(const std::vector<EntityIdDraw> &draws,
                                                 const glm::mat4 &viewProj, int width, int height) {
        (void)draws;
        (void)viewProj;
        (void)width;
        (void)height;
        return nullptr;
    }
 
    virtual image::ImageData *readGBufferToImageData(const std::string &name) {
        (void)name;
        return nullptr;
    }
 
    virtual void drawMesh(Mesh *mesh, const glm::mat4 &model, Texture *texture, const Color &tint) = 0;
 
    virtual void drawMeshShader(Mesh *mesh, const glm::mat4 &model, Texture *texture, const Color &tint,
                                Shader *shader) = 0;
 
    virtual void setMesh3DNormalTexture(Texture *normal) = 0;
 
    virtual void setMesh3DHeightTexture(Texture *height) = 0;
 
    virtual void setMesh3DSceneDepth(Texture *depth) = 0;
 
    virtual void setMesh3DMaterial(float metallic, float roughness) = 0;
 
    virtual void setMesh3DTexCellBomb(float cellScale, float strength, float rotAmount = 1.f) = 0;
 
    virtual void setMesh3DParallax(float scale, float minLayers = 8.f, float maxLayers = 32.f) = 0;
 
    virtual void setMesh3DLighting(const Lighting3DPack &pack) = 0;
 
    virtual void setCloudShadows(float strength, float worldCell, float time, float windSpeed,
                                 float windAngle, float coverage, float detail) = 0;
 
    virtual void setMesh3DClusteredLighting(const ClusteredLightingUpload &upload) = 0;
 
    virtual void setMesh3DClusteredActive(bool active) = 0;
 
    virtual void setMesh3DLight(const glm::vec3 &dir, const glm::vec3 &color) = 0;
 
    virtual void setMesh3DCameraPos(const glm::vec3 &eye) = 0;
 
    virtual void drawVoxelFaceInstances(const uint32_t *packed, int count, float originX,
                                        float originY, float originZ, const std::string &faceDir,
                                        Texture *atlas, int tilesPerRow = 16,
                                        const uint32_t *ao = nullptr) = 0;
 
    virtual void setMesh3DEnv(Texture *cube, float intensity) = 0;
 
    virtual void setMesh3DShadows(const ShadowUpload &upload) = 0;
 
    virtual void setMesh3DShadowReceive(bool receive) = 0;
 
    virtual void beginShadowPass(int cascadeIndex) = 0;
    virtual void drawMeshShadow(Mesh *mesh, const glm::mat4 &lightMVP) = 0;
    virtual void drawMeshShadowAlpha(Mesh *mesh, const glm::mat4 &lightMVP,
                                     Texture *albedo = nullptr) = 0;
    virtual void endShadowPass() = 0;
 
    bool consumeFrameHad3D() {
        bool v = frameHad3D;
        return v;
    }
    bool had3DThisFrame() const { return frameHad3D; }
 
    Color getBackgroundColor() const { return backgroundColor; }
    void setBackgroundColor(const Color &c) { backgroundColor = c; }
 
    virtual void setScreenReadbackEnabled(bool enabled) { screenReadbackEnabled = enabled; }
    bool isScreenReadbackEnabled() const { return screenReadbackEnabled; }
 
    bool saveFramePng(const std::string &path);
 
    virtual void setVSync(bool enabled) { vsyncEnabled = enabled; }
    bool isVSync() const { return vsyncEnabled; }
 
    virtual void setMsaaSamples(int samples) { msaaSamples = samples > 0 ? samples : 0; }
    virtual int getMsaaSamples() const { return msaaSamples; }
 
    void setActive(bool active) override {
        graphicsActive = active;
        if (active)
            markSwapchainDirty();
    }
    bool isActive() const { return graphicsActive; }
 
    virtual void markSwapchainDirty() {}
 
    void requestSurfaceRecreate() override {}
 
    virtual void onNativeWindowDestroyed() {
        for (auto &cb : windowDestroyedCallbacks_) cb.first(cb.second);
        windowDestroyedCallbacks_.clear();
        clearPresentOverlay();
    }
 
    void clearPresentOverlay() {
        presentOverlayFn_ = nullptr;
        presentOverlayUser_ = nullptr;
    }
 
    using WindowDestroyedCallback = void (*)(void *userdata);
    void addWindowDestroyedCallback(WindowDestroyedCallback cb, void *userdata) {
        windowDestroyedCallbacks_.emplace_back(cb, userdata);
    }
 
    using PresentOverlayFn = void (*)(void *userdata, void *commandBuffer);
    void setPresentOverlay(PresentOverlayFn fn, void *userdata) {
        presentOverlayFn_ = fn;
        presentOverlayUser_ = userdata;
    }
    PresentOverlayFn getPresentOverlay() const { return presentOverlayFn_; }
    void *getPresentOverlayUser() const { return presentOverlayUser_; }
 
    Font *newFont(font::FontData *data, std::string charset = Font::defaultCharset());
 
    virtual void setFont(Font *font) { currentFont = font; }
    Font *getFont() const { return currentFont; }
 
    virtual void print(const std::string &text, float x, float y, const Color &color = Color(1.f, 1.f, 1.f, 1.f),
                       float scale = 1.f);
 
    virtual void setShader(Shader *shader);
    virtual void setShader();
 
    Shader *getShader() const { return currentShader; }
 
    virtual Shader *newShaderFromSpv(const std::vector<uint32_t> &vertSpv,
                                    const std::vector<uint32_t> &fragSpv) = 0;
 
    virtual Shader *newShaderFromSpvFile(const std::string &vertPath, const std::string &fragPath) = 0;
    Shader *newShaderFromSpvFile(const std::string &fragPath) {
        return newShaderFromSpvFile(std::string(), fragPath);
    }
 
    virtual Shader *newShader(const std::string &vertGlsl, const std::string &fragGlsl) = 0;
    Shader *newShader(const std::string &fragGlsl) { return newShader(std::string(), fragGlsl); }
 
    virtual Shader *newMeshShaderFromSpv(const std::vector<uint32_t> &vertSpv,
                                         const std::vector<uint32_t> &fragSpv) = 0;
    virtual Shader *newMeshShaderFromWgsl(const std::string &vertWgsl,
                                          const std::string &fragWgsl) = 0;
    virtual Shader *newMeshShader(const std::string &vertGlsl, const std::string &fragGlsl) = 0;
    Shader *newMeshShader(const std::string &fragGlsl) {
        return newMeshShader(std::string(), fragGlsl);
    }
 
    virtual Shader *newHairShaderFromSpv(const std::vector<uint32_t> &vertSpv,
                                         const std::vector<uint32_t> &fragSpv) = 0;
    Shader *newHairShader();
 
    virtual bool releaseShader(Shader *shader) {
        (void)shader;
        return false;
    }
 
    Shader *newGrassShader();
 
    GrassField *newGrassField();
 
    Waterfall *newWaterfall();
 
    Water *newWater();
 
    virtual Canvas *newCanvas(int width, int height) = 0;
 
    virtual void setCanvas(Canvas *canvas) = 0;
    void setCanvas() { setCanvas(nullptr); }
 
    virtual bool isCanvasActive() const = 0;
    virtual Canvas *getCanvas() const = 0;
 
    Volumetric *newVolumetric();
 
    AmbientOcclusion *newAmbientOcclusion();
 
    Outline *newOutline();
 
    GlobalIllumination *newGlobalIllumination();
 
    ScreenSpaceReflection *newScreenSpaceReflection();
 
    AmbientOcclusion *pipelineAmbientOcclusion();
    GlobalIllumination *pipelineGlobalIllumination();
    AntiAliasing *pipelineAntiAliasing();
    Outline *pipelineOutline();
 
    AntiAliasing *newAntiAliasing();
 
    virtual void draw(Drawable *drawable, const glm::mat4 &m);
 
    virtual void drawOcclusion(Drawable *drawable, const glm::mat4 &m);
    virtual void drawOcclusionSolid(float x, float y, float w, float h);
    virtual void drawOcclusionTexture(Texture *texture, float x, float y, float w, float h);
    // void draw(Texture *texture, Quad *quad, const glm::mat4 &m);
    // void drawLayer(Texture *texture, int layer, const glm::mat4 &m);
    // void drawLayer(Texture *texture, int layer, Quad *quad, const glm::mat4 &m);
    // void drawInstanced(Mesh *mesh, const glm::mat4 &m, int instancecount);
 
 
    void points(const std::vector<glm::vec2> &positions, const std::vector<Color> &colors);
 
    void polyline(const glm::mat4 *vertices, size_t count);
 
    void rectangle(std::string mode, float x, float y, float w, float h);
 
    void rectangle(std::string mode, float x, float y, float w, float h, float rx, float ry, int points);
    void rectangle(std::string mode, float x, float y, float w, float h, float rx, float ry);
 
    void circle(std::string mode, float x, float y, float radius, int points);
    void circle(std::string mode, float x, float y, float radius);
 
    void ellipse(std::string mode, float x, float y, float a, float b, int points);
    void ellipse(std::string mode, float x, float y, float a, float b);
 
    void arc(std::string mode, std::string arcmode, float x, float y, float radius, float angle1, float angle2,
             int points);
    void arc(std::string mode, std::string arcmode, float x, float y, float radius, float angle1, float angle2);
 
    void polygon(std::string mode, const std::vector<glm::vec2> &vertices, bool skipLastFilledVertex = true);
 
 
    void push(bool all);
    void pop();
 
    const glm::mat4 &getTransform() const;
    const glm::mat4 &getProjection() const;
 
    void rotate(float r);
    void scale(float x, float y = 1.0f);
    void translate(float x, float y);
    void origin();
 
    // void applyTransform(love::math::Transform *transform);
    // void replaceTransform(love::math::Transform *transform);
 
    glm::vec2 transformPoint(glm::vec2 point);
    glm::vec2 inverseTransformPoint(glm::vec2 point);
 
    // virtual void draw(const DrawCommand &cmd) = 0;
    // virtual void draw(const DrawIndexedCommand &cmd) = 0;
    // virtual void drawQuads(int start, int count, const vertex::Attributes &attributes, const vertex::BufferBindings &buffers, Texture *texture) = 0;
 
protected:
    int width = 0;
    int height = 0;
    int pixelWidth = 0;
    int pixelHeight = 0;
    Color backgroundColor{0.1f, 0.1f, 0.12f, 1.0f};
    bool frameHad3D = false;
    bool recordingEngine3D_ = false;
    bool screenReadbackEnabled = false;
    bool vsyncEnabled = true;
    bool graphicsActive = true;
    int msaaSamples = 4;
    PresentOverlayFn presentOverlayFn_ = nullptr;
    void *presentOverlayUser_ = nullptr;
    std::vector<std::pair<WindowDestroyedCallback, void *>> windowDestroyedCallbacks_;
    Shader *currentShader = nullptr;
    Font *currentFont = nullptr;
    std::unique_ptr<RenderControl> renderControl_;
    std::unique_ptr<AmbientOcclusion> pipelineAO_;
    std::unique_ptr<GlobalIllumination> pipelineGI_;
    std::unique_ptr<AntiAliasing> pipelineAA_;
    std::unique_ptr<Outline> pipelineOutline_;
 
    Shader *prepareSceneColorResolveShader(Texture *scene);
};
 
}  // namespace eve::graphics