ReWindow/main.cpp

#include <iostream>
#include <rewindow/types/window.h>
#include <rewindow/types/display.h>
#include <rewindow/logger/logger.h>

//aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa Windows :/
#if _WIN32
	#include <windows.h>
#endif

#include <GL/gl.h>

Vector2 mouse_pos;

// TODO: Move to J3ML::LinearAlgebra::Vector2
std::ostream& operator<<(std::ostream& os, const Vector2& v) {
	return os << "{" << v.x << ", " << v.y << "}";
}

class MyWindow : public ReWindow::RWindow {
    public:
    float r = 255;
    float b = 0;
    float g = g;
	public:
		MyWindow(const std::string& title, int w, int h) : ReWindow::RWindow(title, w, h) {}

	void OnMouseMove(const ReWindow::MouseMoveEvent& e) override {}

	void OnKeyDown(const ReWindow::KeyDownEvent& e) override {}

	void OnRefresh(float elapsed) override {
            if (r >= 1)
                r = 1;
            if (b >= 1)
                b = 1;
            if (g >= 1)
                g = 1;
            glClearColor(r, g, b, 255);
            glClear(GL_COLOR_BUFFER_BIT);
        GLSwapBuffers();
		auto pos = GetMouseCoordinates();
		//std::cout << pos.x << ", " << pos.y << std::endl;

        //if (IsMouseButtonDown(MouseButtons::MWheelUp))
            //std::cout << "WheelUp Mouse Button" << std::endl;

        //if (IsMouseButtonDown(MouseButtons::MWheelDown))
            //std::cout << "WheelDown Mouse Button" << std::endl;

        if (IsMouseButtonDown(MouseButtons::Left))
            std::cout << "Left Mouse Button" << std::endl;

        if (IsMouseButtonDown(MouseButtons::Right))
            std::cout << "Right Mouse Button" << std::endl;

        if (IsMouseButtonDown(MouseButtons::Middle))
            std::cout << "Middle Mouse Button" << std::endl;

        if (IsMouseButtonDown(MouseButtons::Mouse4))
            std::cout << "Mouse4 Mouse Button" << std::endl;

        if (IsMouseButtonDown(MouseButtons::Mouse5))
            std::cout << "Mouse5 Mouse Button" << std::endl;


        if (IsKeyDown(Keys::N)) {
            std::cout << "Gotteem" << std::endl;
        }
        RWindow::OnRefresh(elapsed);
	}

	bool OnResizeRequest(const ReWindow::WindowResizeRequestEvent& e) override {
		//std::cout << "resized to " << e.Size.x << ", " << e.Size.y << std::endl;
		return true;
	}

    void OnMouseButtonDown(const ReWindow::MouseButtonDownEvent &e) override
    {
            //std::cout << "Overload Down: " << e.Button.Mnemonic << std::endl;
            RWindow::OnMouseButtonDown(e);
    }

    void OnMouseButtonUp(const ReWindow::MouseButtonUpEvent &e) override
    {
            //std::cout << "Overload Up: " << e.Button.Mnemonic << std::endl;
            RWindow::OnMouseButtonUp(e);
    }
};

int main() {

    /*
    std::vector<ReWindow::Display> d = ReWindow::Display::getDisplaysFromWindowManager();
    for (ReWindow::Display& display : d) {

        auto w = display.getDefaultGraphicsMode().getWidth();
        auto h = display.getDefaultGraphicsMode().getHeight();
        auto r = display.getDefaultGraphicsMode().getRefreshRate();

        auto aspect = (float)w/(float)h;

        std::cout << "Default: ";
        std::cout << std::format("Mode ({},{}) @ {}hz Ratio {}", w, h, r, aspect) << std::endl;

        for (ReWindow::FullscreenGraphicsMode& fgm : display.getGraphicsModes()) {
            w =  fgm.GetWidth();
            h = fgm.GetHeight();
            r = fgm.getRefreshRate();

            auto aspect = (float)w/(float)h;

            std::cout << std::format("Mode ({},{}) @ {}hz Ratio {}", w, h, r, aspect) << std::endl;
        }
    }
    */

	MyWindow* window = new MyWindow("Test Window", 600, 480);
	jlog::Debug(std::format("New window '{}' created. width={} height={}", window->GetTitle(), window->GetWidth(),
                            window->GetHeight()));

    window->SetRenderer(ReWindow::RenderingAPI::OPENGL);
	jlog::Debug(std::format("Rendering API OPENGL set for window '{}'", window->GetTitle()));

	window->Open();
	jlog::Debug(std::format("Opened window '{}'", window->GetTitle()));

	// TODO: Cannot set flags until after window is open
	// Make this work somehow
	jlog::Debug("TODO: Cannot set flags until after window is open");
    window->SetFullscreen(false);
    window->SetVsyncEnabled(true);
    window->SetResizable(true);
    window->SetCursorVisible(false);



	ReWindow::Logger::Debug(std::format("Window '{}' flags: IN_FOCUS={} FULLSCREEN={} RESIZEABLE={} VSYNC={} QUIT={}",
                                        window->GetTitle(),
                                        window->GetFlag(RWindowFlags::IN_FOCUS),
                                        window->GetFlag(RWindowFlags::FULLSCREEN),
                                        window->GetFlag(RWindowFlags::RESIZABLE),
                                        window->GetFlag(RWindowFlags::VSYNC),
                                        window->GetFlag(RWindowFlags::QUIT)));


	window->OnKeyDownEvent += [&] (ReWindow::KeyDownEvent e) {
        jlog::Debug(e.key.Mnemonic);
	};


	window->OnMouseButtonDownEvent += [&] (ReWindow::MouseButtonDownEvent e) {
		jlog::Debug(e.Button.Mnemonic + std::to_string(e.Button.ButtonIndex));
	};

    window->OnMouseWheelEvent += [&, window] (ReWindow::MouseWheelEvent e)
    {
        std::cout << window->GetMouseWheelPersistent() << std::endl;
    };

    /*
	while (!window->IsClosing()) {
        //window->PollEvents();
        window->ManagedRefresh();
	}*/

    // Found problem
    // free(): double free detected in tcache 2
    // delete window;
    // Alternatively:
    /*
     * while (window->IsAlive()) {
     *      auto start = window->GetTimestamp();
     *      ourUpdateLogic(window->GetDeltaTime());
     *      window->update();
     *      ourDrawLogic();
     *      window->Refresh();
     *      auto end = window->GetTimestamp();
     *      auto dt = window->ComputeElapsedFrameTimeSeconds(start, end);
     *      window->UpdateFrameTiming(dt);
     * }
     *
     */

    //exit(0);

    MyWindow* windowdos = new MyWindow("Test Window Dos", 600, 480);

    windowdos->SetRenderer(ReWindow::RenderingAPI::OPENGL);

    windowdos->Open();

    window->r = 0;

    bool swap;
    while (!windowdos->IsClosing() && !window->IsClosing()) {
        window->r += 0.01;
        if (window->r >= 1 && !swap) {
            window->g += 0.01;
        }
        if (window->g >= 1 && !swap)
            window->b += 0.01;
        if (window->b >= 1) {
            window->r = 0.01;
            window->g = 0.01;
            window->b = 0.01;
        }



        window->ManagedRefresh();
        windowdos->ManagedRefresh();
        //sleep(10);
    }
    delete window;
    delete windowdos;
    return 0;
}

/*
//Windows :(
#ifdef _WIN32
#ifndef UNICODE
#define UNICODE
#endif

extern "C" {
	int wmain(int argc, wchar_t* argv[]) {
		return main();
	}
}
#endif
*/