diff --git a/.idea/runConfigurations/Terrarum.xml b/.idea/runConfigurations/Terrarum.xml
index e3cfa4b07..c124bd17e 100644
--- a/.idea/runConfigurations/Terrarum.xml
+++ b/.idea/runConfigurations/Terrarum.xml
@@ -1,7 +1,7 @@
 <component name="ProjectRunConfigurationManager">
   <configuration default="false" name="Terrarum" type="JarApplication">
     <option name="JAR_PATH" value="$PROJECT_DIR$/out/TerrarumBuild.jar" />
-    <option name="VM_PARAMETERS" value="-ea -Dswing.aatext=true -Dawt.useSystemAAFontSettings=lcd --add-modules jdk.incubator.vector" />
+    <option name="VM_PARAMETERS" value="-ea -Dswing.aatext=true -Dawt.useSystemAAFontSettings=lcd" />
     <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$" />
     <option name="ALTERNATIVE_JRE_PATH_ENABLED" value="true" />
     <option name="ALTERNATIVE_JRE_PATH" value="17" />
diff --git a/src/net/torvald/gdx/graphics/Cvec.kt b/src/net/torvald/gdx/graphics/Cvec.kt
index 38fef6ed8..399729795 100644
--- a/src/net/torvald/gdx/graphics/Cvec.kt
+++ b/src/net/torvald/gdx/graphics/Cvec.kt
@@ -380,8 +380,6 @@ class Cvec {
 
     fun toGdxColor() = Color(r, g, b, a)
 
-    fun toFloatArray() = floatArrayOf(r, g, b, a)
-
     /** Extract Hue-Saturation-Value. This is the inverse of [.fromHsv].
      * @param hsv The HSV array to be modified.
      * @return HSV components for chaining.
diff --git a/src/net/torvald/gdx/graphics/VectorArray.kt b/src/net/torvald/gdx/graphics/VectorArray.kt
deleted file mode 100644
index 9b1c73f4e..000000000
--- a/src/net/torvald/gdx/graphics/VectorArray.kt
+++ /dev/null
@@ -1,67 +0,0 @@
-package net.torvald.gdx.graphics
-
-import jdk.incubator.vector.FloatVector
-import jdk.incubator.vector.FloatVector.SPECIES_128
-import java.nio.ByteBuffer
-import java.nio.ByteOrder
-
-/**
- * Created by minjaesong on 2023-01-18.
- */
-class VectorArray(val width: Int, val height: Int) {
-
-    companion object {
-        val SPECIES = SPECIES_128
-        val BO = ByteOrder.nativeOrder()
-        val NULLVEC = FloatVector.broadcast(VectorArray.SPECIES, 0f)
-    }
-
-    val TOTAL_SIZE_IN_BYTES = 16 * (width + 1) * (height + 1)
-    private val array = ByteBuffer.allocateDirect(TOTAL_SIZE_IN_BYTES)
-
-    private inline fun toAddr(x: Int, y: Int) = 4 * (y * width + x)
-
-
-    init {
-        array.clear()
-        array.rewind()
-    }
-
-    private fun _getVec(a: Int) = FloatVector.fromByteBuffer(SPECIES, array, a, BO)
-
-    fun getVec(x: Int, y: Int): FloatVector {
-        val a = toAddr(x, y)
-        return FloatVector.fromByteBuffer(SPECIES, array, a, BO)
-    }
-
-    private fun _setVec(a: Int, value: FloatVector) {
-        value.intoByteBuffer(array, a, BO)
-    }
-
-    fun setVec(x: Int, y: Int, value: FloatVector) {
-        val a = toAddr(x, y)
-        value.intoByteBuffer(array, a, BO)
-    }
-
-    fun setScalar(x: Int, y: Int, value: Float) {
-        val a = toAddr(x, y)
-
-        array.putFloat(a + 0, value)
-        array.putFloat(a + 1, value)
-        array.putFloat(a + 2, value)
-        array.putFloat(a + 3, value)
-    }
-
-    fun max(x: Int, y: Int, other: FloatVector) {
-        val a = toAddr(x, y)
-        val mv = _getVec(a).max(other)
-        _setVec(a, mv)
-    }
-
-    fun mul(x: Int, y: Int, scalar: Float) {
-        val a = toAddr(x, y)
-        val mv = _getVec(a).max(scalar)
-        _setVec(a, mv)
-    }
-
-}
\ No newline at end of file
diff --git a/src/net/torvald/terrarum/blockproperties/BlockCodex.kt b/src/net/torvald/terrarum/blockproperties/BlockCodex.kt
index 388019450..e50a8bca8 100644
--- a/src/net/torvald/terrarum/blockproperties/BlockCodex.kt
+++ b/src/net/torvald/terrarum/blockproperties/BlockCodex.kt
@@ -1,7 +1,6 @@
 package net.torvald.terrarum.blockproperties
 
-import jdk.incubator.vector.FloatVector
-import net.torvald.gdx.graphics.VectorArray
+import net.torvald.gdx.graphics.Cvec
 import net.torvald.terrarum.App.printdbg
 import net.torvald.terrarum.ReferencingRanges.PREFIX_VIRTUALTILE
 import net.torvald.terrarum.gameitems.ItemID
@@ -191,7 +190,7 @@ class BlockCodex {
         prop.shadeColG = record.floatVal("shdg")
         prop.shadeColB = record.floatVal("shdb")
         prop.shadeColA = record.floatVal("shduv")
-
+        prop.opacity = Cvec(prop.shadeColR, prop.shadeColG, prop.shadeColB, prop.shadeColA)
 
         prop.strength = record.intVal("str")
         prop.density = record.intVal("dsty")
@@ -200,13 +199,7 @@ class BlockCodex {
         prop.baseLumColG = record.floatVal("lumg")
         prop.baseLumColB = record.floatVal("lumb")
         prop.baseLumColA = record.floatVal("lumuv")
-
-        val cvec = floatArrayOf(
-            prop.shadeColR, prop.shadeColG, prop.shadeColB, prop.shadeColA,
-            prop.baseLumColR, prop.baseLumColG, prop.baseLumColB, prop.baseLumColA
-        )
-        prop.opacity = FloatVector.fromArray(VectorArray.SPECIES, cvec, 0)
-        prop.baseLumCol = FloatVector.fromArray(VectorArray.SPECIES, cvec, 4)
+        prop.baseLumCol.set(prop.baseLumColR, prop.baseLumColG, prop.baseLumColB, prop.baseLumColA)
 
         prop.friction = record.intVal("fr")
         prop.viscosity = record.intVal("vscs")
diff --git a/src/net/torvald/terrarum/blockproperties/BlockProp.kt b/src/net/torvald/terrarum/blockproperties/BlockProp.kt
index 638596f1e..ee2eefc45 100644
--- a/src/net/torvald/terrarum/blockproperties/BlockProp.kt
+++ b/src/net/torvald/terrarum/blockproperties/BlockProp.kt
@@ -1,8 +1,6 @@
 package net.torvald.terrarum.blockproperties
 
-import jdk.incubator.vector.FloatVector
 import net.torvald.gdx.graphics.Cvec
-import net.torvald.gdx.graphics.VectorArray.Companion.NULLVEC
 import net.torvald.random.XXHash32
 import net.torvald.terrarum.*
 import net.torvald.terrarum.gameitems.ItemID
@@ -24,7 +22,7 @@ class BlockProp {
     var shadeColB = 0f
     var shadeColA = 0f
 
-    lateinit var opacity: FloatVector
+    lateinit var opacity: Cvec
 
     fun getOpacity(channel: Int) = when (channel) {
         0 -> shadeColR
@@ -56,12 +54,12 @@ class BlockProp {
     internal var baseLumColG = 0f // base value used to calculate dynamic luminosity
     internal var baseLumColB = 0f // base value used to calculate dynamic luminosity
     internal var baseLumColA = 0f // base value used to calculate dynamic luminosity
-    internal var baseLumCol: FloatVector = NULLVEC
+    internal val baseLumCol = Cvec(0)
     //var lumColR = 0f // memoised value of dynamic luminosity
     //var lumColG = 0f // memoised value of dynamic luminosity
     //var lumColB = 0f // memoised value of dynamic luminosity
     //var lumColA = 0f // memoised value of dynamic luminosity
-    internal var _lumCol: FloatVector = NULLVEC
+    internal val _lumCol = Cvec(0)
     // X- and Y-value must be treated properly beforehand! (use GameWorld.coerceXY())
     fun getLumCol(x: Int, y: Int) = if (dynamicLuminosityFunction == 0) {
         baseLumCol
diff --git a/src/net/torvald/terrarum/blockproperties/BlockPropUtil.kt b/src/net/torvald/terrarum/blockproperties/BlockPropUtil.kt
index 0c793dc30..60032b32c 100644
--- a/src/net/torvald/terrarum/blockproperties/BlockPropUtil.kt
+++ b/src/net/torvald/terrarum/blockproperties/BlockPropUtil.kt
@@ -2,9 +2,7 @@ package net.torvald.terrarum.blockproperties
 
 import com.badlogic.gdx.Gdx
 import com.jme3.math.FastMath
-import jdk.incubator.vector.FloatVector
 import net.torvald.gdx.graphics.Cvec
-import net.torvald.gdx.graphics.VectorArray
 import net.torvald.random.HQRNG
 import net.torvald.terrarum.*
 import net.torvald.terrarum.gameworld.WorldTime
@@ -35,17 +33,17 @@ object BlockPropUtil {
 
     }
 
-    private fun getTorchFlicker(prop: BlockProp): FloatVector {
+    private fun getTorchFlicker(prop: BlockProp): Cvec {
         val funcY = FastMath.interpolateLinear(prop.rngBase0 / flickerFuncDomain, prop.rngBase1, prop.rngBase2)
         return alterBrightnessUniform(prop.baseLumCol, funcY)
     }
 
-    private fun getSlowBreath(prop: BlockProp): FloatVector {
+    private fun getSlowBreath(prop: BlockProp): Cvec {
         val funcY = FastMath.sin(FastMath.PI * prop.rngBase0 / breathCycleDuration) * breathRange
         return alterBrightnessUniform(prop.baseLumCol, funcY)
     }
 
-    private fun getPulsate(prop: BlockProp): FloatVector {
+    private fun getPulsate(prop: BlockProp): Cvec {
         val funcY = FastMath.sin(FastMath.PI * prop.rngBase0 / pulsateCycleDuration) * pulsateRange
         return alterBrightnessUniform(prop.baseLumCol, funcY)
     }
@@ -94,7 +92,7 @@ object BlockPropUtil {
                 prop.rngBase2 = getNewRandom()
             }
 
-            prop._lumCol = getDynamicLumFunc(prop)
+            prop._lumCol.set(getDynamicLumFunc(prop))
             //prop.lumColR = prop.lumCol.r
             //prop.lumColG = prop.lumCol.g
             //prop.lumColB = prop.lumCol.b
@@ -106,11 +104,11 @@ object BlockPropUtil {
 
     private fun linearInterpolation1D(a: Float, b: Float, x: Float) = a * (1 - x) + b * x
 
-    private fun getDynamicLumFunc(prop: BlockProp): FloatVector {
+    private fun getDynamicLumFunc(prop: BlockProp): Cvec {
         return when (prop.dynamicLuminosityFunction) {
             1    -> getTorchFlicker(prop)
-            2    -> FloatVector.fromArray(VectorArray.SPECIES, INGAME.world.globalLight.toFloatArray(), 0) // current global light
-            3    -> FloatVector.fromArray(VectorArray.SPECIES, WeatherMixer.getGlobalLightOfTime(INGAME.world, WorldTime.DAY_LENGTH / 2).toFloatArray(), 0) // daylight at noon
+            2    -> (INGAME.world).globalLight.cpy() // current global light
+            3    -> WeatherMixer.getGlobalLightOfTime(INGAME.world, WorldTime.DAY_LENGTH / 2).cpy() // daylight at noon
             4    -> getSlowBreath(prop)
             5    -> getPulsate(prop)
             else -> prop.baseLumCol
@@ -138,7 +136,12 @@ object BlockPropUtil {
      * @param brighten (-1.0 - 1.0) negative means darkening
      * @return processed colour
      */
-    private fun alterBrightnessUniform(data: FloatVector, brighten: Float): FloatVector {
-        return data.add(brighten)
+    private fun alterBrightnessUniform(data: Cvec, brighten: Float): Cvec {
+        return Cvec(
+                data.r + brighten,
+                data.g + brighten,
+                data.b + brighten,
+                data.a + brighten
+        )
     }
 }
\ No newline at end of file
diff --git a/src/net/torvald/terrarum/gameactors/Luminous.kt b/src/net/torvald/terrarum/gameactors/Luminous.kt
index b22be031e..532d39737 100644
--- a/src/net/torvald/terrarum/gameactors/Luminous.kt
+++ b/src/net/torvald/terrarum/gameactors/Luminous.kt
@@ -1,16 +1,15 @@
 package net.torvald.terrarum.gameactors
 
-import jdk.incubator.vector.FloatVector
-import net.torvald.gdx.graphics.VectorArray
+import net.torvald.gdx.graphics.Cvec
 
 /**
  * Lightbox is defined based on pixelwise position in the world!
  */
 class Lightbox() {
     var hitbox: Hitbox = Hitbox(0.0,0.0,0.0,0.0)
-    var light: FloatVector = FloatVector.broadcast(VectorArray.SPECIES, 0f)
+    var light: Cvec = Cvec()
 
-    constructor(hitbox: Hitbox, light: FloatVector) : this() {
+    constructor(hitbox: Hitbox, light: Cvec) : this() {
         this.hitbox = hitbox
         this.light = light
     }
diff --git a/src/net/torvald/terrarum/modulebasegame/gameactors/ActorHumanoid.kt b/src/net/torvald/terrarum/modulebasegame/gameactors/ActorHumanoid.kt
index 63f10f34e..4ebaf1391 100644
--- a/src/net/torvald/terrarum/modulebasegame/gameactors/ActorHumanoid.kt
+++ b/src/net/torvald/terrarum/modulebasegame/gameactors/ActorHumanoid.kt
@@ -3,10 +3,7 @@ package net.torvald.terrarum.modulebasegame.gameactors
 import com.badlogic.gdx.Gdx
 import com.badlogic.gdx.graphics.g2d.TextureRegion
 import com.jme3.math.FastMath
-import jdk.incubator.vector.FloatVector
 import net.torvald.gdx.graphics.Cvec
-import net.torvald.gdx.graphics.VectorArray
-import net.torvald.gdx.graphics.VectorArray.Companion.NULLVEC
 import net.torvald.spriteanimation.AssembledSpriteAnimation
 import net.torvald.spriteanimation.HasAssembledSprite
 import net.torvald.spriteanimation.SheetSpriteAnimation
@@ -68,32 +65,32 @@ open class ActorHumanoid : ActorWithBody, Controllable, Pocketed, Factionable, L
         if (houseDesignation != null) houseDesignation!!.clear()
     }
 
-    var actorValueColour: FloatVector
-        get() = FloatVector.fromArray(VectorArray.SPECIES, floatArrayOf(
+    var actorValueColour: Cvec
+        get() = Cvec(
                 (actorValue.getAsFloat(AVKey.LUMR) ?: 0f),
                 (actorValue.getAsFloat(AVKey.LUMG) ?: 0f),
                 (actorValue.getAsFloat(AVKey.LUMB) ?: 0f),
                 (actorValue.getAsFloat(AVKey.LUMA) ?: 0f)
-        ), 0)
+        )
         set(value) {
-            actorValue[AVKey.LUMR] = value.lane(0)
-            actorValue[AVKey.LUMG] = value.lane(1)
-            actorValue[AVKey.LUMB] = value.lane(2)
-            actorValue[AVKey.LUMA] = value.lane(3)
+            actorValue[AVKey.LUMR] = value.r
+            actorValue[AVKey.LUMG] = value.g
+            actorValue[AVKey.LUMB] = value.b
+            actorValue[AVKey.LUMA] = value.a
         }
 
-    var actorValueShade: FloatVector
-        get() = FloatVector.fromArray(VectorArray.SPECIES, floatArrayOf(
+    var actorValueShade: Cvec
+        get() = Cvec(
                 (actorValue.getAsFloat(AVKey.OPAR) ?: 0f),
                 (actorValue.getAsFloat(AVKey.OPAG) ?: 0f),
                 (actorValue.getAsFloat(AVKey.OPAB) ?: 0f),
                 (actorValue.getAsFloat(AVKey.OPAA) ?: 0f)
-        ), 0)
+        )
         set(value) {
-            actorValue[AVKey.OPAR] = value.lane(0)
-            actorValue[AVKey.OPAG] = value.lane(1)
-            actorValue[AVKey.OPAB] = value.lane(2)
-            actorValue[AVKey.OPAA] = value.lane(3)
+            actorValue[AVKey.OPAR] = value.r
+            actorValue[AVKey.OPAG] = value.g
+            actorValue[AVKey.OPAB] = value.b
+            actorValue[AVKey.OPAA] = value.a
         }
 
     /**
@@ -102,9 +99,9 @@ open class ActorHumanoid : ActorWithBody, Controllable, Pocketed, Factionable, L
      * Hitbox(x-offset, y-offset, width, height)
      * (Use ArrayList for normal circumstances)
      */
-    @Transient override var lightBoxList: List<Lightbox> = listOf(Lightbox(Hitbox(2.0, 2.0, baseHitboxW - 3.0, baseHitboxH - 3.0), NULLVEC))
+    @Transient override var lightBoxList: List<Lightbox> = listOf(Lightbox(Hitbox(2.0, 2.0, baseHitboxW - 3.0, baseHitboxH - 3.0), Cvec(0)))
         // the actual values are update on the update()
-    @Transient override var shadeBoxList: List<Lightbox> = listOf(Lightbox(Hitbox(2.0, 2.0, baseHitboxW - 3.0, baseHitboxH - 3.0), NULLVEC))
+    @Transient override var shadeBoxList: List<Lightbox> = listOf(Lightbox(Hitbox(2.0, 2.0, baseHitboxW - 3.0, baseHitboxH - 3.0), Cvec(0)))
         // the actual values are update on the update()
 
     @Transient val BASE_DENSITY = 980.0
diff --git a/src/net/torvald/terrarum/modulebasegame/gameactors/DroppedItem.kt b/src/net/torvald/terrarum/modulebasegame/gameactors/DroppedItem.kt
index d156ab435..7d7a67e10 100644
--- a/src/net/torvald/terrarum/modulebasegame/gameactors/DroppedItem.kt
+++ b/src/net/torvald/terrarum/modulebasegame/gameactors/DroppedItem.kt
@@ -4,7 +4,6 @@ import com.badlogic.gdx.graphics.g2d.SpriteBatch
 import com.badlogic.gdx.graphics.g2d.TextureRegion
 import com.jme3.math.FastMath
 import net.torvald.gdx.graphics.Cvec
-import net.torvald.gdx.graphics.VectorArray.Companion.NULLVEC
 import net.torvald.terrarum.BlockCodex
 import net.torvald.terrarum.INGAME
 import net.torvald.terrarum.ItemCodex
@@ -40,9 +39,9 @@ open class DroppedItem : ActorWithBody {
     private val randKey1 = (Math.random() * 256).toInt()
     private val randKey2 = (Math.random() * 256).toInt()
 
-    override var lightBoxList = listOf(Lightbox(this.hitbox.clone().setPosition(0.0, 0.0), NULLVEC))
+    override var lightBoxList = listOf(Lightbox(this.hitbox.clone().setPosition(0.0, 0.0), Cvec(0)))
         // the Cvec will be calculated dynamically on Update
-    override var shadeBoxList = listOf(Lightbox(this.hitbox.clone().setPosition(0.0, 0.0), NULLVEC))
+    override var shadeBoxList = listOf(Lightbox(this.hitbox.clone().setPosition(0.0, 0.0), Cvec(0)))
         // the Cvec will be calculated dynamically on Update
 
     /**
diff --git a/src/net/torvald/terrarum/modulebasegame/gameactors/FixtureSwingingDoorBase.kt b/src/net/torvald/terrarum/modulebasegame/gameactors/FixtureSwingingDoorBase.kt
index a949cfdf9..6ef2887c8 100644
--- a/src/net/torvald/terrarum/modulebasegame/gameactors/FixtureSwingingDoorBase.kt
+++ b/src/net/torvald/terrarum/modulebasegame/gameactors/FixtureSwingingDoorBase.kt
@@ -1,10 +1,7 @@
 package net.torvald.terrarum.modulebasegame.gameactors
 
 import com.badlogic.gdx.Gdx
-import jdk.incubator.vector.FloatVector
 import net.torvald.gdx.graphics.Cvec
-import net.torvald.gdx.graphics.VectorArray
-import net.torvald.gdx.graphics.VectorArray.Companion.NULLVEC
 import net.torvald.spriteanimation.SheetSpriteAnimation
 import net.torvald.terrarum.*
 import net.torvald.terrarum.App.printdbg
@@ -29,7 +26,7 @@ open class FixtureSwingingDoorBase : FixtureBase {
     var tw = 2 // tilewise width of the door when opened
     var twClosed = 1 // tilewise width of the door when closed
     var th = 3 // tilewise height of the door
-    var opacity = BlockCodex[Block.STONE].opacity.toCvec()
+    var opacity = BlockCodex[Block.STONE].opacity
     var isOpacityActuallyLuminosity = false
     var moduleName = "basegame"
     var texturePath = "sprites/fixtures/door_test.tga"
@@ -46,9 +43,9 @@ open class FixtureSwingingDoorBase : FixtureBase {
     private var pixelwiseHitboxHeight = TILE_SIZE * tilewiseHitboxHeight
     private var tilewiseDistToAxis = tw - twClosed
 
-    @Transient override var lightBoxList = listOf(Lightbox(Hitbox(TILE_SIZED * tilewiseDistToAxis, 0.0, TILE_SIZED * twClosed, TILE_SIZED * th), NULLVEC))
+    @Transient override var lightBoxList = listOf(Lightbox(Hitbox(TILE_SIZED * tilewiseDistToAxis, 0.0, TILE_SIZED * twClosed, TILE_SIZED * th), Cvec(0)))
     // the Cvec will be calculated dynamically on Update
-    @Transient override var shadeBoxList = listOf(Lightbox(Hitbox(TILE_SIZED * tilewiseDistToAxis, 0.0, TILE_SIZED * twClosed, TILE_SIZED * th), NULLVEC))
+    @Transient override var shadeBoxList = listOf(Lightbox(Hitbox(TILE_SIZED * tilewiseDistToAxis, 0.0, TILE_SIZED * twClosed, TILE_SIZED * th), Cvec(0)))
     // the Cvec will be calculated dynamically on Update
 
     protected var doorState = 0 // -1: open toward left, 0: closed, 1: open toward right
@@ -57,9 +54,6 @@ open class FixtureSwingingDoorBase : FixtureBase {
     @Transient private lateinit var customNameFun: () -> String
     @Transient private lateinit var doorHoldLength: HashMap<Int, Second>
 
-    private fun FloatVector.toCvec() = Cvec(this.lane(0), this.lane(1), this.lane(2), this.lane(3))
-
-
     constructor() : super(
             BlockBox(BlockBox.FULL_COLLISION, 1, 1), // temporary value, will be overwritten by spawn()
             nameFun = { "item not loaded properly, alas!" }
@@ -68,7 +62,7 @@ open class FixtureSwingingDoorBase : FixtureBase {
                 2,
                 1,
                 3,
-                BlockCodex[Block.STONE].opacity.toCvec(),
+                BlockCodex[Block.STONE].opacity,
                 false,
                 "basegame",
                 "sprites/fixtures/door_test.tga",
@@ -79,18 +73,18 @@ open class FixtureSwingingDoorBase : FixtureBase {
     }
 
     protected fun _construct(
-        tw: Int, // tilewise width of the door when opened
-        twClosed: Int, // tilewise width of the door when closed
-        th: Int, // tilewise height of the door
-        opacity: Cvec,
-        isOpacityActuallyLuminosity: Boolean,
-        moduleName: String,
-        texturePath: String,
-        textureIdentifier: String,
-        nameKey: String,
-        nameKeyReadFromLang: Boolean,
-        doorCloseHoldLength: Second = 0.1f,
-        doorOpenedHoldLength: Second = 0.25f
+            tw: Int, // tilewise width of the door when opened
+            twClosed: Int, // tilewise width of the door when closed
+            th: Int, // tilewise height of the door
+            opacity: Cvec,
+            isOpacityActuallyLuminosity: Boolean,
+            moduleName: String,
+            texturePath: String,
+            textureIdentifier: String,
+            nameKey: String,
+            nameKeyReadFromLang: Boolean,
+            doorCloseHoldLength: Second = 0.1f,
+            doorOpenedHoldLength: Second = 0.25f
     ) {
         this.tw = tw
         this.twClosed = twClosed
@@ -129,7 +123,7 @@ open class FixtureSwingingDoorBase : FixtureBase {
 
         // define light/shadebox
         // TODO: redefine when opened to left/right
-        (if (isOpacityActuallyLuminosity) lightBoxList else shadeBoxList)[0].light = FloatVector.fromArray(VectorArray.SPECIES, opacity.toFloatArray(), 0)
+        (if (isOpacityActuallyLuminosity) lightBoxList else shadeBoxList)[0].light = opacity
 
         // define physical size
         setHitboxDimension(TILE_SIZE * tilewiseHitboxWidth, TILE_SIZE * tilewiseHitboxHeight, 0, 0)
@@ -153,16 +147,16 @@ open class FixtureSwingingDoorBase : FixtureBase {
 
         // define light/shadebox
         // TODO: redefine when opened to left/right
-        (if (isOpacityActuallyLuminosity) lightBoxList else shadeBoxList)[0].light = FloatVector.fromArray(VectorArray.SPECIES, opacity.toFloatArray(), 0)
+        (if (isOpacityActuallyLuminosity) lightBoxList else shadeBoxList)[0].light = opacity
 
     }
 
     private fun setOpacity() {
-        shadeBoxList[0].light = FloatVector.fromArray(VectorArray.SPECIES, opacity.toFloatArray(), 0)
+        shadeBoxList[0].light = opacity
     }
 
     private fun unsetOpacity() {
-        shadeBoxList[0].light = NULLVEC
+        shadeBoxList[0].light = Cvec(0)
     }
 
     open protected fun closeDoor(doorHandler: Int) {
diff --git a/src/net/torvald/terrarum/modulebasegame/gameactors/FixtureSwingingDoorRosewood.kt b/src/net/torvald/terrarum/modulebasegame/gameactors/FixtureSwingingDoorRosewood.kt
index 40a7e220b..01c41a568 100644
--- a/src/net/torvald/terrarum/modulebasegame/gameactors/FixtureSwingingDoorRosewood.kt
+++ b/src/net/torvald/terrarum/modulebasegame/gameactors/FixtureSwingingDoorRosewood.kt
@@ -1,22 +1,18 @@
 package net.torvald.terrarum.modulebasegame.gameactors
 
-import jdk.incubator.vector.FloatVector
-import net.torvald.gdx.graphics.Cvec
 import net.torvald.terrarum.BlockCodex
 import net.torvald.terrarum.blockproperties.Block
 
 /**
  * Created by minjaesong on 2022-07-28.
  */
-private fun FloatVector.toCvec() = Cvec(this.lane(0), this.lane(1), this.lane(2), this.lane(3))
-
 class FixtureSwingingDoorOak : FixtureSwingingDoorBase {
     constructor() : super() {
         _construct(
                 2,
                 1,
                 3,
-                BlockCodex[Block.STONE].opacity.toCvec(),
+                BlockCodex[Block.STONE].opacity,
                 false,
                 "basegame",
                 "sprites/fixtures/door_basegame-48.tga",
@@ -33,7 +29,7 @@ class FixtureSwingingDoorEbony : FixtureSwingingDoorBase {
                 2,
                 1,
                 3,
-                BlockCodex[Block.STONE].opacity.toCvec(),
+                BlockCodex[Block.STONE].opacity,
                 false,
                 "basegame",
                 "sprites/fixtures/door_basegame-49.tga",
@@ -50,7 +46,7 @@ class FixtureSwingingDoorBirch : FixtureSwingingDoorBase {
                 2,
                 1,
                 3,
-                BlockCodex[Block.STONE].opacity.toCvec(),
+                BlockCodex[Block.STONE].opacity,
                 false,
                 "basegame",
                 "sprites/fixtures/door_basegame-50.tga",
@@ -67,7 +63,7 @@ class FixtureSwingingDoorRosewood : FixtureSwingingDoorBase {
                 2,
                 1,
                 3,
-                BlockCodex[Block.STONE].opacity.toCvec(),
+                BlockCodex[Block.STONE].opacity,
                 false,
                 "basegame",
                 "sprites/fixtures/door_basegame-51.tga",
diff --git a/src/net/torvald/terrarum/modulebasegame/gameactors/ProjectileSimple.kt b/src/net/torvald/terrarum/modulebasegame/gameactors/ProjectileSimple.kt
index 54fd601ed..20f832dac 100644
--- a/src/net/torvald/terrarum/modulebasegame/gameactors/ProjectileSimple.kt
+++ b/src/net/torvald/terrarum/modulebasegame/gameactors/ProjectileSimple.kt
@@ -2,9 +2,7 @@ package net.torvald.terrarum.modulebasegame.gameactors
 
 import com.badlogic.gdx.graphics.Color
 import com.badlogic.gdx.graphics.g2d.SpriteBatch
-import jdk.incubator.vector.FloatVector
 import net.torvald.gdx.graphics.Cvec
-import net.torvald.gdx.graphics.VectorArray
 import net.torvald.terrarum.BlockCodex
 import net.torvald.terrarum.INGAME
 import net.torvald.terrarum.Point2d
@@ -31,8 +29,8 @@ open class ProjectileSimple : ActorWithBody, Projectile {
     var speed: Int = 0
 
 
-    private var color: FloatVector
-        get() = bulletDatabase[type][OFFSET_LUMINOSITY] as FloatVector
+    private var color: Cvec
+        get() = (bulletDatabase[type][OFFSET_LUMINOSITY] as Cvec).cpy()
         set(value) {
         }
     /**
@@ -117,9 +115,7 @@ open class ProjectileSimple : ActorWithBody, Projectile {
 
     override fun drawGlow(batch: SpriteBatch) = drawBody(batch)
 
-
     companion object {
-        private fun Int.toFloatVector() = FloatVector.fromArray(VectorArray.SPECIES, Cvec(this).toFloatArray(), 0)
         val OFFSET_DAMAGE = 0
         val OFFSET_COL = 1 // Color or SpriteAnimation
         val OFFSET_NOGRAVITY = 2
@@ -127,8 +123,8 @@ open class ProjectileSimple : ActorWithBody, Projectile {
         val OFFSET_LUMINOSITY = 4
         val bulletDatabase = arrayOf(
                 // damage, display colour, no gravity, speed
-                arrayOf(7, 0xFF5429_FF.toInt().toFloatVector(), true, 40, 32),
-                arrayOf(8, 0xFF5429_FF.toInt().toFloatVector(), true, 20, 0)
+                arrayOf(7, Cvec(0xFF5429_FF.toInt()), true, 40, 32),
+                arrayOf(8, Cvec(0xFF5429_FF.toInt()), true, 20, 0)
                 // ...
         )
     }
diff --git a/src/net/torvald/terrarum/ui/BasicDebugInfoWindow.kt b/src/net/torvald/terrarum/ui/BasicDebugInfoWindow.kt
index 203e2c737..6d02adfb1 100644
--- a/src/net/torvald/terrarum/ui/BasicDebugInfoWindow.kt
+++ b/src/net/torvald/terrarum/ui/BasicDebugInfoWindow.kt
@@ -196,10 +196,10 @@ class BasicDebugInfoWindow : UICanvas() {
         try {
             world?.let {
                 val valRaw = LightmapRenderer.getLight(mouseTileX, mouseTileY)
-                val rawR = valRaw?.lane(0)?.toDouble().toIntAndFrac(1,3)
-                val rawG = valRaw?.lane(1)?.toDouble().toIntAndFrac(1,3)
-                val rawB = valRaw?.lane(2)?.toDouble().toIntAndFrac(1,3)
-                val rawA = valRaw?.lane(3)?.toDouble().toIntAndFrac(1,3)
+                val rawR = valRaw?.r?.toDouble().toIntAndFrac(1,3)
+                val rawG = valRaw?.g?.toDouble().toIntAndFrac(1,3)
+                val rawB = valRaw?.b?.toDouble().toIntAndFrac(1,3)
+                val rawA = valRaw?.a?.toDouble().toIntAndFrac(1,3)
 
                 val wallNum = it.getTileFromWall(mouseTileX, mouseTileY)
                 val tileNum = it.getTileFromTerrain(mouseTileX, mouseTileY)
diff --git a/src/net/torvald/terrarum/worlddrawer/LightmapRenderer.kt b/src/net/torvald/terrarum/worlddrawer/LightmapRenderer.kt
index f4393a26d..4cca921e8 100644
--- a/src/net/torvald/terrarum/worlddrawer/LightmapRenderer.kt
+++ b/src/net/torvald/terrarum/worlddrawer/LightmapRenderer.kt
@@ -4,10 +4,8 @@ import com.badlogic.gdx.graphics.Color
 import com.badlogic.gdx.graphics.Pixmap
 import com.badlogic.gdx.graphics.Texture
 import com.jme3.math.FastMath
-import jdk.incubator.vector.FloatVector
-import net.torvald.gdx.graphics.VectorArray
 import net.torvald.gdx.graphics.Cvec
-import net.torvald.gdx.graphics.VectorArray.Companion.NULLVEC
+import net.torvald.gdx.graphics.UnsafeCvecArray
 import net.torvald.terrarum.*
 import net.torvald.terrarum.App.printdbg
 import net.torvald.terrarum.TerrarumAppConfiguration.TILE_SIZE
@@ -50,10 +48,10 @@ object LightmapRenderer {
             if (this.world != world) {
                 printdbg(this, "World change detected -- old world: ${this.world.hashCode()}, new world: ${world.hashCode()}")
 
-//                lightmap.zerofill()
-//                _mapLightLevelThis.zerofill()
-//                _mapThisTileOpacity.zerofill()
-//                _mapThisTileOpacity2.zerofill()
+                lightmap.zerofill()
+                _mapLightLevelThis.zerofill()
+                _mapThisTileOpacity.zerofill()
+                _mapThisTileOpacity2.zerofill()
             }
         }
         catch (e: UninitializedPropertyAccessException) {
@@ -73,8 +71,8 @@ object LightmapRenderer {
 
     //private val noopMask = HashSet<Point2i>((LIGHTMAP_WIDTH + LIGHTMAP_HEIGHT) * 2)
 
-    private val lanternMap = HashMap<BlockAddress, FloatVector>((Terrarum.ingame?.ACTORCONTAINER_INITIAL_SIZE ?: 2) * 4)
-    private val shadowMap = HashMap<BlockAddress, FloatVector>((Terrarum.ingame?.ACTORCONTAINER_INITIAL_SIZE ?: 2) * 4)
+    private val lanternMap = HashMap<BlockAddress, Cvec>((Terrarum.ingame?.ACTORCONTAINER_INITIAL_SIZE ?: 2) * 4)
+    private val shadowMap = HashMap<BlockAddress, Cvec>((Terrarum.ingame?.ACTORCONTAINER_INITIAL_SIZE ?: 2) * 4)
 //    private val giMap = HashMap<BlockAddress, Cvec>((Terrarum.ingame?.ACTORCONTAINER_INITIAL_SIZE ?: 2) * 4)
     /**
      * Float value, 1.0 for 1023
@@ -82,10 +80,10 @@ object LightmapRenderer {
      * Note: using UnsafeCvecArray does not actually show great performance improvement
      */
     // it utilises alpha channel to determine brightness of "glow" sprites (so that alpha channel works like UV light)
-    private var lightmap = VectorArray(LIGHTMAP_WIDTH, LIGHTMAP_HEIGHT)
-    private var _mapLightLevelThis = VectorArray(LIGHTMAP_WIDTH, LIGHTMAP_HEIGHT)
-    private var _mapThisTileOpacity = VectorArray(LIGHTMAP_WIDTH, LIGHTMAP_HEIGHT)
-    private var _mapThisTileOpacity2 = VectorArray(LIGHTMAP_WIDTH, LIGHTMAP_HEIGHT)
+    private var lightmap = UnsafeCvecArray(LIGHTMAP_WIDTH, LIGHTMAP_HEIGHT)
+    private var _mapLightLevelThis = UnsafeCvecArray(LIGHTMAP_WIDTH, LIGHTMAP_HEIGHT)
+    private var _mapThisTileOpacity = UnsafeCvecArray(LIGHTMAP_WIDTH, LIGHTMAP_HEIGHT)
+    private var _mapThisTileOpacity2 = UnsafeCvecArray(LIGHTMAP_WIDTH, LIGHTMAP_HEIGHT)
 
     private const val AIR = Block.AIR
 
@@ -120,7 +118,7 @@ object LightmapRenderer {
      * @param x world tile coord
      * @param y world tile coord
      */
-    internal fun getLight(x: Int, y: Int): FloatVector? {
+    internal fun getLight(x: Int, y: Int): Cvec? {
         val x = if (for_x_start - overscan_open + LIGHTMAP_WIDTH >= world.width && x - for_x_start + overscan_open < 0)
             x + world.width
         else if (for_x_start - overscan_open + LIGHTMAP_WIDTH < 0 && x - for_x_start + overscan_open >= world.width)
@@ -141,7 +139,7 @@ object LightmapRenderer {
 
     fun recalculate(actorContainer: List<ActorWithBody>) = _recalculate(actorContainer, lightmap)
 
-    private fun _recalculate(actorContainer: List<ActorWithBody>, lightmap: VectorArray) {
+    private fun _recalculate(actorContainer: List<ActorWithBody>, lightmap: UnsafeCvecArray) {
         try {
             world.getTileFromTerrain(0, 0) // test inquiry
         }
@@ -181,8 +179,7 @@ object LightmapRenderer {
         } // usually takes 3000 ns
 
         // copy current world's globalLight into this
-        val cvec = world.globalLight.toFloatArray()
-        sunLight = FloatVector.fromArray(VectorArray.SPECIES, cvec, 0)
+        sunLight.set(world.globalLight)
 
         // set no-op mask from solidity of the block
         /*AppLoader.measureDebugTime("Renderer.LightNoOpMask") {
@@ -207,7 +204,7 @@ object LightmapRenderer {
 
         // 'NEWLIGHT2' LIGHT SWIPER
         // O((8*2)n) where n is a size of the map.
-        /* - */fun r1(lightmap: VectorArray) {
+        /* - */fun r1(lightmap: UnsafeCvecArray) {
             swipeDiag = false
             for (line in 1 until LIGHTMAP_HEIGHT - 1) {
                 swipeLight(
@@ -218,7 +215,7 @@ object LightmapRenderer {
                 )
             }
         }
-        /* | */fun r2(lightmap: VectorArray) {
+        /* | */fun r2(lightmap: UnsafeCvecArray) {
             swipeDiag = false
             for (line in 1 until LIGHTMAP_WIDTH - 1) {
                 swipeLight(
@@ -229,7 +226,7 @@ object LightmapRenderer {
                 )
             }
         }
-        /* \ */fun r3(lightmap: VectorArray) {
+        /* \ */fun r3(lightmap: UnsafeCvecArray) {
             swipeDiag = true
             /* construct indices such that:
                   56789ABC
@@ -267,7 +264,7 @@ object LightmapRenderer {
                 )
             }
         }
-        /* / */fun r4(lightmap: VectorArray) {
+        /* / */fun r4(lightmap: UnsafeCvecArray) {
             swipeDiag = true
             /*
                 1       w-2
@@ -363,10 +360,10 @@ object LightmapRenderer {
                     for (x in lightBoxX.div(TILE_SIZE).floorInt()
                             ..lightBoxX.plus(lightBoxW).div(TILE_SIZE).floorInt()) {
 
-                        val oldLight = lanternMap[LandUtil.getBlockAddr(world, x, y)] ?: NULLVEC // if two or more luminous actors share the same block, mix the light
+                        val oldLight = lanternMap[LandUtil.getBlockAddr(world, x, y)] ?: Cvec(0) // if two or more luminous actors share the same block, mix the light
                         val actorLight = colour
 
-                        lanternMap[LandUtil.getBlockAddr(world, x, y)] = oldLight.max(actorLight)
+                        lanternMap[LandUtil.getBlockAddr(world, x, y)] = oldLight.maxAndAssign(actorLight)
                     }
                 }
             }
@@ -382,10 +379,10 @@ object LightmapRenderer {
                     for (x in lightBoxX.div(TILE_SIZE).floorInt()
                             ..lightBoxX.plus(lightBoxW).div(TILE_SIZE).floorInt()) {
 
-                        val oldLight = shadowMap[LandUtil.getBlockAddr(world, x, y)] ?: NULLVEC // if two or more luminous actors share the same block, mix the light
+                        val oldLight = shadowMap[LandUtil.getBlockAddr(world, x, y)] ?: Cvec(0) // if two or more luminous actors share the same block, mix the light
                         val actorLight = colour
 
-                        shadowMap[LandUtil.getBlockAddr(world, x, y)] = oldLight.max(actorLight)
+                        shadowMap[LandUtil.getBlockAddr(world, x, y)] = oldLight.maxAndAssign(actorLight)
                     }
                 }
             }
@@ -430,16 +427,16 @@ object LightmapRenderer {
     }*/
 
     // local variables that are made static
-    private var sunLight = FloatVector.broadcast(VectorArray.SPECIES, 0f)
+    private val sunLight = Cvec(0)
     private var _thisTerrain = 0
     private var _thisFluid = GameWorld.FluidInfo(Fluid.NULL, 0f)
     private var _thisWall = 0
-    private var _ambientAccumulator = FloatVector.broadcast(VectorArray.SPECIES, 0f)
-    private var _reflectanceAccumulator = FloatVector.broadcast(VectorArray.SPECIES, 0f)
-    private var _thisTileOpacity = FloatVector.broadcast(VectorArray.SPECIES, 0f)
-    private var _thisTileOpacity2 = FloatVector.broadcast(VectorArray.SPECIES, 0f) // thisTileOpacity * sqrt(2)
-    private var _fluidAmountToCol = FloatVector.broadcast(VectorArray.SPECIES, 0f)
-    private var _thisTileLuminosity = FloatVector.broadcast(VectorArray.SPECIES, 0f)
+    private val _ambientAccumulator = Cvec(0)
+    private val _reflectanceAccumulator = Cvec(0)
+    private val _thisTileOpacity = Cvec(0)
+    private val _thisTileOpacity2 = Cvec(0) // thisTileOpacity * sqrt(2)
+    private val _fluidAmountToCol = Cvec(0)
+    private val _thisTileLuminosity = Cvec(0)
     private var _thisTerrainProp: BlockProp = BlockProp()
     private var _thisWallProp: BlockProp = BlockProp()
     private var _thisFluidProp: BlockProp = BlockProp()
@@ -488,24 +485,24 @@ object LightmapRenderer {
         }*/
 
         if (_thisFluid.type != Fluid.NULL) {
-            _fluidAmountToCol = FloatVector.broadcast(VectorArray.SPECIES, _thisFluid.amount)
+            _fluidAmountToCol.set(_thisFluid.amount, _thisFluid.amount, _thisFluid.amount, _thisFluid.amount)
 
-            _thisTileLuminosity = _thisTerrainProp.getLumCol(worldX, worldY)
-            _thisTileLuminosity = _thisTileLuminosity.max(_thisFluidProp.getLumCol(worldX, worldY).mul(_fluidAmountToCol))
+            _thisTileLuminosity.set(_thisTerrainProp.getLumCol(worldX, worldY))
+            _thisTileLuminosity.maxAndAssign(_thisFluidProp.getLumCol(worldX, worldY).mul(_fluidAmountToCol))
             _mapThisTileOpacity.setVec(lx, ly, _thisTerrainProp.opacity)
             _mapThisTileOpacity.max(lx, ly, _thisFluidProp.opacity.mul(_fluidAmountToCol))
         }
         else {
-            _thisTileLuminosity = _thisTerrainProp.getLumCol(worldX, worldY)
+            _thisTileLuminosity.set(_thisTerrainProp.getLumCol(worldX, worldY))
             _mapThisTileOpacity.setVec(lx, ly, _thisTerrainProp.opacity)
         }
 
         // blend shade
-        _mapThisTileOpacity.max(lx, ly, shadowMap[LandUtil.getBlockAddr(world, worldX, worldY)] ?: NULLVEC)
+        _mapThisTileOpacity.max(lx, ly, shadowMap[LandUtil.getBlockAddr(world, worldX, worldY)] ?: colourNull)
 
 //        _mapThisTileOpacity2.setVec(lx, ly, _mapThisTileOpacity.getVec(lx, ly).mul(1.41421356f))
-        //_mapThisTileOpacity.getAndSetMap(_mapThisTileOpacity2, lx, ly) { it * 1.41421356f }
-        _mapThisTileOpacity.setVec(lx, ly, _mapThisTileOpacity.getVec(lx, ly).mul(1.41421356f))
+        _mapThisTileOpacity.getAndSetMap(_mapThisTileOpacity2, lx, ly) { it * 1.41421356f }
+
 
         // open air || luminous tile backed by sunlight
         if ((!_thisTerrainProp.isSolid && !_thisWallProp.isSolid) ||
@@ -517,12 +514,12 @@ object LightmapRenderer {
         }
 
         // blend lantern
-        _mapLightLevelThis.max(lx, ly, _thisTileLuminosity.max(
-                lanternMap[LandUtil.getBlockAddr(world, worldX, worldY)] ?: NULLVEC
+        _mapLightLevelThis.max(lx, ly, _thisTileLuminosity.maxAndAssign(
+                lanternMap[LandUtil.getBlockAddr(world, worldX, worldY)] ?: colourNull
         ))
     }
 
-    private fun precalculate2(lightmap: VectorArray, rawx: Int, rawy: Int) {
+    private fun precalculate2(lightmap: UnsafeCvecArray, rawx: Int, rawy: Int) {
         val lx = rawx.convX(); val ly = rawy.convY()
         val (worldX, worldY) = world.coerceXY(rawx, rawy)
 
@@ -533,16 +530,17 @@ object LightmapRenderer {
 //        }
 
         // blend nearby 4 lights to get intensity
-        _ambientAccumulator = lightmap.getVec(lx - 1, ly)
-                .max(lightmap.getVec(lx + 1, ly))
-                .max(lightmap.getVec(lx, ly - 1))
-                .max(lightmap.getVec(lx, ly + 1))
+        _ambientAccumulator.set(0)
+                .maxAndAssign(lightmap.getVec(lx - 1, ly))
+                .maxAndAssign(lightmap.getVec(lx + 1, ly))
+                .maxAndAssign(lightmap.getVec(lx, ly - 1))
+                .maxAndAssign(lightmap.getVec(lx, ly + 1))
 
         _thisTerrain = world.getTileFromTerrainRaw(worldX, worldY)
         _thisTerrainProp = BlockCodex[world.tileNumberToNameMap[_thisTerrain.toLong()]]
 
-        _reflectanceAccumulator = FloatVector.fromArray(VectorArray.SPECIES, App.tileMaker.terrainTileColourMap[_thisTerrainProp.id]!!.cpy().mul(1f,1f,1f,0f).toFloatArray(), 0)
-//        _reflectanceAccumulator.a = 0f // temporarily disabled
+        _reflectanceAccumulator.set(App.tileMaker.terrainTileColourMap[_thisTerrainProp.id]!!)
+        _reflectanceAccumulator.a = 0f // temporarily disabled
         _reflectanceAccumulator.mul(_thisTerrainProp.reflectance).mul(giScale)
 
         _mapLightLevelThis.max(lx, ly, _reflectanceAccumulator)
@@ -553,25 +551,25 @@ object LightmapRenderer {
     private var swipeY = -1
     private var swipeDiag = false
     private val distFromLightSrc = Ivec4()
-    private fun _swipeTask(x: Int, y: Int, x2: Int, y2: Int, lightmap: VectorArray) {//, distFromLightSrc: Ivec4) {
+    private fun _swipeTask(x: Int, y: Int, x2: Int, y2: Int, lightmap: UnsafeCvecArray) {//, distFromLightSrc: Ivec4) {
         if (x2 < 0 || y2 < 0 || x2 >= LIGHTMAP_WIDTH || y2 >= LIGHTMAP_HEIGHT) return
 
 //        _ambientAccumulator.set(_mapLightLevelThis.getVec(x, y))
-        _ambientAccumulator = _mapLightLevelThis.getVec(x, y)
+        _mapLightLevelThis.getAndSet(_ambientAccumulator, x, y)
 
         if (!swipeDiag) {
-            _thisTileOpacity = _mapThisTileOpacity.getVec(x, y)
-            _ambientAccumulator = _ambientAccumulator.max(darkenColoured(x2, y2, _thisTileOpacity, lightmap))//, distFromLightSrc))
+            _mapThisTileOpacity.getAndSet(_thisTileOpacity, x, y)
+            _ambientAccumulator.maxAndAssign(darkenColoured(x2, y2, _thisTileOpacity, lightmap))//, distFromLightSrc))
         }
         else {
-            _thisTileOpacity2 = _mapThisTileOpacity2.getVec(x, y)
-            _ambientAccumulator = _ambientAccumulator.max(darkenColoured(x2, y2, _thisTileOpacity2, lightmap))//, distFromLightSrc))
+            _mapThisTileOpacity2.getAndSet(_thisTileOpacity2, x, y)
+            _ambientAccumulator.maxAndAssign(darkenColoured(x2, y2, _thisTileOpacity2, lightmap))//, distFromLightSrc))
         }
 
         _mapLightLevelThis.setVec(x, y, _ambientAccumulator)
         lightmap.setVec(x, y, _ambientAccumulator)
     }
-    private fun swipeLight(sx: Int, sy: Int, ex: Int, ey: Int, dx: Int, dy: Int, lightmap: VectorArray) {
+    private fun swipeLight(sx: Int, sy: Int, ex: Int, ey: Int, dx: Int, dy: Int, lightmap: UnsafeCvecArray) {
         swipeX = sx; swipeY = sy
 //        if (App.getConfigBoolean("fx_newlight")) distFromLightSrc.broadcast(0)
         while (swipeX*dx <= ex*dx && swipeY*dy <= ey*dy) {
@@ -689,9 +687,7 @@ object LightmapRenderer {
                     val arrayX = x.convX()
                     val arrayY = y.convY()
 
-                    val arr = FloatArray(4); lightmap.getVec(arrayX, arrayY).intoArray(arr, 0)
-
-                    val (red, grn, blu, uvl) = arr
+                    val (red, grn, blu, uvl) = lightmap.getVec(arrayX, arrayY)
 //                    val redw = (red.sqrt() - 1f) * (7f / 24f)
 //                    val grnw = (grn.sqrt() - 1f)
 //                    val bluw = (blu.sqrt() - 1f) * (7f / 72f)
@@ -747,10 +743,10 @@ object LightmapRenderer {
         _lightBufferAsTex.dispose()
         lightBuffer.dispose()
 
-//        lightmap.destroy()
-//        _mapLightLevelThis.destroy()
-//        _mapThisTileOpacity.destroy()
-//        _mapThisTileOpacity2.destroy()
+        lightmap.destroy()
+        _mapLightLevelThis.destroy()
+        _mapThisTileOpacity.destroy()
+        _mapThisTileOpacity2.destroy()
     }
 
     private const val lightScalingMagic = 2f
@@ -787,11 +783,11 @@ object LightmapRenderer {
      * @param darken (0-255) per channel
      * @return darkened data (0-255) per channel
      */
-    internal fun darkenColoured(x: Int, y: Int, darken: FloatVector, lightmap: VectorArray): FloatVector {//, distFromLightSrc: Ivec4 = Ivec4()): Cvec {
+    internal fun darkenColoured(x: Int, y: Int, darken: Cvec, lightmap: UnsafeCvecArray): Cvec {//, distFromLightSrc: Ivec4 = Ivec4()): Cvec {
         // use equation with magic number 8.0
         // this function, when done recursively (A_x = darken(A_x-1, C)), draws exponential curve. (R^2 = 1)
 
-        if (x !in 0 until LIGHTMAP_WIDTH || y !in 0 until LIGHTMAP_HEIGHT) return NULLVEC
+        if (x !in 0 until LIGHTMAP_WIDTH || y !in 0 until LIGHTMAP_HEIGHT) return colourNull
 
 //        if (App.getConfigBoolean("fx_newlight")) {
 //            val newDarken: Cvec = darken.lanewise { it, ch ->
@@ -803,15 +799,12 @@ object LightmapRenderer {
 //            }
 //        }
 //        else {
-            /*return lightmap.getVec(x, y).lanewise { it, ch ->
+            return lightmap.getVec(x, y).lanewise { it, ch ->
                 it * (1f - darken.lane(ch) * lightScalingMagic)
-            }*/
-        return lightmap.getVec(x, y).mul( vectorOne.sub(darken.mul(lightScalingMagic)) )
+            }
 //        }
     }
 
-    private val vectorOne = FloatVector.broadcast(VectorArray.SPECIES, 1f)
-
     /** infix is removed to clarify the association direction */
     private fun Cvec.maxAndAssign(other: Cvec): Cvec {
         // TODO investigate: if I use assignment instead of set(), it blackens like the vector branch.  --Torvald, 2019-06-07
@@ -871,14 +864,14 @@ object LightmapRenderer {
         lightBuffer = Pixmap(tilesInHorizontal, tilesInVertical, Pixmap.Format.RGBA8888)
 
 
-//        lightmap.destroy()
-//        _mapLightLevelThis.destroy()
-//        _mapThisTileOpacity.destroy()
-//        _mapThisTileOpacity2.destroy()
-        lightmap = VectorArray(LIGHTMAP_WIDTH, LIGHTMAP_HEIGHT)
-        _mapLightLevelThis = VectorArray(LIGHTMAP_WIDTH, LIGHTMAP_HEIGHT)
-        _mapThisTileOpacity = VectorArray(LIGHTMAP_WIDTH, LIGHTMAP_HEIGHT)
-        _mapThisTileOpacity2 = VectorArray(LIGHTMAP_WIDTH, LIGHTMAP_HEIGHT)
+        lightmap.destroy()
+        _mapLightLevelThis.destroy()
+        _mapThisTileOpacity.destroy()
+        _mapThisTileOpacity2.destroy()
+        lightmap = UnsafeCvecArray(LIGHTMAP_WIDTH, LIGHTMAP_HEIGHT)
+        _mapLightLevelThis = UnsafeCvecArray(LIGHTMAP_WIDTH, LIGHTMAP_HEIGHT)
+        _mapThisTileOpacity = UnsafeCvecArray(LIGHTMAP_WIDTH, LIGHTMAP_HEIGHT)
+        _mapThisTileOpacity2 = UnsafeCvecArray(LIGHTMAP_WIDTH, LIGHTMAP_HEIGHT)
 
         printdbg(this, "Resize event")
     }
@@ -894,10 +887,10 @@ object LightmapRenderer {
 
     inline fun Float.hdnorm() = hdr(this.coerceIn(0f, 1f))
 
-    private fun FloatVector.nonZero() = this.lane(0).abs() > epsilon ||
-                                 this.lane(1).abs() > epsilon ||
-                                 this.lane(2).abs() > epsilon ||
-                                 this.lane(3).abs() > epsilon
+    private fun Cvec.nonZero() = this.r.abs() > epsilon ||
+                                 this.g.abs() > epsilon ||
+                                 this.b.abs() > epsilon ||
+                                 this.a.abs() > epsilon
 
     val histogram: Histogram
         get() {
@@ -978,7 +971,6 @@ object LightmapRenderer {
     }
 }
 
-
 fun Cvec.toRGBA() = (255 * r).toInt() shl 24 or ((255 * g).toInt() shl 16) or ((255 * b).toInt() shl 8) or (255 * a).toInt()
 fun Color.toRGBA() = (255 * r).toInt() shl 24 or ((255 * g).toInt() shl 16) or ((255 * b).toInt() shl 8) or (255 * a).toInt()