Better way of converting screen position to world ray

Fixed physics scene queries

Source/BansheePhysX/Source/BsPhysX.cpp

@@ -385,10 +385,13 @@ namespace BansheeEngine
 
 	struct PhysXRaycastQueryCallback : PxRaycastCallback
 	{
+		static const int MAX_HITS = 32;
+		PxRaycastHit buffer[MAX_HITS];
+
 		Vector<PhysicsQueryHit> data;
 
 		PhysXRaycastQueryCallback()
-			:PxRaycastCallback(nullptr, 0)
+			:PxRaycastCallback(buffer, MAX_HITS)
 		{ }
 
 		PxAgain processTouches(const PxRaycastHit* buffer, PxU32 nbHits) override
@@ -405,10 +408,13 @@ namespace BansheeEngine
 
 	struct PhysXSweepQueryCallback : PxSweepCallback
 	{
+		static const int MAX_HITS = 32;
+		PxSweepHit buffer[MAX_HITS];
+
 		Vector<PhysicsQueryHit> data;
 
 		PhysXSweepQueryCallback()
-			:PxSweepCallback(nullptr, 0)
+			:PxSweepCallback(buffer, MAX_HITS)
 		{ }
 
 		PxAgain processTouches(const PxSweepHit* buffer, PxU32 nbHits) override
@@ -425,10 +431,13 @@ namespace BansheeEngine
 
 	struct PhysXOverlapQueryCallback : PxOverlapCallback
 	{
+		static const int MAX_HITS = 32;
+		PxOverlapHit buffer[MAX_HITS];
+
 		Vector<Collider*> data;
 
 		PhysXOverlapQueryCallback()
-			:PxOverlapCallback(nullptr, 0)
+			:PxOverlapCallback(buffer, MAX_HITS)
 		{ }
 
 		PxAgain processTouches(const PxOverlapHit* buffer, PxU32 nbHits) override
@@ -1115,6 +1124,7 @@ namespace BansheeEngine
 		PxOverlapBuffer output;
 
 		PxQueryFilterData filterData;
+		filterData.flags |= PxQueryFlag::eANY_HIT;
 		memcpy(&filterData.data.word0, &layer, sizeof(layer));
 
 		return mScene->overlap(geometry, tfrm, output, filterData);

Source/MBansheeEditor/ColorPicker.cs

@@ -310,7 +310,7 @@ namespace BansheeEditor
 
         private void OnEditorUpdate()
         {
-            Vector2I windowPos = ScreenToWindowPos(Input.PointerScreenPosition);
+            Vector2I windowPos = ScreenToWindowPos(Input.PointerPosition);
 
             colorBox.UpdateInput(windowPos);
         }

Source/MBansheeEditor/Inspector/InspectorWindow.cs

@@ -517,7 +517,7 @@ namespace BansheeEditor
             {
                 if ((DragDrop.DragInProgress || DragDrop.DropInProgress) && DragDrop.Type == DragDropType.Resource)
                 {
-                    Vector2I windowPos = ScreenToWindowPos(Input.PointerScreenPosition);
+                    Vector2I windowPos = ScreenToWindowPos(Input.PointerPosition);
                     Vector2I scrollPos = windowPos;
                     Rect2I contentBounds = inspectorLayout.Bounds;
                     scrollPos.x -= contentBounds.x;

Source/MBansheeEditor/Library/LibraryDropTarget.cs

@@ -151,7 +151,7 @@ namespace BansheeEditor
         /// </summary>
         public void Update()
         {
-            Vector2I currentWindowPos = parentWindow.ScreenToWindowPos(Input.PointerScreenPosition);
+            Vector2I currentWindowPos = parentWindow.ScreenToWindowPos(Input.PointerPosition);
 
             if (triggerStartLocalDrag)
             {

Source/MBansheeEditor/Scene/SceneCamera.cs

@@ -171,8 +171,8 @@ namespace BansheeEditor
                         Cursor.Hide();
 
                         Rect2I clipRect;
-                        clipRect.x = Input.PointerScreenPosition.x - 2;
-                        clipRect.y = Input.PointerScreenPosition.y - 2;
+                        clipRect.x = Input.PointerPosition.x - 2;
+                        clipRect.y = Input.PointerPosition.y - 2;
                         clipRect.width = 4;
                         clipRect.height = 4;
 
@@ -267,7 +267,7 @@ namespace BansheeEditor
                 Rect2I bounds = sceneWindow.Bounds;
 
                 // Move using scroll wheel
-                if (bounds.Contains(Input.PointerScreenPosition))
+                if (bounds.Contains(Input.PointerPosition))
                 {
                     float scrollAmount = VirtualInput.GetAxisValue(scrollAxis);
                     if (!isOrtographic)

Source/MBansheeEditor/Scene/SceneWindow.cs

@@ -491,7 +491,7 @@ namespace BansheeEditor
             }
 
             Vector2I scenePos;
-            bool inBounds = ScreenToScenePos(Input.PointerScreenPosition, out scenePos);
+            bool inBounds = ScreenToScenePos(Input.PointerPosition, out scenePos);
 
             bool draggedOver = DragDrop.DragInProgress || DragDrop.DropInProgress;
             draggedOver &= IsPointerHovering && inBounds && DragDrop.Type == DragDropType.Resource;
@@ -555,7 +555,7 @@ namespace BansheeEditor
 
                     if (draggedSO != null)
                     {
-                        Ray worldRay = camera.ScreenToWorldRay(scenePos);
+                        Ray worldRay = camera.ViewportToWorldRay(scenePos);
                         draggedSO.Position = worldRay*DefaultPlacementDepth;
                     }
                 }

Source/MBansheeEngine/Camera.cs

@@ -231,11 +231,11 @@ namespace BansheeEngine
         }
 
         /// <summary>
-        /// Converts a point in world space to screen coordinates.
+        /// Converts a point in world space to coordinates relative to the camera's viewport.
         /// </summary>
         /// <param name="value">3D point in world space.</param>
         /// <returns>2D point on the render target attached to the camera, in pixels.</returns>
-        public Vector2I WorldToScreen(Vector3 value) { return native.WorldToScreen(value); }
+        public Vector2I WorldToViewport(Vector3 value) { return native.WorldToViewport(value); }
 
         /// <summary>
         /// Converts a point in world space to normalized device coordinates.
@@ -252,29 +252,36 @@ namespace BansheeEngine
         public Vector3 WorldToView(Vector3 value) { return native.WorldToView(value); }
 
         /// <summary>
-        /// Converts a point in screen space to a point in world space.
+        /// Converts a point in screen coordinates to viewport coordinates.
+        /// </summary>
+        /// <param name="value">2D point on the screen, in pixels.</param>
+        /// <returns>2D point on the render target attached to the camera, in pixels.</returns>
+        public Vector2I ScreenToViewport(Vector2I value) { return native.ScreenToViewport(value); }
+
+        /// <summary>
+        /// Converts a point in viewport coordinates to a point in world space.
         /// </summary>
         /// <param name="value">2D point on the render target attached to the camera, in pixels.</param>
         /// <param name="depth">Depth at which place the world point at. The depth is applied to the vector going from 
         ///                     camera origin to the point on the near plane.</param>
         /// <returns>3D point in world space.</returns>
-        public Vector3 ScreenToWorld(Vector2I value, float depth = 0.5f) { return native.ScreenToWorld(value, depth); }
+        public Vector3 ViewportToWorld(Vector2I value, float depth = 0.5f) { return native.ViewportToWorld(value, depth); }
 
         /// <summary>
-        /// Converts a point in screen space to a point in view space.
+        /// Converts a point in viewport coordinates to a point in view space.
         /// </summary>
         /// <param name="value">2D point on the render target attached to the camera, in pixels.</param>
         /// <param name="depth">Depth at which place the view point at. The depth is applied to the vector going from 
         ///                     camera origin to the point on the near plane.</param>
         /// <returns>3D point in view space.</returns>
-        public Vector3 ScreenToView(Vector2I value, float depth = 0.5f) { return native.ScreenToView(value, depth); }
+        public Vector3 ViewportToView(Vector2I value, float depth = 0.5f) { return native.ViewportToView(value, depth); }
 
         /// <summary>
-        /// Converts a point in screen space to a point in normalized device coordinates.
+        /// Converts a point in viewport coordinates to a point in normalized device coordinates.
         /// </summary>
         /// <param name="value">2D point on the render target attached to the camera, in pixels.</param>
         /// <returns>2D point in normalized device coordinates ([-1, 1] range), relative to the camera's viewport.</returns>
-        public Vector2 ScreenToNDC(Vector2I value) { return native.ScreenToNDC(value); }
+        public Vector2 ViewportToNDC(Vector2I value) { return native.ViewportToNDC(value); }
 
         /// <summary>
         /// Converts a point relative to camera's coordinate system (view space) into a point in world space.
@@ -288,7 +295,7 @@ namespace BansheeEngine
         /// </summary>
         /// <param name="value">3D point in view space.</param>
         /// <returns>2D point on the render target attached to the camera, in pixels.</returns>
-        public Vector2I ViewToScreen(Vector3 value) { return native.ViewToScreen(value); }
+        public Vector2I ViewToViewport(Vector3 value) { return native.ViewToViewport(value); }
 
         /// <summary>
         /// Converts a point relative to camera's coordinate system (view space) to normalized device coordinates.
@@ -318,18 +325,27 @@ namespace BansheeEngine
         public Vector3 NDCToView(Vector2 value, float depth = 0.5f) { return native.NDCToView(value, depth); }
 
         /// <summary>
-        /// Converts a point relative to camera's viewport in normalized device coordinates ([-1, 1] range) to screen space.
+        /// Converts a point relative to camera's viewport in normalized device coordinates ([-1, 1] range) to viewport
+        /// coordinates in pixels.
         /// </summary>
         /// <param name="value">2D point in normalized device coordinates.</param>
         /// <returns>2D point on the render target attached to the camera, in pixels.</returns>
-        public Vector2I NDCToScreen(Vector2 value) { return native.NDCToScreen(value); }
+        public Vector2I NDCToViewport(Vector2 value) { return native.NDCToViewport(value); }
 
         /// <summary>
-        /// Converts a point in screen space in a ray in world space.
+        /// Converts a point in viewport coordinates to a ray in world space.
         /// </summary>
         /// <param name="value">2D point on the render target attached to the camera, in pixels.</param>
         /// <returns>A ray in world space with it's origin the selected point at the near frustum plane, pointing in the 
         ///          direction going from camera's origin towards a point on the near frustum plane.</returns>
+        public Ray ViewportToWorldRay(Vector2I value) { return native.ViewportToWorldRay(value); }
+
+        /// <summary>
+        /// Converts a point in screen coordinates to a ray in world space.
+        /// </summary>
+        /// <param name="value">2D point on the screen, in pixels.</param>
+        /// <returns>A ray in world space with it's origin the selected point at the near frustum plane, pointing in the 
+        ///          direction going from camera's origin towards a point on the near frustum plane.</returns>
         public Ray ScreenToWorldRay(Vector2I value) { return native.ScreenToWorldRay(value); }
 
         /// <summary>

Source/MBansheeEngine/Input.cs

@@ -292,7 +292,7 @@ namespace BansheeEngine
         }
 
         /// <summary>
-        /// Returns position of the pointer (for example mouse cursor) relative to the game window (or viewport).
+        /// Returns position of the pointer (for example mouse cursor) relative to the screen.
         /// </summary>
         public static Vector2I PointerPosition
         {
@@ -304,19 +304,6 @@ namespace BansheeEngine
             }
         }
 
-        /// <summary>
-        /// Returns position of the pointer (for example mouse cursor) relative to the screen.
-        /// </summary>
-        public static Vector2I PointerScreenPosition
-        {
-            get
-            {
-                Vector2I value;
-                Internal_GetPointerScreenPosition(out value);
-                return value;
-            }
-        }
-
         /// <summary>
         /// Returns difference between last and current pointer position.
         /// </summary>
@@ -479,9 +466,6 @@ namespace BansheeEngine
         [MethodImpl(MethodImplOptions.InternalCall)]
         private static extern void Internal_GetPointerPosition(out Vector2I position);
 
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_GetPointerScreenPosition(out Vector2I position);
-
         [MethodImpl(MethodImplOptions.InternalCall)]
         private static extern void Internal_GetPointerDelta(out Vector2I delta);
     }

Source/MBansheeEngine/NativeCamera.cs

@@ -203,10 +203,10 @@ namespace BansheeEngine
             set { Internal_SetMain(mCachedPtr, value); }
         }
 
-        internal Vector2I WorldToScreen(Vector3 value)
+        internal Vector2I WorldToViewport(Vector3 value)
         {
             Vector2I output;
-            Internal_WorldToScreen(mCachedPtr, ref value, out output);
+            Internal_WorldToViewport(mCachedPtr, ref value, out output);
             return output;
         }
 
@@ -224,24 +224,31 @@ namespace BansheeEngine
             return output;
         }
 
-        internal Vector3 ScreenToWorld(Vector2I value, float depth)
+        internal Vector2I ScreenToViewport(Vector2I value)
+        {
+            Vector2I output;
+            Internal_ScreenToViewport(mCachedPtr, ref value, out output);
+            return output;
+        }
+
+        internal Vector3 ViewportToWorld(Vector2I value, float depth)
         {
             Vector3 output;
-            Internal_ScreenToWorld(mCachedPtr, ref value, depth, out output);
+            Internal_ViewportToWorld(mCachedPtr, ref value, depth, out output);
             return output;
         }
 
-        internal Vector3 ScreenToView(Vector2I value, float depth)
+        internal Vector3 ViewportToView(Vector2I value, float depth)
         {
             Vector3 output;
-            Internal_ScreenToView(mCachedPtr, ref value, depth, out output);
+            Internal_ViewportToView(mCachedPtr, ref value, depth, out output);
             return output;
         }
 
-        internal Vector2 ScreenToNDC(Vector2I value)
+        internal Vector2 ViewportToNDC(Vector2I value)
         {
             Vector2 output;
-            Internal_ScreenToNDC(mCachedPtr, ref value, out output);
+            Internal_ViewportToNDC(mCachedPtr, ref value, out output);
             return output;
         }
 
@@ -252,10 +259,10 @@ namespace BansheeEngine
             return output;
         }
 
-        internal Vector2I ViewToScreen(Vector3 value)
+        internal Vector2I ViewToViewport(Vector3 value)
         {
             Vector2I output;
-            Internal_ViewToScreen(mCachedPtr, ref value, out output);
+            Internal_ViewToViewport(mCachedPtr, ref value, out output);
             return output;
         }
 
@@ -280,10 +287,17 @@ namespace BansheeEngine
             return output;
         }
 
-        internal Vector2I NDCToScreen(Vector2 value)
+        internal Vector2I NDCToViewport(Vector2 value)
         {
             Vector2I output;
-            Internal_NDCToScreen(mCachedPtr, ref value, out output);
+            Internal_NDCToViewport(mCachedPtr, ref value, out output);
+            return output;
+        }
+
+        internal Ray ViewportToWorldRay(Vector2I value)
+        {
+            Ray output;
+            Internal_ViewportToWorldRay(mCachedPtr, ref value, out output);
             return output;
         }
 
@@ -416,23 +430,26 @@ namespace BansheeEngine
         private static extern int Internal_GetHeightPixels(IntPtr instance);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_WorldToScreen(IntPtr instance, ref Vector3 value, out Vector2I output);
+        private static extern void Internal_WorldToViewport(IntPtr instance, ref Vector3 value, out Vector2I output);
         [MethodImpl(MethodImplOptions.InternalCall)]
         private static extern void Internal_WorldToNDC(IntPtr instance, ref Vector3 value, out Vector2 output);
         [MethodImpl(MethodImplOptions.InternalCall)]
         private static extern void Internal_WorldToView(IntPtr instance, ref Vector3 value, out Vector3 output);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_ScreenToWorld(IntPtr instance, ref Vector2I value, float depth, out Vector3 output);
+        private static extern void Internal_ScreenToViewport(IntPtr instance, ref Vector2I value, out Vector2I output);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_ViewportToWorld(IntPtr instance, ref Vector2I value, float depth, out Vector3 output);
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_ScreenToView(IntPtr instance, ref Vector2I value, float depth, out Vector3 output);
+        private static extern void Internal_ViewportToView(IntPtr instance, ref Vector2I value, float depth, out Vector3 output);
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_ScreenToNDC(IntPtr instance, ref Vector2I value, out Vector2 output);
+        private static extern void Internal_ViewportToNDC(IntPtr instance, ref Vector2I value, out Vector2 output);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
         private static extern void Internal_ViewToWorld(IntPtr instance, ref Vector3 value, out Vector3 output);
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_ViewToScreen(IntPtr instance, ref Vector3 value, out Vector2I output);
+        private static extern void Internal_ViewToViewport(IntPtr instance, ref Vector3 value, out Vector2I output);
         [MethodImpl(MethodImplOptions.InternalCall)]
         private static extern void Internal_ViewToNDC(IntPtr instance, ref Vector3 value, out Vector2 output);
 
@@ -441,8 +458,10 @@ namespace BansheeEngine
         [MethodImpl(MethodImplOptions.InternalCall)]
         private static extern void Internal_NDCToView(IntPtr instance, ref Vector2 value, float depth, out Vector3 output);
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_NDCToScreen(IntPtr instance, ref Vector2 value, out Vector2I output);
+        private static extern void Internal_NDCToViewport(IntPtr instance, ref Vector2 value, out Vector2I output);
 
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_ViewportToWorldRay(IntPtr instance, ref Vector2I value, out Ray output);
         [MethodImpl(MethodImplOptions.InternalCall)]
         private static extern void Internal_ScreenToWorldRay(IntPtr instance, ref Vector2I value, out Ray output);
         [MethodImpl(MethodImplOptions.InternalCall)]

Source/MBansheeEngine/Physics/Physics.cs

@@ -31,14 +31,7 @@ namespace BansheeEngine
         /// <returns>True if something was hit, false otherwise.</returns>
         public static bool RayCast(Ray ray, out PhysicsQueryHit hit, ulong layer = ulong.MaxValue, float max = float.MaxValue)
         {
-            ScriptPhysicsQueryHit scriptHit = new ScriptPhysicsQueryHit();
-            if (RayCast(ray.origin, ray.direction, out hit, layer, max))
-            {
-                ConvertPhysicsQueryHit(ref scriptHit, out hit);
-                return true;
-            }
-
-            return false;
+            return RayCast(ray.origin, ray.direction, out hit, layer, max);
         }
 
         /// <summary>
@@ -565,7 +558,11 @@ namespace BansheeEngine
         /// <param name="hit">Managed physics query hit info</param>
         private static void ConvertPhysicsQueryHit(ref ScriptPhysicsQueryHit scriptHit, out PhysicsQueryHit hit)
         {
-            hit.collider = scriptHit.collider.Component;
+            if (scriptHit.collider != null)
+                hit.collider = scriptHit.collider.Component;
+            else
+                hit.collider = null;
+
             hit.distance = scriptHit.distance;
             hit.normal = scriptHit.normal;
             hit.point = scriptHit.point;

Source/SBansheeEngine/Include/BsScriptCamera.h

@@ -98,23 +98,27 @@ namespace BansheeEngine
 		static int internal_GetWidthPixels(ScriptCamera* instance);
 		static int internal_GetHeightPixels(ScriptCamera* instance);
 
-		static void internal_WorldToScreen(ScriptCamera* instance, Vector3* value, Vector2I* output);
+		static void internal_WorldToViewport(ScriptCamera* instance, Vector3* value, Vector2I* output);
 		static void internal_WorldToNDC(ScriptCamera* instance, Vector3* value, Vector2* output);
 		static void internal_WorldToView(ScriptCamera* instance, Vector3* value, Vector3* output);
 
-		static void internal_ScreenToWorld(ScriptCamera* instance, Vector2I* value, float depth, Vector3* output);
-		static void internal_ScreenToView(ScriptCamera* instance, Vector2I* value, float depth, Vector3* output);
-		static void internal_ScreenToNDC(ScriptCamera* instance, Vector2I* value, Vector2* output);
+		static void internal_ScreenToViewport(ScriptCamera* instance, Vector2I* value, Vector2I* output);
+
+		static void internal_ViewportToWorld(ScriptCamera* instance, Vector2I* value, float depth, Vector3* output);
+		static void internal_ViewportToView(ScriptCamera* instance, Vector2I* value, float depth, Vector3* output);
+		static void internal_ViewportToNDC(ScriptCamera* instance, Vector2I* value, Vector2* output);
 
 		static void internal_ViewToWorld(ScriptCamera* instance, Vector3* value, Vector3* output);
-		static void internal_ViewToScreen(ScriptCamera* instance, Vector3* value, Vector2I* output);
+		static void internal_ViewToViewport(ScriptCamera* instance, Vector3* value, Vector2I* output);
 		static void internal_ViewToNDC(ScriptCamera* instance, Vector3* value, Vector2* output);
 
 		static void internal_NDCToWorld(ScriptCamera* instance, Vector2* value, float depth, Vector3* output);
 		static void internal_NDCToView(ScriptCamera* instance, Vector2* value, float depth, Vector3* output);
-		static void internal_NDCToScreen(ScriptCamera* instance, Vector2* value, Vector2I* output);
+		static void internal_NDCToViewport(ScriptCamera* instance, Vector2* value, Vector2I* output);
 
+		static void internal_ViewportToWorldRay(ScriptCamera* instance, Vector2I* value, Ray* output);
 		static void internal_ScreenToWorldRay(ScriptCamera* instance, Vector2I* value, Ray* output);
+		
 		static void internal_ProjectPoint(ScriptCamera* instance, Vector3* value, Vector3* output);
 		static void internal_UnprojectPoint(ScriptCamera* instance, Vector3* value, Vector3* output);
 

Source/SBansheeEngine/Include/BsScriptInput.h

@@ -67,7 +67,6 @@ namespace BansheeEngine
 		static bool internal_isPointerDoubleClicked();
 		static float internal_getAxisValue(UINT32 axisType, UINT32 deviceIdx);
 		static void internal_getPointerPosition(Vector2I* position);
-		static void internal_getPointerScreenPosition(Vector2I* position);
 		static void internal_getPointerDelta(Vector2I* position);
 
 		typedef void(__stdcall *OnButtonEventThunkDef) (ButtonCode, UINT32, MonoException**);

Source/SBansheeEngine/Source/BsScriptCamera.cpp

@@ -1,444 +1,488 @@
-//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
-//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
-#include "BsScriptCamera.h"
-#include "BsScriptMeta.h"
-#include "BsMonoField.h"
-#include "BsMonoClass.h"
-#include "BsMonoManager.h"
-#include "BsMonoUtil.h"
-#include "BsApplication.h"
-#include "BsCamera.h"
-#include "BsScriptSceneObject.h"
-#include "BsSceneObject.h"
-#include "BsScriptRenderTarget.h"
-#include "BsSceneManager.h"
-
-namespace BansheeEngine
-{
-	ScriptCamera::ScriptCamera(MonoObject* managedInstance, const HSceneObject& parentSO)
-		:ScriptObject(managedInstance), mCamera(nullptr), mLastUpdateHash(0)
-	{ 
-		mCamera = Camera::create(nullptr);
-		gSceneManager()._registerCamera(mCamera, parentSO);
-	}
-
-	ScriptCamera::~ScriptCamera()
-	{
-
-	}
-
-	void ScriptCamera::initRuntimeData()
-	{
-		metaData.scriptClass->addInternalCall("Internal_Create", &ScriptCamera::internal_Create);
-
-		metaData.scriptClass->addInternalCall("Internal_GetAspect", &ScriptCamera::internal_GetAspect);
-		metaData.scriptClass->addInternalCall("Internal_SetAspect", &ScriptCamera::internal_SetAspect);
-		metaData.scriptClass->addInternalCall("Internal_GetNearClip", &ScriptCamera::internal_GetNearClip);
-		metaData.scriptClass->addInternalCall("Internal_SetNearClip", &ScriptCamera::internal_SetNearClip);
-
-		metaData.scriptClass->addInternalCall("Internal_GetFarClip", &ScriptCamera::internal_GetFarClip);
-		metaData.scriptClass->addInternalCall("Internal_SetFarClip", &ScriptCamera::internal_SetFarClip);
-
-		metaData.scriptClass->addInternalCall("Internal_GetFieldOfView", &ScriptCamera::internal_GetFieldOfView);
-		metaData.scriptClass->addInternalCall("Internal_SetFieldOfView", &ScriptCamera::internal_SetFieldOfView);
-
-		metaData.scriptClass->addInternalCall("Internal_GetViewportRect", &ScriptCamera::internal_GetViewportRect);
-		metaData.scriptClass->addInternalCall("Internal_SetViewportRect", &ScriptCamera::internal_SetViewportRect);
-
-		metaData.scriptClass->addInternalCall("Internal_GetProjectionType", &ScriptCamera::internal_GetProjectionType);
-		metaData.scriptClass->addInternalCall("Internal_SetProjectionType", &ScriptCamera::internal_SetProjectionType);
-
-		metaData.scriptClass->addInternalCall("Internal_GetOrthographicHeight", &ScriptCamera::internal_GetOrthographicHeight);
-		metaData.scriptClass->addInternalCall("Internal_SetOrthographicHeight", &ScriptCamera::internal_SetOrthographicHeight);
-
-		metaData.scriptClass->addInternalCall("Internal_GetOrthographicWidth", &ScriptCamera::internal_GetOrthographicWidth);
-
-		metaData.scriptClass->addInternalCall("Internal_GetClearColor", &ScriptCamera::internal_GetClearColor);
-		metaData.scriptClass->addInternalCall("Internal_SetClearColor", &ScriptCamera::internal_SetClearColor);
-
-		metaData.scriptClass->addInternalCall("Internal_GetDepthClearValue", &ScriptCamera::internal_GetDepthClearValue);
-		metaData.scriptClass->addInternalCall("Internal_SetDepthClearValue", &ScriptCamera::internal_SetDepthClearValue);
-
-		metaData.scriptClass->addInternalCall("Internal_GetStencilClearValue", &ScriptCamera::internal_GetStencilClearValue);
-		metaData.scriptClass->addInternalCall("Internal_SetStencilClearValue", &ScriptCamera::internal_SetStencilClearValue);
-
-		metaData.scriptClass->addInternalCall("Internal_GetClearFlags", &ScriptCamera::internal_GetClearFlags);
-		metaData.scriptClass->addInternalCall("Internal_SetClearFlags", &ScriptCamera::internal_SetClearFlags);
-
-		metaData.scriptClass->addInternalCall("Internal_GetPriority", &ScriptCamera::internal_GetPriority);
-		metaData.scriptClass->addInternalCall("Internal_SetPriority", &ScriptCamera::internal_SetPriority);
-
-		metaData.scriptClass->addInternalCall("Internal_GetLayers", &ScriptCamera::internal_GetLayers);
-		metaData.scriptClass->addInternalCall("Internal_SetLayers", &ScriptCamera::internal_SetLayers);
-
-		metaData.scriptClass->addInternalCall("Internal_GetProjMatrix", &ScriptCamera::internal_GetProjMatrix);
-		metaData.scriptClass->addInternalCall("Internal_GetProjMatrixInv", &ScriptCamera::internal_GetProjMatrixInv);
-
-		metaData.scriptClass->addInternalCall("Internal_GetViewMatrix", &ScriptCamera::internal_GetViewMatrix);
-		metaData.scriptClass->addInternalCall("Internal_GetViewMatrixInv", &ScriptCamera::internal_GetViewMatrixInv);
-
-		metaData.scriptClass->addInternalCall("Internal_GetWidthPixels", &ScriptCamera::internal_GetWidthPixels);
-		metaData.scriptClass->addInternalCall("Internal_GetHeightPixels", &ScriptCamera::internal_GetHeightPixels);
-
-		metaData.scriptClass->addInternalCall("Internal_WorldToScreen", &ScriptCamera::internal_WorldToScreen);
-		metaData.scriptClass->addInternalCall("Internal_WorldToNDC", &ScriptCamera::internal_WorldToNDC);
-		metaData.scriptClass->addInternalCall("Internal_WorldToView", &ScriptCamera::internal_WorldToView);
-
-		metaData.scriptClass->addInternalCall("Internal_ScreenToWorld", &ScriptCamera::internal_ScreenToWorld);
-		metaData.scriptClass->addInternalCall("Internal_ScreenToView", &ScriptCamera::internal_ScreenToView);
-		metaData.scriptClass->addInternalCall("Internal_ScreenToNDC", &ScriptCamera::internal_ScreenToNDC);
-
-		metaData.scriptClass->addInternalCall("Internal_ViewToWorld", &ScriptCamera::internal_ViewToWorld);
-		metaData.scriptClass->addInternalCall("Internal_ViewToScreen", &ScriptCamera::internal_ViewToScreen);
-		metaData.scriptClass->addInternalCall("Internal_ViewToNDC", &ScriptCamera::internal_ViewToNDC);
-
-		metaData.scriptClass->addInternalCall("Internal_NDCToWorld", &ScriptCamera::internal_NDCToWorld);
-		metaData.scriptClass->addInternalCall("Internal_NDCToView", &ScriptCamera::internal_NDCToView);
-		metaData.scriptClass->addInternalCall("Internal_NDCToScreen", &ScriptCamera::internal_NDCToScreen);
-
-		metaData.scriptClass->addInternalCall("Internal_ScreenToWorldRay", &ScriptCamera::internal_ScreenToWorldRay);
-		metaData.scriptClass->addInternalCall("Internal_ProjectPoint", &ScriptCamera::internal_ProjectPoint);
-		metaData.scriptClass->addInternalCall("Internal_UnprojectPoint", &ScriptCamera::internal_UnprojectPoint);
-
-		metaData.scriptClass->addInternalCall("Internal_SetRenderTarget", &ScriptCamera::internal_SetRenderTarget);
-
-		metaData.scriptClass->addInternalCall("Internal_GetMain", &ScriptCamera::internal_GetMain);
-		metaData.scriptClass->addInternalCall("Internal_SetMain", &ScriptCamera::internal_SetMain);
-
-		metaData.scriptClass->addInternalCall("Internal_UpdateView", &ScriptCamera::internal_UpdateView);
-		metaData.scriptClass->addInternalCall("Internal_OnDestroy", &ScriptCamera::internal_OnDestroy);
-	}
-
-	void ScriptCamera::updateView(const HSceneObject& parent)
-	{
-		if (parent.isDestroyed())
-			return;
-
-		UINT32 curHash = parent->getTransformHash();
-		if (curHash != mLastUpdateHash)
-		{
-			mCamera->setPosition(parent->getWorldPosition());
-			mCamera->setRotation(parent->getWorldRotation());
-
-			mLastUpdateHash = curHash;
-		}
-
-		if (parent->getActive() != mCamera->getIsActive())
-		{
-			mCamera->setIsActive(parent->getActive());
-		}
-	}
-
-	void ScriptCamera::internal_Create(MonoObject* managedInstance, ScriptSceneObject* parentSO)
-	{
-		HSceneObject so;
-		if (parentSO != nullptr)
-			so = parentSO->getNativeHandle();
-
-		ScriptCamera* nativeInstance = new (bs_alloc<ScriptCamera>()) ScriptCamera(managedInstance, so);
-	}
-
-	float ScriptCamera::internal_GetAspect(ScriptCamera* instance)
-	{
-		return instance->mCamera->getAspectRatio();
-	}
-
-	void ScriptCamera::internal_SetAspect(ScriptCamera* instance, float value)
-	{
-		instance->mCamera->setAspectRatio(value);
-	}
-
-	float ScriptCamera::internal_GetNearClip(ScriptCamera* instance)
-	{
-		return instance->mCamera->getNearClipDistance();
-	}
-
-	void ScriptCamera::internal_SetNearClip(ScriptCamera* instance, float value)
-	{
-		instance->mCamera->setNearClipDistance(value);
-	}
-
-	float ScriptCamera::internal_GetFarClip(ScriptCamera* instance)
-	{
-		return instance->mCamera->getFarClipDistance();
-	}
-
-	void ScriptCamera::internal_SetFarClip(ScriptCamera* instance, float value)
-	{
-		instance->mCamera->setFarClipDistance(value);
-	}
-
-	void ScriptCamera::internal_GetFieldOfView(ScriptCamera* instance, Degree* value)
-	{
-		*value = instance->mCamera->getHorzFOV();
-	}
-
-	void ScriptCamera::internal_SetFieldOfView(ScriptCamera* instance, Degree* value)
-	{
-		instance->mCamera->setHorzFOV(*value);
-	}
-
-	void ScriptCamera::internal_GetViewportRect(ScriptCamera* instance, Rect2* value)
-	{
-		*value = instance->mCamera->getViewport()->getNormArea();
-	}
-
-	void ScriptCamera::internal_SetViewportRect(ScriptCamera* instance, Rect2* value)
-	{
-		instance->mCamera->getViewport()->setArea(value->x, value->y, value->width, value->height);
-	}
-
-	UINT32 ScriptCamera::internal_GetProjectionType(ScriptCamera* instance)
-	{
-		return instance->mCamera->getProjectionType();
-	}
-
-	void ScriptCamera::internal_SetProjectionType(ScriptCamera* instance, UINT32 value)
-	{
-		instance->mCamera->setProjectionType((ProjectionType)value);
-	}
-
-	float ScriptCamera::internal_GetOrthographicHeight(ScriptCamera* instance)
-	{
-		return instance->mCamera->getOrthoWindowHeight();
-	}
-
-	void ScriptCamera::internal_SetOrthographicHeight(ScriptCamera* instance, float value)
-	{
-		instance->mCamera->setOrthoWindowHeight(value);
-	}
-
-	float ScriptCamera::internal_GetOrthographicWidth(ScriptCamera* instance)
-	{
-		return instance->mCamera->getOrthoWindowWidth();
-	}
-
-	void ScriptCamera::internal_GetClearColor(ScriptCamera* instance, Color* value)
-	{
-		*value = instance->mCamera->getViewport()->getClearColor();
-	}
-
-	void ScriptCamera::internal_SetClearColor(ScriptCamera* instance, Color* value)
-	{
-		ViewportPtr vp = instance->mCamera->getViewport();
-		vp->setClearValues(*value, vp->getClearDepthValue(), vp->getClearStencilValue());
-	}
-
-	float ScriptCamera::internal_GetDepthClearValue(ScriptCamera* instance)
-	{
-		return instance->mCamera->getViewport()->getClearDepthValue();
-	}
-
-	void ScriptCamera::internal_SetDepthClearValue(ScriptCamera* instance, float value)
-	{
-		ViewportPtr vp = instance->mCamera->getViewport();
-		vp->setClearValues(vp->getClearColor(), value, vp->getClearStencilValue());
-	}
-
-	UINT16 ScriptCamera::internal_GetStencilClearValue(ScriptCamera* instance)
-	{
-		return instance->mCamera->getViewport()->getClearStencilValue();
-	}
-
-	void ScriptCamera::internal_SetStencilClearValue(ScriptCamera* instance, UINT16 value)
-	{
-		ViewportPtr vp = instance->mCamera->getViewport();
-		vp->setClearValues(vp->getClearColor(), vp->getClearDepthValue(), value);
-	}
-
-	UINT32 ScriptCamera::internal_GetClearFlags(ScriptCamera* instance)
-	{
-		ViewportPtr vp = instance->mCamera->getViewport();
-		UINT32 clearFlags = 0;
-
-		clearFlags |= vp->getRequiresColorClear() ? 0x01 : 0;
-		clearFlags |= vp->getRequiresDepthClear() ? 0x02 : 0;
-		clearFlags |= vp->getRequiresStencilClear() ? 0x04 : 0;
-
-		return clearFlags;
-	}
-
-	void ScriptCamera::internal_SetClearFlags(ScriptCamera* instance, UINT32 value)
-	{
-		ViewportPtr vp = instance->mCamera->getViewport();
-
-		vp->setRequiresClear((value & 0x01) != 0,
-			(value & 0x02) != 0, (value & 0x04) != 0);
-	}
-
-	int ScriptCamera::internal_GetPriority(ScriptCamera* instance)
-	{
-		return instance->mCamera->getPriority();
-	}
-
-	void ScriptCamera::internal_SetPriority(ScriptCamera* instance, int value)
-	{
-		instance->mCamera->setPriority(value);
-	}
-
-	UINT64 ScriptCamera::internal_GetLayers(ScriptCamera* instance)
-	{
-		return instance->mCamera->getLayers();
-	}
-
-	void ScriptCamera::internal_SetLayers(ScriptCamera* instance, UINT64 value)
-	{
-		instance->mCamera->setLayers(value);
-	}
-
-	void ScriptCamera::internal_GetProjMatrix(ScriptCamera* instance, Matrix4* output)
-	{
-		*output = instance->mCamera->getProjectionMatrixRS();
-	}
-
-	void ScriptCamera::internal_GetProjMatrixInv(ScriptCamera* instance, Matrix4* output)
-	{
-		*output = instance->mCamera->getProjectionMatrixRSInv();
-	}
-
-	void ScriptCamera::internal_GetViewMatrix(ScriptCamera* instance, Matrix4* output)
-	{
-		*output = instance->mCamera->getViewMatrix();
-	}
-
-	void ScriptCamera::internal_GetViewMatrixInv(ScriptCamera* instance, Matrix4* output)
-	{
-		*output = instance->mCamera->getViewMatrixInv();
-	}
-
-	int ScriptCamera::internal_GetWidthPixels(ScriptCamera* instance)
-	{
-		ViewportPtr vp = instance->mCamera->getViewport();
-
-		return vp->getWidth();
-	}
-
-	int ScriptCamera::internal_GetHeightPixels(ScriptCamera* instance)
-	{
-		ViewportPtr vp = instance->mCamera->getViewport();
-
-		return vp->getHeight();
-	}
-
-	void ScriptCamera::internal_WorldToScreen(ScriptCamera* instance, Vector3* value, Vector2I* output)
-	{
-		*output = instance->mCamera->worldToScreenPoint(*value);
-	}
-
-	void ScriptCamera::internal_WorldToNDC(ScriptCamera* instance, Vector3* value, Vector2* output)
-	{
-		*output = instance->mCamera->worldToNdcPoint(*value);
-	}
-
-	void ScriptCamera::internal_WorldToView(ScriptCamera* instance, Vector3* value, Vector3* output)
-	{
-		*output = instance->mCamera->worldToViewPoint(*value);
-	}
-
-	void ScriptCamera::internal_ScreenToWorld(ScriptCamera* instance, Vector2I* value, float depth, Vector3* output)
-	{
-		*output = instance->mCamera->screenToWorldPoint(*value, depth);
-	}
-
-	void ScriptCamera::internal_ScreenToView(ScriptCamera* instance, Vector2I* value, float depth, Vector3* output)
-	{
-		*output = instance->mCamera->screenToViewPoint(*value, depth);
-	}
-
-	void ScriptCamera::internal_ScreenToNDC(ScriptCamera* instance, Vector2I* value, Vector2* output)
-	{
-		*output = instance->mCamera->screenToNdcPoint(*value);
-	}
-
-	void ScriptCamera::internal_ViewToWorld(ScriptCamera* instance, Vector3* value, Vector3* output)
-	{
-		*output = instance->mCamera->viewToWorldPoint(*value);
-	}
-
-	void ScriptCamera::internal_ViewToScreen(ScriptCamera* instance, Vector3* value, Vector2I* output)
-	{
-		*output = instance->mCamera->viewToScreenPoint(*value);
-	}
-
-	void ScriptCamera::internal_ViewToNDC(ScriptCamera* instance, Vector3* value, Vector2* output)
-	{
-		*output = instance->mCamera->viewToNdcPoint(*value);
-	}
-
-	void ScriptCamera::internal_NDCToWorld(ScriptCamera* instance, Vector2* value, float depth, Vector3* output)
-	{
-		*output = instance->mCamera->ndcToWorldPoint(*value, depth);
-	}
-
-	void ScriptCamera::internal_NDCToView(ScriptCamera* instance, Vector2* value, float depth, Vector3* output)
-	{
-		*output = instance->mCamera->ndcToViewPoint(*value, depth);
-	}
-
-	void ScriptCamera::internal_NDCToScreen(ScriptCamera* instance, Vector2* value, Vector2I* output)
-	{
-		*output = instance->mCamera->ndcToScreenPoint(*value);
-	}
-
-	void ScriptCamera::internal_ScreenToWorldRay(ScriptCamera* instance, Vector2I* value, Ray* output)
-	{
-		*output = instance->mCamera->screenPointToRay(*value);
-	}
-
-	void ScriptCamera::internal_ProjectPoint(ScriptCamera* instance, Vector3* value, Vector3* output)
-	{
-		*output = instance->mCamera->projectPoint(*value);
-	}
-
-	void ScriptCamera::internal_UnprojectPoint(ScriptCamera* instance, Vector3* value, Vector3* output)
-	{
-		*output = instance->mCamera->unprojectPoint(*value);
-	}
-
-	void ScriptCamera::internal_SetRenderTarget(ScriptCamera* instance, ScriptRenderTarget* target)
-	{
-		if (target == nullptr)
-			instance->mCamera->getViewport()->setTarget(nullptr);
-		else
-			instance->mCamera->getViewport()->setTarget(target->getNativeValue());
-	}
-
-	bool ScriptCamera::internal_GetMain(ScriptCamera* instance)
-	{
-		return instance->mCamera->isMain();
-	}
-
-	void ScriptCamera::internal_SetMain(ScriptCamera* instance, bool main)
-	{
-		instance->mCamera->setMain(main);
-		gSceneManager()._notifyMainCameraStateChanged(instance->mCamera);
-	}
-
-	void ScriptCamera::internal_UpdateView(ScriptCamera* instance, ScriptSceneObject* parent)
-	{
-		HSceneObject parentSO = parent->getNativeSceneObject();
-
-		instance->updateView(parentSO);
-	}
-
-	void ScriptCamera::internal_OnDestroy(ScriptCamera* instance)
-	{
-		instance->destroy();
-	}
-
-	void ScriptCamera::destroy()
-	{
-		if (mCamera->isDestroyed())
-			return;
-
-		gSceneManager()._unregisterCamera(mCamera);
-		mCamera->destroy();
-	}
-
-	void ScriptCamera::_onManagedInstanceDeleted()
-	{
-		destroy();
-
-		ScriptObject::_onManagedInstanceDeleted();
-	}
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#include "BsScriptCamera.h"
+#include "BsScriptMeta.h"
+#include "BsMonoClass.h"
+#include "BsMonoManager.h"
+#include "BsMonoUtil.h"
+#include "BsCamera.h"
+#include "BsScriptSceneObject.h"
+#include "BsSceneObject.h"
+#include "BsScriptRenderTarget.h"
+#include "BsSceneManager.h"
+#include "BsViewport.h"
+#include "BsRenderTarget.h"
+#include "BsRenderWindow.h"
+#include "BsRenderTexture.h"
+#include "BsGUIManager.h"
+
+namespace BansheeEngine
+{
+	ScriptCamera::ScriptCamera(MonoObject* managedInstance, const HSceneObject& parentSO)
+		:ScriptObject(managedInstance), mCamera(nullptr), mLastUpdateHash(0)
+	{ 
+		mCamera = Camera::create(nullptr);
+		gSceneManager()._registerCamera(mCamera, parentSO);
+	}
+
+	ScriptCamera::~ScriptCamera()
+	{
+
+	}
+
+	void ScriptCamera::initRuntimeData()
+	{
+		metaData.scriptClass->addInternalCall("Internal_Create", &ScriptCamera::internal_Create);
+
+		metaData.scriptClass->addInternalCall("Internal_GetAspect", &ScriptCamera::internal_GetAspect);
+		metaData.scriptClass->addInternalCall("Internal_SetAspect", &ScriptCamera::internal_SetAspect);
+		metaData.scriptClass->addInternalCall("Internal_GetNearClip", &ScriptCamera::internal_GetNearClip);
+		metaData.scriptClass->addInternalCall("Internal_SetNearClip", &ScriptCamera::internal_SetNearClip);
+
+		metaData.scriptClass->addInternalCall("Internal_GetFarClip", &ScriptCamera::internal_GetFarClip);
+		metaData.scriptClass->addInternalCall("Internal_SetFarClip", &ScriptCamera::internal_SetFarClip);
+
+		metaData.scriptClass->addInternalCall("Internal_GetFieldOfView", &ScriptCamera::internal_GetFieldOfView);
+		metaData.scriptClass->addInternalCall("Internal_SetFieldOfView", &ScriptCamera::internal_SetFieldOfView);
+
+		metaData.scriptClass->addInternalCall("Internal_GetViewportRect", &ScriptCamera::internal_GetViewportRect);
+		metaData.scriptClass->addInternalCall("Internal_SetViewportRect", &ScriptCamera::internal_SetViewportRect);
+
+		metaData.scriptClass->addInternalCall("Internal_GetProjectionType", &ScriptCamera::internal_GetProjectionType);
+		metaData.scriptClass->addInternalCall("Internal_SetProjectionType", &ScriptCamera::internal_SetProjectionType);
+
+		metaData.scriptClass->addInternalCall("Internal_GetOrthographicHeight", &ScriptCamera::internal_GetOrthographicHeight);
+		metaData.scriptClass->addInternalCall("Internal_SetOrthographicHeight", &ScriptCamera::internal_SetOrthographicHeight);
+
+		metaData.scriptClass->addInternalCall("Internal_GetOrthographicWidth", &ScriptCamera::internal_GetOrthographicWidth);
+
+		metaData.scriptClass->addInternalCall("Internal_GetClearColor", &ScriptCamera::internal_GetClearColor);
+		metaData.scriptClass->addInternalCall("Internal_SetClearColor", &ScriptCamera::internal_SetClearColor);
+
+		metaData.scriptClass->addInternalCall("Internal_GetDepthClearValue", &ScriptCamera::internal_GetDepthClearValue);
+		metaData.scriptClass->addInternalCall("Internal_SetDepthClearValue", &ScriptCamera::internal_SetDepthClearValue);
+
+		metaData.scriptClass->addInternalCall("Internal_GetStencilClearValue", &ScriptCamera::internal_GetStencilClearValue);
+		metaData.scriptClass->addInternalCall("Internal_SetStencilClearValue", &ScriptCamera::internal_SetStencilClearValue);
+
+		metaData.scriptClass->addInternalCall("Internal_GetClearFlags", &ScriptCamera::internal_GetClearFlags);
+		metaData.scriptClass->addInternalCall("Internal_SetClearFlags", &ScriptCamera::internal_SetClearFlags);
+
+		metaData.scriptClass->addInternalCall("Internal_GetPriority", &ScriptCamera::internal_GetPriority);
+		metaData.scriptClass->addInternalCall("Internal_SetPriority", &ScriptCamera::internal_SetPriority);
+
+		metaData.scriptClass->addInternalCall("Internal_GetLayers", &ScriptCamera::internal_GetLayers);
+		metaData.scriptClass->addInternalCall("Internal_SetLayers", &ScriptCamera::internal_SetLayers);
+
+		metaData.scriptClass->addInternalCall("Internal_GetProjMatrix", &ScriptCamera::internal_GetProjMatrix);
+		metaData.scriptClass->addInternalCall("Internal_GetProjMatrixInv", &ScriptCamera::internal_GetProjMatrixInv);
+
+		metaData.scriptClass->addInternalCall("Internal_GetViewMatrix", &ScriptCamera::internal_GetViewMatrix);
+		metaData.scriptClass->addInternalCall("Internal_GetViewMatrixInv", &ScriptCamera::internal_GetViewMatrixInv);
+
+		metaData.scriptClass->addInternalCall("Internal_GetWidthPixels", &ScriptCamera::internal_GetWidthPixels);
+		metaData.scriptClass->addInternalCall("Internal_GetHeightPixels", &ScriptCamera::internal_GetHeightPixels);
+
+		metaData.scriptClass->addInternalCall("Internal_WorldToViewport", &ScriptCamera::internal_WorldToViewport);
+		metaData.scriptClass->addInternalCall("Internal_WorldToNDC", &ScriptCamera::internal_WorldToNDC);
+		metaData.scriptClass->addInternalCall("Internal_WorldToView", &ScriptCamera::internal_WorldToView);
+
+		metaData.scriptClass->addInternalCall("Internal_ScreenToViewport", &ScriptCamera::internal_ScreenToViewport);
+
+		metaData.scriptClass->addInternalCall("Internal_ViewportToWorld", &ScriptCamera::internal_ViewportToWorld);
+		metaData.scriptClass->addInternalCall("Internal_ViewportToView", &ScriptCamera::internal_ViewportToView);
+		metaData.scriptClass->addInternalCall("Internal_ViewportToNDC", &ScriptCamera::internal_ViewportToNDC);
+
+		metaData.scriptClass->addInternalCall("Internal_ViewToWorld", &ScriptCamera::internal_ViewToWorld);
+		metaData.scriptClass->addInternalCall("Internal_ViewToViewport", &ScriptCamera::internal_ViewToViewport);
+		metaData.scriptClass->addInternalCall("Internal_ViewToNDC", &ScriptCamera::internal_ViewToNDC);
+
+		metaData.scriptClass->addInternalCall("Internal_NDCToWorld", &ScriptCamera::internal_NDCToWorld);
+		metaData.scriptClass->addInternalCall("Internal_NDCToView", &ScriptCamera::internal_NDCToView);
+		metaData.scriptClass->addInternalCall("Internal_NDCToViewport", &ScriptCamera::internal_NDCToViewport);
+
+		metaData.scriptClass->addInternalCall("Internal_ViewportToWorldRay", &ScriptCamera::internal_ViewportToWorldRay);
+		metaData.scriptClass->addInternalCall("Internal_ScreenToWorldRay", &ScriptCamera::internal_ScreenToWorldRay);
+
+		metaData.scriptClass->addInternalCall("Internal_ProjectPoint", &ScriptCamera::internal_ProjectPoint);
+		metaData.scriptClass->addInternalCall("Internal_UnprojectPoint", &ScriptCamera::internal_UnprojectPoint);
+
+		metaData.scriptClass->addInternalCall("Internal_SetRenderTarget", &ScriptCamera::internal_SetRenderTarget);
+
+		metaData.scriptClass->addInternalCall("Internal_GetMain", &ScriptCamera::internal_GetMain);
+		metaData.scriptClass->addInternalCall("Internal_SetMain", &ScriptCamera::internal_SetMain);
+
+		metaData.scriptClass->addInternalCall("Internal_UpdateView", &ScriptCamera::internal_UpdateView);
+		metaData.scriptClass->addInternalCall("Internal_OnDestroy", &ScriptCamera::internal_OnDestroy);
+	}
+
+	void ScriptCamera::updateView(const HSceneObject& parent)
+	{
+		if (parent.isDestroyed())
+			return;
+
+		UINT32 curHash = parent->getTransformHash();
+		if (curHash != mLastUpdateHash)
+		{
+			mCamera->setPosition(parent->getWorldPosition());
+			mCamera->setRotation(parent->getWorldRotation());
+
+			mLastUpdateHash = curHash;
+		}
+
+		if (parent->getActive() != mCamera->getIsActive())
+		{
+			mCamera->setIsActive(parent->getActive());
+		}
+	}
+
+	void ScriptCamera::internal_Create(MonoObject* managedInstance, ScriptSceneObject* parentSO)
+	{
+		HSceneObject so;
+		if (parentSO != nullptr)
+			so = parentSO->getNativeHandle();
+
+		ScriptCamera* nativeInstance = new (bs_alloc<ScriptCamera>()) ScriptCamera(managedInstance, so);
+	}
+
+	float ScriptCamera::internal_GetAspect(ScriptCamera* instance)
+	{
+		return instance->mCamera->getAspectRatio();
+	}
+
+	void ScriptCamera::internal_SetAspect(ScriptCamera* instance, float value)
+	{
+		instance->mCamera->setAspectRatio(value);
+	}
+
+	float ScriptCamera::internal_GetNearClip(ScriptCamera* instance)
+	{
+		return instance->mCamera->getNearClipDistance();
+	}
+
+	void ScriptCamera::internal_SetNearClip(ScriptCamera* instance, float value)
+	{
+		instance->mCamera->setNearClipDistance(value);
+	}
+
+	float ScriptCamera::internal_GetFarClip(ScriptCamera* instance)
+	{
+		return instance->mCamera->getFarClipDistance();
+	}
+
+	void ScriptCamera::internal_SetFarClip(ScriptCamera* instance, float value)
+	{
+		instance->mCamera->setFarClipDistance(value);
+	}
+
+	void ScriptCamera::internal_GetFieldOfView(ScriptCamera* instance, Degree* value)
+	{
+		*value = instance->mCamera->getHorzFOV();
+	}
+
+	void ScriptCamera::internal_SetFieldOfView(ScriptCamera* instance, Degree* value)
+	{
+		instance->mCamera->setHorzFOV(*value);
+	}
+
+	void ScriptCamera::internal_GetViewportRect(ScriptCamera* instance, Rect2* value)
+	{
+		*value = instance->mCamera->getViewport()->getNormArea();
+	}
+
+	void ScriptCamera::internal_SetViewportRect(ScriptCamera* instance, Rect2* value)
+	{
+		instance->mCamera->getViewport()->setArea(value->x, value->y, value->width, value->height);
+	}
+
+	UINT32 ScriptCamera::internal_GetProjectionType(ScriptCamera* instance)
+	{
+		return instance->mCamera->getProjectionType();
+	}
+
+	void ScriptCamera::internal_SetProjectionType(ScriptCamera* instance, UINT32 value)
+	{
+		instance->mCamera->setProjectionType((ProjectionType)value);
+	}
+
+	float ScriptCamera::internal_GetOrthographicHeight(ScriptCamera* instance)
+	{
+		return instance->mCamera->getOrthoWindowHeight();
+	}
+
+	void ScriptCamera::internal_SetOrthographicHeight(ScriptCamera* instance, float value)
+	{
+		instance->mCamera->setOrthoWindowHeight(value);
+	}
+
+	float ScriptCamera::internal_GetOrthographicWidth(ScriptCamera* instance)
+	{
+		return instance->mCamera->getOrthoWindowWidth();
+	}
+
+	void ScriptCamera::internal_GetClearColor(ScriptCamera* instance, Color* value)
+	{
+		*value = instance->mCamera->getViewport()->getClearColor();
+	}
+
+	void ScriptCamera::internal_SetClearColor(ScriptCamera* instance, Color* value)
+	{
+		ViewportPtr vp = instance->mCamera->getViewport();
+		vp->setClearValues(*value, vp->getClearDepthValue(), vp->getClearStencilValue());
+	}
+
+	float ScriptCamera::internal_GetDepthClearValue(ScriptCamera* instance)
+	{
+		return instance->mCamera->getViewport()->getClearDepthValue();
+	}
+
+	void ScriptCamera::internal_SetDepthClearValue(ScriptCamera* instance, float value)
+	{
+		ViewportPtr vp = instance->mCamera->getViewport();
+		vp->setClearValues(vp->getClearColor(), value, vp->getClearStencilValue());
+	}
+
+	UINT16 ScriptCamera::internal_GetStencilClearValue(ScriptCamera* instance)
+	{
+		return instance->mCamera->getViewport()->getClearStencilValue();
+	}
+
+	void ScriptCamera::internal_SetStencilClearValue(ScriptCamera* instance, UINT16 value)
+	{
+		ViewportPtr vp = instance->mCamera->getViewport();
+		vp->setClearValues(vp->getClearColor(), vp->getClearDepthValue(), value);
+	}
+
+	UINT32 ScriptCamera::internal_GetClearFlags(ScriptCamera* instance)
+	{
+		ViewportPtr vp = instance->mCamera->getViewport();
+		UINT32 clearFlags = 0;
+
+		clearFlags |= vp->getRequiresColorClear() ? 0x01 : 0;
+		clearFlags |= vp->getRequiresDepthClear() ? 0x02 : 0;
+		clearFlags |= vp->getRequiresStencilClear() ? 0x04 : 0;
+
+		return clearFlags;
+	}
+
+	void ScriptCamera::internal_SetClearFlags(ScriptCamera* instance, UINT32 value)
+	{
+		ViewportPtr vp = instance->mCamera->getViewport();
+
+		vp->setRequiresClear((value & 0x01) != 0,
+			(value & 0x02) != 0, (value & 0x04) != 0);
+	}
+
+	int ScriptCamera::internal_GetPriority(ScriptCamera* instance)
+	{
+		return instance->mCamera->getPriority();
+	}
+
+	void ScriptCamera::internal_SetPriority(ScriptCamera* instance, int value)
+	{
+		instance->mCamera->setPriority(value);
+	}
+
+	UINT64 ScriptCamera::internal_GetLayers(ScriptCamera* instance)
+	{
+		return instance->mCamera->getLayers();
+	}
+
+	void ScriptCamera::internal_SetLayers(ScriptCamera* instance, UINT64 value)
+	{
+		instance->mCamera->setLayers(value);
+	}
+
+	void ScriptCamera::internal_GetProjMatrix(ScriptCamera* instance, Matrix4* output)
+	{
+		*output = instance->mCamera->getProjectionMatrixRS();
+	}
+
+	void ScriptCamera::internal_GetProjMatrixInv(ScriptCamera* instance, Matrix4* output)
+	{
+		*output = instance->mCamera->getProjectionMatrixRSInv();
+	}
+
+	void ScriptCamera::internal_GetViewMatrix(ScriptCamera* instance, Matrix4* output)
+	{
+		*output = instance->mCamera->getViewMatrix();
+	}
+
+	void ScriptCamera::internal_GetViewMatrixInv(ScriptCamera* instance, Matrix4* output)
+	{
+		*output = instance->mCamera->getViewMatrixInv();
+	}
+
+	int ScriptCamera::internal_GetWidthPixels(ScriptCamera* instance)
+	{
+		ViewportPtr vp = instance->mCamera->getViewport();
+
+		return vp->getWidth();
+	}
+
+	int ScriptCamera::internal_GetHeightPixels(ScriptCamera* instance)
+	{
+		ViewportPtr vp = instance->mCamera->getViewport();
+
+		return vp->getHeight();
+	}
+
+	void ScriptCamera::internal_WorldToViewport(ScriptCamera* instance, Vector3* value, Vector2I* output)
+	{
+		*output = instance->mCamera->worldToScreenPoint(*value);
+	}
+
+	void ScriptCamera::internal_WorldToNDC(ScriptCamera* instance, Vector3* value, Vector2* output)
+	{
+		*output = instance->mCamera->worldToNdcPoint(*value);
+	}
+
+	void ScriptCamera::internal_WorldToView(ScriptCamera* instance, Vector3* value, Vector3* output)
+	{
+		*output = instance->mCamera->worldToViewPoint(*value);
+	}
+
+	void ScriptCamera::internal_ScreenToViewport(ScriptCamera* instance, Vector2I* value, Vector2I* output)
+	{
+		SceneCameraData mainCamera = gSceneManager().getMainCamera();
+		if (mainCamera.camera == nullptr)
+			return;
+
+		// The main camera could be rendering to a standalone window, or be a part of the editor GUI. Find out which
+		// and transform the pointer position appropriately.
+		RenderTargetPtr target = mainCamera.camera->getViewport()->getTarget();
+		if (target == nullptr)
+			return;
+
+		if (target->getProperties().isWindow())
+		{
+			RenderWindowPtr window = std::static_pointer_cast<RenderWindow>(target);
+			*output = window->screenToWindowPos(*value);
+		}
+		else
+		{
+			RenderTexturePtr texture = std::static_pointer_cast<RenderTexture>(target);
+
+			RenderWindowPtr window = GUIManager::instance().getBridgeWindow(texture);
+			if (window == nullptr)
+				return;
+
+			*output = window->screenToWindowPos(*value);
+			*output = GUIManager::instance().windowToBridgedCoords(target, *output);
+		}
+	}
+
+	void ScriptCamera::internal_ViewportToWorld(ScriptCamera* instance, Vector2I* value, float depth, Vector3* output)
+	{
+		*output = instance->mCamera->screenToWorldPoint(*value, depth);
+	}
+
+	void ScriptCamera::internal_ViewportToView(ScriptCamera* instance, Vector2I* value, float depth, Vector3* output)
+	{
+		*output = instance->mCamera->screenToViewPoint(*value, depth);
+	}
+
+	void ScriptCamera::internal_ViewportToNDC(ScriptCamera* instance, Vector2I* value, Vector2* output)
+	{
+		*output = instance->mCamera->screenToNdcPoint(*value);
+	}
+
+	void ScriptCamera::internal_ViewToWorld(ScriptCamera* instance, Vector3* value, Vector3* output)
+	{
+		*output = instance->mCamera->viewToWorldPoint(*value);
+	}
+
+	void ScriptCamera::internal_ViewToViewport(ScriptCamera* instance, Vector3* value, Vector2I* output)
+	{
+		*output = instance->mCamera->viewToScreenPoint(*value);
+	}
+
+	void ScriptCamera::internal_ViewToNDC(ScriptCamera* instance, Vector3* value, Vector2* output)
+	{
+		*output = instance->mCamera->viewToNdcPoint(*value);
+	}
+
+	void ScriptCamera::internal_NDCToWorld(ScriptCamera* instance, Vector2* value, float depth, Vector3* output)
+	{
+		*output = instance->mCamera->ndcToWorldPoint(*value, depth);
+	}
+
+	void ScriptCamera::internal_NDCToView(ScriptCamera* instance, Vector2* value, float depth, Vector3* output)
+	{
+		*output = instance->mCamera->ndcToViewPoint(*value, depth);
+	}
+
+	void ScriptCamera::internal_NDCToViewport(ScriptCamera* instance, Vector2* value, Vector2I* output)
+	{
+		*output = instance->mCamera->ndcToScreenPoint(*value);
+	}
+
+	void ScriptCamera::internal_ScreenToWorldRay(ScriptCamera* instance, Vector2I* value, Ray* output)
+	{
+		Vector2I viewportPos;
+		internal_ScreenToViewport(instance, value, &viewportPos);
+		internal_ViewportToWorldRay(instance, &viewportPos, output);
+	}
+
+	void ScriptCamera::internal_ViewportToWorldRay(ScriptCamera* instance, Vector2I* value, Ray* output)
+	{
+		*output = instance->mCamera->screenPointToRay(*value);
+	}
+
+	void ScriptCamera::internal_ProjectPoint(ScriptCamera* instance, Vector3* value, Vector3* output)
+	{
+		*output = instance->mCamera->projectPoint(*value);
+	}
+
+	void ScriptCamera::internal_UnprojectPoint(ScriptCamera* instance, Vector3* value, Vector3* output)
+	{
+		*output = instance->mCamera->unprojectPoint(*value);
+	}
+
+	void ScriptCamera::internal_SetRenderTarget(ScriptCamera* instance, ScriptRenderTarget* target)
+	{
+		if (target == nullptr)
+			instance->mCamera->getViewport()->setTarget(nullptr);
+		else
+			instance->mCamera->getViewport()->setTarget(target->getNativeValue());
+	}
+
+	bool ScriptCamera::internal_GetMain(ScriptCamera* instance)
+	{
+		return instance->mCamera->isMain();
+	}
+
+	void ScriptCamera::internal_SetMain(ScriptCamera* instance, bool main)
+	{
+		instance->mCamera->setMain(main);
+		gSceneManager()._notifyMainCameraStateChanged(instance->mCamera);
+	}
+
+	void ScriptCamera::internal_UpdateView(ScriptCamera* instance, ScriptSceneObject* parent)
+	{
+		HSceneObject parentSO = parent->getNativeSceneObject();
+
+		instance->updateView(parentSO);
+	}
+
+	void ScriptCamera::internal_OnDestroy(ScriptCamera* instance)
+	{
+		instance->destroy();
+	}
+
+	void ScriptCamera::destroy()
+	{
+		if (mCamera->isDestroyed())
+			return;
+
+		gSceneManager()._unregisterCamera(mCamera);
+		mCamera->destroy();
+	}
+
+	void ScriptCamera::_onManagedInstanceDeleted()
+	{
+		destroy();
+
+		ScriptObject::_onManagedInstanceDeleted();
+	}
 }

Source/SBansheeEngine/Source/BsScriptInput.cpp

@@ -8,13 +8,6 @@
 #include "BsInput.h"
 #include "BsScriptVector2I.h"
 #include "BsPlayInEditorManager.h"
-#include "BsSceneManager.h"
-#include "BsCamera.h"
-#include "BsViewport.h"
-#include "BsRenderTarget.h"
-#include "BsRenderWindow.h"
-#include "BsRenderTexture.h"
-#include "BsGUIManager.h"
 
 namespace BansheeEngine
 {
@@ -49,7 +42,6 @@ namespace BansheeEngine
 		metaData.scriptClass->addInternalCall("Internal_IsPointerDoubleClicked", &ScriptInput::internal_isPointerDoubleClicked);
 		metaData.scriptClass->addInternalCall("Internal_GetAxisValue", &ScriptInput::internal_getAxisValue);
 		metaData.scriptClass->addInternalCall("Internal_GetPointerPosition", &ScriptInput::internal_getPointerPosition);
-		metaData.scriptClass->addInternalCall("Internal_GetPointerScreenPosition", &ScriptInput::internal_getPointerScreenPosition);
 		metaData.scriptClass->addInternalCall("Internal_GetPointerDelta", &ScriptInput::internal_getPointerDelta);
 
 		OnButtonPressedThunk = (OnButtonEventThunkDef)metaData.scriptClass->getMethodExact("Internal_TriggerButtonDown", "ButtonCode,int")->getThunk();
@@ -198,38 +190,6 @@ namespace BansheeEngine
 	}
 
 	void ScriptInput::internal_getPointerPosition(Vector2I* position)
-	{
-		*position = Input::instance().getPointerPosition();
-
-		SceneCameraData mainCamera = gSceneManager().getMainCamera();
-		if (mainCamera.camera == nullptr)
-			return;
-
-		// The main camera could be rendering to a standalone window, or be a part of the editor GUI. Find out which
-		// and transform the pointer position appropriately.
-		RenderTargetPtr target = mainCamera.camera->getViewport()->getTarget();
-		if (target == nullptr)
-			return;
-
-		if(target->getProperties().isWindow())
-		{
-			RenderWindowPtr window = std::static_pointer_cast<RenderWindow>(target);
-			*position = window->screenToWindowPos(*position);
-		}
-		else
-		{
-			RenderTexturePtr texture = std::static_pointer_cast<RenderTexture>(target);
-
-			RenderWindowPtr window = GUIManager::instance().getBridgeWindow(texture);
-			if (window == nullptr)
-				return;
-
-			*position = window->screenToWindowPos(*position);
-			*position = GUIManager::instance().windowToBridgedCoords(target, *position);
-		}		
-	}
-
-	void ScriptInput::internal_getPointerScreenPosition(Vector2I* position)
 	{
 		*position = Input::instance().getPointerPosition();
 	}

Source/SBansheeEngine/Source/BsScriptPhysics.cpp

@@ -1,276 +1,276 @@
-//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
-//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
-#include "BsScriptPhysics.h"
-#include "BsMonoManager.h"
-#include "BsMonoClass.h"
-#include "BsMonoUtil.h"
-#include "BsPhysics.h"
-#include "BsScriptPhysicsMesh.h"
-#include "BsScriptCollider.h"
-#include "BsCollider.h"
-
-namespace BansheeEngine
-{
-	ScriptPhysics::ScriptPhysics(MonoObject* instance)
-		:ScriptObject(instance)
-	{ }
-
-	void ScriptPhysics::initRuntimeData()
-	{
-		metaData.scriptClass->addInternalCall("Internal_GetGravity", &ScriptPhysics::internal_GetGravity);
-		metaData.scriptClass->addInternalCall("Internal_SetGravity", &ScriptPhysics::internal_SetGravity);
-
-		metaData.scriptClass->addInternalCall("Internal_AddPhysicsRegion", &ScriptPhysics::internal_AddPhysicsRegion);
-		metaData.scriptClass->addInternalCall("Internal_RemovePhysicsRegion", &ScriptPhysics::internal_RemovePhysicsRegion);
-		metaData.scriptClass->addInternalCall("Internal_ClearPhysicsRegions", &ScriptPhysics::internal_ClearPhysicsRegions);
-
-		metaData.scriptClass->addInternalCall("Internal_ToggleCollision", &ScriptPhysics::internal_ToggleCollision);
-		metaData.scriptClass->addInternalCall("Internal_IsCollisionEnabled", &ScriptPhysics::internal_IsCollisionEnabled);
-
-		metaData.scriptClass->addInternalCall("Internal_IsUpdateInProgress", &ScriptPhysics::internal_IsUpdateInProgress);
-
-		metaData.scriptClass->addInternalCall("Internal_RayCast", &ScriptPhysics::internal_RayCast);
-		metaData.scriptClass->addInternalCall("Internal_BoxCast", &ScriptPhysics::internal_BoxCast);
-		metaData.scriptClass->addInternalCall("Internal_SphereCast", &ScriptPhysics::internal_SphereCast);
-		metaData.scriptClass->addInternalCall("Internal_CapsuleCast", &ScriptPhysics::internal_CapsuleCast);
-		metaData.scriptClass->addInternalCall("Internal_ConvexCast", &ScriptPhysics::internal_ConvexCast);
-
-		metaData.scriptClass->addInternalCall("Internal_RayCastAll", &ScriptPhysics::internal_RayCastAll);
-		metaData.scriptClass->addInternalCall("Internal_BoxCastAll", &ScriptPhysics::internal_BoxCastAll);
-		metaData.scriptClass->addInternalCall("Internal_SphereCastAll", &ScriptPhysics::internal_SphereCastAll);
-		metaData.scriptClass->addInternalCall("Internal_CapsuleCastAll", &ScriptPhysics::internal_CapsuleCastAll);
-		metaData.scriptClass->addInternalCall("Internal_ConvexCastAll", &ScriptPhysics::internal_ConvexCastAll);
-
-		metaData.scriptClass->addInternalCall("Internal_RayCastAny", &ScriptPhysics::internal_RayCastAny);
-		metaData.scriptClass->addInternalCall("Internal_BoxCastAny", &ScriptPhysics::internal_BoxCastAny);
-		metaData.scriptClass->addInternalCall("Internal_SphereCastAny", &ScriptPhysics::internal_SphereCastAny);
-		metaData.scriptClass->addInternalCall("Internal_CapsuleCastAny", &ScriptPhysics::internal_CapsuleCastAny);
-		metaData.scriptClass->addInternalCall("Internal_ConvexCastAny", &ScriptPhysics::internal_ConvexCastAny);
-
-		metaData.scriptClass->addInternalCall("Internal_BoxOverlap", &ScriptPhysics::internal_BoxOverlap);
-		metaData.scriptClass->addInternalCall("Internal_SphereOverlap", &ScriptPhysics::internal_SphereOverlap);
-		metaData.scriptClass->addInternalCall("Internal_CapsuleOverlap", &ScriptPhysics::internal_CapsuleOverlap);
-		metaData.scriptClass->addInternalCall("Internal_ConvexOverlap", &ScriptPhysics::internal_ConvexOverlap);
-
-		metaData.scriptClass->addInternalCall("Internal_BoxOverlapAny", &ScriptPhysics::internal_BoxOverlapAny);
-		metaData.scriptClass->addInternalCall("Internal_SphereOverlapAny", &ScriptPhysics::internal_SphereOverlapAny);
-		metaData.scriptClass->addInternalCall("Internal_CapsuleOverlapAny", &ScriptPhysics::internal_CapsuleOverlapAny);
-		metaData.scriptClass->addInternalCall("Internal_ConvexOverlapAny", &ScriptPhysics::internal_ConvexOverlapAny);
-	}
-
-	void ScriptPhysics::internal_GetGravity(Vector3* gravity)
-	{
-		*gravity = gPhysics().getGravity();
-	}
-
-	void ScriptPhysics::internal_SetGravity(Vector3* gravity)
-	{
-		gPhysics().setGravity(*gravity);
-	}
-
-	int ScriptPhysics::internal_AddPhysicsRegion(AABox* region)
-	{
-		return gPhysics().addBroadPhaseRegion(*region);
-	}
-
-	void ScriptPhysics::internal_RemovePhysicsRegion(int handle)
-	{
-		gPhysics().removeBroadPhaseRegion(handle);
-	}
-
-	void ScriptPhysics::internal_ClearPhysicsRegions()
-	{
-		gPhysics().clearBroadPhaseRegions();
-	}
-
-	void ScriptPhysics::internal_ToggleCollision(UINT64 layerA, UINT64 layerB, bool enabled)
-	{
-		gPhysics().toggleCollision(layerA, layerB, enabled);
-	}
-
-	bool ScriptPhysics::internal_IsCollisionEnabled(UINT64 layerA, UINT64 layerB)
-	{
-		return gPhysics().isCollisionEnabled(layerA, layerB);
-	}
-
-	bool ScriptPhysics::internal_IsUpdateInProgress()
-	{
-		return gPhysics()._isUpdateInProgress();
-	}
-
-	bool ScriptPhysics::internal_RayCast(Vector3* origin, Vector3* unitDir, ScriptPhysicsQueryHit* hit, UINT64 layer, float max)
-	{
-		PhysicsQueryHit nativeHit;
-		bool wasHit = gPhysics().rayCast(*origin, *unitDir, nativeHit, layer, max);
-		*hit = ScriptPhysicsQueryHitHelper::create(nativeHit);
-
-		return wasHit;
-	}
-
-	bool ScriptPhysics::internal_BoxCast(AABox* box, Quaternion* rotation, Vector3* unitDir, ScriptPhysicsQueryHit* hit, UINT64 layer, float max)
-	{
-		PhysicsQueryHit nativeHit;
-		bool wasHit = gPhysics().boxCast(*box, *rotation, *unitDir, nativeHit, layer, max);
-		*hit = ScriptPhysicsQueryHitHelper::create(nativeHit);
-
-		return wasHit;
-	}
-
-	bool ScriptPhysics::internal_SphereCast(Sphere* sphere, Vector3* unitDir, ScriptPhysicsQueryHit* hit, UINT64 layer, float max)
-	{
-		PhysicsQueryHit nativeHit;
-		bool wasHit = gPhysics().sphereCast(*sphere, *unitDir, nativeHit, layer, max);
-		*hit = ScriptPhysicsQueryHitHelper::create(nativeHit);
-
-		return wasHit;
-	}
-
-	bool ScriptPhysics::internal_CapsuleCast(Capsule* capsule, Quaternion* rotation, Vector3* unitDir, ScriptPhysicsQueryHit* hit, UINT64 layer, float max)
-	{
-		PhysicsQueryHit nativeHit;
-		bool wasHit = gPhysics().capsuleCast(*capsule, *rotation, *unitDir, nativeHit, layer, max);
-		*hit = ScriptPhysicsQueryHitHelper::create(nativeHit);
-
-		return wasHit;
-	}
-
-	bool ScriptPhysics::internal_ConvexCast(ScriptPhysicsMesh* mesh, Vector3* position, Quaternion* rotation, Vector3* unitDir, ScriptPhysicsQueryHit* hit, UINT64 layer, float max)
-	{
-		HPhysicsMesh meshHandle;
-		if (mesh != nullptr)
-			meshHandle = mesh->getHandle();
-
-		PhysicsQueryHit nativeHit;
-		bool wasHit = gPhysics().convexCast(meshHandle, *position, *rotation, *unitDir, nativeHit, layer, max);
-		*hit = ScriptPhysicsQueryHitHelper::create(nativeHit);
-
-		return wasHit;
-	}
-
-	MonoArray* nativeToManagedHitArray(const Vector<PhysicsQueryHit>& hits)
-	{
-		UINT32 numHits = (UINT32)hits.size();
-		ScriptArray output = ScriptArray::create<ScriptPhysicsQueryHitHelper>(numHits);
-
-		for (UINT32 i = 0; i < numHits; i++)
-			output.set(i, ScriptPhysicsQueryHitHelper::box(ScriptPhysicsQueryHitHelper::create(hits[i])));
-
-		return output.getInternal();
-	}
-
-	MonoArray* ScriptPhysics::internal_RayCastAll(Vector3* origin, Vector3* unitDir, UINT64 layer, float max)
-	{
-		return nativeToManagedHitArray(gPhysics().rayCastAll(*origin, *unitDir, layer, max));
-	}
-
-	MonoArray* ScriptPhysics::internal_BoxCastAll(AABox* box, Quaternion* rotation, Vector3* unitDir, UINT64 layer, float max)
-	{
-		return nativeToManagedHitArray(gPhysics().boxCastAll(*box, *rotation, *unitDir, layer, max));
-	}
-
-	MonoArray* ScriptPhysics::internal_SphereCastAll(Sphere* sphere, Vector3* unitDir, UINT64 layer, float max)
-	{
-		return nativeToManagedHitArray(gPhysics().sphereCastAll(*sphere, *unitDir, layer, max));
-	}
-
-	MonoArray* ScriptPhysics::internal_CapsuleCastAll(Capsule* capsule, Quaternion* rotation, Vector3* unitDir, UINT64 layer, float max)
-	{
-		return nativeToManagedHitArray(gPhysics().capsuleCastAll(*capsule, *rotation, *unitDir, layer, max));
-	}
-
-	MonoArray* ScriptPhysics::internal_ConvexCastAll(ScriptPhysicsMesh* mesh, Vector3* position, Quaternion* rotation, Vector3* unitDir, UINT64 layer, float max)
-	{
-		HPhysicsMesh meshHandle;
-		if (mesh != nullptr)
-			meshHandle = mesh->getHandle();
-
-		return nativeToManagedHitArray(gPhysics().convexCastAll(meshHandle, *position, *rotation, *unitDir, layer, max));
-	}
-
-	bool ScriptPhysics::internal_RayCastAny(Vector3* origin, Vector3* unitDir, UINT64 layer, float max)
-	{
-		return gPhysics().rayCastAny(*origin, *unitDir, layer, max);
-	}
-
-	bool ScriptPhysics::internal_BoxCastAny(AABox* box, Quaternion* rotation, Vector3* unitDir, UINT64 layer, float max)
-	{
-		return gPhysics().boxCastAny(*box, *rotation, *unitDir, layer, max);
-	}
-
-	bool ScriptPhysics::internal_SphereCastAny(Sphere* sphere, Vector3* unitDir, UINT64 layer, float max)
-	{
-		return gPhysics().sphereCastAny(*sphere, *unitDir, layer, max);
-	}
-
-	bool ScriptPhysics::internal_CapsuleCastAny(Capsule* capsule, Quaternion* rotation, Vector3* unitDir, UINT64 layer, float max)
-	{
-		return gPhysics().capsuleCastAny(*capsule, *rotation, *unitDir, layer, max);
-	}
-
-	bool ScriptPhysics::internal_ConvexCastAny(ScriptPhysicsMesh* mesh, Vector3* position, Quaternion* rotation, Vector3* unitDir, UINT64 layer, float max)
-	{
-		HPhysicsMesh meshHandle;
-		if (mesh != nullptr)
-			meshHandle = mesh->getHandle();
-
-		return gPhysics().convexCastAny(meshHandle, *position, *rotation, *unitDir, layer, max);
-	}
-
-	MonoArray* nativeToManagedColliderArray(const Vector<Collider*>& colliders)
-	{
-		UINT32 numColliders = (UINT32)colliders.size();
-		ScriptArray output = ScriptArray::create<ScriptCollider>(numColliders);
-		for (UINT32 i = 0; i < numColliders; i++)
-			output.set(i, colliders[i]->_getOwner(PhysicsOwnerType::Script));
-
-		return output.getInternal();
-	}
-
-	MonoArray* ScriptPhysics::internal_BoxOverlap(AABox* box, Quaternion* rotation, UINT64 layer)
-	{
-		return nativeToManagedColliderArray(gPhysics()._boxOverlap(*box, *rotation, layer));
-	}
-
-	MonoArray* ScriptPhysics::internal_SphereOverlap(Sphere* sphere, UINT64 layer)
-	{
-		return nativeToManagedColliderArray(gPhysics()._sphereOverlap(*sphere, layer));
-	}
-
-	MonoArray* ScriptPhysics::internal_CapsuleOverlap(Capsule* capsule, Quaternion* rotation, UINT64 layer)
-	{
-		return nativeToManagedColliderArray(gPhysics()._capsuleOverlap(*capsule, *rotation, layer));
-	}
-
-	MonoArray* ScriptPhysics::internal_ConvexOverlap(ScriptPhysicsMesh* mesh, Vector3* position, Quaternion* rotation, UINT64 layer)
-	{
-		HPhysicsMesh meshHandle;
-		if (mesh != nullptr)
-			meshHandle = mesh->getHandle();
-
-		return nativeToManagedColliderArray(gPhysics()._convexOverlap(meshHandle, *position, *rotation, layer));
-	}
-
-	bool ScriptPhysics::internal_BoxOverlapAny(AABox* box, Quaternion* rotation, UINT64 layer)
-	{
-		return gPhysics().boxOverlapAny(*box, *rotation, layer);
-	}
-
-	bool ScriptPhysics::internal_SphereOverlapAny(Sphere* sphere, UINT64 layer)
-	{
-		return gPhysics().sphereOverlapAny(*sphere, layer);
-	}
-
-	bool ScriptPhysics::internal_CapsuleOverlapAny(Capsule* capsule, Quaternion* rotation, UINT64 layer)
-	{
-		return gPhysics().capsuleOverlapAny(*capsule, *rotation, layer);
-	}
-
-	bool ScriptPhysics::internal_ConvexOverlapAny(ScriptPhysicsMesh* mesh, Vector3* position, Quaternion* rotation, UINT64 layer)
-	{
-		HPhysicsMesh meshHandle;
-		if (mesh != nullptr)
-			meshHandle = mesh->getHandle();
-
-		return gPhysics().convexOverlapAny(meshHandle, *position, *rotation, layer);
-	}
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
+#include "BsScriptPhysics.h"
+#include "BsMonoManager.h"
+#include "BsMonoClass.h"
+#include "BsMonoUtil.h"
+#include "BsPhysics.h"
+#include "BsScriptPhysicsMesh.h"
+#include "BsScriptCollider.h"
+#include "BsCollider.h"
+
+namespace BansheeEngine
+{
+	ScriptPhysics::ScriptPhysics(MonoObject* instance)
+		:ScriptObject(instance)
+	{ }
+
+	void ScriptPhysics::initRuntimeData()
+	{
+		metaData.scriptClass->addInternalCall("Internal_GetGravity", &ScriptPhysics::internal_GetGravity);
+		metaData.scriptClass->addInternalCall("Internal_SetGravity", &ScriptPhysics::internal_SetGravity);
+
+		metaData.scriptClass->addInternalCall("Internal_AddPhysicsRegion", &ScriptPhysics::internal_AddPhysicsRegion);
+		metaData.scriptClass->addInternalCall("Internal_RemovePhysicsRegion", &ScriptPhysics::internal_RemovePhysicsRegion);
+		metaData.scriptClass->addInternalCall("Internal_ClearPhysicsRegions", &ScriptPhysics::internal_ClearPhysicsRegions);
+
+		metaData.scriptClass->addInternalCall("Internal_ToggleCollision", &ScriptPhysics::internal_ToggleCollision);
+		metaData.scriptClass->addInternalCall("Internal_IsCollisionEnabled", &ScriptPhysics::internal_IsCollisionEnabled);
+
+		metaData.scriptClass->addInternalCall("Internal_IsUpdateInProgress", &ScriptPhysics::internal_IsUpdateInProgress);
+
+		metaData.scriptClass->addInternalCall("Internal_RayCast", &ScriptPhysics::internal_RayCast);
+		metaData.scriptClass->addInternalCall("Internal_BoxCast", &ScriptPhysics::internal_BoxCast);
+		metaData.scriptClass->addInternalCall("Internal_SphereCast", &ScriptPhysics::internal_SphereCast);
+		metaData.scriptClass->addInternalCall("Internal_CapsuleCast", &ScriptPhysics::internal_CapsuleCast);
+		metaData.scriptClass->addInternalCall("Internal_ConvexCast", &ScriptPhysics::internal_ConvexCast);
+
+		metaData.scriptClass->addInternalCall("Internal_RayCastAll", &ScriptPhysics::internal_RayCastAll);
+		metaData.scriptClass->addInternalCall("Internal_BoxCastAll", &ScriptPhysics::internal_BoxCastAll);
+		metaData.scriptClass->addInternalCall("Internal_SphereCastAll", &ScriptPhysics::internal_SphereCastAll);
+		metaData.scriptClass->addInternalCall("Internal_CapsuleCastAll", &ScriptPhysics::internal_CapsuleCastAll);
+		metaData.scriptClass->addInternalCall("Internal_ConvexCastAll", &ScriptPhysics::internal_ConvexCastAll);
+
+		metaData.scriptClass->addInternalCall("Internal_RayCastAny", &ScriptPhysics::internal_RayCastAny);
+		metaData.scriptClass->addInternalCall("Internal_BoxCastAny", &ScriptPhysics::internal_BoxCastAny);
+		metaData.scriptClass->addInternalCall("Internal_SphereCastAny", &ScriptPhysics::internal_SphereCastAny);
+		metaData.scriptClass->addInternalCall("Internal_CapsuleCastAny", &ScriptPhysics::internal_CapsuleCastAny);
+		metaData.scriptClass->addInternalCall("Internal_ConvexCastAny", &ScriptPhysics::internal_ConvexCastAny);
+
+		metaData.scriptClass->addInternalCall("Internal_BoxOverlap", &ScriptPhysics::internal_BoxOverlap);
+		metaData.scriptClass->addInternalCall("Internal_SphereOverlap", &ScriptPhysics::internal_SphereOverlap);
+		metaData.scriptClass->addInternalCall("Internal_CapsuleOverlap", &ScriptPhysics::internal_CapsuleOverlap);
+		metaData.scriptClass->addInternalCall("Internal_ConvexOverlap", &ScriptPhysics::internal_ConvexOverlap);
+
+		metaData.scriptClass->addInternalCall("Internal_BoxOverlapAny", &ScriptPhysics::internal_BoxOverlapAny);
+		metaData.scriptClass->addInternalCall("Internal_SphereOverlapAny", &ScriptPhysics::internal_SphereOverlapAny);
+		metaData.scriptClass->addInternalCall("Internal_CapsuleOverlapAny", &ScriptPhysics::internal_CapsuleOverlapAny);
+		metaData.scriptClass->addInternalCall("Internal_ConvexOverlapAny", &ScriptPhysics::internal_ConvexOverlapAny);
+	}
+
+	void ScriptPhysics::internal_GetGravity(Vector3* gravity)
+	{
+		*gravity = gPhysics().getGravity();
+	}
+
+	void ScriptPhysics::internal_SetGravity(Vector3* gravity)
+	{
+		gPhysics().setGravity(*gravity);
+	}
+
+	int ScriptPhysics::internal_AddPhysicsRegion(AABox* region)
+	{
+		return gPhysics().addBroadPhaseRegion(*region);
+	}
+
+	void ScriptPhysics::internal_RemovePhysicsRegion(int handle)
+	{
+		gPhysics().removeBroadPhaseRegion(handle);
+	}
+
+	void ScriptPhysics::internal_ClearPhysicsRegions()
+	{
+		gPhysics().clearBroadPhaseRegions();
+	}
+
+	void ScriptPhysics::internal_ToggleCollision(UINT64 layerA, UINT64 layerB, bool enabled)
+	{
+		gPhysics().toggleCollision(layerA, layerB, enabled);
+	}
+
+	bool ScriptPhysics::internal_IsCollisionEnabled(UINT64 layerA, UINT64 layerB)
+	{
+		return gPhysics().isCollisionEnabled(layerA, layerB);
+	}
+
+	bool ScriptPhysics::internal_IsUpdateInProgress()
+	{
+		return gPhysics()._isUpdateInProgress();
+	}
+
+	bool ScriptPhysics::internal_RayCast(Vector3* origin, Vector3* unitDir, ScriptPhysicsQueryHit* hit, UINT64 layer, float max)
+	{
+		PhysicsQueryHit nativeHit;
+		bool wasHit = gPhysics().rayCast(*origin, *unitDir, nativeHit, layer, max);
+		*hit = ScriptPhysicsQueryHitHelper::create(nativeHit);
+
+		return wasHit;
+	}
+
+	bool ScriptPhysics::internal_BoxCast(AABox* box, Quaternion* rotation, Vector3* unitDir, ScriptPhysicsQueryHit* hit, UINT64 layer, float max)
+	{
+		PhysicsQueryHit nativeHit;
+		bool wasHit = gPhysics().boxCast(*box, *rotation, *unitDir, nativeHit, layer, max);
+		*hit = ScriptPhysicsQueryHitHelper::create(nativeHit);
+
+		return wasHit;
+	}
+
+	bool ScriptPhysics::internal_SphereCast(Sphere* sphere, Vector3* unitDir, ScriptPhysicsQueryHit* hit, UINT64 layer, float max)
+	{
+		PhysicsQueryHit nativeHit;
+		bool wasHit = gPhysics().sphereCast(*sphere, *unitDir, nativeHit, layer, max);
+		*hit = ScriptPhysicsQueryHitHelper::create(nativeHit);
+
+		return wasHit;
+	}
+
+	bool ScriptPhysics::internal_CapsuleCast(Capsule* capsule, Quaternion* rotation, Vector3* unitDir, ScriptPhysicsQueryHit* hit, UINT64 layer, float max)
+	{
+		PhysicsQueryHit nativeHit;
+		bool wasHit = gPhysics().capsuleCast(*capsule, *rotation, *unitDir, nativeHit, layer, max);
+		*hit = ScriptPhysicsQueryHitHelper::create(nativeHit);
+
+		return wasHit;
+	}
+
+	bool ScriptPhysics::internal_ConvexCast(ScriptPhysicsMesh* mesh, Vector3* position, Quaternion* rotation, Vector3* unitDir, ScriptPhysicsQueryHit* hit, UINT64 layer, float max)
+	{
+		HPhysicsMesh meshHandle;
+		if (mesh != nullptr)
+			meshHandle = mesh->getHandle();
+
+		PhysicsQueryHit nativeHit;
+		bool wasHit = gPhysics().convexCast(meshHandle, *position, *rotation, *unitDir, nativeHit, layer, max);
+		*hit = ScriptPhysicsQueryHitHelper::create(nativeHit);
+
+		return wasHit;
+	}
+
+	MonoArray* nativeToManagedHitArray(const Vector<PhysicsQueryHit>& hits)
+	{
+		UINT32 numHits = (UINT32)hits.size();
+		ScriptArray output = ScriptArray::create<ScriptPhysicsQueryHitHelper>(numHits);
+
+		for (UINT32 i = 0; i < numHits; i++)
+			output.set(i, ScriptPhysicsQueryHitHelper::create(hits[i]));
+
+		return output.getInternal();
+	}
+
+	MonoArray* ScriptPhysics::internal_RayCastAll(Vector3* origin, Vector3* unitDir, UINT64 layer, float max)
+	{
+		return nativeToManagedHitArray(gPhysics().rayCastAll(*origin, *unitDir, layer, max));
+	}
+
+	MonoArray* ScriptPhysics::internal_BoxCastAll(AABox* box, Quaternion* rotation, Vector3* unitDir, UINT64 layer, float max)
+	{
+		return nativeToManagedHitArray(gPhysics().boxCastAll(*box, *rotation, *unitDir, layer, max));
+	}
+
+	MonoArray* ScriptPhysics::internal_SphereCastAll(Sphere* sphere, Vector3* unitDir, UINT64 layer, float max)
+	{
+		return nativeToManagedHitArray(gPhysics().sphereCastAll(*sphere, *unitDir, layer, max));
+	}
+
+	MonoArray* ScriptPhysics::internal_CapsuleCastAll(Capsule* capsule, Quaternion* rotation, Vector3* unitDir, UINT64 layer, float max)
+	{
+		return nativeToManagedHitArray(gPhysics().capsuleCastAll(*capsule, *rotation, *unitDir, layer, max));
+	}
+
+	MonoArray* ScriptPhysics::internal_ConvexCastAll(ScriptPhysicsMesh* mesh, Vector3* position, Quaternion* rotation, Vector3* unitDir, UINT64 layer, float max)
+	{
+		HPhysicsMesh meshHandle;
+		if (mesh != nullptr)
+			meshHandle = mesh->getHandle();
+
+		return nativeToManagedHitArray(gPhysics().convexCastAll(meshHandle, *position, *rotation, *unitDir, layer, max));
+	}
+
+	bool ScriptPhysics::internal_RayCastAny(Vector3* origin, Vector3* unitDir, UINT64 layer, float max)
+	{
+		return gPhysics().rayCastAny(*origin, *unitDir, layer, max);
+	}
+
+	bool ScriptPhysics::internal_BoxCastAny(AABox* box, Quaternion* rotation, Vector3* unitDir, UINT64 layer, float max)
+	{
+		return gPhysics().boxCastAny(*box, *rotation, *unitDir, layer, max);
+	}
+
+	bool ScriptPhysics::internal_SphereCastAny(Sphere* sphere, Vector3* unitDir, UINT64 layer, float max)
+	{
+		return gPhysics().sphereCastAny(*sphere, *unitDir, layer, max);
+	}
+
+	bool ScriptPhysics::internal_CapsuleCastAny(Capsule* capsule, Quaternion* rotation, Vector3* unitDir, UINT64 layer, float max)
+	{
+		return gPhysics().capsuleCastAny(*capsule, *rotation, *unitDir, layer, max);
+	}
+
+	bool ScriptPhysics::internal_ConvexCastAny(ScriptPhysicsMesh* mesh, Vector3* position, Quaternion* rotation, Vector3* unitDir, UINT64 layer, float max)
+	{
+		HPhysicsMesh meshHandle;
+		if (mesh != nullptr)
+			meshHandle = mesh->getHandle();
+
+		return gPhysics().convexCastAny(meshHandle, *position, *rotation, *unitDir, layer, max);
+	}
+
+	MonoArray* nativeToManagedColliderArray(const Vector<Collider*>& colliders)
+	{
+		UINT32 numColliders = (UINT32)colliders.size();
+		ScriptArray output = ScriptArray::create<ScriptCollider>(numColliders);
+		for (UINT32 i = 0; i < numColliders; i++)
+			output.set(i, colliders[i]->_getOwner(PhysicsOwnerType::Script));
+
+		return output.getInternal();
+	}
+
+	MonoArray* ScriptPhysics::internal_BoxOverlap(AABox* box, Quaternion* rotation, UINT64 layer)
+	{
+		return nativeToManagedColliderArray(gPhysics()._boxOverlap(*box, *rotation, layer));
+	}
+
+	MonoArray* ScriptPhysics::internal_SphereOverlap(Sphere* sphere, UINT64 layer)
+	{
+		return nativeToManagedColliderArray(gPhysics()._sphereOverlap(*sphere, layer));
+	}
+
+	MonoArray* ScriptPhysics::internal_CapsuleOverlap(Capsule* capsule, Quaternion* rotation, UINT64 layer)
+	{
+		return nativeToManagedColliderArray(gPhysics()._capsuleOverlap(*capsule, *rotation, layer));
+	}
+
+	MonoArray* ScriptPhysics::internal_ConvexOverlap(ScriptPhysicsMesh* mesh, Vector3* position, Quaternion* rotation, UINT64 layer)
+	{
+		HPhysicsMesh meshHandle;
+		if (mesh != nullptr)
+			meshHandle = mesh->getHandle();
+
+		return nativeToManagedColliderArray(gPhysics()._convexOverlap(meshHandle, *position, *rotation, layer));
+	}
+
+	bool ScriptPhysics::internal_BoxOverlapAny(AABox* box, Quaternion* rotation, UINT64 layer)
+	{
+		return gPhysics().boxOverlapAny(*box, *rotation, layer);
+	}
+
+	bool ScriptPhysics::internal_SphereOverlapAny(Sphere* sphere, UINT64 layer)
+	{
+		return gPhysics().sphereOverlapAny(*sphere, layer);
+	}
+
+	bool ScriptPhysics::internal_CapsuleOverlapAny(Capsule* capsule, Quaternion* rotation, UINT64 layer)
+	{
+		return gPhysics().capsuleOverlapAny(*capsule, *rotation, layer);
+	}
+
+	bool ScriptPhysics::internal_ConvexOverlapAny(ScriptPhysicsMesh* mesh, Vector3* position, Quaternion* rotation, UINT64 layer)
+	{
+		HPhysicsMesh meshHandle;
+		if (mesh != nullptr)
+			meshHandle = mesh->getHandle();
+
+		return gPhysics().convexOverlapAny(meshHandle, *position, *rotation, layer);
+	}
 }