ensenn/renderer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Added camera, use MVP.

Browse Source
This commit is contained in:
samstalhandske
2025-11-29 20:35:11 +01:00
parent bd62b8a528
commit 4cc0c8c73e
4 changed files with 135 additions and 22 deletions
Download Patch File Download Diff File Expand all files Collapse all files

62
camera.odin Normal file
View File

@@ -0,0 +1,62 @@
package renderer
import "core:math/linalg"
Camera :: struct {
position: [3]f32,
forward, up: [3]f32,
fov: f32,
near, far: f32,
yaw, pitch: f32,
}
create_camera :: proc(renderer: ^Renderer, position: [3]f32, forward, up: [3]f32, fov, near, far: f32) -> Camera {
c: Camera
c.position = position
c.forward = forward
c.up = up
c.fov = fov
c.near = near
c.far = far
assert(c.forward != {})
assert(c.up != {})
assert(fov > 0)
assert(near > 0)
assert(far > 0)
return c
}
get_camera_view_matrix :: proc(camera: ^Camera) -> (linalg.Matrix4f32, bool) {
if camera == nil {
return {}, false
}
center := camera.position + camera.forward
view_matrix := linalg.identity(linalg.Matrix4x4f32)
view_matrix *= linalg.matrix4_look_at_f32(camera.position, center, camera.up)
return view_matrix, true
}
get_camera_projection_matrix :: proc(renderer: ^Renderer, camera: ^Camera) -> (linalg.Matrix4f32, bool) {
if camera == nil {
return {}, false
}
projection_matrix := linalg.identity(linalg.Matrix4x4f32)
projection_matrix *= linalg.matrix4_perspective(camera.fov, get_aspect_ratio(renderer), camera.near, camera.far)
return projection_matrix, true
}
set_active_camera :: proc(renderer: ^Renderer, camera: ^Camera) {
renderer.active_camera = camera
}
get_active_camera :: proc(renderer: ^Renderer) -> ^Camera {
return renderer.active_camera
}

3
pass.odin
View File

@@ -8,6 +8,9 @@ Pass :: struct {
name: string,
clear_color: RGB_Color,
should_test_depth: bool,
should_clear_depth: bool,
draw_commands: [MAX_DRAW_COMMANDS_PER_PASS]Draw_Command,
draw_command_count: u32,
}

52
renderer.odin
View File

@@ -15,12 +15,21 @@ Renderer :: struct {
backend: rawptr,
pipeline: Pipeline,
active_camera: ^Camera,
}
Viewport :: struct {
x, y, width, height: u16,
}
get_aspect_ratio :: proc(renderer: ^Renderer) -> f32 {
assert(renderer != nil)
viewport := &renderer.viewport
return f32(viewport.width) / f32(viewport.height)
}
RGB_Color :: [3]u8
RGBA_Color :: [4]u8
@@ -46,7 +55,7 @@ create :: proc(surface_ptr: rawptr) -> (^Renderer, bool) {
}
set_viewport :: proc(renderer: ^Renderer, x, y, width, height: u16) {
fmt.printfln("Setting viewport to %v:%v, %vx%v.", x, y, width, height)
log.infof("Setting viewport to %v:%v, %vx%v.", x, y, width, height)
renderer.viewport = {
x = x,
@@ -66,39 +75,50 @@ set_viewport :: proc(renderer: ^Renderer, x, y, width, height: u16) {
}
}
@(private="file") clear_screen :: proc(renderer: ^Renderer) { // TODO: SS - Add options here to say if you want to clear depth or not, for example.
@(private="file") clear_screen :: proc(renderer: ^Renderer, clear_depth: bool) {
when RENDER_BACKEND_OPENGL {
opengl_clear_screen(renderer)
opengl_clear_screen(renderer, clear_depth)
}
}
render_frame :: proc(renderer: ^Renderer) {
if renderer.active_camera == nil {
fmt.printfln("No active camera!")
return
}
view_matrix, view_matrix_ok := get_camera_view_matrix(renderer.active_camera)
assert(view_matrix_ok)
projection_matrix, projection_matrix_ok := get_camera_projection_matrix(renderer, renderer.active_camera)
assert(projection_matrix_ok)
pipeline := &renderer.pipeline
for i in 0 ..< pipeline.amount_of_passes {
pass := pipeline.passes[i]
set_clear_color(renderer, pass.clear_color)
clear_screen(renderer)
clear_screen(renderer, pass.should_clear_depth)
enable_depth_testing(renderer, pass.should_test_depth)
for i in 0..<pass.draw_command_count {
command := &pass.draw_commands[i]
transform := linalg.identity(linalg.Matrix4x4f32)
model_matrix := linalg.identity(linalg.Matrix4x4f32)
scale := linalg.matrix4_scale(command.scale)
rotation := linalg.matrix4_rotate(0, [3]f32 { 0, 0, 1 })
rotation := linalg.matrix4_rotate(linalg.to_radians(f32(0.0)), [3]f32 { 1, 0, 0 })
translation := linalg.matrix4_translate(command.position)
// Scale.
transform *= scale
model_matrix *= scale
// Rotate.
transform *= rotation
model_matrix *= rotation
// Translate.
transform *= translation
model_matrix *= translation
activate_material(&command.material, transform)
activate_material(&command.material, model_matrix, view_matrix, projection_matrix)
draw_mesh(&command.mesh)
}
@@ -112,6 +132,8 @@ render_frame :: proc(renderer: ^Renderer) {
when RENDER_BACKEND_OPENGL {
opengl_swap_buffers(renderer)
}
clear_screen(renderer, true)
}
destroy :: proc(renderer: ^Renderer) {
@@ -123,11 +145,11 @@ destroy :: proc(renderer: ^Renderer) {
free(renderer)
}
@(private) activate_material :: proc(material: ^Material, transform: linalg.Matrix4x4f32) {
@(private) activate_material :: proc(material: ^Material, model_matrix, view_matrix, projection_matrix: linalg.Matrix4x4f32) {
assert(material != nil)
when RENDER_BACKEND_OPENGL {
opengl_activate_material(material, transform)
opengl_activate_material(material, model_matrix, view_matrix, projection_matrix)
}
}
@@ -137,4 +159,10 @@ destroy :: proc(renderer: ^Renderer) {
when RENDER_BACKEND_OPENGL {
opengl_draw_mesh(mesh)
}
}
@(private) enable_depth_testing :: proc(renderer: ^Renderer, enable: bool) {
when RENDER_BACKEND_OPENGL {
opengl_enable_depth_testing(renderer, true)
}
}

40
renderer_backend_opengl_windows.odin
View File

@@ -84,8 +84,6 @@ when RENDER_BACKEND_OPENGL {
opengl_viewport_changed :: proc(renderer: ^Renderer) {
opengl_clear_screen(renderer)
gl.Viewport(
i32(renderer.viewport.x),
i32(renderer.viewport.y),
@@ -103,13 +101,18 @@ when RENDER_BACKEND_OPENGL {
)
}
opengl_clear_screen :: proc(renderer: ^Renderer) {
gl.Clear(gl.COLOR_BUFFER_BIT)
opengl_clear_screen :: proc(renderer: ^Renderer, clear_depth: bool) {
mask := u32(gl.COLOR_BUFFER_BIT)
if clear_depth {
gl.ClearDepth(1.0)
mask |= gl.DEPTH_BUFFER_BIT
}
gl.Clear(mask)
}
opengl_swap_buffers :: proc(renderer: ^Renderer) {
win.SwapBuffers(backend.hdc)
opengl_clear_screen(renderer)
}
opengl_destroy :: proc(renderer: ^Renderer) {
@@ -239,15 +242,23 @@ when RENDER_BACKEND_OPENGL {
gl.DeleteProgram(shader_program.backend.handle)
}
opengl_activate_material :: proc(material: ^Material, transform: linalg.Matrix4x4f32) {
opengl_activate_material :: proc(material: ^Material, model_matrix, view_matrix, projection_matrix: linalg.Matrix4x4f32) {
gl.UseProgram(material.shader_program.backend.handle)
gl.ActiveTexture(gl.TEXTURE0)
gl.BindTexture(gl.TEXTURE_2D, material.texture.backend.handle)
transform_loc := gl.GetUniformLocation(material.shader_program.backend.handle, "in_transform")
transform_as_f32_array := transmute([16]f32)(transform)
gl.UniformMatrix4fv(transform_loc, 1, false, &transform_as_f32_array[0])
model_matrix_loc := gl.GetUniformLocation(material.shader_program.backend.handle, "in_model_matrix")
model_matrix_as_f32_array := transmute([16]f32)(model_matrix)
gl.UniformMatrix4fv(model_matrix_loc, 1, false, &model_matrix_as_f32_array[0])
view_matrix_loc := gl.GetUniformLocation(material.shader_program.backend.handle, "in_view_matrix")
view_matrix_as_f32_array := transmute([16]f32)(view_matrix)
gl.UniformMatrix4fv(view_matrix_loc, 1, false, &view_matrix_as_f32_array[0])
projection_matrix_loc := gl.GetUniformLocation(material.shader_program.backend.handle, "in_projection_matrix")
projection_matrix_as_f32_array := transmute([16]f32)(projection_matrix)
gl.UniformMatrix4fv(projection_matrix_loc, 1, false, &projection_matrix_as_f32_array[0])
}
opengl_draw_mesh :: proc(mesh: ^Mesh) {
@@ -322,6 +333,15 @@ when RENDER_BACKEND_OPENGL {
}
opengl_delete_texture :: proc(renderer: ^Renderer, t: ^Texture) {
gl.DeleteTextures(1, &t.backend.handle)
}
opengl_enable_depth_testing :: proc(renderer: ^Renderer, enable: bool) {
if enable {
gl.Enable(gl.DEPTH_TEST)
}
else {
gl.Disable(gl.DEPTH_TEST)
}
}
}