Variant — C# API

struct VariantReckfellSharpInherits ValueType

Variant holds one value and its VariantType tag. Check type and constraints before conversion; As<T> is not strict schema validation. Int maps to long and Float to double. Containers can be shared, and an Entity reference does not guarantee the object still exists.

Declarations checked against C# SDK 1.0.0. Expand a name to see declarations and documentation.

Properties2

ObjProperty

# Obj

C#
public object? Obj { get; }

Managed object representation: Int is boxed as long, Float as double, Nil becomes null. Containers and engine objects retain their reference semantics; this is not an independent deep copy.

VariantTypeProperty

# VariantType

public Variant.Type VariantType { get; }

Tag of the actually stored engine type. Check it before strict reads: successful AsInt32 conversion does not prove the original tag was Int.

Methods227

AsT

# As

public T? As<T>();

Converts the value to supported type T through Variant conversion rules. Does not guarantee an exact original tag, allowed range or deep container copying.

Returns T

Result converted to supported T.

AsAabbAabb

# AsAabb

C#
public Aabb AsAabb();

Returns Aabb

AsBasisBasis

# AsBasis

C#
public Basis AsBasis();

Returns Basis

AsBoolbool

# AsBool

C#
public bool AsBool();

Returns bool

AsBytebyte

# AsByte

C#
public byte AsByte();

Returns byte

AsByteArraybyte[]

# AsByteArray

C#
public byte[] AsByteArray();

Returns byte[]

AsCallableCallable

# AsCallable

C#
public Callable AsCallable();

Returns Callable

AsCharchar

# AsChar

C#
public char AsChar();

Returns char

AsColorColor

# AsColor

C#
public Color AsColor();

Returns Color

AsColorArrayColor[]

# AsColorArray

C#
public Color[] AsColorArray();

Returns Color[]

AsDoubledouble

# AsDouble

C#
public double AsDouble();

Reads the stored Float as double or performs a supported numeric conversion. Check VariantType separately when the input must specifically be Float.

Returns double

Double-precision number after conversion.

AsEntityPathEntityPath

# AsEntityPath

C#
public EntityPath AsEntityPath();

Returns EntityPath

AsFloat32Arrayfloat[]

# AsFloat32Array

C#
public float[] AsFloat32Array();

Returns float[]

AsFloat64Arraydouble[]

# AsFloat64Array

C#
public double[] AsFloat64Array();

Returns double[]

AsInt16short

# AsInt16

C#
public short AsInt16();

Returns short

AsInt32int

# AsInt32

C#
public int AsInt32();

Converts to a 32-bit integer without validating the exact original type or allowed range. Int 2147483648 narrows to -2147483648. For validation require Type.Int first and range-check AsInt64 against int bounds.

Returns int

Converted int, without range validation.

AsInt32Arrayint[]

# AsInt32Array

C#
public int[] AsInt32Array();

Returns a managed copy of PackedInt32Array contents. Editing the returned int[] does not modify the packed value stored in Variant; check the corresponding tag for strict input.

Returns int[]

New managed int[] containing copied elements.

AsInt64long

# AsInt64

C#
public long AsInt64();

Reads Int as a signed 64-bit integer or performs a supported conversion from another type. For example Float 3.75 becomes 3; this does not replace checking VariantType.

Returns long

Signed 64-bit integer after conversion.

AsInt64Arraylong[]

# AsInt64Array

C#
public long[] AsInt64Array();

Returns long[]

AsPlanePlane

# AsPlane

C#
public Plane AsPlane();

Returns Plane

AsProjectionProjection

# AsProjection

C#
public Projection AsProjection();

Returns Projection

AsQuaternionQuaternion

# AsQuaternion

C#
public Quaternion AsQuaternion();

Returns Quaternion

AsReckfellArray2 overloads

# AsReckfellArray · 1/2

C#
public Reckfell.Collections.Array AsReckfellArray();

Returns an engine Array wrapper sharing the original container, not a deep copy. Element changes are visible through other references; use Duplicate for an independent outer container.

Returns Reckfell.Collections.Array

Wrapper for the shared engine Array.

# AsReckfellArray · 2/2

C#
public Reckfell.Collections.Array<T> AsReckfellArray<T>();

Returns Reckfell.Collections.Array<T>

AsReckfellDictionary2 overloads

# AsReckfellDictionary · 1/2

C#
public Reckfell.Collections.Dictionary AsReckfellDictionary();

Returns an engine Dictionary wrapper sharing the original contents. This does not produce System.Collections.Generic.Dictionary or a deep copy.

Returns Reckfell.Collections.Dictionary

Wrapper for the shared engine Dictionary.

# AsReckfellDictionary · 2/2

C#
public Reckfell.Collections.Dictionary<TKey, TValue> AsReckfellDictionary<TKey, TValue>();

Returns Reckfell.Collections.Dictionary<TKey, TValue>

AsReckfellObjectReckfellObject

# AsReckfellObject

C#
public ReckfellObject AsReckfellObject();

Returns the engine object with identity preserved, not a clone. An Entity can be explicitly freed while a Variant exists; use IsInstanceValid before using a potentially expired object.

Returns ReckfellObject

Engine object or null; validate object liveness separately.

AsReckfellObjectArrayT[]

# AsReckfellObjectArray

C#
public T[] AsReckfellObjectArray<T>() where T : ReckfellObject;

Returns T[]

AsRect2Rect2

# AsRect2

C#
public Rect2 AsRect2();

Returns Rect2

AsRect2IRect2I

# AsRect2I

C#
public Rect2I AsRect2I();

Returns Rect2I

AsRidRid

# AsRid

C#
public Rid AsRid();

Returns Rid

AsSBytesbyte

# AsSByte

C#
public sbyte AsSByte();

Returns sbyte

AsSignalSignal

# AsSignal

C#
public Signal AsSignal();

Returns Signal

AsSinglefloat

# AsSingle

C#
public float AsSingle();

Converts to C# float. Stored Float has double precision, so narrowing can lose precision; this method does not validate an exact input schema.

Returns float

Converted float, with possible precision loss.

AsStringstring

# AsString

C#
public string AsString();

Returns a string representation, not proof that the stored tag is String. Check VariantType for an exact text field; this representation is not a serialization format.

Returns string

String representation of the value.

AsStringArraystring[]

# AsStringArray

C#
public string[] AsStringArray();

Returns string[]

AsStringNameStringName

# AsStringName

C#
public StringName AsStringName();

Returns StringName

AsSystemArrayOfEntityPathEntityPath[]

# AsSystemArrayOfEntityPath

C#
public EntityPath[] AsSystemArrayOfEntityPath();

Returns EntityPath[]

AsSystemArrayOfRidRid[]

# AsSystemArrayOfRid

C#
public Rid[] AsSystemArrayOfRid();

Returns Rid[]

AsSystemArrayOfStringNameStringName[]

# AsSystemArrayOfStringName

C#
public StringName[] AsSystemArrayOfStringName();

Returns StringName[]

AsTransform2DTransform2D

# AsTransform2D

C#
public Transform2D AsTransform2D();

Returns Transform2D

AsTransform3DTransform3D

# AsTransform3D

C#
public Transform3D AsTransform3D();

Returns Transform3D

AsUInt16ushort

# AsUInt16

C#
public ushort AsUInt16();

Returns ushort

AsUInt32uint

# AsUInt32

C#
public uint AsUInt32();

Returns uint

AsUInt64ulong

# AsUInt64

C#
public ulong AsUInt64();

Returns ulong

AsVector2Vector2

# AsVector2

C#
public Vector2 AsVector2();

Extracts or converts to Vector2. For an exact position field check Type.Vector2 and, when required, IsFinite; Vector2I has a different tag.

Returns Vector2

Vector2; component finiteness is not separately validated.

AsVector2ArrayVector2[]

# AsVector2Array

C#
public Vector2[] AsVector2Array();

Returns Vector2[]

AsVector2IVector2I

# AsVector2I

C#
public Vector2I AsVector2I();

Returns Vector2I

AsVector3Vector3

# AsVector3

C#
public Vector3 AsVector3();

Returns Vector3

AsVector3ArrayVector3[]

# AsVector3Array

C#
public Vector3[] AsVector3Array();

Returns Vector3[]

AsVector3IVector3I

# AsVector3I

C#
public Vector3I AsVector3I();

Returns Vector3I

AsVector4Vector4

# AsVector4

C#
public Vector4 AsVector4();

Returns Vector4

AsVector4ArrayVector4[]

# AsVector4Array

C#
public Vector4[] AsVector4Array();

Returns Vector4[]

AsVector4IVector4I

# AsVector4I

C#
public Vector4I AsVector4I();

Returns Vector4I

CopyNativeVariantReckfell.NativeInterop.reckfell_variant

# CopyNativeVariant

C#
public Reckfell.NativeInterop.reckfell_variant CopyNativeVariant();

Constructs a new NativeInterop.reckfell_variant from this instance. The caller is responsible of disposing the new instance to avoid memory leaks.

Returns Reckfell.NativeInterop.reckfell_variant

CreateCopyingBorrowedVariant

# CreateCopyingBorrowed

C#
public static Variant CreateCopyingBorrowed(in Reckfell.NativeInterop.reckfell_variant nativeValueToOwn);

Parameters
Name	Type	Default
`nativeValueToOwn`	`Reckfell.NativeInterop.reckfell_variant`	—

Returns Variant

CreateFrom53 overloads

# CreateFrom · 1/53

C#
public static Variant CreateFrom(Aabb from);

Parameters
Name	Type	Default
`from`	`Aabb`	—

Returns Variant

# CreateFrom · 2/53

C#
public static Variant CreateFrom(Basis from);

Parameters
Name	Type	Default
`from`	`Basis`	—

Returns Variant

# CreateFrom · 3/53

C#
public static Variant CreateFrom(Callable from);

Parameters
Name	Type	Default
`from`	`Callable`	—

Returns Variant

# CreateFrom · 4/53

C#
public static Variant CreateFrom(Reckfell.Collections.Array from);

Stores an engine Array in Variant with the container shared, without deep copying.

Parameters
Name	Type	Default
`from`	`Reckfell.Collections.Array`	—

from

Source Reckfell.Collections.Array value with the documented copying semantics.

Returns Variant

Variant tagged Array.

# CreateFrom · 5/53

C#
public static Variant CreateFrom(Reckfell.Collections.Dictionary from);

Stores an engine Dictionary in Variant with shared contents. This is not a conversion of a managed .NET dictionary.

Parameters
Name	Type	Default
`from`	`Reckfell.Collections.Dictionary`	—

from

Source Reckfell.Collections.Dictionary value with the documented copying semantics.

Returns Variant

Variant tagged Dictionary.

# CreateFrom · 6/53

C#
public static Variant CreateFrom(Color from);

Parameters
Name	Type	Default
`from`	`Color`	—

Returns Variant

# CreateFrom · 7/53

C#
public static Variant CreateFrom(EntityPath from);

Parameters
Name	Type	Default
`from`	`EntityPath`	—

Returns Variant

# CreateFrom · 8/53

C#
public static Variant CreateFrom(Plane from);

Parameters
Name	Type	Default
`from`	`Plane`	—

Returns Variant

# CreateFrom · 9/53

C#
public static Variant CreateFrom(Projection from);

Parameters
Name	Type	Default
`from`	`Projection`	—

Returns Variant

# CreateFrom · 10/53

C#
public static Variant CreateFrom(Quaternion from);

Parameters
Name	Type	Default
`from`	`Quaternion`	—

Returns Variant

# CreateFrom · 11/53

C#
public static Variant CreateFrom(ReckfellObject from);

Stores an engine object reference; null becomes Nil. The object is not cloned, and an Entity can still be explicitly freed.

Parameters
Name	Type	Default
`from`	`ReckfellObject`	—

from

Source Reckfell.ReckfellObject value with the documented copying semantics.

Returns Variant

Variant tagged Object; Nil for a null engine object.

# CreateFrom · 12/53

C#
public static Variant CreateFrom(ReckfellObject[] from);

Parameters
Name	Type	Default
`from`	`ReckfellObject[]`	—

Returns Variant

# CreateFrom · 13/53

C#
public static Variant CreateFrom(Rect2 from);

Parameters
Name	Type	Default
`from`	`Rect2`	—

Returns Variant

# CreateFrom · 14/53

C#
public static Variant CreateFrom(Rect2I from);

Parameters
Name	Type	Default
`from`	`Rect2I`	—

Returns Variant

# CreateFrom · 15/53

C#
public static Variant CreateFrom(Rid from);

Parameters
Name	Type	Default
`from`	`Rid`	—

Returns Variant

# CreateFrom · 16/53

C#
public static Variant CreateFrom(Signal from);

Parameters
Name	Type	Default
`from`	`Signal`	—

Returns Variant

# CreateFrom · 17/53

C#
public static Variant CreateFrom(StringName from);

Parameters
Name	Type	Default
`from`	`StringName`	—

Returns Variant

# CreateFrom · 18/53

C#
public static Variant CreateFrom(Transform2D from);

Parameters
Name	Type	Default
`from`	`Transform2D`	—

Returns Variant

# CreateFrom · 19/53

C#
public static Variant CreateFrom(Transform3D from);

Parameters
Name	Type	Default
`from`	`Transform3D`	—

Returns Variant

# CreateFrom · 20/53

C#
public static Variant CreateFrom(Vector2 from);

Stores Vector2 in Variant with the Vector2 tag, distinct from Vector2I.

Parameters
Name	Type	Default
`from`	`Vector2`	—

from

Source Reckfell.Vector2 value with the documented copying semantics.

Returns Variant

Variant tagged Vector2.

# CreateFrom · 21/53

C#
public static Variant CreateFrom(Vector2I from);

Parameters
Name	Type	Default
`from`	`Vector2I`	—

Returns Variant

# CreateFrom · 22/53

C#
public static Variant CreateFrom(Vector3 from);

Parameters
Name	Type	Default
`from`	`Vector3`	—

Returns Variant

# CreateFrom · 23/53

C#
public static Variant CreateFrom(Vector3I from);

Parameters
Name	Type	Default
`from`	`Vector3I`	—

Returns Variant

# CreateFrom · 24/53

C#
public static Variant CreateFrom(Vector4 from);

Parameters
Name	Type	Default
`from`	`Vector4`	—

Returns Variant

# CreateFrom · 25/53

C#
public static Variant CreateFrom(Vector4I from);

Parameters
Name	Type	Default
`from`	`Vector4I`	—

Returns Variant

# CreateFrom · 26/53

C#
public static Variant CreateFrom(bool from);

Parameters
Name	Type	Default
`from`	`bool`	—

Returns Variant

# CreateFrom · 27/53

C#
public static Variant CreateFrom(byte from);

Parameters
Name	Type	Default
`from`	`byte`	—

Returns Variant

# CreateFrom · 28/53

C#
public static Variant CreateFrom(char from);

Parameters
Name	Type	Default
`from`	`char`	—

Returns Variant

# CreateFrom · 29/53

C#
public static Variant CreateFrom(double from);

Stores double in the engine double-precision Float.

Parameters
Name	Type	Default
`from`	`double`	—

from

Source System.Double value with the documented copying semantics.

Returns Variant

Variant tagged Float.

# CreateFrom · 30/53

C#
public static Variant CreateFrom(short from);

Parameters
Name	Type	Default
`from`	`short`	—

Returns Variant

# CreateFrom · 31/53

C#
public static Variant CreateFrom(int from);

Stores int in signed 64-bit Int without losing the value.

Parameters
Name	Type	Default
`from`	`int`	—

from

Source System.Int32 value with the documented copying semantics.

Returns Variant

Variant tagged Int.

# CreateFrom · 32/53

C#
public static Variant CreateFrom(long from);

Stores long in signed 64-bit Int.

Parameters
Name	Type	Default
`from`	`long`	—

from

Source System.Int64 value with the documented copying semantics.

Returns Variant

Variant tagged Int.

# CreateFrom · 33/53

C#
public static Variant CreateFrom(sbyte from);

Parameters
Name	Type	Default
`from`	`sbyte`	—

Returns Variant

# CreateFrom · 34/53

C#
public static Variant CreateFrom(float from);

Stores float in Float using double storage. Precision already lost in the source float is not recovered.

Parameters
Name	Type	Default
`from`	`float`	—

from

Source System.Single value with the documented copying semantics.

Returns Variant

Variant tagged Float.

# CreateFrom · 35/53

C#
public static Variant CreateFrom(Span<Color> from);

Parameters
Name	Type	Default
`from`	`Span<Color>`	—

Returns Variant

# CreateFrom · 36/53

C#
public static Variant CreateFrom(Span<EntityPath> from);

Parameters
Name	Type	Default
`from`	`Span<EntityPath>`	—

Returns Variant

# CreateFrom · 37/53

C#
public static Variant CreateFrom(Span<Rid> from);

Parameters
Name	Type	Default
`from`	`Span<Rid>`	—

Returns Variant

# CreateFrom · 38/53

C#
public static Variant CreateFrom(Span<StringName> from);

Parameters
Name	Type	Default
`from`	`Span<StringName>`	—

Returns Variant

# CreateFrom · 39/53

C#
public static Variant CreateFrom(Span<Vector2> from);

Parameters
Name	Type	Default
`from`	`Span<Vector2>`	—

Returns Variant

# CreateFrom · 40/53

C#
public static Variant CreateFrom(Span<Vector3> from);

Parameters
Name	Type	Default
`from`	`Span<Vector3>`	—

Returns Variant

# CreateFrom · 41/53

C#
public static Variant CreateFrom(Span<Vector4> from);

Parameters
Name	Type	Default
`from`	`Span<Vector4>`	—

Returns Variant

# CreateFrom · 42/53

C#
public static Variant CreateFrom(Span<byte> from);

Parameters
Name	Type	Default
`from`	`Span<byte>`	—

Returns Variant

# CreateFrom · 43/53

C#
public static Variant CreateFrom(Span<double> from);

Parameters
Name	Type	Default
`from`	`Span<double>`	—

Returns Variant

# CreateFrom · 44/53

C#
public static Variant CreateFrom(Span<int> from);

Parameters
Name	Type	Default
`from`	`Span<int>`	—

Returns Variant

# CreateFrom · 45/53

C#
public static Variant CreateFrom(Span<long> from);

Parameters
Name	Type	Default
`from`	`Span<long>`	—

Returns Variant

# CreateFrom · 46/53

C#
public static Variant CreateFrom(Span<float> from);

Parameters
Name	Type	Default
`from`	`Span<float>`	—

Returns Variant

# CreateFrom · 47/53

C#
public static Variant CreateFrom(Span<string> from);

Parameters
Name	Type	Default
`from`	`Span<string>`	—

Returns Variant

# CreateFrom · 48/53

C#
public static Variant CreateFrom(string from);

Stores text as the engine String without interpreting its contents as a number or JSON.

Parameters
Name	Type	Default
`from`	`string`	—

from

Source System.String value with the documented copying semantics.

Returns Variant

Variant tagged String.

# CreateFrom · 49/53

C#
public static Variant CreateFrom(ushort from);

Parameters
Name	Type	Default
`from`	`ushort`	—

Returns Variant

# CreateFrom · 50/53

C#
public static Variant CreateFrom(uint from);

Parameters
Name	Type	Default
`from`	`uint`	—

Returns Variant

# CreateFrom · 51/53

C#
public static Variant CreateFrom(ulong from);

Parameters
Name	Type	Default
`from`	`ulong`	—

Returns Variant

# CreateFrom · 52/53

C#
public static Variant CreateFrom<T>(Reckfell.Collections.Array<T> from);

Parameters
Name	Type	Default
`from`	`Reckfell.Collections.Array<T>`	—

Returns Variant

# CreateFrom · 53/53

C#
public static Variant CreateFrom<TKey, TValue>(Reckfell.Collections.Dictionary<TKey, TValue> from);

Parameters
Name	Type	Default
`from`	`Reckfell.Collections.Dictionary<TKey, TValue>`	—

Returns Variant

CreateTakingOwnershipOfDisposableValueVariant

# CreateTakingOwnershipOfDisposableValue

C#
public static Variant CreateTakingOwnershipOfDisposableValue(in Reckfell.NativeInterop.reckfell_variant nativeValueToOwn);

Parameters
Name	Type	Default
`nativeValueToOwn`	`Reckfell.NativeInterop.reckfell_variant`	—

Returns Variant

Disposevoid

# Dispose

C#
public void Dispose();

Releases native payload owned by the wrapper and resets this instance. Do not dispose a borrowed Variant: struct copies can share disposal bookkeeping. Do not use such aliases after disposal.

FromVariant

# From

C#
public static Variant From<T>(in T? from);

Creates a Variant from supported value T. int and long are stored as Int, float and double as Float; a generic call does not make an arbitrary CLR class supported.

Parameters
Name	Type	Default
`from`	`T`	—

from

Supported value of type T to store in Variant.

Returns Variant

Variant with the corresponding engine tag and ownership semantics.

ToStringstring

# ToString

C#
public override string ToString();

Returns string

op_Explicit50 overloads

# op_Explicit · 1/50

C#
public static explicit operator Aabb(Variant from);

Parameters
Name	Type	Default
`from`	`Variant`	—

Returns Aabb

# op_Explicit · 2/50

C#
public static explicit operator Basis(Variant from);

Parameters
Name	Type	Default
`from`	`Variant`	—

Returns Basis

# op_Explicit · 3/50

C#
public static explicit operator Callable(Variant from);

Parameters
Name	Type	Default
`from`	`Variant`	—

Returns Callable

# op_Explicit · 4/50

C#
public static explicit operator Reckfell.Collections.Array(Variant from);

Returns an engine Array wrapper sharing the original container, not a deep copy. Element changes are visible through other references; use Duplicate for an independent outer container.

Parameters
Name	Type	Default
`from`	`Variant`	—

from

Variant to convert; validate the original tag separately.

Returns Reckfell.Collections.Array

Wrapper for the shared engine Array.

# op_Explicit · 5/50

C#
public static explicit operator Reckfell.Collections.Dictionary(Variant from);

Returns an engine Dictionary wrapper sharing the original contents. This does not produce System.Collections.Generic.Dictionary or a deep copy.

Parameters
Name	Type	Default
`from`	`Variant`	—

from

Variant to convert; validate the original tag separately.

Returns Reckfell.Collections.Dictionary

Wrapper for the shared engine Dictionary.

# op_Explicit · 6/50

C#
public static explicit operator Color(Variant from);

Parameters
Name	Type	Default
`from`	`Variant`	—

Returns Color

# op_Explicit · 7/50

C#
public static explicit operator Color[](Variant from);

Parameters
Name	Type	Default
`from`	`Variant`	—

Returns Color[]

# op_Explicit · 8/50

C#
public static explicit operator EntityPath(Variant from);

Parameters
Name	Type	Default
`from`	`Variant`	—

Returns EntityPath

# op_Explicit · 9/50

C#
public static explicit operator EntityPath[](Variant from);

Parameters
Name	Type	Default
`from`	`Variant`	—

Returns EntityPath[]

# op_Explicit · 10/50

C#
public static explicit operator Plane(Variant from);

Parameters
Name	Type	Default
`from`	`Variant`	—

Returns Plane

# op_Explicit · 11/50

C#
public static explicit operator Projection(Variant from);

Parameters
Name	Type	Default
`from`	`Variant`	—

Returns Projection

# op_Explicit · 12/50

C#
public static explicit operator Quaternion(Variant from);

Parameters
Name	Type	Default
`from`	`Variant`	—

Returns Quaternion

# op_Explicit · 13/50

C#
public static explicit operator ReckfellObject(Variant from);

Returns the engine object with identity preserved, not a clone. An Entity can be explicitly freed while a Variant exists; use IsInstanceValid before using a potentially expired object.

Parameters
Name	Type	Default
`from`	`Variant`	—

from

Variant to convert; validate the original tag separately.

Returns ReckfellObject

Engine object or null; validate object liveness separately.

# op_Explicit · 14/50

C#
public static explicit operator Rect2(Variant from);

Parameters
Name	Type	Default
`from`	`Variant`	—

Returns Rect2

# op_Explicit · 15/50

C#
public static explicit operator Rect2I(Variant from);

Parameters
Name	Type	Default
`from`	`Variant`	—

Returns Rect2I

# op_Explicit · 16/50

C#
public static explicit operator Rid(Variant from);

Parameters
Name	Type	Default
`from`	`Variant`	—

Returns Rid

# op_Explicit · 17/50

C#
public static explicit operator Rid[](Variant from);

Parameters
Name	Type	Default
`from`	`Variant`	—

Returns Rid[]

# op_Explicit · 18/50

C#
public static explicit operator Signal(Variant from);

Parameters
Name	Type	Default
`from`	`Variant`	—

Returns Signal

# op_Explicit · 19/50

C#
public static explicit operator StringName(Variant from);

Parameters
Name	Type	Default
`from`	`Variant`	—

Returns StringName

# op_Explicit · 20/50

C#
public static explicit operator StringName[](Variant from);

Parameters
Name	Type	Default
`from`	`Variant`	—

Returns StringName[]

# op_Explicit · 21/50

C#
public static explicit operator Transform2D(Variant from);

Parameters
Name	Type	Default
`from`	`Variant`	—

Returns Transform2D

# op_Explicit · 22/50

C#
public static explicit operator Transform3D(Variant from);

Parameters
Name	Type	Default
`from`	`Variant`	—

Returns Transform3D

# op_Explicit · 23/50

C#
public static explicit operator Vector2(Variant from);

Extracts or converts to Vector2. For an exact position field check Type.Vector2 and, when required, IsFinite; Vector2I has a different tag.

Parameters
Name	Type	Default
`from`	`Variant`	—

from

Variant to convert; validate the original tag separately.

Returns Vector2

Vector2; component finiteness is not separately validated.

# op_Explicit · 24/50

C#
public static explicit operator Vector2I(Variant from);

Parameters
Name	Type	Default
`from`	`Variant`	—

Returns Vector2I

# op_Explicit · 25/50

C#
public static explicit operator Vector2[](Variant from);

Parameters
Name	Type	Default
`from`	`Variant`	—

Returns Vector2[]

# op_Explicit · 26/50

C#
public static explicit operator Vector3(Variant from);

Parameters
Name	Type	Default
`from`	`Variant`	—

Returns Vector3

# op_Explicit · 27/50

C#
public static explicit operator Vector3I(Variant from);

Parameters
Name	Type	Default
`from`	`Variant`	—

Returns Vector3I

# op_Explicit · 28/50

C#
public static explicit operator Vector3[](Variant from);

Parameters
Name	Type	Default
`from`	`Variant`	—

Returns Vector3[]

# op_Explicit · 29/50

C#
public static explicit operator Vector4(Variant from);

Parameters
Name	Type	Default
`from`	`Variant`	—

Returns Vector4

# op_Explicit · 30/50

C#
public static explicit operator Vector4I(Variant from);

Parameters
Name	Type	Default
`from`	`Variant`	—

Returns Vector4I

# op_Explicit · 31/50

C#
public static explicit operator Vector4[](Variant from);

Parameters
Name	Type	Default
`from`	`Variant`	—

Returns Vector4[]

# op_Explicit · 32/50

C#
public static explicit operator bool(Variant from);

Parameters
Name	Type	Default
`from`	`Variant`	—

Returns bool

# op_Explicit · 33/50

C#
public static explicit operator byte(Variant from);

Parameters
Name	Type	Default
`from`	`Variant`	—

Returns byte

# op_Explicit · 34/50

C#
public static explicit operator byte[](Variant from);

Parameters
Name	Type	Default
`from`	`Variant`	—

Returns byte[]

# op_Explicit · 35/50

C#
public static explicit operator char(Variant from);

Parameters
Name	Type	Default
`from`	`Variant`	—

Returns char

# op_Explicit · 36/50

C#
public static explicit operator double(Variant from);

Reads the stored Float as double or performs a supported numeric conversion. Check VariantType separately when the input must specifically be Float.

Parameters
Name	Type	Default
`from`	`Variant`	—

from

Variant to convert; validate the original tag separately.

Returns double

Double-precision number after conversion.

# op_Explicit · 37/50

C#
public static explicit operator double[](Variant from);

Parameters
Name	Type	Default
`from`	`Variant`	—

Returns double[]

# op_Explicit · 38/50

C#
public static explicit operator short(Variant from);

Parameters
Name	Type	Default
`from`	`Variant`	—

Returns short

# op_Explicit · 39/50

C#
public static explicit operator int(Variant from);

Parameters
Name	Type	Default
`from`	`Variant`	—

from

Variant to convert; validate the original tag separately.

Returns int

Converted int, without range validation.

# op_Explicit · 40/50

C#
public static explicit operator int[](Variant from);

Returns a managed copy of PackedInt32Array contents. Editing the returned int[] does not modify the packed value stored in Variant; check the corresponding tag for strict input.

Parameters
Name	Type	Default
`from`	`Variant`	—

from

Variant to convert; validate the original tag separately.

Returns int[]

New managed int[] containing copied elements.

# op_Explicit · 41/50

C#
public static explicit operator long(Variant from);

Reads Int as a signed 64-bit integer or performs a supported conversion from another type. For example Float 3.75 becomes 3; this does not replace checking VariantType.

Parameters
Name	Type	Default
`from`	`Variant`	—

from

Variant to convert; validate the original tag separately.

Returns long

Signed 64-bit integer after conversion.

# op_Explicit · 42/50

C#
public static explicit operator long[](Variant from);

Parameters
Name	Type	Default
`from`	`Variant`	—

Returns long[]

# op_Explicit · 43/50

C#
public static explicit operator sbyte(Variant from);

Parameters
Name	Type	Default
`from`	`Variant`	—

Returns sbyte

# op_Explicit · 44/50

C#
public static explicit operator float(Variant from);

Converts to C# float. Stored Float has double precision, so narrowing can lose precision; this method does not validate an exact input schema.

Parameters
Name	Type	Default
`from`	`Variant`	—

from

Variant to convert; validate the original tag separately.

Returns float

Converted float, with possible precision loss.

# op_Explicit · 45/50

C#
public static explicit operator float[](Variant from);

Parameters
Name	Type	Default
`from`	`Variant`	—

Returns float[]

# op_Explicit · 46/50

C#
public static explicit operator string(Variant from);

Returns a string representation, not proof that the stored tag is String. Check VariantType for an exact text field; this representation is not a serialization format.

Parameters
Name	Type	Default
`from`	`Variant`	—

from

Variant to convert; validate the original tag separately.

Returns string

String representation of the value.

# op_Explicit · 47/50

C#
public static explicit operator string[](Variant from);

Parameters
Name	Type	Default
`from`	`Variant`	—

Returns string[]

# op_Explicit · 48/50

C#
public static explicit operator ushort(Variant from);

Parameters
Name	Type	Default
`from`	`Variant`	—

Returns ushort

# op_Explicit · 49/50

C#
public static explicit operator uint(Variant from);

Parameters
Name	Type	Default
`from`	`Variant`	—

Returns uint

# op_Explicit · 50/50

C#
public static explicit operator ulong(Variant from);

Parameters
Name	Type	Default
`from`	`Variant`	—

Returns ulong

op_Implicit64 overloads

# op_Implicit · 1/64

C#
public static implicit operator Variant(Aabb from);

Parameters
Name	Type	Default
`from`	`Aabb`	—

Returns Variant

# op_Implicit · 2/64

C#
public static implicit operator Variant(Basis from);

Parameters
Name	Type	Default
`from`	`Basis`	—

Returns Variant

# op_Implicit · 3/64

C#
public static implicit operator Variant(Callable from);

Parameters
Name	Type	Default
`from`	`Callable`	—

Returns Variant

# op_Implicit · 4/64

C#
public static implicit operator Variant(Reckfell.Collections.Array from);

Stores an engine Array in Variant with the container shared, without deep copying.

Parameters
Name	Type	Default
`from`	`Reckfell.Collections.Array`	—

from

Source Reckfell.Collections.Array value with the documented copying semantics.

Returns Variant

Variant tagged Array.

# op_Implicit · 5/64

C#
public static implicit operator Variant(Reckfell.Collections.Dictionary from);

Stores an engine Dictionary in Variant with shared contents. This is not a conversion of a managed .NET dictionary.

Parameters
Name	Type	Default
`from`	`Reckfell.Collections.Dictionary`	—

from

Source Reckfell.Collections.Dictionary value with the documented copying semantics.

Returns Variant

Variant tagged Dictionary.

# op_Implicit · 6/64

C#
public static implicit operator Variant(Color from);

Parameters
Name	Type	Default
`from`	`Color`	—

Returns Variant

# op_Implicit · 7/64

C#
public static implicit operator Variant(Color[] from);

Parameters
Name	Type	Default
`from`	`Color[]`	—

Returns Variant

# op_Implicit · 8/64

C#
public static implicit operator Variant(EntityPath from);

Parameters
Name	Type	Default
`from`	`EntityPath`	—

Returns Variant

# op_Implicit · 9/64

C#
public static implicit operator Variant(EntityPath[] from);

Parameters
Name	Type	Default
`from`	`EntityPath[]`	—

Returns Variant

# op_Implicit · 10/64

C#
public static implicit operator Variant(Plane from);

Parameters
Name	Type	Default
`from`	`Plane`	—

Returns Variant

# op_Implicit · 11/64

C#
public static implicit operator Variant(Projection from);

Parameters
Name	Type	Default
`from`	`Projection`	—

Returns Variant

# op_Implicit · 12/64

C#
public static implicit operator Variant(Quaternion from);

Parameters
Name	Type	Default
`from`	`Quaternion`	—

Returns Variant

# op_Implicit · 13/64

C#
public static implicit operator Variant(ReckfellObject from);

Stores an engine object reference; null becomes Nil. The object is not cloned, and an Entity can still be explicitly freed.

Parameters
Name	Type	Default
`from`	`ReckfellObject`	—

from

Source Reckfell.ReckfellObject value with the documented copying semantics.

Returns Variant

Variant tagged Object; Nil for a null engine object.

# op_Implicit · 14/64

C#
public static implicit operator Variant(ReckfellObject[] from);

Parameters
Name	Type	Default
`from`	`ReckfellObject[]`	—

Returns Variant

# op_Implicit · 15/64

C#
public static implicit operator Variant(Rect2 from);

Parameters
Name	Type	Default
`from`	`Rect2`	—

Returns Variant

# op_Implicit · 16/64

C#
public static implicit operator Variant(Rect2I from);

Parameters
Name	Type	Default
`from`	`Rect2I`	—

Returns Variant

# op_Implicit · 17/64

C#
public static implicit operator Variant(Rid from);

Parameters
Name	Type	Default
`from`	`Rid`	—

Returns Variant

# op_Implicit · 18/64

C#
public static implicit operator Variant(Rid[] from);

Parameters
Name	Type	Default
`from`	`Rid[]`	—

Returns Variant

# op_Implicit · 19/64

C#
public static implicit operator Variant(Signal from);

Parameters
Name	Type	Default
`from`	`Signal`	—

Returns Variant

# op_Implicit · 20/64

C#
public static implicit operator Variant(StringName from);

Parameters
Name	Type	Default
`from`	`StringName`	—

Returns Variant

# op_Implicit · 21/64

C#
public static implicit operator Variant(StringName[] from);

Parameters
Name	Type	Default
`from`	`StringName[]`	—

Returns Variant

# op_Implicit · 22/64

C#
public static implicit operator Variant(Transform2D from);

Parameters
Name	Type	Default
`from`	`Transform2D`	—

Returns Variant

# op_Implicit · 23/64

C#
public static implicit operator Variant(Transform3D from);

Parameters
Name	Type	Default
`from`	`Transform3D`	—

Returns Variant

# op_Implicit · 24/64

C#
public static implicit operator Variant(Vector2 from);

Stores Vector2 in Variant with the Vector2 tag, distinct from Vector2I.

Parameters
Name	Type	Default
`from`	`Vector2`	—

from

Source Reckfell.Vector2 value with the documented copying semantics.

Returns Variant

Variant tagged Vector2.

# op_Implicit · 25/64

C#
public static implicit operator Variant(Vector2I from);

Parameters
Name	Type	Default
`from`	`Vector2I`	—

Returns Variant

# op_Implicit · 26/64

C#
public static implicit operator Variant(Vector2[] from);

Parameters
Name	Type	Default
`from`	`Vector2[]`	—

Returns Variant

# op_Implicit · 27/64

C#
public static implicit operator Variant(Vector3 from);

Parameters
Name	Type	Default
`from`	`Vector3`	—

Returns Variant

# op_Implicit · 28/64

C#
public static implicit operator Variant(Vector3I from);

Parameters
Name	Type	Default
`from`	`Vector3I`	—

Returns Variant

# op_Implicit · 29/64

C#
public static implicit operator Variant(Vector3[] from);

Parameters
Name	Type	Default
`from`	`Vector3[]`	—

Returns Variant

# op_Implicit · 30/64

C#
public static implicit operator Variant(Vector4 from);

Parameters
Name	Type	Default
`from`	`Vector4`	—

Returns Variant

# op_Implicit · 31/64

C#
public static implicit operator Variant(Vector4I from);

Parameters
Name	Type	Default
`from`	`Vector4I`	—

Returns Variant

# op_Implicit · 32/64

C#
public static implicit operator Variant(Vector4[] from);

Parameters
Name	Type	Default
`from`	`Vector4[]`	—

Returns Variant

# op_Implicit · 33/64

C#
public static implicit operator Variant(bool from);

Stores bool in a Variant tagged Bool, not Int.

Parameters
Name	Type	Default
`from`	`bool`	—

from

C# boolean value.

Returns Variant

Variant tagged Bool.

# op_Implicit · 34/64

C#
public static implicit operator Variant(byte from);

Parameters
Name	Type	Default
`from`	`byte`	—

Returns Variant

# op_Implicit · 35/64

C#
public static implicit operator Variant(byte[] from);

Parameters
Name	Type	Default
`from`	`byte[]`	—

Returns Variant

# op_Implicit · 36/64

C#
public static implicit operator Variant(char from);

Parameters
Name	Type	Default
`from`	`char`	—

Returns Variant

# op_Implicit · 37/64

C#
public static implicit operator Variant(double from);

Stores double in the engine double-precision Float.

Parameters
Name	Type	Default
`from`	`double`	—

from

Source System.Double value with the documented copying semantics.

Returns Variant

Variant tagged Float.

# op_Implicit · 38/64

C#
public static implicit operator Variant(double[] from);

Parameters
Name	Type	Default
`from`	`double[]`	—

Returns Variant

# op_Implicit · 39/64

C#
public static implicit operator Variant(short from);

Parameters
Name	Type	Default
`from`	`short`	—

Returns Variant

# op_Implicit · 40/64

C#
public static implicit operator Variant(int from);

Stores int in signed 64-bit Int without losing the value.

Parameters
Name	Type	Default
`from`	`int`	—

from

Source System.Int32 value with the documented copying semantics.

Returns Variant

Variant tagged Int.

# op_Implicit · 41/64

C#
public static implicit operator Variant(int[] from);

Copies managed int[] elements into PackedInt32Array. Editing the source array does not change the existing Variant.

Parameters
Name	Type	Default
`from`	`int[]`	—

from

Source System.Int32[] value with the documented copying semantics.

Returns Variant

Variant tagged PackedInt32Array.

# op_Implicit · 42/64

C#
public static implicit operator Variant(long from);

Stores long in signed 64-bit Int.

Parameters
Name	Type	Default
`from`	`long`	—

from

Source System.Int64 value with the documented copying semantics.

Returns Variant

Variant tagged Int.

# op_Implicit · 43/64

C#
public static implicit operator Variant(long[] from);

Parameters
Name	Type	Default
`from`	`long[]`	—

Returns Variant

# op_Implicit · 44/64

C#
public static implicit operator Variant(sbyte from);

Parameters
Name	Type	Default
`from`	`sbyte`	—

Returns Variant

# op_Implicit · 45/64

C#
public static implicit operator Variant(float from);

Stores float in Float using double storage. Precision already lost in the source float is not recovered.

Parameters
Name	Type	Default
`from`	`float`	—

from

Source System.Single value with the documented copying semantics.

Returns Variant

Variant tagged Float.

# op_Implicit · 46/64

C#
public static implicit operator Variant(float[] from);

Parameters
Name	Type	Default
`from`	`float[]`	—

Returns Variant

# op_Implicit · 47/64

C#
public static implicit operator Variant(Span<Color> from);

Parameters
Name	Type	Default
`from`	`Span<Color>`	—

Returns Variant

# op_Implicit · 48/64

C#
public static implicit operator Variant(Span<EntityPath> from);

Parameters
Name	Type	Default
`from`	`Span<EntityPath>`	—

Returns Variant

# op_Implicit · 49/64

C#
public static implicit operator Variant(Span<Rid> from);

Parameters
Name	Type	Default
`from`	`Span<Rid>`	—

Returns Variant

# op_Implicit · 50/64

C#
public static implicit operator Variant(Span<StringName> from);

Parameters
Name	Type	Default
`from`	`Span<StringName>`	—

Returns Variant

# op_Implicit · 51/64

C#
public static implicit operator Variant(Span<Vector2> from);

Parameters
Name	Type	Default
`from`	`Span<Vector2>`	—

Returns Variant

# op_Implicit · 52/64

C#
public static implicit operator Variant(Span<Vector3> from);

Parameters
Name	Type	Default
`from`	`Span<Vector3>`	—

Returns Variant

# op_Implicit · 53/64

C#
public static implicit operator Variant(Span<Vector4> from);

Parameters
Name	Type	Default
`from`	`Span<Vector4>`	—

Returns Variant

# op_Implicit · 54/64

C#
public static implicit operator Variant(Span<byte> from);

Parameters
Name	Type	Default
`from`	`Span<byte>`	—

Returns Variant

# op_Implicit · 55/64

C#
public static implicit operator Variant(Span<double> from);

Parameters
Name	Type	Default
`from`	`Span<double>`	—

Returns Variant

# op_Implicit · 56/64

C#
public static implicit operator Variant(Span<int> from);

Parameters
Name	Type	Default
`from`	`Span<int>`	—

Returns Variant

# op_Implicit · 57/64

C#
public static implicit operator Variant(Span<long> from);

Parameters
Name	Type	Default
`from`	`Span<long>`	—

Returns Variant

# op_Implicit · 58/64

C#
public static implicit operator Variant(Span<float> from);

Parameters
Name	Type	Default
`from`	`Span<float>`	—

Returns Variant

# op_Implicit · 59/64

C#
public static implicit operator Variant(Span<string> from);

Parameters
Name	Type	Default
`from`	`Span<string>`	—

Returns Variant

# op_Implicit · 60/64

C#
public static implicit operator Variant(string from);

Stores text as the engine String without interpreting its contents as a number or JSON.

Parameters
Name	Type	Default
`from`	`string`	—

from

Source System.String value with the documented copying semantics.

Returns Variant

Variant tagged String.

# op_Implicit · 61/64

C#
public static implicit operator Variant(string[] from);

Parameters
Name	Type	Default
`from`	`string[]`	—

Returns Variant

# op_Implicit · 62/64

C#
public static implicit operator Variant(ushort from);

Parameters
Name	Type	Default
`from`	`ushort`	—

Returns Variant

# op_Implicit · 63/64

C#
public static implicit operator Variant(uint from);

Parameters
Name	Type	Default
`from`	`uint`	—

Returns Variant

# op_Implicit · 64/64

C#
public static implicit operator Variant(ulong from);

Parameters
Name	Type	Default
`from`	`ulong`	—

Returns Variant

Variant.Operator

Value	Description
`Add = 6`	Addition operator (`+`).
`And = 20`	Logical AND operator (`and` or `&&`).
`BitAnd = 16`	Bitwise AND operator (`&`).
`BitNegate = 19`	Bitwise NOT operator (`~`).
`BitOr = 17`	Bitwise OR operator (`\|`).
`BitXor = 18`	Bitwise XOR operator (`^`).
`Divide = 9`	Division operator (`/`).
`Equal = 0`	Equality operator (`==`).
`Greater = 4`	Greater than operator (`>`).
`GreaterEqual = 5`	Greater than or equal operator (`>=`).
`In = 24`	Logical IN operator (`in`).
`Less = 2`	Less than operator (`<`).
`LessEqual = 3`	Less than or equal operator (`<=`).
`Max = 25`	Represents the size of the `Variant.Operator` enum.
`Module = 12`	Remainder/modulo operator (`%`).
`Multiply = 8`	Multiplication operator (`*`).
`Negate = 10`	Unary negation operator (`-`).
`Not = 23`	Logical NOT operator (`not` or `!`).
`NotEqual = 1`	Inequality operator (`!=`).
`Or = 21`	Logical OR operator (`or` or `\|\|`).
`Positive = 11`	Unary plus operator (`+`).
`Power = 13`	Power operator (`**`).
`ShiftLeft = 14`	Left shift operator (`<<`).
`ShiftRight = 15`	Right shift operator (`>>`).
`Subtract = 7`	Subtraction operator (`-`).
`Xor = 22`	Logical XOR operator (not implemented in C#).

Variant.Type

Value	Description
`Aabb = 16`	Variable is of type `Aabb`.
`Array = 28`	Variable is of type `Reckfell.Collections.Array`.
`Basis = 17`	Variable is of type `Basis`.
`Bool = 1`	Variable is of type [bool].
`Callable = 25`	Variable is of type `Callable`.
`Color = 20`	Variable is of type `Color`.
`Dictionary = 27`	Variable is of type `Reckfell.Collections.Dictionary`.
`EntityPath = 22`	Variable is of type `EntityPath`.
`Float = 3`	Variable is of type [float].
`Int = 2`	Variable is of type [int].
`Max = 39`	Represents the size of the `Variant.Type` enum.
`Nil = 0`	Variable is `null`.
`Object = 24`	Variable is of type `ReckfellObject`.
`PackedByteArray = 29`	Variable is of type `byte[]`.
`PackedColorArray = 37`	Variable is of type `Color[]`.
`PackedFloat32Array = 32`	Variable is of type `float[]`.
`PackedFloat64Array = 33`	Variable is of type `double[]`.
`PackedInt32Array = 30`	Variable is of type `int[]`.
`PackedInt64Array = 31`	Variable is of type `long[]`.
`PackedStringArray = 34`	Variable is of type `string[]`.
`PackedVector2Array = 35`	Variable is of type `Vector2[]`.
`PackedVector3Array = 36`	Variable is of type `Vector3[]`.
`PackedVector4Array = 38`	Variable is of type `Vector4[]`.
`Plane = 14`	Variable is of type `Plane`.
`Projection = 19`	Variable is of type `Projection`.
`Quaternion = 15`	Variable is of type `Quaternion`.
`Rect2 = 7`	Variable is of type `Rect2`.
`Rect2I = 8`	Variable is of type `Rect2I`.
`Rid = 23`	Variable is of type `Rid`.
`Signal = 26`	Variable is of type `Signal`.
`String = 4`	Variable is of type `string`.
`StringName = 21`	Variable is of type `StringName`.
`Transform2D = 11`	Variable is of type `Transform2D`.
`Transform3D = 18`	Variable is of type `Transform3D`.
`Vector2 = 5`	Variable is of type `Vector2`.
`Vector2I = 6`	Variable is of type `Vector2I`.
`Vector3 = 9`	Variable is of type `Vector3`.
`Vector3I = 10`	Variable is of type `Vector3I`.
`Vector4 = 12`	Variable is of type `Vector4`.
`Vector4I = 13`	Variable is of type `Vector4I`.