private void easeDragObject()
{
if (CurrentDragObject.Ease)
{
// calculate new parameter-Value
//#if UNITY_EDITOR
// if (CurrentDragObject.t < 1)
// {
// CurrentDragObject.t += Time.deltaTime / CurrentDragObject.TimeFactor;
// }
//#else
if (CurrentDragObject.t < 1)
{
//CurrentDragObject.t += GUIDeltaTime.deltaTimeGUI / CurrentDragObject.TimeFactor;
CurrentDragObject.t += Time.deltaTime / CurrentDragObject.TimeFactor;
}
//#endif
CurrentDragObject.t = Mathf.Clamp01(CurrentDragObject.t);
// calculate the Rectangle for parameter
CurrentDragObject.CurrentRect = EasingCurves.EaseRect(
CurrentDragObject.EaseStartRect,
CurrentDragObject.EaseEndRect,
CurrentDragObject.EaseInType,
CurrentDragObject.t);
// dragObject reached its targetPosition?
if (CurrentDragObject.t == 1)
{
CurrentDragObject.Ease = false;
CurrentDragObject.t = 0;
}
}
}
public static Rect EaseRect(string id, Rect start, Rect end, EasingCurves.EaseType inType)
{
EasingRect rect;
if (!easingRects.TryGetValue(id, out rect))
{
rect = new EasingRect();
rect.start = start;
rect.end = end;
rect.easeType = inType;
rect.t = 0f;
rect.ease = true;
easingRects[id] = rect;
}
if (rect.ease)
{
if (rect.t < 1)
{
//CurrentDragObject.t += GUIDeltaTime.deltaTimeGUI / CurrentDragObject.TimeFactor;
rect.t += Time.deltaTime / rect.timeFactor;
}
//#endif
rect.t = Mathf.Clamp01(rect.t);
// calculate the Rectangle for parameter
rect.current = EasingCurves.EaseRect(
rect.start,
rect.end,
rect.easeType,
rect.t);
// dragObject reached its targetPosition?
if (rect.t == 1)
{
rect.ease = false;
rect.t = 0;
}
}
easingRects[id] = rect;
return(rect.current);
}
private void DrawEase(Rect rect, EasingCurves.List ease)
{
if (!windowRect.Overlaps(rect))
{
return;
}
Dictionary <string, Rect> rects = AdvancedRect.GetRects(rect, AdvancedRect.Orientation.Vertical,
new AdvancedRect.FixedItem("Header", 20),
new AdvancedRect.FixedSpace(1),
new AdvancedRect.ExpandedItem("Ease")
);
Rect originalEaseRect = rects["Ease"];
Rect easeRect = originalEaseRect;
GUI.Label(rects["Header"], ease.ToString().ToTitleCase(), EasingCurvesStyles.Header);
EasingCurvesStyles.Ease.Draw(easeRect);
GUI.BeginGroup(easeRect);
easeRect.position = Vector2.zero;
easeRect = new RectOffset(-2, -2, 0, 0).Add(easeRect);
float verticalOffset = easeRect.height / 4f;
Vector2 offset = new Vector2(easeRect.xMin, easeRect.height - verticalOffset);
Vector2 bottomLeft = offset;
Vector2 bottomRight = offset + Vector2.right * easeRect.width;
Vector2 topLeft = new Vector2(easeRect.xMin, verticalOffset);
Vector2 topRight = new Vector2(easeRect.xMax, verticalOffset);
Handles.color = Color.red;
Handles.DrawLine(bottomLeft, bottomRight);
Handles.DrawLine(topLeft, topRight);
Handles.color = Color.white;
for (int i = 0; i <= Resolution; i++)
{
float previousPercent = (i > 0 ? i - 1 : i) / Resolution;
float percent = i / Resolution;
Vector2 prevPosition = new Vector2(offset.x + previousPercent * easeRect.width, offset.y + -EasingCurves.GetEaseValue(ease, previousPercent) * (easeRect.height - verticalOffset * 2));
Vector2 position = new Vector2(offset.x + percent * easeRect.width, offset.y + -EasingCurves.GetEaseValue(ease, percent) * (easeRect.height - verticalOffset * 2));
Handles.DrawLine(prevPosition, position);
}
GUI.EndGroup();
if (originalEaseRect.Contains(Event.current.mousePosition) && Event.current.type == EventType.MouseDown)
{
previewEase = ease;
currentPreviewTime = Time.realtimeSinceStartup;
}
if (ease == previewEase)
{
float previewTime = Mathf.Clamp(Time.realtimeSinceStartup - currentPreviewTime, 0, 1 + PreviewDelay);
if (previewTime <= PreviewDelay)
{
previewTime = 0;
}
else
{
previewTime -= PreviewDelay;
}
Vector2 position = new Vector2(offset.x + previewTime * easeRect.width, offset.y + -EasingCurves.GetEaseValue(ease, previewTime) * (easeRect.height - verticalOffset * 2));
Rect circleRect = new Rect(originalEaseRect.position + position - Vector2.one * 4f, Vector2.one * 8);
EasingCurvesStyles.Circle.Draw(circleRect);
Rect arrowRect = new Rect(originalEaseRect.xMax + 5, originalEaseRect.y + position.y - 6, 20, 12);
EasingCurvesStyles.Arrow.Draw(arrowRect);
}
}
public IEnumerator AnimateIteration(MeshIterator iterator)
{
InProgress = true;
IterationElements.ForEach(a => a.AddToMesh());
iterator.meshContainer.UpdateMesh();
var timer = 0.0f;
while (timer < 1)
{
var tick = Time.deltaTime / iterator.meshContainer.IterationSpeed;
timer = 1 - timer <= tick * 2 ? 1 : timer + tick;
foreach (var ie in IterationElements)
{
foreach (var fv in ie.floatingVerts)
{
iterator.meshContainer.Vertices[fv.copyLayer.parentIndex] = Vector3.Lerp(fv.StartPosition, fv.meshVert.Position, EasingCurves.easeOutCubic(0, 1, timer));
}
}
iterator.meshContainer.UpdateVertices();
yield return(null);// new UnityEngine.WaitForEndOfFrame();
}
foreach (var ie in IterationElements)
{
ie.RemoveUniqueVertices();
}
InProgress = false;
}
IEnumerator AnimateStage()
{
//print("Coroutine statred");
// Add New Mesh Data
foreach (var t in foldingStages[stageIndex])
{
Debug.DrawLine(t.triCenter, t.triCenter - t.Normal, Color.green, 3, false);
//if (t.floatingVerts.Count > 0)
//{
// Debug.DrawLine(t.triCenter, t.triCenter + Vector3.up, Color.green, 3, false);
// Debug.DrawLine(t.triCenter + Vector3.up, t.floatingVerts[0].targetPosition, Color.green, 3, false);
//}
t.AddTriToMesh();
}
// Update Mesh
meshFilter.mesh.Clear();
meshFilter.mesh.vertices = vertexData.ToArray();
meshFilter.mesh.triangles = triangleData.ToArray();
meshFilter.mesh.RecalculateNormals();
// Animate FloatingVert
if (stageIndex == 0)
{
//print("stageindex == 0");
foreach (var v in foldingStages[0][0].vertices)
{
vertexData[v.index] = v.position = v.targetPosition;
}
meshFilter.mesh.vertices = vertexData.ToArray();
meshFilter.mesh.RecalculateNormals();
}
else
{
// Set Length Lerp
var lengthLerp = 1.0f;
if (stageIndex != 0 && foldingStages.Count != 0)
{
var ratio = ((float)stageIndex / foldingStages.Count);
var crossover = 0.3f;
if (stageIndex < foldingStages.Count * crossover)
{
ratio = (ratio) * (1 / crossover);
lengthLerp = EasingCurves.easeInQuint(1.0f, 2.0f, ratio);
}
else
{
ratio = (ratio - crossover) * (1 / (1 - crossover));
lengthLerp = EasingCurves.easeOutQuint(2.0f, 1.25f, ratio);
}
}
// Set Density Lerp
var densityLerp = 1.0f;
if (foldingStages[stageIndex].Count != 0 && maximumStageTris != 0)
{
var ratio = ((float)foldingStages[stageIndex].Count / maximumStageTris);
densityLerp = EasingCurves.easeInOutQuint(0.15f, 1.0f, ratio);
}
var foldSpeedLerp = foldSpeed * sizeOffset * lengthLerp * (1 + densityLerp * .2f);
var timer = 0.0f;
while (timer < 1)
{
var tick = Time.deltaTime * foldSpeedLerp;
timer = 1 - timer <= tick * 2 ? 1 : timer + tick;
foreach (var t in foldingStages[stageIndex])
{
//// Stocastic anchoredVerts Animations
//if (t.sourceTri != null)
//{
// vertexData[t.anchoredVerts[0].index] = t.anchoredVerts[0].position += ((t.sourceTri.triCenter - t.anchoredVerts[0].position)) * .1f * densityLerp; //
// vertexData[t.anchoredVerts[1].index] = t.anchoredVerts[1].position += ((t.sourceTri.triCenter - t.anchoredVerts[1].position)) * .1f * densityLerp; //(t.anchoredVerts[0].position)
//}
////
//if (stageIndex < foldingStages.Count - 1)
//{
// foreach (var n in t.neighbours.Where(nt => foldingStages[stageIndex + 1].Contains(nt)))
// {
// //Debug.Log("yep " + n.stageIndex);
// var v1 = n.sourceTri.floatingVerts[0];
// if (vertexData.Count < v1.index) continue;
// vertexData[v1.index] = v1.position += (t.triCenter - v1.position) * 1.0f * densityLerp;
// }
//}
// Animate floatingVert
foreach (var floatingVert in t.floatingVerts)
{
var offset = (t.sourceTri.triCenter - floatingVert.initialPosition) * densityLerp; // (t.triCenter - floatingVert.initialPosition) //(((floatingVert.targetPosition + floatingVert.initialPosition) * 0.5f) - t.triCenter)
vertexData[floatingVert.index] = floatingVert.position = Vector3.Lerp(floatingVert.initialPosition,
floatingVert.targetPosition,
EasingCurves.easeOutCubic(0, 1, timer));
}
}
meshFilter.mesh.vertices = vertexData.ToArray();
meshFilter.mesh.RecalculateNormals();
yield return(new WaitForEndOfFrame());
}
// Reuse Shared Verts
foreach (var t in foldingStages[stageIndex])
{
var triIndex = t.triIndex;
t.RemoveUniqueVerts();
foreach (var v in t.vertices)
{
vertexData[v.index] = v.position = v.initialPosition = v.targetPosition;
triangleData[triIndex] = v.index;
triIndex++;
}
}
}
// Increment Stage
stageIndex++;
if (stageIndex < foldingStages.Count)
{
StartCoroutine(AnimateStage());
}
else
{
FinalizeAnimation();
}
}
public void OnGUI()
{
if (dragNDrop.DropAreaBegin("outer"))
{
CustomGUIUtils.DrawBox(dragNDrop.ThisDropArea.Rect, XKCDColors.LightGreyBlue);
GUI.Label(dragNDrop.ThisDropArea.Rect, dragNDrop.ThisDropArea.ToString());
dragNDrop.DropAreaEnd("outer");
}
if (dragNDrop.DropAreaBegin("outer2"))
{
CustomGUIUtils.DrawBox(dragNDrop.ThisDropArea.Rect, color);
GUI.Label(dragNDrop.ThisDropArea.Rect, dragNDrop.ThisDropArea.ToString());
if (dragNDrop.ThisDropArea.ContainsMouse() && InputHelpers.ClickedLeft())
{
color = XKCDColors.Blue;
}
if (color == XKCDColors.Blue)
{
dragNDrop.ThisDropArea.Rect = EasingCurves.EaseRect(
"outer2",
dragNDrop.ThisDropArea.Rect,
new Rect(dragNDrop.ThisDropArea.Rect).AddOffset(new Rect(-100, -100, -200, -200)),
EasingCurves.EaseType.easeOutElastic);
}
dragNDrop.DropAreaEnd("outer2");
}
if (dragNDrop.DragObjectBegin(strings[0]))
{
CustomGUIUtils.DrawBox(dragNDrop.CurrentDragObject.CurrentRect, myGrey);
GUI.Label(dragNDrop.CurrentDragObject.CurrentRect, strings[0].ToString());
GUI.DrawTexture(dragNDrop.CurrentDragObject.CurrentRect, DefaultIconSet.Device);
// DropAreas
if (dragNDrop.DropAreaBegin("inner1"))
{
Rect drawRect = new Rect(dragNDrop.CurrentDragObject.CurrentRect);
drawRect.x += 10;
drawRect.y += 10;
drawRect.width = 130;
drawRect.height = 150;
dragNDrop.ThisDropArea.Rect = drawRect;
CustomGUIUtils.DrawBox(drawRect, XKCDColors.LightRed);
GUI.Label(drawRect, dragNDrop.ThisDropArea.ToString());
dragNDrop.DropAreaEnd("inner1");
}
if (dragNDrop.DropAreaBegin("inner2"))
{
Rect drawRect = new Rect(dragNDrop.CurrentDragObject.CurrentRect);
drawRect.x += 10;
drawRect.y += 210;
drawRect.width = 130;
drawRect.height = 150;
dragNDrop.ThisDropArea.Rect = drawRect;
CustomGUIUtils.DrawBox(drawRect, XKCDColors.GreenApple);
GUI.Label(drawRect, dragNDrop.ThisDropArea.ToString());
dragNDrop.DropAreaEnd("inner2");
}
// DragObjects
if (dragNDrop.DragObjectBegin(strings[1]))
{
CustomGUIUtils.DrawBox(dragNDrop.CurrentDragObject.CurrentRect, myGrey);
GUI.Label(dragNDrop.CurrentDragObject.CurrentRect, strings[1].ToString());
GUI.DrawTexture(dragNDrop.CurrentDragObject.CurrentRect, DefaultIconSet.Device);
dragNDrop.DragObjectEnd(strings[1]);
}
if (dragNDrop.DragObjectBegin(strings[2]))
{
CustomGUIUtils.DrawBox(dragNDrop.CurrentDragObject.CurrentRect, myGrey);
GUI.Label(dragNDrop.CurrentDragObject.CurrentRect, strings[2].ToString());
GUI.DrawTexture(dragNDrop.CurrentDragObject.CurrentRect, DefaultIconSet.Device);
dragNDrop.DragObjectEnd(strings[2]);
}
dragNDrop.DragObjectEnd(strings[0]);
}
//foreach (DropArea dropArea in dragNDrop.dropAreas.Values)
//{
// if (dropArea.Object != null)
// {
// if (dropArea.Object.GetType() == typeof(A))
// {
// A readA = dropArea.GetObject<A>();
// Debug.Log("A gelesen: " + readA.ToString());
// }
// }
//}
}
public static DialogResultType Dialog(DialogType dialogType, string title, string message, Rect rect, float factor, ref bool showDialog)
{
result = DialogResultType.UNDEFINED;
if (target == 0)
{
if (t > 0)
{
t -= Time.deltaTime / factor;
}
}
else if (target == 1)
{
if (t < 1)
{
t += Time.deltaTime / factor;
}
}
t = Mathf.Clamp01(t);
if (MathUtils.AlmostEqual(t, 0f, 0.01f) && target == 0f)
{
//ease = false;
showDialog = false;
target = 1f;
Debug.Log("Done?" + showDialog);
}
if (ease && showDialog)
{
if (target == 1)
{
currentRect = EasingCurves.EaseRect(
closedRect,
rect,
EasingCurves.EaseType.easeOutExpo,
t);
}
else if (target == 0)
{
currentRect = EasingCurves.EaseRect(
closedRect,
rect,
EasingCurves.EaseType.easeInExpo,
t);
}
}
CustomGUIUtils.DrawFrameBox(currentRect, Color.gray, 3f, Color.black);
//if(t == 1){
GUILayout.BeginArea(currentRect);
GUILayout.Label(title, GUILayout.Width(currentRect.width), GUILayout.Height(30f));
GUILayout.Space(30f);
GUILayout.BeginHorizontal();
GUILayout.Space(30f);
GUILayout.BeginVertical();
GUILayout.Label(message);
GUILayout.EndVertical();
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
switch (dialogType)
{
case DialogType.YES_NO:
if (GUILayout.Button("Yes"))
{
CloseDialog();
result = DialogResultType.YES;
}
if (GUILayout.Button("No"))
{
CloseDialog();
result = DialogResultType.NO;
}
break;
case DialogType.YES_NO_CANCEL:
if (GUILayout.Button("Yes"))
{
CloseDialog();
result = DialogResultType.YES;
}
if (GUILayout.Button("No"))
{
CloseDialog();
result = DialogResultType.NO;
}
if (GUILayout.Button("Cancel"))
{
CloseDialog();
result = DialogResultType.CANCEL;
}
break;
case DialogType.OK:
if (GUILayout.Button("OK"))
{
CloseDialog();
result = DialogResultType.OK;
}
break;
case DialogType.OK_CANCEL:
if (GUILayout.Button("Cancel"))
{
CloseDialog();
result = DialogResultType.CANCEL;
}
break;
default:
result = DialogResultType.UNDEFINED;
break;
}
GUILayout.EndHorizontal();
GUILayout.EndArea();
return(result);
}
public static void EndSideBar()
{
SidebarProperties sidebarProperties = sidebarPropertiesStack.Pop();
// End the ScrollView, Insets and GUIArea
GUILayout.EndScrollView();
GUILayout.Space(sidebarProperties.inset);
GUILayout.EndHorizontal();
GUILayout.Space(sidebarProperties.inset);
GUILayout.EndVertical();
GUILayout.EndArea();
GUI.EndGroup();
// Prepare the Slider-Button
Rect buttonRect = new Rect();
Texture2D icon = null;
switch (sidebarProperties.sidebarType)
{
case SidebarType.LEFT:
buttonRect = new Rect(
sidebarProperties.currentRect.xMax,
sidebarProperties.currentRect.yMin + sidebarProperties.currentRect.height / 2 - sidebarButtonSize.y / 2f,
sidebarButtonSize.x,
sidebarButtonSize.y);
icon = DefaultIconSet.ListLeftRight;
break;
case SidebarType.RIGHT:
buttonRect = new Rect(
sidebarProperties.currentRect.xMin - sidebarButtonSize.x,
sidebarProperties.currentRect.yMin + sidebarProperties.currentRect.height / 2 - sidebarButtonSize.y / 2f,
sidebarButtonSize.x,
sidebarButtonSize.y);
icon = DefaultIconSet.ListLeftRight;
break;
case SidebarType.TOP:
buttonRect = new Rect(
sidebarProperties.currentRect.xMin + sidebarProperties.currentRect.width / 2 - sidebarButtonSize.x / 2f,
sidebarProperties.currentRect.yMax,
sidebarButtonSize.x,
sidebarButtonSize.y);
icon = DefaultIconSet.ListUpDown;
break;
case SidebarType.BOTTOM:
buttonRect = new Rect(
sidebarProperties.currentRect.xMin + sidebarProperties.currentRect.width / 2 - sidebarButtonSize.x / 2f,
sidebarProperties.currentRect.yMin - sidebarButtonSize.y,
sidebarButtonSize.x,
sidebarButtonSize.y);
icon = DefaultIconSet.ListUpDown;
break;
default:
break;
}
GUIAreas.Add(sidebarProperties.sidebarName + "_Button", buttonRect);
// Draw the SliderButton
GUI.Label(buttonRect, icon);
// Handle Mouse and Touch-Input
Event currentEvent = Event.current;
#region Multitouch preparation
// Check if the current touchindex is still correct and available
if (Input.touchCount < sidebarProperties.touchIndex)
{
sidebarProperties.touchIndex = int.MaxValue;
}
for (int i = 0; i < Input.touches.Length; i++)
{
if (buttonRect.Contains(Input.touches[i].position.SwapScreenToWorldPoint()))
{
sidebarProperties.touchIndex = i;
}
}
#endregion // Multitouch preparation
#region Dragging
bool isTouchMoving = false;
if (Input.touchCount > sidebarProperties.touchIndex)
{
isTouchMoving =
(buttonRect.Contains(Input.touches[sidebarProperties.touchIndex].position.SwapScreenToWorldPoint()) || sidebarProperties.isDragging) &&
Input.touches[sidebarProperties.touchIndex].phase == TouchPhase.Moved;
}
bool isMouseDown = currentEvent.isMouse &&
currentEvent.type == EventType.MouseDrag &&
currentEvent.button == 0 &&
(buttonRect.Contains(currentEvent.mousePosition) || sidebarProperties.isDragging);
if (isTouchMoving || isMouseDown || sidebarProperties.isDragging)
{
sidebarProperties.isDragging = true;
float newPositionXmax;
float newPositionXmin;
float newPositionYmax;
float newPositionYmin;
Vector2 delta = Vector2.zero;
Vector2 newPosition = Vector2.zero;
if (isTouchMoving)
{
delta = Input.touches[sidebarProperties.touchIndex].deltaPosition;
newPosition = Input.touches[sidebarProperties.touchIndex].position.SwapScreenToWorldPoint();
}
else
{
delta = currentEvent.delta;
newPosition = currentEvent.mousePosition;
}
if (delta != Vector2.zero)
{
switch (sidebarProperties.sidebarType)
{
case SidebarType.LEFT:
newPositionXmax = newPosition.x;
if (newPositionXmax >= sidebarProperties.openRect.xMin && newPositionXmax <= sidebarProperties.openRect.xMax)
{
sidebarProperties.currentRect.xMax = newPositionXmax;
sidebarProperties.current = MathUtils.ParameterLine(sidebarProperties.openRect.xMin, sidebarProperties.openRect.xMax, sidebarProperties.currentRect.xMax);
}
sidebarProperties.draggingDirection = delta.ResetY().normalized;
break;
case SidebarType.RIGHT:
newPositionXmin = newPosition.x;
if (newPositionXmin >= sidebarProperties.openRect.xMin && newPositionXmin <= sidebarProperties.openRect.xMax)
{
sidebarProperties.currentRect.xMin = newPositionXmin;
sidebarProperties.current = MathUtils.ParameterLine(sidebarProperties.openRect.xMax, sidebarProperties.openRect.xMin, sidebarProperties.currentRect.xMin);
}
sidebarProperties.draggingDirection = delta.ResetY().normalized;
break;
case SidebarType.TOP:
newPositionYmax = newPosition.y;
if (newPositionYmax >= sidebarProperties.openRect.yMin && newPositionYmax <= sidebarProperties.openRect.yMax)
{
sidebarProperties.currentRect.yMax = newPositionYmax;
sidebarProperties.current = MathUtils.ParameterLine(sidebarProperties.openRect.yMin, sidebarProperties.openRect.yMax, sidebarProperties.currentRect.yMax);
}
sidebarProperties.draggingDirection = delta.ResetX().normalized;
break;
case SidebarType.BOTTOM:
newPositionYmin = newPosition.y;
if (newPositionYmin >= sidebarProperties.openRect.yMin && newPositionYmin <= sidebarProperties.openRect.yMax)
{
sidebarProperties.currentRect.yMin = newPositionYmin;
sidebarProperties.current = MathUtils.ParameterLine(sidebarProperties.openRect.yMax, sidebarProperties.openRect.yMin, sidebarProperties.currentRect.yMin);
}
sidebarProperties.draggingDirection = delta.ResetX().normalized;
break;
default:
break;
}
}
Debug.Log(delta + " --> DraggingDirection: " + sidebarProperties.draggingDirection);
}
#endregion // Dragging
#region Button clicked or DragMode-Ended
// If Touch ended inside Button-Rectangle
bool isTouchEnded = false;
if (Input.touchCount > sidebarProperties.touchIndex)
{
isTouchEnded =
(buttonRect.Contains(Input.touches[sidebarProperties.touchIndex].position.SwapScreenToWorldPoint()) || sidebarProperties.isDragging) &&
Input.touches[sidebarProperties.touchIndex].phase == TouchPhase.Ended;
}
// If Mouse clicked inside Button-Rectangle
bool isMouseUp =
currentEvent.isMouse &&
currentEvent.type == EventType.MouseUp &&
currentEvent.button == 0 &&
(buttonRect.Contains(currentEvent.mousePosition) || sidebarProperties.isDragging);
// If either mouse ot touch clicked the button
// OR DraggingMode has been ended
if (isTouchEnded || isMouseUp)
{
Debug.Log("Ended Touch / Mouse Clicked" + sidebarProperties.current);
// If we were in DraggingMode
if (sidebarProperties.isDragging)
{
Debug.Log("DraggingDirection: " + sidebarProperties.draggingDirection);
if (sidebarProperties.draggingDirection == Vector2.zero)
{
// snap to the nearest side
//Debug.Log("Setting new Target for " + sidebarProperties.current);
if (sidebarProperties.current <= 0.5f)
{
sidebarProperties.target = 0;
}
if (sidebarProperties.current > 0.5f)
{
sidebarProperties.target = 1;
}
//Debug.Log("---> " + sidebarProperties.target);
}
else
{
switch (sidebarProperties.sidebarType)
{
case SidebarType.LEFT:
if (sidebarProperties.draggingDirection == Vector2.right)
{
sidebarProperties.target = 1;
}
else
{
sidebarProperties.target = 0;
}
break;
case SidebarType.RIGHT:
if (sidebarProperties.draggingDirection == -Vector2.right)
{
sidebarProperties.target = 1;
}
else
{
sidebarProperties.target = 0;
}
break;
case SidebarType.TOP:
if (sidebarProperties.draggingDirection == -Vector2.up)
{
sidebarProperties.target = 1;
}
else
{
sidebarProperties.target = 0;
}
break;
case SidebarType.BOTTOM:
if (sidebarProperties.draggingDirection == Vector2.up)
{
sidebarProperties.target = 1;
}
else
{
sidebarProperties.target = 0;
}
break;
default:
break;
}
}
}
else
{
// Clicked the button --> open or close the sidebar
if (sidebarProperties.current <= 0.5f)
{
sidebarProperties.target = 1;
}
if (sidebarProperties.current > 0.5f)
{
sidebarProperties.target = 0;
}
}
//Debug.Log("Setting ease TRUE");
// set to ease --> animate the
sidebarProperties.ease = true;
sidebarProperties.isDragging = false;
}
#endregion // Button clicked or DragMode-Ended
#region Easing the Sidebar
if (sidebarProperties.ease)
{
if (sidebarProperties.easeInType == EasingCurves.EaseType.none)
{
sidebarProperties.ease = false;
if (sidebarProperties.target == 0)
{
sidebarProperties.currentRect = sidebarProperties.closedRect;
sidebarProperties.target = 1;
}
else if (sidebarProperties.target == 1)
{
sidebarProperties.currentRect = sidebarProperties.openRect;
sidebarProperties.target = 0;
}
}
else
{
if (sidebarProperties.target == 0)
{
if (sidebarProperties.current > 0)
{
sidebarProperties.current -= Time.deltaTime / sidebarProperties.factor;
}
}
else if (sidebarProperties.target == 1)
{
if (sidebarProperties.current < 1)
{
sidebarProperties.current += Time.deltaTime / sidebarProperties.factor;
}
}
sidebarProperties.current = Mathf.Clamp01(sidebarProperties.current);
if (sidebarProperties.ease)
{
if (sidebarProperties.target == 1)
{
sidebarProperties.currentRect = EasingCurves.EaseRect(
sidebarProperties.closedRect,
sidebarProperties.openRect,
sidebarProperties.easeInType,
sidebarProperties.current);
}
else if (sidebarProperties.target == 0)
{
sidebarProperties.currentRect = EasingCurves.EaseRect(
sidebarProperties.closedRect,
sidebarProperties.openRect,
sidebarProperties.easeOutType,
sidebarProperties.current);
}
}
if (sidebarProperties.current >= 1)
{
sidebarProperties.ease = false;
sidebarProperties.current = 1;
sidebarProperties.target = 0;
}
else if (sidebarProperties.current <= 0)
{
sidebarProperties.ease = false;
sidebarProperties.current = 0;
sidebarProperties.target = 1;
}
}
}
#endregion // Easing the Sidebar
}
