+Unity Runtime codeHEADmaster

1 files changed, 1235 insertions, 0 deletions

diff --git a/Runtime/Export/Utils.txt b/Runtime/Export/Utils.txt
new file mode 100644
index 0000000..18fbfe1
--- /dev/null
+++ b/Runtime/Export/Utils.txt
@@ -0,0 +1,1235 @@
+C++RAW
+
+#include "UnityPrefix.h"
+#include "Configuration/UnityConfigure.h"
+#include "Runtime/Graphics/Texture2D.h"
+#include "Runtime/Graphics/ImageConversion.h"
+#include "Runtime/Misc/Player.h"
+#include "Runtime/Export/WWW.h"
+#include "Runtime/Misc/WWWCached.h"
+#include "Runtime/Mono/MonoBehaviour.h"
+#include "Runtime/Scripting/ScriptingUtility.h"
+#include "Runtime/Scripting/ScriptingExportUtility.h"
+#include "Runtime/Scripting/Backend/ScriptingTypes.h"
+#include "Runtime/Scripting/ScriptingManager.h"
+#include "Runtime/Scripting/Scripting.h"
+#include "Runtime/Scripting/ScriptingObjectWithIntPtrField.h"
+#include "Runtime/Interfaces/IAudio.h"
+
+#if WEBPLUG
+#include "PlatformDependent/CommonWebPlugin/UnityWebStream.h"
+#include "PlatformDependent/CommonWebPlugin/CompressedFileStreamMemory.h"
+#endif
+#include "Runtime/Misc/AssetBundle.h"
+#include "Runtime/Serialize/PersistentManager.h"
+#include "Runtime/Misc/Player.h"
+#include "Runtime/Utilities/GUID.h"
+#include "Runtime/Misc/CachingManager.h"
+#include "Runtime/Misc/AssetBundleUtility.h"
+
+#if UNITY_EDITOR
+#include "Editor/Src/LicenseInfo.h"
+#include "Editor/Src/EditorUserBuildSettings.h"
+#endif
+
+#if UNITY_FLASH
+#include "PlatformDependent/FlashSupport/cpp/WWWFlash.h"
+#endif
+
+#if ENABLE_MOVIES
+#include "Runtime/Video/MovieTexture.h"
+#endif
+#if ENABLE_AUDIO
+#include "Runtime/Audio/AudioClip.h"
+#endif
+#include "Runtime/Misc/Player.h"
+#include "Runtime/Utilities/PathNameUtility.h"
+
+CSRAW
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+
+namespace UnityEngine
+{
+#if ENABLE_WWW
+// Simple access to web pages.
+
+CONDITIONAL ENABLE_WWW
+CLASS WWW : IDisposable
+	// We are matching the WWW class here so we can directly access it.
+	CSRAW internal IntPtr m_Ptr;
+
+	C++RAW
+
+	#if ENABLE_WWW
+	inline WWW* GetWWWChecked (ScriptingObjectWithIntPtrField<WWW>& self)
+	{
+		WWW* www = self.GetPtr();
+		
+		if (!www)
+			Scripting::RaiseNullException("WWW class has already been disposed.");
+
+		return www;
+	}
+	#endif
+
+	C++RAW
+ #define GET GetWWWChecked (self)
+
+	//*undocumented*
+	CSRAW public void Dispose ()
+	{
+		DestroyWWW(true);
+	}
+
+	CSRAW ~WWW() {
+		DestroyWWW(false);
+	}
+
+	//*undocumented*
+	THREAD_SAFE
+	CUSTOM private void DestroyWWW(bool cancel) {
+		WWW* www = self.GetPtr();
+
+    // no-op if already 0
+		self.SetPtr(0);
+
+		if (www)
+		{
+			if (cancel)
+				www->Cancel();
+			www->Release();
+		}
+	}
+
+	//*undocumented*
+	CUSTOM void InitWWW( string url , byte[] postData, string[] iHeaders ) {
+		string cpp_string = url;
+		map<string,string> headers;
+		// Copy in headers from the MonoArray if available
+		int headersSize = GetScriptingArraySize(iHeaders);
+		for(int i=0; i < headersSize-1 ; i += 2) {
+			headers[scripting_cpp_string_for(Scripting::GetScriptingArrayElementNoRef<ScriptingStringPtr>(iHeaders,i))] = scripting_cpp_string_for(Scripting::GetScriptingArrayElementNoRef<ScriptingStringPtr>(iHeaders,i+1));
+		}
+		int rawPostDataLength = -1;
+		char* rawPostDataPtr = NULL;
+		if(postData != SCRIPTING_NULL) {
+			rawPostDataPtr = Scripting::GetScriptingArrayStart<char>(postData); // Will be copied by WWW::Create
+			rawPostDataLength = GetScriptingArraySize(postData);
+		}
+		WWW* www = WWW::Create (cpp_string.c_str(), rawPostDataPtr, rawPostDataLength, headers);
+		self.SetPtr(www);
+	}
+
+	// Creates a WWW request with the given URL.
+	CSRAW public WWW(string url) {
+		InitWWW(url, null, null);
+	}
+
+	// Creates a WWW request with the given URL.
+	CONDITIONAL !UNITY_WEBGL
+	CSRAW public WWW(string url, WWWForm form ) {
+		string[] flattenedHeaders = FlattenedHeadersFrom(form.headers);
+
+		#if UNITY_WEBPLAYER || UNITY_EDITOR
+		if(enforceWebSecurityRestrictions()) {
+			CheckSecurityOnHeaders(flattenedHeaders);
+		}
+		#endif
+
+		InitWWW(url, form.data, flattenedHeaders);
+		}
+
+	// Creates a WWW request with the given URL.
+	CSRAW public WWW(string url, byte[] postData) {
+		InitWWW(url, postData, null);
+	}
+
+	// Creates a WWW request with the given URL.
+	CSRAW #if !UNITY_METRO_API && !UNITY_WP8_API
+	CSRAW public WWW(string url, byte[] postData, Hashtable headers ) {
+		string[] flattenedHeaders = FlattenedHeadersFrom(headers);
+
+		#if UNITY_WEBPLAYER || UNITY_EDITOR
+		if(enforceWebSecurityRestrictions()) {
+			CheckSecurityOnHeaders(flattenedHeaders);
+		}
+		#endif
+
+		InitWWW(url, postData, flattenedHeaders);
+		}
+
+	CSRAW #else
+	CSRAW public WWW(string url, byte[] postData, Dictionary<string, string> headers ) {
+		string[] flattenedHeaders = FlattenedHeadersFrom(headers);
+
+		#if UNITY_WEBPLAYER || UNITY_EDITOR
+		if(enforceWebSecurityRestrictions()) {
+			CheckSecurityOnHeaders(flattenedHeaders);
+		}
+		#endif
+
+		InitWWW(url, postData, flattenedHeaders);
+		}
+	CSRAW #endif
+	
+	CUSTOM internal bool enforceWebSecurityRestrictions() {
+		#if UNITY_WEBPLAYER
+		return true;
+		#elif UNITY_EDITOR
+		BuildTargetPlatform buildTarget = GetEditorUserBuildSettings().GetActiveBuildTarget();
+		return  buildTarget == kBuildWebPlayerLZMA || buildTarget == kBuildWebPlayerLZMAStreamed;
+		#else
+		return false;
+		#endif
+	}
+
+	// Encodes string into an URL-friendly format.
+	
+	CSRAW
+#if !UNITY_WEBGL
+	public static string EscapeURL(string s, Encoding e=System.Text.Encoding.UTF8)
+	{
+		if (s == null)
+			return null;
+
+		if (s == "")
+			return "";
+
+		if (e == null)
+			return null;
+
+		return WWWTranscoder.URLEncode(s,e);
+	}
+#endif
+
+	// Decodes string from an URL-friendly format.
+	
+	CSRAW 
+#if !UNITY_WEBGL
+	public static string UnEscapeURL(string s, Encoding e=System.Text.Encoding.UTF8)
+	{
+		if (null == s)
+			return null;
+
+		if (s.IndexOf ('%') == -1 && s.IndexOf ('+') == -1)
+			return s;
+
+		return WWWTranscoder.URLDecode(s,e);
+
+	}
+#endif
+
+
+	// The headers from the HTTP response.
+	
+	CSRAW
+#if ENABLE_GENERICS
+	public System.Collections.Generic.Dictionary<string,string> responseHeaders
+	{
+		get {
+			#if UNITY_FLASH
+				UnityEngine.Flash.ActionScript.Import("System.UnityException");
+			#endif
+			if (!isDone) throw new UnityException("WWW is not finished downloading yet");
+			return ParseHTTPHeaderString(responseHeadersString);
+		}
+	}
+#endif
+	CUSTOM_PROP private string responseHeadersString
+	{
+		WWW& www = *GET;
+
+		ScriptingStringPtr res = scripting_string_new(www.GetResponseHeaders().c_str());
+		return res;
+	}
+
+
+	// Returns the contents of the fetched web page as a string (RO).
+	CONDITIONAL !UNITY_WEBGL
+	CSRAW public string text { get {
+#if !UNITY_FLASH
+			if (!isDone) throw new UnityException("WWW is not ready downloading yet");
+			return GetTextEncoder().GetString(this.bytes, 0, this.bytes.Length);
+#else
+			//Flash can't access responsheaders correctly, so we always asume utf8 and use native parsing, directly from the bytearray, and let flash try and deal with it.
+			return stringFromByteArray;
+#endif
+		}
+	}
+	CSRAW internal static System.Text.Encoding DefaultEncoding
+	{
+		get
+		{
+		#if UNITY_WINRT
+			return System.Text.Encoding.UTF8;
+		#else
+			return System.Text.Encoding.ASCII;
+		#endif
+		}
+	}
+
+	CONDITIONAL UNITY_FLASH
+	CUSTOM_PROP internal string stringFromByteArray {
+		WWWFlash *wwwflash = (WWWFlash*)GET; 
+		ScriptingString* str = scripting_string_new("");//We don't really care about the return string, as we'll emit as3 to parse bytearray below, no need to marshall the bytearray into native first.
+		__asm __volatile__("var heapPos:int = heap.position;");
+		__asm __volatile__("heap.position = %0;"::"r"(wwwflash->m_Buffer));
+		__asm __volatile__("returnString = heap.readUTFBytes(%0); "::"r"(wwwflash->m_SizeLoaded));	
+		__asm __volatile__("heap.position = heapPos;");
+		return str;
+	}
+	
+	
+	CONDITIONAL !UNITY_FLASH && !UNITY_WEBGL
+	CSRAW private Encoding GetTextEncoder()
+	{
+#if ENABLE_GENERICS
+		// Check for charset type
+		string contentType=null;
+		if (responseHeaders.TryGetValue("CONTENT-TYPE",out contentType))
+		{
+			int charsetKeyIndex = contentType.IndexOf("charset", StringComparison.OrdinalIgnoreCase);
+			if (charsetKeyIndex > -1)
+			{
+				int charsetValueIndex = contentType.IndexOf('=', charsetKeyIndex);
+				if (charsetValueIndex > -1)
+				{
+					string encoding = contentType.Substring(charsetValueIndex + 1).Trim().Trim(new []{'\'', '"'}).Trim();
+					int semicolonIndex = encoding.IndexOf(';');
+					if (semicolonIndex > -1)
+						encoding = encoding.Substring(0, semicolonIndex);
+					try
+					{
+						return System.Text.Encoding.GetEncoding(encoding);
+					} catch (Exception) {
+						Debug.Log("Unsupported encoding: '" + encoding + "'");
+					}
+				}
+			}
+		}
+#endif
+		// Use default (utf8)
+		return System.Text.Encoding.UTF8;
+	}
+
+	FLUSHCONDITIONS
+
+	CONDITIONAL !UNITY_FLASH && !UNITY_WEBGL
+	OBSOLETE warning Please use WWW.text instead
+	CSRAW public string data { get { return text; } }
+
+	// Returns the contents of the fetched web page as a byte array (RO).
+	CUSTOM_PROP byte[] bytes {
+		WWW& www = *GET;
+		if (www.GetType() == kWWWTypeCached)
+		{
+			ErrorString(kWWWCachedAccessError);
+			return SCRIPTING_NULL;
+		}
+		if (www.GetSecurityPolicy() != WWW::kSecurityPolicyAllowAccess)
+			Scripting::RaiseSecurityException("No valid crossdomain policy available to allow access");
+
+		if (!www.HasDownloadedOrMayBlock ())
+			return CreateEmptyStructArray(GetScriptingManager().GetCommonClasses().byte);
+
+		return CreateScriptingArray<UInt8>( www.GetData(), www.GetSize(), GetScriptingManager().GetCommonClasses().byte );
+	}
+
+	//*undocumented* OBSOLETE Can do the same with bytes.Length
+	CUSTOM_PROP int size {
+		WWW& www = *GET;
+		if (!www.HasDownloadedOrMayBlock ())
+			return 0;
+		return www.GetSize();
+	}
+
+	//*undocumented*
+	CONDITIONAL UNITY_WINRT
+	CUSTOM private IntPtr GetError()
+	{
+		WWW *www = GET; 
+		if (www)
+			return (void*)self->GetError();			
+		else
+			return (void*)kWWWErrCancelled;
+	}
+	
+	// Returns an error message if there was an error during the download (RO).
+	CSRAW
+	#if UNITY_WINRT
+	public string error 
+	{
+		get
+		{
+			return Marshal.PtrToStringAnsi(GetError());
+		}		
+	}
+	#endif
+
+	// Returns an error message if there was an error during the download (RO).
+	CONDITIONAL !UNITY_WINRT
+	CUSTOM_PROP string error {
+		WWW *www = GET; 
+		if (www)
+		{
+			const char* e = self->GetError();
+			if (e)
+				return scripting_string_new(e);
+			else
+				return SCRIPTING_NULL;
+		}
+		else
+			return scripting_string_new(kWWWErrCancelled);
+	}
+
+	//*undocumented*
+	CUSTOM private Texture2D GetTexture(bool markNonReadable)
+	{
+		WWW& www = *GET;
+		if (www.GetType() == kWWWTypeCached)
+		{
+			ErrorString(kWWWCachedAccessError);
+			return SCRIPTING_NULL;
+		}
+
+		// create the texture
+		Texture2D* tex = CreateObjectFromCode<Texture2D>();
+
+		if (www.HasDownloadedOrMayBlock ())
+		{
+			LoadMemoryBufferIntoTexture( *tex, self->GetData(), self->GetSize(), kLoadImageUncompressed, markNonReadable );
+			WWW::SecurityPolicy policy = self->GetSecurityPolicy();
+			if (policy != WWW::kSecurityPolicyAllowAccess)
+				tex->SetReadAllowed(false);
+		}
+		else
+		{
+			LoadMemoryBufferIntoTexture( *tex, NULL, 0, kLoadImageUncompressed, markNonReadable );
+		}
+
+		return Scripting::ScriptingWrapperFor(tex);
+	}
+
+	// Returns a [[Texture2D]] generated from the downloaded data (RO).
+	CSRAW public Texture2D texture { get { return GetTexture(false); } }
+
+	// Returns a non-readable [[Texture2D]] generated from the downloaded data (RO).
+	CSRAW public Texture2D textureNonReadable { get { return GetTexture(true); } }
+
+	// Returns a [[AudioClip]] generated from the downloaded data (RO).
+
+	CONDITIONAL !UNITY_WEBGL && ENABLE_AUDIO
+	CSRAW public AudioClip audioClip {
+		get { return GetAudioClip(true); }
+	}
+
+	FLUSHCONDITIONS
+
+	/// *listonly* 
+	CONDITIONAL !UNITY_WEBGL && ENABLE_AUDIO
+	CSRAW public AudioClip GetAudioClip(bool threeD)
+	{
+		return GetAudioClip(threeD, false);
+	}
+	
+	/// *listonly* 
+	CONDITIONAL !UNITY_WEBGL && ENABLE_AUDIO
+	CSRAW public AudioClip GetAudioClip(bool threeD, bool stream)
+	{
+		return GetAudioClip(threeD, stream, AudioType.UNKNOWN);
+	}
+
+	// Returns an [[AudioClip]] generated from the downloaded data (RO).
+	CONDITIONAL !UNITY_WEBGL && ENABLE_AUDIO
+	CUSTOM public AudioClip GetAudioClip(bool threeD, bool stream, AudioType audioType)
+	{
+		IAudio *audio = GetIAudio();
+		if(audio == NULL)
+			return SCRIPTING_NULL;
+		
+		WWW& www = *GET;
+		if (www.GetType() == kWWWTypeCached)
+		{
+			ErrorString(kWWWCachedAccessError);
+			return SCRIPTING_NULL;
+		}
+		
+		AudioClip* clip = audio->CreateAudioClipFromWWW(*GET, threeD, stream, audioType);
+		return Scripting::ScriptingWrapperFor (clip);
+	}
+
+
+	// Returns a [[MovieTexture]] generated from the downloaded data (RO).
+	CONDITIONAL ENABLE_MOVIES
+	CUSTOM_PROP MovieTexture movie
+	{
+
+		WWW& www = *GET;
+		if (www.GetType() == kWWWTypeCached)
+		{
+			ErrorString(kWWWCachedAccessError);
+			return SCRIPTING_NULL;
+		}
+		#if UNITY_EDITOR
+		if (!LicenseInfo::Flag(lf_pro_version))
+		{
+			ErrorString("Movie playback is only possible with Unity Pro");
+			return SCRIPTING_NULL;
+		}
+		#endif
+		
+		MovieTexture* tex = NULL;
+		IAudio *audio = GetIAudio();
+		if(audio)
+			tex = audio->CreateMovieTextureFromWWW(*GET);
+			
+
+		//Not applying any security restrictions here, because currently our API does not allow grabbing samples from the movieclip
+		//It's impossible for a hacker to get his hands on the data, or xfer it somewhere. When we start supporting this, we should
+		//add a crossdomain securitycheck here.
+		return Scripting::ScriptingWrapperFor (tex);
+	}
+
+	// Replaces the contents of an existing [[Texture2D]] with an image from the downloaded data.
+	CUSTOM void LoadImageIntoTexture(Texture2D tex) {
+		WWW& www = *GET;
+		if (www.GetType() == kWWWTypeCached)
+		{
+			ErrorString(kWWWCachedAccessError);
+			return;
+		}
+
+		if (!www.HasDownloadedOrMayBlock ())
+			return;
+
+		LoadMemoryBufferIntoTexture( *tex, www.GetData(), www.GetSize(), IsCompressedDXTTextureFormat(tex->GetTextureFormat())?kLoadImageDXTCompressDithered:kLoadImageUncompressed );
+		if (www.GetSecurityPolicy() != WWW::kSecurityPolicyAllowAccess) tex->SetReadAllowed(false);
+	}
+
+	// Is the download already finished? (RO)
+	CUSTOM_PROP bool isDone {
+		return (short)GET->IsDone();
+	}
+
+	CONDITIONAL !UNITY_FLASH && !UNITY_WEBGL && !UNITY_WINRT
+	OBSOLETE error All blocking WWW functions have been deprecated, please use one of the asynchronous functions instead.
+	CUSTOM static string GetURL(string url) {
+		map<string,string> headers;
+		const char* c_string = url.AsUTF8().c_str();
+		WWW* fetcher = WWW::Create(c_string, NULL, -1, headers);
+
+		MonoString* result;
+
+		if (fetcher->GetSecurityPolicy() != WWW::kSecurityPolicyAllowAccess)
+		{
+			Scripting::RaiseSecurityException("No valid crossdomain policy available to allow access");
+			return scripting_string_new("");
+		}
+
+		if (!fetcher->HasDownloadedOrMayBlock ())
+			result = scripting_string_new("");
+		else
+			result = scripting_string_new((char*)fetcher->GetData(), fetcher->GetSize());
+
+		fetcher->Release();
+		return result;
+	}
+
+	FLUSHCONDITIONS
+
+	CSRAW
+#if !UNITY_FLASH && !UNITY_WEBGL && !UNITY_WINRT
+	OBSOLETE error All blocking WWW functions have been deprecated, please use one of the asynchronous functions instead.
+#endif
+	public static Texture2D GetTextureFromURL(string url) {
+		return new WWW(url).texture;
+	}
+
+	// How far has the download progressed (RO).
+	CUSTOM_PROP float progress
+	{
+		return GET->GetProgress();
+	}
+
+	// How far has the upload progressed (RO).
+	CUSTOM_PROP float uploadProgress
+	{
+		return GET->GetUploadProgress();
+	}
+	
+	// How many bytes have been downloaded (RO).
+	CUSTOM_PROP int bytesDownloaded
+	{
+		return GET->GetSize();
+	}
+
+	// Loads the new web player data file.
+	CUSTOM void LoadUnityWeb ()
+	{
+		WWW& www = *GET;
+		if (!www.HasDownloadedOrMayBlock ())
+			return;
+
+		if (www.GetSecurityPolicy() != WWW::kSecurityPolicyAllowAccess)
+		{
+			Scripting::RaiseSecurityException("No valid crossdomain policy available to allow access");
+			return; //is this return required?
+		}
+
+		#if WEBPLUG
+		QueuePlayerLoadWebData (www.GetUnityWebStream());
+		www.GetUnityWebStream()->RetainDownload (&www);
+		#else
+		LogString (Format("Requested loading unity web file %s. This will only be loaded in the web player.", www.GetUrl ()));
+		#endif
+	}
+
+	// Load an Ogg Vorbis file into the audio clip.
+	
+	CONDITIONAL !UNITY_FLASH && !UNITY_WEBGL && !UNITY_WINRT && ENABLE_AUDIO
+	OBSOLETE warning .oggVorbis accessor is deprecated, use .audioClip or GetAudioClip() instead.
+	CUSTOM_PROP AudioClip oggVorbis
+	{
+		IAudio *audio = GetIAudio();
+		if(audio == NULL) 
+			return SCRIPTING_NULL;
+		
+		if (audio->IsFormatSupportedByPlatform("ogg"))
+		{
+			ErrorString("Streaming of 'ogg' on this platform is not supported");
+			return SCRIPTING_NULL;
+		}
+
+		WWW& www = *GET;
+		if (www.GetType() == kWWWTypeCached)
+		{
+			ErrorString(kWWWCachedAccessError);
+			return SCRIPTING_NULL;
+		}
+
+		if (!www.HasDownloadedOrMayBlock ())
+			return SCRIPTING_NULL;
+		
+		AudioClip *clip = audio->CreateAudioClipOGGFromWWW(*GET);
+		return Scripting::ScriptingWrapperFor(clip);
+	}
+
+	
+	// The URL of this WWW request (RO).
+	CUSTOM_PROP string url { return scripting_string_new(GET->GetUrl()); }
+
+	// Streams an AssetBundle that can contain any kind of asset from the project folder.
+	CUSTOM_PROP AssetBundle assetBundle
+	{
+		return Scripting::ScriptingWrapperFor (ExtractAssetBundle (*GET));
+	}
+
+	// Priority of [[AssetBundle]] decompression thread.
+	// SA: [[ThreadPriority]] enum.
+	CONDITIONAL !UNITY_FLASH && !UNITY_WEBGL
+	CUSTOM_PROP ThreadPriority threadPriority { return GET->GetThreadPriority(); }  { GET->SetThreadPriority(value); }
+
+	CUSTOM internal WWW (string url, int version, uint crc)
+	{
+		string cpp_string = url;
+		#if ENABLE_CACHING
+		WWW* www = new WWWCached(cpp_string.c_str(), version, crc);
+		#else
+		WWW* www = WWW::Create (cpp_string.c_str(), NULL, 0, WWW::WWWHeaders(), 0, crc);
+		#endif
+		self.SetPtr(www);
+	}
+
+	// Loads an AssetBundle with the specified version number from the cache. If the AssetBundle is not currently cached, it will automatically be downloaded and stored in the cache for future retrieval from local storage.
+
+
+	CSRAW public static WWW LoadFromCacheOrDownload( string url, int version, uint crc = 0) {
+		return new WWW(url, version, crc);
+	}
+	C++RAW
+ #undef GET
+END
+
+// Helper class to generate form data to post to web servers using the [[WWW]] class.
+
+
+
+CONDITIONAL !UNITY_WEBGL
+CLASS WWWForm
+
+CSRAW private List<byte[]> formData; // <byte[]>
+CSRAW private List<string> fieldNames; // <string>
+CSRAW private List<string> fileNames; // <string>
+CSRAW private List<string> types; // <string>
+CSRAW private byte[] boundary;
+CSRAW private bool containsFiles = false;
+
+// Creates an empty WWWForm object.
+CSRAW public WWWForm() {
+	formData = new List<byte[]>();
+	fieldNames = new List<string>();
+	fileNames = new List<string>();
+	types = new List<string>();
+
+	// Generate a random boundary
+	boundary=new byte[40];
+	for(int i=0; i<40; i++) {
+		int randomChar=Random.Range(48,110);
+		if(randomChar > 57) // skip unprintable chars between 57 and 64 (inclusive)
+			randomChar+=7;
+		if(randomChar > 90) // and 91 and 96 (inclusive)
+			randomChar+=6;
+		boundary[i]=(byte)randomChar;
+	}
+
+}
+
+// Add a simple field to the form.
+CSRAW public void AddField(string fieldName, string value, Encoding e=System.Text.Encoding.UTF8) {
+	fieldNames.Add(fieldName);
+	fileNames.Add(null);
+	formData.Add(e.GetBytes(value));
+	types.Add("text/plain; charset=\"" + e.WebName + "\"");
+}
+
+// Adds a simple field to the form.
+CSRAW public void AddField(string fieldName, int i) {
+	AddField(fieldName, i.ToString());
+}
+
+// Add binary data to the form.
+CSRAW public void AddBinaryData(string fieldName, byte[] contents, string fileName=null, string mimeType = null) {
+	containsFiles=true;
+
+	// We handle png files automatically as we suspect people will be uploading png files a lot due to the new
+	// screen shot feature. If we want to add support for detecting other file types, we will need to do it in a more extensible way.
+	bool isPng = contents.Length > 8 && contents[0] == 0x89 && contents[1] == 0x50 && contents[2] == 0x4e && contents[3] == 0x47
+									&& contents[4] == 0x0d && contents[5] == 0x0a && contents[6] == 0x1a && contents[7] == 0x0a;
+	if(fileName == null) {
+		fileName = fieldName + (isPng?".png":".dat");
+	}
+	if(mimeType == null) {
+		if(isPng)
+			mimeType="image/png";
+		else
+			mimeType="application/octet-stream";
+	}
+
+	fieldNames.Add(fieldName);
+	fileNames.Add(fileName);
+	formData.Add(contents);
+	types.Add(mimeType);
+}
+
+// (RO) Returns the correct request headers for posting the form using the [[WWW]] class.
+CSRAW #if !UNITY_METRO_API && !UNITY_WP8_API
+CSRAW public Hashtable headers { get {
+		Hashtable retval = new Hashtable();
+		if(containsFiles)
+			retval["Content-Type"]="multipart/form-data; boundary=\"" + System.Text.Encoding.UTF8.GetString(boundary) + "\"";
+		else
+			retval["Content-Type"]="application/x-www-form-urlencoded";
+		return retval;
+	}
+}
+
+CSRAW #else
+CSRAW public Dictionary<string, string> headers { get {
+		Dictionary<string, string> retval = new Dictionary<string, string>();
+		if(containsFiles)
+			retval["Content-Type"]="multipart/form-data; boundary=\"" + System.Text.Encoding.UTF8.GetString(boundary, 0, boundary.Length) + "\"";
+		else
+			retval["Content-Type"]="application/x-www-form-urlencoded";
+		return retval;
+	}
+}
+
+CSRAW #endif
+
+// (RO) The raw data to pass as the POST request body when sending the form.
+CSRAW public byte[] data { get {
+
+		if(containsFiles) {
+			byte[] dDash = WWW.DefaultEncoding.GetBytes("--");
+			byte[] crlf = WWW.DefaultEncoding.GetBytes("\r\n");
+			byte[] contentTypeHeader = WWW.DefaultEncoding.GetBytes("Content-Type: ");
+			byte[] dispositionHeader = WWW.DefaultEncoding.GetBytes("Content-disposition: form-data; name=\"");
+			byte[] endQuote = WWW.DefaultEncoding.GetBytes("\"");
+			byte[] fileNameField = WWW.DefaultEncoding.GetBytes("; filename=\"");
+
+
+			using(MemoryStream memStream = new MemoryStream(1024))
+			{
+				for(int i=0; i < formData.Count; i++) {
+					memStream.Write(crlf, 0, (int) crlf.Length);
+					memStream.Write(dDash, 0, (int) dDash.Length);
+					memStream.Write(boundary, 0, (int) boundary.Length);
+					memStream.Write(crlf, 0, (int) crlf.Length);
+					memStream.Write(contentTypeHeader, 0, (int) contentTypeHeader.Length);
+
+					byte[] type=System.Text.Encoding.UTF8.GetBytes((string)types[i]);
+					memStream.Write(type, 0, (int) type.Length);
+					memStream.Write(crlf, 0, (int) crlf.Length);
+					memStream.Write(dispositionHeader, 0, (int) dispositionHeader.Length);
+					
+					#if !UNITY_METRO_API && !UNITY_WP8_API
+					string headerName = System.Text.Encoding.UTF8.HeaderName;
+					#else
+					string headerName = "";
+					#endif
+					// Headers must be 7 bit clean, so encode as per rfc1522 using quoted-printable if needed.
+					string encodedFieldName=(string)fieldNames[i];
+					if(!WWWTranscoder.SevenBitClean(encodedFieldName, System.Text.Encoding.UTF8) || encodedFieldName.IndexOf("=?") > -1) {
+						encodedFieldName="=?"+headerName+"?Q?"+WWWTranscoder.QPEncode(encodedFieldName, System.Text.Encoding.UTF8) + "?=";
+					}
+					byte[] name=System.Text.Encoding.UTF8.GetBytes(encodedFieldName);
+					memStream.Write(name, 0, (int) name.Length);
+					memStream.Write(endQuote, 0, (int) endQuote.Length);
+
+					if(fileNames[i] != null) {
+						// Headers must be 7 bit clean, so encode as per rfc1522 using quoted-printable if needed.
+						string encodedFileName=(string)fileNames[i];
+						if(!WWWTranscoder.SevenBitClean(encodedFileName, System.Text.Encoding.UTF8) || encodedFileName.IndexOf("=?") > -1) {
+							encodedFileName="=?"+headerName+"?Q?"+WWWTranscoder.QPEncode(encodedFileName, System.Text.Encoding.UTF8) + "?=";
+						}
+						byte[] fileName=System.Text.Encoding.UTF8.GetBytes(encodedFileName);
+
+						memStream.Write(fileNameField, 0, (int) fileNameField.Length);
+						memStream.Write(fileName, 0, (int) fileName.Length);
+						memStream.Write(endQuote, 0, (int) endQuote.Length);
+
+					}
+					memStream.Write(crlf, 0, (int) crlf.Length);
+					memStream.Write(crlf, 0, (int) crlf.Length);
+
+					byte[] formBytes = (byte[])formData[i];
+					memStream.Write(formBytes, 0, (int) formBytes.Length);
+				}
+				memStream.Write(crlf, 0, (int) crlf.Length);
+				memStream.Write(dDash, 0, (int) dDash.Length);
+				memStream.Write(boundary, 0, (int) boundary.Length);
+				memStream.Write(dDash, 0, (int) dDash.Length);
+				memStream.Write(crlf, 0, (int) crlf.Length);
+
+				return memStream.ToArray();
+			}
+		}
+		else {
+			byte[] ampersand = WWW.DefaultEncoding.GetBytes("&");
+			byte[] equal = WWW.DefaultEncoding.GetBytes("=");
+
+			using(MemoryStream memStream = new MemoryStream(1024))
+			{
+				for(int i=0; i < formData.Count; i++) {
+					byte[] name=WWWTranscoder.URLEncode(System.Text.Encoding.UTF8.GetBytes((string)fieldNames[i]));
+					byte[] formBytes = (byte[])formData[i];
+					byte[] value=WWWTranscoder.URLEncode(formBytes);
+
+					if(i>0) memStream.Write(ampersand, 0, (int) ampersand.Length);
+					memStream.Write(name, 0, (int) name.Length);
+					memStream.Write(equal, 0, (int) equal.Length);
+					memStream.Write(value, 0, (int) value.Length);
+				}
+				return memStream.ToArray();
+			}
+		}
+	}
+}
+
+
+END
+//*undocumented*
+CONDITIONAL !UNITY_WEBGL
+CLASS internal WWWTranscoder
+
+	CSRAW private static byte [] ucHexChars = WWW.DefaultEncoding.GetBytes("0123456789ABCDEF");
+	CSRAW private static byte [] lcHexChars = WWW.DefaultEncoding.GetBytes("0123456789abcdef");
+	CSRAW private static byte urlEscapeChar=(byte)'%';
+	CSRAW private static byte urlSpace=(byte)'+';
+	CSRAW private static byte [] urlForbidden=WWW.DefaultEncoding.GetBytes("@&;:<>=?\"'/\\!#%+$,{}|^[]`");
+	CSRAW private static byte qpEscapeChar=(byte)'=';
+	CSRAW private static byte qpSpace=(byte)'_';
+	CSRAW private static byte [] qpForbidden=WWW.DefaultEncoding.GetBytes("&;=?\"'%+_");
+
+	CSRAW private static byte Hex2Byte (byte[] b, int offset) {
+		byte result=(byte)0;
+
+		for (int i = offset; i < offset+2; i++ ) {
+			result *= 16;
+			int d=b[i];
+
+			if (d >= 48 && d <= 57) // 0 - 9
+				d -= 48;
+			else if (d >= 65 && d <= 75) // A -F
+				d -= 55;
+			else if (d >= 97 && d <= 102) // a - f
+				d -= 87;
+			if (d>15) {
+				return 63; // ?
+			}
+
+			result += (byte)d;
+		}
+
+		return result;
+	}
+
+	CSRAW private static byte[] Byte2Hex (byte b, byte[] hexChars) {
+		byte[] dest= new byte[2];
+		dest[0]=hexChars[ b >> 4 ];
+		dest[1]=hexChars[ b &0xf ];
+		return dest;
+	}
+
+
+	CSRAW public static string URLEncode(string toEncode, Encoding e = Encoding.UTF8) {
+		byte[] data = Encode(e.GetBytes(toEncode), urlEscapeChar, urlSpace, urlForbidden, false);
+		return WWW.DefaultEncoding.GetString(data, 0, data.Length);
+	}
+
+	CSRAW public static byte[] URLEncode(byte[] toEncode) {
+		return Encode(toEncode, urlEscapeChar, urlSpace, urlForbidden, false);
+	}
+
+	CSRAW public static string QPEncode(string toEncode, Encoding e = Encoding.UTF8) {
+		byte[] data = Encode(e.GetBytes(toEncode), qpEscapeChar, qpSpace, qpForbidden, true);
+		return WWW.DefaultEncoding.GetString(data, 0, data.Length);
+	}
+
+	CSRAW public static byte[] QPEncode(byte[] toEncode) {
+		return Encode(toEncode, qpEscapeChar, qpSpace, qpForbidden, true);
+	}
+
+	CSRAW public static byte[] Encode(byte[] input, byte escapeChar, byte space, byte[] forbidden, bool uppercase) {
+		using(MemoryStream memStream = new MemoryStream(input.Length*2)) {
+			// encode
+			for(int i=0; i < input.Length; i++) {
+				if(input[i] == 32) {
+					memStream.WriteByte(space);
+				} else if(input[i] < 32 || input[i] > 126 || ByteArrayContains(forbidden, input[i])){
+					memStream.WriteByte(escapeChar);
+					memStream.Write(Byte2Hex(input[i],uppercase?ucHexChars:lcHexChars),0,2);
+				} else {
+					memStream.WriteByte(input[i]);
+				}
+			}
+
+			return memStream.ToArray();
+		}
+
+	}
+
+	CSRAW private static bool ByteArrayContains(byte[] array, byte b)
+	{
+#if !UNITY_FLASH
+		return (System.Array.IndexOf(array, b) != -1);
+#else
+		for(int i = 0; i<array.Length; i++){
+			if(array[i] == b)
+				return true;
+		}
+		return false;
+#endif
+	}
+	
+	CSRAW public static string URLDecode(string toEncode, Encoding e = Encoding.UTF8) {
+		byte []data = Decode(WWW.DefaultEncoding.GetBytes(toEncode), urlEscapeChar, urlSpace);
+		return e.GetString(data, 0, data.Length);
+	}
+
+	CSRAW public static byte[] URLDecode(byte[] toEncode) {
+		return Decode(toEncode, urlEscapeChar, urlSpace);
+	}
+
+	CSRAW public static string QPDecode(string toEncode, Encoding e = Encoding.UTF8) {
+		byte[] data = Decode(WWW.DefaultEncoding.GetBytes(toEncode), qpEscapeChar, qpSpace);
+		return e.GetString(data, 0, data.Length);
+	}
+
+	CSRAW public static byte[] QPDecode(byte[] toEncode){
+		return Decode(toEncode, qpEscapeChar, qpSpace);
+	}
+
+	CSRAW public static byte[] Decode(byte[] input, byte escapeChar, byte space) {
+		using(MemoryStream memStream = new MemoryStream(input.Length)) {
+			// decode
+			for(int i=0; i < input.Length; i++) {
+				if(input[i] == space) {
+					memStream.WriteByte((byte)32);
+				} else if(input[i] == escapeChar && i+2 < input.Length) {
+					i++;
+					memStream.WriteByte(Hex2Byte(input,i++));
+				} else {
+					memStream.WriteByte(input[i]);
+				}
+			}
+
+			return memStream.ToArray();
+		}
+
+	}
+
+	CSRAW public static bool SevenBitClean(string s, Encoding e = Encoding.UTF8) {
+		return SevenBitClean(e.GetBytes(s));
+	}
+
+	CSRAW public static bool SevenBitClean(byte[] input) {
+		for(int i= 0; i<input.Length; i++) {
+			if (input[i] < 32 || input[i] > 126 )
+				return false;
+		}
+
+		return true;
+	}
+
+
+END
+
+CSRAW
+[System.Obsolete ("this API is not for public use.")]
+public struct CacheIndex {
+	public string name;
+	public int bytesUsed;
+	public int expires;
+}
+
+C++RAW
+
+struct MonoCacheIndex {
+	ScriptingStringPtr name;
+	int bytesUsed;
+	int expires;
+};
+
+// The Caching class lets you manage cached AssetBundles, downloaded using WWW::ref::LoadFromCacheOrDownload.
+CONDITIONAL ENABLE_CACHING
+CLASS Caching
+
+// (This is a WebPlayer-only function)
+CSRAW public static bool Authorize (string name, string domain, long size, string signature)
+{
+	return Authorize(name, domain, size, -1, signature);
+}
+///*listonly*
+CUSTOM static bool Authorize(string name, string domain, long size, int expiration, string signature)
+{
+	return GetCachingManager().Authorize(name, domain, size, expiration, signature);
+}
+
+OBSOLETE warning Size is now specified as a long
+CSRAW public static bool Authorize(string name, string domain, int size, int expiration, string signature)
+{
+	return Authorize(name, domain, (long)size, expiration, signature);
+}
+
+OBSOLETE warning Size is now specified as a long
+CSRAW public static bool Authorize (string name, string domain, int size, string signature)
+{
+	return Authorize( name, domain, (long)size, signature);
+}
+
+// Delete all AssetBundle content that has been cached by the current application.
+CUSTOM static bool CleanCache ()
+{
+	if (GetCachingManager().GetAuthorizationLevel() >= CachingManager::kAuthorizationUser)
+		return GetCachingManager().GetCurrentCache().CleanCache();
+	else
+	{
+		ErrorString("Unauthorized use of Caching API.");
+		return false;
+	}
+}
+
+OBSOLETE warning this API is not for public use.
+CUSTOM static bool CleanNamedCache (string name)
+{
+	if (GetCachingManager().GetAuthorizationLevel() >= CachingManager::kAuthorizationAdmin)
+		return GetCachingManager().CleanCache(name);
+	else
+	{
+		ErrorString("Unauthorized use of Caching API.");
+		return false;
+	}
+}
+
+OBSOLETE warning This function is obsolete and has no effect.
+CUSTOM static bool DeleteFromCache (string url)
+{
+	return false;
+}
+
+OBSOLETE warning This function is obsolete and will always return -1. Use IsVersionCached instead.
+CUSTOM static int GetVersionFromCache (string url)
+{
+	return -1;
+}
+
+// Checks if an AssetBundle is cached.
+CUSTOM static bool IsVersionCached (string url, int version)
+{
+	return GetCachingManager().IsCached(url, version);
+}
+
+// Bumps the timestamp of a cached file to be the current time.
+CUSTOM static bool MarkAsUsed (string url, int version)
+{
+	return GetCachingManager().MarkAsUsed(url, version);
+}
+
+OBSOLETE warning this API is not for public use.
+CUSTOM_PROP static CacheIndex[] index
+{
+#if !UNITY_WINRT && ENABLE_WWW
+	if (GetCachingManager().GetAuthorizationLevel() < CachingManager::kAuthorizationAdmin)
+	{
+		ErrorString("Unauthorized use of Caching API.");
+		return NULL;
+	}
+	vector<Cache*> &indices = GetGlobalCachingManager().GetCacheIndices();
+	MonoArray *monoIndices = mono_array_new (mono_domain_get (), GetMonoManager().GetCommonClasses().cacheIndex, indices.size() );
+
+	for(int i=0; i<indices.size(); i++)
+	{
+		GetMonoArrayElement<MonoCacheIndex>(monoIndices, i).name = scripting_string_new (indices[i]->m_Name);
+		GetMonoArrayElement<MonoCacheIndex>(monoIndices, i).bytesUsed = indices[i]->m_BytesUsed;
+		GetMonoArrayElement<MonoCacheIndex>(monoIndices, i).expires = indices[i]->m_Expires;
+	}
+	return monoIndices;
+#else
+	return SCRIPTING_NULL;
+#endif
+}
+
+// The number of currently unused bytes in the cache.
+CUSTOM_PROP static long spaceFree
+{
+	return GetCachingManager().GetCachingDiskSpaceFree();
+}
+
+// The total number of bytes that can potentially be allocated for caching.
+CUSTOM_PROP static long maximumAvailableDiskSpace
+{
+	return GetCachingManager().GetMaximumDiskSpaceAvailable();
+}
+{
+	GetCachingManager().SetMaximumDiskSpaceAvailable(value);
+}
+
+// Used disk space in bytes.
+CUSTOM_PROP static long spaceOccupied
+{
+	return GetCachingManager().GetCachingDiskSpaceUsed();
+}
+
+OBSOLETE warning Please use Caching.spaceFree instead
+CUSTOM_PROP static int spaceAvailable
+{
+	return GetCachingManager().GetCachingDiskSpaceFree();
+}
+
+OBSOLETE warning Please use Caching.spaceOccupied instead
+CUSTOM_PROP static int spaceUsed
+{
+	return GetCachingManager().GetCachingDiskSpaceUsed();
+}
+
+// The number of seconds that an AssetBundle may remain unused in the cache before it is automatically deleted.
+CUSTOM_PROP static int expirationDelay
+{
+	return GetCachingManager().GetExpirationDelay();
+}
+{
+	if (GetCachingManager().GetAuthorizationLevel() >= CachingManager::kAuthorizationUser)
+		GetCachingManager().GetCurrentCache().SetExpirationDelay(value);
+}
+
+// Is Caching enabled?
+CUSTOM_PROP static bool enabled
+{
+	return GetCachingManager().GetEnabled();
+}
+{
+	if (GetCachingManager().GetAuthorizationLevel() >= CachingManager::kAuthorizationAdmin)
+		GetCachingManager().SetEnabled(value);
+	else
+		ErrorString("Unable to assign a value to Caching.enabled. This property is read-only.");
+}
+
+// Is caching ready?
+CUSTOM_PROP static bool ready
+{
+	return GetCachingManager().GetIsReady();
+}
+
+CONDITIONAL UNITY_IPHONE_API
+CUSTOM static void SetNoBackupFlag (string url, int version)
+{
+#if UNITY_IPHONE
+	GetCachingManager().SetNoBackupFlag(url, version);
+#endif
+}
+
+CONDITIONAL UNITY_IPHONE_API
+CUSTOM static void ResetNoBackupFlag (string url, int version)
+{
+#if UNITY_IPHONE
+	GetCachingManager().ResetNoBackupFlag(url, version);
+#endif
+}
+
+END
+
+CSRAW
+
+#endif //ENABLE_WWW
+
+CONDITIONAL !UNITY_FLASH && !UNITY_WEBGL && !UNITY_WINRT
+CLASS internal UnityLogWriter : System.IO.TextWriter
+
+	THREAD_SAFE
+	CUSTOM static void WriteStringToUnityLog(string s)
+	{
+		//this userstring could contains things like "%20", which we should make sure printf does not interpet
+		//as if we wanted to print some argument.
+		if (s.IsNull())
+			return;
+
+		std::string utf8 = s.AsUTF8();
+		printf_console("%s",utf8.c_str());
+	}
+
+	CSRAW
+	public static void Init()
+	{
+		System.Console.SetOut(new UnityLogWriter());
+	}
+	public override System.Text.Encoding Encoding
+	{
+			get { return System.Text.Encoding.UTF8; }
+	}
+	public override void Write(char value)
+	{
+			WriteStringToUnityLog(value.ToString());
+	}
+	public override void Write(string s)
+	{
+			WriteStringToUnityLog(s);
+	}
+
+END
+
+CLASS internal UnityString
+	CSRAW
+	public static string Format(string fmt, params object[] args)
+	{
+		return String.Format(fmt, args);
+	}
+END
+
+}
\ No newline at end of file