RenderSystem.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/ECS.h"
#include "graphics/DrawItem2D.h"
#include "graphics/Quad.h"
#include "graphics/Shader.h"
#include "graphics/Texture.h"
#include "zeroerr/assert.h"
#include <cstdint>
#include <string>
#include <vector>
 
namespace eve::graphics {
 
class Canvas;
 
class EVENGINE_API_BACKENDS Camera2D : public ecs::Entity {
public:
    ENTITY(Camera2D, ecs::Entity)
 
    
    void release() override {}
 
    struct Data {
        float x = 0.f;
        float y = 0.f;
        float zoom = 1.f;
        float r = 0.1f, g = 0.1f, b = 0.12f, a = 1.f;
        float ambientR = 0.15f, ambientG = 0.15f, ambientB = 0.18f;
        bool active = false; // true only after createCamera() / explicit enable
        Canvas *canvas = nullptr;
        Camera2D *entity = nullptr;  // self; set by createCamera()
    };
 
    COMPONENT(Data, data)
 
    static Camera2D *createCamera() {
        Camera2D *c = Camera2D::create();
        ASSERT(c != nullptr);
        c->data()->entity = c;
        c->data()->active = true;
        ASSERT(c->data()->entity == c);
        return c;
    }
 
    void setAmbient(float r, float g, float b);
 
    void  setPosition(float x, float y);
    float getX();
    float getY();
    void  setZoom(float zoom);
    float getZoom();
 
    float screenToWorldX(float screenX, float screenY, float viewW, float viewH);
    float screenToWorldY(float screenX, float screenY, float viewW, float viewH);
    float worldToScreenX(float worldX, float worldY, float viewW, float viewH);
    float worldToScreenY(float worldX, float worldY, float viewW, float viewH);
};
 
class EVENGINE_API_BACKENDS Renderable2D : public ecs::Entity {
public:
    ENTITY(Renderable2D, ecs::Entity)
 
    
    void release() override;
 
    struct Transform2D {
        float x = 0;
        float y = 0;
        float rot = 0;
        float sx = 1;
        float sy = 1;
    };
 
    struct Sprite {
        float width = 32;
        float height = 32;
        float r = 1, g = 1, b = 1, a = 1;
        int layer = 0;
        bool visible = true;
        Texture *texture = nullptr;
        Texture *normalTexture = nullptr;  // non-null → GPU lit2d path
        Quad *quad = nullptr;              // nullptr → full UV 0..1
        Shader *shader = nullptr;          // nullptr → default textured / solid pipeline
        Canvas *canvas = nullptr;          // nullptr → screen
        Camera2D *camera = nullptr;        // nullptr → default active camera for canvas
        bool receiveLight = true;          // false → force unlit (ignore lights)
        bool castOcclusion = true;         // volumetric occlusion map (shadow analogue)
        BlendMode blend = BlendMode::Alpha;
        float anchorX = 0.5f, anchorY = 0.5f;
        bool flipX = false, flipY = false;
        int trimW = 0, trimH = 0, offsetX = 0, offsetY = 0;
    };
 
    COMPONENT(Transform2D, transform)
    COMPONENT(Sprite, sprite)
 
    
    void setPosition(float x, float y);
    float getX();
    float getY();
    void setRotation(float degrees);
    float getRotation();
    void setScale(float sx, float sy);
    float getScaleX();
    float getScaleY();
    void setSize(float width, float height);
    float getWidth();
    float getHeight();
    void setTexture(Texture *texture);
    Texture *getTexture();
    void setNormalTexture(Texture *texture);
    Texture *getNormalTexture();
    void setQuad(Quad *quad);
    Quad *getQuad();
    void setColor(float r, float g, float b, float a = 1.f);
    void setLayer(int layer);
    int getLayer();
    void setVisible(bool visible);
    bool getVisible();
    void setReceiveLight(bool receive);
    bool getReceiveLight();
    void setBlend(const std::string &blend);
    std::string getBlend();
    void setAnchor(float x, float y);
    float getAnchorX();
    float getAnchorY();
    void setFlip(bool horizontal, bool vertical);
    bool getFlipX();
    bool getFlipY();
    void setFrameLayout(int sourceW, int sourceH, int trimW, int trimH, int offsetX, int offsetY);
    void setCastOcclusion(bool cast);
    bool getCastOcclusion();
};
 
class Graphics;
 
class EVENGINE_API_BACKENDS RenderSystem {
public:
    static void render(Graphics &gfx);
 
    static void collectSprites(std::vector<DrawItem2D> &out);
 
    static void drawItems(Graphics &gfx, std::vector<DrawItem2D> &items, bool present);
};
 
}  // namespace eve::graphics