Unity3D核心类型一览

爱被打了一巴掌 2022-08-20 05:07 318阅读 0赞

原文 [http://www.cnblogs.com/bitzhuwei/p/unity-core-types.html][http_www.cnblogs.com_bitzhuwei_p_unity-core-types.html]

主题 [Unity3D][]

#### Unity3D核心类型一览 ####

![eAFFZn3.png_web][]

本文记录了Unity3D的最基本的核心类型。包括Object、GameObject、Component、Transform、Behaviour、Renderer、Collider、Rigidbody、Camera、Light、MonoBehaviour等。

## UnityEngine.Object ##

![7JJJry.gif_web][]

1 namespace UnityEngine
      2 {
      3     using System;
      4     using System.Runtime.CompilerServices;
      5     using System.Runtime.InteropServices;
      6     using UnityEngine.Internal;
      7     using UnityEngineInternal;
      8 
      9     [StructLayout(LayoutKind.Sequential)]
     10     public class Object
     11     {
     12         private ReferenceData m_UnityRuntimeReferenceData;
     13         private string m_UnityRuntimeErrorString;
     14         public override bool Equals(object o)
     15         {
     16             return CompareBaseObjects(this, o as UnityEngine.Object);
     17         }
     18 
     19         public override int GetHashCode()
     20         {
     21             return this.GetInstanceID();
     22         }
     23 
     24         private static bool CompareBaseObjects(UnityEngine.Object lhs, UnityEngine.Object rhs)
     25         {
     26             return CompareBaseObjectsInternal(lhs, rhs);
     27         }
     28 
     29         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     30         private static extern bool CompareBaseObjectsInternal([Writable] UnityEngine.Object lhs, [Writable] UnityEngine.Object rhs);
     31         [NotRenamed]
     32         public int GetInstanceID()
     33         {
     34             return this.m_UnityRuntimeReferenceData.instanceID;
     35         }
     36 
     37         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     38         private static extern UnityEngine.Object Internal_CloneSingle(UnityEngine.Object data);
     39         private static UnityEngine.Object Internal_InstantiateSingle(UnityEngine.Object data, Vector3 pos, Quaternion rot)
     40         {
     41             return INTERNAL_CALL_Internal_InstantiateSingle(data, ref pos, ref rot);
     42         }
     43 
     44         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     45         private static extern UnityEngine.Object INTERNAL_CALL_Internal_InstantiateSingle(UnityEngine.Object data, ref Vector3 pos, ref Quaternion rot);
     46         [TypeInferenceRule(TypeInferenceRules.TypeOfFirstArgument)]
     47         public static UnityEngine.Object Instantiate(UnityEngine.Object original, Vector3 position, Quaternion rotation)
     48         {
     49             CheckNullArgument(original, "The prefab you want to instantiate is null.");
     50             return Internal_InstantiateSingle(original, position, rotation);
     51         }
     52 
     53         [TypeInferenceRule(TypeInferenceRules.TypeOfFirstArgument)]
     54         public static UnityEngine.Object Instantiate(UnityEngine.Object original)
     55         {
     56             CheckNullArgument(original, "The thing you want to instantiate is null.");
     57             return Internal_CloneSingle(original);
     58         }
     59 
     60         private static void CheckNullArgument(object arg, string message)
     61         {
     62             if (arg == null)
     63             {
     64                 throw new ArgumentException(message);
     65             }
     66         }
     67 
     68         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     69         public static extern void Destroy(UnityEngine.Object obj, [DefaultValue("0.0F")] float t);
     70         [ExcludeFromDocs]
     71         public static void Destroy(UnityEngine.Object obj)
     72         {
     73             float t = 0f;
     74             Destroy(obj, t);
     75         }
     76 
     77         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     78         public static extern void DestroyImmediate(UnityEngine.Object obj, [DefaultValue("false")] bool allowDestroyingAssets);
     79         [ExcludeFromDocs]
     80         public static void DestroyImmediate(UnityEngine.Object obj)
     81         {
     82             bool allowDestroyingAssets = false;
     83             DestroyImmediate(obj, allowDestroyingAssets);
     84         }
     85 
     86         [MethodImpl(MethodImplOptions.InternalCall), TypeInferenceRule(TypeInferenceRules.ArrayOfTypeReferencedByFirstArgument), WrapperlessIcall]
     87         public static extern UnityEngine.Object[] FindObjectsOfType(System.Type type);
     88         public static T[] FindObjectsOfType<T>() where T: UnityEngine.Object
     89         {
     90             return Resources.ConvertObjects<T>(FindObjectsOfType(typeof(T)));
     91         }
     92 
     93         [TypeInferenceRule(TypeInferenceRules.TypeReferencedByFirstArgument)]
     94         public static UnityEngine.Object FindObjectOfType(System.Type type)
     95         {
     96             UnityEngine.Object[] objArray = FindObjectsOfType(type);
     97             if (objArray.Length > 0)
     98             {
     99                 return objArray[0];
    100             }
    101             return null;
    102         }
    103 
    104         public static T FindObjectOfType<T>() where T: UnityEngine.Object
    105         {
    106             return (T) FindObjectOfType(typeof(T));
    107         }
    108 
    109         public string name { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    110         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    111         public static extern void DontDestroyOnLoad(UnityEngine.Object target);
    112         public HideFlags hideFlags { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    113         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    114         public static extern void DestroyObject(UnityEngine.Object obj, [DefaultValue("0.0F")] float t);
    115         [ExcludeFromDocs]
    116         public static void DestroyObject(UnityEngine.Object obj)
    117         {
    118             float t = 0f;
    119             DestroyObject(obj, t);
    120         }
    121 
    122         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall, Obsolete("use Object.FindObjectsOfType instead.")]
    123         public static extern UnityEngine.Object[] FindSceneObjectsOfType(System.Type type);
    124         [MethodImpl(MethodImplOptions.InternalCall), Obsolete("use Resources.FindObjectsOfTypeAll instead."), WrapperlessIcall]
    125         public static extern UnityEngine.Object[] FindObjectsOfTypeIncludingAssets(System.Type type);
    126         [Obsolete("Please use Resources.FindObjectsOfTypeAll instead")]
    127         public static UnityEngine.Object[] FindObjectsOfTypeAll(System.Type type)
    128         {
    129             return Resources.FindObjectsOfTypeAll(type);
    130         }
    131 
    132         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    133         public override extern string ToString();
    134         public static implicit operator bool(UnityEngine.Object exists)
    135         {
    136             return !CompareBaseObjects(exists, null);
    137         }
    138 
    139         public static bool operator ==(UnityEngine.Object x, UnityEngine.Object y)
    140         {
    141             return CompareBaseObjects(x, y);
    142         }
    143 
    144         public static bool operator !=(UnityEngine.Object x, UnityEngine.Object y)
    145         {
    146             return !CompareBaseObjects(x, y);
    147         }
    148     }
    149 }

## UnityEngine.GameObject ##

![7JJJry.gif_web][]

1 namespace UnityEngine
      2 {
      3     using System;
      4     using System.Collections;
      5     using System.Collections.Generic;
      6     using System.Runtime.CompilerServices;
      7     using UnityEngine.Internal;
      8     using UnityEngineInternal;
      9 
     10     public sealed class GameObject : UnityEngine.Object
     11     {
     12         public GameObject()
     13         {
     14             Internal_CreateGameObject(this, null);
     15         }
     16 
     17         public GameObject(string name)
     18         {
     19             Internal_CreateGameObject(this, name);
     20         }
     21 
     22         public GameObject(string name, params System.Type[] components)
     23         {
     24             Internal_CreateGameObject(this, name);
     25             foreach (System.Type type in components)
     26             {
     27                 this.AddComponent(type);
     28             }
     29         }
     30 
     31         public T AddComponent<T>() where T: Component
     32         {
     33             return (this.AddComponent(typeof(T)) as T);
     34         }
     35 
     36         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     37         public extern Component AddComponent(string className);
     38         [TypeInferenceRule(TypeInferenceRules.TypeReferencedByFirstArgument)]
     39         public Component AddComponent(System.Type componentType)
     40         {
     41             return this.Internal_AddComponentWithType(componentType);
     42         }
     43 
     44         [ExcludeFromDocs]
     45         public void BroadcastMessage(string methodName)
     46         {
     47             SendMessageOptions requireReceiver = SendMessageOptions.RequireReceiver;
     48             object parameter = null;
     49             this.BroadcastMessage(methodName, parameter, requireReceiver);
     50         }
     51 
     52         [ExcludeFromDocs]
     53         public void BroadcastMessage(string methodName, object parameter)
     54         {
     55             SendMessageOptions requireReceiver = SendMessageOptions.RequireReceiver;
     56             this.BroadcastMessage(methodName, parameter, requireReceiver);
     57         }
     58 
     59         public void BroadcastMessage(string methodName, SendMessageOptions options)
     60         {
     61             this.BroadcastMessage(methodName, null, options);
     62         }
     63 
     64         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     65         public extern void BroadcastMessage(string methodName, [DefaultValue("null")] object parameter, [DefaultValue("SendMessageOptions.RequireReceiver")] SendMessageOptions options);
     66         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     67         public extern bool CompareTag(string tag);
     68         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     69         public static extern GameObject CreatePrimitive(PrimitiveType type);
     70         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     71         public static extern GameObject Find(string name);
     72         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     73         public static extern GameObject[] FindGameObjectsWithTag(string tag);
     74         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     75         public static extern GameObject FindGameObjectWithTag(string tag);
     76         public static GameObject FindWithTag(string tag)
     77         {
     78             return FindGameObjectWithTag(tag);
     79         }
     80 
     81         public T GetComponent<T>() where T: Component
     82         {
     83             return (this.GetComponent(typeof(T)) as T);
     84         }
     85 
     86         public Component GetComponent(string type)
     87         {
     88             return this.GetComponentByName(type);
     89         }
     90 
     91         [MethodImpl(MethodImplOptions.InternalCall), TypeInferenceRule(TypeInferenceRules.TypeReferencedByFirstArgument), WrapperlessIcall]
     92         public extern Component GetComponent(System.Type type);
     93         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     94         private extern Component GetComponentByName(string type);
     95         public T GetComponentInChildren<T>() where T: Component
     96         {
     97             return (this.GetComponentInChildren(typeof(T)) as T);
     98         }
     99 
    100         [TypeInferenceRule(TypeInferenceRules.TypeReferencedByFirstArgument)]
    101         public Component GetComponentInChildren(System.Type type)
    102         {
    103             if (this.activeInHierarchy)
    104             {
    105                 Component component = this.GetComponent(type);
    106                 if (component != null)
    107                 {
    108                     return component;
    109                 }
    110             }
    111             Transform transform = this.transform;
    112             if (transform != null)
    113             {
    114                 IEnumerator enumerator = transform.GetEnumerator();
    115                 try
    116                 {
    117                     while (enumerator.MoveNext())
    118                     {
    119                         Transform current = (Transform) enumerator.Current;
    120                         Component componentInChildren = current.gameObject.GetComponentInChildren(type);
    121                         if (componentInChildren != null)
    122                         {
    123                             return componentInChildren;
    124                         }
    125                     }
    126                 }
    127                 finally
    128                 {
    129                     IDisposable disposable = enumerator as IDisposable;
    130                     if (disposable == null)
    131                     {
    132                     }
    133                     disposable.Dispose();
    134                 }
    135             }
    136             return null;
    137         }
    138 
    139         public T GetComponentInParent<T>() where T: Component
    140         {
    141             return (this.GetComponentInParent(typeof(T)) as T);
    142         }
    143 
    144         [TypeInferenceRule(TypeInferenceRules.TypeReferencedByFirstArgument)]
    145         public Component GetComponentInParent(System.Type type)
    146         {
    147             if (this.activeInHierarchy)
    148             {
    149                 Component component = this.GetComponent(type);
    150                 if (component != null)
    151                 {
    152                     return component;
    153                 }
    154             }
    155             Transform parent = this.transform.parent;
    156             if (parent != null)
    157             {
    158                 while (parent != null)
    159                 {
    160                     if (parent.gameObject.activeInHierarchy)
    161                     {
    162                         Component component2 = parent.gameObject.GetComponent(type);
    163                         if (component2 != null)
    164                         {
    165                             return component2;
    166                         }
    167                     }
    168                     parent = parent.parent;
    169                 }
    170             }
    171             return null;
    172         }
    173 
    174         public T[] GetComponents<T>() where T: Component
    175         {
    176             return (T[]) this.GetComponentsInternal(typeof(T), true, false, true, false);
    177         }
    178 
    179         public void GetComponents<T>(List<T> results) where T: Component
    180         {
    181             this.GetComponentsForListInternal(typeof(T), typeof(T), false, true, false, results);
    182         }
    183 
    184         [CanConvertToFlash]
    185         public Component[] GetComponents(System.Type type)
    186         {
    187             return this.GetComponentsInternal(type, false, false, true, false);
    188         }
    189 
    190         public void GetComponents(System.Type type, List<Component> results)
    191         {
    192             this.GetComponentsForListInternal(type, typeof(Component), false, true, false, results);
    193         }
    194 
    195         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    196         private extern void GetComponentsForListInternal(System.Type searchType, System.Type listElementType, bool recursive, bool includeInactive, bool reverse, object resultList);
    197         public T[] GetComponentsInChildren<T>() where T: Component
    198         {
    199             return this.GetComponentsInChildren<T>(false);
    200         }
    201 
    202         public T[] GetComponentsInChildren<T>(bool includeInactive) where T: Component
    203         {
    204             return (T[]) this.GetComponentsInternal(typeof(T), true, true, includeInactive, false);
    205         }
    206 
    207         [ExcludeFromDocs]
    208         public Component[] GetComponentsInChildren(System.Type type)
    209         {
    210             bool includeInactive = false;
    211             return this.GetComponentsInChildren(type, includeInactive);
    212         }
    213 
    214         public void GetComponentsInChildren<T>(List<T> results) where T: Component
    215         {
    216             this.GetComponentsInChildren<T>(false, results);
    217         }
    218 
    219         public void GetComponentsInChildren<T>(bool includeInactive, List<T> results) where T: Component
    220         {
    221             this.GetComponentsForListInternal(typeof(T), typeof(T), true, includeInactive, false, results);
    222         }
    223 
    224         public Component[] GetComponentsInChildren(System.Type type, [DefaultValue("false")] bool includeInactive)
    225         {
    226             return this.GetComponentsInternal(type, false, true, includeInactive, false);
    227         }
    228 
    229         public T[] GetComponentsInParent<T>() where T: Component
    230         {
    231             return this.GetComponentsInParent<T>(false);
    232         }
    233 
    234         public T[] GetComponentsInParent<T>(bool includeInactive) where T: Component
    235         {
    236             return (T[]) this.GetComponentsInternal(typeof(T), true, true, includeInactive, true);
    237         }
    238 
    239         [ExcludeFromDocs]
    240         public Component[] GetComponentsInParent(System.Type type)
    241         {
    242             bool includeInactive = false;
    243             return this.GetComponentsInParent(type, includeInactive);
    244         }
    245 
    246         public void GetComponentsInParent<T>(bool includeInactive, List<T> results) where T: Component
    247         {
    248             this.GetComponentsForListInternal(typeof(T), typeof(T), true, includeInactive, true, results);
    249         }
    250 
    251         public Component[] GetComponentsInParent(System.Type type, [DefaultValue("false")] bool includeInactive)
    252         {
    253             return this.GetComponentsInternal(type, false, true, includeInactive, true);
    254         }
    255 
    256         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    257         private extern Component[] GetComponentsInternal(System.Type type, bool isGenericTypeArray, bool recursive, bool includeInactive, bool reverse);
    258         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    259         private extern Component Internal_AddComponentWithType(System.Type componentType);
    260         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    261         private static extern void Internal_CreateGameObject([Writable] GameObject mono, string name);
    262         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall, Obsolete("gameObject.PlayAnimation is not supported anymore. Use animation.Play")]
    263         public extern void PlayAnimation(AnimationClip animation);
    264         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    265         public extern void SampleAnimation(AnimationClip animation, float time);
    266         [ExcludeFromDocs]
    267         public void SendMessage(string methodName)
    268         {
    269             SendMessageOptions requireReceiver = SendMessageOptions.RequireReceiver;
    270             object obj2 = null;
    271             this.SendMessage(methodName, obj2, requireReceiver);
    272         }
    273 
    274         [ExcludeFromDocs]
    275         public void SendMessage(string methodName, object value)
    276         {
    277             SendMessageOptions requireReceiver = SendMessageOptions.RequireReceiver;
    278             this.SendMessage(methodName, value, requireReceiver);
    279         }
    280 
    281         public void SendMessage(string methodName, SendMessageOptions options)
    282         {
    283             this.SendMessage(methodName, null, options);
    284         }
    285 
    286         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    287         public extern void SendMessage(string methodName, [DefaultValue("null")] object value, [DefaultValue("SendMessageOptions.RequireReceiver")] SendMessageOptions options);
    288         [ExcludeFromDocs]
    289         public void SendMessageUpwards(string methodName)
    290         {
    291             SendMessageOptions requireReceiver = SendMessageOptions.RequireReceiver;
    292             object obj2 = null;
    293             this.SendMessageUpwards(methodName, obj2, requireReceiver);
    294         }
    295 
    296         [ExcludeFromDocs]
    297         public void SendMessageUpwards(string methodName, object value)
    298         {
    299             SendMessageOptions requireReceiver = SendMessageOptions.RequireReceiver;
    300             this.SendMessageUpwards(methodName, value, requireReceiver);
    301         }
    302 
    303         public void SendMessageUpwards(string methodName, SendMessageOptions options)
    304         {
    305             this.SendMessageUpwards(methodName, null, options);
    306         }
    307 
    308         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    309         public extern void SendMessageUpwards(string methodName, [DefaultValue("null")] object value, [DefaultValue("SendMessageOptions.RequireReceiver")] SendMessageOptions options);
    310         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    311         public extern void SetActive(bool value);
    312         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall, Obsolete("gameObject.SetActiveRecursively() is obsolete. Use GameObject.SetActive(), which is now inherited by children.")]
    313         public extern void SetActiveRecursively(bool state);
    314         [MethodImpl(MethodImplOptions.InternalCall), Obsolete("gameObject.StopAnimation is not supported anymore. Use animation.Stop"), WrapperlessIcall]
    315         public extern void StopAnimation();
    316 
    317         [Obsolete("GameObject.active is obsolete. Use GameObject.SetActive(), GameObject.activeSelf or GameObject.activeInHierarchy.")]
    318         public bool active { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    319 
    320         public bool activeInHierarchy { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    321 
    322         public bool activeSelf { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    323 
    324         public Animation animation { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    325 
    326         public AudioSource audio { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    327 
    328         public Camera camera { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    329 
    330         public Collider collider { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    331 
    332         public Collider2D collider2D { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    333 
    334         public ConstantForce constantForce { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    335 
    336         public GameObject gameObject
    337         {
    338             get
    339             {
    340                 return this;
    341             }
    342         }
    343 
    344         [Obsolete("Please use guiTexture instead")]
    345         public GUIElement guiElement { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    346 
    347         public GUIText guiText { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    348 
    349         public GUITexture guiTexture { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    350 
    351         public HingeJoint hingeJoint { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    352 
    353         public bool isStatic { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    354 
    355         internal bool isStaticBatchable { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    356 
    357         public int layer { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    358 
    359         public Light light { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    360 
    361         public NetworkView networkView { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    362 
    363         public ParticleEmitter particleEmitter { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    364 
    365         public ParticleSystem particleSystem { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    366 
    367         public Renderer renderer { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    368 
    369         public Rigidbody rigidbody { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    370 
    371         public Rigidbody2D rigidbody2D { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    372 
    373         public string tag { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    374 
    375         public Transform transform { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    376     }
    377 }

## UnityEngine.Component ##

![7JJJry.gif_web][]

1 namespace UnityEngine
      2 {
      3     using System;
      4     using System.Collections.Generic;
      5     using System.Runtime.CompilerServices;
      6     using UnityEngine.Internal;
      7     using UnityEngineInternal;
      8 
      9     public class Component : UnityEngine.Object
     10     {
     11         [ExcludeFromDocs]
     12         public void BroadcastMessage(string methodName)
     13         {
     14             SendMessageOptions requireReceiver = SendMessageOptions.RequireReceiver;
     15             object parameter = null;
     16             this.BroadcastMessage(methodName, parameter, requireReceiver);
     17         }
     18 
     19         [ExcludeFromDocs]
     20         public void BroadcastMessage(string methodName, object parameter)
     21         {
     22             SendMessageOptions requireReceiver = SendMessageOptions.RequireReceiver;
     23             this.BroadcastMessage(methodName, parameter, requireReceiver);
     24         }
     25 
     26         public void BroadcastMessage(string methodName, SendMessageOptions options)
     27         {
     28             this.BroadcastMessage(methodName, null, options);
     29         }
     30 
     31         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     32         public extern void BroadcastMessage(string methodName, [DefaultValue("null")] object parameter, [DefaultValue("SendMessageOptions.RequireReceiver")] SendMessageOptions options);
     33         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     34         public extern bool CompareTag(string tag);
     35         public T GetComponent<T>() where T: Component
     36         {
     37             return (this.GetComponent(typeof(T)) as T);
     38         }
     39 
     40         public Component GetComponent(string type)
     41         {
     42             return this.gameObject.GetComponent(type);
     43         }
     44 
     45         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall, TypeInferenceRule(TypeInferenceRules.TypeReferencedByFirstArgument)]
     46         public extern Component GetComponent(System.Type type);
     47         public T GetComponentInChildren<T>() where T: Component
     48         {
     49             return (T) this.GetComponentInChildren(typeof(T));
     50         }
     51 
     52         [TypeInferenceRule(TypeInferenceRules.TypeReferencedByFirstArgument)]
     53         public Component GetComponentInChildren(System.Type t)
     54         {
     55             return this.gameObject.GetComponentInChildren(t);
     56         }
     57 
     58         public T GetComponentInParent<T>() where T: Component
     59         {
     60             return (T) this.GetComponentInParent(typeof(T));
     61         }
     62 
     63         [TypeInferenceRule(TypeInferenceRules.TypeReferencedByFirstArgument)]
     64         public Component GetComponentInParent(System.Type t)
     65         {
     66             return this.gameObject.GetComponentInParent(t);
     67         }
     68 
     69         public T[] GetComponents<T>() where T: Component
     70         {
     71             return (T[]) this.GetComponentsWithCorrectReturnType(typeof(T));
     72         }
     73 
     74         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     75         public extern Component[] GetComponents(System.Type type);
     76         public void GetComponents<T>(List<T> results) where T: Component
     77         {
     78             this.GetComponentsForListInternal(typeof(T), typeof(T), false, true, results);
     79         }
     80 
     81         public void GetComponents(System.Type type, List<Component> results)
     82         {
     83             this.GetComponentsForListInternal(type, typeof(Component), false, true, results);
     84         }
     85 
     86         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     87         private extern void GetComponentsForListInternal(System.Type searchType, System.Type listElementType, bool recursive, bool includeInactive, object resultList);
     88         public T[] GetComponentsInChildren<T>() where T: Component
     89         {
     90             return this.GetComponentsInChildren<T>(false);
     91         }
     92 
     93         public T[] GetComponentsInChildren<T>(bool includeInactive) where T: Component
     94         {
     95             return this.gameObject.GetComponentsInChildren<T>(includeInactive);
     96         }
     97 
     98         public void GetComponentsInChildren<T>(List<T> results) where T: Component
     99         {
    100             this.GetComponentsInChildren<T>(false, results);
    101         }
    102 
    103         [ExcludeFromDocs]
    104         public Component[] GetComponentsInChildren(System.Type t)
    105         {
    106             bool includeInactive = false;
    107             return this.GetComponentsInChildren(t, includeInactive);
    108         }
    109 
    110         public void GetComponentsInChildren<T>(bool includeInactive, List<T> result) where T: Component
    111         {
    112             this.gameObject.GetComponentsInChildren<T>(includeInactive, result);
    113         }
    114 
    115         public Component[] GetComponentsInChildren(System.Type t, [DefaultValue("false")] bool includeInactive)
    116         {
    117             return this.gameObject.GetComponentsInChildren(t, includeInactive);
    118         }
    119 
    120         public T[] GetComponentsInParent<T>() where T: Component
    121         {
    122             return this.GetComponentsInParent<T>(false);
    123         }
    124 
    125         public T[] GetComponentsInParent<T>(bool includeInactive) where T: Component
    126         {
    127             return this.gameObject.GetComponentsInParent<T>(includeInactive);
    128         }
    129 
    130         [ExcludeFromDocs]
    131         public Component[] GetComponentsInParent(System.Type t)
    132         {
    133             bool includeInactive = false;
    134             return this.GetComponentsInParent(t, includeInactive);
    135         }
    136 
    137         public Component[] GetComponentsInParent(System.Type t, [DefaultValue("false")] bool includeInactive)
    138         {
    139             return this.gameObject.GetComponentsInParent(t, includeInactive);
    140         }
    141 
    142         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    143         private extern Component[] GetComponentsWithCorrectReturnType(System.Type type);
    144         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    145         internal extern GameObject InternalGetGameObject();
    146         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    147         internal extern Transform InternalGetTransform();
    148         [ExcludeFromDocs]
    149         public void SendMessage(string methodName)
    150         {
    151             SendMessageOptions requireReceiver = SendMessageOptions.RequireReceiver;
    152             object obj2 = null;
    153             this.SendMessage(methodName, obj2, requireReceiver);
    154         }
    155 
    156         [ExcludeFromDocs]
    157         public void SendMessage(string methodName, object value)
    158         {
    159             SendMessageOptions requireReceiver = SendMessageOptions.RequireReceiver;
    160             this.SendMessage(methodName, value, requireReceiver);
    161         }
    162 
    163         public void SendMessage(string methodName, SendMessageOptions options)
    164         {
    165             this.SendMessage(methodName, null, options);
    166         }
    167 
    168         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    169         public extern void SendMessage(string methodName, [DefaultValue("null")] object value, [DefaultValue("SendMessageOptions.RequireReceiver")] SendMessageOptions options);
    170         [ExcludeFromDocs]
    171         public void SendMessageUpwards(string methodName)
    172         {
    173             SendMessageOptions requireReceiver = SendMessageOptions.RequireReceiver;
    174             object obj2 = null;
    175             this.SendMessageUpwards(methodName, obj2, requireReceiver);
    176         }
    177 
    178         [ExcludeFromDocs]
    179         public void SendMessageUpwards(string methodName, object value)
    180         {
    181             SendMessageOptions requireReceiver = SendMessageOptions.RequireReceiver;
    182             this.SendMessageUpwards(methodName, value, requireReceiver);
    183         }
    184 
    185         public void SendMessageUpwards(string methodName, SendMessageOptions options)
    186         {
    187             this.SendMessageUpwards(methodName, null, options);
    188         }
    189 
    190         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    191         public extern void SendMessageUpwards(string methodName, [DefaultValue("null")] object value, [DefaultValue("SendMessageOptions.RequireReceiver")] SendMessageOptions options);
    192 
    193         [Obsolete("the active property is deprecated on components. Please use gameObject.active instead. If you meant to enable / disable a single component use enabled instead.")]
    194         public bool active { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    195 
    196         public Animation animation { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    197 
    198         public AudioSource audio { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    199 
    200         public Camera camera { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    201 
    202         public Collider collider { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    203 
    204         public Collider2D collider2D { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    205 
    206         public ConstantForce constantForce { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    207 
    208         public GameObject gameObject
    209         {
    210             get
    211             {
    212                 return this.InternalGetGameObject();
    213             }
    214         }
    215 
    216         [Obsolete("Please use guiTexture instead")]
    217         public GUIElement guiElement { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    218 
    219         public GUIText guiText { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    220 
    221         public GUITexture guiTexture { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    222 
    223         public HingeJoint hingeJoint { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    224 
    225         public Light light { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    226 
    227         public NetworkView networkView { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    228 
    229         public ParticleEmitter particleEmitter { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    230 
    231         public ParticleSystem particleSystem { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    232 
    233         public Renderer renderer { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    234 
    235         public Rigidbody rigidbody { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    236 
    237         public Rigidbody2D rigidbody2D { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    238 
    239         public string tag { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    240 
    241         public Transform transform
    242         {
    243             get
    244             {
    245                 return this.InternalGetTransform();
    246             }
    247         }
    248     }
    249 }

## UnityEngine.Texture ##

![7JJJry.gif_web][]

1 namespace UnityEngine
     2 {
     3     using System;
     4     using System.Runtime.CompilerServices;
     5     using System.Runtime.InteropServices;
     6 
     7     public class Texture : UnityEngine.Object
     8     {
     9         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    10         public extern int GetNativeTextureID();
    11         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    12         public extern IntPtr GetNativeTexturePtr();
    13         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    14         private static extern int Internal_GetHeight(Texture mono);
    15         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    16         private static extern void Internal_GetTexelSize(Texture tex, out Vector2 output);
    17         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    18         private static extern int Internal_GetWidth(Texture mono);
    19         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    20         public static extern void SetGlobalAnisotropicFilteringLimits(int forcedMin, int globalMax);
    21 
    22         public int anisoLevel { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    23 
    24         public static AnisotropicFiltering anisotropicFiltering { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    25 
    26         public FilterMode filterMode { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    27 
    28         public virtual int height
    29         {
    30             get
    31             {
    32                 return Internal_GetHeight(this);
    33             }
    34             set
    35             {
    36                 throw new Exception("not implemented");
    37             }
    38         }
    39 
    40         public static int masterTextureLimit { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    41 
    42         public float mipMapBias { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    43 
    44         public Vector2 texelSize
    45         {
    46             get
    47             {
    48                 Vector2 vector;
    49                 Internal_GetTexelSize(this, out vector);
    50                 return vector;
    51             }
    52         }
    53 
    54         public virtual int width
    55         {
    56             get
    57             {
    58                 return Internal_GetWidth(this);
    59             }
    60             set
    61             {
    62                 throw new Exception("not implemented");
    63             }
    64         }
    65 
    66         public TextureWrapMode wrapMode { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    67     }
    68 }

## UnityEngine.Mesh ##

![7JJJry.gif_web][]

1 namespace UnityEngine
      2 {
      3     using System;
      4     using System.Runtime.CompilerServices;
      5     using System.Runtime.InteropServices;
      6     using UnityEngine.Internal;
      7 
      8     public sealed class Mesh : UnityEngine.Object
      9     {
     10         public Mesh()
     11         {
     12             Internal_Create(this);
     13         }
     14 
     15         [ExcludeFromDocs]
     16         public void Clear()
     17         {
     18             bool keepVertexLayout = true;
     19             this.Clear(keepVertexLayout);
     20         }
     21 
     22         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     23         public extern void Clear([DefaultValue("true")] bool keepVertexLayout);
     24         [ExcludeFromDocs]
     25         public void CombineMeshes(CombineInstance[] combine)
     26         {
     27             bool useMatrices = true;
     28             bool mergeSubMeshes = true;
     29             this.CombineMeshes(combine, mergeSubMeshes, useMatrices);
     30         }
     31 
     32         [ExcludeFromDocs]
     33         public void CombineMeshes(CombineInstance[] combine, bool mergeSubMeshes)
     34         {
     35             bool useMatrices = true;
     36             this.CombineMeshes(combine, mergeSubMeshes, useMatrices);
     37         }
     38 
     39         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     40         public extern void CombineMeshes(CombineInstance[] combine, [DefaultValue("true")] bool mergeSubMeshes, [DefaultValue("true")] bool useMatrices);
     41         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     42         public extern int GetBlendShapeIndex(string blendShapeName);
     43         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     44         public extern string GetBlendShapeName(int index);
     45         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     46         public extern int[] GetIndices(int submesh);
     47         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     48         public extern MeshTopology GetTopology(int submesh);
     49         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     50         public extern int[] GetTriangles(int submesh);
     51         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall, Obsolete("Use GetTriangles instead. Internally this function converts a list of triangles to a strip, so it might be slow, it might be a mess.")]
     52         public extern int[] GetTriangleStrip(int submesh);
     53         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     54         private static extern void Internal_Create([Writable] Mesh mono);
     55         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     56         private extern void INTERNAL_get_bounds(out Bounds value);
     57         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     58         private extern void INTERNAL_set_bounds(ref Bounds value);
     59         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     60         public extern void MarkDynamic();
     61         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     62         public extern void Optimize();
     63         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     64         public extern void RecalculateBounds();
     65         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     66         public extern void RecalculateNormals();
     67         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     68         public extern void SetIndices(int[] indices, MeshTopology topology, int submesh);
     69         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     70         public extern void SetTriangles(int[] triangles, int submesh);
     71         [MethodImpl(MethodImplOptions.InternalCall), Obsolete("Use SetTriangles instead. Internally this function will convert the triangle strip to a list of triangles anyway."), WrapperlessIcall]
     72         public extern void SetTriangleStrip(int[] triangles, int submesh);
     73         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     74         public extern void UploadMeshData(bool markNoLogerReadable);
     75 
     76         public Matrix4x4[] bindposes { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
     77 
     78         public int blendShapeCount { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
     79 
     80         public BoneWeight[] boneWeights { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
     81 
     82         public Bounds bounds
     83         {
     84             get
     85             {
     86                 Bounds bounds;
     87                 this.INTERNAL_get_bounds(out bounds);
     88                 return bounds;
     89             }
     90             set
     91             {
     92                 this.INTERNAL_set_bounds(ref value);
     93             }
     94         }
     95 
     96         internal bool canAccess { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
     97 
     98         public Color[] colors { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
     99 
    100         public Color32[] colors32 { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    101 
    102         public bool isReadable { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    103 
    104         public Vector3[] normals { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    105 
    106         public int subMeshCount { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    107 
    108         public Vector4[] tangents { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    109 
    110         public int[] triangles { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    111 
    112         public Vector2[] uv { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    113 
    114         public Vector2[] uv1
    115         {
    116             get
    117             {
    118                 return this.uv2;
    119             }
    120             set
    121             {
    122                 this.uv2 = value;
    123             }
    124         }
    125 
    126         public Vector2[] uv2 { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    127 
    128         public int vertexCount { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    129 
    130         public Vector3[] vertices { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    131     }
    132 }

## UnityEngine.Material ##

![7JJJry.gif_web][]

1 namespace UnityEngine
      2 {
      3     using System;
      4     using System.Runtime.CompilerServices;
      5     using System.Runtime.InteropServices;
      6     using UnityEngine.Internal;
      7 
      8     public class Material : UnityEngine.Object
      9     {
     10         public Material(string contents)
     11         {
     12             Internal_CreateWithString(this, contents);
     13         }
     14 
     15         public Material(Material source)
     16         {
     17             Internal_CreateWithMaterial(this, source);
     18         }
     19 
     20         public Material(Shader shader)
     21         {
     22             Internal_CreateWithShader(this, shader);
     23         }
     24 
     25         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     26         public extern void CopyPropertiesFromMaterial(Material mat);
     27         [Obsolete("Use the Material constructor instead.")]
     28         public static Material Create(string scriptContents)
     29         {
     30             return new Material(scriptContents);
     31         }
     32 
     33         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     34         public extern void DisableKeyword(string keyword);
     35         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     36         public extern void EnableKeyword(string keyword);
     37         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     38         public extern Color GetColor(int nameID);
     39         public Color GetColor(string propertyName)
     40         {
     41             return this.GetColor(Shader.PropertyToID(propertyName));
     42         }
     43 
     44         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     45         public extern float GetFloat(int nameID);
     46         public float GetFloat(string propertyName)
     47         {
     48             return this.GetFloat(Shader.PropertyToID(propertyName));
     49         }
     50 
     51         public int GetInt(int nameID)
     52         {
     53             return (int) this.GetFloat(nameID);
     54         }
     55 
     56         public int GetInt(string propertyName)
     57         {
     58             return (int) this.GetFloat(propertyName);
     59         }
     60 
     61         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     62         public extern Matrix4x4 GetMatrix(int nameID);
     63         public Matrix4x4 GetMatrix(string propertyName)
     64         {
     65             return this.GetMatrix(Shader.PropertyToID(propertyName));
     66         }
     67 
     68         [ExcludeFromDocs]
     69         public string GetTag(string tag, bool searchFallbacks)
     70         {
     71             string defaultValue = string.Empty;
     72             return this.GetTag(tag, searchFallbacks, defaultValue);
     73         }
     74 
     75         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     76         public extern string GetTag(string tag, bool searchFallbacks, [DefaultValue("\"\"")] string defaultValue);
     77         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     78         public extern Texture GetTexture(int nameID);
     79         public Texture GetTexture(string propertyName)
     80         {
     81             return this.GetTexture(Shader.PropertyToID(propertyName));
     82         }
     83 
     84         public Vector2 GetTextureOffset(string propertyName)
     85         {
     86             Vector2 vector;
     87             Internal_GetTextureOffset(this, propertyName, out vector);
     88             return vector;
     89         }
     90 
     91         public Vector2 GetTextureScale(string propertyName)
     92         {
     93             Vector2 vector;
     94             Internal_GetTextureScale(this, propertyName, out vector);
     95             return vector;
     96         }
     97 
     98         public Vector4 GetVector(int nameID)
     99         {
    100             Color color = this.GetColor(nameID);
    101             return new Vector4(color.r, color.g, color.b, color.a);
    102         }
    103 
    104         public Vector4 GetVector(string propertyName)
    105         {
    106             Color color = this.GetColor(propertyName);
    107             return new Vector4(color.r, color.g, color.b, color.a);
    108         }
    109 
    110         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    111         public extern bool HasProperty(int nameID);
    112         public bool HasProperty(string propertyName)
    113         {
    114             return this.HasProperty(Shader.PropertyToID(propertyName));
    115         }
    116 
    117         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    118         private static extern void INTERNAL_CALL_SetColor(Material self, int nameID, ref Color color);
    119         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    120         private static extern void INTERNAL_CALL_SetMatrix(Material self, int nameID, ref Matrix4x4 matrix);
    121         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    122         private static extern void INTERNAL_CALL_SetTextureOffset(Material self, string propertyName, ref Vector2 offset);
    123         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    124         private static extern void INTERNAL_CALL_SetTextureScale(Material self, string propertyName, ref Vector2 scale);
    125         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    126         private static extern void Internal_CreateWithMaterial([Writable] Material mono, Material source);
    127         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    128         private static extern void Internal_CreateWithShader([Writable] Material mono, Shader shader);
    129         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    130         private static extern void Internal_CreateWithString([Writable] Material mono, string contents);
    131         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    132         private static extern void Internal_GetTextureOffset(Material mat, string name, out Vector2 output);
    133         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    134         private static extern void Internal_GetTextureScale(Material mat, string name, out Vector2 output);
    135         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    136         public extern void Lerp(Material start, Material end, float t);
    137         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    138         public extern void SetBuffer(string propertyName, ComputeBuffer buffer);
    139         public void SetColor(int nameID, Color color)
    140         {
    141             INTERNAL_CALL_SetColor(this, nameID, ref color);
    142         }
    143 
    144         public void SetColor(string propertyName, Color color)
    145         {
    146             this.SetColor(Shader.PropertyToID(propertyName), color);
    147         }
    148 
    149         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    150         public extern void SetFloat(int nameID, float value);
    151         public void SetFloat(string propertyName, float value)
    152         {
    153             this.SetFloat(Shader.PropertyToID(propertyName), value);
    154         }
    155 
    156         public void SetInt(int nameID, int value)
    157         {
    158             this.SetFloat(nameID, (float) value);
    159         }
    160 
    161         public void SetInt(string propertyName, int value)
    162         {
    163             this.SetFloat(propertyName, (float) value);
    164         }
    165 
    166         public void SetMatrix(int nameID, Matrix4x4 matrix)
    167         {
    168             INTERNAL_CALL_SetMatrix(this, nameID, ref matrix);
    169         }
    170 
    171         public void SetMatrix(string propertyName, Matrix4x4 matrix)
    172         {
    173             this.SetMatrix(Shader.PropertyToID(propertyName), matrix);
    174         }
    175 
    176         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    177         public extern bool SetPass(int pass);
    178         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    179         public extern void SetTexture(int nameID, Texture texture);
    180         public void SetTexture(string propertyName, Texture texture)
    181         {
    182             this.SetTexture(Shader.PropertyToID(propertyName), texture);
    183         }
    184 
    185         public void SetTextureOffset(string propertyName, Vector2 offset)
    186         {
    187             INTERNAL_CALL_SetTextureOffset(this, propertyName, ref offset);
    188         }
    189 
    190         public void SetTextureScale(string propertyName, Vector2 scale)
    191         {
    192             INTERNAL_CALL_SetTextureScale(this, propertyName, ref scale);
    193         }
    194 
    195         public void SetVector(int nameID, Vector4 vector)
    196         {
    197             this.SetColor(nameID, new Color(vector.x, vector.y, vector.z, vector.w));
    198         }
    199 
    200         public void SetVector(string propertyName, Vector4 vector)
    201         {
    202             this.SetColor(propertyName, new Color(vector.x, vector.y, vector.z, vector.w));
    203         }
    204 
    205         public Color color
    206         {
    207             get
    208             {
    209                 return this.GetColor("_Color");
    210             }
    211             set
    212             {
    213                 this.SetColor("_Color", value);
    214             }
    215         }
    216 
    217         public Texture mainTexture
    218         {
    219             get
    220             {
    221                 return this.GetTexture("_MainTex");
    222             }
    223             set
    224             {
    225                 this.SetTexture("_MainTex", value);
    226             }
    227         }
    228 
    229         public Vector2 mainTextureOffset
    230         {
    231             get
    232             {
    233                 return this.GetTextureOffset("_MainTex");
    234             }
    235             set
    236             {
    237                 this.SetTextureOffset("_MainTex", value);
    238             }
    239         }
    240 
    241         public Vector2 mainTextureScale
    242         {
    243             get
    244             {
    245                 return this.GetTextureScale("_MainTex");
    246             }
    247             set
    248             {
    249                 this.SetTextureScale("_MainTex", value);
    250             }
    251         }
    252 
    253         public int passCount { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    254 
    255         public int renderQueue { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    256 
    257         public Shader shader { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    258 
    259         public string[] shaderKeywords { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    260     }
    261 }

## UnityEngine.Transform ##

![7JJJry.gif_web][]

1 namespace UnityEngine
      2 {
      3     using System;
      4     using System.Collections;
      5     using System.Runtime.CompilerServices;
      6     using System.Runtime.InteropServices;
      7     using UnityEngine.Internal;
      8 
      9     public class Transform : Component, IEnumerable
     10     {
     11         protected Transform()
     12         {
     13         }
     14 
     15         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     16         public extern void DetachChildren();
     17         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     18         public extern Transform Find(string name);
     19         public Transform FindChild(string name)
     20         {
     21             return this.Find(name);
     22         }
     23 
     24         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     25         public extern Transform GetChild(int index);
     26         [MethodImpl(MethodImplOptions.InternalCall), Obsolete("use Transform.childCount instead."), WrapperlessIcall]
     27         public extern int GetChildCount();
     28         public IEnumerator GetEnumerator()
     29         {
     30             return new Enumerator(this);
     31         }
     32 
     33         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     34         public extern int GetSiblingIndex();
     35         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     36         private static extern Vector3 INTERNAL_CALL_InverseTransformDirection(Transform self, ref Vector3 direction);
     37         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     38         private static extern Vector3 INTERNAL_CALL_InverseTransformPoint(Transform self, ref Vector3 position);
     39         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     40         private static extern Vector3 INTERNAL_CALL_InverseTransformVector(Transform self, ref Vector3 vector);
     41         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     42         private static extern void INTERNAL_CALL_LookAt(Transform self, ref Vector3 worldPosition, ref Vector3 worldUp);
     43         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     44         private static extern void INTERNAL_CALL_RotateAround(Transform self, ref Vector3 axis, float angle);
     45         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     46         private static extern void INTERNAL_CALL_RotateAroundInternal(Transform self, ref Vector3 axis, float angle);
     47         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     48         private static extern void INTERNAL_CALL_RotateAroundLocal(Transform self, ref Vector3 axis, float angle);
     49         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     50         private static extern Vector3 INTERNAL_CALL_TransformDirection(Transform self, ref Vector3 direction);
     51         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     52         private static extern Vector3 INTERNAL_CALL_TransformPoint(Transform self, ref Vector3 position);
     53         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     54         private static extern Vector3 INTERNAL_CALL_TransformVector(Transform self, ref Vector3 vector);
     55         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     56         private extern void INTERNAL_get_localEulerAngles(out Vector3 value);
     57         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     58         private extern void INTERNAL_get_localPosition(out Vector3 value);
     59         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     60         private extern void INTERNAL_get_localRotation(out Quaternion value);
     61         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     62         private extern void INTERNAL_get_localScale(out Vector3 value);
     63         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     64         private extern void INTERNAL_get_localToWorldMatrix(out Matrix4x4 value);
     65         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     66         private extern void INTERNAL_get_lossyScale(out Vector3 value);
     67         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     68         private extern void INTERNAL_get_position(out Vector3 value);
     69         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     70         private extern void INTERNAL_get_rotation(out Quaternion value);
     71         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     72         private extern void INTERNAL_get_worldToLocalMatrix(out Matrix4x4 value);
     73         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     74         private extern void INTERNAL_set_localEulerAngles(ref Vector3 value);
     75         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     76         private extern void INTERNAL_set_localPosition(ref Vector3 value);
     77         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     78         private extern void INTERNAL_set_localRotation(ref Quaternion value);
     79         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     80         private extern void INTERNAL_set_localScale(ref Vector3 value);
     81         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     82         private extern void INTERNAL_set_position(ref Vector3 value);
     83         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     84         private extern void INTERNAL_set_rotation(ref Quaternion value);
     85         public Vector3 InverseTransformDirection(Vector3 direction)
     86         {
     87             return INTERNAL_CALL_InverseTransformDirection(this, ref direction);
     88         }
     89 
     90         public Vector3 InverseTransformDirection(float x, float y, float z)
     91         {
     92             return this.InverseTransformDirection(new Vector3(x, y, z));
     93         }
     94 
     95         public Vector3 InverseTransformPoint(Vector3 position)
     96         {
     97             return INTERNAL_CALL_InverseTransformPoint(this, ref position);
     98         }
     99 
    100         public Vector3 InverseTransformPoint(float x, float y, float z)
    101         {
    102             return this.InverseTransformPoint(new Vector3(x, y, z));
    103         }
    104 
    105         public Vector3 InverseTransformVector(Vector3 vector)
    106         {
    107             return INTERNAL_CALL_InverseTransformVector(this, ref vector);
    108         }
    109 
    110         public Vector3 InverseTransformVector(float x, float y, float z)
    111         {
    112             return this.InverseTransformVector(new Vector3(x, y, z));
    113         }
    114 
    115         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    116         public extern bool IsChildOf(Transform parent);
    117         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    118         internal extern bool IsNonUniformScaleTransform();
    119         [ExcludeFromDocs]
    120         public void LookAt(Transform target)
    121         {
    122             Vector3 up = Vector3.up;
    123             this.LookAt(target, up);
    124         }
    125 
    126         [ExcludeFromDocs]
    127         public void LookAt(Vector3 worldPosition)
    128         {
    129             Vector3 up = Vector3.up;
    130             INTERNAL_CALL_LookAt(this, ref worldPosition, ref up);
    131         }
    132 
    133         public void LookAt(Transform target, [DefaultValue("Vector3.up")] Vector3 worldUp)
    134         {
    135             if (target != null)
    136             {
    137                 this.LookAt(target.position, worldUp);
    138             }
    139         }
    140 
    141         public void LookAt(Vector3 worldPosition, [DefaultValue("Vector3.up")] Vector3 worldUp)
    142         {
    143             INTERNAL_CALL_LookAt(this, ref worldPosition, ref worldUp);
    144         }
    145 
    146         [ExcludeFromDocs]
    147         public void Rotate(Vector3 eulerAngles)
    148         {
    149             Space self = Space.Self;
    150             this.Rotate(eulerAngles, self);
    151         }
    152 
    153         [ExcludeFromDocs]
    154         public void Rotate(Vector3 axis, float angle)
    155         {
    156             Space self = Space.Self;
    157             this.Rotate(axis, angle, self);
    158         }
    159 
    160         public void Rotate(Vector3 eulerAngles, [DefaultValue("Space.Self")] Space relativeTo)
    161         {
    162             Quaternion quaternion = Quaternion.Euler(eulerAngles.x, eulerAngles.y, eulerAngles.z);
    163             if (relativeTo == Space.Self)
    164             {
    165                 this.localRotation *= quaternion;
    166             }
    167             else
    168             {
    169                 this.rotation *= (Quaternion.Inverse(this.rotation) * quaternion) * this.rotation;
    170             }
    171         }
    172 
    173         [ExcludeFromDocs]
    174         public void Rotate(float xAngle, float yAngle, float zAngle)
    175         {
    176             Space self = Space.Self;
    177             this.Rotate(xAngle, yAngle, zAngle, self);
    178         }
    179 
    180         public void Rotate(Vector3 axis, float angle, [DefaultValue("Space.Self")] Space relativeTo)
    181         {
    182             if (relativeTo == Space.Self)
    183             {
    184                 this.RotateAroundInternal(base.transform.TransformDirection(axis), angle * 0.01745329f);
    185             }
    186             else
    187             {
    188                 this.RotateAroundInternal(axis, angle * 0.01745329f);
    189             }
    190         }
    191 
    192         public void Rotate(float xAngle, float yAngle, float zAngle, [DefaultValue("Space.Self")] Space relativeTo)
    193         {
    194             this.Rotate(new Vector3(xAngle, yAngle, zAngle), relativeTo);
    195         }
    196 
    197         [Obsolete("use Transform.Rotate instead.")]
    198         public void RotateAround(Vector3 axis, float angle)
    199         {
    200             INTERNAL_CALL_RotateAround(this, ref axis, angle);
    201         }
    202 
    203         public void RotateAround(Vector3 point, Vector3 axis, float angle)
    204         {
    205             Vector3 position = this.position;
    206             Quaternion quaternion = Quaternion.AngleAxis(angle, axis);
    207             Vector3 vector2 = position - point;
    208             vector2 = (Vector3) (quaternion * vector2);
    209             position = point + vector2;
    210             this.position = position;
    211             this.RotateAroundInternal(axis, angle * 0.01745329f);
    212         }
    213 
    214         internal void RotateAroundInternal(Vector3 axis, float angle)
    215         {
    216             INTERNAL_CALL_RotateAroundInternal(this, ref axis, angle);
    217         }
    218 
    219         [Obsolete("use Transform.Rotate instead.")]
    220         public void RotateAroundLocal(Vector3 axis, float angle)
    221         {
    222             INTERNAL_CALL_RotateAroundLocal(this, ref axis, angle);
    223         }
    224 
    225         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    226         internal extern void SendTransformChangedScale();
    227         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    228         public extern void SetAsFirstSibling();
    229         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    230         public extern void SetAsLastSibling();
    231         public void SetParent(Transform parent)
    232         {
    233             this.SetParent(parent, true);
    234         }
    235 
    236         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    237         public extern void SetParent(Transform parent, bool worldPositionStays);
    238         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    239         public extern void SetSiblingIndex(int index);
    240         public Vector3 TransformDirection(Vector3 direction)
    241         {
    242             return INTERNAL_CALL_TransformDirection(this, ref direction);
    243         }
    244 
    245         public Vector3 TransformDirection(float x, float y, float z)
    246         {
    247             return this.TransformDirection(new Vector3(x, y, z));
    248         }
    249 
    250         public Vector3 TransformPoint(Vector3 position)
    251         {
    252             return INTERNAL_CALL_TransformPoint(this, ref position);
    253         }
    254 
    255         public Vector3 TransformPoint(float x, float y, float z)
    256         {
    257             return this.TransformPoint(new Vector3(x, y, z));
    258         }
    259 
    260         public Vector3 TransformVector(Vector3 vector)
    261         {
    262             return INTERNAL_CALL_TransformVector(this, ref vector);
    263         }
    264 
    265         public Vector3 TransformVector(float x, float y, float z)
    266         {
    267             return this.TransformVector(new Vector3(x, y, z));
    268         }
    269 
    270         [ExcludeFromDocs]
    271         public void Translate(Vector3 translation)
    272         {
    273             Space self = Space.Self;
    274             this.Translate(translation, self);
    275         }
    276 
    277         public void Translate(Vector3 translation, [DefaultValue("Space.Self")] Space relativeTo)
    278         {
    279             if (relativeTo == Space.World)
    280             {
    281                 this.position += translation;
    282             }
    283             else
    284             {
    285                 this.position += this.TransformDirection(translation);
    286             }
    287         }
    288 
    289         public void Translate(Vector3 translation, Transform relativeTo)
    290         {
    291             if (relativeTo != null)
    292             {
    293                 this.position += relativeTo.TransformDirection(translation);
    294             }
    295             else
    296             {
    297                 this.position += translation;
    298             }
    299         }
    300 
    301         [ExcludeFromDocs]
    302         public void Translate(float x, float y, float z)
    303         {
    304             Space self = Space.Self;
    305             this.Translate(x, y, z, self);
    306         }
    307 
    308         public void Translate(float x, float y, float z, [DefaultValue("Space.Self")] Space relativeTo)
    309         {
    310             this.Translate(new Vector3(x, y, z), relativeTo);
    311         }
    312 
    313         public void Translate(float x, float y, float z, Transform relativeTo)
    314         {
    315             this.Translate(new Vector3(x, y, z), relativeTo);
    316         }
    317 
    318         public int childCount { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    319 
    320         public Vector3 eulerAngles
    321         {
    322             get
    323             {
    324                 return this.rotation.eulerAngles;
    325             }
    326             set
    327             {
    328                 this.rotation = Quaternion.Euler(value);
    329             }
    330         }
    331 
    332         public Vector3 forward
    333         {
    334             get
    335             {
    336                 return (Vector3) (this.rotation * Vector3.forward);
    337             }
    338             set
    339             {
    340                 this.rotation = Quaternion.LookRotation(value);
    341             }
    342         }
    343 
    344         public bool hasChanged { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    345 
    346         public Vector3 localEulerAngles
    347         {
    348             get
    349             {
    350                 Vector3 vector;
    351                 this.INTERNAL_get_localEulerAngles(out vector);
    352                 return vector;
    353             }
    354             set
    355             {
    356                 this.INTERNAL_set_localEulerAngles(ref value);
    357             }
    358         }
    359 
    360         public Vector3 localPosition
    361         {
    362             get
    363             {
    364                 Vector3 vector;
    365                 this.INTERNAL_get_localPosition(out vector);
    366                 return vector;
    367             }
    368             set
    369             {
    370                 this.INTERNAL_set_localPosition(ref value);
    371             }
    372         }
    373 
    374         public Quaternion localRotation
    375         {
    376             get
    377             {
    378                 Quaternion quaternion;
    379                 this.INTERNAL_get_localRotation(out quaternion);
    380                 return quaternion;
    381             }
    382             set
    383             {
    384                 this.INTERNAL_set_localRotation(ref value);
    385             }
    386         }
    387 
    388         public Vector3 localScale
    389         {
    390             get
    391             {
    392                 Vector3 vector;
    393                 this.INTERNAL_get_localScale(out vector);
    394                 return vector;
    395             }
    396             set
    397             {
    398                 this.INTERNAL_set_localScale(ref value);
    399             }
    400         }
    401 
    402         public Matrix4x4 localToWorldMatrix
    403         {
    404             get
    405             {
    406                 Matrix4x4 matrixx;
    407                 this.INTERNAL_get_localToWorldMatrix(out matrixx);
    408                 return matrixx;
    409             }
    410         }
    411 
    412         public Vector3 lossyScale
    413         {
    414             get
    415             {
    416                 Vector3 vector;
    417                 this.INTERNAL_get_lossyScale(out vector);
    418                 return vector;
    419             }
    420         }
    421 
    422         public Transform parent
    423         {
    424             get
    425             {
    426                 return this.parentInternal;
    427             }
    428             set
    429             {
    430                 if (this is RectTransform)
    431                 {
    432                     Debug.LogWarning("Parent of RectTransform is being set with parent property. Consider using the SetParent method instead, with the worldPositionStays argument set to false. This will retain local orientation and scale rather than world orientation and scale, which can prevent common UI scaling issues.", this);
    433                 }
    434                 this.parentInternal = value;
    435             }
    436         }
    437 
    438         internal Transform parentInternal { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    439 
    440         public Vector3 position
    441         {
    442             get
    443             {
    444                 Vector3 vector;
    445                 this.INTERNAL_get_position(out vector);
    446                 return vector;
    447             }
    448             set
    449             {
    450                 this.INTERNAL_set_position(ref value);
    451             }
    452         }
    453 
    454         public Vector3 right
    455         {
    456             get
    457             {
    458                 return (Vector3) (this.rotation * Vector3.right);
    459             }
    460             set
    461             {
    462                 this.rotation = Quaternion.FromToRotation(Vector3.right, value);
    463             }
    464         }
    465 
    466         public Transform root { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    467 
    468         public Quaternion rotation
    469         {
    470             get
    471             {
    472                 Quaternion quaternion;
    473                 this.INTERNAL_get_rotation(out quaternion);
    474                 return quaternion;
    475             }
    476             set
    477             {
    478                 this.INTERNAL_set_rotation(ref value);
    479             }
    480         }
    481 
    482         public Vector3 up
    483         {
    484             get
    485             {
    486                 return (Vector3) (this.rotation * Vector3.up);
    487             }
    488             set
    489             {
    490                 this.rotation = Quaternion.FromToRotation(Vector3.up, value);
    491             }
    492         }
    493 
    494         public Matrix4x4 worldToLocalMatrix
    495         {
    496             get
    497             {
    498                 Matrix4x4 matrixx;
    499                 this.INTERNAL_get_worldToLocalMatrix(out matrixx);
    500                 return matrixx;
    501             }
    502         }
    503 
    504         private sealed class Enumerator : IEnumerator
    505         {
    506             private int currentIndex = -1;
    507             private Transform outer;
    508 
    509             internal Enumerator(Transform outer)
    510             {
    511                 this.outer = outer;
    512             }
    513 
    514             public bool MoveNext()
    515             {
    516                 int childCount = this.outer.childCount;
    517                 return (++this.currentIndex < childCount);
    518             }
    519 
    520             public void Reset()
    521             {
    522                 this.currentIndex = -1;
    523             }
    524 
    525             public object Current
    526             {
    527                 get
    528                 {
    529                     return this.outer.GetChild(this.currentIndex);
    530                 }
    531             }
    532         }
    533     }
    534 }

## UnityEngine.Renderer ##

![7JJJry.gif_web][]

1 namespace UnityEngine
     2 {
     3     using System;
     4     using System.Runtime.CompilerServices;
     5     using System.Runtime.InteropServices;
     6 
     7     public class Renderer : Component
     8     {
     9         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    10         public extern void GetPropertyBlock(MaterialPropertyBlock dest);
    11         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    12         private extern void INTERNAL_get_lightmapTilingOffset(out Vector4 value);
    13         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    14         private extern void INTERNAL_get_localToWorldMatrix(out Matrix4x4 value);
    15         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    16         private extern void INTERNAL_get_worldToLocalMatrix(out Matrix4x4 value);
    17         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    18         private extern void INTERNAL_set_lightmapTilingOffset(ref Vector4 value);
    19         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    20         public extern void Render(int material);
    21         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    22         public extern void SetPropertyBlock(MaterialPropertyBlock properties);
    23         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    24         internal extern void SetSubsetIndex(int index, int subSetIndexForMaterial);
    25 
    26         public Bounds bounds { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    27 
    28         public bool castShadows { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    29 
    30         public bool enabled { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    31 
    32         public bool isPartOfStaticBatch { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    33 
    34         public bool isVisible { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    35 
    36         public int lightmapIndex { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    37 
    38         public Vector4 lightmapTilingOffset
    39         {
    40             get
    41             {
    42                 Vector4 vector;
    43                 this.INTERNAL_get_lightmapTilingOffset(out vector);
    44                 return vector;
    45             }
    46             set
    47             {
    48                 this.INTERNAL_set_lightmapTilingOffset(ref value);
    49             }
    50         }
    51 
    52         public Transform lightProbeAnchor { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    53 
    54         public Matrix4x4 localToWorldMatrix
    55         {
    56             get
    57             {
    58                 Matrix4x4 matrixx;
    59                 this.INTERNAL_get_localToWorldMatrix(out matrixx);
    60                 return matrixx;
    61             }
    62         }
    63 
    64         public Material material { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    65 
    66         public Material[] materials { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    67 
    68         public bool receiveShadows { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    69 
    70         public Material sharedMaterial { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    71 
    72         public Material[] sharedMaterials { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    73 
    74         public int sortingLayerID { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    75 
    76         public string sortingLayerName { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    77 
    78         public int sortingOrder { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    79 
    80         internal int staticBatchIndex { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    81 
    82         internal Transform staticBatchRootTransform { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    83 
    84         public bool useLightProbes { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    85 
    86         public Matrix4x4 worldToLocalMatrix
    87         {
    88             get
    89             {
    90                 Matrix4x4 matrixx;
    91                 this.INTERNAL_get_worldToLocalMatrix(out matrixx);
    92                 return matrixx;
    93             }
    94         }
    95     }
    96 }

## UnityEngine.ParticalSystem ##

![7JJJry.gif_web][]

1 namespace UnityEngine
      2 {
      3     using System;
      4     using System.Collections;
      5     using System.Collections.Generic;
      6     using System.Runtime.CompilerServices;
      7     using System.Runtime.InteropServices;
      8     using UnityEngine.Internal;
      9 
     10     public sealed class ParticleSystem : Component
     11     {
     12         [ExcludeFromDocs]
     13         public void Clear()
     14         {
     15             bool withChildren = true;
     16             this.Clear(withChildren);
     17         }
     18 
     19         public void Clear([DefaultValue("true")] bool withChildren)
     20         {
     21             if (withChildren)
     22             {
     23                 foreach (ParticleSystem system in GetParticleSystems(this))
     24                 {
     25                     system.Internal_Clear();
     26                 }
     27             }
     28             else
     29             {
     30                 this.Internal_Clear();
     31             }
     32         }
     33 
     34         public void Emit(int count)
     35         {
     36             INTERNAL_CALL_Emit(this, count);
     37         }
     38 
     39         public void Emit(Particle particle)
     40         {
     41             this.Internal_Emit(ref particle);
     42         }
     43 
     44         public void Emit(Vector3 position, Vector3 velocity, float size, float lifetime, Color32 color)
     45         {
     46             Particle particle = new Particle {
     47                 position = position,
     48                 velocity = velocity,
     49                 lifetime = lifetime,
     50                 startLifetime = lifetime,
     51                 size = size,
     52                 rotation = 0f,
     53                 angularVelocity = 0f,
     54                 color = color,
     55                 randomSeed = 5
     56             };
     57             this.Internal_Emit(ref particle);
     58         }
     59 
     60         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     61         public extern int GetCollisionEvents(GameObject go, CollisionEvent[] collisionEvents);
     62         private static void GetDirectParticleSystemChildrenRecursive(Transform transform, List<ParticleSystem> particleSystems)
     63         {
     64             IEnumerator enumerator = transform.GetEnumerator();
     65             try
     66             {
     67                 while (enumerator.MoveNext())
     68                 {
     69                     Transform current = (Transform) enumerator.Current;
     70                     ParticleSystem component = current.gameObject.GetComponent<ParticleSystem>();
     71                     if (component != null)
     72                     {
     73                         particleSystems.Add(component);
     74                         GetDirectParticleSystemChildrenRecursive(current, particleSystems);
     75                     }
     76                 }
     77             }
     78             finally
     79             {
     80                 IDisposable disposable = enumerator as IDisposable;
     81                 if (disposable == null)
     82                 {
     83                 }
     84                 disposable.Dispose();
     85             }
     86         }
     87 
     88         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     89         public extern int GetParticles(Particle[] particles);
     90         internal static ParticleSystem[] GetParticleSystems(ParticleSystem root)
     91         {
     92             if (root == null)
     93             {
     94                 return null;
     95             }
     96             List<ParticleSystem> particleSystems = new List<ParticleSystem> {
     97                 root
     98             };
     99             GetDirectParticleSystemChildrenRecursive(root.transform, particleSystems);
    100             return particleSystems.ToArray();
    101         }
    102 
    103         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    104         internal static extern Collider InstanceIDToCollider(int instanceID);
    105         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    106         private static extern void INTERNAL_CALL_Emit(ParticleSystem self, int count);
    107         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    108         private extern void Internal_Clear();
    109         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    110         private extern void Internal_Emit(ref Particle particle);
    111         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    112         private extern void INTERNAL_get_startColor(out Color value);
    113         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    114         private extern bool Internal_IsAlive();
    115         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    116         private extern void Internal_Pause();
    117         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    118         private extern void Internal_Play();
    119         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    120         private extern void INTERNAL_set_startColor(ref Color value);
    121         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    122         private extern void Internal_Simulate(float t, bool restart);
    123         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    124         private extern void Internal_Stop();
    125         [ExcludeFromDocs]
    126         public bool IsAlive()
    127         {
    128             bool withChildren = true;
    129             return this.IsAlive(withChildren);
    130         }
    131 
    132         public bool IsAlive([DefaultValue("true")] bool withChildren)
    133         {
    134             if (!withChildren)
    135             {
    136                 return this.Internal_IsAlive();
    137             }
    138             foreach (ParticleSystem system in GetParticleSystems(this))
    139             {
    140                 if (system.Internal_IsAlive())
    141                 {
    142                     return true;
    143                 }
    144             }
    145             return false;
    146         }
    147 
    148         [ExcludeFromDocs]
    149         public void Pause()
    150         {
    151             bool withChildren = true;
    152             this.Pause(withChildren);
    153         }
    154 
    155         public void Pause([DefaultValue("true")] bool withChildren)
    156         {
    157             if (withChildren)
    158             {
    159                 foreach (ParticleSystem system in GetParticleSystems(this))
    160                 {
    161                     system.Internal_Pause();
    162                 }
    163             }
    164             else
    165             {
    166                 this.Internal_Pause();
    167             }
    168         }
    169 
    170         [ExcludeFromDocs]
    171         public void Play()
    172         {
    173             bool withChildren = true;
    174             this.Play(withChildren);
    175         }
    176 
    177         public void Play([DefaultValue("true")] bool withChildren)
    178         {
    179             if (withChildren)
    180             {
    181                 foreach (ParticleSystem system in GetParticleSystems(this))
    182                 {
    183                     system.Internal_Play();
    184                 }
    185             }
    186             else
    187             {
    188                 this.Internal_Play();
    189             }
    190         }
    191 
    192         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    193         public extern void SetParticles(Particle[] particles, int size);
    194         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    195         internal extern void SetupDefaultType(int type);
    196         [ExcludeFromDocs]
    197         public void Simulate(float t)
    198         {
    199             bool restart = true;
    200             bool withChildren = true;
    201             this.Simulate(t, withChildren, restart);
    202         }
    203 
    204         [ExcludeFromDocs]
    205         public void Simulate(float t, bool withChildren)
    206         {
    207             bool restart = true;
    208             this.Simulate(t, withChildren, restart);
    209         }
    210 
    211         public void Simulate(float t, [DefaultValue("true")] bool withChildren, [DefaultValue("true")] bool restart)
    212         {
    213             if (withChildren)
    214             {
    215                 foreach (ParticleSystem system in GetParticleSystems(this))
    216                 {
    217                     system.Internal_Simulate(t, restart);
    218                 }
    219             }
    220             else
    221             {
    222                 this.Internal_Simulate(t, restart);
    223             }
    224         }
    225 
    226         [ExcludeFromDocs]
    227         public void Stop()
    228         {
    229             bool withChildren = true;
    230             this.Stop(withChildren);
    231         }
    232 
    233         public void Stop([DefaultValue("true")] bool withChildren)
    234         {
    235             if (withChildren)
    236             {
    237                 foreach (ParticleSystem system in GetParticleSystems(this))
    238                 {
    239                     system.Internal_Stop();
    240                 }
    241             }
    242             else
    243             {
    244                 this.Internal_Stop();
    245             }
    246         }
    247 
    248         public float duration { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    249 
    250         public float emissionRate { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    251 
    252         public bool enableEmission { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    253 
    254         public float gravityModifier { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    255 
    256         public bool isPaused { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    257 
    258         public bool isPlaying { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    259 
    260         public bool isStopped { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    261 
    262         public bool loop { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    263 
    264         public int maxParticles { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    265 
    266         public int particleCount { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    267 
    268         public float playbackSpeed { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    269 
    270         public bool playOnAwake { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    271 
    272         public uint randomSeed { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    273 
    274         public int safeCollisionEventSize { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    275 
    276         public ParticleSystemSimulationSpace simulationSpace { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    277 
    278         public Color startColor
    279         {
    280             get
    281             {
    282                 Color color;
    283                 this.INTERNAL_get_startColor(out color);
    284                 return color;
    285             }
    286             set
    287             {
    288                 this.INTERNAL_set_startColor(ref value);
    289             }
    290         }
    291 
    292         public float startDelay { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    293 
    294         public float startLifetime { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    295 
    296         public float startRotation { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    297 
    298         public float startSize { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    299 
    300         public float startSpeed { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    301 
    302         public float time { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    303 
    304         [StructLayout(LayoutKind.Sequential)]
    305         public struct CollisionEvent
    306         {
    307             private Vector3 m_Intersection;
    308             private Vector3 m_Normal;
    309             private Vector3 m_Velocity;
    310             private int m_ColliderInstanceID;
    311             public Vector3 intersection
    312             {
    313                 get
    314                 {
    315                     return this.m_Intersection;
    316                 }
    317             }
    318             public Vector3 normal
    319             {
    320                 get
    321                 {
    322                     return this.m_Normal;
    323                 }
    324             }
    325             public Vector3 velocity
    326             {
    327                 get
    328                 {
    329                     return this.m_Velocity;
    330                 }
    331             }
    332             public Collider collider
    333             {
    334                 get
    335                 {
    336                     return ParticleSystem.InstanceIDToCollider(this.m_ColliderInstanceID);
    337                 }
    338             }
    339         }
    340 
    341         [StructLayout(LayoutKind.Sequential)]
    342         public struct Particle
    343         {
    344             private Vector3 m_Position;
    345             private Vector3 m_Velocity;
    346             private Vector3 m_AnimatedVelocity;
    347             private Vector3 m_AxisOfRotation;
    348             private float m_Rotation;
    349             private float m_AngularVelocity;
    350             private float m_Size;
    351             private Color32 m_Color;
    352             private uint m_RandomSeed;
    353             private float m_Lifetime;
    354             private float m_StartLifetime;
    355             private float m_EmitAccumulator0;
    356             private float m_EmitAccumulator1;
    357             public Vector3 position
    358             {
    359                 get
    360                 {
    361                     return this.m_Position;
    362                 }
    363                 set
    364                 {
    365                     this.m_Position = value;
    366                 }
    367             }
    368             public Vector3 velocity
    369             {
    370                 get
    371                 {
    372                     return this.m_Velocity;
    373                 }
    374                 set
    375                 {
    376                     this.m_Velocity = value;
    377                 }
    378             }
    379             public float lifetime
    380             {
    381                 get
    382                 {
    383                     return this.m_Lifetime;
    384                 }
    385                 set
    386                 {
    387                     this.m_Lifetime = value;
    388                 }
    389             }
    390             public float startLifetime
    391             {
    392                 get
    393                 {
    394                     return this.m_StartLifetime;
    395                 }
    396                 set
    397                 {
    398                     this.m_StartLifetime = value;
    399                 }
    400             }
    401             public float size
    402             {
    403                 get
    404                 {
    405                     return this.m_Size;
    406                 }
    407                 set
    408                 {
    409                     this.m_Size = value;
    410                 }
    411             }
    412             public Vector3 axisOfRotation
    413             {
    414                 get
    415                 {
    416                     return this.m_AxisOfRotation;
    417                 }
    418                 set
    419                 {
    420                     this.m_AxisOfRotation = value;
    421                 }
    422             }
    423             public float rotation
    424             {
    425                 get
    426                 {
    427                     return (this.m_Rotation * 57.29578f);
    428                 }
    429                 set
    430                 {
    431                     this.m_Rotation = value * 0.01745329f;
    432                 }
    433             }
    434             public float angularVelocity
    435             {
    436                 get
    437                 {
    438                     return (this.m_AngularVelocity * 57.29578f);
    439                 }
    440                 set
    441                 {
    442                     this.m_AngularVelocity = value * 0.01745329f;
    443                 }
    444             }
    445             public Color32 color
    446             {
    447                 get
    448                 {
    449                     return this.m_Color;
    450                 }
    451                 set
    452                 {
    453                     this.m_Color = value;
    454                 }
    455             }
    456             [Obsolete("randomValue property is deprecated. Use randomSeed instead to control random behavior of particles.")]
    457             public float randomValue
    458             {
    459                 get
    460                 {
    461                     return BitConverter.ToSingle(BitConverter.GetBytes(this.m_RandomSeed), 0);
    462                 }
    463                 set
    464                 {
    465                     this.m_RandomSeed = BitConverter.ToUInt32(BitConverter.GetBytes(value), 0);
    466                 }
    467             }
    468             public uint randomSeed
    469             {
    470                 get
    471                 {
    472                     return this.m_RandomSeed;
    473                 }
    474                 set
    475                 {
    476                     this.m_RandomSeed = value;
    477                 }
    478             }
    479         }
    480     }
    481 }

## UnityEngine.Behaviour ##

![7JJJry.gif_web][]

1 namespace UnityEngine
     2 {
     3     using System;
     4     using System.Runtime.CompilerServices;
     5 
     6     public class Behaviour : Component
     7     {
     8         public bool enabled { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
     9     }
    10 }

## UnityEngine.Collider ##

![7JJJry.gif_web][]

1 namespace UnityEngine
     2 {
     3     using System;
     4     using System.Runtime.CompilerServices;
     5     using System.Runtime.InteropServices;
     6 
     7     public class Collider : Component
     8     {
     9         public Vector3 ClosestPointOnBounds(Vector3 position)
    10         {
    11             return INTERNAL_CALL_ClosestPointOnBounds(this, ref position);
    12         }
    13 
    14         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    15         private static extern Vector3 INTERNAL_CALL_ClosestPointOnBounds(Collider self, ref Vector3 position);
    16         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    17         private static extern bool INTERNAL_CALL_Internal_Raycast(Collider col, ref Ray ray, out RaycastHit hitInfo, float distance);
    18         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    19         private extern void INTERNAL_get_bounds(out Bounds value);
    20         private static bool Internal_Raycast(Collider col, Ray ray, out RaycastHit hitInfo, float distance)
    21         {
    22             return INTERNAL_CALL_Internal_Raycast(col, ref ray, out hitInfo, distance);
    23         }
    24 
    25         public bool Raycast(Ray ray, out RaycastHit hitInfo, float distance)
    26         {
    27             return Internal_Raycast(this, ray, out hitInfo, distance);
    28         }
    29 
    30         public Rigidbody attachedRigidbody { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    31 
    32         public Bounds bounds
    33         {
    34             get
    35             {
    36                 Bounds bounds;
    37                 this.INTERNAL_get_bounds(out bounds);
    38                 return bounds;
    39             }
    40         }
    41 
    42         public bool enabled { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    43 
    44         public bool isTrigger { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    45 
    46         public PhysicMaterial material { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    47 
    48         public PhysicMaterial sharedMaterial { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    49     }
    50 }

## UnityEngine.Rigidbody ##

![7JJJry.gif_web][]

1 namespace UnityEngine
      2 {
      3     using System;
      4     using System.Runtime.CompilerServices;
      5     using System.Runtime.InteropServices;
      6     using UnityEngine.Internal;
      7 
      8     public sealed class Rigidbody : Component
      9     {
     10         [ExcludeFromDocs]
     11         public void AddExplosionForce(float explosionForce, Vector3 explosionPosition, float explosionRadius)
     12         {
     13             ForceMode force = ForceMode.Force;
     14             float upwardsModifier = 0f;
     15             INTERNAL_CALL_AddExplosionForce(this, explosionForce, ref explosionPosition, explosionRadius, upwardsModifier, force);
     16         }
     17 
     18         [ExcludeFromDocs]
     19         public void AddExplosionForce(float explosionForce, Vector3 explosionPosition, float explosionRadius, float upwardsModifier)
     20         {
     21             ForceMode force = ForceMode.Force;
     22             INTERNAL_CALL_AddExplosionForce(this, explosionForce, ref explosionPosition, explosionRadius, upwardsModifier, force);
     23         }
     24 
     25         public void AddExplosionForce(float explosionForce, Vector3 explosionPosition, float explosionRadius, [DefaultValue("0.0F")] float upwardsModifier, [DefaultValue("ForceMode.Force")] ForceMode mode)
     26         {
     27             INTERNAL_CALL_AddExplosionForce(this, explosionForce, ref explosionPosition, explosionRadius, upwardsModifier, mode);
     28         }
     29 
     30         [ExcludeFromDocs]
     31         public void AddForce(Vector3 force)
     32         {
     33             ForceMode mode = ForceMode.Force;
     34             INTERNAL_CALL_AddForce(this, ref force, mode);
     35         }
     36 
     37         public void AddForce(Vector3 force, [DefaultValue("ForceMode.Force")] ForceMode mode)
     38         {
     39             INTERNAL_CALL_AddForce(this, ref force, mode);
     40         }
     41 
     42         [ExcludeFromDocs]
     43         public void AddForce(float x, float y, float z)
     44         {
     45             ForceMode force = ForceMode.Force;
     46             this.AddForce(x, y, z, force);
     47         }
     48 
     49         public void AddForce(float x, float y, float z, [DefaultValue("ForceMode.Force")] ForceMode mode)
     50         {
     51             this.AddForce(new Vector3(x, y, z), mode);
     52         }
     53 
     54         [ExcludeFromDocs]
     55         public void AddForceAtPosition(Vector3 force, Vector3 position)
     56         {
     57             ForceMode mode = ForceMode.Force;
     58             INTERNAL_CALL_AddForceAtPosition(this, ref force, ref position, mode);
     59         }
     60 
     61         public void AddForceAtPosition(Vector3 force, Vector3 position, [DefaultValue("ForceMode.Force")] ForceMode mode)
     62         {
     63             INTERNAL_CALL_AddForceAtPosition(this, ref force, ref position, mode);
     64         }
     65 
     66         [ExcludeFromDocs]
     67         public void AddRelativeForce(Vector3 force)
     68         {
     69             ForceMode mode = ForceMode.Force;
     70             INTERNAL_CALL_AddRelativeForce(this, ref force, mode);
     71         }
     72 
     73         public void AddRelativeForce(Vector3 force, [DefaultValue("ForceMode.Force")] ForceMode mode)
     74         {
     75             INTERNAL_CALL_AddRelativeForce(this, ref force, mode);
     76         }
     77 
     78         [ExcludeFromDocs]
     79         public void AddRelativeForce(float x, float y, float z)
     80         {
     81             ForceMode force = ForceMode.Force;
     82             this.AddRelativeForce(x, y, z, force);
     83         }
     84 
     85         public void AddRelativeForce(float x, float y, float z, [DefaultValue("ForceMode.Force")] ForceMode mode)
     86         {
     87             this.AddRelativeForce(new Vector3(x, y, z), mode);
     88         }
     89 
     90         [ExcludeFromDocs]
     91         public void AddRelativeTorque(Vector3 torque)
     92         {
     93             ForceMode force = ForceMode.Force;
     94             INTERNAL_CALL_AddRelativeTorque(this, ref torque, force);
     95         }
     96 
     97         public void AddRelativeTorque(Vector3 torque, [DefaultValue("ForceMode.Force")] ForceMode mode)
     98         {
     99             INTERNAL_CALL_AddRelativeTorque(this, ref torque, mode);
    100         }
    101 
    102         [ExcludeFromDocs]
    103         public void AddRelativeTorque(float x, float y, float z)
    104         {
    105             ForceMode force = ForceMode.Force;
    106             this.AddRelativeTorque(x, y, z, force);
    107         }
    108 
    109         public void AddRelativeTorque(float x, float y, float z, [DefaultValue("ForceMode.Force")] ForceMode mode)
    110         {
    111             this.AddRelativeTorque(new Vector3(x, y, z), mode);
    112         }
    113 
    114         [ExcludeFromDocs]
    115         public void AddTorque(Vector3 torque)
    116         {
    117             ForceMode force = ForceMode.Force;
    118             INTERNAL_CALL_AddTorque(this, ref torque, force);
    119         }
    120 
    121         public void AddTorque(Vector3 torque, [DefaultValue("ForceMode.Force")] ForceMode mode)
    122         {
    123             INTERNAL_CALL_AddTorque(this, ref torque, mode);
    124         }
    125 
    126         [ExcludeFromDocs]
    127         public void AddTorque(float x, float y, float z)
    128         {
    129             ForceMode force = ForceMode.Force;
    130             this.AddTorque(x, y, z, force);
    131         }
    132 
    133         public void AddTorque(float x, float y, float z, [DefaultValue("ForceMode.Force")] ForceMode mode)
    134         {
    135             this.AddTorque(new Vector3(x, y, z), mode);
    136         }
    137 
    138         public Vector3 ClosestPointOnBounds(Vector3 position)
    139         {
    140             return INTERNAL_CALL_ClosestPointOnBounds(this, ref position);
    141         }
    142 
    143         public Vector3 GetPointVelocity(Vector3 worldPoint)
    144         {
    145             return INTERNAL_CALL_GetPointVelocity(this, ref worldPoint);
    146         }
    147 
    148         public Vector3 GetRelativePointVelocity(Vector3 relativePoint)
    149         {
    150             return INTERNAL_CALL_GetRelativePointVelocity(this, ref relativePoint);
    151         }
    152 
    153         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    154         private static extern void INTERNAL_CALL_AddExplosionForce(Rigidbody self, float explosionForce, ref Vector3 explosionPosition, float explosionRadius, float upwardsModifier, ForceMode mode);
    155         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    156         private static extern void INTERNAL_CALL_AddForce(Rigidbody self, ref Vector3 force, ForceMode mode);
    157         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    158         private static extern void INTERNAL_CALL_AddForceAtPosition(Rigidbody self, ref Vector3 force, ref Vector3 position, ForceMode mode);
    159         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    160         private static extern void INTERNAL_CALL_AddRelativeForce(Rigidbody self, ref Vector3 force, ForceMode mode);
    161         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    162         private static extern void INTERNAL_CALL_AddRelativeTorque(Rigidbody self, ref Vector3 torque, ForceMode mode);
    163         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    164         private static extern void INTERNAL_CALL_AddTorque(Rigidbody self, ref Vector3 torque, ForceMode mode);
    165         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    166         private static extern Vector3 INTERNAL_CALL_ClosestPointOnBounds(Rigidbody self, ref Vector3 position);
    167         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    168         private static extern Vector3 INTERNAL_CALL_GetPointVelocity(Rigidbody self, ref Vector3 worldPoint);
    169         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    170         private static extern Vector3 INTERNAL_CALL_GetRelativePointVelocity(Rigidbody self, ref Vector3 relativePoint);
    171         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    172         private static extern bool INTERNAL_CALL_IsSleeping(Rigidbody self);
    173         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    174         private static extern void INTERNAL_CALL_MovePosition(Rigidbody self, ref Vector3 position);
    175         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    176         private static extern void INTERNAL_CALL_MoveRotation(Rigidbody self, ref Quaternion rot);
    177         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    178         private static extern void INTERNAL_CALL_SetDensity(Rigidbody self, float density);
    179         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    180         private static extern void INTERNAL_CALL_Sleep(Rigidbody self);
    181         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    182         private static extern bool INTERNAL_CALL_SweepTest(Rigidbody self, ref Vector3 direction, out RaycastHit hitInfo, float distance);
    183         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    184         private static extern RaycastHit[] INTERNAL_CALL_SweepTestAll(Rigidbody self, ref Vector3 direction, float distance);
    185         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    186         private static extern void INTERNAL_CALL_WakeUp(Rigidbody self);
    187         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    188         private extern void INTERNAL_get_angularVelocity(out Vector3 value);
    189         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    190         private extern void INTERNAL_get_centerOfMass(out Vector3 value);
    191         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    192         private extern void INTERNAL_get_inertiaTensor(out Vector3 value);
    193         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    194         private extern void INTERNAL_get_inertiaTensorRotation(out Quaternion value);
    195         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    196         private extern void INTERNAL_get_position(out Vector3 value);
    197         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    198         private extern void INTERNAL_get_rotation(out Quaternion value);
    199         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    200         private extern void INTERNAL_get_velocity(out Vector3 value);
    201         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    202         private extern void INTERNAL_get_worldCenterOfMass(out Vector3 value);
    203         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    204         private extern void INTERNAL_set_angularVelocity(ref Vector3 value);
    205         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    206         private extern void INTERNAL_set_centerOfMass(ref Vector3 value);
    207         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    208         private extern void INTERNAL_set_inertiaTensor(ref Vector3 value);
    209         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    210         private extern void INTERNAL_set_inertiaTensorRotation(ref Quaternion value);
    211         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    212         private extern void INTERNAL_set_position(ref Vector3 value);
    213         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    214         private extern void INTERNAL_set_rotation(ref Quaternion value);
    215         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    216         private extern void INTERNAL_set_velocity(ref Vector3 value);
    217         public bool IsSleeping()
    218         {
    219             return INTERNAL_CALL_IsSleeping(this);
    220         }
    221 
    222         public void MovePosition(Vector3 position)
    223         {
    224             INTERNAL_CALL_MovePosition(this, ref position);
    225         }
    226 
    227         public void MoveRotation(Quaternion rot)
    228         {
    229             INTERNAL_CALL_MoveRotation(this, ref rot);
    230         }
    231 
    232         public void SetDensity(float density)
    233         {
    234             INTERNAL_CALL_SetDensity(this, density);
    235         }
    236 
    237         [Obsolete("use Rigidbody.maxAngularVelocity instead.")]
    238         public void SetMaxAngularVelocity(float a)
    239         {
    240             this.maxAngularVelocity = a;
    241         }
    242 
    243         public void Sleep()
    244         {
    245             INTERNAL_CALL_Sleep(this);
    246         }
    247 
    248         [ExcludeFromDocs]
    249         public bool SweepTest(Vector3 direction, out RaycastHit hitInfo)
    250         {
    251             float positiveInfinity = float.PositiveInfinity;
    252             return INTERNAL_CALL_SweepTest(this, ref direction, out hitInfo, positiveInfinity);
    253         }
    254 
    255         public bool SweepTest(Vector3 direction, out RaycastHit hitInfo, [DefaultValue("Mathf.Infinity")] float distance)
    256         {
    257             return INTERNAL_CALL_SweepTest(this, ref direction, out hitInfo, distance);
    258         }
    259 
    260         [ExcludeFromDocs]
    261         public RaycastHit[] SweepTestAll(Vector3 direction)
    262         {
    263             float positiveInfinity = float.PositiveInfinity;
    264             return INTERNAL_CALL_SweepTestAll(this, ref direction, positiveInfinity);
    265         }
    266 
    267         public RaycastHit[] SweepTestAll(Vector3 direction, [DefaultValue("Mathf.Infinity")] float distance)
    268         {
    269             return INTERNAL_CALL_SweepTestAll(this, ref direction, distance);
    270         }
    271 
    272         public void WakeUp()
    273         {
    274             INTERNAL_CALL_WakeUp(this);
    275         }
    276 
    277         public float angularDrag { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    278 
    279         public Vector3 angularVelocity
    280         {
    281             get
    282             {
    283                 Vector3 vector;
    284                 this.INTERNAL_get_angularVelocity(out vector);
    285                 return vector;
    286             }
    287             set
    288             {
    289                 this.INTERNAL_set_angularVelocity(ref value);
    290             }
    291         }
    292 
    293         public Vector3 centerOfMass
    294         {
    295             get
    296             {
    297                 Vector3 vector;
    298                 this.INTERNAL_get_centerOfMass(out vector);
    299                 return vector;
    300             }
    301             set
    302             {
    303                 this.INTERNAL_set_centerOfMass(ref value);
    304             }
    305         }
    306 
    307         public CollisionDetectionMode collisionDetectionMode { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    308 
    309         public RigidbodyConstraints constraints { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    310 
    311         public bool detectCollisions { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    312 
    313         public float drag { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    314 
    315         public bool freezeRotation { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    316 
    317         public Vector3 inertiaTensor
    318         {
    319             get
    320             {
    321                 Vector3 vector;
    322                 this.INTERNAL_get_inertiaTensor(out vector);
    323                 return vector;
    324             }
    325             set
    326             {
    327                 this.INTERNAL_set_inertiaTensor(ref value);
    328             }
    329         }
    330 
    331         public Quaternion inertiaTensorRotation
    332         {
    333             get
    334             {
    335                 Quaternion quaternion;
    336                 this.INTERNAL_get_inertiaTensorRotation(out quaternion);
    337                 return quaternion;
    338             }
    339             set
    340             {
    341                 this.INTERNAL_set_inertiaTensorRotation(ref value);
    342             }
    343         }
    344 
    345         public RigidbodyInterpolation interpolation { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    346 
    347         public bool isKinematic { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    348 
    349         public float mass { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    350 
    351         public float maxAngularVelocity { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    352 
    353         public Vector3 position
    354         {
    355             get
    356             {
    357                 Vector3 vector;
    358                 this.INTERNAL_get_position(out vector);
    359                 return vector;
    360             }
    361             set
    362             {
    363                 this.INTERNAL_set_position(ref value);
    364             }
    365         }
    366 
    367         public Quaternion rotation
    368         {
    369             get
    370             {
    371                 Quaternion quaternion;
    372                 this.INTERNAL_get_rotation(out quaternion);
    373                 return quaternion;
    374             }
    375             set
    376             {
    377                 this.INTERNAL_set_rotation(ref value);
    378             }
    379         }
    380 
    381         public float sleepAngularVelocity { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    382 
    383         public float sleepVelocity { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    384 
    385         public int solverIterationCount { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    386 
    387         public bool useConeFriction { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    388 
    389         public bool useGravity { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    390 
    391         public Vector3 velocity
    392         {
    393             get
    394             {
    395                 Vector3 vector;
    396                 this.INTERNAL_get_velocity(out vector);
    397                 return vector;
    398             }
    399             set
    400             {
    401                 this.INTERNAL_set_velocity(ref value);
    402             }
    403         }
    404 
    405         public Vector3 worldCenterOfMass
    406         {
    407             get
    408             {
    409                 Vector3 vector;
    410                 this.INTERNAL_get_worldCenterOfMass(out vector);
    411                 return vector;
    412             }
    413         }
    414     }
    415 }

## UnityEngine.AudioListener ##

![7JJJry.gif_web][]

1 namespace UnityEngine
     2 {
     3     using System;
     4     using System.Runtime.CompilerServices;
     5 
     6     public sealed class AudioListener : Behaviour
     7     {
     8         [Obsolete("GetOutputData returning a float[] is deprecated, use GetOutputData and pass a pre allocated array instead.")]
     9         public static float[] GetOutputData(int numSamples, int channel)
    10         {
    11             float[] samples = new float[numSamples];
    12             GetOutputDataHelper(samples, channel);
    13             return samples;
    14         }
    15 
    16         public static void GetOutputData(float[] samples, int channel)
    17         {
    18             GetOutputDataHelper(samples, channel);
    19         }
    20 
    21         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    22         private static extern void GetOutputDataHelper(float[] samples, int channel);
    23         [Obsolete("GetSpectrumData returning a float[] is deprecated, use GetOutputData and pass a pre allocated array instead.")]
    24         public static float[] GetSpectrumData(int numSamples, int channel, FFTWindow window)
    25         {
    26             float[] samples = new float[numSamples];
    27             GetSpectrumDataHelper(samples, channel, window);
    28             return samples;
    29         }
    30 
    31         public static void GetSpectrumData(float[] samples, int channel, FFTWindow window)
    32         {
    33             GetSpectrumDataHelper(samples, channel, window);
    34         }
    35 
    36         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    37         private static extern void GetSpectrumDataHelper(float[] samples, int channel, FFTWindow window);
    38 
    39         public static bool pause { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    40 
    41         public AudioVelocityUpdateMode velocityUpdateMode { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    42 
    43         public static float volume { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    44     }
    45 }

## UnityEngine.Camera ##

![7JJJry.gif_web][]

1 namespace UnityEngine
      2 {
      3     using System;
      4     using System.Runtime.CompilerServices;
      5     using System.Runtime.InteropServices;
      6     using UnityEngine.Internal;
      7 
      8     public sealed class Camera : Behaviour
      9     {
     10         public Matrix4x4 CalculateObliqueMatrix(Vector4 clipPlane)
     11         {
     12             return INTERNAL_CALL_CalculateObliqueMatrix(this, ref clipPlane);
     13         }
     14 
     15         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     16         public extern void CopyFrom(Camera other);
     17         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall, Obsolete("Camera.DoClear is deprecated and may be removed in the future.")]
     18         public extern void DoClear();
     19         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     20         public static extern int GetAllCameras(Camera[] cameras);
     21         [MethodImpl(MethodImplOptions.InternalCall), Obsolete("use Screen.height instead."), WrapperlessIcall]
     22         public extern float GetScreenHeight();
     23         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall, Obsolete("use Screen.width instead.")]
     24         public extern float GetScreenWidth();
     25         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     26         private static extern Matrix4x4 INTERNAL_CALL_CalculateObliqueMatrix(Camera self, ref Vector4 clipPlane);
     27         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     28         private static extern void INTERNAL_CALL_ResetAspect(Camera self);
     29         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     30         private static extern void INTERNAL_CALL_ResetProjectionMatrix(Camera self);
     31         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     32         private static extern void INTERNAL_CALL_ResetReplacementShader(Camera self);
     33         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     34         private static extern void INTERNAL_CALL_ResetWorldToCameraMatrix(Camera self);
     35         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     36         private static extern Ray INTERNAL_CALL_ScreenPointToRay(Camera self, ref Vector3 position);
     37         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     38         private static extern Vector3 INTERNAL_CALL_ScreenToViewportPoint(Camera self, ref Vector3 position);
     39         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     40         private static extern Vector3 INTERNAL_CALL_ScreenToWorldPoint(Camera self, ref Vector3 position);
     41         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     42         private static extern Ray INTERNAL_CALL_ViewportPointToRay(Camera self, ref Vector3 position);
     43         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     44         private static extern Vector3 INTERNAL_CALL_ViewportToScreenPoint(Camera self, ref Vector3 position);
     45         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     46         private static extern Vector3 INTERNAL_CALL_ViewportToWorldPoint(Camera self, ref Vector3 position);
     47         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     48         private static extern Vector3 INTERNAL_CALL_WorldToScreenPoint(Camera self, ref Vector3 position);
     49         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     50         private static extern Vector3 INTERNAL_CALL_WorldToViewportPoint(Camera self, ref Vector3 position);
     51         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     52         private extern void INTERNAL_get_backgroundColor(out Color value);
     53         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     54         private extern void INTERNAL_get_cameraToWorldMatrix(out Matrix4x4 value);
     55         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     56         private extern void INTERNAL_get_pixelRect(out Rect value);
     57         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     58         private extern void INTERNAL_get_projectionMatrix(out Matrix4x4 value);
     59         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     60         private extern void INTERNAL_get_rect(out Rect value);
     61         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     62         private extern void INTERNAL_get_velocity(out Vector3 value);
     63         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     64         private extern void INTERNAL_get_worldToCameraMatrix(out Matrix4x4 value);
     65         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     66         private extern bool Internal_RenderToCubemapRT(RenderTexture cubemap, int faceMask);
     67         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     68         private extern bool Internal_RenderToCubemapTexture(Cubemap cubemap, int faceMask);
     69         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     70         private extern void INTERNAL_set_backgroundColor(ref Color value);
     71         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     72         private extern void INTERNAL_set_pixelRect(ref Rect value);
     73         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     74         private extern void INTERNAL_set_projectionMatrix(ref Matrix4x4 value);
     75         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     76         private extern void INTERNAL_set_rect(ref Rect value);
     77         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     78         private extern void INTERNAL_set_worldToCameraMatrix(ref Matrix4x4 value);
     79         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     80         internal extern bool IsFiltered(GameObject go);
     81         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     82         public extern void Render();
     83         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     84         public extern void RenderDontRestore();
     85         [ExcludeFromDocs]
     86         public bool RenderToCubemap(Cubemap cubemap)
     87         {
     88             int faceMask = 0x3f;
     89             return this.RenderToCubemap(cubemap, faceMask);
     90         }
     91 
     92         [ExcludeFromDocs]
     93         public bool RenderToCubemap(RenderTexture cubemap)
     94         {
     95             int faceMask = 0x3f;
     96             return this.RenderToCubemap(cubemap, faceMask);
     97         }
     98 
     99         public bool RenderToCubemap(Cubemap cubemap, [DefaultValue("63")] int faceMask)
    100         {
    101             return this.Internal_RenderToCubemapTexture(cubemap, faceMask);
    102         }
    103 
    104         public bool RenderToCubemap(RenderTexture cubemap, [DefaultValue("63")] int faceMask)
    105         {
    106             return this.Internal_RenderToCubemapRT(cubemap, faceMask);
    107         }
    108 
    109         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    110         public extern void RenderWithShader(Shader shader, string replacementTag);
    111         public void ResetAspect()
    112         {
    113             INTERNAL_CALL_ResetAspect(this);
    114         }
    115 
    116         public void ResetProjectionMatrix()
    117         {
    118             INTERNAL_CALL_ResetProjectionMatrix(this);
    119         }
    120 
    121         public void ResetReplacementShader()
    122         {
    123             INTERNAL_CALL_ResetReplacementShader(this);
    124         }
    125 
    126         public void ResetWorldToCameraMatrix()
    127         {
    128             INTERNAL_CALL_ResetWorldToCameraMatrix(this);
    129         }
    130 
    131         public Ray ScreenPointToRay(Vector3 position)
    132         {
    133             return INTERNAL_CALL_ScreenPointToRay(this, ref position);
    134         }
    135 
    136         public Vector3 ScreenToViewportPoint(Vector3 position)
    137         {
    138             return INTERNAL_CALL_ScreenToViewportPoint(this, ref position);
    139         }
    140 
    141         public Vector3 ScreenToWorldPoint(Vector3 position)
    142         {
    143             return INTERNAL_CALL_ScreenToWorldPoint(this, ref position);
    144         }
    145 
    146         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    147         public extern void SetReplacementShader(Shader shader, string replacementTag);
    148         public void SetTargetBuffers(RenderBuffer colorBuffer, RenderBuffer depthBuffer)
    149         {
    150             this.SetTargetBuffersImpl(out colorBuffer, out depthBuffer);
    151         }
    152 
    153         public void SetTargetBuffers(RenderBuffer[] colorBuffer, RenderBuffer depthBuffer)
    154         {
    155             this.SetTargetBuffersMRTImpl(colorBuffer, out depthBuffer);
    156         }
    157 
    158         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    159         private extern void SetTargetBuffersImpl(out RenderBuffer color, out RenderBuffer depth);
    160         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    161         private extern void SetTargetBuffersMRTImpl(RenderBuffer[] color, out RenderBuffer depth);
    162         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    163         public static extern void SetupCurrent(Camera cur);
    164         public Ray ViewportPointToRay(Vector3 position)
    165         {
    166             return INTERNAL_CALL_ViewportPointToRay(this, ref position);
    167         }
    168 
    169         public Vector3 ViewportToScreenPoint(Vector3 position)
    170         {
    171             return INTERNAL_CALL_ViewportToScreenPoint(this, ref position);
    172         }
    173 
    174         public Vector3 ViewportToWorldPoint(Vector3 position)
    175         {
    176             return INTERNAL_CALL_ViewportToWorldPoint(this, ref position);
    177         }
    178 
    179         public Vector3 WorldToScreenPoint(Vector3 position)
    180         {
    181             return INTERNAL_CALL_WorldToScreenPoint(this, ref position);
    182         }
    183 
    184         public Vector3 WorldToViewportPoint(Vector3 position)
    185         {
    186             return INTERNAL_CALL_WorldToViewportPoint(this, ref position);
    187         }
    188 
    189         public RenderingPath actualRenderingPath { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    190 
    191         public static Camera[] allCameras { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    192 
    193         public static int allCamerasCount { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    194 
    195         public float aspect { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    196 
    197         public Color backgroundColor
    198         {
    199             get
    200             {
    201                 Color color;
    202                 this.INTERNAL_get_backgroundColor(out color);
    203                 return color;
    204             }
    205             set
    206             {
    207                 this.INTERNAL_set_backgroundColor(ref value);
    208             }
    209         }
    210 
    211         public Matrix4x4 cameraToWorldMatrix
    212         {
    213             get
    214             {
    215                 Matrix4x4 matrixx;
    216                 this.INTERNAL_get_cameraToWorldMatrix(out matrixx);
    217                 return matrixx;
    218             }
    219         }
    220 
    221         public CameraClearFlags clearFlags { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    222 
    223         public bool clearStencilAfterLightingPass { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    224 
    225         public int cullingMask { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    226 
    227         public static Camera current { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    228 
    229         public float depth { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    230 
    231         public DepthTextureMode depthTextureMode { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    232 
    233         public int eventMask { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    234 
    235         [Obsolete("use Camera.farClipPlane instead.")]
    236         public float far
    237         {
    238             get
    239             {
    240                 return this.farClipPlane;
    241             }
    242             set
    243             {
    244                 this.farClipPlane = value;
    245             }
    246         }
    247 
    248         public float farClipPlane { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    249 
    250         public float fieldOfView { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    251 
    252         [Obsolete("use Camera.fieldOfView instead.")]
    253         public float fov
    254         {
    255             get
    256             {
    257                 return this.fieldOfView;
    258             }
    259             set
    260             {
    261                 this.fieldOfView = value;
    262             }
    263         }
    264 
    265         public bool hdr { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    266 
    267         public bool isOrthoGraphic
    268         {
    269             get
    270             {
    271                 return this.orthographic;
    272             }
    273             set
    274             {
    275                 this.orthographic = value;
    276             }
    277         }
    278 
    279         public float[] layerCullDistances { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    280 
    281         public bool layerCullSpherical { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    282 
    283         public static Camera main { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    284 
    285         [Obsolete("use Camera.main instead.")]
    286         public static Camera mainCamera
    287         {
    288             get
    289             {
    290                 return main;
    291             }
    292         }
    293 
    294         [Obsolete("use Camera.nearClipPlane instead.")]
    295         public float near
    296         {
    297             get
    298             {
    299                 return this.nearClipPlane;
    300             }
    301             set
    302             {
    303                 this.nearClipPlane = value;
    304             }
    305         }
    306 
    307         public float nearClipPlane { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    308 
    309         public bool orthographic { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    310 
    311         public float orthographicSize { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    312 
    313         public float pixelHeight { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    314 
    315         public Rect pixelRect
    316         {
    317             get
    318             {
    319                 Rect rect;
    320                 this.INTERNAL_get_pixelRect(out rect);
    321                 return rect;
    322             }
    323             set
    324             {
    325                 this.INTERNAL_set_pixelRect(ref value);
    326             }
    327         }
    328 
    329         public float pixelWidth { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    330 
    331         public Matrix4x4 projectionMatrix
    332         {
    333             get
    334             {
    335                 Matrix4x4 matrixx;
    336                 this.INTERNAL_get_projectionMatrix(out matrixx);
    337                 return matrixx;
    338             }
    339             set
    340             {
    341                 this.INTERNAL_set_projectionMatrix(ref value);
    342             }
    343         }
    344 
    345         public Rect rect
    346         {
    347             get
    348             {
    349                 Rect rect;
    350                 this.INTERNAL_get_rect(out rect);
    351                 return rect;
    352             }
    353             set
    354             {
    355                 this.INTERNAL_set_rect(ref value);
    356             }
    357         }
    358 
    359         public RenderingPath renderingPath { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    360 
    361         public float stereoConvergence { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    362 
    363         public bool stereoEnabled { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    364 
    365         public float stereoSeparation { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    366 
    367         public RenderTexture targetTexture { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    368 
    369         public TransparencySortMode transparencySortMode { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    370 
    371         public bool useOcclusionCulling { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    372 
    373         public Vector3 velocity
    374         {
    375             get
    376             {
    377                 Vector3 vector;
    378                 this.INTERNAL_get_velocity(out vector);
    379                 return vector;
    380             }
    381         }
    382 
    383         public Matrix4x4 worldToCameraMatrix
    384         {
    385             get
    386             {
    387                 Matrix4x4 matrixx;
    388                 this.INTERNAL_get_worldToCameraMatrix(out matrixx);
    389                 return matrixx;
    390             }
    391             set
    392             {
    393                 this.INTERNAL_set_worldToCameraMatrix(ref value);
    394             }
    395         }
    396     }
    397 }

## UnityEngine.Animator ##

![7JJJry.gif_web][]

1 namespace UnityEngine
      2 {
      3     using System;
      4     using System.Runtime.CompilerServices;
      5     using System.Runtime.InteropServices;
      6     using UnityEngine.Internal;
      7 
      8     public sealed class Animator : Behaviour
      9     {
     10         [ExcludeFromDocs]
     11         public void CrossFade(int stateNameHash, float transitionDuration)
     12         {
     13             float negativeInfinity = float.NegativeInfinity;
     14             int layer = -1;
     15             this.CrossFade(stateNameHash, transitionDuration, layer, negativeInfinity);
     16         }
     17 
     18         [ExcludeFromDocs]
     19         public void CrossFade(string stateName, float transitionDuration)
     20         {
     21             float negativeInfinity = float.NegativeInfinity;
     22             int layer = -1;
     23             this.CrossFade(stateName, transitionDuration, layer, negativeInfinity);
     24         }
     25 
     26         [ExcludeFromDocs]
     27         public void CrossFade(int stateNameHash, float transitionDuration, int layer)
     28         {
     29             float negativeInfinity = float.NegativeInfinity;
     30             this.CrossFade(stateNameHash, transitionDuration, layer, negativeInfinity);
     31         }
     32 
     33         [ExcludeFromDocs]
     34         public void CrossFade(string stateName, float transitionDuration, int layer)
     35         {
     36             float negativeInfinity = float.NegativeInfinity;
     37             this.CrossFade(stateName, transitionDuration, layer, negativeInfinity);
     38         }
     39 
     40         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     41         public extern void CrossFade(int stateNameHash, float transitionDuration, [DefaultValue("-1")] int layer, [DefaultValue("float.NegativeInfinity")] float normalizedTime);
     42         public void CrossFade(string stateName, float transitionDuration, [DefaultValue("-1")] int layer, [DefaultValue("float.NegativeInfinity")] float normalizedTime)
     43         {
     44             this.CrossFade(StringToHash(stateName), transitionDuration, layer, normalizedTime);
     45         }
     46 
     47         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     48         internal extern void EvaluateSM();
     49         [Obsolete("ForceStateNormalizedTime is deprecated. Please use Play or CrossFade instead.")]
     50         public void ForceStateNormalizedTime(float normalizedTime)
     51         {
     52             this.Play(0, 0, normalizedTime);
     53         }
     54 
     55         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     56         public extern AnimatorTransitionInfo GetAnimatorTransitionInfo(int layerIndex);
     57         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     58         public extern Transform GetBoneTransform(HumanBodyBones humanBoneId);
     59         public bool GetBool(int id)
     60         {
     61             return this.GetBoolID(id);
     62         }
     63 
     64         public bool GetBool(string name)
     65         {
     66             return this.GetBoolString(name);
     67         }
     68 
     69         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     70         private extern bool GetBoolID(int id);
     71         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     72         private extern bool GetBoolString(string name);
     73         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     74         public extern AnimationInfo[] GetCurrentAnimationClipState(int layerIndex);
     75         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     76         public extern AnimatorStateInfo GetCurrentAnimatorStateInfo(int layerIndex);
     77         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     78         internal extern string GetCurrentStateName(int layerIndex);
     79         public float GetFloat(int id)
     80         {
     81             return this.GetFloatID(id);
     82         }
     83 
     84         public float GetFloat(string name)
     85         {
     86             return this.GetFloatString(name);
     87         }
     88 
     89         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     90         private extern float GetFloatID(int id);
     91         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     92         private extern float GetFloatString(string name);
     93         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     94         public extern Vector3 GetIKPosition(AvatarIKGoal goal);
     95         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     96         public extern float GetIKPositionWeight(AvatarIKGoal goal);
     97         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     98         public extern Quaternion GetIKRotation(AvatarIKGoal goal);
     99         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    100         public extern float GetIKRotationWeight(AvatarIKGoal goal);
    101         public int GetInteger(int id)
    102         {
    103             return this.GetIntegerID(id);
    104         }
    105 
    106         public int GetInteger(string name)
    107         {
    108             return this.GetIntegerString(name);
    109         }
    110 
    111         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    112         private extern int GetIntegerID(int id);
    113         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    114         private extern int GetIntegerString(string name);
    115         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    116         public extern string GetLayerName(int layerIndex);
    117         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    118         public extern float GetLayerWeight(int layerIndex);
    119         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    120         public extern AnimationInfo[] GetNextAnimationClipState(int layerIndex);
    121         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    122         public extern AnimatorStateInfo GetNextAnimatorStateInfo(int layerIndex);
    123         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    124         internal extern string GetNextStateName(int layerIndex);
    125         [Obsolete("GetQuaternion is deprecated.")]
    126         public Quaternion GetQuaternion(int id)
    127         {
    128             return Quaternion.identity;
    129         }
    130 
    131         [Obsolete("GetQuaternion is deprecated.")]
    132         public Quaternion GetQuaternion(string name)
    133         {
    134             return Quaternion.identity;
    135         }
    136 
    137         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    138         internal extern string GetStats();
    139         [Obsolete("GetVector is deprecated.")]
    140         public Vector3 GetVector(int id)
    141         {
    142             return Vector3.zero;
    143         }
    144 
    145         [Obsolete("GetVector is deprecated.")]
    146         public Vector3 GetVector(string name)
    147         {
    148             return Vector3.zero;
    149         }
    150 
    151         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    152         private static extern void INTERNAL_CALL_MatchTarget(Animator self, ref Vector3 matchPosition, ref Quaternion matchRotation, AvatarTarget targetBodyPart, ref MatchTargetWeightMask weightMask, float startNormalizedTime, float targetNormalizedTime);
    153         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    154         private static extern void INTERNAL_CALL_SetIKPosition(Animator self, AvatarIKGoal goal, ref Vector3 goalPosition);
    155         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    156         private static extern void INTERNAL_CALL_SetIKRotation(Animator self, AvatarIKGoal goal, ref Quaternion goalRotation);
    157         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    158         private static extern void INTERNAL_CALL_SetLookAtPosition(Animator self, ref Vector3 lookAtPosition);
    159         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    160         private extern void INTERNAL_get_bodyPosition(out Vector3 value);
    161         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    162         private extern void INTERNAL_get_bodyRotation(out Quaternion value);
    163         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    164         private extern void INTERNAL_get_rootPosition(out Vector3 value);
    165         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    166         private extern void INTERNAL_get_rootRotation(out Quaternion value);
    167         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    168         private extern void INTERNAL_set_bodyPosition(ref Vector3 value);
    169         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    170         private extern void INTERNAL_set_bodyRotation(ref Quaternion value);
    171         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    172         private extern void INTERNAL_set_rootPosition(ref Vector3 value);
    173         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    174         private extern void INTERNAL_set_rootRotation(ref Quaternion value);
    175         [ExcludeFromDocs]
    176         public void InterruptMatchTarget()
    177         {
    178             bool completeMatch = true;
    179             this.InterruptMatchTarget(completeMatch);
    180         }
    181 
    182         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    183         public extern void InterruptMatchTarget([DefaultValue("true")] bool completeMatch);
    184         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    185         internal extern bool IsBoneTransform(Transform transform);
    186         [MethodImpl(MethodImplOptions.InternalCall), Obsolete("use mask and layers to control subset of transfroms in a skeleton", true), WrapperlessIcall]
    187         public extern bool IsControlled(Transform transform);
    188         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    189         public extern bool IsInTransition(int layerIndex);
    190         public bool IsParameterControlledByCurve(int id)
    191         {
    192             return this.IsParameterControlledByCurveID(id);
    193         }
    194 
    195         public bool IsParameterControlledByCurve(string name)
    196         {
    197             return this.IsParameterControlledByCurveString(name);
    198         }
    199 
    200         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    201         private extern bool IsParameterControlledByCurveID(int id);
    202         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    203         private extern bool IsParameterControlledByCurveString(string name);
    204         [ExcludeFromDocs]
    205         public void MatchTarget(Vector3 matchPosition, Quaternion matchRotation, AvatarTarget targetBodyPart, MatchTargetWeightMask weightMask, float startNormalizedTime)
    206         {
    207             float targetNormalizedTime = 1f;
    208             INTERNAL_CALL_MatchTarget(this, ref matchPosition, ref matchRotation, targetBodyPart, ref weightMask, startNormalizedTime, targetNormalizedTime);
    209         }
    210 
    211         public void MatchTarget(Vector3 matchPosition, Quaternion matchRotation, AvatarTarget targetBodyPart, MatchTargetWeightMask weightMask, float startNormalizedTime, [DefaultValue("1")] float targetNormalizedTime)
    212         {
    213             INTERNAL_CALL_MatchTarget(this, ref matchPosition, ref matchRotation, targetBodyPart, ref weightMask, startNormalizedTime, targetNormalizedTime);
    214         }
    215 
    216         [ExcludeFromDocs]
    217         public void Play(int stateNameHash)
    218         {
    219             float negativeInfinity = float.NegativeInfinity;
    220             int layer = -1;
    221             this.Play(stateNameHash, layer, negativeInfinity);
    222         }
    223 
    224         [ExcludeFromDocs]
    225         public void Play(string stateName)
    226         {
    227             float negativeInfinity = float.NegativeInfinity;
    228             int layer = -1;
    229             this.Play(stateName, layer, negativeInfinity);
    230         }
    231 
    232         [ExcludeFromDocs]
    233         public void Play(int stateNameHash, int layer)
    234         {
    235             float negativeInfinity = float.NegativeInfinity;
    236             this.Play(stateNameHash, layer, negativeInfinity);
    237         }
    238 
    239         [ExcludeFromDocs]
    240         public void Play(string stateName, int layer)
    241         {
    242             float negativeInfinity = float.NegativeInfinity;
    243             this.Play(stateName, layer, negativeInfinity);
    244         }
    245 
    246         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    247         public extern void Play(int stateNameHash, [DefaultValue("-1")] int layer, [DefaultValue("float.NegativeInfinity")] float normalizedTime);
    248         public void Play(string stateName, [DefaultValue("-1")] int layer, [DefaultValue("float.NegativeInfinity")] float normalizedTime)
    249         {
    250             this.Play(StringToHash(stateName), layer, normalizedTime);
    251         }
    252 
    253         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    254         public extern void Rebind();
    255         public void ResetTrigger(int id)
    256         {
    257             this.ResetTriggerID(id);
    258         }
    259 
    260         public void ResetTrigger(string name)
    261         {
    262             this.ResetTriggerString(name);
    263         }
    264 
    265         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    266         private extern void ResetTriggerID(int id);
    267         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    268         private extern void ResetTriggerString(string name);
    269         public void SetBool(int id, bool value)
    270         {
    271             this.SetBoolID(id, value);
    272         }
    273 
    274         public void SetBool(string name, bool value)
    275         {
    276             this.SetBoolString(name, value);
    277         }
    278 
    279         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    280         private extern void SetBoolID(int id, bool value);
    281         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    282         private extern void SetBoolString(string name, bool value);
    283         public void SetFloat(int id, float value)
    284         {
    285             this.SetFloatID(id, value);
    286         }
    287 
    288         public void SetFloat(string name, float value)
    289         {
    290             this.SetFloatString(name, value);
    291         }
    292 
    293         public void SetFloat(int id, float value, float dampTime, float deltaTime)
    294         {
    295             this.SetFloatIDDamp(id, value, dampTime, deltaTime);
    296         }
    297 
    298         public void SetFloat(string name, float value, float dampTime, float deltaTime)
    299         {
    300             this.SetFloatStringDamp(name, value, dampTime, deltaTime);
    301         }
    302 
    303         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    304         private extern void SetFloatID(int id, float value);
    305         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    306         private extern void SetFloatIDDamp(int id, float value, float dampTime, float deltaTime);
    307         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    308         private extern void SetFloatString(string name, float value);
    309         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    310         private extern void SetFloatStringDamp(string name, float value, float dampTime, float deltaTime);
    311         public void SetIKPosition(AvatarIKGoal goal, Vector3 goalPosition)
    312         {
    313             INTERNAL_CALL_SetIKPosition(this, goal, ref goalPosition);
    314         }
    315 
    316         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    317         public extern void SetIKPositionWeight(AvatarIKGoal goal, float value);
    318         public void SetIKRotation(AvatarIKGoal goal, Quaternion goalRotation)
    319         {
    320             INTERNAL_CALL_SetIKRotation(this, goal, ref goalRotation);
    321         }
    322 
    323         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    324         public extern void SetIKRotationWeight(AvatarIKGoal goal, float value);
    325         public void SetInteger(int id, int value)
    326         {
    327             this.SetIntegerID(id, value);
    328         }
    329 
    330         public void SetInteger(string name, int value)
    331         {
    332             this.SetIntegerString(name, value);
    333         }
    334 
    335         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    336         private extern void SetIntegerID(int id, int value);
    337         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    338         private extern void SetIntegerString(string name, int value);
    339         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    340         public extern void SetLayerWeight(int layerIndex, float weight);
    341         public void SetLookAtPosition(Vector3 lookAtPosition)
    342         {
    343             INTERNAL_CALL_SetLookAtPosition(this, ref lookAtPosition);
    344         }
    345 
    346         [ExcludeFromDocs]
    347         public void SetLookAtWeight(float weight)
    348         {
    349             float clampWeight = 0.5f;
    350             float eyesWeight = 0f;
    351             float headWeight = 1f;
    352             float bodyWeight = 0f;
    353             this.SetLookAtWeight(weight, bodyWeight, headWeight, eyesWeight, clampWeight);
    354         }
    355 
    356         [ExcludeFromDocs]
    357         public void SetLookAtWeight(float weight, float bodyWeight)
    358         {
    359             float clampWeight = 0.5f;
    360             float eyesWeight = 0f;
    361             float headWeight = 1f;
    362             this.SetLookAtWeight(weight, bodyWeight, headWeight, eyesWeight, clampWeight);
    363         }
    364 
    365         [ExcludeFromDocs]
    366         public void SetLookAtWeight(float weight, float bodyWeight, float headWeight)
    367         {
    368             float clampWeight = 0.5f;
    369             float eyesWeight = 0f;
    370             this.SetLookAtWeight(weight, bodyWeight, headWeight, eyesWeight, clampWeight);
    371         }
    372 
    373         [ExcludeFromDocs]
    374         public void SetLookAtWeight(float weight, float bodyWeight, float headWeight, float eyesWeight)
    375         {
    376             float clampWeight = 0.5f;
    377             this.SetLookAtWeight(weight, bodyWeight, headWeight, eyesWeight, clampWeight);
    378         }
    379 
    380         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    381         public extern void SetLookAtWeight(float weight, [DefaultValue("0.00f")] float bodyWeight, [DefaultValue("1.00f")] float headWeight, [DefaultValue("0.00f")] float eyesWeight, [DefaultValue("0.50f")] float clampWeight);
    382         [Obsolete("SetQuaternion is deprecated.")]
    383         public void SetQuaternion(int id, Quaternion value)
    384         {
    385         }
    386 
    387         [Obsolete("SetQuaternion is deprecated.")]
    388         public void SetQuaternion(string name, Quaternion value)
    389         {
    390         }
    391 
    392         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    393         public extern void SetTarget(AvatarTarget targetIndex, float targetNormalizedTime);
    394         public void SetTrigger(int id)
    395         {
    396             this.SetTriggerID(id);
    397         }
    398 
    399         public void SetTrigger(string name)
    400         {
    401             this.SetTriggerString(name);
    402         }
    403 
    404         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    405         private extern void SetTriggerID(int id);
    406         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    407         private extern void SetTriggerString(string name);
    408         [Obsolete("SetVector is deprecated.")]
    409         public void SetVector(int id, Vector3 value)
    410         {
    411         }
    412 
    413         [Obsolete("SetVector is deprecated.")]
    414         public void SetVector(string name, Vector3 value)
    415         {
    416         }
    417 
    418         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    419         public extern void StartPlayback();
    420         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    421         public extern void StartRecording(int frameCount);
    422         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    423         public extern void StopPlayback();
    424         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    425         public extern void StopRecording();
    426         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    427         public static extern int StringToHash(string name);
    428         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    429         public extern void Update(float deltaTime);
    430         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    431         internal extern void WriteDefaultPose();
    432 
    433         internal bool allowConstantClipSamplingOptimization { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    434 
    435         [Obsolete("Use AnimationMode.updateMode instead")]
    436         public bool animatePhysics
    437         {
    438             get
    439             {
    440                 return (this.updateMode == AnimatorUpdateMode.AnimatePhysics);
    441             }
    442             set
    443             {
    444                 this.updateMode = !value ? AnimatorUpdateMode.Normal : AnimatorUpdateMode.AnimatePhysics;
    445             }
    446         }
    447 
    448         public bool applyRootMotion { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    449 
    450         public Avatar avatar { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    451 
    452         internal Transform avatarRoot { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    453 
    454         public Vector3 bodyPosition
    455         {
    456             get
    457             {
    458                 Vector3 vector;
    459                 this.INTERNAL_get_bodyPosition(out vector);
    460                 return vector;
    461             }
    462             set
    463             {
    464                 this.INTERNAL_set_bodyPosition(ref value);
    465             }
    466         }
    467 
    468         public Quaternion bodyRotation
    469         {
    470             get
    471             {
    472                 Quaternion quaternion;
    473                 this.INTERNAL_get_bodyRotation(out quaternion);
    474                 return quaternion;
    475             }
    476             set
    477             {
    478                 this.INTERNAL_set_bodyRotation(ref value);
    479             }
    480         }
    481 
    482         public AnimatorCullingMode cullingMode { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    483 
    484         public Vector3 deltaPosition { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    485 
    486         public Quaternion deltaRotation { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    487 
    488         public float feetPivotActive { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    489 
    490         public bool fireEvents { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    491 
    492         public float gravityWeight { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    493 
    494         public bool hasRootMotion { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    495 
    496         public bool hasTransformHierarchy { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    497 
    498         public float humanScale { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    499 
    500         public bool isHuman { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    501 
    502         private bool isInManagerList { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    503 
    504         public bool isMatchingTarget { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    505 
    506         public bool isOptimizable { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    507 
    508         public int layerCount { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    509 
    510         public bool layersAffectMassCenter { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    511 
    512         public float leftFeetBottomHeight { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    513 
    514         public bool logWarnings { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    515 
    516         public Vector3 pivotPosition { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    517 
    518         public float pivotWeight { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    519 
    520         public float playbackTime { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    521 
    522         public float recorderStartTime { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    523 
    524         public float recorderStopTime { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    525 
    526         public float rightFeetBottomHeight { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    527 
    528         public Vector3 rootPosition
    529         {
    530             get
    531             {
    532                 Vector3 vector;
    533                 this.INTERNAL_get_rootPosition(out vector);
    534                 return vector;
    535             }
    536             set
    537             {
    538                 this.INTERNAL_set_rootPosition(ref value);
    539             }
    540         }
    541 
    542         public Quaternion rootRotation
    543         {
    544             get
    545             {
    546                 Quaternion quaternion;
    547                 this.INTERNAL_get_rootRotation(out quaternion);
    548                 return quaternion;
    549             }
    550             set
    551             {
    552                 this.INTERNAL_set_rootRotation(ref value);
    553             }
    554         }
    555 
    556         public RuntimeAnimatorController runtimeAnimatorController { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    557 
    558         public float speed { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    559 
    560         public bool stabilizeFeet { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    561 
    562         internal bool supportsOnAnimatorMove { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    563 
    564         public Vector3 targetPosition { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    565 
    566         public Quaternion targetRotation { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    567 
    568         public AnimatorUpdateMode updateMode { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    569     }
    570 }

## UnityEngine.AudioSource ##

![7JJJry.gif_web][]

1 namespace UnityEngine
      2 {
      3     using System;
      4     using System.Runtime.CompilerServices;
      5     using UnityEngine.Internal;
      6 
      7     public sealed class AudioSource : Behaviour
      8     {
      9         [Obsolete("GetOutputData return a float[] is deprecated, use GetOutputData passing a pre allocated array instead.")]
     10         public float[] GetOutputData(int numSamples, int channel)
     11         {
     12             float[] samples = new float[numSamples];
     13             this.GetOutputDataHelper(samples, channel);
     14             return samples;
     15         }
     16 
     17         public void GetOutputData(float[] samples, int channel)
     18         {
     19             this.GetOutputDataHelper(samples, channel);
     20         }
     21 
     22         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     23         private extern void GetOutputDataHelper(float[] samples, int channel);
     24         [Obsolete("GetSpectrumData returning a float[] is deprecated, use GetSpectrumData passing a pre allocated array instead.")]
     25         public float[] GetSpectrumData(int numSamples, int channel, FFTWindow window)
     26         {
     27             float[] samples = new float[numSamples];
     28             this.GetSpectrumDataHelper(samples, channel, window);
     29             return samples;
     30         }
     31 
     32         public void GetSpectrumData(float[] samples, int channel, FFTWindow window)
     33         {
     34             this.GetSpectrumDataHelper(samples, channel, window);
     35         }
     36 
     37         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     38         private extern void GetSpectrumDataHelper(float[] samples, int channel, FFTWindow window);
     39         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     40         private static extern void INTERNAL_CALL_Pause(AudioSource self);
     41         public void Pause()
     42         {
     43             INTERNAL_CALL_Pause(this);
     44         }
     45 
     46         [ExcludeFromDocs]
     47         public void Play()
     48         {
     49             ulong delay = 0L;
     50             this.Play(delay);
     51         }
     52 
     53         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     54         public extern void Play([DefaultValue("0")] ulong delay);
     55         [ExcludeFromDocs]
     56         public static void PlayClipAtPoint(AudioClip clip, Vector3 position)
     57         {
     58             float volume = 1f;
     59             PlayClipAtPoint(clip, position, volume);
     60         }
     61 
     62         public static void PlayClipAtPoint(AudioClip clip, Vector3 position, [DefaultValue("1.0F")] float volume)
     63         {
     64             GameObject obj2 = new GameObject("One shot audio") {
     65                 transform = { position = position }
     66             };
     67             AudioSource source = (AudioSource) obj2.AddComponent(typeof(AudioSource));
     68             source.clip = clip;
     69             source.volume = volume;
     70             source.Play();
     71             UnityEngine.Object.Destroy(obj2, clip.length * Time.timeScale);
     72         }
     73 
     74         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     75         public extern void PlayDelayed(float delay);
     76         [ExcludeFromDocs]
     77         public void PlayOneShot(AudioClip clip)
     78         {
     79             float volumeScale = 1f;
     80             this.PlayOneShot(clip, volumeScale);
     81         }
     82 
     83         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     84         public extern void PlayOneShot(AudioClip clip, [DefaultValue("1.0F")] float volumeScale);
     85         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     86         public extern void PlayScheduled(double time);
     87         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     88         public extern void SetScheduledEndTime(double time);
     89         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     90         public extern void SetScheduledStartTime(double time);
     91         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     92         public extern void Stop();
     93 
     94         public bool bypassEffects { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
     95 
     96         public bool bypassListenerEffects { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
     97 
     98         public bool bypassReverbZones { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
     99 
    100         public AudioClip clip { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    101 
    102         public float dopplerLevel { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    103 
    104         public bool ignoreListenerPause { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    105 
    106         public bool ignoreListenerVolume { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    107 
    108         public bool isPlaying { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    109 
    110         public bool loop { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    111 
    112         public float maxDistance { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    113 
    114         [Obsolete("maxVolume is not supported anymore. Use min-, maxDistance and rolloffMode instead.", true)]
    115         public float maxVolume { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    116 
    117         public float minDistance { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    118 
    119         [Obsolete("minVolume is not supported anymore. Use min-, maxDistance and rolloffMode instead.", true)]
    120         public float minVolume { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    121 
    122         public bool mute { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    123 
    124         public float pan { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    125 
    126         public float panLevel { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    127 
    128         public float pitch { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    129 
    130         public bool playOnAwake { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    131 
    132         public int priority { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    133 
    134         [Obsolete("rolloffFactor is not supported anymore. Use min-, maxDistance and rolloffMode instead.", true)]
    135         public float rolloffFactor { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    136 
    137         public AudioRolloffMode rolloffMode { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    138 
    139         public float spread { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    140 
    141         public float time { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    142 
    143         public int timeSamples { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    144 
    145         public AudioVelocityUpdateMode velocityUpdateMode { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    146 
    147         public float volume { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    148     }
    149 }

## UnityEngine.Light ##

![7JJJry.gif_web][]

1 namespace UnityEngine
      2 {
      3     using System;
      4     using System.Runtime.CompilerServices;
      5     using System.Runtime.InteropServices;
      6 
      7     public sealed class Light : Behaviour
      8     {
      9         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     10         public static extern Light[] GetLights(LightType type, int layer);
     11         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     12         private extern void INTERNAL_get_areaSize(out Vector2 value);
     13         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     14         private extern void INTERNAL_get_color(out Color value);
     15         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     16         private extern void INTERNAL_set_areaSize(ref Vector2 value);
     17         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     18         private extern void INTERNAL_set_color(ref Color value);
     19 
     20         public bool alreadyLightmapped { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
     21 
     22         public Vector2 areaSize
     23         {
     24             get
     25             {
     26                 Vector2 vector;
     27                 this.INTERNAL_get_areaSize(out vector);
     28                 return vector;
     29             }
     30             set
     31             {
     32                 this.INTERNAL_set_areaSize(ref value);
     33             }
     34         }
     35 
     36         [Obsolete("light.attenuate was removed; all lights always attenuate now", true)]
     37         public bool attenuate
     38         {
     39             get
     40             {
     41                 return true;
     42             }
     43             set
     44             {
     45             }
     46         }
     47 
     48         public Color color
     49         {
     50             get
     51             {
     52                 Color color;
     53                 this.INTERNAL_get_color(out color);
     54                 return color;
     55             }
     56             set
     57             {
     58                 this.INTERNAL_set_color(ref value);
     59             }
     60         }
     61 
     62         public Texture cookie { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
     63 
     64         public float cookieSize { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
     65 
     66         public int cullingMask { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
     67 
     68         public Flare flare { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
     69 
     70         public float intensity { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
     71 
     72         [Obsolete("Use QualitySettings.pixelLightCount instead.")]
     73         public static int pixelLightCount { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
     74 
     75         public float range { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
     76 
     77         public LightRenderMode renderMode { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
     78 
     79         public float shadowBias { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
     80 
     81         [Obsolete("light.shadowConstantBias was removed, use light.shadowBias", true)]
     82         public float shadowConstantBias
     83         {
     84             get
     85             {
     86                 return 0f;
     87             }
     88             set
     89             {
     90             }
     91         }
     92 
     93         [Obsolete("light.shadowObjectSizeBias was removed, use light.shadowBias", true)]
     94         public float shadowObjectSizeBias
     95         {
     96             get
     97             {
     98                 return 0f;
     99             }
    100             set
    101             {
    102             }
    103         }
    104 
    105         public LightShadows shadows { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    106 
    107         public float shadowSoftness { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    108 
    109         public float shadowSoftnessFade { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    110 
    111         public float shadowStrength { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    112 
    113         public float spotAngle { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    114 
    115         public LightType type { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    116     }
    117 }

## UnityEngine.Animation ##

![7JJJry.gif_web][]

1 namespace UnityEngine
      2 {
      3     using System;
      4     using System.Collections;
      5     using System.Reflection;
      6     using System.Runtime.CompilerServices;
      7     using System.Runtime.InteropServices;
      8     using UnityEngine.Internal;
      9 
     10     public sealed class Animation : Behaviour, IEnumerable
     11     {
     12         public void AddClip(AnimationClip clip, string newName)
     13         {
     14             this.AddClip(clip, newName, -2147483648, 0x7fffffff);
     15         }
     16 
     17         [ExcludeFromDocs]
     18         public void AddClip(AnimationClip clip, string newName, int firstFrame, int lastFrame)
     19         {
     20             bool addLoopFrame = false;
     21             this.AddClip(clip, newName, firstFrame, lastFrame, addLoopFrame);
     22         }
     23 
     24         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     25         public extern void AddClip(AnimationClip clip, string newName, int firstFrame, int lastFrame, [DefaultValue("false")] bool addLoopFrame);
     26         [ExcludeFromDocs]
     27         public void Blend(string animation)
     28         {
     29             float fadeLength = 0.3f;
     30             float targetWeight = 1f;
     31             this.Blend(animation, targetWeight, fadeLength);
     32         }
     33 
     34         [ExcludeFromDocs]
     35         public void Blend(string animation, float targetWeight)
     36         {
     37             float fadeLength = 0.3f;
     38             this.Blend(animation, targetWeight, fadeLength);
     39         }
     40 
     41         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     42         public extern void Blend(string animation, [DefaultValue("1.0F")] float targetWeight, [DefaultValue("0.3F")] float fadeLength);
     43         [ExcludeFromDocs]
     44         public void CrossFade(string animation)
     45         {
     46             PlayMode stopSameLayer = PlayMode.StopSameLayer;
     47             float fadeLength = 0.3f;
     48             this.CrossFade(animation, fadeLength, stopSameLayer);
     49         }
     50 
     51         [ExcludeFromDocs]
     52         public void CrossFade(string animation, float fadeLength)
     53         {
     54             PlayMode stopSameLayer = PlayMode.StopSameLayer;
     55             this.CrossFade(animation, fadeLength, stopSameLayer);
     56         }
     57 
     58         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     59         public extern void CrossFade(string animation, [DefaultValue("0.3F")] float fadeLength, [DefaultValue("PlayMode.StopSameLayer")] PlayMode mode);
     60         [ExcludeFromDocs]
     61         public AnimationState CrossFadeQueued(string animation)
     62         {
     63             PlayMode stopSameLayer = PlayMode.StopSameLayer;
     64             QueueMode completeOthers = QueueMode.CompleteOthers;
     65             float fadeLength = 0.3f;
     66             return this.CrossFadeQueued(animation, fadeLength, completeOthers, stopSameLayer);
     67         }
     68 
     69         [ExcludeFromDocs]
     70         public AnimationState CrossFadeQueued(string animation, float fadeLength)
     71         {
     72             PlayMode stopSameLayer = PlayMode.StopSameLayer;
     73             QueueMode completeOthers = QueueMode.CompleteOthers;
     74             return this.CrossFadeQueued(animation, fadeLength, completeOthers, stopSameLayer);
     75         }
     76 
     77         [ExcludeFromDocs]
     78         public AnimationState CrossFadeQueued(string animation, float fadeLength, QueueMode queue)
     79         {
     80             PlayMode stopSameLayer = PlayMode.StopSameLayer;
     81             return this.CrossFadeQueued(animation, fadeLength, queue, stopSameLayer);
     82         }
     83 
     84         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     85         public extern AnimationState CrossFadeQueued(string animation, [DefaultValue("0.3F")] float fadeLength, [DefaultValue("QueueMode.CompleteOthers")] QueueMode queue, [DefaultValue("PlayMode.StopSameLayer")] PlayMode mode);
     86         public AnimationClip GetClip(string name)
     87         {
     88             AnimationState state = this.GetState(name);
     89             if (state != null)
     90             {
     91                 return state.clip;
     92             }
     93             return null;
     94         }
     95 
     96         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
     97         public extern int GetClipCount();
     98         public IEnumerator GetEnumerator()
     99         {
    100             return new Enumerator(this);
    101         }
    102 
    103         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    104         internal extern AnimationState GetState(string name);
    105         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    106         internal extern AnimationState GetStateAtIndex(int index);
    107         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    108         internal extern int GetStateCount();
    109         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    110         private static extern void INTERNAL_CALL_Rewind(Animation self);
    111         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    112         private static extern void INTERNAL_CALL_Sample(Animation self);
    113         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    114         private static extern void INTERNAL_CALL_Stop(Animation self);
    115         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    116         private static extern void INTERNAL_CALL_SyncLayer(Animation self, int layer);
    117         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    118         private extern void INTERNAL_get_localBounds(out Bounds value);
    119         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    120         private extern void Internal_RewindByName(string name);
    121         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    122         private extern void INTERNAL_set_localBounds(ref Bounds value);
    123         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    124         private extern void Internal_StopByName(string name);
    125         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    126         public extern bool IsPlaying(string name);
    127         [ExcludeFromDocs]
    128         public bool Play()
    129         {
    130             PlayMode stopSameLayer = PlayMode.StopSameLayer;
    131             return this.Play(stopSameLayer);
    132         }
    133 
    134         [ExcludeFromDocs]
    135         public bool Play(string animation)
    136         {
    137             PlayMode stopSameLayer = PlayMode.StopSameLayer;
    138             return this.Play(animation, stopSameLayer);
    139         }
    140 
    141         [Obsolete("use PlayMode instead of AnimationPlayMode.")]
    142         public bool Play(AnimationPlayMode mode)
    143         {
    144             return this.PlayDefaultAnimation((PlayMode) mode);
    145         }
    146 
    147         public bool Play([DefaultValue("PlayMode.StopSameLayer")] PlayMode mode)
    148         {
    149             return this.PlayDefaultAnimation(mode);
    150         }
    151 
    152         [Obsolete("use PlayMode instead of AnimationPlayMode.")]
    153         public bool Play(string animation, AnimationPlayMode mode)
    154         {
    155             return this.Play(animation, (PlayMode) mode);
    156         }
    157 
    158         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    159         public extern bool Play(string animation, [DefaultValue("PlayMode.StopSameLayer")] PlayMode mode);
    160         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    161         private extern bool PlayDefaultAnimation(PlayMode mode);
    162         [ExcludeFromDocs]
    163         public AnimationState PlayQueued(string animation)
    164         {
    165             PlayMode stopSameLayer = PlayMode.StopSameLayer;
    166             QueueMode completeOthers = QueueMode.CompleteOthers;
    167             return this.PlayQueued(animation, completeOthers, stopSameLayer);
    168         }
    169 
    170         [ExcludeFromDocs]
    171         public AnimationState PlayQueued(string animation, QueueMode queue)
    172         {
    173             PlayMode stopSameLayer = PlayMode.StopSameLayer;
    174             return this.PlayQueued(animation, queue, stopSameLayer);
    175         }
    176 
    177         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    178         public extern AnimationState PlayQueued(string animation, [DefaultValue("QueueMode.CompleteOthers")] QueueMode queue, [DefaultValue("PlayMode.StopSameLayer")] PlayMode mode);
    179         public void RemoveClip(string clipName)
    180         {
    181             this.RemoveClip2(clipName);
    182         }
    183 
    184         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    185         public extern void RemoveClip(AnimationClip clip);
    186         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    187         private extern void RemoveClip2(string clipName);
    188         public void Rewind()
    189         {
    190             INTERNAL_CALL_Rewind(this);
    191         }
    192 
    193         public void Rewind(string name)
    194         {
    195             this.Internal_RewindByName(name);
    196         }
    197 
    198         public void Sample()
    199         {
    200             INTERNAL_CALL_Sample(this);
    201         }
    202 
    203         public void Stop()
    204         {
    205             INTERNAL_CALL_Stop(this);
    206         }
    207 
    208         public void Stop(string name)
    209         {
    210             this.Internal_StopByName(name);
    211         }
    212 
    213         public void SyncLayer(int layer)
    214         {
    215             INTERNAL_CALL_SyncLayer(this, layer);
    216         }
    217 
    218         [Obsolete("Use cullingType instead")]
    219         public bool animateOnlyIfVisible { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    220 
    221         public bool animatePhysics { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    222 
    223         public AnimationClip clip { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    224 
    225         public AnimationCullingType cullingType { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    226 
    227         public bool isPlaying { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; }
    228 
    229         public AnimationState this[string name]
    230         {
    231             get
    232             {
    233                 return this.GetState(name);
    234             }
    235         }
    236 
    237         public Bounds localBounds
    238         {
    239             get
    240             {
    241                 Bounds bounds;
    242                 this.INTERNAL_get_localBounds(out bounds);
    243                 return bounds;
    244             }
    245             set
    246             {
    247                 this.INTERNAL_set_localBounds(ref value);
    248             }
    249         }
    250 
    251         public bool playAutomatically { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    252 
    253         public WrapMode wrapMode { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    254 
    255         private sealed class Enumerator : IEnumerator
    256         {
    257             private int m_CurrentIndex = -1;
    258             private Animation m_Outer;
    259 
    260             internal Enumerator(Animation outer)
    261             {
    262                 this.m_Outer = outer;
    263             }
    264 
    265             public bool MoveNext()
    266             {
    267                 int stateCount = this.m_Outer.GetStateCount();
    268                 this.m_CurrentIndex++;
    269                 return (this.m_CurrentIndex < stateCount);
    270             }
    271 
    272             public void Reset()
    273             {
    274                 this.m_CurrentIndex = -1;
    275             }
    276 
    277             public object Current
    278             {
    279                 get
    280                 {
    281                     return this.m_Outer.GetStateAtIndex(this.m_CurrentIndex);
    282                 }
    283             }
    284         }
    285     }
    286 }

## UnityEngine.Monobehaviour ##

![7JJJry.gif_web][]

1 namespace UnityEngine
     2 {
     3     using System;
     4     using System.Collections;
     5     using System.Runtime.CompilerServices;
     6     using UnityEngine.Internal;
     7 
     8     public class MonoBehaviour : Behaviour
     9     {
    10         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    11         public extern MonoBehaviour();
    12         public void CancelInvoke()
    13         {
    14             this.Internal_CancelInvokeAll();
    15         }
    16 
    17         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    18         public extern void CancelInvoke(string methodName);
    19         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    20         private extern void Internal_CancelInvokeAll();
    21         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    22         private extern bool Internal_IsInvokingAll();
    23         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    24         public extern void Invoke(string methodName, float time);
    25         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    26         public extern void InvokeRepeating(string methodName, float time, float repeatRate);
    27         public bool IsInvoking()
    28         {
    29             return this.Internal_IsInvokingAll();
    30         }
    31 
    32         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    33         public extern bool IsInvoking(string methodName);
    34         public static void print(object message)
    35         {
    36             Debug.Log(message);
    37         }
    38 
    39         public Coroutine StartCoroutine(IEnumerator routine)
    40         {
    41             return this.StartCoroutine_Auto(routine);
    42         }
    43 
    44         [ExcludeFromDocs]
    45         public Coroutine StartCoroutine(string methodName)
    46         {
    47             object obj2 = null;
    48             return this.StartCoroutine(methodName, obj2);
    49         }
    50 
    51         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    52         public extern Coroutine StartCoroutine(string methodName, [DefaultValue("null")] object value);
    53         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    54         public extern Coroutine StartCoroutine_Auto(IEnumerator routine);
    55         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    56         public extern void StopAllCoroutines();
    57         public void StopCoroutine(IEnumerator routine)
    58         {
    59             this.StopCoroutineViaEnumerator_Auto(routine);
    60         }
    61 
    62         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    63         public extern void StopCoroutine(string methodName);
    64         public void StopCoroutine(Coroutine routine)
    65         {
    66             this.StopCoroutine_Auto(routine);
    67         }
    68 
    69         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    70         internal extern void StopCoroutine_Auto(Coroutine routine);
    71         [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall]
    72         internal extern void StopCoroutineViaEnumerator_Auto(IEnumerator routine);
    73 
    74         public bool useGUILayout { [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] get; [MethodImpl(MethodImplOptions.InternalCall), WrapperlessIcall] set; }
    75     }
    76 }

## 总结 ##

[http_www.cnblogs.com_bitzhuwei_p_unity-core-types.html]: http://www.cnblogs.com/bitzhuwei/p/unity-core-types.html?utm_source=tuicool&utm_medium=referral
[Unity3D]: http://www.tuicool.com/topics/11080124
[eAFFZn3.png_web]: /images/20220731/ee531ee819ff49b782d9649c15cd8c68.png
[7JJJry.gif_web]: /images/20220731/68fa084c69ab4bb9953775322120d4fa.png