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>());
}
