public void GenerateChildren(ViewModelContext context, IViewModelNode viewModelNode, ref bool handled)
{
if (viewModelNode.NodeValue is EffectOld)
{
viewModelNode.Children.Add(new ViewModelNode("Name", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(EffectOld).GetProperty("Name"))));
viewModelNode.Children.Add(new ViewModelNode("Plugins",
LambdaViewModelContent<EffectPluginDefinition[]>.FromParent<EffectOld>(
effect => effect.Plugins.Select(plugin => new EffectPluginDefinition { PluginType = plugin.GetType().AssemblyQualifiedName }).ToArray())));
}
}
public void GenerateChildren(ViewModelContext context, IViewModelNode viewModelNode, ref bool handled)
{
if (viewModelNode.NodeValue is RenderPass)
{
viewModelNode.Children.Add(new ViewModelNode("Name", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(ComponentBase).GetProperty("Name"))));
viewModelNode.Children.Add(new ViewModelNode("SubPasses", EnumerableViewModelContent.FromUnaryLambda <ViewModelReference, RenderPass>(new ParentNodeValueViewModelContent(),
(renderPass) => renderPass.Passes != null
? renderPass.Passes.Select(x => new ViewModelReference(x, true))
: Enumerable.Empty <ViewModelReference>())));
}
}
public void GenerateChildren(ViewModelContext context, IViewModelNode viewModelNode, ref bool handled)
{
if (viewModelNode.NodeValue is RenderPass)
{
viewModelNode.Children.Add(new ViewModelNode("Name", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(ComponentBase).GetProperty("Name"))));
viewModelNode.Children.Add(new ViewModelNode("SubPasses", EnumerableViewModelContent.FromUnaryLambda<ViewModelReference, RenderPass>(new ParentNodeValueViewModelContent(),
(renderPass) => renderPass.Passes != null
? renderPass.Passes.Select(x => new ViewModelReference(x, true))
: Enumerable.Empty<ViewModelReference>())));
}
}
public void GenerateChildren(ViewModelContext context, IViewModelNode viewModelNode, ref bool handled)
{
if (viewModelNode.NodeValue is EffectOld)
{
viewModelNode.Children.Add(new ViewModelNode("Name", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(EffectOld).GetProperty("Name"))));
viewModelNode.Children.Add(new ViewModelNode("Plugins",
LambdaViewModelContent <EffectPluginDefinition[]> .FromParent <EffectOld>(
effect => effect.Plugins.Select(plugin => new EffectPluginDefinition {
PluginType = plugin.GetType().AssemblyQualifiedName
}).ToArray())));
}
}
public void GenerateChildren(ViewModelContext context, IViewModelNode viewModelNode, ref bool handled)
{
if (viewModelNode.NodeValue is RenderPassPlugin)
{
var pluginType = viewModelNode.NodeValue.GetType();
foreach (var propertyInfo in pluginType.GetProperties(BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Instance))
{
IViewModelContent viewModelContent = new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), propertyInfo);
if (propertyInfo.PropertyType == typeof(RenderPass) || propertyInfo.PropertyType.IsSubclassOf(typeof(RenderPass)))
{
viewModelContent = LambdaViewModelContent <ViewModelReference> .FromOperand <RenderPass>(viewModelContent, x => new ViewModelReference(x, false));
}
else if (!propertyInfo.PropertyType.IsValueType || !propertyInfo.PropertyType.FullName.StartsWith("System."))
{
continue;
}
viewModelNode.Children.Add(new ViewModelNode(propertyInfo.Name, viewModelContent));
}
foreach (var fieldinfo in pluginType.GetFields(BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Instance))
{
IViewModelContent viewModelContent = new FieldInfoViewModelContent(new ParentNodeValueViewModelContent(pluginType), fieldinfo);
//if (fieldinfo.FieldType.IsValueType && !fieldinfo.FieldType.IsPrimitive && !fieldinfo.FieldType.IsEnum)
// viewModelContent.Flags = ViewModelFlags.None;
viewModelNode.Children.Add(new ViewModelNode(fieldinfo.Name, viewModelContent).GenerateChildren(context));
}
}
#if PARADOX_YEBIS
else if (viewModelNode.Type.Namespace == typeof(ToneMap).Namespace &&
viewModelNode.Type.IsValueType && !viewModelNode.Type.IsPrimitive && !viewModelNode.Type.IsEnum)
{
// Use default for those types
foreach (var fieldinfo in viewModelNode.Type.GetFields(BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Instance))
{
IViewModelContent viewModelContent = new FieldInfoViewModelContent(new ParentValueViewModelContent(viewModelNode.Type), fieldinfo);
//if (fieldinfo.FieldType.IsValueType && !fieldinfo.FieldType.IsPrimitive && !fieldinfo.FieldType.IsEnum)
// viewModelContent.Flags = ViewModelFlags.None;
// Doesn't support array
if (fieldinfo.FieldType.IsArray)
{
continue;
}
viewModelNode.Children.Add(new ViewModelNode(fieldinfo.Name, viewModelContent).GenerateChildren(context));
}
}
#endif
}
public void GenerateChildren(ViewModelContext context, IViewModelNode viewModelNode, ref bool handled)
{
if (viewModelNode.NodeValue is RenderPassPlugin)
{
viewModelNode.Children.Add(new ViewModelNode("Name", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(ComponentBase).GetProperty("Name"))));
viewModelNode.Children.Add(new ViewModelNode("EventOpen", new RootViewModelContent((ExecuteCommand)((viewModel2, parameter) =>
{
SelectedRenderPassPluginContext.ViewModelByGuid.Clear();
//SelectedRenderPassPluginContext.Root = SelectedRenderPassPluginContext.GetModelView(viewModel2.Parent.NodeValue);
SelectedRenderPassPluginContext.Root = new ViewModelNode("Root", new RootViewModelContent(new[] { new ViewModelReference(viewModel2.Parent.NodeValue, true) }, typeof(IList<ViewModelReference>)));
//SelectedRenderPassPluginContext.GetModelView(viewModel2.Parent.NodeValue);
}))));
handled = true;
}
}
public void GenerateChildren(ViewModelContext context, IViewModelNode viewModelNode, ref bool handled)
{
if (viewModelNode.NodeValue is RenderPassPlugin)
{
viewModelNode.Children.Add(new ViewModelNode("Name", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(ComponentBase).GetProperty("Name"))));
viewModelNode.Children.Add(new ViewModelNode("EventOpen", new RootViewModelContent((ExecuteCommand)((viewModel2, parameter) =>
{
SelectedRenderPassPluginContext.ViewModelByGuid.Clear();
//SelectedRenderPassPluginContext.Root = SelectedRenderPassPluginContext.GetModelView(viewModel2.Parent.NodeValue);
SelectedRenderPassPluginContext.Root = new ViewModelNode("Root", new RootViewModelContent(new[] { new ViewModelReference(viewModel2.Parent.NodeValue, true) }, typeof(IList <ViewModelReference>)));
//SelectedRenderPassPluginContext.GetModelView(viewModel2.Parent.NodeValue);
}))));
handled = true;
}
}
public void GenerateChildren(ViewModelContext context, IViewModelNode viewModelNode, ref bool handled)
{
if (viewModelNode.NodeValue is EffectBuilder)
{
viewModelNode.Children.Add(new ViewModelNode("Name", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(EffectBuilder).GetProperty("Name"))));
viewModelNode.Children.Add(new ViewModelNode("EventOpen", new RootViewModelContent((ExecuteCommand)((viewModel2, parameter) =>
{
selectedEntitiesContext.ViewModelByGuid.Clear();
selectedEntitiesContext.Root = selectedEntitiesContext.GetModelView(viewModel2.Parent.NodeValue);
}))));
viewModelNode.Children.Add(new ViewModelNode("Definition", new AsyncViewModelContent <EffectDefinition>(new ParentNodeValueViewModelContent(),
operand => new EffectDefinition
{
Plugins = ((EffectBuilder)operand.Value).Plugins.Select(x =>
{
var pluginDefinition = new EffectPluginDefinition
{
PluginType = x.GetType().AssemblyQualifiedName,
Parameters = new Dictionary <string, EffectParameterDefinition>()
};
foreach (var property in x.GetType().GetProperties(BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Instance))
{
if (property.GetCustomAttributes(typeof(EffectDefinitionPropertyAttribute), true).Length == 0)
{
continue;
}
// Check type and do some simple conversion
var value = property.GetValue(x, null);
if (typeof(RenderPassPlugin).IsAssignableFrom(property.PropertyType))
{
value = Guid.NewGuid();
}
else if (!typeof(ShaderSource).IsAssignableFrom(property.PropertyType) &&
!property.PropertyType.IsValueType)
{
throw new NotSupportedException();
}
pluginDefinition.Parameters.Add(property.Name, new EffectParameterDefinition(property.PropertyType, value));
}
return(pluginDefinition);
}).ToList()
})));
//new AsyncViewModelContent<EffectDefinition>(() => ) { LoadState = ViewModelContentState.NotLoaded, Flags = ViewModelFlags.Static | ViewModelFlags.Async | ViewModelFlags.Serialize });
}
}
public void GenerateChildren(ViewModelContext context, IViewModelNode viewModelNode, ref bool handled)
{
if (viewModelNode.NodeValue is MicroThread)
{
viewModelNode.Children.Add(new ViewModelNode("Id", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(MicroThread).GetProperty("Id"))));
viewModelNode.Children.Add(new ViewModelNode("Name", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(MicroThread).GetProperty("Name"))));
viewModelNode.Children.Add(new ViewModelNode("ScriptName",
LambdaViewModelContent <string> .FromParent <MicroThread>(x => x.Get(ScriptManager.ScriptEntryProperty).TypeName)));
viewModelNode.Children.Add(new ViewModelNode("EventOpen", new RootViewModelContent((ExecuteCommand)((viewModel2, parameter) =>
{
selectedEntitiesContext.ViewModelByGuid.Clear();
selectedEntitiesContext.Root = selectedEntitiesContext.GetModelView(viewModel2.Parent.NodeValue);
}))));
handled = true;
}
}
public void GenerateChildren(ViewModelContext context, IViewModelNode viewModelNode, ref bool handled)
{
if (viewModelNode.NodeValue is MicroThread)
{
viewModelNode.Children.Add(new ViewModelNode("Id", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(MicroThread).GetProperty("Id"))));
viewModelNode.Children.Add(new ViewModelNode("Name", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(MicroThread).GetProperty("Name"))));
viewModelNode.Children.Add(new ViewModelNode("ScriptName",
LambdaViewModelContent<string>.FromParent<MicroThread>(x => x.Get(ScriptManager.ScriptEntryProperty).TypeName)));
viewModelNode.Children.Add(new ViewModelNode("EventOpen", new RootViewModelContent((ExecuteCommand)((viewModel2, parameter) =>
{
selectedEntitiesContext.ViewModelByGuid.Clear();
selectedEntitiesContext.Root = selectedEntitiesContext.GetModelView(viewModel2.Parent.NodeValue);
}))));
handled = true;
}
}
public void GenerateChildren(ViewModelContext context, IViewModelNode viewModelNode, ref bool handled)
{
if (viewModelNode.NodeValue is EffectBuilder)
{
viewModelNode.Children.Add(new ViewModelNode("Name", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(EffectBuilder).GetProperty("Name"))));
viewModelNode.Children.Add(new ViewModelNode("EventOpen", new RootViewModelContent((ExecuteCommand)((viewModel2, parameter) =>
{
selectedEntitiesContext.ViewModelByGuid.Clear();
selectedEntitiesContext.Root = selectedEntitiesContext.GetModelView(viewModel2.Parent.NodeValue);
}))));
viewModelNode.Children.Add(new ViewModelNode("Definition", new AsyncViewModelContent<EffectDefinition>(new ParentNodeValueViewModelContent(),
operand => new EffectDefinition
{
Plugins = ((EffectBuilder)operand.Value).Plugins.Select(x =>
{
var pluginDefinition = new EffectPluginDefinition
{
PluginType = x.GetType().AssemblyQualifiedName,
Parameters = new Dictionary<string, EffectParameterDefinition>()
};
foreach (var property in x.GetType().GetProperties(BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Instance))
{
if (property.GetCustomAttributes(typeof(EffectDefinitionPropertyAttribute), true).Length == 0)
continue;
// Check type and do some simple conversion
var value = property.GetValue(x, null);
if (typeof(RenderPassPlugin).IsAssignableFrom(property.PropertyType))
{
value = Guid.NewGuid();
}
else if (!typeof(ShaderSource).IsAssignableFrom(property.PropertyType)
&& !property.PropertyType.IsValueType)
{
throw new NotSupportedException();
}
pluginDefinition.Parameters.Add(property.Name, new EffectParameterDefinition(property.PropertyType, value));
}
return pluginDefinition;
}).ToList()
})));
//new AsyncViewModelContent<EffectDefinition>(() => ) { LoadState = ViewModelContentState.NotLoaded, Flags = ViewModelFlags.Static | ViewModelFlags.Async | ViewModelFlags.Serialize });
}
}
public void GenerateChildren(ViewModelContext context, IViewModelNode viewModelNode, ref bool handled)
{
if (viewModelNode.NodeValue is RenderPassPlugin)
{
var pluginType = viewModelNode.NodeValue.GetType();
foreach (var propertyInfo in pluginType.GetProperties(BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Instance))
{
IViewModelContent viewModelContent = new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), propertyInfo);
if (propertyInfo.PropertyType == typeof(RenderPass) || propertyInfo.PropertyType.IsSubclassOf(typeof(RenderPass)))
viewModelContent = LambdaViewModelContent<ViewModelReference>.FromOperand<RenderPass>(viewModelContent, x => new ViewModelReference(x, false));
else if (!propertyInfo.PropertyType.IsValueType || !propertyInfo.PropertyType.FullName.StartsWith("System."))
continue;
viewModelNode.Children.Add(new ViewModelNode(propertyInfo.Name, viewModelContent));
}
foreach (var fieldinfo in pluginType.GetFields( BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Instance))
{
IViewModelContent viewModelContent = new FieldInfoViewModelContent(new ParentNodeValueViewModelContent(pluginType), fieldinfo);
//if (fieldinfo.FieldType.IsValueType && !fieldinfo.FieldType.IsPrimitive && !fieldinfo.FieldType.IsEnum)
// viewModelContent.Flags = ViewModelFlags.None;
viewModelNode.Children.Add(new ViewModelNode(fieldinfo.Name, viewModelContent).GenerateChildren(context));
}
}
#if PARADOX_YEBIS
else if (viewModelNode.Type.Namespace == typeof(ToneMap).Namespace
&& viewModelNode.Type.IsValueType && !viewModelNode.Type.IsPrimitive && !viewModelNode.Type.IsEnum)
{
// Use default for those types
foreach (var fieldinfo in viewModelNode.Type.GetFields(BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Instance))
{
IViewModelContent viewModelContent = new FieldInfoViewModelContent(new ParentValueViewModelContent(viewModelNode.Type), fieldinfo);
//if (fieldinfo.FieldType.IsValueType && !fieldinfo.FieldType.IsPrimitive && !fieldinfo.FieldType.IsEnum)
// viewModelContent.Flags = ViewModelFlags.None;
// Doesn't support array
if (fieldinfo.FieldType.IsArray)
continue;
viewModelNode.Children.Add(new ViewModelNode(fieldinfo.Name, viewModelContent).GenerateChildren(context));
}
}
#endif
}
public void GenerateChildren(ViewModelContext context, IViewModelNode viewModelNode, ref bool handled)
{
var type = viewModelNode.Type;
if (viewModelNode.NodeValue is ScriptAssembly)
{
viewModelNode.Children.Add(new ViewModelNode("Url", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(ScriptAssembly).GetProperty("Url"))));
viewModelNode.Children.Add(new ViewModelNode("Scripts", EnumerableViewModelContent.FromUnaryLambda<ViewModelReference, ScriptAssembly>(new ParentNodeValueViewModelContent(),
(scriptAssembly) => scriptAssembly.Scripts.Select(x => new ViewModelReference(x, true)))));
handled = true;
}
if (viewModelNode.NodeValue is ScriptEntry2)
{
viewModelNode.Children.Add(new ViewModelNode("TypeName", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(ScriptEntry2).GetProperty("TypeName"))));
viewModelNode.Children.Add(new ViewModelNode("MethodName", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(ScriptEntry2).GetProperty("MethodName"))));
viewModelNode.Children.Add(new ViewModelNode("Run", new RootViewModelContent((ExecuteCommand)((viewModel2, parameter) =>
{
var scriptEntry = (ScriptEntry2)viewModel2.Parent.NodeValue;
var microThread = engineContext.ScriptManager.RunScript(scriptEntry, null);
}))));
handled = true;
}
}
public void GenerateChildren(ViewModelContext context, IViewModelNode viewModelNode, ref bool handled)
{
var type = viewModelNode.Type;
if (viewModelNode.NodeValue is ScriptAssembly)
{
viewModelNode.Children.Add(new ViewModelNode("Url", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(ScriptAssembly).GetProperty("Url"))));
viewModelNode.Children.Add(new ViewModelNode("Scripts", EnumerableViewModelContent.FromUnaryLambda <ViewModelReference, ScriptAssembly>(new ParentNodeValueViewModelContent(),
(scriptAssembly) => scriptAssembly.Scripts.Select(x => new ViewModelReference(x, true)))));
handled = true;
}
if (viewModelNode.NodeValue is ScriptEntry2)
{
viewModelNode.Children.Add(new ViewModelNode("TypeName", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(ScriptEntry2).GetProperty("TypeName"))));
viewModelNode.Children.Add(new ViewModelNode("MethodName", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(ScriptEntry2).GetProperty("MethodName"))));
viewModelNode.Children.Add(new ViewModelNode("Run", new RootViewModelContent((ExecuteCommand)((viewModel2, parameter) =>
{
var scriptEntry = (ScriptEntry2)viewModel2.Parent.NodeValue;
var microThread = engineContext.ScriptManager.RunScript(scriptEntry, null);
}))));
handled = true;
}
}
public void GenerateChildren(ViewModelContext context, IViewModelNode viewModelNode, ref bool handled)
{
if (viewModelNode.NodeValue is Entity)
{
viewModelNode.Children.Add(new ViewModelNode("Name", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(Entity).GetProperty("Name"))));
viewModelNode.Children.Add(new ViewModelNode("Guid", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(Entity).GetProperty("Guid"))));
viewModelNode.Children.Add(new ViewModelNode("IsSelected", new PropertyKeyViewModelContent(new ParentNodeValueViewModelContent(), isSelectedProperty)));
viewModelNode.Children.Add(new ViewModelNode("ParentReference", LambdaViewModelContent <ViewModelReference> .FromParent <Entity>(x =>
{
var transformationComponent = x.Transformation;
var parent = transformationComponent != null ? transformationComponent.Parent : null;
return(new ViewModelReference(parent != null ? parent.Entity : null));
})));
viewModelNode.Children.Add(new ViewModelNode("HierarchicalEntities", EnumerableViewModelContent.FromUnaryLambda <ViewModelReference, Entity>(new ParentNodeValueViewModelContent(),
(entity) =>
{
var result = Enumerable.Empty <ViewModelReference>();
// Enumerates children nodes
var transformationComponent = entity.Transformation;
if (transformationComponent != null)
{
result = result.Concat(transformationComponent.Children
.Select(x => new ViewModelReference(x.Entity, true)));
}
// Enumerates EffectMesh
var meshComponent = entity.Get(ModelComponent.Key);
if (meshComponent != null && meshComponent.InstantiatedSubMeshes != null)
{
result = result.Concat(meshComponent.InstantiatedSubMeshes.Select((x, i) =>
{
effectMeshIndices.GetOrCreateValue(x.Value).Index = i;
return(new ViewModelReference(x.Value, true));
}));
}
return(result);
})));
viewModelNode.Children.Add(new ViewModelNode("EventOpen", new RootViewModelContent((ExecuteCommand)((viewModel2, parameter) =>
{
ScriptDebug.SelectEntity((Entity)viewModel2.Parent.NodeValue);
}))));
viewModelNode.Children.Add(new ViewModelNode("CreateNewEntity", new RootViewModelContent((ExecuteCommand)((viewModel2, parameter) =>
{
var entity = (Entity)viewModel2.Parent.NodeValue;
var newEntity = new Entity("New Entity");
entity.Transformation.Children.Add(newEntity.Transformation);
}))));
viewModelNode.Children.Add(new ViewModelNode("Remove", new RootViewModelContent((ExecuteCommand)((viewModel2, parameter) =>
{
var entity = (Entity)viewModel2.Parent.NodeValue;
EntitySystem.Remove(entity);
}))));
handled = true;
}
else if (viewModelNode.NodeValue is EffectMesh)
{
viewModelNode.Children.Add(new ViewModelNode("Name", new LambdaViewModelContent <string>(new NullViewModelContent(), (content) =>
{
var effectMesh = (EffectMesh)content.OwnerNode.Parent.NodeValue;
var result = effectMeshIndices.GetOrCreateValue(effectMesh).Index.ToString();
if (effectMesh.Name != null)
{
result += " - " + effectMesh.Name;
}
return(result);
})));
viewModelNode.Children.Add(new ViewModelNode("EventOpen", new RootViewModelContent((ExecuteCommand)((viewModel2, parameter) =>
{
selectedEntitiesContext.ViewModelByGuid.Clear();
selectedEntitiesContext.Root = new ViewModelNode("Root", new RootViewModelContent(new[] { new ViewModelReference(viewModel2.Parent.NodeValue, true) }, typeof(IList <ViewModelReference>)));
}))));
handled = true;
}
}
/// <summary>
/// Display components that are tagged with the <see cref="DisplayAttribute"/>.
/// </summary>
/// <param name="context">Context of the view model.</param>
/// <param name="viewModel">The current view model</param>
/// <param name="component">The entity component to display</param>
private void AutoDisplayComponent(ViewModelContext context, IViewModelNode viewModel, EntityComponent component)
{
var displayComp = DisplayAttribute.GetDisplay(component.GetType());
if (displayComp == null)
{
return;
}
var componentViewModel = viewModel.GetChildrenByName("Component");
if (componentViewModel == null)
{
return;
}
// Change the name of the component being displayed
if (!string.IsNullOrEmpty(displayComp.Name))
{
var componentName = viewModel.GetChildrenByName("PropertyKeyName");
if (componentName != null)
{
componentName.Value = displayComp.Name;
}
}
var propertyToDisplay = new List <Tuple <DisplayAttribute, ViewModelNode> >();
var memberInfos = new List <MemberInfo>();
memberInfos.AddRange(component.GetType().GetProperties());
memberInfos.AddRange(component.GetType().GetFields());
// Process fields and properties
foreach (var property in memberInfos)
{
var display = DisplayAttribute.GetDisplay(property);
if (display == null)
{
continue;
}
IViewModelContent modelContent = null;
object modelValue = null;
var propertyInfo = property as PropertyInfo;
if (propertyInfo != null)
{
if (typeof(ParameterCollection).IsAssignableFrom(propertyInfo.PropertyType))
{
modelValue = propertyInfo.GetValue(component, null);
}
else
{
modelContent = new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), propertyInfo);
}
}
var fieldInfo = property as FieldInfo;
if (fieldInfo != null)
{
if (typeof(ParameterCollection).IsAssignableFrom(fieldInfo.FieldType))
{
modelValue = fieldInfo.GetValue(component);
}
else
{
modelContent = new FieldInfoViewModelContent(new ParentNodeValueViewModelContent(), fieldInfo);
}
}
var propertyViewModel = modelValue != null ? new ViewModelNode(display.Name ?? property.Name, modelValue) : new ViewModelNode(display.Name ?? property.Name, modelContent);
propertyViewModel.GenerateChildren(context);
propertyToDisplay.Add(new Tuple <DisplayAttribute, ViewModelNode>(display, propertyViewModel));
}
foreach (var item in propertyToDisplay.OrderBy((left) => left.Item1.Order))
{
componentViewModel.Children.Add(item.Item2);
}
}
public void GenerateChildren(ViewModelContext context, IViewModelNode viewModelNode, ref bool handled)
{
bool handleValueType = false;
if (viewModelNode.NodeValue is MicroThread)
{
var microThread = (MicroThread)viewModelNode.NodeValue;
var script = microThread.Get(ScriptManager.ScriptProperty);
viewModelNode.Content = new EnumerableViewModelContent <ViewModelReference>(() => new[] { new ViewModelReference(script, true) });
handled = true;
}
else if (viewModelNode.NodeValue is IScript)
{
var script = (IScript)viewModelNode.NodeValue;
// Expose all variables of IScript (defined by user)
foreach (var property in script.GetType().GetProperties())
{
if (property.PropertyType != typeof(int) && property.PropertyType != typeof(float))
{
continue;
}
viewModelNode.Children.Add(new ViewModelNode(property.Name, new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), property)));
}
handled = true;
}
else if (viewModelNode.NodeValue is Entity)
{
ViewModelNode componentsViewModelNode;
viewModelNode.Children.Add(new ViewModelNode("Name", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(Entity).GetProperty("Name"))));
viewModelNode.Children.Add(new ViewModelNode("Guid", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(Entity).GetProperty("Guid"))));
viewModelNode.Children.Add(componentsViewModelNode = new ViewModelNode("Components", EnumerableViewModelContent.FromUnaryLambda <ViewModelReference, Entity>(new ParentNodeValueViewModelContent(),
(entity) => entity.Properties
.Select(x => x.Value)
.OfType <EntityComponent>()
.Select(x => new ViewModelReference(x, true)))));
var availableKeysContent = new RootViewModelContent(null, typeof(string[]));
componentsViewModelNode.Children.Add(new ViewModelNode("AvailableKeys", availableKeysContent));
componentsViewModelNode.Children.Add(new ViewModelNode("RequestKeys", new RootViewModelContent((ExecuteCommand)((viewModel2, parameter) =>
{
var availableComponentKeys = new List <string>();
// TODO: Improve component keys enumeration (maybe need a registry?)
// For now, scan assemblies for all types inheriting from EntityComponent
foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
{
foreach (var type in assembly.GetTypes())
{
if (type.IsSubclassOf(typeof(EntityComponent)) &&
type.GetField("Key", BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy) != null)
{
availableComponentKeys.Add(type.AssemblyQualifiedName);
}
}
}
availableKeysContent.Value = availableComponentKeys.ToArray();
}))));
componentsViewModelNode.Children.Add(new ViewModelNode("Add", new RootViewModelContent((ExecuteCommand)((viewModel2, parameter) =>
{
var entity = (Entity)viewModel2.Parent.Parent.NodeValue;
var componentType = Type.GetType((string)parameter);
// For now, assume it will be stored in a PropertyKey inside the actual component named "Key"
var componentKeyField = componentType.GetField("Key", BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy);
entity.SetObject((PropertyKey)componentKeyField.GetValue(null), Activator.CreateInstance(componentType));
}))));
handled = true;
}
else if (viewModelNode.NodeValue is EntityComponent)
{
viewModelNode.PropertyName = "EntityComponent";
var component = (EntityComponent)viewModelNode.NodeValue;
// Would be better higher in the hierarchy, but it would complicate model
var propertyKey = component.Entity.Properties.First(x => x.Value == component).Key;
var propertyKeyName = propertyKey.OwnerType.Name;
viewModelNode.Children.Add(new ViewModelNode("PropertyKeyName", new RootViewModelContent(propertyKeyName)));
viewModelNode.Children.Add(new ViewModelNode("Remove", new RootViewModelContent((ExecuteCommand)((viewModel2, parameter) =>
{
component.Entity.SetObject(propertyKey, null);
}))));
var componentViewModel = new ViewModelNode("Component", component);
viewModelNode.Children.Add(componentViewModel);
if (component is TransformationComponent)
{
componentViewModel.Children.Add(new ViewModelNode("WorldMatrix", new FieldInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(TransformationComponent).GetField("WorldMatrix"))).GenerateChildren(context));
// TODO: How to switch view model depending on TransformationComponent.Values type? Or should we always expose everything?
componentViewModel.Children.Add(new ViewModelNode("LocalMatrix", new FieldInfoViewModelContent(new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(TransformationComponent).GetProperty("Value")), typeof(TransformationValue).GetField("LocalMatrix"))).GenerateChildren(context));
//if (((TransformationComponent)component).Values is TransformationTRS)
{
componentViewModel.Children.Add(new ViewModelNode("Translation", new FieldInfoViewModelContent(new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(TransformationComponent).GetProperty("Value")), typeof(TransformationTRS).GetField("Translation"))).GenerateChildren(context));
componentViewModel.Children.Add(new ViewModelNode("Rotation", new FieldInfoViewModelContent(new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(TransformationComponent).GetProperty("Value")), typeof(TransformationTRS).GetField("Rotation"))).GenerateChildren(context));
componentViewModel.Children.Add(new ViewModelNode("Scaling", new FieldInfoViewModelContent(new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(TransformationComponent).GetProperty("Value")), typeof(TransformationTRS).GetField("Scaling"))).GenerateChildren(context));
}
componentViewModel.Children.Add(new ViewModelNode("Parent", LambdaViewModelContent <ViewModelReference> .FromOperand <EntityComponent>(new ParentNodeValueViewModelContent(), x => new ViewModelReference(x.Entity, false))));
componentViewModel.Children.Last().Children.Add(new ViewModelNode("SetAsRoot", new RootViewModelContent((ExecuteCommand)((viewModel2, parameter) =>
{
context.ViewModelByGuid.Clear();
context.Root = context.GetModelView(((TransformationComponent)component).Parent.Entity).Children.First(x => x.PropertyName == "Components");
}))));
}
if (component is ModelComponent)
{
componentViewModel.Children.Add(new ViewModelNode("Parameters", ((ModelComponent)component).MeshParameters).GenerateChildren(context));
//componentViewModel.Children.Add(new ViewModelNode(
// "MeshParameters",
// EnumerableViewModelContent.FromUnaryLambda<ViewModelReference, ModelComponent>(
// new ParentNodeValueViewModelContent(),
// (ModelComponent) => ModelComponent.MeshParameters.Keys.Select(key => new ViewModelReference(Tuple.Create(ModelComponent.MeshParameters, key), true)))));
}
if (component is LightComponent)
{
componentViewModel.Children.Add(new ViewModelNode("Type", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(LightComponent).GetProperty("Type"))).GenerateChildren(context));
componentViewModel.Children.Add(new ViewModelNode("ShadowMap", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(LightComponent).GetProperty("ShadowMap"))).GenerateChildren(context));
componentViewModel.Children.Add(new ViewModelNode("Deferred", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(LightComponent).GetProperty("Deferred"))).GenerateChildren(context));
componentViewModel.Children.Add(new ViewModelNode("Intensity", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(LightComponent).GetProperty("Intensity"))).GenerateChildren(context));
componentViewModel.Children.Add(new ViewModelNode("DecayStart", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(LightComponent).GetProperty("DecayStart"))).GenerateChildren(context));
componentViewModel.Children.Add(new ViewModelNode("Color", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(LightComponent).GetProperty("Color"))).GenerateChildren(context));
componentViewModel.Children.Add(new ViewModelNode("LightDirection", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(LightComponent).GetProperty("LightDirection"))).GenerateChildren(context));
}
if (component is LightShaftsComponent)
{
componentViewModel.Children.Add(new ViewModelNode("Color", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(LightShaftsComponent).GetProperty("Color"))).GenerateChildren(context));
//componentViewModel.Children.Add(new ViewModelNode("LightShaftsBoundingBoxes", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(LightShaftsComponent).GetProperty("LightShaftsBoundingBoxes"))).GenerateChildren(context));
}
// Else try to display it using auto-display
AutoDisplayComponent(context, viewModelNode, component);
handled = true;
}
else if (viewModelNode.NodeValue is ParameterCollection)
{
viewModelNode.Content = EnumerableViewModelContent.FromUnaryLambda <ViewModelReference, ParameterCollection>(new NodeValueViewModelContent(), (parameterCollection) =>
parameterCollection.Keys.Where(key => key.PropertyType.IsValueType).Select(key =>
{
if (key.PropertyType.IsValueType)
{
// For value type, generated tree won't change so make value based on key only.
return(new ViewModelReference(Tuple.Create(parameterCollection, key), true));
}
else
{
// TODO: resources currently ignored (until fixed)
// For reference type, make value dependent on actual value reference and source.
// This will trigger a regeneration for reference change (i.e. new texture bound).
// Useful since asset type/state might be different.
var value = parameterCollection.GetObject(key);
var valueSource = engineContext.AssetManager.Url.Get(value);
return(new ViewModelReference(Tuple.Create(parameterCollection, key, valueSource), true));
}
}));
var availableKeysContent = new RootViewModelContent(null, typeof(string[]));
viewModelNode.Children.Add(new ViewModelNode("AvailableKeys", availableKeysContent));
viewModelNode.Children.Add(new ViewModelNode("RequestKeys", new RootViewModelContent((ExecuteCommand)((viewModel2, parameter) =>
{
var parameterCollection = (ParameterCollection)viewModel2.Parent.NodeValue;
var effectMesh = viewModel2.Parent.Parent.NodeValue as EffectMesh;
if (effectMesh != null)
{
var availableKeys = effectMesh.Effect.Passes.SelectMany(x => x.DefaultParameters.Parameters.Select(y => y.Key)).Distinct().Where(x => !parameterCollection.IsValueOwner(x)).Select(x => x.Name).ToArray();
availableKeysContent.Value = availableKeys;
}
}))));
viewModelNode.Children.Add(new ViewModelNode("Add", new RootViewModelContent((ExecuteCommand)((viewModel2, parameter) =>
{
var effectMesh = viewModel2.Parent.Parent.NodeValue as EffectMesh;
if (effectMesh != null)
{
var key = effectMesh.Effect.Passes.SelectMany(x => x.DefaultParameters.Parameters.Select(y => y.Key)).FirstOrDefault(x => x.Name == (string)parameter);
if (key != null)
{
effectMesh.Parameters.SetDefault(key);
}
}
}))));
}
else if (viewModelNode.NodeValue is EffectMesh)
{
viewModelNode.PropertyName = "Mesh";
viewModelNode.Children.Add(new ViewModelNode("Effect", LambdaViewModelContent <string> .FromParent <EffectMesh>(x => x.EffectMeshData.EffectData.Name, (x, effectName) => x.EffectMeshData.EffectData.Name = effectName)));
viewModelNode.Children.Add(new ViewModelNode("Parameters", ((EffectMesh)viewModelNode.NodeValue).Parameters).GenerateChildren(context));
//viewModelNode.Children.Add(new ViewModelNode("MeshData", LambdaViewModelContent<ViewModelReference>.FromParent<MeshData>(effectMeshData => new ViewModelReference(effectMeshData.MeshData, true))));
handled = true;
}
else if (viewModelNode.NodeValue is ContentData || typeof(ContentData).IsAssignableFrom(viewModelNode.Type))
{
if (viewModelNode.NodeValue is ContentData)
{
viewModelNode.Content = new NodeValueViewModelContent();
}
if (viewModelNode.Value != null)
{
viewModelNode.Children.Add(new ViewModelNode("Url", new LambdaViewModelContent <string>(new ParentValueViewModelContent(),
x => engineContext.AssetManager.Url.Get((x.Value)),
(x, y) =>
{
var nodeValue = x.OwnerNode.Parent.NodeValue;
})));
viewModelNode.Children.Add(new ViewModelNode("ChangeUrl", new RootViewModelContent((ExecuteCommand)(async(viewModel2, parameter) =>
{
var dropParameters = (DropCommandParameters)parameter;
var parameterInfo = (Tuple <ParameterCollection, ParameterKey, ContentData>)viewModel2.Parent.Parent.NodeValue;
var parameterCollection = parameterInfo.Item1;
var textureData = await engineContext.AssetManager.LoadAsync <Image>((string)dropParameters.Data);
//parameter.Item1.SetObject(parameter.Item2, );
//parameterCollection.Remove(parameterInfo.Item2);
//var texture = engineContext.ContentManager.Convert<ITexture, Image>(textureData);
Texture texture;
throw new NotImplementedException();
parameterCollection.SetObject(parameterInfo.Item2, texture);
}))));
if (viewModelNode.Type == typeof(Image))
{
Image thumbnail = null;
Task <Image> textureData = null;
viewModelNode.Children.Add(new ViewModelNode("Thumbnail", new LambdaViewModelContent <Image>(new ParentValueViewModelContent(), (viewModelContent) =>
{
if (textureData == null)
{
var textureDataNew = viewModelContent.Value as Image;
if (engineContext.AssetManager.Url.Get(textureDataNew) != null)
{
textureData = engineContext.AssetManager.LoadAsync <Image>(engineContext.AssetManager.Url.Get(textureDataNew));
textureData.ContinueWith(task =>
{
thumbnail = task.Result;
viewModelContent.OwnerNode.Content.SerializeFlags |= ViewModelContentSerializeFlags.Static;
});
}
}
return(thumbnail);
})));
}
}
handled = true;
}
else if (viewModelNode.NodeValue is MeshData)
{
handled = true;
}
else if (viewModelNode.NodeValue is Tuple <ParameterCollection, ParameterKey, ContentData> )
{
var value = (Tuple <ParameterCollection, ParameterKey, ContentData>)viewModelNode.NodeValue;
// Ignore namespace and class name for key name
viewModelNode.PropertyName = value.Item2.Name;
if (viewModelNode.PropertyName.Contains('.'))
{
viewModelNode.PropertyName = viewModelNode.PropertyName.Substring(viewModelNode.PropertyName.LastIndexOf('.') + 1);
}
viewModelNode.Content = new NullViewModelContent(typeof(Image));
if (value.Item3 != null)
{
viewModelNode.Children.Add(new ViewModelNode("ObjectRef", new RootViewModelContent(value.Item3)
{
SerializeFlags = ViewModelContentSerializeFlags.None
}).GenerateChildren(context));
}
handled = true;
}
else if (viewModelNode.NodeValue is Tuple <ParameterCollection, ParameterKey> )
{
var value = (Tuple <ParameterCollection, ParameterKey>)viewModelNode.NodeValue;
// Ignore namespace and class name for key name
viewModelNode.PropertyName = value.Item2.Name;
if (viewModelNode.PropertyName.Contains('.'))
{
viewModelNode.PropertyName = viewModelNode.PropertyName.Substring(viewModelNode.PropertyName.LastIndexOf('.') + 1);
}
if (value.Item2.PropertyType.IsValueType)
{
viewModelNode.Content =
new LambdaViewModelContent <object>(() => value.Item1.GetObject(value.Item2), newValue => value.Item1.SetObject(value.Item2, newValue))
{
Type = value.Item2.PropertyType
};
handleValueType = true;
}
handled = true;
}
else if (viewModelNode.Type == typeof(Matrix) || viewModelNode.Type == typeof(Vector3) || viewModelNode.Type == typeof(Color))
{
handled = true;
}
else if (viewModelNode.Type.IsValueType)
{
handleValueType = true;
}
if (handleValueType)
{
if (!(viewModelNode.Type == typeof(Matrix) || viewModelNode.Type == typeof(Vector3) || viewModelNode.Type == typeof(Color) || viewModelNode.Type == typeof(Color3)))
{
if (viewModelNode.Type.IsValueType && !viewModelNode.Type.IsPrimitive && !viewModelNode.Type.IsEnum)
{
viewModelNode.Content.SerializeFlags = ViewModelContentSerializeFlags.None;
// Use default for those types
foreach (var fieldinfo in viewModelNode.Type.GetFields(BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Instance))
{
IViewModelContent viewModelContent = new FieldInfoViewModelContent(new ParentValueViewModelContent(viewModelNode.Type), fieldinfo);
//if (fieldinfo.FieldType.IsValueType && !fieldinfo.FieldType.IsPrimitive && !fieldinfo.FieldType.IsEnum)
// viewModelContent.Flags = ViewModelFlags.None;
// Doesn't support array
if (fieldinfo.FieldType.IsArray)
{
continue;
}
viewModelNode.Children.Add(new ViewModelNode(fieldinfo.Name, viewModelContent).GenerateChildren(context));
}
handled = true;
}
}
}
}
public void GenerateChildren(ViewModelContext context, IViewModelNode viewModelNode, ref bool handled)
{
throw new NotImplementedException();
}
public void GenerateChildren(ViewModelContext context, IViewModelNode viewModelNode, ref bool handled)
{
bool handleValueType = false;
if (viewModelNode.NodeValue is MicroThread)
{
var microThread = (MicroThread)viewModelNode.NodeValue;
var script = microThread.Get(ScriptManager.ScriptProperty);
viewModelNode.Content = new EnumerableViewModelContent<ViewModelReference>(() => new[] { new ViewModelReference(script, true) });
handled = true;
}
else if (viewModelNode.NodeValue is IScript)
{
var script = (IScript)viewModelNode.NodeValue;
// Expose all variables of IScript (defined by user)
foreach (var property in script.GetType().GetProperties())
{
if (property.PropertyType != typeof(int) && property.PropertyType != typeof(float))
continue;
viewModelNode.Children.Add(new ViewModelNode(property.Name, new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), property)));
}
handled = true;
}
else if (viewModelNode.NodeValue is Entity)
{
ViewModelNode componentsViewModelNode;
viewModelNode.Children.Add(new ViewModelNode("Name", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(Entity).GetProperty("Name"))));
viewModelNode.Children.Add(new ViewModelNode("Guid", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(Entity).GetProperty("Guid"))));
viewModelNode.Children.Add(componentsViewModelNode = new ViewModelNode("Components", EnumerableViewModelContent.FromUnaryLambda<ViewModelReference, Entity>(new ParentNodeValueViewModelContent(),
(entity) => entity.Properties
.Select(x => x.Value)
.OfType<EntityComponent>()
.Select(x => new ViewModelReference(x, true)))));
var availableKeysContent = new RootViewModelContent(null, typeof(string[]));
componentsViewModelNode.Children.Add(new ViewModelNode("AvailableKeys", availableKeysContent));
componentsViewModelNode.Children.Add(new ViewModelNode("RequestKeys", new RootViewModelContent((ExecuteCommand)((viewModel2, parameter) =>
{
var availableComponentKeys = new List<string>();
// TODO: Improve component keys enumeration (maybe need a registry?)
// For now, scan assemblies for all types inheriting from EntityComponent
foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
{
foreach (var type in assembly.GetTypes())
{
if (type.IsSubclassOf(typeof(EntityComponent))
&& type.GetField("Key", BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy) != null)
{
availableComponentKeys.Add(type.AssemblyQualifiedName);
}
}
}
availableKeysContent.Value = availableComponentKeys.ToArray();
}))));
componentsViewModelNode.Children.Add(new ViewModelNode("Add", new RootViewModelContent((ExecuteCommand)((viewModel2, parameter) =>
{
var entity = (Entity)viewModel2.Parent.Parent.NodeValue;
var componentType = Type.GetType((string)parameter);
// For now, assume it will be stored in a PropertyKey inside the actual component named "Key"
var componentKeyField = componentType.GetField("Key", BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy);
entity.SetObject((PropertyKey)componentKeyField.GetValue(null), Activator.CreateInstance(componentType));
}))));
handled = true;
}
else if (viewModelNode.NodeValue is EntityComponent)
{
viewModelNode.PropertyName = "EntityComponent";
var component = (EntityComponent)viewModelNode.NodeValue;
// Would be better higher in the hierarchy, but it would complicate model
var propertyKey = component.Entity.Properties.First(x => x.Value == component).Key;
var propertyKeyName = propertyKey.OwnerType.Name;
viewModelNode.Children.Add(new ViewModelNode("PropertyKeyName", new RootViewModelContent(propertyKeyName)));
viewModelNode.Children.Add(new ViewModelNode("Remove", new RootViewModelContent((ExecuteCommand)((viewModel2, parameter) =>
{
component.Entity.SetObject(propertyKey, null);
}))));
var componentViewModel = new ViewModelNode("Component", component);
viewModelNode.Children.Add(componentViewModel);
if (component is TransformationComponent)
{
componentViewModel.Children.Add(new ViewModelNode("WorldMatrix", new FieldInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(TransformationComponent).GetField("WorldMatrix"))).GenerateChildren(context));
// TODO: How to switch view model depending on TransformationComponent.Values type? Or should we always expose everything?
componentViewModel.Children.Add(new ViewModelNode("LocalMatrix", new FieldInfoViewModelContent(new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(TransformationComponent).GetProperty("Value")), typeof(TransformationValue).GetField("LocalMatrix"))).GenerateChildren(context));
//if (((TransformationComponent)component).Values is TransformationTRS)
{
componentViewModel.Children.Add(new ViewModelNode("Translation", new FieldInfoViewModelContent(new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(TransformationComponent).GetProperty("Value")), typeof(TransformationTRS).GetField("Translation"))).GenerateChildren(context));
componentViewModel.Children.Add(new ViewModelNode("Rotation", new FieldInfoViewModelContent(new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(TransformationComponent).GetProperty("Value")), typeof(TransformationTRS).GetField("Rotation"))).GenerateChildren(context));
componentViewModel.Children.Add(new ViewModelNode("Scaling", new FieldInfoViewModelContent(new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(TransformationComponent).GetProperty("Value")), typeof(TransformationTRS).GetField("Scaling"))).GenerateChildren(context));
}
componentViewModel.Children.Add(new ViewModelNode("Parent", LambdaViewModelContent<ViewModelReference>.FromOperand<EntityComponent>(new ParentNodeValueViewModelContent(), x => new ViewModelReference(x.Entity, false))));
componentViewModel.Children.Last().Children.Add(new ViewModelNode("SetAsRoot", new RootViewModelContent((ExecuteCommand)((viewModel2, parameter) =>
{
context.ViewModelByGuid.Clear();
context.Root = context.GetModelView(((TransformationComponent)component).Parent.Entity).Children.First(x => x.PropertyName == "Components");
}))));
}
if (component is ModelComponent)
{
componentViewModel.Children.Add(new ViewModelNode("Parameters", ((ModelComponent)component).MeshParameters).GenerateChildren(context));
//componentViewModel.Children.Add(new ViewModelNode(
// "MeshParameters",
// EnumerableViewModelContent.FromUnaryLambda<ViewModelReference, ModelComponent>(
// new ParentNodeValueViewModelContent(),
// (ModelComponent) => ModelComponent.MeshParameters.Keys.Select(key => new ViewModelReference(Tuple.Create(ModelComponent.MeshParameters, key), true)))));
}
if (component is LightComponent)
{
componentViewModel.Children.Add(new ViewModelNode("Type", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(LightComponent).GetProperty("Type"))).GenerateChildren(context));
componentViewModel.Children.Add(new ViewModelNode("ShadowMap", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(LightComponent).GetProperty("ShadowMap"))).GenerateChildren(context));
componentViewModel.Children.Add(new ViewModelNode("Deferred", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(LightComponent).GetProperty("Deferred"))).GenerateChildren(context));
componentViewModel.Children.Add(new ViewModelNode("Intensity", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(LightComponent).GetProperty("Intensity"))).GenerateChildren(context));
componentViewModel.Children.Add(new ViewModelNode("DecayStart", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(LightComponent).GetProperty("DecayStart"))).GenerateChildren(context));
componentViewModel.Children.Add(new ViewModelNode("Color", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(LightComponent).GetProperty("Color"))).GenerateChildren(context));
componentViewModel.Children.Add(new ViewModelNode("LightDirection", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(LightComponent).GetProperty("LightDirection"))).GenerateChildren(context));
}
if (component is LightShaftsComponent)
{
componentViewModel.Children.Add(new ViewModelNode("Color", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(LightShaftsComponent).GetProperty("Color"))).GenerateChildren(context));
//componentViewModel.Children.Add(new ViewModelNode("LightShaftsBoundingBoxes", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(LightShaftsComponent).GetProperty("LightShaftsBoundingBoxes"))).GenerateChildren(context));
}
// Else try to display it using auto-display
AutoDisplayComponent(context, viewModelNode, component);
handled = true;
}
else if (viewModelNode.NodeValue is ParameterCollection)
{
viewModelNode.Content = EnumerableViewModelContent.FromUnaryLambda<ViewModelReference, ParameterCollection>(new NodeValueViewModelContent(), (parameterCollection) =>
parameterCollection.Keys.Where(key => key.PropertyType.IsValueType).Select(key =>
{
if (key.PropertyType.IsValueType)
{
// For value type, generated tree won't change so make value based on key only.
return new ViewModelReference(Tuple.Create(parameterCollection, key), true);
}
else
{
// TODO: resources currently ignored (until fixed)
// For reference type, make value dependent on actual value reference and source.
// This will trigger a regeneration for reference change (i.e. new texture bound).
// Useful since asset type/state might be different.
var value = parameterCollection.GetObject(key);
var valueSource = engineContext.AssetManager.Url.Get(value);
return new ViewModelReference(Tuple.Create(parameterCollection, key, valueSource), true);
}
}));
var availableKeysContent = new RootViewModelContent(null, typeof(string[]));
viewModelNode.Children.Add(new ViewModelNode("AvailableKeys", availableKeysContent));
viewModelNode.Children.Add(new ViewModelNode("RequestKeys", new RootViewModelContent((ExecuteCommand)((viewModel2, parameter) =>
{
var parameterCollection = (ParameterCollection)viewModel2.Parent.NodeValue;
var effectMesh = viewModel2.Parent.Parent.NodeValue as EffectMesh;
if (effectMesh != null)
{
var availableKeys = effectMesh.Effect.Passes.SelectMany(x => x.DefaultParameters.Parameters.Select(y => y.Key)).Distinct().Where(x => !parameterCollection.IsValueOwner(x)).Select(x => x.Name).ToArray();
availableKeysContent.Value = availableKeys;
}
}))));
viewModelNode.Children.Add(new ViewModelNode("Add", new RootViewModelContent((ExecuteCommand)((viewModel2, parameter) =>
{
var effectMesh = viewModel2.Parent.Parent.NodeValue as EffectMesh;
if (effectMesh != null)
{
var key = effectMesh.Effect.Passes.SelectMany(x => x.DefaultParameters.Parameters.Select(y => y.Key)).FirstOrDefault(x => x.Name == (string)parameter);
if (key != null)
{
effectMesh.Parameters.SetDefault(key);
}
}
}))));
}
else if (viewModelNode.NodeValue is EffectMesh)
{
viewModelNode.PropertyName = "Mesh";
viewModelNode.Children.Add(new ViewModelNode("Effect", LambdaViewModelContent<string>.FromParent<EffectMesh>(x => x.EffectMeshData.EffectData.Name, (x, effectName) => x.EffectMeshData.EffectData.Name = effectName)));
viewModelNode.Children.Add(new ViewModelNode("Parameters", ((EffectMesh)viewModelNode.NodeValue).Parameters).GenerateChildren(context));
//viewModelNode.Children.Add(new ViewModelNode("MeshData", LambdaViewModelContent<ViewModelReference>.FromParent<MeshData>(effectMeshData => new ViewModelReference(effectMeshData.MeshData, true))));
handled = true;
}
else if (viewModelNode.NodeValue is ContentData || typeof(ContentData).IsAssignableFrom(viewModelNode.Type))
{
if (viewModelNode.NodeValue is ContentData)
viewModelNode.Content = new NodeValueViewModelContent();
if (viewModelNode.Value != null)
{
viewModelNode.Children.Add(new ViewModelNode("Url", new LambdaViewModelContent<string>(new ParentValueViewModelContent(),
x => engineContext.AssetManager.Url.Get((x.Value)),
(x, y) =>
{
var nodeValue = x.OwnerNode.Parent.NodeValue;
})));
viewModelNode.Children.Add(new ViewModelNode("ChangeUrl", new RootViewModelContent((ExecuteCommand)(async (viewModel2, parameter) =>
{
var dropParameters = (DropCommandParameters)parameter;
var parameterInfo = (Tuple<ParameterCollection, ParameterKey, ContentData>)viewModel2.Parent.Parent.NodeValue;
var parameterCollection = parameterInfo.Item1;
var textureData = await engineContext.AssetManager.LoadAsync<Image>((string)dropParameters.Data);
//parameter.Item1.SetObject(parameter.Item2, );
//parameterCollection.Remove(parameterInfo.Item2);
//var texture = engineContext.ContentManager.Convert<ITexture, Image>(textureData);
Texture texture;
throw new NotImplementedException();
parameterCollection.SetObject(parameterInfo.Item2, texture);
}))));
if (viewModelNode.Type == typeof(Image))
{
Image thumbnail = null;
Task<Image> textureData = null;
viewModelNode.Children.Add(new ViewModelNode("Thumbnail", new LambdaViewModelContent<Image>(new ParentValueViewModelContent(), (viewModelContent) =>
{
if (textureData == null)
{
var textureDataNew = viewModelContent.Value as Image;
if (engineContext.AssetManager.Url.Get(textureDataNew) != null)
{
textureData = engineContext.AssetManager.LoadAsync<Image>(engineContext.AssetManager.Url.Get(textureDataNew));
textureData.ContinueWith(task =>
{
thumbnail = task.Result;
viewModelContent.OwnerNode.Content.SerializeFlags |= ViewModelContentSerializeFlags.Static;
});
}
}
return thumbnail;
})));
}
}
handled = true;
}
else if (viewModelNode.NodeValue is MeshData)
{
handled = true;
}
else if (viewModelNode.NodeValue is Tuple<ParameterCollection, ParameterKey, ContentData>)
{
var value = (Tuple<ParameterCollection, ParameterKey, ContentData>)viewModelNode.NodeValue;
// Ignore namespace and class name for key name
viewModelNode.PropertyName = value.Item2.Name;
if (viewModelNode.PropertyName.Contains('.'))
viewModelNode.PropertyName = viewModelNode.PropertyName.Substring(viewModelNode.PropertyName.LastIndexOf('.') + 1);
viewModelNode.Content = new NullViewModelContent(typeof(Image));
if (value.Item3 != null)
viewModelNode.Children.Add(new ViewModelNode("ObjectRef", new RootViewModelContent(value.Item3) { SerializeFlags = ViewModelContentSerializeFlags.None }).GenerateChildren(context));
handled = true;
}
else if (viewModelNode.NodeValue is Tuple<ParameterCollection, ParameterKey>)
{
var value = (Tuple<ParameterCollection, ParameterKey>)viewModelNode.NodeValue;
// Ignore namespace and class name for key name
viewModelNode.PropertyName = value.Item2.Name;
if (viewModelNode.PropertyName.Contains('.'))
viewModelNode.PropertyName = viewModelNode.PropertyName.Substring(viewModelNode.PropertyName.LastIndexOf('.') + 1);
if (value.Item2.PropertyType.IsValueType)
{
viewModelNode.Content =
new LambdaViewModelContent<object>(() => value.Item1.GetObject(value.Item2), newValue => value.Item1.SetObject(value.Item2, newValue))
{
Type = value.Item2.PropertyType
};
handleValueType = true;
}
handled = true;
}
else if (viewModelNode.Type == typeof(Matrix) || viewModelNode.Type == typeof(Vector3) || viewModelNode.Type == typeof(Color))
{
handled = true;
}
else if (viewModelNode.Type.IsValueType)
{
handleValueType = true;
}
if (handleValueType)
{
if (!(viewModelNode.Type == typeof(Matrix) || viewModelNode.Type == typeof(Vector3) || viewModelNode.Type == typeof(Color) || viewModelNode.Type == typeof(Color3)))
{
if (viewModelNode.Type.IsValueType && !viewModelNode.Type.IsPrimitive && !viewModelNode.Type.IsEnum)
{
viewModelNode.Content.SerializeFlags = ViewModelContentSerializeFlags.None;
// Use default for those types
foreach (var fieldinfo in viewModelNode.Type.GetFields(BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Instance))
{
IViewModelContent viewModelContent = new FieldInfoViewModelContent(new ParentValueViewModelContent(viewModelNode.Type), fieldinfo);
//if (fieldinfo.FieldType.IsValueType && !fieldinfo.FieldType.IsPrimitive && !fieldinfo.FieldType.IsEnum)
// viewModelContent.Flags = ViewModelFlags.None;
// Doesn't support array
if (fieldinfo.FieldType.IsArray)
continue;
viewModelNode.Children.Add(new ViewModelNode(fieldinfo.Name, viewModelContent).GenerateChildren(context));
}
handled = true;
}
}
}
}
/// <summary>
/// Display components that are tagged with the <see cref="DisplayAttribute"/>.
/// </summary>
/// <param name="context">Context of the view model.</param>
/// <param name="viewModel">The current view model</param>
/// <param name="component">The entity component to display</param>
private void AutoDisplayComponent(ViewModelContext context, IViewModelNode viewModel, EntityComponent component)
{
var displayComp = DisplayAttribute.GetDisplay(component.GetType());
if (displayComp == null)
return;
var componentViewModel = viewModel.GetChildrenByName("Component");
if (componentViewModel == null)
return;
// Change the name of the component being displayed
if (!string.IsNullOrEmpty(displayComp.Name))
{
var componentName = viewModel.GetChildrenByName("PropertyKeyName");
if (componentName != null)
{
componentName.Value = displayComp.Name;
}
}
var propertyToDisplay = new List<Tuple<DisplayAttribute, ViewModelNode>>();
var memberInfos = new List<MemberInfo>();
memberInfos.AddRange(component.GetType().GetProperties());
memberInfos.AddRange(component.GetType().GetFields());
// Process fields and properties
foreach (var property in memberInfos)
{
var display = DisplayAttribute.GetDisplay(property);
if (display == null) continue;
IViewModelContent modelContent = null;
object modelValue = null;
var propertyInfo = property as PropertyInfo;
if (propertyInfo != null)
{
if (typeof(ParameterCollection).IsAssignableFrom(propertyInfo.PropertyType))
{
modelValue = propertyInfo.GetValue(component, null);
}
else
{
modelContent = new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), propertyInfo);
}
}
var fieldInfo = property as FieldInfo;
if (fieldInfo != null)
{
if (typeof(ParameterCollection).IsAssignableFrom(fieldInfo.FieldType))
{
modelValue = fieldInfo.GetValue(component);
}
else
{
modelContent = new FieldInfoViewModelContent(new ParentNodeValueViewModelContent(), fieldInfo);
}
}
var propertyViewModel = modelValue != null ? new ViewModelNode(display.Name ?? property.Name, modelValue) : new ViewModelNode(display.Name ?? property.Name, modelContent);
propertyViewModel.GenerateChildren(context);
propertyToDisplay.Add(new Tuple<DisplayAttribute, ViewModelNode>(display, propertyViewModel));
}
foreach(var item in propertyToDisplay.OrderBy((left) => left.Item1.Order))
{
componentViewModel.Children.Add(item.Item2);
}
}
public void GenerateChildren(ViewModelContext context, IViewModelNode viewModelNode, ref bool handled)
{
throw new NotImplementedException();
}
public void GenerateChildren(ViewModelContext context, IViewModelNode viewModelNode, ref bool handled)
{
if ((viewModelNode.NodeValue as string) == "Root")
{
viewModelNode.Children.Add(new ViewModelNode("SearchResults", new EnumerableViewModelContent <ViewModelReference>(() =>
searchResults != null && searchResults.IsCompleted ? searchResults.Result.Select(searchResult => new ViewModelReference(KeyValuePair.Create(UrlType.SearchResult, searchResult), true))
: new ViewModelReference[] { })));
viewModelNode.Children.Add(new ViewModelNode("SearchFilter",
new LambdaViewModelContent <string>(
() => searchFilter,
(newFilter) =>
{
searchFilter = newFilter;
StartSearch();
})));
viewModelNode.Children.Add(new ViewModelNode("Packages",
new EnumerableViewModelContent <ViewModelReference>(() => engineContext.PackageManager.Packages.Select(package => new ViewModelReference(package, true)))));
fileTracker = new FileTracker();
fileTracker.Setup("/global_data");
fileTracker.Setup("/global_data2");
viewModelNode.Children.Add(new ViewModelNode("FileTracker", new RootViewModelContent(fileTracker)).GenerateChildren(context));
}
if (viewModelNode.Type == typeof(FileTracker))
{
viewModelNode.Content.SerializeFlags = ViewModelContentSerializeFlags.None;
viewModelNode.Children.Add(new ViewModelNode("RootFolder", KeyValuePair.Create(UrlType.FileTracker, "/")).GenerateChildren(context));
handled = true;
}
if (viewModelNode.NodeValue is Package)
{
viewModelNode.Children.Add(new ViewModelNode("Name", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(Package).GetProperty("Name"))));
handled = true;
}
if (viewModelNode.NodeValue is Tuple <UrlType, string> )
{
var nodeValue = (Tuple <UrlType, string>)viewModelNode.NodeValue;
var url = nodeValue.Item2;
if (nodeValue.Item1 == UrlType.SearchResult)
{
// Load thumbnail (not cached yet)
if (url.EndsWith(".png") || url.EndsWith(".jpg"))
{
//var textureData = engineContext.ContentManager.LoadAsync<Image>(url);
var thumbnail = new ViewModelNode("Thumbnail",
new AsyncViewModelContent <Image>(new NullViewModelContent(), operand => engineContext.AssetManager.Load <Image>(url)));
viewModelNode.Children.Add(thumbnail);
/*textureData.ContinueWith(task =>
* {
* thumbnail.Value = task.Result;
* thumbnail.Content.Flags |= ViewModelFlags.Static;
* });*/
}
/*else
* {
* throw new NotImplementedException();
* }*/
viewModelNode.Content = new RootViewModelContent(url);
viewModelNode.Content.SerializeFlags = ViewModelContentSerializeFlags.Serialize;
}
else if (nodeValue.Item1 == UrlType.FileTracker)
{
viewModelNode.Content = new RootViewModelContent(url);
viewModelNode.Content.SerializeFlags = ViewModelContentSerializeFlags.Serialize;
viewModelNode.Children.Add(new ViewModelNode("SetAsSearchFilter", new RootViewModelContent((ExecuteCommand)((viewModel2, parameter) =>
{
searchRoot = url;
StartSearch();
}))));
if (url.EndsWith("/"))
{
viewModelNode.Children.Add(new ViewModelNode("Folders", new EnumerableViewModelContent <ViewModelReference>(() =>
fileTracker.Files
.Where(file => file.StartsWith(url))
.GroupBy(file =>
{
var separatorIndex = file.IndexOf('/', url.Length + 1);
return(file.Substring(url.Length, separatorIndex != -1 ? separatorIndex - url.Length + 1 : file.Length - url.Length));
})
.Where(x => x.Key.EndsWith("/") || x.Key.EndsWith(".dat") || x.Key.EndsWith(".xksl"))
.Select(x => new ViewModelReference(KeyValuePair.Create(UrlType.FileTracker, url + x.Key), this))
)));
}
}
handled = true;
}
}
public void GenerateChildren(ViewModelContext context, IViewModelNode viewModelNode, ref bool handled)
{
if (viewModelNode.NodeValue is Entity)
{
viewModelNode.Children.Add(new ViewModelNode("Name", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(Entity).GetProperty("Name"))));
viewModelNode.Children.Add(new ViewModelNode("Guid", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(Entity).GetProperty("Guid"))));
viewModelNode.Children.Add(new ViewModelNode("IsSelected", new PropertyKeyViewModelContent(new ParentNodeValueViewModelContent(), isSelectedProperty)));
viewModelNode.Children.Add(new ViewModelNode("ParentReference", LambdaViewModelContent<ViewModelReference>.FromParent<Entity>(x =>
{
var transformationComponent = x.Transformation;
var parent = transformationComponent != null ? transformationComponent.Parent : null;
return new ViewModelReference(parent != null ? parent.Entity : null);
})));
viewModelNode.Children.Add(new ViewModelNode("HierarchicalEntities", EnumerableViewModelContent.FromUnaryLambda<ViewModelReference, Entity>(new ParentNodeValueViewModelContent(),
(entity) =>
{
var result = Enumerable.Empty<ViewModelReference>();
// Enumerates children nodes
var transformationComponent = entity.Transformation;
if (transformationComponent != null)
result = result.Concat(transformationComponent.Children
.Select(x => new ViewModelReference(x.Entity, true)));
// Enumerates EffectMesh
var meshComponent = entity.Get(ModelComponent.Key);
if (meshComponent != null && meshComponent.InstantiatedSubMeshes != null)
result = result.Concat(meshComponent.InstantiatedSubMeshes.Select((x, i) =>
{
effectMeshIndices.GetOrCreateValue(x.Value).Index = i;
return new ViewModelReference(x.Value, true);
}));
return result;
})));
viewModelNode.Children.Add(new ViewModelNode("EventOpen", new RootViewModelContent((ExecuteCommand)((viewModel2, parameter) =>
{
ScriptDebug.SelectEntity((Entity)viewModel2.Parent.NodeValue);
}))));
viewModelNode.Children.Add(new ViewModelNode("CreateNewEntity", new RootViewModelContent((ExecuteCommand)((viewModel2, parameter) =>
{
var entity = (Entity)viewModel2.Parent.NodeValue;
var newEntity = new Entity("New Entity");
entity.Transformation.Children.Add(newEntity.Transformation);
}))));
viewModelNode.Children.Add(new ViewModelNode("Remove", new RootViewModelContent((ExecuteCommand)((viewModel2, parameter) =>
{
var entity = (Entity)viewModel2.Parent.NodeValue;
EntitySystem.Remove(entity);
}))));
handled = true;
}
else if (viewModelNode.NodeValue is EffectMesh)
{
viewModelNode.Children.Add(new ViewModelNode("Name", new LambdaViewModelContent<string>(new NullViewModelContent(), (content) =>
{
var effectMesh = (EffectMesh)content.OwnerNode.Parent.NodeValue;
var result = effectMeshIndices.GetOrCreateValue(effectMesh).Index.ToString();
if (effectMesh.Name != null)
result += " - " + effectMesh.Name;
return result;
})));
viewModelNode.Children.Add(new ViewModelNode("EventOpen", new RootViewModelContent((ExecuteCommand)((viewModel2, parameter) =>
{
selectedEntitiesContext.ViewModelByGuid.Clear();
selectedEntitiesContext.Root = new ViewModelNode("Root", new RootViewModelContent(new[] { new ViewModelReference(viewModel2.Parent.NodeValue, true) }, typeof(IList<ViewModelReference>)));
}))));
handled = true;
}
}
public void GenerateChildren(ViewModelContext context, IViewModelNode viewModelNode, ref bool handled)
{
if ((viewModelNode.NodeValue as string) == "Root")
{
viewModelNode.Children.Add(new ViewModelNode("SearchResults", new EnumerableViewModelContent<ViewModelReference>(() =>
searchResults != null && searchResults.IsCompleted ? searchResults.Result.Select(searchResult => new ViewModelReference(KeyValuePair.Create(UrlType.SearchResult, searchResult), true))
: new ViewModelReference[] { })));
viewModelNode.Children.Add(new ViewModelNode("SearchFilter",
new LambdaViewModelContent<string>(
() => searchFilter,
(newFilter) =>
{
searchFilter = newFilter;
StartSearch();
})));
viewModelNode.Children.Add(new ViewModelNode("Packages",
new EnumerableViewModelContent<ViewModelReference>(() => engineContext.PackageManager.Packages.Select(package => new ViewModelReference(package, true)))));
fileTracker = new FileTracker();
fileTracker.Setup("/global_data");
fileTracker.Setup("/global_data2");
viewModelNode.Children.Add(new ViewModelNode("FileTracker", new RootViewModelContent(fileTracker)).GenerateChildren(context));
}
if (viewModelNode.Type == typeof(FileTracker))
{
viewModelNode.Content.SerializeFlags = ViewModelContentSerializeFlags.None;
viewModelNode.Children.Add(new ViewModelNode("RootFolder", KeyValuePair.Create(UrlType.FileTracker, "/")).GenerateChildren(context));
handled = true;
}
if (viewModelNode.NodeValue is Package)
{
viewModelNode.Children.Add(new ViewModelNode("Name", new PropertyInfoViewModelContent(new ParentNodeValueViewModelContent(), typeof(Package).GetProperty("Name"))));
handled = true;
}
if (viewModelNode.NodeValue is Tuple<UrlType, string>)
{
var nodeValue = (Tuple<UrlType, string>)viewModelNode.NodeValue;
var url = nodeValue.Item2;
if (nodeValue.Item1 == UrlType.SearchResult)
{
// Load thumbnail (not cached yet)
if (url.EndsWith(".png") || url.EndsWith(".jpg"))
{
//var textureData = engineContext.ContentManager.LoadAsync<Image>(url);
var thumbnail = new ViewModelNode("Thumbnail",
new AsyncViewModelContent<Image>(new NullViewModelContent(), operand => engineContext.AssetManager.Load<Image>(url)));
viewModelNode.Children.Add(thumbnail);
/*textureData.ContinueWith(task =>
{
thumbnail.Value = task.Result;
thumbnail.Content.Flags |= ViewModelFlags.Static;
});*/
}
/*else
{
throw new NotImplementedException();
}*/
viewModelNode.Content = new RootViewModelContent(url);
viewModelNode.Content.SerializeFlags = ViewModelContentSerializeFlags.Serialize;
}
else if (nodeValue.Item1 == UrlType.FileTracker)
{
viewModelNode.Content = new RootViewModelContent(url);
viewModelNode.Content.SerializeFlags = ViewModelContentSerializeFlags.Serialize;
viewModelNode.Children.Add(new ViewModelNode("SetAsSearchFilter", new RootViewModelContent((ExecuteCommand)((viewModel2, parameter) =>
{
searchRoot = url;
StartSearch();
}))));
if (url.EndsWith("/"))
{
viewModelNode.Children.Add(new ViewModelNode("Folders", new EnumerableViewModelContent<ViewModelReference>(() =>
fileTracker.Files
.Where(file => file.StartsWith(url))
.GroupBy(file =>
{
var separatorIndex = file.IndexOf('/', url.Length + 1);
return file.Substring(url.Length, separatorIndex != -1 ? separatorIndex - url.Length + 1 : file.Length - url.Length);
})
.Where(x => x.Key.EndsWith("/") || x.Key.EndsWith(".dat") || x.Key.EndsWith(".xksl"))
.Select(x => new ViewModelReference(KeyValuePair.Create(UrlType.FileTracker, url + x.Key), this))
)));
}
}
handled = true;
}
}
