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; }