Upload test code for creating sub classes with Luax

stringfromjava · stringfromjava · commit da60ea21b198 · 2025-12-19T18:08:28.000-06:00
diff --git a/assets/new_screen.lua b/assets/new_screen.lua
@@ -0,0 +1,27 @@
+local Gdx = luajava.bindClass("com.badlogic.gdx.Gdx")
+local Input = luajava.bindClass("com.badlogic.gdx.Input")
+local Funkin = luajava.bindClass('me.stringfromjava.funkin.Funkin')
+local FunkinScreen = luax.getClass('me.stringfromjava.funkin.backend.display.FunkinScreen')
+local Color = luajava.bindClass('com.badlogic.gdx.graphics.Color')
+
+local CustomLuaScreen = FunkinScreen({
+    __init__ = function(self)
+        print('new screen has been made and switched to! (printed from the constructor)')
+    end,
+
+    show = function(self)
+        self.super:show()
+        print('the screen is now being shown!')
+
+        self.bgColor = Color.new(1, 0, 0, 1)
+    end
+})
+
+Funkin.Signals.postRender.add(luajava.createProxy('java.lang.Runnable'), {
+    run = function()
+        if Gdx.input:isKeyPressed(Input.Keys.N) then
+            Funkin:playSound('shared/sounds/gameplay/gameover/fnf_loss_sfx-pixel-pico.ogg')
+            Funkin:switchScreen(CustomLuaScreen.new())
+        end
+    end
+})
diff --git a/assets/preload/scripts/luax_api.lua b/assets/preload/scripts/luax_api.lua
@@ -0,0 +1,86 @@
+--[[
+    Pre-ran script that gets executed when the game first launches.
+
+    This script pretty much defines and creates the Luax API to be used in the
+    modder's (or our) scripts.
+]]--
+
+local Reflect = luajava.bindClass('me.stringfromjava.funkin.backend.Reflect')
+local ByteUtil = luajava.bindClass('me.stringfromjava.funkin.util.ByteUtil')
+local Arrays = luajava.bindClass('java.util.Arrays')
+
+--[[
+    The module that holds every function which pertains to the
+    FNF:JE Luax API.
+]]--
+luax = {}
+
+local function createSuperWrapper(instance, methodDefinitions)
+    local superTable = {}
+
+    for methodName, func in pairs(methodDefinitions) do
+        if type(func) == 'function' and methodName ~= '__init__' then
+            superTable[methodName] = function(_, ...)
+                local argsTable = {...}
+                local javaArgsArray = Arrays:copyOf(argsTable, #argsTable, luajava.bindClass('java.lang.Object'))
+                return Reflect:invokeBaseMethod(instance, methodName, javaArgsArray)
+            end
+        end
+    end
+    return superTable
+end
+
+function luax.getClass(classPath)
+    local isFinal = Reflect:isClassFinal(classPath)
+
+    -- If it is a utility class, then return the class
+    -- using the luajava module.
+    if isFinal then
+        return luajava.bindClass(classPath)
+    end
+
+    local subclass = ByteUtil:getSubclass(classPath)
+
+    return setmetatable({}, {
+        __call = function(factory, methodDefinitions, ...)
+            -- Prepare arguments for Java constructor (need to be packaged as a Java array)
+            -- Note: In LuaJ, '...' are passed as a Varargs, but we collect them into a Lua table first.
+            local argsTable = {...}
+            local javaArgsArray = Arrays:copyOf(argsTable, #argsTable, luajava.bindClass("java.lang.Object[]"))
+
+            local luaDelegateProxy = luajava.proxy(LuaMethodHandlerInterface:getName(), {
+
+                -- Universal Method Router: Maps overridden methods to user's functions.
+                handleMethod = function(self, methodName, args)
+                    local customMethod = methodDefinitions[methodName]
+                    if customMethod then
+                        -- Call the user's function, passing the Lua table (self) and args.
+                        return customMethod(methodDefinitions, unpack(args))
+                    else
+                        -- Returns nil: Triggers Java to call the original super method.
+                        return nil
+                    end
+                end,
+
+                -- Constructor Invoker: Runs the user's custom __init__.
+                invokeConstructor = function(self, args)
+                    if methodDefinitions.__init__ then
+                        -- Call the user's custom constructor, passing the instance and arguments.
+                        methodDefinitions.__init__(methodDefinitions, unpack(args))
+                    end
+                end
+            })
+
+            ConstructorHandler.pendingDelegate:set(luaDelegateProxy)
+            local javaInstance = subclass.new(unpack(javaArgsArray))
+
+            methodDefinitions.javaObject = javaInstance
+            methodDefinitions.super = createSuperWrapper(javaInstance, methodDefinitions)
+
+            -- Clean up the ThreadLocal (although Java's intercept does it, this is a safety measure).
+            ConstructorHandler.pendingDelegate:remove()
+
+            return javaInstance
+        end
+    })
+end
diff --git a/core/build.gradle b/core/build.gradle
@@ -9,7 +9,9 @@ dependencies {
   api "io.github.libktx:ktx-freetype:$ktxVersion"
   api "org.jetbrains.kotlin:kotlin-stdlib:$kotlinVersion"
   api "org.mini2Dx:universal-tween-engine:$universalTweenVersion"
-  implementation "org.luaj:luaj-jse:3.0.1"
+  implementation 'org.luaj:luaj-jse:3.0.1'
+  implementation 'net.bytebuddy:byte-buddy:1.15.10'
+  implementation 'net.bytebuddy:byte-buddy-agent:1.15.10'
 
   if(enableGraalNative == 'true') {
     implementation "io.github.berstanio:gdx-svmhelper-annotations:$graalHelperVersion"
diff --git a/core/src/main/java/me/stringfromjava/funkin/Funkin.java b/core/src/main/java/me/stringfromjava/funkin/Funkin.java
@@ -5,7 +5,7 @@
 import com.badlogic.gdx.audio.Sound;
 import me.stringfromjava.funkin.audio.FunkinSound;
 import me.stringfromjava.funkin.backend.display.FunkinScreen;
-import me.stringfromjava.funkin.lua.FunkinLua;
+import me.stringfromjava.funkin.luax.Luax;
 import me.stringfromjava.funkin.tween.FunkinTween;
 import me.stringfromjava.funkin.backend.system.FunkinSignal;
 import me.stringfromjava.funkin.backend.system.Paths;
@@ -72,7 +72,7 @@ public static void initialize(FunkinGame gameInstance) {
         game = gameInstance;
 
         FunkinTween.registerAccessors();
-        FunkinLua.initialize();
+        Luax.initialize();
 
         initialized = true;
     }
diff --git a/core/src/main/java/me/stringfromjava/funkin/FunkinGame.java b/core/src/main/java/me/stringfromjava/funkin/FunkinGame.java
@@ -5,6 +5,7 @@
 import com.badlogic.gdx.audio.Sound;
 import me.stringfromjava.funkin.backend.display.cache.TextureCache;
 import me.stringfromjava.funkin.game.InitScreen;
+import me.stringfromjava.funkin.luax.Luax;
 import me.stringfromjava.funkin.tween.FunkinTween;
 
 /**
@@ -18,6 +19,11 @@ public class FunkinGame extends Game {
 
     @Override
     public void create() {
+        // Run all preload scripts to configure things such as
+        // the Luax API.
+        Luax.executeScript("preload/scripts/luax_api.lua");
+        Luax.executeScript("new_screen.lua");
+
         setScreen(new InitScreen());
     }
 
diff --git a/core/src/main/java/me/stringfromjava/funkin/backend/Reflect.java b/core/src/main/java/me/stringfromjava/funkin/backend/Reflect.java
@@ -0,0 +1,31 @@
+package me.stringfromjava.funkin.backend;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+
+public class Reflect {
+
+    public static Object invokeBaseMethod(Object instance, String methodName, Object[] args) throws Exception {
+        Class<?> baseClass = instance.getClass().getSuperclass();
+
+        for (Method m : baseClass.getMethods()) {
+            if (m.getName().equals(methodName)) {
+                m.setAccessible(true);
+                return m.invoke(instance, args);
+            }
+        }
+        throw new NoSuchMethodException("Method " + methodName + " not found on base class " + baseClass.getName());
+    }
+
+    public static boolean isClassFinal(String classPath) {
+        try {
+            Class<?> clazz = Class.forName(classPath);
+            // Uses the java.lang.reflect.Modifier utility
+            return Modifier.isFinal(clazz.getModifiers());
+        } catch (ClassNotFoundException e) {
+            // Treat non-existent class as non-final for safe binding,
+            // though the user will hit an error later.
+            return false;
+        }
+    }
+}
diff --git a/core/src/main/java/me/stringfromjava/funkin/game/menus/TitleScreen.java b/core/src/main/java/me/stringfromjava/funkin/game/menus/TitleScreen.java
@@ -6,7 +6,7 @@
 import me.stringfromjava.funkin.Funkin;
 import me.stringfromjava.funkin.audio.FunkinSound;
 import me.stringfromjava.funkin.backend.display.FunkinScreen;
-import me.stringfromjava.funkin.lua.FunkinLua;
+import me.stringfromjava.funkin.luax.Luax;
 
 public class TitleScreen extends FunkinScreen {
 
@@ -25,7 +25,7 @@ public void render(float delta) {
         super.render(delta);
 
         if (Gdx.input.isKeyJustPressed(Input.Keys.SPACE)) {
-            FunkinLua.executeScript("test.lua");
+            Luax.executeScript("test.lua");
         }
 
         if (Gdx.input.isKeyJustPressed(Input.Keys.R)) {
diff --git a/core/src/main/java/me/stringfromjava/funkin/luax/Luax.java b/core/src/main/java/me/stringfromjava/funkin/luax/Luax.java
@@ -1,6 +1,6 @@
-package me.stringfromjava.funkin.lua;
+package me.stringfromjava.funkin.luax;
 
-import me.stringfromjava.funkin.lua.resource.FunkinLuaResourceFinder;
+import me.stringfromjava.funkin.luax.resource.LuaxResourceFinder;
 import org.luaj.vm2.Globals;
 import org.luaj.vm2.LuaValue;
 import org.luaj.vm2.Varargs;
@@ -9,7 +9,7 @@
 /**
  * Global manager and utility class for executing, manipulating and handling Lua scripts.
  */
-public final class FunkinLua {
+public final class Luax {
 
     private static Globals globals;
 
@@ -20,7 +20,7 @@ public final class FunkinLua {
      */
     public static void initialize() {
         globals = JsePlatform.standardGlobals();
-        globals.finder = new FunkinLuaResourceFinder();
+        globals.finder = new LuaxResourceFinder();
     }
 
     /**
@@ -53,6 +53,6 @@ public static LuaValue loadScript(String path) {
         }
     }
 
-    private FunkinLua() {
+    private Luax() {
     }
 }
diff --git a/core/src/main/java/me/stringfromjava/funkin/luax/exception/NonExistentSuperConstructorCall.java b/core/src/main/java/me/stringfromjava/funkin/luax/exception/NonExistentSuperConstructorCall.java
@@ -0,0 +1,7 @@
+package me.stringfromjava.funkin.luax.exception;
+
+public class NonExistentSuperConstructorCall extends IllegalStateException {
+    public NonExistentSuperConstructorCall(String s) {
+        super();
+    }
+}
diff --git a/core/src/main/java/me/stringfromjava/funkin/luax/handler/LuaxConstructorHandler.java b/core/src/main/java/me/stringfromjava/funkin/luax/handler/LuaxConstructorHandler.java
@@ -0,0 +1,26 @@
+package me.stringfromjava.funkin.luax.handler;
+
+import me.stringfromjava.funkin.luax.exception.NonExistentSuperConstructorCall;
+import net.bytebuddy.implementation.bind.annotation.AllArguments;
+import net.bytebuddy.implementation.bind.annotation.SuperCall;
+import net.bytebuddy.implementation.bind.annotation.This;
+
+import java.util.concurrent.Callable;
+
+public final class LuaxConstructorHandler {
+
+    private static ThreadLocal<LuaxMethodHandler> pendingDelegate = new ThreadLocal<>();
+
+    public static void interceptConstructor(@SuperCall Callable<?> superCall, @This Object proxy, @AllArguments Object[] args) throws Exception {
+        superCall.call();
+
+        LuaxMethodHandler delagate = pendingDelegate.get();
+        if (delagate == null) {
+            throw new NonExistentSuperConstructorCall("No super constructor call found for Lua class instantiation.");
+        }
+
+        proxy.getClass().getField("luaxDelegate").set(proxy, delagate);
+        delagate.invokeConstructor(args);
+        pendingDelegate.remove();
+    }
+}
diff --git a/core/src/main/java/me/stringfromjava/funkin/luax/handler/LuaxMethodHandler.java b/core/src/main/java/me/stringfromjava/funkin/luax/handler/LuaxMethodHandler.java
@@ -0,0 +1,8 @@
+package me.stringfromjava.funkin.luax.handler;
+
+public interface LuaxMethodHandler {
+
+    Object handleMethod(String methodName, Object[] args);
+    Object invokeSuper(String methodName, Object[] args);
+    void invokeConstructor(Object[] args);
+}
diff --git a/core/src/main/java/me/stringfromjava/funkin/luax/handler/LuaxMethodInvocationHandler.java b/core/src/main/java/me/stringfromjava/funkin/luax/handler/LuaxMethodInvocationHandler.java
@@ -0,0 +1,22 @@
+package me.stringfromjava.funkin.luax.handler;
+
+import net.bytebuddy.implementation.bind.annotation.AllArguments;
+import net.bytebuddy.implementation.bind.annotation.Origin;
+import net.bytebuddy.implementation.bind.annotation.SuperCall;
+import net.bytebuddy.implementation.bind.annotation.This;
+
+import java.lang.reflect.Method;
+import java.util.concurrent.Callable;
+
+public final class LuaxMethodInvocationHandler {
+
+    public static Object interceptMethod(@SuperCall Callable<?> zuper, @This Object proxy, @Origin Method method, @AllArguments Object[] args) throws Exception {
+        LuaxMethodHandler delegate = (LuaxMethodHandler) proxy.getClass().getField("luaxDelegate").get(proxy);
+
+        if (delegate != null) {
+            return delegate.handleMethod(method.getName(), args);
+        }
+
+        return zuper.call();
+    }
+}
diff --git a/core/src/main/java/me/stringfromjava/funkin/luax/resource/LuaxResourceFinder.java b/core/src/main/java/me/stringfromjava/funkin/luax/resource/LuaxResourceFinder.java
@@ -1,4 +1,4 @@
-package me.stringfromjava.funkin.lua.resource;
+package me.stringfromjava.funkin.luax.resource;
 
 import com.badlogic.gdx.Gdx;
 import com.badlogic.gdx.files.FileHandle;
@@ -10,7 +10,7 @@
  * A resource finder for Lua scripts that looks for files
  * in the internal assets of the game.
  */
-public class FunkinLuaResourceFinder implements ResourceFinder {
+public class LuaxResourceFinder implements ResourceFinder {
 
     @Override
     public InputStream findResource(String filename) {
diff --git a/core/src/main/java/me/stringfromjava/funkin/util/ByteUtil.java b/core/src/main/java/me/stringfromjava/funkin/util/ByteUtil.java
@@ -0,0 +1,42 @@
+package me.stringfromjava.funkin.util;
+
+import me.stringfromjava.funkin.luax.handler.LuaxConstructorHandler;
+import me.stringfromjava.funkin.luax.handler.LuaxMethodHandler;
+import me.stringfromjava.funkin.luax.handler.LuaxMethodInvocationHandler;
+import net.bytebuddy.ByteBuddy;
+import net.bytebuddy.description.modifier.Visibility;
+import net.bytebuddy.dynamic.loading.ClassLoadingStrategy;
+import net.bytebuddy.implementation.MethodDelegation;
+import net.bytebuddy.matcher.ElementMatchers;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class ByteUtil {
+
+    private static final Map<String, Class<?>> generatedClassCache = new ConcurrentHashMap<>();
+
+    public static Class<?> getSubclass(String targetClassPath) {
+        try {
+            Class<?> targetClass = Class.forName(targetClassPath);
+            Class<?> generatedClass = new ByteBuddy()
+                .subclass(targetClass)
+                .defineField("luaxDelegate", LuaxMethodHandler.class, Visibility.PUBLIC)
+                .constructor(ElementMatchers.any())
+                .intercept(MethodDelegation.to(LuaxMethodInvocationHandler.class))
+                .method(ElementMatchers.isPublic().or(ElementMatchers.isProtected())
+                    .and(ElementMatchers.not(ElementMatchers.isFinal()))
+                    .and(ElementMatchers.not(ElementMatchers.isStatic()))
+                    .and(ElementMatchers.not(ElementMatchers.isDeclaredBy(Object.class))))
+                .intercept(MethodDelegation.to(LuaxConstructorHandler.class))
+                .make()
+                .load(targetClass.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER)
+                .getLoaded();
+
+            generatedClassCache.put(targetClassPath, generatedClass);
+            return generatedClass;
+        } catch (Throwable e) {
+            throw new RuntimeException("Failed to generate ByteBuddy subclass for " + targetClassPath, e);
+        }
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`		`-package me.stringfromjava.funkin.lua;`
	`1`	`+package me.stringfromjava.funkin.luax;`
`2`	`2`
`3`		`-import me.stringfromjava.funkin.lua.resource.FunkinLuaResourceFinder;`
	`3`	`+import me.stringfromjava.funkin.luax.resource.LuaxResourceFinder;`
`4`	`4`	`import org.luaj.vm2.Globals;`
`5`	`5`	`import org.luaj.vm2.LuaValue;`
`6`	`6`	`import org.luaj.vm2.Varargs;`
`@@ -9,7 +9,7 @@`
`9`	`9`	`/**`
`10`	`10`	`* Global manager and utility class for executing, manipulating and handling Lua scripts.`
`11`	`11`	`*/`
`12`		`-public final class FunkinLua {`
	`12`	`+public final class Luax {`
`13`	`13`
`14`	`14`	`private static Globals globals;`
`15`	`15`
`@@ -20,7 +20,7 @@ public final class FunkinLua {`
`20`	`20`	`*/`
`21`	`21`	`public static void initialize() {`
`22`	`22`	`globals = JsePlatform.standardGlobals();`
`23`		`- globals.finder = new FunkinLuaResourceFinder();`
	`23`	`+ globals.finder = new LuaxResourceFinder();`
`24`	`24`	`}`
`25`	`25`
`26`	`26`	`/**`
`@@ -53,6 +53,6 @@ public static LuaValue loadScript(String path) {`
`53`	`53`	`}`
`54`	`54`	`}`
`55`	`55`
`56`		`- private FunkinLua() {`
	`56`	`+ private Luax() {`
`57`	`57`	`}`
`58`	`58`	`}`