public void RedirectSelected(EditorSceneBase scene)
{
List <RenderablePathPoint> swappedPoints = new List <RenderablePathPoint>();
var selected = GetSelectedPoints();
foreach (var point in selected)
{
foreach (var child in point.Children)
{
if (swappedPoints.Contains(child))
{
continue;
}
}
foreach (var parent in point.Parents)
{
if (swappedPoints.Contains(parent))
{
continue;
}
}
point.SwapChildrenAndParents();
swappedPoints.Add(point);
}
}
public override void ApplyTransformActionToSelection(EditorSceneBase scene, AbstractTransformAction transformAction, ref TransformChangeInfos infos)
{
if (PickingSelection == PickingMode.Mesh)
{
foreach (GenericPickableMesh point in PickableMeshes)
{
point.ApplyTransformActionToSelection(scene, transformAction, ref infos);
}
}
else if (Selected)
{
Vector3 pp = Position, pr = Rotation, ps = Scale;
GlobalPosition = OnPositionChanged(transformAction.NewPos(GlobalPosition, out bool posHasChanged));
Matrix3 rotMtx = GlobalRotation;
GlobalRotation = transformAction.NewRot(GlobalRotation, out bool rotHasChanged);
GlobalScale = transformAction.NewScale(GlobalScale, rotMtx, out bool scaleHasChanged);
infos.Add(this, 0,
posHasChanged ? new Vector3?(pp) : new Vector3?(),
rotHasChanged ? new Vector3?(pr) : new Vector3?(),
scaleHasChanged ? new Vector3?(ps) : new Vector3?());
}
}
public IRevertable Revert(EditorSceneBase scene) //Insert deleted objs back in
{
Revertable3DWorldObjAddition.ObjListInfo[] newObjListInfos = new Revertable3DWorldObjAddition.ObjListInfo[objListInfos.Length];
int i_newObjListInfos = 0;
int i_index = linkIndices.Length;
foreach (ObjListInfo objListInfo in objListInfos.Reverse())
{
newObjListInfos[i_newObjListInfos].objList = objListInfo.objList;
I3dWorldObject[] newObjs = newObjListInfos[i_newObjListInfos++].objects = new I3dWorldObject[objListInfo.deleteInfos.Length];
int i_newObjs = 0;
foreach (DeleteInfo info in objListInfo.deleteInfos.Reverse())
{
//Insert obj into the list
objListInfo.objList.Insert(info.index, info.obj);
newObjs[i_newObjs++] = info.obj;
//Insert obj into all links linking to it
for (int i = info.obj.LinkDestinations.Count - 1; i >= 0; i--)
{
(string, I3dWorldObject)dest = info.obj.LinkDestinations[i];
dest.Item2.Links[dest.Item1].Insert(linkIndices[--i_index], info.obj);
}
}
}
(scene as SM3DWorldScene)?.UpdateLinkDestinations();
return(new Revertable3DWorldObjAddition(newObjListInfos));
}
public IRevertable Revert(EditorSceneBase scene)
{
Revertable3DWorldObjDeletion.ObjListInfo[] newObjListInfos = new Revertable3DWorldObjDeletion.ObjListInfo[objListInfos.Length];
int i_newObjListInfos = 0;
List <int> newLinkIndices = new List <int>();
foreach (ObjListInfo objListInfo in objListInfos)
{
newObjListInfos[i_newObjListInfos].objList = objListInfo.objList;
Revertable3DWorldObjDeletion.DeleteInfo[] newObjs =
newObjListInfos[i_newObjListInfos++].deleteInfos = new Revertable3DWorldObjDeletion.DeleteInfo[objListInfo.objects.Length];
int i_newObjs = 0;
foreach (I3dWorldObject obj in objListInfo.objects)
{
//Remove obj from the list
newObjs[i_newObjs++] = new Revertable3DWorldObjDeletion.DeleteInfo(objListInfo.objList.IndexOf(obj), obj);
objListInfo.objList.Remove(obj);
//remove obj from all links linking to it
foreach ((string, I3dWorldObject)dest in obj.LinkDestinations)
{
newLinkIndices.Add(dest.Item2.Links[dest.Item1].IndexOf(obj));
dest.Item2.Links[dest.Item1].Remove(obj);
}
}
}
(scene as SM3DWorldScene)?.UpdateLinkDestinations();
return(new Revertable3DWorldObjDeletion(newObjListInfos, newLinkIndices.ToArray()));
}
public void ApplyIfChanged(IList objects, EditorSceneBase scene = null)
{
var infos = new List <EditorSceneBase.RevertableMassPropertyChange <TObject, TValue> .Info>();
if (Value != prevValue)
{
for (int i = 0; i < objects.Count; i++)
{
var value = getter((TObject)objects[i]);
if (!value.Equals(Value.SharedValue))
{
infos.Add(new EditorSceneBase.RevertableMassPropertyChange <TObject, TValue> .Info((TObject)objects[i], value));
setter((TObject)objects[i], Value.SharedValue);
}
}
prevValue = Value;
if (infos.Count > 0)
{
scene?.AddToUndo(new EditorSceneBase.RevertableMassPropertyChange <TObject, TValue>(getter, setter, infos.ToArray()));
}
}
}
public override void DeleteSelected(EditorSceneBase scene, DeletionManager manager, IList list)
{
if (Selected)
{
manager.Add(list, this);
}
}
public override void ApplyTransformActionToSelection(EditorSceneBase scene, AbstractTransformAction transformAction, ref TransformChangeInfos transformChangeInfos)
{
foreach (RenderablePathPoint point in GetSelectedPoints())
{
point.ApplyTransformActionToSelection(scene, transformAction, ref transformChangeInfos);
}
}
public Matrix4 GetMatrix(EditorSceneBase editorScene)
{
if (Selected)
{
bool posChanged = false;
bool scaleChanged = false;
bool rotChanged = false;
editorScene.CurrentAction.NewPos(GlobalPosition, out posChanged);
editorScene.CurrentAction.NewScale(GlobalScale, GlobalRotation, out scaleChanged);
editorScene.CurrentAction.NewRot(GlobalRotation, out rotChanged);
if (posChanged || scaleChanged || rotChanged)
{
updateMatrix = true;
}
Console.WriteLine($"updateMatrix {updateMatrix} GlobalPosition {GlobalPosition}");
}
if (!updateMatrix)
{
return(transform);
}
else
{
updateMatrix = false;
transform = UpdateMatrix(editorScene);
return(transform);
}
}
public BasicPropertyUIContainer(AreaObject area, EditorSceneBase scene)
{
this.area = area;
this.scene = scene;
shapeNames = LevelIO.AreaModelNames.ToArray();
}
public override void Draw(GL_ControlModern control, Pass pass, EditorSceneBase editorScene)
{
Vector4 hightlightColor;
if (Selected && editorScene.Hovered == this)
{
hightlightColor = General3dWorldObject.hoverSelectColor;
}
else if (Selected)
{
hightlightColor = General3dWorldObject.selectColor;
}
else if (editorScene.Hovered == this)
{
hightlightColor = General3dWorldObject.hoverColor;
}
else
{
hightlightColor = Vector4.Zero;
}
Matrix3 rotMat = Framework.Mat3FromEulerAnglesDeg(Rotation);
rotMat = Selected ? editorScene.SelectionTransformAction.NewRot(rotMat) : rotMat;
Matrix4 transform = new Matrix4(rotMat) * Matrix4.CreateTranslation(Selected ? editorScene.SelectionTransformAction.NewPos(Position) : Position);
Vector4 pickingColor = control.NextPickingColor();
foreach (var renderer in Zone.ZoneBatch.BatchRenderers)
{
renderer.Draw(control, pass, hightlightColor, transform, pickingColor);
}
}
public IRevertable Revert(EditorSceneBase scene)
{
var infos = new List <RenderablePathPoint>();
foreach (var info in Points)
{
info.Point.Parents.Clear();
info.Point.Children.Clear();
foreach (var parent in info.Parents)
{
info.Point.Parents.Add(parent);
}
foreach (var child in info.Children)
{
info.Point.Children.Add(child);
}
if (!info.ParentPath.PathPoints.Contains(info.Point))
{
info.ParentPath.AddPoint(info.Point);
}
infos.Add(info.Point);
}
return(new RevertableDelPointCollection(infos));
}
public override bool TrySetupObjectUIControl(EditorSceneBase scene, ObjectUIControl objectUIControl)
{
if (!Selected)
{
return(false);
}
objectUIControl.AddObjectUIContainer(new CameraUI(this, scene), "General Settings");
if (mFields.Keys.Any(k => k.StartsWith("flag.")))
{
objectUIControl.AddObjectUIContainer(new CameraFlagsUI(this, scene), "Camera Flags");
}
// camera types "Cube", "Group", "Start", and "Other" load the chunk CameraParamChunkGame
// "Event" loads CameraParamChunkEvent
CameraType type = GetCameraType();
if (type == CameraType.Cube || type == CameraType.Group || type == CameraType.Start || type == CameraType.Other)
{
objectUIControl.AddObjectUIContainer(new CameraGameFlagsUI(this, scene), "Camera Game Flags");
}
if (type == CameraType.Event)
{
objectUIControl.AddObjectUIContainer(new CameraEventFlagsUI(this, scene), "Camera Event Flags");
}
return(true);
}
public override void Draw(GL_ControlModern control, Pass pass, EditorSceneBase editorScene)
{
if (pass == Pass.TRANSPARENT)
{
return;
}
if (!editorScene.ShouldBeDrawn(this))
{
return;
}
bool hovered = editorScene.Hovered == this;
Matrix4 mtx = Matrix4.CreateScale(1f, 0.25f, 1f);
mtx *= Matrix4.CreateFromAxisAngle(Vector3.UnitY, -Framework.HALF_PI);
mtx *= Matrix4.CreateTranslation(Selected ? editorScene.CurrentAction.NewPos(Position) : Position);
Vector4 pickingColor = control.NextPickingColor();
Vector4 lineBoxColor;
if (hovered && Selected)
{
lineBoxColor = hoverSelectColor;
}
else if (Selected)
{
lineBoxColor = selectColor;
}
else if (hovered)
{
lineBoxColor = hoverColor;
}
else
{
lineBoxColor = new Vector4(0.75f, 0.75f, 0.75f, 1);
}
if (Selected)
{
control.UpdateModelMatrix(mtx * Matrix4.CreateTranslation(Vector3.UnitX * (3f - Math.Abs((control.RedrawerFrame - animationStartFrame) * 0.0625f % 6f - 3f))));
}
else
{
control.UpdateModelMatrix(mtx);
}
Renderers.ColorBlockRenderer.Draw(control, pass, Color, Color, pickingColor);
control.UpdateModelMatrix(mtx);
Renderers.ColorBlockRenderer.DrawLineBox(control, pass, lineBoxColor, pickingColor);
control.UpdateModelMatrix(mtx * Matrix4.CreateTranslation(Vector3.UnitX * 3f));
Renderers.ColorBlockRenderer.DrawLineBox(control, pass, lineBoxColor, pickingColor);
}
public BasicPropertyUIContainer(AreaObject area, EditorSceneBase scene)
{
this.area = area;
this.scene = scene;
shapeNames = LevelIO.AreaModelNames.ToArray();
DB_classNames = Program.ParameterDB.AreaParameters.Keys.ToArray();
}
public StartObjUI(AbstractObj obj, EditorSceneBase scene)
{
this.obj = obj as StartObj;
this.scene = scene;
zones = new List <string>();
zones.AddRange(obj.mParentZone.mGalaxy.GetZones().Keys);
}
public RailUIContainer(Rail rail, EditorSceneBase scene)
{
this.rail = rail;
List <PathPoint> points = new List <PathPoint>();
this.scene = scene;
}
public override void Draw(GL_ControlModern control, Pass pass, EditorSceneBase editorScene)
{
if (!ObjectRenderState.ShouldBeDrawn(this) || pass != Pass.OPAQUE)
{
return;
}
bool hovered = editorScene.Hovered == this;
if (!CanPick)
{
control.SkipPickingColors(1);
Selected = false;
hovered = false;
if (pass == Pass.PICKING)
{
return;
}
}
Matrix3 rotMtx = GlobalRotation;
Vector4 highlightColor = Vector4.Zero;
if (Selected && hovered)
{
highlightColor = hoverSelectColor;
}
else if (Selected)
{
highlightColor = selectColor;
}
else if (hovered)
{
highlightColor = hoverColor;
}
bool positionChanged = false;
Vector3 position = !Selected ? GlobalPosition :
editorScene.CurrentAction.NewPos(GlobalPosition, out positionChanged);
if (positionChanged && editorScene.CurrentAction is TranslateAction)
{
var newPosition = OnPositionChanged(position);
if (newPosition != position)
{
((TranslateAction)editorScene.CurrentAction).SetAxisXZ();
}
position = newPosition;
}
control.UpdateModelMatrix(
Matrix4.CreateScale((Selected ? editorScene.CurrentAction.NewScale(GlobalScale, rotMtx) : GlobalScale)) *
new Matrix4(Selected ? editorScene.CurrentAction.NewRot(rotMtx) : rotMtx) *
Matrix4.CreateTranslation(position));
DrawModel(control, editorScene, pass, highlightColor);
}
public void ConnectToHoveredPoints(EditorSceneBase scene, bool alt)
{
//Only pass if points can be hover connected by movement or being extruded
//If an action occurs then the point may be being extruded
bool hasExclusiveAction = (scene.ExclusiveAction != null && scene.ExclusiveAction != EditorScene.NoAction);
bool hasNormalAction = (scene.CurrentAction != null && scene.CurrentAction != EditorScene.NoAction);
if ((!hasExclusiveAction && !hasNormalAction) && ConnectExtrudedHoveredPoints)
{
return;
}
//Get the selected points.
//Make sure selected points cannot use the hovered pick pass
var points = GetSelectedPoints();
foreach (var point in points)
{
point.isHoverPickPass = true;
}
//For each point disable the current hovered point
foreach (var point in PathPoints)
{
point.IsPointOver = false;
}
//Find any points hovered over while a point is selected
int part = scene.FindPickablePart(scene.GL_Control, this);
if (part != -1)
{
foreach (var point in points)
{
int hoveredPart = part;
foreach (var pt in PathPoints)
{
//When a selected point's position is changed
//check all points and find a hovered point
//To determine a connection to be made when released
int span = pt.GetPickableSpan();
if (hoveredPart >= 0 && hoveredPart < span && !pt.IsSelected() && PointCanConnect(point))
{
pt.IsPointOver = true;
}
hoveredPart -= span;
}
}
}
//Disable bool preventing hover pick pass when finished
foreach (var point in points)
{
point.isHoverPickPass = false;
}
scene.GL_Control.Invalidate();
}
public void MergeSelectedPoints(EditorSceneBase scene)
{
var selected = GetSelectedPoints();
if (selected.Count == 2)
{
selected[1].ConnectToPoint(selected[0]);
}
}
public void FillSelectedPoints(EditorSceneBase scene)
{
var selected = GetSelectedPoints();
if (!selected[1].Children.Contains(selected[0]))
{
selected[1].Children.Add(selected[0]);
}
}
public BasicPropertyUIContainer(General3dWorldObject obj, EditorSceneBase scene)
{
this.obj = obj;
this.scene = scene;
DB_classNames = Program.ParameterDB.ObjectParameters.Keys.ToArray();
UpdateClassNameInfo();
}
public override bool TrySetupObjectUIControl(EditorSceneBase scene, ObjectUIControl objectUIControl)
{
if (!Selected)
{
return(false);
}
objectUIControl.AddObjectUIContainer(new PropertyProvider(this, scene), "Transform");
return(true);
}
public override void Draw(GL_ControlModern control, Pass pass, EditorSceneBase editorScene)
{
if (!Visible)
{
return;
}
if (Selected && editorScene.Hovered == this)
{
SceneDrawState.HighlightColorOverride = General3dWorldObject.hoverSelectColor;
}
else if (Selected)
{
SceneDrawState.HighlightColorOverride = General3dWorldObject.selectColor;
}
else if (editorScene.Hovered == this)
{
SceneDrawState.HighlightColorOverride = General3dWorldObject.hoverColor;
}
else
{
SceneDrawState.HighlightColorOverride = Vector4.Zero;
}
Matrix3 rotMat = Framework.Mat3FromEulerAnglesDeg(Rotation);
rotMat = Selected ? editorScene.SelectionTransformAction.NewRot(rotMat) : rotMat;
SceneDrawState.ZoneTransform = new ZoneTransform(
new Matrix4(rotMat) * Matrix4.CreateTranslation(Selected ? editorScene.SelectionTransformAction.NewPos(Position) : Position),
rotMat);
var actionBackup = editorScene.SelectionTransformAction;
editorScene.SelectionTransformAction = EditorSceneBase.NoAction;
SceneObjectIterState.InLinks = false;
foreach (ObjectList objects in Zone.ObjLists.Values)
{
foreach (I3dWorldObject obj in objects)
{
obj.Draw(control, pass, editorScene);
}
}
SceneObjectIterState.InLinks = true;
foreach (I3dWorldObject obj in Zone.LinkedObjects)
{
obj.Draw(control, pass, editorScene);
}
SceneDrawState.ZoneTransform = ZoneTransform.Identity;
SceneDrawState.HighlightColorOverride = null;
editorScene.SelectionTransformAction = actionBackup;
}
public override bool TrySetupObjectUIControl(EditorSceneBase scene, ObjectUIControl objectUIControl)
{
if (!Selected)
{
return(false);
}
objectUIControl.AddObjectUIContainer(new LightUI(this, scene), "General Settings");
return(true);
}
private void AddPointTransformsToUndo(EditorSceneBase scene, List <RenderablePathPoint> selected)
{
TransformChangeInfos transformChangeInfos = new TransformChangeInfos(new List <TransformChangeInfo>());
for (int i = 0; i < selected.Count; i++)
{
transformChangeInfos.Add(selected[i], i, selected[i].GlobalPosition, selected[i].Rotation, selected[i].GlobalScale);
}
scene.AddTransformToUndo(transformChangeInfos);
}
public ExtraPropertiesUIContainer(Dictionary <string, dynamic> propertyDict, EditorSceneBase scene, Information information = null)
{
this.propertyDict = propertyDict;
this.scene = scene;
propertyDictKeys = propertyDict.Keys.ToArray();
if (information != null)
{
propertyInfos = information.Properties;
}
}
public override void Draw(GL_ControlLegacy control, Pass pass, EditorSceneBase editorScene)
{
if (pass == Pass.TRANSPARENT)
{
return;
}
if (!ObjectRenderState.ShouldBeDrawn(this))
{
return;
}
}
public IRevertable Revert(EditorSceneBase scene)
{
var infos = new List <RenderablePathPoint>();
foreach (var info in Points)
{
info.ParentPath.RemovePoint(info.Point);
infos.Add(info.Point);
}
return(new RevertableDelPointCollection(infos));
}
public override bool TrySetupObjectUIControl(EditorSceneBase scene, ObjectUIControl objectUIControl)
{
if (Selected)
{
objectUIControl.AddObjectUIContainer(new GeneralUIContainer(this, scene), "General");
return(true);
}
else
{
return(false);
}
}
public override void ApplyTransformActionToPart(EditorSceneBase scene, AbstractTransformAction transformAction, int _part, ref TransformChangeInfos transformChangeInfos)
{
foreach (RenderablePathPoint point in PathPoints)
{
int span = point.GetPickableSpan();
if (_part >= 0 && _part < span)
{
point.ApplyTransformActionToPart(scene, transformAction, _part, ref transformChangeInfos);
return;
}
_part -= span;
}
throw new Exception("Invalid partIndex");
}
