How to port this code to eepp?

[Curculigo]

GdiPlus version:

#include <windows.h>
#include <gdiplus.h>
#include <cmath>
#include <vector>

using namespace Gdiplus;

static const char kClassName[] = "SineWaveWindowClass";

struct AppState {
    int width = 800;
    int height = 600;
    GdiplusStartupInput gdiplusStartupInput;
    ULONG_PTR gdiplusToken;
};

void DrawSineWave(HDC hdc, int width, int height) {
    if (width <= 0 || height <= 0) return;

    Graphics graphics(hdc);
    graphics.SetSmoothingMode(SmoothingModeAntiAlias);

    // Background
    SolidBrush bgBrush(Color(255, 255, 255, 255));
    graphics.FillRectangle(&bgBrush, 0, 0, width, height);

    // Axis
    Pen axisPen(Color(200, 200, 200), 1.0f);
    graphics.DrawLine(&axisPen, 0, height / 2, width, height / 2);

    // Sine wave parameters
    double amplitude = (height - 20) / 2.0;
    double midY = height / 2.0;
    double period = width;
    double twoPi = 6.283185307179586;

    // Build points
    std::vector<PointF> pts;
    double step = 0.25; // smaller step for smoother curve
    for (double x = 0; x < width; x += step) {
        double t = x / period;
        double y = midY - amplitude * std::sin(twoPi * t);
        pts.push_back(PointF(static_cast<REAL>(x), static_cast<REAL>(y)));
    }

    // Draw sine wave
    Pen sinePen(Color(0, 120, 215), 2.0f);
    if (!pts.empty()) {
        graphics.DrawLines(&sinePen, pts.data(), static_cast<INT>(pts.size()));
    }
}

LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) {
    static AppState* state = nullptr;

    switch (msg) {
    case WM_CREATE: {
        state = new AppState();
        RECT rc;
        GetClientRect(hwnd, &rc);
        state->width = rc.right - rc.left;
        state->height = rc.bottom - rc.top;
        GdiplusStartup(&state->gdiplusToken, &state->gdiplusStartupInput, nullptr);
        return 0;
    }
    case WM_SIZE: {
        if (state) {
            state->width = LOWORD(lParam);
            state->height = HIWORD(lParam);
            InvalidateRect(hwnd, nullptr, TRUE);
        }
        return 0;
    }
    case WM_PAINT: {
        PAINTSTRUCT ps;
        HDC hdc = BeginPaint(hwnd, &ps);
        if (state) {
            DrawSineWave(hdc, state->width, state->height);
        }
        EndPaint(hwnd, &ps);
        return 0;
    }
    case WM_ERASEBKGND:
        return 1; // prevent flicker
    case WM_DESTROY:
        if (state) {
            GdiplusShutdown(state->gdiplusToken);
            delete state;
            state = nullptr;
        }
        PostQuitMessage(0);
        return 0;
    default:
        return DefWindowProc(hwnd, msg, wParam, lParam);
    }
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE, LPSTR, int nCmdShow) {
    WNDCLASSEX wc = {};
    wc.cbSize = sizeof(WNDCLASSEX);
    wc.style = CS_HREDRAW | CS_VREDRAW;
    wc.lpfnWndProc = WndProc;
    wc.hInstance = hInstance;
    wc.hIcon = LoadIcon(nullptr, IDI_APPLICATION);
    wc.hCursor = LoadCursor(nullptr, IDC_ARROW);
    wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
    wc.lpszClassName = kClassName;
    wc.hIconSm = LoadIcon(nullptr, IDI_APPLICATION);

    if (!RegisterClassEx(&wc)) {
        MessageBox(nullptr, "Failed to register window class.", "Error", MB_ICONERROR | MB_OK);
        return 0;
    }

    HWND hwnd = CreateWindowEx(
        0,
        kClassName,
        "Sine Wave - GDI+",
        WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT, CW_USEDEFAULT,
        800, 600,
        nullptr, nullptr, hInstance, nullptr);

    if (!hwnd) {
        MessageBox(nullptr, "Failed to create window.", "Error", MB_ICONERROR | MB_OK);
        return 0;
    }

    ShowWindow(hwnd, nCmdShow);
    UpdateWindow(hwnd);

    MSG msg = {};
    while (GetMessage(&msg, nullptr, 0, 0)) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
    return static_cast<int>(msg.wParam);
}

Direct2d version:

#include <windows.h>
#include <d2d1.h>
#include <cmath>
#include <vector>

static const char kClassName[] = "SineWaveWindowClass";

struct AppState {
    int width = 800;
    int height = 600;
    ID2D1Factory* factory = nullptr;
    ID2D1HwndRenderTarget* renderTarget = nullptr;
    ID2D1SolidColorBrush* axisBrush = nullptr;
    ID2D1SolidColorBrush* sineBrush = nullptr;
};

void CreateGraphicsResources(HWND hwnd, AppState* state) {
    if (state->renderTarget) return;

    RECT rc;
    GetClientRect(hwnd, &rc);
    D2D1_SIZE_U size = D2D1::SizeU(rc.right - rc.left, rc.bottom - rc.top);

    // Create render target
    state->factory->CreateHwndRenderTarget(
        D2D1::RenderTargetProperties(),
        D2D1::HwndRenderTargetProperties(hwnd, size),
        &state->renderTarget);

    // Create brushes
    if (state->renderTarget) {
        state->renderTarget->CreateSolidColorBrush(
            D2D1::ColorF(D2D1::ColorF::LightGray),
            &state->axisBrush);
        state->renderTarget->CreateSolidColorBrush(
            D2D1::ColorF(D2D1::ColorF::Blue),
            &state->sineBrush);
    }
}

void DiscardGraphicsResources(AppState* state) {
    if (state->axisBrush) { state->axisBrush->Release(); state->axisBrush = nullptr; }
    if (state->sineBrush) { state->sineBrush->Release(); state->sineBrush = nullptr; }
    if (state->renderTarget) { state->renderTarget->Release(); state->renderTarget = nullptr; }
}

void DrawSineWave(AppState* state) {
    if (!state->renderTarget) return;

    state->renderTarget->BeginDraw();
    state->renderTarget->Clear(D2D1::ColorF(D2D1::ColorF::White));

    float width = static_cast<float>(state->width);
    float height = static_cast<float>(state->height);

    // Draw axis
    state->renderTarget->DrawLine(
        D2D1::Point2F(0, height / 2),
        D2D1::Point2F(width, height / 2),
        state->axisBrush, 1.0f);

    // Sine wave parameters
    double amplitude = (height - 20) / 2.0;
    double midY = height / 2.0;
    double period = width;
    double twoPi = 6.283185307179586;

    // Build geometry
    ID2D1PathGeometry* geometry = nullptr;
    state->factory->CreatePathGeometry(&geometry);
    ID2D1GeometrySink* sink = nullptr;
    geometry->Open(&sink);

    sink->BeginFigure(D2D1::Point2F(0, static_cast<float>(midY)), D2D1_FIGURE_BEGIN_HOLLOW);

    for (int x = 0; x < state->width; ++x) {
        double t = static_cast<double>(x) / period;
        double y = midY - amplitude * std::sin(twoPi * t);
        sink->AddLine(D2D1::Point2F(static_cast<float>(x), static_cast<float>(y)));
    }

    sink->EndFigure(D2D1_FIGURE_END_OPEN);
    sink->Close();
    sink->Release();

    state->renderTarget->DrawGeometry(geometry, state->sineBrush, 2.0f);
    geometry->Release();

    HRESULT hr = state->renderTarget->EndDraw();
    if (hr == D2DERR_RECREATE_TARGET) {
        DiscardGraphicsResources(state);
    }
}

LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) {
    static AppState* state = nullptr;

    switch (msg) {
    case WM_CREATE: {
        state = new AppState();
        RECT rc;
        GetClientRect(hwnd, &rc);
        state->width = rc.right - rc.left;
        state->height = rc.bottom - rc.top;
        D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, &state->factory);
        return 0;
    }
    case WM_SIZE: {
        if (state) {
            state->width = LOWORD(lParam);
            state->height = HIWORD(lParam);
            if (state->renderTarget) {
                D2D1_SIZE_U size = D2D1::SizeU(state->width, state->height);
                state->renderTarget->Resize(size);
            }
        }
        return 0;
    }
    case WM_PAINT: {
        if (state) {
            PAINTSTRUCT ps;
            BeginPaint(hwnd, &ps);
            CreateGraphicsResources(hwnd, state);
            DrawSineWave(state);
            EndPaint(hwnd, &ps);
        }
        return 0;
    }
    case WM_DESTROY:
        if (state) {
            DiscardGraphicsResources(state);
            if (state->factory) { state->factory->Release(); }
            delete state;
            state = nullptr;
        }
        PostQuitMessage(0);
        return 0;
    default:
        return DefWindowProc(hwnd, msg, wParam, lParam);
    }
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE, LPSTR, int nCmdShow) {
    WNDCLASSEX wc = {};
    wc.cbSize = sizeof(WNDCLASSEX);
    wc.style = CS_HREDRAW | CS_VREDRAW;
    wc.lpfnWndProc = WndProc;
    wc.hInstance = hInstance;
    wc.hIcon = LoadIcon(nullptr, IDI_APPLICATION);
    wc.hCursor = LoadCursor(nullptr, IDC_ARROW);
    wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
    wc.lpszClassName = kClassName;
    wc.hIconSm = LoadIcon(nullptr, IDI_APPLICATION);

    if (!RegisterClassEx(&wc)) {
        MessageBox(nullptr, "Failed to register window class.", "Error", MB_ICONERROR | MB_OK);
        return 0;
    }

    HWND hwnd = CreateWindowEx(
        0,
        kClassName,
        "Sine Wave - Direct2D",
        WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT, CW_USEDEFAULT,
        800, 600,
        nullptr, nullptr, hInstance, nullptr);

    if (!hwnd) {
        MessageBox(nullptr, "Failed to create window.", "Error", MB_ICONERROR | MB_OK);
        return 0;
    }

    ShowWindow(hwnd, nCmdShow);
    UpdateWindow(hwnd);

    MSG msg = {};
    while (GetMessage(&msg, nullptr, 0, 0)) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
    return static_cast<int>(msg.wParam);
}

OpenGL version:

#include <windows.h>
#include <GL/gl.h>
#include <cmath>

static const char kClassName[] = "SineWaveOpenGLClass";

struct AppState {
    int width = 800;
    int height = 600;
};

void DrawSineWave(int width, int height) {
    if (width <= 0 || height <= 0) return;

    glViewport(0, 0, width, height);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(0, width, height, 0, -1, 1); // top-left origin

    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();

    // Clear background
    glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
    glClear(GL_COLOR_BUFFER_BIT);

    // Enable blending and line smoothing
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    
    glEnable(GL_LINE_SMOOTH);
    glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);

    // Draw axis
    glColor3ub(200, 200, 200);
    glBegin(GL_LINES);
    glVertex2f(0, height / 2.0f);
    glVertex2f(width, height / 2.0f);
    glEnd();

    // Sine wave parameters
    double amplitude = (height - 20) / 2.0;
    double midY = height / 2.0;
    double period = width;
    double twoPi = 6.283185307179586;

    // Draw sine wave
    glColor3ub(0, 120, 215);
    glLineWidth(2.0f); // <-- increase thickness here
    glBegin(GL_LINE_STRIP);
    for (int x = 0; x < width; ++x) {
        double t = static_cast<double>(x) / period;
        double y = midY - amplitude * std::sin(twoPi * t);
        glVertex2f(static_cast<float>(x), static_cast<float>(y));
    }
    glEnd();
}

LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) {
    static AppState* state = nullptr;
    static HGLRC hglrc = nullptr;
    static HDC hdc = nullptr;

    switch (msg) {
    case WM_CREATE: {
        state = new AppState();
        RECT rc;
        GetClientRect(hwnd, &rc);
        state->width = rc.right - rc.left;
        state->height = rc.bottom - rc.top;

        hdc = GetDC(hwnd);
        PIXELFORMATDESCRIPTOR pfd = {};
        pfd.nSize = sizeof(pfd);
        pfd.nVersion = 1;
        pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
        pfd.iPixelType = PFD_TYPE_RGBA;
        pfd.cColorBits = 32;
        pfd.cDepthBits = 24;
        pfd.iLayerType = PFD_MAIN_PLANE;

        int pf = ChoosePixelFormat(hdc, &pfd);
        SetPixelFormat(hdc, pf, &pfd);

        hglrc = wglCreateContext(hdc);
        wglMakeCurrent(hdc, hglrc);
        return 0;
    }
    case WM_SIZE: {
        if (state) {
            state->width = LOWORD(lParam);
            state->height = HIWORD(lParam);
            InvalidateRect(hwnd, nullptr, FALSE);
        }
        return 0;
    }
    case WM_PAINT: {
        PAINTSTRUCT ps;
        BeginPaint(hwnd, &ps);
        if (state) {
            DrawSineWave(state->width, state->height);
            SwapBuffers(hdc);
        }
        EndPaint(hwnd, &ps);
        return 0;
    }
    case WM_DESTROY:
        if (hglrc) {
            wglMakeCurrent(nullptr, nullptr);
            wglDeleteContext(hglrc);
        }
        if (hdc) ReleaseDC(hwnd, hdc);
        if (state) {
            delete state;
            state = nullptr;
        }
        PostQuitMessage(0);
        return 0;
    default:
        return DefWindowProc(hwnd, msg, wParam, lParam);
    }
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE, LPSTR, int nCmdShow) {
    WNDCLASSEX wc = {};
    wc.cbSize = sizeof(WNDCLASSEX);
    wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
    wc.lpfnWndProc = WndProc;
    wc.hInstance = hInstance;
    wc.hIcon = LoadIcon(nullptr, IDI_APPLICATION);
    wc.hCursor = LoadCursor(nullptr, IDC_ARROW);
    wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
    wc.lpszClassName = kClassName;
    wc.hIconSm = LoadIcon(nullptr, IDI_APPLICATION);

    if (!RegisterClassEx(&wc)) {
        MessageBox(nullptr, "Failed to register window class.", "Error", MB_ICONERROR | MB_OK);
        return 0;
    }

    HWND hwnd = CreateWindowEx(
        0,
        kClassName,
        "Sine Wave - OpenGL",
        WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT, CW_USEDEFAULT,
        800, 600,
        nullptr, nullptr, hInstance, nullptr);

    if (!hwnd) {
        MessageBox(nullptr, "Failed to create window.", "Error", MB_ICONERROR | MB_OK);
        return 0;
    }

    ShowWindow(hwnd, nCmdShow);
    UpdateWindow(hwnd);

    MSG msg = {};
    while (GetMessage(&msg, nullptr, 0, 0)) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
    return static_cast<int>(msg.wParam);
}

What about the eepp version?

BTW, I can't find the old thread about drawing sine wave anymore (even with is:archived).

Update: I found it (#73). I need to bypass the browser's cache with multiple F5 and Ctrl-F5. I always use private browsing mode so cache should not be an issue for me. Weird. I compiled and run the code. It's not the same as my code here. My code doesn't allow changing of the frequency, but it will auto redraw when resize window (this is more important to me).

[Curculigo]

Note: All code above was generated by AI. But the AI is really defeated by eepp. It doesn't even know what eepp is. I have to point it to this repository, and it still generates obviously invalid code. It hallucinated so badly. So AI is no help when you want to develop eepp programs. The unit tests are precious. They are the only source of simple enough programs for you to learn by examples!

[SpartanJ]

Yes, in order to get some decent results you'll need to provide enough context and examples to help you with it, but AI is really not useful with "unknown" code (not very well known code bases, although I'm sure they have been trained with eepp source, it's just a drop in the ocean). In my experience Gemini or Claude do some decent job in some cases.

[SpartanJ]

but it will auto redraw when resize window

All examples should do that.
BTW, this particular example has been added to the repository when it was requested in the past, so you don't need to look in the forums it's here.