Resource

public Resource();

Creates an owned Resource with empty path/name. Loads no file, registers no format and adds no Entity to a tree. Resources may be shared: choose the appropriate Duplicate mode for independent data rather than another variable pointing to the same object.

public bool ResourceLocalToScene { get; set; }

Marks a resource for level/prefab instance-local handling by PackedEntity. Set before instantiation; changing the flag does not retroactively separate shared references. Not uniqueness per every Entity or a network ID. Actual PackedEntity handling was source-reviewed; a standalone flag assigning no GetLocalScene root was executed.

public string ResourceName { get; set; }

Display name. Assignment emits Changed even for the same value; renames no file and does not change ResourcePath.

public string ResourcePath { get; set; }

Path and shared-resource cache key, not a file-save command. The setter registers a nonempty path; empty unregisters it. For an occupied path use an intentional TakeOverPath or another path. Current native code rejects a collision after removing this object previous registration and clearing its path, so rollback is not promised. The collision branch was source-reviewed without executing the failing case.

public string ResourceSceneUniqueId { get; set; }

Local serialized-subresource ID. ASCII letters, digits, underscore and empty are allowed. An invalid character causes native diagnostics and replacement with a generated candidate rather than preserving the old value. Distinct from uid:// and project-wide uniqueness.

public Error CopyFromResource(Resource resource);

Copies STORAGE properties into the existing object while preserving its ResourcePath. Calls ResetState first; nested Resources remain shared rather than deeply copied. Checks the native engine class, not exact C# type equality. A mismatch returns InvalidParameter; null is also invalid. Changed emissions are batched into one pending notification if any occurred; Ok promises neither independent nested data nor disk persistence.

public Resource Duplicate(bool deep = false);

Creates a new root Resource and copies stored properties/script, excluding ResourcePath. Containers and nested resources are shared by default. deep=true copies containers and built-in nested Resources; externally pathed resources normally remain shared. Repeated references to one duplicated resource point to one copy. Property usage flags can override the rule. Use DuplicateDeep(All) for external resources too; custom constructors/scripts can constrain duplication.

public Resource DuplicateDeep(Resource.DeepDuplicateMode deepSubresourcesMode = Resource.DeepDuplicateMode.Internal);

Creates a new root and recursively copies Array/Dictionary containers. None shares nested Resources; Internal duplicates built-in ones; All includes external Resources. All does not promise universal independence: scripts and NEVER_DUPLICATE properties may remain shared. A remap preserves repeated references within the copied graph rather than cloning every occurrence separately. Original Resource paths are not copied; nothing is saved to disk.

public void EmitChanged();

Notifies Changed subscribers after a data change. Writes no file and guarantees no refresh of every editor view. Call after an actual change in a custom C# setter; avoid recursively emitting from your own Changed handler. During background loading the native backend may defer notification to the main thread.

public static string GenerateSceneUniqueId();

Creates a short five-character internal-ID candidate. Not a global UID, cryptographic identifier or uniqueness reservation. The current implementation uses a–y and 0–8; do not build a permanent public protocol around that detail. The saving caller handles collisions.

public string GetIdForPath(string path);

Reads the editor ID cache for the pair of referring file path and this resource current ResourcePath. Not ResourceUid or an ID read from an arbitrary file. Returns empty when absent or built without TOOLS_ENABLED. Editor persistence was source-reviewed only.

public Entity GetLocalScene();

Returns the Entity root assigned by local-to-scene handling, an available editor context, or null. Setting ResourceLocalToScene=true alone neither creates nor assigns a root. The returned Entity is borrowed; do not Free it as your own temporary object. Actual PackedEntity instantiation was not executed in this pass.

public string GetName();

Returns ResourceName, a display name rather than a file path or global registry key.

public string GetPath();

Returns the current ResourcePath string. It may be empty, internal, or set with SetPathCache without registration. Nonempty does not prove a file exists, was loaded or was written.

public Rid GetRid();

Returns a backend-resource RID when provided by the concrete type. Base Resource returns an empty RID; not an InstanceId. Do not manually free a returned RID still owned by the Resource. IsValid checks a nonzero value, not suitability for every server API.

public string GetSceneUniqueId();

Returns ResourceSceneUniqueId, a local serialized-subresource ID rather than global ResourceUid. Empty is permitted.

public bool IsBuiltIn();

Classifies by path: empty, containing ::, or starting with local:// counts as built-in. Deep duplication uses this rule; it validates neither file presence, saving nor Entity ownership.

public bool IsLocalToScene();

Returns the ResourceLocalToScene flag. True does not prove this instance has already been duplicated or assigned an Entity root.

public void ResetState();

Calls _ResetState for state the concrete class must clear itself. The base implementation does not automatically zero every exported property, name or path. CopyFromResource calls this hook before copying.

public void SetIdForPath(string path, string id);

Writes the editor ID cache for a referring file and current ResourcePath. Empty id removes the entry. Assigns no ResourceUid, saves no file and registers no new resource path. Does nothing without TOOLS_ENABLED; editor workflow was not executed here.

public void SetLocalToScene(bool enable);

Sets ResourceLocalToScene. Creates no immediate copy, rewires no existing references and assigns no GetLocalScene root.

public void SetName(string name);

Sets ResourceName and emits Changed, including for the same value. Performs no file rename.

public void SetPath(string path);

Sets ResourcePath with ordinary cache registration. Writes/moves no file. A path occupied by another resource produces native diagnostics; current implementation has already cleared this object previous path at that point. Use TakeOverPath for intentional ownership replacement; SetPathCache has different raw-path semantics.

public void SetPathCache(string path);

Internally changes the path string and invokes _SetPathCache, bypassing ResourceCache registration. Not equivalent to ResourcePath/SetPath. Do not use to ordinarily move a cached object: this operation maintains no cache-entry consistency. Tested on an unregistered QA object.

public void SetSceneUniqueId(string id);

Sets local ResourceSceneUniqueId. ASCII letters, digits and underscore are permitted; empty is accepted. For an invalid character native code assigns a generated ID and emits diagnostics. Writes no file and reserves no global uniqueness.

public void SetupLocalToScene();

SDK-obsolete internal method. Emits SetupLocalToSceneRequested then calls _SetupLocalToScene. Does not itself duplicate the resource or enable local-to-scene. Override _SetupLocalToScene in ordinary user classes instead of manually calling this method; internal dispatch was exercised only by deliberate QA.

public void TakeOverPath(string path);

Assigns a resource path while replacing its cache owner. Existing references keep the previous owner alive, but its ResourcePath becomes empty. Subsequent path lookup points to this resource. Moves/saves no files; use only for intentional shared-object replacement.

public virtual Rid _GetRid();

Hook for the concrete resource GetRid. Return a RID of an actually owned backend object or an empty RID. Returning it creates no server object and transfers no ownership to the caller; do not substitute an InstanceId as a RID.

public virtual void _ResetState();

Override to clear your own nonstored/dynamic state. Called by ResetState, including before CopyFromResource. Do not recursively call ResetState from the hook; no automatic reset of all properties is provided.

public virtual void _SetPathCache(string path);

Notification after internal SetPathCache. The path is already assigned; the hook substitutes for neither ResourcePath registration nor file-operation confirmation. Do not recursively call SetPathCache here.

public virtual void _SetupLocalToScene();

Override to initialize a resource in local-to-scene handling. GetLocalScene can supply the assigned root; check for null outside normal instantiation. Not an every-Entity constructor or _Ready. Standalone callback dispatch was tested; actual PackedEntity local duplication was not executed in this pass.

public event Action Changed;

Change notification, not an automatic disk save. ResourceName emits even when assigned the same value. An ordinary custom C# [Export] setter does not emit automatically: call EmitChanged after a meaningful change. Shared references observe the same object.

public event Action SetupLocalToSceneRequested;

SDK-obsolete: override _SetupLocalToScene for resource initialization instead of subscribing here. Native setup emits this event before the callback; the event itself proves neither duplication nor a level root.