godotengine
/
godot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #71137 from lyuma/remove_modification_stack_3d 

Remove SkeletonModificationStack3D, and Skeleton3D api cleanup
This commit is contained in:
Rémi Verschelde 2023-01-13 22:34:09 +01:00
parent 682ef35787 fd25bb50ab
commit 030a95dd61
No known key found for this signature in database
GPG Key ID: C3336907360768E1
33 changed files with 47 additions and 5294 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
CHANGELOG.md
View File

@ -37,11 +37,8 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
- [New and improved IK in Skeleton2D](https://github.com/godotengine/godot/pull/40347).
- New classes: SkeletonModifier2D, SkeletonModifierStack2D, SkeletonModification2DLookAt, SkeletonModification2DCCDIK, SkeletonModification2DFABRIK, SkeletonModification2DJiggle, SkeletonModification2DTwoBoneIK, PhysicalBone2D, SkeletonModification2DPhysicalBones, SkeletonModification2DStackHolder.
- New `Transform2D.looking_at()` function.
- [New and improved IK in Skeleton3D](https://github.com/godotengine/godot/pull/39353).
- New classes: SkeletonModifier3D, SkeletonModifierStack3D, SkeletonModifier3DLookAt, SkeletonModification3DCCDIK, SkeletonModification3DFABRIK, SkeletonModification3DJiggle, SkeletonModification3DTwoBoneIK, SkeletonModification3DStackHolder.
- The Bone struct now includes a local_pose_override.
- [Improvements to Skeleton3D](https://github.com/godotengine/godot/pull/39353).
- The Bone struct now keeps track of its children bones, if it has any.
- Added functions to Skeleton3D for getting the forward vector using the information stored in the rest pose for the bones.
- New `Basis.rotate_to_align()` function.
- Refactored the BoneAttachment3D node.
- Removed the `process_list` functions.

31
doc/classes/BoneAttachment3D.xml
View File

@ -16,19 +16,6 @@
Returns the [NodePath] to the external [Skeleton3D] node, if one has been set.
</description>
</method>
<method name="get_override_mode" qualifiers="const" is_deprecated="true">
<return type="int" />
<description>
Deprecated. Local pose overrides will be removed.
Returns the override mode for the BoneAttachment3D node (0=global / 1=local).
</description>
</method>
<method name="get_override_pose" qualifiers="const">
<return type="bool" />
<description>
Returns whether the BoneAttachment3D node is overriding the bone pose of the bone it's attached to.
</description>
</method>
<method name="get_use_external_skeleton" qualifiers="const">
<return type="bool" />
<description>
@ -49,21 +36,6 @@
Sets the [NodePath] to the external skeleton that the BoneAttachment3D node should use. The external [Skeleton3D] node is only used when [code]use_external_skeleton[/code] is set to [code]true[/code].
</description>
</method>
<method name="set_override_mode" is_deprecated="true">
<return type="void" />
<param index="0" name="override_mode" type="int" />
<description>
Deprecated. Local pose overrides will be removed.
Sets the override mode for the BoneAttachment3D node (0=global / 1=local). The override mode defines which of the bone poses the BoneAttachment3D node will override.
</description>
</method>
<method name="set_override_pose">
<return type="void" />
<param index="0" name="override_pose" type="bool" />
<description>
Sets whether the BoneAttachment3D node will override the bone pose of the bone it is attached to. When set to [code]true[/code], the BoneAttachment3D node can change the pose of the bone.
</description>
</method>
<method name="set_use_external_skeleton">
<return type="void" />
<param index="0" name="use_external_skeleton" type="bool" />
@ -79,5 +51,8 @@
<member name="bone_name" type="String" setter="set_bone_name" getter="get_bone_name" default="&quot;&quot;">
The name of the attached bone.
</member>
<member name="override_pose" type="bool" setter="set_override_pose" getter="get_override_pose" default="false">
Whether the BoneAttachment3D node will override the bone pose of the bone it is attached to. When set to [code]true[/code], the BoneAttachment3D node can change the pose of the bone. When set to [code]false[/code], the BoneAttachment3D will always be set to the bone's transform.
</member>
</members>
</class>

96
doc/classes/Skeleton3D.xml
View File

@ -7,6 +7,7 @@
Skeleton3D provides a hierarchical interface for managing bones, including pose, rest and animation (see [Animation]). It can also use ragdoll physics.
The overall transform of a bone with respect to the skeleton is determined by the following hierarchical order: rest pose, custom pose and pose.
Note that "global pose" below refers to the overall transform of the bone with respect to skeleton, so it not the actual global/world transform of the bone.
To setup different types of inverse kinematics, consider using [SkeletonIK3D], or add a custom IK implementation in [method Node._process] as a child node.
</description>
<tutorials>
<link title="3D Inverse Kinematics Demo">https://godotengine.org/asset-library/asset/523</link>
@ -32,26 +33,11 @@
Removes the global pose override on all bones in the skeleton.
</description>
</method>
<method name="clear_bones_local_pose_override" is_deprecated="true">
<return type="void" />
<description>
Deprecated. Local pose overrides will be removed.
Removes the local pose override on all bones in the skeleton.
</description>
</method>
<method name="create_skin_from_rest_transforms">
<return type="Skin" />
<description>
</description>
</method>
<method name="execute_modifications" is_deprecated="true">
<return type="void" />
<param index="0" name="delta" type="float" />
<param index="1" name="execution_mode" type="int" />
<description>
Executes all the modifications on the [SkeletonModificationStack3D], if the Skeleton3D has one assigned.
</description>
</method>
<method name="find_bone" qualifiers="const">
<return type="int" />
<param index="0" name="name" type="String" />
@ -113,13 +99,6 @@
Returns the global rest transform for [param bone_idx].
</description>
</method>
<method name="get_bone_local_pose_override" qualifiers="const">
<return type="Transform3D" />
<param index="0" name="bone_idx" type="int" />
<description>
Returns the local pose override transform for [param bone_idx].
</description>
</method>
<method name="get_bone_name" qualifiers="const">
<return type="String" />
<param index="0" name="bone_idx" type="int" />
@ -167,43 +146,18 @@
Returns the rest transform for a bone [param bone_idx].
</description>
</method>
<method name="get_modification_stack" is_deprecated="true">
<return type="SkeletonModificationStack3D" />
<description>
Returns the modification stack attached to this skeleton, if one exists.
</description>
</method>
<method name="get_parentless_bones" qualifiers="const">
<return type="PackedInt32Array" />
<description>
Returns an array with all of the bones that are parentless. Another way to look at this is that it returns the indexes of all the bones that are not dependent or modified by other bones in the Skeleton.
</description>
</method>
<method name="global_pose_to_local_pose" is_deprecated="true">
<return type="Transform3D" />
<param index="0" name="bone_idx" type="int" />
<param index="1" name="global_pose" type="Transform3D" />
<method name="get_version" qualifiers="const">
<return type="int" />
<description>
Takes the passed-in global pose and converts it to local pose transform.
This can be used to easily convert a global pose from [method get_bone_global_pose] to a global transform in [method set_bone_local_pose_override].
</description>
</method>
<method name="global_pose_to_world_transform" is_deprecated="true">
<return type="Transform3D" />
<param index="0" name="global_pose" type="Transform3D" />
<description>
Deprecated. Use [Node3D] apis instead.
Takes the passed-in global pose and converts it to a world transform.
This can be used to easily convert a global pose from [method get_bone_global_pose] to a global transform usable with a node's transform, like [member Node3D.global_transform] for example.
</description>
</method>
<method name="global_pose_z_forward_to_bone_forward" is_deprecated="true">
<return type="Basis" />
<param index="0" name="bone_idx" type="int" />
<param index="1" name="basis" type="Basis" />
<description>
Rotates the given [Basis] so that the forward axis of the Basis is facing in the forward direction of the bone at [param bone_idx].
This is helper function to make using [method Transform3D.looking_at] easier with bone poses.
Returns the number of times the bone hierarchy has changed within this skeleton, including renames.
The Skeleton version is not serialized: only use within a single instance of Skeleton3D.
Use for invalidating caches in IK solvers and other nodes which process bones.
</description>
</method>
<method name="is_bone_enabled" qualifiers="const">
@ -213,15 +167,6 @@
Returns whether the bone pose for the bone at [param bone_idx] is enabled.
</description>
</method>
<method name="local_pose_to_global_pose" is_deprecated="true">
<return type="Transform3D" />
<param index="0" name="bone_idx" type="int" />
<param index="1" name="local_pose" type="Transform3D" />
<description>
Converts the passed-in local pose to a global pose relative to the inputted bone, [param bone_idx].
This could be used to convert [method get_bone_pose] for use with the [method set_bone_global_pose_override] function.
</description>
</method>
<method name="localize_rests">
<return type="void" />
<description>
@ -298,19 +243,6 @@
[b]Note:[/b] The pose transform needs to be a global pose! To convert a world transform from a [Node3D] to a global bone pose, multiply the [method Transform3D.affine_inverse] of the node's [member Node3D.global_transform] by the desired world transform
</description>
</method>
<method name="set_bone_local_pose_override" is_deprecated="true">
<return type="void" />
<param index="0" name="bone_idx" type="int" />
<param index="1" name="pose" type="Transform3D" />
<param index="2" name="amount" type="float" />
<param index="3" name="persistent" type="bool" default="false" />
<description>
Deprecated. Local pose overrides will be removed.
Sets the local pose transform, [param pose], for the bone at [param bone_idx].
[param amount] is the interpolation strength that will be used when applying the pose, and [param persistent] determines if the applied pose will remain.
[b]Note:[/b] The pose transform needs to be a local pose! Use [method global_pose_to_local_pose] to convert a global pose to a local pose.
</description>
</method>
<method name="set_bone_name">
<return type="void" />
<param index="0" name="bone_idx" type="int" />
@ -356,13 +288,6 @@
Sets the rest transform for bone [param bone_idx].
</description>
</method>
<method name="set_modification_stack" is_deprecated="true">
<return type="void" />
<param index="0" name="modification_stack" type="SkeletonModificationStack3D" />
<description>
Sets the modification stack for this skeleton to the passed-in modification stack, [param modification_stack].
</description>
</method>
<method name="unparent_bone_and_rest">
<return type="void" />
<param index="0" name="bone_idx" type="int" />
@ -370,15 +295,6 @@
Unparents the bone at [param bone_idx] and sets its rest position to that of its parent prior to being reset.
</description>
</method>
<method name="world_transform_to_global_pose" is_deprecated="true">
<return type="Transform3D" />
<param index="0" name="world_transform" type="Transform3D" />
<description>
Deprecated. Use [Node3D] apis instead.
Takes the passed-in global transform and converts it to a global pose.
This can be used to easily convert a global transform from [member Node3D.global_transform] to a global pose usable with [method set_bone_global_pose_override], for example.
</description>
</method>
</methods>
<members>
<member name="animate_physical_bones" type="bool" setter="set_animate_physical_bones" getter="get_animate_physical_bones" default="true">

66
doc/classes/SkeletonModification3D.xml
View File

@ -1,66 +0,0 @@
<?xml version="1.0" encoding="UTF-8" ?>
<class name="SkeletonModification3D" inherits="Resource" is_deprecated="true" version="4.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../class.xsd">
<brief_description>
A resource that operates on bones in a [Skeleton3D].
</brief_description>
<description>
This resource provides an interface that can be expanded so code that operates on bones in a [Skeleton3D] can be mixed and matched together to create complex interactions.
This is used to provide Godot with a flexible and powerful Inverse Kinematics solution that can be adapted for many different uses.
</description>
<tutorials>
</tutorials>
<methods>
<method name="_execute" qualifiers="virtual">
<return type="void" />
<param index="0" name="delta" type="float" />
<description>
Executes the given modification. This is where the modification performs whatever function it is designed to do.
</description>
</method>
<method name="_setup_modification" qualifiers="virtual">
<return type="void" />
<param index="0" name="modification_stack" type="SkeletonModificationStack3D" />
<description>
Sets up the modification so it can be executed. This function should be called automatically by the [SkeletonModificationStack3D] containing this modification.
If you need to initialize a modification before use, this is the place to do it!
</description>
</method>
<method name="clamp_angle">
<return type="float" />
<param index="0" name="angle" type="float" />
<param index="1" name="min" type="float" />
<param index="2" name="max" type="float" />
<param index="3" name="invert" type="bool" />
<description>
Takes a angle and clamps it so it is within the passed-in [param min] and [param max] range. [param invert] will inversely clamp the angle, clamping it to the range outside of the given bounds.
</description>
</method>
<method name="get_is_setup" qualifiers="const">
<return type="bool" />
<description>
Returns whether this modification has been successfully setup or not.
</description>
</method>
<method name="get_modification_stack">
<return type="SkeletonModificationStack3D" />
<description>
Returns the [SkeletonModificationStack3D] that this modification is bound to. Through the modification stack, you can access the Skeleton3D the modification is operating on.
</description>
</method>
<method name="set_is_setup">
<return type="void" />
<param index="0" name="is_setup" type="bool" />
<description>
Manually allows you to set the setup state of the modification. This function should only rarely be used, as the [SkeletonModificationStack3D] the modification is bound to should handle setting the modification up.
</description>
</method>
</methods>
<members>
<member name="enabled" type="bool" setter="set_enabled" getter="get_enabled" default="true">
When true, the modification's [method _execute] function will be called by the [SkeletonModificationStack3D].
</member>
<member name="execution_mode" type="int" setter="set_execution_mode" getter="get_execution_mode" default="0">
The execution mode for the modification. This tells the modification stack when to execute the modification. Some modifications have settings that are only available in certain execution modes.
</member>
</members>
</class>

136
doc/classes/SkeletonModification3DCCDIK.xml
View File

@ -1,136 +0,0 @@
<?xml version="1.0" encoding="UTF-8" ?>
<class name="SkeletonModification3DCCDIK" inherits="SkeletonModification3D" is_deprecated="true" version="4.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../class.xsd">
<brief_description>
A modification that uses CCDIK to manipulate a series of bones to reach a target.
</brief_description>
<description>
This [SkeletonModification3D] uses an algorithm called Cyclic Coordinate Descent Inverse Kinematics, or CCDIK, to manipulate a chain of bones in a Skeleton so it reaches a defined target.
CCDIK works by rotating a set of bones, typically called a "bone chain", on a single axis. Each bone is rotated to face the target from the tip (by default), which over a chain of bones allow it to rotate properly to reach the target. Because the bones only rotate on a single axis, CCDIK [i]can[/i] look more robotic than other IK solvers.
[b]Note:[/b] The CCDIK modifier has [code]ccdik_joints[/code], which are the data objects that hold the data for each joint in the CCDIK chain. This is different from a bone! CCDIK joints hold the data needed for each bone in the bone chain used by CCDIK.
CCDIK also fully supports angle constraints, allowing for more control over how a solution is met.
</description>
<tutorials>
</tutorials>
<methods>
<method name="get_ccdik_joint_bone_index" qualifiers="const">
<return type="int" />
<param index="0" name="joint_idx" type="int" />
<description>
Returns the bone index of the bone assigned to the CCDIK joint at [param joint_idx].
</description>
</method>
<method name="get_ccdik_joint_bone_name" qualifiers="const">
<return type="String" />
<param index="0" name="joint_idx" type="int" />
<description>
Returns the name of the bone that is assigned to the CCDIK joint at [param joint_idx].
</description>
</method>
<method name="get_ccdik_joint_ccdik_axis" qualifiers="const">
<return type="int" />
<param index="0" name="joint_idx" type="int" />
<description>
Returns the integer representing the joint axis of the CCDIK joint at [param joint_idx].
</description>
</method>
<method name="get_ccdik_joint_constraint_angle_max" qualifiers="const">
<return type="float" />
<param index="0" name="joint_idx" type="int" />
<description>
Returns the maximum angle constraint for the joint at [param joint_idx]. [b]Note:[/b] This angle is in degrees!
</description>
</method>
<method name="get_ccdik_joint_constraint_angle_min" qualifiers="const">
<return type="float" />
<param index="0" name="joint_idx" type="int" />
<description>
Returns the minimum angle constraint for the joint at [param joint_idx]. [b]Note:[/b] This angle is in degrees!
</description>
</method>
<method name="get_ccdik_joint_constraint_invert" qualifiers="const">
<return type="bool" />
<param index="0" name="joint_idx" type="int" />
<description>
Returns whether the CCDIK joint at [param joint_idx] uses an inverted joint constraint. See [method set_ccdik_joint_constraint_invert] for details.
</description>
</method>
<method name="get_ccdik_joint_enable_joint_constraint" qualifiers="const">
<return type="bool" />
<param index="0" name="joint_idx" type="int" />
<description>
Enables angle constraints to the CCDIK joint at [param joint_idx].
</description>
</method>
<method name="set_ccdik_joint_bone_index">
<return type="void" />
<param index="0" name="joint_idx" type="int" />
<param index="1" name="bone_index" type="int" />
<description>
Sets the bone index, [param bone_index], of the CCDIK joint at [param joint_idx]. When possible, this will also update the [code]bone_name[/code] of the CCDIK joint based on data provided by the linked skeleton.
</description>
</method>
<method name="set_ccdik_joint_bone_name">
<return type="void" />
<param index="0" name="joint_idx" type="int" />
<param index="1" name="bone_name" type="String" />
<description>
Sets the bone name, [param bone_name], of the CCDIK joint at [param joint_idx]. When possible, this will also update the [code]bone_index[/code] of the CCDIK joint based on data provided by the linked skeleton.
</description>
</method>
<method name="set_ccdik_joint_ccdik_axis">
<return type="void" />
<param index="0" name="joint_idx" type="int" />
<param index="1" name="axis" type="int" />
<description>
Sets the joint axis of the CCDIK joint at [param joint_idx] to the passed-in joint axis, [param axis].
</description>
</method>
<method name="set_ccdik_joint_constraint_angle_max">
<return type="void" />
<param index="0" name="joint_idx" type="int" />
<param index="1" name="max_angle" type="float" />
<description>
Sets the maximum angle constraint for the joint at [param joint_idx]. [b]Note:[/b] This angle must be in radians!
</description>
</method>
<method name="set_ccdik_joint_constraint_angle_min">
<return type="void" />
<param index="0" name="joint_idx" type="int" />
<param index="1" name="min_angle" type="float" />
<description>
Sets the minimum angle constraint for the joint at [param joint_idx]. [b]Note:[/b] This angle must be in radians!
</description>
</method>
<method name="set_ccdik_joint_constraint_invert">
<return type="void" />
<param index="0" name="joint_idx" type="int" />
<param index="1" name="invert" type="bool" />
<description>
Sets whether the CCDIK joint at [param joint_idx] uses an inverted joint constraint.
An inverted joint constraint only constraints the CCDIK joint to the angles [i]outside of[/i] the inputted minimum and maximum angles. For this reason, it is referred to as an inverted joint constraint, as it constraints the joint to the outside of the inputted values.
</description>
</method>
<method name="set_ccdik_joint_enable_joint_constraint">
<return type="void" />
<param index="0" name="joint_idx" type="int" />
<param index="1" name="enable" type="bool" />
<description>
Sets whether joint constraints are enabled for the CCDIK joint at [param joint_idx].
</description>
</method>
</methods>
<members>
<member name="ccdik_data_chain_length" type="int" setter="set_ccdik_data_chain_length" getter="get_ccdik_data_chain_length" default="0">
The number of CCDIK joints in the CCDIK modification.
</member>
<member name="high_quality_solve" type="bool" setter="set_use_high_quality_solve" getter="get_use_high_quality_solve" default="true">
When true, the CCDIK algorithm will perform a higher quality solve that returns more natural results. A high quality solve requires more computation power to solve though, and therefore can be disabled to save performance.
</member>
<member name="target_nodepath" type="NodePath" setter="set_target_node" getter="get_target_node" default="NodePath(&quot;&quot;)">
The NodePath to the node that is the target for the CCDIK modification. This node is what the CCDIK chain will attempt to rotate the bone chain to.
</member>
<member name="tip_nodepath" type="NodePath" setter="set_tip_node" getter="get_tip_node" default="NodePath(&quot;&quot;)">
The end position of the CCDIK chain. Typically, this should be a child of a [BoneAttachment3D] node attached to the final bone in the CCDIK chain, where the child node is offset so it is at the end of the final bone.
</member>
</members>
</class>

161
doc/classes/SkeletonModification3DFABRIK.xml
View File

@ -1,161 +0,0 @@
<?xml version="1.0" encoding="UTF-8" ?>
<class name="SkeletonModification3DFABRIK" inherits="SkeletonModification3D" is_deprecated="true" version="4.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../class.xsd">
<brief_description>
A modification that uses FABRIK to manipulate a series of bones to reach a target.
</brief_description>
<description>
This [SkeletonModification3D] uses an algorithm called Forward And Backward Reaching Inverse Kinematics, or FABRIK, to rotate a bone chain so that it reaches a target.
FABRIK works by knowing the positions and lengths of a series of bones, typically called a "bone chain". It first starts by running a forward pass, which places the final bone at the target's position. Then all other bones are moved towards the tip bone, so they stay at the defined bone length away. Then a backwards pass is performed, where the root/first bone in the FABRIK chain is placed back at the origin. then all other bones are moved so they stay at the defined bone length away. This positions the bone chain so that it reaches the target when possible, but all of the bones stay the correct length away from each other.
Because of how FABRIK works, it often gives more natural results than those seen in [SkeletonModification3DCCDIK], though FABRIK currently does not support joint constraints.
[b]Note:[/b] The FABRIK modifier has [code]fabrik_joints[/code], which are the data objects that hold the data for each joint in the FABRIK chain. This is different from a bone! FABRIK joints hold the data needed for each bone in the bone chain used by FABRIK.
To help control how the FABRIK joints move, a magnet vector can be passed, which can nudge the bones in a certain direction prior to solving, giving a level of control over the final result.
</description>
<tutorials>
</tutorials>
<methods>
<method name="fabrik_joint_auto_calculate_length">
<return type="void" />
<param index="0" name="joint_idx" type="int" />
<description>
Will attempt to automatically calculate the length of the bone assigned to the FABRIK joint at [param joint_idx].
</description>
</method>
<method name="get_fabrik_joint_auto_calculate_length" qualifiers="const">
<return type="bool" />
<param index="0" name="joint_idx" type="int" />
<description>
Returns a boolean that indicates whether this modification will attempt to autocalculate the length of the bone assigned to the FABRIK joint at [param joint_idx].
</description>
</method>
<method name="get_fabrik_joint_bone_index" qualifiers="const">
<return type="int" />
<param index="0" name="joint_idx" type="int" />
<description>
Returns the bone index of the bone assigned to the FABRIK joint at [param joint_idx].
</description>
</method>
<method name="get_fabrik_joint_bone_name" qualifiers="const">
<return type="String" />
<param index="0" name="joint_idx" type="int" />
<description>
Returns the name of the bone that is assigned to the FABRIK joint at [param joint_idx].
</description>
</method>
<method name="get_fabrik_joint_length" qualifiers="const">
<return type="float" />
<param index="0" name="joint_idx" type="int" />
<description>
Returns the length of the FABRIK joint at [param joint_idx].
</description>
</method>
<method name="get_fabrik_joint_magnet" qualifiers="const">
<return type="Vector3" />
<param index="0" name="joint_idx" type="int" />
<description>
Returns the magnet vector of the FABRIK joint at [param joint_idx].
</description>
</method>
<method name="get_fabrik_joint_tip_node" qualifiers="const">
<return type="NodePath" />
<param index="0" name="joint_idx" type="int" />
<description>
Returns the [Node3D]-based node placed at the tip of the FABRIK joint at [param joint_idx], if one has been set.
</description>
</method>
<method name="get_fabrik_joint_use_target_basis" qualifiers="const">
<return type="bool" />
<param index="0" name="joint_idx" type="int" />
<description>
Returns a boolean indicating whether the FABRIK joint uses the target's [Basis] for its rotation.
[b]Note:[/b] This option is only available for the final bone in the FABRIK chain, with this setting being ignored for all other bones.
</description>
</method>
<method name="get_fabrik_joint_use_tip_node" qualifiers="const">
<return type="bool" />
<param index="0" name="joint_idx" type="int" />
<description>
Sets the [Node3D]-based node that will be used as the tip of the FABRIK joint at [param joint_idx].
</description>
</method>
<method name="set_fabrik_joint_auto_calculate_length">
<return type="void" />
<param index="0" name="joint_idx" type="int" />
<param index="1" name="auto_calculate_length" type="bool" />
<description>
When [code]true[/code], this modification will attempt to automatically calculate the length of the bone for the FABRIK joint at [param joint_idx]. It does this by either using the tip node assigned, if there is one assigned, or the distance the of the bone's children, if the bone has any. If the bone has no children and no tip node is assigned, then the modification [b]cannot[/b] autocalculate the joint's length. In this case, the joint length should be entered manually or a tip node assigned.
</description>
</method>
<method name="set_fabrik_joint_bone_index">
<return type="void" />
<param index="0" name="joint_idx" type="int" />
<param index="1" name="bone_index" type="int" />
<description>
Sets the bone index, [param bone_index], of the FABRIK joint at [param joint_idx]. When possible, this will also update the [code]bone_name[/code] of the FABRIK joint based on data provided by the [Skeleton3D].
</description>
</method>
<method name="set_fabrik_joint_bone_name">
<return type="void" />
<param index="0" name="joint_idx" type="int" />
<param index="1" name="bone_name" type="String" />
<description>
Sets the bone name, [param bone_name], of the FABRIK joint at [param joint_idx]. When possible, this will also update the [code]bone_index[/code] of the FABRIK joint based on data provided by the [Skeleton3D].
</description>
</method>
<method name="set_fabrik_joint_length">
<return type="void" />
<param index="0" name="joint_idx" type="int" />
<param index="1" name="length" type="float" />
<description>
Sets the joint length, [param length], of the FABRIK joint at [param joint_idx].
</description>
</method>
<method name="set_fabrik_joint_magnet">
<return type="void" />
<param index="0" name="joint_idx" type="int" />
<param index="1" name="magnet_position" type="Vector3" />
<description>
Sets the magenet position to [param magnet_position] for the joint at [param joint_idx]. The magnet position is used to nudge the joint in that direction when solving, which gives some control over how that joint will bend when being solved.
</description>
</method>
<method name="set_fabrik_joint_tip_node">
<return type="void" />
<param index="0" name="joint_idx" type="int" />
<param index="1" name="tip_node" type="NodePath" />
<description>
Sets the nodepath of the FARIK joint at [param joint_idx] to [param tip_node]. The tip node is used to calculate the length of the FABRIK joint when set to automatically calculate joint length.
[b]Note:[/b] The tip node should generally be a child node of a [BoneAttachment3D] node attached to the bone that this FABRIK joint operates on, with the child node being offset so it is at the end of the bone.
</description>
</method>
<method name="set_fabrik_joint_use_target_basis">
<return type="void" />
<param index="0" name="joint_idx" type="int" />
<param index="1" name="use_target_basis" type="bool" />
<description>
Sets whether the FABRIK joint at [param joint_idx] uses the target's [Basis] for its rotation.
[b]Note:[/b] This option is only available for the final bone in the FABRIK chain, with this setting being ignored for all other bones.
</description>
</method>
<method name="set_fabrik_joint_use_tip_node">
<return type="void" />
<param index="0" name="joint_idx" type="int" />
<param index="1" name="use_tip_node" type="bool" />
<description>
Sets whether the tip node should be used when autocalculating the joint length for the FABRIK joint at [param joint_idx]. This will only work if there is a node assigned to the tip nodepath for this joint.
</description>
</method>
</methods>
<members>
<member name="chain_max_iterations" type="int" setter="set_chain_max_iterations" getter="get_chain_max_iterations" default="10">
The number of times FABRIK will try to solve each time the [code]execute[/code] function is called. Setting this value to a lower number will be result in better performance, but this can also result in harsher movements and slower solves.
</member>
<member name="chain_tolerance" type="float" setter="set_chain_tolerance" getter="get_chain_tolerance" default="0.01">
The minimum distance the target has to be from the tip of the final bone in the bone chain. Setting this value to a higher number allows for greater performance, but less accurate solves.
</member>
<member name="fabrik_data_chain_length" type="int" setter="set_fabrik_data_chain_length" getter="get_fabrik_data_chain_length" default="0">
The amount of FABRIK joints in the FABRIK modification.
</member>
<member name="target_nodepath" type="NodePath" setter="set_target_node" getter="get_target_node" default="NodePath(&quot;&quot;)">
The NodePath to the node that is the target for the FABRIK modification. This node is what the FABRIK chain will attempt to rotate the bone chain to.
</member>
</members>
</class>

199
doc/classes/SkeletonModification3DJiggle.xml
View File

@ -1,199 +0,0 @@
<?xml version="1.0" encoding="UTF-8" ?>
<class name="SkeletonModification3DJiggle" inherits="SkeletonModification3D" is_deprecated="true" version="4.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../class.xsd">
<brief_description>
A modification that jiggles bones as they move towards a target.
</brief_description>
<description>
This modification moves a series of bones, typically called a bone chain, towards a target. What makes this modification special is that it calculates the velocity and acceleration for each bone in the bone chain, and runs a very light physics-like calculation using the inputted values. This allows the bones to overshoot the target and "jiggle" around. It can be configured to act more like a spring, or sway around like cloth might.
This modification is useful for adding additional motion to things like hair, the edges of clothing, and more. It has several settings to that allow control over how the joint moves when the target moves.
[b]Note:[/b] The Jiggle modifier has [code]jiggle_joints[/code], which are the data objects that hold the data for each joint in the Jiggle chain. This is different from a bone! Jiggle joints hold the data needed for each bone in the bone chain used by the Jiggle modification.
</description>
<tutorials>
</tutorials>
<methods>
<method name="get_collision_mask" qualifiers="const">
<return type="int" />
<description>
Returns the collision mask that the Jiggle modifier will take into account when performing physics calculations.
</description>
</method>
<method name="get_jiggle_joint_bone_index" qualifiers="const">
<return type="int" />
<param index="0" name="joint_idx" type="int" />
<description>
Returns the bone index of the bone assigned to the Jiggle joint at [param joint_idx].
</description>
</method>
<method name="get_jiggle_joint_bone_name" qualifiers="const">
<return type="String" />
<param index="0" name="joint_idx" type="int" />
<description>
Returns the name of the bone that is assigned to the Jiggle joint at [param joint_idx].
</description>
</method>
<method name="get_jiggle_joint_damping" qualifiers="const">
<return type="float" />
<param index="0" name="joint_idx" type="int" />
<description>
Returns the amount of dampening of the Jiggle joint at [param joint_idx].
</description>
</method>
<method name="get_jiggle_joint_gravity" qualifiers="const">
<return type="Vector3" />
<param index="0" name="joint_idx" type="int" />
<description>
Returns a [Vector3] representign the amount of gravity the Jiggle joint at [param joint_idx] is influenced by.
</description>
</method>
<method name="get_jiggle_joint_mass" qualifiers="const">
<return type="float" />
<param index="0" name="joint_idx" type="int" />
<description>
Returns the amount of mass of the Jiggle joint at [param joint_idx].
</description>
</method>
<method name="get_jiggle_joint_override" qualifiers="const">
<return type="bool" />
<param index="0" name="joint_idx" type="int" />
<description>
Returns a boolean that indicates whether the joint at [param joint_idx] is overriding the default jiggle joint data defined in the modification.
</description>
</method>
<method name="get_jiggle_joint_roll" qualifiers="const">
<return type="float" />
<param index="0" name="joint_idx" type="int" />
<description>
Returns the amount of roll/twist applied to the bone that the Jiggle joint is applied to.
</description>
</method>
<method name="get_jiggle_joint_stiffness" qualifiers="const">
<return type="float" />
<param index="0" name="joint_idx" type="int" />
<description>
Returns the stiffness of the Jiggle joint at [param joint_idx].
</description>
</method>
<method name="get_jiggle_joint_use_gravity" qualifiers="const">
<return type="bool" />
<param index="0" name="joint_idx" type="int" />
<description>
Returns a boolean that indicates whether the joint at [param joint_idx] is using gravity or not.
</description>
</method>
<method name="get_use_colliders" qualifiers="const">
<return type="bool" />
<description>
Returns whether the Jiggle modifier is taking physics colliders into account when solving.
</description>
</method>
<method name="set_collision_mask">
<return type="void" />
<param index="0" name="mask" type="int" />
<description>
Sets the collision mask that the Jiggle modifier takes into account when performing physics calculations.
</description>
</method>
<method name="set_jiggle_joint_bone_index">
<return type="void" />
<param index="0" name="joint_idx" type="int" />
<param index="1" name="bone_idx" type="int" />
<description>
Sets the bone index, [param bone_idx], of the Jiggle joint at [param joint_idx]. When possible, this will also update the [code]bone_name[/code] of the Jiggle joint based on data provided by the [Skeleton3D].
</description>
</method>
<method name="set_jiggle_joint_bone_name">
<return type="void" />
<param index="0" name="joint_idx" type="int" />
<param index="1" name="name" type="String" />
<description>
Sets the bone name, [param name], of the Jiggle joint at [param joint_idx]. When possible, this will also update the [code]bone_index[/code] of the Jiggle joint based on data provided by the [Skeleton3D].
</description>
</method>
<method name="set_jiggle_joint_damping">
<return type="void" />
<param index="0" name="joint_idx" type="int" />
<param index="1" name="damping" type="float" />
<description>
Sets the amount of dampening of the Jiggle joint at [param joint_idx].
</description>
</method>
<method name="set_jiggle_joint_gravity">
<return type="void" />
<param index="0" name="joint_idx" type="int" />
<param index="1" name="gravity" type="Vector3" />
<description>
Sets the gravity vector of the Jiggle joint at [param joint_idx].
</description>
</method>
<method name="set_jiggle_joint_mass">
<return type="void" />
<param index="0" name="joint_idx" type="int" />
<param index="1" name="mass" type="float" />
<description>
Sets the of mass of the Jiggle joint at [param joint_idx].
</description>
</method>
<method name="set_jiggle_joint_override">
<return type="void" />
<param index="0" name="joint_idx" type="int" />
<param index="1" name="override" type="bool" />
<description>
Sets whether the Jiggle joint at [param joint_idx] should override the default Jiggle joint settings. Setting this to true will make the joint use its own settings rather than the default ones attached to the modification.
</description>
</method>
<method name="set_jiggle_joint_roll">
<return type="void" />
<param index="0" name="joint_idx" type="int" />
<param index="1" name="roll" type="float" />
<description>
Sets the amount of roll/twist on the bone the Jiggle joint is attached to.
</description>
</method>
<method name="set_jiggle_joint_stiffness">
<return type="void" />
<param index="0" name="joint_idx" type="int" />
<param index="1" name="stiffness" type="float" />
<description>
Sets the of stiffness of the Jiggle joint at [param joint_idx].
</description>
</method>
<method name="set_jiggle_joint_use_gravity">
<return type="void" />
<param index="0" name="joint_idx" type="int" />
<param index="1" name="use_gravity" type="bool" />
<description>
Sets whether the Jiggle joint at [param joint_idx] should use gravity.
</description>
</method>
<method name="set_use_colliders">
<return type="void" />
<param index="0" name="use_colliders" type="bool" />
<description>
When [code]true[/code], the Jiggle modifier will use raycasting to prevent the Jiggle joints from rotating themselves into collision objects when solving.
</description>
</method>
</methods>
<members>
<member name="damping" type="float" setter="set_damping" getter="get_damping" default="0.75">
The default amount of dampening applied to the Jiggle joints, if they are not overridden. Higher values lead to more of the calculated velocity being applied.
</member>
<member name="gravity" type="Vector3" setter="set_gravity" getter="get_gravity" default="Vector3(0, -6, 0)">
The default amount of gravity applied to the Jiggle joints, if they are not overridden.
</member>
<member name="jiggle_data_chain_length" type="int" setter="set_jiggle_data_chain_length" getter="get_jiggle_data_chain_length" default="0">
The amount of Jiggle joints in the Jiggle modification.
</member>
<member name="mass" type="float" setter="set_mass" getter="get_mass" default="0.75">
The default amount of mass assigned to the Jiggle joints, if they are not overridden. Higher values lead to faster movements and more overshooting.
</member>
<member name="stiffness" type="float" setter="set_stiffness" getter="get_stiffness" default="3.0">
The default amount of stiffness assigned to the Jiggle joints, if they are not overridden. Higher values act more like springs, quickly moving into the correct position.
</member>
<member name="target_nodepath" type="NodePath" setter="set_target_node" getter="get_target_node" default="NodePath(&quot;&quot;)">
The NodePath to the node that is the target for the Jiggle modification. This node is what the Jiggle chain will attempt to rotate the bone chain to.
</member>
<member name="use_gravity" type="bool" setter="set_use_gravity" getter="get_use_gravity" default="false">
Whether the gravity vector, [member gravity], should be applied to the Jiggle joints, assuming they are not overriding the default settings.
</member>
</members>
</class>

64
doc/classes/SkeletonModification3DLookAt.xml
View File

@ -1,64 +0,0 @@
<?xml version="1.0" encoding="UTF-8" ?>
<class name="SkeletonModification3DLookAt" inherits="SkeletonModification3D" is_deprecated="true" version="4.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../class.xsd">
<brief_description>
A modification that rotates a bone to look at a target.
</brief_description>
<description>
This [SkeletonModification3D] rotates a bone to look a target. This is extremely helpful for moving character's heads to look at the player, rotating a turret to look at a target, or any other case where you want to make a bone rotate towards something quickly and easily.
</description>
<tutorials>
</tutorials>
<methods>
<method name="get_additional_rotation" qualifiers="const">
<return type="Vector3" />
<description>
Returns the amount of extra rotation that is applied to the bone after the LookAt modification executes.
</description>
</method>
<method name="get_lock_rotation_plane" qualifiers="const">
<return type="int" />
<description>
Returns the plane that the LookAt modification is limiting rotation to.
</description>
</method>
<method name="get_lock_rotation_to_plane" qualifiers="const">
<return type="bool" />
<description>
Returns whether the LookAt modification is limiting rotation to a single plane in 3D space.
</description>
</method>
<method name="set_additional_rotation">
<return type="void" />
<param index="0" name="additional_rotation" type="Vector3" />
<description>
Sets the amount of extra rotation to be applied after the LookAt modification executes. This allows you to adjust the finished result.
</description>
</method>
<method name="set_lock_rotation_plane">
<return type="void" />
<param index="0" name="plane" type="int" />
<description>
</description>
</method>
<method name="set_lock_rotation_to_plane">
<return type="void" />
<param index="0" name="lock_to_plane" type="bool" />
<description>
When [code]true[/code], the LookAt modification will limit its rotation to a single plane in 3D space. The plane used can be configured using the [code]set_lock_rotation_plane[/code] function.
</description>
</method>
</methods>
<members>
<member name="bone_index" type="int" setter="set_bone_index" getter="get_bone_index" default="-2">
The bone index of the bone that should be operated on by this modification.
When possible, this will also update the [member bone_name] based on data provided by the [Skeleton3D].
</member>
<member name="bone_name" type="String" setter="set_bone_name" getter="get_bone_name" default="&quot;&quot;">
The name of the bone that should be operated on by this modification.
When possible, this will also update the [member bone_index] based on data provided by the [Skeleton3D].
</member>
<member name="target_nodepath" type="NodePath" setter="set_target_node" getter="get_target_node" default="NodePath(&quot;&quot;)">
The NodePath to the node that is the target for the modification.
</member>
</members>
</class>

27
doc/classes/SkeletonModification3DStackHolder.xml
View File

@ -1,27 +0,0 @@
<?xml version="1.0" encoding="UTF-8" ?>
<class name="SkeletonModification3DStackHolder" inherits="SkeletonModification3D" is_deprecated="true" version="4.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../class.xsd">
<brief_description>
A modification that holds and executes a [SkeletonModificationStack3D].
</brief_description>
<description>
This [SkeletonModification3D] holds a reference to a [SkeletonModificationStack3D], allowing you to use multiple modification stacks on a single [Skeleton3D].
[b]Note:[/b] The modifications in the held [SkeletonModificationStack3D] will only be executed if their execution mode matches the execution mode of the SkeletonModification3DStackHolder.
</description>
<tutorials>
</tutorials>
<methods>
<method name="get_held_modification_stack" qualifiers="const">
<return type="SkeletonModificationStack3D" />
<description>
Returns the [SkeletonModificationStack3D] that this modification is holding.
</description>
</method>
<method name="set_held_modification_stack">
<return type="void" />
<param index="0" name="held_modification_stack" type="SkeletonModificationStack3D" />
<description>
Sets the [SkeletonModificationStack3D] that this modification is holding. This modification stack will then be executed when this modification is executed.
</description>
</method>
</methods>
</class>

191
doc/classes/SkeletonModification3DTwoBoneIK.xml
View File

@ -1,191 +0,0 @@
<?xml version="1.0" encoding="UTF-8" ?>
<class name="SkeletonModification3DTwoBoneIK" inherits="SkeletonModification3D" is_deprecated="true" version="4.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../class.xsd">
<brief_description>
A modification that moves two bones to reach the target.
</brief_description>
<description>
This [SkeletonModification3D] uses an algorithm typically called TwoBoneIK. This algorithm works by leveraging the law of cosigns and the lengths of the bones to figure out what rotation the bones currently have, and what rotation they need to make a complete triangle, where the first bone, the second bone, and the target form the three vertices of the triangle. Because the algorithm works by making a triangle, it can only operate on two bones.
TwoBoneIK is great for arms, legs, and really any joints that can be represented by just two bones that bend to reach a target. This solver is more lightweight than [SkeletonModification3DFABRIK], but gives similar, natural looking results.
A [Node3D]-based node can be used to define the pole, or bend direction, allowing control over which direction the joint takes when bending to reach the target when the target is within reach.
</description>
<tutorials>
</tutorials>
<methods>
<method name="get_auto_calculate_joint_length" qualifiers="const">
<return type="bool" />
<description>
Returns whether the TwoBoneIK modification will attempt to autocalculate the lengths of the two bones.
</description>
</method>
<method name="get_joint_one_bone_idx" qualifiers="const">
<return type="int" />
<description>
Returns the bone index of the first bone in the TwoBoneIK modification.
</description>
</method>
<method name="get_joint_one_bone_name" qualifiers="const">
<return type="String" />
<description>
Returns the name of the first bone in the TwoBoneIK modification.
</description>
</method>
<method name="get_joint_one_length" qualifiers="const">
<return type="float" />
<description>
Returns the length of the first bone in the TwoBoneIK modification.
</description>
</method>
<method name="get_joint_one_roll" qualifiers="const">
<return type="float" />
<description>
Returns the amount of roll/twist applied to the first bone in the TwoBoneIK modification.
</description>
</method>
<method name="get_joint_two_bone_idx" qualifiers="const">
<return type="int" />
<description>
Returns the bone index of the second bone in the TwoBoneIK modification.
</description>
</method>
<method name="get_joint_two_bone_name" qualifiers="const">
<return type="String" />
<description>
Returns the name of the second bone in the TwoBoneIK modification.
</description>
</method>
<method name="get_joint_two_length" qualifiers="const">
<return type="float" />
<description>
Returns the length of the second bone in the TwoBoneIK modification.
</description>
</method>
<method name="get_joint_two_roll" qualifiers="const">
<return type="float" />
<description>
Returns the amount of roll/twist applied to the second bone in the TwoBoneIK modification.
</description>
</method>
<method name="get_pole_node" qualifiers="const">
<return type="NodePath" />
<description>
Returns the node that is being used as the pole node for the TwoBoneIK modification, if a pole node has been set.
</description>
</method>
<method name="get_tip_node" qualifiers="const">
<return type="NodePath" />
<description>
Returns the node that is being used to calculate the tip position of the second bone in the TwoBoneIK modification, if a tip node has been set.
</description>
</method>
<method name="get_use_pole_node" qualifiers="const">
<return type="bool" />
<description>
Returns whether the TwoBoneIK modification will attempt to use the pole node to figure out which direction to bend, if a pole node has been set.
</description>
</method>
<method name="get_use_tip_node" qualifiers="const">
<return type="bool" />
<description>
Returns whether the TwoBoneIK modification will attempt to use the tip node to figure out the length and position of the tip of the second bone.
</description>
</method>
<method name="set_auto_calculate_joint_length">
<return type="void" />
<param index="0" name="auto_calculate_joint_length" type="bool" />
<description>
If true, the TwoBoneIK modification will attempt to autocalculate the lengths of the bones being used. The first bone will be calculated by using the distance from the origin of the first bone to the origin of the second bone.
The second bone will be calculated either using the tip node if that setting is enabled, or by using the distances of the second bone's children. If the tip node is not enabled and the bone has no children, then the length cannot be autocalculated. In this case, the length will either have to be manually inputted or a tip node used to calculate the length.
</description>
</method>
<method name="set_joint_one_bone_idx">
<return type="void" />
<param index="0" name="bone_idx" type="int" />
<description>
Sets the bone index, [param bone_idx], of the first bone. When possible, this will also update the [code]bone_name[/code] of the first bone based on data provided by the [Skeleton3D].
</description>
</method>
<method name="set_joint_one_bone_name">
<return type="void" />
<param index="0" name="bone_name" type="String" />
<description>
Sets the bone name, [param bone_name], of the first bone. When possible, this will also update the [code]bone_index[/code] of the first bone based on data provided by the [Skeleton3D].
</description>
</method>
<method name="set_joint_one_length">
<return type="void" />
<param index="0" name="bone_length" type="float" />
<description>
Sets the length of the first bone in the TwoBoneIK modification.
</description>
</method>
<method name="set_joint_one_roll">
<return type="void" />
<param index="0" name="roll" type="float" />
<description>
Sets the amount of roll/twist applied to the first bone in the TwoBoneIK modification.
</description>
</method>
<method name="set_joint_two_bone_idx">
<return type="void" />
<param index="0" name="bone_idx" type="int" />
<description>
Sets the bone index, [param bone_idx], of the second bone. When possible, this will also update the [code]bone_name[/code] of the second bone based on data provided by the [Skeleton3D].
</description>
</method>
<method name="set_joint_two_bone_name">
<return type="void" />
<param index="0" name="bone_name" type="String" />
<description>
Sets the bone name, [param bone_name], of the second bone. When possible, this will also update the [code]bone_index[/code] of the second bone based on data provided by the [Skeleton3D].
</description>
</method>
<method name="set_joint_two_length">
<return type="void" />
<param index="0" name="bone_length" type="float" />
<description>
Sets the length of the second bone in the TwoBoneIK modification.
</description>
</method>
<method name="set_joint_two_roll">
<return type="void" />
<param index="0" name="roll" type="float" />
<description>
Sets the amount of roll/twist applied to the second bone in the TwoBoneIK modification.
</description>
</method>
<method name="set_pole_node">
<return type="void" />
<param index="0" name="pole_nodepath" type="NodePath" />
<description>
Sets the node to be used as the for the pole of the TwoBoneIK. When a node is set and the modification is set to use the pole node, the TwoBoneIK modification will bend the nodes in the direction towards this node when the bones need to bend.
</description>
</method>
<method name="set_tip_node">
<return type="void" />
<param index="0" name="tip_nodepath" type="NodePath" />
<description>
Sets the node to be used as the tip for the second bone. This is used to calculate the length and position of the end of the second bone in the TwoBoneIK modification.
[b]Note:[/b] The tip node should generally be a child node of a [BoneAttachment3D] node attached to the second bone, with the child node being offset so it is at the end of the bone.
</description>
</method>
<method name="set_use_pole_node">
<return type="void" />
<param index="0" name="use_pole_node" type="bool" />
<description>
When [code]true[/code], the TwoBoneIK modification will bend the bones towards the pole node, if one has been set. This gives control over the direction the TwoBoneIK solver will bend, which is helpful for joints like elbows that only bend in certain directions.
</description>
</method>
<method name="set_use_tip_node">
<return type="void" />
<param index="0" name="use_tip_node" type="bool" />
<description>
When [code]true[/code], the TwoBoneIK modification will use the tip node to calculate the distance and position of the end/tip of the second bone. This is the most stable solution for knowing the tip position and length of the second bone.
</description>
</method>
</methods>
<members>
<member name="target_nodepath" type="NodePath" setter="set_target_node" getter="get_target_node" default="NodePath(&quot;&quot;)">
The NodePath to the node that is the target for the TwoBoneIK modification. This node is what the modification will attempt to rotate the bones to reach.
</member>
</members>
</class>

88
doc/classes/SkeletonModificationStack3D.xml
View File

@ -1,88 +0,0 @@
<?xml version="1.0" encoding="UTF-8" ?>
<class name="SkeletonModificationStack3D" inherits="Resource" is_deprecated="true" version="4.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../class.xsd">
<brief_description>
A resource that holds a stack of [SkeletonModification3D]s.
</brief_description>
<description>
This resource is used by the Skeleton and holds a stack of [SkeletonModification3D]s. The SkeletonModificationStack3D controls the order of the modifications, which controls how they are applied. Modification order is especially important for full-body IK setups, as you need to execute the modifications in the correct order to get the desired results. For example, you want to execute a modification on the spine [i]before[/i] the arms on a humanoid skeleton.
Additionally, the SkeletonModificationStack3D also controls how strongly the modifications are applied to the [Skeleton3D] node.
</description>
<tutorials>
</tutorials>
<methods>
<method name="add_modification">
<return type="void" />
<param index="0" name="modification" type="SkeletonModification3D" />
<description>
Adds the passed-in [SkeletonModification3D] to the stack.
</description>
</method>
<method name="delete_modification">
<return type="void" />
<param index="0" name="mod_idx" type="int" />
<description>
Deletes the [SkeletonModification3D] at the index position [param mod_idx], if it exists.
</description>
</method>
<method name="enable_all_modifications">
<return type="void" />
<param index="0" name="enabled" type="bool" />
<description>
Enables all [SkeletonModification3D]s in the stack.
</description>
</method>
<method name="execute">
<return type="void" />
<param index="0" name="delta" type="float" />
<param index="1" name="execution_mode" type="int" />
<description>
Executes all of the [SkeletonModification3D]s in the stack that use the same execution mode as the passed-in [param execution_mode], starting from index [code]0[/code] to [member modification_count].
[b]Note:[/b] The order of the modifications can matter depending on the modifications. For example, modifications on a spine should operate before modifications on the arms in order to get proper results.
</description>
</method>
<method name="get_is_setup" qualifiers="const">
<return type="bool" />
<description>
Returns a boolean that indicates whether the modification stack is setup and can execute.
</description>
</method>
<method name="get_modification" qualifiers="const">
<return type="SkeletonModification3D" />
<param index="0" name="mod_idx" type="int" />
<description>
Returns the [SkeletonModification3D] at the passed-in index, [param mod_idx].
</description>
</method>
<method name="get_skeleton" qualifiers="const">
<return type="Skeleton3D" />
<description>
Returns the [Skeleton3D] node that the SkeletonModificationStack3D is bound to.
</description>
</method>
<method name="set_modification">
<return type="void" />
<param index="0" name="mod_idx" type="int" />
<param index="1" name="modification" type="SkeletonModification3D" />
<description>
Sets the modification at [param mod_idx] to the passed-in modification, [param modification].
</description>
</method>
<method name="setup">
<return type="void" />
<description>
Sets up the modification stack so it can execute. This function should be called by [Skeleton3D] and shouldn't be called unless you know what you are doing.
</description>
</method>
</methods>
<members>
<member name="enabled" type="bool" setter="set_enabled" getter="get_enabled" default="false">
When true, the modification's in the stack will be called. This is handled automatically through the [Skeleton3D] node.
</member>
<member name="modification_count" type="int" setter="set_modification_count" getter="get_modification_count" default="0">
The number of modifications in the stack.
</member>
<member name="strength" type="float" setter="set_strength" getter="get_strength" default="1.0">
The interpolation strength of the modifications in stack. A value of [code]0[/code] will make it where the modifications are not applied, a strength of [code]0.5[/code] will be half applied, and a strength of [code]1[/code] will allow the modifications to be fully applied and override the skeleton bone poses.
</member>
</members>
</class>

48
scene/3d/bone_attachment_3d.cpp
View File

@ -61,11 +61,7 @@ void BoneAttachment3D::_validate_property(PropertyInfo &p_property) const {
}
bool BoneAttachment3D::_set(const StringName &p_path, const Variant &p_value) {
if (p_path == SNAME("override_pose")) {
set_override_pose(p_value);
} else if (p_path == SNAME("override_mode")) {
set_override_mode(p_value);
} else if (p_path == SNAME("use_external_skeleton")) {
if (p_path == SNAME("use_external_skeleton")) {
set_use_external_skeleton(p_value);
} else if (p_path == SNAME("external_skeleton")) {
set_external_skeleton(p_value);
@ -75,11 +71,7 @@ bool BoneAttachment3D::_set(const StringName &p_path, const Variant &p_value) {
}
bool BoneAttachment3D::_get(const StringName &p_path, Variant &r_ret) const {
if (p_path == SNAME("override_pose")) {
r_ret = get_override_pose();
} else if (p_path == SNAME("override_mode")) {
r_ret = get_override_mode();
} else if (p_path == SNAME("use_external_skeleton")) {
if (p_path == SNAME("use_external_skeleton")) {
r_ret = get_use_external_skeleton();
} else if (p_path == SNAME("external_skeleton")) {
r_ret = get_external_skeleton();
@ -208,14 +200,10 @@ void BoneAttachment3D::_transform_changed() {
Transform3D our_trans = get_transform();
if (use_external_skeleton) {
our_trans = sk->world_transform_to_global_pose(get_global_transform());
our_trans = sk->get_global_transform().affine_inverse() * get_global_transform();
}
if (override_mode == OVERRIDE_MODES::MODE_GLOBAL_POSE) {
sk->set_bone_global_pose_override(bone_idx, our_trans, 1.0, true);
} else if (override_mode == OVERRIDE_MODES::MODE_LOCAL_POSE) {
sk->set_bone_local_pose_override(bone_idx, sk->global_pose_to_local_pose(bone_idx, our_trans), 1.0, true);
}
}
}
@ -267,11 +255,7 @@ void BoneAttachment3D::set_override_pose(bool p_override) {
if (!override_pose) {
Skeleton3D *sk = _get_skeleton3d();
if (sk) {
if (override_mode == OVERRIDE_MODES::MODE_GLOBAL_POSE) {
sk->set_bone_global_pose_override(bone_idx, Transform3D(), 0.0, false);
} else if (override_mode == OVERRIDE_MODES::MODE_LOCAL_POSE) {
sk->set_bone_local_pose_override(bone_idx, Transform3D(), 0.0, false);
}
}
_transform_changed();
}
@ -282,27 +266,6 @@ bool BoneAttachment3D::get_override_pose() const {
return override_pose;
}
void BoneAttachment3D::set_override_mode(int p_mode) {
if (override_pose) {
Skeleton3D *sk = _get_skeleton3d();
if (sk) {
if (override_mode == OVERRIDE_MODES::MODE_GLOBAL_POSE) {
sk->set_bone_global_pose_override(bone_idx, Transform3D(), 0.0, false);
} else if (override_mode == OVERRIDE_MODES::MODE_LOCAL_POSE) {
sk->set_bone_local_pose_override(bone_idx, Transform3D(), 0.0, false);
}
}
override_mode = p_mode;
_transform_changed();
return;
}
override_mode = p_mode;
}
int BoneAttachment3D::get_override_mode() const {
return override_mode;
}
void BoneAttachment3D::set_use_external_skeleton(bool p_use_external) {
use_external_skeleton = p_use_external;
@ -361,7 +324,7 @@ void BoneAttachment3D::on_bone_pose_update(int p_bone_index) {
if (sk) {
if (!override_pose) {
if (use_external_skeleton) {
set_global_transform(sk->global_pose_to_world_transform(sk->get_bone_global_pose(bone_idx)));
set_global_transform(sk->get_global_transform() * sk->get_bone_global_pose(bone_idx));
} else {
set_transform(sk->get_bone_global_pose(bone_idx));
}
@ -407,8 +370,6 @@ void BoneAttachment3D::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_override_pose", "override_pose"), &BoneAttachment3D::set_override_pose);
ClassDB::bind_method(D_METHOD("get_override_pose"), &BoneAttachment3D::get_override_pose);
ClassDB::bind_method(D_METHOD("set_override_mode", "override_mode"), &BoneAttachment3D::set_override_mode);
ClassDB::bind_method(D_METHOD("get_override_mode"), &BoneAttachment3D::get_override_mode);
ClassDB::bind_method(D_METHOD("set_use_external_skeleton", "use_external_skeleton"), &BoneAttachment3D::set_use_external_skeleton);
ClassDB::bind_method(D_METHOD("get_use_external_skeleton"), &BoneAttachment3D::get_use_external_skeleton);
@ -420,4 +381,5 @@ void BoneAttachment3D::_bind_methods() {
ADD_PROPERTY(PropertyInfo(Variant::STRING_NAME, "bone_name"), "set_bone_name", "get_bone_name");
ADD_PROPERTY(PropertyInfo(Variant::INT, "bone_idx"), "set_bone_idx", "get_bone_idx");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "override_pose"), "set_override_pose", "get_override_pose");
}

8
scene/3d/bone_attachment_3d.h
View File

@ -44,14 +44,8 @@ class BoneAttachment3D : public Node3D {
int bone_idx = -1;
bool override_pose = false;
int override_mode = 0;
bool _override_dirty = false;
enum OVERRIDE_MODES {
MODE_GLOBAL_POSE,
MODE_LOCAL_POSE,
};
bool use_external_skeleton = false;
NodePath external_skeleton_node;
ObjectID external_skeleton_node_cache;
@ -86,8 +80,6 @@ public:
void set_override_pose(bool p_override);
bool get_override_pose() const;
void set_override_mode(int p_mode);
int get_override_mode() const;
void set_use_external_skeleton(bool p_external_skeleton);
bool get_use_external_skeleton() const;

261
scene/3d/skeleton_3d.cpp
View File

@ -33,7 +33,6 @@
#include "core/object/message_queue.h"
#include "core/variant/type_info.h"
#include "scene/3d/physics_body_3d.h"
#include "scene/resources/skeleton_modification_3d.h"
#include "scene/resources/surface_tool.h"
#include "scene/scene_string_names.h"
@ -70,13 +69,6 @@ SkinReference::~SkinReference() {
bool Skeleton3D::_set(const StringName &p_path, const Variant &p_value) {
String path = p_path;
#ifndef _3D_DISABLED
if (path.begins_with("modification_stack")) {
set_modification_stack(p_value);
return true;
}
#endif //_3D_DISABLED
if (!path.begins_with("bones/")) {
return false;
}
@ -113,13 +105,6 @@ bool Skeleton3D::_set(const StringName &p_path, const Variant &p_value) {
bool Skeleton3D::_get(const StringName &p_path, Variant &r_ret) const {
String path = p_path;
#ifndef _3D_DISABLED
if (path.begins_with("modification_stack")) {
r_ret = modification_stack;
return true;
}
#endif //_3D_DISABLED
if (!path.begins_with("bones/")) {
return false;
}
@ -162,14 +147,6 @@ void Skeleton3D::_get_property_list(List<PropertyInfo> *p_list) const {
p_list->push_back(PropertyInfo(Variant::VECTOR3, prep + PNAME("scale"), PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NO_EDITOR));
}
#ifndef _3D_DISABLED
p_list->push_back(
PropertyInfo(Variant::OBJECT, "modification_stack",
PROPERTY_HINT_RESOURCE_TYPE,
"SkeletonModificationStack3D",
PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_DEFERRED_SET_RESOURCE | PROPERTY_USAGE_DO_NOT_SHARE_ON_DUPLICATE));
#endif //_3D_DISABLED
for (PropertyInfo &E : *p_list) {
_validate_property(E);
}
@ -330,24 +307,10 @@ void Skeleton3D::_notification(int p_what) {
}
}
}
if (modification_stack.is_valid()) {
execute_modifications(get_physics_process_delta_time(), SkeletonModificationStack3D::EXECUTION_MODE::execution_mode_physics_process);
}
} break;
case NOTIFICATION_INTERNAL_PROCESS: {
if (modification_stack.is_valid()) {
execute_modifications(get_process_delta_time(), SkeletonModificationStack3D::EXECUTION_MODE::execution_mode_process);
}
} break;
case NOTIFICATION_READY: {
if (Engine::get_singleton()->is_editor_hint()) {
set_physics_process_internal(true);
set_process_internal(true);
if (modification_stack.is_valid()) {
set_modification_stack(modification_stack);
}
} break;
#endif // _3D_DISABLED
@ -395,99 +358,6 @@ Transform3D Skeleton3D::get_bone_global_pose_no_override(int p_bone) const {
return bones[p_bone].pose_global_no_override;
}
void Skeleton3D::clear_bones_local_pose_override() {
for (int i = 0; i < bones.size(); i += 1) {
bones.write[i].local_pose_override_amount = 0;
}
_make_dirty();
}
void Skeleton3D::set_bone_local_pose_override(int p_bone, const Transform3D &p_pose, real_t p_amount, bool p_persistent) {
const int bone_size = bones.size();
ERR_FAIL_INDEX(p_bone, bone_size);
bones.write[p_bone].local_pose_override_amount = p_amount;
bones.write[p_bone].local_pose_override = p_pose;
bones.write[p_bone].local_pose_override_reset = !p_persistent;
_make_dirty();
}
Transform3D Skeleton3D::get_bone_local_pose_override(int p_bone) const {
const int bone_size = bones.size();
ERR_FAIL_INDEX_V(p_bone, bone_size, Transform3D());
return bones[p_bone].local_pose_override;
}
void Skeleton3D::update_bone_rest_forward_vector(int p_bone, bool p_force_update) {
const int bone_size = bones.size();
ERR_FAIL_INDEX(p_bone, bone_size);
if (bones[p_bone].rest_bone_forward_vector.length_squared() > 0 && p_force_update == false) {
update_bone_rest_forward_axis(p_bone, p_force_update);
}
// If it is a child/leaf bone...
if (get_bone_parent(p_bone) > 0) {
bones.write[p_bone].rest_bone_forward_vector = bones[p_bone].rest.origin.normalized();
} else {
// If it has children...
Vector<int> child_bones = get_bone_children(p_bone);
if (child_bones.size() > 0) {
Vector3 combined_child_dir = Vector3(0, 0, 0);
for (int i = 0; i < child_bones.size(); i++) {
combined_child_dir += bones[child_bones[i]].rest.origin.normalized();
}
combined_child_dir = combined_child_dir / child_bones.size();
bones.write[p_bone].rest_bone_forward_vector = combined_child_dir.normalized();
} else {
WARN_PRINT_ONCE("Cannot calculate forward direction for bone " + itos(p_bone));
WARN_PRINT_ONCE("Assuming direction of (0, 1, 0) for bone");
bones.write[p_bone].rest_bone_forward_vector = Vector3(0, 1, 0);
}
}
update_bone_rest_forward_axis(p_bone, p_force_update);
}
void Skeleton3D::update_bone_rest_forward_axis(int p_bone, bool p_force_update) {
const int bone_size = bones.size();
ERR_FAIL_INDEX(p_bone, bone_size);
if (bones[p_bone].rest_bone_forward_axis > -1 && p_force_update == false) {
return;
}
Vector3 forward_axis_absolute = bones[p_bone].rest_bone_forward_vector.abs();
if (forward_axis_absolute.x > forward_axis_absolute.y && forward_axis_absolute.x > forward_axis_absolute.z) {
if (bones[p_bone].rest_bone_forward_vector.x > 0) {
bones.write[p_bone].rest_bone_forward_axis = BONE_AXIS_X_FORWARD;
} else {
bones.write[p_bone].rest_bone_forward_axis = BONE_AXIS_NEGATIVE_X_FORWARD;
}
} else if (forward_axis_absolute.y > forward_axis_absolute.x && forward_axis_absolute.y > forward_axis_absolute.z) {
if (bones[p_bone].rest_bone_forward_vector.y > 0) {
bones.write[p_bone].rest_bone_forward_axis = BONE_AXIS_Y_FORWARD;
} else {
bones.write[p_bone].rest_bone_forward_axis = BONE_AXIS_NEGATIVE_Y_FORWARD;
}
} else {
if (bones[p_bone].rest_bone_forward_vector.z > 0) {
bones.write[p_bone].rest_bone_forward_axis = BONE_AXIS_Z_FORWARD;
} else {
bones.write[p_bone].rest_bone_forward_axis = BONE_AXIS_NEGATIVE_Z_FORWARD;
}
}
}
Vector3 Skeleton3D::get_bone_axis_forward_vector(int p_bone) {
const int bone_size = bones.size();
ERR_FAIL_INDEX_V(p_bone, bone_size, Vector3(0, 0, 0));
return bones[p_bone].rest_bone_forward_vector;
}
int Skeleton3D::get_bone_axis_forward_enum(int p_bone) {
const int bone_size = bones.size();
ERR_FAIL_INDEX_V(p_bone, bone_size, -1);
return bones[p_bone].rest_bone_forward_axis;
}
void Skeleton3D::set_motion_scale(float p_motion_scale) {
if (p_motion_scale <= 0) {
motion_scale = 1;
@ -503,6 +373,10 @@ float Skeleton3D::get_motion_scale() const {
// Skeleton creation api
uint64_t Skeleton3D::get_version() const {
return version;
}
void Skeleton3D::add_bone(const String &p_name) {
ERR_FAIL_COND(p_name.is_empty() || p_name.contains(":") || p_name.contains("/"));
@ -546,6 +420,7 @@ void Skeleton3D::set_bone_name(int p_bone, const String &p_name) {
}
bones.write[p_bone].name = p_name;
version++;
}
bool Skeleton3D::is_bone_parent_of(int p_bone, int p_parent_bone_id) const {
@ -1068,23 +943,10 @@ void Skeleton3D::force_update_bone_children_transforms(int p_bone_idx) {
b.global_rest = b.parent >= 0 ? bonesptr[b.parent].global_rest * b.rest : b.rest;
}
if (b.local_pose_override_amount >= CMP_EPSILON) {
Transform3D override_local_pose;
if (b.parent >= 0) {
override_local_pose = bonesptr[b.parent].pose_global * b.local_pose_override;
} else {
override_local_pose = b.local_pose_override;
}
b.pose_global = b.pose_global.interpolate_with(override_local_pose, b.local_pose_override_amount);
}
if (b.global_pose_override_amount >= CMP_EPSILON) {
b.pose_global = b.pose_global.interpolate_with(b.global_pose_override, b.global_pose_override_amount);
}
if (b.local_pose_override_reset) {
b.local_pose_override_amount = 0.0;
}
if (b.global_pose_override_reset) {
b.global_pose_override_amount = 0.0;
}
@ -1100,100 +962,6 @@ void Skeleton3D::force_update_bone_children_transforms(int p_bone_idx) {
rest_dirty = false;
}
// Helper functions
Transform3D Skeleton3D::global_pose_to_world_transform(Transform3D p_global_pose) {
return get_global_transform() * p_global_pose;
}
Transform3D Skeleton3D::world_transform_to_global_pose(Transform3D p_world_transform) {
return get_global_transform().affine_inverse() * p_world_transform;
}
Transform3D Skeleton3D::global_pose_to_local_pose(int p_bone_idx, Transform3D p_global_pose) {
const int bone_size = bones.size();
ERR_FAIL_INDEX_V(p_bone_idx, bone_size, Transform3D());
if (bones[p_bone_idx].parent >= 0) {
int parent_bone_idx = bones[p_bone_idx].parent;
Transform3D conversion_transform = get_bone_global_pose(parent_bone_idx).affine_inverse();
return conversion_transform * p_global_pose;
} else {
return p_global_pose;
}
}
Transform3D Skeleton3D::local_pose_to_global_pose(int p_bone_idx, Transform3D p_local_pose) {
const int bone_size = bones.size();
ERR_FAIL_INDEX_V(p_bone_idx, bone_size, Transform3D());
if (bones[p_bone_idx].parent >= 0) {
int parent_bone_idx = bones[p_bone_idx].parent;
return bones[parent_bone_idx].pose_global * p_local_pose;
} else {
return p_local_pose;
}
}
Basis Skeleton3D::global_pose_z_forward_to_bone_forward(int p_bone_idx, Basis p_basis) {
const int bone_size = bones.size();
ERR_FAIL_INDEX_V(p_bone_idx, bone_size, Basis());
Basis return_basis = p_basis;
if (bones[p_bone_idx].rest_bone_forward_axis < 0) {
update_bone_rest_forward_vector(p_bone_idx, true);
}
if (bones[p_bone_idx].rest_bone_forward_axis == BONE_AXIS_X_FORWARD) {
return_basis.rotate_local(Vector3(0, 1, 0), (Math_PI / 2.0));
} else if (bones[p_bone_idx].rest_bone_forward_axis == BONE_AXIS_NEGATIVE_X_FORWARD) {
return_basis.rotate_local(Vector3(0, 1, 0), -(Math_PI / 2.0));
} else if (bones[p_bone_idx].rest_bone_forward_axis == BONE_AXIS_Y_FORWARD) {
return_basis.rotate_local(Vector3(1, 0, 0), -(Math_PI / 2.0));
} else if (bones[p_bone_idx].rest_bone_forward_axis == BONE_AXIS_NEGATIVE_Y_FORWARD) {
return_basis.rotate_local(Vector3(1, 0, 0), (Math_PI / 2.0));
} else if (bones[p_bone_idx].rest_bone_forward_axis == BONE_AXIS_Z_FORWARD) {
// Do nothing!
} else if (bones[p_bone_idx].rest_bone_forward_axis == BONE_AXIS_NEGATIVE_Z_FORWARD) {
return_basis.rotate_local(Vector3(0, 0, 1), Math_PI);
}
return return_basis;
}
// Modifications
#ifndef _3D_DISABLED
void Skeleton3D::set_modification_stack(Ref<SkeletonModificationStack3D> p_stack) {
if (modification_stack.is_valid()) {
modification_stack->is_setup = false;
modification_stack->set_skeleton(nullptr);
}
modification_stack = p_stack;
if (modification_stack.is_valid()) {
modification_stack->set_skeleton(this);
modification_stack->setup();
}
}
Ref<SkeletonModificationStack3D> Skeleton3D::get_modification_stack() {
return modification_stack;
}
void Skeleton3D::execute_modifications(real_t p_delta, int p_execution_mode) {
if (!modification_stack.is_valid()) {
return;
}
// Needed to avoid the issue where the stack looses reference to the skeleton when the scene is saved.
if (modification_stack->skeleton != this) {
modification_stack->set_skeleton(this);
}
modification_stack->execute(p_delta, p_execution_mode);
}
#endif // _3D_DISABLED
void Skeleton3D::_bind_methods() {
ClassDB::bind_method(D_METHOD("add_bone", "name"), &Skeleton3D::add_bone);
ClassDB::bind_method(D_METHOD("find_bone", "name"), &Skeleton3D::find_bone);
@ -1204,6 +972,7 @@ void Skeleton3D::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_bone_parent", "bone_idx", "parent_idx"), &Skeleton3D::set_bone_parent);
ClassDB::bind_method(D_METHOD("get_bone_count"), &Skeleton3D::get_bone_count);
ClassDB::bind_method(D_METHOD("get_version"), &Skeleton3D::get_version);
ClassDB::bind_method(D_METHOD("unparent_bone_and_rest", "bone_idx"), &Skeleton3D::unparent_bone_and_rest);
@ -1243,23 +1012,12 @@ void Skeleton3D::_bind_methods() {
ClassDB::bind_method(D_METHOD("get_bone_global_pose", "bone_idx"), &Skeleton3D::get_bone_global_pose);
ClassDB::bind_method(D_METHOD("get_bone_global_pose_no_override", "bone_idx"), &Skeleton3D::get_bone_global_pose_no_override);
ClassDB::bind_method(D_METHOD("clear_bones_local_pose_override"), &Skeleton3D::clear_bones_local_pose_override);
ClassDB::bind_method(D_METHOD("set_bone_local_pose_override", "bone_idx", "pose", "amount", "persistent"), &Skeleton3D::set_bone_local_pose_override, DEFVAL(false));
ClassDB::bind_method(D_METHOD("get_bone_local_pose_override", "bone_idx"), &Skeleton3D::get_bone_local_pose_override);
ClassDB::bind_method(D_METHOD("force_update_all_bone_transforms"), &Skeleton3D::force_update_all_bone_transforms);
ClassDB::bind_method(D_METHOD("force_update_bone_child_transform", "bone_idx"), &Skeleton3D::force_update_bone_children_transforms);
ClassDB::bind_method(D_METHOD("set_motion_scale", "motion_scale"), &Skeleton3D::set_motion_scale);
ClassDB::bind_method(D_METHOD("get_motion_scale"), &Skeleton3D::get_motion_scale);
// Helper functions
ClassDB::bind_method(D_METHOD("global_pose_to_world_transform", "global_pose"), &Skeleton3D::global_pose_to_world_transform);
ClassDB::bind_method(D_METHOD("world_transform_to_global_pose", "world_transform"), &Skeleton3D::world_transform_to_global_pose);
ClassDB::bind_method(D_METHOD("global_pose_to_local_pose", "bone_idx", "global_pose"), &Skeleton3D::global_pose_to_local_pose);
ClassDB::bind_method(D_METHOD("local_pose_to_global_pose", "bone_idx", "local_pose"), &Skeleton3D::local_pose_to_global_pose);
ClassDB::bind_method(D_METHOD("global_pose_z_forward_to_bone_forward", "bone_idx", "basis"), &Skeleton3D::global_pose_z_forward_to_bone_forward);
ClassDB::bind_method(D_METHOD("set_show_rest_only", "enabled"), &Skeleton3D::set_show_rest_only);
ClassDB::bind_method(D_METHOD("is_show_rest_only"), &Skeleton3D::is_show_rest_only);
@ -1271,11 +1029,6 @@ void Skeleton3D::_bind_methods() {
ClassDB::bind_method(D_METHOD("physical_bones_add_collision_exception", "exception"), &Skeleton3D::physical_bones_add_collision_exception);
ClassDB::bind_method(D_METHOD("physical_bones_remove_collision_exception", "exception"), &Skeleton3D::physical_bones_remove_collision_exception);
// Modifications
ClassDB::bind_method(D_METHOD("set_modification_stack", "modification_stack"), &Skeleton3D::set_modification_stack);
ClassDB::bind_method(D_METHOD("get_modification_stack"), &Skeleton3D::get_modification_stack);
ClassDB::bind_method(D_METHOD("execute_modifications", "delta", "execution_mode"), &Skeleton3D::execute_modifications);
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "motion_scale", PROPERTY_HINT_RANGE, "0.001,10,0.001,or_greater"), "set_motion_scale", "get_motion_scale");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "show_rest_only"), "set_show_rest_only", "is_show_rest_only");
#ifndef _3D_DISABLED

55
scene/3d/skeleton_3d.h
View File

@ -32,7 +32,6 @@
#define SKELETON_3D_H
#include "scene/3d/node_3d.h"
#include "scene/resources/skeleton_modification_3d.h"
#include "scene/resources/skin.h"
typedef int BoneId;
@ -64,8 +63,6 @@ public:
~SkinReference();
};
class SkeletonModificationStack3D;
class Skeleton3D : public Node3D {
GDCLASS(Skeleton3D, Node3D);
@ -104,17 +101,8 @@ private:
PhysicalBone3D *physical_bone = nullptr;
PhysicalBone3D *cache_parent_physical_bone = nullptr;
real_t local_pose_override_amount;
bool local_pose_override_reset;
Transform3D local_pose_override;
Vector<int> child_bones;
// The forward direction vector and rest bone forward axis are cached because they do not change
// 99% of the time, but recalculating them can be expensive on models with many bones.
Vector3 rest_bone_forward_vector;
int rest_bone_forward_axis = -1;
Bone() {
parent = -1;
enabled = true;
@ -124,12 +112,7 @@ private:
physical_bone = nullptr;
cache_parent_physical_bone = nullptr;
#endif // _3D_DISABLED
local_pose_override_amount = 0;
local_pose_override_reset = false;
child_bones = Vector<int>();
rest_bone_forward_vector = Vector3(0, 0, 0);
rest_bone_forward_axis = -1;
}
};
@ -162,25 +145,13 @@ protected:
void _notification(int p_what);
static void _bind_methods();
#ifndef _3D_DISABLED
Ref<SkeletonModificationStack3D> modification_stack;
#endif // _3D_DISABLED
public:
enum Bone_Forward_Axis {
BONE_AXIS_X_FORWARD = 0,
BONE_AXIS_Y_FORWARD = 1,
BONE_AXIS_Z_FORWARD = 2,
BONE_AXIS_NEGATIVE_X_FORWARD = 3,
BONE_AXIS_NEGATIVE_Y_FORWARD = 4,
BONE_AXIS_NEGATIVE_Z_FORWARD = 5,
};
enum {
NOTIFICATION_UPDATE_SKELETON = 50
};
// skeleton creation api
uint64_t get_version() const;
void add_bone(const String &p_name);
int find_bone(const String &p_name) const;
String get_bone_name(int p_bone) const;
@ -233,10 +204,6 @@ public:
Transform3D get_bone_global_pose_override(int p_bone) const;
void set_bone_global_pose_override(int p_bone, const Transform3D &p_pose, real_t p_amount, bool p_persistent = false);
void clear_bones_local_pose_override();
Transform3D get_bone_local_pose_override(int p_bone) const;
void set_bone_local_pose_override(int p_bone, const Transform3D &p_pose, real_t p_amount, bool p_persistent = false);
void localize_rests(); // used for loaders and tools
Ref<Skin> create_skin_from_rest_transforms();
@ -247,26 +214,6 @@ public:
void force_update_all_bone_transforms();
void force_update_bone_children_transforms(int bone_idx);
void update_bone_rest_forward_vector(int p_bone, bool p_force_update = false);
void update_bone_rest_forward_axis(int p_bone, bool p_force_update = false);
Vector3 get_bone_axis_forward_vector(int p_bone);
int get_bone_axis_forward_enum(int p_bone);
// Helper functions
Transform3D global_pose_to_world_transform(Transform3D p_global_pose);
Transform3D world_transform_to_global_pose(Transform3D p_transform);
Transform3D global_pose_to_local_pose(int p_bone_idx, Transform3D p_global_pose);
Transform3D local_pose_to_global_pose(int p_bone_idx, Transform3D p_local_pose);
Basis global_pose_z_forward_to_bone_forward(int p_bone_idx, Basis p_basis);
// Modifications
#ifndef _3D_DISABLED
Ref<SkeletonModificationStack3D> get_modification_stack();
void set_modification_stack(Ref<SkeletonModificationStack3D> p_stack);
void execute_modifications(real_t p_delta, int p_execution_mode);
#endif // _3D_DISABLED
// Physical bone API
void set_animate_physical_bones(bool p_enabled);

23
scene/3d/skeleton_ik_3d.cpp
View File

@ -249,6 +249,26 @@ void FabrikInverseKinematic::make_goal(Task *p_task, const Transform3D &p_invers
}
}
static Vector3 get_bone_axis_forward_vector(Skeleton3D *skeleton, int p_bone) {
// If it is a child/leaf bone...
if (skeleton->get_bone_parent(p_bone) > 0) {
return skeleton->get_bone_rest(p_bone).origin.normalized();
}
// If it has children...
Vector<int> child_bones = skeleton->get_bone_children(p_bone);
if (child_bones.size() == 0) {
WARN_PRINT_ONCE("Cannot calculate forward direction for bone " + itos(p_bone));
WARN_PRINT_ONCE("Assuming direction of (0, 1, 0) for bone");
return Vector3(0, 1, 0);
}
Vector3 combined_child_dir = Vector3(0, 0, 0);
for (int i = 0; i < child_bones.size(); i++) {
combined_child_dir += skeleton->get_bone_rest(child_bones[i]).origin.normalized();
}
combined_child_dir = combined_child_dir / child_bones.size();
return combined_child_dir.normalized();
}
void FabrikInverseKinematic::solve(Task *p_task, real_t blending_delta, bool override_tip_basis, bool p_use_magnet, const Vector3 &p_magnet_position) {
if (blending_delta <= 0.01f) {
// Before skipping, make sure we undo the global pose overrides
@ -287,8 +307,7 @@ void FabrikInverseKinematic::solve(Task *p_task, real_t blending_delta, bool ove
new_bone_pose.origin = ci->current_pos;
if (!ci->children.is_empty()) {
p_task->skeleton->update_bone_rest_forward_vector(ci->bone);
Vector3 forward_vector = p_task->skeleton->get_bone_axis_forward_vector(ci->bone);
Vector3 forward_vector = get_bone_axis_forward_vector(p_task->skeleton, ci->bone);
// Rotate the bone towards the next bone in the chain:
new_bone_pose.basis.rotate_to_align(forward_vector, new_bone_pose.origin.direction_to(ci->children[0].current_pos));

17
scene/register_scene_types.cpp
View File

@ -184,15 +184,7 @@
#include "scene/resources/skeleton_modification_2d_physicalbones.h"
#include "scene/resources/skeleton_modification_2d_stackholder.h"
#include "scene/resources/skeleton_modification_2d_twoboneik.h"
#include "scene/resources/skeleton_modification_3d.h"
#include "scene/resources/skeleton_modification_3d_ccdik.h"
#include "scene/resources/skeleton_modification_3d_fabrik.h"
#include "scene/resources/skeleton_modification_3d_jiggle.h"
#include "scene/resources/skeleton_modification_3d_lookat.h"
#include "scene/resources/skeleton_modification_3d_stackholder.h"
#include "scene/resources/skeleton_modification_3d_twoboneik.h"
#include "scene/resources/skeleton_modification_stack_2d.h"
#include "scene/resources/skeleton_modification_stack_3d.h"
#include "scene/resources/skeleton_profile.h"
#include "scene/resources/sky.h"
#include "scene/resources/sky_material.h"
@ -833,15 +825,6 @@ void register_scene_types() {
GDREGISTER_CLASS(ConvexPolygonShape3D);
GDREGISTER_CLASS(ConcavePolygonShape3D);
GDREGISTER_CLASS(SkeletonModificationStack3D);
GDREGISTER_CLASS(SkeletonModification3D);
GDREGISTER_CLASS(SkeletonModification3DLookAt);
GDREGISTER_CLASS(SkeletonModification3DCCDIK);
GDREGISTER_CLASS(SkeletonModification3DFABRIK);
GDREGISTER_CLASS(SkeletonModification3DJiggle);
GDREGISTER_CLASS(SkeletonModification3DTwoBoneIK);
GDREGISTER_CLASS(SkeletonModification3DStackHolder);
OS::get_singleton()->yield(); // may take time to init
#endif // _3D_DISABLED

151
scene/resources/skeleton_modification_3d.cpp
View File

@ -1,151 +0,0 @@
/**************************************************************************/
/* skeleton_modification_3d.cpp */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/**************************************************************************/
#include "skeleton_modification_3d.h"
#include "scene/3d/skeleton_3d.h"
void SkeletonModification3D::_execute(real_t p_delta) {
GDVIRTUAL_CALL(_execute, p_delta);
if (!enabled) {
return;
}
}
void SkeletonModification3D::_setup_modification(SkeletonModificationStack3D *p_stack) {
stack = p_stack;
if (stack) {
is_setup = true;
} else {
WARN_PRINT("Could not setup modification with name " + this->get_name());
}
GDVIRTUAL_CALL(_setup_modification, Ref<SkeletonModificationStack3D>(p_stack));
}
void SkeletonModification3D::set_enabled(bool p_enabled) {
enabled = p_enabled;
}
bool SkeletonModification3D::get_enabled() {
return enabled;
}
// Helper function. Needed for CCDIK.
real_t SkeletonModification3D::clamp_angle(real_t p_angle, real_t p_min_bound, real_t p_max_bound, bool p_invert) {
// Map to the 0 to 360 range (in radians though) instead of the -180 to 180 range.
if (p_angle < 0) {
p_angle = Math_TAU + p_angle;
}
// Make min and max in the range of 0 to 360 (in radians), and make sure they are in the right order
if (p_min_bound < 0) {
p_min_bound = Math_TAU + p_min_bound;
}
if (p_max_bound < 0) {
p_max_bound = Math_TAU + p_max_bound;
}
if (p_min_bound > p_max_bound) {
SWAP(p_min_bound, p_max_bound);
}
bool is_beyond_bounds = (p_angle < p_min_bound || p_angle > p_max_bound);
bool is_within_bounds = (p_angle > p_min_bound && p_angle < p_max_bound);
// Note: May not be the most optimal way to clamp, but it always constraints to the nearest angle.
if ((!p_invert && is_beyond_bounds) || (p_invert && is_within_bounds)) {
Vector2 min_bound_vec = Vector2(Math::cos(p_min_bound), Math::sin(p_min_bound));
Vector2 max_bound_vec = Vector2(Math::cos(p_max_bound), Math::sin(p_max_bound));
Vector2 angle_vec = Vector2(Math::cos(p_angle), Math::sin(p_angle));
if (angle_vec.distance_squared_to(min_bound_vec) <= angle_vec.distance_squared_to(max_bound_vec)) {
p_angle = p_min_bound;
} else {
p_angle = p_max_bound;
}
}
return p_angle;
}
bool SkeletonModification3D::_print_execution_error(bool p_condition, String p_message) {
// If the modification is not setup, don't bother printing the error
if (!is_setup) {
return p_condition;
}
if (p_condition && !execution_error_found) {
ERR_PRINT(p_message);
execution_error_found = true;
}
return p_condition;
}
Ref<SkeletonModificationStack3D> SkeletonModification3D::get_modification_stack() {
return stack;
}
void SkeletonModification3D::set_is_setup(bool p_is_setup) {
is_setup = p_is_setup;
}
bool SkeletonModification3D::get_is_setup() const {
return is_setup;
}
void SkeletonModification3D::set_execution_mode(int p_mode) {
execution_mode = p_mode;
}
int SkeletonModification3D::get_execution_mode() const {
return execution_mode;
}
void SkeletonModification3D::_bind_methods() {
GDVIRTUAL_BIND(_execute, "delta");
GDVIRTUAL_BIND(_setup_modification, "modification_stack")
ClassDB::bind_method(D_METHOD("set_enabled", "enabled"), &SkeletonModification3D::set_enabled);
ClassDB::bind_method(D_METHOD("get_enabled"), &SkeletonModification3D::get_enabled);
ClassDB::bind_method(D_METHOD("get_modification_stack"), &SkeletonModification3D::get_modification_stack);
ClassDB::bind_method(D_METHOD("set_is_setup", "is_setup"), &SkeletonModification3D::set_is_setup);
ClassDB::bind_method(D_METHOD("get_is_setup"), &SkeletonModification3D::get_is_setup);
ClassDB::bind_method(D_METHOD("set_execution_mode", "execution_mode"), &SkeletonModification3D::set_execution_mode);
ClassDB::bind_method(D_METHOD("get_execution_mode"), &SkeletonModification3D::get_execution_mode);
ClassDB::bind_method(D_METHOD("clamp_angle", "angle", "min", "max", "invert"), &SkeletonModification3D::clamp_angle);
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "enabled"), "set_enabled", "get_enabled");
ADD_PROPERTY(PropertyInfo(Variant::INT, "execution_mode", PROPERTY_HINT_ENUM, "process,physics_process"), "set_execution_mode", "get_execution_mode");
}
SkeletonModification3D::SkeletonModification3D() {
stack = nullptr;
is_setup = false;
}

79
scene/resources/skeleton_modification_3d.h
View File

@ -1,79 +0,0 @@
/**************************************************************************/
/* skeleton_modification_3d.h */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/**************************************************************************/
#ifndef SKELETON_MODIFICATION_3D_H
#define SKELETON_MODIFICATION_3D_H
#include "scene/3d/skeleton_3d.h"
#include "scene/resources/skeleton_modification_stack_3d.h"
class SkeletonModificationStack3D;
class SkeletonModification3D : public Resource {
GDCLASS(SkeletonModification3D, Resource);
friend class Skeleton3D;
friend class SkeletonModificationStack3D;
protected:
static void _bind_methods();
SkeletonModificationStack3D *stack = nullptr;
int execution_mode = 0; // 0 = process
bool enabled = true;
bool is_setup = false;
bool execution_error_found = false;
bool _print_execution_error(bool p_condition, String p_message);
GDVIRTUAL1(_execute, double)
GDVIRTUAL1(_setup_modification, Ref<SkeletonModificationStack3D>)
public:
virtual void _execute(real_t p_delta);
virtual void _setup_modification(SkeletonModificationStack3D *p_stack);
real_t clamp_angle(real_t p_angle, real_t p_min_bound, real_t p_max_bound, bool p_invert);
void set_enabled(bool p_enabled);
bool get_enabled();
void set_execution_mode(int p_mode);
int get_execution_mode() const;
Ref<SkeletonModificationStack3D> get_modification_stack();
void set_is_setup(bool p_setup);
bool get_is_setup() const;
SkeletonModification3D();
};
#endif // SKELETON_MODIFICATION_3D_H

474
scene/resources/skeleton_modification_3d_ccdik.cpp
View File

@ -1,474 +0,0 @@
/**************************************************************************/
/* skeleton_modification_3d_ccdik.cpp */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/**************************************************************************/
#include "scene/resources/skeleton_modification_3d_ccdik.h"
#include "scene/3d/skeleton_3d.h"
#include "scene/resources/skeleton_modification_3d.h"
bool SkeletonModification3DCCDIK::_set(const StringName &p_path, const Variant &p_value) {
String path = p_path;
if (path.begins_with("joint_data/")) {
int ccdik_data_size = ccdik_data_chain.size();
int which = path.get_slicec('/', 1).to_int();
String what = path.get_slicec('/', 2);
ERR_FAIL_INDEX_V(which, ccdik_data_size, false);
if (what == "bone_name") {
set_ccdik_joint_bone_name(which, p_value);
} else if (what == "bone_index") {
set_ccdik_joint_bone_index(which, p_value);
} else if (what == "ccdik_axis") {
set_ccdik_joint_ccdik_axis(which, p_value);
} else if (what == "enable_joint_constraint") {
set_ccdik_joint_enable_constraint(which, p_value);
} else if (what == "joint_constraint_angle_min") {
set_ccdik_joint_constraint_angle_min(which, Math::deg_to_rad(real_t(p_value)));
} else if (what == "joint_constraint_angle_max") {
set_ccdik_joint_constraint_angle_max(which, Math::deg_to_rad(real_t(p_value)));
} else if (what == "joint_constraint_angles_invert") {
set_ccdik_joint_constraint_invert(which, p_value);
}
return true;
}
return true;
}
bool SkeletonModification3DCCDIK::_get(const StringName &p_path, Variant &r_ret) const {
String path = p_path;
if (path.begins_with("joint_data/")) {
const int ccdik_data_size = ccdik_data_chain.size();
int which = path.get_slicec('/', 1).to_int();
String what = path.get_slicec('/', 2);
ERR_FAIL_INDEX_V(which, ccdik_data_size, false);
if (what == "bone_name") {
r_ret = get_ccdik_joint_bone_name(which);
} else if (what == "bone_index") {
r_ret = get_ccdik_joint_bone_index(which);
} else if (what == "ccdik_axis") {
r_ret = get_ccdik_joint_ccdik_axis(which);
} else if (what == "enable_joint_constraint") {
r_ret = get_ccdik_joint_enable_constraint(which);
} else if (what == "joint_constraint_angle_min") {
r_ret = Math::rad_to_deg(get_ccdik_joint_constraint_angle_min(which));
} else if (what == "joint_constraint_angle_max") {
r_ret = Math::rad_to_deg(get_ccdik_joint_constraint_angle_max(which));
} else if (what == "joint_constraint_angles_invert") {
r_ret = get_ccdik_joint_constraint_invert(which);
}
return true;
}
return true;
}
void SkeletonModification3DCCDIK::_get_property_list(List<PropertyInfo> *p_list) const {
for (uint32_t i = 0; i < ccdik_data_chain.size(); i++) {
String base_string = "joint_data/" + itos(i) + "/";
p_list->push_back(PropertyInfo(Variant::STRING_NAME, base_string + "bone_name", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT));
p_list->push_back(PropertyInfo(Variant::INT, base_string + "bone_index", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT));
p_list->push_back(PropertyInfo(Variant::INT, base_string + "ccdik_axis",
PROPERTY_HINT_ENUM, "X Axis,Y Axis,Z Axis", PROPERTY_USAGE_DEFAULT));
p_list->push_back(PropertyInfo(Variant::BOOL, base_string + "enable_joint_constraint", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT));
if (ccdik_data_chain[i].enable_constraint) {
p_list->push_back(PropertyInfo(Variant::FLOAT, base_string + "joint_constraint_angle_min", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT));
p_list->push_back(PropertyInfo(Variant::FLOAT, base_string + "joint_constraint_angle_max", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT));
p_list->push_back(PropertyInfo(Variant::BOOL, base_string + "joint_constraint_angles_invert", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT));
}
}
}
void SkeletonModification3DCCDIK::_execute(real_t p_delta) {
ERR_FAIL_COND_MSG(!stack || !is_setup || stack->skeleton == nullptr,
"Modification is not setup and therefore cannot execute!");
if (!enabled) {
return;
}
if (target_node_cache.is_null()) {
_print_execution_error(true, "Target cache is out of date. Attempting to update");
update_target_cache();
return;
}
if (tip_node_cache.is_null()) {
_print_execution_error(true, "Tip cache is out of date. Attempting to update");
update_tip_cache();
return;
}
// Reset the local bone overrides for CCDIK affected nodes
for (uint32_t i = 0; i < ccdik_data_chain.size(); i++) {
stack->skeleton->set_bone_local_pose_override(ccdik_data_chain[i].bone_idx,
stack->skeleton->get_bone_local_pose_override(ccdik_data_chain[i].bone_idx),
0.0, false);
}
Node3D *node_target = Object::cast_to<Node3D>(ObjectDB::get_instance(target_node_cache));
Node3D *node_tip = Object::cast_to<Node3D>(ObjectDB::get_instance(tip_node_cache));
if (_print_execution_error(!node_target || !node_target->is_inside_tree(), "Target node is not in the scene tree. Cannot execute modification!")) {
return;
}
if (_print_execution_error(!node_tip || !node_tip->is_inside_tree(), "Tip node is not in the scene tree. Cannot execute modification!")) {
return;
}
if (use_high_quality_solve) {
for (uint32_t i = 0; i < ccdik_data_chain.size(); i++) {
for (uint32_t j = i; j < ccdik_data_chain.size(); j++) {
_execute_ccdik_joint(j, node_target, node_tip);
}
}
} else {
for (uint32_t i = 0; i < ccdik_data_chain.size(); i++) {
_execute_ccdik_joint(i, node_target, node_tip);
}
}
execution_error_found = false;
}
void SkeletonModification3DCCDIK::_execute_ccdik_joint(int p_joint_idx, Node3D *p_target, Node3D *p_tip) {
CCDIK_Joint_Data ccdik_data = ccdik_data_chain[p_joint_idx];
if (_print_execution_error(ccdik_data.bone_idx < 0 || ccdik_data.bone_idx > stack->skeleton->get_bone_count(),
"CCDIK joint: bone index for joint" + itos(p_joint_idx) + " not found. Cannot execute modification!")) {
return;
}
Transform3D bone_trans = stack->skeleton->global_pose_to_local_pose(ccdik_data.bone_idx, stack->skeleton->get_bone_global_pose(ccdik_data.bone_idx));
Transform3D tip_trans = stack->skeleton->global_pose_to_local_pose(ccdik_data.bone_idx, stack->skeleton->world_transform_to_global_pose(p_tip->get_global_transform()));
Transform3D target_trans = stack->skeleton->global_pose_to_local_pose(ccdik_data.bone_idx, stack->skeleton->world_transform_to_global_pose(p_target->get_global_transform()));
if (tip_trans.origin.distance_to(target_trans.origin) <= 0.01) {
return;
}
// Inspired (and very loosely based on) by the CCDIK algorithm made by Zalo on GitHub (https://github.com/zalo/MathUtilities)
// Convert the 3D position to a 2D position so we can use Atan2 (via the angle function)
// to know how much rotation we need on the given axis to place the tip at the target.
Vector2 tip_pos_2d;
Vector2 target_pos_2d;
if (ccdik_data.ccdik_axis == CCDIK_Axes::AXIS_X) {
tip_pos_2d = Vector2(tip_trans.origin.y, tip_trans.origin.z);
target_pos_2d = Vector2(target_trans.origin.y, target_trans.origin.z);
bone_trans.basis.rotate_local(Vector3(1, 0, 0), target_pos_2d.angle() - tip_pos_2d.angle());
} else if (ccdik_data.ccdik_axis == CCDIK_Axes::AXIS_Y) {
tip_pos_2d = Vector2(tip_trans.origin.z, tip_trans.origin.x);
target_pos_2d = Vector2(target_trans.origin.z, target_trans.origin.x);
bone_trans.basis.rotate_local(Vector3(0, 1, 0), target_pos_2d.angle() - tip_pos_2d.angle());
} else if (ccdik_data.ccdik_axis == CCDIK_Axes::AXIS_Z) {
tip_pos_2d = Vector2(tip_trans.origin.x, tip_trans.origin.y);
target_pos_2d = Vector2(target_trans.origin.x, target_trans.origin.y);
bone_trans.basis.rotate_local(Vector3(0, 0, 1), target_pos_2d.angle() - tip_pos_2d.angle());
} else {
// Should never happen, but...
ERR_FAIL_MSG("CCDIK joint: Unknown axis vector passed for joint" + itos(p_joint_idx) + ". Cannot execute modification!");
}
if (ccdik_data.enable_constraint) {
Vector3 rotation_axis;
real_t rotation_angle;
bone_trans.basis.get_axis_angle(rotation_axis, rotation_angle);
// Note: When the axis has a negative direction, the angle is OVER 180 degrees and therefore we need to account for this
// when constraining.
if (ccdik_data.ccdik_axis == CCDIK_Axes::AXIS_X) {
if (rotation_axis.x < 0) {
rotation_angle += Math_PI;
rotation_axis = Vector3(1, 0, 0);
}
} else if (ccdik_data.ccdik_axis == CCDIK_Axes::AXIS_Y) {
if (rotation_axis.y < 0) {
rotation_angle += Math_PI;
rotation_axis = Vector3(0, 1, 0);
}
} else if (ccdik_data.ccdik_axis == CCDIK_Axes::AXIS_Z) {
if (rotation_axis.z < 0) {
rotation_angle += Math_PI;
rotation_axis = Vector3(0, 0, 1);
}
} else {
// Should never happen, but...
ERR_FAIL_MSG("CCDIK joint: Unknown axis vector passed for joint" + itos(p_joint_idx) + ". Cannot execute modification!");
}
rotation_angle = clamp_angle(rotation_angle, ccdik_data.constraint_angle_min, ccdik_data.constraint_angle_max, ccdik_data.constraint_angles_invert);
bone_trans.basis.set_axis_angle(rotation_axis, rotation_angle);
}
stack->skeleton->set_bone_local_pose_override(ccdik_data.bone_idx, bone_trans, stack->strength, true);
stack->skeleton->force_update_bone_children_transforms(ccdik_data.bone_idx);
}
void SkeletonModification3DCCDIK::_setup_modification(SkeletonModificationStack3D *p_stack) {
stack = p_stack;
if (stack != nullptr) {
is_setup = true;
execution_error_found = false;
update_target_cache();
update_tip_cache();
}
}
void SkeletonModification3DCCDIK::update_target_cache() {
if (!is_setup || !stack) {
_print_execution_error(true, "Cannot update target cache: modification is not properly setup!");
return;
}
target_node_cache = ObjectID();
if (stack->skeleton) {
if (stack->skeleton->is_inside_tree()) {
if (stack->skeleton->has_node(target_node)) {
Node *node = stack->skeleton->get_node(target_node);
ERR_FAIL_COND_MSG(!node || stack->skeleton == node,
"Cannot update target cache: node is this modification's skeleton or cannot be found!");
ERR_FAIL_COND_MSG(!node->is_inside_tree(),
"Cannot update target cache: node is not in scene tree!");
target_node_cache = node->get_instance_id();
execution_error_found = false;
}
}
}
}
void SkeletonModification3DCCDIK::update_tip_cache() {
if (!is_setup || !stack) {
_print_execution_error(true, "Cannot update tip cache: modification is not properly setup!");
return;
}
tip_node_cache = ObjectID();
if (stack->skeleton) {
if (stack->skeleton->is_inside_tree()) {
if (stack->skeleton->has_node(tip_node)) {
Node *node = stack->skeleton->get_node(tip_node);
ERR_FAIL_COND_MSG(!node || stack->skeleton == node,
"Cannot update tip cache: node is this modification's skeleton or cannot be found!");
ERR_FAIL_COND_MSG(!node->is_inside_tree(),
"Cannot update tip cache: node is not in scene tree!");
tip_node_cache = node->get_instance_id();
execution_error_found = false;
}
}
}
}
void SkeletonModification3DCCDIK::set_target_node(const NodePath &p_target_node) {
target_node = p_target_node;
update_target_cache();
}
NodePath SkeletonModification3DCCDIK::get_target_node() const {
return target_node;
}
void SkeletonModification3DCCDIK::set_tip_node(const NodePath &p_tip_node) {
tip_node = p_tip_node;
update_tip_cache();
}
NodePath SkeletonModification3DCCDIK::get_tip_node() const {
return tip_node;
}
void SkeletonModification3DCCDIK::set_use_high_quality_solve(bool p_high_quality) {
use_high_quality_solve = p_high_quality;
}
bool SkeletonModification3DCCDIK::get_use_high_quality_solve() const {
return use_high_quality_solve;
}
// CCDIK joint data functions
String SkeletonModification3DCCDIK::get_ccdik_joint_bone_name(int p_joint_idx) const {
const int bone_chain_size = ccdik_data_chain.size();
ERR_FAIL_INDEX_V(p_joint_idx, bone_chain_size, String());
return ccdik_data_chain[p_joint_idx].bone_name;
}
void SkeletonModification3DCCDIK::set_ccdik_joint_bone_name(int p_joint_idx, String p_bone_name) {
const int bone_chain_size = ccdik_data_chain.size();
ERR_FAIL_INDEX(p_joint_idx, bone_chain_size);
ccdik_data_chain[p_joint_idx].bone_name = p_bone_name;
if (stack) {
if (stack->skeleton) {
ccdik_data_chain[p_joint_idx].bone_idx = stack->skeleton->find_bone(p_bone_name);
}
}
execution_error_found = false;
notify_property_list_changed();
}
int SkeletonModification3DCCDIK::get_ccdik_joint_bone_index(int p_joint_idx) const {
const int bone_chain_size = ccdik_data_chain.size();
ERR_FAIL_INDEX_V(p_joint_idx, bone_chain_size, -1);
return ccdik_data_chain[p_joint_idx].bone_idx;
}
void SkeletonModification3DCCDIK::set_ccdik_joint_bone_index(int p_joint_idx, int p_bone_idx) {
const int bone_chain_size = ccdik_data_chain.size();
ERR_FAIL_INDEX(p_joint_idx, bone_chain_size);
ERR_FAIL_COND_MSG(p_bone_idx < 0, "Bone index is out of range: The index is too low!");
ccdik_data_chain[p_joint_idx].bone_idx = p_bone_idx;
if (stack) {
if (stack->skeleton) {
ccdik_data_chain[p_joint_idx].bone_name = stack->skeleton->get_bone_name(p_bone_idx);
}
}
execution_error_found = false;
notify_property_list_changed();
}
int SkeletonModification3DCCDIK::get_ccdik_joint_ccdik_axis(int p_joint_idx) const {
const int bone_chain_size = ccdik_data_chain.size();
ERR_FAIL_INDEX_V(p_joint_idx, bone_chain_size, -1);
return ccdik_data_chain[p_joint_idx].ccdik_axis;
}
void SkeletonModification3DCCDIK::set_ccdik_joint_ccdik_axis(int p_joint_idx, int p_axis) {
const int bone_chain_size = ccdik_data_chain.size();
ERR_FAIL_INDEX(p_joint_idx, bone_chain_size);
ERR_FAIL_COND_MSG(p_axis < 0, "CCDIK axis is out of range: The axis mode is too low!");
ccdik_data_chain[p_joint_idx].ccdik_axis = p_axis;
notify_property_list_changed();
}
bool SkeletonModification3DCCDIK::get_ccdik_joint_enable_constraint(int p_joint_idx) const {
const int bone_chain_size = ccdik_data_chain.size();
ERR_FAIL_INDEX_V(p_joint_idx, bone_chain_size, false);
return ccdik_data_chain[p_joint_idx].enable_constraint;
}
void SkeletonModification3DCCDIK::set_ccdik_joint_enable_constraint(int p_joint_idx, bool p_enable) {
const int bone_chain_size = ccdik_data_chain.size();
ERR_FAIL_INDEX(p_joint_idx, bone_chain_size);
ccdik_data_chain[p_joint_idx].enable_constraint = p_enable;
notify_property_list_changed();
}
real_t SkeletonModification3DCCDIK::get_ccdik_joint_constraint_angle_min(int p_joint_idx) const {
const int bone_chain_size = ccdik_data_chain.size();
ERR_FAIL_INDEX_V(p_joint_idx, bone_chain_size, false);
return ccdik_data_chain[p_joint_idx].constraint_angle_min;
}
void SkeletonModification3DCCDIK::set_ccdik_joint_constraint_angle_min(int p_joint_idx, real_t p_angle_min) {
const int bone_chain_size = ccdik_data_chain.size();
ERR_FAIL_INDEX(p_joint_idx, bone_chain_size);
ccdik_data_chain[p_joint_idx].constraint_angle_min = p_angle_min;
}
real_t SkeletonModification3DCCDIK::get_ccdik_joint_constraint_angle_max(int p_joint_idx) const {
const int bone_chain_size = ccdik_data_chain.size();
ERR_FAIL_INDEX_V(p_joint_idx, bone_chain_size, false);
return ccdik_data_chain[p_joint_idx].constraint_angle_max;
}
void SkeletonModification3DCCDIK::set_ccdik_joint_constraint_angle_max(int p_joint_idx, real_t p_angle_max) {
const int bone_chain_size = ccdik_data_chain.size();
ERR_FAIL_INDEX(p_joint_idx, bone_chain_size);
ccdik_data_chain[p_joint_idx].constraint_angle_max = p_angle_max;
}
bool SkeletonModification3DCCDIK::get_ccdik_joint_constraint_invert(int p_joint_idx) const {
const int bone_chain_size = ccdik_data_chain.size();
ERR_FAIL_INDEX_V(p_joint_idx, bone_chain_size, false);
return ccdik_data_chain[p_joint_idx].constraint_angles_invert;
}
void SkeletonModification3DCCDIK::set_ccdik_joint_constraint_invert(int p_joint_idx, bool p_invert) {
const int bone_chain_size = ccdik_data_chain.size();
ERR_FAIL_INDEX(p_joint_idx, bone_chain_size);
ccdik_data_chain[p_joint_idx].constraint_angles_invert = p_invert;
}
int SkeletonModification3DCCDIK::get_ccdik_data_chain_length() {
return ccdik_data_chain.size();
}
void SkeletonModification3DCCDIK::set_ccdik_data_chain_length(int p_length) {
ERR_FAIL_COND(p_length < 0);
ccdik_data_chain.resize(p_length);
execution_error_found = false;
notify_property_list_changed();
}
void SkeletonModification3DCCDIK::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_target_node", "target_nodepath"), &SkeletonModification3DCCDIK::set_target_node);
ClassDB::bind_method(D_METHOD("get_target_node"), &SkeletonModification3DCCDIK::get_target_node);
ClassDB::bind_method(D_METHOD("set_tip_node", "tip_nodepath"), &SkeletonModification3DCCDIK::set_tip_node);
ClassDB::bind_method(D_METHOD("get_tip_node"), &SkeletonModification3DCCDIK::get_tip_node);
ClassDB::bind_method(D_METHOD("set_use_high_quality_solve", "high_quality_solve"), &SkeletonModification3DCCDIK::set_use_high_quality_solve);
ClassDB::bind_method(D_METHOD("get_use_high_quality_solve"), &SkeletonModification3DCCDIK::get_use_high_quality_solve);
// CCDIK joint data functions
ClassDB::bind_method(D_METHOD("get_ccdik_joint_bone_name", "joint_idx"), &SkeletonModification3DCCDIK::get_ccdik_joint_bone_name);
ClassDB::bind_method(D_METHOD("set_ccdik_joint_bone_name", "joint_idx", "bone_name"), &SkeletonModification3DCCDIK::set_ccdik_joint_bone_name);
ClassDB::bind_method(D_METHOD("get_ccdik_joint_bone_index", "joint_idx"), &SkeletonModification3DCCDIK::get_ccdik_joint_bone_index);
ClassDB::bind_method(D_METHOD("set_ccdik_joint_bone_index", "joint_idx", "bone_index"), &SkeletonModification3DCCDIK::set_ccdik_joint_bone_index);
ClassDB::bind_method(D_METHOD("get_ccdik_joint_ccdik_axis", "joint_idx"), &SkeletonModification3DCCDIK::get_ccdik_joint_ccdik_axis);
ClassDB::bind_method(D_METHOD("set_ccdik_joint_ccdik_axis", "joint_idx", "axis"), &SkeletonModification3DCCDIK::set_ccdik_joint_ccdik_axis);
ClassDB::bind_method(D_METHOD("get_ccdik_joint_enable_joint_constraint", "joint_idx"), &SkeletonModification3DCCDIK::get_ccdik_joint_enable_constraint);
ClassDB::bind_method(D_METHOD("set_ccdik_joint_enable_joint_constraint", "joint_idx", "enable"), &SkeletonModification3DCCDIK::set_ccdik_joint_enable_constraint);
ClassDB::bind_method(D_METHOD("get_ccdik_joint_constraint_angle_min", "joint_idx"), &SkeletonModification3DCCDIK::get_ccdik_joint_constraint_angle_min);
ClassDB::bind_method(D_METHOD("set_ccdik_joint_constraint_angle_min", "joint_idx", "min_angle"), &SkeletonModification3DCCDIK::set_ccdik_joint_constraint_angle_min);
ClassDB::bind_method(D_METHOD("get_ccdik_joint_constraint_angle_max", "joint_idx"), &SkeletonModification3DCCDIK::get_ccdik_joint_constraint_angle_max);
ClassDB::bind_method(D_METHOD("set_ccdik_joint_constraint_angle_max", "joint_idx", "max_angle"), &SkeletonModification3DCCDIK::set_ccdik_joint_constraint_angle_max);
ClassDB::bind_method(D_METHOD("get_ccdik_joint_constraint_invert", "joint_idx"), &SkeletonModification3DCCDIK::get_ccdik_joint_constraint_invert);
ClassDB::bind_method(D_METHOD("set_ccdik_joint_constraint_invert", "joint_idx", "invert"), &SkeletonModification3DCCDIK::set_ccdik_joint_constraint_invert);
ClassDB::bind_method(D_METHOD("set_ccdik_data_chain_length", "length"), &SkeletonModification3DCCDIK::set_ccdik_data_chain_length);
ClassDB::bind_method(D_METHOD("get_ccdik_data_chain_length"), &SkeletonModification3DCCDIK::get_ccdik_data_chain_length);
ADD_PROPERTY(PropertyInfo(Variant::NODE_PATH, "target_nodepath", PROPERTY_HINT_NODE_PATH_VALID_TYPES, "Node3D"), "set_target_node", "get_target_node");
ADD_PROPERTY(PropertyInfo(Variant::NODE_PATH, "tip_nodepath", PROPERTY_HINT_NODE_PATH_VALID_TYPES, "Node3D"), "set_tip_node", "get_tip_node");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "high_quality_solve", PROPERTY_HINT_NONE, ""), "set_use_high_quality_solve", "get_use_high_quality_solve");
ADD_PROPERTY(PropertyInfo(Variant::INT, "ccdik_data_chain_length", PROPERTY_HINT_RANGE, "0,100,1"), "set_ccdik_data_chain_length", "get_ccdik_data_chain_length");
}
SkeletonModification3DCCDIK::SkeletonModification3DCCDIK() {
stack = nullptr;
is_setup = false;
enabled = true;
}
SkeletonModification3DCCDIK::~SkeletonModification3DCCDIK() {
}

114
scene/resources/skeleton_modification_3d_ccdik.h
View File

@ -1,114 +0,0 @@
/**************************************************************************/
/* skeleton_modification_3d_ccdik.h */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/**************************************************************************/
#ifndef SKELETON_MODIFICATION_3D_CCDIK_H
#define SKELETON_MODIFICATION_3D_CCDIK_H
#include "core/templates/local_vector.h"
#include "scene/3d/skeleton_3d.h"
#include "scene/resources/skeleton_modification_3d.h"
class SkeletonModification3DCCDIK : public SkeletonModification3D {
GDCLASS(SkeletonModification3DCCDIK, SkeletonModification3D);
private:
enum CCDIK_Axes {
AXIS_X,
AXIS_Y,
AXIS_Z
};
struct CCDIK_Joint_Data {
String bone_name = "";
int bone_idx = -1;
int ccdik_axis = 0;
bool enable_constraint = false;
real_t constraint_angle_min = 0;
real_t constraint_angle_max = (2.0 * Math_PI);
bool constraint_angles_invert = false;
};
LocalVector<CCDIK_Joint_Data> ccdik_data_chain;
NodePath target_node;
ObjectID target_node_cache;
NodePath tip_node;
ObjectID tip_node_cache;
bool use_high_quality_solve = true;
void update_target_cache();
void update_tip_cache();
void _execute_ccdik_joint(int p_joint_idx, Node3D *p_target, Node3D *p_tip);
protected:
static void _bind_methods();
bool _get(const StringName &p_path, Variant &r_ret) const;
bool _set(const StringName &p_path, const Variant &p_value);
void _get_property_list(List<PropertyInfo> *p_list) const;
public:
virtual void _execute(real_t p_delta) override;
virtual void _setup_modification(SkeletonModificationStack3D *p_stack) override;
void set_target_node(const NodePath &p_target_node);
NodePath get_target_node() const;
void set_tip_node(const NodePath &p_tip_node);
NodePath get_tip_node() const;
void set_use_high_quality_solve(bool p_solve);
bool get_use_high_quality_solve() const;
String get_ccdik_joint_bone_name(int p_joint_idx) const;
void set_ccdik_joint_bone_name(int p_joint_idx, String p_bone_name);
int get_ccdik_joint_bone_index(int p_joint_idx) const;
void set_ccdik_joint_bone_index(int p_joint_idx, int p_bone_idx);
int get_ccdik_joint_ccdik_axis(int p_joint_idx) const;
void set_ccdik_joint_ccdik_axis(int p_joint_idx, int p_axis);
bool get_ccdik_joint_enable_constraint(int p_joint_idx) const;
void set_ccdik_joint_enable_constraint(int p_joint_idx, bool p_enable);
real_t get_ccdik_joint_constraint_angle_min(int p_joint_idx) const;
void set_ccdik_joint_constraint_angle_min(int p_joint_idx, real_t p_angle_min);
real_t get_ccdik_joint_constraint_angle_max(int p_joint_idx) const;
void set_ccdik_joint_constraint_angle_max(int p_joint_idx, real_t p_angle_max);
bool get_ccdik_joint_constraint_invert(int p_joint_idx) const;
void set_ccdik_joint_constraint_invert(int p_joint_idx, bool p_invert);
int get_ccdik_data_chain_length();
void set_ccdik_data_chain_length(int p_new_length);
SkeletonModification3DCCDIK();
~SkeletonModification3DCCDIK();
};
#endif // SKELETON_MODIFICATION_3D_CCDIK_H

628
scene/resources/skeleton_modification_3d_fabrik.cpp
View File

@ -1,628 +0,0 @@
/**************************************************************************/
/* skeleton_modification_3d_fabrik.cpp */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/**************************************************************************/
#include "scene/resources/skeleton_modification_3d_fabrik.h"
#include "scene/3d/skeleton_3d.h"
#include "scene/resources/skeleton_modification_3d.h"
bool SkeletonModification3DFABRIK::_set(const StringName &p_path, const Variant &p_value) {
String path = p_path;
if (path.begins_with("joint_data/")) {
int fabrik_data_size = fabrik_data_chain.size();
int which = path.get_slicec('/', 1).to_int();
String what = path.get_slicec('/', 2);
ERR_FAIL_INDEX_V(which, fabrik_data_size, false);
if (what == "bone_name") {
set_fabrik_joint_bone_name(which, p_value);
} else if (what == "bone_index") {
set_fabrik_joint_bone_index(which, p_value);
} else if (what == "length") {
set_fabrik_joint_length(which, p_value);
} else if (what == "magnet_position") {
set_fabrik_joint_magnet(which, p_value);
} else if (what == "auto_calculate_length") {
set_fabrik_joint_auto_calculate_length(which, p_value);
} else if (what == "use_tip_node") {
set_fabrik_joint_use_tip_node(which, p_value);
} else if (what == "tip_node") {
set_fabrik_joint_tip_node(which, p_value);
} else if (what == "use_target_basis") {
set_fabrik_joint_use_target_basis(which, p_value);
} else if (what == "roll") {
set_fabrik_joint_roll(which, Math::deg_to_rad(real_t(p_value)));
}
return true;
}
return true;
}
bool SkeletonModification3DFABRIK::_get(const StringName &p_path, Variant &r_ret) const {
String path = p_path;
if (path.begins_with("joint_data/")) {
const int fabrik_data_size = fabrik_data_chain.size();
int which = path.get_slicec('/', 1).to_int();
String what = path.get_slicec('/', 2);
ERR_FAIL_INDEX_V(which, fabrik_data_size, false);
if (what == "bone_name") {
r_ret = get_fabrik_joint_bone_name(which);
} else if (what == "bone_index") {
r_ret = get_fabrik_joint_bone_index(which);
} else if (what == "length") {
r_ret = get_fabrik_joint_length(which);
} else if (what == "magnet_position") {
r_ret = get_fabrik_joint_magnet(which);
} else if (what == "auto_calculate_length") {
r_ret = get_fabrik_joint_auto_calculate_length(which);
} else if (what == "use_tip_node") {
r_ret = get_fabrik_joint_use_tip_node(which);
} else if (what == "tip_node") {
r_ret = get_fabrik_joint_tip_node(which);
} else if (what == "use_target_basis") {
r_ret = get_fabrik_joint_use_target_basis(which);
} else if (what == "roll") {
r_ret = Math::rad_to_deg(get_fabrik_joint_roll(which));
}
return true;
}
return true;
}
void SkeletonModification3DFABRIK::_get_property_list(List<PropertyInfo> *p_list) const {
for (uint32_t i = 0; i < fabrik_data_chain.size(); i++) {
String base_string = "joint_data/" + itos(i) + "/";
p_list->push_back(PropertyInfo(Variant::STRING_NAME, base_string + "bone_name", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT));
p_list->push_back(PropertyInfo(Variant::INT, base_string + "bone_index", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT));
p_list->push_back(PropertyInfo(Variant::FLOAT, base_string + "roll", PROPERTY_HINT_RANGE, "-360,360,0.01", PROPERTY_USAGE_DEFAULT));
p_list->push_back(PropertyInfo(Variant::BOOL, base_string + "auto_calculate_length", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT));
if (!fabrik_data_chain[i].auto_calculate_length) {
p_list->push_back(PropertyInfo(Variant::FLOAT, base_string + "length", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT));
} else {
p_list->push_back(PropertyInfo(Variant::BOOL, base_string + "use_tip_node", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT));
if (fabrik_data_chain[i].use_tip_node) {
p_list->push_back(PropertyInfo(Variant::NODE_PATH, base_string + "tip_node", PROPERTY_HINT_NODE_PATH_VALID_TYPES, "Node3D", PROPERTY_USAGE_DEFAULT));
}
}
// Cannot apply magnet to the origin of the chain, as it will not do anything.
if (i > 0) {
p_list->push_back(PropertyInfo(Variant::VECTOR3, base_string + "magnet_position", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT));
}
// Only give the override basis option on the last bone in the chain, so only include it for the last bone.
if (i == fabrik_data_chain.size() - 1) {
p_list->push_back(PropertyInfo(Variant::BOOL, base_string + "use_target_basis", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT));
}
}
}
void SkeletonModification3DFABRIK::_execute(real_t p_delta) {
ERR_FAIL_COND_MSG(!stack || !is_setup || stack->skeleton == nullptr,
"Modification is not setup and therefore cannot execute!");
if (!enabled) {
return;
}
if (target_node_cache.is_null()) {
_print_execution_error(true, "Target cache is out of date. Attempting to update...");
update_target_cache();
return;
}
if (_print_execution_error(fabrik_data_chain.size() <= 1, "FABRIK requires at least two joints to operate. Cannot execute modification!")) {
return;
}
Node3D *node_target = Object::cast_to<Node3D>(ObjectDB::get_instance(target_node_cache));
if (_print_execution_error(!node_target || !node_target->is_inside_tree(), "Target node is not in the scene tree. Cannot execute modification!")) {
return;
}
// Make sure the transform cache is the correct size
if (fabrik_transforms.size() != fabrik_data_chain.size()) {
fabrik_transforms.resize(fabrik_data_chain.size());
}
// Verify that all joints have a valid bone ID, and that all bone lengths are zero or more
// Also, while we are here, apply magnet positions.
for (uint32_t i = 0; i < fabrik_data_chain.size(); i++) {
if (_print_execution_error(fabrik_data_chain[i].bone_idx < 0, "FABRIK Joint " + itos(i) + " has an invalid bone ID. Cannot execute!")) {
return;
}
if (fabrik_data_chain[i].length < 0 && fabrik_data_chain[i].auto_calculate_length) {
fabrik_joint_auto_calculate_length(i);
}
if (_print_execution_error(fabrik_data_chain[i].length < 0, "FABRIK Joint " + itos(i) + " has an invalid joint length. Cannot execute!")) {
return;
}
fabrik_transforms[i] = stack->skeleton->get_bone_global_pose(fabrik_data_chain[i].bone_idx);
// Apply magnet positions:
if (stack->skeleton->get_bone_parent(fabrik_data_chain[i].bone_idx) >= 0) {
int parent_bone_idx = stack->skeleton->get_bone_parent(fabrik_data_chain[i].bone_idx);
Transform3D conversion_transform = (stack->skeleton->get_bone_global_pose(parent_bone_idx));
fabrik_transforms[i].origin += conversion_transform.basis.xform_inv(fabrik_data_chain[i].magnet_position);
} else {
fabrik_transforms[i].origin += fabrik_data_chain[i].magnet_position;
}
}
Transform3D origin_global_pose_trans = stack->skeleton->get_bone_global_pose_no_override(fabrik_data_chain[0].bone_idx);
target_global_pose = stack->skeleton->world_transform_to_global_pose(node_target->get_global_transform());
origin_global_pose = origin_global_pose_trans;
final_joint_idx = fabrik_data_chain.size() - 1;
real_t target_distance = fabrik_transforms[final_joint_idx].origin.distance_to(target_global_pose.origin);
chain_iterations = 0;
while (target_distance > chain_tolerance) {
chain_backwards();
chain_forwards();
// update the target distance
target_distance = fabrik_transforms[final_joint_idx].origin.distance_to(target_global_pose.origin);
// update chain iterations
chain_iterations += 1;
if (chain_iterations >= chain_max_iterations) {
break;
}
}
chain_apply();
execution_error_found = false;
}
void SkeletonModification3DFABRIK::chain_backwards() {
int final_bone_idx = fabrik_data_chain[final_joint_idx].bone_idx;
Transform3D final_joint_trans = fabrik_transforms[final_joint_idx];
// Get the direction the final bone is facing in.
stack->skeleton->update_bone_rest_forward_vector(final_bone_idx);
Transform3D final_bone_direction_trans = final_joint_trans.looking_at(target_global_pose.origin, Vector3(0, 1, 0));
final_bone_direction_trans.basis = stack->skeleton->global_pose_z_forward_to_bone_forward(final_bone_idx, final_bone_direction_trans.basis);
Vector3 direction = final_bone_direction_trans.basis.xform(stack->skeleton->get_bone_axis_forward_vector(final_bone_idx)).normalized();
// If set to override, then use the target's Basis rather than the bone's
if (fabrik_data_chain[final_joint_idx].use_target_basis) {
direction = target_global_pose.basis.xform(stack->skeleton->get_bone_axis_forward_vector(final_bone_idx)).normalized();
}
// set the position of the final joint to the target position
final_joint_trans.origin = target_global_pose.origin - (direction * fabrik_data_chain[final_joint_idx].length);
fabrik_transforms[final_joint_idx] = final_joint_trans;
// for all other joints, move them towards the target
int i = final_joint_idx;
while (i >= 1) {
Transform3D next_bone_trans = fabrik_transforms[i];
i -= 1;
Transform3D current_trans = fabrik_transforms[i];
real_t length = fabrik_data_chain[i].length / (current_trans.origin.distance_to(next_bone_trans.origin));
current_trans.origin = next_bone_trans.origin.lerp(current_trans.origin, length);
// Save the result
fabrik_transforms[i] = current_trans;
}
}
void SkeletonModification3DFABRIK::chain_forwards() {
// Set root at the initial position.
Transform3D root_transform = fabrik_transforms[0];
root_transform.origin = origin_global_pose.origin;
fabrik_transforms[0] = origin_global_pose;
for (uint32_t i = 0; i < fabrik_data_chain.size() - 1; i++) {
Transform3D current_trans = fabrik_transforms[i];
Transform3D next_bone_trans = fabrik_transforms[i + 1];
real_t length = fabrik_data_chain[i].length / (next_bone_trans.origin.distance_to(current_trans.origin));
next_bone_trans.origin = current_trans.origin.lerp(next_bone_trans.origin, length);
// Save the result
fabrik_transforms[i + 1] = next_bone_trans;
}
}
void SkeletonModification3DFABRIK::chain_apply() {
for (uint32_t i = 0; i < fabrik_data_chain.size(); i++) {
int current_bone_idx = fabrik_data_chain[i].bone_idx;
Transform3D current_trans = fabrik_transforms[i];
// If this is the last bone in the chain...
if (i == fabrik_data_chain.size() - 1) {
if (fabrik_data_chain[i].use_target_basis == false) { // Point to target...
// Get the forward direction that the basis is facing in right now.
stack->skeleton->update_bone_rest_forward_vector(current_bone_idx);
Vector3 forward_vector = stack->skeleton->get_bone_axis_forward_vector(current_bone_idx);
// Rotate the bone towards the target:
current_trans.basis.rotate_to_align(forward_vector, current_trans.origin.direction_to(target_global_pose.origin));
current_trans.basis.rotate_local(forward_vector, fabrik_data_chain[i].roll);
} else { // Use the target's Basis...
current_trans.basis = target_global_pose.basis.orthonormalized().scaled(current_trans.basis.get_scale());
}
} else { // every other bone in the chain...
Transform3D next_trans = fabrik_transforms[i + 1];
// Get the forward direction that the basis is facing in right now.
stack->skeleton->update_bone_rest_forward_vector(current_bone_idx);
Vector3 forward_vector = stack->skeleton->get_bone_axis_forward_vector(current_bone_idx);
// Rotate the bone towards the next bone in the chain:
current_trans.basis.rotate_to_align(forward_vector, current_trans.origin.direction_to(next_trans.origin));
current_trans.basis.rotate_local(forward_vector, fabrik_data_chain[i].roll);
}
stack->skeleton->set_bone_local_pose_override(current_bone_idx, stack->skeleton->global_pose_to_local_pose(current_bone_idx, current_trans), stack->strength, true);
}
// Update all the bones so the next modification has up-to-date data.
stack->skeleton->force_update_all_bone_transforms();
}
void SkeletonModification3DFABRIK::_setup_modification(SkeletonModificationStack3D *p_stack) {
stack = p_stack;
if (stack != nullptr) {
is_setup = true;
execution_error_found = false;
update_target_cache();
for (uint32_t i = 0; i < fabrik_data_chain.size(); i++) {
update_joint_tip_cache(i);
}
}
}
void SkeletonModification3DFABRIK::update_target_cache() {
if (!is_setup || !stack) {
_print_execution_error(true, "Cannot update target cache: modification is not properly setup!");
return;
}
target_node_cache = ObjectID();
if (stack->skeleton) {
if (stack->skeleton->is_inside_tree() && target_node.is_empty() == false) {
if (stack->skeleton->has_node(target_node)) {
Node *node = stack->skeleton->get_node(target_node);
ERR_FAIL_COND_MSG(!node || stack->skeleton == node,
"Cannot update target cache: node is this modification's skeleton or cannot be found!");
ERR_FAIL_COND_MSG(!node->is_inside_tree(),
"Cannot update target cache: node is not in the scene tree!");
target_node_cache = node->get_instance_id();
execution_error_found = false;
}
}
}
}
void SkeletonModification3DFABRIK::update_joint_tip_cache(int p_joint_idx) {
const int bone_chain_size = fabrik_data_chain.size();
ERR_FAIL_INDEX_MSG(p_joint_idx, bone_chain_size, "FABRIK joint not found");
if (!is_setup || !stack) {
_print_execution_error(true, "Cannot update tip cache: modification is not properly setup!");
return;
}
fabrik_data_chain[p_joint_idx].tip_node_cache = ObjectID();
if (stack->skeleton) {
if (stack->skeleton->is_inside_tree() && fabrik_data_chain[p_joint_idx].tip_node.is_empty() == false) {
if (stack->skeleton->has_node(fabrik_data_chain[p_joint_idx].tip_node)) {
Node *node = stack->skeleton->get_node(fabrik_data_chain[p_joint_idx].tip_node);
ERR_FAIL_COND_MSG(!node || stack->skeleton == node,
"Cannot update tip cache for joint " + itos(p_joint_idx) + ": node is this modification's skeleton or cannot be found!");
ERR_FAIL_COND_MSG(!node->is_inside_tree(),
"Cannot update tip cache for joint " + itos(p_joint_idx) + ": node is not in scene tree!");
fabrik_data_chain[p_joint_idx].tip_node_cache = node->get_instance_id();
execution_error_found = false;
}
}
}
}
void SkeletonModification3DFABRIK::set_target_node(const NodePath &p_target_node) {
target_node = p_target_node;
update_target_cache();
}
NodePath SkeletonModification3DFABRIK::get_target_node() const {
return target_node;
}
int SkeletonModification3DFABRIK::get_fabrik_data_chain_length() {
return fabrik_data_chain.size();
}
void SkeletonModification3DFABRIK::set_fabrik_data_chain_length(int p_length) {
ERR_FAIL_COND(p_length < 0);
fabrik_data_chain.resize(p_length);
fabrik_transforms.resize(p_length);
execution_error_found = false;
notify_property_list_changed();
}
real_t SkeletonModification3DFABRIK::get_chain_tolerance() {
return chain_tolerance;
}
void SkeletonModification3DFABRIK::set_chain_tolerance(real_t p_tolerance) {
ERR_FAIL_COND_MSG(p_tolerance <= 0, "FABRIK chain tolerance must be more than zero!");
chain_tolerance = p_tolerance;
}
int SkeletonModification3DFABRIK::get_chain_max_iterations() {
return chain_max_iterations;
}
void SkeletonModification3DFABRIK::set_chain_max_iterations(int p_iterations) {
ERR_FAIL_COND_MSG(p_iterations <= 0, "FABRIK chain iterations must be at least one. Set enabled to false to disable the FABRIK chain.");
chain_max_iterations = p_iterations;
}
// FABRIK joint data functions
String SkeletonModification3DFABRIK::get_fabrik_joint_bone_name(int p_joint_idx) const {
const int bone_chain_size = fabrik_data_chain.size();
ERR_FAIL_INDEX_V(p_joint_idx, bone_chain_size, String());
return fabrik_data_chain[p_joint_idx].bone_name;
}
void SkeletonModification3DFABRIK::set_fabrik_joint_bone_name(int p_joint_idx, String p_bone_name) {
const int bone_chain_size = fabrik_data_chain.size();
ERR_FAIL_INDEX(p_joint_idx, bone_chain_size);
fabrik_data_chain[p_joint_idx].bone_name = p_bone_name;
if (stack) {
if (stack->skeleton) {
fabrik_data_chain[p_joint_idx].bone_idx = stack->skeleton->find_bone(p_bone_name);
}
}
execution_error_found = false;
notify_property_list_changed();
}
int SkeletonModification3DFABRIK::get_fabrik_joint_bone_index(int p_joint_idx) const {
const int bone_chain_size = fabrik_data_chain.size();
ERR_FAIL_INDEX_V(p_joint_idx, bone_chain_size, -1);
return fabrik_data_chain[p_joint_idx].bone_idx;
}
void SkeletonModification3DFABRIK::set_fabrik_joint_bone_index(int p_joint_idx, int p_bone_idx) {
const int bone_chain_size = fabrik_data_chain.size();
ERR_FAIL_INDEX(p_joint_idx, bone_chain_size);
ERR_FAIL_COND_MSG(p_bone_idx < 0, "Bone index is out of range: The index is too low!");
fabrik_data_chain[p_joint_idx].bone_idx = p_bone_idx;
if (stack) {
if (stack->skeleton) {
fabrik_data_chain[p_joint_idx].bone_name = stack->skeleton->get_bone_name(p_bone_idx);
}
}
execution_error_found = false;
notify_property_list_changed();
}
real_t SkeletonModification3DFABRIK::get_fabrik_joint_length(int p_joint_idx) const {
const int bone_chain_size = fabrik_data_chain.size();
ERR_FAIL_INDEX_V(p_joint_idx, bone_chain_size, -1);
return fabrik_data_chain[p_joint_idx].length;
}
void SkeletonModification3DFABRIK::set_fabrik_joint_length(int p_joint_idx, real_t p_bone_length) {
const int bone_chain_size = fabrik_data_chain.size();
ERR_FAIL_INDEX(p_joint_idx, bone_chain_size);
ERR_FAIL_COND_MSG(p_bone_length < 0, "FABRIK joint length cannot be less than zero!");
if (!is_setup) {
fabrik_data_chain[p_joint_idx].length = p_bone_length;
return;
}
if (fabrik_data_chain[p_joint_idx].auto_calculate_length) {
WARN_PRINT("FABRIK Length not set: auto calculate length is enabled for this joint!");
fabrik_joint_auto_calculate_length(p_joint_idx);
} else {
fabrik_data_chain[p_joint_idx].length = p_bone_length;
}
execution_error_found = false;
}
Vector3 SkeletonModification3DFABRIK::get_fabrik_joint_magnet(int p_joint_idx) const {
const int bone_chain_size = fabrik_data_chain.size();
ERR_FAIL_INDEX_V(p_joint_idx, bone_chain_size, Vector3());
return fabrik_data_chain[p_joint_idx].magnet_position;
}
void SkeletonModification3DFABRIK::set_fabrik_joint_magnet(int p_joint_idx, Vector3 p_magnet) {
const int bone_chain_size = fabrik_data_chain.size();
ERR_FAIL_INDEX(p_joint_idx, bone_chain_size);
fabrik_data_chain[p_joint_idx].magnet_position = p_magnet;
}
bool SkeletonModification3DFABRIK::get_fabrik_joint_auto_calculate_length(int p_joint_idx) const {
const int bone_chain_size = fabrik_data_chain.size();
ERR_FAIL_INDEX_V(p_joint_idx, bone_chain_size, false);
return fabrik_data_chain[p_joint_idx].auto_calculate_length;
}
void SkeletonModification3DFABRIK::set_fabrik_joint_auto_calculate_length(int p_joint_idx, bool p_auto_calculate) {
const int bone_chain_size = fabrik_data_chain.size();
ERR_FAIL_INDEX(p_joint_idx, bone_chain_size);
fabrik_data_chain[p_joint_idx].auto_calculate_length = p_auto_calculate;
fabrik_joint_auto_calculate_length(p_joint_idx);
notify_property_list_changed();
}
void SkeletonModification3DFABRIK::fabrik_joint_auto_calculate_length(int p_joint_idx) {
const int bone_chain_size = fabrik_data_chain.size();
ERR_FAIL_INDEX(p_joint_idx, bone_chain_size);
if (!fabrik_data_chain[p_joint_idx].auto_calculate_length) {
return;
}
if (!stack || !stack->skeleton || !is_setup) {
_print_execution_error(true, "Cannot auto calculate joint length: modification is not properly setup!");
return;
}
ERR_FAIL_INDEX_MSG(fabrik_data_chain[p_joint_idx].bone_idx, stack->skeleton->get_bone_count(),
"Bone for joint " + itos(p_joint_idx) + " is not set or points to an unknown bone!");
if (fabrik_data_chain[p_joint_idx].use_tip_node) { // Use the tip node to update joint length.
update_joint_tip_cache(p_joint_idx);
Node3D *tip_node = Object::cast_to<Node3D>(ObjectDB::get_instance(fabrik_data_chain[p_joint_idx].tip_node_cache));
ERR_FAIL_COND_MSG(!tip_node, "Tip node for joint " + itos(p_joint_idx) + "is not a Node3D-based node. Cannot calculate length...");
ERR_FAIL_COND_MSG(!tip_node->is_inside_tree(), "Tip node for joint " + itos(p_joint_idx) + "is not in the scene tree. Cannot calculate length...");
Transform3D node_trans = tip_node->get_global_transform();
node_trans = stack->skeleton->world_transform_to_global_pose(node_trans);
//node_trans = stack->skeleton->global_pose_to_local_pose(fabrik_data_chain[p_joint_idx].bone_idx, node_trans);
//fabrik_data_chain[p_joint_idx].length = node_trans.origin.length();
fabrik_data_chain[p_joint_idx].length = stack->skeleton->get_bone_global_pose(fabrik_data_chain[p_joint_idx].bone_idx).origin.distance_to(node_trans.origin);
} else { // Use child bone(s) to update joint length, if possible
Vector<int> bone_children = stack->skeleton->get_bone_children(fabrik_data_chain[p_joint_idx].bone_idx);
if (bone_children.size() <= 0) {
ERR_FAIL_MSG("Cannot calculate length for joint " + itos(p_joint_idx) + "joint uses leaf bone. \nPlease manually set the bone length or use a tip node!");
return;
}
Transform3D bone_trans = stack->skeleton->get_bone_global_pose(fabrik_data_chain[p_joint_idx].bone_idx);
real_t final_length = 0;
for (int i = 0; i < bone_children.size(); i++) {
Transform3D child_transform = stack->skeleton->get_bone_global_pose(bone_children[i]);
final_length += bone_trans.origin.distance_to(child_transform.origin);
//final_length += stack->skeleton->global_pose_to_local_pose(fabrik_data_chain[p_joint_idx].bone_idx, child_transform).origin.length();
}
fabrik_data_chain[p_joint_idx].length = final_length / bone_children.size();
}
execution_error_found = false;
notify_property_list_changed();
}
bool SkeletonModification3DFABRIK::get_fabrik_joint_use_tip_node(int p_joint_idx) const {
const int bone_chain_size = fabrik_data_chain.size();
ERR_FAIL_INDEX_V(p_joint_idx, bone_chain_size, false);
return fabrik_data_chain[p_joint_idx].use_tip_node;
}
void SkeletonModification3DFABRIK::set_fabrik_joint_use_tip_node(int p_joint_idx, bool p_use_tip_node) {
const int bone_chain_size = fabrik_data_chain.size();
ERR_FAIL_INDEX(p_joint_idx, bone_chain_size);
fabrik_data_chain[p_joint_idx].use_tip_node = p_use_tip_node;
notify_property_list_changed();
}
NodePath SkeletonModification3DFABRIK::get_fabrik_joint_tip_node(int p_joint_idx) const {
const int bone_chain_size = fabrik_data_chain.size();
ERR_FAIL_INDEX_V(p_joint_idx, bone_chain_size, NodePath());
return fabrik_data_chain[p_joint_idx].tip_node;
}
void SkeletonModification3DFABRIK::set_fabrik_joint_tip_node(int p_joint_idx, NodePath p_tip_node) {
const int bone_chain_size = fabrik_data_chain.size();
ERR_FAIL_INDEX(p_joint_idx, bone_chain_size);
fabrik_data_chain[p_joint_idx].tip_node = p_tip_node;
update_joint_tip_cache(p_joint_idx);
}
bool SkeletonModification3DFABRIK::get_fabrik_joint_use_target_basis(int p_joint_idx) const {
const int bone_chain_size = fabrik_data_chain.size();
ERR_FAIL_INDEX_V(p_joint_idx, bone_chain_size, false);
return fabrik_data_chain[p_joint_idx].use_target_basis;
}
void SkeletonModification3DFABRIK::set_fabrik_joint_use_target_basis(int p_joint_idx, bool p_use_target_basis) {
const int bone_chain_size = fabrik_data_chain.size();
ERR_FAIL_INDEX(p_joint_idx, bone_chain_size);
fabrik_data_chain[p_joint_idx].use_target_basis = p_use_target_basis;
}
real_t SkeletonModification3DFABRIK::get_fabrik_joint_roll(int p_joint_idx) const {
const int bone_chain_size = fabrik_data_chain.size();
ERR_FAIL_INDEX_V(p_joint_idx, bone_chain_size, 0.0);
return fabrik_data_chain[p_joint_idx].roll;
}
void SkeletonModification3DFABRIK::set_fabrik_joint_roll(int p_joint_idx, real_t p_roll) {
const int bone_chain_size = fabrik_data_chain.size();
ERR_FAIL_INDEX(p_joint_idx, bone_chain_size);
fabrik_data_chain[p_joint_idx].roll = p_roll;
}
void SkeletonModification3DFABRIK::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_target_node", "target_nodepath"), &SkeletonModification3DFABRIK::set_target_node);
ClassDB::bind_method(D_METHOD("get_target_node"), &SkeletonModification3DFABRIK::get_target_node);
ClassDB::bind_method(D_METHOD("set_fabrik_data_chain_length", "length"), &SkeletonModification3DFABRIK::set_fabrik_data_chain_length);
ClassDB::bind_method(D_METHOD("get_fabrik_data_chain_length"), &SkeletonModification3DFABRIK::get_fabrik_data_chain_length);
ClassDB::bind_method(D_METHOD("set_chain_tolerance", "tolerance"), &SkeletonModification3DFABRIK::set_chain_tolerance);
ClassDB::bind_method(D_METHOD("get_chain_tolerance"), &SkeletonModification3DFABRIK::get_chain_tolerance);
ClassDB::bind_method(D_METHOD("set_chain_max_iterations", "max_iterations"), &SkeletonModification3DFABRIK::set_chain_max_iterations);
ClassDB::bind_method(D_METHOD("get_chain_max_iterations"), &SkeletonModification3DFABRIK::get_chain_max_iterations);
// FABRIK joint data functions
ClassDB::bind_method(D_METHOD("get_fabrik_joint_bone_name", "joint_idx"), &SkeletonModification3DFABRIK::get_fabrik_joint_bone_name);
ClassDB::bind_method(D_METHOD("set_fabrik_joint_bone_name", "joint_idx", "bone_name"), &SkeletonModification3DFABRIK::set_fabrik_joint_bone_name);
ClassDB::bind_method(D_METHOD("get_fabrik_joint_bone_index", "joint_idx"), &SkeletonModification3DFABRIK::get_fabrik_joint_bone_index);
ClassDB::bind_method(D_METHOD("set_fabrik_joint_bone_index", "joint_idx", "bone_index"), &SkeletonModification3DFABRIK::set_fabrik_joint_bone_index);
ClassDB::bind_method(D_METHOD("get_fabrik_joint_length", "joint_idx"), &SkeletonModification3DFABRIK::get_fabrik_joint_length);
ClassDB::bind_method(D_METHOD("set_fabrik_joint_length", "joint_idx", "length"), &SkeletonModification3DFABRIK::set_fabrik_joint_length);
ClassDB::bind_method(D_METHOD("get_fabrik_joint_magnet", "joint_idx"), &SkeletonModification3DFABRIK::get_fabrik_joint_magnet);
ClassDB::bind_method(D_METHOD("set_fabrik_joint_magnet", "joint_idx", "magnet_position"), &SkeletonModification3DFABRIK::set_fabrik_joint_magnet);
ClassDB::bind_method(D_METHOD("get_fabrik_joint_auto_calculate_length", "joint_idx"), &SkeletonModification3DFABRIK::get_fabrik_joint_auto_calculate_length);
ClassDB::bind_method(D_METHOD("set_fabrik_joint_auto_calculate_length", "joint_idx", "auto_calculate_length"), &SkeletonModification3DFABRIK::set_fabrik_joint_auto_calculate_length);
ClassDB::bind_method(D_METHOD("fabrik_joint_auto_calculate_length", "joint_idx"), &SkeletonModification3DFABRIK::fabrik_joint_auto_calculate_length);
ClassDB::bind_method(D_METHOD("get_fabrik_joint_use_tip_node", "joint_idx"), &SkeletonModification3DFABRIK::get_fabrik_joint_use_tip_node);
ClassDB::bind_method(D_METHOD("set_fabrik_joint_use_tip_node", "joint_idx", "use_tip_node"), &SkeletonModification3DFABRIK::set_fabrik_joint_use_tip_node);
ClassDB::bind_method(D_METHOD("get_fabrik_joint_tip_node", "joint_idx"), &SkeletonModification3DFABRIK::get_fabrik_joint_tip_node);
ClassDB::bind_method(D_METHOD("set_fabrik_joint_tip_node", "joint_idx", "tip_node"), &SkeletonModification3DFABRIK::set_fabrik_joint_tip_node);
ClassDB::bind_method(D_METHOD("get_fabrik_joint_use_target_basis", "joint_idx"), &SkeletonModification3DFABRIK::get_fabrik_joint_use_target_basis);
ClassDB::bind_method(D_METHOD("set_fabrik_joint_use_target_basis", "joint_idx", "use_target_basis"), &SkeletonModification3DFABRIK::set_fabrik_joint_use_target_basis);
ADD_PROPERTY(PropertyInfo(Variant::NODE_PATH, "target_nodepath", PROPERTY_HINT_NODE_PATH_VALID_TYPES, "Node3D"), "set_target_node", "get_target_node");
ADD_PROPERTY(PropertyInfo(Variant::INT, "fabrik_data_chain_length", PROPERTY_HINT_RANGE, "0,100,1"), "set_fabrik_data_chain_length", "get_fabrik_data_chain_length");
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "chain_tolerance", PROPERTY_HINT_RANGE, "0,100,0.001"), "set_chain_tolerance", "get_chain_tolerance");
ADD_PROPERTY(PropertyInfo(Variant::INT, "chain_max_iterations", PROPERTY_HINT_RANGE, "1,50,1"), "set_chain_max_iterations", "get_chain_max_iterations");
}
SkeletonModification3DFABRIK::SkeletonModification3DFABRIK() {
stack = nullptr;
is_setup = false;
enabled = true;
}
SkeletonModification3DFABRIK::~SkeletonModification3DFABRIK() {
}

124
scene/resources/skeleton_modification_3d_fabrik.h
View File

@ -1,124 +0,0 @@
/**************************************************************************/
/* skeleton_modification_3d_fabrik.h */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/**************************************************************************/
#ifndef SKELETON_MODIFICATION_3D_FABRIK_H
#define SKELETON_MODIFICATION_3D_FABRIK_H
#include "core/templates/local_vector.h"
#include "scene/3d/skeleton_3d.h"
#include "scene/resources/skeleton_modification_3d.h"
class SkeletonModification3DFABRIK : public SkeletonModification3D {
GDCLASS(SkeletonModification3DFABRIK, SkeletonModification3D);
private:
struct FABRIK_Joint_Data {
String bone_name = "";
int bone_idx = -1;
real_t length = -1;
Vector3 magnet_position = Vector3(0, 0, 0);
bool auto_calculate_length = true;
bool use_tip_node = false;
NodePath tip_node;
ObjectID tip_node_cache;
bool use_target_basis = false;
real_t roll = 0;
};
LocalVector<FABRIK_Joint_Data> fabrik_data_chain;
LocalVector<Transform3D> fabrik_transforms;
NodePath target_node;
ObjectID target_node_cache;
real_t chain_tolerance = 0.01;
int chain_max_iterations = 10;
int chain_iterations = 0;
void update_target_cache();
void update_joint_tip_cache(int p_joint_idx);
int final_joint_idx = 0;
Transform3D target_global_pose;
Transform3D origin_global_pose;
void chain_backwards();
void chain_forwards();
void chain_apply();
protected:
static void _bind_methods();
bool _get(const StringName &p_path, Variant &r_ret) const;
bool _set(const StringName &p_path, const Variant &p_value);
void _get_property_list(List<PropertyInfo> *p_list) const;
public:
virtual void _execute(real_t p_delta) override;
virtual void _setup_modification(SkeletonModificationStack3D *p_stack) override;
void set_target_node(const NodePath &p_target_node);
NodePath get_target_node() const;
int get_fabrik_data_chain_length();
void set_fabrik_data_chain_length(int p_new_length);
real_t get_chain_tolerance();
void set_chain_tolerance(real_t p_tolerance);
int get_chain_max_iterations();
void set_chain_max_iterations(int p_iterations);
String get_fabrik_joint_bone_name(int p_joint_idx) const;
void set_fabrik_joint_bone_name(int p_joint_idx, String p_bone_name);
int get_fabrik_joint_bone_index(int p_joint_idx) const;
void set_fabrik_joint_bone_index(int p_joint_idx, int p_bone_idx);
real_t get_fabrik_joint_length(int p_joint_idx) const;
void set_fabrik_joint_length(int p_joint_idx, real_t p_bone_length);
Vector3 get_fabrik_joint_magnet(int p_joint_idx) const;
void set_fabrik_joint_magnet(int p_joint_idx, Vector3 p_magnet);
bool get_fabrik_joint_auto_calculate_length(int p_joint_idx) const;
void set_fabrik_joint_auto_calculate_length(int p_joint_idx, bool p_auto_calculate);
void fabrik_joint_auto_calculate_length(int p_joint_idx);
bool get_fabrik_joint_use_tip_node(int p_joint_idx) const;
void set_fabrik_joint_use_tip_node(int p_joint_idx, bool p_use_tip_node);
NodePath get_fabrik_joint_tip_node(int p_joint_idx) const;
void set_fabrik_joint_tip_node(int p_joint_idx, NodePath p_tip_node);
bool get_fabrik_joint_use_target_basis(int p_joint_idx) const;
void set_fabrik_joint_use_target_basis(int p_joint_idx, bool p_use_basis);
real_t get_fabrik_joint_roll(int p_joint_idx) const;
void set_fabrik_joint_roll(int p_joint_idx, real_t p_roll);
SkeletonModification3DFABRIK();
~SkeletonModification3DFABRIK();
};
#endif // SKELETON_MODIFICATION_3D_FABRIK_H

582
scene/resources/skeleton_modification_3d_jiggle.cpp
View File

@ -1,582 +0,0 @@
/**************************************************************************/
/* skeleton_modification_3d_jiggle.cpp */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/**************************************************************************/
#include "scene/resources/skeleton_modification_3d_jiggle.h"
#include "scene/3d/skeleton_3d.h"
#include "scene/resources/skeleton_modification_3d.h"
bool SkeletonModification3DJiggle::_set(const StringName &p_path, const Variant &p_value) {
String path = p_path;
if (path.begins_with("joint_data/")) {
const int jiggle_size = jiggle_data_chain.size();
int which = path.get_slicec('/', 1).to_int();
String what = path.get_slicec('/', 2);
ERR_FAIL_INDEX_V(which, jiggle_size, false);
if (what == "bone_name") {
set_jiggle_joint_bone_name(which, p_value);
} else if (what == "bone_index") {
set_jiggle_joint_bone_index(which, p_value);
} else if (what == "override_defaults") {
set_jiggle_joint_override(which, p_value);
} else if (what == "stiffness") {
set_jiggle_joint_stiffness(which, p_value);
} else if (what == "mass") {
set_jiggle_joint_mass(which, p_value);
} else if (what == "damping") {
set_jiggle_joint_damping(which, p_value);
} else if (what == "use_gravity") {
set_jiggle_joint_use_gravity(which, p_value);
} else if (what == "gravity") {
set_jiggle_joint_gravity(which, p_value);
} else if (what == "roll") {
set_jiggle_joint_roll(which, Math::deg_to_rad(real_t(p_value)));
}
return true;
} else {
if (path == "use_colliders") {
set_use_colliders(p_value);
} else if (path == "collision_mask") {
set_collision_mask(p_value);
}
return true;
}
return true;
}
bool SkeletonModification3DJiggle::_get(const StringName &p_path, Variant &r_ret) const {
String path = p_path;
if (path.begins_with("joint_data/")) {
const int jiggle_size = jiggle_data_chain.size();
int which = path.get_slicec('/', 1).to_int();
String what = path.get_slicec('/', 2);
ERR_FAIL_INDEX_V(which, jiggle_size, false);
if (what == "bone_name") {
r_ret = get_jiggle_joint_bone_name(which);
} else if (what == "bone_index") {
r_ret = get_jiggle_joint_bone_index(which);
} else if (what == "override_defaults") {
r_ret = get_jiggle_joint_override(which);
} else if (what == "stiffness") {
r_ret = get_jiggle_joint_stiffness(which);
} else if (what == "mass") {
r_ret = get_jiggle_joint_mass(which);
} else if (what == "damping") {
r_ret = get_jiggle_joint_damping(which);
} else if (what == "use_gravity") {
r_ret = get_jiggle_joint_use_gravity(which);
} else if (what == "gravity") {
r_ret = get_jiggle_joint_gravity(which);
} else if (what == "roll") {
r_ret = Math::rad_to_deg(get_jiggle_joint_roll(which));
}
return true;
} else {
if (path == "use_colliders") {
r_ret = get_use_colliders();
} else if (path == "collision_mask") {
r_ret = get_collision_mask();
}
return true;
}
return true;
}
void SkeletonModification3DJiggle::_get_property_list(List<PropertyInfo> *p_list) const {
p_list->push_back(PropertyInfo(Variant::BOOL, "use_colliders", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT));
if (use_colliders) {
p_list->push_back(PropertyInfo(Variant::INT, "collision_mask", PROPERTY_HINT_LAYERS_3D_PHYSICS, "", PROPERTY_USAGE_DEFAULT));
}
for (uint32_t i = 0; i < jiggle_data_chain.size(); i++) {
String base_string = "joint_data/" + itos(i) + "/";
p_list->push_back(PropertyInfo(Variant::STRING_NAME, base_string + "bone_name", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT));
p_list->push_back(PropertyInfo(Variant::INT, base_string + "bone_index", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT));
p_list->push_back(PropertyInfo(Variant::FLOAT, base_string + "roll", PROPERTY_HINT_RANGE, "-360,360,0.01", PROPERTY_USAGE_DEFAULT));
p_list->push_back(PropertyInfo(Variant::BOOL, base_string + "override_defaults", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT));
if (jiggle_data_chain[i].override_defaults) {
p_list->push_back(PropertyInfo(Variant::FLOAT, base_string + "stiffness", PROPERTY_HINT_RANGE, "0, 1000, 0.01", PROPERTY_USAGE_DEFAULT));
p_list->push_back(PropertyInfo(Variant::FLOAT, base_string + "mass", PROPERTY_HINT_RANGE, "0, 1000, 0.01", PROPERTY_USAGE_DEFAULT));
p_list->push_back(PropertyInfo(Variant::FLOAT, base_string + "damping", PROPERTY_HINT_RANGE, "0, 1, 0.01", PROPERTY_USAGE_DEFAULT));
p_list->push_back(PropertyInfo(Variant::BOOL, base_string + "use_gravity", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT));
if (jiggle_data_chain[i].use_gravity) {
p_list->push_back(PropertyInfo(Variant::VECTOR3, base_string + "gravity", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT));
}
}
}
}
void SkeletonModification3DJiggle::_execute(real_t p_delta) {
ERR_FAIL_COND_MSG(!stack || !is_setup || stack->skeleton == nullptr,
"Modification is not setup and therefore cannot execute!");
if (!enabled) {
return;
}
if (target_node_cache.is_null()) {
_print_execution_error(true, "Target cache is out of date. Attempting to update...");
update_cache();
return;
}
Node3D *target = Object::cast_to<Node3D>(ObjectDB::get_instance(target_node_cache));
_print_execution_error(!target || !target->is_inside_tree(), "Target node is not in the scene tree. Cannot execute modification!");
for (uint32_t i = 0; i < jiggle_data_chain.size(); i++) {
_execute_jiggle_joint(i, target, p_delta);
}
execution_error_found = false;
}
void SkeletonModification3DJiggle::_execute_jiggle_joint(int p_joint_idx, Node3D *p_target, real_t p_delta) {
// Adopted from: https://wiki.unity3d.com/index.php/JiggleBone
// With modifications by TwistedTwigleg.
if (jiggle_data_chain[p_joint_idx].bone_idx <= -2) {
jiggle_data_chain[p_joint_idx].bone_idx = stack->skeleton->find_bone(jiggle_data_chain[p_joint_idx].bone_name);
}
if (_print_execution_error(
jiggle_data_chain[p_joint_idx].bone_idx < 0 || jiggle_data_chain[p_joint_idx].bone_idx > stack->skeleton->get_bone_count(),
"Jiggle joint " + itos(p_joint_idx) + " bone index is invalid. Cannot execute modification!")) {
return;
}
Transform3D bone_local_pos = stack->skeleton->get_bone_local_pose_override(jiggle_data_chain[p_joint_idx].bone_idx);
if (bone_local_pos == Transform3D()) {
bone_local_pos = stack->skeleton->get_bone_pose(jiggle_data_chain[p_joint_idx].bone_idx);
}
Transform3D new_bone_trans = stack->skeleton->local_pose_to_global_pose(jiggle_data_chain[p_joint_idx].bone_idx, bone_local_pos);
Vector3 target_position = stack->skeleton->world_transform_to_global_pose(p_target->get_global_transform()).origin;
jiggle_data_chain[p_joint_idx].force = (target_position - jiggle_data_chain[p_joint_idx].dynamic_position) * jiggle_data_chain[p_joint_idx].stiffness * p_delta;
if (jiggle_data_chain[p_joint_idx].use_gravity) {
Vector3 gravity_to_apply = new_bone_trans.basis.inverse().xform(jiggle_data_chain[p_joint_idx].gravity);
jiggle_data_chain[p_joint_idx].force += gravity_to_apply * p_delta;
}
jiggle_data_chain[p_joint_idx].acceleration = jiggle_data_chain[p_joint_idx].force / jiggle_data_chain[p_joint_idx].mass;
jiggle_data_chain[p_joint_idx].velocity += jiggle_data_chain[p_joint_idx].acceleration * (1 - jiggle_data_chain[p_joint_idx].damping);
jiggle_data_chain[p_joint_idx].dynamic_position += jiggle_data_chain[p_joint_idx].velocity + jiggle_data_chain[p_joint_idx].force;
jiggle_data_chain[p_joint_idx].dynamic_position += new_bone_trans.origin - jiggle_data_chain[p_joint_idx].last_position;
jiggle_data_chain[p_joint_idx].last_position = new_bone_trans.origin;
// Collision detection/response
if (use_colliders) {
if (execution_mode == SkeletonModificationStack3D::EXECUTION_MODE::execution_mode_physics_process) {
Ref<World3D> world_3d = stack->skeleton->get_world_3d();
ERR_FAIL_COND(world_3d.is_null());
PhysicsDirectSpaceState3D *space_state = PhysicsServer3D::get_singleton()->space_get_direct_state(world_3d->get_space());
PhysicsDirectSpaceState3D::RayResult ray_result;
// Convert to world transforms, which is what the physics server needs
Transform3D new_bone_trans_world = stack->skeleton->global_pose_to_world_transform(new_bone_trans);
Transform3D dynamic_position_world = stack->skeleton->global_pose_to_world_transform(Transform3D(Basis(), jiggle_data_chain[p_joint_idx].dynamic_position));
PhysicsDirectSpaceState3D::RayParameters ray_params;
ray_params.from = new_bone_trans_world.origin;
ray_params.to = dynamic_position_world.get_origin();
ray_params.collision_mask = collision_mask;
bool ray_hit = space_state->intersect_ray(ray_params, ray_result);
if (ray_hit) {
jiggle_data_chain[p_joint_idx].dynamic_position = jiggle_data_chain[p_joint_idx].last_noncollision_position;
jiggle_data_chain[p_joint_idx].acceleration = Vector3(0, 0, 0);
jiggle_data_chain[p_joint_idx].velocity = Vector3(0, 0, 0);
} else {
jiggle_data_chain[p_joint_idx].last_noncollision_position = jiggle_data_chain[p_joint_idx].dynamic_position;
}
} else {
WARN_PRINT_ONCE("Jiggle modifier: You cannot detect colliders without the stack mode being set to _physics_process!");
}
}
// Get the forward direction that the basis is facing in right now.
stack->skeleton->update_bone_rest_forward_vector(jiggle_data_chain[p_joint_idx].bone_idx);
Vector3 forward_vector = stack->skeleton->get_bone_axis_forward_vector(jiggle_data_chain[p_joint_idx].bone_idx);
// Rotate the bone using the dynamic position!
new_bone_trans.basis.rotate_to_align(forward_vector, new_bone_trans.origin.direction_to(jiggle_data_chain[p_joint_idx].dynamic_position));
// Roll
new_bone_trans.basis.rotate_local(forward_vector, jiggle_data_chain[p_joint_idx].roll);
new_bone_trans = stack->skeleton->global_pose_to_local_pose(jiggle_data_chain[p_joint_idx].bone_idx, new_bone_trans);
stack->skeleton->set_bone_local_pose_override(jiggle_data_chain[p_joint_idx].bone_idx, new_bone_trans, stack->strength, true);
stack->skeleton->force_update_bone_children_transforms(jiggle_data_chain[p_joint_idx].bone_idx);
}
void SkeletonModification3DJiggle::_update_jiggle_joint_data() {
for (uint32_t i = 0; i < jiggle_data_chain.size(); i++) {
if (!jiggle_data_chain[i].override_defaults) {
set_jiggle_joint_stiffness(i, stiffness);
set_jiggle_joint_mass(i, mass);
set_jiggle_joint_damping(i, damping);
set_jiggle_joint_use_gravity(i, use_gravity);
set_jiggle_joint_gravity(i, gravity);
}
}
}
void SkeletonModification3DJiggle::_setup_modification(SkeletonModificationStack3D *p_stack) {
stack = p_stack;
if (stack) {
is_setup = true;
execution_error_found = false;
if (stack->skeleton) {
for (uint32_t i = 0; i < jiggle_data_chain.size(); i++) {
int bone_idx = jiggle_data_chain[i].bone_idx;
if (bone_idx > 0 && bone_idx < stack->skeleton->get_bone_count()) {
jiggle_data_chain[i].dynamic_position = stack->skeleton->local_pose_to_global_pose(bone_idx, stack->skeleton->get_bone_local_pose_override(bone_idx)).origin;
}
}
}
update_cache();
}
}
void SkeletonModification3DJiggle::update_cache() {
if (!is_setup || !stack) {
_print_execution_error(true, "Cannot update target cache: modification is not properly setup!");
return;
}
target_node_cache = ObjectID();
if (stack->skeleton) {
if (stack->skeleton->is_inside_tree()) {
if (stack->skeleton->has_node(target_node)) {
Node *node = stack->skeleton->get_node(target_node);
ERR_FAIL_COND_MSG(!node || stack->skeleton == node,
"Cannot update target cache: node is this modification's skeleton or cannot be found!");
ERR_FAIL_COND_MSG(!node->is_inside_tree(),
"Cannot update target cache: node is not in the scene tree!");
target_node_cache = node->get_instance_id();
execution_error_found = false;
}
}
}
}
void SkeletonModification3DJiggle::set_target_node(const NodePath &p_target_node) {
target_node = p_target_node;
update_cache();
}
NodePath SkeletonModification3DJiggle::get_target_node() const {
return target_node;
}
void SkeletonModification3DJiggle::set_stiffness(real_t p_stiffness) {
ERR_FAIL_COND_MSG(p_stiffness < 0, "Stiffness cannot be set to a negative value!");
stiffness = p_stiffness;
_update_jiggle_joint_data();
}
real_t SkeletonModification3DJiggle::get_stiffness() const {
return stiffness;
}
void SkeletonModification3DJiggle::set_mass(real_t p_mass) {
ERR_FAIL_COND_MSG(p_mass < 0, "Mass cannot be set to a negative value!");
mass = p_mass;
_update_jiggle_joint_data();
}
real_t SkeletonModification3DJiggle::get_mass() const {
return mass;
}
void SkeletonModification3DJiggle::set_damping(real_t p_damping) {
ERR_FAIL_COND_MSG(p_damping < 0, "Damping cannot be set to a negative value!");
ERR_FAIL_COND_MSG(p_damping > 1, "Damping cannot be more than one!");
damping = p_damping;
_update_jiggle_joint_data();
}
real_t SkeletonModification3DJiggle::get_damping() const {
return damping;
}
void SkeletonModification3DJiggle::set_use_gravity(bool p_use_gravity) {
use_gravity = p_use_gravity;
_update_jiggle_joint_data();
}
bool SkeletonModification3DJiggle::get_use_gravity() const {
return use_gravity;
}
void SkeletonModification3DJiggle::set_gravity(Vector3 p_gravity) {
gravity = p_gravity;
_update_jiggle_joint_data();
}
Vector3 SkeletonModification3DJiggle::get_gravity() const {
return gravity;
}
void SkeletonModification3DJiggle::set_use_colliders(bool p_use_collider) {
use_colliders = p_use_collider;
notify_property_list_changed();
}
bool SkeletonModification3DJiggle::get_use_colliders() const {
return use_colliders;
}
void SkeletonModification3DJiggle::set_collision_mask(int p_mask) {
collision_mask = p_mask;
}
int SkeletonModification3DJiggle::get_collision_mask() const {
return collision_mask;
}
// Jiggle joint data functions
int SkeletonModification3DJiggle::get_jiggle_data_chain_length() {
return jiggle_data_chain.size();
}
void SkeletonModification3DJiggle::set_jiggle_data_chain_length(int p_length) {
ERR_FAIL_COND(p_length < 0);
jiggle_data_chain.resize(p_length);
execution_error_found = false;
notify_property_list_changed();
}
void SkeletonModification3DJiggle::set_jiggle_joint_bone_name(int p_joint_idx, String p_name) {
const int bone_chain_size = jiggle_data_chain.size();
ERR_FAIL_INDEX(p_joint_idx, bone_chain_size);
jiggle_data_chain[p_joint_idx].bone_name = p_name;
if (stack && stack->skeleton) {
jiggle_data_chain[p_joint_idx].bone_idx = stack->skeleton->find_bone(p_name);
}
execution_error_found = false;
notify_property_list_changed();
}
String SkeletonModification3DJiggle::get_jiggle_joint_bone_name(int p_joint_idx) const {
const int bone_chain_size = jiggle_data_chain.size();
ERR_FAIL_INDEX_V(p_joint_idx, bone_chain_size, "");
return jiggle_data_chain[p_joint_idx].bone_name;
}
int SkeletonModification3DJiggle::get_jiggle_joint_bone_index(int p_joint_idx) const {
const int bone_chain_size = jiggle_data_chain.size();
ERR_FAIL_INDEX_V(p_joint_idx, bone_chain_size, -1);
return jiggle_data_chain[p_joint_idx].bone_idx;
}
void SkeletonModification3DJiggle::set_jiggle_joint_bone_index(int p_joint_idx, int p_bone_idx) {
const int bone_chain_size = jiggle_data_chain.size();
ERR_FAIL_INDEX(p_joint_idx, bone_chain_size);
ERR_FAIL_COND_MSG(p_bone_idx < 0, "Bone index is out of range: The index is too low!");
jiggle_data_chain[p_joint_idx].bone_idx = p_bone_idx;
if (stack) {
if (stack->skeleton) {
jiggle_data_chain[p_joint_idx].bone_name = stack->skeleton->get_bone_name(p_bone_idx);
}
}
execution_error_found = false;
notify_property_list_changed();
}
void SkeletonModification3DJiggle::set_jiggle_joint_override(int p_joint_idx, bool p_override) {
const int bone_chain_size = jiggle_data_chain.size();
ERR_FAIL_INDEX(p_joint_idx, bone_chain_size);
jiggle_data_chain[p_joint_idx].override_defaults = p_override;
_update_jiggle_joint_data();
notify_property_list_changed();
}
bool SkeletonModification3DJiggle::get_jiggle_joint_override(int p_joint_idx) const {
const int bone_chain_size = jiggle_data_chain.size();
ERR_FAIL_INDEX_V(p_joint_idx, bone_chain_size, false);
return jiggle_data_chain[p_joint_idx].override_defaults;
}
void SkeletonModification3DJiggle::set_jiggle_joint_stiffness(int p_joint_idx, real_t p_stiffness) {
const int bone_chain_size = jiggle_data_chain.size();
ERR_FAIL_COND_MSG(p_stiffness < 0, "Stiffness cannot be set to a negative value!");
ERR_FAIL_INDEX(p_joint_idx, bone_chain_size);
jiggle_data_chain[p_joint_idx].stiffness = p_stiffness;
}
real_t SkeletonModification3DJiggle::get_jiggle_joint_stiffness(int p_joint_idx) const {
const int bone_chain_size = jiggle_data_chain.size();
ERR_FAIL_INDEX_V(p_joint_idx, bone_chain_size, -1);
return jiggle_data_chain[p_joint_idx].stiffness;
}
void SkeletonModification3DJiggle::set_jiggle_joint_mass(int p_joint_idx, real_t p_mass) {
const int bone_chain_size = jiggle_data_chain.size();
ERR_FAIL_COND_MSG(p_mass < 0, "Mass cannot be set to a negative value!");
ERR_FAIL_INDEX(p_joint_idx, bone_chain_size);
jiggle_data_chain[p_joint_idx].mass = p_mass;
}
real_t SkeletonModification3DJiggle::get_jiggle_joint_mass(int p_joint_idx) const {
const int bone_chain_size = jiggle_data_chain.size();
ERR_FAIL_INDEX_V(p_joint_idx, bone_chain_size, -1);
return jiggle_data_chain[p_joint_idx].mass;
}
void SkeletonModification3DJiggle::set_jiggle_joint_damping(int p_joint_idx, real_t p_damping) {
const int bone_chain_size = jiggle_data_chain.size();
ERR_FAIL_COND_MSG(p_damping < 0, "Damping cannot be set to a negative value!");
ERR_FAIL_INDEX(p_joint_idx, bone_chain_size);
jiggle_data_chain[p_joint_idx].damping = p_damping;
}
real_t SkeletonModification3DJiggle::get_jiggle_joint_damping(int p_joint_idx) const {
const int bone_chain_size = jiggle_data_chain.size();
ERR_FAIL_INDEX_V(p_joint_idx, bone_chain_size, -1);
return jiggle_data_chain[p_joint_idx].damping;
}
void SkeletonModification3DJiggle::set_jiggle_joint_use_gravity(int p_joint_idx, bool p_use_gravity) {
const int bone_chain_size = jiggle_data_chain.size();
ERR_FAIL_INDEX(p_joint_idx, bone_chain_size);
jiggle_data_chain[p_joint_idx].use_gravity = p_use_gravity;
notify_property_list_changed();
}
bool SkeletonModification3DJiggle::get_jiggle_joint_use_gravity(int p_joint_idx) const {
const int bone_chain_size = jiggle_data_chain.size();
ERR_FAIL_INDEX_V(p_joint_idx, bone_chain_size, false);
return jiggle_data_chain[p_joint_idx].use_gravity;
}
void SkeletonModification3DJiggle::set_jiggle_joint_gravity(int p_joint_idx, Vector3 p_gravity) {
const int bone_chain_size = jiggle_data_chain.size();
ERR_FAIL_INDEX(p_joint_idx, bone_chain_size);
jiggle_data_chain[p_joint_idx].gravity = p_gravity;
}
Vector3 SkeletonModification3DJiggle::get_jiggle_joint_gravity(int p_joint_idx) const {
const int bone_chain_size = jiggle_data_chain.size();
ERR_FAIL_INDEX_V(p_joint_idx, bone_chain_size, Vector3(0, 0, 0));
return jiggle_data_chain[p_joint_idx].gravity;
}
void SkeletonModification3DJiggle::set_jiggle_joint_roll(int p_joint_idx, real_t p_roll) {
const int bone_chain_size = jiggle_data_chain.size();
ERR_FAIL_INDEX(p_joint_idx, bone_chain_size);
jiggle_data_chain[p_joint_idx].roll = p_roll;
}
real_t SkeletonModification3DJiggle::get_jiggle_joint_roll(int p_joint_idx) const {
const int bone_chain_size = jiggle_data_chain.size();
ERR_FAIL_INDEX_V(p_joint_idx, bone_chain_size, 0.0);
return jiggle_data_chain[p_joint_idx].roll;
}
void SkeletonModification3DJiggle::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_target_node", "target_nodepath"), &SkeletonModification3DJiggle::set_target_node);
ClassDB::bind_method(D_METHOD("get_target_node"), &SkeletonModification3DJiggle::get_target_node);
ClassDB::bind_method(D_METHOD("set_jiggle_data_chain_length", "length"), &SkeletonModification3DJiggle::set_jiggle_data_chain_length);
ClassDB::bind_method(D_METHOD("get_jiggle_data_chain_length"), &SkeletonModification3DJiggle::get_jiggle_data_chain_length);
ClassDB::bind_method(D_METHOD("set_stiffness", "stiffness"), &SkeletonModification3DJiggle::set_stiffness);
ClassDB::bind_method(D_METHOD("get_stiffness"), &SkeletonModification3DJiggle::get_stiffness);
ClassDB::bind_method(D_METHOD("set_mass", "mass"), &SkeletonModification3DJiggle::set_mass);
ClassDB::bind_method(D_METHOD("get_mass"), &SkeletonModification3DJiggle::get_mass);
ClassDB::bind_method(D_METHOD("set_damping", "damping"), &SkeletonModification3DJiggle::set_damping);
ClassDB::bind_method(D_METHOD("get_damping"), &SkeletonModification3DJiggle::get_damping);
ClassDB::bind_method(D_METHOD("set_use_gravity", "use_gravity"), &SkeletonModification3DJiggle::set_use_gravity);
ClassDB::bind_method(D_METHOD("get_use_gravity"), &SkeletonModification3DJiggle::get_use_gravity);
ClassDB::bind_method(D_METHOD("set_gravity", "gravity"), &SkeletonModification3DJiggle::set_gravity);
ClassDB::bind_method(D_METHOD("get_gravity"), &SkeletonModification3DJiggle::get_gravity);
ClassDB::bind_method(D_METHOD("set_use_colliders", "use_colliders"), &SkeletonModification3DJiggle::set_use_colliders);
ClassDB::bind_method(D_METHOD("get_use_colliders"), &SkeletonModification3DJiggle::get_use_colliders);
ClassDB::bind_method(D_METHOD("set_collision_mask", "mask"), &SkeletonModification3DJiggle::set_collision_mask);
ClassDB::bind_method(D_METHOD("get_collision_mask"), &SkeletonModification3DJiggle::get_collision_mask);
// Jiggle joint data functions
ClassDB::bind_method(D_METHOD("set_jiggle_joint_bone_name", "joint_idx", "name"), &SkeletonModification3DJiggle::set_jiggle_joint_bone_name);
ClassDB::bind_method(D_METHOD("get_jiggle_joint_bone_name", "joint_idx"), &SkeletonModification3DJiggle::get_jiggle_joint_bone_name);
ClassDB::bind_method(D_METHOD("set_jiggle_joint_bone_index", "joint_idx", "bone_idx"), &SkeletonModification3DJiggle::set_jiggle_joint_bone_index);
ClassDB::bind_method(D_METHOD("get_jiggle_joint_bone_index", "joint_idx"), &SkeletonModification3DJiggle::get_jiggle_joint_bone_index);
ClassDB::bind_method(D_METHOD("set_jiggle_joint_override", "joint_idx", "override"), &SkeletonModification3DJiggle::set_jiggle_joint_override);
ClassDB::bind_method(D_METHOD("get_jiggle_joint_override", "joint_idx"), &SkeletonModification3DJiggle::get_jiggle_joint_override);
ClassDB::bind_method(D_METHOD("set_jiggle_joint_stiffness", "joint_idx", "stiffness"), &SkeletonModification3DJiggle::set_jiggle_joint_stiffness);
ClassDB::bind_method(D_METHOD("get_jiggle_joint_stiffness", "joint_idx"), &SkeletonModification3DJiggle::get_jiggle_joint_stiffness);
ClassDB::bind_method(D_METHOD("set_jiggle_joint_mass", "joint_idx", "mass"), &SkeletonModification3DJiggle::set_jiggle_joint_mass);
ClassDB::bind_method(D_METHOD("get_jiggle_joint_mass", "joint_idx"), &SkeletonModification3DJiggle::get_jiggle_joint_mass);
ClassDB::bind_method(D_METHOD("set_jiggle_joint_damping", "joint_idx", "damping"), &SkeletonModification3DJiggle::set_jiggle_joint_damping);
ClassDB::bind_method(D_METHOD("get_jiggle_joint_damping", "joint_idx"), &SkeletonModification3DJiggle::get_jiggle_joint_damping);
ClassDB::bind_method(D_METHOD("set_jiggle_joint_use_gravity", "joint_idx", "use_gravity"), &SkeletonModification3DJiggle::set_jiggle_joint_use_gravity);
ClassDB::bind_method(D_METHOD("get_jiggle_joint_use_gravity", "joint_idx"), &SkeletonModification3DJiggle::get_jiggle_joint_use_gravity);
ClassDB::bind_method(D_METHOD("set_jiggle_joint_gravity", "joint_idx", "gravity"), &SkeletonModification3DJiggle::set_jiggle_joint_gravity);
ClassDB::bind_method(D_METHOD("get_jiggle_joint_gravity", "joint_idx"), &SkeletonModification3DJiggle::get_jiggle_joint_gravity);
ClassDB::bind_method(D_METHOD("set_jiggle_joint_roll", "joint_idx", "roll"), &SkeletonModification3DJiggle::set_jiggle_joint_roll);
ClassDB::bind_method(D_METHOD("get_jiggle_joint_roll", "joint_idx"), &SkeletonModification3DJiggle::get_jiggle_joint_roll);
ADD_PROPERTY(PropertyInfo(Variant::NODE_PATH, "target_nodepath", PROPERTY_HINT_NODE_PATH_VALID_TYPES, "Node3D"), "set_target_node", "get_target_node");
ADD_PROPERTY(PropertyInfo(Variant::INT, "jiggle_data_chain_length", PROPERTY_HINT_RANGE, "0,100,1"), "set_jiggle_data_chain_length", "get_jiggle_data_chain_length");
ADD_GROUP("Default Joint Settings", "");
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "stiffness"), "set_stiffness", "get_stiffness");
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "mass"), "set_mass", "get_mass");
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "damping", PROPERTY_HINT_RANGE, "0, 1, 0.01"), "set_damping", "get_damping");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "use_gravity"), "set_use_gravity", "get_use_gravity");
ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "gravity"), "set_gravity", "get_gravity");
ADD_GROUP("", "");
}
SkeletonModification3DJiggle::SkeletonModification3DJiggle() {
stack = nullptr;
is_setup = false;
jiggle_data_chain = Vector<Jiggle_Joint_Data>();
stiffness = 3;
mass = 0.75;
damping = 0.75;
use_gravity = false;
gravity = Vector3(0, -6.0, 0);
enabled = true;
}
SkeletonModification3DJiggle::~SkeletonModification3DJiggle() {
}

138
scene/resources/skeleton_modification_3d_jiggle.h
View File

@ -1,138 +0,0 @@
/**************************************************************************/
/* skeleton_modification_3d_jiggle.h */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/**************************************************************************/
#ifndef SKELETON_MODIFICATION_3D_JIGGLE_H
#define SKELETON_MODIFICATION_3D_JIGGLE_H
#include "core/templates/local_vector.h"
#include "scene/3d/skeleton_3d.h"
#include "scene/resources/skeleton_modification_3d.h"
class SkeletonModification3DJiggle : public SkeletonModification3D {
GDCLASS(SkeletonModification3DJiggle, SkeletonModification3D);
private:
struct Jiggle_Joint_Data {
String bone_name = "";
int bone_idx = -1;
bool override_defaults = false;
real_t stiffness = 3;
real_t mass = 0.75;
real_t damping = 0.75;
bool use_gravity = false;
Vector3 gravity = Vector3(0, -6.0, 0);
real_t roll = 0;
Vector3 cached_rotation = Vector3(0, 0, 0);
Vector3 force = Vector3(0, 0, 0);
Vector3 acceleration = Vector3(0, 0, 0);
Vector3 velocity = Vector3(0, 0, 0);
Vector3 last_position = Vector3(0, 0, 0);
Vector3 dynamic_position = Vector3(0, 0, 0);
Vector3 last_noncollision_position = Vector3(0, 0, 0);
};
NodePath target_node;
ObjectID target_node_cache;
LocalVector<Jiggle_Joint_Data> jiggle_data_chain;
real_t stiffness = 3;
real_t mass = 0.75;
real_t damping = 0.75;
bool use_gravity = false;
Vector3 gravity = Vector3(0, -6.0, 0);
bool use_colliders = false;
uint32_t collision_mask = 1;
void update_cache();
void _execute_jiggle_joint(int p_joint_idx, Node3D *p_target, real_t p_delta);
void _update_jiggle_joint_data();
protected:
static void _bind_methods();
bool _get(const StringName &p_path, Variant &r_ret) const;
bool _set(const StringName &p_path, const Variant &p_value);
void _get_property_list(List<PropertyInfo> *p_list) const;
public:
virtual void _execute(real_t p_delta) override;
virtual void _setup_modification(SkeletonModificationStack3D *p_stack) override;
void set_target_node(const NodePath &p_target_node);
NodePath get_target_node() const;
void set_stiffness(real_t p_stiffness);
real_t get_stiffness() const;
void set_mass(real_t p_mass);
real_t get_mass() const;
void set_damping(real_t p_damping);
real_t get_damping() const;
void set_use_gravity(bool p_use_gravity);
bool get_use_gravity() const;
void set_gravity(Vector3 p_gravity);
Vector3 get_gravity() const;
void set_use_colliders(bool p_use_colliders);
bool get_use_colliders() const;
void set_collision_mask(int p_mask);
int get_collision_mask() const;
int get_jiggle_data_chain_length();
void set_jiggle_data_chain_length(int p_new_length);
void set_jiggle_joint_bone_name(int p_joint_idx, String p_name);
String get_jiggle_joint_bone_name(int p_joint_idx) const;
void set_jiggle_joint_bone_index(int p_joint_idx, int p_idx);
int get_jiggle_joint_bone_index(int p_joint_idx) const;
void set_jiggle_joint_override(int p_joint_idx, bool p_override);
bool get_jiggle_joint_override(int p_joint_idx) const;
void set_jiggle_joint_stiffness(int p_joint_idx, real_t p_stiffness);
real_t get_jiggle_joint_stiffness(int p_joint_idx) const;
void set_jiggle_joint_mass(int p_joint_idx, real_t p_mass);
real_t get_jiggle_joint_mass(int p_joint_idx) const;
void set_jiggle_joint_damping(int p_joint_idx, real_t p_damping);
real_t get_jiggle_joint_damping(int p_joint_idx) const;
void set_jiggle_joint_use_gravity(int p_joint_idx, bool p_use_gravity);
bool get_jiggle_joint_use_gravity(int p_joint_idx) const;
void set_jiggle_joint_gravity(int p_joint_idx, Vector3 p_gravity);
Vector3 get_jiggle_joint_gravity(int p_joint_idx) const;
void set_jiggle_joint_roll(int p_joint_idx, real_t p_roll);
real_t get_jiggle_joint_roll(int p_joint_idx) const;
SkeletonModification3DJiggle();
~SkeletonModification3DJiggle();
};
#endif // SKELETON_MODIFICATION_3D_JIGGLE_H

267
scene/resources/skeleton_modification_3d_lookat.cpp
View File

@ -1,267 +0,0 @@
/**************************************************************************/
/* skeleton_modification_3d_lookat.cpp */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/**************************************************************************/
#include "scene/resources/skeleton_modification_3d_lookat.h"
#include "scene/3d/skeleton_3d.h"
#include "scene/resources/skeleton_modification_3d.h"
bool SkeletonModification3DLookAt::_set(const StringName &p_path, const Variant &p_value) {
if (p_path == "lock_rotation_to_plane") {
set_lock_rotation_to_plane(p_value);
} else if (p_path == "lock_rotation_plane") {
set_lock_rotation_plane(p_value);
} else if (p_path == "additional_rotation") {
Vector3 tmp = p_value;
tmp.x = Math::deg_to_rad(tmp.x);
tmp.y = Math::deg_to_rad(tmp.y);
tmp.z = Math::deg_to_rad(tmp.z);
set_additional_rotation(tmp);
}
return true;
}
bool SkeletonModification3DLookAt::_get(const StringName &p_path, Variant &r_ret) const {
if (p_path == "lock_rotation_to_plane") {
r_ret = get_lock_rotation_to_plane();
} else if (p_path == "lock_rotation_plane") {
r_ret = get_lock_rotation_plane();
} else if (p_path == "additional_rotation") {
Vector3 tmp = get_additional_rotation();
tmp.x = Math::rad_to_deg(tmp.x);
tmp.y = Math::rad_to_deg(tmp.y);
tmp.z = Math::rad_to_deg(tmp.z);
r_ret = tmp;
}
return true;
}
void SkeletonModification3DLookAt::_get_property_list(List<PropertyInfo> *p_list) const {
p_list->push_back(PropertyInfo(Variant::BOOL, "lock_rotation_to_plane", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT));
if (lock_rotation_to_plane) {
p_list->push_back(PropertyInfo(Variant::INT, "lock_rotation_plane", PROPERTY_HINT_ENUM, "X plane,Y plane,Z plane", PROPERTY_USAGE_DEFAULT));
}
p_list->push_back(PropertyInfo(Variant::VECTOR3, "additional_rotation", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT));
}
void SkeletonModification3DLookAt::_execute(real_t p_delta) {
ERR_FAIL_COND_MSG(!stack || !is_setup || stack->skeleton == nullptr,
"Modification is not setup and therefore cannot execute!");
if (!enabled) {
return;
}
if (target_node_cache.is_null()) {
_print_execution_error(true, "Target cache is out of date. Attempting to update...");
update_cache();
return;
}
if (bone_idx <= -2) {
bone_idx = stack->skeleton->find_bone(bone_name);
}
Node3D *target = Object::cast_to<Node3D>(ObjectDB::get_instance(target_node_cache));
if (_print_execution_error(!target || !target->is_inside_tree(), "Target node is not in the scene tree. Cannot execute modification!")) {
return;
}
if (_print_execution_error(bone_idx <= -1, "Bone index is invalid. Cannot execute modification!")) {
return;
}
Transform3D new_bone_trans = stack->skeleton->get_bone_local_pose_override(bone_idx);
if (new_bone_trans == Transform3D()) {
new_bone_trans = stack->skeleton->get_bone_pose(bone_idx);
}
Vector3 target_pos = stack->skeleton->global_pose_to_local_pose(bone_idx, stack->skeleton->world_transform_to_global_pose(target->get_global_transform())).origin;
// Lock the rotation to a plane relative to the bone by changing the target position
if (lock_rotation_to_plane) {
if (lock_rotation_plane == ROTATION_PLANE::ROTATION_PLANE_X) {
target_pos.x = new_bone_trans.origin.x;
} else if (lock_rotation_plane == ROTATION_PLANE::ROTATION_PLANE_Y) {
target_pos.y = new_bone_trans.origin.y;
} else if (lock_rotation_plane == ROTATION_PLANE::ROTATION_PLANE_Z) {
target_pos.z = new_bone_trans.origin.z;
}
}
// Look at the target!
new_bone_trans = new_bone_trans.looking_at(target_pos, Vector3(0, 1, 0));
// Convert from Z-forward to whatever direction the bone faces.
stack->skeleton->update_bone_rest_forward_vector(bone_idx);
new_bone_trans.basis = stack->skeleton->global_pose_z_forward_to_bone_forward(bone_idx, new_bone_trans.basis);
// Apply additional rotation
new_bone_trans.basis.rotate_local(Vector3(1, 0, 0), additional_rotation.x);
new_bone_trans.basis.rotate_local(Vector3(0, 1, 0), additional_rotation.y);
new_bone_trans.basis.rotate_local(Vector3(0, 0, 1), additional_rotation.z);
stack->skeleton->set_bone_local_pose_override(bone_idx, new_bone_trans, stack->strength, true);
stack->skeleton->force_update_bone_children_transforms(bone_idx);
// If we completed it successfully, then we can set execution_error_found to false
execution_error_found = false;
}
void SkeletonModification3DLookAt::_setup_modification(SkeletonModificationStack3D *p_stack) {
stack = p_stack;
if (stack != nullptr) {
is_setup = true;
execution_error_found = false;
update_cache();
}
}
void SkeletonModification3DLookAt::set_bone_name(String p_name) {
bone_name = p_name;
if (stack) {
if (stack->skeleton) {
bone_idx = stack->skeleton->find_bone(bone_name);
}
}
execution_error_found = false;
notify_property_list_changed();
}
String SkeletonModification3DLookAt::get_bone_name() const {
return bone_name;
}
int SkeletonModification3DLookAt::get_bone_index() const {
return bone_idx;
}
void SkeletonModification3DLookAt::set_bone_index(int p_bone_idx) {
ERR_FAIL_COND_MSG(p_bone_idx < 0, "Bone index is out of range: The index is too low!");
bone_idx = p_bone_idx;
if (stack) {
if (stack->skeleton) {
bone_name = stack->skeleton->get_bone_name(p_bone_idx);
}
}
execution_error_found = false;
notify_property_list_changed();
}
void SkeletonModification3DLookAt::update_cache() {
if (!is_setup || !stack) {
_print_execution_error(true, "Cannot update target cache: modification is not properly setup!");
return;
}
target_node_cache = ObjectID();
if (stack->skeleton) {
if (stack->skeleton->is_inside_tree()) {
if (stack->skeleton->has_node(target_node)) {
Node *node = stack->skeleton->get_node(target_node);
ERR_FAIL_COND_MSG(!node || stack->skeleton == node,
"Cannot update target cache: Node is this modification's skeleton or cannot be found!");
ERR_FAIL_COND_MSG(!node->is_inside_tree(),
"Cannot update target cache: Node is not in the scene tree!");
target_node_cache = node->get_instance_id();
execution_error_found = false;
}
}
}
}
void SkeletonModification3DLookAt::set_target_node(const NodePath &p_target_node) {
target_node = p_target_node;
update_cache();
}
NodePath SkeletonModification3DLookAt::get_target_node() const {
return target_node;
}
Vector3 SkeletonModification3DLookAt::get_additional_rotation() const {
return additional_rotation;
}
void SkeletonModification3DLookAt::set_additional_rotation(Vector3 p_offset) {
additional_rotation = p_offset;
}
bool SkeletonModification3DLookAt::get_lock_rotation_to_plane() const {
return lock_rotation_plane;
}
void SkeletonModification3DLookAt::set_lock_rotation_to_plane(bool p_lock_rotation) {
lock_rotation_to_plane = p_lock_rotation;
notify_property_list_changed();
}
int SkeletonModification3DLookAt::get_lock_rotation_plane() const {
return lock_rotation_plane;
}
void SkeletonModification3DLookAt::set_lock_rotation_plane(int p_plane) {
lock_rotation_plane = p_plane;
}
void SkeletonModification3DLookAt::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_bone_name", "name"), &SkeletonModification3DLookAt::set_bone_name);
ClassDB::bind_method(D_METHOD("get_bone_name"), &SkeletonModification3DLookAt::get_bone_name);
ClassDB::bind_method(D_METHOD("set_bone_index", "bone_idx"), &SkeletonModification3DLookAt::set_bone_index);
ClassDB::bind_method(D_METHOD("get_bone_index"), &SkeletonModification3DLookAt::get_bone_index);
ClassDB::bind_method(D_METHOD("set_target_node", "target_nodepath"), &SkeletonModification3DLookAt::set_target_node);
ClassDB::bind_method(D_METHOD("get_target_node"), &SkeletonModification3DLookAt::get_target_node);
ClassDB::bind_method(D_METHOD("set_additional_rotation", "additional_rotation"), &SkeletonModification3DLookAt::set_additional_rotation);
ClassDB::bind_method(D_METHOD("get_additional_rotation"), &SkeletonModification3DLookAt::get_additional_rotation);
ClassDB::bind_method(D_METHOD("set_lock_rotation_to_plane", "lock_to_plane"), &SkeletonModification3DLookAt::set_lock_rotation_to_plane);
ClassDB::bind_method(D_METHOD("get_lock_rotation_to_plane"), &SkeletonModification3DLookAt::get_lock_rotation_to_plane);
ClassDB::bind_method(D_METHOD("set_lock_rotation_plane", "plane"), &SkeletonModification3DLookAt::set_lock_rotation_plane);
ClassDB::bind_method(D_METHOD("get_lock_rotation_plane"), &SkeletonModification3DLookAt::get_lock_rotation_plane);
ADD_PROPERTY(PropertyInfo(Variant::STRING_NAME, "bone_name"), "set_bone_name", "get_bone_name");
ADD_PROPERTY(PropertyInfo(Variant::INT, "bone_index"), "set_bone_index", "get_bone_index");
ADD_PROPERTY(PropertyInfo(Variant::NODE_PATH, "target_nodepath", PROPERTY_HINT_NODE_PATH_VALID_TYPES, "Node3D"), "set_target_node", "get_target_node");
}
SkeletonModification3DLookAt::SkeletonModification3DLookAt() {
stack = nullptr;
is_setup = false;
bone_name = "";
bone_idx = -2;
additional_rotation = Vector3();
lock_rotation_to_plane = false;
enabled = true;
}
SkeletonModification3DLookAt::~SkeletonModification3DLookAt() {
}

89
scene/resources/skeleton_modification_3d_lookat.h
View File

@ -1,89 +0,0 @@
/**************************************************************************/
/* skeleton_modification_3d_lookat.h */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/**************************************************************************/
#ifndef SKELETON_MODIFICATION_3D_LOOKAT_H
#define SKELETON_MODIFICATION_3D_LOOKAT_H
#include "scene/3d/skeleton_3d.h"
#include "scene/resources/skeleton_modification_3d.h"
class SkeletonModification3DLookAt : public SkeletonModification3D {
GDCLASS(SkeletonModification3DLookAt, SkeletonModification3D);
private:
String bone_name = "";
int bone_idx = -1;
NodePath target_node;
ObjectID target_node_cache;
Vector3 additional_rotation = Vector3(1, 0, 0);
bool lock_rotation_to_plane = false;
int lock_rotation_plane = ROTATION_PLANE_X;
void update_cache();
protected:
static void _bind_methods();
bool _get(const StringName &p_path, Variant &r_ret) const;
bool _set(const StringName &p_path, const Variant &p_value);
void _get_property_list(List<PropertyInfo> *p_list) const;
public:
enum ROTATION_PLANE {
ROTATION_PLANE_X,
ROTATION_PLANE_Y,
ROTATION_PLANE_Z
};
virtual void _execute(real_t p_delta) override;
virtual void _setup_modification(SkeletonModificationStack3D *p_stack) override;
void set_bone_name(String p_name);
String get_bone_name() const;
void set_bone_index(int p_idx);
int get_bone_index() const;
void set_target_node(const NodePath &p_target_node);
NodePath get_target_node() const;
void set_additional_rotation(Vector3 p_offset);
Vector3 get_additional_rotation() const;
void set_lock_rotation_to_plane(bool p_lock_to_plane);
bool get_lock_rotation_to_plane() const;
void set_lock_rotation_plane(int p_plane);
int get_lock_rotation_plane() const;
SkeletonModification3DLookAt();
~SkeletonModification3DLookAt();
};
#endif // SKELETON_MODIFICATION_3D_LOOKAT_H

104
scene/resources/skeleton_modification_3d_stackholder.cpp
View File

@ -1,104 +0,0 @@
/**************************************************************************/
/* skeleton_modification_3d_stackholder.cpp */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/**************************************************************************/
#include "scene/resources/skeleton_modification_3d_stackholder.h"
#include "scene/3d/skeleton_3d.h"
#include "scene/resources/skeleton_modification_3d.h"
bool SkeletonModification3DStackHolder::_set(const StringName &p_path, const Variant &p_value) {
String path = p_path;
if (path == "held_modification_stack") {
set_held_modification_stack(p_value);
}
return true;
}
bool SkeletonModification3DStackHolder::_get(const StringName &p_path, Variant &r_ret) const {
String path = p_path;
if (path == "held_modification_stack") {
r_ret = get_held_modification_stack();
}
return true;
}
void SkeletonModification3DStackHolder::_get_property_list(List<PropertyInfo> *p_list) const {
p_list->push_back(PropertyInfo(Variant::OBJECT, "held_modification_stack", PROPERTY_HINT_RESOURCE_TYPE, "SkeletonModificationStack3D", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_DO_NOT_SHARE_ON_DUPLICATE));
}
void SkeletonModification3DStackHolder::_execute(real_t p_delta) {
ERR_FAIL_COND_MSG(!stack || !is_setup || stack->skeleton == nullptr,
"Modification is not setup and therefore cannot execute!");
if (held_modification_stack.is_valid()) {
held_modification_stack->execute(p_delta, execution_mode);
}
}
void SkeletonModification3DStackHolder::_setup_modification(SkeletonModificationStack3D *p_stack) {
stack = p_stack;
if (stack != nullptr) {
is_setup = true;
if (held_modification_stack.is_valid()) {
held_modification_stack->set_skeleton(stack->get_skeleton());
held_modification_stack->setup();
}
}
}
void SkeletonModification3DStackHolder::set_held_modification_stack(Ref<SkeletonModificationStack3D> p_held_stack) {
held_modification_stack = p_held_stack;
if (is_setup && held_modification_stack.is_valid()) {
held_modification_stack->set_skeleton(stack->get_skeleton());
held_modification_stack->setup();
}
}
Ref<SkeletonModificationStack3D> SkeletonModification3DStackHolder::get_held_modification_stack() const {
return held_modification_stack;
}
void SkeletonModification3DStackHolder::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_held_modification_stack", "held_modification_stack"), &SkeletonModification3DStackHolder::set_held_modification_stack);
ClassDB::bind_method(D_METHOD("get_held_modification_stack"), &SkeletonModification3DStackHolder::get_held_modification_stack);
}
SkeletonModification3DStackHolder::SkeletonModification3DStackHolder() {
stack = nullptr;
is_setup = false;
enabled = true;
}
SkeletonModification3DStackHolder::~SkeletonModification3DStackHolder() {
}

59
scene/resources/skeleton_modification_3d_stackholder.h
View File

@ -1,59 +0,0 @@
/**************************************************************************/
/* skeleton_modification_3d_stackholder.h */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/**************************************************************************/
#ifndef SKELETON_MODIFICATION_3D_STACKHOLDER_H
#define SKELETON_MODIFICATION_3D_STACKHOLDER_H
#include "scene/3d/skeleton_3d.h"
#include "scene/resources/skeleton_modification_3d.h"
class SkeletonModification3DStackHolder : public SkeletonModification3D {
GDCLASS(SkeletonModification3DStackHolder, SkeletonModification3D);
protected:
static void _bind_methods();
bool _get(const StringName &p_path, Variant &r_ret) const;
bool _set(const StringName &p_path, const Variant &p_value);
void _get_property_list(List<PropertyInfo> *p_list) const;
public:
Ref<SkeletonModificationStack3D> held_modification_stack;
virtual void _execute(real_t p_delta) override;
virtual void _setup_modification(SkeletonModificationStack3D *p_stack) override;
void set_held_modification_stack(Ref<SkeletonModificationStack3D> p_held_stack);
Ref<SkeletonModificationStack3D> get_held_modification_stack() const;
SkeletonModification3DStackHolder();
~SkeletonModification3DStackHolder();
};
#endif // SKELETON_MODIFICATION_3D_STACKHOLDER_H

617
scene/resources/skeleton_modification_3d_twoboneik.cpp
View File

@ -1,617 +0,0 @@
/**************************************************************************/
/* skeleton_modification_3d_twoboneik.cpp */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/**************************************************************************/
#include "scene/resources/skeleton_modification_3d_twoboneik.h"
#include "scene/3d/skeleton_3d.h"
#include "scene/resources/skeleton_modification_3d.h"
bool SkeletonModification3DTwoBoneIK::_set(const StringName &p_path, const Variant &p_value) {
String path = p_path;
if (path == "use_tip_node") {
set_use_tip_node(p_value);
} else if (path == "tip_node") {
set_tip_node(p_value);
} else if (path == "auto_calculate_joint_length") {
set_auto_calculate_joint_length(p_value);
} else if (path == "use_pole_node") {
set_use_pole_node(p_value);
} else if (path == "pole_node") {
set_pole_node(p_value);
} else if (path == "joint_one_length") {
set_joint_one_length(p_value);
} else if (path == "joint_two_length") {
set_joint_two_length(p_value);
} else if (path == "joint_one/bone_name") {
set_joint_one_bone_name(p_value);
} else if (path == "joint_one/bone_idx") {
set_joint_one_bone_idx(p_value);
} else if (path == "joint_one/roll") {
set_joint_one_roll(Math::deg_to_rad(real_t(p_value)));
} else if (path == "joint_two/bone_name") {
set_joint_two_bone_name(p_value);
} else if (path == "joint_two/bone_idx") {
set_joint_two_bone_idx(p_value);
} else if (path == "joint_two/roll") {
set_joint_two_roll(Math::deg_to_rad(real_t(p_value)));
}
return true;
}
bool SkeletonModification3DTwoBoneIK::_get(const StringName &p_path, Variant &r_ret) const {
String path = p_path;
if (path == "use_tip_node") {
r_ret = get_use_tip_node();
} else if (path == "tip_node") {
r_ret = get_tip_node();
} else if (path == "auto_calculate_joint_length") {
r_ret = get_auto_calculate_joint_length();
} else if (path == "use_pole_node") {
r_ret = get_use_pole_node();
} else if (path == "pole_node") {
r_ret = get_pole_node();
} else if (path == "joint_one_length") {
r_ret = get_joint_one_length();
} else if (path == "joint_two_length") {
r_ret = get_joint_two_length();
} else if (path == "joint_one/bone_name") {
r_ret = get_joint_one_bone_name();
} else if (path == "joint_one/bone_idx") {
r_ret = get_joint_one_bone_idx();
} else if (path == "joint_one/roll") {
r_ret = Math::rad_to_deg(get_joint_one_roll());
} else if (path == "joint_two/bone_name") {
r_ret = get_joint_two_bone_name();
} else if (path == "joint_two/bone_idx") {
r_ret = get_joint_two_bone_idx();
} else if (path == "joint_two/roll") {
r_ret = Math::rad_to_deg(get_joint_two_roll());
}
return true;
}
void SkeletonModification3DTwoBoneIK::_get_property_list(List<PropertyInfo> *p_list) const {
p_list->push_back(PropertyInfo(Variant::BOOL, "use_tip_node", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT));
if (use_tip_node) {
p_list->push_back(PropertyInfo(Variant::NODE_PATH, "tip_node", PROPERTY_HINT_NODE_PATH_VALID_TYPES, "Node3D", PROPERTY_USAGE_DEFAULT));
}
p_list->push_back(PropertyInfo(Variant::BOOL, "auto_calculate_joint_length", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT));
if (!auto_calculate_joint_length) {
p_list->push_back(PropertyInfo(Variant::FLOAT, "joint_one_length", PROPERTY_HINT_RANGE, "-1, 10000, 0.001", PROPERTY_USAGE_DEFAULT));
p_list->push_back(PropertyInfo(Variant::FLOAT, "joint_two_length", PROPERTY_HINT_RANGE, "-1, 10000, 0.001", PROPERTY_USAGE_DEFAULT));
}
p_list->push_back(PropertyInfo(Variant::BOOL, "use_pole_node", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT));
if (use_pole_node) {
p_list->push_back(PropertyInfo(Variant::NODE_PATH, "pole_node", PROPERTY_HINT_NODE_PATH_VALID_TYPES, "Node3D", PROPERTY_USAGE_DEFAULT));
}
p_list->push_back(PropertyInfo(Variant::STRING_NAME, "joint_one/bone_name", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT));
p_list->push_back(PropertyInfo(Variant::INT, "joint_one/bone_idx", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT));
p_list->push_back(PropertyInfo(Variant::FLOAT, "joint_one/roll", PROPERTY_HINT_RANGE, "-360, 360, 0.01", PROPERTY_USAGE_DEFAULT));
p_list->push_back(PropertyInfo(Variant::STRING_NAME, "joint_two/bone_name", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT));
p_list->push_back(PropertyInfo(Variant::INT, "joint_two/bone_idx", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT));
p_list->push_back(PropertyInfo(Variant::FLOAT, "joint_two/roll", PROPERTY_HINT_RANGE, "-360, 360, 0.01", PROPERTY_USAGE_DEFAULT));
}
void SkeletonModification3DTwoBoneIK::_execute(real_t p_delta) {
ERR_FAIL_COND_MSG(!stack || !is_setup || stack->skeleton == nullptr,
"Modification is not setup and therefore cannot execute!");
if (!enabled) {
return;
}
if (_print_execution_error(joint_one_bone_idx < 0 || joint_two_bone_idx < 0,
"One (or more) of the bones in the modification have invalid bone indexes. Cannot execute modification!")) {
return;
}
if (target_node_cache.is_null()) {
_print_execution_error(true, "Target cache is out of date. Attempting to update...");
update_cache_target();
return;
}
// Update joint lengths (if needed)
if (auto_calculate_joint_length && (joint_one_length < 0 || joint_two_length < 0)) {
calculate_joint_lengths();
}
// Adopted from the links below:
// http://theorangeduck.com/page/simple-two-joint
// https://www.alanzucconi.com/2018/05/02/ik-2d-2/
// With modifications by TwistedTwigleg
Node3D *target = Object::cast_to<Node3D>(ObjectDB::get_instance(target_node_cache));
if (_print_execution_error(!target || !target->is_inside_tree(), "Target node is not in the scene tree. Cannot execute modification!")) {
return;
}
Transform3D target_trans = stack->skeleton->world_transform_to_global_pose(target->get_global_transform());
Transform3D bone_one_trans;
Transform3D bone_two_trans;
// Make the first joint look at the pole, and the second look at the target. That way, the
// TwoBoneIK solver has to really only handle extension/contraction, which should make it align with the pole.
if (use_pole_node) {
if (pole_node_cache.is_null()) {
_print_execution_error(true, "Pole cache is out of date. Attempting to update...");
update_cache_pole();
return;
}
Node3D *pole = Object::cast_to<Node3D>(ObjectDB::get_instance(pole_node_cache));
if (_print_execution_error(!pole || !pole->is_inside_tree(), "Pole node is not in the scene tree. Cannot execute modification!")) {
return;
}
Transform3D pole_trans = stack->skeleton->world_transform_to_global_pose(pole->get_global_transform());
Transform3D bone_one_local_pos = stack->skeleton->get_bone_local_pose_override(joint_one_bone_idx);
if (bone_one_local_pos == Transform3D()) {
bone_one_local_pos = stack->skeleton->get_bone_pose(joint_one_bone_idx);
}
Transform3D bone_two_local_pos = stack->skeleton->get_bone_local_pose_override(joint_two_bone_idx);
if (bone_two_local_pos == Transform3D()) {
bone_two_local_pos = stack->skeleton->get_bone_pose(joint_two_bone_idx);
}
bone_one_trans = stack->skeleton->local_pose_to_global_pose(joint_one_bone_idx, bone_one_local_pos);
bone_one_trans = bone_one_trans.looking_at(pole_trans.origin, Vector3(0, 1, 0));
bone_one_trans.basis = stack->skeleton->global_pose_z_forward_to_bone_forward(joint_one_bone_idx, bone_one_trans.basis);
stack->skeleton->update_bone_rest_forward_vector(joint_one_bone_idx);
bone_one_trans.basis.rotate_local(stack->skeleton->get_bone_axis_forward_vector(joint_one_bone_idx), joint_one_roll);
stack->skeleton->set_bone_local_pose_override(joint_one_bone_idx, stack->skeleton->global_pose_to_local_pose(joint_one_bone_idx, bone_one_trans), stack->strength, true);
stack->skeleton->force_update_bone_children_transforms(joint_one_bone_idx);
bone_two_trans = stack->skeleton->local_pose_to_global_pose(joint_two_bone_idx, bone_two_local_pos);
bone_two_trans = bone_two_trans.looking_at(target_trans.origin, Vector3(0, 1, 0));
bone_two_trans.basis = stack->skeleton->global_pose_z_forward_to_bone_forward(joint_two_bone_idx, bone_two_trans.basis);
stack->skeleton->update_bone_rest_forward_vector(joint_two_bone_idx);
bone_two_trans.basis.rotate_local(stack->skeleton->get_bone_axis_forward_vector(joint_two_bone_idx), joint_two_roll);
stack->skeleton->set_bone_local_pose_override(joint_two_bone_idx, stack->skeleton->global_pose_to_local_pose(joint_two_bone_idx, bone_two_trans), stack->strength, true);
stack->skeleton->force_update_bone_children_transforms(joint_two_bone_idx);
} else {
Transform3D bone_one_local_pos = stack->skeleton->get_bone_local_pose_override(joint_one_bone_idx);
if (bone_one_local_pos == Transform3D()) {
bone_one_local_pos = stack->skeleton->get_bone_pose(joint_one_bone_idx);
}
Transform3D bone_two_local_pos = stack->skeleton->get_bone_local_pose_override(joint_two_bone_idx);
if (bone_two_local_pos == Transform3D()) {
bone_two_local_pos = stack->skeleton->get_bone_pose(joint_two_bone_idx);
}
bone_one_trans = stack->skeleton->local_pose_to_global_pose(joint_one_bone_idx, bone_one_local_pos);
bone_two_trans = stack->skeleton->local_pose_to_global_pose(joint_two_bone_idx, bone_two_local_pos);
}
Transform3D bone_two_tip_trans;
if (use_tip_node) {
if (tip_node_cache.is_null()) {
_print_execution_error(true, "Tip cache is out of date. Attempting to update...");
update_cache_tip();
return;
}
Node3D *tip = Object::cast_to<Node3D>(ObjectDB::get_instance(tip_node_cache));
if (_print_execution_error(!tip || !tip->is_inside_tree(), "Tip node is not in the scene tree. Cannot execute modification!")) {
return;
}
bone_two_tip_trans = stack->skeleton->world_transform_to_global_pose(tip->get_global_transform());
} else {
stack->skeleton->update_bone_rest_forward_vector(joint_two_bone_idx);
bone_two_tip_trans = bone_two_trans;
bone_two_tip_trans.origin += bone_two_trans.basis.xform(stack->skeleton->get_bone_axis_forward_vector(joint_two_bone_idx)).normalized() * joint_two_length;
}
real_t joint_one_to_target_length = bone_one_trans.origin.distance_to(target_trans.origin);
if (joint_one_length + joint_two_length < joint_one_to_target_length) {
// Set the target *just* out of reach to straighten the bones
joint_one_to_target_length = joint_one_length + joint_two_length + 0.01;
} else if (joint_one_to_target_length < joint_one_length) {
// Place the target in reach so the solver doesn't do crazy things
joint_one_to_target_length = joint_one_length;
}
// Get the square lengths for all three sides of the triangle we'll use to calculate the angles
real_t sqr_one_length = joint_one_length * joint_one_length;
real_t sqr_two_length = joint_two_length * joint_two_length;
real_t sqr_three_length = joint_one_to_target_length * joint_one_to_target_length;
// Calculate the angles for the first joint using the law of cosigns
real_t ac_ab_0 = Math::acos(CLAMP(bone_two_tip_trans.origin.direction_to(bone_one_trans.origin).dot(bone_two_trans.origin.direction_to(bone_one_trans.origin)), -1, 1));
real_t ac_at_0 = Math::acos(CLAMP(bone_one_trans.origin.direction_to(bone_two_tip_trans.origin).dot(bone_one_trans.origin.direction_to(target_trans.origin)), -1, 1));
real_t ac_ab_1 = Math::acos(CLAMP((sqr_two_length - sqr_one_length - sqr_three_length) / (-2.0 * joint_one_length * joint_one_to_target_length), -1, 1));
// Calculate the angles of rotation. Angle 0 is the extension/contraction axis, while angle 1 is the rotation axis to align the triangle to the target
Vector3 axis_0 = bone_one_trans.origin.direction_to(bone_two_tip_trans.origin).cross(bone_one_trans.origin.direction_to(bone_two_trans.origin));
Vector3 axis_1 = bone_one_trans.origin.direction_to(bone_two_tip_trans.origin).cross(bone_one_trans.origin.direction_to(target_trans.origin));
// Make a quaternion with the delta rotation needed to rotate the first joint into alignment and apply it to the transform.
Quaternion bone_one_quat = bone_one_trans.basis.get_rotation_quaternion();
Quaternion rot_0 = Quaternion(bone_one_quat.inverse().xform(axis_0).normalized(), (ac_ab_1 - ac_ab_0));
Quaternion rot_2 = Quaternion(bone_one_quat.inverse().xform(axis_1).normalized(), ac_at_0);
bone_one_trans.basis.set_quaternion(bone_one_quat * (rot_0 * rot_2));
stack->skeleton->update_bone_rest_forward_vector(joint_one_bone_idx);
bone_one_trans.basis.rotate_local(stack->skeleton->get_bone_axis_forward_vector(joint_one_bone_idx), joint_one_roll);
// Apply the rotation to the first joint
bone_one_trans = stack->skeleton->global_pose_to_local_pose(joint_one_bone_idx, bone_one_trans);
bone_one_trans.origin = Vector3(0, 0, 0);
stack->skeleton->set_bone_local_pose_override(joint_one_bone_idx, bone_one_trans, stack->strength, true);
stack->skeleton->force_update_bone_children_transforms(joint_one_bone_idx);
if (use_pole_node) {
// Update bone_two_trans so its at the latest position, with the rotation of bone_one_trans taken into account, then look at the target.
bone_two_trans = stack->skeleton->local_pose_to_global_pose(joint_two_bone_idx, stack->skeleton->get_bone_local_pose_override(joint_two_bone_idx));
stack->skeleton->update_bone_rest_forward_vector(joint_two_bone_idx);
Vector3 forward_vector = stack->skeleton->get_bone_axis_forward_vector(joint_two_bone_idx);
bone_two_trans.basis.rotate_to_align(forward_vector, bone_two_trans.origin.direction_to(target_trans.origin));
stack->skeleton->update_bone_rest_forward_vector(joint_two_bone_idx);
bone_two_trans.basis.rotate_local(stack->skeleton->get_bone_axis_forward_vector(joint_two_bone_idx), joint_two_roll);
bone_two_trans = stack->skeleton->global_pose_to_local_pose(joint_two_bone_idx, bone_two_trans);
stack->skeleton->set_bone_local_pose_override(joint_two_bone_idx, bone_two_trans, stack->strength, true);
stack->skeleton->force_update_bone_children_transforms(joint_two_bone_idx);
} else {
// Calculate the angles for the second joint using the law of cosigns, make a quaternion with the delta rotation needed to rotate the joint into
// alignment, and then apply it to the second joint.
real_t ba_bc_0 = Math::acos(CLAMP(bone_two_trans.origin.direction_to(bone_one_trans.origin).dot(bone_two_trans.origin.direction_to(bone_two_tip_trans.origin)), -1, 1));
real_t ba_bc_1 = Math::acos(CLAMP((sqr_three_length - sqr_one_length - sqr_two_length) / (-2.0 * joint_one_length * joint_two_length), -1, 1));
Quaternion bone_two_quat = bone_two_trans.basis.get_rotation_quaternion();
Quaternion rot_1 = Quaternion(bone_two_quat.inverse().xform(axis_0).normalized(), (ba_bc_1 - ba_bc_0));
bone_two_trans.basis.set_quaternion(bone_two_quat * rot_1);
stack->skeleton->update_bone_rest_forward_vector(joint_two_bone_idx);
bone_two_trans.basis.rotate_local(stack->skeleton->get_bone_axis_forward_vector(joint_two_bone_idx), joint_two_roll);
bone_two_trans = stack->skeleton->global_pose_to_local_pose(joint_two_bone_idx, bone_two_trans);
bone_two_trans.origin = Vector3(0, 0, 0);
stack->skeleton->set_bone_local_pose_override(joint_two_bone_idx, bone_two_trans, stack->strength, true);
stack->skeleton->force_update_bone_children_transforms(joint_two_bone_idx);
}
}
void SkeletonModification3DTwoBoneIK::_setup_modification(SkeletonModificationStack3D *p_stack) {
stack = p_stack;
if (stack != nullptr) {
is_setup = true;
execution_error_found = false;
update_cache_target();
update_cache_tip();
}
}
void SkeletonModification3DTwoBoneIK::update_cache_target() {
if (!is_setup || !stack) {
_print_execution_error(true, "Cannot update target cache: modification is not properly setup!");
return;
}
target_node_cache = ObjectID();
if (stack->skeleton) {
if (stack->skeleton->is_inside_tree() && target_node.is_empty() == false) {
if (stack->skeleton->has_node(target_node)) {
Node *node = stack->skeleton->get_node(target_node);
ERR_FAIL_COND_MSG(!node || stack->skeleton == node,
"Cannot update target cache: Target node is this modification's skeleton or cannot be found. Cannot execute modification");
ERR_FAIL_COND_MSG(!node->is_inside_tree(),
"Cannot update target cache: Target node is not in the scene tree. Cannot execute modification!");
target_node_cache = node->get_instance_id();
execution_error_found = false;
}
}
}
}
void SkeletonModification3DTwoBoneIK::update_cache_tip() {
if (!is_setup || !stack) {
_print_execution_error(true, "Cannot update tip cache: modification is not properly setup!");
return;
}
tip_node_cache = ObjectID();
if (stack->skeleton) {
if (stack->skeleton->is_inside_tree()) {
if (stack->skeleton->has_node(tip_node)) {
Node *node = stack->skeleton->get_node(tip_node);
ERR_FAIL_COND_MSG(!node || stack->skeleton == node,
"Cannot update tip cache: Tip node is this modification's skeleton or cannot be found!");
ERR_FAIL_COND_MSG(!node->is_inside_tree(),
"Cannot update tip cache: Tip node is not in the scene tree. Cannot execute modification!");
tip_node_cache = node->get_instance_id();
execution_error_found = false;
}
}
}
}
void SkeletonModification3DTwoBoneIK::update_cache_pole() {
if (!is_setup || !stack) {
_print_execution_error(true, "Cannot update pole cache: modification is not properly setup!");
return;
}
pole_node_cache = ObjectID();
if (stack->skeleton) {
if (stack->skeleton->is_inside_tree()) {
if (stack->skeleton->has_node(pole_node)) {
Node *node = stack->skeleton->get_node(pole_node);
ERR_FAIL_COND_MSG(!node || stack->skeleton == node,
"Cannot update pole cache: Pole node is this modification's skeleton or cannot be found!");
ERR_FAIL_COND_MSG(!node->is_inside_tree(),
"Cannot update pole cache: Pole node is not in the scene tree. Cannot execute modification!");
pole_node_cache = node->get_instance_id();
execution_error_found = false;
}
}
}
}
void SkeletonModification3DTwoBoneIK::set_target_node(const NodePath &p_target_node) {
target_node = p_target_node;
update_cache_target();
}
NodePath SkeletonModification3DTwoBoneIK::get_target_node() const {
return target_node;
}
void SkeletonModification3DTwoBoneIK::set_use_tip_node(const bool p_use_tip_node) {
use_tip_node = p_use_tip_node;
notify_property_list_changed();
}
bool SkeletonModification3DTwoBoneIK::get_use_tip_node() const {
return use_tip_node;
}
void SkeletonModification3DTwoBoneIK::set_tip_node(const NodePath &p_tip_node) {
tip_node = p_tip_node;
update_cache_tip();
}
NodePath SkeletonModification3DTwoBoneIK::get_tip_node() const {
return tip_node;
}
void SkeletonModification3DTwoBoneIK::set_use_pole_node(const bool p_use_pole_node) {
use_pole_node = p_use_pole_node;
notify_property_list_changed();
}
bool SkeletonModification3DTwoBoneIK::get_use_pole_node() const {
return use_pole_node;
}
void SkeletonModification3DTwoBoneIK::set_pole_node(const NodePath &p_pole_node) {
pole_node = p_pole_node;
update_cache_pole();
}
NodePath SkeletonModification3DTwoBoneIK::get_pole_node() const {
return pole_node;
}
void SkeletonModification3DTwoBoneIK::set_auto_calculate_joint_length(bool p_calculate) {
auto_calculate_joint_length = p_calculate;
if (p_calculate) {
calculate_joint_lengths();
}
notify_property_list_changed();
}
bool SkeletonModification3DTwoBoneIK::get_auto_calculate_joint_length() const {
return auto_calculate_joint_length;
}
void SkeletonModification3DTwoBoneIK::calculate_joint_lengths() {
if (!is_setup) {
return; // fail silently, as we likely just loaded the scene.
}
ERR_FAIL_COND_MSG(!stack || stack->skeleton == nullptr,
"Modification is not setup and therefore cannot calculate joint lengths!");
ERR_FAIL_COND_MSG(joint_one_bone_idx <= -1 || joint_two_bone_idx <= -1,
"One of the bones in the TwoBoneIK modification are not set! Cannot calculate joint lengths!");
Transform3D bone_one_rest_trans = stack->skeleton->get_bone_global_pose(joint_one_bone_idx);
Transform3D bone_two_rest_trans = stack->skeleton->get_bone_global_pose(joint_two_bone_idx);
joint_one_length = bone_one_rest_trans.origin.distance_to(bone_two_rest_trans.origin);
if (use_tip_node) {
if (tip_node_cache.is_null()) {
update_cache_tip();
WARN_PRINT("Tip cache is out of date. Updating...");
}
Node3D *tip = Object::cast_to<Node3D>(ObjectDB::get_instance(tip_node_cache));
if (tip) {
Transform3D bone_tip_trans = stack->skeleton->world_transform_to_global_pose(tip->get_global_transform());
joint_two_length = bone_two_rest_trans.origin.distance_to(bone_tip_trans.origin);
}
} else {
// Attempt to use children bones to get the length
Vector<int> bone_two_children = stack->skeleton->get_bone_children(joint_two_bone_idx);
if (bone_two_children.size() > 0) {
joint_two_length = 0;
for (int i = 0; i < bone_two_children.size(); i++) {
joint_two_length += bone_two_rest_trans.origin.distance_to(
stack->skeleton->get_bone_global_pose(bone_two_children[i]).origin);
}
joint_two_length = joint_two_length / bone_two_children.size();
} else {
WARN_PRINT("TwoBoneIK modification: Cannot auto calculate length for joint 2! Auto setting the length to 1...");
joint_two_length = 1.0;
}
}
execution_error_found = false;
}
void SkeletonModification3DTwoBoneIK::set_joint_one_bone_name(String p_bone_name) {
joint_one_bone_name = p_bone_name;
if (stack && stack->skeleton) {
joint_one_bone_idx = stack->skeleton->find_bone(p_bone_name);
}
execution_error_found = false;
notify_property_list_changed();
}
String SkeletonModification3DTwoBoneIK::get_joint_one_bone_name() const {
return joint_one_bone_name;
}
void SkeletonModification3DTwoBoneIK::set_joint_one_bone_idx(int p_bone_idx) {
joint_one_bone_idx = p_bone_idx;
if (stack && stack->skeleton) {
joint_one_bone_name = stack->skeleton->get_bone_name(p_bone_idx);
}
execution_error_found = false;
notify_property_list_changed();
}
int SkeletonModification3DTwoBoneIK::get_joint_one_bone_idx() const {
return joint_one_bone_idx;
}
void SkeletonModification3DTwoBoneIK::set_joint_one_length(real_t p_length) {
joint_one_length = p_length;
}
real_t SkeletonModification3DTwoBoneIK::get_joint_one_length() const {
return joint_one_length;
}
void SkeletonModification3DTwoBoneIK::set_joint_two_bone_name(String p_bone_name) {
joint_two_bone_name = p_bone_name;
if (stack && stack->skeleton) {
joint_two_bone_idx = stack->skeleton->find_bone(p_bone_name);
}
execution_error_found = false;
notify_property_list_changed();
}
String SkeletonModification3DTwoBoneIK::get_joint_two_bone_name() const {
return joint_two_bone_name;
}
void SkeletonModification3DTwoBoneIK::set_joint_two_bone_idx(int p_bone_idx) {
joint_two_bone_idx = p_bone_idx;
if (stack && stack->skeleton) {
joint_two_bone_name = stack->skeleton->get_bone_name(p_bone_idx);
}
execution_error_found = false;
notify_property_list_changed();
}
int SkeletonModification3DTwoBoneIK::get_joint_two_bone_idx() const {
return joint_two_bone_idx;
}
void SkeletonModification3DTwoBoneIK::set_joint_two_length(real_t p_length) {
joint_two_length = p_length;
}
real_t SkeletonModification3DTwoBoneIK::get_joint_two_length() const {
return joint_two_length;
}
void SkeletonModification3DTwoBoneIK::set_joint_one_roll(real_t p_roll) {
joint_one_roll = p_roll;
}
real_t SkeletonModification3DTwoBoneIK::get_joint_one_roll() const {
return joint_one_roll;
}
void SkeletonModification3DTwoBoneIK::set_joint_two_roll(real_t p_roll) {
joint_two_roll = p_roll;
}
real_t SkeletonModification3DTwoBoneIK::get_joint_two_roll() const {
return joint_two_roll;
}
void SkeletonModification3DTwoBoneIK::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_target_node", "target_nodepath"), &SkeletonModification3DTwoBoneIK::set_target_node);
ClassDB::bind_method(D_METHOD("get_target_node"), &SkeletonModification3DTwoBoneIK::get_target_node);
ClassDB::bind_method(D_METHOD("set_use_pole_node", "use_pole_node"), &SkeletonModification3DTwoBoneIK::set_use_pole_node);
ClassDB::bind_method(D_METHOD("get_use_pole_node"), &SkeletonModification3DTwoBoneIK::get_use_pole_node);
ClassDB::bind_method(D_METHOD("set_pole_node", "pole_nodepath"), &SkeletonModification3DTwoBoneIK::set_pole_node);
ClassDB::bind_method(D_METHOD("get_pole_node"), &SkeletonModification3DTwoBoneIK::get_pole_node);
ClassDB::bind_method(D_METHOD("set_use_tip_node", "use_tip_node"), &SkeletonModification3DTwoBoneIK::set_use_tip_node);
ClassDB::bind_method(D_METHOD("get_use_tip_node"), &SkeletonModification3DTwoBoneIK::get_use_tip_node);
ClassDB::bind_method(D_METHOD("set_tip_node", "tip_nodepath"), &SkeletonModification3DTwoBoneIK::set_tip_node);
ClassDB::bind_method(D_METHOD("get_tip_node"), &SkeletonModification3DTwoBoneIK::get_tip_node);
ClassDB::bind_method(D_METHOD("set_auto_calculate_joint_length", "auto_calculate_joint_length"), &SkeletonModification3DTwoBoneIK::set_auto_calculate_joint_length);
ClassDB::bind_method(D_METHOD("get_auto_calculate_joint_length"), &SkeletonModification3DTwoBoneIK::get_auto_calculate_joint_length);
ClassDB::bind_method(D_METHOD("set_joint_one_bone_name", "bone_name"), &SkeletonModification3DTwoBoneIK::set_joint_one_bone_name);
ClassDB::bind_method(D_METHOD("get_joint_one_bone_name"), &SkeletonModification3DTwoBoneIK::get_joint_one_bone_name);
ClassDB::bind_method(D_METHOD("set_joint_one_bone_idx", "bone_idx"), &SkeletonModification3DTwoBoneIK::set_joint_one_bone_idx);
ClassDB::bind_method(D_METHOD("get_joint_one_bone_idx"), &SkeletonModification3DTwoBoneIK::get_joint_one_bone_idx);
ClassDB::bind_method(D_METHOD("set_joint_one_length", "bone_length"), &SkeletonModification3DTwoBoneIK::set_joint_one_length);
ClassDB::bind_method(D_METHOD("get_joint_one_length"), &SkeletonModification3DTwoBoneIK::get_joint_one_length);
ClassDB::bind_method(D_METHOD("set_joint_two_bone_name", "bone_name"), &SkeletonModification3DTwoBoneIK::set_joint_two_bone_name);
ClassDB::bind_method(D_METHOD("get_joint_two_bone_name"), &SkeletonModification3DTwoBoneIK::get_joint_two_bone_name);
ClassDB::bind_method(D_METHOD("set_joint_two_bone_idx", "bone_idx"), &SkeletonModification3DTwoBoneIK::set_joint_two_bone_idx);
ClassDB::bind_method(D_METHOD("get_joint_two_bone_idx"), &SkeletonModification3DTwoBoneIK::get_joint_two_bone_idx);
ClassDB::bind_method(D_METHOD("set_joint_two_length", "bone_length"), &SkeletonModification3DTwoBoneIK::set_joint_two_length);
ClassDB::bind_method(D_METHOD("get_joint_two_length"), &SkeletonModification3DTwoBoneIK::get_joint_two_length);
ClassDB::bind_method(D_METHOD("set_joint_one_roll", "roll"), &SkeletonModification3DTwoBoneIK::set_joint_one_roll);
ClassDB::bind_method(D_METHOD("get_joint_one_roll"), &SkeletonModification3DTwoBoneIK::get_joint_one_roll);
ClassDB::bind_method(D_METHOD("set_joint_two_roll", "roll"), &SkeletonModification3DTwoBoneIK::set_joint_two_roll);
ClassDB::bind_method(D_METHOD("get_joint_two_roll"), &SkeletonModification3DTwoBoneIK::get_joint_two_roll);
ADD_PROPERTY(PropertyInfo(Variant::NODE_PATH, "target_nodepath", PROPERTY_HINT_NODE_PATH_VALID_TYPES, "Node3D"), "set_target_node", "get_target_node");
ADD_GROUP("", "");
}
SkeletonModification3DTwoBoneIK::SkeletonModification3DTwoBoneIK() {
stack = nullptr;
is_setup = false;
}
SkeletonModification3DTwoBoneIK::~SkeletonModification3DTwoBoneIK() {
}

118
scene/resources/skeleton_modification_3d_twoboneik.h
View File

@ -1,118 +0,0 @@
/**************************************************************************/
/* skeleton_modification_3d_twoboneik.h */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/**************************************************************************/
#ifndef SKELETON_MODIFICATION_3D_TWOBONEIK_H
#define SKELETON_MODIFICATION_3D_TWOBONEIK_H
#include "scene/3d/skeleton_3d.h"
#include "scene/resources/skeleton_modification_3d.h"
class SkeletonModification3DTwoBoneIK : public SkeletonModification3D {
GDCLASS(SkeletonModification3DTwoBoneIK, SkeletonModification3D);
private:
NodePath target_node;
ObjectID target_node_cache;
bool use_tip_node = false;
NodePath tip_node;
ObjectID tip_node_cache;
bool use_pole_node = false;
NodePath pole_node;
ObjectID pole_node_cache;
String joint_one_bone_name = "";
int joint_one_bone_idx = -1;
String joint_two_bone_name = "";
int joint_two_bone_idx = -1;
bool auto_calculate_joint_length = false;
real_t joint_one_length = -1;
real_t joint_two_length = -1;
real_t joint_one_roll = 0;
real_t joint_two_roll = 0;
void update_cache_target();
void update_cache_tip();
void update_cache_pole();
protected:
static void _bind_methods();
bool _get(const StringName &p_path, Variant &r_ret) const;
bool _set(const StringName &p_path, const Variant &p_value);
void _get_property_list(List<PropertyInfo> *p_list) const;
public:
virtual void _execute(real_t p_delta) override;
virtual void _setup_modification(SkeletonModificationStack3D *p_stack) override;
void set_target_node(const NodePath &p_target_node);
NodePath get_target_node() const;
void set_use_tip_node(const bool p_use_tip_node);
bool get_use_tip_node() const;
void set_tip_node(const NodePath &p_tip_node);
NodePath get_tip_node() const;
void set_use_pole_node(const bool p_use_pole_node);
bool get_use_pole_node() const;
void set_pole_node(const NodePath &p_pole_node);
NodePath get_pole_node() const;
void set_auto_calculate_joint_length(bool p_calculate);
bool get_auto_calculate_joint_length() const;
void calculate_joint_lengths();
void set_joint_one_bone_name(String p_bone_name);
String get_joint_one_bone_name() const;
void set_joint_one_bone_idx(int p_bone_idx);
int get_joint_one_bone_idx() const;
void set_joint_one_length(real_t p_length);
real_t get_joint_one_length() const;
void set_joint_two_bone_name(String p_bone_name);
String get_joint_two_bone_name() const;
void set_joint_two_bone_idx(int p_bone_idx);
int get_joint_two_bone_idx() const;
void set_joint_two_length(real_t p_length);
real_t get_joint_two_length() const;
void set_joint_one_roll(real_t p_roll);
real_t get_joint_one_roll() const;
void set_joint_two_roll(real_t p_roll);
real_t get_joint_two_roll() const;
SkeletonModification3DTwoBoneIK();
~SkeletonModification3DTwoBoneIK();
};
#endif // SKELETON_MODIFICATION_3D_TWOBONEIK_H

224
scene/resources/skeleton_modification_stack_3d.cpp
View File

@ -1,224 +0,0 @@
/**************************************************************************/
/* skeleton_modification_stack_3d.cpp */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/**************************************************************************/
#include "skeleton_modification_stack_3d.h"
#include "scene/3d/skeleton_3d.h"
///////////////////////////////////////
// ModificationStack3D
///////////////////////////////////////
void SkeletonModificationStack3D::_get_property_list(List<PropertyInfo> *p_list) const {
for (uint32_t i = 0; i < modifications.size(); i++) {
p_list->push_back(
PropertyInfo(Variant::OBJECT, "modifications/" + itos(i),
PROPERTY_HINT_RESOURCE_TYPE,
"SkeletonModification3D",
PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_DEFERRED_SET_RESOURCE | PROPERTY_USAGE_DO_NOT_SHARE_ON_DUPLICATE));
}
}
bool SkeletonModificationStack3D::_set(const StringName &p_path, const Variant &p_value) {
String path = p_path;
if (path.begins_with("modifications/")) {
int mod_idx = path.get_slicec('/', 1).to_int();
set_modification(mod_idx, p_value);
return true;
}
return true;
}
bool SkeletonModificationStack3D::_get(const StringName &p_path, Variant &r_ret) const {
String path = p_path;
if (path.begins_with("modifications/")) {
int mod_idx = path.get_slicec('/', 1).to_int();
r_ret = get_modification(mod_idx);
return true;
}
return true;
}
void SkeletonModificationStack3D::setup() {
if (is_setup) {
return;
}
if (skeleton != nullptr) {
is_setup = true;
for (uint32_t i = 0; i < modifications.size(); i++) {
if (!modifications[i].is_valid()) {
continue;
}
modifications[i]->_setup_modification(this);
}
} else {
WARN_PRINT("Cannot setup SkeletonModificationStack3D: no skeleton set!");
}
}
void SkeletonModificationStack3D::execute(real_t p_delta, int p_execution_mode) {
ERR_FAIL_COND_MSG(!is_setup || skeleton == nullptr || is_queued_for_deletion(),
"Modification stack is not properly setup and therefore cannot execute!");
if (!skeleton->is_inside_tree()) {
ERR_PRINT_ONCE("Skeleton is not inside SceneTree! Cannot execute modification!");
return;
}
if (!enabled) {
return;
}
for (uint32_t i = 0; i < modifications.size(); i++) {
if (!modifications[i].is_valid()) {
continue;
}
if (modifications[i]->get_execution_mode() == p_execution_mode) {
modifications[i]->_execute(p_delta);
}
}
}
void SkeletonModificationStack3D::enable_all_modifications(bool p_enabled) {
for (uint32_t i = 0; i < modifications.size(); i++) {
if (!modifications[i].is_valid()) {
continue;
}
modifications[i]->set_enabled(p_enabled);
}
}
Ref<SkeletonModification3D> SkeletonModificationStack3D::get_modification(int p_mod_idx) const {
const int modifications_size = modifications.size();
ERR_FAIL_INDEX_V(p_mod_idx, modifications_size, nullptr);
return modifications[p_mod_idx];
}
void SkeletonModificationStack3D::add_modification(Ref<SkeletonModification3D> p_mod) {
ERR_FAIL_NULL(p_mod);
p_mod->_setup_modification(this);
modifications.push_back(p_mod);
}
void SkeletonModificationStack3D::delete_modification(int p_mod_idx) {
const int modifications_size = modifications.size();
ERR_FAIL_INDEX(p_mod_idx, modifications_size);
modifications.remove_at(p_mod_idx);
}
void SkeletonModificationStack3D::set_modification(int p_mod_idx, Ref<SkeletonModification3D> p_mod) {
const int modifications_size = modifications.size();
ERR_FAIL_INDEX(p_mod_idx, modifications_size);
if (p_mod == nullptr) {
modifications.remove_at(p_mod_idx);
} else {
p_mod->_setup_modification(this);
modifications[p_mod_idx] = p_mod;
}
}
void SkeletonModificationStack3D::set_modification_count(int p_count) {
ERR_FAIL_COND_MSG(p_count < 0, "Modification count cannot be less than zero.");
modifications.resize(p_count);
notify_property_list_changed();
}
int SkeletonModificationStack3D::get_modification_count() const {
return modifications.size();
}
void SkeletonModificationStack3D::set_skeleton(Skeleton3D *p_skeleton) {
skeleton = p_skeleton;
}
Skeleton3D *SkeletonModificationStack3D::get_skeleton() const {
return skeleton;
}
bool SkeletonModificationStack3D::get_is_setup() const {
return is_setup;
}
void SkeletonModificationStack3D::set_enabled(bool p_enabled) {
enabled = p_enabled;
if (!enabled && is_setup && skeleton != nullptr) {
skeleton->clear_bones_local_pose_override();
}
}
bool SkeletonModificationStack3D::get_enabled() const {
return enabled;
}
void SkeletonModificationStack3D::set_strength(real_t p_strength) {
ERR_FAIL_COND_MSG(p_strength < 0, "Strength cannot be less than zero!");
ERR_FAIL_COND_MSG(p_strength > 1, "Strength cannot be more than one!");
strength = p_strength;
}
real_t SkeletonModificationStack3D::get_strength() const {
return strength;
}
void SkeletonModificationStack3D::_bind_methods() {
ClassDB::bind_method(D_METHOD("setup"), &SkeletonModificationStack3D::setup);
ClassDB::bind_method(D_METHOD("execute", "delta", "execution_mode"), &SkeletonModificationStack3D::execute);
ClassDB::bind_method(D_METHOD("enable_all_modifications", "enabled"), &SkeletonModificationStack3D::enable_all_modifications);
ClassDB::bind_method(D_METHOD("get_modification", "mod_idx"), &SkeletonModificationStack3D::get_modification);
ClassDB::bind_method(D_METHOD("add_modification", "modification"), &SkeletonModificationStack3D::add_modification);
ClassDB::bind_method(D_METHOD("delete_modification", "mod_idx"), &SkeletonModificationStack3D::delete_modification);
ClassDB::bind_method(D_METHOD("set_modification", "mod_idx", "modification"), &SkeletonModificationStack3D::set_modification);
ClassDB::bind_method(D_METHOD("set_modification_count", "count"), &SkeletonModificationStack3D::set_modification_count);
ClassDB::bind_method(D_METHOD("get_modification_count"), &SkeletonModificationStack3D::get_modification_count);
ClassDB::bind_method(D_METHOD("get_is_setup"), &SkeletonModificationStack3D::get_is_setup);
ClassDB::bind_method(D_METHOD("set_enabled", "enabled"), &SkeletonModificationStack3D::set_enabled);
ClassDB::bind_method(D_METHOD("get_enabled"), &SkeletonModificationStack3D::get_enabled);
ClassDB::bind_method(D_METHOD("set_strength", "strength"), &SkeletonModificationStack3D::set_strength);
ClassDB::bind_method(D_METHOD("get_strength"), &SkeletonModificationStack3D::get_strength);
ClassDB::bind_method(D_METHOD("get_skeleton"), &SkeletonModificationStack3D::get_skeleton);
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "enabled"), "set_enabled", "get_enabled");
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "strength", PROPERTY_HINT_RANGE, "0, 1, 0.001"), "set_strength", "get_strength");
ADD_PROPERTY(PropertyInfo(Variant::INT, "modification_count", PROPERTY_HINT_RANGE, "0, 100, 1", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_ARRAY, "Modifications,modifications/"), "set_modification_count", "get_modification_count");
}
SkeletonModificationStack3D::SkeletonModificationStack3D() {
}

91
scene/resources/skeleton_modification_stack_3d.h
View File

@ -1,91 +0,0 @@
/**************************************************************************/
/* skeleton_modification_stack_3d.h */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/**************************************************************************/
#ifndef SKELETON_MODIFICATION_STACK_3D_H
#define SKELETON_MODIFICATION_STACK_3D_H
#include "core/templates/local_vector.h"
#include "scene/3d/skeleton_3d.h"
class Skeleton3D;
class SkeletonModification3D;
class SkeletonModificationStack3D : public Resource {
GDCLASS(SkeletonModificationStack3D, Resource);
friend class Skeleton3D;
friend class SkeletonModification3D;
protected:
static void _bind_methods();
virtual void _get_property_list(List<PropertyInfo> *p_list) const;
virtual bool _set(const StringName &p_path, const Variant &p_value);
virtual bool _get(const StringName &p_path, Variant &r_ret) const;
public:
Skeleton3D *skeleton = nullptr;
bool is_setup = false;
bool enabled = false;
real_t strength = 1.0;
enum EXECUTION_MODE {
execution_mode_process,
execution_mode_physics_process,
};
LocalVector<Ref<SkeletonModification3D>> modifications = LocalVector<Ref<SkeletonModification3D>>();
int modifications_count = 0;
virtual void setup();
virtual void execute(real_t p_delta, int p_execution_mode);
void enable_all_modifications(bool p_enable);
Ref<SkeletonModification3D> get_modification(int p_mod_idx) const;
void add_modification(Ref<SkeletonModification3D> p_mod);
void delete_modification(int p_mod_idx);
void set_modification(int p_mod_idx, Ref<SkeletonModification3D> p_mod);
void set_modification_count(int p_count);
int get_modification_count() const;
void set_skeleton(Skeleton3D *p_skeleton);
Skeleton3D *get_skeleton() const;
bool get_is_setup() const;
void set_enabled(bool p_enabled);
bool get_enabled() const;
void set_strength(real_t p_strength);
real_t get_strength() const;
SkeletonModificationStack3D();
};
#endif // SKELETON_MODIFICATION_STACK_3D_H