MeshTextureDuplicationPlugin.cs

using DuplicationPluginInjectorPlugin;
using Frosty.Controls;
using Frosty.Core;
using Frosty.Core.Controls;
using Frosty.Core.Viewport;
using Frosty.Core.Windows;
using FrostySdk;
using FrostySdk.Ebx;
using FrostySdk.IO;
using FrostySdk.Managers;
using FrostySdk.Resources;
using MeshSetPlugin.Resources;
using MeshTextureDuplicationPlugin.Windows;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Windows;
using System.Windows.Media;
using System.Windows.Threading;
using System.Linq;
using static DuplicationPlugin.DuplicationTool;

namespace MeshTextureDuplicationPlugin
{
    [RegisterDuplicationExtension]
    public class MeshTextureDuplicationExtension : DuplicateAssetExtension {
        public override string AssetType => "MeshAsset";

        public override EbxAssetEntry DuplicateAsset(EbxAssetEntry entry, string newName, bool createNew, Type newType)
        {
            //2017 battlefront meshes always have lowercase names. This doesn't apply to all games, but its still safer to do so
            newName = newName.ToLower();

            // Duplicate the ebx
            EbxAssetEntry newEntry = base.DuplicateAsset(entry, newName, createNew, newType);
            EbxAsset newAsset = App.AssetManager.GetEbx(newEntry);

            // Get the original asset root object data
            EbxAsset asset = App.AssetManager.GetEbx(entry);
            dynamic meshProperties = asset.RootObject;
            dynamic newMeshProperties = newAsset.RootObject;

            //Get the original res entry and duplicate it
            ResAssetEntry resAsset = App.AssetManager.GetResEntry(meshProperties.MeshSetResource);
            ResAssetEntry newResAsset = DuplicateRes(resAsset, newName, ResourceType.MeshSet);

            //Since this is a mesh we need to get the meshSet for the duplicated entry and set it up
            MeshSet meshSet = App.AssetManager.GetResAs<MeshSet>(newResAsset);
            meshSet.FullName = newResAsset.Name;

            //Go through all of the lods and duplicate their chunks
            foreach (MeshSetLod lod in meshSet.Lods)
            {
                lod.Name = newResAsset.Name;
                //Double check that the lod actually has a chunk id. If it doesn't this means the data is inline and we don't need to worry
                if (lod.ChunkId != Guid.Empty)
                {
                    //Get the original chunk and dupe it
                    ChunkAssetEntry chunk = App.AssetManager.GetChunkEntry(lod.ChunkId);
                    ChunkAssetEntry newChunk = DuplicateChunk(chunk);

                    //Now set the params for the lod
                    lod.ChunkId = newChunk.Id;

                    //Link the res and chunk
                    newResAsset.LinkAsset(newChunk);

                    foreach (var section in lod.Sections)
                    {
                        string sectionName = section.Name;
                    }
                }
            }

            //Set our new mesh's properties
            newMeshProperties.MeshSetResource = newResAsset.ResRid;
            newMeshProperties.NameHash = (uint)Utils.HashString(newName);

            //Link the res and ebx
            newEntry.LinkAsset(newResAsset);

            // Stuff for SBDs since SWBF2 is weird
            if (ProfilesLibrary.IsLoaded(ProfileVersion.StarWarsBattlefrontII))
            {
                // Restore the texture params
                MeshVariation meshVariation = MeshVariationDb.GetVariations(entry.Guid).Variations[0];

                List<MeshVariationMaterial> mats = new List<MeshVariationMaterial>();
                List<string> sectionNames = new List<string>();
                Dictionary<MeshVariationMaterial, string> idDict = new Dictionary<MeshVariationMaterial, string>();

                for (int i = 0; i < newMeshProperties.Materials.Count; i++) // For each material in the new variation
                {
                    PointerRef _matObject = newMeshProperties.Materials[i];
                    object matObject = _matObject.Internal;
                    string sectionName = meshSet.Lods[0].Sections[i].Name;
                    sectionNames.Add(sectionName);
                    // Check if this is actually a material
                    if (TypeLibrary.IsSubClassOf(matObject.GetType(), "MeshMaterial") && ((dynamic)matObject).Shader.TextureParameters.Count == 0)
                    {
                        // Get the material object as a dynamic, so we can see and edit its properties
                        dynamic matProperties = matObject as dynamic;

                        AssetClassGuid guid = matProperties.GetInstanceGuid();

                        foreach (MeshVariationMaterial mvm in meshVariation.Materials) // For each material in the original assets MVDB Entry
                        {
                            if (mvm.MaterialGuid == guid.ExportedGuid) // If it has the same guid
                            {
                                mats.Add(mvm);

                                // We then use its texture params as the texture params in the variation
                                foreach (dynamic texParam in (dynamic)mvm.TextureParameters)
                                {
                                    // do NOT do this! it will make a references internally to the same class, making all
                                    // instances the same! bad wannkunst bad!
                                    //matProperties.Shader.TextureParameters.Add(texParam);
                                    dynamic newTexParam = TypeLibrary.CreateObject("TextureShaderParameter");
                                    newTexParam.ParameterName = texParam.ParameterName;
                                    newTexParam.Value = texParam.Value;
                                    matProperties.Shader.TextureParameters.Add(newTexParam);
                                }
                                break;
                            }
                        }
                    }
                }

                MeshDuplicationOptions opts = new MeshDuplicationOptions();
                opts.Load();

                if (opts.DupeMeshTextures)
                {
                    Application.Current.Dispatcher.Invoke(() =>
                    {
                        DuplicateMeshTexturesConfigWindow configWindow = new DuplicateMeshTexturesConfigWindow(mats, entry, sectionNames);
                        configWindow.Show();
                        configWindow.Closed += (_, __) =>
                        {
                            // FIXME: Account for placeholders in target path.
                            // FIXME: Ensure unique names.
                            //App.Logger.Log($"Closed with value {configWindow.shouldDupe}");
                            //App.Logger.Log($"Enabled value: {configWindow.parameters[0].Enabled}");
                            if (!configWindow.shouldDupe) { return; } // cancel button clicked

                            TextureExtension ext = new TextureExtension();

                            EbxAssetEntry lastTexture = null;
                            foreach (TextureParameterRepresentation tpr in configWindow.parameters)
                            {
                                if (!tpr.Enabled)
                                {
                                    continue; // box was not checked
                                }

                                string[] splitName = newEntry.Name.Split('/');
                                string targetPath = string.Join("/", splitName.Take(splitName.Length - 1).ToArray()) + "/" + tpr.TargetName;
                                lastTexture = ext.DuplicateAsset(tpr.OriginalTextureEntry, targetPath, false, null);
                            }
                            try
                            {
                                App.EditorWindow.DataExplorer.SelectAsset(lastTexture);
                            }
                            catch (Exception ex)
                            {
                                App.Logger.Log("Unable to show duped texture in data explorer for some reason. Refresh the data explorer by toggling \"Show Modified\".");
                            }
                        };
                    });
                    if (opts.ShowWarningPopup)
                    {
                        FrostyMessageBox.Show("Please finish duplicating the textures (or hit cancel) before moving on to other tasks.\n\nYou can disable this popup in settings.", "Duplication Plugin");
                    }
                }

                // Duplicate the sbd
                ResAssetEntry oldShaderBlock = App.AssetManager.GetResEntry(entry.Name.ToLower() + "_mesh/blocks");
                ResAssetEntry newShaderBlock = DuplicateRes(oldShaderBlock, newResAsset.Name + "_mesh/blocks", ResourceType.ShaderBlockDepot);
                ShaderBlockDepot newShaderBlockDepot = App.AssetManager.GetResAs<ShaderBlockDepot>(newShaderBlock);

                // TODO: hacky way to generate unique hashes
                for (int i = 0; i < newShaderBlockDepot.ResourceCount; i++)
                {
                    ShaderBlockResource res = newShaderBlockDepot.GetResource(i);
                    res.ChangeHash(meshSet.NameHash);
                }

                // Change the references in the sbd
                for (int lod = 0; lod < meshSet.Lods.Count; lod++)
                {
                    ShaderBlockEntry sbEntry = newShaderBlockDepot.GetSectionEntry(lod);
                    ShaderBlockMeshVariationEntry sbMvEntry = newShaderBlockDepot.GetResource(sbEntry.Index + 1) as ShaderBlockMeshVariationEntry;

                    // calculate new entry hash
                    sbEntry.SetHash(meshSet.NameHash, 0, lod);
                    sbMvEntry.SetHash(meshSet.NameHash, 0, lod);

                    // Update the mesh guid
                    for (int section = 0; section < meshSet.Lods[lod].Sections.Count; section++)
                    {
                        MeshParamDbBlock mesh = sbEntry.GetMeshParams(section);
                        mesh.MeshAssetGuid = newAsset.RootInstanceGuid;
                    }
                }

                App.AssetManager.ModifyRes(newShaderBlock.Name, newShaderBlockDepot);

                newResAsset.LinkAsset(newShaderBlock);
            }

            //Modify the res and ebx
            App.AssetManager.ModifyRes(newResAsset.Name, meshSet);
            App.AssetManager.ModifyEbx(newName, newAsset);

            return newEntry;
        }
    }

    public class CheatSheetMenuExtension : MenuExtension
    {
        public override string MenuItemName => "Texture Placeholder Cheat Sheet";
        public override string TopLevelMenuName => "Help";
    }
}