Update Files

lib/leenkx2d/Sources/lnx2d/tools/Math.hx

@@ -0,0 +1,94 @@
+package lnx2d.tools;
+
+// Kha
+import kha.math.Vector2;
+
+// Zui
+import zui.Zui;
+import leenkx.ui.Canvas.TCanvas;
+import leenkx.ui.Canvas.TElement;
+
+class Math {
+
+    public static inline function toDegrees(radians:Float):Float { return radians * 57.29578; }
+	public static inline function toRadians(degrees:Float):Float { return degrees * 0.0174532924; }
+
+	/**
+	 * Calculates if the mouse is in the given hitbox rectangle.
+	 *
+	 * @param ui The Zui object of which this function should take the mouse position
+	 * @param x The x position of the hitbox
+	 * @param y The y position of the hitbox
+	 * @param w The width of the hitbox
+	 * @param h The height of the hitbox
+	 * @param rotation The rotation of the hitbox in radians, default = 0.0
+	 * @param center (Optional) The [x, y] coordinates of the center of rotation. If not given or null, use the center of the rectangle given by (x, y, w, h)
+	 * @return Bool
+	 */
+    public static function hitbox(ui: Zui, x: Float, y: Float, w: Float, h: Float, rotation: Float = 0.0, ?center: Array<Float>):Bool {
+		if (center != null && center.length != 2) {
+			throw "lnx2d.tools.Math.hitbox(): 'center' argument must consist of two values!";
+		}
+
+		if (center == null) center = [x + w / 2, y + h / 2];
+
+		var rotatedInput:Vector2 = rotatePoint(ui.inputX, ui.inputY, center[0], center[1], -rotation);
+		return rotatedInput.x > x && rotatedInput.x < x + w && rotatedInput.y > y && rotatedInput.y < y + h;
+	}
+
+    public static function absx(canvas:TCanvas, e:TElement):Float {
+		if (e == null) return 0;
+		return e.x + absx(canvas, CanvasTools.elemById(canvas, e.parent));
+	}
+
+	public static function absy(canvas:TCanvas, e:TElement):Float {
+		if (e == null) return 0;
+		return e.y + absy(canvas, CanvasTools.elemById(canvas, e.parent));
+	}
+
+	public static function roundPrecision(v:Float, ?precision=0):Float {
+		v *= std.Math.pow(10, precision);
+
+		v = Std.int(v) * 1.0;
+		v /= std.Math.pow(10, precision);
+
+		return v;
+	}
+
+	public static function rotatePoint(pointX: Float, pointY: Float, centerX: Float, centerY: Float, angle:Float): Vector2 {
+		pointX -= centerX;
+		pointY -= centerY;
+
+		var x = pointX * std.Math.cos(angle) - pointY * std.Math.sin(angle);
+		var y = pointX * std.Math.sin(angle) + pointY * std.Math.cos(angle);
+
+		return new Vector2(centerX + x, centerY + y);
+	}
+
+	public static function calculateTransformDelta(ui:Zui, gSP:Bool, gUR:Bool, gS:Int, value:Float, ?offset=0.0):Float {
+		var precisionMode = ui.isKeyDown && ui.key == Main.prefs.keyMap.slowMovement;
+		var enabled = gSP != (ui.isKeyDown && (ui.key == Main.prefs.keyMap.gridInvert));
+		var useOffset = gUR != (ui.isKeyDown && (ui.key == Main.prefs.keyMap.gridInvertRelative));
+
+		if (!enabled) return precisionMode ? value / 2 : value;
+
+		// Round the delta value to steps of gridSize
+		value = std.Math.round(value / gS) * gS;
+
+		if (precisionMode) value /= 2;
+
+		// Apply an offset
+		if (useOffset && offset != 0) {
+			offset = offset % gS;
+
+			// Round to nearest grid position instead of rounding off
+			if (offset > gS / 2) {
+				offset = -(gS - offset);
+			}
+
+			value -= offset;
+		}
+		return value;
+	}
+
+}