OpenGL: Камера — часть 3 — Управление мышью

// Конструктор, инициализирующий данные
CVector3(float X, float Y, float Z)
{
x = X; y = Y; z = Z;
}
// Перегружаем оператор +, чтобы прибавлять друг к другу векторы
CVector3 operator+(CVector3 vVector)
{
// Возвращаем +добавленный вектор
return CVector3(vVector.x + x, vVector.y + y, vVector.z + z);
}

// перегружаем оператор —
CVector3 operator—(CVector3 vVector)
{
return CVector3(x—vVector.x, y—vVector.y, z—vVector.z);
}

// Перегружаем оператор *
CVector3 operator*(float num)
{
return CVector3(x*num, y*num, z*num);
}

// Перегружаем оператор /
CVector3 operator/(float num)
{
return CVector3(x/num,y/num,z/num);
}

float x, y, z;              // Просто float для X,Y,Z
};

// В обьявление класса CCamera добавьте новую функцию:

class CCamera {
public:
….
….
….
// Функция, устанавливающая взгляд по позиции мыши
void SetViewByMouse();
};

// И изменим функцию MoveCamera(), т.к. мы добавили операторы классу вектора:
void CCamera::MoveCamera(float speed)
{
CVector3 vVector = m_vView — m_vPosition;

m_vPosition.x += vVector.x * speed;
m_vPosition.z += vVector.z * speed;
m_vView.x += vVector.x * speed;
m_vView.z += vVector.z * speed;
}

// Теперь напишем несколько новых функций:
/////////////////////////////////////// CROSS \\\\\\\\\\\\\\\\\\\\\*
/////
/////   Возвращает перпендикулярный вектор от 2х переданных векторов.
/////   2 любых пересекающихся вектора образуют плоскость, от котороый мы
/////   и ищем перпендикуляр.
/////
/////////////////////////////////////// CROSS \\\\\\\\\\\\\\\\\\\\\*

CVector3 Cross(CVector3 vVector1, CVector3 vVector2)
{
CVector3 vNormal;

// Если у нас есть 2 вектора (вектор взгляда и вертикальный вектор),
// у нас есть плоскость, от которой мы можем вычислить угол в 90 градусов.
// Рассчет cross’a прост, но его сложно запомнить с первого раза.
// Значение X для вектора — (V1.y * V2.z) — (V1.z * V2.y)
vNormal.x = ((vVector1.y * vVector2.z) — (vVector1.z * vVector2.y));

// Значение Y — (V1.z * V2.x) — (V1.x * V2.z)
vNormal.y = ((vVector1.z * vVector2.x) — (vVector1.x * vVector2.z));

// Значение Z: (V1.x * V2.y) — (V1.y * V2.x)
vNormal.z  = ((vVector1.x * vVector2.y) — (vVector1.y * vVector2.x));

// *ВАЖНО* Вы не можете менять этот порядок, иначе ничего не будет работать.
// Должно быть именно так, как здесь. Просто запомните, если вы ищите Х, вы не
// используете значение X двух векторов, и то же самое для Y и Z. Заметьте,
// вы рассчитываете значение из двух других осей, и никогда из той же самой.

// Итак, зачем всё это? Нам нужно найти ось, вокруг которой вращаться. Вращение камеры
// влево и вправо простое — вертикальная ось всегда (0,1,0).
// Вращение камеры вверх и вниз отличается, так как оно происходит вне
// глобальных осей. Достаньте себе книгу по линейной алгебре, если у вас
// её ещё нет, она вам пригодится.

// вернем результат.
return vNormal;
}

/////////////////////////////////////// MAGNITUDE \\\\\\\\\\\\\\\\\\\\\*
/////
/////               Возвращает величину вектора
/////
/////////////////////////////////////// MAGNITUDE \\\\\\\\\\\\\\\\\\\\\*

float Magnitude(CVector3 vNormal)
{
// Это даст нам величину нашей нормали,
// т.е. длину вектора. Мы используем эту информацию для нормализации
// вектора. Вот формула: magnitude = sqrt(V.x^2 + V.y^2 + V.z^2)   где V — вектор.

return (float)sqrt( (vNormal.x * vNormal.x) +
(vNormal.y * vNormal.y) +
(vNormal.z * vNormal.z) );
}

/////////////////////////////////////// NORMALIZE \\\\\\\\\\\\\\\\\\\\\*
/////
/////   Возвращает нормализированный вектор, длинна которого==1,
/////   это делает все рассчеты проще.
/////
/////////////////////////////////////// NORMALIZE \\\\\\\\\\\\\\\\\\\\\*

CVector3 Normalize(CVector3 vVector)
{
// Вы спросите, для чего эта ф-я? Мы должны убедиться, что наш вектор нормализирован.
// Вектор нормализирован — значит, его длинна равна 1. Например,
// вектор (2,0,0) после нормализации будет (1,0,0).

// Вычислим величину нормали
float magnitude = Magnitude(vVector);

// Теперь у нас есть величина, и мы можем разделить наш вектор на его величину.
// Это сделает длинну вектора равной единице, так с ним будет легче работать.
vVector = vVector / magnitude;

return vVector;
}

// Ну и наконец функция SetViewByMouse().
///////////////////////////////// SET VIEW BY MOUSE \\\\\\\\\\\\\\\\*
/////
/////   Добавим ф-ю управления взглядом с пом. мышки
/////
///////////////////////////////// SET VIEW BY MOUSE \\\\\\\\\\\\\\\\*
void CCamera::SetViewByMouse()
{
POINT mousePos;         // Это структура, хранящяя X и Y позиции мыши

// Оператор » >> 1″ — то же самое, что деление на 2, но о**енно быстрее 😉
int middleX = SCREEN_WIDTH  >> 1;   // Вычисляем половину ширины
int middleY = SCREEN_HEIGHT >> 1;   // И половину высоты экрана
float angleY = 0.0f;    // Направление взгляда вверх/вниз
float angleZ = 0.0f;    // Значение, необходимое для вращения влево-вправо (по оси Y)
static float currentRotX = 0.0f;

// Получаем текущие коорд. мыши
GetCursorPos(&mousePos);

// Если курсор остался в том же положении, мы не вращаем камеру
if( (mousePos.x == middleX) && (mousePos.y == middleY) ) return;

// Теперь, получив координаты курсора, возвращаем его обратно в середину.
SetCursorPos(middleX, middleY);

// Теперь нам нужно направление (или вектор), куда сдвинулся курсор.
// Его рассчет — простое вычитание. Просто возьмите среднюю точку и вычтите из неё
// новую позицию мыши: VECTOR = P1 — P2; где P1 — средняя точка (400,300 при 800х600).
// После получения дельты X и Y (или направления), я делю значение
// на 1000, иначе камера будет жутко быстрой.
angleY = (float)((middleX — mousePos.x))/1000.0f;
angleZ = (float)((middleY — mousePos.y)) / 1000.0f;

static float lastRotX = 0.0f;
lastRotX = currentRotX;     // Сохраняем последний угол вращения
// и используем заново currentRotX

// Если текущее вращение больше 1 градуса, обрежем его, чтобы не вращать слишком быстро
if(currentRotX > 1.0f)
{
currentRotX = 1.0f;

// врощаем на оставшийся угол
if(lastRotX != 1.0f)
{
// Чтобы найти ось, вокруг которой вращаться вверх и вниз, нужно
// найти вектор, перпендикулярный вектору взгляда камеры и
// вертикальному вектору.
// Это и будет наша ось. И прежде чем использовать эту ось,
// неплохо бы нормализовать её.
CVector3 vAxis = Cross(m_vView — m_vPosition, m_vUpVector);
vAxis = Normalize(vAxis);

// Вращаем камеру вокруг нашей оси на заданный угол
RotateView(1.0f — lastRotX, vAxis.x, vAxis.y, vAxis.z);
}
}

// Если угол меньше -1.0f, убедимся, что вращение не продолжится
else if(currentRotX < —1.0f)
{
currentRotX = —1.0f;
if(lastRotX != —1.0f)
{
// Опять же вычисляем ось
CVector3 vAxis = Cross(m_vView — m_vPosition, m_vUpVector);
vAxis = Normalize(vAxis);

// Вращаем
RotateView( —1.0f — lastRotX, vAxis.x, vAxis.y, vAxis.z);
}
}
// Если укладываемся в пределы 1.0f -1.0f — просто вращаем
else
{
CVector3 vAxis = Cross(m_vView — m_vPosition, m_vUpVector);
vAxis = Normalize(vAxis);
RotateView(angleZ, vAxis.x, vAxis.y, vAxis.z);
}

// Всегда вращаем камеру вокруг Y-оси
RotateView(angleY, 0, 1, 0);
}

// В главном игровом цикле (while(1)) перед вызовом CheckForMovement() добавьте
// вызов g_Camera.SetViewByMouse():

while(1)
{
……………….
……………….
……………….
//Проверяем мышь и клавиши каждый кадр
g_Camera.SetViewByMouse();  //передвинуть мышью
CheckForMovement();
RenderScene();
……………….
……………….
}

// В функции RenderScene изменим отрисовку объектов: вместо треугольников нарисуем
// квадраты.
// Замените glBegin(GL_TRIANGLES); …………. glEnd(); на следующее:

glBegin (GL_QUADS);
for(float i = 0; i < 100; i += 5)
{
glColor3ub(255, 255,   0);
glVertex3f(—10 + i/5,   i,  10 — i/5);
glColor3ub(255,   0,   0);
glVertex3f(—10 + i/5,   i, —10 + i/5);
glColor3ub(0,   255, 255);
glVertex3f(10 — i/5,    i, —10 + i/5);
glColor3ub(0,     0, 255);
glVertex3f(10 — i/5,    i,  10 — i/5);
}
glEnd();