merge upstream

leenkx/Sources/leenkx/logicnode/MouseLookNode.hx

@@ -0,0 +1,232 @@
+package leenkx.logicnode;
+
+import iron.math.Vec4;
+import iron.system.Input;
+import iron.object.Object;
+import kha.System;
+import kha.FastFloat;
+
+class MouseLookNode extends LogicNode {
+	// Note: This implementation works in degrees internally and converts to radians only when applying rotations
+	// Sub-pixel interpolation is always enabled for optimal precision
+	// Features: Resolution-adaptive scaling and precise low-sensitivity support
+
+	public var property0: String; // Front axis
+	public var property1: Bool; // Center Mouse
+	public var property2: Bool; // Invert X
+	public var property3: Bool; // Invert Y  
+	public var property4: Bool; // Cap Left/Right
+	public var property5: Bool; // Cap Up/Down
+	
+	// New strategy toggles
+	public var property6: Bool; // Resolution-Adaptive Scaling
+
+	// Smoothing variables
+	var smoothX: FastFloat = 0.0;
+	var smoothY: FastFloat = 0.0;
+	
+	// Capping limits (in degrees)
+	var maxHorizontal: FastFloat = 180.0; // 180 degrees
+	var maxVertical: FastFloat = 90.0; // 90 degrees
+	
+	// Current accumulated rotations for capping
+	var currentHorizontal: FastFloat = 0.0;
+	var currentVertical: FastFloat = 0.0;
+	
+	// Sub-pixel interpolation accumulators
+	var accumulatedHorizontalRotation: FastFloat = 0.0;
+	var accumulatedVerticalRotation: FastFloat = 0.0;
+	var minimumRotationThreshold: FastFloat = 0.01; // degrees (was 0.0001 radians)
+	
+	// Frame rate independence removed - not applicable to mouse input
+	
+	// Resolution adaptive scaling
+	var baseResolutionWidth: FastFloat = 1920.0;
+	var baseResolutionHeight: FastFloat = 1080.0;
+	
+
+
+	public function new(tree: LogicTree) {
+		super(tree);
+	}
+
+	override function run(from: Int) {
+		var bodyObject: Object = inputs[1].get();
+		var headObject: Object = inputs[2].get();
+		var sensitivity: FastFloat = inputs[3].get();
+		var smoothing: FastFloat = inputs[4].get();
+
+		if (bodyObject == null) {
+			runOutput(0);
+			return;
+		}
+
+		var mouse = Input.getMouse();
+		
+		// Handle mouse centering/locking
+		if (property1) {
+			if (mouse.started() && !mouse.locked) {
+				mouse.lock();
+			}
+		}
+
+		// Only process if mouse is active
+		if (!mouse.locked && !mouse.down()) {
+			runOutput(0);
+			return;
+		}
+
+		// Get mouse movement deltas
+		var deltaX: FastFloat = mouse.movementX;
+		var deltaY: FastFloat = mouse.movementY;
+
+		// Note: Sensitivity will be applied later to preserve precision for small movements
+
+		// Apply inversion
+		if (property2) deltaX = -deltaX;
+		if (property3) deltaY = -deltaY;
+
+		// Strategy 1: Resolution-Adaptive Scaling
+		var resolutionMultiplier: FastFloat = 1.0;
+		if (property6) {
+			var currentWidth = System.windowWidth();
+			var currentHeight = System.windowHeight();
+			resolutionMultiplier = (currentWidth / baseResolutionWidth) * (currentHeight / baseResolutionHeight);
+			resolutionMultiplier = Math.sqrt(resolutionMultiplier); // Take square root to avoid over-scaling
+		}
+
+		// Frame Rate Independence disabled for mouse input - mouse deltas are inherently frame-rate independent
+
+		// Apply smoothing
+		if (smoothing > 0.0) {
+			var smoothFactor = 1.0 - Math.min(smoothing, 0.99); // Prevent complete smoothing
+			smoothX = smoothX * smoothing + deltaX * smoothFactor;
+			smoothY = smoothY * smoothing + deltaY * smoothFactor;
+			deltaX = smoothX;
+			deltaY = smoothY;
+		}
+
+		// Determine rotation axes based on front axis setting
+		var horizontalAxis = new Vec4();
+		var verticalAxis = new Vec4();
+		
+		switch (property0) {
+			case "X": // X is front
+				horizontalAxis.set(0, 0, 1); // Z axis for horizontal (yaw)
+				verticalAxis.set(0, 1, 0);   // Y axis for vertical (pitch)
+			case "Y": // Y is front (default)
+				#if lnx_yaxisup
+				horizontalAxis.set(0, 0, 1); // Z axis for horizontal (yaw)
+				verticalAxis.set(1, 0, 0);   // X axis for vertical (pitch)
+				#else
+				horizontalAxis.set(0, 0, 1); // Z axis for horizontal (yaw)  
+				verticalAxis.set(1, 0, 0);   // X axis for vertical (pitch)
+				#end
+			case "Z": // Z is front
+				horizontalAxis.set(0, 1, 0); // Y axis for horizontal (yaw)
+				verticalAxis.set(1, 0, 0);   // X axis for vertical (pitch)
+		}
+
+		// Base scaling
+		var baseScale: FastFloat = 1500.0;
+		var finalScale = baseScale;
+
+		// Apply resolution scaling
+		if (property6) {
+			finalScale *= resolutionMultiplier;
+		}
+
+
+
+		// Apply sensitivity scaling after all enhancement strategies to preserve precision
+		deltaX *= sensitivity;
+		deltaY *= sensitivity;
+
+		// Calculate rotation amounts (in degrees)
+		var horizontalRotation: FastFloat = (-deltaX / finalScale) * 180.0 / Math.PI;
+		var verticalRotation: FastFloat = (-deltaY / finalScale) * 180.0 / Math.PI;
+
+		// Note: Frame rate independence removed for mouse input as mouse deltas
+		// are already frame-rate independent by nature. Mouse input represents
+		// instantaneous user intent, not time-based movement.
+
+		// Strategy 2: Sub-Pixel Interpolation (always enabled)
+		accumulatedHorizontalRotation += horizontalRotation;
+		accumulatedVerticalRotation += verticalRotation;
+		
+		// Only apply rotation if accumulated amount exceeds threshold
+		if (Math.abs(accumulatedHorizontalRotation) >= minimumRotationThreshold) {
+			horizontalRotation = accumulatedHorizontalRotation;
+			accumulatedHorizontalRotation = 0.0;
+		} else {
+			horizontalRotation = 0.0;
+		}
+		
+		if (Math.abs(accumulatedVerticalRotation) >= minimumRotationThreshold) {
+			verticalRotation = accumulatedVerticalRotation;
+			accumulatedVerticalRotation = 0.0;
+		} else {
+			verticalRotation = 0.0;
+		}
+
+		// Apply capping constraints
+		if (property4) { // Cap Left/Right
+			currentHorizontal += horizontalRotation;
+			if (currentHorizontal > maxHorizontal) {
+				horizontalRotation -= (currentHorizontal - maxHorizontal);
+				currentHorizontal = maxHorizontal;
+			} else if (currentHorizontal < -maxHorizontal) {
+				horizontalRotation -= (currentHorizontal + maxHorizontal);
+				currentHorizontal = -maxHorizontal;
+			}
+		}
+
+		if (property5) { // Cap Up/Down
+			currentVertical += verticalRotation;
+			if (currentVertical > maxVertical) {
+				verticalRotation -= (currentVertical - maxVertical);
+				currentVertical = maxVertical;
+			} else if (currentVertical < -maxVertical) {
+				verticalRotation -= (currentVertical + maxVertical);
+				currentVertical = -maxVertical;
+			}
+		}
+
+		// Apply horizontal rotation to body (yaw)
+		if (Math.abs(horizontalRotation) > 0.01) { // 0.01 degrees threshold
+			bodyObject.transform.rotate(horizontalAxis, horizontalRotation * Math.PI / 180.0); // Convert degrees to radians
+			
+			// Sync physics if needed
+			#if lnx_physics
+			var rigidBody = bodyObject.getTrait(leenkx.trait.physics.RigidBody);
+			if (rigidBody != null) rigidBody.syncTransform();
+			#end
+		}
+
+		// Apply vertical rotation to head (pitch) if head object is provided
+		if (headObject != null && Math.abs(verticalRotation) > 0.01) { // 0.01 degrees threshold
+			// For head rotation, use the head's local coordinate system
+			var headVerticalAxis = headObject.transform.world.right();
+			headObject.transform.rotate(headVerticalAxis, verticalRotation * Math.PI / 180.0); // Convert degrees to radians
+			
+			// Sync physics if needed
+			#if lnx_physics
+			var headRigidBody = headObject.getTrait(leenkx.trait.physics.RigidBody);
+			if (headRigidBody != null) headRigidBody.syncTransform();
+			#end
+		} else if (headObject == null) {
+			// If no head object, apply vertical rotation to body as well
+			if (Math.abs(verticalRotation) > 0.01) { // 0.01 degrees threshold
+				bodyObject.transform.rotate(verticalAxis, verticalRotation * Math.PI / 180.0); // Convert degrees to radians
+				
+				// Sync physics if needed
+				#if lnx_physics
+				var rigidBody = bodyObject.getTrait(leenkx.trait.physics.RigidBody);
+				if (rigidBody != null) rigidBody.syncTransform();
+				#end
+			}
+		}
+
+		runOutput(0);
+	}
+} 

leenkx/Sources/leenkx/logicnode/SetLightShadowNode.hx

@@ -0,0 +1,21 @@
+package leenkx.logicnode;
+
+import iron.object.LightObject;
+
+class SetLightShadowNode extends LogicNode {
+
+	public function new(tree: LogicTree) {
+		super(tree);
+	}
+
+	override function run(from: Int) {
+		var light: LightObject = inputs[1].get();
+		var shadow: Bool = inputs[2].get();
+
+		if (light == null) return;
+
+		light.data.raw.cast_shadow = shadow;
+
+		runOutput(0);
+	}
+}

leenkx/Sources/leenkx/logicnode/SetLookAtRotationNode.hx

@@ -12,6 +12,7 @@ class SetLookAtRotationNode extends LogicNode {
 	public var property2: String; // Use vector for source (true/false)
 	public var property3: String; // Damping value (backward compatibility, now input socket)
 	public var property4: String; // Disable rotation on aligning axis (true/false)
+	public var property5: String; // Use local space (true/false)
 	
 	// Store the calculated rotation for output
 	var calculatedRotation: Quat = null;
@@ -51,8 +52,8 @@ class SetLookAtRotationNode extends LogicNode {
 				return;
 			}
 
-			// Get source object's position
-			objectLoc = objectToUse.transform.loc;
+			// Get source object's WORLD position (important for child objects)
+			objectLoc = new Vec4(objectToUse.transform.worldx(), objectToUse.transform.worldy(), objectToUse.transform.worldz());
 		}
 
 		// Determine if we're using a vector or an object as target
@@ -74,8 +75,8 @@ class SetLookAtRotationNode extends LogicNode {
 				return;
 			}
 			
-			// Get target object's position
-			targetLoc = targetObject.transform.loc;
+			// Get target object's WORLD position (important for child objects)
+			targetLoc = new Vec4(targetObject.transform.worldx(), targetObject.transform.worldy(), targetObject.transform.worldz());
 		}
 		
 		// Calculate direction to target
@@ -122,6 +123,28 @@ class SetLookAtRotationNode extends LogicNode {
 			calculatedRotation.fromEulerOrdered(eulerAngles, "XYZ");
 		}
 		
+		// Convert world rotation to local rotation if local space is enabled and object has a parent
+		var targetRotation = new Quat();
+		if (property5 == "true" && objectToUse.parent != null) {
+			// Get parent's world rotation
+			var parentWorldLoc = new Vec4();
+			var parentWorldRot = new Quat();
+			var parentWorldScale = new Vec4();
+			objectToUse.parent.transform.world.decompose(parentWorldLoc, parentWorldRot, parentWorldScale);
+			
+			// Convert world rotation to local space by removing parent's rotation influence
+			// local_rotation = inverse(parent_world_rotation) * world_rotation
+			var invParentRot = new Quat().setFrom(parentWorldRot);
+			invParentRot.x = -invParentRot.x;
+			invParentRot.y = -invParentRot.y;
+			invParentRot.z = -invParentRot.z;
+			
+			targetRotation.multquats(invParentRot, calculatedRotation);
+		} else {
+			// No local space conversion needed, use world rotation directly
+			targetRotation.setFrom(calculatedRotation);
+		}
+		
 		// Apply rotation with damping
 		var dampingValue: Float = 0.0;
 		
@@ -141,17 +164,17 @@ class SetLookAtRotationNode extends LogicNode {
 			// Higher damping = slower rotation (smaller step)
 			var step = Math.max(0.001, (1.0 - dampingValue) * 0.2); // 0.001 to 0.2 range
 			
-			// Get current rotation as quaternion
-			var currentRot = new Quat().setFrom(objectToUse.transform.rot);
+			// Get current local rotation as quaternion
+			var currentLocalRot = new Quat().setFrom(objectToUse.transform.rot);
 			
 			// Calculate the difference between current and target rotation
 			var diffQuat = new Quat();
 			// q1 * inverse(q2) gives the rotation from q2 to q1
-			var invCurrent = new Quat().setFrom(currentRot);
+			var invCurrent = new Quat().setFrom(currentLocalRot);
 			invCurrent.x = -invCurrent.x;
 			invCurrent.y = -invCurrent.y;
 			invCurrent.z = -invCurrent.z;
-			diffQuat.multquats(calculatedRotation, invCurrent);
+			diffQuat.multquats(targetRotation, invCurrent);
 			
 			// Convert to axis-angle representation
 			var axis = new Vec4();
@@ -163,15 +186,15 @@ class SetLookAtRotationNode extends LogicNode {
 			// Create partial rotation quaternion
 			var partialRot = new Quat().fromAxisAngle(axis, partialAngle);
 			
-			// Apply this partial rotation to current
-			var newRot = new Quat();
-			newRot.multquats(partialRot, currentRot);
+			// Apply this partial rotation to current local rotation
+			var newLocalRot = new Quat();
+			newLocalRot.multquats(partialRot, currentLocalRot);
 			
-			// Apply the new rotation
-			objectToUse.transform.rot.setFrom(newRot);
+			// Apply the new local rotation
+			objectToUse.transform.rot.setFrom(newLocalRot);
 		} else {
 			// No damping, apply instant rotation
-			objectToUse.transform.rot.setFrom(calculatedRotation);
+			objectToUse.transform.rot.setFrom(targetRotation);
 		}
 		
 		objectToUse.transform.buildMatrix();
@@ -179,12 +202,5 @@ class SetLookAtRotationNode extends LogicNode {
 		runOutput(0);
 	}
 
-	// Getter method for output sockets
-	override function get(from: Int): Dynamic {
-		// Output index 1 is the rotation socket (global rotation)
-		if (from == 1) {
-			return calculatedRotation;
-		}
-		return null;
-	}
+	// No output sockets needed - this node only performs actions
 }

leenkx/Sources/leenkx/trait/internal/DebugConsole.hx

@@ -280,7 +280,11 @@ class DebugConsole extends Trait {
 
 					function drawObjectNameInList(object: iron.object.Object, selected: Bool) {
 						var _y = ui._y;
-						ui.text(object.uid+'_'+object.name);
+
+						if (object.parent.name == 'Root')
+							ui.text(object.uid+'_'+object.name+' ('+iron.Scene.active.raw.world_ref+')');
+						else
+							ui.text(object.uid+'_'+object.name);
 
 						if (object == iron.Scene.active.camera) {
 							var tagWidth = 100;