Hello, I am writing to get some help from you Dear Spine masters 🙂
Spine animations are being planned as a center of our Godot indie game but only few active Spine animations on the scren initialized manually (not with the Scene loading) ends immediately with significant (and I mean SIGNIFICANT) frame drops...
Before activating Spine animation it was 120 FPS
4 FPS on GF GTX 1050Ti after executing Spine animations
Worth to mention, we use 3D hack mentioned on that forum (Mesh3D + Texture from SubViewport) which bypass Spine-library limitation in 3D games and C# scripts, and - what is very important - we are initializing Spine animation on-the fly, not when Scene loading. Although performance seems to be much better when Spine animations initialize with scene, but - unfortunately - we cannot do that in that way.
At the beginning we thought the issue is with 2 things:
- Average Spine atlas size (2030x1297 px) - but, be honest, doesn't seems to be big nowadays
- Amount of Spine animations on the screen - 348 animated trees
Ok. At this point you may think - those guys are crazy to have 348 active animations on the screen.
Agree...
First we were trying to scale down Atlas image size twice - no satisfying effect.
Then, we limited amount of visible and active nodes with Spine animation
We did a lot of optimization (hide Spine animations arround your character)
35 Spine animations on the screen - 8 FPS
So we limited even more...
3 Spine animation - 27 FPS
Enough. Should be at least 60FPS! We need help!
I am attaching raw code which is doing initialization of Spine animation (nothing sophisticated but should show the problem)
using Godot;
using System;
using System.Collections.Generic;
using System.Linq;
using Vector2 = Godot.Vector2;
using Vector3 = Godot.Vector3;
public partial class OnFlyLoadedSpineSprite : Node3D
{
public SpineSkeletonDataResource SpineSkeletonDataResource { get; set; } = new SpineSkeletonDataResource();
[Export]
public SpineAtlasResource AtlasResource
{
get => SpineSkeletonDataResource.AtlasRes;
set
{
SpineAtlasResource spineAtlasResource = value;
SpineSkeletonDataResource.AtlasRes = spineAtlasResource;
}
}
[Export]
public SpineSkeletonFileResource SkeletonFileResource
{
get => SpineSkeletonDataResource.SkeletonFileRes;
set
{
SpineSkeletonFileResource spineSkeletonFileResource = value;
SpineSkeletonDataResource.SkeletonFileRes = spineSkeletonFileResource;
}
}
[Export] bool Mirrored { get; set; }
[Export] public string NameOfAnimationToPlay { get; set; } = "idle";
[Export(PropertyHint.Range, "0,100,")] public int DeviationPercent = 0;
[Export] public float SortingOffset { get; set; } = 50.0f;
public const float PixelToMeterConversionRatio = 0.01f;
private const int DefaultTrackId = 0;
public MeshInstance3D MeshInstance3D { get; set; }
public SubViewport SubViewport { get; set; }
public SpineSprite SpineAnimationSprite { get; set; }
public void InitializeSpineAnimation()
{
SpineAnimationSprite = new SpineSprite()
{
SkeletonDataRes = SpineSkeletonDataResource,
UpdateMode = SpineConstant.UpdateMode.Process
};
if (Mirrored)
{
SpineAnimationSprite.Scale = new(-1 * SpineAnimationSprite.Scale.X, 1 * SpineAnimationSprite.Scale.Y);
}
var state = SpineAnimationSprite.GetAnimationState();
state?.SetAnimation(NameOfAnimationToPlay, true, DefaultTrackId);
var subViewportSize = CalculateSubViewportSize();
var (meshSizeWithoutDeviation, meshSize) = CalculateMeshSize();
var subviewport = new SubViewport()
{
TransparentBg = true,
Size = subViewportSize
};
SubViewport = subviewport;
SpineAnimationSprite.Position = new Vector2(subViewportSize.X / 2.0f, subViewportSize.Y);
MeshInstance3D = new MeshInstance3D()
{
Mesh = new QuadMesh()
{
Size = meshSize,
CenterOffset = new Vector3(meshSizeWithoutDeviation.X / 2.0f, meshSize.Y / 2.0f, 0)
},
Scale = Vector3.One,
SortingOffset = SortingOffset
};
var material = new StandardMaterial3D()
{
Transparency = BaseMaterial3D.TransparencyEnum.Alpha,
AlphaScissorThreshold = 0f,
ShadingMode = BaseMaterial3D.ShadingModeEnum.Unshaded,
};
Texture2D texture = SubViewport.GetTexture();
material.AlbedoTexture = texture;
MeshInstance3D.MaterialOverride = material;
this.AddChild(MeshInstance3D);
MeshInstance3D.Owner = this;
MeshInstance3D.AddChild(SubViewport);
SubViewport.Owner = MeshInstance3D;
SubViewport.AddChild(SpineAnimationSprite);
SpineAnimationSprite.Owner = SubViewport;
SpineAnimationSprite.Visible = true;
MeshInstance3D.Visible = true;
}
private Vector2I CalculateSubViewportSize()
{
var skeletonSize = SpineAnimationSprite.GetSkeleton().GetBounds().Size;
var subViewportSize = new Vector2I((int)skeletonSize.X + 1, (int)skeletonSize.Y + 1);
if (DeviationPercent > 0)
{
var deviationX = subViewportSize.X * (DeviationPercent / 100.0f);
var deviationY = subViewportSize.Y * (DeviationPercent / 100.0f);
var deviation = new Vector2I((int)deviationX + 1, (int)deviationY + 1);
subViewportSize = subViewportSize + deviation;
}
return subViewportSize;
}
private List<Node> spritesDisplayedBeforeAnimationStarted = new List<Node>();
private Tuple<Vector2, Vector2> CalculateMeshSize()
{
this.spritesDisplayedBeforeAnimationStarted = this.GetChildren().Where(x => x is Sprite3D).ToList();
Vector2 meshSize;
if (spritesDisplayedBeforeAnimationStarted == null || spritesDisplayedBeforeAnimationStarted.Count == 0)
{
meshSize = SpineAnimationSprite.GetSkeleton().GetBounds().Size;
}
else
{
var firstSprite = (Sprite3D)spritesDisplayedBeforeAnimationStarted.FirstOrDefault(x => x is Sprite3D);
meshSize = firstSprite.Texture.GetSize();
}
meshSize *= PixelToMeterConversionRatio;
var meshSizeWithoutDeviation = meshSize;
if (DeviationPercent > 0)
{
var deviation = meshSize * (DeviationPercent / 100.0f);
meshSize += deviation;
}
return new Tuple<Vector2, Vector2>(meshSizeWithoutDeviation, meshSize);
}
}
