1004 lines
42 KiB
Java
1004 lines
42 KiB
Java
package com.spineview;
|
||
|
||
import java.lang.reflect.Field;
|
||
import java.lang.reflect.Method;
|
||
import java.lang.reflect.Modifier;
|
||
import java.util.List;
|
||
|
||
/**
|
||
* 场景对象的"增 / 删 / 改"。
|
||
*
|
||
* 两条路（都在 `编辑器交互与数据API.md` 里有字节码出处）：
|
||
*
|
||
* 1. **走编辑器菜单命令**（`New Bone` / `Delete` / `Rename` …）：
|
||
* 路径 = 先 `VZ.D(对象)` 把选择设成目标 → 跑命令。
|
||
* 编辑器自己会改属性面板、插树节点、弹确认框、进撤销栈。**增**走这条。
|
||
* 2. **直接改模型 + 自己包撤销**：`un.D()` … `对象.L()`/`对象.D(名字,true)` … `un.B()`，
|
||
* 再 `VZ.D(骨架,true,true)` 重建树节点。**删/改**走这条（不进确认框，但带撤销）。
|
||
*
|
||
* 模型对象（载荷名）：`GP` 骨架、`Gp` 骨骼、`GU` 插槽、`GT`/`GO` 附件，都 extends `Gj`。
|
||
* `L()V` = 把自己从模型里摘掉；`D(String,boolean)V` = 改名（第二参 = 是否同步子对象名字）。
|
||
*/
|
||
public final class SceneActions {
|
||
|
||
/** 标记"当前线程就是编辑器渲染线程"，避免 `OG.B` 二次投递（它内部会断言不在渲染线程）。 */
|
||
private static final ThreadLocal<Boolean> ON_EDITOR_THREAD = new ThreadLocal<Boolean>();
|
||
|
||
private SceneActions() {
|
||
}
|
||
|
||
/**
|
||
* 把一段动作切到**编辑器的渲染线程**上执行并等待。
|
||
*
|
||
* 为什么必须切：编辑器在改模型前会调 `OG.I()`（`javap -c OG`）：
|
||
* ```java
|
||
* if (!Editor.S && Editor.D != null && Editor.D != Thread.currentThread())
|
||
* throw new RuntimeException(); // "不能在非渲染线程动模型"
|
||
* ```
|
||
* 而 `OG.B(Runnable)V` / `OG.D(Runnable)V` 就是编辑器自己的"投递到渲染线程"接口
|
||
* （`B` 用 `CountDownLatch` 等它跑完，`D` 不等；内部走 `cOm4.D:LnUl;.D(Runnable)`）。
|
||
*
|
||
* 面板按钮本身是 libGDX 事件回调，天然就在渲染线程上；这个方法主要给后台线程/探针用。
|
||
*/
|
||
public static void onEditorThread(ClassLoader loader, Runnable body) {
|
||
if (Boolean.TRUE.equals(ON_EDITOR_THREAD.get())) {
|
||
body.run();
|
||
return;
|
||
}
|
||
final Runnable wrapped = new Runnable() {
|
||
@Override
|
||
public void run() {
|
||
ON_EDITOR_THREAD.set(Boolean.TRUE);
|
||
try {
|
||
body.run();
|
||
} finally {
|
||
ON_EDITOR_THREAD.remove();
|
||
}
|
||
}
|
||
};
|
||
try {
|
||
Class<?> og = Class.forName("OG", true, loader);
|
||
for (Method method : og.getDeclaredMethods()) {
|
||
if (!method.getName().equals("B")) continue;
|
||
Class<?>[] parameters = method.getParameterTypes();
|
||
if (parameters.length != 1 || parameters[0] != Runnable.class) continue;
|
||
method.setAccessible(true);
|
||
method.invoke(null, wrapped);
|
||
return;
|
||
}
|
||
System.err.println("[crud] OG.B(Runnable) 没找到，直接在当前线程执行");
|
||
} catch (Throwable error) {
|
||
System.err.println("[crud] 切渲染线程失败，直接在当前线程执行: " + error);
|
||
}
|
||
wrapped.run();
|
||
}
|
||
|
||
/** 撤销栈（载荷类 un）：`D()` 记一次编辑开始，`B()` 提交。 */
|
||
private static Class<?> undoManager(ClassLoader loader) throws Exception {
|
||
return Class.forName("un", true, loader);
|
||
}
|
||
|
||
/** 调 `un.D()` / `un.B()` 这类无参静态方法（名字被混淆过，按"名字 + 空参数 + void"取）。 */
|
||
private static void undoCall(Class<?> undoClass, String name) throws Exception {
|
||
// ⚠️ 不能 getDeclaredMethod(name)：`un` 上有 4 个同名无参方法（返回 Z/J/I/V），会抛 NoSuchMethod。
|
||
for (Method method : undoClass.getDeclaredMethods()) {
|
||
if (!method.getName().equals(name)) continue;
|
||
if (!hasNoArgs(method)) continue;
|
||
method.setAccessible(true);
|
||
method.invoke(null);
|
||
return;
|
||
}
|
||
throw new NoSuchMethodException("un." + name + "():V");
|
||
}
|
||
|
||
private static boolean hasNoArgs(Method method) {
|
||
return method.getParameterTypes().length == 0 && method.getReturnType() == void.class
|
||
&& Modifier.isStatic(method.getModifiers());
|
||
}
|
||
|
||
/** 选中某个场景对象（编辑器层级树里高亮它，并切换它的属性面板）。 */
|
||
public static boolean select(ClassLoader loader, Object sceneObject) {
|
||
if (sceneObject == null) return false;
|
||
final Object target = sceneObject;
|
||
final ClassLoader classLoader = loader;
|
||
final boolean[] result = new boolean[1];
|
||
// 选中会触发 editor 的事件链路（改属性面板等），同样必须在渲染线程上做。
|
||
onEditorThread(loader, new Runnable() {
|
||
@Override
|
||
public void run() {
|
||
try {
|
||
result[0] = SceneObjects.select(classLoader, target);
|
||
} catch (Throwable error) {
|
||
System.err.println("[crud] 选中失败: " + error);
|
||
}
|
||
}
|
||
});
|
||
return result[0];
|
||
}
|
||
|
||
/**
|
||
* 新建：先把选择设成父对象，再跑编辑器的 `New <type>` 命令。
|
||
*
|
||
* `type` 用编辑器自己的类型名：`Bone` / `Slot` / `Skin Placeholder` / `Bounding Box` /
|
||
* `Path` / `Clipping` / `IK Constraint` / `Transform Constraint` / `Path Constraint`。
|
||
* 命令只在"当前选择是合法父级"时生效（例如选骨骼才能 New Bone / New Slot），否则编辑器什么都不做。
|
||
*/
|
||
public static boolean create(ClassLoader loader, Object parent, String type) {
|
||
final Object target = parent;
|
||
final String typeName = type;
|
||
final ClassLoader classLoader = loader;
|
||
final boolean[] result = new boolean[1];
|
||
onEditorThread(loader, new Runnable() {
|
||
@Override
|
||
public void run() {
|
||
result[0] = createNow(classLoader, target, typeName);
|
||
}
|
||
});
|
||
// ⚠️ 输入名字的对话框是**下一帧**才建出来的，只能在渲染线程之外等它出现
|
||
// （在渲染线程里 sleep 会卡住帧，对话框永远不出现）。
|
||
// `New Bone` 是编辑器自动编号、不弹框；其余 New X 都会弹，所以：
|
||
// 没给名字 → 自动生成一个不重名的；给了名字 → 用它；然后自动点 OK。
|
||
if (!"Bone".equals(typeName)) {
|
||
String pending = PENDING_NAME.get();
|
||
if (pending == null || pending.length() == 0) {
|
||
pending = autoName(loader, typeName);
|
||
}
|
||
LAST_NAME.set(pending);
|
||
fillDialogWhenReady(loader, pending);
|
||
PENDING_NAME.remove();
|
||
}
|
||
return result[0];
|
||
}
|
||
|
||
private static boolean createNow(ClassLoader loader, Object parent, String type) {
|
||
if (parent == null) {
|
||
System.err.println("[crud] 新建失败：没有选中的父对象");
|
||
return false;
|
||
}
|
||
if (!select(loader, parent)) {
|
||
System.err.println("[crud] 新建失败：选不中父对象 " + SceneObjects.nameOf(parent));
|
||
return false;
|
||
}
|
||
String command = type.startsWith("New ") ? type : "New " + type;
|
||
System.err.println("[crud] 新建: " + command + "（父级 = " + SceneObjects.nameOf(parent) + "）");
|
||
// 有些 New X 会弹"输入名字"对话框（New Slot / New Bounding Box / New Path / …），
|
||
// 光执行命令不会建对象，对话框由 create() 在本线程轮询后填名字 + 点 OK（见 fillDialogWhenReady）。
|
||
return Commands.run(loader, command);
|
||
}
|
||
|
||
/** 面板/探针给下一次"会弹对话框的新建"准备好的名字。 */
|
||
private static final ThreadLocal<String> PENDING_NAME = new ThreadLocal<String>();
|
||
/** 这一次新建实际用的名字（面板用来显示）。 */
|
||
private static final ThreadLocal<String> LAST_NAME = new ThreadLocal<String>();
|
||
|
||
public static void nextName(String name) {
|
||
PENDING_NAME.set(name);
|
||
}
|
||
|
||
public static String lastName() {
|
||
return LAST_NAME.get();
|
||
}
|
||
|
||
/**
|
||
* 自动生成一个**不重名**的名字：`Slot` → `slot` / `slot_2` / `slot_3` …
|
||
* 判断重名时比的是"同一类对象"的现有名字（骨骼/插槽全局唯一，附件同名也能查出来）。
|
||
*/
|
||
static String autoName(ClassLoader loader, String type) {
|
||
String base = type.toLowerCase().replace(' ', '_');
|
||
java.util.Set<String> used = new java.util.HashSet<String>();
|
||
try {
|
||
for (Object item : SceneObjects.listAllNodes(loader)) {
|
||
used.add(SceneObjects.nameOf(item));
|
||
}
|
||
} catch (Throwable ignored) {
|
||
// 读不到就用 1
|
||
}
|
||
if (!used.contains(base)) return base;
|
||
for (int i = 2; i < 10000; i++) {
|
||
String candidate = base + "_" + i;
|
||
if (!used.contains(candidate)) return candidate;
|
||
}
|
||
return base + "_" + System.nanoTime();
|
||
}
|
||
|
||
// ==================== 输入对话框自动化 ====================
|
||
//
|
||
// `New Slot` / `New Bounding Box` / `New Path` / `New Clipping` / `New Skin Placeholder` /
|
||
// `New IK Constraint` / `New Event` / `New Animation` 都会弹一个"输入名字"的窗口
|
||
// （标题如 "New Slot"，正文 "Enter a name to create a new slot:"，按钮 OK / Cancel）。
|
||
// 命令本身只负责弹窗，名字与 OK 必须有人点。这里把这一步自动化：
|
||
// Stage(OG.D:Ldt;) → 找最后一个 TextField（对话框里的输入框）
|
||
// → 找最后一个文字含 "OK" 的 TextButton → 填名字 + 点它。
|
||
|
||
/** 轮询等对话框出现（最多约 3 秒），出现后填名字 + 点 OK。 */
|
||
static boolean fillDialogWhenReady(ClassLoader loader, String name) {
|
||
for (int i = 0; i < 30; i++) {
|
||
if (fillDialog(loader, name)) {
|
||
System.err.println("[crud] 已自动填写对话框并点 OK: " + name);
|
||
sleep(300);
|
||
return true;
|
||
}
|
||
sleep(100);
|
||
}
|
||
System.err.println("[crud] 没等到输入对话框: " + name);
|
||
return false;
|
||
}
|
||
|
||
static boolean fillDialog(ClassLoader loader, String name) {
|
||
try {
|
||
Object stage = SceneObjects.global(loader, "dt");
|
||
if (stage == null) return false;
|
||
// 不顺着"children 数组"找了（编辑器的弹窗并不一定在 Stage 根的孩子里）。
|
||
// 改成：从 Stage 出发按字段广度遍历，找"**有 TextField 字段 + 有 L(Object)V 回调**"的对象
|
||
// —— 载荷里所有这类输入对话框（New Slot / New Bounding Box / New Event / …）都长这样：
|
||
// zY（New Slot 对话框）的 OK 回调就是 `L(Object)`，体里只做
|
||
// `String name = TextField.getText(...); …建对象…`。
|
||
Object dialog = findDialog(stage);
|
||
if (dialog == null) return false;
|
||
Object textField = SceneObjects.fieldOfType(dialog, "com.badlogic.gdx.scenes.scene2d.ui.TextField");
|
||
if (textField == null) return false;
|
||
setText(textField, name);
|
||
Method ok = findMethod(dialog.getClass(), "L", new Class<?>[] {Object.class}, void.class);
|
||
if (ok == null) return false;
|
||
ok.setAccessible(true);
|
||
ok.invoke(dialog, Boolean.TRUE);
|
||
return true;
|
||
} catch (Throwable error) {
|
||
System.err.println("[crud] 对话框自动化失败: " + error);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
/** 广度遍历 Stage 上的对象图，找"带 TextField 且有 L(Object)V"的对话框。 */
|
||
private static Object findDialog(Object stage) {
|
||
java.util.Set<Object> seen = java.util.Collections.newSetFromMap(
|
||
new java.util.IdentityHashMap<Object, Boolean>());
|
||
java.util.ArrayDeque<Object> queue = new java.util.ArrayDeque<Object>();
|
||
queue.add(stage);
|
||
int visited = 0;
|
||
while (!queue.isEmpty() && visited++ < 40000) {
|
||
Object current = queue.poll();
|
||
if (current == null || !seen.add(current)) continue;
|
||
if (isDialog(current)) return current;
|
||
if (current.getClass().isArray()) {
|
||
if (!current.getClass().getComponentType().isPrimitive()) {
|
||
for (Object item : (Object[]) current) queue.add(item);
|
||
}
|
||
continue;
|
||
}
|
||
String typeName = current.getClass().getName();
|
||
if (typeName.startsWith("java.") || typeName.startsWith("javax.")) continue;
|
||
for (Class<?> type = current.getClass(); type != null && type != Object.class;
|
||
type = type.getSuperclass()) {
|
||
for (Field field : type.getDeclaredFields()) {
|
||
if (Modifier.isStatic(field.getModifiers())) continue;
|
||
if (field.getType().isPrimitive()) continue;
|
||
try {
|
||
field.setAccessible(true);
|
||
Object value = field.get(current);
|
||
if (value != null) queue.add(value);
|
||
} catch (Throwable ignored) {
|
||
// 跳过
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
|
||
private static boolean isDialog(Object candidate) {
|
||
if (SceneObjects.fieldOfType(candidate, "com.badlogic.gdx.scenes.scene2d.ui.TextField") == null) {
|
||
return false;
|
||
}
|
||
return findMethod(candidate.getClass(), "L", new Class<?>[] {Object.class}, void.class) != null;
|
||
}
|
||
|
||
/** 深度优先遍历 actor 树，记住**最后一个** TextField 和最后一个文字含 OK 的按钮。 */
|
||
private static void walkActors(Object actor, Object[] found, int depth) {
|
||
if (actor == null || depth > 24) return;
|
||
String type = actor.getClass().getName();
|
||
if (type.equals("com.badlogic.gdx.scenes.scene2d.ui.TextField")) found[0] = actor;
|
||
if (type.startsWith("com.badlogic.gdx.scenes.scene2d.ui.TextButton")) {
|
||
String label = ObjectPanel.buttonLabel(actor);
|
||
if (label != null && label.toUpperCase().contains("OK")) found[1] = actor;
|
||
}
|
||
for (Object child : children(actor)) walkActors(child, found, depth + 1);
|
||
}
|
||
|
||
/** Group 的子节点（`do` 上的 Object[] 字段 + 一个 int size）。 */
|
||
private static Object[] children(Object actor) {
|
||
for (Class<?> type = actor.getClass(); type != null && type != Object.class;
|
||
type = type.getSuperclass()) {
|
||
for (Field field : type.getDeclaredFields()) {
|
||
if (Modifier.isStatic(field.getModifiers())) continue;
|
||
try {
|
||
field.setAccessible(true);
|
||
Object value = field.get(actor);
|
||
Object[] items = SceneObjects.arrayItems(value);
|
||
if (items.length > 0) return items;
|
||
} catch (Throwable ignored) {
|
||
// 跳过
|
||
}
|
||
}
|
||
if (type.getName().equals(Obf.GROUP)) break;
|
||
}
|
||
return new Object[0];
|
||
}
|
||
|
||
private static void setText(Object textField, String text) throws Exception {
|
||
Method setter = findMethod(textField.getClass(), Obf.LABEL_SET_TEXT, new Class<?>[] {String.class}, void.class);
|
||
if (setter == null) {
|
||
setter = findMethod(textField.getClass(), Obf.LABEL_SET_TEXT, new Class<?>[] {CharSequence.class}, void.class);
|
||
}
|
||
if (setter == null) throw new NoSuchMethodException("TextField.setText");
|
||
setter.setAccessible(true);
|
||
setter.invoke(textField, text);
|
||
}
|
||
|
||
private static void pressButton(Object button) throws Exception {
|
||
Method setChecked = findMethod(button.getClass(), Obf.BUTTON_SET_CHECKED_FIRE,
|
||
new Class<?>[] {boolean.class, boolean.class}, void.class);
|
||
if (setChecked == null) {
|
||
setChecked = findMethod(button.getClass(), Obf.BUTTON_SET_CHECKED,
|
||
new Class<?>[] {boolean.class}, void.class);
|
||
setChecked.setAccessible(true);
|
||
setChecked.invoke(button, Boolean.TRUE);
|
||
return;
|
||
}
|
||
setChecked.setAccessible(true);
|
||
setChecked.invoke(button, Boolean.TRUE, Boolean.TRUE);
|
||
}
|
||
|
||
/**
|
||
* 删除：`un.D()` → `对象.L()` → `un.B()` → 重建树。
|
||
* 返回 true 表示调用链没抛异常（不代表编辑器真的删掉了，删掉与否看树）。
|
||
*/
|
||
public static boolean delete(ClassLoader loader, Object sceneObject) {
|
||
final Object target = sceneObject;
|
||
final ClassLoader classLoader = loader;
|
||
final boolean[] result = new boolean[1];
|
||
onEditorThread(loader, new Runnable() {
|
||
@Override
|
||
public void run() {
|
||
result[0] = deleteNow(classLoader, target);
|
||
}
|
||
});
|
||
return result[0];
|
||
}
|
||
|
||
private static boolean deleteNow(ClassLoader loader, Object sceneObject) {
|
||
if (sceneObject == null) return false;
|
||
try {
|
||
Method remove = findMethod(sceneObject.getClass(), "L", new Class<?>[0], void.class);
|
||
if (remove == null) {
|
||
System.err.println("[crud] 删除失败：" + sceneObject.getClass().getName() + " 上没有 L()V");
|
||
return false;
|
||
}
|
||
Object skeleton = skeletonOf(sceneObject);
|
||
Class<?> undoClass = undoManager(loader);
|
||
undoCall(undoClass, "D");
|
||
remove.setAccessible(true);
|
||
remove.invoke(sceneObject);
|
||
undoCall(undoClass, "B");
|
||
refresh(loader, skeleton);
|
||
System.err.println("[crud] 已删除 " + SceneObjects.kind(sceneObject) + " "
|
||
+ SceneObjects.nameOf(sceneObject));
|
||
return true;
|
||
} catch (Throwable error) {
|
||
System.err.println("[crud] 删除失败: " + error);
|
||
error.printStackTrace(System.err);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
/** 改名：`un.D()` → `对象.D(新名字, true)` → `un.B()` → 重建树。 */
|
||
public static boolean rename(ClassLoader loader, Object sceneObject, String newName) {
|
||
final Object target = sceneObject;
|
||
final String name = newName;
|
||
final ClassLoader classLoader = loader;
|
||
final boolean[] result = new boolean[1];
|
||
onEditorThread(loader, new Runnable() {
|
||
@Override
|
||
public void run() {
|
||
result[0] = renameNow(classLoader, target, name);
|
||
}
|
||
});
|
||
return result[0];
|
||
}
|
||
|
||
private static boolean renameNow(ClassLoader loader, Object sceneObject, String newName) {
|
||
if (sceneObject == null || newName == null || newName.length() == 0) return false;
|
||
try {
|
||
Method setName = findMethod(sceneObject.getClass(), "D",
|
||
new Class<?>[] {String.class, boolean.class}, void.class);
|
||
if (setName == null) {
|
||
System.err.println("[crud] 改名失败：" + sceneObject.getClass().getName()
|
||
+ " 上没有 D(String,boolean)V");
|
||
return false;
|
||
}
|
||
Object skeleton = skeletonOf(sceneObject);
|
||
Class<?> undoClass = undoManager(loader);
|
||
undoCall(undoClass, "D");
|
||
setName.setAccessible(true);
|
||
setName.invoke(sceneObject, newName, Boolean.TRUE);
|
||
undoCall(undoClass, "B");
|
||
refresh(loader, skeleton);
|
||
System.err.println("[crud] 已改名 -> " + newName);
|
||
return true;
|
||
} catch (Throwable error) {
|
||
System.err.println("[crud] 改名失败: " + error);
|
||
error.printStackTrace(System.err);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 重建某个骨架在层级树里的节点（编辑器删除流程里用的就是这个：
|
||
* `VZ.D(LGP;ZZ)V`，见 `vq_0.java:54`）。
|
||
*/
|
||
public static boolean refresh(ClassLoader loader, Object skeleton) {
|
||
if (skeleton == null) return false;
|
||
try {
|
||
Object treeView = SceneObjects.global(loader, SceneObjects.TREE_VIEW);
|
||
Class<?> skeletonClass = Class.forName("GP", true, loader);
|
||
Method rebuild = null;
|
||
for (Method method : treeView.getClass().getDeclaredMethods()) {
|
||
Class<?>[] types = method.getParameterTypes();
|
||
if (types.length != 3 || types[0] != skeletonClass) continue;
|
||
if (types[1] != boolean.class || types[2] != boolean.class) continue;
|
||
rebuild = method;
|
||
break;
|
||
}
|
||
if (rebuild == null) {
|
||
System.err.println("[crud] 刷新失败：VZ 上没有 D(GP,boolean,boolean)V");
|
||
return false;
|
||
}
|
||
System.err.println("[crud] 刷新用方法 " + rebuild.getDeclaringClass().getName() + "."
|
||
+ rebuild.getName() + java.util.Arrays.toString(rebuild.getParameterTypes())
|
||
+ " static=" + Modifier.isStatic(rebuild.getModifiers()));
|
||
rebuild.setAccessible(true);
|
||
// ⚠️ 参数就 3 个（GP, boolean, boolean）：editor 不是参数，别多传。
|
||
rebuild.invoke(treeView, skeleton, Boolean.TRUE, Boolean.TRUE);
|
||
return true;
|
||
} catch (Throwable error) {
|
||
System.err.println("[crud] 刷新失败: " + error);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
/** 找到所属骨架：骨骼是 `Gp.D:LGP;`，骨架自己就是 `GP`。 */
|
||
public static Object skeletonOf(Object sceneObject) {
|
||
if (sceneObject == null) return null;
|
||
if (sceneObject.getClass().getName().equals("GP")) return sceneObject;
|
||
for (Class<?> type = sceneObject.getClass(); type != null && type != Object.class;
|
||
type = type.getSuperclass()) {
|
||
for (Field field : type.getDeclaredFields()) {
|
||
if (!field.getType().getName().equals("GP")) continue;
|
||
try {
|
||
field.setAccessible(true);
|
||
Object value = field.get(sceneObject);
|
||
if (value != null) return value;
|
||
} catch (Throwable ignored) {
|
||
// 跳过
|
||
}
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
|
||
/** 当前选中对象的类型名（给面板显示用）。 */
|
||
public static String selectedKind(ClassLoader loader) {
|
||
try {
|
||
return SceneObjects.kind(SceneObjects.selected(loader));
|
||
} catch (Throwable error) {
|
||
return "?";
|
||
}
|
||
}
|
||
|
||
/** 当前显示在 Tree 视图里的"属性面板控件"类名（诊断用）。 */
|
||
public static String propertyPanelClass(ClassLoader loader) {
|
||
try {
|
||
Object treeView = SceneObjects.global(loader, SceneObjects.TREE_VIEW);
|
||
Object panel = SceneObjects.fieldOfType(treeView, "VY");
|
||
return panel == null ? "null" : panel.getClass().getName();
|
||
} catch (Throwable error) {
|
||
return "err:" + error;
|
||
}
|
||
}
|
||
|
||
/** 按"名字 + 参数 + 返回类型"找实例方法（载荷里同名方法成堆，必须全判）。 */
|
||
static Method findMethod(Class<?> owner, String name, Class<?>[] parameters,
|
||
Class<?> returnType) {
|
||
for (Class<?> type = owner; type != null && type != Object.class;
|
||
type = type.getSuperclass()) {
|
||
for (Method method : type.getDeclaredMethods()) {
|
||
if (!method.getName().equals(name)) continue;
|
||
if (!java.util.Arrays.equals(method.getParameterTypes(), parameters)) continue;
|
||
if (returnType != null && method.getReturnType() != returnType) continue;
|
||
return method;
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
|
||
/** 诊断：把树里每个对象的类型 + 属性面板类名打出来。 */
|
||
static String describePanels(ClassLoader loader) {
|
||
StringBuilder out = new StringBuilder();
|
||
try {
|
||
List<Object> all = SceneObjects.listAllNodes(loader);
|
||
for (Object item : all) {
|
||
out.append(" ").append(SceneObjects.kind(item)).append(' ')
|
||
.append(SceneObjects.nameOf(item));
|
||
// 选中动作必须在编辑器渲染线程上做（否则属性面板不刷新，见 onEditorThread）。
|
||
final Object target = item;
|
||
final String[] info = new String[1];
|
||
onEditorThread(loader, new Runnable() {
|
||
@Override
|
||
public void run() {
|
||
boolean ok = select(loader, target);
|
||
Object selected;
|
||
try {
|
||
selected = SceneObjects.selected(loader);
|
||
} catch (Throwable error) {
|
||
selected = error;
|
||
}
|
||
info[0] = " select=" + ok + " treeSelected="
|
||
+ (selected == null ? "null" : SceneObjects.nameOf(selected))
|
||
+ " panel=" + propertyPanelClass(loader);
|
||
}
|
||
});
|
||
out.append(info[0] == null ? " (no info)" : info[0]);
|
||
out.append('\n');
|
||
}
|
||
} catch (Throwable error) {
|
||
out.append("describePanels failed: ").append(error).append('\n');
|
||
}
|
||
return out.toString();
|
||
}
|
||
|
||
/**
|
||
* 探针：真机跑一遍"选中 → 新建 → 改名 → 删除"，每步都把对象列表打出来。
|
||
* 只用于验证，不参与面板逻辑。
|
||
*/
|
||
/** 探针：走编辑器自己的 `Select - Bones`，用来确认"选中"到底体现在哪。 */
|
||
public static String probeSelect(final ClassLoader loader) {
|
||
final StringBuilder out = new StringBuilder();
|
||
onEditorThread(loader, new Runnable() {
|
||
@Override
|
||
public void run() {
|
||
out.append("before: treeSelected=").append(describeSelection(loader)).append('\n');
|
||
Commands.run(loader, "Select - Bones");
|
||
out.append("after Select - Bones: ").append(describeSelection(loader)).append('\n');
|
||
Object bone = null;
|
||
try {
|
||
bone = findByName(loader, "bone3");
|
||
} catch (Throwable error) {
|
||
out.append("findByName failed: ").append(error).append('\n');
|
||
}
|
||
out.append("select(\"bone3\") = ").append(select(loader, bone)).append('\n');
|
||
out.append("after select: ").append(describeSelection(loader)).append('\n');
|
||
}
|
||
});
|
||
return out.toString();
|
||
}
|
||
|
||
private static String describeSelection(ClassLoader loader) {
|
||
StringBuilder out = new StringBuilder();
|
||
try {
|
||
Object selected = SceneObjects.selected(loader);
|
||
out.append("treeSelected=").append(selected == null ? "null" : SceneObjects.nameOf(selected));
|
||
Object treeView = SceneObjects.global(loader, SceneObjects.TREE_VIEW);
|
||
Object selection = SceneObjects.fieldNamed(treeView, "D", "fC");
|
||
out.append(" selectionItems=").append(selection == null ? "noSelection" : String.valueOf(
|
||
selectionCount(selection)));
|
||
out.append(" lastSelected=").append(selection == null ? "-" : String.valueOf(
|
||
lastSelected(selection)));
|
||
out.append(" panel=").append(propertyPanelClass(loader));
|
||
} catch (Throwable error) {
|
||
out.append(" describeSelection failed: ").append(error);
|
||
}
|
||
return out.toString();
|
||
}
|
||
|
||
private static int selectionCount(Object selection) {
|
||
try {
|
||
Method items = findMethod(selection.getClass(), "D", new Class<?>[0],
|
||
Class.forName("fI", true, selection.getClass().getClassLoader()));
|
||
if (items == null) return -1;
|
||
items.setAccessible(true);
|
||
Object array = items.invoke(selection);
|
||
Object[] values = SceneObjects.arrayItems(array);
|
||
return values.length;
|
||
} catch (Throwable error) {
|
||
return -2;
|
||
}
|
||
}
|
||
|
||
private static String lastSelected(Object selection) {
|
||
try {
|
||
Method last = findMethod(selection.getClass(), "D", new Class<?>[0], Object.class);
|
||
if (last == null) return "?";
|
||
last.setAccessible(true);
|
||
Object value = last.invoke(selection);
|
||
if (value == null) return "null";
|
||
Object object = SceneObjects.nodeObject(value);
|
||
return object == null ? String.valueOf(value) : SceneObjects.nameOf(object);
|
||
} catch (Throwable error) {
|
||
return "err:" + error;
|
||
}
|
||
}
|
||
|
||
public static String probeCrud(ClassLoader loader) {
|
||
StringBuilder out = new StringBuilder();
|
||
try {
|
||
out.append("--- before ---\n").append(listNames(loader));
|
||
Object parent = findByName(loader, "bone");
|
||
out.append("parent = ").append(parent == null ? "null" : SceneObjects.kind(parent)
|
||
+ " " + SceneObjects.nameOf(parent)).append('\n');
|
||
if (parent == null) return out.toString();
|
||
select(loader, parent);
|
||
out.append("parent panel = ").append(propertyPanelClass(loader)).append('\n');
|
||
|
||
out.append("--- create New Bone under ").append(SceneObjects.nameOf(parent)).append(" ---\n");
|
||
boolean created = create(loader, parent, "Bone");
|
||
sleep(400);
|
||
out.append("created=").append(created).append('\n').append(listNames(loader));
|
||
|
||
Object fresh = findByName(loader, "bone3");
|
||
out.append("fresh = ").append(fresh == null ? "null" : SceneObjects.nameOf(fresh))
|
||
.append('\n');
|
||
if (fresh != null) {
|
||
out.append("--- rename -> panel_test ---\n");
|
||
boolean renamed = rename(loader, fresh, "panel_test");
|
||
sleep(400);
|
||
out.append("renamed=").append(renamed).append('\n').append(listNames(loader));
|
||
Object renamedObject = findByName(loader, "panel_test");
|
||
if (renamedObject != null) {
|
||
out.append("--- delete panel_test ---\n");
|
||
boolean deleted = delete(loader, renamedObject);
|
||
sleep(400);
|
||
out.append("deleted=").append(deleted).append('\n').append(listNames(loader));
|
||
}
|
||
}
|
||
} catch (Throwable error) {
|
||
out.append("probeCrud failed: ").append(error).append('\n');
|
||
error.printStackTrace(System.err);
|
||
}
|
||
return out.toString();
|
||
}
|
||
|
||
private static String listNames(ClassLoader loader) throws Exception {
|
||
StringBuilder out = new StringBuilder();
|
||
for (Object item : SceneObjects.listAllNodes(loader)) {
|
||
out.append(" ").append(SceneObjects.kind(item)).append(' ')
|
||
.append(SceneObjects.nameOf(item)).append('\n');
|
||
}
|
||
return out.toString();
|
||
}
|
||
|
||
/** 按名字在树里找一个场景对象。 */
|
||
static Object findByName(ClassLoader loader, String name) throws Exception {
|
||
for (Object item : SceneObjects.listAllNodes(loader)) {
|
||
if (name.equals(SceneObjects.nameOf(item))) return item;
|
||
}
|
||
return null;
|
||
}
|
||
|
||
private static void sleep(long millis) {
|
||
try {
|
||
Thread.sleep(millis);
|
||
} catch (InterruptedException ignored) {
|
||
Thread.currentThread().interrupt();
|
||
}
|
||
}
|
||
|
||
// ==================== 综合矩阵测试：骨骼 / 插槽 / 附件 的增删改查 + 同名规则 ====================
|
||
|
||
/**
|
||
* 一次跑完三类对象的增删改查与同名规则，把每一步的**事实**打出来（不做断言）。
|
||
*
|
||
* 三类对象的模型 API 不一样，这正是要测的点：
|
||
* - 骨骼：`GP.D(String)LGp;`（按名字查，全局唯一）
|
||
* - 插槽：`GP.D(String)LGU;`（按名字查，全局唯一）
|
||
* - 附件：`GP.D(LGU;String)LGn;`（**先按插槽、再按名字**查 —— 附件名只在自己插槽内唯一）
|
||
*/
|
||
public static String probeMatrix(final ClassLoader loader) {
|
||
final StringBuilder out = new StringBuilder();
|
||
// ⚠️ 不要整段包 onEditorThread：编辑器有些创建是"投递到下一帧"再做的，
|
||
// 而 onEditorThread 会一直占着渲染线程等我们返回，帧就跑不起来、对象永远建不出来。
|
||
// 所以：每一步各自切渲染线程（select/create/delete 内部已经切了），sleep 留在本线程。
|
||
{
|
||
try {
|
||
out.append("== initial ==\n").append(names(loader));
|
||
|
||
// ---- 骨骼 ----
|
||
out.append("\n== bone ==\n");
|
||
Object bone = findByName(loader, "bone");
|
||
Object created = createAndReport(loader, bone, "Bone", out, "New Bone");
|
||
Object created2 = createAndReport(loader, bone, "Bone", out, "New Bone#2");
|
||
out.append(" names like bone*: ").append(countNames(loader, "bone", "bone")).append('\n');
|
||
if (created2 != null) {
|
||
// 重名：把第二个新建的骨骼改成第一个的名字
|
||
boolean renamed = rename(loader, created2, SceneObjects.nameOf(created));
|
||
sleep(200);
|
||
out.append(" rename(").append(SceneObjects.nameOf(created2)).append(" -> ")
|
||
.append(SceneObjects.nameOf(created)).append(") = ").append(renamed)
|
||
.append("; 现在叫 ").append(SceneObjects.nameOf(created2))
|
||
.append("; 同名骨骼数=").append(countNames(loader, "bone",
|
||
SceneObjects.nameOf(created))).append('\n');
|
||
}
|
||
// 按名字查（模型 API）
|
||
Object skeleton = findByName(loader, "skeleton");
|
||
out.append(" getBone(\"").append(SceneObjects.nameOf(created)).append("\") = ")
|
||
.append(describe(lookup(skeleton, "Gp", SceneObjects.nameOf(created)))).append('\n');
|
||
out.append(" getBone(\"no_such_bone\") = ")
|
||
.append(describe(lookup(skeleton, "Gp", "no_such_bone"))).append('\n');
|
||
// 删除
|
||
if (created != null) {
|
||
boolean ok = delete(loader, created);
|
||
sleep(200);
|
||
out.append(" delete(").append(SceneObjects.nameOf(created)).append(") = ").append(ok)
|
||
.append("; 还在吗=").append(findByName(loader, SceneObjects.nameOf(created)) != null)
|
||
.append('\n');
|
||
}
|
||
|
||
// ---- 插槽 ----
|
||
out.append("\n== slot ==\n");
|
||
Object slot = createAndReport(loader, bone, "Slot", out, "New Slot");
|
||
Object slot2 = createAndReport(loader, bone, "Slot", out, "New Slot#2");
|
||
if (slot != null) {
|
||
out.append(" getSlot(\"").append(SceneObjects.nameOf(slot)).append("\") = ")
|
||
.append(describe(lookup(skeleton, "GU", SceneObjects.nameOf(slot)))).append('\n');
|
||
}
|
||
if (slot2 != null && slot != null) {
|
||
boolean renamed = rename(loader, slot2, SceneObjects.nameOf(slot));
|
||
sleep(200);
|
||
out.append(" rename(slot2 -> \"").append(SceneObjects.nameOf(slot)).append("\") = ")
|
||
.append(renamed).append("; 现在叫 ").append(SceneObjects.nameOf(slot2))
|
||
.append("; 同名插槽数=").append(countNames(loader, "slot",
|
||
SceneObjects.nameOf(slot))).append('\n');
|
||
}
|
||
|
||
// ---- 附件（挂在插槽下）----
|
||
out.append("\n== attachment ==\n");
|
||
if (slot != null) {
|
||
out.append(" select slot ").append(SceneObjects.nameOf(slot)).append(" = ")
|
||
.append(select(loader, slot)).append('\n');
|
||
sleep(200);
|
||
Object att1 = createAndReport(loader, slot, "Bounding Box", out, "New Bounding Box");
|
||
Object att2 = createAndReport(loader, slot, "Path", out, "New Path");
|
||
if (att1 != null && att2 != null) {
|
||
out.append(" attachment 类: ").append(att1.getClass().getName()).append(" / ")
|
||
.append(att2.getClass().getName()).append('\n');
|
||
boolean renamed = rename(loader, att2, SceneObjects.nameOf(att1));
|
||
sleep(200);
|
||
out.append(" rename(att2 -> \"").append(SceneObjects.nameOf(att1))
|
||
.append("\") = ").append(renamed).append("; att2 现在叫 ")
|
||
.append(SceneObjects.nameOf(att2)).append('\n');
|
||
out.append(" getAttachment(slot,\"").append(SceneObjects.nameOf(att1))
|
||
.append("\") = ")
|
||
.append(describe(lookupAttachment(skeleton, slot, SceneObjects.nameOf(att1))))
|
||
.append('\n');
|
||
out.append(" delete(att1) = ").append(delete(loader, att1)).append('\n');
|
||
sleep(200);
|
||
}
|
||
}
|
||
|
||
// ---- 跨类型同名 ----
|
||
out.append("\n== cross-type duplicate names ==\n");
|
||
if (slot != null && bone != null) {
|
||
boolean renamed = rename(loader, slot, SceneObjects.nameOf(bone));
|
||
sleep(200);
|
||
out.append(" rename(slot -> bone 的名字 \"").append(SceneObjects.nameOf(bone))
|
||
.append("\") = ").append(renamed).append("; slot 现在叫 ")
|
||
.append(SceneObjects.nameOf(slot)).append('\n');
|
||
}
|
||
out.append("\n== final ==\n").append(names(loader));
|
||
} catch (Throwable error) {
|
||
out.append("probeMatrix failed: ").append(error).append('\n');
|
||
error.printStackTrace(System.err);
|
||
}
|
||
}
|
||
return out.toString();
|
||
}
|
||
|
||
/** 建一个对象并把"新建前后的差集"报出来。 */
|
||
private static Object createAndReport(ClassLoader loader, Object parent, String type,
|
||
StringBuilder out, String label) {
|
||
try {
|
||
List<Object> before = SceneObjects.listAllNodes(loader);
|
||
// 会弹名字对话框的那几种，先把名字准备好（bone 不用，编辑器自己编号）。
|
||
if (!type.equals("Bone")) {
|
||
nextName(type.toLowerCase().replace(' ', '_') + "_probe"
|
||
+ (System.nanoTime() % 1000));
|
||
}
|
||
boolean ok = create(loader, parent, type);
|
||
sleep(300);
|
||
List<Object> after = SceneObjects.listAllNodes(loader);
|
||
Object fresh = null;
|
||
for (Object item : after) {
|
||
boolean seen = false;
|
||
for (Object old : before) {
|
||
if (old == item) {
|
||
seen = true;
|
||
break;
|
||
}
|
||
}
|
||
if (!seen) {
|
||
fresh = item;
|
||
break;
|
||
}
|
||
}
|
||
out.append(" ").append(label).append("(parent=").append(SceneObjects.nameOf(parent))
|
||
.append(") -> ok=").append(ok).append(" new=")
|
||
.append(fresh == null ? "null" : fresh.getClass().getName() + " \""
|
||
+ SceneObjects.nameOf(fresh) + "\"")
|
||
.append('\n');
|
||
return fresh;
|
||
} catch (Throwable error) {
|
||
out.append(" ").append(label).append(" failed: ").append(error).append('\n');
|
||
return null;
|
||
}
|
||
}
|
||
|
||
/** 模型层的按名字查：骨骼 `GP.D(String)LGp;` / 插槽 `GP.D(String)LGU;`。 */
|
||
static Object lookup(Object skeleton, String typeName, String name) {
|
||
if (skeleton == null) return null;
|
||
for (Method method : skeleton.getClass().getMethods()) {
|
||
Class<?>[] types = method.getParameterTypes();
|
||
if (types.length != 1 || types[0] != String.class) continue;
|
||
if (!method.getReturnType().getName().equals(typeName)) continue;
|
||
try {
|
||
method.setAccessible(true);
|
||
return method.invoke(skeleton, name);
|
||
} catch (Throwable ignored) {
|
||
// 换下一个
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
|
||
/** 附件的按名字查要连插槽一起给：`GP.D(LGU;Ljava/lang/String;)LGn;`。 */
|
||
static Object lookupAttachment(Object skeleton, Object slot, String name) {
|
||
if (skeleton == null || slot == null) return null;
|
||
for (Method method : skeleton.getClass().getMethods()) {
|
||
Class<?>[] types = method.getParameterTypes();
|
||
if (types.length != 2 || types[0] != slot.getClass()) continue;
|
||
if (types[1] != String.class) continue;
|
||
try {
|
||
method.setAccessible(true);
|
||
return method.invoke(skeleton, slot, name);
|
||
} catch (Throwable ignored) {
|
||
// 换下一个
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
|
||
private static String describe(Object object) {
|
||
return object == null ? "null" : object.getClass().getName() + " \""
|
||
+ SceneObjects.nameOf(object) + "\"";
|
||
}
|
||
|
||
private static String names(ClassLoader loader) throws Exception {
|
||
StringBuilder out = new StringBuilder();
|
||
for (Object item : SceneObjects.listAllNodes(loader)) {
|
||
String kind = SceneObjects.kind(item);
|
||
if (kind.equals("skeleton") || kind.equals("bone") || kind.equals("slot")
|
||
|| kind.equals("attachment")) {
|
||
out.append(" ").append(kind).append(" \"").append(SceneObjects.nameOf(item))
|
||
.append("\"\n");
|
||
}
|
||
}
|
||
return out.toString();
|
||
}
|
||
|
||
private static int countNames(ClassLoader loader, String kind, String name) throws Exception {
|
||
int count = 0;
|
||
for (Object item : SceneObjects.listAllNodes(loader)) {
|
||
if (!SceneObjects.kind(item).equals(kind)) continue;
|
||
if (SceneObjects.nameOf(item).equals(name)) count++;
|
||
}
|
||
return count;
|
||
}
|
||
|
||
// ==================== 直接模型 API：新建骨骼（不经 UI 菜单、不依赖下一帧） ====================
|
||
//
|
||
// 编辑器自己的"新建骨骼"代码就在 `Yi.run()` 里，去掉 UI 后本质是：
|
||
// new Gp() → 设 name/parent/skeleton/x/y/color → 骨架.D(骨骼) ← GP 上的 (LGp;)V = addBone
|
||
// → 骨架.StackMapTable() ← 重建索引 → Editor.D(骨骼, true) → VZ.D(骨架, true, true) 重建树
|
||
// 一次调用可以连建 N 根，最后只刷新一次；外层包 un.D()/un.B() 就是"一次撤销"。
|
||
|
||
/** 直接建一根骨骼（返回新骨骼对象；失败返回 null）。 */
|
||
public static Object createBone(ClassLoader loader, Object skeleton, Object parent, String name,
|
||
float x, float y, Object color) {
|
||
try {
|
||
System.err.println("[crud] createBone step1 new Gp " + skeleton + " parent=" + parent);
|
||
Class<?> boneClass = Class.forName("Gp", true, loader);
|
||
Object bone = boneClass.getConstructor().newInstance();
|
||
setByType(bone, "GP", skeleton);
|
||
if (parent != null) setByType(bone, "Gp", parent);
|
||
setByNameType(bone, "D", String.class, name);
|
||
setByNameType(bone, "Z", float.class, Float.valueOf(x));
|
||
setByNameType(bone, "V", float.class, Float.valueOf(y));
|
||
if (color != null) setByNameType(bone, "B",
|
||
Class.forName("com.badlogic.gdx.graphics.Color", true, loader), color);
|
||
System.err.println("[crud] createBone step2 fields ok");
|
||
|
||
// 骨架.D(骨骼)：GP 上的 (LGp;)V
|
||
Method addBone = findMethod(skeleton.getClass(), "D", new Class<?>[] {boneClass}, void.class);
|
||
if (addBone == null) throw new NoSuchMethodException("GP.D(LGp;)V addBone");
|
||
addBone.setAccessible(true);
|
||
System.err.println("[crud] createBone step3 " + addBone.getDeclaringClass().getName() + "."
|
||
+ addBone.getName() + "(Gp) 调用中");
|
||
addBone.invoke(skeleton, bone);
|
||
System.err.println("[crud] createBone step3 ok");
|
||
|
||
// 骨架.StackMapTable()：重建索引
|
||
Method rebuild = null;
|
||
for (Method m : skeleton.getClass().getMethods()) {
|
||
if (m.getName().equals("StackMapTable") && m.getParameterTypes().length == 0
|
||
&& m.getReturnType() == void.class) {
|
||
rebuild = m;
|
||
break;
|
||
}
|
||
}
|
||
if (rebuild != null) {
|
||
rebuild.setAccessible(true);
|
||
rebuild.invoke(skeleton);
|
||
}
|
||
|
||
// Editor.D(骨骼, true)：通知编辑器（找不到就跳过，不影响模型）
|
||
try {
|
||
Class<?> editorClass = Class.forName("com.esotericsoftware.spine.editor.Editor", true, loader);
|
||
Method notify = findMethod(editorClass, "D", new Class<?>[] {boneClass, boolean.class},
|
||
void.class);
|
||
Object editor = SceneObjects.global(loader, "com.esotericsoftware.spine.editor.Editor");
|
||
if (notify != null && editor != null) {
|
||
notify.setAccessible(true);
|
||
notify.invoke(editor, bone, Boolean.TRUE);
|
||
}
|
||
} catch (Throwable error) {
|
||
System.err.println("[crud] Editor.D(bone,true) 跳过: " + error);
|
||
}
|
||
return bone;
|
||
} catch (Throwable error) {
|
||
System.err.println("[crud] createBone 失败: " + error);
|
||
Throwable cause = error;
|
||
while (cause != null) {
|
||
System.err.println("[crud] cause: " + cause);
|
||
cause.printStackTrace(System.err);
|
||
cause = cause.getCause();
|
||
}
|
||
return null;
|
||
}
|
||
}
|
||
|
||
/** 按字段类型写（用于 D:LGP; / D:LGp; 这种同名不同描述符的坑）。 */
|
||
static void setByType(Object target, String typeName, Object value) throws Exception {
|
||
for (Class<?> type = target.getClass(); type != null && type != Object.class;
|
||
type = type.getSuperclass()) {
|
||
for (Field field : type.getDeclaredFields()) {
|
||
if (!field.getType().getName().equals(typeName)) continue;
|
||
field.setAccessible(true);
|
||
field.set(target, value);
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
|
||
/** 按"名字 + 类型"写字段。 */
|
||
static void setByNameType(Object target, String name, Class<?> fieldType, Object value)
|
||
throws Exception {
|
||
for (Class<?> type = target.getClass(); type != null && type != Object.class;
|
||
type = type.getSuperclass()) {
|
||
for (Field field : type.getDeclaredFields()) {
|
||
if (!field.getName().equals(name) || field.getType() != fieldType) continue;
|
||
field.setAccessible(true);
|
||
field.set(target, value);
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
}
|