UnityEngine

Structure describing acceleration status of the device.

Value of acceleration.

Amount of time passed since last accelerometer measurement.

The AddComponentMenu attribute allows you to place a script anywhere in the "Component" menu, instead of just the "Component->Scripts" menu.

The order of the component in the component menu (lower is higher to the top).

Add an item in the Component menu.

The path to the component. Where in the component menu to add the new item.

Add an item in the Component menu.

The path to the component. Where in the component menu to add the new item.

Parent class for all joints that have anchor points.

The joint's anchor point on the object that has the joint component.

The joint's anchor point on the second object (ie, the one which doesn't have the joint component).

The animation component is used to play back animations.

When turned on, Unity might stop animating if it thinks that the results of the animation won't be visible to the user.

When turned on, animations will be executed in the physics loop. This is only useful in conjunction with kinematic rigidbodies.

The default animation.

Controls culling of this Animation component.

Are we playing any animations?

AABB of this Animation animation component in local space.

Should the default animation clip (the [[Animation.clip]] property) automatically start playing on startup?

How should time beyond the playback range of the clip be treated?

Adds a /clip/ to the animation with name /newName/.

Adds /clip/ to the only play between /firstFrame/ and /lastFrame/. The new clip will also be added to the animation with name /newName/.

Should an extra frame be inserted at the end that matches the first frame? Turn this on if you are making a looping animation.

Adds /clip/ to the only play between /firstFrame/ and /lastFrame/. The new clip will also be added to the animation with name /newName/.

Should an extra frame be inserted at the end that matches the first frame? Turn this on if you are making a looping animation.

Blends the animation named /animation/ towards /targetWeight/ over the next /time/ seconds.

Fades the animation with name /animation/ in over a period of /time/ seconds and fades other animations out.

Cross fades an animation after previous animations has finished playing.

Get the number of clips currently assigned to this animation.

Is the animation named /name/ playing?

Plays an animation without any blending.

Plays an animation after previous animations has finished playing.

Remove clip from the animation list.

Rewinds the animation named /name/.

Rewinds all animations.

Samples animations at the current state.

Stops all playing animations that were started with this Animation.

Stops an animation named /name/.

Returns the animation state named /name/.

Used by [[Animation.Play]] function.

Animations will be added.

Animations will be blended.

Stores keyframe based animations.

Animation Events for this animation clip.

Frame rate at which keyframes are sampled. (RO)

Returns true if the animation contains curve that drives a humanoid rig.

Set to true if the AnimationClip will be used with the Legacy Animation component ( instead of the Animator ).

Animation length in seconds. (RO)

AABB of this Animation Clip in local space of Animation component that it is attached too.

Sets the default wrap mode used in the animation state.

Adds an animation event to the clip.

AnimationEvent to add.

Clears all curves from the clip.

Creates a new animation clip.

In order to insure better interpolation of quaternions, call this function after you are finished setting animation curves.

Samples an animation at a given time for any animated properties.

The animated game object. The time to sample an animation.

Assigns the curve to animate a specific property.

Path to the game object this curve applies to. /relativePath/ is formatted similar to a pathname, e.g. "root/spine/leftArm". If /relativePath/ is empty it refers to the game object the animation clip is attached to. The class type of the component that is animated. The name or path to the property being animated. The animation curve.

This class defines a pair of clips used by [[AnimatorOverrideController]].

The original clip from the controller.

The override animation clip.

This enum controlls culling of Animation component.

Animation culling is disabled - object is animated even when offscreen.

Animation is disabled when Animation::ref::localBounds are not visible.

Animation is disabled when renderers are not visible.

Animation is disabled when Animation::ref::localBounds are not visible.

A collection of curves form an [[AnimationClip]].

All keys defined in the animation curve.

The number of keys in the curve. (RO)

The behaviour of the animation after the last keyframe.

The behaviour of the animation before the first keyframe.

Add a new key to the curve.

Creates an animation curve from arbitrary number of keyframes.

Creates an empty animation curve.

An ease-in and out curve starting at /timeStart/, /valueStart/ and ending at /timeEnd/, /valueEnd/.

Evaluate the curve at /time/.

A straight Line starting at /timeStart/, /valueStart/ and ending at /timeEnd/, /valueEnd/.

Removes the keyframe at /index/ and inserts key.

Removes a key.

Smooth the in and out tangents of the keyframe at /index/.

Retrieves the key at index. (RO)

AnimationEvent lets you call a script function similar to SendMessage as part of playing back an animation.

The animation state that fired this event (RO).

The animator clip info related to this event (RO).

The animator state info related to this event (RO).

Float parameter that is stored in the event and will be sent to the function.

The name of the function that will be called.

Int parameter that is stored in the event and will be sent to the function.

Returns true if this Animation event has been fired by an Animator component.

Returns true if this Animation event has been fired by an Animation component.

Function call options.

Object reference parameter that is stored in the event and will be sent to the function.

String parameter that is stored in the event and will be sent to the function.

The time at which the event will be fired off.

Creates a new animation event.

The AnimationState gives full control over animation blending.

Which blend mode should be used?

The clip that is being played by this animation state.

Enables / disables the animation.

The length of the animation clip in seconds.

The name of the animation.

The normalized playback speed.

The normalized time of the animation.

The playback speed of the animation. 1 is normal playback speed.

The current time of the animation.

The weight of animation.

Wrapping mode of the animation.

Adds a transform which should be animated. This allows you to reduce the number of animations you have to create.

Removes a transform which should be animated.

Interface to control the Mecanim animation system.

Gets the avatar angular velocity for the last evaluated frame.

When turned on, animations will be executed in the physics loop. This is only useful in conjunction with kinematic rigidbodies.

Should root motion be applied?

Gets/Sets the current Avatar.

The position of the body center of mass.

The rotation of the body center of mass.

Controls culling of this Animator component.

Gets the avatar delta position for the last evaluated frame.

Gets the avatar delta rotation for the last evaluated frame.

Blends pivot point between body center of mass and feet pivot. At 0%, the blending point is body center of mass. At 100%, the blending point is feet pivot.

The current gravity weight based on current animations that are played.

Returns true if the current rig has root motion.

Returns true if the object has a transform hierarchy.

Returns the scale of the current Avatar for a humanoid rig, (1 by default if the rig is generic).

Returns true if the current rig is ''humanoid'', false if it is ''generic''.

If automatic matching is active.

Returns true if the current rig is optimizable with AnimatorUtility.OptimizeTransformHierarchy.

The AnimatorController layer count.

Additional layers affects the center of mass.

Get left foot bottom height.

When linearVelocityBlending is set to true, the root motion velocity and angular velocity will be blended linearly.

Read only acces to the AnimatorControllerParameters used by the animator.

Get the current position of the pivot.

Gets the pivot weight.

Sets the playback position in the recording buffer.

Gets the mode of the Animator recorder.

Start time of the first frame of the buffer relative to the frame at which ::ref::StartRecording was called.

End time of the recorded clip relative to when ::ref::StartRecording was called.

Get right foot bottom height.

The root position, the position of the game object.

The root rotation, the rotation of the game object.

The runtime representation of AnimatorController that controls the Animator.

The playback speed of the Animator. 1 is normal playback speed.

Automatic stabilization of feet during transition and blending.

Returns the position of the target specified by SetTarget(AvatarTarget targetIndex, float targetNormalizedTime)).

Returns the rotation of the target specified by SetTarget(AvatarTarget targetIndex, float targetNormalizedTime)).

Specifies the update mode of the Animator.

Gets the avatar velocity for the last evaluated frame.

Apply the default Root Motion.

Creates a dynamic transition between the current state and the destination state.

The name of the destination state. The duration of the transition. Value is in source state normalized time. Start time of the current destination state. Value is in source state normalized time, should be between 0 and 1. If no explicit normalizedTime is specified or normalizedTime value is float.NegativeInfinity, the state will either be played from the start if it's not already playing, or will continue playing from its current time and no transition will happen. Layer index containing the destination state. If no layer is specified or layer is -1, the first state that is found with the given name or hash will be played. State hash of the destination state. Passing 0 will transition to self.

Creates a dynamic transition between the current state and the destination state.

Same as [[Animator.CrossFade]], but the duration and offset in the target state are in fixed time.

The name of the destination state. The duration of the transition. Value is in seconds. Start time of the current destination state. Value is in seconds. If no explicit fixedTime is specified or fixedTime value is float.NegativeInfinity, the state will either be played from the start if it's not already playing, or will continue playing from its current time and no transition will happen. Layer index containing the destination state. If no layer is specified or layer is -1, the first state that is found with the given name or hash will be played. State hash of the destination state. Passing 0 will transition to self.

Same as [[Animator.CrossFade]], but the duration and offset in the target state are in fixed time.

Gets the Transition information on a specified AnimatorController layer.

The layer's index.

Return the first StateMachineBehaviour that match type /T/ or derived from /T/. Return null if none are found.

Returns all StateMachineBehaviour that match type /T/ or are derived from /T/. Returns null if none are found.

Returns transform mapped to this human bone id.

The human bone that is queried, see enum HumanBodyBones for a list of possible values.

Gets the value of a bool parameter.

The name of the parameter.

Gets the value of a bool parameter.

The id of the parameter. The id is generated using Animator::StringToHash.

Gets the list of AnimatorClipInfo currently played by the current state.

The layer's index.

Gets the current State information on a specified AnimatorController layer.

The layer's index.

Gets the value of a float parameter.

The name of the parameter.

Gets the value of a float parameter.

The id of the parameter. The id is generated using Animator::StringToHash.

Gets the position of an IK hint.

The AvatarIKHint that is queried. Return the current position of this IK hint in world space.

Gets the translative weight of an IK Hint (0 = at the original animation before IK, 1 = at the hint).

The AvatarIKHint that is queried. Return translative weight.

Gets the position of an IK goal.

The AvatarIKGoal that is queried. Return the current position of this IK goal in world space.

Gets the translative weight of an IK goal (0 = at the original animation before IK, 1 = at the goal).

The AvatarIKGoal that is queried.

Gets the rotation of an IK goal.

The AvatarIKGoal that is is queried.

Gets the rotational weight of an IK goal (0 = rotation before IK, 1 = rotation at the IK goal).

The AvatarIKGoal that is queried.

Gets the value of an integer parameter.

The name of the parameter.

Gets the value of an integer parameter.

The id of the parameter. The id is generated using Animator::StringToHash.

Gets the index of the layer with specified name.

The layer's name.

Gets name of the layer.

The layer's index.

Gets the layer's current weight.

The layer's index.

Gets the list of AnimatorClipInfo currently played by the next state. Only valid during a transition.

The layer's index.

Gets the next State information on a specified AnimatorController layer.

The layer's index.

Gets the value of a quaternion parameter.

The name of the parameter.

Gets the value of a quaternion parameter.

The id of the parameter. The id is generated using Animator::StringToHash.

Gets the value of a vector parameter.

The name of the parameter.

Gets the value of a vector parameter.

The id of the parameter. The id is generated using Animator::StringToHash.

Returns true if the AnimatorState is present in the Animator's controller.

The layer's index. The AnimatorState fullPathHash, nameHash or shortNameHash. The State is found.

Interrupts the automatic target matching.

Returns true if the transform is controlled by the Animator\.

The transform that is queried.

Is the specified AnimatorController layer in a transition.

The layer's index.

Returns true if a parameter is controlled by an additional curve on an animation.

The name of the parameter.

Returns true if a parameter is controlled by an additional curve on an animation.

The id of the parameter. The id is generated using Animator::StringToHash.

Automatically adjust the gameobject position and rotation so that the AvatarTarget reaches the matchPosition when the current state is at the specified progress.

The position we want the body part to reach. The rotation in which we want the body part to be. The body part that is involved in the match. Structure that contains weights for matching position and rotation. Start time within the animation clip (0 - beginning of clip, 1 - end of clip). End time within the animation clip (0 - beginning of clip, 1 - end of clip), values greater than 1 can be set to trigger a match after a certain number of loops. Ex: 2.3 means at 30% of 2nd loop.

Plays a state.

The name of the state the will be played. The layer where the state is. If no layer is specified or layer is -1, the first state that is found with the given name or hash will be played. The normalized time at which the state will play. If no explicit normalizedTime is specified or normalizedTime value is float.NegativeInfinity, the state will either be played from the start if it's not already playing, or will continue playing from its current time. The hash of the state. Passing zero will play the current state.

Plays a state.

Same as [[Animator.CrossFade]], but the duration and offset in the target state are in fixed time.

The name of the destination state. Start time of the current destination state. Value is in seconds. If no explicit fixedTime is specified or fixedTime value is float.NegativeInfinity, the state will either be played from the start if it's not already playing, or will continue playing from its current time and no transition will happen. Layer index containing the destination state. If no layer is specified or layer is -1, the first state that is found with the given name or hash will be played. State hash of the destination state. Passing 0 will transition to self.

Same as [[Animator.CrossFade]], but the duration and offset in the target state are in fixed time.

Rebind all the animated properties and mesh data with the Animator.

Resets the trigger parameter to false.

The name of the parameter.

Resets the trigger parameter to false.

The id of the parameter. The id is generated using Animator::StringToHash.

Sets the value of a bool parameter.

The name of the parameter. The new value for the parameter.

Sets the value of a bool parameter.

The id of the parameter. The id is generated using Animator::StringToHash. The new value for the parameter.

Sets the value of a float parameter.

The name of the parameter. The new value for the parameter.

Sets the value of a float parameter.

The name of the parameter. The new value for the parameter. The time allowed to parameter to reach the value. The current frame deltaTime.

Sets the value of a float parameter.

The id of the parameter. The id is generated using Animator::StringToHash. The new value for the parameter.

Sets the value of a float parameter.

The id of the parameter. The id is generated using Animator::StringToHash. The new value for the parameter. The time allowed to parameter to reach the value. The current frame deltaTime.

Sets the position of an IK hint.

The AvatarIKHint that is set. The position in world space.

Sets the translative weight of an IK hint (0 = at the original animation before IK, 1 = at the hint).

The AvatarIKHint that is set. The translative weight.

Sets the position of an IK goal.

The AvatarIKGoal that is set. The position in world space.

Sets the translative weight of an IK goal (0 = at the original animation before IK, 1 = at the goal).

The AvatarIKGoal that is set. The translative weight.

Sets the rotation of an IK goal.

The AvatarIKGoal that is set. The rotation in world space.

Sets the rotational weight of an IK goal (0 = rotation before IK, 1 = rotation at the IK goal).

The AvatarIKGoal that is set. The rotational weight.

Sets the value of an integer parameter.

The name of the parameter. The new value for the parameter.

Sets the value of an integer parameter.

The id of the parameter. The id is generated using Animator::StringToHash. The new value for the parameter.

Sets the layer's current weight.

The layer's index. The weight of the layer.

Sets the look at position.

The position to lookAt.

Set look at weights.

(0-1) the global weight of the LookAt, multiplier for other parameters. (0-1) determines how much the body is involved in the LookAt. (0-1) determines how much the head is involved in the LookAt. (0-1) determines how much the eyes are involved in the LookAt. (0-1) 0.0 means the character is completely unrestrained in motion, 1.0 means he's completely clamped (look at becomes impossible), and 0.5 means he'll be able to move on half of the possible range (180 degrees).

Set look at weights.

Sets the value of a quaternion parameter.

The name of the parameter. The new value for the parameter.

Sets the value of a quaternion parameter.

Of the parameter. The id is generated using Animator::StringToHash. The new value for the parameter.

Sets an AvatarTarget and a targetNormalizedTime for the current state.

The avatar body part that is queried. The current state Time that is queried.

Sets a trigger parameter to active.

The name of the parameter.

Sets a trigger parameter to active.

The id of the parameter. The id is generated using Animator::StringToHash.

Sets the value of a vector parameter.

The name of the parameter. The new value for the parameter.

Sets the value of a vector parameter.

The id of the parameter. The id is generated using Animator::StringToHash. The new value for the parameter.

Sets the animator in playback mode.

Sets the animator in recording mode, and allocates a circular buffer of size ''frameCount''.

The number of frames (updates) that will be recorded. If frameCount is 0, the recording will continue until the user calls ::ref::StopRecording. The maximum value for frameCount is 10000.

Stops the animator playback mode. When playback stops, the avatar resumes getting control from game logic.

Stops animator record mode.

Generates an parameter id from a string.

The string to convert to Id.

Evaluates the animator based on deltaTime.

The time delta.

Information about clip been played and blended by the Animator.

Returns the animation clip played by the Animator.

Returns the blending weight used by the Animator to blend this clip.

Used to communicate between scripting and the controller. Some parameters can be set in scripting and used by the controller, while other parameters are based on Custom Curves in Animation Clips and can be sampled using the scripting API.

The default bool value for the parameter.

The name of the parameter.

Returns the hash of the parameter based on its name.

The type of the parameter.

Boolean type parameter.

Float type parameter.

Int type parameter.

Trigger type parameter.

Culling mode for the Animator.

Always animate the entire character. Object is animated even when offscreen.

Animation is completely disabled when renderers are not visible.

Retarget, IK and write of Transforms are disabled when renderers are not visible.

Interface to control AnimatorOverrideController.

Returns the list of orignal clip from the controller and their override clip.

The Controller that the AnimatorOverrideController overrides.

Returns either the overriding clip if set or the original clip named name.

The mode of the Animator's recorder.

The Animator recorder is offline.

The Animator recorder is in Playback.

The Animator recorder is in Record.

Information about the current or next state.

The full path hash for this state.

Current duration of the state.

Is the state looping.

The hashed name of the State.

Normalized time of the State.

The hash is generated using Animator::StringToHash. The string to pass doest not include the parent layer's name.

The Tag of the State.

Does /name/ match the name of the active state in the statemachine?

Does /tag/ match the tag of the active state in the statemachine.

Information about the current transition.

Returns true if the transition is from an AnyState node, or from Animator.CrossFade().

The unique name of the Transition.

The simplified name of the Transition.

Normalized time of the Transition.

The user-specidied name of the Transition.

Does /name/ match the name of the active Transition.

Does /userName/ match the name of the active Transition.

The update mode of the Animator.

Updates the animator during the physic loop in order to have the animation system synchronized with the physics engine.

Normal update of the animator.

Animator updates independently of Time.timeScale.

Various utilities for animator manipulation.

This function will recreate all transform hierarchy under GameObject.

GameObject to Deoptimize.

This function will remove all transform hierarchy under GameObject, the animator will write directly transform matrices into the skin mesh matrices saving alot of CPU cycles.

GameObject to Optimize. List of transform name to expose.

Anisotropic filtering mode.

Disable anisotropic filtering for all textures.

Enable anisotropic filtering, as set for each texture.

Enable anisotropic filtering for all textures.

Access to application run-time data.

The absolute path to the web player data file (RO).

Priority of background loading thread.

Returns application bundle identifier at runtime.

A unique cloud project identifier. It is unique for every project (Read Only).

Return application company name (Read Only).

Contains the path to the game data folder (RO).

Returns false if application is altered in any way after it was built.

Returns true if application integrity can be confirmed.

Returns application install mode (Read Only).

Returns the type of Internet reachability currently possible on the device.

Is the current Runtime platform a known console platform.

Are we running inside the Unity editor? (RO)

Is some level being loaded? (RO)

Is the current Runtime platform a known mobile platform.

Returns true when in any kind of player (RO).

Are we running inside a web player? (RO)

The total number of levels available (RO).

The level index that was last loaded (RO).

The name of the level that was last loaded (RO).

Event that is fired if a log message is received.

Contains the path to a persistent data directory (RO).

Returns the platform the game is running (RO).

Returns application product name (Read Only).

Should the player be running when the application is in the background?

Returns application running in sandbox (Read Only).

The path to the web player data file relative to the html file (RO).

How many bytes have we downloaded from the main unity web stream (RO).

Contains the path to the StreamingAssets folder (RO).

The language the user's operating system is running in.

Instructs game to try to render at a specified frame rate.

Contains the path to a temporary data / cache directory (RO).

The version of the Unity runtime used to play the content.

Returns application version number (Read Only).

Indicates whether Unity's webplayer security model is enabled.

Cancels quitting the application. This is useful for showing a splash screen at the end of a game.

Can the streamed level be loaded?

Captures a screenshot at path /filename/ as a PNG file.

Pathname to save the screenshot file to. Factor by which to increase resolution.

Captures a screenshot at path /filename/ as a PNG file.

Pathname to save the screenshot file to. Factor by which to increase resolution.

Calls a function in the containing web page __(Web Player only)__.

Evaluates script snippet in the containing web page __(Web Player only)__.

How far has the download progressed? [0...1].

Is Unity activated with the Pro license?

Check if the user has authorized use of the webcam or microphone in the Web Player.

Loads the level by its name or index.

The level to load. The name of the level to load.

Loads the level by its name or index.

The level to load. The name of the level to load.

Loads a level additively.

Loads the level additively and asynchronously in the background.

Loads the level asynchronously in the background.

Use this delegate type with [[Application.logMessageReceived]] or [[Application.logMessageReceivedThreaded]] to monitor what gets logged.

Opens the /url/ in a browser.

Quits the player application.

Request authorization to use the webcam or microphone in the Web Player.

Application installation mode (Read Only).

Application installed via ad hoc distribution.

Application installed via developer build.

Application running in editor.

Application installed via enterprise distribution.

Application installed via online store.

Application install mode unknown.

Application sandbox type.

Application not running in a sandbox.

Application is running in broken sandbox.

Application is running in a sandbox.

Application sandbox type is unknown.

Applies forces within an area.

The angular drag to apply to rigid-bodies.

The linear drag to apply to rigid-bodies.

The angle of the force to be applied.

The magnitude of the force to be applied.

The target for where the effector applies any force.

The variation of the magnitude of the force to be applied.

Should the /forceAngle/ use global space?

Assembly level attribute. Any classes in an assembly with this attribute will be considered to be Editor Classes.

Constructor.

The Assert class contains assertion methods for setting invariants in the code.

Should an exception be thrown on a failure.

Asserts that the values are approximately equal. An absolute error check is used for approximate equality check (|a-b| < tolerance). Default tolerance is 0.00001f. Note: Every time you call the method with tolerance specified, a new instance of [[Assertions.Comparers.FloatComparer]] is created. For performance reasons you might want to instance your own comparer and pass it to the AreEqual method. If the tolerance is not specifies, a default comparer is used and the issue does not occur.

Tolerance of approximation.

Asserts that the values are equal. If no comparer is specified, EqualityComparer<T>.Default is used.

Asserts that the values are approximately not equal. An absolute error check is used for approximate equality check (|a-b| < tolerance). Default tolerance is 0.00001f.

Tolerance of approximation.

Asserts that the values are approximately not equal. An absolute error check is used for approximate equality check (|a-b| < tolerance). Default tolerance is 0.00001f.

Tolerance of approximation.

Asserts that the values are approximately not equal. An absolute error check is used for approximate equality check (|a-b| < tolerance). Default tolerance is 0.00001f.

Tolerance of approximation.

Asserts that the values are approximately not equal. An absolute error check is used for approximate equality check (|a-b| < tolerance). Default tolerance is 0.00001f.

Tolerance of approximation.

Asserts that the values are not equal.

Asserts that the condition is false.

Asserts that the value is not null.

Asserts that the value is null.

Asserts that the condition is true.

An exception that is thrown on a failure. [[Assertions.Assert._raiseExceptions]] needs to be set to true.

A float comparer used by [[Assertions.Assert]] performing approximate comparison.

Default epsilon used by the comparer.

Default instance of a comparer class with deafult error epsilon and absolute error check.

Performs equality check with absolute error check.

Expected value. Actual value. Comparison error. Result of the comparison.

Performs equality check with relative error check.

Expected value. Actual value. Comparison error. Result of the comparison.

Creates an instance of the comparer.

Should use relative check when comparing values. By default, and absolute check will be used. Allowed comparison error. By default, the [[FloatComparer.kEpsilon]] is used.

Creates an instance of the comparer.

Should use relative check when comparing values. By default, and absolute check will be used. Allowed comparison error. By default, the [[FloatComparer.kEpsilon]] is used.

Creates an instance of the comparer.

Should use relative check when comparing values. By default, and absolute check will be used. Allowed comparison error. By default, the [[FloatComparer.kEpsilon]] is used.

Creates an instance of the comparer.

Should use relative check when comparing values. By default, and absolute check will be used. Allowed comparison error. By default, the [[FloatComparer.kEpsilon]] is used.

An extension class that serves as a wrapper for the Assert class.

An extension method for [[Assertions.Assert.AreApproximatelyEqual]].

An extension method for [[Assertions.Assert.AreEqual]].

An extension method for [[Assertions.Assert.IsFalse]].

An extension method for [[Assertions.Assert.IsNull]].

An extension method for [[Assertions.Assert.IsTrue]].

An extension method for [[Assertions.Assert.AreNotApproximatelyEqual]].

An extension method for [[Assertions.Assert.AreNotEqual]].

An extension method for [[Assertions.Assert.AreNotNull]].

AssetBundles let you stream additional assets via the WWW class and instantiate them at runtime. AssetBundles are created via BuildPipeline.BuildAssetBundle.

Main asset that was supplied when building the asset bundle (RO).

Check if an AssetBundle contains a specific object.

Loads an asset bundle from a disk.

Path of the file on disk SA: [[WWW.assetBundle]], [[WWW.LoadFromCacheOrDownload]].

Asynchronously create an AssetBundle from a memory region.

Synchronously create an AssetBundle from a memory region.

Array of bytes with the AssetBundle data.

Return all asset names in the AssetBundle.

Return all the scene asset paths (paths to *.unity assets) in the AssetBundle.

Loads all assets contained in the asset bundle that inherit from /type/.

Loads all assets contained in the asset bundle.

Loads all assets contained in the asset bundle that inherit from type /T/.

Loads all assets contained in the asset bundle asynchronously.

Loads all assets contained in the asset bundle that inherit from /T/ asynchronously.

Loads all assets contained in the asset bundle that inherit from /type/ asynchronously.

Loads asset with /name/ from the bundle.

Loads asset with /name/ of a given /type/ from the bundle.

Loads asset with /name/ of type /T/ from the bundle.

Asynchronously loads asset with /name/ from the bundle.

Asynchronously loads asset with /name/ of a given /T/ from the bundle.

Asynchronously loads asset with /name/ of a given /type/ from the bundle.

Loads asset and sub assets with /name/ from the bundle.

Loads asset and sub assets with /name/ of a given /type/ from the bundle.

Loads asset and sub assets with /name/ of type /T/ from the bundle.

Loads asset with sub assets with /name/ from the bundle asynchronously.

Loads asset with sub assets with /name/ of type /T/ from the bundle asynchronously.

Loads asset with sub assets with /name/ of a given /type/ from the bundle asynchronously.

Unloads all assets in the bundle.

Asynchronous create request for an [[AssetBundle]].

Asset object being loaded (RO).

Manifest for all the assetBundle in the build.

Get all the AssetBundles in the manifest.

An array of asset bundle names.

Get all the AssetBundles with variant in the manifest.

An array of asset bundle names.

Get all the dependent AssetBundles for the given AssetBundle.

Name of the asset bundle.

Get the hash for the given AssetBundle.

Name of the asset bundle. The 128-bit hash for the asset bundle.

Get the direct dependent AssetBundles for the given AssetBundle.

Name of the asset bundle. Array of asset bundle names this asset bundle depends on.

Asynchronous load request from an [[AssetBundle]].

Asset objects with sub assets being loaded. (RO)

Asset object being loaded (RO).

Asynchronous operation coroutine.

Allow scenes to be activated as soon as it is ready.

Has the operation finished? (RO)

Priority lets you tweak in which order async operation calls will be performed.

What's the operation's progress. (RO)

AudioMixer asset.

Routing target.

Resets an exposed parameter to its initial value.

Exposed parameter. Returns false if the parameter was not found or could not be set.

Connected groups in the mixer form a path from the mixer's master group to the leaves. This path has the format "Master Group/Child of Master Group/Grandchild of Master Group", so to find the grandchild group in this example, a valid search string would be for instance "randchi" which would return exactly one group while "hild" or "oup/" would return 2 different groups.

Sub-string of the paths to be matched. Groups in the mixer whose paths match the specified search path.

The name must be an exact match.

Name of snapshot object to be returned. The snapshot identified by the name.

Returns the value of the exposed parameter specified. If the parameter doesn't exist the function returns false. Prior to calling SetFloat and after ClearFloat has been called on this parameter the value returned will be that of the current snapshot or snapshot transition.

Name of exposed parameter. Return value of exposed parameter. Returns false if the exposed parameter specified doesn't exist.

Sets the value of the exposed parameter specified. When a parameter is exposed, it is not controlled by mixer snapshots and can therefore only be changed via this function.

Name of exposed parameter. New value of exposed parameter. Returns false if the exposed parameter was not found or snapshots are currently being edited.

Transitions to a weighted mixture of the snapshots specified. This can be used for games that specify the game state as a continuum between states or for interpolating snapshots from a triangulated map location.

The set of snapshots to be mixed. The mix weights for the snapshots specified. Relative time after which the mixture should be reached from any current state.

Object representing a group in the mixer.

Object representing a snapshot in the mixer.

Performs an interpolated transition towards this snapshot over the time interval specified.

Relative time after which this snapshot should be reached from any current state.

The Audio Chorus Filter takes an Audio Clip and processes it creating a chorus effect.

Chorus delay in ms. 0.1 to 100.0. Default = 40.0 ms.

Chorus modulation depth. 0.0 to 1.0. Default = 0.03.

Volume of original signal to pass to output. 0.0 to 1.0. Default = 0.5.

Chorus feedback. Controls how much of the wet signal gets fed back into the chorus buffer. 0.0 to 1.0. Default = 0.0.

Chorus modulation rate in hz. 0.0 to 20.0. Default = 0.8 hz.

Volume of 1st chorus tap. 0.0 to 1.0. Default = 0.5.

Volume of 2nd chorus tap. This tap is 90 degrees out of phase of the first tap. 0.0 to 1.0. Default = 0.5.

Volume of 3rd chorus tap. This tap is 90 degrees out of phase of the second tap. 0.0 to 1.0. Default = 0.5.

A container for audio data.

The number of channels in the audio clip. (RO)

The sample frequency of the clip in Hertz. (RO)

Returns true if the AudioClip is ready to play (read-only).

The length of the audio clip in seconds. (RO)

Corresponding to the "Load In Background" flag in the inspector, when this flag is set, the loading will happen delayed without blocking the main thread.

Returns the current load state of the audio data associated with an AudioClip.

The load type of the clip (read-only).

Preloads audio data of the clip when the clip asset is loaded. When this flag is off, scripts have to call AudioClip.LoadAudioData() to load the data before the clip can be played. Properties like length, channels and format are available before the audio data has been loaded.

The length of the audio clip in samples. (RO)

Creates a user AudioClip with a name and with the given length in samples, channels and frequency.

Name of clip. Number of sample frames. Number of channels per frame. Sample frequency of clip. Audio clip is played back in 3D. True if clip is streamed, that is if the pcmreadercallback generates data on the fly. This callback is invoked to generate a block of sample data. Non-streamed clips call this only once at creation time while streamed clips call this continuously. This callback is invoked whenever the clip loops or changes playback position. A reference to the created AudioClip.

Creates a user AudioClip with a name and with the given length in samples, channels and frequency.

Fills an array with sample data from the clip.

Loads the audio data of a clip. Clips that have "Preload Audio Data" set will load the audio data automatically.

Returns true if loading succeeded.

Delegate called each time [[AudioClip]] reads data.

Array of floats containing data read from the clip.

Delegate called each time [[AudioClip]] changes read position.

New position in the audio clip.

Set sample data in a clip.

Unloads the audio data associated with the clip. This works only for AudioClips that are based on actual sound file assets.

Returns false if unloading failed.

Determines how the audio clip is loaded in.

The audio data of the clip will be kept in memory in compressed form.

The audio data is decompressed when the audio clip is loaded.

Streams audio data from disk.

An enum containing different compression types.

AAC Audio Compression.

Adaptive differential pulse-code modulation.

Sony proprietory hardware codec.

MPEG Audio Layer III.

Uncompressed pulse-code modulation.

Sony proprietary hardware format.

Vorbis compression format.

Xbox One proprietary hardware format.

Specifies the current properties or desired properties to be set for the audio system.

The length of the DSP buffer in samples determining the latency of sounds by the audio output device.

The current maximum number of simultaneously audible sounds in the game.

The maximum number of managed sounds in the game. Beyond this limit sounds will simply stop playing.

The current sample rate of the audio output device used.

The current speaker mode used by the audio output device.

Value describing the current load state of the audio data associated with an AudioClip.

Value returned by AudioClip.loadState for an AudioClip that has failed loading its audio data.

Value returned by AudioClip.loadState for an AudioClip that has succeeded loading its audio data.

Value returned by AudioClip.loadState for an AudioClip that is currently loading audio data.

Value returned by AudioClip.loadState for an AudioClip that has no audio data loaded and where loading has not been initiated yet.

The Audio Distortion Filter distorts the sound from an AudioSource or.

Distortion value. 0.0 to 1.0. Default = 0.5.

The Audio Echo Filter repeats a sound after a given Delay, attenuating.

Echo decay per delay. 0 to 1. 1.0 = No decay, 0.0 = total decay (i.e. simple 1 line delay). Default = 0.5.

Echo delay in ms. 10 to 5000. Default = 500.

Volume of original signal to pass to output. 0.0 to 1.0. Default = 1.0.

Volume of echo signal to pass to output. 0.0 to 1.0. Default = 1.0.

The Audio High Pass Filter passes high frequencies of an AudioSource and.

Highpass cutoff frequency in hz. 10.0 to 22000.0. Default = 5000.0.

Determines how much the filter's self-resonance isdampened.

Representation of a listener in 3D space.

The paused state of the audio system.

This lets you set whether the Audio Listener should be updated in the fixed or dynamic update.

Controls the game sound volume (0.0 to 1.0).

Returns a block of the listener (master)'s output data.

Returns a block of the listener (master)'s spectrum data.

The Audio Low Pass Filter filter passes low frequencies of an.

Lowpass cutoff frequency in hz. 10.0 to 22000.0. Default = 5000.0.

Determines how much the filter's self-resonance is dampened.

The Audio Reverb Filter takes an Audio Clip and distortionates it in a.

Decay HF Ratio : High-frequency to low-frequency decay time ratio. Ranges from 0.1 to 2.0. Default is 0.5.

Reverberation decay time at low-frequencies in seconds. Ranges from 0.1 to 20.0. Default is 1.0.

Reverberation density (modal density) in percent. Ranges from 0.0 to 100.0. Default is 100.0.

Reverberation diffusion (echo density) in percent. Ranges from 0.0 to 100.0. Default is 100.0.

Mix level of dry signal in output in mB. Ranges from -10000.0 to 0.0. Default is 0.

Reference high frequency in Hz. Ranges from 20.0 to 20000.0. Default is 5000.0.

Reference low-frequency in Hz. Ranges from 20.0 to 1000.0. Default is 250.0.

Late reverberation level relative to room effect in mB. Ranges from -10000.0 to 2000.0. Default is 0.0.

Early reflections level relative to room effect in mB. Ranges from -10000.0 to 1000.0. Default is -10000.0.

Late reverberation delay time relative to first reflection in seconds. Ranges from 0.0 to 0.1. Default is 0.04.

Late reverberation level relative to room effect in mB. Ranges from -10000.0 to 2000.0. Default is 0.0.

Set/Get reverb preset properties.

Room effect level at low frequencies in mB. Ranges from -10000.0 to 0.0. Default is 0.0.

Room effect high-frequency level re. low frequency level in mB. Ranges from -10000.0 to 0.0. Default is 0.0.

Room effect low-frequency level in mB. Ranges from -10000.0 to 0.0. Default is 0.0.

Rolloff factor for room effect. Ranges from 0.0 to 10.0. Default is 10.0.

Reverb presets used by the Reverb Zone class and the audio reverb filter.

Alley preset.

Arena preset.

Auditorium preset.

Bathroom preset.

Carpeted hallway preset.

Cave preset.

City preset.

Concert hall preset.

Dizzy preset.

Drugged preset.

Forest preset.

Generic preset.

Hallway preset.

Hangar preset.

Livingroom preset.

Mountains preset.

No reverb preset selected.

Padded cell preset.

Parking Lot preset.

Plain preset.

Psychotic preset.

Quarry preset.

Room preset.

Sewer pipe preset.

Stone corridor preset.

Stoneroom preset.

Underwater presset.

User defined preset.

Reverb Zones are used when you want to create location based ambient effects in the scene.

High-frequency to mid-frequency decay time ratio.

Reverberation decay time at mid frequencies.

Value that controls the modal density in the late reverberation decay.

Value that controls the echo density in the late reverberation decay.

The distance from the centerpoint that the reverb will not have any effect. Default = 15.0.

The distance from the centerpoint that the reverb will have full effect at. Default = 10.0.

Early reflections level relative to room effect.

Initial reflection delay time.

Late reverberation level relative to room effect.

Late reverberation delay time relative to initial reflection.

Set/Get reverb preset properties.

Room effect level (at mid frequencies).

Relative room effect level at high frequencies.

Relative room effect level at low frequencies.

Like rolloffscale in global settings, but for reverb room size effect.

Reference high frequency (hz).

Reference low frequency (hz).

Rolloff modes that a 3D sound can have in an audio source.

Use this when you want to use a custom rolloff.

Use this mode when you want to lower the volume of your sound over the distance.

Use this mode when you want a real-world rolloff.

Controls the global audio settings from script.

Returns the speaker mode capability of the current audio driver. (RO)

Returns the current time of the audio system.

Get the mixer's current output rate.

Gets the current speaker mode. Default is 2 channel stereo.

A delegate called whenever the global audio settings are changed, either by [[AudioSettings.Reset]] or by an external device change such as the OS control panel changing the sample rate or because the default output device was changed, for example when plugging in an HDMI monitor or a USB headset.

True if the change was caused by an device change.

Returns the current configuration of the audio device and system. The values in the struct may then be modified and reapplied via [[AudioSettings.Reset]].

The new configuration to be applied.

Get the mixer's buffer size in samples.

Is the length of each buffer in the ringbuffer. Is number of buffers.

A delegate called whenever the global audio settings are changed, either by [[AudioSettings.Reset]] or by an external factor such as the OS control panel changing the sample rate or because the default output device was changed, for example when plugging in an HDMI monitor or a USB headset.

True if the change was caused by an device change.

Performs a change of the device configuration. In response to this the [[AudioSettings.OnAudioConfigurationChanged]] delegate is invoked with the argument deviceWasChanged=false. It cannot be guaranteed that the exact settings specified can be used, but the an attempt is made to use the closest match supported by the system.

The new configuration to be used. True if all settings could be successfully applied.

A representation of audio sources in 3D.

Bypass effects (Applied from filter components or global listener filters).

When set global effects on the AudioListener will not be applied to the audio signal generated by the AudioSource. Does not apply if the AudioSource is playing into a mixer group.

When set doesn't route the signal from an AudioSource into the global reverb associated with reverb zones.

The default [[AudioClip]] to play.

Sets the Doppler scale for this AudioSource.

Allows AudioSource to play even though AudioListener.pause is set to true. This is useful for the menu element sounds or background music in pause menus.

This makes the audio source not take into account the volume of the audio listener.

Is the ::ref::clip playing right now (RO)?

Is the audio clip looping?

(Logarithmic rolloff) MaxDistance is the distance a sound stops attenuating at.

Within the Min distance the AudioSource will cease to grow louder in volume.

Un- / Mutes the AudioSource. Mute sets the volume=0, Un-Mute restore the original volume.

The target group to which the AudioSource should route its signal.

Pans a playing sound in a stereo way (left or right). This only applies to sounds that are Mono or Stereo.

The pitch of the audio source.

If set to true, the audio source will automatically start playing on awake.

Sets the priority of the [[AudioSource]].

The amount by which the signal from the AudioSource will be mixed into the global reverb associated with the Reverb Zones.

Sets/Gets how the AudioSource attenuates over distance.

Sets how much this AudioSource is affected by 3D spatialisation calculations (attenuation, doppler etc). 0.0 makes the sound full 2D, 1.0 makes it full 3D.

Sets the spread angle (in degrees) of a 3d stereo or multichannel sound in speaker space.

Playback position in seconds.

Playback position in PCM samples.

Whether the Audio Source should be updated in the fixed or dynamic update.

The volume of the audio source (0.0 to 1.0).

Returns a block of the currently playing source's output data.

Returns a block of the currently playing source's spectrum data.

Pauses playing the ::ref::clip.

Plays the ::ref::clip with an optional certain delay.

Delay in number of samples, assuming a 44100Hz sample rate (meaning that Play(44100) will delay the playing by exactly 1 sec).

Plays the ::ref::clip with an optional certain delay.

Delay in number of samples, assuming a 44100Hz sample rate (meaning that Play(44100) will delay the playing by exactly 1 sec).

Plays an AudioClip at a given position in world space.

Audio data to play. Position in world space from which sound originates. Playback volume.

Plays an AudioClip at a given position in world space.

Audio data to play. Position in world space from which sound originates. Playback volume.

Plays the ::ref::clip with a delay specified in seconds. Users are advised to use this function instead of the old Play(delay) function that took a delay specified in samples relative to a reference rate of 44.1 kHz as an argument.

Delay time specified in seconds.

Plays an [[AudioClip]], and scales the [[AudioSource]] volume by volumeScale.

The clip being played. The scale of the volume (0-1).

Plays an [[AudioClip]], and scales the [[AudioSource]] volume by volumeScale.

The clip being played. The scale of the volume (0-1).

Plays the ::ref::clip at a specific time on the absolute time-line that AudioSettings.dspTime reads from.

Time in seconds on the absolute time-line that AudioSettings.dspTime refers to for when the sound should start playing.

Changes the time at which a sound that has already been scheduled to play will end. Notice that depending on the timing not all rescheduling requests can be fulfilled.

Time in seconds.

Changes the time at which a sound that has already been scheduled to play will start.

Time in seconds.

Stops playing the ::ref::clip.

Unpause the paused playback of this AudioSource.

These are speaker types defined for use with [[AudioSettings.speakerMode]].

Channel count is set to 6. 5.1 speaker setup. This includes front left, front right, center, rear left, rear right and a subwoofer.

Channel count is set to 8. 7.1 speaker setup. This includes front left, front right, center, rear left, rear right, side left, side right and a subwoofer.

Channel count is set to 1. The speakers are monaural.

Channel count is set to 2. Stereo output, but data is encoded in a way that is picked up by a Prologic/Prologic2 decoder and split into a 5.1 speaker setup.

Channel count is set to 4. 4 speaker setup. This includes front left, front right, rear left, rear right.

Channel count is unaffected.

Channel count is set to 2. The speakers are stereo. This is the editor default.

Channel count is set to 5. 5 speaker setup. This includes front left, front right, center, rear left, rear right.

Type of the imported(native) data.

Acc - not supported.

Aiff.

iPhone hardware decoder, supports AAC, ALAC and MP3. Extracodecdata is a pointer to an FMOD_AUDIOQUEUE_EXTRACODECDATA structure.

Impulse tracker.

Protracker / Fasttracker MOD.

MP2/MP3 MPEG.

Ogg vorbis.

ScreamTracker 3.

3rd party / unknown plugin format.

VAG.

Microsoft WAV.

FastTracker 2 XM.

Xbox360 XMA.

Describes when an [[AudioSource]] or [[AudioListener]] is updated.

Updates the source or listener in the fixed update loop if it is attached to a [[Rigidbody]], dynamic otherwise.

Updates the source or listener in the dynamic update loop.

Updates the source or listener in the fixed update loop.

Avatar definition.

Return true if this avatar is a valid human avatar.

Return true if this avatar is a valid mecanim avatar. It can be a generic avatar or a human avatar.

Class to build avatars from user scripts.

Create a new generic avatar.

Root object of your transform hierarchy. Transform name of the root motion transform. If empty no root motion is defined and you must take care of avatar movement yourself.

Create a humanoid avatar.

Root object of your transform hierachy. Description of the avatar.

IK Goal.

The left foot.

The left hand.

The right foot.

The right hand.

IK Hint.

The left elbow IK hint.

The left knee IK hint.

The right elbow IK hint.

The right knee IK hint.

Target.

The body, center of mass.

The left foot.

The left hand.

The right foot.

The right hand.

The root, the position of the game object.

Behaviours are Components that can be enabled or disabled.

Enabled Behaviours are Updated, disabled Behaviours are not.

Has the Behaviour had enabled called.

BillboardAsset describes how a billboard is rendered.

Height of the billboard that is below ground.

Height of the billboard.

Number of pre-baked images that can be switched when the billboard is viewed from different angles.

Number of indices in the billboard mesh. The mesh is not necessarily a quad. It can be a more complex shape which fits the actual image more precisely.

The material used for rendering.

Number of vertices in the billboard mesh. The mesh is not necessarily a quad. It can be a more complex shape which fits the actual image more precisely.

Width of the billboard.

Constructs a new BillboardAsset.

Renders a billboard.

The BillboardAsset to render.

Constructor.

The BitStream class represents seralized variables, packed into a stream.

Is the BitStream currently being read? (RO)

Is the BitStream currently being written? (RO)

Serializes different types of variables.

Blend weights.

Four bones affect each vertex.

One bone affects each vertex.

Two bones affect each vertex.

Skinning bone weights of a vertex in the mesh.

Index of first bone.

Index of second bone.

Index of third bone.

Index of fourth bone.

Skinning weight for first bone.

Skinning weight for second bone.

Skinning weight for third bone.

Skinning weight for fourth bone.

Represents an axis aligned bounding box.

The center of the bounding box.

The extents of the box. This is always half of the ::ref::size.

The maximal point of the box. This is always equal to ''center+extents''.

The minimal point of the box. This is always equal to ''center-extents''.

The total size of the box. This is always twice as large as the ::ref::extents.

The closest point on the bounding box.

Arbitrary point. The point on the bounding box or inside the bounding box.

Is /point/ contained in the bounding box?

Creates new Bounds with a given /center/ and total /size/. Bound ::ref::extents will be half the given size.

Grows the Bounds to include the /point/.

Grow the bounds to encapsulate the bounds.

Expand the bounds by increasing its /size/ by /amount/ along each side.

Does /ray/ intersect this bounding box?

Does another bounding box intersect with this bounding box?

Sets the bounds to the /min/ and /max/ value of the box.

The smallest squared distance between the point and this bounding box.

Returns a nicely formatted string for the bounds.

A box-shaped primitive collider.

The center of the box, measured in the object's local space.

The size of the box, measured in the object's local space.

Collider for 2D physics representing an axis-aligned rectangle.

The width and height of the rectangle.

The Caching class lets you manage cached AssetBundles, downloaded using WWW::ref::LoadFromCacheOrDownload.

Is Caching enabled?

The number of seconds that an AssetBundle may remain unused in the cache before it is automatically deleted.

The total number of bytes that can potentially be allocated for caching.

Is caching ready?

The number of currently unused bytes in the cache.

Used disk space in bytes.

(This is a WebPlayer-only function).

Signature The authentification signature provided by Unity. Size The number of bytes allocated to this cache.

(This is a WebPlayer-only function).

Signature The authentification signature provided by Unity. Size The number of bytes allocated to this cache.

TODO.

Delete all AssetBundle content that has been cached by the current application.

True when cache cleaning succeeded, false if cache was in use.

Checks if an AssetBundle is cached.

Url The filename of the AssetBundle. Domain and path information are stripped from this string automatically. Version The version number of the AssetBundle to check for. Negative values are not allowed. True if an AssetBundle matching the /url/ and /version/ parameters has previously been loaded using WWW.LoadFromCacheOrDownload() and is currently stored in the cache. Returns false if the AssetBundle is not in cache, either because it has been flushed from the cache or was never loaded using the Caching API.

Bumps the timestamp of a cached file to be the current time.

A Camera is a device through which the player views the world.

Actually used rendering path (RO).

Returns all enabled cameras in the scene.

The number of cameras in the current scene.

The aspect ratio (width divided by height).

The color with which the screen will be cleared.

Matrix that transforms from camera space to world space (RO).

How the camera clears the background.

Should the camera clear the stencil buffer after the deferred light pass?

Number of command buffers set up on this camera (RO).

This is used to render parts of the scene selectively.

The camera we are currently rendering with, for low-level render control only (Read Only).

Camera's depth in the camera rendering order.

How and if camera generates a depth texture.

Mask to select which layers can trigger events on the camera.

The far clipping plane distance.

The field of view of the camera in degrees.

High dynamic range rendering.

Per-layer culling distances.

How to perform per-layer culling for a Camera.

The first enabled camera tagged "MainCamera" (RO).

The near clipping plane distance.

Event that is fired after any camera finishes rendering.

Event that is fired before any camera starts culling.

Event that is fired before any camera starts rendering.

Opaque object sorting mode.

Is the camera orthographic (''true'') or perspective (''false'')?

Camera's half-size when in orthographic mode.

How tall is the camera in pixels (RO).

Where on the screen is the camera rendered in pixel coordinates.

How wide is the camera in pixels (RO).

Set a custom projection matrix.

Where on the screen is the camera rendered in normalized coordinates.

Rendering path.

Distance to a point where virtual eyes converge.

Stereoscopic rendering.

Render only once and use resulting image for both eyes.

Distance between the virtual eyes.

Set the target display for this Camera.

Destination render texture.

Transparent object sorting mode.

Whether or not the Camera will use occlusion culling during rendering.

Get the world-space speed of the camera (RO).

Matrix that transforms from world to camera space.

Add a command buffer to be executed at a specified place.

When to execute the command buffer during rendering. The buffer to execute.

Calculates and returns oblique near-plane projection matrix.

Vector4 that describes a clip plane. Oblique near-plane projection matrix.

Delegate type for camera callbacks.

Makes this camera's settings match other camera.

Fills an array of Camera with the current cameras in the scene, without allocating a new array.

An array to be filled up with cameras currently in the scene.

Get command buffers to be executed at a specified place.

When to execute the command buffer during rendering. Array of command buffers.

Remove all command buffers set on this camera.

Remove command buffer from execution at a specified place.

When to execute the command buffer during rendering. The buffer to execute.

Remove command buffers from execution at a specified place.

When to execute the command buffer during rendering.

Render the camera manually.

Render into a static cubemap from this camera.

The cube map to render to. A bitmask which determines which of the six faces are rendered to. False is rendering fails, else true.

Render into a cubemap from this camera.

A bitfield indicating which cubemap faces should be rendered into. The texture to render to. False is rendering fails, else true.

Render the camera with shader replacement.

Revert the aspect ratio to the screen's aspect ratio.

Make the projection reflect normal camera's parameters.

Remove shader replacement from camera.

Make the rendering position reflect the camera's position in the scene.

Returns a ray going from camera through a screen point.

Transforms /position/ from screen space into viewport space.

Transforms /position/ from screen space into world space.

Make the camera render with shader replacement.

Sets the Camera to render to the chosen buffers of one or more RenderTextures.

The RenderBuffer(s) to which color information will be rendered. The RenderBuffer to which depth information will be rendered.

Sets the Camera to render to the chosen buffers of one or more RenderTextures.

The RenderBuffer(s) to which color information will be rendered. The RenderBuffer to which depth information will be rendered.

Returns a ray going from camera through a viewport point.

Transforms /position/ from viewport space into screen space.

Transforms /position/ from viewport space into world space.

Transforms /position/ from world space into screen space.

Transforms /position/ from world space into viewport space.

Values for Camera.clearFlags, determining what to clear when rendering a [[Camera]].

Clear only the depth buffer.

Don't clear anything.

Clear with the skybox.

Clear with a background color.

Element that can be used for screen rendering.

Cached calculated value based upon SortingLayerID.

Is this the root [[Canvas]]?

Allows for nested canvases to override pixelPerfect settings inherited from parent canvases.

Override the sorting of canvas.

Force elements in the canvas to be aligned with pixels. Only applies with renderMode is Screen Space.

Get the render rect for the [[Canvas]].

How far away from the camera is the Canvas generated.

The number of pixels per unit that is considered the default.

Is the [[Canvas]] in World or Overlay mode?

The render order in which the canvas is being emitted to the scene.

Used to scale the entire canvas, while still making it fit the screen. Only applies with renderMode is Screen Space.

Unique ID of the Canvas' sorting layer.

Name of the Canvas' sorting layer.

Canvas' order within a sorting layer.

Event that is called just before [[Canvas]] rendering happens.

[[Camera]] used for sizing the [[Canvas]] when in Screen Space - Camera. Also used as the [[Camera]] that events will be sent through for a World Space [[Canvas].

Force all canvases to update their content.

Returns the default material that can be used for rendering normal elements on the Canvas.

Returns the default material that can be used for rendering text elements on the Canvas.

A [[Canvas]] placable element that can be used to modify children Alpha, Raycasting, Enabled state.

Set the alpha of the group.

Does this group block raycasting (allow collision).

Should the group ignore parent groups?

Is the group interactable (are the elements beneath the group enabled).

Returns true if the Group allows raycasts.

A component that will render to the screen after all normal rendering has completed when attached to a [[Canvas]]. Designed for GUI application.

Depth of the renderer realitive to the root canvas.

Is the UIRenderer a mask component.

Depth of the renderer realative to the parent canvas.

Remove all cached vertices.

Get the current alpha of the renderer.

Get the current color of the renderer.

Gets the current [[Material]] assigned to the UIRenderer.

Result.

Set the alpha of the renderer. Will be multiplied with the [[UIVertex]] alpha and the [[Canvas]] alpha.

Alpha.

Set the color of the renderer. Will be multiplied with the [[UIVertex]] color and the [[Canvas]] color.

Renderer multiply color.

Set the material for [[UIRenderer]]. If a texture is specified then it will be used as the 'MainTex' instead of the material's 'MainTex'.

Material for rendering. Material texture overide.

Set the vertices for the [[UIRenderer]].

Array of vertices to set. Number of vertices to set.

Set the vertices for the [[UIRenderer]].

Array of vertices to set. Number of vertices to set.

A capsule-shaped primitive collider.

The center of the capsule, measured in the object's local space.

The direction of the capsule.

The height of the capsule meased in the object's local space.

The radius of the sphere, measured in the object's local space.

A CharacterController allows you to easily do movement constrained by collisions without having to deal with a rigidbody.

The center of the character's capsule relative to the transform's position.

What part of the capsule collided with the environment during the last CharacterController.Move call.

Determines whether other rigidbodies or character controllers collide with this character controller (by default this is always enabled).

The height of the character's capsule.

Was the CharacterController touching the ground during the last move?

The radius of the character's capsule.

The character controllers slope limit in degrees.

The character controllers step offset in meters.

The current relative velocity of the Character (see notes).

A more complex move function taking absolute movement deltas.

Moves the character with /speed/.

Specification for how to render a character from the font texture. See [[Font.characterInfo]].

The horizontal distance from the origin of this character to the origin of the next character.

The horizontal distance from the origin of this glyph to the begining of the glyph image.

Is the character flipped?

The height of the glyph image.

The width of the glyph image.

Unicode value of the character.

The maximum extend of the glyph image in the x-axis.

The maximum extend of the glyph image in the y-axis.

The minium extend of the glyph image in the x-axis.

The minimum extend of the glyph image in the y-axis.

The size of the character or 0 if it is the default font size.

The style of the character.

UV coordinates for the character in the texture.

The uv coordinate matching the bottom left of the glyph image in the font texture.

The uv coordinate matching the bottom right of the glyph image in the font texture.

The uv coordinate matching the top left of the glyph image in the font texture.

The uv coordinate matching the top right of the glyph image in the font texture.

Screen coordinates for the character in generated text meshes.

How far to advance between the beginning of this charcater and the next.

Character Joints are mainly used for Ragdoll effects.

Brings violated constraints back into alignment even when the solver fails.

The upper limit around the primary axis of the character joint.

The lower limit around the primary axis of the character joint.

Set the angular tolerance threshold (in degrees) for projection.

Set the linear tolerance threshold for projection.

The angular limit of rotation (in degrees) around the primary axis of the character joint.

The secondary axis around which the joint can rotate.

The configuration of the spring attached to the swing limits of the joint.

The configuration of the spring attached to the twist limits of the joint.

Collider for 2D physics representing an circle.

Radius of the circle.

The Cloth class provides an interface to cloth simulation physics.

Bending stiffness of the cloth.

An array of CapsuleColliders which this Cloth instance should collide with.

The cloth skinning coefficients used to set up how the cloth interacts with the skinned mesh.

How much to increase mass of colliding particles.

Damp cloth motion.

Is this cloth enabled?

A constant, external acceleration applied to the cloth.

The friction of the cloth when colliding with the character.

The current normals of the cloth object.

A random, external acceleration applied to the cloth.

Cloth's sleep threshold.

Number of solver iterations per second.

An array of ClothSphereColliderPairs which this Cloth instance should collide with.

Stretching stiffness of the cloth.

Enable continuous collision to improve collision stability.

Should gravity affect the cloth simulation?

Add one virtual particle per triangle to improve collision stability.

The current vertex positions of the cloth object.

How much world-space acceleration of the character will affect cloth vertices.

How much world-space movement of the character will affect cloth vertices.

Clear the pending transform changes from affecting the cloth simulation.

Fade the cloth simulation in or out.

Fading enabled or not.

The ClothSkinningCoefficient struct is used to set up how a [[Cloth]] component is allowed to move with respect to the [[SkinnedMeshRenderer]] it is attached to.

Definition of a sphere a vertex is not allowed to enter. This allows collision against the animated cloth.

Distance a vertex is allowed to travel from the skinned mesh vertex position.

A pair of SphereColliders used to define shapes for Cloth objects to collide against.

The first SphereCollider of a ClothSphereColliderPair.

The second SphereCollider of a ClothSphereColliderPair.

Creates a ClothSphereColliderPair. If only one SphereCollider is given, the ClothSphereColliderPair will define a simple sphere. If two SphereColliders are given, the ClothSphereColliderPair defines a conic capsule shape, composed of the two spheres and the cone connecting the two.

The first SphereCollider of a ClothSphereColliderPair. The second SphereCollider of a ClothSphereColliderPair.

A base class of all colliders.

The rigidbody the collider is attached to.

The world space bounding volume of the collider.

Contact offset value of this collider.

Enabled Colliders will collide with other colliders, disabled Colliders won't.

Is the collider a trigger?

The material used by the collider.

The shared physic material of this collider.

The closest point to the bounding box of the attached collider.

Casts a [[Ray]] that ignores all Colliders except this one.

The starting point and direction of the ray. If true is returned, /hitInfo/ will contain more information about where the collider was hit (SA: [[RaycastHit]]). The length of the ray. True when the ray intersects any collider, otherwise false.

Parent class for collider types used with 2D gameplay.

The Rigidbody2D attached to the Collider2D's GameObject.

The world space bounding area of the collider.

Is this collider configured as a trigger?

The local offset of the collider geometry.

The number of separate shaped regions in the collider.

The PhysicsMaterial2D that is applied to this collider.

Whether the collider is used by an attached effector or not.

Check whether this collider is touching the /collider/ or not.

The collider to check if it is touching this collider. Whether the /collider/ is touching this collider or not.

Checks whether this collider is touching any colliders on the specified /layerMask/ or not.

Any colliders on any of these layers count as touching. Whether this collider is touching any collider on the specified /layerMask/ or not.

Check if a collider overlaps a point in space.

A point in world space.

Describes a collision.

The [[Collider]] we hit (RO).

The contact points generated by the physics engine.

The [[GameObject]] whose collider we are colliding with. (RO).

The relative linear velocity of the two colliding objects (RO).

The [[Rigidbody]] we hit (RO). This is /null/ if the object we hit is a collider with no rigidbody attached.

The [[Transform]] of the object we hit (RO).

Information returned by a collision in 2D physics.

The incoming Collider2D involved in the collision.

The specific points of contact with the incoming Collider2D.

Whether the collision was disabled or not.

The incoming GameObject involved in the collision.

The relative linear velocity of the two colliding objects (RO).

The incoming Rigidbody2D involved in the collision.

The Transform of the incoming object involved in the collision.

The collision detection mode constants used for [[Rigidbody.collisionDetectionMode]].

Continuous collision detection is on for colliding with static mesh geometry.

Continuous collision detection is on for colliding with static and dynamic geometry.

Continuous collision detection is off for this Rigidbody.

Options for the detection mode used by a Rigidbody2D.

The Rigidbody2D estimates its position between physics updates.

No collision detection is used on the Rigidbody2D.

CollisionFlags is a bitmask returned by CharacterController.Move.

Representation of RGBA colors.

Alpha component of the color.

Blue component of the color.

Solid black. RGBA is (0, 0, 0, 1).

Solid blue. RGBA is (0, 0, 1, 1).

Completely transparent. RGBA is (0, 0, 0, 0).

Cyan. RGBA is (0, 1, 1, 1).

Green component of the color.

A version of the color that has had the gamma curve applied.

Gray. RGBA is (0.5, 0.5, 0.5, 1).

The grayscale value of the color. (RO)

Solid green. RGBA is (0, 1, 0, 1).

English spelling for ::ref::gray. RGBA is the same (0.5, 0.5, 0.5, 1).

A version of the color that has had the inverse gamma curve applied.

Magenta. RGBA is (1, 0, 1, 1).

Returns the maximum color component value: Max(r,g,b).

Red component of the color.

Solid red. RGBA is (1, 0, 0, 1).

Solid white. RGBA is (1, 1, 1, 1).

Yellow. RGBA is (1, 0.92, 0.016, 1), but the color is nice to look at!

Constructs a new Color with given r,g,b,a components.

Red component. Green component. Blue component. Alpha component.

Constructs a new Color with given r,g,b components and sets /a/ to 1.

Red component. Green component. Blue component.

Colors can be implicitly converted to and from [[Vector4]].

Interpolates between colors /a/ and /b/ by /t/.

Divides color /a/ by the float /b/. Each color component is scaled separately.

Subtracts color /b/ from color /a/. Each component is subtracted separately.

Multiplies two colors together. Each component is multiplied separately.

Multiplies color /a/ by the float /b/. Each color component is scaled separately.

Adds two colors together. Each component is added separately.

Access the r, g, b,a components using [0], [1], [2], [3] respectively.

Returns the color as a hexadecimal string in the format RRGGBB.

Hexadecimal string representing the color.

Returns the color as a hexadecimal string in the format RRGGBBAA.

Hexadecimal string representing the color.

Returns a nicely formatted string of this color.

Converts a hexadecimal string into a color.

Hexadecimal string to be converted into a color. The converted color. Returns true if the operation was successful.

Representation of RGBA colors in 32 bit format.

Alpha component of the color.

Blue component of the color.

Green component of the color.

Red component of the color.

Constructs a new Color with given r, g, b, a components.

Color32 can be implicitly converted to and from [[Color]].

Interpolates between colors /a/ and /b/ by /t/.

Returns a nicely formatted string of this color.

Valid color spaces.

Lightmap has been baked for gamma rendering.

Lightmap has been baked for linear rendering.

Uninitialized colorspace.

Attribute used to configure the usage of the ColorField and Color Picker for a color.

If set to true the Color is treated as a HDR color.

Maximum allowed HDR color component value when using the HDR Color Picker.

Maximum exposure value allowed in the HDR Color Picker.

Minimum allowed HDR color component value when using the Color Picker.

Minimum exposure value allowed in the HDR Color Picker.

If false then the alpha bar is hidden in the ColorField and the alpha value is not shown in the Color Picker.

Attribute for Color fields. Used for configuring the GUI for the color.

If false then the alpha channel info is hidden both in the ColorField and in the Color Picker. Set to true if the color should be treated as a HDR color (default value: false). Minimum allowed HDR color component value when using the HDR Color Picker (default value: 0). Maximum allowed HDR color component value when using the HDR Color Picker (default value: 8). Minimum exposure value allowed in the HDR Color Picker (default value: 1/8 = 0.125). Maximum exposure value allowed in the HDR Color Picker (default value: 3).

Attribute for Color fields. Used for configuring the GUI for the color.

Struct used to describe meshes to be combined using Mesh.CombineMeshes.

[[Mesh]] to combine.

Submesh index of the mesh.

Matrix to transform the mesh with before combining.

Interface into compass functionality.

Used to enable or disable compass. Note, that if you want @@Input.compass.trueHeading@@ property to contain a valid value, you must also enable location updates by calling @@Input.location.Start()@@.

Accuracy of heading reading in degrees.

The heading in degrees relative to the magnetic North Pole. (RO)

The raw geomagnetic data measured in microteslas. (RO)

Timestamp (in seconds since 1970) when the heading was last time updated. (RO)

The heading in degrees relative to the geographic North Pole. (RO)

Base class for everything attached to [[GameObject]]s.

The game object this component is attached to. A component is always attached to a game object.

The tag of this game object.

The [[Transform]] attached to this [[GameObject]] (null if there is none attached).

Calls the method named /methodName/ on every [[MonoBehaviour]] in this game object or any of its children.

Name of the method to call. Optional parameter to pass to the method (can be any value). Should an error be raised if the method does not exist for a given target object?

Calls the method named /methodName/ on every [[MonoBehaviour]] in this game object or any of its children.

Name of the method to call. Optional parameter to pass to the method (can be any value). Should an error be raised if the method does not exist for a given target object?

Calls the method named /methodName/ on every [[MonoBehaviour]] in this game object or any of its children.

Name of the method to call. Optional parameter to pass to the method (can be any value). Should an error be raised if the method does not exist for a given target object?

Calls the method named /methodName/ on every [[MonoBehaviour]] in this game object or any of its children.

Name of the method to call. Optional parameter to pass to the method (can be any value). Should an error be raised if the method does not exist for a given target object?

Is this game object tagged with /tag/ ?

The tag to compare.

Returns the component of Type /type/ if the game object has one attached, null if it doesn't.

The type of Component to retrieve.

Generic version. See the [[wiki:Generic Functions|Generic Functions]] page for more details.

Returns the component with name /type/ if the game object has one attached, null if it doesn't.

Returns the component of Type /type/ in the [[GameObject]] or any of its children using depth first search.

The type of Component to retrieve.

Generic version. See the [[wiki:Generic Functions|Generic Functions]] page for more details.

Returns the component of Type /type/ in the [[GameObject]] or any of its parents.

The type of Component to retrieve.

Generic version. See the [[wiki:Generic Functions|Generic Functions]] page for more details.

Returns all components of Type /type/ in the [[GameObject]].

The type of Component to retrieve.

Generic version. See the [[wiki:Generic Functions|Generic Functions]] page for more details.

Returns all components of Type /type/ in the [[GameObject]] or any of its children.

The type of Component to retrieve. Should Components on inactive GameObjects be included in the found set?

Returns all components of Type /type/ in the [[GameObject]] or any of its children.

The type of Component to retrieve. Should Components on inactive GameObjects be included in the found set?

Generic version. See the [[wiki:Generic Functions|Generic Functions]] page for more details.

Should inactive Components be included in the found set?

Generic version. See the [[wiki:Generic Functions|Generic Functions]] page for more details.

Returns all components of Type /type/ in the [[GameObject]] or any of its parents.

The type of Component to retrieve. Should inactive Components be included in the found set?

Generic version. See the [[wiki:Generic Functions|Generic Functions]] page for more details.

Should inactive Components be included in the found set?

Generic version. See the [[wiki:Generic Functions|Generic Functions]] page for more details.

Should inactive Components be included in the found set?

Calls the method named /methodName/ on every [[MonoBehaviour]] in this game object.

Name of the method to call. Optional parameter for the method. Should an error be raised if the target object doesn't implement the method for the message?

Calls the method named /methodName/ on every [[MonoBehaviour]] in this game object.

Name of the method to call. Optional parameter for the method. Should an error be raised if the target object doesn't implement the method for the message?

Calls the method named /methodName/ on every [[MonoBehaviour]] in this game object.

Name of the method to call. Optional parameter for the method. Should an error be raised if the target object doesn't implement the method for the message?

Calls the method named /methodName/ on every [[MonoBehaviour]] in this game object.

Name of the method to call. Optional parameter for the method. Should an error be raised if the target object doesn't implement the method for the message?

Calls the method named /methodName/ on every [[MonoBehaviour]] in this game object and on every ancestor of the behaviour.

Name of method to call. Optional parameter value for the method. Should an error be raised if the method does not exist on the target object?

Calls the method named /methodName/ on every [[MonoBehaviour]] in this game object and on every ancestor of the behaviour.

Name of method to call. Optional parameter value for the method. Should an error be raised if the method does not exist on the target object?

Calls the method named /methodName/ on every [[MonoBehaviour]] in this game object and on every ancestor of the behaviour.

Name of method to call. Optional parameter value for the method. Should an error be raised if the method does not exist on the target object?

Calls the method named /methodName/ on every [[MonoBehaviour]] in this game object and on every ancestor of the behaviour.

Name of method to call. Optional parameter value for the method. Should an error be raised if the method does not exist on the target object?

Data buffer to hold data for compute shaders.

Number of elements in the buffer (RO).

Size of one element in the buffer (RO).

Copy counter value of append/consume buffer into another buffer.

Append/consume buffer to copy the counter from. A buffer to copy the counter to. Target byte offset in /dst/.

Create a Compute Buffer.

Number of elements in the buffer. Size of one element in the buffer. Has to match size of buffer type in the shader. See [[wiki:Compute Shaders|Compute Shaders]] for cross-platform compatibility information. Type of the buffer, default is ComputeBufferType.Default.

Create a Compute Buffer.

Read data values from the buffer into an array.

An array to receive the data.

Release a Compute Buffer.

Set the buffer with values from an array.

Array of values to fill the buffer.

[[ComputeBuffer]] type.

Append-consume [[ComputeBuffer]] type.

[[ComputeBuffer]] with a counter.

Default [[ComputeBuffer]] type.

[[ComputeBuffer]] used for Graphics.DrawProceduralIndirect.

Raw [[ComputeBuffer]] type.

Compute Shader asset.

Execute a compute shader.

Which kernel to execute. A single compute shader asset can have multiple kernel entry points. Work size in X dimension. Work size in Y dimension. Work size in Z dimension.

Find [[ComputeShader]] kernel index.

Name of kernel function. Kernel index, or -1 if not found.

Sets an input or output compute buffer.

For which kernel the buffer is being set. See ::ref::FindKernel. Name of the buffer variable in shader code. Buffer to set.

Set a float parameter.

Variable name in shader code. Value to set.

Set multiple consecutive float parameters at once.

Array variable name in the shader code. Value array to set.

Set an integer parameter.

Variable name in shader code. Value to set.

Set multiple consecutive integer parameters at once.

Array variable name in the shader code. Value array to set.

Set a texture parameter.

For which kernel the texture is being set. See ::ref::FindKernel. Name of the buffer variable in shader code. Texture to set.

Set a vector parameter.

Variable name in shader code. Value to set.

The configurable joint is an extremely flexible joint giving you complete control over rotation and linear motion.

Definition of how the joint's rotation will behave around its local X axis. Only used if Rotation Drive Mode is Swing & Twist.

The configuration of the spring attached to the angular X limit of the joint.

Allow rotation around the X axis to be Free, completely Locked, or Limited according to Low and High Angular XLimit.

Boundary defining rotation restriction, based on delta from original rotation.

Allow rotation around the Y axis to be Free, completely Locked, or Limited according to Angular YLimit.

Definition of how the joint's rotation will behave around its local Y and Z axes. Only used if Rotation Drive Mode is Swing & Twist.

The configuration of the spring attached to the angular Y and angular Z limits of the joint.

Boundary defining rotation restriction, based on delta from original rotation.

Allow rotation around the Z axis to be Free, completely Locked, or Limited according to Angular ZLimit.

If enabled, all Target values will be calculated in world space instead of the object's local space.

Boundary defining upper rotation restriction, based on delta from original rotation.

Boundary defining movement restriction, based on distance from the joint's origin.

The configuration of the spring attached to the linear limit of the joint.

Boundary defining lower rotation restriction, based on delta from original rotation.

Set the angular tolerance threshold (in degrees) for projection. If the joint deviates by more than this angle around its locked angular degrees of freedom, the solver will move the bodies to close the angle. Setting a very small tolerance may result in simulation jitter or other artifacts. Sometimes it is not possible to project (for example when the joints form a cycle).

Set the linear tolerance threshold for projection. If the joint separates by more than this distance along its locked degrees of freedom, the solver will move the bodies to close the distance. Setting a very small tolerance may result in simulation jitter or other artifacts. Sometimes it is not possible to project (for example when the joints form a cycle).

Brings violated constraints back into alignment even when the solver fails. Projection is not a physical process and does not preserve momentum or respect collision geometry. It is best avoided if practical, but can be useful in improving simulation quality where joint separation results in unacceptable artifacts.

Control the object's rotation with either X & YZ or Slerp Drive by itself.

The joint's secondary axis.

Definition of how the joint's rotation will behave around all local axes. Only used if Rotation Drive Mode is Slerp Only.

If enabled, the two connected rigidbodies will be swapped, as if the joint was attached to the other body.

This is a [[Vector3]]. It defines the desired angular velocity that the joint should rotate into.

The desired position that the joint should move into.

This is a [[Quaternion]]. It defines the desired rotation that the joint should rotate into.

The desired velocity that the joint should move along.

Definition of how the joint's movement will behave along its local X axis.

Allow movement along the X axis to be Free, completely Locked, or Limited according to Linear Limit.

Definition of how the joint's movement will behave along its local Y axis.

Allow movement along the Y axis to be Free, completely Locked, or Limited according to Linear Limit.

Definition of how the joint's movement will behave along its local Z axis.

Allow movement along the Z axis to be Free, completely Locked, or Limited according to Linear Limit.

Constrains movement for a [[ConfigurableJoint]] along the 6 axes.

Motion along the axis will be completely free and completely unconstrained.

Motion along the axis will be limited by the respective limit.

Motion along the axis will be locked.

The various test results the connection tester may return with.

Some unknown error occurred.

Port-restricted NAT type, can do NAT punchthrough to everyone except symmetric.

Symmetric NAT type, cannot do NAT punchthrough to other symmetric types nor port restricted type.

Address-restricted cone type, NAT punchthrough fully supported.

Full cone type, NAT punchthrough fully supported.

Public IP address detected and game listen port is accessible to the internet.

Public IP address detected but server is not initialized and no port is listening.

Public IP address detected but the port is not connectable from the internet.

Test result undetermined, still in progress.

A force applied constantly.

The force applied to the rigidbody every frame.

The force - relative to the rigid bodies coordinate system - applied every frame.

The torque - relative to the rigid bodies coordinate system - applied every frame.

The torque applied to the rigidbody every frame.

Applies both linear and angular (torque) forces continuously to the rigidbody each physics update.

The linear force applied to the rigidbody each physics update.

The linear force, relative to the rigid-body coordinate system, applied each physics update.

The torque applied to the rigidbody each physics update.

Describes a contact point where the collision occurs.

Normal of the contact point.

The other collider in contact at the point.

The point of contact.

The first collider in contact at the point.

Details about a specific point of contact involved in a 2D physics collision.

The collider attached to the object receiving the collision message.

Surface normal at the contact point.

The incoming collider involved in the collision at this contact point.

The point of contact between the two colliders in world space.

The ContextMenu attribute allows you to add commands to the context menu.

Adds the function to the context menu of the component.

Use this attribute to add a context menu to a field that calls a named method.

The name of the function that should be called.

The name of the context menu item.

Use this attribute to add a context menu to a field that calls a named method.

The name of the context menu item. The name of the function that should be called.

ControllerColliderHit is used by CharacterController.OnControllerColliderHit to give detailed information about the collision and how to deal with it.

The collider that was hit by the controller.

The controller that hit the collider.

The game object that was hit by the controller.

The direction the CharacterController was moving in when the collision occured.

How far the character has travelled until it hit the collider.

The normal of the surface we collided with in world space.

The impact point in world space.

The rigidbody that was hit by the controller.

The transform that was hit by the controller.

MonoBehaviour.StartCoroutine returns a Coroutine. Instances of this class are only used to reference these coroutines and do not hold any exposed properties or functions.

Holds data for a single application crash event and provides access to all gathered crash reports.

Returns last crash report, or null if no reports are available.

Returns all currently available reports in a new array.

Crash report data as formatted text.

Time, when the crash occured.

Remove report from available reports list.

Remove all reports from available reports list.

Mark a ScriptableObject-derived type to be automatically listed in the Assets/Create submenu, so that instances of the type can be easily created and stored in the project as ".asset" files.

The default file name used by newly created instances of this type.

The display name for this type shown in the Assets/Create menu.

The position of the menu item within the Assets/Create menu.

Class for handling cube maps, Use this to create or modify existing [[wiki:class-Cubemap|cube map assets]].

The format of the pixel data in the texture (RO).

Actually apply all previous ::ref::SetPixel and ::ref::SetPixels changes.

Should all mipmap levels be updated? Should the Cubemap texture data be readable/modifiable after changes are applied?

Create a new empty cubemap texture.

Width/height of a cube face in pixels. Pixel data format to be used for the Cubemap. Should mipmaps be created?

Returns pixel color at coordinates (face, x, y).

Returns pixel colors of a cubemap face.

The face from which pixel data is taken. Mipmap level for the chosen face.

Sets pixel color at coordinates (face, x, y).

Sets pixel colors of a cubemap face.

Pixel data for the Cubemap face. The face to which the new data should be applied. The mipmap level for the face.

Performs smoothing of near edge regions.

Pixel distance at edges over which to apply smoothing.

[[Cubemap]] face.

Left facing side (-x).

Downward facing side (-y).

Backward facing side (-z).

Right facing side (+x).

Upwards facing side (+y).

Forward facing side (+z).

Cursor API for setting the cursor that is used for rendering.

How should the cursor be handled?

Should the cursor be visible?

Change the mouse cursor to the set texture OnMouseEnter.

Specify a custom cursor that you wish to use as a cursor.

The texture to use for the cursor or null to set the default cursor. Note that a texture needs to be imported with "Read/Write enabled" in the texture importer (or using the "Cursor" defaults), in order to be used as a cursor. The offset from the top left of the texture to use as the target point (must be within the bounds of the cursor). Allow this cursor to render as a hardware cursor on supported platforms, or force software cursor.

How the cursor should behave.

Confine cursor to the game window.

Lock cursor to the center of the game window.

Cursor behavior is unmodified.

How should the custom cursor be rendered.

Use hardware cursors on supported platforms.

Force the use of software cursors.

Class containing methods to ease debugging while developing a game.

Opens or closes developer console.

In the Build Settings dialog there is a check box called "Development Build".

Assert the condition.

Condition you expect to be true. String or object to be converted to string representation for display. Formatted string for display. Arguments for the formatted string.

Assert the condition.

Condition you expect to be true. String or object to be converted to string representation for display. Formatted string for display. Arguments for the formatted string.

Assert the condition.

Condition you expect to be true. String or object to be converted to string representation for display. Formatted string for display. Arguments for the formatted string.

Pauses the editor.

Clears errors from the developer console.

Draws a line between specified start and end points.

Point in world space where the line should start. Point in world space where the line should end. Color of the line. How long the line should be visible for. Should the line be obscured by objects closer to the camera?

Draws a line between specified start and end points.

Draws a line from /start/ to /start/ + /dir/ in world coordinates.

Point in world space where the ray should start. Direction and length of the ray. Color of the drawn line. How long the line will be visible for (in seconds). Should the line be obscured by other objects closer to the camera?

Draws a line from /start/ to /start/ + /dir/ in world coordinates.

Logs /message/ to the Unity Console.

String or object to be converted to string representation for display. Object to which the message applies.

Logs /message/ to the Unity Console.

String or object to be converted to string representation for display. Object to which the message applies.

A variant of Debug.Log that logs an error message to the console.

String or object to be converted to string representation for display. Object to which the message applies.

A variant of Debug.Log that logs an error message to the console.

String or object to be converted to string representation for display. Object to which the message applies.

Logs a formatted error message to the Unity console.

A composite format string. Format arguments. Object to which the message applies.

Logs a formatted error message to the Unity console.

A composite format string. Format arguments. Object to which the message applies.

A variant of Debug.Log that logs an error message to the console.

Logs a formatted message to the Unity Console.

A composite format string. Format arguments. Object to which the message applies.

Logs a formatted message to the Unity Console.

A composite format string. Format arguments. Object to which the message applies.

A variant of Debug.Log that logs a warning message to the console.

String or object to be converted to string representation for display. Object to which the message applies.

A variant of Debug.Log that logs a warning message to the console.

String or object to be converted to string representation for display. Object to which the message applies.

Logs a formatted warning message to the Unity Console.

A composite format string. Format arguments. Object to which the message applies.

Logs a formatted warning message to the Unity Console.

A composite format string. Format arguments. Object to which the message applies.

Depth texture generation mode for [[Camera]].

Generate a depth texture.

Generate a depth + normals texture.

Do not generate depth texture (Default).

Detail prototype used by the Terrain GameObject.

Bend factor of the detailPrototype.

Color when the DetailPrototypes are "dry".

Color when the DetailPrototypes are "healthy".

Maximum height of the grass billboards (if render mode is GrassBillboard).

Maximum width of the grass billboards (if render mode is GrassBillboard).

Minimum height of the grass billboards (if render mode is GrassBillboard).

Minimum width of the grass billboards (if render mode is GrassBillboard).

How spread out is the noise for the DetailPrototype.

GameObject used by the DetailPrototype.

Texture used by the DetailPrototype.

Render mode for the DetailPrototype.

Render mode for detail prototypes.

The detail prototype will use the grass shader.

The detail prototype will be rendered as billboards that are always facing the camera.

Will show the prototype using diffuse shading.

Describes physical orientation of the device as determined by the OS.

The device is held parallel to the ground with the screen facing downwards.

The device is held parallel to the ground with the screen facing upwards.

The device is in landscape mode, with the device held upright and the home button on the right side.

The device is in landscape mode, with the device held upright and the home button on the left side.

The device is in portrait mode, with the device held upright and the home button at the bottom.

The device is in portrait mode but upside down, with the device held upright and the home button at the top.

The orientation of the device cannot be determined.

Enumeration for [[SystemInfo.deviceType]], denotes a coarse grouping of kinds of devices.

A stationary gaming console.

Desktop or laptop computer.

A handheld device like mobile phone or a tablet.

Device type is unknown. You should never see this in practice.

Prevents MonoBehaviour of same type (or subtype) to be added more than once to a GameObject.

Provides access to a display / screen for rendering operations.

Color RenderBuffer.

Depth RenderBuffer.

The list of currently connected Displays. Contains at least one (main) display.

Main Display.

Rendering Height.

Rendering Width.

System Height.

System Width.

Activate an external display. Eg. Secondary Monitors connected to the System.

This overloaded function available for Windows allows specifying desired Window Width, Height and Refresh Rate.

Desired Width of the Window (for Windows only. On Linux and Mac uses Screen Width). Desired Height of the Window (for Windows only. On Linux and Mac uses Screen Height). Desired Refresh Rate.

Check if MultiDisplayLicense is enabled.

Query relative mouse coordinates.

Mouse Input Position as Coordinates.

This Windows only function can be used to set Size and Position of the Screen when Multi-Display is enabled.

Change Window Width (Windows Only). Change Window Height (Windows Only). Change Window Position X (Windows Only). Change Window Position Y (Windows Only).

Sets Rendering resolution for the display.

Rendering width. Rendering height.

Joint that keeps two Rigidbody2D objects a fixed distance apart.

The distance separating the two ends of the joint.

Whether to maintain a maximum distance only or not. If not then the absolute distance will be maintained instead.

Gets the reaction force of the joint given the specified /timestep/.

The time to calculate the reaction force for.

Gets the reaction torque of the joint given the specified /timestep/.

The time to calculate the reaction torque for.

A component can be designed drive a RectTransform. The DrivenRectTransformTracker struct is used to specify which RectTransforms it is driving.

Add a RectTransform to be driven.

The object to drive properties. The RectTransform to be driven. The properties to be driven.

Clear the list of RectTransforms being driven.

An enumeration of transform properties that can be driven on a RectTransform by an object.

Selects all driven properties.

Selects driven property [[RectTransform.anchoredPosition]].

Selects driven property [[RectTransform.anchoredPosition3D]].

Selects driven property [[RectTransform.anchoredPosition]].x.

Selects driven property [[RectTransform.anchoredPosition]].y.

Selects driven property [[RectTransform.anchoredPosition3D]].z.

Selects driven property combining ::ref::AnchorMaxX and ::ref::AnchorMaxY.

Selects driven property [[RectTransform.anchorMax]].x.

Selects driven property [[RectTransform.anchorMax]].y.

Selects driven property combining ::ref::AnchorMinX and ::ref::AnchorMinY.

Selects driven property [[RectTransform.anchorMin]].x.

Selects driven property [[RectTransform.anchorMin]].y.

Selects driven property combining ::ref::AnchorMinX, ::ref::AnchorMinY, ::ref::AnchorMaxX and ::ref::AnchorMaxY.

Deselects all driven properties.

Selects driven property combining ::ref::PivotX and ::ref::PivotY.

Selects driven property [[RectTransform.pivot]].x.

Selects driven property [[RectTransform.pivot]].y.

Selects driven property [[Transform.localRotation]].

Selects driven property combining ::ref::ScaleX, ::ref::ScaleY && ::ref::ScaleZ.

Selects driven property [[Transform.localScale]].x.

Selects driven property [[Transform.localScale]].y.

Selects driven property [[Transform.localScale]].z.

Selects driven property combining ::ref::SizeDeltaX and ::ref::SizeDeltaY.

Selects driven property [[RectTransform.sizeDelta]].x.

Selects driven property [[RectTransform.sizeDelta]].y.

Allows to control the dynamic Global Illumination.

Allows for scaling the contribution coming from realtime & static lightmaps.

When enabled, new dynamic Global Illumination output is shown in each frame.

Threshold for limiting updates of realtime GI.

Allows to set an emissive color for a given renderer quickly, without the need to render the emissive input for the entire system.

The [[Renderer]] that should get a new color. The emissive [[Color]]. The index of the submesh that should use the color.

Schedules an update of the environment texture.

Schedules an update of the albedo and emissive textures of a system that contains the renderer or the terrain.

The [[Renderer]] to use when searching for a system to update. The [[Terrain]] to use when searching for systems to update.

Schedules an update of the albedo and emissive textures of a system that contains the renderer or the terrain.

The [[Renderer]] to use when searching for a system to update. The [[Terrain]] to use when searching for systems to update.

Schedules an update of the albedo and emissive textures of a system that contains the renderer or the terrain.

The [[Renderer]] to use when searching for a system to update. The [[Terrain]] to use when searching for systems to update.

Collider for 2D physics representing an arbitrary set of connected edges (lines) defined by its vertices.

Gets the number of edges.

Gets the number of points.

Get or set the points defining multiple continuous edges.

Reset to a single edge consisting of two points.

A base class for all 2D effectors.

The mask used to select specific layers allowed to interact with the effector.

Should the collider-mask be used or the global collision matrix?

The mode used to apply [[Effector2D]] forces.

The force is applied at a constant rate.

The force is applied inverse-linear relative to a point.

The force is applied inverse-squared relative to a point.

Selects the source and/or target to be used by an [[Effector2D]].

The source/target is defined by the [[Collider2D]].

The source/target is defined by the [[Rigidbody2D]].

Class used to allow [[GameObject.AddComponent]] / [[GameObject.GetComponent]] to be used.

A UnityGUI event.

Is Alt/Option key held down? (RO)

Which mouse button was pressed.

Is Caps Lock on? (RO)

The character typed.

How many consecutive mouse clicks have we received.

Is Command/Windows key held down? (RO)

The name of an ExecuteCommand or ValidateCommand Event.

Is Control key held down? (RO)

The current event that's being processed right now.

The relative movement of the mouse compared to last event.

Is the current keypress a function key? (RO)

Is this event a keyboard event? (RO)

Is this event a mouse event? (RO)

The raw key code for keyboard events.

Which modifier keys are held down.

The mouse position.

Is the current keypress on the numeric keyboard? (RO)

Is Shift held down? (RO)

The type of event.

Returns the current number of events that are stored in the event queue.

Current number of events currently in the event queue.

Get a filtered event type for a given control ID.

The ID of the control you are querying from.

Create a keyboard event.

Get the next queued [Event] from the event system.

Next Event.

Use this event.

Types of modifier key that can be active during a keystroke event.

Alt key.

Caps lock key.

Command key (Mac).

Control key.

Function key.

No modifier key pressed during a keystroke event.

Num lock key.

Shift key.

THe mode that a listener is operating in.

The listener will bind to one argument bool functions.

The listener will use the function binding specified by the even.

The listener will bind to one argument float functions.

The listener will bind to one argument int functions.

The listener will bind to one argument [[Object]] functions.

The listener will bind to one argument string functions.

The listener will bind to zero argument functions.

Zero argument delegate used by UnityEvents.

One argument delegate used by UnityEvents.

Two argument delegate used by UnityEvents.

Three argument delegate used by UnityEvents.

Four argument delegate used by UnityEvents.

A zero argument persistent callback that can be saved with the scene.

Add a non persistent listener to the UnityEvent.

Callback function.

Constructor.

Invoke all registered callbacks (runtime and peristent).

Remove a non persistent listener from the UnityEvent.

Callback function.

One argument version of [[UnityEvent]].

Two argument version of [[UnityEvent]].

Three argument version of [[UnityEvent]].

Four argument version of [[UnityEvent]].

Abstract base class for UnityEvents.

Get the number of registered persistent listeners.

Get the target method name of the listener at index index.

Index of the listener to query.

Get the target component of the listener at index index.

Index of the listener to query.

Given an object, function name, and a list of argument types; find the method that matches.

Object to search for the method. Function name to search for. Argument types for the function.

Remove all listeners from the event.

Modify the execution state of a persistent listener.

Index of the listener to query. State to set.

Controls the scope of UnityEvent callbacks.

Callback is always issued.

Callback is not issued.

Callback is only issued in the Runtime and Editor playmode.

Types of UnityGUI input and processing events.

User has right-clicked (or control-clicked on the mac).

Editor only: drag & drop operation exited.

Editor only: drag & drop operation performed.

Editor only: drag & drop operation updated.

Execute a special command (eg. copy & paste).

[[Event]] should be ignored.

A keyboard key was pressed.

A keyboard key was released.

A layout event.

Mouse button was pressed.

Mouse was dragged.

Mouse was moved (editor views only).

Mouse button was released.

A repaint event. One is sent every frame.

The scroll wheel was moved.

Already processed event.

Validates a special command (e.g. copy & paste).

Makes a script execute in edit mode.

Spectrum analysis windowing types.

W[n] = 0.42 - (0.5 * COS(n/N) ) + (0.08 * COS(2.0 * n/N) ).

W[n] = 0.35875 - (0.48829 * COS(1.0 * n/N)) + (0.14128 * COS(2.0 * n/N)) - (0.01168 * COS(3.0 * n/N)).

W[n] = 0.54 - (0.46 * COS(n/N) ).

W[n] = 0.5 * (1.0 - COS(n/N) ).

W[n] = 1.0.

W[n] = TRI(2n/N).

Filtering mode for textures. Corresponds to the settings in a [[wiki:Textures|texture inspector]].

Bilinear filtering - texture samples are averaged.

Point filtering - texture pixels become blocky up close.

Trilinear filtering - texture samples are averaged and also blended between mipmap levels.

The Fixed joint groups together 2 rigidbodies, making them stick together in their bound position.

A flare asset. Read more about flares in the [[wiki:class-Flare|components reference]].

FlareLayer component.

Used by GUIUtility.GetControlID to inform the UnityGUI system if a given control can get keyboard focus.

This is a proper keyboard control. It can have input focus on all platforms. Used for TextField and TextArea controls.

This control can get keyboard focus on Windows, but not on Mac. Used for buttons, checkboxes and other "pressable" things.

This control can never recieve keyboard focus.

Fog mode to use.

Exponential fog.

Exponential squared fog (default).

Linear fog.

Script interface for [[wiki:class-Font|font assets]].

The ascent of the font.

Access an array of all characters contained in the font texture.

Is the font a dynamic font.

The default size of the font.

The line height of the font.

The material used for the font display.

Set a function to be called when the dynamic font texture is rebuilt.

Creates a Font object which lets you render a font installed on the user machine.

The name of the OS font to use for this font object. The default character size of the generated font. Am array of names of OS fonts to use for this font object. When rendering characters using this font object, the first font which is installed on the machine, which contains the requested character will be used. The generate Font object.

Creates a Font object which lets you render a font installed on the user machine.

Create a new Font.

The name of the created Font object.

Create a new Font.

The name of the created Font object.

Get rendering info for a specific character.

The character you need rendering information for. Returns the CharacterInfo struct with the rendering information for the character (if available). The size of the character (default value of zero will use font default size). The style of the character.

Get rendering info for a specific character.

Returns the maximum number of verts that the text generator may return for a given string.

Input string.

Get names of fonts installed on the machine.

An array of the names of all fonts installed on the machine.

Does this font have a specific character?

Request characters to be added to the font texture (dynamic fonts only).

The characters which are needed to be in the font texture. The size of the requested characters (the default value of zero will use the font's default size). The style of the requested characters.

Font Style applied to GUI Texts, Text Meshes or GUIStyles.

Bold style applied to your texts.

Bold and Italic styles applied to your texts.

Italic style applied to your texts.

No special style is applied.

Option for how to apply a force using [[Rigidbody.AddForce]].

Add a continuous acceleration to the rigidbody, ignoring its mass.

Add a continuous force to the rigidbody, using its mass.

Add an instant force impulse to the rigidbody, using its mass.

Add an instant velocity change to the rigidbody, ignoring its mass.

Option for how to apply a force using [[Rigidbody2D.AddForce]].

Add a force to the Rigidbody2D, using its mass.

Add an instant force impulse to the rigidbody2D, using its mass.

Base class for all entities in Unity scenes.

Is the GameObject active in the scene?

The local active state of this GameObject. (RO)

Editor only API that specifies if a game object is static.

The layer the game object is in. A layer is in the range [0...31].

The tag of this game object.

The [[Transform]] attached to this GameObject. (null if there is none attached).

Adds a component class named /className/ to the game object.

Adds a component class of type /componentType/ to the game object. C# Users can use a generic version.

Generic version. See the [[wiki:Generic Functions|Generic Functions]] page for more details.

Calls the method named /methodName/ on every [[MonoBehaviour]] in this game object or any of its children.

Is this game object tagged with /tag/ ?

The tag to compare.

Creates a game object with a primitive mesh renderer and appropriate collider.

The type of primitive object to create.

Creates a new game object, named __name__.

Creates a new game object.

Creates a game object and attaches the specified components.

Finds a game object by /name/ and returns it.

Returns a list of active GameObjects tagged /tag/. Returns empty array if no GameObject was found.

The name of the tag to search @@GameObjects@@ for.

Returns one active [[GameObject]] tagged /tag/. Returns @@null@@ if no GameObject was found.

The tag to search for.

Returns the component of Type /type/ if the game object has one attached, null if it doesn't.

The type of Component to retrieve.

Generic version. See the [[wiki:Generic Functions|Generic Functions]] page for more details.

Returns the component with name /type/ if the game object has one attached, null if it doesn't.

The type of Component to retrieve.

Returns the component of Type /type/ in the GameObject or any of its children using depth first search.

The type of Component to retrieve.

Generic version. See the [[wiki:Generic Functions|Generic Functions]] page for more details.

Finds component in the parent.

Type of component to find.

Finds component in the parent.

Returns all components of Type /type/ in the GameObject.

The type of Component to retrieve.

Generic version. See the [[wiki:Generic Functions|Generic Functions]] page for more details.

Returns all components of Type /type/ in the GameObject or any of its children.

The type of Component to retrieve. Should Components on inactive GameObjects be included in the found set?

Returns all components of Type /type/ in the GameObject or any of its children.

The type of Component to retrieve. Should Components on inactive GameObjects be included in the found set?

Generic version. See the [[wiki:Generic Functions|Generic Functions]] page for more details.

Should inactive Components be included in the found set?

Generic version. See the [[wiki:Generic Functions|Generic Functions]] page for more details.

Returns all components of Type /type/ in the GameObject or any of its parents.

The type of Component to retrieve. Should inactive Components be included in the found set?

Generic version. See the [[wiki:Generic Functions|Generic Functions]] page for more details.

Should inactive Components be included in the found set?

Generic version. See the [[wiki:Generic Functions|Generic Functions]] page for more details.

Should inactive Components be included in the found set?

Calls the method named /methodName/ on every [[MonoBehaviour]] in this game object.

The name of the method to call. An optional parameter value to pass to the called method. Should an error be raised if the method doesn't exist on the target object?