lingdar77/leanCLR_gdext
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

init

Browse Source
This commit is contained in:
MaidOpi
2026-05-10 22:29:56 +08:00
commit 0428927f5f
54 changed files with 15200 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
project/scripts/ScriptMain.cs
+546
View File
@@ -0,0 +1,546 @@
using Godot;
namespace Game;
public partial class ScriptMain : Node2D
{
[Export(PropertyHint.Range, "0,1000,1")]
public int InspectorNumber { get; set; } = 7;
private bool processPrinted;
private bool physicsProcessPrinted;
private bool inputPrinted;
private bool guiInputPrinted;
public override void _EnterTree()
{
GD.Print("LeanCLR demo: _EnterTree owner name = " + Name);
}
public override void _ExitTree()
{
GD.Print("LeanCLR demo: _ExitTree owner name = " + Name);
}
public override void _Ready()
{
StringName ownerName = Name;
GD.Print("LeanCLR demo: ScriptLanguage owner name = " + ownerName.ToString());
Position = new Vector2(12.0f, 34.0f);
Scale = new Vector2(2.0f, 3.0f);
SetModulate(new Color(0.25f, 0.5f, 0.75f, 1.0f));
Color modulate = GetModulate();
GD.Print("LeanCLR demo: position = " + Position.ToString());
GD.Print("LeanCLR demo: scale = " + Scale.ToString());
GD.Print("LeanCLR demo: modulate color = " + modulate.ToString());
Label label = GetNode<Label>(new NodePath("UiLabel"));
label.Text = "LeanCLR Label";
label.Position = new Vector2(7.0f, 8.0f);
label.Size = new Vector2(120.0f, 24.0f);
label.SetHorizontalAlignment(HorizontalAlignment.Center);
label.SetHSizeFlags(Control.SizeFlags.SizeExpandFill);
label.SetJustificationFlags(TextServer.JustificationFlag.JustificationWordBound | TextServer.JustificationFlag.JustificationTrimEdgeSpaces);
label.Hide();
label.Show();
GD.Print("LeanCLR demo: label text = " + label.Text);
GD.Print("LeanCLR demo: label position = " + label.Position.ToString());
GD.Print("LeanCLR demo: label h alignment = " + label.GetHorizontalAlignment().ToString());
GD.Print("LeanCLR demo: label h size flags = " + label.GetHSizeFlags().ToString());
GD.Print("LeanCLR demo: label justification flags = " + label.GetJustificationFlags().ToString());
GD.Print("LeanCLR demo: label rect = " + label.GetRect().ToString());
GD.Print("LeanCLR demo: node2d transform = " + GetTransform().ToString());
GD.Print("LeanCLR demo: label canvas RID valid = " + label.GetCanvasItem().IsValid().ToString());
Font defaultFont = label.GetThemeDefaultFont();
GD.Print("LeanCLR demo: label default font exists = " + (defaultFont != null).ToString());
Font defaultFontAgain = label.GetThemeDefaultFont();
GD.Print("LeanCLR demo: wrapper identity cache = " + object.ReferenceEquals(defaultFont, defaultFontAgain).ToString());
if (defaultFont != null)
{
defaultFont.Dispose();
}
GD.Print("LeanCLR demo: label visible = " + label.IsVisible().ToString());
GD.Print("LeanCLR demo: script property initial = " + Get(new StringName("InspectorNumber")).AsInt64().ToString());
Set(new StringName("InspectorNumber"), new Variant(314));
GD.Print("LeanCLR demo: script property updated = " + InspectorNumber.ToString());
GodotArray scriptProperties = GetPropertyList();
GD.Print("LeanCLR demo: script property list exists = " + (scriptProperties != null).ToString());
if (scriptProperties != null)
{
for (int i = 0; i < scriptProperties.Count; ++i)
{
Dictionary propertyInfo = scriptProperties[i].AsDictionary();
if (propertyInfo[new Variant("name")].ToString() == "InspectorNumber")
{
GD.Print("LeanCLR demo: script property hint = " + propertyInfo[new Variant("hint")].ToString());
GD.Print("LeanCLR demo: script property hint string = " + propertyInfo[new Variant("hint_string")].ToString());
}
}
scriptProperties.Dispose();
}
string sceneUniqueId = Resource.GenerateSceneUniqueId();
GD.Print("LeanCLR demo: resource id length > 0 = " + (sceneUniqueId.Length > 0).ToString());
Variant metaValue = new Variant("LeanCLR Variant");
SetMeta(new StringName("leanclr_meta"), metaValue);
GD.Print("LeanCLR demo: variant meta exists = " + HasMeta(new StringName("leanclr_meta")).ToString());
Variant metaRoundtrip = GetMeta(new StringName("leanclr_meta"));
GD.Print("LeanCLR demo: variant meta = " + metaRoundtrip.ToString());
metaRoundtrip.Dispose();
metaValue.Dispose();
Variant callMetaKey = new Variant("leanclr_call_meta");
Variant callMetaValue = new Variant("LeanCLR Call Variant");
Call(new StringName("set_meta"), callMetaKey, callMetaValue).Dispose();
Variant callMetaRoundtrip = Call(new StringName("get_meta"), callMetaKey);
GD.Print("LeanCLR demo: object call variant meta = " + callMetaRoundtrip.ToString());
callMetaRoundtrip.Dispose();
callMetaValue.Dispose();
callMetaKey.Dispose();
AddToGroup(new StringName("leanclr_vararg_group"));
Variant groupMetaKey = new Variant("leanclr_group_meta");
Variant groupMetaValue = new Variant("LeanCLR Group Variant");
GetTree().CallGroup(new StringName("leanclr_vararg_group"), new StringName("set_meta"), groupMetaKey, groupMetaValue);
Variant groupMetaRoundtrip = GetMeta(new StringName("leanclr_group_meta"));
GD.Print("LeanCLR demo: call group variant meta = " + groupMetaRoundtrip.ToString());
groupMetaRoundtrip.Dispose();
groupMetaValue.Dispose();
groupMetaKey.Dispose();
Variant jsonValue = new Variant("LeanCLR JSON");
string jsonText = JSON.Stringify(jsonValue);
GD.Print("LeanCLR demo: variant json = " + jsonText);
jsonValue.Dispose();
Variant parsedJson = JSON.ParseString("123");
GD.Print("LeanCLR demo: parsed variant = " + parsedJson.ToString());
parsedJson.Dispose();
GD.Print("LeanCLR demo: project file exists = " + FileAccess.FileExists("res://project.godot").ToString());
GD.Print("LeanCLR demo: project file text length > 0 = " + (FileAccess.GetFileAsString("res://project.godot").Length > 0).ToString());
PackedByteArray projectBytes = FileAccess.GetFileAsBytes("res://project.godot");
Variant packedByteVariant = new Variant(projectBytes);
GD.Print("LeanCLR demo: variant packed byte array type = " + packedByteVariant.VariantType.ToString());
GD.Print("LeanCLR demo: packed byte array wrapper exists = " + (packedByteVariant.AsPackedByteArray() != null).ToString());
packedByteVariant.Dispose();
PackedByteArray manualBytes = new PackedByteArray();
manualBytes.Add(1);
manualBytes.Add(2);
manualBytes[1] = 3;
GD.Print("LeanCLR demo: packed byte manual count = " + manualBytes.Count.ToString());
GD.Print("LeanCLR demo: packed byte manual second = " + manualBytes[1].ToString());
manualBytes.Clear();
GD.Print("LeanCLR demo: packed byte manual cleared = " + manualBytes.Count.ToString());
manualBytes.Dispose();
projectBytes.Dispose();
DirAccess projectDir = DirAccess.Open("res://");
GD.Print("LeanCLR demo: dir access open = " + (projectDir != null).ToString());
GD.Print("LeanCLR demo: dir open error = " + DirAccess.GetOpenError().ToString());
GD.Print("LeanCLR demo: dir drive count >= 0 = " + (DirAccess.GetDriveCount() >= 0).ToString());
if (projectDir != null)
{
projectDir.Dispose();
}
PackedStringArray projectFiles = DirAccess.GetFilesAt("res://");
bool foundProjectFile = false;
for (int i = 0; i < projectFiles.Count; ++i)
{
if (projectFiles[i] == "project.godot")
{
foundProjectFile = true;
}
}
GD.Print("LeanCLR demo: packed files count > 0 = " + (projectFiles.Count > 0).ToString());
GD.Print("LeanCLR demo: packed files include project = " + foundProjectFile.ToString());
projectFiles.Dispose();
PackedInt32Array packedInts = new PackedInt32Array();
packedInts.Add(4);
packedInts[0] = 5;
GD.Print("LeanCLR demo: packed int32 first = " + packedInts[0].ToString());
packedInts.Dispose();
PackedInt64Array packedLongs = new PackedInt64Array();
packedLongs.Add(6L);
GD.Print("LeanCLR demo: packed int64 count = " + packedLongs.Count.ToString());
packedLongs.Dispose();
PackedFloat32Array packedFloats = new PackedFloat32Array();
packedFloats.Add(1.25f);
GD.Print("LeanCLR demo: packed float32 first = " + packedFloats[0].ToString());
packedFloats.Dispose();
PackedFloat64Array packedDoubles = new PackedFloat64Array();
packedDoubles.Add(2.5);
GD.Print("LeanCLR demo: packed float64 first = " + packedDoubles[0].ToString());
packedDoubles.Dispose();
PackedVector2Array packedVector2s = new PackedVector2Array();
packedVector2s.Add(new Vector2(1.0f, 2.0f));
GD.Print("LeanCLR demo: packed vector2 first = " + packedVector2s[0].ToString());
packedVector2s.Dispose();
PackedVector3Array packedVector3s = new PackedVector3Array();
packedVector3s.Add(new Vector3(3.0f, 4.0f, 5.0f));
GD.Print("LeanCLR demo: packed vector3 first = " + packedVector3s[0].ToString());
packedVector3s.Dispose();
PackedColorArray packedColors = new PackedColorArray();
packedColors.Add(new Color(0.6f, 0.7f, 0.8f, 1.0f));
GD.Print("LeanCLR demo: packed color first = " + packedColors[0].ToString());
packedColors.Dispose();
PackedStringArray csvValues = new PackedStringArray(new string[] { "alpha", "beta" });
GD.Print("LeanCLR demo: packed manual first = " + csvValues[0]);
FileAccess csvFile = FileAccess.Open("user://leanclr_packed.csv", FileAccess.ModeFlags.Write);
bool csvStored = csvFile != null && csvFile.StoreCsvLine(csvValues);
GD.Print("LeanCLR demo: packed csv stored = " + csvStored.ToString());
if (csvFile != null)
{
csvFile.Dispose();
}
csvValues.Dispose();
Image image = Image.CreateEmpty(4, 4, false, Image.Format.Rgba8);
image.SetPixel(2, 1, new Color(1.0f, 0.0f, 0.0f, 1.0f));
GD.Print("LeanCLR demo: image used rect = " + image.GetUsedRect().ToString());
image.Dispose();
PhysicsRayQueryParameters3D rayQuery = PhysicsRayQueryParameters3D.Create(new Vector3(1.0f, 2.0f, 3.0f), new Vector3(4.0f, 5.0f, 6.0f));
GD.Print("LeanCLR demo: physics ray 3d query exists = " + (rayQuery != null).ToString());
if (rayQuery != null)
{
GD.Print("LeanCLR demo: physics ray 3d from = " + rayQuery.GetFrom().ToString());
GD.Print("LeanCLR demo: physics ray 3d to = " + rayQuery.GetTo().ToString());
rayQuery.Dispose();
}
Node3D node3D = GetNode<Node3D>(new NodePath("Node3DDemo"));
node3D.SetPosition(new Vector3(7.0f, 8.0f, 9.0f));
node3D.SetQuaternion(Quaternion.Identity);
node3D.SetBasis(Basis.Identity);
node3D.SetTransform(new Transform3D(Basis.Identity, new Vector3(10.0f, 11.0f, 12.0f)));
GD.Print("LeanCLR demo: node3d position = " + node3D.GetPosition().ToString());
GD.Print("LeanCLR demo: node3d quaternion = " + node3D.GetQuaternion().ToString());
GD.Print("LeanCLR demo: node3d basis = " + node3D.GetBasis().ToString());
GD.Print("LeanCLR demo: node3d transform = " + node3D.GetTransform().ToString());
CPUParticles3D particles3D = GetNode<CPUParticles3D>(new NodePath("CpuParticles3DDemo"));
particles3D.SetVisibilityAabb(new Aabb(new Vector3(1.0f, 2.0f, 3.0f), new Vector3(4.0f, 5.0f, 6.0f)));
GD.Print("LeanCLR demo: particles visibility aabb = " + particles3D.GetVisibilityAabb().ToString());
Camera3D camera3D = GetNode<Camera3D>(new NodePath("Camera3DDemo"));
GD.Print("LeanCLR demo: camera transform = " + camera3D.GetCameraTransform().ToString());
Projection cameraProjection = camera3D.GetCameraProjection();
GD.Print("LeanCLR demo: camera projection = " + cameraProjection.ToString());
Variant projectionVariant = new Variant(cameraProjection);
GD.Print("LeanCLR demo: variant projection type = " + projectionVariant.VariantType.ToString());
GD.Print("LeanCLR demo: variant projection = " + projectionVariant.AsProjection().ToString());
projectionVariant.Dispose();
Plane demoPlane = new Plane(new Vector3(0.0f, 1.0f, 0.0f), 2.0f);
Variant planeVariant = new Variant(demoPlane);
GD.Print("LeanCLR demo: variant plane type = " + planeVariant.VariantType.ToString());
GD.Print("LeanCLR demo: variant plane = " + planeVariant.AsPlane().ToString());
planeVariant.Dispose();
Sprite2D sprite = GetNode<Sprite2D>(new NodePath("SpriteDemo"));
Texture2D spriteTexture = sprite.GetTexture();
sprite.Centered = false;
sprite.Offset = new Vector2(5.0f, 6.0f);
sprite.FlipH = true;
sprite.SetHframes(2);
sprite.SetVframes(2);
sprite.SetFrameCoords(new Vector2i(1, 1));
SetRotationDegrees(15.0f);
GD.Print("LeanCLR demo: sprite centered = " + sprite.Centered.ToString());
GD.Print("LeanCLR demo: sprite texture is null = " + (spriteTexture == null).ToString());
GD.Print("LeanCLR demo: sprite offset = " + sprite.Offset.ToString());
GD.Print("LeanCLR demo: sprite flip h = " + sprite.FlipH.ToString());
GD.Print("LeanCLR demo: sprite frame coords = " + sprite.GetFrameCoords().ToString());
GD.Print("LeanCLR demo: rotation degrees = " + GetRotationDegrees().ToString());
NodePath childPath = new NodePath("Child");
Node child = GetNode<Node>(childPath);
GD.Print("LeanCLR demo: child before QueueFree = " + child.Name);
GD.Print("LeanCLR demo: child parent = " + child.GetParent().Name);
GD.Print("LeanCLR demo: child count = " + GetChildCount().ToString());
GD.Print("LeanCLR demo: inside tree = " + IsInsideTree().ToString());
GD.Print("LeanCLR demo: tree node count > 0 = " + (GetTree().GetNodeCount() > 0).ToString());
SetProcessMode(Node.ProcessMode.Always);
GD.Print("LeanCLR demo: process mode = " + GetProcessMode().ToString());
Variant selfVariant = new Variant(this);
Node2D selfObject = selfVariant.AsObject<Node2D>();
GD.Print("LeanCLR demo: variant object name = " + selfObject.Name.ToString());
selfVariant.Dispose();
Variant vector2Variant = new Variant(new Vector2(3.0f, 4.0f));
GD.Print("LeanCLR demo: variant vector2 = " + vector2Variant.AsVector2().ToString());
GD.Print("LeanCLR demo: variant vector2 stringify = " + vector2Variant.ToString());
vector2Variant.Dispose();
Variant vector3Variant = new Variant(new Vector3(5.0f, 6.0f, 7.0f));
GD.Print("LeanCLR demo: variant vector3 = " + vector3Variant.AsVector3().ToString());
vector3Variant.Dispose();
Variant stringNameVariant = new Variant(new StringName("leanclr_name"));
GD.Print("LeanCLR demo: variant string name type = " + stringNameVariant.VariantType.ToString());
GD.Print("LeanCLR demo: variant string name = " + stringNameVariant.AsStringName().ToString());
stringNameVariant.Dispose();
Variant nodePathVariant = new Variant(new NodePath("Child"));
GD.Print("LeanCLR demo: variant node path type = " + nodePathVariant.VariantType.ToString());
GD.Print("LeanCLR demo: variant node path = " + nodePathVariant.AsNodePath().ToString());
nodePathVariant.Dispose();
Variant ridVariant = new Variant(new RID(0));
GD.Print("LeanCLR demo: variant rid type = " + ridVariant.VariantType.ToString());
GD.Print("LeanCLR demo: variant rid valid = " + ridVariant.AsRID().IsValid().ToString());
ridVariant.Dispose();
PackedStringArray packedStrings = new PackedStringArray(new string[] { "alpha", "beta" });
Variant packedStringArrayVariant = new Variant(packedStrings);
PackedStringArray packedStringsRoundtrip = packedStringArrayVariant.AsPackedStringArray();
GD.Print("LeanCLR demo: variant packed string array type = " + packedStringArrayVariant.VariantType.ToString());
GD.Print("LeanCLR demo: packed string array count = " + packedStringsRoundtrip.Count.ToString());
GD.Print("LeanCLR demo: packed string array first = " + packedStringsRoundtrip[0]);
packedStringsRoundtrip.Dispose();
packedStringArrayVariant.Dispose();
packedStrings.Dispose();
Array demoArray = new Array();
demoArray.Add(new Variant("array first"));
demoArray.Add(new Variant(new Vector2(8.0f, 9.0f)));
Variant arrayVariant = new Variant(demoArray);
GD.Print("LeanCLR demo: variant array type = " + arrayVariant.VariantType.ToString());
GD.Print("LeanCLR demo: variant array wrapper exists = " + (arrayVariant.AsArray() != null).ToString());
GD.Print("LeanCLR demo: array count = " + demoArray.Count.ToString());
GD.Print("LeanCLR demo: array first = " + demoArray[0].ToString());
GD.Print("LeanCLR demo: array second = " + demoArray[1].AsVector2().ToString());
Variant arrayInserted = new Variant("array inserted");
demoArray.Insert(1, arrayInserted);
GD.Print("LeanCLR demo: array inserted = " + demoArray[1].ToString());
GD.Print("LeanCLR demo: array contains inserted = " + demoArray.Contains(arrayInserted).ToString());
GD.Print("LeanCLR demo: array inserted index = " + demoArray.IndexOf(arrayInserted).ToString());
int arrayEnumerated = 0;
foreach (Variant item in demoArray)
{
arrayEnumerated++;
}
GD.Print("LeanCLR demo: array enumerated = " + arrayEnumerated.ToString());
demoArray.RemoveAt(1);
GD.Print("LeanCLR demo: array count after remove = " + demoArray.Count.ToString());
demoArray.Clear();
GD.Print("LeanCLR demo: array count after clear = " + demoArray.Count.ToString());
arrayInserted.Dispose();
arrayVariant.Dispose();
demoArray.Dispose();
Dictionary demoDictionary = new Dictionary();
Variant dictionaryKey = new Variant("answer");
demoDictionary[dictionaryKey] = new Variant(42);
Variant dictionaryVariant = new Variant(demoDictionary);
GD.Print("LeanCLR demo: variant dictionary type = " + dictionaryVariant.VariantType.ToString());
GD.Print("LeanCLR demo: variant dictionary wrapper exists = " + (dictionaryVariant.AsDictionary() != null).ToString());
GD.Print("LeanCLR demo: dictionary count = " + demoDictionary.Count.ToString());
GD.Print("LeanCLR demo: dictionary has key = " + demoDictionary.ContainsKey(dictionaryKey).ToString());
Variant dictionaryValue = demoDictionary[dictionaryKey];
GD.Print("LeanCLR demo: dictionary value type = " + dictionaryValue.VariantType.ToString());
GD.Print("LeanCLR demo: dictionary value = " + dictionaryValue.ToString());
GD.Print("LeanCLR demo: dictionary value int = " + dictionaryValue.AsInt64().ToString());
Array dictionaryKeys = demoDictionary.Keys;
Array dictionaryValues = demoDictionary.Values;
GD.Print("LeanCLR demo: dictionary keys count = " + dictionaryKeys.Count.ToString());
GD.Print("LeanCLR demo: dictionary values first = " + dictionaryValues[0].ToString());
int dictionaryEnumerated = 0;
foreach (var entry in demoDictionary)
{
if (entry.Key.ToString() == "answer" && entry.Value.AsInt64() == 42)
{
dictionaryEnumerated++;
}
}
GD.Print("LeanCLR demo: dictionary enumerated = " + dictionaryEnumerated.ToString());
GD.Print("LeanCLR demo: dictionary removed = " + demoDictionary.Remove(dictionaryKey).ToString());
GD.Print("LeanCLR demo: dictionary count after remove = " + demoDictionary.Count.ToString());
demoDictionary[dictionaryKey] = new Variant(7);
demoDictionary.Clear();
GD.Print("LeanCLR demo: dictionary count after clear = " + demoDictionary.Count.ToString());
dictionaryKeys.Dispose();
dictionaryValues.Dispose();
dictionaryValue.Dispose();
dictionaryKey.Dispose();
dictionaryVariant.Dispose();
demoDictionary.Dispose();
Callable setMetaCallable = new Callable(this, new StringName("set_meta"));
Variant callableMetaKey = new Variant("leanclr_callable_meta");
Variant callableMetaValue = new Variant("LeanCLR Callable Variant");
setMetaCallable.Call(callableMetaKey, callableMetaValue).Dispose();
Variant callableMetaRoundtrip = GetMeta(new StringName("leanclr_callable_meta"));
GD.Print("LeanCLR demo: callable valid = " + setMetaCallable.IsValid().ToString());
GD.Print("LeanCLR demo: callable method = " + setMetaCallable.GetMethod().ToString());
GD.Print("LeanCLR demo: callable call meta = " + callableMetaRoundtrip.ToString());
callableMetaRoundtrip.Dispose();
callableMetaValue.Dispose();
callableMetaKey.Dispose();
AddUserSignal("leanclr_user_signal");
Signal userSignal = new Signal(this, new StringName("leanclr_user_signal"));
Variant signalMetaKey = new Variant("leanclr_signal_meta");
Variant signalMetaValue = new Variant("LeanCLR Signal Variant");
Callable signalCallable = setMetaCallable.Bind(signalMetaKey, signalMetaValue);
GD.Print("LeanCLR demo: signal name = " + userSignal.GetName().ToString());
GD.Print("LeanCLR demo: signal connect = " + userSignal.Connect(signalCallable, 0).ToString());
userSignal.Emit();
Variant signalMetaRoundtrip = GetMeta(new StringName("leanclr_signal_meta"));
GD.Print("LeanCLR demo: signal emitted meta = " + signalMetaRoundtrip.ToString());
Variant callableVariant = new Variant(signalCallable);
Variant signalVariant = new Variant(userSignal);
GD.Print("LeanCLR demo: variant callable type = " + callableVariant.VariantType.ToString());
GD.Print("LeanCLR demo: variant callable valid = " + callableVariant.AsCallable().IsValid().ToString());
GD.Print("LeanCLR demo: variant signal type = " + signalVariant.VariantType.ToString());
GD.Print("LeanCLR demo: variant signal name = " + signalVariant.AsSignal().GetName().ToString());
AddUserSignal("leanclr_managed_signal");
Signal managedSignal = new Signal(this, new StringName("leanclr_managed_signal"));
Callable managedCallable = new Callable(this, new StringName("OnLeanClrManagedSignal"));
GD.Print("LeanCLR demo: managed callable valid = " + managedCallable.IsValid().ToString());
GD.Print("LeanCLR demo: managed signal connect = " + managedSignal.Connect(managedCallable, 0).ToString());
managedSignal.Emit();
Variant managedSignalRoundtrip = GetMeta(new StringName("leanclr_managed_signal_meta"));
GD.Print("LeanCLR demo: managed signal emitted meta = " + managedSignalRoundtrip.ToString());
managedSignalRoundtrip.Dispose();
AddUserSignal("leanclr_managed_arg_signal");
Signal managedArgSignal = new Signal(this, new StringName("leanclr_managed_arg_signal"));
Callable managedArgCallable = new Callable(this, new StringName("OnLeanClrManagedSignalWithArg"));
GD.Print("LeanCLR demo: managed arg callable valid = " + managedArgCallable.IsValid().ToString());
GD.Print("LeanCLR demo: managed arg signal connect = " + managedArgSignal.Connect(managedArgCallable, 0).ToString());
Variant managedArgPayload = new Variant("LeanCLR Managed Signal Payload");
managedArgSignal.Emit(managedArgPayload);
Variant managedArgSignalRoundtrip = GetMeta(new StringName("leanclr_managed_arg_signal_meta"));
GD.Print("LeanCLR demo: managed arg signal emitted meta = " + managedArgSignalRoundtrip.ToString());
managedArgSignalRoundtrip.Dispose();
AddUserSignal("leanclr_managed_multi_signal");
Signal managedMultiSignal = new Signal(this, new StringName("leanclr_managed_multi_signal"));
Callable managedMultiCallable = new Callable(this, new StringName("OnLeanClrManagedSignalWithArgs"));
GD.Print("LeanCLR demo: managed multi callable valid = " + managedMultiCallable.IsValid().ToString());
GD.Print("LeanCLR demo: managed multi signal connect = " + managedMultiSignal.Connect(managedMultiCallable, 0).ToString());
Variant managedMultiFirst = new Variant("LeanCLR");
Variant managedMultiSecond = new Variant("Multi Signal Payload");
managedMultiSignal.Emit(managedMultiFirst, managedMultiSecond);
Variant managedMultiSignalRoundtrip = GetMeta(new StringName("leanclr_managed_multi_signal_meta"));
GD.Print("LeanCLR demo: managed multi signal emitted meta = " + managedMultiSignalRoundtrip.ToString());
managedMultiSignalRoundtrip.Dispose();
Callable typedCallable = new Callable(this, new StringName("OnLeanClrTypedCallable"));
Variant typedCallResult = typedCallable.Call(new Variant("LeanCLR Typed"), new Variant(41), new Variant(1.5), new Variant(new Vector2(2.0f, 3.0f)), new Variant(this));
GD.Print("LeanCLR demo: typed callable result = " + typedCallResult.ToString());
typedCallResult.Dispose();
Callable returnIntCallable = new Callable(this, new StringName("OnLeanClrReturnInt"));
Variant returnIntResult = returnIntCallable.Call(new Variant(41));
GD.Print("LeanCLR demo: return int callable result = " + returnIntResult.ToString());
returnIntResult.Dispose();
returnIntCallable.Dispose();
Callable structCallable = new Callable(this, new StringName("OnLeanClrStructCallable"));
Variant structCallResult = structCallable.Call(new Variant(new StringName("struct_name")), new Variant(new NodePath("Child")), new Variant(new RID(0)), new Variant(new Color(0.1f, 0.2f, 0.3f, 1.0f)), new Variant(Quaternion.Identity), new Variant(Basis.Identity), new Variant(Transform3D.Identity));
GD.Print("LeanCLR demo: struct callable result = " + structCallResult.ToString());
structCallResult.Dispose();
structCallable.Dispose();
Callable returnColorCallable = new Callable(this, new StringName("OnLeanClrReturnColor"));
Variant returnColorResult = returnColorCallable.Call(new Variant(new Color(0.2f, 0.3f, 0.4f, 1.0f)));
GD.Print("LeanCLR demo: return color callable result = " + returnColorResult.AsColor().ToString());
returnColorResult.Dispose();
returnColorCallable.Dispose();
int delegateSignalCount = 0;
Callable delegateCallable = Callable.From(() => { delegateSignalCount = 42; });
AddUserSignal("leanclr_delegate_signal");
Signal delegateSignal = new Signal(this, new StringName("leanclr_delegate_signal"));
GD.Print("LeanCLR demo: delegate callable valid = " + delegateCallable.IsValid().ToString());
GD.Print("LeanCLR demo: delegate signal connect = " + delegateSignal.Connect(delegateCallable, 0).ToString());
delegateSignal.Emit();
GD.Print("LeanCLR demo: delegate signal count = " + delegateSignalCount.ToString());
Callable delegateArgCallable = Callable.From<Variant>((payload) => { SetMeta(new StringName("leanclr_delegate_arg_meta"), payload); });
AddUserSignal("leanclr_delegate_arg_signal");
Signal delegateArgSignal = new Signal(this, new StringName("leanclr_delegate_arg_signal"));
GD.Print("LeanCLR demo: delegate arg signal connect = " + delegateArgSignal.Connect(delegateArgCallable, 0).ToString());
delegateArgSignal.Emit(new Variant("LeanCLR Delegate Payload"));
Variant delegateArgRoundtrip = GetMeta(new StringName("leanclr_delegate_arg_meta"));
GD.Print("LeanCLR demo: delegate arg meta = " + delegateArgRoundtrip.ToString());
delegateArgRoundtrip.Dispose();
delegateArgCallable.Dispose();
delegateArgSignal.Dispose();
delegateCallable.Dispose();
delegateSignal.Emit();
GD.Print("LeanCLR demo: delegate signal count after dispose = " + delegateSignalCount.ToString());
delegateSignal.Dispose();
typedCallable.Dispose();
managedMultiSecond.Dispose();
managedMultiFirst.Dispose();
managedMultiCallable.Dispose();
managedMultiSignal.Dispose();
managedArgPayload.Dispose();
managedArgCallable.Dispose();
managedArgSignal.Dispose();
managedCallable.Dispose();
managedSignal.Dispose();
callableVariant.Dispose();
signalVariant.Dispose();
signalMetaRoundtrip.Dispose();
signalMetaValue.Dispose();
signalMetaKey.Dispose();
signalCallable.Dispose();
userSignal.Dispose();
setMetaCallable.Dispose();
SetPhysicsProcess(true);
SetProcessInput(true);
Call(new StringName("_input"), new Variant((GodotObject)null)).Dispose();
Call(new StringName("_gui_input"), new Variant((GodotObject)null)).Dispose();
child.QueueFree();
}
public void OnLeanClrManagedSignal()
{
SetMeta(new StringName("leanclr_managed_signal_meta"), new Variant("LeanCLR Managed Signal Variant"));
}
public void OnLeanClrManagedSignalWithArg(Variant payload)
{
SetMeta(new StringName("leanclr_managed_arg_signal_meta"), payload);
}
public void OnLeanClrManagedSignalWithArgs(Variant[] payloads)
{
SetMeta(new StringName("leanclr_managed_multi_signal_meta"), new Variant(payloads[0].ToString() + " " + payloads[1].ToString()));
}
public string OnLeanClrTypedCallable(string label, int count, double amount, Vector2 point, Node node)
{
return label + " " + (count + 1).ToString() + " " + amount.ToString() + " " + point.ToString() + " " + node.Name.ToString();
}
public int OnLeanClrReturnInt(int value)
{
return value + 1;
}
public string OnLeanClrStructCallable(StringName name, NodePath path, RID rid, Color color, Quaternion quaternion, Basis basis, Transform3D transform)
{
return name.ToString() + " " + path.ToString() + " " + rid.IsValid().ToString() + " " + color.ToString() + " " + quaternion.ToString() + " " + basis.ToString() + " " + transform.ToString();
}
public Color OnLeanClrReturnColor(Color value)
{
return value;
}
public override void _Process(double delta)
{
if (processPrinted)
{
return;
}
processPrinted = true;
GD.Print("LeanCLR demo: _Process delta > 0 = " + (delta > 0.0).ToString());
}
public override void _PhysicsProcess(float delta)
{
if (physicsProcessPrinted)
{
return;
}
physicsProcessPrinted = true;
GD.Print("LeanCLR demo: _PhysicsProcess delta > 0 = " + (delta > 0.0f).ToString());
}
public override void _Input(InputEvent event_)
{
if (inputPrinted)
{
return;
}
inputPrinted = true;
GD.Print("LeanCLR demo: _Input event wrapper exists = " + (event_ != null).ToString());
}
public void _GuiInput(InputEvent event_)
{
if (guiInputPrinted)
{
return;
}
guiInputPrinted = true;
GD.Print("LeanCLR demo: _GuiInput event wrapper exists = " + (event_ != null).ToString());
}
}