AstralTransRocketries/minosoft
1
0
Fork 0
mirror of https://gitlab.bixilon.de/bixilon/minosoft.git synced 2025-09-15 10:25:06 -04:00
Code Issues Packages Projects Releases Wiki Activity

rendering: use position offset more, fixes

Browse Source
This commit is contained in:
Bixilon 2023-05-23 19:11:43 +02:00
parent 4794d1cf61
commit 553084744f
No known key found for this signature in database
GPG Key ID: 5CAD791931B09AC4
12 changed files with 57 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/main/java/de/bixilon/minosoft/gui/rendering/camera/MatrixHandler.kt
View File

@ -113,7 +113,8 @@ class MatrixHandler(
val fov = calculateFOV()
val view = camera.view.view
val eyePosition = view.eyePosition
val matrixPosition = view.matrixPosition
context.camera.offset.draw()
val matrixPosition = Vec3(eyePosition - context.camera.offset.offset)
val front = view.front
if (upToDate && matrixPosition == this.matrixPosition && front == this.front && fov == previousFOV && shaking.isEmpty) {
return

10
src/main/java/de/bixilon/minosoft/gui/rendering/camera/WorldOffset.kt
View File

@ -17,15 +17,23 @@ import de.bixilon.kotlinglm.vec3.Vec3i
import de.bixilon.kutil.observer.DataObserver.Companion.observed
import de.bixilon.minosoft.data.world.World
import de.bixilon.minosoft.gui.rendering.renderer.drawable.Drawable
import de.bixilon.minosoft.gui.rendering.util.vec.vec3.Vec3dUtil.blockPosition
import de.bixilon.minosoft.gui.rendering.util.vec.vec3.Vec3iUtil.EMPTY
import de.bixilon.minosoft.protocol.protocol.ProtocolDefinition
class WorldOffset(private val camera: Camera) : Drawable {
var offset by observed(Vec3i(100, 100, 100))
var offset by observed(Vec3i.EMPTY)
private set
override fun draw() {
val previous = offset
val position = camera.view.view.eyePosition
val mod = (position.blockPosition / MAX_DISTANCE) * MAX_DISTANCE
if (mod != previous) {
this.offset = mod
}
// TODO: optimize this and use MIN_DISTANCE
}

9
src/main/java/de/bixilon/minosoft/gui/rendering/camera/view/CameraView.kt
View File

@ -32,7 +32,6 @@ interface CameraView {
val updateFrustum: Boolean get() = true
val eyePosition: Vec3d
val matrixPosition: Vec3
val rotation: EntityRotation
val front: Vec3
@ -49,12 +48,4 @@ interface CameraView {
fun draw() = Unit
companion object {
fun CameraView.matrix(eye: Vec3d): Vec3 {
return Vec3(eye - context.camera.offset.offset)
}
}
}

4
src/main/java/de/bixilon/minosoft/gui/rendering/camera/view/DebugView.kt
View File

@ -20,7 +20,6 @@ import de.bixilon.minosoft.data.entities.EntityRotation
import de.bixilon.minosoft.gui.rendering.RenderContext
import de.bixilon.minosoft.gui.rendering.camera.Camera
import de.bixilon.minosoft.gui.rendering.camera.CameraDefinition.CAMERA_UP_VEC3
import de.bixilon.minosoft.gui.rendering.camera.view.CameraView.Companion.matrix
import de.bixilon.minosoft.gui.rendering.util.vec.vec3.Vec3Util.EMPTY
import de.bixilon.minosoft.gui.rendering.util.vec.vec3.Vec3dUtil.EMPTY
import de.bixilon.minosoft.input.camera.MovementInputActions
@ -32,7 +31,6 @@ class DebugView(private val camera: Camera) : CameraView {
override val shaking: Boolean get() = false
override var eyePosition = Vec3d.EMPTY
override var matrixPosition = Vec3.EMPTY
override var rotation = EntityRotation.EMPTY
override var front = Vec3.EMPTY
@ -65,7 +63,6 @@ class DebugView(private val camera: Camera) : CameraView {
movement *= delta
eyePosition = eyePosition + movement
this.matrixPosition = matrix(this.eyePosition)
}
override fun onMouse(delta: Vec2d) {
@ -79,7 +76,6 @@ class DebugView(private val camera: Camera) : CameraView {
override fun onAttach(previous: CameraView?) {
this.eyePosition = previous?.eyePosition ?: Vec3d.EMPTY
this.matrixPosition = matrix(this.eyePosition)
this.rotation = previous?.rotation ?: EntityRotation.EMPTY
this.front = previous?.front ?: Vec3.EMPTY
}

3
src/main/java/de/bixilon/minosoft/gui/rendering/camera/view/person/FirstPersonView.kt
View File

@ -22,7 +22,6 @@ import de.bixilon.minosoft.data.entities.entities.player.PlayerEntity
import de.bixilon.minosoft.gui.rendering.RenderContext
import de.bixilon.minosoft.gui.rendering.camera.Camera
import de.bixilon.minosoft.gui.rendering.camera.view.CameraView
import de.bixilon.minosoft.gui.rendering.camera.view.CameraView.Companion.matrix
import de.bixilon.minosoft.gui.rendering.util.vec.vec3.Vec3Util.EMPTY
import de.bixilon.minosoft.gui.rendering.util.vec.vec3.Vec3dUtil.EMPTY
@ -41,7 +40,6 @@ class FirstPersonView(override val camera: Camera) : PersonView {
override val renderOverlays: Boolean get() = true
override var eyePosition: Vec3d = Vec3d.EMPTY
override var matrixPosition: Vec3 = Vec3.EMPTY
override var rotation = EntityRotation.EMPTY
override var front = Vec3.EMPTY
@ -56,7 +54,6 @@ class FirstPersonView(override val camera: Camera) : PersonView {
private fun update() {
val entity = context.connection.camera.entity
this.eyePosition = entity.renderInfo.eyePosition
this.matrixPosition = matrix(this.eyePosition)
this.rotation = entity.physics.rotation
this.front = this.rotation.front
}

3
src/main/java/de/bixilon/minosoft/gui/rendering/camera/view/person/ThirdPersonView.kt
View File

@ -20,7 +20,6 @@ import de.bixilon.minosoft.data.entities.EntityRotation
import de.bixilon.minosoft.gui.rendering.RenderContext
import de.bixilon.minosoft.gui.rendering.camera.Camera
import de.bixilon.minosoft.gui.rendering.camera.view.CameraView
import de.bixilon.minosoft.gui.rendering.camera.view.CameraView.Companion.matrix
import de.bixilon.minosoft.gui.rendering.util.VecUtil.toVec3d
import de.bixilon.minosoft.gui.rendering.util.vec.vec3.Vec3Util.EMPTY
import de.bixilon.minosoft.gui.rendering.util.vec.vec3.Vec3dUtil.EMPTY
@ -32,7 +31,6 @@ class ThirdPersonView(override val camera: Camera) : PersonView {
override val context: RenderContext get() = camera.context
override var eyePosition: Vec3d = Vec3d.EMPTY
override var matrixPosition: Vec3 = Vec3.EMPTY
override var rotation = EntityRotation.EMPTY
override var front = Vec3.EMPTY
@ -62,7 +60,6 @@ class ThirdPersonView(override val camera: Camera) : PersonView {
val distance = target?.distance?.let { minOf(it, MAX_DISTANCE) } ?: MAX_DISTANCE
this.eyePosition = position + (-front * distance)
this.matrixPosition = matrix(this.eyePosition)
}
override fun onAttach(previous: CameraView?) {

3
src/main/java/de/bixilon/minosoft/gui/rendering/sky/clouds/CloudArray.kt
View File

@ -27,6 +27,7 @@ class CloudArray(
}
private fun build() {
val offset = layer.clouds.context.camera.offset.offset
val matrix = layer.clouds.matrix
val matrixOffset = (offset * ARRAY_SIZE) and 0xFF
@ -47,7 +48,7 @@ class CloudArray(
matrix[matrixX - 1, matrixZ + 0], // WEST
matrix[matrixX + 1, matrixZ + 0], // EAST
)
mesh.createCloud(start, start + CLOUD_SIZE, layer.height.first, layer.height.last, layer.clouds.flat, cull)
mesh.createCloud(start, start + CLOUD_SIZE, offset, layer.height.first, layer.height.last, layer.clouds.flat, cull)
}
}
}

7
src/main/java/de/bixilon/minosoft/gui/rendering/sky/clouds/CloudMesh.kt
View File

@ -16,6 +16,7 @@ package de.bixilon.minosoft.gui.rendering.sky.clouds
import de.bixilon.kotlinglm.vec2.Vec2
import de.bixilon.kotlinglm.vec2.Vec2i
import de.bixilon.kotlinglm.vec3.Vec3
import de.bixilon.kotlinglm.vec3.Vec3i
import de.bixilon.minosoft.data.direction.Directions
import de.bixilon.minosoft.gui.rendering.RenderContext
import de.bixilon.minosoft.gui.rendering.system.base.MeshUtil.buffer
@ -30,9 +31,9 @@ class CloudMesh(context: RenderContext) : Mesh(context, CloudMeshStruct, context
}
fun createCloud(start: Vec2i, end: Vec2i, yStart: Int, yEnd: Int, flat: Boolean, culling: BooleanArray) {
val start = Vec3(start.x, yStart, start.y) + CLOUD_OFFSET
val end = Vec3(end.x, yEnd, end.y) + CLOUD_OFFSET
fun createCloud(start: Vec2i, end: Vec2i, offset: Vec3i, yStart: Int, yEnd: Int, flat: Boolean, culling: BooleanArray) {
val start = Vec3(start.x - offset.x, yStart - offset.y, start.y - offset.z) + CLOUD_OFFSET
val end = Vec3(end.x - offset.x, yEnd - offset.y, end.y - offset.z) + CLOUD_OFFSET
addYQuad(Vec2(start.x, start.z), start.y, Vec2(end.x, end.z)) { position, _ -> addVertex(position, Directions.DOWN) }
if (!flat) {

1
src/main/java/de/bixilon/minosoft/gui/rendering/world/WorldRenderer.kt
View File

@ -113,6 +113,7 @@ class WorldRenderer(
paused = false
}
}
context.camera.offset::offset.observe(this) { silentlyClearChunkCache() }
context.inputHandler.registerKeyCallback("minosoft:clear_chunk_cache".toResourceLocation(), KeyBinding(
KeyActions.MODIFIER to setOf(KeyCodes.KEY_F3),

4
src/main/java/de/bixilon/minosoft/gui/rendering/world/border/WorldBorderRenderer.kt
View File

@ -15,6 +15,7 @@ package de.bixilon.minosoft.gui.rendering.world.border
import de.bixilon.kotlinglm.func.common.clamp
import de.bixilon.kotlinglm.vec2.Vec2
import de.bixilon.kotlinglm.vec2.Vec2d
import de.bixilon.kutil.latch.CountUpAndDownLatch
import de.bixilon.kutil.time.TimeUtil.millis
import de.bixilon.minosoft.data.registries.identified.Namespaces.minosoft
@ -86,7 +87,8 @@ class WorldBorderRenderer(
color = color.with(alpha = (strength * strength))
shader.tintColor = color
shader.radius = border.diameter.toFloat() / 2.0f
shader.center = Vec2(border.center)
val offset = context.camera.offset.offset
shader.center = Vec2(border.center - Vec2d(offset.x, offset.z))
}
override fun drawTranslucent() {

40
src/main/java/de/bixilon/minosoft/gui/rendering/world/chunk/ChunkBorderRenderer.kt
View File

@ -32,6 +32,7 @@ import de.bixilon.minosoft.gui.rendering.system.base.RenderSystem
import de.bixilon.minosoft.gui.rendering.system.base.phases.OpaqueDrawable
import de.bixilon.minosoft.gui.rendering.util.mesh.LineMesh
import de.bixilon.minosoft.gui.rendering.util.vec.vec3.Vec3dUtil.blockPosition
import de.bixilon.minosoft.gui.rendering.util.vec.vec3.Vec3iUtil.EMPTY
import de.bixilon.minosoft.gui.rendering.util.vec.vec3.Vec3iUtil.chunkPosition
import de.bixilon.minosoft.gui.rendering.util.vec.vec3.Vec3iUtil.sectionHeight
import de.bixilon.minosoft.protocol.network.connection.play.PlayConnection
@ -45,6 +46,7 @@ class ChunkBorderRenderer(
) : AsyncRenderer, OpaqueDrawable, MeshSwapper {
private val profile = connection.profiles.rendering
override val renderSystem: RenderSystem = context.renderSystem
private var offset = Vec3i.EMPTY
private var chunkPosition: Vec2i? = null
private var sectionHeight: Int = Int.MIN_VALUE
@ -77,52 +79,54 @@ class ChunkBorderRenderer(
val eyePosition = connection.camera.entity.renderInfo.eyePosition.blockPosition
val chunkPosition = eyePosition.chunkPosition
val sectionHeight = eyePosition.sectionHeight
if (chunkPosition == this.chunkPosition && sectionHeight == this.sectionHeight && mesh != null) {
val offset = context.camera.offset.offset
if (chunkPosition == this.chunkPosition && sectionHeight == this.sectionHeight && this.offset == offset && mesh != null) {
return
}
unload = true
val mesh = LineMesh(context)
val dimension = context.connection.world.dimension
val basePosition = chunkPosition * Vec2i(ProtocolDefinition.SECTION_WIDTH_X, ProtocolDefinition.SECTION_WIDTH_Z)
val basePosition = chunkPosition * Vec2i(ProtocolDefinition.SECTION_WIDTH_X, ProtocolDefinition.SECTION_WIDTH_Z) - Vec2i(offset.x, offset.z)
mesh.drawInnerChunkLines(basePosition, dimension)
mesh.drawInnerChunkLines(Vec3i(basePosition.x, -offset.y, basePosition.y), dimension)
if (sectionHeight in dimension.minSection until dimension.maxSection) {
mesh.drawSectionLines(Vec3i(basePosition.x, sectionHeight * ProtocolDefinition.SECTION_HEIGHT_Y, basePosition.y))
}
mesh.drawOuterChunkLines(chunkPosition, dimension)
mesh.drawOuterChunkLines(chunkPosition, offset, dimension)
this.nextMesh = mesh
this.chunkPosition = chunkPosition
this.sectionHeight = sectionHeight
this.offset = offset
this.nextMesh = mesh
}
private fun LineMesh.drawOuterChunkLines(chunkPosition: Vec2i, dimension: DimensionProperties) {
private fun LineMesh.drawOuterChunkLines(chunkPosition: Vec2i, offset: Vec3i, dimension: DimensionProperties) {
for (x in -OUTER_CHUNK_SIZE..OUTER_CHUNK_SIZE + 1) {
for (z in -OUTER_CHUNK_SIZE..OUTER_CHUNK_SIZE + 1) {
if ((x == 0 || x == 1) && (z == 0 || z == 1)) {
continue
}
val chunkBase = (chunkPosition + Vec2i(x, z)) * Vec2i(ProtocolDefinition.SECTION_WIDTH_X, ProtocolDefinition.SECTION_WIDTH_Z)
drawLine(Vec3(chunkBase.x + 0, dimension.minY, chunkBase.y), Vec3(chunkBase.x + 0, dimension.maxY + 1, chunkBase.y), OUTER_CHUNK_LINE_WIDTH, OUTER_CHUNK_COLOR)
val chunkBase = (chunkPosition + Vec2i(x, z)) * Vec2i(ProtocolDefinition.SECTION_WIDTH_X, ProtocolDefinition.SECTION_WIDTH_Z) - Vec2i(offset.x, offset.z)
drawLine(Vec3(chunkBase.x + 0, dimension.minY - offset.y, chunkBase.y), Vec3(chunkBase.x + 0, dimension.maxY - offset.y + 1, chunkBase.y), OUTER_CHUNK_LINE_WIDTH, OUTER_CHUNK_COLOR)
}
}
}
private fun LineMesh.drawInnerChunkLines(basePosition: Vec2i, dimension: DimensionProperties) {
drawLine(Vec3(basePosition.x + 0, dimension.minY, basePosition.y), Vec3(basePosition.x + 0, dimension.maxY + 1, basePosition.y), INNER_CHUNK_LINE_WIDTH, INNER_CHUNK_COLOR)
drawLine(Vec3(basePosition.x, dimension.minY, basePosition.y + ProtocolDefinition.SECTION_WIDTH_Z), Vec3(basePosition.x, dimension.maxY + 1, basePosition.y + ProtocolDefinition.SECTION_WIDTH_Z), INNER_CHUNK_LINE_WIDTH, INNER_CHUNK_COLOR)
drawLine(Vec3(basePosition.x + ProtocolDefinition.SECTION_WIDTH_X, dimension.minY, basePosition.y + 0), Vec3(basePosition.x + ProtocolDefinition.SECTION_WIDTH_X, dimension.maxY + 1, basePosition.y + 0), INNER_CHUNK_LINE_WIDTH, INNER_CHUNK_COLOR)
drawLine(Vec3(basePosition.x + ProtocolDefinition.SECTION_WIDTH_X, dimension.minY, basePosition.y + ProtocolDefinition.SECTION_WIDTH_Z), Vec3(basePosition.x + ProtocolDefinition.SECTION_WIDTH_X, dimension.maxY + 1, basePosition.y + ProtocolDefinition.SECTION_WIDTH_Z), INNER_CHUNK_LINE_WIDTH, INNER_CHUNK_COLOR)
private fun LineMesh.drawInnerChunkLines(basePosition: Vec3i, dimension: DimensionProperties) {
drawLine(Vec3(basePosition.x + 0, basePosition.y + dimension.minY, basePosition.z), Vec3(basePosition.x + 0, basePosition.y + dimension.maxY + 1, basePosition.z), INNER_CHUNK_LINE_WIDTH, INNER_CHUNK_COLOR)
drawLine(Vec3(basePosition.x, basePosition.y + dimension.minY, basePosition.z + ProtocolDefinition.SECTION_WIDTH_Z), Vec3(basePosition.x, basePosition.y + dimension.maxY + 1, basePosition.z + ProtocolDefinition.SECTION_WIDTH_Z), INNER_CHUNK_LINE_WIDTH, INNER_CHUNK_COLOR)
drawLine(Vec3(basePosition.x + ProtocolDefinition.SECTION_WIDTH_X, basePosition.y + dimension.minY, basePosition.z + 0), Vec3(basePosition.x + ProtocolDefinition.SECTION_WIDTH_X, basePosition.y + dimension.maxY + 1, basePosition.z + 0), INNER_CHUNK_LINE_WIDTH, INNER_CHUNK_COLOR)
drawLine(Vec3(basePosition.x + ProtocolDefinition.SECTION_WIDTH_X, basePosition.y + dimension.minY, basePosition.z + ProtocolDefinition.SECTION_WIDTH_Z), Vec3(basePosition.x + ProtocolDefinition.SECTION_WIDTH_X, basePosition.y + dimension.maxY + 1, basePosition.z + ProtocolDefinition.SECTION_WIDTH_Z), INNER_CHUNK_LINE_WIDTH, INNER_CHUNK_COLOR)
for (sectionHeight in dimension.minSection..dimension.maxSection) {
val y = sectionHeight * ProtocolDefinition.SECTION_HEIGHT_Y
drawLine(Vec3(basePosition.x, y, basePosition.y), Vec3(basePosition.x + ProtocolDefinition.SECTION_WIDTH_X, y, basePosition.y), INNER_CHUNK_LINE_WIDTH, INNER_CHUNK_COLOR)
drawLine(Vec3(basePosition.x, y, basePosition.y), Vec3(basePosition.x, y, basePosition.y + ProtocolDefinition.SECTION_WIDTH_Z), INNER_CHUNK_LINE_WIDTH, INNER_CHUNK_COLOR)
drawLine(Vec3(basePosition.x + ProtocolDefinition.SECTION_WIDTH_X, y, basePosition.y + ProtocolDefinition.SECTION_WIDTH_Z), Vec3(basePosition.x + ProtocolDefinition.SECTION_WIDTH_X, y, basePosition.y), INNER_CHUNK_LINE_WIDTH, INNER_CHUNK_COLOR)
drawLine(Vec3(basePosition.x + ProtocolDefinition.SECTION_WIDTH_X, y, basePosition.y + ProtocolDefinition.SECTION_WIDTH_Z), Vec3(basePosition.x, y, basePosition.y + ProtocolDefinition.SECTION_WIDTH_Z), INNER_CHUNK_LINE_WIDTH, INNER_CHUNK_COLOR)
val y = basePosition.y + sectionHeight * ProtocolDefinition.SECTION_HEIGHT_Y
drawLine(Vec3(basePosition.x, y, basePosition.z), Vec3(basePosition.x + ProtocolDefinition.SECTION_WIDTH_X, y, basePosition.z), INNER_CHUNK_LINE_WIDTH, INNER_CHUNK_COLOR)
drawLine(Vec3(basePosition.x, y, basePosition.z), Vec3(basePosition.x, y, basePosition.z + ProtocolDefinition.SECTION_WIDTH_Z), INNER_CHUNK_LINE_WIDTH, INNER_CHUNK_COLOR)
drawLine(Vec3(basePosition.x + ProtocolDefinition.SECTION_WIDTH_X, y, basePosition.z + ProtocolDefinition.SECTION_WIDTH_Z), Vec3(basePosition.x + ProtocolDefinition.SECTION_WIDTH_X, y, basePosition.z), INNER_CHUNK_LINE_WIDTH, INNER_CHUNK_COLOR)
drawLine(Vec3(basePosition.x + ProtocolDefinition.SECTION_WIDTH_X, y, basePosition.z + ProtocolDefinition.SECTION_WIDTH_Z), Vec3(basePosition.x, y, basePosition.z + ProtocolDefinition.SECTION_WIDTH_Z), INNER_CHUNK_LINE_WIDTH, INNER_CHUNK_COLOR)
}
}

24
src/main/java/de/bixilon/minosoft/gui/rendering/world/preparer/cull/FluidCullSectionPreparer.kt
View File

@ -68,6 +68,8 @@ class FluidCullSectionPreparer(
var rendered = false
var tint: Int
val cameraOffset = context.camera.offset.offset
val offsetX = chunkPosition.x * ProtocolDefinition.SECTION_WIDTH_X
val offsetY = sectionHeight * ProtocolDefinition.SECTION_HEIGHT_Y
val offsetZ = chunkPosition.y * ProtocolDefinition.SECTION_WIDTH_Z
@ -130,6 +132,8 @@ class FluidCullSectionPreparer(
getCornerHeight(chunk, chunkPosition, position + Directions.SOUTH, fluid),
)
val offsetPosition = Vec3(position - cameraOffset)
if (!skip[Directions.O_UP]) {
val velocity = fluid.getVelocity(blockState, position, chunk)
val still = velocity.x == 0.0 && velocity.z == 0.0
@ -164,10 +168,10 @@ class FluidCullSectionPreparer(
val meshToUse = texture.transparency.getMesh(mesh)
val positions = arrayOf(
Vec3(position.x, position.y + cornerHeights[0], position.z),
Vec3(position.x + 1, position.y + cornerHeights[1], position.z),
Vec3(position.x + 1, position.y + cornerHeights[2], position.z + 1),
Vec3(position.x, position.y + cornerHeights[3], position.z + 1),
Vec3(offsetPosition.x, offsetPosition.y + cornerHeights[0], offsetPosition.z),
Vec3(offsetPosition.x + 1, offsetPosition.y + cornerHeights[1], offsetPosition.z),
Vec3(offsetPosition.x + 1, offsetPosition.y + cornerHeights[2], offsetPosition.z + 1),
Vec3(offsetPosition.x, offsetPosition.y + cornerHeights[3], offsetPosition.z + 1),
)
@ -182,9 +186,9 @@ class FluidCullSectionPreparer(
if (skip[Directions.SIDE_OFFSET + direction]) {
continue
}
var faceX = position.x.toFloat()
var faceX = offsetPosition.x
var faceXEnd = faceX
var faceZ = position.z.toFloat()
var faceZ = offsetPosition.z
var faceZEnd = faceZ
var v1 = 0.0f
var v2 = 0.0f
@ -222,10 +226,10 @@ class FluidCullSectionPreparer(
val positions = arrayOf(
Vec3(faceX, position.y + v1, faceZ),
Vec3(faceX, position.y, faceZ),
Vec3(faceXEnd, position.y, faceZEnd),
Vec3(faceXEnd, position.y + v2, faceZEnd),
Vec3(faceX, offsetPosition.y + v1, faceZ),
Vec3(faceX, offsetPosition.y, faceZ),
Vec3(faceXEnd, offsetPosition.y, faceZEnd),
Vec3(faceXEnd, offsetPosition.y + v2, faceZEnd),
)
val texturePositions = arrayOf(
TEXTURE_1,