РЕДАКТИРОВАТЬ Отказ от ответственности : Для удобства в этом ответе векторы с w == 0 называются векторами, а с w == 1 - точками. Хотя, как указал FxIII, это не математически правильная терминология. Однако, поскольку суть ответа не в терминологии, а в необходимости различать оба типа векторов, я буду придерживаться этого. По практическим соображениям это соглашение широко используется в разработке игр.
Невозможно провести различие между векторами и точками без компонента w. Это 1 для точек и 0 для векторов.
Если векторы умножаются на аффинную матрицу преобразования 4x4, которая имеет перевод в последней строке / столбце, вектор также будет переведен, что неверно, должны быть переведены только точки. Об этом заботится ноль в компоненте 'w' вектора.
Выделение этой части умножения матрицы на вектор делает это более ясным:
r.x = ... + a._14 * v.w;
r.y = ... + a._24 * v.w;
r.z = ... + a._34 * v.w;
r.w = ... + a._44 * v.w;
a._14, a._24 and a._34 is the translational part of the affine matrix.
Without a 'w' component one has to set it implicitly to 0 (vector) or to 1 (point)
Т.е. было бы неправильно переводить вектор, например ось вращения, результат просто неправильный. Имея ноль 4-го компонента, вы все равно можете использовать ту же матрицу, которая преобразует точки для преобразования оси вращения, и результат будет действительным и его длина сохраняется до тех пор, пока в матрице нет шкалы. Это поведение, которое вы хотите для векторов. Без 4-го компонента вам пришлось бы создать 2 матрицы (или 2 разные функции умножения с неявным 4-м параметром) и сделать 2 разных вызова функций для точек и векторов.
Чтобы использовать векторные регистры современных процессоров (SSE, Altivec, SPU), вы все равно должны передать 4x 32-битные числа с плавающей запятой (это 128-битный регистр), плюс вам нужно позаботиться о выравнивании, обычно 16 байтах. Таким образом, у вас нет возможности сохранить место для 4-го компонента в любом случае.
РЕДАКТИРОВАТЬ:
ответ на вопрос в основном
- Сохраните w-компонент: 1 для позиций и 0 для векторов
- Или вызовите разные функции умножения матрицы на вектор и неявно передайте компонент 'w', выбрав одну из функций
Нужно выбрать один из них, невозможно сохранить только {x, y, z} и при этом использовать только одну функцию умножения матрицы на вектор. XNA, например, использует последний подход, имея 2 функции Transform в своем классе Vector3 , которые называются TransformиTransformNormal
Вот пример кода, который демонстрирует оба подхода и демонстрирует необходимость различать оба вида векторов одним из двух возможных способов. Мы переместим игровую сущность с позицией и направлением взгляда в мире, преобразовав ее с помощью матрицы. Если мы не используем компонент 'w', мы больше не можем использовать такое же умножение матрицы на вектор, как показано в этом примере. Если мы все равно это сделаем, мы получим неправильный ответ для преобразованного look_dirвектора:
#include <cstdio>
#include <cmath>
struct vector3
{
vector3() {}
vector3(float _x, float _y, float _z) { x = _x; y = _y; z = _z; }
float x, y, z;
};
struct vector4
{
vector4() {}
vector4(float _x, float _y, float _z, float _w) { x = _x; y = _y; z = _z; w = _w; }
float x, y, z, w;
};
struct matrix
{
// convenience column accessors
vector4& operator[](int col) { return cols[col]; }
const vector4& operator[](int col) const { return cols[col]; }
vector4 cols[4];
};
// since we transform a vector that stores the 'w' component,
// we just need this one matrix-vector multiplication
vector4 operator*( const matrix &m, const vector4 &v )
{
vector4 ret;
ret.x = v.x * m[0].x + v.y * m[1].x + v.z * m[2].x + v.w * m[3].x;
ret.y = v.x * m[0].y + v.y * m[1].y + v.z * m[2].y + v.w * m[3].y;
ret.z = v.x * m[0].z + v.y * m[1].z + v.z * m[2].z + v.w * m[3].z;
ret.w = v.x * m[0].w + v.y * m[1].w + v.z * m[2].w + v.w * m[3].w;
return ret;
}
// if we don't store 'w' in the vector we need 2 different transform functions
// this to transform points (w==1), i.e. positions
vector3 TransformV3( const matrix &m, const vector3 &v )
{
vector3 ret;
ret.x = v.x * m[0].x + v.y * m[1].x + v.z * m[2].x + 1.0f * m[3].x;
ret.y = v.x * m[0].y + v.y * m[1].y + v.z * m[2].y + 1.0f * m[3].y;
ret.z = v.x * m[0].z + v.y * m[1].z + v.z * m[2].z + 1.0f * m[3].z;
return ret;
}
// and this one is to transform vectors (w==0), like a direction-vector
vector3 TransformNormalV3( const matrix &m, const vector3 &v )
{
vector3 ret;
ret.x = v.x * m[0].x + v.y * m[1].x + v.z * m[2].x + 0.0f * m[3].x;
ret.y = v.x * m[0].y + v.y * m[1].y + v.z * m[2].y + 0.0f * m[3].y;
ret.z = v.x * m[0].z + v.y * m[1].z + v.z * m[2].z + 0.0f * m[3].z;
return ret;
}
// some helpers to output the results
void PrintV4(const char *msg, const vector4 &p ) { printf("%-15s: %10.6f %10.6f %10.6f %10.6f\n", msg, p.x, p.y, p.z, p.w ); }
void PrintV3(const char *msg, const vector3 &p ) { printf("%-15s: %10.6f %10.6f %10.6f\n", msg, p.x, p.y, p.z); }
#define STORE_W 1
int main()
{
// suppose we have a "position" of an entity and its
// look direction "look_dir" which is a unit vector
// we will move this entity in the world
// the entity will be moved in the world by a translation
// in x+5 and a rotation of 90 degrees around the y-axis
// let's create that matrix first
// the rotation angle, 90 degrees in radians
float a = 1.570796326794896619f;
matrix moveEntity;
moveEntity[0] = vector4( cos(a), 0.0f, sin(a), 0.0f);
moveEntity[1] = vector4( 0.0f, 1.0f, 0.0f, 0.0f);
moveEntity[2] = vector4(-sin(a), 0.0f, cos(a), 0.0f);
moveEntity[3] = vector4( 5.0f, 0.0f, 0.0f, 1.0f);
#if STORE_W
vector4 position(0.0f, 0.0f, 0.0f, 1.0f);
// entity is looking towards the positive x-axis
vector4 look_dir(1.0f, 0.0f, 0.0f, 0.0f);
// move the entity using the matrix
// we can use the same function for the matrix-vector multiplication to transform
// the position and the unit vector since we store 'w' in the vector
position = moveEntity * position;
look_dir = moveEntity * look_dir;
PrintV4("position", position);
PrintV4("look_dir", look_dir);
#else
vector3 position(0.0f, 0.0f, 0.0f);
// entity is looking towards the positive x-axis
vector3 look_dir(1.0f, 0.0f, 0.0f);
// move the entity using the matrix
// we have to call 2 different transform functions one to transform the position
// and the other one to transform the unit-vector since we don't
// store 'w' in the vector
position = TransformV3(moveEntity, position);
look_dir = TransformNormalV3(moveEntity, look_dir);
PrintV3("position", position);
PrintV3("look_dir", look_dir);
#endif
return 0;
}
Начальное состояние объекта:
position : 0.000000 0.000000 0.000000 1.000000
look_dir : 1.000000 0.000000 0.000000 0.000000
Теперь к этой сущности будет применено преобразование с переводом x + 5 и поворотом на 90 градусов вокруг оси y. Правильный ответ после преобразования:
position : 5.000000 0.000000 0.000000 1.000000
look_dir : 0.000000 0.000000 1.000000 0.000000
Мы получим правильный ответ, только если будем различать векторы с w == 0 и позиции с w == 1 одним из представленных выше способов.
r.x = ... + a._14*v.w;r.y = ... + a._24*v.w;r.z = ... + a._34*v.w;r.w = ... + a._44*v.w;посмотрите на мой ответ для деталей