shaders.asm

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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

;---------------------------------------------------------------------------------------------------
; 3.1 Shaders
;---------------------------------------------------------------------------------------------------
; Two ways to get data into a shader:
;
;   * per vertex: each vertex carries a colour, and the rasterizer blends the three across the
;     triangle on its way to the pixel shader (right)
;   * per draw: a constant buffer, D3D's uniform. The CPU fills a struct and copies it in whole
;     with Map; every vertex and pixel of the draw reads the same values (left: a tint that pulses
;     over time)
;
; From here on shaders are loaded by includes/learn/shader.asm, which does what 2.1 wrote out:
; compile vs_main and ps_main from one .hlsl file and create the input layout against the vertex
; shader. LearnOpenGL's 3.3 shaders_class introduces its Shader class the same way. The window,
; device and swap chain, written out in 1.1 and 2.1, come from includes/learn/window.asm, which is
; to these lessons what GLFW is to LearnOpenGL's.
include rt.inc
include d3d11.inc
include macros.asm
include math.asm
include learn\window.asm
include learn\shader.asm
include learn\gpu.asm

;---------------------------------------------------------------------------------------------------
.data
;---------------------------------------------------------------------------------------------------
; x, y, z, then r, g, b
align 4
left_triangle real4 -0.9, -0.5, 0.0,   1.0, 1.0, 1.0
              real4 -0.1, -0.5, 0.0,   1.0, 1.0, 1.0
              real4 -0.5,  0.5, 0.0,   1.0, 1.0, 1.0
left_triangle_size equ $ - left_triangle

right_triangle real4 0.1, -0.5, 0.0,   1.0, 0.0, 0.0
               real4 0.9, -0.5, 0.0,   0.0, 1.0, 0.0
               real4 0.5,  0.5, 0.0,   0.0, 0.0, 1.0
right_triangle_size equ $ - right_triangle

semantic_position byte "POSITION", 0
semantic_color byte "COLOR", 0
align 8
vertex_layout D3D11_INPUT_ELEMENT_DESC <offset semantic_position, 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0>
              D3D11_INPUT_ELEMENT_DESC <offset semantic_color, 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0>

; Mirrors `cbuffer frame` in the shader, register for register.
frame_constants struct
    tint vec4 <>
frame_constants ends

align 16
s shader <>
c frame_constants <>
align 8
left_vb qword 0
right_vb qword 0
constants qword 0
stride dword 24
offset_ dword 0

; timing
current_frame real4 0.0

;---------------------------------------------------------------------------------------------------
.code
;---------------------------------------------------------------------------------------------------
align 16
main proc
    invoke window_create, "LearnD3D11"

    ; build and compile our shader program
    ; ------------------------------------
    invoke shader_create, ADDR s, "src/1.getting_started/3.1.shaders/shaders.hlsl", ADDR vertex_layout, 2

    ; set up vertex data
    ; ------------------
    invoke create_buffer, D3D11_BIND_VERTEX_BUFFER, ADDR left_triangle, left_triangle_size
    mov left_vb, rax
    invoke create_buffer, D3D11_BIND_VERTEX_BUFFER, ADDR right_triangle, right_triangle_size
    mov right_vb, rax

    ; A dynamic constant buffer: the CPU may rewrite it. Its size must be a multiple of 16 bytes,
    ; the size of one HLSL register.
    invoke create_constant_buffer, sizeof frame_constants
    mov constants, rax

    ; render loop
    ; -----------
    render_loop:
        call window_poll
        test eax, eax
        jz render_loop_done

        ; per-frame time logic
        ; --------------------
        call get_time
        movss current_frame, xmm0

        ; render
        ; ------
        vcall context, ID3D11DeviceContext_OMSetRenderTargets, 1, ADDR backbuffer_rtv, 0
        vcall context, ID3D11DeviceContext_RSSetViewports, 1, ADDR viewport
        vcall context, ID3D11DeviceContext_ClearRenderTargetView, backbuffer_rtv, floats(0.2, 0.3, 0.3, 1.0)

        invoke shader_use, ADDR s
        vcall context, ID3D11DeviceContext_IASetPrimitiveTopology, D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST
        vcall context, ID3D11DeviceContext_PSSetConstantBuffers, 0, 1, ADDR constants

        ; WRITE_DISCARD hands back fresh memory each time, so the GPU never waits on the CPU, and
        ; the previous draw keeps the values it saw.
        ; tint = (0, sin(t) / 2 + 0.5, 0, 1)
        movss xmm0, current_frame
        call sinf
        mulss xmm0, math_half
        addss xmm0, math_half
        storef c.tint.x, 0.0
        movss c.tint.y, xmm0
        storef c.tint.z, 0.0
        storef c.tint.w, 1.0
        invoke update_buffer, constants, ADDR c, sizeof frame_constants
        vcall context, ID3D11DeviceContext_IASetVertexBuffers, 0, 1, ADDR left_vb, ADDR stride, ADDR offset_
        vcall context, ID3D11DeviceContext_Draw, 3, 0

        storef c.tint.x, 1.0
        storef c.tint.y, 1.0
        storef c.tint.z, 1.0
        invoke update_buffer, constants, ADDR c, sizeof frame_constants
        vcall context, ID3D11DeviceContext_IASetVertexBuffers, 0, 1, ADDR right_vb, ADDR stride, ADDR offset_
        vcall context, ID3D11DeviceContext_Draw, 3, 0

        ; dxgi: show the image just drawn, waiting for the next vertical blank
        ; --------------------------------------------------------------------
        call window_present
        jmp render_loop
    render_loop_done:

    invoke ExitProcess, 0
main endp

end