Как сделать куб в OpenGL

Загрузить PDF
Загрузить PDF

OpenGL — это инструмент 3D-программирования, позволяющий создавать сложные трехмерные изображения из простых форм. Из этой статьи вы узнаете, как нарисовать с его поможью простой куб, который можно вращать в в трех измерениях!

Часть 1
Часть 1 из 3:

Первоначальная установка

Загрузить PDF
  1. 1
    Установите OpenGL. Начните с руководства по установке OpenGL на ваш компьютер. Если OpenGL и компилятор С у вас уже есть, можете пропустить этот шаг и перейти к следующему.
  2. 2
    Создайте документ. Создайте новый файл в своем любимом редакторе кода и сохраните его как mycube.c
  3. 3
    Добавьте #includes. Вот основные директивы #include, которые вам понадобятся. Важно помнить, что директивы для разных операционных систем — разные, а потому выбрать нужно все, чтобы программа была универсальной и ее можно было запустить в любой системе. 
       // Includes 
 #include 
 <stdio.h> 
  
 #include 
 <stdarg.h> 
  
 #include 
 <math.h> 
  
 #define GL_GLEXT_PROTOTYPES 
 #ifdef __APPLE__ 
 #include 
 <GLUT/glut.h> 
  
 #else 
 #include 
 <GL/glut.h> 
  
 #endif
  4. 4
    Добавьте функциональные прототипы и глобальные переменные. Следующим шагом будет объявить функциональные прототипы. 
       // Функциональные прототипы 
 void 
 display 
 (); 
 void 
 specialKeys 
 (); 
 // Глобальные переменные 
 double 
 rotate_y 
 = 
 0 
 ; 
 double 
 rotate_x 
 = 
 0 
 ;
  5. 5
    Задайте функцию main(). 
       int 
 main 
 ( 
 int 
 argc 
 , 
 char 
 * 
 argv 
 []){ 
 //  Инициализируем GLUT и обрабатываем пользовательские параметры 
 glutInit 
 ( 
 & 
 argc 
 , 
 argv 
 ); 
 //  Запрашиваем окно с поддержкой двойной буферизации, z-буферизации и цветовой схемы True Color 
 glutInitDisplayMode 
 ( 
 GLUT_DOUBLE 
 | 
 GLUT_RGB 
 | 
 GLUT_DEPTH 
 );
    • Это настройка нашей среды разработки. Важно помнить, что, работая над созданием программ OpenGL, вы должны запрашивать каждый параметр. Поэтому вам нужно хорошо понимать, как будет работать ваша программа и что нужно включить в необходимый вам функционал. В этой строке вы настроили отображение с двойной буферизацией, поддержкой цветов по RGB и z-буферизацией.
    • Двойная буферизация — это прием, позволяющий графическим программам избежать потенциальной проблемы с отображением изображений. Эта проблема может возникнуть в связи с тем, что при каждой перерисовке сцены необходимо сперва очистить дисплей, и только потом можно выводить новую информацию. Без двойной буферизации вы будете наблюдать мигающий эффект по мере того, как экран будет очищаться и зарисовываться снова и снова.
    • Эта проблема имеет простое решение: добавляется второй буфер для отрисовки. Изображение отрисовывается в первом буфере, который и выводится на экран. Следующий кадр будет отрисован уже во втором буфере, после чего кадры поменяются местами. Мы сразу же увидим содержимое второго буфера, а первый буфер, скрытый от нас вторым, будет в это самое время очищен и заполнен третьим кадром. И так далее...
    • Кроме того, вам понадобится поддержка цветов по схеме RGB .
    • Z-буферизация — это, собственно, то, что и создает эффект трехмерности. OpenGL использует трехмерную пространственную систему координат с осями x, y и z. Приближение объекта к зрителю и удаление его от зрителя — это изменение дистанции по оси z.
  6. 6
    Создайте окно. Теперь нужно создать окно , в котором и будет отрисован куб. Назовем его просто и без изысков — «Awesome Cube», то есть «Шикарный куб». 
       // Создаем окно 
 glutCreateWindow 
 ( 
 "Awesome Cube" 
 );
  7. 7
    Активируйте тест глубины. OpenGL — язык довольно строгий, подразумевающий, что никакие специальные функции не активированы. Нам же, чтобы должным образом отобразить трехмерный объект с помощью z-буфера, необходим тест глубины . Изучая OpenGL дальше, вы откроете для себя еще много функций, которые нужно активировать (освещение, текстуры и так далее). 
       //  Активируем тест глубины Z-буферизации 
 glEnable 
 ( 
 GL_DEPTH_TEST 
 );
  8. 8
    Добавьте функции обратного вызова. Вот функции обратного вызова для созданных нами ранее прототипов. Эти функции будут вызываться через основной цикл программы. Функция display будет перерисовывать сцену исходя из изменения значений переменных, которые были сделаны после прошлого их вызова. Функция specialKeys, в свою очередь, позволит нам взаимодействовать с программой. 
       // Функции обратного вызова 
 glutDisplayFunc 
 ( 
 display 
 ); 
 glutSpecialFunc 
 ( 
 specialKeys 
 );
  9. 9
    Запустите MainLoop. Последний шаг настройки — запуск MainLoop , основного цикла, с помощью которого мы будем вызвать основную функцию, обеспечивая анимацию и взаимодействие с пользователем, пока программа не будет закрыта. 
       //  Передаем контроль над событиями в GLUT 
 glutMainLoop 
 (); 
 //  Возвращаемся в ОС 
 return 
 0 
 ; 
 }
    Реклама
Часть 2
Часть 2 из 3:

Функция display()

Загрузить PDF
  1. 1
    Поймите назначение функции display(). Вся работа по отрисовке куба ляжет на хрупкие строчки этой функции. Идея в целом такова: вы нарисуете шесть отдельных граней куба и разместите их в соответствующих позициях.
    • Для каждой грани вы зададите четыре угла, а OpenGL соединит их линиями и выполнит заливку выбранным вами цветом. Ниже будет рассказано, как это сделать.
  2. 2
    Добавьте функцию glClear(). Первым делом, работая с этой функцией, нам надо очистить цвет и z-буфер . Без этого под новым рисунком будет виднеться старый, а нарисованные программой объекты будут расположены неправильно. 
       void 
 display 
 (){ 
 //  Очищаем экран и z-буфер 
 glClear 
 ( 
 GL_COLOR_BUFFER_BIT 
 | 
 GL_DEPTH_BUFFER_BIT 
 );
  3. 3
    Добавьте glBegin() и glEnd(). Объекты в OpenGL — это комбинации различных многоугольников. Команда glBegin() позволит нам с вами нарисовать объект — это как бы карандаш, которым вы рисуете фигуру, не отрывая его от бумаги. Чтобы оторвать карандаш от листа и начать рисовать что-то новое, нужна команда glEnd() . В данной статье мы будем использовать GL_POLYGON для отрисовки каждой грани куба, хотя для создания других форм можно воспользоваться и другими параметрами, такими как GL_LINE, GL_QUAD или GL_TRIANGLE.
    • Начните с передней стороны куба. Позже мы добавим цвет к каждой из шести граней.
      •  // Многоцветная сторона — ПЕРЕДНЯЯ 
 glBegin 
 ( 
 GL_POLYGON 
 ); 
 // Вершины добавим в следующем шаге 
 glEnd 
 ();
  4. 4
    Добавьте функцию glVertex3f(). Теперь, когда вы объяснили программе, что хотите начать рисовать многоугольник, нужно задать вершины объекта. У функции glVertex есть несколько форм, использование которых зависит от того, что вы намерены делать со своим объектом.
    • Первое — во скольких измерениях вы будете работать? Цифра 3 в in glVertex3f указывает на три измерения. Впрочем, можно работать и в 2, и в 4 измерениях. Буква f, в свою очередь, указывает на то, что мы работаем с цифрами с плавающей запятой. Впрочем, тут вы можете использовать и данные типов integer, double или short.
    • Заметьте, что все точки задаются против часовой стрелки. Пока это еще не очень важно, но когда вы начнете работать над освещением, текстурирование, обработкой нецелевых граней, то привычка прописывать все против часовой стрелки вам очень пригодится.
    • Добавьте вершины между линиями glBegin() и glEnd().


      •  // Многоцветная сторона — ПЕРЕДНЯЯ 
 glBegin 
 ( 
 GL_POLYGON 
 ); 
 glVertex3f 
 ( 
 - 
 0.5 
 , 
 - 
 0.5 
 , 
 - 
 0.5 
 ); 
 // P1 
 glVertex3f 
 ( 
 - 
 0.5 
 , 
 0.5 
 , 
 - 
 0.5 
 ); 
 // P2 
 glVertex3f 
 ( 
 0.5 
 , 
 0.5 
 , 
 - 
 0.5 
 ); 
 // P3 
 glVertex3f 
 ( 
 0.5 
 , 
 - 
 0.5 
 , 
 - 
 0.5 
 ); 
 // P4 
 glEnd 
 ();
  5. 5
    Добавьте функцию glColor3f(). glColor действует во многом аналогично glVertex. Точки можно задать данными типов short, integer, double или float. У каждого цвета есть значение от 0 до 1. Все нули — это черный цвет, все единицы — соответственно, белый. Цифра 3 в glColor3f() указывает на цветовую схему RGB без альфа-канала. Альфа-канал цвета отвечает за его прозрачность. Чтобы изменить значение альфа-канала, используйте glColor4f() с последним параметром от 0 до 1, то есть от непрозрачности до прозрачности.
    • Вызывая glColor3f(), мы отрисовываем каждую вершину от указанной точки в указанном цвете. Иными словами, если все четыре вершины должны быть красными, то просто один-единственный раз задайте значение цвета до вызова команд glVertex3f(), и все они будут красными.
    • На примере заданной ниже передней стороны можно увидеть, как задается новый цвет каждой вершины. Когда вы это делаете, то можете познакомиться с интересной особенностью цветов OpenGL. Так как каждая вершина многоугольника имеет свой цвет, OpenGL автоматически смешивает цвета! Код, размещенный дальше, показывает, как создать четыре вершины с одинаковым цветом.
      •  // Многоцветная сторона — ПЕРЕДНЯЯ 
 glBegin 
 ( 
 GL_POLYGON 
 ); 
 glColor3f 
 ( 
 1.0 
 , 
 0.0 
 , 
 0.0 
 ); 
 glVertex3f 
 ( 
 0.5 
 , 
 - 
 0.5 
 , 
 - 
 0.5 
 ); 
 // P1 красная 
 glColor3f 
 ( 
 0.0 
 , 
 1.0 
 , 
 0.0 
 ); 
 glVertex3f 
 ( 
 0.5 
 , 
 0.5 
 , 
 - 
 0.5 
 ); 
 // P2 зеленая 
 glColor3f 
 ( 
 0.0 
 , 
 0.0 
 , 
 1.0 
 ); 
 glVertex3f 
 ( 
 - 
 0.5 
 , 
 0.5 
 , 
 - 
 0.5 
 ); 
 // P3 синяя 
 glColor3f 
 ( 
 1.0 
 , 
 0.0 
 , 
 1.0 
 ); 
 glVertex3f 
 ( 
 - 
 0.5 
 , 
 - 
 0.5 
 , 
 - 
 0.5 
 ); 
 // P4 фиолетовая 
 glEnd 
 ();
  6. 6
    Нарисуйте другие грани куба. Лучше, конечно, если вы сами найдете местоположение остальных граней куба и каждой из вершин, но ради простоты мы рассчитали их для вас. Код приведен в финальной функции display() ниже. 
       // Белая сторона — ЗАДНЯЯ 
 glBegin 
 ( 
 GL_POLYGON 
 ); 
 glColor3f 
 ( 
 1.0 
 , 
 1.0 
 , 
 1.0 
 ); 
 glVertex3f 
 ( 
 0.5 
 , 
 - 
 0.5 
 , 
 0.5 
 ); 
 glVertex3f 
 ( 
 0.5 
 , 
 0.5 
 , 
 0.5 
 ); 
 glVertex3f 
 ( 
 - 
 0.5 
 , 
 0.5 
 , 
 0.5 
 ); 
 glVertex3f 
 ( 
 - 
 0.5 
 , 
 - 
 0.5 
 , 
 0.5 
 ); 
 glEnd 
 (); 
 // Фиолетовая сторона — ПРАВАЯ 
 glBegin 
 ( 
 GL_POLYGON 
 ); 
 glColor3f 
 ( 
 1.0 
 , 
 0.0 
 , 
 1.0 
 ); 
 glVertex3f 
 ( 
 0.5 
 , 
 - 
 0.5 
 , 
 - 
 0.5 
 ); 
 glVertex3f 
 ( 
 0.5 
 , 
 0.5 
 , 
 - 
 0.5 
 ); 
 glVertex3f 
 ( 
 0.5 
 , 
 0.5 
 , 
 0.5 
 ); 
 glVertex3f 
 ( 
 0.5 
 , 
 - 
 0.5 
 , 
 0.5 
 ); 
 glEnd 
 (); 
 // Зеленая сторона — ЛЕВАЯ 
 glBegin 
 ( 
 GL_POLYGON 
 ); 
 glColor3f 
 ( 
 0.0 
 , 
 1.0 
 , 
 0.0 
 ); 
 glVertex3f 
 ( 
 - 
 0.5 
 , 
 - 
 0.5 
 , 
 0.5 
 ); 
 glVertex3f 
 ( 
 - 
 0.5 
 , 
 0.5 
 , 
 0.5 
 ); 
 glVertex3f 
 ( 
 - 
 0.5 
 , 
 0.5 
 , 
 - 
 0.5 
 ); 
 glVertex3f 
 ( 
 - 
 0.5 
 , 
 - 
 0.5 
 , 
 - 
 0.5 
 ); 
 glEnd 
 (); 
 // Синяя сторона — ВЕРХНЯЯ 
 glBegin 
 ( 
 GL_POLYGON 
 ); 
 glColor3f 
 ( 
 0.0 
 , 
 0.0 
 , 
 1.0 
 ); 
 glVertex3f 
 ( 
 0.5 
 , 
 0.5 
 , 
 0.5 
 ); 
 glVertex3f 
 ( 
 0.5 
 , 
 0.5 
 , 
 - 
 0.5 
 ); 
 glVertex3f 
 ( 
 - 
 0.5 
 , 
 0.5 
 , 
 - 
 0.5 
 ); 
 glVertex3f 
 ( 
 - 
 0.5 
 , 
 0.5 
 , 
 0.5 
 ); 
 glEnd 
 (); 
 // Красная сторона — НИЖНЯЯ 
 glBegin 
 ( 
 GL_POLYGON 
 ); 
 glColor3f 
 ( 
 1.0 
 , 
 0.0 
 , 
 0.0 
 ); 
 glVertex3f 
 ( 
 0.5 
 , 
 - 
 0.5 
 , 
 - 
 0.5 
 ); 
 glVertex3f 
 ( 
 0.5 
 , 
 - 
 0.5 
 , 
 0.5 
 ); 
 glVertex3f 
 ( 
 - 
 0.5 
 , 
 - 
 0.5 
 , 
 0.5 
 ); 
 glVertex3f 
 ( 
 - 
 0.5 
 , 
 - 
 0.5 
 , 
 - 
 0.5 
 ); 
 glEnd 
 (); 
 glFlush 
 (); 
 glutSwapBuffers 
 (); 
 }
    • Обратите внимание на две последние строки. Это функции glFlush(); и glutSwapBuffers(); , дающие эффект двойной буферизации, о котором было рассказано выше.
    Реклама
Часть 3
Часть 3 из 3:

Интерактивность программы

Загрузить PDF
  1. 1
    Добавьте функцию specialKeys(). В принципе, все уже почти готово, однако куб только отрисовывается и не вращается. Для этого надо создать функцию specialKeys() , которая позволит вращать куб, нажимая на клавиши-стрелки!
    • Именно ради этой функции были объявлены глобальные переменные rotate_x и rotate_y. Когда вы будете нажимать на клавиши-стрелки «влево» и «вправо», значение rotate_y будет увеличиваться или уменьшаться на пять градусов. Аналогичным образом будем меняться и значение rotate_x, но уже при нажатии на клавиши-стрелки «вверх» и «вниз».
      •  void 
 specialKeys 
 ( 
 int 
 key 
 , 
 int 
 x 
 , 
 int 
 y 
 ) 
 { 
 //  Правая стрелка — увеличение вращения на 5 градусов 
 if 
 ( 
 key 
 == 
 GLUT_KEY_RIGHT 
 ) 
 rotate_y 
 += 
 5 
 ; 
 //  Левая стрелка — уменьшение вращения на 5 градусов 
 else 
 if 
 ( 
 key 
 == 
 GLUT_KEY_LEFT 
 ) 
 rotate_y 
 -= 
 5 
 ; 
 else 
 if 
 ( 
 key 
 == 
 GLUT_KEY_UP 
 ) 
 rotate_x 
 += 
 5 
 ; 
 else 
 if 
 ( 
 key 
 == 
 GLUT_KEY_DOWN 
 ) 
 rotate_x 
 -= 
 5 
 ; 
 //  Запрос обновления экрана 
 glutPostRedisplay 
 (); 
 }
  2. 2
    Добавьте glRotate(). Последнее, что мы сделаем, — добавим строку, которая позволит нам вращать объект. Вернитесь к функции display() и перед описанием ПЕРЕДНЕЙ стороны добавьте: 
       // Сброс трансформаций 
 glLoadIdentity 
 (); 
 // Вращение при изменении пользователем значений rotate_x и rotate_y 
 glRotatef 
 ( 
 rotate_x 
 , 
 1.0 
 , 
 0.0 
 , 
 0.0 
 ); 
 glRotatef 
 ( 
 rotate_y 
 , 
 0.0 
 , 
 1.0 
 , 
 0.0 
 ); 
 // Многоцветная сторона — ПЕРЕДНЯЯ 
 ....
    • Обратите внимание, что синтаксис glRotatef() , который схож с синтаксисом glColor3f() и glVertex3f(), но всегда требует указания четырех параметров. Первый — угол вращения в градусах. Следующие три — оси, по которым идет вращение, в порядке x, y, z. Пока что нам нужно вращать куб по двум осям, x и у.
    • Для всех трансформаций, которые мы задаем в программе, требуются аналогичные строки. По сути, мы представляем вращение объекта по оси х как изменение значения rotate_x, а вращение по оси у — как изменение значения rotate_y. Впрочем, OpenGL объединит все в одну матрицу трансформации. Всякий раз, вызывая функцию display, вы будете создавать матрицу трансформации, и glLoadIdentity() позволит начинать каждый раз с новой матрицы.
    • Другие функции трансформации, которым вы могли воспользоваться, — это glTranslatef() и glScalef(). Они аналогичны glRotatef(), за исключением того, что требуют лишь трех параметров: значения x, y и z для изменения и масштабирования объекта.
    • Чтобы все отображалось правильно, когда все три трансформации применены к одному объекту, нужно задавать трансформации в соответствующем порядке, а именно glTranslate, glRotate, glScale — и никогда иначе. OpenGL трансформирует объект, читая программу снизу вверх. Чтобы лучше это понять, представьте, как куб 1x1x1 будет выглядеть после всех трансформаций, если бы OpenGL применял их в том порядке, как те указаны (сверху вниз), а потом подумайте, как OpenGL обработает куб, читая инструкции снизу вверх.
  3. 3
    Добавьте следующие команды для двухкратного масштабирования куба по осям х и у, для вращения куба на 180 градусов по оси у, а также для перемещения куба на 0,1 по оси х. Убедитесь, что все соответствующие команды, включая ранее заданные команды glRotate(), указаны в правильном порядке. Если боитесь ошибиться, посмотрите финальную версию программы в конце статьи. 
       // Другие трансформации 
 glTranslatef 
 ( 
 0.1 
 , 
 0.0 
 , 
 0.0 
 ); 
 glRotatef 
 ( 
 180 
 , 
 0.0 
 , 
 1.0 
 , 
 0.0 
 ); 
 glScalef 
 ( 
 2.0 
 , 
 2.0 
 , 
 0.0 
 );
  4. 4
    Скомпилируйте и запустите код. Допустим, в качестве компилятора вы используете gcc, поэтому введите в терминал следующие команды: 
      На Linux:
gcc cube.c -o cube -lglut -lGL

./ mycube

На Mac:
gcc -o foo foo.c -framework GLUT -framework OpenGL
./ mycube

На Windows:
gcc -Wall -ofoo foo.c -lglut32cu -lglu32 -lopengl32
./ mycube
  5. 5
    Проверьте финальный код. Вот финальный код, созданный автором статьи, в котором не переведены комментарии. 
       // 
 // File:        mycube.c 
 // Author:      Matt Daisley 
 // Created:     4/25/2012 
 // Project:     Source code for Make a Cube in OpenGL 
 // Description: Creates an OpenGL window and draws a 3D cube 
 //              That the user can rotate using the arrow keys 
 // 
 // Controls:    Left Arrow  - Rotate Left 
 //              Right Arrow - Rotate Right 
 //              Up Arrow    - Rotate Up 
 //              Down Arrow  - Rotate Down 
 // ---------------------------------------------------------- 
 // Includes 
 // ---------------------------------------------------------- 
 #include 
 <stdio.h> 
  
 #include 
 <stdarg.h> 
  
 #include 
 <math.h> 
  
 #define GL_GLEXT_PROTOTYPES 
 #ifdef __APPLE__ 
 #include 
 <GLUT/glut.h> 
  
 #else 
 #include 
 <GL/glut.h> 
  
 #endif 
 // ---------------------------------------------------------- 
 // Function Prototypes 
 // ---------------------------------------------------------- 
 void 
 display 
 (); 
 void 
 specialKeys 
 (); 
 // ---------------------------------------------------------- 
 // Global Variables 
 // ---------------------------------------------------------- 
 double 
 rotate_y 
 = 
 0 
 ; 
 double 
 rotate_x 
 = 
 0 
 ; 
 // ---------------------------------------------------------- 
 // display() Callback function 
 // ---------------------------------------------------------- 
 void 
 display 
 (){ 
 //  Clear screen and Z-buffer 
 glClear 
 ( 
 GL_COLOR_BUFFER_BIT 
 | 
 GL_DEPTH_BUFFER_BIT 
 ); 
 // Reset transformations 
 glLoadIdentity 
 (); 
 // Other Transformations 
 // glTranslatef( 0.1, 0.0, 0.0 );      // Not included 
 // glRotatef( 180, 0.0, 1.0, 0.0 );    // Not included 
 // Rotate when user changes rotate_x and rotate_y 
 glRotatef 
 ( 
 rotate_x 
 , 
 1.0 
 , 
 0.0 
 , 
 0.0 
 ); 
 glRotatef 
 ( 
 rotate_y 
 , 
 0.0 
 , 
 1.0 
 , 
 0.0 
 ); 
 // Other Transformations 
 // glScalef( 2.0, 2.0, 0.0 );          // Not included 
 //Multi-colored side - FRONT 
 glBegin 
 ( 
 GL_POLYGON 
 ); 
 glColor3f 
 ( 
 1.0 
 , 
 0.0 
 , 
 0.0 
 ); 
 glVertex3f 
 ( 
 0.5 
 , 
 - 
 0.5 
 , 
 - 
 0.5 
 ); 
 // P1 is red 
 glColor3f 
 ( 
 0.0 
 , 
 1.0 
 , 
 0.0 
 ); 
 glVertex3f 
 ( 
 0.5 
 , 
 0.5 
 , 
 - 
 0.5 
 ); 
 // P2 is green 
 glColor3f 
 ( 
 0.0 
 , 
 0.0 
 , 
 1.0 
 ); 
 glVertex3f 
 ( 
 - 
 0.5 
 , 
 0.5 
 , 
 - 
 0.5 
 ); 
 // P3 is blue 
 glColor3f 
 ( 
 1.0 
 , 
 0.0 
 , 
 1.0 
 ); 
 glVertex3f 
 ( 
 - 
 0.5 
 , 
 - 
 0.5 
 , 
 - 
 0.5 
 ); 
 // P4 is purple 
 glEnd 
 (); 
 // White side - BACK 
 glBegin 
 ( 
 GL_POLYGON 
 ); 
 glColor3f 
 ( 
 1.0 
 , 
 1.0 
 , 
 1.0 
 ); 
 glVertex3f 
 ( 
 0.5 
 , 
 - 
 0.5 
 , 
 0.5 
 ); 
 glVertex3f 
 ( 
 0.5 
 , 
 0.5 
 , 
 0.5 
 ); 
 glVertex3f 
 ( 
 - 
 0.5 
 , 
 0.5 
 , 
 0.5 
 ); 
 glVertex3f 
 ( 
 - 
 0.5 
 , 
 - 
 0.5 
 , 
 0.5 
 ); 
 glEnd 
 (); 
 // Purple side - RIGHT 
 glBegin 
 ( 
 GL_POLYGON 
 ); 
 glColor3f 
 ( 
 1.0 
 , 
 0.0 
 , 
 1.0 
 ); 
 glVertex3f 
 ( 
 0.5 
 , 
 - 
 0.5 
 , 
 - 
 0.5 
 ); 
 glVertex3f 
 ( 
 0.5 
 , 
 0.5 
 , 
 - 
 0.5 
 ); 
 glVertex3f 
 ( 
 0.5 
 , 
 0.5 
 , 
 0.5 
 ); 
 glVertex3f 
 ( 
 0.5 
 , 
 - 
 0.5 
 , 
 0.5 
 ); 
 glEnd 
 (); 
 // Green side - LEFT 
 glBegin 
 ( 
 GL_POLYGON 
 ); 
 glColor3f 
 ( 
 0.0 
 , 
 1.0 
 , 
 0.0 
 ); 
 glVertex3f 
 ( 
 - 
 0.5 
 , 
 - 
 0.5 
 , 
 0.5 
 ); 
 glVertex3f 
 ( 
 - 
 0.5 
 , 
 0.5 
 , 
 0.5 
 ); 
 glVertex3f 
 ( 
 - 
 0.5 
 , 
 0.5 
 , 
 - 
 0.5 
 ); 
 glVertex3f 
 ( 
 - 
 0.5 
 , 
 - 
 0.5 
 , 
 - 
 0.5 
 ); 
 glEnd 
 (); 
 // Blue side - TOP 
 glBegin 
 ( 
 GL_POLYGON 
 ); 
 glColor3f 
 ( 
 0.0 
 , 
 0.0 
 , 
 1.0 
 ); 
 glVertex3f 
 ( 
 0.5 
 , 
 0.5 
 , 
 0.5 
 ); 
 glVertex3f 
 ( 
 0.5 
 , 
 0.5 
 , 
 - 
 0.5 
 ); 
 glVertex3f 
 ( 
 - 
 0.5 
 , 
 0.5 
 , 
 - 
 0.5 
 ); 
 glVertex3f 
 ( 
 - 
 0.5 
 , 
 0.5 
 , 
 0.5 
 ); 
 glEnd 
 (); 
 // Red side - BOTTOM 
 glBegin 
 ( 
 GL_POLYGON 
 ); 
 glColor3f 
 ( 
 1.0 
 , 
 0.0 
 , 
 0.0 
 ); 
 glVertex3f 
 ( 
 0.5 
 , 
 - 
 0.5 
 , 
 - 
 0.5 
 ); 
 glVertex3f 
 ( 
 0.5 
 , 
 - 
 0.5 
 , 
 0.5 
 ); 
 glVertex3f 
 ( 
 - 
 0.5 
 , 
 - 
 0.5 
 , 
 0.5 
 ); 
 glVertex3f 
 ( 
 - 
 0.5 
 , 
 - 
 0.5 
 , 
 - 
 0.5 
 ); 
 glEnd 
 (); 
 glFlush 
 (); 
 glutSwapBuffers 
 (); 
 } 
 // ---------------------------------------------------------- 
 // specialKeys() Callback Function 
 // ---------------------------------------------------------- 
 void 
 specialKeys 
 ( 
 int 
 key 
 , 
 int 
 x 
 , 
 int 
 y 
 ) 
 { 
 //  Right arrow - increase rotation by 5 degree 
 if 
 ( 
 key 
 == 
 GLUT_KEY_RIGHT 
 ) 
 rotate_y 
 += 
 5 
 ; 
 //  Left arrow - decrease rotation by 5 degree 
 else 
 if 
 ( 
 key 
 == 
 GLUT_KEY_LEFT 
 ) 
 rotate_y 
 -= 
 5 
 ; 
 else 
 if 
 ( 
 key 
 == 
 GLUT_KEY_UP 
 ) 
 rotate_x 
 += 
 5 
 ; 
 else 
 if 
 ( 
 key 
 == 
 GLUT_KEY_DOWN 
 ) 
 rotate_x 
 -= 
 5 
 ; 
 //  Request display update 
 glutPostRedisplay 
 (); 
 } 
 // ---------------------------------------------------------- 
 // main() function 
 // ---------------------------------------------------------- 
 int 
 main 
 ( 
 int 
 argc 
 , 
 char 
 * 
 argv 
 []){ 
 //  Initialize GLUT and process user parameters 
 glutInit 
 ( 
 & 
 argc 
 , 
 argv 
 ); 
 //  Request double buffered true color window with Z-buffer 
 glutInitDisplayMode 
 ( 
 GLUT_DOUBLE 
 | 
 GLUT_RGB 
 | 
 GLUT_DEPTH 
 ); 
 // Create window 
 glutCreateWindow 
 ( 
 "Awesome Cube" 
 ); 
 //  Enable Z-buffer depth test 
 glEnable 
 ( 
 GL_DEPTH_TEST 
 ); 
 // Callback functions 
 glutDisplayFunc 
 ( 
 display 
 ); 
 glutSpecialFunc 
 ( 
 specialKeys 
 ); 
 //  Pass control to GLUT for events 
 glutMainLoop 
 (); 
 //  Return to OS 
 return 
 0 
 ; 
 }
    Реклама


Дополнительные статьи

Как
запустить файл Python с помощью Командной строки Windows
Как
написать программу в блокноте
Как
вставить пробелы в HTML
Как
добавить веб–сайт в надежные узлы
Как
добавлять и удалять учетные записи пользователей через командную строку Windows
Как
добавить горизонтальную линию в HTML
Как
научиться писать программы
Как
использовать Net Send
Как
скомпилировать программу C, используя компилятор GNU Compiler (GCC)
Как
менять цвета в Командной строке
Как
сделать задержку в командном файле
Как
создать гиперссылку в HTML
Как
использовать DOSBox
Как
создать базу данных в среде SQL Server
Реклама

Источники

  1. Установка OpenGL
  2. Руководства Nehe Productions по OpenGL
  3. OpenGL для начинающих, 3/E
  4. CSCI 4229 Introduction to Computer Graphics. Professor Schreüder, University of Colorado at Boulder

Об этой статье

На других языках
Эту страницу просматривали 39 898 раз.

Была ли эта статья полезной?

Реклама