C++RAW


#include "UnityPrefix.h"
#include "Configuration/UnityConfigure.h"
#include "Runtime/Misc/AssetBundle.h"
#include "Runtime/Misc/AssetBundleUtility.h"
#include "Runtime/Scripting/ScriptingUtility.h"
#include "Runtime/Scripting/ScriptingExportUtility.h"
#include "Runtime/Scripting/Backend/ScriptingBackendApi.h"
#include "Runtime/Misc/SaveAndLoadHelper.h"
#include "Runtime/Misc/AsyncOperation.h"
#include "Runtime/Scripting/Scripting.h"


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
{


// Asynchronous create request for an [[AssetBundle]].
CONDITIONAL ENABLE_WWW
CLASS AssetBundleCreateRequest : AsyncOperation

	C++RAW
	#define GET_REQUEST(variableName) \
		AssetBundleCreateRequest* variableName; \
		MarshallManagedStructIntoNative (self, &variableName);

	// Asset object being loaded (RO).
	CUSTOM_PROP AssetBundle assetBundle
	{
		GET_REQUEST (ptr);
		return Scripting::ScriptingWrapperFor(ptr->GetAssetBundle());
	}

	CUSTOM internal void DisableCompatibilityChecks()
	{
		GET_REQUEST (ptr);
		ptr->SetEnableCompatibilityChecks (false);
	}

	C++RAW
	#undef GET_REQUEST

END

// Asynchronous load request from an [[AssetBundle]].
CSRAW [StructLayout (LayoutKind.Sequential)]
CLASS AssetBundleRequest : AsyncOperation
	C++RAW
 #define GET ExtractMonoObjectData<PreloadManagerOperation*> (self)

	CSRAW internal AssetBundle m_AssetBundle;
	CSRAW internal string m_Path;
	CSRAW internal Type m_Type;

	// Asset object being loaded (RO).
	CSRAW public Object asset { get { return m_AssetBundle.Load(m_Path, m_Type); } }

	C++RAW
 #undef GET

END

// AssetBundles let you stream additional assets via the WWW class and instantiate them at runtime. AssetBundles are created via BuildPipeline.BuildAssetBundle.

CLASS AssetBundle : Object

	// Asynchronously create an AssetBundle from a memory region.
	CONDITIONAL ENABLE_WWW
	CUSTOM static AssetBundleCreateRequest CreateFromMemory(byte[] binary)
	{
		if (!binary)
			return SCRIPTING_NULL;

		int dataSize = GetScriptingArraySize(binary);
		UInt8* dataPtr = Scripting::GetScriptingArrayStart<UInt8>(binary);

		AsyncOperation* req = new AssetBundleCreateRequest(dataPtr, dataSize);


		return CreateScriptingObjectFromNativeStruct(MONO_COMMON.assetBundleCreateRequest,req);
	}

	// Loads an asset bundle from a disk.
	CUSTOM static AssetBundle CreateFromFile(string path)
	{
		return Scripting::ScriptingWrapperFor(ExtractAssetBundle(path));
	}

	// Main asset that was supplied when building the asset bundle (RO).
	CUSTOM_PROP Object mainAsset { return Scripting::ScriptingWrapperFor(LoadMainObjectFromAssetBundle(*self)); }

	// Check if an AssetBundle contains a specific object.
	CUSTOM bool Contains (string name)
	{
		string lowerName = ToLower(name.AsUTF8());
		AssetBundle::range found = self->GetPathRange(lowerName);
		return found.first != found.second;
	}

	// Loads object with /name/ from the bundle.
	CSRAW public Object Load (string name)
	{
		return Load(name, typeof(Object));
	}

	// Loads object with /name/ of a given /type/ from the bundle.
	CSRAW
	[TypeInferenceRule(TypeInferenceRules.TypeReferencedBySecondArgument)]
	CONSTRUCTOR_SAFE
	CUSTOM Object Load (string name, Type type)
	{
		Scripting::RaiseIfNull (type);
		Object* o = LoadNamedObjectFromAssetBundle(*self, name, type);
		if (o==0) return SCRIPTING_NULL;
		return Scripting::ScriptingWrapperFor(o);
	}

	// Asynchronously loads object with /name/ of a given /type/ from the bundle.
	CUSTOM AssetBundleRequest LoadAsync (string name, Type type)
	{
		AsyncOperation* result = PreloadLevelOperation::LoadAssetBundle(*self, name);
		#if ENABLE_MONO || UNITY_WINRT
		ScriptingObjectPtr mono = scripting_object_new(MONO_COMMON.assetBundleRequest);
		AssetBundleRequestMono data;
		data.m_Result = result;
		data.m_Path = name.GetNativeString();
		data.m_Type = type;
		data.m_AssetBundle = Scripting::ScriptingWrapperFor((AssetBundle*)self);
		MarshallNativeStructIntoManaged(data, mono);

		return mono;
		#else
		return SCRIPTING_NULL;
		#endif

	}

	// Loads all objects contained in the asset bundle that inherit from /type/.
	CUSTOM Object[] LoadAll (Type type)
	{
		Scripting::RaiseIfNull (type);

		vector<Object* > objects;
		LoadAllFromAssetBundle(*self, type, objects);
		return CreateScriptingArrayFromUnityObjects(objects, ClassID(Object));
	}

	// Loads all objects contained in the asset bundle.
	CSRAW public Object[] LoadAll ()
	{
		return LoadAll(typeof(Object));
	}

	// Unloads all assets in the bundle.
	CUSTOM void Unload (bool unloadAllLoadedObjects)
	{
		AssetBundle& file = *self;
		UnloadAssetBundle(file, unloadAllLoadedObjects);
	}
END

CSRAW }