Кватернион, он же гиперкомплексное число, представляет собой набор четырех чисел. Иногда будет удобно представлять себе кватернион как 4D-вектор, иногда как набор четырех чисел, иногда как число и 3D-вектор, а иногда и как гиперкомплексное число с тремя мнимыми единицами i, j, k; таким образом, имеем следующие представления: q = [x1,x2,x3,x4] = [scalar,(vector)] = [x1,(x2,x3,x4)] = x1+x2*i+x3*j+x4*k. Сложить или вычесть два кватерниона, а также умножить кватернион на число можно, как обычно, покомпонентно; с умножением ситуация более сложная. Умножение кватернионов должно в результате дать тоже кватернион, то есть конструкцию, содержащую лишь слагаемые вида r и r*l, где r - действительное число, а l - одна из мнимых единиц. Поэтому надо как-то определить операцию умножения для любых двух мнимых единиц. Определяется она так, что умножение получается некоммутативным, т.е. от перестановки мест множителей произведение меняется, и x*y != y*x. Поэтому умножение двух кватернионов приходится выполнять не по привычным правилам арифметики, а по следующим аксиомам: a*(b*c) = (a*b)*c, (ассоциативность) (a+b)*c = a*c+b*c, (транзитивность) a*(b+c) = a*b+a*c, (транзитивность) a*1 = 1*a = a, (существование единицы) a*0 = 0*a = 0, (существование нуля) i*i = j*j = k*k = -1, (свойство мнимых единиц) i*j = -j*i = k. (связь между мнимыми единицами i, j, k) Из этих правил, кстати, следует, что j*k = -k*j = i, k*i = -i*k = j, и получается такая вот таблица умножения комплексных единиц (умножение действительных чисел между собой и на комплексные единицы действует по обычным правилам, так что все свойства кватернионов определяются, в общем, этой таблицей):
Кроме того, из этих правил можно вывести правило для умножения кватернионов, заданных в форме [scalar,vector]: q1 = [s1,v1], Здесь v1*v2 - скалярное произведение векторов v1, v2; v1xv2 - векторное, все остальные произведения обычные (либо число на число, либо число на вектор). Нужны же кватернионы для представления и интерполяции поворотов. Поворот относительно оси (x,y,z) (иными словами, поворот вокруг вектора (x,y,z), проведенного из начала координат) на угол angle представляется кватернионом q, лежащим на единичной 4D-сфере (то есть, 4D-вектором длины 1): s = cos(angle/2), Что интересно, в такой форме поворот, соответствующий комбинации поворотов q1 и q2, просто равен их произведению. В случае с 3D Studio это позволяет быстро и просто перевести сохраненные в CHUNK_TRACKROTATE относительные повороты в абсолютные: просто читаем эти самые повороты (а записаны они как раз в форме [angle,(x,y,z)], причем длина вектора (x,y,z) уже приведена к единичной), переводим их в кватернионную форму, получаем набор кватернионов q0, q1, ..., q(n-1), qn. Здесь q0 и так задает абсолютный поворот, а вот все остальные придется переводить (умножение здесь, конечно, кватернионное): absolute_q0 = q0, Получаем набор кватернионов, задающих абсолютные повороты, или абсолютную
ориентацию объекта в какие-то моменты времени. Для того же, чтобы получить
поворот-ориентацию в любой момент времени, придется как-то интерполировать
повороты между этими заданными ключевыми значениями.
slerp(q1,q2,t) = (q1*sin((1-t)*a) + q2*sin(t*a)) / sin(a), где t - локальное время (см.п.7.6), a - угол между векторами q1, q2; 0 <= t <= 1, То есть q1, q2 здесь уже рассматриваем как 4D-вектора. Приведенную формулу нетрудно вывести (для лучшего понимания): нам нужна такая точка q, которая лежит на единичной сфере, лежит в одной плоскости с q1 и q2 и центром (то есть нулем), причем угол между векторами q и q1 меняется линейно и, таким образом, равен t*a. Раз точка лежит в одной плоскости с 0, q1, q2, то вектор q равен линейной комбинации векторов q1, q2: q = k1*q1 + k2*q2, где k1, k2 - какие-то (пока неизвестные) коэффициенты. q лежит на сфере, значит, длина q равна 1, отсюда имеем: |q| = (q,q) = 1, Угол между q и q1 равен t*a, отсюда: cos(q,q1) = cos(t*a), Получили систему уравнений для k1, k2: k1 + k2*(q1,q2) = cos(t*a), или k1 + k2*cos(a) = cos(t*a), Отсюда k1 = (cos(t*a) - k2*cos(a)), и получаем квадратное уравнение: cos(t*a)^2 - 2*k2*cos(a)*cos(t*a) + k2^2*cos(a)^2 + k2^2 + Если a - очень маленький угол, настолько, что могут возникнуть ошибки при делении на sin(a), можно использовать обычную линейную интерполяцию (так как при маленьких значениях a sin(a) ~= a, sin(t*a) ~= t*a, и так далее). Итак, мы умеем задавать повороты кватернионами, мы умеем их интерполировать линейно по множеству их возможных значений, то есть, поверхности сферы. Но хочется ведь интерполировать сплайнами Кочанека-Бартельса (далее везде, где используется термин "сплайны", подразумеваются именно такие сплайны), так как ориентация объекта должна меняться плавно, а не рывками, и желательно по совршенно той же траектории, что и в 3D Studio. Причем строить сплайны надо на поверхности четырехмерной сферы, иначе результаты интерполяции не будут соответствовать поворотам; кватернион-поворот должен обязательно лежать на единичной 4D-сфере. Естественное, возникает вопрос - как все это сделать? Оказывается, кубическую функцию, переписав ее в определенном виде, можно строить только с помощью линейной интерполяции - или, для нашего случая, с помощью сферической линейной интерполяции. А именно, переписываем эту самую произвольную кубическую функцию в виде g(t) = v1*(1-t)^3 + c1*3*t*(1-t)^2 + c2*3*t^2*(1-t) + v2*t^3, и считаем ее значение в произвольно взятой точке t, используя только линейную интерполяцию (linear interpolation, lerp): пусть lerp(a, b, t) = a*(1-t) + b*t, тогда g(t) можно посчитать вот так: tmp1 = lerp(v1, c1, t), Нам же надо интерполяцию сплайнами по поверхности сферы, это можно получить, всего-навсего заменив в приведенных выше формулах линейную интерполяцию lerp на наш сферический вариант, slerp. Далее, сравнивая g(t) с полученной в п.7.6. интерполяционной функцией f(t) можно заметить, что, если p1 = v1 <=> v1 = p1, r1 = (c1 - v1) * 3 <=> c1 = (p1 + r1) / 3, r2 = (v2 - c2) * 3 <=> c2 = (p2 - r2) / 3, p2 = v2 <=> v2 = p2, то g(t) совпадает с f(t). Длинный и нудный вывод для v1, v2, c1, c2 через функции lerp()/slerp() делать, пожалуй, смысле нет, так что ограничимся конечными результатами. А именно, для каждой точки-ключа cur имеем g1 = slerp(cur, prev, -(1+bias)/3.0); Для начальной и конечной точки, соответственно, имеем следующее: q0.rb = slerp(p0, p1, (1-tension)*(1+continuity*bias)/3.0); При интерполяции между какими-то точками a и b просто полагаем v1 = a, и считаем g(t) по приведенному выше алгоритму. Здесь мы до сих пор не учли параметры ease to и ease from, но это дело одной строки кода - посчитать на самом деле надо не g(t), а g(ease(t)). Впрочем, обычно ease(t) = t. Что это за функция ease(), откуда она берется, для чего нужна и как рассчитывается, написано в п.7.6. Таким образом, получаем кватернион, соответствующий повороту, задающий ориентацию объекта. Осталось выяснить, как из этого кватерниона получить что-нибудь более привычное - скажем, матрицу поворота. С одной стороны, вспомнив, как делается перевод в кватернионную форму для поворота на угол angle относительно оси (x,y,z), можно написать, что q = [s,v], и посчитать матрицу поворота на полученный угол относительно полученной оси. Но есть метод попроще, позволяющий получить матрицу непосредственно из кватерниона:
q = [w,(x,y,z)],
[ 1-2*(y*y+z*z) 2*(x*y-w*z) 2*(x*z+w*y) ]
A = [ 2*(x*y+w*z) 1-2*(x*x-z*z) 2*(y*z-w*x) ]
[ 2*(x*z-w*y) 2*(y*z+w*x) 1-2*(x*x-y*y) ].
Подведем итог. Для интерполяции ориентации объекта в какой-то момент времени с помощью кватернионов и сплайнов придется сделать почти то же самое, что и в случае "обычной" интерполяции чего-нибудь сплайнами (п.7.6). Различия же заключаются в следующем:
Все остальное совпадает с планом действий при "обычной" сплайновой интерполяциии и изложено в пункте 7.6. | |||
 |
|
|
|
|
