Scene view refactor (moving it to C#)

BansheeCore/Include/BsInput.h

@@ -136,6 +136,11 @@ namespace BansheeEngine
 		 */
 		Vector2I getPointerPosition() const;
 
+		/**
+		 * @brief	Returns difference between last and current pointer position.
+		 */
+		Vector2I getPointerDelta() const { return mPointerDelta; }
+
 		/**
 		 * @brief	Enables or disables mouse smoothing. Smoothing makes the changes to
 		 *			mouse axes more gradual.
@@ -199,6 +204,8 @@ namespace BansheeEngine
 
 		Vector<DeviceData> mDevices;
 		Vector2I mPointerPosition;
+		Vector2I mPointerDelta;
+		bool mLastPositionSet;
 
 		/************************************************************************/
 		/* 								STATICS		                      		*/

BansheeCore/Include/BsInputFwd.h

@@ -312,6 +312,7 @@ namespace BansheeEngine
 		}
 
 		Vector2I screenPos; /**< Screen position where the input event occurred. */
+		Vector2I delta; /**< Change in movement since last sent event. */
 		bool buttonStates[(UINT32)PointerEventButton::Count]; /**< States of the pointer buttons (e.g. mouse buttons). */
 		PointerEventButton button; /**< Button that triggered the pointer event. Might be irrelevant 
 										depending on event type. (e.g. move events don't correspond to a button. */

BansheeCore/Include/BsOSInputHandler.h

@@ -99,6 +99,8 @@ namespace BansheeEngine
 		BS_MUTEX(mOSInputMutex);
 		Vector2I mLastCursorPos;
 		Vector2I mCursorPosition;
+		Vector2I mDelta;
+		bool mLastCursorPosSet;
 		float mMouseScroll;
 		WString mInputString;
 		Queue<ButtonStateChange> mButtonStates;

BansheeCore/Source/BsCoreApplication.cpp

@@ -239,6 +239,21 @@ namespace BansheeEngine
 			gProfilerCPU().endThread();
 			gProfiler()._update();
 		}
+
+		// Wait until last core frame is finished before exiting
+		{
+			BS_LOCK_MUTEX_NAMED(mFrameRenderingFinishedMutex, lock);
+
+			while (!mIsFrameRenderingFinished)
+			{
+				TaskScheduler::instance().addWorker();
+				BS_THREAD_WAIT(mFrameRenderingFinishedCondition, mFrameRenderingFinishedMutex, lock);
+				TaskScheduler::instance().removeWorker();
+			}
+		}
+
+		// One final sync in order to dealloc anything that was queued for sync from core
+		CoreObjectManager::instance().syncUpload(CoreObjectSync::Core);
 	}
 
 	void CoreApplication::update()

BansheeCore/Source/BsInput.cpp

@@ -19,6 +19,7 @@ namespace BansheeEngine
 	}
 
 	Input::Input()
+		:mLastPositionSet(false)
 	{ 
 		mOSInputHandler = bs_shared_ptr<OSInputHandler>();
 
@@ -146,7 +147,11 @@ namespace BansheeEngine
 		if(!onPointerMoved.empty())
 			onPointerMoved(event);
 
+		if (mLastPositionSet)
+			mPointerDelta = event.screenPos - mPointerPosition;
+
 		mPointerPosition = event.screenPos;
+		mLastPositionSet = true;
 	}
 
 	void Input::cursorPressed(const PointerEvent& event)

BansheeCore/Source/BsOSInputHandler.cpp

@@ -8,7 +8,7 @@ using namespace std::placeholders;
 namespace BansheeEngine
 {
 	OSInputHandler::OSInputHandler()
-		:mMouseScroll(0.0f)
+		:mMouseScroll(0.0f), mLastCursorPosSet(false)
 	{
 		mCharInputConn = Platform::onCharInput.connect(std::bind(&OSInputHandler::charInput, this, _1));
 		mCursorMovedConn = Platform::onCursorMoved.connect(std::bind(&OSInputHandler::cursorMoved, this, _1, _2));
@@ -78,10 +78,14 @@ namespace BansheeEngine
 				event.type = PointerEventType::CursorMoved;
 				event.screenPos = mousePosition;
 
+				if (mLastCursorPosSet)
+					event.delta = mousePosition - mLastCursorPos;
+
 				onCursorMoved(event);
 			}
 
 			mLastCursorPos = mousePosition;
+			mLastCursorPosSet = true;
 		}
 
 		while(!buttonStates.empty())

BansheeCore/Source/BsViewport.cpp

@@ -155,8 +155,12 @@ namespace BansheeEngine
 
 	SPtr<CoreObjectCore> Viewport::createCore() const
 	{
+		SPtr<RenderTargetCore> targetCore;
+		if (mTarget != nullptr)
+			targetCore = mTarget->getCore();
+
 		ViewportCore* viewport = new (bs_alloc<Viewport>()) 
-			ViewportCore(mTarget->getCore(), mNormArea.x, mNormArea.y, mNormArea.width, mNormArea.height);
+			ViewportCore(targetCore, mNormArea.x, mNormArea.y, mNormArea.width, mNormArea.height);
 
 		SPtr<ViewportCore> viewportPtr = bs_shared_ptr<ViewportCore, GenAlloc>(viewport);
 		viewportPtr->_setThisPtr(viewportPtr);

BansheeEditor/Include/BsEditorWidget.h

@@ -17,6 +17,7 @@ namespace BansheeEngine
 		UINT32 getWidth() const { return mWidth; }
 		UINT32 getHeight() const { return mHeight; }
 		bool hasFocus() const { return mHasFocus; }
+		EditorWindowBase* getParentWindow() const;
 
 		void _setSize(UINT32 width, UINT32 height);
 		void _setPosition(INT32 x, INT32 y);

BansheeEditor/Include/BsHandleManager.h

@@ -12,7 +12,7 @@ namespace BansheeEngine
 		HandleManager();
 		virtual ~HandleManager();
 
-		void update(const CameraHandlerPtr& camera, const Vector2I& inputPos);
+		void update(const CameraHandlerPtr& camera, const Vector2I& inputPos, const Vector2I& inputDelta);
 		void trySelect(const CameraHandlerPtr& camera, const Vector2I& inputPos);
 		void clearSelection();
 		bool isHandleActive() const;

BansheeEditor/Include/BsHandleSlider.h

@@ -21,7 +21,7 @@ namespace BansheeEngine
 		virtual ~HandleSlider() { }
 
 		virtual bool intersects(const Ray& ray, float& t) const = 0;
-		virtual void handleInput(const CameraHandlerPtr& camera, const Vector2I& pointerPos, const Ray& ray) = 0;
+		virtual void handleInput(const CameraHandlerPtr& camera, const Vector2I& inputDelta) = 0;
 		void update(const CameraHandlerPtr& camera);
 
 		State getState() const { return mState; }
@@ -35,19 +35,18 @@ namespace BansheeEngine
 		const Quaternion& getRotation() const { return mRotation; }
 		const Vector3& getScale() const { return mScale; }
 
-		float getDelta() const;
-		void reset();
-
 	protected:
 		friend class HandleSliderManager;
 
-		void setInactive() { mState = State::Inactive; reset(); }
-		void setActive(const Vector2I& pointerPos) { mState = State::Active; mLastPointerPos = pointerPos; }
-		void setHover() { mState = State::Hover; reset(); }
+		void setInactive();
+		void setActive(const CameraHandlerPtr& camera, const Vector2I& pointerPos);
+		void setHover();
 
 		const Matrix4& getTransform() const;
 		const Matrix4& getTransformInv() const;
 
+		virtual void activate(const CameraHandlerPtr& camera, const Vector2I& pointerPos) { }
+		virtual void reset() { }
 		virtual void updateCachedTransform() const;
 
 		float calcDelta(const CameraHandlerPtr& camera, const Vector3& position, const Vector3& direction,
@@ -60,13 +59,10 @@ namespace BansheeEngine
 		Vector3 mScale;
 		float mDistanceScale;
 
-		Vector2I mLastPointerPos;
-		Vector2I mCurPointerPos;
+		Vector2I mStartPointerPos;
+		Vector2I mCurrentPointerPos;
 		State mState;
 
-		float mDelta;
-		bool mHasLastPos;
-
 		mutable bool mTransformDirty;
 		mutable Matrix4 mTransform;
 		mutable Matrix4 mTransformInv;

BansheeEditor/Include/BsHandleSliderDisc.h

@@ -13,20 +13,30 @@ namespace BansheeEngine
 		~HandleSliderDisc();
 
 		bool intersects(const Ray& ray, float& t) const;
-		void handleInput(const CameraHandlerPtr& camera, const Vector2I& pointerPos, const Ray& ray);
+		void handleInput(const CameraHandlerPtr& camera, const Vector2I& inputDelta);
 
-		Vector3 getDeltaDirection() const { return Vector3::ZERO; /* TODO */ }
-		Quaternion getNewRotation() const { return mRotation; /* TODO */ }
+		float getDelta() const { return mDelta; }
 
 	protected:
+		void activate(const CameraHandlerPtr& camera, const Vector2I& pointerPos);
+		void reset() { mDelta = 0.0f; }
 		virtual void updateCachedTransform() const;
 
+		Vector3 calculateClosestPointOnArc(const Ray& inputRay, const Vector3& center, const Vector3& up,
+			float radius, Degree startAngle, Degree angleAmount);
+
+		Degree pointOnCircleToAngle(Vector3 up, Vector3 point);
+
 		static const float TORUS_RADIUS;
 
 		Vector3 mNormal;
 		float mRadius;
 		Matrix4 mTorusRotation;
 
+		Vector3 mDirection;
+		Vector3 mStartPosition;
+		float mDelta;
+
 		Torus mCollider;
 	};
 }

BansheeEditor/Include/BsHandleSliderLine.h

@@ -14,11 +14,13 @@ namespace BansheeEngine
 		~HandleSliderLine();
 
 		bool intersects(const Ray& ray, float& t) const;
-		void handleInput(const CameraHandlerPtr& camera, const Vector2I& pointerPos, const Ray& ray);
+		void handleInput(const CameraHandlerPtr& camera, const Vector2I& inputDelta);
 
-		Vector3 getNewPosition() const;
+		float getDelta() const { return mDelta; }
 
 	protected:
+		void activate(const CameraHandlerPtr& camera, const Vector2I& pointerPos) { mStartPosition = getPosition(); }
+		void reset() { mDelta = 0.0f; }
 
 		static const float CAPSULE_RADIUS;
 		static const float SPHERE_RADIUS;
@@ -26,6 +28,9 @@ namespace BansheeEngine
 		Vector3 mDirection;
 		float mLength;
 
+		float mDelta;
+		Vector3 mStartPosition;
+
 		Capsule mCapsuleCollider;
 		Sphere mSphereCollider;
 	};

BansheeEditor/Include/BsHandleSliderManager.h

@@ -10,7 +10,7 @@ namespace BansheeEngine
 		HandleSliderManager();
 		~HandleSliderManager();
 
-		void update(const CameraHandlerPtr& camera, const Vector2I& inputPos);
+		void update(const CameraHandlerPtr& camera, const Vector2I& inputPos, const Vector2I& inputDelta);
 		void trySelect(const CameraHandlerPtr& camera, const Vector2I& inputPos);
 		void clearSelection();
 		bool isSliderActive() const { return mActiveSlider != nullptr; }

BansheeEditor/Include/BsHandleSliderPlane.h

@@ -3,6 +3,7 @@
 #include "BsEditorPrerequisites.h"
 #include "BsHandleSlider.h"
 #include "BsRect3.h"
+#include "BsVector2.h"
 
 namespace BansheeEngine
 {
@@ -13,19 +14,20 @@ namespace BansheeEngine
 		~HandleSliderPlane();
 
 		bool intersects(const Ray& ray, float& t) const;
-		void handleInput(const CameraHandlerPtr& camera, const Vector2I& pointerPos, const Ray& ray);
-
-		Vector3 getDeltaDirection() const { return Vector3::ZERO; /* TODO */ }
-		Vector3 getNewPosition() const { return mPosition; /* TODO */ }
+		void handleInput(const CameraHandlerPtr& camera, const Vector2I& inputDelta);
 
+		Vector2 getDelta() const { return mDelta; }
 	protected:
+		void activate(const CameraHandlerPtr& camera, const Vector2I& pointerPos) { mStartPosition = getPosition(); }
+		void reset() { mDelta = Vector2::ZERO; }
+
 		Vector3 mDirection1;
 		Vector3 mDirection2;
 		float mLength;
 
 		Rect3 mCollider;
 
-		float mDelta;
-		bool mHasLastPos;
+		Vector2 mDelta;
+		Vector3 mStartPosition;
 	};
 }

BansheeEditor/Include/BsSceneViewHandler.h

@@ -7,17 +7,20 @@ namespace BansheeEngine
 	class BS_ED_EXPORT SceneViewHandler
 	{
 	public:
-		SceneViewHandler(const SPtr<CameraHandler>& camera);
+		SceneViewHandler(const EditorWidgetBase* parentWidget, const SPtr<CameraHandler>& camera);
 		virtual ~SceneViewHandler();
 
-		void update(const Vector2I& position);
+		void update(const Vector2I& position, const Vector2I& delta);
 		void pointerPressed(const Vector2I& position);
 		void pointerReleased(const Vector2I& position, bool controlHeld);
 
 	protected:
 		void render(const Viewport* viewport, DrawList& drawList);
 
+		void wrapCursorToWindow();
+
 	private:
+		EditorWidgetBase* mParentWidget;
 		SPtr<CameraHandler> mCamera;
 		SceneGrid* mSceneGrid;
 		HEvent mRenderCallback;

BansheeEditor/Source/BsEditorWidget.cpp

@@ -25,6 +25,11 @@ namespace BansheeEngine
 			GUIArea::destroy(mContent);
 	}
 
+	EditorWindowBase* EditorWidgetBase::getParentWindow() const
+	{
+		return mParent->getParentWindow();
+	}
+
 	void EditorWidgetBase::close()
 	{
 		EditorWidgetManager::instance().close(this);

BansheeEditor/Source/BsGizmoManager.cpp

@@ -715,6 +715,9 @@ namespace BansheeEngine
 
 	void GizmoManagerCore::render(const CameraHandlerCore& camera)
 	{
+		if (mSceneRenderTarget == nullptr)
+			return;
+
 		SPtr<RenderTargetCore> sceneRenderTarget = mSceneRenderTarget->getCore();
 
 		if (camera.getViewport()->getTarget() != sceneRenderTarget)

BansheeEditor/Source/BsHandleDrawManager.cpp

@@ -214,6 +214,9 @@ namespace BansheeEngine
 	{
 		THROW_IF_NOT_CORE_THREAD;
 
+		if (mSceneRenderTarget == nullptr)
+			return;
+
 		SPtr<RenderTargetCore> sceneRenderTarget = mSceneRenderTarget->getCore();
 		if (camera.getViewport()->getTarget() != sceneRenderTarget)
 			return;

BansheeEditor/Source/BsHandleManager.cpp

@@ -25,13 +25,13 @@ namespace BansheeEngine
 		return mSliderManager->isSliderActive();
 	}
 
-	void HandleManager::update(const CameraHandlerPtr& camera, const Vector2I& inputPos)
+	void HandleManager::update(const CameraHandlerPtr& camera, const Vector2I& inputPos, const Vector2I& inputDelta)
 	{
 		if (mSettings != nullptr && mSettingsHash != mSettings->getHash())
 			updateFromProjectSettings();
 
 		refreshHandles();
-		mSliderManager->update(camera, inputPos);
+		mSliderManager->update(camera, inputPos, inputDelta);
 		triggerHandles();
 
 		queueDrawCommands();

BansheeEditor/Source/BsHandleSlider.cpp

@@ -6,7 +6,7 @@ namespace BansheeEngine
 {
 	HandleSlider::HandleSlider(bool fixedScale)
 		:mFixedScale(fixedScale), mScale(Vector3::ONE), mTransformDirty(true),
-		mDistanceScale(1.0f), mDelta(0.0f), mHasLastPos(false)
+		mDistanceScale(1.0f)
 	{
 
 	}
@@ -62,15 +62,24 @@ namespace BansheeEngine
 		mTransformDirty = false;
 	}
 
-	void HandleSlider::reset()
-	{
-		mDelta = 0.0f;
-		mHasLastPos = false;
+	void HandleSlider::setInactive() 
+	{ 
+		mState = State::Inactive; 
+		reset(); 
 	}
 
-	float HandleSlider::getDelta() const
-	{
-		return mDelta;
+	void HandleSlider::setActive(const CameraHandlerPtr& camera, const Vector2I& pointerPos)
+	{ 
+		mState = State::Active; 
+		mStartPointerPos = pointerPos; 
+		mCurrentPointerPos = pointerPos;
+		activate(camera, pointerPos);
+	}
+
+	void HandleSlider::setHover() 
+	{ 
+		mState = State::Hover; 
+		reset(); 
 	}
 
 	float HandleSlider::calcDelta(const CameraHandlerPtr& camera, const Vector3& position, const Vector3& direction,

BansheeEditor/Source/BsHandleSliderDisc.cpp

@@ -4,13 +4,14 @@
 #include "BsRay.h"
 #include "BsVector3.h"
 #include "BsQuaternion.h"
+#include "BsCamera.h"
 
 namespace BansheeEngine
 {
 	const float HandleSliderDisc::TORUS_RADIUS = 0.5f;
 
 	HandleSliderDisc::HandleSliderDisc(const Vector3& normal, float radius, bool fixedScale)
-		:HandleSlider(fixedScale), mRadius(radius)
+		:HandleSlider(fixedScale), mRadius(radius), mDelta(0.0f)
 	{
 		Vector3 x, z;
 		mNormal.orthogonalComplement(x, z);
@@ -58,18 +59,108 @@ namespace BansheeEngine
 		return false;
 	}
 
-	void HandleSliderDisc::handleInput(const CameraHandlerPtr& camera, const Vector2I& pointerPos, const Ray& ray)
+	Vector3 HandleSliderDisc::calculateClosestPointOnArc(const Ray& inputRay, const Vector3& center, const Vector3& up,
+		float radius, Degree startAngle, Degree angleAmount)
 	{
-		assert(getState() == State::Active);
+		Vector3 arcBasis[3];
+		arcBasis[1] = up;
+		arcBasis[1].orthogonalComplement(arcBasis[2], arcBasis[0]);
+
+		Matrix4 worldToPlane = Matrix4::IDENTITY;
+		worldToPlane.setColumn(0, (Vector4)arcBasis[0]);
+		worldToPlane.setColumn(1, (Vector4)arcBasis[1]);
+		worldToPlane.setColumn(2, (Vector4)arcBasis[2]);
+		worldToPlane.setColumn(3, (Vector4)worldToPlane.multiplyAffine(-center));
+		worldToPlane[3][3] = 1;
+
+		Plane plane(up, (-center).dot(up));
+		Vector3 pointOnPlane;
+
+		auto intersectResult = plane.intersects(inputRay);
+
+		float t = 0.0f;
+		if (intersectResult.second)
+			pointOnPlane = inputRay.getPoint(intersectResult.first);
+		else
+			pointOnPlane = Vector3::ZERO;
+
+		pointOnPlane = worldToPlane.multiplyAffine(pointOnPlane);
+		Vector2 pointOnPlane2D(pointOnPlane.x, pointOnPlane.z); // y always 0
+
+		Vector2 closestPoint2D;
+		float dist = pointOnPlane2D.length();
+		if (dist > 0.0f)
+			closestPoint2D = mRadius * (pointOnPlane2D / dist);
+		else
+			closestPoint2D = Vector2(mRadius, 0);
+
+		Radian angle = Math::atan2(-closestPoint2D.y, -closestPoint2D.x) + Math::PI;
 
-		mLastPointerPos = mCurPointerPos;
-		mCurPointerPos = pointerPos;
+		float angleRad = angle.valueRadians();
+		float startAngleRad = startAngle.wrap().valueRadians();
+		float endAngleRad = (startAngle + angleAmount).wrap().valueRadians();
 
-		if (mHasLastPos)
+		float clampedAngle;
+		if (startAngleRad <= endAngleRad)
+			clampedAngle = Math::clamp(angleRad, startAngleRad, endAngleRad);
+		else
 		{
-			// TODO
+			if ((angleRad < startAngleRad) && (angleRad > endAngleRad))
+			{
+				if ((startAngleRad - angleRad) > (angleRad - endAngleRad))
+					clampedAngle = endAngleRad;
+				else
+					clampedAngle = startAngleRad;
+			}
+			else
+				clampedAngle = angleRad;
 		}
-		
-		mHasLastPos = false;
+
+		Vector3 clampedAnglePoint;
+		clampedAnglePoint.x = Math::cos(clampedAngle) * radius;
+		clampedAnglePoint.z = Math::sin(clampedAngle) * radius;
+
+		return worldToPlane.inverseAffine().multiplyAffine(clampedAnglePoint);
+	}
+
+	Degree HandleSliderDisc::pointOnCircleToAngle(Vector3 up, Vector3 point)
+	{
+		Vector3 arcBasis[3];
+		arcBasis[1] = up;
+		arcBasis[1].orthogonalComplement(arcBasis[2], arcBasis[0]);
+
+		Matrix4 worldToPlane = Matrix4::IDENTITY;
+		worldToPlane.setColumn(0, (Vector4)arcBasis[0]);
+		worldToPlane.setColumn(1, (Vector4)arcBasis[1]);
+		worldToPlane.setColumn(2, (Vector4)arcBasis[2]);
+
+		point = worldToPlane.multiplyAffine(point);
+
+		return Radian(Math::atan2(-point.z, -point.x) + Math::PI);
+	}
+
+	void HandleSliderDisc::activate(const CameraHandlerPtr& camera, const Vector2I& pointerPos)
+	{
+		Ray localRay = camera->screenPointToRay(pointerPos);
+		localRay.transformAffine(getTransformInv());
+
+		Quaternion camLocalRotation = camera->getRotation() * getRotation().inverse();
+
+		Vector3 startDir = camLocalRotation.zAxis().cross(mNormal);
+		Degree startAngle = pointOnCircleToAngle(mNormal, startDir);
+
+		mStartPosition = calculateClosestPointOnArc(localRay, Vector3::ZERO, mNormal, mRadius, startAngle, Degree(180.0f));
+		mStartPosition = getTransform().multiplyAffine(mStartPosition);
+
+		mDirection = mNormal.cross(mStartPosition - getPosition());
+		mDirection.normalize();
+	}
+
+	void HandleSliderDisc::handleInput(const CameraHandlerPtr& camera, const Vector2I& inputDelta)
+	{
+		assert(getState() == State::Active);
+
+		mCurrentPointerPos += inputDelta;
+		mDelta = calcDelta(camera, mStartPosition, mDirection, mStartPointerPos, mCurrentPointerPos);
 	}
 }

BansheeEditor/Source/BsHandleSliderLine.cpp

@@ -12,7 +12,7 @@ namespace BansheeEngine
 	const float HandleSliderLine::SPHERE_RADIUS = 0.2f;
 
 	HandleSliderLine::HandleSliderLine(const Vector3& direction, float length, bool fixedScale)
-		:HandleSlider(fixedScale), mLength(length)
+		:HandleSlider(fixedScale), mLength(length), mDelta(0.0f)
 	{
 		mDirection = Vector3::normalize(direction);
 
@@ -63,21 +63,11 @@ namespace BansheeEngine
 		return gotIntersect;
 	}
 
-	void HandleSliderLine::handleInput(const CameraHandlerPtr& camera, const Vector2I& pointerPos, const Ray& ray)
+	void HandleSliderLine::handleInput(const CameraHandlerPtr& camera, const Vector2I& inputDelta)
 	{
 		assert(getState() == State::Active);
 
-		mLastPointerPos = mCurPointerPos;
-		mCurPointerPos = pointerPos;
-
-		if (mHasLastPos)
-			mDelta = calcDelta(camera, getPosition(), mDirection, mLastPointerPos, mCurPointerPos);
-
-		mHasLastPos = true;
-	}
-
-	Vector3 HandleSliderLine::getNewPosition() const
-	{
-		return getPosition() + mDirection * getDelta();
+		mCurrentPointerPos += inputDelta;
+		mDelta = calcDelta(camera, mStartPosition, getTransform().multiplyAffine(mDirection), mStartPointerPos, mCurrentPointerPos);
 	}
 }

BansheeEditor/Source/BsHandleSliderManager.cpp

@@ -24,15 +24,14 @@ namespace BansheeEngine
 
 	}
 
-	void HandleSliderManager::update(const CameraHandlerPtr& camera, const Vector2I& inputPos)
+	void HandleSliderManager::update(const CameraHandlerPtr& camera, const Vector2I& inputPos, const Vector2I& inputDelta)
 	{
 		for (auto& slider : mSliders)
 			slider->update(camera);
 
 		if (mActiveSlider != nullptr)
 		{
-			Ray inputRay = camera->screenPointToRay(inputPos);
-			mActiveSlider->handleInput(camera, inputPos, inputRay);
+			mActiveSlider->handleInput(camera, inputDelta);
 		}
 		else
 		{
@@ -76,7 +75,7 @@ namespace BansheeEngine
 			if (newActiveSlider != nullptr)
 			{
 				mActiveSlider = newActiveSlider;
-				mActiveSlider->setActive(inputPos);
+				mActiveSlider->setActive(camera, inputPos);
 			}
 		}
 	}

BansheeEditor/Source/BsHandleSliderPlane.cpp

@@ -45,18 +45,12 @@ namespace BansheeEngine
 		return false;
 	}
 
-	void HandleSliderPlane::handleInput(const CameraHandlerPtr& camera, const Vector2I& pointerPos, const Ray& ray)
+	void HandleSliderPlane::handleInput(const CameraHandlerPtr& camera, const Vector2I& inputDelta)
 	{
 		assert(getState() == State::Active);
 
-		mLastPointerPos = mCurPointerPos;
-		mCurPointerPos = pointerPos;
-
-		if (mHasLastPos)
-		{
-			// TODO
-		}
-		
-		mHasLastPos = true;
+		mCurrentPointerPos += inputDelta;
+		mDelta.x = calcDelta(camera, mStartPosition, getRotation().rotate(mDirection1), mStartPointerPos, mCurrentPointerPos);
+		mDelta.y = calcDelta(camera, mStartPosition, getRotation().rotate(mDirection2), mStartPointerPos, mCurrentPointerPos);
 	}
 }

BansheeEditor/Source/BsSceneViewHandler.cpp

@@ -8,12 +8,16 @@
 #include "BsScenePicking.h"
 #include "BsCameraHandler.h"
 #include "BsEditorApplication.h"
+#include "BsEditorWidget.h"
+#include "BsEditorWindowBase.h"
+#include "BsRenderWindow.h"
+#include "BsCursor.h"
 
 using namespace std::placeholders;
 
 namespace BansheeEngine
 {
-	SceneViewHandler::SceneViewHandler(const SPtr<CameraHandler>& camera)
+	SceneViewHandler::SceneViewHandler(const EditorWidgetBase* parentWidget, const SPtr<CameraHandler>& camera)
 		:mCamera(camera), mSceneGrid(nullptr)
 	{
 		mRenderCallback = RendererManager::instance().getActive()->onRenderViewport.connect(std::bind(&SceneViewHandler::render, this, _1, _2));
@@ -26,13 +30,17 @@ namespace BansheeEngine
 		bs_delete(mSceneGrid);
 		mRenderCallback.disconnect();
 
-		GizmoManager::instance().clearRenderData();
+		if (GizmoManager::isStarted()) // If not active, we don't care
+			GizmoManager::instance().clearRenderData();
 	}
 
-	void SceneViewHandler::update(const Vector2I& position)
+	void SceneViewHandler::update(const Vector2I& position, const Vector2I& delta)
 	{
+		if (HandleManager::instance().isHandleActive())
+			wrapCursorToWindow();
+
 		GizmoManager::instance().update(mCamera);
-		HandleManager::instance().update(mCamera, position); // TODO - Make sure these internally check ProjectSettings
+		HandleManager::instance().update(mCamera, position, delta);
 		mSceneGrid->update();
 	}
 
@@ -87,4 +95,25 @@ namespace BansheeEngine
 
 		mSceneGrid->render(mCamera, drawList);
 	}
+
+	void SceneViewHandler::wrapCursorToWindow()
+	{
+		RenderWindowPtr parentWindow = mParentWidget->getParentWindow()->_getRenderWindow();
+
+		Vector2I windowPos = parentWindow->screenToWindowPos(Cursor::instance().getScreenPosition());
+		const RenderWindowProperties& rwProps = parentWindow->getProperties();
+
+		if (windowPos.x < 0)
+			windowPos.x += rwProps.getWidth();
+		else if (windowPos.x >= (INT32)rwProps.getWidth())
+			windowPos.x -= rwProps.getWidth();
+
+		if (windowPos.y < 0)
+			windowPos.y += rwProps.getHeight();
+		else if (windowPos.y >= (INT32)rwProps.getHeight())
+			windowPos.y -= rwProps.getHeight();
+
+		Vector2I wrappedScreenPos = parentWindow->windowToScreenPos(windowPos);
+		Cursor::instance().setScreenPosition(wrappedScreenPos);
+	}
 }

BansheeEngine/Include/BsApplication.h

@@ -47,7 +47,7 @@ namespace BansheeEngine
 		 *
 		 * @note	e.g. player or game view.
 		 */
-		const ViewportPtr& getPrimaryViewport() const;
+		ViewportPtr getPrimaryViewport() const;
 
 	protected:
 		/**

BansheeEngine/Source/BsApplication.cpp

@@ -11,6 +11,7 @@
 #include "BsSceneManager.h"
 #include "BsSceneObject.h"
 #include "BsCursor.h"
+#include "BsCoreThread.h"
 
 namespace BansheeEngine
 {
@@ -63,6 +64,10 @@ namespace BansheeEngine
 		unloadPlugin(mMonoPlugin);
 #endif
 
+		// Cleanup any new objects queued for destruction by unloaded scripts
+		gCoreThread().update();
+		gCoreThread().submitAccessors(true);
+
 		Cursor::shutDown();
 
 		GUIMaterialManager::instance().clearMaterials();
@@ -95,7 +100,7 @@ namespace BansheeEngine
 		PROFILE_CALL(GUIManager::instance().update(), "GUI");
 	}
 
-	const ViewportPtr& Application::getPrimaryViewport() const
+	ViewportPtr Application::getPrimaryViewport() const
 	{
 		// TODO - Need a way to determine primary viewport!
 		return nullptr;

BansheeEngine/Source/BsCameraHandler.cpp

@@ -729,7 +729,9 @@ namespace BansheeEngine
 
 	CameraHandler::CameraHandler(RenderTargetPtr target, float left, float top, float width, float height)
 	{
-		target->blockUntilCoreInitialized();
+		if (target != nullptr)
+			target->blockUntilCoreInitialized();
+
 		mViewport = Viewport::create(target, left, top, width, height);
 	}
 

BansheeEngine/Source/BsShapeMeshes3D.cpp

@@ -928,19 +928,21 @@ namespace BansheeEngine
 	{
 		assert(numVertices >= 2);
 
+		startAngle += Degree(90.0f); // Offset so arc starts the same as trig functions
+
 		Vector3 normalizedUp = Vector3::normalize(up);
 		Vector3 right;
 
 		if (Math::abs(normalizedUp.dot(Vector3::UNIT_Z)) <= 0.95f)
-			right = normalizedUp.cross(Vector3::UNIT_Z);
+			right = Vector3::UNIT_Z.cross(normalizedUp);
 		else
-			right = normalizedUp.cross(Vector3::UNIT_Y);
+			right = Vector3::UNIT_Y.cross(normalizedUp);
 
 		right.normalize();
-		Quaternion moveToStart(up, startAngle);
+		Quaternion moveToStart(-up, startAngle);
 		Vector3 start = moveToStart.rotate(right);
 
-		Quaternion increment(up, angleAmount / (float)(numVertices - 1));
+		Quaternion increment(-up, angleAmount / (float)(numVertices - 1));
 
 		outVertices += vertexOffset * vertexStride;
 		Vector3 curDirection = start * radius;

BansheeGLRenderSystem/Source/BsGLTexture.cpp

@@ -79,13 +79,13 @@ namespace BansheeEngine
 		}
 
 		UINT32 sampleCount = mProperties.getMultisampleCount();
-		if ((usage & TU_RENDERTARGET) != 0 && mProperties.getTextureType() == TEX_TYPE_2D && sampleCount > 0)
+		if ((usage & TU_RENDERTARGET) != 0 && mProperties.getTextureType() == TEX_TYPE_2D && sampleCount > 1)
 		{
-			glTexImage2DMultisample(GL_TEXTURE_2D, sampleCount, mGLFormat, width, height, GL_FALSE);
+			glTexImage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, sampleCount, mGLFormat, width, height, GL_FALSE);
 		}
 		else if ((usage & TU_DEPTHSTENCIL) != 0)
 		{
-			if (sampleCount > 0)
+			if (sampleCount > 1)
 			{
 				glTexImage2DMultisample(GL_TEXTURE_2D, sampleCount, mGLFormat,
 					width, height, GL_FALSE);
@@ -167,7 +167,7 @@ namespace BansheeEngine
             case TEX_TYPE_1D:
                 return GL_TEXTURE_1D;
             case TEX_TYPE_2D:
-				if (mProperties.getMultisampleCount() > 0)
+				if (mProperties.getMultisampleCount() > 1)
 					return GL_TEXTURE_2D_MULTISAMPLE;
 				else
 					return GL_TEXTURE_2D;

BansheeUtility/Include/BsDegree.h

@@ -25,6 +25,11 @@ namespace BansheeEngine
 		float valueDegrees() const { return mDeg; }
 		float valueRadians() const;
 
+		/**
+		 * @brief  Wraps the angle in [0, 360) range
+		 */
+		Degree wrap();
+
 		const Degree& operator+ () const { return *this; }
 		Degree operator+ (const Degree& d) const { return Degree (mDeg + d.mDeg); }
 		Degree operator+ (const Radian& r) const;

BansheeUtility/Include/BsMatrix4.h

@@ -230,6 +230,28 @@ namespace BansheeEngine
                            m[0][3], m[1][3], m[2][3], m[3][3]);
         }
 
+		/**
+		 * @brief	Assigns the vector to a column of the matrix
+		 */
+		void setColumn(UINT32 idx, const Vector4& column)
+		{
+			m[0][idx] = column.x;
+			m[1][idx] = column.y;
+			m[2][idx] = column.z;
+			m[3][idx] = column.w;
+		}
+
+		/**
+		 * @brief	Assigns the vector to a row of the matrix
+		 */
+		void setRow(UINT32 idx, const Vector4& column)
+		{
+			m[idx][0] = column.x;
+			m[idx][1] = column.y;
+			m[idx][2] = column.z;
+			m[idx][3] = column.w;
+		}
+
         /**
          * @brief	Extracts the rotation/scaling part of the matrix as a 3x3 matrix.
          */

BansheeUtility/Include/BsModule.h

@@ -93,7 +93,7 @@ namespace BansheeEngine
 		 */
 		static void shutDown()
 		{
-			if (isShutDown())
+			if (isShutDown() || isDestroyed())
 			{
 				BS_EXCEPT(InternalErrorException, 
 					"Trying to shut down an already shut down module.");
@@ -102,7 +102,7 @@ namespace BansheeEngine
 			((Module*)_instance())->onShutDown();
 
 			bs_delete(_instance());
-			isShutDown() = true;
+			isDestroyed() = true;
 		}
 
 		/**

BansheeUtility/Include/BsRadian.h

@@ -25,6 +25,11 @@ namespace BansheeEngine
 		float valueDegrees() const;
 		float valueRadians() const { return mRad; }
 
+		/**
+		 * @brief  Wraps the angle in [0, 2 *  PI) range
+		 */
+		Radian wrap();
+
         const Radian& operator+ () const { return *this; }
 		Radian operator+ (const Radian& r) const { return Radian (mRad + r.mRad); }
 		Radian operator+ (const Degree& d) const;

BansheeUtility/Include/BsVector4.h

@@ -22,6 +22,10 @@ namespace BansheeEngine
             :x(x), y(y), z(z), w(w)
         { }
 
+		explicit Vector4(const Vector3& vec)
+			:x(vec.x), y(vec.y), z(vec.z), w(0.0f)
+		{ }
+
 		/**
 		 * @brief	Exchange the contents of this vector with another.
 		 */

BansheeUtility/Source/BsDegree.cpp

@@ -7,6 +7,16 @@ namespace BansheeEngine
 		:mDeg(r.valueDegrees()) 
 	{ }
 
+	inline Degree Degree::wrap()
+	{
+		mDeg = fmod(mDeg, 360.0f);
+
+		if (mDeg < 0)
+			mDeg += 360.0f;
+
+		return *this;
+	}
+
 	Degree& Degree::operator= (const Radian& r) 
 	{ 
 		mDeg = r.valueDegrees(); return *this; 

BansheeUtility/Source/BsRadian.cpp

@@ -6,6 +6,16 @@ namespace BansheeEngine
 	inline Radian::Radian (const Degree& d) : mRad(d.valueRadians()) 
 	{ }
 
+	inline Radian Radian::wrap()
+	{
+		mRad = fmod(mRad, Math::TWO_PI);
+
+		if (mRad < 0)
+			mRad += Math::TWO_PI;
+
+		return *this;
+	}
+
 	inline Radian& Radian::operator= (const Degree& d) 
 	{
 		mRad = d.valueRadians(); 

MBansheeEditor/DebugCameraHandle.cs

@@ -23,7 +23,7 @@ namespace BansheeEditor
 
         protected override void PostInput()
         {
-            target.sceneObject.Position = xAxis.NewPosition;
+            //target.sceneObject.Position = xAxis.NewPosition;
         }
 
         protected override void Draw()

MBansheeEditor/Scene/DefaultHandle.cs

@@ -33,5 +33,7 @@ namespace BansheeEditor
         {
             Draw();
         }
+
+        internal abstract bool IsDragged();
     }
 }

MBansheeEditor/Scene/DefaultHandleManager.cs

@@ -5,9 +5,24 @@ namespace BansheeEditor
 {
     internal sealed class DefaultHandleManager : Handle
     {
+        private struct HandledObject
+        {
+            public HandledObject(SceneObject so)
+            {
+                this.so = so;
+                initialPosition = so.Position;
+            }
+
+            public SceneObject so;
+            public Vector3 initialPosition;
+        }
+
         private SceneViewTool activeHandleType = SceneViewTool.View;
         private DefaultHandle activeHandle;
 
+        private HandledObject[] activeSelection;
+        private bool isDragged;
+
         protected override void PreInput()
         {
             SceneObject[] selectedSceneObjects = Selection.sceneObjects;
@@ -81,40 +96,65 @@ namespace BansheeEditor
         {
             if (activeHandle != null)
             {
+                if (activeHandle.IsDragged())
+                {
+                    if (!isDragged)
+                    {
+                        isDragged = true;
+
+                        SceneObject[] selectedSceneObjects = Selection.sceneObjects;
+                        activeSelection = new HandledObject[selectedSceneObjects.Length];
+                        for (int i = 0; i < selectedSceneObjects.Length; i++)
+                            activeSelection[i] = new HandledObject(selectedSceneObjects[0]);
+                    }
+                }
+                else
+                {
+                    isDragged = false;
+                    activeSelection = null;
+                }
+
                 activeHandle.DoPostInput();
 
-                SceneObject[] selectedSceneObjects = Selection.sceneObjects;
-                switch (activeHandleType)
+                if (activeHandle.IsDragged())
                 {
-                    case SceneViewTool.Move:
+                    switch (activeHandleType)
+                    {
+                        case SceneViewTool.Move:
                         {
-                            MoveHandle moveHandle = (MoveHandle)activeHandle;
+                            MoveHandle moveHandle = (MoveHandle) activeHandle;
 
-                            foreach (var so in selectedSceneObjects)
-                                so.Position += moveHandle.Delta;
+                            foreach (var selectedObj in activeSelection)
+                                selectedObj.so.Position = selectedObj.initialPosition + moveHandle.Delta;
                         }
 
-                        break;
-                    case SceneViewTool.Rotate:
+                            break;
+                        case SceneViewTool.Rotate:
                         {
-                            RotateHandle rotateHandle = (RotateHandle)activeHandle;
+                            RotateHandle rotateHandle = (RotateHandle) activeHandle;
 
                             // TODO - Add delta rotation
                             //foreach (var so in selectedSceneObjects)
                             //    so.rotation += rotateHandle.Delta;
                         }
-                        break;
-                    case SceneViewTool.Scale:
+                            break;
+                        case SceneViewTool.Scale:
                         {
-                            ScaleHandle scaleHandle = (ScaleHandle)activeHandle;
+                            ScaleHandle scaleHandle = (ScaleHandle) activeHandle;
 
                             // TODO - Add delta scale
                             //foreach (var so in selectedSceneObjects)
                             //    so.localScale += scaleHandle.Delta;
                         }
-                        break;
+                            break;
+                    }
                 }
             }
+            else
+            {
+                isDragged = false;
+                activeSelection = null;
+            }
         }
 
         protected override void Draw()

MBansheeEditor/Scene/HandleSliderDisc.cs

@@ -21,36 +21,11 @@ namespace BansheeEditor
                 return value;
             }
         }
-        public Quaternion NewRotation
-        {
-            get
-            {
-                Quaternion value;
-                Internal_GetNewRotation(mCachedPtr, out value);
-                return value;
-            }
-        }
-
-        public Vector3 DeltaDirection
-        {
-            get
-            {
-                Vector3 value;
-                Internal_GetDeltaDirection(mCachedPtr, out value);
-                return value;
-            }
-        }
 
         [MethodImpl(MethodImplOptions.InternalCall)]
         private static extern void Internal_CreateInstance(HandleSliderDisc instance, Vector3 normal, float radius, bool fixedScale);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
         private static extern void Internal_GetDelta(IntPtr nativeInstance, out float value);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_GetDeltaDirection(IntPtr nativeInstance, out Vector3 value);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_GetNewRotation(IntPtr nativeInstance, out Quaternion value);
     }
 }

MBansheeEditor/Scene/HandleSliderLine.cs

@@ -22,23 +22,10 @@ namespace BansheeEditor
             }
         }
 
-        public Vector3 NewPosition
-        {
-            get
-            {
-                Vector3 value;
-                Internal_GetNewPosition(mCachedPtr, out value);
-                return value;
-            }
-        }
-
         [MethodImpl(MethodImplOptions.InternalCall)]
         private static extern void Internal_CreateInstance(HandleSliderLine instance, Vector3 direction, float length, bool fixedScale);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
         private static extern void Internal_GetDelta(IntPtr nativeInstance, out float value);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_GetNewPosition(IntPtr nativeInstance, out Vector3 value);
     }
 }

MBansheeEditor/Scene/HandleSliderPlane.cs

@@ -12,46 +12,20 @@ namespace BansheeEditor
             Internal_CreateInstance(this, dir1, dir2, length, fixedScale);
         }
 
-        public float Delta
+        public Vector2 Delta
         {
             get
             {
-                float value;
+                Vector2 value;
                 Internal_GetDelta(mCachedPtr, out value);
                 return value;
             }
         }
 
-        public Vector3 NewPosition
-        {
-            get
-            {
-                Vector3 value;
-                Internal_GetNewPosition(mCachedPtr, out value);
-                return value;
-            }
-        }
-
-        public Vector3 DeltaDirection
-        {
-            get
-            {
-                Vector3 value;
-                Internal_GetDeltaDirection(mCachedPtr, out value);
-                return value;
-            }
-        }
-
         [MethodImpl(MethodImplOptions.InternalCall)]
         private static extern void Internal_CreateInstance(HandleSliderPlane instance, Vector3 dir1, Vector3 dir2, float length, bool fixedScale);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_GetDelta(IntPtr nativeInstance, out float value);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_GetDeltaDirection(IntPtr nativeInstance, out Vector3 value);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_GetNewPosition(IntPtr nativeInstance, out Vector3 value);
+        private static extern void Internal_GetDelta(IntPtr nativeInstance, out Vector2 value);
     }
 }

MBansheeEditor/Scene/Handles.cs

@@ -43,9 +43,10 @@ namespace BansheeEditor
 
         public static float SnapValue(float value, float snapAmount)
         {
-            int intValue = MathEx.FloorToInt(value/snapAmount);
+            if (snapAmount > 0)
+                return MathEx.RoundToInt(value / snapAmount) * snapAmount;
 
-            return value - intValue*snapAmount;
+            return value;
         }
 
         public static float GetHandleSize(Camera camera, Vector3 position)

MBansheeEditor/Scene/MoveHandle.cs

@@ -18,6 +18,13 @@ namespace BansheeEditor
             get { return delta; }
         }
 
+        internal override bool IsDragged()
+        {
+            return xAxis.State == HandleSlider.StateType.Active ||
+                    yAxis.State == HandleSlider.StateType.Active ||
+                    zAxis.State == HandleSlider.StateType.Active;
+        }
+
         public MoveHandle()
         {
             xAxis = new HandleSliderLine(this, Vector3.xAxis, 1.0f);

MBansheeEditor/Scene/RotateHandle.cs

@@ -9,6 +9,11 @@ namespace BansheeEditor
 
         }
 
+        internal override bool IsDragged()
+        {
+            return false;
+        }
+
         protected override void PreInput()
         {
 

MBansheeEditor/Scene/ScaleHandle.cs

@@ -9,6 +9,11 @@ namespace BansheeEditor
 
         }
 
+        internal override bool IsDragged()
+        {
+            return false;
+        }
+
         protected override void PreInput()
         {
 

MBansheeEditor/Scene/SceneViewHandler.cs

@@ -10,14 +10,14 @@ namespace BansheeEditor
 {
     internal sealed class SceneViewHandler : ScriptObject
     {
-        internal SceneViewHandler(Camera sceneCamera)
+        internal SceneViewHandler(EditorWindow parent, Camera sceneCamera)
         {
-            Internal_Create(this, sceneCamera.GetCachedPtr());
+            Internal_Create(this, parent.GetCachedPtr(), sceneCamera.Handler.GetCachedPtr());
         }
 
-        internal void Update(Vector2I pointerPos)
+        internal void Update(Vector2I pointerPos, Vector2I inputDelta)
         {
-            Internal_Update(mCachedPtr, pointerPos);
+            Internal_Update(mCachedPtr, pointerPos, inputDelta);
         }
 
         internal void PointerPressed(Vector2I pointerPos)
@@ -31,10 +31,10 @@ namespace BansheeEditor
         }
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_Create(SceneViewHandler managedInstance, IntPtr camera);
+        private static extern void Internal_Create(SceneViewHandler managedInstance, IntPtr parentWindow, IntPtr camera);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_Update(IntPtr thisPtr, Vector2I pointerPos);
+        private static extern void Internal_Update(IntPtr thisPtr, Vector2I pointerPos, Vector2I inputDelta);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
         private static extern void Internal_PointerPressed(IntPtr thisPtr, Vector2I pointerPos);

MBansheeEditor/Scene/SceneWindow.cs

@@ -16,6 +16,8 @@ namespace BansheeEditor
         private GUIRenderTexture renderTextureGUI;
         private SceneViewHandler sceneViewHandler;
 
+        private bool dragActive;
+
         public Camera GetCamera()
         {
             return camera;
@@ -24,9 +26,6 @@ namespace BansheeEditor
         internal SceneWindow()
         {
             UpdateRenderTexture(Width, Height);
-
-            Input.OnPointerPressed += OnPointerPressed;
-            Input.OnPointerReleased += OnPointerReleased;
         }
 
         private bool ScreenToScenePos(Vector2I screenPos, out Vector2I scenePos)
@@ -48,21 +47,35 @@ namespace BansheeEditor
 
         private void EditorUpdate()
         {
-            Vector2I scenePos;
-            if (ScreenToScenePos(Input.PointerPosition, out scenePos))
+            if (Input.IsButtonDown(ButtonCode.MouseLeft))
             {
-                sceneViewHandler.Update(scenePos);
-            }
-        }
+                sceneViewHandler.PointerPressed(Input.PointerPosition);
 
-        private void OnPointerPressed(PointerEvent ev)
-        {
-            sceneViewHandler.PointerPressed(ev.ScreenPos);
-        }
+                Vector2I scenePos;
+                if (ScreenToScenePos(Input.PointerPosition, out scenePos))
+                    dragActive = true;
+            }
+            else if (Input.IsButtonUp(ButtonCode.MouseLeft))
+            {
+                bool ctrlHeld = Input.IsButtonHeld(ButtonCode.LeftControl) || Input.IsButtonHeld(ButtonCode.RightControl);
+                sceneViewHandler.PointerReleased(Input.PointerPosition, ctrlHeld);
+                dragActive = false;
+            }
 
-        private void OnPointerReleased(PointerEvent ev)
-        {
-            sceneViewHandler.PointerReleased(ev.ScreenPos, ev.Control);
+            if (dragActive)
+            {
+                Vector2I scenePos;
+                ScreenToScenePos(Input.PointerPosition, out scenePos);
+                sceneViewHandler.Update(scenePos, Input.PointerDelta);
+            }
+            else
+            {
+                Vector2I scenePos;
+                if (ScreenToScenePos(Input.PointerPosition, out scenePos))
+                {
+                    sceneViewHandler.Update(scenePos, Input.PointerDelta);
+                }
+            }
         }
 
         protected override void WindowResized(int width, int height)
@@ -99,7 +112,7 @@ namespace BansheeEditor
                 renderTextureGUI = new GUIRenderTexture(renderTexture);
 		        GUI.layout.AddElement(renderTextureGUI);
 
-		        sceneViewHandler = new SceneViewHandler(camera);
+		        sceneViewHandler = new SceneViewHandler(this, camera);
 		    }
 		    else
 		    {

MBansheeEngine/Camera.cs

@@ -6,309 +6,162 @@ using System.Text;
 
 namespace BansheeEngine
 {
-    // Don't reorder, used by native code
-    public enum ProjectionType
+    public class Camera : Component
     {
-        Orthographic, Perspective
-    }
+        private CameraHandler handler;
 
-    // Don't reorder, used by native code
-    [Flags]
-    public enum ClearFlags
-    {
-        Color = 0x01, Depth = 0x02, Stencil = 0x04
-    }
+        internal CameraHandler Handler
+        {
+            get { return handler; }
+        }
 
-    public class Camera : Component
-    {
         public float aspectRatio
         {
-            get { return Internal_GetAspect(mCachedPtr); }
-            set { Internal_SetAspect(mCachedPtr, value); }
+            get { return handler.aspectRatio; }
+            set { handler.aspectRatio = value; }
         }
 
         public float nearClipPlane
         {
-            get { return Internal_GetNearClip(mCachedPtr); }
-            set { Internal_SetNearClip(mCachedPtr, value); }
+            get { return handler.nearClipPlane; }
+            set { handler.nearClipPlane = value; }
         }
 
         public float farClipPlane
         {
-            get { return Internal_GetFarClip(mCachedPtr); }
-            set { Internal_SetFarClip(mCachedPtr, value); }
+            get { return handler.farClipPlane; }
+            set { handler.farClipPlane = value; }
         }
 
         public Degree fieldOfView
         {
-            get { return Internal_GetFieldOfView(mCachedPtr); }
-            set { Internal_SetFieldOfView(mCachedPtr, value); }
+            get { return handler.fieldOfView; }
+            set { handler.fieldOfView = value; }
         }
 
         public Rect2 viewportRect
         {
-            get { return Internal_GetViewportRect(mCachedPtr); }
-            set { Internal_SetViewportRect(mCachedPtr, value); }
+            get { return handler.viewportRect; }
+            set { handler.viewportRect = value; }
         }
 
         public ProjectionType projectionType
         {
-            get { return Internal_GetProjectionType(mCachedPtr); }
-            set { Internal_SetProjectionType(mCachedPtr, value); }
+            get { return handler.projectionType; }
+            set { handler.projectionType = value; }
         }
 
         public float orthoHeight
         {
-            get { return Internal_GetOrthographicHeight(mCachedPtr); }
-            set { Internal_SetOrthographicHeight(mCachedPtr, value); }
+            get { return handler.orthoHeight; }
+            set { handler.orthoHeight = value; }
         }
 
         public float orthoWidth
         {
-            get { return Internal_GetOrthographicWidth(mCachedPtr); }
+            get { return handler.orthoWidth; }
         }
 
         public Color clearColor
         {
-            get { return Internal_GetClearColor(mCachedPtr); }
-            set { Internal_SetClearColor(mCachedPtr, value); }
+            get { return handler.clearColor; }
+            set { handler.clearColor = value; }
         }
 
         public float clearDepth
         {
-            get { return Internal_GetDepthClearValue(mCachedPtr); }
-            set { Internal_SetDepthClearValue(mCachedPtr, value); }
+            get { return handler.clearDepth; }
+            set { handler.clearDepth = value; }
         }
 
         public UInt16 clearStencil
         {
-            get { return Internal_GetStencilClearValue(mCachedPtr); }
-            set { Internal_SetStencilClearValue(mCachedPtr, value); }
+            get { return handler.clearStencil; }
+            set { handler.clearStencil = value; }
         }
 
         public ClearFlags clearFlags
         {
-            get { return Internal_GetClearFlags(mCachedPtr); }
-            set { Internal_SetClearFlags(mCachedPtr, value); }
+            get { return handler.clearFlags; }
+            set { handler.clearFlags = value; }
         }
 
         public int priority
         {
-            get { return Internal_GetPriority(mCachedPtr); }
-            set { Internal_SetPriority(mCachedPtr, value); }
+            get { return handler.priority; }
+            set { handler.priority = value; }
         }
 
         public UInt64 layers
         {
-            get { return Internal_GetLayers(mCachedPtr); }
-            set { Internal_SetLayers(mCachedPtr, value); }
+            get { return handler.layers; }
+            set { handler.layers = value; }
         }
 
         public Matrix4 projMatrix
         {
-            get { return Internal_GetProjMatrix(mCachedPtr); }
+            get { return handler.projMatrix; }
         }
 
         public Matrix4 projMatrixInv
         {
-            get { return Internal_GetProjMatrixInv(mCachedPtr); }
+            get { return handler.projMatrixInv; }
         }
 
         public Matrix4 viewMatrix
         {
-            get { return Internal_GetViewMatrix(mCachedPtr); }
+            get { return handler.viewMatrix; }
         }
 
         public Matrix4 viewMatrixInv
         {
-            get { return Internal_GetViewMatrixInv(mCachedPtr); }
+            get { return handler.viewMatrixInv; }
         }
 
         public int widthPixels
         {
-            get { return Internal_GetWidthPixels(mCachedPtr); }
+            get { return handler.widthPixels; }
         }
 
         public int heightPixels
         {
-            get { return Internal_GetHeightPixels(mCachedPtr); }
+            get { return handler.heightPixels; }
         }
 
         public RenderTarget target
         {
-            get
-            {
-                return _target;
-            }
-            set
-            {
-                _target = value;
-
-                IntPtr targetPtr = IntPtr.Zero;
-                if (_target != null)
-                    targetPtr = _target.mCachedPtr;
-
-                Internal_SetRenderTarget(mCachedPtr, targetPtr);
-            }
+            get { return handler.target; }
+            set { handler.target = value; }
         }
 
-        public Vector2I WorldToScreen(Vector3 value) { return Internal_WorldToScreen(mCachedPtr, value); }
-        public Vector2 WorldToClip(Vector3 value) { return Internal_WorldToClip(mCachedPtr, value); }
-        public Vector3 WorldToView(Vector3 value) { return Internal_WorldToView(mCachedPtr, value); }
-
-        public Vector3 ScreenToWorld(Vector2I value) { return Internal_ScreenToWorld(mCachedPtr, value); }
-        public Vector3 ScreenToView(Vector2I value) { return Internal_ScreenToView(mCachedPtr, value); }
-        public Vector2 ScreenToClip(Vector2I value) { return Internal_ScreenToClip(mCachedPtr, value); }
+        public Vector2I WorldToScreen(Vector3 value) { return handler.WorldToScreen(value); }
+        public Vector2 WorldToClip(Vector3 value) { return handler.WorldToClip(value); }
+        public Vector3 WorldToView(Vector3 value) { return handler.WorldToView(value); }
 
-        public Vector3 ViewToWorld(Vector3 value) { return Internal_ViewToWorld(mCachedPtr, value); }
-        public Vector2I ViewToScreen(Vector3 value) { return Internal_ViewToScreen(mCachedPtr, value); }
-        public Vector2 ViewToClip(Vector3 value) { return Internal_ViewToClip(mCachedPtr, value); }
+        public Vector3 ScreenToWorld(Vector2I value) { return handler.ScreenToWorld(value); }
+        public Vector3 ScreenToView(Vector2I value) { return handler.ScreenToView(value); }
+        public Vector2 ScreenToClip(Vector2I value) { return handler.ScreenToClip(value); }
 
-        public Vector3 ClipToWorld(Vector2 value) { return Internal_ClipToWorld(mCachedPtr, value); }
-        public Vector3 ClipToView(Vector2 value) { return Internal_ClipToView(mCachedPtr, value); }
-        public Vector2I ClipToScreen(Vector2 value) { return Internal_ClipToScreen(mCachedPtr, value); }
+        public Vector3 ViewToWorld(Vector3 value) { return handler.ViewToWorld(value); }
+        public Vector2I ViewToScreen(Vector3 value) { return handler.ViewToScreen(value); }
+        public Vector2 ViewToClip(Vector3 value) { return handler.ViewToClip(value); }
 
-        public Ray ScreenToWorldRay(Vector2I value) { return Internal_ScreenToWorldRay(mCachedPtr, value); }
-        public Vector3 ProjectPoint(Vector3 value) { return Internal_ProjectPoint(mCachedPtr, value); }
-        public Vector3 UnprojectPoint(Vector3 value) { return Internal_UnprojectPoint(mCachedPtr, value); }
+        public Vector3 ClipToWorld(Vector2 value) { return handler.ClipToWorld(value); }
+        public Vector3 ClipToView(Vector2 value) { return handler.ClipToView(value); }
+        public Vector2I ClipToScreen(Vector2 value) { return handler.ClipToScreen(value); }
 
-        private RenderTarget _target;
+        public Ray ScreenToWorldRay(Vector2I value) { return handler.ScreenToWorldRay(value); }
+        public Vector3 ProjectPoint(Vector3 value) { return handler.ProjectPoint(value); }
+        public Vector3 UnprojectPoint(Vector3 value) { return handler.UnprojectPoint(value); }
 
         public Camera()
         {
-            Internal_Create(this);
+            handler = new CameraHandler();
         }
 
         private void Update()
         {
-            Internal_UpdateView(mCachedPtr, sceneObject.mCachedPtr);
+            handler.UpdateView(sceneObject);
         }
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_Create(Camera instance);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern float Internal_GetAspect(IntPtr instance);
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_SetAspect(IntPtr instance, float value);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern float Internal_GetNearClip(IntPtr instance);
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_SetNearClip(IntPtr instance, float value);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern float Internal_GetFarClip(IntPtr instance);
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_SetFarClip(IntPtr instance, float value);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern Degree Internal_GetFieldOfView(IntPtr instance);
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_SetFieldOfView(IntPtr instance, Degree value);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern Rect2 Internal_GetViewportRect(IntPtr instance);
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_SetViewportRect(IntPtr instance, Rect2 value);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern ProjectionType Internal_GetProjectionType(IntPtr instance);
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_SetProjectionType(IntPtr instance, ProjectionType value);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern float Internal_GetOrthographicHeight(IntPtr instance);
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_SetOrthographicHeight(IntPtr instance, float value);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern float Internal_GetOrthographicWidth(IntPtr instance);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern Color Internal_GetClearColor(IntPtr instance);
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_SetClearColor(IntPtr instance, Color value);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern float Internal_GetDepthClearValue(IntPtr instance);
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_SetDepthClearValue(IntPtr instance, float value);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern UInt16 Internal_GetStencilClearValue(IntPtr instance);
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_SetStencilClearValue(IntPtr instance, UInt16 value);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern ClearFlags Internal_GetClearFlags(IntPtr instance);
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_SetClearFlags(IntPtr instance, ClearFlags value);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern int Internal_GetPriority(IntPtr instance);
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_SetPriority(IntPtr instance, int value);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern UInt64 Internal_GetLayers(IntPtr instance);
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_SetLayers(IntPtr instance, UInt64 value);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern Matrix4 Internal_GetProjMatrix(IntPtr instance);
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern Matrix4 Internal_GetProjMatrixInv(IntPtr instance);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern Matrix4 Internal_GetViewMatrix(IntPtr instance);
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern Matrix4 Internal_GetViewMatrixInv(IntPtr instance);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern int Internal_GetWidthPixels(IntPtr instance);
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern int Internal_GetHeightPixels(IntPtr instance);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern Vector2I Internal_WorldToScreen(IntPtr instance, Vector3 value);
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern Vector2 Internal_WorldToClip(IntPtr instance, Vector3 value);
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern Vector3 Internal_WorldToView(IntPtr instance, Vector3 value);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern Vector3 Internal_ScreenToWorld(IntPtr instance, Vector2I value);
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern Vector3 Internal_ScreenToView(IntPtr instance, Vector2I value);
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern Vector2 Internal_ScreenToClip(IntPtr instance, Vector2I value);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern Vector3 Internal_ViewToWorld(IntPtr instance, Vector3 value);
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern Vector2I Internal_ViewToScreen(IntPtr instance, Vector3 value);
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern Vector2 Internal_ViewToClip(IntPtr instance, Vector3 value);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern Vector3 Internal_ClipToWorld(IntPtr instance, Vector2 value);
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern Vector3 Internal_ClipToView(IntPtr instance, Vector2 value);
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern Vector2I Internal_ClipToScreen(IntPtr instance, Vector2 value);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern Ray Internal_ScreenToWorldRay(IntPtr instance, Vector2I value);
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern Vector3 Internal_ProjectPoint(IntPtr instance, Vector3 value);
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern Vector3 Internal_UnprojectPoint(IntPtr instance, Vector3 value);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_SetRenderTarget(IntPtr instance, IntPtr rt);
-
-        [MethodImpl(MethodImplOptions.InternalCall)]
-        private static extern void Internal_UpdateView(IntPtr instance, IntPtr parentSO);
     }
 }

MBansheeEngine/CameraHandler.cs

@@ -0,0 +1,314 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace BansheeEngine
+{
+    // Don't reorder, used by native code
+    public enum ProjectionType
+    {
+        Orthographic, Perspective
+    }
+
+    // Don't reorder, used by native code
+    [Flags]
+    public enum ClearFlags
+    {
+        Color = 0x01, Depth = 0x02, Stencil = 0x04
+    }
+
+    internal class CameraHandler : ScriptObject
+    {
+        internal float aspectRatio
+        {
+            get { return Internal_GetAspect(mCachedPtr); }
+            set { Internal_SetAspect(mCachedPtr, value); }
+        }
+
+        internal float nearClipPlane
+        {
+            get { return Internal_GetNearClip(mCachedPtr); }
+            set { Internal_SetNearClip(mCachedPtr, value); }
+        }
+
+        internal float farClipPlane
+        {
+            get { return Internal_GetFarClip(mCachedPtr); }
+            set { Internal_SetFarClip(mCachedPtr, value); }
+        }
+
+        internal Degree fieldOfView
+        {
+            get { return Internal_GetFieldOfView(mCachedPtr); }
+            set { Internal_SetFieldOfView(mCachedPtr, value); }
+        }
+
+        internal Rect2 viewportRect
+        {
+            get { return Internal_GetViewportRect(mCachedPtr); }
+            set { Internal_SetViewportRect(mCachedPtr, value); }
+        }
+
+        internal ProjectionType projectionType
+        {
+            get { return Internal_GetProjectionType(mCachedPtr); }
+            set { Internal_SetProjectionType(mCachedPtr, value); }
+        }
+
+        internal float orthoHeight
+        {
+            get { return Internal_GetOrthographicHeight(mCachedPtr); }
+            set { Internal_SetOrthographicHeight(mCachedPtr, value); }
+        }
+
+        internal float orthoWidth
+        {
+            get { return Internal_GetOrthographicWidth(mCachedPtr); }
+        }
+
+        internal Color clearColor
+        {
+            get { return Internal_GetClearColor(mCachedPtr); }
+            set { Internal_SetClearColor(mCachedPtr, value); }
+        }
+
+        internal float clearDepth
+        {
+            get { return Internal_GetDepthClearValue(mCachedPtr); }
+            set { Internal_SetDepthClearValue(mCachedPtr, value); }
+        }
+
+        internal UInt16 clearStencil
+        {
+            get { return Internal_GetStencilClearValue(mCachedPtr); }
+            set { Internal_SetStencilClearValue(mCachedPtr, value); }
+        }
+
+        internal ClearFlags clearFlags
+        {
+            get { return Internal_GetClearFlags(mCachedPtr); }
+            set { Internal_SetClearFlags(mCachedPtr, value); }
+        }
+
+        internal int priority
+        {
+            get { return Internal_GetPriority(mCachedPtr); }
+            set { Internal_SetPriority(mCachedPtr, value); }
+        }
+
+        internal UInt64 layers
+        {
+            get { return Internal_GetLayers(mCachedPtr); }
+            set { Internal_SetLayers(mCachedPtr, value); }
+        }
+
+        internal Matrix4 projMatrix
+        {
+            get { return Internal_GetProjMatrix(mCachedPtr); }
+        }
+
+        internal Matrix4 projMatrixInv
+        {
+            get { return Internal_GetProjMatrixInv(mCachedPtr); }
+        }
+
+        internal Matrix4 viewMatrix
+        {
+            get { return Internal_GetViewMatrix(mCachedPtr); }
+        }
+
+        internal Matrix4 viewMatrixInv
+        {
+            get { return Internal_GetViewMatrixInv(mCachedPtr); }
+        }
+
+        internal int widthPixels
+        {
+            get { return Internal_GetWidthPixels(mCachedPtr); }
+        }
+
+        internal int heightPixels
+        {
+            get { return Internal_GetHeightPixels(mCachedPtr); }
+        }
+
+        internal RenderTarget target
+        {
+            get
+            {
+                return _target;
+            }
+            set
+            {
+                _target = value;
+
+                IntPtr targetPtr = IntPtr.Zero;
+                if (_target != null)
+                    targetPtr = _target.mCachedPtr;
+
+                Internal_SetRenderTarget(mCachedPtr, targetPtr);
+            }
+        }
+
+        internal Vector2I WorldToScreen(Vector3 value) { return Internal_WorldToScreen(mCachedPtr, value); }
+        internal Vector2 WorldToClip(Vector3 value) { return Internal_WorldToClip(mCachedPtr, value); }
+        internal Vector3 WorldToView(Vector3 value) { return Internal_WorldToView(mCachedPtr, value); }
+
+        internal Vector3 ScreenToWorld(Vector2I value) { return Internal_ScreenToWorld(mCachedPtr, value); }
+        internal Vector3 ScreenToView(Vector2I value) { return Internal_ScreenToView(mCachedPtr, value); }
+        internal Vector2 ScreenToClip(Vector2I value) { return Internal_ScreenToClip(mCachedPtr, value); }
+
+        internal Vector3 ViewToWorld(Vector3 value) { return Internal_ViewToWorld(mCachedPtr, value); }
+        internal Vector2I ViewToScreen(Vector3 value) { return Internal_ViewToScreen(mCachedPtr, value); }
+        internal Vector2 ViewToClip(Vector3 value) { return Internal_ViewToClip(mCachedPtr, value); }
+
+        internal Vector3 ClipToWorld(Vector2 value) { return Internal_ClipToWorld(mCachedPtr, value); }
+        internal Vector3 ClipToView(Vector2 value) { return Internal_ClipToView(mCachedPtr, value); }
+        internal Vector2I ClipToScreen(Vector2 value) { return Internal_ClipToScreen(mCachedPtr, value); }
+
+        internal Ray ScreenToWorldRay(Vector2I value) { return Internal_ScreenToWorldRay(mCachedPtr, value); }
+        internal Vector3 ProjectPoint(Vector3 value) { return Internal_ProjectPoint(mCachedPtr, value); }
+        internal Vector3 UnprojectPoint(Vector3 value) { return Internal_UnprojectPoint(mCachedPtr, value); }
+
+        private RenderTarget _target;
+
+        public CameraHandler()
+        {
+            Internal_Create(this);
+        }
+
+        internal void UpdateView(SceneObject sceneObject)
+        {
+            Internal_UpdateView(mCachedPtr, sceneObject.mCachedPtr);
+        }
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_Create(CameraHandler instance);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern float Internal_GetAspect(IntPtr instance);
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_SetAspect(IntPtr instance, float value);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern float Internal_GetNearClip(IntPtr instance);
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_SetNearClip(IntPtr instance, float value);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern float Internal_GetFarClip(IntPtr instance);
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_SetFarClip(IntPtr instance, float value);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern Degree Internal_GetFieldOfView(IntPtr instance);
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_SetFieldOfView(IntPtr instance, Degree value);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern Rect2 Internal_GetViewportRect(IntPtr instance);
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_SetViewportRect(IntPtr instance, Rect2 value);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern ProjectionType Internal_GetProjectionType(IntPtr instance);
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_SetProjectionType(IntPtr instance, ProjectionType value);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern float Internal_GetOrthographicHeight(IntPtr instance);
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_SetOrthographicHeight(IntPtr instance, float value);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern float Internal_GetOrthographicWidth(IntPtr instance);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern Color Internal_GetClearColor(IntPtr instance);
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_SetClearColor(IntPtr instance, Color value);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern float Internal_GetDepthClearValue(IntPtr instance);
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_SetDepthClearValue(IntPtr instance, float value);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern UInt16 Internal_GetStencilClearValue(IntPtr instance);
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_SetStencilClearValue(IntPtr instance, UInt16 value);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern ClearFlags Internal_GetClearFlags(IntPtr instance);
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_SetClearFlags(IntPtr instance, ClearFlags value);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern int Internal_GetPriority(IntPtr instance);
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_SetPriority(IntPtr instance, int value);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern UInt64 Internal_GetLayers(IntPtr instance);
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_SetLayers(IntPtr instance, UInt64 value);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern Matrix4 Internal_GetProjMatrix(IntPtr instance);
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern Matrix4 Internal_GetProjMatrixInv(IntPtr instance);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern Matrix4 Internal_GetViewMatrix(IntPtr instance);
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern Matrix4 Internal_GetViewMatrixInv(IntPtr instance);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern int Internal_GetWidthPixels(IntPtr instance);
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern int Internal_GetHeightPixels(IntPtr instance);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern Vector2I Internal_WorldToScreen(IntPtr instance, Vector3 value);
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern Vector2 Internal_WorldToClip(IntPtr instance, Vector3 value);
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern Vector3 Internal_WorldToView(IntPtr instance, Vector3 value);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern Vector3 Internal_ScreenToWorld(IntPtr instance, Vector2I value);
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern Vector3 Internal_ScreenToView(IntPtr instance, Vector2I value);
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern Vector2 Internal_ScreenToClip(IntPtr instance, Vector2I value);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern Vector3 Internal_ViewToWorld(IntPtr instance, Vector3 value);
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern Vector2I Internal_ViewToScreen(IntPtr instance, Vector3 value);
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern Vector2 Internal_ViewToClip(IntPtr instance, Vector3 value);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern Vector3 Internal_ClipToWorld(IntPtr instance, Vector2 value);
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern Vector3 Internal_ClipToView(IntPtr instance, Vector2 value);
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern Vector2I Internal_ClipToScreen(IntPtr instance, Vector2 value);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern Ray Internal_ScreenToWorldRay(IntPtr instance, Vector2I value);
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern Vector3 Internal_ProjectPoint(IntPtr instance, Vector3 value);
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern Vector3 Internal_UnprojectPoint(IntPtr instance, Vector3 value);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_SetRenderTarget(IntPtr instance, IntPtr rt);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_UpdateView(IntPtr instance, IntPtr parentSO);
+    }
+}

MBansheeEngine/Input.cs

@@ -33,36 +33,39 @@ namespace BansheeEngine
 
     public struct PointerEvent
     {
-        internal Vector2I screenPos;
-        internal PointerEventButton button;
+        internal Vector2I _screenPos;
+        internal Vector2I _delta;
+        internal PointerEventButton _button;
 
-        internal bool shift;
-        internal bool control;
-        internal bool alt;
+        internal bool _shift;
+        internal bool _control;
+        internal bool _alt;
 
-        internal float mouseWheelScrollAmount;
+        internal float _mouseWheelScrollAmount;
 
-        internal PointerEvent(Vector2I screenPos, PointerEventButton button,
+        internal PointerEvent(Vector2I screenPos, Vector2I delta, PointerEventButton button,
             bool shift, bool control, bool alt, float mouseWheelScrollAmount)
         {
-            this.screenPos = screenPos;
-            this.button = button;
+            _screenPos = screenPos;
+            _delta = delta;
+            _button = button;
 
-            this.shift = shift;
-            this.control = control;
-            this.alt = alt;
+            _shift = shift;
+            _control = control;
+            _alt = alt;
 
-            this.mouseWheelScrollAmount = mouseWheelScrollAmount;
+            _mouseWheelScrollAmount = mouseWheelScrollAmount;
         }
 
-        public Vector2I ScreenPos { get { return screenPos; } }
-        public PointerEventButton Button { get { return button; } }
+        public Vector2I screenPos { get { return _screenPos; } }
+        public Vector2I delta { get { return _delta; } }
+        public PointerEventButton button { get { return _button; } }
 
-        public bool Shift { get { return shift; } }
-        public bool Control { get { return control; } }
-        public bool Alt { get { return alt; } }
+        public bool shift { get { return _shift; } }
+        public bool control { get { return _control; } }
+        public bool alt { get { return _alt; } }
 
-        public float ScrollAmount { get { return mouseWheelScrollAmount; } }
+        public float scrollAmount { get { return _mouseWheelScrollAmount; } }
     }
 
     public struct TextInputEvent
@@ -121,6 +124,16 @@ namespace BansheeEngine
             }
         }
 
+        public static Vector2I PointerDelta
+        {
+            get
+            {
+                Vector2I value;
+                Internal_GetPointerDelta(out value);
+                return value;
+            }
+        }
+
         private static void Internal_TriggerButtonDown(ButtonCode code, int deviceIdx)
         {
             ButtonEvent ev = new ButtonEvent(code, deviceIdx);
@@ -145,37 +158,37 @@ namespace BansheeEngine
                 OnCharInput(ev);
         }
 
-        private static void Internal_TriggerPointerMove(Vector2I screenPos, PointerEventButton button, bool shift, 
+        private static void Internal_TriggerPointerMove(Vector2I screenPos, Vector2I delta, PointerEventButton button, bool shift, 
             bool ctrl, bool alt, float scrollAmount)
         {
-            PointerEvent ev = new PointerEvent(screenPos, button, shift, ctrl, alt, scrollAmount);
+            PointerEvent ev = new PointerEvent(screenPos, delta, button, shift, ctrl, alt, scrollAmount);
 
             if (OnPointerMoved != null)
                 OnPointerMoved(ev);
         }
 
-        private static void Internal_TriggerPointerPressed(Vector2I screenPos, PointerEventButton button, bool shift,
+        private static void Internal_TriggerPointerPressed(Vector2I screenPos, Vector2I delta, PointerEventButton button, bool shift,
             bool ctrl, bool alt, float scrollAmount)
         {
-            PointerEvent ev = new PointerEvent(screenPos, button, shift, ctrl, alt, scrollAmount);
+            PointerEvent ev = new PointerEvent(screenPos, delta, button, shift, ctrl, alt, scrollAmount);
 
             if (OnPointerPressed != null)
                 OnPointerPressed(ev);
         }
 
-        private static void Internal_TriggerPointerReleased(Vector2I screenPos, PointerEventButton button, bool shift,
+        private static void Internal_TriggerPointerReleased(Vector2I screenPos, Vector2I delta, PointerEventButton button, bool shift,
             bool ctrl, bool alt, float scrollAmount)
         {
-            PointerEvent ev = new PointerEvent(screenPos, button, shift, ctrl, alt, scrollAmount);
+            PointerEvent ev = new PointerEvent(screenPos, delta, button, shift, ctrl, alt, scrollAmount);
 
             if (OnPointerReleased != null)
                 OnPointerReleased(ev);
         }
 
-        private static void Internal_TriggerPointerDoubleClick(Vector2I screenPos, PointerEventButton button, bool shift,
+        private static void Internal_TriggerPointerDoubleClick(Vector2I screenPos, Vector2I delta, PointerEventButton button, bool shift,
             bool ctrl, bool alt, float scrollAmount)
         {
-            PointerEvent ev = new PointerEvent(screenPos, button, shift, ctrl, alt, scrollAmount);
+            PointerEvent ev = new PointerEvent(screenPos, delta, button, shift, ctrl, alt, scrollAmount);
 
             if (OnPointerDoubleClick != null)
                 OnPointerDoubleClick(ev);
@@ -195,6 +208,9 @@ namespace BansheeEngine
 
         [MethodImpl(MethodImplOptions.InternalCall)]
         private static extern void Internal_GetPointerPosition(out Vector2I position);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern void Internal_GetPointerDelta(out Vector2I delta);
     }
 
     // Do not change IDs, must match ButtonCode C++ enum

MBansheeEngine/MBansheeEngine.csproj

@@ -45,6 +45,7 @@
     <Compile Include="AsyncOp.cs" />
     <Compile Include="BuiltinResources.cs" />
     <Compile Include="Camera.cs" />
+    <Compile Include="CameraHandler.cs" />
     <Compile Include="Cursor.cs" />
     <Compile Include="Debug.cs" />
     <Compile Include="Color.cs" />

SBansheeEditor/Include/BsScriptHandleSliderDisc.h

@@ -20,8 +20,6 @@ namespace BansheeEngine
 	private:
 		static void internal_CreateInstance(MonoObject* instance, Vector3 normal, float radius, bool fixedScale);
 		static void internal_GetDelta(ScriptHandleSliderDisc* nativeInstance, float* value);
-		static void internal_GetDeltaDirection(ScriptHandleSliderDisc* nativeInstance, Vector3* value);
-		static void internal_GetNewRotation(ScriptHandleSliderDisc* nativeInstance, Quaternion* value);
 
 		ScriptHandleSliderDisc(MonoObject* instance, const Vector3& normal, float radius, bool fixedScale);
 		~ScriptHandleSliderDisc();

SBansheeEditor/Include/BsScriptHandleSliderLine.h

@@ -20,7 +20,6 @@ namespace BansheeEngine
 	private:
 		static void internal_CreateInstance(MonoObject* instance, Vector3 direction, float length, bool fixedScale);
 		static void internal_GetDelta(ScriptHandleSliderLine* nativeInstance, float* value);
-		static void internal_GetNewPosition(ScriptHandleSliderLine* nativeInstance, Vector3* value);
 
 		ScriptHandleSliderLine(MonoObject* instance, const Vector3& direction, float length, bool fixedScale);
 		~ScriptHandleSliderLine();

SBansheeEditor/Include/BsScriptHandleSliderPlane.h

@@ -19,9 +19,7 @@ namespace BansheeEngine
 
 	private:
 		static void internal_CreateInstance(MonoObject* instance, Vector3 dir1, Vector3 dir2, float length, bool fixedScale);
-		static void internal_GetDelta(ScriptHandleSliderPlane* nativeInstance, float* value);
-		static void internal_GetDeltaDirection(ScriptHandleSliderPlane* nativeInstance, Vector3* value);
-		static void internal_GetNewPosition(ScriptHandleSliderPlane* nativeInstance, Vector3* value);
+		static void internal_GetDelta(ScriptHandleSliderPlane* nativeInstance, Vector2* value);
 
 		ScriptHandleSliderPlane(MonoObject* instance, const Vector3& dir1, const Vector3& dir2, float length, bool fixedScale);
 		~ScriptHandleSliderPlane();

SBansheeEditor/Include/BsScriptSceneViewHandler.h

@@ -11,12 +11,12 @@ namespace BansheeEngine
 		SCRIPT_OBJ(BansheeEditorAssemblyName, "BansheeEditor", "SceneViewHandler")
 
 	private:
-		static void internal_Create(MonoObject* managedInstance, ScriptCamera* camera);
-		static void internal_Update(ScriptSceneViewHandler* thisPtr, Vector2I inputPos);
+		static void internal_Create(MonoObject* managedInstance, ScriptEditorWindow* parentWindow, ScriptCameraHandler* camera);
+		static void internal_Update(ScriptSceneViewHandler* thisPtr, Vector2I inputPos, Vector2I inputDelta);
 		static void internal_PointerPressed(ScriptSceneViewHandler* thisPtr, Vector2I inputPos);
 		static void internal_PointerReleased(ScriptSceneViewHandler* thisPtr, Vector2I inputPos, bool controlPressed);
 
-		ScriptSceneViewHandler(MonoObject* object, const SPtr<CameraHandler>& camera);
+		ScriptSceneViewHandler(MonoObject* object, const EditorWidgetBase* parentWidget, const SPtr<CameraHandler>& camera);
 		~ScriptSceneViewHandler();
 
 		SceneViewHandler* mHandler;

SBansheeEditor/Source/BsScriptHandleSliderDisc.cpp

@@ -30,8 +30,6 @@ namespace BansheeEngine
 	{
 		metaData.scriptClass->addInternalCall("Internal_CreateInstance", &ScriptHandleSliderDisc::internal_CreateInstance);
 		metaData.scriptClass->addInternalCall("Internal_GetDelta", &ScriptHandleSliderDisc::internal_GetDelta);
-		metaData.scriptClass->addInternalCall("Internal_GetDeltaDirection", &ScriptHandleSliderDisc::internal_GetDeltaDirection);
-		metaData.scriptClass->addInternalCall("Internal_GetNewRotation", &ScriptHandleSliderDisc::internal_GetNewRotation);
 	}
 
 	void ScriptHandleSliderDisc::internal_CreateInstance(MonoObject* instance, Vector3 normal, float radius, bool fixedScale)
@@ -44,14 +42,4 @@ namespace BansheeEngine
 	{
 		*value = nativeInstance->mSlider->getDelta();
 	}
-
-	void ScriptHandleSliderDisc::internal_GetDeltaDirection(ScriptHandleSliderDisc* nativeInstance, Vector3* value)
-	{
-		*value = nativeInstance->mSlider->getDeltaDirection();
-	}
-
-	void ScriptHandleSliderDisc::internal_GetNewRotation(ScriptHandleSliderDisc* nativeInstance, Quaternion* value)
-	{
-		*value = nativeInstance->mSlider->getNewRotation();
-	}
 }

SBansheeEditor/Source/BsScriptHandleSliderLine.cpp

@@ -30,7 +30,6 @@ namespace BansheeEngine
 	{
 		metaData.scriptClass->addInternalCall("Internal_CreateInstance", &ScriptHandleSliderLine::internal_CreateInstance);
 		metaData.scriptClass->addInternalCall("Internal_GetDelta", &ScriptHandleSliderLine::internal_GetDelta);
-		metaData.scriptClass->addInternalCall("Internal_GetNewPosition", &ScriptHandleSliderLine::internal_GetNewPosition);
 	}
 
 	void ScriptHandleSliderLine::internal_CreateInstance(MonoObject* instance, Vector3 direction, float length, bool fixedScale)
@@ -43,9 +42,4 @@ namespace BansheeEngine
 	{
 		*value = nativeInstance->mSlider->getDelta();
 	}
-
-	void ScriptHandleSliderLine::internal_GetNewPosition(ScriptHandleSliderLine* nativeInstance, Vector3* value)
-	{
-		*value = nativeInstance->mSlider->getNewPosition();
-	}
 }

SBansheeEditor/Source/BsScriptHandleSliderPlane.cpp

@@ -30,8 +30,6 @@ namespace BansheeEngine
 	{
 		metaData.scriptClass->addInternalCall("Internal_CreateInstance", &ScriptHandleSliderPlane::internal_CreateInstance);
 		metaData.scriptClass->addInternalCall("Internal_GetDelta", &ScriptHandleSliderPlane::internal_GetDelta);
-		metaData.scriptClass->addInternalCall("Internal_GetDeltaDirection", &ScriptHandleSliderPlane::internal_GetDeltaDirection);
-		metaData.scriptClass->addInternalCall("Internal_GetNewPosition", &ScriptHandleSliderPlane::internal_GetNewPosition);
 	}
 
 	void ScriptHandleSliderPlane::internal_CreateInstance(MonoObject* instance, Vector3 dir1, Vector3 dir2, float length, bool fixedScale)
@@ -40,18 +38,8 @@ namespace BansheeEngine
 			ScriptHandleSliderPlane(instance, dir1, dir2, length, fixedScale);
 	}
 
-	void ScriptHandleSliderPlane::internal_GetDelta(ScriptHandleSliderPlane* nativeInstance, float* value)
+	void ScriptHandleSliderPlane::internal_GetDelta(ScriptHandleSliderPlane* nativeInstance, Vector2* value)
 	{
 		*value = nativeInstance->mSlider->getDelta();
 	}
-
-	void ScriptHandleSliderPlane::internal_GetDeltaDirection(ScriptHandleSliderPlane* nativeInstance, Vector3* value)
-	{
-		*value = nativeInstance->mSlider->getDeltaDirection();
-	}
-
-	void ScriptHandleSliderPlane::internal_GetNewPosition(ScriptHandleSliderPlane* nativeInstance, Vector3* value)
-	{
-		*value = nativeInstance->mSlider->getNewPosition();
-	}
 }

SBansheeEditor/Source/BsScriptSceneViewHandler.cpp

@@ -3,14 +3,17 @@
 #include "BsMonoClass.h"
 #include "BsMonoUtil.h"
 #include "BsSceneViewHandler.h"
-#include "BsScriptCamera.h"
+#include "BsScriptCameraHandler.h"
+#include "BsScriptEditorWindow.h"
+#include "BsEditorWidgetContainer.h"
+#include "BsEditorWindowBase.h"
 
 namespace BansheeEngine
 {
-	ScriptSceneViewHandler::ScriptSceneViewHandler(MonoObject* object, const SPtr<CameraHandler>& camera)
+	ScriptSceneViewHandler::ScriptSceneViewHandler(MonoObject* object, const EditorWidgetBase* parentWidget, const SPtr<CameraHandler>& camera)
 		:ScriptObject(object), mHandler(nullptr)
 	{ 
-		mHandler = bs_new<SceneViewHandler>(camera);
+		mHandler = bs_new<SceneViewHandler>(parentWidget, camera);
 	}
 
 	ScriptSceneViewHandler::~ScriptSceneViewHandler()
@@ -26,14 +29,16 @@ namespace BansheeEngine
 		metaData.scriptClass->addInternalCall("Internal_PointerReleased", &ScriptSceneViewHandler::internal_PointerReleased);
 	}
 
-	void ScriptSceneViewHandler::internal_Create(MonoObject* managedInstance, ScriptCamera* camera)
+	void ScriptSceneViewHandler::internal_Create(MonoObject* managedInstance, ScriptEditorWindow* parentWindow, ScriptCameraHandler* camera)
 	{
-		new (bs_alloc<ScriptSceneViewHandler>()) ScriptSceneViewHandler(managedInstance, camera->getHandler());
+		EditorWidgetBase* widget = parentWindow->getEditorWidget();
+
+		new (bs_alloc<ScriptSceneViewHandler>()) ScriptSceneViewHandler(managedInstance, widget, camera->getInternal());
 	}
 
-	void ScriptSceneViewHandler::internal_Update(ScriptSceneViewHandler* thisPtr, Vector2I inputPos)
+	void ScriptSceneViewHandler::internal_Update(ScriptSceneViewHandler* thisPtr, Vector2I inputPos, Vector2I inputDelta)
 	{
-		thisPtr->mHandler->update(inputPos);
+		thisPtr->mHandler->update(inputPos, inputDelta);
 	}
 
 	void ScriptSceneViewHandler::internal_PointerPressed(ScriptSceneViewHandler* thisPtr, Vector2I inputPos)

SBansheeEngine/Include/BsScriptCamera.h

@@ -1,107 +0,0 @@
-#pragma once
-
-#include "BsScriptEnginePrerequisites.h"
-#include "BsScriptObject.h"
-#include "BsVector2.h"
-#include "BsVector3.h"
-#include "BsVector2I.h"
-#include "BsRay.h"
-#include "BsDegree.h"
-#include "BsMatrix4.h"
-#include "BsRect2.h"
-#include "BsColor.h"
-
-namespace BansheeEngine
-{
-	class BS_SCR_BE_EXPORT ScriptCamera : public ScriptObject<ScriptCamera>
-	{
-	public:
-		SCRIPT_OBJ(BansheeEngineAssemblyName, "BansheeEngine", "Camera")
-
-		SPtr<CameraHandler> getHandler() const { return mCameraHandler; }
-
-	private:
-		ScriptCamera(MonoObject* managedInstance);
-		~ScriptCamera();
-
-		void updateView(const HSceneObject& parent);
-
-		static void internal_Create(MonoObject* managedInstance);
-
-		static float internal_GetAspect(ScriptCamera* instance);
-		static void internal_SetAspect(ScriptCamera* instance, float value);
-		static float internal_GetNearClip(ScriptCamera* instance);
-		static void internal_SetNearClip(ScriptCamera* instance, float value);
-
-		static float internal_GetFarClip(ScriptCamera* instance);
-		static void internal_SetFarClip(ScriptCamera* instance, float value);
-
-		static Degree internal_GetFieldOfView(ScriptCamera* instance);
-		static void internal_SetFieldOfView(ScriptCamera* instance, Degree value);
-
-		static Rect2 internal_GetViewportRect(ScriptCamera* instance);
-		static void internal_SetViewportRect(ScriptCamera* instance, Rect2 value);
-
-		static UINT32 internal_GetProjectionType(ScriptCamera* instance);
-		static void internal_SetProjectionType(ScriptCamera* instance, UINT32 value);
-
-		static float internal_GetOrthographicHeight(ScriptCamera* instance);
-		static void internal_SetOrthographicHeight(ScriptCamera* instance, float value);
-
-		static float internal_GetOrthographicWidth(ScriptCamera* instance);
-
-		static Color internal_GetClearColor(ScriptCamera* instance);
-		static void internal_SetClearColor(ScriptCamera* instance, Color value);
-
-		static float internal_GetDepthClearValue(ScriptCamera* instance);
-		static void internal_SetDepthClearValue(ScriptCamera* instance, float value);
-
-		static UINT16 internal_GetStencilClearValue(ScriptCamera* instance);
-		static void internal_SetStencilClearValue(ScriptCamera* instance, UINT16 value);
-
-		static UINT32 internal_GetClearFlags(ScriptCamera* instance);
-		static void internal_SetClearFlags(ScriptCamera* instance, UINT32 value);
-
-		static int internal_GetPriority(ScriptCamera* instance);
-		static void internal_SetPriority(ScriptCamera* instance, int value);
-
-		static UINT64 internal_GetLayers(ScriptCamera* instance);
-		static void internal_SetLayers(ScriptCamera* instance, UINT64 value);
-
-		static Matrix4 internal_GetProjMatrix(ScriptCamera* instance);
-		static Matrix4 internal_GetProjMatrixInv(ScriptCamera* instance);
-
-		static Matrix4 internal_GetViewMatrix(ScriptCamera* instance);
-		static Matrix4 internal_GetViewMatrixInv(ScriptCamera* instance);
-
-		static int internal_GetWidthPixels(ScriptCamera* instance);
-		static int internal_GetHeightPixels(ScriptCamera* instance);
-
-		static Vector2I internal_WorldToScreen(ScriptCamera* instance, Vector3 value);
-		static Vector2 internal_WorldToClip(ScriptCamera* instance, Vector3 value);
-		static Vector3 internal_WorldToView(ScriptCamera* instance, Vector3 value);
-
-		static Vector3 internal_ScreenToWorld(ScriptCamera* instance, Vector2I value);
-		static Vector3 internal_ScreenToView(ScriptCamera* instance, Vector2I value);
-		static Vector2 internal_ScreenToClip(ScriptCamera* instance, Vector2I value);
-
-		static Vector3 internal_ViewToWorld(ScriptCamera* instance, Vector3 value);
-		static Vector2I internal_ViewToScreen(ScriptCamera* instance, Vector3 value);
-		static Vector2 internal_ViewToClip(ScriptCamera* instance, Vector3 value);
-
-		static Vector3 internal_ClipToWorld(ScriptCamera* instance, Vector2 value);
-		static Vector3 internal_ClipToView(ScriptCamera* instance, Vector2 value);
-		static Vector2I internal_ClipToScreen(ScriptCamera* instance, Vector2 value);
-
-		static Ray internal_ScreenToWorldRay(ScriptCamera* instance, Vector2I value);
-		static Vector3 internal_ProjectPoint(ScriptCamera* instance, Vector3 value);
-		static Vector3 internal_UnprojectPoint(ScriptCamera* instance, Vector3 value);
-
-		static void internal_SetRenderTarget(ScriptCamera* instance, ScriptRenderTarget* target);
-
-		static void internal_UpdateView(ScriptCamera* instance, ScriptSceneObject* parent);
-
-		SPtr<CameraHandler> mCameraHandler;
-		UINT32 mLastUpdateHash;
-	};
-}

SBansheeEngine/Include/BsScriptCameraHandler.h

@@ -0,0 +1,107 @@
+#pragma once
+
+#include "BsScriptEnginePrerequisites.h"
+#include "BsScriptObject.h"
+#include "BsVector2.h"
+#include "BsVector3.h"
+#include "BsVector2I.h"
+#include "BsRay.h"
+#include "BsDegree.h"
+#include "BsMatrix4.h"
+#include "BsRect2.h"
+#include "BsColor.h"
+
+namespace BansheeEngine
+{
+	class BS_SCR_BE_EXPORT ScriptCameraHandler : public ScriptObject<ScriptCameraHandler>
+	{
+	public:
+		SCRIPT_OBJ(BansheeEngineAssemblyName, "BansheeEngine", "CameraHandler")
+
+		SPtr<CameraHandler> getInternal() const { return mCameraHandler; }
+
+	private:
+		ScriptCameraHandler(MonoObject* managedInstance);
+		~ScriptCameraHandler();
+
+		void updateView(const HSceneObject& parent);
+
+		static void internal_Create(MonoObject* managedInstance);
+
+		static float internal_GetAspect(ScriptCameraHandler* instance);
+		static void internal_SetAspect(ScriptCameraHandler* instance, float value);
+		static float internal_GetNearClip(ScriptCameraHandler* instance);
+		static void internal_SetNearClip(ScriptCameraHandler* instance, float value);
+
+		static float internal_GetFarClip(ScriptCameraHandler* instance);
+		static void internal_SetFarClip(ScriptCameraHandler* instance, float value);
+
+		static Degree internal_GetFieldOfView(ScriptCameraHandler* instance);
+		static void internal_SetFieldOfView(ScriptCameraHandler* instance, Degree value);
+
+		static Rect2 internal_GetViewportRect(ScriptCameraHandler* instance);
+		static void internal_SetViewportRect(ScriptCameraHandler* instance, Rect2 value);
+
+		static UINT32 internal_GetProjectionType(ScriptCameraHandler* instance);
+		static void internal_SetProjectionType(ScriptCameraHandler* instance, UINT32 value);
+
+		static float internal_GetOrthographicHeight(ScriptCameraHandler* instance);
+		static void internal_SetOrthographicHeight(ScriptCameraHandler* instance, float value);
+
+		static float internal_GetOrthographicWidth(ScriptCameraHandler* instance);
+
+		static Color internal_GetClearColor(ScriptCameraHandler* instance);
+		static void internal_SetClearColor(ScriptCameraHandler* instance, Color value);
+
+		static float internal_GetDepthClearValue(ScriptCameraHandler* instance);
+		static void internal_SetDepthClearValue(ScriptCameraHandler* instance, float value);
+
+		static UINT16 internal_GetStencilClearValue(ScriptCameraHandler* instance);
+		static void internal_SetStencilClearValue(ScriptCameraHandler* instance, UINT16 value);
+
+		static UINT32 internal_GetClearFlags(ScriptCameraHandler* instance);
+		static void internal_SetClearFlags(ScriptCameraHandler* instance, UINT32 value);
+
+		static int internal_GetPriority(ScriptCameraHandler* instance);
+		static void internal_SetPriority(ScriptCameraHandler* instance, int value);
+
+		static UINT64 internal_GetLayers(ScriptCameraHandler* instance);
+		static void internal_SetLayers(ScriptCameraHandler* instance, UINT64 value);
+
+		static Matrix4 internal_GetProjMatrix(ScriptCameraHandler* instance);
+		static Matrix4 internal_GetProjMatrixInv(ScriptCameraHandler* instance);
+
+		static Matrix4 internal_GetViewMatrix(ScriptCameraHandler* instance);
+		static Matrix4 internal_GetViewMatrixInv(ScriptCameraHandler* instance);
+
+		static int internal_GetWidthPixels(ScriptCameraHandler* instance);
+		static int internal_GetHeightPixels(ScriptCameraHandler* instance);
+
+		static Vector2I internal_WorldToScreen(ScriptCameraHandler* instance, Vector3 value);
+		static Vector2 internal_WorldToClip(ScriptCameraHandler* instance, Vector3 value);
+		static Vector3 internal_WorldToView(ScriptCameraHandler* instance, Vector3 value);
+
+		static Vector3 internal_ScreenToWorld(ScriptCameraHandler* instance, Vector2I value);
+		static Vector3 internal_ScreenToView(ScriptCameraHandler* instance, Vector2I value);
+		static Vector2 internal_ScreenToClip(ScriptCameraHandler* instance, Vector2I value);
+
+		static Vector3 internal_ViewToWorld(ScriptCameraHandler* instance, Vector3 value);
+		static Vector2I internal_ViewToScreen(ScriptCameraHandler* instance, Vector3 value);
+		static Vector2 internal_ViewToClip(ScriptCameraHandler* instance, Vector3 value);
+
+		static Vector3 internal_ClipToWorld(ScriptCameraHandler* instance, Vector2 value);
+		static Vector3 internal_ClipToView(ScriptCameraHandler* instance, Vector2 value);
+		static Vector2I internal_ClipToScreen(ScriptCameraHandler* instance, Vector2 value);
+
+		static Ray internal_ScreenToWorldRay(ScriptCameraHandler* instance, Vector2I value);
+		static Vector3 internal_ProjectPoint(ScriptCameraHandler* instance, Vector3 value);
+		static Vector3 internal_UnprojectPoint(ScriptCameraHandler* instance, Vector3 value);
+
+		static void internal_SetRenderTarget(ScriptCameraHandler* instance, ScriptRenderTarget* target);
+
+		static void internal_UpdateView(ScriptCameraHandler* instance, ScriptSceneObject* parent);
+
+		SPtr<CameraHandler> mCameraHandler;
+		UINT32 mLastUpdateHash;
+	};
+}

SBansheeEngine/Include/BsScriptEnginePrerequisites.h

@@ -39,7 +39,7 @@ namespace BansheeEngine
 	class ScriptManagedResource;
 	class ScriptRenderTarget;
 	class ScriptRenderTexture2D;
-	class ScriptCamera;
+	class ScriptCameraHandler;
 	class ManagedComponent;
 	class ManagedSerializableFieldData;
 	class ManagedSerializableFieldKey;

SBansheeEngine/Include/BsScriptInput.h

@@ -28,10 +28,11 @@ namespace BansheeEngine
 		static bool internal_isButtonUp(ButtonCode code, UINT32 deviceIdx);
 		static float internal_getAxisValue(UINT32 axisType, UINT32 deviceIdx);
 		static void internal_getPointerPosition(Vector2I* position);
+		static void internal_getPointerDelta(Vector2I* position);
 
 		typedef void(__stdcall *OnButtonEventThunkDef) (ButtonCode, UINT32, MonoException**);
 		typedef void(__stdcall *OnCharInputEventThunkDef) (UINT32, MonoException**);
-		typedef void(__stdcall *OnPointerEventThunkDef) (MonoObject*, PointerEventButton, 
+		typedef void(__stdcall *OnPointerEventThunkDef) (MonoObject*, MonoObject*, PointerEventButton,
 			bool, bool, bool, float, MonoException**);
 
 		static OnButtonEventThunkDef OnButtonPressedThunk;

SBansheeEngine/SBansheeEngine.vcxproj

@@ -250,7 +250,7 @@
     <ClInclude Include="Include\BsManagedSerializableObject.h" />
     <ClInclude Include="Include\BsRuntimeScriptObjects.h" />
     <ClInclude Include="Include\BsScriptAsyncOp.h" />
-    <ClInclude Include="Include\BsScriptCamera.h" />
+    <ClInclude Include="Include\BsScriptCameraHandler.h" />
     <ClInclude Include="Include\BsScriptColor.h" />
     <ClInclude Include="Include\BsScriptComponent.h" />
     <ClInclude Include="Include\BsScriptCursor.h" />
@@ -320,7 +320,7 @@
     <ClCompile Include="Source\BsManagedResourceMetaData.cpp" />
     <ClCompile Include="Source\BsRuntimeScriptObjects.cpp" />
     <ClCompile Include="Source\BsScriptAsyncOp.cpp" />
-    <ClCompile Include="Source\BsScriptCamera.cpp" />
+    <ClCompile Include="Source\BsScriptCameraHandler.cpp" />
     <ClCompile Include="Source\BsScriptColor.cpp" />
     <ClCompile Include="Source\BsScriptComponent.cpp" />
     <ClCompile Include="Source\BsScriptCursor.cpp" />

SBansheeEngine/SBansheeEngine.vcxproj.filters

@@ -216,9 +216,6 @@
     <ClInclude Include="Include\BsScriptSerializableDictionary.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="Include\BsScriptCamera.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
     <ClInclude Include="Include\BsScriptInput.h">
       <Filter>Header Files</Filter>
     </ClInclude>
@@ -273,6 +270,9 @@
     <ClInclude Include="Include\BsScriptGUIRenderTexture.h">
       <Filter>Header Files\GUI</Filter>
     </ClInclude>
+    <ClInclude Include="Include\BsScriptCameraHandler.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Source\BsScriptTexture2D.cpp">
@@ -422,9 +422,6 @@
     <ClCompile Include="Source\BsScriptSerializableDictionary.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="Source\BsScriptCamera.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
     <ClCompile Include="Source\BsScriptInput.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
@@ -479,5 +476,8 @@
     <ClCompile Include="Source\BsScriptGUIRenderTexture.cpp">
       <Filter>Source Files\GUI</Filter>
     </ClCompile>
+    <ClCompile Include="Source\BsScriptCameraHandler.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
 </Project>

SBansheeEngine/Source/BsScriptCamera.cpp → SBansheeEngine/Source/BsScriptCameraHandler.cpp

@@ -1,4 +1,4 @@
-#include "BsScriptCamera.h"
+#include "BsScriptCameraHandler.h"
 #include "BsScriptMeta.h"
 #include "BsMonoField.h"
 #include "BsMonoClass.h"
@@ -12,98 +12,102 @@
 
 namespace BansheeEngine
 {
-	ScriptCamera::ScriptCamera(MonoObject* managedInstance)
+	ScriptCameraHandler::ScriptCameraHandler(MonoObject* managedInstance)
 		:ScriptObject(managedInstance), mCameraHandler(nullptr), mLastUpdateHash(0)
 	{ 
 		ViewportPtr primaryViewport = gApplication().getPrimaryViewport();
+		RenderTargetPtr target;
 
-		mCameraHandler = CameraHandler::create(primaryViewport->getTarget());
+		if (primaryViewport != nullptr) // TODO - Normally this should never be null, but right now there is no primary viewport
+			target = primaryViewport->getTarget();
+
+		mCameraHandler = CameraHandler::create(target);
 	}
 
-	ScriptCamera::~ScriptCamera()
+	ScriptCameraHandler::~ScriptCameraHandler()
 	{
 
 	}
 
-	void ScriptCamera::initRuntimeData()
+	void ScriptCameraHandler::initRuntimeData()
 	{
-		metaData.scriptClass->addInternalCall("Internal_Create", &ScriptCamera::internal_Create);
+		metaData.scriptClass->addInternalCall("Internal_Create", &ScriptCameraHandler::internal_Create);
 
-		metaData.scriptClass->addInternalCall("Internal_GetAspect", &ScriptCamera::internal_GetAspect);
-		metaData.scriptClass->addInternalCall("Internal_SetAspect", &ScriptCamera::internal_GetAspect);
-		metaData.scriptClass->addInternalCall("Internal_GetNearClip", &ScriptCamera::internal_GetAspect);
-		metaData.scriptClass->addInternalCall("Internal_SetNearClip", &ScriptCamera::internal_GetAspect);
+		metaData.scriptClass->addInternalCall("Internal_GetAspect", &ScriptCameraHandler::internal_GetAspect);
+		metaData.scriptClass->addInternalCall("Internal_SetAspect", &ScriptCameraHandler::internal_GetAspect);
+		metaData.scriptClass->addInternalCall("Internal_GetNearClip", &ScriptCameraHandler::internal_GetAspect);
+		metaData.scriptClass->addInternalCall("Internal_SetNearClip", &ScriptCameraHandler::internal_GetAspect);
 
-		metaData.scriptClass->addInternalCall("Internal_GetFarClip", &ScriptCamera::internal_GetAspect);
-		metaData.scriptClass->addInternalCall("Internal_SetFarClip", &ScriptCamera::internal_GetAspect);
+		metaData.scriptClass->addInternalCall("Internal_GetFarClip", &ScriptCameraHandler::internal_GetAspect);
+		metaData.scriptClass->addInternalCall("Internal_SetFarClip", &ScriptCameraHandler::internal_GetAspect);
 
-		metaData.scriptClass->addInternalCall("Internal_GetFieldOfView", &ScriptCamera::internal_GetAspect);
-		metaData.scriptClass->addInternalCall("Internal_SetFieldOfView", &ScriptCamera::internal_GetAspect);
+		metaData.scriptClass->addInternalCall("Internal_GetFieldOfView", &ScriptCameraHandler::internal_GetAspect);
+		metaData.scriptClass->addInternalCall("Internal_SetFieldOfView", &ScriptCameraHandler::internal_GetAspect);
 
-		metaData.scriptClass->addInternalCall("Internal_GetViewportRect", &ScriptCamera::internal_GetAspect);
-		metaData.scriptClass->addInternalCall("Internal_SetViewportRect", &ScriptCamera::internal_GetAspect);
+		metaData.scriptClass->addInternalCall("Internal_GetViewportRect", &ScriptCameraHandler::internal_GetAspect);
+		metaData.scriptClass->addInternalCall("Internal_SetViewportRect", &ScriptCameraHandler::internal_GetAspect);
 
-		metaData.scriptClass->addInternalCall("Internal_GetProjectionType", &ScriptCamera::internal_GetAspect);
-		metaData.scriptClass->addInternalCall("Internal_SetProjectionType", &ScriptCamera::internal_GetAspect);
+		metaData.scriptClass->addInternalCall("Internal_GetProjectionType", &ScriptCameraHandler::internal_GetAspect);
+		metaData.scriptClass->addInternalCall("Internal_SetProjectionType", &ScriptCameraHandler::internal_GetAspect);
 
-		metaData.scriptClass->addInternalCall("Internal_GetOrthographicHeight", &ScriptCamera::internal_GetAspect);
-		metaData.scriptClass->addInternalCall("Internal_SetOrthographicHeight", &ScriptCamera::internal_GetAspect);
+		metaData.scriptClass->addInternalCall("Internal_GetOrthographicHeight", &ScriptCameraHandler::internal_GetAspect);
+		metaData.scriptClass->addInternalCall("Internal_SetOrthographicHeight", &ScriptCameraHandler::internal_GetAspect);
 
-		metaData.scriptClass->addInternalCall("Internal_GetOrthographicWidth", &ScriptCamera::internal_GetAspect);
+		metaData.scriptClass->addInternalCall("Internal_GetOrthographicWidth", &ScriptCameraHandler::internal_GetAspect);
 
-		metaData.scriptClass->addInternalCall("Internal_GetClearColor", &ScriptCamera::internal_GetAspect);
-		metaData.scriptClass->addInternalCall("Internal_SetClearColor", &ScriptCamera::internal_GetAspect);
+		metaData.scriptClass->addInternalCall("Internal_GetClearColor", &ScriptCameraHandler::internal_GetAspect);
+		metaData.scriptClass->addInternalCall("Internal_SetClearColor", &ScriptCameraHandler::internal_GetAspect);
 
-		metaData.scriptClass->addInternalCall("Internal_GetDepthClearValue", &ScriptCamera::internal_GetAspect);
-		metaData.scriptClass->addInternalCall("Internal_SetDepthClearValue", &ScriptCamera::internal_GetAspect);
+		metaData.scriptClass->addInternalCall("Internal_GetDepthClearValue", &ScriptCameraHandler::internal_GetAspect);
+		metaData.scriptClass->addInternalCall("Internal_SetDepthClearValue", &ScriptCameraHandler::internal_GetAspect);
 
-		metaData.scriptClass->addInternalCall("Internal_GetStencilClearValue", &ScriptCamera::internal_GetAspect);
-		metaData.scriptClass->addInternalCall("Internal_SetStencilClearValue", &ScriptCamera::internal_GetAspect);
+		metaData.scriptClass->addInternalCall("Internal_GetStencilClearValue", &ScriptCameraHandler::internal_GetAspect);
+		metaData.scriptClass->addInternalCall("Internal_SetStencilClearValue", &ScriptCameraHandler::internal_GetAspect);
 
-		metaData.scriptClass->addInternalCall("Internal_GetClearFlags", &ScriptCamera::internal_GetAspect);
-		metaData.scriptClass->addInternalCall("Internal_SetClearFlags", &ScriptCamera::internal_GetAspect);
+		metaData.scriptClass->addInternalCall("Internal_GetClearFlags", &ScriptCameraHandler::internal_GetAspect);
+		metaData.scriptClass->addInternalCall("Internal_SetClearFlags", &ScriptCameraHandler::internal_GetAspect);
 
-		metaData.scriptClass->addInternalCall("Internal_GetPriority", &ScriptCamera::internal_GetAspect);
-		metaData.scriptClass->addInternalCall("Internal_SetPriority", &ScriptCamera::internal_GetAspect);
+		metaData.scriptClass->addInternalCall("Internal_GetPriority", &ScriptCameraHandler::internal_GetAspect);
+		metaData.scriptClass->addInternalCall("Internal_SetPriority", &ScriptCameraHandler::internal_GetAspect);
 
-		metaData.scriptClass->addInternalCall("Internal_GetLayers", &ScriptCamera::internal_GetAspect);
-		metaData.scriptClass->addInternalCall("Internal_SetLayers", &ScriptCamera::internal_GetAspect);
+		metaData.scriptClass->addInternalCall("Internal_GetLayers", &ScriptCameraHandler::internal_GetAspect);
+		metaData.scriptClass->addInternalCall("Internal_SetLayers", &ScriptCameraHandler::internal_GetAspect);
 
-		metaData.scriptClass->addInternalCall("Internal_GetProjMatrix", &ScriptCamera::internal_GetAspect);
-		metaData.scriptClass->addInternalCall("Internal_GetProjMatrixInv", &ScriptCamera::internal_GetAspect);
+		metaData.scriptClass->addInternalCall("Internal_GetProjMatrix", &ScriptCameraHandler::internal_GetAspect);
+		metaData.scriptClass->addInternalCall("Internal_GetProjMatrixInv", &ScriptCameraHandler::internal_GetAspect);
 
-		metaData.scriptClass->addInternalCall("Internal_GetViewMatrix", &ScriptCamera::internal_GetAspect);
-		metaData.scriptClass->addInternalCall("Internal_GetViewMatrixInv", &ScriptCamera::internal_GetAspect);
+		metaData.scriptClass->addInternalCall("Internal_GetViewMatrix", &ScriptCameraHandler::internal_GetAspect);
+		metaData.scriptClass->addInternalCall("Internal_GetViewMatrixInv", &ScriptCameraHandler::internal_GetAspect);
 
-		metaData.scriptClass->addInternalCall("Internal_GetWidthPixels", &ScriptCamera::internal_GetAspect);
-		metaData.scriptClass->addInternalCall("Internal_GetHeightPixels", &ScriptCamera::internal_GetAspect);
+		metaData.scriptClass->addInternalCall("Internal_GetWidthPixels", &ScriptCameraHandler::internal_GetAspect);
+		metaData.scriptClass->addInternalCall("Internal_GetHeightPixels", &ScriptCameraHandler::internal_GetAspect);
 
-		metaData.scriptClass->addInternalCall("Internal_WorldToScreen", &ScriptCamera::internal_GetAspect);
-		metaData.scriptClass->addInternalCall("Internal_WorldToClip", &ScriptCamera::internal_GetAspect);
-		metaData.scriptClass->addInternalCall("Internal_WorldToView", &ScriptCamera::internal_GetAspect);
+		metaData.scriptClass->addInternalCall("Internal_WorldToScreen", &ScriptCameraHandler::internal_GetAspect);
+		metaData.scriptClass->addInternalCall("Internal_WorldToClip", &ScriptCameraHandler::internal_GetAspect);
+		metaData.scriptClass->addInternalCall("Internal_WorldToView", &ScriptCameraHandler::internal_GetAspect);
 
-		metaData.scriptClass->addInternalCall("Internal_ScreenToWorld", &ScriptCamera::internal_GetAspect);
-		metaData.scriptClass->addInternalCall("Internal_ScreenToView", &ScriptCamera::internal_GetAspect);
-		metaData.scriptClass->addInternalCall("Internal_ScreenToClip", &ScriptCamera::internal_GetAspect);
+		metaData.scriptClass->addInternalCall("Internal_ScreenToWorld", &ScriptCameraHandler::internal_GetAspect);
+		metaData.scriptClass->addInternalCall("Internal_ScreenToView", &ScriptCameraHandler::internal_GetAspect);
+		metaData.scriptClass->addInternalCall("Internal_ScreenToClip", &ScriptCameraHandler::internal_GetAspect);
 
-		metaData.scriptClass->addInternalCall("Internal_ViewToWorld", &ScriptCamera::internal_GetAspect);
-		metaData.scriptClass->addInternalCall("Internal_ViewToScreen", &ScriptCamera::internal_GetAspect);
-		metaData.scriptClass->addInternalCall("Internal_ViewToClip", &ScriptCamera::internal_GetAspect);
+		metaData.scriptClass->addInternalCall("Internal_ViewToWorld", &ScriptCameraHandler::internal_GetAspect);
+		metaData.scriptClass->addInternalCall("Internal_ViewToScreen", &ScriptCameraHandler::internal_GetAspect);
+		metaData.scriptClass->addInternalCall("Internal_ViewToClip", &ScriptCameraHandler::internal_GetAspect);
 
-		metaData.scriptClass->addInternalCall("Internal_ClipToWorld", &ScriptCamera::internal_GetAspect);
-		metaData.scriptClass->addInternalCall("Internal_ClipToView", &ScriptCamera::internal_GetAspect);
-		metaData.scriptClass->addInternalCall("Internal_ClipToScreen", &ScriptCamera::internal_GetAspect);
+		metaData.scriptClass->addInternalCall("Internal_ClipToWorld", &ScriptCameraHandler::internal_GetAspect);
+		metaData.scriptClass->addInternalCall("Internal_ClipToView", &ScriptCameraHandler::internal_GetAspect);
+		metaData.scriptClass->addInternalCall("Internal_ClipToScreen", &ScriptCameraHandler::internal_GetAspect);
 
-		metaData.scriptClass->addInternalCall("Internal_ScreenToWorldRay", &ScriptCamera::internal_GetAspect);
-		metaData.scriptClass->addInternalCall("Internal_ProjectPoint", &ScriptCamera::internal_GetAspect);
-		metaData.scriptClass->addInternalCall("Internal_UnprojectPoint", &ScriptCamera::internal_GetAspect);
+		metaData.scriptClass->addInternalCall("Internal_ScreenToWorldRay", &ScriptCameraHandler::internal_GetAspect);
+		metaData.scriptClass->addInternalCall("Internal_ProjectPoint", &ScriptCameraHandler::internal_GetAspect);
+		metaData.scriptClass->addInternalCall("Internal_UnprojectPoint", &ScriptCameraHandler::internal_GetAspect);
 
-		metaData.scriptClass->addInternalCall("Internal_SetRenderTarget", &ScriptCamera::internal_SetRenderTarget);
+		metaData.scriptClass->addInternalCall("Internal_SetRenderTarget", &ScriptCameraHandler::internal_SetRenderTarget);
 
-		metaData.scriptClass->addInternalCall("Internal_UpdateView", &ScriptCamera::internal_UpdateView);
+		metaData.scriptClass->addInternalCall("Internal_UpdateView", &ScriptCameraHandler::internal_UpdateView);
 	}
 
-	void ScriptCamera::updateView(const HSceneObject& parent)
+	void ScriptCameraHandler::updateView(const HSceneObject& parent)
 	{
 		UINT32 curHash = parent->getTransformHash();
 		if (curHash != mLastUpdateHash)
@@ -115,120 +119,120 @@ namespace BansheeEngine
 		}
 	}
 
-	void ScriptCamera::internal_Create(MonoObject* managedInstance)
+	void ScriptCameraHandler::internal_Create(MonoObject* managedInstance)
 	{
-		ScriptCamera* nativeInstance = new (bs_alloc<ScriptCamera>()) ScriptCamera(managedInstance);
+		ScriptCameraHandler* nativeInstance = new (bs_alloc<ScriptCameraHandler>()) ScriptCameraHandler(managedInstance);
 	}
 
-	float ScriptCamera::internal_GetAspect(ScriptCamera* instance)
+	float ScriptCameraHandler::internal_GetAspect(ScriptCameraHandler* instance)
 	{
 		return instance->mCameraHandler->getAspectRatio();
 	}
 
-	void ScriptCamera::internal_SetAspect(ScriptCamera* instance, float value)
+	void ScriptCameraHandler::internal_SetAspect(ScriptCameraHandler* instance, float value)
 	{
 		instance->mCameraHandler->setAspectRatio(value);
 	}
 
-	float ScriptCamera::internal_GetNearClip(ScriptCamera* instance)
+	float ScriptCameraHandler::internal_GetNearClip(ScriptCameraHandler* instance)
 	{
 		return instance->mCameraHandler->getNearClipDistance();
 	}
 
-	void ScriptCamera::internal_SetNearClip(ScriptCamera* instance, float value)
+	void ScriptCameraHandler::internal_SetNearClip(ScriptCameraHandler* instance, float value)
 	{
 		instance->mCameraHandler->setNearClipDistance(value);
 	}
 
-	float ScriptCamera::internal_GetFarClip(ScriptCamera* instance)
+	float ScriptCameraHandler::internal_GetFarClip(ScriptCameraHandler* instance)
 	{
 		return instance->mCameraHandler->getFarClipDistance();
 	}
 
-	void ScriptCamera::internal_SetFarClip(ScriptCamera* instance, float value)
+	void ScriptCameraHandler::internal_SetFarClip(ScriptCameraHandler* instance, float value)
 	{
 		instance->mCameraHandler->setFarClipDistance(value);
 	}
 
-	Degree ScriptCamera::internal_GetFieldOfView(ScriptCamera* instance)
+	Degree ScriptCameraHandler::internal_GetFieldOfView(ScriptCameraHandler* instance)
 	{
 		return instance->mCameraHandler->getHorzFOV();
 	}
 
-	void ScriptCamera::internal_SetFieldOfView(ScriptCamera* instance, Degree value)
+	void ScriptCameraHandler::internal_SetFieldOfView(ScriptCameraHandler* instance, Degree value)
 	{
 		instance->mCameraHandler->setHorzFOV(value);
 	}
 
-	Rect2 ScriptCamera::internal_GetViewportRect(ScriptCamera* instance)
+	Rect2 ScriptCameraHandler::internal_GetViewportRect(ScriptCameraHandler* instance)
 	{
 		return instance->mCameraHandler->getViewport()->getNormArea();
 	}
 
-	void ScriptCamera::internal_SetViewportRect(ScriptCamera* instance, Rect2 value)
+	void ScriptCameraHandler::internal_SetViewportRect(ScriptCameraHandler* instance, Rect2 value)
 	{
 		instance->mCameraHandler->getViewport()->setArea(value.x, value.y, value.width, value.height);
 	}
 
-	UINT32 ScriptCamera::internal_GetProjectionType(ScriptCamera* instance)
+	UINT32 ScriptCameraHandler::internal_GetProjectionType(ScriptCameraHandler* instance)
 	{
 		return instance->mCameraHandler->getProjectionType();
 	}
 
-	void ScriptCamera::internal_SetProjectionType(ScriptCamera* instance, UINT32 value)
+	void ScriptCameraHandler::internal_SetProjectionType(ScriptCameraHandler* instance, UINT32 value)
 	{
 		instance->mCameraHandler->setProjectionType((ProjectionType)value);
 	}
 
-	float ScriptCamera::internal_GetOrthographicHeight(ScriptCamera* instance)
+	float ScriptCameraHandler::internal_GetOrthographicHeight(ScriptCameraHandler* instance)
 	{
 		return instance->mCameraHandler->getOrthoWindowHeight();
 	}
 
-	void ScriptCamera::internal_SetOrthographicHeight(ScriptCamera* instance, float value)
+	void ScriptCameraHandler::internal_SetOrthographicHeight(ScriptCameraHandler* instance, float value)
 	{
 		instance->mCameraHandler->setOrthoWindowHeight(value);
 	}
 
-	float ScriptCamera::internal_GetOrthographicWidth(ScriptCamera* instance)
+	float ScriptCameraHandler::internal_GetOrthographicWidth(ScriptCameraHandler* instance)
 	{
 		return instance->mCameraHandler->getOrthoWindowWidth();
 	}
 
-	Color ScriptCamera::internal_GetClearColor(ScriptCamera* instance)
+	Color ScriptCameraHandler::internal_GetClearColor(ScriptCameraHandler* instance)
 	{
 		return instance->mCameraHandler->getViewport()->getClearColor();
 	}
 
-	void ScriptCamera::internal_SetClearColor(ScriptCamera* instance, Color value)
+	void ScriptCameraHandler::internal_SetClearColor(ScriptCameraHandler* instance, Color value)
 	{
 		ViewportPtr vp = instance->mCameraHandler->getViewport();
 		vp->setClearValues(value, vp->getClearDepthValue(), vp->getClearStencilValue());
 	}
 
-	float ScriptCamera::internal_GetDepthClearValue(ScriptCamera* instance)
+	float ScriptCameraHandler::internal_GetDepthClearValue(ScriptCameraHandler* instance)
 	{
 		return instance->mCameraHandler->getViewport()->getClearDepthValue();
 	}
 
-	void ScriptCamera::internal_SetDepthClearValue(ScriptCamera* instance, float value)
+	void ScriptCameraHandler::internal_SetDepthClearValue(ScriptCameraHandler* instance, float value)
 	{
 		ViewportPtr vp = instance->mCameraHandler->getViewport();
 		vp->setClearValues(vp->getClearColor(), value, vp->getClearStencilValue());
 	}
 
-	UINT16 ScriptCamera::internal_GetStencilClearValue(ScriptCamera* instance)
+	UINT16 ScriptCameraHandler::internal_GetStencilClearValue(ScriptCameraHandler* instance)
 	{
 		return instance->mCameraHandler->getViewport()->getClearStencilValue();
 	}
 
-	void ScriptCamera::internal_SetStencilClearValue(ScriptCamera* instance, UINT16 value)
+	void ScriptCameraHandler::internal_SetStencilClearValue(ScriptCameraHandler* instance, UINT16 value)
 	{
 		ViewportPtr vp = instance->mCameraHandler->getViewport();
 		vp->setClearValues(vp->getClearColor(), vp->getClearDepthValue(), value);
 	}
 
-	UINT32 ScriptCamera::internal_GetClearFlags(ScriptCamera* instance)
+	UINT32 ScriptCameraHandler::internal_GetClearFlags(ScriptCameraHandler* instance)
 	{
 		ViewportPtr vp = instance->mCameraHandler->getViewport();
 		UINT32 clearFlags = 0;
@@ -240,7 +244,7 @@ namespace BansheeEngine
 		return clearFlags;
 	}
 
-	void ScriptCamera::internal_SetClearFlags(ScriptCamera* instance, UINT32 value)
+	void ScriptCameraHandler::internal_SetClearFlags(ScriptCameraHandler* instance, UINT32 value)
 	{
 		ViewportPtr vp = instance->mCameraHandler->getViewport();
 
@@ -248,136 +252,136 @@ namespace BansheeEngine
 			(value & 0x02) != 0, (value & 0x04) != 0);
 	}
 
-	int ScriptCamera::internal_GetPriority(ScriptCamera* instance)
+	int ScriptCameraHandler::internal_GetPriority(ScriptCameraHandler* instance)
 	{
 		return instance->mCameraHandler->getPriority();
 	}
 
-	void ScriptCamera::internal_SetPriority(ScriptCamera* instance, int value)
+	void ScriptCameraHandler::internal_SetPriority(ScriptCameraHandler* instance, int value)
 	{
 		instance->mCameraHandler->setPriority(value);
 	}
 
-	UINT64 ScriptCamera::internal_GetLayers(ScriptCamera* instance)
+	UINT64 ScriptCameraHandler::internal_GetLayers(ScriptCameraHandler* instance)
 	{
 		return instance->mCameraHandler->getLayers();
 	}
 
-	void ScriptCamera::internal_SetLayers(ScriptCamera* instance, UINT64 value)
+	void ScriptCameraHandler::internal_SetLayers(ScriptCameraHandler* instance, UINT64 value)
 	{
 		instance->mCameraHandler->setLayers(value);
 	}
 
-	Matrix4 ScriptCamera::internal_GetProjMatrix(ScriptCamera* instance)
+	Matrix4 ScriptCameraHandler::internal_GetProjMatrix(ScriptCameraHandler* instance)
 	{
 		return instance->mCameraHandler->getProjectionMatrixRS();
 	}
 
-	Matrix4 ScriptCamera::internal_GetProjMatrixInv(ScriptCamera* instance)
+	Matrix4 ScriptCameraHandler::internal_GetProjMatrixInv(ScriptCameraHandler* instance)
 	{
 		return instance->mCameraHandler->getProjectionMatrixRSInv();
 	}
 
-	Matrix4 ScriptCamera::internal_GetViewMatrix(ScriptCamera* instance)
+	Matrix4 ScriptCameraHandler::internal_GetViewMatrix(ScriptCameraHandler* instance)
 	{
 		return instance->mCameraHandler->getViewMatrix();
 	}
 
-	Matrix4 ScriptCamera::internal_GetViewMatrixInv(ScriptCamera* instance)
+	Matrix4 ScriptCameraHandler::internal_GetViewMatrixInv(ScriptCameraHandler* instance)
 	{
 		return instance->mCameraHandler->getViewMatrixInv();
 	}
 
-	int ScriptCamera::internal_GetWidthPixels(ScriptCamera* instance)
+	int ScriptCameraHandler::internal_GetWidthPixels(ScriptCameraHandler* instance)
 	{
 		ViewportPtr vp = instance->mCameraHandler->getViewport();
 
 		return vp->getWidth();
 	}
 
-	int ScriptCamera::internal_GetHeightPixels(ScriptCamera* instance)
+	int ScriptCameraHandler::internal_GetHeightPixels(ScriptCameraHandler* instance)
 	{
 		ViewportPtr vp = instance->mCameraHandler->getViewport();
 
 		return vp->getHeight();
 	}
 
-	Vector2I ScriptCamera::internal_WorldToScreen(ScriptCamera* instance, Vector3 value)
+	Vector2I ScriptCameraHandler::internal_WorldToScreen(ScriptCameraHandler* instance, Vector3 value)
 	{
 		return instance->mCameraHandler->worldToScreenPoint(value);
 	}
 
-	Vector2 ScriptCamera::internal_WorldToClip(ScriptCamera* instance, Vector3 value)
+	Vector2 ScriptCameraHandler::internal_WorldToClip(ScriptCameraHandler* instance, Vector3 value)
 	{
 		return instance->mCameraHandler->worldToClipPoint(value);
 	}
 
-	Vector3 ScriptCamera::internal_WorldToView(ScriptCamera* instance, Vector3 value)
+	Vector3 ScriptCameraHandler::internal_WorldToView(ScriptCameraHandler* instance, Vector3 value)
 	{
 		return instance->mCameraHandler->worldToViewPoint(value);
 	}
 
-	Vector3 ScriptCamera::internal_ScreenToWorld(ScriptCamera* instance, Vector2I value)
+	Vector3 ScriptCameraHandler::internal_ScreenToWorld(ScriptCameraHandler* instance, Vector2I value)
 	{
 		return instance->mCameraHandler->screenToWorldPoint(value);
 	}
 
-	Vector3 ScriptCamera::internal_ScreenToView(ScriptCamera* instance, Vector2I value)
+	Vector3 ScriptCameraHandler::internal_ScreenToView(ScriptCameraHandler* instance, Vector2I value)
 	{
 		return instance->mCameraHandler->screenToViewPoint(value);
 	}
 
-	Vector2 ScriptCamera::internal_ScreenToClip(ScriptCamera* instance, Vector2I value)
+	Vector2 ScriptCameraHandler::internal_ScreenToClip(ScriptCameraHandler* instance, Vector2I value)
 	{
 		return instance->mCameraHandler->screenToClipPoint(value);
 	}
 
-	Vector3 ScriptCamera::internal_ViewToWorld(ScriptCamera* instance, Vector3 value)
+	Vector3 ScriptCameraHandler::internal_ViewToWorld(ScriptCameraHandler* instance, Vector3 value)
 	{
 		return instance->mCameraHandler->viewToWorldPoint(value);
 	}
 
-	Vector2I ScriptCamera::internal_ViewToScreen(ScriptCamera* instance, Vector3 value)
+	Vector2I ScriptCameraHandler::internal_ViewToScreen(ScriptCameraHandler* instance, Vector3 value)
 	{
 		return instance->mCameraHandler->viewToScreenPoint(value);
 	}
 
-	Vector2 ScriptCamera::internal_ViewToClip(ScriptCamera* instance, Vector3 value)
+	Vector2 ScriptCameraHandler::internal_ViewToClip(ScriptCameraHandler* instance, Vector3 value)
 	{
 		return instance->mCameraHandler->viewToClipPoint(value);
 	}
 
-	Vector3 ScriptCamera::internal_ClipToWorld(ScriptCamera* instance, Vector2 value)
+	Vector3 ScriptCameraHandler::internal_ClipToWorld(ScriptCameraHandler* instance, Vector2 value)
 	{
 		return instance->mCameraHandler->clipToWorldPoint(value);
 	}
 
-	Vector3 ScriptCamera::internal_ClipToView(ScriptCamera* instance, Vector2 value)
+	Vector3 ScriptCameraHandler::internal_ClipToView(ScriptCameraHandler* instance, Vector2 value)
 	{
 		return instance->mCameraHandler->clipToViewPoint(value);
 	}
 
-	Vector2I ScriptCamera::internal_ClipToScreen(ScriptCamera* instance, Vector2 value)
+	Vector2I ScriptCameraHandler::internal_ClipToScreen(ScriptCameraHandler* instance, Vector2 value)
 	{
 		return instance->mCameraHandler->clipToScreenPoint(value);
 	}
 
-	Ray ScriptCamera::internal_ScreenToWorldRay(ScriptCamera* instance, Vector2I value)
+	Ray ScriptCameraHandler::internal_ScreenToWorldRay(ScriptCameraHandler* instance, Vector2I value)
 	{
 		return instance->mCameraHandler->screenPointToRay(value);
 	}
 
-	Vector3 ScriptCamera::internal_ProjectPoint(ScriptCamera* instance, Vector3 value)
+	Vector3 ScriptCameraHandler::internal_ProjectPoint(ScriptCameraHandler* instance, Vector3 value)
 	{
 		return instance->mCameraHandler->projectPoint(value);
 	}
 
-	Vector3 ScriptCamera::internal_UnprojectPoint(ScriptCamera* instance, Vector3 value)
+	Vector3 ScriptCameraHandler::internal_UnprojectPoint(ScriptCameraHandler* instance, Vector3 value)
 	{
 		return instance->mCameraHandler->unprojectPoint(value);
 	}
 
-	void ScriptCamera::internal_SetRenderTarget(ScriptCamera* instance, ScriptRenderTarget* target)
+	void ScriptCameraHandler::internal_SetRenderTarget(ScriptCameraHandler* instance, ScriptRenderTarget* target)
 	{
 		if (target == nullptr)
 		{
@@ -391,7 +395,7 @@ namespace BansheeEngine
 		}
 	}
 
-	void ScriptCamera::internal_UpdateView(ScriptCamera* instance, ScriptSceneObject* parent)
+	void ScriptCameraHandler::internal_UpdateView(ScriptCameraHandler* instance, ScriptSceneObject* parent)
 	{
 		HSceneObject parentSO = parent->getNativeSceneObject();
 

SBansheeEngine/Source/BsScriptInput.cpp

@@ -36,14 +36,15 @@ namespace BansheeEngine
 		metaData.scriptClass->addInternalCall("Internal_IsButtonUp", &ScriptInput::internal_isButtonUp);
 		metaData.scriptClass->addInternalCall("Internal_GetAxisValue", &ScriptInput::internal_getAxisValue);
 		metaData.scriptClass->addInternalCall("Internal_GetPointerPosition", &ScriptInput::internal_getPointerPosition);
+		metaData.scriptClass->addInternalCall("Internal_GetPointerDelta", &ScriptInput::internal_getPointerDelta);
 
 		OnButtonPressedThunk = (OnButtonEventThunkDef)metaData.scriptClass->getMethodExact("Internal_TriggerButtonDown", "ButtonCode,int")->getThunk();
 		OnButtonReleasedThunk = (OnButtonEventThunkDef)metaData.scriptClass->getMethodExact("Internal_TriggerButtonUp", "ButtonCode,int")->getThunk();
 		OnCharInputThunk = (OnCharInputEventThunkDef)metaData.scriptClass->getMethodExact("Internal_TriggerCharInput", "int")->getThunk();
-		OnPointerPressedThunk = (OnPointerEventThunkDef)metaData.scriptClass->getMethodExact("Internal_TriggerPointerPressed", "Vector2I,PointerEventButton,bool,bool,bool,single")->getThunk();
-		OnPointerReleasedThunk = (OnPointerEventThunkDef)metaData.scriptClass->getMethodExact("Internal_TriggerPointerReleased", "Vector2I,PointerEventButton,bool,bool,bool,single")->getThunk();
-		OnPointerMovedThunk = (OnPointerEventThunkDef)metaData.scriptClass->getMethodExact("Internal_TriggerPointerMove", "Vector2I,PointerEventButton,bool,bool,bool,single")->getThunk();
-		OnPointerDoubleClickThunk = (OnPointerEventThunkDef)metaData.scriptClass->getMethodExact("Internal_TriggerPointerDoubleClick", "Vector2I,PointerEventButton,bool,bool,bool,single")->getThunk();
+		OnPointerPressedThunk = (OnPointerEventThunkDef)metaData.scriptClass->getMethodExact("Internal_TriggerPointerPressed", "Vector2I,Vector2I,PointerEventButton,bool,bool,bool,single")->getThunk();
+		OnPointerReleasedThunk = (OnPointerEventThunkDef)metaData.scriptClass->getMethodExact("Internal_TriggerPointerReleased", "Vector2I,Vector2I,PointerEventButton,bool,bool,bool,single")->getThunk();
+		OnPointerMovedThunk = (OnPointerEventThunkDef)metaData.scriptClass->getMethodExact("Internal_TriggerPointerMove", "Vector2I,Vector2I,PointerEventButton,bool,bool,bool,single")->getThunk();
+		OnPointerDoubleClickThunk = (OnPointerEventThunkDef)metaData.scriptClass->getMethodExact("Internal_TriggerPointerDoubleClick", "Vector2I,Vector2I,PointerEventButton,bool,bool,bool,single")->getThunk();
 	}
 
 	void ScriptInput::startUp()
@@ -98,8 +99,9 @@ namespace BansheeEngine
 	{
 		MonoException* exception = nullptr;
 		MonoObject* screenPos = ScriptVector2I::box(ev.screenPos);
+		MonoObject* delta = ScriptVector2I::box(ev.delta);
 
-		OnPointerMovedThunk(screenPos, ev.button, ev.shift, ev.control, ev.alt, ev.mouseWheelScrollAmount, &exception);
+		OnPointerMovedThunk(screenPos, delta, ev.button, ev.shift, ev.control, ev.alt, ev.mouseWheelScrollAmount, &exception);
 
 		MonoUtil::throwIfException(exception);
 	}
@@ -108,8 +110,9 @@ namespace BansheeEngine
 	{
 		MonoException* exception = nullptr;
 		MonoObject* screenPos = ScriptVector2I::box(ev.screenPos);
+		MonoObject* delta = ScriptVector2I::box(ev.delta);
 
-		OnPointerPressedThunk(screenPos, ev.button, ev.shift, ev.control, ev.alt, ev.mouseWheelScrollAmount, &exception);
+		OnPointerPressedThunk(screenPos, delta, ev.button, ev.shift, ev.control, ev.alt, ev.mouseWheelScrollAmount, &exception);
 
 		MonoUtil::throwIfException(exception);
 	}
@@ -118,8 +121,9 @@ namespace BansheeEngine
 	{
 		MonoException* exception = nullptr;
 		MonoObject* screenPos = ScriptVector2I::box(ev.screenPos);
+		MonoObject* delta = ScriptVector2I::box(ev.delta);
 
-		OnPointerReleasedThunk(screenPos, ev.button, ev.shift, ev.control, ev.alt, ev.mouseWheelScrollAmount, &exception);
+		OnPointerReleasedThunk(screenPos, delta, ev.button, ev.shift, ev.control, ev.alt, ev.mouseWheelScrollAmount, &exception);
 
 		MonoUtil::throwIfException(exception);
 	}
@@ -128,8 +132,9 @@ namespace BansheeEngine
 	{
 		MonoException* exception = nullptr;
 		MonoObject* screenPos = ScriptVector2I::box(ev.screenPos);
+		MonoObject* delta = ScriptVector2I::box(ev.delta);
 
-		OnPointerDoubleClickThunk(screenPos, ev.button, ev.shift, ev.control, ev.alt, ev.mouseWheelScrollAmount, &exception);
+		OnPointerDoubleClickThunk(screenPos, delta, ev.button, ev.shift, ev.control, ev.alt, ev.mouseWheelScrollAmount, &exception);
 
 		MonoUtil::throwIfException(exception);
 	}
@@ -158,4 +163,9 @@ namespace BansheeEngine
 	{
 		*position = Input::instance().getPointerPosition();
 	}
+
+	void ScriptInput::internal_getPointerDelta(Vector2I* position)
+	{
+		*position = Input::instance().getPointerDelta();
+	}
 }

TODO.txt

@@ -12,21 +12,23 @@
 
 See GDrive/Resources doc for resources refactor
 
+Add cutoff plane when rendering discs for rotation handle.
+
 C# SceneView:
 Test new Scene window and fix every issue
 Add ProjectWindow and HierarchyWindow to C#
  - Make TreeViews a C# element?
 Set up a default layout and save it
 
-Handle snapping is probably set up wrong. Handles.SnapValue seems to wrap a value instead of snapping, plus I might
-need to store the unsnapped amount somewhere until it reaches some amount worthy of snapping to next value
+Test:
+ - If cursor wrap works
+ - If handles work when dragged outside of scene window
+ - If handle is properly released if mouse up is pressed outside
 
 -----------------
 
 Move handle is buggy as hell - It moves in wrong direction sometimes, sometimes it skips, other times collision seems to be wrong
 Need a way to drag and drop items from Scene tree view to Scene view
-When dragging a handle make sure it works when cursor leaves the scene view
-Also make sure that handle manager receives mouse up event if its done outside of scene view
 
 AFTER I have scene widget in C#:
  - Finish up C# Handles class so it returns proper values