Surface _validate_property method in Godot for allowing custom properties to be controlled (#675)

* Surface _validate_property method in Godot for allowing custom properties to be controlled

* Oh so the return value means - copy the results back, as a way of altering the properties

* Make PropInfo fields variables, so they can be changed

* Blindly: what if we keep a reference to the original to update

* Revert last changes, crashes and does not fix it

* Ok, now with a test: _validateProperty works

Author: migueldeicaza

Sources/SwiftGodot/Core/ClassServices.swift

@@ -199,17 +199,17 @@ public class ClassInfo<T:Object> {
 /// The supported types are those that can be wrapped as a Godot Variant type.
 public struct PropInfo: CustomDebugStringConvertible {
     /// The type of the property being defined
-    public let propertyType: Variant.GType
+    public var propertyType: Variant.GType
     /// The name for the property
-    public let propertyName: StringName
+    public var propertyName: StringName
     /// The class name where this is defined
-    public let className: StringName
+    public var className: StringName
     /// Property Hint for this property
-    public let hint: PropertyHint
+    public var hint: PropertyHint
     /// Human-readable hint
-    public let hintStr: GString
+    public var hintStr: GString
     /// Describes how the property can be used.
-    public let usage: PropertyUsageFlags
+    public var usage: PropertyUsageFlags
 
     public init(propertyType: Variant.GType, propertyName: StringName, className: StringName, hint: PropertyHint, hintStr: GString, usage: PropertyUsageFlags) {
         self.propertyType = propertyType

Sources/SwiftGodot/Core/Wrapped.swift

@@ -201,7 +201,12 @@ open class Wrapped: Equatable, Identifiable, Hashable {
     /// For example `Node.notificationProcess`
     open func _notification(code: Int, reversed: Bool) {
     }
-    
+
+    ///  Called whenever Godot retrieves value of property. Allows to customize existing properties.
+    /// Return true if you made changes to the PropInfo value you got
+    open func _validateProperty(_ property: inout PropInfo) -> Bool {
+        return false
+    }
 
     /// Checks if this object has a script with the given method.
     /// - Parameter method: StringName identifying the method.
@@ -352,6 +357,7 @@ func register<T:Wrapped> (type name: StringName, parent: StringName, type: T.Typ
     info.get_virtual_func = getVirtual
     info.notification_func = notificationFunc
     info.recreate_instance_func = recreateFunc
+    info.validate_property_func = validatePropertyFunc
     info.is_exposed = 1
     userTypes [name.description] = { ptr in
         return type.init(nativeHandle: ptr)
@@ -547,6 +553,38 @@ func notificationFunc (ptr: UnsafeMutableRawPointer?, code: Int32, reversed: UIn
     original._notification(code: Int(code), reversed: reversed != 0)
 }
 
+func validatePropertyFunc(ptr: UnsafeMutableRawPointer?, _info: UnsafeMutablePointer<GDExtensionPropertyInfo>?) -> UInt8 {
+    guard let ptr else { return 0 }
+    let original = Unmanaged<Wrapped>.fromOpaque(ptr).takeUnretainedValue()
+    guard var info = _info?.pointee else { return 0 }
+    guard let namePtr = info.name,
+          let classNamePtr = info.class_name,
+          let infoHintPtr = info.hint_string else {
+        return 0
+    }
+    guard let ptype = Variant.GType(rawValue: Int64(info.type.rawValue)) else { return 0 }
+    let pname = StringName(fromPtr: namePtr)
+    let className = StringName(fromPtr: classNamePtr)
+    let hint = PropertyHint(rawValue: Int64(info.hint)) ?? .none
+    let hintStr = GString(content: infoHintPtr.load(as: Int64.self))
+    let usage = PropertyUsageFlags(rawValue: Int(info.usage))
+
+    var pinfo = PropInfo(propertyType: ptype, propertyName: pname, className: className, hint: hint, hintStr: hintStr, usage: usage)
+    if original._validateProperty(&pinfo) {
+        // The problem with the code below is that it does not make a copy of the StringName and String,
+        // and passes a reference that we will destroy right away when `pinfo` goes out of scope.
+        //
+        // For now, we just update the usage, type and hint but we need to find a solution for those other fields
+        let native = pinfo.makeNativeStruct()
+        _info?.pointee.usage = UInt32(pinfo.usage.rawValue)
+        _info?.pointee.hint = UInt32(pinfo.hint.rawValue)
+        _info?.pointee.type = GDExtensionVariantType(GDExtensionVariantType.RawValue (pinfo.propertyType.rawValue))
+
+        return 1
+    }
+    return 0
+}
+
 func userTypeBindingCreate (_ token: UnsafeMutableRawPointer?, _ instance: UnsafeMutableRawPointer?) -> UnsafeMutableRawPointer? {
     // Godot-cpp does nothing for user types
     //print ("SWIFT: instanceBindingCreate")

Tests/SwiftGodotTests/SignalTests.swift

@@ -13,6 +13,11 @@ private class TestSignalNode: Node {
         receivedInt = age
         receivedString = name
     }
+
+    override func _validateProperty(_ prop: inout PropInfo) -> Bool {
+
+        return true
+    }
 }
 
 final class SignalTests: GodotTestCase {

Tests/SwiftGodotTests/ValidatePropertyTests.swift

@@ -0,0 +1,47 @@
+//
+//  ValidatePropertyTests.swift
+//  SwiftGodot
+//
+//  Created by Miguel de Icaza on 3/29/25.
+//
+
+import XCTest
+import SwiftGodotTestability
+@testable import SwiftGodot
+
+@Godot
+private class TestProp: Node {
+    @Export
+    var changeThisVariable: Int = 1
+
+    override func _validateProperty(_ prop: inout PropInfo) -> Bool {
+        if prop.propertyName == "changeThisVariable" {
+            prop.usage.insert(.group)
+            return true
+        }
+        return false
+    }
+}
+
+final class TestProperty: GodotTestCase {
+    override static var godotSubclasses: [Wrapped.Type] {
+        return [TestProp.self]
+    }
+
+    func testThing() {
+        var found = false
+        let node = TestProp()
+        for prop in node.getPropertyList() {
+            //print("PROP: \(prop)")
+            guard let nameV = prop["name"] else { continue }
+            guard let name = String(nameV) else { continue }
+            guard let flagsV = prop["usage"], let iflags = Int(flagsV) else { continue }
+            let flags = PropertyUsageFlags(rawValue: iflags)
+
+            if name == "changeThisVariable", flags.contains(.group) {
+                found = true
+            }
+        }
+        XCTAssertTrue(found, "Should have found a property named hideThisVariable with the usage set to 'readOnly'")
+    }
+}