public virtual void SetBlendState(FMAT material) { var blend = material.BlendState; blend.RenderDepthTest(); if (blend.State == GLMaterialBlendState.BlendState.Opaque) { GL.Disable(EnableCap.AlphaTest); GL.Disable(EnableCap.Blend); return; } blend.RenderBlendState(); }
public override bool UseRenderer(FMAT material, string archive, string model) { return(archive == "RenderMaterial" || archive == "RenderMaterialAlphaMask" || archive == "RenderMaterialGrass" || archive == "RenderMaterialCloud" || archive == "RenderMaterialCrystal" || archive == "RenderMaterialEcho" || archive == "RenderMaterialEmission" || archive == "RenderMaterialGodRay" || archive == "RenderMaterialIndirect" || archive == "RenderMaterialMirror" || archive == "RenderMaterialNoiseSpecular" || archive == "RenderMaterialMultiTex"); }
public static string[] FindRenderInfoPresets(FMAT material, string targetInfoName) { foreach (var info in InfoItemDump) { //Check for shader mapping if (!info.ShaderTarget.Contains(material.ShaderArchive) && !info.ShaderTarget.Contains(material.ShaderModel)) { continue; } //Find the enum with the current info target return(FindEnums(info.GetType(), targetInfoName)); } //Default to the entry defaults with common render info values. return(FindEnums(typeof(DefaultEntry), targetInfoName)); }
private void ParseSamplerTrack(FMAT material, SamplerTrack track) { if (TextureList.Count == 0) { return; } if (material.AnimatedSamplers.ContainsKey(track.Sampler)) { material.AnimatedSamplers.Remove(track.Sampler); } var value = (int)track.GetFrameValue(this.Frame); var texture = TextureList[value]; material.AnimatedSamplers.Add(track.Sampler, texture); }
public static void Render(FMAT material) { RenderHeader(); if (ImGui.BeginChild("RENDER_INFO_LIST")) { int index = 0; foreach (var renderInfo in material.Material.RenderInfos.Values) { ImGui.Columns(2); if (ImGui.Selectable(renderInfo.Name, SelectedIndices.Contains(index))) { SelectedIndices.Clear(); SelectedIndices.Add(index); } ImGui.NextColumn(); ImGui.Text(GetDataString(renderInfo, ",")); ImGui.NextColumn(); if (dialogOpen && SelectedIndices.Contains(index)) { ActiveDialog.LoadDialog(renderInfo, dialogOpen, (o, e) => { material.UpdateRenderState(); foreach (FSHP mesh in material.GetMappedMeshes()) { mesh.ReloadShader(); } }); } if (SelectedIndices.Contains(index) && ImGui.IsMouseDoubleClicked(0)) { dialogOpen = true; ActiveDialog.OnLoad(material, renderInfo); ImGui.OpenPopup("##render_info_dialog"); } index++; ImGui.Columns(1); } } ImGui.EndChild(); }
static void SelectSampler(FMAT material, UVViewport UVViewport, int index, bool onLoad) { var materialData = material.Material; var sampler = materialData.Samplers[index].TexSampler; var texMapSel = materialData.TextureRefs[index]; //Texture map info if (ImGui.CollapsingHeader("Texture Info", ImGuiTreeNodeFlags.DefaultOpen)) { ImGuiHelper.InputFromText("Name", texMapSel, "Name", 200); } var width = ImGui.GetWindowWidth(); //A UV preview window drawn using opengl if (ImGui.CollapsingHeader("Preview", ImGuiTreeNodeFlags.DefaultOpen)) { if (ImGui.BeginChild("uv_viewport1", new Vector2(width, 150))) { if (onLoad) { var meshes = material.GetMappedMeshes(); UVViewport.ActiveObjects.Clear(); foreach (FSHP mesh in meshes) { UVViewport.ActiveObjects.Add(mesh); } } UVViewport.ActiveTextureMap = material.TextureMaps[index]; UVViewport.Render((int)width, 150); } ImGui.EndChild(); } if (ImGui.BeginChild("sampler_properties")) { LoadProperties(sampler); material.ReloadTextureMap(index); ImGui.EndChild(); } }
private void ParseAnimationTrack(STAnimGroup group, FMAT mat) { foreach (var track in group.GetTracks()) { if (track is SamplerTrack) { ParseSamplerTrack(mat, (SamplerTrack)track); } if (track is ParamTrack) { ParseParamTrack(mat, group, (ParamTrack)track); } } foreach (var subGroup in group.SubAnimGroups) { ParseAnimationTrack(subGroup, mat); } }
public virtual void SetRenderState(FMAT mat) { GL.Enable(EnableCap.CullFace); if (mat.CullFront && mat.CullBack) { GL.CullFace(CullFaceMode.FrontAndBack); } else if (mat.CullFront) { GL.CullFace(CullFaceMode.Front); } else if (mat.CullBack) { GL.CullFace(CullFaceMode.Back); } else { GL.Disable(EnableCap.CullFace); } }
private NodeBase CreateGroupHierachy(FMAT material, STAnimGroup group) { if (group is ParamAnimGroup) { return(CreateParamNodeHierachy(material, (ParamAnimGroup)group)); } var groupNode = new NodeBase(group.Name); groupNode.Tag = group; //Params have their own sub group for each parameter //The X, Y, Z values being individual tracks foreach (STAnimGroup subGroup in group.SubAnimGroups) { groupNode.AddChild(CreateGroupHierachy(material, subGroup)); } var tracks = group.GetTracks(); return(groupNode); }
static void RenderHeader(FMAT material) { ImGui.Columns(2); if (ImGui.Selectable("Name")) { LoadedOptions.Clear(); foreach (var op in material.ShaderOptions.OrderBy(x => x.Key)) { LoadedOptions.Add(op.Key, op.Value); } } ImGui.NextColumn(); if (ImGui.Selectable("Value")) { LoadedOptions.Clear(); foreach (var op in material.ShaderOptions.OrderBy(x => x.Value)) { LoadedOptions.Add(op.Key, op.Value); } } ImGui.Separator(); ImGui.Columns(1); }
/// <summary> /// A helper method to set a material parameter block layout. /// </summary> public virtual void SetMaterialBlock(FMAT mat, UniformBlock block) { //Fill the buffer by program offsets var mem = new System.IO.MemoryStream(); using (var writer = new Toolbox.Core.IO.FileWriter(mem)) { writer.SeekBegin(0); var matBlock = ShaderModel.UniformBlocks.Values.FirstOrDefault(x => x.Type == BfshaLibrary.UniformBlock.BlockType.Material); int index = 0; foreach (var param in matBlock.Uniforms.Values) { var uniformName = matBlock.Uniforms.GetKey(index++); writer.SeekBegin(param.Offset - 1); if (mat.ShaderParams.ContainsKey(uniformName)) { var matParam = mat.ShaderParams[uniformName]; if (mat.AnimatedParams.ContainsKey(uniformName)) { matParam = mat.AnimatedParams[uniformName]; } if (matParam.Type == BfresLibrary.ShaderParamType.TexSrtEx) //Texture matrix (texmtx) { writer.Write(CalculateSRT3x4((BfresLibrary.TexSrt)matParam.DataValue)); } else if (matParam.Type == BfresLibrary.ShaderParamType.TexSrt) { writer.Write(CalculateSRT2x3((BfresLibrary.TexSrt)matParam.DataValue)); } else if (matParam.DataValue is BfresLibrary.Srt2D) //Indirect SRT (ind_texmtx) { writer.Write(CalculateSRT((BfresLibrary.Srt2D)matParam.DataValue)); } else if (matParam.DataValue is float) { writer.Write((float)matParam.DataValue); } else if (matParam.DataValue is float[]) { writer.Write((float[])matParam.DataValue); } else if (matParam.DataValue is int[]) { writer.Write((int[])matParam.DataValue); } else if (matParam.DataValue is uint[]) { writer.Write((uint[])matParam.DataValue); } else if (matParam.DataValue is int) { writer.Write((int)matParam.DataValue); } else if (matParam.DataValue is uint) { writer.Write((uint)matParam.DataValue); } else { throw new Exception($"Unsupported render type! {matParam.Type}"); } } } } block.Buffer.Clear(); block.Buffer.AddRange(mem.ToArray()); }
/// <summary> /// A helper method to auto map commonly used render info settings to options. /// Not all games use the same render info settings so this only works for certain games! /// </summary> public virtual void LoadRenderStateOptions(Dictionary <string, string> options, FMAT mat) { ShaderOptionHelper.LoadRenderStateOptions(options, mat); }
static void LoadShaderInfo(FMAT material) { var shader = material.MaterialAsset as SharcFBRenderer; var program = shader.ShaderModel; if (selectedStage == "Vertex") { var gx2Shader = (GX2VertexShader)program.GetGX2VertexShader(shader.BinaryIndex); if (ImGui.CollapsingHeader("Attributes", ImGuiTreeNodeFlags.DefaultOpen)) { for (int i = 0; i < gx2Shader.Attributes.Count; i++) { ImGui.Text($"In {gx2Shader.Attributes[i].Name} Location {gx2Shader.Attributes[i].Location} Location {gx2Shader.Attributes[i].Type}"); } } if (ImGui.CollapsingHeader("Uniform Blocks", ImGuiTreeNodeFlags.DefaultOpen)) { for (int i = 0; i < gx2Shader.UniformBlocks.Count; i++) { if (ImGui.CollapsingHeader($"Uniforms##{i}")) { ImGui.Text($"{gx2Shader.UniformBlocks[i].Name} Location {gx2Shader.UniformBlocks[i].Offset}"); var uniforms = gx2Shader.Uniforms.OrderBy(x => x.Offset).ToList(); for (int j = 0; j < uniforms.Count; j++) { if (uniforms[j].BlockIndex == i) { ImGui.Text($"{uniforms[j].Name} Type {uniforms[j].Type} offset {uniforms[j].Offset}"); } } } } } if (ImGui.CollapsingHeader("SHARCFB Attributes", ImGuiTreeNodeFlags.DefaultOpen)) { for (int i = 0; i < program.AttributeVariables.symbols.Count; i++) { var symbol = program.AttributeVariables.symbols[i]; ImGui.Text($"Name {symbol.Name} Symbol { symbol.SymbolName} Usage: { symbol.flags[shader.VariationBaseIndex]}"); } } if (ImGui.CollapsingHeader("SHARCFB Uniform Blocks", ImGuiTreeNodeFlags.DefaultOpen)) { for (int i = 0; i < program.UniformBlocks.symbols.Count; i++) { ImGui.Text($"Name {program.UniformBlocks.symbols[i].Name} Symbol { program.UniformBlocks.symbols[i].SymbolName}"); } } } if (selectedStage == "Pixel") { var gx2Shader = (GX2PixelShader)program.GetGX2PixelShader(shader.BinaryIndex); if (ImGui.CollapsingHeader("Uniform Blocks", ImGuiTreeNodeFlags.DefaultOpen)) { for (int i = 0; i < gx2Shader.UniformBlocks.Count; i++) { ImGui.Text($"{gx2Shader.UniformBlocks[i].Name} Location {gx2Shader.UniformBlocks[i].Offset}"); if (ImGui.CollapsingHeader($"Uniforms##{i}")) { var uniforms = gx2Shader.Uniforms.OrderBy(x => x.Offset).ToList(); for (int j = 0; j < uniforms.Count; j++) { if (uniforms[j].BlockIndex == i) { ImGui.Text($"{uniforms[j].Name} Type {uniforms[j].Type} offset {uniforms[j].Offset}"); } } } } } if (ImGui.CollapsingHeader("Samplers", ImGuiTreeNodeFlags.DefaultOpen)) { for (int i = 0; i < gx2Shader.Samplers.Count; i++) { ImGui.Text($"{gx2Shader.Samplers[i].Name} Location {gx2Shader.Samplers[i].Location} Type {gx2Shader.Samplers[i].Type}"); } } if (ImGui.CollapsingHeader("SHARCFB Samplers", ImGuiTreeNodeFlags.DefaultOpen)) { for (int i = 0; i < program.SamplerVariables.symbols.Count; i++) { ImGui.Text($"{program.SamplerVariables.symbols[i].Name} Symbol {program.SamplerVariables.symbols[i].SymbolName}"); } } } }
public void LoadEditorMenus(FMAT material) { if (UVViewport == null) { Init(); } if (activeMaterial != material) { onLoad = true; MaterialParameter.Reset(); MaterialOptions.Reset(); BfresTextureMapEditor.Reset(); UVViewport.Reset(); } activeMaterial = material; if (ImGui.CollapsingHeader("Material Info", ImGuiTreeNodeFlags.DefaultOpen)) { ImGuiHelper.InputFromText("Name", material, "Name", 200); ImGuiHelper.InputFromText("ShaderArchive", material, "ShaderArchive", 200); ImGuiHelper.InputFromText("ShaderModel", material, "ShaderModel", 200); ImGuiHelper.InputFromBoolean("Visible", material.Material, "Visible"); } if (ImGui.BeginChild("##MATERIAL_EDITOR")) { ImGui.BeginTabBar("Menu1"); if (ImguiCustomWidgets.BeginTab("Menu1", "Texture Maps")) { BfresTextureMapEditor.Render(material, UVViewport, onLoad); ImGui.EndTabItem(); } if (ImguiCustomWidgets.BeginTab("Menu1", "Parameters")) { MaterialParameter.Render(material); ImGui.EndTabItem(); } if (ImguiCustomWidgets.BeginTab("Menu1", "Render Info")) { RenderInfoEditor.Render(material); ImGui.EndTabItem(); } if (ImguiCustomWidgets.BeginTab("Menu1", "Options")) { MaterialOptions.Render(material); ImGui.EndTabItem(); } if (!material.ParentFile.ResFile.IsPlatformSwitch) { if (ImguiCustomWidgets.BeginTab("Menu1", "Render State")) { RenderStateEditor.Render(material); ImGui.EndTabItem(); } } if (ImguiCustomWidgets.BeginTab("Menu1", "User Data")) { UserDataInfoEditor.Render(material.Material.UserData); ImGui.EndTabItem(); } if (material.MaterialAsset is BfshaRenderer) { if (ImguiCustomWidgets.BeginTab("Menu1", "Shader Data")) { BfshaShaderProgramViewer.Render(material); ImGui.EndTabItem(); } } else if (material.MaterialAsset is SharcFBRenderer) { if (ImguiCustomWidgets.BeginTab("Menu1", "Shader Data")) { SharcFBShaderProgramViewer.Render(material); ImGui.EndTabItem(); } } if (material.MaterialAsset is KSANXRender) { if (ImguiCustomWidgets.BeginTab("Menu1", "Lighting Data")) { ((KSANXRender)material.MaterialAsset).RenderUI(); ImGui.EndTabItem(); } } ImGui.EndTabBar(); } ImGui.EndChild(); onLoad = false; }
public void LoadEditor(FMAT material) { LoadEditorMenus(material); }
public override bool UseRenderer(FMAT material, string archive, string model) { return(archive == "alRenderMaterial"); }
/// <summary> /// Determines when to use this renderer for the given material. /// This is typically done from the shader archive or shader model name. /// The material can also be used for shader specific render information to check. /// </summary> /// <returns></returns> public virtual bool UseRenderer(FMAT material, string archive, string model) { return(false); }
public static void Render(FMAT material) { if (LoadedOptions.Count == 0) { foreach (var op in material.ShaderOptions) { LoadedOptions.Add(op.Key, op.Value); } } bool isValid = true; var meshes = material.GetMappedMeshes(); foreach (FSHP mesh in meshes) { if (!mesh.HasValidShader) { isValid = false; } } if (!isValid) { ImGui.TextColored(new System.Numerics.Vector4(1f, 0, 0.0f, 1), "Invalid Option Combination!"); } else { ImGui.Text(""); } //ImGui.TextColored(new System.Numerics.Vector4(0.2f, 1, 0.3f, 1), "Valid Option Combination!"); RenderHeader(material); if (ImGui.BeginChild("OPTION_LIST")) { ImGui.Columns(2); int index = 0; foreach (var option in LoadedOptions) { if (SelectedIndices.Contains(index)) { if (ImGui.CollapsingHeader(option.Key, ImGuiTreeNodeFlags.DefaultOpen)) { string value = option.Value; if (ImGui.InputText("", ref value, 100)) { material.ShaderOptions[option.Key] = value; foreach (FSHP mesh in meshes) { mesh.ReloadShader(); } } } } else if (ImGui.Selectable(option.Key, SelectedIndices.Contains(index))) { SelectedIndices.Clear(); SelectedIndices.Add(index); } ImGui.NextColumn(); ImGui.Text(option.Value); ImGui.NextColumn(); index++; } } ImGui.EndChild(); ImGui.Columns(1); }
public void OnLoad(FMAT material, RenderInfo renderInfo) { originalData = renderInfo.Data; originalName = renderInfo.Name; ValuePresets = RenderInfoEnums.FindRenderInfoPresets(material, renderInfo.Name).ToList(); }
static void ConvertSwitchRenderState(FMAT mat) { string blend = mat.GetRenderInfo("gsys_render_state_blend_mode"); //Alpha test string alphaTest = mat.GetRenderInfo("gsys_alpha_test_enable"); string alphaFunc = mat.GetRenderInfo("gsys_alpha_test_func"); float alphaValue = mat.GetRenderInfo("gsys_alpha_test_value"); string colorOp = mat.GetRenderInfo("gsys_color_blend_rgb_op"); string colorDst = mat.GetRenderInfo("gsys_color_blend_rgb_dst_func"); string colorSrc = mat.GetRenderInfo("gsys_color_blend_rgb_src_func"); float[] blendColorF32 = mat.Material.RenderInfos["gsys_color_blend_const_color"].GetValueSingles(); string alphaOp = mat.GetRenderInfo("gsys_color_blend_alpha_op"); string alphaDst = mat.GetRenderInfo("gsys_color_blend_alpha_dst_func"); string alphaSrc = mat.GetRenderInfo("gsys_color_blend_alpha_src_func"); string depthTest = mat.GetRenderInfo("gsys_depth_test_enable"); string depthTestFunc = mat.GetRenderInfo("gsys_depth_test_func"); string depthWrite = mat.GetRenderInfo("gsys_depth_test_write"); string state = mat.GetRenderInfo("gsys_render_state_mode"); if (state == "opaque") { mat.BlendState.State = GLMaterialBlendState.BlendState.Opaque; } else if (state == "translucent") { mat.BlendState.State = GLMaterialBlendState.BlendState.Translucent; } else if (state == "mask") { mat.BlendState.State = GLMaterialBlendState.BlendState.Mask; } else { mat.BlendState.State = GLMaterialBlendState.BlendState.Custom; } string displayFace = mat.GetRenderInfo("gsys_render_state_display_face"); if (displayFace == "front") { mat.CullFront = false; mat.CullBack = true; } if (displayFace == "back") { mat.CullFront = true; mat.CullBack = false; } if (displayFace == "both") { mat.CullFront = false; mat.CullBack = false; } if (displayFace == "none") { mat.CullFront = true; mat.CullBack = true; } if (!string.IsNullOrEmpty(state) && state != "opaque") { mat.IsTransparent = true; } mat.BlendState.Color = new OpenTK.Vector4(blendColorF32[0], blendColorF32[1], blendColorF32[2], blendColorF32[3]); mat.BlendState.BlendColor = blend == "color"; mat.BlendState.DepthTest = depthTest == "true"; mat.BlendState.DepthWrite = depthWrite == "true"; mat.BlendState.AlphaTest = alphaTest == "true"; mat.BlendState.AlphaValue = alphaValue; if (alphaFunc == "always") { mat.BlendState.AlphaFunction = AlphaFunction.Always; } if (alphaFunc == "equal") { mat.BlendState.AlphaFunction = AlphaFunction.Equal; } if (alphaFunc == "lequal") { mat.BlendState.AlphaFunction = AlphaFunction.Lequal; } if (alphaFunc == "gequal") { mat.BlendState.AlphaFunction = AlphaFunction.Gequal; } if (alphaFunc == "less") { mat.BlendState.AlphaFunction = AlphaFunction.Less; } if (alphaFunc == "greater") { mat.BlendState.AlphaFunction = AlphaFunction.Greater; } if (alphaFunc == "never") { mat.BlendState.AlphaFunction = AlphaFunction.Never; } }
public override bool UseRenderer(FMAT material, string archive, string model) { //Todo users may want to use multiple shader archives in a custom map. //May need to find a better way to detect this. return(archive == "Turbo_UBER"); }
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; } }
/// <summary> /// Determines when to use this renderer for the given material. /// This is typically done from the shader archive or shader model name. /// The material can also be used for shader specific render information to check. /// </summary> /// <returns></returns> public override bool UseRenderer(FMAT material, string archive, string model) { return(false); }
public static void Render(FMAT material, UVViewport UVViewport, bool onLoad) { float width = ImGui.GetWindowWidth(); if (ImGui.BeginChild("TEXTURE_MAP_LIST", new System.Numerics.Vector2(width, 100))) { int index = 0; foreach (var texMap in material.TextureMaps) { var tex = SearchTextureInstance(texMap.Name); if (tex != null) { if (tex.RenderableTex == null) { tex.LoadRenderableTexture(); } if (tex.RenderableTex != null) { IconManager.LoadTexture(tex.Name, tex); } else { IconManager.LoadIcon("TEXTURE"); } } else { IconManager.LoadIcon("TEXTURE"); } ImGui.SameLine(); if (dialogOpened && SelectedIndices.Contains(index)) { if (TextureSelectionDialog.Render(texMap.Name, ref dialogOpened)) { var input = TextureSelectionDialog.OutputName; //Only undo matching textures, not typed names if (tex != null) { UndoStack.Add(new UndoStringOperation($"Texture Map", texMap, "Name", input)); } texMap.Name = input; } } else { if (ImGui.Selectable(texMap.Name, SelectedIndices.Contains(index))) { SelectedIndices.Clear(); SelectedIndices.Add(index); } if (ImGui.IsItemClicked() && ImGui.IsMouseDoubleClicked(0)) { dialogOpened = true; } } index++; } } ImGui.EndChild(); if (material.TextureMaps.Count == 0) { return; } //Make sure there is atleast 1 selection used if (SelectedIndices.Count == 0) { SelectedIndices.Add(0); } if (ImGui.BeginChild("SAMPLER_DATA")) { SelectSampler(material, UVViewport, SelectedIndices.FirstOrDefault(), onLoad); } ImGui.EndChild(); }
static void ConvertWiiURenderState(FMAT mat, RenderState renderState) { var alphaControl = renderState.AlphaControl; var depthControl = renderState.DepthControl; var blendControl = renderState.BlendControl; var blendColor = renderState.BlendColor; mat.CullBack = renderState.PolygonControl.CullBack; mat.CullFront = renderState.PolygonControl.CullFront; var mode = renderState.FlagsMode; if (mode == RenderStateFlagsMode.Opaque) { mat.BlendState.State = GLMaterialBlendState.BlendState.Opaque; } else if (mode == RenderStateFlagsMode.Translucent) { mat.BlendState.State = GLMaterialBlendState.BlendState.Translucent; } else if (mode == RenderStateFlagsMode.AlphaMask) { mat.BlendState.State = GLMaterialBlendState.BlendState.Mask; } else { mat.BlendState.State = GLMaterialBlendState.BlendState.Custom; } mat.IsTransparent = mode != RenderStateFlagsMode.Opaque; mat.BlendState.ColorDst = (BlendingFactorDest)ConvertBlend(blendControl.ColorDestinationBlend); mat.BlendState.ColorSrc = (BlendingFactorSrc)ConvertBlend(blendControl.ColorSourceBlend); mat.BlendState.AlphaDst = (BlendingFactorDest)ConvertBlend(blendControl.AlphaDestinationBlend); mat.BlendState.AlphaSrc = (BlendingFactorSrc)ConvertBlend(blendControl.AlphaSourceBlend); mat.BlendState.AlphaOp = ConvertOp(blendControl.AlphaCombine); mat.BlendState.ColorOp = ConvertOp(blendControl.ColorCombine); mat.BlendState.Color = new OpenTK.Vector4(blendColor[0], blendColor[1], blendColor[2], blendColor[3]); mat.BlendState.DepthTest = depthControl.DepthTestEnabled; mat.BlendState.DepthWrite = depthControl.DepthWriteEnabled; mat.BlendState.AlphaTest = alphaControl.AlphaTestEnabled; mat.BlendState.AlphaValue = renderState.AlphaRefValue; mat.BlendState.BlendMask = renderState.ColorControl.BlendEnableMask == 1; //Todo the blend state flags seem off? This works for now. mat.BlendState.BlendColor = renderState.FlagsBlendMode != RenderStateFlagsBlendMode.None; switch (alphaControl.AlphaFunc) { case GX2CompareFunction.Always: mat.BlendState.AlphaFunction = AlphaFunction.Always; break; case GX2CompareFunction.Greater: mat.BlendState.AlphaFunction = AlphaFunction.Greater; break; case GX2CompareFunction.GreaterOrEqual: mat.BlendState.AlphaFunction = AlphaFunction.Gequal; break; case GX2CompareFunction.Equal: mat.BlendState.AlphaFunction = AlphaFunction.Equal; break; case GX2CompareFunction.LessOrEqual: mat.BlendState.AlphaFunction = AlphaFunction.Lequal; break; case GX2CompareFunction.NotEqual: mat.BlendState.AlphaFunction = AlphaFunction.Notequal; break; case GX2CompareFunction.Never: mat.BlendState.AlphaFunction = AlphaFunction.Never; break; } }
private NodeBase CreateParamNodeHierachy(FMAT material, ParamAnimGroup group) { var groupNode = new NodeBase(group.Name); groupNode.Tag = group; var tracks = group.GetTracks(); if (material != null) { List <ParamTrack> paramTracks = new List <ParamTrack>(); var param = material.ShaderParams[group.Name]; switch (param.Type) { case ShaderParamType.TexSrt: case ShaderParamType.TexSrtEx: var texSrt = ((TexSrt)param.DataValue); paramTracks.Add(new ParamTrack(0, (float)texSrt.Mode, "Mode")); paramTracks.Add(new ParamTrack(4, (float)texSrt.Scaling.X, "Scale.X")); paramTracks.Add(new ParamTrack(8, (float)texSrt.Scaling.Y, "Scale.Y")); paramTracks.Add(new ParamTrack(12, (float)texSrt.Rotation, "Rotate")); paramTracks.Add(new ParamTrack(16, (float)texSrt.Translation.X, "Position.X")); paramTracks.Add(new ParamTrack(20, (float)texSrt.Translation.Y, "Position.X")); break; case ShaderParamType.Float: paramTracks.Add(new ParamTrack(0, (float)param.DataValue, "Value")); break; case ShaderParamType.Float2: case ShaderParamType.Float3: case ShaderParamType.Float4: var values = ((float[])param.DataValue); string[] channel = new string[4] { "X", "Y", "Z", "W" }; for (int i = 0; i < values.Length; i++) { paramTracks.Add(new ParamTrack((uint)i * 4, values[i], channel[i])); } break; } for (int i = 0; i < paramTracks.Count; i++) { var targetTrack = group.Tracks.FirstOrDefault(x => ((ParamTrack)x).ValueOffset == paramTracks[i].ValueOffset); if (targetTrack == null) { group.Tracks.Add(paramTracks[i]); } else { targetTrack.Name = paramTracks[i].Name; } } } foreach (ParamTrack track in group.Tracks.OrderBy(x => ((ParamTrack)x).ValueOffset)) { track.ChannelIndex = ((int)track.ValueOffset / 4); var trackNode = new NodeBase(track.Name); trackNode.Tag = track; groupNode.AddChild(trackNode); } return(groupNode); }
private void SetUniforms(ShaderProgram shader, FMAT mat) { }
public override bool UseRenderer(FMAT material, string archive, string model) { return(archive == "Blitz_UBER"); }
public override bool UseRenderer(FMAT material, string archive, string model) { return(material.Material.RenderInfos.ContainsKey("shadingModel")); }
public void DragDroppedOnEnter() { beforeDroppedMaterial = this.Material; }