public void HandleRebuild (SkeletonRenderer renderer) {
if (string.IsNullOrEmpty(slotName))
return;
hasReset = true;
ClearColliders();
colliderTable.Clear();
if (skeletonRenderer.skeleton == null) {
skeletonRenderer.OnRebuild -= HandleRebuild;
skeletonRenderer.Initialize(false);
skeletonRenderer.OnRebuild += HandleRebuild;
}
var skeleton = skeletonRenderer.skeleton;
slot = skeleton.FindSlot(slotName);
int slotIndex = skeleton.FindSlotIndex(slotName);
if (this.gameObject.activeInHierarchy) {
foreach (var skin in skeleton.Data.Skins) {
var attachmentNames = new List<string>();
skin.FindNamesForSlot(slotIndex, attachmentNames);
foreach (var attachmentName in attachmentNames) {
var attachment = skin.GetAttachment(slotIndex, attachmentName);
var boundingBoxAttachment = attachment as BoundingBoxAttachment;
#if UNITY_EDITOR
if (attachment != null && boundingBoxAttachment == null)
Debug.Log("BoundingBoxFollower tried to follow a slot that contains non-boundingbox attachments: " + slotName);
#endif
if (boundingBoxAttachment != null) {
var bbCollider = SkeletonUtility.AddBoundingBoxAsComponent(boundingBoxAttachment, gameObject, true);
bbCollider.enabled = false;
bbCollider.hideFlags = HideFlags.NotEditable;
bbCollider.isTrigger = IsTrigger;
colliderTable.Add(boundingBoxAttachment, bbCollider);
attachmentNameTable.Add(boundingBoxAttachment, attachmentName);
}
}
}
}
#if UNITY_EDITOR
valid = colliderTable.Count != 0;
if (!valid) {
if (this.gameObject.activeInHierarchy)
Debug.LogWarning("Bounding Box Follower not valid! Slot [" + slotName + "] does not contain any Bounding Box Attachments!");
else
Debug.LogWarning("Bounding Box Follower tried to rebuild as a prefab.");
}
#endif
}
void OnEnable () {
ClearColliders();
if (skeletonRenderer == null)
skeletonRenderer = GetComponentInParent<SkeletonRenderer>();
if (skeletonRenderer != null) {
skeletonRenderer.OnReset -= HandleReset;
skeletonRenderer.OnReset += HandleReset;
}
}
void UpdateLocal(SkeletonRenderer renderer) {
Vector3 vec = useAcceleration ? acceleration : velocity;
if (Mathf.Abs(vec.x) < returnThreshhold)
goalRotation = Mathf.Lerp(goalRotation, 0, returnSpeed * Time.deltaTime);
else
goalRotation += vec.x * rotationFactor * Time.deltaTime * (bone.WorldFlipX ? -1 : 1);
goalRotation = Mathf.Clamp(goalRotation, minRotation, maxRotation);
bone.Rotation = Mathf.Lerp(bone.Rotation, bone.Rotation + goalRotation, boneSpeed * Time.deltaTime);
}
void Start () {
skeletonRenderer = GetComponent<SkeletonRenderer>();
Skeleton skeleton = skeletonRenderer.skeleton;
customSkin = new Skin("CustomSkin");
foreach (var pair in skinning) {
var attachment = SpineAttachment.GetAttachment(pair.sourceAttachment, skinSource);
customSkin.AddAttachment(skeleton.FindSlotIndex(pair.targetSlot), pair.targetAttachment, attachment);
}
skeleton.SetSkin(customSkin);
}
void OnEnable () {
ClearColliders();
if (skeletonRenderer == null)
skeletonRenderer = GetComponentInParent<SkeletonRenderer>();
if (skeletonRenderer != null) {
skeletonRenderer.OnRebuild -= HandleReset;
skeletonRenderer.OnRebuild += HandleReset;
if (hasReset)
HandleReset(skeletonRenderer);
}
}
void Start () {
skeletonRenderer = GetComponent<SkeletonRenderer>();
Skeleton skeleton = skeletonRenderer.skeleton;
customSkin = new Skin("CustomSkin");
foreach (var pair in skinItems) {
var attachment = SpineAttachment.GetAttachment(pair.sourceAttachmentPath, skinSource);
customSkin.AddAttachment(skeleton.FindSlotIndex(pair.targetSlot), pair.targetAttachment, attachment);
}
// The custom skin does not need to be added to the skeleton data for it to work.
// But it's useful for your script to keep a reference to it.
skeleton.SetSkin(customSkin);
}
public void HandleReset (SkeletonRenderer renderer) {
if (slotName == null || slotName == "")
return;
hasReset = true;
ClearColliders();
colliderTable.Clear();
if (skeletonRenderer.skeleton == null) {
skeletonRenderer.OnReset -= HandleReset;
skeletonRenderer.Reset();
skeletonRenderer.OnReset += HandleReset;
}
var skeleton = skeletonRenderer.skeleton;
slot = skeleton.FindSlot(slotName);
int slotIndex = skeleton.FindSlotIndex(slotName);
foreach (var skin in skeleton.Data.Skins) {
List<string> attachmentNames = new List<string>();
skin.FindNamesForSlot(slotIndex, attachmentNames);
foreach (var name in attachmentNames) {
var attachment = skin.GetAttachment(slotIndex, name);
if (attachment is BoundingBoxAttachment) {
var collider = SkeletonUtility.AddBoundingBoxAsComponent((BoundingBoxAttachment)attachment, gameObject, true);
collider.enabled = false;
collider.hideFlags = HideFlags.HideInInspector;
colliderTable.Add((BoundingBoxAttachment)attachment, collider);
attachmentNameTable.Add((BoundingBoxAttachment)attachment, name);
}
}
}
if (colliderTable.Count == 0)
valid = false;
else
valid = true;
if (!valid)
Debug.LogWarning("Bounding Box Follower not valid! Slot [" + slotName + "] does not contain any Bounding Box Attachments!");
}
void Start () {
if (ghostShader == null)
ghostShader = Shader.Find(GhostingShaderName);
skeletonRenderer = GetComponent<SkeletonRenderer>();
meshFilter = GetComponent<MeshFilter>();
meshRenderer = GetComponent<MeshRenderer>();
nextSpawnTime = Time.time + spawnRate;
pool = new SkeletonGhostRenderer[maximumGhosts];
for (int i = 0; i < maximumGhosts; i++) {
GameObject go = new GameObject(gameObject.name + " Ghost", typeof(SkeletonGhostRenderer));
pool[i] = go.GetComponent<SkeletonGhostRenderer>();
go.SetActive(false);
go.hideFlags = GhostHideFlags;
}
var skeletonAnimation = skeletonRenderer as Spine.Unity.IAnimationStateComponent;
if (skeletonAnimation != null) skeletonAnimation.AnimationState.Event += OnEvent;
}
void OnEnable () {
skeletonUtility = (SkeletonUtility)target;
skeletonRenderer = skeletonUtility.GetComponent<SkeletonRenderer>();
skeleton = skeletonRenderer.skeleton;
transform = skeletonRenderer.transform;
if (skeleton == null) {
skeletonRenderer.Reset();
skeletonRenderer.LateUpdate();
skeleton = skeletonRenderer.skeleton;
}
UpdateAttachments();
if (PrefabUtility.GetPrefabType(this.target) == PrefabType.Prefab)
isPrefab = true;
}
void OnEnable(){
if(skeletonRenderer == null){
skeletonRenderer = GetComponent<SkeletonRenderer>();
}
if(skeletonAnimation == null){
skeletonAnimation = GetComponent<SkeletonAnimation>();
}
skeletonRenderer.OnReset -= HandleRendererReset;
skeletonRenderer.OnReset += HandleRendererReset;
if(skeletonAnimation != null){
skeletonAnimation.UpdateLocal -= UpdateLocal;
skeletonAnimation.UpdateLocal += UpdateLocal;
}
CollectBones();
}
public static void ReapplySeparatorSlotNames (SkeletonRenderer skeletonRenderer) {
if (!skeletonRenderer.valid) return;
var separatorSlots = skeletonRenderer.separatorSlots;
var separatorSlotNames = skeletonRenderer.separatorSlotNames;
var skeleton = skeletonRenderer.skeleton;
separatorSlots.Clear();
for (int i = 0, n = separatorSlotNames.Length; i < n; i++) {
var slot = skeleton.FindSlot(separatorSlotNames[i]);
if (slot != null) {
separatorSlots.Add(slot);
//Debug.Log(slot + " added as separator.");
} else {
Debug.LogWarning(separatorSlotNames[i] + " is not a slot in " + skeletonRenderer.skeletonDataAsset.skeletonJSON.name);
}
}
//Debug.Log("Reapplied Separator Slot Names. Count is now: " + separatorSlots.Count);
}
void Start () {
if (ghostShader == null)
ghostShader = Shader.Find("Spine/SkeletonGhost");
skeletonRenderer = GetComponent<SkeletonRenderer>();
meshFilter = GetComponent<MeshFilter>();
meshRenderer = GetComponent<MeshRenderer>();
nextSpawnTime = Time.time + spawnRate;
pool = new SkeletonGhostRenderer[maximumGhosts];
for (int i = 0; i < maximumGhosts; i++) {
GameObject go = new GameObject(gameObject.name + " Ghost", typeof(SkeletonGhostRenderer));
pool[i] = go.GetComponent<SkeletonGhostRenderer>();
go.SetActive(false);
go.hideFlags = HideFlags.HideInHierarchy;
}
if (skeletonRenderer is SkeletonAnimation)
((SkeletonAnimation)skeletonRenderer).state.Event += OnEvent;
}
public void HandleReset (SkeletonRenderer renderer) {
if (string.IsNullOrEmpty(slotName))
return;
hasReset = true;
ClearColliders();
colliderTable.Clear();
if (skeletonRenderer.skeleton == null) {
skeletonRenderer.OnRebuild -= HandleReset;
skeletonRenderer.Initialize(false);
skeletonRenderer.OnRebuild += HandleReset;
}
var skeleton = skeletonRenderer.skeleton;
slot = skeleton.FindSlot(slotName);
int slotIndex = skeleton.FindSlotIndex(slotName);
foreach (var skin in skeleton.Data.Skins) {
var attachmentNames = new List<string>();
skin.FindNamesForSlot(slotIndex, attachmentNames);
foreach (var attachmentName in attachmentNames) {
var attachment = skin.GetAttachment(slotIndex, attachmentName);
var boundingBoxAttachment = attachment as BoundingBoxAttachment;
if (boundingBoxAttachment != null) {
var bbCollider = SkeletonUtility.AddBoundingBoxAsComponent(boundingBoxAttachment, gameObject, true);
bbCollider.enabled = false;
bbCollider.hideFlags = HideFlags.HideInInspector;
colliderTable.Add(boundingBoxAttachment, bbCollider);
attachmentNameTable.Add(boundingBoxAttachment, attachmentName);
}
}
}
valid = colliderTable.Count != 0;
if (!valid)
Debug.LogWarning("Bounding Box Follower not valid! Slot [" + slotName + "] does not contain any Bounding Box Attachments!");
}
void Apply (SkeletonRenderer skeletonRenderer) {
atlas = atlasAsset.GetAtlas();
AtlasAttachmentLoader loader = new AtlasAttachmentLoader(atlas);
float scaleMultiplier = skeletonRenderer.skeletonDataAsset.scale;
var enumerator = attachments.GetEnumerator();
while (enumerator.MoveNext()) {
var entry = (SlotRegionPair)enumerator.Current;
var regionAttachment = loader.NewRegionAttachment(null, entry.region, entry.region);
regionAttachment.Width = regionAttachment.RegionOriginalWidth * scaleMultiplier;
regionAttachment.Height = regionAttachment.RegionOriginalHeight * scaleMultiplier;
regionAttachment.SetColor(new Color(1, 1, 1, 1));
regionAttachment.UpdateOffset();
var slot = skeletonRenderer.skeleton.FindSlot(entry.slot);
slot.Attachment = regionAttachment;
}
}
void Reset()
{
skeletonRenderer = GetComponent<SkeletonRenderer>();
// Populate atlas list
if (skeletonRenderer != null && skeletonRenderer.skeletonDataAsset != null) {
AtlasAsset[] atlasAssets = skeletonRenderer.skeletonDataAsset.atlasAssets;
var initialAtlasMaterialOverrides = new List<AtlasMaterialOverride>();
foreach (AtlasAsset atlasAsset in atlasAssets) {
foreach (Material atlasMaterial in atlasAsset.materials) {
var atlasMaterialOverride = new AtlasMaterialOverride();
atlasMaterialOverride.overrideDisabled = true;
atlasMaterialOverride.originalMaterial = atlasMaterial;
initialAtlasMaterialOverrides.Add(atlasMaterialOverride);
}
}
customMaterialOverrides = initialAtlasMaterialOverrides;
}
}
void Start()
{
instance = this;
_skeletonRenderer = GetComponent<SkeletonRenderer>();
// GetComponent<SkeletonRenderer>().skeleton.FindSlot("hand1_red").Attachment = null;
// GetComponent<SkeletonRenderer>().skeleton.FindSlot("hand1_red").SetToSetupPose();
for(int i = 0; i < _skeletonRenderer.skeleton.slots.Count; i++) {
if(_skeletonRenderer.skeleton.Slots.Items[i].ToString().Contains("red")) {
redSet.Add(_skeletonRenderer.skeleton.Slots.Items[i].ToString());
} else if(_skeletonRenderer.skeleton.Slots.Items[i].ToString().Contains("green")) {
greenSet.Add(_skeletonRenderer.skeleton.Slots.Items[i].ToString());
} else if(_skeletonRenderer.skeleton.Slots.Items[i].ToString().Contains("blue")) {
blueSet.Add(_skeletonRenderer.skeleton.Slots.Items[i].ToString());
} else if(_skeletonRenderer.skeleton.Slots.Items[i].ToString().Contains("white")) {
whiteSet.Add(_skeletonRenderer.skeleton.Slots.Items[i].ToString());
}
}
ChangeSet();
}
static bool UpdateIfSkinMismatch(SkeletonRenderer skeletonRenderer)
{
if (!skeletonRenderer.valid)
{
return(false);
}
var skin = skeletonRenderer.Skeleton.Skin;
string skeletonSkinName = skin != null ? skin.Name : null;
string componentSkinName = skeletonRenderer.initialSkinName;
bool defaultCase = skin == null && string.IsNullOrEmpty(componentSkinName);
bool fieldMatchesSkin = defaultCase || string.Equals(componentSkinName, skeletonSkinName, System.StringComparison.Ordinal);
if (!fieldMatchesSkin)
{
Skin skinToSet = string.IsNullOrEmpty(componentSkinName) ? null : skeletonRenderer.Skeleton.Data.FindSkin(componentSkinName);
skeletonRenderer.Skeleton.Skin = skinToSet;
skeletonRenderer.Skeleton.SetSlotsToSetupPose();
skeletonRenderer.LateUpdate();
return(true);
}
return(false);
}
public override void GatherProperties(PlayableDirector director, IPropertyCollector driver)
{
#if UNITY_EDITOR
SkeletonRenderer trackBinding = director.GetGenericBinding(this) as SkeletonRenderer;
if (trackBinding == null)
{
return;
}
var serializedObject = new UnityEditor.SerializedObject(trackBinding);
var iterator = serializedObject.GetIterator();
while (iterator.NextVisible(true))
{
if (iterator.hasVisibleChildren)
{
continue;
}
driver.AddFromName <SkeletonRenderer>(trackBinding.gameObject, iterator.propertyPath);
}
#endif
base.GatherProperties(director, driver);
}
void Apply(SkeletonRenderer skeletonRenderer)
{
atlas = atlasAsset.GetAtlas();
AtlasAttachmentLoader loader = new AtlasAttachmentLoader(atlas);
float scaleMultiplier = skeletonRenderer.skeletonDataAsset.scale;
var enumerator = attachments.GetEnumerator();
while (enumerator.MoveNext())
{
var entry = (SlotRegionPair)enumerator.Current;
var regionAttachment = loader.NewRegionAttachment(null, entry.region, entry.region);
regionAttachment.Width = regionAttachment.RegionOriginalWidth * scaleMultiplier;
regionAttachment.Height = regionAttachment.RegionOriginalHeight * scaleMultiplier;
regionAttachment.SetColor(new Color(1, 1, 1, 1));
regionAttachment.UpdateOffset();
var slot = skeletonRenderer.skeleton.FindSlot(entry.slot);
slot.Attachment = regionAttachment;
}
}
public static void SetSortingLayer(this GameObject target, string sName)
{
if (target == null)
{
return;
}
SkeletonRenderer skeleton = target.gameObject.GetComponentInChildren <SkeletonRenderer> ();
if (skeleton != null)
{
Renderer render = skeleton.gameObject.GetComponentInChildren <Renderer> ();
if (render != null)
{
render.sortingLayerName = sName;
}
}
SpriteRenderer spRender = target.gameObject.GetComponentInChildren <SpriteRenderer>();
if (spRender != null)
{
spRender.sortingLayerName = sName;
}
}
static void EditorForceReloadSkeletonDataAssetAndComponent(SkeletonRenderer component)
{
if (component == null)
{
return;
}
// Clear all and reload.
if (component.skeletonDataAsset != null)
{
foreach (AtlasAssetBase aa in component.skeletonDataAsset.atlasAssets)
{
if (aa != null)
{
aa.Clear();
}
}
component.skeletonDataAsset.Clear();
}
component.skeletonDataAsset.GetSkeletonData(true);
// Reinitialize.
EditorForceInitializeComponent(component);
}
public override void spinerender(SkeletonRenderer renderer)
{
if (mech_state != MechState.Death)
{
current_skeleton.Skeleton.RootBone.X = CenterPoint.X;
current_skeleton.Skeleton.RootBone.Y = CenterPoint.Y;
if ((int)turret_angle < (int)(angle * 180 / Math.PI))
{
turret_angle++;
}
else if ((int)turret_angle > (int)(angle * 180 / Math.PI))
{
turret_angle--;
}
current_skeleton.Skeleton.RootBone.Rotation = (float)(-1 * turret_angle) - 90.0f;
current_skeleton.Skeleton.RootBone.ScaleX = 1.0f;
current_skeleton.Skeleton.RootBone.ScaleY = 1.0f;
current_skeleton.Skeleton.UpdateWorldTransform();
renderer.Draw(current_skeleton.Skeleton);
}
}
public void Init()
{
skeletonUtility = GetComponent <SkeletonUtility>();
skeletonRenderer = skeletonUtility.GetComponent <SkeletonRenderer>();
skeleton = skeletonRenderer.skeleton;
Skin defaultSkin = skeleton.Data.DefaultSkin;
Skin skin = skeleton.Skin ?? defaultSkin;
bool notDefaultSkin = skin != defaultSkin;
attachmentTable.Clear();
//Debug.Log(skeleton.Slots.Count);
for (int i = skeleton.Slots.Count - 1; i >= 0; i--)
{
var attachments = new List <Attachment>();
attachmentTable.Add(skeleton.Slots.Items[i], attachments);
skin.FindAttachmentsForSlot(i, attachments); // Add skin attachments.
if (notDefaultSkin)
{
defaultSkin.FindAttachmentsForSlot(i, attachments); // Add default skin attachments.
}
}
activeSkin = skeleton.Skin;
}
void Start () {
game = GameObject.Find ("Gui").GetComponent<GameHandler> ();
boxCollider = GetComponent<BoxCollider2D> ();
character = GetComponent<MeshRenderer> ();
controller = GetComponent<Controller2D> ();
anim = GetComponent<SkeletonAnimation> ();
skeleton = anim.skeleton;
arm = skeleton.FindBone ("RShoulder");
backArm = skeleton.FindBone ("LShoulder");
weap = skeleton.FindBone ("Weapon");
skelRend = GetComponent<SkeletonRenderer> ();
skeleton.FindSlot ("WeaponImage").Attachment = null;
anim.state.ClearTrack(1);
controller.CatchPlayer (this);
crouchTap = new TapInfo (.6f, int.MaxValue);
dashTap = new TapInfo (.6f, int.MaxValue);
//Initiate the width of the HP bar, this may need to be placed in the Update portion if window scaling is changed.
width = healthbar.GetComponent<RectTransform>().rect.width;
startMaxXPos = healthbar.GetComponent<RectTransform>().offsetMax.x;
UpdateGravity();
}
void OnEnable()
{
if (skeletonRenderer == null)
{
skeletonRenderer = GetComponent <SkeletonRenderer>();
}
if (skeletonAnimation == null)
{
skeletonAnimation = GetComponent <SkeletonAnimation>();
}
skeletonRenderer.OnReset -= HandleRendererReset;
skeletonRenderer.OnReset += HandleRendererReset;
if (skeletonAnimation != null)
{
skeletonAnimation.UpdateLocal -= UpdateLocal;
skeletonAnimation.UpdateLocal += UpdateLocal;
}
CollectBones();
}
public void LoadContent(ContentManager contentManager)
{
skeletonRenderer = new SkeletonRenderer(App.graphicsDevice);
skeletonRenderer.PremultipliedAlpha = App.globalValues.Alpha;
atlas = new Atlas(App.globalValues.SelectAtlasFile, new XnaTextureLoader(App.graphicsDevice));
if (Common.IsBinaryData(App.globalValues.SelectSpineFile))
{
binary = new SkeletonBinary(atlas);
binary.Scale = App.globalValues.Scale;
skeletonData = binary.ReadSkeletonData(App.globalValues.SelectSpineFile);
}
else
{
json = new SkeletonJson(atlas);
json.Scale = App.globalValues.Scale;
skeletonData = json.ReadSkeletonData(App.globalValues.SelectSpineFile);
}
App.globalValues.SpineVersion = skeletonData.Version;
skeleton = new Skeleton(skeletonData);
Common.SetInitLocation(skeleton.Data.Height);
App.globalValues.FileHash = skeleton.Data.Hash;
stateData = new AnimationStateData(skeleton.Data);
state = new AnimationState(stateData);
List <string> AnimationNames = new List <string>();
listAnimation = state.Data.skeletonData.Animations;
foreach (Animation An in listAnimation)
{
AnimationNames.Add(An.name);
}
App.globalValues.AnimeList = AnimationNames;
List <string> SkinNames = new List <string>();
listSkin = state.Data.skeletonData.Skins;
foreach (Skin Sk in listSkin)
{
SkinNames.Add(Sk.name);
}
App.globalValues.SkinList = SkinNames;
if (App.globalValues.SelectAnimeName != "")
{
state.SetAnimation(0, App.globalValues.SelectAnimeName, App.globalValues.IsLoop);
}
else
{
state.SetAnimation(0, state.Data.skeletonData.animations.Items[0].name, App.globalValues.IsLoop);
}
if (App.isNew)
{
MainWindow.SetCBAnimeName();
}
App.isNew = false;
}
void HandleRender (SkeletonRenderer.SmartMesh.Instruction instruction) {
int rendererCount = partsRenderers.Count;
if (rendererCount <= 0) return;
int rendererIndex = 0;
if (copyPropertyBlock)
mainMeshRenderer.GetPropertyBlock(block);
var submeshInstructions = instruction.submeshInstructions;
var submeshInstructionsItems = submeshInstructions.Items;
int lastSubmeshInstruction = submeshInstructions.Count - 1;
var currentRenderer = partsRenderers[rendererIndex];
bool skeletonRendererCalculateNormals = skeletonRenderer.calculateNormals;
for (int i = 0, start = 0; i <= lastSubmeshInstruction; i++) {
if (submeshInstructionsItems[i].forceSeparate) {
currentRenderer.RenderParts(instruction.submeshInstructions, start, i + 1);
currentRenderer.MeshGenerator.GenerateNormals = skeletonRendererCalculateNormals;
if (copyPropertyBlock)
currentRenderer.SetPropertyBlock(block);
start = i + 1;
rendererIndex++;
if (rendererIndex < rendererCount) {
currentRenderer = partsRenderers[rendererIndex];
} else {
// Not enough renderers. Skip the rest of the instructions.
break;
}
} else if (i == lastSubmeshInstruction) {
currentRenderer.RenderParts(instruction.submeshInstructions, start, i + 1);
currentRenderer.MeshGenerator.GenerateNormals = skeletonRendererCalculateNormals;
if (copyPropertyBlock)
currentRenderer.SetPropertyBlock(block);
}
}
// If too many renderers. Clear the rest.
rendererIndex++;
if (rendererIndex < rendererCount - 1) {
for (int i = rendererIndex; i < rendererCount; i++) {
currentRenderer = partsRenderers[i];
currentRenderer.ClearMesh();
}
}
}
void Start()
{
skeletonRenderer = GetComponentInChildren<SkeletonRenderer> ();
skeletonAnimation = GetComponentInChildren<SkeletonAnimation> ();
rigidbody2d = GetComponentInChildren<Rigidbody2D> ();
collider2d = GetComponentInChildren<Collider2D> ();
//Debug.Log (team + " " + Game.instance.teams + " " + Game.instance.player);
if (isLocalPlayer) {
CmdSetUsername (UsernameStore.username);
username = UsernameStore.username;
}
if (isLocalPlayer) {
skeletonAnimation.state.Event += (Spine.AnimationState state, int trackIndex, Spine.Event e) => {
if (e.Data.name == "Hit") {
CmdHit ();
}
};
}
}
public void HandleResetRenderer(SkeletonRenderer skeletonRenderer)
{
Reset();
}
void UpdateWorld(SkeletonRenderer skeletonRenderer)
{
foreach (var pair in boneTable)
{
var b = pair.Key;
var t = pair.Value;
bool flip = false;
bool flipX = false; //TODO: deal with negative scale instead of Flip Key
bool flipY = false; //TODO: deal with negative scale instead of Flip Key
Bone parentBone = null;
Transform parentTransform = transform;
if (b != startingBone)
{
parentBone = b.Parent;
parentTransform = boneTable[parentBone];
flipX = parentBone.WorldFlipX;
flipY = parentBone.WorldFlipY;
}
else
{
parentBone = b.Parent;
parentTransform = ragdollRoot;
if (b.Parent != null)
{
flipX = b.worldFlipX;
flipY = b.WorldFlipY;
}
else
{
flipX = b.Skeleton.FlipX;
flipY = b.Skeleton.FlipY;
}
}
flip = flipX ^ flipY;
helper.position = parentTransform.position;
helper.rotation = parentTransform.rotation;
helper.localScale = new Vector3(flipX ? -parentTransform.localScale.x : parentTransform.localScale.x, flipY ? -parentTransform.localScale.y : parentTransform.localScale.y, 1);
Vector3 pos = t.position;
pos = helper.InverseTransformPoint(pos);
b.X = Mathf.Lerp(b.X, pos.x, mix);
b.Y = Mathf.Lerp(b.Y, pos.y, mix);
Vector3 right = helper.InverseTransformDirection(t.right);
float a = Mathf.Atan2(right.y, right.x) * Mathf.Rad2Deg;
if (b.WorldFlipX ^ b.WorldFlipY)
{
a *= -1;
}
if (parentBone != null)
{
if ((b.WorldFlipX ^ b.WorldFlipY) != flip)
{
a -= GetCompensatedRotationIK(parentBone) * 2;
}
}
b.Rotation = Mathf.Lerp(b.Rotation, a, mix);
b.RotationIK = Mathf.Lerp(b.rotationIK, a, mix);
}
}
private void LoadContent(ContentManager contentManager)
{
skeletonRenderer = new SkeletonRenderer(_graphicsDevice);
skeletonRenderer.PremultipliedAlpha = App.GV.Alpha;
atlas = new Atlas(App.GV.SelectFile, new XnaTextureLoader(_graphicsDevice));
if (Common.IsBinaryData(App.GV.SelectFile))
{
binary = new SkeletonBinary(atlas);
binary.Scale = App.GV.Scale;
skeletonData = binary.ReadSkeletonData(Common.GetSkelPath(App.GV.SelectFile));
}
else
{
json = new SkeletonJson(atlas);
json.Scale = App.GV.Scale;
skeletonData = json.ReadSkeletonData(Common.GetJsonPath(App.GV.SelectFile));
}
skeleton = new Skeleton(skeletonData);
if (isNew)
{
App.GV.PosX = skeleton.Data.Width;
App.GV.PosY = skeleton.Data.Height;
}
App.GV.FileHash = skeleton.Data.Hash;
stateData = new AnimationStateData(skeleton.Data);
state = new AnimationState(stateData);
if (isRecoding)
{
state.Start += State_Start;
state.Complete += State_Complete;
}
List <string> AnimationNames = new List <string>();
LA = state.Data.skeletonData.Animations;
foreach (Animation An in LA)
{
AnimationNames.Add(An.name);
}
App.GV.AnimeList = AnimationNames;
List <string> SkinNames = new List <string>();
LS = state.Data.skeletonData.Skins;
foreach (Skin Sk in LS)
{
SkinNames.Add(Sk.name);
}
App.GV.SkinList = SkinNames;
if (App.GV.SelectAnimeName != "")
{
state.SetAnimation(0, App.GV.SelectAnimeName, App.GV.IsLoop);
}
else
{
state.SetAnimation(0, state.Data.skeletonData.animations.Items[0].name, App.GV.IsLoop);
}
if (isNew)
{
MainWindow.SetCBAnimeName();
}
isNew = false;
}
void Apply(SkeletonRenderer skeletonRenderer) {
StartCoroutine("Blink");
}
private void Awake()
{
_skeleton = GetComponent <SkeletonRenderer>();
}
public void HandleRebuildRenderer (SkeletonRenderer skeletonRenderer) {
Initialize();
}
public static Bone GetBone(string boneName, SkeletonRenderer renderer)
{
return((renderer.skeleton != null) ? renderer.skeleton.FindBone(boneName) : null);
}
protected override void PopulateMenu(GenericMenu menu, SerializedProperty property, SpineAttachment targetAttribute, SkeletonData data)
{
List <Skin> validSkins = new List <Skin>();
SkeletonRenderer skeletonRenderer = null;
var component = property.serializedObject.targetObject as Component;
if (component != null)
{
if (component.GetComponentInChildren <SkeletonRenderer>() != null)
{
skeletonRenderer = component.GetComponentInChildren <SkeletonRenderer>();
//if (skeletonDataAsset != skeletonRenderer.skeletonDataAsset) Debug.LogWarning("DataField SkeletonDataAsset and SkeletonRenderer/SkeletonAnimation's SkeletonDataAsset do not match. Remove the explicit dataField parameter of your [SpineAttachment] field.");
skeletonDataAsset = skeletonRenderer.skeletonDataAsset;
}
}
if (skeletonRenderer != null && targetAttribute.currentSkinOnly)
{
if (skeletonRenderer.skeleton.Skin != null)
{
validSkins.Add(skeletonRenderer.skeleton.Skin);
}
else
{
validSkins.Add(data.Skins.Items[0]);
}
}
else
{
foreach (Skin skin in data.Skins)
{
if (skin != null)
{
validSkins.Add(skin);
}
}
}
List <string> attachmentNames = new List <string>();
List <string> placeholderNames = new List <string>();
string prefix = "";
if (skeletonRenderer != null && targetAttribute.currentSkinOnly)
{
menu.AddDisabledItem(new GUIContent(skeletonRenderer.gameObject.name + " (SkeletonRenderer)"));
}
else
{
menu.AddDisabledItem(new GUIContent(skeletonDataAsset.name));
}
menu.AddSeparator("");
menu.AddItem(new GUIContent("Null"), property.stringValue == "", HandleSelect, new SpineDrawerValuePair("", property));
menu.AddSeparator("");
Skin defaultSkin = data.Skins.Items[0];
SerializedProperty slotProperty = property.serializedObject.FindProperty(targetAttribute.slotField);
string slotMatch = "";
if (slotProperty != null)
{
if (slotProperty.propertyType == SerializedPropertyType.String)
{
slotMatch = slotProperty.stringValue.ToLower();
}
}
foreach (Skin skin in validSkins)
{
string skinPrefix = skin.Name + "/";
if (validSkins.Count > 1)
{
prefix = skinPrefix;
}
for (int i = 0; i < data.Slots.Count; i++)
{
if (slotMatch.Length > 0 && data.Slots.Items[i].Name.ToLower().Contains(slotMatch) == false)
{
continue;
}
attachmentNames.Clear();
placeholderNames.Clear();
skin.FindNamesForSlot(i, attachmentNames);
if (skin != defaultSkin)
{
defaultSkin.FindNamesForSlot(i, attachmentNames);
skin.FindNamesForSlot(i, placeholderNames);
}
for (int a = 0; a < attachmentNames.Count; a++)
{
string attachmentPath = attachmentNames[a];
string menuPath = prefix + data.Slots.Items[i].Name + "/" + attachmentPath;
string name = attachmentNames[a];
if (targetAttribute.returnAttachmentPath)
{
name = skin.Name + "/" + data.Slots.Items[i].Name + "/" + attachmentPath;
}
if (targetAttribute.placeholdersOnly && placeholderNames.Contains(attachmentPath) == false)
{
menu.AddDisabledItem(new GUIContent(menuPath));
}
else
{
menu.AddItem(new GUIContent(menuPath), name == property.stringValue, HandleSelect, new SpineDrawerValuePair(name, property));
}
}
}
}
}
override public void OnInspectorGUI()
{
if (serializedObject.isEditingMultipleObjects)
{
if (needsReset)
{
needsReset = false;
foreach (var o in targets)
{
var bf = (BoneFollower)o;
bf.Initialize();
bf.LateUpdate();
}
SceneView.RepaintAll();
}
EditorGUI.BeginChangeCheck();
DrawDefaultInspector();
needsReset |= EditorGUI.EndChangeCheck();
return;
}
if (needsReset && UnityEngine.Event.current.type == EventType.Layout)
{
targetBoneFollower.Initialize();
targetBoneFollower.LateUpdate();
needsReset = false;
SceneView.RepaintAll();
}
serializedObject.Update();
// Find Renderer
if (skeletonRenderer.objectReferenceValue == null)
{
SkeletonRenderer parentRenderer = targetBoneFollower.GetComponentInParent <SkeletonRenderer>();
if (parentRenderer != null && parentRenderer.gameObject != targetBoneFollower.gameObject)
{
skeletonRenderer.objectReferenceValue = parentRenderer;
Debug.Log("Inspector automatically assigned BoneFollower.SkeletonRenderer");
}
}
EditorGUILayout.PropertyField(skeletonRenderer);
var skeletonRendererReference = skeletonRenderer.objectReferenceValue as SkeletonRenderer;
if (skeletonRendererReference != null)
{
if (skeletonRendererReference.gameObject == targetBoneFollower.gameObject)
{
skeletonRenderer.objectReferenceValue = null;
EditorUtility.DisplayDialog("Invalid assignment.", "BoneFollower can only follow a skeleton on a separate GameObject.\n\nCreate a new GameObject for your BoneFollower, or choose a SkeletonRenderer from a different GameObject.", "Ok");
}
}
if (targetBoneFollower.valid)
{
EditorGUI.BeginChangeCheck();
EditorGUILayout.PropertyField(boneName);
needsReset |= EditorGUI.EndChangeCheck();
EditorGUILayout.PropertyField(followBoneRotation);
EditorGUILayout.PropertyField(followZPosition);
EditorGUILayout.PropertyField(followLocalScale);
EditorGUILayout.PropertyField(followSkeletonFlip);
}
else
{
var boneFollowerSkeletonRenderer = targetBoneFollower.skeletonRenderer;
if (boneFollowerSkeletonRenderer == null)
{
EditorGUILayout.HelpBox("SkeletonRenderer is unassigned. Please assign a SkeletonRenderer (SkeletonAnimation or SkeletonAnimator).", MessageType.Warning);
}
else
{
boneFollowerSkeletonRenderer.Initialize(false);
if (boneFollowerSkeletonRenderer.skeletonDataAsset == null)
{
EditorGUILayout.HelpBox("Assigned SkeletonRenderer does not have SkeletonData assigned to it.", MessageType.Warning);
}
if (!boneFollowerSkeletonRenderer.valid)
{
EditorGUILayout.HelpBox("Assigned SkeletonRenderer is invalid. Check target SkeletonRenderer, its SkeletonDataAsset or the console for other errors.", MessageType.Warning);
}
}
}
var current = UnityEngine.Event.current;
bool wasUndo = (current.type == EventType.ValidateCommand && current.commandName == "UndoRedoPerformed");
if (wasUndo)
{
targetBoneFollower.Initialize();
}
serializedObject.ApplyModifiedProperties();
}
private void Awake()
{
this.skeletonRenderer = base.GetComponent <SkeletonRenderer>();
}
override public void OnInspectorGUI()
{
if (serializedObject.isEditingMultipleObjects)
{
if (needsReset)
{
needsReset = false;
foreach (var o in targets)
{
var bf = (BoneFollower)o;
bf.Initialize();
bf.LateUpdate();
}
SceneView.RepaintAll();
}
EditorGUI.BeginChangeCheck();
DrawDefaultInspector();
needsReset |= EditorGUI.EndChangeCheck();
return;
}
if (needsReset && Event.current.type == EventType.Layout)
{
targetPointFollower.Initialize();
targetPointFollower.LateUpdate();
needsReset = false;
SceneView.RepaintAll();
}
serializedObject.Update();
DrawDefaultInspector();
// Find Renderer
if (skeletonRenderer.objectReferenceValue == null)
{
SkeletonRenderer parentRenderer = targetPointFollower.GetComponentInParent <SkeletonRenderer>();
if (parentRenderer != null && parentRenderer.gameObject != targetPointFollower.gameObject)
{
skeletonRenderer.objectReferenceValue = parentRenderer;
Debug.Log("Inspector automatically assigned PointFollower.SkeletonRenderer");
}
}
var skeletonRendererReference = skeletonRenderer.objectReferenceValue as SkeletonRenderer;
if (skeletonRendererReference != null)
{
if (skeletonRendererReference.gameObject == targetPointFollower.gameObject)
{
skeletonRenderer.objectReferenceValue = null;
EditorUtility.DisplayDialog("Invalid assignment.", "PointFollower can only follow a skeleton on a separate GameObject.\n\nCreate a new GameObject for your PointFollower, or choose a SkeletonRenderer from a different GameObject.", "Ok");
}
}
if (!targetPointFollower.IsValid)
{
needsReset = true;
}
var current = Event.current;
bool wasUndo = (current.type == EventType.ValidateCommand && current.commandName == "UndoRedoPerformed");
if (wasUndo)
{
targetPointFollower.Initialize();
}
serializedObject.ApplyModifiedProperties();
}
public static T NewSpineGameObject <T> (SkeletonDataAsset skeletonDataAsset) where T : SkeletonRenderer
{
return(SkeletonRenderer.AddSpineComponent <T>(new GameObject("New Spine GameObject"), skeletonDataAsset));
}
void Awake()
{
skeletonRenderer = GetComponent <SkeletonRenderer>();
}
public void HandleResetRenderer(SkeletonRenderer skeletonRenderer)
{
Reset();
}
protected virtual void DrawInspectorGUI()
{
// JOHN: todo: support multiediting.
SkeletonRenderer component = (SkeletonRenderer)target;
using (new EditorGUILayout.HorizontalScope()) {
EditorGUILayout.PropertyField(skeletonDataAsset);
const string ReloadButtonLabel = "Reload";
float reloadWidth = GUI.skin.label.CalcSize(new GUIContent(ReloadButtonLabel)).x + 20;
if (GUILayout.Button(ReloadButtonLabel, GUILayout.Width(reloadWidth)))
{
if (component.skeletonDataAsset != null)
{
foreach (AtlasAsset aa in component.skeletonDataAsset.atlasAssets)
{
if (aa != null)
{
aa.Reset();
}
}
component.skeletonDataAsset.Reset();
}
component.Initialize(true);
}
}
if (!component.valid)
{
component.Initialize(true);
component.LateUpdate();
if (!component.valid)
{
return;
}
}
#if NO_PREFAB_MESH
if (meshFilter == null)
{
meshFilter = component.GetComponent <MeshFilter>();
}
if (isInspectingPrefab)
{
meshFilter.sharedMesh = null;
}
#endif
// Initial skin name.
{
string[] skins = new string[component.skeleton.Data.Skins.Count];
int skinIndex = 0;
for (int i = 0; i < skins.Length; i++)
{
string skinNameString = component.skeleton.Data.Skins.Items[i].Name;
skins[i] = skinNameString;
if (skinNameString == initialSkinName.stringValue)
{
skinIndex = i;
}
}
skinIndex = EditorGUILayout.Popup("Initial Skin", skinIndex, skins);
initialSkinName.stringValue = skins[skinIndex];
}
EditorGUILayout.Space();
// Sorting Layers
SpineInspectorUtility.SortingPropertyFields(sortingProperties, applyModifiedProperties: true);
// More Render Options...
using (new EditorGUILayout.VerticalScope(EditorStyles.helpBox)) {
EditorGUI.indentLevel++;
advancedFoldout = EditorGUILayout.Foldout(advancedFoldout, "Advanced");
if (advancedFoldout)
{
EditorGUI.indentLevel++;
SeparatorsField(separatorSlotNames);
EditorGUILayout.PropertyField(meshes,
new GUIContent("Render MeshAttachments", "Disable to optimize rendering for skeletons that don't use Mesh Attachments"));
EditorGUILayout.PropertyField(immutableTriangles,
new GUIContent("Immutable Triangles", "Enable to optimize rendering for skeletons that never change attachment visbility"));
EditorGUILayout.Space();
const float MinZSpacing = -0.1f;
const float MaxZSpacing = 0f;
EditorGUILayout.Slider(zSpacing, MinZSpacing, MaxZSpacing);
// Optional fields. May be disabled in SkeletonRenderer.
if (normals != null)
{
EditorGUILayout.PropertyField(normals, new GUIContent("Add Normals"));
}
if (tangents != null)
{
EditorGUILayout.PropertyField(tangents, new GUIContent("Solve Tangents"));
}
if (frontFacing != null)
{
EditorGUILayout.PropertyField(frontFacing);
}
EditorGUI.indentLevel--;
}
EditorGUI.indentLevel--;
}
}
void HandleSkeletonReset (SkeletonRenderer r) {
if (parentRenderer != null)
Initialize(parentRenderer);
}
void Apply(SkeletonRenderer skeletonRenderer)
{
StartCoroutine("Blink");
}
void UpdateComplete(SkeletonRenderer anim)
{
UpdateAllBones();
}
public static Spine.Bone GetBone(string boneName, SkeletonRenderer renderer) {
if (renderer.skeleton == null)
return null;
return renderer.skeleton.FindBone(boneName);
}
override public void OnInspectorGUI()
{
if (needsReset)
{
targetBoneFollower.Initialize();
targetBoneFollower.LateUpdate();
needsReset = false;
SceneView.RepaintAll();
}
serializedObject.Update();
// Find Renderer
if (skeletonRenderer.objectReferenceValue == null)
{
SkeletonRenderer parentRenderer = BoneFollowerInspector.GetInParent <SkeletonRenderer>(targetBoneFollower.transform);
if (parentRenderer != null)
{
Debug.Log("Inspector automatically assigned BoneFollower.SkeletonRenderer");
skeletonRenderer.objectReferenceValue = parentRenderer;
}
}
EditorGUILayout.PropertyField(skeletonRenderer);
if (targetBoneFollower.valid)
{
EditorGUI.BeginChangeCheck();
EditorGUILayout.PropertyField(boneName);
if (EditorGUI.EndChangeCheck())
{
serializedObject.ApplyModifiedProperties();
needsReset = true;
serializedObject.Update();
}
EditorGUILayout.PropertyField(followBoneRotation);
EditorGUILayout.PropertyField(followZPosition);
}
else
{
var boneFollowerSkeletonRenderer = targetBoneFollower.skeletonRenderer;
if (boneFollowerSkeletonRenderer == null)
{
EditorGUILayout.HelpBox("SkeletonRenderer is unassigned. Please assign a SkeletonRenderer (SkeletonAnimation or SkeletonAnimator).", MessageType.Warning);
}
else
{
boneFollowerSkeletonRenderer.Initialize(false);
if (boneFollowerSkeletonRenderer.skeletonDataAsset == null)
{
EditorGUILayout.HelpBox("Assigned SkeletonRenderer does not have SkeletonData assigned to it.", MessageType.Warning);
}
if (!boneFollowerSkeletonRenderer.valid)
{
EditorGUILayout.HelpBox("Assigned SkeletonRenderer is invalid. Check target SkeletonRenderer, its SkeletonDataAsset or the console for other errors.", MessageType.Warning);
}
}
}
var current = UnityEngine.Event.current;
bool wasUndo = (current.type == EventType.ValidateCommand && current.commandName == "UndoRedoPerformed");
if (serializedObject.ApplyModifiedProperties() || wasUndo)
{
targetBoneFollower.Initialize();
}
}
public void Draw()
{
if (App.GV.SpineVersion != "3.6.53" || App.GV.FileHash != skeleton.Data.Hash)
{
state = null;
skeletonRenderer = null;
return;
}
App.graphicsDevice.Clear(Color.Transparent);
Player.DrawBG(ref App.spriteBatch);
state.Update(App.GV.Speed / 1000f);
if (binary != null)
{
if (App.GV.Scale != binary.Scale)
{
binary.Scale = App.GV.Scale;
skeletonData = binary.ReadSkeletonData(Common.GetSkelPath(App.GV.SelectFile));
skeleton = new Skeleton(skeletonData);
}
}
else if (json != null)
{
if (App.GV.Scale != json.Scale)
{
json.Scale = App.GV.Scale;
skeletonData = json.ReadSkeletonData(Common.GetJsonPath(App.GV.SelectFile));
skeleton = new Skeleton(skeletonData);
}
}
skeleton.X = App.GV.PosX;
skeleton.Y = App.GV.PosY;
skeleton.FlipX = App.GV.FilpX;
skeleton.FlipY = App.GV.FilpY;
skeleton.RootBone.Rotation = App.GV.Rotation;
skeleton.UpdateWorldTransform();
state.TimeScale = App.GV.TimeScale;
state.Apply(skeleton);
skeletonRenderer.PremultipliedAlpha = App.GV.Alpha;
if (skeletonRenderer.Effect is BasicEffect)
{
((BasicEffect)skeletonRenderer.Effect).Projection = Matrix.CreateOrthographicOffCenter(0, App.graphicsDevice.Viewport.Width, App.graphicsDevice.Viewport.Height, 0, 1, 0);
}
else
{
skeletonRenderer.Effect.Parameters["Projection"].SetValue(Matrix.CreateOrthographicOffCenter(0, App.graphicsDevice.Viewport.Width, App.graphicsDevice.Viewport.Height, 0, 1, 0));
}
skeletonRenderer.Begin();
skeletonRenderer.Draw(skeleton);
skeletonRenderer.End();
if (state != null)
{
TrackEntry entry = state.GetCurrent(0);
if (entry != null)
{
if (App.GV.IsRecoding && App.GV.GifList != null && !entry.IsComplete)
{
if (App.GV.GifList.Count == 0)
{
TrackEntry te = state.GetCurrent(0);
te.trackTime = 0;
App.GV.TimeScale = 1;
App.GV.Lock = 0;
}
App.GV.GifList.Add(Common.TakeRecodeScreenshot(App.graphicsDevice));
}
if (App.GV.IsRecoding && entry.IsComplete)
{
state.TimeScale = 0;
App.GV.IsRecoding = false;
Common.RecodingEnd(entry.AnimationEnd);
state.TimeScale = 1;
App.GV.TimeScale = 1;
}
if (App.GV.TimeScale == 0)
{
entry.TrackTime = entry.AnimationEnd * App.GV.Lock;
entry.TimeScale = 0;
}
else
{
App.GV.Lock = entry.AnimationTime / entry.AnimationEnd;
entry.TimeScale = 1;
}
App.GV.LoadingProcess = $"{ Math.Round(entry.AnimationTime / entry.AnimationEnd * 100, 2)}%";
}
}
}
void Reset () {
if (skeletonRenderer == null)
skeletonRenderer = GetComponent<SkeletonRenderer>();
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label) {
if (property.propertyType != SerializedPropertyType.String) {
EditorGUI.LabelField(position, "ERROR:", "May only apply to type string");
return;
}
SpineAttachment attrib = (SpineAttachment)attribute;
var dataProperty = property.serializedObject.FindProperty(attrib.dataField);
if (dataProperty != null) {
if (dataProperty.objectReferenceValue is SkeletonDataAsset) {
skeletonDataAsset = (SkeletonDataAsset)dataProperty.objectReferenceValue;
} else if (dataProperty.objectReferenceValue is SkeletonRenderer) {
var renderer = (SkeletonRenderer)dataProperty.objectReferenceValue;
if (renderer != null)
skeletonDataAsset = renderer.skeletonDataAsset;
else {
EditorGUI.LabelField(position, "ERROR:", "No SkeletonRenderer");
}
} else {
EditorGUI.LabelField(position, "ERROR:", "Invalid reference type");
return;
}
} else if (property.serializedObject.targetObject is Component) {
var component = (Component)property.serializedObject.targetObject;
if (component.GetComponentInChildren<SkeletonRenderer>() != null) {
skeletonRenderer = component.GetComponentInChildren<SkeletonRenderer>();
skeletonDataAsset = skeletonRenderer.skeletonDataAsset;
}
}
if (skeletonDataAsset == null && skeletonRenderer == null) {
EditorGUI.LabelField(position, "ERROR:", "Must have reference to a SkeletonDataAsset or SkeletonRenderer");
return;
}
position = EditorGUI.PrefixLabel(position, label);
if (GUI.Button(position, property.stringValue, EditorStyles.popup)) {
Selector(property);
}
}
public static void SetSeparatorSlotNames(SkeletonRenderer skeletonRenderer, string[] newSlotNames)
{
var field = SpineInspectorUtility.GetNonPublicField(typeof(SkeletonRenderer), SeparatorSlotNamesFieldName);
field.SetValue(skeletonRenderer, newSlotNames);
}
void HandleRender (SkeletonRenderer.SmartMesh.Instruction instruction) {
int rendererCount = partsRenderers.Count;
if (rendererCount <= 0) return;
int rendererIndex = 0;
if (copyPropertyBlock)
mainMeshRenderer.GetPropertyBlock(copiedBlock);
var submeshInstructions = instruction.submeshInstructions;
var submeshInstructionsItems = submeshInstructions.Items;
int lastSubmeshInstruction = submeshInstructions.Count - 1;
var currentRenderer = partsRenderers[rendererIndex];
bool addNormals = skeletonRenderer.calculateNormals;
bool addTangents = skeletonRenderer.calculateTangents;
for (int si = 0, start = 0; si <= lastSubmeshInstruction; si++) {
if (submeshInstructionsItems[si].forceSeparate || si == lastSubmeshInstruction) {
// Apply properties
var meshGenerator = currentRenderer.MeshGenerator;
meshGenerator.AddNormals = addNormals;
meshGenerator.AddTangents = addTangents;
if (copyPropertyBlock)
currentRenderer.SetPropertyBlock(copiedBlock);
// Render
currentRenderer.RenderParts(instruction.submeshInstructions, start, si + 1);
start = si + 1;
rendererIndex++;
if (rendererIndex < rendererCount) {
currentRenderer = partsRenderers[rendererIndex];
} else {
// Not enough renderers. Skip the rest of the instructions.
break;
}
}
}
// Clear extra renderers if they exist.
for (; rendererIndex < rendererCount; rendererIndex++) {
partsRenderers[rendererIndex].ClearMesh();
}
}
protected override void LoadContent()
{
// Two color tint effect, comment line 80 to disable
var spineEffect = Content.Load <Effect>("Content\\SpineEffect");
spineEffect.Parameters["World"].SetValue(Matrix.Identity);
spineEffect.Parameters["View"].SetValue(Matrix.CreateLookAt(new Vector3(0.0f, 0.0f, 1.0f), Vector3.Zero, Vector3.Up));
skeletonRenderer = new SkeletonRenderer(GraphicsDevice);
skeletonRenderer.PremultipliedAlpha = false;
skeletonRenderer.Effect = spineEffect;
// String name = "spineboy-ess";
// String name = "goblins-pro";
// String name = "raptor-pro";
// String name = "tank-pro";
String name = "raptor-pro";
String atlasName = name.Replace("-pro", "").Replace("-ess", "");
bool binaryData = false;
Atlas atlas = new Atlas(assetsFolder + atlasName + ".atlas", new XnaTextureLoader(GraphicsDevice));
float scale = 1;
if (name == "spineboy-ess")
{
scale = 0.6f;
}
if (name == "raptor-pro")
{
scale = 0.5f;
}
if (name == "tank-pro")
{
scale = 0.3f;
}
if (name == "coin-pro")
{
scale = 1;
}
SkeletonData skeletonData;
if (binaryData)
{
SkeletonBinary binary = new SkeletonBinary(atlas);
binary.Scale = scale;
skeletonData = binary.ReadSkeletonData(assetsFolder + name + ".skel");
}
else
{
SkeletonJson json = new SkeletonJson(atlas);
json.Scale = scale;
skeletonData = json.ReadSkeletonData(assetsFolder + name + ".json");
}
skeleton = new Skeleton(skeletonData);
if (name == "goblins-pro")
{
skeleton.SetSkin("goblin");
}
// Define mixing between animations.
AnimationStateData stateData = new AnimationStateData(skeleton.Data);
state = new AnimationState(stateData);
if (name == "spineboy-ess")
{
stateData.SetMix("run", "jump", 0.2f);
stateData.SetMix("jump", "run", 0.4f);
// Event handling for all animations.
state.Start += Start;
state.End += End;
state.Complete += Complete;
state.Event += Event;
state.SetAnimation(0, "walk", false);
TrackEntry entry = state.AddAnimation(0, "jump", false, 0);
entry.End += End; // Event handling for queued animations.
state.AddAnimation(0, "run", true, 0);
}
else if (name == "raptor-pro")
{
state.SetAnimation(0, "walk", true);
state.AddAnimation(1, "gun-grab", false, 2);
}
else if (name == "coin-pro")
{
state.SetAnimation(0, "rotate", true);
}
else if (name == "tank-pro")
{
state.SetAnimation(0, "drive", true);
}
else
{
state.SetAnimation(0, "walk", true);
}
skeleton.X = 400 + (name == "tank-pro" ? 300 : 0);
skeleton.Y = GraphicsDevice.Viewport.Height;
skeleton.UpdateWorldTransform();
headSlot = skeleton.FindSlot("head");
}
void UpdateWorld (SkeletonRenderer skeletonRenderer) {
foreach (var pair in boneTable) {
var b = pair.Key;
var t = pair.Value;
bool flip = false;
bool flipX = false; //TODO: deal with negative scale instead of Flip Key
bool flipY = false; //TODO: deal with negative scale instead of Flip Key
Bone parentBone = null;
Transform parentTransform = transform;
if (b != startingBone) {
parentBone = b.Parent;
parentTransform = boneTable[parentBone];
flipX = parentBone.WorldFlipX;
flipY = parentBone.WorldFlipY;
} else {
parentBone = b.Parent;
parentTransform = ragdollRoot;
if (b.Parent != null) {
flipX = b.worldFlipX;
flipY = b.WorldFlipY;
} else {
flipX = b.Skeleton.FlipX;
flipY = b.Skeleton.FlipY;
}
}
flip = flipX ^ flipY;
helper.position = parentTransform.position;
helper.rotation = parentTransform.rotation;
helper.localScale = new Vector3(flipX ? -parentTransform.localScale.x : parentTransform.localScale.x, flipY ? -parentTransform.localScale.y : parentTransform.localScale.y, 1);
Vector3 pos = t.position;
pos = helper.InverseTransformPoint(pos);
b.X = Mathf.Lerp(b.X, pos.x, mix);
b.Y = Mathf.Lerp(b.Y, pos.y, mix);
Vector3 right = helper.InverseTransformDirection(t.right);
float a = Mathf.Atan2(right.y, right.x) * Mathf.Rad2Deg;
if (b.WorldFlipX ^ b.WorldFlipY) {
a *= -1;
}
if (parentBone != null) {
if ((b.WorldFlipX ^ b.WorldFlipY) != flip) {
a -= GetCompensatedRotationIK(parentBone) * 2;
}
}
b.Rotation = Mathf.Lerp(b.Rotation, a, mix);
b.RotationIK = Mathf.Lerp(b.rotationIK, a, mix);
}
}
protected virtual void DrawInspectorGUI()
{
SkeletonRenderer component = (SkeletonRenderer)target;
EditorGUILayout.BeginHorizontal();
EditorGUILayout.PropertyField(skeletonDataAsset);
float reloadWidth = GUI.skin.label.CalcSize(new GUIContent("Reload")).x + 20;
if (GUILayout.Button("Reload", GUILayout.Width(reloadWidth)))
{
if (component.skeletonDataAsset != null)
{
foreach (AtlasAsset aa in component.skeletonDataAsset.atlasAssets)
{
if (aa != null)
{
aa.Reset();
}
}
component.skeletonDataAsset.Reset();
}
component.Initialize(true);
}
EditorGUILayout.EndHorizontal();
if (!component.valid)
{
component.Initialize(true);
component.LateUpdate();
if (!component.valid)
{
return;
}
}
// Initial skin name.
{
String[] skins = new String[component.skeleton.Data.Skins.Count];
int skinIndex = 0;
for (int i = 0; i < skins.Length; i++)
{
String name = component.skeleton.Data.Skins.Items[i].Name;
skins[i] = name;
if (name == initialSkinName.stringValue)
{
skinIndex = i;
}
}
skinIndex = EditorGUILayout.Popup("Initial Skin", skinIndex, skins);
initialSkinName.stringValue = skins[skinIndex];
}
EditorGUILayout.Space();
// Sorting Layers
{
var renderer = component.GetComponent <Renderer>();
if (renderer != null)
{
EditorGUI.BeginChangeCheck();
if (EditorGUILayoutSortingLayerField != null && sortingLayerIDProperty != null)
{
EditorGUILayoutSortingLayerField.Invoke(null, new object[] { new GUIContent("Sorting Layer"), sortingLayerIDProperty, EditorStyles.popup });
}
else
{
renderer.sortingLayerID = EditorGUILayout.IntField("Sorting Layer ID", renderer.sortingLayerID);
}
renderer.sortingOrder = EditorGUILayout.IntField("Order in Layer", renderer.sortingOrder);
if (EditorGUI.EndChangeCheck())
{
rendererSerializedObject.ApplyModifiedProperties();
EditorUtility.SetDirty(renderer);
}
}
}
// More Render Options...
{
advancedFoldout = EditorGUILayout.Foldout(advancedFoldout, "Advanced");
if (advancedFoldout)
{
EditorGUI.indentLevel++;
EditorGUILayout.PropertyField(submeshSeparators, true);
EditorGUILayout.Space();
EditorGUILayout.PropertyField(meshes,
new GUIContent("Render Mesh Attachments", "Disable to optimize rendering for skeletons that don't use Mesh Attachments"));
EditorGUILayout.PropertyField(immutableTriangles,
new GUIContent("Immutable Triangles", "Enable to optimize rendering for skeletons that never change attachment visbility"));
EditorGUILayout.Space();
const float MinZSpacing = -0.1f;
const float MaxZSpacing = 0f;
EditorGUILayout.Slider(zSpacing, MinZSpacing, MaxZSpacing);
EditorGUILayout.PropertyField(normals);
EditorGUILayout.PropertyField(tangents);
EditorGUILayout.PropertyField(front);
EditorGUILayout.Separator();
EditorGUI.indentLevel--;
}
}
}
public static string[] GetSeparatorSlotNames(SkeletonRenderer skeletonRenderer)
{
var field = SpineInspectorUtility.GetNonPublicField(typeof(SkeletonRenderer), SeparatorSlotNamesFieldName);
return(field.GetValue(skeletonRenderer) as string[]);
}
void Awake () {
skeletonRenderer = GetComponent<SkeletonRenderer>();
}
void HandleRebuild (SkeletonRenderer sr) {
//if (BoundingBoxFollower.DebugMessages) Debug.Log("Skeleton was rebuilt. Repopulating BoundingBoxFollower.");
Initialize();
}
public virtual void Reset()
{
if (this.meshFilter != null)
{
this.meshFilter.set_sharedMesh(null);
}
this.meshRenderer = base.GetComponent <MeshRenderer>();
if (this.meshRenderer != null)
{
this.meshRenderer.set_sharedMaterial(null);
}
if (this.mesh1 != null)
{
if (Application.get_isPlaying())
{
Object.Destroy(this.mesh1);
}
else
{
Object.DestroyImmediate(this.mesh1);
}
}
if (this.mesh2 != null)
{
if (Application.get_isPlaying())
{
Object.Destroy(this.mesh2);
}
else
{
Object.DestroyImmediate(this.mesh2);
}
}
this.meshState = new SkeletonRenderer.MeshState();
this.mesh1 = null;
this.mesh2 = null;
this.vertices = null;
this.colors = null;
this.uvs = null;
this.sharedMaterials = new Material[0];
this.submeshMaterials.Clear(true);
this.submeshes.Clear(true);
this.skeleton = null;
this.valid = false;
if (!this.skeletonDataAsset)
{
if (this.logErrors)
{
Debug.LogError("Missing SkeletonData asset.", this);
}
return;
}
SkeletonData skeletonData = this.skeletonDataAsset.GetSkeletonData(false);
if (skeletonData == null)
{
return;
}
this.valid = true;
this.meshFilter = base.GetComponent <MeshFilter>();
this.meshRenderer = base.GetComponent <MeshRenderer>();
this.mesh1 = SkeletonRenderer.newMesh();
this.mesh2 = SkeletonRenderer.newMesh();
this.vertices = new Vector3[0];
this.skeleton = new Skeleton(skeletonData);
if (this.initialSkinName != null && this.initialSkinName.get_Length() > 0 && this.initialSkinName != "default")
{
this.skeleton.SetSkin(this.initialSkinName);
}
this.submeshSeparatorSlots.Clear();
for (int i = 0; i < this.submeshSeparators.Length; i++)
{
this.submeshSeparatorSlots.Add(this.skeleton.FindSlot(this.submeshSeparators[i]));
}
this.CollectSubmeshRenderers();
this.LateUpdate();
if (this.OnReset != null)
{
this.OnReset(this);
}
}
