public void SetAppearance(AppearancePreset preset)
    {
        if (!canCustomize)
        {
            spawned = true;
            return;
        }

        DisableAll();

        if (preset.fullBody != -1)
        {
            fullBody [preset.fullBody].SetActive(true);
            fullBody [preset.fullBody].GetComponent <Renderer> ().material.color = Color.red;
        }
        else
        {
            if (preset.top != -1 && tops.Length > preset.top)
            {
                tops [preset.top].SetActive(true);
                tops [preset.top].GetComponent <Renderer> ().material.color = Color.red;
            }
            if (preset.bottom != -1 && bottoms.Length > preset.bottom)
            {
                bottoms [preset.bottom].SetActive(true);
                bottoms [preset.bottom].GetComponent <Renderer> ().material.color = Color.red;
            }
            if (preset.over != -1 && overs.Length > preset.over)
            {
                overs [preset.over].SetActive(true);
                overs [preset.over].GetComponent <Renderer> ().material.color = Color.red;
            }
        }

        if (preset.shoes != -1 && shoes.Length > preset.shoes)
        {
            shoes [preset.shoes].SetActive(true);
            shoes [preset.shoes].GetComponent <Renderer> ().material.color = Color.red;
        }

        body.material.color = preset.bodyColor;
        hair.material.color = preset.hairColor;
        hair.material.color = Color.red * 0.75f;
        hair.material.SetColor("_SpecColor", Color.black);
        spawned = true;
    }
示例#2
0
    static void AssignPreset()
    {
        GameObject             person     = Selection.activeGameObject;
        CharacterCustomization appearance = person.GetComponent <CharacterCustomization> ();

        GameObject spawner = GameObject.Find("PeopleSpawner");

        if (spawner == null)
        {
            EditorUtility.DisplayDialog("Spawner inactive", "Set PeopleSpawner active and try again", "OK");
            return;
        }

        AppearancePreset preset = new AppearancePreset(appearance);

        PeopleSpawner script = spawner.GetComponent <PeopleSpawner> ();

        script.heroPreset = preset;

        DestroyImmediate(person);
    }
示例#3
0
        private void OnSaveAppearancePresetToFile(object sender, EventArgs e)
        {
            if (this._SaveFile == null)
            {
                MessageBox.Show(
                    Properties.Localization.Editor_NoActiveSave,
                    Properties.Localization.Error,
                    MessageBoxButtons.OK,
                    MessageBoxIcon.Error);
                return;
            }

            if (this._SaveFile.Player.Appearance.HasMorphHead == false)
            {
                MessageBox.Show(
                    Properties.Localization.Editor_NoHeadMorph,
                    Properties.Localization.Error,
                    MessageBoxButtons.OK,
                    MessageBoxIcon.Error);
                return;
            }

            if (this._RootAppearancePresetSaveFileDialog.ShowDialog() != DialogResult.OK)
            {
                return;
            }

            var dir = Path.GetDirectoryName(this._RootAppearancePresetSaveFileDialog.FileName);
            this._RootAppearancePresetSaveFileDialog.InitialDirectory = dir;

            var headMorph = this.SaveFile.Player.Appearance.MorphHead;

            // ReSharper disable UseObjectOrCollectionInitializer
            var preset = new AppearancePreset();
            // ReSharper restore UseObjectOrCollectionInitializer

            preset.HairMesh = headMorph.HairMesh;

            foreach (var scalar in headMorph.ScalarParameters)
            {
                preset.Scalars.Set.Add(new KeyValuePair<string, float>(scalar.Name, scalar.Value));
            }

            foreach (var texture in headMorph.TextureParameters)
            {
                preset.Textures.Set.Add(new KeyValuePair<string, string>(texture.Name, texture.Value));
            }

            foreach (var vector in headMorph.VectorParameters)
            {
                preset.Vectors.Set.Add(new KeyValuePair<string, AppearancePreset.
                                           LinearColor>(vector.Name,
                                                        new AppearancePreset.
                                                            LinearColor()
                                                        {
                                                            R = vector.Value.R,
                                                            G = vector.Value.G,
                                                            B = vector.Value.B,
                                                            A = vector.Value.A,
                                                        }));
            }

            using (var output = File.Create(this._RootAppearancePresetSaveFileDialog.FileName))
            {
                var writer = new StreamWriter(output);
                writer.Write(JsonConvert.SerializeObject(
                    preset, Formatting.Indented));
                writer.Flush();
            }
        }
示例#4
0
        private static void ApplyAppearancePreset(SaveFormats.MorphHead morphHead,
                                                  AppearancePreset preset)
        {
            if (morphHead == null)
            {
                throw new ArgumentNullException("morphHead");
            }

            if (preset == null)
            {
                throw new ArgumentNullException("preset");
            }

            if (string.IsNullOrEmpty(preset.HairMesh) == false)
            {
                morphHead.HairMesh = preset.HairMesh;
            }

            if (preset.Scalars != null)
            {
                if (preset.Scalars.Clear == true)
                {
                    morphHead.ScalarParameters.Clear();
                }

                if (preset.Scalars.Remove != null)
                {
                    foreach (var scalar in preset.Scalars.Remove)
                    {
                        morphHead.ScalarParameters.RemoveAll(
                            p => string.Compare(p.Name, scalar, StringComparison.InvariantCultureIgnoreCase) == 0);
                    }
                }

                if (preset.Scalars.Add != null)
                {
                    foreach (var scalar in preset.Scalars.Add)
                    {
                        morphHead.ScalarParameters.Add(
                            new SaveFormats.MorphHead.ScalarParameter()
                            {
                                Name = scalar.Key,
                                Value = scalar.Value,
                            });
                    }
                }

                if (preset.Scalars.Set != null)
                {
                    foreach (var scalar in preset.Scalars.Set)
                    {
                        morphHead.ScalarParameters.RemoveAll(
                            p => string.Compare(p.Name, scalar.Key, StringComparison.InvariantCultureIgnoreCase) == 0);
                        morphHead.ScalarParameters.Add(
                            new SaveFormats.MorphHead.ScalarParameter()
                            {
                                Name = scalar.Key,
                                Value = scalar.Value,
                            });
                    }
                }
            }

            if (preset.Textures != null)
            {
                if (preset.Textures.Clear == true)
                {
                    morphHead.TextureParameters.Clear();
                }

                if (preset.Textures.Remove != null)
                {
                    foreach (var texture in preset.Textures.Remove)
                    {
                        morphHead.TextureParameters.RemoveAll(
                            p => string.Compare(p.Name, texture, StringComparison.InvariantCultureIgnoreCase) == 0);
                    }
                }

                if (preset.Textures.Add != null)
                {
                    foreach (var texture in preset.Textures.Add)
                    {
                        morphHead.TextureParameters.Add(
                            new SaveFormats.MorphHead.TextureParameter()
                            {
                                Name = texture.Key,
                                Value = texture.Value,
                            });
                    }
                }

                if (preset.Textures.Set != null)
                {
                    foreach (var texture in preset.Textures.Set)
                    {
                        morphHead.TextureParameters.RemoveAll(
                            p => string.Compare(p.Name, texture.Key, StringComparison.InvariantCultureIgnoreCase) == 0);
                        morphHead.TextureParameters.Add(
                            new SaveFormats.MorphHead.TextureParameter()
                            {
                                Name = texture.Key,
                                Value = texture.Value,
                            });
                    }
                }
            }

            if (preset.Vectors != null)
            {
                if (preset.Vectors.Clear == true)
                {
                    morphHead.VectorParameters.Clear();
                }

                if (preset.Vectors.Remove != null)
                {
                    foreach (var vector in preset.Vectors.Remove)
                    {
                        string temp = vector;
                        morphHead.VectorParameters.RemoveAll(
                            p => string.Compare(p.Name, temp, StringComparison.InvariantCultureIgnoreCase) == 0);
                    }
                }

                if (preset.Vectors.Add != null)
                {
                    foreach (var vector in preset.Vectors.Add)
                    {
                        morphHead.VectorParameters.Add(
                            new SaveFormats.MorphHead.VectorParameter()
                            {
                                Name = vector.Key,
                                Value = new SaveFormats.LinearColor()
                                {
                                    R = vector.Value.R,
                                    G = vector.Value.G,
                                    B = vector.Value.B,
                                    A = vector.Value.A,
                                },
                            });
                    }
                }

                if (preset.Vectors.Set != null)
                {
                    foreach (var vector in preset.Vectors.Set)
                    {
                        var temp = vector;
                        morphHead.VectorParameters.RemoveAll(
                            p => string.Compare(p.Name, temp.Key, StringComparison.InvariantCultureIgnoreCase) == 0);
                        morphHead.VectorParameters.Add(
                            new SaveFormats.MorphHead.VectorParameter()
                            {
                                Name = vector.Key,
                                Value = new SaveFormats.LinearColor()
                                {
                                    R = vector.Value.R,
                                    G = vector.Value.G,
                                    B = vector.Value.B,
                                    A = vector.Value.A,
                                },
                            });
                    }
                }
            }
        }
示例#5
0
 public void ApplyPresetToPoly(AppearancePreset preset)
 {
     preset.ApplyToPoly(ref _poly, LightsParent, CurrentCamera);
 }