private void btnAdd_Click(object sender, EventArgs e)
        {
            if (IsWiiU)
            {
                UserData userDataNew = new UserData();
                userDataNew.SetValue(new int[0]);
                SelectedDataU = userDataNew;
                bool IsEdited = EditData();

                if (IsEdited)
                {
                    userData.Add(SelectedDataU.Name, SelectedDataU);
                    LoadUserData(SelectedDataU);
                }
            }
            else
            {
                ResNX.UserData userDataNew = new ResNX.UserData();
                userDataNew.SetValue(new int[0]);
                SelectedDataNX = userDataNew;
                bool IsEdited = EditData();

                if (IsEdited)
                {
                    userDataNX.Add(SelectedDataNX);
                    LoadUserData(SelectedDataNX);
                }
            }
        }
示例#2
0
        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);
            }
        }
示例#3
0
        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));
        }
示例#4
0
        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);
            }
        }
示例#5
0
        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
            });
        }
示例#6
0
        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);
        }
示例#8
0
        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();
        }
        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;
        }