private void OnSelectionChange()
{
string selectionAssetPath = this.GetSelectionAssetPath();
AssetImporter atPath = AssetImporter.GetAtPath(selectionAssetPath);
ISpriteEditorDataProvider spriteEditorDataProvider = atPath as ISpriteEditorDataProvider;
if (spriteEditorDataProvider == null || this.selectedProviderChanged)
{
this.HandleApplyRevertDialog(SpriteEditorWindow.SpriteEditorWindowStyles.applyRevertDialogTitle.text, string.Format(SpriteEditorWindow.SpriteEditorWindowStyles.applyRevertDialogContent.text, this.m_SelectedAssetPath));
this.ResetWindow();
this.RefreshPropertiesCache();
this.RefreshRects();
}
if (this.m_RectsCache != null)
{
if (Selection.activeObject is Sprite)
{
this.UpdateSelectedSpriteRect(Selection.activeObject as Sprite);
}
else if (Selection.activeGameObject != null && Selection.activeGameObject.GetComponent <SpriteRenderer>())
{
Sprite sprite = Selection.activeGameObject.GetComponent <SpriteRenderer>().sprite;
this.UpdateSelectedSpriteRect(sprite);
}
}
this.UpdateAvailableModules();
base.Repaint();
}
public void OverwriteMesh()
{
ISpriteEditorDataProvider mainSpriteDataProvider = AssetImporter.GetAtPath(AssetDatabase.GetAssetPath(mainSprite)) as ISpriteEditorDataProvider;
mainSpriteDataProvider.InitSpriteEditorDataProvider();
ISpriteMeshDataProvider meshDataProvider = mainSpriteDataProvider.GetDataProvider <ISpriteMeshDataProvider>();
for (int i = 0; i < spritesToOverwrite.Length; i++)
{
ISpriteEditorDataProvider spriteDataProvider = AssetImporter.GetAtPath(AssetDatabase.GetAssetPath(spritesToOverwrite[i])) as ISpriteEditorDataProvider;
spriteDataProvider.InitSpriteEditorDataProvider();
ISpriteMeshDataProvider meshDataToOverwrite = spriteDataProvider.GetDataProvider <ISpriteMeshDataProvider>();
GUID toOver = spritesToOverwrite[i].GetSpriteID();
GUID mainGuid = mainSprite.GetSpriteID();
meshDataToOverwrite.SetEdges(toOver, meshDataProvider.GetEdges(mainGuid));
meshDataToOverwrite.SetIndices(toOver, meshDataProvider.GetIndices(mainGuid));
meshDataToOverwrite.SetVertices(toOver, meshDataProvider.GetVertices(mainGuid));
spriteDataProvider.Apply();
//force SetBindPose
AssetDatabase.ImportAsset(AssetDatabase.GetAssetPath(spritesToOverwrite[i]));
}
Debug.Log("Mesh overwritten");
}
static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAssets, string[] movedAssets, string[] movedFromAssetPaths)
{
m_AssetList = new List <object>();
List <string> assetPathModified = new List <string>();
foreach (var importedAsset in importedAssets)
{
ISpriteEditorDataProvider ai = InternalEditorBridge.GetISpriteEditorDataProviderFromPath(importedAsset);
if (ai != null)
{
ai.InitSpriteEditorDataProvider();
var assets = AssetDatabase.LoadAllAssetsAtPath(importedAsset);
var sprites = assets.OfType <Sprite>().ToArray <Sprite>();
bool dataChanged = false;
dataChanged = PostProcessBoneData(ai, sprites);
dataChanged |= PostProcessSpriteMeshData(ai, sprites);
if (dataChanged)
{
assetPathModified.Add(importedAsset);
m_AssetList.AddRange(assets);
}
}
}
if (assetPathModified.Count > 0 && m_AssetList.Count > 0)
{
var originalValue = EditorPrefs.GetBool("VerifySavingAssets", false);
EditorPrefs.SetBool("VerifySavingAssets", false);
AssetDatabase.ForceReserializeAssets(assetPathModified, ForceReserializeAssetsOptions.ReserializeMetadata);
EditorPrefs.SetBool("VerifySavingAssets", originalValue);
m_AssetList.Clear();
}
}
internal bool ContainsAllType(ISpriteEditorDataProvider provider)
{
return(provider == null ? false : m_Types.Where(x =>
{
return provider.HasDataProvider(x);
}).Count() == m_Types.Length);
}
static internal void ApplyChanges(SkinningCache skinningCache, ISpriteEditorDataProvider dataProvider)
{
skinningCache.applyingChanges = true;
skinningCache.RestoreBindPose();
ApplyBone(skinningCache, dataProvider);
ApplyMesh(skinningCache, dataProvider);
ApplyCharacter(skinningCache, dataProvider);
skinningCache.applyingChanges = false;
}
public void OnEnable()
{
m_DataProvider = GetSpriteEditorDataProvider();
m_DataProvider.InitSpriteEditorDataProvider();
m_SkinningModule = new SkinningModule();
m_SkinningModule.GetType()
.GetProperty("spriteEditor", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public)
.SetValue(m_SkinningModule, this, null);
}
void OnPostprocessSprites(Texture2D texture, Sprite[] sprites)
{
var dataProviderFactories = new SpriteDataProviderFactories();
dataProviderFactories.Init();
PSDImporter psd = AssetImporter.GetAtPath(assetPath) as PSDImporter;
if (psd == null)
{
return;
}
ISpriteEditorDataProvider importer = dataProviderFactories.GetSpriteEditorDataProviderFromObject(psd);
if (importer != null)
{
importer.InitSpriteEditorDataProvider();
var physicsOutlineDataProvider = importer.GetDataProvider <ISpritePhysicsOutlineDataProvider>();
var textureDataProvider = importer.GetDataProvider <ITextureDataProvider>();
int actualWidth = 0, actualHeight = 0;
textureDataProvider.GetTextureActualWidthAndHeight(out actualWidth, out actualHeight);
float definitionScaleW = (float)texture.width / actualWidth;
float definitionScaleH = (float)texture.height / actualHeight;
float definitionScale = Mathf.Min(definitionScaleW, definitionScaleH);
foreach (var sprite in sprites)
{
var guid = sprite.GetSpriteID();
var outline = physicsOutlineDataProvider.GetOutlines(guid);
var outlineOffset = sprite.rect.size / 2;
if (outline != null && outline.Count > 0)
{
// Ensure that outlines are all valid.
int validOutlineCount = 0;
for (int i = 0; i < outline.Count; ++i)
{
validOutlineCount = validOutlineCount + ((outline[i].Length > 2) ? 1 : 0);
}
int index = 0;
var convertedOutline = new Vector2[validOutlineCount][];
for (int i = 0; i < outline.Count; ++i)
{
if (outline[i].Length > 2)
{
convertedOutline[index] = new Vector2[outline[i].Length];
for (int j = 0; j < outline[i].Length; ++j)
{
convertedOutline[index][j] = outline[i][j] * definitionScale + outlineOffset;
}
index++;
}
}
sprite.OverridePhysicsShape(convertedOutline);
}
}
}
}
private void CheckDataProviderChanged()
{
var dp = m_SpriteEditor.GetDataProvider <ISpriteEditorDataProvider>();
if (dp != m_CurrentDataProvider)
{
DestoryTextures();
m_OutlineTextureCache.Clear();
m_CurrentDataProvider = dp;
}
}
private void UnifiedValues(out bool name, out bool alignment, out bool border)
{
name = true;
alignment = true;
border = true;
if (base.targets.Length >= 2)
{
string assetPath = AssetDatabase.GetAssetPath(this.sprite);
ISpriteEditorDataProvider spriteEditorDataProvider = AssetImporter.GetAtPath(assetPath) as ISpriteEditorDataProvider;
if (spriteEditorDataProvider != null)
{
spriteEditorDataProvider.InitSpriteEditorDataProvider();
SpriteRect[] spriteRects = spriteEditorDataProvider.GetSpriteRects();
string text = null;
int num = -1;
Vector4? vector = null;
for (int i = 0; i < base.targets.Length; i++)
{
Sprite sprite = base.targets[i] as Sprite;
for (int j = 0; j < spriteRects.Length; j++)
{
if (spriteRects[j].name.Equals(sprite.name))
{
if (spriteRects[j].alignment != (SpriteAlignment)num && num > 0)
{
alignment = false;
}
else
{
num = (int)spriteRects[j].alignment;
}
if (spriteRects[j].name != text && text != null)
{
name = false;
}
else
{
text = spriteRects[j].name;
}
if (spriteRects[j].border != vector && vector.HasValue)
{
border = false;
}
else
{
vector = new Vector4?(spriteRects[j].border);
}
}
}
}
}
}
}
static void ApplyBone(SkinningCache skinningCache, ISpriteEditorDataProvider dataProvider)
{
var boneDataProvider = dataProvider.GetDataProvider <ISpriteBoneDataProvider>();
if (boneDataProvider != null)
{
var sprites = skinningCache.GetSprites();
foreach (var sprite in sprites)
{
var bones = sprite.GetSkeleton().bones;
boneDataProvider.SetBones(new GUID(sprite.id), bones.ToSpriteBone(sprite.localToWorldMatrix).ToList());
}
}
}
protected virtual void LoadOutline()
{
this.m_Outline = ScriptableObject.CreateInstance <SpriteOutlineModel>();
ISpriteEditorDataProvider dataProvider = this.spriteEditorWindow.GetDataProvider <ISpriteEditorDataProvider>();
ISpriteOutlineDataProvider dataProvider2 = this.spriteEditorWindow.GetDataProvider <ISpriteOutlineDataProvider>();
SpriteRect[] spriteRects = dataProvider.GetSpriteRects();
for (int i = 0; i < spriteRects.Length; i++)
{
SpriteRect spriteRect = spriteRects[i];
List <Vector2[]> outlines = dataProvider2.GetOutlines(spriteRect.spriteID);
this.m_Outline.AddListVector2(spriteRect.spriteID, outlines);
this.m_Outline[this.m_Outline.Count - 1].tessellationDetail = dataProvider2.GetTessellationDetail(spriteRect.spriteID);
}
}
void OnPostprocessSprites(Texture2D texture, Sprite[] sprites)
{
ISpriteEditorDataProvider ai = GetSpriteEditorDataProvider(assetPath);
if (ai != null)
{
float definitionScale = CalculateDefinitionScale(texture, ai.GetDataProvider <ITextureDataProvider>());
ai.InitSpriteEditorDataProvider();
PostProcessBoneData(ai, definitionScale, sprites);
PostProcessSpriteMeshData(ai, definitionScale, sprites);
BoneGizmo.instance.ClearSpriteBoneCache();
}
// Get all SpriteSkin in scene and inform them to refresh their cache
RefreshSpriteSkinCache();
}
void OnPostprocessSprites(Texture2D texture, Sprite[] sprites)
{
var dataProviderFactories = new SpriteDataProviderFactories();
dataProviderFactories.Init();
ISpriteEditorDataProvider ai = dataProviderFactories.GetSpriteEditorDataProviderFromObject(AssetImporter.GetAtPath(assetPath));
if (ai != null)
{
float definitionScale = CalculateDefinitionScale(texture, ai.GetDataProvider <ITextureDataProvider>());
ai.InitSpriteEditorDataProvider();
PostProcessBoneData(ai, definitionScale, sprites);
PostProcessSpriteMeshData(ai, definitionScale, sprites);
BoneGizmo.instance.ClearSpriteBoneCache();
}
}
static bool PostProcessBoneData(ISpriteEditorDataProvider spriteDataProvider, float definitionScale, Sprite[] sprites)
{
var boneDataProvider = spriteDataProvider.GetDataProvider <ISpriteBoneDataProvider>();
var textureDataProvider = spriteDataProvider.GetDataProvider <ITextureDataProvider>();
if (sprites == null || sprites.Length == 0 || boneDataProvider == null || textureDataProvider == null)
{
return(false);
}
bool dataChanged = false;
var spriteRects = spriteDataProvider.GetSpriteRects();
foreach (var sprite in sprites)
{
var guid = sprite.GetSpriteID();
{
var spriteBone = boneDataProvider.GetBones(guid);
if (spriteBone == null)
{
continue;
}
var spriteBoneCount = spriteBone.Count;
if (spriteBoneCount == 0)
{
continue;
}
var spriteRect = spriteRects.First(s => { return(s.spriteID == guid); });
var bindPose = new NativeArray <Matrix4x4>(spriteBoneCount, Allocator.Temp);
var outputSpriteBones = new UnityEngine.U2D.SpriteBone ? [spriteBoneCount];
for (int i = 0; i < spriteBoneCount; ++i)
{
CalculateLocaltoWorldMatrix(i, spriteRect, definitionScale, sprite.pixelsPerUnit, spriteBone, ref outputSpriteBones, ref bindPose);
}
sprite.SetBindPoses(bindPose);
sprite.SetBones(outputSpriteBones.Select(x => x.Value).ToArray());
bindPose.Dispose();
dataChanged = true;
}
}
return(dataChanged);
}
public void RefreshPropertiesCache()
{
this.m_SelectedAssetPath = this.GetSelectionAssetPath();
this.m_SpriteDataProvider = (AssetImporter.GetAtPath(this.m_SelectedAssetPath) as ISpriteEditorDataProvider);
if (this.m_SpriteDataProvider != null)
{
this.m_SpriteDataProvider.InitSpriteEditorDataProvider();
ITextureDataProvider dataProvider = this.m_SpriteDataProvider.GetDataProvider <ITextureDataProvider>();
if (dataProvider != null)
{
int width = 0;
int height = 0;
dataProvider.GetTextureActualWidthAndHeight(out width, out height);
this.m_Texture = ((!(dataProvider.texture == null)) ? new SpriteEditorWindow.PreviewTexture2D(dataProvider.texture, width, height) : null);
}
}
}
public override void OnModuleActivate()
{
this.spriteImportMode = SpriteUtility.GetSpriteImportMode(base.spriteEditor.GetDataProvider <ISpriteEditorDataProvider>());
this.m_TextureDataProvider = base.spriteEditor.GetDataProvider <ITextureDataProvider>();
this.m_SpriteDataProvider = base.spriteEditor.GetDataProvider <ISpriteEditorDataProvider>();
int textureActualWidth;
int textureActualHeight;
this.m_TextureDataProvider.GetTextureActualWidthAndHeight(out textureActualWidth, out textureActualHeight);
this.textureActualWidth = textureActualWidth;
this.textureActualHeight = textureActualHeight;
this.m_RectsCache = ScriptableObject.CreateInstance <SpriteRectModel>();
this.m_RectsCache.spriteRects = this.m_SpriteDataProvider.GetSpriteRects().ToList <SpriteRect>();
if (base.spriteEditor.selectedSpriteRect != null)
{
base.spriteEditor.selectedSpriteRect = this.m_RectsCache.spriteRects.FirstOrDefault((SpriteRect x) => x.spriteID == base.spriteEditor.selectedSpriteRect.spriteID);
}
}
// implements ISpriteEditorModule
public override void OnModuleActivate()
{
spriteImportMode = SpriteUtility.GetSpriteImportMode(spriteEditor.GetDataProvider <ISpriteEditorDataProvider>());
m_TextureDataProvider = spriteEditor.GetDataProvider <ITextureDataProvider>();
m_SpriteDataProvider = spriteEditor.GetDataProvider <ISpriteEditorDataProvider>();
int width, height;
m_TextureDataProvider.GetTextureActualWidthAndHeight(out width, out height);
textureActualWidth = width;
textureActualHeight = height;
m_RectsCache = ScriptableObject.CreateInstance <SpriteRectModel>();
m_RectsCache.spriteRects = m_SpriteDataProvider.GetSpriteRects().ToList();
spriteEditor.spriteRects = m_RectsCache.spriteRects;
if (spriteEditor.selectedSpriteRect != null)
{
spriteEditor.selectedSpriteRect = m_RectsCache.spriteRects.FirstOrDefault(x => x.spriteID == spriteEditor.selectedSpriteRect.spriteID);
}
}
private static void OverwriteOutline(Sprite mainSprite, float tessellationDetail, List <Vector2[]> outlines)
{
ISpriteEditorDataProvider mainSpriteDataProvider = AssetImporter.GetAtPath(AssetDatabase.GetAssetPath(mainSprite)) as ISpriteEditorDataProvider;
mainSpriteDataProvider.InitSpriteEditorDataProvider();
ISpritePhysicsOutlineDataProvider meshDataProvider = mainSpriteDataProvider.GetDataProvider <ISpritePhysicsOutlineDataProvider>();
GUID mainGuid = mainSprite.GetSpriteID();
meshDataProvider.SetOutlines(mainGuid, outlines);
meshDataProvider.SetTessellationDetail(mainGuid, tessellationDetail);
mainSpriteDataProvider.Apply();
//AssetDatabase.ImportAsset(AssetDatabase.GetAssetPath(mainSprite));
Debug.Log("Outlines overwritten for " + mainSprite.name);
}
void OnPreprocessAsset()
{
ISpriteEditorDataProvider ai = GetSpriteEditorDataProvider(assetPath);
if (ai != null)
{
var characterDataProvider = ai.GetDataProvider <ICharacterDataProvider>();
var boneDataProvider = ai.GetDataProvider <ISpriteBoneDataProvider>();
var characterData = characterDataProvider?.GetCharacterData();
if (characterData.HasValue && characterData.Value.boneReadOnly && boneDataProvider != null)
{
var skinningCache = Cache.Create <SkinningCache>();
skinningCache.Create(ai, new SkinningCachePersistentStateTemp());
SkinningModule.ApplyChanges(skinningCache, ai);
ai.Apply();
}
}
}
static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAssets, string[] movedAssets, string[] movedFromAssetPaths)
{
var dataProviderFactories = new SpriteDataProviderFactories();
dataProviderFactories.Init();
m_AssetList = new List <object>();
List <string> assetPathModified = new List <string>();
foreach (var importedAsset in importedAssets)
{
var asset = AssetDatabase.LoadMainAssetAtPath(importedAsset);
ISpriteEditorDataProvider ai = dataProviderFactories.GetSpriteEditorDataProviderFromObject(asset);
if (ai != null)
{
ai.InitSpriteEditorDataProvider();
var assets = AssetDatabase.LoadAllAssetsAtPath(importedAsset);
var sprites = assets.OfType <Sprite>().ToArray <Sprite>();
bool dataChanged = false;
dataChanged = PostProcessBoneData(ai, sprites);
dataChanged |= PostProcessSpriteMeshData(ai, sprites);
if (ai is IAnimationAssetPostProcess)
{
dataChanged |= ((IAnimationAssetPostProcess)ai).OnAfterPostProcess();
}
if (dataChanged)
{
assetPathModified.Add(importedAsset);
m_AssetList.AddRange(assets);
}
}
}
if (assetPathModified.Count > 0 && m_AssetList.Count > 0)
{
var originalValue = EditorPrefs.GetBool("VerifySavingAssets", false);
EditorPrefs.SetBool("VerifySavingAssets", false);
AssetDatabase.ForceReserializeAssets(assetPathModified, ForceReserializeAssetsOptions.ReserializeMetadata);
EditorPrefs.SetBool("VerifySavingAssets", originalValue);
m_AssetList.Clear();
BoneGizmo.instance.ClearSpriteBoneCache();
}
}
public void RefreshPropertiesCache()
{
m_SelectedAssetPath = GetSelectionAssetPath();
m_SpriteDataProvider = AssetImporter.GetAtPath(m_SelectedAssetPath) as ISpriteEditorDataProvider;
if (m_SpriteDataProvider == null)
{
return;
}
m_SpriteDataProvider.InitSpriteEditorDataProvider();
var textureProvider = m_SpriteDataProvider.GetDataProvider <ITextureDataProvider>();
if (textureProvider != null)
{
int width = 0, height = 0;
textureProvider.GetTextureActualWidthAndHeight(out width, out height);
m_Texture = textureProvider.texture == null ? null : new PreviewTexture2D(textureProvider.texture, width, height);
}
}
// implements ISpriteEditorModule
public override void OnModuleActivate()
{
spriteImportMode = SpriteFrameModule.GetSpriteImportMode(spriteEditor.GetDataProvider <ISpriteEditorDataProvider>());
m_TextureDataProvider = spriteEditor.GetDataProvider <ITextureDataProvider>();
m_SpriteDataProvider = spriteEditor.GetDataProvider <ISpriteEditorDataProvider>();
int width, height;
m_TextureDataProvider.GetTextureActualWidthAndHeight(out width, out height);
textureActualWidth = width;
textureActualHeight = height;
m_RectsCache = ScriptableObject.CreateInstance <SpriteRectModel>();
m_RectsCache.hideFlags = HideFlags.HideAndDontSave;
m_RectsCache.spriteRects = m_SpriteDataProvider.GetSpriteRects().ToList();
spriteEditor.spriteRects = m_RectsCache.spriteRects;
if (spriteEditor.selectedSpriteRect != null)
{
spriteEditor.selectedSpriteRect = m_RectsCache.spriteRects.FirstOrDefault(x => x.spriteID == spriteEditor.selectedSpriteRect.spriteID);
}
AddMainUI(spriteEditor.GetMainVisualContainer());
undoSystem.RegisterUndoCallback(UndoCallback);
}
public void RefreshPropertiesCache()
{
var obj = AssetDatabase.LoadMainAssetAtPath(m_SelectedAssetPath);
m_SpriteDataProvider = m_SpriteDataProviderFactories.GetSpriteEditorDataProviderFromObject(obj);
if (!IsSpriteDataProviderValid())
{
m_SelectedAssetPath = "";
return;
}
m_SpriteDataProvider.InitSpriteEditorDataProvider();
var textureProvider = m_SpriteDataProvider.GetDataProvider <ITextureDataProvider>();
if (textureProvider != null)
{
int width = 0, height = 0;
textureProvider.GetTextureActualWidthAndHeight(out width, out height);
m_Texture = textureProvider.previewTexture == null ? null : new PreviewTexture2D(textureProvider.previewTexture, width, height);
}
}
static void ApplyMesh(SkinningCache skinningCache, ISpriteEditorDataProvider dataProvider)
{
var meshDataProvider = dataProvider.GetDataProvider <ISpriteMeshDataProvider>();
if (meshDataProvider != null)
{
var sprites = skinningCache.GetSprites();
foreach (var sprite in sprites)
{
var mesh = sprite.GetMesh();
var guid = new GUID(sprite.id);
meshDataProvider.SetVertices(guid, mesh.vertices.Select(x =>
new Vertex2DMetaData()
{
boneWeight = x.editableBoneWeight.ToBoneWeight(false),
position = x.position
}
).ToArray());
meshDataProvider.SetIndices(guid, mesh.indices.ToArray());
meshDataProvider.SetEdges(guid, mesh.edges.Select(x => new Vector2Int(x.index1, x.index2)).ToArray());
}
}
}
public void Create(ISpriteEditorDataProvider spriteEditor, ISkinningCachePersistentState state)
{
Clear();
var dataProvider = spriteEditor.GetDataProvider <ISpriteEditorDataProvider>();
var boneProvider = spriteEditor.GetDataProvider <ISpriteBoneDataProvider>();
var meshProvider = spriteEditor.GetDataProvider <ISpriteMeshDataProvider>();
var spriteRects = dataProvider.GetSpriteRects();
var textureProvider = spriteEditor.GetDataProvider <ITextureDataProvider>();
m_State = state;
m_State.lastTexture = textureProvider.texture;
for (var i = 0; i < spriteRects.Length; i++)
{
var spriteRect = spriteRects[i];
var sprite = CreateSpriteCache(spriteRect);
CreateSkeletonCache(sprite, boneProvider);
CreateMeshCache(sprite, meshProvider, textureProvider);
CreateMeshPreviewCache(sprite);
}
CreateCharacter(spriteEditor);
}
static void ApplyCharacter(SkinningCache skinningCache, ISpriteEditorDataProvider dataProvider)
{
var characterDataProvider = dataProvider.GetDataProvider <ICharacterDataProvider>();
var character = skinningCache.character;
if (characterDataProvider != null && character != null)
{
var data = new CharacterData();
var characterBones = character.skeleton.bones;
data.bones = characterBones.ToSpriteBone(Matrix4x4.identity);
var parts = character.parts;
data.parts = parts.Select(x =>
new CharacterPart()
{
spriteId = x.sprite.id,
spritePosition = new RectInt((int)x.position.x, (int)x.position.y, (int)x.sprite.textureRect.width, (int)x.sprite.textureRect.height),
bones = x.bones.Select(bone => Array.IndexOf(characterBones, bone)).ToArray()
}
).ToArray();
characterDataProvider.SetCharacterData(data);
}
}
public void InvalidatePropertiesCache()
{
m_RectsCache = null;
m_SpriteDataProvider = null;
}
private void CreateCharacter(ISpriteEditorDataProvider spriteEditor)
{
var characterProvider = spriteEditor.GetDataProvider <ICharacterDataProvider>();
if (characterProvider != null)
{
var characterData = characterProvider.GetCharacterData();
var characterParts = new List <CharacterPartCache>();
m_Character = CreateCache <CharacterCache>();
m_BonesReadOnly = spriteEditor.GetDataProvider <IMainSkeletonDataProvider>() != null;
var skeleton = CreateCache <SkeletonCache>();
var characterBones = characterData.bones;
skeleton.SetBones(CreateBoneCacheFromSpriteBones(characterBones, 1.0f));
skeleton.position = Vector3.zero;
var bones = skeleton.bones;
foreach (var p in characterData.parts)
{
var spriteBones = p.bones != null?p.bones.ToList() : new List <int>();
var characterPartBones = spriteBones.ConvertAll(i => bones.ElementAtOrDefault(i)).ToArray();
var characterPart = CreateCache <CharacterPartCache>();
var positionInt = p.spritePosition.position;
characterPart.position = new Vector2(positionInt.x, positionInt.y);
characterPart.sprite = GetSprite(p.spriteId);
characterPart.bones = characterPartBones;
characterPart.parentGroup = p.parentGroup;
characterPart.order = p.order;
var mesh = characterPart.sprite.GetMesh();
if (mesh != null)
{
mesh.SetCompatibleBoneSet(characterPartBones);
}
characterParts.Add(characterPart);
m_CharacterPartMap.Add(characterPart.sprite, characterPart);
}
if (characterData.characterGroups != null)
{
m_Character.groups = characterData.characterGroups.Select(x =>
{
var group = CreateCache <CharacterGroupCache>();
group.name = x.name;
group.parentGroup = x.parentGroup;
group.order = x.order;
return(group);
}).ToArray();
}
else
{
m_Character.groups = new CharacterGroupCache[0];
}
m_Character.parts = characterParts.ToArray();
m_Character.skeleton = skeleton;
m_Character.dimension = characterData.dimension;
CreateSpriteSheetSkeletons();
}
}
static bool PostProcessSpriteMeshData(ISpriteEditorDataProvider spriteDataProvider, Sprite[] sprites)
{
var spriteMeshDataProvider = spriteDataProvider.GetDataProvider <ISpriteMeshDataProvider>();
var boneDataProvider = spriteDataProvider.GetDataProvider <ISpriteBoneDataProvider>();
var textureDataProvider = spriteDataProvider.GetDataProvider <ITextureDataProvider>();
if (sprites == null || sprites.Length == 0 || spriteMeshDataProvider == null || textureDataProvider == null)
{
return(false);
}
bool dataChanged = false;
float definitionScale = CalculateDefinitionScale(textureDataProvider);
foreach (var sprite in sprites)
{
var guid = sprite.GetSpriteID();
var spriteRect = spriteDataProvider.GetSpriteRects().First(s => { return(s.spriteID == guid); });
var spriteBone = boneDataProvider.GetBones(guid);
var hasBones = spriteBone != null && spriteBone.Count > 0;
var hasInvalidWeights = false;
var vertices = spriteMeshDataProvider.GetVertices(guid);
var indices = spriteMeshDataProvider.GetIndices(guid);
if (vertices.Length > 2 && indices.Length > 2)
{
var vertexArray = new NativeArray <Vector3>(vertices.Length, Allocator.Temp);
var boneWeightArray = new NativeArray <BoneWeight>(vertices.Length, Allocator.Temp);
for (int i = 0; i < vertices.Length; ++i)
{
var boneWeight = vertices[i].boneWeight;
vertexArray[i] = (Vector3)(vertices[i].position - Vector2.Scale(spriteRect.rect.size, spriteRect.pivot)) * definitionScale / sprite.pixelsPerUnit;
boneWeightArray[i] = boneWeight;
if (hasBones && !hasInvalidWeights)
{
var sum = boneWeight.weight0 + boneWeight.weight1 + boneWeight.weight2 + boneWeight.weight3;
hasInvalidWeights = sum < 0.999f;
}
}
var indicesArray = new NativeArray <ushort>(indices.Length, Allocator.Temp);
for (int i = 0; i < indices.Length; ++i)
{
indicesArray[i] = (ushort)indices[i];
}
sprite.SetVertexCount(vertices.Length);
sprite.SetVertexAttribute <Vector3>(VertexAttribute.Position, vertexArray);
sprite.SetIndices(indicesArray);
sprite.SetBoneWeights(boneWeightArray);
vertexArray.Dispose();
boneWeightArray.Dispose();
indicesArray.Dispose();
dataChanged = true;
if (hasBones && hasInvalidWeights)
{
Debug.LogWarning("Sprite \"" + spriteRect.name + "\" contains bone weights which sum zero or are not normalized. To avoid visual artifacts please consider fixing them.");
}
}
else
{
var boneWeightArray = new NativeArray <BoneWeight>(sprite.GetVertexCount(), Allocator.Temp);
var defaultBoneWeight = new BoneWeight()
{
weight0 = 1f
};
for (var i = 0; i < boneWeightArray.Length; ++i)
{
boneWeightArray[i] = defaultBoneWeight;
}
sprite.SetBoneWeights(boneWeightArray);
}
}
return(dataChanged);
}
public static SpriteImportMode GetSpriteImportMode(ISpriteEditorDataProvider dataProvider)
{
return(dataProvider == null ? SpriteImportMode.None : dataProvider.spriteImportMode);
}
