Fix rendering lines twice and more settings

Avanatiker · Avanatiker · commit 405ff129abe0 · 2024-06-15T06:11:39.000+02:00
diff --git a/common/src/main/kotlin/com/lambda/graphics/renderer/esp/ChunkStorage.kt b/common/src/main/kotlin/com/lambda/graphics/renderer/esp/ChunkStorage.kt
@@ -13,11 +13,11 @@ object ChunkStorage : Loadable {
 
     init {
         concurrentListener<WorldEvent.ChunkEvent.Load> { event ->
-            chunkMap[event.chunk.pos] = event.chunk
+            chunkMap[event.chunk.pos.toLong()] = event.chunk
         }
 
         concurrentListener<WorldEvent.ChunkEvent.Unload> { event ->
-            chunkMap.remove(event.chunk.pos)
+            chunkMap.remove(event.chunk.pos.toLong())
         }
 
         concurrentListener<ConnectionEvent.Disconnect> {
@@ -26,4 +26,4 @@ object ChunkStorage : Loadable {
     }
 }
 
-typealias ChunkMap = ConcurrentHashMap<ChunkPos, WorldChunk>
+typealias ChunkMap = ConcurrentHashMap<Long, WorldChunk>
diff --git a/common/src/main/kotlin/com/lambda/graphics/renderer/esp/ChunkedESP.kt b/common/src/main/kotlin/com/lambda/graphics/renderer/esp/ChunkedESP.kt
@@ -8,64 +8,65 @@ import com.lambda.event.listener.SafeListener.Companion.listener
 import com.lambda.module.modules.client.RenderSettings
 import com.lambda.threading.runGameBlocking
 import net.minecraft.util.math.ChunkPos
-import net.minecraft.world.BlockView
+import net.minecraft.world.WorldView
 import net.minecraft.world.chunk.WorldChunk
 import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.ConcurrentLinkedDeque
 
 class ChunkedESP private constructor(
     owner: Any,
-    private val update: EspRenderer.(BlockView, Int, Int, Int) -> Unit
+    private val update: EspRenderer.(WorldView, Int, Int, Int) -> Unit
 ) {
-    private val rendererMap = ConcurrentHashMap<ChunkPos, EspChunk>()
-    private val WorldChunk.renderer get() = rendererMap.getOrPut(pos) {
+    private val rendererMap = ConcurrentHashMap<Long, EspChunk>()
+    private val WorldChunk.renderer get() = rendererMap.getOrPut(pos.toLong()) {
         EspChunk(this, this@ChunkedESP)
     }
     private var ticks = 0
 
-    private val uploadPool = ConcurrentLinkedDeque<() -> Unit>()
-    private val rebuildPool = ConcurrentLinkedDeque<EspChunk>()
+    private val uploadQueue = ConcurrentLinkedDeque<() -> Unit>()
+    private val rebuildQueue = ConcurrentLinkedDeque<EspChunk>()
 
     // i completely dont like to listen to enable events
 
-    fun clear() {
-        rendererMap.clear()
+    fun rebuild() {
+        rebuildQueue.clear()
+        rebuildQueue.addAll(rendererMap.values)
     }
 
     init {
-        owner.concurrentListener<WorldEvent.BlockUpdate> { event ->
+        concurrentListener<WorldEvent.BlockUpdate> { event ->
             world.getWorldChunk(event.pos).renderer.apply {
                 queueRebuild()
                 notifyNeighbors()
             }
         }
 
-        owner.concurrentListener<WorldEvent.ChunkEvent.Load> { event ->
+        concurrentListener<WorldEvent.ChunkEvent.Load> { event ->
             event.chunk.renderer.notifyNeighbors()
         }
 
-        owner.concurrentListener<WorldEvent.ChunkEvent.Unload> { event ->
-            rendererMap.remove(event.chunk.pos)?.notifyNeighbors()
+        concurrentListener<WorldEvent.ChunkEvent.Unload> { event ->
+            rendererMap.remove(event.chunk.pos.toLong())?.notifyNeighbors()
         }
 
         owner.concurrentListener<TickEvent.Pre> {
             if (++ticks % RenderSettings.updateFrequency == 0) {
-                val polls = minOf(RenderSettings.rebuildsPerTick, rebuildPool.size)
+                val polls = minOf(RenderSettings.rebuildsPerTick, rebuildQueue.size)
 
                 repeat(polls) {
-                    rebuildPool.poll()?.rebuild()
+                    rebuildQueue.poll()?.rebuild()
                 }
                 ticks = 0
             }
         }
 
         owner.listener<TickEvent.Pre> {
-            if (uploadPool.isEmpty()) return@listener
+            if (uploadQueue.isEmpty()) return@listener
 
-            val polls = minOf(RenderSettings.uploadsPerTick, uploadPool.size)
+            val polls = minOf(RenderSettings.uploadsPerTick, uploadQueue.size)
 
             repeat(polls) {
-                uploadPool.poll()?.invoke()
+                uploadQueue.poll()?.invoke()
             }
         }
 
@@ -78,7 +79,7 @@ class ChunkedESP private constructor(
 
     companion object {
         fun Any.newChunkedESP(
-            update: EspRenderer.(BlockView, Int, Int, Int) -> Unit
+            update: EspRenderer.(WorldView, Int, Int, Int) -> Unit
         ) = ChunkedESP(this, update)
     }
 
@@ -94,12 +95,13 @@ class ChunkedESP private constructor(
         fun ChunkPos.isLoaded() = chunk.world.chunkManager.isChunkLoaded(x, z)
 
         fun queueRebuild() {
-            owner.rebuildPool.add(this)
+            if (owner.rebuildQueue.contains(this)) return
+            owner.rebuildQueue.add(this)
         }
 
         fun notifyNeighbors() {
             neighbors.forEach {
-                owner.rendererMap[it]?.queueRebuild()
+                owner.rendererMap[it.toLong()]?.queueRebuild()
             }
         }
 
@@ -114,6 +116,7 @@ class ChunkedESP private constructor(
 
             val upload = {
                 newRenderer.upload()
+                renderer?.clear()
                 renderer = newRenderer
             }
 
@@ -124,7 +127,7 @@ class ChunkedESP private constructor(
                     }
                 }
                 RenderSettings.UploadScheduler.Delayed -> {
-                    owner.uploadPool.add(upload)
+                    owner.uploadQueue.add(upload)
                 }
             }
         }
diff --git a/common/src/main/kotlin/com/lambda/graphics/renderer/esp/EspRenderer.kt b/common/src/main/kotlin/com/lambda/graphics/renderer/esp/EspRenderer.kt
@@ -22,6 +22,8 @@ import com.lambda.util.primitives.extension.min
 import net.minecraft.util.math.Box
 import java.awt.Color
 import java.util.concurrent.ConcurrentHashMap
+import kotlin.math.abs
+import kotlin.math.hypot
 
 class EspRenderer(
     usage: BufferUsage = BufferUsage.STATIC
@@ -35,26 +37,117 @@ class EspRenderer(
     private var updateFilled = false
     private var updateOutline = false
 
-    fun build(box: Box, filledColor: Color, outlineColor: Color, sides: Int = DirectionMask.ALL, outlineMode: DirectionMask.OutlineMode = DirectionMask.OutlineMode.OR) {
+    fun build(
+        box: Box,
+        filledColor: Color,
+        outlineColor: Color,
+        sides: Int = DirectionMask.ALL,
+        outlineMode: DirectionMask.OutlineMode = DirectionMask.OutlineMode.OR
+    ) {
         buildFilled(box, filledColor, sides)
         buildOutline(box, outlineColor, sides, outlineMode)
     }
 
+    fun buildConvexHull(
+        boxes: Set<Box>,
+        color: Color
+    ) = outline.use {
+        updateOutline = true
+
+        // Step 1: Collect all vertices
+        val vertices = mutableSetOf<Vertex>()
+        boxes.forEach { box ->
+            val pos1 = box.min
+            val pos2 = box.max
+
+            vertices.add(Vertex(pos1.x, pos1.y, pos1.z, color))
+            vertices.add(Vertex(pos1.x, pos1.y, pos2.z, color))
+            vertices.add(Vertex(pos2.x, pos1.y, pos1.z, color))
+            vertices.add(Vertex(pos2.x, pos1.y, pos2.z, color))
+            vertices.add(Vertex(pos1.x, pos2.y, pos1.z, color))
+            vertices.add(Vertex(pos1.x, pos2.y, pos2.z, color))
+            vertices.add(Vertex(pos2.x, pos2.y, pos1.z, color))
+            vertices.add(Vertex(pos2.x, pos2.y, pos2.z, color))
+        }
+
+        // Step 2: Find the convex hull
+        val convexHull = findConvexHull(vertices)
+
+        // Step 3: Build outline of convex hull
+        for (i in convexHull.indices) {
+            val v1 = convexHull[i]
+            val v2 = convexHull[(i + 1) % convexHull.size]
+            val intV1 = vec3(v1.x, v1.y, v1.z).color(v1.color).end()
+            val intV2 = vec3(v2.x, v2.y, v2.z).color(v2.color).end()
+            putLine(intV1, intV2)
+        }
+    }
+
+    // Utility function to find the convex hull using the QuickHull algorithm
+    private fun findConvexHull(vertices: Set<Vertex>): List<Vertex> {
+        if (vertices.size <= 1) return vertices.toList()
+
+        val points = vertices.toMutableList()
+        points.sortWith(compareBy({ it.x }, { it.y }))
+        val left = points.first()
+        val right = points.last()
+
+        val (leftSet, rightSet) = points.partition { isLeft(left, right, it) }
+
+        val hull = mutableListOf<Vertex>()
+        hull.add(left)
+        hull.addAll(findHull(left, right, leftSet))
+        hull.add(right)
+        hull.addAll(findHull(right, left, rightSet))
+
+        return hull
+    }
+
+    // Check if the point is on the left side of the line from start to end
+    private fun isLeft(start: Vertex, end: Vertex, point: Vertex): Boolean {
+        return (end.x - start.x) * (point.y - start.y) - (end.y - start.y) * (point.x - start.x) > 0
+    }
+
+    // Recursively find the hull points
+    private fun findHull(start: Vertex, end: Vertex, points: List<Vertex>): List<Vertex> {
+        if (points.isEmpty()) return emptyList()
+
+        val farthest = points.maxByOrNull { distanceFromLine(start, end, it) } ?: return emptyList()
+
+        // Partition points into two sets: those to the left of the line (start, farthest) and those to the left of (farthest, end)
+        val (leftSetStartFarthest, _) = points.partition { isLeft(start, farthest, it) }
+        val (leftSetFarthestEnd, _) = points.partition { isLeft(farthest, end, it) }
+
+        val hull = mutableListOf<Vertex>()
+        hull.addAll(findHull(start, farthest, leftSetStartFarthest))
+        hull.add(farthest)
+        hull.addAll(findHull(farthest, end, leftSetFarthestEnd))
+
+        return hull
+    }
+
+    // Calculate the distance from the line
+    private fun distanceFromLine(start: Vertex, end: Vertex, point: Vertex): Double {
+        val area = abs((end.x - start.x) * (point.y - start.y) - (end.y - start.y) * (point.x - start.x))
+        val base = Math.hypot((end.x - start.x), (end.y - start.y))
+        return area / base
+    }
+
     fun buildFilled(box: Box, color: Color, sides: Int = DirectionMask.ALL) = filled.use {
         updateFilled = true
         val pos1 = box.min
         val pos2 = box.max
 
         grow(8)
 
-        val blb by vertex(filledVertices, pos1.x, pos1.y, pos1.z, color)
-        val blf by vertex(filledVertices, pos1.x, pos1.y, pos2.z, color)
-        val brb by vertex(filledVertices, pos2.x, pos1.y, pos1.z, color)
-        val brf by vertex(filledVertices, pos2.x, pos1.y, pos2.z, color)
-        val tlb by vertex(filledVertices, pos1.x, pos2.y, pos1.z, color)
-        val tlf by vertex(filledVertices, pos1.x, pos2.y, pos2.z, color)
-        val trb by vertex(filledVertices, pos2.x, pos2.y, pos1.z, color)
-        val trf by vertex(filledVertices, pos2.x, pos2.y, pos2.z, color)
+        val blb by vertex(pos1.x, pos1.y, pos1.z, color)
+        val blf by vertex(pos1.x, pos1.y, pos2.z, color)
+        val brb by vertex(pos2.x, pos1.y, pos1.z, color)
+        val brf by vertex(pos2.x, pos1.y, pos2.z, color)
+        val tlb by vertex(pos1.x, pos2.y, pos1.z, color)
+        val tlf by vertex(pos1.x, pos2.y, pos2.z, color)
+        val trb by vertex(pos2.x, pos2.y, pos1.z, color)
+        val trf by vertex(pos2.x, pos2.y, pos2.z, color)
 
         if (sides.hasDirection(EAST))  putQuad(brb, trb, trf, brf)
         if (sides.hasDirection(WEST))  putQuad(blb, blf, tlf, tlb)
@@ -71,14 +164,14 @@ class EspRenderer(
 
         grow(8)
 
-        val blb by vertex(outlineVertices, pos1.x, pos1.y, pos1.z, color)
-        val blf by vertex(outlineVertices, pos1.x, pos1.y, pos2.z, color)
-        val brb by vertex(outlineVertices, pos2.x, pos1.y, pos1.z, color)
-        val brf by vertex(outlineVertices, pos2.x, pos1.y, pos2.z, color)
-        val tlb by vertex(outlineVertices, pos1.x, pos2.y, pos1.z, color)
-        val tlf by vertex(outlineVertices, pos1.x, pos2.y, pos2.z, color)
-        val trb by vertex(outlineVertices, pos2.x, pos2.y, pos1.z, color)
-        val trf by vertex(outlineVertices, pos2.x, pos2.y, pos2.z, color)
+        val blb by vertex(pos1.x, pos1.y, pos1.z, color)
+        val blf by vertex(pos1.x, pos1.y, pos2.z, color)
+        val brb by vertex(pos2.x, pos1.y, pos1.z, color)
+        val brf by vertex(pos2.x, pos1.y, pos2.z, color)
+        val tlb by vertex(pos1.x, pos2.y, pos1.z, color)
+        val tlf by vertex(pos1.x, pos2.y, pos2.z, color)
+        val trb by vertex(pos2.x, pos2.y, pos1.z, color)
+        val trf by vertex(pos2.x, pos2.y, pos2.z, color)
 
         val hasEast  = sides.hasDirection(EAST)
         val hasWest  = sides.hasDirection(WEST)
@@ -132,7 +225,6 @@ class EspRenderer(
     }
 
     private fun IRenderContext.vertex(
-        storage: MutableMap<Vertex, Int>,
         x: Double, y: Double, z: Double,
         color: Color
     ) = lazy {
@@ -141,11 +233,12 @@ class EspRenderer(
         }
 
         if (RenderSettings.vertexMapping) {
-            storage.getOrPut(Vertex(x, y, z, color), newVertex)
+            filledVertices.getOrPut(Vertex(x, y, z, color), newVertex)
         } else newVertex()
     }
 
     private data class Vertex(val x: Double, val y: Double, val z: Double, val color: Color)
+    private data class Edge(val vertex1: Vertex, val vertex2: Vertex)
 
     companion object {
         private val shader = Shader("renderer/pos_color", "renderer/box_static")
diff --git a/common/src/main/kotlin/com/lambda/module/modules/client/RenderSettings.kt b/common/src/main/kotlin/com/lambda/module/modules/client/RenderSettings.kt
@@ -20,8 +20,8 @@ object RenderSettings : Module(
 
     // ESP
     val uploadScheduler by setting("Upload Scheduler", UploadScheduler.Instant) { page == Page.ESP }
-    val uploadsPerTick by setting("Uploads", 8, 1..32, 1, unit = " chunk/tick") { page == Page.ESP && uploadScheduler == UploadScheduler.Delayed }
-    val rebuildsPerTick by setting("Rebuilds", 8, 1..32, 1, unit = " chunk/tick") { page == Page.ESP }
+    val uploadsPerTick by setting("Uploads", 16, 1..256, 1, unit = " chunk/tick") { page == Page.ESP && uploadScheduler == UploadScheduler.Delayed }
+    val rebuildsPerTick by setting("Rebuilds", 64, 1..256, 1, unit = " chunk/tick") { page == Page.ESP }
     val vertexMapping by setting("Vertex Mapping", true) { page == Page.ESP }
     val updateFrequency by setting("Update Frequency", 2, 1..10, 1, "Frequency of block updates", unit = " ticks") { page == Page.ESP }
     val outlineWidth by setting("Outline Width", 1.0, 0.1..5.0, 0.1, "Width of block outlines", unit = "px") { page == Page.ESP }
diff --git a/common/src/main/kotlin/com/lambda/module/modules/render/BlockESP.kt b/common/src/main/kotlin/com/lambda/module/modules/render/BlockESP.kt

Original file line number	Diff line number	Diff line change
`@@ -13,11 +13,11 @@ object ChunkStorage : Loadable {`
`13`	`13`
`14`	`14`	`init {`
`15`	`15`	`concurrentListener<WorldEvent.ChunkEvent.Load> { event ->`
`16`		`- chunkMap[event.chunk.pos] = event.chunk`
	`16`	`+ chunkMap[event.chunk.pos.toLong()] = event.chunk`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`concurrentListener<WorldEvent.ChunkEvent.Unload> { event ->`
`20`		`- chunkMap.remove(event.chunk.pos)`
	`20`	`+ chunkMap.remove(event.chunk.pos.toLong())`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`concurrentListener<ConnectionEvent.Disconnect> {`
`@@ -26,4 +26,4 @@ object ChunkStorage : Loadable {`
`26`	`26`	`}`
`27`	`27`	`}`
`28`	`28`
`29`		`-typealias ChunkMap = ConcurrentHashMap<ChunkPos, WorldChunk>`
	`29`	`+typealias ChunkMap = ConcurrentHashMap<Long, WorldChunk>`
Original file line number	Diff line number	Diff line change
`@@ -8,64 +8,65 @@ import com.lambda.event.listener.SafeListener.Companion.listener`
`8`	`8`	`import com.lambda.module.modules.client.RenderSettings`
`9`	`9`	`import com.lambda.threading.runGameBlocking`
`10`	`10`	`import net.minecraft.util.math.ChunkPos`
`11`		`-import net.minecraft.world.BlockView`
	`11`	`+import net.minecraft.world.WorldView`
`12`	`12`	`import net.minecraft.world.chunk.WorldChunk`
`13`	`13`	`import java.util.concurrent.ConcurrentHashMap`
`14`	`14`	`import java.util.concurrent.ConcurrentLinkedDeque`
`15`	`15`
`16`	`16`	`class ChunkedESP private constructor(`
`17`	`17`	`owner: Any,`
`18`		`- private val update: EspRenderer.(BlockView, Int, Int, Int) -> Unit`
	`18`	`+ private val update: EspRenderer.(WorldView, Int, Int, Int) -> Unit`
`19`	`19`	`) {`
`20`		`- private val rendererMap = ConcurrentHashMap<ChunkPos, EspChunk>()`
`21`		`- private val WorldChunk.renderer get() = rendererMap.getOrPut(pos) {`
	`20`	`+ private val rendererMap = ConcurrentHashMap<Long, EspChunk>()`
	`21`	`+ private val WorldChunk.renderer get() = rendererMap.getOrPut(pos.toLong()) {`
`22`	`22`	`EspChunk(this, this@ChunkedESP)`
`23`	`23`	`}`
`24`	`24`	`private var ticks = 0`
`25`	`25`
`26`		`- private val uploadPool = ConcurrentLinkedDeque<() -> Unit>()`
`27`		`- private val rebuildPool = ConcurrentLinkedDeque<EspChunk>()`
	`26`	`+ private val uploadQueue = ConcurrentLinkedDeque<() -> Unit>()`
	`27`	`+ private val rebuildQueue = ConcurrentLinkedDeque<EspChunk>()`
`28`	`28`
`29`	`29`	`// i completely dont like to listen to enable events`
`30`	`30`
`31`		`- fun clear() {`
`32`		`- rendererMap.clear()`
	`31`	`+ fun rebuild() {`
	`32`	`+ rebuildQueue.clear()`
	`33`	`+ rebuildQueue.addAll(rendererMap.values)`
`33`	`34`	`}`
`34`	`35`
`35`	`36`	`init {`
`36`		`- owner.concurrentListener<WorldEvent.BlockUpdate> { event ->`
	`37`	`+ concurrentListener<WorldEvent.BlockUpdate> { event ->`
`37`	`38`	`world.getWorldChunk(event.pos).renderer.apply {`
`38`	`39`	`queueRebuild()`
`39`	`40`	`notifyNeighbors()`
`40`	`41`	`}`
`41`	`42`	`}`
`42`	`43`
`43`		`- owner.concurrentListener<WorldEvent.ChunkEvent.Load> { event ->`
	`44`	`+ concurrentListener<WorldEvent.ChunkEvent.Load> { event ->`
`44`	`45`	`event.chunk.renderer.notifyNeighbors()`
`45`	`46`	`}`
`46`	`47`
`47`		`- owner.concurrentListener<WorldEvent.ChunkEvent.Unload> { event ->`
`48`		`- rendererMap.remove(event.chunk.pos)?.notifyNeighbors()`
	`48`	`+ concurrentListener<WorldEvent.ChunkEvent.Unload> { event ->`
	`49`	`+ rendererMap.remove(event.chunk.pos.toLong())?.notifyNeighbors()`
`49`	`50`	`}`
`50`	`51`
`51`	`52`	`owner.concurrentListener<TickEvent.Pre> {`
`52`	`53`	`if (++ticks % RenderSettings.updateFrequency == 0) {`
`53`		`- val polls = minOf(RenderSettings.rebuildsPerTick, rebuildPool.size)`
	`54`	`+ val polls = minOf(RenderSettings.rebuildsPerTick, rebuildQueue.size)`
`54`	`55`
`55`	`56`	`repeat(polls) {`
`56`		`- rebuildPool.poll()?.rebuild()`
	`57`	`+ rebuildQueue.poll()?.rebuild()`
`57`	`58`	`}`
`58`	`59`	`ticks = 0`
`59`	`60`	`}`
`60`	`61`	`}`
`61`	`62`
`62`	`63`	`owner.listener<TickEvent.Pre> {`
`63`		`- if (uploadPool.isEmpty()) return@listener`
	`64`	`+ if (uploadQueue.isEmpty()) return@listener`
`64`	`65`
`65`		`- val polls = minOf(RenderSettings.uploadsPerTick, uploadPool.size)`
	`66`	`+ val polls = minOf(RenderSettings.uploadsPerTick, uploadQueue.size)`
`66`	`67`
`67`	`68`	`repeat(polls) {`
`68`		`- uploadPool.poll()?.invoke()`
	`69`	`+ uploadQueue.poll()?.invoke()`
`69`	`70`	`}`
`70`	`71`	`}`
`71`	`72`
`@@ -78,7 +79,7 @@ class ChunkedESP private constructor(`
`78`	`79`
`79`	`80`	`companion object {`
`80`	`81`	`fun Any.newChunkedESP(`
`81`		`- update: EspRenderer.(BlockView, Int, Int, Int) -> Unit`
	`82`	`+ update: EspRenderer.(WorldView, Int, Int, Int) -> Unit`
`82`	`83`	`) = ChunkedESP(this, update)`
`83`	`84`	`}`
`84`	`85`
`@@ -94,12 +95,13 @@ class ChunkedESP private constructor(`
`94`	`95`	`fun ChunkPos.isLoaded() = chunk.world.chunkManager.isChunkLoaded(x, z)`
`95`	`96`
`96`	`97`	`fun queueRebuild() {`
`97`		`- owner.rebuildPool.add(this)`
	`98`	`+ if (owner.rebuildQueue.contains(this)) return`
	`99`	`+ owner.rebuildQueue.add(this)`
`98`	`100`	`}`
`99`	`101`
`100`	`102`	`fun notifyNeighbors() {`
`101`	`103`	`neighbors.forEach {`
`102`		`- owner.rendererMap[it]?.queueRebuild()`
	`104`	`+ owner.rendererMap[it.toLong()]?.queueRebuild()`
`103`	`105`	`}`
`104`	`106`	`}`
`105`	`107`
`@@ -114,6 +116,7 @@ class ChunkedESP private constructor(`
`114`	`116`
`115`	`117`	`val upload = {`
`116`	`118`	`newRenderer.upload()`
	`119`	`+ renderer?.clear()`
`117`	`120`	`renderer = newRenderer`
`118`	`121`	`}`
`119`	`122`
`@@ -124,7 +127,7 @@ class ChunkedESP private constructor(`
`124`	`127`	`}`
`125`	`128`	`}`
`126`	`129`	`RenderSettings.UploadScheduler.Delayed -> {`
`127`		`- owner.uploadPool.add(upload)`
	`130`	`+ owner.uploadQueue.add(upload)`
`128`	`131`	`}`
`129`	`132`	`}`
`130`	`133`	`}`