Софт

Directx 3

Рейтинг: 4.0/5.0 (608 проголосовавших)

Описание

Загрузить драйверы Direct3D

Загрузки драйверов Direct3D

Доступные для загрузки с использованием DriverDoc:

На данной странице содержится информация об установке последних загрузок драйверов Direct3D с использованием средства обновления драйверов Direct3D .

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

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

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

Directx 3:

  • скачать
  • скачать
  • Другие статьи, обзоры программ, новости

    Компьютерра: OpenGL vs

    OpenGL vs. Direct3D

    OpenGL и Direct3D - две основные на сегодняшний день аппаратно-ускоряемые библиотеки для создания компьютерной трехмерной графики. Перед каждым начинающим 3D-программистом встает вопрос: что выбрать?

    OpenGL и Direct3D - две основные на сегодняшний день аппаратно-ускоряемые библиотеки для создания компьютерной трехмерной графики. Перед каждым начинающим 3D-программистом встает вопрос: какой из двух вариантов API выбрать? Вопрос этот совсем не прост, собственного опыта для принятия осознанного решения, как правило, не хватает. И хотя на форумах такие темы обсуждаются регулярно, почерпнуть из них информацию порой непросто, поскольку "советы бывалых" обычно основываются на личных предпочтениях.

    Итак, что же выбрать начинающему "тридешнику"? Ответ зависит от трех факторов: от поставленной задачи, от умений программиста и от того, чем он намерен заниматься в дальнейшем. С первым фактором все более или менее просто: начинающий 3D-программист может быть или совсем зеленым новичком, или обладать каким-то опытом в других областях. Второй фактор более расплывчат и во многом зависит от первого, ведь только-только ступая на стезю программирования, очень трудно четко поставить задачу, обычно хочется написать что-то такое, чтоб было красиво и все двигалось и блестело; из этого мы и будем исходить, советуя ту или иную библиотеку. В случае же с опытным программистом дела обстоят иначе; тут может потребоваться или визуализация результатов какой-то вычислительной программы, или внезапно появился выгодный заказ, да вот беда, с необходимостью 3D-графики. Ну а третий фактор очень грубо можно разделить на два направления: первое - разработка игр и все что с этим связано; второе - написание приложений для работы с 3D-графикой и визуализация научных данных (скромно назовем все это научной графикой). Третий фактор тоже тесно связан с первым: практически все "молодые и перспективные" хотят писать игры, ну так уж повелось; и в общем-то они правы - игровая отрасль не только интересная и быстро развивающаяся, но и гораздо лучше представлена на территории нашей страны. В самом деле, все слышали об отечественных играх и компаниях их разрабатывающих, но мало что известно об успехах россиян на поприще научной графики.

    Теперь подробнее остановимся на истории каждой из технологий. Начнем с Direct3D. В те давние времена, когда Windows только входила в нашу жизнь, абсолютное большинство игр писалось еще под DOS, а Windows 3.1 не предоставляла эффективных средств доступа к видео- и звуковым устройством. Такое положение дел не устраивало Microsoft, и корпорация вознамерилась сделать 3D API, который стал бы удобным инструментом в руках разработчиков игр. То ли из-за нехватки времени и ресурсов, то ли по другим причинам Microsoft решила не изобретать велосипед, а использовать наработки компании RenderMorphics. Это был совсем маленький проект, на его базе была создана небольшая библиотека Game SDK, которая и стала впоследствии именоваться DirectX 1.0. И как это ни прискорбно для Microsoft, первому DirectX не суждено было стать распространенным средством разработки игр. Причин тому было множество, и если с плохой структурой и сложностью использования еще можно было мириться, то многочисленные ошибки и неповоротливость написанных игр ставили крест на широком распространении этой технологии. Но не в правилах Microsoft сдаваться, и она немедленно принялась совершенствовать свое неудачное детище. Первой по-настоящему принятой программистским сообществом версией DirectX стала 7.0. Этот продукт был лишен большинства из "детских болезней" своих предшественников: научился почти полностью использовать потенциал видеокарт, его интерфейс стал гораздо приятнее, и, главное, DirectX 7.0 был стабилен (сейчас существует DirectX 9.0 - мощное и удобное средство разработки). Вы, наверное, обратили внимание, что я периодически называю вроде бы одно и то же по-разному - то DirectX, то Direct3D. На самом деле все просто: Direct3D - это часть DirectX. До седьмой версии в DirectX было два графических инструмента: Direct3D и DirectDraw, для трех- и двухмерной графики соответственно. DirectX содержит и другие полезные компоненты - например, DirectSound и DirectPlay. Первый используется для воспроизведения звуков, а второй облегчает жизнь разработчику игр: он берет на себя работу с вводом и даже включает сетевые интерфейсы.

    История OpenGL ведется с 1992 года. Компания Silicon Graphics создала его как открытый стандарт. Отсюда и первая часть названия, а GL означает Graphic Library (графическая библиотека). На данный момент OpenGL находится под контролем комитета Architectural Review Board (ARB), куда входят представители наиболее влиятельных в 3D-секторе корпораций - nVidia, ATI, SGI, Apple, Intel, id Software и, что особенно интересно, Microsoft. ARB является по сути некой бюрократической машиной, чья задача - вводить в стандарт OpenGL новые возможности. Для этого был создан механизм расширений. Как и любая бюрократическая машина, ARB работает медленно и неповоротливо, что стало главной проблемой OpenGL, который просто не может угнаться за стремительным развитием графических технологий. Достаточно сказать, что между выходом версий 1.0 и 1.4 прошло больше десяти лет! Сейчас этот стандарт морально устарел. Хотя все новые возможности современных видеоускорителей доступны через расширения ARB, пользоваться ими, прямо скажем, неудобно.

    OpenGL, создававшийся для профессионального сектора, прочно в нем закрепился во многом благодаря своей переносимости, а вот нишу PC-игр практически полностью уступил своему конкуренту. Изменится ли эта ситуация? Чтобы существенно потеснить DirectX в game-секторе, ARB необходимо вывести OpenGL на современный уровень, и, надо сказать, комитет не сидит сложа руки: грядет так долго ожидаемая вторая версия GL, ее создатели хотят снова создать стандарт на десятилетие вперед. А что же Microsoft? Попытается ли компания захватить и профессиональный сектор? Это возможно только с выходом DirectX под другие операционные системы, что вряд ли случится.

    Перейдем к сравнению технологий. DirectX построен по объектно-ориентированной схеме, а OpenGL по процедурной. Что лучше? Программа на GL одинаково "хорошо" выглядит и на C++, и на чистом C, чего не скажешь о DX (хотя это надуманное преимущество, сейчас мало кто пишет на C, особенно под Windows). А вот простота архитектуры GL - неоспоримый плюс: GL работает исключительно с примитивами (треугольники, отрезки и точки) и управляется набором булевых переменных, которые позволяют включать или отключать некоторые функции - например, накладывать текстуру или нет, использовать ли освещение и т. д. Код для отображения "вашего первого треугольника" занимает примерно пятьдесят строк. В DX эта цифра куда больше. С одним-то треугольником у GL все хорошо, но как только захочется использовать что-нибудь из современных 3D-эффектов - появляются расширения GL, и еще недавно простой и понятный код тонет в непонятных и ничего не значащих для человека, не посвященного в тайны 3D-графики, строках.

    Как ни странно, ведутся споры о производительности. Проверить это проще простого, но зачем? - ведь результат легко предсказуем. Он будет одинаков для обеих библиотек, поскольку сейчас практически все функции реализуются напрямую через аппаратные ускорители. Расхождение результатов может быть только из-за погрешности измерений; сюда я отношу и оптимизацию тестирующего кода, и специфику конкретных драйверов, но в целом для выполнения кода на GL и DX видеокарта должна выполнять одни и те же действия, а значит, и дискуссии о быстродействии беспочвенны. Конечно, можно копать глубже и спорить о качестве шейдерных компиляторов HLSL[High-level Shader Language - С-подобный язык для написания шейдеров в DirectX 9.0] и GLSL[OpenGL Shading Language - аналог HLSL для OpenGL], но мы не будем лезть в такие дебри, тем более что оба решения далеки от совершенства.

    Что мы имеем: львиная доля создателей игр выбирает DirectX за удобную поддержку современных возможностей, остальные предпочитают OpenGL - за переносимость и простоту написания программ. Ситуация в общем-то нормальная, если вспомнить, для чего создавалась каждая из технологий. Но если мы обратим внимание, что Doom III, самая нашумевшая игра последнего времени, написана на OpenGL, то поневоле закрадывается подозрение, что не все так просто. Может быть, в id Software знают какой-то секрет, делающий применение OpenGL предпочтительнее? Нет, просто команда разработчиков уже привыкла работать на нем. Это еще раз красноречиво говорит о том, что GL мало чем уступает DirectX.

    Я много говорил о возможностях современного железа, но ни разу не упомянул о том, что же это за возможности и что для их использования предоставляют OpenGL и DirectX. Прежде всего, нынешние видеокарты - это программируемые устройства. Теперь некоторый код можно выполнять прямо на графическом процессоре (GPU). Эти программы называют шейдерами. Они позволяют создавать сложнейшие эффекты в реальном времени. Изначально эти программы можно было писать только на "фирменных" языках производителей видеокарт - ATI и nVidia. Оба языка очень похожи на ассемблер, но, увы, несовместимы. А кому захочется писать два разных кода для реализации одного и того же эффекта? И вот в DirectX 8.0 появляется универсальный язык программирования шейдеров. Он тоже похож на ассемблер, но позволяет обойтись одним шейдером для обоих типов видеокарт. И снова закавыка: много ли людей любят программировать на языках низкого уровня? И вот Microsoft представляет в своем DX 9.0 уже C-подобный язык HLSL. ARB в ответ выкатил аналогичную технологию GLSL. Как уже говорилось, обе эти технологии далеки от совершенства, прежде всего из-за слабой оптимизации компиляторов. Например, создатели игры Chronicles of Riddick (кстати, использовавшие OpenGL) для увеличения производительности написали все шейдеры в двух вариантах, на родных ассемблероподобных языках от ATI и nVidia. Это выглядит странным, так как обычные компиляторы показывают совсем неплохие результаты.

    Итак, у нас две библиотеки с практически одинаковыми возможностями и быстродействием. Отличия лишь в сложности написания кода. И даже здесь явного лидерства нет. Все зависит от уровня используемых в программе эффектов. Если нам достаточно базовой функциональности OpenGL (то есть мы не используем расширений), то разумнее использовать именно GL, а если дело дошло до продвинутых эффектов, тут предпочтительнее Direct3D. Но с появлением второго GL ситуация может в корне измениться, так как переход на новую версию избавит GL от большинства недостатков. Но Microsoft тоже не будет стоять на месте, и вполне возможно, что к моменту своего выхода OGL 2.0 уже устареет. Да и в дальнейшем для успешной конкуренции с DX ARB понадобится существенно переработать механизм внесения изменений в библиотеку, чтобы сделать OpenGL более динамично развивающимся.

    Так что же выбрать начинающему 3D-программисту? Молодому поколению я, скрепя сердце, посоветую DirectX. Прежде всего потому, что знание DX поможет стать создателем игр. Все российские компании, разрабатывающие игры, используют эту технологию. А вот совет программистам с опытом не так однозначен. Чтобы ваша программа работала не только на Windows, но и на других операционных системах, следует выбрать GL. Далее следует решить, какие эффекты вам необходимы: можете ли вы обойтись стандартной функциональностью GL, или вам непременно нужно использовать более "продвинутые" эффекты. И, наконец, на сцену выходят личные предпочтения: одним придется по вкусу объектная структура DirectX, другим же она покажется слишком громоздкой. И, конечно, не стоит забывать старый анекдот: "Какой дистрибутив Linux ставить? Тот, который стоит у ближайшего гуру".

    Простейшая программа на OpenGL и на Direct3D

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

    Для начала очистим фон. В OpenGL для этого потребуется написать следующую строку:

    glClear(GL_COLOR_BUFFER_BIT);

    где glClear() - функция, предназначенная для очистки буферов, а константа GL_COLOR_BUFFER_BIT указывает, что именно нужно очистить.

    Для аналогичной операции в D3D нужно написать

    d3d_Device->Clear (0, 0, D3DCLEAR_TARGET, D3DCOLOR_XRGB (0, 0, 0), 0, 0);

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

    Вот рабочее пространство и готово, можно приступать к рисованию. В OGL все примитивы для обрисовки должны находиться между вызовами glBegin() и glEnd(), некоторым их аналогом в D3D являются d3d_Device->BeginScene () и d3d_Device->EndScene (). В случае с OGL уже можно привести фрагмент кода, выполняющий нашу задачу:

    glBegin(GL_TRIANGLES);

    glColor3d(1,0,0);

    glVertex3d(1,2,3);

    glColor3d(0,1,0);

    glVertex3d(4,5,6);

    LPDIRECT3DVERTEXBUFFER8 p_VertexBuffer = NULL;

    Эта структура содержит и координаты вершин, и их цвета. p_VertexBuffer - указатель на нашу структуру, для хранения вершин.

    Теперь напишем следующее:

    d3d_Device->CreateVertexBuffer (3*sizeof(CUSTOMVERTEX),

    0, D3DFVF_XYZRHW | D3DFVF_DIFFUSE, D3DPOOL_DEFAULT, &p_VertexBuffer);

    VOID* pVertices;

    p_VertexBuffer->Lock (0, sizeof(g_Vertices), (BYTE**)&pVertices, 0);

    memcpy (pVertices, g_Vertices, sizeof(g_Vertices));

    p_VertexBuffer->Unlock();

    CreateVertexBuffer - выделяет место на устройстве под три вершины (3*sizeof(CUSTOMVERTEX),) и присваивает его нашему указателю (p_VertexBuffer). Далее «запираем» (Lock()) буфер вершин, чтобы случайно его не повредить. Копируем весь наш буфер (memcpy()) в буфер видеокарты. И снова разрешаем доступ (Unlock();).

    И наконец, мы готовы к рисованию:

    d3d_Device->BeginScene ();

    SetVertexShader() определяет тип вершин. SetStreamSource() задает поток для дальнейшей работы. Здесь 0 - номер потока, второй параметр - данные, которые присваиваются к этому потоку, и третий параметр - размер, занимаемый в памяти одной вершиной. DrawPrimitive - рисует примитивы на экране, принимает на вход (в порядке следования) тип примитивов для отрисовки, индекс первой вершины, с которой нужно начать рисование, и количество примитивов в последовательности.

    Direct3D 10: преимущества нового стандарта

    Direct3D 10: преимущества нового стандарта Встречаем DirectX 10

    Многие люди в свободное время играют в компьютерные игры. И получают немало удовольствия. Частично в этом "повинен" и DirectX 9. Действительно, мы играем в игры, разработанные под интерфейс прикладного программирования (API) DirectX 9 ещё в декабре 2002 года. Почти четыре года назад. И хотя многие подразумевают под словом "DirectX" только графику, в стандарт DirectX на самом деле входят разные API, отвечающие за различные игровые аспекты, из которых графика - только один. Популярные игры, такие, как Half-Life 2, F.E.A.R. Battlefield 2 и Oblivion, используют самую последнюю версию DirectX, а именно 9.0c.

    В оставшейся части статьи мы поговорим о том API, который интересует большинство людей: Direct3D. И здесь с появлением DirectX 10 нас ждёт немало перемен. В Direct3D 10 появятся новые функции, призванные решить существующие графические проблемы, а также инструменты, позволяющие заняться новыми задачами рендеринга. Кроме того, 3D-конвейер будет упрощён, что тоже должно способствовать появлению лучших и более эффектных игр.

    Что изменилось?

    В октябре, после пленарного доклада по поводу DX10 на мероприятии nVidia, мы смогли поговорить с Дэвидом Блюфом (David Blythe), software-архитектором Microsoft Graphics Platform Unit по DirectX 10. Он прочитал доклад о важных улучшениях, сделанных в Direct3D 10. Разработчики ПО и производители "железа" уже давно накопили немалый багаж проблем, и, по словам Блюфа, Direct3D 10 решает большинство проблем и жалоб.

    Direct3D 10 отличается пятью ключевыми изменениями:
    1. улучшенные возможности программирования (Shader Model 4.0 и геометрические шейдеры);
    2. строгие аппаратные спецификации;
    3. улучшенная производительность (снижение числа обрабатываемых команд на кадр);
    4. унифицированные наборы инструкций (HLSL 10);
    5. потоковый ввод/вывод (геометрический шейдер может записывать в память).

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

    Слайд презентации "The Direct3D 10 System" от David Blythe .

    С появлением линейки ATi Radeon X1000 концепция традиционного конвейера ушла в историю. Теперь говорить о том, что карта обладает каким-то числом пиксельных конвейеров совершенно бессмысленно. Просто выкиньте слово "пиксельные конвейеры" из головы, если только вы не рассматриваете устаревшие карты.

    Глава 1 - Устройство Direct3D

    Устройство Direct3D

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

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

    Что же значат все эти параметры, и как их использовать? Ну что же, первый аргумент, adapter. указываает какое физическое устройство будет представлять данный экземпляр класса. У каждого устройства в вашем компьютере есть уникальный идентификатор (обычно они находятся в диапазоне от 0 до числа, на единицу меньшего, чем количество имеющихся устройств). Значение 0 соответствует устройству, которое используется по умолчанию.

    ПЕРЕГРУЖЕННЫЕ КОНСТРУКТОРЫ УСТРОЙСТВ

    Второй перегруженный конструктор устройства идентичен первому за исключением параметра renderWindow. который получает значение типа IntPtr для неуправляемого (не относящегося к Windows Forms) окна. Последний перегруженный конструктор получает единственное значение типа IntPtr. являющееся неуправляемым COM-указателем на интерфейс IDirect3DDevice9. Они могут использоваться, если вам необходимо работать с неуправляемыми приложениями из вашего управляемого кода.

    Следующий аргумент, DeviceType. сообщает Direct3D какой тип устройства вы хотите создать. Обычно здесь указывается значение DeviceType.Hardware. обозначающее, что вы хотите использовать аппаратное устройство. Другое значение, DeviceType.Reference. позволяет вам использовать вспомогательный растеризатор, который программно эмулирует все возможности Direct3D, но работает исключительно медленно. Этот вариант используется главным образом для оладки, или для проверки тех возможностей приложения, которые не поддерживает установленная видеокарта.

    ПРОГРАММНАЯ ЭМУЛЯЦИЯ УСТРОЙСТВ

    Обратите внимание, что вспомогательный растеризатор поставляется только с DirectX SDK, а библиотеки времени выполнения DirectX не предоставляют этой возможности. Последнее значение, DeviceType.Software. означает, что вы используете собственный программный растеризатор. Если вы не знаете о том, есть ли у вас программный растеризатор, игнорируйте этот вариант.

    Аргумент renderWindow привязывает окно к данному устройству. Поскольку классы элементов управления Windows Forms содержат дескриптор окна, достаточно просто использовать наследуемый класс в качестве нашего окна визуализации. В этом параметре вы можете указать форму, панель или любой другой класс, наследуемый от элемента управления. Сейчас мы будем использовать формы.

    Следующий параметр, behaviorFlags. используется для управления поведением устройства после его создания. Большинство членов перечисления CreateFlags можно комбинировать, что позволяет сразу задавать несколько вариантов поведения. Некоторые флаги являются взаимоисключающими, однако об этом я расскажу позже. Сейчас мы будем использовать только флаг SoftwareVertexProcessing. Он указывает, что вся обработка вершин должна выполняться центральным процессором. Хотя это значительно медленнее, чем обработка вершин видеокартой, мы сейчас не можем гарантировать, что ваша видеокарта поддерживает эту возможность. Безопаснее будет пока возложить задачу обработки на центральный процессор.

    Последний параметр конструктора, presentationParameters. управляет тем, как устройство отображает данные на экране. Через этот класс можно управлять любыми параметрами отображения устройства. Позже мы более подробно поговорим об этой структуре, а сейчас уделим винмание только членам Windowed и SwapEffect .

    Член Windowed является логической переменной, определяющей работает ли устройство в полноэкранном режиме (false ) или в оконном режиме (true ).

    Член SwapEffect используется для управления поведением механизма переключения буферов. Если вы выберете SwapEffect.Flip. во время выполнения будет создан дополнительный вторичный буфер, который во время показа будет меняться местами с первичным буфером. SwapEffect.Copy похож на Flip. но требует, чтобы вы установили количество вторичных буферов равным 1. Сейчас мы выберем вариант SwapEffect.Discard. который после показа просто делает недействительным содержимое вторичного буфера.

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

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

    Как видите, мы создаем аргумент с параметрами показа, устанавливаем упомянутые выше члены (Windowed и SwapEffect ), а затем создаем устройство. В качестве идентификатора адаптера мы указываем 0, что означает используемый по умолчанию адаптер. Мы создаем аппаратное устройство, а не вспомогательный или программный растеризатор. Обратите внимание на использование ключевого слова this в качестве окна визуализации. Поскольку наше приложение и, в частности, данный класс, является формой Windows, мы просто используем ее. Кроме того, как упоминалось ранее, мы возлагаем обработку вершин на центральный процессор. Все замечательно, но сейчас этот код никогда не вызывается, так что давайте изменим функцию Main нашего класса, чтобы она обращалась к этому методу. Внесите в созданный по умолчанию статический метод Main следующие изменения:

    В функции мы сделали несколько изменений. Во-первых, мы добавили инструкцию using к оператору создания формы. Это гарантирует, что наша форма будет доступна, когда приложение покинет область видимости данного блока. Затем мы добавили команду Show для формы. Сделав это мы гарантируем, что окно будет действительно загружено и отображено (и, следовательно, будет создан дескриптор окна) до того, как мы попытаемся создать устройство. Потом мы вызываем нашу функцию, выполняющую создание устройства, и используем стандартный метод Run для запуска приложения. Скомпилируйте приложение и запустите его. Поздравляю, вы только что успешно создали свое первое Direct3D-приложение.

    Ладно, следует признать, что приложение исключительно скучное. Оно создает устройство, но ничего не делает с ним, так что посмотрев на запущенное приложение вы не заметите никаких отличий от созданного в самом начале «пустого» проекта C#. Давайте изменим это, и что-нибудь визуализируем на экране.

    У классов форм есть встроенная возможность определить момент, когда им надо перерисовать себя: использование переопределенного метода OnPaint (или перехват события Paint ). Данное событие происходит каждый раз, когда окно необходимо перерисовать. Похоже, это прекрасное место для размещения нашего кода визуализации. Мы сейчас не будем делать что-либо поражающее воображение, а просто очистим окно, залив его заданным цветом. Добавьте к определению вашего класса следующий код:

    Для сплошной заливки окна заданным цветом мы используем метод устройства Clear. Сейчас мы используем один из предопределенных цветов с именем CornflowerBlue (васильковый). Первый параметр метода указывает, что именно мы хотим очистить; в данном примере мы очищаем целевое окно. С другими членами перечисления ClearFlags мы познакомимся позже. Второй параметр — это используемый для очистки цвет, а оставшиеся два параметра пока для нас не важны. После того, как устройство очищено, нам необходимо обновить изображение на экране монитора. Это делает метод Present. Существует несколько перегруженных версий этого метода; показанная здесь обновляет всю область устройства. Остальные перегрузки мы обсудим позже.

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

    Основной объект, рисуемый в трехмерной графике, это треугольник. Достаточное количество треугольников позволяет представить все, что угодно, в том числе и плавные кривые поверхности. Так что вполне естественно, что нашим первым рисунком должен быть отдельный треугольник. Чтобы упростить процесс рисования этого треугольника, мы не будем беспокоиться о таких вещах, как «мировое пространство» или «преобразования» (с этими темами вы вскоре познакомитесь), а нарисуем треугольник, используя экранные координаты. Итак, чтобы нарисовать наш замечательный треугольник, необходимы две вещи. Во-первых, нам нужна какая-нибудь структура данных, где будет храниться информация о треугольнике. Во-вторых, надо сообщить устройству, о том, что надо нарисовать треугольник.

    К счастью, в DirectX для управляемого кода уже есть конструкция для хранения данных треугольников. Это класс CustomVertex в пространстве имен Direct3D. приютивший многие общеупотребительные конструкции формата вершин. используемые в Direct3D. Структура формата вершин хранит данные в формате, который Direct3D понимает и может использовать. Позже мы более подробно обсудим эти структуры, а сейчас для нашего треугольника выберем структуру TransformedColored. Она сообщает Direct3D, что наш треугольник не надо преобразовывать (то есть вращать или перемещать), поскольку мы указываем его местоположение в экранных координатах. Также для каждой точки (вершины) треугольника включена цветовая компонента. Вернемся к нашему переопределенному методу OnPaint. и добавим следующий код после вызова очистки устройства:

    Каждый член созданного массива представляет одну точку нашего треугольника, так что необходимо три элемента. Затем для каждого члена массива мы присваиваем свойству Position структуру Vector4. Местоположение преобразованной вершины включает координаты X и Y в пространстве экрана (относительно начала координат окна), а также координату Z и значение rhw (обратное или однородное w ). Последние два члена в данном примере игнорируются. Структура Vector4 очень удобна для хранения подобной информации. Затем мы устанавливаем цвета каждой из вершин. Обратите внимание, что при использовании стандартных цветов необходимо вызывать метод ToArgb. Direct3D ожидает, что цвета будут представлены в виде 32-разрядных целых чисел, и данный метод преобразует имеющийся цвет в этот формат.

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

    Теперь у нас есть данные и надо сообщить Direct3D о том, что мы хотим нарисовать наш треугольник, и как надо его рисовать. Это делается путем добавления к перегруженному методу OnPaint следующего кода:

    Что, черт возьми, все это значит? Не волнуйтесь, все относительно просто. Метод BeginScene позволяет Direct3D узнать, что мы собираемся что-то рисовать, и подготовиться к этому. Теперь, когда мы сказали Direct3D, что собираемся что-то нарисовать, нам надо сообщить что именно мы будем рисовать. Для этого предназначено свойство VertexFormat. Оно сообщает Direct3D, какой формат фиксированного конвейера функций мы хотим использовать. В нашем случае мы используем конвейер для преобразованных и окрашенных вершин. Не беспокойтесь, если вам пока непонятны слова «фиксированный конвейер функций», мы поговорим об этом позже.

    В функции DrawUserPrimitives происходит собственно рисование. Так что означают ее параметры? Первый параметр — это тип примитивов, которые мы планируем рисовать. Доступно несколько различных типов, но сейчас мы хотим просто нарисовать список треугольников, так что выберем тип TriangleList. Второй параметр — это сколько треугольников мы собираемся рисовать; для списка треугольников это число всегда должно быть равно количеству вершин в массиве, деленому на три. Поскольку мы рисуем один треугольник, естественно, здесь укажем 1. Последний параметр функции — это данные, которые Direct3D будет использовать для рисования треугольника. Мы уже создали массив данных, так что осталось указать его здесь. Последний метод, EndScene. просто сообщает Direct3D, что мы не будем больше рисовать. После каждого вызова BeginScene вы должны вызывать EndScene .

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

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

    Ох, кажется мы сломали наше приложение! Его запуск показывает нам черный экран, на котором иногда мелькает наш треугольник. При изменении размеров окна этот эффект проявляется более отчетливо. Это плохо, но что произошло? Дело в том, что Windows пытается быть умной и перерисовывает текущую форму (она у нас пустая), после того, как окно объявлено недействительным. Это перекрашивание проходит мимо нашего переопределенного метода OnPaint. Исправить ситуацию довольно просто, изменив стиль создаваемого окна. В конструкторе вашей формы замените скекцию TODO на следующую строку:

    Теперь при запуске приложения все работает как ожидалось. Мы сообщили окну, что вся перерисовка должна происходить внутри переопределенного метода OnPaint (WmPaint является обычным сообщением Win32) и наше окно непрозрачно. Это означает, что не будет никакого рисования вне окна, и все происходящее зависит от нас. Также можно отметить, что если вы измените размеры окна так, что у него не будет видимой клиентской области, то будет сгенерировано исключение. Если это действительно беспокоит вас, можете изменить параметр, определяющий минимальные размеры формы.

    DirectX API: Инициализация Direct3D

    DirectX API: Инициализация Direct3D

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

    Здесь представлена полная версия программы, только в начале нужно добавить две директивы include для файлов windows.h и d3d9.h.

    код на языке c++

    Теперь немножко поподробнее. Код относящийся к Direct3d "встроен" в каркас приложения под Windows. Здесь можно выделить три основные части: до основного цикла - иницализация, код в основном цикле - построение сцены и вывод на экран, и после основного цикла - освобождение памяти, занимаемой экземплярами интерфейсов.

    Инициализация Direct3D

    Приложение на основе Direct3d строится вокруг "устройства". В Direct3D устройство - это представление видеокарты (физического устройства) в программе. За устройство отвечает интерфейс IDirect3DDevice9 (device - устройство). Соответствующую переменную обзовём dev.

    Прежде чем получить указатель на устройство, во-первых необходимо получить указатель на объект IDirect3D9 - это позволит не прибегать к механизмам получения интерфейсов COM, во-вторых нужно заполнить структуру D3DPRESENT_PARAMETERS, в которой можно задать свойства основной и фоновой поверхности.

    Интерфейс IDirect3D9 и функция Direct3DCreate9

    Итак, программа использующая Direct3D начинается с получения указателя на интерфейс IDirect3D9. С помощью полученного объекта можно создать нужный нам объект IDirect3DDevice9. Получить указатель на IDirect3D9 можно с помощью одной из немногих функций Direct3D:

    d3d = Direct3DCreate9(D3D_SDK_VERSION);

    Аргументом функции Direct3DCreate9 всегда должна быть константа D3D_SDK_VERSION. Объявление этой константы расположено в файле d3d9.h, это так к слову.

    Объект IDirect3D9 мы получили. Для успешного создания объекта устройства нужно заполнить структурную переменную pp типа D3DPRESENT_PARAMETERS:

    код на языке c++

    Здесь мы заполняем только часть полей, поэтому, чтобы в остальных полях не оказалось какого-нибудь случайного значения, вся память, занимаемая переменной pp, обнуляется (функция ZeroMemory).

    На данный момент вам должно быть понятно назначение всех вышеперечисленных полей кроме одного - SwapEffect. Данное поле определяет каким способом будет происходить смена поверхностей (основной и фоновой). Здесь присвается значение D3DSWAPEFFECT_DISCARD - это самый эффективный способ вывода содержимого фонового буфера на экран. О других способах мы поговорим позднее.

    Метод IDirect3D9::CreateDevice

    Теперь, когда у нас есть экземпляр интерфейса IDirect3D9 и заполненная структурная переменная D3DPRESENT_PARAMETERS, можно создать устройство с помощью метода IDirect3D9::CreateDevice. Посмотрим на его объявление:

    код на языке c++

    Метод IDirect3D9::CreateDevice принимает шесть аргументов.

    UINT Adapter:

    Непосредственно видеокарта. Используется, когда в компьютере установлено более одной видеокарты. Мы пока данный случай рассматривать не будем - в программах всегда будем передавать значение по умолчанию (ноль или, что то же самое, D3DADAPTER_DEFAULT).

    D3DDEVTYPE DeviceType:

    IDirect3DDevice9 ** ppReturnedDeviceInterface:

    И последний аргумент - указатель на указатель на интерфейс IDirect3DDevice9.

    Ну и собственно вызов метода:

    код на языке c++

    С этого момента в нашей программе присутствует видеокарта.

    Обратите внимание на получения интерфейсов IDirect3D9 и IDirect3DDevice9. В первом случае используется операция присваивания над результатом независимой функции Direct3DCreate9, а во втором - указатель на устройство передаётся в метод IDirect3D9::CreateDevice.

    Вывод на экран в Direct3D

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

    Перед выводом каждого кадра на экран нужно очищать экран от содержимого предыдущего кадра:

    dev->Clear(0,NULL,D3DCLEAR_TARGET,

    D3DCOLOR_XRGB(255,255,255),1.0f,0);

    Остановимся только на четвёртом аргументе: D3DCOLOR_XRGB(255,255,255) - данный аргумент задаёт цвет, которым будет заполнен экран после очистки (в этом примере - белый). Остальные аргументы позволяют очистить только часть экрана, z-буфер, трафаретный буфер - нам это пока не нужно.

    Игроделу Direct3D: Первая программа под DirectX9

    Direct3D: Первая программа под DirectX9.

    Вывод 3D объекта.

    Итак, основная структура приложения нашего урока рассмотрена. Теперь попытаемся вывести некий простой 3-х мерный объект.

    Каждый трёхмерный объект в Direct3D задаётся набором вершин, между которыми строятся треугольники. Каждая вершинка имеет координаты в пространстве, а также может иметь ещё некоторые дополнительные параметры. Например, вершина может иметь цвет. Зададим такую структуру для каждой вершины:

    тут всё просто - x,y,z - координаты вершины в трёхмерном пространстве. А color - цвет вершины (по байту на каждую компоненту - ARGB).

    Для того чтобы Direct3D узнал, какой формат структуры вы создали для своих вершин, вам необходимо указать этот формат. Формат вершин задаётся специальными флажками D3DFVF. В нашем случае формат для структуры MyVertex будет выглядеть следующим образом:

    Если вы этот формат сравните со структурой MyVertex - вы заметите соответствие. Diffuse - означает диффузный (рассеянный) цвет.

    Как уже говорилось, 3D объект задаётся набором вершин. Например, треугольник можно задать тремя вершинами, прямоугольник - двумя треугольниками, для которых понадобится четыре вершины. Все вершины одного объекта можно поместить в вершинный буфер. Для этого в Direct3D предусмотрен специальный интерфейс - IDirect3DVertexBuffer9.

    Вывод треугольников может быть осуществлён прямым заданием списка вершин, или же индексным. В двух словах - о чём речь. Например, для вывода четырёхугольника (состоящего из двух треугольников) в "неиндексном" случае необходимо указать последовательно сначала три вершины одного треугольника, а затем три вершины второго. Однако, не трудно заметить, что две вершины в каждом треугольнике - совпадают. Чтобы не посылать повторно эти вершины, можно воспользоваться индексами. Индексы - это обычные номера вершин в вершинном буфере. То есть, мы даём четыре вершины и последовательность из шести индексов, говорящую о порядке вершин для построения треугольников.

    Преимущество такого подхода в том, что 3D объект в целом занимает меньше памяти, так как индекс имеет меньше размер, чем вершина. Соответственно и вывод таких индексных объектов происходит быстрее.

    Последовательности индексов собираются в специальные индексные буферы. Для них тоже есть отдельный интерфейс - IDirect3DIndexBuffer9.

    Попробуем построить куб. Куб имеет 6 сторон. Каждая сторона имеет 4-ре вершины и два треугольника. Как уже выяснили, каждая сторона, как квадрат будет иметь 6 индексов. Для всего куба имеем: