/*
* public static void HideGizmos()
* {
* var Annotation = System.Type.GetType("UnityEditor.Annotation, UnityEditor");
* var ClassId = Annotation.GetField("classID");
* var ScriptClass = Annotation.GetField("scriptClass");
*
* System.Type AnnotationUtility = System.Type.GetType("UnityEditor.AnnotationUtility, UnityEditor");
* var GetAnnotations = AnnotationUtility.GetMethod("GetAnnotations", BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static);
* //var SetGizmoEnabled = AnnotationUtility.GetMethod("SetGizmoEnabled", BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static);
* var SetIconEnabled = AnnotationUtility.GetMethod("SetIconEnabled", BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static);
*
* System.Array annotations = (System.Array)GetAnnotations.Invoke(null, null);
* foreach (var a in annotations)
* {
* int classId = (int)ClassId.GetValue(a);
* string scriptClass = (string)ScriptClass.GetValue(a);
* if(string.IsNullOrEmpty(scriptClass)) continue;
*
* if(scriptClass == typeof(SVGAsset).Name ||
* scriptClass == typeof(SVGAtlas).Name ||
* scriptClass == typeof(SVGImage).Name ||
* scriptClass == typeof(SVGRenderer).Name ||
* scriptClass == typeof(SVGCollider2D).Name
* )
* {
* if(SetIconEnabled != null)
* SetIconEnabled.Invoke(null, new object[] { classId, scriptClass, 0 });
* }
* }
* }
*/
static void PlaymodeStateChanged()
{
SVGAtlas svgAtlas = Object.FindObjectOfType <SVGAtlas>();
if (svgAtlas != null)
{
svgAtlas.ClearAll();
}
/*
* SVGImage[] svgImages = Resources.FindObjectsOfTypeAll<SVGImage>();
* if(svgImages != null && svgImages.Length > 0)
* {
* for(int i = 0; i < svgImages.Length; i++)
* {
* if(svgImages[i] == null)
* continue;
* if(svgImages[i].vectorGraphics == null)
* continue;
* svgImages[i].vectorGraphics._editor_ClearCache();
* }
* }
*/
//visible = visible;
}
internal static void Init()
{
Camera[] cameras = SVGAtlas.GetAllCameras();
if (cameras != null && cameras.Length > 0)
{
for (int i = 0; i < cameras.Length; i++)
{
SVGAtlas.AddComponent <PrivateBetaBuild>(cameras[i]);
}
}
}
public static void ClearAll()
{
if (_Instance == null)
{
return;
}
if (_Instance.ui != null)
{
DestroyObjectInternal(_Instance.ui);
_Instance.ui = null;
}
if (_Instance.uiMask != null)
{
DestroyObjectInternal(_Instance.uiMask);
_Instance.uiMask = null;
}
if (_Instance.opaqueSolid != null)
{
DestroyObjectInternal(_Instance.opaqueSolid);
_Instance.opaqueSolid = null;
}
if (_Instance.transparentSolid != null)
{
DestroyObjectInternal(_Instance.transparentSolid);
_Instance.transparentSolid = null;
}
if (_Instance.opaqueGradient != null)
{
DestroyObjectInternal(_Instance.opaqueGradient);
_Instance.opaqueGradient = null;
}
if (_Instance.transparentGradient != null)
{
DestroyObjectInternal(_Instance.transparentGradient);
_Instance.transparentGradient = null;
}
_Instance.ClearAllData();
_Instance.ClearMaterials();
_Instance.ClearAtlasTextures();
DestroyObjectInternal(_Instance.gameObject);
_Instance = null;
}
public override void OnInspectorGUI()
{
base.OnInspectorGUI();
if (gradientTexture == null)
{
gradientTexture = new Texture2D(128, 16);
}
SVGAtlas atlas = target as SVGAtlas;
if (atlas.atlasData != null && atlas.atlasData.gradients != null)
{
// Debug.Log(atlas.atlasData);
/*
* for(int i = 0; i < atlas.atlasData.gradients.Length; i++)
* {
* //SVGAtlas.RenderGradient(gradientTexture, atlas.atlasData.gradients[i], 0, 0, gradientTexture.width, gradientTexture.height);
* //GUILayout.Box(gradientTexture);
* }
*/
}
}
public static void DoRenderPreview(SVGAsset targetObject, PreviewRenderUtility previewUtility)
{
if (targetObject == null)
{
return;
}
bool hasGradients = targetObject.hasGradients;
Mesh tempMesh = GetMesh(targetObject);
if (tempMesh == null)
{
return;
}
Material[] sharedMaterials = targetObject.sharedMaterials;
Material[] outputMaterials = sharedMaterials;
if (tempMesh == null || sharedMaterials == null || sharedMaterials.Length == 0)
{
return;
}
Texture2D gradientAtlas = null;
if (hasGradients)
{
gradientAtlas = SVGAtlas.GenerateGradientAtlasTexture(targetObject.sharedGradients, SVGAtlas.defaultGradientWidth, SVGAtlas.defaultGradientHeight);
outputMaterials = new Material[sharedMaterials.Length];
for (int i = 0; i < sharedMaterials.Length; i++)
{
if (sharedMaterials[i] == null)
{
continue;
}
outputMaterials[i] = Instantiate <Material>(sharedMaterials[i]);
if (outputMaterials[i].HasProperty("_Params"))
{
outputMaterials[i].SetVector("_Params", new Vector4(gradientAtlas.width, gradientAtlas.height, SVGAtlas.defaultGradientWidth, SVGAtlas.defaultGradientHeight));
}
if (outputMaterials[i].HasProperty("_GradientColor"))
{
outputMaterials[i].SetTexture("_GradientColor", gradientAtlas);
}
if (outputMaterials[i].HasProperty("_GradientShape"))
{
outputMaterials[i].SetTexture("_GradientShape", SVGAtlas.gradientShapeTexture);
}
}
}
RenderMeshPreviewSkipCameraAndLighting(tempMesh, previewUtility, outputMaterials);
if (hasGradients)
{
for (int i = 0; i < outputMaterials.Length; i++)
{
if (outputMaterials[i] == null)
{
continue;
}
DestroyImmediate(outputMaterials[i]);
}
}
if (gradientAtlas != null)
{
DestroyImmediate(gradientAtlas);
}
}
public void StartProcess(SVGAsset asset)
{
if (UnityEditor.EditorApplication.isPlayingOrWillChangePlaymode)
{
return;
}
if (errors == null)
{
errors = new List <SVGError>();
}
else
{
errors.Clear();
}
_importingSVG = true;
UnityEditor.SerializedObject svgAsset = new UnityEditor.SerializedObject(asset);
UnityEditor.SerializedProperty sharedMesh = svgAsset.FindProperty("_sharedMesh");
UnityEditor.SerializedProperty sharedShaders = svgAsset.FindProperty("_sharedShaders");
// clean up
SVGParser.Clear();
SVGParser.Init();
SVGGraphics.Clear();
SVGGraphics.Init();
SVGElement _rootSVGElement = null;
#if IGNORE_EXCEPTIONS
try {
#else
Debug.LogWarning("Exceptions are turned on!");
#endif
// Create new Asset
CreateEmptySVGDocument();
_rootSVGElement = this._svgDocument.rootElement;
#if IGNORE_EXCEPTIONS
} catch (System.Exception exception) {
_rootSVGElement = null;
errors.Add(SVGError.Syntax);
Debug.LogError("SVG Document Exception: " + exception.Message, asset);
}
#endif
if (_rootSVGElement == null)
{
Debug.LogError("SVG Document is corrupted! " + UnityEditor.AssetDatabase.GetAssetPath(asset), asset);
return;
}
SVGGraphics.depthTree = new SVGDepthTree(_rootSVGElement.paintable.viewport);
#if IGNORE_EXCEPTIONS
try {
#endif
_rootSVGElement.Render();
// Handle gradients
bool hasGradients = (useGradients == SVGUseGradients.Always);
SVGAtlas atlas = SVGAtlas.Instance;
if (useGradients != SVGUseGradients.Never)
{
atlas.hideFlags = HideFlags.DontSave;
if (SVGAtlas.Instance.gradients != null && atlas.gradients.Count > 1)
{
int gradientCount = atlas.gradients.Count;
int gradientWidth = atlas.gradientWidth;
int gradientHeight = atlas.gradientHeight;
atlas.atlasTextureWidth = gradientWidth * 2;
atlas.atlasTextureHeight = Mathf.CeilToInt((gradientCount * gradientWidth) / atlas.atlasTextureWidth) * gradientHeight + gradientHeight;
atlas.RebuildAtlas();
hasGradients = true;
}
}
// Create actual Mesh
Material[] outputMaterials;
Mesh mesh = SVGMesh.CreateMesh(out outputMaterials);
if (mesh == null)
{
return;
}
// Delete gradients if needed
if (!hasGradients)
{
mesh.uv = new Vector2[0];
mesh.uv2 = new Vector2[0];
}
Vector3[] vertices = mesh.vertices;
Vector2 offset;
Bounds bounds = mesh.bounds;
Rect viewport = _rootSVGElement.paintable.viewport;
viewport.x *= SVGMesh.meshScale;
viewport.y *= SVGMesh.meshScale;
viewport.size *= SVGMesh.meshScale;
if (asset.ignoreSVGCanvas)
{
offset = new Vector2(bounds.min.x + bounds.size.x * asset.pivotPoint.x,
bounds.min.y + bounds.size.y * asset.pivotPoint.y);
}
else
{
offset = new Vector2(viewport.min.x + viewport.size.x * asset.pivotPoint.x,
viewport.min.y + viewport.size.y * asset.pivotPoint.y);
}
// Apply pivot point and Flip Y Axis
for (int i = 0; i < vertices.Length; i++)
{
vertices[i].x = vertices[i].x - offset.x;
vertices[i].y = (vertices[i].y - offset.y) * -1f;
}
mesh.vertices = vertices;
mesh.RecalculateBounds();
sharedMesh.objectReferenceValue = AddObjectToAsset <Mesh>(mesh, asset, HideFlags.HideInHierarchy);
// Material sharedMaterial;
if (outputMaterials != null && outputMaterials.Length > 0)
{
sharedShaders.arraySize = outputMaterials.Length;
if (hasGradients)
{
for (int i = 0; i < outputMaterials.Length; i++)
{
sharedShaders.GetArrayElementAtIndex(i).stringValue = outputMaterials[i].shader.name;
}
}
else
{
for (int i = 0; i < outputMaterials.Length; i++)
{
if (outputMaterials[i].shader.name == SVGShader.GradientColorAlphaBlended.name)
{
outputMaterials[i].shader = SVGShader.SolidColorAlphaBlended;
}
else if (outputMaterials[i].shader.name == SVGShader.GradientColorOpaque.name)
{
outputMaterials[i].shader = SVGShader.SolidColorOpaque;
}
sharedShaders.GetArrayElementAtIndex(i).stringValue = outputMaterials[i].shader.name;
}
}
}
// Serialize the Asset
svgAsset.ApplyModifiedProperties();
// Handle Canvas Rectangle
System.Reflection.MethodInfo _editor_SetCanvasRectangle = typeof(SVGAsset).GetMethod("_editor_SetCanvasRectangle", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
_editor_SetCanvasRectangle.Invoke(asset, new object[] { new Rect(viewport.x, viewport.y, viewport.size.x, viewport.size.y) });
if (asset.generateCollider)
{
// Create polygon contour
if (SVGGraphics.paths != null && SVGGraphics.paths.Count > 0)
{
List <List <Vector2> > polygons = new List <List <Vector2> >();
for (int i = 0; i < SVGGraphics.paths.Count; i++)
{
Vector2[] points = SVGGraphics.paths[i].points;
for (int j = 0; j < points.Length; j++)
{
points[j].x = points[j].x * SVGMesh.meshScale - offset.x;
points[j].y = (points[j].y * SVGMesh.meshScale - offset.y) * -1f;
}
polygons.Add(new List <Vector2>(points));
}
polygons = SVGGeom.MergePolygon(polygons);
SVGPath[] paths = new SVGPath[polygons.Count];
for (int i = 0; i < polygons.Count; i++)
{
paths[i] = new SVGPath(polygons[i].ToArray());
}
System.Reflection.MethodInfo _editor_SetColliderShape = typeof(SVGAsset).GetMethod("_editor_SetColliderShape", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
if (paths != null && paths.Length > 0)
{
_editor_SetColliderShape.Invoke(asset, new object[] { paths });
}
else
{
_editor_SetColliderShape.Invoke(asset, new object[] { null });
}
}
}
else
{
System.Reflection.MethodInfo _editor_SetColliderShape = typeof(SVGAsset).GetMethod("_editor_SetColliderShape", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
_editor_SetColliderShape.Invoke(asset, new object[] { null });
}
if (hasGradients)
{
System.Reflection.MethodInfo _editor_SetGradients = typeof(SVGAsset).GetMethod("_editor_SetGradients", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
if (atlas.gradients != null && atlas.gradients.Count > 0)
{
_editor_SetGradients.Invoke(asset, new object[] { atlas.gradients.ToArray() });
}
else
{
_editor_SetGradients.Invoke(asset, new object[] { null });
}
}
#if IGNORE_EXCEPTIONS
} catch (System.Exception exception) {
Debug.LogWarning("Asset: " + UnityEditor.AssetDatabase.GetAssetPath(asset) + " Failed to import\n" + exception.Message, asset);
errors.Add(SVGError.CorruptedFile);
}
#endif
SVGAtlas.ClearAll();
SVGGraphics.Clear();
if (_svgDocument != null)
{
_svgDocument.Clear();
}
UnityEditor.EditorUtility.SetDirty(asset);
_importingSVG = false;
}
