framebuffers.rasm

src/4.advanced_d3d11/5.1.framebuffers/framebuffers.rasm · 168 lines

; 5.1 Framebuffers
;
; Drawing into a texture instead of the screen. The scene is rendered into a
; colour target of the window's size, with a depth buffer of its own, and then
; a second pass draws one full-screen triangle that reads that texture and
; writes the screen. Whatever the second pixel shader does to the colour
; applies to the whole frame at once: post-processing.
;
;   1 plain   2 inverted   3 greyscale   4 sharpen   5 blur   6 edges
;
; The last three are kernels: each pixel becomes a weighted sum of its
; neighbours, the weights in a 3x3 grid.
;
; GL calls the pair a framebuffer object with attachments. In D3D it is views
; of resources: a render target view to draw into the texture, a shader
; resource view to read it; one texture cannot be bound as both at once.
; create_render_target and create_depth_buffer (includes/learn/gpu.rasm) make
; them.
import "../../../includes/d3d11.rin"
import "../../../includes/calls.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"

plane_vertices: [48]const f32 = {
    ; position             normal              uv
    -5.0, -0.5,  5.0,     0.0, 1.0, 0.0,     0.0, 2.0,
     5.0, -0.5,  5.0,     0.0, 1.0, 0.0,     2.0, 2.0,
     5.0, -0.5, -5.0,     0.0, 1.0, 0.0,     2.0, 0.0,
    -5.0, -0.5,  5.0,     0.0, 1.0, 0.0,     0.0, 2.0,
     5.0, -0.5, -5.0,     0.0, 1.0, 0.0,     2.0, 0.0,
    -5.0, -0.5, -5.0,     0.0, 1.0, 0.0,     0.0, 0.0,
}

; Mirrors `cbuffer post` in framebuffers_screen.hlsl.
post_constants: struct = {
    mode: u32                              ; 1..6, as the keys
    pad: [3]u32
}

camera_start: const vec3 = { -1.0, 1.0, 4.0 }
cube_a: const vec3 = { -1.0, 0.0, -1.0 }
cube_b: const vec3 = { 2.0, 0.0, 0.0 }
clear_color: [4]const f32 = { 0.1, 0.1, 0.1, 1.0 }

t: transforms = {}
post: post_constants = {}
model: mat4 = {}
s: shader = {}
screen_shader: shader = {}
cam: camera = {}
scene_target: render_target = {}
scene_depth: *ID3D11DepthStencilView = {}
cube_vb: *ID3D11Buffer = {}
plane_vb: *ID3D11Buffer = {}
transforms_buffer: *ID3D11Buffer = {}
post_buffer: *ID3D11Buffer = {}
cube_texture: *ID3D11ShaderResourceView = {}
floor_texture: *ID3D11ShaderResourceView = {}
sampler: *ID3D11SamplerState = {}
clamp_sampler: *ID3D11SamplerState = {}

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

main: proc() -> i32 = {
    sub rsp, 40                            ; draw_vertices and create_render_target take 5: 32 + 8; entry 8 + 40 lands on 16

    invoke(window_create, "LearnD3D11")
    invoke(window_mode_default, 5)         ; edges

    invoke(create_sampler, D3D11_FILTER.D3D11_FILTER_ANISOTROPIC, D3D11_TEXTURE_ADDRESS_MODE.D3D11_TEXTURE_ADDRESS_WRAP)
    mov sampler, rax
    invoke(create_sampler, D3D11_FILTER.D3D11_FILTER_MIN_MAG_MIP_LINEAR, D3D11_TEXTURE_ADDRESS_MODE.D3D11_TEXTURE_ADDRESS_CLAMP)
    mov clamp_sampler, rax

    invoke(shader_create, s&, "src/4.advanced_d3d11/5.1.framebuffers/framebuffers.hlsl", cube_layout&, CUBE_LAYOUT_COUNT)
    ; The screen pass makes its own triangle from SV_VertexID: no vertices, no
    ; input layout.
    invoke(shader_create, screen_shader&, "src/4.advanced_d3d11/5.1.framebuffers/framebuffers_screen.hlsl", 0, 0)

    invoke(create_buffer, D3D11_BIND_FLAG.D3D11_BIND_VERTEX_BUFFER, cube_vertices&, sizeof(cube_vertices))
    mov cube_vb, rax
    invoke(create_buffer, D3D11_BIND_FLAG.D3D11_BIND_VERTEX_BUFFER, plane_vertices&, sizeof(plane_vertices))
    mov plane_vb, rax
    invoke(create_constant_buffer, sizeof(transforms))
    mov transforms_buffer, rax
    invoke(create_constant_buffer, sizeof(post_constants))
    mov post_buffer, rax
    invoke(filesystem_path, "resources/textures/marble.jpg")
    invoke(load_texture, rax, 0)
    mov cube_texture, rax
    invoke(filesystem_path, "resources/textures/metal.png")
    invoke(load_texture, rax, 0)
    mov floor_texture, rax

    ; the scene's own colour target and depth buffer, the window's size. The
    ; size is SCR_WIDTH and SCR_HEIGHT, immediates: scr_width is a u32 in
    ; memory, which an argument register (64 bits) cannot be loaded from as is.
    invoke(create_render_target, scene_target&, SCR_WIDTH, SCR_HEIGHT, DXGI_FORMAT.DXGI_FORMAT_R8G8B8A8_UNORM, 1)
    invoke(create_depth_buffer, SCR_WIDTH, SCR_HEIGHT, 1)
    mov scene_depth, rax

    lea rcx, cam
    lea rdx, camera_start
    movss xmm2, -75.0                      ; yaw
    movss xmm3, -15.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_mode, 6)
    inc eax
    mov post.mode, eax

    ; first pass: the scene, into the texture
    ; ---------------------------------------
    call unbind_textures                   ; the texture was being read last frame
    vcall(context, ID3D11DeviceContextVtbl.OMSetRenderTargets, 1, scene_target.rtv&, scene_depth)
    vcall(context, ID3D11DeviceContextVtbl.RSSetViewports, 1, viewport&)
    vcall(context, ID3D11DeviceContextVtbl.ClearRenderTargetView, scene_target.rtv, clear_color&)
    movss xmm3, 1.0                        ; the depth, a float: xmm3
    vcall(context, ID3D11DeviceContextVtbl.ClearDepthStencilView, scene_depth, D3D11_CLEAR_FLAG.D3D11_CLEAR_DEPTH, 0, 0)
    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, s&)
    vcall(context, ID3D11DeviceContextVtbl.PSSetSamplers, 0, 1, sampler&)
    invoke(bind_texture, 0, floor_texture)
    invoke(m4_identity, model&)
    invoke(draw_vertices, transforms_buffer, t&, plane_vb, 6, model&)
    invoke(bind_texture, 0, cube_texture)
    invoke(m4_translate, model&, cube_a&)
    invoke(draw_vertices, transforms_buffer, t&, cube_vb, 36, model&)
    invoke(m4_translate, model&, cube_b&)
    invoke(draw_vertices, transforms_buffer, t&, cube_vb, 36, model&)

    ; second pass: one triangle over the screen, reading the texture
    ; --------------------------------------------------------------
    vcall(context, ID3D11DeviceContextVtbl.OMSetRenderTargets, 1, backbuffer_rtv&, 0)
    invoke(update_buffer, post_buffer, post&, sizeof(post_constants))
    invoke(shader_use, screen_shader&)
    invoke(bind_constants, 1, post_buffer)
    invoke(bind_texture, 0, scene_target.srv)
    vcall(context, ID3D11DeviceContextVtbl.PSSetSamplers, 0, 1, clamp_sampler&)
    vcall(context, ID3D11DeviceContextVtbl.Draw, 3, 0)

    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.