2D и 3D графика в OpenGL. На примере библиотеки freeglut мы познакомимся с тем, как работает 2D- и

Содержание

Работа с OpenGL 3.3 с использованием библиотек freeglut и glew

Важной особенностью OpenGL 3.2 и выше является то, что для работы с ним необходимо создать специальный контекст. Для создания контекста при помощи расширений WGL_ARB_create_context/GLX_ARB_create_context предоставляются функции wglCreateContextAttribsARB/glXCreateContextAttribsARB, позволяющие создать контекст с заданными атрибутами. Однако для того, чтобы получить эти функции (вводимые через расширения OpenGL) необходимо уже иметь готовый контекст OpenGL.

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

При создании контекста при помощи wglCreateContextAttribsARB/glXCreateContextAttribsARB необходимо задать ряд атрибутов, таких требуемая версия OpenGL, используемый профиль (compatibility или core) и дополнительные свойства (поддержка отладочной информации и поддержка deprecated-функционала).

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

Очень большое количество примеров на OpenGL традиционно пишется с использованием библиотеки glut. К сожалению код этой библиотеки закрыт, она уже давно не обновляется и не поддерживает создание контекста для OpenGL 3.2 и выше.

Зато есть открытая библиотека freeglut, полностью включающая в себя как функциональность библиотеки glut (т.е. если заменить glut на нее, то все будет компилироваться и работать). При этом в состав библиотеки freeglut входит ряд дополнительных возможностей, в том числе и поддержка создания контекста для OpenGL версии 3.2 и выше. При этом библиотека остается кроссплатформенной и позволяет легко писать приложения, компилирующиеся и работающие как под Windows, так и под Linux.

Ниже будут рассмотрены некоторые из дополнительный функций freeglut, а также создание простейших OpenGL 3.3 приложений.

Дополнительные возможности библиотеки freeglut

Библиотека freeglut предоставляет много дополнительных возможностей, здесь будут рассмотрены только некоторые из них. Полное описание содержится в документации к самой библиотеке.

Прежде всего были добавлены функции, позволяющие изменить цикл обработки сообщений и сделать нормальную деинициализацию приложения. В основе этого лежат функции glutMainLoopEvent и glutLeaveMainLoop.

Функция glutMainLoopEvent обрабатывает все имеющиеся в очереди сообщения и возвращает управление. Тем самым весь цикл обработки сообщений, реализуемый функцией glutyMainLoop можно реализовать как явный цикл, вызывающий функцию и glutMainLoopEvent.

Следующая группа функций добавляет новые callback‘и к уже существующим.

Функция glutMouseWheelFunc позволяет установить обработчик колесика мышки. Функция-обработчик имеет следующий вид:

Параметр wheel содержит номер колесика мыши, вызвавше7го данное событие (обычно он равен нулю), а параметр dir задает направление в котором было повернуто колесико и принимает значения +1 и -1.

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

Функция glutKeyboardUpFunc является парной к функции glutKeyboardFunc и позволяет установить обработчик отпускания клавиши, генерирующей ASCII-код.

Функция glutCloseFunc служит для установки обработчика, который будет вызываться при закрытии окна.

Следующая (и наиболее важная для нас) группа функция служит для «заказа» требуемого контекста OpenGL. За счет их использования мы сразу получаем требуемый контекст и можем начать с ним работать.

Функция glutInitContextVersion задает для какой версии OpenGL нужно создать контекст. Функция glutInitContextProfile задает тип профиля, который должен быть создан для этого контекста. В качестве этого параметра могут выступать значения GLUT_CORE_PROFILE и GLUT_COMPATIBILITY_PROFILE. Функция glutInitContextFlags позволяет задать дополнительные свойства для профиля. Свойства задаются как набор битов и допустимыми на данный момент являются GLUT_DEBUG и GLUT_FORWARD_COMPATIBLE. Последнее значение позволяет создать профиль, в котором весь deprecated функционал будет выключен.

Ниже приводится простейшая программа, использующая freeglut для создания контекста для core profile с отключенным deprecated-функционалом и создающий пустое окно.

Использование библиотеки glew

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

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

Для подключения библиотеки достаточно включить заголовочные файлы (основной файл glew.h и два дополнительных файлы, зависящих от конкретной платформы — wglew.h и glxew.h).

Также необходимо явно проинициализировать библиотеку при помощи вызова функции glewInit. Перед этим вызовом желательно выставить флаг glewExperimental в GL_TRUE — в противном случае glew иногда считает некоторые расширения экспериментальными и не инициализирует их поддержку.

Также можно использовать ряд встроенных переменных glew для проверки поддержки той или иной версии OpenGL (GLEW_VERSION_3_3) или расширения (GLEW_ARB_vertex_array_object):

Работа с OpenGL 3.3

Важной особенностью OpenGL 3.2 при работе с core profile является полное отсутствие FFP и связанного с ним функционала. Убраны функции glBegin, glEnd, glVertex*, убраны стандартные атрибуты вершин ( glNormal*, glTexCoord), все вершины теперь задаются через вершинные массивы.

Убраны некоторые типы примитивов — GL_QUADS, GL_QUAD_STRIP и GL_POLYGON. Все команды glTexImage* не принимают число компонент в качестве значения для внутреннего формата. Также убран режим приведения текстурных координат GL_CLAMP (допустимыми режимами являются только GL_CLAMP_TO_EDGE, GL_CLAMP_TO_BORDER, GL_REPEAT и GL_MIRRORED_REPEAT). Кроме того параметр border в glTexImage* должен быть равен нулю.

Убран альфа-тест и функция glAlphaFunc — это надо делать в шейдере. Убрана поддержка aux и accumulation буферов, дисплейных списков, ряда hint‘ов, стеки атрибутов.

Весь вывод теперь осуществляется при помощи шейдеров, т.е. без них теперь вообще ничего не нарисовать. Рассматриваемый в одной из статей WebGL очень близок к этому — всю работу с матрицами необходимо делать руками, весь вывод — только через шейдеры и т.д.

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

Чтобы избежать большого количества рутинных операций, подобно тому как это делалось во многих предыдущих статьях, можно завернуть все основные необходимые сущности — вектора, матрицы, шейдеры — в объекты языка C++ и за счет этого заметно упростить работу (как это делалось в предыдущих статьях). Дополнительным плюсом таких врапперов является то, что на них можно переложить основной матричный функционал, перешедший в категорию deprecated. В этой статье такие врапперы рассматриваться не будут, но последующие статьи уже будут основаны на таких врапперах.

Ссылки

По этой ссылке можно скачать весь исходный код к этой статье. Также доступны для скачивания откомпилированные версии для M$ Windows и Linux.

Обратите внимание, что для сборки под Linux может понадобиться скачать исходники последних версий библиотек freeglut и glew и собрать и установить их из исходников.

2D и 3D графика в OpenGL. На примере библиотеки freeglut мы познакомимся с тем, как работает 2D- и 3D-графика.

200?’200px’:»+(this.scrollHeight+5)+’px’);»> #include
using namespace std;

void display()
<
glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_LINES);
glColor3f(1.0, 0.0, 0.0);
glVertex2f(0.4, 0.4);
glVertex2f(0.4, 0.8);
//
glVertex2f(0.4, 0.8);
glVertex2f(0.8, 0.8);
//
glVertex2f(0.8, 0.8);
glVertex2f(0.8, 0.4);
//
glVertex2f(0.4, 0.4);
glVertex2f(0.8, 0.4);
glEnd();
glFlush();

int main(int argc, char **argv)
<
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize(240, 240);
glutInitWindowPosition(100, 740);
glutCreateWindow(«First window!»);
glClearColor(1.0, 1.0, 1.0, 1.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0);
glutDisplayFunc(display);
glutMainLoop();
>

Записки инженера

Доступным языком заметки по IT технологиям

Библиотеки для 2D графики (C/С++)

В один из моментов, я задался вопросом как мне вывести графику используя C++ (С). Я не хотел использовать такие популярные среды Builder или MS Visual с их библиотеками окон. Мне была нужна просто библиотека для работы с простой графикой в консоли.

Если судить по запросам в интернете и на форумах, этот вопрос возникал не только у меня.

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

Список библиотек

1. WinBGIm — портированная «старая» библиотека от компании Borland для Windows. Изначально она разрабатывалась для отображения графики под DOS.

2. Cairo — библиотека под лицензий GNU, поддерживается многими языками программирования (Delphi, Factor, Haskell, Lua, Perl, PHP, Python, Ruby, Scheme, Smalltalk и т.п.). Также поддержка большого количество операционных систем.

3. SDL — кроссплатформенная мультимедийная библиотека под лицензий GNU реализующая единый программный интерфейс к графической подсистеме, звуковым устройствам и средствам ввода для широкого спектра платформ.

Данная библиотека активно используется при написании кроссплатформенных мультимедийных программ (в основном игр). Поддерживается большим количеством языков программирования (C, C++, C#, VB.NET, D, Ada, Vala, Eiffel, Haskell, Erlang, Euphoria, Java, Lisp, Lua, ML, Pascal, Perl, PHP, Pike, PureBasic, Python и Ruby) и операционных систем (Linux, Microsoft Windows, Mac OS X, iOS и Android).

Из интересной особенности библиотеки, она позволяет работать с джостиком, CD-ROM и сетью.

4. SFML — простая и быстрая кроссплатформенная мультимедийная библиотека, доступная на языках: С++, C, D, Java, Python, Ruby, OCaml, .Net и Go. Является объектно ориентированный аналог SDL. Позволяет работать с аудио, сетью и окнами.

5. Allergo — кроссплатформенная библиотека позволяющая работать с 2D графикой, аудиофайлами, окнами, файловой системой, 3D графикой. Помимо этого библиотека предоставляет дополнительные функции по работе с числами с фиксированной, плавающей запятой и матрицами.

Изначально создавалась для разработки игр под Atari (Allergo расшифровывается как Atari Low-Level Game Routines), сейчас библиотека поддерживается языками: C, C++, Pascal, Python, Lua, Scheme, D, Go, Ada, Lisp, Mercury, Perl, Scheme. Есть поддержка под следующие платформы: Windows, macOS, Unix-подобные системы, Android и iOS.

6. SKIA — компактная графическая библиотека. Её использует в Google Chrome, Chrome OS, Chromium OS, Mozilla Firefox, Android (до 3.0), Firefox OS и Sublime Text 3. Библиотека работает на С и Python.

7. OpenGL (или glut) — библиотека на которой основываются некоторые из выше указанных. Я заявил о ней в самом конце списка, т.к. многие о ней слышали и она достаточно мощна для простых задач вроде 2D графики, но реализовывать она это может. Точнее даже сказать, OpenGL это спецификация, т.е. набор правил описывающих интерфейс, а разработчик оборудования (видеокарты) на её основе разрабатывает библиотеку. Реализуется на большом количество операционных систем и языков программирования.

8. DirectX — библиотека от компании Microsoft только для Windows. Изначально разрабатывалась именно для игр, является конкурентов OpenGL. Позволяет работать с большим количество периферии, сеть, звук, видео, 3D графика, 2D графика, клавиатура, джостик и т.п.

9. Direct2D — библиотека от Microsoft появилась с DirectX v.10. Задача библиотеки отображать 2D графику с использованием аппаратного ускорения, изначально реализовывалась для Windows 7.

Вам будет интересно:

Буду признателен если вы поделитесь данным постом

  1. Василий (iklife.ru) пишет:

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

Графическая библиотека OpenGL

Open Graphics Library — это стандартное графическое приложением для 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. К ним относятся следующие:

Первые две из этих библиотек 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 для связывания.

Цукерберг рекомендует:  Ключевое слово new - Для чего нужен new в C#

Библиотеки изображений

DevIL используется для разработчиков. Он поддерживает множество форматов изображений для чтения и записи, несколько компиляторов и ОС («Виндовс», «Линукс», Мас). Библиотека имеет следующий синтаксис :

  1. FreeImage — это кросс-платформенная библиотека OpenGL загрузки изображений с очень широкой поддержкой форматов (включая некоторые HDR-форматы, такие как OpenEXR).
  2. OpenImageIO (OIIO) — это библиотека для чтения и записи изображений, а также множество связанных классов, утилит и приложений. Широко используется в анимационных и VFX-студиях по всему миру, а также встроена в несколько коммерческих продуктах.
  3. SOIL — это кросс-платформенный загрузчик изображений общего пользования, который чрезвычайно мал. C ++, способный загружать текстуры DDS (DDS9 и DDS10) по лицензии MIT.
  4. Glraw предоставляет инструмент командной строки, который преобразует файлы изображений в необработанные, непосредственно содержащие простые текстурные данные.

Импорт активов 3D-файлов

Графическая библиотека OpenGL для импорта активов (Assimp) представлена как библиотека с открытым исходным кодом для импорта разнообразных популярных трехмерных моделей. Самая последняя версия экспортирует 3d-файлы и подходит как конвертер общего назначения. Имеется несколько видов таких библиотек:

  1. Может считывать различные форматы 3D-файлов — COLLADA, собственные файлы Blender3D, Wavefront Obj (.obj) и многие другие. Библиотека lib3ds предназначена для чтения 3ds-файлов.
  2. Open3mod — это средство просмотра модели на базе Windows. Он загружает все форматы файлов, которые поддерживает Assimp, и идеально подходит для быстрой проверки 3D-активов.
  3. 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 следующим образом:

Проверка и выбор версии 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 говорят о том, что первая из них имеет все же больше позитива:

  1. Предоставляет возможность использовать функции графики для оперативных систем, в то время как DirectX предоставляет только моментальные элементы из них в новейших версиях «Виндовс». Технология тесселяции, которую Microsoft разработывал для DirectX 11, была расширением OpenGL в течение трех лет. Путем кропотливого труда удалось добиться того, что DirectX 10 и 11 теперь работают так же быстро, как и OpenGL, и поддерживают почти столько же функций. Однако есть одна большая проблема: они не работают в Windows XP, которой до сих пор пользуются много людей.
  2. Кросс-платформенный. Многие пользователи Lugaru работают на Mac, Linux и Windows XP и не могут играть через DirectX. Единственный способ доставить новейшую графику для геймеров Windows XP — через 32bits opengl библиотеки.
  3. Лучше для будущего игр. Это некоммерческий открытый стандарт, созданный для того, чтобы пользователи на любой платформе могли получать высококачественную графику, которую предоставиляет их оборудование. Его развитие разрушается сегодня монополистической атакой корпоративного гиганта, пытающегося доминировать в отрасли. Вот почему 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:

  1. Нажать ссылку внутри пакета freeglut 3.0.0 MSVC.
  2. Ввести имя файла, который нужно скачать.
  3. Загрузить его, в папке с freeglut.
  4. Извлечь и переименовать в freeglut.
  5. Общий каталог для установки: C: \ DEV.
  6. Каталог, в котором находятся проекты: C: \ DEV \ visual-studio-c ++.
  7. Каталог, в котором находятся библиотеки: C: \ DEV \ Lib Visual Studio.
  8. Открыть его и создать пустой проект > «Шаблоны»> Visual C ++> Пустой проект.
  9. Затем написать «Имя»: Shapes2D.
  10. Местоположение: C: \ dev \ visual-studio-c ++ \.
  11. Создать новое решение в OpenGL-библиотеке для Visual Studio. Название решения: BadprogTutorial OK.
  12. Проект Shapes2D создан в решении BadprogTutorial.
  13. Добавить main.cpp> Кликнуть правой кнопкой мыши «Проект»> «Добавить»> «Новый элемент»> Visual C ++> Файл C ++. Написать имя: main.cpp и добавить.
  14. Настроить конфигурации библиотеки GL и OpenGL glut.
  15. Кликнуть мышью проект Shapes2D> «Свойства». В левом верхнем углу раскрывающегося меню найти «Конфигурация» и выбрать все конфигурации (вместо Debug).
  16. Кликнуть мышью на «Свойства конфигурации»> C / C ++> «Общие»> «Дополнительные каталоги вложений». Справа находится раскрывающееся меню, нажать «Изменить . ».
  17. Появилось новое окно: «Дополнительные каталоги».
  18. Нажать значок «Новая линия»> кнопку обзора и выбрать две следующие папки: C: \ DEV \ Lib \ Glew-1.12.0 \ . C: \ DEV \ Lib \ freeglut-3.0.0 \ .
  19. Нажать кнопку ОК. Применить использование библиотеки OpenGL, включая библиотеки, библиотечные папки.
  20. Кликнуть правой кнопкой мыши проект Shapes2D> «Свойства» > «Свойства конфигурации»> «Коннектор»> «Общие»> «Дополнительные каталоги библиотек».
  21. Справа находится раскрывающееся меню. Нажать на «Изменить . ». Появилось новое окно: «Дополнительные библиотеки».
  22. Нажать значок «Новая линия»> нажать кнопку обзора> выбрать две следующие папки для 64-разрядной версии: C: \ DEV \ Lib \ Glew-1.12.0 \ Lib \ Release \ x64 и C: \ DEV \ Lib \ freeglut-3.0.0 \ Lib \ x64.
  23. Нажать кнопку ОК> применить библиотечные файлы. Кликнуть мышью проект Shapes2D> «Свойства» > «Свойства конфигурации»> «Коннектор»> «Ввод».
  24. Справа находится раскрывающееся меню, нажмите «Изменить . ».
  25. Появилось новое окно: «Дополнительные зависимости». Кликнуите по белой области и напишите: freeglut.lib.
  26. Нажать Enter, чтобы перейти к следующей строке: glew32.lib.
  27. Нажать «Применить» и ОК.

Теперь Visual Studio IDE готова работать с OpenGL.

Загрузка Dev-C ++

Эти инструкции были протестированы на большом множестве систем Windows, которые поставляются с файлами, необходимыми для OpenGL, но не для файлов, необходимых для GLUT. Dev-C ++ не работает с Vista от Microsoft.

  1. Загрузите Dev-C ++ и установите его.
  2. Получите Dev-C ++ 5.0 beta 9.2 (4.9.9.2) (9.0 MB) с Mingw / GCC 3.4.2 (хотя это «бета-версия», она отлично работает).
  3. Теперь нужно нажать на SourceForge, чтобы перейти к списку сайтов загрузки, и выбрать один.
  4. Сохранить этот файл в таком месте, как C: \ Temp.
  5. Когда загрузка будет завершена, нажать кнопку «открыть», чтобы начать процесс установки. Или перейти к C: \ Temp и дважды кликнуть по devcpp4.9.9.2_setup.exe.
  6. Выбрать «типичную» установку. Принять предложенный пункт назначения для установки.
  7. Ответить: «Да», когда установка спрашивает, хотите ли установить Dev-cpp для всех пользователей. На экране появляется сообщение, что установка завершена. Нажать «Готово». Появится первый экран конфигурации.
  8. Выбрать «Английский» и «Новый взгляд». На следующих нескольких экранах нажать «Да». Программа запускается автоматически.
  9. Нажать «Файл», затем создать проект.
  10. Выбрать имя для проекта (например, «myProject»).
  11. Нажать «C Project», «Пустой проект» и ОК.
  12. В окне «Создать новый проект» нажать «Сохранить».
  13. Нажать «Файл / Новый / Исходный файл» и в «Добавить исходный файл в текущий проект» нажать «Да».
  14. Нажать «Файл / Сохранить как» и сохранить файл как «hello.c» (или другое имя). Важно убедиться, что расширение файла .c. С любым другим расширением (например, предлагаемым .cpp) возникнут проблемы с компиляцией.
  15. Нажать «Выполнить / Скомпилировать и запустить». Программа компилирует, запускает и записывает свой вывод в окно DOS.
  16. Попробовать другой способ запуска программы (после ее компиляции) — запустить окно DOS вне системы Dev-Cpp.
  17. Перейти к подкаталогу, в котором содержится проект, и набрать hello.exe.
  18. Найти Dev-C ++, указанный в разделе «Программы» из пускового меню.

Теперь пользователь сможет создавать, компилировать и запускать программы C (и C ++). У него будут файлы, библиотеки и dll для OpenGL (и всех других стандартных пакетов), но не GLUT. GLUT управляет окнами и другими компонентами пользовательского интерфейса, необходимыми для него, и их устанавливают отдельно .

Установка и запуск программы на Windows 7

Платформа выполнения для Visual Studio 2010 — Integrated. Среда (IDE), под управлением Windows 7. Вам нужно загрузить и установить Microsoft Visual C ++ 2010 Express. А после того как Visual C ++ будет успешно установлен, следует выполнить следующие действия:

  1. Загрузить и распаковать файл freeglut-MSVC-2.8.1-1.
  2. Открыть экран приветствия Visual C ++ 2010 из меню «Пуск».
  3. Создать новый проект, выбрав File -> New -> Project.
  4. Выбрать Win32 на панели «Установленные шаблоны», а затем «Консольное приложение Win32» со следующей панели.
  5. Назвать свой проект и выбрать папку, в которую нужно его сохранить.
  6. Снять флажок «Создать каталог для решения».
  7. Нажать ОК, чтобы открыть окно приветствия мастера и «Параметры приложения» для диалогового окна настроек.
  8. Снять флажок «Предварительно скомпилированный заголовок», установить флажок «Пустое проект» и выбрать «Консольное приложение».
  9. Нажать «Готово», чтобы увидеть новое окно проекта библиотеки OpenGL для Windows 7.
  10. Нажать мышью на Source Files и выбрать Add -> New Item, чтобы открыть диалоговое окно.
  11. Выбрать «Код» на панели «Установленные шаблоны» и «Файл C ++» (.cpp) со следующей панели.
  12. Назвать свой файл и нажать «Добавить», чтобы увидеть пустую панель кода в окне проекта с названием «Выбранное имя».
  13. Сохранить и создайть проект, перейдя в 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 до браузеров, независимо от платформы.

OpenGL. Урок 4. Создание 3D-объектов.

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

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

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

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

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

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

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

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

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

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

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

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

Цукерберг рекомендует:  11 плюшек для Java-разработчика

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

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

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

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

yAngle = 180 * d / w;

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

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

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

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

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

Здесь первый параметр – угол поворота, а три остальных определяют, вокруг какой из осей необходимо выполнить вращение. То есть если мы сделаем так:

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

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

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

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

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

Как и обещал прилагаю архив с полным проектом этого примера: OpenGLTest_Cube

Похожие статьи:

Понравилась статья? Поделись с друзьями!

Отличный курс. С интересом слежу за ним и думаю не только я. В дальнейшем планируется затрагивать тему редактирования объектов? Например, было бы интересно узнать, как при наведении мыши на грань куба подсветить ее, как цепляться за узел и перетаскивать его.

Раз интерес есть, то постараюсь описать )

Великолепная вводная в OpenGL – с благодарностью жду от автора продолжения. Однозначно респект.

Большое спасибо автору статьи.

Спасибо за хороший отзыв!

Здравствуйте, можно ли Вам задавать вопросы? У меня проблема с массивами данных. У меня задание – построить полигонами деталь. координаты и как соединить их в элементы заданы. Не знаю как задать массив нормалей , и почему строиться невероятно большая деталь, хотя координаты в пределах [0.5;2] . Вы можете что то посоветовать? Как менять масштаб например

На самом деле так сложно что-то конкретное и определенное сказать… Надо хотя бы код или пример полностью посмотреть.

Здравствуйте! У меня такая проблема: нужно научиться конвертировать любую плоскую фигуру в объёмную opengl c++. Не подскажете? Пжл

Спасибо, отличный мануал, вместе со всеми предидущими. Долго не мог разобраться с OpenGL, а тут буквально за пару вечеров понял основы.
Только я заметил одну вещь. Если сделать как у вас написано
xAxisRotation += (формула)
yAxisRotation += (формула)
кубик почему-то вращается совершенно непредсказуемым образом.
Если написать там просто “=” а не “+=” то всё работает как надо.

Спасибо за отличный отзыв.

Блин)
Я просто забыл
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
И так всё работает отлично)

10. Создание проекта и подключение библиотеки Tao OpenGL в С#

Сначала создайте новый проект, в качестве шаблона установив приложение Windows Forms.

Дождитесь пока MS Visual Studio закончит генерацию кода шаблона. Теперь перейдите к окну Solution Explorer (Обозреватель решений). Здесь, нас интересует узел Links, который отображает связи с библиотеками, необходимыми для работы нашего приложения (рисунок 1)

Щелкните по этому узлу правой клавишей мыши, после чего, в открывшемся контекстном меню выберите «Добавить ссылку» (“Add Link”), как показано на рисунке 2

В открывшемся окне «Добавить ссылку», перейдите к закладке обзор. После этого перейдите к директории, в которую была установлена библиотека Tao Framework. (По умолчанию — “C:Program FilesTao Framework”). Нам потребуется папка bin — в ней хранятся необходимые нам библиотеки. Перейдите в папку bin и выберите3 библиотеки, как показано на рисунке 3:

1. Tao.OpenGL.dll — отвечает за реализация библиотеки OpenGL

2. Tao.FreeGlut.dll — отвечает за реализацию функций библиотеки Glut. Мы будем ее использовать для инициализации рендера, а так же для различных других целей.

3. Tao.Platform.Windows.dll — отвечает за поддержку элементов непосредственно для визуализации непосредственно на платформе Windows.

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

// для работы с библиотекой OpenGL

// для работы с библиотекой FreeGLUT

// для работы с элементом управления SimpleOpenGLControl

Теперь вернитесь к конструктору диалогового окна и перейдите к окну Toolbox (панель элементов). Щелкните правой кнопкой на вкладке «Общие», и в раскрывшемся контекстном меню выберите пункт «Выбрать элементы» (Select elements), как показано на рисунке 4.

В открывшемся окне найдите элемент SimpleOpenGLControl и установите возле него галочку, как показано на рисунке 6. Затем нажмите ОК.

Теперь данный элемент станет доступным для размещения на форме приложения. Перетащите элемент на форму, и разместите так, как показано на рисунке 5. Справа от размещенного элемента установите 2 кнопки — «Визуализировать» и «Выйти».

Теперь выделите элемент simpleOpenGlControl1, расположенный на форме и перейдите к его свойствам. Измените параметр name на значение “AnT”. Далее во всех главах элементы simpleOpenGlControl мы будем называть AnT.

11. Инициализация OpenGL в C# .NET

Теперь нам необходимо инициализировать работу OpenGL.

Сначала мы в конструкторе класса должны инициализировать работу элемента AnT:

Снова перейдите к конструктору и сделайте двойной щелчок левой клавишей мыши на форме — создастся функция обработчик события загрузки формы.

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

private void Form1_Load(object sender, EventArgs e)

Glut.glutInitDisplayMode(Glut.GLUT_RGB | Glut.GLUT_DOUBLE | Glut.GLUT_DEPTH);

Gl.glClearColor(255, 255, 255, 1);

// установка порта вывода в соотвествии с размерами элемента anT

Gl.glViewport(0, 0, AnT.Width, AnT.Height);

Glu.gluPerspective(45, (float)AnT.Width / (float)AnT.Height, 0.1, 200);

// настройка параметров OpenGL для визуализации

На окне мы создали 2 кнопки. Обработчик кнопки выйти будет выглядеть следующим образом

//обработчик кнопки «выйти»

private void button2_Click(object sender, EventArgs e)

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

// обработчик кнопки «визуализировать»

private void button1_Click(object sender, EventArgs e)

Gl.glColor3f(1.0f, 0, 0);

Gl.glRotated(45, 1, 1, 0);

// рисуем сферу с помощью библиотеки FreeGLUT

Glut.glutWireSphere(2, 32, 32);

Откомпилируйте и запустите приложение.

Результат работы приложения показан на рисунке 9. Если вы правильно набрали все исходные коды и выполнили все описанные действия, то вы увидите аналогичную визуализацию сферы, после нажатия на кнопке «Визуализировать».

Вот и все. Мы протестировали работоспособность библиотеки Tao, инициализировав библиотеку OpenGL в C# .NET.

2D и 3D графика в OpenGL. На примере библиотеки freeglut мы познакомимся с тем, как работает 2D- и 3D-графика.

В статье мы познакомимся со стандартом OpenGL и напишем простейшее приложение, использующее API OpenGL.

Содержание

Клонируем репозиторий, создаём ветку

Для освоения OpenGL мы будем использовать репозиторий с примерами cg-course-2020/QtLabs2D. Если вы ещё не клонировали к себе этот репозиторий, клонируйте его. После этого вы можете переключиться на ветку stable в интерфейсе своего клиента git или в консоли.

Вы должны переключиться в существующую ветку, а не в новую. Возможно, перед началом потребуется синхронизировать репозитории ( git fetch origin ).

Теперь на основе ветки stable создайте ветку tmp_ , где вместо — ваше имя на латинице.

Ветку не нужно будет отправлять на удалённый репозиторий. Она временная.

Что такое OpenGL

OpenGL — это стандарт API для рисования трёхмерной графики. В нашем курсе будем использовать OpenGL 3.x — примерно то же самое, что GLES 2.x или WebGL 1.

Посмотрите на общую историю версий графических API, чтобы понять, где мы находимся:

За годы, прошедшие между OpenGL 1.x и OpenGL 3.x, представления программистов о 3D-графике изменились кардинально. Было обнаружено, что программный интерфейс, разработанный для OpenGL 1.0, имеет недостаточную гибкость и потворствует потерям производительности при рисовании графики. Начиная с OpenGL 3.0, была представлена полностью новая модель программирования с использованием OpenGL, а старый способ был объявлен устаревшим.

В последующие годы появились очередные новшества, такие как OpenGL 4.x и Vulkan. Они нацелены на сверхбыстрый параллелизм при вычислениях и на нестандартные применения видеокарт (например, для выполнения расчётов общего назначения с помощью Computing Shaders). Если же вы хотите изучить именно графику, не стоит оглядываться на OpenGL 4 и Vulkan: их использование даже в минимальных примерах требует прекрасного понимания 3D-графики, умения качественно писать многопоточный и асинхронный код, глубоких знаний в системном программировании.

OpenGL спроектирован для видеокарт

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

Современные видеокарты предоставляют огромные вычислительные возможности благодаря параллельной обработке вершин и фрагментов. Это хорошо показано на видео “CPU vs GPU” от NVIDIA:

Возможности OpenGL на конкретном компьютере зависят от операционной системы и от производителя драйвера. OpenGL на Linux и на Windows имеют разные возможности. OpenGL в драйверах от NVIDIA и в драйверах от Intel также различаются. Тем не менее, можно писать код, одинаково качественно работающий на любой реализации OpenGL — для этого нужно соблюдать стандарты и внимательно читать документацию используемых функций OpenGL.

Создаём сцену для работы с OpenGL

В наборе проектов QtLabs2D из шаблона Qt GUI Application создайте новый проект приложения с названием “Sample05”:

Удалите все файлы, кроме “main.cpp”. Перейдите к настройкам проекта и добавьте в пути поиска заголовочных файлов путь к корню репозитория. Это можно сделать, используя переменную SolutionDir:

Затем нужно добавить ссылку на проект libplatform, чтобы система сборки автоматически выполняла компоновку с ним.

Затем перепишите в “main.cpp” следующий код:

Наконец, соберите и запустите проект “Sample05”. Программа должна собраться успешно, после запуска программы отобразится окно размерами 800×600 (вероятно, залитое чёрным цветом).

Теперь создадим и подключим класс сцены. Создайте в проекте заголовок и “*.cpp” файл для класса SimpleScene.

В заголовке “SimpleScene.h” вам нужно подключить заголовок
, и затем перегрузить методы интерфейса IRenderScene:

Реализация класса пока что будет пустой:

Теперь можно передать объект класса сцены объекту окна. В функции main добавьте соответствующую инструкцию:

Путаница версий OpenGL

Интерфейс OpenGL состоит из функций и констант. В новых версиях OpenGL старые функции и константы исчезали (в режиме Core Profile) либо оставались в роли устаревших (в режиме Compatibility Profile).

Для использования OpenGL предоставляется заголовок . Какую версию OpenGL вы увидите в этом заголовке?

  • На Windows: OpenGL 1.1, API 1997-го года
  • На Android/iOS: зависит от версии NDK/SDK
  • На Linux/Mac OSX: зависит от способа подключения заголовка (набора макросов) и версии ОС

Реализацию OpenGL предоставляет видеодрайвер. Это означает, что на Windows с современной видеокартой NVIDIA вам может быть доступна последняя версия OpenGL, а с древней видеокартой — только версия 2.0 или даже 1.1.

На современных Linux/Mac OSX ситуация лучше: если видеокарта устаревшая, то новые возможности OpenGL буду эмулироваться программно. Это работает медленнее и нагружает центральный процессор, зато вам доступна новая версия OpenGL.

Как использовать OpenGL без привязки к версии платформы? Для этой в Qt5 есть класс QOpenGLFunctions_3_3_Core (и серия похожих классов). Вы можете унаследовать от него свой класс сцены

Также добавьте инициализацию функций OpenGL в метод initialize:

Устанавливаем glm

Для установки библиотек мы будем использовать пакетный менеджер vcpkg. Пакетный менеджер vcpkg распространяется в исходниках и собирается на машине разработчика. Для сборки потребуется установленная Visual Studio с инструментами C++ разработчика.

Порядок установки описан в консольных командах:

После того, как вы получили vcpkg.exe , вы можете устанавливать пакеты командой install .

В частности, нам потребуется установить GLBinding и GLM:

В команде, представленной выше, имена пакетов перечисляются по порядку, а в качестве суффикса используется так называемый “триплет”: имя_пакета:триплет .

  • Имя пакета задаёт одно из множества имён доступных библиотек, полный список есть в блоге Visual C++ Team
  • Триплет задаёт архитектуру и режим сборки

Для удобства использования пакетов vcpkg вы можете включить режим интеграции для всех проектов на своей машине одной командой:

Как работает OpenGL

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

Шаг №1 — загрузка вершин примитивов

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

Шаг №2 — обработка вершин примитивов вершинным шейдером

На втором шаге выполняется вершинный шейдер (англ. vertex shader): он получает на вход все данные одной из вершин, а на выход обязан предоставить четырёхкомпонентный вектор с координатами вершины и набор любых других данных для фрагментного шейдера:

Программист заранее указывает свой вершинный шейдер. Его пишут на специальном языке GLSL, затем он компилируется видеодрайвером и выполняется прямо на видеокарте.

Шаг №3 — интерполяция атрибутов вершин и фрагментация примитивов

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

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

  • вы указываете разные цвета для каждой из вершин треугольника
  • на шаге №3 видеокарта выполняет в каждом фрагменте линейную интерполяцию, вычисляя взвешенное значение цвета или любого другого атрибута

Линейная интерполяция — это интерполяция с линейным (равномерным) изменением свойства от вершины A к вершине B. Возьмём условный параметр t ∈ [0..1] , описанный следующим образом:

  • для фрагмента, содержащего вершину A, t = 0
  • для фрагмента, содержащего вершину B, t = 1
  • для фрагмента, лежащего между A и B ровно посередине, t = 0.5
  • и так далее для всех фрагментов между A и B

Линейно интерполированное свойство фрагмента будет вычисляться по формуле: p(t) = pA ∙ (1 — t) + pB ∙ t . Легко заметить, что эта формула работает для самих вершин A и B:

  • для вершины A: p(0) = pA ∙ (1 — 0) + pB ∙ 0 = pA
  • для вершины B: p(1) = pA ∙ (1 — 1) + pB ∙ 1 = pB

Конечный результат линейной интерполяции RGBA-цвета от вершин по всему треугольнику показан на рисунке:

Шаг №4 — обработка фрагментов фрагментным шейдером

На данном шаге снова вызывается пользовательский код в составе фрагментного шейдера (англ. fragment shader). Его также пишут на языке GLSL. Фрагментный шейдер получает на вход всё, что вершинный шейдер ему передал, но в преобразованном виде. Допустим, вершинный шейдер сохранил для фрагментного цвет вершины — но фрагментный шейдер оперирует фрагментами, и поэтому переданные данные также проходят линейную интерполяцию.

Цукерберг рекомендует:  Books - Литература для продакт менеджера

Шаг №5 — проверки, смешивание цвета и запись в буфер кадра

На последнем шаге фрагмент проходит ряд тестов — в каждом из них видеокарта проверяет, должен ли фрагмент попасть в кадр. Например, в 3D пространстве фрагмент может быть закрыт другим геометрическим телом, и это выявляется в тесте глубины (англ. depth test).

Если проверка пройдена (что в 2D графике случается почти всегда), то фрагмент записывается в пиксель кадра. Перед эти выполняется смешивание, позволяющее наложить полупрозрачный пиксель на существующий фон кадра.

Конвейер в целом

Все шаги конвейера изображены на единой схеме, взятой из статьи An intro to modern OpenGL. Chapter 1: The Graphics Pipeline:

Подготовка: RandomColorGenerator

Чтобы продемонстрировать работу интерполяции атрибутов вершин, мы будем генерировать цвета вершин случайным образом. Для этого создайте класс RandomColorGenerator. Объявление будет следующим:

Реализация генератора случайных цветов будет всего лишь выбирать цвет из готовой палитры:

Запускаем конвейер

Перейдите к “SimpleScene.cpp” и добавьте подключение заголовков glm. Заголовки пригодятся нам для работы с векторной алгеброй.

Создайте анонимное пространство имён и добавьте в него константы-строки, содержащие исходные коды вершинного и фрагментного шейдеров.

Анонимное пространство имён прячет константы и функции от других единиц трансляции (cpp-файлов), тем самым избавляя вас от неожиданных конфликтов имён функций.

Компиляция шейдеров

Что такое шейдер? Это маленькая программа на языке GLSL (расшифровывается OpenGL Shading Language). Задача программы зависит от типа шейдера: вершинный шейдер трансформирует вершины, фрагментный шейдер вычисляет цвет фрагмента фигуры. Шейдер работает как чистая функция: один вход, один выход и никаких состояний (вы не можете ничего запомнить между двумя вызовами шейдера).

Компиляция шейдера выполняется во время выполнения вашей программы. Компилятор шейдеров находится в ядре видеодрайвера. Руководит компиляцией ваша программа. В OpenGL разделены понятия “шейдер” и “программа”. Программа состоит из нескольких разнотипных шейдеров. Минимальная программа в OpenGL Core Profile состоит из вершинного и фрагментного шейдеров.

Общая схема компиляции шейдеров изображена ниже.

Для сборки шейдера мы будем использовать API OpenGL. Примерная схема вызовов (без обработки ошибок) выглядит следующим образом:

Добавьте классу SimpleScene три поля:

После этого в метод initialize() добавьте вызов нового приватного метода initializeShaders() , в котором будет размещена компиляция шейдеров и компоновка программы:

Приватный метод compileShader будет выполнять компиляцию шейдера и проверку статуса компиляции:

Приватный метод linkProgram выполняет компоновку программы из шейдеров:

В конце добавьте в деструктор SimpleScene удаление шейдерной программы и шейдеров:

Вершинные данные

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

Наши шейдеры ожидают два атрибута на каждую вершину: двумерные координаты и четырёхмерный цвет (RGBA). Поэтому мы поместим в начале заголовка “SimpleScene.h” определение структуры, которую мы назовём VertexP2C4:

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

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

Vertex Buffer Object и Vertex Array Object

Vertex Buffer Object — это объект видеодрайвера, представляющий область пользовательских данных на видеокарте. Для программиста VBO доступен в виде целочисленного идентификатора.

Чтобы хранить целочисленный идентификатор VBO, добавьте в SimpleScene поле GLuint m_vbo = 0; .

Кроме того, мы будем хранить Vertex Array Object — объект, позволяющий оптимизировать смену состояний видеодрайвера. Пока что мы используем VAO просто потому, что OpenGL требует хотя бы одного VAO, поэтому добавьте в класс ещё одно поле: GLuint m_vao = 0;

Затем в функцию initialize добавьте инициализацию VBO и VAO:

В конце добавьте деструктор классу SimpleScene, который будет очищать данные:

Триангуляция пятиугольника

Среди всех многоугольников в компьютерной графике предпочитают выпуклые многоугольники (англ. convex), т.к. их проще всего разделить на треугольники. Согласно википедии:

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

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

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

Добавьте в анонимное пространство имён функции триангуляции многоугольника:

Триангуляция круга

Разделить круг на треугольники легко с помощью тригонометрии: достаточно пройтись по углам от 0° до 360° с некоторым шагом, например, 1°. Каждый угол вместе с радиусом задаёт точку в полярных координатах.

Перевести полярные координаты в декартовы очень легко — достаточно вспомнить одно из определений синуса и косинуса:

Декартовы координаты по-английски называются Эвклидовыми (euclidean), и мы назовём функцию соответствующе:

Теперь мы можем описать функцию для триангуляции круга:

Выполняем триангуляцию двух фигур

Теперь мы можем триангулировать фигуры, чтобы получить результат, который вы видите на скриншоте:

Прежде всего добавьте в SimpleScene новое поле size_t m_vertexCount = 0; — позже число треугольников потребуется нам для рисования.

Добавим в main следующий код в метод initializeShapes, вызов которого надо поместить в конец метода initialize:

Устанавливаем матрицу проецирования

Казалось бы, что может быть проще, чем наложить виртуальные координаты холста на координаты окна? Однако, OpenGL устроен иначе: он рассчитан на 3D графику, в которой координаты виртуального мира не совпадают с координатами окна. Более того, начало координат OpenGL находится в нижнем левом углу, а не в верхнем левом!

Ради нужд 3D графики все координаты вершин проецируются внутрь куба размерами 2x2x2 условных единиц с помощью матрицы проецирования. Поскольку мы хотим получить 2D координаты, да ещё и совмещённые с привычными координатами окна, нам нужна матрица ортографического проецирования, которая растянет координаты вершин обратно из куба 2x2x2 в координаты окна. Для этой цели мы напишем метод setProjectionMatrix , выполняющий две задачи:

  • вычислить матрицу ортографического проецирования из куба на координаты окна с помощью функции glm::ortho
  • установить эту матрицу как константу в шейдерной программе с помощью glUniformMatrix4fv

Реализуем метод redraw

Метод redraw будет с использованием полученных размеров окна устанавливать так называемый Viewport, привязывать шейдерную программу и VAO, а затем очищать изображение, устанавливать матрицу проецирования, наконец, вызывать glDrawArrays для рисования всех примитивов.

Теперь вы наконец можете собрать, запустить и увидеть готовый результат!

10. Создание проекта и подключение библиотеки Tao OpenGL в С#

Сначала создайте новый проект, в качестве шаблона установив приложение Windows Forms.

Дождитесь пока MS Visual Studio закончит генерацию кода шаблона. Теперь перейдите к окну Solution Explorer (Обозреватель решений). Здесь, нас интересует узел Links, который отображает связи с библиотеками, необходимыми для работы нашего приложения (рисунок 1)

Щелкните по этому узлу правой клавишей мыши, после чего, в открывшемся контекстном меню выберите «Добавить ссылку» (“Add Link”), как показано на рисунке 2

В открывшемся окне «Добавить ссылку», перейдите к закладке обзор. После этого перейдите к директории, в которую была установлена библиотека Tao Framework. (По умолчанию — “C:Program FilesTao Framework”). Нам потребуется папка bin — в ней хранятся необходимые нам библиотеки. Перейдите в папку bin и выберите3 библиотеки, как показано на рисунке 3:

1. Tao.OpenGL.dll — отвечает за реализация библиотеки OpenGL

2. Tao.FreeGlut.dll — отвечает за реализацию функций библиотеки Glut. Мы будем ее использовать для инициализации рендера, а так же для различных других целей.

3. Tao.Platform.Windows.dll — отвечает за поддержку элементов непосредственно для визуализации непосредственно на платформе Windows.

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

// для работы с библиотекой OpenGL

// для работы с библиотекой FreeGLUT

// для работы с элементом управления SimpleOpenGLControl

Теперь вернитесь к конструктору диалогового окна и перейдите к окну Toolbox (панель элементов). Щелкните правой кнопкой на вкладке «Общие», и в раскрывшемся контекстном меню выберите пункт «Выбрать элементы» (Select elements), как показано на рисунке 4.

В открывшемся окне найдите элемент SimpleOpenGLControl и установите возле него галочку, как показано на рисунке 6. Затем нажмите ОК.

Теперь данный элемент станет доступным для размещения на форме приложения. Перетащите элемент на форму, и разместите так, как показано на рисунке 5. Справа от размещенного элемента установите 2 кнопки — «Визуализировать» и «Выйти».

Теперь выделите элемент simpleOpenGlControl1, расположенный на форме и перейдите к его свойствам. Измените параметр name на значение “AnT”. Далее во всех главах элементы simpleOpenGlControl мы будем называть AnT.

11. Инициализация OpenGL в C# .NET

Теперь нам необходимо инициализировать работу OpenGL.

Сначала мы в конструкторе класса должны инициализировать работу элемента AnT:

Снова перейдите к конструктору и сделайте двойной щелчок левой клавишей мыши на форме — создастся функция обработчик события загрузки формы.

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

private void Form1_Load(object sender, EventArgs e)

Glut.glutInitDisplayMode(Glut.GLUT_RGB | Glut.GLUT_DOUBLE | Glut.GLUT_DEPTH);

Gl.glClearColor(255, 255, 255, 1);

// установка порта вывода в соотвествии с размерами элемента anT

Gl.glViewport(0, 0, AnT.Width, AnT.Height);

Glu.gluPerspective(45, (float)AnT.Width / (float)AnT.Height, 0.1, 200);

// настройка параметров OpenGL для визуализации

На окне мы создали 2 кнопки. Обработчик кнопки выйти будет выглядеть следующим образом

//обработчик кнопки «выйти»

private void button2_Click(object sender, EventArgs e)

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

// обработчик кнопки «визуализировать»

private void button1_Click(object sender, EventArgs e)

Gl.glColor3f(1.0f, 0, 0);

Gl.glRotated(45, 1, 1, 0);

// рисуем сферу с помощью библиотеки FreeGLUT

Glut.glutWireSphere(2, 32, 32);

Откомпилируйте и запустите приложение.

Результат работы приложения показан на рисунке 9. Если вы правильно набрали все исходные коды и выполнили все описанные действия, то вы увидите аналогичную визуализацию сферы, после нажатия на кнопке «Визуализировать».

Вот и все. Мы протестировали работоспособность библиотеки Tao, инициализировав библиотеку OpenGL в C# .NET.

[SDL][OpenGL] Что выбрать для 2d?

Хочу немножко поиграться с 2d графикой (в планах возможна небольшая 2d игрушка). Что лучше выбрать в плане быстродействия, и вообще насколько подходит openGL для 2d графики?
Еще давно я поглядывал на SDL. Библиотека была неплоха, но по-моему уж слишком низкоуровневая.
Сейчас ковыряю openGL. Вроде бы пока все понятно, но не слишком ли она перегруженная для работы c 2D?
Также меня радует что openGL более известна и точно уж завтра не загнется, и возможно когда нибудь пригодится.
Уважаемый ЛОР, так что же выбрать мне?

SDL для обработки ввода и прочих платформозависимых штук, а opengl для вывода графики.

Если чисто спрайты будут без поворотов, то всё что угодно, если нужны повороты или 3д-искажения, то opengl

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

Также меня радует что openGL более известна и точно уж завтра не загнется

SDL тоже не загнётся, инфа 100%.

openGL Можно много красивостей налепить, используя шейдеры. Вдруг нужна будет простая 3д анимация, вроде вращающихся колёс. Освещение, или даже тени. Отрисовка множества прокси-объектов без тормозов.

Сам графическую составляющую для 2д движка делаю на опенЖЛ — одно удовольствие — возможностей немерено.

Для 2D — строго SDL, т.к. работает везде даже без 3d-ускорения.

Записки инженера

Доступным языком заметки по IT технологиям

Библиотеки для 2D графики (C/С++)

В один из моментов, я задался вопросом как мне вывести графику используя C++ (С). Я не хотел использовать такие популярные среды Builder или MS Visual с их библиотеками окон. Мне была нужна просто библиотека для работы с простой графикой в консоли.

Если судить по запросам в интернете и на форумах, этот вопрос возникал не только у меня.

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

Список библиотек

1. WinBGIm — портированная «старая» библиотека от компании Borland для Windows. Изначально она разрабатывалась для отображения графики под DOS.

2. Cairo — библиотека под лицензий GNU, поддерживается многими языками программирования (Delphi, Factor, Haskell, Lua, Perl, PHP, Python, Ruby, Scheme, Smalltalk и т.п.). Также поддержка большого количество операционных систем.

3. SDL — кроссплатформенная мультимедийная библиотека под лицензий GNU реализующая единый программный интерфейс к графической подсистеме, звуковым устройствам и средствам ввода для широкого спектра платформ.

Данная библиотека активно используется при написании кроссплатформенных мультимедийных программ (в основном игр). Поддерживается большим количеством языков программирования (C, C++, C#, VB.NET, D, Ada, Vala, Eiffel, Haskell, Erlang, Euphoria, Java, Lisp, Lua, ML, Pascal, Perl, PHP, Pike, PureBasic, Python и Ruby) и операционных систем (Linux, Microsoft Windows, Mac OS X, iOS и Android).

Из интересной особенности библиотеки, она позволяет работать с джостиком, CD-ROM и сетью.

4. SFML — простая и быстрая кроссплатформенная мультимедийная библиотека, доступная на языках: С++, C, D, Java, Python, Ruby, OCaml, .Net и Go. Является объектно ориентированный аналог SDL. Позволяет работать с аудио, сетью и окнами.

5. Allergo — кроссплатформенная библиотека позволяющая работать с 2D графикой, аудиофайлами, окнами, файловой системой, 3D графикой. Помимо этого библиотека предоставляет дополнительные функции по работе с числами с фиксированной, плавающей запятой и матрицами.

Изначально создавалась для разработки игр под Atari (Allergo расшифровывается как Atari Low-Level Game Routines), сейчас библиотека поддерживается языками: C, C++, Pascal, Python, Lua, Scheme, D, Go, Ada, Lisp, Mercury, Perl, Scheme. Есть поддержка под следующие платформы: Windows, macOS, Unix-подобные системы, Android и iOS.

6. SKIA — компактная графическая библиотека. Её использует в Google Chrome, Chrome OS, Chromium OS, Mozilla Firefox, Android (до 3.0), Firefox OS и Sublime Text 3. Библиотека работает на С и Python.

7. OpenGL (или glut) — библиотека на которой основываются некоторые из выше указанных. Я заявил о ней в самом конце списка, т.к. многие о ней слышали и она достаточно мощна для простых задач вроде 2D графики, но реализовывать она это может. Точнее даже сказать, OpenGL это спецификация, т.е. набор правил описывающих интерфейс, а разработчик оборудования (видеокарты) на её основе разрабатывает библиотеку. Реализуется на большом количество операционных систем и языков программирования.

8. DirectX — библиотека от компании Microsoft только для Windows. Изначально разрабатывалась именно для игр, является конкурентов OpenGL. Позволяет работать с большим количество периферии, сеть, звук, видео, 3D графика, 2D графика, клавиатура, джостик и т.п.

9. Direct2D — библиотека от Microsoft появилась с DirectX v.10. Задача библиотеки отображать 2D графику с использованием аппаратного ускорения, изначально реализовывалась для Windows 7.

Вам будет интересно:

Буду признателен если вы поделитесь данным постом

  1. Василий (iklife.ru) пишет:

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

Понравилась статья? Поделиться с друзьями:
Все языки программирования для начинающих