public bool GetVirtualPos(out Vec3 pos)
{
Vec3 raySrc;
Vec3 rayDir;
Editor.GetWorldRayFromScreenPoint(Editor.Viewport.NormalizedMousePos, out raySrc, out rayDir);
if (!this.m_virtualPlane.RayIntersect(raySrc, rayDir, out pos))
{
return false;
}
switch (this.m_axisConstraint)
{
case Axis.X:
pos = Vec3.Dot(pos, this.m_virtualPlaneBase.axisX) * this.m_virtualPlaneBase.axisX;
break;
case Axis.Y:
pos = Vec3.Dot(pos, this.m_virtualPlaneBase.axisY) * this.m_virtualPlaneBase.axisY;
break;
case Axis.Z:
pos = Vec3.Dot(pos, this.m_virtualPlaneBase.axisZ) * this.m_virtualPlaneBase.axisZ;
break;
}
return true;
}
public static Plane FromPointNormal(Vec3 pt, Vec3 normal)
{
return new Plane
{
normal = normal,
dist = Vec3.Dot(normal, pt)
};
}
private void OnValueChanged(Vec3 value)
{
this.m_value = value;
if (this.ValueChanged != null)
{
this.ValueChanged(this, new EventArgs());
}
}
public static EditorObject GetObjectFromScreenPoint(Vec2 pt, out Vec3 hitPos, bool includeFrozen, EditorObjectSelection ignore)
{
EditorObject result;
using (PhysEntityVector vector = PhysEntityVector.Create())
{
ignore.GetPhysEntities(vector);
result = new EditorObject(Binding.FCE_ObjectManager_GetObjectFromScreenPoint(pt.X, pt.Y, out hitPos.X, out hitPos.Y, out hitPos.Z, includeFrozen, vector.Pointer));
}
return result;
}
public static Plane FromPoints(Vec3 p1, Vec3 p2, Vec3 p3)
{
Plane result = default(Plane);
Vec3 v = p2 - p1;
Vec3 v2 = p2 - p3;
Vec3 v3 = Vec3.Cross(v, v2);
v3.Normalize();
result.normal = v3;
result.dist = Vec3.Dot(v3, p1);
return result;
}
public bool RayIntersect(Vec3 raySrc, Vec3 rayDir, out Vec3 pt)
{
float num = Vec3.Dot(this.normal, rayDir);
if (Math.Abs(num) < 0.0001f)
{
pt = default(Vec3);
return false;
}
float s = Vec3.Dot(this.normal, this.dist * this.normal - raySrc) / num;
pt = raySrc + s * rayDir;
return true;
}
public void InitVirtualPlane(Vec3 planePos, CoordinateSystem planeBase, Axis axisConstraint)
{
this.m_virtualPlanePos = planePos;
this.m_virtualPlaneBase = planeBase;
this.m_axisConstraint = axisConstraint;
CoordinateSystem virtualPlaneCoords = default(CoordinateSystem);
switch (this.m_axisConstraint)
{
case Axis.X:
virtualPlaneCoords.axisX = planeBase.axisX;
virtualPlaneCoords.axisY = Vec3.Cross(Camera.FrontVector, planeBase.axisX);
virtualPlaneCoords.axisY.Normalize();
virtualPlaneCoords.axisZ = Vec3.Cross(planeBase.axisX, virtualPlaneCoords.axisY);
virtualPlaneCoords.axisZ.Normalize();
break;
case Axis.Y:
virtualPlaneCoords.axisX = planeBase.axisY;
virtualPlaneCoords.axisY = Vec3.Cross(Camera.FrontVector, planeBase.axisY);
virtualPlaneCoords.axisY.Normalize();
virtualPlaneCoords.axisZ = Vec3.Cross(planeBase.axisY, virtualPlaneCoords.axisY);
virtualPlaneCoords.axisZ.Normalize();
break;
case Axis.XY:
virtualPlaneCoords.axisX = planeBase.axisX;
virtualPlaneCoords.axisY = planeBase.axisY;
virtualPlaneCoords.axisZ = planeBase.axisZ;
break;
case Axis.Z:
virtualPlaneCoords.axisX = planeBase.axisZ;
virtualPlaneCoords.axisY = Vec3.Cross(Camera.FrontVector, planeBase.axisZ);
virtualPlaneCoords.axisY.Normalize();
virtualPlaneCoords.axisZ = Vec3.Cross(planeBase.axisZ, virtualPlaneCoords.axisY);
virtualPlaneCoords.axisZ.Normalize();
break;
case Axis.XZ:
virtualPlaneCoords.axisX = planeBase.axisX;
virtualPlaneCoords.axisY = planeBase.axisZ;
virtualPlaneCoords.axisZ = planeBase.axisY;
break;
case Axis.YZ:
virtualPlaneCoords.axisX = planeBase.axisY;
virtualPlaneCoords.axisY = planeBase.axisZ;
virtualPlaneCoords.axisZ = planeBase.axisX;
break;
}
this.m_virtualPlane = Plane.FromPointNormal(this.m_virtualPlanePos, virtualPlaneCoords.axisZ);
this.m_virtualPlaneCoords = virtualPlaneCoords;
}
public static EditorObject GetObjectFromScreenPoint(Vec2 pt, out Vec3 hitPos, bool includeFrozen, EditorObject ignore)
{
PhysEntityVector vector = PhysEntityVector.Null;
if (ignore.IsValid)
{
vector = PhysEntityVector.Create();
ignore.GetPhysEntities(vector);
}
EditorObject result = new EditorObject(Binding.FCE_ObjectManager_GetObjectFromScreenPoint(pt.X, pt.Y, out hitPos.X, out hitPos.Y, out hitPos.Z, includeFrozen, vector.Pointer));
if (vector.IsValid)
{
vector.Dispose();
}
return result;
}
public void Unapply(EditorObject obj)
{
CoordinateSystem coordinateSystem = CoordinateSystem.FromAngles(obj.Angles);
AABB localBounds = obj.LocalBounds;
Vec3 vec = (localBounds.max + localBounds.min) * 0.5f;
Vec3 vec2 = localBounds.Length * 0.5f;
this.position -= obj.Position + vec.X * coordinateSystem.axisX + vec.Y * coordinateSystem.axisY;
this.position = coordinateSystem.ConvertFromWorld(this.position);
this.normal = coordinateSystem.ConvertFromWorld(this.normal);
this.normalUp = coordinateSystem.ConvertFromWorld(this.normalUp);
this.position.X = this.position.X / vec2.X;
this.position.Y = this.position.Y / vec2.Y;
if (this.position.X > 1f)
{
this.position.X = 1f;
}
else
{
if (this.position.X < -1f)
{
this.position.X = -1f;
}
}
if (this.position.Y > 1f)
{
this.position.Y = 1f;
}
else
{
if (this.position.Y < -1f)
{
this.position.Y = -1f;
}
}
if (this.position.Z > 1f)
{
this.position.Z = 1f;
}
else
{
if (this.position.Z < -1f)
{
this.position.Z = -1f;
}
}
this.normal.Z = 0f;
this.normalUp = new Vec3(0f, 0f, 1f);
}
public Vec3 GetPivotPoint(Vec3 center, AABB bounds, Pivot pivot)
{
Vec3 vec = center;
switch (pivot)
{
case Pivot.Left:
vec += this.axisX * bounds.min.X;
break;
case Pivot.Right:
vec += this.axisX * bounds.max.X;
break;
case Pivot.Down:
vec += this.axisY * bounds.min.Y;
break;
case Pivot.Up:
vec += this.axisY * bounds.max.Y;
break;
}
return vec;
}
public bool Start(Vec3 rotationPivot, Vec3 rotationAxis)
{
this.m_rotationPivot = rotationPivot;
this.m_rotationAxis = rotationAxis;
base.AcquireInput();
this.m_context.m_selection.SaveState();
return true;
}
public virtual bool Start(Vec3 pivot)
{
this.m_pivot = pivot;
this.m_delayedMove = true;
this.m_delayedMoveStart = Cursor.Position;
if ((Control.ModifierKeys & Keys.Control) != Keys.None)
{
this.m_localRotate = true;
Editor.Viewport.CaptureMouse = true;
}
base.AcquireInput();
this.m_context.m_selection.SaveState();
return true;
}
public override bool OnMouseEvent(Editor.MouseEvent mouseEvent, MouseEventArgs mouseEventArgs)
{
switch (mouseEvent)
{
case Editor.MouseEvent.MouseUp:
base.ReleaseInput();
break;
case Editor.MouseEvent.MouseMove:
{
if (this.m_delayedMove)
{
if (Math.Abs(this.m_delayedMoveStart.X - Cursor.Position.X) < 2 && Math.Abs(this.m_delayedMoveStart.Y - Cursor.Position.Y) < 2)
{
break;
}
if ((Control.ModifierKeys & Keys.Shift) != Keys.None)
{
EditorObjectSelection editorObjectSelection = EditorObjectSelection.Create();
this.m_context.m_selection.Clone(editorObjectSelection, true);
int num = this.m_context.m_selection.IndexOf(this.m_context.m_gizmoObject);
this.m_context.SetSelection(editorObjectSelection, (num != -1) ? editorObjectSelection[num] : EditorObject.Null);
}
Vec2 normalizedMousePos;
if (Editor.GetScreenPointFromWorldPos(this.m_pivot, out normalizedMousePos))
{
Editor.Viewport.NormalizedMousePos = normalizedMousePos;
}
this.m_delayedMove = false;
}
Vec3 raySrc;
Vec3 rayDir;
Editor.GetWorldRayFromScreenPoint(Editor.Viewport.NormalizedMousePos, out raySrc, out rayDir);
Vec3 vec;
float num2;
Vec3 normal;
if (Editor.RayCastPhysics(raySrc, rayDir, this.m_context.m_selection, out vec, out num2, out normal))
{
this.m_context.m_selection.Center = this.m_pivot;
this.m_context.m_selection.LoadState();
if (this.m_context.m_selection.Count == 1)
{
EditorObject editorObject = this.m_context.m_selection[0];
if (editorObject.Entry.AutoOrientation)
{
Vec3 angles;
editorObject.ComputeAutoOrientation(ref vec, out angles, normal);
editorObject.Angles = angles;
}
}
this.m_context.m_selection.MoveTo(vec, EditorObjectSelection.MoveMode.MoveNormal);
this.m_context.m_selection.SnapToClosestObjects();
this.m_pivot = vec;
this.m_context.UpdateSelection();
}
break;
}
case Editor.MouseEvent.MouseMoveDelta:
this.m_context.m_selection.LoadState();
this.m_context.m_selection.RotateCenter(0.025f * (float)mouseEventArgs.X, new Vec3(0f, 0f, 1f));
this.m_context.m_selection.SaveState();
this.m_context.m_selection.SnapToClosestObjects();
break;
case Editor.MouseEvent.MouseWheel:
{
this.m_context.m_selection.LoadState();
Vec3 center = this.m_context.m_selection.Center;
center.Z += (float)((0.3f * (float)mouseEventArgs.Delta > 0f) ? 1 : -1);
this.m_context.m_selection.MoveTo(center, EditorObjectSelection.MoveMode.MoveNormal);
this.m_context.m_selection.SaveState();
break;
}
}
return false;
}
public bool Start(Vec3 pivot)
{
this.m_refGizmo = this.m_context.m_gizmo;
this.m_gizmoHelper.InitVirtualPlane(this.m_refGizmo.Position, this.m_refGizmo.Axis, this.m_refGizmo.Active);
if (!this.m_gizmoHelper.GetVirtualPos(out this.m_virtualStart))
{
return false;
}
this.m_pivot = pivot;
this.m_startPosition = pivot;
base.AcquireInput();
this.m_context.m_selection.SaveState();
return true;
}
public override bool OnMouseEvent(Editor.MouseEvent mouseEvent, MouseEventArgs mouseEventArgs)
{
switch (mouseEvent)
{
case Editor.MouseEvent.MouseUp:
base.ReleaseInput();
break;
case Editor.MouseEvent.MouseMove:
{
Vec3 v;
if (this.m_gizmoHelper.GetVirtualPos(out v))
{
Vec3 vec = v - this.m_virtualStart;
if (this.m_snap)
{
vec = this.m_refGizmo.Axis.ConvertFromWorld(vec);
if (!this.m_snapObject.IsValid)
{
vec.Snap(this.m_snapSize);
}
else
{
if (this.m_snapObject.IsLoaded)
{
vec.Snap(this.m_snapObject.LocalBounds.Length);
}
else
{
vec = new Vec3(0f, 0f, 0f);
}
}
vec = this.m_refGizmo.Axis.ConvertToWorld(vec);
}
Vec3 vec2 = this.m_startPosition + vec;
this.m_context.m_selection.LoadState();
this.m_context.m_selection.MoveTo(vec2, EditorObjectSelection.MoveMode.MoveNormal);
this.m_context.m_selection.SnapToClosestObjects();
this.m_pivot = vec2;
this.m_context.UpdateSelection();
}
break;
}
}
return false;
}
public AABB(Vec3 min, Vec3 max)
{
this.min = min;
this.max = max;
}
public void Snap(Vec3 resolutionVector)
{
this.X -= (float)Math.IEEERemainder((double)this.X, (double)resolutionVector.X);
this.Y -= (float)Math.IEEERemainder((double)this.Y, (double)resolutionVector.Y);
this.Z -= (float)Math.IEEERemainder((double)this.Z, (double)resolutionVector.Z);
}
public static void GetWorldRayFromScreenPoint(Vec2 screenPoint, out Vec3 raySrc, out Vec3 rayDir)
{
Binding.FCE_Editor_GetWorldRayFromScreenPoint(screenPoint.X, screenPoint.Y, out raySrc.X, out raySrc.Y, out raySrc.Z, out rayDir.X, out rayDir.Y, out rayDir.Z);
}
public bool GetClosestPivot(Vec3 pos, out EditorObjectPivot pivot)
{
return this.GetClosestPivot(pos, out pivot, 3.40282347E+38f);
}
public static bool RayCastTerrain(Vec3 raySrc, Vec3 rayDir, out Vec3 hitPos, out float hitDist)
{
return(Binding.FCE_Editor_RayCastTerrain(raySrc.X, raySrc.Y, raySrc.Z, rayDir.X, rayDir.Y, rayDir.Z, out hitPos.X, out hitPos.Y, out hitPos.Z, out hitDist));
}
public static bool RayCastPhysics(Vec3 raySrc, Vec3 rayDir, EditorObjectSelection ignore, out Vec3 hitPos, out float hitDist)
{
Vec3 vec;
return(Editor.RayCastPhysics(raySrc, rayDir, ignore, out hitPos, out hitDist, out vec));
}
public static bool RayCastPhysics(Vec3 raySrc, Vec3 rayDir, EditorObjectSelection ignore, out Vec3 hitPos, out float hitDist, out Vec3 hitNormal)
{
return(Binding.FCE_Editor_RayCastPhysics2(raySrc.X, raySrc.Y, raySrc.Z, rayDir.X, rayDir.Y, rayDir.Z, ignore.Pointer, out hitPos.X, out hitPos.Y, out hitPos.Z, out hitDist, out hitNormal.X, out hitNormal.Y, out hitNormal.Z));
}
public static Vec3 Cross(Vec3 v1, Vec3 v2)
{
return new Vec3(v1.Y * v2.Z - v1.Z * v2.Y, v1.Z * v2.X - v1.X * v2.Z, v1.X * v2.Y - v1.Y * v2.X);
}
private void DrawSource(Vec3 cursorCenter, Vec3 cursorPos)
{
Color color = ((Control.ModifierKeys & Keys.Control) == Keys.None) ? Color.White : Color.Black;
Color borderColor = ((Control.ModifierKeys & Keys.Control) == Keys.None) ? Color.Black : Color.White;
float length = (Camera.Position - cursorCenter).Length;
Render.DrawTerrainSquare(cursorCenter.XY, 32f, length * 0.02f, color, 0.01f, 0.31f, borderColor);
Render.DrawTerrainCircle(cursorPos.XY, length * 0.0075f, length * 0.015f, color, 0f, 0f, borderColor);
}
public static float Dot(Vec3 v1, Vec3 v2)
{
return v1.X * v2.X + v1.Y * v2.Y + v1.Z * v2.Z;
}
public static bool GetScreenPointFromWorldPos(Vec3 worldPos, out Vec2 screenPoint)
{
return(Editor.GetScreenPointFromWorldPos(worldPos, out screenPoint, false));
}
public static void ApplyScreenDeltaToWorldPos(Vec2 screenDelta, ref Vec3 worldPos)
{
Vec3 vec = Camera.FrontVector;
if ((double)Math.Abs(vec.X) < 0.001 && (double)Math.Abs(vec.Y) < 0.001)
{
vec = Camera.UpVector;
}
Vec2 vec2 = -vec.XY;
vec2.Normalize();
Vec2 vec3 = new Vec2(-vec2.Y, vec2.X);
float num = (float)((double)Vec3.Dot(worldPos - Camera.Position, Camera.FrontVector) * Math.Tan((double)Camera.HalfFOV) * 2.0);
worldPos.X += num * screenDelta.X * vec3.X + num * screenDelta.Y * vec2.X;
worldPos.Y += num * screenDelta.X * vec3.Y + num * screenDelta.Y * vec2.Y;
}
public static bool RayCastPhysicsFromMouse(out Vec3 hitPos)
{
return(Editor.RayCastPhysicsFromScreenPoint(Editor.Viewport.NormalizedMousePos, out hitPos));
}
public void ComputeAutoOrientation(ref Vec3 pos, out Vec3 angles, Vec3 normal)
{
angles = default(Vec3);
Binding.FCE_Object_ComputeAutoOrientation(this.m_objPtr, ref pos.X, ref pos.Y, ref pos.Z, out angles.X, out angles.Y, out angles.Z, normal.X, normal.Y, normal.Z);
}
private Vec3 GetTileCenter(Vec3 cursorPos)
{
return new Vec3
{
X = cursorPos.X + 4f - cursorPos.X % 8f,
Y = cursorPos.Y + 4f - cursorPos.Y % 8f,
Z = cursorPos.Z
};
}
public bool GetClosestPivot(Vec3 pos, out EditorObjectPivot pivot, float minDist)
{
pivot = new EditorObjectPivot();
return Binding.FCE_Object_GetClosestPivot(this.m_objPtr, pos.X, pos.Y, pos.Z, out pivot.position.X, out pivot.position.Y, out pivot.position.Z, out pivot.normal.X, out pivot.normal.Y, out pivot.normal.Z, out pivot.normalUp.X, out pivot.normalUp.Y, out pivot.normalUp.Z, minDist);
}
public Axis HitTest(Vec3 raySrc, Vec3 rayDir)
{
return (Axis)Binding.FCE_Gizmo_HitTest(this.m_gizmoPtr, raySrc.X, raySrc.Y, raySrc.Z, rayDir.X, rayDir.Y, rayDir.Z);
}
public void Update(float dt)
{
if (this.m_cursorValid)
{
Vec3 vec = new Vec3((float)(this.m_cursorSX * 64 + 32), (float)(this.m_cursorSY * 64 + 32), 0f);
vec.Z = TerrainManager.GetHeightAtWithWater(vec.XY);
Vec3 vec2 = new Vec3(vec.X, vec.Y, this.m_paramWaterLevel.Value);
float num = Vec3.Dot(vec - Camera.Position, Camera.FrontVector);
float num2 = Vec3.Dot(vec2 - Camera.Position, Camera.FrontVector);
if (num > num2)
{
this.DrawSource(vec, this.m_cursorPos);
if ((Control.ModifierKeys & Keys.Control) == Keys.None && !this.m_painting)
{
this.DrawTarget(vec2);
return;
}
}
else
{
if ((Control.ModifierKeys & Keys.Control) == Keys.None && !this.m_painting)
{
this.DrawTarget(vec2);
}
this.DrawSource(vec, this.m_cursorPos);
}
}
}
public virtual bool OnMouseEvent(Editor.MouseEvent mouseEvent, MouseEventArgs mouseEventArgs)
{
switch (mouseEvent)
{
case Editor.MouseEvent.MouseDown:
if ((Control.ModifierKeys & Keys.Shift) == Keys.None)
{
Vec3 cursorPos;
if (Editor.RayCastTerrainFromMouse(out cursorPos))
{
this.m_cursorPos = cursorPos;
this.OnBeginPaint();
}
}
else
{
this.m_painting = ToolPaint.PaintingMode.Shortcut;
}
if (this.m_painting != ToolPaint.PaintingMode.None)
{
Editor.Viewport.CaptureMouse = true;
Editor.Viewport.CameraEnabled = false;
}
break;
case Editor.MouseEvent.MouseUp:
if (this.m_painting != ToolPaint.PaintingMode.None)
{
switch (this.m_painting)
{
case ToolPaint.PaintingMode.Plus:
case ToolPaint.PaintingMode.Minus:
this.OnEndPaint();
break;
}
this.m_cursorPos.Z = TerrainManager.GetHeightAtWithWater(this.m_cursorPos.XY);
Vec2 captureMousePos;
if (Editor.GetScreenPointFromWorldPos(this.m_cursorPos, out captureMousePos, true))
{
Editor.Viewport.CaptureMousePos = captureMousePos;
}
Editor.Viewport.CaptureMouse = false;
Editor.Viewport.CameraEnabled = true;
this.m_painting = ToolPaint.PaintingMode.None;
}
break;
case Editor.MouseEvent.MouseMove:
switch (this.m_painting)
{
case ToolPaint.PaintingMode.None:
case ToolPaint.PaintingMode.Plus:
case ToolPaint.PaintingMode.Minus:
this.m_cursorValid = Editor.RayCastTerrainFromMouse(out this.m_cursorPos);
break;
}
break;
case Editor.MouseEvent.MouseMoveDelta:
switch (this.m_painting)
{
case ToolPaint.PaintingMode.Plus:
case ToolPaint.PaintingMode.Minus:
if (!this.m_grabMode.Value)
{
Editor.ApplyScreenDeltaToWorldPos(new Vec2((float)mouseEventArgs.X / (float)Editor.Viewport.Width, (float)mouseEventArgs.Y / (float)Editor.Viewport.Height), ref this.m_cursorPos);
this.m_cursorPos.Z = TerrainManager.GetHeightAtWithWater(this.m_cursorPos.XY);
}
else
{
this.OnPaintGrab((float)mouseEventArgs.X, (float)mouseEventArgs.Y);
}
break;
case ToolPaint.PaintingMode.Shortcut:
{
float delta;
if (Math.Abs(mouseEventArgs.X) > Math.Abs(mouseEventArgs.Y))
{
delta = (float)mouseEventArgs.X;
}
else
{
delta = (float)(-(float)mouseEventArgs.Y);
}
this.OnShortcutDelta(delta);
break;
}
}
break;
}
return false;
}
private void DrawTarget(Vec3 cursorTarget)
{
float length = (Camera.Position - cursorTarget).Length;
if (!this.m_painting)
{
Render.DrawQuad(cursorTarget, 64f, 64f, Color.FromArgb(24, Color.Turquoise));
}
Render.DrawSquare(cursorTarget, 32f, length * 0.02f, Color.DarkGreen, 0f, Color.Black);
}
public override bool OnMouseEvent(Editor.MouseEvent mouseEvent, MouseEventArgs mouseEventArgs)
{
if (mouseEvent == Editor.MouseEvent.MouseDown)
{
if (this.m_context.m_gizmoActive)
{
Vec3 position = this.m_context.m_gizmo.Position;
Vec3 rotationAxis = default(Vec3);
switch (this.m_context.m_gizmo.Active)
{
case Axis.X:
rotationAxis = this.m_context.m_gizmo.Axis.axisX;
break;
case Axis.Y:
rotationAxis = this.m_context.m_gizmo.Axis.axisY;
break;
case Axis.Z:
rotationAxis = this.m_context.m_gizmo.Axis.axisZ;
break;
}
ToolObject.RotateAction rotateAction = new ToolObject.RotateAction(this.m_context);
if (this.m_paramSnap.Value)
{
rotateAction.SetSnap(this.m_paramSnapSize.Value);
}
rotateAction.Start(position, rotationAxis);
}
else
{
Vec3 pos;
EditorObject objectFromScreenPoint = ObjectManager.GetObjectFromScreenPoint(Editor.Viewport.NormalizedMousePos, out pos);
if (objectFromScreenPoint.IsValid)
{
if (!this.m_context.m_selection.Contains(objectFromScreenPoint))
{
EditorObjectSelection editorObjectSelection = EditorObjectSelection.Create();
if ((Control.ModifierKeys & Keys.Control) != Keys.None)
{
this.m_context.m_selection.Clone(editorObjectSelection, false);
}
this.m_context.SelectObject(editorObjectSelection, objectFromScreenPoint);
this.m_context.SetSelection(editorObjectSelection, objectFromScreenPoint);
}
else
{
this.m_context.SetupGizmo(objectFromScreenPoint);
}
EditorObjectPivot editorObjectPivot;
Vec3 position2;
if (objectFromScreenPoint.GetClosestPivot(pos, out editorObjectPivot))
{
position2 = editorObjectPivot.position;
}
else
{
position2 = objectFromScreenPoint.Position;
}
Vec3 rotationAxis2 = new Vec3(0f, 0f, 1f);
ToolObject.RotateAction rotateAction2 = new ToolObject.RotateAction(this.m_context);
if (this.m_paramSnap.Value)
{
rotateAction2.SetSnap(this.m_paramSnapSize.Value);
}
rotateAction2.Start(position2, rotationAxis2);
}
else
{
ToolObject.SelectAction selectAction = new ToolObject.SelectAction(this.m_context);
selectAction.Start();
}
}
}
return false;
}
