+Unity Runtime codeHEADmaster

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	
+
+