OpenGL Extension Viewer для Windows
OpenGL Extension Viewer – это универсальная программа позволяющая получить подробную информацию о графической OpenGL подсистеме драйвера видеокарты. Она также выдает подробную информацию о поддерживаемых видео драйвером режимах работы и предоставляет возможность настройки целого ряда функций рендеринга.
- отображение степени соответствия драйвера различным версиям стандарта OpenGL (1.1 — 4.3) отдельно по расширениям и целиком
- отображение подробной информации о каждом поддерживаемом расширении и его функции
- отображение информации о поддержке разнообразных функций и технологий рендеринга драйвером
- наличие списка поддерживаемых видеорежимов и форматов изображения
- предоставление "быстрого отчета", включающего информацию о важных недостатках и преимуществах благодаря поддержке тех или иных функций или ее отсутствии
- встроенные 3D-тесторы с поддержки OpenGL от версии 1.1 до 4.3 с возможностью настройки некоторых функций рендеринга и замера уровня быстродействия
- активация некоторых скрытых расширений OpenGL
- предоставление доступа к полной базе данных по всем расширениям на основе любого фильтра производитель/видеокарта/расширение
AIDA64 Extreme Edition — незаменимое приложение для диагностики ПК с возможностью проведения.
CPU-Z — небольшая полезная программа, с помощью которой вы получите всю информацию об.
FurMark — мощный инструмент, который будет в первую очередь полезен оверклокерам, позволяющий.
CrystalDiskMark — небольшая бесплатная программа, предназначенная для сравнительного анализа.
GPU-Z — отличная утилита для просмотра разнообразной информации о видеокарте и ее.
Core Temp — утилита, которая в режиме реального времени отображает температуру Вашего.
Отзывы о программе OpenGL Extension Viewer
Minescar227 про OpenGL Extension Viewer 6.1.2 [17-03-2021]
Отвечаю, это работает, там сверху, после загрузки программы, появится значок загрузить в верхнем левом углу, после загрузки перезагрузить пк!
| | Ответить
Tимофей про OpenGL Extension Viewer 6.1.2 [21-10-2020]
Вообще я скачал на телефон но перенес на комп щас загружается пока не известно заработает или нет)) (Windows 7 начальная)
1 | 1 | Ответить
ETOGG про OpenGL Extension Viewer 5.1.1 [30-04-2019]
у меня проблема мне переустановили виндовс 7 32 бит на виндовс 7 86 бит когда захожу в майн у меня вылетает и пишет что драйвера не совместимы ((((((((((((((((((((((((
6 | 22 | Ответить
ДОНЕЙШЕН в ответ ETOGG про OpenGL Extension Viewer 6.0.1 [27-02-2020]
ETOGG 32 bit это тоже самое что и 86 bit
| 12 | Ответить
Михаил про OpenGL Extension Viewer 5.1.1 [30-12-2018]
парп про OpenGL Extension Viewer 5.1.1 [16-09-2018]
У меня на виндеXP не идёт. Что делать?
7 | 11 | Ответить
Rox в ответ парп про OpenGL Extension Viewer 5.1.1 [18-07-2019]
Opengl extensions viewer как пользоваться
Краткое описание:
Отображает имя производителя, версию, имя визуализации для OpenGl ES.
Описание:
From the makers of the famous OpenGL Extensions Viewer on PC and Mac, the Android version can access each extension documentation, renderers capabilities.
Ideal if you are developing application for Android,
CPU information, Android OS revision are also reported.
Main key features:
• Reports Android version, model and CPU.
• Reports OpenGL ES information and gives access to OpenGL Extension extension specification online (requires internet connection).
• Submit your OpenGL EX information into to the Cloud storage and check the results on the Mac and PC version.
• Free of charge.
OpenGL 2.0: программируемый, масштабируемый и расширяемый
Для того чтобы ближе познакомиться с описываемым софтом мы приведем его основные возможности:
- При помощи данной графической библиотеки можно реализовать функции описания примитивов нижнего уровня иерархии.
- Поддерживаются функции описания источников света.
- Функции задания атрибутов.
- При помощи технологии реализуется наилучшая визуализация на том или ином аппаратном обеспечении.
- Также есть технология геометрических преобразований.
Рассматривать возможности описываемой в статье библиотеки можно еще долго. Но для того чтобы не терять времени, давайте сразу переходить к делу и говорить, как бесплатно скачать OpenGL 2 для Windows 10, а также, как правильно установить данное программное обеспечение.
Немного истории данного продукта
В эпоху бурного распространения 3D – компьютерных игр возникала сложность с реализации программного кода при использовании разных устройств (процессора, видеокарты, памяти, материнской платы). Это удорожало и замедляло выпуск новых игр, программных продуктов, кино и мультфильмов, построенных с использованием компьютерной графики.
Компания Silicon Graphics – лидер того времени в производстве оборудования для воспроизведения трехмерной графики. Чтобы повысить привлекательно и расширить аудиторию, которая тесно соприкасается с трехмерным компьютерным миром, было принято решение разработки программного интерфейса, позволяющего систематизировать доступ и обработку 3D моделей на аппаратном уровне.
В результате был разработан OpenGL. Он стандартизирует спецификацию обработки различных функций, используемых в работе с 3D графикой. Это дало возможность программистам не привязываться к конкретному производителю оборудования, а разрабатывать программы исходя из определённого списка возможных операций. И уже производители графических карты должны были обеспечивать возможность выполнения этих операций согласно принятой спецификации. Это позволило значительно повысить уровень выпускаемых программных продуктов, сделать их более доступными и увеличило скорость разработки новых игр и программ.
Как пользоваться
Итак, сейчас мы в два этапа разберем процесс загрузки программы, а также ее установку.
Загрузка и установка
Скачивание должно производиться только с официального сайта. Это полностью бесплатное ПО, соответственно, загружать софт со сторонних источников мы не рекомендуем. Поступим следующим образом:
- Чтобы обновить OpenGL, переходим немного ниже и жмем кнопку, при помощи которой автоматически запустится скачивание.
- Распаковываем установочный файл и запускаем его, произведя двойной левый клик.
- Следуя подсказкам, которые будут появляться в процессе инсталляции, производим установку нашего программного обеспечения.
Вместе с этим смотрят: Unarc.dll для Windows 10 x64 Bit
Для максимально корректной работы OpenGL вы в обязательном порядке должны установить последнюю версию драйвера для своей видеокарты. В случае с NVIDIA лучше всего подойдет программное обеспечение под названием GeForce Experience.
Инструкция по работе
Библиотека, которую вы скачали и установили шагом ранее, не предусматривает каких-либо дополнительных настроек после своей инсталляции. Максимум, что может потребоваться от пользователя, чтобы включить OpenGL, это перезагрузка персонального компьютера или ноутбука.
Почему драйверы не обновляются?
Если вдруг ни одно из вышеперечисленных решений не помогает, вероятнее всего, причина кроется только в том, что видеоадаптер инсталлируемую версию OpenGL попросту не поддерживает, поэтому, как ни пытайся, драйвер установить не получится. Единственным выходом станет установка более мощной видеокарты.
Кстати сказать, наиболее часто такая проблема встречается в случае с интегрированным видеочипами стандарта video-on-board, которые встроены в материнские платы. С дискретными видеокартами, как правило, таких проблем нет (естественно, при условии, что чип не является слишком устаревшим и изначально поддерживает технологию OpenGL). Как обновить драйверы для таких карт, думается, уже понятно. Но иногда может потребоваться апдейт платформ JAVA Runtime или даже .NET Framework от Microsoft – об этом тоже забывать нельзя. Но как правило, в большинстве случаев этого делать не требуется — достаточно обновить DirectX и параллельно использовать утилиту OpenGL Extensions Viewer.
Достоинства и недостатки
Теперь, когда с теорией и практикой мы закончили, давайте рассмотрим также дополнительные моменты в виде положительных и отрицательных особенностей OpenGL 2.
- Использование библиотеки позволяет с максимальной производительностью запускать игры или мультимедийные приложения, построенные на базе данной технологии.
- Отличное быстродействие.
- Хорошая оптимизация для Windows 10 и других операционных систем Microsoft.
- Оптимальное использование аппаратных ресурсов ПК.
- Данная технология в некоторых случаях может проигрывать Direct X.
OpenGL ES 2.0 для начинающих
Одна из самых мощный сторон современных мобильных устройств Apple- это графическая подсистема, позволяющая писать качественные 2d и 3d игры с отличной производительностью и детальной графикой. О ней я и хочу рассказать, так как в интернете для новичков информации про OpenGL ES 2.0 на русском языке очень мало. Итак, что же такое OpenGL? Это Открытая графическая библиотека (Open Graphics Library), которая имеет свой api, свои переменные, и является самой ближайшей точкой взаимодействия между процессором и графическим чипом (GPU).
Как работает OpenGL
В устройствах на iOS есть центральный процессор (CPU) и графический процессор (GPU). GPU призван разгрузить центральный процессор от обработки графических данных перед выводом на экран. Другими словами, OpenGL позволяет рассчитывать все детали конечного изображения на графическом чипе (Графический чип в разы быстрее в расчетах чисел с плавающей точкой), а центральный процессор оставить для других расчетов, например, игровой логики. Так же OpenGL предоставляет множество возможностей для хранения информации, данных и изображений в оптимальном для графического чипа формате для более быстрой обработки. Эти данные будут обрабатываться напрямую непосредственно графическим чипом.
Логика OpenGL
Логика OpenGL до безобразия проста, и ее можно объяснить тремя вещами:
- примитивы
- буферы
- растеризация
Весь OpenGL работает вокруг этих понятий. Рассмотрим их поподробнее.
Примитивы
Примитивы в OpenGL состоят из трех объектов:
- точка в пространстве (x,y,z)
- линия в пространстве (состоит из 2х точек в пространстве)
- треугольник в пространстве (состоит из 3х точек в пространстве)
Точка может использоваться как частица в пространстве. Линия всегда сплошная и может использоваться как вектор. Треугольник может быть одной из частей огромного полигона, который может состоять из тысяч треугольников.
Буферы
Буферы в OpenGL это временное хранилище. Они делятся на 3 типа:
- frame buffer (кадровый буфер)
- render buffer (визуализирующий буфер)
- buffer object (буфер объектов)
Кадровый буфер является самым абстрактным из всех трех. Когда вы формируете итоговое изображение в OpenGL, вы можете отправить его напрямую на экран либо в кадровый буфер. Этот буфер хранит информацию о всех 3d объектах в пространстве, удаленности этих объектов в пространстве, перекрываемости объектами друг друга. Все эти данные хранятся в буфере в виде информации о пикселях в двоичном массиве.
Визуализирующий буфер это временное хранилище для одного изображения. Этот буфер представляет из себя коллекцию кадровых буферов. Существует несколько видов визуализации буфера: цвет, глубина и шаблон.
буфер визуализации цвета хранит итоговое цветное изображение, созданное рендером OpenGL. Это цветное (RGB) изображение. буфер визуализации глубины хранит координату глубины (точка z) объектов в пространстве. буфер визуализации шаблона хранит видимую часть объекта (как маску видимой части). В буфере хранится черно-белое изображение.
Буфер объектов хранит информацию о структурах и индексах, причем эта информация в отличие от других буферов может храниться на протяжении всего цикла выполнения приложения. Структурой является массив, который описывает 3d-модель как массив вершин, массив координат текстур или массив нужных вам данных. Индексы более специфичны. Массив индексов используется для указания, как стороны вашего полигона будут построены на основе массива структур. Давайте представим куб в пространстве. Куб состоит из 6 сторон и 8 вершин.
Каждая из сторон это квадрат, но OpenGL умеет работать только с треугольниками. Таким образом нам нужно преобразовать каждый квадрат в треугольники, что бы отобразить его. Когда мы это сделаем, то получится, что 6 сторон преобразовались в 12. Треугольники в OpenGL представляют собой комбинацию из 3х вершин. Таким образом, что бы «объяснить» OpenGL что мы хотим изобразить куб, нам потребуется нарисовать 2 треугольника со следующими вершинами:
Растеризация
Растеризация это процесс, когда OpenGL собирает всю информацию о 3d объектах (координаты, вершины и т. д. ) и создает 2d изображение, как правило для отображения на экране устройства. В реализации OpenGL Apple вы не можете вывести изображение сразу на экран, а должны обязательно его поместить в кадровый буфер, а уже оттуда, средствами EAGL (Extended Apple GL) вывести его на экран устройства.
Конвейеры OpenGL
В OpenGL ES 2.0 используется программируемый конвейер. Это означает что вся ответственность за камеры, освещение, эффекты лежит полностью на разработчиках. Делается все это шейдерами. Таким образом, когда слышите о программируемом конвейере, думайте о шейдерах 
Шейдеры это такие маленькие кусочки кода, маленькие программки, которые выполняются непосредственно на графическом чипе для совершения сложных расчетов. Фиксированный конвейер это полная противоположность программируемому. Фиксированный конвейер предоставляет api для управления камерой, освещением, эффектами, материалами.
Для создания шейдеров в OpenGL ES используется язык, весьма похожий на C, называемый OpenGL ES Shader Language (GLSL ES или ESSL). Как же работают шейдеры? Вы создаете их либо в отдельных файлах, либо прямо в коде, главное что бы строка, содержащая код шейдера, была отправлена в ядро OpenGL и скомпилирована там для использования. Шейдеры работают в паре — вершинные шейдеры и фрагментные. Что бы понять что каждый из них означает, вернемся к примеру с кубом.
Вершинный шейдер
Вершинные шейдеры (vertex shader), так же известные как VS или VSH, это маленькие программы, которые выполняются для каждой вершины. Если посмотреть на куб на рисунке выше, то у куба получается 8 вершин (5 вершина невидимая). Соответственно вершинный шейдер обработает этот куб 8 раз на графическом процессоре. Вершинный шейдер задаст конечные позиции вершин с учетом положения камеры, а так же подготовит и выведет некоторые переменные, требуемые для фрагментного шейдера. В OpenGL мы не можем задавать переменные напрямую для фрагментного шейдера, только через вершинный. Почему нельзя обращаться к фрагментному шейдеру напрямую? Давайте рассмотрим.
Фрагментный фейдер (fragment shader, FSH)
Давайте посмотрим вновь на куб. 5 вершина невидимая по причине местоположения и поворота куба в пространстве, значит мы можем видеть только 3 стороны куба, и они составляют 7 вершин. Это то, что делает фрагментный шейдер. Он обрабатывает каждую видимую часть конечного изображения. Можно преставить каждую часть как пиксель, но это не совсем так, потому что пиксеть в рендеринге OpenGL и в итоговом изображение, которое вы видите на экране, может различаться по размеру. Таким образом фрагмент может быть больше или меньше нежели реальный пиксель, в зависимости от конфигурации устройства и параметров рендеринга. В кубе, приведенном выше, фрагментный шейдер обработает каждый пиксеть на всех 3х сторонах куба, сформированных с помощью 7 вершин. Внутри фрагментного шейдера мы будем работать со всем, что связано с поверхностью- освещение, тени, отражения, текстуры и любые эффекты, которые вы захотите. Результат работы фрагментного шейдера это цвет пикселя в формате RGBA (красный, зеленый, синий и альфа-канал). Вершинный и фрагментный шейдеры работают вместе. Один вершинный шейдер и один фрагментный, не больше и не меньше. Что бы гарантировать, что м ы не наделаем ошибок, OpenGL всегда компилирует пару VSH и FSH.
Ошибки в OpenGL
Так как OpenGL это отдельный api и выполняется он в графическом чипе, вы не имеете прямого доступа к процессам, происходящим внутри. Поэтому если возникает ошибка внутри, то с вашим приложением ничего не случится. Но как узнать, что если в одном из шейдеров есть ошибка или буфер рендеринга настроен неправильно? Для таких случаев в OpenGL есть специальный Error api. Он весьма прост и состоит из нескольких функций, одна из которых это простая проверка успешность завершения каких либо операций, возвращающая yes или no. Таким образом очень просто быстро проверить есть ли ошибки, и, если таковые имею место быть, то вы получите сообщение с ошибкой. Обычно проверки размещаются в критических точках приложения, например при компиляции шейдеров или при создании буферов.
Если тема будет интересна, продолжу уже с реальными примерами для iOS.
learnopengl. Урок 1.3 — Hello Window
В прошлом уроке мы подготовили рабочее пространство и теперь мы полностью готовы создать окно.
Данный перевод подготовлен совместно с FERusM за что ему большое спасибо.
Заинтересовавшихся прошу под кат.
Часть 1.3. Hello Window
После установки GLFW самое время сделать простенькую программку, как это принято в подобных материалах, пусть это будет Hello World. Для начала нужно создать .cpp файл и подключить несколько заголовочников, также необходимо установить переменную GLEW_STATIC, которая указывает на то, что мы будем использовать статическую версию библиотеки GLEW.
Далее напишем функцию 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.
Теперь нужно создать объект окна. Этот объект содержит всю необходимую информацию об окне и используется функциями 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.
Подготавливаем двигатели
Мы не хотим, чтобы приложение сразу после отрисовки одного изображения упало. Мы хотим, чтобы программа продолжала отрисовывать изображения и обрабатывать пользовательский ввод до тех пор, пока ее не закроют. Для этого мы должны создать цикл, называемый игровым циклом, который будет обрабатываться до тех пор, пока мы не скажем 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 весь буфер будет заполнен указанным цветом. В результату вы получите зелено-голубой цвет.
Полный исходный код урока можно найти здесь.
Теперь у нас есть все, чтобы начать заполнять игровой цикл вызовами функций отрисовки, но мы прибережем это для следующего урока.