Proper and accurate grid raycasting

CREDITS.md

@@ -0,0 +1,26 @@
+
+### Libraries making this project possible
+
+* [OpenJDK - Reference Java Virtual Machine and Java Standard Library implementations](https://openjdk.org/)
+* [Kotlin programming language](https://kotlinlang.org/)
+* [LWJGL - Lightweight Java Game Library](https://www.lwjgl.org/)
+* [Lua, embeddable scripting language](https://www.lua.org/)
+* [mimalloc, a compact general purpose allocator with excellent performance](https://github.com/microsoft/mimalloc)
+* [fastutil - extends the Java™ Collections Framework by providing type-specific maps, sets, lists and queues. ](https://github.com/vigna/fastutil)
+* [box2d - 2D Physics Engine](https://github.com/erincatto/box2d)
+* [Guava - Google core libraries for Java](https://github.com/google/guava)
+* [Gson - A Java serialization/deserialization library to convert Java Objects into JSON and back](https://github.com/google/gson)
+* [Log4j - Apache Log4j 2 is a versatile, feature-rich, efficient logging API and backend for Java](https://github.com/apache/logging-log4j2)
+
+### Snippets of code making this project possible
+
+* [Super Fast Ray Casting in Tiled Worlds using DDA by javidx9](https://www.youtube.com/watch?v=NbSee-XM7WA)
+* [Efficient HSV convertor inside Fragment Shader by Sam Hocevar](https://stackoverflow.com/questions/15095909/from-rgb-to-hsv-in-opengl-glsl)
+
+### Special Thanks
+
+* JetBrains
+  * for creating amazing programming language Kotlin
+  * for providing IntelliJ IDEA Community Edition free of charge for making these projects possible to write
+* Curtis Schweitzer, your ability to make atmospheric music can not be described by words
+* Starbound Community, for being passionate and determinant in keeping game alive

build.gradle.kts

@@ -82,8 +82,8 @@ dependencies {
 	implementation("net.java.dev.jna:jna:5.13.0")
 	implementation("com.github.jnr:jnr-ffi:2.2.13")
 
-	implementation("ru.dbotthepony:kbox2d:2.4.1.6")
+	implementation("ru.dbotthepony:kbox2d:2.4.1.7")
-	implementation("ru.dbotthepony:kvector:2.9.2")
+	implementation("ru.dbotthepony:kvector:2.10.2")
 
 	implementation("com.github.ben-manes.caffeine:caffeine:3.1.5")
 }

src/main/kotlin/ru/dbotthepony/kstarbound/client/gl/shader/Programs.kt

@@ -43,11 +43,11 @@ class GLLiquidProgram : GLShaderProgram(shaders("liquid"), VertexAttributes.POSI
 }
 
 class GLPrograms {
-	val position = UberShader.Builder().build()
+	val position by lazy(LazyThreadSafetyMode.NONE) { UberShader.Builder().build() }
-	val positionTexture = UberShader.Builder().withTexture().build()
+	val positionTexture by lazy(LazyThreadSafetyMode.NONE) { UberShader.Builder().withTexture().build() }
-	val positionTextureLightmap = UberShader.Builder().withTexture().withLightMap().build()
+	val positionTextureLightmap by lazy(LazyThreadSafetyMode.NONE) { UberShader.Builder().withTexture().withLightMap().build() }
-	val positionColor = UberShader.Builder().withColor().build()
+	val positionColor by lazy(LazyThreadSafetyMode.NONE) { UberShader.Builder().withColor().build() }
-	val tile = UberShader.Builder().withTexture().withHueShift().withLightMap().build()
+	val tile by lazy(LazyThreadSafetyMode.NONE) { UberShader.Builder().withTexture().withHueShift().withLightMap().build() }
-	val font = FontProgram()
+	val font by lazy(LazyThreadSafetyMode.NONE) { FontProgram() }
-	val liquid = GLLiquidProgram()
+	val liquid by lazy(LazyThreadSafetyMode.NONE) { GLLiquidProgram() }
 }

src/main/kotlin/ru/dbotthepony/kstarbound/client/world/ClientWorld.kt

@@ -16,12 +16,14 @@ import ru.dbotthepony.kstarbound.math.roundTowardsNegativeInfinity
 import ru.dbotthepony.kstarbound.math.roundTowardsPositiveInfinity
 import ru.dbotthepony.kstarbound.world.CHUNK_SIZE
 import ru.dbotthepony.kstarbound.world.ChunkPos
-import ru.dbotthepony.kstarbound.world.NonSolidRayFilter
+import ru.dbotthepony.kstarbound.world.NeverFilter
-import ru.dbotthepony.kstarbound.world.SolidRayFilter
+import ru.dbotthepony.kstarbound.world.NonEmptyFilter
+import ru.dbotthepony.kstarbound.world.RayCastResult
 import ru.dbotthepony.kstarbound.world.World
 import ru.dbotthepony.kstarbound.world.api.ITileAccess
 import ru.dbotthepony.kstarbound.world.api.OffsetCellAccess
 import ru.dbotthepony.kstarbound.world.api.TileView
+import ru.dbotthepony.kstarbound.world.castRay
 import ru.dbotthepony.kstarbound.world.positiveModulo
 import ru.dbotthepony.kvector.api.IStruct2i
 import ru.dbotthepony.kvector.util2d.AABB
@@ -287,48 +289,6 @@ class ClientWorld(
 				obj.addLights(client.viewportLighting, client.viewportCellX, client.viewportCellY)
 			}
 		}
-
-		/*layers.add(RenderLayer.Overlay.base) {
-			val rayFan = ArrayList<Vector2d>()
-			val pos = client.screenToWorld(client.mouseCoordinates)
-
-			//for (i in 0 .. 359) {
-			//	rayFan.add(Vector2d(cos(i / 180.0 * PI), sin(i / 180.0 * PI)))
-			//}
-
-			rayFan.add(Vector2d(0.5, 0.7).unitVector)
-
-			client.quadWireframe(RGBAColor(1f, 1f, 1f, 0.4f)) {
-				for (x in -20 .. 20) {
-					for (y in -20 .. 20) {
-						it.vertex(pos.x.toInt().toFloat() + x, pos.y.toInt().toFloat() + y)
-						it.vertex(pos.x.toInt().toFloat() + x + 1f, pos.y.toInt().toFloat() + y)
-						it.vertex(pos.x.toInt().toFloat() + x + 1f, pos.y.toInt().toFloat() + 1f + y)
-						it.vertex(pos.x.toInt().toFloat() + x, pos.y.toInt().toFloat() + 1f + y)
-					}
-				}
-			}
-
-			client.lines {
-				for (ray in rayFan) {
-					val trace = castRayExact(pos, ray, 16.0, NonSolidRayFilter)
-
-					it.vertex(pos.x.toFloat(), pos.y.toFloat())
-					it.vertex(pos.x.toFloat() + ray.x.toFloat() * trace.fraction.toFloat() * 16f, pos.y.toFloat() + ray.y.toFloat() * trace.fraction.toFloat() * 16f)
-
-					/*for ((tpos, tile) in trace.traversedTiles) {
-						if (!tile.foreground.material.renderParameters.lightTransparent) {
-							it.vertex(tpos.x.toFloat(), tpos.y.toFloat())
-							it.vertex(tpos.x.toFloat() + 1f, tpos.y.toFloat())
-							it.vertex(tpos.x.toFloat() + 1f, tpos.y.toFloat() + 1f)
-							it.vertex(tpos.x.toFloat(), tpos.y.toFloat() + 1f)
-						}
-					}*/
-				}
-			}
-		}*/
-
-		//rayLightCircleNaive(pos, 48.0, falloffByTravel = 1.0, falloffByTile = 3.0)
 	}
 
 	override fun thinkInner() {

src/main/kotlin/ru/dbotthepony/kstarbound/defs/CollisionType.kt

@@ -1,10 +1,10 @@
 package ru.dbotthepony.kstarbound.defs
 
-enum class CollisionType {
+enum class CollisionType(val isEmpty: Boolean) {
-	NULL,
+	NULL(true),
-	NONE,
+	NONE(true),
-	PLATFORM,
+	PLATFORM(false),
-	DYNAMIC,
+	DYNAMIC(false),
-	SLIPPERY,
+	SLIPPERY(false),
-	BLOCK;
+	BLOCK(false);
 }

src/main/kotlin/ru/dbotthepony/kstarbound/defs/object/ObjectOrientation.kt

@@ -11,12 +11,10 @@ import com.google.gson.reflect.TypeToken
 import com.google.gson.stream.JsonReader
 import com.google.gson.stream.JsonWriter
 import ru.dbotthepony.kstarbound.PIXELS_IN_STARBOUND_UNITf
-import ru.dbotthepony.kstarbound.Starbound
 import ru.dbotthepony.kstarbound.client.render.RenderLayer
 import ru.dbotthepony.kstarbound.defs.Drawable
 import ru.dbotthepony.kstarbound.defs.JsonReference
 import ru.dbotthepony.kstarbound.defs.tile.BuiltinMetaMaterials
-import ru.dbotthepony.kstarbound.io.json.JsonArray
 import ru.dbotthepony.kstarbound.io.json.clear
 import ru.dbotthepony.kstarbound.io.json.consumeNull
 import ru.dbotthepony.kstarbound.io.json.listAdapter
@@ -24,7 +22,7 @@ import ru.dbotthepony.kstarbound.io.json.setAdapter
 import ru.dbotthepony.kstarbound.util.contains
 import ru.dbotthepony.kstarbound.util.get
 import ru.dbotthepony.kstarbound.util.set
-import ru.dbotthepony.kstarbound.world.Direction
+import ru.dbotthepony.kstarbound.world.Side
 import ru.dbotthepony.kvector.util2d.AABB
 import ru.dbotthepony.kvector.util2d.AABBi
 import ru.dbotthepony.kvector.vector.Vector2d
@@ -46,7 +44,7 @@ data class ObjectOrientation(
 	val metaBoundBox: AABB?,
 	val anchors: ImmutableSet<Anchor>,
 	val anchorAny: Boolean,
-	val directionAffinity: Direction?,
+	val directionAffinity: Side?,
 	val materialSpaces: ImmutableList<Pair<Vector2i, String>>,
 	val interactiveSpaces: ImmutableSet<Vector2i>,
 	val lightPosition: Vector2i,
@@ -202,7 +200,7 @@ data class ObjectOrientation(
 				anchors.add(Anchor(true, vectorsi.fromJsonTree(v), requireTilledAnchors, requireSoilAnchors, anchorMaterial))
 
 			val anchorAny = obj["anchorAny"]?.asBoolean ?: false
-			val directionAffinity = obj["directionAffinity"]?.asString?.uppercase()?.let { Direction.valueOf(it) }
+			val directionAffinity = obj["directionAffinity"]?.asString?.uppercase()?.let { Side.valueOf(it) }
 			val materialSpaces: ImmutableList<Pair<Vector2i, String>>
 
 			if ("materialSpaces" in obj) {

src/main/kotlin/ru/dbotthepony/kstarbound/io/StarboundPak.kt

@@ -97,7 +97,7 @@ class StarboundPak(val path: File, callback: (finished: Boolean, status: String)
 						return -1
 					}
 
-					synchronized(lock) {
+					synchronized(reader) {
 						reader.seek(innerOffset + offset)
 						innerOffset++
 						return reader.read()
@@ -112,7 +112,7 @@ class StarboundPak(val path: File, callback: (finished: Boolean, status: String)
 					if (readMax == 0)
 						return ByteArray(0)
 
-					synchronized(lock) {
+					synchronized(reader) {
 						val b = ByteArray(readMax)
 						reader.seek(innerOffset + offset)
 						reader.readFully(b)
@@ -133,7 +133,7 @@ class StarboundPak(val path: File, callback: (finished: Boolean, status: String)
 					if (readMax <= 0)
 						return -1
 
-					synchronized(lock) {
+					synchronized(reader) {
 						reader.seek(innerOffset + offset)
 						val readBytes = reader.read(b, off, readMax)
 
@@ -153,7 +153,6 @@ class StarboundPak(val path: File, callback: (finished: Boolean, status: String)
 	}
 
 	private val reader = RandomAccessFile(path, "r")
-	private val lock = Any()
 
 	init {
 		readHeader(reader, 0x53) // S

src/main/kotlin/ru/dbotthepony/kstarbound/io/json/builder/EnumAdapter.kt

@@ -59,7 +59,7 @@ class EnumAdapter<T : Enum<T>>(private val enum: KClass<T>, values: Stream<T> =
 
 	private val values = values.collect(ImmutableList.toImmutableList())
 	private val mapping: ImmutableMap<String, T>
-	private val areCustom = IStringSerializable::class.isSuperclassOf(enum)
+	private val areCustom = IStringSerializable::class.java.isAssignableFrom(enum.java)
 	private val misses = ObjectOpenHashSet<String>()
 
 	init {

src/main/kotlin/ru/dbotthepony/kstarbound/world/Direction.kt

@@ -1,6 +1,11 @@
 package ru.dbotthepony.kstarbound.world
 
-enum class Direction {
+import ru.dbotthepony.kvector.vector.Vector2d
-	LEFT,
+
-	RIGHT;
+enum class Direction(val normal: Vector2d) {
+	UP(Vector2d.POSITIVE_Y),
+	RIGHT(Vector2d.POSITIVE_X),
+	DOWN(Vector2d.NEGATIVE_Y),
+	LEFT(Vector2d.NEGATIVE_X),
+	NONE(Vector2d.ZERO);
 }

src/main/kotlin/ru/dbotthepony/kstarbound/world/Raycasting.kt

@@ -1,72 +1,39 @@
 package ru.dbotthepony.kstarbound.world
 
-import com.google.common.collect.ImmutableList
 import ru.dbotthepony.kstarbound.METRES_IN_STARBOUND_UNIT
+import ru.dbotthepony.kstarbound.math.roundTowardsNegativeInfinity
 import ru.dbotthepony.kstarbound.world.api.ICellAccess
 import ru.dbotthepony.kstarbound.world.api.IChunkCell
-import ru.dbotthepony.kvector.arrays.Double2DArray
 import ru.dbotthepony.kvector.vector.Vector2d
 import ru.dbotthepony.kvector.vector.Vector2i
-import java.util.*
 import kotlin.collections.ArrayList
-import kotlin.math.PI
+import kotlin.math.pow
-import kotlin.math.cos
+import kotlin.math.sqrt
-import kotlin.math.roundToInt
-import kotlin.math.sin
 
 const val EARTH_FREEFALL_ACCELERATION = 9.8312 / METRES_IN_STARBOUND_UNIT
 
 data class RayCastResult(
-	val traversedTiles: List<Pair<Vector2i, IChunkCell>>,
+	val traversedTiles: List<HitCell>,
-	val hitTile: Pair<Vector2i, IChunkCell>?,
+	val hitTile: HitCell?,
-	val fraction: Double
+	val fraction: Double,
-)
+	val startPos: Vector2d,
+	val hitPos: Vector2d,
+	val direction: Vector2d
+) {
+	constructor(startPos: Vector2d, direction: Vector2d) : this(listOf(), null, 0.0, startPos, startPos, direction)
 
-private fun makeDirFan(step: Double): List<Vector2d> {
+	data class HitCell(val pos: Vector2i, val normal: Direction, val borderCross: Vector2d, val cell: IChunkCell)
-	var i = 0.0
-	val result = ImmutableList.builder<Vector2d>()
-
-	while (i < 360.0) {
-		i += step
-		result.add(Vector2d(cos(i / 180.0 * PI), sin(i / 180.0 * PI)))
-	}
-
-	return result.build()
 }
 
-private val potatoDirFan by lazy { makeDirFan(4.0) }
+enum class RayFilterResult(val hit: Boolean, val write: Boolean) {
-private val veryRoughDirFan by lazy { makeDirFan(3.0) }
+	// stop tracing, write hit tile into traversed tiles list
-private val roughDirFan by lazy { makeDirFan(2.0) }
+	HIT(true, true),
-private val dirFan by lazy { makeDirFan(1.0) }
+	// stop tracing, don't write hit tile into traversed tiles list
-private val preciseFan by lazy { makeDirFan(0.5) }
+	HIT_SKIP(true, false),
-private val veryPreciseFan by lazy { makeDirFan(0.25) }
+	// continue tracing, don't write hit tile into traversed tiles list
-
+	SKIP(false, false),
-private fun chooseLightRayFan(size: Double): List<Vector2d> {
+	// continue tracing, write hit tile into traversed tiles list
-	return when (size) {
+	CONTINUE(false, true);
-		in 0.0 .. 8.0 -> potatoDirFan
-		in 8.0 .. 16.0 -> veryRoughDirFan
-		in 16.0 .. 24.0 -> roughDirFan
-		in 24.0 .. 48.0 -> dirFan
-		in 48.0 .. 96.0 -> preciseFan
-		// in 32.0 .. 48.0 -> veryPreciseFan
-		else -> veryPreciseFan
-	}
-}
-
-/**
- * [HIT] - луч попал по объекту и трассировка прекращается; объект записывается в коллекцию объектов, в которые попал луч.
- *
- * [HIT_SKIP] - луч попал по объекту и трассировка прекращается; объект не записывается в коллекцию объектов, в которые попал луч.
- *
- * [SKIP] - луч не попал по объекту, объект не записывается в коллекцию объектов, в которые попал луч.
- *
- * [CONTINUE] - луч не попал по объекту; объект записывается в коллекцию объектов, в которые попал луч.
- */
-enum class RayFilterResult {
-	HIT,
-	HIT_SKIP,
-	SKIP,
-	CONTINUE;
 
 	companion object {
 		fun of(boolean: Boolean): RayFilterResult {
@@ -76,153 +43,98 @@ enum class RayFilterResult {
 }
 
 fun interface TileRayFilter {
-	fun test(state: IChunkCell, fraction: Double, position: Vector2i): RayFilterResult
+	/**
+	 * [x] and [y] are wrapped around positions
+	 */
+	fun test(cell: IChunkCell, fraction: Double, x: Int, y: Int, normal: Direction, borderX: Double, borderY: Double): RayFilterResult
 }
 
-/**
+val NeverFilter = TileRayFilter { state, fraction, x, y, normal, borderX, borderY -> RayFilterResult.CONTINUE }
- * Считает все тайлы неблокирующими
+val NonEmptyFilter = TileRayFilter { state, fraction, x, y, normal, borderX, borderY -> RayFilterResult.of(!state.foreground.material.collisionKind.isEmpty) }
- */
-val AnythingRayFilter = TileRayFilter { state, t, pos -> RayFilterResult.CONTINUE }
 
-/**
+fun ICellAccess.castRay(startPos: Vector2d, direction: Vector2d, length: Double, filter: TileRayFilter) = castRay(startPos, startPos + direction * length, filter)
- * Попадает по первому не-пустому тайлу
- */
-val NonSolidRayFilter = TileRayFilter { state, t, pos -> RayFilterResult.of(state.foreground.material != null) }
 
-/**
+// https://www.youtube.com/watch?v=NbSee-XM7WA
- * Попадает по первому пустому тайлу
+fun ICellAccess.castRay(
- */
+	start: Vector2d,
-val SolidRayFilter = TileRayFilter { state, t, pos -> RayFilterResult.of(state.foreground.material == null) }
+	end: Vector2d,
-
+	filter: TileRayFilter
-/**
- * Попадает по первому тайлу который блокирует проход света
- */
-val LineOfSightRayFilter = TileRayFilter { state, t, pos -> RayFilterResult.of(state.foreground.material?.renderParameters?.lightTransparent == false) }
-
-/**
- * Бросает луч напротив тайлов мира с заданными позициями и фильтром
- */
-fun ICellAccess.castRayNaive(
-	rayStart: Vector2d,
-	rayEnd: Vector2d,
-	filter: TileRayFilter = AnythingRayFilter
 ): RayCastResult {
-	if (rayStart == rayEnd) {
+	if (start == end)
-		return RayCastResult(listOf(), null, 1.0)
+		return RayCastResult(start, Vector2d.ZERO)
+
+	val hitTiles = ArrayList<RayCastResult.HitCell>()
+	var cellPosX = roundTowardsNegativeInfinity(start.x)
+	var cellPosY = roundTowardsNegativeInfinity(start.y)
+	var cell = getCell(cellPosX, cellPosY) ?: return RayCastResult(start, Vector2d.ZERO)
+
+	val direction = (end - start).unitVector
+
+	var result = filter.test(cell, 0.0, cellPosX, cellPosY, Direction.NONE, start.x, start.y)
+	if (result.write) hitTiles.add(RayCastResult.HitCell(Vector2i(cellPosX, cellPosY), Direction.NONE, start, cell))
+	if (result.hit) return RayCastResult(hitTiles, RayCastResult.HitCell(Vector2i(cellPosX, cellPosY), Direction.NONE, start, cell), 0.0, start, start, direction)
+
+	val distance = start.distance(end)
+	var travelled = 0.0
+	val unitStepSizeX = sqrt(1 + (direction.y / direction.x).pow(2.0))
+	val unitStepSizeY = sqrt(1 + (direction.x / direction.y).pow(2.0))
+
+	val stepX: Int
+	val stepY: Int
+
+	val xNormal: Direction
+	val yNormal: Direction
+
+	var rayLengthX: Double
+	var rayLengthY: Double
+
+	if (direction.x < 0.0) {
+		stepX = -1
+		rayLengthX = (start.x - cellPosX) * unitStepSizeX
+		xNormal = Direction.RIGHT
+	} else {
+		stepX = 1
+		rayLengthX = (cellPosX - start.x + 1) * unitStepSizeX
+		xNormal = Direction.LEFT
 	}
 
-	var t = 0.0
+	if (direction.y < 0.0) {
-	val dir = rayEnd - rayStart
+		stepY = -1
-	val inc = 0.5 / dir.length
+		rayLengthY = (start.y - cellPosY) * unitStepSizeY
-
+		yNormal = Direction.UP
-	val tiles = LinkedList<Pair<Vector2i, IChunkCell>>()
+	} else {
-	var prev = Vector2i(Int.MIN_VALUE, Int.MAX_VALUE)
+		stepY = 1
-	var hitTile: Pair<Vector2i, IChunkCell>? = null
+		rayLengthY = (cellPosY - start.y + 1) * unitStepSizeY
-
+		yNormal = Direction.DOWN
-	while (t < 1.0) {
-		val (x, y) = rayStart + dir * t
-		val tilePos = Vector2i(x.roundToInt(), y.roundToInt())
-
-		if (tilePos != prev) {
-			val tile = getCell(tilePos) ?: break
-
-			when (filter.test(tile, t, tilePos)) {
-				RayFilterResult.HIT -> {
-					hitTile = tilePos to tile
-					tiles.add(hitTile)
-					break
-				}
-
-				RayFilterResult.HIT_SKIP -> {
-					hitTile = tilePos to tile
-					break
-				}
-
-				RayFilterResult.SKIP -> {}
-				RayFilterResult.CONTINUE -> tiles.add(tilePos to tile)
-			}
-
-			prev = tilePos
-		}
-
-		t += inc
 	}
 
-	return RayCastResult(tiles, hitTile, t)
+	while (travelled < distance) {
-}
+		val normal: Direction
 
-/**
+		if (rayLengthX < rayLengthY) {
- * Бросает луч напротив тайлов мира с заданной позицией, направлением и фильтром
+			cellPosX += stepX
- */
+			travelled = rayLengthX
-fun ICellAccess.castRayNaive(
+			rayLengthX += unitStepSizeX
-	rayPosition: Vector2d,
+			normal = xNormal
-	direction: Vector2d,
-	length: Double,
-	filter: TileRayFilter = AnythingRayFilter
-): RayCastResult {
-	return castRayNaive(rayPosition, rayPosition + direction.unitVector * length, filter)
-}
-
-/**
- * Выпускает луч света с заданной силой (определяет длину луча и способность проходить сквозь тайлы), позицией и направлением.
- *
- * Позволяет указать отдельно [falloffByTile] потерю силы света при прохождении через тайлы.
- */
-fun ICellAccess.rayLightNaive(
-	position: Vector2d,
-	direction: Vector2d,
-	intensity: Double,
-	falloffByTile: Double = 2.0,
-	falloffByTravel: Double = 1.0,
-): List<Pair<Double, Vector2i>> {
-	val result = ArrayList<Pair<Double, Vector2i>>()
-
-	var currentIntensity = intensity
-
-	castRayNaive(position, direction, intensity) { state, t, pos ->
-		if (state.foreground.material?.renderParameters?.lightTransparent == false) {
-			currentIntensity -= falloffByTile
 		} else {
-			currentIntensity -= falloffByTravel
+			cellPosY += stepY
+			travelled = rayLengthY
+			rayLengthY += unitStepSizeY
+			normal = yNormal
 		}
 
-		//result.add(currentIntensity to pos)
+		cell = getCell(cellPosX, cellPosY) ?: return RayCastResult(hitTiles, null, travelled / distance, start, start + direction * travelled, direction)
+		result = filter.test(cell, 0.0, cellPosX, cellPosY, normal, start.x + direction.x * travelled, start.y + direction.y * travelled)
 
-		if (currentIntensity <= 0.0) {
+		val c = if (result.write || result.hit) {
-			return@castRayNaive RayFilterResult.HIT_SKIP
+			RayCastResult.HitCell(Vector2i(cellPosX, cellPosY), normal, start + direction * travelled, cell)
 		} else {
-			return@castRayNaive RayFilterResult.SKIP
+			null
 		}
+
+		if (result.write) hitTiles.add(c!!)
+		if (result.hit) return RayCastResult(hitTiles, c, travelled / distance, start, start + direction * travelled, direction)
 	}
 
-	return result
+	return RayCastResult(hitTiles, null, 1.0, start, start + direction * distance, direction)
-}
-
-/**
- * Трассирует лучи света вокруг себя с заданной позицией, интенсивностью,
- * падением интенсивности за проход сквозь тайл [falloffByTile] и
- * падением интенсивности за проход по пустому месту [falloffByTravel].
- */
-fun ICellAccess.rayLightCircleNaive(
-	position: Vector2d,
-	intensity: Double,
-	falloffByTile: Double = 2.0,
-	falloffByTravel: Double = 1.0,
-): Double2DArray {
-	val combinedResult = Double2DArray.allocate(intensity.roundToInt() * 2, intensity.roundToInt() * 2)
-	val baselineX = position.x.roundToInt() - intensity.roundToInt()
-	val baselineY = position.y.roundToInt() - intensity.roundToInt()
-
-	val dirs = chooseLightRayFan(intensity)
-	val mul = 1.0 / dirs.size
-
-	for (dir in dirs) {
-		val result2 = rayLightNaive(position, dir, intensity, falloffByTile, falloffByTravel)
-
-		for (pair in result2) {
-			combinedResult[pair.second.y - baselineY, pair.second.x - baselineX] += pair.first * mul
-		}
-	}
-
-	return combinedResult
 }

src/main/kotlin/ru/dbotthepony/kstarbound/world/Side.kt

@@ -0,0 +1,6 @@
+package ru.dbotthepony.kstarbound.world
+
+enum class Side {
+	LEFT,
+	RIGHT;
+}

src/main/kotlin/ru/dbotthepony/kstarbound/world/entities/WorldObject.kt

@@ -15,7 +15,7 @@ import ru.dbotthepony.kstarbound.defs.`object`.ObjectDefinition
 import ru.dbotthepony.kstarbound.defs.`object`.ObjectOrientation
 import ru.dbotthepony.kstarbound.util.get
 import ru.dbotthepony.kstarbound.util.set
-import ru.dbotthepony.kstarbound.world.Direction
+import ru.dbotthepony.kstarbound.world.Side
 import ru.dbotthepony.kstarbound.world.LightCalculator
 import ru.dbotthepony.kstarbound.world.World
 import ru.dbotthepony.kstarbound.world.api.TileColor
@@ -32,7 +32,7 @@ open class WorldObject(
 		Starbound.worldObjects[data["name"]?.asString ?: throw IllegalArgumentException("Missing object name")] ?: throw IllegalArgumentException("No such object defined for '${data["name"]}'"),
 		data.get("tilePosition", vectors) { throw IllegalArgumentException("No tilePosition was present in saved data") }
 	) {
-		direction = data.get("direction", directions) { Direction.LEFT }
+		direction = data.get("direction", directions) { Side.LEFT }
 		orientationIndex = data.get("orientationIndex", -1)
 		interactive = data.get("interactive", false)
 
@@ -73,7 +73,7 @@ open class WorldObject(
 	//
 	var uniqueId: String? = null
 	var interactive = false
-	var direction = Direction.LEFT
+	var direction = Side.LEFT
 
 	var orientationIndex = -1
 		set(value) {
@@ -186,7 +186,7 @@ open class WorldObject(
 		private val colors1 by lazy { Starbound.gson.getAdapter(TypeToken.getParameterized(ImmutableMap::class.java, String::class.java, RGBAColor::class.java)) as TypeAdapter<ImmutableMap<String, RGBAColor>> }
 		private val colors0 by lazy { Starbound.gson.getAdapter(RGBAColor::class.java) }
 		private val strings by lazy { Starbound.gson.getAdapter(String::class.java) }
-		private val directions by lazy { Starbound.gson.getAdapter(Direction::class.java) }
+		private val directions by lazy { Starbound.gson.getAdapter(Side::class.java) }
 		private val vectors by lazy { Starbound.gson.getAdapter(Vector2i::class.java) }
 	}
 }