Projection, Particles, Speed fixes

bladekt · bladekt · commit 47929ff8200e · 2024-07-11T19:20:20.000+03:00
diff --git a/common/src/main/java/com/lambda/mixin/entity/ClientPlayInteractionManagerMixin.java b/common/src/main/java/com/lambda/mixin/entity/ClientPlayInteractionManagerMixin.java
@@ -1,10 +1,13 @@
 package com.lambda.mixin.entity;
 
 import com.lambda.event.EventFlow;
+import com.lambda.event.events.AttackEvent;
 import com.lambda.event.events.InteractionEvent;
 import net.minecraft.client.MinecraftClient;
 import net.minecraft.client.network.ClientPlayerEntity;
 import net.minecraft.client.network.ClientPlayerInteractionManager;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.PlayerEntity;
 import net.minecraft.util.ActionResult;
 import net.minecraft.util.Hand;
 import net.minecraft.util.hit.BlockHitResult;
@@ -13,6 +16,7 @@
 import org.spongepowered.asm.mixin.Shadow;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 
 @Mixin(ClientPlayerInteractionManager.class)
@@ -27,4 +31,14 @@ public void interactBlockHead(final ClientPlayerEntity player, final Hand hand,
         if (client.world == null) return;
         EventFlow.post(new InteractionEvent.Block(client.world, hitResult));
     }
+
+    @Inject(method = "attackEntity", at = @At("HEAD"), cancellable = true)
+    void onAttackPre(PlayerEntity player, Entity target, CallbackInfo ci) {
+        if (EventFlow.post(new AttackEvent.Pre(target)).isCanceled()) ci.cancel();
+    }
+
+    @Inject(method = "attackEntity", at = @At("TAIL"))
+    void onAttackPost(PlayerEntity player, Entity target, CallbackInfo ci) {
+        EventFlow.post(new AttackEvent.Post(target));
+    }
 }
diff --git a/common/src/main/kotlin/com/lambda/event/events/AttackEvent.kt b/common/src/main/kotlin/com/lambda/event/events/AttackEvent.kt
@@ -0,0 +1,11 @@
+package com.lambda.event.events
+
+import com.lambda.event.Event
+import com.lambda.event.callback.Cancellable
+import com.lambda.event.callback.ICancellable
+import net.minecraft.entity.Entity
+
+abstract class AttackEvent(val entity: Entity) : Event {
+    class Pre(entity: Entity) : AttackEvent(entity), ICancellable by Cancellable()
+    class Post(entity: Entity) : AttackEvent(entity)
+}
diff --git a/common/src/main/kotlin/com/lambda/graphics/buffer/vao/IRenderContext.kt b/common/src/main/kotlin/com/lambda/graphics/buffer/vao/IRenderContext.kt
@@ -1,15 +1,13 @@
 package com.lambda.graphics.buffer.vao
 
-import com.lambda.graphics.gl.Matrices
-import org.joml.Matrix4f
 import java.awt.Color
 
 interface IRenderContext {
     fun vec3(x: Double, y: Double, z: Double): IRenderContext
     fun vec2(x: Double, y: Double): IRenderContext
 
-    fun vec3m(x: Double, y: Double, z: Double, matrix4f: Matrix4f = Matrices.peek()): IRenderContext
-    fun vec2m(x: Double, y: Double, matrix4f: Matrix4f = Matrices.peek()): IRenderContext
+    fun vec3m(x: Double, y: Double, z: Double): IRenderContext
+    fun vec2m(x: Double, y: Double): IRenderContext
 
     fun float(v: Double): IRenderContext
     fun color(color: Color): IRenderContext
diff --git a/common/src/main/kotlin/com/lambda/graphics/buffer/vao/VAO.kt b/common/src/main/kotlin/com/lambda/graphics/buffer/vao/VAO.kt
@@ -3,6 +3,7 @@ package com.lambda.graphics.buffer.vao
 import com.lambda.graphics.buffer.vao.vertex.BufferUsage
 import com.lambda.graphics.buffer.vao.vertex.VertexAttrib
 import com.lambda.graphics.buffer.vao.vertex.VertexMode
+import com.lambda.graphics.gl.Matrices
 import com.lambda.graphics.gl.Memory.address
 import com.lambda.graphics.gl.Memory.byteBuffer
 import com.lambda.graphics.gl.Memory.capacity
@@ -89,16 +90,20 @@ class VAO(
         return this
     }
 
-    override fun vec3m(x: Double, y: Double, z: Double, matrix4f: Matrix4f): IRenderContext {
-        // ToDo: optimize at runtime
-        val vec = Vector4d(x, y, z, 1.0).apply(Matrix4d(matrix4f)::transform)
-        verticesPosition += vec3(verticesPosition, vec.x, vec.y, vec.z)
+    override fun vec3m(x: Double, y: Double, z: Double): IRenderContext {
+        Matrices.vertexTransformer?.let { mat ->
+            val vec = Vector4d(x, y, z, 1.0).apply(mat::transform)
+            vec3(vec.x, vec.y, vec.z)
+        } ?: vec3(x, y, z)
+
         return this
     }
 
-    override fun vec2m(x: Double, y: Double, matrix4f: Matrix4f): IRenderContext {
-        val vec = Vector4d(x, y, 0.0, 1.0).apply(Matrix4d(matrix4f)::transform)
-        verticesPosition += vec2(verticesPosition, vec.x, vec.y)
+    override fun vec2m(x: Double, y: Double): IRenderContext {
+        Matrices.vertexTransformer?.let { mat ->
+            val vec = Vector4d(x, y, 0.0, 1.0).apply(mat::transform)
+            vec2(vec.x, vec.y)
+        } ?: vec2(x, y)
         return this
     }
 
diff --git a/common/src/main/kotlin/com/lambda/graphics/buffer/vao/vertex/VertexAttrib.kt b/common/src/main/kotlin/com/lambda/graphics/buffer/vao/vertex/VertexAttrib.kt
@@ -16,13 +16,15 @@ enum class VertexAttrib(val componentCount: Int, componentSize: Int, val normali
         POS_UV(Vec2, Vec2),
 
         // GUI
-        FONT(Vec2, Vec2, Color), // pos, uv, color
+        FONT(Vec3, Vec2, Color), // pos, uv, color
         RECT_FILLED(Vec2, Vec2, Vec2, Float, Float, Color), // pos, uv, size, roundRadius, shade, color
         RECT_OUTLINE(Vec2, Float, Float, Color), // pos, alpha, shade, color
 
         // WORLD
         DYNAMIC_RENDERER(Vec3, Vec3, Color), // prev pos, pos, color
-        STATIC_RENDERER(Vec3, Color); // pos, color
+        STATIC_RENDERER(Vec3, Color), // pos, color
+
+        PARTICLE(Vec3, Vec2, Color); // pos, uv, color
 
         val stride = attributes.sumOf { attribute -> attribute.size }
     }
diff --git a/common/src/main/kotlin/com/lambda/graphics/gl/Matrices.kt b/common/src/main/kotlin/com/lambda/graphics/gl/Matrices.kt
@@ -1,11 +1,16 @@
 package com.lambda.graphics.gl
 
+import com.lambda.Lambda.mc
+import net.minecraft.util.math.Vec3d
+import org.joml.Matrix4d
 import org.joml.Matrix4f
 import org.joml.Quaternionf
 
 object Matrices {
     private val stack = ArrayDeque<Matrix4f>(1)
 
+    var vertexTransformer: Matrix4d? = null
+
     fun translate(x: Double, y: Double, z: Double) {
         translate(x.toFloat(), y.toFloat(), z.toFloat())
     }
@@ -51,4 +56,18 @@ object Matrices {
         stack.clear()
         stack.add(entry)
     }
+
+    fun withVertexTransform(matrix: Matrix4f, block: () -> Unit) {
+        vertexTransformer = Matrix4d(matrix)
+        block()
+        vertexTransformer = null
+    }
+
+    fun buildWorldProjection(pos: Vec3d, scale: Double = 1.0) = Matrix4f().apply {
+        val s = 0.025f * scale.toFloat()
+
+        translate(pos.x.toFloat(), pos.y.toFloat(), pos.z.toFloat())
+        rotate(mc.gameRenderer.camera.rotation)
+        scale(-s, -s, s)
+    }
 }
diff --git a/common/src/main/kotlin/com/lambda/graphics/renderer/gui/font/FontRenderer.kt b/common/src/main/kotlin/com/lambda/graphics/renderer/gui/font/FontRenderer.kt
@@ -33,10 +33,10 @@ class FontRenderer(
         iterateText(text, scale, shadow, color) { char, pos1, pos2, color ->
             grow(4)
             putQuad(
-                vec2(pos1.x + position.x, pos1.y + position.y).vec2(char.uv1.x, char.uv1.y).color(color).end(),
-                vec2(pos1.x + position.x, pos2.y + position.y).vec2(char.uv1.x, char.uv2.y).color(color).end(),
-                vec2(pos2.x + position.x, pos2.y + position.y).vec2(char.uv2.x, char.uv2.y).color(color).end(),
-                vec2(pos2.x + position.x, pos1.y + position.y).vec2(char.uv2.x, char.uv1.y).color(color).end()
+                vec3m(pos1.x + position.x, pos1.y + position.y, 0.0).vec2(char.uv1.x, char.uv1.y).color(color).end(),
+                vec3m(pos1.x + position.x, pos2.y + position.y, 0.0).vec2(char.uv1.x, char.uv2.y).color(color).end(),
+                vec3m(pos2.x + position.x, pos2.y + position.y, 0.0).vec2(char.uv2.x, char.uv2.y).color(color).end(),
+                vec3m(pos2.x + position.x, pos1.y + position.y, 0.0).vec2(char.uv2.x, char.uv1.y).color(color).end()
             )
         }
     }
diff --git a/common/src/main/kotlin/com/lambda/graphics/renderer/gui/rect/FilledRectRenderer.kt b/common/src/main/kotlin/com/lambda/graphics/renderer/gui/rect/FilledRectRenderer.kt
@@ -50,10 +50,10 @@ class FilledRectRenderer : AbstractRectRenderer(
         grow(4)
 
         putQuad(
-            vec2(p1.x, p1.y).vec2(0.0, 0.0).vec2(size.x, size.y).float(round).float(s).color(leftTop).end(),
-            vec2(p1.x, p2.y).vec2(0.0, 1.0).vec2(size.x, size.y).float(round).float(s).color(leftBottom).end(),
-            vec2(p2.x, p2.y).vec2(1.0, 1.0).vec2(size.x, size.y).float(round).float(s).color(rightBottom).end(),
-            vec2(p2.x, p1.y).vec2(1.0, 0.0).vec2(size.x, size.y).float(round).float(s).color(rightTop).end()
+            vec2m(p1.x, p1.y).vec2(0.0, 0.0).vec2(size.x, size.y).float(round).float(s).color(leftTop).end(),
+            vec2m(p1.x, p2.y).vec2(0.0, 1.0).vec2(size.x, size.y).float(round).float(s).color(leftBottom).end(),
+            vec2m(p2.x, p2.y).vec2(1.0, 1.0).vec2(size.x, size.y).float(round).float(s).color(rightBottom).end(),
+            vec2m(p2.x, p1.y).vec2(1.0, 0.0).vec2(size.x, size.y).float(round).float(s).color(rightTop).end()
         )
     }
 
diff --git a/common/src/main/kotlin/com/lambda/graphics/renderer/gui/rect/OutlineRectRenderer.kt b/common/src/main/kotlin/com/lambda/graphics/renderer/gui/rect/OutlineRectRenderer.kt
@@ -57,7 +57,7 @@ class OutlineRectRenderer : AbstractRectRenderer(
 
                 val pos = base + Vec2d(cos(angle), -sin(angle)) * round
                 val s = shade.toInt().toDouble()
-                add(vec2(pos.x, pos.y).float(a).float(s).color(c).end())
+                add(vec2m(pos.x, pos.y).float(a).float(s).color(c).end())
             }
 
             val rt = r.rightTop + Vec2d(-round, round)
diff --git a/common/src/main/kotlin/com/lambda/module/modules/movement/Speed.kt b/common/src/main/kotlin/com/lambda/module/modules/movement/Speed.kt
@@ -123,18 +123,6 @@ object Speed : Module(
             event.context = RotationContext(rotation, rotationConfig)
         }
 
-        listener<MovementEvent.InputUpdate> { event ->
-            if (mode != Mode.GRIM_STRAFE) return@listener
-            if (!shouldWork() || !isInputting) return@listener
-            if (player.input.handledByBaritone || TargetStrafe.isActive) return@listener
-
-            event.input.mergeFrom(
-                buildMovementInput(
-                    1.0, 0.0, event.input.jumping, event.input.sneaking
-                )
-            )
-        }
-
         onEnable {
             reset()
         }
diff --git a/common/src/main/kotlin/com/lambda/module/modules/movement/TargetStrafe.kt b/common/src/main/kotlin/com/lambda/module/modules/movement/TargetStrafe.kt
@@ -41,7 +41,7 @@ object TargetStrafe : Module(
         override val rotationMode = RotationMode.SYNC
     }
 
-    @JvmStatic val isActive get() = targetEntity != null
+    @JvmStatic val isActive get() = isEnabled && targetEntity != null
 
     init {
         listener<TickEvent.Post> {
diff --git a/common/src/main/kotlin/com/lambda/module/modules/render/Particles.kt b/common/src/main/kotlin/com/lambda/module/modules/render/Particles.kt
@@ -0,0 +1,171 @@
+package com.lambda.module.modules.render
+
+import com.lambda.event.events.AttackEvent
+import com.lambda.event.events.MovementEvent
+import com.lambda.event.events.RenderEvent
+import com.lambda.event.events.TickEvent
+import com.lambda.event.listener.SafeListener.Companion.listener
+import com.lambda.graphics.buffer.vao.VAO
+import com.lambda.graphics.buffer.vao.vertex.VertexAttrib
+import com.lambda.graphics.buffer.vao.vertex.VertexMode
+import com.lambda.graphics.gl.GlStateUtils.withBlendFunc
+import com.lambda.graphics.gl.GlStateUtils.withDepth
+import com.lambda.graphics.gl.Matrices.buildWorldProjection
+import com.lambda.graphics.gl.Matrices.withVertexTransform
+import com.lambda.graphics.shader.Shader
+import com.lambda.module.Module
+import com.lambda.module.modules.client.GuiSettings
+import com.lambda.module.modules.client.GuiSettings.colorSpeed
+import com.lambda.module.tag.ModuleTag
+import com.lambda.threading.runSafe
+import com.lambda.util.math.ColorUtils.multAlpha
+import com.lambda.util.math.MathUtils.lerp
+import com.lambda.util.math.MathUtils.random
+import com.lambda.util.math.transform
+import com.lambda.util.player.MovementUtils.moveDelta
+import com.lambda.util.player.MovementUtils.movementVector
+import com.lambda.util.player.MovementUtils.randomDirection
+import com.lambda.util.primitives.extension.partialTicks
+import net.minecraft.entity.Entity
+import net.minecraft.util.math.Vec3d
+
+import org.lwjgl.opengl.GL11.GL_ONE
+import org.lwjgl.opengl.GL11.GL_SRC_ALPHA
+import kotlin.math.sin
+
+object Particles : Module(
+    name = "Particles",
+    description = "Spawns fancy particles",
+    defaultTags = setOf(ModuleTag.RENDER)
+) {
+    private val duration by setting("Duration", 5.0, 1.0..500.0, 1.0)
+    private val fadeDuration by setting("Fade Ticks", 5.0, 1.0..30.0, 1.0)
+    private val spawnAmount by setting("Spawn Amount", 30.0, 3.0..500.0, 1.0)
+    private val size by setting("Size", 2.0, 0.1..50.0, 0.1)
+    private val alphaSetting by setting("Alpha", 1.5, 0.01..2.0, 0.01)
+    private val speedH by setting("Speed H", 1.0, 0.0..10.0, 0.1)
+    private val speedV by setting("Speed V", 1.0, 0.0..10.0, 0.1)
+    private val inertia by setting("Inertia", 0.0, 0.0..1.0, 0.01)
+    private val gravity by setting("Gravity", 0.2, 0.0..1.0, 0.01)
+
+    private val onMove by setting("On Move", true)
+
+    private var particles = mutableListOf<Particle>()
+    private val vao = VAO(VertexMode.TRIANGLES, VertexAttrib.Group.PARTICLE)
+    private val shader = Shader("renderer/particle", "renderer/particle")
+
+    init {
+        listener<TickEvent.Pre> {
+            particles.forEach(Particle::tick)
+            particles.removeIf(Particle::shouldRemove)
+        }
+
+        listener<RenderEvent.World> {
+            // Todo: interpolated tickbased upload?
+            particles.forEach(Particle::build)
+
+            withBlendFunc(GL_SRC_ALPHA, GL_ONE) {
+                shader.use()
+                shader["u_CameraPosition"] = mc.gameRenderer.camera.pos
+
+                vao.upload()
+                withDepth(vao::render)
+                vao.clear()
+            }
+        }
+
+        listener<AttackEvent.Pre> { event ->
+            spawnForEntity(event.entity)
+        }
+
+        listener<MovementEvent.Post> {
+            if (!onMove || player.moveDelta < 0.05) return@listener
+            spawnForEntity(player)
+        }
+    }
+
+    private fun spawnForEntity(entity: Entity) {
+        repeat(spawnAmount.toInt()) {
+            val i = (it + 1) / spawnAmount
+
+            val pos = entity.pos
+            val height = entity.boundingBox.lengthY
+            val spawnHeight = height * transform(i, 0.0, 1.0, 0.2, 0.8)
+            val particlePos = pos.add(0.0, spawnHeight, 0.0)
+
+            particles.add(Particle(particlePos))
+        }
+    }
+
+    private class Particle(posIn: Vec3d) {
+        var initTick = 0
+        var maxAge = 0
+        var fadeTicks = fadeDuration
+
+        var shouldRemove = false
+
+        var prevPos = posIn
+        var pos = posIn
+
+        var motion: Vec3d = Vec3d.ZERO
+
+        init {
+            runSafe {
+                initTick = player.age
+                maxAge = (duration + random(0.0, 20.0)).toInt()
+
+
+                motion = movementVector(randomDirection(), sin(random(0.0, Math.PI)))
+                    .multiply(random(0.0, 1.0), random(0.0, 1.0), random(0.0, 1.0))
+                    .multiply(
+                        speedH * random(0.9, 1.1),
+                        speedV * random(0.9, 1.1),
+                        speedH * random(0.9, 1.1)
+                    ).multiply(0.1)
+            }
+        }
+
+        fun tick() = runSafe {
+            prevPos = pos
+            pos = pos.add(motion)
+
+            motion = motion
+                .subtract(0.0, gravity * 0.01, 0.0)
+                .multiply(0.9 + inertia * 0.1)
+
+            shouldRemove = player.age - initTick > 5.0 + maxAge + fadeTicks * 2
+        }
+
+        fun build() = runSafe {
+            val age = player.age - initTick + mc.partialTicks
+            val colorTicks = age * 0.1 / colorSpeed
+
+            val alpha = when {
+                age < fadeTicks -> age / fadeTicks
+                age in fadeTicks..fadeTicks + maxAge -> 1.0
+                else -> {
+                    val min = fadeTicks + maxAge
+                    val max = fadeTicks * 2 + maxAge
+                    transform(age, min, max, 1.0, 0.0)
+                }
+            } * alphaSetting
+
+            val (c1, c2) = GuiSettings.primaryColor to GuiSettings.secondaryColor
+            val color = lerp(c1, c2, sin(colorTicks) * 0.5 + 0.5).multAlpha(alpha)
+
+            val position = lerp(prevPos, pos, mc.partialTicks)
+
+            withVertexTransform(buildWorldProjection(position, size)) {
+                vao.use {
+                    grow(4) // DO NOT FUCKING FORGOTEOIJTOWKET TO GROW (cost me an hour)
+                    putQuad(
+                        vec3m(-1.0, -1.0, 0.0).vec2(0.0, 0.0).color(color).end(),
+                        vec3m(-1.0, 1.0, 0.0).vec2(0.0, 1.0).color(color).end(),
+                        vec3m(1.0, 1.0, 0.0).vec2(1.0, 1.0).color(color).end(),
+                        vec3m(1.0, -1.0, 0.0).vec2(1.0, 0.0).color(color).end()
+                    )
+                }
+            }
+        }
+    }
+}
diff --git a/common/src/main/resources/assets/lambda/shaders/fragment/renderer/particle.frag b/common/src/main/resources/assets/lambda/shaders/fragment/renderer/particle.frag
diff --git a/common/src/main/resources/assets/lambda/shaders/vertex/renderer/particle.vert b/common/src/main/resources/assets/lambda/shaders/vertex/renderer/particle.vert

Original file line number	Diff line number	Diff line change
`@@ -33,10 +33,10 @@ class FontRenderer(`
`33`	`33`	`iterateText(text, scale, shadow, color) { char, pos1, pos2, color ->`
`34`	`34`	`grow(4)`
`35`	`35`	`putQuad(`
`36`		`- vec2(pos1.x + position.x, pos1.y + position.y).vec2(char.uv1.x, char.uv1.y).color(color).end(),`
`37`		`- vec2(pos1.x + position.x, pos2.y + position.y).vec2(char.uv1.x, char.uv2.y).color(color).end(),`
`38`		`- vec2(pos2.x + position.x, pos2.y + position.y).vec2(char.uv2.x, char.uv2.y).color(color).end(),`
`39`		`- vec2(pos2.x + position.x, pos1.y + position.y).vec2(char.uv2.x, char.uv1.y).color(color).end()`
	`36`	`+ vec3m(pos1.x + position.x, pos1.y + position.y, 0.0).vec2(char.uv1.x, char.uv1.y).color(color).end(),`
	`37`	`+ vec3m(pos1.x + position.x, pos2.y + position.y, 0.0).vec2(char.uv1.x, char.uv2.y).color(color).end(),`
	`38`	`+ vec3m(pos2.x + position.x, pos2.y + position.y, 0.0).vec2(char.uv2.x, char.uv2.y).color(color).end(),`
	`39`	`+ vec3m(pos2.x + position.x, pos1.y + position.y, 0.0).vec2(char.uv2.x, char.uv1.y).color(color).end()`
`40`	`40`	`)`
`41`	`41`	`}`
`42`	`42`	`}`
Original file line number	Diff line number	Diff line change
`@@ -50,10 +50,10 @@ class FilledRectRenderer : AbstractRectRenderer(`
`50`	`50`	`grow(4)`
`51`	`51`
`52`	`52`	`putQuad(`
`53`		`- vec2(p1.x, p1.y).vec2(0.0, 0.0).vec2(size.x, size.y).float(round).float(s).color(leftTop).end(),`
`54`		`- vec2(p1.x, p2.y).vec2(0.0, 1.0).vec2(size.x, size.y).float(round).float(s).color(leftBottom).end(),`
`55`		`- vec2(p2.x, p2.y).vec2(1.0, 1.0).vec2(size.x, size.y).float(round).float(s).color(rightBottom).end(),`
`56`		`- vec2(p2.x, p1.y).vec2(1.0, 0.0).vec2(size.x, size.y).float(round).float(s).color(rightTop).end()`
	`53`	`+ vec2m(p1.x, p1.y).vec2(0.0, 0.0).vec2(size.x, size.y).float(round).float(s).color(leftTop).end(),`
	`54`	`+ vec2m(p1.x, p2.y).vec2(0.0, 1.0).vec2(size.x, size.y).float(round).float(s).color(leftBottom).end(),`
	`55`	`+ vec2m(p2.x, p2.y).vec2(1.0, 1.0).vec2(size.x, size.y).float(round).float(s).color(rightBottom).end(),`
	`56`	`+ vec2m(p2.x, p1.y).vec2(1.0, 0.0).vec2(size.x, size.y).float(round).float(s).color(rightTop).end()`
`57`	`57`	`)`
`58`	`58`	`}`
`59`	`59`
Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,7 @@ class OutlineRectRenderer : AbstractRectRenderer(`
`57`	`57`
`58`	`58`	`val pos = base + Vec2d(cos(angle), -sin(angle)) * round`
`59`	`59`	`val s = shade.toInt().toDouble()`
`60`		`- add(vec2(pos.x, pos.y).float(a).float(s).color(c).end())`
	`60`	`+ add(vec2m(pos.x, pos.y).float(a).float(s).color(c).end())`
`61`	`61`	`}`
`62`	`62`
`63`	`63`	`val rt = r.rightTop + Vec2d(-round, round)`