private void ExportData_Execute(object parameter)
{
PssgNodeViewModel nodeView = (PssgNodeViewModel)parameter;
SaveFileDialog dialog = new SaveFileDialog();
dialog.Filter = "Bin files|*.bin|All files|*.*";
dialog.Title = "Select the byte data save location and file name";
dialog.DefaultExt = "bin";
dialog.FileName = "nodeData.bin";
if (dialog.ShowDialog() == true)
{
try
{
PssgNode node = nodeView.Node;
using (PssgBinaryWriter writer = new PssgBinaryWriter(new BigEndianBitConverter(), File.Open(dialog.FileName, FileMode.Create)))
{
writer.WriteObject(node.Value);
}
}
catch (Exception ex)
{
MessageBox.Show("Could not export data!" + Environment.NewLine + Environment.NewLine +
ex.Message, "Export Failed", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
}
private void AddNode_Execute(object parameter)
{
PssgNodeViewModel nodeView = (PssgNodeViewModel)parameter;
if (nodeView.Node.IsDataNode)
{
MessageBox.Show("Adding sub nodes to a node with data is not allowed!", Properties.Resources.AppTitleShort, MessageBoxButton.OK, MessageBoxImage.Stop);
return;
}
AddNodeWindow aaw = new AddNodeWindow();
if (aaw.ShowDialog() == true)
{
PssgNode newNode = nodeView.Node.AppendChild(aaw.NodeName);
if (newNode == null)
{
return;
}
PssgNodeViewModel newNodeView = new PssgNodeViewModel(newNode, nodeView);
nodeView.Children.Add(newNodeView);
}
}
public void Write(ShaderInputInfo shaderInput, PssgNode rdsLib, PssgNode ribLib, PssgModelWriterState state)
{
var streamCount = (uint)shaderInput.BlockInputs.Sum(bi => bi.VertexInputs.Count);
var rdsNode = new PssgNode("RENDERDATASOURCE", rdsLib.File, rdsLib);
rdsNode.AddAttribute("streamCount", streamCount);
rdsNode.AddAttribute("id", Name);
rdsLib.ChildNodes.Add(rdsNode);
WriteIndices(rdsNode);
// Write the data
foreach (var bi in shaderInput.BlockInputs)
{
for (int i = 0; i < bi.VertexInputs.Count; ++i)
{
var vi = bi.VertexInputs[i];
WriteRenderStream(rdsNode, state.DataBlockCount, state.RenderStreamCount, (uint)i);
state.RenderStreamCount++;
}
WriteDataBlock(bi, ribLib, state.DataBlockCount);
state.DataBlockCount++;
}
private void DuplicateTexture_Execute(object parameter)
{
PssgTextureViewModel texView = (PssgTextureViewModel)parameter;
DuplicateTextureWindow dtw = new DuplicateTextureWindow();
dtw.TextureName = texView.DisplayName + "_2";
if (dtw.ShowDialog() == true)
{
// Copy and Edit Name
PssgNode nodeToCopy = texView.Texture;
PssgNode newTexture = new PssgNode(nodeToCopy);
newTexture.Attributes["id"].Value = dtw.TextureName;
// Add to Library
if (nodeToCopy.ParentNode != null)
{
nodeToCopy.ParentNode.AppendChild(newTexture);
PssgNodeViewModel newNodeView = new PssgNodeViewModel(newTexture, texView.NodeView.Parent);
texView.NodeView.Parent.Children.Add(newNodeView);
Textures.Add(new PssgTextureViewModel(newNodeView));
}
else
{
nodeToCopy.AppendChild(newTexture);
PssgNodeViewModel newNodeView = new PssgNodeViewModel(newTexture, texView.NodeView);
texView.NodeView.Children.Add(newNodeView);
Textures.Add(new PssgTextureViewModel(newNodeView));
}
}
}
private void ImportData_Execute(object parameter)
{
PssgNodeViewModel nodeView = (PssgNodeViewModel)parameter;
OpenFileDialog dialog = new OpenFileDialog();
dialog.Filter = "Bin files|*.bin|All files|*.*";
dialog.Title = "Select a bin file";
dialog.FileName = "nodeData.bin";
if (dialog.ShowDialog() == true)
{
try
{
PssgNode node = nodeView.Node;
using (PssgBinaryReader reader = new PssgBinaryReader(new BigEndianBitConverter(), File.Open(dialog.FileName, FileMode.Open, FileAccess.Read)))
{
node.Value = reader.ReadNodeValue(node.ValueType, (int)reader.BaseStream.Length);
nodeView.IsSelected = false;
nodeView.IsSelected = true;
}
}
catch (Exception ex)
{
MessageBox.Show("Could not import data!" + Environment.NewLine + Environment.NewLine +
ex.Message, "Import Failed", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
}
static void WriteRenderStream(PssgNode rdsNode, uint dataBlockId, uint streamId, uint subStream)
{
PssgNode rsNode = new PssgNode("RENDERSTREAM", rdsNode.File, rdsNode);
rsNode.AddAttribute("dataBlock", $"#block{dataBlockId}");
rsNode.AddAttribute("subStream", subStream);
rsNode.AddAttribute("id", $"stream{streamId}");
rdsNode.ChildNodes.Add(rsNode);
}
public RenderDataSourceReader(PssgNode rdsNode)
{
var risNode = rdsNode.ChildNodes.FirstOrDefault(n => n.Name == "RENDERINDEXSOURCE") ??
throw new InvalidDataException($"RDS node {rdsNode.Attributes["id"].GetValue<string>()} must have RENDERINDEXSOURCE as its first child.");
var isdNode = risNode.ChildNodes.FirstOrDefault(n => n.Name == "INDEXSOURCEDATA") ??
throw new InvalidDataException($"RENDERINDEXSOURCE node {risNode.Attributes["id"].GetValue<string>()} must have INDEXSOURCEDATA as its first child.");
// Setup indices
_indexFormat = risNode.Attributes["format"].GetValue <string>();
_indexStride = GetIndexStride(_indexFormat);
Primitive = risNode.Attributes["primitive"].GetValue <string>();
IndexCount = risNode.Attributes["count"].GetValue <uint>();
_indexData = ((byte[])isdNode.Value);
// Setup vertex attributes
var renderStreamNodes = rdsNode.FindNodes("RENDERSTREAM").ToList();
_vertexAttributes = new Dictionary <string, VertexAttributeData>();
_texCoordSets = new List <VertexAttributeData>();
foreach (var rsNode in renderStreamNodes)
{
var dbId = rsNode.Attributes["dataBlock"].GetValue <string>().Substring(1);
var subStream = rsNode.Attributes["subStream"].GetValue <uint>();
var dbNode = rsNode.File.FindNodes("DATABLOCK", "id", dbId).First();
var dbStreamNode = dbNode.ChildNodes[(int)subStream];
var size = dbNode.Attributes["size"].GetValue <uint>();
var elemCount = dbNode.Attributes["elementCount"].GetValue <uint>();
var dataBlockDataNode = dbNode.FindNodes("DATABLOCKDATA").First();
var data = (byte[])dataBlockDataNode.Value;
var renderType = dbStreamNode.Attributes["renderType"].GetValue <string>();
var offset = dbStreamNode.Attributes["offset"].GetValue <uint>();
var stride = dbStreamNode.Attributes["stride"].GetValue <uint>();
var dataType = dbStreamNode.Attributes["dataType"].GetValue <string>();
if (data.Length != size)
{
throw new InvalidDataException($"The data block size ({size}) is different than data block data size ({data.Length}).");
}
var attr = new VertexAttributeData(renderType, dataType, elemCount, offset, stride, data);
if (attr.Name == "ST")
{
// tex coords are a different case since I need to differentiate them into different uv sets
_texCoordSets.AddRange(HandleSTAttribute(attr));
}
else
{
_vertexAttributes.Add(attr.Name, attr);
}
}
public ImportState(PssgNode rdsLib, PssgNode ribLib, Dictionary <string, ShaderInputInfo> shaderGroupMap)
{
RenderNodeName = "RENDERNODE";
RdsLib = rdsLib;
RibLib = ribLib;
ShaderGroupMap = shaderGroupMap;
MatShaderMapping = new Dictionary <int, ShaderInstanceData>();
if (rdsLib == ribLib)
{
IsF1 = true;
}
}
public ImportState(PssgNode rdsLib, PssgNode ribLib, Dictionary <string, ShaderInputInfo> shaderGroupMap)
{
RdsLib = rdsLib;
RibLib = ribLib;
ShaderGroupMap = shaderGroupMap;
MatShaderMapping = new Dictionary <int, ShaderInstanceData>();
LodMatcher = new Regex("^LOD([0-9]+)_$", RegexOptions.CultureInvariant);
if (rdsLib == ribLib)
{
IsF1 = true;
}
}
private static void CreateMatrixPaletteJointNode(PssgNode parent, Node gltfNode, ImportState state)
{
var node = new PssgNode("MATRIXPALETTEJOINTNODE", parent.File, parent);
node.AddAttribute("matrixPalette", $"#x{state.LodNumber}_MPN");
node.AddAttribute("stopTraversal", 0u);
node.AddAttribute("nickname", gltfNode.Name);
node.AddAttribute("id", gltfNode.Name);
parent.ChildNodes.Add(node);
// Now add a new mesh from mesh builder
ConvertMesh(node, gltfNode, state);
}
private static NodeBuilder CreateMeshNode(SceneBuilder sceneBuilder, PssgNode mpjnNode, NodeBuilder parent, ExportState state)
{
string name = (string)mpjnNode.Attributes["id"].Value;
NodeBuilder node = parent.CreateNode(name);
node.LocalTransform = GetTransform(mpjnNode);
var mesh = ConvertMesh(mpjnNode, state);
sceneBuilder.AddRigidMesh(mesh, node);
return(node);
}
public PssgNodeViewModel(PssgNode node, PssgNodeViewModel parent)
{
this.node = node;
this.parent = parent;
attributes = new ObservableCollection <PssgAttributeViewModel>();
//this.attributes = new ObservableCollection<PssgAttributeViewModel>(
// from attribute in node.Attributes
// select new PssgAttributeViewModel(attribute));
children = new ObservableCollection <PssgNodeViewModel>(
from child in node.ChildNodes
select new PssgNodeViewModel(child, this));
}
private static PssgNode CreateMatrixPaletteBundleNode(PssgNode parent, Node gltfNode, int lodNumber, ImportState state)
{
PssgNode node = new PssgNode("MATRIXPALETTEBUNDLENODE", parent.File, parent);
node.AddAttribute("stopTraversal", 0u);
node.AddAttribute("nickname", $"LOD{lodNumber}_");
node.AddAttribute("id", $"LOD{lodNumber}_");
parent.ChildNodes.Add(node);
var transformNode = new PssgNode("TRANSFORM", node.File, node);
transformNode.Value = GetTransform(gltfNode.LocalMatrix);
node.ChildNodes.Add(transformNode);
var bboxNode = new PssgNode("BOUNDINGBOX", node.File, node);
bboxNode.Value = GetBoundingBoxData(Vector3.Zero, Vector3.Zero);
node.ChildNodes.Add(bboxNode);
state.LodNumber = lodNumber;
state.JointId = 0;
state.MatShaderMapping.Clear();
List <string> jointNames = new List <string>();
foreach (var child in gltfNode.VisualChildren)
{
if (child.Mesh is null)
{
continue;
}
if (child.Mesh.Primitives.Count == 0)
{
continue;
}
CreateMatrixPaletteJointNode(node, child, state);
jointNames.Add(node.ChildNodes.Last().Attributes["id"].GetValue <string>());
}
CreateMatrixPaletteNode(node, jointNames, state);
// Write the mesh data
var rdsLib = node.File.FindNodes("LIBRARY", "type", "RENDERDATASOURCE").First();
var ribLib = node.File.FindNodes("LIBRARY", "type", "RENDERINTERFACEBOUND").First();
WriteMeshData(rdsLib, ribLib, state);
return(node);
}
private static IMeshBuilder <MaterialBuilder> ConvertMesh(PssgNode mpjnNode, ExportState state)
{
IEnumerable <PssgNode> primitives = mpjnNode.FindNodes("MATRIXPALETTERENDERINSTANCE"); // RD: Grid
primitives = primitives.Concat(mpjnNode.FindNodes("MATRIXPALETTEJOINTRENDERINSTANCE")); // Dirt 2 and beyond
var primitiveDatas = new List <PrimitiveData>();
var texCoordSets = 0;
foreach (var prim in primitives)
{
var shaderName = ((string)prim.Attributes["shader"].Value).Substring(1);
var material = CreateMaterialBuilder(shaderName, state, out var createdNew);
string rdsId = ((string)prim.Attributes["indices"].Value).Substring(1);
var rdsNode = prim.File.FindNodes("RENDERDATASOURCE", "id", rdsId).First();
var rds = new RenderDataSourceReader(rdsNode);
texCoordSets = Math.Max(texCoordSets, rds.TexCoordSetCount);
primitiveDatas.Add(new PrimitiveData(prim, material, createdNew, rds));
}
string name = (string)mpjnNode.Attributes["id"].Value;
var mb = CreateMeshBuilder(name, texCoordSets);
foreach (var prim in primitiveDatas)
{
if (prim.CreatedNewMaterial)
{
ConvertMaterial(prim.Node.File, prim.Material, prim.Rds.TexCoordSetCount);
}
var pb = mb.UsePrimitive(prim.Material);
var rds = prim.Rds;
var indexOffset = prim.Node.Attributes["indexOffset"].GetValue <uint>();
var indexCount = prim.Node.Attributes["indicesCountFromOffset"].GetValue <uint>();
var triangles = rds.GetTriangles((int)indexOffset, (int)indexCount);
foreach (var tri in triangles)
{
pb.AddTriangle(
CreateVertexBuilder(rds, tri.A, state),
CreateVertexBuilder(rds, tri.B, state),
CreateVertexBuilder(rds, tri.C, state));
}
}
return(mb);
}
private void SaveTag()
{
PssgNode node;
if (file.RootNode == null)
{
node = new PssgNode("PSSGDATABASE", file, null);
file.RootNode = node;
nodesWorkspace.LoadData(file);
}
else
{
node = file.RootNode;
}
PssgAttribute attribute = node.AddAttribute("creatorApplication", Properties.Resources.AppTitleLong);
}
private static void ConvertSceneNodes(PssgFile pssg, PssgNode parent, Node gltfNode, ImportState state)
{
PssgNode node;
if (gltfNode.Name.StartsWith("Scene Root", StringComparison.InvariantCulture))
{
node = new PssgNode("ROOTNODE", parent.File, parent);
node.AddAttribute("stopTraversal", 0u);
node.AddAttribute("nickname", "Scene Root");
node.AddAttribute("id", "Scene Root");
parent.ChildNodes.Add(node);
}
else if (gltfNode.Mesh is not null)
{
_ = CreateRenderNode(parent, gltfNode, state);
return;
}
else
{
node = new PssgNode("NODE", parent.File, parent);
node.AddAttribute("stopTraversal", 0u);
node.AddAttribute("nickname", gltfNode.Name);
node.AddAttribute("id", gltfNode.Name);
parent.ChildNodes.Add(node);
}
var transformNode = new PssgNode("TRANSFORM", node.File, node)
{
Value = GetTransform(gltfNode.LocalMatrix)
};
node.ChildNodes.Add(transformNode);
var bboxNode = new PssgNode("BOUNDINGBOX", node.File, node)
{
Value = GetBoundingBoxData(Vector3.Zero, Vector3.Zero)
};
node.ChildNodes.Add(bboxNode);
foreach (var child in gltfNode.VisualChildren)
{
ConvertSceneNodes(pssg, node, child, state);
}
}
private void AddNode_Execute(object parameter)
{
PssgNodeViewModel nodeView = (PssgNodeViewModel)parameter;
AddNodeWindow aaw = new AddNodeWindow();
if (aaw.ShowDialog() == true)
{
PssgNode newNode = nodeView.Node.AppendChild(aaw.NodeName);
if (newNode == null)
{
return;
}
PssgNodeViewModel newNodeView = new PssgNodeViewModel(newNode, nodeView);
nodeView.Children.Add(newNodeView);
}
}
private void Import_Execute(object parameter)
{
PssgNodeViewModel nodeView = (PssgNodeViewModel)parameter;
OpenFileDialog dialog = new OpenFileDialog();
dialog.Filter = "Xml files|*.xml|All files|*.*";
dialog.Title = "Select a xml file";
dialog.FileName = "node.xml";
if (dialog.ShowDialog() == true)
{
try
{
PssgNode node = nodeView.Node;
using (FileStream fileStream = File.Open(dialog.FileName, FileMode.Open, FileAccess.Read, FileShare.Read))
{
XDocument xDoc = XDocument.Load(fileStream);
PssgNode newNode = new PssgNode((XElement)((XElement)xDoc.FirstNode).FirstNode, node.File, node.ParentNode);
if (node.ParentNode != null)
{
node = node.ParentNode.SetChild(node, newNode);
int index = nodeView.Parent.Children.IndexOf(nodeView);
PssgNodeViewModel newNodeView = new PssgNodeViewModel(node, nodeView.Parent);
nodeView.Parent.Children[index] = newNodeView;
newNodeView.IsSelected = true;
}
else
{
node.File.RootNode = newNode;
LoadData(node.File);
rootNode.IsSelected = true;
}
mainView.TexturesWorkspace.ClearData();
mainView.TexturesWorkspace.LoadData(RootNode);
}
}
catch (Exception ex)
{
MessageBox.Show("Could not import the node!" + Environment.NewLine + Environment.NewLine +
ex.Message, "Import Failed", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
}
private static PssgNode CreateMatrixPaletteBundleNode(PssgNode parent, Node gltfNode, int lodNumber, ImportState state)
{
PssgNode node = new PssgNode("MATRIXPALETTEBUNDLENODE", parent.File, parent);
node.AddAttribute("stopTraversal", 0u);
node.AddAttribute("nickname", $"LOD{lodNumber}_");
node.AddAttribute("id", $"LOD{lodNumber}_");
parent.ChildNodes.Add(node);
var transformNode = new PssgNode("TRANSFORM", node.File, node);
transformNode.Value = GetTransform(gltfNode.LocalMatrix);
node.ChildNodes.Add(transformNode);
var bboxNode = new PssgNode("BOUNDINGBOX", node.File, node);
bboxNode.Value = GetBoundingBoxData(Vector3.Zero, Vector3.Zero);
node.ChildNodes.Add(bboxNode);
state.LodNumber = lodNumber;
state.MatShaderMapping.Clear();
foreach (var child in gltfNode.VisualChildren)
{
if (child.Mesh is null)
{
continue;
}
if (child.Mesh.Primitives.Count == 0)
{
continue;
}
CreateMatrixPaletteJointNode(node, child, state);
}
CreateMatrixPaletteNode(node, state);
// Write the mesh data
WriteMeshData(state);
return(node);
}
private static PssgNode CreateRenderNode(PssgNode parent, Node gltfNode, ImportState state)
{
var node = new PssgNode(state.RenderNodeName, parent.File, parent);
node.AddAttribute("stopTraversal", 0u);
node.AddAttribute("nickname", gltfNode.Name);
node.AddAttribute("id", gltfNode.Name);
parent.ChildNodes.Add(node);
state.MatShaderMapping.Clear();
// Now add a new mesh from mesh builder
ConvertMesh(node, gltfNode, state);
// Write the mesh data
WriteMeshData(state);
return(node);
}
private static void ConvertSceneNodes(PssgFile pssg, PssgNode parent, Node gltfNode, ImportState state)
{
PssgNode node;
Match lodMatch;
if (gltfNode.Name.StartsWith("Scene Root"))
{
node = new PssgNode("ROOTNODE", parent.File, parent);
node.AddAttribute("stopTraversal", 0u);
node.AddAttribute("nickname", "Scene Root");
node.AddAttribute("id", "Scene Root");
parent.ChildNodes.Add(node);
}
else if ((lodMatch = state.LodMatcher.Match(gltfNode.Name)).Success)
{
var lodNumber = int.Parse(lodMatch.Groups[1].Value);
node = CreateMatrixPaletteBundleNode(parent, gltfNode, lodNumber, state);
return;
}
else
{
node = new PssgNode("NODE", parent.File, parent);
node.AddAttribute("stopTraversal", 0u);
node.AddAttribute("nickname", gltfNode.Name);
node.AddAttribute("id", gltfNode.Name);
parent.ChildNodes.Add(node);
}
var transformNode = new PssgNode("TRANSFORM", node.File, node);
transformNode.Value = GetTransform(gltfNode.LocalMatrix);
node.ChildNodes.Add(transformNode);
var bboxNode = new PssgNode("BOUNDINGBOX", node.File, node);
bboxNode.Value = GetBoundingBoxData(Vector3.Zero, Vector3.Zero);
node.ChildNodes.Add(bboxNode);
foreach (var child in gltfNode.VisualChildren)
{
ConvertSceneNodes(pssg, node, child, state);
}
}
private static void CreateNode(SceneBuilder sceneBuilder, PssgNode node, NodeBuilder?parent, ExportState state)
{
// only consider a scene node if it has a transform child node
if (!node.ChildNodes.Any(c => c.Name == "TRANSFORM"))
{
return;
}
NodeBuilder gltfNode;
if (parent is null)
{
string name = (string)node.Attributes["id"].Value;
gltfNode = new NodeBuilder(name);
gltfNode.LocalTransform = GetTransform(node);
}
else if (node.Name == "MATRIXPALETTEJOINTNODE")
{
gltfNode = CreateMeshNode(sceneBuilder, node, parent, state);
}
else if (node.Name == "MATRIXPALETTENODE")
{
// do nothing for this node
return;
}
else if (node.Name == "NODE" || node.Name == "MATRIXPALETTEBUNDLENODE")
{
string name = (string)node.Attributes["id"].Value;
gltfNode = parent.CreateNode(name);
gltfNode.LocalTransform = GetTransform(node);
}
else
{
throw new NotImplementedException($"Support for node {node.Name} not implemented.");
}
foreach (var child in node.ChildNodes)
{
CreateNode(sceneBuilder, child, gltfNode, state);
}
}
private static void CreateMatrixPaletteNode(PssgNode parent, List <string> jointNames, ImportState state)
{
var node = new PssgNode("MATRIXPALETTENODE", parent.File, parent);
node.AddAttribute("jointCount", state.JointId);
node.AddAttribute("stopTraversal", 0u);
node.AddAttribute("id", $"x{state.LodNumber}_MPN");
parent.ChildNodes.Add(node);
var transformNode = new PssgNode("TRANSFORM", node.File, node);
transformNode.Value = GetTransform(Matrix4x4.Identity);
node.ChildNodes.Add(transformNode);
var bboxNode = new PssgNode("BOUNDINGBOX", node.File, node);
bboxNode.Value = GetBoundingBoxData(Vector3.Zero, Vector3.Zero);
node.ChildNodes.Add(bboxNode);
foreach (var shader in state.MatShaderMapping.Values)
{
var rsiNode = new PssgNode("RENDERSTREAMINSTANCE", node.File, node);
rsiNode.AddAttribute("sourceCount", 1u);
rsiNode.AddAttribute("indices", $"#{shader.Rds.Name}");
rsiNode.AddAttribute("streamCount", 0u);
rsiNode.AddAttribute("shader", $"#{shader.ShaderInstanceName}");
rsiNode.AddAttribute("id", shader.Rds.Name.Replace("RDS", "RSI"));
node.ChildNodes.Add(rsiNode);
var risNode = new PssgNode("RENDERINSTANCESOURCE", rsiNode.File, rsiNode);
risNode.AddAttribute("source", $"#{shader.Rds.Name}");
rsiNode.ChildNodes.Add(risNode);
}
foreach (var jointName in jointNames)
{
var mpsjNode = new PssgNode("MATRIXPALETTESKINJOINT", node.File, node);
mpsjNode.AddAttribute("joint", $"#{jointName}");
node.ChildNodes.Add(mpsjNode);
}
}
private void Export_Execute(object parameter)
{
PssgNode node = ((PssgTextureViewModel)parameter).Texture;
SaveFileDialog dialog = new SaveFileDialog();
dialog.Filter = "Dds files|*.dds|All files|*.*";
dialog.Title = "Select the dds save location and file name";
dialog.FileName = node.Attributes["id"].DisplayValue + ".dds";
if (dialog.ShowDialog() == true)
{
try
{
DdsFile dds = new DdsFile(node, false);
dds.Write(File.Open(dialog.FileName, FileMode.Create), -1);
}
catch (Exception ex)
{
MessageBox.Show("Could not export texture!" + Environment.NewLine + Environment.NewLine +
ex.Message, "Export Failed", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
}
private void Export_Execute(object parameter)
{
PssgNode node = ((PssgNodeViewModel)parameter).Node;
SaveFileDialog dialog = new SaveFileDialog();
dialog.Filter = "Xml files|*.xml|All files|*.*";
dialog.Title = "Select the node's save location and file name";
dialog.DefaultExt = "xml";
dialog.FileName = "node.xml";
if (dialog.ShowDialog() == true)
{
try
{
XDocument xDoc = new XDocument(new XDeclaration("1.0", "utf-8", "yes"));
xDoc.Add(new XElement("PSSGFILE", new XAttribute("version", "1.0.0.0")));
XmlWriterSettings settings = new XmlWriterSettings();
settings.Encoding = new UTF8Encoding(false);
settings.NewLineChars = "\n";
settings.Indent = true;
settings.IndentChars = "";
settings.CloseOutput = true;
XElement pssg = (XElement)xDoc.FirstNode;
node.WriteXml(pssg);
using (XmlWriter writer = XmlWriter.Create(File.Open(dialog.FileName, FileMode.Create, FileAccess.Write, FileShare.Read), settings))
{
xDoc.Save(writer);
}
}
catch (Exception ex)
{
MessageBox.Show("Could not export the node!" + Environment.NewLine + Environment.NewLine +
ex.Message, "Export Failed", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
}
private void Import_Execute(object parameter)
{
PssgTextureViewModel texView = (PssgTextureViewModel)parameter;
PssgNode node = texView.Texture;
OpenFileDialog dialog = new OpenFileDialog();
dialog.Filter = "Dds files|*.dds|All files|*.*";
dialog.Title = "Select a dds file";
dialog.FileName = node.Attributes["id"].DisplayValue + ".dds";
if (dialog.ShowDialog() == true)
{
try
{
DdsFile dds = new DdsFile(File.Open(dialog.FileName, FileMode.Open));
dds.Write(node);
texView.GetPreview();
}
catch (Exception ex)
{
MessageBox.Show("Could not import texture!" + Environment.NewLine + Environment.NewLine +
ex.Message, "Import Failed", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
}
protected static Matrix4x4 GetTransform(PssgNode sceneNode)
{
var transformNode = sceneNode.FindNodes("TRANSFORM").First();
return(GetTransform(transformNode.Value));
}
protected record PrimitiveData(PssgNode Node, MaterialBuilder Material, bool CreatedNewMaterial, RenderDataSourceReader Rds);
static ShaderInputInfo?GetShaderInfo(PssgNode rdsNode, HashSet <string> visitedShaders)
{
var rdsId = rdsNode.Attributes["id"].GetValue <string>();
var risNode = rdsNode.File.FindNodes("RENDERINSTANCESOURCE", "source", '#' + rdsId).FirstOrDefault();
var shaderInstanceId = risNode?.ParentNode?.Attributes["shader"].GetValue <string>().Substring(1);
if (shaderInstanceId is null)
{
return(null);
}
var siNode = rdsNode.File.FindNodes("SHADERINSTANCE", "id", shaderInstanceId).FirstOrDefault();
if (siNode is null)
{
return(null);
}
var shaderGroupId = siNode.Attributes["shaderGroup"].GetValue <string>().Substring(1);
var sgNode = rdsNode.File.FindNodes("SHADERGROUP", "id", shaderGroupId).FirstOrDefault();
if (sgNode is null)
{
return(null);
}
if (visitedShaders.Contains(shaderGroupId))
{
return(null);
}
var dataBlockIdMap = new Dictionary <string, int>();
var blockInputs = new List <ShaderBlockInputInfo>();
var renderStreamNodes = rdsNode.FindNodes("RENDERSTREAM");
foreach (var rsNode in renderStreamNodes)
{
var dbId = rsNode.Attributes["dataBlock"].GetValue <string>().Substring(1);
var subStream = rsNode.Attributes["subStream"].GetValue <uint>();
var dbNode = rsNode.File.FindNodes("DATABLOCK", "id", dbId).First();
var dbStreamNode = dbNode.ChildNodes[(int)subStream];
var renderType = dbStreamNode.Attributes["renderType"].GetValue <string>();
var offset = dbStreamNode.Attributes["offset"].GetValue <uint>();
var stride = dbStreamNode.Attributes["stride"].GetValue <uint>();
var dataType = dbStreamNode.Attributes["dataType"].GetValue <string>();
var vi = new ShaderVertexInputInfo(renderType, dataType, offset, stride);
if (dataBlockIdMap.TryGetValue(dbId, out var biIndex))
{
var bi = blockInputs[biIndex];
bi.VertexInputs.Add(vi);
}
else
{
var bi = new ShaderBlockInputInfo(new List <ShaderVertexInputInfo>());
bi.VertexInputs.Add(vi);
dataBlockIdMap.Add(dbId, blockInputs.Count);
blockInputs.Add(bi);
}
}
visitedShaders.Add(shaderGroupId);
return(new ShaderInputInfo(shaderGroupId, blockInputs));
}
public PssgNodeViewModel(PssgNode node)
: this(node, null)
{
}
