paradiso/examples/simple/main.cpp

/**
 * paradiso - Paradigmen der Softwareentwicklung
 *
 * (c) Copyright 2023 Hartmut Seichter
 *
 */

#include <paradiso/bitmap.hpp>
#include <paradiso/context.hpp>
#include <paradiso/geometry.hpp>
#include <paradiso/renderer.hpp>
#include <paradiso/shader.hpp>
#include <paradiso/sprite.hpp>
#include <paradiso/window.hpp>

#include <iomanip>
#include <iostream>

void setup_shaders(paradiso::Shader& shader) {
    const auto unlit_v = R"(
#version 400 core

layout (location = 0) in vec3 vertices;
layout (location = 1) in vec3 normals;
layout (location = 2) in vec2 texture_coords;

// pivot der sprite
uniform vec2 pivot = vec2( 0.0, 0.0 );
// scale 
uniform vec2 scale = vec2( 1.0, 1.0 );
// rotation
uniform float rotation = 0.2;

// wir sind natuerlich in homogenenen 3D Koordinaten unterwegs
mat4 mm = mat4(
    vec4( scale.x, 0.0, 0.0, 0.0),
    vec4( 0.0, scale.y, 0.0, 0.0),
    vec4( 0.0, 0.0, 1.0, 0.0),
    vec4( pivot, 0.0, 1.0)
);

float sir = sin(rotation);
float cor = cos(rotation);

mat4 mr = mat4(
    vec4( cor, sir, 0.0, 0.0),
    vec4(-sir, cor, 0.0, 0.0),
    vec4( 0.0, 0.0, 1.0, 0.0),
    vec4( 0.0, 0.0, 0.0, 1.0)
    );

out vec2 tex_c; // das hier reicht die texturkoordinaten durch

void main() {
    tex_c = texture_coords; // umstaendlich aber notwendig
    gl_Position = mm * mr * vec4(vertices, 1.0); // unsere eigentliche shader position
}
)";

    const auto unlit_f = R"(
#version 400 core

uniform sampler2D tex_color; // hier ist unsere sprite textur (bitmap)

in vec2 tex_c; // da sind die texturkoordinaten wieder

out vec4 frag_color; // das hier wird der output (pixelwert/fragment)

void main() {
    frag_color = texture(tex_color,tex_c);
})";

    shader.set_source(paradiso::Shader::Type::Vertex, unlit_v);
    shader.set_source(paradiso::Shader::Type::Fragment, unlit_f);

    shader.build();
}

auto main() -> int {

    // Ausgabefenster ... sieht aus als wäre es auf dem Stack
    auto window = paradiso::Window();

    // wir bauen ein Fenster ...
    window
        .set_size(paradiso::Size{.width = 1280, .height = 720}) // ... Grösse
        .set_position(paradiso::Point{.x = 100, .y = 100})      // ... Position
        .set_title("PardiSO")                                   // ... Titel
        .set_visible(true); // ... und jetzt anzeigen!

    // der Fenster Kontext
    auto ctx = paradiso::Context{};

    // als Beispiel eine Sprite mit farbiger Textur
    auto sprite = paradiso::Sprite{
        .bitmap = paradiso::Bitmap::from_data(
            paradiso::Size{2, 2},
            paradiso::RGBA::from_rgba(0x00, 0xFF, 0x00, 0x80), // G
            paradiso::RGBA::from_rgba(0xFF, 0x00, 0x00, 0x80), // R
            paradiso::RGBA::from_rgba(0x00, 0x00, 0xFF, 0x80), // B
            paradiso::RGBA::from_rgba(0xFF, 0x00, 0xFF, 0x80)) // C
    };

    // das eigentliche 2D rendering sub-system
    auto renderer = paradiso::Renderer{};

    // ein Shader (Schattierungsprogramm)
    auto shader = paradiso::Shader{};

    // hier werden die Shader Programme geladen, kompiliert usw.
    setup_shaders(shader);

    // kein schönes Design: dies sind globale Variablen ...
    uint8_t slider_value = 0xFF;
    bool want_close{false};

    // eine sehr rudimentäre Eingabebehandlung. Bei vorhandenen
    // Eingaben landen diese hier. Wer sich am Design beteiligen
    // möchte: hier gibt es viel Potential zur Verbesserung ;)
    window.set_keyboardcallback(
        [&](auto& w, int key, int scancode, int action, int mods) {
            if (key == 'Q' || key == 256) // Q oder ESC beenden das Programm
                want_close = true;
            else if (key == 'B') { // kleine Spielerei
                slider_value += 10;
            } else if (key == 'W') {
                sprite.pivot.y() += 0.1f;
            } else if (key == 'S') {
                sprite.pivot.y() -= 0.1f;
            } else if (key == 'A') {
                sprite.pivot.x() -= 0.1f;
            } else if (key == 'D') {
                sprite.pivot.x() += 0.1f;
            } else if (key == 'P') {
                sprite.scale *= 0.9;
            } else if (key == 'R') {
                sprite.rotation += 0.1;
            }
        });

    // das update führt den hier mitgegebnen Ausdruck innerhalb der internen
    // Updates des Fensters auf. Es wird hier auch explizit ein bool gefordert
    // damit das update auch zu jederzeit unterbrochen werden kann
    while (window.update([&](auto& w) -> bool {
        // Context behandelt den sogenannten viewport - Hintergrund löschen,
        // grösse usw. werden hier behandelt

        ctx.set_clearcolor(
            paradiso::RGBA::from_rgb(slider_value, slider_value, slider_value));

        // ein viewport stellt die Sicht der Kamera dar, d.h. bei quadratischen
        // Pixeln sollte hier auch eine dementsprechende Grösse eingestellt
        // werden
        ctx.set_viewport(paradiso::Rectangle{
            .size =
                w.client_size().maximal_extent() // wir wollen das
                                                 // Seitenverhältnis beibehalten
        });

        // hier wird das eigentliche löschen des vorherigen Inhalts ausgelöst
        ctx.clear();

        // wir setzen die daten der sprite über den shader
        shader.set_uniform("pivot", sprite.pivot);
        shader.set_uniform("scale", sprite.scale);
        shader.set_uniform("rotation", sprite.rotation);

        // Ein `renderer` kann nur mit einer Sprite verwendet werden!
        // Aber ein Shader kann man für mehrere Sprite-Renderer Kombis verwenden
        renderer.draw(sprite, shader);

        // ... signalisiere ob wir weitermachen wollen ...
        return !want_close;
    })) {
    };

    return 0;
}