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)
}