Что такое код opengl поддержка


Содержание

4.1 Немного Об OpenGL

Как известно, OpenGL расшифровывается как Open Graphics Library, что в переводе на русский язык означает «открытая графическая библиотека».

Другими словами, OpenGL — это некая спецификация, включающая в себя несколько сотен функций. Она определяет независимый от языка программирования кросс-платформенный программный интерфейс, с помощью которого программист может создавать приложения, использующие двухмерную и трехмерную компьютерную графику. Первая базовая версия OpenGL появилась в 1992 году – она была разработана компанией Silicon Graphics Inc., занимающейся разработками в области трехмерной компьютерной графики.

За следующие 17 лет версия библиотеки достигла отметки 3.1. Но нельзя сказать, что библиотека видоизменялась, нет. Ее создатели заложили в нее механизм расширений, благодаря которому производители аппаратного обеспечения (к примеру, производители видеокарт) могли выпускать расширения OpenGL для поддержки новых специфических возможностей, не включенных в текущую версию библиотеки. Благодаря этому, программисты могли сразу использовать эти новые возможности, в то время как в случае использования библиотеки Microsoft Direct3D им бы пришлось ждать выхода новой версии DirectX.

В современном мире, библиотеки OpenGL и DirectX являются конкурентами на платформе MS Windows. Microsoft всеми силами продвигает свою библиотеку DirectX, а также всеми силами стремится замедлить развитие библиотеки OpenGL, что ослабило бы графическую систему конкурирующих ОС, где для реализации вывода всей графики используется исключительно библиотека OpenGL. Мы будем учиться визуализации компьютерной графики именно с применением этой библиотеки. Но, к сожалению, прямой поддержки данной библиотеки в .NET Framework нет, опять же по причинам конкуренции. Поэтому мы будем использовать библиотеку Tao Framework, о которой поговорим в следующей части главы.

Пара слов об OpenGL 4

11 марта 2010 года Khronos Group на GDC объявила о выпуске спецификации OpenGL 4.0:

Рисунок 1. OpenGL 4.0

Эволюция OpenGL 1 — 4

Эта новая версия продолжает стремительное развитие свободного стандарта OpenGL, для того чтобы графические разработчики имели доступ ко всей функциональности современных GPU для использования в самых разнообразных операционных системах и платформах. Полная спецификация доступна для скачивания на http://www.opengl.org/registry.

OpenGL 4.0 улучшает тесные взаимодействия с OpenCL™ для ускорения вычислительных ресурсов графических приложений. OpenGL 4.0 также продолжает оказывать поддержку совместимости с OpenGL 3.2, что позволяет разработчикам использовать упрощенный API или сохранить обратную совместимость для существующего кода OpenGL в зависимости от потребностей рынка.

Основные изменения

OpenGL 4.0 был специально разработан, чтобы принести значительные выгоды для разработчиков приложений, в том числе:

  • 2 новых уровня шейдеров, которые обрабатываются в GPU для разгрузки CPU при выполнении тессиляции;
  • поддержка выборочных фрагментных шейдеров и программируемых фрагментных шейдеров для увеличения качества рендеринга и гибкости при реализации сглаживания;
  • отрисовка данных, полученных в OpenGL или через внешние интерфейсы, таких как OpenCL, без вмешательства центрального процессора;
  • шейдерные подпрограммы для значительного увеличения гибкости программирования;
  • разделение состояния текстур и текстурных данных за счет добавления нового типа объекта данных – «объекты семплов»;
  • 64-битная двойная точность шейдерных операций с плавающей точкой и входов / выходов для увеличения точности и качества рендеринга;
  • улучшена производительность, в том числе экземпляров геометрических шейдеров, экземпляров массивов, а также новым подходом запросов к таймеру.

Khronos одновременно с этим выпустила спецификацию OpenGL 3.3, а также набор расширений ARB, чтобы большинство функциональных возможностей OpenGL 4.0 работало на предыдущих поколениях аппаратных GPU.

Все это дает максимальную гибкость и охват платформ для разработчиков приложений. Полная спецификация OpenGL 3.3 также доступна для скачивания на http://www.opengl.org/registry

OpenGL 4.1

26 июля 2010 года Khronos Group анонсировала спецификацию OpenGL 4.1. Спецификация включает в себя обновление GLSL (GL Shading language) до версии 4.10 и несет в себе как нововведения (такие как обеспечение полной совместимости с OpenGL ES 2.0 API, улучшения взаимодействия с OpenGL, улучшения при работе в WebGL приложениями и другие).

В англоязычной части интернета уже появились новые уроки и демонстрационные программы по использованию OpenGl 3.2 и OpenGL 4.

В скором времени вы сможете прочитать пару слов о спецификации OpenGL 4.1.

Поддержка версий OpenGL, конвертирование и использование

Я понимаю, что OpenGL 3 был выпущен в 2008 году, что он имеет резкое изменение API и что он не поддерживается, если ваш компьютер/графический процессор слишком старый. Например, я знаю, что OpenGL 3 API не работает на моем графическом процессоре (мой компьютер был куплен в 2009 году и имеет ATI Mobility Radeon HD 4530).

  • Есть ли способ конвертировать OpenGL 3/OpenGL 4 в код OpenGL 2?
  • Если нет, значит ли это, что мой компьютер не сможет запустить новое программное обеспечение, написанное с помощью OpenGL 3+?
  • Большинство разработчиков графики по-прежнему используют старый API (то есть OpenGL 2) для поддержки старых машин?
  • Насколько сложно изучать новый API OpenGL, когда вы уже знакомы со старым? Является ли знание старого API полезным?

1) Невозможно напрямую преобразовать OpenGL 3.x или 4.x код, чтобы он работал в системе, которая поддерживает только GL2, если вы не хотите писать много кода эмуляции.
Не только парадигмы различны (это действительно довольно легко сделать, существуют, например, библиотеки немедленного режима для OpenGL3, можно, очевидно, сделать обратное и иметь класс для объектов буфера, которые могут быть «отображены» и «не указаны», и что испускает много вызовов glVertex ). Аппаратное обеспечение также поддерживает множество функций как часть конвейера рендеринга, который просто отсутствует в более старых аппаратных средствах (таких как instancing, геометрические шейдеры, тесселяция). Некоторые из этих (скажем, instancing) более тривиальны для подражания, другие сложнее (гео-шейдеры). Конечно, вообще возможно как-то подражать всему, но это такая ужасная работа, что это просто не имеет смысла.

2) Ваш компьютер может запускать программное обеспечение, использующее OpenGL 3, при условии, что у вас есть уровень эмуляции программного обеспечения, который поддерживает это. В то же время MESA поддерживает OpenGL 3.1, так что это будет «да» (также nVidia однажды использовала какой-то «инструмент tuneup», который позволил бы некоторым графическим процессорам использовать функции, которые они действительно не поддерживали, посредством эмуляции. но я сомневаюсь, что это включало в себя что-то вроде полной поддержки GL3, и в любом случае это не повлияло бы на ATI-карту).
В противном случае ответ, конечно: Нет.

3) Это зависит. Трудно сказать, что такое «большинство». Но имеет ли это значение в любом случае? Вам нужно делать то, что подходит для вашего приложения, а не то, что «большинство».
Для конфеты сокрушительной плиткой и спрайтом, которую люди играют на своем телефоне по дороге домой с работы, GL2 (или ES) отлично подходит. Разработчики, которые делают что-то подобное, будут использовать старый API, потому что он работает, и гораздо проще получить что-то за малое время.
Большинство других не будет, поскольку не только производительность значительно хуже для более требовательных приложений, но и у вас нет шейдеров и других очень полезных функций. Кроме того, практически все разумно текущее оборудование поддерживает как минимум GL3.

Оборудование GL3 доступно для недорогих двухзначных сумм валюты в течение как минимум 5 лет, а аппаратное обеспечение GL4 также доступно для этой цены в течение некоторого времени. Я проповедовал в течение полутора лет (возможно, я ошибаюсь, но это моя точка зрения), что если кто-то не может или не хочет позволить себе купить новую карту за 20 долларов, то они не будут платить за ваше программное обеспечение или. Поэтому они не являются «серьезными» клиентами, которых я хочу рассмотреть. Кроме того, карта, которая не может выполнять GL3, — из-за отсутствия вычислительной мощности — неспособна делать большинство вещей с приемлемой частотой кадров. Это означает, что, даже если эти люди будут серьезными, платят клиентам, они будут несчастными клиентами, которые будут поднимать много жалоб.
Разумеется, ваш подход может меняться, но я убежден, что лучше просто держаться подальше от этих клиентов. Это неразумный подход к тому, чтобы уже планировать несчастных пользователей.

OpenGL3 имеет профиль совместимости, но если вы спросите меня, это было бессмысленное решение со стороны комитета. Хотя nVidia по-прежнему рекомендует просто использовать профиль совместимости с обещанием поддерживать его на неопределенный срок и утверждать, что он будет работать не медленнее, а, возможно, быстрее, я не согласен с этой точкой зрения.
Хотя включение профиля совместимости как такового может быть «безвредным» и может действительно не вызывать каких-либо проблем с производительностью, оно позволяет сознательно или непреднамеренно использовать функциональные возможности, которые плохо отображают, как работает оборудование, и даже позволяет делать то, что концептуально «ошибочны». Использование основного профиля может быть болезненным и кажется излишне ограничивающим, когда вы привыкли использовать старые функции, но ограничения действительно помогают вам лучше писать код.

4) Знание старого API на самом деле скорее препятствует. Вы должны в моем высказывании забыть об этом, как только сможете. Единственное преимущество устаревшего API заключается в том, что он мертв просто, чтобы перенести свой первый треугольник на экран (что-то, что уже немного связано с примерно 40 строками кода с использованием GL3). Но как только вы захотите сделать что-то еще более развитое, первоначально высокий барьер входа GL3/GL4 больше не имеет значения. Напротив. Как только вы привыкнете к нему, гораздо проще просто выбросить весь буфер косвенных команд рисования и весь буфер данных вершин в драйвере и позволить ему хрустнуть через него.

Если вы еще не начали изучать что-либо, изучите только современный подход и никогда не оглядываетесь назад. С некоторой удачей Вулькан в этом году будет иметь законченные характеристики (да, я мечтатель, но можно надеяться!). Это, опять же, будет радикально отличаться от того, как выглядит API GL. Но опять же, если вы уже привыкли делать стиль GLAD в основном AZDO, это не так сильно изменится.

Работа с расширениями OpenGL с использованием NV >Автор: Сергей Александрович Гайдуков

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

Что такое расширение OpenGL

Если производитель обнаруживал, что OpenGL не может использовать все аппаратные возможности его «железа», он выпускал расширение для OpenGL с поддержкой новых возможностей. Причем это расширение, как правило, появлялось почти на год раньше, чем новая версия DirectX, поддерживающая новые возможности. Так, поддержка вершинных и пиксельных шейдеров для GeForce2 в OpenGL появилась намного раньше 8-й версии DirectX. А когда DirectX 8 все-таки вышел, то выяснилось, что про пиксельные шейдеры GeForce2 он ничего не знает:

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

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

Для выполнения всех примеров вам потребуются Microsoft Visual C++ 6 и NVIDIA OpenGL SDK, который можно скачать с www.nvidia.com. В составе этого SDK имеется NVIDIA OpenGL Extension Specification, в котором описаны большинство расширений, которые поддерживаются NVIDIA.

Инициализация WGL-расширений

Перед тем, как использовать любое OpenGL-расширение, его надо инициализировать. Для начала рассмотрим инициализацию WGL-расширений. Этот класс расширений предназначен для инициализации OpenGL в ОС семейства Windows, а также для выполнения некоторых функций, которые зависят от используемой операционной системы — например, работа со внеэкранными поверхностями (буферами пикселей). В приведенном ниже примере показывается, как проверить поддержку двух расширений WGL_ARB_pixel_format и WGL_ARB_pbuffer и подготовить их к использованию. Этот и все остальные примеры из статьи полностью можно скачать.

Для начала не забудьте настроить Visual C++ для работы с NVSDK (пропишите пути к включаемым файлам и библиотекам). Теперь создайте новый проект и настройте его для работы с OpenGL (подключите библиотеки opengl.lib, glu32.lib, glut32.lib, установите точку входа mainCRTStartup и т.д.)

Напишите простейшее GLUT-приложение, создающее окно:

Не забудьте директивой #include подключить заголовочные файлы glext.h (замена gl.h) и wglext.h. Перед началом работы с WGL-расширениями надо проверить поддержку расширения WGL_ARB_extensions_string, при помощи которого осуществляется инициализация остальных WGL-расширений.

Для это мы объявляем переменную, которая является указателем на функцию wglGetExtensionsStringARB. Обратите внимание, что название типа функции начинается с префикса PFN, далее идет название расширения, а затем окончание ARBPROC (в случае расширений ARB):

Теперь надо получить адрес этой функции. Для этого используется функция wglGetProcAddress. В качества параметра она принимает строку, содержащую название функции, адрес которой надо получить:

В случае удачного вызова она возвращает адрес функции, иначе — NULL.

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

Если все прошло удачно, то, используя функцию wglGetProcAddress, можно получить адреса точек входа нужных нам функций:

Как видно, инициализировать WGL-расширения непосредственно через OpenGL API довольно неудобно, особенно если надо подключить больше десятка различных расширений, каждое из которых содержит больше десятка функций. Но в NV >

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


Это все! Теперь вы можете вызывать функции указанных расширений как обычные функции.

Инициализация OpenGL расширений

В принципе, инициализация GL-расширений должна была выполняться очень просто, путем включения в проект файла glext.h. Но на практике это не так. Причина этого кроется в том, что файл opengl.lib, поставляемый с Visual C++ 6, не содержит функций GL-расширений (если бы он их содержал, программа бы отказывалась запускаться на видеокартах, драйверы которых не полностью поддерживают все GL-расширения).

Поэтому инициализация GL-расширений выполняется аналогично инициализации WGL-расширений с единственным отличием — для получения списка GL-расширений используется функция glGetString(GL_EXTENSIONS).

Если же вы используете NVIDIA OpenGL Helper Library, то никакой разницы в инициализации GL и WGL расширений нет — функция glh_init_extensions умеет инициализировать оба вида расширений.

Использование расширений OpenGL на примере GL_EXT_separate_specular_color

Рассмотрим небольшую программу, которая рисует на экране вращающийся чайник с нанесенной текстурой. Клавишей F1 можно включать/выключать вращение. При нажатой левой кнопке мыши можно вращать чайник, а при правой — перемещать. Клавишей F2 можно сменить плоскость, в которой перемещается чайник.

Текстура чайника хранится в файле wood.tga. Для его загрузки используется библиотека NV_UTIL из состава NVSDK, которая содержит множество процедур для работы с наиболее распространенными графическими форматами. Перед использованием этой библиотеки нужно подключить к проекту библиотеку nv_util.lib.

Функции для работы с файлами формата TGA находятся в файле nv_tga.h в пространстве имен tga. Следовательно, для доступа к ним надо использовать либо директиву using namespace tga, либо указывать перед названием функций и типов этой библиотеки префикс tga.

Загрузка файла в память осуществляется функцией tga::read, которой передается имя файла. Функция возвращает указатель на структуру tga::tgaImage. Нас интересуют следующие поля структуры:
· GLsizei width — ширина рисунка;
· GLsizei height — высота рисунка;
· GLubyte *pixels — указатель на массив пикселей;
· GLenum format — формат пикселей рисунка.

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

Хотя в примерах NVSDK это нигде не показано, я считаю, что перед удалением указателя надо удалить из памяти еще и указатель на массив пикселей (pixels), иначе он останется находится в памяти до окончания работы программы.

Теперь можно использовать эту информацию для создания текстуры.

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

Но что делать, если надо получить блик именно белого цвета на деревянном чайнике. Одно из решений проблемы — наложение текстуры на чайник в 2 прохода. Сначала мы рисуем чайник с наложенной текстурой с отключенными бликами, а затем, на втором проходе, рисуем блики без текстуры. Пример реализации этого алгоритма можно найти в книге М. Красного «OpenGL. Графика в проектах Delphi» (глава 4, пример 83).

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

Для того чтобы заставить программу использовать эту модель освещения, в нее достаточно добавить всего несколько строк.

Прежде всего в процедуру Init() добавим инициализацию расширения и сроку для включения режима освещения GL_SEPARATE_SPECULAR_COLOR_EXT. Для этого используется процедура glLightModeli с новыми параметрами.

Илон Маск рекомендует:  AnsiUpperCase - Функция Delphi

Параметр GL_SEPARATE_SPECULAR_COLOR_EXT включает режим наложения бликов после наложения текстуры. Для возвращения к классической схеме вычисления цвета достаточно вызвать функцию с параметром GL_SINGLE_COLOR_EXT.

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

Расширение GL_SEPARATE_SPECULAR_COLOR_EXT поддерживается всеми видеокартами NVIDIA, за исключением видеокарт семейства Riva128/128ZX.

Что такое OpenGL?

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

Что такое OpenGL и с чем его едят?

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

OpenGL переводится как Открытая Графическая Библиотека (Open Graphics Library), это означает, что OpenGL — это открытый и мобильный стандарт. Программы, написанные с помощью OpenGL можно переносить практически на любые платформы, получая при этом одинаковый результат, будь это графическая станция или суперЭВМ.

OpenGL освобождает программиста от написания программ под какое-то конкретное оборудование. Если устройство поддерживает какую-то функцию, то эта функция выполняется аппаратно, если нет, то её реализацией занимается программа-библиотека.

На одном популярном сайте можно найти подробности сего стандарта:

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

Реализации OpenGL.

Как вы могли понять из выше описанного. Что OpenGL, это всего лишь некая описанная спецификация по 3D графике. Чтобы эту спецификацию преобразить в жизнь необходимо написать (реализовать) код. Код затем упаковывается в специальную библиотеку. И вот таких библиотек существует несколько, от разных программистов.

Первая из этих библиотек называется GLU. Эта библиотека уже стала стандартом и поставляется вместе с главной библиотекой OpenGL. Следующая библиотека, также широко используемая — это GLUT. Это также независимая от платформы библиотека. Она реализует не только дополнительные функции OpenGL, но и предоставляет функции для работы с окнами, клавиатурой и мышкой. Есть ещё одна библиотека похожая на GLUT, называется она GLAUX. Это библиотека разработана фирмой Microsoft для операционной системы Windows. Она во многом схожа с библиотекой GLUT, но немного отстаёт от неё по своим возможностям.

Альтернатива для OpenGL.

Хотя библиотека OpenGL и считается одной из лучших библиотек, но существует она в этой отрасли не одна. Есть у неё один прямой конкурент, о котором я рассказывал в одной из прошлой статей. И этим конкурентом считается Direct3D из пакета DirectX, разработанный фирмой Microsoft. Direct3D создавался исключительно для игровых приложений. Между ними существует множество различий, из наиболее явных можно выделить, что Direct3D осуществляем поддержку начиная с дешёвого оборудования, а OpenGL же поддерживается не на всех графических картах.

Нужно ли устанавливать OpenGL?

В случае если Вы уже установили драйвера на свою видеокарту, то нет. Так как последняя версия OpenGL устанавливается при установке драйверов от вашей графической карты.

Чтобы установить новую версию OpenGL необходимо обновить драйвера вашей видеокарты. Зайдите на сайт производителя Вашей видеокарты: NVIDIA, AMD или прочее. Скачайте последние драйвера для вашей карты, установите их.

Например, моя видеокарта Radeon 7850. Захожу я на сайт www.amd.com нахожу там страничку с моей видеокартой, смотрю технические характеристики.

Как можете заметить, с OpenGL 4.2 мой видеоадаптер дружит. Теперь подбираем драйвера.

Ну а дальше, качаем, устанавливаем, перезагружаемся.

Может ли OpenGL работать на одном компьютере с Direct3D?

Да. Обе программы включены в версию Windows, работают на высокой скорости и предоставляют много функций для геймеров и видеоредакторов. Поэтому нет поводу переживать, насчёт их совместного «проживания» на вашем компьютере ��

Как включить OpenGL?

На этот вопрос нельзя дать однозначной инструкции. Вообще по умолчанию поддержка сей технологии прописывается создателем игры ещё в момент написания кода. И использование скажем DirectX или OpenGL, может настраиваться через определённый пункт в меню игры, либо включать самой игрой по-умолчанию. Поэтому если создатель игры не выпускает дополнительный обновлений и инструкций к ним по установке скажем дополнительных библиотек, то нет смысла Вам думать об этом вопросе. Ну а если какие-то дополнения вышли, скажем на тот же Counter Strike 1.6, энтузиасты написали чит (а чит — это плохо!! атата), то для этого установки необходимо скачать небольшой файл .dll и закинуть в корневую директорию игры, а затем в настройках игры выбрать пункт OpenGL.

За счёт этого игра начинает использовать функции написанные внутри этого файла.

Вывод

Вот и пробежались мы по ещё одной библиотеке для работы с графикой. OpenGL скажем такая специфичная вещь, которая в большей степени применяется в профессиональной деятельности для 3D моделей. В играх по большему счету хватает и функций Direct3D, да даже больше. Взять недавно вышедшую версию 12. Но OpenGL тоже не стоит на месте и с определённым промежутком времени выпускает новые версии из последних — версия 4.5 от 11 августа 2014 года.

Как написать инсталлятор, который проверяет наличие поддержки OpenGL?


У нас есть 3D-просмотра, который использует OpenGL, но наши клиенты иногда жалуются на это «не работает». Мы подозреваем, что большинство из этих проблем вытекают из них пытается использовать, то, что в действительности современные 3D игры в режиме реального времени, на businiss портативного компьютера.

Как мы можем, в установщик Windows MSI мы используем, проверить поддержку OpenGL?

И как примечание стороны, если вы можете ответить на «Список OpenGL поддерживается видеокартами?», Что также будет Greate. Странно, что Google не помогает здесь ..

Зависит от того, что клиенты в виду под «не работает». Это может быть один из:

  1. он не устанавливает / запуск вообще, из-за отсутствия какой-то OpenGL поддержки.
  2. он запускает, но падает дальше.
  3. он запускает, не ломается, но рендеринг поврежден.
  4. он запускает и правильно делает все, но производительность плачевна.

Все версии Windows , (начиная с 95) имеют OpenGL встроенной поддержки. Так что вряд ли может вызвать ситуацию 1) выше, если ваше приложение не требует более новой версии OpenGL.

Тем не менее, что реализация OpenGL по умолчанию OpenGL 1.1 с программным рендерингом . Если пользователь не вручную установить драйвера , которые имеют поддержку OpenGL (любой драйвер , загруженный с сайта NVIDIA / AMD / Intel будет OpenGL), они будут по умолчанию этой медленной и старой реализации. Это вполне может вызвать ситуации , 3) и 4) выше.

Даже если OpenGL доступен на драйвера для Windows OpenGL не очень надежны, мягко говоря. Различные ошибки в драйверах, весьма вероятно, чтобы вызвать ситуацию 2), где делать что-то действительное вызывает сбой в драйвере.

Вот фрагмент коды C ++ / WinAPI, что создает фиктивный контекст OpenGL и извлекает информацию (версию GL, название видеокарты, расширение и т.д.):

Вы можете как-то подключить этот код в ваш установщик или приложение и по крайней мере проверить GL версию для быть 1.1; это обнаружит «драйвер не установлен» ситуацию. Чтобы обойти фактические ошибки драйвера OpenGL, хорошо, вы должны понять их и работать вокруг них. Много работы.

Знакомство с OpenGL

OpenGL (Open Graphics Language) — это интерфейс трехмерной графики, предложенный фирмой SGI (которая ранее называлась Silicon Graphics Incorporated). OpenGL появился в результате переработки специализированного 3D-интерфейса этой фирмы IrisGL на универсальный, независимый от платформы. Данный интерфейс позволяет создавать трехмерные графические изображения независимо от используемых оконных интерфейсов, операционной системы и графических устройств.

В настоящее время разработкой стандарта OpenGL занимается индустриальный консорциум OpenGL Architecture Review Board (ARB), в состав которого входят представители таких фирм, как SGI, Microsoft, Intel, IBM и Digital Equipment.

Версии OpenGL существуют на графических станциях фирмы SGI (под управлением как операционной системы IRIX, так и Windows NT), рабочих станциях фирмы DEC, компьютерах IBM RS/6000 и всех платформах, поддерживаемых операционными системами семейства Microsoft Windows.

OpenGL API

В основе OpenGL лежит библиотека графических функций, предоставляющих разработчику все необходимое для создания и отображения плоских (2D) и пространственных (3D) моделей и анимации. Эта библиотека, содержащая более 100 функций, обеспечивает средства для управления графическими примитивами, выполнения матричных преобразований, задания источников света, теней, управления цветами и т.п. Существует также библиотека функций более высокого уровня, сервисы которой позволяют отображать полигональные трехмерные модели, строить кривые и поверхности на основе NURBS (неоднородных рациональных B-сплайнов) и поддерживают ряд других операций. Отдельные реализации библиотеки OpenGL содержат расширения, специфичные для конкретной операционной системы или аппаратной платформы.

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

На рис. 1 показано, как ядро OpenGL интегрируется в операционную систему.

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

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

Функции OpenGL доступны практически из любого языка программирования, но большинство примеров и кода в статьях приводится на языке С. В Internet вы сможете найти необходимые интерфейсные модули для Visual Basic, Delphi и других языков. Обратите внимание на то, что фирма Softoholic (http:\\www.softoholic.bc.ca) выпустила компонент OGL ActiveX Control, который реализует всю функциональность OpenGL и доступен из различных языков программирования и сред, поддерживающих компоненты ActiveX. Также существует библиотека расширения OpenGL на языке С++ — OpenInventor.

Аппаратная поддержка

Большое число графических карт с ускорителями и специализированных 3D-карт поддерживает выполнение примитивов OpenGL на аппаратном уровне. Эти карты, а также специализированные процессоры, перечислены в приложении 1.

Основные функции OpenGL

Ниже кратко перечислены основные функции и возможности, реализованные в библиотеке OpenGL. Для удобства некоторые термины приводятся как на русском языке, так и в оригинале.

Геометрические примитивы. Позволяют задавать математическое описание объектов. В настоящее время существуют следующие примитивы: точки, линии, многоугольники и растровые изображения (bitmap).

Цветное кодирование в формате RGBA (Red-Green-Blue-Alpha) или в режиме индексированных цветов.

Просмотр и моделирование позволяют размещать трехмерные объекты на сцене, передвигать камеры вокруг сцены и выбирать требуемый вид (точку обзора), для которого выполняется рендеринг.

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

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

Двойная буферизация позволяет устранить мерцание при анимации. Каждый следующий кадр анимации строится в отдельном буфере памяти и отображается только по завершении рендеринга.

Антиалиасинг(Anti-aliasing) сглаживает «ступенчатые» края цветовых переходов. Антиалиасинг является стандартной техникой в компьютерной графике, и суть ее заключается в изменении цвета и интенсивности точек вблизи линии резкого перехода цветов для уменьшения появления «лестничного эффекта». «Ступенчатые» линии особенно заметны при низком графическом разрешении.

Затенение по методу Гуро (Gouraud Shading) — закраска 3D-объектов, при которой сначала рассчитывается освещение вдоль ребер треугольников на основании данных об освещенности вершин, а затем на основании этих данных и направления градиентов изменения цвета закрашивается внутренняя поверхность треугольников.

Z-буферизация используется для сохранения информации о «глубине» трехмерного объекта (Z-координаты). Z-буфер используется для определения близости наблюдателя к объекту и удаления невидимых поверхностей.

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

Alpha-смешение (Alpha Blending) использует значение Альфа-буфера (информации о прозрачности пикселов) как составляющую расширенного цветового кода растрового изображения в формате RGBA, позволяя комбинировать цвет обрабатываемого фрагмента с цветом точек, которые уже хранятся в буфере изображения. Представьте, например, отрисовку прозрачного голубого стекла перед красной коробкой. Alpha-смешение позволяет моделировать прозрачность стекла таким образом, что часть коробки, которая видна сквозь стекло, будет иметь необходимый в данном случае сиреневый оттенок.

Трафаретные планы (Stencil Planes) ограничивают отрисовку на некоторых областях экрана по маске (трафарету).

Списки отображения (Display Lists) позволяют сохранять команды отрисовки в некотором списке для дальнейшего рендеринга. При правильном применении такие списки могут заметно повысить скорость и производительность рендеринга.

Полиномные вычисления (Polynomial Evaluations) используются для поддержки NURBS-сплайнов. С их помощью можно рисовать плавные кривые через небольшой набор опорных точек, что исключает необходимость сохранять все промежуточные значения.

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

Растровые примитивы — растровые изображения (прямоугольные картинки, состоящие из точек).

Операции с пикселами.

Различные преобразования: вращение, масштабирование, перемещение, перспективные искажения и т.д.

Заключение

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

Отметим, что в качестве дополнения к библиотеке OpenGL существует библиотека GLUT (GL Utility Toolkit), которая обеспечивает более простую интеграцию OpenGL с конкретным оконным интерфейсом — X11, Windows, Motif и т.п. Использование этой библиотеки не только скрывает от разработчика нюансы программирования того или иного интерфейса, но и делает приложение независимым от платформы.

Большое количество приложений поддерживает работу с библиотекой OpenGL. Некоторые из них перечислены в приложении 2.


Портирование приложений OpenGL* на Andro >

Опубликовано: 28 апреля 2013 г.

Эта статья является продолжением серии из двух статей, в которой рассматриваются проблемы, возникающие в процессе портирования преложений на OpenGL на платформу Google Android. В данной статье рассматриваются ограничения, связанные с различиями расширений OpenGL, поддержкой операций с плавающей запятой, сжатыми форматами текстур и библиотекой OpenGL Utility Library (GLU). Кроме того, здесь описана настройка системы разработки для Android на базе процессоров Intel® Atom и пути достижения максимально возможной производительности в средствах эмуляции виртуального устройства Android при использовании OpenGL ES.

В первой части данной серии статей содержится информация об использовании OpenGL ES на платформе Android с помощью пакета средств разработки программного обеспечения (SDK) или пакета Android NDK (Native Development Kit) и о том, по какому принципу выбирается тот или иной пакет. В ней описаны различные примеры приложений OpenGL ES в SDK и NDK и интерфейс Java* Native Interface, позволяющий комбинировать компоненты Java и C/C++.

Препятствия при портировании приложений OpenGL для настольных ПК

API-интерфейс OpenGL ES 1.1 является подмножеством API-интерфейсов OpenGL 1.x, которые использовались в настольных системах Linux* и Windows* на протяжении десятилетий. Аналогично API-интерфейс OpenGL ES 2.0 является подмножеством API-интерфейса OpenGL 2.0 для настольных систем. Поэтому любое портирование следует начать с оценки набора функций OpenGL, используемых в коде приложения, определения того насколько стар этот код и какие его части необходимо переписать по причине различий между используемой версией OpenGL и целевой версией OpenGL ES на Android.

Основные различия между OpenGL 2.0 и OpenGL ES 2.0 можно разделить на три категории: спецификации геометрии, преобразования геометрии и изменения в языке GLSL (OpenGL Shading Language). OpenGL 2.0 позволяет задавать спецификацию геометрии четырьмя способами: с помощью непосредственного режима (immediate mode), списков отображения (display lists), массивов вершин (vertex arrays) и объектов буфера вершин (vertex buffer objects). OpenGL ES 2.0 не поддерживает непосредственный режим (блоки glBegin и glEnd ) и списки отображения, поэтому задавать геометрию необходимо с помощью массивов вершин или объектов буфера вершин.

В OpenGL 2.0 есть функции для загрузки матриц модели-вида (model view), проекции (projection) и текстуры (texture), а также функции, упрощающие совместное использование этих матриц, например glTranslate , glRotate и glScale . В OpenGL ES 2.0 нет ни этих функций, ни функций освещения, поскольку фиксированный конвейер (fixed-function pipeline) был заменен на модель программирования шейдеров. В OpenGL ES 2.0 расчеты матриц и освещения должны выполняться в вершинном шейдере (vertex shader).

Язык шейдеров для OpenGL ES 2.0 (GLSL ES) также является подмножеством языка шейдеров для настойной версии OpenGL 2.0 (GLSL). Одно основное отличие состоит в том, что язык GLSL включает в себя встроенные переменные для доступа к состояниям в фиксированном конвейере вершинного шейдера (например, gl_ModelViewMatrix ). Поскольку OpenGL ES 2.0 не поддерживает фиксированный конвейер, эти переменные не поддерживаются в GLSL ES.

В OpenGL ES 2.0 отсутствуют следующие функции OpenGL 2.0:

  • Спецификация геометрии с помощью непосредственного режима
  • Спецификация геометрии с помощью списка отображения
  • Обработка всего фиксированного конвейера
  • Фиксированные преобразования и освещенность
  • Матричный стек и преобразования матриц
  • Пользовательские плоскости отсечения
  • Сглаживание и пунктирное отображение линий и многоугольников
  • Пиксельные прямоугольники и растровые изображения
  • Одномерные текстуры и некоторые режимы обертывания текстур
  • Запросы на перекрытие
  • Туман

Портирование из других встроенных систем

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

Поддержка операций с плавающей запятой

Ранние реализации OpenGL ES 1.0 и 1.1 поставлялись в двух версиях — Common и Common-Lite. Версия Common предназначалась для процессоров с поддержкой аппаратной обработки операций с плавающей запятой; версия Common-Lite — для процессоров без такой поддержки, требующих использования расчетов с фиксированной запятой. Поскольку для Android требуются процессоры, поддерживающие операции с плавающей запятой, такие как Intel Atom, необходимость в использовании фиксированной запятой не возникает никогда, и образы системы Android, предоставленные компанией Google, включают в себя только драйверы Common для OpenGL ES 1.1 (с поддержкой плавающей запятой). Стандарт Khronos для OpenGL ES 2.0 предусматривает только операции с плавающей запятой. Это нужно учитывать при портировании игры OpenGL ES 1.0 или 1.1 из другой встроенной системы, использующей реализацию Common-Lite стандарта OpenGL ES, поскольку вы должны будете преобразовать все имеющиеся в коде расчеты с фиксированной запятой в формат с плавающей запятой (так как в Android доступна только версия Common стандарта OpenGL ES). Драйверы Common и Common-Lite во встроенных системах Linux обычно имеют имена, похожие на libGLESv1_CM.so и libGLESv1_CL.so .

Илон Маск рекомендует:  Триггеры oracle forms для начинающих

Если код OpenGL портируется из приложения для настольных ПК, то, скорее всего, в нем уже используются операции с плавающей запятой. Однако следите за тем, чтобы код не включал в себя операции с плавающей запятой с двойной точностью. Android поддерживает операции с плавающей запятой с двойной точностью, но OpenGL ES поддерживает только одинарную точность. По этой причине перед переносом кода OpenGL ES 1.1 или 2.0 необходимо преобразовать все значения с двойной точностью в значения с одинарной точностью.

Расширения OpenGL

Одно из наиболее значительных препятствий при портировании кода OpenGL на другую платформу возникает в связи с использованием в коде приложения расширений OpenGL и библиотеки EGL (Embedded System Graphics Library). Необходимо на раннем этапе портирования выяснить, какие расширения используются в старом коде, и сравнить их с расширениями, доступными на целевых устройствах Android. Расширение — это реализованный разработчиками графического процессора способ предоставления доступа к специальным возможностям графического процессора, выходящими за рамки стандартных спецификаций OpenGL. Для каждого использованного в старом коде расширения, недоступного на целевой платформе, потребуется написать новый код, позволяющий обойтись без этого расширения, или использовать другое расширение.

Поддерживаемые расширения существенно различаются в разных версиях OpenGL и даже на разных платформах Android из-за различий в архитектуре графического процессора. Системы с процессорами Intel Atom оснащаются графическими процессорами PowerVR*, представляющими наиболее распространенную архитектуру графических процессоров в современных мобильных устройствах. При создании приложений для Android не следует полагаться на то, что определенное расширение OpenGL ES будет доступно на любом устройстве. Приложение должно запрашивать список доступных расширений OpenGL ES во время выполнения. Такие списки расширений можно получить из драйверов OpenGL ES и EGL с помощью следующих функций:

  • glGetString(GL_EXTENSIONS);
  • eglQueryString(eglGetCurrentDisplay(), EGL_EXTENSIONS);

Имена всех функций и перечислений, необходимых для вызова расширений, определены в файлах заголовков glext.h , gl2ext.h и eglext.h , поэтому после того, как приложение проверит доступность определенного расширения во время выполнения, его можно будет непосредственно вызвать.

На веб-сайте Google Play предлагается полезное приложение OpenGL Extensions Viewer (GLview), выполняющее данный запрос и отображающее полученную информацию для любого устройства Android, на котором оно запускается. Было бы неплохо, если бы вы сами протестировали несколько устройств Android на наличие нужных расширений средством, подобным GLview. Кроме того, Khronos поддерживает реестр API-интерфейсов OpenGL ES для всех известных расширений OpenGL ES — используйте этот важный источник информации.

Сжатые форматы текстур

Наиболее важные расширения OpenGL ES обеспечивают поддержку сжатых текстур. Эта важная технология используется в большинстве 3D-игр для снижения требований к памяти и повышения производительности, но форматы, применяемые в OpenGL ES, определяются только расширениями и поэтому различаются для каждой платформы. К сожалению, единственным форматом, который поддерживается на всех устройствах Android (кроме устройств первого поколения, не поддерживавших OpenGL ES 2.0) является ETC1 (Ericsson Texture Compression). Формат ETC1 обеспечивает точность только 8 бит на пиксель и не поддерживает альфа-канал. Так как в большинстве игр используются сжатые текстуры с альфа-каналом, это часто затрудняет процесс портирования. Несколько архитектурно-зависимых форматов для различных платформ Android поддерживают альфа-канал, но при их использовании ваша игра будет работать только на устройствах Android с данной архитектурой графического процессора. В таблице 1 приведен список архитектур графических процессоров и соответствующих сжатых форматов текстур для Android.

Таблица 1. Архитектурно-зависимые сжатые форматы текстур с поддержкой альфа-канала

Архитектура графического процессора Форматы текстур
PowerVR PVRTC
ATI/AMD ATITC/3DC
NVIDIA Tegra* 2/3 DXT/S3TC

Графический процессор PowerVR на системах с процессором Intel Atom помимо ETC1 поддерживает форматы PVRTC. PVRTC поддерживает альфа-канал и точность 2 или 4 бит на пиксел, что помогает значительно уменьшать размер текстур по сравнению с форматом ETC1. PVRTC — самый массовый формат после ETC1, который также используется на всех поколениях устройств Apple iPhone*, iPod touch* и iPad*, поэтому он обеспечивает некоторую совместимость с устройствами Android на процессорах Intel Atom за рамками базового стандарта OpenGL ES, что имеет важное значение при портировании игр на платформы Android и Apple iOS*. Тем не менее остаются устройства Android с другими архитектурами графических процессоров, для которых также требуется решение. Если в вашем приложении используются любые архитектурно-зависимые форматы текстур, оно должно запрашивать расширения OpenGL ES во время выполнения для определения доступных форматов и использовать только текстуры, которые были сжаты в этом формате. Нужно принять непростое проектное решение. Варианты таковы:

  • Не поддерживать устройства Android с другими архитектурами графических процессоров.
  • Предоставить текстуры, сжатые во всех трех архитектурно-зависимых форматах.
  • Не использовать сжатие текстур с альфа-каналом.
  • Разделить цветовые и альфа-компоненты на пары файлов ETC1 и совмещать их во фрагментном шейдере (fragment shader).

Приняв решение о том, какие архитектурно зависимые форматы должны присутствовать в вашем приложении, не забудьте объявить их в файле манифеста, как будет описано далее. Дополнительные сведения см. в статье о поддержке сжатия текстур [Eng].

Библиотека GLU

Версии OpenGL для настольных ПК обычно включают в себя библиотеку утилит OpenGL (GLU), содержащую функции для упрощения работы. В библиотеку GLU входят функции, не относящиеся напрямую к OpenGL и необязательные для использования OpenGL, но они могут быть полезны при создании 3D-приложений для OpenGL. Обычно библиотека GLU включает в себя функции для конструирования матриц модели-вида и проекции, выполнения общих матричных расчетов, расчета поверхностей с произвольной геометрией (quadric), тесселяции полигонов (tessellation), генерации мип-карт (mipmap) и вывода сообщений об ошибках. Во многих играх OpenGL для настольных ПК используются некоторые функции GLU, что может вызвать проблемы, поскольку в Android реализован только минимум возможностей GLU и они доступны только в SDK. Эти классы перечислены в таблице 2.

Таблица 2. Сводная информация о классах Android с поддержкой функций GLU

Класс Функция
android.opengl.GLU Создание матриц проекции для OpenGL ES
android.graphics.Matrix Создание матриц модели вида и общих матриц

В OpenGL ES 1.1 и 2.0 поддерживается генерация мип-карт и отсутствует поддержка расчета поверхностей с произвольной геометрией и тесселяции полигонов. Если эти функции необходимы, существуют другие реализации GLU с открытым исходным кодом, более полные и совместимые с Android NDK, например GLU ES.

Объявление OpenGL ES в файле манифеста

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

В Android 4.0 (API level 14) было представлено важное изменение — аппаратное ускорение OpenGL ES теперь включено по умолчанию для всех приложений, в которых декларируется параметр minSdkVersion со значением 14 или выше. Приложения могут включать ускорение на более низких уровнях API путем добавления атрибута andro > в тег . Если ваше приложение использует новые функции Android 4.0, требующие аппаратного ускорения OpenGL ES, например класс TextureView , его необходимо включить в файле манифеста, иначе эти функции не будут работать.

Если ваше приложение использует класс NativeActivity , он должен быть объявлен в файле манифеста и должно быть указано имя библиотеки общих объектов, содержащей действие NativeActivity. Параметр minSdkVersion также должен иметь значение 9 или выше. См. пример в образце приложения native-activity в NDK.

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

Параметры манифеста, необходимые при использовании сжатых форматов текстур:

Настройка системы разработки под Android для процессоров Intel Atom

При настройке своей системы разработки под Android обязательно выберите версию Android со встроенной поддержкой процессоров Intel Atom. Таким образом, вы сможете запускать свои приложения на устройствах Intel Atom и использовать системные образы AVD (Android Virtual Devices) с эмуляцией Intel Atom. В таблице 3 собрана информация обо всех основных версиях Android до сегодняшнего дня и о том, для каких из них доступны системные образы с эмуляцией встроенных процессоров Intel Atom.

Таблица 3. Сводная информация о версиях Android с поддержкой OpenGL ES и процессоров Intel® Atom

Версия Название API Поддерживает Поддерживает Intel Atom
Android 1.5 Cupcake 3 OpenGL ES 1.0 Нет
Android 1.6 Donut 4 OpenGL ES 1.0, 1.1 Нет
Android 2.0 Éclair 5 OpenGL ES 1.0, 1.1 Нет
Android 2.1 Éclair 7 OpenGL ES 1.0, 1.1 Нет
Android 2.2 Froyo 8 OpenGL ES 1.0, 1.1, 2.0 Нет
Android 2.3.3 Gingerbread 10 OpenGL ES 1.0, 1.1, 2.0 Да
Android 3.0 Honeycomb 11 OpenGL ES 1.0, 1.1, 2.0 Нет
Android 3.1 Honeycomb 12 OpenGL ES 1.0, 1.1, 2.0 Нет
Android 3.2 Honeycomb 13 OpenGL ES 1.0, 1.1, 2.0 Нет
Android 4.0 Ice Cream Sandwich 14 OpenGL ES 1.0, 1.1, 2.0 Нет
Android 4.0.3 Ice Cream Sandwich 15 OpenGL ES 1.0, 1.1, 2.0 Да
Android 4.1 Jelly Bean 16 OpenGL ES 1.0, 1.1, 2.0 Да

Версии Android 2.3.3 (Gingerbread), 4.0.3 (Ice Cream Sandwich) и 4.1 (Jelly Bean) полностью поддерживают процессоры Intel Atom, включая драйверы для OpenGL ES 1.0, 1.1 и 2.0. Просто выберите одну из этих версий в Android SDK Manager и убедитесь, что в списке есть системный образ Intel x86 Atom System Image. Кроме того, загрузите и установите Intel® Hardware Accelerated Execution Manager (HAXM), который указывается в разделе Extras в SDK Manager. Если вы еще не установили средство Android SDK Manager, его можно загрузить по адресу http://developer.android.com/sdk/index.html.


SDK Manager загружает программу установки HAXM и помещает ее в папку Extras, но для завершения установки необходимо запустить программу установки HAXM вручную. Необходимо также включить функцию Virtualization Technology в меню установки ROM BIOS на компьютере, который используется для разработки. Программа установки HAXM находится в папке …\android-sdk\extras\intel\Hardware_Accelerated_Execution_Manager . При запуске эмулятора x86 AVD с правильно установленным средством HAXM отображается следующее сообщение: «HAX is working and emulator runs in fast virt mode» (Средство HAX запущено, и эмулятор работает в быстром виртуальном режиме)

Использование системных образов x86 и HAXM с эмулятором AVD

Любому разработчику приложений для встроенных систем известно, насколько ускоряет работу эмулятор виртуального устройства. Но с системным образом ARM эмулятор AVD работает невыносимо медленно, поскольку он должен эмулировать каждую инструкцию ARM в системе разработки на базе Windows или Linux. На типичном эмуляторе AVD с ARM одна лишь загрузка Android может занять 5 минут. Для решения этой проблемы компания Intel выпустила средство HAXM, запускающее системные образы Android x86 непосредственно с помощью функции Virtualization Technology, встроенной в новые процессоры Intel для настольных ПК. Если вы установите и будете использовать это средство для работы с AVD и системным образом Intel Atom x86, это позволит значительно ускорить разработку приложений, и для начала работы вам даже не понадобится устройство с Intel Atom.

Компания Google добавила поддержку OpenGL ES 2.0 в эмулятор AVD, начиная с версии SDK Tools 17 (Android 4.0.3 r2) в апреле 2012 года. Это позволяет транслировать вызовы OpenGL ES 2.0 в функции API OpenGL 2.0, доступные в операционной системе компьютера, что намного ускоряет обработку 3D-графики. Однако эта функция должна быть специально включена при создании AVD; иначе вызовы OpenGL ES 2.0 возвращают ошибку. В операционной системе Windows или Linux на компьютере также должны быть установлены драйверы для OpenGL 2.0 (или более поздней версии), что, в свою очередь, обычно требует наличия установленного отдельного графического адаптера. Эмуляция OpenGL ES 2.0 работает в системных образах ARM и x86, но для достижения максимальной производительности используйте системный образ x86 с включенным HAXM. Разница в производительности огромна.

Чтобы включить эмуляцию OpenGL ES 2.0, выберите AVD в средстве AVD Manager и щелкните Edit (Изменить). Затем в окне Hardware Properties (Свойства оборудования) щелкните New (Создать); прокрутите вниз список свойств и найдите элемент GPU emulation (Эмуляция графического процессора), затем щелкните OK. Измените значение этого свойства с no на yes и щелкните Edit AVD (Изменить AVD), затем щелкните OK для сохранения изменений. Должно появиться сообщение hw.gpu.enabled=yes .

До версии SDK Tools 17 эмуляция AVD поддерживала только OpenGL ES 1.0 и 1.1. Включение эмуляции графического процессора необязательно для версии 1.1, поскольку эмуляция может выполняться без помощи операционной системы компьютера, хотя и намного медленнее. Пакет SDK Tools не может эмулировать версию 2.0 без помощи операционной системы компьютера, и при ее отсутствии AVD просто закрывает ваше приложение, когда пытается инициализировать OpenGL ES 2.0.

В качестве первоначального теста для проверки эмуляции OpenGL ES 2.0 используйте образец приложения HelloEffects. Образец GLES20TriangleRenderer при выполнении на AVD просто восстанавливает версию 1.1, поэтому он неприменим в качестве теста. Все образцы OpenGL ES 2.0, включенные в Android SDK и NDK, достаточно примитивны и не должны рассматриваться как полноценные тесты эмуляции OpenGL 2.0.

Intel® Graphics Performance Analyzers

Еще одним важным набором средств, доступных разработчикам приложений на базе OpenGL ES для устройств Android с процессорами Intel Atom, являются анализаторы производительности графики Intel® (Intel® GPA). Этот набор средств позволяет в режиме реального времени отслеживать десятки критически важных системных метрик, оценивающих параметры ЦП, графического процессора и OpenGL ES. Анализаторы Intel GPA выполняются в системах разработки Windows или Ubuntu Linux и взаимодействуют с компонентами драйверов, работающих на целевом устройстве Android, через отладочный интерфейс Android. Проведя несколько экспериментов, вы можете быстро визуально выявить критические секции графического конвейера и определить наиболее перспективные пути оптимизации кода.

Получить дополнительные сведения и загрузить последнюю версию Intel GPA (2012 R4) для разработки под Andro >

Заключение

Постоянное улучшение поддержки OpenGL ES и C/C++ в Android помогло устранить часть трудностей, связанных с портированием игр и других приложений, интенсивно использующих 3D-графику, на платформу Android, в том числе на устройства на базе процессоров Intel Atom. Тем не менее некоторые препятствия остаются, и важно изучить их, прежде чем начинать проект портирования игры. Наиболее важные препятствия касаются отличий в поддержке расширений OpenGL и сжатых форматов текстур на Android. Можно порадоваться тому, что компании Google и Intel за последние годы совершили внушительный скачок вперед, усовершенствовав средства разработки для OpenGL ES 2.0, и перед разработчиками ПО открылись широкие возможности по адаптации накопившегося к сегодняшнему дню огромного количества игр, игровых движков и других старых программ на базе стандарта OpenGL.

Работа с расширениями OpenGL с использованием NV >Автор: Сергей Александрович Гайдуков

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

Что такое расширение OpenGL

Если производитель обнаруживал, что OpenGL не может использовать все аппаратные возможности его «железа», он выпускал расширение для OpenGL с поддержкой новых возможностей. Причем это расширение, как правило, появлялось почти на год раньше, чем новая версия DirectX, поддерживающая новые возможности. Так, поддержка вершинных и пиксельных шейдеров для GeForce2 в OpenGL появилась намного раньше 8-й версии DirectX. А когда DirectX 8 все-таки вышел, то выяснилось, что про пиксельные шейдеры GeForce2 он ничего не знает:

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

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

Для выполнения всех примеров вам потребуются Microsoft Visual C++ 6 и NVIDIA OpenGL SDK, который можно скачать с www.nvidia.com. В составе этого SDK имеется NVIDIA OpenGL Extension Specification, в котором описаны большинство расширений, которые поддерживаются NVIDIA.

Инициализация WGL-расширений

Перед тем, как использовать любое OpenGL-расширение, его надо инициализировать. Для начала рассмотрим инициализацию WGL-расширений. Этот класс расширений предназначен для инициализации OpenGL в ОС семейства Windows, а также для выполнения некоторых функций, которые зависят от используемой операционной системы — например, работа со внеэкранными поверхностями (буферами пикселей). В приведенном ниже примере показывается, как проверить поддержку двух расширений WGL_ARB_pixel_format и WGL_ARB_pbuffer и подготовить их к использованию. Этот и все остальные примеры из статьи полностью можно скачать.

Для начала не забудьте настроить Visual C++ для работы с NVSDK (пропишите пути к включаемым файлам и библиотекам). Теперь создайте новый проект и настройте его для работы с OpenGL (подключите библиотеки opengl.lib, glu32.lib, glut32.lib, установите точку входа mainCRTStartup и т.д.)

Напишите простейшее GLUT-приложение, создающее окно:

Не забудьте директивой #include подключить заголовочные файлы glext.h (замена gl.h) и wglext.h. Перед началом работы с WGL-расширениями надо проверить поддержку расширения WGL_ARB_extensions_string, при помощи которого осуществляется инициализация остальных WGL-расширений.

Для это мы объявляем переменную, которая является указателем на функцию wglGetExtensionsStringARB. Обратите внимание, что название типа функции начинается с префикса PFN, далее идет название расширения, а затем окончание ARBPROC (в случае расширений ARB):

Теперь надо получить адрес этой функции. Для этого используется функция wglGetProcAddress. В качества параметра она принимает строку, содержащую название функции, адрес которой надо получить:

В случае удачного вызова она возвращает адрес функции, иначе — NULL.

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

Если все прошло удачно, то, используя функцию wglGetProcAddress, можно получить адреса точек входа нужных нам функций:

Как видно, инициализировать WGL-расширения непосредственно через OpenGL API довольно неудобно, особенно если надо подключить больше десятка различных расширений, каждое из которых содержит больше десятка функций. Но в NV >

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

Это все! Теперь вы можете вызывать функции указанных расширений как обычные функции.

Инициализация OpenGL расширений

В принципе, инициализация GL-расширений должна была выполняться очень просто, путем включения в проект файла glext.h. Но на практике это не так. Причина этого кроется в том, что файл opengl.lib, поставляемый с Visual C++ 6, не содержит функций GL-расширений (если бы он их содержал, программа бы отказывалась запускаться на видеокартах, драйверы которых не полностью поддерживают все GL-расширения).

Поэтому инициализация GL-расширений выполняется аналогично инициализации WGL-расширений с единственным отличием — для получения списка GL-расширений используется функция glGetString(GL_EXTENSIONS).

Если же вы используете NVIDIA OpenGL Helper Library, то никакой разницы в инициализации GL и WGL расширений нет — функция glh_init_extensions умеет инициализировать оба вида расширений.

Использование расширений OpenGL на примере GL_EXT_separate_specular_color

Рассмотрим небольшую программу, которая рисует на экране вращающийся чайник с нанесенной текстурой. Клавишей F1 можно включать/выключать вращение. При нажатой левой кнопке мыши можно вращать чайник, а при правой — перемещать. Клавишей F2 можно сменить плоскость, в которой перемещается чайник.

Текстура чайника хранится в файле wood.tga. Для его загрузки используется библиотека NV_UTIL из состава NVSDK, которая содержит множество процедур для работы с наиболее распространенными графическими форматами. Перед использованием этой библиотеки нужно подключить к проекту библиотеку nv_util.lib.

Функции для работы с файлами формата TGA находятся в файле nv_tga.h в пространстве имен tga. Следовательно, для доступа к ним надо использовать либо директиву using namespace tga, либо указывать перед названием функций и типов этой библиотеки префикс tga.

Загрузка файла в память осуществляется функцией tga::read, которой передается имя файла. Функция возвращает указатель на структуру tga::tgaImage. Нас интересуют следующие поля структуры:
· GLsizei width — ширина рисунка;
· GLsizei height — высота рисунка;
· GLubyte *pixels — указатель на массив пикселей;
· GLenum format — формат пикселей рисунка.

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

Хотя в примерах NVSDK это нигде не показано, я считаю, что перед удалением указателя надо удалить из памяти еще и указатель на массив пикселей (pixels), иначе он останется находится в памяти до окончания работы программы.

Теперь можно использовать эту информацию для создания текстуры.

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

Но что делать, если надо получить блик именно белого цвета на деревянном чайнике. Одно из решений проблемы — наложение текстуры на чайник в 2 прохода. Сначала мы рисуем чайник с наложенной текстурой с отключенными бликами, а затем, на втором проходе, рисуем блики без текстуры. Пример реализации этого алгоритма можно найти в книге М. Красного «OpenGL. Графика в проектах Delphi» (глава 4, пример 83).

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

Для того чтобы заставить программу использовать эту модель освещения, в нее достаточно добавить всего несколько строк.


Прежде всего в процедуру Init() добавим инициализацию расширения и сроку для включения режима освещения GL_SEPARATE_SPECULAR_COLOR_EXT. Для этого используется процедура glLightModeli с новыми параметрами.

Параметр GL_SEPARATE_SPECULAR_COLOR_EXT включает режим наложения бликов после наложения текстуры. Для возвращения к классической схеме вычисления цвета достаточно вызвать функцию с параметром GL_SINGLE_COLOR_EXT.

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

Расширение GL_SEPARATE_SPECULAR_COLOR_EXT поддерживается всеми видеокартами NVIDIA, за исключением видеокарт семейства Riva128/128ZX.

OpenGL — отличная технология компьютерной графики

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

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

Объяснение термина

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

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

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

Существуют реализации интерфейса для Windows, Unix-платформ, PlayStation 3 и Mac OS, которые предоставляются производителями видеокарт для возможности работы с ними. Но есть и открытая реализация для других графических карт — библиотека Mesa, которая хоть и считается неофициальной, но отлично справляется со своими задачами.

Появление

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

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

Таким образом, в 1992 году появилась первая OpenGL. Последнее ее обновление произошло в 2020 году до версии 4.6.

Основные функции

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

Несколько стандартных возможностей спецификации:

  • Применение В-сплайнов, необходимых для проведения кривых по опорным точкам;
  • Геометрические и растровые примитивы, из которых делаются любые объекты;
  • Управление цветами в режиме RGBA, или выбирая оттенки из палитры;
  • Модельная и видовая оптимизация для перемещения объекта в трехмерном пространстве;
  • Одинарная, двойная (для устранения мерцания в анимации) и тройная буферизация которая в сравнении со второй быстрее выводит изображение;
  • Стирание невидимых линий и поверхностей;
  • Придание объектам текстуры, чтобы они выглядели реалистично;
  • Сглаживание линий путем изменения яркости и цвета пикселей возле них;
  • Расстановка и контроль источников света;
  • Добавление таких эффектов как туман, дым и пр.

Принцип действия

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

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

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

Что такое opengl вспомогательные библиотеки

Широко используются 4 дополнительные библиотеки:

  • GLU. Она уже считается стандартом в работе с компьютерной графикой, поэтому поставляется в комплекте с OpenGL. Первая построена поверх второй, поэтому использует ее функции, только в упрощенной, но в то же время совершенной форме, а также может выполнять и более сложные задачи.
  • GLUT. Функционирует на различных операционках. Эта библиотека пригодиться вам, если захотите работать с окнами и устройствами ввода-вывода. Еще она позволяет распознавать такие непростые объекты как тетраэдры, конусы и даже, к примеру, чайники, всего одной командой.
  • GLAUX. Менее производительный аналог предыдущего варианта, созданный компанией Microsoft специально для работы в ОС Windows.
  • GLX. Еще одно расширение для Виндовс, предоставляющее как локальный, так и сетевой рендеринг.

Сравнение с Direct3D

Основным конкурентом OpenGL выступает Direct3D — продукт фирмы Майкрософт, созданный специально для написания компьютерных игр. На вопрос «что лучше» сложно ответить, потому что обе имеют свои преимущества.

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

  • Direct3D работает только на платформах Intel и ОС Windows, а OpenGL успешно открывается не только на этой системе, но и на Unix, Linux, MacOS, IRIX, SunOS и пр.
  • Однако опенгл принимают не все графические карты, а директ лишен такого недостатка;
  • Также последний отличается лучшим объектно-ориентированного подходом.
  • Правда, кроссплатформенная спецификация проще к пониманию, поэтому новичкам для обучения основам трехмерной графики лучше выбирать ее.

На этом всё что касается того, что такое opengl.

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

Руководство по программированию OpenGL для Mac

Определение возможностей OpenGL, поддерживаемых средством рендеринга

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

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

Поскольку определенная функциональность становится широко принятой, она может быть перемещена в базовый OpenGL API ARB. В результате функциональность, которую Вы хотите использовать, могла быть включена как расширение как часть базового API или обоих. Например, возможность объединить среды текстуры поддерживается через GL_ARB_texture_env_combine и GL_EXT_texture_env_combine расширения. Это — также часть базовой версии 1.3 OpenGL API. Несмотря на то, что у каждого есть схожая функциональность, они используют различный синтаксис. Вы, возможно, должны зарегистрироваться в нескольких местах (базовый OpenGL API и дополнительные строки), чтобы определить, поддерживает ли определенное средство рендеринга функциональность, которую Вы хотите использовать.

Обнаружение функциональности

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

Независимо от какой функциональности Вы проверяете на, подход является тем же. Необходимо вызвать функцию OpenGL glGetString дважды. В первый раз передают GL_VERSION постоянный. Функция возвращает строку, указывающую версию OpenGL. Во второй раз, передача GL_EXTENSIONS постоянный. Функция возвращает указатель на дополнительную строку имени. Дополнительная строка имени является разделенным пробелами списком расширений OpenGL, поддерживающихся текущим средством рендеринга. Эта строка может быть довольно длинной, не выделяйте строку фиксированной длины для возвращаемого значения glGetString функция. Используйте указатель и оцените строку на месте.


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

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

Проверка функциональность, несмотря на то, что довольно прямой, включает запись большого блока кода. Лучший способ проверить на функциональность OpenGL состоит в том, чтобы реализовать функцию проверки возможностей, которую Вы вызываете, когда Ваша программа запускает, и затем любое время изменения средства рендеринга. Перечисление 8-1 показывает выборку кода что проверки на несколько расширений. Подробное объяснение каждой строки кода появляется после перечисления.

Проверка перечисления 8-1 функциональность OpenGL

Вот то, что делает код:

Получает строку, указывающую версию OpenGL.

Получает дополнительную строку имени.

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

Получает максимальный размер текстуры.

Проверки, поддерживаются ли объекты массива вершины.

Проверки на расширение предела Apple.

Проверки на поддержку версии 1.0 языка штриховки OpenGL.

Проверки на поддержку таблицы цветов RGBA-формата. В этом случае код должен проверить на специфичную для поставщика строку и на строку ARB. Если любой присутствует, функциональность поддерживается.

Проверки на расширение имели отношение к параметру уровня детализации текстуры (ЛОД). В этом случае код должен проверить на специфичную для поставщика строку и на версию OpenGL. Если строка поставщика присутствует, или версия OpenGL больше, чем или равна 1,2, функциональность поддерживается.

Получает предел OpenGL для прямоугольных текстур. Для некоторых расширений, таких как прямоугольное расширение текстуры, может не быть достаточно проверить, поддерживается ли функциональность. Вы, возможно, также должны проверить пределы. Можно использовать glGetIntegerv и связанные функции ( glGetBooleanv , glGetDoublev , glGetFloatv ) получить множество значений параметров.

Можно расширить этот пример для создания проверяющей полную функциональность подпрограммы для приложения. Для получения дополнительной информации посмотрите GLCheck.c файл в Какао пример приложения OpenGL.

Код в Перечислении 8-2 показывает один способ запросить текущее средство рендеринга. Это использует API CGL, который можно вызвать из приложений Какао. В действительности необходимо выполнить итерации по всем дисплеям и всем средствам рендеринга для каждого дисплея для получения истинного изображения функциональности OpenGL, доступной в определенной системе. Также необходимо обновить функциональность, создают снимки каждый раз список дисплеев или выводят на экран изменения конфигурации.

Перечисление 8-2 , Настраивающее допустимый контекст рендеринга для получения информацию функциональности средства рендеринга

Вот то, что делает код:

Получает дисплей ID основного дисплея.

Отображает дисплей ID на маску OpenGL.

Заполняется формат пикселя приписывает массив с атрибутом маски дисплея и значением маски.

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

Получает объект формата пикселя для дисплея. numPixelFormats параметр указывает, сколько форматов пикселя перечислено в объекте формата пикселя.

Создает контекст на основе первого формата пикселя в списке, предоставленном объектом формата пикселя. Только одно средство рендеринга будет связано с этим контекстом.

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

Уничтожает объект формата пикселя, когда он больше не необходим.

Устанавливает текущий контекст в недавно создаваемый, контекст единственного средства рендеринга. Теперь Вы готовы проверить на функциональность, поддерживаемую текущим средством рендеринга. См. Перечисление 8-1 для примера проверяющего функциональность кода.

Уничтожает контекст, потому что он больше не необходим.

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

Инструкции для кода, проверяющего на функциональность

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

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

Удостоверьтесь, что средство рендеринга присоединено к допустимому контексту рендеринга перед проверкой функциональности того средства рендеринга.

Проверьте версию API или дополнительную строку имени для текущего средства рендеринга перед выдачей команд OpenGL.

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

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

Средство рендеринга OpenGL зависящие от реализации значения

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

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

Таблица 8-1 Общие ограничения средства рендеринга OpenGL

Максимальный размер текстуры

Число плоскостей буфера глубины

Число плоскостей буфера шаблонов

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

Таблица 8-2 ограничения программы построения теней OpenGL

Максимальное количество атрибутов вершины

Максимальное количество универсальных векторов вершины

Максимальное количество универсальных векторов фрагмента

Максимальное количество переменных векторов

Максимальное количество модулей текстуры, применимых в вершинном шейдере

Максимальное количество модулей текстуры, применимых в программе построения теней фрагмента

Илон Маск рекомендует:  Поиск уязвимостей в программах с помощью анализаторов кода
Понравилась статья? Поделиться с друзьями:
Кодинг, CSS и SQL