OpenGL является на данный момент одним из самых популярных программных интерфейсов (API) для разработки приложений в области двумерной и трехмерной графики. Стандарт OpenGL был разработан и утвержден в 1992 году ведущими фирмами в области разработки программного обеспечения, а его основой стала библиотека IRIS GL, разработанная Silicon Graphics.
На данный момент реализация OpenGL включает в себя несколько библиотек (описание базовых функций OpenGL, GLU,GLUT,GLAUX и другие), назначение которых будет описано ниже.
Характерными особенностями OpenGL, которые обеспечили распространение и развитие этого графического стандарта, являются:
Стабильность - дополнения и изменения в стандарте реализуются таким образом, чтобы сохранить совместимость с разработанным ранее программным обеспечением.
Надежность и переносимость - приложения, использующие OpenGL, гарантируют одинаковый визуальный результат вне зависимости от типа используемой операционной системы и организации отображения информации. Кроме того, эти приложения могут выполняться как на персональных компьютерах, так и на рабочих станциях и суперкомпьютерах.
Легкость применения - стандарт OpenGL имеет продуманную структуру и интуитивно понятный интерфейс, что позволяет с меньшими затратами создавать эффективные приложения, содержащие меньше строк кода, чем с использованием других графических библиотек. Необходимые функции для обеспечения совместимости с различным оборудованием реализованы на уровне библиотеки и значительно упрощают разработку приложений.
Основные возможности OpenGL
Набор базовых примитивов: точки, линии, многоугольники и т.п.
Видовые и координатные преобразования
Удаление невидимых линий и поверхностей (z-буфер)
Использование сплайнов для построения линий и поверхностей
Наложение текстуры и применение освещения
Добавление специальных эффектов: тумана, изменение прозрачности,сопряжение цветов (blending), устранение ступенчатости (anti-aliasing).
Как уже было сказано, существует реализация OpenGL для разных платформ, для чего было удобно разделить базовые функции графической системы и функции для отображения графической информации и взаимодействия с пользователем. Были созданы библиотеки для отображения информации с помощью оконной подсистемы для операционных систем Windows и Unix (WGL и GLX соответственно), а также библиотеки GLAUX и GLUT, которые используются для создания так называемых консольных приложений.
Библиотека GLAUX уступает по популярности написанной несколько позже библиотеке GLUT, хотя они предоставляют примерно одинаковые возможности. В состав библиотеки GLU вошла реализация более сложных функций, таких как набор популярных геометрических примитивов (куб, шар, цилиндр, диск), функции построения сплайнов, реализация дополнительных операций над матрицами и т.п. Все они реализованы через базовые функции OpenGL.
Архитектура и особенности синтаксиса
С точки зрения архитектуры, графическая система OpenGL является конвейером, состоящим из нескольких этапов обработки данных:
Аппроксимация кривых и поверхностей
Обработка вершин и сборка примитивов
Растеризация и обработка фрагментов
Операции над пикселями
Подготовка текстуры
Передача данных в буфер кадра
Вообще, OpenGL можно сравнить с конечным автоматом, состояние которого определяется множеством значений специальных переменных (их имена обычно начинаются с символов GL_) и значениями текущей нормали, цвета и координат текстуры. Все эта информация будет использована при поступлении в систему координат вершины для построения фигуры, в которую она входит. Смена состояний происходит с помощью команд, которые оформляются как вызовы функций.
ИНИЦИАЛИЗАЦИЯ БИБЛИОТЕКИ OpenGL В C++
Первым делом нужно подключить заголовочные файлы:
#include
#include
#include
· gl.h и glu.h содержат прототипы основных функций OpenGL определённых в opengl32.dll и glu32.dll.
· glaux.h содержит вспомогательные (auxiliary) функции (glaux.dll).
После подключения заголовочных файлов нужно установить формат пикселей. Для этой цели используется следующая функция:
BOOL bSetupPixelFormat(HDC hdc)
PIXELFORMATDESCRIPTOR pfd, *ppfd;
int pixelformat;
ppfd->nSize = sizeof(PIXELFORMATDESCRIPTOR);
ppfd->nVersion = 1;
ppfd->dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
ppfd->dwLayerMask = PFD_MAIN_PLANE;
ppfd->iPixelType = PFD_TYPE_RGBA;
ppfd->cColorBits = 16;
ppfd->cDepthBits = 16;
ppfd->cAccumBits = 0;
ppfd->cStencilBits = 0;
if ((pixelformat = ChoosePixelFormat(hdc, ppfd)) == 0)
MessageBox(NULL, "ChoosePixelFormat failed", "Error", MB_OK);
if (SetPixelFormat(hdc, pixelformat, ppfd) == FALSE)
MessageBox(NULL, "SetPixelFormat failed", "Error", MB_OK);
Структура PIXELFORMATDESCRIPTOR сказать надо.
cColorBits - глубина цвета
cDepthBits - размер буфера глубины (Z-Buffer)
cStencilBits - размер буфера трафарета (мы его пока не используем)
iPixelType - формат указания цвета. Может принимать значения PFD_TYPE_RGBA (цвет указывается четырьмя параметрами RGBA - красный, зленный, синий и альфа) и PFD_TYPE_COLORINDEX (цвет указывается индексом в палитре).
Функция ChoosePixelFormat() подбирает формат пикселей и возвращает его дескриптор, а SetPixelFormat() устанавливает его в контексте устройства (dc).
После того как в контексте устройства установлен формат пикселей, нужно создать контекст воспроизведения (Rendering Context) для этого в OpenGL определены следующие функции:
HGLRC wglCreateContext(HDC hdc);
BOOL wglMakeCurrent(HDC hdc, HGLRC hglrc);
В объявлении класса формы в области private необходимо добавить следующее:
ghRC - указатель на контекст воспроизведения (Rendering Context)
ghDC - дескриптор устройства (для нас - просто указатель на окно)
Процедура Draw будет отвечать за рисование.
void __fastcall TForm1::FormCreate(TObject *Sender)
ghDC = GetDC(Handle);
if (!bSetupPixelFormat(ghDC))
ghRC = wglCreateContext(ghDC);
wglMakeCurrent(ghDC, ghRC);
glClearColor(0.0, 0.0, 0.0, 0.0);
FormResize(Sender);
glEnable(GL_COLOR_MATERIAL);
glEnable(GL_DEPTH_TEST);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
float p={3,3,3,1},
glLightfv(GL_LIGHT0,GL_POSITION,p);
glLightfv(GL_LIGHT0,GL_SPOT_DIRECTION,d);
glViewport(0, 0, Width, Height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-5,5, -5,5, 2,12);
gluLookAt(0,0,5, 0,0,0, 0,1,0);
glMatrixMode(GL_MODELVIEW);
glClearColor() устанавливает цвет, которым будет заполняться экран при очищении. У этой процедуры - 4 параметра, что соответствует RGBA. Вместо нее можно написать glClearIndex(0.0) . Эта процедура устанавливает индекс цвета в палитре.
glViewport() устанавливает область вывода - область, в которую OpenGL будет выводить изображение.
glMatrixMode() устанавливает режим матрицы видового преобразования.
glLoadIdentity() заменяет текущую матрицу видового преобразования на единичную.
glOrtho() устанавливает режим ортогонального (прямоугольного) проецирования. Это значит, что изображение будет рисоваться как в изометрии. 6 параметров типа GLdouble (или просто double): left, right, bottom, top, near, far определяют координаты соответственно левой, правой, нижней, верхней, ближней и дальней плоскостей отсечения, т.е. всё, что окажется за этими пределами, рисоваться не будет. На самом деле эта процедура просто устанавливает масштабы координатных осей. Для того чтобы установить перспективное проецирование, используются процедуры glFrustum() и gluPerspective().
gluLookAt() устанавливает параметры камеры: первая тройка - её координаты, вторая - вектор направления, третья - направление оси Y.
В OpenGL всё включается и выключается (разрешается и запрещается) процедурами glEnable() и glDisable().
glLightfv() устанавливает свойства "лампочек": позицию и направление света.
После того, как завершена работа с OpenGL, нужно освободить занятые ресурсы: освободить контекст, вызвав wglMakeCurrent с параметром ноль для идентификатора контекста OpenGL и разрушить этот контекст функцией wglDeleteContext. Кроме того нужно удалить дескриптор ghDC. Так как обычно работу с OpenGL завершается при завершении работы приложения, то соответствующий код нужно поместить в FormClose:
void __fastcall TForm1::FormClose(TObject *Sender, TCloseAction &Action)
wglMakeCurrent(ghDC,0);
wglDeleteContext(ghRC);
ReleaseDC(Handle, ghDC);
ЗАКЛЮЧЕНИЕ
За время прохождения производственной практики с 5 июля по 31 июля 2011 г. в ЗАО «Транзас», Авиационное направление в отделе программирования, я ознакомился с работой отдела программирования. Ознакомился с устройством и функционированием комплексных авиа тренажеров, разрабатываемых в ЗАО «Транзас». Я узнал о такой системе визуализации ландшафтов и различных объектов, как «Аврора». Я получил первоначальные практические навыки и умения, необходимые для разработки приложений и программного обеспечения с помощью современного высокоуровневого языка программирования и графической библиотеки.
Знакомство с OpenGL нужно начать с того, что OpenGL - это спецификация . Т.е. OpenGL лишь определяет набор обязательных возможностей. Реализация же зависит от конкретной платформы.OpenGL является кроссплатформенным, независимым от языка программирования API для работы с графикой. OpenGL - низкоуровневый API, поэтому для работы с ним неплохо иметь некоторое представление о графике в целом и знать основы линейной алгебры.
Именования
Скажем пару слов об именовании функций в OpenGL. Во-первых имена всех функций, предоставляемых непосредственно OpenGL, начинаются с приставки gl . Во-вторых функции, задающие некоторый параметр, характеризующийся набором чисел (например координату или цвет), имеют суффикс вида [число параметров + тип параметров + представление параметров].- Число параметров - указывает число принимаемых параметров. Принимает следующие значения: 1 , 2 , 3 , 4
- Тип параметров - указывает тип принимаемых параметров. Возможны следующие значения: b , s , i , f , d , ub , us , ui . Т.е. byte (char в C, 8-битное целое число), short (16-битное целое число), int (32-битное целое число), float (число с плавающей запятой), double (число с плавающей запятой двойной точности), unsigned byte, unsigned short, unsigned int (последние три - беззнаковые целые числа)
- Представление параметров - указывает в каком виде передаются параметры, если каждое число по отдельности, то ничего не пишется, если же параметры передаются в виде массива, то к названию функции дописывается буква v
Графика
Все графические объекты в OpenGL представляют собой набор точек, линий и многоугольников. Существует 10 различных примитивов, при помощи которых строятся все объекты. Как двухмерные, так и трехмерные. Все примитивы в свою очередь задаются точками - вершинами.- GL_POINTS - каждая вершина задает точку
- GL_LINES - каждая отдельная пара вершин задает линию
- GL_LINE_STRIP - каждая пара вершин задает линию (т.е. конец предыдущей линии является началом следующей)
- GL_LINE_LOOP - аналогично предыдущему за исключением того, что последняя вершина соединяется с первой и получается замкнутая фигура
- GL_TRIANGLES - каждая отдельная тройка вершин задает треугольник
- GL_TRIANGLE_STRIP - каждая следующая вершина задает треугольник вместе с двумя предыдущими (получается лента из треугольников)
- GL_TRIANGLE_FAN - каждый треугольник задается первой вершиной и последующими парами (т.е. треугольники строятся вокруг первой вершины, образуя нечто похожее на диафрагму)
- GL_QUADS - каждые четыре вершины образуют четырехугольник
- GL_QUAD_STRIP - каждая следующая пара вершин образует четырехугольник вместе с парой предыдущих
- GL_POLYGON - задает многоугольник с количеством углов равным количеству заданных вершин
Вот код рисующий квадрат с разноцветными вершинами:
- glBegin(GL_QUADS) ;
- glVertex2i(250 , 450 ) ;
- glVertex2i(250 , 150 ) ;
- glVertex2i(550 , 150 ) ;
- glVertex2i(550 , 450 ) ;
- glEnd() ;
Основы программы на OpenGL
Для платформонезависимой работы с окнами можно использовать библиотеку . GLUT упрощает работу с OpenGL.Для инициализации GLUT в начале программы надо вызвать glutInit (&argc, argv) . Для задания режима дисплея вызывается glutInitDisplayMode (режим) , где режим может принимать следующие значения:
- GLUT_RGBA - включает четырехкомпонентный цвет (используется по умолчанию)
- GLUT_RGB - то же, что и GLUT_RGBA
- GLUT_INDEX - включает индексированный цвет
- GLUT_DOUBLE - включает двойной экранный буфер
- GLUT_SINGLE - включает одиночный экранный буфер (по умолчанию)
- GLUT_DEPTH - включает Z-буфер (буфер глубины)
- GLUT_STENCIL - включает трафаретный буфер
- GLUT_ACCUM - включает буфер накопления
- GLUT_ALPHA - включает альфа-смешивание (прозрачность)
- GLUT_MULTISAMPLE - включает мультисемплинг (сглаживание)
- GLUT_STEREO - включает стерео-изображение
GLUT реализует событийно-управляемый механизм. Т.е. есть главный цикл, который запускается после инициализации, и в нем уже обрабатываются все объявленные события. Например нажатие клавиши на клавиатуре или движение курсора мыши и т.д. Зарегистрировать функции-обработчики событий можно при помощи следующих команд:
- void glutDisplayFunc (void (*func) (void)) - задает функцию рисования изображения
- void glutReshapeFunc (void (*func) (int width, int height)) - задает функцию обработки изменения размеров окна
- void glutVisibilityFunc (void (*func)(int state)) - задает функцию обработки изменения состояния видимости окна
- void glutKeyboardFunc (void (*func)(unsigned char key, int x, int y)) - задает функцию обработки нажатия клавиш клавиатуры (только тех, что генерируют ascii-символы)
- void glutSpecialFunc (void (*func)(int key, int x, int y)) - задает функцию обработки нажатия клавиш клавиатуры (тех, что не генерируют ascii-символы)
- void glutIdleFunc (void (*func) (void)) - задает функцию, вызываемую при отсутствии других событий
- void glutMouseFunc (void (*func) (int button, int state, int x, int y)) - задает функцию, обрабатывающую команды мыши
- void glutMotionFunc (void (*func)(int x, int y)) - задает функцию, обрабатывающую движение курсора мыши, когда зажата какая-либо кнопка мыши
- void glutPassiveMotionFunc (void (*func)(int x, int y)) - задает функцию, обрабатывающую движение курсора мыши, когда не зажато ни одной кнопки мыши
- void glutEntryFunc (void (*func)(int state)) - задает функцию, обрабатывающую движение курсора за пределы окна и его возвращение
- void glutTimerFunc (unsigned int msecs, void (*func)(int value), value) - задает функцию, вызываемую по таймеру
Первая программа
Теперь мы знаем основы работы с OpenGL. Можно написать простую программу для закрепления знаний.Начнем с того, что нужно подключить заголовочный файл GLUT:
Теперь мы уже знаем, что писать в main. Зарегистрируем два обработчика: для рисования содержимого окна и обработки изменения его размеров. Эти два обработчика по сути используются в любой программе, использующей OpenGL и GLUT.
- int main (int argc, char * argv )
- glutInit(& argc, argv) ;
- glutInitDisplayMode(GLUT_DOUBLE| GLUT_RGBA) ; /*Включаем двойную буферизацию и четырехкомпонентный цвет*/
- glutInitWindowSize(800 , 600 ) ;
- glutCreateWindow(«OpenGL lesson 1» ) ;
- glutReshapeFunc(reshape) ;
- glutDisplayFunc(display) ;
- glutMainLoop() ;
- return 0 ;
Теперь надо написать функцию-обработчик изменений размеров окна. Зададим область вывода изображения размером со все окно при помощи команды glViewport (х, у, ширина, высота) . Затем загрузим матрицу проекции glMatrixMode (GL_PROJECTION) , заменим ее единичной glLoadIdentity () и установим ортогональную проекцию. И наконец загрузим модельно-видовую матрицу glMatrixMode (GL_MODELVIEW) и заменим ее единичной.
В итоге получим:
- void reshape(int w, int h)
- glViewport(0 , 0 , w, h) ;
- glMatrixMode(GL_PROJECTION) ;
- glLoadIdentity() ;
- gluOrtho2D(0 , w, 0 , h) ;
- glMatrixMode(GL_MODELVIEW) ;
- glLoadIdentity() ;
Осталось только написать функцию рисования содержимого окна. Рисовать будем тот квадрат, что я приводил выше в качестве примера. Добавить придется совсем немного кода. Во-первых перед рисованием надо очистить различные буфера при помощи glClear (режим) . Используется также как и glutInitDisplayMode. Возможные значения:
- GL_COLOR_BUFFER_BIT - для очистки буфера цвета
- GL_DEPTH_BUFFER_BIT - для очистки буфера глубины
- GL_ACCUM_BUFFER_BIT - для очистки буфера накопления
- GL_STENCIL_BUFFER_BIT - для очистки трафаретного буфера
Получаем:
- void display()
- glClear(GL_COLOR_BUFFER_BIT) ;
- glBegin(GL_QUADS) ;
- glColor3f(1.0 , 1.0 , 1.0 ) ;
- glVertex2i(250 , 450 ) ;
- glColor3f(0.0 , 0.0 , 1.0 ) ;
- glVertex2i(250 , 150 ) ;
- glColor3f(0.0 , 1.0 , 0.0 ) ;
- glVertex2i(550 , 150 ) ;
- glColor3f(1.0 , 0.0 , 0.0 ) ;
- glVertex2i(550 , 450 ) ;
- glEnd() ;
- glutSwapBuffers() ;
Итог
Все! Можно компилировать. Должно получиться что-то вроде этого:Лабораторная работа № 2.
1. Введение
OpenGL – Open Graphics Library, открытая графическая библиотека. Термин "открытый" – означает независимый от производителей. Имеется спецификация (стандарт) на OpenGL, где все четко задокументировано и описано. Библиотеку OpenGL может производить кто угодно. Главное, чтобы библиотека удовлетворяла спецификации OpenGL и ряду тестов. Как следствие, в библиотеке нет никаких темных мест, секретов, недокументированных возможностей и т. п, те кто программировал под MS Windows или MS DOS понимают о чем я говорю. Библиотеку выпускают такие корпорации, как Microsoft, Silicon Graphics, а также просто группы программистов. Одним из таких примеров служит реализация Mesa. Эту библиотеку написали целый ряд программистов, главным автором является Brian Paul. Библиотека Mesa распространяется в исходных текстах на языке Си и собирается почти для любой операционной системы. Стандарт OpenGL развивается с 1992 года. Он разрабатывается фирмой Silicon Graphics. С тех пор библиотека завоевала огромную популярность и была интегрирована с множеством языков и систем разработки приложений. Вы можете писать программу с использованием OpenGL на Си, С++, Pascal, Java и многих других языках. Основное предназначение OpenGL программирование трехмерной графики.
Библиотека OpenGL представляет собой интерфейс программирования трехмерной графики. Единицей информации является вершина, из них состоят более сложные объекты. Программист создает вершины, указывает, как их соединять (линиями или многоугольниками), устанавливает координаты и параметры камеры и ламп, а библиотека OpenGL берет на себя работу создания изображения на экране. OpenGL идеально подходит для программистов, которым необходимо создать небольшую трехмерную сцену и не задумываться о деталях реализации алгоритмов трехмерной графики. Для профессионалов, занимающихся программированием трехмерной графики, библиотека тоже будет полезной, т. к. она представляет основные механизмы и выполняет определенную автоматизацию. Используя OpenGL можно с легкостью создать трехмерные поверхности, наложить на них текстуры, осветить источниками света, сделать эффект тумана, прозрачности, смешивания цветов, а также наложить трафарет, передвигать объекты сцены, лампы и камеры по заданным траекториям, сделав тем самым анимацию. OpenGL непосредственно не поддерживает работу с устройствами ввода, такими как мышь или клавиатура, т. к. эта библиотека является платформенно независимой. Но можно задействовать функции конкретной операционной системы, под которую вы пишите свою программу или воспользоваться надстройками над OpenGL, такими как библиотеки GLUT или GLAUX.
2. Первая программа
Самым простым объектом, с помощью которого можно увидеть всю мощь OpenGL, является сфера. Можно попытаться ее изобразить. Для этого надо создать новый проект в VisualC++, выполнив следующие действия:
— запустить Visual C++;
— выполнить команду File | New…;
— в открывшемся диалоговом окне выбрать тип проекта Win32 Application, в поле Project Name указать имя проекта, а в поле Location – папку в которой будет находиться проект;
— нажать кнопку OK. Затем, ничего не изменяя, – кнопку Finish и еще раз OK;
— скопировать в папку проекта два файла Sample. cpp и Sample. h (выдаются преподавателем);
— подключить эти два файла к проекту выполнив команду Project | Add To Project | Files…;
— вставьте в функцию Display следующий код:
GlColor3d(1,0,0);
AuxSolidSphere(1);
— создать exe-модуль (F7).
Поясним назначение вставленных двух функций. Функция glColor3d устанавливает текущий цвет, которым будут рисоваться фигуры. Тут нужно пояснить, как устанавливается цвет и общую философию в названии функций OpenGL. Цвет устанавливается четырьмя параметрами: красный, синий, зеленый и прозрачность. Эти параметры варьируются в диапазоне от нуля до единицы. Четвертый параметр нам пока не нужен, поэтому мы вызвали glColor с тремя параметрами. В этом случае, значение четвертого параметра, прозрачности, по умолчанию считается равным единице, т. е. абсолютно непрозрачным, ноль – будет абсолютно прозрачным. Применяется следующий синтаксис вызова функций – FuncionName[тип параметров].
Доступны следующие типы:
B – GLbyte байт;
S – GLshort короткое целое;
I – GLint целое;
F – GLfloat дробное;
D – GLdouble дробное с двойной точностью;
Ub – GLubyte беззнаковый байт;
Us – GLushort беззнаковое короткое целое;
Ui – GLuint беззнаковое целое;
V – массив из n параметров указанного типа;
В нашем случае – glColor3d – означает, что в функцию передается три параметра типа GLdouble. Также можно было вызвать glColor3i, т. е. три параметра типа GLint. Если тип параметров короткое целое, целое, байт или длинное, то компонента цвета приводится к диапазону . Приведение к этому диапазону осуществляется по следующим правилам. В случае беззнакового типа возможное наибольшее значение приводится к единице, ноль к нулю. В случае знакового максимальное значение приводится к единице или к минус единице, а минус единица будет приведена к единице. На практике обычно пользуются одним из трех случаев, рассмотренных в качестве примера ниже. Например, для беззнакового байта приведение будет осуществлено по следующей формуле: значение_переменной_хранимой_в_байте/255, т. к. 255 максимальное число, хранимое в одном байте. Функция glColor3dv означает, что в качестве параметров передается массив из трех элементов типа GLdouble. Например:
Double array = {0.5, 0.75, 0.3};
GlColor3dv(array);
GlColor3ub(200,100,0); // приводится к
// 200/256, 100/256, 0,256
GlColor3d(0.25,0.25,0); // темно-желтый
GlColot3ub(0,100,0); // темно-зеленый
GlColor3ub(0,0,255); // синий
3. Простые объекты. Общие положения
Точки, линии, треугольники, четырехугольники, многоугольники –простые объекты, из которых состоят любые сложные фигуры. OpenGL непосредственно не поддерживает функций для создания таких сложных объектов как сфера, цилиндр тор и др., т. е. таких функций нет в opengl32.dll. Эти функции есть в библиотеки утилит glu32.dll, и устроены они следующим образом. Для того чтобы нарисовать сферу функция auxSolidSphere использует функции из библиотеки glu32.dll, а те в свою очередь, используют базовую библиотеку opengl32.dll и из линий или многоугольников строят сферу. Примитивы создаются следующим образом:
GlBegin(mode); // указываем, что будем рисовать
glVertex(…); // первая вершина
… // тут остальные вершины
glVertex(…); // последняя
//вершина
GlEnd(); // закончили рисовать примитив
Сначала необходимо указать начало рисования – glBegin с соответствующим параметром.
Возможные значения mode перечислены ниже в таблице. Далее указываются вершины, определяющие объекты указанного типа. Обычно вершину задают одним из четырех способов.
GlVertex2d(x, y); // две переменных типа double
GlVertex3d(x, y,z); // три переменных типа double
GlVertex2dv(array); // массив из двух переменных типа
GlVertex3d(array); // массив из трех переменных типа
Void glEnd(void);
Указывает на конец рисования объектов типа, указанного в glBegin. Далее подробно разберем создание всех примитивов.
Таблица 1.
Возможные значения mode
|
Значение |
Описание |
|
Каждый вызов glVertex задает отдельную точку. |
|
|
Каждая пара вершин задает отрезок. |
|
|
Рисуется ломанная. |
|
|
Рисуется ломанная, причем ее последняя точка соединяется с первой. |
|
|
Каждые три вызова glVertex задают треугольник. |
|
|
GL_TRIANGLE_STRIP |
Рисуются треугольники с общей стороной. |
|
То же самое, но по другому правилу соединяются вершины. |
|
|
Каждые четыре вызова glVertex задают четырехугольник. |
|
|
Четырехугольники с общей стороной. |
|
|
Многоугольник. |
3.1. Точки
Можно нарисовать сколько угодно точек, вызывая glVertex3d, и тем самым, устанавливая новую точку. При создании точек можно изменять следующие параметры. Можно вызывать glColor3d внутри glBegin/glEnd. Размер точки можно устанавливать с помощью функции:
Void glPointSize(GLfloat size);
Режим сглаживания можно устанавливать вызовом функции
GlEnable(GL_POINT_SMOOTH);
Отключается соответственно вызовом glDisable(GL_POINT_SMOOTH). Последние функции – glPointSize и glEnable/glDisable надо вызывать вне glBegin/glEnd, иначе они будут проигнорированы. Функции glEnable/glDisable включают/выключают множество опций, но следует учитывать, что некоторые опции влекут за собой большие вычисления и, следовательно, изрядно затормаживают приложение, поэтому без надобности не стоит их включать.
// рисуем точки
GlBegin(GL_POINTS);
glColor3d(1,0,0);
glVertex3d(-4.5,4,0); // первая точка
glColor3d(0,1,0);
glVertex3d(-4,4,0); // вторая точка
glColor3d(0,0,1);
glVertex3d(-3.5,4,0); // третья
GlBegin(GL_POINTS);
glColor3d(1,0,0);
glVertex3d(-2,4,0); // первая точка
glColor3d(0,1,0);
glVertex3d(-1,4,0); // вторая точка
glColor3d(0,0,1);
glVertex3d(0,4,0); // третья
GlPointSize(10);
GlEnable(GL_POINT_SMOOTH);
GlBegin(GL_POINTS);
glColor3d(1,0,0);
glVertex3d(2,4,0); // первая точка
glColor3d(0,1,0);
glVertex3d(3,4,0); // вторая точка
glColor3d(0,0,1);
glVertex3d(4,4,0); // третья
GlDisable(GL_POINT_SMOOTH);
3.2. Линии
Для линий также можно изменять ширину, цвет, размер сглаживание. Если вы зададите разные цвета для начала и конца линии, то ее цвет будет переливающимся. OpenGL по умолчанию делает интерполяцию. Так же можно рисовать прерывистые линии, делается это путем наложения маски при помощи, следующей функции:
Void glLineStipple(GLint factor, GLushort pattern);
Второй параметр задает саму маску. Например, если его значение равно 255(0x00FF), то чтобы вычислить задаваемую маску воспользуемся калькулятором. В двоичном виде это число выглядит так: 0000000011111111, т. е. всего 16 бит. Старшие восемь установлены в ноль, значит, тут линии не будет. Младшие установлены в единицу, тут будет рисоваться линия. Первый параметр определяет, сколько раз повторяется каждый бит. Скажем, если его установить равным 2, то накладываемая маска будет выглядеть так:
GlLineWidth(1); // ширину линии
// устанавливаем 1
GlBegin(GL_LINES);
glColor3d(1,0,0); // красный цвет
glVertex3d(-4.5,3,0); // первая линия
glVertex3d(-3,3,0);
glColor3d(0,1,0); // зеленый
glVertex3d(-3,3.3,0); // вторая линия
glVertex3d(-4,3.4,0);
GlLineWidth(3); // ширина 3
GlBegin(GL_LINE_STRIP); // см. ниже
glColor3d(1,0,0);
glVertex3d(-2.7,3,0);
glVertex3d(-1,3,0);
glColor3d(0,1,0);
glVertex3d(-1.5,3.3,0);
glColor3d(0,0,1);
glVertex3d(-1,3.5,0);
GlEnable(GL_LINE_SMOOTH);
GlEnable(GL_LINE_STIPPLE); // разрешаем рисовать
// прерывистую линию
GlLineStipple(2,58360); // устанавливаем маску
// пояснения см. ниже
GlBegin(GL_LINE_LOOP);
glColor3d(1,0,0);
glVertex3d(1,3,0);
glVertex3d(4,3,0);
glColor3d(0,1,0);
glVertex3d(3,2.7,0);
glColor3d(0,0,1);
glVertex3d(2.5,3.7,0);
GlDisable(GL_LINE_SMOOTH);
GlDisable(GL_LINE_STIPPLE);
3.3. Треугольники
Для треугольника можно задавать те же параметры, что и для линии плюс есть еще одна функция
Void glPolygonMode(
Она устанавливает опции для прорисовки многоугольника. Возможные значения параметров функции приведены в таблице 2.
Таблица 2.
Значения параметров функции glPolygonMode
Первый параметр указывает, для каких сторон применяется опция, заданная вторым параметром. Треугольники можно рисовать, передав GL_TRIANGLE_STRIP или GL_TRIANGLE_FAN в glBegin. В первом случае первая, вторая и третья вершины задают первый треугольник. Вторая, третья и четвертая вершина — второй треугольник. Третья, четвертая и пятая вершина — третий треугольник и т. д. Вершины n, n+1 и n+2 определят n-ый треугольник. Во втором случае первая, вторая и третья вершина задают первый треугольник. Первая, третья и четвертая вершины задают второй треугольник и т. д. Вершины 1, n+1, n+2 определяют n-ый треугольник. Далее следует пример с комментариями.
GlPolygonMode(GL_FRONT_AND_BACK, GL_FILL); // см. выше
GlBegin(GL_TRIANGLES);
glColor3d(1,0,0); // рисуем треугольник
glVertex3d(-4,2,0);
glVertex3d(-3,2.9,0);
glVertex3d(-2,2,0);
//рисуем проволочные треугольники
GlBegin(GL_TRIANGLE_STRIP); // обратите внимание на
// порядок вершин
glColor3d(0,1,0);
glVertex3d(1,2,0);
glVertex3d(0,2.9,0);
glVertex3d(-1,2,0);
glVertex3d(0,1.1,0);
GlEnable(GL_LINE_STIPPLE);
GlPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
GlBegin(GL_TRIANGLE_FAN);
glColor3d(0,0,1);
glVertex3d(4,2,0);
glVertex3d(2.6,2.8,0);
glVertex3d(2,2,0);
glVertex3d(3,1.1,0);
GlDisable(GL_LINE_STIPPLE);
3.4. Четырехугольники и многоугольники
Четырехугольники рисуются вызовом функции glBegin с параметром GL_QUADS или GL_QUAD_STRIP. Для первого случая каждые четыре вершины определяют свой четырехугольник. Во втором случае рисуются связанные четырехугольники. Первая, вторая, третья и четвертая вершина определяют первый четырехугольник. Третья, четвертая, пятая и шестая вершина — второй четырехугольник и т. д. (2n-1), 2n, (2n+1) и (2n+2) вершины задают n-ый четырехугольник. Многоугольники задаются вызовом glBegin с параметром GL_POLYGON. Все вершины определяют один многоугольник. Для многоугольников можно задавать стили при помощи выше описанной функции glPolygonMode, толщину линии, толщину точек и цвет.
4. Переход к новым координатам
В предыдущем разделе вы научились рисовать примитивные трехмерные объекты. Но проблема в том, что они рисуются только в начале координат, т. е. в точке (0,0,0). Для того чтобы изобразить объект в точке (x0,y0,z0), надо переместить начало координат в эту точку, т. е. надо перейти к новым координатам. Эта процедура довольно распространенная при программировании графики и анимации. Часто, бывает очень удобно, сместить координаты в новую точку и повернуть их на требуемый угол, и ваши расчеты резко упростятся. Для перехода к новым координатам в OpenGL есть две функции:
Void glTranslated(Dx, Dy, Dz);
Void glRotated(j, x0,y0,z0);
Первая функция сдвигает начало системы координат на (Dx, Dy, Dz). Вторая — поворачивает на угол j против часовой стрелки вокруг вектора (x0,y0,z0). Теперь, стоит сказать еще о двух очень важных функциях:
Void glPushMatrix();
Void glPopMatrix();
Они предназначены для сохранения и восстановления текущих координат. Часто бывает неудобно переходить от одной системы координат к другой и помнить все переходы. Гораздо удобнее с помощью glPushMatrix() сохранить текущие координаты, потом сдвигаться, вертеться, как угодно, а после, вызовом glPopMatrix вернуться к старым координатам. Теперь можно поэкспериментировать. Рассмотрим сдвиг координат. Вставьте в функцию display следующий код:
GlTranslated(1.4,0,0);// сдвигаемся по оси Х на 1.4
GlColor3d(0,1,0);
AuxSolidSphere(0.5); // рисуем сферу в (1.4,0,0)
// в абсолютных координатах
GlTranslated(1,0,0); // еще раз сдвигаемся
GlColor3d(0,0,1);
AuxSolidSphere(0.3);
GlPopMatrix(); // возвращаемся к старой системе
// координат
GlColor3d(1,0,0);
AuxSolidSphere(0.75); // рисуем сферу в точке (0,0,0)
// в абсолютных координатах
5. Поворот координат
Теперь рассмотрим вращение координат. В функцию display вставьте следующий код:
GlColor3d(1,0,0);
AuxSolidCone(1, 2); // рисуем конус в центре координат
GlPushMatrix(); // сохраняем текущие координаты
glTranslated(1,0,0); // сдвигаемся в точку (1,0,0)
glRotated(75,1,0,0); // поворачиваем систему
// координат на 75 градусов
glColor3d(0,1,0);
auxSolidCone(1, 2); // рисуем конус
GlPopMatrix(); // возвращаемся к старым координатам
Как видите, конус повернулся в абсолютных координатах. Так что, для того, чтобы нарисовать фигуру не в начале координат, надо:
· сдвинуть(glTranslated), повернуть(glRotated);
· нарисовать то, что хотели;
· вернуться к старым координатам.
Вызовы glPushMatrix/PopMatrix могут быть вложенными, т. е.:
Естественно число вызовов glPopMatrix должно соответствовать числу вызовов glPushMatrix, иначе сцена улетит в неизвестном направление. Максимально допустимая глубина вложенности glPushMatrix/glPopMatrix определяется следующим образом:
GlGetIntegerv(GL_MAX_MODELVIEW_STACK_DEPTH, &n);
Printf("n=%d ",n);
Спецификация на OpenGL гарантирует, что глубина стека не может быть меньше 32.
6. Построение поверхностей
Существует набор функций для построения сфер, цилиндров и дисков. Эти функции представляют очень мощный контроль за построением трехмерных объектов. Для рисования поверхностей используются следующие функции:
GLUquadricObj * qobj,
GLdouble radius,
Void gluCylinder(
GLUquadricObj *qobj,
GLdouble baseRadius,
GLdouble topRadius,
GLdouble height,
GLUquadricObj *qobj,
GLdouble innerRadius,
GLdouble outerRadius,
Void gluPartialDisk(
GLUquadricObj *qobj,
GLdouble innerRadius,
GLdouble outerRadius,
GLdouble startAngle,
GLdouble sweepAngle
В начале занятия вы научились строить трехмерные объекты с помощью функций из библиотеки Auxilary Library. Функции auxSphere, auxCylinder и auxCone просто вызывают gluSphere и gluCylinder. В auxCylinder и auxCone фирмы Microsoft имеются баги. Здесь будет подробно рассмотрено построение сфер и цилиндров, так что потребность в auxCylinder и auxCone отпадет.
Первым параметром для gluSphere, gluCylinder, gluDisk и gluPartialDisk является указатель на объект типа GLUquadricObj. Далее следуют параметры непосредственно создаваемой фигуры. Для сферы – это радиус; для цилиндра – радиус нижнего основания, радиус верхнего основания и высота; для диска – внутренний радиус, внешний радиус и для частичного диска – внутренний радиус, внешний радиус, угол, с которого начинать рисовать, длина дуги в градусах, которую рисовать. Последние два параметра у всех этих функций одинаковы. Это число разбиений вокруг оси Z и число разбиений вдоль оси Z. Как известно, все сложные объекты состоят из простых: точек, линий и многоугольников. Понятно, что нарисовать (создать) идеально гладкую сферу или цилиндр невозможно. Поэтому строится приближение из плоскостей. Для этого и нужно указать количество разбиений. Чем больше разбиение, тем лучше будет выглядеть ваш объект. Однако, задавать здесь число с шестью нулями не стоит. Это лишено всякого смысла. Оптимальным является число от 10 до 20. Чем больше объект, тем больше нужно разбиений. Число разбиений (вдоль и поперек) лучше выставлять одинаковыми.
Сначала необходимо создать объект типа GLUquadricObj с помощью функции
GLUquadricObj * gluNewQuadric(void);
Затем нужно установить свойства с помощью функции
Void gluQuadricDrawStyle(
GLUquadricObj *qobj,
Glenum drawStyle
Доступны стили:
GLU_FILL – рисуется сплошной объект;
GLU_LINE – проволочный объект;
GLU_POINT – рисуются только точки.
Удалить созданный объект можно, воспользовавшись функцией
Void gluDeleteQuadric(GLUquadricObj * state);
Теперь можно поэкспериментировать. Измените функцию display следующим образом.
Void display(void)
GLUquadricObj * quadObj;
// создаем новый объект для создания сфер и цилиндров
quadObj = gluNewQuadric();
glColor3d(1,0,0);
// устанавливаем стиль: сплошной
gluQuadricDrawStyle(quadObj, GLU_FILL);
// рисуем сферу радиусом 0.5
gluSphere(quadObj, 0.5, 10, 10);
glTranslated(-2,0,0); // сдвигаемся влево
glRotated(45, 1,0,0); // поворачиваем
glColor3d(0,1,0);
// устанавливаем стиль: проволочный
gluQuadricDrawStyle(quadObj, GLU_LINE);
gluCylinder(quadObj, 0.5, 0.75, 1, 15, 15);
gluDeleteQuadric(quadObj);
auxSwapBuffers();
7. Плоскости отсечения
Если требуется нарисовать сферу или любой другой объект урезанным, то это можно сделать с помощью плоскости отсечения. Плоскостей отсечения может быть шесть. По умолчанию они все запрещены. Плоскость отсечения включается командой glEnable(GL_CLIP_PLANE0). Ноль на конце GL_CLIP_PLANE означает нулевую плоскость; можно указать один, два, три и т. д. Сама плоскость устанавливается функцией
Void glClipPlane(
const GLdouble *equation
Первый аргумент этой функции – это плоскость, второй – это массив из четырех элементов, в котором хранятся коэффициенты (A, B, C, D) уравнения плоскости: A*x + B*y + C*z + D = 0. Измените функцию display, как показано ниже.
Void display(void)
GLdouble equation = {-1,-0.25,0,2};
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_CLIP_PLANE0);
glClipPlane(GL_CLIP_PLANE0, equation);
glColor3d(1,0,0);
auxSolidSphere(3);
glDisable(GL_CLIP_PLANE0);
auxSwapBuffers();
8. Задания
1. Нарисовать куб представляющий собой пространство RGB. Вершины куба имеют цвета: R – красный, G – зеленый, B – синий, C – голубой, M – пурпурный, Y – желтый, W – белый, K – черный. Цвет каждого ребра плавно изменяется от цвета одной вершины до цвета другой.
После того, как куб нарисован, осуществить сдвиг его так, чтобы начало координат совпало с центром куба, а затем поворот вокруг оси OX на угол 30° и вокруг оси OZ на угол -20°.
2. Нарисовать сцену, в которой в начале координат изображается сфера радиуса r. На расстоянии R1 от первой сферы в некоторой точке (x1, y1, 0) изображается сфера с радиусом r1. От нее на расстоянии R2 в некоторой точке (x2, y2, 0) изображается сфера радиуса r2.
После того как сцена нарисована необходимо ее «оживить», т. е. заставить вращаться сферу r1 вокруг сферы r, а сферу r2 вокруг r1. Для этого необходимо объявить глобальные переменные f1 и f2 – углы поворота соответственно r1 вокруг r и r2 вокруг r1. Затем перед каждым выводом инкрементировать f1f2 на постоянные величины и вычислять x1, y1, x2, y2 по следующим формулам.
Отправить свою хорошую работу в базу знаний просто. Используйте форму, расположенную ниже
Студенты, аспиранты, молодые ученые, использующие базу знаний в своей учебе и работе, будут вам очень благодарны.
Размещено на http://www.allbest.ru/
OpenGL - это программный интерфейс к графической аппаратуре. Этот интерфейс состоит приблизительно из 250 отдельных команд (около 200 команд в самой OpenGL и еще 50 в библиотеке утилит), которые используются для указания объектов и операций, которые необходимо выполнить, чтобы получить интерактивное приложение, работающее с трехмерной графикой. оpengl программный интерфейс графический
Библиотека OpenGL разработана как обобщенный, независимый интерфейс, который может быть реализован для различного аппаратного обеспечения. По этой причине сама OpenGL не включает функций для создания окон или для захвата пользовательского ввода; для этих операций вы должны использовать средства той операционной системы, в которой вы работаете. По тем же причинам в OpenGL нет высокоуровневых функций для описания моделей трехмерных объектов. Такие команды позволили бы вам описывать относительно сложные фигуры, такие как автомобили, части человеческого тела или молекулы. При использовании библиотеки OpenGL вы должны строить необходимые модели при помощи небольшого набора геометрических примитивов - точек, линий и многоугольников (полигонов).
Тем не менее, библиотека, предоставляющая описанные возможности может быть построена поверх OpenGL. Библиотека утилит OpenGL (OpenGL Utility Library -- GLU) предоставляет множество средств для моделирования, например, квадрические поверхности, кривые и поверхности типа NURBS. GLU - стандартная часть любой реализации OpenGL. Существуют также и более высокоуровневые библиотеки, например, Fahrenheit Scene Graph (FSG), которые построены с использованием OpenGL и распространяются отдельно для многих ее реализаций.
В следующем списке коротко описаны основные графические операции, которые выполняет OpenGL для вывода изображения на экран.
1. Конструирует фигуры из геометрических примитивов, создавая математическое описание объектов (примитивами в OpenGL считаются точки, линии, полигоны, битовые карты и изображения).
2. Позиционирует объекты в трехмерном пространстве и выбирает точку наблюдения для осмотра полученной композиции.
3. Вычисляет цвета для всех объектов. Цвета могут быть определены приложением, получены из расчета условий освещенности, вычислены при помощи текстур, наложенных на объекты или из любой комбинации этих факторов.
4. Преобразует математическое описание объектов и ассоциированной с ними цветовой информации в пиксели на экране. Этот процесс называется растеризацией (или растровой разверткой).
В течение всех этих этапов OpenGL может производить и другие операции, например, удаление частей объектов, скрытых другими объектами. В дополнение к этому, после того, как сцена растеризована, но до того, как она выводится на экран, вы можете производить некоторые операции с пиксельными данными, если это необходимо.
Общий порядок работы с библиотекой OpenGl таков:
1. Инициализировать окно (получить область для вывода изображения)
2. Установить камеру
3. Включить свет (если это необходимо)
4. В цикле начать выводить примитивы (точки, линии, полигоны), предварительно очищая окно от предыдущего рисунка.
Инициализация окна.
Если вы работаете в Visual C++, то окно, создается при помощи функций
auxInitDisplayMode
Основной цикл рисования кадра создается в функции Draw и регистрируется при помощи функции
auxMainLoop(Draw);
static void CALLBACK Draw(void) // создается пользователем
// расположение окна OpenGL на экране
auxInitPosition(100, 100, windowW, windowH);
// установка основных параметров работы OpenGL
// цветовой режим RGB | включение Z-буфера для сортировки по глубине
// |Двойная буферизация
auxInitDisplayMode(AUX_RGB | AUX_DEPTH | AUX_DOUBLE);
// инициализация окна OpenGL с заголовком Title
if(auxInitWindow("Example1") ==GL_FALSE) auxQuit();
// регистрация функции, которая вызывается при перерисовке
// и запуск цикла обработки событий
// Draw() - функция пользователя
auxMainLoop(Draw);
Если вы работаете в Borland C++ Builder, то для инициализации окна, надо получить Handle (уникальный идентификатор окна Windows) того окна, на котором вы будите рисовать. Handle имеется у всех окон-приложений верхнего уровня и у большинства дочерних окон. В наших примерах мы будем рисовать на дочернем окне StaticText.
Далее мы должны создать Контекст рисования (device context) и установить его формат. Для этого инициализируется структуру PIXELFORMATDESCRIPTOR (формат описания пикселей). В этой структуре описывается, требуется ли нам поддержка буфера глубины, двойной буферизации и проч.).
Затем следуют функции:
ChoosePixelFormat
Создается контекст рисования OpenGL:
wglCreateContext(hdc);
А потом связываются контексты OpenGL и Windows:
wglMakeCurrent(hdc, hrc)
void __fastcall TFormMain::FormCreate(TObject *Sender)
// возьмем ХЕНДЛ окошка StaticText
static HWND Handle=a->Handle;
// создадим Хендл места рисования для окна StaticText
hdc = GetDC (Handle) ;
// устанавливаем соответствующие настройки контекста устройства
PIXELFORMATDESCRIPTOR pfd = {
sizeof(PIXELFORMATDESCRIPTOR),
PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
// выбрать соответствующий формат
PixelFormat = ChoosePixelFormat(hdc, &pfd);
SetPixelFormat(hdc, PixelFormat, &pfd);
// создадим контекст устройства для OpenGL
// используя Хендл места рисования
hrc = wglCreateContext(hdc);
ShowMessage(":-)~ hrc == NULL");
if(wglMakeCurrent(hdc, hrc) == false)
ShowMessage("Could not MakeCurrent");
Установка камеры
По умолчанию камера расположена в начале координат (0, 0, 0), направлена вдоль отрицательного направления оси z, и вектором верхнего направления имеет (0, 1, 0).
Для установки камеры удобно использовать функцию gluLookAt(). Хотя она имеет 9 параметров, в них легко разобраться. Они делятся по три параметра, соответственно для трех точек: Eye (Глаз), Center, Up.
Глаз определяет точку откуда смотрим, Центр - куда смотрим, а вектор верха определяет, где у нас должен быть верх (представьте себе пилота в самолете летящего головой вниз). Вектора удобно заключать в классы с переопределенными операциями.
gluLookAt(e.x,e.y,e.z, c.x,c.y,c.z, u.x,u.y,u.z);
Основной цикл включает в себя следующие этапы рисования кадра:
1. Очистку буферов от рисования предыдущей картинки
2. Функции рисования примитивов
3. Функции завершения рисования и ожидания ответа видеокарты
4. Функции копирования изображения из памяти на экран
Основной цикл не включает в себя обработку событий,таких как нажатие клавиш и изменение размеров окна. Для обработки событий создаются отдельные функции и присоединяются к приложению дополнительно.
Если вы работаете в Visual C, то это осуществляется при помощи функций, прототипы которых описаны в файле glaux.h:
auxReshapeFunc()
Если вы работаете в Borland C, то обработка событий осуществляется традиционным для созданных этой программной средой образом: вы просто выбираете компонент(например, Button1), создаете обработчик (например нажатие клавиши) и внутри описываете тело функции.
Рисование примитивов
Рисование примитивов осуществляется командами glBegin() и glEnd().
Константа переданная функции glBegin определяет тип примитива, который будет рисоваться
Координаты точек задаются трехмерным пространственным вектором вектором. Цвета задаются тремя (RGB) или четырьмя (RGBA) параметрами. В нашем примере значение цветовой составляющей каждого цвета можно варьировать от 0 до 1. Если вы привыкли к значению цветовой составляющей от 0 до 255(MsPaint), то используется функция glColor3ub(255,0,0). Суффикс ub означает unsigned byte.
Освещение в Компьютерной графике имеет 3 составляющие
Фоновое излучение - это свет, который настолько распределен средой (предметами, стенами и так далее), что его направление определить невозможно - кажется, что он исходит отовсюду. Лампа дневного света имеет большой фоновый компонент, поскольку большая часть света, достигающего вашего глаза, сначала отражается от множества поверхностей. Уличный фонарь имеет маленький фоновый компонент: большая часть его света идет в одном направлении, кроме того, поскольку он находится на улице, очень небольшая часть света попадает вам в глаз после того, как отразится от других объектов. Когда фоновый свет падает на поверхность, он одинаково распределяется во всех направлениях.
Диффузный компонент - это свет, идущий из одного направления, таким образом, он выглядит ярче, если падает на поверхность под прямым углом, и выглядит тусклым, если касается ее всего лишь вскользь. Однако, когда он падает на поверхность, он распределяется одинаково во всех направлениях, то есть его яркость одинакова вне зависимости от того, с какой стороны вы смотрите на поверхность. Вероятно, любой свет, исходящий из определенного направления или позиции, имеет диффузный компонент.
Зеркальный свет исходит из определенного направления и отражается от поверхности в определенном направлении. При отражении хорошо сфокусированного лазерного луча от качественного зеркала происходит почти 100 процентное зеркальное отражение. Блестящий метал или пластик имеет высокий зеркальный компонент, а кусок ковра или плюшевая игрушка - нет. Вы можете думать о зеркальности как о том, насколько блестящим выглядит материал.
Помимо фонового, диффузного и зеркального цветов, материалы могут также иметь исходящий цвет, имитирующий свет, исходящий от самого объекта. В модели освещения OpenGLисходящий свет поверхности добавляет объекту интенсивности, но на него не влияют никакие источники света, и он не производит дополнительного света для сцены в целом.
Хотя источник света излучает единое распределение частот, фоновый, диффузный и зеркальный компоненты могут быть различны. Например, если в вашей комнате красные стены и белый свет, то этот свет, отражаясь от стен будет скорее красным, чем белым (несмотря на то, что падающий на стену свет -- белый). OpenGL позволяет устанавливать значения красного, зеленого и синего независимо для каждого компонента света.
Команды, используемые для установления материала таковы:
// экземпляры для источника света и материала
// Включим свет источник номер ноль
glEnable(GL_LIGHT0);
// устанавливаем положение и цветовые составляющие источника света
glLightfv(GL_LIGHT0, GL_POSITION, LL.pos);
glLightfv(GL_LIGHT0, GL_AMBIENT, LL.amb);
glLightfv(GL_LIGHT0, GL_DIFFUSE, LL.dif);
glLightfv(GL_LIGHT0, GL_SPECULAR, LL.spec);
// включим режим затениения/освещения
glEnable(GL_LIGHTING);
// устанавливаем параметры материала обьекта
// на лицевых гранях --- GL_FRONT для задних GL_BACK для обоих - GL_FRONT_AND_BACK
// второй параметр - какая составляющая материала
// можно GL_AMBIENT, GL_DIFFUSE, GL_SPECULAR, GL_EMISSION, GL_SHININESS
// соотв РАССЕЯННЫЙ, ОТРАЖЕННЫЙ, ЗЕРКАЛЬНЫЙ, САМОИЗЛУЧЕНИЯ, показатель зеркального блика
glMaterialfv(GL_FRONT,GL_AMBIENT,MM.amb);
glMaterialfv(GL_FRONT,GL_DIFFUSE,MM.dif);
glMaterialfv(GL_FRONT,GL_SPECULAR,MM.spec);
glMaterialf(GL_FRONT,GL_SHININESS,MM.pos);
glNormal3f(0,0,1);
glBegin(GL_QUADS);
for(i=-10; i<20;i++)
for(j=-10;j<20;j++)
glVertex3f(i,j,0);
glVertex3f(i+1,j,0);
glVertex3f(i+1,j+1,0);
glVertex3f(i,j+1,0);
Заключение
Система OpenGL является гибким процедурным интерфейсом, позволяющим программисту разрабатывать различные приложения с применением трехмерной графики. В стандарте нет регламентаций по описанию структуры графических объектов, главное внимание уделяется описанию процесса их визуализации. Благодаря этому возрастает эффективность работы имеющейся аппаратуры: от простых устройств, использующих только буфер кадра до современных графических систем, способных на аппаратном уровне визуализировать трехмерные объекты. В OpenGL предусмотрены только возможности по выводу изображений, организация ввода целиком отдана на откуп конкретной оконной системе, что позволяет достигать дополнительной аппаратной независимости приложений.
По причине минимального использования сложных структур для представления трехмерных объектов возможно применение OpenGL в качестве основы для построения библиотек управления структурированными объектами. Примерами таких библиотек могут быть объектно-ориентированные инструментальные пакеты, используемые для визуализации и моделирования сложных графических структур
Размещено на Allbest.ru
Подобные документы
Программный код OpenGL. Синтаксис команд OpenGL. OpenGL как конечный автомат. Конвейер визуализации OpenGL. Библиотеки, относящиеся к OpenGL. Библиотека OpenGL. Подключаемые файлы. GLUT, инструментарий утилит библиотеки OpenGL.
курсовая работа , добавлен 01.06.2004
Программирование приложения с использованием библиотеки OpenGL и функции для рисования геометрических объектов. Разработка процедуры визуализации трехмерной сцены и интерфейса пользователя. Логическая структура и функциональная декомпозиция проекта.
курсовая работа , добавлен 23.06.2011
Ознакомление с интерфейсом, основными возможностями и преимуществами использования программы OpenGL - популярной библиотекой для работы с 2D и 3D графикой. Рассмотрение назначения, базовых компонент и правил инициализации программного движка DirectX.
презентация , добавлен 14.08.2013
Создание программы на языке C++ с использованием графических библиотек OpenGL в среде Microsoft Visual Studio. Построение динамического изображения трехмерной модели объекта "Нефтяная платформа". Логическая структура и функциональная декомпозиция проекта.
курсовая работа , добавлен 23.06.2011
Суть программирования с использованием библиотеки OpenGL, его назначение, архитектура, преимущества и базовые возможности. Разработка приложения для построения динамического изображения трехмерной модели объекта "Компьютер", руководство пользователя.
курсовая работа , добавлен 22.06.2011
Работа с цветом с помощью графической библиотеки OpenGL. Программа, отображающая квадрат, с меняющимся цветом, в зависимости от изменения градиентов (R,G,B), треугольник, вершины которого имеют различные цвета, прямоугольную полосу в виде спектра.
контрольная работа , добавлен 21.01.2011
Назначение и стандарты реализации OpenGL для Windows, порядок подключения графической библиотеки. Основные функции и синтаксис команд. Рисование примитивов, видовые и аффинные преобразования. Моделирование двумерных графических объектов и анимации.
лабораторная работа , добавлен 04.07.2009
Основы программирования с использованием библиотеки OpenGL. Приложение для построения динамического изображения модели объекта "Батискаф": разработка процедуры визуализации трехмерной схемы, интерфейса пользователя и подсистемы управления событиями.
курсовая работа , добавлен 26.06.2011
Поняття та сфери використання тривимірної графіки. Описання та характеристика можливостей бібліотеки OpenGL. Загальний опис інтерфейсу мови програмування Borland C++, лістинг програми, що демонструє її можливості. Розрахунок витрат на виконання проекту.
дипломная работа , добавлен 24.06.2015
Разработка компоненты для математических вычислений (операций над матрицами) с использованием технологии OpenGL (сложение, вычитание, умножение, транспонирование, определитель, обратная матрица). Базовые навыки по работе с технологией в среде.Net.
Это стандартное графическое приложением для 2D и 3D-визуализации, разработанного в 1992 году. Opengl поставляется в двух вариантах. Первый из них — «Микрософт OpenGL», который часто включается в «Виндовс» для установки графической карты. Второй — Cosmo OpenGL - предназначен для систем, у которых нет ускоренной видеокарты. Библиотека OpenGL - основное условие работы приложения.
Пользовательский обзор OpenGL
До OpenGL любая компания, разрабатывающая графическое приложение, должна была переписать графическую часть для каждой платформы операционной системы. С ним можно создавать одни и те же эффекты в разных операционных системах, используя любой графический адаптер, поддерживающий программу. OpenGL задает набор «команд» или сразу выполняемых функций, каждая из которых направляет действие рисования или вызывает специальные эффекты. Список их может быть создан для повторяющихся эффектов.
OpenGL не зависит от характеристик «Виндовс» каждой операционной системы, но предоставляет специальные подпрограммы для ОС. Она выпускается с огромным перечнем встроенных возможностей, запрашиваемых через API. К ним относятся:
- скрытое удаление поверхности;
- альфа-смешение (прозрачность);
- сглаживание;
- текстурное картирование;
- операции с пикселями;
- просмотр и моделирование трансформаций;
- атмосферные эффекты (туман и дымка).
Silicon Graphics - разработчики передовых графических рабочих станций - инициировала разработку OpenGL. DEC, Intel, IBM, Microsoft и Sun Microsystems вошли в отраслевую комиссию по обзору архитектуры. Разработка приложений, использующих API OpenGL, не несет никаких затрат, кроме обучения. Microsoft предлагает бесплатную загрузку ее библиотек для своих систем.
Набор модулей для Windows
Приложение доступно на многих системах Win32 и Unix. А f90gl — это реализация публичного домена официальных связей Fortran 90 для OpenGL, оформленная в виде базы данных модулей и библиотек, определяющей необходимые интерфейсы для функциональности программы. Сам f90gl был разработан Уильямом Ф. Митчеллом технологического института Гейтерберга в США. До недавнего времени OpenGL LF9x можно было создавать только в виде статически связанных программ, ориентированных на Visual C.
В настоящее время доступен гораздо более дружелюбный метод благодаря усилиям по переносу, реализованным Lawson B. Wakefield из Великобритании. Эта реализация сделала интерфейс OpenGL доступным в рамках WiSK и Winteracter и была выполнена на добровольной, некоммерческой основе. Для подключения библиотеки OpenGL нужны определенные DLL OpenGL, установленные в каталоге Windows SYSTEM32. К ним относятся следующие:
- opengl32.dll;
- glu32.dll;
- glut32.dll.
Первые две из этих библиотек OpenGL (изучить их перед установкой необходимо), являются стандартной частью Windows разных модификаций и Me. Библиотеки и модули f90gl должны быть установлены в LIB-каталоге LF95:
- F90GL.LIB;
- F90GLU.LIB;
- F90GLUT.LIB;
- OPENGL32.LIB;
- GLU32.LIB;
- GLUT32.LIB;
- OPENGL.MOD;
- OPENGL2.MOD;
- OPENGL_KINDS.MOD;
- OPENGL_GLINTERFACES.MOD;
- OPENGL_FWRAP.MOD;
- OPENGL_GLUINTERFACES.MOD;
- OPENGL_GLU.MOD;
- OPENGL_GLUTINTERFACES.MOD;
- OPENGL_GLUT.MOD;
- OPENGL_GL.MODd.
Компиляция и связывание программ f90gl требует, чтобы каталог LF95 LIB указывался в пути модуля компилятора и имена библиотек f90gl для связывания.
Библиотеки изображений
DevIL используется для разработчиков. Он поддерживает множество форматов изображений для чтения и записи, несколько компиляторов и ОС («Виндовс», «Линукс», Мас). Библиотека имеет следующий синтаксис:
- FreeImage — это кросс-платформенная библиотека OpenGL загрузки изображений с очень широкой поддержкой форматов (включая некоторые HDR-форматы, такие как OpenEXR).
- OpenImageIO (OIIO) — это библиотека для чтения и записи изображений, а также множество связанных классов, утилит и приложений. Широко используется в анимационных и VFX-студиях по всему миру, а также встроена в несколько коммерческих продуктах.
- SOIL — это кросс-платформенный загрузчик изображений общего пользования, который чрезвычайно мал. C ++, способный загружать текстуры DDS (DDS9 и DDS10) по лицензии MIT.
- Glraw предоставляет инструмент командной строки, который преобразует файлы изображений в необработанные, непосредственно содержащие простые текстурные данные.
Импорт активов 3D-файлов
Графическая библиотека OpenGL для импорта активов (Assimp) представлена как библиотека с для импорта разнообразных популярных трехмерных моделей. Самая последняя версия экспортирует 3d-файлы и подходит как конвертер общего назначения. Имеется несколько видов таких библиотек:
- Может считывать различные форматы 3D-файлов - COLLADA, собственные файлы Blender3D, Wavefront Obj (.obj) и многие другие. Библиотека lib3ds предназначена для чтения 3ds-файлов.
- Open3mod — это средство просмотра модели на базе Windows. Он загружает все форматы файлов, которые поддерживает Assimp, и идеально подходит для быстрой проверки 3D-активов.
- AssetKit (In Progress) — библиотека OpenGL импортер/экспортер 3D-ресурсов, утилита, основанная на спецификациях COLLADA/glTF. Главное внимание здесь уделено COLLADA и glTF. Она будет полностью поддерживать форматы 1.4, 1.4.1, 1.5+, а также некоторые другие в качестве библиотеки для загрузки моделей в OpenGL.
Высокопроизводительная 2D/3D-графика
Графическая библиотека OpenGL для Android включает поддержку высокопроизводительной 2D и 3D-графики с открытой библиотекой, в частности API OpenGL ES. Android поддерживает ее как через API-интерфейс инфраструктуры, так и Native Development Kit (NDK). В платформе названной операционной системы есть два фундаментальных класса, которые позволяют создавать и манипулировать графикой с помощью API: GLSurfaceView и GLSurfaceView.Renderer.
Если есть цель использовать OpenGL в приложении для Android, то нужно понимать, как реализовать эти классы в действии. Так, GLSurfaceView может рисовать и манипулировать объектами, используя вызовы API OpenGL аналогично функции SurfaceView. Этот интерфейс определяет методы, необходимые для рисования графики в a GLSurfaceView. И пользователь должен обеспечить реализацию этого интерфейса как отдельный класс и прикрепить к GLSurfaceView экземпляр GLSurfaceView.setRenderer. После того как создан контейнерный вид для OpenGL ES, GLSurfaceView и GLSurfaceView.Renderer, можно начать подключение библиотеки OpenGL и использовать API.
Набор мобильных графических устройств
Реализации приложения различаются для Android-устройств поддерживаемыми расширениями API и включают сжатие текстур и другой набор функций. Android Extension Pack (AEP) поддерживает стандартную базу расширений. Упаковка их вместе способствует последовательному набору функциональности на всех устройствах, позволяя разработчикам в полной мере использовать новейший пакет мобильных графических конструкций.
AEP также улучшает поддержку изображений, буферов хранения шейдеров и счетчиков. Чтобы приложение могло использовать AEP, версия платформы должна поддерживать ее. Нужно также обозначит требование AEP следующим образом: <использует функцию android: name = "android.hardware.opengles.aep" android: required = "true" />
Проверка и выбор версии OpenGL ES
На Android-устройствах доступно несколько версий приложения. Можно указать минимальную версию API, которая требуется приложению в телефоне. Версия API opengl ES 1.0, версия 2.0 и версия 3.0 обеспечивают высокопроизводительные графические интерфейсы для создания 3D-игр, визуализации и пользовательских интерфейсов. Программа для OpenGL ES 2.0 во многом похожа на версию 3.0, представляющую собой надмножество API 2.0 с дополнительными функциями.
Программирование для 1.0 / 1.1 API по сравнению с 2.0 и 3.0 значительно отличается, и поэтому разработчикам следует внимательно изучить некоторые факторы, прежде чем начинать разработку с помощью этих API. Так, в общем, 2 и 3 обеспечивают более быструю графическую производительность, чем API ES 1/1,1. Тем не менее разница в ней может варьироваться в зависимости от устройства Android, на котором работает приложение, из-за различий в реализации аппаратного обеспечения графического конвейера.
Сравнение с драйверами DirectX
В Windows графические драйверы DirectX поддерживаются качественнее, чем OpenGL, несмотря на то что разработчики управляют из более быстрых.
Библиотеки OpenGL и DirectX (история и перспективы их) связаны с «Микрософт», которая фактически выступила против OpenGL. В 2003 году Microsoft заявила, что ей больше не интересны планы OpenGL. Затем в 2005 году они на презентации в SIGGRAPH сделали заявление, что Windows Vista удалит ее поддержку.
Эта кампания вызвала хаос в сообществе OpenGL, после чего многие программисты в области профессиональной графики перешли на DirectX. После того как Vista все же была выпущена, громкие заявления выполнены не были - поставщики создали новые производительные драйверы (ICD), которые восстанавливают встроенную функцию. Open рассылала информационные бюллетени с информацией, что по-прежнему является лучшим приложением. Тем не менее ущерб уже был нанесен, а общественное доверие к OpenGL сильно пошатнулось.
На самом деле OpenGL более мощный, чем DirectX, поддерживает больше платформ и имеет преимущественное значение для будущего игр. История и перспективы библиотек OpenGL и DirectX говорят о том, что первая из них имеет все же больше позитива:
- Предоставляет возможность использовать функции графики для оперативных систем, в то время как DirectX предоставляет только моментальные элементы из них в новейших версиях «Виндовс». Технология тесселяции, которую Microsoft разработывал для DirectX 11, была расширением OpenGL в течение трех лет. Путем кропотливого труда удалось добиться того, что DirectX 10 и 11 теперь работают так же быстро, как и OpenGL, и поддерживают почти столько же функций. Однако есть одна большая проблема: они не работают в Windows XP, которой до сих пор пользуются много людей.
- Кросс-платформенный. Многие пользователи Lugaru работают на Mac, Linux и Windows XP и не могут играть через DirectX. Единственный способ доставить новейшую графику для геймеров Windows XP — через 32bits opengl библиотеки.
- Лучше для будущего игр. Это некоммерческий открытый стандарт, созданный для того, чтобы пользователи на любой платформе могли получать высококачественную графику, которую предоставиляет их оборудование. Его развитие разрушается сегодня монополистической атакой корпоративного гиганта, пытающегося доминировать в отрасли. Вот почему Direct3D становится единственным игровым графическим API, поддерживаемым в Windows.
C ++ и настройка Visual Studio
Библиотека OpenGL для c имеет бесплатную версию. Специалисты рекомендуют скомпилировать программы, написанные на ANSI C с OpenGL и GLUT, с помощью Dev-C ++.
Bloodshed Dev-C ++ - это бесплатный компилятор C ++ и среды разработки для операционных систем Windows. Как и большинство таких же технических средств, его можно использовать для компиляции ANSI C. Установив файлы заголовков GLUT и библиотеки, его применяют для написания программ. Для реализации этого проекта можно использовать 32-разрядную или 64-разрядную «Виндовс».
Перед тем как подключить к dev c библиотеку OpenGL, понадобятся заголовки glew, которые можно найти на вебсайте sourceforge Extension Wrangler, и версия freeglut для Visual Studio:
- Нажать ссылку внутри пакета freeglut 3.0.0 MSVC.
- Ввести имя файла, который нужно скачать.
- Загрузить его, в папке с freeglut.
- Извлечь и переименовать в freeglut.
- Общий каталог для установки: C: \ DEV.
- Каталог, в котором находятся проекты: C: \ DEV \ visual-studio-c ++.
- Каталог, в котором находятся библиотеки: C: \ DEV \ Lib Visual Studio.
- Открыть его и создать пустой проект > «Шаблоны»> Visual C ++> Пустой проект.
- Затем написать «Имя»: Shapes2D.
- Местоположение: C: \ dev \ visual-studio-c ++ \.
- Создать новое решение в OpenGL-библиотеке для Visual Studio. Название решения: BadprogTutorial OK.
- Проект Shapes2D создан в решении BadprogTutorial.
- Добавить main.cpp> Кликнуть правой кнопкой мыши «Проект»> «Добавить»> «Новый элемент»> Visual C ++> Файл C ++. Написать имя: main.cpp и добавить.
- Настроить конфигурации библиотеки GL и OpenGL glut.
- Кликнуть мышью проект Shapes2D> «Свойства». В левом верхнем углу раскрывающегося меню найти «Конфигурация» и выбрать все конфигурации (вместо Debug).
- Кликнуть мышью на «Свойства конфигурации»> C / C ++> «Общие»> «Дополнительные каталоги вложений». Справа находится раскрывающееся меню, нажать «Изменить...».
- Появилось новое окно: «Дополнительные каталоги».
- Нажать значок «Новая линия»> кнопку обзора и выбрать две следующие папки: C: \ DEV \ Lib \ Glew-1.12.0 \ . C: \ DEV \ Lib \ freeglut-3.0.0 \ .
- Нажать кнопку ОК. Применить использование библиотеки OpenGL, включая библиотеки, библиотечные папки.
- Кликнуть правой кнопкой мыши проект Shapes2D> «Свойства» > «Свойства конфигурации»> «Коннектор»> «Общие»> «Дополнительные каталоги библиотек».
- Справа находится раскрывающееся меню. Нажать на «Изменить...». Появилось новое окно: «Дополнительные библиотеки».
- Нажать значок «Новая линия»> нажать кнопку обзора> выбрать две следующие папки для 64-разрядной версии: C: \ DEV \ Lib \ Glew-1.12.0 \ Lib \ Release \ x64 и C: \ DEV \ Lib \ freeglut-3.0.0 \ Lib \ x64.
- Нажать кнопку ОК> применить библиотечные файлы. Кликнуть мышью проект Shapes2D> «Свойства» > «Свойства конфигурации»> «Коннектор»> «Ввод».
- Справа находится раскрывающееся меню, нажмите «Изменить...».
- Появилось новое окно: «Дополнительные зависимости». Кликнуите по белой области и напишите: freeglut.lib.
- Нажать Enter, чтобы перейти к следующей строке: glew32.lib.
- Нажать «Применить» и ОК.
Теперь Visual Studio IDE готова работать с OpenGL.
Загрузка Dev-C ++
Эти инструкции были протестированы на большом множестве систем Windows, которые поставляются с файлами, необходимыми для OpenGL, но не для файлов, необходимых для GLUT. Dev-C ++ не работает с Vista от Microsoft.
Процедура загрузки:
- Загрузите Dev-C ++ и установите его.
- Получите Dev-C ++ 5.0 beta 9.2 (4.9.9.2) (9.0 MB) с Mingw / GCC 3.4.2 (хотя это «бета-версия», она отлично работает).
- Теперь нужно нажать на SourceForge, чтобы перейти к списку сайтов загрузки, и выбрать один.
- Сохранить этот файл в таком месте, как C: \ Temp.
- Когда загрузка будет завершена, нажать кнопку «открыть», чтобы начать процесс установки. Или перейти к C: \ Temp и дважды кликнуть по devcpp4.9.9.2_setup.exe.
- Выбрать «типичную» установку. Принять предложенный пункт назначения для установки.
- Ответить: «Да», когда установка спрашивает, хотите ли установить Dev-cpp для всех пользователей. На экране появляется сообщение, что установка завершена. Нажать «Готово». Появится первый экран конфигурации.
- Выбрать «Английский» и «Новый взгляд». На следующих нескольких экранах нажать «Да». Программа запускается автоматически.
- Нажать «Файл», затем создать проект.
- Выбрать имя для проекта (например, «myProject»).
- Нажать «C Project», «Пустой проект» и ОК.
- В окне «Создать новый проект» нажать «Сохранить».
- Нажать «Файл / Новый / Исходный файл» и в «Добавить исходный файл в текущий проект» нажать «Да».
- Нажать «Файл / Сохранить как» и сохранить файл как «hello.c» (или другое имя). Важно убедиться, что расширение файла.c. С любым другим расширением (например, предлагаемым.cpp) возникнут проблемы с компиляцией.
- Нажать «Выполнить / Скомпилировать и запустить». Программа компилирует, запускает и записывает свой вывод в окно DOS.
- Попробовать другой способ запуска программы (после ее компиляции) — запустить окно DOS вне системы Dev-Cpp.
- Перейти к подкаталогу, в котором содержится проект, и набрать hello.exe.
- Найти Dev-C ++, указанный в разделе «Программы» из пускового меню.
Теперь пользователь сможет создавать, компилировать и запускать программы C (и C ++). У него будут файлы, библиотеки и dll для OpenGL (и всех других стандартных пакетов), но не GLUT. GLUT управляет окнами и другими компонентами пользовательского интерфейса, необходимыми для него, и их устанавливают отдельно.
Установка и запуск программы на Windows 7
Платформа выполнения для Visual Studio 2010 - Integrated. Среда (IDE), под управлением Windows 7. Вам нужно загрузить и установить Microsoft Visual C ++ 2010 Express. А после того как Visual C ++ будет успешно установлен, следует выполнить следующие действия:
- Загрузить и распаковать файл freeglut-MSVC-2.8.1-1.
- Открыть экран приветствия Visual C ++ 2010 из меню «Пуск».
- Создать новый проект, выбрав File -> New -> Project.
- Выбрать Win32 на панели «Установленные шаблоны», а затем «Консольное приложение Win32» со следующей панели.
- Назвать свой проект и выбрать папку, в которую нужно его сохранить.
- Снять флажок «Создать каталог для решения».
- Нажать ОК, чтобы открыть окно приветствия мастера и «Параметры приложения» для диалогового окна настроек.
- Снять флажок «Предварительно скомпилированный заголовок», установить флажок «Пустое проект» и выбрать «Консольное приложение».
- Нажать «Готово», чтобы увидеть новое окно проекта библиотеки OpenGL для Windows 7.
- Нажать мышью на Source Files и выбрать Add -> New Item, чтобы открыть диалоговое окно.
- Выбрать «Код» на панели «Установленные шаблоны» и «Файл C ++» (.cpp) со следующей панели.
- Назвать свой файл и нажать «Добавить», чтобы увидеть пустую панель кода в окне проекта с названием «Выбранное имя».
- Сохранить и создайть проект, перейдя в Debug -> Build Solution. Затем выполнить программу с помощью Debug -> Start Debugging.
Если графическая карта не поддерживает OpenGL 4.3, то программы, использующие его, могут компилироваться, но не выполняться, поскольку система не может предоставить контекст рендеринга OpenGL 4.3, заданный командой glutInitContextVersion (4. 3) в основной процедуре. В этом случае можно заменить Version 4.3 на 3.3 или даже на 2.1.
Хотя почти все платформы поддерживают OpenGL API, разработчикам по-прежнему необходимо создавать индивидуальные приложения для разных платформ. Это связано с тем, что графика является лишь частью приложения, а другие компоненты по-прежнему отличаются между платформами. Чтобы исправить это, WebApp был разработан для запуска целых программ в веб-браузере, таких как Chrome и Firefox. Так что одна программа может работать на всех платформах с совместимым браузером.
Между тем на стороне клиента все передается «на лету» с серверов, поэтому дальнейшая установка приложения не требуется. Специальный API под названием WebGL также был создан для Интернета и основан на ES, подмножестве OpenGL, разработанном специально для мобильных устройств. Чтобы достичь аналогичной цели для VR, другой API, называемый WebVR, был разработан, чтобы легко довести опыт VR до браузеров, независимо от платформы.