/// <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); }
private Dictionary(godot_dictionary nativeValueToOwn) { NativeValue = (godot_dictionary.movable)(nativeValueToOwn.IsAllocated ? nativeValueToOwn : NativeFuncs.godotsharp_dictionary_new()); _weakReferenceToSelf = DisposablesTracker.RegisterDisposable(this); }
/// <summary> /// Searches this <see cref="Array"/> for an item /// and returns its index or -1 if not found. /// </summary> /// <param name="item">The <see cref="Variant"/> item to search for.</param> /// <returns>The index of the item, or -1 if not found.</returns> public int IndexOf(Variant item) { godot_variant variantValue = (godot_variant)item.NativeVar; var self = (godot_array)NativeValue; return(NativeFuncs.godotsharp_array_index_of(ref self, variantValue)); }
/// <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); }
internal static unsafe godot_bool Set(IntPtr godotObjectGCHandle, godot_string_name *name, godot_variant *value) { try { var godotObject = (Object)GCHandle.FromIntPtr(godotObjectGCHandle).Target; if (godotObject == null) { throw new InvalidOperationException(); } if (godotObject.SetGodotClassPropertyValue(CustomUnsafe.AsRef(name), CustomUnsafe.AsRef(value))) { return(godot_bool.True); } var nameManaged = StringName.CreateTakingOwnershipOfDisposableValue( NativeFuncs.godotsharp_string_name_new_copy(CustomUnsafe.AsRef(name))); Variant valueManaged = Variant.CreateCopyingBorrowed(*value); return(godotObject._Set(nameManaged, valueManaged).ToGodotBool()); } catch (Exception e) { ExceptionUtils.LogException(e); return(godot_bool.False); } }
/// <summary> /// Adds an item to the end of this <see cref="Array"/>. /// This is the same as <c>append</c> or <c>push_back</c> in GDScript. /// </summary> /// <param name="item">The <see cref="Variant"/> item to add.</param> public void Add(Variant item) { godot_variant variantValue = (godot_variant)item.NativeVar; var self = (godot_array)NativeValue; _ = NativeFuncs.godotsharp_array_add(ref self, variantValue); }
/// <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> /// Returns a node path with a colon character (<c>:</c>) prepended, /// transforming it to a pure property path with no node name (defaults /// to resolving from the current node). /// </summary> /// <example> /// <code> /// // This will be parsed as a node path to the "x" property in the "position" node. /// var nodePath = new NodePath("position:x"); /// // This will be parsed as a node path to the "x" component of the "position" property in the current node. /// NodePath propertyPath = nodePath.GetAsPropertyPath(); /// GD.Print(propertyPath); // :position:x /// </code> /// </example> /// <returns>The <see cref="NodePath"/> as a pure property path.</returns> public NodePath GetAsPropertyPath() { godot_node_path propertyPath = default; var self = (godot_node_path)NativeValue; NativeFuncs.godotsharp_node_path_get_as_property_path(self, ref propertyPath); return(CreateTakingOwnershipOfDisposableValue(propertyPath)); }
/// <summary> /// Constructs a <see cref="NodePath"/> from a string <paramref name="path"/>, /// e.g.: <c>"Path2D/PathFollow2D/Sprite2D:texture:size"</c>. /// A path is absolute if it starts with a slash. Absolute paths /// are only valid in the global scene tree, not within individual /// scenes. In a relative path, <c>"."</c> and <c>".."</c> indicate /// the current node and its parent. /// The "subnames" optionally included after the path to the target /// node can point to resources or properties, and can also be nested. /// </summary> /// <example> /// Examples of valid NodePaths (assuming that those nodes exist and /// have the referenced resources or properties): /// <code> /// // Points to the Sprite2D node. /// "Path2D/PathFollow2D/Sprite2D" /// // Points to the Sprite2D node and its "texture" resource. /// // GetNode() would retrieve "Sprite2D", while GetNodeAndResource() /// // would retrieve both the Sprite2D node and the "texture" resource. /// "Path2D/PathFollow2D/Sprite2D:texture" /// // Points to the Sprite2D node and its "position" property. /// "Path2D/PathFollow2D/Sprite2D:position" /// // Points to the Sprite2D node and the "x" component of its "position" property. /// "Path2D/PathFollow2D/Sprite2D:position:x" /// // Absolute path (from "root") /// "/root/Level/Path2D" /// </code> /// </example> /// <param name="path">A string that represents a path in a scene tree.</param> public NodePath(string path) { if (!string.IsNullOrEmpty(path)) { NativeValue = (godot_node_path.movable)NativeFuncs.godotsharp_node_path_new_from_string(path); _weakReferenceToSelf = DisposablesTracker.RegisterDisposable(this); } }
/// <summary> /// Constructs a <see cref="StringName"/> from the given <paramref name="name"/> string. /// </summary> /// <param name="name">String to construct the <see cref="StringName"/> from.</param> public StringName(string name) { if (!string.IsNullOrEmpty(name)) { NativeValue = (godot_string_name.movable)NativeFuncs.godotsharp_string_name_new_from_string(name); _weakReferenceToSelf = DisposablesTracker.RegisterDisposable(this); } }
/// <summary> /// Duplicates this <see cref="Dictionary"/>. /// </summary> /// <param name="deep">If <see langword="true"/>, performs a deep copy.</param> /// <returns>A new Godot Dictionary.</returns> public Dictionary Duplicate(bool deep = false) { godot_dictionary newDictionary; var self = (godot_dictionary)NativeValue; NativeFuncs.godotsharp_dictionary_duplicate(ref self, deep.ToGodotBool(), out newDictionary); return(CreateTakingOwnershipOfDisposableValue(newDictionary)); }
public unsafe void Dispose() { if (_ptr == null) { return; } NativeFuncs.godotsharp_stack_info_vector_destroy(ref this); _ptr = null; }
public SignalAwaiter(Object source, StringName signal, Object target) { var awaiterGcHandle = CustomGCHandle.AllocStrong(this); using godot_string_name signalSrc = NativeFuncs.godotsharp_string_name_new_copy( (godot_string_name)(signal?.NativeValue ?? default)); NativeFuncs.godotsharp_internal_signal_awaiter_connect(Object.GetPtr(source), in signalSrc, Object.GetPtr(target), GCHandle.ToIntPtr(awaiterGcHandle)); }
/// <summary> /// Removes an element from this <see cref="Array"/> by index. /// </summary> /// <param name="index">The index of the element to remove.</param> public void RemoveAt(int index) { if (index < 0 || index > Count) { throw new ArgumentOutOfRangeException(nameof(index)); } var self = (godot_array)NativeValue; NativeFuncs.godotsharp_array_remove_at(ref self, index); }
/// <summary> /// Inserts a new item at a given position in the array. /// The position must be a valid position of an existing item, /// or the position at the end of the array. /// Existing items will be moved to the right. /// </summary> /// <param name="index">The index to insert at.</param> /// <param name="item">The <see cref="Variant"/> item to insert.</param> public void Insert(int index, Variant item) { if (index < 0 || index > Count) { throw new ArgumentOutOfRangeException(nameof(index)); } godot_variant variantValue = (godot_variant)item.NativeVar; var self = (godot_array)NativeValue; NativeFuncs.godotsharp_array_insert(ref self, index, variantValue); }
public void Resize(int size) { if (size < 0) { throw new ArgumentOutOfRangeException(nameof(size)); } var err = NativeFuncs.godotsharp_stack_info_vector_resize(ref this, size); if (err != Error.Ok) { throw new InvalidOperationException("Failed to resize vector. Error code is: " + err.ToString()); } }
private (Array keys, Array values, int count) GetKeyValuePairs() { var self = (godot_dictionary)NativeValue; godot_array keysArray; NativeFuncs.godotsharp_dictionary_keys(ref self, out keysArray); var keys = Array.CreateTakingOwnershipOfDisposableValue(keysArray); godot_array valuesArray; NativeFuncs.godotsharp_dictionary_keys(ref self, out valuesArray); var values = Array.CreateTakingOwnershipOfDisposableValue(valuesArray); int count = NativeFuncs.godotsharp_dictionary_count(ref self); return(keys, values, count); }
/// <summary> /// Returns a weak reference to an object, or <see langword="null"/> /// if the argument is invalid. /// A weak reference to an object is not enough to keep the object alive: /// when the only remaining references to a referent are weak references, /// garbage collection is free to destroy the referent and reuse its memory /// for something else. However, until the object is actually destroyed the /// weak reference may return the object even if there are no strong references /// to it. /// </summary> /// <param name="obj">The object.</param> /// <returns> /// The <see cref="WeakRef"/> reference to the object or <see langword="null"/>. /// </returns> public static WeakRef WeakRef(Object obj) { if (!IsInstanceValid(obj)) { return(null); } NativeFuncs.godotsharp_weakref(GetPtr(obj), out godot_ref weakRef); using (weakRef) { if (weakRef.IsNull) { return(null); } return((WeakRef)InteropUtils.UnmanagedGetManaged(weakRef.Reference)); } }
public Array(Span <NodePath> array) : this() { if (array == null) { throw new ArgumentNullException(nameof(array)); } NativeValue = (godot_array.movable)NativeFuncs.godotsharp_array_new(); _weakReferenceToSelf = DisposablesTracker.RegisterDisposable(this); int length = array.Length; Resize(length); for (int i = 0; i < length; i++) { this[i] = array[i]; } }
/// <summary> /// Returns the item at the given <paramref name="index"/>. /// </summary> /// <value>The <see cref="Variant"/> item at the given <paramref name="index"/>.</value> public unsafe Variant this[int index] { get { GetVariantBorrowElementAt(index, out godot_variant borrowElem); return(Variant.CreateCopyingBorrowed(borrowElem)); } set { if (index < 0 || index >= Count) { throw new ArgumentOutOfRangeException(nameof(index)); } var self = (godot_array)NativeValue; godot_variant *ptrw = NativeFuncs.godotsharp_array_ptrw(ref self); godot_variant *itemPtr = &ptrw[index]; (*itemPtr).Dispose(); *itemPtr = value.CopyNativeVariant(); } }
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> /// Resizes this <see cref="Array"/> to the given size. /// </summary> /// <param name="newSize">The new size of the array.</param> /// <returns><see cref="Error.Ok"/> if successful, or an error code.</returns> public Error Resize(int newSize) { var self = (godot_array)NativeValue; return(NativeFuncs.godotsharp_array_resize(ref self, newSize)); }
/// <summary> /// Constructs a new empty <see cref="Dictionary"/>. /// </summary> public Dictionary() { NativeValue = (godot_dictionary.movable)NativeFuncs.godotsharp_dictionary_new(); _weakReferenceToSelf = DisposablesTracker.RegisterDisposable(this); }
/// <summary> /// Gets the number of resource or property names ("subnames") in the path. /// Each subname is listed after a colon character (<c>:</c>) in the node path. /// For example, <c>"Path2D/PathFollow2D/Sprite2D:texture:load_path"</c> has 2 subnames. /// </summary> /// <returns>The number of subnames in the path.</returns> public int GetSubNameCount() { var self = (godot_node_path)NativeValue; return(NativeFuncs.godotsharp_node_path_get_subname_count(self)); }
/// <summary> /// Returns <see langword="true"/> if the node path is absolute (as opposed to relative), /// which means that it starts with a slash character (<c>/</c>). Absolute node paths can /// be used to access the root node (<c>"/root"</c>) or autoloads (e.g. <c>"/global"</c> /// if a "global" autoload was registered). /// </summary> /// <returns>If the <see cref="NodePath"/> is an absolute path.</returns> public bool IsAbsolute() { var self = (godot_node_path)NativeValue; return(NativeFuncs.godotsharp_node_path_is_absolute(self).ToBool()); }
/// <summary> /// Shuffles the contents of this <see cref="Array"/> into a random order. /// </summary> public void Shuffle() { var self = (godot_array)NativeValue; NativeFuncs.godotsharp_array_shuffle(ref self); }
/// <summary> /// Constructs a new empty <see cref="Array"/>. /// </summary> public Array() { NativeValue = (godot_array.movable)NativeFuncs.godotsharp_array_new(); _weakReferenceToSelf = DisposablesTracker.RegisterDisposable(this); }