Upgrade inspector with new capabilities and detached window mode.

src/main/kotlin/gg/essential/elementa/UIComponent.kt

@@ -17,7 +17,6 @@ import gg.essential.elementa.utils.requireMainThread
 import gg.essential.elementa.utils.requireState
 import gg.essential.universal.UMatrixStack
 import gg.essential.universal.UMouse
-import gg.essential.universal.UResolution
 import org.lwjgl.opengl.GL11
 import java.awt.Color
 import java.util.*
@@ -388,8 +387,9 @@ abstract class UIComponent : Observable() {
 
     internal fun pixelCoordinatesToPixelCenter(mouseX: Double, mouseY: Double): Pair<Double, Double> {
         // Move the position of a click to the center of a pixel. See [ElementaVersion.v2] for more info
-        return if ((Window.ofOrNull(this)?.version ?: ElementaVersion.v0) >= ElementaVersion.v2) {
-            val halfPixel = 0.5 / UResolution.scaleFactor
+        val window = Window.ofOrNull(this)
+        return if (window !=null && window.version >= ElementaVersion.v2) {
+            val halfPixel = 0.5 / window.resolutionManager.scaleFactor
             mouseX + halfPixel to mouseY + halfPixel
         } else {
             mouseX to mouseY
@@ -1237,8 +1237,9 @@ abstract class UIComponent : Observable() {
         /**
          * Hints a number with respect to the current GUI scale.
          */
+        @Deprecated("This relies on global states", replaceWith = ReplaceWith("guiHint(number, roundDown, component)"))
         fun guiHint(number: Float, roundDown: Boolean): Float {
-            val factor = UResolution.scaleFactor.toFloat()
+            val factor = Window.resolutionManager.scaleFactor.toFloat()
             return (number * factor).let {
                 if (roundDown) floor(it) else ceil(it)
             } / factor
@@ -1247,13 +1248,35 @@ abstract class UIComponent : Observable() {
         /**
          * Hints a number with respect to the current GUI scale.
          */
+        fun guiHint(number: Float, roundDown: Boolean, component: UIComponent): Float {
+            val factor = component.resolutionManager.scaleFactor.toFloat()
+            return (number * factor).let {
+                if (roundDown) floor(it) else ceil(it)
+            } / factor
+        }
+
+        /**
+         * Hints a number with respect to the current GUI scale.
+         */
+        @Deprecated("This relies on global states", replaceWith = ReplaceWith("guiHint(number, roundDown, component)"))
         fun guiHint(number: Double, roundDown: Boolean): Double {
-            val factor = UResolution.scaleFactor
+            val factor = Window.resolutionManager.scaleFactor
             return (number * factor).let {
                 if (roundDown) floor(it) else ceil(it)
             } / factor
         }
 
+        /**
+         * Hints a number with respect to the current GUI scale.
+         */
+        fun guiHint(number: Double, roundDown: Boolean, component: UIComponent): Double {
+            val factor = component.resolutionManager.scaleFactor
+            return (number * factor).let {
+                if (roundDown) floor(it) else ceil(it)
+            } / factor
+        }
+
+
         internal fun getMouseX(): Float {
             return UMouse.Scaled.x.toFloat()
         }

src/main/kotlin/gg/essential/elementa/VanillaFontRenderer.kt

@@ -22,6 +22,7 @@ class VanillaFontRenderer : FontProvider {
     override fun getStringHeight(string: String, pointSize: Float): Float =
         UGraphics.getFontHeight().toFloat()
 
+    @Suppress("DEPRECATION")
     override fun drawString(
         matrixStack: UMatrixStack,
         string: String,

src/main/kotlin/gg/essential/elementa/components/Window.kt

@@ -8,6 +8,8 @@ import gg.essential.elementa.constraints.resolution.ConstraintResolverV2
 import gg.essential.elementa.effects.ScissorEffect
 import gg.essential.elementa.font.FontRenderer
 import gg.essential.elementa.impl.Platform.Companion.platform
+import gg.essential.elementa.manager.DefaultResolutionManager
+import gg.essential.elementa.manager.ResolutionManager
 import gg.essential.elementa.utils.elementaDev
 import gg.essential.elementa.utils.requireMainThread
 import gg.essential.universal.*
@@ -37,6 +39,11 @@ class Window @JvmOverloads constructor(
 
     internal var clickInterceptor: ((mouseX: Double, mouseY: Double, button: Int) -> Boolean)? = null
 
+    /**
+     *  State managers to avoid global states
+     */
+    internal var resolutionManager: ResolutionManager = DefaultResolutionManager
+
     @Deprecated("Add ElementaVersion as the first argument to opt-in to improved behavior.")
     @JvmOverloads
     constructor(animationFPS: Int = 244) : this(ElementaVersion.v0, animationFPS)
@@ -59,6 +66,7 @@ class Window @JvmOverloads constructor(
     private fun doDraw(matrixStack: UMatrixStack) {
         if (cancelDrawing)
             return
+        currentWindow.set(this)
 
         requireMainThread()
 
@@ -137,6 +145,7 @@ class Window @JvmOverloads constructor(
                 }
             }
         }
+        currentWindow.set(null)
     }
 
     internal fun drawEmbedded(matrixStack: UMatrixStack) {
@@ -269,11 +278,11 @@ class Window @JvmOverloads constructor(
     }
 
     override fun getWidth(): Float {
-        return UResolution.scaledWidth.toFloat()
+        return resolutionManager.scaledWidth.toFloat()
     }
 
     override fun getHeight(): Float {
-        return UResolution.scaledHeight.toFloat()
+        return resolutionManager.scaledHeight.toFloat()
     }
 
     override fun getRight() = getWidth()
@@ -287,12 +296,12 @@ class Window @JvmOverloads constructor(
         ) return false
 
         val currentScissor = ScissorEffect.currentScissorState ?: return true
-        val sf = UResolution.scaleFactor
+        val sf = resolutionManager.scaleFactor
 
         val realX = currentScissor.x / sf
         val realWidth = currentScissor.width / sf
 
-        val bottomY = ((UResolution.scaledHeight * sf) - currentScissor.y) / sf
+        val bottomY = ((resolutionManager.scaledHeight * sf) - currentScissor.y) / sf
         val realHeight = currentScissor.height / sf
 
         return right > realX &&
@@ -368,6 +377,18 @@ class Window @JvmOverloads constructor(
     companion object {
         private val renderOperations = ConcurrentLinkedQueue<() -> Unit>()
 
+        /**
+         * Instance of the Window currently being rendered
+         */
+        internal val currentWindow: ThreadLocal<Window?> = ThreadLocal.withInitial { null }
+
+        /**
+         * Resolution manager of the window currently being rendered or [DefaultResolutionManager]
+         * if one cannot be resolved.
+         */
+        internal val resolutionManager: ResolutionManager
+            get() = currentWindow.get()?.resolutionManager ?: DefaultResolutionManager
+
         fun enqueueRenderOperation(operation: Runnable) {
             renderOperations.add {
                 operation.run()

src/main/kotlin/gg/essential/elementa/constraints/CenterConstraint.kt

@@ -16,19 +16,19 @@ class CenterConstraint : PositionConstraint {
         val parent = constrainTo ?: component.parent
 
         return if (component.isPositionCenter()) {
-            parent.getLeft() + (parent.getWidth() / 2).roundToRealPixels()
+            parent.getLeft() + (parent.getWidth() / 2).roundToRealPixels(component)
         } else {
-            parent.getLeft() + (parent.getWidth() / 2 - component.getWidth() / 2).roundToRealPixels()
+            parent.getLeft() + (parent.getWidth() / 2 - component.getWidth() / 2).roundToRealPixels(component)
         }
     }
 
     override fun getYPositionImpl(component: UIComponent): Float {
         val parent = constrainTo ?: component.parent
 
         return if (component.isPositionCenter()) {
-            parent.getTop() + (parent.getHeight() / 2).roundToRealPixels()
+            parent.getTop() + (parent.getHeight() / 2).roundToRealPixels(component)
         } else {
-            parent.getTop() + (parent.getHeight() / 2 - component.getHeight() / 2).roundToRealPixels()
+            parent.getTop() + (parent.getHeight() / 2 - component.getHeight() / 2).roundToRealPixels(component)
         }
     }
 

src/main/kotlin/gg/essential/elementa/constraints/Constraint.kt

@@ -79,7 +79,7 @@ interface XConstraint : SuperConstraint<Float> {
         }
 
         if (recalculate) {
-            cachedValue = getXPositionImpl(component).roundToRealPixels()
+            cachedValue = getXPositionImpl(component).roundToRealPixels(component)
             recalculate = false
         }
 
@@ -97,7 +97,7 @@ interface YConstraint : SuperConstraint<Float> {
         }
 
         if (recalculate) {
-            cachedValue = getYPositionImpl(component).roundToRealPixels()
+            cachedValue = getYPositionImpl(component).roundToRealPixels(component)
             recalculate = false
         }
 
@@ -135,7 +135,7 @@ interface WidthConstraint : SuperConstraint<Float> {
         }
 
         if (recalculate) {
-            cachedValue = getWidthImpl(component).roundToRealPixels()
+            cachedValue = getWidthImpl(component).roundToRealPixels(component)
             recalculate = false
         }
 
@@ -153,7 +153,7 @@ interface HeightConstraint : SuperConstraint<Float> {
         }
 
         if (recalculate) {
-            cachedValue = getHeightImpl(component).roundToRealPixels()
+            cachedValue = getHeightImpl(component).roundToRealPixels(component)
             recalculate = false
         }
 

src/main/kotlin/gg/essential/elementa/constraints/debug/ConstraintDebugger.kt

@@ -15,10 +15,10 @@ internal interface ConstraintDebugger {
 
     fun invokeImpl(constraint: SuperConstraint<Float>, type: ConstraintType, component: UIComponent): Float =
         when (type) {
-            ConstraintType.X -> (constraint as XConstraint).getXPositionImpl(component).roundToRealPixels()
-            ConstraintType.Y -> (constraint as YConstraint).getYPositionImpl(component).roundToRealPixels()
-            ConstraintType.WIDTH -> (constraint as WidthConstraint).getWidthImpl(component).roundToRealPixels()
-            ConstraintType.HEIGHT -> (constraint as HeightConstraint).getHeightImpl(component).roundToRealPixels()
+            ConstraintType.X -> (constraint as XConstraint).getXPositionImpl(component).roundToRealPixels(component)
+            ConstraintType.Y -> (constraint as YConstraint).getYPositionImpl(component).roundToRealPixels(component)
+            ConstraintType.WIDTH -> (constraint as WidthConstraint).getWidthImpl(component).roundToRealPixels(component)
+            ConstraintType.HEIGHT -> (constraint as HeightConstraint).getHeightImpl(component).roundToRealPixels(component)
             ConstraintType.RADIUS -> (constraint as RadiusConstraint).getRadiusImpl(component)
             else -> throw UnsupportedOperationException()
         }

src/main/kotlin/gg/essential/elementa/effects/ScissorEffect.kt

@@ -1,9 +1,9 @@
 package gg.essential.elementa.effects
 
 import gg.essential.elementa.UIComponent
+import gg.essential.elementa.utils.resolutionManager
 import gg.essential.elementa.utils.roundToRealPixels
 import gg.essential.universal.UMatrixStack
-import gg.essential.universal.UResolution
 import org.lwjgl.opengl.GL11.*
 import kotlin.math.max
 import kotlin.math.min
@@ -22,7 +22,8 @@ class ScissorEffect @JvmOverloads constructor(
     private val scissorIntersection: Boolean = true
 ) : Effect() {
     private var oldState: ScissorState? = null
-    private var scissorBounds: ScissorBounds? = null
+    private var unroundedScissorBounds: ScissorBounds? = null
+    private var roundedScissorBounds: ScissorBounds? = null
 
     /**
      * Create a custom bounding box using precise coordinates.
@@ -35,17 +36,28 @@ class ScissorEffect @JvmOverloads constructor(
         y2: Number,
         scissorIntersection: Boolean = true
     ) : this(scissorIntersection = scissorIntersection) {
-        scissorBounds = ScissorBounds(
-            x1.toFloat().roundToRealPixels(),
-            y1.toFloat().roundToRealPixels(),
-            x2.toFloat().roundToRealPixels(),
-            y2.toFloat().roundToRealPixels(),
+        unroundedScissorBounds = ScissorBounds(
+            x1.toFloat(),
+            y1.toFloat(),
+            x2.toFloat(),
+            y2.toFloat(),
         )
     }
 
     override fun beforeDraw(matrixStack: UMatrixStack) {
-        val bounds = customBoundingBox?.getScissorBounds() ?: scissorBounds ?: boundComponent.getScissorBounds()
-        val scaleFactor = UResolution.scaleFactor.toInt()
+        val unroundedScissorBounds = roundedScissorBounds
+        if (unroundedScissorBounds !=null) {
+            roundedScissorBounds = ScissorBounds(
+                unroundedScissorBounds.x1.roundToRealPixels(boundComponent),
+                unroundedScissorBounds.y1.roundToRealPixels(boundComponent),
+                unroundedScissorBounds.x2.roundToRealPixels(boundComponent),
+                unroundedScissorBounds.y2.roundToRealPixels(boundComponent),
+            )
+            this.unroundedScissorBounds = null
+        }
+        val bounds = customBoundingBox?.getScissorBounds() ?: roundedScissorBounds ?: boundComponent.getScissorBounds()
+        val resolutionManager = boundComponent.resolutionManager
+        val scaleFactor = resolutionManager.scaleFactor.toInt()
 
         if (currentScissorState == null) {
             glEnable(GL_SCISSOR_TEST)
@@ -57,7 +69,7 @@ class ScissorEffect @JvmOverloads constructor(
         // TODO ideally we should respect matrixStack offset and maybe scale, though we do not currently care about
         //      global gl state either, so not really important until someone needs it
         var x = (bounds.x1 * scaleFactor).roundToInt()
-        var y = UResolution.viewportHeight - (bounds.y2 * scaleFactor).roundToInt()
+        var y = resolutionManager.viewportHeight - (bounds.y2 * scaleFactor).roundToInt()
         var width = (bounds.width * scaleFactor).roundToInt()
         var height = (bounds.height * scaleFactor).roundToInt()
 
@@ -96,10 +108,10 @@ class ScissorEffect @JvmOverloads constructor(
     }
 
     private fun UIComponent.getScissorBounds(): ScissorBounds = ScissorBounds(
-        getLeft().roundToRealPixels(),
-        getTop().roundToRealPixels(),
-        getRight().roundToRealPixels(),
-        getBottom().roundToRealPixels(),
+        getLeft().roundToRealPixels(this),
+        getTop().roundToRealPixels(this),
+        getRight().roundToRealPixels(this),
+        getBottom().roundToRealPixels(this),
     )
 
     data class ScissorState(val x: Int, val y: Int, val width: Int, val height: Int)

src/main/kotlin/gg/essential/elementa/font/FontRenderer.kt

@@ -1,14 +1,14 @@
 package gg.essential.elementa.font
 
 import gg.essential.elementa.UIComponent
+import gg.essential.elementa.components.Window
 import gg.essential.elementa.constraints.ConstraintType
 import gg.essential.elementa.constraints.resolution.ConstraintVisitor
 import gg.essential.elementa.font.data.Font
 import gg.essential.elementa.font.data.Glyph
 import gg.essential.elementa.utils.readFromLegacyShader
 import gg.essential.universal.UGraphics
 import gg.essential.universal.UMatrixStack
-import gg.essential.universal.UResolution
 import gg.essential.universal.shader.BlendState
 import gg.essential.universal.shader.Float2Uniform
 import gg.essential.universal.shader.Float4Uniform
@@ -194,7 +194,7 @@ class FontRenderer(
         doffsetUniform.setValue(3.5f / currentPointSize)
 
 
-        val guiScale = UResolution.scaleFactor.toFloat()
+        val guiScale = Window.resolutionManager.scaleFactor.toFloat()
 
         //Reset
         obfuscated = false

src/main/kotlin/gg/essential/elementa/manager/DefaultResolutionManager.kt

@@ -0,0 +1,30 @@
+package gg.essential.elementa.manager
+
+import gg.essential.universal.UResolution
+
+/**
+ * A resolution manager that provides its values from [UResolution].
+ */
+internal object DefaultResolutionManager : ResolutionManager {
+
+    override val windowWidth: Int
+        get() = UResolution.windowWidth
+
+    override val windowHeight: Int
+        get() = UResolution.windowHeight
+
+    override val viewportWidth: Int
+        get() = UResolution.viewportWidth
+
+    override val viewportHeight: Int
+        get() = UResolution.viewportHeight
+
+    override val scaledWidth: Int
+        get() = UResolution.scaledWidth
+
+    override val scaledHeight: Int
+        get() = UResolution.scaledHeight
+
+    override val scaleFactor: Double
+        get() = UResolution.scaleFactor
+}

src/main/kotlin/gg/essential/elementa/manager/ResolutionManager.kt

@@ -0,0 +1,22 @@
+package gg.essential.elementa.manager
+
+
+/**
+ * Provides a non-global way to access different aspects about the current resolution
+ */
+internal interface ResolutionManager {
+
+    val windowWidth: Int
+
+    val windowHeight: Int
+
+    val viewportWidth: Int
+
+    val viewportHeight: Int
+
+    val scaledWidth: Int
+
+    val scaledHeight: Int
+
+    val scaleFactor: Double
+}