Enhance PathRenderer for adaptive divisions, improve dialogue handling, and refine UI interactions

- Added adaptive divisions calculation in PathRenderer for better path rendering quality.
- Updated DialogueBox to handle null or empty dialogue lists gracefully.
- Improved Limo and School stages to ensure proper layering and dialogue initialization.
- Enhanced PauseSubState with dynamic difficulty loading based on available charts.
- Refined ResetScoreSubState dialog messages for clarity.
- Adjusted LoadingState to handle null current file gracefully.
- Improved MenuCharacter to reload character only when necessary.
- Updated MaterialDialog button focus behavior for better UX.
- Enhanced MaterialNumericStepper with pointer detection for mobile.
- Added touch-zone hitboxes in FreeplayState for improved gesture handling.
- Updated NoteOffsetState to support touch input alongside mouse and gamepad.
- Enhanced StoryMenuState to filter story difficulties based on week data.
- Refined WindowMode to manage window sizing and positioning more effectively.

Author: Lenin

source/funkin/modding/modchart/backend/graphics/CtxRenderer.hx

@@ -18,6 +18,12 @@ import openfl.display.BlendMode;
 using funkin.modding.modchart.backend.util.SortUtil;
 
 class CtxRenderer {
+	/**
+	 * Global quality multiplier consumed by PathRenderer.
+	 * 1.0 = full quality, lower values reduce path divisions to protect FPS.
+	 */
+	public static var pathQualityScale:Float = 1.0;
+
 	var ctx:Context;
 
 	public function new() {}
@@ -89,11 +95,15 @@ class CtxRenderer {
 		if (avgFps < 45 && cur > 2) {
 			__targetSubdivisions = cur; // save before lowering
 			Adapter.instance.setHoldSubdivisions(2);
+			pathQualityScale = 0.65;
+		} else if (avgFps < 50) {
+			pathQualityScale = 0.8;
 		} else if (avgFps >= 55) {
 			if (cur == 2 && __targetSubdivisions > 2)
 				Adapter.instance.setHoldSubdivisions(__targetSubdivisions);
 			else
 				__targetSubdivisions = cur; // keep in sync with Lua overrides
+			pathQualityScale = 1.0;
 		}
 	}
 
@@ -161,6 +171,8 @@ class CtxRenderer {
 				if (pathCount > 0) {
 					// iterate through receptors, yes
 					for (receptor in curItems[0]) {
+						if (!getVisibility(receptor))
+							continue;
 						var _ = emitPathCmd(receptor);
 						if (_ != null)
 							this.append(_);

source/funkin/modding/modchart/backend/graphics/renderers/ArrowRenderer.hx

@@ -1,5 +1,7 @@
 package funkin.modding.modchart.backend.graphics.renderers;
 
+import flixel.math.FlxMath;
+
 using flixel.util.FlxColorTransformUtil;
 
 final matrix:Matrix = new Matrix();
@@ -119,11 +121,18 @@ final class ArrowRenderer extends BaseRenderer<FlxSprite> {
 		final projectionZ = _projZ;
 
 		var vertPointer = 0;
+		final distAbs = Math.abs(arrowData.distance);
+		// Very soft far-distance compensation to keep angles close to target value
+		// while still avoiding extreme over-tilt on very distant notes.
+		final farRatio = FlxMath.bound((distAbs - 600.0) / 2600.0, 0, 1);
+		final perspectiveDamp = 1.0 - (farRatio * 0.15);
+		final visualAngleX = output.visuals.angleX * perspectiveDamp;
+		final visualAngleY = output.visuals.angleY * perspectiveDamp;
 		@:privateAccess do {
 			rotationVector.setTo(planeVertices[vertPointer], planeVertices[vertPointer + 1], 0);
 
 			// The result of the vert rotation
-			var rotation = ModchartUtil.rotate3DVector(rotationVector, output.visuals.angleX, output.visuals.angleY,
+			var rotation = ModchartUtil.rotate3DVector(rotationVector, visualAngleX, visualAngleY,
 				ModchartUtil.getFrameAngle(arrow) + output.visuals.angleZ + arrow.angle);
 
 			// apply skewness

source/funkin/modding/modchart/backend/graphics/renderers/HoldRenderer.hx

@@ -1,5 +1,7 @@
 package funkin.modding.modchart.backend.graphics.renderers;
 
+import haxe.ds.ObjectMap;
+
 using flixel.util.FlxColorTransformUtil;
 
 typedef HoldSegmentOutput = {
@@ -41,6 +43,35 @@ final class HoldRenderer extends BaseRenderer<FlxSprite> {
 	var _uvtCacheVals:Array<openfl.Vector<Float>> = [];
 	var _uvtCacheSubs:Int = -1;
 
+	// Per-hold pools to avoid per-frame allocations of geometry/color buffers.
+	var _holdVerticesPool:ObjectMap<FlxSprite, openfl.Vector<Float>> = new ObjectMap<FlxSprite, openfl.Vector<Float>>();
+	var _holdColorsPool:ObjectMap<FlxSprite, NativeVector<ColorTransform>> = new ObjectMap<FlxSprite, NativeVector<ColorTransform>>();
+	var _holdPoolSubs:ObjectMap<FlxSprite, Int> = new ObjectMap<FlxSprite, Int>();
+
+	inline private function _getPooledVertices(item:FlxSprite, subs:Int):openfl.Vector<Float> {
+		final oldSubs = _holdPoolSubs.get(item);
+		var verts = _holdVerticesPool.get(item);
+		if (verts == null || oldSubs == null || oldSubs != subs || verts.length != subs * 8) {
+			verts = new openfl.Vector<Float>(subs * 8, true);
+			_holdVerticesPool.set(item, verts);
+			_holdPoolSubs.set(item, subs);
+		}
+		return verts;
+	}
+
+	inline private function _getPooledColors(item:FlxSprite, subs:Int):NativeVector<ColorTransform> {
+		final oldSubs = _holdPoolSubs.get(item);
+		var cols = _holdColorsPool.get(item);
+		if (cols == null || oldSubs == null || oldSubs != subs || cols.length != subs) {
+			cols = new NativeVector<ColorTransform>(subs);
+			for (i in 0...subs)
+				cols[i] = new ColorTransform();
+			_holdColorsPool.set(item, cols);
+			_holdPoolSubs.set(item, subs);
+		}
+		return cols;
+	}
+
 	inline private function _getCachedUVT(item:FlxSprite, subs:Int):openfl.Vector<Float> {
 		if (subs != _uvtCacheSubs) {
 			// Subdivision count changed (settings) — invalidate entire cache
@@ -115,7 +146,7 @@ final class HoldRenderer extends BaseRenderer<FlxSprite> {
 
 		final size = hold.frame.frame.width * hold.scale.x * .5;
 
-		var origin:ModifierOutput = parent.modifiers.getPath(basePos.clone(), params);
+		var origin:ModifierOutput = parent.modifiers.getPath(copyVec3(basePos, _pathInputA), params);
 		var curPoint = new Vector3(origin.pos.x, origin.pos.y, 0);
 		final depth = (origin.pos.z - 1) * 1000;
 		final worldX = origin.rawX;
@@ -128,7 +159,7 @@ final class HoldRenderer extends BaseRenderer<FlxSprite> {
 		if (Config.OPTIMIZE_HOLDS) {
 			unit = __holdUnitUp; // reuse static up-vector, no allocation
 		} else {
-			var next = parent.modifiers.getPath(basePos.clone(), params, 1, false, true);
+			var next = parent.modifiers.getPath(copyVec3(basePos, _pathInputB), params, 1, false, true);
 			next.pos.z = 0;
 
 			// normalized points difference (from 0-1)
@@ -224,6 +255,24 @@ final class HoldRenderer extends BaseRenderer<FlxSprite> {
 	final _holdArrowBuf:ArrowData = {hitTime: 0, distance: 0, sourceTime: 0, lane: 0, player: 0, hitten: false, isTapArrow: false, straightHolds: false};
 	/** Pre-allocated ArrowData buffer for parentData (rotate path) to avoid per-hold heap allocation. */
 	final _parentDataBuf:ArrowData = {hitTime: 0, distance: 0, sourceTime: 0, lane: 0, player: 0, hitten: false, isTapArrow: false, straightHolds: false};
+	/** Reused path input vectors to avoid allocating basePos.clone() for every getPath call. */
+	final _pathInputA:Vector3 = new Vector3();
+	final _pathInputB:Vector3 = new Vector3();
+
+	// Cached hold metadata used by getArrowParams() in the subdivision loop.
+	var __cachedHoldPlayer:Int = 0;
+	var __cachedHoldLane:Int = 0;
+	var __cachedHoldHitTime:Float = 0;
+	var __cachedHoldParentTime:Float = 0;
+	var __cachedHoldHitten:Bool = false;
+	var __cachedSongPos:Float = 0;
+
+	inline private function copyVec3(from:Vector3, into:Vector3):Vector3 {
+		into.x = from.x;
+		into.y = from.y;
+		into.z = from.z;
+		return into;
+	}
 
 	override public function prepare(item:FlxSprite):Null<DrawCommand> {
 		if (item == null || item.graphic == null || item.frame == null) {
@@ -245,14 +294,25 @@ final class HoldRenderer extends BaseRenderer<FlxSprite> {
 
 		final player = Adapter.instance.getPlayerFromArrow(item);
 		final lane = Adapter.instance.getLaneFromArrow(item);
+		final hitten = Adapter.instance.arrowHit(item);
+		final holdHitTime = Adapter.instance.getTimeFromArrow(item);
+		final holdParentTime = Adapter.instance.getHoldParentTime(item);
+		final songPosNow = Adapter.instance.getSongPosition();
+
+		__cachedHoldPlayer = player;
+		__cachedHoldLane = lane;
+		__cachedHoldHitTime = holdHitTime;
+		__cachedHoldParentTime = holdParentTime;
+		__cachedHoldHitten = hitten;
+		__cachedSongPos = songPosNow;
 
 		basePos = ModchartUtil.getHalfPos();
 		basePos.x += Adapter.instance.getDefaultReceptorX(lane, player);
 		basePos.y += Adapter.instance.getDefaultReceptorY(lane, player);
 
-		// build directly as openfl.Vector to avoid conversion at render time
-		var vertices = new openfl.Vector<Float>(8 * HOLD_SUBDIVISIONS, true);
-		var transfTotal = new NativeVector<ColorTransform>(HOLD_SUBDIVISIONS);
+		// Reuse per-hold buffers to avoid per-frame heap churn.
+		var vertices = _getPooledVertices(item, HOLD_SUBDIVISIONS);
+		var transfTotal = _getPooledColors(item, HOLD_SUBDIVISIONS);
 		var tID = 0;
 
 		var lastData:ArrowData = null;
@@ -272,19 +332,19 @@ final class HoldRenderer extends BaseRenderer<FlxSprite> {
 		__rotateY = canUseLast ? __lastRY : (__lastRY = parent.getPercent('holdRotateY', player));
 		__rotateZ = canUseLast ? __lastRZ : (__lastRZ = parent.getPercent('holdRotateZ', player));
 
-		var parentTime = Adapter.instance.getHoldParentTime(item);
+		var parentTime = holdParentTime;
 		_parentDataBuf.hitTime = parentTime;
 		// this fixed the clipping gaps
-		_parentDataBuf.distance = Math.max(0, parentTime - Adapter.instance.getSongPosition());
+		_parentDataBuf.distance = Math.max(0, parentTime - songPosNow);
 		_parentDataBuf.sourceTime = parentTime;
 		_parentDataBuf.lane = lane;
 		_parentDataBuf.player = player;
-		_parentDataBuf.hitten = Adapter.instance.arrowHit(item);
+		_parentDataBuf.hitten = hitten;
 		_parentDataBuf.isTapArrow = true;
 		_parentDataBuf.straightHolds = __straightHolds > 0;
 		final parentData = _parentDataBuf;
 		if (__rotateX != 0 || __rotateY != 0 || __rotateZ != 0) {
-			__parentOutput = parent.modifiers.getPath(basePos.clone(), parentData);
+			__parentOutput = parent.modifiers.getPath(copyVec3(basePos, _pathInputA), parentData);
 		}
 
 		var vertPointer = 0;
@@ -345,10 +405,19 @@ final class HoldRenderer extends BaseRenderer<FlxSprite> {
 			final negGlow = 1 - out1.visuals.glow;
 			final absGlow = out1.visuals.glow * 255;
 
-			var ctr:ColorTransform;
-
-			transfTotal[tID++] = ctr = new ColorTransform(negGlow, negGlow, negGlow, out1.visuals.alpha * item.alpha,
-				Math.round(out1.visuals.glowR * absGlow), Math.round(out1.visuals.glowG * absGlow), Math.round(out1.visuals.glowB * absGlow));
+			var ctr = transfTotal[tID++];
+			if (ctr == null) {
+				ctr = new ColorTransform();
+				transfTotal[tID - 1] = ctr;
+			}
+			ctr.redMultiplier = negGlow;
+			ctr.greenMultiplier = negGlow;
+			ctr.blueMultiplier = negGlow;
+			ctr.alphaMultiplier = out1.visuals.alpha * item.alpha;
+			ctr.redOffset = Math.round(out1.visuals.glowR * absGlow);
+			ctr.greenOffset = Math.round(out1.visuals.glowG * absGlow);
+			ctr.blueOffset = Math.round(out1.visuals.glowB * absGlow);
+			ctr.alphaOffset = 0;
 
 			if (ctr.hasRGBMultipliers() || ctr.alphaMultiplier != 1)
 				hasC = true;
@@ -383,24 +452,29 @@ final class HoldRenderer extends BaseRenderer<FlxSprite> {
 	}
 
 	inline private function getArrowParams(arrow:FlxSprite, posOff:Float = 0):ArrowData {
-		final player = Adapter.instance.getPlayerFromArrow(arrow);
-		final lane = Adapter.instance.getLaneFromArrow(arrow);
-
 		final timeC2 = flixel.FlxG.height * 0.25 * __centered2;
-		final hitTime = Adapter.instance.getTimeFromArrow(arrow);
+		final hitTime = __cachedHoldHitTime;
 
-		var pos = (hitTime - Adapter.instance.getSongPosition()) + posOff;
+		var pos = (hitTime - __cachedSongPos) + posOff;
 		pos += timeC2;
 
 		// Reuse _holdArrowBuf to avoid a heap allocation per segment.
 		_holdArrowBuf.hitTime = hitTime + posOff + timeC2;
 		_holdArrowBuf.distance = pos;
-		_holdArrowBuf.sourceTime = Adapter.instance.getHoldParentTime(arrow);
-		_holdArrowBuf.lane = lane;
-		_holdArrowBuf.player = player;
-		_holdArrowBuf.hitten = Adapter.instance.arrowHit(arrow);
+		_holdArrowBuf.sourceTime = __cachedHoldParentTime;
+		_holdArrowBuf.lane = __cachedHoldLane;
+		_holdArrowBuf.player = __cachedHoldPlayer;
+		_holdArrowBuf.hitten = __cachedHoldHitten;
 		_holdArrowBuf.isTapArrow = true;
 		_holdArrowBuf.straightHolds = __straightHolds > 0;
 		return _holdArrowBuf;
 	}
+
+	override function dispose() {
+		_uvtCacheKeys = [];
+		_uvtCacheVals = [];
+		_holdVerticesPool = new ObjectMap<FlxSprite, openfl.Vector<Float>>();
+		_holdColorsPool = new ObjectMap<FlxSprite, NativeVector<ColorTransform>>();
+		_holdPoolSubs = new ObjectMap<FlxSprite, Int>();
+	}
 }

source/funkin/modding/modchart/backend/graphics/renderers/PathRenderer.hx

@@ -2,6 +2,7 @@ package funkin.modding.modchart.backend.graphics.renderers;
 
 import flixel.FlxG;
 import flixel.graphics.FlxGraphic;
+import flixel.math.FlxMath;
 import flixel.util.FlxDestroyUtil;
 import openfl.geom.ColorTransform;
 import funkin.modding.modchart.engine.modifiers.list.Reverse;
@@ -17,6 +18,8 @@ var pathVector = new Vector3();
 #end
 final class PathRenderer extends BaseRenderer<FlxSprite> {
 	static inline final DEFAULT_PATH_BOUND:Float = 300;
+	static inline final BASE_PATH_LIMIT:Float = 1800 + DEFAULT_PATH_BOUND;
+	static inline final MAX_ADAPTIVE_DIVISIONS:Int = 512;
 
 	var __lineGraphic:FlxGraphic;
 	var __lastDivisions:Int = -1;
@@ -181,6 +184,15 @@ final class PathRenderer extends BaseRenderer<FlxSprite> {
 		return DEFAULT_PATH_BOUND;
 	}
 
+	private inline function getAdaptiveDivisions(limit:Float):Int {
+		final baseDivisions = Std.int(Config.ARROW_PATHS_CONFIG.BASE_DIVISIONS * Config.ARROW_PATHS_CONFIG.RESOLUTION);
+		final safeBase = Std.int(Math.max(2, baseDivisions));
+		final ratio = BASE_PATH_LIMIT > 0 ? (limit / BASE_PATH_LIMIT) : 1.0;
+		final qualityScale = FlxMath.bound(funkin.modding.modchart.backend.graphics.CtxRenderer.pathQualityScale, 0.5, 1.0);
+		final scaledDivisions = Std.int(Math.ceil(safeBase * Math.max(1.0, ratio) * qualityScale));
+		return Std.int(FlxMath.bound(scaledDivisions, 2, MAX_ADAPTIVE_DIVISIONS));
+	}
+
 	// The entry sprite should be A RECEPTOR / STRUM.
 	override public function prepare(item:FlxSprite):Null<DrawCommand> {
 		final lane = Adapter.instance.getLaneFromArrow(item);
@@ -201,8 +213,8 @@ final class PathRenderer extends BaseRenderer<FlxSprite> {
 		__lastPlayer = fn;
 		__lastLane = lane;
 
-		final divisions = Std.int(Config.ARROW_PATHS_CONFIG.BASE_DIVISIONS * Config.ARROW_PATHS_CONFIG.RESOLUTION);
 		final limit = 1800 + pathBound;
+		final divisions = getAdaptiveDivisions(limit);
 		final interval = limit / (divisions - 1); // max point distance = limit (receptor → furthest sample)
 		final songPos = Adapter.instance.getSongPosition();
 		final segs = divisions - 1;

source/funkin/play/PlayState.hx

@@ -1,6 +1,6 @@
 package funkin.play;
 
-import sys.thread.Thread;
+impor sys.thread.Thread;
 import funkin.save.Highscore;
 import funkin.data.stage.StageData;
 import funkin.data.story.level.WeekData;

source/funkin/play/cutscene/dialogue/DialogueBox.hx

@@ -67,7 +67,7 @@ class DialogueBox extends FlxSpriteGroup
 				hasDialog = false;
 		}
 
-		this.dialogueList = dialogueList;
+		this.dialogueList = dialogueList != null ? dialogueList : [];
 
 		if (!hasDialog)
 			return;
@@ -128,6 +128,17 @@ class DialogueBox extends FlxSpriteGroup
 		// HARD CODING CUZ IM STUPDI
 		super.update(elapsed);
 
+		if (dialogueList == null || dialogueList.length == 0)
+		{
+			if (!isEnding)
+			{
+				if (finishThing != null)
+					finishThing();
+				kill();
+			}
+			return;
+		}
+
 		switch(songName)
 		{
 			case 'roses':
@@ -216,7 +227,18 @@ class DialogueBox extends FlxSpriteGroup
 
 	function startDialogue():Void
 	{
+		if (dialogueList == null || dialogueList.length == 0)
+		{
+			dialogueCompleted();
+			return;
+		}
+
 		cleanDialog();
+		if (dialogueList == null || dialogueList.length == 0 || dialogueList[0] == null)
+		{
+			dialogueCompleted();
+			return;
+		}
 		// var theDialog:Alphabet = new Alphabet(0, 70, dialogueList[0], false, true);
 		// dialogue = theDialog;
 		// add(theDialog);
@@ -254,8 +276,19 @@ class DialogueBox extends FlxSpriteGroup
 
 	function cleanDialog():Void
 	{
+		if (dialogueList == null || dialogueList.length == 0 || dialogueList[0] == null)
+			return;
+
 		var splitName:Array<String> = dialogueList[0].split(':');
-		curCharacter = splitName[1];
-		dialogueList[0] = dialogueList[0].substr(splitName[1].length + 2).trim();
+		if (splitName.length > 1 && splitName[1] != null)
+		{
+			curCharacter = splitName[1];
+			dialogueList[0] = dialogueList[0].substr(splitName[1].length + 2).trim();
+		}
+		else
+		{
+			curCharacter = 'dad';
+			dialogueList[0] = dialogueList[0].trim();
+		}
 	}
 }

source/funkin/play/stage/Limo.hx

@@ -81,7 +81,8 @@ class Limo extends BaseStage
 		addBehindGF(fastCar);
 
 		var limo:BGSprite = new BGSprite('limo/limoDrive', -120, 550, 1, 1, ['Limo stage'], true);
-		addBehindGF(limo); //Shitty layering but whatev it works LOL
+		// Keep GF between the back limo and this front limo layer.
+		addBehindDad(limo);
 	}
 
 	var limoSpeed:Float = 0;