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
120
121
122
123
124
125
126
127
|
const std = @import("std");
const Allocator = std.mem.Allocator;
const assert = std.debug.assert;
const gl = @import("opengl");
const OpenGL = @import("../OpenGL.zig");
const log = std.log.scoped(.opengl);
/// Options for initializing a buffer.
pub const Options = struct {
target: gl.Buffer.Target = .array,
usage: gl.Buffer.Usage = .dynamic_draw,
};
/// OpenGL data storage for a certain set of equal types. This is usually
/// used for vertex buffers, etc. This helpful wrapper makes it easy to
/// prealloc, shrink, grow, sync, buffers with OpenGL.
pub fn Buffer(comptime T: type) type {
return struct {
const Self = @This();
/// Underlying `gl.Buffer` instance.
buffer: gl.Buffer,
/// Options this buffer was allocated with.
opts: Options,
/// Current allocated length of the data store.
/// Note this is the number of `T`s, not the size in bytes.
len: usize,
/// Initialize a buffer with the given length pre-allocated.
pub fn init(opts: Options, len: usize) !Self {
const buffer = try gl.Buffer.create();
errdefer buffer.destroy();
const binding = try buffer.bind(opts.target);
defer binding.unbind();
try binding.setDataNullManual(len * @sizeOf(T), opts.usage);
return .{
.buffer = buffer,
.opts = opts,
.len = len,
};
}
/// Init the buffer filled with the given data.
pub fn initFill(opts: Options, data: []const T) !Self {
const buffer = try gl.Buffer.create();
errdefer buffer.destroy();
const binding = try buffer.bind(opts.target);
defer binding.unbind();
try binding.setData(data, opts.usage);
return .{
.buffer = buffer,
.opts = opts,
.len = data.len * @sizeOf(T),
};
}
pub fn deinit(self: Self) void {
self.buffer.destroy();
}
/// Sync new contents to the buffer. The data is expected to be the
/// complete contents of the buffer. If the amount of data is larger
/// than the buffer length, the buffer will be reallocated.
///
/// If the amount of data is smaller than the buffer length, the
/// remaining data in the buffer is left untouched.
pub fn sync(self: *Self, data: []const T) !void {
const binding = try self.buffer.bind(self.opts.target);
defer binding.unbind();
// If we need more space than our buffer has, we need to reallocate.
if (data.len > self.len) {
// Reallocate the buffer to hold double what we require.
self.len = data.len * 2;
try binding.setDataNullManual(
self.len * @sizeOf(T),
self.opts.usage,
);
}
// We can fit within the buffer so we can just replace bytes.
try binding.setSubData(0, data);
}
/// Like Buffer.sync but takes data from an array of ArrayLists,
/// rather than a single array. Returns the number of items synced.
pub fn syncFromArrayLists(self: *Self, lists: []const std.ArrayListUnmanaged(T)) !usize {
const binding = try self.buffer.bind(self.opts.target);
defer binding.unbind();
var total_len: usize = 0;
for (lists) |list| {
total_len += list.items.len;
}
// If we need more space than our buffer has, we need to reallocate.
if (total_len > self.len) {
// Reallocate the buffer to hold double what we require.
self.len = total_len * 2;
try binding.setDataNullManual(
self.len * @sizeOf(T),
self.opts.usage,
);
}
// We can fit within the buffer so we can just replace bytes.
var i: usize = 0;
for (lists) |list| {
try binding.setSubData(i, list.items);
i += list.items.len * @sizeOf(T);
}
return total_len;
}
};
}
|
