1756 lines
51 KiB
Zig
1756 lines
51 KiB
Zig
const std = @import("std");
|
|
const log = std.log.scoped(.graphics);
|
|
const assert = std.debug.assert;
|
|
const Allocator = std.mem.Allocator;
|
|
|
|
const sokol = @import("sokol");
|
|
const sg = sokol.gfx;
|
|
const sapp = sokol.app;
|
|
const sglue = sokol.glue;
|
|
|
|
const Math = @import("math");
|
|
const Vec2 = Math.Vec2;
|
|
const Vec4 = Math.Vec4;
|
|
const Mat4 = Math.Mat4;
|
|
const Rect = Math.Rect;
|
|
|
|
const STBRectPack = @import("stb_rect_pack");
|
|
const ImGUI = @import("imgui.zig");
|
|
pub const Color = @import("./color.zig");
|
|
const shd = @import("shader");
|
|
const SlotMapType = @import("slot_map.zig").SlotMapType;
|
|
|
|
const Frame = struct {
|
|
index: u32,
|
|
quads: std.ArrayList(VertexQuad),
|
|
transforms: std.ArrayList(TransformFrame),
|
|
|
|
window_size: Vec2,
|
|
clear_color: Color = .black,
|
|
pass_started: bool = false
|
|
};
|
|
|
|
const State = struct {
|
|
gpa: std.mem.Allocator,
|
|
|
|
frame: Frame,
|
|
|
|
shader: sg.Shader,
|
|
pipeline: sg.Pipeline,
|
|
bindings: sg.Bindings,
|
|
|
|
default_sprite: Sprite.Id,
|
|
error_sprite: Sprite.Id,
|
|
default_spritesheet: Spritesheet.Id,
|
|
|
|
linear_sampler: sg.Sampler,
|
|
nearest_sampler: sg.Sampler,
|
|
default_sampler: Sampler,
|
|
|
|
quads_buffer: [8192]VertexQuad,
|
|
transforms_buffer: [32]TransformFrame,
|
|
|
|
textures_buffer: [Texture.max_textures]Texture.SlotMap.Slot,
|
|
textures: Texture.SlotMap,
|
|
|
|
spritesheets_buffer: [Spritesheet.max_spritesheets]Spritesheet.SlotMap.Slot,
|
|
spritesheets: Spritesheet.SlotMap,
|
|
|
|
sprites_buffer: [Sprite.max_sprites]Sprite.SlotMap.Slot,
|
|
sprites: Sprite.SlotMap,
|
|
};
|
|
|
|
var g_state: State = undefined;
|
|
|
|
pub fn init(gpa: std.mem.Allocator, logger: sg.Logger) !void {
|
|
const self = &g_state;
|
|
|
|
sg.setup(.{
|
|
.environment = sglue.environment(),
|
|
.logger = logger
|
|
});
|
|
|
|
const shader = sg.makeShader(shd.mainShaderDesc(sg.queryBackend()));
|
|
assert(shader.id != sg.invalid_id);
|
|
|
|
const linear_sampler = sg.makeSampler(.{
|
|
.min_filter = .LINEAR,
|
|
.mag_filter = .LINEAR,
|
|
.label = "linear-sampler"
|
|
});
|
|
assert(linear_sampler.id != sg.invalid_id);
|
|
|
|
const nearest_sampler = sg.makeSampler(.{
|
|
.min_filter = .NEAREST,
|
|
.mag_filter = .NEAREST,
|
|
.label = "nearest-sampler"
|
|
});
|
|
assert(linear_sampler.id != sg.invalid_id);
|
|
|
|
const pipeline = sg.makePipeline(.{
|
|
.primitive_type = .TRIANGLES,
|
|
.index_type = .UINT16,
|
|
.cull_mode = .BACK,
|
|
.colors = init: {
|
|
var s: [8]sg.ColorTargetState = @splat(.{});
|
|
s[0] = .{
|
|
.blend = .{
|
|
.enabled = true,
|
|
|
|
.src_factor_rgb = .ONE,
|
|
.dst_factor_rgb = .ONE_MINUS_SRC_ALPHA,
|
|
.op_rgb = .ADD,
|
|
|
|
.src_factor_alpha = .ONE,
|
|
.dst_factor_alpha = .ONE_MINUS_SRC_ALPHA,
|
|
.op_alpha = .ADD,
|
|
}
|
|
};
|
|
break :init s;
|
|
},
|
|
.shader = shader,
|
|
.layout = init: {
|
|
var l = sg.VertexLayoutState{};
|
|
l.attrs[shd.ATTR_main_position].format = .FLOAT2;
|
|
l.attrs[shd.ATTR_main_texcoord0].format = .FLOAT2;
|
|
l.attrs[shd.ATTR_main_color0].format = .FLOAT4;
|
|
break :init l;
|
|
},
|
|
.label = "main-pipeline"
|
|
});
|
|
assert(pipeline.id != sg.invalid_id);
|
|
|
|
var bindings: sg.Bindings = .{};
|
|
{
|
|
const max_quads = self.quads_buffer.len;
|
|
|
|
bindings.vertex_buffers[0] = sg.makeBuffer(.{
|
|
.size = @sizeOf(VertexQuad) * max_quads,
|
|
.usage = .{ .vertex_buffer = true, .dynamic_update = true },
|
|
.label = "quad-vertices"
|
|
});
|
|
|
|
const index_count = max_quads * 6;
|
|
var indices: []u16 = try gpa.alloc(u16, index_count);
|
|
defer gpa.free(indices);
|
|
for (0..max_quads) |i| {
|
|
indices[6*i + 0] = @intCast(4*i + 0);
|
|
indices[6*i + 1] = @intCast(4*i + 1);
|
|
indices[6*i + 2] = @intCast(4*i + 2);
|
|
|
|
indices[6*i + 3] = @intCast(4*i + 1);
|
|
indices[6*i + 4] = @intCast(4*i + 3);
|
|
indices[6*i + 5] = @intCast(4*i + 2);
|
|
}
|
|
|
|
bindings.index_buffer = sg.makeBuffer(.{
|
|
.data = sg.asRange(indices),
|
|
.usage = .{ .index_buffer = true, },
|
|
.label = "indices"
|
|
});
|
|
}
|
|
|
|
self.* = State{
|
|
.gpa = gpa,
|
|
.shader = shader,
|
|
.pipeline = pipeline,
|
|
.bindings = bindings,
|
|
.quads_buffer = undefined,
|
|
.transforms_buffer = undefined,
|
|
.default_sprite = undefined,
|
|
.error_sprite = undefined,
|
|
.default_spritesheet = undefined,
|
|
|
|
.linear_sampler = linear_sampler,
|
|
.nearest_sampler = nearest_sampler,
|
|
.default_sampler = .nearest,
|
|
|
|
.textures_buffer = undefined,
|
|
.textures = .initBuffer(&self.textures_buffer),
|
|
|
|
.sprites_buffer = undefined,
|
|
.sprites = .initBuffer(&self.sprites_buffer),
|
|
|
|
.spritesheets_buffer = undefined,
|
|
.spritesheets = .initBuffer(&self.spritesheets_buffer),
|
|
|
|
.frame = .{
|
|
.index = 0,
|
|
.quads = .initBuffer(&self.quads_buffer),
|
|
.transforms = .initBuffer(&self.transforms_buffer),
|
|
.clear_color = .black,
|
|
.window_size = .init(0, 0)
|
|
}
|
|
};
|
|
|
|
self.default_spritesheet = initSpritesheet(.{});
|
|
|
|
{
|
|
const width = 6;
|
|
const height = 6;
|
|
|
|
var pixels: [width * height * 4]u8 = undefined;
|
|
@memset(&pixels, 0xFF);
|
|
|
|
self.default_sprite = initSprite(.{ .padding = 1 });
|
|
setSprite(self.default_sprite, .{
|
|
.mipchain = .initSingle(Image{
|
|
.width = width,
|
|
.height = height,
|
|
.format = .rgba8,
|
|
.pixels = &pixels,
|
|
})
|
|
});
|
|
}
|
|
|
|
{
|
|
const width = 6;
|
|
const height = 6;
|
|
|
|
var pixels: [width * height * 4]u8 = undefined;
|
|
for (0..height) |y| {
|
|
for (0..width) |x| {
|
|
const pixel_index = y * width + x;
|
|
|
|
var color: Color = undefined;
|
|
if ((pixel_index+y) % 2 == 0) {
|
|
color = .purple;
|
|
} else {
|
|
color = .black;
|
|
}
|
|
|
|
const pixel = pixels[(4*pixel_index)..];
|
|
pixel[0] = @intFromFloat(color.r*255);
|
|
pixel[1] = @intFromFloat(color.g*255);
|
|
pixel[2] = @intFromFloat(color.b*255);
|
|
pixel[3] = @intFromFloat(color.a*255);
|
|
}
|
|
}
|
|
|
|
self.error_sprite = initSprite(.{ .padding = 1 });
|
|
setSprite(self.error_sprite, .{
|
|
.mipchain = .initSingle(.{
|
|
.width = width,
|
|
.height = height,
|
|
.format = .rgba8,
|
|
.pixels = &pixels,
|
|
})
|
|
});
|
|
}
|
|
}
|
|
|
|
pub fn deinit() void {
|
|
const self = &g_state;
|
|
|
|
var sprite_iter = self.sprites.iterator();
|
|
while (sprite_iter.next()) |sprite_id| {
|
|
const sprite = self.sprites.getAssumeExists(sprite_id);
|
|
sprite.arena.deinit();
|
|
}
|
|
|
|
sg.shutdown();
|
|
}
|
|
|
|
fn toSokolColor(color: Color) sokol.gfx.Color {
|
|
// TODO: Assert and do cast
|
|
return sokol.gfx.Color{
|
|
.r = color.r,
|
|
.g = color.g,
|
|
.b = color.b,
|
|
.a = color.a,
|
|
};
|
|
}
|
|
|
|
fn getTransformPtr() ?*TransformFrame {
|
|
const self = &g_state;
|
|
if (self.frame.transforms.items.len == 0) {
|
|
return null;
|
|
}
|
|
|
|
return &self.frame.transforms.items[self.frame.transforms.items.len-1];
|
|
}
|
|
|
|
pub fn transformTranslate(offset: Vec2) void {
|
|
const top_frame = getTransformPtr() orelse return;
|
|
|
|
top_frame.offset = top_frame.offset.add(offset.multiply(top_frame.scale));
|
|
}
|
|
|
|
pub fn transformScale(scale: Vec2) void {
|
|
const top_frame = getTransformPtr() orelse return;
|
|
|
|
top_frame.scale = top_frame.scale.multiply(scale);
|
|
}
|
|
|
|
pub fn transformPush() void {
|
|
const self = &g_state;
|
|
|
|
const top_frame = getTransformPtr() orelse return;
|
|
|
|
self.frame.transforms.appendBounded(top_frame.*) catch {
|
|
log.warn("Transform stack limit reached!", .{});
|
|
};
|
|
}
|
|
|
|
pub fn transformPop() void {
|
|
const self = &g_state;
|
|
_ = self.frame.transforms.pop();
|
|
}
|
|
|
|
pub fn getTransform() TransformFrame {
|
|
if (getTransformPtr()) |top_frame| {
|
|
return top_frame.*;
|
|
} else {
|
|
return TransformFrame{
|
|
.offset = .init(0, 0),
|
|
.scale = .init(1, 1)
|
|
};
|
|
}
|
|
}
|
|
|
|
pub fn beginFrame() void {
|
|
const self = &g_state;
|
|
|
|
self.frame.quads.clearRetainingCapacity();
|
|
self.frame.transforms.clearRetainingCapacity();
|
|
self.frame = Frame{
|
|
.index = self.frame.index,
|
|
.quads = self.frame.quads,
|
|
.transforms = self.frame.transforms,
|
|
.window_size = Vec2.init(sapp.widthf(), sapp.heightf())
|
|
};
|
|
|
|
self.frame.transforms.appendAssumeCapacity(TransformFrame{
|
|
.offset = .init(0, 0),
|
|
.scale = .init(1, 1),
|
|
});
|
|
|
|
self.bindings.views[shd.VIEW_tex].id = sg.invalid_id;
|
|
self.bindings.samplers[shd.SMP_smp] = self.linear_sampler;
|
|
}
|
|
|
|
pub fn showDebug() void {
|
|
const self = &g_state;
|
|
|
|
_ = ImGUI.beginTabBar("graphics tab bar");
|
|
defer ImGUI.endTabBar();
|
|
|
|
if (ImGUI.beginTabItem("Spritesheets")) {
|
|
defer ImGUI.endTabItem();
|
|
|
|
if(ImGUI.beginTable("spritesheets", 2, .{})) {
|
|
defer ImGUI.endTable();
|
|
|
|
ImGUI.tableSetupColumn("ID", .{});
|
|
ImGUI.tableSetupColumn("Size", .{});
|
|
ImGUI.tableHeadersRow();
|
|
|
|
var spritesheet_iter = self.spritesheets.iterator();
|
|
while (spritesheet_iter.next()) |spritesheet_id| {
|
|
const spritesheet = self.spritesheets.getAssumeExists(spritesheet_id);
|
|
|
|
ImGUI.pushID(.{ .int = spritesheet_id.index });
|
|
defer ImGUI.popID();
|
|
|
|
ImGUI.tableNextRow();
|
|
|
|
ImGUI.tableNextColumn();
|
|
ImGUI.text("{{ {}, {} }}", .{spritesheet_id.index, spritesheet_id.generation});
|
|
|
|
ImGUI.tableNextColumn();
|
|
ImGUI.text("{}x{}", .{spritesheet.size.x, spritesheet.size.x});
|
|
}
|
|
}
|
|
}
|
|
|
|
if (ImGUI.beginTabItem("Sprites")) {
|
|
defer ImGUI.endTabItem();
|
|
|
|
if(ImGUI.beginTable("sprites", 2, .{})) {
|
|
defer ImGUI.endTable();
|
|
|
|
ImGUI.tableSetupColumn("ID", .{});
|
|
ImGUI.tableSetupColumn("Position", .{});
|
|
ImGUI.tableHeadersRow();
|
|
|
|
var sprite_iter = self.sprites.iterator();
|
|
while (sprite_iter.next()) |sprite_id| {
|
|
const sprite = self.sprites.getAssumeExists(sprite_id);
|
|
|
|
ImGUI.pushID(.{ .int = sprite_id.index });
|
|
defer ImGUI.popID();
|
|
|
|
ImGUI.tableNextRow();
|
|
|
|
ImGUI.tableNextColumn();
|
|
ImGUI.text("{{ {}, {} }}", .{sprite_id.index, sprite_id.generation});
|
|
|
|
ImGUI.tableNextColumn();
|
|
if (sprite.position) |position| {
|
|
ImGUI.text("{:3}, {:3}", .{position.x, position.y});
|
|
} else {
|
|
ImGUI.text("null", .{});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn setClearColor(color: Color) void {
|
|
const self = &g_state;
|
|
self.frame.clear_color = color;
|
|
}
|
|
|
|
pub fn getWindowSize() Vec2 {
|
|
const self = &g_state;
|
|
return self.frame.window_size;
|
|
}
|
|
|
|
pub fn getFrameIndex() u32 {
|
|
const self = &g_state;
|
|
return self.frame.index;
|
|
}
|
|
|
|
pub fn flush() void {
|
|
const self = &g_state;
|
|
|
|
if (self.frame.quads.items.len == 0) {
|
|
return;
|
|
}
|
|
defer self.frame.quads.clearRetainingCapacity();
|
|
|
|
if (!self.frame.pass_started) {
|
|
var pass_action: sg.PassAction = .{};
|
|
pass_action.colors[0] = .{
|
|
.load_action = .CLEAR,
|
|
.clear_value = toSokolColor(self.frame.clear_color)
|
|
};
|
|
|
|
sg.beginPass(.{
|
|
.action = pass_action,
|
|
.swapchain = sglue.swapchain()
|
|
});
|
|
self.frame.pass_started = true;
|
|
}
|
|
|
|
var spritesheet_iter = self.spritesheets.iterator();
|
|
while (spritesheet_iter.next()) |spritesheet_id| {
|
|
const spritesheet = self.spritesheets.getAssumeExists(spritesheet_id);
|
|
const texture = self.textures.get(spritesheet.texture) orelse continue;
|
|
if (isViewBound(texture.view)) {
|
|
rebuildSpritesheetTextureIfNeeded(spritesheet_id);
|
|
}
|
|
}
|
|
|
|
if (sg.queryViewState(getBoundView().*) != .VALID) {
|
|
log.warn("Attempt to use view which isn't valid", .{});
|
|
return;
|
|
}
|
|
|
|
const vertex_buffer = self.bindings.vertex_buffers[0];
|
|
|
|
const data = sg.asRange(self.frame.quads.items);
|
|
if (sg.queryBufferWillOverflow(vertex_buffer, data.size)) {
|
|
log.warn("Vertex buffer overflow", .{});
|
|
return;
|
|
}
|
|
|
|
self.bindings.vertex_buffer_offsets[0] = sg.appendBuffer(vertex_buffer, data);
|
|
|
|
const window_size = Vec2.init(sapp.widthf(), sapp.heightf());
|
|
|
|
var mvp = Mat4.initIdentity();
|
|
{
|
|
// Convert normalized [-1; 1] coordinates to [0; 1]
|
|
mvp = mvp.multiply(Mat4.initTranslate(.{ .x = -1, .y = -1, .z = 0 }));
|
|
mvp = mvp.multiply(Mat4.initScale(.{ .x = 2, .y = 2, .z = 0 }));
|
|
|
|
// Make the top-left corner (0,0)
|
|
mvp = mvp.multiply(Mat4.initTranslate(.{ .x = 0, .y = 1, .z = 0 }));
|
|
mvp = mvp.multiply(Mat4.initScale(.{ .x = 1, .y = -1, .z = 0 }));
|
|
|
|
// Scretch [0; 1] so that they map 1-to-1 on to screen coordinates.
|
|
mvp = mvp.multiply(Mat4.initScale(.{
|
|
.x = 1/window_size.x,
|
|
.y = 1/window_size.y,
|
|
.z = 0
|
|
}));
|
|
}
|
|
|
|
var vs_params: shd.VsParams = .{
|
|
.mvp = mvp
|
|
};
|
|
var fs_params: shd.FsParams = .{
|
|
.texture_mode = 0,
|
|
};
|
|
const image = sg.queryViewImage(getBoundView().*);
|
|
if (sg.queryImagePixelformat(image) == .R8) {
|
|
fs_params.texture_mode = 1;
|
|
}
|
|
|
|
sg.applyPipeline(self.pipeline);
|
|
sg.applyBindings(self.bindings);
|
|
sg.applyUniforms(shd.UB_vs_params, sg.asRange(&vs_params));
|
|
sg.applyUniforms(shd.UB_fs_params, sg.asRange(&fs_params));
|
|
assert(self.frame.quads.items.len > 0);
|
|
sg.draw(0, @intCast(self.frame.quads.items.len * 6), 1);
|
|
}
|
|
|
|
pub fn endFrame() void {
|
|
const self = &g_state;
|
|
|
|
flush();
|
|
|
|
if (self.frame.pass_started) {
|
|
sg.endPass();
|
|
sg.commit();
|
|
}
|
|
|
|
var spritesheet_iter = self.spritesheets.iterator();
|
|
while (spritesheet_iter.next()) |spritesheet_id| {
|
|
repackSpritesheetIfNeeded(spritesheet_id);
|
|
}
|
|
|
|
if (self.frame.transforms.items.len > 1) {
|
|
log.warn("Too many calls to transformPush()", .{});
|
|
} else if (self.frame.transforms.items.len == 0) {
|
|
log.warn("Too many calls to transformPop()", .{});
|
|
}
|
|
|
|
self.frame.index += 1;
|
|
}
|
|
|
|
pub fn drawRectangle(pos: Vec2, size: Vec2, color: Color) void {
|
|
drawQuad(Quad.initRect(pos, size), color);
|
|
}
|
|
|
|
pub fn drawQuad(quad: Quad, color: Color) void {
|
|
const self = &g_state;
|
|
|
|
drawSpriteQuad(self.default_sprite, quad, color);
|
|
}
|
|
|
|
pub fn drawRectangleOutline(pos: Vec2, size: Vec2, color: Color, width: f32, alignment: f32) void {
|
|
const self = &g_state;
|
|
|
|
const outer_rect = (Rect{ .pos = pos, .size = size }).grow(Vec2.init(width, width).multiplyScalar(1-alignment));
|
|
const inner_rect = (Rect{ .pos = pos, .size = size }).shrink(Vec2.init(width, width).multiplyScalar(alignment));
|
|
|
|
drawSpriteQuad(
|
|
self.default_sprite,
|
|
.init(.{
|
|
.init(outer_rect.right(), outer_rect.top()),
|
|
.init(outer_rect.left(), outer_rect.top()),
|
|
.init(inner_rect.right(), inner_rect.top()),
|
|
.init(inner_rect.left(), inner_rect.top()),
|
|
}),
|
|
color
|
|
);
|
|
drawSpriteQuad(
|
|
self.default_sprite,
|
|
.init(.{
|
|
.init(outer_rect.right(), outer_rect.top()),
|
|
.init(inner_rect.right(), inner_rect.top()),
|
|
.init(outer_rect.right(), outer_rect.bottom()),
|
|
.init(inner_rect.right(), inner_rect.bottom()),
|
|
}),
|
|
color
|
|
);
|
|
drawSpriteQuad(
|
|
self.default_sprite,
|
|
.init(.{
|
|
.init(outer_rect.left(), outer_rect.top()),
|
|
.init(inner_rect.left(), inner_rect.top()),
|
|
.init(outer_rect.left(), outer_rect.bottom()),
|
|
.init(inner_rect.left(), inner_rect.bottom()),
|
|
}),
|
|
color
|
|
);
|
|
drawSpriteQuad(
|
|
self.default_sprite,
|
|
.init(.{
|
|
.init(outer_rect.right(), outer_rect.bottom()),
|
|
.init(outer_rect.left(), outer_rect.bottom()),
|
|
.init(inner_rect.right(), inner_rect.bottom()),
|
|
.init(inner_rect.left(), inner_rect.bottom()),
|
|
}),
|
|
color
|
|
);
|
|
}
|
|
|
|
pub fn drawLine(from: Vec2, to: Vec2, color: Color, width: f32) void {
|
|
const self = &g_state;
|
|
|
|
const step = to.sub(from).normalized().multiplyScalar(width/2);
|
|
|
|
const top_left = from.add(step.rotateLeft90());
|
|
const bottom_left = from.add(step.rotateRight90());
|
|
const top_right = to.add(step.rotateLeft90());
|
|
const bottom_right = to.add(step.rotateRight90());
|
|
|
|
drawSpriteQuad(
|
|
self.default_sprite,
|
|
.init(.{ top_right, top_left, bottom_right, bottom_left }),
|
|
color
|
|
);
|
|
}
|
|
|
|
const TextureOptions = struct {
|
|
dynamic: bool = false
|
|
};
|
|
|
|
pub fn initTexture(opts: TextureOptions) Texture.Id {
|
|
const self = &g_state;
|
|
const id = self.textures.insertUndefined() catch {
|
|
log.warn("Failed to create texture, limit reached! limit: {}", .{self.textures.slots.capacity});
|
|
return .nil;
|
|
};
|
|
|
|
const view = sg.allocView();
|
|
if (sg.queryViewState(view) != .ALLOC) {
|
|
log.warn("Failed to alloc texture view", .{});
|
|
return .nil;
|
|
}
|
|
|
|
const texture = self.textures.getAssumeExists(id);
|
|
texture.* = .{
|
|
.dynamic = opts.dynamic,
|
|
.updated_at = null,
|
|
.image = .{ .id = sg.invalid_id },
|
|
.view = view,
|
|
};
|
|
return id;
|
|
}
|
|
|
|
fn getBoundView() *sg.View {
|
|
const self = &g_state;
|
|
return &self.bindings.views[shd.VIEW_tex];
|
|
}
|
|
|
|
fn isViewBound(view: sg.View) bool {
|
|
return getBoundView().id == view.id;
|
|
}
|
|
|
|
pub fn deinitTexture(id: Texture.Id) void {
|
|
const self = &g_state;
|
|
if (id == Texture.Id.nil) {
|
|
return;
|
|
}
|
|
|
|
if (self.textures.get(id)) |texture| {
|
|
const bound_view = getBoundView();
|
|
if (bound_view.id == texture.view.id) {
|
|
bound_view.id = sg.invalid_id;
|
|
}
|
|
|
|
sg.destroyImage(texture.image);
|
|
sg.destroyView(texture.view);
|
|
self.textures.removeAssumeExists(id);
|
|
}
|
|
}
|
|
|
|
const SetTextureOptions = struct {
|
|
mipchain: Mipchain,
|
|
premultiplied: bool = false
|
|
};
|
|
|
|
pub fn setTexture(id: Texture.Id, opts: SetTextureOptions) void {
|
|
const self = &g_state;
|
|
const texture = self.textures.get(id) orelse {
|
|
log.warn("Attempt to set texture that doesn't exist: {}", .{id});
|
|
return;
|
|
};
|
|
|
|
var scratch = std.heap.ArenaAllocator.init(self.gpa);
|
|
|
|
var mipchain = opts.mipchain;
|
|
if (!opts.premultiplied) {
|
|
var new_mipchain = mipchain.clone(scratch.allocator()) catch |e| {
|
|
log.warn("Failed to clone mipmap: {}", .{e});
|
|
return;
|
|
};
|
|
|
|
new_mipchain.premultiplyAlpha();
|
|
|
|
mipchain = new_mipchain;
|
|
}
|
|
|
|
var image_data: sg.ImageData = .{};
|
|
assert(mipchain.length() <= image_data.mip_levels.len);
|
|
for (0..mipchain.length()) |index| {
|
|
const image = mipchain.getLevel(@intCast(index));
|
|
image_data.mip_levels[index] = sg.asRange(image.pixelsSlice());
|
|
}
|
|
|
|
var new_image_desc = sg.ImageDesc{
|
|
.type = ._2D,
|
|
.width = @intCast(mipchain.width),
|
|
.height = @intCast(mipchain.height),
|
|
.num_mipmaps = @intCast(@max(1, mipchain.length())),
|
|
.pixel_format = switch (mipchain.format) {
|
|
.rgba8 => .RGBA8,
|
|
.r8 => .R8,
|
|
}
|
|
};
|
|
if (texture.dynamic) {
|
|
new_image_desc.usage.dynamic_update = true;
|
|
} else {
|
|
new_image_desc.data = image_data;
|
|
}
|
|
|
|
var texture_updated: bool = false;
|
|
if (sg.queryImageState(texture.image) == .VALID) {
|
|
const image_desc = sg.queryImageDesc(texture.image);
|
|
if (image_desc.width == new_image_desc.width and
|
|
image_desc.height == new_image_desc.height and
|
|
image_desc.num_mipmaps == new_image_desc.num_mipmaps and
|
|
image_desc.pixel_format == new_image_desc.pixel_format and
|
|
image_desc.usage.dynamic_update == new_image_desc.usage.dynamic_update and
|
|
image_desc.usage.immutable == new_image_desc.usage.immutable and
|
|
image_desc.usage.dynamic_update
|
|
) {
|
|
log.debug("[{}] Update texture '{f}'", .{self.frame.index, id});
|
|
if (texture.updated_at == null or texture.updated_at.? != self.frame.index) {
|
|
sg.updateImage(texture.image, image_data);
|
|
texture_updated = true;
|
|
texture.updated_at = self.frame.index;
|
|
} else {
|
|
log.warn("Attempt to update the same texture multiple times per frame, texture: {f}", .{id});
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!texture_updated) {
|
|
log.debug("[{}] Create image-view, texture={f}", .{self.frame.index, id});
|
|
const new_image = sg.makeImage(new_image_desc);
|
|
if (sg.queryImageState(new_image) != .VALID) {
|
|
log.warn("makeImage() failed", .{});
|
|
return;
|
|
}
|
|
|
|
if (sg.queryViewState(texture.view) == .VALID) {
|
|
sg.uninitView(texture.view);
|
|
}
|
|
sg.initView(texture.view, .{
|
|
.texture = .{ .image = new_image }
|
|
});
|
|
if (sg.queryViewState(texture.view) != .VALID) {
|
|
log.warn("makeView() failed", .{});
|
|
return;
|
|
}
|
|
|
|
sg.destroyImage(texture.image);
|
|
texture.image = new_image;
|
|
texture.updated_at = null;
|
|
|
|
log.debug("is dynamic {f}, {}", .{id, texture.dynamic});
|
|
if (texture.dynamic) {
|
|
log.debug("update texture {f}", .{id});
|
|
sg.updateImage(new_image, image_data);
|
|
texture.updated_at = self.frame.index;
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn drawTexture(id: Texture.Id, pos: Vec2, size: Vec2, color: Color) void {
|
|
var quad: VertexQuad = undefined;
|
|
quad.setColor(color);
|
|
quad.setRect(.{ .pos = pos, .size = size });
|
|
quad.setUVRect(.init(0, 0, 1, 1));
|
|
|
|
draw(.{
|
|
.texture = id,
|
|
.quad = quad
|
|
});
|
|
}
|
|
|
|
pub fn setDefaultSampler(sampler: Sampler) void {
|
|
const self = &g_state;
|
|
self.default_sampler = sampler;
|
|
}
|
|
|
|
pub const Sampler = enum {
|
|
linear,
|
|
nearest,
|
|
};
|
|
|
|
const DrawOptions = struct {
|
|
sampler: ?Sampler = null,
|
|
texture: Texture.Id,
|
|
quad: VertexQuad
|
|
};
|
|
|
|
pub fn draw(opts: DrawOptions) void {
|
|
const self = &g_state;
|
|
|
|
var quad = opts.quad;
|
|
|
|
var view: sg.View = .{ .id = sg.invalid_id };
|
|
if (self.textures.get(opts.texture)) |texture| {
|
|
view = texture.view;
|
|
}
|
|
|
|
if (sg.queryViewState(view) != .VALID and sg.queryViewState(view) != .ALLOC) {
|
|
if (self.sprites.get(self.error_sprite)) |sprite| {
|
|
if (self.spritesheets.get(sprite.spritesheet)) |spritesheet| {
|
|
if (self.textures.get(spritesheet.texture)) |texture| {
|
|
if (getSpriteUVRect(self.error_sprite)) |uv| {
|
|
quad.setUVRect(uv);
|
|
quad.setColor(.white);
|
|
view = texture.view;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (sg.queryViewState(view) != .VALID and sg.queryViewState(view) != .ALLOC) {
|
|
log.warn("Failed to bind view", .{});
|
|
return;
|
|
}
|
|
|
|
const view_state = sg.queryViewState(view);
|
|
if (view_state == .VALID or view_state == .ALLOC) {
|
|
const bound_view = getBoundView();
|
|
if (bound_view.id != view.id) {
|
|
flush();
|
|
bound_view.* = view;
|
|
}
|
|
} else {
|
|
log.warn("Attempt to bind non-valid view: state={}", .{view_state});
|
|
return;
|
|
}
|
|
|
|
const sampler = switch (opts.sampler orelse self.default_sampler) {
|
|
.linear => self.linear_sampler,
|
|
.nearest => self.nearest_sampler,
|
|
};
|
|
const bound_sampler = &self.bindings.samplers[shd.SMP_smp];
|
|
if (bound_sampler.id != sampler.id) {
|
|
flush();
|
|
bound_sampler.* = sampler;
|
|
}
|
|
|
|
if (self.frame.quads.items.len == self.frame.quads.capacity) {
|
|
flush();
|
|
}
|
|
|
|
if (getTransformPtr()) |transform| {
|
|
for (&quad.vertices) |*vertex| {
|
|
vertex.position = transform.apply(vertex.position);
|
|
}
|
|
}
|
|
|
|
self.frame.quads.appendAssumeCapacity(quad);
|
|
}
|
|
|
|
pub const SpriteOptions = struct {
|
|
spritesheet: ?Spritesheet.Id = null,
|
|
padding: u32 = 0,
|
|
};
|
|
|
|
pub fn initSprite(opts: SpriteOptions) Sprite.Id {
|
|
const self = &g_state;
|
|
const id = self.sprites.insertUndefined() catch {
|
|
log.warn("Failed to create sprite, limit reached! limit: {}", .{self.sprites.slots.capacity});
|
|
return .nil;
|
|
};
|
|
|
|
const sprite = self.sprites.getAssumeExists(id);
|
|
sprite.* = .{
|
|
.arena = .init(self.gpa),
|
|
.spritesheet = opts.spritesheet orelse self.default_spritesheet,
|
|
.padding = opts.padding,
|
|
.mipchain = null,
|
|
.position = null,
|
|
};
|
|
|
|
return id;
|
|
}
|
|
|
|
pub fn deinitSprite(id: Sprite.Id) void {
|
|
const self = &g_state;
|
|
if (id == Sprite.Id.nil) {
|
|
return;
|
|
}
|
|
|
|
if (self.sprites.get(id)) |sprite| {
|
|
sprite.arena.deinit();
|
|
self.sprites.removeAssumeExists(id);
|
|
|
|
if (self.spritesheets.get(sprite.spritesheet)) |spritesheet| {
|
|
spritesheet.needs_repack = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
const SetSpriteOptions = struct {
|
|
mipchain: Mipchain,
|
|
rect: ?Rect = null,
|
|
premultiplied: bool = false
|
|
};
|
|
|
|
pub fn setSprite(id: Sprite.Id, opts: SetSpriteOptions) void {
|
|
const self = &g_state;
|
|
|
|
const sprite = self.sprites.get(id) orelse {
|
|
log.warn("Attempt to set sprite that doesn't exist: {}", .{id});
|
|
return;
|
|
};
|
|
|
|
const spritesheet = self.spritesheets.get(sprite.spritesheet) orelse {
|
|
log.warn("Attempt to set sprite which doesn't have spritesheet", .{});
|
|
return;
|
|
};
|
|
|
|
if (opts.mipchain.format != spritesheet.format) {
|
|
log.warn("Attempt to use image of format '{}' on a spritesheet with '{}' format", .{opts.mipchain.format, spritesheet.format});
|
|
return;
|
|
}
|
|
if (opts.mipchain.length() != spritesheet.mipmaps) {
|
|
log.warn("Attempt to use image with '{}' mipmaps on a spritesheet with '{}' mipmaps", .{opts.mipchain.length(), spritesheet.mipmaps});
|
|
return;
|
|
}
|
|
|
|
var next_mipchain: Mipchain = .none;
|
|
var next_arena = std.heap.ArenaAllocator.init(self.gpa);
|
|
errdefer next_arena.deinit();
|
|
|
|
if (opts.rect) |rect| {
|
|
const image_opts = Image.InitOptions{
|
|
.width = @trunc(rect.size.x),
|
|
.height = @trunc(rect.size.y),
|
|
.format = opts.mipchain.format
|
|
};
|
|
next_mipchain = Mipchain.initAlloc(next_arena.allocator(), image_opts, opts.mipchain.length()) catch |e| {
|
|
log.warn("Failed to create texture data: {}", .{e});
|
|
return;
|
|
};
|
|
|
|
next_mipchain.copyFromRect(opts.mipchain, 0, 0, .initTrunc(rect));
|
|
} else {
|
|
next_mipchain = opts.mipchain.clone(next_arena.allocator()) catch |e| {
|
|
log.warn("Failed to clone mipchain: {}", .{e});
|
|
return;
|
|
};
|
|
}
|
|
|
|
if (!opts.premultiplied) {
|
|
next_mipchain.premultiplyAlpha();
|
|
}
|
|
|
|
var prev_size: ?Vec2 = null;
|
|
if (sprite.mipchain) |prev_mipchain| {
|
|
prev_size = Vec2.initFromInt(u32, prev_mipchain.width, prev_mipchain.height);
|
|
}
|
|
sprite.arena.deinit();
|
|
sprite.mipchain = next_mipchain;
|
|
sprite.arena = next_arena;
|
|
|
|
const new_size = Vec2.initFromInt(u32, next_mipchain.width, next_mipchain.height);
|
|
|
|
log.debug("set sprite on {f}", .{sprite.spritesheet});
|
|
|
|
if (prev_size == null or !prev_size.?.eql(new_size) or sprite.position == null) {
|
|
sprite.position = null;
|
|
spritesheet.needs_repack = true;
|
|
}
|
|
|
|
spritesheet.needs_texture_rebuild = true;
|
|
}
|
|
|
|
// WARNING: This will change the UV coordinates of all sprites.
|
|
// It's only safe to do this operation between frames where it's guarenteed that sprites aren't being used.
|
|
fn repackSpritesheet(id: Spritesheet.Id) void {
|
|
const self = &g_state;
|
|
|
|
const spritesheet = self.spritesheets.get(id) orelse {
|
|
log.warn("Attempt to repack spritesheet which doesn't exist", .{});
|
|
return;
|
|
};
|
|
|
|
log.debug("[{}] Repack spritesheet: {f}", .{self.frame.index, id});
|
|
|
|
// TODO: Add a smarter startegy for picking the initial texture size.
|
|
// One idea is to calculate the sum area of all sprites and pick a atlas size based on that.
|
|
const texture_sizes = [_]u32{
|
|
256, 512, 1024, 2048, 4096
|
|
};
|
|
|
|
var sprites_buffer: [Sprite.max_sprites]*Sprite = undefined;
|
|
var sprites = std.ArrayList(*Sprite).initBuffer(&sprites_buffer);
|
|
|
|
var sprite_iter = self.sprites.iterator();
|
|
while (sprite_iter.next()) |sprite_id| {
|
|
const sprite = self.sprites.getAssumeExists(sprite_id);
|
|
if (sprite.mipchain != null and sprite.spritesheet == id) {
|
|
sprites.appendAssumeCapacity(sprite);
|
|
}
|
|
}
|
|
|
|
var rects: [Sprite.max_sprites]STBRectPack.Rect = undefined;
|
|
@memset(&rects, .{});
|
|
for (0.., sprites.items) |i, sprite| {
|
|
const sprite_mipchain = sprite.mipchain.?;
|
|
const padding = sprite.padding << @intCast(sprite_mipchain.length()-1);
|
|
rects[i] = .{
|
|
.w = @intCast(sprite_mipchain.width + padding * 2),
|
|
.h = @intCast(sprite_mipchain.height + padding * 2),
|
|
};
|
|
}
|
|
|
|
spritesheet.packer = .{};
|
|
const packer = &spritesheet.packer.?;
|
|
|
|
for (&texture_sizes) |texture_size| {
|
|
packer.init(texture_size, texture_size, &spritesheet.nodes);
|
|
packer.setupAllowOutOfMem(true);
|
|
|
|
if (!packer.packRects(&rects)) {
|
|
continue;
|
|
}
|
|
|
|
for (0.., sprites.items) |i, sprite| {
|
|
assert(rects[i].was_packed == 1);
|
|
const padding = sprite.padding << @intCast(sprite.mipchain.?.length()-1);
|
|
const x: u32 = @as(u32, @intCast(rects[i].x)) + padding;
|
|
const y: u32 = @as(u32, @intCast(rects[i].y)) + padding;
|
|
sprite.position = .initFromInt(u32, x, y);
|
|
}
|
|
|
|
spritesheet.size = .initFromInt(u32, texture_size, texture_size);
|
|
spritesheet.needs_texture_rebuild = true;
|
|
spritesheet.needs_repack = false;
|
|
return;
|
|
}
|
|
|
|
const max_texture_size = texture_sizes[texture_sizes.len-1];
|
|
log.err("Failed to pack sprites, couldn't create a texture that is large enough. Max size tried: {}x{}", .{max_texture_size, max_texture_size});
|
|
return;
|
|
}
|
|
|
|
fn repackSpritesheetIfNeeded(id: Spritesheet.Id) void {
|
|
const self = &g_state;
|
|
const spritesheet = self.spritesheets.get(id) orelse {
|
|
log.warn("Attempt to pack spritesheet that doesn't exist: {f}", .{id});
|
|
return;
|
|
};
|
|
|
|
if (!spritesheet.needs_repack) {
|
|
return;
|
|
}
|
|
|
|
repackSpritesheet(id);
|
|
}
|
|
|
|
// TODO: This function is a bit large, there are some easy things that could be moved to separate function.
|
|
// e.g. extruding padding.
|
|
fn rebuildSpritesheetTextureIfNeeded(id: Spritesheet.Id) void {
|
|
// TODO: Allow generating mipmaps
|
|
// https://github.com/floooh/sokol/issues/102#issuecomment-2926566603
|
|
|
|
const self = &g_state;
|
|
const spritesheet = self.spritesheets.get(id) orelse return;
|
|
if (!spritesheet.needs_texture_rebuild) {
|
|
return;
|
|
}
|
|
|
|
log.debug("[{}] Rebuild spritesheet texture: {f}", .{self.frame.index, id});
|
|
|
|
var mipchain_arena = std.heap.ArenaAllocator.init(self.gpa);
|
|
defer mipchain_arena.deinit();
|
|
const mipchain = Mipchain.initAlloc(
|
|
mipchain_arena.allocator(),
|
|
.{
|
|
.width = @intFromFloat(spritesheet.size.x),
|
|
.height = @intFromFloat(spritesheet.size.y),
|
|
.format = spritesheet.format
|
|
},
|
|
spritesheet.mipmaps
|
|
) catch |e| {
|
|
log.err("Mipchain allocation failed: {}", .{e});
|
|
return;
|
|
};
|
|
|
|
var sprite_iter = self.sprites.iterator();
|
|
while (sprite_iter.next()) |sprite_id| {
|
|
const sprite = self.sprites.getAssumeExists(sprite_id);
|
|
if (sprite.spritesheet != id) {
|
|
continue;
|
|
}
|
|
|
|
const sprite_mipchain = sprite.mipchain orelse continue;
|
|
const sprite_position = sprite.position orelse continue;
|
|
assert(sprite_mipchain.length() == spritesheet.mipmaps);
|
|
|
|
for (0..spritesheet.mipmaps) |index| {
|
|
const level = mipchain.getLevel(index);
|
|
|
|
const sprite_level = sprite_mipchain.getLevel(index);
|
|
const padding = sprite.padding << @intCast(sprite_mipchain.length()-1 - index);
|
|
var x: u32 = @intFromFloat(sprite_position.x);
|
|
x = x >> @intCast(index);
|
|
var y: u32 = @intFromFloat(sprite_position.y);
|
|
y = y >> @intCast(index);
|
|
|
|
level.setRectZero(
|
|
x - padding,
|
|
y - padding,
|
|
sprite_level.width + padding * 2,
|
|
sprite_level.height + padding * 2
|
|
);
|
|
level.copyFrom(sprite_level, x, y);
|
|
|
|
// TODO: Make `edge_extrusion` amount configurable
|
|
var edge_extrusion: u32 = 0;
|
|
if (padding > 0) {
|
|
edge_extrusion = 1;
|
|
}
|
|
|
|
if (edge_extrusion > 0) {
|
|
level.extrudeEdge(
|
|
.{
|
|
.x = x,
|
|
.y = y,
|
|
.width = sprite_level.width,
|
|
.height = sprite_level.height,
|
|
},
|
|
edge_extrusion
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
setTexture(spritesheet.texture, .{
|
|
.mipchain = mipchain,
|
|
.premultiplied = true
|
|
});
|
|
|
|
spritesheet.needs_texture_rebuild = false;
|
|
}
|
|
|
|
fn ensureSpritePacked(id: Sprite.Id) bool {
|
|
const self = &g_state;
|
|
const sprite = self.sprites.get(id) orelse return false;
|
|
|
|
if (sprite.position == null) {
|
|
const spritesheet = self.spritesheets.get(sprite.spritesheet) orelse return false;
|
|
const sprite_mipchain = sprite.mipchain orelse return false;
|
|
|
|
if (spritesheet.packer) |*packer| {
|
|
assert(sprite_mipchain.length() > 0);
|
|
const padding = sprite.padding << @intCast(sprite_mipchain.length()-1);
|
|
|
|
var rects: [1]STBRectPack.Rect = .{
|
|
.{
|
|
.w = @intCast(sprite_mipchain.width + padding * 2),
|
|
.h = @intCast(sprite_mipchain.height + padding * 2),
|
|
}
|
|
};
|
|
if (packer.packRects(&rects)) {
|
|
// Suboptimal sprite packing, will repack at end of frame
|
|
assert(rects[0].was_packed == 1);
|
|
const x: u32 = @as(u32, @intCast(rects[0].x)) + padding;
|
|
const y: u32 = @as(u32, @intCast(rects[0].y)) + padding;
|
|
sprite.position = .initFromInt(u32, x, y);
|
|
spritesheet.needs_repack = true;
|
|
} else {
|
|
log.debug("Failed to pack a single sprite to spritesheet", .{});
|
|
}
|
|
} else {
|
|
repackSpritesheet(sprite.spritesheet);
|
|
}
|
|
}
|
|
|
|
return sprite.position != null;
|
|
}
|
|
|
|
pub fn getSpriteUVRect(id: Sprite.Id) ?Rect {
|
|
const self = &g_state;
|
|
const sprite = self.sprites.get(id) orelse return null;
|
|
const sprite_mipchain = sprite.mipchain orelse return null;
|
|
|
|
const spritesheet = self.spritesheets.get(sprite.spritesheet) orelse return null;
|
|
|
|
if (!ensureSpritePacked(id)) {
|
|
return null;
|
|
}
|
|
|
|
assert(sprite.position != null);
|
|
|
|
const sprite_size = Vec2.initFromInt(u32, sprite_mipchain.width, sprite_mipchain.height);
|
|
return Rect{
|
|
.pos = sprite.position.?.divide(spritesheet.size),
|
|
.size = sprite_size.divide(spritesheet.size),
|
|
};
|
|
}
|
|
|
|
pub fn drawSpriteQuad(id: Sprite.Id, points: Quad, color: Color) void {
|
|
const self = &g_state;
|
|
|
|
var quad: VertexQuad = undefined;
|
|
quad.setColor(color);
|
|
quad.vertices[0].position = points.positions[0];
|
|
quad.vertices[1].position = points.positions[1];
|
|
quad.vertices[2].position = points.positions[2];
|
|
quad.vertices[3].position = points.positions[3];
|
|
|
|
var texture: ?Texture.Id = null;
|
|
if (getSpriteUVRect(id)) |sprite_uv| {
|
|
quad.setUVRect(sprite_uv);
|
|
|
|
const sprite = self.sprites.getAssumeExists(id);
|
|
const spritesheet = self.spritesheets.getAssumeExists(sprite.spritesheet);
|
|
texture = spritesheet.texture;
|
|
}
|
|
|
|
draw(.{
|
|
.texture = texture orelse .nil,
|
|
.quad = quad
|
|
});
|
|
}
|
|
|
|
pub fn drawSprite(id: Sprite.Id, pos: Vec2, size: Vec2, color: Color) void {
|
|
const rect = Quad.initRect(pos, size);
|
|
drawSpriteQuad(id, rect, color);
|
|
}
|
|
|
|
pub const SpriteSheetOptions = struct {
|
|
mipmaps: u32 = 1,
|
|
format: Image.Format = .rgba8
|
|
};
|
|
|
|
pub fn initSpritesheet(opts: SpriteSheetOptions) Spritesheet.Id {
|
|
const self = &g_state;
|
|
const id = self.spritesheets.insertUndefined() catch {
|
|
log.warn("Failed to create spritesheet, limit reached! limit: {}", .{self.spritesheets.slots.capacity});
|
|
return .nil;
|
|
};
|
|
|
|
assert(opts.mipmaps <= sg.max_mipmaps);
|
|
assert(opts.mipmaps > 0);
|
|
|
|
const spritesheet = self.spritesheets.getAssumeExists(id);
|
|
spritesheet.* = .{
|
|
.texture = initTexture(.{ .dynamic = true }),
|
|
.size = .init(0, 0),
|
|
.format = opts.format,
|
|
.mipmaps = opts.mipmaps,
|
|
.needs_repack = false,
|
|
.needs_texture_rebuild = false,
|
|
.nodes = undefined,
|
|
.packer = null
|
|
};
|
|
|
|
return id;
|
|
}
|
|
|
|
pub fn deinitSpritesheet(id: Spritesheet.Id) void {
|
|
const self = &g_state;
|
|
if (self.spritesheets.get(id)) |spritesheet| {
|
|
deinitTexture(spritesheet.texture);
|
|
self.spritesheets.removeAssumeExists(id);
|
|
}
|
|
}
|
|
|
|
pub const Image = struct {
|
|
format: Image.Format,
|
|
pixels: [*]u8,
|
|
width: u32,
|
|
height: u32,
|
|
|
|
pub const Format = enum {
|
|
rgba8,
|
|
r8,
|
|
|
|
pub fn pixelSize(self: Image.Format) usize {
|
|
return switch(self) {
|
|
.rgba8 => 4,
|
|
.r8 => 1,
|
|
};
|
|
}
|
|
|
|
pub fn maxPixelSize() usize {
|
|
var result: usize = 0;
|
|
for (@typeInfo(Image.Format).@"enum".field_values) |field_value| {
|
|
const pixel_size = Image.Format.pixelSize(@enumFromInt(field_value));
|
|
result = @max(result, pixel_size);
|
|
}
|
|
return result;
|
|
}
|
|
};
|
|
|
|
pub const none = Image{
|
|
.format = .rgba8,
|
|
.pixels = &.{},
|
|
.width = 0,
|
|
.height = 0,
|
|
};
|
|
|
|
const InitOptions = struct {
|
|
format: Image.Format,
|
|
width: u32,
|
|
height: u32,
|
|
};
|
|
|
|
const Rect = struct {
|
|
x: u32,
|
|
y: u32,
|
|
width: u32,
|
|
height: u32,
|
|
|
|
fn initTrunc(r: Math.Rect) Image.Rect {
|
|
return .{
|
|
.x = @trunc(r.pos.x),
|
|
.y = @trunc(r.pos.y),
|
|
.width = @trunc(r.size.x),
|
|
.height = @trunc(r.size.y),
|
|
};
|
|
}
|
|
};
|
|
|
|
pub fn initAlloc(gpa: Allocator, opts: InitOptions) !Image {
|
|
const pixel_count = opts.width * opts.height;
|
|
const pixel_size = opts.format.pixelSize();
|
|
|
|
return Image{
|
|
.format = opts.format,
|
|
.pixels = (try gpa.alloc(u8, pixel_count * pixel_size)).ptr,
|
|
.width = opts.width,
|
|
.height = opts.height
|
|
};
|
|
}
|
|
|
|
fn pixelCount(self: Image) usize {
|
|
return self.width * self.height;
|
|
}
|
|
|
|
fn pixelsSlice(self: Image) []u8 {
|
|
return self.pixels[0..(self.pixelCount() * self.format.pixelSize())];
|
|
}
|
|
|
|
pub fn clone(self: Image, arena: Allocator) !Image {
|
|
return Image{
|
|
.pixels = (try arena.dupe(u8, self.pixelsSlice())).ptr,
|
|
.format = self.format,
|
|
.width = self.width,
|
|
.height = self.height
|
|
};
|
|
}
|
|
|
|
pub fn deinit(self: Image, gpa: Allocator) void {
|
|
gpa.free(self.pixelsSlice());
|
|
}
|
|
|
|
pub fn getPixel(self: Image, x: usize, y: usize) []u8 {
|
|
const pixel_index = y * self.width + x;
|
|
const pixel_size = self.format.pixelSize();
|
|
return self.pixels[(pixel_size*pixel_index)..][0..pixel_size];
|
|
}
|
|
|
|
pub fn setRect(self: Image, x: u32, y: u32, width: u32, height: u32, pixel: []const u8) void {
|
|
for (0..height) |oy| {
|
|
const iy = y + oy;
|
|
if (iy >= self.height) {
|
|
continue;
|
|
}
|
|
|
|
for (0..width) |ox| {
|
|
const ix = x + ox;
|
|
if (ix >= self.width) {
|
|
continue;
|
|
}
|
|
|
|
const dest_pixel = self.getPixel(@intCast(ix), @intCast(iy));
|
|
@memcpy(dest_pixel, pixel);
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn setRectZero(self: Image, x: u32, y: u32, width: u32, height: u32) void {
|
|
const zero_pixel_buff: [Image.Format.maxPixelSize()]u8 = @splat(0);
|
|
const zero_pixel = zero_pixel_buff[0..self.format.pixelSize()];
|
|
self.setRect(x, y, width, height, zero_pixel);
|
|
}
|
|
|
|
pub fn premultiplyAlpha(self: Image) void {
|
|
if (self.format != .rgba8) return;
|
|
|
|
for (0..self.height) |y| {
|
|
for (0..self.width) |x| {
|
|
const pixel_index = y * self.width + x;
|
|
const rgba8_pixel = self.pixels[(4*pixel_index)..][0..4];
|
|
|
|
inline for (0..3) |i| {
|
|
rgba8_pixel[i] = @intCast(@as(u16, rgba8_pixel[i]) * rgba8_pixel[3] / 255);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn copyFromRect(
|
|
self: Image,
|
|
source: Image,
|
|
cx: u32,
|
|
cy: u32,
|
|
source_rect: Image.Rect,
|
|
) void {
|
|
assert(source.format == self.format);
|
|
|
|
for (0..source_rect.height) |oy| {
|
|
const source_y = source_rect.y+oy;
|
|
const dest_y = cy+oy;
|
|
if (dest_y >= self.height) {
|
|
continue;
|
|
}
|
|
if (source_y >= source.height) {
|
|
continue;
|
|
}
|
|
|
|
for (0..source_rect.width) |ox| {
|
|
const source_x = source_rect.x+ox;
|
|
const dest_x = cx+ox;
|
|
if (dest_x >= self.width) {
|
|
continue;
|
|
}
|
|
if (source_x >= source.width) {
|
|
continue;
|
|
}
|
|
|
|
const source_pixel = source.getPixel(@intCast(source_x), @intCast(source_y));
|
|
const dest_pixel = self.getPixel(@intCast(dest_x), @intCast(dest_y));
|
|
|
|
@memcpy(dest_pixel, source_pixel);
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn copyFrom(
|
|
self: Image,
|
|
source: Image,
|
|
cx: u32,
|
|
cy: u32,
|
|
) void {
|
|
self.copyFromRect(source, cx, cy, .{ .x = 0, .y = 0, .width = source.width, .height = source.height});
|
|
}
|
|
|
|
pub fn extrudeEdge(self: Image, rect: Image.Rect, size: u32) void {
|
|
for (0..rect.width) |ox| {
|
|
const pixel = self.getPixel(rect.x+ox, rect.y);
|
|
for (0..size) |i| {
|
|
@memcpy(self.getPixel(rect.x+ox, rect.y-(i+1)), pixel);
|
|
}
|
|
}
|
|
|
|
for (0..rect.width) |ox| {
|
|
const pixel = self.getPixel(rect.x+ox, rect.y+rect.height-1);
|
|
for (0..size) |i| {
|
|
@memcpy(self.getPixel(rect.x+ox, rect.y+rect.height+i), pixel);
|
|
}
|
|
}
|
|
|
|
for (0..rect.height) |oy| {
|
|
const pixel = self.getPixel(rect.x, rect.y+oy);
|
|
for (0..size) |i| {
|
|
@memcpy(self.getPixel(rect.x-(i+1), rect.y+oy), pixel);
|
|
}
|
|
}
|
|
|
|
for (0..rect.height) |oy| {
|
|
const pixel = self.getPixel(rect.x+rect.width-1, rect.y+oy);
|
|
for (0..size) |i| {
|
|
@memcpy(self.getPixel(rect.x+rect.width+i, rect.y+oy), pixel);
|
|
}
|
|
}
|
|
|
|
// TODO: Add padding to corners.
|
|
}
|
|
};
|
|
|
|
pub const Mipchain = struct {
|
|
format: Image.Format,
|
|
level0: [*]u8, // level0 is stored inline, so that we could cast a `Image` into a `Mipchain` without allocations
|
|
next_levels: [][*]u8, // Each level after `level0` must be half the size
|
|
width: u32,
|
|
height: u32,
|
|
|
|
pub const none = Mipchain{
|
|
.format = .rgba8,
|
|
.level0 = &.{},
|
|
.next_levels = &.{},
|
|
.width = 0,
|
|
.height = 0,
|
|
};
|
|
|
|
pub const InitOptions = struct {
|
|
format: Image.Format,
|
|
levels: [][*]u8,
|
|
width: u32,
|
|
height: u32,
|
|
};
|
|
|
|
pub fn init(opts: InitOptions) Mipchain {
|
|
var mipchain: Mipchain = .{
|
|
.format = opts.format,
|
|
.level0 = &.{},
|
|
.next_levels = &.{},
|
|
.width = opts.width,
|
|
.height = opts.height,
|
|
};
|
|
if (opts.levels.len > 0) {
|
|
mipchain.level0 = opts.levels[0];
|
|
mipchain.next_levels = opts.levels[1..];
|
|
}
|
|
return mipchain;
|
|
}
|
|
|
|
pub fn initSingle(image: Image) Mipchain {
|
|
return Mipchain{
|
|
.format = image.format,
|
|
.level0 = image.pixels,
|
|
.next_levels = &.{},
|
|
.width = image.width,
|
|
.height = image.height,
|
|
};
|
|
}
|
|
|
|
pub fn clone(self: Mipchain, arena: Allocator) !Mipchain {
|
|
var mipchain = Mipchain{
|
|
.format = self.format,
|
|
.width = self.width,
|
|
.height = self.height,
|
|
.level0 = &.{},
|
|
.next_levels = &.{}
|
|
};
|
|
|
|
if (self.length() >= 2) {
|
|
mipchain.next_levels = try arena.alloc([*]u8, self.length()-1);
|
|
}
|
|
|
|
for (0..mipchain.length()) |index| {
|
|
var level = self.getLevel(index);
|
|
const pixels = try arena.dupe(u8, level.pixelsSlice());
|
|
mipchain.getLevelPixelsPtr(index).* = pixels.ptr;
|
|
}
|
|
|
|
return mipchain;
|
|
}
|
|
|
|
pub fn initAlloc(arena: Allocator, image_opts: Image.InitOptions, levels: usize) !Mipchain {
|
|
var mipchain = Mipchain{
|
|
.width = image_opts.width,
|
|
.height = image_opts.height,
|
|
.format = image_opts.format,
|
|
.level0 = &.{},
|
|
.next_levels = &.{}
|
|
};
|
|
|
|
if (levels >= 2) {
|
|
mipchain.next_levels = try arena.alloc([*]u8, levels-1);
|
|
}
|
|
|
|
for (0..mipchain.length()) |index| {
|
|
var level = mipchain.getLevel(index);
|
|
const pixels = try arena.alloc(u8, level.pixelCount() * level.format.pixelSize());
|
|
mipchain.getLevelPixelsPtr(index).* = pixels.ptr;
|
|
}
|
|
|
|
assert(mipchain.length() == levels);
|
|
|
|
return mipchain;
|
|
}
|
|
|
|
pub fn length(self: Mipchain) usize {
|
|
if (self.width == 0 or self.height == 0) {
|
|
return 0;
|
|
}
|
|
|
|
return 1 + self.next_levels.len;
|
|
}
|
|
|
|
pub fn getLevelPixels(self: Mipchain, index: usize) [*]u8 {
|
|
if (index == 0) {
|
|
return self.level0;
|
|
} else {
|
|
return self.next_levels[index-1];
|
|
}
|
|
}
|
|
|
|
// TODO: Don't like that this is redundant with `getLevelPixels`
|
|
pub fn getLevelPixelsPtr(self: *Mipchain, index: usize) *[*]u8 {
|
|
if (index == 0) {
|
|
return &self.level0;
|
|
} else {
|
|
return &self.next_levels[index-1];
|
|
}
|
|
}
|
|
|
|
pub fn getLevel(self: Mipchain, index: usize) Image {
|
|
return Image{
|
|
.format = self.format,
|
|
.pixels = self.getLevelPixels(index),
|
|
.width = @max(self.width >> @intCast(index), 1),
|
|
.height = @max(self.height >> @intCast(index), 1),
|
|
};
|
|
}
|
|
|
|
pub fn copyFromRect(
|
|
self: Mipchain,
|
|
source: Mipchain,
|
|
cx: u32,
|
|
cy: u32,
|
|
source_rect: Image.Rect,
|
|
) void {
|
|
assert(self.length() == source.length());
|
|
|
|
for (0..self.length()) |index| {
|
|
const self_level = self.getLevel(index);
|
|
const source_level = source.getLevel(index);
|
|
self_level.copyFromRect(
|
|
source_level,
|
|
cx >> @intCast(index),
|
|
cy >> @intCast(index),
|
|
.{
|
|
.x = source_rect.x >> @intCast(index),
|
|
.y = source_rect.y >> @intCast(index),
|
|
.width = source_rect.width >> @intCast(index),
|
|
.height = source_rect.height >> @intCast(index),
|
|
}
|
|
);
|
|
}
|
|
}
|
|
|
|
pub fn premultiplyAlpha(self: Mipchain) void {
|
|
for (0..self.length()) |index| {
|
|
self.getLevel(index).premultiplyAlpha();
|
|
}
|
|
}
|
|
};
|
|
|
|
pub const Texture = struct {
|
|
dynamic: bool,
|
|
updated_at: ?u64,
|
|
image: sg.Image,
|
|
view: sg.View,
|
|
|
|
const max_textures = 64;
|
|
const SlotMap = SlotMapType(std.math.IntFittingRange(0, max_textures-1), u8, Texture);
|
|
pub const Id = SlotMap.Id;
|
|
};
|
|
|
|
pub const Sprite = struct {
|
|
arena: std.heap.ArenaAllocator,
|
|
spritesheet: Spritesheet.Id,
|
|
mipchain: ?Mipchain,
|
|
position: ?Vec2,
|
|
padding: u32,
|
|
|
|
const max_sprites = 256;
|
|
const SlotMap = SlotMapType(std.math.IntFittingRange(0, max_sprites-1), u8, Sprite);
|
|
pub const Id = SlotMap.Id;
|
|
};
|
|
|
|
pub const Spritesheet = struct {
|
|
texture: Texture.Id,
|
|
format: Image.Format,
|
|
size: Vec2,
|
|
mipmaps: u32,
|
|
|
|
needs_repack: bool,
|
|
needs_texture_rebuild: bool,
|
|
|
|
packer: ?STBRectPack,
|
|
nodes: [256]STBRectPack.Node,
|
|
|
|
const max_spritesheets = 64;
|
|
const SlotMap = SlotMapType(std.math.IntFittingRange(0, max_spritesheets-1), u8, Spritesheet);
|
|
pub const Id = SlotMap.Id;
|
|
};
|
|
|
|
pub const Vertex = extern struct {
|
|
position: Vec2,
|
|
texcoord: Vec2,
|
|
color: Vec4,
|
|
};
|
|
|
|
pub const VertexQuad = extern struct {
|
|
vertices: [4]Vertex,
|
|
|
|
pub fn init(vertices: [4]Vertex) VertexQuad {
|
|
return VertexQuad{
|
|
.vertices = vertices
|
|
};
|
|
}
|
|
|
|
pub fn setColor(self: *VertexQuad, color: Color) void {
|
|
for (&self.vertices) |*vertex| {
|
|
vertex.color = Vec4{
|
|
.x = color.r,
|
|
.y = color.g,
|
|
.z = color.b,
|
|
.w = color.a,
|
|
};
|
|
}
|
|
}
|
|
|
|
pub fn setUVRect(self: *VertexQuad, rect: Rect) void {
|
|
const pos = rect.pos;
|
|
const size = rect.size;
|
|
self.vertices[0].texcoord = pos;
|
|
self.vertices[1].texcoord = pos.add(.init(size.x, 0));
|
|
self.vertices[2].texcoord = pos.add(.init(0, size.y));
|
|
self.vertices[3].texcoord = pos.add(size);
|
|
}
|
|
|
|
pub fn setRect(self: *VertexQuad, rect: Rect) void {
|
|
const pos = rect.pos;
|
|
const size = rect.size;
|
|
self.vertices[0].position = pos;
|
|
self.vertices[1].position = pos.add(.init(size.x, 0));
|
|
self.vertices[2].position = pos.add(.init(0, size.y));
|
|
self.vertices[3].position = pos.add(size);
|
|
}
|
|
};
|
|
|
|
pub const Quad = struct {
|
|
positions: [4]Vec2,
|
|
|
|
pub fn init(positions: [4]Vec2) Quad {
|
|
return Quad{
|
|
.positions = positions
|
|
};
|
|
}
|
|
|
|
pub fn initRect(pos: Vec2, size: Vec2) Quad {
|
|
return Quad{
|
|
.positions = .{
|
|
pos,
|
|
pos.add(.init(size.x, 0)),
|
|
pos.add(.init(0, size.y)),
|
|
pos.add(size),
|
|
}
|
|
};
|
|
}
|
|
|
|
pub fn applyRotate(self: *Quad, rad: f32, origin: Vec2) void {
|
|
for (&self.positions) |*pos| {
|
|
pos.* = pos.sub(origin).rotate(rad).add(origin);
|
|
}
|
|
}
|
|
|
|
pub fn applyOffset(self: *Quad, vec2: Vec2) void {
|
|
for (&self.positions) |*pos| {
|
|
pos.* = pos.add(vec2);
|
|
}
|
|
}
|
|
};
|
|
|
|
pub const TransformFrame = struct {
|
|
offset: Vec2,
|
|
scale: Vec2,
|
|
|
|
pub fn apply(self: TransformFrame, position: Vec2) Vec2 {
|
|
return position.multiply(self.scale).add(self.offset);
|
|
}
|
|
};
|