hello_window.rin

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

// 1.1 Hello window
//
// A window, a D3D11 device, and a colour every frame: what GLFW and a GL
// context give LearnOpenGL, done by hand because on Windows it is only a page.
//
//   1. register a window class, naming the procedure that receives the
//      window's events, and create the window
//   2. create the device (which makes resources), its immediate context (which
//      records drawing) and a swap chain (the images that take turns being
//      shown and drawn into)
//   3. a render target view of the swap chain's back buffer, so it can be
//      cleared and drawn into
//   4. loop: hand window events to window_proc, clear, present

import "../../../includes/win32.rin"
import "std/print.rin"

// settings
scr_width: i32 = 1280;
scr_height: i32 = 720;

// win32: every event for the window (keys, mouse, closing) arrives here
// ---------------------------------------------------------------------
window_proc: proc[callconv(CALLBACK)](hwnd: HWND, msg: UINT, wparam: WPARAM, lparam: LPARAM) -> LRESULT = {
    if (msg == WM_DESTROY) {
        PostQuitMessage(0);
        return 0;
    }
    return DefWindowProcA(hwnd, msg, wparam, lparam);
}

// process all input: ask Windows whether relevant keys are down this frame and react accordingly
// ----------------------------------------------------------------------------------------------
// The top bit of GetAsyncKeyState is set while a key is held, which makes the SHORT negative.
key_down: proc(key: i32) -> b32 = {
    return GetAsyncKeyState(key) < 0;
}

process_input: proc(window: HWND) -> void = {
    // GetAsyncKeyState reads the whole keyboard, so ignore it while another
    // window has the focus; glfwGetKey only ever sees its own window's keys.
    if (GetForegroundWindow() != window) { return; }
    if (key_down(VK_ESCAPE)) { DestroyWindow(window); }
}

main: proc() -> i32 = {
    // win32: register a window class and create the window
    // ----------------------------------------------------
    SetProcessDPIAware();
    instance: HMODULE = GetModuleHandleA(null);
    wc: WNDCLASSA = {
        .lpfnWndProc = window_proc,
        .hInstance = instance,
        .hCursor = LoadCursorA(null, IDC_ARROW),
        .lpszClassName = "LearnD3D11",
    };
    RegisterClassA(wc&);
    // A fixed size: the swap chain and every render target keep the size they
    // were created with, so nothing needs rebuilding on resize.
    style: DWORD = WS_OVERLAPPEDWINDOW & ~(WS_THICKFRAME | WS_MAXIMIZEBOX);
    rect: RECT = { .right = scr_width, .bottom = scr_height };
    AdjustWindowRect(rect&, style, 0);
    window: HWND = CreateWindowExA(0, wc.lpszClassName, "LearnD3D11", style | WS_VISIBLE, CW_USEDEFAULT, CW_USEDEFAULT,
                                   rect.right - rect.left, rect.bottom - rect.top, null, null, instance, null);
    if (window == null) {
        printf("Failed to create the window\n");
        return -1;
    }

    // d3d11: create the device, its immediate context and a swap chain
    // ----------------------------------------------------------------
    swap_desc: DXGI_SWAP_CHAIN_DESC = {
        .BufferDesc = {
            .Width = cast(scr_width, UINT),
            .Height = cast(scr_height, UINT),
            .Format = DXGI_FORMAT.DXGI_FORMAT_R8G8B8A8_UNORM,
        },
        .SampleDesc = { .Count = 1 },
        .BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT,
        .BufferCount = 2,
        .OutputWindow = window,
        .Windowed = 1,
        .SwapEffect = DXGI_SWAP_EFFECT.DXGI_SWAP_EFFECT_FLIP_DISCARD,
    };
    feature_level: D3D_FEATURE_LEVEL = D3D_FEATURE_LEVEL.D3D_FEATURE_LEVEL_11_0;
    swap_chain: *IDXGISwapChain = null;
    device: *ID3D11Device = null;
    context: *ID3D11DeviceContext = null;
    if (D3D11CreateDeviceAndSwapChain(null, D3D_DRIVER_TYPE.D3D_DRIVER_TYPE_HARDWARE, null, 0, feature_level&, 1, D3D11_SDK_VERSION,
                                      swap_desc&, swap_chain&, device&, null, context&) < 0) {
        printf("Failed to create the D3D11 device\n");
        return -1;
    }
    backbuffer: *ID3D11Texture2D = null;
    IDXGISwapChain_GetBuffer(swap_chain, 0, IID_ID3D11Texture2D&, cast(backbuffer&, **void));
    backbuffer_rtv: *ID3D11RenderTargetView = null;
    ID3D11Device_CreateRenderTargetView(device, cast(backbuffer, *ID3D11Resource), null, backbuffer_rtv&);

    // render loop
    // -----------
    running: b32 = 1;
    while (running) {
        msg: MSG = {};
        while (PeekMessageA(msg&, null, 0, 0, PM_REMOVE) != 0) {
            if (msg.message == WM_QUIT) { running = 0; }
            TranslateMessage(msg&);
            DispatchMessageA(msg&);
        }

        // input
        // -----
        process_input(window);

        // render
        // ------
        clear_color: [4]f32 = { 0.2, 0.3, 0.3, 1.0 };
        ID3D11DeviceContext_ClearRenderTargetView(context, backbuffer_rtv, clear_color[0]&);

        // dxgi: show the image just drawn, waiting for the next vertical blank
        // --------------------------------------------------------------------
        IDXGISwapChain_Present(swap_chain, 1, 0);
    }
    return 0;
}