/// <summary>
/// Prepare bricks groups to drag.
/// </summary>
/// <returns>The group to drag.</returns>
/// <param name="">.</param>
DragableBrick PrepereGroupToDrag(List <SelectableBrick> bricks)
{
//create parent object to handle dragging
GameObject parentObject = new GameObject();
var parentBrick = parentObject.AddComponent <AgaQTemporaryGroup>();
parentBrick.transform.SetParent(bricks[0].transform.parent);
//make parentObject parent to all selected bricks and tuen off its highlight
foreach (var brick in bricks)
{
brick.transform.SetParent(parentObject.transform);
brick.SetHighlighted(false);
brick.SetLayer(Preferences.instance.movingLayer);
if (brick is DragableBrick)
{
(brick as DragableBrick).isDragging = true;
}
}
groupBrick = true;
//prepare undo nodes
historyNodes = HistoryTool.PrepareTransformNodes(bricks);
return(parentBrick);
}
public void PrepareRemoveNodesTest()
{
var nodes = HistoryTool.PrepareRemoveNodes(new GameObject[] { gameObject });
Assert.IsNotNull(nodes);
Assert.Greater(nodes.Length, 0);
Assert.IsInstanceOf <HistoryNodeRemove>(nodes[0]);
}
public void PreparePositionNodesTest()
{
var nodes = HistoryTool.PrepareTransformNodes(new GameObject[] { gameObject });
Assert.IsNotNull(nodes);
Assert.Greater(nodes.Length, 0);
Assert.IsInstanceOf <HistoryNodeTransform>(nodes[0]);
}
public IEnumerator UndoRedoTest()
{
yield return(null);
gameObject = GameObject.CreatePrimitive(PrimitiveType.Cube);
HistoryManager.instance.Register(HistoryTool.PrepareAddNodes(new GameObject[] { gameObject }));
var mat = gameObject.GetComponent <Renderer> ().sharedMaterial;
mat.color = Color.white;
var nodes1 = HistoryTool.PrepareColorNodes(new GameObject[] { gameObject });
mat.color = Color.red;
HistoryManager.instance.Register(nodes1);
var oldPos = gameObject.transform.position;
var oldRot = gameObject.transform.rotation;
var nodes2 = HistoryTool.PrepareTransformNodes(new GameObject[] { gameObject });
gameObject.transform.position = new Vector3(10, 10, 10);
gameObject.transform.rotation = Quaternion.Euler(new Vector3(10, 10, 10));
HistoryManager.instance.Register(nodes2);
var nodes3 = HistoryTool.PrepareRemoveNodes(new GameObject[] { gameObject });
HistoryManager.instance.Register(nodes3);
HistoryManager.instance.Undo();
Asset.Equals(gameObject.activeSelf, true);
HistoryManager.instance.Undo();
Asset.Equals(gameObject.transform.position, oldPos);
Asset.Equals(gameObject.transform.rotation, oldRot);
HistoryManager.instance.Undo();
Asset.Equals(mat.color, Color.white);
HistoryManager.instance.Undo();
Asset.Equals(gameObject.activeSelf, false);
HistoryManager.instance.Redo();
Asset.Equals(gameObject.activeSelf, true);
HistoryManager.instance.Redo();
Asset.Equals(mat.color, Color.red);
HistoryManager.instance.Redo();
Asset.Equals(new Vector3(10, 10, 10), oldPos);
Asset.Equals(Quaternion.Euler(new Vector3(10, 10, 10)), oldRot);
HistoryManager.instance.Redo();
Asset.Equals(gameObject.activeSelf, false);
}
public IEnumerator RegisterTest()
{
yield return(null);
gameObject = GameObject.CreatePrimitive(PrimitiveType.Cube);
HistoryManager.instance.Register(HistoryTool.PrepareAddNodes(new GameObject[] { gameObject }));
gameObject = GameObject.CreatePrimitive(PrimitiveType.Cube);
HistoryManager.instance.Register(HistoryTool.PrepareColorNodes(new GameObject[] { gameObject }));
gameObject = GameObject.CreatePrimitive(PrimitiveType.Cube);
HistoryManager.instance.Register(HistoryTool.PrepareTransformNodes(new GameObject[] { gameObject }));
gameObject = GameObject.CreatePrimitive(PrimitiveType.Cube);
HistoryManager.instance.Register(HistoryTool.PrepareRemoveNodes(new GameObject[] { gameObject }));
}
/// <summary>
/// Find mesh point under cursor and higlight it
/// </summary>
void HighlightPoint()
{
var ray = UnityEngine.Camera.main.ScreenPointToRay(Input.mousePosition);
RaycastHit hit;
if (Physics.SphereCast(ray, 0.1f, out hit, 1000, 255, QueryTriggerInteraction.Collide))
{
var obj = hit.collider.gameObject;
var meshFilter = obj.GetComponentInChildren <MeshFilter>();
if (meshFilter != null)
{
var meshVertises = meshFilter.gameObject.GetComponent <Vertices>();
if (meshVertises == null)
{
meshVertises = meshFilter.gameObject.AddComponent <Vertices>();
}
Vector2 currentScreenPoint;
Vector3 currentWorldPoint;
if (MeshPointsTool.GetVisiblePointUnderCursor(
meshVertises.uniqueVertices, meshFilter.gameObject.transform,
UnityEngine.Camera.main,
Input.mousePosition,
pointSelectAccuracy,
out currentScreenPoint,
out currentWorldPoint))
{
MeasureToolVisualizer.instance.HighlighVertex(currentScreenPoint);
if (Input.GetMouseButton(0))
{
isPointJoining = true;
pointJoinBrick = hit.collider;
pointJointDragOffset = currentWorldPoint - obj.transform.position;
//prepare undo nodes
historyNodes = HistoryTool.PrepareTransformNodes(obj);
}
}
else
{
MeasureToolVisualizer.instance.ResetHighlight();
}
}
}
}
void Join()
{
if (amountOfPoints != 2)
{
return;
}
//prepare history
historyNodes = HistoryTool.PrepareTransformNodes(objects[0]);
var offset = points[0] - objects[0].transform.position;
objects[0].transform.position = points[1] - offset;
amountOfPoints = 0;
MeasureToolVisualizer.instance.ClearVertexes();
//register hostory
HistoryManager.instance.Register(historyNodes);
}
/// <summary>
/// Prepare brick or all selected bric to be dragged.
/// </summary>
/// <param name="brick">Brick that is dragged</param>
void PrepareBrickToDrag(DragableBrick brick)
{
if (SelectionManager.instance.SelectedAmount <= 1)
{
dragableBrick = brick;
dragableBrick.SetHighlighted(false);
dragableBrick.SetLayer(Preferences.instance.movingLayer);
groupBrick = false;
//prepare undo nodes
historyNodes = HistoryTool.PrepareTransformNodes(brick.gameObject);
}
else
{
var selectedBricks = SelectionManager.instance.GetSelected();
dragableBrick = PrepereGroupToDrag(selectedBricks);
}
dragableBrick.isDragging = true;
AddRigidBody(dragableBrick);
}
public virtual void OnBeginDrag(PointerEventData eventData)
{
startDragPos = Input.mousePosition;
selected = SelectionManager.instance.GetSelected();
historyNodes = HistoryTool.PrepareTransformNodes(selected);
}
/// <summary>
/// Tunrn off (set inactive) selected bricks
/// and register it HistoryManager.
/// </summary>
public void DeleteSelected()
{
var currSelObject = EventSystem.current.currentSelectedGameObject;
if (currSelObject != null)
{
var input = currSelObject.GetComponent <InputField>();
if (input != null)
{
return;
}
}
var selectedBricks = SelectionManager.instance.GetSelected();
SelectionManager.instance.Clear();
if (selectedBricks.Count > 0 || isDragging)
{
DragableBrick dragObject = null;
//if dragging is pending break it
if (isDragging)
{
dragObject = dragableBrick;
OnCancel();
}
//prepare state for undo
HistoryNodeRemove[] historyNodes = selectedBricks.Count > 0 ?
HistoryTool.PrepareRemoveNodes(selectedBricks) :
HistoryTool.PrepareRemoveNodes(dragObject.gameObject);
//remove selected bricks
//(realy don't delete them, just set inactive to be able to do undo action)
if (selectedBricks.Count > 0)
{
foreach (var brick in selectedBricks)
{
if (brick is AgaQBrick)
{
(brick as AgaQBrick).ClearJoints();
}
brick.gameObject.SetActive(false);
}
}
else
{
if (dragObject is AgaQBrick)
{
(dragObject as AgaQBrick).ClearJoints();
}
dragObject.gameObject.SetActive(false);
}
//register state in history
HistoryManager.instance.Register(historyNodes);
if (OnModelChange != null)
{
OnModelChange();
}
}
}
