1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
|
package fw
import "core:log"
import "core:math/linalg"
import "vendor:glfw"
Vec2 :: [2]f32
Vec2i :: [2]i32
Vec3 :: [3]f32
Vec4 :: [4]f32
Color :: [4]f32
Mat4 :: matrix[4, 4]f32
Rect :: struct {
start: Vec2,
size: Vec2,
}
Config :: struct {
win_name: cstring,
win_size: Vec2i,
screen_size: Vec2i,
renderer_backend: Renderer_Backend,
}
@(private) window: glfw.WindowHandle
@(private) last_frame: f64
@(private) dt: f64
rgba8 :: proc(r: u8, g: u8, b: u8, a: u8 = 255) -> Color {
return Color{
f32(r) / 255,
f32(g) / 255,
f32(b) / 255,
f32(a) / 255,
}
}
init :: proc(config: Config) {
if !glfw.Init() {
panic("could not init glfw window")
}
glfw.WindowHint(glfw.CONTEXT_VERSION_MAJOR, 3)
glfw.WindowHint(glfw.CONTEXT_VERSION_MINOR, 3)
glfw.WindowHint(glfw.RESIZABLE, false)
glfw.WindowHint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
window = glfw.CreateWindow(
config.win_size.x,
config.win_size.y,
config.win_name,
nil,
nil,
)
if window == nil {
panic("could not create glfw window")
}
glfw.SwapInterval(1)
_renderer_init(config)
}
deinit :: proc() {
_renderer_deinit()
glfw.DestroyWindow(window)
glfw.Terminate()
}
next_frame :: proc() -> bool {
// End the previous frame
if can_flush() {
flush_batch(&renderer.draw_call)
new_batch(renderer.white_1x1.handle, .None, false)
}
view := renderer.view
renderer.view = linalg.MATRIX4F32_IDENTITY
renderer.vt.end_frame()
renderer.view = view
new_batch(renderer.white_1x1.handle, .None, false)
renderer.draw_calls_count = renderer._draw_call_counter
renderer._draw_call_counter = 0
glfw.SwapBuffers(window)
glfw.PollEvents()
_update_input()
// log.debugf("Draw calls: %v", renderer.draw_calls_count)
// Begin next frame
time := get_time()
dt = time - last_frame
last_frame = time
renderer.vt.clear({0, 0, 0, 1})
renderer.vt.start_frame()
renderer.vt.clear(renderer.bg_col)
return !bool(glfw.WindowShouldClose(window))
}
@(require_results)
get_time :: #force_inline proc() -> f64 {
return glfw.GetTime()
}
@(require_results)
get_delta_time :: #force_inline proc() -> f64 {
return dt
}
|
