OpenGL: Коллизия камеры в мире

// Вернём смещение для «выдавливания» сферы.
return vOffset;
}

// Цикл по всем треугольникам
for(int i = 0; i < numOfVerts; i += 3)
{
// Сохраним текущий треугольник в переменную
CVector3 vTriangle[3] = { pVertices[i], pVertices[i+1], pVertices[i+2] };

// 1) ШАГ ОДИН — находим положение сферы

// Находим нормаль текущего треугольника
CVector3 vNormal = Normal(vTriangle);

// Переменная — расстояние сферы от плоскости треугольника
float distance = 0.0f;

// Находим положение сферы — сзади, спереди, или пересекается с плоскостью
int classification = ClassifySphere(m_vPosition, vNormal, vTriangle[0], m_radius, distance);

// Если сфера пересекает плоскость, продолжаем проверку дальше
if(classification == INTERSECTS)
{
// 2) ШАГ ДВА — находим псевдо точку пересечения

// Теперь проецируем центр сферы на плоскость треугольника
CVector3 vOffset = vNormal * distance;

// Получив смещение от плоскости, просто вычитаем его из центра сферы.
// «vIntersection» — точка пересечения с плоскостью (или треугольником)
CVector3 vIntersection = m_vPosition — vOffset;

// 3) ШАГ ТРИ — Проверяем, находится ли точка пересечения внутри треугольника

// Сначала проверяем, находится ли точка внутри треугольника, если нет —
// переходоим к шагу 4, где проверяем на пересечение рёбра треугольника.

// Мы изменяем одну вещь в параметрах EdgeSphereCollision. Поскольку сфера
// вокруг нашей камеры большая, нам придется проходить лишнее расстояние,
// чтобы пройти за угол. Это потому, что угла полигона могут пересечься со
// сторонами нашей сферы. Так что это будет выглядеть как будто мы можем пройти
// вперед, угол ведь справа от нас, но будет обрабатыватся пересечение.
// Чтобы исправить это, просто делим радиус на 2. Помните, это делается только
// при проверке пересечения рёбер треугольника. Это просто добавит реалистичности
// при огибании углов. В идеале, если мы будем использовать для коллизий ограничи-
// вающий куб, цилиндр или эллипс, этой проблемы не возникнет.

if(InsidePolygon(vIntersection, vTriangle, 3) ||
EdgeSphereCollision(m_vPosition, vTriangle, 3, m_radius / 2))
{

// Если мы здесь — у нас есть пересечение! Чтобы исправить его, все что нам
// нужно — найти глубину, на которую сфера проникла в полигон, и вытолкнуть
// её назад на это же значение. GetCollisionOffset() вернет нам нужное
// смещение, основываясь на нормали, радиусе и дистанции центра сферы
// от плоскости:
vOffset = GetCollisionOffset(vNormal, m_radius, distance);

// Теперь, получив смещение, нужно прибавить его к позиции и вектору взгляда
// камеры. Это «выдавит» её назад из плоскости. Визуально мы этого
// не заметим, так как рассччет коллизий происходит до рендера сцены.
m_vPosition = m_vPosition + vOffset;
m_vView = m_vView + vOffset;
}
}
}
}

void LoadVertices()
{
// Эта функция читает вершины из ASCII текстового файла (World.raw).
// Сначала читаем вершины во временную переменную CVector3 чтобы
// получить их число. Затем ещё раз читаем вершины, уже сохраняя их в массив.

// Создаем десткриптор файла и открываем файл с вершинами
FILE *fp = fopen(FILE_NAME, «r»);

// Убедимся, что файл открылся верно
if(!fp){
MessageBox(NULL, «Can’t Open File», «Error», MB_OK);
exit(1);
}

// Создаём временную переменную для хранения вершин
CVector3 vTemp;

// Получаем число вершин из файла
while(1)
{
// Читаем вершины и получаем результат чтения. Если результат == EOF,
// завершаем чтение.
int result = fscanf(fp, «%f %f %fn», &vTemp.x, &vTemp.y, &vTemp.z);

// Если мы достигли конца файла — завершаем чтение
if(result == EOF)
break;

// Увеличиваем число вершин
g_NumberOfVerts++;
}

// Резервируем память под вершины
g_vWorld     = new CVector3 [ g_NumberOfVerts ];

// «перематываем» файл на начало
rewind(fp);

// Создаём счетчик для индекса массива g_vWorld[]
int index = 0;

// Читаем вершины из файла
for(int i = 0; i < g_NumberOfVerts; i++)
{
// Читаем текущую вершину и увеличиваем индекс
fscanf(fp, «%f %f %fn», &g_vWorld[ index ].x,
&g_vWorld[ index ].y,
&g_vWorld[ index ].z);

index++;    // Увеличиваем индекс массива вершин
}

// Закрываем файл
fclose(fp);
}

//////////////////////////////////////////////////////////////////////////////////////////
//
// Изменяем инициализацию (функция Init()):
//

void Init(HWND hWnd)
{
g_hWnd = hWnd;
GetClientRect(g_hWnd, &g_rRect);
InitializeOpenGL(g_rRect.right, g_rRect.bottom);
g_Camera.PositionCamera(10, 4, 12,   9, 4, 12,   0, 1, 0);

// В начале нужно установить радиус сферы. Я выбрал 1
g_Camera.SetCameraRadius(1);

// Загружаем вершины из файла
LoadVertices();

// Сейчас мы включим обрезку задних полигонов. Если вы не знаете, что это
// такое — это просто значит, что мы не будем отрисовывать обе стороны полигона.
// Единственная сторона, которая будет отрисовыватся — это сторона с исходящей
// от неё нормалью. Включая culling, OpenGL будет «обрезать» задние полигоны.
// Поскольну наш мир похож на «коробку», внутри которой — мы, мы никогда
// не увидим задней стороны полигонов, так что их отрисовывать нет смысла.
// Вы можете изменить GL_BACK на GL_FRONT для противоположного эффекта.

glCullFace(GL_BACK);                // Не отрисовываем задние стороны полигонов
glEnable(GL_CULL_FACE);             // Включим обрезку

glClearColor(0.0, 0.0, 0.0, 1);         // Установим цвет бекграунда в черный

float fogColor[4] = {0.0, 0.0, 0.0, 1.0f};  // Сделаем туман также черным

glFogi(GL_FOG_MODE, GL_EXP2);       // Режим тумана
glFogfv(GL_FOG_COLOR, fogColor);    // Цвет тумана
glFogf(GL_FOG_DENSITY, 0.045f);     // Глубина тумана
glHint(GL_FOG_HINT, GL_DONT_CARE);  // Способ создания тумана
glFogf(GL_FOG_START, 0);        // Стартовая глубина
glFogf(GL_FOG_END, 50.0f);      // Конечная глубина

glEnable(GL_FOG);       // И включим туман

ShowCursor(false);
}

/////////////////////////////////////////////////////////////////////////////////////////////
//
// Уберём всё лишнее из обработки клавиш, оставим только ESCAPE:
//

case WM_KEYDOWN:

switch(wParam) {
case VK_ESCAPE:
PostQuitMessage(0);
break;
}
break;

///////////////////////////////////////////////////////////////////////////////////////////////
//
// И наконец изменим функцию RenderScene():
//
void RenderScene()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();

// Чтобы рассчитать коллизии камеры, со стороны клиента вызываем только одну
// функцию. Просто передаём в неё вершины нашего мира, которые мы хотим проверить,
// и число этих вершин.
g_Camera.CheckCameraCollision(g_vWorld, g_NumberOfVerts);

// Позиционируем камеру
g_Camera.Look();

// Поскольку вершины нашего мира установлены в правильном порядке, давайте создадим
// цикл, проходящий через все вершины и передающий их для рендера.

glBegin(GL_TRIANGLES);

// Проходим через все вершины и рисуем их
for(int i = 0; i < g_NumberOfVerts; i += 3)
{
glVertex3f(g_vWorld[i].x, g_vWorld[i].y, g_vWorld[i].z);
glVertex3f(g_vWorld[i+1].x, g_vWorld[i+1].y, g_vWorld[i+1].z);
glVertex3f(g_vWorld[i+2].x, g_vWorld[i+2].y, g_vWorld[i+2].z);
}

glEnd();

SwapBuffers(g_hDC);
}