public void Render(JOBJManager jobjManager, List <SBM_Hurtbox> hurtboxes, HSDAccessor selected, Dictionary <int, int> states = null, int bodyState = -1)
{
foreach (SBM_Hurtbox v in hurtboxes)
{
var clr = HurtboxColor;
var a = 0.25f;
if (selected == v)
{
clr = SelectedHurtboxColor;
a = 0.6f;
}
if (states != null)
{
if (states.ContainsKey(v.BoneIndex))
{
switch (states[v.BoneIndex])
{
case 1:
clr = InvulColor;
break;
case 2:
clr = IntanColor;
break;
}
}
}
if (bodyState == 1)
{
clr = InvulColor;
}
if (bodyState == 2)
{
clr = IntanColor;
}
var transform = jobjManager.GetWorldTransform(v.BoneIndex);
if (!HurtboxToCapsule.ContainsKey(v))
{
HurtboxToCapsule.Add(v, new Capsule(new Vector3(v.X1, v.Y1, v.Z1), new Vector3(v.X2, v.Y2, v.Z2), v.Size));
}
var cap = HurtboxToCapsule[v];
cap.SetParameters(new Vector3(v.X1, v.Y1, v.Z1), new Vector3(v.X2, v.Y2, v.Z2), v.Size);
cap.Draw(transform, new Vector4(clr, a));
}
}
/// <summary>
///
/// </summary>
/// <param name="offset"></param>
/// <param name="size"></param>
private void LoadAnimation(string symbol)
{
// clear animation
JointManager.SetFigaTree(null);
// check if animation exists
if (symbol == null || !SymbolToAnimation.ContainsKey(symbol))
{
return;
}
// load animation
var anim = new HSDRawFile(SymbolToAnimation[symbol]);
if (anim.Roots[0].Data is HSD_FigaTree tree)
{
var name = new Action()
{
Symbol = anim.Roots[0].Name
}.ToString();
JointManager.SetFigaTree(tree);
_animEditor.SetJoint(JointManager.GetJOBJ(0), JointManager.Animation);
viewport.MaxFrame = tree.FrameCount;
ThrowDummyManager.CleanupRendering();
ThrowDummyManager = new JOBJManager();
//AnimationName = name;
// load throw dummy for thrown animations
if (name.Contains("Throw") && !name.Contains("Taro"))
{
// find thrown anim
Action throwAction = null;
foreach (Action a in actionList.Items)
{
if (a.Symbol != null && a.Symbol.Contains("Taro") && a.Symbol.Contains(name) && !a.Symbol.Equals(anim.Roots[0].Name))
{
throwAction = a;
break;
}
}
if (throwAction != null && throwAction.Symbol != null && SymbolToAnimation.ContainsKey(throwAction.Symbol))
{
// load throw dummy
ThrowDummyManager.SetJOBJ(DummyThrowModel.GenerateThrowDummy());
// load throw animation
var tanim = new HSDRawFile(SymbolToAnimation[throwAction.Symbol]);
if (tanim.Roots[0].Data is HSD_FigaTree tree2)
{
ThrowDummyManager.SetFigaTree(tree2);
}
}
}
}
}
/// <summary>
///
/// </summary>
/// <param name="table"></param>
/// <param name="icons"></param>
/// <returns></returns>
public static MEX_mexSelectChr GenerateMEXMapFromVanilla(SBM_SelectChrDataTable table, MEX_CSSIconEntry[] icons)
{
// generate icon model
var icon_joint = HSDAccessor.DeepClone <HSD_JOBJ>(table.MenuModel.Children[2].Child);
icon_joint.TX = 0;
icon_joint.TY = 0;
icon_joint.TZ = 0;
icon_joint.Next = null;
var center = RegenerateIcon(icon_joint);
var icon_matanim_joint = HSDAccessor.DeepClone <HSD_MatAnimJoint>(table.MenuMaterialAnimation.Children[2].Child);
icon_matanim_joint.Next = null;
// generate mat anim node
var joints = table.MenuModel.BreathFirstList;
HSD_TOBJ[] tobjs = new HSD_TOBJ[icons.Max(e => e.FighterExternalID) + 1];
JOBJManager m = new JOBJManager();
m.SetJOBJ(table.MenuModel);
m.SetAnimJoint(table.MenuAnimation);
m.Frame = 600;
m.UpdateNoRender();
var csps = table.MenuMaterialAnimation.Children[6].Child.MaterialAnimation.TextureAnimation.ToTOBJs();
var cspKeys = table.MenuMaterialAnimation.Children[6].Child.MaterialAnimation.TextureAnimation.AnimationObject.FObjDesc.GetDecodedKeys();
var stride = 30;
foreach (var ico in icons)
{
if (joints[ico.icon.JointID].Dobj == null)
{
continue;
}
HSD_JOBJ pos = HSDAccessor.DeepClone <HSD_JOBJ>(icon_joint);
pos.Dobj.Pobj.Attributes = icon_joint.Dobj.Pobj.Attributes;
pos.Dobj.Next.Pobj.Attributes = icon_joint.Dobj.Pobj.Attributes;
pos.Dobj.Next.Mobj.Textures = HSDAccessor.DeepClone <HSD_TOBJ>(joints[ico.icon.JointID].Dobj.Next.Mobj.Textures);
var worldPosition = Vector3.TransformPosition(Vector3.Zero, m.GetWorldTransform(ico.icon.JointID));
pos.TX = worldPosition.X + center.X;
pos.TY = worldPosition.Y + center.Y;
pos.TZ = worldPosition.Z + center.Z;
ico.Joint = pos;
ico.Animation = new MexMenuAnimation();
ico.MatAnimJoint = HSDAccessor.DeepClone <HSD_MatAnimJoint>(icon_matanim_joint);
// load csps
// find key at stride
var icocsps = new List <HSD_TOBJ>();
int cspIndex = 0;
while (true)
{
var key = ico.FighterExternalID + (cspIndex * stride);
if (ico.FighterExternalID > 0x13)
{
key = ico.FighterExternalID + (cspIndex * stride) - 1;
}
var k = cspKeys.Find(e => e.Frame == key);
if (k == null)
{
break;
}
icocsps.Add(csps[(int)k.Value]);
cspIndex++;
}
ico.CSPs = icocsps.Select(e => new TOBJProxy()
{
TOBJ = e
}).ToArray();
}
m.RefreshRendering = true;
MEX_mexSelectChr mex = new MEX_mexSelectChr();
SetMexNode(mex, icons);
return(mex);
}
/// <summary>
///
/// </summary>
/// <param name="source"></param>
/// <param name="target"></param>
/// <param name="animation"></param>
/// <param name="sourceMap"></param>
/// <param name="targetMap"></param>
/// <returns></returns>
public static JointAnimManager SmartPort(HSD_JOBJ source, HSD_JOBJ target, JointAnimManager animation, JointMap sourceMap = null, JointMap targetMap = null)
{
var sourceManager = new JOBJManager();
sourceManager.SetJOBJ(source);
var sourceInverseWorldTransforms = new List <Matrix4>();
for (int i = 0; i < sourceManager.JointCount; i++)
{
sourceInverseWorldTransforms.Add(sourceManager.GetWorldTransform(i).Inverted());
}
sourceManager.Animation = animation;
var targetManager = new JOBJManager();
targetManager.SetJOBJ(target);
JointAnimManager newAnim = new JointAnimManager();
newAnim.FrameCount = sourceManager.Animation.FrameCount;
newAnim.Nodes.Clear();
for (int i = 0; i < targetManager.JointCount; i++)
{
newAnim.Nodes.Add(new AnimNode());
}
for (int i = 0; i < sourceManager.JointCount; i++)
{
int targetIndex = i;
int sourceIndex = i;
Console.WriteLine(sourceMap[i]);
// remap bone if joint maps are present
if (sourceMap != null && targetMap != null && !string.IsNullOrEmpty(sourceMap[i]))
{
targetIndex = targetMap.IndexOf(sourceMap[i]);
}
if (targetIndex == -1)
{
continue;
}
var sourceJoint = sourceManager.GetJOBJ(sourceIndex);
var targetJoint = targetManager.GetJOBJ(targetIndex);
Console.WriteLine($"\t {sourceJoint.RX} {sourceJoint.RY} {sourceJoint.RZ}");
Console.WriteLine($"\t {targetJoint.RX} {targetJoint.RY} {targetJoint.RZ}");
/*if(sourceMap[i] == "RLegJ")
* {
* var track = animation.Nodes[sourceIndex].Tracks.Find(e => e.JointTrackType == JointTrackType.HSD_A_J_ROTX);
*
* if (track != null)
* foreach (var k in track.Keys)
* k.Value += (float)Math.PI / 2;
*
* track = animation.Nodes[sourceIndex].Tracks.Find(e => e.JointTrackType == JointTrackType.HSD_A_J_ROTZ);
*
* if (track != null)
* foreach (var k in track.Keys)
* k.Value += (float)Math.PI / 2;
* }*/
newAnim.Nodes[targetIndex].Tracks = animation.Nodes[sourceIndex].Tracks;;
}
return(newAnim);
}
/// <summary>
///
/// </summary>
/// <param name="source"></param>
/// <param name="target"></param>
/// <param name="animation"></param>
/// <returns></returns>
public static JointAnimManager Retarget(HSD_JOBJ source, HSD_JOBJ target, JointAnimManager animation, JointMap sourceMap = null, JointMap targetMap = null)
{
var sourceManager = new JOBJManager();
sourceManager.SetJOBJ(source);
var sourceInverseWorldTransforms = new List <Matrix4>();
for (int i = 0; i < sourceManager.JointCount; i++)
{
sourceInverseWorldTransforms.Add(sourceManager.GetWorldTransform(i).Inverted());
}
sourceManager.Animation = animation;
var targetManager = new JOBJManager();
targetManager.SetJOBJ(target);
JointAnimManager newAnim = new JointAnimManager();
newAnim.FrameCount = sourceManager.Animation.FrameCount;
var targetWorldTransforms = new List <Matrix4>();
for (int i = 0; i < targetManager.JointCount; i++)
{
targetWorldTransforms.Add(targetManager.GetWorldTransform(i));
newAnim.Nodes.Add(new AnimNode());
}
targetManager.Animation = newAnim;
for (int f = 0; f <= sourceManager.Animation.FrameCount; f++)
{
sourceManager.Frame = f - 1;
sourceManager.UpdateNoRender();
targetManager.Frame = f;
targetManager.UpdateNoRender();
// bake animation on target skeleton
for (int i = 0; i < sourceManager.JointCount; i++)
{
int targetIndex = i;
int sourceIndex = i;
// remap bone if joint maps are present
if (sourceMap != null && targetMap != null && !string.IsNullOrEmpty(sourceMap[i]))
{
targetIndex = targetMap.IndexOf(sourceMap[i]);
}
if (targetIndex == -1)
{
continue;
}
int targetParentIndex = targetManager.ParentIndex(targetManager.GetJOBJ(targetIndex));
var inverseSourceWorldRotation = sourceInverseWorldTransforms[sourceIndex];
var sourceAnimatedWorldRotation = sourceManager.GetWorldTransform(sourceIndex);
var targetWorldRotation = targetWorldTransforms[targetIndex];
var rel = targetWorldRotation *
inverseSourceWorldRotation *
sourceAnimatedWorldRotation;
if (targetParentIndex != -1)
{
rel *= targetManager.GetWorldTransform(targetParentIndex).Inverted();
}
var rot = Math3D.ToEulerAngles(rel.ExtractRotation().Inverted());
var targetJOBJ = targetManager.GetJOBJ(targetIndex);
var sourceJOBJ = sourceManager.GetJOBJ(sourceIndex);
sourceManager.Animation.GetAnimatedState(f - 1, sourceIndex, sourceJOBJ, out float TX, out float TY, out float TZ, out float RX, out float RY, out float RZ, out float SX, out float SY, out float SZ);
var relTranslate = new Vector3(sourceJOBJ.TX - TX, sourceJOBJ.TY - TY, sourceJOBJ.TZ - TZ);
//relTranslate = Vector3.TransformNormal(relTranslate, Matrix4.CreateFromQuaternion(Math3D.FromEulerAngles(sourceJOBJ.RZ, sourceJOBJ.RY, sourceJOBJ.RX).Inverted()));
//relTranslate = Vector3.TransformNormal(relTranslate, Matrix4.CreateFromQuaternion(Math3D.FromEulerAngles(targetJOBJ.RZ, targetJOBJ.RY, targetJOBJ.RX)));
var relScale = new Vector3(sourceJOBJ.SX - SX, sourceJOBJ.SY - SY, sourceJOBJ.SZ - SZ);
//relScale = Vector3.TransformNormal(relScale, inverseSourceWorldRotation);
//relScale = Vector3.TransformNormal(relScale, targetWorldRotation);
AddKey(targetIndex, f, targetJOBJ.TX - relTranslate.X, JointTrackType.HSD_A_J_TRAX, newAnim);
AddKey(targetIndex, f, targetJOBJ.TY - relTranslate.Y, JointTrackType.HSD_A_J_TRAY, newAnim);
AddKey(targetIndex, f, targetJOBJ.TZ - relTranslate.Z, JointTrackType.HSD_A_J_TRAZ, newAnim);
AddKey(targetIndex, f, rot.X, JointTrackType.HSD_A_J_ROTX, newAnim);
AddKey(targetIndex, f, rot.Y, JointTrackType.HSD_A_J_ROTY, newAnim);
AddKey(targetIndex, f, rot.Z, JointTrackType.HSD_A_J_ROTZ, newAnim);
AddKey(targetIndex, f, targetJOBJ.SX - relScale.X, JointTrackType.HSD_A_J_SCAX, newAnim);
AddKey(targetIndex, f, targetJOBJ.SY - relScale.Y, JointTrackType.HSD_A_J_SCAY, newAnim);
AddKey(targetIndex, f, targetJOBJ.SZ - relScale.Z, JointTrackType.HSD_A_J_SCAZ, newAnim);
targetManager.UpdateNoRender();
}
}
EulerFilter(newAnim);
var targetAnim = newAnim.ToAnimJoint(target, AOBJ_Flags.ANIM_LOOP);
AnimationCompressor.AdaptiveCompressAnimation(targetAnim, targetMap);
RemoveUnusedTracks(target, targetAnim);
newAnim.FromAnimJoint(targetAnim);
// apply additional single frame filter check
for (int i = 0; i < sourceManager.JointCount; i++)
{
int targetIndex = i;
int sourceIndex = i;
// remap bone if joint maps are present
if (sourceMap != null && targetMap != null && !string.IsNullOrEmpty(sourceMap[i]))
{
targetIndex = targetMap.IndexOf(sourceMap[i]);
}
if (targetIndex == -1)
{
continue;
}
var sourceNode = animation.Nodes[sourceIndex];
var targetNode = newAnim.Nodes[targetIndex];
FOBJ_Player sourceXRot = null;
FOBJ_Player sourceYRot = null;
FOBJ_Player sourceZRot = null;
foreach (var t in sourceNode.Tracks)
{
if (t.JointTrackType == JointTrackType.HSD_A_J_ROTX)
{
sourceXRot = t;
}
if (t.JointTrackType == JointTrackType.HSD_A_J_ROTY)
{
sourceYRot = t;
}
if (t.JointTrackType == JointTrackType.HSD_A_J_ROTZ)
{
sourceZRot = t;
}
}
if (sourceXRot != null && sourceYRot != null && sourceZRot != null &&
sourceXRot.Keys.Count == 1 && sourceYRot.Keys.Count == 1 && sourceZRot.Keys.Count == 1)
{
foreach (var t in targetNode.Tracks)
{
if (t.JointTrackType == JointTrackType.HSD_A_J_ROTX ||
t.JointTrackType == JointTrackType.HSD_A_J_ROTY ||
t.JointTrackType == JointTrackType.HSD_A_J_ROTZ)
{
t.Keys.RemoveAll(e => e.Frame > 0);
t.Keys[0].InterpolationType = GXInterpolationType.HSD_A_OP_KEY;
}
}
}
}
return(newAnim);
}
/// <summary>
///
/// </summary>
/// <param name="manager"></param>
/// <param name="after_image"></param>
public static void RenderAfterImage(JOBJManager manager, float frame, AfterImageDesc after_image)
{
if (manager.Animation == null)
{
return;
}
// process previous keys
AfterImageKey[] keys = new AfterImageKey[3];
for (int i = 0; i < keys.Length; i++)
{
manager.Frame = frame - i;
manager.UpdateNoRender();
var bone = manager.GetWorldTransform(after_image.Bone);
keys[i] = new AfterImageKey()
{
pos = bone.ExtractTranslation(),
rot = bone.ExtractRotation()
};
}
// calculate point positions
var top = new Vector3(after_image.Top, 0, 0);
var bot = new Vector3(after_image.Bottom, 0, 0);
Vector3[] points_top = new Vector3[keys.Length];
Vector3[] points_bottom = new Vector3[keys.Length];
for (int i = 0; i < keys.Length; i++)
{
points_top[i] = keys[i].Transform(top);
points_bottom[i] = keys[i].Transform(bot);
}
float term1 = 1 / (keys[0].pos - keys[1].pos).Length;
float term2 = 1 / (keys[1].pos - keys[2].pos).Length;
Vector3 tan_bottom =
new Vector3(
CalculateTangent(term1, term2, points_bottom[0].X, points_bottom[1].X, points_bottom[2].X),
CalculateTangent(term1, term2, points_bottom[0].Y, points_bottom[1].Y, points_bottom[2].Y),
CalculateTangent(term1, term2, points_bottom[0].Z, points_bottom[1].Z, points_bottom[2].Z));
Vector3 tan_top =
new Vector3(
CalculateTangent(term1, term2, points_top[0].X, points_top[1].X, points_top[2].X),
CalculateTangent(term1, term2, points_top[0].Y, points_top[1].Y, points_top[2].Y),
CalculateTangent(term1, term2, points_top[0].Z, points_top[1].Z, points_top[2].Z));
// render sword trail
GL.PushAttrib(AttribMask.AllAttribBits);
GL.Disable(EnableCap.CullFace);
GL.Disable(EnableCap.DepthTest);
GL.Enable(EnableCap.Blend);
GL.BlendFunc(BlendingFactor.SrcAlpha, BlendingFactor.OneMinusSrcAlpha);
// draw strips interpolated
GL.Begin(PrimitiveType.TriangleStrip);
int slices = 10;
float total_indices = (keys.Length - 1) * slices;
float index = total_indices;
for (int s = 0; s < keys.Length - 1; s++)
{
float length = (keys[s].pos - keys[s + 1].pos).Length;
for (float i = 0; i < length; i += length / slices)
{
float alpha = index / total_indices;
GL.Color4(after_image.Color1.X, after_image.Color1.Y, after_image.Color1.Z, alpha);
GL.Vertex3(Herp(1 / length, i, points_top[s], points_top[s + 1], tan_top));
GL.Color4(after_image.Color2.X, after_image.Color2.Y, after_image.Color2.Z, alpha);
GL.Vertex3(Herp(1 / length, i, points_bottom[s], points_bottom[s + 1], tan_bottom));
index--;
}
tan_bottom *= -1;
tan_top *= -1;
}
/*
* GL.Color3(after_image.Color1);
* GL.Vertex3(keys[0].Transform(top));
* GL.Color3(after_image.Color2);
* GL.Vertex3(keys[0].Transform(bot));
*
* GL.Color3(after_image.Color1);
* GL.Vertex3(keys[1].Transform(top));
* GL.Color3(after_image.Color2);
* GL.Vertex3(keys[1].Transform(bot));
*
* GL.Color3(after_image.Color1);
* GL.Vertex3(keys[2].Transform(top));
* GL.Color3(after_image.Color2);
* GL.Vertex3(keys[2].Transform(bot));
*/
GL.End();
GL.PopAttrib();
}
/// <summary>
///
/// </summary>
/// <param name="manager"></param>
/// <param name="after_image"></param>
public static void RenderAfterImage(JOBJManager manager, float frame, AfterImageDesc after_image)
{
if (manager.Animation == null)
{
return;
}
// process previous keys
AfterImageKey[] keys = new AfterImageKey[3];
for (int i = 0; i < keys.Length; i++)
{
manager.Frame = frame - i;
manager.UpdateNoRender();
var bone = manager.GetWorldTransform(after_image.Bone);
keys[i] = new AfterImageKey()
{
pos = bone.ExtractTranslation(),
rot = bone.ExtractRotation()
};
}
//// render sword trail
GL.PushAttrib(AttribMask.AllAttribBits);
GL.Disable(EnableCap.CullFace);
GL.Disable(EnableCap.DepthTest);
GL.Enable(EnableCap.Blend);
GL.BlendFunc(BlendingFactor.SrcAlpha, BlendingFactor.OneMinusSrcAlpha);
// draw strips interpolated
GL.Begin(PrimitiveType.TriangleStrip);
var top = new Vector3(after_image.Top, 0, 0);
var bot = new Vector3(after_image.Bottom, 0, 0);
int slices = 10;
float total_indices = (keys.Length - 1) * slices;
float index = total_indices;
for (int s = 0; s < keys.Length - 1; s++)
{
var key1 = keys[s];
var key2 = keys[s + 1];
float length = (keys[s].pos - keys[s + 1].pos).Length;
for (float i = 0; i < length; i += length / slices)
{
float alpha = index / total_indices;
index--;
float blend = i / length;
// lerp angle
var rot = Quaternion.Slerp(key1.rot, key2.rot, blend);
var pos = Vector3.Lerp(key1.pos, key2.pos, blend);
var mat = Matrix4.CreateFromQuaternion(rot) * Matrix4.CreateTranslation(pos);
var start_top = Vector3.TransformPosition(top, mat);
var start_bot = Vector3.TransformPosition(bot, mat);
GL.Color4(after_image.Color1.X, after_image.Color1.Y, after_image.Color1.Z, alpha);
GL.Vertex3(start_top);
GL.Color4(after_image.Color2.X, after_image.Color2.Y, after_image.Color2.Z, alpha);
GL.Vertex3(start_bot);
}
}
GL.End();
GL.PopAttrib();
}
