advanced_hlsl.rasm

src/4.advanced_d3d11/8.advanced_hlsl/advanced_hlsl.rasm · 165 lines

; 8. Advanced HLSL
;
; LearnOpenGL's "advanced GLSL", in HLSL terms.
;
;   one buffer, many shaders   The four cubes are drawn by four different pixel
;                              shaders, compiled from one file by entry name,
;                              and none of them is handed the camera: it is a
;                              constant buffer bound to b0 once per frame, and
;                              every shader that declares `cbuffer transforms :
;                              register(b0)` reads it. (GL: a uniform buffer
;                              object at a binding point.)
;   system values              SV_Position in a pixel shader is the pixel's own
;                              coordinates (gl_FragCoord): the left half of the
;                              window is drawn darker. SV_IsFrontFace
;                              (gl_FrontFacing) says which side of a triangle
;                              is showing: the cubes' near faces are cut away,
;                              and their insides drawn as a dark checker.
;   packing                    A cbuffer packs into 16-byte registers, and a
;                              float3 followed by a float shares one. The
;                              structs that mirror cbuffers pad to match
;                              (std140, in GL): see `transforms` in
;                              includes/learn/transforms.rasm.
import "../../../includes/d3d11.rin"
import "../../../includes/calls.rasm"
import "../../../includes/macros.rasm"
import "../../../includes/math.rasm"
import "../../../includes/learn/window.rasm"
import "../../../includes/learn/shader.rasm"
import "../../../includes/learn/gpu.rasm"
import "../../../includes/learn/cube.rasm"
import "../../../includes/learn/camera.rasm"
import "../../../includes/learn/transforms.rasm"

; A pointer global, not a literal: it is passed twice, to shader_create and
; to filesystem_path.
shader_path: *const c8 = "src/4.advanced_d3d11/8.advanced_hlsl/advanced_hlsl.hlsl"
entries: [4]const *const c8 = { "ps_main", "ps_green", "ps_blue", "ps_yellow" }

camera_start: const vec3 = { 0.0, 0.0, 5.0 }
corners: [4]const vec3 = {
    { -0.75,  0.75, 0.0 },
    {  0.75,  0.75, 0.0 },
    { -0.75, -0.75, 0.0 },
    {  0.75, -0.75, 0.0 },
}
spin_axis: const vec3 = { 0.3, 1.0, 0.2 }
clear_color: [4]const f32 = { 0.1, 0.1, 0.1, 1.0 }

t: transforms = {}
model: mat4 = {}
rotation: mat4 = {}
turned: mat4 = {}
base: shader = {}
cam: camera = {}
pixel_shaders: [4]*ID3D11PixelShader = {}
cube_vb: *ID3D11Buffer = {}
transforms_buffer: *ID3D11Buffer = {}

; main's: MASM's locals
path: *c8 = {}
source: *u8 = {}
source_size: u64 = 0
blob: *ID3DBlob = {}
code_size: u64 = 0

; timing
delta_time: f32 = 0.0
last_frame: f32 = 0.0

main: proc() -> i32 = {
    push rbx
    push rsi
    push rdi
    push r12
    sub rsp, 40                                ; shader_compile and draw_vertices take 5: 32 + 8; entry 8 + four pushes 32 + 40 lands on 16

    invoke(window_create, "LearnD3D11")
    call window_create_depth

    ; the vertex shader and layout as usual; then four pixel shaders from the same file
    invoke(shader_create, base&, shader_path, cube_layout&, CUBE_LAYOUT_COUNT)
    invoke(filesystem_path, shader_path)
    mov path, rax
    invoke(filesystem_read, path, source_size&)
    mov source, rax
    lea rsi, entries
    lea rdi, pixel_shaders
    xor ebx, ebx
  entry_points:
    invoke(shader_compile, path, source, source_size, [rsi + rbx * 8], "ps_5_0")
    mov blob, rax
    vcall(blob, ID3D10BlobVtbl.GetBufferPointer)
    mov r12, rax
    vcall(blob, ID3D10BlobVtbl.GetBufferSize)
    mov code_size, rax
    lea rax, [rdi + rbx * 8]
    vcall(device, ID3D11DeviceVtbl.CreatePixelShader, r12, code_size, 0, rax)
    release(blob)
    inc ebx
    cmp ebx, 4
    jb entry_points

    invoke(create_buffer, D3D11_BIND_FLAG.D3D11_BIND_VERTEX_BUFFER, cube_vertices&, sizeof(cube_vertices))
    mov cube_vb, rax
    invoke(create_constant_buffer, sizeof(transforms))
    mov transforms_buffer, rax

    lea rcx, cam
    lea rdx, camera_start
    movss xmm2, -90.0                          ; yaw
    movss xmm3, 0.0                            ; pitch
    call camera_create

  render_loop:
    call window_poll
    test eax, eax
    jz render_loop_done

    call get_time
    movss xmm1, xmm0
    subss xmm0, last_frame
    movss delta_time, xmm0
    movss last_frame, xmm1

    invoke(camera_process_input, cam&, delta_time&)

    invoke(window_begin, clear_color&)
    vcall(context, ID3D11DeviceContextVtbl.IASetPrimitiveTopology, D3D11_PRIMITIVE_TOPOLOGY.D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST)
    invoke(bind_constants, 0, transforms_buffer)
    invoke(transforms_from_camera, t&, cam&)
    invoke(shader_use, base&)

    lea rsi, corners
    lea rdi, pixel_shaders
    xor ebx, ebx
  cubes:
    ; this cube's pixel shader in place of base's
    vcall(context, ID3D11DeviceContextVtbl.PSSetShader, [rdi + rbx * 8], 0, 0)
    ; model = translate(corner) * rotate(0.6 + 0.3 i, (0.3, 1, 0.2)) * scale(0.8)
    cvtsi2ss xmm1, ebx
    mulss xmm1, 0.3
    addss xmm1, 0.6                            ; the angle, m4_rotate's second argument
    lea rcx, rotation
    lea r8, spin_axis
    call m4_rotate
    invoke(m4_identity, model&)
    movss xmm0, 0.8
    movss model.m[0], xmm0
    movss model.m[5], xmm0
    movss model.m[10], xmm0
    invoke(m4_mul, turned&, rotation&, model&)
    invoke(m4_translate, model&, rsi)
    invoke(m4_mul, model&, model&, turned&)
    invoke(draw_vertices, transforms_buffer, t&, cube_vb, 36, model&)
    add rsi, sizeof(vec3)
    inc ebx
    cmp ebx, 4
    jb cubes

    call window_present
    jmp render_loop
  render_loop_done:

    invoke(ExitProcess, 0)
}
Part of rasm-dx11, LearnOpenGL's lessons rewritten for Direct3D 11 in rasm. Licensed CC BY-NC 4.0, after LearnOpenGL by Joey de Vries.