/// <summary>
///
/// </summary>
/// <typeparam name="V"></typeparam>
/// <typeparam name="E"></typeparam>
/// <typeparam name="F"></typeparam>
/// <param name="mesh"></param>
/// <param name="position"></param>
private static void QuadSplitGeometry <V, E, F>(HeMeshBase <V, E, F> mesh, Property <V, Vec3d> position)
where V : HeMeshBase <V, E, F> .Vertex
where E : HeMeshBase <V, E, F> .Halfedge
where F : HeMeshBase <V, E, F> .Face
{
// create face vertices
foreach (var f in mesh.Faces)
{
var v = mesh.AddVertex();
if (!f.IsUnused)
{
position.Set(v, f.Vertices.Mean(position.Get));
}
}
// create edge vertices
foreach (var he in mesh.Edges)
{
var v = mesh.AddVertex();
if (!he.IsUnused)
{
position.Set(v, he.Lerp(position.Get, 0.5));
}
}
}
/// <summary>
///
/// </summary>
private static void CatmullClarkSmoothCornerFixed <V, E, F>(HeMeshBase <V, E, F> mesh, Property <V, Vec3d> position)
where V : HeVertex <V, E, F>
where E : Halfedge <V, E, F>
where F : HeFace <V, E, F>
{
var verts = mesh.Vertices;
int ev0 = verts.Count - mesh.Edges.Count; // index of first edge vertex
int fv0 = ev0 - mesh.Faces.Count; // index of first face vertex
// set old vertices
for (int i = 0; i < fv0; i++)
{
var v = verts[i];
if (v.IsRemoved)
{
continue;
}
if (v.IsBoundary)
{
var he0 = v.FirstOut;
if (he0.IsAtDegree2)
{
continue; // skip corner verts
}
var he1 = he0.PrevInFace;
var p0 = position.Get(verts[(he0.Index >> 1) + ev0]);
var p1 = position.Get(verts[(he1.Index >> 1) + ev0]);
position.Set(v, position.Get(v) * 0.5 + (p0 + p1) * 0.25);
}
else
{
Vec3d fsum = new Vec3d();
Vec3d esum = new Vec3d();
int n = 0;
foreach (var he in v.OutgoingHalfedges)
{
fsum += position.Get(verts[he.Face.Index + fv0]);
esum += position.Get(verts[(he.Index >> 1) + ev0]);
n++;
}
double t = 1.0 / n;
position.Set(v, (position.Get(v) * (n - 3) + fsum * t + 2 * esum * t) * t);
}
}
}
public string Settings()
{
User user = new User(); // todo: here you should really load user from the DB
user.UserName = UserName;
if (Request.Method == Method.Post)
{
// load stuff from the web form
foreach (HttpInputItem item in Request.Form["user"])
{
Property.Set(user, item.Name, item.Value == string.Empty ? null : item.Value);
}
// validate input
LocalizedValidator validator = new LocalizedValidator(ValidationLanguage);
NameValueCollection errors = validator.Validate(null, user, Language);
if (errors.Count != 0)
{
return(RenderErrors(errors, "settings", "user", user));
}
// and here you should save it to the database.
// and do something when you are done.
Response.Redirect("/user/");
return(null);
}
// just render the web form.
return(Render("user", user));
}
/// <summary>
///
/// </summary>
private static void CatmullClarkSmoothFixed <V, E, F>(HeMeshBase <V, E, F> mesh, Property <V, Vec3d> position)
where V : HeVertex <V, E, F>
where E : Halfedge <V, E, F>
where F : HeFace <V, E, F>
{
var verts = mesh.Vertices;
int ev0 = verts.Count - mesh.Edges.Count; // index of first edge vertex
int fv0 = ev0 - mesh.Faces.Count; // index of first face vertex
// set old vertices
for (int i = 0; i < fv0; i++)
{
var v = verts[i];
if (v.IsRemoved || v.IsBoundary)
{
continue; // skip boundary verts
}
var fsum = new Vec3d();
var esum = new Vec3d();
int n = 0;
foreach (var he in v.OutgoingHalfedges)
{
fsum += position.Get(verts[he.Face.Index + fv0]);
esum += position.Get(verts[(he.Index >> 1) + ev0]);
n++;
}
var t = 1.0 / n;
position.Set(v, (position.Get(v) * (n - 3) + fsum * t + 2 * esum * t) * t);
}
}
protected void LateUpdate()
{
if (Property.Set(ref isDirty, false))
{
Repaint();
}
}
public void Set(Parametrs value)
{
_name = value.name;
_time = value.time;
Name.Set(_name);
Time.Set(_time.ToString());
}
public virtual bool Update(T obj, bool update, params string[] properties)
{
Type t = GetType();
if (properties != null && properties.Length > 0)
{
foreach (string s in properties)
{
PropertyInfo type = t.GetProperty(s);
if (type.SetMethod != null)
{
Property.Set(this, type.Name, Property.Get(obj, type.Name));
}
}
}
else
{
foreach (PropertyInfo prop in t.GetProperties())
{
if (prop.SetMethod != null)
{
Property.Set(this, prop.Name, Property.Get(obj, prop.Name));
}
//prop.SetValue(this, prop.GetValue(obj));
}
}
if (update)
{
return(Update());
}
return(true);
}
public override void Refresh(User user)
{
Time.Set((user.FinishTime - user.StartTime).ToString());
var rand = new Random();
base.Refresh(user);
}
/// <summary>
///
/// </summary>
/// <typeparam name="V"></typeparam>
/// <typeparam name="E"></typeparam>
/// <typeparam name="F"></typeparam>
/// <param name="mesh"></param>
/// <param name="position"></param>
/// <param name="boundaryType"></param>
private static void CatmullClarkGeometry <V, E, F>(HeMesh <V, E, F> mesh, Property <V, Vec3d> position, SmoothBoundaryType boundaryType)
where V : HeMesh <V, E, F> .Vertex
where E : HeMesh <V, E, F> .Halfedge
where F : HeMesh <V, E, F> .Face
{
var verts = mesh.Vertices;
int fv0 = verts.Count; // index of first face vertex
// create face vertices
foreach (var f in mesh.Faces)
{
var v = mesh.AddVertex();
if (!f.IsUnused)
{
position.Set(v, f.Vertices.Mean(position.Get));
}
}
// create edge vertices
foreach (var he0 in mesh.Edges)
{
var v = mesh.AddVertex();
if (he0.IsUnused)
{
continue;
}
if (he0.IsBoundary)
{
var p = (position.Get(he0.Start) + position.Get(he0.End)) * 0.5;
position.Set(v, p);
continue;
}
var he1 = he0.Twin;
var p0 = position.Get(he0.Start);
var p1 = position.Get(he1.Start);
var p2 = position.Get(verts[he0.Face.Index + fv0]);
var p3 = position.Get(verts[he1.Face.Index + fv0]);
position.Set(v, (p0 + p1 + p2 + p3) * 0.25);
}
// smooth old vertices
CatmullClarkSmooth(mesh, position, boundaryType);
}
/// <summary>
///
/// </summary>
private static void CatmullClarkSmoothFree <V, E, F>(HeMesh <V, E, F> mesh, Property <V, Vector3d> position)
where V : HeMesh <V, E, F> .Vertex
where E : HeMesh <V, E, F> .Halfedge
where F : HeMesh <V, E, F> .Face
{
var verts = mesh.Vertices;
int ev0 = verts.Count - mesh.Edges.Count; // index of first edge vertex
int fv0 = ev0 - mesh.Faces.Count; // index of first face vertex
// set old vertices
for (int i = 0; i < fv0; i++)
{
var v = verts[i];
if (v.IsUnused)
{
continue;
}
if (v.IsBoundary)
{
var he0 = v.First;
var he1 = he0.Previous;
var p0 = position.Get(verts[(he0.Index >> 1) + ev0]);
var p1 = position.Get(verts[(he1.Index >> 1) + ev0]);
position.Set(v, position.Get(v) * 0.5 + (p0 + p1) * 0.25);
}
else
{
Vector3d fsum = new Vector3d();
Vector3d esum = new Vector3d();
int n = 0;
foreach (var he in v.OutgoingHalfedges)
{
fsum += position.Get(verts[he.Face.Index + fv0]);
esum += position.Get(verts[(he.Index >> 1) + ev0]);
n++;
}
double t = 1.0 / n;
position.Set(v, (position.Get(v) * (n - 3) + fsum * t + 2 * esum * t) * t);
}
}
}
public void ShouldSetProperty()
{
var foo = new Foo();
var boo = new Boo();
Property.Set(() => foo.Boo, boo);
Assert.AreSame(boo, foo.Boo);
}
public override void Refresh(User user)
{
IconIndex.Set(user.GetGameZone(x, y).Value);
Count.Set(user.GetOpenedZone(x, y).Value);
var point = new Point(y, x);
Disable.Set(!user.GetOpenedZone(x, y).Value&& !user.Flags.Contains(point));
Flag.Set(!user.GetOpenedZone(x, y).Value&& user.Flags.Contains(point));
}
public void Set_When_SetsProperty()
{
Property property = Create();
DummyData data = new DummyData();
property.Set(data, "123");
Assert.Equal(123, data.Int32);
}
public void ShouldSetPropertyOnInnerProperty()
{
var foo = new Foo {
Boo = new Boo()
};
Property.Set(() => foo.Boo.Name, "changed");
Assert.AreSame("changed", foo.Boo.Name);
}
private void btn_Update_Click(object sender, EventArgs e)
{
KeyValuePair <string, string> item = (KeyValuePair <string, string>)listBox_Property.SelectedItem;
Property.Set(item.Key, txtBox_NewValue.Text);
int index = listBox_Property.SelectedIndex;
ReloadListbox();
listBox_Property.SelectedIndex = index;
}
public void Rebind(THost host, ICollection<TProperty> nullCollection, ICollection<TProperty> collection)
{
var lazyCollection = collection as LazyEntityCollection<TProperty>;
if (lazyCollection != null)
lazyCollection.ItemAdded += x => Property.Set(x, _inverse, host);
foreach (var item in collection)
{
Property.Set(item, _inverse, host);
}
}
public override void Refresh(User user)
{
SizeX.Set(user.XSize.Value);
SizeY.Set(user.YSize.Value);
CellItems.Set((new int[user.XSize.Value * user.YSize.Value]).Select((i, index) => new CellItemViewModel.Parametrs()
{
X = index % user.XSize.Value,
Y = index / user.XSize.Value
}).ToList());
SetFlagCount(user);
SetFlagMode(user);
}
/*
* /// <summary>
* /// Applies a single iteration of Catmull-Clark subdivision to the given mesh.
* /// http://rosettacode.org/wiki/Catmull%E2%80%93Clark_subdivision_surface
* /// http://w3.impa.br/~lcruz/courses/cma/surfaces.html
* /// </summary>
* /// <typeparam name="V"></typeparam>
* /// <typeparam name="E"></typeparam>
* /// <typeparam name="F"></typeparam>
* /// <param name="mesh"></param>
* /// <param name="position"></param>
* /// <param name="boundaryType"></param>
* public static void CatmullClark<V, E, F>(HeMesh<V, E, F> mesh, Property<V, Vec3d> position, SmoothBoundaryType boundaryType, bool parallel)
* where V : HeVertex<V, E, F>
* where E : Halfedge<V, E, F>
* where F : HeFace<V, E, F>
* {
* CatmullClarkGeometry(mesh, position, boundaryType, parallel);
* QuadSplitTopology(mesh);
* }
*
*
* /// <summary>
* ///
* /// </summary>
* private static void CatmullClarkGeometry<V, E, F>(HeMesh<V, E, F> mesh, Property<V, Vec3d> position, SmoothBoundaryType boundaryType, bool parallel)
* where V : HeVertex<V, E, F>
* where E : Halfedge<V, E, F>
* where F : HeFace<V, E, F>
* {
* var verts = mesh.Vertices;
* var edges = mesh.Edges;
* var faces = mesh.Faces;
*
* int fv0 = verts.Count; // index of first face vertex
* int ev0 = verts.Count + faces.Count;
*
* // add all new vertices
* mesh.AddVertices(faces.Count);
* mesh.AddVertices(edges.Count);
*
* // set attributes of face vertices
* Action<Tuple<int, int>> setFaceVerts = range =>
* {
* for (int i = range.Item1; i < range.Item2; i++)
* {
* var f = faces[i];
*
* if (!f.IsRemoved)
* position.Set(verts[i + fv0], f.Vertices.Mean(position.Get));
* }
* };
*
* // set attributes of edge vertices
* Action<Tuple<int, int>> setEdgeVerts = range =>
* {
* for (int i = range.Item1; i < range.Item2; i++)
* {
* var he0 = edges[i];
* if (he0.IsRemoved) continue;
*
* if (he0.IsBoundary)
* {
* position.Set(verts[i + ev0], he0.Lerp(position.Get, 0.5));
* continue;
* }
*
* var he1 = he0.Twin;
* var p0 = position.Get(he0.Start);
* var p1 = position.Get(he1.Start);
* var p2 = position.Get(verts[he0.Face.Index + fv0]);
* var p3 = position.Get(verts[he1.Face.Index + fv0]);
* position.Set(verts[i + ev0], (p0 + p1 + p2 + p3) * 0.25);
* }
* };
*
* // set attributes of old vertices
* //CatmullClarkSmooth(mesh, position, boundaryType);
* Action<Tuple<int, int>> setOldVerts = range =>
* {
* for (int i = range.Item1; i < range.Item2; i++)
* {
* var v = verts[i];
* if (v.IsRemoved) continue;
*
* if (v.IsBoundary)
* {
* var he0 = v.FirstOut;
* var he1 = he0.PrevInFace;
* var p0 = position.Get(verts[(he0.Index >> 1) + ev0]);
* var p1 = position.Get(verts[(he1.Index >> 1) + ev0]);
* position.Set(v, position.Get(v) * 0.5 + (p0 + p1) * 0.25);
* }
* else
* {
* Vec3d fsum = new Vec3d();
* Vec3d esum = new Vec3d();
* int n = 0;
*
* foreach (var he in v.OutgoingHalfedges)
* {
* fsum += position.Get(verts[he.Face.Index + fv0]);
* esum += position.Get(verts[(he.Index >> 1) + ev0]);
* n++;
* }
*
* double t = 1.0 / n;
* position.Set(v, (position.Get(v) * (n - 3) + fsum * t + 2 * esum * t) * t);
* }
* }
* };
*
*
* if (parallel)
* {
* Parallel.ForEach(Partitioner.Create(0, faces.Count), setFaceVerts);
* Parallel.ForEach(Partitioner.Create(0, edges.Count), setEdgeVerts);
* Parallel.ForEach(Partitioner.Create(0, verts.Count), setOldVerts);
* }
* else
* {
* setFaceVerts(Tuple.Create(0, faces.Count));
* setEdgeVerts(Tuple.Create(0, edges.Count));
* setOldVerts(Tuple.Create(0, verts.Count));
* }
* }
*/
#endregion
/// <summary>
/// If using external buffers to store vertex attributes, the number of vertices after subdivision equals the sum of the number of vertices and faces in the initial mesh.
/// </summary>
/// <typeparam name="V"></typeparam>
/// <typeparam name="E"></typeparam>
/// <typeparam name="F"></typeparam>
/// <param name="mesh"></param>
/// <param name="position"></param>
/// <param name="skipBoundary"></param>
public static void Diagonalize <V, E, F>(HeMeshBase <V, E, F> mesh, Property <V, Vec3d> position, bool skipBoundary)
where V : HeVertex <V, E, F>
where E : Halfedge <V, E, F>
where F : HeFace <V, E, F>
{
var edges = mesh.Edges;
var faces = mesh.Faces;
int ne = edges.Count;
int nf = faces.Count;
// stellate faces
for (int i = 0; i < nf; i++)
{
var f = faces[i];
if (f.IsRemoved)
{
continue;
}
var v = mesh.AddVertex();
position.Set(v, f.GetBarycenter(position.Get));
mesh.PokeFaceImpl(f.First, v);
}
// merge faces
if (skipBoundary)
{
for (int i = 0; i < ne; i++)
{
var he = edges[i];
if (he.IsRemoved || he.IsBoundary)
{
continue;
}
mesh.MergeFaces(he);
}
}
else
{
for (int i = 0; i < ne; i++)
{
var he = edges[i];
if (he.IsRemoved)
{
continue;
}
mesh.MergeFaces(he);
}
}
}
/// <summary>
/// 设置脏属性值
/// </summary>
/// <param name="propertyLambda">含类属性的 lambda 表达式</param>
/// <param name="newValue">新属性值</param>
public void SetDirtyValue(Expression <Func <T, object> > propertyLambda, object newValue)
{
IsSelfDirty = true;
Property property = SelfSheet.GetProperty(this.GetType(), Utilities.GetPropertyInfo <T>(propertyLambda).Name);
if (property.Field != null)
{
property.Field.Set(this, newValue);
}
else
{
property.Set(this, newValue);
}
DirtyPropertyNames[property.PropertyInfo.Name] = true;
}
public object this[string key]
{
get { return(_properties[key].Get()); }
set
{
if (!_properties.ContainsKey(key))
{
throw new Exception("You can't add items to this Dictionary.");
}
Property property = _properties[key];
if (!property.CanSet())
{
throw new Exception("The key \"" + key + "\" cannot be set (it is read-only).");
}
property.Set(value);
}
}
private void saveCustomSettings()
{
// Printer
string printer = dbHandler.GetPrinters().Where(p => p.Equals(cb_printers.SelectedItem)).FirstOrDefault();
Property.Set("Setting_PrinterPath", printer);
Property.Set("Printer_TimeOfDay", timePicker_Printer.Value);
Property.Set("Printer_Date", datePicker_Printer.Value);
Property.Set("Printer_Interval", txt_Printer_Interval.Text);
// PDF
Property.Set("PDF_TimeOfDay", timePicker_PDF.Value);
Property.Set("PDF_Date", datePicker_PDF.Value);
Property.Set("PDF_Interval", txt_PDF_Interval.Text);
// Save
Property.Save();
}
public object this[string key]
{
#pragma warning disable IDE0027
get { return(GetEnabledProperty(key).Get()); }
#pragma warning restore
set
{
if (!_properties.ContainsKey(key))
{
throw new Exception("You can't add items to this Dictionary.");
}
Property property = GetEnabledProperty(key);
if (!property.CanSet())
{
throw new Exception("The key \"" + key + "\" cannot be set (it is read-only).");
}
property.Set(value);
}
}
protected override void Action(string[] args)
{
if (args == null)
{
Console.WriteLine("Аргументы переданы с указателем null.");
throw new ArgumentNullException();
}
if (args.Length == 0)
{
try
{
Console.WriteLine($"{Property.Name} = {Property.Get(State)}");
}
catch
{
Console.WriteLine("Не удалось получить значение свойства.");
}
}
else if (Property.TryParse(args[0], out PropertyType value))
{
try
{
if (Property.IsFine(value))
{
Property.Set(State, value);
}
else
{
Console.WriteLine("Не удалось изменить значение свойства.");
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
else
{
Console.WriteLine($"Не удалось преобразовать входной текст в тип {typeof(PropertyType).Name}.");
}
}
public static void DeserializeProperty(BinaryReader rea, PropertyInfo info, object o)
{
Type t = info.PropertyType;
if (t.IsPrimitive)
{
Property.Set(o, info.Name, DeserializePrimitive(rea, info.PropertyType));
}
else if (t.IsList())
{
Property.Set(o, info.Name, DeserializeList(rea, info.PropertyType));
}
else if (t.IsArray)
{
Property.Set(o, info.Name, DeserializeArray(rea, info.PropertyType));
}
else
{
Property.Set(o, info.Name, DeserializeObject(rea, info.PropertyType));
}
}
public FluentPropertyRegistration <TData> WithDefaultValue(TData data)
{
Property.Set(data);
return(this);
}
public void SetReferenceProperty(object obj, object val)
{
Property.Set(obj, SetProperty, val, true);
}
private void check_Warn_CheckedChanged(object sender, EventArgs e)
{
Property.Set("LoggerLevel_WARN", check_Warn.Checked);
}
private void check_Debug_CheckedChanged(object sender, EventArgs e)
{
Property.Set("LoggerLevel_DEBUG", check_Debug.Checked);
}
/// <summary>
///
/// </summary>
/// <typeparam name="UV"></typeparam>
/// <typeparam name="UE"></typeparam>
/// <param name="graph"></param>
/// <param name="setVertex"></param>
/// <param name="setHedge"></param>
/// <param name="componentIndex"></param>
/// <param name="edgeIndex"></param>
/// <returns></returns>
public TG[] CreateConnectedComponents <UV, UE>(HeGraphBase <UV, UE> graph, Action <TV, UV> setVertex, Action <TE, UE> setHedge, Property <UE, int> componentIndex, Property <UE, int> edgeIndex)
where UV : HeVertex <UV, UE>
where UE : Halfedge <UV, UE>
{
var vertices = graph.Vertices;
var hedges = graph.Halfedges;
int ncomp = graph.GetEdgeComponentIndices(componentIndex.Set);
var comps = new TG[ncomp];
// initialize components
for (int i = 0; i < comps.Length; i++)
{
comps[i] = Create();
}
// create component halfedges
for (int i = 0; i < hedges.Count; i += 2)
{
var heA = hedges[i];
if (heA.IsRemoved)
{
continue;
}
var comp = comps[componentIndex.Get(heA)];
var heB = comp.AddEdge();
edgeIndex.Set(heA, heB.Index >> 1);
}
// set component halfedge->halfedge refs
for (int i = 0; i < hedges.Count; i++)
{
var heA0 = hedges[i];
if (heA0.IsRemoved)
{
continue;
}
// the component to which heA0 was copied
var compHedges = comps[componentIndex.Get(heA0)].Halfedges;
var heA1 = heA0.NextAtStart;
// set refs
var heB0 = compHedges[(edgeIndex.Get(heA0) << 1) + (i & 1)];
var heB1 = compHedges[(edgeIndex.Get(heA1) << 1) + (heA1.Index & 1)];
heB0.MakeConsecutive(heB1);
setHedge(heB0, heA0);
}
// create component vertices
for (int i = 0; i < vertices.Count; i++)
{
var vA = vertices[i];
if (vA.IsRemoved)
{
continue;
}
var heA = vA.FirstOut;
var comp = comps[componentIndex.Get(heA)];
var heB = comp.Halfedges[(edgeIndex.Get(heA) << 1) + (heA.Index & 1)];
// set vertex refs
var vB = comp.AddVertex();
vB.FirstOut = heB;
foreach (var he in heB.CirculateStart)
{
he.Start = vB;
}
setVertex(vB, vA);
}
return(comps);
}
public void SetValue(object instance, object val)
{
Property.Set(instance, Info.Name, val);
}
public StudioUI(Studio studio, Sequence sequence, Gui gui, Layer gridLayer, Layer uiLayer)
{
_gui = gui;
// create layers
var studioLayer = Add(new Layer());
var annotationLayer = studioLayer.Add(new Layer());
// fullscreen switch
Add(new KeyBinding(Keys.F1, () => Render.Viewport.IsFullScreen = !Render.Viewport.IsFullScreen));
// tool bars setup
var panel = uiLayer.Add(new StackPanel(5) { Padding = new Margin() });
var horizontalBar = panel.Add(new StackPanel(5) { Padding = new Margin(), Orientation = Orientation.Horizontal });
//var verticalBar = panel.Add(new StackPanel(5));
//uiLayer.Add(new BackgroundView(verticalBar));
// time controls
var timePanel = horizontalBar.Add(new StackPanel(5) { Orientation = Orientation.Horizontal });
uiLayer.Add(new BackgroundView(timePanel));
// camera
var cameraMode = Add(new ToolUI());
cameraMode.Add(new EditorCameraController());
// editor mode / game mode switch
var toolMode = new ToggleComponent(v =>
{
UI.ToolMode.Set(v);
Hgl.Time.IsPaused = v;
gui.Scene.IsFocusable = v;
uiLayer.IsEnabled = v;
});
var pauseButton = timePanel.Add(new ToggleButton(toolMode) { Size = _buttonSize });
uiLayer.Add(new ToggleButonView(pauseButton, DataPack.Textures.Studio.Pause, DataPack.Textures.Studio.Play));
//Add(new PropertyRecorder<bool>("toolMode", toolMode));
Add(new KeyBinding(Keys.Tab, toolMode.Toggle));
Add(new KeyBinding(Keys.Q, Hgl.Time.TogglePause));
// next frame
var nextFrameButton = timePanel.Add(new Button(() => NextFrame(pauseButton)) { Size = _buttonSize });
uiLayer.Add(new PressButtonView(nextFrameButton, DataPack.Textures.Studio.NextFrame));
Add(new KeyBinding(Keys.E, nextFrameButton));
// slow motion
var slowMo = Add(new SlowMotion(pauseButton));
var slowMoButton = timePanel.Add(new Button(slowMo.Start, slowMo.Stop) { Size = _buttonSize });
uiLayer.Add(new PressButtonView(slowMoButton, DataPack.Textures.Studio.SlowMotion));
Add(new KeyBinding(Keys.R, slowMoButton));
// sequence
var seqPanel = horizontalBar.Add(new StackPanel(5) { Orientation = Orientation.Horizontal });
uiLayer.Add(new BackgroundView(seqPanel));
var previousButton = seqPanel.Add(new Button(sequence.Previous) { Size = _buttonSize });
uiLayer.Add(new PressButtonView(previousButton, DataPack.Textures.Studio.Previous));
Add(new KeyBinding(Keys.OemMinus, previousButton));
var nextButton = seqPanel.Add(new Button(sequence.Next) { Size = _buttonSize });
uiLayer.Add(new PressButtonView(nextButton, DataPack.Textures.Studio.Next));
Add(new KeyBinding(Keys.OemPlus, nextButton));
var reloadButton = seqPanel.Add(new Button(() => ReloadCurrentScene(sequence)) { Size = _buttonSize });
uiLayer.Add(new PressButtonView(reloadButton, DataPack.Textures.Studio.Reload));
Add(new KeyBinding(Keys.Back, reloadButton));
// tool bar
var toolBar = horizontalBar.Add(new StackPanel(5) { Orientation = Orientation.Horizontal });
uiLayer.Add(new BackgroundView(toolBar));
// camera home position
var homePosition = new Property<Vector2>();
uiLayer.Add(new PropertyRecorder<Vector2>("homePosition", homePosition));
uiLayer.Add(new KeyBinding(Keys.End, () => homePosition.Set(Render.Camera.Position)));
uiLayer.Add(new KeyBinding(Keys.Home, () => Render.Camera.Position = homePosition.Get()));
// grid
var grid = new Node
{
new Grid(Color.White, size: .1f, minZoomLevel: .02f, fullZoomLevel: 9f),
new Grid(Color.White, size: 1, minZoomLevel: .008f, fullZoomLevel: .8f),
new Grid(Color.White, size: 10, minZoomLevel: .005f, fullZoomLevel: .1f),
new Grid(Color.White, size: 100, minZoomLevel: .001f, fullZoomLevel: .01f),
new Grid(Color.White, size: 1000, minZoomLevel: .0001f, fullZoomLevel: .001f),
};
var gridSwitch = new ToggleComponent(() => gridLayer.Add(grid), () => gridLayer.Remove(grid));
var gridControl = toolBar.Add(new ToggleButton(gridSwitch) { Size = _buttonSize });
Add(gridControl);
uiLayer.Add(new ToggleButonView(gridControl, DataPack.Textures.Studio.Grid));
Add(new PropertyRecorder<bool>("gridState", gridControl));
Add(new KeyBinding(Keys.G, gridControl.Toggle));
// annotation
Add(Annotate.Update);
var annotation = new ToggleComponent(() => annotationLayer.Add(Annotate.Layer), () => annotationLayer.Remove(Annotate.Layer));
var annotationControl = toolBar.Add((new ToggleButton(annotation) { Size = _buttonSize }));
Add(annotationControl);
uiLayer.Add(new ToggleButonView(annotationControl, DataPack.Textures.Studio.Annotate));
Add(new PropertyRecorder<bool>("showAnnotations", annotationControl));
Add(new KeyBinding(Keys.V, annotationControl.Toggle));
// live coding
var liveCodingSwitch = toolBar.Add(new ToggleButton(true, v => LiveComponent.AutoRecompile = v) { Size = _buttonSize });
uiLayer.Add(new ToggleButonView(liveCodingSwitch, DataPack.Textures.Studio.LiveCoding));
Add(new KeyBinding(Keys.L, liveCodingSwitch.Toggle));
// auto-pause on window lost focus
/*
var autoPause = Add(new PauseAuto(pauseButton));
var autoPauseSwitch = toolBar.Add(new CheckBox(autoPause) { Size = _buttonSize });
uiLayer.Add(new IconUI.ToggleButon(autoPauseSwitch, DataPack.Textures.Studio.AutoPause));
Add(new KeyBinding(Keys.OemTilde, autoPauseSwitch.Toggle));
*/
// serialization
var savePanel = horizontalBar.Add(new StackPanel(5) { Orientation = Orientation.Horizontal });
uiLayer.Add(new BackgroundView(savePanel));
var saveButton = savePanel.Add(new Button(studio.Serialize) { Size = _buttonSize });
uiLayer.Add(new PressButtonView(saveButton, DataPack.Textures.Studio.Save));
Add(new KeyBinding(Keys.F6, saveButton));
var loadButton = savePanel.Add(new Button(studio.Unserialize) { Size = _buttonSize });
uiLayer.Add(new PressButtonView(loadButton, DataPack.Textures.Studio.Load));
Add(new KeyBinding(Keys.F7, loadButton));
// edition tools
//var polytool = new PolyEditor();
//UIFocusableControl currentTool;
//var polyButton = verticalBar.Add(new ToggleButton(v => { if (v) currentTool = polytool; }) { Size = _buttonSize });
//var toolButtons = new ToggleButtonList { polyButton };
// tree
/*var tree = new Tree();
uiLayer.Add(tree);*/
// inspector
_inspector = new Inspector();
gui.Scene.NodeSelected += _inspector.Inspect;
//tree.NodeSelected += _inspector.Inspect;
uiLayer.Add(_inspector);
// debug
//Add(new Watch());
Add(new FpsCounter(DataPack.Fonts.StudioFont));
// cursor
_focusCursor = uiLayer.Add(new Cursor(DataPack.Textures.Cursors.Link)
{
IsVisible = false,
Offset = new Vector2(-5, 0)
});
gui.InteractionFocusedChanged += SetFocusCursor;
}
