void OnDraggingStart(DragInfo dragInfo)
{
//currentDragIndex=dragInfo.index;
Debug.Log("ondragging start");
//if(currentDragIndex==-1){
Ray ray = Camera.main.ScreenPointToRay(dragInfo.pos);
RaycastHit hit;
//use raycast at the cursor position to detect the object
if (Physics.Raycast(ray, out hit, Mathf.Infinity))
{
if (hit.collider.transform == dragObj1)
{
dragObj1.localScale *= 1.1f;
Obj1ToCursor(dragInfo);
currentDragIndex1 = dragInfo.index;
}
else if (hit.collider.transform == dragObj2)
{
dragObj2.localScale *= 1.1f;
Obj2ToCursor(dragInfo);
currentDragIndex2 = dragInfo.index;
}
}
//}
}
private void OnDraggingEnd(DragInfo dragInfo)
{
if (isDraging && mCamera != null)
{
mStopWatch.Stop();
Vector3 vector = GenerateMovedPercentage(mVector3SwipeMoved.x, mVector3SwipeMoved.y);
OnSwipe(ActionType.FingerUp, dragInfo.delta.x, dragInfo.delta.y, vector.x, vector.y, mStopWatch.ElapsedMilliseconds);
if (mNeedFlickCheck && dragInfo.isFlick)
{
if (Math.Abs(vector.x) < Math.Abs(vector.y))
{
OnSwipeEventAction(ActionType.FingerUpWithVerticalFlick, dragInfo.delta.x, dragInfo.delta.y, vector.x, vector.y, mStopWatch.ElapsedMilliseconds);
}
else
{
OnSwipeEventAction(ActionType.FingerUp, dragInfo.delta.x, dragInfo.delta.y, vector.x, vector.y, mStopWatch.ElapsedMilliseconds);
}
}
else
{
OnSwipeEventAction(ActionType.FingerUp, dragInfo.delta.x, dragInfo.delta.y, vector.x, vector.y, mStopWatch.ElapsedMilliseconds);
}
if (dragInfo.index == mCurrentDragIndex)
{
mCurrentDragIndex = -1;
}
mVector3SwipeMoved.Set(0f, 0f, 0f);
}
isDraging = false;
}
private void OnDraggingStart(DragInfo dragInfo)
{
if (SingletonMonoBehaviour <UIShortCutMenu> .exist() && SingletonMonoBehaviour <UIShortCutMenu> .Instance.IsFocus)
{
return;
}
if (this.mCamera != null)
{
Ray ray = this.mCamera.ScreenPointToRay(dragInfo.pos);
RaycastHit raycastHit;
if (Physics.Raycast(ray, ref raycastHit, float.PositiveInfinity))
{
if (!raycastHit.get_collider().get_gameObject().get_transform().Equals(base.get_transform()))
{
return;
}
if (raycastHit.get_collider().get_transform() == this.mTransformCache)
{
this.mVector3SwipeMoved.Set(0f, 0f, 0f);
this.mStopWatch.Reset();
this.mStopWatch.Start();
this.isDraging = true;
this.OnSwipeEventAction(UIDisplaySwipeEventRegion.ActionType.Start, dragInfo.delta.x, dragInfo.delta.y, 0f, 0f, 0f);
this.mLastSwipeStartWorldPosition.Set(dragInfo.pos.x, dragInfo.pos.y, 0f);
this.mCurrentDragIndex = dragInfo.index;
}
}
}
}
public DragInfo ConstructorTest(object sender, MouseButtonEventArgs e)
{
DragInfo target = new DragInfo(sender, e);
return(target);
// TODO: add assertions to method DragInfoTest.ConstructorTest(Object, MouseButtonEventArgs)
}
static void Postfix(FreeRoamCamera __instance, DragInfo dragInfo)
{
if (!Main.enabled || !Main.freeCamActivated)
{
return;
}
try
{
var mDragDelayTimer = Traverse.Create(__instance).Field("mDragDelayTimer").GetValue <float>();
var dragInitialDelay = Traverse.Create(__instance).Field("dragInitialDelay").GetValue <float>();
var dragModifier = Traverse.Create(__instance).Field("dragModifier").GetValue <float>();
if (Input.GetMouseButton(1) && mDragDelayTimer >= dragInitialDelay && !(UIManager.instance.UIObjectsAtMousePosition.Count > 0))
{
var zoom = Mathf.Lerp(__instance.cameraMaxZoom, __instance.cameraMinZoom, __instance.zoomNormalized);
var pos = Vector3.zero;
var transform = __instance.transform;
var position = transform.position;
var forward = transform.forward;
forward.y = 0;
pos += forward.normalized * (-dragInfo.delta.y * Time.unscaledDeltaTime) * dragModifier * Main.settings.GetMouseSpeed * zoom;
var right = transform.right;
right.y = 0;
pos += right.normalized * (-dragInfo.delta.x * Time.unscaledDeltaTime) * dragModifier * Main.settings.GetMouseSpeed * zoom;
transform.parent.position += pos;
}
}
catch (Exception e)
{
Main.logger.LogException(e);
}
}
void OnDraggingEnd(DragInfo dragInfo)
{
if (m_isHaveActiveElement && dragInfo.index == m_activeTapIndex)
{
if (m_isHaveActiveElement)
{
ObjToDragPosition(dragInfo);
}
Vector2 direction = Vector2.zero;
LayerMask layerMask = 1 << m_dragLayerID;
Vector2 worlTouchdPos = Camera.main.ScreenToWorldPoint(dragInfo.pos);
drgaDelegate.endDragingPos(worlTouchdPos);
RaycastHit2D hit = Support.getHitForNearestObjectByZ(worlTouchdPos, layerMask, direction, m_activeElement);
if (hit.collider != null)
{
drgaDelegate.endDraging(hit.collider.gameObject, worlTouchdPos);
}
else
{
drgaDelegate.endDraging(null, worlTouchdPos);
}
m_activeElement = null;
m_isHaveActiveElement = false;
}
}
private void OnDraggingEnd(DragInfo dragInfo)
{
if (this.isDraging && this.mCamera != null)
{
this.mStopWatch.Stop();
Vector3 vector = this.GenerateMovedPercentage(this.mVector3SwipeMoved.x, this.mVector3SwipeMoved.y);
this.OnSwipe(UIDisplaySwipeEventRegion.ActionType.FingerUp, dragInfo.delta.x, dragInfo.delta.y, vector.x, vector.y, (float)this.mStopWatch.get_ElapsedMilliseconds());
if (this.mNeedFlickCheck && dragInfo.isFlick)
{
if (Math.Abs(vector.x) < Math.Abs(vector.y))
{
this.OnSwipeEventAction(UIDisplaySwipeEventRegion.ActionType.FingerUpWithVerticalFlick, dragInfo.delta.x, dragInfo.delta.y, vector.x, vector.y, (float)this.mStopWatch.get_ElapsedMilliseconds());
}
else
{
this.OnSwipeEventAction(UIDisplaySwipeEventRegion.ActionType.FingerUp, dragInfo.delta.x, dragInfo.delta.y, vector.x, vector.y, (float)this.mStopWatch.get_ElapsedMilliseconds());
}
}
else
{
this.OnSwipeEventAction(UIDisplaySwipeEventRegion.ActionType.FingerUp, dragInfo.delta.x, dragInfo.delta.y, vector.x, vector.y, (float)this.mStopWatch.get_ElapsedMilliseconds());
}
if (dragInfo.index == this.mCurrentDragIndex)
{
this.mCurrentDragIndex = -1;
}
this.mVector3SwipeMoved.Set(0f, 0f, 0f);
}
this.isDraging = false;
}
void onDraggingFinished(DragInfo dragInfo)
{
if (OnDraggingFinished != null)
{
OnDraggingFinished(dragInfo.pos, dragInfo.index);
}
}
public static void DFDragging(DragInfo dragInfo)
{
if (IT_Gesture.onDualFDraggingE != null)
{
IT_Gesture.onDualFDraggingE(dragInfo);
}
}
//dual finger drag event
public static void DFDragging(DragInfo dragInfo)
{
if (onDualFDraggingE != null)
{
onDualFDraggingE(dragInfo);
}
}
public static void DFDraggingEnd(DragInfo dragInfo)
{
if (onDualFDraggingEndE != null)
{
onDualFDraggingEndE(dragInfo.pos);
}
}
//なぞり開始
void OnDraggingStart(DragInfo dragInfo)
{
isNowAttackable = false;
//タイル上
var tilePosition = TileBase.GetArrayFromRay(dragInfo.pos);
if (tilePosition == null)
{
return;
}
//キャラクターの上
if (IntVect2D.IsEqual(tilePosition, character.positionArray) == false)
{
return;
}
BattleStage.Instance.ResetAllTileColor();
nowTraceTiles = new List <IntVect2D>();
nowTraceTiles.Add(tilePosition);
BattleStage.Instance.ChangeColor(tilePosition, TileState.Skill);
IT_Gesture.onDraggingE += OnDragging;
IT_Gesture.onDraggingEndE += OnDraggingEnd;
isNowCharge = true;
ActionSelect.Instance.DisableMoveAttackButton();
}
void OnDragging(DragInfo dragInfo)
{
//もうなぞれない
if (nowTraceTiles.Count == moveRange)
{
return;
}
//タイル上
var tilePosition = TileBase.GetArrayFromRay(dragInfo.pos);
if (tilePosition == null)
{
return;
}
//まだ未通過
if (IntVect2D.IsEqual(tilePosition, nowTraceTiles.LastOrDefault()))
{
return;
}
//まだ未完成
if (moveRange == nowTraceTiles.Count)
{
return;
}
//次のタイル
if (IntVect2D.IsNeighbor(tilePosition, nowTraceTiles.LastOrDefault()) == false)
{
return;
}
nowTraceTiles.Add(tilePosition);
BattleStage.Instance.ChangeColor(tilePosition, TileState.Skill);
}
void OnDragging(DragInfo dragInfo)
{
//もうなぞれない
if (nowTraceTiles.Count == selectAttackParameter.moveRange)
{
return;
}
//タイル上
var tilePosition = BBattleStage.Instance.GetTilePositionFromScreenPosition(dragInfo.pos);
if (tilePosition == null)
{
return;
}
//まだ未通過
if (IntVect2D.IsEqual(tilePosition, nowTraceTiles.LastOrDefault()))
{
return;
}
//まだ未完成
if (selectAttackParameter.moveRange == nowTraceTiles.Count)
{
return;
}
//次のタイル
if (IntVect2D.IsNeighbor(tilePosition, nowTraceTiles.LastOrDefault()) == false)
{
return;
}
nowTraceTiles.Add(tilePosition);
BBattleStage.Instance.ChangeColor(tilePosition, TileState.Skill);
}
public override void OnDragEnd(DragInfo drag)
{
if (Time.time - lastShootTime >= player.SHOOT_COOLDOWN)
{
Shoot((Camera.main.ScreenToWorldPoint(drag.end) - transform.position).normalized);
}
}
public static void DFDraggingEnd(DragInfo dragInfo)
{
if (IT_Gesture.onDualFDraggingEndE != null)
{
IT_Gesture.onDualFDraggingEndE(dragInfo.pos);
}
}
void DraggingHandler(DragInfo dragInfo)
{
if (debug) Debug.Log("====DraggingHandler====\n|| fingercount: " + dragInfo.fingerCount +
" || index: " + dragInfo.index +
" || isFlick: " + dragInfo.isFlick +
" || pos: " + dragInfo.pos );
if (dragInfo.pos.x / Screen.width <= 0.3)
{
yTouchLeft = dragInfo.pos.y / Screen.height;
Debug.Log("Left: " + yTouchLeft );
}
if (dragInfo.pos.x / Screen.width >= 0.7)
{
yTouchRight = dragInfo.pos.y / Screen.height;
Debug.Log("Right: " + yTouchRight );
}
speedModifier = (yTouchLeft >= yTouchRight) ? yTouchLeft : yTouchRight;
directionModifier = yTouchLeft - yTouchRight;
Debug.Log("Direction: " + directionModifier );
Debug.Log("speedModifier: " + speedModifier );
Vector3 pos = Megaman.transform.localPosition;
pos.x = megamanInitialX + directionModifier*-1;
float offsettedSpeedModifier = speedModifier - 0.5f;
pos.z = megamanInitialZ + offsettedSpeedModifier;
Megaman.transform.localPosition = pos;
//Debug.Log("orbit.XModifier: "+orbit.XModifier);
}
public static void BeginDrag(DragSource source)
{
if (source.IsDraggable() == DraggableResult.Accept)
{
AcceptBeginDrag();
}
else
{
DeniedBeginDrag();
}
void AcceptBeginDrag()
{
var dragInfo = new DragInfo
{
Source = source,
OriginPosition = source.transform.position
};
dragingObjects.Add(source.gameObject, dragInfo);
}
void DeniedBeginDrag()
{
source.CancelDragging();
}
}
public void DragStart(DragInfo info)
{
_popupWin = FindTopWindow(info.Source as FrameworkElement);
_startPos = info.PointOnScreen;
_popupWin.ViewModel.ControlModel.IsControlPanelVisible = false;
_popupWin.Visibility = Visibility.Collapsed;
}
void DraggingStartHandler(DragInfo dragInfo)
{
if (debug) Debug.Log("====DraggingStartHandler====\n|| fingercount: " + dragInfo.fingerCount +
" || index: " + dragInfo.index +
" || isFlick: " + dragInfo.isFlick +
" || pos: " + dragInfo.pos );
}
public void DragStart(DragInfo info)
{
if (info.SourceItem == null)
{
info.Cancelled = true;
return;
}
RadListBox rlb = info.Source as RadListBox;
if (rlb != null)
{
//设置拖拽窗口视觉效果。
IEnumerable <RadListBoxItem> items = rlb.FindVisualChildren <RadListBoxItem>();
foreach (RadListBoxItem item in items)
{
if (item.DataContext.Equals(rlb.SelectedItem))
{
rlb.SetValue(DragDropVisual.VisualProperty, item);
break;
}
}
SearchNodeHistoryViewModel searchVM = rlb.DataContext as SearchNodeHistoryViewModel;
if (searchVM == null || searchVM.SelectedVideo == null)
{//如果没有选中项，或者选中项不是视频节点，取消拖拽。
info.Cancelled = true;
}
}
}
public void Dragging(DragInfo info)
{
VideoPanelItem vpi = info.Source as VideoPanelItem;
if (info.Effects == DragDropEffects.None)
{
if (!IsCursorInWindow(info) && vpi.ViewModel != null && vpi.ViewModel.IsInEditStatus)
{
Mouse.SetCursor(Cursors.Hand);
info.Handled = true;
}
}
else
{
Mouse.SetCursor(Cursors.SizeAll);
info.Handled = true;
}
if (vpi != null)
{
if (info.Effects.HasFlag(DragDropEffects.Copy))
{
updateOpacity(vpi, 1);
}
else
{
updateOpacity(vpi, 0);
}
}
}
void OnDraggingStart(DragInfo dragInfo)
{
//currentDragIndex=dragInfo.index;
//if(currentDragIndex==-1){
Ray ray = Camera.main.ScreenPointToRay(dragInfo.pos);
RaycastHit hit;
//use raycast at the cursor position to detect the object
if (Physics.Raycast(ray, out hit, Mathf.Infinity))
{
//if the drag started on dragObj1
if (hit.collider.transform == dragObj1)
{
//change the scale of dragObj1, give the user some visual feedback
dragObj1.localScale *= 1.1f;
//latch dragObj1 to the cursor, based on the index
Obj1ToCursor(dragInfo);
currentDragIndex1 = dragInfo.index;
}
//if the drag started on dragObj2
else if (hit.collider.transform == dragObj2)
{
//change the scale of dragObj2, give the user some visual feedback
dragObj2.localScale *= 1.1f;
//latch dragObj2 to the cursor, based on the index
Obj2ToCursor(dragInfo);
currentDragIndex2 = dragInfo.index;
}
}
//}
}
void onDragging(DragInfo dragInfo)
{
if (OnDragging != null)
{
OnDragging(dragInfo.pos, dragInfo.index);
}
}
void OnDragging(DragInfo dragInfo)
{
//タイル上
var targetPosition = TileBase.GetArrayFromRay(dragInfo.pos);
if (targetPosition == null)
{
return;
}
//まだ未通過
if (IntVect2D.IsEqual(targetPosition, nowTraceTiles.LastOrDefault()))
{
return;
}
//まだ未完成
if (skillTiles.Count == nowTraceTiles.Count)
{
return;
}
//次のタイル
if (IntVect2D.IsEqual(targetPosition, IntVect2D.Add(skillTiles[nowTraceTiles.Count], nowTraceTiles[0])) == false)
{
FailAciton();
return;
}
nowTraceTiles.Add(targetPosition);
BattleStage.Instance.ChangeColor(targetPosition, TileState.Skill);
}
private double ApplyMouseDrag(Point mpos, DragInfo info, DiagramItemBlock diagramItem)
{
var delta = (mpos - info.DragStartPosition) / _scaleFactor;
diagramItem.X = info.ItemStartPosition.X + delta.X;
diagramItem.Y = info.ItemStartPosition.Y + delta.Y;
return(delta.LengthSquared);
}
/// <summary>
/// ドラック中
/// </summary>
void OnDragging(DragInfo dragInfo)
{
Debug.Log("長押し中");
onDragging.Invoke();
// ドラックのフレーム数をカウント
dragFrame++;
}
void OnDraggingEnd(DragInfo drag)
{
pointer.enabled = false;
IT_Gesture.onMouse1E -= OnTouch;
IT_Gesture.onDraggingEndE -= OnDraggingEnd;
}
public static void DualFingerDragging(DragInfo dragInfo)
{
//Debug.Log("DualFingerDrag "+dir);
if (onDualFDraggingE != null)
{
onDualFDraggingE(dragInfo);
}
}
//スワイプによる移動操作検知
void OnChargeForMove(DragInfo dragInfo)
{
//自分キャラ
if (BCharacterManager.Instance.GetCharacterOnTile(dragInfo.pos) != this.character) return;
//キャラクター移動用
IT_Gesture.onDraggingEndE += OnDragMove;
}
public void OnEndDrag(PointerEventData eventData)
{
Vector3 worldPosition = eventData.pointerCurrentRaycast.worldPosition;
MoveObjectToPosition(info.target, worldPosition + info.offset);
info = new DragInfo();
}
//Dual Finger dragging
public static void Dragging(DragInfo dragInfo)
{
//Debug.Log("dragging "+dir);
if (onDraggingE != null)
{
onDraggingE(dragInfo);
}
}
void OnDraggingEnd(DragInfo drag)
{
pointer.enabled = false;
IT_Gesture.onMouse1E -= OnTouch;
IT_Gesture.onDraggingEndE -= OnDraggingEnd;
}
void OnDraggingEnd(DragInfo dragInfo)
{
CheckTraceComplete();
//nowTraceTiles = new List<IntVect2D>();
IT_Gesture.onDraggingE -= OnDragging;
isNowCharge = false;
IT_Gesture.onDraggingEndE -= OnDraggingEnd;
}
void OnDrag(DragInfo info)
{
if (vertical) scrollDelta = info.delta.y;
else scrollDelta = info.delta.x;
MoveChildren(scrollDelta*scrollSpeed);
scrollDelta /= Mathf.Abs(scrollDelta);
}
//called when one finger drag are detected
void OnDragging(DragInfo dragInfo)
{
//apply the DPI scaling
dragInfo.delta/=IT_Gesture.GetDPIFactor();
//vertical movement is corresponded to rotation in x-axis
this.orbitSpeedX=-dragInfo.delta.y* this.rotXSpeedModifier;
//horizontal movement is corresponded to rotation in y-axis
this.orbitSpeedY=dragInfo.delta.x* this.rotYSpeedModifier;
}
//移動開始
void OnDraggingStart(DragInfo drag)
{
//タッチ位置取得
pointer.enabled = true;
DragPosition = drag.pos;
IT_Gesture.onMouse1E += OnTouch;
IT_Gesture.onDraggingEndE += OnDraggingEnd;
}
//移動開始
void OnDraggingStart(DragInfo drag)
{
//タッチ位置取得
dragPosition = drag.pos;
IT_Gesture.onMouse1E += OnTouch;
IT_Gesture.onDraggingEndE += OnDraggingEnd;
}
void HandleGestureonDraggingStartE(DragInfo dragInfo)
{
if (!isDragging) return;
Transform puck = PickObject (dragInfo.pos);
if (puck) {
lastPuck = puck;
baseHeight = puck.position.y;
puck.renderer.material.color = Color.green;
}
}
void HandleDragging(DragInfo dragInfo)
{
if (!isDragging) return;
if (lastPuck) {
DisplayText ("Dragging puck to: " + dragInfo.pos);
Vector3 worldPos = GetWorldPos (dragInfo.pos);
lastPuck.transform.position = worldPos;
} else {
DisplayText ("Dragging to: " + dragInfo.pos);
}
}
//called when one finger drag are detected
void OnDragging(DragInfo dragInfo)
{
//if the drag is perform using mouse2, use it as a two finger drag
if(dragInfo.isMouse && dragInfo.index==1) OnMFDragging(dragInfo);
//else perform normal orbiting
else{
//vertical movement is corresponded to rotation in x-axis
orbitSpeedX=-dragInfo.delta.y*rotXSpeedModifier;
//horizontal movement is corresponded to rotation in y-axis
orbitSpeedY=dragInfo.delta.x*rotYSpeedModifier;
}
}
//assign dragObj2 to the dragInfo position, and display the appropriate tooltip
void Obj2ToCursor(DragInfo dragInfo)
{
Vector3 p=Camera.main.ScreenToWorldPoint(new Vector3(dragInfo.pos.x, dragInfo.pos.y, 30));
dragObj2.position=p;
if(dragInfo.isMouse){
dragTextMesh2.text="Dragging with mouse"+(dragInfo.index+1);
}
else{
dragTextMesh2.text="Dragging with finger"+(dragInfo.index+1);
}
}
IEnumerator MouseRoutine(int index)
{
mouseIndex.Add(index);
bool dragStarted=false;
Vector2 startPos=Input.mousePosition;
Vector2 lastPos=startPos;
float timeStart=Mathf.Infinity;
while(mouseIndex.Contains(index)){
Vector2 curPos=Input.mousePosition;
if(!dragStarted){
if(Vector3.Distance(curPos, startPos)>minDragDistance){
dragStarted=true;
Vector2 delta=curPos-startPos;
DragInfo dragInfo=new DragInfo(curPos, delta, 1, index, true);
IT_Gesture.DraggingStart(dragInfo);
timeStart=Time.realtimeSinceStartup;
}
}
else{
if(curPos!=lastPos){
Vector2 delta=curPos-lastPos;
DragInfo dragInfo=new DragInfo(curPos, delta, 1, index, true);
IT_Gesture.Dragging(dragInfo);
}
else if(fireOnDraggingWhenNotMoving){
DragInfo dragInfo=new DragInfo(curPos, Vector2.zero, 1, index, true);
IT_Gesture.Dragging(dragInfo);
}
}
lastPos=curPos;
yield return null;
}
if(dragStarted){
bool isFlick=false;
if(Time.realtimeSinceStartup-timeStart<0.5f) isFlick=true;
Vector2 delta=lastPos-startPos;
DragInfo dragInfo=new DragInfo(lastPos, delta, 1, index, isFlick, true);
IT_Gesture.DraggingEnd(dragInfo);
}
}
//called when one finger drag are detected
void OnDragging(DragInfo dragInfo)
{
Debug.Log("drag "+dragInfo.delta);
if(dragInfo.type!=2){
//vertical movement is corresponded to rotation in x-axis
orbitSpeedX=-dragInfo.delta.y*rotXSpeedModifier;
//horizontal movement is corresponded to rotation in y-axis
orbitSpeedY=dragInfo.delta.x*rotYSpeedModifier;
}
//if the drag is perform using mouse2, use it as a two finger drag
if(dragInfo.type==2) OnDFDragging(dragInfo);
}
//called when one finger drag are detected
void OnDragging(DragInfo dragInfo)
{
//if the drag is perform using mouse2, use it as a two finger drag
if(dragInfo.isMouse && dragInfo.index==1) this.OnMFDragging(dragInfo);
//else perform normal orbiting
else{
//apply the DPI scaling
dragInfo.delta/=IT_Gesture.GetDPIFactor();
//vertical movement is corresponded to rotation in x-axis
this.orbitSpeedX=-dragInfo.delta.y* this.rotXSpeedModifier;
//horizontal movement is corresponded to rotation in y-axis
this.orbitSpeedY=dragInfo.delta.x* this.rotYSpeedModifier;
}
}
public static Directions ConvertDragToDirection(DragInfo drag)
{
Vector2 normalized = (drag.pos - dragStart).normalized;
if (normalized.x > 0 && Math.Abs(normalized.y) < normalized.x)
return Directions.Right;
if (normalized.y > 0 && Math.Abs(normalized.x) < normalized.y)
return Directions.Up;
if (normalized.x < 0 && Math.Abs(normalized.y) > normalized.x)
return Directions.Left;
if (normalized.y < 0 && Math.Abs(normalized.x) > normalized.y)
return Directions.Down;
Debug.Log("Converting Drag to Directions Failed");
return Directions.None;
}
//called when a dual finger or a right mouse drag is detected
void OnMFDragging(DragInfo dragInfo)
{
//make a new direction, pointing horizontally at the direction of the camera y-rotation
Quaternion direction=Quaternion.Euler(0, transform.parent.rotation.eulerAngles.y, 0);
//calculate forward movement based on vertical input
Vector3 moveDirZ=transform.parent.InverseTransformDirection(direction*Vector3.forward*-dragInfo.delta.y);
//calculate sideway movement base on horizontal input
Vector3 moveDirX=transform.parent.InverseTransformDirection(direction*Vector3.right*-dragInfo.delta.x);
//move the cmera
transform.parent.Translate(moveDirZ * panSpeedModifier * Time.deltaTime);
transform.parent.Translate(moveDirX * panSpeedModifier * Time.deltaTime);
}
public virtual void StartDrag(DragInfo dragInfo)
{
int itemCount = dragInfo.SourceItems.Cast<object>().Count();
if (itemCount == 1)
{
dragInfo.Data = dragInfo.SourceItems.Cast<object>().First();
}
else if (itemCount > 1)
{
dragInfo.Data = TypeUtilities.CreateDynamicallyTypedList(dragInfo.SourceItems);
}
dragInfo.Effects = (dragInfo.Data != null) ?
DragDropEffects.Copy | DragDropEffects.Move :
DragDropEffects.None;
}
//assign dragObj1 to the dragInfo position, and display the appropriate tooltip
void Obj1ToCursor(DragInfo dragInfo)
{
//~ LayerMask layer=~(1<<dragObj1.gameObject.layer);
//~ Ray ray = Camera.main.ScreenPointToRay (dragInfo.pos);
//~ RaycastHit hit;
//~ if (Physics.Raycast (ray, out hit, Mathf.Infinity, layer)) {
//~ dragObj1.position=hit.point;
//~ }
Vector3 p=Camera.main.ScreenToWorldPoint(new Vector3(dragInfo.pos.x, dragInfo.pos.y, 30));
this.dragObj1.position=p+ this.dragOffset1;
if(dragInfo.isMouse){
this.dragTextMesh1.text="Dragging with mouse"+(dragInfo.index+1);
}
else{
this.dragTextMesh1.text="Dragging with finger"+(dragInfo.index+1);
}
}
IEnumerator MouseRoutine(int index)
{
mouseIndex.Add(index);
bool dragStarted=false;
Vector2 startPos=Input.mousePosition;
Vector2 lastPos=startPos;
while(mouseIndex.Contains(index)){
Vector2 curPos=Input.mousePosition;
if(!dragStarted){
if(Vector3.Distance(curPos, startPos)>minDragDistance){
dragStarted=true;
Vector2 delta=curPos-startPos;
DragInfo dragInfo=new DragInfo(curPos, delta, 1, index, true);
Gesture.DraggingStart(dragInfo);
}
}
else{
if(curPos!=lastPos){
Vector2 delta=curPos-lastPos;
DragInfo dragInfo=new DragInfo(curPos, delta, 1, index, true);
Gesture.Dragging(dragInfo);
}
}
lastPos=curPos;
yield return null;
}
if(dragStarted){
Vector2 delta=lastPos-startPos;
DragInfo dragInfo=new DragInfo(lastPos, delta, 1, index, true);
Gesture.DraggingEnd(dragInfo);
}
}
public DropInfo(object sender, DragEventArgs e, DragInfo dragInfo, string dataFormat)
{
Data = (e.Data.GetDataPresent(dataFormat)) ? e.Data.GetData(dataFormat) : e.Data;
DragInfo = dragInfo;
VisualTarget = sender as UIElement;
if (sender is ItemsControl)
{
ItemsControl itemsControl = (ItemsControl)sender;
UIElement item = itemsControl.GetItemContainerAt(e.GetPosition(itemsControl));
VisualTargetOrientation = itemsControl.GetItemsPanelOrientation();
if (item != null)
{
ItemsControl itemParent = ItemsControl.ItemsControlFromItemContainer(item);
InsertIndex = itemParent.ItemContainerGenerator.IndexFromContainer(item);
TargetCollection = itemParent.ItemsSource ?? itemParent.Items;
TargetItem = itemParent.ItemContainerGenerator.ItemFromContainer(item);
VisualTargetItem = item;
if (VisualTargetOrientation == Orientation.Vertical)
{
if (e.GetPosition(item).Y > item.RenderSize.Height / 2) InsertIndex++;
}
else
{
if (e.GetPosition(item).X > item.RenderSize.Width / 2) InsertIndex++;
}
}
else
{
TargetCollection = itemsControl.ItemsSource ?? itemsControl.Items;
InsertIndex = itemsControl.Items.Count;
}
}
}
void OnDraggingEnd(DragInfo dragInfo)
{
//drop the dragObj being drag by this particular cursor
if(dragInfo.index==currentDragIndex1){
currentDragIndex1=-1;
dragObj1.localScale*=10f/11f;
Vector3 p=Camera.main.ScreenToWorldPoint(new Vector3(dragInfo.pos.x, dragInfo.pos.y, 30));
dragObj1.position=p;
dragTextMesh1.text="DragMe";
}
else if(dragInfo.index==currentDragIndex2){
currentDragIndex2=-1;
dragObj2.localScale*=10f/11f;
Vector3 p=Camera.main.ScreenToWorldPoint(new Vector3(dragInfo.pos.x, dragInfo.pos.y, 30));
dragObj2.position=p;
dragTextMesh2.text="DragMe";
}
}
//triggered on a single-finger/mouse dragging event is on-going
void OnDragging(DragInfo dragInfo)
{
//if the dragInfo index matches dragIndex1, call function to position dragObj1 accordingly
if(dragInfo.index==currentDragIndex1){
Obj1ToCursor(dragInfo);
}
//if the dragInfo index matches dragIndex2, call function to position dragObj2 accordingly
else if(dragInfo.index==currentDragIndex2){
Obj2ToCursor(dragInfo);
}
}
IEnumerator TouchRoutine(int index){
fingerIndex.Add(index);
bool dragStarted=false;
Vector2 startPos=Gesture.GetTouch(index).position;
Vector2 lastPos=startPos;
float timeStart=Mathf.Infinity;
while((enableMultiDrag && Input.touchCount>0) || (!enableMultiDrag && Input.touchCount==1)){
Touch touch=Gesture.GetTouch(index);
if(touch.position==Vector2.zero) break;
Vector2 curPos=touch.position;
if(touch.phase==TouchPhase.Moved){
if(!dragStarted){
if(Vector3.Distance(curPos, startPos)>minDragDistance){
dragStarted=true;
Vector2 delta=curPos-startPos;
DragInfo dragInfo=new DragInfo(curPos, delta, 1, index, false);
Gesture.DraggingStart(dragInfo);
timeStart=Time.realtimeSinceStartup;
}
}
else{
if(curPos!=lastPos){
Vector2 delta=curPos-lastPos;
DragInfo dragInfo=new DragInfo(curPos, delta, 1, index, false);
Gesture.Dragging(dragInfo);
}
}
lastPos=curPos;
}
else if(dragStarted && fireOnDraggingWhenNotMoving){
DragInfo dragInfo=new DragInfo(curPos, Vector2.zero, 1, index, false);
Gesture.Dragging(dragInfo);
}
yield return null;
}
if(dragStarted){
bool isFlick=false;
if(Time.realtimeSinceStartup-timeStart<0.5f) isFlick=true;
Vector2 delta=lastPos-startPos;
DragInfo dragInfo=new DragInfo(lastPos, delta, 1, index, isFlick, false);
Gesture.DraggingEnd(dragInfo);
}
fingerIndex.Remove(index);
}
void OnDraggingStart(DragInfo dragInfo)
{
//currentDragIndex=dragInfo.index;
//if(currentDragIndex==-1){
Ray ray = Camera.main.ScreenPointToRay(dragInfo.pos);
RaycastHit hit;
//use raycast at the cursor position to detect the object
if(Physics.Raycast(ray, out hit, Mathf.Infinity)){
//if the drag started on dragObj1
if(hit.collider.transform==dragObj1){
//change the scale of dragObj1, give the user some visual feedback
dragObj1.localScale*=1.1f;
//latch dragObj1 to the cursor, based on the index
Obj1ToCursor(dragInfo);
currentDragIndex1=dragInfo.index;
}
//if the drag started on dragObj2
else if(hit.collider.transform==dragObj2){
//change the scale of dragObj2, give the user some visual feedback
dragObj2.localScale*=1.1f;
//latch dragObj2 to the cursor, based on the index
Obj2ToCursor(dragInfo);
currentDragIndex2=dragInfo.index;
}
}
//}
}
IEnumerator MultiDragRoutine(int count){
if(count<=1) yield break;
bool dragStarted=false;
Vector2 startPos=Vector2.zero;
for(int i=0; i<Input.touchCount; i++){
startPos+=Input.touches[i].position;
}
startPos/=Input.touchCount;
Vector2 lastPos=startPos;
float timeStart=Mathf.Infinity;
#if UNITY_ANDROID
Vector2[] lastPoss=new Vector2[count];
for(int i=0; i<count; i++){
lastPoss[i]=Input.touches[i].position;
}
#endif
while(Input.touchCount==count){
Vector2 curPos=Vector2.zero;
Vector2[] allPos=new Vector2[count];
bool moving=true;
for(int i=0; i<count; i++){
Touch touch=Input.touches[i];
curPos+=touch.position;
allPos[i]=touch.position;
if(touch.phase!=TouchPhase.Moved) moving=false;
}
curPos/=count;
bool sync=true;
if(moving){
for(int i=0; i<count-1; i++){
#if UNITY_ANDROID
Vector2 v1=(Input.touches[i].position+lastPoss[i]).normalized;
Vector2 v2=(Input.touches[i+1].position+lastPoss[i+1]).normalized;
#else
Vector2 v1=Input.touches[i].deltaPosition.normalized;
Vector2 v2=Input.touches[i+1].deltaPosition.normalized;
#endif
if(Vector2.Dot(v1, v2)<0.85f) sync=false;
}
}
if(moving && sync){
if(!dragStarted){
if(Vector2.Distance(curPos, startPos)>minDragDistance){
dragStarted=true;
Vector2 delta=curPos-startPos;
DragInfo dragInfo=new DragInfo(curPos, delta, count);
Gesture.DraggingStart(dragInfo);
timeStart=Time.realtimeSinceStartup;
}
}
else{
if(curPos!=lastPos){
Vector2 delta=curPos-lastPos;
DragInfo dragInfo=new DragInfo(curPos, delta, count);
Gesture.Dragging(dragInfo);
}
}
}
else if(dragStarted && fireOnDraggingWhenNotMoving){
DragInfo dragInfo=new DragInfo(curPos, Vector2.zero, count);
Gesture.Dragging(dragInfo);
}
lastPos=curPos;
#if UNITY_ANDROID
for(int i=0; i<count; i++){
lastPoss[i]=Input.touches[i].position;
}
#endif
yield return null;
}
if(dragStarted){
bool isFlick=false;
if(Time.realtimeSinceStartup-timeStart<0.5f) isFlick=true;
Vector2 delta=lastPos-startPos;
DragInfo dragInfo=new DragInfo(lastPos, delta, count, isFlick);
Gesture.DraggingEnd(dragInfo);
}
}
//dual finger drag event
public static void DFDragging(DragInfo dragInfo)
{
if(onDualFDraggingE!=null) onDualFDraggingE(dragInfo);
}
//*****************************************************************************//
//dragging
public static void DraggingStart(DragInfo dragInfo)
{
if(dragInfo.fingerCount>1){
if(onMFDraggingStartE!=null) onMFDraggingStartE(dragInfo);
}
else{
if(onDraggingStartE!=null) onDraggingStartE(dragInfo);
}
}
public static void DraggingEnd(DragInfo dragInfo)
{
if(dragInfo.fingerCount>1){
if(dragInfo.fingerCount==2) DFDraggingEnd(dragInfo); //obsolete function call
if(onMFDraggingEndE!=null) onMFDraggingEndE(dragInfo);
}
else{
if(onDraggingEndE!=null) onDraggingEndE(dragInfo);
}
}
public static void DFDraggingEnd(DragInfo dragInfo)
{
if(onDualFDraggingEndE!=null) onDualFDraggingEndE(dragInfo.pos);
}
