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 }

  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 }

  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 }

 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 }

  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 }

  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 }

  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 }

 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 }

  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 }

 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 }

 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 }

  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 }