public static void AddBones(this SkeletonCache skeleton, BoneCache[] bones, bool worldPositionStays)
{
foreach (var bone in bones)
{
skeleton.AddBone(bone, worldPositionStays);
}
}
public static BoneCache CreateBone(this SkeletonCache skeleton, BoneCache parentBone, Vector3 position, Vector3 endPosition, bool isChained, string name)
{
Debug.Assert(skeleton != null);
if (parentBone != null)
{
Debug.Assert(skeleton.Contains(parentBone));
}
var bone = skeleton.skinningCache.CreateCache <BoneCache>();
bone.SetParent(parentBone);
bone.name = name;
bone.bindPoseColor = ModuleUtility.CalculateNiceColor(skeleton.BoneCount, 6);
bone.position = position;
bone.endPosition = endPosition;
if (isChained && parentBone != null)
{
parentBone.chainedChild = bone;
}
skeleton.AddBone(bone);
return(bone);
}
private void OnSkeletonTopologyChanged(SkeletonCache skeleton)
{
if (m_Model.view.visible)
{
m_Model.view.OnSkeletonChanged();
}
}
public static void MoveJoints(this SkeletonCache skeleton, BoneCache[] bones, Vector3 deltaPosition)
{
Debug.Assert(skeleton != null);
foreach (var bone in bones)
{
Debug.Assert(bone != null);
Debug.Assert(skeleton.Contains(bone));
var childrenWorldPose = bone.GetChildrenWoldPose();
var endPosition = bone.endPosition;
bone.position += deltaPosition;
if (bone.localLength > 0f)
{
bone.endPosition = endPosition;
}
if (bone.parentBone != null && bone.parentBone.chainedChild == bone)
{
bone.parentBone.OrientToChainedChild(true);
}
bone.SetChildrenWorldPose(childrenWorldPose);
if (bone.chainedChild != null)
{
bone.OrientToChainedChild(true);
}
}
}
public static void FreeMoveBones(this SkeletonCache skeleton, BoneCache[] bones, Vector3 deltaPosition)
{
Debug.Assert(skeleton != null);
foreach (var bone in bones)
{
Debug.Assert(bone != null);
Debug.Assert(skeleton.Contains(bone));
var childrenWorldPose = bone.GetChildrenWoldPose();
if (bone.chainedChild != null && ArrayUtility.Contains(bones, bone.chainedChild) == false)
{
bone.chainedChild = null;
}
if (bone.parentBone != null && bone.parentBone.chainedChild == bone && ArrayUtility.Contains(bones, bone.parentBone) == false)
{
bone.parentBone.chainedChild = null;
}
bone.position += deltaPosition;
bone.SetChildrenWorldPose(childrenWorldPose);
}
}
private void StorePersistentStateVisibilityForSkeleton(SkeletonCache skeleton, SpriteCache sprite)
{
foreach (var bone in skeleton.bones)
{
var id = GetBoneNameHash(m_StringBuilder, bone, sprite);
m_State.lastBoneVisibility[id] = bone.isVisible;
}
}
void OnSkeletonTopologyChanged(SkeletonCache skeleton)
{
SetAnimationEvent(new AnimationEvent()
{
sub_type = AnimationEventType.SkeletonTopologyChanged,
data = ""
});
}
void OnSkeletonTopologyChanged(SkeletonCache skeleton)
{
if (m_Model.view.visible)
{
m_Model.view.UpdateList(m_Model.influencedSprites);
m_Model.view.UpdateSelection(new TransformCache[] { m_Model.selectedSprite });
}
}
void OnSkeletonPreviewPoseChanged(SkeletonCache skeleton)
{
SetAnimationEvent(new AnimationEvent()
{
sub_type = AnimationEventType.SkeletonPreviewPoseChanged,
data = ""
});
}
private void SetSkeleton(SkeletonCache newSkeleton)
{
if (skeleton != newSkeleton)
{
m_Skeleton = newSkeleton;
Reset();
}
}
//TODO: Bring this to a better place, maybe CharacterController
private void SkeletonPreviewPoseChanged(SkeletonCache skeleton)
{
var character = skinningCache.character;
if (character != null && character.skeleton == skeleton)
{
skinningCache.SyncSpriteSheetSkeletons();
}
}
private void SetupSkeleton(SkeletonCache sk)
{
m_RectBoneSelector.bones = null;
skeleton = sk;
if (skeleton != null)
{
m_RectBoneSelector.bones = skeleton.bones;
}
}
private void SkeletonBindPoseChanged(SkeletonCache skeleton)
{
var character = skinningCache.character;
if (character != null && character.skeleton == skeleton)
{
skinningCache.SyncSpriteSheetSkeletons();
}
DataModified();
}
void OnSkeletonTopologyChanged(SkeletonCache skeleton)
{
if (m_Model.view.visible)
{
UpdateSelectedSpriteBoneInfluence();
m_Model.view.UpdateList(m_Model.selectionInfluencedBones);
m_Model.view.UpdateSelection(m_Model.selectedBones);
}
}
public static void SetAllBoneVisibility(SkeletonCache skeleton, bool visibility)
{
if (skeleton != null)
{
foreach (var bone in skeleton.bones)
{
bone.isVisible = visibility;
}
}
}
public static void SetEndPosition(this SkeletonCache skeleton, BoneCache bone, Vector3 endPosition)
{
Debug.Assert(skeleton != null);
Debug.Assert(bone != null);
Debug.Assert(skeleton.Contains(bone));
var childrenStorage = bone.GetChildrenWoldPose();
bone.endPosition = endPosition;
bone.SetChildrenWorldPose(childrenStorage);
}
private void UpdateVisibilityFromPersistentState(SkeletonCache skeleton, SpriteCache sprite)
{
foreach (var bone in skeleton.bones)
{
var id = GetBoneNameHash(m_StringBuilder, bone, sprite);
if (m_State.lastBoneVisibility.TryGetValue(id, out var visibility))
{
bone.isVisible = visibility;
}
}
}
private void StorePersistentStatePoseForSkeleton(SkeletonCache skeleton, SpriteCache sprite)
{
foreach (var bone in skeleton.bones)
{
var id = GetBoneNameHash(m_StringBuilder, bone, sprite);
if (bone.NotInDefaultPose())
{
m_State.lastPreviewPose[id] = bone.localPose;
}
}
}
public static void RotateBones(this SkeletonCache skeleton, BoneCache[] bones, float deltaAngle)
{
Debug.Assert(skeleton != null);
foreach (var bone in bones)
{
Debug.Assert(bone != null);
Debug.Assert(skeleton.Contains(bone));
bone.localRotation *= Quaternion.AngleAxis(deltaAngle, Vector3.forward);
}
}
public static void DestroyBones(this SkeletonCache skeleton, BoneCache[] bones)
{
Debug.Assert(skeleton != null);
foreach (var bone in bones)
{
Debug.Assert(bone != null);
Debug.Assert(skeleton.Contains(bone));
skeleton.DestroyBone(bone);
}
}
public void RestoreToolStateFromPersistentState()
{
events.boneSelectionChanged.RemoveListener(BoneSelectionChanged);
events.skeletonPreviewPoseChanged.RemoveListener(SkeletonPreviewPoseChanged);
events.toolChanged.RemoveListener(ToolChanged);
SkeletonCache skeleton = null;
if (hasCharacter)
{
skeleton = character.skeleton;
}
else if (selectedSprite != null)
{
skeleton = selectedSprite.GetSkeleton();
}
skeletonSelection.Clear();
if (skeleton != null && m_State.lastBoneSelectionIds.Count > 0)
{
bool selectionChanged = false;
foreach (var bone in skeleton.bones)
{
var id = GetBoneNameHash(m_StringBuilder, bone);
if (m_State.lastBoneSelectionIds.Contains(id))
{
skeletonSelection.Select(bone, true);
selectionChanged = true;
}
}
if (selectionChanged)
{
events.boneSelectionChanged.Invoke();
}
}
if (m_State.lastPreviewPose.Count > 0)
{
if (hasCharacter)
{
UpdatePoseFromPersistentState(character.skeleton, null);
}
foreach (var sprite in m_SkeletonMap.Keys)
{
UpdatePoseFromPersistentState(m_SkeletonMap[sprite], sprite);
}
}
events.boneSelectionChanged.AddListener(BoneSelectionChanged);
events.skeletonPreviewPoseChanged.AddListener(SkeletonPreviewPoseChanged);
events.toolChanged.AddListener(ToolChanged);
}
public static void MoveBones(this SkeletonCache skeleton, BoneCache[] bones, Vector3 deltaPosition)
{
Debug.Assert(skeleton != null);
foreach (var bone in bones)
{
Debug.Assert(bone != null);
Debug.Assert(skeleton.Contains(bone));
bone.position += deltaPosition;
if (bone.parentBone != null && bone.parentBone.chainedChild == bone)
{
bone.parentBone.OrientToChainedChild(false);
}
}
}
internal void BoneVisibilityChanged(SkeletonCache sc)
{
if (applyingChanges)
{
return;
}
m_State.lastBoneVisibility.Clear();
if (hasCharacter)
{
StorePersistentStateVisibilityForSkeleton(character.skeleton, null);
}
foreach (var sprite in m_SkeletonMap.Keys)
{
StorePersistentStateVisibilityForSkeleton(m_SkeletonMap[sprite], sprite);
}
}
private void SkeletonPreviewPoseChanged(SkeletonCache sc)
{
if (applyingChanges)
{
return;
}
m_State.lastPreviewPose.Clear();
if (hasCharacter)
{
StorePersistentStatePoseForSkeleton(character.skeleton, null);
}
foreach (var sprite in m_SkeletonMap.Keys)
{
StorePersistentStatePoseForSkeleton(m_SkeletonMap[sprite], sprite);
}
}
private void SkeletonTopologyChanged(SkeletonCache skeleton)
{
var character = skinningCache.character;
if (character == null)
{
var sprite = FindSpriteFromSkeleton(skeleton);
Debug.Assert(sprite != null);
sprite.UpdateMesh(skeleton.bones);
DataModified();
}
else if (character.skeleton == skeleton)
{
skinningCache.CreateSpriteSheetSkeletons();
DataModified();
}
}
private void UpdatePoseFromPersistentState(SkeletonCache skeleton, SpriteCache sprite)
{
bool poseChanged = false;
foreach (var bone in skeleton.bones)
{
var id = GetBoneNameHash(m_StringBuilder, bone, sprite);
BonePose pose;
if (m_State.lastPreviewPose.TryGetValue(id, out pose))
{
bone.localPose = pose;
poseChanged = true;
}
}
if (poseChanged)
{
skeleton.SetPosePreview();
events.skeletonPreviewPoseChanged.Invoke(skeleton);
}
}
public static BoneCache SplitBone(this SkeletonCache skeleton, BoneCache boneToSplit, float splitLength, string name)
{
Debug.Assert(skeleton.Contains(boneToSplit));
Debug.Assert(boneToSplit.length > splitLength);
var endPosition = boneToSplit.endPosition;
var chainedChild = boneToSplit.chainedChild;
var splitPosition = boneToSplit.position + boneToSplit.right * splitLength;
boneToSplit.length = splitLength;
var bone = skeleton.CreateBone(boneToSplit, splitPosition, endPosition, true, name);
if (chainedChild != null)
{
chainedChild.SetParent(bone);
bone.chainedChild = chainedChild;
}
return(bone);
}
public DefaultPoseScope(SkeletonCache skeleton, bool useLocalPose = true)
{
Debug.Assert(skeleton != null);
m_Skeleton = skeleton;
m_UseLocalPose = useLocalPose;
if (m_Skeleton.isPosePreview)
{
m_DoRestorePose = true;
if (useLocalPose)
{
m_Pose = m_Skeleton.GetLocalPose();
}
else
{
m_Pose = m_Skeleton.GetWorldPose();
}
m_Skeleton.RestoreDefaultPose();
}
}
private SpriteCache FindSpriteFromSkeleton(SkeletonCache skeleton)
{
var sprites = skinningCache.GetSprites();
return(sprites.FirstOrDefault(sprite => sprite.GetSkeleton() == skeleton));
}
private string[] GetUniqueBoneNames(BoneCache[] bones, SkeletonCache skeleton)
{
return(Array.ConvertAll(bones, b => skeleton.GetUniqueName(b)));
}
