1 #include "ik/chain_tree.h"
2 #include "ik/effector.h"
3 #include "ik/log.h"
4 #include "ik/memory.h"
5 #include "ik/node.h"
6 #include "ik/solver.h"
7 #include "ik/solver_FABRIK.h"
8 #include "ik/solver_2bone.h"
9 #include "ik/solver_1bone.h"
10 #include "ik/solver_MSD.h"
11 #include "ik/solver_jacobian_inverse.h"
12 #include "ik/solver_jacobian_transpose.h"
13 #include <string.h>
14 #include <assert.h>
15
16 static int
17 recursively_get_all_effector_nodes(ik_node_t* node, ordered_vector_t* effector_nodes_list);
18
19 /* ------------------------------------------------------------------------- */
20 ik_solver_t*
ik_solver_create(enum solver_algorithm_e algorithm)21 ik_solver_create(enum solver_algorithm_e algorithm)
22 {
23 uintptr_t solver_size = 0;
24 int (*solver_construct)(ik_solver_t*) = NULL;
25 ik_solver_t* solver = NULL;
26
27 /*
28 * Determine the correct size and confunction, depending on the
29 * selected algorithm.
30 */
31 switch (algorithm)
32 {
33 case SOLVER_FABRIK:
34 solver_size = sizeof(fabrik_t);
35 solver_construct = solver_FABRIK_construct;
36 break;
37
38 case SOLVER_TWO_BONE:
39 solver_size = sizeof(two_bone_t);
40 solver_construct = solver_2bone_construct;
41 break;
42
43 case SOLVER_ONE_BONE:
44 solver_size = sizeof(one_bone_t);
45 solver_construct = solver_1bone_construct;
46 break;
47
48 case SOLVER_MSD:
49 solver_size = sizeof(msd_t);
50 solver_construct = solver_MSD_construct;
51 break;
52
53 /*
54 case SOLVER_JACOBIAN_INVERSE:
55 case SOLVER_JACOBIAN_TRANSPOSE:
56 break;*/
57 }
58
59 if (solver_construct == NULL)
60 {
61 ik_log_message("Unknown algorithm \"%d\" was specified", algorithm);
62 goto alloc_solver_failed;
63 }
64
65 /*
66 * Allocate the solver, initialise to 0 and initialise the base fields
67 * before calling the construct() callback for the specific solver.
68 */
69 solver = (ik_solver_t*)MALLOC(solver_size);
70 if (solver == NULL)
71 {
72 ik_log_message("Failed to allocate solver: ran out of memory");
73 goto alloc_solver_failed;
74 }
75 memset(solver, 0, solver_size);
76
77 ordered_vector_construct(&solver->effector_nodes_list, sizeof(ik_node_t*));
78 chain_tree_construct(&solver->chain_tree);
79
80 /* Now call derived construction */
81 if (solver_construct(solver) < 0)
82 goto construct_derived_solver_failed;
83
84 /* Derived destruct callback must be set */
85 if (solver->destruct == NULL)
86 {
87 ik_log_message("Derived solvers MUST implement the destruct() callback");
88 goto derived_didnt_implement_destruct;
89 }
90
91 return solver;
92
93 derived_didnt_implement_destruct :
94 construct_derived_solver_failed : FREE(solver);
95 alloc_solver_failed : return NULL;
96 }
97
98 /* ------------------------------------------------------------------------- */
99 void
ik_solver_destroy(ik_solver_t * solver)100 ik_solver_destroy(ik_solver_t* solver)
101 {
102 solver->destruct(solver);
103
104 if (solver->tree)
105 ik_node_destroy(solver->tree);
106
107 chain_tree_destruct(&solver->chain_tree);
108 ordered_vector_clear_free(&solver->effector_nodes_list);
109
110 FREE(solver);
111 }
112
113 /* ------------------------------------------------------------------------- */
114 void
ik_solver_set_tree(ik_solver_t * solver,ik_node_t * root)115 ik_solver_set_tree(ik_solver_t* solver, ik_node_t* root)
116 {
117 ik_solver_destroy_tree(solver);
118 solver->tree = root;
119 }
120
121 /* ------------------------------------------------------------------------- */
122 ik_node_t*
ik_solver_unlink_tree(ik_solver_t * solver)123 ik_solver_unlink_tree(ik_solver_t* solver)
124 {
125 ik_node_t* root = solver->tree;
126 if (root == NULL)
127 return NULL;
128 solver->tree = NULL;
129
130 /*
131 * Effectors are owned by the nodes, but we need to release references to
132 * them.
133 */
134 ordered_vector_clear(&solver->effector_nodes_list);
135
136 return root;
137 }
138
139 /* ------------------------------------------------------------------------- */
140 void
ik_solver_destroy_tree(ik_solver_t * solver)141 ik_solver_destroy_tree(ik_solver_t* solver)
142 {
143 ik_node_t* root;
144 if ((root = ik_solver_unlink_tree(solver)) == NULL)
145 return;
146 ik_node_destroy(root);
147 }
148
149 /* ------------------------------------------------------------------------- */
150 int
ik_solver_rebuild_chain_trees(ik_solver_t * solver)151 ik_solver_rebuild_chain_trees(ik_solver_t* solver)
152 {
153 /* If the solver has no tree, then there's nothing to do */
154 if (solver->tree == NULL)
155 {
156 ik_log_message("No tree to work with. Did you forget to set the tree with ik_solver_set_tree()?");
157 return -1;
158 }
159
160 /*
161 * Traverse the entire tree and generate a list of the effectors. This
162 * makes the process of building the chain list for FABRIK much easier.
163 */
164 ik_log_message("Rebuilding effector nodes list");
165 ordered_vector_clear(&solver->effector_nodes_list);
166 if (recursively_get_all_effector_nodes(solver->tree, &solver->effector_nodes_list) < 0)
167 {
168 ik_log_message("Ran out of memory while building the effector nodes list");
169 return -1;
170 }
171
172 /* now build the chain tree */
173 if (rebuild_chain_tree(solver) < 0)
174 return -1;
175
176 if (solver->post_chain_build != NULL)
177 return solver->post_chain_build(solver);
178
179 return 0;
180 }
181
182 /* ------------------------------------------------------------------------- */
183 void
ik_solver_recalculate_segment_lengths(ik_solver_t * solver)184 ik_solver_recalculate_segment_lengths(ik_solver_t* solver)
185 {
186 calculate_segment_lengths(&solver->chain_tree);
187 }
188
189 /* ------------------------------------------------------------------------- */
190 int
ik_solver_solve(ik_solver_t * solver)191 ik_solver_solve(ik_solver_t* solver)
192 {
193 return solver->solve(solver);
194 }
195
196 /* ------------------------------------------------------------------------- */
197 void
ik_solver_calculate_joint_rotations(ik_solver_t * solver)198 ik_solver_calculate_joint_rotations(ik_solver_t* solver)
199 {
200 ORDERED_VECTOR_FOR_EACH(&solver->chain_tree.islands, chain_island_t, island)
201 calculate_global_rotations(&island->root_chain);
202 ORDERED_VECTOR_END_EACH
203 }
204
205 /* ------------------------------------------------------------------------- */
206 static void
iterate_tree_recursive(ik_node_t * node,ik_solver_iterate_node_cb_func callback)207 iterate_tree_recursive(ik_node_t* node,
208 ik_solver_iterate_node_cb_func callback)
209 {
210 callback(node);
211
212 BSTV_FOR_EACH(&node->children, ik_node_t, guid, child)
213 iterate_tree_recursive(child, callback);
214 BSTV_END_EACH
215 }
216 void
ik_solver_iterate_tree(ik_solver_t * solver,ik_solver_iterate_node_cb_func callback)217 ik_solver_iterate_tree(ik_solver_t* solver,
218 ik_solver_iterate_node_cb_func callback)
219 {
220 if (solver->tree == NULL)
221 {
222 ik_log_message("Warning: Tried iterating the tree, but no tree was set");
223 return;
224 }
225
226 iterate_tree_recursive(solver->tree, callback);
227 }
228
229 /* ------------------------------------------------------------------------- */
230 static void
iterate_chain_tree_recursive(chain_t * chain,ik_solver_iterate_node_cb_func callback)231 iterate_chain_tree_recursive(chain_t* chain,
232 ik_solver_iterate_node_cb_func callback)
233 {
234 /*
235 * Iterate the chain tree breadth first. Note that we exclude the base node
236 * in each chain, because otherwise the same node would be passed to the
237 * callback multiple times. The base node is shared by the parent chain's
238 * effector as well as with other chains in the same depth.
239 */
240 int idx = ordered_vector_count(&chain->nodes);
241 assert(idx > 0); // chains must have at least 2 nodes in them
242 while (idx--)
243 {
244 callback(*(ik_node_t**)ordered_vector_get_element(&chain->nodes, idx));
245 }
246
247 ORDERED_VECTOR_FOR_EACH(&chain->children, chain_t, child)
248 iterate_chain_tree_recursive(child, callback);
249 ORDERED_VECTOR_END_EACH
250 }
ik_solver_iterate_chain_tree(ik_solver_t * solver,ik_solver_iterate_node_cb_func callback)251 void ik_solver_iterate_chain_tree(ik_solver_t* solver,
252 ik_solver_iterate_node_cb_func callback)
253 {
254 ORDERED_VECTOR_FOR_EACH(&solver->chain_tree.islands, chain_island_t, island)
255 /*
256 * The root node is excluded by the recursive function, so we must
257 * do the callback here
258 */
259 int idx = ordered_vector_count(&island->root_chain.nodes) - 1;
260 ik_node_t* root = *(ik_node_t**)ordered_vector_get_element(&island->root_chain.nodes, idx);
261 callback(root);
262
263 iterate_chain_tree_recursive(&island->root_chain, callback);
264 ORDERED_VECTOR_END_EACH
265 }
266
267 /* ------------------------------------------------------------------------- */
268 static void
reset_active_pose_recursive(ik_node_t * node)269 reset_active_pose_recursive(ik_node_t* node)
270 {
271 node->position = node->original_position;
272 node->rotation = node->original_rotation;
273
274 BSTV_FOR_EACH(&node->children, ik_node_t, guid, child)
275 reset_active_pose_recursive(child);
276 BSTV_END_EACH
277 }
278 void
ik_solver_reset_to_original_pose(ik_solver_t * solver)279 ik_solver_reset_to_original_pose(ik_solver_t* solver)
280 {
281 if (solver->tree == NULL)
282 return;
283
284 reset_active_pose_recursive(solver->tree);
285 }
286
287 /* ------------------------------------------------------------------------- */
288 static int
recursively_get_all_effector_nodes(ik_node_t * node,ordered_vector_t * effector_nodes_list)289 recursively_get_all_effector_nodes(ik_node_t* node, ordered_vector_t* effector_nodes_list)
290 {
291 if (node->effector != NULL)
292 if (ordered_vector_push(effector_nodes_list, &node) < 0)
293 return -1;
294
295 BSTV_FOR_EACH(&node->children, ik_node_t, guid, child)
296 if (recursively_get_all_effector_nodes(child, effector_nodes_list) < 0)
297 return -1;
298 BSTV_END_EACH
299
300 return 0;
301 }
302