public override void Clone(ScalableObject toClone, Vector2 positioner)
{
PathObject pathObjectToClone = toClone as PathObject;
Init();
BezierCurve.Clear();
BezierCurve = pathObjectToClone.BezierCurve.ConvertAll(segment => new BezierSegment(this, segment));
IsClosed = pathObjectToClone.IsClosed;
OrganizeAllNeighbors();
HandOverPointsToRenderer();
_pathRenderer.UpdateRenderer();
_pathSelectionRenderer.UpdateRenderer();
Anchors(GetAllPoints());
PositionAtCenter(positioner);
SortPoints(GetAllPoints());
UpdateInlineAreaRenderer();
IColorable selectable = toClone as IColorable;
UpdateFillRendererColor(selectable.GetInlineAreaColor());
UpdateLineRendererColor(selectable.GetPathColor());
UpdateLineRendererThickness(selectable.GetPathThickness());
Hover(false);
ShowBoundingRect(false);
selected = false;
SegmentCount = BezierCurve.Count;
showPointsHandles = false;
}
public void UpdateSelectedPathObject(ScalableObject scalableObject)
{
if (scalableObject != null)
{
OnSelectedObjectChanged(scalableObject);
}
}
private void scaleParticleSystem()
{
ParticleSystem system = ScalableObject.GetComponent <ParticleSystem>();
var sz = system.sizeOverLifetime;
sz.enabled = true;
ParticleSystem.MinMaxCurve curve = new ParticleSystem.MinMaxCurve();
curve.mode = ParticleSystemCurveMode.TwoConstants;
if (sz.size.constantMax + CustomIncrementAmount < Max)
{
curve.constantMin = sz.size.constant + CustomIncrementAmount;
curve.constantMax = sz.size.constantMax + CustomIncrementAmount;
curve.constant = sz.size.constantMin + CustomIncrementAmount;
}
else if (sz.size.constantMin + CustomIncrementAmount > Min)
{
curve.constantMin = sz.size.constant + CustomIncrementAmount;
curve.constantMax = sz.size.constantMax + CustomIncrementAmount;
curve.constant = sz.size.constantMin + CustomIncrementAmount;
}
sz.size = curve;
}
void UpdatePathObject(ScalableObject current)
{
_currentHoveredObject = current;
_currentPathObject = current as PathObject;
if (_currentPathObject != null)
{
_segments = _currentPathObject.BezierCurve;
}
}
public void DeleteObject(ScalableObject scalableObject)
{
if (scalableObject == null)
{
return;
}
GameObject.Destroy(scalableObject.gameObject);
RemoveObject(scalableObject);
}
public void UpdateHoveredPathObject(ScalableObject scalableObject)
{
if (_currentUpdater != null)
{
_currentUpdater.SetLastSelected(scalableObject);
}
OnHoveredObjectChanged(scalableObject);
ChangeState();
}
public void Unselect()
{
if (_lastSelectedObject == null)
{
return;
}
_lastSelectedObject.Unselect();
_lastSelectedObject.Hover(false);
_lastSelectedObject = null;
_isPathObjectUpdateAllowed = true;
}
//////////////////////////// ObjectListUpdater ///////////////////////////
public ScalableObject GetAreaObject()
{
ScalableObject drawArea = _drawAreaObjectsUpdater.GetFirstSelectedObject();
if (drawArea == null)
{
drawArea = _drawAreaObjectsUpdater.NewObject(true);
}
return(drawArea);
}
public bool CheckCondition(ScalableObject pathObject)
{
if (checkBaseCondition != null)
{
return(checkBaseCondition.Invoke(pathObject));
}
else
{
return(checkCondition.Invoke(pathObject as PathObject));
}
}
public void Unsuscribe(ScalableObject scalable)
{
if (scalable == null)
{
return;
}
scalable.Selected = false;
scalable.ShowBoundingRect(false);
_currentList.Remove(scalable);
_currentColorables.Remove(scalable as IColorable);
}
public void Suscribe(ScalableObject scalable)
{
scalable.Selected = true;
scalable.ShowBoundingRect(true);
_currentList.Add(scalable);
IColorable colorable = scalable as IColorable;
_currentColorables.Add(colorable);
if (_currentColorables.Count == 1)
{
_editorMenu.UpdateMenu(colorable);
}
}
private void OnTriggerEnter(Collider other)
{
if (!hitObj)
{
if (other.CompareTag("Scalable"))
{
hitObj = true;
ScalingObj = other.gameObject.transform;
scaleObj = ScalingObj.GetComponent <ScalableObject>();
art.SetActive(false);
StartCoroutine(Scale());
}
}
}
public ScalableObject NewObject(bool objectUpdateAfter)
{
GameObject newPathObject = GameObject.Instantiate(_prefab, _prefabParent);
_lastSelectedObject = newPathObject.GetComponent <ScalableObject>();
_lastSelectedObject.Init();
AddObject(_lastSelectedObject);
Program.Instance.UpdateHoveredPathObject(_lastSelectedObject);
_isPathObjectUpdateAllowed = objectUpdateAfter;
SortObjectList();
return(_lastSelectedObject);
}
public bool OtherObjectHovered(out ScalableObject hoveredObject, out bool overObject)
{
if (!_isPathObjectUpdateAllowed && _lastSelectedObject != null)
{
overObject = false;
CheckConditions(out overObject);
_lastSelectedObject.Hover(overObject, true);
hoveredObject = _lastSelectedObject;
return(false);
}
bool otherObjectHovered;
if (CheckCondition(out hoveredObject, out otherObjectHovered))
{
overObject = true;
if (otherObjectHovered)
{
if (_lastHoveredObject != null && _lastHoveredObject.Hovered)
{
_lastHoveredObject.Hover(false);
}
_lastHoveredObject = hoveredObject;
hoveredObject = _lastHoveredObject;
return(true);
}
if (!_lastHoveredObject.Hovered)
{
_lastHoveredObject.Hover(true, true);
}
hoveredObject = _lastHoveredObject;
return(otherObjectHovered);
}
hoveredObject = null;
overObject = false;
if (_lastHoveredObject != null && _lastHoveredObject.Hovered)
{
_lastHoveredObject.Hover(false);
}
return(false);
}
public override bool CheckCondition(out ScalableObject hoveredObject, out bool otherObjectHovered)
{
hoveredObject = _lastHoveredObject;
foreach (PathObject pathObject in objectList)
{
foreach (Func <PathObject, bool> func in _onHoverUpdate)
{
if (func.Invoke(pathObject))
{
hoveredObject = pathObject;
otherObjectHovered = pathObject != _lastHoveredObject;
return(true);
}
}
}
otherObjectHovered = false;
return(false);
}
public void HoverPathObject(bool isHover)
{
if (_lastHoveredObject != null && _lastHoveredObject.Hovered)
{
_lastHoveredObject.Hover(false);
}
;
if (isHover)
{
if (_currentHoveredObject)
{
_currentHoveredObject.Hover(true, true);
}
_lastHoveredObject = _currentHoveredObject;
}
}
public IEnumerator TakeScreenShot(OpenFileName ofn)
{
yield return(new WaitForEndOfFrame()); // it must be a coroutine
yield return(new WaitForEndOfFrame());
Program.Instance.HideAllBoundingBoxes();
Program.Instance.AllowPathObjectUpdate();
ScalableObject drawArea = Program.Instance.GetAreaObject();
Vector2 minPosition = drawArea.DownLeftAnchor;
minPosition = canvas.TransformPoint(minPosition);
Vector3 minPosition3 = new Vector3(minPosition.x, minPosition.y, corners[0].z);
minPosition = _camera.WorldToScreenPoint(minPosition3);
Vector2 maxPosition = drawArea.UpRightAnchor;
maxPosition = canvas.TransformPoint(maxPosition);
Vector3 maxPosition3 = new Vector3(maxPosition.x, maxPosition.y, corners[2].z);
maxPosition = _camera.WorldToScreenPoint(maxPosition3);
Vector2 size = maxPosition - minPosition;
Texture2D snapShot = new Texture2D((int)size.x - 2, (int)size.y, TextureFormat.ARGB32, false);
RenderTexture snapShotRT = new RenderTexture(Screen.width, Screen.height, 24, RenderTextureFormat.ARGB32);
RenderTexture.active = snapShotRT;
_camera.targetTexture = snapShotRT;
_camera.Render();
snapShot.ReadPixels(new Rect((int)minPosition.x + 2, Screen.height - (int)maxPosition.y, Screen.width, Screen.height), 0, 0);
snapShot.Apply();
RenderTexture.active = null;
_camera.targetTexture = null;
var bytes = snapShot.EncodeToPNG();
Destroy(snapShot);
File.WriteAllBytes(ofn.file, bytes);
}
public void DuplicateObject()
{
bool downLeftset = false;
Vector2 downLeft = Vector2.zero;
Vector2 oldDownLeft = Vector2.zero;
Vector2 translate = Vector2.zero;
for (int i = ObjectList.Count - 1; i >= 0; i--)
{
ScalableObject currentObject = ObjectList[i];
if (currentObject.Selected)
{
if (!downLeftset)
{
oldDownLeft = currentObject.DownLeftAnchor;
downLeft = new Vector2(currentObject.Width() / 2f, currentObject.Height() / 2f) - Vector2.zero;
translate = downLeft;
downLeftset = true;
}
else
{
translate = downLeft;
translate += oldDownLeft;
translate -= currentObject.DownLeftAnchor;
}
GameObject newPathObject = GameObject.Instantiate(currentObject.gameObject, _prefabParent);
ScalableObject dublicate = newPathObject.GetComponent <ScalableObject>();
dublicate.Clone(currentObject, translate);
newObjects.Add(dublicate);
}
}
foreach (var item in newObjects)
{
ObjectList.Add(item);
}
newObjects.Clear();
SortObjectList();
}
public override void Clone(ScalableObject toClone, Vector2 positioner)
{
base.Init();
_selectionRenderer = _drawAreaSelectionRenderer;
AreaObject areaObjectToClone = toClone as AreaObject;
_downLeftAnchor = areaObjectToClone.DownLeftAnchor;
_upRightAnchor = areaObjectToClone.UpRightAnchor;
_drawAreaRenderer.UpdateRenderer(DownLeftAnchor, UpRightAnchor, true);
_drawAreaSelectionRenderer.UpdateRenderer(DownLeftAnchor, UpRightAnchor, false);
_borderRenderer.UpdateRenderer(DownLeftAnchor, UpRightAnchor, false);
SetPoints();
BoundingBoxRenderer.UpdateRectangle();
PositionAtCenter(positioner);
Hover(false);
ShowBoundingRect(false);
selected = false;
}
public void Select()
{
Vector2 mousePosition = _program.GetMouseCanvasPosition();
Renderer.UpdateRectangle(StartSelectionPoint, mousePosition);
ItemSelected = 0;
_currentSelectionMode = SelectionMode.MultipleObject;
ScalableObject selected = null;
List <ScalableObject> objectList = _program.CurrentScalableList();
UnsuscribeAll();
for (int i = 0; i < objectList.Count; i++)
{
ScalableObject segment = objectList[i];
Vector2 downLeftAnchor = segment.DownLeftAnchor;
Vector2 upRightAnchor = segment.UpRightAnchor;
if (mousePosition.x < downLeftAnchor.x && StartSelectionPoint.x < downLeftAnchor.x ||
mousePosition.x > upRightAnchor.x && StartSelectionPoint.x > upRightAnchor.x ||
mousePosition.y < downLeftAnchor.y && StartSelectionPoint.y < downLeftAnchor.y ||
mousePosition.y > upRightAnchor.y && StartSelectionPoint.y > upRightAnchor.y)
{
continue;
}
Suscribe(segment);
selected = segment;
ItemSelected++;
}
if (ItemSelected == 1)
{
_currentSelectionMode = SelectionMode.SingleObject;
_currentHoveredObject = selected;
}
}
public virtual void Clone(ScalableObject toClone, Vector2 positioner)
{
}
public void Delete(ScalableObject scalableObject)
{
_currentUpdater.DeleteObject(scalableObject);
}
public void RemoveObject(ScalableObject scaleableObject)
{
ObjectList.Remove(scaleableObject);
}
public void AddObject(ScalableObject scaleableObject)
{
ObjectList.Add(scaleableObject);
}
public virtual void SetLastSelected(ScalableObject scalableObject)
{
_lastSelectedObject = scalableObject;
}
public override void SetLastSelected(ScalableObject scalableObject)
{
base.SetLastSelected(scalableObject);
_lastSelected = scalableObject as PathObject;
}
void UpdateSelectedPathObject(ScalableObject current)
{
_currentSelectedObject = current;
_currentSelectedPathObject = current as PathObject;
}
public virtual bool CheckCondition(out ScalableObject otherObject, out bool newObject)
{
otherObject = null;
newObject = false;
return(false);
}
