private List <Field> FindCommonFields()
{
List <Field> ret = null;
if (boundContainers.Count > 0)
{
// take all fields from the least selected container...
ret = boundContainers[boundContainers.Count - 1].GetFields();
for (int i = 0; i < boundContainers.Count - 1; i++)
{
DrawableContainer dc = boundContainers[i];
List <Field> fieldsToRemove = new List <Field>();
foreach (Field f in ret)
{
// ... throw out those that do not apply to one of the other containers
if (!dc.HasField(f.FieldType))
{
fieldsToRemove.Add(f);
}
}
foreach (Field f in fieldsToRemove)
{
ret.Remove(f);
}
}
}
if (ret == null)
{
ret = new List <Field>();
}
return(ret);
}
private IList <IField> FindCommonFields()
{
IList <IField> returnFields = null;
if (_boundContainers.Count > 0)
{
// take all fields from the least selected container...
DrawableContainer leastSelectedContainer = _boundContainers[_boundContainers.Count - 1] as DrawableContainer;
if (leastSelectedContainer != null)
{
returnFields = leastSelectedContainer.GetFields();
for (int i = 0; i < _boundContainers.Count - 1; i++)
{
DrawableContainer dc = _boundContainers[i] as DrawableContainer;
if (dc != null)
{
IList <IField> fieldsToRemove = new List <IField>();
foreach (IField field in returnFields)
{
// ... throw out those that do not apply to one of the other containers
if (!dc.HasField(field.FieldType))
{
fieldsToRemove.Add(field);
}
}
foreach (var field in fieldsToRemove)
{
returnFields.Remove(field);
}
}
}
}
}
return(returnFields ?? new List <IField>());
}
public void Load(System.IO.Stream stream)
{
Text = FileName;
Renderer = new KCLRendering();
DrawableContainer = new DrawableContainer()
{
Name = FileName,
Drawables = new List <AbstractGlDrawable>()
{
Renderer
},
};
stream.Position = 0;
KclFile = new KCLFile(stream);
ReloadData();
string path = Path.Combine(Runtime.ExecutableDir, "KclMaterialPresets");
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
CollisionPresetData.LoadPresets(Directory.GetFiles(path));
}
public void Dispose()
{
if (drawableContainer != null)
{
drawableContainer.Dispose();
drawableContainer = null;
}
}
public void UnbindElement(DrawableContainer dc)
{
if (boundContainers.Contains(dc))
{
boundContainers.Remove(dc);
UpdateFromBoundElements();
}
}
public void BindElement(DrawableContainer dc)
{
if (!boundContainers.Contains(dc))
{
boundContainers.Add(dc);
dc.ChildrenChanged += delegate { UpdateFromBoundElements(); };
UpdateFromBoundElements();
}
}
public static void RemoveContainer(DrawableContainer drawable)
{
var editor = LibraryGUI.GetObjectEditor();
if (editor == null)
{
return;
}
editor.DrawableContainers.Remove(drawable);
}
public static void AddContainer(DrawableContainer drawable)
{
var editor = LibraryGUI.Instance.GetObjectEditor();
if (editor == null)
{
return;
}
editor.DrawableContainers.Add(drawable);
}
private void drawableContainerCB_SelectedIndexChanged(object sender, EventArgs e)
{
if (drawableContainerCB.SelectedIndex >= 0)
{
int index = drawableContainerCB.SelectedIndex;
DrawableContainer container = Containers[index];
Materials.Clear();
Textures.Clear();
Objects.Clear();
for (int i = 0; i < container.Drawables.Count; i++)
{
if (container.Drawables[i] is IMeshContainer && container.Drawables[i].Visible)
{
for (int m = 0; m < ((IMeshContainer)container.Drawables[i]).Meshes.Count; m++)
{
var mesh = ((IMeshContainer)container.Drawables[i]).Meshes[m];
if (mesh.GetMaterial() != null)
{
Objects.Add(mesh);
var mat = mesh.GetMaterial();
if (!Materials.Contains(mat))
{
Materials.Add(mat);
}
}
}
}
if (container.Drawables[i] is Rendering.GenericModelRenderer && container.Drawables[i].Visible)
{
for (int m = 0; m < ((Rendering.GenericModelRenderer)container.Drawables[i]).Meshes.Count; m++)
{
var mesh = ((Rendering.GenericModelRenderer)container.Drawables[i]).Meshes[m];
if (mesh.GetMaterial() != null)
{
Objects.Add(mesh);
var mat = mesh.GetMaterial();
if (!Materials.Contains(mat))
{
Materials.Add(mat);
}
}
}
}
}
Reset();
Refresh();
gL_ControlLegacy2D1.Invalidate();
}
}
public void UpdateElement(DrawableContainer dc)
{
internalUpdateRunning = true;
foreach (Field field in GetFields())
{
if (dc.HasField(field.FieldType) && field.HasValue)
{
//if(LOG.IsDebugEnabled) LOG.Debug(" "+field+ ": "+field.Value);
dc.SetFieldValue(field.FieldType, field.Value);
}
}
internalUpdateRunning = false;
}
public void BindElement(IDrawableContainer dc)
{
DrawableContainer container = dc as DrawableContainer;
if (container != null && !boundContainers.Contains(container))
{
boundContainers.Add(container);
container.ChildrenChanged += delegate {
UpdateFromBoundElements();
};
UpdateFromBoundElements();
}
}
private void FromDrawableContainer(DrawableContainer drawableContainer, IList <IBaseShape> shapes, IFactory factory)
{
var group = factory.CreateGroupShape(ProjectEditorConfiguration.DefaulGroupName);
var groupShapes = new List <IBaseShape>();
foreach (var child in drawableContainer.ChildrenDrawables)
{
ToShape(child, groupShapes, factory);
}
foreach (var groupShape in groupShapes)
{
group.AddShape(groupShape);
}
shapes.Add(group);
}
public void Load(System.IO.Stream stream)
{
Text = FileName;
Renderer = new KCLRendering();
DrawableContainer = new DrawableContainer()
{
Name = FileName,
Drawables = new List <AbstractGlDrawable>()
{
Renderer
},
};
stream.Position = 0;
data = stream.ToArray();
Read(data);
}
public void LoadViewport(DrawableContainer ActiveDrawable, List <ToolStripMenuItem> customContextMenus = null)
{
if (!Runtime.UseOpenGL || !DisplayViewport)
{
return;
}
if (customContextMenus != null)
{
foreach (var menu in customContextMenus)
{
viewport.LoadCustomMenuItem(menu);
}
}
viewport.ReloadDrawables(ActiveDrawable);
OnLoadedTab();
}
public void UpdateElement(IDrawableContainer dc)
{
DrawableContainer container = dc as DrawableContainer;
if (container == null)
{
return;
}
internalUpdateRunning = true;
foreach (Field field in GetFields())
{
if (container.HasField(field.FieldType) && field.HasValue)
{
//if(LOG.IsDebugEnabled) LOG.Debug(" "+field+ ": "+field.Value);
container.SetFieldValue(field.FieldType, field.Value);
}
}
internalUpdateRunning = false;
}
public void Unload()
{
foreach (var mesh in ((GenericModelRenderer)DrawableContainer.Drawables[1]).Meshes)
{
mesh.vertices.Clear();
mesh.faces.Clear();
mesh.display = new int[0];
}
((GenericModelRenderer)DrawableContainer.Drawables[1]).Meshes.Clear();
DrawableContainer.Drawables.Clear();
DrawableContainer = null;
header.Materials.Clear();
header.TextureMaps.Clear();
header.TotalNodes.Clear();
header.BoneList.Clear();
header.LinkNodes.Clear();
Nodes.Clear();
header = null;
}
public void LoadViewport(BFRES bfres, bool hasShapes, DrawableContainer activeDrawable, List <ToolStripMenuItem> customContextMenus = null)
{
ActiveBfres = bfres;
HasShapes = hasShapes;
ActiveDrawable = activeDrawable;
if (!Runtime.UseOpenGL || !DisplayViewport)
{
return;
}
ReloadDrawableList();
if (customContextMenus != null)
{
foreach (var menu in customContextMenus)
{
viewport.LoadCustomMenuItem(menu);
}
}
OnLoadedTab();
}
public PixelizationFilter(DrawableContainer parent) : base(parent) {
AddField(GetType(), FieldType.PIXEL_SIZE, 5);
}
public AbstractFilter(DrawableContainer parent)
{
this.parent = parent;
}
public MagnifierFilter(DrawableContainer parent)
: base(parent)
{
AddField(GetType(), FieldType.MAGNIFICATION_FACTOR, 2);
}
public PixelizationFilter(DrawableContainer parent) : base(parent)
{
AddField(GetType(), FieldType.PIXEL_SIZE, 5);
}
public AbstractFilter(DrawableContainer parent)
{
this.parent = parent;
}
public HighlightFilter(DrawableContainer parent)
: base(parent)
{
AddField(GetType(), FieldType.FILL_COLOR, Color.Yellow);
}
public GrayscaleFilter(DrawableContainer parent) : base(parent)
{
}
public FastSmoothFilter(DrawableContainer parent)
: base(parent)
{
AddField(GetType(), FieldType.BLUR_RADIUS, 3);
}
public BrightnessFilter(DrawableContainer parent)
: base(parent)
{
AddField(GetType(), FieldType.BRIGHTNESS, 0.9d);
}
public void BindAndUpdateElement(DrawableContainer dc)
{
UpdateElement(dc);
BindElement(dc);
}
private void drawableContainerCB_SelectedIndexChanged(object sender, EventArgs e)
{
if (drawableContainerCB.SelectedIndex >= 0)
{
int index = drawableContainerCB.SelectedIndex;
DrawableContainer container = Containers[index];
Materials.Clear();
Textures.Clear();
Objects.Clear();
for (int i = 0; i < container.Drawables.Count; i++)
{
if (container.Drawables[i] is IMeshContainer && container.Drawables[i].Visible)
{
for (int m = 0; m < ((IMeshContainer)container.Drawables[i]).Meshes.Count; m++)
{
var mesh = ((IMeshContainer)container.Drawables[i]).Meshes[m];
Objects.Add(mesh);
if (mesh.PolygonGroups.Count > 0)
{
foreach (var group in mesh.PolygonGroups)
{
var mat = group.Material;
if (mat != null && !Materials.Contains(mat))
{
Materials.Add(mat);
}
}
}
else if (mesh.GetMaterial() != null)
{
var mat = mesh.GetMaterial();
if (!Materials.Contains(mat))
{
Materials.Add(mat);
}
}
}
}
if (container.Drawables[i] is Rendering.GenericModelRenderer && container.Drawables[i].Visible)
{
for (int m = 0; m < ((Rendering.GenericModelRenderer)container.Drawables[i]).Meshes.Count; m++)
{
var mesh = ((Rendering.GenericModelRenderer)container.Drawables[i]).Meshes[m];
if (mesh.GetMaterial() != null)
{
Objects.Add(mesh);
var mat = mesh.GetMaterial();
if (!Materials.Contains(mat))
{
Materials.Add(mat);
}
}
}
}
}
Reset();
Refresh();
uvViewport1.UpdateViewport();
}
}
public void BindAndUpdateElement(DrawableContainer dc)
{
UpdateElement(dc);
BindElement(dc);
}
public void Read(FileReader reader)
{
Renderer = new G1M_Renderer();
Renderer.G1MFile = this;
DrawableContainer = new DrawableContainer();
DrawableContainer.Name = FileName;
DrawableContainer.Drawables.Add(Renderer);
reader.ByteOrder = Syroot.BinaryData.ByteOrder.BigEndian;
string Magic = reader.ReadString(4);
if (Magic == "_M1G")
{
reader.ByteOrder = Syroot.BinaryData.ByteOrder.LittleEndian;
}
else
{
reader.ByteOrder = Syroot.BinaryData.ByteOrder.BigEndian;
}
uint Version = reader.ReadUInt32();
uint FileSize = reader.ReadUInt32();
uint firstChunkOffset = reader.ReadUInt32();
uint padding = reader.ReadUInt32();
uint numChunks = reader.ReadUInt32();
switch (Version)
{
case 0x30303334: break;
case 0x30303335: break;
case 0x30303336: break;
case 0x30303337: break;
default: break;
}
reader.SeekBegin(firstChunkOffset);
for (int i = 0; i < numChunks; i++)
{
G1MChunkCommon chunk = new G1MChunkCommon();
chunk.ChunkPosition = reader.Position;
chunk.Magic = reader.ReadString(4, Encoding.ASCII);
chunk.ChunkVersion = reader.ReadUInt32();
chunk.ChunkSize = reader.ReadUInt32();
Console.WriteLine("chunkMagic " + chunk.Magic);
if (chunk.Magic == "G1MF")
{
}
else if (chunk.Magic == "SM1G" || chunk.Magic == "G1MS")
{
G1MSkeleton = new G1MS(reader);
Renderer.Skeleton = G1MSkeleton.GenericSkeleton;
DrawableContainer.Drawables.Add(G1MSkeleton.GenericSkeleton);
TreeNode skeleton = new TreeNode("Skeleton");
Nodes.Add(skeleton);
foreach (var bn in G1MSkeleton.GenericSkeleton.bones)
{
if (bn.Parent == null)
{
skeleton.Nodes.Add(bn);
}
}
}
else if (chunk.Magic == "G1MM")
{
}
else if (chunk.Magic == "G1MG")
{
Model = new G1MG(reader);
Renderer.Meshes.AddRange(Model.GenericMeshes);
meshNode = new TreeNode("Meshes");
Nodes.Add(meshNode);
foreach (var mesh in Model.GenericMeshes)
{
meshNode.Nodes.Add(mesh);
}
if (G1MSkeleton != null)
{
foreach (var mesh in Model.GenericMeshes)
{
bool isSingleBind = false;
if (isSingleBind)
{
for (int v = 0; v < mesh.vertices.Count; v++)
{
var boneId = mesh.vertices[v].boneIds[0];
var transform = G1MSkeleton.GenericSkeleton.bones[boneId].Transform;
mesh.vertices[v].pos = Vector3.TransformPosition(
mesh.vertices[v].pos, transform);
mesh.vertices[v].nrm = Vector3.TransformNormal(
mesh.vertices[v].nrm, transform);
}
}
}
}
}
else if (chunk.Magic == "COLL")
{
}
else if (chunk.Magic == "HAIR")
{
}
else if (chunk.Magic == "NUNO")
{
NUNO = new NUNO(reader, chunk.ChunkVersion);
}
else if (chunk.Magic == "NUNS")
{
}
else if (chunk.Magic == "NUNV")
{
NUNV = new NUNV(reader, chunk.ChunkVersion);
}
else if (chunk.Magic == "EXTR")
{
}
else
{
}
reader.SeekBegin(chunk.ChunkPosition + chunk.ChunkSize);
}
ComputeClothDrivers();
SetLevelOfDetailGroups();
}
public void BindElement(DrawableContainer dc)
{
if (!boundContainers.Contains(dc)) {
boundContainers.Add(dc);
dc.ChildrenChanged += delegate { UpdateFromBoundElements(); };
UpdateFromBoundElements();
}
}
public BlurFilter(DrawableContainer parent) : base(parent)
{
AddField(GetType(), FieldType.BLUR_RADIUS, 15);
AddField(GetType(), FieldType.PREVIEW_QUALITY, 1.0d);
}
public FastSmoothFilter(DrawableContainer parent) : base(parent)
{
AddField(GetType(), FieldType.BLUR_RADIUS, 3);
}
public void UpdateElement(DrawableContainer dc)
{
internalUpdateRunning = true;
foreach(Field field in GetFields()) {
if (dc.HasField(field.FieldType) && field.HasValue) {
//if(LOG.IsDebugEnabled) LOG.Debug(" "+field+ ": "+field.Value);
dc.SetFieldValue(field.FieldType, field.Value);
}
}
internalUpdateRunning = false;
}
public BrightnessFilter(DrawableContainer parent) : base(parent)
{
AddField(GetType(), FieldType.BRIGHTNESS, 0.9d);
}
public override void Load()
{
base.Load();
refreshAudio();
WidgetManager.Root.Add(mainStoryboardContainer = new DrawableContainer(WidgetManager)
{
Drawable = mainStoryboardDrawable = new StoryboardDrawable(project)
{
UpdateFrameStats = true,
},
AnchorTarget = WidgetManager.Root,
AnchorFrom = BoxAlignment.Centre,
AnchorTo = BoxAlignment.Centre,
});
WidgetManager.Root.Add(bottomLeftLayout = new LinearLayout(WidgetManager)
{
AnchorTarget = WidgetManager.Root,
AnchorFrom = BoxAlignment.BottomLeft,
AnchorTo = BoxAlignment.BottomLeft,
Padding = new FourSide(16, 8, 16, 16),
Horizontal = true,
Fill = true,
Children = new Widget[]
{
timeButton = new Button(WidgetManager)
{
StyleName = "small",
AnchorFrom = BoxAlignment.Centre,
Text = "--:--:---",
Tooltip = "Current time\nCtrl-C to copy",
CanGrow = false,
},
divisorButton = new Button(WidgetManager)
{
StyleName = "small",
Text = $"1/{snapDivisor}",
Tooltip = "Snap divisor",
AnchorFrom = BoxAlignment.Centre,
CanGrow = false,
},
audioTimeFactorButton = new Button(WidgetManager)
{
StyleName = "small",
Text = $"{timeSource.TimeFactor:P0}",
Tooltip = "Audio speed",
AnchorFrom = BoxAlignment.Centre,
CanGrow = false,
},
timeline = new TimelineSlider(WidgetManager, project)
{
AnchorFrom = BoxAlignment.Centre,
SnapDivisor = snapDivisor,
},
changeMapButton = new Button(WidgetManager)
{
StyleName = "icon",
Icon = IconFont.FilesO,
Tooltip = "Change beatmap",
AnchorFrom = BoxAlignment.Centre,
CanGrow = false,
},
fitButton = new Button(WidgetManager)
{
StyleName = "icon",
Icon = IconFont.Desktop,
Tooltip = "Fit/Fill",
AnchorFrom = BoxAlignment.Centre,
CanGrow = false,
Checkable = true,
},
playPauseButton = new Button(WidgetManager)
{
StyleName = "icon",
Icon = IconFont.Play,
Tooltip = "Play/Pause\nShortcut: Space",
AnchorFrom = BoxAlignment.Centre,
CanGrow = false,
},
},
});
WidgetManager.Root.Add(bottomRightLayout = new LinearLayout(WidgetManager)
{
AnchorTarget = WidgetManager.Root,
AnchorFrom = BoxAlignment.BottomRight,
AnchorTo = BoxAlignment.BottomRight,
Padding = new FourSide(16, 16, 16, 8),
Horizontal = true,
Fill = true,
Children = new Widget[]
{
effectsButton = new Button(WidgetManager)
{
StyleName = "small",
Text = "Effects",
},
layersButton = new Button(WidgetManager)
{
StyleName = "small",
Text = "Layers",
},
settingsButton = new Button(WidgetManager)
{
StyleName = "small",
Text = "Settings",
},
projectFolderButton = new Button(WidgetManager)
{
StyleName = "icon",
Icon = IconFont.FolderOpen,
Tooltip = "Open project folder",
AnchorFrom = BoxAlignment.Centre,
CanGrow = false,
},
mapsetFolderButton = new Button(WidgetManager)
{
StyleName = "icon",
Icon = IconFont.FolderOpen,
Tooltip = "Open mapset folder\n(Right click to change)",
AnchorFrom = BoxAlignment.Centre,
CanGrow = false,
},
saveButton = new Button(WidgetManager)
{
StyleName = "icon",
Icon = IconFont.Save,
Tooltip = "Save project\nShortcut: Ctrl-S",
AnchorFrom = BoxAlignment.Centre,
CanGrow = false,
},
exportButton = new Button(WidgetManager)
{
StyleName = "icon",
Icon = IconFont.PuzzlePiece,
Tooltip = "Export to .osb\n(Right click to export once for each diff)",
AnchorFrom = BoxAlignment.Centre,
CanGrow = false,
},
},
});
WidgetManager.Root.Add(effectConfigUi = new EffectConfigUi(WidgetManager)
{
AnchorTarget = WidgetManager.Root,
AnchorFrom = BoxAlignment.TopLeft,
AnchorTo = BoxAlignment.TopLeft,
Offset = new Vector2(16, 16),
Displayed = false,
});
effectConfigUi.OnDisplayedChanged += (sender, e) => resizeStoryboard();
WidgetManager.Root.Add(effectsList = new EffectList(WidgetManager, project, effectConfigUi)
{
AnchorTarget = bottomRightLayout,
AnchorFrom = BoxAlignment.BottomRight,
AnchorTo = BoxAlignment.TopRight,
Offset = new Vector2(-16, 0),
});
effectsList.OnEffectPreselect += effect =>
{
if (effect != null)
{
timeline.Highlight(effect.StartTime, effect.EndTime);
}
else
{
timeline.ClearHighlight();
}
};
effectsList.OnEffectSelected += effect => timeline.Value = (float)effect.StartTime / 1000;
WidgetManager.Root.Add(layersList = new LayerList(WidgetManager, project.LayerManager)
{
AnchorTarget = bottomRightLayout,
AnchorFrom = BoxAlignment.BottomRight,
AnchorTo = BoxAlignment.TopRight,
Offset = new Vector2(-16, 0),
});
layersList.OnLayerPreselect += layer =>
{
if (layer != null)
{
timeline.Highlight(layer.StartTime, layer.EndTime);
}
else
{
timeline.ClearHighlight();
}
};
layersList.OnLayerSelected += layer => timeline.Value = (float)layer.StartTime / 1000;
WidgetManager.Root.Add(settingsMenu = new SettingsMenu(WidgetManager, project)
{
AnchorTarget = bottomRightLayout,
AnchorFrom = BoxAlignment.BottomRight,
AnchorTo = BoxAlignment.TopRight,
Offset = new Vector2(-16, 0),
});
WidgetManager.Root.Add(statusLayout = new LinearLayout(WidgetManager)
{
StyleName = "tooltip",
AnchorTarget = bottomLeftLayout,
AnchorFrom = BoxAlignment.BottomLeft,
AnchorTo = BoxAlignment.TopLeft,
Offset = new Vector2(16, 0),
Horizontal = true,
Hoverable = false,
Displayed = false,
Children = new Widget[]
{
statusIcon = new Label(WidgetManager)
{
StyleName = "icon",
AnchorFrom = BoxAlignment.Left,
CanGrow = false,
},
statusMessage = new Label(WidgetManager)
{
AnchorFrom = BoxAlignment.Left,
},
},
});
WidgetManager.Root.Add(warningsLabel = new Label(WidgetManager)
{
StyleName = "tooltip",
AnchorTarget = timeline,
AnchorFrom = BoxAlignment.BottomLeft,
AnchorTo = BoxAlignment.TopLeft,
Offset = new Vector2(0, -8),
});
WidgetManager.Root.Add(previewContainer = new DrawableContainer(WidgetManager)
{
StyleName = "storyboardPreview",
Drawable = previewDrawable = new StoryboardDrawable(project),
AnchorTarget = timeline,
AnchorFrom = BoxAlignment.Bottom,
AnchorTo = BoxAlignment.Top,
Hoverable = false,
Displayed = false,
Size = new Vector2(16, 9) * 16,
});
timeButton.OnClick += (sender, e) => Manager.ShowPrompt("Skip to...", value =>
{
if (float.TryParse(value, out float time))
{
timeline.Value = time / 1000;
}
});
resizeTimeline();
timeline.OnValueChanged += (sender, e) => pendingSeek = timeline.Value;
timeline.OnValueCommited += (sender, e) => timeline.Snap();
timeline.OnHovered += (sender, e) => previewContainer.Displayed = e.Hovered;
changeMapButton.OnClick += (sender, e) =>
{
if (project.MapsetManager.BeatmapCount > 2)
{
Manager.ShowContextMenu("Select a beatmap", beatmap => project.SelectBeatmap(beatmap.Id, beatmap.Name), project.MapsetManager.Beatmaps);
}
else
{
project.SwitchMainBeatmap();
}
};
Program.Settings.FitStoryboard.Bind(fitButton, () => resizeStoryboard());
playPauseButton.OnClick += (sender, e) => timeSource.Playing = !timeSource.Playing;
divisorButton.OnClick += (sender, e) =>
{
snapDivisor++;
if (snapDivisor == 5 || snapDivisor == 7)
{
snapDivisor++;
}
if (snapDivisor == 9)
{
snapDivisor = 12;
}
if (snapDivisor == 13)
{
snapDivisor = 16;
}
if (snapDivisor > 16)
{
snapDivisor = 1;
}
timeline.SnapDivisor = snapDivisor;
divisorButton.Text = $"1/{snapDivisor}";
};
audioTimeFactorButton.OnClick += (sender, e) =>
{
if (e == MouseButton.Left)
{
var speed = timeSource.TimeFactor;
if (speed > 1)
{
speed = 2;
}
speed *= 0.5;
if (speed < 0.2)
{
speed = 1;
}
timeSource.TimeFactor = speed;
}
else if (e == MouseButton.Right)
{
var speed = timeSource.TimeFactor;
if (speed < 1)
{
speed = 1;
}
speed += speed >= 2 ? 1 : 0.5;
if (speed > 8)
{
speed = 1;
}
timeSource.TimeFactor = speed;
}
else if (e == MouseButton.Middle)
{
timeSource.TimeFactor = timeSource.TimeFactor == 8 ? 1 : 8;
}
audioTimeFactorButton.Text = $"{timeSource.TimeFactor:P0}";
};
MakeTabs(
new Button[] { settingsButton, effectsButton, layersButton },
new Widget[] { settingsMenu, effectsList, layersList });
projectFolderButton.OnClick += (sender, e) =>
{
var path = Path.GetFullPath(project.ProjectFolderPath);
if (Directory.Exists(path))
{
Process.Start(path);
}
};
mapsetFolderButton.OnClick += (sender, e) =>
{
var path = Path.GetFullPath(project.MapsetPath);
if (e == MouseButton.Right || !Directory.Exists(path))
{
changeMapsetFolder();
}
else
{
Process.Start(path);
}
};
saveButton.OnClick += (sender, e) => saveProject();
exportButton.OnClick += (sender, e) =>
{
if (e == MouseButton.Right)
{
exportProjectAll();
}
else
{
exportProject();
}
};
project.OnMapsetPathChanged += project_OnMapsetPathChanged;
project.OnEffectsContentChanged += project_OnEffectsContentChanged;
project.OnEffectsStatusChanged += project_OnEffectsStatusChanged;
if (!project.MapsetPathIsValid)
{
Manager.ShowMessage($"The mapset folder cannot be found.\n{project.MapsetPath}\n\nPlease select a new one.", () => changeMapsetFolder(), true);
}
}
public DeleteElementMemento(Surface surface, DrawableContainer drawableContainer)
{
this.surface = surface;
this.drawableContainer = drawableContainer;
}
public BlurFilter(DrawableContainer parent) : base(parent) {
AddField(GetType(), FieldType.BLUR_RADIUS, 3);
AddField(GetType(), FieldType.PREVIEW_QUALITY, 1.0d);
}
public MagnifierFilter(DrawableContainer parent) : base(parent)
{
AddField(GetType(), FieldTypes.MAGNIFICATION_FACTOR, 2);
}
public HighlightFilter(DrawableContainer parent) : base(parent)
{
AddField(GetType(), FieldType.FILL_COLOR, Color.Yellow);
}
public GrayscaleFilter(DrawableContainer parent)
: base(parent)
{
}
public void UnbindElement(DrawableContainer dc)
{
if (boundContainers.Contains(dc)) {
boundContainers.Remove(dc);
UpdateFromBoundElements();
}
}
