public override GameObject CreateExternalObject(Sprite sprite, SpriteConfigData data)
{
GameObject prefab = sprite.CreateEmptyMeshPrefab(false);
sprite.GetVertexAndTriangle3D(data, out var vertices, out var triangles, MeshRenderType.Opaque);
sprite.AddComponentsAssets(vertices, triangles, prefab, RENDER_TYPE_OPAQUE, data.opaqueShaderName);
return(prefab);
}
private void Revert()
{
_configData = SpriteConfigData.GetData(_originalUserData);
_meshCreator = MeshCreatorBase.GetInstnace(_configData);
_preview.SetWireframes(_meshCreator.GetMeshWireframes());
_importData.textureImporter.userData = _originalUserData;
_isDataChanged = false;
}
public override GameObject CreateExternalObject(Sprite sprite, SpriteConfigData data)
{
GameObject prefab = sprite.CreateEmptyMeshPrefab(false);
sprite.GetMeshData(data, out var vertices, out var triangles, MeshRenderType.Transparent);
sprite.AddComponentsAssets(vertices, triangles, prefab, RENDER_TYPE_TRANSPARENT, data.transparentShader);
return(prefab);
}
public override GameObject CreateExternalObject(Sprite sprite, SpriteConfigData data)
{
GameObject prefab = sprite.CreateEmptyMeshPrefab(false);
Vector3[] vertices3D = Array.ConvertAll(sprite.vertices, i => new Vector3(i.x, i.y, 0));
int[] triangles3D = Array.ConvertAll(sprite.triangles, i => (int)i);
sprite.AddComponentsAssets(vertices3D, triangles3D, prefab, RENDER_TYPE_TRANSPARENT, data.transparentShaderName);
return(prefab);
}
public override GameObject CreateExternalObject(Sprite sprite, SpriteConfigData data)
{
GameObject prefab = sprite.CreateEmptyMeshPrefab(false);
Vector2[] vertices = sprite.vertices;
ushort[] triangles = sprite.triangles;
sprite.AddComponentsAssets(vertices, triangles, prefab, RENDER_TYPE_TRANSPARENT, data.transparentShader);
return(prefab);
}
public static void GetMeshData(this Sprite sprite, SpriteConfigData data, out Vector2[] vertices, out ushort[] triangles, MeshRenderType meshRenderType)
{
if (!TryGetMeshData(sprite, data, out vertices, out triangles, meshRenderType))
{
//fallback
vertices = sprite.vertices;
triangles = sprite.triangles;
}
}
public static void GetVertexAndTriangle2D(this Sprite sprite, SpriteConfigData configData, out Vector2[] vertices2D, out ushort[] triangles2D, MeshRenderType meshRenderType)
{
if (!TryGetVertexAndTriangle2D(sprite, configData, out vertices2D, out triangles2D, meshRenderType))
{
//fallback
vertices2D = sprite.vertices;
triangles2D = sprite.triangles;
}
}
public SpriteProcessor(Sprite sprite, string assetPath)
{
_importData = new SpriteImportData(sprite, assetPath);
_originalUserData = _importData.textureImporter.userData;
_configData = SpriteConfigData.GetData(_originalUserData);
_meshCreator = MeshCreatorBase.GetInstnace(_configData);
_preview = new SpritePreview(_meshCreator.GetMeshWireframes());
Undo.undoRedoPerformed += UndoReimport;
}
public override GameObject CreateExternalObject(Sprite sprite, SpriteConfigData data)
{
GameObject root = sprite.CreateEmptyMeshPrefab(true);
GameObject sub = root.transform.GetChild(0).gameObject;
sprite.GetMeshData(data, out var transparentVertices, out var transparentTriangles, MeshRenderType.SeparatedTransparent);
sprite.GetMeshData(data, out var opaqueVertices, out var opaqueTriangles, MeshRenderType.Opaque);
sprite.AddComponentsAssets(transparentVertices, transparentTriangles, root, RENDER_TYPE_TRANSPARENT, data.transparentShader);
sprite.AddComponentsAssets(opaqueVertices, opaqueTriangles, sub, RENDER_TYPE_OPAQUE, data.opaqueShader);
return(root);
}
private void UndoReimport()
{
_configData = SpriteConfigData.GetData(_importData.textureImporter.userData);
_isDataChanged = true;
foreach (var t in _targets)
{
AssetDatabase.ImportAsset(AssetDatabase.GetAssetPath(t),
ImportAssetOptions.ForceUpdate |
ImportAssetOptions.DontDownloadFromCacheServer);
}
}
private void UpdateAndResize(Rect rect, Sprite sprite, SpriteConfigData data)
{
_rect = rect;
_sprite = sprite;
_infoText = "";
foreach (var wireframe in _wireframes)
{
wireframe.UpdateAndResize(_rect, _sprite, data);
_infoText += wireframe.GetInfo(_sprite) + "\n";
}
}
private static Vector2[][] GenerateSeparatedTransparent(Sprite sprite, SpriteConfigData data)
{
Vector2[][] transparentPaths = GenerateTransparentOutline(sprite, data.transparentDetail, data.transparentAlphaTolerance, data.detectHoles);
Vector2[][] opaquePaths = GenerateOpaqueOutline(sprite, data.opaqueDetail, data.opaqueAlphaTolerance);
List <List <IntPoint> > convertedTransparentPaths = ConvertToIntPointList(transparentPaths);
List <List <IntPoint> > convertedOpaquePaths = ConvertToIntPointList(opaquePaths);
List <List <IntPoint> > intersectionPaths = new List <List <IntPoint> >();
Clipper clipper = new Clipper();
clipper.AddPaths(convertedTransparentPaths, PolyType.ptSubject, true);
clipper.AddPaths(convertedOpaquePaths, PolyType.ptClip, true);
clipper.Execute(ClipType.ctDifference, intersectionPaths, PolyFillType.pftEvenOdd, PolyFillType.pftEvenOdd);
return(ConvertToVector2Array(intersectionPaths));
}
public static Vector2[][] GenerateOutline(Sprite sprite, SpriteConfigData data, MeshRenderType meshRenderType)
{
switch (meshRenderType)
{
case MeshRenderType.Transparent:
return(GenerateTransparentOutline(sprite, data.transparentDetail, data.transparentAlphaTolerance, data.detectHoles));
case MeshRenderType.Opaque:
return(GenerateOpaqueOutline(sprite, data.opaqueDetail, data.opaqueAlphaTolerance));
case MeshRenderType.SeparatedTransparent:
return(GenerateSeparatedTransparent(sprite, data));
default:
return(Array.Empty <Vector2[]>());
}
}
public static void GetVertexAndTriangle3D(this Sprite sprite, SpriteConfigData configData, out Vector3[] vertices3D, out int[] triangles3D, MeshRenderType meshRenderType)
{
if (!TryGetVertexAndTriangle2D(sprite, configData, out var vertices2D, out var triangles2D, meshRenderType))
{
//fallback
vertices2D = sprite.vertices;
triangles2D = sprite.triangles;
}
vertices3D = Array.ConvertAll(vertices2D, i => new Vector3(i.x, i.y, 0));
triangles3D = Array.ConvertAll(triangles2D, i => (int)i);
if (configData.thickness > 0)
{
TriangulationUtil.ExpandMeshThickness(ref vertices3D, ref triangles3D, configData.thickness);
}
}
private void OnPostprocessSprites(Texture2D texture, Sprite[] sprites)
{
TextureImporter textureImporter = assetImporter as TextureImporter;
TextureImporterSettings textureImporterSettings = new TextureImporterSettings();
textureImporter.ReadTextureSettings(textureImporterSettings);
SpriteConfigData configData = SpriteConfigData.GetData(textureImporter.userData);
if (textureImporterSettings.spriteMeshType != SpriteMeshType.Tight || !configData.overriden)
{
return;
}
MeshCreatorBase creator = MeshCreatorBase.GetInstnace(configData);
foreach (var sprite in sprites)
{
creator.OverrideGeometry(sprite, configData);
}
}
public static SpriteConfigData GetData(string jsonData)
{
SpriteConfigData data = null;
try
{
data = JsonUtility.FromJson <SpriteConfigData>(jsonData);
}
catch (Exception e)
{
Debug.LogWarning(e);
}
if (data == null)
{
data = new SpriteConfigData();
}
return(data);
}
private void UndoReimport()
{
_configData = SpriteConfigData.GetData(_mainImportData.textureImporter.userData);
_isDataChanged = true;
if (_targets == null)
{
return;
}
foreach (var t in _targets)
{
string path = AssetDatabase.GetAssetPath(t);
if (!string.IsNullOrEmpty(path))
{
AssetDatabase.ImportAsset(path, ImportAssetOptions.ForceUpdate | ImportAssetOptions.DontDownloadFromCacheServer);
}
}
}
private static bool TryGetMeshData(Sprite sprite, SpriteConfigData data, out Vector2[] vertices, out ushort[] triangles, MeshRenderType meshRenderType)
{
vertices = Array.Empty <Vector2>();
triangles = Array.Empty <ushort>();
if (data == null || !data.overriden)
{
return(false);
}
Vector2[][] paths = OutlineUtil.GenerateOutline(sprite, data, meshRenderType);
TriangulationUtil.Triangulate(paths, data.edgeSmoothing, data.useNonZero, out vertices, out triangles);
//validate
if (vertices.Length >= ushort.MaxValue)
{
Debug.LogErrorFormat($"Too many veretics! Sprite '{sprite.name}' has {vertices.Length} vertices.");
return(false);
}
return(true);
}
public static bool TryGetVertexAndTriangle2D(this Sprite sprite, SpriteConfigData configData, out Vector2[] vertices, out ushort[] triangles, MeshRenderType meshRenderType)
{
vertices = Array.Empty <Vector2>();
triangles = Array.Empty <ushort>();
if (configData == null || sprite == null ||
configData.mode == SpriteConfigData.Mode.UnityDefaultForTransparent ||
configData.mode == SpriteConfigData.Mode.UnityDefaultForOpaque)
{
return(false);
}
Vector2[][] paths = OutlineUtil.GenerateOutline(sprite, configData, meshRenderType);
if (meshRenderType == MeshRenderType.Grid)
{
vertices = paths[0];
triangles = new ushort[vertices.Length];
for (var i = 0; i < triangles.Length; i++)
{
triangles[i] = (ushort)i;
}
}
else
{
TriangulationUtil.Triangulate(paths, configData.edgeSmoothing, configData.useNonZero, out vertices, out triangles);
}
//validate
if (vertices.Length >= ushort.MaxValue)
{
Debug.LogErrorFormat($"Too many vertices! Sprite '{sprite.name}' has {vertices.Length} vertices.");
return(false);
}
return(true);
}
public void Update(Rect rect, Sprite baseSprite, Sprite dummySprite, TextureInfo textureInfo, SpriteConfigData configData)
{
Rect = rect;
_textureInfo = textureInfo;
_infoText = "";
foreach (var wireframe in _wireframes)
{
wireframe.UpdateAndResize(this.Rect, baseSprite, dummySprite, _textureInfo, configData);
_infoText += wireframe.GetInfo(textureInfo) + "\n";
}
}
public void UpdateAndResize(Rect rect, Sprite sprite, SpriteConfigData data)
{
sprite.GetMeshData(data, out _vertices, out _triangles, _meshRenderType);
Resize(rect, sprite);
}
public abstract void UpdateExternalObject(GameObject externalObject, Sprite baseSprite, Sprite dummySprite, TextureInfo textureInfo, SpriteConfigData data);
public abstract GameObject CreateExternalObject(Sprite sprite, TextureInfo textureInfo, SpriteConfigData data, string oldPrefabPath = null);
public abstract void OverrideGeometry(Sprite baseSprite, Sprite dummySprite, TextureInfo textureInfo, SpriteConfigData configData);
public void Show(Rect rect, Sprite sprite, SpriteConfigData configData, bool hasMultipleTargets)
{
UpdateAndResize(rect, sprite, configData);
Draw(hasMultipleTargets);
}
public override void OverrideGeometry(Sprite sprite, SpriteConfigData data)
{
sprite.GetMeshData(data, out var vertices, out var triangles, MeshRenderType.Transparent);
sprite.SetSpriteScaleToVertices(vertices, 1, false, false);
sprite.OverrideGeometry(vertices, triangles);
}
public static MeshCreatorBase GetInstnace(SpriteConfigData configData)
{
return(configData.overriden ? _creator[configData.mode] : _defaultCreator);
}
public static void AddComponentsAssets(Sprite sprite, GameObject prefab, Vector3[] v, int[] t, TextureInfo textureInfo, string renderType, string shaderName, SpriteConfigData spriteConfigData)
{
prefab.layer = spriteConfigData.overrideSortingLayer ? spriteConfigData.layer : SpriteAssistSettings.Settings.defaultLayer;
string tag = spriteConfigData.overrideTag ? spriteConfigData.tag : SpriteAssistSettings.Settings.defaultTag;
if (string.IsNullOrEmpty(tag))
{
prefab.tag = SpriteAssistSettings.DEFAULT_TAG;
}
//add components
MeshFilter meshFilter = prefab.GetComponent <MeshFilter>();
MeshRenderer meshRenderer = prefab.GetComponent <MeshRenderer>();
if (meshFilter == null)
{
meshFilter = prefab.AddComponent <MeshFilter>();
}
if (meshRenderer == null)
{
meshRenderer = prefab.AddComponent <MeshRenderer>();
}
if (spriteConfigData.overrideSortingLayer)
{
meshRenderer.sortingLayerID = spriteConfigData.sortingLayerId;
meshRenderer.sortingOrder = spriteConfigData.sortingOrder;
}
else
{
meshRenderer.sortingLayerID = SpriteAssistSettings.Settings.defaultSortingLayerId;
meshRenderer.sortingOrder = SpriteAssistSettings.Settings.defaultSortingOrder;
}
//create new mesh
Mesh mesh = new Mesh()
{
name = renderType,
};
mesh.Update(v, t, textureInfo);
meshFilter.mesh = mesh;
//create new material
Material material = new Material(Shader.Find(shaderName));
material.name = renderType;
material.mainTexture = sprite.texture;
meshRenderer.sharedMaterial = material;
//set assets as sub-asset
AssetDatabase.AddObjectToAsset(material, prefab);
AssetDatabase.AddObjectToAsset(mesh, prefab);
//AssetDatabase.SaveAssets();
}
public abstract void OverrideGeometry(Sprite sprite, SpriteConfigData configData);
public abstract GameObject CreateExternalObject(Sprite sprite, SpriteConfigData data);
