basic_lighting.rasm
src/2.lighting/2.1.basic_lighting/basic_lighting.rasm · 140 lines
; 2.1 Basic lighting
;
; The Phong model: light reflected by a surface, as the sum of three parts.
;
; ambient a little light from everywhere, so nothing is pitch black
; diffuse brightest where the surface faces the light: dot(normal, to_light)
; specular a highlight where the light bounces straight at the eye
;
; All three need the surface's normal and position in one space; here that
; is world space. Normals are moved there by the normal matrix, the inverse
; transpose of the model matrix, so a stretched object does not get bent
; normals. HLSL has no inverse(), so draw_cube computes it on the CPU and
; sends it with every draw. The light circles the cube.
;
; W A S D, Space, Shift move
; right mouse + drag look
; wheel zoom
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"
; Mirrors `cbuffer light` in basic_lighting.hlsl.
light_constants: struct = {
object_color: vec3
pad0: f32
light_color: vec3
pad1: f32
light_position: vec3
pad2: f32
}
camera_start: const vec3 = { -1.0, 1.0, 4.0 }
clear_color: [4]const f32 = { 0.1, 0.1, 0.1, 1.0 }
t: transforms = {}
light: light_constants = {
.object_color = { 1.0, 0.5, 0.31 },
.light_color = { 1.0, 1.0, 1.0 },
} ; light_position is set every frame
lamp_color: const vec4 = { 1.0, 1.0, 1.0, 1.0 }
model: mat4 = {}
lighting_shader: shader = {}
lamp_shader: shader = {}
cam: camera = {}
cube_vb: *ID3D11Buffer = {}
transforms_buffer: *ID3D11Buffer = {}
light_buffer: *ID3D11Buffer = {}
lamp_buffer: *ID3D11Buffer = {}
stride: u32 = CUBE_STRIDE
offset: u32 = 0
; timing
current_frame: f32 = 0.0
delta_time: f32 = 0.0
last_frame: f32 = 0.0
main: proc() -> i32 = {
sub rsp, 56 ; IASetVertexBuffers: 5 past `this`, 2 on the stack: 32 + 16; entry 8 + 56 lands on 16
invoke(window_create, "LearnD3D11")
call window_create_depth
invoke(shader_create, lighting_shader&, "src/2.lighting/2.1.basic_lighting/basic_lighting.hlsl", cube_layout&, CUBE_LAYOUT_COUNT)
invoke(shader_create, lamp_shader&, "src/2.lighting/2.1.basic_lighting/light_cube.hlsl", cube_layout&, CUBE_LAYOUT_COUNT)
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
invoke(create_constant_buffer, sizeof(light_constants))
mov light_buffer, rax
invoke(create_constant_buffer, sizeof(vec4))
mov lamp_buffer, rax
lea rcx, cam
lea rdx, camera_start
movss xmm2, -75.0 ; yaw
movss xmm3, -10.0 ; pitch
call camera_create
render_loop:
call window_poll
test eax, eax
jz render_loop_done
; per-frame time logic
call get_time
movss current_frame, xmm0
movss xmm1, xmm0
subss xmm0, last_frame
movss delta_time, xmm0
movss last_frame, xmm1
invoke(camera_process_input, cam&, delta_time&)
; render
invoke(window_begin, clear_color&)
vcall(context, ID3D11DeviceContextVtbl.IASetPrimitiveTopology, D3D11_PRIMITIVE_TOPOLOGY.D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST)
vcall(context, ID3D11DeviceContextVtbl.IASetVertexBuffers, 0, 1, cube_vb&, stride&, offset&)
invoke(bind_constants, 0, transforms_buffer)
invoke(transforms_from_camera, t&, cam&)
; the light circles the cube: (2 cos t, 1, 2 sin t)
movss xmm0, current_frame
call cosf
addss xmm0, xmm0
movss light.light_position.x, xmm0
mov light.light_position.y, 0x3F800000 ; 1.0
movss xmm0, current_frame
call sinf
addss xmm0, xmm0
movss light.light_position.z, xmm0
invoke(update_buffer, light_buffer, light&, sizeof(light_constants))
invoke(shader_use, lighting_shader&)
invoke(bind_constants, 1, light_buffer)
lea rcx, model
call m4_identity
invoke(draw_cube, transforms_buffer, t&, model&)
invoke(update_buffer, lamp_buffer, lamp_color&, sizeof(vec4))
invoke(shader_use, lamp_shader&)
invoke(bind_constants, 1, lamp_buffer)
lea rcx, model
lea rdx, light.light_position
movss xmm2, 0.2 ; the scale, the third argument
call m4_translate_scale
invoke(draw_cube, transforms_buffer, t&, model&)
call window_present
jmp render_loop
render_loop_done:
invoke(ExitProcess, 0)
}