GFXWindow.cpp

#include "GFXWindow.h"
#define _USE_MATH_DEFINES
#include <cmath>
#include <iostream>
#include <fcntl.h>

int GFX::Window::RUN(){
    if (debugFlag && AllocConsole()) {
        int ifd = _open_osfhandle((intptr_t)GetStdHandle(STD_INPUT_HANDLE), _O_TEXT);
        int ofd = _open_osfhandle((intptr_t)GetStdHandle(STD_OUTPUT_HANDLE), _O_TEXT);

        *stdin = *_fdopen(ifd, "r");
        *stdout = *_fdopen(ofd, "w");
        
    }
    MSG msg = {0};
    POINT p = {0, 0};
    bool reset = false;
    //Vec2d p(Width/2+100, Height/2-40);
    std::vector<GFX::Math::Vec2d> trgPoints(3);
    //{(243, 46), (362, 185), (148, 372)} {0, 0}, {150, 100}, {30, 80}
    //(23, 177), (360, 216), (244, 356) , (22, 195), (361, 200), (259, 351)
    GFX::Math::Triangle2d trg({243, 46}, {362, 185}, {148, 372});
    double phi = 0;
    GFX::Math::Vec2d cntrCircle = {Width/2.0f-10, Height/2.0f+10};
    GFX::Math::Vec2d point = trg.GetTriangleCentre();
    int counter = 0;
    while (true){
        if (PeekMessage(&msg, nullptr, 0, 0, PM_REMOVE)){
            DispatchMessage(&msg);

            if (msg.message == WM_QUIT) {
                break;
            }
        }
        SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), {0, 0});
        //printf("Points %d: ", counter); PrintVector(trgPoints);
        if (GetAsyncKeyState('R')) reset = true;
        if (GetAsyncKeyState(RI_MOUSE_BUTTON_1_UP) && reset){
            GetCursorPos(&p);
            ScreenToClient(WindowHandle, &p);
            if (counter == 0){
                trgPoints[0] = GFX::Math::Vec2d(p.x, p.y);
                counter++;
            } else{
                if (trgPoints[counter-1] != GFX::Math::Vec2d(p.x, p.y)){
                    trgPoints[counter] = GFX::Math::Vec2d(p.x, p.y);
                    counter++;
                    //printf("%d %d %d\n", p.x, p.y, counter);
                }
                if (counter > 2) {
                    counter = 0;
                    trg = GFX::Math::Triangle2d(trgPoints);
                    
                    reset = false;
                    printf("Done\n");
                }
                
            }
            
        }
        phi += 0.01 ;
        if (abs(phi) > 2*M_PI) phi = 0;
        //trg.RotateTriangle(0, 0, M_PI/6);
        //SCR->SetPixel(p.x, p.y, {255, 0, 0});
        
        SCR->FillColor({0, 0, 0});
        printf("Triangle: "); PrintTriangle2d(GFX::Math::RotateTriangle2d(trg, point, phi));
        printf("%f\n", phi);

        if (!reset){
            point = trg.GetTriangleCentre();
            SCR->PlotTriangle2d(GFX::Math::RotateTriangle2d(trg, point, phi), {255, 255, 0});
        }
        
        //Vec2d cntrCircle = RotatePoint(Vec2d(Width/2, Height/2), cntrCircle, phi);

        //SCR->PlotCircle(cntrCircle.x, cntrCircle.y, 50, true, {255, 255, 0});


        TransferBufferToWindow();
        Sleep(10);
    }
    fclose(stdout);
    fclose(stdin);
    return 0;
}

GFX::Window::Window(int x, int y, int W, int H, std::wstring Title,
        std::wstring ClassName, HINSTANCE hInstance, DWORD Style) : Width(W), Height(H)
{
    SCR = new GFX::Screen(W, H);
    WindowClass = {0};
    WindowClass.hCursor = LoadCursor(NULL, IDC_ARROW);
    WindowClass.hIcon = LoadIcon(NULL, IDI_QUESTION);
    WindowClass.hInstance = hInstance;
    WindowClass.lpszClassName = ClassName.c_str();
    WindowClass.hbrBackground = (HBRUSH)COLOR_WINDOW;
    WindowClass.lpfnWndProc = WinProcedure;
    
    if (RegisterClass(&WindowClass)){
        WindowHandle = CreateWindowW(ClassName.c_str(), Title.c_str(), Style, x, y, W, H, NULL, NULL, NULL, NULL);
    }
    GFX::currentWindow = this;
}


GFX::Window* GFX::Window::ReceiveWindow(){
    return currentWindow;
}

GFX::Window::~Window(){
    delete SCR;
}

void GFX::Window::Resize(int W, int H){
    Width = W, Height = H;
    SCR->Resize(W, H);
}

void GFX::Window::TransferBufferToWindow(){
    HBITMAP hBitMap = CreateBitmap(Width, Height, 1, 8 * 4, SCR->GetFrameBuffer());
    HDC hdc = GetDC(WindowHandle);
    HDC hdcSrc = CreateCompatibleDC(hdc);
    SelectObject(hdcSrc, hBitMap);
    BitBlt(hdc, 0, 0, Width, Height, hdcSrc, 0, 0, SRCCOPY);
    DeleteObject(hBitMap);
    DeleteDC(hdcSrc);
    DeleteDC(hdc);
}


LRESULT CALLBACK GFX::Window::WinProcedure(HWND hWnd, UINT msg, WPARAM wp, LPARAM lp){
    switch (msg) {
    case WM_CREATE:
        break;
    /*case WM_SIZE:{
        int newW = LOWORD(lp), newH = HIWORD(lp);
        if (currentWindow != nullptr && 
                (currentWindow->Width < newW || currentWindow->Height < newH))
            currentWindow->Resize(newW, newH);
    } break;*/
    case WM_DESTROY:
        PostQuitMessage(0);
        break;
    }
    return DefWindowProc(hWnd, msg, wp, lp);
}