static string GetDataString(ShaderParam Param) { switch (Param.Type) { case ShaderParamType.Float: case ShaderParamType.UInt: return(Param.DataValue.ToString()); case ShaderParamType.Float2: case ShaderParamType.Float3: case ShaderParamType.Float4: return(string.Join(",", (float[])Param.DataValue)); case ShaderParamType.Srt2D: { var texSrt = (Srt2D)Param.DataValue; return($"{texSrt.Scaling.X} {texSrt.Scaling.Y} {texSrt.Rotation} {texSrt.Translation.X} {texSrt.Translation.Y}"); } case ShaderParamType.TexSrt: case ShaderParamType.TexSrtEx: { var texSrt = (TexSrt)Param.DataValue; return($"{texSrt.Mode} {texSrt.Scaling.X} {texSrt.Scaling.Y} {texSrt.Rotation} {texSrt.Translation.X} {texSrt.Translation.Y}"); } default: return(Param.DataValue.ToString()); } }
public static byte[] WriteShaderParams(this FMAT m, Material mat) { mat.ShaderParams = new List <ShaderParam>(); System.IO.MemoryStream mem = new System.IO.MemoryStream(); using (FileWriter writer = new FileWriter(mem)) { uint Offset = 0; int index = 0; writer.ByteOrder = Syroot.BinaryData.ByteOrder.LittleEndian; foreach (BfresShaderParam shaderParam in m.matparam.Values) { ShaderParam param = new ShaderParam(); param.Name = shaderParam.Name; param.Type = shaderParam.Type; param.DataOffset = (ushort)Offset; param.DependedIndex = (ushort)index; param.DependIndex = (ushort)index; writer.Seek(param.DataOffset, System.IO.SeekOrigin.Begin); shaderParam.WriteValue(writer); Offset += param.DataSize; mat.ShaderParams.Add(param); index++; } writer.Close(); } return(mem.ToArray()); }
public static byte[] WriteShaderParams(this FMAT m, Material mat) { mat.ShaderParams = new ResDict <ShaderParam>(); System.IO.MemoryStream mem = new System.IO.MemoryStream(); using (FileWriter writer = new FileWriter(mem)) { uint Offset = 0; int index = 0; writer.ByteOrder = Syroot.BinaryData.ByteOrder.BigEndian; foreach (BfresShaderParam shaderParam in m.matparam.Values) { ShaderParam param = new ShaderParam(); param.Name = shaderParam.Name; param.Type = shaderParam.SetTypeWiiU(shaderParam.Type); param.DataOffset = (ushort)Offset; param.offset = -1; param.callbackPointer = 0; param.PaddingLength = shaderParam.PaddingLength; param.DependedIndex = (ushort)index; param.DependIndex = (ushort)index; writer.Seek(param.DataOffset, System.IO.SeekOrigin.Begin); shaderParam.WriteValue(writer); Offset += (param.DataSize + (uint)shaderParam.PaddingLength); mat.ShaderParams.Add(param.Name, param); index++; } writer.Close(); } return(mem.ToArray()); }
private void ReadShaderParams(Material mat, Mesh poly) { using (Syroot.BinaryData.BinaryDataReader reader = new Syroot.BinaryData.BinaryDataReader(new MemoryStream(mat.ShaderParamData))) { reader.ByteOrder = Syroot.BinaryData.ByteOrder.LittleEndian; foreach (Syroot.NintenTools.NSW.Bfres.ShaderParam param in mat.ShaderParams) { ShaderParam prm = new ShaderParam(); prm.Type = (Syroot.NintenTools.Bfres.ShaderParamType)param.Type; switch (param.Type) { case ShaderParamType.Float: reader.Seek(param.DataOffset, SeekOrigin.Begin); prm.Value_float = reader.ReadSingle(); break; case ShaderParamType.Float2: reader.Seek(param.DataOffset, SeekOrigin.Begin); prm.Value_float2 = new Vector2( reader.ReadSingle(), reader.ReadSingle()); break; case ShaderParamType.Float3: reader.Seek(param.DataOffset, SeekOrigin.Begin); prm.Value_float3 = new Vector3( reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle()); break; case ShaderParamType.Float4: reader.Seek(param.DataOffset, SeekOrigin.Begin); prm.Value_float4 = new Vector4( reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle()); break; } poly.material.matparam.Add(param.Name, prm); } reader.Close(); } }
private static void ReadAttributes(XmlNode materialNode, MaterialData material) { ShaderParam shaderParam = new ShaderParam(); foreach (XmlAttribute attribute in materialNode.Attributes) { char[] RemoveThese = new char[] { ' ', '(', ')' }; string valueFix = string.Join("", attribute.Value.Split(RemoveThese)); switch (attribute.Name) { case "Name": shaderParam.Name = attribute.Value; break; case "ValueFloat": float.TryParse(attribute.Value, out shaderParam.Value_float); break; case "ValueFloat2": float[] f2Array = Array.ConvertAll(valueFix.Split(','), float.Parse); shaderParam.Value_float2 = new OpenTK.Vector2(f2Array[0], f2Array[1]); break; case "ValueFloat3": float[] f3Array = Array.ConvertAll(valueFix.Split(','), float.Parse); shaderParam.Value_float3 = new OpenTK.Vector3(f3Array[0], f3Array[1], f3Array[2]); break; case "ValueTexSrt": float[] srt = Array.ConvertAll(valueFix.Split(','), float.Parse); // shaderParam.Value_TexSrt.scale = new OpenTK.Vector2(srt[0], srt[1]); // shaderParam.Value_TexSrt.rotate = srt[2]; // shaderParam.Value_TexSrt.translate = new OpenTK.Vector2(srt[3], srt[4]); break; } } if (shaderParam.Name != "") { material.matparam.Add(shaderParam.Name, shaderParam); } }
private void ReadShaderParams(Material mat, Mesh poly) { using (Syroot.BinaryData.BinaryDataReader reader = new Syroot.BinaryData.BinaryDataReader(new MemoryStream(mat.ShaderParamData))) { reader.ByteOrder = Syroot.BinaryData.ByteOrder.LittleEndian; foreach (Syroot.NintenTools.NSW.Bfres.ShaderParam param in mat.ShaderParams) { ShaderParam prm = new ShaderParam(); prm.Type = (Syroot.NintenTools.Bfres.ShaderParamType)param.Type; prm.Name = param.Name; switch (param.Type) { case ShaderParamType.Float: reader.Seek(param.DataOffset, SeekOrigin.Begin); prm.Value_float = reader.ReadSingle(); break; case ShaderParamType.Float2: reader.Seek(param.DataOffset, SeekOrigin.Begin); prm.Value_float2 = new Vector2( reader.ReadSingle(), reader.ReadSingle()); break; case ShaderParamType.Float3: reader.Seek(param.DataOffset, SeekOrigin.Begin); prm.Value_float3 = new Vector3( reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle()); break; case ShaderParamType.Float4: reader.Seek(param.DataOffset, SeekOrigin.Begin); prm.Value_float4 = new Vector4( reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle()); break; case ShaderParamType.TexSrt: reader.Seek(param.DataOffset, SeekOrigin.Begin); ShaderParam.TextureSRT texSRT = new ShaderParam.TextureSRT(); texSRT.Mode = reader.ReadSingle(); //Scale mode, Maya, max ect texSRT.scale = new Vector2(reader.ReadSingle(), reader.ReadSingle()); texSRT.rotate = reader.ReadSingle(); texSRT.translate = new Vector2(reader.ReadSingle(), reader.ReadSingle()); prm.Value_TexSrt = texSRT; break; case ShaderParamType.UInt: prm.Value_UInt = reader.ReadUInt32(); break; case ShaderParamType.Bool: prm.Value_Bool = reader.ReadBoolean(); break; case ShaderParamType.Float4x4: prm.Value_float4x4 = reader.ReadSingles(16); break; } poly.material.matparam.Add(param.Name, prm); } reader.Close(); } }
private static string GenerateFloat2Initialisation(ShaderParam shaderParam) { if (string.IsNullOrEmpty(shaderParam.DefaultValue)) return ""; var values = shaderParam.DefaultValue.Replace(" ", "").Split(',').Select(v => v +"f"); var value = "new Vector2(" + string.Join(", ", values) + ");"; var line = GetPropertyName(shaderParam) + " = " + value; return line; }
private static ShaderParam CreateParam(string name, string[] lines, int index, ShaderParamType type) { var exitCondition = new Func<string, int, bool>((line, i) => line == "" || i < 0); var param = new ShaderParam { Name = name, Summary = GetValue("summary", lines, index, -1, exitCondition), MinValue = GetValue("minValue", lines, index, -1, exitCondition), MaxValue = GetValue("maxValue", lines, index, -1, exitCondition), DefaultValue = GetValue("defaultValue", lines, index, -1, exitCondition), Type = type }; return param; }
private static string GetPropertyName(ShaderParam shaderParam) { return shaderParam.Name.Substring(0, 1).ToUpper() + shaderParam.Name.Substring(1); }
private static IEnumerable<string> GenerateTextureProperty(ShaderParam shaderParam) { return GenerateProperty(shaderParam, "Texture2D", "GetValueTexture2D"); }
private static string GenerateTextureInitialisation(ShaderParam shaderParam) { if (string.IsNullOrEmpty(shaderParam.DefaultValue)) return ""; var values = GetColor(shaderParam.DefaultValue); var value = "new Texture2D(" + string.Join(", ", values) + ");"; var line = GetPropertyName(shaderParam) + " = " + value; return line; }
private void ParseParamTrack(FMAT material, STAnimGroup group, ParamTrack track) { if (!material.ShaderParams.ContainsKey(group.Name)) { return; } var value = track.GetFrameValue(this.Frame); //4 bytes per float or int value uint index = track.ValueOffset / 4; var targetParam = material.ShaderParams[group.Name]; var param = new ShaderParam(); if (!material.AnimatedParams.ContainsKey(group.Name)) { if (targetParam.DataValue is float[]) { float[] values = (float[])targetParam.DataValue; float[] dest = new float[values.Length]; Array.Copy(values, dest, values.Length); param.DataValue = dest; } else { param.DataValue = targetParam.DataValue; } param.Type = targetParam.Type; param.Name = group.Name; material.AnimatedParams.Add(group.Name, param); } param = material.AnimatedParams[group.Name]; switch (targetParam.Type) { case ShaderParamType.Float: param.DataValue = (float)value; break; case ShaderParamType.Float2: case ShaderParamType.Float3: case ShaderParamType.Float4: ((float[])param.DataValue)[index] = value; break; case ShaderParamType.Int: param.DataValue = value; break; case ShaderParamType.Int2: case ShaderParamType.Int3: case ShaderParamType.Int4: ((int[])param.DataValue)[index] = (int)value; break; case ShaderParamType.TexSrt: case ShaderParamType.TexSrtEx: { TexSrtMode mode = ((TexSrt)param.DataValue).Mode; var translateX = ((TexSrt)param.DataValue).Translation.X; var translateY = ((TexSrt)param.DataValue).Translation.Y; var rotate = ((TexSrt)param.DataValue).Rotation; var scaleX = ((TexSrt)param.DataValue).Scaling.X; var scaleY = ((TexSrt)param.DataValue).Scaling.Y; // if (track.ValueOffset == 0) mode = (TexSrtMode)Convert.ToUInt32(value); if (track.ValueOffset == 4) { scaleX = value; } if (track.ValueOffset == 8) { scaleY = value; } if (track.ValueOffset == 12) { rotate = value; } if (track.ValueOffset == 16) { translateX = value; } if (track.ValueOffset == 20) { translateY = value; } param.DataValue = new TexSrt() { Mode = mode, Scaling = new Syroot.Maths.Vector2F(scaleX, scaleY), Translation = new Syroot.Maths.Vector2F(translateX, translateY), Rotation = rotate, }; } break; case ShaderParamType.Srt2D: { var translateX = ((Srt2D)param.DataValue).Translation.X; var translateY = ((Srt2D)param.DataValue).Translation.Y; var rotate = ((Srt2D)param.DataValue).Rotation; var scaleX = ((Srt2D)param.DataValue).Scaling.X; var scaleY = ((Srt2D)param.DataValue).Scaling.Y; if (track.ValueOffset == 0) { scaleX = value; } if (track.ValueOffset == 4) { scaleY = value; } if (track.ValueOffset == 8) { rotate = value; } if (track.ValueOffset == 12) { translateX = value; } if (track.ValueOffset == 16) { translateY = value; } param.DataValue = new Srt2D() { Scaling = new Syroot.Maths.Vector2F(scaleX, scaleY), Translation = new Syroot.Maths.Vector2F(translateX, translateY), Rotation = rotate, }; } break; } }
public void Read(ResFile TargetWiiUBFRES) { Nodes.Add(TModels); Nodes.Add(TTextures); Nodes.Add(TShaderparam); Nodes.Add(TColoranim); Nodes.Add(TTextureSRT); Nodes.Add(TTexturePat); Nodes.Add(TBonevisabilty); Nodes.Add(TVisualAnim); Nodes.Add(TShapeAnim); Nodes.Add(TSceneAnim); Nodes.Add(TEmbedded); ImageKey = "bfres"; SelectedImageKey = "bfres"; FSKACount = TargetWiiUBFRES.SkeletalAnims.Count; textures.Clear(); foreach (Texture tex in TargetWiiUBFRES.Textures.Values) { string TextureName = tex.Name; FTEX texture = new FTEX(); texture.ReadFTEX(tex); textures.Add(TextureName, texture); TTextures.Nodes.Add(texture); } int ModelCur = 0; //FMDLs -Models- foreach (Model mdl in TargetWiiUBFRES.Models.Values) { FMDL_Model model = new FMDL_Model(); //This will store VBN data and stuff model.Text = mdl.Name; TModels.Nodes.Add(model); model.Node_Array = new int[mdl.Skeleton.MatrixToBoneList.Count]; int nodes = 0; foreach (ushort node in mdl.Skeleton.MatrixToBoneList) { model.Node_Array[nodes] = node; nodes++; } foreach (Syroot.NintenTools.Bfres.Bone bn in mdl.Skeleton.Bones.Values) { Bone bone = new Bone(model.skeleton); bone.Text = bn.Name; bone.boneId = bn.BillboardIndex; bone.parentIndex = bn.ParentIndex; bone.scale = new float[3]; bone.rotation = new float[4]; bone.position = new float[3]; if (bn.FlagsRotation == BoneFlagsRotation.Quaternion) { bone.boneRotationType = 1; } else { bone.boneRotationType = 0; } bone.scale[0] = bn.Scale.X; bone.scale[1] = bn.Scale.Y; bone.scale[2] = bn.Scale.Z; bone.rotation[0] = bn.Rotation.X; bone.rotation[1] = bn.Rotation.Y; bone.rotation[2] = bn.Rotation.Z; bone.rotation[3] = bn.Rotation.W; bone.position[0] = bn.Position.X; bone.position[1] = bn.Position.Y; bone.position[2] = bn.Position.Z; model.skeleton.bones.Add(bone); } model.skeleton.reset(); model.skeleton.update(); //MeshTime!! int ShapeCur = 0; foreach (Shape shp in mdl.Shapes.Values) { Mesh poly = new Mesh(); poly.Text = shp.Name; poly.MaterialIndex = shp.MaterialIndex; poly.matrFlag = shp.VertexSkinCount; poly.fsklindx = shp.BoneIndex; TModels.Nodes[ModelCur].Nodes.Add(poly); //Create a buffer instance which stores all the buffer data VertexBufferHelper helper = new VertexBufferHelper(mdl.VertexBuffers[shp.VertexBufferIndex], TargetWiiUBFRES.ByteOrder); // VertexBufferHelperAttrib uv1 = helper["_u1"]; Vertex v = new Vertex(); foreach (VertexAttrib att in mdl.VertexBuffers[shp.VertexBufferIndex].Attributes.Values) { if (att.Name == "_p0") { Console.WriteLine(att.Name); VertexBufferHelperAttrib position = helper["_p0"]; Syroot.Maths.Vector4F[] vec4Positions = position.Data; foreach (Syroot.Maths.Vector4F p in vec4Positions) { v.pos.Add(new Vector3 { X = p.X, Y = p.Y, Z = p.Z }); } } if (att.Name == "_n0") { Console.WriteLine(att.Name); VertexBufferHelperAttrib normal = helper["_n0"]; Syroot.Maths.Vector4F[] vec4Normals = normal.Data; foreach (Syroot.Maths.Vector4F n in vec4Normals) { v.nrm.Add(new Vector3 { X = n.X, Y = n.Y, Z = n.Z }); } } if (att.Name == "_u0") { Console.WriteLine(att.Name); VertexBufferHelperAttrib uv0 = helper["_u0"]; Syroot.Maths.Vector4F[] vec4uv0 = uv0.Data; foreach (Syroot.Maths.Vector4F u in vec4uv0) { v.uv0.Add(new Vector2 { X = u.X, Y = u.Y }); } } if (att.Name == "_u1") { Console.WriteLine(att.Name); VertexBufferHelperAttrib uv1 = helper["_u1"]; Syroot.Maths.Vector4F[] vec4uv1 = uv1.Data; foreach (Syroot.Maths.Vector4F u in vec4uv1) { v.uv1.Add(new Vector2 { X = u.X, Y = u.Y }); } } if (att.Name == "_u2") { Console.WriteLine(att.Name); VertexBufferHelperAttrib uv2 = helper["_u2"]; Syroot.Maths.Vector4F[] vec4uv2 = uv2.Data; foreach (Syroot.Maths.Vector4F u in vec4uv2) { v.uv2.Add(new Vector2 { X = u.X, Y = u.Y }); } } if (att.Name == "_c0") { Console.WriteLine(att.Name); VertexBufferHelperAttrib c0 = helper["_c0"]; Syroot.Maths.Vector4F[] vec4c0 = c0.Data; foreach (Syroot.Maths.Vector4F c in vec4c0) { v.col.Add(new Vector4 { X = c.X, Y = c.Y, Z = c.Z, W = c.W }); } } if (att.Name == "_t0") { Console.WriteLine(att.Name); VertexBufferHelperAttrib t0 = helper["_t0"]; Syroot.Maths.Vector4F[] vec4t0 = t0.Data; foreach (Syroot.Maths.Vector4F u in vec4t0) { v.tans.Add(new Vector4 { X = u.X, Y = u.Y, Z = u.Z, W = u.W }); } } if (att.Name == "_b0") { Console.WriteLine(att.Name); VertexBufferHelperAttrib b0 = helper["_b0"]; Syroot.Maths.Vector4F[] vec4b0 = b0.Data; foreach (Syroot.Maths.Vector4F u in vec4b0) { v.bitans.Add(new Vector4 { X = u.X, Y = u.Y, Z = u.Z, W = u.W }); } } if (att.Name == "_w0") { Console.WriteLine(att.Name); VertexBufferHelperAttrib w0 = helper["_w0"]; Syroot.Maths.Vector4F[] vec4w0 = w0.Data; foreach (Syroot.Maths.Vector4F w in vec4w0) { v.weights.Add(new Vector4 { X = w.X, Y = w.Y, Z = w.Z, W = w.W }); } } if (att.Name == "_i0") { Console.WriteLine(att.Name); VertexBufferHelperAttrib i0 = helper["_i0"]; Syroot.Maths.Vector4F[] vec4i0 = i0.Data; foreach (Syroot.Maths.Vector4F i in vec4i0) { v.nodes.Add(new Vector4 { X = i.X, Y = i.Y, Z = i.Z, W = i.W }); } } } poly.vertices = v; //shp.Meshes.Count - 1 //For going to the lowest poly LOD mesh int LODCount = 0; uint FaceCount = FaceCount = shp.Meshes[LODCount].IndexCount; uint[] indicesArray = shp.Meshes[LODCount].GetIndices().ToArray(); poly.BoundingCount = shp.SubMeshBoundings.Count; for (int face = 0; face < FaceCount; face++) { poly.faces.Add((int)indicesArray[face] + (int)shp.Meshes[LODCount].FirstVertex); } int AlbedoCount = 0; string TextureName = ""; int id = 0; foreach (TextureRef tex in mdl.Materials[shp.MaterialIndex].TextureRefs) { TextureName = tex.Name; MatTexture texture = new MatTexture(); poly.Nodes.Add(new TreeNode { Text = TextureName }); if (mdl.Materials[shp.MaterialIndex].Samplers[id].Name == "_a0") { if (AlbedoCount == 0) { try { poly.texHashs.Add(textures[TextureName].texture.display); AlbedoCount++; } catch { poly.texHashs.Add(0); } poly.TextureMapTypes.Add("Diffuse"); } } if (mdl.Materials[shp.MaterialIndex].Samplers[id].Name == "_a1") { try { poly.texHashs.Add(textures[TextureName].texture.display); AlbedoCount++; } catch { poly.texHashs.Add(0); } poly.TextureMapTypes.Add("Diffuse_Layer"); } if (mdl.Materials[shp.MaterialIndex].Samplers[id].Name == "_n0") { try { poly.texHashs.Add(textures[TextureName].texture.display); } catch { poly.texHashs.Add(1); } poly.material.HasNormalMap = true; poly.TextureMapTypes.Add("Normal"); } if (mdl.Materials[shp.MaterialIndex].Samplers[id].Name == "_b0") { try { poly.texHashs.Add(textures[TextureName].texture.display); } catch { poly.texHashs.Add(2); } poly.TextureMapTypes.Add("Bake1"); } if (mdl.Materials[shp.MaterialIndex].Samplers[id].Name == "_b1") { try { poly.texHashs.Add(textures[TextureName].texture.display); } catch { poly.texHashs.Add(3); } poly.TextureMapTypes.Add("Bake2"); } id++; texture.Name = TextureName; } poly.material.Name = mdl.Materials[shp.MaterialIndex].Name; foreach (Sampler smp in mdl.Materials[shp.MaterialIndex].Samplers.Values) { SamplerInfo s = new SamplerInfo(); s.WrapModeU = (int)smp.TexSampler.ClampX; s.WrapModeV = (int)smp.TexSampler.ClampY; s.WrapModeW = (int)smp.TexSampler.ClampZ; poly.material.samplerinfo.Add(s); } using (Syroot.BinaryData.BinaryDataReader reader = new Syroot.BinaryData.BinaryDataReader(new MemoryStream(mdl.Materials[shp.MaterialIndex].ShaderParamData))) { reader.ByteOrder = Syroot.BinaryData.ByteOrder.BigEndian; foreach (Syroot.NintenTools.Bfres.ShaderParam param in mdl.Materials[shp.MaterialIndex].ShaderParams.Values) { ShaderParam prm = new ShaderParam(); prm.Type = param.Type; switch (param.Type) { case ShaderParamType.Float: reader.Seek(param.DataOffset, SeekOrigin.Begin); prm.Value_float = reader.ReadSingle(); break; case ShaderParamType.Float2: reader.Seek(param.DataOffset, SeekOrigin.Begin); prm.Value_float2 = new Vector2( reader.ReadSingle(), reader.ReadSingle()); break; case ShaderParamType.Float3: reader.Seek(param.DataOffset, SeekOrigin.Begin); prm.Value_float3 = new Vector3( reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle()); break; case ShaderParamType.Float4: reader.Seek(param.DataOffset, SeekOrigin.Begin); prm.Value_float4 = new Vector4( reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle()); break; } poly.material.matparam.Add(param.Name, prm); } reader.Close(); } model.poly.Add(poly); ShapeCur++; } models.Add(model); ModelCur++; } }
public static List <MeshMetaInfo> FromJson(Material mat, string json) { JsonConvert.DefaultSettings = () => { var settings = new JsonSerializerSettings(); return(settings); }; var matJson = JsonConvert.DeserializeObject <MaterialStruct>(json); mat.Name = matJson.Name; mat.Visible = matJson.Visible; mat.ShaderAssign = ConvertShaderAssign(matJson.ShaderAssign); mat.TextureRefs = new List <TextureRef>(); mat.Samplers = new ResDict <Sampler>(); mat.ShaderParams = new ResDict <ShaderParam>(); mat.UserData = new ResDict <UserData>(); mat.RenderInfos = new ResDict <RenderInfo>(); mat.ShaderParamData = new byte[0]; mat.VolatileFlags = new byte[0]; if (matJson.RenderState != null) { mat.RenderState = matJson.RenderState; } foreach (var tex in matJson.Textures) { mat.TextureRefs.Add(new TextureRef() { Name = tex }); } foreach (var sampler in matJson.Samplers) { mat.Samplers.Add(sampler.Name, sampler); } mat.TextureSlotArray = new long[matJson.Textures.Count]; mat.SamplerSlotArray = new long[matJson.Textures.Count]; mat.VolatileFlags = matJson.VolatileFlags; foreach (var param in matJson.Parameters) { string type = param.Key.Split('|')[0]; string name = param.Key.Split('|')[1]; ShaderParam shaderParam = new ShaderParam(); shaderParam.Name = name; var dataType = (ShaderParamType)Enum.Parse(typeof(ShaderParamType), type); object value = null; switch (dataType) { case ShaderParamType.Float: value = Convert.ToSingle(param.Value); break; case ShaderParamType.UInt: value = Convert.ToUInt32(param.Value); break; case ShaderParamType.Int: value = Convert.ToInt32(param.Value); break; case ShaderParamType.Bool: value = Convert.ToBoolean(param.Value); break; case ShaderParamType.Srt2D: value = ((JObject)param.Value).ToObject <Srt2D>(); break; case ShaderParamType.Srt3D: value = ((JObject)param.Value).ToObject <Srt3D>(); break; case ShaderParamType.TexSrt: value = ((JObject)param.Value).ToObject <TexSrt>(); break; case ShaderParamType.TexSrtEx: value = ((JObject)param.Value).ToObject <TexSrt>(); break; case ShaderParamType.Float2: case ShaderParamType.Float2x2: case ShaderParamType.Float2x3: case ShaderParamType.Float2x4: case ShaderParamType.Float3: case ShaderParamType.Float3x2: case ShaderParamType.Float3x3: case ShaderParamType.Float3x4: case ShaderParamType.Float4: case ShaderParamType.Float4x2: case ShaderParamType.Float4x3: case ShaderParamType.Float4x4: value = ((JArray)param.Value).ToObject <float[]>(); break; case ShaderParamType.Bool2: case ShaderParamType.Bool3: case ShaderParamType.Bool4: value = ((JArray)param.Value).ToObject <bool>(); break; case ShaderParamType.Int2: case ShaderParamType.Int3: case ShaderParamType.Int4: value = ((JArray)param.Value).ToObject <int[]>(); break; case ShaderParamType.UInt2: case ShaderParamType.UInt3: case ShaderParamType.UInt4: value = ((JArray)param.Value).ToObject <uint[]>(); break; default: throw new Exception($"Unsupported parameter type! {type}"); } mat.SetShaderParameter(name, dataType, value); } foreach (var param in matJson.RenderInfo) { string type = param.Key.Split('|')[0]; string name = param.Key.Split('|')[1]; RenderInfoType dataType = (RenderInfoType)Enum.Parse(typeof(RenderInfoType), type); if (dataType == RenderInfoType.Single) { mat.SetRenderInfo(name, ((JArray)param.Value).ToObject <float[]>()); } if (dataType == RenderInfoType.Int32) { mat.SetRenderInfo(name, ((JArray)param.Value).ToObject <int[]>()); } if (dataType == RenderInfoType.String) { mat.SetRenderInfo(name, ((JArray)param.Value).ToObject <string[]>()); } } mat.UserData = UserDataConvert.Convert(matJson.UserData); return(matJson.MeshInfo); }
private static IEnumerable<string> GenerateFloat4Property(ShaderParam shaderParam) { return GenerateProperty(shaderParam, "Vector4", "GetValueVector4"); }
public static void WriteMaterialXML(MaterialData mat, Mesh msh) { SaveFileDialog sfd = new SaveFileDialog(); sfd.Filter = "XML|*.xml|All files(*.*)|*.*"; sfd.FileName = mat.Name; //Todo. Redo this using XmlDocument and organise better if (sfd.ShowDialog() == DialogResult.OK) { XmlWriterSettings settings = new XmlWriterSettings(); settings.Indent = true; XmlWriter writer = XmlWriter.Create(sfd.FileName, settings); writer.WriteStartDocument(); writer.WriteStartElement("Materials"); writer.WriteStartElement("SamplerArray"); int s = 0; foreach (var tex in mat.textures) { writer.WriteStartElement("Sampler"); writer.WriteAttributeString("Name", mat.Samplers.Keys.ElementAt(s)); writer.WriteAttributeString("Texture_Name", tex.Name); writer.WriteAttributeString("Index", s.ToString()); writer.WriteStartElement("WrapMode"); writer.WriteAttributeString("U", wrapmode[mat.samplerinfo[s].WrapModeU].ToString()); writer.WriteAttributeString("V", wrapmode[mat.samplerinfo[s].WrapModeV].ToString()); writer.WriteAttributeString("W", wrapmode[mat.samplerinfo[s].WrapModeW].ToString()); writer.WriteEndElement(); writer.WriteEndElement(); s++; } writer.WriteEndElement(); writer.WriteStartElement("Sampler"); foreach (var smp in mat.Samplers) { writer.WriteStartElement("SamplerInfo"); writer.WriteString(smp.Key); writer.WriteEndElement(); } writer.WriteEndElement(); writer.WriteStartElement("RenderInfo"); int p = 0; foreach (var rnd in mat.renderinfo) { writer.WriteStartElement("Info"); writer.WriteAttributeString("Index", p.ToString()); switch (rnd.Type) { case RenderInfoType.String: foreach (string item in rnd.Value_Strings) { writer.WriteAttributeString(rnd.Name, item); } break; case RenderInfoType.Int32: foreach (int item in rnd.Value_Ints) { writer.WriteAttributeString(rnd.Name, item.ToString()); } break; case RenderInfoType.Single: foreach (float item in rnd.Value_Floats) { writer.WriteAttributeString(rnd.Name, item.ToString()); } break; } writer.WriteEndElement(); p++; } writer.WriteEndElement(); writer.WriteStartElement("ShaderAssign"); writer.WriteAttributeString("ShaderFile", mat.shaderassign.ShaderModel); p = 0; foreach (var op in mat.shaderassign.options) { writer.WriteStartElement("Option"); writer.WriteAttributeString("Index", p.ToString()); writer.WriteAttributeString(op.Key, op.Value); writer.WriteEndElement(); p++; } foreach (var smp in mat.shaderassign.samplers) { writer.WriteStartElement("SamplersFragmentShader"); writer.WriteAttributeString(smp.Key, smp.Value); writer.WriteEndElement(); } foreach (var att in mat.shaderassign.attributes) { writer.WriteStartElement("AttributesVertexShader"); writer.WriteAttributeString(att.Key, att.Value); writer.WriteEndElement(); } writer.WriteEndElement(); p = 0; writer.WriteStartElement("ShaderParam"); foreach (var prm in mat.matparam) { ShaderParam param = prm.Value; writer.WriteStartElement("ShaderParam"); writer.WriteAttributeString("Name", param.Name); string value = "Value" + param.Type.ToString(); switch (param.Type) { case ShaderParamType.UInt: writer.WriteAttributeString(value, param.Value_UInt.ToString()); break; case ShaderParamType.Float: writer.WriteAttributeString(value, param.Value_float.ToString()); break; case ShaderParamType.Float2: writer.WriteAttributeString(value, param.Value_float2.ToString()); break; case ShaderParamType.Float3: writer.WriteAttributeString(value, param.Value_float3.ToString()); break; case ShaderParamType.Float4: writer.WriteAttributeString(value, param.Value_float4.ToString()); break; case ShaderParamType.TexSrt: writer.WriteAttributeString(value, param.Value_TexSrt.scale.ToString() + ", (" + param.Value_TexSrt.rotate.ToString() + "), " + param.Value_TexSrt.translate.ToString()); break; case ShaderParamType.Bool: writer.WriteAttributeString(value, param.Value_bool.ToString()); break; case ShaderParamType.Float2x2: writer.WriteAttributeString(value, FloatArrayToString(param.Value_float2x2)); break; case ShaderParamType.Float2x3: writer.WriteAttributeString(value, FloatArrayToString(param.Value_float2x3)); break; case ShaderParamType.Float4x4: writer.WriteAttributeString(value + param.Type.ToString(), FloatArrayToString(param.Value_float4x4)); break; default: MessageBox.Show("Cannot save undefined param type " + param.Type.ToString()); writer.WriteAttributeString(value, "Undefined"); break; } writer.WriteEndElement(); p++; } writer.WriteEndElement(); writer.WriteEndDocument(); writer.Close(); } }
public void Read(ResFile TargetWiiUBFRES) { Nodes.Add(TModels); Nodes.Add(TTextures); Nodes.Add(TShaderparam); Nodes.Add(TColoranim); Nodes.Add(TTextureSRT); Nodes.Add(TTexturePat); Nodes.Add(TBonevisabilty); Nodes.Add(TVisualAnim); Nodes.Add(TShapeAnim); Nodes.Add(TSceneAnim); Nodes.Add(TEmbedded); ImageKey = "bfres"; SelectedImageKey = "bfres"; FSKACount = TargetWiiUBFRES.SkeletalAnims.Count; FTXPCount = TargetWiiUBFRES.TexPatternAnims.Count; FSHUCount = TargetWiiUBFRES.ColorAnims.Count + TargetWiiUBFRES.TexSrtAnims.Count + TargetWiiUBFRES.ShaderParamAnims.Count; AnimationCountTotal = FSKACount + FTXPCount + FSHUCount; FTEXContainer = new FTEXContainer(); foreach (Texture tex in TargetWiiUBFRES.Textures.Values) { string TextureName = tex.Name; FTEX texture = new FTEX(); texture.ReadFTEX(tex); TTextures.Nodes.Add(texture); FTEXContainer.FTEXtextures.Add(texture.Text, texture); Runtime.FTEXContainerList.Add(FTEXContainer); } int ModelCur = 0; //FMDLs -Models- foreach (Model mdl in TargetWiiUBFRES.Models.Values) { FMDL_Model model = new FMDL_Model(); //This will store VBN data and stuff model.Text = mdl.Name; TModels.Nodes.Add(model); model.Node_Array = new int[mdl.Skeleton.MatrixToBoneList.Count]; int nodes = 0; foreach (ushort node in mdl.Skeleton.MatrixToBoneList) { model.Node_Array[nodes] = node; nodes++; } foreach (Syroot.NintenTools.Bfres.Bone bn in mdl.Skeleton.Bones.Values) { Bone bone = new Bone(model.skeleton); bone.Text = bn.Name; bone.boneId = bn.BillboardIndex; bone.parentIndex = bn.ParentIndex; bone.scale = new float[3]; bone.rotation = new float[4]; bone.position = new float[3]; if (bn.FlagsRotation == BoneFlagsRotation.Quaternion) { bone.boneRotationType = 1; } else { bone.boneRotationType = 0; } bone.scale[0] = bn.Scale.X; bone.scale[1] = bn.Scale.Y; bone.scale[2] = bn.Scale.Z; bone.rotation[0] = bn.Rotation.X; bone.rotation[1] = bn.Rotation.Y; bone.rotation[2] = bn.Rotation.Z; bone.rotation[3] = bn.Rotation.W; bone.position[0] = bn.Position.X; bone.position[1] = bn.Position.Y; bone.position[2] = bn.Position.Z; model.skeleton.bones.Add(bone); } model.skeleton.reset(); model.skeleton.update(); //MeshTime!! int ShapeCur = 0; foreach (Shape shp in mdl.Shapes.Values) { Mesh poly = new Mesh(); poly.Text = shp.Name; poly.MaterialIndex = shp.MaterialIndex; poly.VertexSkinCount = shp.VertexSkinCount; poly.boneIndx = shp.BoneIndex; poly.fmdlIndx = ModelCur; foreach (int bn in shp.SkinBoneIndices) { if (!poly.BoneIndexList.ContainsKey(model.skeleton.bones[bn].Text)) { poly.BoneIndexList.Add(model.skeleton.bones[bn].Text, bn); } } TModels.Nodes[ModelCur].Nodes.Add(poly); //Create a buffer instance which stores all the buffer data VertexBufferHelper helper = new VertexBufferHelper(mdl.VertexBuffers[shp.VertexBufferIndex], TargetWiiUBFRES.ByteOrder); //Set each array first from the lib if exist. Then add the data all in one loop Syroot.Maths.Vector4F[] vec4Positions = new Syroot.Maths.Vector4F[0]; Syroot.Maths.Vector4F[] vec4Normals = new Syroot.Maths.Vector4F[0]; Syroot.Maths.Vector4F[] vec4uv0 = new Syroot.Maths.Vector4F[0]; Syroot.Maths.Vector4F[] vec4uv1 = new Syroot.Maths.Vector4F[0]; Syroot.Maths.Vector4F[] vec4uv2 = new Syroot.Maths.Vector4F[0]; Syroot.Maths.Vector4F[] vec4c0 = new Syroot.Maths.Vector4F[0]; Syroot.Maths.Vector4F[] vec4t0 = new Syroot.Maths.Vector4F[0]; Syroot.Maths.Vector4F[] vec4b0 = new Syroot.Maths.Vector4F[0]; Syroot.Maths.Vector4F[] vec4w0 = new Syroot.Maths.Vector4F[0]; Syroot.Maths.Vector4F[] vec4i0 = new Syroot.Maths.Vector4F[0]; foreach (VertexAttrib att in mdl.VertexBuffers[shp.VertexBufferIndex].Attributes.Values) { Mesh.VertexAttribute attr = new Mesh.VertexAttribute(); attr.Name = att.Name; // attr.Format = att.Format; if (att.Name == "_p0") { vec4Positions = WiiUAttributeData(att, helper, "_p0"); } if (att.Name == "_n0") { vec4Normals = WiiUAttributeData(att, helper, "_n0"); } if (att.Name == "_u0") { vec4uv0 = WiiUAttributeData(att, helper, "_u0"); } if (att.Name == "_u1") { vec4uv1 = WiiUAttributeData(att, helper, "_u1"); } if (att.Name == "_u2") { vec4uv2 = WiiUAttributeData(att, helper, "_u2"); } if (att.Name == "_c0") { vec4c0 = WiiUAttributeData(att, helper, "_c0"); } if (att.Name == "_t0") { vec4t0 = WiiUAttributeData(att, helper, "_t0"); } if (att.Name == "_b0") { vec4b0 = WiiUAttributeData(att, helper, "_b0"); } if (att.Name == "_w0") { vec4w0 = WiiUAttributeData(att, helper, "_w0"); } if (att.Name == "_i0") { vec4i0 = WiiUAttributeData(att, helper, "_i0"); } poly.vertexAttributes.Add(attr); } for (int i = 0; i < vec4Positions.Length; i++) { Vertex v = new Vertex(); if (vec4Positions.Length > 0) { v.pos = new Vector3(vec4Positions[i].X, vec4Positions[i].Y, vec4Positions[i].Z); } if (vec4Normals.Length > 0) { v.nrm = new Vector3(vec4Normals[i].X, vec4Normals[i].Y, vec4Normals[i].Z); } if (vec4uv0.Length > 0) { v.uv0 = new Vector2(vec4uv0[i].X, vec4uv0[i].Y); } if (vec4uv1.Length > 0) { v.uv1 = new Vector2(vec4uv1[i].X, vec4uv1[i].Y); } if (vec4uv2.Length > 0) { v.uv2 = new Vector2(vec4uv2[i].X, vec4uv2[i].Y); } if (vec4w0.Length > 0) { v.boneWeights.Add(vec4w0[i].X); v.boneWeights.Add(vec4w0[i].Y); v.boneWeights.Add(vec4w0[i].Z); v.boneWeights.Add(vec4w0[i].W); } if (vec4i0.Length > 0) { v.boneIds.Add((int)vec4i0[i].X); v.boneIds.Add((int)vec4i0[i].Y); v.boneIds.Add((int)vec4i0[i].Z); v.boneIds.Add((int)vec4i0[i].W); } if (vec4t0.Length > 0) { v.tan = new Vector4(vec4t0[i].X, vec4t0[i].Y, vec4t0[i].Z, vec4t0[i].W); } if (vec4b0.Length > 0) { v.bitan = new Vector4(vec4b0[i].X, vec4b0[i].Y, vec4b0[i].Z, vec4b0[i].W); } if (vec4c0.Length > 0) { v.col = new Vector4(vec4c0[i].X, vec4c0[i].Y, vec4c0[i].Z, vec4c0[i].W); } if (poly.VertexSkinCount == 1) { Matrix4 sb = model.skeleton.bones[model.Node_Array[v.boneIds[0]]].transform; // Console.WriteLine(model.skeleton.bones[model.Node_Array[v.boneIds[0]]].Text); v.pos = Vector3.TransformPosition(v.pos, sb); v.nrm = Vector3.TransformNormal(v.nrm, sb); } if (poly.VertexSkinCount == 0) { Matrix4 NoBindFix = model.skeleton.bones[poly.boneIndx].transform; v.pos = Vector3.TransformPosition(v.pos, NoBindFix); v.nrm = Vector3.TransformNormal(v.nrm, NoBindFix); } poly.vertices.Add(v); } //shp.Meshes.Count - 1 //For going to the lowest poly LOD mesh poly.BoundingCount = shp.SubMeshBoundings.Count; int CurLOD = 0; foreach (var lod in shp.Meshes) { Mesh.LOD_Mesh lodmsh = new Mesh.LOD_Mesh(); lodmsh.index = CurLOD++; uint FaceCount = lod.IndexCount; uint[] indicesArray = lod.GetIndices().ToArray(); for (int face = 0; face < FaceCount; face++) { lodmsh.faces.Add((int)indicesArray[face] + (int)lod.FirstVertex); } poly.lodMeshes.Add(lodmsh); } foreach (Bounding bnd in shp.SubMeshBoundings) { Mesh.BoundingBox box = new Mesh.BoundingBox(); box.Center = new Vector3(bnd.Center.X, bnd.Center.Y, bnd.Center.Z); box.Extent = new Vector3(bnd.Extent.X, bnd.Extent.Y, bnd.Extent.Z); poly.boundingBoxes.Add(box); //Each box is by LOD mesh. This will be in a seperate class later so only one will be added } foreach (float r in shp.RadiusArray) { poly.radius.Add(r); } // Read materials Material mat = mdl.Materials[shp.MaterialIndex]; int SampIndex = 0; foreach (var smp in mat.Samplers) { poly.material.Samplers.Add(smp.Key, SampIndex); SampIndex++; } int AlbedoCount = 0; string TextureName = ""; MaterialData.ShaderAssign shaderassign = new MaterialData.ShaderAssign(); if (mat.ShaderAssign != null) //Some special cases (env models) have none { shaderassign.ShaderModel = mat.ShaderAssign.ShadingModelName; shaderassign.ShaderArchive = mat.ShaderAssign.ShaderArchiveName; int o = 0; foreach (var op in mat.ShaderAssign.ShaderOptions) { shaderassign.options.Add(op.Key, mat.ShaderAssign.ShaderOptions[o]); o++; } int sa = 0; foreach (var smp in mat.ShaderAssign.SamplerAssigns) { shaderassign.samplers.Add(smp.Key, mat.ShaderAssign.SamplerAssigns[sa]); sa++; } int va = 0; foreach (var att in mat.ShaderAssign.AttribAssigns) { shaderassign.attributes.Add(att.Key, mat.ShaderAssign.AttribAssigns[va]); va++; } } poly.material.shaderassign = shaderassign; int id = 0; foreach (TextureRef tex in mdl.Materials[shp.MaterialIndex].TextureRefs) { TextureName = tex.Name; MatTexture texture = new MatTexture(); texture.wrapModeS = (int)mdl.Materials[shp.MaterialIndex].Samplers[id].TexSampler.ClampX; texture.wrapModeT = (int)mdl.Materials[shp.MaterialIndex].Samplers[id].TexSampler.ClampY; bool IsAlbedo = HackyTextureList.Any(TextureName.Contains); if (mdl.Materials[shp.MaterialIndex].Samplers[id].Name == "_a0") { poly.material.HasDiffuseMap = true; texture.hash = 0; texture.Type = MatTexture.TextureType.Diffuse; } if (mdl.Materials[shp.MaterialIndex].Samplers[id].Name == "_a1") { poly.material.HasDiffuseLayer = true; texture.hash = 19; texture.Type = MatTexture.TextureType.DiffuseLayer2; } if (mdl.Materials[shp.MaterialIndex].Samplers[id].Name == "_n0") { texture.hash = 1; poly.material.HasNormalMap = true; texture.Type = MatTexture.TextureType.Normal; } if (mdl.Materials[shp.MaterialIndex].Samplers[id].Name == "_s0") { texture.hash = 4; poly.material.HasSpecularMap = true; texture.Type = MatTexture.TextureType.Specular; } if (mdl.Materials[shp.MaterialIndex].Samplers[id].Name == "_b0") { texture.hash = 2; poly.material.HasShadowMap = true; texture.Type = MatTexture.TextureType.Shadow; } if (mdl.Materials[shp.MaterialIndex].Samplers[id].Name == "_b1") { texture.hash = 3; poly.material.HasLightMap = true; texture.Type = MatTexture.TextureType.Light; } if (mdl.Materials[shp.MaterialIndex].Samplers[id].Name == "_e0") { texture.hash = 8; poly.material.HasEmissionMap = true; texture.Type = MatTexture.TextureType.Emission; } texture.Name = TextureName; poly.material.textures.Add(texture); id++; } foreach (Sampler smp in mat.Samplers.Values) { SamplerInfo s = new SamplerInfo(); s.WrapModeU = (int)smp.TexSampler.ClampX; s.WrapModeV = (int)smp.TexSampler.ClampY; s.WrapModeW = (int)smp.TexSampler.ClampZ; poly.material.samplerinfo.Add(s); } poly.material.Name = mdl.Materials[shp.MaterialIndex].Name; if (mdl.Materials[shp.MaterialIndex].ShaderParamData != null) //Some special cases (env models) have none { using (Syroot.BinaryData.BinaryDataReader reader = new Syroot.BinaryData.BinaryDataReader(new MemoryStream(mdl.Materials[shp.MaterialIndex].ShaderParamData))) { reader.ByteOrder = Syroot.BinaryData.ByteOrder.BigEndian; foreach (Syroot.NintenTools.Bfres.ShaderParam param in mdl.Materials[shp.MaterialIndex].ShaderParams.Values) { ShaderParam prm = new ShaderParam(); prm.Type = param.Type; prm.Name = param.Name; switch (param.Type) { case ShaderParamType.Float: reader.Seek(param.DataOffset, SeekOrigin.Begin); prm.Value_float = reader.ReadSingle(); break; case ShaderParamType.Float2: reader.Seek(param.DataOffset, SeekOrigin.Begin); prm.Value_float2 = new Vector2( reader.ReadSingle(), reader.ReadSingle()); break; case ShaderParamType.Float3: reader.Seek(param.DataOffset, SeekOrigin.Begin); prm.Value_float3 = new Vector3( reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle()); break; case ShaderParamType.Float4: reader.Seek(param.DataOffset, SeekOrigin.Begin); prm.Value_float4 = new Vector4( reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle()); break; case ShaderParamType.TexSrt: reader.Seek(param.DataOffset, SeekOrigin.Begin); ShaderParam.TextureSRT texSRT = new ShaderParam.TextureSRT(); texSRT.Mode = reader.ReadSingle(); //Scale mode, Maya, max ect texSRT.scale = new Vector2(reader.ReadSingle(), reader.ReadSingle()); texSRT.rotate = reader.ReadSingle(); texSRT.translate = new Vector2(reader.ReadSingle(), reader.ReadSingle()); prm.Value_TexSrt = texSRT; break; } poly.material.matparam.Add(param.Name, prm); } reader.Close(); } } model.poly.Add(poly); ShapeCur++; } models.Add(model); ModelCur++; } }
static void LoadParamColumns(ShaderParam param, int index, bool animated = false) { ImGui.Columns(3); if (selectedIndices.Contains(index)) { ImGui.Columns(1); if (ImGui.CollapsingHeader(param.Name, ImGuiTreeNodeFlags.DefaultOpen)) { LoadParamUI(param, $"##{param.Name}", drag); if (OriginalValues[param.Name] != param.DataValue) { ImGui.SameLine(); if (ImGui.Button("Reset")) { param.DataValue = OriginalValues[param.Name]; } } } ImGui.Columns(3); } else { if (animated) { ImGui.PushStyleColor(ImGuiCol.Border, new Vector4(0, 0.5f, 0, 1)); ImGui.PushStyleVar(ImGuiStyleVar.FrameBorderSize, 1); } ImGui.SetColumnWidth(0, columnSize1); ImGui.SetColumnWidth(1, columnSize2); ImGui.SetColumnWidth(2, columnSize3); if (ImGui.Selectable(param.Name, selectedIndices.Contains(index), ImGuiSelectableFlags.SpanAllColumns)) { selectedIndices.Clear(); selectedIndices.Add(index); } ImGui.NextColumn(); ImGui.Text(GetDataString(param)); ImGui.NextColumn(); if (animated) { ImGui.PopStyleColor(); ImGui.PopStyleVar(); } if (param.Type == ShaderParamType.Float4) { if (param.Name.Contains("color") || param.Name.Contains("Color")) { ImGuiHelper.InputFloatsFromColor4Button("", param, "DataValue", ImGuiColorEditFlags.AlphaPreviewHalf | ImGuiColorEditFlags.HDR); } } else if (param.Type == ShaderParamType.Float3) { if (param.Name.Contains("color") || param.Name.Contains("Color")) { ImGuiHelper.InputFloatsFromColor3Button("", param, "DataValue", ImGuiColorEditFlags.HDR); } } ImGui.NextColumn(); ImGui.Columns(1); } }
public static Material CreateSwitchMaterial(this BFRES.MaterialData mat) { Material m = new Material(); m.Flags = (MaterialFlags)mat.IsVisable; m.Name = mat.Name; m.TextureRefs = new List <TextureRef>(); m.RenderInfos = new List <RenderInfo>(); m.Samplers = new List <Sampler>(); m.VolatileFlags = new byte[0]; m.UserDatas = new List <UserData>(); m.ShaderParams = new List <ShaderParam>(); m.SamplerDict = new ResDict(); m.RenderInfoDict = new ResDict(); m.ShaderParamDict = new ResDict(); m.UserDataDict = new ResDict(); m.VolatileFlags = new byte[0]; m.TextureSlotArray = new long[mat.textures.Count]; m.SamplerSlotArray = new long[mat.textures.Count]; m.ShaderParamData = WriteShaderParams(mat); int CurTex = 0; foreach (BFRES.MatTexture tex in mat.textures) { TextureRef texture = new TextureRef(); texture.Name = tex.Name; m.TextureRefs.Add(texture); Sampler samp = new Sampler(); samp.BorderColorType = tex.BorderColorType; samp.CompareFunc = tex.CompareFunc; samp.FilterMode = tex.FilterMode; samp.LODBias = tex.LODBias; samp.MaxAnisotropic = tex.MaxAnisotropic; samp.MaxLOD = tex.magFilter; samp.MinLOD = tex.minFilter; samp.WrapModeU = (TexClamp)tex.wrapModeS; samp.WrapModeV = (TexClamp)tex.wrapModeT; samp.WrapModeW = (TexClamp)tex.wrapModeW; m.Samplers.Add(samp); m.SamplerDict.Add(tex.SamplerName); m.TextureSlotArray[CurTex] = -1; m.SamplerSlotArray[CurTex] = -1; CurTex++; } int CurParam = 0; foreach (var prm in mat.matparam) { ShaderParam shaderParam = new ShaderParam(); shaderParam.Name = prm.Key; shaderParam.Type = (ShaderParamType)prm.Value.Type; shaderParam.DependIndex = (ushort)CurParam; shaderParam.DependedIndex = (ushort)CurParam; shaderParam.DataOffset = (ushort)prm.Value.DataOffset; CurParam++; } foreach (BFRES.RenderInfoData rnd in mat.renderinfo) { RenderInfo renderInfo = new RenderInfo(); renderInfo.Name = rnd.Name; if (rnd.Type == Syroot.NintenTools.Bfres.RenderInfoType.Int32) { renderInfo.SetValue(rnd.Value_Ints); } if (rnd.Type == Syroot.NintenTools.Bfres.RenderInfoType.Single) { renderInfo.SetValue(rnd.Value_Floats); } if (rnd.Type == Syroot.NintenTools.Bfres.RenderInfoType.String) { renderInfo.SetValue(rnd.Value_Strings); } m.RenderInfos.Add(renderInfo); } ShaderAssign shaderAssign = new ShaderAssign(); shaderAssign.ShaderArchiveName = mat.shaderassign.ShaderArchive; shaderAssign.ShadingModelName = mat.shaderassign.ShaderModel; shaderAssign.ShaderOptionDict = new ResDict(); shaderAssign.AttribAssignDict = new ResDict(); shaderAssign.SamplerAssignDict = new ResDict(); shaderAssign.ShaderOptions = new List <string>(); shaderAssign.AttribAssigns = new List <string>(); shaderAssign.SamplerAssigns = new List <string>(); foreach (var op in mat.shaderassign.options) { shaderAssign.ShaderOptionDict.Add(op.Key); shaderAssign.ShaderOptions.Add(op.Value); } foreach (var att in mat.shaderassign.attributes) { shaderAssign.AttribAssignDict.Add(att.Key); shaderAssign.AttribAssigns.Add(att.Value); } foreach (var smp in mat.shaderassign.samplers) { shaderAssign.SamplerAssignDict.Add(smp.Key); shaderAssign.SamplerAssigns.Add(smp.Value); } m.ShaderAssign = shaderAssign; return(m); }
private static IEnumerable<string> GenerateProperty(ShaderParam shaderParam, string type, string getter) { var result = new List<string> { "/// <summary>", }; if (!string.IsNullOrEmpty(shaderParam.Summary)) result.Add("/// " + shaderParam.Summary); if (!string.IsNullOrEmpty(shaderParam.DefaultValue)) result.Add("/// Default: " + shaderParam.DefaultValue); if (!string.IsNullOrEmpty(shaderParam.MinValue)) result.Add("/// Min: " + shaderParam.MinValue); if (!string.IsNullOrEmpty(shaderParam.MaxValue)) result.Add("/// Max: " + shaderParam.MaxValue); result.AddRange(new List<string> { "/// </summary>", "public " + type + " " + GetPropertyName(shaderParam), "{", "\tget { return Effect.Parameters[\"" + shaderParam.Name +"\"]." + getter + "(); }", "\tset { Effect.Parameters[\"" + shaderParam.Name +"\"].SetValue(value); }", "}", }); return result; }
private static string GenerateFloatInitialisation(ShaderParam shaderParam) { if (string.IsNullOrEmpty(shaderParam.DefaultValue)) return ""; var line = GetPropertyName(shaderParam) + " = " + shaderParam.DefaultValue + "f;"; return line; }
static void LoadParamUI(ShaderParam param, string label = "", bool drag = false) { switch (param.Type) { case ShaderParamType.Bool: { ImGuiHelper.InputFromBoolean(label, param, "DataValue"); } break; case ShaderParamType.Int: { ImGuiHelper.InputFromInt(label, param, "DataValue", 1, drag); } break; case ShaderParamType.UInt: { ImGuiHelper.InputFromUint(label, param, "DataValue", 1, drag); } break; case ShaderParamType.Float: { ImGuiHelper.InputFromFloat(label, param, "DataValue", drag); } break; case ShaderParamType.Float2: { ImGuiHelper.InputFloatsFromVector2(label, param, "DataValue", drag); } break; case ShaderParamType.Float3: { if (param.Name.Contains("color") || param.Name.Contains("Color")) { ImGuiHelper.InputFloatsFromColor3(label, param, "DataValue"); } else { ImGuiHelper.InputFloatsFromVector3(label, param, "DataValue", drag); } } break; case ShaderParamType.Float4: { if (param.Name.Contains("color") || param.Name.Contains("Color")) { ImGuiHelper.InputFloatsFromColor4(label, param, "DataValue", ImGuiColorEditFlags.AlphaBar | ImGuiColorEditFlags.AlphaPreviewHalf); } else { ImGuiHelper.InputFloatsFromVector4(label, param, "DataValue", drag); } } break; case ShaderParamType.Srt2D: { Srt2D value = (Srt2D)param.DataValue; var pos = new Vector2(value.Translation.X, value.Translation.Y); var scale = new Vector2(value.Scaling.X, value.Scaling.Y); var rot = value.Rotation; bool edited0 = ImGui.DragFloat2("Scale", ref scale); bool edited1 = ImGui.DragFloat("Rotate", ref rot, 0.1f); bool edited2 = ImGui.DragFloat2("Translate", ref pos); if (edited0 || edited1 || edited2) { param.DataValue = new Srt2D() { Scaling = new Syroot.Maths.Vector2F(scale.X, scale.Y), Translation = new Syroot.Maths.Vector2F(pos.X, pos.Y), Rotation = rot, }; } } break; case ShaderParamType.TexSrt: case ShaderParamType.TexSrtEx: { TexSrt value = (TexSrt)param.DataValue; bool edited3 = ImGuiHelper.ComboFromEnum <TexSrtMode>("Mode", value, "Mode"); var pos = new Vector2(value.Translation.X, value.Translation.Y); var scale = new Vector2(value.Scaling.X, value.Scaling.Y); var rot = value.Rotation; bool edited0 = ImGui.DragFloat2("Scale", ref scale); bool edited1 = ImGui.DragFloat("Rotate", ref rot, 0.1f); bool edited2 = ImGui.DragFloat2("Translate", ref pos); if (edited0 || edited1 || edited2 || edited3) { param.DataValue = new TexSrt() { Mode = value.Mode, Scaling = new Syroot.Maths.Vector2F(scale.X, scale.Y), Translation = new Syroot.Maths.Vector2F(pos.X, pos.Y), Rotation = rot, }; } } break; } }
private static IEnumerable<string> GenerateFloatProperty(ShaderParam shaderParam) { return GenerateProperty(shaderParam, "float", "GetValueSingle"); }
public static void WriteFMATXML(MaterialData mat, Mesh msh) { SaveFileDialog sfd = new SaveFileDialog(); sfd.Filter = "XML|*.xml|All files(*.*)|*.*"; sfd.FileName = mat.Name; if (sfd.ShowDialog() == DialogResult.OK) { /* StreamWriter file = new StreamWriter(sfd.FileName); * using (JsonWriter writer = new JsonTextWriter(file)) * { * writer.Formatting = Formatting.Indented; * * writer.WriteStartObject(); * writer.WritePropertyName("Material"); * writer.WriteValue(mat.Name); * writer.WritePropertyName("TextureArray"); * writer.WriteStartArray(); * int s = 0; * foreach (var tex in mat.textures) * { * writer.WritePropertyName("TextureArray"); * writer.WriteValue(mat.Samplers.Keys.ElementAt(s)); * s++; * } * writer.WriteEnd(); * writer.WriteEndObject(); * * }*/ XmlWriterSettings settings = new XmlWriterSettings(); settings.Indent = true; XmlWriter writer = XmlWriter.Create(sfd.FileName, settings); writer.WriteStartDocument(); writer.WriteStartElement("Materials"); writer.WriteStartElement("SamplerArray"); int s = 0; foreach (var tex in mat.textures) { writer.WriteStartElement("Sampler"); writer.WriteAttributeString("Name", mat.Samplers.Keys.ElementAt(s)); writer.WriteAttributeString("Texture_Name", tex.Name); writer.WriteAttributeString("Index", s.ToString()); writer.WriteStartElement("WrapMode"); writer.WriteAttributeString("U", wrapmode[mat.samplerinfo[s].WrapModeU].ToString()); writer.WriteAttributeString("V", wrapmode[mat.samplerinfo[s].WrapModeV].ToString()); writer.WriteAttributeString("W", wrapmode[mat.samplerinfo[s].WrapModeW].ToString()); writer.WriteEndElement(); writer.WriteEndElement(); s++; } writer.WriteEndElement(); writer.WriteStartElement("Sampler"); foreach (var smp in mat.Samplers) { writer.WriteStartElement("SamplerInfo"); writer.WriteString(smp.Key); writer.WriteEndElement(); } writer.WriteEndElement(); writer.WriteStartElement("RenderInfo"); int p = 0; foreach (var rnd in mat.renderinfo) { writer.WriteStartElement("Info"); writer.WriteAttributeString("Index", p.ToString()); switch (rnd.Type) { case RenderInfoType.String: writer.WriteAttributeString(rnd.Name, rnd.Value_String); break; case RenderInfoType.Int32: writer.WriteAttributeString(rnd.Name, rnd.Value_Int.ToString()); break; case RenderInfoType.Single: writer.WriteAttributeString(rnd.Name, rnd.Value_Float.ToString()); break; } writer.WriteAttributeString("Type", rnd.Type.ToString()); writer.WriteEndElement(); p++; } writer.WriteEndElement(); writer.WriteStartElement("ShaderAssign"); writer.WriteAttributeString("ShaderFile", mat.shaderassign.ShaderModel); p = 0; foreach (var op in mat.shaderassign.options) { writer.WriteStartElement("Option"); writer.WriteAttributeString("Index", p.ToString()); writer.WriteAttributeString(op.Key, op.Value); writer.WriteEndElement(); p++; } foreach (var smp in mat.shaderassign.samplers) { writer.WriteStartElement("SamplersFragmentShader"); writer.WriteAttributeString(smp.Key, smp.Value); writer.WriteEndElement(); } foreach (var att in mat.shaderassign.attributes) { writer.WriteStartElement("AttributesVertexShader"); writer.WriteAttributeString(att.Key, att.Value); writer.WriteEndElement(); } writer.WriteEndElement(); p = 0; writer.WriteStartElement("ShaderParam"); foreach (var prm in mat.matparam) { ShaderParam param = prm.Value; writer.WriteStartElement("ShaderParam"); writer.WriteAttributeString("Index", p.ToString()); switch (param.Type) { case ShaderParamType.Float: writer.WriteAttributeString(prm.Key, param.Value_float.ToString()); break; case ShaderParamType.Float2: writer.WriteAttributeString(prm.Key, param.Value_float2.ToString()); break; case ShaderParamType.Float3: writer.WriteAttributeString(prm.Key, param.Value_float3.ToString()); break; case ShaderParamType.Float4: writer.WriteAttributeString(prm.Key, param.Value_float4.ToString()); break; case ShaderParamType.TexSrt: writer.WriteAttributeString(prm.Key, param.Value_TexSrt.scale.ToString() + " " + param.Value_TexSrt.rotate.ToString() + " " + param.Value_TexSrt.translate.ToString()); break; case ShaderParamType.Bool: writer.WriteAttributeString(prm.Key, param.Value_bool.ToString()); break; } writer.WriteAttributeString("Type", param.Type.ToString()); writer.WriteEndElement(); p++; } writer.WriteEndElement(); writer.WriteEndDocument(); writer.Close(); } }