internal ResDict <T> LoadDictValues <T>(long dictionaryOffset, long valueOffset)
where T : IResData, new()
{
if (dictionaryOffset == 0)
{
return(new ResDict <T>());
}
using (TemporarySeek(dictionaryOffset, SeekOrigin.Begin))
{
ResDict <T> dict = new ResDict <T>();
((IResData)dict).Load(this);
//Load data via list next to dictionary
var keys = dict.Keys.ToList();
var values = LoadList <T>(dict.Count, (uint)valueOffset);
dict.Clear();
for (int i = 0; i < keys.Count; i++)
{
dict.Add(keys[i], values[i]);
}
return(dict);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Texture"/> class.
/// </summary>
public Texture()
{
CompSelR = GX2CompSel.ChannelR;
CompSelG = GX2CompSel.ChannelG;
CompSelB = GX2CompSel.ChannelB;
CompSelA = GX2CompSel.ChannelA;
Name = "";
Path = "";
Width = 0;
Height = 0;
Depth = 1;
Swizzle = 0;
Alignment = 0x1000;
ArrayLength = 1;
Pitch = 32;
TileMode = GX2TileMode.Mode2dTiledThin1;
AAMode = GX2AAMode.Mode1X;
Dim = GX2SurfaceDim.Dim2D;
Format = GX2SurfaceFormat.T_BC1_SRGB;
Data = new byte[0];
MipData = new byte[0];
MipOffsets = new uint[13];
Regs = new uint[5];
UserData = new ResDict <UserData>();
}
private void AddNodeGroup <T>(ResDict <T> SubSections, BCRESGroupNode Folder)
where T : CtrObject, new()
{
if (SubSections == null || SubSections.Count == 0)
{
return;
}
Nodes.Add(Folder);
foreach (CtrObject section in SubSections.Values)
{
switch (Folder.Type)
{
case BCRESGroupType.Models:
var CMDLWrapper = new CMDLWrapper((Model)section, this);
Folder.AddNode(CMDLWrapper);
RenderedBcres.Models.Add(CMDLWrapper);
break;
case BCRESGroupType.Textures:
Folder.AddNode(new TXOBWrapper((Texture)section, this));
PluginRuntime.bcresTexContainers.Add(Folder);
break;
}
}
}
public TextureFolder(BFRES bfres, ResFile resFile, ResDict <TextureShared> resDict, ExternalFile externalTextureFile)
{
if (externalTextureFile != null)
{
var bntxFile = externalTextureFile.LoadedFileData as BntxFile;
Tag = new BntxWrapper(bntxFile);
}
List <TextureAsset> assetList = new List <TextureAsset>();
foreach (TextureShared tex in resDict.Values)
{
var node = new BfresNodeBase(tex.Name);
node.Icon = "/Images/Texture.png";
AddChild(node);
if (tex is BfresLibrary.WiiU.Texture)
{
FtexTexture ftex = new FtexTexture(resFile, (BfresLibrary.WiiU.Texture)tex);
bfres.Textures.Add(ftex);
node.Tag = ftex;
assetList.Add(ftex.TextureAsset);
}
else
{
var texture = (BfresLibrary.Switch.SwitchTexture)tex;
BntxTexture bntxTexture = new BntxTexture(texture.BntxFile, texture.Texture);
bfres.Textures.Add(bntxTexture);
node.Tag = bntxTexture;
}
}
}
public SceneAnimFolder(BFRES bfres, ResFile resFile, ResDict <SceneAnim> resDict)
{
foreach (SceneAnim anim in resDict.Values)
{
var node = new BfresNodeBase(anim.Name);
AddChild(node);
foreach (CameraAnim camAnim in anim.CameraAnims.Values)
{
var camnode = new BfresNodeBase(camAnim.Name);
camnode.Tag = new BfresCameraAnim(camAnim);
node.AddChild(camnode);
}
foreach (LightAnim lightAnim in anim.LightAnims.Values)
{
var camnode = new BfresNodeBase(lightAnim.Name);
node.AddChild(camnode);
}
foreach (FogAnim fogAnim in anim.FogAnims.Values)
{
var camnode = new BfresNodeBase(fogAnim.Name);
node.AddChild(camnode);
}
}
}
internal void SaveDict(ResDict dict, long ShiftPos = 0)
{
long NewPos = Position;
if (ShiftPos != 0)
{
NewPos = ShiftPos;
}
if (dict?.Count == 0 && ShiftPos == 0)
{
Write(0L);
return;
}
if (TryGetItemEntry(dict, ItemEntryType.Dict, out ItemEntry entry))
{
entry.Offsets.Add((uint)NewPos);
}
else
{
_savedItems.Add(new ItemEntry(dict, ItemEntryType.Dict, (uint)NewPos));
}
if (ShiftPos == 0)
{
Write(UInt32.MaxValue);
Write(0);
}
}
public EmbeddedFolder(BFRES bfres, ResFile resFile, ResDict <ExternalFile> resDict)
{
foreach (var file in resDict)
{
var node = new BfresNodeBase(file.Key);
node.Tag = new BfresExternalFile(file.Value, file.Key);
AddChild(node);
}
}
public void LoadKeyShapes(IList <KeyShape> KeyShapes, ResDict keys)
{
keyShapeListView.Items.Clear();
foreach (var keyShape in keys)
{
keyShapeListView.Items.Add($"{keyShape}");
}
}
public BoneVisibilityAnimFolder(BFRES bfres, ResFile resFile, ResDict <VisibilityAnim> resDict)
{
foreach (VisibilityAnim anim in resDict.Values)
{
var node = new BfresNodeBase(anim.Name);
AddChild(node);
var fsha = new BfresVisibilityAnim(anim, resFile.Name);
node.Tag = fsha;
bfres.VisibilityAnimations.Add(fsha);
}
}
public ShapeAnimFolder(BFRES bfres, ResFile resFile, ResDict <ShapeAnim> resDict)
{
foreach (ShapeAnim anim in resDict.Values)
{
var node = new BfresNodeBase(anim.Name);
AddChild(node);
var fsha = new BfresShapeAnim(anim, resFile.Name);
node.Tag = fsha;
bfres.ShapeAnimations.Add(fsha);
}
}
public TexturePatternAnimFolder(BFRES bfres, ResFile resFile, ResDict <MaterialAnim> resDict)
{
foreach (MaterialAnim anim in resDict.Values)
{
var node = new BfresNodeBase(anim.Name);
AddChild(node);
var fsha = new BfresMaterialAnim(anim, resFile.Name);
node.Tag = fsha;
bfres.MaterialAnimations.Add(fsha);
}
}
public ShaderParamAnimFolder(BFRES bfres, ResFile resFile, ResDict <MaterialAnim> resDict)
{
foreach (MaterialAnim anim in resDict.Values)
{
var node = new BfresNodeBase(anim.Name);
AddChild(node);
var fmaa = new BfresMaterialAnim(anim, resFile.Name);
node.Tag = fmaa;
bfres.MaterialAnimations.Add(fmaa);
}
}
public void LoadUserData(ResDict <UserData> UserDataList)
{
listViewCustom1.Items.Clear();
IsWiiU = true;
userData = UserDataList;
foreach (var item in userData.Values)
{
LoadUserData(item);
}
}
public SkeletalAnimFolder(BFRES bfres, ResFile resFile, ResDict <SkeletalAnim> resDict)
{
foreach (SkeletalAnim anim in resDict.Values)
{
var node = new BfresNodeBase(anim.Name);
node.Icon = "/Images/SkeletonAnimation.png";
AddChild(node);
var fska = new BfresSkeletalAnim(resFile, anim, resFile.Name);
node.Tag = fska;
bfres.SkeletalAnimations.Add(fska);
}
}
private static void WriteSamplers(XmlDocument doc, List <Sampler> samplers, ResDict samplerDictionary, string Name, XmlNode node)
{
XmlNode rootNode = doc.CreateElement(Name);
foreach (var sampler in samplers)
{
XmlNode childNode = doc.CreateElement("sampler");
AddAttribute(doc, "name", samplerDictionary.GetKey(sampler.Index), childNode);
AddAttribute(doc, "alt", sampler.AltAnnotation, childNode);
AddAttribute(doc, "index", sampler.Index.ToString(), childNode);
rootNode.AppendChild(childNode);
}
node.AppendChild(rootNode);
}
public void AddToBones(ResDict <Bone> bones, Matrix4 parentBoneMatrix, short parentBoneIndex = -1)
{
bones.Add(BoneName, new Bone
{
Name = BoneName,
Position = Vector4.Transform(new Vector4(Position.ToSkeletonScale(), 1), parentBoneMatrix.Inverted()).Xyz.ToVec3F(),
Rotation = new Syroot.Maths.Vector4F(0, 0, 0, 0),
Scale = Syroot.Maths.Vector3F.One,
ParentIndex = parentBoneIndex,
FlagsRotation = BoneFlagsRotation.EulerXYZ
});
Cob?.AddToBones(bones, Matrix4.CreateTranslation(Position.ToSkeletonScale()), (short)(bones.Count - 1));
}
public void AddToBones(ResDict <Bone> bones, Matrix4 parentBoneMatrix, short parentBoneIndex = -1)
{
bone.Name = BoneName;
bone.Position = Vector4.Transform(new Vector4(Position.ToSkeletonScale(), 1), parentBoneMatrix.Inverted()).Xyz.ToVec3F();
bone.ParentIndex = parentBoneIndex;
bones.Add(BoneName, bone);
parentBoneIndex = (short)(bones.Count - 1);
foreach (var child in Children)
{
child.AddToBones(bones, bone.CalculateRelativeMatrix() * parentBoneMatrix, parentBoneIndex);
}
}
internal ResDict LoadDict()
{
long offset = ReadInt64();
if (offset == 0)
{
return(new ResDict());
}
using (TemporarySeek(offset, SeekOrigin.Begin))
{
ResDict dict = new ResDict();
((IResData)dict).Load(this);
return(dict);
}
}
public ModelFolder(BFRES bfres, ResFile resFile, ResDict <Model> resDict)
{
foreach (Model model in resDict.Values)
{
var node = new BfresNodeBase(model.Name);
node.Icon = "/Images/Model.png";
AddChild(node);
var fmdl = new FMDL(node, bfres, model);
node.Tag = fmdl;
bfres.Models.Add(fmdl);
node.AddChild(new BfresNodeBase("Meshes"));
node.AddChild(new MaterialFolder("Materials"));
node.AddChild(new BfresNodeBase("Skeleton"));
foreach (FSHP mesh in fmdl.Meshes)
{
var meshNode = new BfresNodeBase(mesh.Name)
{
Tag = mesh,
Icon = "/Images/Mesh.png"
};
mesh.ParentNode = meshNode;
mesh.MeshSelected = (o, s) => {
meshNode.IsSelected = (bool)o;
};
node.Children[0].AddChild(meshNode);
}
foreach (FMAT mat in fmdl.Materials)
{
var matNode = new BfresNodeBase(mat.Name)
{
Tag = mat,
Icon = ((FMAT)mat).Icon,
};
mat.ParentNode = matNode;
node.Children[1].AddChild(matNode);
}
foreach (var bone in ((FSKL)fmdl.Skeleton).CreateBoneHierarchy())
{
node.Children[2].AddChild(bone);
}
}
}
internal ResDict <T> LoadDict <T>()
where T : IResData, new()
{
uint offset = ReadOffset();
if (offset == 0)
{
return(new ResDict <T>());
}
using (TemporarySeek(offset, SeekOrigin.Begin))
{
ResDict <T> dict = new ResDict <T>();
((IResData)dict).Load(this);
return(dict);
}
}
internal void SaveDict <T>(ResDict <T> dict)
where T : IResData, new()
{
if (dict?.Count == 0)
{
Write(0);
return;
}
if (TryGetItemEntry(dict, ItemEntryType.Dict, out ItemEntry entry))
{
entry.Offsets.Add((uint)Position);
}
else
{
_savedItems.Add(new ItemEntry(dict, ItemEntryType.Dict, (uint)Position));
}
Write(UInt32.MaxValue);
}
public void AddToBones(ResDict <Bone> bones, Matrix4 parentBoneMatrix, short parentBoneIndex = -1)
{
int cobCount = bones.Keys.Count(x => x.StartsWith(ModelName));
string modelName = ModelName;
if (cobCount > 0)
{
modelName = ModelName + cobCount + 1;
}
bones.Add(modelName, new Bone
{
Name = modelName,
Position = Vector4.Transform(new Vector4(Position.ToSkeletonScale(), 1), parentBoneMatrix.Inverted()).Xyz.ToVec3F(),
Rotation = new Syroot.Maths.Vector4F(0, 0, 0, 1),
Scale = Syroot.Maths.Vector3F.One,
ParentIndex = parentBoneIndex,
FlagsRotation = BoneFlagsRotation.EulerXYZ
});
}
public void AddToBones(ResDict <Bone> bones, Matrix4 parentBoneMatrix, short parentBoneIndex = -1)
{
bones.Add(Name, new Bone
{
Name = Name,
Position = Vector4.Transform(new Vector4(0, 0, 0, 1), parentBoneMatrix.Inverted()).Xyz.ToVec3F(),
Rotation = new Syroot.Maths.Vector4F(0, 0, 0, 1),
Scale = Syroot.Maths.Vector3F.One,
ParentIndex = parentBoneIndex,
FlagsRotation = BoneFlagsRotation.EulerXYZ
});
parentBoneIndex = (short)(bones.Count - 1);
foreach (WorldMapPoint point in RoutePoints)
{
point.AddToBones(bones, parentBoneMatrix, parentBoneIndex);
parentBoneMatrix = Matrix4.CreateTranslation(point.Position.ToSkeletonScale());
parentBoneIndex++;
}
}
public static ResDict <UserData> Convert(Dictionary <string, object> userData)
{
ResDict <UserData> userDataDict = new ResDict <UserData>();
foreach (var param in userData)
{
UserData usd = new UserData();
string type = param.Key.Split('|')[0];
string name = param.Key.Split('|')[1];
UserDataType dataType = (UserDataType)Enum.Parse(typeof(UserDataType), type);
if (dataType == UserDataType.Single)
{
usd = SetUserData(name, ((JArray)param.Value).ToObject <float[]>());
}
if (dataType == UserDataType.Int32)
{
usd = SetUserData(name, ((JArray)param.Value).ToObject <int[]>());
}
if (dataType == UserDataType.Byte)
{
usd = SetUserData(name, ((JArray)param.Value).ToObject <byte[]>());
}
if (dataType == UserDataType.String)
{
usd = SetUserData(name, ((JArray)param.Value).ToObject <string[]>());
}
if (dataType == UserDataType.WString)
{
usd = SetUserData(name, ((JArray)param.Value).ToObject <string[]>(), true);
}
userDataDict.Add(usd.Name, usd);
}
return(userDataDict);
}
public BoneIter(ResDict <Bone> bones)
{
this.bones = bones;
}
public static void Render(ResDict <UserData> userDataDict)
{
if (ImGui.Button("Add"))
{
var userData = new UserData();
userData.Name = " ";
Selected.Add(userData);
dialogOpen = true;
ImGui.OpenPopup("##user_data_dialog");
if (ActiveDialog.LoadDialog(userData, dialogOpen))
{
userDataDict.Add(userData.Name, userData);
}
}
var diabledTextColor = ImGui.GetStyle().Colors[(int)ImGuiCol.TextDisabled];
if (Selected.Count == 0)
{
ImGui.PushStyleColor(ImGuiCol.Text, diabledTextColor);
}
ImGui.SameLine();
if (ImGui.Button("Remove") && Selected.Count > 0)
{
foreach (var usd in Selected)
{
userDataDict.Remove(usd);
}
}
ImGui.SameLine();
if (ImGui.Button("Edit") && Selected.Count > 0)
{
dialogOpen = true;
ImGui.OpenPopup("##user_data_dialog");
}
if (Selected.Count == 0)
{
ImGui.PopStyleColor();
}
if (Selected.Count > 0 && dialogOpen)
{
ActiveDialog.LoadDialog(Selected.FirstOrDefault(), dialogOpen);
}
RenderHeader();
if (ImGui.BeginChild("USER_DATA_LIST"))
{
int index = 0;
foreach (var userData in userDataDict.Values)
{
bool isSelected = Selected.Contains(userData);
ImGui.Columns(2);
if (ImGui.Selectable(userData.Name, isSelected))
{
Selected.Clear();
Selected.Add(userData);
}
ImGui.NextColumn();
ImGui.Text(GetDataString(userData, ","));
ImGui.NextColumn();
if (isSelected && ImGui.IsMouseDoubleClicked(0))
{
dialogOpen = true;
ImGui.OpenPopup("##user_data_dialog");
}
index++;
ImGui.Columns(1);
}
}
ImGui.EndChild();
}
private static void WriteUniformBlocks(XmlDocument doc, List <UniformBlock> uniformBlocks, ResDict uniformBlockeDictionary, string Name, XmlNode node)
{
XmlNode rootNode = doc.CreateElement(Name);
foreach (var block in uniformBlocks)
{
XmlNode childNode = doc.CreateElement("uniform_block");
AddAttribute(doc, "name", uniformBlockeDictionary.GetKey(block.Index), childNode);
AddAttribute(doc, "size", block.Size.ToString(), childNode);
AddAttribute(doc, "type", block.Type.ToString(), childNode);
rootNode.AppendChild(childNode);
int ind = 0;
foreach (var uniform in block.Uniforms)
{
XmlNode uniformsNode = doc.CreateElement("uniform");
if (ind < block.UniformDict.Count && ind >= 0)
{
AddAttribute(doc, "name", block.UniformDict.GetKey(ind), uniformsNode);
}
AddAttribute(doc, "index", uniform.Index.ToString(), uniformsNode);
AddAttribute(doc, "block_index", uniform.BlockIndex.ToString(), uniformsNode);
AddAttribute(doc, "offset", uniform.Offset.ToString(), uniformsNode);
if (ind < (block.UniformDict.Count - 1) && ind >= 0)
{
uint nextOffset = block.Uniforms[ind + 1].Offset;
uint currentOffset = block.Uniforms[ind].Offset;
uint Size = nextOffset - currentOffset;
AddAttribute(doc, "size", Size.ToString(), uniformsNode);
}
if (ind == (block.UniformDict.Count - 1))
{
AddAttribute(doc, "size", (block.Size - uniform.Offset).ToString(), uniformsNode);
}
childNode.AppendChild(uniformsNode);
ind++;
}
}
node.AppendChild(rootNode);
}
private static void WriteAttributes(XmlDocument doc, List <BfshaLibrary.Attribute> attributes, ResDict attributeDictionary, string Name, XmlNode node)
{
XmlNode rootNode = doc.CreateElement(Name);
foreach (var attribute in attributes)
{
XmlNode childNode = doc.CreateElement("attribute");
AddAttribute(doc, "name", attributeDictionary.GetKey(attribute.Index), childNode);
AddAttribute(doc, "location", attribute.Location.ToString(), childNode);
AddAttribute(doc, "index", attribute.Index.ToString(), childNode);
rootNode.AppendChild(childNode);
}
node.AppendChild(rootNode);
}
public WorldMapScene(SarcData sarc, string sarcName)
{
multiSelect = true;
#region read files
this.sarc = sarc;
this.sarcName = sarcName;
bfresEntry = sarc.Files.First(x => x.Key.EndsWith(".bfres"));
pointEntry = sarc.Files.First(x => x.Key.StartsWith("pointW"));
routeEntry = sarc.Files.First(x => x.Key.StartsWith("routeW"));
bfres = new ResFile(new MemoryStream(bfresEntry.Value));
bones = bfres.Models[0].Skeleton.Bones;
pointCsv = Encoding.GetEncoding("shift-jis").GetString(sarc.Files.First(file => file.Key.StartsWith("pointW")).Value).
Split(new[] { "\r\n", "\r", "\n" }, StringSplitOptions.None).Reverse().Skip(1).Select(row =>
{
int pos = 0;
List <string> fields = new List <string>();
while (pos < row.Length)
{
string value;
// Special handling for quoted field
if (row[pos] == '"')
{
// Skip initial quote
pos++;
// Parse quoted value
int start = pos;
while (pos < row.Length)
{
// Test for quote character
if (row[pos] == '"')
{
// Found one
pos++;
// If two quotes together, keep one
// Otherwise, indicates end of value
if (pos >= row.Length || row[pos] != '"')
{
pos--;
break;
}
}
pos++;
}
value = row.Substring(start, pos - start);
value = value.Replace("\"\"", "\"");
}
else
{
// Parse unquoted value
int start = pos;
while (pos < row.Length && row[pos] != ',')
{
pos++;
}
value = row.Substring(start, pos - start);
}
// Add field to list
fields.Add(value);
// Eat up to and including next comma
while (pos < row.Length && row[pos] != ',')
{
pos++;
}
if (pos < row.Length)
{
pos++;
}
}
return(fields.ToArray());
}).Reverse().ToArray().ToDictionary(x => x[1]);
routeCsv = Encoding.GetEncoding("shift-jis").GetString(sarc.Files.First(file => file.Key.StartsWith("routeW")).Value).
Split(new[] { "\r\n", "\r", "\n" }, StringSplitOptions.None).Reverse().Skip(1).Select(row =>
{
int pos = 0;
List <string> fields = new List <string>();
while (pos < row.Length)
{
string value;
// Special handling for quoted field
if (row[pos] == '"')
{
// Skip initial quote
pos++;
// Parse quoted value
int start = pos;
while (pos < row.Length)
{
// Test for quote character
if (row[pos] == '"')
{
// Found one
pos++;
// If two quotes together, keep one
// Otherwise, indicates end of value
if (pos >= row.Length || row[pos] != '"')
{
pos--;
break;
}
}
pos++;
}
value = row.Substring(start, pos - start);
value = value.Replace("\"\"", "\"");
}
else
{
// Parse unquoted value
int start = pos;
while (pos < row.Length && row[pos] != ',')
{
pos++;
}
value = row.Substring(start, pos - start);
}
// Add field to list
fields.Add(value);
// Eat up to and including next comma
while (pos < row.Length && row[pos] != ',')
{
pos++;
}
if (pos < row.Length)
{
pos++;
}
}
return(fields.ToArray());
}).Reverse().ToArray().ToDictionary(x => x[0]);
//SaveFileDialog sfd = new SaveFileDialog()
//{
// FileName = sarcName
//};
//if (sfd.ShowDialog() == DialogResult.OK)
//{
// var stream = new MemoryStream();
// bfres.Save(stream, true);
// sarc.Files[bfresEntry.Key] = stream.ToArray();
// Yaz0.Compress(new FileStream(sfd.FileName, FileMode.OpenOrCreate), SARC.PackN(sarc));
//}
#endregion
#region read map from bones
Matrix4 rootMatrix = bones[0].CalculateRelativeMatrix();
var boneIter = new BoneIter(bones);
boneIter.MoveNext(); //first bone is the root, we don't need to read it
while (boneIter.MoveNext())
{
var bone = boneIter.Current;
if (bone.ParentIndex == -1) //there is more than one root (should never happen)
{
break;
}
if (bone.Name.StartsWith("R")) //indicates a Route
{
Routes.Add(new WorldMapRoute(boneIter, rootMatrix, pointCsv));
continue;
}
if (bone.ParentIndex != 0)
{
throw new Exception(bone.Name + " is in an unexpected Layer, proceeding might currupt the file");
}
Vector4 pos = new Vector4(
bone.Position.X / 100,
bone.Position.Y / 100,
bone.Position.Z / 100,
1
);
if (bone.Name == "course")
{
Matrix4 courseBoneMatrix = boneIter.Current.CalculateRelativeMatrix() * rootMatrix;
short courseBoneIndex = (short)boneIter.CurrentBoneIndex;
while (boneIter.PeekNext()?.ParentIndex == courseBoneIndex)
{
boneIter.MoveNext();
if (pointCsv.ContainsKey(boneIter.Current.Name))
{
WorldMapObjects.Add(new WorldMapPoint(boneIter, courseBoneMatrix, pointCsv[boneIter.Current.Name]));
}
else
{
WorldMapObjects.Add(new UnknownWorldMapBone(boneIter, rootMatrix));
}
}
}
else if (pointCsv.ContainsKey(bone.Name))
{
WorldMapObjects.Add(new WorldMapPoint(boneIter, rootMatrix, pointCsv[bone.Name]));
}
else if (bone.Name.StartsWith("cob"))
{
WorldMapObjects.Add(new WorldMapCob(boneIter, rootMatrix));
}
else
{
WorldMapObjects.Add(new UnknownWorldMapBone(boneIter, rootMatrix));
}
}
#endregion
foreach (var route in Routes)
{
TryGetPoint(route.Name.Substring(1, 4), out WorldMapPoint start);
TryGetPoint(route.Name.Substring(5, 4), out WorldMapPoint end);
route.Start = start;
route.End = end;
}
//ModelObjectReplace();
StaticObjects.Add(new StaticModel(bfresEntry.Key, bfres));
StaticObjects.Add(new ConnectionDrawer(this));
SelectionChanged += WorldMapScene_SelectionChanged;
}
internal override void ConvertToSwitchMaterial(Material material)
{
//Convert all render info
if (material.ShaderAssign.ShadingModelName == "turbo_uber_xlu" || material.Name.Contains("CausticsArea"))
{
material.Visible = false;
return;
}
Console.WriteLine("Converting material " + material.Name);
for (int i = 0; i < 5; i++)
{
RemoveRenderInfo(material, $"gsys_model_fx{i}");
}
material.SetRenderInfo("gsys_bake_normal_map", "default");
material.SetRenderInfo("gsys_bake_emission_map", "default");
material.SetRenderInfo("gsys_render_state_display_face", GetCullState(material.RenderState));
material.SetRenderInfo("gsys_render_state_mode", GetRenderState(material.RenderState));
material.SetRenderInfo("gsys_depth_test_enable", RenderInfoBoolString(
material.RenderState.DepthControl.DepthTestEnabled));
material.SetRenderInfo("gsys_depth_test_func", CompareFunction[
material.RenderState.DepthControl.DepthFunc]);
material.SetRenderInfo("gsys_depth_test_write", RenderInfoBoolString(
material.RenderState.DepthControl.DepthWriteEnabled));
material.SetRenderInfo("gsys_alpha_test_enable", RenderInfoBoolString(
material.RenderState.AlphaControl.AlphaTestEnabled));
material.SetRenderInfo("gsys_alpha_test_func", CompareFunction[
material.RenderState.AlphaControl.AlphaFunc]);
material.SetRenderInfo("gsys_alpha_test_value",
material.RenderState.AlphaRefValue);
material.SetRenderInfo("gsys_render_state_blend_mode", GetBlendMode(material.RenderState));
material.SetRenderInfo("gsys_color_blend_rgb_op", BlendCombine[
material.RenderState.BlendControl.ColorCombine]);
material.SetRenderInfo("gsys_color_blend_rgb_src_func", BlendFunction[
material.RenderState.BlendControl.ColorSourceBlend]);
material.SetRenderInfo("gsys_color_blend_rgb_dst_func", BlendFunction[
material.RenderState.BlendControl.ColorDestinationBlend]);
material.SetRenderInfo("gsys_color_blend_alpha_op", BlendCombine[
material.RenderState.BlendControl.AlphaCombine]);
material.SetRenderInfo("gsys_color_blend_alpha_src_func", BlendFunction[
material.RenderState.BlendControl.AlphaSourceBlend]);
material.SetRenderInfo("gsys_color_blend_alpha_dst_func", BlendFunction[
material.RenderState.BlendControl.AlphaDestinationBlend]);
material.SetRenderInfo("gsys_color_blend_const_color", new float[4] {
0, 0, 0, 0
});
material.SetShaderParameter("gsys_alpha_test_ref_value",
ShaderParamType.Float, material.RenderState.AlphaRefValue);
material.SetShaderParameter("gsys_xlu_zprepass_alpha",
ShaderParamType.Float4, new float[4] {
1, 1, 1, 1
});
material.SetShaderParameter("screen_fake_scale_begin_ratio",
ShaderParamType.Float, 0.25f);
material.SetShaderParameter("screen_fake_scale_factor",
ShaderParamType.Float3, new float[3] {
0, 0, 0
});
if (!material.ShaderParams.ContainsKey("d_shadow_bake_l_cancel_rate"))
{
material.SetShaderParameter("d_shadow_bake_l_cancel_rate",
ShaderParamType.Float, 0.25f);
}
if (!material.ShaderParams.ContainsKey("decal_trail_intensity"))
{
material.SetShaderParameter("decal_trail_intensity",
ShaderParamType.Float, 1);
}
if (!material.ShaderParams.ContainsKey("indirect_magB"))
{
material.SetShaderParameter("indirect_magB",
ShaderParamType.Float2, new float[2] {
1, 1
});
}
if (!material.ShaderParams.ContainsKey("decal_trail_color"))
{
material.SetShaderParameter("decal_trail_color",
ShaderParamType.Float2, new float[3] {
1, 1, 1
});
}
material.ShaderParams.RemoveKey("effect_normal_offset");
material.ShaderParams.RemoveKey("gsys_model_fx_ratio");
material.ShaderParams.RemoveKey("gsys_specular_roughness");
material.ShaderParams.RemoveKey("zprepass_shadow_rate");
//Adjust shader params
//Here we'll make a new shader param list in the same switch order
List <ShaderParam> param = new List <ShaderParam>();
param.Add(material.ShaderParams["edge_light_rim_i"]);
param.Add(material.ShaderParams["d_shadow_bake_l_cancel_rate"]);
param.Add(material.ShaderParams["gsys_i_color_ratio0"]);
param.Add(material.ShaderParams["gsys_edge_ratio0"]);
param.Add(material.ShaderParams["gsys_edge_width0"]);
param.Add(material.ShaderParams["bloom_intensity"]);
param.Add(material.ShaderParams["gsys_outline_width"]);
param.Add(material.ShaderParams["gsys_alpha_threshold"]);
param.Add(material.ShaderParams["game_edge_pow"]);
param.Add(material.ShaderParams["edge_alpha_scale"]);
param.Add(material.ShaderParams["post_multi_texture"]);
param.Add(material.ShaderParams["edge_alpha_width"]);
param.Add(material.ShaderParams["edge_alpha_pow"]);
param.Add(material.ShaderParams["transparency"]);
param.Add(material.ShaderParams["alphat_out_start"]);
param.Add(material.ShaderParams["alphat_out_end"]);
param.Add(material.ShaderParams["gsys_area_env_index_diffuse"]);
param.Add(material.ShaderParams["shadow_density"]);
param.Add(material.ShaderParams["ao_density"]);
param.Add(material.ShaderParams["transmit_intensity"]);
param.Add(material.ShaderParams["edge_light_vc_intensity"]);
param.Add(material.ShaderParams["specular_aniso_power"]);
param.Add(material.ShaderParams["transmit_shadow_intensity"]);
param.Add(material.ShaderParams["edge_light_intensity"]);
param.Add(material.ShaderParams["light_pre_pass_intensity"]);
param.Add(material.ShaderParams["gsys_bake_opacity"]);
param.Add(material.ShaderParams["shiny_specular_intensity"]);
param.Add(material.ShaderParams["specular_intensity"]);
param.Add(material.ShaderParams["specular_roughness"]);
param.Add(material.ShaderParams["specular_fresnel_i"]);
param.Add(material.ShaderParams["specular_fresnel_s"]);
param.Add(material.ShaderParams["specular_fresnel_m"]);
param.Add(material.ShaderParams["shiny_specular_sharpness"]);
param.Add(material.ShaderParams["emission_intensity"]);
param.Add(material.ShaderParams["soft_edge_dist_inv"]);
param.Add(material.ShaderParams["silhoutte_depth"]);
param.Add(material.ShaderParams["refraction_intensity"]);
param.Add(material.ShaderParams["normal_map_weight"]);
param.Add(material.ShaderParams["shiny_specular_fresnel"]);
param.Add(material.ShaderParams["silhoutte_depth_contrast"]);
param.Add(material.ShaderParams["fresnel_look_depend_factor"]);
param.Add(material.ShaderParams["mii_hair_specular_intensity"]);
param.Add(material.ShaderParams["decal_trail_intensity"]);
param.Add(material.ShaderParams["screen_fake_scale_begin_ratio"]);
param.Add(material.ShaderParams["fog_emission_intensity"]);
param.Add(material.ShaderParams["fog_emission_effect"]);
param.Add(material.ShaderParams["fog_edge_power"]);
param.Add(material.ShaderParams["fog_edge_width"]);
param.Add(material.ShaderParams["gsys_alpha_test_ref_value"]);
param.Add(material.ShaderParams["edge_light_sharpness"]);
param.Add(material.ShaderParams["indirect_mag"]);
param.Add(material.ShaderParams["indirect_magB"]);
param.Add(material.ShaderParams["silhoutte_depth_color"]);
param.Add(material.ShaderParams["gsys_mii_skin_color"]);
param.Add(material.ShaderParams["gsys_mii_favorite_color"]);
param.Add(material.ShaderParams["gsys_point_light_color"]);
param.Add(material.ShaderParams["gsys_edge_color0"]);
param.Add(material.ShaderParams["transmit_color"]);
param.Add(material.ShaderParams["gsys_i_color0"]);
param.Add(material.ShaderParams["gsys_i_color0_b"]);
param.Add(material.ShaderParams["gsys_bake_light_scale"]);
param.Add(material.ShaderParams["gsys_bake_light_scale1"]);
param.Add(material.ShaderParams["gsys_bake_light_scale2"]);
param.Add(material.ShaderParams["albedo_tex_color"]);
param.Add(material.ShaderParams["decal_trail_color"]);
param.Add(material.ShaderParams["fog_emission_color"]);
param.Add(material.ShaderParams["screen_fake_scale_factor"]);
param.Add(material.ShaderParams["edge_light_color"]);
param.Add(material.ShaderParams["shiny_specular_color"]);
param.Add(material.ShaderParams["specular_color"]);
param.Add(material.ShaderParams["emission_color"]);
param.Add(material.ShaderParams["gsys_depth_silhoutte_color"]);
param.Add(material.ShaderParams["gsys_outline_color"]);
param.Add(material.ShaderParams["gsys_area_env_data0"]);
param.Add(material.ShaderParams["gsys_area_env_data1"]);
param.Add(material.ShaderParams["gsys_bake_st0"]);
param.Add(material.ShaderParams["gsys_bake_st1"]);
param.Add(material.ShaderParams["multi_tex_reg0"]);
param.Add(material.ShaderParams["multi_tex_reg1"]);
param.Add(material.ShaderParams["multi_tex_param0"]);
param.Add(material.ShaderParams["fog_edge_color"]);
param.Add(material.ShaderParams["gsys_xlu_zprepass_alpha"]);
param.Add(material.ShaderParams["multi_tex_reg2"]);
param.Add(material.ShaderParams["gsys_sssss_color"]);
param.Add(material.ShaderParams["tex_mtx1"]);
param.Add(material.ShaderParams["tex_mtx2"]);
param.Add(material.ShaderParams["tex_mtx0"]);
material.ShaderParams.Clear();
foreach (var prm in param)
{
material.ShaderParams.Add(prm.Name, prm);
}
//Adjust shader options
//gsys_alpha_test_enable
//gsys_alpha_test_func
//enable_screen_fake_scale
var shaderAssign = material.ShaderAssign;
shaderAssign.ShaderOptions.RemoveKey("enable_effect_normal_offset");
shaderAssign.ShaderOptions.RemoveKey("bake_calc_type");
ResDict <ResString> shaderOptions = new ResDict <ResString>();
var keys = shaderAssign.ShaderOptions.Keys.ToList();
var values = shaderAssign.ShaderOptions.Values.ToList();
int opIndex = 0;
for (int i = 0; i < keys.Count + 3; i++)
{
if (i == 0)
{
shaderOptions.Add("gsys_alpha_test_enable",
material.RenderState.AlphaControl.AlphaTestEnabled ? "0" : "0");
}
else if (i == 1)
{
shaderOptions.Add("gsys_alpha_test_func", GetShaderOptionAlphaTestFunc(
CompareFunction[material.RenderState.AlphaControl.AlphaFunc]));
}
else if (i == 100)
{
shaderOptions.Add("enable_screen_fake_scale", "0");
}
else
{
shaderOptions.Add(keys[opIndex], values[opIndex]);
opIndex++;
}
}
shaderAssign.ShaderOptions = shaderOptions;
}
