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); } } } }
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 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); }
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 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()); } } }
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); }
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(); } }
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); }
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); } }
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 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 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); } }
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 override bool ApplyRevert(bool apply) { if (apply) { if (containsMultipleSprites) { var oldNames = new List <string>(); var newNames = new List <string>(); var ids = new List <long>(); var names = new List <string>(); foreach (var spriteRect in m_RectsCache.spriteRects) { if (string.IsNullOrEmpty(spriteRect.name)) { spriteRect.name = "Empty"; } if (!string.IsNullOrEmpty(spriteRect.originalName)) { oldNames.Add(spriteRect.originalName); newNames.Add(spriteRect.name); } if (spriteRect.m_RegisterInternalID) { ids.Add(spriteRect.internalID); names.Add(spriteRect.name); } spriteRect.m_RegisterInternalID = false; } var so = new SerializedObject(m_SpriteDataProvider.targetObject); if (so.isValid && ids.Count > 0) { ImportSettingInternalID.RegisterInternalID(so, spriteType, ids, names); so.ApplyModifiedPropertiesWithoutUndo(); } AssetImporter assetImporter = m_SpriteDataProvider.targetObject as AssetImporter; if (oldNames.Count > 0 && assetImporter != null) { assetImporter.RenameSubAssets(spriteType.persistentTypeID, oldNames.ToArray(), newNames.ToArray()); so.ApplyModifiedPropertiesWithoutUndo(); } } var array = m_RectsCache != null?m_RectsCache.spriteRects.ToArray() : null; m_SpriteDataProvider.SetSpriteRects(array); var outlineDataProvider = m_SpriteDataProvider.GetDataProvider <ISpriteOutlineDataProvider>(); var physicsDataProvider = m_SpriteDataProvider.GetDataProvider <ISpritePhysicsOutlineDataProvider>(); foreach (var rect in array) { if (rect is OutlineSpriteRect outlineRect) { if (outlineRect.outlines.Count > 0) { outlineDataProvider.SetOutlines(outlineRect.spriteID, outlineRect.outlines); physicsDataProvider.SetOutlines(outlineRect.spriteID, outlineRect.outlines); } } } if (m_RectsCache != null) { undoSystem.ClearUndo(m_RectsCache); } } else { if (m_RectsCache != null) { undoSystem.ClearUndo(m_RectsCache); var spriteList = m_SpriteDataProvider.GetSpriteRects().ToList(); m_RectsCache.SetSpriteRects(spriteList); spriteEditor.spriteRects = spriteList; if (spriteEditor.selectedSpriteRect != null) { spriteEditor.selectedSpriteRect = m_RectsCache.spriteRects.FirstOrDefault(x => x.spriteID == spriteEditor.selectedSpriteRect.spriteID); } } } return(true); }
static bool PostProcessBoneData(ISpriteEditorDataProvider spriteDataProvider, 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; float definitionScale = CalculateDefinitionScale(textureDataProvider); foreach (var sprite in sprites) { var guid = sprite.GetSpriteID(); { SpriteRect spriteRect = spriteDataProvider.GetSpriteRects().First(s => { return(s.spriteID == guid); }); var spriteBone = boneDataProvider.GetBones(guid); if (spriteBone == null) { continue; } var spriteBoneCount = spriteBone.Count; var pivotPointInPixels = sprite.pivot; var bindPose = new NativeArray <Matrix4x4>(spriteBoneCount, Allocator.Temp); var outputSpriteBones = new SpriteBone[spriteBoneCount];// NativeArray<SpriteBone>(spriteBone.Count, Allocator.Temp); for (int i = 0; i < spriteBoneCount; ++i) { // Convert position to world unit. SpriteBone sp = spriteBone[i]; var isRoot = sp.parentId == -1; var position = isRoot ? (spriteBone[i].position - Vector3.Scale(spriteRect.rect.size, spriteRect.pivot)) : spriteBone[i].position; position.z = 0f; sp.position = position * definitionScale / sprite.pixelsPerUnit; sp.length = spriteBone[i].length * definitionScale / sprite.pixelsPerUnit; outputSpriteBones[i] = sp; // Calculate bind poses var worldPosition = Vector3.zero; var worldRotation = Quaternion.identity; if (sp.parentId == -1) { worldPosition = sp.position; worldRotation = sp.rotation; } else { var parentBindPose = bindPose[sp.parentId]; var invParentBindPose = Matrix4x4.Inverse(parentBindPose); worldPosition = invParentBindPose.MultiplyPoint(sp.position); worldRotation = sp.rotation * invParentBindPose.rotation; } // Practically Matrix4x4.SetTRInverse var rot = Quaternion.Inverse(worldRotation); Matrix4x4 mat = Matrix4x4.identity; mat = Matrix4x4.Rotate(rot); mat = mat * Matrix4x4.Translate(-worldPosition); bindPose[i] = mat; } sprite.SetBindPoses(bindPose); sprite.SetBones(outputSpriteBones); bindPose.Dispose(); dataChanged = true; } } return(dataChanged); }
public T GetDataProvider <T>() where T : class { return(m_SpriteDataProvider != null?m_SpriteDataProvider.GetDataProvider <T>() : null); }
public override bool ApplyRevert(bool apply) { if (apply) { var array = m_RectsCache != null?m_RectsCache.spriteRects.ToArray() : null; m_SpriteDataProvider.SetSpriteRects(array); var spriteNames = m_RectsCache?.spriteNames; var spriteFileIds = m_RectsCache?.spriteFileIds; if (spriteNames != null && spriteFileIds != null) { var pairList = new List <SpriteNameFileIdPair>(spriteNames.Count); for (var i = 0; i < spriteNames.Count; ++i) { pairList.Add(new SpriteNameFileIdPair(spriteNames[i], spriteFileIds[i])); } m_NameFileIdDataProvider.SetNameFileIdPairs(pairList.ToArray()); } var outlineDataProvider = m_SpriteDataProvider.GetDataProvider <ISpriteOutlineDataProvider>(); var physicsDataProvider = m_SpriteDataProvider.GetDataProvider <ISpritePhysicsOutlineDataProvider>(); foreach (var rect in array) { if (rect is OutlineSpriteRect outlineRect) { if (outlineRect.outlines.Count > 0) { outlineDataProvider.SetOutlines(outlineRect.spriteID, outlineRect.outlines); physicsDataProvider.SetOutlines(outlineRect.spriteID, outlineRect.outlines); } } } if (m_RectsCache != null) { undoSystem.ClearUndo(m_RectsCache); } } else { if (m_RectsCache != null) { undoSystem.ClearUndo(m_RectsCache); var spriteList = m_SpriteDataProvider.GetSpriteRects().ToList(); m_RectsCache.SetSpriteRects(spriteList); var nameFileIdPairs = m_NameFileIdDataProvider.GetNameFileIdPairs(); m_RectsCache.SetNameFileIdPairs(nameFileIdPairs); spriteEditor.spriteRects = spriteList; if (spriteEditor.selectedSpriteRect != null) { spriteEditor.selectedSpriteRect = m_RectsCache.spriteRects.FirstOrDefault(x => x.spriteID == spriteEditor.selectedSpriteRect.spriteID); } } } return(true); }
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(); } }
public virtual T GetDataProvider <T>() where T : class { return(m_DataProvider.GetDataProvider <T>()); }
public T GetDataProvider <T>() where T : class { return(m_SpriteDataProvider?.GetDataProvider <T>()); }