public override void OnTriggerDown()
{
if (m_PointerController.collidingObject != null)
{
m_PointerController.IncreaseSizeOfPointer();
if (m_PointerController.collidingObject.GetComponent <ShapeType>().m_ShapeType == ShapeTypeEnum.Area)
{
GameObject area = m_PointerController.collidingObject.transform.parent.gameObject;
// TODO: change back
m_DrawableShape.m_AreaLocalRotation = area.transform.localRotation;
m_DrawableShape.m_AreaLocalScale = area.transform.localScale;
m_DrawableShape.m_AreaForwardDir = area.transform.forward;
m_DrawableShape.StartDrawing(area.transform.position);
}
else if (m_PointerController.collidingObject.GetComponent <ShapeType>().m_ShapeType == ShapeTypeEnum.Polygon)
{
// start extruding mesh
GameObject polygon = m_PointerController.collidingObject;
// drawing = Tool.Volume;
initialPosition = polygon.transform.position;
m_MeshCreatorController = polygon.GetComponent <MeshCreatorController>();
}
OnTriggerHold();
}
}
void Start()
{
m_Parent = transform.parent.gameObject;
m_RectTransform = gameObject.GetComponent <RectTransform>();
m_BaseScale = m_RectTransform.localScale;
m_BaseWidthHeight = m_RectTransform.sizeDelta;
UpdateSpecific = NOP;
if (m_Parent.name.Contains("Clone"))
{
if (m_Parent.name.Contains("Line"))
{
m_ScaleDim = "y";
m_FollowCamera = true;
scaleMultiplier = .5f;
m_OriginalImage = transform.Find("Image").gameObject;
UpdateSpecific = SpecificUpdate;
}
else if (m_Parent.name.Contains("Volume"))
{
m_VolumeForwardController = m_Parent.GetComponent <VolumeForwardController>();
m_ScaleDim = "x";
m_OriginalImage = transform.Find("Image (Horz)").gameObject; // TODO: rename
m_CrossAxisOriginalImage = transform.Find("Image (Vert)").gameObject;
m_Volume = true;
AdjustCrossAxisTicks();
SetInitial();
UpdateSpecific = SpecificUpdate;
}
else if (m_Parent.name.Contains("Mesh"))
{
m_MeshCreator = m_Parent.GetComponent <MeshCreatorController>();
m_PointerController = m_Pointer.GetComponent <PointerController>();
transform.localScale = Vector3.zero;
m_ScaleDim = "";
m_OriginalImage = transform.Find("Image (Horz)").gameObject;
m_CrossAxisOriginalImage = transform.Find("Image (Vert)").gameObject;
CreateGridForMesh();
UpdateSpecific = MeshUpdate;
}
}
else if (m_Parent.transform.parent.gameObject.name.Contains("Clone") && m_Parent.transform.parent.gameObject.name.Contains("Area"))
{
m_ScaleDim = "x";
m_Parent = m_Parent.transform.parent.gameObject;
m_OriginalImage = transform.Find("Image (Horz)").gameObject; // TODO: rename
m_CrossAxisOriginalImage = transform.Find("Image (Vert)").gameObject;
UpdateSpecific = SpecificUpdate;
AdjustCrossAxisTicks();
}
UpdateGridScale();
GlobalGridScale.AddScaleListener(UpdateGridScale);
}
void Start()
{
m_Parent = transform.parent.gameObject;
m_RectTransform = gameObject.GetComponent <RectTransform>();
m_BaseScale = m_RectTransform.localScale;
m_BaseWidthHeight = m_RectTransform.sizeDelta;
m_MeshCreator = m_Parent.GetComponent <MeshCreatorController>();
m_PointerController = m_Pointer.GetComponent <PointerController>();
transform.localScale = Vector3.zero;
m_OriginalImage = transform.Find("Image (Horz)").gameObject;
m_CrossAxisOriginalImage = transform.Find("Image (Vert)").gameObject;
UpdateGridScale();
GlobalGridScale.AddScaleListener(UpdateGridScale);
}
public void MouseUp()
{
// finish drawing
if (drawing == Tool.None && m_CurrentTool != Tool.Mesh)
{
return;
}
if (m_CurrentTool != Tool.Mesh && (m_CurrentTool != Tool.Volume || m_MeshForVolume == null))
{
drawing = Tool.None;
initialPosition = Vector3.zero;
currentPosition = Vector3.zero;
m_PointerController.DecreaseSizeOfPointer();
}
// drag out
switch (m_CurrentTool)
{
case Tool.Line:
// TODO: change back
m_DrawableLine.StopDrawing(m_SnapToGrid);
break;
case Tool.Area:
// TODO: change back
m_DrawableArea.StopDrawing(m_SnapToGrid);
Destroy(m_LineForArea);
break;
case Tool.Volume:
// if (m_VolumeCopy != null)
// {
if (m_MeshForVolume == null)
{
// TODO: change back
m_DrawableVolume.StopDrawing(m_SnapToGrid);
Destroy(m_AreaForVolume);
}
else
{
m_PointerController.DecreaseSizeOfPointer();
m_MeshForVolume.GetComponent <LightUpOnCollision>().SetEnabled(false);
if (m_MeshCreatorController.m_SnapToGrid)
{
DrawVolume(true);
}
m_MeshForVolume = null;
m_MeshCreatorController.FinishMesh();
m_PointerController.collidingObject = null;
currentPosition = Vector3.zero;
initialPosition = Vector3.zero;
drawing = Tool.None;
}
break;
case Tool.Sphere:
m_DrawableSphere.StopDrawing(m_SnapToGrid);
break;
case Tool.Mesh:
if (drawing != Tool.Mesh) // start drawing mesh
{
m_PointerController.IncreaseSizeOfPointer();
drawing = Tool.Mesh;
initialPosition = m_Pointer.transform.position;
m_MeshCopy = UnityEngine.Object.Instantiate(m_Mesh, initialPosition, Quaternion.identity, m_Parent.transform);
m_MeshCreatorController = m_MeshCopy.GetComponent <MeshCreatorController>();
m_LineCopy = m_MeshCreatorController.AddLine(initialPosition);
DrawMesh();
}
else
{
// want to end current line and start new line unless we are back at the starting position
// if m_MeshCreatorController.m_SnapToGrid is true, then the line should snap to a whole number plus the initial pos
if (m_MeshCreatorController.m_SnapToGrid)
{
// last currentPosition should snap to the first initial position plus or minus a whole number
DrawMesh(true);
initialPosition = currentPosition;
}
else
{
initialPosition = m_Pointer.transform.position;
}
GameObject originalLine = m_MeshCreatorController.GetLine(0);
if (originalLine.transform.Find("Sphere").gameObject.GetComponent <LightUpOnCollision>().collision)
{
m_PointerController.DecreaseSizeOfPointer();
// end mesh
m_LineCopy = null;
drawing = Tool.None;
m_MeshCreatorController.CreateMesh();
m_MeshCreatorController.DeleteLines();
m_PointerController.UnrestrictPointerToInsideRays();
m_PointerController.isCentered = true;
}
else
{
// new line
m_LineCopy = m_MeshCreatorController.AddLine(initialPosition);
DrawMesh();
}
}
break;
case Tool.None:
default:
break;
}
}
public void Clicked()
{
// initialize a move
switch (m_CurrentTool)
{
case Tool.Line:
m_PointerController.IncreaseSizeOfPointer();
// draw point ?
drawing = Tool.Line;
// TODO:
m_DrawableLine.StartDrawing(m_Pointer.transform.position);
break;
case Tool.Area:
if (m_PointerController.collidingObject != null && m_PointerController.collidingObject.name.Contains("Line"))
{
m_PointerController.IncreaseSizeOfPointer();
m_LineForArea = m_PointerController.collidingObject;
drawing = Tool.Area;
// TODO: change back
m_DrawableArea.m_UpVec = m_LineForArea.transform.up;
m_DrawableArea.m_YScale = m_LineForArea.transform.localScale.y;
m_DrawableArea.StartDrawing(m_LineForArea.transform.position);
Dragged(); // TODO: do we need? if so add to post start
}
break;
case Tool.Volume:
if (m_PointerController.collidingObject != null)
{
m_PointerController.IncreaseSizeOfPointer();
if (m_PointerController.collidingObject.transform.parent.gameObject.name.Contains("Area"))
{
m_AreaForVolume = m_PointerController.collidingObject.transform.parent.gameObject;
drawing = Tool.Volume;
// TODO: change back
m_DrawableVolume.m_AreaLocalRotation = m_AreaForVolume.transform.localRotation;
m_DrawableVolume.m_AreaLocalScale = m_AreaForVolume.transform.localScale;
m_DrawableVolume.m_AreaForwardDir = m_AreaForVolume.transform.forward;
m_DrawableVolume.StartDrawing(m_AreaForVolume.transform.position);
}
else if (m_PointerController.collidingObject.transform.name.Contains("Mesh"))
{
// start extruding mesh
m_MeshForVolume = m_PointerController.collidingObject;
drawing = Tool.Volume;
initialPosition = m_MeshForVolume.transform.position;
m_MeshCreatorController = m_MeshForVolume.GetComponent <MeshCreatorController>();
}
Dragged();
}
break;
case Tool.Sphere:
drawing = Tool.Sphere;
m_DrawableSphere.StartDrawing(m_Pointer.transform.position);
break;
case Tool.Mesh:
// TODO
// maybe create a plane that we draw on with a grid (could make the grid lines variable in spacing)
break;
case Tool.None:
default:
drawing = Tool.None;
break;
}
}