public override void OnDrawingGizmosSelected()
{
var elemRef = Target as ElementReferenceDataControl;
var rect = GetElementRect(elemRef);
var id = GUIUtility.GetControlID(GetHashCode(), FocusType.Passive);
var newRect = HandleUtil.HandleFixedRatioRect(id, rect, rect.width / rect.height, 10f,
(polygon, over, active) => HandleUtil.DrawPolyLine(polygon, true, Color.red, over && MouseOverTexture(elemRef, rect) || active ? 4f : 2f),
(point, over, active) => HandleUtil.DrawPoint(point, 4.5f, Color.blue, over || active ? 2f : 1f, SceneEditor.GetColor(over || active ? Color.red : Color.black)));
if (newRect != rect)
{
var original = newRect.ViewportToScreen(SceneEditor.Current.Size.x, SceneEditor.Current.Size.y, SceneEditor.Current.Viewport);
var unscaled = ScenesWindowElementReference.ReferenceComponent.GetUnscaledRect(Target);
// And then we rip the position
var position = original.center + new Vector2(0, original.height / 2f);
var scale = original.size.magnitude / unscaled.size.magnitude;
// And then we set the values in the reference
elemRef.setElementPositionAndScale(Mathf.RoundToInt(position.x), Mathf.RoundToInt(position.y), scale);
}
var movementId = GUIUtility.GetControlID(GetHashCode() + 1, FocusType.Passive);
EditorGUI.BeginChangeCheck();
rect = HandleUtil.HandleRectMovement(movementId, rect);
if (EditorGUI.EndChangeCheck())
{
var original = rect.ViewportToScreen(SceneEditor.Current.Size.x, SceneEditor.Current.Size.y, SceneEditor.Current.Viewport);
elemRef.setElementPosition(Mathf.RoundToInt(original.x + 0.5f * original.width), Mathf.RoundToInt(original.y + original.height));
}
}
public override void OnDrawingGizmosSelected()
{
var elemRef = Target as ElementReferenceDataControl;
var rect = GetElementRect(elemRef);
var newRect = HandleUtil.HandleFixedRatioRect(elemRef.GetHashCode() + 1, rect, rect.width / rect.height, 10f,
polygon => HandleUtil.DrawPolyLine(polygon, true, Color.red),
point => HandleUtil.DrawPoint(point, 4.5f, Color.blue, Color.black));
if (newRect != rect)
{
var original = newRect.ViewportToScreen(SceneEditor.Current.Size.x, SceneEditor.Current.Size.y, SceneEditor.Current.Viewport);
var unscaled = ScenesWindowElementReference.ReferenceComponent.GetUnscaledRect(Target);
// And then we rip the position
var position = original.center + new Vector2(0, original.height / 2f);
var scale = original.size.magnitude / unscaled.size.magnitude;
// And then we set the values in the reference
elemRef.setElementPositionAndScale(Mathf.RoundToInt(position.x), Mathf.RoundToInt(position.y), scale);
}
EditorGUI.BeginChangeCheck();
rect = HandleUtil.HandleRectMovement(elemRef.GetHashCode(), rect);
if (EditorGUI.EndChangeCheck())
{
var original = rect.ViewportToScreen(SceneEditor.Current.Size.x, SceneEditor.Current.Size.y, SceneEditor.Current.Viewport);
elemRef.setElementPosition(Mathf.RoundToInt(original.x + 0.5f * original.width), Mathf.RoundToInt(original.y + original.height));
}
}
public override void OnDrawingGizmosSelected()
{
var gameplayArea = Target as GameplayAreaDataControl;
if (!gameplayArea.UsesGameplayArea)
{
return;
}
var gameplayAreaRect = MapEditor.Current.ToRelative(MapEditor.Current.LatLonToPixels(gameplayArea.BoundingBox.ToPoints()))
.ToRectD().ToRect();
var handleRectID = GUIUtility.GetControlID(GetHashCode(), FocusType.Passive);
EditorGUI.BeginChangeCheck();
Handles.BeginGUI();
var newRect = HandleUtil.HandleRect(handleRectID, gameplayAreaRect, 10, (_, __, ___) => { },
(p, hover, active) => HandleUtil.DrawSquare(p, 10, MapEditor.GetColor(Color.yellow),
hover ? MapEditor.GetColor(Color.red) : MapEditor.GetColor(Color.black)));
Handles.EndGUI();
if (EditorGUI.EndChangeCheck())
{
var latLonRect = MapEditor.Current
.PixelsToLatLon(MapEditor.Current.FromRelative(newRect.ToRectD().ToPoints())).ToRectD();
gameplayArea.BoundingBox = latLonRect;
}
}
public static void AppendToWallpaperArea(IntPtr handle)
{
if (HandleUtil.NeedSeparation)
{
HandleUtil.SpawnWorker();
}
WindowNative.SetParent(handle, HandleUtil.WallpaperArea);
}
public static Graphics GetWallpaperGraphics()
{
if (HandleUtil.NeedSeparation)
{
HandleUtil.SpawnWorker();
}
return(Graphics.FromHwnd(HandleUtil.WallpaperArea));
}
public override void OnDrawingGizmosSelected()
{
var rect = ScenesWindowElementReference.ReferenceComponent.GetElementRect(Target);
// Rect resizing
var id = GUIUtility.GetControlID(GetHashCode(), FocusType.Passive);
EditorGUI.BeginChangeCheck();
var newRect = HandleUtil.HandleFixedRatioRect(id, rect, rect.width / rect.height, 10f,
(polygon, over, active) => HandleUtil.DrawPolyLine(polygon, true, SceneEditor.GetColor(Color.red)),
(point, over, active) => HandleUtil.DrawPoint(point, 4.5f, SceneEditor.GetColor(Color.blue), SceneEditor.GetColor(Color.black)));
if (EditorGUI.EndChangeCheck())
{
var original = newRect.ViewportToScreen(SceneEditor.Current.Size.x, SceneEditor.Current.Size.y, SceneEditor.Current.Viewport);
var unscaled = ScenesWindowElementReference.ReferenceComponent.GetUnscaledRect(Target);
// And then we rip the position
var position = original.center + new Vector2(0, original.height / 2f);
var scale = original.size.magnitude / unscaled.size.magnitude;
if (Target is PlayerDataControl)
{
var workingScene = Controller.Instance.SelectedChapterDataControl.getScenesList().getScenes()[
GameRources.GetInstance().selectedSceneIndex];
// And then we set the values in the reference
workingScene.setDefaultInitialPosition(Mathf.RoundToInt(position.x), Mathf.RoundToInt(position.y));
workingScene.setPlayerScale(scale);
}
else if (Target is NodeDataControl)
{
var node = Target as NodeDataControl;
node.setNode(Mathf.RoundToInt(position.x), Mathf.RoundToInt(position.y), scale);
}
}
// Rect movement
var movementId = GUIUtility.GetControlID(GetHashCode() + 1, FocusType.Passive);
EditorGUI.BeginChangeCheck();
rect = HandleUtil.HandleRectMovement(movementId, rect);
if (EditorGUI.EndChangeCheck())
{
var original = rect.ViewportToScreen(SceneEditor.Current.Size.x, SceneEditor.Current.Size.y, SceneEditor.Current.Viewport);
var rectBase = original.Base();
if (Target is PlayerDataControl)
{
var workingScene = Controller.Instance.SelectedChapterDataControl.getScenesList().getScenes()[GameRources.GetInstance().selectedSceneIndex];
workingScene.setDefaultInitialPosition(Mathf.RoundToInt(rectBase.x), Mathf.RoundToInt(rectBase.y));
}
else if (Target is NodeDataControl)
{
var node = Target as NodeDataControl;
node.setNode(Mathf.RoundToInt(rectBase.x), Mathf.RoundToInt(rectBase.y), node.getScale());
}
}
}
// AUX FUNCTIONS
private void DrawScene(SceneDataControl scene)
{
var rect = AdaptToViewport(GetSceneRect(scene), space);
switch (Event.current.type)
{
case EventType.Repaint:
GUI.DrawTexture(rect, images[scene.getPreviewBackground()] ?? noBackground);
if (sceneList.index != -1 && Controller.Instance.SelectedChapterDataControl.getScenesList().getScenes()[sceneList.index] == scene)
{
HandleUtil.DrawPolyLine(rect.ToPoints().ToArray(), true, Color.red);
}
break;
}
EditorGUI.DropShadowLabel(new Rect(rect.position - new Vector2(20, 0), rect.size), scene.getId());
var prevHot = GUIUtility.hotControl;
EditorGUI.BeginChangeCheck();
rect = HandleUtil.HandleRectMovement(scene.GetHashCode(), rect);
if (EditorGUI.EndChangeCheck())
{
rect = RevertFromViewport(rect, space);
if (settings != null)
{
var canvasRect = new Rect(0, 0, SPACE_WIDTH, SPACE_HEIGHT);
sceneToNode[scene].BoundingBox = ToGraphRect(rect, canvasRect, graph.BoundingBox);
UpdatePositions();
/*var bounds =
* new Microsoft.Msagl.Core.Geometry.Rectangle(100, 100, 100 + rect.width,
* 100 + rect.height);
*
* if (!sceneLockPositions.ContainsKey(scene))
* {
* sceneLockPositions[scene] = settings.CreateLock(sceneToNode[scene], bounds);
* }
*
* sceneLockPositions[scene].Bounds = bounds;*/
}
else
{
positions[scene.getId()] = rect.position;
}
}
if (GUIUtility.hotControl != prevHot)
{
sceneList.index = Controller.Instance.SelectedChapterDataControl.getScenesList().getScenes().IndexOf(scene);
if (Event.current.clickCount == 2 && OnSelectElement != null)
{
OnSelectElement(scene);
}
}
}
public void Initialize()
{
if (Initialized)
{
return;
}
Initialized = true;
// pre spawn worker to draw faster
if (HandleUtil.NeedSeparation)
{
HandleUtil.SpawnWorker();
}
}
public static Rect HandleRect(int handleId, Rect rect, float maxPointDistance, Action <Vector2[]> drawPolygon, Action <Vector2> drawPoint)
{
var points = rect.ToPoints();
int pointChanged = -1;
Vector2 oldPointValue = Vector2.zero;
if (Event.current.type == EventType.Repaint)
{
drawPolygon(points);
}
for (int i = 0; i < points.Length; i++)
{
EditorGUI.BeginChangeCheck();
var aux = points[i];
points[i] = HandleUtil.HandlePointMovement(handleId + i + 1, points[i], 10f, p => drawPoint(p));
if (EditorGUI.EndChangeCheck())
{
oldPointValue = aux;
points[i] = Event.current.mousePosition;
pointChanged = i;
}
}
if (pointChanged != -1)
{
GUI.changed = true;
var diff = points[pointChanged] - oldPointValue;
// Fix the change
switch (pointChanged)
{
case 0: points[3].x += diff.x; points[1].y += diff.y; break;
case 1: points[2].x += diff.x; points[0].y += diff.y; break;
case 2: points[1].x += diff.x; points[3].y += diff.y; break;
case 3: points[0].x += diff.x; points[2].y += diff.y; break;
}
//First we calculate the new original screen rect
var original = points.ToRect();
rect = original;
}
return(rect);
}
private static void DrawIconIndex(Rect controlRect, IntGridValueDefinition data)
{
Color color = HandleUtil.GetTextColorForIntGridValueNumber(data.UnityColor);
GUIStyle style = new GUIStyle(GUI.skin.label)
{
normal = new GUIStyleState()
{
textColor = color
}
};
string value = $"{data.Value}";
GUI.Label(controlRect, value, style);
}
public void PrecalculateValues()
{
if (_tex == null)
{
return;
}
if (_transform == null)
{
return;
}
if (!LDtkPrefs.ShowEntityIcon)
{
return;
}
Handles.BeginGUI();
Vector3 worldPosition = _transform.position;
Vector3 guiPoint = HandleUtility.WorldToGUIPointWithDepth(worldPosition);
//if camera is in front of the point, then don't draw it
if (guiPoint.z < 0)
{
return;
}
Vector2 guiSize = Vector2.one * HandleUtil.GetIconGUISize(worldPosition, _srcPx.size);
_imageArea = new Rect
{
position = (Vector2)guiPoint - (guiSize / 2),
size = guiSize
};
_texCoords = HandleUtil.GetNormalizedTextureCoords(_tex, _srcPx);
OffsetToNextUI = new Vector2()
{
x = _imageArea.x - guiPoint.x,
y = _imageArea.height / 2 + 2
};
_canDraw = true;
Handles.EndGUI();
}
public override void OnDrawingGizmosSelected()
{
if (GetScenePlayerMode(SceneEditor.Current.Scene) != PlayerMode.Trajectory)
{
return;
}
wasSelected = Target;
var influenceArea = getInfluenceArea(Target);
if (influenceArea == null)
{
return;
}
var boundaries = GetElementBoundaries(Target);
var rect = influenceArea.ScreenRect(boundaries);
if (!influenceArea.hasInfluenceArea())
{
rect.position -= new Vector2(20, 20);
rect.size = boundaries.size + new Vector2(40, 40);
}
rect = rect.AdjustToViewport(SceneEditor.Current.Size.x, SceneEditor.Current.Size.y, SceneEditor.Current.Viewport);
EditorGUI.BeginChangeCheck();
var newRect = HandleUtil.HandleRect(influenceArea.GetHashCode() + 1, rect, 10f,
(polygon, over, active) =>
{
HandleUtil.DrawPolyLine(polygon, true, Color.blue);
HandleUtil.DrawPolygon(polygon, new Color(0, 0, 1f, 0.3f));
},
(point, over, active) => HandleUtil.DrawSquare(point, 6.5f, Color.yellow, Color.black));
newRect = HandleUtil.HandleRectMovement(influenceArea.GetHashCode(), newRect);
if (EditorGUI.EndChangeCheck())
{
var original = newRect.ViewportToScreen(SceneEditor.Current.Size.x, SceneEditor.Current.Size.y, SceneEditor.Current.Viewport);
original.position -= boundaries.position;
var rectFixed = FixToBoundaries(new RectInt((int)original.x, (int)original.y, (int)original.width, (int)original.height), boundaries);
// And then we set the values in the reference
influenceArea.setInfluenceArea(rectFixed.x, rectFixed.y, rectFixed.width, rectFixed.height);
}
}
public override void OnRender()
{
var side = Target as SideDataControl;
var p1 = GetPivot(side.getStart());
var p2 = GetPivot(side.getEnd());
HandleUtil.DrawPolyLine(new Vector2[] { p1, p2 }, false, SceneEditor.GetColor(Color.black), 5f);
HandleUtil.DrawPolyLine(new Vector2[] { p1, p2 }, false, SceneEditor.GetColor(Color.white), 3f);
var bcColor = GUI.color;
if (side.getLength() != side.getRealLength())
{
GUI.color = SceneEditor.GetColor(Color.yellow);
}
EditorGUI.DropShadowLabel(new Rect(((p1 + p2) / 2f) - new Vector2(100f, 25f), new Vector2(200, 30)), new GUIContent(Mathf.RoundToInt(side.getLength()).ToString()));
GUI.color = bcColor;
}
private void DrawExit(SceneDataControl scene, ExitDataControl exit)
{
var scenes = Controller.Instance.SelectedChapterDataControl.getScenesList();
var index = scenes.getSceneIndexByID(exit.getNextSceneId());
// If the exit points to a cutscene it normally is out of the array
if (index < 0 || index > scenes.getScenes().Count)
{
return;
}
var polygon = AdaptToViewport(GetExitArea(scene, exit), space);
if (polygon == null || polygon.Length == 0)
{
// If the exit is empty use the scene center itself to prevent errors
polygon = new [] { AdaptToViewport(GetSceneRect(scene), space).center };
}
var c = sceneColors[scene.getId()];
c = new Color(c.r, c.g, c.b, 0.8f);
HandleUtil.DrawPolygon(polygon, c);
var nextScene = scenes.getScenes()[index];
var sceneRect = AdaptToViewport(GetSceneRect(nextScene), space);
Vector2 origin = polygon.Center(), destination;
if (exit.hasDestinyPosition())
{
destination = new Vector2(exit.getDestinyPositionX(), exit.getDestinyPositionY());
destination.x = sceneRect.x + (destination.x / sizes[nextScene.getPreviewBackground()].x) * sceneRect.width;
destination.y = sceneRect.y + (destination.y / sizes[nextScene.getPreviewBackground()].y) * sceneRect.height;
}
else
{
destination = sceneRect.ToPoints().Center();
}
HandleUtil.DrawPolyLine(new [] { origin, destination }, false, sceneColors[scene.getId()], 4);
DrawArrowCap(destination, (destination - origin), 15f);
}
private static ILDtkHandleDrawer DrawEntity(LDtkEntityDrawerData entity)
{
Vector2 offset = Vector2.down;
if (entity.Transform == null || !entity.Transform.gameObject.activeInHierarchy)
{
return(null);
}
switch (entity.EntityMode)
{
case RenderMode.Cross:
case RenderMode.Ellipse:
case RenderMode.Rectangle:
LDtkEntityDrawerShapes.Data shapeData = new LDtkEntityDrawerShapes.Data()
{
EntityMode = entity.EntityMode,
FillOpacity = entity.FillOpacity,
LineOpacity = entity.LineOpacity,
Hollow = entity.Hollow,
Pivot = entity.Pivot,
Size = entity.Size
};
LDtkEntityDrawerShapes entityDrawer = new LDtkEntityDrawerShapes(entity.Transform, shapeData);
entityDrawer.OnDrawHandles();
break;
}
if (entity.DrawTile)
{
LDtkEntityDrawerIcon iconDrawer = new LDtkEntityDrawerIcon(entity.Transform, entity.Tex, entity.TexRect);
iconDrawer.PrecalculateValues();
offset = iconDrawer.OffsetToNextUI;
iconDrawer.OnDrawHandles();
}
if (entity.ShowName && LDtkPrefs.ShowEntityIdentifier)
{
HandleUtil.DrawText(entity.Identifier, entity.Transform.position, entity.GizmoColor, offset, () => Selection.activeGameObject = entity.Transform.gameObject);
}
return(null);
}
void OnGUI()
{
if (guiMap == null)
{
guiMap = new GUIMap();
}
debugWindowRect = GUI.Window(12341234, debugWindowRect, (id) =>
{
var mapRect = new Rect(2, 18, 196, 180);
using (new GUILayout.AreaScope(mapRect))
{
guiMap.Center = GeoExtension.Instance.Location;
guiMap.Zoom = 17;
guiMap.DrawMap(new Rect(0, 0, 196, 180));
// Calculate the player pixel relative to the map
var playerMeters = MapzenGo.Helpers.GM.LatLonToMeters(GeoExtension.Instance.Location);
var playerPixel = MapzenGo.Helpers.GM.MetersToPixels(playerMeters, guiMap.Zoom);
var playerPixelRelative = playerPixel + guiMap.PATR;
// Do the point handling
var pointControl = GUIUtility.GetControlID("PlayerPosition".GetHashCode(), FocusType.Passive);
EditorGUI.BeginChangeCheck();
var newPlayerPixel = HandleUtil.HandlePointMovement(pointControl, playerPixelRelative.ToVector2(), 10,
(point, isOver, isActive) => HandleUtil.DrawPoint(point, 4, Color.cyan,
Color.black), MouseCursor.MoveArrow);
if (EditorGUI.EndChangeCheck())
{
// If changed, restore the point to the geochar
playerPixel = newPlayerPixel.ToVector2d() - guiMap.PATR;
playerMeters = MapzenGo.Helpers.GM.PixelsToMeters(playerPixel, guiMap.Zoom);
GeoExtension.Instance.Location = MapzenGo.Helpers.GM.MetersToLatLon(playerMeters);
}
guiMap.ProcessEvents(mapRect);
}
GUI.DragWindow();
},
"DebugWindow");
}
/**
* Handles a {@link MotionEvent#ACTION_DOWN} event.
*
* @param x the x-coordinate of the down action
* @param y the y-coordinate of the down action
*/
private void OnActionDown(float x, float y)
{
float left = EdgeManager.LEFT.coordinate;
float top = EdgeManager.TOP.coordinate;
float right = EdgeManager.RIGHT.coordinate;
float bottom = EdgeManager.BOTTOM.coordinate;
mPressedHandle = HandleUtil.getPressedHandle(x, y, left, top, right, bottom, mHandleRadius);
if (mPressedHandle == null)
{
return;
}
// Calculate the offset of the touch point from the precise location
// of the handle. Save these values in a member variable since we want
// to maintain this offset as we drag the handle.
mTouchOffset = HandleUtil.getOffset(mPressedHandle, x, y, left, top, right, bottom);
Invalidate();
}
// AUX FUNCTIONS
private void DrawScene(SceneDataControl scene)
{
var rect = AdaptToViewport(GetSceneRect(scene), space);
switch (Event.current.type)
{
case EventType.Repaint:
GUI.DrawTexture(rect, images[scene.getPreviewBackground()] ?? noBackground);
if (sceneList.index != -1 && Controller.Instance.SelectedChapterDataControl.getScenesList().getScenes()[sceneList.index] == scene)
{
HandleUtil.DrawPolyLine(rect.ToPoints().ToArray(), true, Color.red);
}
break;
}
EditorGUI.DropShadowLabel(new Rect(rect.position - new Vector2(20, 0), rect.size), scene.getId());
var prevHot = GUIUtility.hotControl;
EditorGUI.BeginChangeCheck();
rect = HandleUtil.HandleRectMovement(scene.GetHashCode(), rect);
if (EditorGUI.EndChangeCheck())
{
rect = RevertFromViewport(rect, space);
positions[scene.getId()] = rect.position;
// Update in the project data
var id = GetScenePropertyId(Controller.Instance.SelectedChapterDataControl, scene);
ProjectConfigData.setProperty(id + ".X", ((int)positions[scene.getId()].x).ToString());
ProjectConfigData.setProperty(id + ".Y", ((int)positions[scene.getId()].y).ToString());
}
if (GUIUtility.hotControl != prevHot)
{
sceneList.index = Controller.Instance.SelectedChapterDataControl.getScenesList().getScenes().IndexOf(scene);
if (Event.current.clickCount == 2)
{
OnSelectElement(scene);
}
}
}
private void DrawIconInventory(AdventureDataControl adventureData, Matrix4x4 matrix)
{
if (icon != null)
{
var scale = adventureData.getInventoryScale();
var pos = matrix.MultiplyPoint3x4(adventureData.getInventoryCoords());
var textureSize = matrix.MultiplyVector(new Vector2(icon.width, icon.height));
var inventorySize = textureSize * scale;
var inventoryCorner = pos - new Vector3(inventorySize.x / 2f, inventorySize.y);
var inventoryRect = new Rect(inventoryCorner, inventorySize);
GUI.DrawTexture(inventoryRect, icon);
EditorGUI.BeginChangeCheck();
var inventoryId = GUIUtility.GetControlID("SizeId".GetHashCode(), FocusType.Passive, inventoryRect);
var newRect = HandleUtil.HandleFixedRatioRect(inventoryId, inventoryRect, icon.width / (float)icon.height, 10f,
(polygon, over, active) => HandleUtil.DrawPolyLine(polygon, true, Color.red, over || active ? 4f : 2f),
(point, over, active) => HandleUtil.DrawPoint(point, 4.5f, Color.blue, over || active ? 2f : 1f, over || active ? Color.red : Color.black));
if (EditorGUI.EndChangeCheck())
{
var newScale = newRect.width / (float)textureSize.x;
var newCoords = InverseMultiplyPoint(matrix, newRect.center + new Vector2(0, newRect.height / 2f));
adventureData.setInventoryCoords(newCoords);
adventureData.setInventoryScale(newScale);
}
EditorGUI.BeginChangeCheck();
var inventoryMovementId = GUIUtility.GetControlID("MovementId".GetHashCode(), FocusType.Passive, inventoryRect);
newRect = HandleUtil.HandleRectMovement(inventoryMovementId, newRect);
if (EditorGUI.EndChangeCheck())
{
var newCoords = InverseMultiplyPoint(matrix, newRect.center + new Vector2(0, newRect.height / 2f));
adventureData.setInventoryCoords(newCoords);
}
}
}
static void OnSceneGUI(SceneView sceneView)
{
if (!EditorApplication.isPlaying || !showSelectors)
{
return;
}
Vector3 forward = Vector3.forward;
using (HandleUtil.With(Color.green)) {
foreach (Danmaku danmaku in Danmaku.All)
{
if (danmaku == null)
{
continue;
}
selectedDanmaku = danmaku;
Handles.matrix = Matrix4x4.TRS(danmaku.Position, Quaternion.Euler(0f, 0f, danmaku.Rotation), danmaku.Size * Vector3.one);
float colliderSize = danmaku.Prefab.ColliderSize.Max();
Handles.DrawWireDisc(danmaku.Prefab.ColliderOffset, forward, colliderSize);
Handles.DrawLine(Vector3.zero, colliderSize * Vector3.right);
}
}
}
// Private Methods /////////////////////////////////////////////////////////
private void Init(Context context)
{
try
{
DisplayMetrics displayMetrics = context.Resources.DisplayMetrics;
mHandleRadius = HandleUtil.getTargetRadius(context);
mSnapRadius = TypedValue.ApplyDimension(ComplexUnitType.Dip, SNAP_RADIUS_DP, displayMetrics);
mBorderPaint = PaintUtil.newBorderPaint(context);
mGuidelinePaint = PaintUtil.newGuidelinePaint();
mBackgroundPaint = PaintUtil.newBackgroundPaint(context);
mCornerPaint = PaintUtil.newCornerPaint(context);
// Sets the values for the corner sizes
mCornerOffset = TypedValue.ApplyDimension(ComplexUnitType.Dip, DEFAULT_CORNER_OFFSET_DP, displayMetrics);
mCornerExtension = TypedValue.ApplyDimension(ComplexUnitType.Dip, DEFAULT_CORNER_EXTENSION_DP, displayMetrics);
mCornerLength = TypedValue.ApplyDimension(ComplexUnitType.Dip, DEFAULT_CORNER_LENGTH_DP, displayMetrics);
// Sets guidelines to default until specified otherwise
mGuidelines = CropImageView.DEFAULT_GUIDELINES;
}
catch (Exception ex)
{
ex.ToString();
}
}
public static Rect HandleRect(int handleId, Rect rect, float maxPointDistance, Action <Vector2[], bool, bool> drawPolygon, Action <Vector2, bool, bool> drawPoint)
{
var points = rect.ToPoints();
int pointChanged = -1;
Vector2 oldPointValue = Vector2.zero;
int overActivePoint = -1;
bool over = rect.Contains(Event.current.mousePosition);
bool active = GUIUtility.hotControl == handleId;
for (int i = 0; i < points.Length; i++)
{
EditorGUI.BeginChangeCheck();
var aux = points[i];
var pointId = GUIUtility.GetControlID(handleId + i + 1, FocusType.Passive);
points[i] = HandleUtil.HandlePointMovement(pointId, points[i], 10f, (p, o, a) => {
if (o || a)
{
overActivePoint = i;
over = o;
active = a;
}
}, i % 2 == 0 ? MouseCursor.ResizeUpLeft : MouseCursor.ResizeUpRight);
if (EditorGUI.EndChangeCheck())
{
oldPointValue = aux;
points[i] = Event.current.mousePosition;
pointChanged = i;
}
}
if (Event.current.type == EventType.Repaint)
{
drawPolygon(points, overActivePoint == -1 && over, overActivePoint == -1 && active);
for (int i = 0; i < points.Length; i++)
{
drawPoint(points[i], overActivePoint == i && over, overActivePoint == i && active);
}
}
if (pointChanged != -1)
{
GUI.changed = true;
var diff = points[pointChanged] - oldPointValue;
// Fix the change
switch (pointChanged)
{
case 0: points[3].x += diff.x; points[1].y += diff.y; break;
case 1: points[2].x += diff.x; points[0].y += diff.y; break;
case 2: points[1].x += diff.x; points[3].y += diff.y; break;
case 3: points[0].x += diff.x; points[2].y += diff.y; break;
}
//First we calculate the new original screen rect
var original = points.ToRect();
rect = original;
}
return(rect);
}
public override void OnDrawingGizmosSelected()
{
Handles.BeginGUI();
Color lineColor = Color.red;
var rectangleArea = Target as RectangleArea;
var points = WorldToViewport(GetPoints(rectangleArea), SceneEditor.Current.Viewport, SceneEditor.Current.Size.x, SceneEditor.Current.Size.y);
switch (Event.current.type)
{
case EventType.Repaint: HandleUtil.DrawPolyLine(points, true, lineColor, 5f); break;
}
bool pointsChanged = false;
int index = 1;
int rectCornerChanged = -1;
foreach (var point in points)
{
var pointControlId = GUIUtility.GetControlID("Rectangle Point".GetHashCode(), FocusType.Passive, new Rect(point, new Vector2(10, 10)));
switch (Event.current.GetTypeForControl(pointControlId))
{
case EventType.Repaint: if (rectangleArea.isRectangular())
{
HandleUtil.DrawSquare(point, 10f, Color.yellow, Color.black);
}
else
{
HandleUtil.DrawPoint(point, 4.5f, Color.cyan, Color.black);
} break;
case EventType.MouseDown:
switch (ActionSelected)
{
case 0:
if (GUIUtility.hotControl == 0 && (point - Event.current.mousePosition).magnitude < 10)
{
GUIUtility.hotControl = pointControlId;
Event.current.Use();
}
break;
case 2:
if ((point - Event.current.mousePosition).magnitude < 10)
{
rectangleArea.deletePoint(rectangleArea.getPoints()[index - 1]);
Event.current.Use();
}
break;
}
break;
case EventType.MouseDrag:
if (GUIUtility.hotControl == pointControlId)
{
points[index - 1].x += Event.current.delta.x;
points[index - 1].y += Event.current.delta.y;
pointsChanged = true;
rectCornerChanged = index - 1;
Event.current.Use();
}
break;
case EventType.MouseUp:
if (GUIUtility.hotControl == pointControlId)
{
GUIUtility.hotControl = 0;
Event.current.Use();
}
break;
}
index++;
}
var rectangleControlID = GUIUtility.GetControlID("Rectangle".GetHashCode(), FocusType.Passive);
switch (Event.current.GetTypeForControl(rectangleControlID))
{
case EventType.MouseDown:
switch (ActionSelected)
{
case 0:
if (GUIUtility.hotControl == 0 && points.Inside(Event.current.mousePosition))
{
GUIUtility.hotControl = rectangleControlID;
Event.current.Use();
}
break;
case 1:
var point = Event.current.mousePosition; //ViewportToWorld(Event.current.mousePosition, SceneEditor.Current.Viewport, new Vector2(800f, 600f));
var pointlist = points.ToList();
pointlist.Insert(FindInsertPos(points, point), point);
points = pointlist.ToArray();
pointsChanged = true;
Event.current.Use();
break;
}
break;
case EventType.MouseDrag:
if (GUIUtility.hotControl == rectangleControlID)
{
points = points.Select(p => p + Event.current.delta).ToArray();
pointsChanged = true;
Event.current.Use();
}
break;
case EventType.MouseUp:
if (GUIUtility.hotControl == rectangleControlID)
{
GUIUtility.hotControl = 0;
Event.current.Use();
}
break;
case EventType.Repaint:
if (ActionSelected == 1)
{
var pos = FindInsertPos(points, Event.current.mousePosition);
Handles.DrawLine(points[(points.Length + pos - 1) % points.Length], Event.current.mousePosition);
Handles.DrawLine(Event.current.mousePosition, points[pos % points.Length]);
}
break;
}
if (pointsChanged)
{
this.Repaint();
// Update points in the selection
if (rectangleArea.isRectangular())
{
switch (rectCornerChanged)
{
case 0: points[3].x += Event.current.delta.x; points[1].y += Event.current.delta.y; break;
case 1: points[2].x += Event.current.delta.x; points[0].y += Event.current.delta.y; break;
case 2: points[1].x += Event.current.delta.x; points[3].y += Event.current.delta.y; break;
case 3: points[0].x += Event.current.delta.x; points[2].y += Event.current.delta.y; break;
}
var rect = ViewportToWorld(points, SceneEditor.Current.Viewport, SceneEditor.Current.Size.x, SceneEditor.Current.Size.y).ToRect();
rectangleArea.getRectangle().setValues(
Mathf.RoundToInt(rect.x),
Mathf.RoundToInt(rect.y),
Mathf.RoundToInt(rect.width),
Mathf.RoundToInt(rect.height));
}
else
{
rectangleArea.getPoints().Clear();
rectangleArea.getPoints().AddRange(ViewportToWorld(points, SceneEditor.Current.Viewport, SceneEditor.Current.Size.x, SceneEditor.Current.Size.y));
}
}
Handles.EndGUI();
}
public void DrawLabel()
{
if (LDtkPrefs.ShowLevelIdentifier)
{
//todo add color to this label perhaps
HandleUtil.DrawText(_identifier, _position, _bgColor, default, () => HandleUtil.SelectIfNotAlreadySelected(_obj));
public override void OnDrawingGizmos()
{
var trajectory = Target as TrajectoryDataControl;
if (trajectory == null)
{
return;
}
if (SceneEditor.Current.Disabled && pairing != null)
{
pairing = null;
}
if (previousTrajectoryDataControl != trajectory)
{
previousTrajectoryDataControl = trajectory;
pairing = null;
}
if (Event.current.type == EventType.MouseDown)
{
var selected = SceneEditor.Current.SelectedElement;
var node = selected as NodeDataControl;
var side = selected as SideDataControl;
var isNode = node != null && trajectory.getNodes().Contains(node);
var isSide = side != null && trajectory.getSides().Contains(side);
switch (Action)
{
// Moving
case 1:
if (SceneEditor.Current.SelectedElement == null)
{
var pos = (Event.current.mousePosition - SceneEditor.Current.Viewport.position);
pos.x = (pos.x / SceneEditor.Current.Viewport.size.x) * SceneEditor.Current.Size.x;
pos.y = (pos.y / SceneEditor.Current.Viewport.size.y) * SceneEditor.Current.Size.y;
trajectory.addNode(Mathf.RoundToInt(pos.x), Mathf.RoundToInt(pos.y));
}
break;
// Pariring
case 2:
if (isNode)
{
if (pairing == null)
{
pairing = node;
}
else
{
var duplicated = trajectory.getSides().Find(s => IsPairingStartOrEnd(s, node)) != null;
if (!duplicated)
{
trajectory.addSide(pairing, node);
}
pairing = null;
}
}
else
{
pairing = null;
}
break;
// Initial
case 3:
if (isNode)
{
trajectory.setInitialNode(node);
}
break;
// Deleting
case 4:
if ((isNode || isSide) && trajectory.deleteElement(selected, false))
{
SceneEditor.Current.SelectedElement = null;
}
break;
}
}
foreach (var node in trajectory.getNodes())
{
HandleUtil.DrawPoint(GetPivot(node), 10f, SceneEditor.GetColor(node.isInitial() ? Color.red : Color.blue), SceneEditor.GetColor(Color.black));
}
if (pairing != null)
{
HandleUtil.DrawPolyLine(new Vector2[] { GetPivot(pairing), Event.current.mousePosition }, false, SceneEditor.GetColor(Color.white), 3f);
}
}
private void DrawArea(Vector2[] points, Color lineColor, Color backgroundColor)
{
HandleUtil.DrawPolyLine(points, true, lineColor);
HandleUtil.DrawPolygon(points, backgroundColor);
}
private void DrawSelectedArea(Vector2[] points, Color lineColor, Color backgroundColor)
{
HandleUtil.DrawPolyLine(points, true, lineColor, 5f);
}
