// boneGroups = springBone.Springs.Select(x => x.ToGltf(nodes, springBone.Colliders)).ToList(),
public static VrmProtobuf.SpringBone.Types.BoneGroup ToGltf(this SpringBone self, List <Node> nodes, List <SpringBoneColliderGroup> colliders)
{
var boneGroup = new VrmProtobuf.SpringBone.Types.BoneGroup
{
Name = self.Comment,
Center = nodes.IndexOfNullable(self.Origin),
DragForce = self.DragForce,
GravityPower = self.GravityPower,
HitRadius = self.HitRadius,
Stiffness = self.Stiffness,
};
boneGroup.GravityDir.Add(self.GravityDir.X);
boneGroup.GravityDir.Add(self.GravityDir.Y);
boneGroup.GravityDir.Add(self.GravityDir.Z);
foreach (var x in self.Colliders)
{
boneGroup.ColliderGroups.Add(colliders.IndexOfThrow(x));
}
foreach (var x in self.Bones)
{
boneGroup.Bones.Add(nodes.IndexOfThrow(x));
}
return(boneGroup);
}
public SpringBoneManager CreateVrmSpringBone(List <Node> nodes)
{
var gltfVrm = Gltf.Extensions.VRMCSpringBone;
if ((gltfVrm is null))
{
return(null);
}
var springBone = new SpringBoneManager();
// springs
foreach (var group in gltfVrm.Springs.GroupBy(x => x.Setting.Value))
{
var sb = new SpringBone();
sb.Comment = group.First().Name;
sb.HitRadius = group.First().HitRadius.Value;
var setting = gltfVrm.Settings[group.Key];
sb.DragForce = setting.DragForce.Value;
sb.GravityDir = setting.GravityDir.ToVector3();
sb.GravityPower = setting.GravityPower.Value;
sb.Stiffness = setting.Stiffness.Value;
foreach (var spring in group)
{
// root
sb.Bones.Add(nodes[spring.SpringRoot.Value]);
// collider
foreach (var colliderNode in spring.Colliders)
{
var collider = springBone.Colliders.FirstOrDefault(x => x.Node == nodes[colliderNode]);
if (collider == null)
{
collider = new SpringBoneColliderGroup(nodes[colliderNode], Gltf.Nodes[colliderNode].Extensions.VRMCNodeCollider.Shapes.Select(x =>
{
if (x.Sphere != null)
{
return(VrmSpringBoneCollider.CreateSphere(x.Sphere.Offset.ToVector3(), x.Sphere.Radius.Value));
}
else if (x.Capsule != null)
{
return(VrmSpringBoneCollider.CreateCapsule(x.Capsule.Offset.ToVector3(), x.Capsule.Radius.Value, x.Capsule.Tail.ToVector3()));
}
else
{
throw new NotImplementedException();
}
}));
springBone.Colliders.Add(collider);
}
sb.Colliders.Add(collider);
}
}
springBone.Springs.Add(sb);
}
return(springBone);
}
void DrawGizmoRecursive(SpringBone bone)
{
Gizmos.color = Color.yellow;
Gizmos.DrawWireSphere(bone.transform.position, bone.radius);
if (bone.childNode != null)
{
DrawGizmoRecursive(bone.childNode);
}
}
void ExportSpringBone()
{
Object[] objects = targetModel.GetComponentsInChildren <SpringBone>();
//gizmo以外はエクスポート
//transformは名前をエクスポートする(インポート時にFindで探す)
for (int j = 0; j < objects.Length; j++)
{
SpringBone springbone = (SpringBone)objects[j];
SpringBoneSetting exportData
= ScriptableObject.CreateInstance <SpringBoneSetting>();
exportData.m_AttachObject = m_Utility.GetHierarchyPath(springbone.gameObject.transform);
exportData.m_comment = springbone.m_comment;
exportData.m_stiffnessForce = springbone.m_stiffnessForce;
exportData.m_gravityPower = springbone.m_gravityPower;
exportData.m_gravityDir = springbone.m_gravityDir;
exportData.m_dragForce = springbone.m_dragForce;
if (springbone.m_center != null)
{
exportData.m_center = m_Utility.GetHierarchyPath(springbone.m_center.transform);
}
exportData.RootBones = new string[springbone.RootBones.Count];
for (int i = 0; i < springbone.RootBones.Count; i++)
{
exportData.RootBones[i] = m_Utility.GetHierarchyPath(springbone.RootBones[i].transform);
}
exportData.m_hitRadius = springbone.m_hitRadius;
exportData.ColliderGroups = new string[springbone.ColliderGroups.Length];
for (int i = 0; i < springbone.ColliderGroups.Length; i++)
{
exportData.ColliderGroups[i]
= m_Utility.GetHierarchyPath(springbone.ColliderGroups[i].transform);
if (ColliderTergetName.Count == 0)
{
ColliderTergetName.Add(exportData.ColliderGroups[i]);
}
else
{
if (ColliderTergetName.IndexOf(exportData.ColliderGroups[i]) == -1)
{
ColliderTergetName.Add(exportData.ColliderGroups[i]);
}
;
}
}
AssetDatabase.CreateAsset(
exportData, "Assets/Models/Resources/SpringBoneData/SpringBone/SpringBoneData_" + j + ".asset");
}
}
public static SpringSetting ToGltf(this SpringBone self, List <Node> nodes)
{
var setting = new SpringSetting
{
DragForce = self.DragForce,
GravityPower = self.GravityPower,
Stiffness = self.Stiffness,
GravityDir = self.GravityDir.ToFloat3(),
};
return(setting);
}
public static VrmProtobuf.SpringSetting ToGltf(this SpringBone self, List <Node> nodes)
{
var setting = new VrmProtobuf.SpringSetting
{
DragForce = self.DragForce,
GravityPower = self.GravityPower,
Stiffness = self.Stiffness,
};
setting.GravityDir.Add(self.GravityDir.X);
setting.GravityDir.Add(self.GravityDir.Y);
setting.GravityDir.Add(self.GravityDir.Z);
return(setting);
}
void ApplySpringBone()
{
//gizmo以外は設定を反映
//transformはFind後したTransformを反映)
for (int j = 0; j < boneObjects.Length; j++)
{
//設定データ
SpringBoneSetting settingData = (SpringBoneSetting)boneObjects[j];
//対象のボーン
//m_Utility.ChangeRootPath 設定されたパスをターゲット対象に変更する
GameObject targetObject
= GameObject.Find(m_Utility.ChangeRootPath(settingData.m_AttachObject, targetModel.name));
SpringBone springbone = targetObject.AddComponent <SpringBone>();
springbone.m_comment = settingData.m_comment;
springbone.m_stiffnessForce = settingData.m_stiffnessForce;
springbone.m_gravityPower = settingData.m_gravityPower;
springbone.m_gravityDir = settingData.m_gravityDir;
springbone.m_dragForce = settingData.m_dragForce;
if (settingData.m_center != null)
{
GameObject findObject = GameObject.Find(settingData.m_center);
if (findObject != null)
{
springbone.m_center = findObject.GetComponent <Transform>();
}
}
springbone.RootBones = new List <Transform>();
for (int i = 0; i < settingData.RootBones.Length; i++)
{
GameObject findObject
= GameObject.Find(m_Utility.ChangeRootPath(settingData.RootBones[i], targetModel.name));
springbone.RootBones.Add(findObject.GetComponent <Transform>());
}
springbone.m_hitRadius = settingData.m_hitRadius;
springbone.ColliderGroups = new SpringBoneColliderGroup[settingData.ColliderGroups.Length];
for (int i = 0; i < settingData.ColliderGroups.Length; i++)
{
GameObject findObject
= GameObject.Find(m_Utility.ChangeRootPath(settingData.ColliderGroups[i], targetModel.name));
springbone.ColliderGroups[i] = findObject.GetComponent <SpringBoneColliderGroup>();
}
}
}
public SpringBoneManager CreateVrmSpringBone(List <Node> nodes)
{
var gltfVrm = Gltf.Extensions.VRMCVrm;
if ((gltfVrm.SpringBone is null))
{
return(null);
}
var springBone = new SpringBoneManager();
// colliders
springBone.Colliders.AddRange(
gltfVrm.SpringBone.ColliderGroups.Select(y =>
new SpringBoneColliderGroup(
nodes[y.Node],
y.Colliders.Select(z => new VrmSpringBoneColliderSphere(z.Offset.ToVector3(), z.Radius))
)
));
// springs
springBone.Springs.AddRange(gltfVrm.SpringBone.BoneGroups.Select(x =>
{
var sb = new SpringBone();
sb.Bones.AddRange(x.Bones.Select(y => nodes[y]));
if (x.Center.TryGetValidIndex(nodes.Count, out int centerIndex))
{
sb.Origin = nodes[centerIndex];
}
sb.Colliders.AddRange(x.ColliderGroups.Select(y => springBone.Colliders[y]));
sb.Comment = x.Name;
sb.DragForce = x.DragForce;
sb.GravityDir = x.GravityDir.ToVector3();
sb.GravityPower = x.GravityPower;
sb.HitRadius = x.HitRadius;
sb.Stiffness = x.Stiffness;
return(sb);
}));
return(springBone);
}
public override void OnInspectorGUI()
{
sb = (SpringBone)target;
DrawDefaultInspector();
GUILayout.Space(10);
if (GUILayout.Button("Find First Child"))
{
sb.child = GetNextChild(false);
}
if (GUILayout.Button("Find Next Child"))
{
sb.child = GetNextChild(true);
}
GUILayout.Space(5);
GUILayout.TextArea("WARNING: Uses world scale.x to scale the bones and colliders.\nDO NOT SCALE THE GAMEOBJECT NON-UNIFORMLY (Very bad idea with rigidbodies anyway).");
}
static void WriteSpringBone(Component com)
{
WriteString("SpringBone");
SpringBone bone = com as SpringBone;
if (bone.child)
{
WriteString(bone.child.name);
}
else
{
WriteString("");
}
bw.Write(bone.radius);
bw.Write(bone.stiffnessForce);
bw.Write(bone.dragForce);
bw.Write(bone.threshold);
WriteVector3(bone.boneAxis);
WriteVector3(bone.springForce);
int collider_count = bone.colliders.Length;
bw.Write(collider_count);
for (int i = 0; i < collider_count; ++i)
{
var collider = bone.colliders[i];
if (collider)
{
string path = GetRelativePath(bone.transform, collider.transform);
WriteString(path);
}
else
{
WriteString("");
}
}
}
private GenericMenu GetWeaponsMenu(SpringBone bone, int current)
{
if (!bone)
{
return(null);
}
var ids = bone.GetSavedWeaponIDs();
if (ids.Count < 1)
{
return(null);
}
var menu = new GenericMenu();
foreach (var id in ids)
{
menu.AddItem(new GUIContent(SpringManagerEditor.GetWeaponString(id)), current == id, i => bone.CopyParams((int)i, current), id);
}
return(menu);
}
public static bool LoadVrm(this Model self, Gltf gltf)
{
var gltfVrm = gltf.extensions?.VRM;
if (gltfVrm == null)
{
return(false);
}
var Vrm = new Vrm(gltfVrm.meta.FromGltf(self.Textures), gltfVrm.exporterVersion, gltfVrm.specVersion);
self.Vrm = Vrm;
if (gltfVrm.humanoid != null)
{
foreach (var humanBone in gltfVrm.humanoid.humanBones)
{
if (humanBone.bone != GltfFormat.HumanoidBones.unknown)
{
self.Nodes[humanBone.node].HumanoidBone = (VrmLib.HumanoidBones)humanBone.bone;
}
}
}
if (!self.CheckVrmHumanoid())
{
throw new Exception("duplicate human bone");
}
// blendshape
if (gltfVrm.blendShapeMaster != null &&
gltfVrm.blendShapeMaster.blendShapeGroups != null &&
gltfVrm.blendShapeMaster.blendShapeGroups.Any())
{
Vrm.BlendShape = gltfVrm.blendShapeMaster.FromGltf(self.MeshGroups, self.Materials, self.Nodes);
}
// secondary
if (!(gltfVrm.secondaryAnimation is null))
{
Vrm.SpringBone = new SpringBoneManager();
// colliders
Vrm.SpringBone.Colliders.AddRange(
gltfVrm.secondaryAnimation.colliderGroups.Select(y =>
new SpringBoneColliderGroup(
self.Nodes[y.node],
y.colliders.Select(z => VrmSpringBoneCollider.CreateSphere(z.offset, z.radius))
)
));
// springs
Vrm.SpringBone.Springs.AddRange(gltfVrm.secondaryAnimation.boneGroups.Select(x =>
{
var sb = new SpringBone();
sb.Bones.AddRange(x.bones.Select(y => self.Nodes[y]));
if (x.center >= 0)
{
sb.Origin = self.Nodes[x.center];
}
sb.Colliders.AddRange(x.colliderGroups.Select(y => Vrm.SpringBone.Colliders[y]));
sb.Comment = x.comment;
sb.DragForce = x.dragForce;
sb.GravityDir = x.gravityDir;
sb.GravityPower = x.gravityPower;
sb.HitRadius = x.hitRadius;
sb.Stiffness = x.stiffiness;
return(sb);
}));
}
// material(already replaced)
if (gltfVrm.firstPerson != null)
{
Vrm.FirstPerson = gltfVrm.firstPerson.FromGltf(self.Nodes, self.MeshGroups);
Vrm.LookAt = gltfVrm.firstPerson.LookAtFromGltf();
Vrm.LookAt.OffsetFromHeadBone = gltfVrm.firstPerson.firstPersonBoneOffset;
}
return(true);
}
public SpringBoneManager CreateVrmSpringBone(List <Node> nodes)
{
if ((gltfVrmSpringBone is null))
{
return(null);
}
var springBoneManager = new SpringBoneManager();
// springs
if (gltfVrmSpringBone.Springs != null)
{
foreach (var gltfSpring in gltfVrmSpringBone.Springs)
{
var springBone = new SpringBone();
springBone.Comment = gltfSpring.Name;
// joint
foreach (var gltfJoint in gltfSpring.Joints)
{
var joint = new SpringJoint(nodes[gltfJoint.Node.Value]);
joint.HitRadius = gltfJoint.HitRadius.Value;
joint.DragForce = gltfJoint.DragForce.Value;
joint.GravityDir = gltfJoint.GravityDir.ToVector3();
joint.GravityPower = gltfJoint.GravityPower.Value;
joint.Stiffness = gltfJoint.Stiffness.Value;
joint.Exclude = gltfJoint.Exclude.GetValueOrDefault();
springBone.Joints.Add(joint);
}
// collider
springBone.Colliders.AddRange(gltfSpring.Colliders.Select(colliderNode =>
{
if (UniGLTF.Extensions.VRMC_node_collider.GltfDeserializer.TryGet(Gltf.nodes[colliderNode].extensions,
out UniGLTF.Extensions.VRMC_node_collider.VRMC_node_collider extension))
{
var collider = new SpringBoneColliderGroup(nodes[colliderNode], extension.Shapes.Select(x =>
{
if (x.Sphere != null)
{
return(VrmSpringBoneCollider.CreateSphere(x.Sphere.Offset.ToVector3(), x.Sphere.Radius.Value));
}
else if (x.Capsule != null)
{
return(VrmSpringBoneCollider.CreateCapsule(x.Capsule.Offset.ToVector3(), x.Capsule.Radius.Value, x.Capsule.Tail.ToVector3()));
}
else
{
throw new NotImplementedException();
}
}));
return(collider);
}
else
{
return(null);
}
}).Where(x => x != null));
springBoneManager.Springs.Add(springBone);
}
}
return(springBoneManager);
}
void OnEnable()
{
_instance = (SpringBone)target;
}
public override void OnInspectorGUI()
{
serializedObject.Update();
// Base Parameter
EditorGUILayout.BeginVertical("Box");
EditorGUILayout.LabelField("Base Parameter", EditorStyles.boldLabel);
EditorGUI.BeginChangeCheck();
_instance.stiffnessForce = EditorGUILayout.FloatField("Stiffness", _instance.stiffnessForce);
_instance.dragForce = EditorGUILayout.FloatField("Drag Force", _instance.dragForce);
_instance.springForce = EditorGUILayout.Vector3Field("Spring Force", _instance.springForce);
_instance.childNode = (SpringBone)EditorGUILayout.ObjectField("Child Node", _instance.childNode, typeof(SpringBone), true);
if (EditorGUI.EndChangeCheck())
{
foreach (var subObject in targets)
{
var subBone = subObject as SpringBone;
subBone.stiffnessForce = _instance.stiffnessForce;
subBone.dragForce = _instance.dragForce;
subBone.springForce = _instance.springForce;
EditorUtility.SetDirty(subObject);
}
}
EditorGUILayout.BeginHorizontal();
if (GUILayout.Button("Add Children"))
{
_instance.DeployChildrenRecursive();
}
if (GUILayout.Button("Apply Children"))
{
if (Selection.objects.Length > 1)
{
for (int i = 0; i < Selection.objects.Length; i++)
{
SpringBone bone;
if (Selection.objects[i] is SpringBone)
{
bone = Selection.objects[i] as SpringBone;
}
else
{
bone = (Selection.objects[i] as GameObject).GetComponent <SpringBone>();
}
bone?.CopySettingRecursive();
}
}
else
{
_instance.CopySettingRecursive();
}
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.EndVertical();
// Side Link
EditorGUILayout.BeginVertical("Box");
EditorGUILayout.LabelField("Links", EditorStyles.boldLabel);
EditorGUI.BeginChangeCheck();
_instance.sideLinkForce = EditorGUILayout.FloatField("Side Link", _instance.sideLinkForce);
if (EditorGUI.EndChangeCheck())
{
foreach (var subObject in targets)
{
var subBone = subObject as SpringBone;
subBone.sideLinkForce = _instance.sideLinkForce;
EditorUtility.SetDirty(subObject);
}
}
_instance.sideNodeLeft = (SpringBone)EditorGUILayout.ObjectField("Left Link Target", _instance.sideNodeLeft, typeof(SpringBone), true);
_instance.sideNodeRight = (SpringBone)EditorGUILayout.ObjectField("Right Link Target", _instance.sideNodeRight, typeof(SpringBone), true);
EditorGUILayout.BeginHorizontal();
if (GUILayout.Button("Apply Children"))
{
if (Selection.objects.Length > 1)
{
for (int i = 0; i < Selection.objects.Length - 1; i++)
{
var leftObject = Selection.objects[i] as GameObject;
SpringBone leftBone = leftObject.GetComponent <SpringBone>();
var rightObject = Selection.objects[i + 1] as GameObject;
SpringBone rightBone = rightObject.GetComponent <SpringBone>();
if (leftBone == null || rightBone == null)
{
continue;
}
leftBone.sideNodeRight = rightBone;
rightBone.sideNodeLeft = leftBone;
leftBone.SetLinkRecursive();
}
}
else
{
_instance.SetLinkRecursive();
}
}
if (GUILayout.Button("Clear"))
{
if (Selection.objects.Length > 1)
{
for (int i = 0; i < Selection.objects.Length; i++)
{
var leftObject = Selection.objects[i] as GameObject;
SpringBone bone = leftObject.GetComponent <SpringBone>();
bone?.ClearLinkRecursive();
}
}
else
{
_instance.ClearLinkRecursive();
}
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.EndVertical();
// Collision
EditorGUILayout.BeginVertical("Box");
EditorGUILayout.LabelField("Collisions", EditorStyles.boldLabel);
EditorGUI.BeginChangeCheck();
EditorGUI.indentLevel++;
_instance.radius = EditorGUILayout.FloatField("Collision Radius", _instance.radius);
var colliders = serializedObject.FindProperty("colliders");
if (colliders != null)
{
EditorGUILayout.PropertyField(colliders, true);
}
EditorGUI.indentLevel--;
if (EditorGUI.EndChangeCheck())
{
foreach (var subObject in targets)
{
var subBone = subObject as SpringBone;
subBone.radius = _instance.radius;
subBone.colliders = _instance.colliders;
EditorUtility.SetDirty(subObject);
}
}
if (GUILayout.Button("Apply Children"))
{
if (Selection.objects.Length > 1)
{
for (int i = 0; i < Selection.objects.Length; i++)
{
var boneObject = Selection.objects[i] as GameObject;
var bone = boneObject.GetComponent <SpringBone>();
bone?.SetCollisionRecursive();
}
}
else
{
_instance.SetCollisionRecursive();
}
}
EditorGUILayout.EndVertical();
serializedObject.ApplyModifiedProperties();
}