public ShaderEditorPageViewModel(ShaderStorageLinker shaderStorage, Workspace workspace, EventAggregator eventAggregator)
{
int index = workspace.SelectedIndex;
_shaderStorage = shaderStorage;
Workspace = workspace;
ShadersFlattened.AddRange(_shaderStorage.ShaderGroups.SelectMany((s) => s.Shaders));
ShaderGroupsView = CollectionViewSource.GetDefaultView(ShadersFlattened);
ShaderGroupsView.Filter = (s) => ((Shader)s).Group.IsOpen;
ShaderGroupsView.GroupDescriptions.Add(new PropertyGroupDescription("Group"));
RaiseLoadedCommand = new DelegateCommand(RaiseLoaded);
SelectErrorCommand = new DelegateCommand <SelectionChangedEventArgs>(SelectError);
RaiseCompileShaderCommand = new DelegateCommand(RaiseCompileShader, CanExecuteCompileShader);
RaiseNewShaderGroupCommand = new DelegateCommand(RaiseNewShaderGroup);
RaiseShaderNameChangedCommand = new DelegateCommand <ShaderNameChangedEventArgs>(RaiseShaderNameChanged);
InitializeExplorerButtons();
InitializeSaveButtonCommands();
RaiseBuildShaderGroupCommand = new DelegateCommand(RaiseBuildShaderGroup, CanExecuteCompileShader);
_includeHeaderCallback = new CallbackDelegate(SaveIncludeHeaderCallback);
Workspace.SelectedIndex = index;
eventAggregator.GetEvent <RefreshExplorer>().Subscribe(RefreshExplorerEvent);
}
public MainPageViewModel(ShaderStorageLinker shaderStorage, Workspace workspace, EventAggregator eventAggregator)
{
_shaderStorageLinker = shaderStorage;
_eventAggregator = eventAggregator;
Workspace = workspace;
ShadersViewSource = new ListCollectionView(shaderStorage.ShaderGroups);
ShadersViewSource.Filter = (s) =>
{
return(((ShaderGroup)s).ShaderGroupType != ShaderGroupType.SharedHeaders);
};
RaiseLoadedCommand = new DelegateCommand(RaiseLoaded);
RaiseEditShaderGroupCommand = new DelegateCommand(RaiseEditShaderGroup);
RaiseDeleteShaderGroupCommand = new DelegateCommand(RaiseDeleteShaderGroup);
RaiseSaveShaderPropertiesCommand = new DelegateCommand(RaiseSaveShaderProperties);
}
public MainWindowPageViewModel()
{
Workspace workspace = null;
try
{
if (File.Exists(ShaderBoxRootFileLocation))
{
XmlSerializer serializer = new XmlSerializer(typeof(Workspace));
using (Stream stream = File.OpenRead(ShaderBoxRootFileLocation))
{
workspace = ((Workspace)serializer.Deserialize(stream));
}
}
}
catch (Exception)
{
}
finally
{
if (workspace == null)
{
workspace = new Workspace();
}
if (workspace.Shaders.Count == 0 || workspace.Shaders.FirstOrDefault((s) => s.Path == ShaderBoxSharedProject) == null)
{
workspace.Shaders.Insert(0, new ShaderPath()
{
Path = ShaderBoxSharedProject,
IsOpen = true
});
}
if (workspace.Models.Count == 0 || workspace.Models.FirstOrDefault((s) => s.Path == ShaderBoxBuiltInModel) == null)
{
workspace.Models.Insert(0, new Model3DData()
{
Hash = 0,
ImagePath = ShaderBoxBuiltInModelImage,
IsBuiltIn = true,
Name = "Cube.obj",
Path = ShaderBoxBuiltInModel
});
}
if (!File.Exists(ShaderBoxSharedProject))
{
ShaderGroup group = new ShaderGroup("Shared headers [../.Shared/]", ShaderGroupType.SharedHeaders)
{
UniqueName = ShaderBoxSharedFolderName,
IsOpen = true
};
Shader shader = new Shader("SB_Header.hlsli", ShaderType.Header, ShaderBoxBaseShaderLocation);
shader.IsBuiltIn = true;
group.AddShader(shader);
group.Save(workspace);
}
ShaderStorageLinker shaderStorage = new ShaderStorageLinker();
XmlSerializer serializer = new XmlSerializer(typeof(ShaderGroup));
List <ShaderPath> toDelete = new List <ShaderPath>();
foreach (ShaderPath sPath in workspace.Shaders)
{
try
{
using (Stream stream = File.OpenRead(sPath.Path))
{
ShaderGroup group = (ShaderGroup)serializer.Deserialize(stream);
group.IsOpen = sPath.IsOpen;
shaderStorage.ShaderGroups.Add(group);
}
}
catch (Exception e)
{
MessageBox.Show($"Failed to load project: {sPath.Path}\nError: {e}", "Load error", MessageBoxButton.OK, MessageBoxImage.Error);
toDelete.Add(sPath);
}
}
workspace.Shaders = workspace.Shaders.Except(toDelete).ToList();
if (!File.Exists(ShaderBoxBaseShaderLocation))
{
ShaderBoxSharedFolderLocation.EnsureFolder();
using (StreamWriter stream = new StreamWriter(ShaderBoxBaseShaderLocation))
{
stream.Write(ShaderBoxBaseShaderContent);
}
}
_workspace = workspace;
_workspace.PropertyChanged += new PropertyChangedEventHandler(OnResourcePropertyChanged);
App.Container.RegisterInstance(workspace);
App.Container.RegisterInstance(shaderStorage);
// Resolve cyclic dependency
foreach (ShaderGroup shaderGroup in shaderStorage.ShaderGroups)
{
foreach (Shader shader in shaderGroup.Shaders)
{
shader.Group = shaderGroup;
}
foreach (AnnotationShaderGroup annotationShaderGroup in shaderGroup.AnnotationShaderGroups)
{
annotationShaderGroup.CreateUI();
}
}
}
}
