diff options
Diffstat (limited to 'Runtime/Export/UnityEngineGameObject.txt')
| -rw-r--r-- | Runtime/Export/UnityEngineGameObject.txt | 439 |
1 files changed, 439 insertions, 0 deletions
diff --git a/Runtime/Export/UnityEngineGameObject.txt b/Runtime/Export/UnityEngineGameObject.txt new file mode 100644 index 0000000..1915db0 --- /dev/null +++ b/Runtime/Export/UnityEngineGameObject.txt @@ -0,0 +1,439 @@ +C++RAW + + +#include "UnityPrefix.h" +#include "Configuration/UnityConfigure.h" +#include "Runtime/Graphics/Transform.h" +#include "Runtime/Mono/MonoBehaviour.h" +#include "Runtime/BaseClasses/Tags.h" +#include "Runtime/Scripting/ScriptingUtility.h" +#include "Runtime/Export/GameObjectExport.h" +#if ENABLE_AUDIO +#include "Runtime/Audio/AudioSource.h" +#endif + +#include "Runtime/Animation/Animation.h" +#include "Runtime/Camera/Camera.h" + +#if ENABLE_PHYSICS +#include "Runtime/Dynamics/RigidBody.h" +#include "Runtime/Dynamics/ConstantForce.h" +#include "Runtime/Dynamics/HingeJoint.h" +#include "Runtime/Dynamics/Collider.h" +#endif +#if ENABLE_2D_PHYSICS +#include "Runtime/Physics2D/RigidBody2D.h" +#include "Runtime/Physics2D/Collider2D.h" +#endif +#include "Runtime/Camera/Light.h" +#include "Runtime/Filters/Renderer.h" +#if ENABLE_NETWORK +#include "Runtime/Network/NetworkView.h" +#endif +#include "Runtime/Camera/RenderLayers/GUIText.h" +#include "Runtime/Camera/RenderLayers/GUITexture.h" +#include "Runtime/Filters/Particles/ParticleEmitter.h" +#include "Runtime/Graphics/ParticleSystem/ParticleSystem.h" +#include "Runtime/Misc/GameObjectUtility.h" +#include "Runtime/Misc/GOCreation.h" +#include "Runtime/Scripting/ScriptingExportUtility.h" +#include "Runtime/Scripting/GetComponent.h" +#include "Runtime/Scripting/Scripting.h" + + +using namespace Unity; + +/* + Mono defines a bool as either 1 or 2 bytes. + On windows a bool on the C++ side needs to be 2 bytes. + We use the typemap to map bool's to short's. + When using the C++ keyword and you want to export a bool value + to mono you have to use a short on the C++ side. +*/ + +using namespace std; + +CSRAW +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Collections; +using UnityEngineInternal; + +namespace UnityEngine +{ + + + +// Base class for all entities in Unity scenes. +CSRAW +CLASS GameObject : Object + + // Creates a game object with a primitive mesh renderer and appropriate collider. + CSRAW + CUSTOM static GameObject CreatePrimitive (PrimitiveType type) + { + return Scripting::ScriptingWrapperFor(CreatePrimitive(type)); + } + + + + // Returns the component of Type /type/ if the game object has one attached, null if it doesn't. You can access both builtin components or scripts with this function. + + CSRAW + [TypeInferenceRule(TypeInferenceRules.TypeReferencedByFirstArgument)] + CUSTOM Component GetComponent (Type type) { return ScriptingGetComponentOfType (*self, type); } + + CSRAW + #if ENABLE_GENERICS + // Generic version. See the [[wiki:Generic Functions|Generic Functions]] page for more details. + public T GetComponent<T>() where T : Component { return GetComponent(typeof(T)) as T; } + #endif + + + // Returns the component with name /type/ if the game object has one attached, null if it doesn't. + + CSRAW + public Component GetComponent (string type) { return GetComponentByName(type); } + CUSTOM private Component GetComponentByName (string type) { return Scripting::GetScriptingWrapperOfComponentOfGameObject (*self, type); } + + + + + // Returns the component of Type /type/ in the GameObject or any of its children using depth first search. + + CSRAW + [TypeInferenceRule(TypeInferenceRules.TypeReferencedByFirstArgument)] + CSRAW public Component GetComponentInChildren (Type type) + { + if( activeInHierarchy ) { + + Component attachedCom = GetComponent (type); + if ( attachedCom != null ) + return attachedCom; + } + + Transform transform = this.transform; + if ( transform != null ) + { + foreach (Transform child in transform) + { + Component childCom = child.gameObject.GetComponentInChildren (type); + if (childCom != null) + return childCom; + } + } + + return null; + } + + CSRAW + #if ENABLE_GENERICS + // Generic version. See the [[wiki:Generic Functions|Generic Functions]] page for more details. + public T GetComponentInChildren<T>() where T : Component { return GetComponentInChildren(typeof(T)) as T; } + #endif + + // Editor only API that specifies if a game object is static. + AUTO_PROP bool isStatic GetIsStaticDeprecated SetIsStaticDeprecated + + CUSTOM_PROP internal bool isStaticBatchable { return self->IsStaticBatchable (); } + + // Returns all components of Type /type/ in the GameObject. + + CSRAW [CanConvertToFlash] + CSRAW public Component[] GetComponents (Type type) { return (Component[])GetComponentsInternal (type, false, false, true); } + + CSRAW + #if ENABLE_GENERICS + // Generic version. See the [[wiki:Generic Functions|Generic Functions]] page for more details. + public T[] GetComponents<T>() where T : Component + { + return (T[]) GetComponentsInternal(typeof(T), true, false, true); + } + #endif + + // Returns all components of Type /type/ in the GameObject or any of its children. + + CSRAW public Component[] GetComponentsInChildren (Type type, bool includeInactive = false) + { + return (Component[])GetComponentsInternal(type, false, true, includeInactive); + } + + CSRAW + #if ENABLE_GENERICS + // Generic version. See the [[wiki:Generic Functions|Generic Functions]] page for more details. + public T[] GetComponentsInChildren<T>(bool includeInactive) where T : Component + { + return (T[])GetComponentsInternal(typeof(T), true, true, includeInactive); + } + #endif + + CSRAW + #if ENABLE_GENERICS + // Manually supplying the overload because lucas cannot figure out how to patch cspreprocess to add template support to the overload generation code. + // Generic version. See the [[wiki:Generic Functions|Generic Functions]] page for more details. + public T[] GetComponentsInChildren<T>() where T : Component { return GetComponentsInChildren<T>(false); } + #endif + + + + CUSTOM private Component[] GetComponentsInternal(Type type, bool isGenericTypeArray, bool recursive, bool includeInactive) + { + DISALLOW_IN_CONSTRUCTOR return ScriptingGetComponentsOfType (*self, type, isGenericTypeArray, recursive, includeInactive); + } + + + C++RAW + #define FASTGO_QUERY_COMPONENT(x) GameObject& go = *self; return Scripting::GetComponentObjectToScriptingObject (go.QueryComponent (x), go, ClassID (x)); + + + // The [[Transform]] attached to this GameObject. (null if there is none attached) + CSRAW + CUSTOM_PROP Transform transform { FASTGO_QUERY_COMPONENT(Transform) } + + CONDITIONAL ENABLE_PHYSICS + // The [[Rigidbody]] attached to this GameObject (RO). (null if there is none attached) + CUSTOM_PROP Rigidbody rigidbody { FASTGO_QUERY_COMPONENT(Rigidbody) } + + CONDITIONAL ENABLE_2D_PHYSICS + CUSTOM_PROP Rigidbody2D rigidbody2D { FASTGO_QUERY_COMPONENT(Rigidbody2D) } + + // The [[Camera]] attached to this GameObject (RO). (null if there is none attached) + CUSTOM_PROP Camera camera { FASTGO_QUERY_COMPONENT(Camera) } + + // The [[Light]] attached to this GameObject (RO). (null if there is none attached) + CUSTOM_PROP Light light { FASTGO_QUERY_COMPONENT(Light) } + + // The [[Animation]] attached to this GameObject (RO). (null if there is none attached) + CUSTOM_PROP Animation animation { FASTGO_QUERY_COMPONENT(Animation) } + + // The [[ConstantForce]] attached to this GameObject (RO). (null if there is none attached) + CONDITIONAL ENABLE_PHYSICS + CUSTOM_PROP ConstantForce constantForce { FASTGO_QUERY_COMPONENT(ConstantForce) } + + // The [[Renderer]] attached to this GameObject (RO). (null if there is none attached) + CUSTOM_PROP Renderer renderer { FASTGO_QUERY_COMPONENT(Renderer) } + + // The [[AudioSource]] attached to this GameObject (RO). (null if there is none attached) + CONDITIONAL ENABLE_AUDIO + CUSTOM_PROP AudioSource audio { FASTGO_QUERY_COMPONENT(AudioSource) } + + // The [[GUIText]] attached to this GameObject (RO). (null if there is none attached) + CUSTOM_PROP GUIText guiText { FASTGO_QUERY_COMPONENT(GUIText) } + + CONDITIONAL ENABLE_NETWORK + // The [[NetworkView]] attached to this GameObject (RO). (null if there is none attached) + CUSTOM_PROP NetworkView networkView + { + #if ENABLE_NETWORK + FASTGO_QUERY_COMPONENT(NetworkView) + #else + return SCRIPTING_NULL; + #endif + } + + FLUSHCONDITIONS + + CSRAW +#if ENABLE_NETWORK + OBSOLETE warning Please use guiTexture instead +#endif + CUSTOM_PROP GUIElement guiElement { FASTGO_QUERY_COMPONENT(GUIElement) } + + // The [[GUITexture]] attached to this GameObject (RO). (null if there is none attached) + CUSTOM_PROP GUITexture guiTexture { FASTGO_QUERY_COMPONENT(GUITexture) } + + // The [[Collider]] attached to this GameObject (RO). (null if there is none attached) + CONDITIONAL ENABLE_PHYSICS + CUSTOM_PROP Collider collider { FASTGO_QUERY_COMPONENT(Collider) } + + CONDITIONAL ENABLE_2D_PHYSICS + CUSTOM_PROP Collider2D collider2D { FASTGO_QUERY_COMPONENT(Collider2D) } + + // The [[HingeJoint]] attached to this GameObject (RO). (null if there is none attached) + CONDITIONAL ENABLE_PHYSICS + CUSTOM_PROP HingeJoint hingeJoint { FASTGO_QUERY_COMPONENT(HingeJoint) } + + // The [[ParticleEmitter]] attached to this GameObject (RO). (null if there is none attached) + CUSTOM_PROP ParticleEmitter particleEmitter { FASTGO_QUERY_COMPONENT(ParticleEmitter) } + + // The [[ParticleSystem]] attached to this GameObject (RO). (null if there is none attached) + CUSTOM_PROP ParticleSystem particleSystem { FASTGO_QUERY_COMPONENT(ParticleSystem) } + + // The layer the game object is in. A layer is in the range [0...31] + AUTO_PROP int layer GetLayer SetLayer + + OBSOLETE warning GameObject.active is obsolete. Use GameObject.SetActive(), GameObject.activeSelf or GameObject.activeInHierarchy. + CSRAW + CUSTOM_PROP bool active { return self->IsActive (); } { self->SetSelfActive (value); } + + // Activates/Deactivates the GameObject. + CUSTOM void SetActive (bool value) { self->SetSelfActive (value); } + + // The local active state of this GameObject. + CUSTOM_PROP public bool activeSelf { return self->IsSelfActive (); } + + // Is the GameObject active in the scene? + CUSTOM_PROP public bool activeInHierarchy { return self->IsActive (); } + + OBSOLETE warning gameObject.SetActiveRecursively() is obsolete. Use GameObject.SetActive(), which is now inherited by children. + CUSTOM public void SetActiveRecursively (bool state) + { + self->SetActiveRecursivelyDeprecated (state); + } + + // The tag of this game object. + CUSTOM_PROP string tag + { + const string& tag = TagToString (self->GetTag ()); + if (!tag.empty ()) + return scripting_string_new(tag); + else + { + Scripting::RaiseMonoException ("GameObject has undefined tag!"); + return SCRIPTING_NULL; + } + } + { + self->SetTag (ExtractTagThrowing (value)); + } + + // Is this game object tagged with /tag/? + CUSTOM public bool CompareTag (string tag) + { + return ExtractTagThrowing (tag) == self->GetTag (); + } + + //*undocumented* + CUSTOM static GameObject FindGameObjectWithTag (string tag) + { + DISALLOW_IN_CONSTRUCTOR + int tagInt = ExtractTagThrowing (tag); + return Scripting::ScriptingWrapperFor(FindGameObjectWithTag (tagInt)); + } + + // Returns one active GameObject tagged /tag/. Returns null if no GameObject was found. + CSRAW static public GameObject FindWithTag (string tag) + { + return FindGameObjectWithTag(tag); + } + + // Returns a list of active GameObjects tagged /tag/. Returns null if no GameObject was found. + CUSTOM static GameObject[] FindGameObjectsWithTag (string tag) + { + DISALLOW_IN_CONSTRUCTOR + static vector<GameObject*> go; go.clear (); + int tagInt = ExtractTagThrowing (tag); + FindGameObjectsWithTag (tagInt, go); + ScriptingClassPtr goClass = Scripting::ClassIDToScriptingType (ClassID (GameObject)); + return CreateScriptingArrayFromUnityObjects(go,goClass); + } + + // Calls the method named /methodName/ on every [[MonoBehaviour]] in this game object and on every ancestor of the behaviour + CUSTOM void SendMessageUpwards (string methodName, object value = null, SendMessageOptions options = SendMessageOptions.RequireReceiver) + { + Scripting::SendScriptingMessageUpwards(*self, methodName, value, options); + } + + //*undocumented* Function is for convenience and avoid coming mistakes. + CSRAW public void SendMessageUpwards (string methodName, SendMessageOptions options) + { + SendMessageUpwards (methodName, null, options); + } + + // Calls the method named /methodName/ on every [[MonoBehaviour]] in this game object. + CUSTOM void SendMessage (string methodName, object value = null, SendMessageOptions options = SendMessageOptions.RequireReceiver) + { + Scripting::SendScriptingMessage(*self, methodName, value, options); + } + + //*undocumented* Function is for convenience and avoid coming mistakes. + CSRAW public void SendMessage (string methodName, SendMessageOptions options) + { + SendMessage (methodName, null, options); + } + + // Calls the method named /methodName/ on every [[MonoBehaviour]] in this game object or any of its children. + CUSTOM void BroadcastMessage (string methodName, object parameter = null, SendMessageOptions options = SendMessageOptions.RequireReceiver) + { + Scripting::BroadcastScriptingMessage(*self, methodName, parameter, options); + } + + //*undocumented* Function is for convenience and avoid coming mistakes. + CSRAW public void BroadcastMessage (string methodName, SendMessageOptions options) + { + BroadcastMessage (methodName, null, options); + } + + // Adds a component class named /className/ to the game object. + + CUSTOM Component AddComponent (string className) { return MonoAddComponent (*self, className.AsUTF8().c_str()); } + + // Adds a component class of type /componentType/ to the game object. C# Users can use a generic version + CSRAW + [TypeInferenceRule(TypeInferenceRules.TypeReferencedByFirstArgument)] + CSRAW public Component AddComponent (Type componentType) + { + return Internal_AddComponentWithType(componentType); + } + + CSRAW + CUSTOM private Component Internal_AddComponentWithType (Type componentType) + { + return MonoAddComponentWithType(*self, componentType); + } + + CSRAW + #if ENABLE_GENERICS + // Generic version. See the [[wiki:Generic Functions|Generic Functions]] page for more details. + public T AddComponent<T>() where T : Component + { + return AddComponent(typeof(T)) as T; + } + #endif + + CUSTOM private static void Internal_CreateGameObject ([Writable]GameObject mono, string name) + { + DISALLOW_IN_CONSTRUCTOR + GameObject* go = MonoCreateGameObject (name.IsNull() ? NULL : name.AsUTF8().c_str() ); + Scripting::ConnectScriptingWrapperToObject (mono.GetScriptingObject(), go); + } + + // Creates a new game object, named __name__. + CSRAW public GameObject (string name) { Internal_CreateGameObject (this, name); } + + // Creates a new game object. + CSRAW public GameObject () { Internal_CreateGameObject (this, null); } + + // Creates a game object and attaches the specified components. + CSRAW public GameObject (string name, params Type[] components) + { + Internal_CreateGameObject (this, name); + foreach (Type t in components) + AddComponent (t); + } + + OBSOLETE warning gameObject.PlayAnimation is not supported anymore. Use animation.Play + CUSTOM void PlayAnimation (AnimationClip animation) { ErrorString("gameObject.PlayAnimation(); is not supported anymore. Use animation.Stop();"); } + + OBSOLETE warning gameObject.StopAnimation is not supported anymore. Use animation.Stop + CUSTOM void StopAnimation () { ErrorString("gameObject.StopAnimation(); is not supported anymore. Use animation.Stop();"); } + + // Finds a game object by /name/ and returns it. + CSRAW + CUSTOM static GameObject Find (string name) + { + DISALLOW_IN_CONSTRUCTOR + Transform* transform = FindActiveTransformWithPath (name.AsUTF8().c_str ()); + GameObject* go = NULL; + if (transform) + go = transform->GetGameObjectPtr (); + return Scripting::ScriptingWrapperFor (go); + } + + //*undocumented - just for convenience + CSRAW public GameObject gameObject { get { return this; } } +} +END + + |