C# API reference.

EntityHandle Entity { get; }

Opaque native identity of the entity that owns this behavior.

IReadOnlyDictionary<string, JsonElement> Fields { get; }

Typed serialized values authored on this behavior binding.

Transform Transform { get; }

The entity's live transform. Set Position, LocalPosition, EulerAngles, or LocalEulerAngles directly; use Translate or Rotate for incremental motion.

virtual void Awake()

Called once after the behavior is constructed and bound to an entity.

virtual void FixedUpdate(double deltaTime)

Called at the fixed simulation interval.

T? GetField<T>(string name)

Gets one Stage-authored serialized field as its declared managed value. The value is decoded from the typed Stage field payload; no runtime default is substituted for a missing or incompatible field.

virtual void LateUpdate(double deltaTime)

Called after Behavior.Update.

virtual void OnCollision2D(CollisionEvent2D e)

Called after Behavior.FixedUpdate for each 2D collision involving this behavior's entity. Inspect CollisionEvent2D.IsStay and CollisionEvent2D.IsExit to distinguish enter, stay, and exit events.

virtual void OnCollision3D(CollisionEvent3D e)

Called after Behavior.FixedUpdate for each 3D collision involving this behavior's entity.

virtual void OnDestroy()

Called exactly once while the native Play session is stopping, before the behavior instance and its collectible game assembly are released. Use this for deterministic gameplay cleanup; it is not a finalizer.

virtual void OnDisable()

Called whenever the behavior becomes disabled.

virtual void OnEnable()

Called whenever the behavior becomes enabled.

virtual void OnTrigger2D(TriggerEvent2D e)

Called after Behavior.FixedUpdate for each 2D trigger involving this behavior's entity. Inspect TriggerEvent2D.IsStay and TriggerEvent2D.IsExit to distinguish enter, stay, and exit events.

virtual void OnTrigger3D(TriggerEvent3D e)

Called after Behavior.FixedUpdate for each 3D trigger involving this behavior's entity.

virtual void OnUiClick(UiEvent e)

Called when this entity's UI control is activated.

virtual void OnUiFocusChanged(UiEvent e)

Called when this entity's input field gains or loses focus.

virtual void OnUiTextChanged(UiEvent e)

Called when this entity's input-field text changes.

virtual void OnUiValueChanged(UiEvent e)

Called when this entity's UI control changes value.

virtual void Start()

Called once before the first update.

bool TryGetField<T>(string name, out T value)

Attempts to decode one authored Stage field without replacing failures with a default value.

virtual void Update(double deltaTime)

Called once per rendered frame.

EntityHandle Entity { get; }

The entity whose native transform this component addresses.

Vector3d EulerAngles { get; set; }

World-space XYZ angles in degrees. Use Rotate for incremental animation.

Vector3d Forward { get; }

The entity's local +Y direction expressed in world space. A Camera's optical forward direction is local -Z.

Vector3d LocalEulerAngles { get; set; }

Parent-relative XYZ angles in degrees, matching the Inspector. Use Rotate for incremental animation.

Vector3d LocalPosition { get; set; }

Position relative to the parent, in metres.

Quaterniond LocalRotation { get; set; }

Parent-relative quaternion rotation. Use LocalEulerAngles for degree angles.

Vector3d LocalScale { get; set; }

Parent-relative scale. One preserves the authored size.

Vector3d Position { get; set; }

Position in world coordinates, in metres. Accounts for parent rotation and scale.

Vector3d Right { get; }

The entity's local +X direction expressed in world space.

Quaterniond Rotation { get; set; }

World-space quaternion rotation. Use EulerAngles for degree angles.

Vector3d Up { get; }

The entity's local +Z direction expressed in world space (IronGrid is Z-up).

Transform(EntityHandle entity)

Addresses an entity's live Transform; operations validate the handle with the native engine.

void Rotate(double xDegrees, double yDegrees, double zDegrees, Space relativeTo = Space.Self)

Applies XYZ degree increments around the entity's axes (Self) or world axes (World), without Euler readback.

void Rotate(Vector3d axis, double angleDegrees, Space relativeTo = Space.Self)

Rotates angleDegrees around the supplied axis in the requested coordinate space.

void Rotate(Vector3d degrees, Space relativeTo = Space.Self)

Applies XYZ degree increments without Euler readback.

void SetLocalPositionAndRotation(Vector3d position, Quaterniond rotation)

Changes parent-relative position and rotation together, preserving local scale.

void SetPositionAndRotation(Vector3d position, Quaterniond rotation)

Changes position and quaternion rotation together in world space, preserving local scale.

void Translate(double x, double y, double z, Space relativeTo = Space.Self)

Moves by XYZ distances in metres in the requested space.

void Translate(Vector3d distance, Space relativeTo = Space.Self)

Moves by a distance in metres along the entity's axes or world axes. Scale does not multiply the distance.

static bool CursorVisibleRequested { get; }

Gets the cursor visibility currently requested by gameplay code.

static bool MouseCaptureRequested { get; }

Gets whether relative/captured mouse input is requested.

static Vector2d MouseDelta { get; }

Gets pointer movement since the previous input frame.

static Vector2d MousePosition { get; }

Gets the pointer position in the active game viewport.

static Vector2d MouseViewportSize { get; }

Gets the active game viewport dimensions in pixels.

static double GetAxis(string name)

Gets a normalized project input axis by its authored name.

static bool GetButton(string name)

Gets whether an authored project button is currently held.

static bool GetButtonDown(string name)

Gets whether an authored project button was pressed this frame.

static bool GetButtonUp(string name)

Gets whether an authored project button was released this frame.

static bool KeyDown(int key)

Gets whether a platform-neutral numeric key is currently held.

static bool KeyDown(KeyCode key)

Gets whether an engine-normalized key is currently held.

static bool KeyPressed(int key)

Gets whether a platform-neutral numeric key was pressed this frame.

static bool KeyPressed(KeyCode key)

Gets whether an engine-normalized key was pressed this frame.

static bool KeyReleased(int key)

Gets whether a platform-neutral numeric key was released this frame.

static bool KeyReleased(KeyCode key)

Gets whether an engine-normalized key was released this frame.

static bool MouseDown(int button)

Gets whether a platform mouse button is currently held.

static bool MouseDown(MouseButton button)

Gets whether an engine-normalized mouse button is currently held.

static bool MousePressed(int button)

Gets whether a platform mouse button was pressed this frame.

static bool MousePressed(MouseButton button)

Gets whether an engine-normalized mouse button was pressed this frame.

static bool MouseReleased(int button)

Gets whether a platform mouse button was released this frame.

static bool MouseReleased(MouseButton button)

Gets whether an engine-normalized mouse button was released this frame.

static void SetCursorVisible(bool visible)

Requests visible or hidden game cursor presentation.

static void SetMouseCapture(bool capture)

Requests relative/captured mouse input for this Play session.

static IReadOnlyList<EntityHandle> All()

Returns a copied deterministic snapshot of every active native entity.

static IReadOnlyList<EntityHandle> Children(EntityHandle entity)

Returns the current direct children of an entity.

static void Despawn(EntityHandle entity)

Destroys the entity and its children, including disabled entities.

static bool Exists(EntityHandle entity)

Returns whether an entity handle still resolves to an active native entity.

static IReadOnlyList<EntityHandle> FindAllByName(string name)

Finds every active entity with an exact authored or runtime name.

static EntityHandle? FindByGuid(string guid)

Finds an active entity by its authored Stage GUID, or returns null when it is absent.

static EntityHandle? FindByName(string name)

Finds the first active entity with an exact authored or runtime name.

static IReadOnlyList<EntityHandle> FindByPrefix(string prefix)

Finds active entities whose authored or runtime name begins with the supplied prefix.

static Transform GetTransformComponent(EntityHandle entity)

Returns an entity's live Transform component with immediate local/world property setters.

static EntityHandle Instantiate(EntityHandle template, string name = "")

Clones the entity's complete hierarchy and Modules into the active Stage. An empty name preserves the source name.

static EntityHandle Instantiate(string archetypeAssetPath, string name = "")

Instantiates an Archetype's complete hierarchy and Modules in the active Stage. An empty name preserves the Archetype root name.

static bool IsEnabled(EntityHandle entity)

Gets whether an entity is enabled in its Transform state.

static string Name(EntityHandle entity)

Gets an entity's current Transform-owned name.

static void SetEnabled(EntityHandle entity, bool enabled)

Updates an entity's Transform-enabled state.

static void SetName(EntityHandle entity, string name)

Updates an entity's current Transform-owned name.

static EntityHandle Spawn(string name = "Entity")

Creates an active runtime entity with a named default Transform.

static bool TryGetRenderableBounds(EntityHandle entity, out Bounds3d bounds)

Copies this entity's current rendered world-space axis-aligned bounds, including its parent transform. Returns false when it has no renderable bounds (including disabled renderers). Does not aggregate children. Invalid handles or calls outside Play throw.

static EntityHandle? ActiveCamera { get; }

Gets the active native camera entity, or null when the current Stage has none.

static string Name { get; }

Gets the current native StageCore name.

static void Load(string stageNameOrPath)

Requests a switch to an included Stage on the next native frame boundary.

static void SetTrigger(EntityHandle entity, string parameter)

Activates one authored trigger parameter on an entity's Animator.

static void Pause(EntityHandle source)

Pauses every active voice for an authored AudioSource entity.

static void Play(EntityHandle source, double volumeScale = 1)

Plays the authored AudioSource attached to an entity.

static void PlayOneShot(string assetGuid, double volume = 1, string busName = "SFX")

Plays a cooked audio asset addressed by its immutable project asset GUID.

static void Resume(EntityHandle source)

Resumes every active voice for an authored AudioSource entity.

static void SetBusMuted(string busName, bool muted)

Mutes or unmutes a named audio bus.

static void SetBusVolume(string busName, double volume)

Changes the runtime volume of a named audio bus.

static void SetPitch(EntityHandle source, double pitch)

Changes the authored AudioSource's runtime pitch.

static void SetVolume(EntityHandle source, double volume)

Changes the authored AudioSource's runtime volume.

static void Stop(EntityHandle source)

Stops every active voice for an authored AudioSource entity.

static void StopAll()

Stops every engine audio voice, including one-shots.

string AssetGuid { get; }

The immutable project GUID of a clip included in the shipped game.

AudioAssetDependencyAttribute(string assetGuid)

Declares a cooked audio dependency when PlayOneShot selects its GUID at runtime. Constant GUID arguments are discovered automatically during packaging. Apply this attribute for every possible clip on a gameplay class in the source closure.

Vector3d Max { get; set; }

Vector3d Min { get; set; }

Bounds3d(Vector3d Min, Vector3d Max)

A world-space axis-aligned box, described by its minimum and maximum corners.

void Deconstruct(out Vector3d Min, out Vector3d Max)

bool Equals(Bounds3d other)

virtual bool Equals(object obj)

virtual int GetHashCode()

virtual string ToString()

static Ray3d ScreenPointToRay(EntityHandle camera, Vector2d point, Vector2d viewportSize)

Converts viewport-local pixels (top-left origin, Y downward) to a world ray from the camera's near plane. Pass Input.MousePosition and Input.MouseViewportSize for cursor aiming. Uses the requested viewport's aspect for perspective and orthographic cameras.

double Impulse { get; set; }

bool IsExit { get; set; }

bool IsStay { get; set; }

Vector2d Normal { get; set; }

EntityHandle Other { get; set; }

EntityHandle Self { get; set; }

CollisionEvent2D(EntityHandle Self, EntityHandle Other, Vector2d Normal, double Impulse, bool IsStay, bool IsExit)

One 2D collision event copied from the active native physics world.

void Deconstruct(out EntityHandle Self, out EntityHandle Other, out Vector2d Normal, out double Impulse, out bool IsStay, out bool IsExit)

bool Equals(CollisionEvent2D other)

virtual bool Equals(object obj)

virtual int GetHashCode()

virtual string ToString()

double Impulse { get; set; }

bool IsExit { get; set; }

bool IsStay { get; set; }

Vector3d Normal { get; set; }

EntityHandle Other { get; set; }

EntityHandle Self { get; set; }

CollisionEvent3D(EntityHandle Self, EntityHandle Other, Vector3d Normal, double Impulse, bool IsStay, bool IsExit)

One 3D collision event copied from the active native physics world.

void Deconstruct(out EntityHandle Self, out EntityHandle Other, out Vector3d Normal, out double Impulse, out bool IsStay, out bool IsExit)

bool Equals(CollisionEvent3D other)

virtual bool Equals(object obj)

virtual int GetHashCode()

virtual string ToString()

uint CollisionLayer

Collision-category bits assigned to the entity.

uint CollisionMask

Collision-category bits the entity accepts.

EntityCollisionFilter(uint collisionLayer = 1, uint collisionMask = 4294967295)

Builds an explicit entity collision filter.

uint Generation { get; set; }

bool IsValid { get; }

Gets whether this handle refers to a non-null native entity identity.

ulong Value { get; set; }

EntityHandle(ulong Value, uint Generation)

Stable native entity identifier exposed to managed gameplay code.

void Deconstruct(out ulong Value, out uint Generation)

bool Equals(EntityHandle other)

virtual bool Equals(object obj)

virtual int GetHashCode()

virtual string ToString()

GameplayEventPayload()

GameplayEventPayload Boolean(string name, bool value)

Adds a boolean field.

GameplayEventPayload Integer(string name, long value)

Adds an integer field.

GameplayEventPayload Number(string name, double value)

Adds a finite numeric field.

GameplayEventPayload Text(string name, string value)

Adds a text field.

static void Emit(string name, GameplayEventPayload payload)

Emits a typed event without reflecting over an authored C# type.

static void Emit(string name, JsonElement payload)

Emits an event with an explicit JSON-object payload.

static void Emit(string name)

Emits a named gameplay fact with an empty typed payload.

static GameplayEventPayload Payload()

Creates a typed payload using only engine-owned primitive values.

static void Clear()

Explicitly clears all settings in the current game session.

static bool Remove(string key)

Removes a named setting and reports whether it existed.

static void Set(string key, string value)

Copies a named string setting into the current game session.

static bool TryGet(string key, out string value)

Returns a stored setting, or false when the key is absent.

static GraphicsCapabilities Capabilities { get; }

Reads the active renderer's supported features.

static GraphicsSettings Current { get; }

Reads the current effective settings.

static void Apply(GraphicsSettings settings, bool persist = false)

Queues settings for the next frame. Persist saves them in the game's local user settings.

static GraphicsSettings GetPreset(GraphicsPreset preset)

Returns a built-in preset adjusted to the active renderer's capabilities.

static GraphicsAntiAliasing Fxaa = 1

Fast approximate anti-aliasing.

static GraphicsAntiAliasing Off = 0

Disables anti-aliasing.

static GraphicsAntiAliasing Taa = 2

Temporal anti-aliasing.

static GraphicsAntiAliasing TaaHigh = 3

Higher quality temporal anti-aliasing.

bool AutomaticExposure { get; set; }

Histogram exposure availability.

bool Bloom { get; set; }

Bloom availability.

bool Fxaa { get; set; }

Fast approximate anti-aliasing availability.

bool Hdr { get; set; }

HDR post-processing availability.

bool RayTracedAmbientOcclusion { get; set; }

Certified ray-traced ambient occlusion availability.

bool RayTracedGlobalIllumination { get; set; }

Certified ray-traced global illumination availability.

bool RayTracedReflections { get; set; }

Certified ray-traced reflections availability.

bool RayTracedShadows { get; set; }

Certified ray-traced shadows availability.

bool RayTracing { get; set; }

Certified ray-tracing infrastructure availability.

bool ScreenSpaceReflections { get; set; }

Screen-space reflections availability.

bool Ssao { get; set; }

Screen-space ambient occlusion availability.

bool Taa { get; set; }

Temporal anti-aliasing availability.

GraphicsCapabilities()

GraphicsCapabilities <Clone>$()

bool Equals(GraphicsCapabilities? other)

virtual bool Equals(object? obj)

virtual int GetHashCode()

virtual string ToString()

static GraphicsPreset Balanced = 1

Balances image quality and frame rate.

static GraphicsPreset Custom = 4

Individually edited properties.

static GraphicsPreset Performance = 0

Prioritizes frame rate.

static GraphicsPreset Quality = 2

Increases shadows and post-processing quality.

static GraphicsPreset Ultra = 3

Highest built-in raster quality.

GraphicsAntiAliasing AntiAliasing { get; set; }

Controls the native anti aliasing setting.

bool AutomaticExposure { get; set; }

Controls the native automatic exposure setting.

float AutomaticExposureMax { get; set; }

Controls the native automatic exposure max setting.

float AutomaticExposureMin { get; set; }

Controls the native automatic exposure min setting.

float AutomaticExposureSpeedDown { get; set; }

Controls the native automatic exposure speed down setting.

float AutomaticExposureSpeedUp { get; set; }

Controls the native automatic exposure speed up setting.

bool Bloom { get; set; }

Controls the native bloom setting.

float BloomIntensity { get; set; }

Controls the native bloom intensity setting.

int BloomQuality { get; set; }

Controls the native bloom quality setting.

float ContactShadowLength { get; set; }

Controls the native contact shadow length setting.

bool ContactShadows { get; set; }

Controls the native contact shadows setting.

float Exposure { get; set; }

Controls the native exposure setting.

int FrameLimitFps { get; set; }

Native frame limit, from 0 through 1000 FPS inclusive. Zero disables the limit.

float Gamma { get; set; }

Controls the native gamma setting.

bool Hdr { get; set; }

Controls the native hdr setting.

GraphicsPreset Preset { get; set; }

Derived quality classification, recalculated from the effective render properties after Apply. Vsync and FrameLimitFps do not determine this classification. Use Graphics.GetPreset to obtain a preset's property values; compare actual editable properties when confirming an applied request, rather than a manually assigned Preset label.

bool RayTracedAmbientOcclusion { get; set; }

Controls the native ray traced ambient occlusion setting.

bool RayTracedGlobalIllumination { get; set; }

Controls the native ray traced global illumination setting.

bool RayTracedReflections { get; set; }

Controls the native ray traced reflections setting.

bool RayTracedShadows { get; set; }

Controls the native ray traced shadows setting.

bool RayTracing { get; set; }

Controls the native ray tracing setting.

int RayTracingSamples { get; set; }

Controls the native ray tracing samples setting.

float ReflectionIntensity { get; set; }

Controls the native reflection intensity setting.

float RenderScale { get; set; }

Native render resolution scale, from 0.5 through 2.0 inclusive.

bool ScreenSpaceReflections { get; set; }

Controls the native screen space reflections setting.

int ShadowCascadeCount { get; set; }

Controls the native shadow cascade count setting.

float ShadowDistance { get; set; }

Controls the native shadow distance setting.

int ShadowMapSize { get; set; }

Native shadow map size. Supported steps are 1024, 2048, 4096 and 8192 pixels; other values are rejected.

bool Ssao { get; set; }

Controls the native ssao setting.

bool SsaoHalfResolution { get; set; }

Controls the native ssao half resolution setting.

float SsaoStrength { get; set; }

Controls the native ssao strength setting.

bool SsrHalfResolution { get; set; }

Controls the native ssr half resolution setting.

int Tonemapper { get; set; }

Controls the native tonemapper setting.

bool Vsync { get; set; }

Controls the native vsync setting.

GraphicsSettings()

GraphicsSettings <Clone>$()

bool Equals(GraphicsSettings? other)

virtual bool Equals(object? obj)

virtual int GetHashCode()

virtual string ToString()

static EntityHandle? GetParent(EntityHandle entity)

Gets an entity's parent, or null when it is a hierarchy root.

static void SetParent(EntityHandle child, EntityHandle? parent)

Reparents an entity, or passes null to make it a hierarchy root. Cycles are rejected.

static HitscanShot Trace(Vector3d aimOrigin, Vector3d aimDirection, Vector3d barrelStart, Vector3d muzzle, double range, IReadOnlyCollection<EntityHandle> ignoredEntities, PhysicsQueryFilter3D? filter = null)

Aims from an explicit world-space ray, checks cover between barrelStart and muzzle, then casts from the muzzle toward the aiming point. Range is in metres. Pass the shooter and held-item entity handles to ignore them; other colliders, including walls on the same layer, still block the shot. A camera aim direction is its world rotation times local (0,0,-1). A point emitter may use the same barrelStart and muzzle. This query does not consume ammunition, apply damage or emit a claimed hit event.

Vector3d AimPoint { get; set; }

bool BlockedBeforeMuzzle { get; set; }

Vector3d Direction { get; set; }

Vector3d EndPoint { get; set; }

RaycastHit3D? Hit { get; set; }

Vector3d Origin { get; set; }

HitscanShot(Vector3d AimPoint, Vector3d Origin, Vector3d Direction, Vector3d EndPoint, RaycastHit3D? Hit, bool BlockedBeforeMuzzle)

A factual shot query result. Hit is null on a miss. When BlockedBeforeMuzzle is true, Origin and Direction describe the blocked barrel segment; otherwise they describe muzzle-to-target travel. Damage and effects remain game-owned.

void Deconstruct(out Vector3d AimPoint, out Vector3d Origin, out Vector3d Direction, out Vector3d EndPoint, out RaycastHit3D? Hit, out bool BlockedBeforeMuzzle)

bool Equals(HitscanShot other)

virtual bool Equals(object obj)

virtual int GetHashCode()

virtual string ToString()

static KeyCode A = 97

The A key.

static KeyCode D = 100

The D key.

static KeyCode DownArrow = 1073741905

The down-arrow key.

static KeyCode E = 101

The E key.

static KeyCode Enter = 13

The Enter key.

static KeyCode Escape = 27

The Escape key.

static KeyCode F = 102

The F key.

static KeyCode G = 103

The G key.

static KeyCode LeftArrow = 1073741904

The left-arrow key.

static KeyCode Q = 113

The Q key.

static KeyCode R = 114

The R key.

static KeyCode RightArrow = 1073741903

The right-arrow key.

static KeyCode S = 115

The S key.

static KeyCode Space = 32

The space bar.

static KeyCode UpArrow = 1073741906

The up-arrow key.

static KeyCode W = 119

The W key.

static LifecyclePhase Awake = 0

Initial construction phase.

static LifecyclePhase FixedUpdate = 3

Fixed-step simulation phase.

static LifecyclePhase LateUpdate = 5

Post-update phase.

static LifecyclePhase OnDestroy = 7

Deterministic Play-session teardown phase.

static LifecyclePhase OnDisable = 6

Enabled-state exit phase.

static LifecyclePhase OnEnable = 1

Enabled-state entry phase.

static LifecyclePhase Start = 2

One-time startup phase.

static LifecyclePhase Update = 4

Per-frame phase.

static MouseButton Left = 1

The primary mouse button.

static MouseButton Middle = 2

The middle mouse button.

static MouseButton Right = 3

The secondary mouse button.

EntityHandle Entity { get; set; }

bool IsTrigger { get; set; }

OverlapHit2D(EntityHandle Entity, bool IsTrigger)

One entity returned by a complete engine-backed 2D overlap query.

void Deconstruct(out EntityHandle Entity, out bool IsTrigger)

bool Equals(OverlapHit2D other)

virtual bool Equals(object obj)

virtual int GetHashCode()

virtual string ToString()

EntityHandle Entity { get; set; }

bool IsTrigger { get; set; }

OverlapHit3D(EntityHandle Entity, bool IsTrigger)

One entity returned by a complete engine-backed 3D sphere-overlap query.

void Deconstruct(out EntityHandle Entity, out bool IsTrigger)

bool Equals(OverlapHit3D other)

virtual bool Equals(object obj)

virtual int GetHashCode()

virtual string ToString()

static void AddForce(EntityHandle entity, Vector2d force)

Applies a force to an entity's 2D rigid body.

static void AddImpulse(EntityHandle entity, Vector2d impulse)

Applies an instantaneous impulse to an entity's 2D rigid body.

static double GetAngularVelocity(EntityHandle entity)

Gets an entity's current 2D angular velocity.

static IReadOnlyList<CollisionEvent2D> GetCollisionEvents(EntityHandle entity)

Copies the active 2D collision events involving an entity into managed-owned values.

static Vector2d GetLinearVelocity(EntityHandle entity)

Gets an entity's current 2D linear velocity.

static IReadOnlyList<TriggerEvent2D> GetTriggerEvents(EntityHandle entity)

Copies the active 2D trigger events involving an entity into managed-owned values.

static IReadOnlyList<OverlapHit2D> OverlapBox(Vector2d center, Vector2d halfExtents, double rotationDegrees = 0, PhysicsQueryFilter2D? filter = null)

Returns every collider that overlaps the supplied oriented box in the active native physics world.

static IReadOnlyList<OverlapHit2D> OverlapCircle(Vector2d center, double radius, PhysicsQueryFilter2D? filter = null)

Returns every collider that overlaps the supplied circle in the active native physics world.

static RaycastHit2D? RaycastFirst(Vector2d origin, Vector2d direction, double maxDistance, PhysicsQueryFilter2D? filter = null)

Runs a first-hit 2D raycast against the active native physics world.

static void SetAngularVelocity(EntityHandle entity, double velocity)

Sets an entity's 2D angular velocity and wakes its rigid body.

static void SetLinearVelocity(EntityHandle entity, Vector2d velocity)

Sets an entity's 2D linear velocity and wakes its rigid body.

static void AddForce(EntityHandle entity, Vector3d force)

Applies a world-space force through the native 3D physics owner.

static void AddImpulse(EntityHandle entity, Vector3d impulse)

Applies an instantaneous impulse through the native 3D physics owner.

static void AddTorque(EntityHandle entity, Vector3d torque)

Applies a torque through the native 3D physics owner.

static RaycastHit3D? BoxCastFirst(Vector3d center, Vector3d halfExtents, Quaterniond rotation, Vector3d direction, double maxDistance, PhysicsQueryFilter3D? filter = null)

Runs a first-hit swept oriented-box cast against the active native physics world.

static RaycastHit3D? CapsuleCastFirst(Vector3d center, double radius, double halfHeight, Quaterniond rotation, Vector3d direction, double maxDistance, PhysicsQueryFilter3D? filter = null)

Runs a first-hit swept capsule cast against the active native physics world.

static Vector3d GetAngularVelocity(EntityHandle entity)

Returns the current 3D rigid-body angular velocity for an entity.

static IReadOnlyList<CollisionEvent3D> GetCollisionEvents(EntityHandle entity)

Copies active 3D collision events involving an entity.

static Vector3d GetLinearVelocity(EntityHandle entity)

Returns the current 3D rigid-body linear velocity for an entity.

static IReadOnlyList<TriggerEvent3D> GetTriggerEvents(EntityHandle entity)

Copies active 3D trigger events involving an entity.

static IReadOnlyList<OverlapHit3D> OverlapBox(Vector3d center, Vector3d halfExtents, Quaterniond rotation, PhysicsQueryFilter3D? filter = null)

Returns every collider that overlaps the supplied oriented box in the active native physics world.

static IReadOnlyList<OverlapHit3D> OverlapCapsule(Vector3d center, double radius, double halfHeight, Quaterniond rotation, PhysicsQueryFilter3D? filter = null)

Returns every collider that overlaps the supplied capsule in the active native physics world.

static IReadOnlyList<OverlapHit3D> OverlapSphere(Vector3d center, double radius, PhysicsQueryFilter3D? filter = null)

Returns every collider that overlaps the supplied sphere in the active native physics world.

static IReadOnlyList<RaycastHit3D> RaycastAll(Vector3d origin, Vector3d direction, double maxDistance, PhysicsQueryFilter3D? filter = null)

Returns every intersected 3D collider, ordered by distance, using the native layer/mask/trigger filter. Results retain entity identity so gameplay can explicitly exclude a shooter and held items while preserving other obstacles. Direction must be finite and nonzero; distance must be finite and positive.

static RaycastHit3D? RaycastFirst(Vector3d origin, Vector3d direction, double maxDistance, PhysicsQueryFilter3D? filter = null)

Runs a first-hit 3D raycast against the active native physics world.

static void SetAngularVelocity(EntityHandle entity, Vector3d velocity)

Sets the current 3D rigid-body angular velocity for an entity.

static void SetHingeMotor(EntityHandle entity, bool enabled, double targetDegrees, double frequency = 4, double damping = 1, double maxTorque = 100)

Drives an existing HingeConstraint3D toward an angle relative to its initial joint pose. The target is in degrees [-180, 180] and is limited by the joint limits. Frequency is in Hz, damping is a nonnegative ratio, and maxTorque is a finite nonnegative strength in Nm. Update from FixedUpdate for pose tracking. Zero torque lets the limb yield; disabling the motor retains the joint and its limits. This does not teleport or reset the bodies.

static void SetLinearVelocity(EntityHandle entity, Vector3d velocity)

Sets the current 3D rigid-body linear velocity for an entity.

static RaycastHit3D? SphereCastFirst(Vector3d origin, double radius, Vector3d direction, double maxDistance, PhysicsQueryFilter3D? filter = null)

Runs a first-hit swept-sphere cast against the active native physics world.

static EntityCollisionFilter Get(EntityHandle entity)

Gets the entity's authoritative collision-layer and collision-mask bits.

static void Set(EntityHandle entity, EntityCollisionFilter filter)

Sets both collision-filter values on every supported physics module attached to the entity.

static void SetLayer(EntityHandle entity, uint collisionLayer)

Sets the collision-layer bits while preserving the entity's current collision-mask bits.

static void SetMask(EntityHandle entity, uint collisionMask)

Sets the collision-mask bits while preserving the entity's current collision-layer bits.

uint CollisionLayer

Collision layer bits used by the query body.

uint CollisionMask

Collision mask bits accepted by the query.

int IncludeTriggers

Whether trigger colliders may be returned.

PhysicsQueryFilter2D()

Queries solid colliders on all layers from the default query layer.

PhysicsQueryFilter2D(uint collisionLayer = 1, uint collisionMask = 4294967295, bool includeTriggers = false)

Builds an explicit query filter.

uint CollisionLayer

Collision layer bits used by the query shape.

uint CollisionMask

Collision mask bits accepted by the query.

int IncludeTriggers

Whether trigger colliders may be returned.

PhysicsQueryFilter3D()

Queries solid colliders on all layers from the default query layer.

PhysicsQueryFilter3D(uint collisionLayer = 1, uint collisionMask = 4294967295, bool includeTriggers = false)

Builds an explicit 3D query filter.

double W

Quaternion scalar component.

double X

Quaternion X component, not an X angle.

double Y

Quaternion Y component, not a Y angle.

double Z

Quaternion Z component, not a Z angle.

Vector3d EulerAngles { get; }

Returns equivalent XYZ degree angles. Values can wrap; use Transform.Rotate for continuous rotation.

static Quaterniond Identity { get; }

The identity rotation.

Quaterniond Normalized { get; }

Returns a unit quaternion. Rejects zero or non-finite rotations.

Quaterniond(double x, double y, double z, double w)

Creates an explicit quaternion from its four components.

static Quaterniond AngleAxis(double angle, Vector3d axis)

Constructs a rotation of angle degrees about an axis; axis length is ignored.

static Quaterniond Euler(double x, double y, double z)

Constructs a rotation from X/Y/Z degree angles in IronGrid's extrinsic XYZ order, matching the Inspector.

static Quaterniond Euler(Vector3d degrees)

Constructs a rotation from X/Y/Z degree angles, matching the Inspector.

static Quaterniond Inverse(Quaterniond value)

Reverses a rotation.

Vector3d Direction { get; set; }

Vector3d Origin { get; set; }

Ray3d(Vector3d Origin, Vector3d Direction)

A world-space ray with a unit direction, produced by Camera.ScreenPointToRay.

void Deconstruct(out Vector3d Origin, out Vector3d Direction)

bool Equals(Ray3d other)

virtual bool Equals(object obj)

virtual int GetHashCode()

Vector3d GetPoint(double distance)

Returns a world point at the given distance in metres along the ray.

virtual string ToString()

bool TryIntersectBounds(Bounds3d bounds, out double distance)

Intersects a world-space axis-aligned box. Distance is in metres; rays starting inside return zero. Returns false for a miss or a box behind the origin. Invalid bounds or a non-unit ray throw.

bool TryIntersectPlane(Vector3d point, Vector3d normal, out Vector3d intersection)

Intersects a plane defined by a world point and normal. Returns false for parallel rays or a plane behind the ray origin.

double Distance { get; set; }

EntityHandle Entity { get; set; }

double Fraction { get; set; }

bool IsTrigger { get; set; }

Vector2d Normal { get; set; }

Vector2d Point { get; set; }

RaycastHit2D(EntityHandle Entity, Vector2d Point, Vector2d Normal, double Distance, double Fraction, bool IsTrigger)

One first-hit result from an engine-backed 2D raycast.

void Deconstruct(out EntityHandle Entity, out Vector2d Point, out Vector2d Normal, out double Distance, out double Fraction, out bool IsTrigger)

bool Equals(RaycastHit2D other)

virtual bool Equals(object obj)

virtual int GetHashCode()

virtual string ToString()

double Distance { get; set; }

EntityHandle Entity { get; set; }

double Fraction { get; set; }

bool IsTrigger { get; set; }

Vector3d Normal { get; set; }

Vector3d Point { get; set; }

RaycastHit3D(EntityHandle Entity, Vector3d Point, Vector3d Normal, double Distance, double Fraction, bool IsTrigger)

One first-hit result from an engine-backed 3D raycast.

void Deconstruct(out EntityHandle Entity, out Vector3d Point, out Vector3d Normal, out double Distance, out double Fraction, out bool IsTrigger)

bool Equals(RaycastHit3D other)

virtual bool Equals(object obj)

virtual int GetHashCode()

virtual string ToString()

string BehaviorType { get; set; }

string Message { get; set; }

LifecyclePhase Phase { get; set; }

string? StackTrace { get; set; }

ScriptDiagnostic(LifecyclePhase Phase, string BehaviorType, string Message, string? StackTrace)

Structured managed-script diagnostic returned to the native host.

ScriptDiagnostic <Clone>$()

void Deconstruct(out LifecyclePhase Phase, out string BehaviorType, out string Message, out string StackTrace)

bool Equals(ScriptDiagnostic? other)

virtual bool Equals(object? obj)

virtual int GetHashCode()

virtual string ToString()

static Space Self = 1

The entity's own rotated axes.

static Space World = 0

Axes of the world.

static void Add(EntityHandle entity, string tag)

Adds an additional tag if it is not already present.

static bool Has(EntityHandle entity, string tag)

Returns whether an entity has an enabled primary or additional tag.

static string Primary(EntityHandle entity)

Gets the enabled primary tag.

static void Remove(EntityHandle entity, string tag)

Removes an additional tag.

static void SetPrimary(EntityHandle entity, string tag)

Sets the primary tag.

static void SetValues(EntityHandle entity, params string[] values)

Replaces the additional tag set.

static IReadOnlyList<string> Values(EntityHandle entity)

Gets a copied snapshot of additional tags.

static double DeltaTime { get; }

Most recent rendered-frame step in seconds.

static double ElapsedTime { get; }

Elapsed rendered-frame time in the current Play or Player session.

static double FixedDeltaTime { get; }

Most recent fixed simulation step in seconds.

static ulong FrameCount { get; }

Number of rendered-frame updates dispatched in the current session.

bool IsActive { get; }

Whether this timer is still scheduled in the current managed session.

void Cancel()

Cancels this timer. Cancelling a completed timer is safe.

static TimerHandle After(double seconds, Action callback)

Runs callback once after the requested duration.

static void Cancel(TimerHandle? handle)

Cancels a timer. Cancelling an already-completed timer is safe.

static TimerHandle Every(double seconds, Action callback)

Runs callback once per requested duration.

bool IsExit { get; set; }

bool IsStay { get; set; }

EntityHandle Other { get; set; }

EntityHandle Self { get; set; }

TriggerEvent2D(EntityHandle Self, EntityHandle Other, bool IsStay, bool IsExit)

One 2D trigger event copied from the active native physics world.

void Deconstruct(out EntityHandle Self, out EntityHandle Other, out bool IsStay, out bool IsExit)

bool Equals(TriggerEvent2D other)

virtual bool Equals(object obj)

virtual int GetHashCode()

virtual string ToString()

bool IsExit { get; set; }

bool IsStay { get; set; }

EntityHandle Other { get; set; }

EntityHandle Self { get; set; }

TriggerEvent3D(EntityHandle Self, EntityHandle Other, bool IsStay, bool IsExit)

One 3D trigger event copied from the active native physics world.

void Deconstruct(out EntityHandle Self, out EntityHandle Other, out bool IsStay, out bool IsExit)

bool Equals(TriggerEvent3D other)

virtual bool Equals(object obj)

virtual int GetHashCode()

virtual string ToString()

TunableAttribute()

static void SetCheckboxValue(EntityHandle entity, bool value)

Sets the checked state of an entity with a UICheckbox component.

static void SetDropdownSelectedIndex(EntityHandle entity, int index)

Selects an option by index on an entity with a UIDropdown component.

static void SetInputText(EntityHandle entity, string text)

Sets the editable text of an entity with a UIInputField component.

static void SetProgressValue(EntityHandle entity, double value)

Sets the visible value of an entity with a UIProgressBar component.

static void SetSliderValue(EntityHandle entity, double value)

Sets the clamped value of an entity with a UISlider component.

static void SetText(EntityHandle entity, string text)

Sets visible UIText text and UIButton labels on an entity. Updates both when both components are present.

JsonElement Data { get; set; }

EntityHandle Entity { get; set; }

UiEvent(EntityHandle Entity, JsonElement Data)

Immutable payload for a native UI event targeting a behavior's entity.

void Deconstruct(out EntityHandle Entity, out JsonElement Data)

bool Equals(UiEvent other)

virtual bool Equals(object obj)

virtual int GetHashCode()

virtual string ToString()

double X

Horizontal component.

double Y

Vertical component.

Vector2d(double x, double y)

Initializes a two-dimensional double-precision value.

double X

X component.

double Y

Y component.

double Z

Z component.

static Vector3d Forward { get; }

Positive Y direction. Cameras have a separate optical axis of local negative Z.

double Magnitude { get; }

Euclidean length.

static Vector3d One { get; }

Unit scale vector.

static Vector3d Right { get; }

Positive X direction.

static Vector3d Up { get; }

Positive Z direction: IronGrid's world-up axis.

static Vector3d Zero { get; }

Zero vector.

Vector3d(double x, double y, double z)

Creates a vector from X, Y, and Z.

static double Dot(Vector3d a, Vector3d b)

Returns the dot product of two vectors.

static Vector3d Add(Vector3d left, Vector3d right)

Adds two generated graph Vector3 values.

static Vector3d Scale(Vector3d value, double scale)

Scales one generated graph Vector3 value.

bool Automatic { get; }

Whether a held trigger repeats fire at the configured cadence.

double CooldownSeconds { get; }

Remaining cooldown, including while the trigger is released.

bool IsReloading { get; }

Whether a requested reload is currently in progress.

int MagazineAmmo { get; }

Current rounds in the magazine.

int MagazineCapacity { get; }

Maximum rounds in the magazine.

double ReloadRemainingSeconds { get; }

Remaining simulation seconds before a reload transfers ammunition.

double ReloadSeconds { get; }

Simulation seconds needed to complete one magazine reload.

int ReserveAmmo { get; }

Current spare rounds; reloading transfers these into the magazine.

double ShotIntervalSeconds { get; }

Minimum simulation seconds between shots.

WeaponCycle(int magazineCapacity, int magazineAmmo, int reserveAmmo, double roundsPerMinute, double reloadSeconds, bool automatic)

Creates a ready weapon with explicit ammunition and timing. Capacity and rounds per minute must be positive; ammunition must fit and reload time may be zero. All timing values and the resulting shot interval must be finite.

void AddReserveAmmo(int rounds)

Adds nonnegative spare rounds; overflow is rejected without changing state.

WeaponStep Advance(double seconds, bool triggerHeld, bool triggerPressed, bool reloadRequested)

Advances a positive finite simulation interval. Input applies at its start. Semi-automatic fire requires triggerPressed; automatic fire also repeats while triggerHeld. A press during cooldown or reload is not buffered. Reload requests take priority over fire, require spare ammo and magazine space, and do not restart an active reload. Reloading is never automatic. Shots belong to [start,end), so an end-boundary shot occurs next step. A held automatic trigger can resume when a reload completes within a step.

double FirstShotOffsetSeconds { get; set; }

bool ReloadCompleted { get; set; }

bool ReloadStarted { get; set; }

double ShotIntervalSeconds { get; set; }

int ShotsFired { get; set; }

WeaponStep(int ShotsFired, double FirstShotOffsetSeconds, double ShotIntervalSeconds, bool ReloadStarted, bool ReloadCompleted)

Factual results of a WeaponCycle step. Shot i occurred at FirstShotOffsetSeconds + i * ShotIntervalSeconds, relative to the step start. The caller resolves these shots against real gameplay state; this is not hit evidence.

void Deconstruct(out int ShotsFired, out double FirstShotOffsetSeconds, out double ShotIntervalSeconds, out bool ReloadStarted, out bool ReloadCompleted)

bool Equals(WeaponStep other)

virtual bool Equals(object obj)

virtual int GetHashCode()

virtual string ToString()