sharkk/corvette public

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

package render_ir_tests

import ir "../../render_ir"
import "core:testing"

@(test)
test_add_buffer_texture_sampler_helpers :: proc(t: ^testing.T) {
	frame := ir.init_frame_ir()
	defer ir.destroy_frame_ir(&frame)

	buffer := ir.add_buffer(&frame, "vertices", 256, {.Vertex, .Transfer_Dst}, {.Device_Local})
	texture := ir.add_texture(&frame, "color", 64, 32, .R8G8B8A8_SRGB, {.Sampled}, .Transient)
	sampler := ir.add_sampler(
		&frame,
		"nearest",
		{
			mag_filter = .Nearest,
			min_filter = .Nearest,
			address_mode_u = .Clamp_To_Edge,
			address_mode_v = .Clamp_To_Border,
			enable_aniso = true,
			enable_compare = true,
			compare_op = .Less_Or_Equal,
			mipmap_mode = .Nearest,
		},
		.Imported,
	)

	buffer_desc, buffer_ok := ir.get_resource(&frame, buffer)
	testing.expect(t, buffer_ok)
	testing.expect(t, buffer_desc.kind == .Buffer)
	testing.expect(t, buffer_desc.lifetime == .Persistent)
	testing.expect_value(t, buffer_desc.buffer.size, u64(256))
	testing.expect(t, .Vertex in buffer_desc.buffer.usage)
	testing.expect(t, .Transfer_Dst in buffer_desc.buffer.usage)
	testing.expect(t, .Device_Local in buffer_desc.buffer.memory)

	texture_desc, texture_ok := ir.get_resource(&frame, texture)
	testing.expect(t, texture_ok)
	testing.expect(t, texture_desc.kind == .Texture)
	testing.expect(t, texture_desc.lifetime == .Transient)
	testing.expect_value(t, texture_desc.texture.width, u32(64))
	testing.expect_value(t, texture_desc.texture.height, u32(32))
	testing.expect(t, texture_desc.texture.format == .R8G8B8A8_SRGB)
	testing.expect(t, .Sampled in texture_desc.texture.usage)

	sampler_desc, sampler_ok := ir.get_resource(&frame, sampler)
	testing.expect(t, sampler_ok)
	testing.expect(t, sampler_desc.kind == .Sampler)
	testing.expect(t, sampler_desc.lifetime == .Imported)
	testing.expect(t, sampler_desc.sampler.mag_filter == .Nearest)
	testing.expect(t, sampler_desc.sampler.min_filter == .Nearest)
	testing.expect(t, sampler_desc.sampler.address_mode_u == .Clamp_To_Edge)
	testing.expect(t, sampler_desc.sampler.address_mode_v == .Clamp_To_Border)
	testing.expect(t, sampler_desc.sampler.enable_aniso)
	testing.expect(t, sampler_desc.sampler.enable_compare)
	testing.expect(t, sampler_desc.sampler.compare_op == .Less_Or_Equal)
	testing.expect(t, sampler_desc.sampler.mipmap_mode == .Nearest)
}

@(test)
test_resource_lifetime_zero_value_is_persistent :: proc(t: ^testing.T) {
	frame := ir.init_frame_ir()
	defer ir.destroy_frame_ir(&frame)

	handle := ir.add_resource(&frame, {kind = .Buffer, name = "raw", buffer = {size = 1}})
	desc, ok := ir.get_resource(&frame, handle)

	testing.expect(t, ok)
	testing.expect(t, desc.lifetime == .Persistent)
}

@(test)
test_resource_flag_formatters :: proc(t: ^testing.T) {
	testing.expect_value(t, ir.format_buffer_usage_flags({}), "None")
	testing.expect_value(
		t,
		ir.format_buffer_usage_flags({.Vertex, .Transfer_Dst}),
		"Vertex|Transfer_Dst",
	)
	testing.expect_value(t, ir.format_memory_property_flags({}), "None")
	testing.expect_value(
		t,
		ir.format_memory_property_flags({.Host_Visible, .Host_Coherent}),
		"Host_Visible|Host_Coherent",
	)
	testing.expect_value(t, ir.format_texture_usage_flags({}), "None")
	testing.expect_value(
		t,
		ir.format_texture_usage_flags({.Sampled, .Transfer_Src}),
		"Sampled|Transfer_Src",
	)
}