//////////////////////////////////////////////////////
// Copyright (c) BrainFailProductions
//////////////////////////////////////////////////////
#if UNITY_EDITOR
using System;
using System.Collections.Generic;
using UnityEditor;
using UnityEngine;
using static BrainFailProductions.PolyFew.CombiningInformation;
namespace BrainFailProductions.PolyFew
{
[System.Serializable]
public class DataContainer
{
[System.Serializable]
public class TempGameObjectWrapper
{
[HideInInspector]
[SerializeField]
private GameObject gameObject;
// This is the unique Id for the current GameObject and it's children hierarchy
[HideInInspector]
[SerializeField]
private int uniqueId;
private TempGameObjectWrapper(GameObject gameObject)
{
this.gameObject = gameObject ?? throw new ArgumentNullException(nameof(gameObject));
uniqueId = gameObject.GetInstanceID();
}
public static implicit operator GameObject(TempGameObjectWrapper gameObjectWrapper) => gameObjectWrapper.gameObject;
public static explicit operator TempGameObjectWrapper(GameObject gameObject) => new TempGameObjectWrapper(gameObject);
public override int GetHashCode()
{
return uniqueId;
}
public override bool Equals(object obj)
{
if ((obj == null) || !GetType().Equals(obj.GetType()))
{
return false;
}
else
{
return (GetHashCode() == obj.GetHashCode());
}
}
}
[System.Serializable]
public class ObjectMeshPair : SerializableDictionary<GameObject, MeshRendererPair> { }
[System.Serializable]
public class MeshRendererPair
{
public bool attachedToMeshFilter;
public Mesh mesh;
public MeshRendererPair(bool attachedToMeshFilter, Mesh mesh)
{
this.attachedToMeshFilter = attachedToMeshFilter;
this.mesh = mesh;
}
public void Destruct()
{
if(mesh != null)
{
UnityEngine.Object.DestroyImmediate(mesh);
}
}
}
[System.Serializable]
public class CustomMeshActionStructure
{
public MeshRendererPair meshRendererPair;
public GameObject gameObject;
public Action action;
public CustomMeshActionStructure(MeshRendererPair meshRendererPair, GameObject gameObject, Action action)
{
this.meshRendererPair = meshRendererPair;
this.gameObject = gameObject;
this.action = action;
}
}
[System.Serializable]
public class ObjectHistory
{
public bool isReduceDeep;
public ObjectMeshPair objectMeshPairs;
public ObjectHistory(bool isReduceDeep, ObjectMeshPair objectMeshPairs)
{
this.isReduceDeep = isReduceDeep;
this.objectMeshPairs = objectMeshPairs;
}
public void Destruct()
{
if (objectMeshPairs == null || objectMeshPairs.Count == 0)
{
return;
}
foreach (var item in objectMeshPairs)
{
item.Value.Destruct();
}
objectMeshPairs = null;
}
}
[System.Serializable]
public class UndoRedoOps
{
private const int OBJECT_HISTORY_LIMIT = 5;
public GameObject gameObject;
public List<ObjectHistory> undoOperations;
public List<ObjectHistory> redoOperations;
public UndoRedoOps(GameObject gameObject, List<ObjectHistory> undoOperations, List<ObjectHistory> redoOperations)
{
this.gameObject = gameObject;
this.undoOperations = undoOperations;
this.redoOperations = redoOperations;
}
public void SaveRecord(bool isReduceDeep, bool isUndo, ObjectMeshPair originalMeshesClones)
{
if (undoOperations == null)
{
undoOperations = new List<ObjectHistory>();
}
if (redoOperations == null)
{
redoOperations = new List<ObjectHistory>();
}
if (isUndo)
{
if (undoOperations.Count == OBJECT_HISTORY_LIMIT)
{
undoOperations[0].Destruct();
undoOperations[0] = null;
undoOperations.RemoveAt(0);
}
ObjectHistory undoOperation = new ObjectHistory(isReduceDeep, originalMeshesClones);
undoOperations.Add(undoOperation);
}
else
{
if (redoOperations.Count == OBJECT_HISTORY_LIMIT)
{
redoOperations[0].Destruct();
redoOperations[0] = null;
redoOperations.RemoveAt(0);
}
ObjectHistory redoOperation = new ObjectHistory(isReduceDeep, originalMeshesClones);
redoOperations.Add(redoOperation);
}
}
public void ApplyUndoRedoOperation(bool isUndo)
{
if (isUndo)
{
if (undoOperations == null || undoOperations.Count == 0)
{
return;
}
}
else
{
if (redoOperations == null || redoOperations.Count == 0)
{
return;
}
}
List<ObjectHistory> operations = isUndo ? undoOperations : redoOperations;
ObjectHistory lastOp = operations[operations.Count - 1];
if (lastOp.isReduceDeep)
{
if (isUndo)
{
//Debug.Log("Last undo operation was reduce deep ObjectMeshPair count " + lastOp.objectMeshPairs.Count);
}
else
{
//Debug.Log("Last redo operation was reduce deep ObjectMeshPair count " + lastOp.objectMeshPairs.Count);
}
}
else
{
if (isUndo)
{
//Debug.Log("Last undo operation was NOT reduce deep ObjectMeshPair count " + lastOp.objectMeshPairs.Count);
}
else
{
//Debug.Log("Last redo operation was NOT reduce deep ObjectMeshPair count " + lastOp.objectMeshPairs.Count);
}
}
ObjectMeshPair originalMeshesClones = new ObjectMeshPair();
int totalOverwrites = lastOp.objectMeshPairs.Count;
int done = 0;
foreach (var kvp in lastOp.objectMeshPairs)
{
EditorUtility.DisplayProgressBar("Performing Undo/Redo", $"Reverting mesh changes to existing files {++done}/{totalOverwrites}", ((float)done / totalOverwrites));
MeshRendererPair meshRendererPair = kvp.Value;
GameObject gameObject = kvp.Key;
if (gameObject == null) { continue; }
if (meshRendererPair == null) { continue; }
if (meshRendererPair.mesh == null) { continue; }
if (meshRendererPair.attachedToMeshFilter)
{
MeshFilter filter = gameObject.GetComponent<MeshFilter>();
if (filter != null)
{
Mesh origMesh = UnityEngine.Object.Instantiate(filter.sharedMesh);
MeshRendererPair originalPair = new MeshRendererPair(true, origMesh);
originalMeshesClones.Add(gameObject, originalPair);
// Overwrites the mesh assets and keeps references intact
if (UtilityServices.OverwriteAssetWith(filter.sharedMesh, meshRendererPair.mesh, true)) { }
else
{
filter.sharedMesh.Clear();
EditorUtility.CopySerialized(meshRendererPair.mesh, filter.sharedMesh);
filter.sharedMesh.vertices = meshRendererPair.mesh.vertices;
}
//meshRendererPair.Destruct();
}
}
else
{
SkinnedMeshRenderer sRenderer = gameObject.GetComponent<SkinnedMeshRenderer>();
if (sRenderer != null)
{
Mesh origMesh = UnityEngine.Object.Instantiate(sRenderer.sharedMesh);
MeshRendererPair originalPair = new MeshRendererPair(false, origMesh);
originalMeshesClones.Add(gameObject, originalPair);
//sRenderer.sharedMesh.MakeSimilarToOtherMesh(meshRendererPair.mesh);
//sRenderer.sharedMesh.Clear();
//EditorUtility.CopySerialized(meshRendererPair.mesh, sRenderer.sharedMesh);
//Overwrites the mesh assets and keeps references intact
if (UtilityServices.OverwriteAssetWith(sRenderer.sharedMesh, meshRendererPair.mesh, true)) { }
else
{
sRenderer.sharedMesh.Clear();
EditorUtility.CopySerialized(meshRendererPair.mesh, sRenderer.sharedMesh);
sRenderer.sharedMesh.vertices = meshRendererPair.mesh.vertices;
}
//meshRendererPair.Destruct();
}
}
}
SaveRecord(lastOp.isReduceDeep, !isUndo, originalMeshesClones);
lastOp.objectMeshPairs = null;
lastOp = null;
operations.RemoveAt(operations.Count - 1);
EditorUtility.ClearProgressBar();
}
public void Destruct()
{
if (undoOperations != null && undoOperations.Count > 0)
{
foreach (var operation in undoOperations)
{
operation.Destruct();
}
}
if (redoOperations != null && redoOperations.Count > 0)
{
foreach (var operation in redoOperations)
{
operation.Destruct();
}
}
}
}
[System.Serializable]
public class LODLevelSettings
{
public float reductionStrength;
public float transitionHeight;
public bool preserveUVFoldover;
public bool preserveUVSeams;
public bool preserveBorders;
public bool useEdgeSort;
public bool recalculateNormals;
public float aggressiveness;
public int maxIterations;
public bool regardCurvature;
public bool regardTolerance;
public bool combineMeshes;
public bool simplificationOptionsFoldout;
public bool intensityFoldout;
public List<float> sphereIntensities;
public LODLevelSettings(float reductionStrength, float transitionHeight, bool preserveUVFoldover, bool preserveUVSeams, bool preserveBorders, bool smartLinking, bool recalculateNormals, float aggressiveness, int maxIterations, bool regardTolerance, bool regardCurvature, bool combineMeshes, List<float> preservationStrengths)
{
this.reductionStrength = reductionStrength;
this.transitionHeight = transitionHeight;
this.preserveUVFoldover = preserveUVFoldover;
this.preserveUVSeams = preserveUVSeams;
this.preserveBorders = preserveBorders;
this.useEdgeSort = smartLinking;
this.recalculateNormals = recalculateNormals;
this.aggressiveness = aggressiveness;
this.maxIterations = maxIterations;
this.regardTolerance = regardTolerance;
this.regardCurvature = regardCurvature;
this.combineMeshes = combineMeshes;
this.sphereIntensities = preservationStrengths;
}
}
[System.Serializable]
public class LODBackup
{
[SerializeField]
private Renderer[] originalRenderers = null;
[SerializeField]
public GameObject lodParentObject;
public Renderer[] OriginalRenderers
{
get { return originalRenderers; }
set { originalRenderers = value; }
}
}
public UndoRedoOps objectsHistory;
public ObjectMeshPair objectMeshPairs;
public List<LODLevelSettings> currentLodLevelSettings;
public List<ToleranceSphere> toleranceSpheres;
public LODBackup lodBackup;
#region BATCH FEW DATA
public TextureArrayGroup textureArraysSettings;
public List<MaterialProperties> materialsToRestore;
public ObjectMaterialLinks lastObjMaterialLinks; // BeforeSerialization
public bool relocateMaterialLinks;
public bool reInitializeTempMatProps;
public int choiceTextureMap = 0;
public int choiceDiffuseColorSpace = 0;
public readonly string[] textureMapsChoices = new[] { "Albedo", "Metallic", "Specular", "Normal", "Height", "Occlusion", "Emission", "Detail Mask", "Detail Albedo", "Detail Normal" };
//public readonly string[] compressionTypesChoices = new[] { "Uncompressed", "DXT1", "ETC2_RGB", "PVRTC_RGB4", "ASTC_RGB", "DXT1_CRUNCHED" };
public readonly string[] compressionTypesChoices = new[] { "Uncompressed", "DXT1", "ETC2_RGB", "PVRTC_RGB4", "ASTC_RGB"};
public readonly string[] resolutionsChoices = new[] { "32", "64", "128", "256", "512", "1024", "2048", "4096" };
public readonly string[] filteringModesChoices = new[] { "Point (no filter)", "Bilinear", "Trilinear" };
public readonly string[] compressionQualitiesChoices = new[] { "Low", "Medium", "High" };
public readonly string[] colorSpaceChoices = new[] { "Non_Linear", "Linear" };
public string batchFewSavePath = "";
#endregion BATCH FEW DATA
#region ALTER TEXTURE ARRAYS
public List<Texture2DArray> existingTextureArrays = new List<Texture2DArray>();
public bool existingTextureArraysFoldout;
public int existingTextureArraysSize;
public bool textureArraysPropsFoldout;
public TextureArrayUserSettings existingArraysProps;
public int choiceColorSpace = 0; //non linear
#endregion ALTER TEXTURE ARRAYS
#region INSPECTOR DRAWER VARS
public bool preserveBorders;
public bool preserveUVSeams;
public bool preserveUVFoldover;
public bool useEdgeSort = false;
public bool recalculateNormals;
public int maxIterations = 100;
public float aggressiveness = 7;
public bool regardCurvature = false;
public bool considerChildren;
public bool isPreservationActive;
public float sphereDiameter = 0.5f;
public Vector3 oldSphereScale;
public float reductionStrength;
public bool reductionPending;
public GameObject prevFeasibleTarget;
public bool runOnThreads;
public int triangleCount;
[SerializeField]
public UnityEngine.Object lastDrawer;
public bool foldoutAutoLOD;
public bool foldoutBatchFew;
public bool foldoutAutoLODMultiple;
public Vector3 objPositionPrevFrame;
public Vector3 objScalePrevFrame;
public bool considerChildrenBatchFew = true;
public string autoLODSavePath = "";
public bool foldoutAdditionalOpts;
public bool generateUV2LODs;
public bool copyParentStaticFlags;
public bool copyParentTag;
public bool copyParentLayer;
public bool createAsChildren;
public bool removeLODBackupComponent;
public bool generateUV2batchfew;
public bool removeMaterialLinksComponent;
public bool clearBlendshapesComplete;
public bool clearBlendshapesNormals;
public bool clearBlendshapesTangents;
public bool isPlainSkin = false;
#endregion INSPECTOR DRAWER VARS
}
}
#endif