Proper and accurate grid raycasting
This commit is contained in:
parent
97d441deba
commit
c0ecbe9a8b
GPG Key ID:
DCC23B5715498507
26
CREDITS.md
Normal file
26
CREDITS.md
Normal file
@ -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
|
||||
@ -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:kvector:2.9.2")
|
||||
implementation("ru.dbotthepony:kbox2d:2.4.1.7")
|
||||
implementation("ru.dbotthepony:kvector:2.10.2")
|
||||
|
||||
implementation("com.github.ben-manes.caffeine:caffeine:3.1.5")
|
||||
}
|
||||
|
||||
@ -43,11 +43,11 @@ class GLLiquidProgram : GLShaderProgram(shaders("liquid"), VertexAttributes.POSI
|
||||
}
|
||||
|
||||
class GLPrograms {
|
||||
val position = UberShader.Builder().build()
|
||||
val positionTexture = UberShader.Builder().withTexture().build()
|
||||
val positionTextureLightmap = UberShader.Builder().withTexture().withLightMap().build()
|
||||
val positionColor = UberShader.Builder().withColor().build()
|
||||
val tile = UberShader.Builder().withTexture().withHueShift().withLightMap().build()
|
||||
val font = FontProgram()
|
||||
val liquid = GLLiquidProgram()
|
||||
val position by lazy(LazyThreadSafetyMode.NONE) { UberShader.Builder().build() }
|
||||
val positionTexture by lazy(LazyThreadSafetyMode.NONE) { UberShader.Builder().withTexture().build() }
|
||||
val positionTextureLightmap by lazy(LazyThreadSafetyMode.NONE) { UberShader.Builder().withTexture().withLightMap().build() }
|
||||
val positionColor by lazy(LazyThreadSafetyMode.NONE) { UberShader.Builder().withColor().build() }
|
||||
val tile by lazy(LazyThreadSafetyMode.NONE) { UberShader.Builder().withTexture().withHueShift().withLightMap().build() }
|
||||
val font by lazy(LazyThreadSafetyMode.NONE) { FontProgram() }
|
||||
val liquid by lazy(LazyThreadSafetyMode.NONE) { GLLiquidProgram() }
|
||||
}
|
||||
|
||||
@ -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.SolidRayFilter
|
||||
import ru.dbotthepony.kstarbound.world.NeverFilter
|
||||
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() {
|
||||
|
||||
@ -1,10 +1,10 @@
|
||||
package ru.dbotthepony.kstarbound.defs
|
||||
|
||||
enum class CollisionType {
|
||||
NULL,
|
||||
NONE,
|
||||
PLATFORM,
|
||||
DYNAMIC,
|
||||
SLIPPERY,
|
||||
BLOCK;
|
||||
enum class CollisionType(val isEmpty: Boolean) {
|
||||
NULL(true),
|
||||
NONE(true),
|
||||
PLATFORM(false),
|
||||
DYNAMIC(false),
|
||||
SLIPPERY(false),
|
||||
BLOCK(false);
|
||||
}
|
||||
|
||||
@ -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) {
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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 {
|
||||
|
||||
@ -1,6 +1,11 @@
|
||||
package ru.dbotthepony.kstarbound.world
|
||||
|
||||
enum class Direction {
|
||||
LEFT,
|
||||
RIGHT;
|
||||
import ru.dbotthepony.kvector.vector.Vector2d
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
@ -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.cos
|
||||
import kotlin.math.roundToInt
|
||||
import kotlin.math.sin
|
||||
import kotlin.math.pow
|
||||
import kotlin.math.sqrt
|
||||
|
||||
const val EARTH_FREEFALL_ACCELERATION = 9.8312 / METRES_IN_STARBOUND_UNIT
|
||||
|
||||
data class RayCastResult(
|
||||
val traversedTiles: List<Pair<Vector2i, IChunkCell>>,
|
||||
val hitTile: Pair<Vector2i, IChunkCell>?,
|
||||
val fraction: Double
|
||||
)
|
||||
val traversedTiles: List<HitCell>,
|
||||
val hitTile: HitCell?,
|
||||
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> {
|
||||
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()
|
||||
data class HitCell(val pos: Vector2i, val normal: Direction, val borderCross: Vector2d, val cell: IChunkCell)
|
||||
}
|
||||
|
||||
private val potatoDirFan by lazy { makeDirFan(4.0) }
|
||||
private val veryRoughDirFan by lazy { makeDirFan(3.0) }
|
||||
private val roughDirFan by lazy { makeDirFan(2.0) }
|
||||
private val dirFan by lazy { makeDirFan(1.0) }
|
||||
private val preciseFan by lazy { makeDirFan(0.5) }
|
||||
private val veryPreciseFan by lazy { makeDirFan(0.25) }
|
||||
|
||||
private fun chooseLightRayFan(size: Double): List<Vector2d> {
|
||||
return when (size) {
|
||||
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;
|
||||
enum class RayFilterResult(val hit: Boolean, val write: Boolean) {
|
||||
// stop tracing, write hit tile into traversed tiles list
|
||||
HIT(true, true),
|
||||
// stop tracing, don't write hit tile into traversed tiles list
|
||||
HIT_SKIP(true, false),
|
||||
// continue tracing, don't write hit tile into traversed tiles list
|
||||
SKIP(false, false),
|
||||
// continue tracing, write hit tile into traversed tiles list
|
||||
CONTINUE(false, true);
|
||||
|
||||
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 AnythingRayFilter = TileRayFilter { state, t, pos -> RayFilterResult.CONTINUE }
|
||||
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 NonSolidRayFilter = TileRayFilter { state, t, pos -> RayFilterResult.of(state.foreground.material != null) }
|
||||
fun ICellAccess.castRay(startPos: Vector2d, direction: Vector2d, length: Double, filter: TileRayFilter) = castRay(startPos, startPos + direction * length, filter)
|
||||
|
||||
/**
|
||||
* Попадает по первому пустому тайлу
|
||||
*/
|
||||
val SolidRayFilter = TileRayFilter { state, t, pos -> RayFilterResult.of(state.foreground.material == null) }
|
||||
|
||||
/**
|
||||
* Попадает по первому тайлу который блокирует проход света
|
||||
*/
|
||||
val LineOfSightRayFilter = TileRayFilter { state, t, pos -> RayFilterResult.of(state.foreground.material?.renderParameters?.lightTransparent == false) }
|
||||
|
||||
/**
|
||||
* Бросает луч напротив тайлов мира с заданными позициями и фильтром
|
||||
*/
|
||||
fun ICellAccess.castRayNaive(
|
||||
rayStart: Vector2d,
|
||||
rayEnd: Vector2d,
|
||||
filter: TileRayFilter = AnythingRayFilter
|
||||
// https://www.youtube.com/watch?v=NbSee-XM7WA
|
||||
fun ICellAccess.castRay(
|
||||
start: Vector2d,
|
||||
end: Vector2d,
|
||||
filter: TileRayFilter
|
||||
): RayCastResult {
|
||||
if (rayStart == rayEnd) {
|
||||
return RayCastResult(listOf(), null, 1.0)
|
||||
if (start == end)
|
||||
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
|
||||
val dir = rayEnd - rayStart
|
||||
val inc = 0.5 / dir.length
|
||||
|
||||
val tiles = LinkedList<Pair<Vector2i, IChunkCell>>()
|
||||
var prev = Vector2i(Int.MIN_VALUE, Int.MAX_VALUE)
|
||||
var hitTile: Pair<Vector2i, IChunkCell>? = null
|
||||
|
||||
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
|
||||
if (direction.y < 0.0) {
|
||||
stepY = -1
|
||||
rayLengthY = (start.y - cellPosY) * unitStepSizeY
|
||||
yNormal = Direction.UP
|
||||
} else {
|
||||
stepY = 1
|
||||
rayLengthY = (cellPosY - start.y + 1) * unitStepSizeY
|
||||
yNormal = Direction.DOWN
|
||||
}
|
||||
|
||||
return RayCastResult(tiles, hitTile, t)
|
||||
}
|
||||
while (travelled < distance) {
|
||||
val normal: Direction
|
||||
|
||||
/**
|
||||
* Бросает луч напротив тайлов мира с заданной позицией, направлением и фильтром
|
||||
*/
|
||||
fun ICellAccess.castRayNaive(
|
||||
rayPosition: Vector2d,
|
||||
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
|
||||
if (rayLengthX < rayLengthY) {
|
||||
cellPosX += stepX
|
||||
travelled = rayLengthX
|
||||
rayLengthX += unitStepSizeX
|
||||
normal = xNormal
|
||||
} 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) {
|
||||
return@castRayNaive RayFilterResult.HIT_SKIP
|
||||
val c = if (result.write || result.hit) {
|
||||
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
|
||||
}
|
||||
|
||||
/**
|
||||
* Трассирует лучи света вокруг себя с заданной позицией, интенсивностью,
|
||||
* падением интенсивности за проход сквозь тайл [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
|
||||
return RayCastResult(hitTiles, null, 1.0, start, start + direction * distance, direction)
|
||||
}
|
||||
|
||||
6
src/main/kotlin/ru/dbotthepony/kstarbound/world/Side.kt
Normal file
6
src/main/kotlin/ru/dbotthepony/kstarbound/world/Side.kt
Normal file
@ -0,0 +1,6 @@
|
||||
package ru.dbotthepony.kstarbound.world
|
||||
|
||||
enum class Side {
|
||||
LEFT,
|
||||
RIGHT;
|
||||
}
|
||||
@ -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) }
|
||||
}
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user