AstralTransRocketries/Cubyz
1
0
Fork 0
mirror of https://github.com/PixelGuys/Cubyz.git synced 2025-08-03 19:28:49 -04:00
Code Issues Packages Projects Releases Wiki Activity

Occlusion culling

Browse Source
This commit is contained in:
IntegratedQuantum 2023-08-15 21:11:40 +02:00
parent 83e8d52120
commit a703cb6c6a
5 changed files with 355 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

70
src/chunk.zig
View File

@ -52,6 +52,27 @@ pub const Neighbors = struct {
pub const bitMask = [_]u6 {0x01, 0x02, 0x04, 0x08, 0x10, 0x20};
/// To iterate over all neighbors easily
pub const iterable = [_]u3 {0, 1, 2, 3, 4, 5};
/// Marks the two dimension that are orthogonal
pub const orthogonalComponents = [_]Vec3i {
.{1, 0, 1},
.{1, 0, 1},
.{0, 1, 1},
.{0, 1, 1},
.{1, 1, 0},
.{1, 1, 0},
};
pub const isPositive = [_]bool {true, false, true, false, true, false};
pub const vectorComponent = [_]enum(u2){x = 0, y = 1, z = 2} {.y, .y, .x, .x, .z, .z};
pub fn extractDirectionComponent(self: u3, in: anytype) @TypeOf(in[0]) {
switch(self) {
inline else => |val| {
if(val >= 6) unreachable;
return in[@intFromEnum(vectorComponent[val])];
}
}
}
};
/// Gets the index of a given position inside this chunk.
@ -105,6 +126,25 @@ pub const ChunkPosition = struct {
return dx*dx + dy*dy + dz*dz;
}
pub fn getMaxDistanceSquared(self: ChunkPosition, playerPosition: Vec3d) f64 {
var halfWidth: f64 = @floatFromInt(self.voxelSize*@divExact(chunkSize, 2));
var dx = @fabs(@as(f64, @floatFromInt(self.wx)) + halfWidth - playerPosition[0]);
var dy = @fabs(@as(f64, @floatFromInt(self.wy)) + halfWidth - playerPosition[1]);
var dz = @fabs(@as(f64, @floatFromInt(self.wz)) + halfWidth - playerPosition[2]);
dx = dx + halfWidth;
dy = dy + halfWidth;
dz = dz + halfWidth;
return dx*dx + dy*dy + dz*dz;
}
pub fn getCenterDistanceSquared(self: ChunkPosition, playerPosition: Vec3d) f64 {
var halfWidth: f64 = @floatFromInt(self.voxelSize*@divExact(chunkSize, 2));
var dx = @as(f64, @floatFromInt(self.wx)) + halfWidth - playerPosition[0];
var dy = @as(f64, @floatFromInt(self.wy)) + halfWidth - playerPosition[1];
var dz = @as(f64, @floatFromInt(self.wz)) + halfWidth - playerPosition[2];
return dx*dx + dy*dy + dz*dz;
}
pub fn getPriority(self: ChunkPosition, playerPos: Vec3d) f32 {
return -@as(f32, @floatCast(self.getMinDistanceSquared(playerPos)))/@as(f32, @floatFromInt(self.voxelSize*self.voxelSize)) + 2*@as(f32, @floatFromInt(std.math.log2_int(u31, self.voxelSize)*chunkSize*chunkSize));
}
@ -372,6 +412,8 @@ pub const meshing = struct {
var vbo: c_uint = undefined;
var faces: std.ArrayList(u32) = undefined;
pub var faceBuffer: graphics.LargeBuffer = undefined;
pub var quadsDrawn: usize = 0;
pub var transparentQuadsDrawn: usize = 0;
pub fn init() !void {
shader = try Shader.initAndGetUniforms("assets/cubyz/shaders/chunks/chunk_vertex.vs", "assets/cubyz/shaders/chunks/chunk_fragment.fs", &uniforms);
@ -585,6 +627,17 @@ pub const meshing = struct {
index: u32,
distance: u32,
};
const BoundingRectToNeighborChunk = struct {
min: Vec3i = @splat(std.math.maxInt(i32)),
max: Vec3i = @splat(0),
fn adjustToBlock(self: *BoundingRectToNeighborChunk, block: Block, pos: Vec3i, neighbor: u3) void {
if(block.viewThrough()) {
self.min = @min(self.min, pos);
self.max = @max(self.max, pos + Neighbors.orthogonalComponents[neighbor]);
}
}
};
pos: ChunkPosition,
size: i32,
chunk: std.atomic.Atomic(?*Chunk),
@ -599,6 +652,8 @@ pub const meshing = struct {
currentSortingSwap: []SortingData = &.{},
lastTransparentUpdatePos: Vec3i = Vec3i{0, 0, 0},
chunkBorders: [6]BoundingRectToNeighborChunk = [1]BoundingRectToNeighborChunk{.{}} ** 6,
pub fn init(allocator: Allocator, pos: ChunkPosition) ChunkMesh {
return ChunkMesh{
.pos = pos,
@ -683,6 +738,19 @@ pub const meshing = struct {
}
}
}
// Check out the borders:
x = 0;
while(x < chunkSize): (x += 1) {
var y: u8 = 0;
while(y < chunkSize): (y += 1) {
self.chunkBorders[Neighbors.dirNegX].adjustToBlock((&chunk.blocks)[getIndex(0, x, y)], .{0, x, y}, Neighbors.dirNegX); // TODO: Wait for the compiler bug to get fixed.
self.chunkBorders[Neighbors.dirPosX].adjustToBlock((&chunk.blocks)[getIndex(chunkSize-1, x, y)], .{chunkSize, x, y}, Neighbors.dirPosX); // TODO: Wait for the compiler bug to get fixed.
self.chunkBorders[Neighbors.dirDown].adjustToBlock((&chunk.blocks)[getIndex(x, 0, y)], .{x, 0, y}, Neighbors.dirDown); // TODO: Wait for the compiler bug to get fixed.
self.chunkBorders[Neighbors.dirUp].adjustToBlock((&chunk.blocks)[getIndex(x, chunkSize-1, y)], .{x, chunkSize, y}, Neighbors.dirUp); // TODO: Wait for the compiler bug to get fixed.
self.chunkBorders[Neighbors.dirNegZ].adjustToBlock((&chunk.blocks)[getIndex(x, y, 0)], .{x, y, 0}, Neighbors.dirNegZ); // TODO: Wait for the compiler bug to get fixed.
self.chunkBorders[Neighbors.dirPosZ].adjustToBlock((&chunk.blocks)[getIndex(x, y, chunkSize-1)], .{x, y, chunkSize}, Neighbors.dirPosZ); // TODO: Wait for the compiler bug to get fixed.
}
}
if(self.chunk.swap(chunk, .Monotonic)) |oldChunk| {
main.globalAllocator.destroy(oldChunk);
@ -948,6 +1016,7 @@ pub const meshing = struct {
);
c.glUniform1i(uniforms.visibilityMask, self.visibilityMask);
c.glUniform1i(uniforms.voxelSize, self.pos.voxelSize);
quadsDrawn += self.opaqueMesh.faces.items.len;
c.glDrawElementsBaseVertex(c.GL_TRIANGLES, self.opaqueMesh.vertexCount, c.GL_UNSIGNED_INT, null, self.opaqueMesh.bufferAllocation.start/8*4);
}
@ -1046,6 +1115,7 @@ pub const meshing = struct {
);
c.glUniform1i(transparentUniforms.visibilityMask, self.visibilityMask);
c.glUniform1i(transparentUniforms.voxelSize, self.pos.voxelSize);
transparentQuadsDrawn += self.transparentMesh.faces.items.len;
c.glDrawElementsBaseVertex(c.GL_TRIANGLES, self.transparentMesh.vertexCount, c.GL_UNSIGNED_INT, null, self.transparentMesh.bufferAllocation.start/8*4);
}
};

3
src/gui/windows/debug.zig
View File

@ -40,8 +40,9 @@ fn flawedRender() !void {
y += 8;
try draw.print("Biome: {s}", .{main.game.world.?.playerBiome.id}, 0, y, 8, .left);
y += 8;
// TODO: packet loss
try draw.print("Opaque faces: {}, Transparent faces: {}", .{main.chunk.meshing.quadsDrawn, main.chunk.meshing.transparentQuadsDrawn}, 0, y, 8, .left);
y += 8;
// TODO: packet loss
// TODO: Protocol statistics(maybe?)
}
}

2
src/gui/windows/save_selection.zig
View File

@ -125,7 +125,7 @@ pub fn onOpen() Allocator.Error!void {
const decodedName = try parseEscapedFolderName(entry.name);
defer main.threadAllocator.free(decodedName);
const name = try buttonNameArena.allocator().dupeZ(u8, entry.name); // Null terminate, so we can later recover the string from jsut the pointer.
const name = try buttonNameArena.allocator().dupeZ(u8, entry.name); // Null terminate, so we can later recover the string from just the pointer.
const buttonName = try std.fmt.allocPrint(buttonNameArena.allocator(), "Play {s}", .{decodedName});
try row.add(try Button.initText(.{0, 0}, 128, buttonName, .{.callback = &openWorld, .arg = @intFromPtr(name.ptr)}));

314
src/renderer.zig
View File

@ -18,6 +18,7 @@ const network = @import("network.zig");
const settings = @import("settings.zig");
const utils = @import("utils.zig");
const vec = @import("vec.zig");
const Vec2f = vec.Vec2f;
const Vec3i = vec.Vec3i;
const Vec3f = vec.Vec3f;
const Vec3d = vec.Vec3d;
@ -198,6 +199,7 @@ pub fn renderWorld(world: *World, ambientLight: Vec3f, skyColor: Vec3f, playerPo
// Uses FrustumCulling on the chunks.
var frustum = Frustum.init(Vec3f{0, 0, 0}, game.camera.viewMatrix, lastFov, lastWidth, lastHeight);
_ = frustum;
const time: u32 = @intCast(std.time.milliTimestamp() & std.math.maxInt(u32));
var waterFog = Fog{.active=true, .color=.{0.0, 0.1, 0.2}, .density=0.1};
@ -213,7 +215,9 @@ pub fn renderWorld(world: *World, ambientLight: Vec3f, skyColor: Vec3f, playerPo
// SimpleList<NormalChunkMesh> visibleChunks = new SimpleList<NormalChunkMesh>(new NormalChunkMesh[64]);
// SimpleList<ReducedChunkMesh> visibleReduced = new SimpleList<ReducedChunkMesh>(new ReducedChunkMesh[64]);
const meshes = try RenderStructure.updateAndGetRenderChunks(game.world.?.conn, playerPos, settings.renderDistance, settings.LODFactor, frustum);
chunk.meshing.quadsDrawn = 0;
chunk.meshing.transparentQuadsDrawn = 0;
const meshes = try RenderStructure.updateAndGetRenderChunks(game.world.?.conn, playerPos, settings.renderDistance, settings.LODFactor);
try sortChunks(meshes, playerPos);
@ -865,6 +869,26 @@ pub const MeshSelection = struct {
}
}
}
pub fn drawCube(projectionMatrix: Mat4f, viewMatrix: Mat4f, relativePositionToPlayer: Vec3d, min: Vec3f, max: Vec3f) void {
shader.bind();
c.glUniformMatrix4fv(uniforms.projectionMatrix, 1, c.GL_FALSE, @ptrCast(&projectionMatrix));
c.glUniformMatrix4fv(uniforms.viewMatrix, 1, c.GL_FALSE, @ptrCast(&viewMatrix));
c.glUniform3f(uniforms.modelPosition,
@floatCast(relativePositionToPlayer[0]),
@floatCast(relativePositionToPlayer[1]),
@floatCast(relativePositionToPlayer[2]),
);
c.glUniform3f(uniforms.lowerBounds, min[0], min[1], min[2]);
c.glUniform3f(uniforms.upperBounds, max[0], max[1], max[2]);
c.glBindVertexArray(cubeVAO);
// c.glLineWidth(2); // TODO: Draw thicker lines so they are more visible. Maybe a simple shader + cube mesh is enough.
c.glDrawElements(c.GL_LINES, 12*2, c.GL_UNSIGNED_BYTE, null);
}
pub fn render(projectionMatrix: Mat4f, viewMatrix: Mat4f, playerPos: Vec3d) void {
if(selectedBlockPos) |_selectedBlockPos| {
var block = RenderStructure.getBlock(_selectedBlockPos[0], _selectedBlockPos[1], _selectedBlockPos[2]) orelse return;
@ -874,28 +898,7 @@ pub const MeshSelection = struct {
var transformedMax = model.permutation.transform(voxelModel.max - @as(Vec3i, @splat(8))) + @as(Vec3i, @splat(8));
const min = @min(transformedMin, transformedMax);
const max = @max(transformedMin ,transformedMax);
shader.bind();
c.glUniformMatrix4fv(uniforms.projectionMatrix, 1, c.GL_FALSE, @ptrCast(&projectionMatrix));
c.glUniformMatrix4fv(uniforms.viewMatrix, 1, c.GL_FALSE, @ptrCast(&viewMatrix));
c.glUniform3f(uniforms.modelPosition,
@floatCast(@as(f64, @floatFromInt(_selectedBlockPos[0])) - playerPos[0]),
@floatCast(@as(f64, @floatFromInt(_selectedBlockPos[1])) - playerPos[1]),
@floatCast(@as(f64, @floatFromInt(_selectedBlockPos[2])) - playerPos[2])
);
c.glUniform3f(uniforms.lowerBounds,
@as(f32, @floatFromInt(min[0]))/16.0,
@as(f32, @floatFromInt(min[1]))/16.0,
@as(f32, @floatFromInt(min[2]))/16.0
);
c.glUniform3f(uniforms.upperBounds,
@as(f32, @floatFromInt(max[0]))/16.0,
@as(f32, @floatFromInt(max[1]))/16.0,
@as(f32, @floatFromInt(max[2]))/16.0
);
c.glBindVertexArray(cubeVAO);
c.glDrawElements(c.GL_LINES, 12*2, c.GL_UNSIGNED_BYTE, null); // TODO: Draw thicker lines so they are more visible. Maybe a simple shader + cube mesh is enough.
drawCube(projectionMatrix, viewMatrix, vec.floatFromInt(f64, _selectedBlockPos) - playerPos, vec.floatFromInt(f32, min)/@as(Vec3f, @splat(16.0)), vec.floatFromInt(f32, max)/@as(Vec3f, @splat(16.0)));
}
}
};
@ -905,6 +908,10 @@ pub const RenderStructure = struct {
mesh: chunk.meshing.ChunkMesh,
shouldBeRemoved: bool, // Internal use.
drawableChildren: u32, // How many children can be renderer. If this is 8 then there is no need to render this mesh.
lod: u3,
min: Vec2f,
max: Vec2f,
active: bool,
};
var storageLists: [settings.highestLOD + 1][]?*ChunkMeshNode = [1][]?*ChunkMeshNode{&.{}} ** (settings.highestLOD + 1);
var storageListsSwap: [settings.highestLOD + 1][]?*ChunkMeshNode = [1][]?*ChunkMeshNode{&.{}} ** (settings.highestLOD + 1);
@ -963,6 +970,18 @@ pub const RenderStructure = struct {
meshList.deinit();
}
fn getNodeFromRenderThread(pos: chunk.ChunkPosition) ?*ChunkMeshNode {
var lod = std.math.log2_int(u31, pos.voxelSize);
var xIndex = pos.wx-%(&lastX[lod]).* >> lod+chunk.chunkShift;
var yIndex = pos.wy-%(&lastY[lod]).* >> lod+chunk.chunkShift;
var zIndex = pos.wz-%(&lastZ[lod]).* >> lod+chunk.chunkShift;
if(xIndex < 0 or xIndex >= (&lastSize[lod]).*) return null;
if(yIndex < 0 or yIndex >= (&lastSize[lod]).*) return null;
if(zIndex < 0 or zIndex >= (&lastSize[lod]).*) return null;
var index = (xIndex*(&lastSize[lod]).* + yIndex)*(&lastSize[lod]).* + zIndex;
return storageLists[lod][@intCast(index)];
}
fn _getNode(pos: chunk.ChunkPosition) ?*ChunkMeshNode {
var lod = std.math.log2_int(u31, pos.voxelSize);
lodMutex[lod].lock();
@ -998,7 +1017,7 @@ pub const RenderStructure = struct {
return &node.mesh;
}
pub fn updateAndGetRenderChunks(conn: *network.Connection, playerPos: Vec3d, renderDistance: i32, LODFactor: f32, frustum: Frustum) ![]*chunk.meshing.ChunkMesh {
pub fn updateAndGetRenderChunks(conn: *network.Connection, playerPos: Vec3d, renderDistance: i32, LODFactor: f32) ![]*chunk.meshing.ChunkMesh {
meshList.clearRetainingCapacity();
if(lastRD != renderDistance and lastFactor != LODFactor) {
try network.Protocols.genericUpdate.sendRenderDistance(conn, renderDistance, LODFactor);
@ -1010,7 +1029,7 @@ pub const RenderStructure = struct {
var meshRequests = std.ArrayList(chunk.ChunkPosition).init(main.threadAllocator);
defer meshRequests.deinit();
for(0..storageLists.len) |_lod| {
for(0..storageLists.len) |_lod| { // TODO: Can this be done in a more intelligent way?
const lod: u5 = @intCast(_lod);
var maxRenderDistance = renderDistance*chunk.chunkSize << lod;
if(lod != 0) maxRenderDistance = @intFromFloat(@ceil(@as(f32, @floatFromInt(maxRenderDistance))*LODFactor));
@ -1058,7 +1077,7 @@ pub const RenderStructure = struct {
const zIndex = @divExact(z -% startZ, size);
const index = (xIndex*maxSideLength + yIndex)*maxSideLength + zIndex;
const pos = chunk.ChunkPosition{.wx=x, .wy=y, .wz=z, .voxelSize=@as(u31, 1)<<lod};
var node = _getNode(pos);
var node = getNodeFromRenderThread(pos);
if(node) |_node| {
_node.shouldBeRemoved = false;
} else {
@ -1067,21 +1086,10 @@ pub const RenderStructure = struct {
node.?.shouldBeRemoved = true; // Might be removed in the next iteration.
try meshRequests.append(pos);
}
if(frustum.testAAB(Vec3f{
@floatCast(@as(f64, @floatFromInt(x)) - playerPos[0]),
@floatCast(@as(f64, @floatFromInt(y)) - playerPos[1]),
@floatCast(@as(f64, @floatFromInt(z)) - playerPos[2]),
}, Vec3f{
@floatFromInt(size),
@floatFromInt(size),
@floatFromInt(size),
}) and node.?.mesh.visibilityMask != 0 and !node.?.mesh.isEmpty()) {
try meshList.append(&node.?.mesh);
}
if(lod+1 != storageLists.len and node.?.mesh.generated) {
if(_getNode(.{.wx=x, .wy=y, .wz=z, .voxelSize=@as(u31, 1)<<(lod+1)})) |parent| {
if(getNodeFromRenderThread(.{.wx=x, .wy=y, .wz=z, .voxelSize=@as(u31, 1)<<(lod+1)})) |parent| {
const octantIndex: u3 = @intCast((x>>sizeShift & 1) | (y>>sizeShift & 1)<<1 | (z>>sizeShift & 1)<<2);
parent.mesh.visibilityMask &= ~(@as(u8, 1) << octantIndex);
parent.mesh.visibilityMask &= ~(@as(u8, 1) << octantIndex); // TODO: Find a more robust solution, that also works for the new occlusion culling.
}
}
node.?.drawableChildren = 0;
@ -1105,7 +1113,7 @@ pub const RenderStructure = struct {
if(nullMesh) |mesh| {
if(mesh.shouldBeRemoved) {
if(mesh.mesh.pos.voxelSize != 1 << settings.highestLOD) {
if(_getNode(.{.wx=mesh.mesh.pos.wx, .wy=mesh.mesh.pos.wy, .wz=mesh.mesh.pos.wz, .voxelSize=2*mesh.mesh.pos.voxelSize})) |parent| {
if(getNodeFromRenderThread(.{.wx=mesh.mesh.pos.wx, .wy=mesh.mesh.pos.wy, .wz=mesh.mesh.pos.wz, .voxelSize=2*mesh.mesh.pos.voxelSize})) |parent| {
const octantIndex: u3 = @intCast((mesh.mesh.pos.wx>>sizeShift & 1) | (mesh.mesh.pos.wy>>sizeShift & 1)<<1 | (mesh.mesh.pos.wz>>sizeShift & 1)<<2);
parent.mesh.visibilityMask |= @as(u8, 1) << octantIndex;
}
@ -1134,6 +1142,232 @@ pub const RenderStructure = struct {
}
}
// Does occlusion using a breadth-first search that caches an on-screen visibility rectangle.
const OcclusionData = struct {
node: *ChunkMeshNode,
distance: f64,
pub fn compare(_: void, a: @This(), b: @This()) std.math.Order {
if(a.distance < b.distance) return .lt;
if(a.distance > b.distance) return .gt;
return .eq;
}
};
var floodFillList = std.PriorityQueue(OcclusionData, void, OcclusionData.compare).init(main.threadAllocator, {});
defer floodFillList.deinit();
{
var firstPos = chunk.ChunkPosition{
.wx = @intFromFloat(@floor(playerPos[0])),
.wy = @intFromFloat(@floor(playerPos[1])),
.wz = @intFromFloat(@floor(playerPos[2])),
.voxelSize = 1,
};
firstPos.wx &= ~@as(i32, chunk.chunkMask);
firstPos.wy &= ~@as(i32, chunk.chunkMask);
firstPos.wz &= ~@as(i32, chunk.chunkMask);
var lod: u3 = 0;
while(lod <= settings.highestLOD) : (lod += 1) {
if(getNodeFromRenderThread(firstPos)) |node| if(node.mesh.generated) {
node.lod = lod;
node.min = @splat(-1);
node.max = @splat(1);
node.active = true;
try floodFillList.add(.{
.node = node,
.distance = 0,
});
break;
};
firstPos.wx &= ~@as(i32, firstPos.voxelSize*chunk.chunkSize);
firstPos.wy &= ~@as(i32, firstPos.voxelSize*chunk.chunkSize);
firstPos.wz &= ~@as(i32, firstPos.voxelSize*chunk.chunkSize);
firstPos.voxelSize *= 2;
}
}
const projRotMat = game.projectionMatrix.mul(game.camera.viewMatrix);
while(floodFillList.removeOrNull()) |data| {
data.node.active = false;
const mesh = &data.node.mesh;
try meshList.append(mesh);
const relPos: Vec3d = vec.floatFromInt(f64, Vec3i{mesh.pos.wx, mesh.pos.wy, mesh.pos.wz}) - playerPos;
const relPosFloat: Vec3f = vec.floatCast(f32, relPos);
for(chunk.Neighbors.iterable) |neighbor| continueNeighborLoop: {
const component = chunk.Neighbors.extractDirectionComponent(neighbor, relPos);
if(chunk.Neighbors.isPositive[neighbor] and component + @as(f64, @floatFromInt(chunk.chunkSize*mesh.pos.voxelSize)) <= 0) continue;
if(!chunk.Neighbors.isPositive[neighbor] and component >= 0) continue;
if(@reduce(.Or, @min(mesh.chunkBorders[neighbor].min, mesh.chunkBorders[neighbor].max) != mesh.chunkBorders[neighbor].min)) continue; // There was not a single block in the chunk. TODO: Find a better solution.
const minVec = vec.floatFromInt(f32, mesh.chunkBorders[neighbor].min*@as(Vec3i, @splat(mesh.pos.voxelSize)));
const maxVec = vec.floatFromInt(f32, mesh.chunkBorders[neighbor].max*@as(Vec3i, @splat(mesh.pos.voxelSize)));
var xyMin: Vec2f = .{10, 10};
var xyMax: Vec2f = .{-10, -10};
var numberOfNegatives: u8 = 0;
var corners: [5]Vec4f = undefined;
var curCorner: usize = 0;
for(0..2) |a| {
for(0..2) |b| {
var cornerVector: Vec3f = undefined;
switch(chunk.Neighbors.vectorComponent[neighbor]) {
.x => {
cornerVector[0] = minVec[0];
cornerVector[1] = if(a == 0) minVec[1] else maxVec[1];
cornerVector[2] = if(b == 0) minVec[2] else maxVec[2];
},
.y => {
cornerVector[1] = minVec[1];
cornerVector[0] = if(a == 0) minVec[0] else maxVec[0];
cornerVector[2] = if(b == 0) minVec[2] else maxVec[2];
},
.z => {
cornerVector[2] = minVec[2];
cornerVector[0] = if(a == 0) minVec[0] else maxVec[0];
cornerVector[1] = if(b == 0) minVec[1] else maxVec[1];
},
}
corners[curCorner] = projRotMat.mulVec(vec.combine(relPosFloat + cornerVector, 1));
if(corners[curCorner][3] < 0) {
numberOfNegatives += 1;
}
curCorner += 1;
}
}
switch(numberOfNegatives) { // Oh, so complicated. But this should only trigger very close to the player.
4 => continue,
0 => {},
1 => {
// Needs to duplicate the problematic corner and move it onto the projected plane.
var problematicOne: usize = 0;
for(0..curCorner) |i| {
if(corners[i][3] < 0) {
problematicOne = i;
break;
}
}
const problematicVector = corners[problematicOne];
// The two neighbors of the quad:
const neighborA = corners[problematicOne ^ 1];
const neighborB = corners[problematicOne ^ 2];
// Move the problematic point towards the neighbor:
const one: Vec4f = @splat(1);
const weightA: Vec4f = @splat(problematicVector[3]/(problematicVector[3] - neighborA[3]));
var towardsA = neighborA*weightA + problematicVector*(one - weightA);
towardsA[3] = 0; // Prevent inaccuracies
const weightB: Vec4f = @splat(problematicVector[3]/(problematicVector[3] - neighborB[3]));
var towardsB = neighborB*weightB + problematicVector*(one - weightB);
towardsB[3] = 0; // Prevent inaccuracies
corners[problematicOne] = towardsA;
corners[curCorner] = towardsB;
curCorner += 1;
},
2 => {
// Needs to move the two problematic corners onto the projected plane.
var problematicOne: usize = undefined;
for(0..curCorner) |i| {
if(corners[i][3] < 0) {
problematicOne = i;
break;
}
}
const problematicVectorOne = corners[problematicOne];
var problematicTwo: usize = undefined;
for(problematicOne+1..curCorner) |i| {
if(corners[i][3] < 0) {
problematicTwo = i;
break;
}
}
const problematicVectorTwo = corners[problematicTwo];
const commonDirection = problematicOne ^ problematicTwo;
const projectionDirection = commonDirection ^ 0b11;
// The respective neighbors:
const neighborOne = corners[problematicOne ^ projectionDirection];
const neighborTwo = corners[problematicTwo ^ projectionDirection];
// Move the problematic points towards the neighbor:
const one: Vec4f = @splat(1);
const weightOne: Vec4f = @splat(problematicVectorOne[3]/(problematicVectorOne[3] - neighborOne[3]));
var towardsOne = neighborOne*weightOne + problematicVectorOne*(one - weightOne);
towardsOne[3] = 0; // Prevent inaccuracies
corners[problematicOne] = towardsOne;
const weightTwo: Vec4f = @splat(problematicVectorTwo[3]/(problematicVectorTwo[3] - neighborTwo[3]));
var towardsTwo = neighborTwo*weightTwo + problematicVectorTwo*(one - weightTwo);
towardsTwo[3] = 0; // Prevent inaccuracies
corners[problematicTwo] = towardsTwo;
},
3 => {
// Throw away the far problematic vector, move the other two onto the projection plane.
var neighborIndex: usize = undefined;
for(0..curCorner) |i| {
if(corners[i][3] >= 0) {
neighborIndex = i;
break;
}
}
const neighborVector = corners[neighborIndex];
const problematicVectorOne = corners[neighborIndex ^ 1];
const problematicVectorTwo = corners[neighborIndex ^ 2];
// Move the problematic points towards the neighbor:
const one: Vec4f = @splat(1);
const weightOne: Vec4f = @splat(problematicVectorOne[3]/(problematicVectorOne[3] - neighborVector[3]));
var towardsOne = neighborVector*weightOne + problematicVectorOne*(one - weightOne);
towardsOne[3] = 0; // Prevent inaccuracies
const weightTwo: Vec4f = @splat(problematicVectorTwo[3]/(problematicVectorTwo[3] - neighborVector[3]));
var towardsTwo = neighborVector*weightTwo + problematicVectorTwo*(one - weightTwo);
towardsTwo[3] = 0; // Prevent inaccuracies
corners[0] = neighborVector;
corners[1] = towardsOne;
corners[2] = towardsTwo;
curCorner = 3;
},
else => unreachable,
}
for(0..curCorner) |i| {
const projected = corners[i];
const xy = vec.xy(projected)/@as(Vec2f, @splat(@max(0, projected[3])));
xyMin = @min(xyMin, xy);
xyMax = @max(xyMax, xy);
}
const min = @max(xyMin, data.node.min);
const max = @min(xyMax, data.node.max);
if(@reduce(.Or, min >= max)) continue; // Nothing to render.
var neighborPos = chunk.ChunkPosition{
.wx = mesh.pos.wx + chunk.Neighbors.relX[neighbor]*chunk.chunkSize*mesh.pos.voxelSize,
.wy = mesh.pos.wy + chunk.Neighbors.relY[neighbor]*chunk.chunkSize*mesh.pos.voxelSize,
.wz = mesh.pos.wz + chunk.Neighbors.relZ[neighbor]*chunk.chunkSize*mesh.pos.voxelSize,
.voxelSize = mesh.pos.voxelSize,
};
var lod: u3 = data.node.lod;
while(lod <= settings.highestLOD) : (lod += 1) {
if(getNodeFromRenderThread(neighborPos)) |node| if(node.mesh.generated) {
if(node.active) {
node.min = @min(node.min, min);
node.max = @max(node.max, max);
} else {
node.lod = lod;
node.min = min;
node.max = max;
node.active = true;
try floodFillList.add(.{
.node = node,
.distance = node.mesh.pos.getMaxDistanceSquared(playerPos)
});
}
break :continueNeighborLoop;
};
neighborPos.wx &= ~@as(i32, neighborPos.voxelSize*chunk.chunkSize);
neighborPos.wy &= ~@as(i32, neighborPos.voxelSize*chunk.chunkSize);
neighborPos.wz &= ~@as(i32, neighborPos.voxelSize*chunk.chunkSize);
neighborPos.voxelSize *= 2;
}
}
}
var i: usize = 0;
while(i < clearList.items.len) {
const mesh = clearList.items[i];

8
src/vec.zig
View File

@ -10,10 +10,18 @@ pub const Vec4i = @Vector(4, i32);
pub const Vec4f = @Vector(4, f32);
pub const Vec4d = @Vector(4, f64);
pub inline fn combine(pos: Vec3f, w: f32) Vec4f {
return .{pos[0], pos[1], pos[2], w};
}
pub fn xyz(self: anytype) @Vector(3, @typeInfo(@TypeOf(self)).Vector.child) {
return @Vector(3, @typeInfo(@TypeOf(self)).Vector.child){self[0], self[1], self[2]};
}
pub fn xy(self: anytype) @Vector(2, @typeInfo(@TypeOf(self)).Vector.child) {
return @Vector(2, @typeInfo(@TypeOf(self)).Vector.child){self[0], self[1]};
}
pub fn dot(self: anytype, other: @TypeOf(self)) @typeInfo(@TypeOf(self)).Vector.child {
return @reduce(.Add, self*other);
}