3fc59887d5
The under-fog check lays a floor under the dust so the march has a finite ray (pixels with no depth are fogged whole), disables the zone noise, and uses a dim uniform fill: the correct event dims the dust to 0.58 of fog-free, and dust drawn after the composite reads 0.99. The check also fails when the dust is erased (below 0.1) or missing with the fog off. The attach check reads Stardust.DrawEvent by reflection and requires no Stardust buffer at any other CameraEvent. Builds. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
392 lines
23 KiB
C#
392 lines
23 KiB
C#
using System;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using UnityEditor;
|
|
using UnityEditor.SceneManagement;
|
|
using UnityEngine;
|
|
using UnityEngine.Rendering;
|
|
|
|
namespace Aetheria.EditorTools
|
|
{
|
|
/// <summary>
|
|
/// Batchmode check for the flow as the scene runs it (campaign aetheria-fauna, cut fauna-flow-field; target
|
|
/// invariants flow-one-owner and flow-shader-parity). FlowFieldParityVerify proves the HLSL against FlowField with
|
|
/// no scene loaded; this opens ARPG.unity, lets VolumeSampling and Stardust initialise as the game does, drives
|
|
/// their own Start and Update with a zone attached, and asserts what the presenters did:
|
|
/// - nothing threw and nothing logged an error (a type that cannot initialise in a scene, as VolumeSampling once
|
|
/// could when it created its keywords in a static field initializer, throws on its first use);
|
|
/// - FLOW_GLOBAL and FLOW_SLOPE are enabled, _FlowAmplitude is the zone's, and the nebula noise clock is the zone's;
|
|
/// - the stardust particle buffer changes with the flow and freezes when the zone pauses;
|
|
/// - CloudShader pass 0 carries the FLOW_* keywords.
|
|
/// The scene is opened before any Aetheria type is touched: run this method alone in its own Unity session, never
|
|
/// after FlowFieldParityVerify (which would initialise VolumeSampling outside a MonoBehaviour constructor).
|
|
/// Dispatches compute and renders, so it needs a graphics device: run WITHOUT -nographics.
|
|
/// Unity -batchmode -projectPath <repo> -executeMethod Aetheria.EditorTools.FlowFieldSceneVerify.Run -logFile <path>
|
|
/// Do not pass -quit: Run exits the Editor itself, 0 on success and 1 on any failure.
|
|
/// </summary>
|
|
public static class FlowFieldSceneVerify
|
|
{
|
|
const string Tag = "[FlowFieldSceneVerify]";
|
|
static bool _ok = true;
|
|
|
|
static void OnLog(string message, string stack, LogType type)
|
|
{
|
|
if ((type == LogType.Error || type == LogType.Exception || type == LogType.Assert) && !message.StartsWith(Tag))
|
|
Fail("logged-error", message.Split('\n')[0]);
|
|
}
|
|
|
|
static void Fail(string check, string detail)
|
|
{
|
|
Debug.LogError($"{Tag} FAIL {check}: {detail}");
|
|
_ok = false;
|
|
}
|
|
|
|
public static void Run()
|
|
{
|
|
if (SystemInfo.graphicsDeviceType == GraphicsDeviceType.Null)
|
|
{
|
|
Debug.LogError($"{Tag} FAIL: no graphics device in this session; rerun batchmode without -nographics.");
|
|
EditorApplication.Exit(1);
|
|
return;
|
|
}
|
|
|
|
Application.logMessageReceived += OnLog;
|
|
try
|
|
{
|
|
// Before anything else touches the project's types: the scene constructs its MonoBehaviours here.
|
|
EditorSceneManager.OpenScene("Assets/Scenes/ARPG.unity", OpenSceneMode.Single);
|
|
Check();
|
|
Debug.Log(_ok ? $"{Tag} PASS" : $"{Tag} FAIL: see errors above");
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Debug.LogError($"{Tag} FAIL exception: {e}");
|
|
_ok = false;
|
|
}
|
|
finally
|
|
{
|
|
Application.logMessageReceived -= OnLog;
|
|
}
|
|
EditorApplication.Exit(_ok ? 0 : 1);
|
|
}
|
|
|
|
static void Check()
|
|
{
|
|
var settings = AssetDatabase.LoadAssetAtPath<GameSettings>("Assets/Resources/Settings.asset")
|
|
?? throw new InvalidOperationException("No Settings.asset.");
|
|
var agm = UnityEngine.Object.FindObjectsByType<ActionGameManager>(FindObjectsInactive.Include, FindObjectsSortMode.None).FirstOrDefault();
|
|
var volume = UnityEngine.Object.FindObjectsByType<VolumeSampling>(FindObjectsInactive.Include, FindObjectsSortMode.None).FirstOrDefault();
|
|
var dust = UnityEngine.Object.FindObjectsByType<Stardust>(FindObjectsInactive.Include, FindObjectsSortMode.None).FirstOrDefault();
|
|
if (agm == null || volume == null || dust == null)
|
|
{
|
|
Fail("scene-objects", $"ARPG.unity has ActionGameManager={agm != null}, VolumeSampling={volume != null}, Stardust={dust != null}");
|
|
return;
|
|
}
|
|
|
|
// Every flow term live, so FLOW_SLOPE is on; and the same flow with every amplitude zero.
|
|
var on = new FlowSettings
|
|
{
|
|
GlobalScale = 512f, GlobalAmplitude = 15f, GlobalScrollSpeed = .025f, Period = 8f, SlopeAmplitude = 3f, SwirlAmplitude = 5f
|
|
};
|
|
var off = new FlowSettings { GlobalScale = on.GlobalScale, GlobalScrollSpeed = on.GlobalScrollSpeed, Period = on.Period };
|
|
var work = Path.Combine(Path.GetTempPath(), "flow-scene-" + Guid.NewGuid().ToString("N"));
|
|
Directory.CreateDirectory(work);
|
|
try
|
|
{
|
|
var zone = FlowFieldParityVerify.BuildZone(settings, work, on, 86400.0 * 3 + 12.3);
|
|
typeof(ActionGameManager).GetProperty("Instance").GetSetMethod(true).Invoke(null, new object[] { agm });
|
|
typeof(ActionGameManager).GetProperty("Zone").GetSetMethod(true).Invoke(agm, new object[] { zone });
|
|
if (agm.Settings == null) agm.Settings = settings;
|
|
|
|
Call(volume, "Start");
|
|
Call(volume, "Update");
|
|
if (!Shader.IsKeywordEnabled("FLOW_GLOBAL")) Fail("scene-keywords", "FLOW_GLOBAL is not enabled after VolumeSampling.Update");
|
|
if (!Shader.IsKeywordEnabled("FLOW_SLOPE")) Fail("scene-keywords", "FLOW_SLOPE is not enabled after VolumeSampling.Update");
|
|
if (Shader.GetGlobalFloat("_FlowAmplitude") != on.GlobalAmplitude)
|
|
Fail("scene-amplitude", $"_FlowAmplitude is {Shader.GetGlobalFloat("_FlowAmplitude")}, the zone's flow has {on.GlobalAmplitude}");
|
|
var scroll = Shader.GetGlobalVector("_FlowScroll");
|
|
if (scroll.x != zone.FlowScroll.x || scroll.y != zone.FlowScroll.y)
|
|
Fail("scene-scroll", $"_FlowScroll ({scroll.x}, {scroll.y}) is not the zone's ({zone.FlowScroll.x}, {zone.FlowScroll.y})");
|
|
var noiseTime = Shader.GetGlobalFloat("_NebulaNoiseTime");
|
|
if (noiseTime != (float) zone.ExactTime)
|
|
Fail("scene-noise-clock", $"_NebulaNoiseTime is {noiseTime}, the zone's time is {(float) zone.ExactTime}");
|
|
|
|
CheckCloudKeywords();
|
|
|
|
// Stardust follows the flow through its own dispatch: the particle buffer read back each frame.
|
|
Call(dust, "Start");
|
|
var bufferField = typeof(Stardust).GetField("_particlesBuffer", BindingFlags.NonPublic | BindingFlags.Instance);
|
|
float[] Frame()
|
|
{
|
|
Call(dust, "Update");
|
|
var buffer = (ComputeBuffer) bufferField.GetValue(dust);
|
|
var data = new float[buffer.count * 7];
|
|
buffer.GetData(data);
|
|
return data;
|
|
}
|
|
var flowing = Frame();
|
|
VolumeSampling.LowerFlow(off, VolumeSampling.FlowClock);
|
|
var still = Frame();
|
|
if (Differing(flowing, still) == 0) Fail("scene-stardust", "the particle buffer is the same with the zone's flow and with no flow");
|
|
|
|
// A paused zone freezes the particles and the nebula noise clock; a running one moves both.
|
|
Call(volume, "Update");
|
|
zone.Update(0f);
|
|
Call(volume, "Update");
|
|
if (Differing(flowing, Frame()) != 0) Fail("scene-stardust-pause", "the particle buffer moved while the zone was paused");
|
|
if (Shader.GetGlobalFloat("_NebulaNoiseTime") != noiseTime) Fail("scene-noise-clock", "_NebulaNoiseTime moved while the zone was paused");
|
|
zone.Update(.05f);
|
|
Call(volume, "Update");
|
|
if (Differing(flowing, Frame()) == 0) Fail("scene-stardust-run", "the particle buffer did not move while the zone ran");
|
|
if (Shader.GetGlobalFloat("_NebulaNoiseTime") == noiseTime) Fail("scene-noise-clock", "_NebulaNoiseTime did not move while the zone ran");
|
|
|
|
CheckStardustUncullable(dust, bufferField);
|
|
CheckStardustUnderFog(dust, bufferField);
|
|
}
|
|
finally
|
|
{
|
|
try { Directory.Delete(work, true); } catch { }
|
|
}
|
|
}
|
|
|
|
// The event Stardust itself attaches its draw at, read from the class so the verifier cannot agree with a copy of it.
|
|
static CameraEvent DrawEvent() =>
|
|
(CameraEvent) typeof(Stardust).GetField("DrawEvent", BindingFlags.NonPublic | BindingFlags.Static).GetRawConstantValue();
|
|
|
|
// The dust is a command buffer on the target camera, which no culling sees: with every particle 10000 below the
|
|
// camera (far past any box a hand could inflate round it) a render still shows dust, and shows none when the
|
|
// same particles have no size.
|
|
static void CheckStardustUncullable(Stardust dust, FieldInfo bufferField)
|
|
{
|
|
var camera = dust.TargetCamera;
|
|
if (camera == null) { Fail("scene-stardust-uncullable", "Stardust has no TargetCamera"); return; }
|
|
var drawEvent = DrawEvent();
|
|
var attached = camera.GetCommandBuffers(drawEvent).Count(buffer => buffer.name == "Stardust");
|
|
if (attached != 1) Fail("scene-stardust-uncullable", $"{attached} Stardust command buffers at {drawEvent} on the target camera, expected 1");
|
|
foreach (var other in Enum.GetValues(typeof(CameraEvent)).Cast<CameraEvent>().Where(other => other != drawEvent))
|
|
{
|
|
var stray = camera.GetCommandBuffers(other).Count(buffer => buffer.name == "Stardust");
|
|
if (stray != 0) Fail("scene-stardust-uncullable", $"{stray} Stardust command buffers at {other}, expected 0");
|
|
}
|
|
|
|
var particles = (ComputeBuffer) bufferField.GetValue(dust);
|
|
float[] Layout(float size, Vector3 centre, float below) => DustLayout(particles.count, size, centre, below);
|
|
|
|
var transform = camera.transform;
|
|
var (position, rotation) = (transform.position, transform.rotation);
|
|
var (far, flags, background, mask, target) = (camera.farClipPlane, camera.clearFlags, camera.backgroundColor, camera.cullingMask, camera.targetTexture);
|
|
var texture = RenderTexture.GetTemporary(64, 64, 24, RenderTextureFormat.ARGB32);
|
|
var readback = new Texture2D(64, 64, TextureFormat.RGBA32, false);
|
|
var previous = RenderTexture.active;
|
|
// Image effects on the camera would write their own frame over the dust; only the dust draw is under test.
|
|
var effects = camera.GetComponents<MonoBehaviour>().Where(behaviour => behaviour.enabled).ToArray();
|
|
Color32[] Render(float size, Vector3 centre, float below)
|
|
{
|
|
Call(dust, "Update"); // on a bounded draw this queues the draw for the camera; here it dispatches the compute
|
|
particles.SetData(Layout(size, centre, below));
|
|
camera.Render();
|
|
RenderTexture.active = texture;
|
|
readback.ReadPixels(new Rect(0, 0, 64, 64), 0, 0);
|
|
readback.Apply();
|
|
return readback.GetPixels32();
|
|
}
|
|
try
|
|
{
|
|
foreach (var effect in effects) effect.enabled = false;
|
|
camera.clearFlags = CameraClearFlags.SolidColor;
|
|
camera.backgroundColor = Color.black;
|
|
camera.cullingMask = 1;
|
|
camera.targetTexture = texture;
|
|
// control: the camera where the scene put it, dust 100 below, inside any box a hand-set extent would give
|
|
transform.SetPositionAndRotation(position, Quaternion.Euler(90f, 0f, 0f));
|
|
camera.farClipPlane = 1000f;
|
|
var nearWith = Render(5f, position, 100f); var nearWithout = Render(0f, position, 100f);
|
|
var nearDiff = 0; for (var i = 0; i < nearWith.Length; i++) if (!nearWith[i].Equals(nearWithout[i])) nearDiff++;
|
|
Debug.Log($"{Tag} stardust near-control differing pixels={nearDiff}");
|
|
if (nearDiff == 0) Fail("scene-stardust-uncullable", "control: dust 100 below the camera drew no pixels");
|
|
transform.SetPositionAndRotation(new Vector3(0f, -40000f, 0f), Quaternion.Euler(90f, 0f, 0f));
|
|
camera.farClipPlane = 30000f;
|
|
var withDust = Render(400f, transform.position, 10000f); // the material scales a quad by distance^.33, so at this range it needs this size to cover pixels
|
|
var without = Render(0f, transform.position, 10000f);
|
|
var differing = 0;
|
|
for (var i = 0; i < withDust.Length; i++)
|
|
if (!withDust[i].Equals(without[i])) differing++;
|
|
if (differing == 0) Fail("scene-stardust-uncullable", "the dust 10000 below the camera drew no pixels");
|
|
}
|
|
finally
|
|
{
|
|
RenderTexture.active = previous;
|
|
foreach (var effect in effects) effect.enabled = true;
|
|
camera.targetTexture = target;
|
|
camera.cullingMask = mask;
|
|
camera.backgroundColor = background;
|
|
camera.clearFlags = flags;
|
|
camera.farClipPlane = far;
|
|
transform.SetPositionAndRotation(position, rotation);
|
|
RenderTexture.ReleaseTemporary(texture);
|
|
UnityEngine.Object.DestroyImmediate(readback);
|
|
}
|
|
}
|
|
|
|
// The nebula is an [ImageEffectOpaque] that fogs the whole ray to a depth the dust never writes (B49): dust drawn
|
|
// before it is attenuated by the fog, dust drawn after it sits on top at full strength. The dust's contribution to a
|
|
// pixel (render with dust minus render without) is read with the cloud renderer off and on, in an HDR target.
|
|
static void CheckStardustUnderFog(Stardust dust, FieldInfo bufferField)
|
|
{
|
|
const int Size = 128;
|
|
var camera = dust.TargetCamera;
|
|
var cloud = camera == null ? null : camera.GetComponent<VolumeCloudRenderer>();
|
|
if (cloud == null) { Fail("scene-stardust-under-fog", "the target camera has no VolumeCloudRenderer"); return; }
|
|
var particles = (ComputeBuffer) bufferField.GetValue(dust);
|
|
|
|
var transform = camera.transform;
|
|
var (position, rotation) = (transform.position, transform.rotation);
|
|
var (far, flags, background, mask, target, hdr) = (camera.farClipPlane, camera.clearFlags, camera.backgroundColor, camera.cullingMask, camera.targetTexture, camera.allowHDR);
|
|
var texture = RenderTexture.GetTemporary(Size, Size, 24, RenderTextureFormat.ARGBHalf);
|
|
var readback = new Texture2D(Size, Size, TextureFormat.RGBAHalf, false);
|
|
var previous = RenderTexture.active;
|
|
var effects = camera.GetComponents<MonoBehaviour>().Where(behaviour => behaviour.enabled).ToArray();
|
|
var fields = new System.Collections.Generic.List<Texture2D>();
|
|
GameObject floor = null;
|
|
float[] Render(bool fog, float size)
|
|
{
|
|
cloud.enabled = fog;
|
|
for (var frame = 0; frame < 2; frame++) // the cloud's first frame forces ULTRA and fills its history; the second is the settled one
|
|
{
|
|
Call(dust, "Update");
|
|
particles.SetData(DustLayout(particles.count, size, position, 100f));
|
|
camera.Render();
|
|
}
|
|
RenderTexture.active = texture;
|
|
readback.ReadPixels(new Rect(0, 0, Size, Size), 0, 0);
|
|
readback.Apply();
|
|
return readback.GetPixels().Select(pixel => pixel.r * .2126f + pixel.g * .7152f + pixel.b * .0722f).ToArray();
|
|
}
|
|
try
|
|
{
|
|
foreach (var effect in effects) effect.enabled = false;
|
|
camera.allowHDR = true;
|
|
camera.clearFlags = CameraClearFlags.SolidColor;
|
|
camera.backgroundColor = Color.black;
|
|
camera.cullingMask = 1;
|
|
camera.targetTexture = texture;
|
|
camera.farClipPlane = 1000f;
|
|
transform.SetPositionAndRotation(position, Quaternion.Euler(90f, 0f, 0f));
|
|
// The fog only measures a partial density where depth is written: a pixel with no depth is fogged whole (CloudShader sets
|
|
// density 1 past the far plane). A floor under the dust gives the march a finite ray.
|
|
floor = GameObject.CreatePrimitive(PrimitiveType.Plane);
|
|
floor.transform.position = position + Vector3.down * 200f;
|
|
floor.transform.localScale = Vector3.one * 100f;
|
|
UnityEngine.Object.DestroyImmediate(floor.GetComponent<Collider>());
|
|
|
|
// The scene's own nebula fields are textures the game renders; here a uniform fill of white fog stands in for them.
|
|
foreach (var (name, format) in new[] { ("_NebulaSurfaceHeight", TextureFormat.RFloat), ("_NebulaPatchHeight", TextureFormat.RHalf), ("_NebulaPatch", TextureFormat.RHalf) })
|
|
Shader.SetGlobalTexture(name, Uniform(format, Color.black, fields));
|
|
Shader.SetGlobalTexture("_NebulaTint", Uniform(TextureFormat.RGBA32, Color.white, fields));
|
|
Shader.DisableKeyword("NOISE_SLOPE");
|
|
Shader.SetGlobalFloat("_NebulaFillDensity", .01f);
|
|
Shader.SetGlobalFloat("_NebulaFillDistance", 120f);
|
|
Shader.SetGlobalFloat("_NebulaFillExponent", 0f);
|
|
Shader.SetGlobalFloat("_NebulaFillOffset", 0f);
|
|
Shader.SetGlobalFloat("_NebulaPatchDensity", 0f);
|
|
Shader.SetGlobalFloat("_NebulaLuminance", .01f); // a fog dimmer than the dust: dust drawn over it would otherwise read as a negative contribution
|
|
Shader.SetGlobalFloat("_ExtinctionCoefficient", .25f); // with the fill density, about 40% of the light to the floor is fogged away
|
|
Shader.SetGlobalFloat("_SafetyDistance", -1e6f); // below every sample: only the uniform fill, none of the zone's noise
|
|
Shader.SetGlobalFloat("_TintLodExponent", 0f);
|
|
|
|
var clearBare = Render(false, 0f);
|
|
var clearDust = Render(false, 5f);
|
|
var fogBare = Render(true, 0f);
|
|
var fogDust = Render(true, 5f);
|
|
|
|
var fogShown = 0f;
|
|
var (clearSum, fogSum, drawn) = (0f, 0f, 0);
|
|
for (var i = 0; i < clearBare.Length; i++)
|
|
{
|
|
fogShown += Mathf.Abs(fogBare[i] - clearBare[i]) / clearBare.Length;
|
|
if (clearDust[i] == clearBare[i]) continue;
|
|
drawn++; clearSum += clearDust[i] - clearBare[i]; fogSum += fogDust[i] - fogBare[i];
|
|
}
|
|
var (clearMean, fogMean) = (drawn == 0 ? 0f : clearSum / drawn, drawn == 0 ? 0f : fogSum / drawn);
|
|
Debug.Log($"{Tag} stardust under fog: fog control mean |difference|={fogShown}, dust pixels={drawn}, dust contribution cloud off={clearMean}, cloud on={fogMean}, ratio={(clearMean == 0f ? 0f : fogMean / clearMean)}");
|
|
if (drawn == 0 || clearMean <= 0f) Fail("scene-stardust-under-fog", "control: the dust drew no pixels with the cloud renderer off");
|
|
else if (fogShown < 1e-3f) Fail("scene-stardust-under-fog", "control: the cloud renderer changed no pixels, so no fog is in view");
|
|
else if (fogMean > .9f * clearMean) Fail("scene-stardust-under-fog", "the dust is not attenuated by the fog in front of it: it was drawn after the nebula composites");
|
|
else if (fogMean < .1f * clearMean) Fail("scene-stardust-under-fog", "the dust is erased, not dimmed, by a partial fog");
|
|
}
|
|
finally
|
|
{
|
|
RenderTexture.active = previous;
|
|
foreach (var effect in effects) effect.enabled = true;
|
|
camera.allowHDR = hdr;
|
|
camera.targetTexture = target;
|
|
camera.cullingMask = mask;
|
|
camera.backgroundColor = background;
|
|
camera.clearFlags = flags;
|
|
camera.farClipPlane = far;
|
|
transform.SetPositionAndRotation(position, rotation);
|
|
RenderTexture.ReleaseTemporary(texture);
|
|
UnityEngine.Object.DestroyImmediate(readback);
|
|
foreach (var field in fields) UnityEngine.Object.DestroyImmediate(field);
|
|
if (floor != null) UnityEngine.Object.DestroyImmediate(floor);
|
|
}
|
|
}
|
|
|
|
static Texture2D Uniform(TextureFormat format, Color colour, System.Collections.Generic.List<Texture2D> owner)
|
|
{
|
|
var texture = new Texture2D(1, 1, format, false) { wrapMode = TextureWrapMode.Clamp };
|
|
texture.SetPixel(0, 0, colour);
|
|
texture.Apply();
|
|
owner.Add(texture);
|
|
return texture;
|
|
}
|
|
|
|
// A square patch of particles 4 apart, `below` under `centre`.
|
|
static float[] DustLayout(int count, float size, Vector3 centre, float below)
|
|
{
|
|
var side = Mathf.RoundToInt(Mathf.Sqrt(count));
|
|
var data = new float[count * 7];
|
|
for (var i = 0; i < count; i++)
|
|
{
|
|
data[i * 7 + 0] = centre.x + ((i % side) - side / 2f) * 4f;
|
|
data[i * 7 + 1] = centre.y - below;
|
|
data[i * 7 + 2] = centre.z + ((i / side) - side / 2f) * 4f;
|
|
data[i * 7 + 3] = data[i * 7 + 4] = data[i * 7 + 5] = 1f;
|
|
data[i * 7 + 6] = size;
|
|
}
|
|
return data;
|
|
}
|
|
|
|
// CloudShader's pass 0 compiles with the flow keywords (it must #include_with_pragmas the shared include).
|
|
static void CheckCloudKeywords()
|
|
{
|
|
var shader = AssetDatabase.LoadAssetAtPath<Shader>("Assets/Shaders/Raymarching/CloudShader.shader");
|
|
if (shader == null) { Fail("scene-cloud-keywords", "No CloudShader.shader."); return; }
|
|
var keywords = ShaderUtil.GetPassKeywords(shader, new PassIdentifier(0, 0), UnityEditor.Rendering.ShaderType.Fragment)
|
|
.Select(keyword => keyword.name).ToArray();
|
|
foreach (var name in new[] { "FLOW_GLOBAL", "FLOW_SLOPE" })
|
|
if (!keywords.Contains(name)) Fail("scene-cloud-keywords", $"CloudShader pass 0 does not carry {name}");
|
|
}
|
|
|
|
static int Differing(float[] a, float[] b)
|
|
{
|
|
var count = 0;
|
|
for (var i = 0; i < a.Length; i++)
|
|
if (Math.Abs(a[i] - b[i]) > 1e-4f) count++;
|
|
return count;
|
|
}
|
|
|
|
// The presenters' own Start and Update, as the game calls them; an exception is a failure that names the type.
|
|
static void Call(object target, string method)
|
|
{
|
|
var info = target.GetType().GetMethod(method, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance);
|
|
if (info == null) { Fail("scene-presenter-exception", $"{target.GetType().Name}.{method} not found"); return; }
|
|
try { info.Invoke(target, null); }
|
|
catch (TargetInvocationException e)
|
|
{
|
|
Fail("scene-presenter-exception", $"{target.GetType().Name}.{method} threw {e.InnerException?.GetType().Name}");
|
|
}
|
|
}
|
|
}
|
|
}
|