Major refactor of how Resource types are exposed to C#, in order to make it significantly more streamlined for adding new Resource types

Source/CMake/GenerateScriptBindings.cmake

@@ -35,69 +35,59 @@ function(addForGeneration name)
 	set(BS_SCRIPT_PARSER_H_FILES ${BS_SCRIPT_PARSER_H_FILES} ${ABS_H_FILES} PARENT_SCOPE)	
 endfunction()
 
-addForGeneration(BansheeUtility)
-addForGeneration(BansheeCore)
-addForGeneration(BansheeEngine)
-addForGeneration(BansheeEditor)
-addForGeneration(SBansheeEngine)
-addForGeneration(SBansheeEditor)
-
-set(BS_SCRIPT_PARSER_INCLUDE_DIRS ${BS_SCRIPT_PARSER_INCLUDE_DIRS} "BansheeMono/Include")
-
-list(REMOVE_DUPLICATES BS_SCRIPT_PARSER_INCLUDE_DIRS)
-list(REMOVE_DUPLICATES BS_SCRIPT_PARSER_H_FILES)
-
 set(BS_GENERATED_CPP_OUTPUT_DIR ${PROJECT_BINARY_DIR}/Generated)
 set(BS_GENERATED_CS_ENGINE_OUTPUT_DIR ${PROJECT_SOURCE_DIR}/MBansheeEngine/Generated)
 set(BS_GENERATED_CS_EDITOR_OUTPUT_DIR ${PROJECT_SOURCE_DIR}/MBansheeEditor/Generated)
-prepend(BS_INCLUDE_DIRS "-I${PROJECT_SOURCE_DIR}" ${BS_SCRIPT_PARSER_INCLUDE_DIRS})
 
-# Generate a single .cpp file including all headers
-set(BS_GLOBAL_FILE_CONTENTS "")
-FOREACH(f ${BS_SCRIPT_PARSER_H_FILES})
-	LIST(APPEND BS_GLOBAL_FILE_CONTENTS "#include \"${f}\"\n")
-ENDFOREACH(f)
+if(GENERATE_SCRIPT_BINDINGS)
+	addForGeneration(BansheeUtility)
+	addForGeneration(BansheeCore)
+	addForGeneration(BansheeEngine)
+	addForGeneration(BansheeEditor)
+	addForGeneration(SBansheeEngine)
+	addForGeneration(SBansheeEditor)
 
-file(WRITE ${BS_GENERATED_CPP_OUTPUT_DIR}/toParse.cpp ${BS_GLOBAL_FILE_CONTENTS})
+	set(BS_SCRIPT_PARSER_INCLUDE_DIRS ${BS_SCRIPT_PARSER_INCLUDE_DIRS} "BansheeMono/Include")
+
+	list(REMOVE_DUPLICATES BS_SCRIPT_PARSER_INCLUDE_DIRS)
+	list(REMOVE_DUPLICATES BS_SCRIPT_PARSER_H_FILES)
+
+	prepend(BS_INCLUDE_DIRS "-I${PROJECT_SOURCE_DIR}" ${BS_SCRIPT_PARSER_INCLUDE_DIRS})
+
+	# Generate a single .cpp file including all headers
+	set(BS_GLOBAL_FILE_CONTENTS "")
+	FOREACH(f ${BS_SCRIPT_PARSER_H_FILES})
+		LIST(APPEND BS_GLOBAL_FILE_CONTENTS "#include \"${f}\"\n")
+	ENDFOREACH(f)
+
+	file(WRITE ${BS_GENERATED_CPP_OUTPUT_DIR}/toParse.cpp ${BS_GLOBAL_FILE_CONTENTS})
+endif()
 
 find_package(BansheeSBGen)
 if(BansheeSBGen_FOUND)
-	set(BS_GSB_COMMAND ${BansheeSBGen_EXECUTABLE_PATH}
-		${BS_GENERATED_CPP_OUTPUT_DIR}/toParse.cpp
-		-output-cpp ${BS_GENERATED_CPP_OUTPUT_DIR}
-		-output-cs-engine ${BS_GENERATED_CS_ENGINE_OUTPUT_DIR}
-		-output-cs-editor ${BS_GENERATED_CS_EDITOR_OUTPUT_DIR}
-		-- ${BS_INCLUDE_DIRS}
-		-DBS_STATIC_LIB
-		-w)
+	if(GENERATE_SCRIPT_BINDINGS)
+		set(BS_GSB_COMMAND ${BansheeSBGen_EXECUTABLE_PATH}
+			${BS_GENERATED_CPP_OUTPUT_DIR}/toParse.cpp
+			-output-cpp ${BS_GENERATED_CPP_OUTPUT_DIR}
+			-output-cs-engine ${BS_GENERATED_CS_ENGINE_OUTPUT_DIR}
+			-output-cs-editor ${BS_GENERATED_CS_EDITOR_OUTPUT_DIR}
+			-- ${BS_INCLUDE_DIRS}
+			-DBS_STATIC_LIB
+			-w)
 
-	message(STATUS "Generating script bindings, please wait...")
-	execute_process(
-		COMMAND ${BS_GSB_COMMAND}
-		WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
-		RESULT_VARIABLE SBGEN_RETURN_VALUE
-	)
+		message(STATUS "Generating script bindings, please wait...")
+		execute_process(
+			COMMAND ${BS_GSB_COMMAND}
+			WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
+			RESULT_VARIABLE SBGEN_RETURN_VALUE
+		)
 
-	if (NOT SBGEN_RETURN_VALUE EQUAL 0)
-		message(FATAL_ERROR "Failed to generate script bindings.")
-	else()
-		message(STATUS "...scripting binding generation OK.")
-	endif()	
-		
-	add_custom_target(GenerateScriptBindings
-		COMMAND ${BS_GSB_COMMAND}
-		WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
-		COMMENT "Generating script bindings, please wait...")	
-		
-	#add_custom_command(
-	#	OUTPUT ${BS_GENERATED_CPP_OUTPUT_DIR}/scriptBindings2.timestamp
-	#	COMMAND echo "Test"
-	#	DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/input.cpp
-	#	COMMENT "Generating script bindings, please wait...")	
-		
-	#add_custom_target(GenerateScriptBindings 
-	#	DEPENDS ${BS_GENERATED_CPP_OUTPUT_DIR}/scriptBindings2.timestamp
-	#	COMMENT "Running custom target")	
+		if (NOT SBGEN_RETURN_VALUE EQUAL 0)
+			message(FATAL_ERROR "Failed to generate script bindings.")
+		else()
+			message(STATUS "...scripting binding generation OK.")
+		endif()
+	endif()
 		
 	file(GLOB BS_GENERATED_ENGINE_H_FILES ${BS_GENERATED_CPP_OUTPUT_DIR}/Engine/Include/*)
 	file(GLOB BS_GENERATED_ENGINE_CPP_FILES ${BS_GENERATED_CPP_OUTPUT_DIR}/Engine/Source/*)

Source/CMakeLists.txt

@@ -48,6 +48,8 @@ set_property(CACHE BUILD_SCOPE PROPERTY STRINGS "Runtime" "Framework")
 
 set(INCLUDE_ALL_IN_WORKFLOW OFF CACHE BOOL "If true, all libraries (even those not selected) will be included in the generated workflow (e.g. Visual Studio solution). This is useful when working on engine internals with a need for easy access to all parts of it. Only relevant for workflow generators like Visual Studio or XCode.")
 
+set(GENERATE_SCRIPT_BINDINGS ON CACHE BOOL "If true, script binding files will be generated. Script bindings are required for the project to build properly, however they take a while to generate. If you are sure the script bindings are up to date, you can turn off their generation (temporarily) to speed up the build.")
+
 if(BUILD_SCOPE MATCHES "Runtime")
 	set(BUILD_EDITOR ON)
 else()
@@ -235,7 +237,7 @@ configure_file("${PROJECT_SOURCE_DIR}/CMake/BsFrameworkConfig.h.in" "${PROJECT_S
 
 # Code generation for script bindings
 include(CMake/GenerateScriptBindings.cmake)
-
+	
 # Sub-directories
 ## Layers
 add_subdirectory(BansheeUtility)

Source/SBansheeEditor/Source/BsGUIResourceField.cpp

@@ -16,6 +16,7 @@
 #include "BsBuiltinEditorResources.h"
 #include "BsScriptManagedResource.h"
 #include "BsSelection.h"
+#include "BsScriptAssemblyManager.h"
 
 using namespace std::placeholders;
 
@@ -300,10 +301,11 @@ namespace bs
 			String uuid = meta->getUUID();
 
 			bool found = false;
-			MonoClass* scriptClass = ScriptResource::getClassFromTypeId(typeId);
-			if (scriptClass != nullptr)
+
+			BuiltinResourceInfo* resInfo = ScriptAssemblyManager::instance().getBuiltinResourceInfo(typeId);
+			if (resInfo != nullptr)
 			{
-				if (scriptClass->isSubClassOf(acceptedClass))
+				if (resInfo->monoClass->isSubClassOf(acceptedClass))
 				{
 					setUUID(uuid);
 					found = true;

Source/SBansheeEditor/Source/BsScriptEditorApplication.cpp

@@ -234,9 +234,7 @@ namespace bs
 			gProjectLibrary().createEntry(scene, nativePath);
 		}
 
-		ScriptPrefab* scriptPrefab;
-		ScriptResourceManager::instance().getScriptResource(scene, &scriptPrefab, true);
-
+		ScriptResourceBase* scriptPrefab = ScriptResourceManager::instance().getScriptResource(scene, true);
 		return scriptPrefab->getManagedInstance();
 	}
 

Source/SBansheeEditor/Source/BsScriptEditorBuiltin.cpp

@@ -107,9 +107,7 @@ namespace bs
 	{
 		HFont font = BuiltinEditorResources::instance().getDefaultFont();
 
-		ScriptFont* scriptFont;
-		ScriptResourceManager::instance().getScriptResource(font, &scriptFont, true);
-
+		ScriptResourceBase* scriptFont = ScriptResourceManager::instance().getScriptResource(font, true);
 		return scriptFont->getManagedInstance();
 	}
 
@@ -117,9 +115,7 @@ namespace bs
 	{
 		HGUISkin guiSkin = BuiltinEditorResources::instance().getSkin();
 
-		ScriptGUISkin* scriptGUISkin;
-		ScriptResourceManager::instance().getScriptResource(guiSkin, &scriptGUISkin, true);
-
+		ScriptResourceBase* scriptGUISkin = ScriptResourceManager::instance().getScriptResource(guiSkin, true);
 		return scriptGUISkin->getManagedInstance();
 	}
 }

Source/SBansheeEditor/Source/BsScriptEditorUtility.cpp

@@ -73,9 +73,7 @@ namespace bs
 		ScriptArray output = ScriptArray::create<ScriptResource>(numEntries);
 		for (UINT32 i = 0; i < numEntries; i++)
 		{
-			ScriptResourceBase* dependency;
-			ScriptResourceManager::instance().getScriptResource(dependencies[i].resource, &dependency, true);
-
+			ScriptResourceBase* dependency = ScriptResourceManager::instance().getScriptResource(dependencies[i].resource, true);
 			output.set(i, dependency->getManagedInstance());
 		}
 

Source/SBansheeEditor/Source/BsScriptGUIResourceField.cpp

@@ -129,20 +129,11 @@ namespace bs
 	MonoObject* ScriptGUIResourceField::nativeToManagedResource(const HResource& instance)
 	{
 		if (instance == nullptr)
-		{
 			return nullptr;
-		}
 		else
 		{
-			ScriptResourceBase* scriptResource = ScriptResourceManager::instance().getScriptResource(instance.getUUID());
-			if (scriptResource == nullptr)
-			{
-				ScriptResourceManager::instance().createScriptResource(instance, &scriptResource);
-
-				return scriptResource->getManagedInstance();
-			}
-			else
-				return scriptResource->getManagedInstance();
+			ScriptResourceBase* scriptResource = ScriptResourceManager::instance().getScriptResource(instance, true);
+			return scriptResource->getManagedInstance();
 		}
 	}
 }

Source/SBansheeEditor/Source/BsScriptGUITextureField.cpp

@@ -126,9 +126,7 @@ namespace bs
 		if (instance == nullptr)
 			return nullptr;
 
-		ScriptTexture* scriptResource = nullptr;
-		ScriptResourceManager::instance().getScriptResource(instance, &scriptResource, true);
-
+		ScriptResourceBase* scriptResource = ScriptResourceManager::instance().getScriptResource(instance, true);
 		return scriptResource->getManagedInstance();
 	}
 }

Source/SBansheeEditor/Source/BsScriptProjectLibrary.cpp

@@ -9,6 +9,7 @@
 #include "BsResources.h"
 #include "BsProjectResourceMeta.h"
 #include "BsScriptResourceManager.h"
+#include "BsScriptAssemblyManager.h"
 #include "BsScriptImportOptions.h"
 #include "BsEditorApplication.h"
 #include "BsManagedSerializableObject.h"
@@ -93,9 +94,7 @@ namespace bs
 		if (!resource)
 			return nullptr;
 
-		ScriptResourceBase* scriptResource;
-		ScriptResourceManager::instance().getScriptResource(resource, &scriptResource, true);
-
+		ScriptResourceBase* scriptResource = ScriptResourceManager::instance().getScriptResource(resource, true);
 		return scriptResource->getManagedInstance();
 	}
 
@@ -191,8 +190,11 @@ namespace bs
 			ScriptArray typeArray(types);
 			for (UINT32 i = 0; i < typeArray.size(); i++)
 			{
-				UINT32 typeId = ScriptResource::getTypeIdFromType((ScriptResourceType)typeArray.get<UINT32>(i));
-				typeIds.push_back(typeId);
+				BuiltinResourceInfo* resInfo = ScriptAssemblyManager::instance().getBuiltinResourceInfo((ScriptResourceType)typeArray.get<UINT32>(i));
+				if (resInfo == nullptr)
+					continue;
+
+				typeIds.push_back(resInfo->typeId);
 			}
 		}
 
@@ -529,7 +531,11 @@ namespace bs
 
 	ScriptResourceType ScriptResourceMeta::internal_GetResourceType(ScriptResourceMeta* thisPtr)
 	{
-		return ScriptResource::getTypeFromTypeId(thisPtr->mMeta->getTypeID());
+		BuiltinResourceInfo* resInfo = ScriptAssemblyManager::instance().getBuiltinResourceInfo(thisPtr->mMeta->getTypeID());
+		if (resInfo == nullptr)
+			return ScriptResourceType::Undefined;
+
+		return resInfo->resType;
 	}
 
 	MonoObject* ScriptResourceMeta::internal_GetEditorData(ScriptResourceMeta* thisPtr)

Source/SBansheeEngine/CMakeSources.cmake

@@ -287,6 +287,7 @@ set(BS_SBANSHEEENGINE_INC_SERIALIZATION
 	"Include/BsManagedSerializableDiff.h"
 	"Include/BsManagedDiff.h"
 	"Include/BsBuiltinComponentLookup.h"
+	"Include/BsBuiltinResourceLookup.h"
 )
 
 set(BS_SBANSHEEENGINE_SRC_NOFILTER

Source/SBansheeEngine/Include/BsBuiltinComponentLookup.h

@@ -6,8 +6,6 @@
 #include "BsScriptMeta.h"
 #include "BsMonoClass.h"
 
-#include "BsScriptRenderable.h"
-
 namespace bs
 {
 	/** Begins the definition for the builtin component lookup table. */

Source/SBansheeEngine/Include/BsBuiltinResourceLookup.h

@@ -0,0 +1,70 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#pragma once
+
+#include "BsScriptEnginePrerequisites.h"
+#include "BsScriptMeta.h"
+#include "BsMonoClass.h"
+#include "BsRTTIType.h"
+
+namespace bs
+{
+	/** Begins the definition for the builtin resource lookup table. */
+#define LOOKUP_BEGIN																										\
+	class BuiltinResourceTypes																								\
+	{																														\
+	private:																												\
+		struct META_FirstEntry {};																							\
+		static void META_GetPrevEntries(Vector<BuiltinResourceInfo>& entries, META_FirstEntry id) { }						\
+																															\
+		typedef META_FirstEntry 
+
+	/** Registers a new entry in the resource lookup table. */
+#define ADD_ENTRY(ResourceType, ScriptType, ResourceTypeEnum)																\
+		META_Entry_##ScriptType;																							\
+																															\
+	public:																													\
+		static ScriptResourceBase* create##ScriptType(const HResource& resource, MonoObject* existingInstance)				\
+		{																													\
+			MonoObject* managedInstance;																					\
+			if(existingInstance != nullptr)																					\
+				managedInstance = existingInstance;																			\
+			else																											\
+				managedInstance = ScriptType::createInstance();																\
+																															\
+			ResourceHandle<ResourceType> castHandle = static_resource_cast<ResourceType>(resource);							\
+			ScriptType* scriptResource = new (bs_alloc<ScriptType>()) ScriptType(managedInstance, castHandle);				\
+																															\
+			return scriptResource;																							\
+		}																													\
+																															\
+		struct META_NextEntry_##ScriptType {};																				\
+		static void META_GetPrevEntries(Vector<BuiltinResourceInfo>& entries, META_NextEntry_##ScriptType id)				\
+		{																													\
+			META_GetPrevEntries(entries, META_Entry_##ScriptType());														\
+																															\
+			BuiltinResourceInfo entry;																						\
+			entry.metaData = ScriptType::getMetaData();																		\
+			entry.typeId = ResourceType::getRTTIStatic()->getRTTIId();														\
+			entry.monoClass = nullptr;																						\
+			entry.resType = ResourceTypeEnum;																				\
+			entry.createCallback = &create##ScriptType;																		\
+																															\
+			entries.push_back(entry);																						\
+		}																													\
+																															\
+		typedef META_NextEntry_##ScriptType
+
+	/** End the definition for the builtin resource lookup table. */
+#define LOOKUP_END																											\
+		META_LastEntry;																										\
+																															\
+	public:																													\
+		static Vector<BuiltinResourceInfo> getEntries()																		\
+		{																													\
+			Vector<BuiltinResourceInfo> entries;																			\
+			META_GetPrevEntries(entries, META_LastEntry());																	\
+			return entries;																									\
+		}																													\
+	};
+}

Source/SBansheeEngine/Include/BsManagedSerializableObjectInfo.h

@@ -33,29 +33,15 @@ namespace bs
 	/** Valid reference script types. */
 	enum class ScriptReferenceType
 	{
-		Texture,
-		SpriteTexture,
+		BuiltinResourceBase,
+		BuiltinResource,
+		ManagedResourceBase,
 		ManagedResource,
-		PlainText,
-		ScriptCode,
-		Shader,
-		ShaderInclude,
-		Material,
-		Mesh,
-		Prefab,
-		Font,
-		StringTable,
-		GUISkin,
-		SceneObject,
-		BuiltinComponent,
-		PhysicsMaterial,
-		PhysicsMesh,
-		AudioClip,
-		AnimationClip,
-		ManagedComponent,
-		Resource,
 		BuiltinComponentBase,
+		BuiltinComponent,
 		ManagedComponentBase,
+		ManagedComponent,
+		SceneObject,
 		Count // Keep at end
 	};
 

Source/SBansheeEngine/Include/BsScriptAnimationClip.h

@@ -23,6 +23,7 @@ namespace bs
 
 	private:
 		friend class ScriptResourceManager;
+		friend class BuiltinResourceTypes;
 
 		ScriptAnimationClip(MonoObject* instance, const HAnimationClip& animationClip);
 

Source/SBansheeEngine/Include/BsScriptAssemblyManager.h

@@ -59,6 +59,24 @@ namespace bs
 		 */
 		BuiltinComponentInfo* getBuiltinComponentInfo(UINT32 rttiTypeId);
 
+		/** 
+		 * Maps a mono type to information about a wrapped built-in resource. Returns null if type doesn't correspond to
+		 * a builtin resource. 
+		 */
+		BuiltinResourceInfo* getBuiltinResourceInfo(::MonoReflectionType* type);
+
+		/** 
+		 * Maps a type id to information about a wrapped built-in resource. Returns null if type id doesn't correspond to
+		 * a builtin resource. 
+		 */
+		BuiltinResourceInfo* getBuiltinResourceInfo(UINT32 rttiTypeId);
+
+		/** 
+		 * Maps a resource type to information about a wrapped built-in resource. Returns null if type id doesn't correspond to
+		 * a builtin resource. 
+		 */
+		BuiltinResourceInfo* getBuiltinResourceInfo(ScriptResourceType type);
+
 		/**
 		 * Checks if the managed serializable object info for the specified type exists.
 		 *
@@ -113,9 +131,15 @@ namespace bs
 		/** Initializes information required for mapping builtin components to managed components. */
 		void initializeBuiltinComponentInfos();
 
+		/** Initializes information required for mapping builtin resources to managed resources. */
+		void initializeBuiltinResourceInfos();
+
 		UnorderedMap<String, SPtr<ManagedSerializableAssemblyInfo>> mAssemblyInfos;
 		UnorderedMap<::MonoReflectionType*, BuiltinComponentInfo> mBuiltinComponentInfos;
 		UnorderedMap<UINT32, BuiltinComponentInfo> mBuiltinComponentInfosByTID;
+		UnorderedMap<::MonoReflectionType*, BuiltinResourceInfo> mBuiltinResourceInfos;
+		UnorderedMap<UINT32, BuiltinResourceInfo> mBuiltinResourceInfosByTID;
+		UnorderedMap<UINT32, BuiltinResourceInfo> mBuiltinResourceInfosByType;
 		bool mBaseTypesInitialized;
 
 		MonoClass* mSystemArrayClass;

Source/SBansheeEngine/Include/BsScriptAudioClip.h

@@ -23,6 +23,7 @@ namespace bs
 
 	private:
 		friend class ScriptResourceManager;
+		friend class BuiltinResourceTypes;
 
 		ScriptAudioClip(MonoObject* instance, const HAudioClip& audioClip);
 

Source/SBansheeEngine/Include/BsScriptEnginePrerequisites.h

@@ -188,4 +188,21 @@ namespace bs
 		MonoClass* monoClass;
 		std::function<ScriptComponentBase*(const HComponent&)> createCallback;
 	};
+
+	/**	Types of resources accessible from script code. */
+	enum class ScriptResourceType // Note: Must be the same as C# enum ResourceType
+	{
+		Texture, SpriteTexture, Mesh, Font, Shader, ShaderInclude, Material, Prefab,
+		PlainText, ScriptCode, StringTable, GUISkin, PhysicsMaterial, PhysicsMesh, AudioClip, AnimationClip, Undefined
+	};
+
+	/** Information about a builtin resource wrapped as a script object. */
+	struct BuiltinResourceInfo
+	{
+		const ScriptMeta* metaData;
+		UINT32 typeId;
+		MonoClass* monoClass;
+		ScriptResourceType resType;
+		std::function<ScriptResourceBase*(const HResource&, MonoObject*)> createCallback;
+	};
 }

Source/SBansheeEngine/Include/BsScriptFont.h

@@ -23,6 +23,7 @@ namespace bs
 		static MonoObject* createInstance();
 	private:
 		friend class ScriptResourceManager;
+		friend class BuiltinResourceTypes;
 
 		ScriptFont(MonoObject* instance, const HFont& font);
 

Source/SBansheeEngine/Include/BsScriptGUISkin.h

@@ -22,6 +22,7 @@ namespace bs
 
 	private:
 		friend class ScriptResourceManager;
+		friend class BuiltinResourceTypes;
 
 		ScriptGUISkin(MonoObject* instance, const HGUISkin& skin);
 

Source/SBansheeEngine/Include/BsScriptMaterial.h

@@ -29,6 +29,7 @@ namespace bs
 
 	private:
 		friend class ScriptResourceManager;
+		friend class BuiltinResourceTypes;
 
 		ScriptMaterial(MonoObject* instance, const HMaterial& material);
 

Source/SBansheeEngine/Include/BsScriptMesh.h

@@ -63,6 +63,7 @@ namespace bs
 
 	private:
 		friend class ScriptResourceManager;
+		friend class BuiltinResourceTypes;
 
 		ScriptMesh(MonoObject* instance, const HMesh& mesh);
 

Source/SBansheeEngine/Include/BsScriptPhysicsMaterial.h

@@ -23,6 +23,7 @@ namespace bs
 
 	private:
 		friend class ScriptResourceManager;
+		friend class BuiltinResourceTypes;
 
 		ScriptPhysicsMaterial(MonoObject* instance, const HPhysicsMaterial& material);
 

Source/SBansheeEngine/Include/BsScriptPhysicsMesh.h

@@ -23,6 +23,7 @@ namespace bs
 
 	private:
 		friend class ScriptResourceManager;
+		friend class BuiltinResourceTypes;
 
 		ScriptPhysicsMesh(MonoObject* instance, const HPhysicsMesh& mesh);
 

Source/SBansheeEngine/Include/BsScriptPlainText.h

@@ -24,6 +24,7 @@ namespace bs
 
 	private:
 		friend class ScriptResourceManager;
+		friend class BuiltinResourceTypes;
 
 		ScriptPlainText(MonoObject* instance, const HPlainText& plainText);
 

Source/SBansheeEngine/Include/BsScriptPrefab.h

@@ -23,6 +23,7 @@ namespace bs
 
 	private:
 		friend class ScriptResourceManager;
+		friend class BuiltinResourceTypes;
 
 		ScriptPrefab(MonoObject* instance, const HPrefab& prefab);
 

Source/SBansheeEngine/Include/BsScriptResource.h

@@ -12,13 +12,6 @@ namespace bs
 	 *  @{
 	 */
 
-	/**	Types of resources accessible from script code. */
-	enum class ScriptResourceType // Note: Must be the same as C# enum ResourceType
-	{
-		Texture, SpriteTexture, Mesh, Font, Shader, ShaderInclude, Material, Prefab, 
-		PlainText, ScriptCode, StringTable, GUISkin, PhysicsMaterial, PhysicsMesh, AudioClip, AnimationClip, Undefined
-	};
-
 	/**	Base class for all resource interop objects. */
 	class BS_SCR_BE_EXPORT ScriptResourceBase : public PersistentScriptObjectBase
 	{
@@ -120,14 +113,6 @@ namespace bs
 	public:
 		SCRIPT_OBJ(ENGINE_ASSEMBLY, "BansheeEngine", "Resource")
 
-		/**	Converts a RTTI id belonging to a resource type into a ScriptResourceType. */
-		static ScriptResourceType getTypeFromTypeId(UINT32 typeId);
-
-		/**	Converts a ScriptResourceType into a RTTI id belonging to that resource type. */
-		static UINT32 getTypeIdFromType(ScriptResourceType type);
-
-		/**	Converts a RTTI id belonging to a resource type into a managed class representing that type. */
-		static MonoClass* getClassFromTypeId(UINT32 typeId);
 	private:
 		ScriptResource(MonoObject* instance)
 			:ScriptObject(instance)

Source/SBansheeEngine/Include/BsScriptResourceManager.h

@@ -24,40 +24,39 @@ namespace bs
 		~ScriptResourceManager();
 
 		/**
-		 * Creates a new managed instance and interop object for the specified resource.
+		 * Creates a new interop object for the specified builtin resource.
 		 *
-		 * @param[in]	resourceHandle	Native resource to wrap in a managed instance.
-		 * @param[out]	out				Output interop object corresponding to the new managed instance.
+		 * @param[in]	resource			Native resource to link to the managed instance.
+		 * @param[in]	existingInstance	Existing managed instance. Caller must ensure the managed instance matches the
+		 *									native resource type. If not provided new object instance will be created
+		 *									internally.
+		 * @return							Interop object corresponding to the managed instance.
 		 *
 		 * @note	Throws an exception if a managed instance for the provided resource already exists.
 		 */
-		template<class RetType, class InType>
-		void createScriptResource(const ResourceHandle<InType>& resourceHandle, RetType** out);
+		ScriptResourceBase* createBuiltinScriptResource(const HResource& resource, MonoObject* existingInstance = nullptr);
 
 		/**
-		 * Creates a new interop object for the specified resource using an existing managed instance.
+		 * Creates a new interop object for the specified custom managed resource.
 		 *
-		 * @param[in]	existingInstance	Existing managed instance. Caller must ensure the managed instance matches the
-		 *									native resource type.
-		 * @param[in]	resourceHandle		Native resource to link to the managed instance.
-		 * @param[out]	out					Output interop object corresponding to the new managed instance.
+		 * @param[in]	resource			Native resource to link to the managed instance.
+		 * @param[in]	existingInstance	Existing managed instance of the resource.
+		 * @return							Interop object corresponding to the managed instance.
 		 *
 		 * @note	Throws an exception if a managed instance for the provided resource already exists.
 		 */
-		template<class RetType, class InType>
-		void createScriptResource(MonoObject* existingInstance, const ResourceHandle<InType>& resourceHandle, RetType** out);
+		ScriptManagedResource* createManagedScriptResource(const HManagedResource& resource, MonoObject* existingInstance);
 
 		/**
 		 * Attempts to find an existing interop object for the specified resource, and optionally creates a new one if one
 		 * cannot be found.
 		 * 
-		 * @param[in]	resourceHandle	Resource to search for.
-		 * @param[out]	out				Found or created interop object containing the resource.
+		 * @param[in]	resource		Resource to search for.
 		 * @param[in]	create			If a resource cannot be found new one will be created when this is true. If false
 		 *								and the resource doesn't exist it will be null.
+		 * @return						Found or created interop object containing the resource.
 		 */
-		template<class RetType, class InType>
-		void getScriptResource(const ResourceHandle<InType>& resourceHandle, RetType** out, bool create = false);
+		ScriptResourceBase* getScriptResource(const HResource& resource, bool create = false);
 
 		/**
 		 * Attempts to find a resource interop object for a resource with the specified UUID. Returns null if the object
@@ -82,33 +81,4 @@ namespace bs
 	};
 
 	/** @} */
-
-	/** @addtogroup Implementation 
-	 *  @{
-	 */
-
-	namespace Detail
-	{
-		/** Another layer of indirection for specialized ScriptResourceManager methods. */
-
-		template<class RetType, class InType>
-		void BS_SCR_BE_EXPORT ScriptResourceManager_createScriptResource(ScriptResourceManager* thisPtr,
-			const ResourceHandle<InType>& resourceHandle, RetType** out);
-
-		template<>
-		void BS_SCR_BE_EXPORT ScriptResourceManager_createScriptResource(ScriptResourceManager* thisPtr,
-			const ResourceHandle<StringTable>& resourceHandle, ScriptStringTable** out);
-
-		template<>
-		void BS_SCR_BE_EXPORT ScriptResourceManager_createScriptResource(ScriptResourceManager* thisPtr,
-			const HResource& resourceHandle, ScriptResourceBase** out);
-	}
-
-	/** @} */
-
-	template<class RetType, class InType>
-	void ScriptResourceManager::createScriptResource(const ResourceHandle<InType>& resourceHandle, RetType** out)
-	{
-		Detail::ScriptResourceManager_createScriptResource<RetType, InType>(this, resourceHandle, out);
-	}
 }

Source/SBansheeEngine/Include/BsScriptScriptCode.h

@@ -24,6 +24,7 @@ namespace bs
 
 	private:
 		friend class ScriptResourceManager;
+		friend class BuiltinResourceTypes;
 		typedef std::pair<WString, WString> FullTypeName;
 
 		ScriptScriptCode(MonoObject* instance, const HScriptCode& scriptCode);

Source/SBansheeEngine/Include/BsScriptShader.h

@@ -23,6 +23,7 @@ namespace bs
 
 	private:
 		friend class ScriptResourceManager;
+		friend class BuiltinResourceTypes;
 
 		ScriptShader(MonoObject* instance, const HShader& shader);
 

Source/SBansheeEngine/Include/BsScriptShaderInclude.h

@@ -23,6 +23,7 @@ namespace bs
 
 	private:
 		friend class ScriptResourceManager;
+		friend class BuiltinResourceTypes;
 
 		ScriptShaderInclude(MonoObject* instance, const HShaderInclude& shaderInclude);
 	};

Source/SBansheeEngine/Include/BsScriptSpriteTexture.h

@@ -26,6 +26,7 @@ namespace bs
 
 	private:
 		friend class ScriptResourceManager;
+		friend class BuiltinResourceTypes;
 
 		ScriptSpriteTexture(MonoObject* instance, const HSpriteTexture& texture);
 

Source/SBansheeEngine/Include/BsScriptStringTable.h

@@ -23,6 +23,7 @@ namespace bs
 
 	private:
 		friend class ScriptResourceManager;
+		friend class BuiltinResourceTypes;
 
 		ScriptStringTable(MonoObject* instance, const HStringTable& table);
 

Source/SBansheeEngine/Source/BsManagedResource.cpp

@@ -122,8 +122,7 @@ namespace bs
 		mManagedHandle = MonoUtil::newGCHandle(mManagedInstance);
 		mMyHandle = myHandle.getWeak();
 
-		ScriptManagedResource* scriptInstance;
-		ScriptResourceManager::instance().createScriptResource(object, myHandle, &scriptInstance);
+		ScriptManagedResource* scriptInstance = ScriptResourceManager::instance().createManagedScriptResource(myHandle, object);
 		ManagedResourceManager::instance().registerManagedResource(mMyHandle);
 	}
 

Source/SBansheeEngine/Source/BsManagedSerializableField.cpp

@@ -9,20 +9,6 @@
 #include "BsScriptGameObjectManager.h"
 #include "BsScriptSpriteTexture.h"
 #include "BsScriptManagedResource.h"
-#include "BsScriptPlainText.h"
-#include "BsScriptScriptCode.h"
-#include "BsScriptShader.h"
-#include "BsScriptShaderInclude.h"
-#include "BsScriptMaterial.h"
-#include "BsScriptMesh.h"
-#include "BsScriptPrefab.h"
-#include "BsScriptFont.h"
-#include "BsScriptStringTable.h"
-#include "BsScriptGUISkin.h"
-#include "BsScriptPhysicsMaterial.h"
-#include "BsScriptPhysicsMesh.h"
-#include "BsScriptAudioClip.h"
-#include "BsScriptAnimationClip.h"
 #include "BsScriptSceneObject.h"
 #include "BsScriptComponent.h"
 #include "BsScriptManagedComponent.h"
@@ -32,8 +18,6 @@
 #include "BsManagedSerializableDictionary.h"
 #include "BsScriptAssemblyManager.h"
 
-#include "BsScriptTexture.generated.h"
-
 namespace bs
 {
 	template<class T>
@@ -81,120 +65,6 @@ namespace bs
 		return create(typeInfo, nullptr, false);
 	}
 
-	template<class ResType, class ScriptType>
-	MonoObject* getScriptResource(const HResource& value)
-	{
-		ResourceHandle<ResType> castValue = static_resource_cast<ResType>(value);
-		if (castValue.isLoaded())
-		{
-			ScriptType* scriptResource;
-			ScriptResourceManager::instance().getScriptResource(castValue, &scriptResource, true);
-
-			return scriptResource->getManagedInstance();
-		}
-		else
-			return nullptr;
-	}
-
-	template<class ScriptType>
-	SPtr<ManagedSerializableFieldData> setScriptResource(MonoObject* value)
-	{
-		auto fieldData = bs_shared_ptr_new<ManagedSerializableFieldDataResourceRef>();
-
-		if (value != nullptr)
-		{
-			ScriptType* scriptResource = ScriptType::toNative(value);
-			fieldData->value = scriptResource->getHandle();
-		}
-
-		return fieldData;
-	}
-
-	template<>
-	SPtr<ManagedSerializableFieldData> setScriptResource<ScriptResourceBase>(MonoObject* value)
-	{
-		auto fieldData = bs_shared_ptr_new<ManagedSerializableFieldDataResourceRef>();
-
-		if (value != nullptr)
-		{
-			ScriptResourceBase* scriptResource = ScriptResource::toNative(value);
-			fieldData->value = scriptResource->getGenericHandle();
-		}
-
-		return fieldData;
-	}
-
-	struct ResourceFieldDataAccessors
-	{
-		std::function<MonoObject*(const HResource&)> getter;
-		std::function<SPtr<ManagedSerializableFieldData>(MonoObject*)> setter;
-	};
-
-	ResourceFieldDataAccessors* getResourceFieldLookup()
-	{
-		static ResourceFieldDataAccessors lookup[(int)ScriptReferenceType::Count];
-		static bool initialized = false;
-
-		if(!initialized)
-		{
-			lookup[(int)ScriptReferenceType::Resource] =
-				{ &getScriptResource<Resource, ScriptResourceBase>, &setScriptResource<ScriptResourceBase> };
-
-			lookup[(int)ScriptReferenceType::Texture] =
-				{ &getScriptResource<Texture, ScriptTexture>, &setScriptResource<ScriptTexture> };
-
-			lookup[(int)ScriptReferenceType::SpriteTexture] =
-				{ &getScriptResource<SpriteTexture, ScriptSpriteTexture>, &setScriptResource<ScriptSpriteTexture> };
-
-			lookup[(int)ScriptReferenceType::Shader] =
-				{ &getScriptResource<Shader, ScriptShader>, &setScriptResource<ScriptShader> };
-
-			lookup[(int)ScriptReferenceType::ShaderInclude] =
-				{ &getScriptResource<ShaderInclude, ScriptShaderInclude>, &setScriptResource<ScriptShaderInclude> };
-
-			lookup[(int)ScriptReferenceType::Material] =
-				{ &getScriptResource<Material, ScriptMaterial>, &setScriptResource<ScriptMaterial> };
-
-			lookup[(int)ScriptReferenceType::Mesh] =
-				{ &getScriptResource<Mesh, ScriptMesh>, &setScriptResource<ScriptMesh> };
-
-			lookup[(int)ScriptReferenceType::Prefab] =
-				{ &getScriptResource<Prefab, ScriptPrefab>, &setScriptResource<ScriptPrefab> };
-
-			lookup[(int)ScriptReferenceType::Font] =
-				{ &getScriptResource<Font, ScriptFont>, &setScriptResource<ScriptFont> };
-
-			lookup[(int)ScriptReferenceType::StringTable] =
-				{ &getScriptResource<StringTable, ScriptStringTable>, &setScriptResource<ScriptStringTable> };
-
-			lookup[(int)ScriptReferenceType::GUISkin] =
-				{ &getScriptResource<GUISkin, ScriptGUISkin>, &setScriptResource<ScriptGUISkin> };
-
-			lookup[(int)ScriptReferenceType::PhysicsMaterial] =
-				{ &getScriptResource<PhysicsMaterial, ScriptPhysicsMaterial>, &setScriptResource<ScriptPhysicsMaterial> };
-
-			lookup[(int)ScriptReferenceType::PhysicsMesh] =
-				{ &getScriptResource<PhysicsMesh, ScriptPhysicsMesh>, &setScriptResource<ScriptPhysicsMesh> };
-
-			lookup[(int)ScriptReferenceType::AudioClip] =
-				{ &getScriptResource<AudioClip, ScriptAudioClip>, &setScriptResource<ScriptAudioClip> };
-
-			lookup[(int)ScriptReferenceType::AnimationClip] =
-				{ &getScriptResource<AnimationClip, ScriptAnimationClip>, &setScriptResource<ScriptAnimationClip> };
-
-			lookup[(int)ScriptReferenceType::ManagedResource] =
-				{ &getScriptResource<ManagedResource, ScriptManagedResource>, &setScriptResource<ScriptManagedResource> };
-
-			lookup[(int)ScriptReferenceType::PlainText] =
-				{ &getScriptResource<PlainText, ScriptPlainText>, &setScriptResource<ScriptPlainText> };
-
-			lookup[(int)ScriptReferenceType::ScriptCode] =
-				{ &getScriptResource<ScriptCode, ScriptScriptCode>, &setScriptResource<ScriptScriptCode> };
-		}
-
-		return lookup;
-	}
-
 	SPtr<ManagedSerializableFieldData> ManagedSerializableFieldData::create(const SPtr<ManagedSerializableTypeInfo>& typeInfo, MonoObject* value, bool allowNull)
 	{
 		if(typeInfo->getTypeId() == TID_SerializableTypeInfoPrimitive)
@@ -361,9 +231,36 @@ namespace bs
 
 				return fieldData;
 			}
-			default:
-				// Must be a resource
-				return getResourceFieldLookup()[(int)refTypeInfo->mType].setter(value);
+			case ScriptReferenceType::ManagedResourceBase:
+			case ScriptReferenceType::ManagedResource:
+			{
+				auto fieldData = bs_shared_ptr_new<ManagedSerializableFieldDataResourceRef>();
+
+				if (value != nullptr)
+				{
+					ScriptResourceBase* scriptResource = ScriptManagedResource::toNative(value);
+					fieldData->value = scriptResource->getGenericHandle();
+				}
+
+				return fieldData;
+			}
+			case ScriptReferenceType::BuiltinResourceBase:
+			case ScriptReferenceType::BuiltinResource:
+			{
+				BuiltinResourceInfo* info = ScriptAssemblyManager::instance().getBuiltinResourceInfo(refTypeInfo->mRTIITypeId);
+				if (info == nullptr)
+					return nullptr;
+
+				auto fieldData = bs_shared_ptr_new<ManagedSerializableFieldDataResourceRef>();
+
+				if (value != nullptr)
+				{
+					ScriptResourceBase* scriptResource = ScriptResource::toNative(value);
+					fieldData->value = scriptResource->getGenericHandle();
+				}
+
+				return fieldData;
+			}
 			}
 		}
 		else if(typeInfo->getTypeId() == TID_SerializableTypeInfoObject)
@@ -599,7 +496,31 @@ namespace bs
 		{
 			auto refTypeInfo = std::static_pointer_cast<ManagedSerializableTypeInfoRef>(typeInfo);
 
-			return getResourceFieldLookup()[(int)refTypeInfo->mType].getter(value);
+			if (!value.isLoaded())
+				return nullptr;
+
+			if (refTypeInfo->mType == ScriptReferenceType::ManagedResourceBase ||
+				refTypeInfo->mType == ScriptReferenceType::ManagedResource)
+			{
+				ScriptResourceBase* scriptResource = ScriptResourceManager::instance().getScriptResource(value, false);
+				assert(scriptResource != nullptr);
+
+				return scriptResource->getManagedInstance();
+			}
+			else if (refTypeInfo->mType == ScriptReferenceType::BuiltinResourceBase ||
+					 refTypeInfo->mType == ScriptReferenceType::BuiltinResource)
+			{
+				ScriptResourceBase* scriptResource = ScriptResourceManager::instance().getScriptResource(value, true);
+
+				return scriptResource->getManagedInstance();
+			}
+
+			if (value.isLoaded())
+			{
+
+			}
+			else
+				return nullptr;
 		}
 
 		BS_EXCEPT(InvalidParametersException, "Requesting an invalid type in serializable field.");

Source/SBansheeEngine/Source/BsManagedSerializableObjectInfo.cpp

@@ -8,27 +8,10 @@
 #include "BsMonoManager.h"
 #include "BsMonoField.h"
 #include "BsMonoProperty.h"
-#include "BsScriptSpriteTexture.h"
 #include "BsScriptAssemblyManager.h"
-#include "BsScriptMaterial.h"
-#include "BsScriptMesh.h"
-#include "BsScriptFont.h"
-#include "BsScriptShader.h"
-#include "BsScriptShaderInclude.h"
-#include "BsScriptPlainText.h"
-#include "BsScriptScriptCode.h"
-#include "BsScriptStringTable.h"
-#include "BsScriptGUISkin.h"
-#include "BsScriptPhysicsMaterial.h"
-#include "BsScriptPhysicsMesh.h"
-#include "BsScriptAudioClip.h"
-#include "BsScriptAnimationClip.h"
-#include "BsScriptPrefab.h"
 #include "BsScriptManagedResource.h"
 #include <BsScriptStep.h>
 
-#include "BsScriptTexture.generated.h"
-
 namespace bs
 {
 	RTTITypeBase* ManagedSerializableAssemblyInfo::getRTTIStatic()
@@ -372,27 +355,13 @@ namespace bs
 	{
 		switch (mType)
 		{
-		case ScriptReferenceType::Resource:
-		case ScriptReferenceType::Texture:
-		case ScriptReferenceType::SpriteTexture:
-		case ScriptReferenceType::Shader:
-		case ScriptReferenceType::ShaderInclude:
-		case ScriptReferenceType::Material:
-		case ScriptReferenceType::Mesh:
-		case ScriptReferenceType::PlainText:
-		case ScriptReferenceType::ScriptCode:
-		case ScriptReferenceType::Prefab:
-		case ScriptReferenceType::Font:
-		case ScriptReferenceType::StringTable:
-		case ScriptReferenceType::GUISkin:
-		case ScriptReferenceType::PhysicsMaterial:
-		case ScriptReferenceType::PhysicsMesh:
-		case ScriptReferenceType::AudioClip:
-		case ScriptReferenceType::AnimationClip:
-		case ScriptReferenceType::SceneObject:
+		case ScriptReferenceType::BuiltinResourceBase:
+		case ScriptReferenceType::ManagedResourceBase:
+		case ScriptReferenceType::BuiltinResource:
 		case ScriptReferenceType::BuiltinComponentBase:
 		case ScriptReferenceType::ManagedComponentBase:
 		case ScriptReferenceType::BuiltinComponent:
+		case ScriptReferenceType::SceneObject:
 			return true;
 		default:
 			break;
@@ -405,40 +374,10 @@ namespace bs
 	{
 		switch (mType)
 		{
-		case ScriptReferenceType::Resource:
+		case ScriptReferenceType::BuiltinResourceBase:
 			return ScriptResource::getMetaData()->scriptClass->_getInternalClass();
-		case ScriptReferenceType::Texture:
-			return ScriptTexture::getMetaData()->scriptClass->_getInternalClass();
-		case ScriptReferenceType::SpriteTexture:
-			return ScriptSpriteTexture::getMetaData()->scriptClass->_getInternalClass();
-		case ScriptReferenceType::Shader:
-			return ScriptShader::getMetaData()->scriptClass->_getInternalClass();
-		case ScriptReferenceType::ShaderInclude:
-			return ScriptShaderInclude::getMetaData()->scriptClass->_getInternalClass();
-		case ScriptReferenceType::Material:
-			return ScriptMaterial::getMetaData()->scriptClass->_getInternalClass();
-		case ScriptReferenceType::Mesh:
-			return ScriptMesh::getMetaData()->scriptClass->_getInternalClass();
-		case ScriptReferenceType::PlainText:
-			return ScriptPlainText::getMetaData()->scriptClass->_getInternalClass();
-		case ScriptReferenceType::ScriptCode:
-			return ScriptScriptCode::getMetaData()->scriptClass->_getInternalClass();
-		case ScriptReferenceType::Prefab:
-			return ScriptPrefab::getMetaData()->scriptClass->_getInternalClass();
-		case ScriptReferenceType::Font:
-			return ScriptFont::getMetaData()->scriptClass->_getInternalClass();
-		case ScriptReferenceType::StringTable:
-			return ScriptStringTable::getMetaData()->scriptClass->_getInternalClass();
-		case ScriptReferenceType::GUISkin:
-			return ScriptGUISkin::getMetaData()->scriptClass->_getInternalClass();
-		case ScriptReferenceType::PhysicsMaterial:
-			return ScriptPhysicsMaterial::getMetaData()->scriptClass->_getInternalClass();
-		case ScriptReferenceType::PhysicsMesh:
-			return ScriptPhysicsMesh::getMetaData()->scriptClass->_getInternalClass();
-		case ScriptReferenceType::AudioClip:
-			return ScriptAudioClip::getMetaData()->scriptClass->_getInternalClass();
-		case ScriptReferenceType::AnimationClip:
-			return ScriptAnimationClip::getMetaData()->scriptClass->_getInternalClass();
+		case ScriptReferenceType::ManagedResourceBase:
+			return ScriptManagedResource::getMetaData()->scriptClass->_getInternalClass();
 		case ScriptReferenceType::SceneObject:
 			return ScriptAssemblyManager::instance().getSceneObjectClass()->_getInternalClass();
 		case ScriptReferenceType::BuiltinComponentBase:
@@ -449,7 +388,7 @@ namespace bs
 			break;
 		}
 
-		// Custom component or resource
+		// Specific component or resource (either builtin or custom)
 		SPtr<ManagedSerializableObjectInfo> objInfo;
 		if (!ScriptAssemblyManager::instance().getSerializableObjectInfo(mTypeNamespace, mTypeName, objInfo))
 			return nullptr;

Source/SBansheeEngine/Source/BsScriptAnimation.cpp

@@ -67,9 +67,7 @@ namespace bs
 
 	void ScriptAnimation::eventTriggered(const HAnimationClip& clip, const String& name)
 	{
-		ScriptAnimationClip* scriptClip = nullptr;
-		ScriptResourceManager::instance().getScriptResource(clip, &scriptClip, true);
-
+		ScriptResourceBase* scriptClip = ScriptResourceManager::instance().getScriptResource(clip, true);
 		MonoString* monoName = MonoUtil::stringToMono(name);
 
 		MonoUtil::invokeThunk(sOnEventTriggeredThunk, mManagedInstance, scriptClip->getManagedInstance(), monoName);
@@ -170,9 +168,7 @@ namespace bs
 		if (!clip.isLoaded())
 			return nullptr;
 
-		ScriptAnimationClip* scriptClip;
-		ScriptResourceManager::instance().getScriptResource(clip, &scriptClip, true);
-
+		ScriptResourceBase* scriptClip = ScriptResourceManager::instance().getScriptResource(clip, true);
 		return scriptClip->getManagedInstance();
 	}
 

Source/SBansheeEngine/Source/BsScriptAnimationClip.cpp

@@ -41,8 +41,7 @@ namespace bs
 	{
 		HAnimationClip clip = AnimationClip::create();
 
-		ScriptAnimationClip* scriptInstance;
-		ScriptResourceManager::instance().createScriptResource(instance, clip, &scriptInstance);
+		ScriptResourceBase* scriptInstance = ScriptResourceManager::instance().createBuiltinScriptResource(clip, instance);
 	}
 
 	MonoObject* ScriptAnimationClip::internal_GetAnimationCurves(ScriptAnimationClip* thisPtr)

Source/SBansheeEngine/Source/BsScriptAssemblyManager.cpp

@@ -12,25 +12,70 @@
 #include "BsScriptComponent.h"
 #include "BsScriptSpriteTexture.h"
 #include "BsScriptMaterial.h"
-#include "BsScriptMesh.h"
-#include "BsScriptFont.h"
-#include "BsScriptShader.h"
-#include "BsScriptShaderInclude.h"
+
+#include "BsBuiltinComponentLookup.generated.h"
+
+// Note: This resource registration code is only here because resource lookup auto-generation isn't yet hooked up
+#include "BsSpriteTexture.h"
+#include "BsMesh.h"
+#include "BsFont.h"
+#include "BsShader.h"
+#include "BsShaderInclude.h"
+#include "BsMaterial.h"
+#include "BsPrefab.h"
+#include "BsPlainText.h"
+#include "BsScriptCode.h"
+#include "BsStringTable.h"
+#include "BsGUISkin.h"
+#include "BsPhysicsMaterial.h"
+#include "BsPhysicsMesh.h"
+#include "BsAudioClip.h"
+#include "BsAnimationClip.h"
+
+#include "BsScriptTexture.generated.h"
+#include "BsScriptSpriteTexture.h"
 #include "BsScriptPlainText.h"
 #include "BsScriptScriptCode.h"
+#include "BsScriptShader.h"
+#include "BsScriptShaderInclude.h"
+#include "BsScriptMaterial.h"
+#include "BsScriptMesh.h"
+#include "BsScriptFont.h"
+#include "BsScriptPrefab.h"
 #include "BsScriptStringTable.h"
 #include "BsScriptGUISkin.h"
 #include "BsScriptPhysicsMaterial.h"
 #include "BsScriptPhysicsMesh.h"
 #include "BsScriptAudioClip.h"
-#include "BsScriptPrefab.h"
 #include "BsScriptAnimationClip.h"
+#include "BsBuiltinResourceLookup.h"
 
-#include "BsBuiltinComponentLookup.generated.h"
-#include "BsScriptTexture.generated.h"
 
 namespace bs
 {
+	LOOKUP_BEGIN
+		ADD_ENTRY(Texture, ScriptTexture, ScriptResourceType::Texture)
+		ADD_ENTRY(SpriteTexture, ScriptSpriteTexture, ScriptResourceType::SpriteTexture)
+		ADD_ENTRY(Mesh, ScriptMesh, ScriptResourceType::Mesh)
+		ADD_ENTRY(Font, ScriptFont, ScriptResourceType::Font)
+		ADD_ENTRY(Shader, ScriptShader, ScriptResourceType::Shader)
+		ADD_ENTRY(ShaderInclude, ScriptShaderInclude, ScriptResourceType::ShaderInclude)
+		ADD_ENTRY(Material, ScriptMaterial, ScriptResourceType::Material)
+		ADD_ENTRY(Prefab, ScriptPrefab, ScriptResourceType::Prefab)
+		ADD_ENTRY(PlainText, ScriptPlainText, ScriptResourceType::PlainText)
+		ADD_ENTRY(ScriptCode, ScriptScriptCode, ScriptResourceType::ScriptCode)
+		ADD_ENTRY(StringTable, ScriptStringTable, ScriptResourceType::StringTable)
+		ADD_ENTRY(GUISkin, ScriptGUISkin, ScriptResourceType::GUISkin)
+		ADD_ENTRY(PhysicsMaterial, ScriptPhysicsMaterial, ScriptResourceType::PhysicsMaterial)
+		ADD_ENTRY(PhysicsMesh, ScriptPhysicsMesh, ScriptResourceType::PhysicsMesh)
+		ADD_ENTRY(AudioClip, ScriptAudioClip, ScriptResourceType::AudioClip)
+		ADD_ENTRY(AnimationClip, ScriptAnimationClip, ScriptResourceType::AnimationClip)
+	LOOKUP_END
+
+#undef LOOKUP_BEGIN
+#undef ADD_ENTRY
+#undef LOOKUP_END
+
 	ScriptAssemblyManager::ScriptAssemblyManager()
 		: mBaseTypesInitialized(false), mSystemArrayClass(nullptr), mSystemGenericListClass(nullptr)
 		, mSystemGenericDictionaryClass(nullptr), mSystemTypeClass(nullptr), mComponentClass(nullptr)
@@ -62,6 +107,7 @@ namespace bs
 			initializeBaseTypes();
 
 		initializeBuiltinComponentInfos();
+		initializeBuiltinResourceInfos();
 
 		// Process all classes and fields
 		UINT32 mUniqueTypeId = 1;
@@ -75,15 +121,17 @@ namespace bs
 
 		mAssemblyInfos[assemblyName] = assemblyInfo;
 
+		MonoClass* resourceClass = ScriptResource::getMetaData()->scriptClass;
 		MonoClass* managedResourceClass = ScriptManagedResource::getMetaData()->scriptClass;
 
 		// Populate class data
 		const Vector<MonoClass*>& allClasses = curAssembly->getAllClasses();
 		for(auto& curClass : allClasses)
 		{
-			if ((curClass->isSubClassOf(mManagedComponentClass) || curClass->isSubClassOf(managedResourceClass) ||
-				curClass->hasAttribute(mSerializeObjectAttribute)) && curClass != mManagedComponentClass && 
-				curClass != managedResourceClass)
+			if ((curClass->isSubClassOf(mComponentClass) || curClass->isSubClassOf(resourceClass) ||
+				curClass->hasAttribute(mSerializeObjectAttribute)) && 
+				curClass != mComponentClass && curClass != resourceClass &&
+				curClass != mManagedComponentClass && curClass != managedResourceClass)
 			{
 				SPtr<ManagedSerializableTypeInfoObject> typeInfo = bs_shared_ptr_new<ManagedSerializableTypeInfoObject>();
 				typeInfo->mTypeNamespace = curClass->getNamespace();
@@ -324,46 +372,27 @@ namespace bs
 				SPtr<ManagedSerializableTypeInfoRef> typeInfo = bs_shared_ptr_new<ManagedSerializableTypeInfoRef>();
 				typeInfo->mTypeNamespace = monoClass->getNamespace();
 				typeInfo->mTypeName = monoClass->getTypeName();
+				typeInfo->mRTIITypeId = 0;
 
 				if(monoClass == ScriptResource::getMetaData()->scriptClass)
-					typeInfo->mType = ScriptReferenceType::Resource;
-				else if (monoClass->isSubClassOf(ScriptTexture::getMetaData()->scriptClass))
-					typeInfo->mType = ScriptReferenceType::Texture;
-				else if (monoClass->isSubClassOf(ScriptSpriteTexture::getMetaData()->scriptClass))
-					typeInfo->mType = ScriptReferenceType::SpriteTexture;
+					typeInfo->mType = ScriptReferenceType::BuiltinResourceBase;
+				else if (monoClass == ScriptManagedResource::getMetaData()->scriptClass)
+					typeInfo->mType = ScriptReferenceType::ManagedResourceBase;
 				else if (monoClass->isSubClassOf(ScriptManagedResource::getMetaData()->scriptClass))
 					typeInfo->mType = ScriptReferenceType::ManagedResource;
-				else if (monoClass->isSubClassOf(ScriptShader::getMetaData()->scriptClass))
-					typeInfo->mType = ScriptReferenceType::Shader;
-				else if (monoClass->isSubClassOf(ScriptShaderInclude::getMetaData()->scriptClass))
-					typeInfo->mType = ScriptReferenceType::ShaderInclude;
-				else if (monoClass->isSubClassOf(ScriptMaterial::getMetaData()->scriptClass))
-					typeInfo->mType = ScriptReferenceType::Material;
-				else if (monoClass->isSubClassOf(ScriptMesh::getMetaData()->scriptClass))
-					typeInfo->mType = ScriptReferenceType::Mesh;
-				else if (monoClass->isSubClassOf(ScriptPlainText::getMetaData()->scriptClass))
-					typeInfo->mType = ScriptReferenceType::PlainText;
-				else if (monoClass->isSubClassOf(ScriptScriptCode::getMetaData()->scriptClass))
-					typeInfo->mType = ScriptReferenceType::ScriptCode;
-				else if (monoClass->isSubClassOf(ScriptPrefab::getMetaData()->scriptClass))
-					typeInfo->mType = ScriptReferenceType::Prefab;
-				else if (monoClass->isSubClassOf(ScriptFont::getMetaData()->scriptClass))
-					typeInfo->mType = ScriptReferenceType::Font;
-				else if (monoClass->isSubClassOf(ScriptStringTable::getMetaData()->scriptClass))
-					typeInfo->mType = ScriptReferenceType::StringTable;
-				else if (monoClass->isSubClassOf(ScriptGUISkin::getMetaData()->scriptClass))
-					typeInfo->mType = ScriptReferenceType::GUISkin;
-				else if (monoClass->isSubClassOf(ScriptPhysicsMaterial::getMetaData()->scriptClass))
-					typeInfo->mType = ScriptReferenceType::PhysicsMaterial;
-				else if (monoClass->isSubClassOf(ScriptPhysicsMesh::getMetaData()->scriptClass))
-					typeInfo->mType = ScriptReferenceType::PhysicsMesh;
-				else if (monoClass->isSubClassOf(ScriptAudioClip::getMetaData()->scriptClass))
-					typeInfo->mType = ScriptReferenceType::AudioClip;
-				else if (monoClass->isSubClassOf(ScriptAnimationClip::getMetaData()->scriptClass))
-					typeInfo->mType = ScriptReferenceType::AnimationClip;
-				else
+				else if (monoClass->isSubClassOf(ScriptResource::getMetaData()->scriptClass))
 				{
-					assert(false && "Unrecognized resource type");
+					typeInfo->mType = ScriptReferenceType::BuiltinResource;
+
+					::MonoReflectionType* type = MonoUtil::getType(monoClass->_getInternalClass());
+					BuiltinResourceInfo* builtinInfo = getBuiltinResourceInfo(type);
+					if (builtinInfo == nullptr)
+					{
+						assert(false && "Unable to find information about a built-in resource. Did you update BuiltinResourceTypes list?");
+						return nullptr;
+					}
+
+					typeInfo->mRTIITypeId = builtinInfo->typeId;
 				}
 
 				return typeInfo;
@@ -624,6 +653,58 @@ namespace bs
 		return &(iterFind->second);
 	}
 
+	void ScriptAssemblyManager::initializeBuiltinResourceInfos()
+	{
+		mBuiltinResourceInfos.clear();
+		mBuiltinResourceInfosByTID.clear();
+		mBuiltinResourceInfosByType.clear();
+
+		Vector<BuiltinResourceInfo> allResourceInfos = BuiltinResourceTypes::getEntries();
+
+		for (auto& entry : allResourceInfos)
+		{
+			MonoAssembly* assembly = MonoManager::instance().getAssembly(entry.metaData->assembly);
+			if (assembly == nullptr)
+				continue;
+
+			BuiltinResourceInfo info = entry;
+			info.monoClass = assembly->getClass(entry.metaData->ns, entry.metaData->name);
+
+			::MonoReflectionType* type = MonoUtil::getType(info.monoClass->_getInternalClass());
+
+			mBuiltinResourceInfos[type] = info;
+			mBuiltinResourceInfosByTID[info.typeId] = info;
+			mBuiltinResourceInfosByType[(UINT32)info.resType] = info;
+		}
+	}
+
+	BuiltinResourceInfo* ScriptAssemblyManager::getBuiltinResourceInfo(::MonoReflectionType* type)
+	{
+		auto iterFind = mBuiltinResourceInfos.find(type);
+		if (iterFind == mBuiltinResourceInfos.end())
+			return nullptr;
+
+		return &(iterFind->second);
+	}
+
+	BuiltinResourceInfo* ScriptAssemblyManager::getBuiltinResourceInfo(UINT32 rttiTypeId)
+	{
+		auto iterFind = mBuiltinResourceInfosByTID.find(rttiTypeId);
+		if (iterFind == mBuiltinResourceInfosByTID.end())
+			return nullptr;
+
+		return &(iterFind->second);
+	}
+
+	BuiltinResourceInfo* ScriptAssemblyManager::getBuiltinResourceInfo(ScriptResourceType type)
+	{
+		auto iterFind = mBuiltinResourceInfosByType.find((UINT32)type);
+		if (iterFind == mBuiltinResourceInfosByType.end())
+			return nullptr;
+
+		return &(iterFind->second);
+	}
+
 	bool ScriptAssemblyManager::getSerializableObjectInfo(const String& ns, const String& typeName, SPtr<ManagedSerializableObjectInfo>& outInfo)
 	{
 		String fullName = ns + "." + typeName;

Source/SBansheeEngine/Source/BsScriptBuiltin.cpp

@@ -30,9 +30,7 @@ namespace bs
 	{
 		HSpriteTexture whiteTexture = BuiltinResources::instance().getWhiteSpriteTexture();
 
-		ScriptSpriteTexture* scriptSpriteTex;
-		ScriptResourceManager::instance().getScriptResource(whiteTexture, &scriptSpriteTex, true);
-
+		ScriptResourceBase* scriptSpriteTex = ScriptResourceManager::instance().getScriptResource(whiteTexture, true);
 		return scriptSpriteTex->getManagedInstance();
 	}
 
@@ -40,9 +38,7 @@ namespace bs
 	{
 		HShader diffuseShader = BuiltinResources::instance().getBuiltinShader(type);
 
-		ScriptShader* scriptShader;
-		ScriptResourceManager::instance().getScriptResource(diffuseShader, &scriptShader, true);
-
+		ScriptResourceBase* scriptShader = ScriptResourceManager::instance().getScriptResource(diffuseShader, true);
 		return scriptShader->getManagedInstance();
 	}
 
@@ -50,9 +46,7 @@ namespace bs
 	{
 		HMesh mesh = BuiltinResources::instance().getMesh(meshType);
 
-		ScriptMesh* scriptMesh;
-		ScriptResourceManager::instance().getScriptResource(mesh, &scriptMesh, true);
-
+		ScriptResourceBase* scriptMesh = ScriptResourceManager::instance().getScriptResource(mesh, true);
 		return scriptMesh->getManagedInstance();
 	}
 
@@ -60,9 +54,7 @@ namespace bs
 	{
 		HFont font = BuiltinResources::instance().getDefaultFont();
 
-		ScriptFont* scriptFont;
-		ScriptResourceManager::instance().getScriptResource(font, &scriptFont, true);
-
+		ScriptResourceBase* scriptFont = ScriptResourceManager::instance().getScriptResource(font, true);
 		return scriptFont->getManagedInstance();
 	}
 }

Source/SBansheeEngine/Source/BsScriptCollider.cpp

@@ -176,9 +176,7 @@ namespace bs
 		if (material == nullptr)
 			return nullptr;
 
-		ScriptPhysicsMaterial* scriptMaterial;
-		ScriptResourceManager::instance().getScriptResource(material, &scriptMaterial, true);
-
+		ScriptResourceBase* scriptMaterial = ScriptResourceManager::instance().getScriptResource(material, true);
 		return scriptMaterial->getManagedInstance();
 	}
 

Source/SBansheeEngine/Source/BsScriptFontBitmap.cpp

@@ -91,9 +91,7 @@ namespace bs
 		ScriptArray output = ScriptArray::create<ScriptTexture>(numPages);
 		for (UINT32 i = 0; i < numPages; i++)
 		{
-			ScriptTexture* scriptTexture = nullptr;
-			ScriptResourceManager::instance().getScriptResource(texturePages[i], &scriptTexture, true);
-
+			ScriptResourceBase* scriptTexture = ScriptResourceManager::instance().getScriptResource(texturePages[i], true);
 			output.set(i, scriptTexture->getManagedInstance());
 		}
 

Source/SBansheeEngine/Source/BsScriptGUIContentImages.cpp

@@ -99,9 +99,7 @@ namespace bs
 			MonoObject* managedImage = nullptr;
 			if (entry.image != nullptr)
 			{
-				ScriptSpriteTexture* scriptImage;
-				ScriptResourceManager::instance().getScriptResource(entry.image, &scriptImage, true);
-
+				ScriptResourceBase* scriptImage = ScriptResourceManager::instance().getScriptResource(entry.image, true);
 				managedImage = scriptImage->getManagedInstance();
 			}
 

Source/SBansheeEngine/Source/BsScriptGUIElementStateStyle.cpp

@@ -25,10 +25,10 @@ namespace bs
 
 	ScriptGUIElementStateStyleStruct ScriptGUIElementStateStyle::toManaged(const GUIElementStyle::GUIElementStateStyle& state)
 	{
-		ScriptSpriteTexture* scriptTexture = nullptr;
+		ScriptResourceBase* scriptTexture = nullptr;
 
 		if (state.texture != nullptr)
-			ScriptResourceManager::instance().getScriptResource(state.texture, &scriptTexture, true);
+			scriptTexture = ScriptResourceManager::instance().getScriptResource(state.texture, true);
 
 		ScriptGUIElementStateStyleStruct output;
 		output.texture = scriptTexture != nullptr ? scriptTexture->getManagedInstance() : nullptr;

Source/SBansheeEngine/Source/BsScriptGUIElementStyle.cpp

@@ -124,9 +124,7 @@ namespace bs
 		const GUIElementStyle& style = nativeInstance->mElementStyle;
 		if (style.font != nullptr)
 		{
-			ScriptFont* scriptFont;
-			ScriptResourceManager::instance().getScriptResource(style.font, &scriptFont, true);
-
+			ScriptResourceBase* scriptFont = ScriptResourceManager::instance().getScriptResource(style.font, true);
 			*value = scriptFont->getManagedInstance();
 		}
 		else

Source/SBansheeEngine/Source/BsScriptGUISkin.cpp

@@ -32,8 +32,7 @@ namespace bs
 	{
 		HGUISkin skin = GUISkin::create();
 
-		ScriptGUISkin* scriptInstance;
-		ScriptResourceManager::instance().createScriptResource(instance, skin, &scriptInstance);
+		ScriptResourceBase* scriptInstance = ScriptResourceManager::instance().createBuiltinScriptResource(skin, instance);
 	}
 
 	bool ScriptGUISkin::internal_HasStyle(ScriptGUISkin* thisPtr, MonoString* name)

Source/SBansheeEngine/Source/BsScriptMaterial.cpp

@@ -57,18 +57,14 @@ namespace bs
 			nativeShader = BuiltinResources::instance().getBuiltinShader(BuiltinShader::Standard);
 
 		HMaterial material = Material::create(nativeShader);
-
-		ScriptMaterial* scriptInstance;
-		ScriptResourceManager::instance().createScriptResource(instance, material, &scriptInstance);
+		ScriptResourceBase* scriptInstance = ScriptResourceManager::instance().createBuiltinScriptResource(material, instance);
 	}
 
 	MonoObject* ScriptMaterial::internal_Clone(ScriptMaterial* nativeInstance)
 	{
 		HMaterial clone = nativeInstance->getHandle()->clone();
 
-		ScriptMaterial* scriptClone;
-		ScriptResourceManager::instance().createScriptResource(clone, &scriptClone);
-
+		ScriptResourceBase* scriptClone = ScriptResourceManager::instance().createBuiltinScriptResource(clone);
 		return scriptClone->getManagedInstance();
 	}
 
@@ -79,9 +75,7 @@ namespace bs
 		if (shader == nullptr)
 			return nullptr;
 
-		ScriptShader* scriptShader;
-		ScriptResourceManager::instance().getScriptResource(shader, &scriptShader, true);
-
+		ScriptResourceBase* scriptShader = ScriptResourceManager::instance().getScriptResource(shader, true);
 		return scriptShader->getManagedInstance();
 	}
 
@@ -215,9 +209,7 @@ namespace bs
 		if (texture == nullptr)
 			return nullptr;
 
-		ScriptTexture* scriptTexture;
-		ScriptResourceManager::instance().getScriptResource(texture, &scriptTexture, true);
-
+		ScriptResourceBase* scriptTexture = ScriptResourceManager::instance().getScriptResource(texture, true);
 		return scriptTexture->getManagedInstance();
 	}
 

Source/SBansheeEngine/Source/BsScriptMesh.cpp

@@ -66,9 +66,7 @@ namespace bs
 		desc.indexType = indexType;
 
 		HMesh mesh = Mesh::create(desc);
-
-		ScriptMesh* scriptInstance;
-		ScriptResourceManager::instance().createScriptResource(instance, mesh, &scriptInstance);
+		ScriptResourceBase* scriptInstance = ScriptResourceManager::instance().createBuiltinScriptResource(mesh, instance);
 	}
 
 	void ScriptMesh::internal_CreateInstanceMeshData(MonoObject* instance, ScriptMeshData* data, MonoArray* subMeshes,
@@ -83,9 +81,7 @@ namespace bs
 		desc.usage = usage;
 
 		HMesh mesh = Mesh::create(meshData, desc);
-
-		ScriptMesh* scriptInstance;
-		ScriptResourceManager::instance().createScriptResource(instance, mesh, &scriptInstance);
+		ScriptResourceBase* scriptInstance = ScriptResourceManager::instance().createBuiltinScriptResource(mesh, instance);
 	}
 
 	MonoArray* ScriptMesh::internal_GetSubMeshes(ScriptMesh* thisPtr)

Source/SBansheeEngine/Source/BsScriptMeshCollider.cpp

@@ -48,9 +48,7 @@ namespace bs
 		if (mesh == nullptr)
 			return nullptr;
 
-		ScriptPhysicsMesh* scriptMesh;
-		ScriptResourceManager::instance().getScriptResource(mesh, &scriptMesh, true);
-
+		ScriptResourceBase* scriptMesh = ScriptResourceManager::instance().getScriptResource(mesh, true);
 		return scriptMesh->getManagedInstance();
 	}
 }

Source/SBansheeEngine/Source/BsScriptPhysicsMaterial.cpp

@@ -29,9 +29,7 @@ namespace bs
 		float dynamicFriction, float restitution)
 	{
 		HPhysicsMaterial material = PhysicsMaterial::create(staticFriction, dynamicFriction, restitution);
-
-		ScriptPhysicsMaterial* scriptInstance;
-		ScriptResourceManager::instance().createScriptResource(instance, material, &scriptInstance);
+		ScriptResourceBase* scriptInstance = ScriptResourceManager::instance().createBuiltinScriptResource(material, instance);
 	}
 
 	float ScriptPhysicsMaterial::internal_GetStaticFriction(ScriptPhysicsMaterial* thisPtr)

Source/SBansheeEngine/Source/BsScriptPlainText.cpp

@@ -31,8 +31,7 @@ namespace bs
 		WString strText = MonoUtil::monoToWString(text);
 		HPlainText plainText = PlainText::create(strText);
 
-		ScriptPlainText* scriptInstance;
-		ScriptResourceManager::instance().createScriptResource(instance, plainText, &scriptInstance);
+		ScriptResourceBase* scriptInstance = ScriptResourceManager::instance().createBuiltinScriptResource(plainText, instance);
 	}
 
 	MonoString* ScriptPlainText::internal_getText(ScriptPlainText* thisPtr)

Source/SBansheeEngine/Source/BsScriptPrefab.cpp

@@ -25,9 +25,7 @@ namespace bs
 	void ScriptPrefab::internal_CreateInstance(MonoObject* instance, ScriptSceneObject* so, bool isScene)
 	{
 		HPrefab prefab = Prefab::create(so->getNativeSceneObject(), isScene);
-
-		ScriptPrefab* scriptInstance;
-		ScriptResourceManager::instance().createScriptResource(instance, prefab, &scriptInstance);
+		ScriptResourceBase* scriptInstance = ScriptResourceManager::instance().createBuiltinScriptResource(prefab, instance);
 	}
 
 	MonoObject* ScriptPrefab::internal_Instantiate(ScriptPrefab* thisPtr)

Source/SBansheeEngine/Source/BsScriptRenderTexture2D.cpp

@@ -111,9 +111,7 @@ namespace bs
 
 			if (colorTex != nullptr)
 			{
-				ScriptTexture* scriptSurface;
-				ScriptResourceManager::instance().getScriptResource(colorTex, &scriptSurface, true);
-
+				ScriptResourceBase* scriptSurface = ScriptResourceManager::instance().getScriptResource(colorTex, true);
 				outArray.set<MonoObject*>(i, scriptSurface->getManagedInstance());
 			}
 			else
@@ -128,9 +126,7 @@ namespace bs
 		SPtr<RenderTexture> tex = thisPtr->getRenderTexture();
 		HTexture depthTex = tex->getDepthStencilTexture();
 
-		ScriptTexture* scriptSurface;
-		ScriptResourceManager::instance().getScriptResource(depthTex, &scriptSurface, true);
-
+		ScriptResourceBase* scriptSurface = ScriptResourceManager::instance().getScriptResource(depthTex, true);
 		*value = scriptSurface->getManagedInstance();
 	}
 }

Source/SBansheeEngine/Source/BsScriptResource.cpp

@@ -4,23 +4,6 @@
 #include "BsScriptResourceManager.h"
 #include "BsResource.h"
 #include "BsMonoUtil.h"
-#include "BsScriptSpriteTexture.h"
-#include "BsScriptMaterial.h"
-#include "BsScriptMesh.h"
-#include "BsScriptFont.h"
-#include "BsScriptShader.h"
-#include "BsScriptShaderInclude.h"
-#include "BsScriptPlainText.h"
-#include "BsScriptScriptCode.h"
-#include "BsScriptStringTable.h"
-#include "BsScriptGUISkin.h"
-#include "BsScriptPhysicsMesh.h"
-#include "BsScriptPhysicsMaterial.h"
-#include "BsScriptAudioClip.h"
-#include "BsScriptPrefab.h"
-#include "BsScriptAnimationClip.h"
-
-#include "BsScriptTexture.generated.h"
 
 namespace bs
 {
@@ -57,131 +40,6 @@ namespace bs
 		metaData.scriptClass->addInternalCall("Internal_Release", &ScriptResource::internal_release);
 	}
 
-	MonoClass* ScriptResource::getClassFromTypeId(UINT32 typeId)
-	{
-		switch (typeId)
-		{
-		case TID_Texture:
-			return ScriptTexture::getMetaData()->scriptClass;
-		case TID_SpriteTexture:
-			return ScriptSpriteTexture::getMetaData()->scriptClass;
-		case TID_Font:
-			return ScriptFont::getMetaData()->scriptClass;
-		case TID_PlainText:
-			return ScriptPlainText::getMetaData()->scriptClass;
-		case TID_ScriptCode:
-			return ScriptScriptCode::getMetaData()->scriptClass;
-		case TID_Shader:
-			return ScriptShader::getMetaData()->scriptClass;
-		case TID_ShaderInclude:
-			return ScriptShaderInclude::getMetaData()->scriptClass;
-		case TID_Material:
-			return ScriptMaterial::getMetaData()->scriptClass;
-		case TID_Mesh:
-			return ScriptMesh::getMetaData()->scriptClass;
-		case TID_Prefab:
-			return ScriptPrefab::getMetaData()->scriptClass;
-		case TID_StringTable:
-			return ScriptStringTable::getMetaData()->scriptClass;
-		case TID_GUISkin:
-			return ScriptGUISkin::getMetaData()->scriptClass;
-		case TID_PhysicsMaterial:
-			return ScriptPhysicsMaterial::getMetaData()->scriptClass;
-		case TID_PhysicsMesh:
-			return ScriptPhysicsMesh::getMetaData()->scriptClass;
-		case TID_AudioClip:
-			return ScriptAudioClip::getMetaData()->scriptClass;
-		case TID_AnimationClip:
-			return ScriptAnimationClip::getMetaData()->scriptClass;
-		}
-
-		return nullptr;
-	}
-
-	ScriptResourceType ScriptResource::getTypeFromTypeId(UINT32 typeId)
-	{
-		switch (typeId)
-		{
-		case TID_Texture:
-			return ScriptResourceType::Texture;
-		case TID_SpriteTexture:
-			return ScriptResourceType::SpriteTexture;
-		case TID_Mesh:
-			return ScriptResourceType::Mesh;
-		case TID_Shader:
-			return ScriptResourceType::Shader;
-		case TID_ShaderInclude:
-			return ScriptResourceType::ShaderInclude;
-		case TID_Material:
-			return ScriptResourceType::Material;
-		case TID_Font:
-			return ScriptResourceType::Font;
-		case TID_Prefab:
-			return ScriptResourceType::Prefab;
-		case TID_StringTable:
-			return ScriptResourceType::StringTable;
-		case TID_PlainText:
-			return ScriptResourceType::PlainText;
-		case TID_ScriptCode:
-			return ScriptResourceType::ScriptCode;
-		case TID_GUISkin:
-			return ScriptResourceType::GUISkin;
-		case TID_PhysicsMaterial:
-			return ScriptResourceType::PhysicsMaterial;
-		case TID_PhysicsMesh:
-			return ScriptResourceType::PhysicsMesh;
-		case TID_AudioClip:
-			return ScriptResourceType::AudioClip;
-		case TID_AnimationClip:
-			return ScriptResourceType::AnimationClip;
-		}
-
-		return ScriptResourceType::Undefined;
-	}
-
-	UINT32 ScriptResource::getTypeIdFromType(ScriptResourceType type)
-	{
-		switch (type)
-		{
-		case ScriptResourceType::Texture:
-			return TID_Texture;
-		case ScriptResourceType::SpriteTexture:
-			return TID_SpriteTexture;
-		case ScriptResourceType::Mesh:
-			return TID_Mesh;
-		case ScriptResourceType::Shader:
-			return TID_Shader;
-		case ScriptResourceType::ShaderInclude:
-			return TID_ShaderInclude;
-		case ScriptResourceType::Font:
-			return TID_Font;
-		case ScriptResourceType::Material:
-			return TID_Material;
-		case ScriptResourceType::Prefab:
-			return TID_Prefab;
-		case ScriptResourceType::StringTable:
-			return TID_StringTable;
-		case ScriptResourceType::PlainText:
-			return TID_PlainText;
-		case ScriptResourceType::ScriptCode:
-			return TID_ScriptCode;
-		case ScriptResourceType::GUISkin:
-			return TID_GUISkin;
-		case ScriptResourceType::PhysicsMaterial:
-			return TID_PhysicsMaterial;
-		case ScriptResourceType::PhysicsMesh:
-			return TID_PhysicsMesh;
-		case ScriptResourceType::AudioClip:
-			return TID_AudioClip;
-		case ScriptResourceType::AnimationClip:
-			return TID_AnimationClip;
-		default:
-			break;
-		}
-
-		return 0;
-	}
-
 	MonoString* ScriptResource::internal_getName(ScriptResourceBase* nativeInstance)
 	{
 		return MonoUtil::wstringToMono(nativeInstance->getGenericHandle()->getName());

Source/SBansheeEngine/Source/BsScriptResourceManager.cpp

@@ -5,26 +5,11 @@
 #include "BsMonoAssembly.h"
 #include "BsMonoClass.h"
 #include "BsResources.h"
-#include "BsScriptSpriteTexture.h"
-#include "BsScriptPlainText.h"
-#include "BsScriptScriptCode.h"
-#include "BsScriptShader.h"
-#include "BsScriptShaderInclude.h"
-#include "BsScriptMaterial.h"
-#include "BsScriptMesh.h"
-#include "BsScriptFont.h"
-#include "BsScriptPrefab.h"
-#include "BsScriptStringTable.h"
-#include "BsScriptGUISkin.h"
-#include "BsScriptPhysicsMaterial.h"
-#include "BsScriptPhysicsMesh.h"
-#include "BsScriptAudioClip.h"
-#include "BsScriptAnimationClip.h"
+#include "BsRTTIType.h"
+#include "BsResource.h"
 #include "BsScriptManagedResource.h"
 #include "BsScriptAssemblyManager.h"
 
-#include "BsScriptTexture.generated.h"
-
 using namespace std::placeholders;
 
 namespace bs
@@ -39,165 +24,53 @@ namespace bs
 		mResourceDestroyedConn.disconnect();
 	}
 
-	template<class RetType, class InType>
-	void ScriptResourceManager::createScriptResource(MonoObject* instance, const ResourceHandle<InType>& resourceHandle, RetType** out)
+	ScriptManagedResource* ScriptResourceManager::createManagedScriptResource(const HManagedResource& resource, MonoObject* instance)
 	{
-		const String& uuid = resourceHandle.getUUID();
+		const String& uuid = resource.getUUID();
 #if BS_DEBUG_MODE
 		_throwExceptionIfInvalidOrDuplicate(uuid);
 #endif
 
-		RetType* scriptResource = new (bs_alloc<RetType>()) RetType(instance, resourceHandle);
+		ScriptManagedResource* scriptResource = new (bs_alloc<ScriptManagedResource>()) ScriptManagedResource(instance, resource);
 		mScriptResources[uuid] = scriptResource;
 
-		*out = scriptResource;
+		return scriptResource;
 	}
 
-	template<class RetType, class InType>
-	void ScriptResourceManager::getScriptResource(const ResourceHandle<InType>& resourceHandle, RetType** out, bool create)
+	ScriptResourceBase* ScriptResourceManager::createBuiltinScriptResource(const HResource& resource, MonoObject* instance)
 	{
-		String uuid = resourceHandle.getUUID();
-
-		if (!uuid.empty())
-		{
-			*out = static_cast<RetType*>(getScriptResource(uuid));
+		const String& uuid = resource.getUUID();
+#if BS_DEBUG_MODE
+		_throwExceptionIfInvalidOrDuplicate(uuid);
+#endif
 
-			if (*out == nullptr && create)
-				createScriptResource(resourceHandle, out);
-		}
-		else
-			*out = nullptr;
-	}
+		UINT32 rttiId = resource->getRTTI()->getRTTIId();
+		BuiltinResourceInfo* info = ScriptAssemblyManager::instance().getBuiltinResourceInfo(rttiId);
 
-	namespace Detail
-	{
-		template<class RetType, class InType>
-		void ScriptResourceManager_createScriptResource(ScriptResourceManager* thisPtr, const ResourceHandle<InType>& resourceHandle, RetType** out)
-		{
-			MonoObject* monoInstance = RetType::createInstance();
+		if (info == nullptr)
+			return nullptr;
 
-			thisPtr->createScriptResource(monoInstance, resourceHandle, out);
-		}
+		ScriptResourceBase* scriptResource = info->createCallback(resource, instance);
+		mScriptResources[uuid] = scriptResource;
 
-		template<>
-		void ScriptResourceManager_createScriptResource(ScriptResourceManager* thisPtr, const ResourceHandle<StringTable>& resourceHandle, ScriptStringTable** out)
-		{
-			MonoClass* resourceClass = ScriptStringTable::getMetaData()->scriptClass;
+		return scriptResource;
+	}
 
-			bool dummy = true;
-			void* params = { &dummy };
+	ScriptResourceBase* ScriptResourceManager::getScriptResource(const HResource& resource, bool create)
+	{
+		String uuid = resource.getUUID();
 
-			MonoObject* monoInstance = resourceClass->createInstance(&params, 1);
-			thisPtr->createScriptResource(monoInstance, resourceHandle, out);
-		}
+		if (uuid.empty())
+			return nullptr;
 
-		template<>
-		void ScriptResourceManager_createScriptResource(ScriptResourceManager* thisPtr, const HResource& resourceHandle, ScriptResourceBase** out)
-		{
-#if BS_DEBUG_MODE
-			thisPtr->_throwExceptionIfInvalidOrDuplicate(resourceHandle.getUUID());
-#endif
+		ScriptResourceBase* output = getScriptResource(uuid);
 
-			UINT32 resTypeID = resourceHandle->getTypeId();
-
-			switch (resTypeID)
-			{
-			case TID_Texture:
-				return ScriptResourceManager_createScriptResource(thisPtr, static_resource_cast<Texture>(resourceHandle), (ScriptTexture**)out);
-			case TID_SpriteTexture:
-				return ScriptResourceManager_createScriptResource(thisPtr, static_resource_cast<SpriteTexture>(resourceHandle), (ScriptSpriteTexture**)out);
-			case TID_Font:
-				return ScriptResourceManager_createScriptResource(thisPtr, static_resource_cast<Font>(resourceHandle), (ScriptFont**)out);
-			case TID_PlainText:
-				return ScriptResourceManager_createScriptResource(thisPtr, static_resource_cast<PlainText>(resourceHandle), (ScriptPlainText**)out);
-			case TID_ScriptCode:
-				return ScriptResourceManager_createScriptResource(thisPtr, static_resource_cast<ScriptCode>(resourceHandle), (ScriptScriptCode**)out);
-			case TID_Shader:
-				return ScriptResourceManager_createScriptResource(thisPtr, static_resource_cast<Shader>(resourceHandle), (ScriptShader**)out);
-			case TID_ShaderInclude:
-				return ScriptResourceManager_createScriptResource(thisPtr, static_resource_cast<ShaderInclude>(resourceHandle), (ScriptShaderInclude**)out);
-			case TID_Prefab:
-				return ScriptResourceManager_createScriptResource(thisPtr, static_resource_cast<Prefab>(resourceHandle), (ScriptPrefab**)out);
-			case TID_StringTable:
-				return ScriptResourceManager_createScriptResource(thisPtr, static_resource_cast<StringTable>(resourceHandle), (ScriptStringTable**)out);
-			case TID_Material:
-				return ScriptResourceManager_createScriptResource(thisPtr, static_resource_cast<Material>(resourceHandle), (ScriptMaterial**)out);
-			case TID_Mesh:
-				return ScriptResourceManager_createScriptResource(thisPtr, static_resource_cast<Mesh>(resourceHandle), (ScriptMesh**)out);
-			case TID_GUISkin:
-				return ScriptResourceManager_createScriptResource(thisPtr, static_resource_cast<GUISkin>(resourceHandle), (ScriptGUISkin**)out);
-			case TID_PhysicsMaterial:
-				return ScriptResourceManager_createScriptResource(thisPtr, static_resource_cast<PhysicsMaterial>(resourceHandle), (ScriptPhysicsMaterial**)out);
-			case TID_PhysicsMesh:
-				return ScriptResourceManager_createScriptResource(thisPtr, static_resource_cast<PhysicsMesh>(resourceHandle), (ScriptPhysicsMesh**)out);
-			case TID_AudioClip:
-				return ScriptResourceManager_createScriptResource(thisPtr, static_resource_cast<AudioClip>(resourceHandle), (ScriptAudioClip**)out);
-			case TID_AnimationClip:
-				return ScriptResourceManager_createScriptResource(thisPtr, static_resource_cast<AnimationClip>(resourceHandle), (ScriptAnimationClip**)out);
-			case TID_ManagedResource:
-				BS_EXCEPT(InternalErrorException, "Managed resources must have a managed instance by default, this call is invalid.")
-					break;
-			default:
-				BS_EXCEPT(NotImplementedException, "Attempting to load a resource type that is not supported. Type ID: " + toString(resTypeID));
-				break;
-			}
-		}
+		if (output == nullptr && create)
+			return createBuiltinScriptResource(resource);
 
-		template void ScriptResourceManager_createScriptResource(ScriptResourceManager* thisPtr, const ResourceHandle<Texture>&, ScriptTexture**);
-		template void ScriptResourceManager_createScriptResource(ScriptResourceManager* thisPtr, const ResourceHandle<SpriteTexture>&, ScriptSpriteTexture**);
-		template void ScriptResourceManager_createScriptResource(ScriptResourceManager* thisPtr, const ResourceHandle<Mesh>&, ScriptMesh**);
-		template void ScriptResourceManager_createScriptResource(ScriptResourceManager* thisPtr, const ResourceHandle<Material>&, ScriptMaterial**);
-		template void ScriptResourceManager_createScriptResource(ScriptResourceManager* thisPtr, const ResourceHandle<Shader>&, ScriptShader**);
-		template void ScriptResourceManager_createScriptResource(ScriptResourceManager* thisPtr, const ResourceHandle<ShaderInclude>&, ScriptShaderInclude**);
-		template void ScriptResourceManager_createScriptResource(ScriptResourceManager* thisPtr, const ResourceHandle<Prefab>&, ScriptPrefab**);
-		template void ScriptResourceManager_createScriptResource(ScriptResourceManager* thisPtr, const ResourceHandle<Font>&, ScriptFont**);
-		template void ScriptResourceManager_createScriptResource(ScriptResourceManager* thisPtr, const ResourceHandle<PlainText>&, ScriptPlainText**);
-		template void ScriptResourceManager_createScriptResource(ScriptResourceManager* thisPtr, const ResourceHandle<ScriptCode>&, ScriptScriptCode**);
-		template void ScriptResourceManager_createScriptResource(ScriptResourceManager* thisPtr, const ResourceHandle<StringTable>&, ScriptStringTable**);
-		template void ScriptResourceManager_createScriptResource(ScriptResourceManager* thisPtr, const ResourceHandle<GUISkin>&, ScriptGUISkin**);
-		template void ScriptResourceManager_createScriptResource(ScriptResourceManager* thisPtr, const ResourceHandle<PhysicsMesh>&, ScriptPhysicsMesh**);
-		template void ScriptResourceManager_createScriptResource(ScriptResourceManager* thisPtr, const ResourceHandle<PhysicsMaterial>&, ScriptPhysicsMaterial**);
-		template void ScriptResourceManager_createScriptResource(ScriptResourceManager* thisPtr, const ResourceHandle<AudioClip>&, ScriptAudioClip**);
-		template void ScriptResourceManager_createScriptResource(ScriptResourceManager* thisPtr, const ResourceHandle<AnimationClip>&, ScriptAnimationClip**);
+		return output;
 	}
 
-	template BS_SCR_BE_EXPORT void ScriptResourceManager::createScriptResource(MonoObject*, const ResourceHandle<Texture>&, ScriptTexture**);
-	template BS_SCR_BE_EXPORT void ScriptResourceManager::createScriptResource(MonoObject*, const ResourceHandle<SpriteTexture>&, ScriptSpriteTexture**);
-	template BS_SCR_BE_EXPORT void ScriptResourceManager::createScriptResource(MonoObject*, const ResourceHandle<Mesh>&, ScriptMesh**);
-	template BS_SCR_BE_EXPORT void ScriptResourceManager::createScriptResource(MonoObject*, const ResourceHandle<Material>&, ScriptMaterial**);
-	template BS_SCR_BE_EXPORT void ScriptResourceManager::createScriptResource(MonoObject*, const ResourceHandle<Shader>&, ScriptShader**);
-	template BS_SCR_BE_EXPORT void ScriptResourceManager::createScriptResource(MonoObject*, const ResourceHandle<ShaderInclude>&, ScriptShaderInclude**);
-	template BS_SCR_BE_EXPORT void ScriptResourceManager::createScriptResource(MonoObject*, const ResourceHandle<Prefab>&, ScriptPrefab**);
-	template BS_SCR_BE_EXPORT void ScriptResourceManager::createScriptResource(MonoObject*, const ResourceHandle<Font>&, ScriptFont**);
-	template BS_SCR_BE_EXPORT void ScriptResourceManager::createScriptResource(MonoObject*, const ResourceHandle<PlainText>&, ScriptPlainText**);
-	template BS_SCR_BE_EXPORT void ScriptResourceManager::createScriptResource(MonoObject*, const ResourceHandle<ScriptCode>&, ScriptScriptCode**);
-	template BS_SCR_BE_EXPORT void ScriptResourceManager::createScriptResource(MonoObject*, const ResourceHandle<StringTable>&, ScriptStringTable**);
-	template BS_SCR_BE_EXPORT void ScriptResourceManager::createScriptResource(MonoObject*, const ResourceHandle<GUISkin>&, ScriptGUISkin**);
-	template BS_SCR_BE_EXPORT void ScriptResourceManager::createScriptResource(MonoObject*, const ResourceHandle<PhysicsMesh>&, ScriptPhysicsMesh**);
-	template BS_SCR_BE_EXPORT void ScriptResourceManager::createScriptResource(MonoObject*, const ResourceHandle<PhysicsMaterial>&, ScriptPhysicsMaterial**);
-	template BS_SCR_BE_EXPORT void ScriptResourceManager::createScriptResource(MonoObject*, const ResourceHandle<AudioClip>&, ScriptAudioClip**);
-	template BS_SCR_BE_EXPORT void ScriptResourceManager::createScriptResource(MonoObject*, const ResourceHandle<AnimationClip>&, ScriptAnimationClip**);
-	template BS_SCR_BE_EXPORT void ScriptResourceManager::createScriptResource(MonoObject*, const ResourceHandle<ManagedResource>&, ScriptManagedResource**);
-
-	template BS_SCR_BE_EXPORT void ScriptResourceManager::getScriptResource(const ResourceHandle<Texture>& resourceHandle, ScriptTexture** out, bool create);
-	template BS_SCR_BE_EXPORT void ScriptResourceManager::getScriptResource(const ResourceHandle<SpriteTexture>& resourceHandle, ScriptSpriteTexture** out, bool create);
-	template BS_SCR_BE_EXPORT void ScriptResourceManager::getScriptResource(const ResourceHandle<Mesh>& resourceHandle, ScriptMesh** out, bool create);
-	template BS_SCR_BE_EXPORT void ScriptResourceManager::getScriptResource(const ResourceHandle<Material>& resourceHandle, ScriptMaterial** out, bool create);
-	template BS_SCR_BE_EXPORT void ScriptResourceManager::getScriptResource(const ResourceHandle<Shader>& resourceHandle, ScriptShader** out, bool create);
-	template BS_SCR_BE_EXPORT void ScriptResourceManager::getScriptResource(const ResourceHandle<ShaderInclude>& resourceHandle, ScriptShaderInclude** out, bool create);
-	template BS_SCR_BE_EXPORT void ScriptResourceManager::getScriptResource(const ResourceHandle<Prefab>& resourceHandle, ScriptPrefab** out, bool create);
-	template BS_SCR_BE_EXPORT void ScriptResourceManager::getScriptResource(const ResourceHandle<Font>& resourceHandle, ScriptFont** out, bool create);
-	template BS_SCR_BE_EXPORT void ScriptResourceManager::getScriptResource(const ResourceHandle<PlainText>& resourceHandle, ScriptPlainText** out, bool create);
-	template BS_SCR_BE_EXPORT void ScriptResourceManager::getScriptResource(const ResourceHandle<ScriptCode>& resourceHandle, ScriptScriptCode** out, bool create);
-	template BS_SCR_BE_EXPORT void ScriptResourceManager::getScriptResource(const ResourceHandle<StringTable>& resourceHandle, ScriptStringTable** out, bool create);
-	template BS_SCR_BE_EXPORT void ScriptResourceManager::getScriptResource(const ResourceHandle<GUISkin>& resourceHandle, ScriptGUISkin** out, bool create);
-	template BS_SCR_BE_EXPORT void ScriptResourceManager::getScriptResource(const ResourceHandle<PhysicsMesh>& resourceHandle, ScriptPhysicsMesh** out, bool create);
-	template BS_SCR_BE_EXPORT void ScriptResourceManager::getScriptResource(const ResourceHandle<PhysicsMaterial>& resourceHandle, ScriptPhysicsMaterial** out, bool create);
-	template BS_SCR_BE_EXPORT void ScriptResourceManager::getScriptResource(const ResourceHandle<AudioClip>& resourceHandle, ScriptAudioClip** out, bool create);
-	template BS_SCR_BE_EXPORT void ScriptResourceManager::getScriptResource(const ResourceHandle<AnimationClip>& resourceHandle, ScriptAnimationClip** out, bool create);
-	template BS_SCR_BE_EXPORT void ScriptResourceManager::getScriptResource(const ResourceHandle<ManagedResource>& resourceHandle, ScriptManagedResource** out, bool create);
-	template BS_SCR_BE_EXPORT void ScriptResourceManager::getScriptResource(const ResourceHandle<Resource>& resourceHandle, ScriptResourceBase** out, bool create);
-
 	ScriptResourceBase* ScriptResourceManager::getScriptResource(const String& uuid)
 	{
 		if (uuid == "")

Source/SBansheeEngine/Source/BsScriptResourceRef.cpp

@@ -45,9 +45,7 @@ namespace bs
 			loadFlags |= ResourceLoadFlag::KeepSourceData;
 
 		HResource resource = gResources().load(nativeInstance->mResource, loadFlags);
-		ScriptResourceBase* scriptResource;
-
-		ScriptResourceManager::instance().getScriptResource(resource, &scriptResource, true);
+		ScriptResourceBase* scriptResource = ScriptResourceManager::instance().getScriptResource(resource, true);
 
 		return scriptResource->getManagedInstance();
 	}

Source/SBansheeEngine/Source/BsScriptResources.cpp

@@ -35,9 +35,7 @@ namespace bs
 		if (resource == nullptr)
 			return nullptr;
 
-		ScriptResourceBase* scriptResource;
-		ScriptResourceManager::instance().getScriptResource(resource, &scriptResource, true);
-
+		ScriptResourceBase* scriptResource = ScriptResourceManager::instance().getScriptResource(resource, true);
 		return scriptResource->getManagedInstance();
 	}
 
@@ -58,9 +56,7 @@ namespace bs
 		if (resource == nullptr)
 			return nullptr;
 
-		ScriptResourceBase* scriptResource;
-		ScriptResourceManager::instance().getScriptResource(resource, &scriptResource, true);
-
+		ScriptResourceBase* scriptResource = ScriptResourceManager::instance().getScriptResource(resource, true);
 		return scriptResource->getManagedInstance();
 	}
 

Source/SBansheeEngine/Source/BsScriptScene.cpp

@@ -69,9 +69,7 @@ namespace bs
 				prefab->instantiate();
 			}
 
-			ScriptPrefab* scriptPrefab;
-			ScriptResourceManager::instance().getScriptResource(prefab, &scriptPrefab, true);
-
+			ScriptResourceBase* scriptPrefab = ScriptResourceManager::instance().getScriptResource(prefab, true);
 			return scriptPrefab->getManagedInstance();
 		}
 		else

Source/SBansheeEngine/Source/BsScriptScriptCode.cpp

@@ -36,8 +36,7 @@ namespace bs
 		WString strText = MonoUtil::monoToWString(text);
 		HScriptCode scriptCode = ScriptCode::create(strText);
 
-		ScriptScriptCode* scriptInstance;
-		ScriptResourceManager::instance().createScriptResource(instance, scriptCode, &scriptInstance);
+		ScriptResourceBase* scriptInstance = ScriptResourceManager::instance().createBuiltinScriptResource(scriptCode, instance);
 	}
 
 	MonoString* ScriptScriptCode::internal_getText(ScriptScriptCode* thisPtr)

Source/SBansheeEngine/Source/BsScriptSpriteTexture.cpp

@@ -36,26 +36,21 @@ namespace bs
 		if (texture == nullptr)
 			return nullptr;
 
-		ScriptSpriteTexture* scriptSpriteTex;
-		ScriptResourceManager::instance().getScriptResource(texture, &scriptSpriteTex, true);
-
+		ScriptResourceBase* scriptSpriteTex = ScriptResourceManager::instance().getScriptResource(texture, true);
 		return scriptSpriteTex->getManagedInstance();
 	}
 
 	void ScriptSpriteTexture::internal_createInstance(MonoObject* instance, MonoObject* texture, Vector2* offset, Vector2* scale)
 	{
 		ScriptTexture* scriptTexture = ScriptTexture::toNative(texture);
-		ScriptSpriteTexture* scriptInstance;
+		ScriptResourceBase* scriptInstance;
 
 		if (scriptTexture == nullptr)
-		{
-			ScriptResourceManager::instance().createScriptResource(instance, SpriteTexture::dummy(), &scriptInstance);
-		}
+			scriptInstance = ScriptResourceManager::instance().createBuiltinScriptResource(SpriteTexture::dummy(), instance);
 		else
 		{
 			HSpriteTexture spriteTexture = SpriteTexture::create(*offset, *scale, scriptTexture->getHandle());
-
-			ScriptResourceManager::instance().createScriptResource(instance, spriteTexture, &scriptInstance);
+			scriptInstance = ScriptResourceManager::instance().createBuiltinScriptResource(spriteTexture, instance);
 		}
 	}
 
@@ -69,9 +64,7 @@ namespace bs
 		if (!texture.isLoaded())
 			return nullptr;
 
-		ScriptTexture* scriptTexture = nullptr;
-		ScriptResourceManager::instance().getScriptResource(texture, &scriptTexture, true);
-
+		ScriptResourceBase* scriptTexture = ScriptResourceManager::instance().getScriptResource(texture, true);
 		return scriptTexture->getManagedInstance();
 	}
 

Source/SBansheeEngine/Source/BsScriptStringTable.cpp

@@ -33,9 +33,7 @@ namespace bs
 	void ScriptStringTable::internal_CreateInstance(MonoObject* instance)
 	{
 		HStringTable stringTable = StringTable::create();
-
-		ScriptStringTable* scriptInstance;
-		ScriptResourceManager::instance().createScriptResource(instance, stringTable, &scriptInstance);
+		ScriptResourceBase* scriptInstance = ScriptResourceManager::instance().createBuiltinScriptResource(stringTable, instance);
 	}
 
 	bool ScriptStringTable::internal_Contains(ScriptStringTable* thisPtr, MonoString* identifier)

Source/SBansheeEngine/Source/BsScriptStringTableManager.cpp

@@ -39,9 +39,7 @@ namespace bs
 	{
 		HStringTable table = StringTableManager::instance().getTable(id);
 
-		ScriptStringTable* scriptStringTable;
-		ScriptResourceManager::instance().getScriptResource(table, &scriptStringTable, true);
-
+		ScriptResourceBase* scriptStringTable = ScriptResourceManager::instance().getScriptResource(table, true);
 		return scriptStringTable->getManagedInstance();
 	}