+Unity Runtime codeHEADmaster

1 files changed, 719 insertions, 0 deletions

diff --git a/Runtime/Input/TouchPhaseEmulation.cpp b/Runtime/Input/TouchPhaseEmulation.cpp
new file mode 100644
index 0000000..be1ab28
--- /dev/null
+++ b/Runtime/Input/TouchPhaseEmulation.cpp
@@ -0,0 +1,719 @@
+#include "UnityPrefix.h"
+
+/*
+ * TouchPhaseEmulation is layer between an 'event-based' touch OS (Android, Metro etc) and our phase-based script API (similar to iOS).
+ *
+ * The core logic of this layer is in DispatchTouchEvent, which handles mapping and collapsing of events to a frame-discrete phase.
+ */
+
+#define DEBUG_TOUCH_EMU	(DEBUGMODE && 0)
+
+#include "TouchPhaseEmulation.h"
+
+#if UNITY_BLACKBERRY
+		static const int touchTimeout = 400;
+#else
+		static const int touchTimeout = 150;
+#endif
+
+// *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
+
+class TouchImpl : public Touch
+{
+	enum { kEmptyTouchId = ~0UL };
+
+public:
+	TouchImpl ()
+	{
+		clear ();
+	}
+
+	long long timestamp;     // in milliseconds
+	UInt32 pointerId;        // matches OS pointerId
+	size_t frameToReport;    // frame # for this event to be reported. Should
+	                         // only be =gFrameCount or =gFrameCount+1
+	size_t frameBegan;       // frame # when BEGIN event was received
+	UInt32 endPhaseInQueue;  // acts both as a bool to indicate that this event
+	                         // has already received an END/CANCEL from OS and
+	                         // will be reported to scripts next frame, and as
+	                         // a container to hold the actual value: was it
+	                         // END or CANCEL?
+
+	void setDeltaTime (long long newTimestamp)
+	{
+		if (timestamp == 0)
+			return;
+
+		deltaTime = (newTimestamp - timestamp) / 1000.0f;
+	}
+
+	void setDeltaPos (Vector2f const& newPos)
+	{
+		if (CompareApproximately (pos, Vector2f::zero))
+			return;
+
+		deltaPos = newPos - pos;
+	}
+
+	bool isMultitap (long long newTimestamp, Vector2f const& newPos, float screenDPI)
+	{
+		static const float tapZoneRadiusCM = 0.4f;	// 4mm
+		static const float cmToInch = 0.393701f;
+		static const float multitapRadiusPixels = screenDPI * tapZoneRadiusCM * cmToInch;
+		static const float multitapRadiusSqr = multitapRadiusPixels * multitapRadiusPixels;
+
+		return newTimestamp - timestamp < touchTimeout
+		       && SqrMagnitude (pos - newPos) < multitapRadiusSqr;
+	}
+
+	void setTapCount (long long newTimestamp, Vector2f const &newPos, float screenDPI)
+	{
+		if (isMultitap (newTimestamp, newPos, screenDPI))
+			++tapCount;
+		else
+			tapCount = 1;
+	}
+
+	void init(size_t _pointerId, Vector2f _pos, TouchPhaseEmulation::TouchPhase _phase,
+				long long _timestamp, size_t currFrame)
+	{
+		pointerId		= _pointerId;
+		pos				= _pos;
+		rawPos			= _pos;
+		phase			= _phase;
+		frameBegan		= currFrame;
+		timestamp		= _timestamp;
+		frameToReport	= currFrame;
+	}
+
+	void clear ()
+	{
+		id = kEmptyTouchId;
+		phase = TouchPhaseEmulation::kTouchCanceled;
+		endPhaseInQueue = 0;
+		deltaPos = Vector2f (0.0f, 0.0f);
+		deltaTime = 0.0f;
+		frameToReport = 0;
+		frameBegan = 0;
+		tapCount = 0;
+		rawPos = pos = Vector2f (0.0f, 0.0f);
+		timestamp = 0;
+		pointerId = kEmptyTouchId;
+	}
+
+	bool isOld (size_t frame) const
+	{
+		return frameToReport < frame;
+	}
+
+	bool isEmpty () const
+	{
+		return id == kEmptyTouchId;
+	}
+
+	bool isFinished () const
+	{
+		return !isEmpty () && IsEnd (phase);
+	}
+
+	bool willBeFinishedNextFrame () const
+	{
+		return !isEmpty () && IsEnd (endPhaseInQueue);
+	}
+
+	bool isNow (size_t frame) const
+	{
+		return frameToReport == frame;
+	}
+
+	static bool IsBegin (size_t phase)
+	{
+		return phase == TouchPhaseEmulation::kTouchBegan;
+	}
+
+	static bool IsTransitional (size_t phase)
+	{
+		return phase == TouchPhaseEmulation::kTouchMoved || phase == TouchPhaseEmulation::kTouchStationary;
+	}
+
+	static bool IsEnd (size_t phase)
+	{
+		return phase == TouchPhaseEmulation::kTouchEnded || phase == TouchPhaseEmulation::kTouchCanceled;
+	}
+
+
+#if DEBUG_TOUCH_EMU
+	void dump (TouchImpl* gAllTouches)
+	{
+		size_t index = this - gAllTouches;
+		char const* phaseNames[] = {
+			"<Began>",
+			"<Moved>",
+			"<Stationary>",
+			"<Ended>",
+			"<Canceled>",
+		};
+
+		char const *fmt =
+		"T[%02d]={fid=%d, pid=%d, phase=%s, p=(%3.1f,%3.1f), dp=(%3.1f,%3.1f),\n"
+		"       tm=%lld, dtm=%f, endPhaseQ=%d, fbeg=%d, frep=%d, tcnt=%d}\n";
+
+		printf_console (fmt, index, id, pointerId, phaseNames[phase], pos.x, pos.y,
+		                deltaPos.x, deltaPos.y, timestamp, deltaTime,
+		                endPhaseInQueue, frameBegan, frameToReport, tapCount);
+	}
+#endif
+};
+
+// *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
+
+TouchPhaseEmulation::TouchPhaseEmulation(float screenDPI, bool singleTouchDevice)
+:	m_AllocatedFingerIDs(0)
+,	m_FrameCount(0)
+,	m_ScreenDPI(screenDPI)
+,	m_IsMultiTouchEnabled(!singleTouchDevice)
+,	m_IsSingleTouchDevice(singleTouchDevice)
+{
+	m_TouchSlots = new TouchImpl[kMaxTouchCount];
+	InitTouches();
+}
+
+TouchPhaseEmulation::~TouchPhaseEmulation()
+{
+	delete [] m_TouchSlots;
+}
+
+void TouchPhaseEmulation::InitTouches ()
+{
+	for (size_t i = 0; i < kMaxTouchCount; ++i)
+	{
+		m_TouchSlots[i].clear();
+	}
+	m_AllocatedFingerIDs = 0;
+
+	m_FrameCount = 1;
+}
+
+void TouchPhaseEmulation::PreprocessTouches ()
+{
+	DiscardRedundantTouches();
+}
+
+void TouchPhaseEmulation::PostprocessTouches ()
+{
+#if DEBUG_TOUCH_EMU
+	DumpAll ();
+#endif
+	++m_FrameCount;
+	UpdateActiveTouches();
+}
+
+
+bool TouchPhaseEmulation::IsExistingTouch( int pointerId )
+{
+	TouchImpl*	matchingSlots[kMaxTouchCount];
+	const size_t slotsFound = FindByPointerId(matchingSlots, pointerId);
+
+	for (size_t i = 0; i < slotsFound; ++i)
+		if (matchingSlots[i])
+			return true;
+
+	return false;
+}
+
+void TouchPhaseEmulation::AddTouchEvent (int pointerId, float x, float y, TouchPhase newPhase, long long timestamp)
+{
+	Vector2f pos = Vector2f (x, y);
+
+#if UNITY_WINRT
+	// [Metro] With one finger touching; that touch pointerId is usually > 0
+	if (!m_IsMultiTouchEnabled && GetTouchCount() > 0 && !IsExistingTouch(pointerId))
+		return;
+#else
+	if (!m_IsMultiTouchEnabled && pointerId > 0)
+		return;
+#endif
+
+	DispatchTouchEvent (pointerId, pos, static_cast<TouchPhase> (newPhase), timestamp, m_FrameCount);
+}
+
+void TouchPhaseEmulation::DispatchTouchEvent (size_t pointerId, Vector2f pos, TouchPhase newPhase, long long timestamp, size_t currFrame)
+{
+	// Brief terminology legend:
+	//		action			The OS level indication of what happened in a particular touch event; DOWN, MOVE, UP etc.
+	//		phase			Logical state of a touch, emulated to the script side; Began/Moved/Ended.
+	//						Phase is considered constant per frame, and all intra-frame actions are collapsed to a single phase.
+	//						If two actions can't be collapsed (like UP/DOWN), then the DOWN action will be delayed one frame.
+	//		pointerId		The ID given to a touch event by the OS. These IDs can be reused if touches end/start within the same frame.
+	//		fingerId		The ID we give a touch when presented to the script side. Also known as 'id' in the Touch struct.
+	//		touch event		OS level touch information
+	//		touch slot		Script level touch information.
+
+	// Step 1: Determine if already tracking this 'pointerId'
+	//			We do this by looping through all touch slots while looking for an active touch with matching 'pointerId'.
+	//			If a slot with phase == Ended has been inactive for 150ms => set it to Inactive
+	// Step 2: Determine if an old touch slot should be updated with the new event information, or if a new touch slot should be allocated.
+	//			If no touch slot was found in Step 1 => allocate a new touch slot. Skip to step 4.
+	//			If only a singular touch slot was found in Step 1 => use that slot. Skip to step 4.
+	//			If multiple slots were found in Step 1 => determine which slot to use, or if another slot needs to be allocated.
+	// Step 3: Determine which active slot to use, or allocate a new.
+	//			If phase == Began : for each slot with phase == Ended, consider event to be a multi-tap by comparing position and timestamp.
+	//			If phase != Began : find slot with phase != Ended (should only be one!)
+	//			If no slot matches : allocate a new slot with fingerId = highestFingerIdUsed + 1.
+	// Step 4: Initialize/update the touch slot based on current and old touch phase.
+	//			If new phase == Began and old phase == Ended => increase tap count.
+	//			If new phase == Began => try to compact finger id
+	//			If new phase == Ended and old phase == Began on the same frame => delay new phase (Ended) until next frame.
+	//			If new phase == Moved and old phase == Stationary => check distance against threshold for Moved/Stationary.
+	//
+	// After every frame, loop through all active touch slots:
+	//			If a delayed phase (Ended) was enabled => update the phase.
+	//			If a touch != Ended wasn't updated this frame => set phase = Stationary
+	//			If a touch began and ended the this frame, and it resulted in another, currently active, touch having an increased tap count
+	//				=> clear those extra touches, and compact the finger id
+
+	// NB: for now we do use passed position as both raw position and position
+	// on ios, where we actually implement raw position, different code is used
+
+	FreeExpiredTouches(m_FrameCount, timestamp);
+
+	TouchImpl*	matchingSlots[kMaxTouchCount];
+	const size_t slotsFound = FindByPointerId(matchingSlots, pointerId);
+
+	TouchImpl* touch = NULL;
+	int inheritedTapCount = 0;
+
+#if UNITY_WINRT
+	// [Metro] Calculate tapCount manually as pointerIds aren't reused.
+	if (TouchImpl::IsBegin(newPhase))
+		inheritedTapCount += CalculateTapCount(timestamp, pos);
+#endif
+
+	for (size_t i = 0; i < slotsFound; ++i)
+	{
+		TouchImpl* slot = matchingSlots[i];
+
+		bool touchFinished = slot->isFinished() || slot->willBeFinishedNextFrame();
+		if (TouchImpl::IsBegin(newPhase))
+		{
+			if (touchFinished)
+			{
+				if (slot->isOld(m_FrameCount))
+				{
+					touch = slot;
+				}
+
+				if (slot->isMultitap(timestamp, pos, m_ScreenDPI))
+				{
+					inheritedTapCount = slot->tapCount;
+				}
+			}
+		}
+		else
+		{
+			if (!touchFinished)
+			{
+				if (touch)
+				{
+					if (DEBUGMODE) printf_console("Stale/stuck touch released.");
+					ExpireOld(*touch);
+				}
+				touch = slot;
+			}
+		}
+	}
+
+	if (!touch)
+	{
+		if (!TouchImpl::IsBegin(newPhase))
+		{
+			if (DEBUGMODE) printf_console("Dropping touch event part of canceled gesture.");
+			return;
+		}
+		if (!(touch = AllocateNew()))
+			return;
+	}
+
+	if (TouchImpl::IsBegin (newPhase))
+	{
+		touch->tapCount = inheritedTapCount;
+	#if DEBUG_TOUCH_EMU
+		printf_console("Slot before initialized:");
+		touch->dump(m_TouchSlots);
+	#endif
+
+		touch->init( pointerId, pos, newPhase, timestamp, currFrame );
+		touch->setTapCount( timestamp, pos, m_ScreenDPI );
+		touch->id = CompactFingerID(touch->id);
+
+	#if DEBUG_TOUCH_EMU
+		printf_console("Slot initialized:");
+		touch->dump(m_TouchSlots);
+	#endif
+		return;
+	}
+	else if (TouchImpl::IsEnd (newPhase))
+	{
+		// if touch began this frame, we will delay end phase for one frame
+		if (touch->frameBegan == currFrame)
+			touch->endPhaseInQueue = newPhase;
+		else
+			touch->phase = newPhase;
+
+		// Android only sends CANCELED on the first pointer in a gesture - kill all other active touches when this happens.
+		if (newPhase == kTouchCanceled)
+		{
+			for (size_t i = 0; i < kMaxTouchCount; ++i)
+			{
+				TouchImpl* slot = &m_TouchSlots[i];
+				if (slot->isEmpty() || slot->isFinished() || slot->willBeFinishedNextFrame())
+					continue;
+				slot->endPhaseInQueue = newPhase;
+		#if DEBUG_TOUCH_EMU
+				m_TouchSlots[i].dump(m_TouchSlots);
+		#endif
+			}
+		}
+	}
+	else if (newPhase == kTouchMoved
+	         && touch->phase == kTouchStationary)
+	{
+		// old event is STATIONARY, the new one is MOVE. Android does not
+		// report STATIONARY Events, so if MOVE's deltaPos is not big enough,
+		// let's keep it STATIONARY. Promote to MOVE otherwise.
+		static const float deltaPosTolerance = 0.5f;
+		if (Magnitude (touch->pos - pos) >= deltaPosTolerance)
+			touch->phase = newPhase;
+	}
+
+	touch->setDeltaPos (pos);
+	touch->pos = pos;
+
+	touch->setDeltaTime (timestamp);
+	touch->timestamp = timestamp;
+	touch->frameToReport = currFrame;
+
+#if DEBUG_TOUCH_EMU
+	printf_console("Slot updated:");
+	touch->dump(m_TouchSlots);
+#endif
+
+}
+
+size_t TouchPhaseEmulation::FindByPointerId(TouchImpl* matchingSlots[kMaxTouchCount], size_t pointerId)
+{
+#if DEBUG_TOUCH_EMU
+	printf_console("%s", __FUNCTION__);
+#endif
+	size_t slotsFound = 0;
+	for (size_t i = 0; i < kMaxTouchCount; ++i)
+	{
+		if (m_TouchSlots[i].pointerId != pointerId)
+			continue;
+#if DEBUG_TOUCH_EMU
+		m_TouchSlots[i].dump(m_TouchSlots);
+#endif
+		matchingSlots[slotsFound++] = &m_TouchSlots[i];
+	}
+	return slotsFound;
+}
+
+TouchImpl* TouchPhaseEmulation::AllocateNew()
+{
+#if DEBUG_TOUCH_EMU
+	printf_console("%s", __FUNCTION__);
+#endif
+	// allocate virtual fingerId
+	int fingerId = 0;
+	const int maxFingerId = sizeof(m_AllocatedFingerIDs) * 8;
+	for (; fingerId < maxFingerId; ++fingerId)
+	{
+		UInt32 bitField = (1 << fingerId);
+		if (m_AllocatedFingerIDs & bitField)
+			continue;
+		m_AllocatedFingerIDs |= bitField;
+		break;
+	}
+	if (fingerId >= maxFingerId)
+	{
+		Assert (!"Out of virtual finger IDs!");
+		return NULL;
+	}
+
+	// find empty slot for touch
+	for (size_t i = 0; i < kMaxTouchCount; ++i)
+	{
+		TouchImpl& t = m_TouchSlots[i];
+
+		if (!t.isEmpty())
+			continue;
+
+		t.id				= fingerId;
+		t.deltaPos			= Vector2f(0, 0);
+		t.deltaTime			= 0.0f;
+		t.endPhaseInQueue	= 0;
+
+		return &t;
+	}
+
+	Assert (!"Out of free touches!");
+	return NULL;
+}
+
+void TouchPhaseEmulation::ExpireOld(TouchImpl& touch)
+{
+#if DEBUG_TOUCH_EMU
+	printf_console("%s", __FUNCTION__);
+#endif
+
+	if (touch.isEmpty())
+	{
+		ErrorString("Trying to expire empty touch slot!");
+		return;
+	}
+
+	// deallocate virtual fingerId
+	UInt32 bitField = (1 << touch.id);
+	Assert((m_AllocatedFingerIDs & bitField) && "Touch with stale finger ID killed!");
+	m_AllocatedFingerIDs &= ~bitField;
+
+	Assert(!touch.endPhaseInQueue && "Delayed touch killed prematurely!");
+	touch.clear();
+}
+
+int TouchPhaseEmulation::CompactFingerID(int id)
+{
+	int fingerId = 0;
+	const int maxFingerId = sizeof(m_AllocatedFingerIDs) * 8;
+	for (; fingerId < maxFingerId; ++fingerId)
+	{
+		UInt32 bitField = (1 << fingerId);
+		if (m_AllocatedFingerIDs & bitField)
+			continue;
+
+		if (id < fingerId)
+			return id;
+
+		m_AllocatedFingerIDs |= bitField;
+		bitField = (1 << id);
+		Assert((m_AllocatedFingerIDs & bitField) && "Touch with stale finger ID killed!");
+		m_AllocatedFingerIDs &= ~bitField;
+		id = fingerId;
+		break;
+	}
+	return id;
+}
+
+void TouchPhaseEmulation::FreeExpiredTouches (size_t eventFrame, long long timestamp)
+{
+	for (size_t i = 0; i < kMaxTouchCount; ++i)
+	{
+		TouchImpl& touch = m_TouchSlots[i];
+
+		if (touch.isEmpty())
+			continue;
+
+		long long age = timestamp - touch.timestamp;
+		if (touch.isOld(eventFrame) && touch.isFinished() && age > touchTimeout)
+		{
+			ExpireOld(touch);
+		}
+	}
+}
+
+void TouchPhaseEmulation::DiscardRedundantTouches()
+{
+	for (size_t i = 0; i < kMaxTouchCount; ++i)
+	{
+		TouchImpl* t0 = &m_TouchSlots[i];
+		TouchImpl* t1 = 0;
+
+		if (t0->isEmpty())
+			continue;
+
+		// find Down/Up touches recorded within a single frame
+		bool downUpTouch =
+			t0->frameBegan == m_FrameCount &&
+			t0->frameToReport == m_FrameCount &&
+			t0->willBeFinishedNextFrame() &&
+			!t0->isFinished();
+
+		if (!downUpTouch)
+			continue;
+
+	#if DEBUG_TOUCH_EMU
+		printf_console("Found new touch set to expire next frame");
+		t0->dump(m_TouchSlots);
+	#endif
+
+		bool redundant = false;
+
+		// compare the multitap info
+		for (size_t j = 0; j < kMaxTouchCount; ++j)
+		{
+			t1 = &m_TouchSlots[j];
+
+			if (t1->isEmpty() || i == j)
+				continue;
+
+			bool multitapTouch =
+				t1->frameBegan == m_FrameCount &&
+				t1->frameToReport == m_FrameCount &&
+				t1->pointerId == t0->pointerId &&
+				t1->tapCount > t0->tapCount &&
+				t0->isMultitap(t1->timestamp, t1->pos, m_ScreenDPI) &&
+				!t1->isFinished();
+
+			if (!multitapTouch)
+				continue;
+
+		#if DEBUG_TOUCH_EMU
+			printf_console("Found new touch, with tapCount that matches the one found earlier");
+			t1->dump(m_TouchSlots);
+		#endif
+			// found a match
+			redundant = true;
+			break;
+		}
+
+		if (redundant)
+		{
+			t0->endPhaseInQueue = 0;		// this touch is officially gone anyway
+			ExpireOld(*t0);
+			t1->id = CompactFingerID(t1->id);
+		#if DEBUG_TOUCH_EMU
+			printf_console("New touch, with compacted finger id");
+			t1->dump(m_TouchSlots);
+		#endif
+		}
+		else
+		{
+			t0->id = CompactFingerID(t0->id);
+		#if DEBUG_TOUCH_EMU
+			printf_console("Refresh touch, with compacted finger id");
+			t0->dump(m_TouchSlots);
+		#endif
+		}
+	}
+}
+
+void TouchPhaseEmulation::UpdateActiveTouches()
+{
+	for (size_t i = 0; i < kMaxTouchCount; ++i)
+	{
+		TouchImpl& touch = m_TouchSlots[i];
+
+		if (touch.isEmpty())
+			continue;
+
+		// Skip Expired Touches
+		if (touch.isFinished())
+		{
+			continue;
+		}
+
+		// End Delayed Touches
+		if (touch.willBeFinishedNextFrame ())
+		{
+			touch.deltaPos			= Vector2f (0, 0);
+			touch.phase				= touch.endPhaseInQueue;
+			touch.endPhaseInQueue	= 0;
+			touch.frameToReport		= m_FrameCount;
+			continue;
+		}
+
+		// Default Stationary Touches
+		touch.phase			= kTouchStationary;
+		touch.deltaPos		= Vector2f (0, 0);
+		touch.frameToReport	= m_FrameCount;
+	}
+
+}
+
+size_t TouchPhaseEmulation::GetTouchCount ()
+{
+	size_t count = 0;
+
+	// TODO: on first call to GetTouchCount() per frame, call PackTouchIds() to
+	// compact virtual touch IDs to stand out less
+
+	for (size_t i = 0; i < kMaxTouchCount; ++i)
+		if ( m_TouchSlots[i].isNow(m_FrameCount) &&
+			!m_TouchSlots[i].isEmpty() )
+			++count;
+
+	return count;
+}
+
+size_t TouchPhaseEmulation::GetActiveTouchCount ()
+{
+	size_t count = 0;
+
+	for (size_t i = 0; i < kMaxTouchCount; ++i)
+		if (!m_TouchSlots[i].isEmpty() && !m_TouchSlots[i].isFinished())
+			++count;
+
+	return count;
+}
+
+// @param index  Zero-based index of events that are to be reported this
+//               frame. Since not all of the events in the container need to
+//               be reported this frame, it's used to skip already reported
+//               ones.
+bool TouchPhaseEmulation::GetTouch (size_t index, Touch& touch)
+{
+	for (size_t i = 0; i < kMaxTouchCount; ++i)
+	{
+		if ( m_TouchSlots[i].isNow(m_FrameCount) &&
+			!m_TouchSlots[i].isEmpty() &&
+			index-- == 0 )
+		{
+			touch = m_TouchSlots[i];
+			return true;
+		}
+	}
+
+	return false;
+}
+
+bool TouchPhaseEmulation::IsMultiTouchEnabled ()
+{
+	if (m_IsSingleTouchDevice)
+		return false;
+
+	return m_IsMultiTouchEnabled;
+}
+
+void TouchPhaseEmulation::SetMultiTouchEnabled (bool enabled)
+{
+	if (m_IsSingleTouchDevice)
+		return;
+
+	m_IsMultiTouchEnabled = enabled;
+}
+
+int TouchPhaseEmulation::CalculateTapCount( long long timestamp, Vector2f const &pos ) const
+{
+	int result = 0;
+	for (size_t i = 0; i < kMaxTouchCount; ++i)
+	{
+		TouchImpl& touch = m_TouchSlots[i];
+
+		if (touch.isEmpty())
+			continue;
+
+		if (touch.isMultitap(timestamp, pos, m_ScreenDPI))
+			result += touch.tapCount;
+	}
+
+	return result;
+}
+
+#if DEBUG_TOUCH_EMU
+void TouchPhaseEmulation::DumpAll (bool verbose)
+{
+	for (int i = 0; i < kMaxTouchCount; ++i)
+		if (!m_TouchSlots[i].isEmpty() && !m_TouchSlots[i].isOld(m_FrameCount) || verbose)
+			m_TouchSlots[i].dump( m_TouchSlots );
+}
+#endif