/// <summary>
/// Converts one or more arguments of any type to string in the best way possible.
/// </summary>
/// <param name="what">Arguments that will converted to string.</param>
/// <returns>The string formed by the given arguments.</returns>
public static string Str(params Variant[] what)
{
using var whatGodot = new Godot.Collections.Array(what);
NativeFuncs.godotsharp_str((godot_array)whatGodot.NativeValue, out godot_string ret);
using (ret)
return(Marshaling.ConvertStringToManaged(ret));
}
/// <summary>
/// Calls the method represented by this <see cref="Callable"/>.
/// Arguments can be passed and should match the method's signature.
/// </summary>
/// <param name="args">Arguments that will be passed to the method call.</param>
/// <returns>The value returned by the method.</returns>
public unsafe Variant Call(params Variant[] args)
{
using godot_callable callable = Marshaling.ConvertCallableToNative(this);
int argc = args.Length;
Span <godot_variant.movable> argsStoreSpan = argc <= VarArgsSpanThreshold ?
stackalloc godot_variant.movable[VarArgsSpanThreshold].Cleared() :
new godot_variant.movable[argc];
Span <IntPtr> argsSpan = argc <= 10 ?
stackalloc IntPtr[argc] :
new IntPtr[argc];
using var variantSpanDisposer = new VariantSpanDisposer(argsStoreSpan);
fixed(godot_variant *varargs = &MemoryMarshal.GetReference(argsStoreSpan).DangerousSelfRef)
fixed(IntPtr * argsPtr = &MemoryMarshal.GetReference(argsSpan))
{
for (int i = 0; i < argc; i++)
{
varargs[i] = (godot_variant)args[i].NativeVar;
argsPtr[i] = new IntPtr(&varargs[i]);
}
godot_variant ret = NativeFuncs.godotsharp_callable_call(callable,
(godot_variant **)argsPtr, argc, out _);
return(Variant.CreateTakingOwnershipOfDisposableValue(ret));
}
}
/// <summary>
/// Prints one or more arguments to strings in the best way possible to console.
/// No newline is added at the end.
///
/// Note: Due to limitations with Godot's built-in console, this only prints to the terminal.
/// If you need to print in the editor, use another method, such as <see cref="Print(object[])"/>.
/// </summary>
/// <example>
/// <code>
/// GD.PrintRaw("A");
/// GD.PrintRaw("B");
/// // Prints AB
/// </code>
/// </example>
/// <param name="what">Arguments that will be printed.</param>
public static void PrintRaw(params object[] what)
{
string str = string.Concat(GetPrintParams(what));
using var godotStr = Marshaling.ConvertStringToNative(str);
NativeFuncs.godotsharp_printraw(godotStr);
}
internal static unsafe void InvokeWithVariantArgs(IntPtr delegateGCHandle, godot_variant **args, uint argc,
godot_variant *outRet)
{
try
{
// TODO: Optimize
var @delegate = (Delegate)GCHandle.FromIntPtr(delegateGCHandle).Target !;
var managedArgs = new object?[argc];
var parameterInfos = @delegate.Method.GetParameters();
var paramsLength = parameterInfos.Length;
if (argc != paramsLength)
{
throw new InvalidOperationException(
$"The delegate expects {paramsLength} arguments, but received {argc}.");
}
for (uint i = 0; i < argc; i++)
{
managedArgs[i] = Marshaling.ConvertVariantToManagedObjectOfType(
*args[i], parameterInfos[i].ParameterType);
}
object?invokeRet = @delegate.DynamicInvoke(managedArgs);
*outRet = Marshaling.ConvertManagedObjectToVariant(invokeRet);
}
catch (Exception e)
{
ExceptionUtils.LogException(e);
*outRet = default;
}
}
void ICollection.CopyTo(System.Array array, int index)
{
if (array == null)
{
throw new ArgumentNullException(nameof(array), "Value cannot be null.");
}
if (index < 0)
{
throw new ArgumentOutOfRangeException(nameof(index),
"Number was less than the array's lower bound in the first dimension.");
}
int count = Count;
if (array.Length < (index + count))
{
throw new ArgumentException(
"Destination array was not long enough. Check destIndex and length, and the array's lower bounds.");
}
unsafe
{
for (int i = 0; i < count; i++)
{
object obj = Marshaling.ConvertVariantToManagedObject(NativeValue.DangerousSelfRef.Elements[i]);
array.SetValue(obj, index);
index++;
}
}
}
/// <summary>
/// Prints one or more arguments to the console with a tab between each argument.
/// </summary>
/// <example>
/// <code>
/// GD.PrintT("A", "B", "C"); // Prints A B C
/// </code>
/// </example>
/// <param name="what">Arguments that will be printed.</param>
public static void PrintT(params object[] what)
{
string str = string.Join('\t', GetPrintParams(what));
using var godotStr = Marshaling.ConvertStringToNative(str);
NativeFuncs.godotsharp_printt(godotStr);
}
public static object EditorShortcut(string setting)
{
using godot_string settingIn = Marshaling.ConvertStringToNative(setting);
Internal.godot_icall_Globals_EditorShortcut(settingIn, out godot_variant result);
using (result)
return(Marshaling.ConvertVariantToManagedObject(result));
}
public static string TTR(this string text)
{
using godot_string textIn = Marshaling.ConvertStringToNative(text);
Internal.godot_icall_Globals_TTR(textIn, out godot_string dest);
using (dest)
return(Marshaling.ConvertStringToManaged(dest));
}
internal static unsafe void CallToString(IntPtr godotObjectGCHandle, godot_string *outRes, godot_bool *outValid)
{
try
{
var self = (Object)GCHandle.FromIntPtr(godotObjectGCHandle).Target;
if (self == null)
{
*outRes = default;
*outValid = godot_bool.False;
return;
}
var resultStr = self.ToString();
if (resultStr == null)
{
*outRes = default;
*outValid = godot_bool.False;
return;
}
*outRes = Marshaling.ConvertStringToNative(resultStr);
*outValid = godot_bool.True;
}
catch (Exception e)
{
ExceptionUtils.LogException(e);
*outRes = default;
*outValid = godot_bool.False;
}
}
public EditorProgress(string task, string label, int amount, bool canCancel = false)
{
Task = task;
using godot_string taskIn = Marshaling.ConvertStringToNative(task);
using godot_string labelIn = Marshaling.ConvertStringToNative(label);
Internal.godot_icall_EditorProgress_Create(taskIn, labelIn, amount, canCancel);
}
public static unsafe object EditorDef(string setting, object defaultValue, bool restartIfChanged = false)
{
using godot_string settingIn = Marshaling.ConvertStringToNative(setting);
using godot_variant defaultValueIn = Marshaling.ConvertManagedObjectToVariant(defaultValue);
Internal.godot_icall_Globals_EditorDef(settingIn, defaultValueIn, restartIfChanged, out godot_variant result);
using (result)
return(Marshaling.ConvertVariantToManagedObject(result));
}
/// <summary>
/// Gets the resource or property name indicated by <paramref name="idx"/> (0 to <see cref="GetSubNameCount"/>).
/// </summary>
/// <param name="idx">The subname index.</param>
/// <returns>The subname at the given index <paramref name="idx"/>.</returns>
public string GetSubName(int idx)
{
var self = (godot_node_path)NativeValue;
NativeFuncs.godotsharp_node_path_get_subname(self, idx, out godot_string subName);
using (subName)
return(Marshaling.ConvertStringToManaged(subName));
}
/// <summary>
/// Returns all subnames concatenated with a colon character (<c>:</c>)
/// as separator, i.e. the right side of the first colon in a node path.
/// </summary>
/// <example>
/// <code>
/// var nodepath = new NodePath("Path2D/PathFollow2D/Sprite2D:texture:load_path");
/// GD.Print(nodepath.GetConcatenatedSubnames()); // texture:load_path
/// </code>
/// </example>
/// <returns>The subnames concatenated with <c>:</c>.</returns>
public string GetConcatenatedSubNames()
{
var self = (godot_node_path)NativeValue;
NativeFuncs.godotsharp_node_path_get_concatenated_subnames(self, out godot_string subNames);
using (subNames)
return(Marshaling.ConvertStringToManaged(subNames));
}
/// <summary>
/// Converts this <see cref="Array"/> to a string.
/// </summary>
/// <returns>A string representation of this array.</returns>
public override string ToString()
{
var self = (godot_array)NativeValue;
NativeFuncs.godotsharp_array_to_string(ref self, out godot_string str);
using (str)
return(Marshaling.ConvertStringToManaged(str));
}
public static string[] CodeCompletionRequest(CodeCompletionRequest.CompletionKind kind,
string scriptFile)
{
using godot_string scriptFileIn = Marshaling.ConvertStringToNative(scriptFile);
godot_icall_Internal_CodeCompletionRequest((int)kind, scriptFileIn, out godot_packed_string_array res);
using (res)
return(Marshaling.ConvertNativePackedStringArrayToSystemArray(res));
}
private static bool IsAnyOS(IEnumerable <string> names)
{
Internal.godot_icall_Utils_OS_GetPlatformName(out godot_string dest);
using (dest)
{
string platformName = Marshaling.ConvertStringToManaged(dest);
return(names.Any(p => p.Equals(platformName, StringComparison.OrdinalIgnoreCase)));
}
}
private static bool IsOS(string name)
{
Internal.godot_icall_Utils_OS_GetPlatformName(out godot_string dest);
using (dest)
{
string platformName = Marshaling.ConvertStringToManaged(dest);
return(name.Equals(platformName, StringComparison.OrdinalIgnoreCase));
}
}
/// <summary>
/// Converts this <see cref="NodePath"/> to a string.
/// </summary>
/// <returns>A string representation of this <see cref="NodePath"/>.</returns>
public override string ToString()
{
if (IsEmpty)
{
return(string.Empty);
}
var src = (godot_node_path)NativeValue;
NativeFuncs.godotsharp_node_path_as_string(out godot_string dest, src);
using (dest)
return(Marshaling.ConvertStringToManaged(dest));
}
public string GetDatapath()
{
IntPtr pointer = Native.DllImports.TessBaseAPIGetDatapath((HandleRef)this);
if (pointer == null || pointer == IntPtr.Zero)
{
return(null);
}
else
{
return(Marshaling.PtrToStringUTF8(pointer));
}
}
/// <summary>
/// The recognized text is returned as a char* which is coded
/// as UNLV format Latin-1 with specific reject and suspect codes
/// and must be freed with the delete[] operator.
/// </summary>
public string GetUNLVText()
{
IntPtr pointer = Native.DllImports.TessBaseAPIGetUNLVText((HandleRef)this);
if (pointer == null || pointer == IntPtr.Zero)
{
return(null);
}
else
{
string returnObject = Marshaling.PtrToStringUTF8(pointer);
Native.DllImports.TessDeleteText(pointer); //Delete the text pointer to clear memory
return(returnObject);
}
}
public string GetUTF8Text(PageIteratorLevel level)
{
IntPtr pointer = Native.DllImports.TessResultIteratorGetUTF8Text(handleRef, level);
if (IntPtr.Zero != pointer)
{
string returnObject = Marshaling.PtrToStringUTF8(pointer);
Native.DllImports.TessDeleteText(pointer);
return(returnObject);
}
else
{
return(null);
}
}
/// <summary>
/// These functions are required for searchable PDF output.
/// We need our hands on the input file so that we can include
/// it in the PDF without transcoding.If that is not possible,
/// we need the original image. Finally, resolution metadata
/// is stored in the PDF so we need that as well.
/// </summary>
public string GetInputName()
{
IntPtr pointer = Native.DllImports.TessBaseAPIGetInputName((HandleRef)this);
if (pointer == null || pointer == IntPtr.Zero)
{
return(null);
}
else
{
string returnObject = Marshaling.PtrToStringUTF8(pointer);
Native.DllImports.TessDeleteText(pointer);
return(returnObject);
}
}
public string GetUTF8Text()
{
IntPtr pointer = Native.DllImports.TessChoiceIteratorGetUTF8Text(handleRef);
if (IntPtr.Zero != pointer)
{
string returnObject = Marshaling.PtrToStringUTF8(pointer);
DllImports.TessDeleteText(pointer);
return(returnObject);
}
else
{
return(null);
}
}
internal static unsafe godot_bool Get(IntPtr godotObjectGCHandle, godot_string_name *name,
godot_variant *outRet)
{
try
{
var godotObject = (Object)GCHandle.FromIntPtr(godotObjectGCHandle).Target;
if (godotObject == null)
{
throw new InvalidOperationException();
}
if (godotObject.GetGodotClassPropertyValue(CustomUnsafe.AsRef(name), out godot_variant outRetValue))
{
*outRet = outRetValue;
return(godot_bool.True);
}
var nameManaged = StringName.CreateTakingOwnershipOfDisposableValue(
NativeFuncs.godotsharp_string_name_new_copy(CustomUnsafe.AsRef(name)));
Variant ret = godotObject._Get(nameManaged);
if (ret.VariantType == Variant.Type.Nil)
{
*outRet = default;
return(godot_bool.False);
}
*outRet = Marshaling.ConvertManagedObjectToVariant(ret);
return(godot_bool.True);
}
catch (Exception e)
{
ExceptionUtils.LogException(e);
*outRet = default;
return(godot_bool.False);
}
}
/// <summary>
/// Encodes a <c>Variant</c> value to a byte array.
/// If <paramref name="fullObjects"/> is <see langword="true"/> encoding objects is allowed
/// (and can potentially include code).
/// Deserialization can be done with <see cref="BytesToVar(Span{byte}, bool)"/>.
/// </summary>
/// <param name="var">Variant that will be encoded.</param>
/// <param name="fullObjects">If objects should be serialized.</param>
/// <returns>The <c>Variant</c> encoded as an array of bytes.</returns>
public static byte[] VarToBytes(Variant var, bool fullObjects = false)
{
NativeFuncs.godotsharp_var_to_bytes((godot_variant)var.NativeVar, fullObjects.ToGodotBool(), out var varBytes);
using (varBytes)
return(Marshaling.ConvertNativePackedByteArrayToSystemArray(varBytes));
}
public bool TryStep(string state, int step = -1, bool forceRefresh = true)
{
using godot_string taskIn = Marshaling.ConvertStringToNative(Task);
using godot_string stateIn = Marshaling.ConvertStringToNative(state);
return(Internal.godot_icall_EditorProgress_Step(taskIn, stateIn, step, forceRefresh));
}
public void Dispose()
{
using godot_string taskIn = Marshaling.ConvertStringToNative(Task);
Internal.godot_icall_EditorProgress_Dispose(taskIn);
GC.SuppressFinalize(this);
}
/// <summary>
/// Get the <see cref="Variant.Type"/> that corresponds for the given <see cref="Type"/>.
/// </summary>
/// <returns>The <see cref="Variant.Type"/> for the given <paramref name="type"/>.</returns>
public static Variant.Type TypeToVariantType(Type type)
{
return(Marshaling.ConvertManagedTypeToVariantType(type, out bool _));
}
/// <summary>
/// Converts a <c>Variant</c> <paramref name="var"/> to a formatted string that
/// can later be parsed using <see cref="StrToVar(string)"/>.
/// </summary>
/// <example>
/// <code>
/// var a = new Godot.Collections.Dictionary { ["a"] = 1, ["b"] = 2 };
/// GD.Print(GD.VarToStr(a));
/// // Prints
/// // {
/// // "a": 1,
/// // "b": 2
/// // }
/// </code>
/// </example>
/// <param name="var">Variant that will be converted to string.</param>
/// <returns>The <c>Variant</c> encoded as a string.</returns>
public static string VarToStr(Variant var)
{
NativeFuncs.godotsharp_var_to_str((godot_variant)var.NativeVar, out godot_string ret);
using (ret)
return(Marshaling.ConvertStringToManaged(ret));
}
public static bool IsMacOSAppBundleInstalled(string bundleId)
{
using godot_string bundleIdIn = Marshaling.ConvertStringToNative(bundleId);
return(godot_icall_Internal_IsMacOSAppBundleInstalled(bundleIdIn));
}
