Очень часто встречаются различные заблуждения по поводу этих двух API .
Я попытался изложить в этой статье основные факты, которые следует знать как разработчикам, так и конечным пользователям.
Так как тема очень холиварная, я старался придерживаться максимально нейтрального тона.
Взгляд с высоты птичьего полёта
Оба API предоставляют доступ к функциям аппаратного ускорения 3D-графики.Распространённые заблуждения
OpenGL отстаёт от Direct3D, и вообще, судя по таким вялым изменениям в спецификации, наверное уже совсем мёртв.Собственно, причина такого заблуждения - это незнание о расширениях. Вообще говоря, OpenGL может и часто опережает (!) Direct3D в плане инноваций, т.к. производитель может добавить расширение к OpenGL, не дожидаясь никого, в то время как в Direct3D изменения может внести только Microsoft.
OpenGL - это для программ профессиональной графики, а Direct3D - это для игр.
Это заблуждение имеет историческую причину. OpenGL исходно разрабатывался как библиотека 3D графики, которая МОЖЕТ, но НЕ ОБЯЗАНА ускоряться аппаратно. Это также объясняет наличие некоторых функций, например рендеринг стерео-изображений, которые не нужны играм. Direct3D же разрабатывался гораздо позже, сразу с расчётом на ускорение на GPU. В момент появления многих пакетов профессиональной работы с графикой Direct3D просто не было.
Microsoft поставляет вместе с Windows драйверы без поддержки OpenGL. OpenGL будет рендерить без ускорения, или эмулироваться через DirectX. Так что, если нужна поддержка OpenGL под Windows, нужно ставить драйвер с сайта производителя. Причины для такого неприятия OpenGL, скорее всего, опять чисто политические.
Так что же делать, как жить?
Примечание: А вот эта часть носит весьма субъективный характер.Если Вы - разработчик, и решаете, какое API использовать, то задумайтесь над следующим:
За OpenGL - массовая кроссплатформенность, в частности, доступность всех новых функций и на Windows XP, где Direct3D 10/11 нет, и никогда не будет.
Против OpenGL - драйвера в Windows из коробки не имеют поддержки OpenGL, так что ставить их нужно с сайта производителя.
Если Вы - новичок в разработке 3D-приложений, и желаете освоить эту область, то я бы рекомендовал сделать так: сначала разобраться с Direct3D (причина тому проста - Microsoft предоставляет очень качественный SDK), а затем разобраться с OpenGL (это будет очень просто после Direct3D). К сожалению, такой вещи, как SDK, для OpenGL нет. Поэтому осваивать с нуля будет сложнее.
Вот вроде и всё. Успехов в разработке!
Учитывая сегодняшнее доминирование DirectX, мы невольно забываем, что 10 лет назад шла жёсткая война между Microsoft и Silicon Graphics в области 3D API. Две компании пытались завоевать доверие разработчиков, Microsoft использовала свою мощную финансовую подпитку, а SGI опиралась на опыт и репутацию в области 3D реального времени. В этой современной битве "Давид против Голиафа", малыш получил на свою сторону одного из самых известных игровых разработчиков - Джона Кармака (John Carmack). Частично это произошло из-за успеха движка Quake; надёжная поддержка OpenGL стала важным фактором, чтобы заставить производителей GPU выпускать полный комплект драйверов. Фактически, это дало 3dfx одно из ранних преимуществ и отбросило ATI в аутсайдеры, пока компания решала проблемы с поддержкой OpenGL.
Между тем Microsoft создавала свой API "с нуля", развитие было постепенным. Несколько лет возможности Direct3D были далеки до желаемого уровня, многие программисты находили API более запутанным и непонятным, чем OpenGL. Но никто не может обвинить Microsoft в том, что эта компания легко сдаётся. С каждой новой версией Direct3D, API постепенно догонял OpenGL. Инженеры в Редмонде работали, не покладая рук, чтобы обеспечить производительность до уровня конкурирующего API.
Поворотный момент настал с выпуском DirectX 8, который появился в 2001 году. Впервые Microsoft API предоставил больше возможностей, нежели просто копировал API SGI. Были введены собственные инновации, подобно поддержке вершинных и пиксельных шейдеров. SGI, чей главный источник прибыли заключается в продаже дорогих рабочих станций 3D, оказалась в неудачном положении, поскольку компания не смогла предсказать взрывной рост видеокарт для геймеров, который позволил ATI и nVidia проникнуть и на профессиональный рынок с настольно низкими ценами (из-за экономии масштаба), что SGI просто не могла конкурировать. Разработка OpenGL была также осложнена горячими спорами между сторонниками API. Поскольку ARB (группа, отвечающая за принятие новых версий API) включала много разных и часто конкурирующих компаний, было сложно прийти к соглашению по поводу функций, которые нужно добавить к API. Вместо этого каждая компания защищала собственные интересы. Напротив, Microsoft тесно работала с ATI и nVidia, используя их вес для принятия решений, если возникали какие-то противоречия.
С выпуском DirectX 9 Microsoft удалось одержать решающую победу и впечатлить разработчиков. Только Джон Кармак и те разработчики, которым была важна универсальность, остались привержены OpenGL. Но их авторитет пошатнулся. Впрочем, не будем забывать, что фортуна может и отворачиваться. Так, в конце концов, случилось с web-браузерами. Пусть даже компания преодолела трудный путь, заняв, фактически, монопольное положение, почивать на лаврах не стоит, поскольку конкуренты могут буквально возникнуть из ниоткуда. И когда группа Khronos взялась за разработку OpenGL два года назад, у многих затеплилась надежда, и к нынешней конференции SIGGRAPH был проявлен немалый интерес.
В августе Khronos анонсировала OpenGL 3, серьёзное обновление API, которое призвано догнать Microsoft, а программный гигант, в свою очередь, запланировал DirectX 11 API следующего поколения. Но всё получилось несколько иначе.
Чтобы полностью понять противоречия, окружающие объявление OpenGL 3, нам нужно вернуться на несколько лет назад, в 2002 год. Как мы уже сказали выше, примерно в то же время OpenGL стал терять почву под ногами. До того момента DirectX просто копировал возможности OpenGL. На этот же раз Microsoft удалось обогнать API SGI. С выпуском DirectX 9, Microsoft добавила поддержку высокоуровневого языка шейдеров HLSL, а у OpenGL не было ничего сравнимого. Следует напомнить, что корни OpenGL лежат в IRIS GL, API, которое было изначально создано SGI для поддержки всех функций "железа" компании. Долгое время ATI и nVidia просто следовали модели рендеринга SGI, то есть OpenGL очень даже хорошо подходил видеокартам производителей с самого их рождения. Но с появлением шейдеров новые GPU отклонились от традиционного конвейера рендеринга.
 |
В то время одна компания осознавала важность быстрого эволюционного развития OpenGL, если это API надеется работать на современных GPU: мы имеем в виду 3DLabs. Это неудивительно, поскольку 3DLabs забросила игровые карты после неудачи Permedia 2, сконцентрировавшись на профессиональном рынке, где OpenGL является стандартом. 3DLabs представила план из нескольких пунктов, который позволял OpenGL перейти в новую эру. Первый пункт: добавление высокоуровневого языка шейдеров GLSL. Затем планировался полный пересмотр API. Многие функции API уже потеряли смысл на современных 3D-видеокартах, но из-за обратной совместимости они требовали разработчиков GPU поддерживать их, по крайней мере, на программном уровне. Это не только приводило к тому, что писать драйверы становилось сложнее, а также повышало вероятность возникновения ошибок, но и наследственные функции делали API довольно запутанным для программистов-новичков.
Поэтому 3DLabs хотела предложить набор функций, который гарантирует эффективное выполнение на GPU, а также устранит устаревшие или избыточные опции. Этот набор функций был назван OpenGL 2.0 Pure и предназначался для разработчиков новых приложений. Для обратной совместимости к Open GL 2.0 был добавлен полный набор расширений OpenGL 1.x.
К сожалению, после бесконечных дискуссий в рамках ARB, этот план был отклонён. И когда OpenGL 2.0 стал, наконец, доступен, всё что в нём было сделано - всего лишь добавлена поддержка GLSL в API. Все другие предложения 3DLabs оказались в мусорной корзине, в результате OpenGL продолжал отставать от Microsoft API.
 |
Нужны перемены
Другой пример демонстрирует то, что ARB не способна принимать быстрые и эффективные решения. Долгое время OpenGL опирался для рендеринга текстур на технику под названием pbuffers. Все программисты соглашались, что эта техника была сложна в понимании, трудна в использовании и давала плохую производительность. Поэтому ATI предложила расширение для её замены - uber-buffers. Это расширение оказалось весьма амбициозным. Кроме рендеринга на текстуру, ATI сделала возможным рендеринг на массив вершин, не считая других расширенных возможностей. Возможно, расширение было даже слишком амбициозными, на его описание и определение ушло слишком много времени, программисты долго ждать не хотели, поэтому nVidia и 3DLabs, в конце концов, предложили свой вариант, который, по крайней мере, позволял выполнять эффективный рендеринг на текстуру, без глобального подхода у решения ATI. Ушло несколько лет, прежде чем стало возможно увидеть результат всех этих усилий - в виде расширения под названием framebuffer_object, которое обеспечивает базовые функции, появившиеся ещё в DirectX 9!
Так, в 2005 году, OpenGL смог догнать Microsoft API, выпущенный тремя годами раньше. Все основные игроки (ATI, nVidia, 3Dlabs и разработчики ПО) соглашались, что дальше так продолжаться не может, либо OpenGL будет постепенно сходить со сцены, и рано или поздно будет предан забвению. В данном контексте ARB передал бразды правления Khronos в 2006 году, и за будущее OpenGL стала отвечать эта группа. ATI и nVidia поклялись, что они станут выше собственных амбиций и конкуренции и будут эффективно сотрудничать, чтобы OpenGL стал, наконец, достоин XXI века. Разработчики тоже были полны энтузиазма, поскольку группа Khronos очень эффективно показала себя в работе над OpenGL ES, 3D API для мобильных устройств.
Очень быстро группа Khronos начала приоткрывать завесу тайны над будущим OpenGL. Опять же, план заключался в переработке API в два этапа. Первая версия, Longs Peak, должна обеспечить уровень функциональности R300/NV30 на равных с Shader Model 2, а также дать новую, более гибкую модель программирования. Получилось нечто подобное OpenGL 2.0 Pure, который 3DLabs предложила несколько лет раньше, поскольку группа Khronos планировала убрать устаревшие функции API и сфокусироваться на небольшом числе современных функций. Их набор был назван OpenGL Lean and Mean. Вторая версия, с кодовым названием Mount Evans, заключалась в обновлении API, попутно исправляя все ошибки, которые были выявлены, до уровня функций R600/G80 (Shader Model 4). План разработок был очень жёсткий, в нём говорилось о появлении Mount Evans меньше, чем через шесть месяцев после Longs Peak. Но участники группы Khronos были уверены в своих силах.
Со времён ARB произошло ещё одно изменение: группа Khronos решила работать более открыто. Вся новая информация публиковалась на сайте OpenGL, рассказывая разработчикам о новом API, чтобы они смогли заранее получить впечатления о его работе. Всё шло достаточно хорошо до конца 2007 года. Хотя финальная спецификация Longs Peak ожидалась в сентябре, группа Khronos объявила, что из-за проблем она будет отложена - без предоставления каких-либо деталей. О решении работать более открыто, принятом несколько месяцев назад, было забыто, и группа Khronos продолжила свою работу в информационном вакууме. Никаких новостей не было - фактически, о прогрессе в области нового API не появлялось никакой информации.
Разоблачение
 |
Про OpenGL 3 ничего не было слышно до августа 2008, когда проводилась конференция SIGGRAPH. Многие ожидали приятного сюрприза, однако новости Khronos оказались для приверженцев OpenGL разочарованием. API не только опоздал примерно на год, но и кроме всего прочего, большинство новых аспектов Longs Peak было полностью забыто. После фиаско OpenGL 2.0, который на самом деле стал OpenGL 1.6 с другим названием, версия OpenGL 3.0 начала выглядеть не больше, чем версия 2.2. Неприятный сюрприз, вместе с отсутствием новостей в течение нескольких месяцев, привели к весьма агрессивной реакции на действия группы Khronos повсюду на форумах. Поскольку реагировать было как-то надо, Khronos ответила на официальном форуме OpenGL через Бартольда Лихтенберта (Barthold Lichtenbelt) из nVidia. Его детальный ответ , по крайней мере, пролил некоторый свет на то, что происходило в группе. Мы узнали, например, что по некоторым пунктам реализации плана решение так и не было принято вовремя, и вместе с тем, многие считали, что нужно срочно добавить поддержку OpenGL для последних GPU. Поэтому план был изменён, чтобы расширить OpenGL 2 и добавить функции Direct3D 10.
Даже с учётом упомянутых аргументов, группу Khronos можно по-прежнему критиковать за то, что она не смогла вовремя оповестить о кризисной ситуации, предпочитая её замалчивать. Поскольку то же самое случилось шесть лет назад с OpenGL 2.0, то оптимизма на будущее это не внушает. После двух обещаний переписать API - оба из которых не были выполнены - как можно верить в будущее OpenGL? Наконец, комментарий Джона Кармака на последней QuakeCon не приносит облегчения. Когда Джона спросили о состоянии OpenGL 3, он ответил ещё менее политкорректно, чем Лихтенберт.
По словам Кармака, провал OpenGL 3, в отличие от распространённого мнения, связан с провалом некоторых разработчиков САПР/CAD, которые не очень хорошо отнеслись к Longs Peak. Они побоялись проблем с совместимостью и своими приложениями из-за исчезновения некоторых старых функций. Эта версия была тактично подтверждена Лихтенбертом: "Во время стадии дизайна Longs Peak, мы пришли к разногласиям по тем функциям, которые будут убраны из API... Разногласия возникли из-за разных потребностей рынков... Мы обнаружили, что не можем предложить один API для всех..."
Итак, в итоге OpenGL 3 стал не более чем очередным обновлением. API на самом деле не поменялось. Khronos просто назвала некоторые функции не рекомендуемыми, а также привела контекст, в рамках которого функции приведут к ошибкам. Это намного меньше того, что было обещано (разработчикам драйверов всё равно придётся поддерживать эти функции), но всё же является шагом вперёд, поскольку разработчики могут приготовиться к будущим версиям, которые могут, наконец, дать настоящий режим Lean and Mean. OpenGL 3 также вводит понятие профилей. На данный момент профиль только один, но по плану будут созданы профили для игр и для САПР, например, причём каждый профиль будет поддерживать разные массивы функций.
Не считая этого, набор функций, предлагаемый OpenGL 3, очень похож на предложение Direct3D 10, за исключением Geometry Shaders и Geometry Instancing, которые добавлены в API в качестве расширений. Но поддерживаются и некоторые функции Direct3D 10.1, подобно независимым режимам смешения (blending) для MRT.
С выпуском Direct3D 10 Microsoft удалось сделать наиболее развёрнутую версию своего API с момента создания. Конечно, все эти годы совместимости существенно ограничили возможности эволюции API, поэтому целью было и создание основы для будущих разработок. Конечно, новый API получил смешанные отзывы от геймеров и разработчиков.
Microsoft есть, за что порицать. После такой хвальбы своего API ещё за несколько лет до его появления, DirectX 10 привёл к разочарованиям, когда геймеры поняли, что на практике он ничего особо не меняет. Добавьте к этому и тот факт, что новый API был написан исключительно для Vista, поэтому вполне понятен негативный настрой к тому, что преподносилось как маленькая революция. Что касается разработчиков, всё оказалось сложнее. Связав Direct3D 10 и Vista, Microsoft существенно ограничила число парка компьютеров, который работает с новым API.
Более того - и это ни для кого не секрет - в последние годы ПК потерял свою роль в качестве игровой платформы, с выходом приставок нового поколения, на которые перешли несколько крупных разработчиков с ПК. id Software, Epic и Lionhead теперь работают на многоплатформенным проектами, если не разрабатывают игры исключительно для приставок. Поскольку обе HD-приставки на рынке используют GPU DirectX 9, у разработчиков есть все стимулы, чтобы придерживаться предыдущего API Microsoft.
Почему мы говорим о Direct3D 11 уже сейчас? Во-первых, потому что Microsoft, наконец, подняла завесу тайны над собственным API. Во-вторых, поскольку перед нами всё же событие, которое позволяет получить представление о том, чего ожидать от "железа" в следующем году. Более того, есть все шансы, что Direct3D 11 станет более важной страницей в истории этого API, чем версия 10. Если Direct3D 10 был полостью переработанной версией, со всеми связанными рисками, у Microsoft есть достаточный промежуток между версиями 10 и 11, чтобы исправить все проблемы, связанные с первой серьёзной переработкой API. Поэтому Direct3D 11 можно назвать серьёзным обновлением, хотя и нельзя назвать революционным. Новый API построен на тех же принципах, что и Direct3D 10, он совместим с предыдущими версиями и с "железом" предыдущего поколения. Наконец, API будет доступен не только на Windows 7, но и под Vista. Microsoft исправила самые крупные проблемы десятой версии, а среди разработчиков ходят неофициальные слухи, что они пропустят Direct3D 10 и перейдут сразу на версию 11 в будущих играх.
В этом есть смысл по нескольким причинам. Обычно стадия разработки игры занимает от двух до четырёх лет. Поэтому к тому времени, когда разрабатываемая сегодня игра выйдет, Direct3D 11 уже утвердится на парке ПК, поскольку API будет работать на всех компьютерах с Windows 7, а также и на подавляющем большинстве ПК под Vista. Кроме того, очень вероятно, что независимо от даты выхода, грядущие приставки будут использовать GPU, совместимые с Direct3D 11 (или что-то подобное, как Xenos в Xbox 360, который является надстройкой над DirectX 9). Следовательно, нацеливание на подобный набор функций позволит разработчиком захватить рынок приставок следующего поколения. Но мы здесь не для того, чтобы изучать рынок. Что даёт новый API с технической точки зрения?
Многопоточный рендеринг
Многопоточный рендеринг? Но разве мы уже не используем многоядерные CPU на протяжении нескольких лет, и разработчики не научились с ними работать? Что же может быть нового в многопоточных движках рендеринга Direct3D 11? Некоторые из вас будут удивлены, но современные движки по-прежнему используют только один поток для рендеринга. Другие потоки используются для звука, распаковки ресурсов, физики и т.д. Но рендеринг серьёзно нагружает CPU, так почему бы его не разнести на несколько потоков? На то есть несколько причин, некоторые из них связаны с тем, как работает GPU, а другие - с 3D API. Поэтому Microsoft решила устранить программные проблемы, а также помочь решить аппаратные.
 |
На первый взгляд, распараллеливание процесса рендеринга выглядит привлекательно, но если вы присмотритесь внимательнее, то поймёте, что GPU здесь только один (даже если несколько GPU соединяются через SLI или CrossFire, их целью является создание иллюзии, что работает один, виртуальный GPU), поэтому и буфер команд только один. Когда один ресурс используется несколькими потоками, технология взаимного исключения (mutual exclusion, mutex) предотвращает одновременную запись команд от нескольких потоков, чтобы они не мешали друг другу. Это означает, что все преимущества использования нескольких потоков устраняются одной критичной секцией, которая делает код последовательным. Никакой API не в силах решить эту проблему - она унаследована из способа связи CPU и GPU. Но Microsoft предлагает API, которое может попытаться её обойти. В Direct3D 11 появились вторичные буферы для команд, которые можно сохранить и использовать позднее.
 |
Нажмите на картинку для увеличения.
Поэтому у каждого потока есть отложенный контекст, где записаны команды в списке (Display List), который можно вставить в главный поток обработки. Вполне понятно, когда список запрашивается основным потоком (команда "Execute" на слайде "Multi-threaded Submission" ниже), нужно убедиться, что поток закончил его заполнять. Поэтому синхронизация по-прежнему есть, но модель исполнения, по крайней мере, позволяет сделать некоторую работу рендеринга параллельной, хотя, конечно, получающееся ускорение нельзя признать идеальным.
Ещё одна проблема предыдущих версий Direct3D связана с созданием ресурсов - например, текстур. В текущих версиях API (9 и 10), ресурсы приходилось создавать в потоке рендеринга. Разработчики обошли эту проблему, создав поток, который считывает и распаковывает текстуры с диска, после чего заполняет ресурс (объект Direct3D), который создан в основном потоке.
Но, как можно видеть, большая часть рабочей нагрузки по-прежнему остаётся в основном потоке, который и так перегружен. Это не даёт оптимального баланса, который нужен для быстрого выполнения. Поэтому Microsoft добавила новый интерфейс в Direct3D 11: программист может создавать один объект "Device" на поток, который можно использовать для загрузки ресурсов. Синхронизация функций объекта "Device" производится более тонко, чем в Direct3D 10, и намного более экономично по ресурсам CPU.
 |
Нажмите на картинку для увеличения.
Тесселяция
Основной новой функцией Direct3D 10 стало появление геометрических шейдеров, которые, наконец, позволили создавать или уничтожать вершины силами GPU. Но роль данного блока не всегда понимают правильно. Он не только обеспечивает массированную поддержку геометрии, но и лучше подходит для реализации более гибких точечных спрайтов (Point Sprites), Fur Shading, или для расчётов силуэта объекта для алгоритмов объёмных теней. Ничего нет лучше, чем специальный блок для выполнения тесселяции. Изначально он планировался для Direct3D 10 (что объясняет присутствие блока в линейке Radeon HD), но, похоже, Microsoft, ATI и nVidia не смогли достичь соглашения вовремя, поэтому блок исчез из спецификаций, вернувшись только с Direct3D 11. Поэтому тесселяция является новой крупной функцией Direct3D 11 - или, по крайней мере, той, которую проще продавать не специалистам.
 |
Нажмите на картинку для увеличения.
В отличие от других ступеней конвейера, эти ступени работают не с треугольниками в качестве примитивов, а с патчами. Hull Shader берёт контрольные точки для патча на входе, после чего определяет некоторые параметры Tesselator, такие, например, как TessFactor, который показывает уровень качестве тесселяцции. Tesselator - блок с фиксированными функциями, поэтому программист не может влиять на то, как производится расчёт тесселяции. Блок отсылает полученные точки в Domain Shader, который может применять к ним операции. Позвольте привести пример, который поможет всё лучше понять. Возьмём пример, который поднимался с каждым поколением со времён Matrox Parhelia - карты смещения (Displacement Mapping).
 |
Нажмите на картинку для увеличения.
В качестве входа для вершинного шейдера у нас есть контрольные точки патча. Программист может изменять их, как ему хочется, поскольку их не так и много. Чтобы упростить, мы взяли очень грубую версию финальной сетки. Трансформированные точки затем передаются в Hull Shader, который определяет, сколько раз требуется делить каждую плоскость патча (например, как функцию размера патча в пикселях дисплея). Tesselator выполняет тесселяцию. То есть создаёт геометрию, которая пересылается в Domain Shader. Блок перемещает точки, созданные для соответствующего пространства (точки, выходящие из Tesselator, находятся в пространстве патча), создавая классические вершины, которые он может смещать как функцию текстуры, то есть производить Displacement Mapping.
Потенциал огромен. Благодаря тесселяции, можно обойтись без карты нормалей и реализовывать уровень детализации напрямую на GPU, позволяя использовать очень детализованные модели (несколько миллионов полигонов вместо 10 000 или около этого числа в современных играх) - по крайней мере, в теории. На практике тесселяция приводит к появлению некоторых проблем, которые не позволяют этой технике развернуться в полную силу. Смогут ли Direct3D 11 и совместимые карты обойти "подводные камни" и представить функциональную версию? Пока ещё слишком рано что-то утверждать, но, в любом случае, убедить удалось не всех, та же id Software работает над решением той же проблемы геометрии через полностью иной подход, основанный на ray casting с вокселями.
Вычислительные шейдеры
Как мы упоминали в нашей статье о CUDA , Microsoft не желает упустить из рук рынок GPGPU, поэтому компания создала собственный язык, чтобы GPU работал над другими задачами, а не только отрисовывал красивые картинки. Отгадайте что? Выбранная Microsoft модель, подобно OpenCL, очень напоминает CUDA, подтверждая перспективность взгляда nVidia. Преимущество над решением nVidia лежит в универсальности - вычислительные шейдеры (Compute Shader) будут работать на GPU nVidia и ATI, на будущем Intel Larrabee, а также обладать лучшей интеграцией с Direct3D, пусть даже у CUDA уже образовалась определённая поддержка. Но мы не будем уделять этой теме много времени, пусть она этого и достойна. Вместо этого мы планируем через несколько месяцев представить отдельную статью, рассказывающую о OpenCL и Compute Shaders.
Улучшенное сжатие текстур
Впервые появившись в DirectX 6 десять лет назад, функция сжатия текстур DXTC быстро распространилась на рынке GPU, её очень активно используют разработчики. Конечно, технология, разработанная S3 Graphics, была эффективная, а накладные аппаратные расходы были скромными, что, без сомнения, объясняет успех. Но теперь нужды изменились. DXTC не разрабатывалась для сжатия карт нормалей и не учитывала HDR-рендеринг. Поэтому цель Direct3D была двойная: разрешить сжатие HDR-текстур и ограничить "блочность" традиционных режимов DXTC. Для этого Microsoft добавила два новых режима: BC6 для HDR-текстур и BC7 для улучшения качества сжатия изображений LDR.
Нажмите на картинку для увеличения.
Shader Model 5
С представлением Shader Model 5, Microsoft старается переложить несколько принципов объектно-ориентированного программирования на язык шейдеров HLSL. В отличие от предыдущих версий, которые представляли новые возможности (динамическое ветвление/Dynamic Branching, поддержка целых чисел и т.д.), в данном случае цель кроется в облегчении работы программистов, решая распространённую проблему в современных игровых движках: рост числа шейдеров из-за большого числа перестановок. Возьмём конкретный пример: представьте, что движок работает с двумя типами материалов, пластиком и металлом, а также двумя типами освещения: световое пятно (spot) и рассеянный свет (omni). Чтобы предусмотреть все случаи, программисту нужно написать четыре шейдера:
| renderPlasticSpot () : // rendering plastic using spot light: |
| renderPlasticOmni () : // rendering plastic using omni light: |
| renderMetalSpot() : //rendering metal using spot light ... |
| renderMetalOmni() : //rendering metal using omni light: |
Пример очень простой, поскольку здесь всего два материала и два типа освещения, но на практике их может быть несколько десятков. Если продолжать таким же образом, то ситуация может быстро выйти из-под контроля. Мы получаем огромное количество дублированного кода, и если обнаруживается какая-либо ошибка, её нужно исправлять во всех шейдерах. Чтобы решить эту проблему, программисты используют так называемый uber-shader, который соединяет вместе все комбинации.
Light и Material - это интерфейсы, а код содержится в производных классах OmniLight и SpotLight, PlasticMaterial и MetalMaterial. Поэтому код полностью размещён в одном месте, правки вносить проще. В то же время и удобство чтения не страдает благодаря организации кода, напоминающей принцип виртуальных функций в объектно-ориентированных языках. Эта функция наверняка будет с одобрением встречена программистами, хотя геймерам она вряд ли что-либо даст.
Прочее
Как вы понимаете, мы только вкратце рассмотрели новые функции Direct3D 11, да и Microsoft ещё не опубликовала всех деталей. Среди тем, о которых мы не упомянули, есть увеличение максимального размера текстуры с 4K x 4K до 16K x 16K, а также возможность ограничивать число mip-карт, загруженных в VRAM. Есть также возможность изменения значения глубины пикселя, не отключая такие функции, как раннюю проверку Z, поддержка переменных с плавающей запятой двойной точности, разброс записи в память (scatter memory write) и т.д.
Заключение
Мы многого ждали от OpenGL 3, и, как вы можете судить по статье, мы были разочарованы: как самим API (из которого исчезли обещанные функции), так и его разработкой (годовая задержка и отсутствие информации со стороны группы Khronos). С новой версией OpenGL едва смог догнать Direct3D 10, в то же время Microsoft опубликовала первые детали об 11 версии своего API.
Ничего революционного от Microsoft ожидать не стоит, но, в отличие от OpenGL, Direct3D уже пережил полную перестройку своей архитектуры два года назад. Конечно, далеко не всё было гладко, но сегодня Microsoft может пожинать плоды усилий по перестройке своего API на новую мощную основу.
Вне всяких сомнений, Редмонд смотрит в будущее, а насчёт OpenGL создаётся впечатление, что Khronos довольствуется поддержкой текущего поколения GPU. Будем надеяться, что мы ошибаемся, и эволюция OpenGL 3 пойдёт намного быстрее, поскольку это единственное API, доступное для мультиплатформенной разработки. Но слишком большое число накладок поколебали нашу веру в развитие этого API.
Вы спросите: кто же они? Они - мёртвая компания, которую я считаю истинным убийцей OpenGL. Конечно, общая несостоятельность Комитета сделала OpenGL уязвимым, в то время как он должен был рвать D3D в клочья. Но по-моему, 3D Labs - возможно единственная причина текущего положения OpenGL на рынке. Что они для этого сделали?
Они разработали язык шейдеров для OpenGL.
3D Labs были умирающей компанией. Их дорогостоящие GPU были вытеснены с рынка рабочих станций всё возрастающим давлением nVidia. И в отличие от nVidia, 3D Labs не были представлены на потребительском рынке; победа nVidia означала бы смерть для 3D Labs.
Что в итоге и случилось.
В стремлении оказаться на плаву в мире, которому были не нужны их продукты, 3D Labs заявились на конференцию Game Developer Conference с презентацией того, что они назвали «OpenGL 2.0». Это был OpenGL API, переписанный с нуля. И это имело смысл, ибо в те времена в API OpenGL было полно хлама (который, впрочем, остаётся там и по сей день). Посмотрите хотя бы на то, насколько эзотерически сделаны загрузка и биндинг текстур.
Частью их предложения был язык шейдеров. Да, именно он. Тем не менее, в отличие от имеющихся кросс-платформенных расширений, их язык шейдеров был «высокоуровневым» (C - это высокий уровень для языка шейдеров).
В это же время в Microsoft работали над своим собственным языком шейдеров. Который они, включив всё своё коллективное воображение, назвали… Высокоуровневым Языком Шейдеров (HLSL). Но их подход к языку был фундаментально иным.
Наибольшей проблемой языка от 3D Labs было то, что он был встраиваемым. Microsoft полностью самостоятельно определяла свой язык. Они выпустили компилятор, который генерировал ассемблерный код для шейдеров SM 2.0 (или выше), который, в свою очередь, можно было скармливать D3D. Во времена D3D v9, HLSL никогда не касался D3D напрямую. Он был хорошей, но необязательной абстракцией. У разработчика всегда была возможность взять выхлоп компилятора и подправить его для максимальной производительности.
В языке от 3D Labs ничего этого не было. Вы отдаёте драйверу C-подобный язык, и он создаёт шейдер. На этом всё. Никакого ассемблерного шейдера, ничего, что можно скормить чему-то ещё. Только объект OpenGL, представляющий шейдер.
Для пользователей OpenGL это означало, что они становились подвержены капризам разработчиков OpenGL, которые только научились компилировать ассемблероподобные языки. В компиляторах новорождённого языка шейдеров OpenGL (GLSL) свирепствовали баги. Что ещё хуже, если вам удавалось заставить шейдер корректно компилироваться на различных платформах (что уже само по себе было большим достижением), то он всё ещё был подвержен оптимизаторам тех времён, которые были не так уж оптимальны, как могли бы быть.
Это было большим, но не единственным недостатком GLSL. Далеко не единственным.
В D3D, как и в старых ассемблерных языках OpenGL, можно было смешивать и всячески комбинировать вершинные и фрагментные шейдеры. Можно было использовать любой вершинный шейдер с любым совместимым фрагментным шейдером, если они взаимодействовали через одинаковый интерфейс. Более того, допускалась даже некоторая несовместимость: например, вершинный шейдер мог подать на выход значение, которое не использовалось фрагментным шейдером.
В GLSL ничего такого не было. Вершинный и фрагментный шейдер сплавлялись воедино, образовывая нечто, названное компанией 3D Labs «программным объектом». Поэтому, для совместного использования нескольких вершинных и фрагментных шейдеров в различных комбинациях, приходилось создавать несколько программных объектов. Это стало причиной второй по величине проблемы.
3D Labs думали, что они самые умные. Они взяли C/C++ за основу для модели компиляции GLSL. Это когда вы берёте один c-файл и и компилируете его в объектный файл, а затем берёте несколько объектных файлов и компонуете их в программу. Именно так компилируется GLSL: сначала вы компилируйте вершинный или фрагментный шейдер в шейдерный объект, затем помещаете эти объекты в программный объект и компонуете их воедино чтобы наконец сформировать программу.
В теории это позволяло появиться таким крутым вещам, как «библиотечные» шейдеры, которые содержат код, вызываемый основным шейдером. На практике это приводило к тому, что шейдеры компилировались дважды : один раз на стадии компиляции и второй раз на стадии компоновки. В частности, этим славился компилятор от nVidia. Он не генерировал какой-либо промежуточный объектный код; он компилировал вначале, выбрасывал полученный результат и компилировал заново на стадии компоновки.
Таким образом, чтобы приделать вершинный шейдер к двум разным фрагментным шейдерам, приходилось компилировать намного больше, чем в D3D. Особенно с учётом того, что вся компиляция производится оффлайново , а не перед непосредственным исполнением программы.
У GLSL были и другие проблемы. Возможно, было бы неправильным сваливать всю вину на 3D Labs, ибо в конечном итоге ARB утвердили и включили в OpenGL язык шейдеров (но ничего больше из предложений 3DLabs). Однако, изначальная идея всё равно была за 3D Labs.
И теперь самое печальное: 3D Labs были правы (в основном). GLSL не векторный язык, каким в то время был HLSL. Так случилось потому, что железо 3D Labs было скалярным (как современное железо от nVidia), и они были полностью правы в выборе направления, которому позднее последовали многие производители оборудования.
Они были правы и с выбором модели компиляции для «высокоуровневого» языка. Даже D3D в итоге к этому пришёл.
Проблема в том, что 3D Labs были правы в неправильное время . И в попытках попасть в будущее преждевременно, в попытках быть готовыми к будущему, они отставили в сторону настоящее. Это выглядит как T&L-функциональность в OpenGL, которая была в нём всегда. За исключением того, что T&L-конвейер OpenGL был полезным и до появления аппаратного T&L, а GLSL был обузой до того как остальной мир догнал его.
GLSL - это хороший язык сейчас . Но что было в то время? Он был ужасен. И OpenGL пострадал от этого.
На подходе к апофеозу
Я поддерживаю ту точку зрения, что 3D Labs нанесли OpenGL смертельный удар, но последний гвоздь в крышку гроба забил сам ARB.Возможно вы слышали эту историю. Во времена OpenGL 2.1, у OpenGL были большие проблемы. Он тащил за собой огромный груз совместимости. API больше не был простым в использовании. Одну вещь можно было сделать пятью разными способами и непонятно какой из них быстрее. Можно было «изучить» OpenGL по простым руководствам, но при этом вы не изучали тот OpenGL, который даёт настоящую графическую мощь и производительность.
ARB решили предпринять ещё одну попытку изобрести OpenGL. Это было как «OpenGL 2.0» от 3D Labs, но лучше, потому что за этой попыткой стоял ARB. Они назвали это «Longs Peak».
Что такого плохого в том, чтобы потратить немного времени на улучшение API? Плохо то, что Microsoft оказалась в довольно шатком положении. Это было время перехода на Vista.
В Vista Microsoft решили внести давно напрашивающиеся изменения в графические драйверы. Они заставили драйверы обращаться к ОС за виртуализацией графической памяти и многим другим.
Можно долго спорить о достоинствах такого подхода, и о том, был ли он вообще возможен, но факт остаётся фактом: Microsoft сделала D3D 10 только для ОС Vista и выше. Даже на поддерживающем D3D железе было невозможно запустить D3D приложение без Висты.
Вы возможно помните, что Виста… скажем так, работала не очень хорошо. Итак, у нас была неторопливая ОС, новый API, который работал только на этой ОС, и новое поколение железа, которое нуждалось в этом API и ОС чтобы делать нечто большее, чем просто превосходить предыдущее поколение в производительности.
Тем не менее, разработчики могли использовать функциональность уровня D3D 10 через OpenGL. То есть могли бы, если бы ARB не был занят работой над Long Peaks.
ARB потратили добрые полтора-два года, работая над улучшением API. Ко времени выхода OpenGL 3.0 переход на Висту закончился, Windows 7 была на подходе, и разработчиков игр больше не заботила функциональность уровня D3D 10. В конце концов, оборудование для D3D 10 прекрасно работало с приложениями на D3D 9. С увеличением темпов портирования с ПК на консоли (или с переходом ПК-разработчиков на консольный рынок), разработчикам всё меньше была нужна функциональность D3D 10.
Если бы разработчики получили доступ к этой функциональности даже на Windows XP, развитие OpenGL могло бы получить живительный заряд бодрости. Но ARB упустили эту возможность. А хотите знать что самое ужасное?
ARB не смогли изобрести API с нуля несмотря на трату двух драгоценных лет на попытки сделать это. Поэтому они вернули статус-кво, добавив лишь механизм для объявления функциональности устаревшей.
В итоге ARB не только упустили ключевые возможности, но и не выполнили ту работу, которая привела их к этому упущению. Это был epic fail по всем направлениям.
Такова история о противостоянии OpenGL и Direct3D. История упущенных возможностей, величайшей глупости, умышленного безрассудства и банальных нелепостей.
Очень часто встречаются различные заблуждения по поводу этих двух API .
Я попытался изложить в этой статье основные факты, которые следует знать как разработчикам, так и конечным пользователям.
Так как тема очень холиварная, я старался придерживаться максимально нейтрального тона.
Взгляд с высоты птичьего полёта
Оба API предоставляют доступ к функциям аппаратного ускорения 3D-графики.Распространённые заблуждения
OpenGL отстаёт от Direct3D, и вообще, судя по таким вялым изменениям в спецификации, наверное уже совсем мёртв.Собственно, причина такого заблуждения - это незнание о расширениях. Вообще говоря, OpenGL может и часто опережает (!) Direct3D в плане инноваций, т.к. производитель может добавить расширение к OpenGL, не дожидаясь никого, в то время как в Direct3D изменения может внести только Microsoft.
OpenGL - это для программ профессиональной графики, а Direct3D - это для игр.
Это заблуждение имеет историческую причину. OpenGL исходно разрабатывался как библиотека 3D графики, которая МОЖЕТ, но НЕ ОБЯЗАНА ускоряться аппаратно. Это также объясняет наличие некоторых функций, например рендеринг стерео-изображений, которые не нужны играм. Direct3D же разрабатывался гораздо позже, сразу с расчётом на ускорение на GPU. В момент появления многих пакетов профессиональной работы с графикой Direct3D просто не было.
Microsoft поставляет вместе с Windows драйверы без поддержки OpenGL. OpenGL будет рендерить без ускорения, или эмулироваться через DirectX. Так что, если нужна поддержка OpenGL под Windows, нужно ставить драйвер с сайта производителя. Причины для такого неприятия OpenGL, скорее всего, опять чисто политические.
Так что же делать, как жить?
Примечание: А вот эта часть носит весьма субъективный характер.Если Вы - разработчик, и решаете, какое API использовать, то задумайтесь над следующим:
За OpenGL - массовая кроссплатформенность, в частности, доступность всех новых функций и на Windows XP, где Direct3D 10/11 нет, и никогда не будет.
Против OpenGL - драйвера в Windows из коробки не имеют поддержки OpenGL, так что ставить их нужно с сайта производителя.
Если Вы - новичок в разработке 3D-приложений, и желаете освоить эту область, то я бы рекомендовал сделать так: сначала разобраться с Direct3D (причина тому проста - Microsoft предоставляет очень качественный SDK), а затем разобраться с OpenGL (это будет очень просто после Direct3D). К сожалению, такой вещи, как SDK, для OpenGL нет. Поэтому осваивать с нуля будет сложнее.
Вот вроде и всё. Успехов в разработке!
Эх, было бы все так просто с OpenGL. Сейчас так или иначе cуществуют используются 6 малосовместимых стандартов (2.1,3.3,4.х, ES 1.0, ES 2.0, ES 3.0), у которых отличаются языки шейдеров, частично (а иногда почти полностью) разные API. Хуже того, нет референсной реализации и очень мало контроля качества. В итоге на большей части PC рынка (Intel и AMD) OpenGL реализован криво, а на мобильниках, помимо часто кривых драйверов (для Adreno (ex-ATI, че тут хотеть), очень сильно различаются подходы к оптимизации
DiDi
Михаил вы немного не правы. Выбирать DirectX нужно только в одном единственном случае. Если вы хотите ограничить свою аудиторию не только платформой виндоус но и одной версией винды и точным совпадением по производителям и сериям копмлеткующих компа с использованым для разработки. И хотя никто не будет спорить что написанное с использванием директа будет работать и на других комплектующих и даже некоторых версиях винды, всё же при любом несовпадении картинка будет отличаться в худшую сторону так же как и производительность. Во всех остальных случаях если разработчик хочет донести своё творение в том виде как он это делал нужно просто обязательно выбирать OpenGL.
crsib
DiDi, вот странные вещи ты говоришь. Во-первых, D3D9 есть везде начиная с XP, и, сюрприз-сюрприз, на XBox и некоторых Windows Mobile телефонах. D3D11 есть на всех PC c Vista+, WinRT, WP8. Видимо будет в следующем поколении XBox.
OpenGL на PC работает экстремально плохо. Шансов, что все будет работать на AMD мало. Про Intel я вообще промолчу. У пользователя, особенно на хрюшке может не стоять драйверов, что обеспечит ему клевый софтварный рендер и поддержку аж API 1.1. При этом есть отличный шанс на то, что D3D игра будет работать великолепно.
DiDi
crsib , надеюсь у вас есть свои игровые проекты.. мне достаточно того что я насмотрелся сколько кода пишут что бы картинка просто была везде где есть этот D3D9, я не буду спорить что большая часть программистов использующих DirectX не ленивые люди в отличие от предпочитающих OpenGL но это не дает добавляет достоинства самому DirectX. В конце концов лично для меня мерилом явлются затраты разработчиков а в случае с директом они несоизмеримо больше с куда меньшим полезным выхлопом в итоге.
crsib
У меня-то как раз есть. Причем на OpenGL ES. Про трудозатраты вообще не понял шутки. Следить за состоянием конвеера на OpenGL та еще пытка, потому что значительная часть его инкапсулирована почему-то в графические "примитивы". Держать код перносимым это вообще жесть. У ES 1 вообще нет требований к форматам аппаратного сжатия текстур, у ES 2.0 есть убогий ETC. В итоге на тот же андроид приходится собирать пачку билдов с текстурами в разных форматах. Я уже не говорю про то, что у PowerVR и Mali и у Adreno местами прямо противолопожные подходы к оптимизации на уровне OpenGL (при его подходе к абстракции "железа"). Про PC я даже говорить не хочу. Из-за того, что приходится работать OpenGL в моих компьтерах всегда будет ускоритель от nVidia. У меня тупо нет выбора. Я могу почти гарантировать, что написаный в соответсвие со стандартом код на Intel GMA/HD работать тупо не будет, даже если я 10 драйверов поставлю. Ну или будет работать так, что лучше бы честно не заработал. Почти таже история с ATI/AMD, ситуация лишь не многим лучше.
В общем твои коментарии звучат в духе начинающего разработчика, который еще просто не успел пройти все круги ада продакшен разработки на OpenGL
