bool HandleDrag(Vector3 from, Vector3 to, Vector3 mouseOffset, int btn)
{
if (dragging && btn == EditWindowClickDetection.BTN_PRIMARY)
{
//TODO: project the dragged object arrow to viewport and then figure out movement from offset
mouseOffset /= 100;
Vector3 worldOffset = new Vector3();
SnapAxis snapAxis = SnapAxis.None;
if (dragObject == moveX)
{
worldOffset.x += mouseOffset.x;
snapAxis = SnapAxis.X;
}
else if (dragObject == moveY)
{
worldOffset.y += mouseOffset.y;
snapAxis = SnapAxis.Y;
}
else if (dragObject == moveZ)
{
worldOffset.z += mouseOffset.x;
snapAxis = SnapAxis.Z;
}
virtualPosition += worldOffset;
Vector3 pos = LevelEditor.SnapManager.Snap(virtualPosition, snapAxis);
target.position = pos;
return(true);
}
return(false);
}
public Vector3 Snap(Vector3 worldPos, SnapAxis snapAxis = SnapAxis.All)
{
Vector3 snapped = worldPos;
switch (SnapMode)
{
case SnapMode.Grid:
snapped = snapGrid.Snap(worldPos);
break;
case SnapMode.Vertex:
snapped = SnapVertex(worldPos);
snapAxis = SnapAxis.All; //vertices are 3d positions so it doesnt make sense to snap to only one axis
break;
}
if (snapAxis.HasFlag(SnapAxis.X))
{
worldPos.x = snapped.x;
}
if (snapAxis.HasFlag(SnapAxis.Y))
{
worldPos.y = snapped.y;
}
if (snapAxis.HasFlag(SnapAxis.Z))
{
worldPos.z = snapped.z;
}
return(worldPos);
}
void SetFocusedActorPositionWithChecks(Vector3 vec, SnapAxis axis)
{
GetFocusActor().SetEnablePhysics(false);
GetFocusActor().SweepTo(
CheckDistanceAndLimits(moveToolSettings.ShouldSnap() ? SnapOnAxis(axis, vec) : vec)
);
}
public static Vector3 Snap(Vector3 val, Vector3 snap, SnapAxis axis = SnapAxis.All)
{
return(new Vector3(
(axis & SnapAxis.X) == SnapAxis.X ? Snap(val.x, snap.x) : val.x,
(axis & SnapAxis.Y) == SnapAxis.Y ? Snap(val.y, snap.y) : val.y,
(axis & SnapAxis.Z) == SnapAxis.Z ? Snap(val.z, snap.z) : val.z
));
}
internal static void SnapSelectionToGrid(SnapAxis axis = SnapAxis.All)
{
var selections = Selection.transforms;
if (selections != null && selections.Length > 0)
{
Undo.RecordObjects(selections, L10n.Tr("Snap to Grid"));
Handles.SnapToGrid(selections, axis);
}
}
Vector3 SnapOnAxis(SnapAxis axis, Vector3 vec)
{
if (axis == SnapAxis.Horizontal)
{
return(TerrainManager.SnapHorizontalPosition(vec));
}
else if (axis == SnapAxis.Vertical)
{
return(TerrainManager.SnapVerticalPosition(vec));
}
else
{
return(TerrainManager.SnapPosition(vec));
}
}
public SnapAxisFilter(SnapAxis axis)
{
m_Mask = 0x0;
if ((axis & SnapAxis.X) == SnapAxis.X)
{
m_Mask |= X;
}
if ((axis & SnapAxis.Y) == SnapAxis.Y)
{
m_Mask |= Y;
}
if ((axis & SnapAxis.Z) == SnapAxis.Z)
{
m_Mask |= Z;
}
}
public SnapAxisFilter(Vector3 v)
{
m_Mask = 0x0;
var epsilon = 0.000001f;
if (Mathf.Abs(v.x) > epsilon)
{
m_Mask |= X;
}
if (Mathf.Abs(v.y) > epsilon)
{
m_Mask |= Y;
}
if (Mathf.Abs(v.z) > epsilon)
{
m_Mask |= Z;
}
}
public void AutoCalculateValues()
{
if (RenderSet.MeshFilters.Length > 0)
{
Bounds Bound = RenderSet.CombinedMeshFilterBounds;
BoundSize = Bound.size;
BoundsOffset = Bound.center;
// max scale
Vector3 MaxAxis = BoundSize.SingleAxis(true, false);
if (MaxAxis.x != 0)
{
GridMaxSize = SnapAxis.X;
}
else if (MaxAxis.y != 0)
{
GridMaxSize = SnapAxis.Y;
}
else
{
GridMaxSize = SnapAxis.Z;
}
// real max
RealMaxSize = GridMaxSize; // set same as max
// min
Vector3 MinAxis = BoundSize.SingleAxis(false);
if (MinAxis.x != 0)
{
GridMinSize = SnapAxis.X;
}
else if (MinAxis.y != 0)
{
GridMinSize = SnapAxis.Y;
}
else
{
GridMinSize = SnapAxis.Z;
}
}
}
protected void Snap(SnapAxis axis)
{
Vector2 cellPos = grid.GetCellPosAt(transform.position);
Vector2 newPos = transform.position;
switch (axis)
{
case SnapAxis.X:
newPos = new Vector2(cellPos.x, transform.position.y);
break;
case SnapAxis.Y:
newPos = new Vector2(transform.position.x, cellPos.y);
break;
case SnapAxis.Both:
newPos = cellPos;
break;
}
transform.position = newPos;
}
public SnapAxisFilter(SnapAxis axis)
{
this.m_Mask = SnapAxis.None;
bool flag = (axis & SnapAxis.X) == SnapAxis.X;
if (flag)
{
this.m_Mask |= SnapAxis.X;
}
bool flag2 = (axis & SnapAxis.Y) == SnapAxis.Y;
if (flag2)
{
this.m_Mask |= SnapAxis.Y;
}
bool flag3 = (axis & SnapAxis.Z) == SnapAxis.Z;
if (flag3)
{
this.m_Mask |= SnapAxis.Z;
}
}
public float this[int i]
{
get
{
bool flag = i < 0 || i > 2;
if (flag)
{
throw new IndexOutOfRangeException();
}
return((float)(SnapAxis.X & this.m_Mask >> (i & 31)) * 1f);
}
set
{
bool flag = i < 0 || i > 2;
if (flag)
{
throw new IndexOutOfRangeException();
}
this.m_Mask &= (SnapAxis)(~(SnapAxis)(1 << i));
this.m_Mask |= (SnapAxis)(((value > 0f) ? 1 : 0) << (i & 31));
}
}
public SnapAxisFilter(Vector3 v)
{
this.m_Mask = SnapAxis.None;
float num = 1E-06f;
bool flag = Mathf.Abs(v.x) > num;
if (flag)
{
this.m_Mask |= SnapAxis.X;
}
bool flag2 = Mathf.Abs(v.y) > num;
if (flag2)
{
this.m_Mask |= SnapAxis.Y;
}
bool flag3 = Mathf.Abs(v.z) > num;
if (flag3)
{
this.m_Mask |= SnapAxis.Z;
}
}
public float this[int i]
{
get
{
if (i < 0 || i > 2)
{
throw new IndexOutOfRangeException();
}
return((1 & ((int)m_Mask >> i)) * 1f);
}
set
{
if (i < 0 || i > 2)
{
throw new IndexOutOfRangeException();
}
m_Mask &= (SnapAxis) ~(1 << i);
m_Mask |= (SnapAxis)((value > 0f ? 1 : 0) << i);
}
}
void MoveFocusedActorOnAxis(GizmoAxis axis)
{
Ray ray = editMain.GetCursorRay();
Ray axisRay = zAxisRay;
Vector3 offset = zAxisRayOffset;
SnapAxis snapAxis = SnapAxis.Horizontal;
if (axis == GizmoAxis.Y)
{
snapAxis = SnapAxis.Vertical;
axisRay = yAxisRay;
offset = yAxisRayOffset;
}
else if (axis == GizmoAxis.X)
{
axisRay = xAxisRay;
offset = xAxisRayOffset;
}
Vector3 point = Util.GetClosestPointOnRayFromRay(axisRay, ray) - offset;
SetFocusedActorPositionWithChecks(point, snapAxis);
}
public void SetCustomGridScale(float GridScale)
{
GridMaxSize = SnapAxis.Custom;
CustomMaxSize = GridScale;
}
public OscillatorPattern(SnapAxis axisOfMovement, float period, float magnitude)
{
this.axisOfMovement = axisOfMovement;
this.period = period;
this.magnitude = magnitude;
}
