More fixes regarding the new component handing - most functionality seems to be restored

Source/BansheeCore/Include/BsCCamera.h

@@ -258,7 +258,7 @@ namespace bs
 		RTTITypeBase* getRTTI() const override;
 
 	protected:
-		CCamera() {} // Serialization only
+		CCamera();// Serialization only
      };
 
 	 /** @} */

Source/BansheeCore/Include/BsCLight.h

@@ -122,7 +122,7 @@ namespace bs
 		RTTITypeBase* getRTTI() const override;
 
 	protected:
-		CLight() {} // Serialization only
+		CLight(); // Serialization only
      };
 
 	 /** @} */

Source/BansheeCore/Include/BsCRenderable.h

@@ -95,7 +95,7 @@ namespace bs
 		RTTITypeBase* getRTTI() const override;
 
 	protected:
-		CRenderable() {} // Serialization only
+		CRenderable(); // Serialization only
 	};
 
 	/** @} */

Source/BansheeCore/Source/BsCCamera.cpp

@@ -7,6 +7,12 @@
 
 namespace bs 
 {
+	CCamera::CCamera()
+	{
+		Component::setFlag(ComponentFlag::AlwaysRun, true);
+		setName("Camera");
+	}
+
 	CCamera::CCamera(const HSceneObject& parent, SPtr<RenderTarget> target, float left, float top, float width, float height)
 		: Component(parent), mTarget(target), mLeft(left), mTop(top), mWidth(width), mHeight(height)
     {

Source/BansheeCore/Source/BsCLight.cpp

@@ -6,6 +6,12 @@
 
 namespace bs
 {
+	CLight::CLight()
+	{
+		setFlag(ComponentFlag::AlwaysRun, true);
+		setName("Light");
+	}
+
 	CLight::CLight(const HSceneObject& parent, LightType type, Color color,
 		float intensity, float range, bool castsShadows, Degree spotAngle, Degree spotFalloffAngle)
 		: Component(parent), mType(type), mColor(color), mIntensity(intensity), mRange(range),

Source/BansheeCore/Source/BsCRenderable.cpp

@@ -11,6 +11,12 @@
 
 namespace bs
 {
+	CRenderable::CRenderable()
+	{
+		setName("Renderable");
+		setFlag(ComponentFlag::AlwaysRun, true);
+	}
+
 	CRenderable::CRenderable(const HSceneObject& parent)
 		:Component(parent)
 	{

Source/BansheeCore/Source/BsCoreApplication.cpp

@@ -75,8 +75,8 @@ namespace bs
 		ct::ParamBlockManager::shutDown();
 		StringTableManager::shutDown();
 		Resources::shutDown();
-		ResourceListenerManager::shutDown();
 		GameObjectManager::shutDown();
+		ResourceListenerManager::shutDown();
 		RenderStateManager::shutDown();
 
 		// This must be done after all resources are released since it will unload the physics plugin, and some resources

Source/BansheeEngine/Include/BsCGUIWidget.h

@@ -110,9 +110,9 @@ namespace bs
 	public:
 		friend class CGUIWidgetRTTI;
 		static RTTITypeBase* getRTTIStatic();
-		virtual RTTITypeBase* getRTTI() const override;
+		RTTITypeBase* getRTTI() const override;
 
-		CGUIWidget() { } // Serialization only
+		CGUIWidget(); // Serialization only
 	};
 
 	/** @} */

Source/BansheeEngine/Include/BsProfilerOverlay.h

@@ -58,7 +58,7 @@ namespace bs
 		static RTTITypeBase* getRTTIStatic();
 		RTTITypeBase* getRTTI() const override;
 
-		ProfilerOverlay() { } // Serialization only
+		ProfilerOverlay(); // Serialization only
 	};
 
 	/**	Handles rendering of Profiler information as an overlay in a viewport. */

Source/BansheeEngine/Source/BsCGUIWidget.cpp

@@ -8,6 +8,11 @@
 
 namespace bs
 {
+	CGUIWidget::CGUIWidget()
+	{
+		setFlag(ComponentFlag::AlwaysRun, true);
+	}
+
 	CGUIWidget::CGUIWidget(const HSceneObject& parent, const SPtr<Camera>& camera)
 		:Component(parent), mCamera(camera), mParentHash((UINT32)-1)
 	{

Source/BansheeEngine/Source/BsProfilerOverlay.cpp

@@ -291,6 +291,11 @@ namespace bs
 
 	const UINT32 ProfilerOverlayInternal::MAX_DEPTH = 4;
 
+	ProfilerOverlay::ProfilerOverlay()
+	{
+		setFlag(ComponentFlag::AlwaysRun, true);
+	}
+
 	ProfilerOverlay::ProfilerOverlay(const HSceneObject& parent, const SPtr<Camera>& target)
 		:Component(parent), mInternal(nullptr)
 	{

Source/MBansheeEngine/Rendering/Renderable2.cs

@@ -0,0 +1,140 @@
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+using System;
+using System.Runtime.CompilerServices;
+
+namespace BansheeEngine
+{
+    /** @addtogroup Rendering
+     *  @{
+     */
+
+    /// <summary>
+    /// Renderable represents any visible object in the scene. It has a mesh, bounds and a set of materials. Renderer will 
+    /// render any Renderable objects visible by a camera.
+    /// </summary>
+    [RunInEditor]
+    public sealed class Renderable2 : Component
+    {
+        /// <summary>
+        /// Mesh to render. 
+        /// </summary>
+        public Mesh Mesh
+        {
+            get { return Internal_GetMesh(mCachedPtr); }
+            set
+            {
+                IntPtr meshPtr = IntPtr.Zero;
+                if (value != null)
+                    meshPtr = value.GetCachedPtr();
+
+                Internal_SetMesh(mCachedPtr, meshPtr);
+            }
+        }
+
+        /// <summary>
+        /// Material to use when rendering the mesh. If the mesh contains multiple sub-meshes then you may set individual
+        /// materials for each sub-mesh.
+        /// </summary>
+        public Material Material
+        {
+            get { return Internal_GetMaterial(mCachedPtr, 0); }
+            set
+            {
+                IntPtr materialPtr = IntPtr.Zero;
+                if (value != null)
+                    materialPtr = value.GetCachedPtr();
+
+                Internal_SetMaterial(mCachedPtr, materialPtr, 0);
+            }
+        }
+
+        /// <summary>
+        /// Materials to use when rendering the mesh. 
+        /// </summary>
+        public Material[] Materials
+        {
+            get { return Internal_GetMaterials(mCachedPtr); }
+            set { Internal_SetMaterials(mCachedPtr, value); }
+        }
+
+        /// <summary>
+        /// Returns a material for a specific sub-mesh.
+        /// </summary>
+        /// <param name="index">Index of the sub-mesh.</param>
+        /// <returns>Material used for rendering the sub-mesh at the specified index.</returns>
+        public Material GetMaterial(int index = 0)
+        {
+            return Internal_GetMaterial(mCachedPtr, index);
+        }
+
+        /// <summary>
+        /// Sets a material for a specific sub-mesh.
+        /// </summary>
+        /// <param name="material">Material to use for rendering the sub-mesh at the specified index.</param>
+        /// <param name="index">Index of the sub-mesh.</param>
+        public void SetMaterial(Material material, int index = 0)
+        {
+            IntPtr materialPtr = IntPtr.Zero;
+            if (material != null)
+                materialPtr = material.GetCachedPtr();
+
+            Internal_SetMaterial(mCachedPtr, materialPtr, index);
+        }
+
+        /// <summary>
+        /// Layer bitfield that controls whether a renderable is considered visible in a specific camera. Renderable layer 
+        /// must match camera layer in order for the camera to render the component.
+        /// </summary>
+        public UInt64 Layers
+        {
+            get { return Internal_GetLayers(mCachedPtr); }
+            set { Internal_SetLayers(mCachedPtr, value); }
+        }
+
+        /// <summary>
+        /// Gets world bounds of the mesh rendered by this object.
+        /// </summary>
+        public Bounds Bounds
+        {
+            get
+            {
+                AABox box;
+                Sphere sphere;
+
+                Internal_GetBounds(mCachedPtr, out box, out sphere);
+
+                return new Bounds(box, sphere);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern Mesh Internal_GetMesh(IntPtr thisPtr);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_SetMesh(IntPtr thisPtr, IntPtr mesh);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_GetBounds(IntPtr thisPtr, out AABox box, out Sphere sphere);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern UInt64 Internal_GetLayers(IntPtr thisPtr);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_SetLayers(IntPtr thisPtr, UInt64 layers);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern Material Internal_GetMaterial(IntPtr thisPtr, int index);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_SetMaterial(IntPtr thisPtr, IntPtr material, int index);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern Material[] Internal_GetMaterials(IntPtr thisPtr);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_SetMaterials(IntPtr thisPtr, Material[] materials);
+    }
+
+    /** @} */
+}

Source/SBansheeEngine/Include/BsBuiltinComponentLookup.h

@@ -73,7 +73,7 @@ namespace bs
 	};
 
 	LOOKUP_BEGIN
-		ADD_ENTRY(TID_Renderable, ScriptRenderable2)
+		ADD_ENTRY(TID_CRenderable, ScriptRenderable2)
 	LOOKUP_END
 
 #undef LOOKUP_BEGIN

Source/SBansheeEngine/Include/BsScriptRenderable.h

@@ -55,7 +55,7 @@ namespace bs
 	};
 
 	/**	Interop class between C++ & CLR for Renderable. */
-	class BS_SCR_BE_EXPORT ScriptRenderable2 : public TScriptComponent <ScriptRenderable2, Renderable>
+	class BS_SCR_BE_EXPORT ScriptRenderable2 : public TScriptComponent <ScriptRenderable2, CRenderable>
 	{
 	public:
 		SCRIPT_OBJ(ENGINE_ASSEMBLY, "BansheeEngine", "Renderable2")

Source/SBansheeEngine/Source/BsScriptRenderable.cpp

@@ -172,7 +172,7 @@ namespace bs
 	}
 
 	ScriptRenderable2::ScriptRenderable2(MonoObject* managedInstance, const HComponent& component)
-		:TScriptComponent <ScriptRenderable2, Renderable>(managedInstance, component)
+		:TScriptComponent <ScriptRenderable2, CRenderable>(managedInstance, component)
 	{ }
 
 	ScriptRenderable2::~ScriptRenderable2()
@@ -210,7 +210,8 @@ namespace bs
 		if (mesh != nullptr)
 			nativeMesh = mesh->getHandle();
 
-		thisPtr->getHandle()->setMesh(nativeMesh);
+		HRenderable renderable = thisPtr->getHandle();
+		renderable->setMesh(nativeMesh);
 	}
 
 	void ScriptRenderable2::internal_GetBounds(ScriptRenderable2* thisPtr, AABox* box, Sphere* sphere)
@@ -282,6 +283,8 @@ namespace bs
 
 	void ScriptRenderable2::internal_SetMaterials(ScriptRenderable2* thisPtr, MonoArray* materials)
 	{
+		HRenderable renderable = thisPtr->getHandle();
+
 		if (materials != nullptr)
 		{
 			ScriptArray scriptMaterials(materials);
@@ -293,14 +296,18 @@ namespace bs
 				ScriptMaterial* scriptMaterial = ScriptMaterial::toNative(monoMaterial);
 
 				if (scriptMaterial != nullptr)
-					nativeMaterials[i] = scriptMaterial->getHandle();
+					renderable->setMaterial(i, scriptMaterial->getHandle());
 			}
-
-			thisPtr->getHandle()->setMaterials(nativeMaterials);
 		}
 		else
 		{
-			thisPtr->getHandle()->setMaterials({});
+			HMesh mesh = renderable->getMesh();
+			if (!mesh.isLoaded())
+				return;
+
+			UINT32 numMaterials = mesh->getProperties().getNumSubMeshes();
+			for (UINT32 i = 0; i < numMaterials; i++)
+				renderable->setMaterial(i, HMaterial());
 		}
 	}
 }