Line drawing

backend_d3d11.odin

@@ -25,8 +25,6 @@ BACKEND_D3D11 :: Rendering_Backend {
 	get_swapchain_width = d3d11_get_swapchain_width,
 	get_swapchain_height = d3d11_get_swapchain_height,
 
-	set_view_projection_matrix = d3d11_set_view_projection_matrix,
-
 	set_internal_state = d3d11_set_internal_state,
 
 	load_texture = d3d11_load_texture,
@@ -207,10 +205,6 @@ d3d11_get_swapchain_height :: proc() -> int {
 	return s.height
 }
 
-d3d11_set_view_projection_matrix :: proc(m: Mat4) {
-	s.view_proj = m
-}
-
 VERTEX_BUFFER_MAX :: 1000000
 
 TEXTURE_NONE :: Texture_Handle {}
@@ -365,7 +359,7 @@ create_vertex_input_override :: proc(val: $T) -> Shader_Input_Value_Override {
 	return res
 }
 
-d3d11_draw :: proc(shd: Shader, texture: Texture_Handle, vertex_buffer: []u8) {
+d3d11_draw :: proc(shd: Shader, texture: Texture_Handle, view_proj: Mat4, vertex_buffer: []u8) {
 	if len(vertex_buffer) == 0 {
 		return
 	}
@@ -413,7 +407,7 @@ d3d11_draw :: proc(shd: Shader, texture: Texture_Handle, vertex_buffer: []u8) {
 		switch builtin {
 		case .MVP:
 			dst := (^matrix[4,4]f32)(&shd.constant_buffers[loc.buffer_idx].cpu_data[loc.offset])
-			dst^ = s.view_proj
+			dst^ = view_proj
 		}
 	}
 

backend_interface.odin

@@ -6,7 +6,7 @@ Rendering_Backend :: struct {
 	shutdown: proc(),
 	clear: proc(color: Color),
 	present: proc(),
-	draw: proc(shader: Shader, texture: Texture_Handle, vertex_buffer: []u8),
+	draw: proc(shader: Shader, texture: Texture_Handle, view_proj: Mat4, vertex_buffer: []u8),
 	set_internal_state: proc(state: rawptr),
 
 	load_texture: proc(data: []u8, width: int, height: int) -> Texture_Handle,
@@ -18,7 +18,5 @@ Rendering_Backend :: struct {
 	get_swapchain_width: proc() -> int,
 	get_swapchain_height: proc() -> int,
 
-	set_view_projection_matrix: proc(m: Mat4),
-
 	batch_vertex: proc(v: Vec2, uv: Vec2, color: Color),
 }

examples/minimal/minimal.odin

@@ -1,14 +1,23 @@
 package karl2d_minimal_example
 
 import k2 "../.."
+import "core:log"
+import "core:time"
 
 main :: proc() {
+	context.logger = log.create_console_logger()
 	k2.init(1280, 720, "Karl2D Minimal Program")
+	k2.set_window_position(300, 100)
+
+	start_time := time.now()
 
 	for !k2.shutdown_wanted() {
+		t := f32(time.duration_seconds(time.since(start_time)))
 		k2.process_events()
 		k2.clear(k2.BLUE)
 		k2.present()
+
+		free_all(context.temp_allocator)
 	}
 
 	k2.shutdown()

karl2d.odin

@@ -134,7 +134,7 @@ docs for those procs).
 */   
 draw_current_batch :: proc() {
 	shader := s.batch_shader.? or_else s.default_shader
-	s.rb.draw(shader, s.batch_texture, s.vertex_buffer_cpu[:s.vertex_buffer_cpu_used])
+	s.rb.draw(shader, s.batch_texture, s.proj_matrix * s.view_matrix, s.vertex_buffer_cpu[:s.vertex_buffer_cpu_used])
 	s.vertex_buffer_cpu_used = 0
 }
 
@@ -198,8 +198,6 @@ set_camera :: proc(camera: Maybe(Camera)) {
 	} else {
 		s.view_matrix = 1
 	}
-
-	s.rb.set_view_projection_matrix(s.proj_matrix * s.view_matrix)
 }
 
 load_texture_from_file :: proc(filename: string) -> Texture {
@@ -238,6 +236,64 @@ draw_rect :: proc(r: Rect, c: Color) {
 	_batch_vertex({r.x, r.y + r.h}, {0, 1}, c)
 }
 
+draw_rect_ex :: proc(r: Rect, origin: Vec2, rot: f32, c: Color) {
+	if s.batch_texture != TEXTURE_NONE && s.batch_texture != s.shape_drawing_texture {
+		draw_current_batch()
+	}
+
+	r := r
+
+	r.x -= origin.x
+	r.y -= origin.y
+
+	s.batch_texture = s.shape_drawing_texture
+	tl, tr, bl, br: Vec2
+
+	// Rotation adapted from Raylib's "DrawTexturePro"
+	if rot == 0 {
+		x := r.x - origin.x
+		y := r.y - origin.y
+		tl = { x,         y }
+		tr = { x + r.w, y }
+		bl = { x,         y + r.h }
+		br = { x + r.w, y + r.h }
+	} else {
+		sin_rot := math.sin(rot * math.RAD_PER_DEG)
+		cos_rot := math.cos(rot * math.RAD_PER_DEG)
+		x := r.x
+		y := r.y
+		dx := -origin.x
+		dy := -origin.y
+
+		tl = {
+			x + dx * cos_rot - dy * sin_rot,
+			y + dx * sin_rot + dy * cos_rot,
+		}
+
+		tr = {
+			x + (dx + r.w) * cos_rot - dy * sin_rot,
+			y + (dx + r.w) * sin_rot + dy * cos_rot,
+		}
+
+		bl = {
+			x + dx * cos_rot - (dy + r.h) * sin_rot,
+			y + dx * sin_rot + (dy + r.h) * cos_rot,
+		}
+
+		br = {
+			x + (dx + r.w) * cos_rot - (dy + r.h) * sin_rot,
+			y + (dx + r.w) * sin_rot + (dy + r.h) * cos_rot,
+		}
+	}
+	
+	_batch_vertex(tl, {0, 0}, c)
+	_batch_vertex(tr, {1, 0}, c)
+	_batch_vertex(br, {1, 1}, c)
+	_batch_vertex(tl, {0, 0}, c)
+	_batch_vertex(br, {1, 1}, c)
+	_batch_vertex(bl, {0, 1}, c)
+}
+
 draw_rect_outline :: proc(r: Rect, thickness: f32, color: Color) {
 	t := thickness
 	
@@ -282,7 +338,15 @@ draw_circle :: proc(center: Vec2, radius: f32, color: Color) {
 }
 
 draw_line :: proc(start: Vec2, end: Vec2, thickness: f32, color: Color) {
-	
+	p := Vec2{start.x, start.y + thickness*0.5}
+	s := Vec2{linalg.length(end - start), thickness}
+
+	origin := Vec2 {0, thickness*0.5}
+	r := Rect {p.x, p.y, s.x, s.y}
+
+	rot := math.atan2(end.y - start.y, end.x - start.x)
+
+	draw_rect_ex(r, origin, rot * math.DEG_PER_RAD, color)
 }
 
 draw_texture :: proc(tex: Texture, pos: Vec2, tint := WHITE) {