pigine/rendering/Renderer.cpp

#include "rendering/Renderer.h"
#include "rendering/GL.h"

Renderer::Renderer(Shader& shader)
    : shader(shader), texture(true), color(true) {
}

void Renderer::init() {
    shader.use();
    GL::enableBlending();
    setTextureMode(false);
    setColorMode(false);

    fontRenderer.init();
    colorRenderer.init();
}

void Renderer::pop() {
    stack.pop();
}

void Renderer::push() {
    stack.push();
}

void Renderer::update() {
    shader.setMatrix("model", stack.peek().getValues());
}

Renderer& Renderer::scale(float sx, float sy) {
    stack.peek().scale(Vector3(sx, sy, 1.0f));
    return *this;
}

Renderer& Renderer::scale(float s) {
    stack.peek().scale(s);
    return *this;
}

Renderer& Renderer::translate(const Vector2& v) {
    stack.peek().translateX(v[0]).translateY(v[1]);
    return *this;
}

Renderer& Renderer::translateX(float tx) {
    stack.peek().translateX(tx);
    return *this;
}

Renderer& Renderer::translateY(float ty) {
    stack.peek().translateY(ty);
    return *this;
}

Renderer& Renderer::translateTo(float tx, float ty) {
    stack.peek().translateTo(Vector3(tx, ty, 0.0f));
    return *this;
}

Renderer& Renderer::rotate(float degrees) {
    stack.peek().rotateZ(degrees);
    return *this;
}

void Renderer::setTextureMode(bool b) {
    if(b != texture) {
        texture = b;
        shader.setInt("useTexture", b);
    }
}

void Renderer::setColorMode(bool b) {
    if(b != color) {
        color = b;
        shader.setInt("useColor", b);
    }
}

void Renderer::setStringSize(int size) {
    fontRenderer.setSize(size);
}

float Renderer::drawString(float x, float y, const char* text) {
    setTextureMode(true);
    setColorMode(true);
    return fontRenderer.drawString(x, y, text);
}

void Renderer::drawTriangle(const ColorRenderer::Vertex& v1,
                            const ColorRenderer::Vertex& v2,
                            const ColorRenderer::Vertex& v3) {
    setTextureMode(false);
    setColorMode(true);
    colorRenderer.draw(v1, v2, v3);
}

void Renderer::drawTriangle(const Vector2& v1, const Vector2& v2,
                            const Vector2& v3, Color4 color) {
    drawTriangle({v1, color}, {v2, color}, {v3, color});
}

void Renderer::drawRectangle(const Vector2& pos, const Vector2& size,
                             Color4 color) {
    drawTriangle({pos[0], pos[1]}, {pos[0] + size[0], pos[1]},
                 {pos[0], pos[1] + size[1]}, color);
    drawTriangle({pos[0] + size[0], pos[1]}, {pos[0], pos[1] + size[1]},
                 {pos[0] + size[0], pos[1] + size[1]}, color);
}