/blender/source/blender/blenkernel/intern/armature.c

Large files files are truncated, but you can click here to view the full file

/*
 * ***** BEGIN GPL LICENSE BLOCK *****
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
 * All rights reserved.
 *
 * Contributor(s): Full recode, Ton Roosendaal, Crete 2005
 *
 * ***** END GPL LICENSE BLOCK *****
 */

/** \file blender/blenkernel/intern/armature.c
 *  \ingroup bke
 */


#include <ctype.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <stdio.h>
#include <float.h>

#include "MEM_guardedalloc.h"

#include "BLI_bpath.h"
#include "BLI_math.h"
#include "BLI_blenlib.h"
#include "BLI_utildefines.h"

#include "DNA_anim_types.h"
#include "DNA_armature_types.h"
#include "DNA_constraint_types.h"
#include "DNA_mesh_types.h"
#include "DNA_lattice_types.h"
#include "DNA_meshdata_types.h"
#include "DNA_nla_types.h"
#include "DNA_scene_types.h"
#include "DNA_object_types.h"

#include "BKE_animsys.h"
#include "BKE_armature.h"
#include "BKE_action.h"
#include "BKE_anim.h"
#include "BKE_constraint.h"
#include "BKE_curve.h"
#include "BKE_depsgraph.h"
#include "BKE_DerivedMesh.h"
#include "BKE_deform.h"
#include "BKE_displist.h"
#include "BKE_global.h"
#include "BKE_idprop.h"
#include "BKE_library.h"
#include "BKE_lattice.h"
#include "BKE_main.h"
#include "BKE_object.h"
#include "BKE_scene.h"

#include "BIK_api.h"
#include "BKE_sketch.h"

/* **************** Generic Functions, data level *************** */

bArmature *BKE_armature_add(const char *name)
{
	bArmature *arm;

	arm = BKE_libblock_alloc(&G.main->armature, ID_AR, name);
	arm->deformflag = ARM_DEF_VGROUP | ARM_DEF_ENVELOPE;
	arm->flag = ARM_COL_CUSTOM; /* custom bone-group colors */
	arm->layer = 1;
	return arm;
}

bArmature *BKE_armature_from_object(Object *ob)
{
	if (ob->type == OB_ARMATURE)
		return (bArmature *)ob->data;
	return NULL;
}

void BKE_armature_bonelist_free(ListBase *lb)
{
	Bone *bone;

	for (bone = lb->first; bone; bone = bone->next) {
		if (bone->prop) {
			IDP_FreeProperty(bone->prop);
			MEM_freeN(bone->prop);
		}
		BKE_armature_bonelist_free(&bone->childbase);
	}

	BLI_freelistN(lb);
}

void BKE_armature_free(bArmature *arm)
{
	if (arm) {
		BKE_armature_bonelist_free(&arm->bonebase);

		/* free editmode data */
		if (arm->edbo) {
			BLI_freelistN(arm->edbo);

			MEM_freeN(arm->edbo);
			arm->edbo = NULL;
		}

		/* free sketch */
		if (arm->sketch) {
			freeSketch(arm->sketch);
			arm->sketch = NULL;
		}

		/* free animation data */
		if (arm->adt) {
			BKE_free_animdata(&arm->id);
			arm->adt = NULL;
		}
	}
}

void BKE_armature_make_local(bArmature *arm)
{
	Main *bmain = G.main;
	int is_local = FALSE, is_lib = FALSE;
	Object *ob;

	if (arm->id.lib == NULL)
		return;
	if (arm->id.us == 1) {
		id_clear_lib_data(bmain, &arm->id);
		return;
	}

	for (ob = bmain->object.first; ob && ELEM(0, is_lib, is_local); ob = ob->id.next) {
		if (ob->data == arm) {
			if (ob->id.lib)
				is_lib = TRUE;
			else
				is_local = TRUE;
		}
	}

	if (is_local && is_lib == FALSE) {
		id_clear_lib_data(bmain, &arm->id);
	}
	else if (is_local && is_lib) {
		bArmature *arm_new = BKE_armature_copy(arm);
		arm_new->id.us = 0;

		/* Remap paths of new ID using old library as base. */
		BKE_id_lib_local_paths(bmain, arm->id.lib, &arm_new->id);

		for (ob = bmain->object.first; ob; ob = ob->id.next) {
			if (ob->data == arm) {
				if (ob->id.lib == NULL) {
					ob->data = arm_new;
					arm_new->id.us++;
					arm->id.us--;
				}
			}
		}
	}
}

static void copy_bonechildren(Bone *newBone, Bone *oldBone, Bone *actBone, Bone **newActBone)
{
	Bone *curBone, *newChildBone;

	if (oldBone == actBone)
		*newActBone = newBone;

	if (oldBone->prop)
		newBone->prop = IDP_CopyProperty(oldBone->prop);

	/* Copy this bone's list */
	BLI_duplicatelist(&newBone->childbase, &oldBone->childbase);

	/* For each child in the list, update it's children */
	newChildBone = newBone->childbase.first;
	for (curBone = oldBone->childbase.first; curBone; curBone = curBone->next) {
		newChildBone->parent = newBone;
		copy_bonechildren(newChildBone, curBone, actBone, newActBone);
		newChildBone = newChildBone->next;
	}
}

bArmature *BKE_armature_copy(bArmature *arm)
{
	bArmature *newArm;
	Bone *oldBone, *newBone;
	Bone *newActBone = NULL;

	newArm = BKE_libblock_copy(&arm->id);
	BLI_duplicatelist(&newArm->bonebase, &arm->bonebase);

	/* Duplicate the childrens' lists*/
	newBone = newArm->bonebase.first;
	for (oldBone = arm->bonebase.first; oldBone; oldBone = oldBone->next) {
		newBone->parent = NULL;
		copy_bonechildren(newBone, oldBone, arm->act_bone, &newActBone);
		newBone = newBone->next;
	}

	newArm->act_bone = newActBone;

	newArm->edbo = NULL;
	newArm->act_edbone = NULL;
	newArm->sketch = NULL;

	return newArm;
}

static Bone *get_named_bone_bonechildren(Bone *bone, const char *name)
{
	Bone *curBone, *rbone;

	if (!strcmp(bone->name, name))
		return bone;

	for (curBone = bone->childbase.first; curBone; curBone = curBone->next) {
		rbone = get_named_bone_bonechildren(curBone, name);
		if (rbone)
			return rbone;
	}

	return NULL;
}


/* Walk the list until the bone is found */
Bone *BKE_armature_find_bone_name(bArmature *arm, const char *name)
{
	Bone *bone = NULL, *curBone;

	if (!arm)
		return NULL;

	for (curBone = arm->bonebase.first; curBone; curBone = curBone->next) {
		bone = get_named_bone_bonechildren(curBone, name);
		if (bone)
			return bone;
	}

	return bone;
}

/* Finds the best possible extension to the name on a particular axis. (For renaming, check for
 * unique names afterwards) strip_number: removes number extensions  (TODO: not used)
 * axis: the axis to name on
 * head/tail: the head/tail co-ordinate of the bone on the specified axis */
int bone_autoside_name(char name[MAXBONENAME], int UNUSED(strip_number), short axis, float head, float tail)
{
	unsigned int len;
	char basename[MAXBONENAME] = "";
	char extension[5] = "";

	len = strlen(name);
	if (len == 0)
		return 0;
	BLI_strncpy(basename, name, sizeof(basename));

	/* Figure out extension to append:
	 *	- The extension to append is based upon the axis that we are working on.
	 *	- If head happens to be on 0, then we must consider the tail position as well to decide
	 *	  which side the bone is on
	 *		-> If tail is 0, then it's bone is considered to be on axis, so no extension should be added
	 *		-> Otherwise, extension is added from perspective of object based on which side tail goes to
	 *	- If head is non-zero, extension is added from perspective of object based on side head is on
	 */
	if (axis == 2) {
		/* z-axis - vertical (top/bottom) */
		if (IS_EQ(head, 0)) {
			if (tail < 0)
				strcpy(extension, "Bot");
			else if (tail > 0)
				strcpy(extension, "Top");
		}
		else {
			if (head < 0)
				strcpy(extension, "Bot");
			else
				strcpy(extension, "Top");
		}
	}
	else if (axis == 1) {
		/* y-axis - depth (front/back) */
		if (IS_EQ(head, 0)) {
			if (tail < 0)
				strcpy(extension, "Fr");
			else if (tail > 0)
				strcpy(extension, "Bk");
		}
		else {
			if (head < 0)
				strcpy(extension, "Fr");
			else
				strcpy(extension, "Bk");
		}
	}
	else {
		/* x-axis - horizontal (left/right) */
		if (IS_EQ(head, 0)) {
			if (tail < 0)
				strcpy(extension, "R");
			else if (tail > 0)
				strcpy(extension, "L");
		}
		else {
			if (head < 0)
				strcpy(extension, "R");
			/* XXX Shouldn't this be simple else, as for z and y axes? */
			else if (head > 0)
				strcpy(extension, "L");
		}
	}

	/* Simple name truncation
	 *	- truncate if there is an extension and it wouldn't be able to fit
	 *	- otherwise, just append to end
	 */
	if (extension[0]) {
		int change = 1;

		while (change) { /* remove extensions */
			change = 0;
			if (len > 2 && basename[len - 2] == '.') {
				if (basename[len - 1] == 'L' || basename[len - 1] == 'R') { /* L R */
					basename[len - 2] = '\0';
					len -= 2;
					change = 1;
				}
			}
			else if (len > 3 && basename[len - 3] == '.') {
				if ((basename[len - 2] == 'F' && basename[len - 1] == 'r') || /* Fr */
				    (basename[len - 2] == 'B' && basename[len - 1] == 'k')) /* Bk */
				{
					basename[len - 3] = '\0';
					len -= 3;
					change = 1;
				}
			}
			else if (len > 4 && basename[len - 4] == '.') {
				if ((basename[len - 3] == 'T' && basename[len - 2] == 'o' && basename[len - 1] == 'p') || /* Top */
				    (basename[len - 3] == 'B' && basename[len - 2] == 'o' && basename[len - 1] == 't')) /* Bot */
				{
					basename[len - 4] = '\0';
					len -= 4;
					change = 1;
				}
			}
		}

		if ((MAXBONENAME - len) < strlen(extension) + 1) { /* add 1 for the '.' */
			strncpy(name, basename, len - strlen(extension));
		}

		BLI_snprintf(name, MAXBONENAME, "%s.%s", basename, extension);

		return 1;
	}

	else
		return 0;
}

/* ************* B-Bone support ******************* */

#define MAX_BBONE_SUBDIV    32

/* data has MAX_BBONE_SUBDIV+1 interpolated points, will become desired amount with equal distances */
static void equalize_bezier(float *data, int desired)
{
	float *fp, totdist, ddist, dist, fac1, fac2;
	float pdist[MAX_BBONE_SUBDIV + 1];
	float temp[MAX_BBONE_SUBDIV + 1][4];
	int a, nr;

	pdist[0] = 0.0f;
	for (a = 0, fp = data; a < MAX_BBONE_SUBDIV; a++, fp += 4) {
		copy_qt_qt(temp[a], fp);
		pdist[a + 1] = pdist[a] + len_v3v3(fp, fp + 4);
	}
	/* do last point */
	copy_qt_qt(temp[a], fp);
	totdist = pdist[a];

	/* go over distances and calculate new points */
	ddist = totdist / ((float)desired);
	nr = 1;
	for (a = 1, fp = data + 4; a < desired; a++, fp += 4) {
		dist = ((float)a) * ddist;

		/* we're looking for location (distance) 'dist' in the array */
		while ((dist >= pdist[nr]) && nr < MAX_BBONE_SUBDIV)
			nr++;

		fac1 = pdist[nr] - pdist[nr - 1];
		fac2 = pdist[nr] - dist;
		fac1 = fac2 / fac1;
		fac2 = 1.0f - fac1;

		fp[0] = fac1 * temp[nr - 1][0] + fac2 * temp[nr][0];
		fp[1] = fac1 * temp[nr - 1][1] + fac2 * temp[nr][1];
		fp[2] = fac1 * temp[nr - 1][2] + fac2 * temp[nr][2];
		fp[3] = fac1 * temp[nr - 1][3] + fac2 * temp[nr][3];
	}
	/* set last point, needed for orientation calculus */
	copy_qt_qt(fp, temp[MAX_BBONE_SUBDIV]);
}

/* returns pointer to static array, filled with desired amount of bone->segments elements */
/* this calculation is done  within unit bone space */
Mat4 *b_bone_spline_setup(bPoseChannel *pchan, int rest)
{
	static Mat4 bbone_array[MAX_BBONE_SUBDIV];
	static Mat4 bbone_rest_array[MAX_BBONE_SUBDIV];
	Mat4 *result_array = (rest) ? bbone_rest_array : bbone_array;
	bPoseChannel *next, *prev;
	Bone *bone = pchan->bone;
	float h1[3], h2[3], scale[3], length, hlength1, hlength2, roll1 = 0.0f, roll2;
	float mat3[3][3], imat[4][4], posemat[4][4], scalemat[4][4], iscalemat[4][4];
	float data[MAX_BBONE_SUBDIV + 1][4], *fp;
	int a, do_scale = 0;

	length = bone->length;

	if (!rest) {
		/* check if we need to take non-uniform bone scaling into account */
		scale[0] = len_v3(pchan->pose_mat[0]);
		scale[1] = len_v3(pchan->pose_mat[1]);
		scale[2] = len_v3(pchan->pose_mat[2]);

		if (fabsf(scale[0] - scale[1]) > 1e-6f || fabsf(scale[1] - scale[2]) > 1e-6f) {
			unit_m4(scalemat);
			scalemat[0][0] = scale[0];
			scalemat[1][1] = scale[1];
			scalemat[2][2] = scale[2];
			invert_m4_m4(iscalemat, scalemat);

			length *= scale[1];
			do_scale = 1;
		}
	}

	hlength1 = bone->ease1 * length * 0.390464f; /* 0.5f * sqrt(2) * kappa, the handle length for near-perfect circles */
	hlength2 = bone->ease2 * length * 0.390464f;

	/* evaluate next and prev bones */
	if (bone->flag & BONE_CONNECTED)
		prev = pchan->parent;
	else
		prev = NULL;

	next = pchan->child;

	/* find the handle points, since this is inside bone space, the
	 * first point = (0, 0, 0)
	 * last point =  (0, length, 0) */
	if (rest) {
		invert_m4_m4(imat, pchan->bone->arm_mat);
	}
	else if (do_scale) {
		copy_m4_m4(posemat, pchan->pose_mat);
		normalize_m4(posemat);
		invert_m4_m4(imat, posemat);
	}
	else
		invert_m4_m4(imat, pchan->pose_mat);

	if (prev) {
		float difmat[4][4], result[3][3], imat3[3][3];

		/* transform previous point inside this bone space */
		if (rest)
			copy_v3_v3(h1, prev->bone->arm_head);
		else
			copy_v3_v3(h1, prev->pose_head);
		mul_m4_v3(imat, h1);

		if (prev->bone->segments > 1) {
			/* if previous bone is B-bone too, use average handle direction */
			h1[1] -= length;
			roll1 = 0.0f;
		}

		normalize_v3(h1);
		mul_v3_fl(h1, -hlength1);

		if (prev->bone->segments == 1) {
			/* find the previous roll to interpolate */
			if (rest)
				mult_m4_m4m4(difmat, imat, prev->bone->arm_mat);
			else
				mult_m4_m4m4(difmat, imat, prev->pose_mat);
			copy_m3_m4(result, difmat); /* the desired rotation at beginning of next bone */

			vec_roll_to_mat3(h1, 0.0f, mat3); /* the result of vec_roll without roll */

			invert_m3_m3(imat3, mat3);
			mul_m3_m3m3(mat3, result, imat3); /* the matrix transforming vec_roll to desired roll */

			roll1 = (float)atan2(mat3[2][0], mat3[2][2]);
		}
	}
	else {
		h1[0] = 0.0f; h1[1] = hlength1; h1[2] = 0.0f;
		roll1 = 0.0f;
	}
	if (next) {
		float difmat[4][4], result[3][3], imat3[3][3];

		/* transform next point inside this bone space */
		if (rest)
			copy_v3_v3(h2, next->bone->arm_tail);
		else
			copy_v3_v3(h2, next->pose_tail);
		mul_m4_v3(imat, h2);

		/* if next bone is B-bone too, use average handle direction */
		if (next->bone->segments > 1)
			;
		else
			h2[1] -= length;
		normalize_v3(h2);

		/* find the next roll to interpolate as well */
		if (rest)
			mult_m4_m4m4(difmat, imat, next->bone->arm_mat);
		else
			mult_m4_m4m4(difmat, imat, next->pose_mat);
		copy_m3_m4(result, difmat); /* the desired rotation at beginning of next bone */

		vec_roll_to_mat3(h2, 0.0f, mat3); /* the result of vec_roll without roll */

		invert_m3_m3(imat3, mat3);
		mul_m3_m3m3(mat3, imat3, result); /* the matrix transforming vec_roll to desired roll */

		roll2 = (float)atan2(mat3[2][0], mat3[2][2]);

		/* and only now negate handle */
		mul_v3_fl(h2, -hlength2);
	}
	else {
		h2[0] = 0.0f; h2[1] = -hlength2; h2[2] = 0.0f;
		roll2 = 0.0;
	}

	/* make curve */
	if (bone->segments > MAX_BBONE_SUBDIV)
		bone->segments = MAX_BBONE_SUBDIV;

	BKE_curve_forward_diff_bezier(0.0f,  h1[0],                               h2[0],                               0.0f,   data[0],     MAX_BBONE_SUBDIV, 4 * sizeof(float));
	BKE_curve_forward_diff_bezier(0.0f,  h1[1],                               length + h2[1],                      length, data[0] + 1, MAX_BBONE_SUBDIV, 4 * sizeof(float));
	BKE_curve_forward_diff_bezier(0.0f,  h1[2],                               h2[2],                               0.0f,   data[0] + 2, MAX_BBONE_SUBDIV, 4 * sizeof(float));
	BKE_curve_forward_diff_bezier(roll1, roll1 + 0.390464f * (roll2 - roll1), roll2 - 0.390464f * (roll2 - roll1), roll2,  data[0] + 3, MAX_BBONE_SUBDIV, 4 * sizeof(float));

	equalize_bezier(data[0], bone->segments); /* note: does stride 4! */

	/* make transformation matrices for the segments for drawing */
	for (a = 0, fp = data[0]; a < bone->segments; a++, fp += 4) {
		sub_v3_v3v3(h1, fp + 4, fp);
		vec_roll_to_mat3(h1, fp[3], mat3); /* fp[3] is roll */

		copy_m4_m3(result_array[a].mat, mat3);
		copy_v3_v3(result_array[a].mat[3], fp);

		if (do_scale) {
			/* correct for scaling when this matrix is used in scaled space */
			mul_serie_m4(result_array[a].mat, iscalemat, result_array[a].mat, scalemat, NULL, NULL, NULL, NULL, NULL);
		}
	}

	return result_array;
}

/* ************ Armature Deform ******************* */

typedef struct bPoseChanDeform {
	Mat4     *b_bone_mats;
	DualQuat *dual_quat;
	DualQuat *b_bone_dual_quats;
} bPoseChanDeform;

static void pchan_b_bone_defmats(bPoseChannel *pchan, bPoseChanDeform *pdef_info, int use_quaternion)
{
	Bone *bone = pchan->bone;
	Mat4 *b_bone = b_bone_spline_setup(pchan, 0);
	Mat4 *b_bone_rest = b_bone_spline_setup(pchan, 1);
	Mat4 *b_bone_mats;
	DualQuat *b_bone_dual_quats = NULL;
	float tmat[4][4] = MAT4_UNITY;
	int a;

	/* allocate b_bone matrices and dual quats */
	b_bone_mats = MEM_mallocN((1 + bone->segments) * sizeof(Mat4), "BBone defmats");
	pdef_info->b_bone_mats = b_bone_mats;

	if (use_quaternion) {
		b_bone_dual_quats = MEM_mallocN((bone->segments) * sizeof(DualQuat), "BBone dqs");
		pdef_info->b_bone_dual_quats = b_bone_dual_quats;
	}

	/* first matrix is the inverse arm_mat, to bring points in local bone space
	 * for finding out which segment it belongs to */
	invert_m4_m4(b_bone_mats[0].mat, bone->arm_mat);

	/* then we make the b_bone_mats:
	 * - first transform to local bone space
	 * - translate over the curve to the bbone mat space
	 * - transform with b_bone matrix
	 * - transform back into global space */

	for (a = 0; a < bone->segments; a++) {
		invert_m4_m4(tmat, b_bone_rest[a].mat);

		mul_serie_m4(b_bone_mats[a + 1].mat, pchan->chan_mat, bone->arm_mat, b_bone[a].mat, tmat, b_bone_mats[0].mat,
		             NULL, NULL, NULL);

		if (use_quaternion)
			mat4_to_dquat(&b_bone_dual_quats[a], bone->arm_mat, b_bone_mats[a + 1].mat);
	}
}

static void b_bone_deform(bPoseChanDeform *pdef_info, Bone *bone, float co[3], DualQuat *dq, float defmat[][3])
{
	Mat4 *b_bone = pdef_info->b_bone_mats;
	float (*mat)[4] = b_bone[0].mat;
	float segment, y;
	int a;

	/* need to transform co back to bonespace, only need y */
	y = mat[0][1] * co[0] + mat[1][1] * co[1] + mat[2][1] * co[2] + mat[3][1];

	/* now calculate which of the b_bones are deforming this */
	segment = bone->length / ((float)bone->segments);
	a = (int)(y / segment);

	/* note; by clamping it extends deform at endpoints, goes best with
	 * straight joints in restpos. */
	CLAMP(a, 0, bone->segments - 1);

	if (dq) {
		copy_dq_dq(dq, &(pdef_info->b_bone_dual_quats)[a]);
	}
	else {
		mul_m4_v3(b_bone[a + 1].mat, co);

		if (defmat) {
			copy_m3_m4(defmat, b_bone[a + 1].mat);
		}
	}
}

/* using vec with dist to bone b1 - b2 */
float distfactor_to_bone(const float vec[3], const float b1[3], const float b2[3], float rad1, float rad2, float rdist)
{
	float dist = 0.0f;
	float bdelta[3];
	float pdelta[3];
	float hsqr, a, l, rad;

	sub_v3_v3v3(bdelta, b2, b1);
	l = normalize_v3(bdelta);

	sub_v3_v3v3(pdelta, vec, b1);

	a = dot_v3v3(bdelta, pdelta);
	hsqr = dot_v3v3(pdelta, pdelta);

	if (a < 0.0f) {
		/* If we're past the end of the bone, do a spherical field attenuation thing */
		dist = len_squared_v3v3(b1, vec);
		rad = rad1;
	}
	else if (a > l) {
		/* If we're past the end of the bone, do a spherical field attenuation thing */
		dist = len_squared_v3v3(b2, vec);
		rad = rad2;
	}
	else {
		dist = (hsqr - (a * a));

		if (l != 0.0f) {
			rad = a / l;
			rad = rad * rad2 + (1.0f - rad) * rad1;
		}
		else
			rad = rad1;
	}

	a = rad * rad;
	if (dist < a)
		return 1.0f;
	else {
		l = rad + rdist;
		l *= l;
		if (rdist == 0.0f || dist >= l)
			return 0.0f;
		else {
			a = sqrtf(dist) - rad;
			return 1.0f - (a * a) / (rdist * rdist);
		}
	}
}

static void pchan_deform_mat_add(bPoseChannel *pchan, float weight, float bbonemat[][3], float mat[][3])
{
	float wmat[3][3];

	if (pchan->bone->segments > 1)
		copy_m3_m3(wmat, bbonemat);
	else
		copy_m3_m4(wmat, pchan->chan_mat);

	mul_m3_fl(wmat, weight);
	add_m3_m3m3(mat, mat, wmat);
}

static float dist_bone_deform(bPoseChannel *pchan, bPoseChanDeform *pdef_info, float vec[3], DualQuat *dq,
                              float mat[][3], const float co[3])
{
	Bone *bone = pchan->bone;
	float fac, contrib = 0.0;
	float cop[3], bbonemat[3][3];
	DualQuat bbonedq;

	if (bone == NULL)
		return 0.0f;

	copy_v3_v3(cop, co);

	fac = distfactor_to_bone(cop, bone->arm_head, bone->arm_tail, bone->rad_head, bone->rad_tail, bone->dist);

	if (fac > 0.0f) {
		fac *= bone->weight;
		contrib = fac;
		if (contrib > 0.0f) {
			if (vec) {
				if (bone->segments > 1)
					/* applies on cop and bbonemat */
					b_bone_deform(pdef_info, bone, cop, NULL, (mat) ? bbonemat : NULL);
				else
					mul_m4_v3(pchan->chan_mat, cop);

				/* Make this a delta from the base position */
				sub_v3_v3(cop, co);
				madd_v3_v3fl(vec, cop, fac);

				if (mat)
					pchan_deform_mat_add(pchan, fac, bbonemat, mat);
			}
			else {
				if (bone->segments > 1) {
					b_bone_deform(pdef_info, bone, cop, &bbonedq, NULL);
					add_weighted_dq_dq(dq, &bbonedq, fac);
				}
				else
					add_weighted_dq_dq(dq, pdef_info->dual_quat, fac);
			}
		}
	}

	return contrib;
}

static void pchan_bone_deform(bPoseChannel *pchan, bPoseChanDeform *pdef_info, float weight, float vec[3], DualQuat *dq,
                              float mat[][3], const float co[3], float *contrib)
{
	float cop[3], bbonemat[3][3];
	DualQuat bbonedq;

	if (!weight)
		return;

	copy_v3_v3(cop, co);

	if (vec) {
		if (pchan->bone->segments > 1)
			/* applies on cop and bbonemat */
			b_bone_deform(pdef_info, pchan->bone, cop, NULL, (mat) ? bbonemat : NULL);
		else
			mul_m4_v3(pchan->chan_mat, cop);

		vec[0] += (cop[0] - co[0]) * weight;
		vec[1] += (cop[1] - co[1]) * weight;
		vec[2] += (cop[2] - co[2]) * weight;

		if (mat)
			pchan_deform_mat_add(pchan, weight, bbonemat, mat);
	}
	else {
		if (pchan->bone->segments > 1) {
			b_bone_deform(pdef_info, pchan->bone, cop, &bbonedq, NULL);
			add_weighted_dq_dq(dq, &bbonedq, weight);
		}
		else
			add_weighted_dq_dq(dq, pdef_info->dual_quat, weight);
	}

	(*contrib) += weight;
}

void armature_deform_verts(Object *armOb, Object *target, DerivedMesh *dm, float (*vertexCos)[3],
                           float (*defMats)[3][3], int numVerts, int deformflag,
                           float (*prevCos)[3], const char *defgrp_name)
{
	bPoseChanDeform *pdef_info_array;
	bPoseChanDeform *pdef_info = NULL;
	bArmature *arm = armOb->data;
	bPoseChannel *pchan, **defnrToPC = NULL;
	int *defnrToPCIndex = NULL;
	MDeformVert *dverts = NULL;
	bDeformGroup *dg;
	DualQuat *dualquats = NULL;
	float obinv[4][4], premat[4][4], postmat[4][4];
	const short use_envelope = deformflag & ARM_DEF_ENVELOPE;
	const short use_quaternion = deformflag & ARM_DEF_QUATERNION;
	const short invert_vgroup = deformflag & ARM_DEF_INVERT_VGROUP;
	int defbase_tot = 0;       /* safety for vertexgroup index overflow */
	int i, target_totvert = 0; /* safety for vertexgroup overflow */
	int use_dverts = FALSE;
	int armature_def_nr;
	int totchan;

	if (arm->edbo) return;

	invert_m4_m4(obinv, target->obmat);
	copy_m4_m4(premat, target->obmat);
	mult_m4_m4m4(postmat, obinv, armOb->obmat);
	invert_m4_m4(premat, postmat);

	/* bone defmats are already in the channels, chan_mat */

	/* initialize B_bone matrices and dual quaternions */
	totchan = BLI_countlist(&armOb->pose->chanbase);

	if (use_quaternion) {
		dualquats = MEM_callocN(sizeof(DualQuat) * totchan, "dualquats");
	}

	pdef_info_array = MEM_callocN(sizeof(bPoseChanDeform) * totchan, "bPoseChanDeform");

	totchan = 0;
	pdef_info = pdef_info_array;
	for (pchan = armOb->pose->chanbase.first; pchan; pchan = pchan->next, pdef_info++) {
		if (!(pchan->bone->flag & BONE_NO_DEFORM)) {
			if (pchan->bone->segments > 1)
				pchan_b_bone_defmats(pchan, pdef_info, use_quaternion);

			if (use_quaternion) {
				pdef_info->dual_quat = &dualquats[totchan++];
				mat4_to_dquat(pdef_info->dual_quat, pchan->bone->arm_mat, pchan->chan_mat);
			}
		}
	}

	/* get the def_nr for the overall armature vertex group if present */
	armature_def_nr = defgroup_name_index(target, defgrp_name);

	if (ELEM(target->type, OB_MESH, OB_LATTICE)) {
		defbase_tot = BLI_countlist(&target->defbase);

		if (target->type == OB_MESH) {
			Mesh *me = target->data;
			dverts = me->dvert;
			if (dverts)
				target_totvert = me->totvert;
		}
		else {
			Lattice *lt = target->data;
			dverts = lt->dvert;
			if (dverts)
				target_totvert = lt->pntsu * lt->pntsv * lt->pntsw;
		}
	}

	/* get a vertex-deform-index to posechannel array */
	if (deformflag & ARM_DEF_VGROUP) {
		if (ELEM(target->type, OB_MESH, OB_LATTICE)) {
			/* if we have a DerivedMesh, only use dverts if it has them */
			if (dm) {
				use_dverts = (dm->getVertData(dm, 0, CD_MDEFORMVERT) != NULL);
			}
			else if (dverts) {
				use_dverts = TRUE;
			}

			if (use_dverts) {
				defnrToPC = MEM_callocN(sizeof(*defnrToPC) * defbase_tot, "defnrToBone");
				defnrToPCIndex = MEM_callocN(sizeof(*defnrToPCIndex) * defbase_tot, "defnrToIndex");
				for (i = 0, dg = target->defbase.first; dg; i++, dg = dg->next) {
					defnrToPC[i] = BKE_pose_channel_find_name(armOb->pose, dg->name);
					/* exclude non-deforming bones */
					if (defnrToPC[i]) {
						if (defnrToPC[i]->bone->flag & BONE_NO_DEFORM) {
							defnrToPC[i] = NULL;
						}
						else {
							defnrToPCIndex[i] = BLI_findindex(&armOb->pose->chanbase, defnrToPC[i]);
						}
					}
				}
			}
		}
	}

	for (i = 0; i < numVerts; i++) {
		MDeformVert *dvert;
		DualQuat sumdq, *dq = NULL;
		float *co, dco[3];
		float sumvec[3], summat[3][3];
		float *vec = NULL, (*smat)[3] = NULL;
		float contrib = 0.0f;
		float armature_weight = 1.0f; /* default to 1 if no overall def group */
		float prevco_weight = 1.0f;   /* weight for optional cached vertexcos */

		if (use_quaternion) {
			memset(&sumdq, 0, sizeof(DualQuat));
			dq = &sumdq;
		}
		else {
			sumvec[0] = sumvec[1] = sumvec[2] = 0.0f;
			vec = sumvec;

			if (defMats) {
				zero_m3(summat);
				smat = summat;
			}
		}

		if (use_dverts || armature_def_nr >= 0) {
			if (dm)
				dvert = dm->getVertData(dm, i, CD_MDEFORMVERT);
			else if (dverts && i < target_totvert)
				dvert = dverts + i;
			else
				dvert = NULL;
		}
		else
			dvert = NULL;

		if (armature_def_nr >= 0 && dvert) {
			armature_weight = defvert_find_weight(dvert, armature_def_nr);

			if (invert_vgroup)
				armature_weight = 1.0f - armature_weight;

			/* hackish: the blending factor can be used for blending with prevCos too */
			if (prevCos) {
				prevco_weight = armature_weight;
				armature_weight = 1.0f;
			}
		}

		/* check if there's any  point in calculating for this vert */
		if (armature_weight == 0.0f)
			continue;

		/* get the coord we work on */
		co = prevCos ? prevCos[i] : vertexCos[i];

		/* Apply the object's matrix */
		mul_m4_v3(premat, co);

		if (use_dverts && dvert && dvert->totweight) { /* use weight groups ? */
			MDeformWeight *dw = dvert->dw;
			int deformed = 0;
			unsigned int j;

			for (j = dvert->totweight; j != 0; j--, dw++) {
				const int index = dw->def_nr;
				if (index >= 0 && index < defbase_tot && (pchan = defnrToPC[index])) {
					float weight = dw->weight;
					Bone *bone = pchan->bone;
					pdef_info = pdef_info_array + defnrToPCIndex[index];

					deformed = 1;

					if (bone && bone->flag & BONE_MULT_VG_ENV) {
						weight *= distfactor_to_bone(co, bone->arm_head, bone->arm_tail,
						                             bone->rad_head, bone->rad_tail, bone->dist);
					}
					pchan_bone_deform(pchan, pdef_info, weight, vec, dq, smat, co, &contrib);
				}
			}
			/* if there are vertexgroups but not groups with bones
			 * (like for softbody groups) */
			if (deformed == 0 && use_envelope) {
				pdef_info = pdef_info_array;
				for (pchan = armOb->pose->chanbase.first; pchan; pchan = pchan->next, pdef_info++) {
					if (!(pchan->bone->flag & BONE_NO_DEFORM))
						contrib += dist_bone_deform(pchan, pdef_info, vec, dq, smat, co);
				}
			}
		}
		else if (use_envelope) {
			pdef_info = pdef_info_array;
			for (pchan = armOb->pose->chanbase.first; pchan; pchan = pchan->next, pdef_info++) {
				if (!(pchan->bone->flag & BONE_NO_DEFORM))
					contrib += dist_bone_deform(pchan, pdef_info, vec, dq, smat, co);
			}
		}

		/* actually should be EPSILON? weight values and contrib can be like 10e-39 small */
		if (contrib > 0.0001f) {
			if (use_quaternion) {
				normalize_dq(dq, contrib);

				if (armature_weight != 1.0f) {
					copy_v3_v3(dco, co);
					mul_v3m3_dq(dco, (defMats) ? summat : NULL, dq);
					sub_v3_v3(dco, co);
					mul_v3_fl(dco, armature_weight);
					add_v3_v3(co, dco);
				}
				else
					mul_v3m3_dq(co, (defMats) ? summat : NULL, dq);

				smat = summat;
			}
			else {
				mul_v3_fl(vec, armature_weight / contrib);
				add_v3_v3v3(co, vec, co);
			}

			if (defMats) {
				float pre[3][3], post[3][3], tmpmat[3][3];

				copy_m3_m4(pre, premat);
				copy_m3_m4(post, postmat);
				copy_m3_m3(tmpmat, defMats[i]);

				if (!use_quaternion) /* quaternion already is scale corrected */
					mul_m3_fl(smat, armature_weight / contrib);

				mul_serie_m3(defMats[i], tmpmat, pre, smat, post, NULL, NULL, NULL, NULL);
			}
		}

		/* always, check above code */
		mul_m4_v3(postmat, co);

		/* interpolate with previous modifier position using weight group */
		if (prevCos) {
			float mw = 1.0f - prevco_weight;
			vertexCos[i][0] = prevco_weight * vertexCos[i][0] + mw * co[0];
			vertexCos[i][1] = prevco_weight * vertexCos[i][1] + mw * co[1];
			vertexCos[i][2] = prevco_weight * vertexCos[i][2] + mw * co[2];
		}
	}

	if (dualquats)
		MEM_freeN(dualquats);
	if (defnrToPC)
		MEM_freeN(defnrToPC);
	if (defnrToPCIndex)
		MEM_freeN(defnrToPCIndex);

	/* free B_bone matrices */
	pdef_info = pdef_info_array;
	for (pchan = armOb->pose->chanbase.first; pchan; pchan = pchan->next, pdef_info++) {
		if (pdef_info->b_bone_mats)
			MEM_freeN(pdef_info->b_bone_mats);
		if (pdef_info->b_bone_dual_quats)
			MEM_freeN(pdef_info->b_bone_dual_quats);
	}

	MEM_freeN(pdef_info_array);
}

/* ************ END Armature Deform ******************* */

void get_objectspace_bone_matrix(struct Bone *bone, float M_accumulatedMatrix[][4], int UNUSED(root),
                                 int UNUSED(posed))
{
	copy_m4_m4(M_accumulatedMatrix, bone->arm_mat);
}

/* **************** Space to Space API ****************** */

/* Convert World-Space Matrix to Pose-Space Matrix */
void BKE_armature_mat_world_to_pose(Object *ob, float inmat[][4], float outmat[][4])
{
	float obmat[4][4];

	/* prevent crashes */
	if (ob == NULL)
		return;

	/* get inverse of (armature) object's matrix  */
	invert_m4_m4(obmat, ob->obmat);

	/* multiply given matrix by object's-inverse to find pose-space matrix */
	mult_m4_m4m4(outmat, inmat, obmat);
}

/* Convert World-Space Location to Pose-Space Location
 * NOTE: this cannot be used to convert to pose-space location of the supplied
 *       pose-channel into its local space (i.e. 'visual'-keyframing) */
void BKE_armature_loc_world_to_pose(Object *ob, const float inloc[3], float outloc[3])
{
	float xLocMat[4][4] = MAT4_UNITY;
	float nLocMat[4][4];

	/* build matrix for location */
	copy_v3_v3(xLocMat[3], inloc);

	/* get bone-space cursor matrix and extract location */
	BKE_armature_mat_world_to_pose(ob, xLocMat, nLocMat);
	copy_v3_v3(outloc, nLocMat[3]);
}

/* Simple helper, computes the offset bone matrix.
 *     offs_bone = yoffs(b-1) + root(b) + bonemat(b).
 * Not exported, as it is only used in this file currently... */
static void get_offset_bone_mat(Bone *bone, float offs_bone[][4])
{
	if (!bone->parent)
		return;

	/* Bone transform itself. */
	copy_m4_m3(offs_bone, bone->bone_mat);

	/* The bone's root offset (is in the parent's coordinate system). */
	copy_v3_v3(offs_bone[3], bone->head);

	/* Get the length translation of parent (length along y axis). */
	offs_bone[3][1] += bone->parent->length;
}

/* Construct the matrices (rot/scale and loc) to apply the PoseChannels into the armature (object) space.
 * I.e. (roughly) the "pose_mat(b-1) * yoffs(b-1) * d_root(b) * bone_mat(b)" in the
 *     pose_mat(b)= pose_mat(b-1) * yoffs(b-1) * d_root(b) * bone_mat(b) * chan_mat(b)
 * ...function.
 *
 * This allows to get the transformations of a bone in its object space, *before* constraints (and IK)
 * get applied (used by pose evaluation code).
 * And reverse: to find pchan transformations needed to place a bone at a given loc/rot/scale
 * in object space (used by interactive transform, and snapping code).
 *
 * Note that, with the HINGE/NO_SCALE/NO_LOCAL_LOCATION options, the location matrix
 * will differ from the rotation/scale matrix...
 *
 * NOTE: This cannot be used to convert to pose-space transforms of the supplied
 *       pose-channel into its local space (i.e. 'visual'-keyframing).
 *       (note: I don't understand that, so I keep it :p --mont29).
 */
void BKE_pchan_to_pose_mat(bPoseChannel *pchan, float rotscale_mat[][4], float loc_mat[][4])
{
	Bone *bone, *parbone;
	bPoseChannel *parchan;

	/* set up variables for quicker access below */
	bone = pchan->bone;
	parbone = bone->parent;
	parchan = pchan->parent;

	if (parchan) {
		float offs_bone[4][4];
		/* yoffs(b-1) + root(b) + bonemat(b). */
		get_offset_bone_mat(bone, offs_bone);

		/* Compose the rotscale matrix for this bone. */
		if ((bone->flag & BONE_HINGE) && (bone->flag & BONE_NO_SCALE)) {
			/* Parent rest rotation and scale. */
			mult_m4_m4m4(rotscale_mat, parbone->arm_mat, offs_bone);
		}
		else if (bone->flag & BONE_HINGE) {
			/* Parent rest rotation and pose scale. */
			float tmat[4][4], tscale[3];

			/* Extract the scale of the parent pose matrix. */
			mat4_to_size(tscale, parchan->pose_mat);
			size_to_mat4(tmat, tscale);

			/* Applies the parent pose scale to the rest matrix. */
			mult_m4_m4m4(tmat, tmat, parbone->arm_mat);

			mult_m4_m4m4(rotscale_mat, tmat, offs_bone);
		}
		else if (bone->flag & BONE_NO_SCALE) {
			/* Parent pose rotation and rest scale (i.e. no scaling). */
			float tmat[4][4];
			copy_m4_m4(tmat, parchan->pose_mat);
			normalize_m4(tmat);
			mult_m4_m4m4(rotscale_mat, tmat, offs_bone);
		}
		else
			mult_m4_m4m4(rotscale_mat, parchan->pose_mat, offs_bone);

		/* Compose the loc matrix for this bone. */
		/* NOTE: That version does not modify bone's loc when HINGE/NO_SCALE options are set. */

		/* In this case, use the object's space *orientation*. */
		if (bone->flag & BONE_NO_LOCAL_LOCATION) {
			/* XXX I'm sure that code can be simplified! */
			float bone_loc[4][4], bone_rotscale[3][3], tmat4[4][4], tmat3[3][3];
			unit_m4(bone_loc);
			unit_m4(loc_mat);
			unit_m4(tmat4);

			mul_v3_m4v3(bone_loc[3], parchan->pose_mat, offs_bone[3]);

			unit_m3(bone_rotscale);
			copy_m3_m4(tmat3, parchan->pose_mat);
			mul_m3_m3m3(bone_rotscale, tmat3, bone_rotscale);

			copy_m4_m3(tmat4, bone_rotscale);
			mult_m4_m4m4(loc_mat, bone_loc, tmat4);
		}
		/* Those flags do not affect position, use plain parent transform space! */
		else if (bone->flag & (BONE_HINGE | BONE_NO_SCALE)) {
			mult_m4_m4m4(loc_mat, parchan->pose_mat, offs_bone);
		}
		/* Else (i.e. default, usual case), just use the same matrix for rotation/scaling, and location. */
		else
			copy_m4_m4(loc_mat, rotscale_mat);
	}
	/* Root bones. */
	else {
		/* Rotation/scaling. */
		copy_m4_m4(rotscale_mat, pchan->bone->arm_mat);
		/* Translation. */
		if (pchan->bone->flag & BONE_NO_LOCAL_LOCATION) {
			/* Translation of arm_mat, without the rotation. */
			unit_m4(loc_mat);
			copy_v3_v3(loc_mat[3], pchan->bone->arm_mat[3]);
		}
		else
			copy_m4_m4(loc_mat, rotscale_mat);
	}
}

/* Convert Pose-Space Matrix to Bone-Space Matrix.
 * NOTE: this cannot be used to convert to pose-space transforms of the supplied
 *       pose-channel into its local space (i.e. 'visual'-keyframing) */
void BKE_armature_mat_pose_to_bone(bPoseChannel *pchan, float inmat[][4], float outmat[][4])
{
	float rotscale_mat[4][4], loc_mat[4][4], inmat_[4][4];

	/* Security, this allows to call with inmat == outmat! */
	copy_m4_m4(inmat_, inmat);

	BKE_pchan_to_pose_mat(pchan, rotscale_mat, loc_mat);
	invert_m4(rotscale_mat);
	invert_m4(loc_mat);

	mult_m4_m4m4(outmat, rotscale_mat, inmat_);
	mul_v3_m4v3(outmat[3], loc_mat, inmat_[3]);
}

/* Convert Bone-Space Matrix to Pose-Space Matrix. */
void BKE_armature_mat_bone_to_pose(bPoseChannel *pchan, float inmat[][4], float outmat[][4])
{
	float rotscale_mat[4][4], loc_mat[4][4], inmat_[4][4];

	/* Security, this allows to call with inmat == outmat! */
	copy_m4_m4(inmat_, inmat);

	BKE_pchan_to_pose_mat(pchan, rotscale_mat, loc_mat);

	mult_m4_m4m4(outmat, rotscale_mat, inmat_);
	mul_v3_m4v3(outmat[3], loc_mat, inmat_[3]);
}

/* Convert Pose-Space Location to Bone-Space Location
 * NOTE: this cannot be used to convert to pose-space location of the supplied
 *       pose-channel into its local space (i.e. 'visual'-keyframing) */
void BKE_armature_loc_pose_to_bone(bPoseChannel *pchan, const float inloc[3], float outloc[3])
{
	float xLocMat[4][4] = MAT4_UNITY;
	float nLocMat[4][4];

	/* build matrix for location */
	copy_v3_v3(xLocMat[3], inloc);

	/* get bone-space cursor matrix and extract location */
	BKE_armature_mat_pose_to_bone(pchan, xLocMat, nLocMat);
	copy_v3_v3(outloc, nLocMat[3]);
}

void BKE_armature_mat_pose_to_bone_ex(Object *ob, bPoseChannel *pchan, float inmat[][4], float outmat[][4])
{
	bPoseChannel work_pchan = *pchan;

	/* recalculate pose matrix with only parent transformations,
	 * bone loc/sca/rot is ignored, scene and frame are not used. */
	BKE_pose_where_is_bone(NULL, ob, &work_pchan, 0.0f, FALSE);

	/* find the matrix, need to remove the bone transforms first so this is
	 * calculated as a matrix to set rather then a difference ontop of whats
	 * already there. */
	unit_m4(outmat);
	BKE_pchan_apply_mat4(&work_pchan, outmat, FALSE);

	BKE_armature_mat_pose_to_bone(&work_pchan, inmat, outmat);
}

/* same as BKE_object_mat3_to_rot() */
void BKE_pchan_mat3_to_rot(bPoseChannel *pchan, float mat[][3], short use_compat)
{
	switch (pchan->rotmode) {
		case ROT_MODE_QUAT:
			mat3_to_quat(pchan->quat, mat);
			break;
		case ROT_MODE_AXISANGLE:
			mat3_to_axis_angle(pchan->rotAxis, &pchan->rotAngle, mat);
			break;
		default: /* euler */
			if (use_compat)
				mat3_to_compatible_eulO(pchan->eul, pchan->eul, pchan->rotmode, mat);
			else
				mat3_to_eulO(pchan->eul, pchan->rotmode, mat);
	}
}

/* Apply a 4x4 matrix to the pose bone,
 * similar to BKE_object_apply_mat4() */
void BKE_pchan_apply_mat4(bPoseChannel *pchan, float mat[][4], short use_compat)
{
	float rot[3][3];
	mat4_to_loc_rot_size(pchan->loc, rot, pchan->size, mat);
	BKE_pchan_mat3_to_rot(pchan, rot, use_compat);
}

/* Remove rest-position effects from pose-transform for obtaining
 * 'visual' transformation of pose-channel.
 * (used by the Visual-Keyframing stuff) */
void BKE_armature_mat_pose_to_delta(float delta_mat[][4], float pose_mat[][4], float arm_mat[][4])
{
	float imat[4][4];

	invert_m4_m4(imat, arm_mat);
	mult_m4_m4m4(delta_mat, imat, pose_mat);
}

/* **************** Rotation Mode Conversions ****************************** */
/* Used for Objects and Pose Channels, since both can have multiple rotation representations */

/* Called from RNA when rotation mode changes
 * - the result should be that the rotations given in the provided pointers have had conversions
 *   applied (as appropriate), such that the rotation of the element hasn't 'visually' changed  */
void BKE_rotMode_change_values(float quat[4], float eul[3], float axis[3], float *angle, short oldMode, short newMode)
{
	/* check if any change - if so, need to convert data */
	if (newMode > 0) { /* to euler */
		if (oldMode == ROT_MODE_AXISANGLE) {
			/* axis-angle to euler */
			axis_angle_to_eulO(eul, newMode, axis, *angle);
		}
		else if (oldMode == ROT_MODE_QUAT) {
			/* quat to euler */
			normalize_qt(quat);
			quat_to_eulO(eul, newMode, quat);
		}
		/* else { no conversion needed } */
	}
	else if (newMode == ROT_MODE_QUAT) { /* to quat */
		if (oldMode == ROT_MODE_AXISANGLE) {
			/* axis angle to quat */
			axis_angle_to_quat(quat, axis, *angle);
		}
		else if (oldMode > 0) {
			/* euler to quat */
			eulO_to_quat(quat, eul, oldMode);
		}
		/* else { no conversion needed } */
	}
	else if (newMode == ROT_MODE_AXISANGLE) { /* to axis-angle */
		if (oldMode > 0) {
			/* euler to axis angle */
			eulO_to_axis_angle(axis, angle, eul, oldMode);
		}
		else if (oldMode == ROT_MODE_QUAT) {
			/* quat to axis angle */
			normalize_qt(quat);
			quat_to_axis_angle(axis, angle, quat);
		}

		/* when converting to axis-angle, we need a special exception for the case when there is no axis */
		if (IS_EQF(axis[0], axis[1]) && IS_EQF(axis[1], axis[2])) {
			/* for now, rotate around y-axis then (so that it simply becomes the roll) */
			axis[1] = 1.0f;
		}
	}
}

/* **************** The new & simple (but OK!) armature evaluation ********* */

/* ****************** And how it works! ****************************************
 *
 * This is the bone transformation trick; they're hierarchical so each bone(b)
 * is in the coord system of bone(b-1):
 *
 * arm_mat(b)= arm_mat(b-1) * yoffs(b-1) * d_root(b) * bone_mat(b)
 *
 * -> yoffs is just the y axis translation in parent's coord system
 * -> d_root is the translation of the bone root, also in parent's coord system
 *
 * pose_mat(b)= pose_mat(b-1) * yoffs(b-1) * d_root(b) * bone_mat(b) * chan_mat(b)
 *
 * we then - in init deform - store the deform in chan_mat, such that:
 *
 * pose_mat(b)= arm_mat(b) * chan_mat(b)
 *
 * *************************************************************************** */
/* Computes vector and roll based on a rotation.
 * "mat" must contain only a rotation, and no scaling. */
void mat3_to_vec_roll(float mat[][3], float vec[3], float *roll)
{
	if (vec)
		copy_v3_v3(vec, mat[1]);

	if (roll) {
		float vecmat[3][3], vecmatinv[3][3], rollmat[3][3];

		vec_roll_to_mat3(mat[1], 0.0f, vecmat);
		invert_m3_m3(vecmatinv, vecmat);
		mul_m3_m3m3(rollmat, vecmatinv, mat);

		*roll = (float)atan2(rollmat[2][0], rollmat[2][2]);
	}
}

/* Calculates the rest matrix of a bone based
 * On its vector and a roll around that vector */
void vec_roll_to_mat3(const float vec[3], const float roll, float mat[][3])
{
	float nor[3], axis[3], target[3] = {0, 1, 0};
	float theta;
	float rMatrix[3][3], bMatrix[3][3];

	normalize_v3_v3(nor, vec);

	/* Find Axis & Amount for bone matrix */
	cross_v3_v3v3(axis, target, nor);

	/* was 0.0000000000001, caused bug [#23954], smaller values give unstable
	 * roll when toggling editmode.
	 *
	 * was 0.00001, causes bug [#27675], with 0.00000495,
	 * so a value inbetween these is needed.
	 *
	 * was 0.000001, causes bug [#30438] (which is same as [#27675, imho).
	 * Reseting it to org value seems to cause no more [#23954]...
	 *
	 * was 0.0000000000001, caused bug [#31333], smaller values give unstable
	 * roll when toggling editmode again...
	 * No good value here, trying 0.000000001 as best compromize. :/
	 */
	if (dot_v3v3(axis, axis) > 1.0e-9f) {
		/* if nor is *not* a multiple of target ... */
		normalize_v3(axis);

		theta = angle_normalized_v3v3(target, nor);

		/* Make Bone matrix*/
		vec_rot_to_mat3(bMatrix, axis, theta);
	}
	else {
		/* if nor is a multiple of target ... */
		float updown;

		/* point same direction, or opposite? */
		updown = (dot_v3v3(target, nor) > 0) ? 1.0f : -1.0f;

		/* I think this should work... */
		bMatrix[0][0] = updown; bMatrix[0][1] = 0.0;    bMatrix[0][2] = 0.0;
		bMatrix[1][0] = 0.0;    bMatrix[1][1] = updown; bMatrix[1][2] = 0.0;
		bMatrix[2][0] = 0.0;    bMatrix[2][1] = 0.0;    bMatrix[2][2] = 1.0;
	}

	/* Make Roll matrix */
	vec_rot_to_mat3(rMatrix, nor, roll);

	/* Combine and output result */
	mul_m3_m3m3(mat, rMatrix, bMatrix);
}


/* recursive part, calculates restposition of entire tree of children */
/* used by exiting editmode too */
void BKE_armature_where_is_bone(Bone *bone, Bone *prevbone)
{
	float vec[3];

	/* Bone Space */
	sub_v3_v3v3(vec, bone->tail, bone->head);
	vec_roll_to_mat3(vec, bone->roll, bone->bone_mat);

	bone->length = len_v3v3(bone->head, bone->tail);

	/* this is called on old file reading too... */
	if (bone->xwidth == 0.0f) {
		bone->xwidth = 0.1f;
		bone->zwidth = 0.1f;
		bone->segments = 1;
	}

	if (prevbone) {
		float offs_bone[4][4];
		/* yoffs(b-1) + root(b) + bonemat(b) */
		get_offset_bone_mat(bone, offs_bone);

		/* Compose the matrix for this bone  */
		mult_m4_m4m4(bone->arm_mat, prevbone->arm_mat, offs_bone);
	}
	else {
		copy_m4_m3(bone->arm_mat, bone->bone_mat);
		copy_v3_v3(bone->arm_mat[3], bone->head);
	}

	/* and the kiddies */
	prevbone = bone;
	for (bone = bone->childbase.first; bone; bone = bone->next) {
		BKE_armature_where_is_bone(bone, prevbone);
	}
}

/* updates vectors and matrices on rest-position level, only needed
 * after editing armature itself, now only on reading file */
void BKE_armature_where_is(bArmature *arm)
{
	Bone *bone;

	/* hierarchical from root to children */
	for (bone = arm->bonebase.first; bone; bone = bone->next) {
		BKE_armature_where_is_bone(bone, NULL);
	}
}

/* if bone layer is protected, copy the data from from->pose
 * when used with linked libraries this copies from the linked pose into the local pose */
static void pose_proxy_synchronize(Object *ob, Object *from, int layer_protected)
{
	bPose *pose = ob->pose, *frompose = from->pose;
	bPoseChannel *pchan, *pchanp, pchanw;
	bConstraint *con;
	int error = 0;

	if (frompose == NULL)
		return;

	/* in some cases when rigs change, we cant synchronize
	 * to avoid crashing check for possible errors here */
	for (pchan = pose->chanbase.first; pchan; pchan = pchan->next) {
		if (pchan->bone->layer & layer_protected) {
			if (BKE_pose_channel_find_name(frompose, pchan->name) == NULL) {
				printf("failed to sync proxy armature because '%s' is missing pose channel '%s'\n",
				       from->id.name, pchan->name);
				error = 1;
			}
		}
	}

	if (error)
		return;

	/* clear all transformation values from library */
	BKE_pose_rest(frompose);

	/* copy over all of the proxy's bone groups */
	/* TODO for later
	 * - implement 'local' bone groups as for constraints
	 * Note: this isn't trivial, as bones reference groups by index not by pointer,
	 *       so syncing things correctly needs careful attention */
	BLI_freelistN(&pose->agroups);
	BLI_duplicatelist(&pose->agroups, &frompose->agroups);
	pose->active_group = frompose->active_group;

	for (pchan = pose->chanbase.first; pchan; pchan = pchan->next) {
		pchanp = BKE_pose_channel_find_name(frompose, pchan->name);

		if (UNLIKELY(pchanp == NULL)) {
			/* happens for proxies that become invalid because of a missing link
			 * for regulat cases it shouldn't happen at all */
		}
		else if (pchan->bone->layer & layer_protected) {
			ListBase proxylocal_constraints = {NULL, NULL};

			/* copy posechannel to temp, but restore important pointers */
			pchanw = *pchanp;
			pchanw.prev = pchan->prev;
			pchanw.next = pchan->next;
			pchanw.parent = pchan->parent;
			pchanw.child = pchan->child;

			/* this is freed so copy a copy, else undo crashes */
			if (pchanw.prop) {
				pchanw.prop = IDP_CopyProperty(pchanw.prop);

				/* use the values from the the existing props */
				if (pchan->prop) {
					IDP_SyncGroupValues(pchanw.prop, pchan->prop);
				}
			}

			/* constraints - proxy constraints are flushed... local ones are added after
			 *     1. extract constraints not from proxy (CONSTRAINT_PROXY_LOCAL) from pchan's constraints
			 *     2. copy proxy-pchan's constraints on-to new
			 *     3. add extracted local constraints back on top
			 *
			 * Note for copy_constraints: when copying constraints, disable 'do_extern' otherwise
			 *                            we get the libs direct linked in this blend. */
			extract_proxylocal_constraints(&proxylocal_constraints, &pchan->constraints);
			copy_constraints(&pchanw.constraints, &pchanp->constraints, FALSE);
			BLI_movelisttolist(&pchanw.constraints, &proxylocal_constraints);

			/* constraints - set target ob pointer to own object */
			for (con = pchanw.constraints.first; con; con = con->next) {
				bConstraintTypeInfo *cti = constraint_get_typeinfo(con);
				ListBase targets = {NULL, NULL};
				bConstraintTarget *ct;

				if (cti && cti->get_constraint_targets) {
					cti->get_constraint_targets(con, &targets);

					for (ct = targets.first; ct; ct = ct->next) {
						if (ct->tar == from)
							ct->tar = ob;
					}

					if (cti->flush_constraint_targets)
						cti->flush_constraint_targets(con, &targets, 0);
				}
			}

			/* free stuff from current channel */
			BKE_pose_channel_free(pchan);

			/* the final copy */
			*pchan = pchanw;
		}
		else {
			/* always copy custom shape */
			pchan->custom = pchanp->custom;
			pchan->custom_tx = pchanp->custom_tx;

			/* ID-Property Syncing */
			{
				IDProperty *prop_orig = pchan->prop;
				if (pchanp->prop) {
					pchan->prop = IDP_CopyProperty(pchanp->prop);
					if (prop_orig) {
						/* copy existing values across when types match */
						IDP_SyncGroupValues(pchan->prop, prop_orig);
					}
				}
				else {
					pchan->prop = NULL;
				}
				if (prop_orig) {
					IDP_FreeProperty(prop_orig);
					MEM_freeN(prop_orig);
				}
			}
		}
	}
}

static int rebuild_pose_bone(bPose *pose, Bone *bone, bPoseChannel *parchan, int counter)
{
	bPoseChannel *pchan = BKE_pose_channel_verify(pose, bone->name); /* verify checks and/or adds */

	pchan->bone = bone;
	pchan->parent = parchan;

	counter++;

	for (bone = bone->childbase.first; bone; bone = bone->next) {
		counter = rebuild_pose_bone(pose, bone, pchan, counter);
		/* for quick detecting of next bone in chain, only b-bone uses it now */
		if (bone->flag & BONE_CONNECTED)
			pchan->child = BKE_pose_channel_find_name(pose, bone->name);
	}

	return counter;
}

/* only after leave editmode, duplicating, validating older files, library syncing */
/* NOTE: pose->flag is set for it */
void BKE_pose_rebuild(Object *ob, bArmature *arm)
{
	Bone *bone;
	bPose *pose;
	bPoseChannel *pchan, *next;
	int counter = 0;

	/* only done here */
	if (ob->pose == NULL) {
		/* create new pose */
		ob->pose = MEM_callocN(size…