+Unity Runtime codeHEADmaster

1 files changed, 1174 insertions, 0 deletions

diff --git a/Runtime/Export/BaseClass.txt b/Runtime/Export/BaseClass.txt
new file mode 100644
index 0000000..f083ca0
--- /dev/null
+++ b/Runtime/Export/BaseClass.txt
@@ -0,0 +1,1174 @@
+C++RAW
+
+
+#include "UnityPrefix.h"
+#include "Configuration/UnityConfigure.h"
+#include "Runtime/Mono/MonoManager.h"
+#include "Runtime/Graphics/Transform.h"
+#include "Runtime/Utilities/PathNameUtility.h"
+#include "Runtime/Input/InputManager.h"
+#include "Runtime/Input/TimeManager.h"
+#include "Runtime/Misc/ResourceManager.h"
+#include "Runtime/Profiler/ProfilerImpl.h"
+#include "Runtime/Mono/MonoBehaviour.h"
+#include "Runtime/BaseClasses/Tags.h"
+#include "Runtime/Misc/DebugUtility.h"
+#include "Runtime/Misc/PlayerSettings.h"
+#include "Runtime/GameCode/CloneObject.h"
+#include "Runtime/Math/Random/Random.h"
+#include "Runtime/Misc/PreloadManager.h"
+#include "Runtime/Allocator/MemoryManager.h"
+#include "Runtime/Audio/AudioClip.h"
+#if ENABLE_AUDIO
+#include "Runtime/Audio/AudioSource.h"
+#include "Runtime/Audio/AudioListener.h"
+#include "Runtime/Audio/AudioManager.h"
+#include "Runtime/Audio/AudioReverbZone.h"
+#include "Runtime/Audio/AudioReverbFilter.h"
+#include "Runtime/Audio/AudioHighPassFilter.h"
+#include "Runtime/Audio/AudioLowPassFilter.h"
+#include "Runtime/Audio/AudioChorusFilter.h"
+#include "Runtime/Audio/AudioDistortionFilter.h"
+#include "Runtime/Audio/AudioEchoFilter.h"
+#endif
+#include "Runtime/Animation/Animation.h"
+#include "Runtime/Math/Color.h"
+#include "Runtime/Utilities/PlayerPrefs.h"
+#include "Runtime/Camera/Camera.h"
+#include "Runtime/Dynamics/RigidBody.h"
+#include "Runtime/Utilities/Word.h"
+#include "Runtime/Camera/Light.h"
+#include "Runtime/Filters/Misc/TextMesh.h"
+#include "Runtime/Dynamics/ConstantForce.h"
+#include "Runtime/Filters/Renderer.h"
+#include "Runtime/Misc/SaveAndLoadHelper.h"
+#include "Runtime/Network/NetworkView.h"
+#include "Runtime/Network/NetworkManager.h"
+#include "Runtime/Camera/RenderLayers/GUIText.h"
+#include "Runtime/Camera/RenderLayers/GUITexture.h"
+#include "Runtime/Dynamics/Collider.h"
+#include "Runtime/Dynamics/HingeJoint.h"
+#include "Runtime/Filters/Particles/ParticleEmitter.h"
+#include "Runtime/Misc/Player.h"
+#include "Runtime/BaseClasses/IsPlaying.h"
+#include "Runtime/Misc/CaptureScreenshot.h"
+#include "Runtime/Misc/GameObjectUtility.h"
+#include "Runtime/Misc/Plugins.h"
+#include "Runtime/Misc/ResourceManagerUtility.h"
+#include "Runtime/Utilities/PathNameUtility.h"
+#include "Runtime/Utilities/File.h"
+#include <ctime>
+#include "Runtime/Input/GetInput.h"
+#include "Runtime/NavMesh/NavMeshAgent.h"
+#include "Runtime/NavMesh/NavMesh.h"
+#include "Runtime/NavMesh/OffMeshLink.h"
+#include "Runtime/Misc/BuildSettings.h"
+#include "Runtime/Animation/AnimationManager.h"
+#include "Runtime/Animation/AnimationClip.h"
+#include "Runtime/BaseClasses/RefCounted.h"
+#include "Runtime/Misc/GOCreation.h"
+#include "Runtime/Utilities/URLUtility.h"
+#include "Runtime/Graphics/ScreenManager.h"
+#include "Runtime/Serialize/PersistentManager.h"
+#include "Runtime/Shaders/GraphicsCaps.h"
+#include "Runtime/Misc/SystemInfo.h"
+#include "Runtime/Utilities/FileUtilities.h"
+#include "Runtime/Misc/GraphicsDevicesDB.h"
+#include "Configuration/UnityConfigureVersion.h"
+#include "Runtime/Profiler/CollectProfilerStats.h"
+#include "Runtime/File/ApplicationSpecificPersistentDataPath.h"
+#include "Runtime/Mono/Coroutine.h"
+#include "Runtime/Scripting/Scripting.h"
+#include "Runtime/Scripting/ScriptingUtility.h"
+#include "Runtime/Scripting/ScriptingExportUtility.h"
+#include "Runtime/Scripting/GetComponent.h"
+#include "Runtime/Scripting/Backend/ScriptingBackendApi.h"
+#include "Runtime/Scripting/Backend/ScriptingTypeRegistry.h"
+#include "Runtime/Scripting/ScriptingObjectWithIntPtrField.h"
+
+#if SUPPORT_REPRODUCE_LOG
+#include "Runtime/Misc/ReproductionLog.h"
+#endif
+
+#if WEBPLUG
+	#include "PlatformDependent/CommonWebPlugin/UnityWebStream.h"
+	#include "PlatformDependent/CommonWebPlugin/WebScripting.h"
+#endif
+
+#if UNITY_EDITOR
+	#include "Editor/Src/EditorSettings.h"
+	#include "Editor/Src/EditorUserBuildSettings.h"
+	#include "Editor/Mono/MonoEditorUtility.h"
+#endif
+
+#if UNITY_WII
+	#include "PlatformDependent/Wii/WiiUtility.h"
+#endif
+
+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.
+*/
+
+
+void PauseEditor ();
+using namespace std;
+
+CSRAW
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngineInternal;
+
+namespace UnityEngine
+{
+
+[StructLayout (LayoutKind.Sequential)]
+internal struct ReferenceData
+{
+	public int instanceID;
+	public IntPtr cachedPtr;
+}
+
+// Bit mask that controls object destruction and visibility in inspectors
+CSRAW [Flags]
+ENUM HideFlags
+	// A normal, visible object. This is the default.
+	None = 0,
+
+	// The object will not appear in the hierarchy and will not show up in the project view if it is stored in an asset.
+	HideInHierarchy = 1,
+
+	// It is not possible to view it in the inspector
+	HideInInspector = 2,
+
+	// The object will not be saved to the scene. __It will not be destroyed when a new scene is loaded__.
+	DontSave = 4,
+
+	// The object is not be editable in the inspector
+	NotEditable = 8,
+
+	// A combination of not shown in the hierarchy and not saved to to scenes.
+	HideAndDontSave = 13
+END
+
+// Options for how to send a message.
+ENUM SendMessageOptions
+	// A receiver is required for SendMessage.
+	RequireReceiver = 0,
+
+	// No receiver is required for SendMessage.
+	DontRequireReceiver = 1
+END
+
+// The various primitives that can be created using the GameObject.CreatePrimitive function.
+CSRAW
+ENUM PrimitiveType
+	// A sphere primitive
+	Sphere = 0,
+
+	// A capsule primitive
+	Capsule = 1,
+
+	// A cylinder primitive
+	Cylinder = 2,
+
+	// A cube primitive
+	Cube = 3,
+
+	// A plane primitive
+	Plane = 4,
+
+	// A quad primitive
+	Quad = 5
+END
+
+// The coordinate space in which to operate.
+ENUM Space
+	// Applies transformation relative to the world coordinate system
+	World = 0,
+	// Applies transformation relative to the local coordinate system
+	Self = 1
+END
+
+
+
+// LayerMask allow you to display the LayerMask popup menu in the inspector
+STRUCT LayerMask
+	CSRAW
+	private int m_Mask;
+
+	//*undocumented* TODO: make this actually work
+	CSRAW public static implicit operator int (LayerMask mask) { return mask.m_Mask; }
+
+	// implicitly converts an integer to a LayerMask
+	public static implicit operator LayerMask (int intVal) { LayerMask mask; mask.m_Mask = intVal; return mask; }
+
+	// Converts a layer mask value to an integer value.
+	CSRAW public int value { get { return m_Mask; } set { m_Mask = value; } }
+
+	// Given a layer number, returns the name of the layer as defined in either a Builtin or a User Layer in the [[wiki:class-TagManager|Tag Manager]]
+	CUSTOM static string LayerToName (int layer) { return scripting_string_new(LayerToString(layer)); }
+
+	// Given a layer name, returns the layer index as defined by either a Builtin or a User Layer in the [[wiki:class-TagManager|Tag Manager]]
+	CUSTOM static int NameToLayer (string layerName) { return StringToLayer(layerName); }
+END
+
+
+// The platform application is running. Returned by Application.platform.
+ENUM RuntimePlatform
+	// In the Unity editor on Mac OS X.
+	OSXEditor = 0,
+
+	// In the player on Mac OS X.
+	OSXPlayer = 1,
+
+	// In the player on Windows.
+	WindowsPlayer = 2,
+
+	// In the web player on Mac OS X.
+	OSXWebPlayer = 3,
+
+	// In the Dashboard widget on Mac OS X.
+	OSXDashboardPlayer = 4,
+
+	// In the web player on Windows.
+	WindowsWebPlayer = 5,
+
+	// In the player on Nintendo Wii.
+	WiiPlayer = 6,
+
+	// In the Unity editor on Windows.
+	WindowsEditor = 7,
+
+	// In the player on the iPhone.
+	IPhonePlayer = 8,
+
+	// In the player on the XBOX360
+	XBOX360 = 10,
+
+	// In the player on the Play Station 3
+	PS3 = 9,
+
+	// In the player on Android devices.
+	Android = 11,
+
+	//Google Native Client
+	NaCl = 12,
+
+	//*undocumented*
+	LinuxPlayer = 13,
+
+	//Flash Player
+	FlashPlayer = 15,
+
+	//*undocumented*
+	MetroPlayerX86 = 18,
+
+	//*undocumented*
+	MetroPlayerX64 = 19,
+
+	//*undocumented*
+	MetroPlayerARM = 20,
+
+	//*undocumented*
+	WP8Player = 21,
+
+	//*undocumented*
+	BB10Player = 22,
+
+	//*undocumented*
+	TizenPlayer = 23,
+
+END
+
+// The language the user's operating system is running in. Returned by Application.systemLanguage.
+ENUM SystemLanguage
+	//Afrikaans
+	Afrikaans = 0,
+	//Arabic
+	Arabic = 1,
+	//Basque
+	Basque = 2,
+	//Belarusian
+	Belarusian = 3,
+	//Bulgarian
+	Bulgarian = 4,
+	//Catalan
+	Catalan = 5,
+	//Chinese
+	Chinese = 6,
+	//Czech
+	Czech = 7,
+	//Danish
+	Danish = 8,
+	//Dutch
+	Dutch = 9,
+	//English
+	English = 10,
+	//Estonian
+	Estonian = 11,
+	//Faroese
+	Faroese = 12,
+	//Finnish
+	Finnish = 13,
+	//French
+	French = 14,
+	//German
+	German = 15,
+	//Greek
+	Greek = 16,
+	//Hebrew
+	Hebrew = 17,
+	//*undocumented*
+	Hugarian = 18,
+	//Icelandic
+	Icelandic = 19,
+	//Indonesian
+	Indonesian = 20,
+	//Italian
+	Italian = 21,
+	//Japanese
+	Japanese = 22,
+	//Korean
+	Korean = 23,
+	//Latvian
+	Latvian = 24,
+	//Lithuanian
+	Lithuanian = 25,
+	//Norwegian
+	Norwegian = 26,
+	//Polish
+	Polish = 27,
+	//Portuguese
+	Portuguese = 28,
+	//Romanian
+	Romanian = 29,
+	//Russian
+	Russian = 30,
+	//Serbo-Croatian
+	SerboCroatian = 31,
+	//Slovak
+	Slovak = 32,
+	//Slovenian
+	Slovenian = 33,
+	//Spanish
+	Spanish = 34,
+	//Swedish
+	Swedish = 35,
+	//Thai
+	Thai = 36,
+	//Turkish
+	Turkish = 37,
+	//Ukrainian
+	Ukrainian = 38,
+	//Vietnamese
+	Vietnamese = 39,
+	//Unknown
+	Unknown = 40,
+	//Hungarian
+	Hungarian = 18
+END
+
+// The type of the log message in the delegate registered with Application.RegisterLogCallback.
+ENUM LogType
+	// LogType used for Errors.
+    Error = 0,
+    // LogType used for Asserts. (These indicate an error inside Unity itself.)
+    Assert = 1,
+    // LogType used for Warnings.
+    Warning = 2,
+    // LogType used for regular log messages.
+    Log = 3,
+    // LogType used for Exceptions.
+    Exception = 4
+END
+
+// Enumeration for [[SystemInfo.deviceType]], denotes a coarse grouping of kinds of devices.
+ENUM DeviceType
+	// Device type is unknown. You should never see this in practice.
+	Unknown = 0,
+
+	// A handheld device like mobile phone or a tablet.
+	Handheld = 1,
+
+	// A stationary gaming console.
+	Console = 2,
+
+	// Desktop or laptop computer.
+	Desktop = 3,
+END
+
+// Access system information.
+CLASS SystemInfo
+
+	// Operating system name with version (RO).
+	CUSTOM_PROP static string operatingSystem { return scripting_string_new( systeminfo::GetOperatingSystem() ); }
+
+	// Processor name (RO).
+	CUSTOM_PROP static string processorType { return scripting_string_new( systeminfo::GetProcessorType() ); }
+
+	// Number of processors present (RO).
+	CUSTOM_PROP static int processorCount { return systeminfo::GetProcessorCount(); }
+
+	// Amount of system memory present (RO).
+	CUSTOM_PROP static int systemMemorySize { return systeminfo::GetPhysicalMemoryMB(); }
+
+
+	// Amount of video memory present (RO).
+	CUSTOM_PROP static int graphicsMemorySize { return (int)gGraphicsCaps.videoMemoryMB; }
+
+
+	// The name of the graphics device (RO).
+	CUSTOM_PROP static string graphicsDeviceName { return scripting_string_new(gGraphicsCaps.rendererString.c_str()); }
+
+
+	// The vendor of the graphics device (RO).
+	CUSTOM_PROP static string graphicsDeviceVendor { return scripting_string_new(gGraphicsCaps.vendorString.c_str()); }
+
+
+	// The identifier code of the graphics device (RO).
+	CUSTOM_PROP static int graphicsDeviceID { return gGraphicsCaps.rendererID; }
+
+
+	// The identifier code of the graphics device vendor (RO).
+	CUSTOM_PROP static int graphicsDeviceVendorID { return gGraphicsCaps.vendorID; }
+
+
+	// The graphics API version supported by the graphics device (RO).
+	CUSTOM_PROP static string graphicsDeviceVersion { return scripting_string_new(gGraphicsCaps.fixedVersionString.c_str()); }
+
+
+
+	// Graphics device shader capability level (RO).
+	CUSTOM_PROP static int graphicsShaderLevel { return gGraphicsCaps.shaderCaps; }
+
+
+	// Approximate pixel fill-rate of the graphics device (RO).
+	CUSTOM_PROP static int graphicsPixelFillrate {
+		return GetGraphicsPixelFillrate (gGraphicsCaps.vendorID, gGraphicsCaps.rendererID);
+	}
+
+
+	// Are built-in shadows supported? (RO)
+	CUSTOM_PROP static bool supportsShadows {
+		return RenderTexture::IsEnabled() && GetBuildSettings().hasShadows && gGraphicsCaps.supportsRenderTextureFormat[kRTFormatDepth];
+	}
+	// Are render textures supported? (RO)
+	CUSTOM_PROP static bool supportsRenderTextures {
+		return RenderTexture::IsEnabled();
+	}
+	CUSTOM_PROP static bool supportsRenderToCubemap {
+		return RenderTexture::IsEnabled() && (gGraphicsCaps.hasRenderToCubemap);
+	}
+	// Are image effects supported? (RO)
+	CUSTOM_PROP static bool supportsImageEffects {
+		return RenderTexture::IsEnabled() && (gGraphicsCaps.npotRT >= kNPOTRestricted);
+	}
+
+	// Are 3D (volume) textures supported? (RO)
+	CUSTOM_PROP static bool supports3DTextures {
+		return gGraphicsCaps.has3DTexture;
+	}
+
+	// Are compute shaders supported? (RO)
+	CUSTOM_PROP static bool supportsComputeShaders {
+		return gGraphicsCaps.hasComputeShader;
+	}
+
+	// Is GPU draw call instancing supported? (RO)
+	CUSTOM_PROP static bool supportsInstancing {
+		return gGraphicsCaps.hasInstancing;
+	}
+
+	// How many simultaneous render targets (MRTs) are supported? (RO)
+	CUSTOM_PROP static int supportedRenderTargetCount {
+		return RenderTexture::IsEnabled() ? gGraphicsCaps.maxMRTs : 0;
+	}
+
+	// Is the stencil buffer supported? (RO)
+	CUSTOM_PROP static int supportsStencil {
+		return gGraphicsCaps.hasStencil && GetBuildSettings ().hasAdvancedVersion;
+	}
+
+	//*undocumented*
+	CUSTOM_PROP static bool supportsVertexPrograms { return true; }
+
+	// Is render texture format supported?
+	CUSTOM static bool SupportsRenderTextureFormat (RenderTextureFormat format) {
+		return RenderTexture::IsEnabled() && gGraphicsCaps.supportsRenderTextureFormat[format];
+	}
+
+	/// What [[NPOT|NPOTSupport]] support does GPU provide? (RO)
+	///
+	/// SA: [[NPOTSupport]] enum.
+	CUSTOM_PROP static NPOTSupport npotSupport { return gGraphicsCaps.npot; }
+
+	//A unique device identifier. It is guaranteed to be unique for every device (RO).
+	CONDITIONAL !UNITY_FLASH && !UNITY_WEBGL
+	CUSTOM_PROP static string deviceUniqueIdentifier {
+		return scripting_string_new (systeminfo::GetDeviceUniqueIdentifier ());
+	}
+
+	// The user defined name of the device (RO).
+	CONDITIONAL !UNITY_FLASH && !UNITY_WEBGL
+	CUSTOM_PROP static string deviceName {
+		return scripting_string_new (systeminfo::GetDeviceName ());
+	}
+
+	// The model of the device (RO).
+	CONDITIONAL !UNITY_FLASH && !UNITY_WEBGL
+	CUSTOM_PROP static string deviceModel {
+		return scripting_string_new (systeminfo::GetDeviceModel ());
+	}
+
+	// Returns a boolean value that indicates whether an accelerometer is
+	CUSTOM_PROP static bool supportsAccelerometer {
+		return systeminfo::SupportsAccelerometer ();
+	}
+
+	// Returns a boolean value that indicates whether a gyroscope is available
+	CUSTOM_PROP static bool supportsGyroscope {
+		return IsGyroAvailable ();
+	}
+
+	// Returns a boolean value that indicates whether the device is capable to
+	CUSTOM_PROP static bool supportsLocationService {
+		return systeminfo::SupportsLocationService ();
+	}
+
+	// Returns a boolean value that indicates whether the device is capable to
+	CUSTOM_PROP static bool supportsVibration {
+		return systeminfo::SupportsVibration ();
+	}
+
+	// Returns the kind of device the application is running on. See [[DeviceType]] enumeration for possible values.
+	CUSTOM_PROP static DeviceType deviceType
+	{
+		return systeminfo::DeviceType ();
+	}
+
+	CUSTOM_PROP static int maxTextureSize
+	{
+		return gGraphicsCaps.maxTextureSize;
+	}
+
+END
+
+// Suspends the coroutine execution for the given amount of seconds.
+CSRAW [StructLayout(LayoutKind.Sequential)]
+CLASS WaitForSeconds : YieldInstruction
+	//*undocumented*
+	CSRAW internal float m_Seconds;
+
+	// Creates a yield instruction to wait for a given number of seconds
+	CSRAW public WaitForSeconds (float seconds) { m_Seconds = seconds; }
+END
+
+// Waits until next fixed frame rate update function. SA: MonoBehaviour::pref::FixedUpdate.
+CLASS WaitForFixedUpdate : YieldInstruction
+END
+
+// Waits until the end of the frame after all cameras and GUI is rendered, just before displaying the frame on screen.
+CLASS WaitForEndOfFrame : YieldInstruction
+END
+
+
+// MonoBehaviour.StartCoroutine returns a Coroutine. Instances of this class are only used to reference these coroutines and do not hold any exposed properties or functions.
+CSRAW [StructLayout (LayoutKind.Sequential)]
+
+CLASS Coroutine : YieldInstruction
+	CSRAW internal IntPtr m_Ptr;
+	private Coroutine () { }
+
+	THREAD_SAFE
+	CUSTOM private void ReleaseCoroutine ()
+	{
+		Assert (self.GetPtr() != NULL);
+		Coroutine::CleanupCoroutineGC (self);
+	}
+
+	CSRAW
+	~Coroutine ()
+	{
+		ReleaseCoroutine ();
+	}
+END
+
+CSRAW
+
+// The RequireComponent attribute lets automatically add required component as a dependency.
+
+
+CSRAW [AttributeUsage(AttributeTargets.Class, AllowMultiple=true)]
+CLASS RequireComponent  : Attribute
+	//*undocumented*
+	CSRAW public Type m_Type0;
+	//*undocumented*
+	CSRAW public Type m_Type1;
+	//*undocumented*
+	CSRAW public Type m_Type2;
+
+	// Require a single component
+	CSRAW public RequireComponent (Type requiredComponent) { m_Type0 = requiredComponent; }
+	// Require a two components
+	CSRAW public RequireComponent (Type requiredComponent, Type requiredComponent2) { m_Type0 = requiredComponent; m_Type1 = requiredComponent2;  }
+	// Require three components
+	CSRAW public RequireComponent (Type requiredComponent, Type requiredComponent2, Type requiredComponent3) { m_Type0 = requiredComponent; m_Type1 = requiredComponent2; m_Type2 = requiredComponent3; }
+END
+
+
+// The AddComponentMenu attribute allows you to place a script anywhere in the "Component" menu, instead of just the "Component->Scripts" menu.
+
+CLASS AddComponentMenu : Attribute
+	CSRAW private string m_AddComponentMenu;
+
+	// The script will be placed in the component menu according to /menuName/. /menuName/ is the path to the component
+	CSRAW public AddComponentMenu (string menuName) { m_AddComponentMenu = menuName; }
+
+	//* undocumented
+	CSRAW public string componentMenu { get {return m_AddComponentMenu; } }
+END
+
+
+// The ContextMenu attribute allows you to add commands to the context menu
+CLASS ContextMenu  : Attribute
+
+	// Adds the function to the context menu of the component.
+	CSRAW public ContextMenu (string name) { m_ItemName = name; }
+
+
+	CSRAW private string m_ItemName;
+
+	//* undocumented
+	CSRAW public string menuItem { get { return m_ItemName; } }
+END
+
+
+// Makes a script execute in edit mode.
+CLASS ExecuteInEditMode : Attribute
+END
+
+
+// Makes a variable not show up in the inspector but be serialized.
+CLASS HideInInspector : Attribute
+END
+
+// A class you can derive from if you want to create objects that don't need to be attached to game objects.
+CSRAW
+[StructLayout (LayoutKind.Sequential)]
+NONSEALED_CLASS ScriptableObject : Object
+
+	//*undocumented* Users are not supposed to instantiate unextended ScriptableObjects, are they?
+	CSRAW public ScriptableObject ()
+	{
+		Internal_CreateScriptableObject(this);
+	}
+
+	THREAD_SAFE
+	CUSTOM private static void Internal_CreateScriptableObject([Writable]ScriptableObject self)
+	{
+		Scripting::CreateEngineScriptableObject(self.GetScriptingObject());
+	}
+
+	CONDITIONAL ENABLE_MONO
+	OBSOLETE warning Use EditorUtility.SetDirty instead
+	AUTO void SetDirty ();
+
+	// Creates an instance of a scriptable object with /className/.
+	CUSTOM static ScriptableObject CreateInstance (string className) { return Scripting::CreateScriptableObject (className.AsUTF8()); }
+
+	// Creates an instance of a scriptable object with /type/.
+	CSRAW public static ScriptableObject CreateInstance (Type type) { return CreateInstanceFromType(type); }
+
+	CUSTOM private static ScriptableObject CreateInstanceFromType (Type type) { return Scripting::CreateScriptableObjectWithType (type); }
+
+	CSRAW
+	#if ENABLE_GENERICS
+	// Creates an instance of a scriptable object with /T/.
+	public static T CreateInstance<T> () where T : ScriptableObject
+	{
+		return (T)CreateInstance(typeof(T));
+	}
+	#endif
+
+	// This function is called when the object is loaded
+	CSNONE void OnEnable ();
+
+
+	// This function is called when the scriptable object goes out of scope
+	CSNONE void OnDisable();
+
+	// This function is called when the scriptable object will be destroyed.
+	CSNONE void OnDestroy();
+
+
+END
+
+// The Resources class allows you to find and access Objects including assets.
+CLASS Resources
+
+	CONDITIONAL (ENABLE_GENERICS && !UNITY_FLASH)
+	CSRAW internal static T[] ConvertObjects<T>(Object[] rawObjects) where T : Object
+	{
+		if (rawObjects == null) return null;
+		T[] typedObjects = new T[rawObjects.Length];
+		for (int i = 0; i < typedObjects.Length; i++)
+			typedObjects[i] = (T)rawObjects[i];
+		return typedObjects;
+	}
+
+	// Returns a list of all objects of Type /type/.
+	CSRAW
+	[TypeInferenceRule(TypeInferenceRules.ArrayOfTypeReferencedByFirstArgument)]
+	CUSTOM static Object[] FindObjectsOfTypeAll (Type type) { DISALLOW_IN_CONSTRUCTOR return Scripting::FindObjectsOfType (type, Scripting::kFindAnything); }
+	
+	CONDITIONAL (ENABLE_GENERICS && !UNITY_FLASH)
+	CSRAW public static T[] FindObjectsOfTypeAll<T> () where T : Object
+	{
+		return ConvertObjects<T>(FindObjectsOfTypeAll (typeof (T)));
+	}
+
+	// Loads an asset stored at /path/ in a Resources folder.
+
+	CSRAW public static Object Load (string path)
+	{
+		return Load(path, typeof(Object));
+	}
+	
+	CONDITIONAL ENABLE_GENERICS
+	CSRAW public static T Load<T> (string path) where T : Object
+	{
+		return (T) Load (path, typeof (T));
+	}
+
+	// Loads an asset stored at /path/ in a Resources folder.
+	CSRAW
+	[TypeInferenceRule(TypeInferenceRules.TypeReferencedBySecondArgument)]
+	CUSTOM static Object Load (string path, Type systemTypeInstance)
+	{
+		Scripting::RaiseIfNull (systemTypeInstance);
+
+		ScriptingClassPtr klass = GetScriptingTypeRegistry().GetType(systemTypeInstance);
+		string lowerPath = ToLower(path.AsUTF8());
+		ResourceManager::range found = GetResourceManager().GetPathRange(lowerPath);
+
+		Object* obj = NULL;
+		ScriptingObjectPtr o = SCRIPTING_NULL;
+		for (ResourceManager::iterator i=found.first;i != found.second;i++)
+		{
+			obj = i->second;
+			GetResourceManager ().PreloadDependencies (obj->GetInstanceID ());
+			
+			o = Scripting::ScriptingWrapperFor(obj);
+			if (o == SCRIPTING_NULL)
+				continue;
+
+			ScriptingClassPtr k = scripting_object_get_class(o, GetScriptingTypeRegistry());
+			if (o && scripting_class_is_subclass_of(k,klass))
+			{
+				break;
+			}
+
+			GameObject* go = dynamic_pptr_cast<GameObject*> (obj);
+			if (go != NULL)
+			{
+				o = ScriptingGetComponentOfType(*go, systemTypeInstance, false);
+				if (o != SCRIPTING_NULL)
+				{
+					break;
+				}
+			}
+		}
+
+		// Android keeps its Resources folder split up (to minimize seeks inside the .apk)
+		// To not "leak" SerializedFile objects we need to unload the added stream here..
+		if (obj && UNITY_ANDROID)
+		{
+			PersistentManager& pm = GetPersistentManager();
+			pm.UnloadNonDirtyStreams();
+		}
+
+		return o;
+	}
+
+	// Loads all assets in a folder or file at /path/ in a Resources folder.
+	CUSTOM static Object[] LoadAll (string path, Type systemTypeInstance)
+	{
+		Scripting::RaiseIfNull (systemTypeInstance);
+
+		ScriptingClassPtr klass = GetScriptingTypeRegistry().GetType(systemTypeInstance);
+		ResourceManager::range found = GetResourceManager().GetAll();
+		string cpath = ToLower(path.AsUTF8());
+
+		vector<PPtr<Object> > objects;
+
+		for (ResourceManager::iterator i=found.first;i != found.second;i++)
+		{
+			// Path doesn't match (But allow empty path for all objects)
+			if (!StartsWithPath(i->first, cpath))
+				continue;
+
+			Object* obj = i->second;
+			GetResourceManager ().PreloadDependencies (obj->GetInstanceID ());
+
+			ScriptingObjectPtr o = Scripting::ScriptingWrapperFor(obj);
+			if (o == SCRIPTING_NULL)
+				continue;
+
+			ScriptingClassPtr k = scripting_object_get_class(o, GetScriptingTypeRegistry());
+			if (o && scripting_class_is_subclass_of(k, klass))
+			{
+				objects.push_back(i->second);
+			}
+			else
+			{
+				GameObject* go = dynamic_pptr_cast<GameObject*> (obj);
+				if (go != NULL)
+				{
+					o = ScriptingGetComponentOfType(*go, systemTypeInstance, false);
+					if (o != SCRIPTING_NULL)
+					{
+						objects.push_back(ScriptingObjectToObject<Object>(o));
+					}
+				}
+			}
+		}
+
+		return CreateScriptingArrayFromUnityObjects (objects, ClassID(Object));
+	}
+
+	// Loads all assets in a folder or file at /path/ in a Resources folder.
+
+	CSRAW public static Object[] LoadAll (string path)
+	{
+		return LoadAll(path, typeof(Object));
+	}
+	
+	CONDITIONAL (ENABLE_GENERICS && !UNITY_FLASH)
+	CSRAW public static T[] LoadAll<T> (string path) where T : Object
+	{
+		return ConvertObjects<T>(LoadAll (path, typeof (T)));
+	}
+	
+	// *undocumented
+	CSRAW
+	[TypeInferenceRule(TypeInferenceRules.TypeReferencedByFirstArgument)]
+	CUSTOM static Object GetBuiltinResource (Type type, string path)
+	{
+		Scripting::RaiseIfNull(type);
+		return GetScriptingBuiltinResource(type, path.AsUTF8());
+	}
+
+	CONDITIONAL ENABLE_GENERICS
+	CSRAW public static T GetBuiltinResource<T> (string path) where T : Object
+	{
+		return (T) GetBuiltinResource (typeof (T), path);
+	}
+
+	// Returns a resource at an asset path (Editor Only).
+	CSRAW
+	[TypeInferenceRule(TypeInferenceRules.TypeReferencedBySecondArgument)]
+	CUSTOM static Object LoadAssetAtPath (string assetPath, Type type)
+	{
+		#if UNITY_EDITOR
+		return LoadAssetAtPath(assetPath, type);
+		#else
+		return SCRIPTING_NULL;
+		#endif
+	}
+
+	CONDITIONAL ENABLE_GENERICS
+	CSRAW public static T LoadAssetAtPath<T> (string assetPath) where T : Object
+	{
+		return (T) LoadAssetAtPath (assetPath, typeof (T));
+	}
+
+	// Unloads /assetToUnload/ from memory.
+	CUSTOM static void UnloadAsset (Object assetToUnload) { Scripting::UnloadAssetFromScripting (assetToUnload); }
+
+	// Unloads assets that are not used.
+	CUSTOM static AsyncOperation UnloadUnusedAssets ()
+	{
+		AsyncOperation* result = UnloadUnusedAssetsOperation::UnloadUnusedAssets ();
+		ScriptingObjectPtr o = scripting_object_new(MONO_COMMON.asyncOperation);
+		ScriptingObjectWithIntPtrField<AsyncOperation>(o).SetPtr(result);
+		return o;
+	}
+
+END
+
+
+OBSOLETE warning Use SerializeField on the private variables that you want to be serialized instead
+CLASS SerializePrivateVariables : Attribute
+END
+
+// Priority of a thread.
+ENUM ThreadPriority
+	// Lowest thread priority
+	Low = 0,
+	// Below normal thread priority
+	BelowNormal = 1,
+	// Normal thread priority
+	Normal = 2,
+	// Highest thread priority
+	High = 4
+END
+
+
+// Force Unity to serialize a private field.
+
+
+
+CLASS SerializeField : Attribute
+END
+
+// Controls the [[wiki:Profiler]] from script.
+CLASS Profiler
+
+	// *undocumented*
+	CUSTOM_PROP static bool supported
+	{
+		#if ENABLE_PROFILER
+		return GetBuildSettings().hasPROVersion;
+		#else
+		return false;
+		#endif
+	}
+
+
+	// Sets profiler output file in built players.
+	CUSTOM_PROP static string logFile
+	{
+		#if ENABLE_PROFILER
+		return scripting_string_new(UnityProfiler::Get().GetLogPath());
+		#else
+		return SCRIPTING_NULL;
+		#endif
+	}
+	{
+		#if ENABLE_PROFILER
+		if (!GetBuildSettings().hasPROVersion)
+		{
+			ErrorString("Profiler is only supported in Unity Pro.");
+			return;
+		}
+		UnityProfiler::Get().SetLogPath(value);
+		#else
+		ErrorString("Profiler is not supported in this build");
+		#endif
+	}
+
+	// Sets profiler output file in built players.
+	CUSTOM_PROP static bool enableBinaryLog
+	{
+		#if ENABLE_PROFILER
+		return UnityProfiler::Get().BinaryLogEnabled();
+		#else
+		return false;
+		#endif
+	}
+	{
+		#if ENABLE_PROFILER
+		if (!GetBuildSettings().hasPROVersion)
+		{
+			ErrorString("Profiler is only supported in Unity Pro.");
+			return;
+		}
+		UnityProfiler::Get().EnableBinaryLog(value);
+		#else
+		ErrorString("Profiler is not supported in this build");
+		#endif
+	}
+
+	// Enables the Profiler.
+	CUSTOM_PROP static bool enabled
+	{
+		#if ENABLE_PROFILER
+		return UnityProfiler::Get().GetEnabled();
+		#else
+		return false;
+		#endif
+	}
+	{
+		#if ENABLE_PROFILER
+		if (!GetBuildSettings().hasPROVersion)
+		{
+			ErrorString("Profiler is only supported in Unity Pro.");
+			return;
+		}
+		return UnityProfiler::Get().SetEnabled(value);
+		#else
+		ErrorString("Profiler is not supported in this build");
+		#endif
+	}
+
+
+	// Displays the recorded profiledata in the profiler.
+	CSRAW [System.Diagnostics.ConditionalAttribute("ENABLE_PROFILER")]
+	CUSTOM static void AddFramesFromFile (string file)
+	{
+		#if ENABLE_PROFILER
+		if(file.Length() == 0)
+		{
+			ErrorString ("AddFramesFromFile: Invalid empty path");
+			return;
+		}
+		UnityProfiler::Get().AddFramesFromFile(file);
+		#endif
+	}
+
+
+	/// *listonly*
+	CSRAW [System.Diagnostics.ConditionalAttribute("ENABLE_PROFILER")]
+	CSRAW static public void BeginSample(string name)
+	{
+		BeginSampleOnly(name);
+	}
+
+	// Begin profiling a piece of code with a custom label.
+	CSRAW [System.Diagnostics.ConditionalAttribute("ENABLE_PROFILER")]
+	CUSTOM static void BeginSample(string name, Object targetObject)
+	{
+		#if ENABLE_PROFILER
+		UnityProfilerPerThread* prof = UnityProfilerPerThread::ms_InstanceTLS;
+		if (prof && prof->GetIsActive())
+			prof->BeginSampleDynamic(name, targetObject);
+		#endif
+	}
+
+	CUSTOM private static void BeginSampleOnly(string name)
+	{
+		#if ENABLE_PROFILER
+		UnityProfilerPerThread* prof = UnityProfilerPerThread::ms_InstanceTLS;
+		if (prof && prof->GetIsActive())
+			prof->BeginSampleDynamic(name, NULL);
+		#endif
+	}
+
+	// End profiling a piece of code with a custom label.
+	CSRAW [System.Diagnostics.ConditionalAttribute("ENABLE_PROFILER")]
+	CUSTOM static void EndSample ()
+	{
+		#if ENABLE_PROFILER
+		UnityProfilerPerThread* prof = UnityProfilerPerThread::ms_InstanceTLS;
+		if (prof)
+			prof->EndSampleDynamic();
+		#endif
+	}
+
+	// Heap size used by the program
+	CUSTOM_PROP static uint usedHeapSize
+	{
+		#if ENABLE_PROFILER
+		return GetUsedHeapSize();
+		#else
+		return 0;
+		#endif
+	}
+
+	// Returns the runtime memory usage of the resource.
+
+	CUSTOM static int GetRuntimeMemorySize(Object o)
+	{
+		#if ENABLE_PROFILER
+			return o->GetRuntimeMemorySize();
+		#else
+			return 0;
+		#endif
+	}
+
+	// Returns the size of the mono heap
+	CUSTOM static uint GetMonoHeapSize ()
+	{
+		#if ENABLE_PROFILER && ENABLE_MONO
+			return mono_gc_get_heap_size ();
+		#else
+			return 0;
+		#endif
+	 }
+
+	// Returns the used size from mono
+	CUSTOM static uint GetMonoUsedSize ()
+	{
+		#if ENABLE_PROFILER && ENABLE_MONO
+			return mono_gc_get_used_size ();
+		#else
+			return 0;
+		#endif
+	}
+	///*undocumented*
+	CUSTOM static uint GetTotalAllocatedMemory()
+	{
+		#if ENABLE_MEMORY_MANAGER
+			return GetMemoryManager().GetTotalAllocatedMemory();
+		#else
+			return 0;
+		#endif
+	}
+	///*undocumented*
+	CUSTOM static uint GetTotalUnusedReservedMemory()
+	{
+		#if ENABLE_MEMORY_MANAGER
+			return GetMemoryManager().GetTotalUnusedReservedMemory();
+		#else
+			return 0;
+		#endif
+	}
+	///*undocumented*
+	CUSTOM static uint GetTotalReservedMemory()
+	{
+		#if ENABLE_MEMORY_MANAGER
+			return GetMemoryManager().GetTotalReservedMemory();
+		#else
+			return 0;
+		#endif
+	}
+
+	//CUSTOM static void SharkBeginRemoteProfiling ()
+	//{
+	//	#if ENABLE_SHARK_PROFILE
+	//	SharkBeginRemoteProfiling();
+	//	#endif
+	//}
+	//
+	//CUSTOM static void SharkEndRemoteProfiling ()
+	//{
+	//	#if ENABLE_SHARK_PROFILE
+	//	SharkEndRemoteProfiling();
+	//	#endif
+	//}
+END
+
+CSRAW }
+
+CSRAW
+namespace UnityEngineInternal
+{
+
+using UnityEngine;
+
+//*undocumented*
+// class for reproduction framework
+CONDITIONAL ENABLE_MONO
+CLASS Reproduction
+
+	CUSTOM static void CaptureScreenshot ()
+	{
+#if SUPPORT_REPRODUCE_LOG
+		CaptureScreenshotReproduction(true);
+#else
+		Scripting::RaiseMonoException("This method only works with internal development builds.");
+#endif
+	}
+
+END
+
+CSRAW }