public PhaseInterfacial(double sigma, double aspectRatio, DRAG_TYPE drag, VIRTUAL_MASS_TYPE virtualMass, HEAT_TRANSFER_TYPE heatTransfer, LIFT_TYPE lift, double pMin)
{
this.sigma = sigma;
this.aspectRatio = aspectRatio;
this.drag = drag;
this.virtualMass = virtualMass;
this.heatTransfer = heatTransfer;
this.lift = lift;
this.pMin = pMin;
}
public PhaseInterfacial()
{
sigma = 0.07;
aspectRatio = 1.0;
drag = DRAG_TYPE.SchillerNaumann;
virtualMass = VIRTUAL_MASS_TYPE.ConstantCoefficient;
heatTransfer = HEAT_TRANSFER_TYPE.RanzMarshall;
lift = LIFT_TYPE.NoLift;
pMin = 10000;
}
void Update()
{
if (isPress)
{
if (eDragType == DRAG_TYPE.NONE && Vector3.Distance(UICamera.lastWorldPosition, startClickPosition) > MIN_DISTANCE)
{
Vector3 dir = Vector3.left;
switch (eDragDirection)
{
case DragDirection.Left:
dir = Vector3.left; break;
case DragDirection.Right:
dir = Vector3.right; break;
case DragDirection.Down:
dir = Vector3.down; break;
case DragDirection.Up:
dir = Vector3.up; break;
}
if (Vector3.Angle(dir, UICamera.lastWorldPosition - startClickPosition) < MIN_ANGLE)
{
OnThisDragStart();
}
else
{
eDragType = DRAG_TYPE.OTHER;
}
}
if (eDragType == DRAG_TYPE.DRAGE_MODEL)
{
OnThisDrag();
}
}
}
protected virtual void OnThisDragEnd()
{
eDragType = DRAG_TYPE.NONE;
EventDelegate.Execute(onDragEndFunc);
}
protected virtual void OnThisDragStart()
{
eDragType = DRAG_TYPE.DRAGE_MODEL;
EventDelegate.Execute(onDragStartFunc);
}
public virtual void Start()
{
isPress = false;
eDragType = DRAG_TYPE.NONE;
}
//Draw the layers
void DrawLayers(Rect layerRect, Rect gridRect)
{
bool contextEnabled = false;
Handles.color = customGUISkin.GetStyle("MinorTimestamp").normal.textColor;
float startY = layerRect.y + HEADER_SIZE;
Vector3 mousePosition = Event.current.mousePosition;
bool mouseUpUsed = false;
for (int i = 0; i < mLayers.Count; i++)
{
if (mLayers[i] != null)
{
float layerHeight = mLayers[i].getHeight();
//Draw labels
Rect thisLayerRect = new Rect(0, startY, layerRect.width, layerHeight);
bevel(ref thisLayerRect, 2.0f);
GUI.Box(thisLayerRect, "");
if (Event.current.type == EventType.mouseDown && thisLayerRect.Contains(mousePosition))
{
Selection.activeGameObject = mLayers[i].gameObject;
}
/*if (mRenamingLayer == i)
{
mLayers[i].name = GUI.TextField(thisLayerRect, mLayers[i].name);
if ((Event.current.type == EventType.MouseUp && !thisLayerRect.Contains(mousePosition)) ||
(Event.current.type == EventType.KeyUp && Event.current.keyCode == KeyCode.Return))
{
resetName(i);
this.Repaint();
}
}
else
{*/
mLayers[i].open = EditorGUI.Foldout(thisLayerRect, mLayers[i].open, mLayers[i].name);
//}
//Draw events
for (int j = 0; j < mLayers[i].events.Count; j++)
{
TimelineEvent tempEvent = mLayers[i].events[j];
if (tempEvent != null)
{
float startTime = tempEvent.startTime;
float length = tempEvent.getLength();
float viewStart = startTime / mDisplayTime - mXScrollMin / (mXScrollMax - mXScrollMin);
float percentLength = length / mDisplayTime;
//Not visible
if (viewStart + percentLength < 0 || viewStart > 1)
{
continue;
}
bool isSelected = false;
for (int index = 0; index < Selection.gameObjects.Length; index++)
{
if (Selection.gameObjects[index] == tempEvent.gameObject)
{
isSelected = true;
}
}
if (viewStart < 0)
{
percentLength += viewStart;
viewStart = 0;
}
if (viewStart + percentLength > 1)
{
percentLength = 1 - viewStart;
}
if (percentLength * gridRect.width < MINIMUM_EVENT_SIZE)
{
percentLength = MINIMUM_EVENT_SIZE / gridRect.width;
}
Rect eventRect = new Rect(gridRect.x + viewStart * gridRect.width, thisLayerRect.y - 3, percentLength * gridRect.width, layerHeight);
//bevel(ref eventRect, 2.0f);
//Draw event context
if (Event.current.type == EventType.ContextClick && eventRect.Contains(mousePosition))
{
mSelectedEvent = tempEvent;
mEventMenu.ShowAsContext();
contextEnabled = true;
}
//Sperate the event's action rect and display rect
Rect actionRect = eventRect;
//Add the length slider tabs
Rect leftSlider = new Rect();
Rect rightSlider = new Rect();
if (tempEvent.gameObject.active && tempEvent.canModifyLength())
{
splitRectHorizontal(actionRect, out leftSlider, out actionRect, SLIDER_SIZE);
splitRectHorizontal(actionRect, out actionRect, out rightSlider, actionRect.width - SLIDER_SIZE);
if (mDragEvents.Count == 0 && Event.current.type == EventType.MouseDown && leftSlider.Contains(mousePosition))
{
mMouseClickPosition = mousePosition;
}
else if (mDragEvents.Count == 0 && Event.current.type == EventType.MouseDrag && leftSlider.Contains(mMouseClickPosition))
{
mDragEvents[tempEvent] = new DraggedEvent();
mDragEventType = DRAG_TYPE.EXPAND_LEFT;
Undo.RegisterUndo(EditorUtility.CollectDeepHierarchy(new UnityEngine.Object[] { mActiveTimeline }), "Expand Left");
}
if (mDragEvents.Count == 0 && Event.current.type == EventType.MouseDown && rightSlider.Contains(mousePosition))
{
mMouseClickPosition = mousePosition;
}
else if (mDragEvents.Count == 0 && Event.current.type == EventType.MouseDrag && rightSlider.Contains(mMouseClickPosition))
{
mDragEvents[tempEvent] = new DraggedEvent();
mDragEventType = DRAG_TYPE.EXPAND_RIGHT;
mDragEvents[tempEvent].mDragEventPlaceTime = tempEvent.startTime;
Undo.RegisterUndo(EditorUtility.CollectDeepHierarchy(new UnityEngine.Object[] { mActiveTimeline }), "Expand Right");
}
}
//Inspector
if (mDragEvents.Count == 0 && Event.current.type == EventType.MouseUp && actionRect.Contains(mousePosition) && !mDraggingTimer)
{
if (Event.current.control)
{
UnityEngine.Object[] tempObjects = new GameObject[Selection.gameObjects.Length + 1];
bool wasInList = false;
int index = 0;
for (index = 0; index < Selection.gameObjects.Length; index++)
{
tempObjects[index] = Selection.gameObjects[index];
if (tempObjects[index] == tempEvent)
{
wasInList = true;
break;
}
}
if (!wasInList)
{
tempObjects[index] = tempEvent.gameObject;
Selection.objects = tempObjects;
}
}
else
{
Selection.activeObject = tempEvent.gameObject;
}
Repaint();
mouseUpUsed = true;
}
Vector2 deltaMouse = Vector2.zero;
//Drag and drop
if (tempEvent.gameObject.active)
{
if (Event.current.type == EventType.MouseDown)//mDragEvents.Count == 0 && Event.current.type == EventType.MouseDown && actionRect.Contains(mousePosition))
{
mMouseClickPosition = mousePosition;
}
else if (mDragEvents.Count == 0 && Event.current.type == EventType.MouseDrag && actionRect.Contains(mMouseClickPosition))
{
if (isSelected && Selection.gameObjects.Length > 1)
{
for (int k = 0; k < Selection.gameObjects.Length; k++)
{
TimelineEvent tempSelectionEvent = (TimelineEvent)Selection.gameObjects[k].GetComponent<TimelineEvent>();
if (tempSelectionEvent != null)
{
mDragEvents[tempSelectionEvent] = new DraggedEvent();
mDragEvents[tempSelectionEvent].mLayerOffset = tempEvent.getLayer().layerNumber - tempSelectionEvent.getLayer().layerNumber;
}
}
}
mDragEvents[tempEvent] = new DraggedEvent();
mDragEvents[tempEvent].mLayerOffset = 0;
mDragEvents[tempEvent].mIsMainEvent = true;
mDragEventStartTime = mMouseTime;
mDragEventType = DRAG_TYPE.MOVE;
mDragEventLength = tempEvent.getLength();
Undo.RegisterUndo(EditorUtility.CollectDeepHierarchy(new UnityEngine.Object[] { mActiveTimeline }), "Move event");
}
else if (mDragEvents.Count > 0)
{
deltaMouse = mousePosition - mMouseClickPosition;
}
}
//This event is being dragged
if (mDragEvents.ContainsKey(tempEvent))
{
switch (mDragEventType)
{
case DRAG_TYPE.EXPAND_RIGHT:
if (Event.current.type == EventType.MouseUp || mouseOverWindow != this)
{
if (!mDragEventInvalidPlacement || !CHECK_VALIDITY)
{
float endPoint = ((mDragEvents[tempEvent].mDragEventPlaceTime + mDragEventLength) / mDisplayTime - mXScrollMin / (mXScrollMax - mXScrollMin)) * gridRect.width + gridRect.x;
tempEvent.length = mDragEventLength;
refreshEvents();
}
mMouseClickPosition = new Vector2(0, 0);
mDragEvents.Clear();
mouseUpUsed = true;
}
else
{
float mousePoint = (mMouseTime / mDisplayTime - mXScrollMin / (mXScrollMax - mXScrollMin)) * gridRect.width + gridRect.x;
float startPoint = eventRect.x;
eventRect.width = mousePoint - eventRect.x;
eventRect.y += HEADER_SIZE * 2;
float tempLength = eventRect.width / gridRect.width * mDisplayTime;
checkEventValidity(i, tempEvent, eventRect.x, tempLength, gridRect, ref eventRect);
eventRect.width -= startPoint - eventRect.x;
eventRect.x += startPoint - eventRect.x;
mDragEvents[tempEvent].mDragEventRect = eventRect;
mDragEventLength = Mathf.Max(0, eventRect.width / gridRect.width * mDisplayTime + (Mathf.Max(0, mXScrollMin - tempEvent.startTime)) / (mXScrollMax - mXScrollMin) * mDisplayTime);
}
break;
case DRAG_TYPE.EXPAND_LEFT:
if (Event.current.type == EventType.MouseUp || mouseOverWindow != this)
{
if (!mDragEventInvalidPlacement || !CHECK_VALIDITY)
{
float delta = tempEvent.startTime - mDragEvents[tempEvent].mDragEventPlaceTime;
tempEvent.startTime = mDragEvents[tempEvent].mDragEventPlaceTime;
tempEvent.length += delta;
refreshEvents();
}
mMouseClickPosition = new Vector2(0, 0);
mDragEvents.Clear();
mouseUpUsed = true;
}
else
{
float startPoint = (mMouseTime / mDisplayTime - mXScrollMin / (mXScrollMax - mXScrollMin)) * gridRect.width + gridRect.x;
float delta = eventRect.x - startPoint;
float rightPoint = eventRect.x + eventRect.width;
eventRect.x = startPoint;
eventRect.width += delta;
eventRect.y += HEADER_SIZE * 2;
float tempLength = eventRect.width / gridRect.width * mDisplayTime;
checkEventValidity(i, tempEvent, eventRect.x, tempLength, gridRect, ref eventRect);
if (eventRect.x > rightPoint - MINIMUM_EVENT_SIZE)
{
eventRect.x = rightPoint - MINIMUM_EVENT_SIZE;
eventRect.width = MINIMUM_EVENT_SIZE;
}
else
{
eventRect.width += startPoint - eventRect.x;
}
mDragEvents[tempEvent].mDragEventRect = eventRect;
mDragEvents[tempEvent].mDragEventPlaceTime = Mathf.Min(tempEvent.startTime + tempEvent.length, ((eventRect.x - gridRect.x) / gridRect.width + mXScrollMin / (mXScrollMax - mXScrollMin)) * mDisplayTime);
mDragEventLength = tempEvent.startTime + tempEvent.length - mDragEvents[tempEvent].mDragEventPlaceTime;//Mathf.Max(0, eventRect.width / gridRect.width * mDisplayTime + mXScrollMin / (mXScrollMax - mXScrollMin) * mDisplayTime);
}
break;
case DRAG_TYPE.MOVE:
//Find layer
int currentLayer = 0;
float tempLayerHeight = 0;
for (; currentLayer < mLayers.Count - 1; currentLayer++)
{
if (mousePosition.y < tempLayerHeight + mLayers[currentLayer].getHeight())
{
break;
}
tempLayerHeight += mLayers[currentLayer].getHeight();
}
currentLayer -= mDragEvents[tempEvent].mLayerOffset;
currentLayer = Mathf.Max(0, Mathf.Min(currentLayer, mLayers.Count - 1));
//Clipping
eventRect.x += deltaMouse.x;
eventRect.y = mLayerSizes[mLayers[currentLayer]] + HEADER_SIZE * 2 - mLayers[currentLayer].getHeight();
if (eventRect.x < gridRect.x)
{
eventRect.x = gridRect.x;
}
if (eventRect.xMax > gridRect.xMax)
{
eventRect.x = gridRect.xMax - eventRect.width;
}
mDragEventInvalidPlacement = false;
//only snap when it's a single selection
if (mDragEvents.Count == 1)
{
checkEventValidity(currentLayer, tempEvent, eventRect.x, tempEvent.getLength(), gridRect, ref eventRect);
}
mDragEvents[tempEvent].mDragEventPlaceTime = mMouseTime - mDragEventStartTime + startTime;
if (mDragEvents[tempEvent].mDragEventPlaceTime < mXScrollMin * mActiveTimeline.length)
{
mDragEvents[tempEvent].mDragEventPlaceTime = mXScrollMin * mActiveTimeline.length;
}
else if (mDragEvents[tempEvent].mDragEventPlaceTime + tempEvent.getLength() > mXScrollMax * mActiveTimeline.length)
{
mDragEvents[tempEvent].mDragEventPlaceTime = mXScrollMax * mActiveTimeline.length - tempEvent.getLength();
}
else
{
mDragEvents[tempEvent].mDragEventPlaceTime = ((eventRect.x - gridRect.x) / gridRect.width + mXScrollMin / (mXScrollMax - mXScrollMin)) * mDisplayTime;
}
if (mDragEvents[tempEvent].mIsMainEvent && (Event.current.type == EventType.MouseUp || mouseOverWindow != this))
{
mMouseClickPosition = new Vector2(0, 0);
if (!mDragEventInvalidPlacement || !CHECK_VALIDITY)
{
foreach (KeyValuePair<TimelineEvent, DraggedEvent> pair in mDragEvents)
{
int tempLayer = currentLayer - pair.Value.mLayerOffset;
tempLayer = Mathf.Max(0, Mathf.Min(tempLayer, mLayers.Count - 1));
pair.Key.transform.parent = mLayers[tempLayer].transform;
pair.Key.startTime = pair.Value.mDragEventPlaceTime;
}
refreshEvents();
}
mDragEvents.Clear();
mouseUpUsed = true;
}
else
{
mDragEvents[tempEvent].mDragEventRect = eventRect;
}
break;
}
this.Repaint();
}
else
{
Color tempColor = GUI.color;
if (isSelected)
{
tempColor = Color.green;
}
else if (!tempEvent.gameObject.active)
{
tempColor = Color.black;
}
DrawEvent(tempEvent, actionRect, tempEvent.startTime, tempEvent.getLength(), tempColor);
if (tempEvent.gameObject.active && tempEvent.canModifyLength())
{
GUI.Button(leftSlider, "");
GUI.Button(rightSlider, "");
}
}
}
}
//Draw dividing lines
Vector3 a = new Vector3(0, startY, 0);
Vector3 b = new Vector3(gridRect.xMax, startY, 0);
Handles.DrawLine(a, b);
startY += layerHeight;
if (i == mLayers.Count - 1)
{
a = new Vector3(0, startY, 0);
b = new Vector3(gridRect.xMax, startY, 0);
Handles.DrawLine(a, b);
}
//Draw layer context
if (!contextEnabled)
{
Rect contextRect = thisLayerRect;
contextRect.width += gridRect.width;
if (Event.current.type == EventType.ContextClick && contextRect.Contains(mousePosition))
{
mSelectedLayer = i;
mLayerMenu.ShowAsContext();
mContextMenuTime = mMouseTime;
contextEnabled = true;
}
}
}
}
//Draw global context
if (!contextEnabled)
{
if (Event.current.type == EventType.ContextClick)
{
mGlobalMenu.ShowAsContext();
}
}
//Clear selection
if (!mouseUpUsed && Event.current.type == EventType.MouseUp && !mDraggingTimer)
{
Selection.activeObject = mActiveTimeline.gameObject;
}
}
