From 0acb0e2c808125512d294014865677cc68acb470 Mon Sep 17 00:00:00 2001 From: IntegratedQuantum Date: Wed, 3 Apr 2024 13:57:25 +0200 Subject: [PATCH] Update zig This one was annoying. --- .zig-version | 2 +- src/audio.zig | 2 +- src/entity.zig | 2 +- src/game.zig | 12 ++-- src/gui/windows/debug.zig | 8 +-- src/gui/windows/debug_network.zig | 6 +- src/gui/windows/multiplayer.zig | 6 +- src/gui/windows/performance_graph.zig | 2 +- src/itemdrop.zig | 2 +- src/json.zig | 3 +- src/main.zig | 4 +- src/network.zig | 92 +++++++++++++-------------- src/renderer.zig | 6 +- src/renderer/chunk_meshing.zig | 22 +++---- src/renderer/lighting.zig | 38 +++++------ src/renderer/mesh_storage.zig | 50 +++++++-------- src/server/server.zig | 10 +-- src/server/terrain/CaveBiomeMap.zig | 6 +- src/server/terrain/CaveMap.zig | 6 +- src/server/terrain/ClimateMap.zig | 6 +- src/server/terrain/LightMap.zig | 6 +- src/server/terrain/SurfaceMap.zig | 6 +- src/utils.zig | 20 +++--- src/utils/file_monitor.zig | 14 ++-- 24 files changed, 166 insertions(+), 165 deletions(-) diff --git a/.zig-version b/.zig-version index befbedb2..2fa7d8f5 100644 --- a/.zig-version +++ b/.zig-version @@ -1 +1 @@ -0.12.0-dev.3142+9d500bda2 \ No newline at end of file +0.12.0-dev.3518+d2be725e4 \ No newline at end of file diff --git a/src/audio.zig b/src/audio.zig index 4f6ec3d3..3498d652 100644 --- a/src/audio.zig +++ b/src/audio.zig @@ -212,7 +212,7 @@ var curIndex: u16 = 0; var curEndIndex: std.atomic.Value(u16) = .{.value = sampleRate/60 & ~@as(u16, 1)}; fn addMusic(buffer: []f32) void { - const musicId = if(main.game.world) |world| world.playerBiome.load(.Monotonic).preferredMusic else "cubyz"; + const musicId = if(main.game.world) |world| world.playerBiome.load(.monotonic).preferredMusic else "cubyz"; if(!std.mem.eql(u8, musicId, activeMusicId)) { if(activeMusicId.len == 0) { if(findMusic(musicId)) |musicBuffer| { diff --git a/src/entity.zig b/src/entity.zig index 3dccb149..0b2d2e2a 100644 --- a/src/entity.zig +++ b/src/entity.zig @@ -113,7 +113,7 @@ pub const ClientEntityManager = struct { fn update() void { std.debug.assert(!mutex.tryLock()); // The mutex should be locked when calling this function. var time: i16 = @truncate(std.time.milliTimestamp()); - time -%= timeDifference.difference.load(.Monotonic); + time -%= timeDifference.difference.load(.monotonic); for(entities.items) |*ent| { ent.update(time, lastTime); } diff --git a/src/game.zig b/src/game.zig index 2bf49270..6d5e86aa 100644 --- a/src/game.zig +++ b/src/game.zig @@ -177,14 +177,14 @@ pub const World = struct { const newTime: i64 = std.time.milliTimestamp(); while(self.milliTime +% 100 -% newTime < 0) { self.milliTime +%= 100; - var curTime = self.gameTime.load(.Monotonic); - while(self.gameTime.cmpxchgWeak(curTime, curTime +% 1, .Monotonic, .Monotonic)) |actualTime| { + var curTime = self.gameTime.load(.monotonic); + while(self.gameTime.cmpxchgWeak(curTime, curTime +% 1, .monotonic, .monotonic)) |actualTime| { curTime = actualTime; } } // Ambient light: { - var dayTime = @abs(@mod(self.gameTime.load(.Monotonic), dayCycle) -% dayCycle/2); + var dayTime = @abs(@mod(self.gameTime.load(.monotonic), dayCycle) -% dayCycle/2); if(dayTime < dayCycle/4 - dayCycle/16) { self.ambientLight = 0.1; self.clearColor[0] = 0; @@ -238,7 +238,7 @@ pub fn update(deltaTime: f64) void { if(main.Window.grabbed) { if(KeyBoard.key("forward").pressed) { if(KeyBoard.key("sprint").pressed) { - if(Player.isFlying.load(.Monotonic)) { + if(Player.isFlying.load(.monotonic)) { movement += forward*@as(Vec3d, @splat(128)); } else { movement += forward*@as(Vec3d, @splat(8)); @@ -257,7 +257,7 @@ pub fn update(deltaTime: f64) void { movement += right*@as(Vec3d, @splat(-4)); } if(KeyBoard.key("jump").pressed) { - if(Player.isFlying.load(.Monotonic)) { + if(Player.isFlying.load(.monotonic)) { if(KeyBoard.key("sprint").pressed) { movement[2] = 59.45; } else { @@ -268,7 +268,7 @@ pub fn update(deltaTime: f64) void { } } if(KeyBoard.key("fall").pressed) { - if(Player.isFlying.load(.Monotonic)) { + if(Player.isFlying.load(.monotonic)) { if(KeyBoard.key("sprint").pressed) { movement[2] = -59.45; } else { diff --git a/src/gui/windows/debug.zig b/src/gui/windows/debug.zig index 825efbe8..cc13dfaf 100644 --- a/src/gui/windows/debug.zig +++ b/src/gui/windows/debug.zig @@ -25,16 +25,16 @@ pub var window = GuiWindow { pub fn render() void { draw.setColor(0xffffffff); var y: f32 = 0; - draw.print(" fps: {d:.0} Hz{s}", .{1.0/main.lastFrameTime.load(.Monotonic), if(main.settings.vsync) @as([]const u8, " (vsync)") else ""}, 0, y, 8, .left); + draw.print(" fps: {d:.0} Hz{s}", .{1.0/main.lastFrameTime.load(.monotonic), if(main.settings.vsync) @as([]const u8, " (vsync)") else ""}, 0, y, 8, .left); y += 8; - draw.print(" frameTime: {d:.1} ms", .{main.lastFrameTime.load(.Monotonic)*1000.0}, 0, y, 8, .left); + draw.print(" frameTime: {d:.1} ms", .{main.lastFrameTime.load(.monotonic)*1000.0}, 0, y, 8, .left); y += 8; draw.print("window size: {}×{}", .{main.Window.width, main.Window.height}, 0, y, 8, .left); y += 8; if (main.game.world != null) { draw.print("Pos: {d:.1}", .{main.game.Player.getPosBlocking()}, 0, y, 8, .left); y += 8; - draw.print("Game Time: {}", .{main.game.world.?.gameTime.load(.Monotonic)}, 0, y, 8, .left); + draw.print("Game Time: {}", .{main.game.world.?.gameTime.load(.monotonic)}, 0, y, 8, .left); y += 8; draw.print("Queue size: {}", .{main.threadPool.queueSize()}, 0, y, 8, .left); y += 8; @@ -52,7 +52,7 @@ pub fn render() void { draw.print("ChunkMesh memory: {} MiB / {} MiB (fragmentation: {} MiB)", .{used >> 20, size >> 20, fragmentation >> 20}, 0, y, 8, .left); y += 8; } - draw.print("Biome: {s}", .{main.game.world.?.playerBiome.load(.Monotonic).id}, 0, y, 8, .left); + draw.print("Biome: {s}", .{main.game.world.?.playerBiome.load(.monotonic).id}, 0, y, 8, .left); y += 8; draw.print("Opaque faces: {}, Transparent faces: {}", .{main.renderer.chunk_meshing.quadsDrawn, main.renderer.chunk_meshing.transparentQuadsDrawn}, 0, y, 8, .left); y += 8; diff --git a/src/gui/windows/debug_network.zig b/src/gui/windows/debug_network.zig index 2265505b..75405be0 100644 --- a/src/gui/windows/debug_network.zig +++ b/src/gui/windows/debug_network.zig @@ -31,15 +31,15 @@ pub fn render() void { draw.print("Players Connected: {}", .{main.server.users.items.len}, 0, y, 8, .left); y += 8; } - const sent = network.Connection.packetsSent.load(.Monotonic); - const resent = network.Connection.packetsResent.load(.Monotonic); + const sent = network.Connection.packetsSent.load(.monotonic); + const resent = network.Connection.packetsResent.load(.monotonic); const loss = @as(f64, @floatFromInt(resent))/@as(f64, @floatFromInt(sent))*100; draw.print("Packet loss: {d:.1}% ({}/{})", .{loss, resent, sent}, 0, y, 8, .left); y += 8; inline for(@typeInfo(network.Protocols).Struct.decls) |decl| { if(@TypeOf(@field(network.Protocols, decl.name)) == type) { const id = @field(network.Protocols, decl.name).id; - draw.print("{s}: {}kiB in {} packets", .{decl.name, network.bytesReceived[id].load(.Monotonic) >> 10, network.packetsReceived[id].load(.Monotonic)}, 0, y, 8, .left); + draw.print("{s}: {}kiB in {} packets", .{decl.name, network.bytesReceived[id].load(.monotonic) >> 10, network.packetsReceived[id].load(.monotonic)}, 0, y, 8, .left); y += 8; } } diff --git a/src/gui/windows/multiplayer.zig b/src/gui/windows/multiplayer.zig index 08b02fca..d7c4c226 100644 --- a/src/gui/windows/multiplayer.zig +++ b/src/gui/windows/multiplayer.zig @@ -34,7 +34,7 @@ fn discoverIpAddress() void { return; }; // TODO: default port ipAddress = std.fmt.allocPrint(main.globalAllocator.allocator, "{}", .{connection.?.externalAddress}) catch unreachable; - gotIpAddress.store(true, .Release); + gotIpAddress.store(true, .release); } fn discoverIpAddressFromNewThread() void { @@ -115,8 +115,8 @@ pub fn onClose() void { } pub fn update() void { - if(gotIpAddress.load(.Acquire)) { - gotIpAddress.store(false, .Monotonic); + if(gotIpAddress.load(.acquire)) { + gotIpAddress.store(false, .monotonic); ipAddressLabel.updateText(ipAddress); } } \ No newline at end of file diff --git a/src/gui/windows/performance_graph.zig b/src/gui/windows/performance_graph.zig index 5a88a465..4d5782eb 100644 --- a/src/gui/windows/performance_graph.zig +++ b/src/gui/windows/performance_graph.zig @@ -49,7 +49,7 @@ pub fn deinit() void { } pub fn render() void { - lastFrameTime[index] = @floatCast(main.lastFrameTime.load(.Monotonic)*1000.0); + lastFrameTime[index] = @floatCast(main.lastFrameTime.load(.monotonic)*1000.0); index = (index + 1)%@as(u31, @intCast(lastFrameTime.len)); draw.setColor(0xffffffff); draw.text("32 ms", 0, 16, 8, .left); diff --git a/src/itemdrop.zig b/src/itemdrop.zig index 78fcc5f2..5b5914ea 100644 --- a/src/itemdrop.zig +++ b/src/itemdrop.zig @@ -506,7 +506,7 @@ pub const ClientItemDropManager = struct { pub fn updateInterpolationData(self: *ClientItemDropManager) void { var time = @as(i16, @truncate(std.time.milliTimestamp())) -% settings.entityLookback; - time -%= self.timeDifference.difference.load(.Monotonic); + time -%= self.timeDifference.difference.load(.monotonic); { self.super.mutex.lock(); defer self.super.mutex.unlock(); diff --git a/src/json.zig b/src/json.zig index 8ce3ffb2..cc1fa21e 100644 --- a/src/json.zig +++ b/src/json.zig @@ -243,7 +243,8 @@ pub const JsonElement = union(JsonType) { std.fmt.formatInt(value, 10, .lower, .{}, list.writer()) catch unreachable; }, .JsonFloat => |value| { - std.fmt.formatFloatScientific(value, .{}, list.writer()) catch unreachable; + var buf: [std.fmt.format_float.bufferSize(.scientific, @TypeOf(value))]u8 = undefined; + list.appendSlice(std.fmt.format_float.formatFloat(&buf, value, .{.mode = .scientific}) catch unreachable); }, .JsonBool => |value| { if(value) { diff --git a/src/main.zig b/src/main.zig index 2a94d1ad..f681ba42 100644 --- a/src/main.zig +++ b/src/main.zig @@ -780,9 +780,9 @@ pub fn main() void { const deltaTime = @as(f64, @floatFromInt(newTime -% lastTime))/1e9; if(@import("builtin").os.tag == .linux and deltaTime > 5) { // On linux a process that runs 10 seconds or longer on the GPU will get stopped. This allows detecting an infinite loop on the GPU. std.log.err("Frame got too long with {} seconds. Infinite loop on GPU?", .{deltaTime}); - std.os.exit(1); + std.posix.exit(1); } - lastFrameTime.store(deltaTime, .Monotonic); + lastFrameTime.store(deltaTime, .monotonic); lastTime = newTime; if(game.world != null) { // Update the game game.update(deltaTime); diff --git a/src/network.zig b/src/network.zig index a446e0c7..9f5d947c 100644 --- a/src/network.zig +++ b/src/network.zig @@ -23,12 +23,12 @@ const NeverFailingAllocator = main.utils.NeverFailingAllocator; //TODO: Might want to use SSL or something similar to encode the message const Socket = struct { - const os = std.os; - socketID: os.socket_t, + const posix = std.posix; + socketID: posix.socket_t, fn startup() void { if(builtin.os.tag == .windows) { - _ = os.windows.WSAStartup(2, 2) catch |err| { + _ = std.os.windows.WSAStartup(2, 2) catch |err| { std.log.err("Could not initialize the Windows Socket API: {s}", .{@errorName(err)}); @panic("Could not init networking."); }; @@ -37,27 +37,27 @@ const Socket = struct { fn init(localPort: u16) !Socket { const self = Socket { - .socketID = try os.socket(os.AF.INET, os.SOCK.DGRAM, os.IPPROTO.UDP), + .socketID = try posix.socket(posix.AF.INET, posix.SOCK.DGRAM, posix.IPPROTO.UDP), }; errdefer self.deinit(); - const bindingAddr = os.sockaddr.in { + const bindingAddr = posix.sockaddr.in { .port = @byteSwap(localPort), .addr = 0, }; - try os.bind(self.socketID, @ptrCast(&bindingAddr), @sizeOf(os.sockaddr.in)); + try posix.bind(self.socketID, @ptrCast(&bindingAddr), @sizeOf(posix.sockaddr.in)); return self; } fn deinit(self: Socket) void { - os.close(self.socketID); + posix.close(self.socketID); } fn send(self: Socket, data: []const u8, destination: Address) void { - const addr = os.sockaddr.in { + const addr = posix.sockaddr.in { .port = @byteSwap(destination.port), .addr = destination.ip, }; - std.debug.assert(data.len == os.sendto(self.socketID, data, 0, @ptrCast(&addr), @sizeOf(os.sockaddr.in)) catch |err| { + std.debug.assert(data.len == posix.sendto(self.socketID, data, 0, @ptrCast(&addr), @sizeOf(posix.sockaddr.in)) catch |err| { std.log.info("Got error while sending to {}: {s}", .{destination, @errorName(err)}); return; }); @@ -65,32 +65,32 @@ const Socket = struct { fn receive(self: Socket, buffer: []u8, timeout: i32, resultAddress: *Address) ![]u8 { if(builtin.os.tag == .windows) { // Of course Windows always has it's own special thing. - var pfd = [1]os.pollfd { + var pfd = [1]posix.pollfd { .{.fd = self.socketID, .events = std.c.POLL.RDNORM | std.c.POLL.RDBAND, .revents = undefined}, }; - const length = os.windows.ws2_32.WSAPoll(&pfd, pfd.len, 0); // The timeout is set to zero. Otherwise sendto operations from other threads will block on this. - if (length == os.windows.ws2_32.SOCKET_ERROR) { - switch (os.windows.ws2_32.WSAGetLastError()) { + const length = std.os.windows.ws2_32.WSAPoll(&pfd, pfd.len, 0); // The timeout is set to zero. Otherwise sendto operations from other threads will block on this. + if (length == std.os.windows.ws2_32.SOCKET_ERROR) { + switch (std.os.windows.ws2_32.WSAGetLastError()) { .WSANOTINITIALISED => unreachable, .WSAENETDOWN => return error.NetworkSubsystemFailed, .WSAENOBUFS => return error.SystemResources, // TODO: handle more errors - else => |err| return os.windows.unexpectedWSAError(err), + else => |err| return std.os.windows.unexpectedWSAError(err), } } else if(length == 0) { std.time.sleep(1000000); // Manually sleep, since WSAPoll is blocking. return error.Timeout; } } else { - var pfd = [1]os.pollfd { - .{.fd = self.socketID, .events = os.POLL.IN, .revents = undefined}, + var pfd = [1]posix.pollfd { + .{.fd = self.socketID, .events = posix.POLL.IN, .revents = undefined}, }; - const length = try os.poll(&pfd, timeout); + const length = try posix.poll(&pfd, timeout); if(length == 0) return error.Timeout; } - var addr: os.sockaddr.in = undefined; - var addrLen: os.socklen_t = @sizeOf(os.sockaddr.in); - const length = try os.recvfrom(self.socketID, buffer, 0, @ptrCast(&addr), &addrLen); + var addr: posix.sockaddr.in = undefined; + var addrLen: posix.socklen_t = @sizeOf(posix.sockaddr.in); + const length = try posix.recvfrom(self.socketID, buffer, 0, @ptrCast(&addr), &addrLen); resultAddress.ip = addr.addr; resultAddress.port = @byteSwap(addr.port); return buffer[0..length]; @@ -417,7 +417,7 @@ pub const ConnectionManager = struct { conn.disconnect(); } - self.running.store(false, .Monotonic); + self.running.store(false, .monotonic); self.thread.join(); Socket.deinit(self.socket); self.connections.deinit(); @@ -430,9 +430,9 @@ pub const ConnectionManager = struct { } pub fn makeOnline(self: *ConnectionManager) void { - if(!self.online.load(.Acquire)) { + if(!self.online.load(.acquire)) { self.externalAddress = STUN.requestAddress(self); - self.online.store(true, .Release); + self.online.store(true, .release); } } @@ -523,7 +523,7 @@ pub const ConnectionManager = struct { return; } } - if(self.online.load(.Acquire) and source.ip == self.externalAddress.ip and source.port == self.externalAddress.port) return; + if(self.online.load(.acquire) and source.ip == self.externalAddress.ip and source.port == self.externalAddress.port) return; // TODO: Reduce the number of false alarms in the short period after a disconnect. std.log.warn("Unknown connection from address: {}", .{source}); std.log.debug("Message: {any}", .{data}); @@ -536,7 +536,7 @@ pub const ConnectionManager = struct { main.stackAllocator = sta.allocator(); var lastTime = std.time.milliTimestamp(); - while(self.running.load(.Monotonic)) { + while(self.running.load(.monotonic)) { self.waitingToFinishReceive.broadcast(); var source: Address = undefined; if(self.socket.receive(&self.receiveBuffer, 100, &source)) |data| { @@ -569,7 +569,7 @@ pub const ConnectionManager = struct { i += 1; } } - if(self.connections.items.len == 0 and self.online.load(.Acquire)) { + if(self.connections.items.len == 0 and self.online.load(.acquire)) { // Send a message to external ip, to keep the port open: const data = [1]u8{0}; self.send(&data, self.externalAddress); @@ -601,8 +601,8 @@ pub const Protocols = struct { const stepComplete: u8 = 255; fn receive(conn: *Connection, data: []const u8) !void { - if(conn.handShakeState.load(.Monotonic) < data[0]) { - conn.handShakeState.store(data[0], .Monotonic); + if(conn.handShakeState.load(.monotonic) < data[0]) { + conn.handShakeState.store(data[0], .monotonic); switch(data[0]) { stepUserData => { const json = JsonElement.parseFromString(main.stackAllocator, data[1..]); @@ -642,8 +642,8 @@ pub const Protocols = struct { const outData = jsonObject.toStringEfficient(main.stackAllocator, &[1]u8{stepServerData}); defer main.stackAllocator.free(outData); conn.sendImportant(id, outData); - conn.handShakeState.store(stepServerData, .Monotonic); - conn.handShakeState.store(stepComplete, .Monotonic); + conn.handShakeState.store(stepServerData, .monotonic); + conn.handShakeState.store(stepComplete, .monotonic); // TODO: // synchronized(conn) { // Notify the waiting server thread. // conn.notifyAll(); @@ -660,7 +660,7 @@ pub const Protocols = struct { const json = JsonElement.parseFromString(main.stackAllocator, data[1..]); defer json.free(main.stackAllocator); try conn.manager.world.?.finishHandshake(json); - conn.handShakeState.store(stepComplete, .Monotonic); + conn.handShakeState.store(stepComplete, .monotonic); conn.handShakeWaiting.broadcast(); // Notify the waiting client thread. }, stepComplete => { @@ -676,7 +676,7 @@ pub const Protocols = struct { } pub fn serverSide(conn: *Connection) void { - conn.handShakeState.store(stepStart, .Monotonic); + conn.handShakeState.store(stepStart, .monotonic); } pub fn clientSide(conn: *Connection, name: []const u8) void { @@ -1086,19 +1086,19 @@ pub const Protocols = struct { const json = JsonElement.parseFromString(main.stackAllocator, data[1..]); defer json.free(main.stackAllocator); const expectedTime = json.get(i64, "time", 0); - var curTime = world.gameTime.load(.Monotonic); + var curTime = world.gameTime.load(.monotonic); if(@abs(curTime -% expectedTime) >= 1000) { - world.gameTime.store(expectedTime, .Monotonic); + world.gameTime.store(expectedTime, .monotonic); } else if(curTime < expectedTime) { // world.gameTime++ - while(world.gameTime.cmpxchgWeak(curTime, curTime +% 1, .Monotonic, .Monotonic)) |actualTime| { + while(world.gameTime.cmpxchgWeak(curTime, curTime +% 1, .monotonic, .monotonic)) |actualTime| { curTime = actualTime; } } else { // world.gameTime-- - while(world.gameTime.cmpxchgWeak(curTime, curTime -% 1, .Monotonic, .Monotonic)) |actualTime| { + while(world.gameTime.cmpxchgWeak(curTime, curTime -% 1, .monotonic, .monotonic)) |actualTime| { curTime = actualTime; } } - world.playerBiome.store(main.server.terrain.biomes.getById(json.get([]const u8, "biome", "")), .Monotonic); + world.playerBiome.store(main.server.terrain.biomes.getById(json.get([]const u8, "biome", "")), .monotonic); } }, else => |unrecognizedType| { @@ -1275,7 +1275,7 @@ pub const Protocols = struct { data = _inflatedData; const map = main.globalAllocator.create(main.server.terrain.LightMap.LightMapFragment); map.init(pos.wx, pos.wy, pos.voxelSize); - _ = map.refCount.fetchAdd(1, .Monotonic); + _ = map.refCount.fetchAdd(1, .monotonic); for(&map.startHeight) |*val| { val.* = std.mem.readInt(i16, data[0..2], .big); data = data[2..]; @@ -1402,7 +1402,7 @@ pub const Connection = struct { .id = id, }; self.unconfirmedPackets.append(packet); - _ = packetsSent.fetchAdd(1, .Monotonic); + _ = packetsSent.fetchAdd(1, .monotonic); self.manager.send(packet.data, self.remoteAddress); self.streamPosition = importantHeaderSize; } @@ -1546,8 +1546,8 @@ pub const Connection = struct { // Resend packets that didn't receive confirmation within the last 2 keep-alive signals. for(self.unconfirmedPackets.items) |*packet| { if(self.lastKeepAliveReceived -% @as(i33, packet.lastKeepAliveSentBefore) >= 2) { - _ = packetsSent.fetchAdd(1, .Monotonic); - _ = packetsResent.fetchAdd(1, .Monotonic); + _ = packetsSent.fetchAdd(1, .monotonic); + _ = packetsResent.fetchAdd(1, .monotonic); self.manager.send(packet.data, self.remoteAddress); packet.lastKeepAliveSentBefore = self.lastKeepAliveSent; } @@ -1631,7 +1631,7 @@ pub const Connection = struct { self.lastReceivedPackets[self.lastIncompletePacket & 65535] = null; } self.lastIndex = newIndex; - _ = bytesReceived[protocol].fetchAdd(data.len + 1 + (7 + std.math.log2_int(usize, 1 + data.len))/7, .Monotonic); + _ = bytesReceived[protocol].fetchAdd(data.len + 1 + (7 + std.math.log2_int(usize, 1 + data.len))/7, .monotonic); if(Protocols.list[protocol]) |prot| { try prot(self, data); } else { @@ -1650,15 +1650,15 @@ pub const Connection = struct { pub fn flawedReceive(self: *Connection, data: []const u8) !void { std.debug.assert(self.manager.threadId == std.Thread.getCurrentId()); const protocol = data[0]; - if(self.handShakeState.load(.Monotonic) != Protocols.handShake.stepComplete and protocol != Protocols.handShake.id and protocol != Protocols.keepAlive and protocol != Protocols.important) { + if(self.handShakeState.load(.monotonic) != Protocols.handShake.stepComplete and protocol != Protocols.handShake.id and protocol != Protocols.keepAlive and protocol != Protocols.important) { return; // Reject all non-handshake packets until the handshake is done. } self.lastConnection = std.time.milliTimestamp(); - _ = bytesReceived[protocol].fetchAdd(data.len + 20 + 8, .Monotonic); // Including IP header and udp header; - _ = packetsReceived[protocol].fetchAdd(1, .Monotonic); + _ = bytesReceived[protocol].fetchAdd(data.len + 20 + 8, .monotonic); // Including IP header and udp header; + _ = packetsReceived[protocol].fetchAdd(1, .monotonic); if(protocol == Protocols.important) { const id = std.mem.readInt(u32, data[1..5], .big); - if(self.handShakeState.load(.Monotonic) == Protocols.handShake.stepComplete and id == 0) { // Got a new "first" packet from client. So the client tries to reconnect, but we still think it's connected. + if(self.handShakeState.load(.monotonic) == Protocols.handShake.stepComplete and id == 0) { // Got a new "first" packet from client. So the client tries to reconnect, but we still think it's connected. // TODO: // if(this instanceof User) { // Server.disconnect((User)this); diff --git a/src/renderer.zig b/src/renderer.zig index 88fb8d2b..a4911bdc 100644 --- a/src/renderer.zig +++ b/src/renderer.zig @@ -115,7 +115,7 @@ pub fn updateViewport(width: u31, height: u31, fov: f32) void { lastHeight = height; lastFov = fov; c.glViewport(0, 0, width, height); - game.projectionMatrix = Mat4f.perspective(std.math.degreesToRadians(f32, fov), @as(f32, @floatFromInt(width))/@as(f32, @floatFromInt(height)), zNear, zFar); + game.projectionMatrix = Mat4f.perspective(std.math.degreesToRadians(fov), @as(f32, @floatFromInt(width))/@as(f32, @floatFromInt(height)), zNear, zFar); worldFrameBuffer.updateSize(width, height, c.GL_RGB16F); worldFrameBuffer.unbind(); } @@ -594,7 +594,7 @@ pub const MenuBackGround = struct { c.glDisable(c.GL_DEPTH_TEST); c.glBindFramebuffer(c.GL_FRAMEBUFFER, 0); - const fileName = std.fmt.allocPrint(main.stackAllocator.allocator, "assets/backgrounds/{s}_{}.png", .{game.world.?.name, game.world.?.gameTime.load(.Monotonic)}) catch unreachable; + const fileName = std.fmt.allocPrint(main.stackAllocator.allocator, "assets/backgrounds/{s}_{}.png", .{game.world.?.name, game.world.?.gameTime.load(.monotonic)}) catch unreachable; defer main.stackAllocator.free(fileName); image.exportToFile(fileName) catch |err| { std.log.err("Cannot write file {s} due to {s}", .{fileName, @errorName(err)}); @@ -616,7 +616,7 @@ pub const Frustum = struct { const cameraUp = vec.xyz(invRotationMatrix.mulVec(Vec4f{0, 1, 0, 1})); const cameraRight = vec.xyz(invRotationMatrix.mulVec(Vec4f{1, 0, 0, 1})); - const halfVSide = std.math.tan(std.math.degreesToRadians(f32, fovY)*0.5); + const halfVSide = std.math.tan(std.math.degreesToRadians(fovY)*0.5); const halfHSide = halfVSide*@as(f32, @floatFromInt(width))/@as(f32, @floatFromInt(height)); var self: Frustum = undefined; diff --git a/src/renderer/chunk_meshing.zig b/src/renderer/chunk_meshing.zig index cd59df22..8a1eb6e9 100644 --- a/src/renderer/chunk_meshing.zig +++ b/src/renderer/chunk_meshing.zig @@ -467,7 +467,7 @@ pub const ChunkMesh = struct { } pub fn deinit(self: *ChunkMesh) void { - std.debug.assert(self.refCount.load(.Monotonic) == 0); + std.debug.assert(self.refCount.load(.monotonic) == 0); self.opaqueMesh.deinit(); self.transparentMesh.deinit(); self.chunk.deinit(); @@ -479,21 +479,21 @@ pub const ChunkMesh = struct { } pub fn increaseRefCount(self: *ChunkMesh) void { - const prevVal = self.refCount.fetchAdd(1, .Monotonic); + const prevVal = self.refCount.fetchAdd(1, .monotonic); std.debug.assert(prevVal != 0); } /// In cases where it's not certain whether the thing was cleared already. pub fn tryIncreaseRefCount(self: *ChunkMesh) bool { - var prevVal = self.refCount.load(.Monotonic); + var prevVal = self.refCount.load(.monotonic); while(prevVal != 0) { - prevVal = self.refCount.cmpxchgWeak(prevVal, prevVal + 1, .Monotonic, .Monotonic) orelse return true; + prevVal = self.refCount.cmpxchgWeak(prevVal, prevVal + 1, .monotonic, .monotonic) orelse return true; } return false; } pub fn decreaseRefCount(self: *ChunkMesh) void { - const prevVal = self.refCount.fetchSub(1, .Monotonic); + const prevVal = self.refCount.fetchSub(1, .monotonic); std.debug.assert(prevVal != 0); if(prevVal == 1) { mesh_storage.addMeshToClearListAndDecreaseRefCount(self); @@ -501,7 +501,7 @@ pub const ChunkMesh = struct { } pub fn scheduleLightRefreshAndDecreaseRefCount(self: *ChunkMesh) void { - if(!self.needsLightRefresh.swap(true, .AcqRel)) { + if(!self.needsLightRefresh.swap(true, .acq_rel)) { LightRefreshTask.scheduleAndDecreaseRefCount(self); } else { self.decreaseRefCount(); @@ -534,7 +534,7 @@ pub const ChunkMesh = struct { } pub fn run(self: *LightRefreshTask) void { - if(self.mesh.needsLightRefresh.swap(false, .AcqRel)) { + if(self.mesh.needsLightRefresh.swap(false, .acq_rel)) { self.mesh.mutex.lock(); self.mesh.finishData(); self.mesh.mutex.unlock(); @@ -633,13 +633,13 @@ pub const ChunkMesh = struct { const shiftSelf: u5 = @intCast(((dx + 1)*3 + dy + 1)*3 + dz + 1); const shiftOther: u5 = @intCast(((-dx + 1)*3 + -dy + 1)*3 + -dz + 1); - if(neighborMesh.litNeighbors.fetchOr(@as(u27, 1) << shiftOther, .Monotonic) ^ @as(u27, 1) << shiftOther == ~@as(u27, 0)) { // Trigger mesh creation for neighbor + if(neighborMesh.litNeighbors.fetchOr(@as(u27, 1) << shiftOther, .monotonic) ^ @as(u27, 1) << shiftOther == ~@as(u27, 0)) { // Trigger mesh creation for neighbor neighborMesh.generateMesh(); } neighborMesh.mutex.lock(); const neighborFinishedLighting = neighborMesh.finishedLighting; neighborMesh.mutex.unlock(); - if(neighborFinishedLighting and self.litNeighbors.fetchOr(@as(u27, 1) << shiftSelf, .Monotonic) ^ @as(u27, 1) << shiftSelf == ~@as(u27, 0)) { + if(neighborFinishedLighting and self.litNeighbors.fetchOr(@as(u27, 1) << shiftSelf, .monotonic) ^ @as(u27, 1) << shiftSelf == ~@as(u27, 0)) { self.generateMesh(); } } @@ -886,7 +886,7 @@ pub const ChunkMesh = struct { } } } - _ = neighborMesh.needsLightRefresh.swap(false, .AcqRel); + _ = neighborMesh.needsLightRefresh.swap(false, .acq_rel); neighborMesh.finishData(); neighborMesh.increaseRefCount(); mesh_storage.addToUpdateListAndDecreaseRefCount(neighborMesh); @@ -962,7 +962,7 @@ pub const ChunkMesh = struct { } self.mutex.lock(); defer self.mutex.unlock(); - _ = self.needsLightRefresh.swap(false, .AcqRel); + _ = self.needsLightRefresh.swap(false, .acq_rel); self.finishData(); mesh_storage.finishMesh(self); } diff --git a/src/renderer/lighting.zig b/src/renderer/lighting.zig index c172b3a8..033d4f35 100644 --- a/src/renderer/lighting.zig +++ b/src/renderer/lighting.zig @@ -71,7 +71,7 @@ pub const ChannelChunk = struct { pub fn getValue(self: *const ChannelChunk, x: i32, y: i32, z: i32) [3]u8 { const index = chunk.getIndex(x, y, z); - return .{self.data[index][0].load(.Unordered), self.data[index][1].load(.Unordered), self.data[index][2].load(.Unordered)}; + return .{self.data[index][0].load(.unordered), self.data[index][1].load(.unordered), self.data[index][2].load(.unordered)}; } fn calculateIncomingOcclusion(result: *[3]u8, block: blocks.Block, voxelSize: u31, neighbor: usize) void { @@ -113,9 +113,9 @@ pub const ChannelChunk = struct { while(lightQueue.dequeue()) |entry| { const index = chunk.getIndex(entry.x, entry.y, entry.z); const oldValue: [3]u8 = .{ - self.data[index][0].load(.Unordered), - self.data[index][1].load(.Unordered), - self.data[index][2].load(.Unordered), + self.data[index][0].load(.unordered), + self.data[index][1].load(.unordered), + self.data[index][2].load(.unordered), }; const newValue: [3]u8 = .{ @max(entry.value[0], oldValue[0]), @@ -123,9 +123,9 @@ pub const ChannelChunk = struct { @max(entry.value[2], oldValue[2]), }; if(newValue[0] == oldValue[0] and newValue[1] == oldValue[1] and newValue[2] == oldValue[2]) continue; - self.data[index][0].store(newValue[0], .Unordered); - self.data[index][1].store(newValue[1], .Unordered); - self.data[index][2].store(newValue[2], .Unordered); + self.data[index][0].store(newValue[0], .unordered); + self.data[index][1].store(newValue[1], .unordered); + self.data[index][2].store(newValue[2], .unordered); for(chunk.Neighbors.iterable) |neighbor| { if(neighbor == entry.sourceDir) continue; const nx = entry.x + chunk.Neighbors.relX[neighbor]; @@ -175,9 +175,9 @@ pub const ChannelChunk = struct { while(lightQueue.dequeue()) |entry| { const index = chunk.getIndex(entry.x, entry.y, entry.z); const oldValue: [3]u8 = .{ - self.data[index][0].load(.Unordered), - self.data[index][1].load(.Unordered), - self.data[index][2].load(.Unordered), + self.data[index][0].load(.unordered), + self.data[index][1].load(.unordered), + self.data[index][2].load(.unordered), }; var activeValue: @Vector(3, bool) = @bitCast(entry.activeValue); var append: bool = false; @@ -204,9 +204,9 @@ pub const ChannelChunk = struct { continue; } isFirstIteration = false; - if(activeValue[0]) self.data[index][0].store(0, .Unordered); - if(activeValue[1]) self.data[index][1].store(0, .Unordered); - if(activeValue[2]) self.data[index][2].store(0, .Unordered); + if(activeValue[0]) self.data[index][0].store(0, .unordered); + if(activeValue[1]) self.data[index][1].store(0, .unordered); + if(activeValue[2]) self.data[index][2].store(0, .unordered); for(chunk.Neighbors.iterable) |neighbor| { if(neighbor == entry.sourceDir) continue; const nx = entry.x + chunk.Neighbors.relX[neighbor]; @@ -309,7 +309,7 @@ pub const ChannelChunk = struct { const neighborLightChunk = neighborMesh.lightingData[@intFromBool(self.isSun)]; const index = chunk.getIndex(x, y, z); const neighborIndex = chunk.getIndex(otherX, otherY, otherZ); - var value: [3]u8 = .{neighborLightChunk.data[neighborIndex][0].load(.Unordered), neighborLightChunk.data[neighborIndex][1].load(.Unordered), neighborLightChunk.data[neighborIndex][2].load(.Unordered)}; + var value: [3]u8 = .{neighborLightChunk.data[neighborIndex][0].load(.unordered), neighborLightChunk.data[neighborIndex][1].load(.unordered), neighborLightChunk.data[neighborIndex][2].load(.unordered)}; if(!self.isSun or neighbor != chunk.Neighbors.dirUp or value[0] != 255 or value[1] != 255 or value[2] != 255) { value[0] -|= 8*|@as(u8, @intCast(self.ch.pos.voxelSize)); @@ -332,7 +332,7 @@ pub const ChannelChunk = struct { defer lightQueue.deinit(); for(lights) |pos| { const index = chunk.getIndex(pos[0], pos[1], pos[2]); - lightQueue.enqueue(.{.x = @intCast(pos[0]), .y = @intCast(pos[1]), .z = @intCast(pos[2]), .value = .{self.data[index][0].load(.Unordered), self.data[index][1].load(.Unordered), self.data[index][2].load(.Unordered)}, .sourceDir = 6, .activeValue = 0b111}); + lightQueue.enqueue(.{.x = @intCast(pos[0]), .y = @intCast(pos[1]), .z = @intCast(pos[2]), .value = .{self.data[index][0].load(.unordered), self.data[index][1].load(.unordered), self.data[index][2].load(.unordered)}, .sourceDir = 6, .activeValue = 0b111}); } var constructiveEntries: main.ListUnmanaged(ChunkEntries) = .{}; defer constructiveEntries.deinit(main.stackAllocator); @@ -348,11 +348,11 @@ pub const ChannelChunk = struct { const channelChunk = if(mesh) |_mesh| _mesh.lightingData[@intFromBool(self.isSun)] else self; for(entryList.items) |entry| { const index = chunk.getIndex(entry.x, entry.y, entry.z); - const value = .{channelChunk.data[index][0].load(.Unordered), channelChunk.data[index][1].load(.Unordered), channelChunk.data[index][2].load(.Unordered)}; + const value = .{channelChunk.data[index][0].load(.unordered), channelChunk.data[index][1].load(.unordered), channelChunk.data[index][2].load(.unordered)}; if(value[0] == 0 and value[1] == 0 and value[2] == 0) continue; - channelChunk.data[index][0].store(0, .Unordered); - channelChunk.data[index][1].store(0, .Unordered); - channelChunk.data[index][2].store(0, .Unordered); + channelChunk.data[index][0].store(0, .unordered); + channelChunk.data[index][1].store(0, .unordered); + channelChunk.data[index][2].store(0, .unordered); lightQueue.enqueue(.{.x = entry.x, .y = entry.y, .z = entry.z, .value = value, .sourceDir = 6, .activeValue = 0b111}); } channelChunk.propagateDirect(&lightQueue); diff --git a/src/renderer/mesh_storage.zig b/src/renderer/mesh_storage.zig index 88918927..892c59d0 100644 --- a/src/renderer/mesh_storage.zig +++ b/src/renderer/mesh_storage.zig @@ -129,9 +129,9 @@ fn getMapPieceLocation(x: i32, y: i32, voxelSize: u31) *Atomic(?*LightMap.LightM } pub fn getLightMapPieceAndIncreaseRefCount(x: i32, y: i32, voxelSize: u31) ?*LightMap.LightMapFragment { - const result: *LightMap.LightMapFragment = getMapPieceLocation(x, y, voxelSize).load(.Acquire) orelse return null; + const result: *LightMap.LightMapFragment = getMapPieceLocation(x, y, voxelSize).load(.acquire) orelse return null; var refCount: u16 = 1; - while(result.refCount.cmpxchgWeak(refCount, refCount+1, .Monotonic, .Monotonic)) |otherVal| { + while(result.refCount.cmpxchgWeak(refCount, refCount+1, .monotonic, .monotonic)) |otherVal| { if(otherVal == 0) return null; refCount = otherVal; } @@ -140,7 +140,7 @@ pub fn getLightMapPieceAndIncreaseRefCount(x: i32, y: i32, voxelSize: u31) ?*Lig pub fn getBlockFromRenderThread(x: i32, y: i32, z: i32) ?blocks.Block { const node = getNodeFromRenderThread(.{.wx = x, .wy = y, .wz = z, .voxelSize=1}); - const mesh = node.mesh.load(.Acquire) orelse return null; + const mesh = node.mesh.load(.acquire) orelse return null; const block = mesh.chunk.getBlock(x & chunk.chunkMask, y & chunk.chunkMask, z & chunk.chunkMask); return block; } @@ -149,7 +149,7 @@ pub fn getBlockFromAnyLodFromRenderThread(x: i32, y: i32, z: i32) blocks.Block { var lod: u5 = 0; while(lod < settings.highestLOD) : (lod += 1) { const node = getNodeFromRenderThread(.{.wx = x, .wy = y, .wz = z, .voxelSize=@as(u31, 1) << lod}); - const mesh = node.mesh.load(.Acquire) orelse continue; + const mesh = node.mesh.load(.acquire) orelse continue; const block = mesh.chunk.getBlock(x & chunk.chunkMask<>sizeShift & 1) | (mesh.pos.wy>>sizeShift & 1)<<1 | (mesh.pos.wz>>sizeShift & 1)<<2); parentMesh.visibilityMask &= ~(@as(u8, 1) << octantIndex); @@ -862,7 +862,7 @@ pub fn updateMeshes(targetTime: i64) void { for(blockUpdateList.items) |blockUpdate| { const pos = chunk.ChunkPosition{.wx=blockUpdate.x, .wy=blockUpdate.y, .wz=blockUpdate.z, .voxelSize=1}; const node = getNodeFromRenderThread(pos); - if(node.mesh.load(.Acquire)) |mesh| { + if(node.mesh.load(.acquire)) |mesh| { mesh.updateBlock(blockUpdate.x, blockUpdate.y, blockUpdate.z, blockUpdate.newBlock); } // TODO: It seems like we simply ignore the block update if we don't have the mesh yet. } @@ -887,7 +887,7 @@ pub fn updateMeshes(targetTime: i64) void { mutex.unlock(); defer mutex.lock(); mesh.decreaseRefCount(); - if(getNodeFromRenderThread(mesh.pos).mesh.load(.Acquire) != mesh) continue; // This mesh isn't used for rendering anymore. + if(getNodeFromRenderThread(mesh.pos).mesh.load(.acquire) != mesh) continue; // This mesh isn't used for rendering anymore. mesh.uploadData(); if(std.time.milliTimestamp() >= targetTime) break; // Update at least one mesh. } @@ -895,7 +895,7 @@ pub fn updateMeshes(targetTime: i64) void { if(!isMapInRenderDistance(map.pos)) { map.decreaseRefCount(); } else { - if(getMapPieceLocation(map.pos.wx, map.pos.wy, map.pos.voxelSize).swap(map, .AcqRel)) |old| { + if(getMapPieceLocation(map.pos.wx, map.pos.wy, map.pos.voxelSize).swap(map, .acq_rel)) |old| { old.decreaseRefCount(); } } @@ -932,7 +932,7 @@ pub fn updateMeshes(targetTime: i64) void { const node = getNodeFromRenderThread(mesh.pos); mesh.finishedMeshing = true; mesh.uploadData(); - if(node.mesh.swap(mesh, .AcqRel)) |oldMesh| { + if(node.mesh.swap(mesh, .acq_rel)) |oldMesh| { oldMesh.decreaseRefCount(); } } else { @@ -943,14 +943,14 @@ pub fn updateMeshes(targetTime: i64) void { } pub fn addMeshToClearListAndDecreaseRefCount(mesh: *chunk_meshing.ChunkMesh) void { - std.debug.assert(mesh.refCount.load(.Monotonic) == 0); + std.debug.assert(mesh.refCount.load(.monotonic) == 0); mutex.lock(); defer mutex.unlock(); clearList.append(mesh); } pub fn addToUpdateListAndDecreaseRefCount(mesh: *chunk_meshing.ChunkMesh) void { - std.debug.assert(mesh.refCount.load(.Monotonic) != 0); + std.debug.assert(mesh.refCount.load(.monotonic) != 0); mutex.lock(); defer mutex.unlock(); if(mesh.finishedMeshing) { @@ -968,7 +968,7 @@ pub fn addMeshToStorage(mesh: *chunk_meshing.ChunkMesh) error{AlreadyStored}!voi defer mutex.unlock(); if(isInRenderDistance(mesh.pos)) { const node = getNodeFromRenderThread(mesh.pos); - if(node.mesh.cmpxchgStrong(null, mesh, .AcqRel, .Monotonic) != null) { + if(node.mesh.cmpxchgStrong(null, mesh, .acq_rel, .monotonic) != null) { return error.AlreadyStored; } else { mesh.increaseRefCount(); diff --git a/src/server/server.zig b/src/server/server.zig index 93108c7d..300aacf1 100644 --- a/src/server/server.zig +++ b/src/server/server.zig @@ -63,7 +63,7 @@ pub const User = struct { pub fn update(self: *User) void { std.debug.assert(!mutex.tryLock()); // The mutex should be locked when calling this function. var time = @as(i16, @truncate(std.time.milliTimestamp())) -% main.settings.entityLookback; - time -%= self.timeDifference.difference.load(.Monotonic); + time -%= self.timeDifference.difference.load(.monotonic); self.interpolation.update(time, self.lastTime); self.lastTime = time; } @@ -168,11 +168,11 @@ pub fn start(name: []const u8) void { var sta = utils.StackAllocator.init(main.globalAllocator, 1 << 23); defer sta.deinit(); main.stackAllocator = sta.allocator(); - std.debug.assert(!running.load(.Monotonic)); // There can only be one server. + std.debug.assert(!running.load(.monotonic)); // There can only be one server. init(name); defer deinit(); - running.store(true, .Monotonic); - while(running.load(.Monotonic)) { + running.store(true, .monotonic); + while(running.load(.monotonic)) { const newTime = std.time.nanoTimestamp(); if(newTime -% lastTime < updateNanoTime) { std.time.sleep(@intCast(lastTime +% updateNanoTime -% newTime)); @@ -187,7 +187,7 @@ pub fn start(name: []const u8) void { } pub fn stop() void { - running.store(false, .Monotonic); + running.store(false, .monotonic); } pub fn disconnect(user: *User) void { diff --git a/src/server/terrain/CaveBiomeMap.zig b/src/server/terrain/CaveBiomeMap.zig index 925bb0e9..b2167fe0 100644 --- a/src/server/terrain/CaveBiomeMap.zig +++ b/src/server/terrain/CaveBiomeMap.zig @@ -458,7 +458,7 @@ pub fn deinit() void { } fn mapFragmentDeinit(mapFragment: *CaveBiomeMapFragment) void { - if(@atomicRmw(u16, &mapFragment.refCount.raw, .Sub, 1, .Monotonic) == 1) { + if(@atomicRmw(u16, &mapFragment.refCount.raw, .Sub, 1, .monotonic) == 1) { main.globalAllocator.destroy(mapFragment); } } @@ -469,7 +469,7 @@ fn cacheInit(pos: ChunkPosition) *CaveBiomeMapFragment { for(profile.caveBiomeGenerators) |generator| { generator.generate(mapFragment, profile.seed ^ generator.generatorSeed); } - _= @atomicRmw(u16, &mapFragment.refCount.raw, .Add, 1, .Monotonic); + _= @atomicRmw(u16, &mapFragment.refCount.raw, .Add, 1, .monotonic); return mapFragment; } @@ -482,6 +482,6 @@ fn getOrGenerateFragment(_wx: i32, _wy: i32, _wz: i32) *CaveBiomeMapFragment { .voxelSize = CaveBiomeMapFragment.caveBiomeSize, }; const result = cache.findOrCreate(compare, cacheInit); - std.debug.assert(@atomicRmw(u16, &result.refCount.raw, .Add, 1, .Monotonic) != 0); + std.debug.assert(@atomicRmw(u16, &result.refCount.raw, .Add, 1, .monotonic) != 0); return result; } \ No newline at end of file diff --git a/src/server/terrain/CaveMap.zig b/src/server/terrain/CaveMap.zig index b3c2b840..d2173581 100644 --- a/src/server/terrain/CaveMap.zig +++ b/src/server/terrain/CaveMap.zig @@ -289,7 +289,7 @@ var cache: Cache(CaveMapFragment, cacheSize, associativity, mapFragmentDeinit) = var profile: TerrainGenerationProfile = undefined; fn mapFragmentDeinit(mapFragment: *CaveMapFragment) void { - if(@atomicRmw(u16, &mapFragment.refCount.raw, .Sub, 1, .Monotonic) == 1) { + if(@atomicRmw(u16, &mapFragment.refCount.raw, .Sub, 1, .monotonic) == 1) { main.globalAllocator.destroy(mapFragment); } } @@ -300,7 +300,7 @@ fn cacheInit(pos: ChunkPosition) *CaveMapFragment { for(profile.caveGenerators) |generator| { generator.generate(mapFragment, profile.seed ^ generator.generatorSeed); } - _ = @atomicRmw(u16, &mapFragment.refCount.raw, .Add, 1, .Monotonic); + _ = @atomicRmw(u16, &mapFragment.refCount.raw, .Add, 1, .monotonic); return mapFragment; } @@ -331,6 +331,6 @@ fn getOrGenerateFragment(wx: i32, wy: i32, wz: i32, voxelSize: u31) *CaveMapFrag .voxelSize = voxelSize, }; const result = cache.findOrCreate(compare, cacheInit); - std.debug.assert(@atomicRmw(u16, &result.refCount.raw, .Add, 1, .Monotonic) != 0); + std.debug.assert(@atomicRmw(u16, &result.refCount.raw, .Add, 1, .monotonic) != 0); return result; } \ No newline at end of file diff --git a/src/server/terrain/ClimateMap.zig b/src/server/terrain/ClimateMap.zig index 0617c442..941a2adc 100644 --- a/src/server/terrain/ClimateMap.zig +++ b/src/server/terrain/ClimateMap.zig @@ -106,7 +106,7 @@ pub fn deinitGenerators() void { } fn mapFragmentDeinit(mapFragment: *ClimateMapFragment) void { - if(@atomicRmw(u16, &mapFragment.refCount.raw, .Sub, 1, .Monotonic) == 1) { + if(@atomicRmw(u16, &mapFragment.refCount.raw, .Sub, 1, .monotonic) == 1) { main.globalAllocator.destroy(mapFragment); } } @@ -115,7 +115,7 @@ fn cacheInit(pos: ClimateMapFragmentPosition) *ClimateMapFragment { const mapFragment = main.globalAllocator.create(ClimateMapFragment); mapFragment.init(pos.wx, pos.wy); profile.climateGenerator.generateMapFragment(mapFragment, profile.seed); - _ = @atomicRmw(u16, &mapFragment.refCount.raw, .Add, 1, .Monotonic); + _ = @atomicRmw(u16, &mapFragment.refCount.raw, .Add, 1, .monotonic); return mapFragment; } @@ -131,7 +131,7 @@ pub fn deinit() void { fn getOrGenerateFragment(wx: i32, wy: i32) *ClimateMapFragment { const compare = ClimateMapFragmentPosition{.wx = wx, .wy = wy}; const result = cache.findOrCreate(compare, cacheInit); - std.debug.assert(@atomicRmw(u16, &result.refCount.raw, .Add, 1, .Monotonic) != 0); + std.debug.assert(@atomicRmw(u16, &result.refCount.raw, .Add, 1, .monotonic) != 0); return result; } diff --git a/src/server/terrain/LightMap.zig b/src/server/terrain/LightMap.zig index cbac64d4..efb8adf6 100644 --- a/src/server/terrain/LightMap.zig +++ b/src/server/terrain/LightMap.zig @@ -30,7 +30,7 @@ pub const LightMapFragment = struct { } pub fn decreaseRefCount(self: *LightMapFragment) void { - if(@atomicRmw(u16, &self.refCount.raw, .Sub, 1, .Monotonic) == 1) { + if(@atomicRmw(u16, &self.refCount.raw, .Sub, 1, .monotonic) == 1) { main.globalAllocator.destroy(self); } } @@ -60,7 +60,7 @@ fn cacheInit(pos: MapFragmentPosition) *LightMapFragment { mapFragment.startHeight[x << LightMapFragment.mapShift | y] = @max(0, baseHeight +| 16); // Simple heuristic. TODO: Update this value once chunks get generated in the region. } } - _ = @atomicRmw(u16, &mapFragment.refCount.raw, .Add, 1, .Monotonic); + _ = @atomicRmw(u16, &mapFragment.refCount.raw, .Add, 1, .monotonic); return mapFragment; } @@ -76,6 +76,6 @@ pub fn getOrGenerateFragment(wx: i32, wy: i32, voxelSize: u31) *LightMapFragment voxelSize ); const result = cache.findOrCreate(compare, cacheInit); - std.debug.assert(@atomicRmw(u16, &result.refCount.raw, .Add, 1, .Monotonic) != 0); + std.debug.assert(@atomicRmw(u16, &result.refCount.raw, .Add, 1, .monotonic) != 0); return result; } \ No newline at end of file diff --git a/src/server/terrain/SurfaceMap.zig b/src/server/terrain/SurfaceMap.zig index 71d71290..a0084c63 100644 --- a/src/server/terrain/SurfaceMap.zig +++ b/src/server/terrain/SurfaceMap.zig @@ -138,7 +138,7 @@ pub fn deinitGenerators() void { } fn mapFragmentDeinit(mapFragment: *MapFragment) void { - if(@atomicRmw(u16, &mapFragment.refCount.raw, .Sub, 1, .Monotonic) == 1) { + if(@atomicRmw(u16, &mapFragment.refCount.raw, .Sub, 1, .monotonic) == 1) { main.globalAllocator.destroy(mapFragment); } } @@ -147,7 +147,7 @@ fn cacheInit(pos: MapFragmentPosition) *MapFragment { const mapFragment = main.globalAllocator.create(MapFragment); mapFragment.init(pos.wx, pos.wy, pos.voxelSize); profile.mapFragmentGenerator.generateMapFragment(mapFragment, profile.seed); - _ = @atomicRmw(u16, &mapFragment.refCount.raw, .Add, 1, .Monotonic); + _ = @atomicRmw(u16, &mapFragment.refCount.raw, .Add, 1, .monotonic); return mapFragment; } @@ -167,6 +167,6 @@ pub fn getOrGenerateFragment(wx: i32, wy: i32, voxelSize: u31) *MapFragment { voxelSize ); const result = cache.findOrCreate(compare, cacheInit); - std.debug.assert(@atomicRmw(u16, &result.refCount.raw, .Add, 1, .Monotonic) != 0); + std.debug.assert(@atomicRmw(u16, &result.refCount.raw, .Add, 1, .monotonic) != 0); return result; } \ No newline at end of file diff --git a/src/utils.zig b/src/utils.zig index b8e67b1b..f095ab52 100644 --- a/src/utils.zig +++ b/src/utils.zig @@ -1051,7 +1051,7 @@ pub const ThreadPool = struct { } // Wait for active tasks: for(self.currentTasks) |*task| { - while(task.load(.Monotonic) == vtable) { + while(task.load(.monotonic) == vtable) { std.time.sleep(1e6); } } @@ -1067,9 +1067,9 @@ pub const ThreadPool = struct { while(true) { { const task = self.loadList.extractMax() catch break; - self.currentTasks[id].store(task.vtable, .Monotonic); + self.currentTasks[id].store(task.vtable, .monotonic); task.vtable.run(task.self); - self.currentTasks[id].store(null, .Monotonic); + self.currentTasks[id].store(null, .monotonic); } if(id == 0 and std.time.milliTimestamp() -% lastUpdate > refreshTime) { @@ -1204,13 +1204,13 @@ pub fn Cache(comptime T: type, comptime numberOfBuckets: u32, comptime bucketSiz /// Tries to find the entry that fits to the supplied hashable. pub fn find(self: *@This(), compareAndHash: anytype) ?*T { const index: u32 = compareAndHash.hashCode() & hashMask; - _ = @atomicRmw(usize, &self.cacheRequests.raw, .Add, 1, .Monotonic); + _ = @atomicRmw(usize, &self.cacheRequests.raw, .Add, 1, .monotonic); self.buckets[index].mutex.lock(); defer self.buckets[index].mutex.unlock(); if(self.buckets[index].find(compareAndHash)) |item| { return item; } - _ = @atomicRmw(usize, &self.cacheMisses.raw, .Add, 1, .Monotonic); + _ = @atomicRmw(usize, &self.cacheMisses.raw, .Add, 1, .monotonic); return null; } @@ -1400,13 +1400,13 @@ pub const TimeDifference = struct { const currentTime: i16 = @truncate(std.time.milliTimestamp()); const timeDifference = currentTime -% time; if(self.firstValue) { - self.difference.store(timeDifference, .Monotonic); + self.difference.store(timeDifference, .monotonic); self.firstValue = false; } - if(timeDifference -% self.difference.load(.Monotonic) > 0) { - _ = @atomicRmw(i16, &self.difference.raw, .Add, 1, .Monotonic); - } else if(timeDifference -% self.difference.load(.Monotonic) < 0) { - _ = @atomicRmw(i16, &self.difference.raw, .Add, -1, .Monotonic); + if(timeDifference -% self.difference.load(.monotonic) > 0) { + _ = @atomicRmw(i16, &self.difference.raw, .Add, 1, .monotonic); + } else if(timeDifference -% self.difference.load(.monotonic) < 0) { + _ = @atomicRmw(i16, &self.difference.raw, .Add, -1, .monotonic); } } }; \ No newline at end of file diff --git a/src/utils/file_monitor.zig b/src/utils/file_monitor.zig index 2f7c79ee..2da930b4 100644 --- a/src/utils/file_monitor.zig +++ b/src/utils/file_monitor.zig @@ -63,7 +63,7 @@ const LinuxImpl = struct { fn init() void { fd = c.inotify_init(); if(fd == -1) { - std.log.err("Error while initializing inotifiy: {}", .{std.os.errno(fd)}); + std.log.err("Error while initializing inotifiy: {}", .{std.posix.errno(fd)}); } watchDescriptors = std.StringHashMap(*DirectoryInfo).init(main.globalAllocator.allocator); callbacks = std.AutoHashMap(c_int, *DirectoryInfo).init(main.globalAllocator.allocator); @@ -72,7 +72,7 @@ const LinuxImpl = struct { fn deinit() void { const result = c.close(fd); if(result == -1) { - std.log.err("Error while closing file descriptor: {}", .{std.os.errno(result)}); + std.log.err("Error while closing file descriptor: {}", .{std.posix.errno(result)}); } var iterator = watchDescriptors.iterator(); while(iterator.next()) |entry| { @@ -120,14 +120,14 @@ const LinuxImpl = struct { var available: c_uint = 0; const result = c.ioctl(fd, c.FIONREAD, &available); if(result == -1) { - std.log.err("Error while checking the number of available bytes for the inotify file descriptor: {}", .{std.os.errno(result)}); + std.log.err("Error while checking the number of available bytes for the inotify file descriptor: {}", .{std.posix.errno(result)}); } if(available == 0) return; const events: []u8 = main.stackAllocator.alloc(u8, available); defer main.stackAllocator.free(events); const readBytes = c.read(fd, events.ptr, available); if(readBytes == -1) { - std.log.err("Error while reading inotify event: {}", .{std.os.errno(readBytes)}); + std.log.err("Error while reading inotify event: {}", .{std.posix.errno(readBytes)}); return; } var triggeredCallbacks = std.AutoHashMap(*DirectoryInfo, void).init(main.stackAllocator.allocator); // Avoid duplicate calls @@ -157,7 +157,7 @@ const LinuxImpl = struct { std.debug.assert(!mutex.tryLock()); const watchDescriptor = c.inotify_add_watch(fd, path.ptr, c.IN_CLOSE_WRITE | c.IN_DELETE | c.IN_CREATE | c.IN_MOVE | c.IN_ONLYDIR); if(watchDescriptor == -1) { - std.log.err("Error while adding watch descriptor for path {s}: {}", .{path, std.os.errno(watchDescriptor)}); + std.log.err("Error while adding watch descriptor for path {s}: {}", .{path, std.posix.errno(watchDescriptor)}); } callbacks.put(watchDescriptor, info) catch unreachable; info.watchDescriptors.append(main.globalAllocator, watchDescriptor); @@ -168,8 +168,8 @@ const LinuxImpl = struct { _ = callbacks.remove(watchDescriptor); const result = c.inotify_rm_watch(fd, watchDescriptor); if(result == -1) { - const err = std.os.errno(result); - if(err != .INVAL) std.log.err("Error while removing watch descriptors for path {s}: {}", .{path, std.os.errno(result)}); + const err = std.posix.errno(result); + if(err != .INVAL) std.log.err("Error while removing watch descriptors for path {s}: {}", .{path, err}); } }