Как проверить opengl linux
Обновлено: 08.07.2024
Я пытаюсь выяснить, какая версия OpenGL для моей видеокарты и драйвера в настоящее время поддерживается.
Этот ответ предполагает запуск glxinfo | grep OpenGL glxinfo | grep OpenGL который, если хорошо, но вот (некоторые) этого вывода:
Так что трудно сказать, это 4.5 или 4.6?
Это самая высокая версия, поддерживаемая реализацией. Здесь есть несколько возможностей:
- Это число будет <= 3.1 для реализаций OpenGL, не поддерживающих современные профили OpenGL (введенные в 3.2).
- Это может быть самая высокая поддерживаемая версия профиля совместимости, если реализация поддерживает профиль совместимости и фактически возвращает контекст профиля совместимости при запросе устаревшего контекста
- Он также может быть <= 3.1 даже для реализаций, которые поддерживают GL> = 3.2 в профиле совместимости, но предпочли не выставлять его при запросе устаревшего контекста.
Собственный драйвер nvidia относится к категории 2.
Для основного профиля нет простого способа спросить реализацию, что она может поддерживать, как описано в этом ответе:
Этот вывод glxinfo не означает, что ваш драйвер не может выполнять 4.6 ядра. (Это на самом деле может). Это просто означает, что glxinfo не знает о присутствии GL 4.6 прямо сейчас, только проверяет только до 4.5.
Исходный код glxinfo покажет следующую логику:
поэтому он просто выполняет gl_versions через массив gl_versions и проверяет, можно ли создать контекст с этой версией.
И OpenGL 4.6 был добавлен в этот массив в этой фиксации 11 октября 2017 года:
Поэтому, если вы используете glxinfo который был скомпилирован по версии исходного кода до 11 октября (что означает в основном каждая версия дистрибутива прямо сейчас), он просто не покажет 4.6, даже если ваш драйвер может это сделать.
Так что трудно сказать, это 4.5 или 4.6?
Это 4,6 для совместимости и профиля ядра. Но я знаю только это, потому что я знаю этого водителя.
Запускаю скринсейверы. шахматы, пауки. тормозят страшно.
Почему тормозят они? и чем проверить ещё? так ли должно быть?
делаю glxgears
20042 frames in 5.0 seconds = 4008.340 FPS
20185 frames in 5.0 seconds = 4036.948 FPS
20286 frames in 5.0 seconds = 4057.140 FPS
20222 frames in 5.0 seconds = 4044.297 FPS
20042 frames in 5.0 seconds = 4008.340 FPS
.
Не супер, но сносно. Это когда на весь экран?
Покажите
Кстати, а композиты всякие выключены?
glxgears на весь экран.
2659 frames in 5.0 seconds = 531.705 FPS
2657 frames in 5.0 seconds = 531.008 FPS
2857 frames in 5.0 seconds = 571.364 FPS
direct rendering: Yes
xorg.conf не трогал, делал всё по инструкции wiki (method 2)
Если делать "Disable" - X - незапускаются
Ну вообще композит затормаживает 3D. Сам скринсейверы не юзаю, но возможно дело действительно в композите.
Вот посмотрел glxgears на весь экран
1477 frames in 5.0 seconds = 295.395 FPS
Nvidia, композит включен.
Погодите переставлять, подождём, народ с ATI-шными картами подтянется. Может чего посоветуют. у вас судя по показателям всё замечательно работает.
хотя почему тормозят шахматы, заставки - сложно сказать>_<
Но то, что 3дакселерация активна у вас - факт.
ЗЫ. Переставлять ничего не стоит=\ вот кстати, про переставить.
я пробовал ставить дрова и через установщик и через генерацию пакетов, и были неудачные попытки. в результате при использовании драйвера fglrx тормозит ужасно (стандартный ATI гораздо лучше себя ведет). Подозреваю, что какой-то "мусор" остался в системе от этих попыток. Как бы деинсталировать все и "прибраться"? Не подскажете?
единственный интуитивно понятный интерфейс - это соска.
_______________________________
у каждого свой любимый способ наступать на грабли
Привожу /var/log/Xorg.0.log.old при "Composite" "Disable" - Х не грузятся
Fatal server error:
no screens found
(WW) xf86CloseConsole: KDSETMODE failed: Bad file descriptor
(WW) xf86CloseConsole: VT_GETMODE failed: Bad file descriptor
(WW) xf86OpenConsole: VT_GETSTATE failed: Bad file descriptor
И
Как только закомметирую "composite" "disable" Х - запускаются
Странная штука, и при "Composite" "Enable" и при "Disable" X - падают :/
Linux не славится высокой игровой производительностью. Это нормально, так как несмотря на то что количество игр для этой платформы увеличивается, их все равно не так много. Да и инструменты, с помощью которых пользователи могли бы проверить свое оборудование можно сосчитать на пальцах.
Однако есть несколько программ, которые помогут вам точно определить особенности работы вашей видеокарты. Это нужно как для технического сравнения видеокарт, так и просто ради интереса. Вообще говоря, для тестирования видеокарты Linux можно использовать только тест OpenGL рендеринга. Возможно, ваша видеокарта не поддерживает новые версии Direct3D, но в Linux это проверить невозможно, поскольку эта технология поддерживается только в Windows, а нас будет интересовать только OpenGL.
Проверка видеокарты в Linux
1. Утилита glxgears
Программа glxgears это популярный OpenGL тест, который входит в пакет утилит mesa-utils. Для установки в Ubuntu выполните команду:
sudo apt install mesa-utils
Для тестирования выполните команду glxgears в терминале:
Программа откроет окно, в котором будут рендериться три вращающихся в 3D пространстве шестеренки. Частота кадров (FPS) измеряется и выводится в терминал каждые 5 секунд. Это очень старый инструмент и поэтому позволяет проверить только небольшую часть из возможностей современного OpenGL.
Раньше он использовался для проверки корректности установки и работы проприетарного видеодрайвера. Драйверы с открытым исходным кодом, как правило, работали ужасно, и это было очень заметно во время того, как выполнялся этот тест opengl linux. Сейчас же вы не заметите никакой разницы, по крайней мере, в glxgears.
2. GLMark2
GLMark2 - более мощный инструмент, выпущенный разработчиками дистрибутива Lenaro. В отличие от glxgears, glmark предлагает большое количество тестов для различных аспектов работы видеокарты (буферизация, освещение, текстурирование, построение и т. д.) что позволяет лучше оценить видеокарту.
Каждый тест проводится на протяжении 10-ти секунд, а частота кадров подсчитывается индивидуально. В конце программа выдает оценку производительности на основе всех проведенных тестов. Мне нравится этот инструмент своей простотой и безупречной работой. Вы можете найти его в официальных репозиториях большинства дистрибутивов под названием gmark2. Для установки в Ubuntu выполните:
sudo apt install glmark2
После установки проверка видеокарты может быть запущена командой:
3. GpuTest
Это небольшая современная утилита для тестирования видеокарты в Linux, она поддерживает несколько OpenGL тестов, в том числе и для современных стандартов. Вот поддерживаемые тесты: треугольник (OpenGL 2.1 или OpenGL 3.2), пиксельный тест шейдеров (OpenGL 2.1 или OpenGL 3.2), FurMark (OpenGL 2.1 или 3.2), Plot3D (OpenGL 2.1 или 3.2), GiMark и TessMark (OpenGL 4.0).
Утилиту можно запустить через терминал или с помощью графического интерфейса. Также кроме обычных OpenGL тестов можно выполнить нагрузочное тестирование. Удобно, что утилита сразу выводит результат в терминал, по которому можно сделать приблизительную оценку того как прошла проверка видеокарты linux. Для установки программы необходимо скачать и распаковать архив с портативной версией из официального сайта.
4. Набор программ Unigine
Для тех кому недостаточно первых трёх программ, и тех кто хочет чего-то более современного есть еще три инструмента которые используют 3D движок Unigine. Это Valley, Heaven и Superposition. Бесплатные версии можно скачать на официальном сайте.
Эти инструменты позволяют тестировать в реальном времени взаимодействие света из различных источников, рендеринг, реалистичное небо с рассеянным светом в атмосфере или воду. Можно настроить уровни сглаживания, качество текстур, фильтрацию, анизатропию и качество шейдеров.
Установочный файл занимает около 1,5 гигабайта. После загрузки просто выполните его для установки программы:
После этого вы сможете найти программу в главном меню системы. Запустите её:
На вкладке Benchmark вы можете выполнить тест производительности видеокарты. Чтобы выбрать параметры тестирования вручную переключите поле Preset в положение Custom или оставьте по умолчанию. Для запуска тестирования нажмите кнопку Run.
Во время тестирования в правом верхнем углу будет отображаться информация о видеокарте. Это объем памяти, частота, а самое главное температура. По завершении вы увидите оценку и сможете сравнить её с другими оценками в интернете:
Выводы
В этой статье мы рассмотрели с помощью каких программ выполняется проверка видеокарты Linux. Несмотря на то, что здесь есть не так много игр как для Windows, все же есть достаточно инструментов, которые можно использовать для тестирования OpenGL, если вы знаете другие отличные инструменты, напишите в комментариях!
Итак, я хочу узнать, какая у меня версия OpenGL. У меня есть доступ к Ubuntu через SSH. Какую команду мне выполнить?
Чтобы проверить версию OpenGL,
glxinfo | grep "OpenGL version"
Вы получите вывод следующим образом,
Редактировать:
Возможно, вам повезет больше с современным OpenGL, просто добавив слово «версия» вместо «версия OpenGL», учитывая различия между профилями ядра и компата, а также различными версиями GLSL и GLES:
Обратите внимание, что фактическая версия представлена «базовой версией профиля» (4.1), тогда как «версия OpenGL» представлена как 3.0.
Осторожный! glxinfo сообщает вам версию OpenGL, используемую вашим DISPLAY, а не удаленной машиной! Тем не менее, он сообщит вам версию GLX удаленного компьютера (биты "client"). И если вы получаете правильную карту, но неправильную версию OpenGL, это, вероятно, драйверы nouveau / open source - либо занесите их в черный список, либо удалите их. Я внес некоторые изменения, чтобы можно было найти лучшую информацию в современных версиях OpenGL, которые представляют несколько профилей, особенно с учетом того, что это лучший результат в поиске Google по запросу "Linux check opengl version". Примечание. В Ubuntu 16.04 glxinfo по умолчанию недоступно. Чтобы использовать его, вам нужно установить mesa-utils пакет. @frank Посмотрите на ответ ниже, автором thomasmichaelwallace в разделе «Библиотеки разработки». Когда вы запускаете клиент openGL на удаленном компьютере, удаленный клиент использует удаленные библиотеки, но отображается на вашем сервере, поэтому иногда это немного сбивает с толкув зависимости от того, что вы ищете:
Реализация Open GL
Вы можете использовать glxinfo из пакета mesa-utils:
Библиотеки развития
это зависит немного,
сообщит вам информацию о версии и т. д. любого пакета.
но вам нужно знать, какая конкретная часть / реализация и т. д. opengl вас интересует. Я подозреваю, для вас это будет:
Используйте X-forwarding при ssh-ing. Это включено с ssh -X .
Здесь я должен отметить, что это не та видеокарта и номера версий . («Неправильно» с точки зрения того, что вы ожидаете).
Установите DISPLAY переменную в :0 , чтобы разрешить доступ к драйверу графической карты из удаленного сеанса.
Здесь перечислены правильная видеокарта (та, что на удаленном компьютере), а также правильные номера версий.
Данный перевод подготовлен совместно с FERusM за что ему большое спасибо.
Заинтересовавшихся прошу под кат.
После установки GLFW самое время сделать простенькую программку, как это принято в подобных материалах, пусть это будет Hello World. Для начала нужно создать .cpp файл и подключить несколько заголовочников, также необходимо установить переменную GLEW_STATIC, которая указывает на то, что мы будем использовать статическую версию библиотеки GLEW.
Убедитесь в том, что подключение GLEW происходит раньше GLFW. Заголовочный файл GLEW содержит в себе подключение всех необходимых заголовочных файлов OpenGL, таких как GL/gl.h
Заметка от переводчика
Как заметил TrueBers это, предположительно, просто устаревший костыль и современные версии GLFW сами подключают требуемые библиотеки, правда если не установлен флаг GLFW_INCLUDE_NONE, а по умолчанию он не объявлен.
Далее напишем функцию main, пока что в ней будет создаваться окно GLFW. Она будет иметь следующий вид:
В данной функции мы сначала инициализируем GLFW вызывом функции glfwInit, после чего приступаем к его настройке, используя функцию glfwWindowHint. glfwWindowHint имеет очень простую сигнатуру, первым аргументом необходимо передать идентификатор параметра, который подвергается изменению, а вторым параметром передается значение, которое устанавливается соответствующему параметру. Идентификаторы параметров, а также некоторые их значения находятся в общем перечислении с префиксом GLFW_. Больше подробностей о настройке контекста GLFW можно найти в официальной документации GLFW. Если при запуске этого примера вы получаете ошибки, сильно похожие на неопределенное поведение, это значит то, что вы неправильно подключили библиотеку GLFW.
Поскольку в статьях будет использоваться OpenGL версии 3.3, то необходимо сообщить GLFW то что мы используем именно эту версию, что происходит в результате вызова метода glfwWindowHint c аргументами:
Таким образом, GLFW производит все необходимые действия при создании OpenGL контекста. Это гарантирует то, что если у пользователя нет необходимой версии OpenGL (в данном случае рассматривается версия 3.3), то GLFW просто не запустится. Помимо установки версии, мы явно указали на то, что будем использовать профиль GLFW_OPENGL_CORE_PROFILE. Это приведет к ошибке в случае использования устаревших функций OpenGL. Если вы используете Mac OS X, то необходимо добавить следующий вызов функции glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE) в код инициализации GLEW.
Убедитесь в наличии поддержки OpenGL версии 3.3 и выше вашим железом и наличие установленного OpenGL соответствующей версии в ОС. Для того, чтобы узнать версию OpenGL на вашем компьютере под Linux используйте glxinfo в консоли. Для Windows можно использовать программу OpenGL Extension Viewer. Если версия OpenGL ниже необходимой убедитесь в том что ваше железо поддерживает его и/или попробуйте обновить драйвера.
Теперь нужно создать объект окна. Этот объект содержит всю необходимую информацию об окне и используется функциями GLFW.
Сигнатура функции glfwCreateWindow требует следующие аргументы: “Высота окна”, “Ширина окна”, “Название окна” (оставшиеся аргументы нам не понадобятся). Возвращает указатель на объект типа GLFWwindow, который нам потом понадобится. Далее мы создаем контекст окна, который будет основным контекстом в данном потоке.
В прошлом уроке мы говорили, что GLEW управляет указателями на функции OpenGL, соответственно мы должны инициализировать GLEW, перед тем как вызывать какие либо функции OpenGL.
Заметьте, что мы установили переменную glewExperimental в GL_TRUE, перед тем как инициализировать GLEW. Установка значения glewExperimental в GL_TRUE позволяет GLEW использовать новейшие техники для управления функционалом OpenGL. Также, если оставить эту переменную со значением по умолчанию, то могут возникнуть проблемы с использованием Core-profile режима.
Viewport
Прежде чем мы начнем что-либо отрисовывать нам надо еще кое что сделать. Нам нужно сообщить OpenGL размер отрисовываемого окна, чтобы OpenGL знал, как мы хотим отображать данные и координаты относительно окна. Мы можем установить эти значения через функцию glViewport.
Первые 2 аргумента функции glViewport — это позиция нижнего левого угла окна. Третий и четвертый — это ширина и высота отрисовываемого окна в px, которые мы получаем напрямую из GLFW. Вместо того, чтобы руками задавать значения ширины и высоты в 800 и 600 соответственно мы будем использовать значения из GLFW, поскольку такой алгоритм также работает и на экранах с большим DPI (как Apple Retina).
Также мы можем задать меньшие значения для viewport. В таком случае, вся отрисовываемая информация будет меньших размеров, и мы сможем, к примеру, отрисовывать другую часть приложения вне viewport.
За кулисами OpenGL использует данные, переданные через glViewport для преобразования 2D координат в координаты экрана. К примеру позиция (-0.5, 0.5) в результате будет преобразована в (200, 450). Заметьте, что обрабатываемые координаты OpenGL находятся в промежутке от -1 до 1, соответственно мы можем эффективно преобразовывать из диапазона (-1, 1) в (0,800) и (0,600).
Подготавливаем двигатели
Мы не хотим, чтобы приложение сразу после отрисовки одного изображения упало. Мы хотим, чтобы программа продолжала отрисовывать изображения и обрабатывать пользовательский ввод до тех пор, пока ее не закроют. Для этого мы должны создать цикл, называемый игровым циклом, который будет обрабатываться до тех пор, пока мы не скажем GLFW остановиться.
Функция glfwWindowShouldClose проверяет в начале каждой итерации цикла, получил ли GLFW инструкцию к закрытию, если так — то функция вернет true и игровой цикл перестанет работать, после чего мы сможем закрыть наше приложение.
Функция glfwPollEvents проверяет были ли вызваны какие либо события (вроде ввода с клавиатуры или перемещение мыши) и вызывает установленные функции (которые мы можем установить через функции обратного вызова (callback)). Обычно мы вызываем функции обработки событий в начале итерации цикла.
Функция glfwSwapBuffers заменяет цветовой буфер (большой буфер, содержащий значения цвета для каждого пикселя в GLFW окне), который использовался для отрисовки во время текущей итерации и показывает результат на экране.
Двойная буферизация
Когда приложение отрисовывает в единственный буфер, то результирующее изображение может мерцать. Причина такого поведения в том, что отрисовка происходит не мгновенно, а попиксельно сверху слева, вправо вниз. Поскольку изображение отображается не мгновенно, а постепенно, то оно может иметь немало артефактов. Для избежания этих проблем, оконные приложения используют двойную буферизация. Передний буфер содержит результирующее изображение, отображаемое пользователю, в это же время на задний буфер ведется отрисовка. Как только отрисовка будет закончена, эти буферы меняются местами и изображение единовременно отображается пользователю.
Еще кое что
Как только мы вышли из игрового цикла, надо очистить выделенные нам ресурсы. Делается это функцией glfwTerminate в конце main функции.
Этот код очистит все ресурсы и выйдет из приложения. Теперь, попробуйте собрать приложение и если проблем с этим не возникнет вы увидите следующее:
Если у вас отобразилась скучнейшая черная картинка — то вы все сделали правильно! Если у вас отрисовывается что-то другое или у вас возникли проблемы с соединением всех примеров в уроке, то попробуйте этот исходный код.
Если у вас есть проблемы со сборкой приложения, для начала, удостоверьтесь, что линковщик в вашей IDE настроен верно (как было описано в прошлом уроке). Также удостоверьтесь, что ваш код не имеет ошибок. Вы можете с легкостью сравнить его с исходным кодом, представленным выше. Если у вас все еще возникают проблемы, просмотрите комментарии к исходной статье, возможно там вы найдете решение своей проблемы.
Для достижения некоего контроля над вводом, мы можем воспользоваться функциями обратного вызова в GLFW. Функции обратного вызова это указатели на функции, которые можно передать в GLFW, чтобы они были вызваны в нужное время. Одной из таких функций является KeyCallback, которая будет вызываться каждый раз, когда пользователь использует клавиатуру. Прототип этой функции выглядит следующим образом:
Эта функция принимает первым аргументом указатель на GLFWwindow, далее идет число описывающее нажатую клавишу, действие осуществляемое над клавишей и число описывающее модификаторы (shift, control, alt или super). Когда будет нажата клавиша, GLFW вызовет эту функцию и передаст в нее требуемые аргументы.
В нашей (новой) key_callback функции мы проверяем является ли нажатая клавиша клавишей ESC и если на нее нажали (а не отпустили) — то мы закрываем GLFW устанавливая свойство WindowShouldClose в true используя glfwSetWindowShouldClose. Следующая проверка состояния в игровом цикле прервет цикл и приложение закроется.
Осталось только передать это функцию в GLFW. Делается это следующим образом:
Существует большое количество функций обратного вызова, которые можно переопределить. К примеру мы можем переопределить функции для изменения размера окна, обработки ошибок и т.д. Зарегистрировать функцию обратного вызова надо после создания окна и до игрового цикла.
Отрисовка
Нам хотелось бы разместить все команды отрисовки в игровом цикле, так как мы хотим, чтобы отрисовка происходила на каждой итерации цикла. Это должно выглядеть как-то так:
Чтобы просто удостовериться в том, что все работает как надо мы будем очищать экран, заливая его своим цветом. В начале каждой итерации отрисовки зачастую надо очищать экран, иначе мы будем видеть результаты прошлой отрисовки (иногда действительно надо добиться такого эффекта, но зачастую это не так). Мы можем с легкостью очистить буфер, использовав glClear, в которую мы передадим специальные биты, чтобы указать какие конкретно буферы надо очистить. Биты, которые мы можем сейчас установить — это GL_COLOR_BUFFER_BIT, GL_DEPTH_BUFFER_BIT и GL_STENCIL_BUFFER_BIT. Сейчас нам надо очистить только цветовой буфер.
Заметьте, что мы также установили требуемый нами цвет, которым будет очищен экран, через glClearColor. Как только мы вызываем glClear весь буфер будет заполнен указанным цветом. В результату вы получите зелено-голубой цвет.
Как вы могли понять, glClearColor — это функция устанавливающая состояние, а glClear — это функция использующая состояние, которая использует состояние для определения цвета заполнения экрана.
Полный исходный код урока можно найти здесь.
Теперь у нас есть все, чтобы начать заполнять игровой цикл вызовами функций отрисовки, но мы прибережем это для следующего урока.
Читайте также: