Где расположены файлы opengl

Обновлено: 02.07.2024

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

Содержание

Структура API OpenGL

API OpenGL описан на языке C без применения C++ ради простоты и платформонезависимости. Он состоит только из функций, констант и примитивных типов, объявленных через typedef , таких как "typedef int GLenum;" .

Функции делятся на две группы:

команды (англ. commands) для изменения состояния драйвера
запросы (англ. queries) состояния драйвера

Вот несколько примеров:

функция-команда void glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) устанавливает цвет очистки; RGBA компоненты цвета передаются как число с плавающей точкой на отрезке [0..1] .
функция-команда void glClear() очищает буфер кадра путём заливки пикселей цветом очистки.
функция-запрос const GLubyte *glGetString(GLenum name) возвращает строковое значение некоторой константы или величины в видеодрайвере, выбор величины зависит от параметра name ; при этом const GLubyte* можно преобразовать в const char* с помощью reinterpret_cast .
тип данных GLclampf означает “число с плавающей точкой на отрезке [0..1] ”; при этом никаких проверок принадлежности диапазону компилятор делать не будет, потому что тип объявлен просто как typedef float GLclampf .

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

Обработка ошибок

OpenGL старательно обрабатывает ошибки, такие как “недопустимый аргумент”, “неправильная константа enum”, “несвоевременный вызов команды”. Узнать о наличии общей ошибки в одной из предыдущих функций-команд можно функцией-запросом GLenum glGetError() .

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

Условно, код может выглядеть так:

Функцию можно улучшить, если учесть следующее:

Распечатать строку ошибки можно в поток ошибок std::cerr
Любую ошибку можно считать фатальной, вызывая std::abort для аварийного завершения программы после вывода текста ошибки
Функцию можно сделать статическим методом класса CUtils

Представим улучшенную версию:

После добавления этого метода можно улучшить основной цикл приложения:

Расширения OpenGL

В целях максимальной гибкости, все изменения в OpenGL вносятся в виде расширений. Расширение OpenGL — это задокументированная спецификация, которая описывает новые функции и их поведение, изменения в поведении старых функций и новые константы. Каждое расширение имеет имя, например, "GL_ARB_multitexture" . При выпуске новой версии OpenGL часть расширений попадает в новую версию и становится частью ядра OpenGL. Таким образом, в версии OpenGL 3.0 и выше вы автоматически получаете ряд возможностей, которые в OpenGL 1.2 были доступны только как расширения.

В UNIX-системах и на мобильных устройствах доступны достаточно свежие версии OpenGL (обычно 3.0 и выше), где многие важные расширения уже стали частью ядра стандарта.
В Windows версии старше OpenGL 1.1 напрямую недоступны, но разработчики драйверов дают доступ к ним через механизм расширений. Если видеодрайвер не установлен, будет доступен только OpenGL 1.1, обладающий весьма ограниченными возможностями.

Функция, описанная в расширении, может не существовать в конкретной реализации OpenGL (если она не поддерживает данное расширение). Поэтому программист должен

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

В стандарте OpenGL не описан способ получения адреса, и каждая операционная система или мультимедийная библиотека предоставляет свой способ. В SDL2 есть функция void *SDL_GL_GetProcAddress(const char *proc) , которая по имени OpenGL-функции возвращает её адрес или nullptr , если функция недоступна.

Получение информации о версии OpenGL

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

константа с именем GL_VERSION возвращает строку версии OpenGL, причём в начале строки обязательно стоит "<номер мажорной версии>.<номер минорной версии> " , а остальная часть строки не определена. Например, строка "3.0 Mesa 10.3.2" обозрачает “OpenGL версии 3.0, реализуемый подсистемой графики Mesa версии 10.3.2”.
константа с именем GL_VENDOR возвращает имя поставщика реализации OpenGL. Например, строка "Intel Open Source Technology Center" обозначает “Видеодрайвер предоставлен OpenSource-подразделением корпорации Intel”.
константа с именем GL_EXTENSIONS содержит полный список расширений, разделённый пробелами. Список обычно насчитывает свыше ста расширений.

Функция печати информации о контексте

Следуя “правилу трёх ударов”, можно отрефакторить этот код:

Библиотека GLEW

Запрашивать функции и проверять расширения вручную не всегда удобно. Для решения этой типовой задачи создана библиотека GLEW (сокращение от “openGL Extensions Wrapper”). С помощью макросов и отложенной загрузки адресов функций эта библиотека позволяет использовать расширения так, как будто бы никаких расширений не существует:

вы просто вызываете функции по имени; если функции нет, произойдёт разыменование нулевого указания
также вы можете использовать модифицированное имя расширения (с префиксом “GLEW_” вместо “GL_”) как целочисленную переменную со значением 0 или 1; 1 означает, что расширение есть и доступно, 0 означает, что расширения нет или оно недоступно
если расширение недоступно, вы не должны вызывать функции расширения, чтобы не получить разыменование нулевого указателя
если при создании контекста OpenGL вы потребовали и получили контекст не ниже определённой версии, то можно даже не проверять расширения, вошедшие в эту версию: они есть.

Подключать заголовок glew.h следует до первого включения gl.h , иначе вы получите ошибку при компиляции.

Библиотека GLEW требует явного вызова функции glewInit для своей инициализации. Сделать вызов следует только один раз. Чтобы не накладывать на класс CAbstractWindow лишних ограничений, нужно гарантировать, что при первом конструировании объекта CAbstractWindow функция будет вызвана, а при последующих — уже нет. Также надо установить глобальную переменную-флаг glewExperimental , чтобы GLEW оборачивала функции из версий OpenGL 3.x и 4.x.

Для этой цели можно использовать два подхода

взять из стандартного заголовка <mutex> функцию std::call_once
завести в функции статическую переменную типа bool, которая будет устанавливаться в false в инициализаторе (который для статических переменных внутри функции вызывается ровно один раз)

В многопоточной среде было бы правильным использовать call_once, чтобы исключить возможность повторного вызова инициализации во время выполнения “glewInit” в другом потоке. Однако, ни контекст OpenGL, ни GLEW не могут использоваться из нескольких потоков одновременно. Поэтому call_once нам не потребуется, и достаточно статической переменной типа bool:

Узнаём о расширениях через GLEW

Читать полный список расширений, полученный через glGetString(GL_EXTENSIONS) , не очень удобно. Сканировать его программно слишком трудоёмко в плане вычислений.

Для удобного получения расширений у GLEW есть переменные-флаги, которые устанавливаются при вызове glewInit() . Для проверки наличия расширения надо:

Теперь можно улучшить функцию PrintOpenGLInfo :

На машине с Ubuntu 14.04 и встроенной видеокартой Intel программа выводит следующее:

На машине с Windows 8 и видеокартой Intel вывод отличается:

Создаём работоспособное приложение

Код запроса версии OpenGL разместим в классе CWindow , потому что в дальнейших примерах нам уже не нужно будет печатать что-либо в консоль.

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

Заинтересовавшихся прошу под кат.

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

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

В основном в этом и следующем уроке мы будем заставлять GLFW нормально работать, проверять правильность создания OpenGL контекста и производить отрисовку окна в котором мы будет рисовать графику. Этот урок пошагово расскажет о сборке и линковке GLFW библиотеки. Для этого урока мы будем использовать Microsoft Visual Studio 2012 (заметьте, что процесс будет мало отличаться для других версий VS). Если вы не используете VS — то не волнуйтесь, этот процесс очень похож для всех IDE.

Сборка GLFW

GLFW можно скачать со страницы загрузки официального сайта. GLFW поставляется с прекомпилированными бинарниками и заголовочными файлами для VS, но для полноты картины мы соберем GLFW собственноручно. Так что давайте скачаем пакет с исходным кодом (Source package).

Если вы используете прекомпилированные бинарники — удостоверьтесь, что вы скачали 32 битную версию, а не 64 битную. (Если вы не знаете в чем существенная разница). Так как 64 битная версия генерирует довольно странное поведение для большинства читателей.

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

Результат компиляции
Папка include

CMake

CMake — это инструмент для генерации файлов Проекта/Решения для IDE, выбранного пользователем (Visual Studio, Code::Blocks, Eclipse) из набора исходных кодов и CMake скриптов. Такая конфигурация позволяет сгенерировать Visual Studio 2012 проектные файлы, чтобы мы могли без труда собрать библиотеку. Для начала нам надо скачать CMake, сделать это можно на странице загрузки. Я использую Win32 установщик.

Как только CMake установится, вы сможете выбрать запуск CMake из консоли или в качестве графического приложения. Так как мы стараемся не перегружать уроки — то мы выберем графическое приложение. CMake требует указать директорию с исходным кодом и папку, куда будет записан результат в виде бинарных файлов. В качества директории с исходным кодом мы укажем корневую папку разархивированного GLFW пакета с исходным кодом, а в качестве папки для бинарных файлов мы укажем новую директорию <build.

После установки требуемых директорий, нажмите Configure, что бы CMake считал требуемые настройки и исходный код. Затем нам требуется выбрать генератор для проекта. Так как мы собираемся использовать Visual Studio 2012 мы выбираем Visual Studio 11 (Visual Studio 2012 также известна как Visual Studio 11). Далее CMake отобразит возможные настройки сборки, их можно оставить без изменения, нажав еще раз на Configure для их сохранения. После сохранения настроек можем приступать к генерации проекта, для этого нажмите на Generate и в папке build будут созданы файлы проекта.

Компиляция

В папке build появился файл GLFW.sln, открываем его Visual Studio. CMake должен был сгенерировать проект со всеми требуемыми настройками, поэтому просто начинаем сборку, нажимая на Build Solution и в качестве результата мы получае glfw3.lib (мы используем 3 версию) в папке src/Debug,

После того, как библиотека сгенерировалась надо удостовериться, что IDE знает где искать библиотеку и заголовочные файлы. Есть 2 способа сделать это:

Наш первый проект

Для начала давайте откроем Visual Studio и создадим новый проект. Выберите Visual C++ и Пустой проект (не забудьте выдать проекту приемлемое имя). Теперь у нас есть рабочее пространство для создания нашего первого приложения с использованием OpenGL.

Линковка

Для использования GLFW нам также требуется его связать с нашим проектом. Это делаеться, указанием, что мы хотим использовать glfw3.lib в настройках линковщика, но наш проект все еще не знает, где искать glfw3.lib (если вы не выбрали 1 вариант во время решения проблемы с местонахождением файлов библиотек), соответственно нам надо добавить эти директории в проект.

Мы можем добавить те директории, для этого перейдите в VC++ Directories, как показано на изображении ниже:

И оттуда вы можете добавить собственные директории, чтобы проект знал где искать требуемые файлы. Это можно сделать ручным способом, просто вставив путь в текстовое поле, либо нажав на Edit…, где вы сможете добавить значения в специальном окне.

Здесь вы можете добавить такое количество директорий, какое вам захочется, а IDE также будет искать требуемые файлы там. Теперь, когда Include папка указана для среды вы сможете найти все требуемые заголовочные файлы GLFW в <GLFW/..>. Тоже самое применимо и для директории с библиотеками.

И уже после того, как Visual Studio узнал, где искать требуемые библиотеки, мы наконец можем связать GLFW и наш проект:

Здесь требуется указать название линкуемой библиотеки, в нашем случае это glfw3.lib и добавляем мы ее в поле Additional Dependencies (сделать это также можно изменив руками или использовав кнопку <Edit…>) и теперь GLFW будет линковаться к проекту во время компиляции. Также требуется указать OpenGL библиотеки, но этот процесс отличается для разных ОС.

OpenGL библиотека для Windows

Если вы используете Windows — то библиотека, называющаяся opengl32.lib поставляется с Microsoft SDK, которая ставится по умолчанию при установке Visual Studio. Так как в этом уроке мы и так использует Visual Studio — то здесь будет достаточно просто добавить opengl32.lib в настройки линковщика.

OpenGL библиотека для Linux

На Linux системах вам требуется использовать libGL.so библиотеку, использовав флаг -lGL в настройках линковщика. Если вы не можете найти эту библиотеку — то вам, вероятно, требуется поставить Mesa, NVidia или AMD dev пакеты, но я не буду вдаваться в подробности, так как это очень специфично для платформы (плюс я не являюсь Linux экспертом).

По окончанию добавления GLFW и OpenGL библиотеки в настройки линковщика вы можете подключать GLFW следующим образом:

Это финальный этап установки и настройки OpenGL.

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

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

Сборка и линковка GLEW

GLEW расшифровывается как OpenGL Extension Wrangler Library и управляем всей той громоздкой работой о которой говорилось выше. Поскольку GLEW это тоже библиотека — то нам опять придется собрать ее и связать с нашим проектом. GLEW может быть скачан с официальной страницы, там вы найдете как уже прекомпилированные библиотеки, так и исходный код. И опять же повторюсь: если вы не уверены какую битность использовать — используйте 32 битную версию.

Мы будем использовать статическую версию GLEW, которая называется glew32s.lib (заметьте приставку `s`). Поэтому добавьте ее в вашу папку с библиотеками, а также добавьте заголовочные файлы в вашу папку с заголовочными файлами. Теперь мы можем линкануть GLEW к проекту, добавив glew32s.lib в настройки линковщика в Visual Studio. Заметьте, что GLFW3 по умолчанию собирается как статическая библиотека.

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

Динамическая линковка осуществляется посредством .dll и .so файлов, осуществляя разделение кода библиотеки и кода приложения, уменьшая размер исполняемого файла и упрощая обновление библиотеки. Недостатком такого подхода является тот факт, что вам придется выпускать DLL файлы вместе с финальным приложением.

Если вы хотите использовать GLEW как статическую библиотеку — то перед подключением GLEW следует задать переменную препроцессора GLEW_STATIC.

Если вы хотите динамическое связывание — то вы можете опустить задачу переменной препроцессора GLEW_STATIC. Помните, что если вы используете динамическое связывание то вам придется скопировать .DLL файл в папку с исполняемым файлом.

Для пользователей Linux, собирающих проект с помощью GCC в сборке могут помочь следующие ключи:

-lGLEW -lglfw3 -lGL -lX11 -lpthread -lXrandr -lXi.

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

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

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

Обновляем OpenGL в Windows 7

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

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

Способ 1: Обновление драйверов видеокарты в Windows 7

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

Способ 2: Обновление компонентов в фирменной утилите видеокарты

Сейчас основными производителями графических адаптеров являются AMD и NVIDIA. У каждого имеется собственный софт, который обеспечивает корректную работу с операционной системой и позволяет обновлять ПО. Обладателям видеокарт NVIDIA советуем обратиться к материалу по следующей ссылке, чтобы разобраться с установкой новой версии драйвера OpenGL в GeForce Experience.

Владельцам карточек от AMD нужно ознакомиться с другими статьями, поскольку в данном случае все действия выполняются в Catalyst Control Center либо в Radeon Software Adrenalin Edition, в зависимости от типа установленного ПО.

Способ 3: Обновление DirectX

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

На данный момент последней версией для ОС Виндовс 7 является DirectX 11. Если у вас инсталлирована более ранняя библиотека, советуем обновить ее и проверить работоспособность ПО. Развернуто на эту тему читайте в другом материале.

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

Мы рады, что смогли помочь Вам в решении проблемы.

Отблагодарите автора, поделитесь статьей в социальных сетях.

Опишите, что у вас не получилось. Наши специалисты постараются ответить максимально быстро.

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

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

Библиотека GLFW

Основное внимание на этом и следующем уроках уделяется изучению библиотеки GLFW, созданию корректного контекста OpenGL, а также простого окна, в котором мы и будем рисовать наши объекты. На этом уроке мы пошагово рассмотрим установку библиотеки GLFW, а также процесс сборки и компиляции программы в связке с GLFW.

Примечание: На момент написания данной статьи в качестве среды разработки мы будем использовать Microsoft Visual Studio 2019 (обратите внимание, что наши действия будут аналогичными и с более старыми версиями Visual Studio). Если же вы используете более старую версию Visual Studio (или вообще другую среду разработки), то можете быть спокойны, т.к. процесс установки и настройки GLFW аналогичен в большинстве IDE.

Сборка GLFW

Библиотеку GLFW можно скачать с официального сайта. Стоит отметить, что GLFW уже имеет предварительно скомпилированные бинарные и заголовочные файлы для Visual Studio 2010-2019, но для полноты картины их мы использовать не будем, а вместо этого вручную скомпилируем GLFW из исходного кода. Это делается для того, чтобы вы сами прочувствовали процесс компиляции библиотек с открытым исходным кодом, поскольку не каждая подобная библиотека будет предоставлять возможность скачать предварительно скомпилированные бинарные файлы. Итак, давайте загрузим пакет с исходным кодом.

Примечание: Мы будем собирать все библиотеки в формате 64-битных бинарных файлов, поэтому убедитесь, что скачиваете и используете именно 64-битные бинарные файлы.

После загрузки пакета с файлами исходного кода извлеките и откройте его содержимое. Нас интересуют следующие вещи:

библиотека, которая будет получена в результате компиляции;

Компиляция библиотек из исходного кода гарантирует, что полученная нами библиотека идеально подойдет для нашего процессора и операционной системы, в то время как предварительно скомпилированные бинарные файлы не всегда могут этим похвастаться (иногда они вообще недоступны для вашей системы). Однако проблема проектов, распространяющихся под эгидой открытого программного обеспечения, заключается в том, что не все используют одну и ту же IDE или систему сборки для разработки своего приложения, а это значит, что предоставленные файлы проекта/решения могут быть несовместимы с настройками IDE у других людей. Следовательно, каждый конечный пользователь должен настроить свой собственный проект/решение с учетом полученных *.с / *.cpp и *.h / *.hpp файлов, что почти всегда является довольно трудоемким и громоздким процессом. Но не спешите расстраиваться, для решения данной проблемы уже существует удобный инструмент сборки проектов под названием CMake.

CMake

CMake — это инструмент, который с использованием заранее определенных сценариев может из коллекции файлов исходного кода сгенерировать файлы проектов/решений под выбранную пользователем IDE (например, для Visual Studio, Code::Blocks или Eclipse). Он позволит нам из исходного пакета файлов GLFW создать файл проекта под среду разработки Visual Studio 2019, а затем данный файл мы сможем использовать для компиляции библиотеки. Но сначала нам нужно его скачать, а затем установить.

После установки CMake у вас будет 2 варианта:

запустить CMake из командной строки;

запустить CMake через графический интерфейс.

Поскольку мы не стремимся всё усложнять, то остановимся на варианте с использованием графического интерфейса. Для работы с CMake нам потребуется указать папку с файлами исходного кода проекта (в нашем случае glfw-3.3.2 ) и папку назначения для бинарных файлов. Для папки исходного кода мы собираемся выбрать корневую папку загруженного исходного пакета GLFW, а для папки сборки мы создадим новый каталог build :

После того, как мы прописали пути для исходной и целевой папок, нам нужно нажать кнопку Configure , чтобы CMake смог просмотреть исходные файлы GLFW и выбрать необходимые параметры для сборки.

В следующем окне необходимо задать используемую версию Visual Studio. Т.к. работать мы будем в Visual Studio 2019, то выбираем опцию "Visual Studio 16 2019" :

Далее CMake отобразит возможные варианты сборки библиотеки. Можно оставить значения по умолчанию и снова нажать кнопку Configure , чтобы сохранить настройки:

После установки параметров мы нажимаем кнопку "Generate" , в результате чего в папке build будут созданы необходимые файлы проекта.

Компиляция проекта

Теперь, зайдя в папку build , среди всего прочего можно увидеть файл с именем GLFW.sln , открываем его с помощью Visual Studio 2019:

Поскольку CMake сгенерировал файл проекта, который уже содержит соответствующие параметры конфигурации, нам остается лишь реализовать решение. При этом CMake должен был автоматически настроить вариант компилирования решения в виде 64-битной библиотеки. Благодаря этому мы получим скомпилированный файл библиотеки с именем glfw3.lib , который будет находиться в папке build/src/Debug .

После того, как мы создали библиотеку, нужно убедиться, что IDE знает, где найти данный файл, а также другие подключаемые файлы нашей программы OpenGL. Решить этот вопрос можно двумя способами:

Способ №1: Можно скопировать содержимое папки include проекта GLFW в соответствующую папку include вашей IDE или компилятора, а также скопировать полученный файл glfw3.lib в соответствующую папку /lib вашей IDE или компилятора. Данный способ вполне рабочий, но мы его не рекомендуем, так как новая установка IDE или компилятора приведет к тому, что вам заново придется подключать необходимые файлы.

Способ №2: Вы можете создать новую папку, которая будет содержать все заголовочные файлы и файлы из сторонних библиотек. На эту папку вы впоследствии сможете ссылаться из своей IDE или компилятора. Например, можно создать папку, в которой будут находиться папки Lib и Include . В них мы будем хранить все наши библиотечные и подключаемые файлы, которые собираемся использовать для наших OpenGL-проектов. Получается, что все сторонние библиотеки будут организованы в одном месте (и их можно будет совместно использовать на нескольких компьютерах). Однако, каждый раз при создании нового проекта, мы должны будем указывать IDE соответствующие пути к этим папкам.

Как только необходимые файлы будут сохранены в выбранном вами месте, мы сможем приступить к созданию нашего первого OpenGL-GLFW-проекта.

Наш первый проект

Для начала давайте откроем Visual Studio и создадим новый проект. Для этого нужно выбрать тип проекта "C++" , а далее — "Пустой проект" (не забудьте дать проекту подходящее имя):

Теперь у нас есть рабочее пространство для создания нашего самого первого OpenGL-приложения!

Линкинг проекта

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

Для этого нажмите правой кнопкой мышки на имя проекта в "Обозреватель Решений" > "Свойства" . В появившемся окне выберите "Каталоги VC++" > "Каталоги библиотек" :

Здесь вы можете добавить свои собственные каталоги, чтобы проект знал, где искать необходимые файлы. Это можно сделать, вставив вручную путь до каталога или щелкнув по соответствующей строке и выбрав пункт <Изменить…> , в результате чего откроется следующее окно:

Здесь вы можете добавить столько дополнительных каталогов, сколько захотите, и с этого момента IDE при поиске файлов библиотек также будет просматривать и эти директории. Поэтому, как только вы подключите папку Lib из проекта GLFW, вы сможете использовать все файлы библиотек из этой папки. Аналогично обстоят дела и с добавлением папки Include для заголовочных файлов.

Поскольку для VS были указаны все необходимые файлы, то мы, наконец, можем связать GLFW с нашим проектом, перейдя в раздел "Компоновщик" > "Ввод" :

Чтобы связать библиотеку, нам нужно указать для компоновщика её имя. Так как библиотека называется glfw3.lib , то мы добавляем название этого файла в раздел "Дополнительные зависимости" (вручную или же через пункт <Изменить…> ), и с этого момента при запуске процесса компиляции GLFW будет связан с нашим проектом. В дополнение к GLFW мы также должны добавить ссылки на библиотеку OpenGL, но данные действия будут отличаться, в зависимости от (вашей) используемой операционной системы:

Библиотека OpenGL в Windows. Если вы используете операционную систему Windows, то необходимый нам файл библиотеки OpenGL32.Lib , входящий в пакет Microsoft SDK, уже есть в составе Visual Studio и не требует отдельной установки. Поскольку мы используем компилятор VS и работаем в операционной системе Windows, то всё, что вам нужно сделать — это добавить название файла OpenGL32.Lib к общему списку параметров компоновщика.

Больше того, если зайти в папку C:\Program Files (x86)\Windows Kits\10\Lib\[Номер_версии_SDK]\um\x86\, то и там можно встретить файл OpenGL32.Lib:

Библиотека OpenGL в Linux. Если вы работаете в операционной системе Linux, то вам нужно подключить библиотеку libGL.so с помощью ключей –lGL , добавляемых к параметрам вашего компоновщика. Если вы не можете найти данную библиотеку, то вам, вероятно, необходимо установить любой из пакетов: Mesa, NVidia или AMD dev.

Затем, после добавления библиотек GLFW и OpenGL в настройки компоновщика, вы сможете подключить заголовочные файлы GLFW следующей строкой кода:

Читайте также: