path: root/Runtime/Export/BaseClass.txt

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 }