Создание игр на opengl. История противостояния OpenGL и Direct3D

Продолжается цикл статей, посвященных работе с библиотекой на нашем сайте, и, наконец, пришло время подключить третье измерение в наших экспериментах) Сегодня мы создадим в пространстве куб, а также добавим функцию вращения фигуры вокруг осей x и y . Как всегда разберем все по шагам, а в конце статьи я выложу полный проект с реализованным примером.

За основу давайте возьмем проект из предыдущего урока (), как и тогда, для построения изображения мы сегодня будем использовать массивы вершин, индексов и цветов . Давайте разберем нашу задачу…

Что из себя представляет куб? Ответ прост – 6 граней (квадратов) и 8 вершин 😉 Именно так мы и будем строить фигуру – построим по отдельности 6 его граней, а эта задача для нас уже не представляет никакой сложности.

Но прежде, чем приступать к рисованию, добавим в функцию initializeGL() следующее:

glShadeModel(GL_FLAT) ; glEnable(GL_CULL_FACE) ;

Помните на прошлом уроке, когда мы задавали разные цвета вершин у одной фигуры, то получали красивые переходы между цветами. Так вот сегодня нам это не нужно, грани будут иметь однородный цвет и именно для включения этого режима (а точнее для отключения режима сглаживания цветов) мы вызываем первую из этих функций. Цвет грани у нас теперь будет определяться цветом последней(!) нарисованной вершины квадрата.

Вторая функция устанавливает режим, когда строятся только внешние поверхности фигур. И вот тут есть один важный момент. Для корректного отображения объекта вершины в массиве вершин должны задаваться против(!) часовой стрелки.

Собственно, с приготовлениями на этом заканчиваем, начинаем отрисовку. Нам понадобятся три массива:

GLfloat cubeVertexArray[ 8 ] [ 3 ] ; GLfloat cubeColorArray[ 8 ] [ 3 ] ; GLubyte cubeIndexArray[ 6 ] [ 4 ] ;

С размерами массивов мы разобрались на прошлом уроке, не буду повторяться, поэтому сразу же переходим к заполнению их данными. Кстати ребро нашего куба будет равно единице, в соответствии с этим задаем координаты вершин в трехмерном пространстве:

cubeVertexArray[ 0 ] [ 0 ] = 0.0 ; cubeVertexArray[ 0 ] [ 1 ] = 0.0 ; cubeVertexArray[ 0 ] [ 2 ] = 1.0 ; cubeVertexArray[ 1 ] [ 0 ] = 0.0 ; cubeVertexArray[ 1 ] [ 1 ] = 1.0 ; cubeVertexArray[ 1 ] [ 2 ] = 1.0 ; cubeVertexArray[ 2 ] [ 0 ] = 1.0 ; cubeVertexArray[ 2 ] [ 1 ] = 1.0 ; cubeVertexArray[ 2 ] [ 2 ] = 1.0 ; cubeVertexArray[ 3 ] [ 0 ] = 1.0 ; cubeVertexArray[ 3 ] [ 1 ] = 0.0 ; cubeVertexArray[ 3 ] [ 2 ] = 1.0 ; cubeVertexArray[ 4 ] [ 0 ] = 0.0 ; cubeVertexArray[ 4 ] [ 1 ] = 0.0 ; cubeVertexArray[ 4 ] [ 2 ] = 0.0 ; cubeVertexArray[ 5 ] [ 0 ] = 0.0 ; cubeVertexArray[ 5 ] [ 1 ] = 1.0 ; cubeVertexArray[ 5 ] [ 2 ] = 0.0 ; cubeVertexArray[ 6 ] [ 0 ] = 1.0 ; cubeVertexArray[ 6 ] [ 1 ] = 1.0 ; cubeVertexArray[ 6 ] [ 2 ] = 0.0 ; cubeVertexArray[ 7 ] [ 0 ] = 1.0 ; cubeVertexArray[ 7 ] [ 1 ] = 0.0 ; cubeVertexArray[ 7 ] [ 2 ] = 0.0 ; cubeColorArray[ 0 ] [ 0 ] = 0.0 ; cubeColorArray[ 0 ] [ 1 ] = 0.0 ; cubeColorArray[ 0 ] [ 2 ] = 1.0 ; cubeColorArray[ 1 ] [ 0 ] = 0.6 ; cubeColorArray[ 1 ] [ 1 ] = 0.98 ; cubeColorArray[ 1 ] [ 2 ] = 0.6 ; cubeColorArray[ 2 ] [ 0 ] = 1.0 ; cubeColorArray[ 2 ] [ 1 ] = 0.84 ; cubeColorArray[ 2 ] [ 2 ] = 0.8 ; cubeColorArray[ 3 ] [ 0 ] = 0.8 ; cubeColorArray[ 3 ] [ 1 ] = 0.36 ; cubeColorArray[ 3 ] [ 2 ] = 0.36 ; cubeColorArray[ 4 ] [ 0 ] = 1.0 ; cubeColorArray[ 4 ] [ 1 ] = 0.27 ; cubeColorArray[ 4 ] [ 2 ] = 0.0 ; cubeColorArray[ 5 ] [ 0 ] = 0.82 ; cubeColorArray[ 5 ] [ 1 ] = 0.13 ; cubeColorArray[ 5 ] [ 2 ] = 0.56 ; cubeColorArray[ 6 ] [ 0 ] = 0.54 ; cubeColorArray[ 6 ] [ 1 ] = 0.17 ; cubeColorArray[ 6 ] [ 2 ] = 0.89 ; cubeColorArray[ 7 ] [ 0 ] = 0.0 ; cubeColorArray[ 7 ] [ 1 ] = 1.0 ; cubeColorArray[ 7 ] [ 2 ] = 1.0 ;

Мы задали координаты и цвета вершин куба. Давайте для наглядности посмотрим на рисунок:

Номера вершин на рисунке полностью соответствуют тому, как мы их задали в нашей программе. Теперь, глядя на картинку можно с легкостью пройтись по всем 6 граням куба и заполнить массив индексов. Давайте смотреть:

  • Грань 1 – вершины 0, 3, 2, 1
  • Грань 2 – вершины 0, 1, 5, 4
  • Грань 3 – вершины 7, 4, 5, 6
  • Грань 4 – вершины 3, 7, 6, 2
  • Грань 5 – вершины 1, 2, 6, 5
  • Грань 6 – вершины 0, 4, 7, 3

Теперь тоже самое делаем в программе =)

cubeIndexArray[ 0 ] [ 0 ] = 0 ; cubeIndexArray[ 0 ] [ 1 ] = 3 ; cubeIndexArray[ 0 ] [ 2 ] = 2 ; cubeIndexArray[ 0 ] [ 3 ] = 1 ; cubeIndexArray[ 1 ] [ 0 ] = 0 ; cubeIndexArray[ 1 ] [ 1 ] = 1 ; cubeIndexArray[ 1 ] [ 2 ] = 5 ; cubeIndexArray[ 1 ] [ 3 ] = 4 ; cubeIndexArray[ 2 ] [ 0 ] = 7 ; cubeIndexArray[ 2 ] [ 1 ] = 4 ; cubeIndexArray[ 2 ] [ 2 ] = 5 ; cubeIndexArray[ 2 ] [ 3 ] = 6 ; cubeIndexArray[ 3 ] [ 0 ] = 3 ; cubeIndexArray[ 3 ] [ 1 ] = 7 ; cubeIndexArray[ 3 ] [ 2 ] = 6 ; cubeIndexArray[ 3 ] [ 3 ] = 2 ; cubeIndexArray[ 4 ] [ 0 ] = 1 ; cubeIndexArray[ 4 ] [ 1 ] = 2 ; cubeIndexArray[ 4 ] [ 2 ] = 6 ; cubeIndexArray[ 4 ] [ 3 ] = 5 ; cubeIndexArray[ 5 ] [ 0 ] = 0 ; cubeIndexArray[ 5 ] [ 1 ] = 4 ; cubeIndexArray[ 5 ] [ 2 ] = 7 ; cubeIndexArray[ 5 ] [ 3 ] = 3 ;

Теперь осталось только вызвать функцию рисования:

glVertexPointer(3 , GL_FLOAT, 0 , cubeVertexArray) ; glColorPointer(3 , GL_FLOAT, 0 , cubeColorArray) ; glDrawElements(GL_QUADS, 24 , GL_UNSIGNED_BYTE, cubeIndexArray) ;

Запускаем программу и видим наш куб!

Правда на данный момент он больше похож на квадрат 😉 Все потому что мы смотрим на куб со стороны оси z и видим его проекцию на плоскость X0Y . Для того, чтобы все-таки увидеть, что это действительно куб, давайте добавим возможность вращать фигуру при удержании кнопки мыши и перемещении ее указателя.

Сделаем так – при перемещении указателя мыши от левого края до правого будем поворачивать куб на 180 градусов. Осталось вычислить, на сколько градусов нужно повернуть фигуру при произвольном перемещении курсора. С этим все просто, получаем формулу:

yAngle = 180 * d / w;

Здесь d – это расстояние, на которое мы переместили курсор, w – ширина нашего окна. Обратите внимание, что при движении мыши вдоль оси x поворот будет осуществляться вокруг оси y , и наоборот, перемещение вдоль y – поворот вокруг x .

Итак, сейчас нам нужно получить в программе данные о перемещениях мыши. Для этого переопределим методы:

void MainScene:: mousePressEvent (QMouseEvent * event) { pressPosition = event-> pos() ; } void MainScene:: mouseMoveEvent (QMouseEvent * event) { xAxisRotation += (180 * ((GLfloat) event-> y() - (GLfloat) pressPosition.y () ) ) / (currentHeight) ; yAxisRotation += (180 * ((GLfloat) event-> x() - (GLfloat) pressPosition.x () ) ) / (currentWidth) ; pressPosition = event-> pos() ; updateGL() ; }

При нажатии кнопки мыши (mousePressEvent() ) сохраняем в переменную pressPosition текущие координаты курсора. При перемещениях указателя производим расчет углов поворота, на которые необходимо развернуть куб, а затем вызываем функцию updateGL() для перерисовки сцены в соответствии с полученными данными. Не забываем объявить все используемые методы и переменные в файле MainScene.h.

Функцию updateGL() то мы вызвали, но само собой ничего, естественно, не повернется)

Для поворота фигуры предлагает нам следующую функцию:

То фигура повернется вокруг оси x на 45 градусов.

С этим все понятно, осталось только добавить вызов этой функций к нам в программу, а точнее в функцию paintGL() :

Как видите, все оказалось довольно-таки просто)

Теперь нам предстоит собрать проект и проверить результат:

На этом заканчиваем сегодняшнюю статью! А уже скоро, а именно в следующем уроке, мы разберемся с текстурами в – создадим собственные текстуры и нанесем их на 3D объекты, так что до скорого, не пропустите новую статью 😉

Во время своего #shaderchallenge (заинтересовался как устроена красивая графика, какие визуальные эффекты можно делать шейдерами и тд,- и решил непременно изучить) я пришел к тому, что мне необходимо знать как устроены внутри игровые движки. И, конечно, нет способа лучше изучить устройство чем попробовать написать свой!

Так сказать позаколачивать знания в свою голову, наступая на разные грабли, изгугливая разные форумы, доски и тп.

В 2016ом я решил прокачаться в программировании графики и начал изучать программирование шейдеров. И как оказалось в этом деле никуда без математики, поэтому я хорошую часть этого года вспоминал, а по-большей части заново знакомился с линейной алгеброй и кое-каким мат. анализом.

С какими-то простыми эффектами я познакомился в Unity3d, я по роду своей деятельности программирую именно на этом движке. Делал скринэффекты, простой аутлайн и тп. Кстати, знание того, как устроен пайплайн и какие эффекты можно получить, развязывают руки и в некоторых ситуациях просто думаешь: — Ага, так можно вот шейдерочек написать.

Но, как я говорил выше, необходимы более глубокие знания. Пишу свой движок. Конечно на C++ и OpenGL. Не DirectX, потому, что мне казалось, что на консолях именно OpenGL, но это не так.

Все говорят, что OpenGL и DirectX очень похожи, а я понимаю, что главное это понимать концепции и подходы, а фреймворк освоить можно быстро. Поэтому перескакивать на DirectX я не стал.

Про графическую библиотеку пояснил. Теперь про язык. Я очень доволен выбором именно C++, какой он крутой, ребята! Сколько всего я о нем не знал! Сколько добавилось в новых стандартах и сколько еще предстоит изучить!

Итак, встречайте, первое более-менее презентабельное демо, в моей собственном игровом движке Rudy Engine.

Первое демо

Реализовано: cubemap/skybox, загрузка моделей через assimp, half-lambert для освещения, overlay-рендерер для прицела и маркера-указателя на космическую станцию.


(очень дрожит видео, не стал искать какую-то хорошую программу для записи, воспользовался monosnap, наверное он не очень для этого подходит)

Дальнейшие планы

В дальнейшем я хочу сделать туман, shadow-mapping, и какие-то эффекты для этой демки и, возможно, переключиться на какую-то следующую. В целом, стараюсь придерживаться взрослой и мучительной разработки: дорабатывать движок таким образом, чтобы старые демо оставались рабочими. Подрихтовываю и подлатываю его. Для чего? Нужно понять этот trade-off как у Unity, чего стоит сделать универсальный инструмент?

Update 2017

Летом в 2017ом году, у меня закончился испытательный срок в крупной игровой студии и я написал в блоге, вся вот эта практика с игровым движком, мне очень помогла!

Всем привет! Что-то последнее время много уроков по конструкторам игр, и не так много по различным языкам программирования. Что бы устранить эту не справедливость, я решил запилить урок по OpenGL C++, надеюсь вы оцените)

Сразу же перейдем к геймдеву и будем писать маленькую игрульку нашего детства.

Для начала подключаем библиотеку OpenGL к своей среде разработки, я лично программирую в Microsoft Visual Studio 2013.

200?"200px":""+(this.scrollHeight+5)+"px");">
#include "stdafx.h"
#include
#include
#include
#include // подключаем все необходимые инклюды.

Int N = 30, M = 20; // т.к. змейка будем ездить по квадратикам, создадим их, для нашего окна в идеале будет 30x20 квадратов
int scale = 25; // размер квадрата. Когда OpenGL будет расчерчивать поле для игры, расстояние между гранями квадрата будет 25 пикселей

Int w = scale*N; // ширина поля
int h = scale*M; // его высота

Int dir, num = 4; // 4 направления и начальный размер змеи.
struct { int x; int y; } s; // структура змеи, X и Y координаты, массив с длинной.

Class fruct // класс фруктов, тех самых, которые будет есть наша змея
{
public:
int x, y; //координаты фруктов, что и где будет находится

Void New() // паблик с новыми фруктами. Он будет вызываться в начале игры и в тот момент, когда змея съест один из фруктов
{
x = rand() % N; // вычисление X координаты через рандом
y = rand() % M; // вычисление Y координаты через рандом
}

Void DrawFruct() // паблик, отрисовывающий фрукты
{
glColor3f(0.0, 1.0, 1.0); // цвет фруктов. в openGL он задается от 0 до 1, а не от 0 до 256, как многие привыкли
glRectf(x*scale, y*scale, (x + 1)*scale, (y + 1)*scale); // "Закрашиваем" квадрат выбранным цветом, таким образом в нем "появляется" фрукт
}
} m; // масив с фруктами, таким образом, у нас появится одновременно 5 фруктов в разных местах, а не один, как мы привыкли

Void Draw() // функция, которая отрисовывает линии
{
glColor3f(1.0, 0.0, 0.0); // цвет наших линий, в данном слуае - красный
glBegin(GL_LINES); // начинаем рисовать и указываем, что это линии
for (int i = 0; i < w; i+= scale) // отрисовываем линии в ширину
{
glVertex2f(i, 0); glVertex2f(i, h); // рисуем прямую
}
for (int j = 0; j < h; j += scale) //отрисовываем линии в высоту
{
glVertex2f(0, j); glVertex2f(w, j); // рисуем ту же самую прямую, но в другом направлении
}

GlEnd(); // конец отрисовки
}

Void tick() // функция в которой будет все обновляться (двигаться змея и т.д.)
{
for (int i = num; i > 0; --i) // движение змеи. Система остроумна и проста: блок перемешается вперед, а остальные X блоков, на X+1(2 блок встанет на место 1, 3 на место 2 и т.д...)
{
s[i].x = s.x; // задаем Х координату i блока координатой i - 1
s[i].y = s.y; // то же самое делаем и с Y координатой
}
// далее у нас система направлений.
if (dir == 0) s.y += 1; // если направление равно 0, то первый фрагмент массива перемещается на один по Y
if (dir == 1) s.x -= 1; // если направление равно 1, то первый фрагмент массива перемещается на минус один по X
if (dir == 2) s.x += 1; // аналогиная система
if (dir == 3) s.y -= 1; // аналогичная система

For (int i = 0; i < 10; i++) //цикл, в котором наша змея будет расти
{
if ((s.x == m[i].x) && (s.y == m[i].y)) // Если голова нашей змеи находится в одном блоке с фруктом, то...
{
num++; //...увеличиваем размер нашей змеи на 1
m[i].New(); // ... запускаем функцию отрисовки нового фрукта.
}
}
// Следующее нужно, что бы змея не выходила за рамка поля. Действует это просто: если змея выходит за рамки поля, то задаем
if (s.x > N) dir = 1; // Ей обратное направление. Например, если она выйдет за экран по высоте, то задаем ей направление, при котором она ползет
if (s.y > M) dir = 3; // вниз
if (s.x < 0) dir = 2;
if (s.y < 0) dir = 0;

For (int i = 1; i < num; i++) // с помощью этого цикла мы "обрежем" змею, если она заползет сама на себя
if (s.x == s[i].x && s.y == s[i].y) // проверка координат частей змеи, если X и Y координата головной части равно координате любого
num = i; // другого блока змеи, то задаем ей длину, при которой "откушенная" часть отпадает.
}

Void Snake() // выводим змейку на экран
{
glColor3f(0.1, 1.0, 0.0); //цвет змеи
for (int i = 0; i < num; i++) // цикл отрисовки.
{
glRectf(s[i].x*scale, s[i].y*scale, (s[i].x + 0.9)*scale, (s[i].y + 0.9)*scale); //Рисуем квадраты, те самые "блоки" змеи
}
}

Void Key(int key, int a, int b) // функция нажатия клавиш
{
switch (key) // используем оператор switch
{
case 101: dir = 0; break; // при нажатии клавиш, задаем направление змеи(вверх, вниз, влево, вправо)
case 102: dir = 2; break;
case 100: dir = 1; break;
case 103: dir = 3; break;
}
}

Void Display() //функция общий отрисовки
{
glClear(GL_COLOR_BUFFER_BIT); // очищаем окно перед началом отрисовки

Draw(); // вызов функции Draw, отвечающей за отрисовку фруктов
Snake(); // вызов функции Snake, отвечающей за отрисовку змейки

For (int i = 0; i < 5; i++) // заполнение карты фруктами
m[i].DrawFruct();

GlFlush(); // выводим на экран все вышеописанное
glutSwapBuffers();
}

Void timer(int = 0) // Таймер игры(промежуток времени, в котором будет производится все процессы)
{
Display(); // Вызов функций
tick();
glutTimerFunc(100, timer, 0); // новый вызов таймера(100 - промежуток времени(в милисекундах), через который он будет вызыватся, timer - вызываемый паблик)
}

Int main(int argc, char **argv) // Главная функция
{
std::cout << "Snake by Alexey Ovchinnikov:P\n Loading..."; // крутой текст в консоле при загрузке
srand(time(0));
for (int i = 0; i<10; i++) // начальная, самая первая отрисовка фруктов
m[i].New();

S.x = 10; // начальное положение змейки по X
s.y = 10; // и Y координате
// следующие функции абсолютно идиентичных почти во всех программах на OpenGL, так то запоминать их не обязательно, кроме...
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize(w, h); // ... этой, она создаем окно (w - ширина, h - высота)
glutCreateWindow("Game"); // ... этой, она задает название окна
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0, 640, 0, 480);
glutDisplayFunc (Display); // ... и этой, она вызывает начальную функцию, в нашем случае это главная функция отрисовки - Display
glutSpecialFunc(Key);
glutTimerFunc(50, timer, 0); // ... Ну и в начале программы задаем рекурсивный таймер.
glutMainLoop();

Return 0;
}

И так, на этом все, запускаем, играем. Постарался объяснить максимально понятно, если будут вопросы - задавайте.
P.S. И пожалуйста, не кидайтесь тапками если что-то не понятно или не так написал, первый урок в моей жизни.

OpenGL для начинающих разработчиков игр.

Посвящается Игорю Тарасову

1. Введение. Каркас OpenGL программы.

2. Перемещение объектов. Анимация.

3. Клавиатура. Мышь.

4. Рисование разных примитивов. Сложные объекты. Нормали. Дисплейные списки.

5. Материалы. Освещение. Масштабирование.

6. Текстуры.

8. Вывод текста.

9. Эффекты.

10. Приятные и полезные вещи: многооконные приложения, пользовательский интерфейс, создание курсора мыши.

11. OpenGL+DirectX=...

12. Делаем настоящие игры.

Приложение 1. Установка всех необходимых компонентов и библиотек.

Наверное, вам уже давно хочется создать свою трехмерную виртуальность. Хоть какую-нибудь, но свою. В принципе, можно использовать что-нибудь вроде DarkBasic или вообще, купить себе движок Q3A, и программирование ограничится скриптовым языком. Но это все для ламеров, мы-то к ним не относимся;-). В качестве простого решения я предлагаю OpenGL и эту книжку. Почему OpenGL а не DirectX? Дело в том, что OpenGL работает как конечный автомат, и в этом смысле он гораздо проще в изучении, чем Direct3D, полностью построенный на классах и интерфейсах. OpenGL – кросс-платформенная графическая библиотека. На какой платформе вы бы не программировали, на Windows, Linux, Unix, Macintosh, весь код относящися собственно к OpenGL был бы совершенно одинаков и отличалось бы только 200-300 строк относящихся к конкретной системе. OpenGL – расширяем. Значит, если в лаборатории Nvidia или Ati открыли какую-то новейшую сверхтехнологию, то Microsoft выпускает новую версию DirectX, а SGI просто добавляет в спецификацию OpenGL новое расширение. Стандарт OpenGL почти не изменился с 1996 года, и не изменится кардинально до выхода OpenGL2. Все, что вы напишите сейчас, пользуясь OpenGL, будет работать и компилироваться через год-два, и будет точно таким же, как вы его создали сегодня. OpenGL не зависит от языка и среды программирования и мы можем писать наши программы на Fortran, Basic, Pascal, C, C++, etc. Я лично предпочитаю Ms Visual С++ 7/Windows, и работоспособность всех примеров из предлагаемой нашему любознательному читателю книги проверена именно в этой среде.

Итак, приняв решение о выборе OpenGL в качестве базового трехмерного движка, бежим в магазин покупать какую-нибуть современную среду разработки, желательно MSVC++7, т.к. далее порядок действий далее я буду описывать для неё.

Также нам понадобится библиотека Glut, которую можно скачать с моего сайта (OpenGL 3 D . fatal . ru ) (см. Прил. 1).

Запустив MSVC++7 вы увидите перед собой примерно такое:

1 – Solution Explorer. Здесь в виде дерева показаны все файлы, имеющиеся в проекте. Пока что наш проект пуст и окно девственно чисто.

2 – Dynamic Help. Если вы почти/совсем не знаете С++, советую чаше сюда заглядывать. При установленной MSDN collection просто наведите курсор на непонянтый код и получите подробную справку.

3 – Task list. Вобще-то это органайзер, но сюда выводятся все сообщения и предупреждения об ошибках компиляции и сборки.

4 – Собственно рабочая область с закладками. Пока что она там только одна – Visual Studio start page.

Теперь, пощелкав из любопытства в разные места, приступаем к делу.

1.Щелкайте File->New->Project и в появившемся окне справа вверху щелкните Win32 Project. Наделите проект именем, например “OpenGL1” и щелкните OK.

2
. Затем выберите Application Settings и затем Console Application. Щелкните Finish и удалите из Solution Explorer (1) все файлы, кроме OpenGL1.cpp. (Правый клик по файлу -> Remove).

3. В Solution Explorer правой кнопкой мыши щелкните по надписи OpenGL1 и выберите “Properties”. Появится окно настроек проекта. В нем выберите папку “Linker”, а в ней – “Input”. Справа выберите “Additional Dependencies”.

4. Впишите туда “opengl32.lib glu32.lib glut32.lib”.

5. В папке “C++” выберите “Precompiled header” и сотрите все из второго поля.

Все! Мы готовы к нормальной работе. Теперь посмотрим (дважды кликнув по OpenGL1.cpp) что же нам сгенерировал MSVC++:

// OpenGL1.cpp: Defines the entry point for the console application.

#include "stdafx.h"

int _tmain(int argc, _TCHAR* argv)

Ерунда, правда? ;-). Удаляем все это и спокойно пишем:

#include

#include

#include

#include "glut.h"

Эти четыре строки подключают все необходимые библиотеки, такие как OpenGL от Microsoft, Glu и Glut который должен быть в каталоге с программой. Они необходимы для любой программы, использующей OpenGL.

glViewport(0,0,width,height);

glMatrixMode(GL_PROJECTION);

glLoadIdentity();

gluPerspective(45.0, width/height, 0.1,10);

glMatrixMode(GL_MODELVIEW);

Это – функция изменения размера окна программы. Она будет вызываться каждый раз, когда у окна программы будет изменен размер, а также при создании окна. Команда gluPerspective устанавливает угол зрения (у нас – 45.0, первый параметр), степень перспективы (второй параметр), переднюю и заднюю плоскости отсечения. Все предметы, находящиеся за плоскостью отсечения вырезаются, так что с этими параметрами надо быть осторожней. Команда gluLookAt задает положение наблюдателя (первые три параметра) и точку, в которую он смотрит (следующие три).

void display(void)

glutSwapBuffers();

А вот тут нам и предстоит рисовать разные объекты. Первая команда очищает экран и буфер глубины, а последняя – меняет буферы местами. Поясню: в OpenGL есть два режима прорисовки (рендеринга) изображения. Первый – немедленный вывод на экран. Второй – двухбуферный, когда, чтобы предотвратить мигание и дрожание изображения, вся картинка рисуется сначала в задний буфер, а потом меняется местами с передним (видимым).

glutInitWindowSize(640, 480);

glutIdleFunc(display);

glutDisplayFunc(display);

glutReshapeFunc(resize);

glEnable(GL_DEPTH_TEST);

glEnable(GL_COLOR_MATERIAL);

glEnable(GL_LIGHTING);

glEnable(GL_LIGHT0);

Это – самая главная функция, которая исполняется в самом начале. Первая команда задает положение окна, вторая его размер. Третья команда устанавливает различные режимы вывода (Rgb цветовое пространство, с буфером глубины (веть у нас 3D), двойная буфферизация.

Ч
етвертая команда создает окно с названием “Opengl1 Window”

Пятая и шестая команды указывают, что в случае неактивности и во всех остальных случаях нужно исполнять функцию display.

С
ледующие четыре комманды относятся к OpenGL. C помощью них включается: тест буфера глубины, необходимый для трехмерных объектов, цветные материалы, иначе все объекты будут серые, освещение и первый источник света. Вообще, с помощью glEnable можно многое включить, а с помощью glDisable выключить то, что включили.

И, наконец, последняя команда запускает цикл, в котором будет все время повторяться функция display.

Вот мы и закончили обзор простейшей программы на основе OpenGL.

Нажмите Ctrl+F5, щелкните Yes и наслаждайтесь…

Да, к сожалению, пока ничего не видно. Но стоит в функции display вместо строки “// ...” вставить, например “glutSolidTeapot(1.0);” и мы тут же увидим значительную разницу! Одной командой мы создали чайник! Впечетляет? Давайте оценим затраты времени. В OpenGL, чтобы нарисовать чайник, нам понадобилось 43 строки кода, в Direct3D нам бы понадобилось написать 320 строк, а при написании собственного движка… Это уж сами считайте.

Правда, чайник некрасивый – белый, да и фон так себе… Теперь встравляем еще две комманды:

glClearColor(0.3,0.2,0.6,1.0);

glColor3f(0.0,0.0,1.0);

перед рисованием чайника и получаем новый результат: на сиреневом фоне – синий чайник!

Команда glClearColor заливает фон цветом, который определяют три первых параметра (четвертый – фиктивный): соотношение красного, зеленого и синего цветов . glColor3f задает текущий цвет, параметры те же: соотношение красного, зеленого, синего . Вообще, многие комманды в OpenGL содержат всякие суффиксы, которые означают количество и тип аргументов, например 3f означает 3 float. Ниже дана таблица, для лучшего понимания команд OpenGL:

Суффикс, тип, размер

Значение

Беззнаковый байт

Значение с плавающей точкой

Короткое целое

US (GLushort), 2

Беззнаковое короткое целое

Беззнаковое целое

Дробное с двойной точностью

Массив из нескольких значений

Например: 3ubv означает, что представлены три параметра типа беззнаковый байт, выраженные массивом.

Команды GLUT также имеют свои аффиксы, то есть кроме таких команд, как glutSolidTeapot, которая рисует чайник со сплошной заливкой, есть, скажем, и команда glutWireTeapot, которая рисует “проволочный” чайниик.

Упражнения.

    Модифицируйте всю программу на свой вкус и цвет. Измените размер окна, его заголовок, различные настройки.

    Кроме glutSolidTeapot, в библиотеке GLUT содержится еше множество различных команд для рисования объектов, например:

glutSolidCube(float size);

glutSolidDodecahedron();

glutSolidOctahedron();

glutSolidThetrahedron();

glutSolidIcosahedron();

Измените команду glutSolidTeapot на одну из этих и поупражняйтесь в рисовании геометрических тел. Также попробуйте применить аффикс “wire”. Примечание: размер рекомендую ставить от 0.1 до 2, помните, что наш чайник-гигант был размером только в 1.

Конечно же, у вас сразу возникло много вопросов. Действительно, очень странно, что чайник и другие объекты всегда рисуются в центре, а функции, их рисующие не имеют никаких параметров насчет координат. Все дело в том, что все объекты всегда рисуются в точке (0,0,0), а когда необходимо передвинуть или повернуть объект, мы поворачиваем или переносим систему координат относительно текущей. Но что же делать, если мы хотим один объект передвинуть, а другой оставить на месте? Ведь если мы передвинем один объект, а потом нарисуем другой, то другой объект тоже передвинется. Значит, надо все время запоминать на сколько мы сдвинулись и возвращаться назад. Слава богу, в OpenGL включены команды glPushMatrix() / glPopMatrix(), которые запоминают текущее “положение вещей” (PushMatrix) а потом восстанавливают то, что запомнили. Эти команды работают со стеком, поэтому их можно использовать вложенно. В OpenGL своя собственная система координат: ось X направлена вправо, ось Y – вверх, а ось Z – к наблюдателю. Да, и конечно, команды для поворота и переноса:

glRotatef(int angle, float x, y, z) – поворачивает систему координат на угол angle отпосительно вектора, который определен x, y и z. Я не рекомендую задавать x, y или z отличными от нуля и единицы, т.к. результат подобной операции не определен.

glTranslatef(float x, y, z) – перенос системы координат на x, y, z относительно текущей.

Посмотрите, например, на такой фрагмент кода:

glTranslatef(-0.4,0,0);

glutSolidTeapot(0.15);

glTranslatef(-0.4,0,0);

glutSolidTeapot(0.17);

glTranslatef(-0.4,0,0);

glutSolidTeapot(0.19);

Если добавить его в программу без дополнительных комманд, то вместо трех чайников, построенных в ряд по X в левую стовону, в первую секунду мы может, ещё что-нибуть увидим, а вот во вторую секунду – уже ничего. Чайники убегут влево с неимоверной быстротой. Почему? Ведь при прорисовке кадра система координат не возвращается в изначальное положение . И мы каждый кадр сдвигаемся влево на 1.2. Как это предотвратить? Очень просто:

glTranslatef(-0.4,0,0);

glutSolidTeapot(0.15);

glTranslatef(-0.4,0,0);

glutSolidTeapot(0.17);

glTranslatef(-0.4,0,0);

glutSolidTeapot(0.19);

Здесь команда glPushMatrix() запоминает текущее положение (0,0,0), потом рисуются чайники, каждый с относительным сдвигом в 0.2. Таким образом, третий чайник сдвинут на 0.6 относительно “абсолютного нуля” (первоначального положения). Я лично вам рекомендую обрамлять в комманды glPushMatrix()/glPopMatrix() все объекты независимо движущиеся, и всегда переносить и поворачивать их относительно “абсолютного нуля”. Иначе вы очень быстро запутаетесь, что относительно чего передвигалось. То же самое относится и к повороту, только тут запутаться проще:

glTranslatef(-0.4,0,0);

glRotatef(-90,1,0,0);

glutSolidTeapot(0.15);

glTranslatef(-0.4,0,0);

glRotatef(90,1,0,0);

glutSolidTeapot(0.19);

Что мы ожидаем увидеть? Конечно, два чайника, один лежит на одном боку, а другой на другом. А получаем: один лежит действительно на боку, а вот другой почему-то не сдвинулся с места. Не пугайтесь, здесь магии нет, просто первый glRotatef повернул всю систему координат, а второй повернул ее обратно. Правильный код:

glTranslatef(-0.4,0,0);

glRotatef(-90,1,0,0);

glutSolidTeapot(0.15);

glTranslatef(-0.4,0,0);

glRotatef(90,1,0,0);

glutSolidTeapot(0.19);

Как видвите, glPopMatrix()/glPushMatrix могут быть вложенными.

Несмотря на кажущуюся простоту, понять это – очень сложно для любого начинающего, и большинство ошибок случается чаще всего именно на эту тему. Поэтому я советую вам еще раз прочитать все выше сказанное.

Раз уж мы умеем вращать и перемещфть объекты, то неплохо было бы делать это динамически, анимированно. Для создания анимации в OpenGL существует множество разных способов, самый простой из них – просто выполнять анимацию при каждой прорисовке кадра, например:

void display(void)

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glColor3f(0.0,0.0,0.8);

glRotatef(r,1,1,0);

glutSolidTeapot(0.7);

if (r>=360) {r=0;};

glutSwapBuffers();

Но у этого подхода есть один, но очень существенный недотсаток: скорость вращения чайника будет зависеть от производительности компьютера. Т.е. на одном компьютере чайник обернется вокруг двух своих осей за 1 сек., а на другом – за 10 мин. Решение этой проблемы заключается в установке мультимедийного таймера. Он может выполнять функцию с интервалом до 1 мс (0.001 сек). Мультимедийный таймер очень точен и всегда стабилен.

uint timeSetEvent(UINT uDelay, UINT uResolution, LPTIMECALLBACK fptc, DWORD_PTR dwUser, UINT fuEvent) – устанавливает таймер и возвращает его идентификатор. Первый параметр – интервал таймера в миллисекундах, второй – количество миллисекунд, ограничивающих обработку каждого тика, т.е. точность. Если значение задано нулём, обработка таймера происходит с максимально возможной точностью. Третий параметр – процедура обработки тика, четвертый – значение, передаваемое этой процедуре. Последний параметр фиктивен – для установки переодического, а не одноразового таймера его надо задавать равным TIME_PERIODIC.

Вот пример его использования: (здесь я привел весь исходный код, и во избежание ошибок новые строки выделены).

#include

#include

#include

#include "glut.h"

#include

GLuint timerId;

void CALLBACK TimerProc(GLuint uTimerId, GLuint uMessage,

DWORD_PTR dwUser, DWORD_PTR dw1, DWORD_PTR dw2)

if (r>=360) {r=0;};

void resize(int width,int height)

glViewport(0,0,width,height);

glMatrixMode(GL_PROJECTION);

glLoadIdentity();

gluLookAt(0,0,5, 0,0,0, 0,1,0);

glMatrixMode(GL_MODELVIEW);

void display(void)

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glClearColor(0.0,0.0,0.0,1.0);

glColor3f(0.0,0.0,0.8);

glRotatef(r,1,1,0);

glutSolidTeapot(0.7);

glutSwapBuffers();

glutInitWindowPosition(50, 50);

glutInitWindowSize(640, 480);

glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);

glutCreateWindow("OpenGL1 Window");

glutIdleFunc(display);

glutDisplayFunc(display);

glutReshapeFunc(resize);

glEnable(GL_DEPTH_TEST);

glEnable(GL_COLOR_MATERIAL);

glEnable(GL_LIGHTING);

glEnable(GL_LIGHT0);

timerId=timeSetEvent(10, 0, TimerProc, 0, TIME_PERIODIC);

timeKillEvent(timerId);

Заметьте, что последней строкой мы уничтожаем таймер функцией timeKillEvent по идентификатору таймера. В функции, относящейся к таймеру я не произвожу рисования, иначе оно замедлило бы поворот чайника рисованием сцены.

Упражнения.

    Пусть по экрану носится чайник, отталкиваясь от стенок

    Теперь чайник должен носиться, вращаясь при этом вокруг своей оси (Подсказка: мы должны сначала переместить систему координат, а потом уже, относительно новых координат, поворачиваем его).

    Сделайте программу “парад объектов”, где будет изображено много различных объектов сразу в виде таблицы. Добавьте им различные скороти вращения

Итак, все вроде знаем: объекты какие-то умеем рисовать, анимацию делать, на 3D-игры вроде похоже. Но главный недостаток всех наших программ виден сразу: никакой реакции на действия пользователя. Даже alt+F4 почему-то не работает. Не бойтесь, здесь вас тоже ничего сложного не ожидает, все просто как… Ну, как все остальное.

glutKeyboardFunc(void (*func)(unsigned char key, int x, int y)) – устанавливает обработчик с клавиатуры. Параметр – функция обработки вида: void keyfunc(unsigned char key, int x, int y), где key – клавиша, x, y – оконные координаты мыши.

Вот пример:

#include

#include

#include

#include "glut.h"

void keyboard(unsigned char key, int x, int y)

switch (key) {

case "a": r++; break ;

case "z": r--; break ;

void resize(int width,int height)

glViewport(0,0,width,height);

glMatrixMode(GL_PROJECTION);

glLoadIdentity();

gluPerspective(45.0, width/height, 0.1,100);

gluLookAt(0,0,5, 0,0,0, 0,1,0);

glMatrixMode(GL_MODELVIEW);

void display(void)

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glClearColor(0.0,0.0,0.0,1.0);

glColor3f(0.0,0.0,0.8);

glRotatef(r,1,1,0);

glutSolidTeapot(0.7);

glutSwapBuffers();

glutInitWindowPosition(50, 50);

glutInitWindowSize(640, 480);

glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);

glutCreateWindow("OpenGL1 Window");

glutIdleFunc(display);

glutDisplayFunc(display);

glutReshapeFunc(resize);

glutKeyboardFunc(keyboard);

glEnable(GL_DEPTH_TEST);

glEnable(GL_COLOR_MATERIAL);

glEnable(GL_LIGHTING);

glEnable(GL_LIGHT0);

Вот и все! При нажатии клавиш ‘a’ и ‘z’ (только на английской раскладке клавиатуры) чайник будет вращаться в одну или в другую сторону, в зависимости от нажатой клавиши. Но glutKeyboardFunc не обрабатывает такие клавиши, как: стрелки, Fx, insert и многие другие. Для этих клавиш существует функция

glutSpecialFunc(void (*func)(unsigned char key, int x, int y)) – все то же самое, что и glutKeyboardFunc, но вместо кода клавиши передается специфический идентификатор, который может быть:

GLUT_KEY_Fx – Fx.

GLUT_KEY_LEFT – Стрелка влево.

GLUT_KEY_UP – Стрелка вверх.

GLUT_KEY_RIGHT – Стрелка вправо.

GLUT_KEY_DOWN – Стрелка вниз.

GLUT_KEY_PAGE_UP – Page up.

GLUT_KEY_PAGE_DOWN – Page down.

GLUT_KEY_HOME – Home.

GLUT_KEY_END – End.

GLUT_KEY_INSERT – Insert.

Примечание: delete, backspace, enter, escape передаются в функцию glutKeyboardFunc.

Все, с клавиатурой вроде разобрались. Да, конечно же, совсем забыл:

int glutGetModifiers() – возвращает, нажаты ли Alt, Control, Shift. Возвращаемые значения:

GLUT_ACTIVE_SHIFT – если нажат Shift (или Caps Lock включен).

GLUT_ACTIVE_CTRL - если нажат Control.

GLUT_ACTIVE_ALT - если нажат Alt.

А теперь мышка:

glutMouseFunc(void (*func)(int button, int state, int x, int y)) – устанавливает обработчик клика мышки. Параметр – функция, где button:

GLUT_LEFT_BUTTON – левая кнопка.

GLUT_MIDDLE_BUTTON – средняя кнопка.

GLUT_RIGHT_BUTTON – правая кнопка.

State может быть:

GLUT_UP – кнопка отпущена.

GLUT_DOWN – кнопка нажата.

X, Y – координаты мыши в окне.

Еще есть функция

glutMotionFunc(void (*func)(int x, int y)) – устанавливает обработчик, вызываемый при нажатой левой кнопке и перемещении мышки. Параметр – функция, где x,y – оконные координаты мыши.

Эту функцию можно использовать для вращения сцены с помощью мыши, это бывает очень полезно, если мы хотим осмотреть сцену со всех сторон. Конечно, вращение по Z нереализуемо по причине того, что мышь ездит по плоскости. Вот пример программы, где таким образом поворачивается чайник:

#include

#include

#include

#include "glut.h"

int rx=0;

int ry=0;

Переменные для поворота по x и по y.

int oX=-1;

int oY=-1;

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

void mouserot (int x , int y )

if (oX >(-1))

ry += x - oX ;

rx += y - oY ;

Собственно функция разворота. Если мы можем получить предыдущее положение, то к rY прибавляем отличие старой и новой координаты X а к rX – отличие страрого Y от нового. Заключительный шаг: сохраняем текущую позицию в качетве старой. Заметьте, координаты несколько запутаны, но это сделано специально для большей удобности вращения.

void resize(int width,int height)

glViewport(0,0,width,height);

glMatrixMode(GL_PROJECTION);

glLoadIdentity();

gluPerspective(45.0, width/height, 0.1,100);

gluLookAt(0,0,5, 0,0,0, 0,1,0);

glMatrixMode(GL_MODELVIEW);

void display(void)

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glClearColor(0.0,0.0,0.0,1.0);

glColor3f(0.0,0.0,0.8);

glRotatef(rx,1,0,0);

glRotatef(ry,0,1,0);

glutSolidTeapot(0.7);

glutSwapBuffers();

glutInitWindowPosition(50, 50);

glutInitWindowSize(640, 480);

glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);

glutCreateWindow("OpenGL1 Window");

glutIdleFunc(display);

glutDisplayFunc(display);

glutReshapeFunc(resize);

glutMotionFunc(mouserot);

glEnable(GL_DEPTH_TEST);

glEnable(GL_COLOR_MATERIAL);

glEnable(GL_LIGHTING);

glEnable(GL_LIGHT0);

Теперь, как видите чайник поворачивается с помощью мыши. Для этих целей также можно использовать функицию glutPassiveMouseFunc, которая вызывает обработчик, когда перемещение мыши совершилось без нажатия.

Упражнения

    Напишите программу, которая при событиях, поступающих с клавиатуры выдавала бы подробную информацию на стандартный вывод (второе окно вашей программы, запись информации туда осуществляется с помощью printf)

    Сделайте то же самое и для мыши, но при этом записывайте все данные в log-файл.

    Напишите программу “просмотр объектов”, в которой можно будет выбирать, перемещать, изменять, вращать объект с помощью мыши и клавиатуры.

Как же рисуются все остальные объекты? Или с помощью OpenGL нам только чайники да тетраэдры придется рисовать? Конечно нет, в OpenGL существует множество комманд, облегчающих рендеринг таких объектов, как диск, сфера, цилиндр, конус, тор (кольцо). И конечно же, линия, точка, треугольник, полигон.

glutSolidSphere(GLdouble radius, GLint slices, GLint stacks) – рисует сферу. Первый параметр – радиус сферы. Второй – количество делений вокруг оси Z (как линии широты на глобусе). Третий – кол-во делений вдоль оси Z (как линии долготы).

glutSolidCone(GLdouble base, GLdouble height, GLint slices, GLint stacks) – рисует конус. Первый параметр – радиус базы, второй – высота. Третий и четвертый – см. glutSolidSphere.

glutSolidTorus(GLdouble innerRadius, GLdouble outerRadius, GLint sides, GLint rings) – рисует тор. Первый параметр – общий радиус, второй – толщина. Третий – кол-во сторон на каждом круговом делении. Четвертый – круговые деления.

Естественно, чем больше параметры slices, stacks, sides, rings, тем более качетвенная получается фигура. Уменьшая эти параметры у сферы можно добиться очень интересных эффектов, например сфера со slices=40, stacks=4 выглядит достаточно странно (для сферы, а не для клетки). (Она изображена на рисунке).

Да ну, зачем нам эти дурацкие торы да конусы. Нам бы попроще чего, треугольник, например. В OpenGL для всех примитивов, строящихся по точкам существуют три унифицированные комманды: glBegin, glVertex и glEnd. Перед тем, как нарисовать объект, мы вызываем glBegin c параметром, обозначающим тип объекта, он может быть:

GL_POINTS – точки

GL_LINES – линии (каждые две вершины образуют линию)

GL_LINE_STRIP – вершины последовательно соединянются линиями

GL_LINE_LOOP – то же, что GL_LINE_STRIP, но последняя вершина соединяется с первой.

GL_TRIANGLES – треугольники (каждые три вершины образуют треугольник)

GL_TRIANGLE_STRIP – связанная группа треугольников. Три первых вершины образуют первый треугольник, с первой по четвертую – второй, и т.д.

GL_TRIANGLE_FAN – первая вершина – общая для всех треугольников.

GL_QUADS – четырехугольники (каждые четыре вершины образуют четырехугольник)

GL_QUAD_STRIP – связанные четырехугольники. Первый четырехугольник – вершины 1,2,3,4, второй – 2,3,4,5. И т.д.

GL_POLYGON – выпуклый многоугольник (каждые скобки glBegin/glEnd – один многоугольник).

Потом идут команды glVertex, которые указывают координаты вершин. Эта команда имеет множество суффиксов, также как glColor,например, для обозначения точки в трехмерном пространстве, заданной массивом из float, комманда будет такой: glVertex3fv.

После того, как мы нарисовали объект, надо завершить рисование командой glEnd.

Также есть комманды:

glLineWidth(float size) – задает ширину линий, равную size.

glPointSize(float size) – задает величину точек, равную size.

glPolygonmode(int origin, int mode) – задает режим рисования полигонов (треугольников, четырехугольников, etc.) Первый параметр может принимать значения:

GL_FRONT – для лицевой стороны многоугольников

GL_BACK – для задней стороны

GL_FRONT_AND_BACK – для обоих сторон

Второй параметр может быть:

GL_POINT – точками

GL_LINE – линиями

GL_FILL – сплошной заливкой.

Интересный эффект можно получить у линий и многоугольников, крася их вершины в разные цвета. Например, с помощью такого кода:

g
lBegin(GL_TRIANGLES);

glColor3f(0.0,0.0,0.8);

glVertex3f(-2,-2,0);

glColor3f(0.8,0.0,0.0);

glVertex3f(2,2,0);

glColor3f(0.0,0.8,0.0);

glVertex3f(-2,2,0);

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

Отключать/включать этот эффект можно вызвав команду glShadeModel c аргументом GL_FLAT/GL_SMOOTH.

С помощью glEnable/glDisable(GL_POLYGON_SMOOTH (или GL_LINE_SMOOTH)) можно включить/выключить сглаживание полигонов или линий.

Внимание: многие команды недоступны внутри скобок glBegin/glEnd.

Н
о наши треугольники и четырехугольники получаются странными и некрасивыми: как их не разворачивай, цвет всегда получишь одинаковый. Даже грани непонятно где: все одного цвета. Для того, чтобы полигоны выглядели реалистичнее, необходимо всегда задавать нормали. Обычная фасетная нормаль – вектор-перпендикуляр единичной длины. Нормали необходимы для правильного расчета освещения. Есть несколько видов нормалей, в том числе и гладкие, которые придают даже грубому объекту гладкость. (На рисунке: сверху – куб без просчета нормалей, снизу – с фасетными нормалями). Вот фукнция для просчета фасетной нормали треугольника:

void calcnorm(float v1, float v2, float v3, float &nx, float &ny, float &nz)

float wrki, vx1, vy1, vz1, vx2, vy2, vz2;

// Вектор-перпендикуляр к центру.

nx = vy1 * vz2 - vz1 * vy2;

ny = vz1 * vx2 - vx1 * vz2;

nz = vx1 * vy2 - vy1 * vx2;

// Чтоб он был длины 1...

wrki = sqrt(nx*nx + ny*ny + nz*nz);

if (wrki==0) {wrki=1;};

Первые три паравметра – массивы из координат точек треугольника. (Первый элемент – x, второй – y, третий – z). Следующие три – ссылки на переменные с нормалями. Примечание: создатели GLUT уже позаботились о нас, и все объекты из этой библиотеки рисуются с просчитанными нормалями.

А если мы нарисовали много объектов сразу и хотим их повторять? Нам что ли каждый раз повторять одни и те же команды? Или, например, загрузили мы объект из файла, нарисовали его в процессе загрузки, а потом приходится хранить огромные объемы памяти, для того, что бы можно было нарисовать этот объект в любой момент. К счастью, в OpenGL присутствует механизм “дисплейных списков” (display lists), с помощью которых можно запомнить почти неограниченное количество команд и потом воспроизвети их одним махом.

Для создания дисплейных списков служит команда glNewList. Первый ее аргумент обозначает имя списка (не совсем имя. Все “имена” в OpenGL являются числами типа GLuint), второй всегда должен быть GL_COMPILE. Далее следуют команды, которые, собственно и образуют список. (Ими могут быть любые команды OpenGL). Заканчивает список команда glEndList(). Чтобы вызвать список (выполнить все его команды) служит команда glCallList(GLuint name), которая вызывает список с именем name. Если непонятно, какое имя придать списку (ведь имя уже может использоваться), можно вызвать команду GLuint glGenLists(GLint range), которая возвращает подходящее незанятое имя для range списков. (О вызове нескольких списков сразу мы поговорим позже). Например:

#include

#include

#include

#include "glut.h"

int triangle;

int cube;

int scene;

Имена различных списков: для треугольника, для куба и всей сцены.

void prepare()

triangle=glGenLists(1);

cube =glGenLists(1);

scene =glGenLists(1);

Даем каждому из них уникальное имя.

glNewList(triangle, GL_COMPILE);

glPushMatrix();

glBegin(GL_TRIANGLES);

glColor3f(1,0,0);

glVertex3f(2,2,0.1);

glColor3f(0,1,0);

glVertex3f(-2,-2,-0.1);

glVertex3f(2,-2,-0.1);

glEnd();

glPopMatrix();

glEndList();

glNewList(cube, GL_COMPILE);

glPushMatrix();

glRotatef(30,1,1,0);

glColor3f(0.3,0.3,0.7);

glutSolidCube(1.3);

glPopMatrix();

glEndList();

glNewList(scene, GL_COMPILE);

glCallList(triangle);

glCallList(cube);

glEndList();

Как видите, списки могут быть и вложенные.

void resize(int width,int height)

glViewport(0,0,width,height);

glMatrixMode(GL_PROJECTION);

glLoadIdentity();

gluPerspective(45.0, height/height, 0.1,100);

gluLookAt(0,0,5, 0,0,0, 0,1,0);

glMatrixMode(GL_MODELVIEW);

void display(void)

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glClearColor(0.0,0.0,0.0,1.0);

glCallList(scene);

Вместо рисования просто вызываем список, содержащий треугольник и куб.

glutSwapBuffers();

glutInitWindowPosition(50, 50);

glutInitWindowSize(640, 480);

glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);

glutCreateWindow("OpenGL1 Window");

glutIdleFunc(display);

glutDisplayFunc(display);

glutReshapeFunc(resize);

glEnable(GL_DEPTH_TEST);

glEnable(GL_COLOR_MATERIAL);

glEnable(GL_LIGHTING);

glEnable(GL_LIGHT0);

prepare();

Упражнения .

    Нарисуйте что-нибудь интересное, например снеговика или автомобиль. Теперь ваши фантазии не ограничены. Пусть ваши мечты о трехмерной графике станут реальностью!

Все картинки, которые мы до сих пор получали, были не слишком реалистичные. До сих пор непонятно, куда и откуда у нас светит источник света. Включить–то мы его включили, а где он, не определили. Для указания различных параметров источник света существует унифицированная команда

glLightf[v](GLenum light, GLenum name, GLfloat *params) – устанавливает какой-то параметр c именем name для источника света light (их может быть максимум 8, различные источники света задаются константами GL_LIGHT0 ... GL_LIGHT7). Параметров существует масса:

GL_POSITION – расположение источника света (Четвертый элемент здесь показывает, учитывать ли удаление объекта от источника света. Он должен быть равен 1. Первые три элемента – x,y,z.).

GL_SPOT_DIRECTION – направление источника света.

GL_AMBIENT – фоновая составляющая (цвет). Говоря короче, цвет, который поглощается объектами

GL_DIFFUSE – диффузная составляющая (цвет). Цвет, отражаемый объектами.

GL_SPECULAR – отраженный цвет. Т.е тот цвет, которым изображаются блики на поверхности объектов.

На рисунке изображен чайник, параметры источника света у которого таковы (Чайник все еше синий! Поэтому цвета сильно изменяются):

float lPos = {1.0,1.0,2.0,1.0};

float lDir = {0.0,0.0,1.0};

float lAmb = {0.5,0.0,0.0, 1.0}; // Темно-красный цвет

float lDiff = {0.0,0.5,0.0, 1.0}; // Темно-зеленый цвет

float lSpec = {1.0,1.0,1.0, 1.0}; // белый цвет

glLightfv(GL_LIGHT0, GL_POSITION, lPos);

glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, lDir);

glLightfv(GL_LIGHT0, GL_AMBIENT, lAmb);

glLightfv(GL_LIGHT0, GL_DIFFUSE, lDiff);

glLightfv(GL_LIGHT0, GL_SPECULAR, lSpec);

Рисунок наглядно демонстрирует смысл параметров GL_AMBIENT, GL_DIFFUSE и GL_SPECULAR. Впрочем, просто добавив этот код в функцию main, красивых бликов мы не увидим, т.к. не заданы свойства отражающей способности материала (и материал сейчас ничего не отражает). Для материала доступны те же самые параметры, что и для источника света, только изменяются они с помощью команды glMaterialf(GLenum face, GLenum pname, GLfloat param). Face может быть GL_FRONT(для лицевых сторон), GL_BACK (для задних) или GL_FRONT_AND_BACK (для всех сразу). Pname – те же самые GL_AMBIENT, GL_DIFFUSE, GL_SPECULAR плюс GL_EMISSION и GL_SHININESS. GL_EMISSION – цвет, который излучает материал. Например, ели мы хотим сделать солнце, вокруг которого вертятся какие-нибудь планеты, код рисования солнца будет такой:

Приложение 1. Установка всех необходимых компонентов и библиотек.

    Скачайте с моего сайта OpenGL 3 D . fatal . ru из раздела “разное” библиотеку GLUT.

    Скопируйте файл glut32.dll в каталог с вашей программой.

    Скопируйте файлы glut32.dll и glut.dll в каталог \windows\system\

    Скопируйте glut.lib и glut32.lib в каталог_где_установлен_MSVS7\ Vc7\lib\

    Скопируйте glut.h в каталог с вашей программой и в каталог_где_установлен_MSVS7\Vc7\include\

OpenGL.dll (Версию OpenGL от SGI), необходимую для компиляции некоторых примеров, можно скачать с моего сайта (раздел “разное”).

Эта статья не о самом OpenGL , а скорее о том, каким образом использовать совместно OpenGL и SFML .

Как вы знаете, одна из самых важных сторон OpenGL - переносимость на другие платформы. Но одного OpenGL недостаточно для создания завершенных приложений: вам потребуется окно, контекст рендеринга, пользовательский ввод, и так далее. У вас нету другого выбора, кроме как писать платформо-зависимый код для управления этими вещами. В этом месте модуль sfml-window выходит из тени. Давайте посмотрим, как он позволяет вам использовать OpenGL .

Включаем и линкуем OpenGL к вашему приложению

Заголовочные файлы OpenGL не одинаковы на разных операционных системах. Поэтому, SFML предоставляет "абстрактный" заголовочный файл, который позаботится о правильном подключении за вас.

#include

Этот заголовочный файл включает функции OpenGL и GLU , ничего более. Люди иногда думаю, что SFML автоматически подключает GLEW (библиотеку, которая дает управление над расширениями OpenGL ), потому что SFML использует GLEW внутри, но это технические детали. Со стороны пользователя, GLEW должен быть подключен также, как остальные библиотеки расширений.

Затем нам потребуется прилинковать к вашему приложению библиотеку OpenGL . К несчастью, такого же простого пути,как с заголовочными файлами, нету, и SFML не может предоставить общий принцип подключения OpenGL . Таким образом, вам нужно знать, какая библиотека прилинкована, в зависимости от используемой операционной системы ("opengl32 " в Windows , "GL" в Linux , и так далее). То же самое касается GLU , если вы хотите его использовать ("glu32 " в Windows , "GLU " в Linux , и так далее).

Функции OpenGL начинаются с префикса "gl ", функции GLU начинаются с префикса "glu ", Помните об это, когда будете получать ошибки при линковке - это поможет вам определить, какую библиотеку вы забыли прилинковать.

Создаем окно OpenGL

Так как SFML основан на OpenGL , его окна готовы для работы с функциями OpenGL безо всяких дополнительных действий.

Sf::Window window(sf::VideoMode(800, 600), "OpenGL"); // это работает без каких-либо дополнительных действий glEnable(GL_TEXTURE_2D); ...

В случае, если вы думаете, что это слишком автоматизировано, конструктор sf::Window имеет дополнительный аргумент, который позволяет изменить настройки основного контекста OpenGL . Этот аргумент - это экземпляр структуры sf::ContextSettings , который обеспечивает доступ к следующим настройкам:
depthBits - это количество битов на пиксель для использования в буфере глубины (0 , чтобы отключить его)
stencilBits - это количество бит на пиксель, чтобы использовать для буфера трафарета (0 , чтобы отключить его)
antialiasingLevel - это уровень мультисэмплинга
MajorVersion и MinorVersion содержат запрашиваемую версию OpenGL

Sf::ContextSettings settings; settings.depthBits = 24; settings.stencilBits = 8; settings.antialiasingLevel = 4; settings.majorVersion = 3; settings.minorVersion = 0; sf::Window window(sf::VideoMode(800, 600), "OpenGL", sf::Style::Default, settings);

Если какие-либо из этих настроек не поддерживаются графической картой, SFML попытается найти ближайшее схожее значение. Например, если 4х-антиалиасинг не поддерживается, SFML попытается использовать 2х, а если и это не поможет, то такая функция будет попросту отключена.
В любом случае, вы можете проверить, какие настройки SFML использует в данный момент с помощью функции getSettings :

Sf::ContextSettings settings = window.getSettings(); std::cout << "depth bits:" << settings.depthBits << std::endl; std::cout << "stencil bits:" << settings.stencilBits << std::endl; std::cout << "antialiasing level:" << settings.antialiasingLevel << std::endl; std::cout << "version:" << settings.majorVersion << "." << settings.minorVersion << std::endl;

OpenGL версии 3.0 и выше поддерживается в SFML (если поддерживается в драйвере видеокарты), но вы не сможете установить флаги на данный момент. Это означает, что вы не можете создать отладочный или совместимый контекст. На самом деле SFML автоматически создает контекст с "совместимыми" флагами, потому что он использует внутренние устаревшие функции. Это будет исправлено в ближайшее время и флаги будут выставлены также и в общественном API .

На OS X SFML поддерживается создание контекста OpenGL 3.2 используя профиль ядра. Помните, что эти контексты не совместимы с графическим модулем SFML. Если вы хотите использовать графический модуль, вам нужно использовать стандартный контекст с версией 2.1.

Типичное OpenGL-SFML приложение

Тут полный код минимального SFML приложения, использующего OpenGL :

#include #include int main() { // создаем окно sf::Window window(sf::VideoMode(800, 600), "OpenGL", sf::Style::Default, sf::ContextSettings(32)); window.setVerticalSyncEnabled(true); // загружаем ресурсы, инициализируем состояния OpenGL // запускаем главный цикл bool running = true; while (running) { // обрабатываем события sf::Event event; while (window.pollEvent(event)) { if (event.type == sf::Event::Closed) { // пора закрывать приложение running = false; } else if (event.type == sf::Event::Resized) { // применяем область просмотра, когда изменены размеры окна glViewport(0, 0, event.size.width, event.size.height); } } // очищаем буферы glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // рисуем // конец текущего кадра (меняем местами передний и задний буферы) window.display(); } // освобождаем ресурсы return 0; }

Здесь мы не используем window.isOpen() как условие в главном цикле, потому что нам нужно, чтобы окно оставалось открытым, пока приложение не закончит свою работу, поэтому у нас все еще будет к этому моменту валидный контекст OpenGL для последней итерации цикла и очистки ресурсов.

Не стесняйтесь посмотреть на примеры "OpenGL " и "Window " в SFML SDK , там вы увидите более развернутые объяснения, которые могут содержать ответы на ваши вопросы.

Управляем несколькими OpenGL окнами

Управление многими окнами OpenGL не намного сложнее, чем управление одним, здесь только стоит запомнить несколько важных вещей.

Вызовы OpenGL делаются в активном контексте (в активном окне). Таким образом, если вы хотите отрисовать два разных окна в одном приложении, вам нужно выбрать, какое окно будет активным, перед тем, как что-либо нарисовать. Для этого нужно использовать функцию setActive:

// активируем первое окно window1.setActive(true); // рисуем первое окно // активируем второе окно window2.setActive(true); // рисуем второе окно

Только один контекст (окно) может быть активно в потоке, поэтому вам не нужно деактивировать окно перед активацией другого, оно деактивируется автоматически. Таким образом работает OpenGL .

Другая вещь, которую нужно знать о контекстах OpenGL , созданных с помощью SFML - это разделение их ресурсов. Это значит, что вам не нужно перезагружать все ваши ресурсы OpenGL , когда вы пересоздаете окно. Только общие ресурсы OpenGL могут быть разделены между контекстами. Пример неразделяемого ресурса - буфер вершин.

OpenGL без окна

Иногда требуется вызвать функции OpenGL без активного окна и, соответственно, без контекста. Например, когда вы загружаете текстуры из разных потоков или перед тем, как первое из окон будет создано. SFML позволяет создавать полу-контекстные окна с помощью класса sf::Context . Все, что вам нужно сделать, это создать его экземпляр, чтобы получить правильный контекст.

Int main() { sf::Context context; // загружаем ресурсы OpenGL sf::Window window(sf::VideoMode(800, 600), "OpenGL"); ... return 0; }

Рисование в потоках

Типичное использование многопоточных приложений - это управление окном и его событиями в одном потоке (главном), и рисование в другом. Если вы так делаете, вам нужно кое-что запомнить: вы не можете активировать контекст (окно), если оно активировано в другом потоке. Это значит, что вам нужно деактивировать ваше окно перед запуском потока отрисовки.

Void renderingThread(sf::Window* window) { // активируем контекст окна window->setActive(true); // цикл отрисовки while (window->isOpen()) { // рисуем // конец текущего кадра - здесь функция отрисовки(требует контекст) window->display(); } } int main() { // создаем окно sf::Window window(sf::VideoMode(800, 600), "OpenGL"); // деактивируем его контексты OpenGL window.setActive(false); // запускаем поток отрисовки sf::Thread thread(&renderingThread, &window); thread.Launch(); // цикл событий\логики\чего-либо еще while (window.isOpen()) { ... } return 0; }

Использование OpenGL вместе с графическим модулем SFML

В этой статье описывается совместное использование OpenGL с модулем sfml-window , это очень легко, так как это единственная цель этого модуля. Использование совместно с графическим модулем немного сложнее: sfml-graphics тоже использует OpenGL , поэтому требуется усиленное внимание, чтобы состояния, заданные пользователем и внутри SFML не конфликтовали между собой.

Если вы еще не изучили графический модуль, то вам следует знать, что класс sf::Window заменен классом sf::RenderWindow , который содержит все его функции и добавляет функционал для отрисовки специальных сущностей SFML .

Единственный путь избежать конфликтов между состояниями SFML и вашими состояниями OpenGL - это сохранение\восстановление их каждый раз, когда вы переключаетесь между SFML и OpenGL .

Draw with OpenGL - save OpenGL states - draw with SFML - restore OpenGL states - draw with OpenGL ...

Простое решение - это позволить SFML делать это за вас,с помощью функций pushGLStates/popGLStates :

GlDraw... window.pushGLStates(); window.draw(...); window.popGLStates(); glDraw...

Так как SFML не знает всё о вашем коде OpenGL , он не может оптимизировать все шаги и в результате сохраняет\загружает все доступные состояния и матрицы OpenGL . Это может быть приемлемо для небольших проектов, но может существенно замедлять работу больших приложений, которые требуют максимальной производительности. В этом случае, вы можете управлять сохранением и загрузкой состояний OpenGL вручную, с помощью glPushAttrib/glPopAttrib , glPushMatrix/glPopMatrix , и так далее.
Если вы будете это делать, вам не нужно восстанавливать состояния SFML перед отрисовкой. Это будет сделано с помощью функции resetGLStates .

GlDraw... glPush... window.resetGLStates(); window.draw(...); glPop... glDraw...

Сохраняя и загружая состояния OpenGL собственноручно, вы можете использовать только те, которые вам реально необходимы, для снижения лишних вызовов драйвера.



Есть вопросы?

Сообщить об опечатке

Текст, который будет отправлен нашим редакторам: