public static void BuildCollection(tmTextureCollection collection)
{
if (collection != null)
{
collection.textureDefenitions.RemoveAll(f => !collection.Textures.Contains(f.texture));
foreach (Texture2D texture in collection.Textures)
{
if (texture != null)
{
tmTextureDefenition textureRef = collection.textureDefenitions.Find(f => f.texture == texture);
if (textureRef == null)
{
textureRef = new tmTextureDefenition();
textureRef.texture = texture;
textureRef.textureName = tmUtility.PlatformlessPath(texture.name); // should attach to name ? or guid better
textureRef.textureGuid = tmEditorUtility.AssetToGUID(texture);
textureRef.assetGuid = tmEditorUtility.AssetToGUID(texture);
collection.textureDefenitions.Add(textureRef);
}
}
}
EditorUtility.SetDirty(collection);
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
BuildPlatformCollections(collection);
collection = tmEditorUtility.GUIDToAsset(collection.assetGuid, typeof(tmTextureCollection)) as tmTextureCollection;
tmIndex.Instance.RegisterCollection(collection);
}
}
public static void UpdatePlatformCollection(tmTextureCollectionPlatform collectionPlatform, List <Texture2D> originalTextures)
{
collectionPlatform.Textures.Clear();
collectionPlatform.textureDefenitions.RemoveAll(def => !originalTextures.Contains(def.texture));
foreach (var texture in originalTextures)
{
if (texture != null)
{
tmTextureDefenition textureRef = collectionPlatform.textureDefenitions.Find(f => f.texture == texture);
if (textureRef == null)
{
textureRef = new tmTextureDefenition();
textureRef.texture = texture;
textureRef.textureName = tmUtility.PlatformlessPath(texture.name);
textureRef.textureGuid = tmEditorUtility.AssetToGUID(texture);
textureRef.assetGuid = tmEditorUtility.AssetToGUID(texture);
collectionPlatform.textureDefenitions.Add(textureRef);
}
string originalPath = AssetDatabase.GetAssetPath(texture);
ConfigureSpriteTextureImporter(originalPath);
bool rebuild = false;
ulong originalTimestamp = tmEditorUtility.Hash(texture);
rebuild |= (originalTimestamp != textureRef.originalTimestamp);
if (textureRef.platformTexture != null)
{
ulong platformTimestamp = tmEditorUtility.Hash(textureRef.platformTexture);
rebuild |= (platformTimestamp != textureRef.platformTimestamp);
}
Texture2D asset = PlatformSpecifiedTexture(textureRef.texture, collectionPlatform.platform, rebuild);
if (asset != null)
{
string platformTexturePath = AssetDatabase.GetAssetPath(asset);
ConfigureSpriteTextureImporter(platformTexturePath);
textureRef.platformTexture = asset;
textureRef.textureName = tmUtility.PlatformlessPath(textureRef.platformTexture.name);
textureRef.assetGuid = tmEditorUtility.AssetToGUID(textureRef.platformTexture);
textureRef.platformTimestamp = tmEditorUtility.Hash(textureRef.platformTexture);
textureRef.originalTimestamp = originalTimestamp;
}
}
}
collectionPlatform.textureDefenitions.Sort((a, b) => (string.Compare(a.textureName, b.textureName, System.StringComparison.OrdinalIgnoreCase)));
EditorUtility.SetDirty(collectionPlatform);
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
tmCollectionBuilder.BuildAtlas(collectionPlatform);
CreatePlatformResourceLink(collectionPlatform);
collectionPlatform = tmEditorUtility.GUIDToAsset(collectionPlatform.assetGuid, typeof(tmTextureCollectionPlatform)) as tmTextureCollectionPlatform;
tmIndex.Instance.RegisterPlatformCollection(collectionPlatform);
}
public void RemapUV(ref Mesh mesh, tmTextureDefenition mainTextureDefenition, tmTextureDefenition lightmapTextureDefenition)
{
if (!tmSettings.Instance.rebuildMesh)
{
return;
}
//============================ recalculate uv ============================
Vector2[] oldUVs = mesh.uv;
if (oldUVs != null && oldUVs.Length > 0)
{
Vector2 oldUV, newUV;
Rect uvRect = mainTextureDefenition.uv;
Rect offset = mainTextureDefenition.offset;
uvRect.center += offset.center;
uvRect.size += offset.size;
int vertexCount = oldUVs.Length;
for (int i = 0; i < vertexCount; i++)
{
oldUV = oldUVs[i];
newUV = new Vector2(
uvRect.x + uvRect.width * oldUV.x,
uvRect.y + uvRect.height * oldUV.y
);
oldUVs[i] = newUV;
}
mesh.uv = oldUVs;
}
//==========================recalculate uv2===============================
if (lightmapTextureDefenition != null)
{
Vector2[] oldUVs2 = mesh.uv2;
if (oldUVs2 != null && oldUVs2.Length > 0)
{
Rect uvRect = lightmapTextureDefenition.uv;
Rect offset = lightmapTextureDefenition.offset;
uvRect.center += offset.center;
uvRect.size += offset.size;
int vertexCount = oldUVs2.Length;
for (int i = 0; i < vertexCount; i++)
{
Vector2 oldUV2 = oldUVs2[i];
Vector2 newUV2 = new Vector2(
uvRect.x + uvRect.width * oldUV2.x,
uvRect.y + uvRect.height * oldUV2.y
);
oldUVs2[i] = newUV2;
}
mesh.uv2 = oldUVs2;
}
}
}
static bool TexturePopup(string label, tmTextureCollectionBase collection, ref string texureID)
{
int entryIndex = 0;
List <string> texureNames = new List <string>();
texureNames.Add("-");
if (collection != null)
{
for (int i = 0; i < collection.textureDefenitions.Count; i++)
{
tmTextureDefenition def = collection.textureDefenitions[i];
texureNames.Add(def.textureName);
if (def.textureGuid.Equals(texureID))
{
entryIndex = i + 1;
}
}
}
int lastIndex = entryIndex;
entryIndex = EditorGUILayout.Popup(label, entryIndex, texureNames.ToArray());
EditorGUILayout.BeginHorizontal();
EditorGUILayout.PrefixLabel(" ");
Rect rect = EditorGUILayout.GetControlRect(GUILayout.Width(100), GUILayout.Height(100));
EditorGUI.DrawRect(rect, Color.black);
if (entryIndex != -1)
{
if (entryIndex == 0)
{
texureID = "";
}
else
{
tmTextureDefenition def = collection.textureDefenitions[entryIndex - 1];
EditorGUI.DrawTextureTransparent(rect, def.texture, ScaleMode.ScaleToFit, def.texture == null ? 1f : (def.texture.width * 1f / def.texture.height));
texureID = def.textureGuid;
if (rect.Contains(Event.current.mousePosition))
{
if (Event.current.clickCount == 1)
{
if (def.texture)
{
EditorGUIUtility.PingObject(def.texture);
}
Event.current.Use();
}
}
}
}
EditorGUILayout.EndHorizontal();
return(lastIndex != entryIndex);
}
public tmTextureDefenition Copy()
{
tmTextureDefenition tr = new tmTextureDefenition();
#if UNITY_EDITOR
tr.texture = texture;
tr.platformTexture = platformTexture;
#endif
tr.textureName = textureName;
tr.textureGuid = textureGuid;
tr.assetGuid = assetGuid;
tr.originalTimestamp = originalTimestamp;
tr.platformTimestamp = platformTimestamp;
tr.offset = offset;
return(tr);
}
protected virtual void BuildMesh()
{
if (Mesh != null && !string.IsNullOrEmpty(MainTextureID) && MainTexCollection != null)
{
tmTextureDefenition mainTextureDefenition = MainTextureDefenition;
if (mainTextureDefenition != null)
{
tmTextureDefenition lightmapTextureDefenition = LightmapTextureDefenition;
if ((ModifiedFlag & (ModifiedFlags.ModifiedMesh | ModifiedFlags.ModifiedUV1 | ModifiedFlags.ModifiedUV2)) != 0)
{
tmManager.Instance.MeshInstance(Mesh, out sharedMesh, mainTextureDefenition, lightmapTextureDefenition, false);
RenderSharedMesh = sharedMesh;
}
}
}
ModifiedFlag &= ~(ModifiedFlags.ModifiedMesh | ModifiedFlags.ModifiedUV1 | ModifiedFlags.ModifiedUV2);
}
public override void OnInspectorGUI()
{
// EyeDropper.GetPickedColor();
// System.Type eyeDropperType = GetType("EyeDropper");
// MethodInfo mi = eyeDropperType.GetMethod("GetPickedColor", BindingFlags.Public | BindingFlags.Static | BindingFlags.DeclaredOnly);
// FieldInfo fi = eyeDropperType.GetField("s_PickCoordinates", BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.DeclaredOnly);
// Vector2 a = GUIUtility.GUIToScreenPoint(Event.current.mousePosition);
// fi.SetValue(null, a);
// Debug.Log(fi);
// Debug.Log(mi);
// Color c = (Color)mi.Invoke(null, null);
//
//
// EditorGUILayout.ColorField(Color.white);
// Debug.Log(
// "r:" + ((int)(c.r * 256)) +
// " g:" + ((int)(c.g * 256)) +
// " b:" + ((int)(c.b * 256)) +
// " a:" + ((int)(c.a * 256))
// );
baseEditor.OnInspectorGUI();
GUILayout.Space(20);
TextureImporter textureImporter = (TextureImporter)target;
tmTextureCollectionIndex currentCollectionIndex = tmIndex.Instance.CollectionIndexForTexturePath(textureImporter.assetPath);
string[] names = new string[tmIndex.Instance.TextureCollections.Count];
int index = -1;
for (int i = 0; i < tmIndex.Instance.TextureCollections.Count; i++)
{
tmTextureCollectionIndex collectionIndex = tmIndex.Instance.TextureCollections[i];
names[i] = collectionIndex.name;
if (collectionIndex.Equals(currentCollectionIndex))
{
index = i;
}
}
if (newIndex < -1)
{
newIndex = index;
}
newIndex = EditorGUILayout.Popup("Texture Atlas", newIndex, names);
if (newIndex > 0)
{
tmTextureCollectionIndex collectionIndex = tmIndex.Instance.TextureCollections[newIndex];
string collectionGUID = collectionIndex.textureCollectionGUID;
string collectionGuidPath = tmUtility.PathForPlatform(collectionGUID, tmSettings.Instance.CurrentPlatform);
tmResourceCollectionLink link = tmUtility.ResourceLinkByGUID(collectionGuidPath);
tmTextureCollectionPlatform collection = link.collectionInEditor;
collection.LoadTexture();
Texture2D atlas = collection.Atlas;
EditorGUILayout.BeginHorizontal();
EditorGUILayout.PrefixLabel(" ");
Rect rect = EditorGUILayout.GetControlRect(GUILayout.Width(150f * atlas.width / atlas.height), GUILayout.Height(150f));
EditorGUI.DrawRect(rect, Color.black);
EditorGUI.DrawTextureTransparent(rect, atlas, ScaleMode.ScaleToFit);
EditorGUILayout.EndHorizontal();
Object asset = tmEditorUtility.GUIDToAsset(collection.AtlasAssetGUID, typeof(Object));
if (rect.Contains(Event.current.mousePosition))
{
if (Event.current.clickCount == 1)
{
if (asset)
{
EditorGUIUtility.PingObject(asset);
}
Event.current.Use();
}
}
}
GUILayout.BeginHorizontal();
{
if (currentCollectionIndex != null)
{
EditorGUILayout.PrefixLabel(" ");
if (GUILayout.Button("Remove from atlas"))
{
newIndex = -1;
}
}
GUILayout.FlexibleSpace();
bool enabled = GUI.enabled;
GUI.enabled = index != newIndex;
if (GUILayout.Button("Revert"))
{
newIndex = -2;
}
if (GUILayout.Button("Apply"))
{
if (currentCollectionIndex != null)
{
tmTextureCollection collection = tmEditorUtility.GUIDToAsset(currentCollectionIndex.assetGUID, typeof(tmTextureCollection)) as tmTextureCollection;
Debug.Log(collection);
if (collection)
{
tmTextureDefenition def = collection.GetTextureDefenitionByID(AssetDatabase.AssetPathToGUID(textureImporter.assetPath));
if (def != null)
{
Debug.Log(def.texture);
collection.textureDefenitions.Remove(def);
collection.Textures.Remove(def.texture);
EditorUtility.SetDirty(collection);
tmCollectionBuilder.BuildCollection(collection);
}
}
}
if (newIndex > 0)
{
tmTextureCollectionIndex newCollectionIndex = tmIndex.Instance.TextureCollections[newIndex];
tmTextureCollection collection = tmEditorUtility.GUIDToAsset(newCollectionIndex.assetGUID, typeof(tmTextureCollection)) as tmTextureCollection;
collection.Textures.Add(AssetDatabase.LoadAssetAtPath(textureImporter.assetPath, typeof(Texture2D)) as Texture2D);
EditorUtility.SetDirty(collection);
tmCollectionBuilder.BuildCollection(collection);
}
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
}
GUI.enabled = enabled;
}
GUILayout.EndHorizontal();
GUILayout.FlexibleSpace();
GUILayout.Label("Description");
GUILayout.BeginHorizontal("Box");
{
textureImporter.userData = GUILayout.TextField(textureImporter.userData, GUI.skin.label);
}
GUILayout.EndHorizontal();
// EditorGUILayout.LabelField("test label");
}
public void MeshInstance(Mesh original, out Mesh sharedMesh, tmTextureDefenition mainTextureDef, tmTextureDefenition lightmapTextureDef, bool makeNoLongerReadable)
{
string key =
"mesh" +
original.GetHashCode() +
(mainTextureDef != null ? mainTextureDef.textureGuid : "") +
(lightmapTextureDef != null ? lightmapTextureDef.textureGuid : "");
string keys =
"" +
(mainTextureDef != null ? mainTextureDef.textureName : "") +
(lightmapTextureDef != null ? lightmapTextureDef.textureName : "");
sharedMesh = null;
WeakReference meshRef = null;
int originalMeshID = original.GetInstanceID();
if (meshMap.TryGetValue(key, out meshRef))
{
if (meshRef.IsAlive && !meshRef.Target.IsNull())
{
sharedMesh = meshRef.Target as Mesh;
}
else
{
meshMap.Remove(key);
destroyedMeshes.Remove(originalMeshID);
}
}
if (sharedMesh == null)
{
if (Application.isPlaying && destroyedMeshes.ContainsKey(originalMeshID))
{
CustomDebug.LogError("duplicate : " + original.name + " " + keys + " vs " + destroyedMeshes[originalMeshID]);
}
if (!original.isReadable)
{
CustomDebug.LogError("NOT READABLE = " + original.name);
}
sharedMesh =
#if UNITY_EDITOR
Instantiate(original) as Mesh;
#else
keepImMemoryMeshes.Contains(original) ? (Instantiate(original) as Mesh) : original;
#endif
#if UNITY_EDITOR
sharedMesh.hideFlags = HideFlags.HideAndDontSave;
#endif
sharedMesh.name = original.name + "_" + mainTextureDef.textureName;
meshRef = new WeakReference(sharedMesh);
meshMap.Add(key, meshRef);
if (!keepImMemoryMeshes.Contains(original))
{
if (!destroyedMeshes.ContainsKey(originalMeshID))
{
destroyedMeshes.Add(originalMeshID, keys);
}
}
RemapUV(ref sharedMesh, mainTextureDef, lightmapTextureDef);
if (makeNoLongerReadable)
{
sharedMesh.UploadMeshData(true);
}
}
}
