JGL/main.cpp

#include <glad/glad.h>
#include <JGL/JGL.h>
#include <rewindow/types/window.h>
#include <JGL/Colors.h>
#include <J3ML/LinearAlgebra/Vector2.h>

using J3ML::LinearAlgebra::Vector2;
using namespace JGL;

//The Re3D style base projection.
std::vector<GLfloat> perspective(float fov, float aspect, float nearPlane, float farPlane) {
    std::vector<float> result(16);
    float f = 1.0f / tan(fov * 0.5f * M_PI / 180.0f);
    result[0] = f / aspect;
    result[5] = f;
    result[10] = (farPlane + nearPlane) / (nearPlane - farPlane);
    result[11] = -1.0f;
    result[14] = (2.0f * farPlane * nearPlane) / (nearPlane - farPlane);
    return result;
}

class Camera {
public:
    Vector3 position = {0,0,0};
    Vector3 angle = {0,0,0};

    std::vector<GLfloat> lookAt(const Vector3& eye, const Vector3& center, const Vector3& up) {
        Vector3 f = Vector3::Normalized((center - eye));
        Vector3 upN = Vector3::Normalized(up);
        Vector3 s = Vector3::Normalized(f.Cross(upN));
        Vector3 u = Vector3::Normalized(s.Cross(f));

        std::vector<GLfloat> result = {
                s.x,         u.x,         -f.x,        0.0f,
                s.y,         u.y,         -f.y,        0.0f,
                s.z,         u.z,         -f.z,        0.0f,
                -s.Dot(eye), -u.Dot(eye),  f.Dot(eye), 1.0f
        };
        return result;
    }

    void render() {
        glRotatef(angle.x,1.0f, 0.0f, 0.0f);
        glRotatef(angle.y,0.0f, 1.0f, 0.0f);
        glRotatef(angle.z,0.0f, 0.0f, 1.0f);
        glMultMatrixf(lookAt({position.x, position.y, position.z}, {position.x, position.y, 100.f + position.z}, {0,1,0}).data());
    }
};

Camera* camera;
using J3ML::LinearAlgebra::Matrix4x4;

struct point {
    GLfloat x;
    GLfloat y;
    GLfloat s;
    GLfloat t;
};

int FreeSans;
int Jupiteroid;

class JGLDemoWindow : public ReWindow::RWindow
{
public:
    void initGL() {
        camera = new Camera;
        auto window_size = getSize();
        auto aspect = (float) window_size[0] / (float) window_size[1];

        gladLoadGL();
        JGL::Update(getSize());
        FreeSans = JGL::LoadFont("assets/fonts/FreeSans.ttf");
        Jupiteroid = JGL::LoadFont("assets/fonts/Jupiteroid.ttf");

        glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        glMultMatrixf(perspective(75, aspect, 0.001, 100).data());
        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();
        glClearColor(0.f, 0.f, 0.f, 0.f);
        glViewport(0,0,window_size.x,window_size.y);
        glEnable(GL_DEPTH_TEST);
        glDepthFunc(GL_LESS);
        glDepthMask(GL_TRUE);
    }

    Vector3 textAngle = {0,0,0};
    void display() {
        textAngle.y += 2.0f;
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();

        camera->render();

        ///All 3D elements of the scene and JGL elements *must* be rendered before the 2d stuff.

        J3D::Begin();
            J3D::DrawLine(JGL::Colors::Red, {-0.33,-0.125,1}, {-1,-0.125,1});
            J3D::DrawLine(JGL::Colors::Red, {-0.33,-0.125,1}, {-0.33,0.25,1});
            J3D::DrawString(JGL::Colors::Red, "JGL Sample Text", {-0.33, -0.1, 1.0f},textAngle,  1.f, 32, FreeSans);
        J3D::End();


        J2D::Begin();
            J2D::FillRect(Colors::Blue, {0,52}, {100,100});
            J2D::FillRect(Color4::FromColor3(Colors::Pinks::HotPink), {68, 120}, {32, 32});
            J2D::FillGradientRect(Colors::Red, Colors::Blue, Gradient::DiagonalBottomLeft, {100,52}, {100,100});
            J2D::FillRoundedRect(JGL::Colors::Red, {200, 52}, {100, 100}, 8, 8);
            J2D::FillRoundedRect(JGL::Colors::Purples::BlueViolet, {300, 52}, {100, 100}, 8, 4);

            J2D::FillCircle(JGL::Colors::White, {52, 204}, 50, 24);
            J2D::OutlineCircle(JGL::Colors::White, {153, 204}, 50, 24);

            J2D::FillTriangle(Colors::Red, {{0, 275}, {0, 375}, {100, 375}});
            J2D::OutlineTriangle(Colors::Blue, {{100, 275}, {0, 275}, {100, 375}});
            J2D::DrawGradientLine(JGL::Colors::Red, JGL::Colors::Blue, {105, 375}, {200, 275}, 2);

            J2D::DrawString(JGL::Colors::Green, "Jupteroid Font", 0.f, 16, 1.f, 16, Jupiteroid);
            J2D::DrawString(JGL::Colors::White, "Position: " + std::to_string(camera->position.x) + " " + std::to_string(camera->position.y) + " " + std::to_string(camera->position.z), 0, 33, 1,16, Jupiteroid);
            J2D::DrawString(JGL::Colors::White, "ViewAngle: " + std::to_string(camera->angle.x) + " " + std::to_string(camera->angle.y) + " " + std::to_string(camera->angle.z), 0, 50, 1,16, Jupiteroid);
        J2D::End();
    }

    void OnRefresh(float elapsed) override {
        display();
        int glError = glGetError();
        if (glError != GL_NO_ERROR)
            std::cout << glError << std::endl;
        glSwapBuffers();
    }

    bool OnResizeRequest(const ReWindow::WindowResizeRequestEvent& e) override {return true;}
    JGLDemoWindow() : ReWindow::RWindow() {}
    JGLDemoWindow(const std::string& title, int width, int height) : ReWindow::RWindow(title, width, height){}
};

int main(int argc, char** argv) {
    auto* window = new JGLDemoWindow("JGL Demo Window", 1280, 720);
    window->setRenderer(RenderingAPI::OPENGL);
    window->Open();
    window->initGL();
    window->setResizable(false);

    while (window->isAlive()) {
        window->pollEvents();
        window->refresh();
    }
    return 0;
}