Dahil sa pangingibabaw ng DirectX ngayon, hindi namin maiwasang makalimutan na 10 taon na ang nakalipas ay nagkaroon ng mapait na digmaan sa pagitan ng Microsoft at Silicon Graphics sa 3D API. Sinisikap ng dalawang kumpanya na makuha ang tiwala ng mga developer, gamit ng Microsoft ang malakas na suportang pinansyal nito, at umaasa ang SGI sa karanasan at reputasyon nito sa real-time na 3D. Sa modernong labanang David vs. Goliath na ito, ang bata ay may isa sa pinakasikat na developer ng laro sa kanyang panig - si John Carmack. Ito ay bahagyang dahil sa tagumpay ng Quake engine; Ang maaasahang suporta sa OpenGL ay naging isang mahalagang kadahilanan sa pagpilit sa mga tagagawa ng GPU na ilabas kumpletong set mga driver. Sa katunayan, binigyan nito ang 3dfx ng isa sa mga unang bentahe at ginawa ang ATI bilang isang tagalabas habang ang kumpanya ay gumawa ng mga problema sa suporta sa OpenGL.

Samantala, nilikha ng Microsoft ang API nito mula sa simula ay unti-unti. Sa loob ng ilang taon, ang mga kakayahan ng Direct3D ay malayo sa pagiging pantay-pantay, kung saan maraming programmer ang nakahanap ng API na mas nakakalito at hindi maintindihan kaysa sa OpenGL. Ngunit walang sinuman ang maaaring sisihin ang Microsoft sa pagiging isang kumpanyang madaling sumuko. Sa bawat bagong bersyon ng Direct3D, unti-unting nahuli ng API ang OpenGL. Ang mga inhinyero sa Redmond ay nagtrabaho nang walang pagod upang maiangat ang pagganap sa kalaban na API.

Ang pagbabago ay dumating sa paglabas ng DirectX 8, na lumitaw noong 2001. Sa unang pagkakataon, nagbigay ang Microsoft API mas maraming posibilidad, sa halip na kopyahin lamang ang SGI API. Ipinakilala ang mga in-house na inobasyon, tulad ng suporta para sa vertex at pixel shaders. Ang SGI, na ang pangunahing pinagmumulan ng kita ay nagmumula sa pagbebenta ng mga mamahaling 3D workstation, ay natagpuan ang sarili sa kapus-palad na posisyon ng pagkabigong hulaan ang paputok na paglaki ng mga video card para sa mga manlalaro, na nagpapahintulot sa ATI at Nvidia na tumagos sa propesyonal na merkado na may mababang presyo (dahil sa economies of scale) ) na hindi kayang makipagkumpitensya ng SGI. Ang pag-unlad ng OpenGL ay kumplikado din ng mainit na debate sa mga tagapagtaguyod ng API. Dahil ang ARB (ang pangkat na responsable sa pag-ampon ng mga bagong bersyon ng API) ay nagsama ng maraming iba't ibang kumpanya at madalas na nakikipagkumpitensya, mahirap sumang-ayon sa mga feature na kailangang idagdag sa API. Sa halip, pinrotektahan ng bawat kumpanya ang sarili nitong interes. Sa kabaligtaran, ang Microsoft ay nakipagtulungan nang malapit sa ATI at nVidia, gamit ang kanilang timbang upang gumawa ng mga pagpapasya kung may mga hindi pagkakapare-pareho na lumitaw.

Sa paglabas ng DirectX 9, nagawa ng Microsoft na makamit ang isang mapagpasyang tagumpay at mapabilib ang mga developer. Tanging si John Carmack at ang mga developer na nagmamalasakit sa versatility ang nanatiling nakatuon sa OpenGL. Ngunit ang kanilang awtoridad ay nayanig. Gayunpaman, huwag nating kalimutan na ang kapalaran ay maaaring tumalikod. Ito ang nangyari sa huli sa mga web browser. Kahit na ang kumpanya ay nagtagumpay sa isang mahirap na landas, na mahalagang kumuha ng isang monopolyo na posisyon, hindi ito nagkakahalaga ng pamamahinga sa mga tagumpay nito, dahil ang mga kakumpitensya ay maaaring literal na lumitaw nang wala saan. At nang ang Khronos group ay gumawa ng OpenGL dalawang taon na ang nakakaraan, maraming tao ang nagsimulang makaramdam ng pag-asa, at malaki ang interes na ipinakita sa kasalukuyang kumperensya ng SIGGRAPH.

Noong Agosto, inihayag ni Khronos ang OpenGL 3, isang pangunahing pag-update ng API na naglalayong abutin ang Microsoft, at ang software giant, naman, ay nagplano ng susunod na henerasyong DirectX 11 API. Ngunit ang lahat ay naging medyo naiiba.

Upang lubos na maunawaan ang kontrobersya na nakapalibot sa anunsyo ng OpenGL 3, kailangan nating bumalik ng ilang taon hanggang 2002. Tulad ng sinabi namin sa itaas, sa parehong oras ang OpenGL ay nagsimulang mawalan ng lupa. Hanggang sa puntong iyon, kinopya lang ng DirectX ang mga kakayahan ng OpenGL. Sa pagkakataong ito, nalampasan ng Microsoft ang SGI API. Sa paglabas ng DirectX 9, nagdagdag ng suporta ang Microsoft mataas na antas ng wika Ang mga shader ng HLSL, at ang OpenGL ay walang maihahambing. Mahalagang tandaan na ang mga ugat ng OpenGL ay nasa IRIS GL, isang API na orihinal na nilikha ng SGI upang suportahan ang lahat ng mga tampok ng hardware ng kumpanya. Sa loob ng mahabang panahon, sinunod lang ng ATI at nVidia ang modelo ng pag-render ng SGI, iyon ay, ang OpenGL ay napakahusay na angkop sa mga video card ng mga tagagawa mula sa kanilang kapanganakan. Ngunit sa pagdating ng mga shader, ang mga bagong GPU ay lumihis mula sa tradisyonal na rendering pipeline.

Noong panahong iyon, kinilala ng isang kumpanya ang kahalagahan ng mabilis na ebolusyon ng OpenGL kung umaasa ang API na gumana sa mga modernong GPU: pinag-uusapan natin ang tungkol sa 3DLabs. Hindi ito nakakagulat, dahil inabandona ang 3DLabs mga baraha ng laro pagkatapos ng kabiguan ng Permedia 2, tumutok sa propesyonal na merkado kung saan ang OpenGL ang pamantayan. Ang 3DLabs ay nagpakita ng isang multi-point na plano na magpapahintulot sa OpenGL na lumipat sa bagong panahon. Unang punto: pagdaragdag ng high-level shader language na GLSL. Pagkatapos ay binalak ang isang kumpletong rebisyon ng API. marami Mga function ng API ay hindi na makabuluhan sa mga modernong 3D graphics card, ngunit dahil sa paatras na compatibility kailangan nila ng mga developer ng GPU na suportahan sila, kahit man lang sa antas ng software. Hindi lamang nito ginawa ang mga driver na mas mahirap magsulat at mas madaling kapitan ng mga bug, ngunit ang mga legacy na function ay ginawa ang API na medyo nakalilito para sa mga bagong programmer.

Samakatuwid, nais ng 3DLabs na mag-alok ng set ng tampok na nagsisiguro ng mahusay na pagpapatupad sa GPU, habang inaalis din ang mga hindi napapanahong o kalabisan na mga opsyon. Ang hanay ng mga tampok na ito ay tinawag na OpenGL 2.0 Pure at nilayon para sa mga developer ng mga bagong application. Para sa backward compatibility, idinagdag ito sa Open GL 2.0 buong set Mga extension ng OpenGL 1.x.

Sa kasamaang palad, pagkatapos ng walang katapusang mga talakayan sa loob ng ARB, ang planong ito ay tinanggihan. At nang maging available na ang OpenGL 2.0, ang ginawa lang nito ay magdagdag ng suporta sa GLSL sa API. Ang lahat ng iba pang alok ng 3DLabs ay napunta sa basurahan, na nag-iiwan sa OpenGL na patuloy na mahuhuli sa Microsoft API.

Kailangan natin ng pagbabago

Ang isa pang halimbawa ay nagpapakita na ang ARB ay hindi kayang tumanggap ng mabilis at mabisang solusyon. Sa mahabang panahon, umasa ang OpenGL sa isang pamamaraan na tinatawag na pbuffers para sa pag-render ng texture. Ang lahat ng mga programmer ay sumang-ayon na ang pamamaraan ay mahirap maunawaan, mahirap gamitin, at mahinang pagganap. Samakatuwid, iminungkahi ng ATI ang isang extension upang palitan ito - mga uber-buffer. Ang pagpapalawak na ito ay naging lubos na ambisyoso. Bilang karagdagan sa pag-render ng texture, ginawang posible ng ATI na mag-render sa isang vertex array, bukod sa iba pang mga advanced na feature. Marahil ang extension ay kahit na masyadong ambisyoso, ito ay tumagal ng masyadong maraming oras upang ilarawan at tukuyin ito, ang mga programmer ay hindi nais na maghintay ng matagal, kaya nVidia at 3DLabs sa wakas ay iminungkahi ng kanilang sariling bersyon, na hindi bababa sa pinapayagan para sa mahusay na pag-render sa texture, nang walang isang pandaigdigang diskarte Mga solusyon sa ATI. Inabot ng ilang taon bago naging posible na makita ang resulta ng lahat ng pagsisikap na ito - sa anyo ng extension na tinatawag na framebuffer_object, na nagbibigay ng pangunahing pag-andar na nagmula sa DirectX 9!

Kaya, noong 2005, nahabol ng OpenGL ang Microsoft API, na inilabas tatlong taon na ang nakaraan. Ang lahat ng mga pangunahing manlalaro (ATI, nVidia, 3Dlabs at mga developer ng software) ay sumang-ayon na hindi ito magpapatuloy, o ang OpenGL ay unti-unting mawawala sa eksena, at sa malao't madali ay malilimutan ito. Sa kontekstong ito, ibinigay ng ARB ang reins kay Khronos noong 2006, at naging responsable ang grupong ito para sa kinabukasan ng OpenGL. Nangako ang ATI at nVidia na lampasan ang kanilang sariling mga ambisyon at kumpetisyon at epektibong magtutulungan upang maging karapat-dapat sa wakas ang OpenGL sa ika-21 siglo. Ang mga developer ay masigasig din, dahil ang Khronos team ay naging napaka-epektibo sa pagtatrabaho sa OpenGL ES, isang 3D API para sa mga mobile device.

Napakabilis, sinimulan ng pangkat ng Khronos na alisin ang belo ng lihim sa hinaharap ng OpenGL. Muli, ang plano ay muling isagawa ang API sa dalawang yugto. Ang unang bersyon, ang Longs Peak, ay dapat magbigay sa R300/NV30 ng parehong antas ng functionality gaya ng Shader Model 2, pati na rin ang isang bago, mas flexible na modelo ng programming. Ang resulta ay isang bagay na katulad ng OpenGL 2.0 Pure, na iminungkahi ng 3DLabs ilang taon na ang nakalilipas, dahil binalak ng pangkat ng Khronos na alisin ang mga legacy na function ng API at tumuon sa isang maliit na bilang. modernong mga pag-andar. Ang kanilang set ay tinawag na OpenGL Lean and Mean. Ang pangalawang bersyon, na may codenamed Mount Evans, ay binubuo ng pag-update sa API, sabay-sabay na pagwawasto sa lahat ng mga bug na natukoy, sa antas ng R600/G80 (Shader Model 4) function. Napakahigpit ng plano sa pagpapaunlad, na nananawagan para sa Mount Evans na lumitaw nang wala pang anim na buwan pagkatapos ng Longs Peak. Ngunit ang mga miyembro ng pangkat ng Khronos ay tiwala sa kanilang mga kakayahan.

Isa pang pagbabago ang naganap mula noong ARB: nagpasya ang Khronos group na magtrabaho nang mas bukas. Na-publish ang lahat ng bagong impormasyon sa website ng OpenGL, na nagsasabi sa mga developer tungkol sa bagong API para makakuha sila ng maagang impression sa kung paano ito gumagana. Naging maayos ang lahat hanggang sa katapusan ng 2007. Bagama't ang panghuling detalye ng Longs Peak ay inaasahan noong Setyembre, inihayag ng pangkat ng Khronos na dahil sa mga problema ay maaantala ito - nang hindi nagbibigay ng anumang mga detalye. Ang desisyon na magtrabaho nang mas bukas, na ginawa ilang buwan na ang nakalipas, ay nakalimutan, at ang pangkat ng Khronos ay nagpatuloy sa trabaho nito sa isang vacuum ng impormasyon. Walang balita - sa katunayan, walang impormasyon tungkol sa pag-unlad sa bagong API.

Pagkalantad

Walang narinig tungkol sa OpenGL 3 hanggang Agosto 2008, nang isagawa ang kumperensya ng SIGGRAPH. Marami ang umaasa ng isang kaaya-ayang sorpresa, ngunit ang balita sa Khronos ay naging isang pagkabigo para sa mga tagahanga ng OpenGL. Hindi lamang huli ang API ng halos isang taon, ngunit ang karamihan sa mga bagong aspeto ng Longs Peak ay ganap na nakalimutan. Pagkatapos ng OpenGL 2.0 fiasco, na talagang naging OpenGL 1.6 na may ibang pangalan, nagsimulang magmukhang hindi hihigit sa bersyon 2.2 ang OpenGL 3.0. Ang hindi kasiya-siyang sorpresa, kasama ang kakulangan ng balita sa loob ng ilang buwan, ay humantong sa isang napaka-agresibong reaksyon sa mga aksyon ng pangkat ng Khronos sa buong mga forum. Dahil kailangang mag-react kahit papaano, tumugon si Khronos sa opisyal na OpenGL forum sa pamamagitan ng Barthold Lichtenbelt mula sa nVidia. Ang kanyang detalyadong sagot, kahit papaano ay nagbigay liwanag sa kung ano ang nangyayari sa grupo. Nalaman namin, halimbawa, na sa ilang mga punto ng plano sa pagpapatupad ang desisyon ay hindi kailanman ginawa sa oras, at sa parehong oras, marami ang naniniwala na ito ay agarang kinakailangan upang magdagdag ng suporta sa OpenGL para sa pinakabagong mga GPU. Samakatuwid, ang plano ay binago upang palawigin ang OpenGL 2 at magdagdag ng Direct3D 10 na mga tampok.

Kahit na nasa isip ang mga argumentong ito, ang pangkat ng Khronos ay maaari pa ring punahin dahil sa hindi pag-uulat ng krisis sa isang napapanahong paraan, mas pinipiling patahimikin ito. Dahil ang parehong bagay ay nangyari anim na taon na ang nakakaraan sa OpenGL 2.0, hindi ito nagbibigay inspirasyon sa pag-asa para sa hinaharap. Pagkatapos ng dalawang pangako na muling isulat ang API - na parehong hindi natupad - paano ka maniniwala sa hinaharap ng OpenGL? Sa wakas, ang komento ni John Carmack sa huling QuakeCon ay hindi nagdudulot ng anumang ginhawa. Nang tanungin tungkol sa estado ng OpenGL 3, si John ay hindi gaanong tama sa pulitika kaysa sa Lichtenbert.

Ayon kay Carmack, ang pagkabigo ng OpenGL 3, salungat sa popular na paniniwala, ay dahil sa kabiguan ng ilang mga developer ng CAD/CAD na hindi tumugon nang maayos sa Longs Peak. Natatakot sila sa mga problema sa compatibility sa kanilang mga application dahil sa pagkawala ng ilang lumang function. Ang bersyon na ito ay mataktikang kinumpirma ni Lichtenbert: "Sa yugto ng disenyo ng Longs Peak, nagkaroon kami ng hindi pagkakasundo sa mga feature na aalisin sa API... Ang hindi pagkakasundo ay lumitaw dahil sa iba't ibang pangangailangan ng mga merkado... Nalaman namin na hindi kami maaaring mag-alok ng isang API para sa lahat..."

Kaya, sa huli, ang OpenGL 3 ay naging walang iba kundi susunod na update. Ang API ay hindi talaga nagbago. Tinawag lang ni Khronos ang ilang feature bilang hindi na ginagamit at ibinigay ang konteksto kung saan magdudulot ng mga error ang mga feature. Mas mababa ito kaysa sa ipinangako (kailangan pa ring suportahan ng mga developer ng driver ang mga feature na ito), ngunit isang hakbang pa rin ito dahil maaaring maghanda ang mga developer para sa mga hinaharap na bersyon na maaaring maghatid ng totoong Lean at Mean mode. Ipinakilala din ng OpenGL 3 ang konsepto ng mga profile. Sa ngayon ay mayroon lamang isang profile, ngunit ayon sa plano, ang mga profile ay gagawin para sa mga laro at para sa CAD, halimbawa, at ang bawat profile ay susuportahan ang iba't ibang mga arrays ng mga function.

Bukod dito, ang set ng tampok na inaalok ng OpenGL 3 ay halos kapareho sa Direct3D 10, maliban sa Geometry Shaders at Geometry Instancing, na idinagdag sa API bilang mga extension. Ngunit sinusuportahan din ang ilang feature ng Direct3D 10.1, tulad ng mga independent blending mode para sa MRT.

Sa paglabas ng Direct3D 10, nagawa ng Microsoft ang pinakamalawak na bersyon ng API nito mula nang mabuo ito. Siyempre, ang lahat ng mga taong ito ng compatibility ay may makabuluhang limitasyon sa ebolusyon ng API, kaya ang layunin ay lumikha ng pundasyon para sa mga pag-unlad sa hinaharap. Siyempre, ang bagong API ay nakatanggap ng magkahalong review mula sa mga gamer at developer.

Maraming dapat sisihin ang Microsoft. Matapos ang gayong papuri para sa API nito ilang taon bago ang pagpapakilala nito, ang DirectX 10 ay humantong sa pagkabigo nang napagtanto ng mga manlalaro na sa pagsasanay ay hindi ito gaanong nagbago. Idagdag dito ang katotohanan na ang bagong API ay isinulat ng eksklusibo para sa Vista, at maliwanag na mayroong negatibong damdamin sa kung ano ang itinuturong maliit na rebolusyon. Tulad ng para sa mga developer, ang lahat ay naging mas kumplikado. Sa pamamagitan ng pag-link ng Direct3D 10 at Vista, ang Microsoft ay lubos na nilimitahan ang bilang ng mga computer na gumagana sa bagong API.

Bukod dito - at ito ay hindi lihim - sa mga nakaraang taon ang PC ay nawala ang papel nito bilang isang platform ng paglalaro, sa paglabas ng mga bagong henerasyong console, kung saan lumipat ang ilang malalaking developer mula sa mga PC. Ang id Software, Epic at Lionhead ay nagtatrabaho na ngayon sa mga multi-platform na proyekto kapag hindi gumagawa ng mga laro na eksklusibo para sa mga console. Dahil ang parehong HD set-top box sa merkado ay gumagamit ng DirectX 9 GPU, ang mga developer ay may bawat insentibo upang manatili sa nakaraang API ng Microsoft.

Bakit natin pinag-uusapan ngayon ang Direct3D 11? Una, dahil sa wakas ay inalis na ng Microsoft ang belo ng lihim sa sarili nitong API. Pangalawa, dahil bago tayo ay isang kaganapan pa rin na nagbibigay-daan sa amin upang makakuha ng ideya kung ano ang aasahan mula sa hardware sa susunod na taon. Bukod dito, mayroong bawat pagkakataon na ang Direct3D 11 ay magiging higit pa mahalagang pahina sa kasaysayan ng API na ito kaysa sa bersyon 10. Kung ang Direct3D 10 ay isang ganap na muling idisenyo na bersyon, kasama ang lahat ng nauugnay na panganib, ang Microsoft ay may sapat na oras sa pagitan ng mga bersyon 10 at 11 upang ayusin ang lahat ng mga problemang nauugnay sa unang pangunahing pag-overhaul ng API. Samakatuwid, ang Direct3D 11 ay maaaring tawaging seryosong pag-update, bagaman hindi ito matatawag na rebolusyonaryo. Ang bagong API ay binuo sa parehong mga prinsipyo tulad ng Direct3D 10, ito ay tugma sa mga nakaraang bersyon at sa hardware ng nakaraang henerasyon. Sa wakas, ang API ay magiging available hindi lamang sa Windows 7, kundi pati na rin sa Vista. Inayos ng Microsoft ang pinakamalalaking problema sa bersyon 10, at may mga hindi opisyal na tsismis sa mga developer na lalaktawan nila ang Direct3D 10 at dumiretso sa bersyon 11 sa mga laro sa hinaharap.

Makatuwiran ito sa ilang kadahilanan. Karaniwan, ang yugto ng pagbuo ng laro ay tumatagal mula dalawa hanggang apat na taon. Samakatuwid, sa oras na ang laro na binuo ngayon ay inilabas, ang Direct3D 11 ay maitatag na sa PC fleet, dahil ang API ay gagana sa lahat ng Windows 7 na computer, gayundin sa karamihan ng mga Vista PC. Malamang din na, anuman ang petsa ng paglabas, ang mga paparating na console ay gagamit ng mga Direct3D 11 na katugmang GPU (o katulad nito, tulad ng Xenos sa Xbox 360, na isang add-on sa DirectX 9). Samakatuwid, ang pag-target sa isang katulad na hanay ng mga tampok ay magbibigay-daan sa mga developer na makuha ang merkado para sa mga susunod na henerasyong console. Ngunit hindi tayo nandito para pag-aralan ang merkado. Ano ang ibinibigay ng bagong API mula sa teknikal na pananaw?

Multi-threaded rendering

Multi-threaded rendering? Ngunit hindi ba't gumagamit na tayo ng mga multi-core na CPU sa loob ng ilang taon, at hindi natutunan ng mga developer kung paano magtrabaho sa kanila? Ano ang maaaring bago sa Direct3D 11 multi-threaded rendering engine? Magugulat ang ilan sa inyo, ngunit ang mga modernong makina ay gumagamit pa rin ng isang thread para sa pag-render. Ginagamit ang iba pang mga thread para sa audio, pag-unpack ng mapagkukunan, pisika, atbp. Ngunit ang pag-render ay seryosong naglo-load sa CPU, kaya bakit hindi ito hatiin sa ilang mga thread? Mayroong ilang mga dahilan para dito, ang ilan sa mga ito ay may kinalaman sa kung paano gumagana ang GPU at ang iba ay may kinalaman sa 3D API. Samakatuwid, nagpasya ang Microsoft na alisin mga problema sa software, at tumulong din sa paglutas ng mga problema sa hardware.

Sa unang sulyap, mukhang kaakit-akit ang paghahalintulad sa proseso ng pag-render, ngunit kung titingnan mo nang mas malapitan, malalaman mo na mayroon lamang isang GPU (kahit na maraming mga GPU ang konektado sa pamamagitan ng SLI o CrossFire, ang layunin nila ay lumikha ng ilusyon na mayroong isang solong, virtual GPU), kaya at mayroon lamang isang command buffer. Kapag ang isang mapagkukunan ay ginagamit ng maraming thread, pinipigilan ng teknolohiyang mutual exclusion (mutex) ang maraming thread sa pagsusulat ng mga command nang sabay-sabay upang hindi makagambala sa isa't isa. Nangangahulugan ito na ang lahat ng mga benepisyo ng paggamit ng maraming mga thread ay inaalis ng isang kritikal na seksyon na ginagawang pare-pareho ang code. Walang API ang makakalutas sa problemang ito - minana ito sa paraan ng komunikasyon ng CPU at GPU. Ngunit nag-aalok ang Microsoft ng isang API na maaaring subukang i-bypass ito. Ipinakilala ng Direct3D 11 ang mga pangalawang buffer para sa mga utos na maaaring i-save at magamit sa ibang pagkakataon.

Mag-click sa larawan upang palakihin.

Samakatuwid, ang bawat thread ay may ipinagpaliban na konteksto, kung saan ang mga command ay nakasulat sa isang Listahan (Display List), na maaaring ipasok sa pangunahing thread sa pagproseso. Naiintindihan na kapag ang isang listahan ay hiniling ng pangunahing thread (ang "Ipatupad" na utos sa "Multi-threaded na Pagsusumite" na slide sa ibaba), kailangan mong tiyakin na ang thread ay tapos nang i-populate ito. Samakatuwid, mayroon pa ring pag-synchronize, ngunit pinapayagan ng modelo ng pagpapatupad ang ilang gawain sa pag-render na gawin nang magkatulad, bagaman, siyempre, ang nagresultang bilis ay hindi perpekto.

Ang isa pang problema sa mga nakaraang bersyon ng Direct3D ay nauugnay sa paglikha ng mga mapagkukunan - halimbawa, mga texture. SA kasalukuyang mga bersyon API (9 at 10), kailangang gumawa ng mga mapagkukunan sa rendering thread. Nalutas ng mga developer ang isyung ito sa pamamagitan ng paglikha ng isang thread na nagbabasa at nagde-decompress ng mga texture mula sa disk, at pagkatapos ay i-populate ang mapagkukunan (Direct3D object) na nilikha sa pangunahing thread.

Ngunit, tulad ng nakikita mo, karamihan sa mga workload ay nananatili pa rin sa pangunahing thread, na na-overload na. Hindi ito nagbibigay ng pinakamainam na balanse na kailangan para sa mabilis na pagpapatupad. Kaya nagdagdag ang Microsoft ng bagong interface sa Direct3D 11: maaaring lumikha ang programmer ng isang object na "Device" sa bawat thread, na maaaring magamit upang mag-load ng mga mapagkukunan. Ang pag-synchronize ng mga function ng object na "Device" ay ginagawa nang mas pino kaysa sa Direct3D 10, at mas matipid sa mga tuntunin ng mga mapagkukunan ng CPU.

Mag-click sa larawan upang palakihin.

Tessellation

Basic bagong feature Ang Direct3D 10 ay ang pagdating ng mga geometry shaders, na sa wakas ay naging posible na lumikha o sirain ang mga vertex gamit ang GPU. Ngunit ang papel ng bloke na ito ay hindi palaging naiintindihan ng tama. Hindi lamang ito nagbibigay ng napakalaking suporta sa geometry, ngunit mas angkop din ito para sa pagpapatupad ng mas flexible na Point Sprites, Fur Shading, o mga kalkulasyon ng object silhouette para sa mga volumetric shadow algorithm. Walang mas mahusay kaysa sa isang nakalaang bloke ng tessellation. Ito ay orihinal na pinlano para sa Direct3D 10 (na nagpapaliwanag ng presensya ng bloke sa linya ng Radeon HD), ngunit tila hindi maabot ng Microsoft, ATI at nVidia ang isang kasunduan sa oras, kaya nawala ang bloke mula sa mga pagtutukoy, bumalik lamang kasama ang Direct3D 11 Samakatuwid, ang Tessellation ay isang pangunahing bagong tampok na Direct3D 11 - o hindi bababa sa isa na mas madaling ibenta sa mga hindi espesyalista.

Mag-click sa larawan upang palakihin.

Hindi tulad ng iba pang mga yugto ng pipeline, ang mga yugtong ito ay hindi gumagana sa mga tatsulok bilang mga primitive, ngunit may mga patch. Hull Shader tumatagal mga control point para sa input patch, pagkatapos nito ay tinukoy ang ilang mga parameter ng Tesselator, tulad ng TessFactor, na nagpapakita ng antas ng kalidad ng tessellation. Ang Tesselator ay isang fixed function block, kaya hindi maimpluwensyahan ng programmer kung paano kinakalkula ang tessellation. Ipinapadala ng block ang mga natanggap na puntos sa Domain Shader, na maaaring maglapat ng mga operasyon sa kanila. Hayaan akong magbigay sa iyo ng isang halimbawa na makakatulong sa iyo na maunawaan ang lahat ng mas mahusay. Kumuha tayo ng isang halimbawa na nabuo sa bawat henerasyon mula noong Matrox Parhelia - Displacement Mapping.

Mag-click sa larawan upang palakihin.

Mayroon kaming mga patch breakpoints bilang input sa vertex shader. Maaaring baguhin ng programmer ang mga ito ayon sa gusto niya, dahil hindi gaanong marami sa kanila. Upang pasimplehin, kumuha kami ng isang napaka-magaspang na bersyon ng panghuling grid. Ang mga nabagong punto ay ipinapasa sa Hull Shader, na tumutukoy kung gaano karaming beses kailangang hatiin ang bawat patch plane (hal., bilang isang function ng laki ng patch sa mga display pixel). Ang Tesselator ay nagsasagawa ng tessellation. Ibig sabihin, lumilikha ito ng geometry na ipinapadala sa Domain Shader. Ang block ay gumagalaw sa mga puntos na nilikha para sa kaukulang espasyo (ang mga puntos na lumalabas sa Tesselator ay nasa patch space), na lumilikha ng mga klasikong vertices na maaari nitong palitan bilang isang function ng texture, iyon ay, Displacement Mapping.

Malaki ang potensyal. Salamat sa tessellation, maaari mong lampasan ang pangangailangan para sa isang normal na mapa at ipatupad ang antas ng detalye nang direkta sa GPU, na nagbibigay-daan sa iyong gumamit ng napakadetalyadong mga modelo (ilang milyong polygon sa halip na 10,000 o higit pa sa modernong laro) - hindi bababa sa teorya. Sa pagsasagawa, ang tessellation ay nagpapakilala ng ilang mga problema na pumipigil sa pamamaraang ito na magamit sa buong potensyal nito. Magagawa bang malampasan ng Direct3D 11 at mga katugmang card ang mga pitfalls at magpakita ng functional na bersyon? Masyado pang maaga para magsabi ng anuman, ngunit sa anumang kaso, hindi lahat ay kumbinsido na ang parehong id Software ay nagtatrabaho sa paglutas ng parehong problema sa geometry sa pamamagitan ng isang ganap na naiibang diskarte batay sa ray casting na may mga voxel.

Compute shaders

Gaya ng nabanggit namin sa aming artikulo tungkol sa CUDA Hindi gustong mawala sa paningin ng Microsoft ang merkado ng GPGPU, kaya gumawa ang kumpanya ng sarili nitong wika para gumana ang GPU sa iba pang mga gawain, hindi lamang sa pag-render. magagandang larawan. Hulaan nyo? Ang piniling modelo ng Microsoft, tulad ng OpenCL, ay lubos na nakapagpapaalaala sa CUDA, na nagpapatunay sa pananaw ng nVidia para sa hinaharap. Ang kalamangan sa solusyon ng nVidia ay nasa versatility nito - gagana ang Compute Shaders GPU nVidia at ATI, sa hinaharap na Intel Larrabee, at mayroon ding mas mahusay na pagsasama sa Direct3D, kahit na ang CUDA ay mayroon nang ilang suporta. Ngunit hindi kami maglalaan ng maraming oras sa paksang ito, kahit na nararapat ito. Sa halip, plano naming magpakita ng hiwalay na artikulo na sumasaklaw sa OpenCL at Compute Shaders sa loob ng ilang buwan.

Pinahusay na texture compression

Unang ipinakilala sa DirectX 6 sampung taon na ang nakalipas, ang DXTC texture compression ay mabilis na kumalat sa merkado ng GPU at malawakang ginagamit ng mga developer. Siyempre, ang teknolohiyang binuo ng S3 Graphics ay mahusay at ang overhead ng hardware ay katamtaman, na walang alinlangan na nagpapaliwanag ng tagumpay. Ngunit ngayon ang mga pangangailangan ay nagbago. Ang DXTC ay hindi idinisenyo para sa normal na pag-compress ng mapa at hindi isinasaalang-alang ang pag-render ng HDR. Samakatuwid, ang layunin ng Direct3D ay dalawang beses: upang payagan ang pag-compress ng mga texture ng HDR at upang limitahan ang "blockiness" ng mga tradisyonal na DXTC mode. Para makamit ito, nagdagdag ang Microsoft ng dalawang bagong mode: BC6 para sa HDR texture at BC7 para pahusayin ang kalidad ng LDR image compression.

Mag-click sa larawan upang palakihin.

Modelo ng Shader 5

Sa pagpapakilala ng Shader Model 5, hinahanap ng Microsoft na isalin ang ilang mga object-oriented programming principles sa HLSL shader language. Hindi tulad ng mga nakaraang bersyon, na nagpakilala ng mga bagong feature (Dynamic Branching, suporta para sa mga integer, atbp.), sa sa kasong ito Ang layunin ay gawing mas madali ang gawain ng mga programmer sa pamamagitan ng paglutas ng isang karaniwang problema sa mga modernong makina ng laro: ang pagtaas ng bilang ng mga shader dahil sa malaking bilang ng mga permutasyon. Kumuha tayo ng isang kongkretong halimbawa: isipin na ang makina ay gumagana sa dalawang uri ng mga materyales, plastik at metal, pati na rin ang dalawang uri ng pag-iilaw: spot at omni. Upang magbigay para sa lahat ng mga kaso, ang programmer ay kailangang magsulat ng apat na shader:

renderPlasticSpot () : // pag-render ng plastic gamit ang spot light:

renderPlasticOmni () : // pag-render ng plastic gamit ang omni light:

renderMetalSpot() : //pag-render ng metal gamit ang spot light ...

renderMetalOmni() : //pag-render ng metal gamit ang omni light:

Ang halimbawa ay napaka-simple, dahil mayroon lamang dalawang materyales at dalawang uri ng pag-iilaw, ngunit sa pagsasagawa ay maaaring mayroong ilang dosenang mga ito. Kung magpapatuloy ka sa ganitong paraan, maaaring mabilis na mawala sa kontrol ang sitwasyon. Nakakakuha kami ng malaking halaga ng duplicate na code at kung may nakitang bug, kailangan itong ayusin sa lahat ng shader. Upang malutas ang problemang ito, ang mga programmer ay gumagamit ng isang bagay na tinatawag na uber-shader, na nag-uugnay sa lahat ng mga kumbinasyon nang magkasama.

Ang Light at Material ay mga interface, at ang code ay nakapaloob sa mga nagmula na klase na OmniLight at SpotLight, PlasticMaterial at MetalMaterial. Samakatuwid, ang code ay ganap na matatagpuan sa isang lugar, na ginagawang mas madali ang mga pagbabago. Kasabay nito, ang pagiging madaling mabasa ay hindi nagdurusa dahil sa organisasyon ng code, na nakapagpapaalaala sa prinsipyo virtual function sa mga object-oriented na wika. Ang tampok na ito ay malamang na malugod na tatanggapin ng mga programmer, bagama't ito ay malamang na hindi makagawa ng marami para sa mga manlalaro.

Iba pa

Gaya ng maiisip mo, panandalian lang naming tiningnan ang mga bagong feature ng Direct3D 11, at hindi pa nai-publish ng Microsoft ang lahat ng detalye. Kasama sa mga paksang hindi namin nabanggit ang pagtaas ng maximum na laki ng texture mula 4K x 4K hanggang 16K x 16K, pati na rin ang kakayahang limitahan ang bilang ng mga mipmap na na-load sa VRAM. Posible ring baguhin ang halaga ng lalim ng pixel nang hindi pinapagana ang mga feature gaya ng maagang Z checking, suporta para sa double-precision floating point variable, scatter memory write, atbp.

Konklusyon

Marami kaming inaasahan mula sa OpenGL 3, at gaya ng masasabi mo mula sa artikulo, nadismaya kami: kapwa sa API mismo (na nawalan ng mga ipinangakong feature) at sa pagbuo nito (isang taon na pagkaantala at kakulangan ng impormasyon mula sa Khronos team). Maligayang bago bersyon ng OpenGL halos hindi makahabol sa Direct3D 10, sa parehong oras Oras ng Microsoft nai-publish ang mga unang detalye tungkol sa bersyon 11 ng API nito.

Hindi mo dapat asahan ang anumang rebolusyonaryo mula sa Microsoft, ngunit, hindi tulad ng OpenGL, ang Direct3D ay dumaan na sa kumpletong pag-overhaul ng arkitektura nito dalawang taon na ang nakakaraan. Siyempre, hindi ito naging maayos, ngunit ngayon ay maaaring anihin ng Microsoft ang mga benepisyo ng mga pagsisikap na muling itayo ang API nito sa isang makapangyarihang bagong pundasyon.

Walang alinlangan na ang Redmond ay tumitingin sa hinaharap, at sa OpenGL ay tila kontento na si Khronos na suportahan ang kasalukuyang henerasyon ng mga GPU. Sana tayo ay mali at ang ebolusyon ng OpenGL 3 ay magiging mas mabilis dahil ito ang tanging API na magagamit para sa multi-platform na pag-unlad. Pero sobra malaking bilang Nayanig ng mga problema ang aming pananampalataya sa pagbuo ng API na ito.

Noong nakaraang linggo ay ipinakita ito API Vulkan, kung saan inanunsyo ng AMD at NVIDIA ang malawakang suporta para sa. Ang bagong graphical na interface ay binuo ng Khronos Group, isang consortium na itinatag noong 2000. Ang Khronos Group ay responsable para sa pagpapaunlad at suporta bukas na mga pamantayan sa bukid mga aplikasyong multimedia sa iba't ibang platform at device. Ang consortium ay sinusuportahan ng AMD at NVIDIA, pati na rin ng maraming iba pang kumpanya.

Noong nakaraang linggo ang huling bersyon 1.0 ng Vulkan API ay niratipikahan. Ipinakita ng AMD at NVIDIA ang kani-kanilang mga beta driver. Ang AMD ay naglabas ng beta na bersyon nang maaga Radeon Software February 14 pa. Ipinakita ang NVIDIA Driver ng GeForce 356.39, na nakatuon din sa pagsuporta sa Vulkan API.

Ang diskarte ng Vulkan API ay halos kapareho sa Mantle API. Ang ideya ay para sa mga developer na magkaroon ng mas malalim na access sa hardware upang masulit ito. Ang diskarte na ito ay nagbibigay-daan sa iyo upang maiwasan ang mga umiiral na bottleneck hangga't maaari. Sa kabilang banda, kailangang malaman ng mga developer kung ano mismo ang kanilang ginagawa - halimbawa, kapag nagtatrabaho sa memorya. Ang interface ng OpenGL ay hindi kasing tanyag ng DirectX, ngunit nagbibigay-daan ito sa iyo na mag-squeeze out pa.

Ang Vulkan API sa bersyon 1.0 ay suportado sa Windows 7, Windows 8.1, Windows 10, Android at Linux. Ang mga developer ng laro ay hindi pa nag-anunsyo ng suporta para sa mga partikular na laro, ngunit sulit na maghintay para sa Games Developer Conference, na gaganapin mula Marso 14 hanggang 18 sa San Francisco. Mula sa mga engine ng laro, mayroon pa ring impormasyon tungkol sa Source 2, na sumusuporta na sa Vulkan API. Ang proseso ng pag-debug ay ginagawang mas madali sa pamamagitan ng suporta mula sa Valve, LunarG at Codeplay.

Ang Prinsipyo ng Talos

Okay, ngunit anong laro o engine ang sumusuporta sa Vulkan API? Ang Talos Principle ay binuo ng Croteam, na kilala na sumusuporta sa maraming graphics API sa nakaraan. At sa pinakabagong pag-ulit, ang Prinsipyo ng Talos ay walang pagbubukod - sinusuportahan nito ang DirectX 9, DirectX 11, OpenGL at ngayon ay Vulkan. Para sa development studio, ang Vulkan ay isang trial balloon, kahit na ang Vulkan API ay available sa bersyon 1.0, ang suporta ay nasa beta pa rin. Ang mga developer ng Croteam ay gumugol ng halos tatlong buwan sa pagdaragdag ng suporta. Ngunit ang unibersal na katangian ng API ay ginagawang posible na ipakilala ang isang variant ng Linux sa lalong madaling panahon.

Ang Vulkan API ay theoretically compatible sa ilang mga platform - ngunit sa ngayon ang mga pagsubok at paghahambing ay maaari lamang isagawa sa Windows, at ito ay may mga limitasyon. Ang pagpapatupad ay nananatili sa napakaagang yugto. Ang DirectX 11 rendering path ay napino sa loob ng maraming taon, kaya walang puwang para sa pag-optimize. Narito ang sitwasyon ay higit na nakasalalay sa mga developer ng driver, katulad ng AMD at NVIDIA. Ang Prinsipyo ng Talos ay ang unang laro na sumuporta sa Vulkan. Samakatuwid, hindi pa posible na gawin pagsubok sa paghahambing upang suriin ang mabuti o masamang pagpapatupad ng suporta.

Ang mga bagong teknolohiya ay unang ipinatupad sa mga halimbawang inihanda ng mga tagagawa. Sa kaso ng DirectX 12, ang diin ay sa Draw Calls, ang parehong 3DMark DirectX 12 na pagsubok ay umaasa lamang sa pagsukat ng pagganap ng Draw Calls, ang DirectX 12 na mga laro tulad ng Star Wars ay sumusubok din na gumamit ng katulad na load. Ngunit ang Prinsipyo ng Talos ay hindi masyadong umaasa sa mataas na bilis ng Draw Call para sa mababang antas ng API upang makagawa ng malaking pagkakaiba.

Ang suporta para sa bersyon 1.0 ng Vulkan API ay nasa maagang yugto nito, at ganoon din ang para sa mga driver ng AMD at NVIDIA. Ang parehong mga driver ay mahalagang mga bersyon ng beta, na kung paano tinitingnan ng mga tagagawa ng GPU ang mga ito. Karaniwang walang mga bagong pagpapahusay sa pagganap o suporta para sa mga bagong teknolohiya, kaya nakakakuha kami ng isang hakbang pabalik. Ngunit kapag naabot na ang isang partikular na antas ng pag-unlad, ang parehong mga driver ng GPU developer ay makakatanggap ng suporta sa Vulkan huling bersyon. Kailan ito mangyayari ay hindi lubos na malinaw. Ngunit sa ngayon, ang mga pangunahing application ay hindi gumagamit ng Vulkan at mga laro na may Suporta sa API ay nasa beta state para madaling mapino ng mga GPU developer ang kanilang mga driver.

Para sa mga pagsubok, kinuha namin ang aming sistema ng pagsubok para sa mga video card. Mga driver AMD video card at NVIDIA na inilarawan na namin sa itaas. Sa mga setting na itinakda namin pinakamataas na antas graphics, ngunit sinubukan din ang mga mababang resolution hanggang 1,280 x 720 pixels para pataasin ang performance ng Draw Call.

Ang pagsubok sa Prinsipyo ng Talos - 1.280 x 720 pixels

Ang pagsubok sa Prinsipyo ng Talos - 2.560 x 1.440 pixels

Ang pagsubok sa Prinsipyo ng Talos - 3.840 x 2.160 pixels

Tulad ng nakikita mo mula sa mga resulta, ang Vulkan API ay nagbibigay ng isang makabuluhang pagtaas kumpara sa OpenGL. Ngunit hindi naabot ng bagong API ang pagganap ng DirectX 11. Mayroong ilang mga dahilan para dito. Sa isang banda, ang pag-unlad para sa Vulkan ay nasa maagang yugto. Nalalapat ito sa API mismo, sa driver, at sa larong The Talos Principle. Kung ikukumpara sa OpenGL, binibigyang-daan ka ng bagong interface na magbakante ng ilang mapagkukunan at maiwasan ang mga bottleneck. Ngunit ang DirectX ay umuunlad sa loob ng maraming taon upang kasalukuyang antas. Sa anumang kaso, ang potensyal ng Vulkan API ay napakahusay.

Kung susuriin namin ang mga detalye, wala kaming nakitang anumang visual na pagkakaiba sa pagitan ng Vulkan API at DirectX 11. Kaya ang landas ng pag-render ay napakahusay na inangkop. Sa kasalukuyang pagpapatupad ng The Talos Principle, ang mga video card na may 2 GB ng memorya ay nakakaranas ng pagbaba sa pagganap, marahil dahil sa hindi karamihan mahusay na trabaho may memorya. Tulad ng Mantle at DirectX 12, ang Vulkan API ay maaaring ma-access ang mga mapagkukunan ng memorya sa isang mas malalim na antas - ang katotohanang ito ay makikita bilang isang kalamangan, ngunit maaari rin itong maging isang kawalan kung ang mga developer ay hindi maaaring gumamit ng memorya nang mahusay.

Medyo nabigo ako sa error sa kasalukuyang Driver ng NVIDIA, dahil sa kung saan kailangang i-reboot ang system pagkatapos ng bawat pagsubok. Nang hindi nagre-reboot, nag-crash ang laro. Bagaman hindi kami nakatagpo ng katulad na error sa driver ng AMD.

Ang kasalukuyang pagpapatupad ng Vulkan API ay tila nangangako. Sa ngayon, hindi ito magiging masyadong nauugnay para sa mga laro sa mga desktop PC, dahil ang DirectX 11 at 12 market ay napakalaki, at kumpara sa parehong DirectX 12, ang mga gastos sa pagpapatupad ay maaaring masyadong mataas at ang mga ibinalik ay masyadong maliit. Ngunit kung ang mga laro ay kailangang tumakbo sa iba't ibang mga platform na may iba't ibang mga kinakailangan sa hardware, maaaring maglaro ang Vulkan mahalagang papel. Sa anumang kaso, dapat tayong maghintay ng reaksyon mula sa mga nag-develop ng laro, kung hindi, magkakaroon tayo ng problema sa manok at itlog na mahirap alisin.

Itanong mo: sino sila? Sila ay isang patay na kumpanya na itinuturing kong tunay na OpenGL killer. Siyempre, ang pangkalahatang kawalan ng kakayahan ng Komite ay nag-iwan sa OpenGL na mahina kapag dapat ay pinupunit nito ang D3D. Ngunit sa aking opinyon, ang 3D Labs ay marahil ang tanging dahilan kasalukuyang sitwasyon OpenGL sa merkado. Ano ang ginawa nila para dito?

Gumawa sila ng isang shader na wika para sa OpenGL.

Ang 3D Labs ay isang namamatay na kumpanya. Ang kanilang mga mamahaling GPU ay itinulak palabas ng workstation market sa pamamagitan ng pagtaas ng presyon mula sa Nvidia. At hindi tulad ng nVidia, ang 3D Labs ay walang presensya sa merkado ng consumer; ang tagumpay para sa nVidia ay mangangahulugan ng kamatayan para sa 3D Labs.

Alin ang nangyari sa huli.

Sa pagsisikap na manatiling nakalutang sa isang mundo na hindi nangangailangan ng kanilang mga produkto, nagpakita ang 3D Labs sa Game Developer Conference na may presentasyon ng tinatawag nilang "OpenGL 2.0." Ito ay ang OpenGL API na muling isinulat mula sa simula. At ito ay may katuturan, dahil sa mga araw na iyon sa OpenGL API ito ay puno ng basura (na, gayunpaman, nananatili doon hanggang ngayon). Tingnan lang kung gaano ka-esoteric ang pag-load at pag-binding ng mga texture.

Bahagi ng kanilang panukala ang isang shader language. Oo, yun lang. Gayunpaman, hindi tulad ng mga kasalukuyang cross-platform na extension, ang kanilang shader language ay "high level" (C ay mataas na level para sa shader language).

Kasabay nito, nagtatrabaho ang Microsoft sa sarili nitong wika ng shader. Na kung saan sila, gamit ang lahat ng kanilang kolektibong imahinasyon, ay tinatawag na... High Level Shader Language (HLSL). Ngunit ang kanilang diskarte sa wika ay sa panimula ay naiiba.

Ang pinakamalaking problema sa wika ng 3D Labs ay na ito ay na-embed. Independiyenteng tinukoy ng Microsoft ang wika nito. Naglabas sila ng isang compiler na nakabuo ng assembly code para sa SM 2.0 (o mas mataas) shaders, na maaaring i-feed sa D3D. Sa panahon ng D3D v9, hindi kailanman direktang hinawakan ng HLSL ang D3D. Ito ay isang mahusay, ngunit hindi kinakailangang abstraction. Palaging may pagkakataon ang developer na kunin ang output ng compiler at i-tweak ito pinakamataas na pagganap.

Sa wika mula sa 3D Labs wala hindi ito ang kaso. Bibigyan mo ang driver ng isang C-like na wika at lumilikha ito ng shader. Iyon lang. Walang assembly shader, walang maipapakain sa ibang bagay. Tanging ang OpenGL object na kumakatawan sa shader.

Para sa mga user ng OpenGL, nangangahulugan ito na napapailalim sila sa mga kapritso ng mga developer ng OpenGL na nag-aaral pa lang kung paano mag-compile ng mga wikang tulad ng assembly. Laganap ang mga bug sa mga compiler ng newborn shader language na OpenGL (GLSL). Ano ang mas masahol pa, kung pinamamahalaan mong makuha ang shader upang mag-compile nang tama iba't ibang mga platform(which in itself was a great achievement), napasailalim pa rin siya mga optimizer ang mga oras na iyon ay hindi kasing-optimal na maaaring mangyari.

Ito ay isang malaki, ngunit hindi lamang ang sagabal ng GLSL. Malayo hindi lang isa.

Sa D3D, tulad ng sa lumang OpenGL assembly language, maaari mong paghaluin at itugma ang vertex at fragment shaders sa lahat ng posibleng paraan. Posibleng gumamit ng anumang vertex shader sa anumang katugmang fragment shader, hangga't nakikipag-ugnayan sila sa parehong interface. Bukod dito, pinahintulutan ang ilang hindi pagkakatugma: halimbawa, ang vertex shader ay maaaring mag-output ng isang halaga na hindi ginamit ng fragment shader.

Walang ganyan sa GLSL. Ang vertex at fragment shader ay pinagsama upang bumuo ng isang bagay na tinatawag ng 3D Labs na "software object." Samakatuwid, upang ibahagi ang maramihang vertex at fragment shaders sa iba't ibang kumbinasyon, kinailangan kong lumikha ng ilang mga bagay sa software. Nagdulot ito ng pangalawang pinakamalaking problema.

Inisip ng 3D Labs na sila ang pinakamatalino. Ginamit nila ang C/C++ bilang batayan para sa GLSL compilation model. Ito ay kapag kumuha ka ng isang c file at i-compile ito sa isang object file, at pagkatapos ay kumuha ng ilang object file at i-link ang mga ito sa isang program. Ganito ang pag-compile ng GLSL: mag-compile ka muna ng vertex o fragment shader sa isang shader object, pagkatapos ay ilagay mo ang mga bagay na iyon sa isang object ng program at i-link ang mga ito nang magkasama upang tuluyang makabuo ng isang program.

Sa teorya, pinapayagan nito ang mga cool na bagay tulad ng "library" shaders, na naglalaman ng code na tinatawag ng pangunahing shader. Sa pagsasagawa, nagresulta ito sa hindi pag-compile ng mga shader dalawang beses: isang beses sa yugto ng pag-compile at sa pangalawang pagkakataon sa yugto ng link. Sa partikular, ang compiler mula sa nVidia ay sikat para dito. Hindi ito nakabuo ng anumang intermediate object code; pinagsama-sama ito sa simula, itinapon ang resulta at pinagsama-sama muli sa yugto ng link.

Kaya, para mag-attach ng vertex shader sa dalawang magkaibang fragment shader, kailangan mong mag-compile ng higit pa kaysa sa D3D. Lalo na kung isasaalang-alang na ang lahat ng compilation ay tapos na offline, at hindi bago ang aktwal na pagpapatupad ng programa.

Ang GLSL ay nagkaroon din ng iba pang mga problema. Maaaring mali na ilagay ang lahat ng sisihin sa 3D Labs, dahil sa kalaunan ay inaprubahan at isinama ng ARB ang shader language sa OpenGL (ngunit wala nang iba pa mula sa mga panukala ng 3DLabs). Gayunpaman, ang orihinal na ideya ay nasa 3D Labs pa rin.

At ngayon ang pinakamalungkot na bagay: 3D Labs noon ay tama(karamihan). Ang GLSL ay hindi isang vector language tulad ng HLSL noong panahong iyon. Ito ay dahil ang hardware ng 3D Labs ay scalar (tulad ng modernong nVidia hardware), at ganap silang tama sa direksyon na sinundan ng maraming mga tagagawa ng hardware.

Tama sila tungkol sa pagpili ng modelo ng compilation para sa "mataas na antas" na wika. Kahit na ang D3D ay dumating sa kalaunan.

Ang problema ay tama ang 3D Labs tungkol sa mali oras. At sa pagsisikap na makarating sa hinaharap nang maaga, sa pagsisikap na maging handa para sa hinaharap, isinasantabi nila ang kasalukuyan. Ito ay mukhang ang T&L functionality sa OpenGL na palaging naroon. Maliban na ang OpenGL T&L pipeline ay kapaki-pakinabang at bago ang pagdating ng hardware T&L, at ang GLSL ay isang pananagutan bago mahuli ang iba pang bahagi ng mundo.

Ang GLSL ay isang magandang wika Ngayon. Ngunit ano ang nangyari sa oras na iyon? Grabe siya. At ang OpenGL ay nagdusa mula dito.

Sa daan patungo sa apotheosis

Sinusuportahan ko ang pananaw na ang 3D Labs ay nagbigay ng kamatayan sa OpenGL, ngunit ang ARB mismo ang humampas ng huling pako sa kabaong.

Maaaring narinig mo na ang kwentong ito. Sa panahon ng OpenGL 2.1, nagkaroon ng OpenGL malalaking problema. Sabay hila niya malaki compatibility load. Ang API ay hindi na madaling gamitin. Isang bagay ang maaaring gawin sa limang magkakaibang paraan at hindi malinaw kung alin ang mas mabilis. Maaari mong "matuto" ang OpenGL mula sa mga simpleng tutorial, ngunit hindi mo natutunan ang uri ng OpenGL na nagbibigay ng tunay na graphical na kapangyarihan at pagganap.

Nagpasya ang ARB na gumawa ng isa pang pagtatangka na muling likhain ang OpenGL. Ito ay tulad ng "OpenGL 2.0" mula sa 3D Labs, ngunit mas mabuti dahil ARB ang nasa likod ng pagsisikap. Tinawag nila itong "Longs Peak".

Ano ang masama sa paggugol ng kaunting oras sa pagpapabuti ng API? Ang masamang balita ay ang Microsoft ay nasa isang medyo walang katiyakan na posisyon. Ito ang panahon ng paglipat sa Vista.

SA Vista Microsoft nagpasya na gumawa ng pinakahihintay na mga pagbabago sa mga driver ng graphics. Pinilit nila ang mga driver na bumaling sa OS para sa virtualization ng memorya ng graphics at marami pang iba.

Ang isang tao ay maaaring magtaltalan nang mahabang panahon tungkol sa mga merito ng diskarteng ito, at kung ito ay posible, ngunit ang katotohanan ay nananatili: Ginawa ng Microsoft ang D3D 10 para lamang sa Vista at mas mataas. Kahit sa sumusuporta Imposible para sa D3D hardware na magpatakbo ng isang D3D application nang walang Vista.

Maaaring natatandaan mo ang Vista na iyon... sabihin nating hindi ito gumana nang maayos. Kaya nagkaroon kami ng mabagal na OS, isang bagong API na gumagana lamang sa OS na iyon, at isang bagong henerasyon ng hardware na iyon kailangan sa API at OS na ito upang makagawa ng higit pa sa pagganap ng nakaraang henerasyon.

Gayunpaman, ang mga developer maaari Gumamit ng D3D 10 level functionality sa pamamagitan ng OpenGL. Iyon ay, magagawa nila kung hindi abala ang ARB sa pagtatrabaho sa Long Peaks.

Ang ARB ay gumugol ng isang magandang taon at kalahati hanggang dalawang taon sa pagtatrabaho sa pagpapabuti ng API. Sa oras na lumabas ang OpenGL 3.0, natapos na ang paglipat sa Vista, paparating na ang Windows 7, at wala nang pakialam ang mga developer ng laro sa 10-level na functionality ng D3D 10 Ang bilis ng mga PC port ay tumaas, console (o sa paglipat ng mga PC developer sa console market), ang mga developer ay nangangailangan ng D3D 10 functionality na mas mababa at mas kaunti.

Kung ang mga developer ay may access sa functionality na ito kahit na sa Windows XP, ang OpenGL development ay maaaring mapasigla. Ngunit pinalampas ng ARB ang pagkakataong ito. Gusto mo bang malaman kung ano ang pinakamasama?

ARB hindi pwede mag-imbento ng API mula sa simula sa kabila ng pag-aaksaya ng dalawang mahalagang taon sa pagsisikap na gawin ito. Kaya't ibinalik nila ang status quo, nagdaragdag lamang ng isang mekanismo upang ihinto ang pagpapagana.

Bilang resulta, hindi lamang napalampas ang ARB susi mga pagkakataon, ngunit hindi rin ginawa ang gawain na humantong sa kanila sa pagkukulang na ito. Isa itong epic fail sa lahat ng larangan.

Ito ang kwento ng pagsalungat sa OpenGL at Direct3D. Isang kwento ng mga napalampas na pagkakataon, malaking katangahan, sinasadyang kawalang-ingat at mga walang katotohanan na kalokohan.

Tila, maraming mga gumagamit, lalo na, ang lahat ng mas gustong gumamit ng isang computer upang mag-install at maglaro ng mga modernong mapagkukunan-intensive na laro, alam na sa mga setting ng graphics maaari mong gamitin espesyal na paraan pabilisin ang output ng imahe at pagbutihin ang kalidad ng imahe OpenGL o DirectX. Ano ang mas mahusay na gamitin para sa buong paggamit lahat ng mga nakatagong mapagkukunan ng isang computer system at makamit ang pinakamataas na pagganap? Ang tanong na ito ay medyo kontrobersyal, at kadalasan ay hindi posible na sagutin nang walang pag-aalinlangan pabor sa alinmang platform, dahil ang lahat ay nakasalalay sa tiyak na layunin na itinakda ng user o developer para sa kanyang sarili, gayundin sa bawat isa. tiyak na sitwasyon, na maaaring bahagyang nauugnay sa hardware sa anyo ng isang graphics accelerator, suporta sa software nito sa anyo ng mga driver at ilang karagdagang aspeto. Subukan nating alamin kung alin ang mas mahusay - OpenGL o DirectX - sa pamamagitan ng pagpunta sa mga opisyal na mapagkukunan ng impormasyon at pag-asa sa mga opinyon ng mga user at software developer na maaaring mangailangan ng suporta para sa mga naturang teknolohiya.

Ano ang OpenGL at DirectX?

Magsimula tayo sa katotohanan na sa mga ordinaryong gumagamit ay may maling kuru-kuro na ang dalawang inilarawang sangkap na ito ay mga graphics engine. Dito lumitaw ang mga maling tanong tungkol sa kung aling makina ang mas mahusay - OpenGL o DirectX?

Ang katotohanan ay ang mga platform na ito ay bahagyang inuri lamang bilang mga makina, dahil ang mga ito ay eksklusibong software na nagpapahintulot sa program (laro) engine na makipag-ugnayan sa naka-install na kagamitan(madalas na may video at sound card) sa pamamagitan ng kanilang mga driver, na nagsisilbing mga tagapamagitan. Sa katunayan, ang OpenGL at DirectX ay bahagi ng mga interface programming ng aplikasyon kasama ang mga kinakailangang hanay ng mga aklatan, klase, kahulugan, istruktura, constants at function na ginagamit upang matiyak na gumagana ang mga produktong panlabas na software na naka-install sa operating system.

Para saan ginagamit ang mga teknolohiyang ito?

Naturally, madalas na makakatagpo ka ng mga tanong tungkol sa kung aling mga graphics ang mas mahusay - OpenGL o DirectX? Ang pagbabalangkas na ito ay bahagyang hindi tama, dahil maaari nating pag-usapan hindi lamang ang tungkol sa paggamit ng mga mapagkukunan ng mga video card, kundi pati na rin ang tunog o anumang iba pang "hardware" at virtual na mga aparatong multimedia. Ngunit kadalasan ay talagang pinag-uusapan natin ang tungkol sa mga graphics accelerators. Kasabay nito, kailangan mong malinaw na maunawaan na ang pagpili na pabor sa isa o isa pang "tulay" na nagsisiguro sa pakikipag-ugnayan ng video card sa isang naka-install na laro o anumang iba pang programa, kung kinakailangan, ay maaari ding depende sa kung paano ipinag-uutos ang naturang suporta ay.

Sa modernong mga laro na may kumplikadong mga texture at masusing iginuhit na mga dynamic na eksena, ang gayong suporta ay lubhang kailangan. Ngunit ang problema ay hindi lahat ng mga graphics accelerator ay maaaring gamitin nang tama ang naturang suporta. Sa kasong ito, ang lahat ay nakasalalay sa mga driver. Gaano man ka-uso ang card, sa hindi napapanahong control software (mga driver) hindi nito magagamit ang lahat ng mga kakayahan na orihinal na idineklara ng manufacturer. Gayunpaman, sa karamihan ng mga laro o sa mga programa para sa pagtatrabaho sa multimedia (halimbawa, para sa pagpoproseso ng video), madalas na kinakailangan upang piliin kung aling suporta ang mai-install sa mga setting, na inilalagay ang isang platform laban sa isa pa (sa Ingles na bersyon ito ay karaniwang mukhang "OpenGL vs DirectX") .

Mga pangunahing pagkakaiba sa pagitan ng DirectX at OpenGL

Tulad ng para sa mga pangunahing pagkakaiba, nang hindi napupunta sa mga teknikal na aspeto ng operasyon, maaari nating agad na mapansin na ang DirectX platform, na isang eksklusibong pag-unlad ng Microsoft Corporation, ay inilaan lamang para sa paggamit sa mga sistema ng Windows at bahagyang sa Xbox, at ang OpenGL ay isang malayang ipinamahagi cross-platform na teknolohiya na naaangkop sa ibang OS (kahit na mobile). Ang lisensya ng GNU ay nagbibigay-daan sa sinuman na gumawa ng sarili nilang mga pagbabago at pagdaragdag sa mga bahagi ng API na ito upang mapabuti ito upang mapataas ang pagganap ng parehong mga video card, habang ang mga pagpapahusay ng DirectX ay maaari lamang asahan kapag inilabas ang mga bagong bersyon ng platform. Kasabay nito, kahit na sa mga pinakabagong driver, kapag ginamit sa mas lumang mga bersyon ng tulay, ang mga graphics accelerators ay hindi gumagawa ng mga tagapagpahiwatig na idineklara ng tagagawa.

Pangunahing pakinabang at disadvantages

Sa pagsasalita tungkol sa kung alin ang mas mahusay - OpenGL o DirectX 11 (12), nararapat na tandaan na ang unang platform ay inilaan lamang para sa mga graphics, at ang pangalawa ay maaaring magamit sa pangkalahatan para sa lahat ng bagay na may kaugnayan sa multimedia (sa kasong ito, ang bahagi ng Direct3D ay responsable para sa mga graphic).

Bilang karagdagan, napansin ng maraming eksperto na sa napakataas na lawak ang pagpili na pabor sa isang tulay o iba pa ay maaaring depende sa uri ng graphics card. Ngunit, kung lalapitan natin ang paghahambing nang may bukas na pag-iisip, pinaniniwalaan na sa mga tuntunin ng saklaw ng platform ang OpenGL ay mukhang mas mahusay, ngunit ang DirectX ay nanalo sa mga tuntunin ng pagiging isang handa na produkto ng software ng klase ng Plug&Play. Gayunpaman, hindi natin dapat kalimutan na ang toolkit Pinakabagong DirectX ang mga bersyon ay magagamit na sa OpenGL, ngunit suporta sa feedback Hindi.

OpenGL o DirectX: alin ang mas mahusay para sa mga laro?

Tulad ng para sa mga laro, kahit dito imposibleng magbigay ng isang tiyak na sagot. Halimbawa, madalas na makakahanap ka ng mga komento tungkol sa katotohanang iyon graphics chips Ipinapakita ng linya ng Radeon 9800 ang pinakamahusay na mga resulta sa mga pagsubok batay sa DirectX, at ang mga card Serye ng GeForce 5XXX - kapag gumagamit ng OpenGL. Ngunit ang DirectX ay may isa pang hindi maikakaila na kalamangan.

Dahil ang tulay ng OpenGL ay orihinal na nilikha para sa iba pang mga platform, ang iba't ibang uri ng mga bug ay maaaring lumitaw kasama nito sa Windows, ngunit pinapayagan ka ng DirectX na gumamit ng mga laro nang medyo matatagalan kahit na sa medyo mga lumang computer nang walang anumang pagbagal (isang kapansin-pansing halimbawa nito ay ang larong Age Of Empires).

Kabaligtaran din ang nangyayari. Halimbawa, napapansin ng ilang user na ang DOOM 3 sa Radeon X1XXX series card na gumagamit ng OpenGL ay "lumilipad" lang, at ang Half-Life 2 ay madalas na "bumabagal". Ngunit dito, tila, ang lahat ay nakasalalay din sa mga driver.

Ngunit, sa pangkalahatan, kung sinusuportahan ng laro ang paggamit ng parehong mga teknolohiya, pinakamahusay na makita kung ano ang magiging resulta ng video card kapag ginagamit ang bawat mode nang halili. Hindi sinasabi na upang makamit ang pinakamainam na pagganap, ang mga platform mismo at ang mga driver ng graphics accelerator ay dapat na ma-update sa pinakabagong mga bersyon.

Alin ang mas mahusay para sa BlueStacks: DirectX o OpenGL?

Madalas ay makakatagpo ka ng mga tanong tungkol sa paggamit ng isa sa pinakasikat na Android system emulator na tinatawag na BlueStacks. Aling platform ang pipiliin sa BlueStacks - OpenGL o DirectX? Naku, imposibleng magbigay ng tiyak na sagot dito.

Gayunpaman, hindi sinasabi na kung nag-install ka ng mga laro sa pamamagitan ng emulator na ito, mas mainam na gumamit ng OpenGL, ngunit kung bumagal ang laro, kailangan mong lumipat sa DirectX. Ngunit, muli, ang lahat ng ito ay may kinalaman lamang sa mga graphics ng laro. Sa kaso ng propesyonal na pagproseso at ang pag-render ng video ay mangangailangan ng ilang seryosong eksperimento.

Sa wakas, kung pag-uusapan natin kung ano ang mas mahusay - OpenGL o DirectX - para sa isang developer na nagsisimula pa lang makabisado ang mga teknolohiyang ito at nagsasagawa ng kanyang mga unang hakbang, karamihan sa mga eksperto sa larangang ito ay tandaan na mas mahusay na maging pamilyar muna sa mga prinsipyo ng pagpapatakbo. at toolkit ng DirectX, dahil mukhang mas simple ang platform na ito para sa isang baguhan, at ang magagandang SDK kit ay patuloy na inilalabas para dito, na idinisenyo para lang gawing simple ang adaptasyon. mga produkto ng software sa hardware, at pagkatapos ay magpatuloy sa pag-aaral ng OpenGL.

Gayunpaman, marami ang maaaring depende sa kung anong huling layunin ang itinakda mo para sa iyong sarili at kung anong partikular na functionality ng bawat platform ang gagamitin sa bawat partikular na kaso (mga graphics lamang, tunog lamang, o ilang uri ng pinagsamang solusyon).

Maikling konklusyon

Summing up, tulad ng malinaw na, medyo mahirap gumawa ng isang hindi malabo na konklusyon na pabor sa isa o ibang bahagi. Mayroong patuloy na kumpetisyon sa pagitan ng mga platform na ito. Minsan bago Bersyon ng DirectX sa mga tuntunin ng mga parameter nito ay nauuna ito sa OpenGL, ngunit habang ito ay luma na, pati na rin ang ilang mga inobasyon ay ipinakilala sa OpenGL, nagsisimula itong mawala. Sa pangkalahatan, kapag gumagawa ng isang pagpipilian, ang isa ay dapat magpatuloy lamang mula sa kilalang prinsipyo na ang katotohanan ay nalalaman sa pamamagitan ng paghahambing. Subukan ang pareho! Pagkatapos lamang makakuha ng mga partikular na resulta at para sa bawat partikular na kaso magiging malinaw kung aling bahagi ng sukat ang iyong pipiliin.

Oh, kung napakasimple lang nito sa OpenGL. Ngayon, sa isang paraan o iba pa, mayroong 6 na hindi tugmang pamantayan na ginagamit (2.1,3.3,4.x, ES 1.0, ES 2.0, ES 3.0), na may iba't ibang mga wika ng shader at bahagyang (at kung minsan halos ganap) iba't ibang mga API . Mas masahol pa, walang pagpapatupad ng sanggunian at napakaliit na kontrol sa kalidad. Bilang resulta, sa karamihan ng merkado ng PC (Intel at AMD), ang OpenGL ay ipinatupad nang baluktot, at sa mga mobile phone, bilang karagdagan sa mga madalas na baluktot na driver (para sa Adreno (ex-ATI, ano ang maaari mong gusto), ang mga diskarte sa pag-optimize ay ibang-iba

DiDi

Mikhail, medyo nagkakamali ka. Kailangan mo lamang pumili ng DirectX sa isang solong kaso. Kung gusto mong limitahan ang iyong madla hindi lamang sa Windows platform, kundi pati na rin sa isang bersyon ng Windows at isang eksaktong tugma ng mga tagagawa at serye ng mga bahagi ng computer na ginagamit para sa pagbuo. At kahit na walang magtaltalan na kung ano ang nakasulat gamit ang direkta ay gagana sa iba pang mga bahagi at kahit na ilang mga bersyon ng Windows, gayunpaman, sa kaso ng anumang pagkakaiba, ang larawan ay magkakaiba sa ang pinakamasamang bahagi pati na rin ang pagganap. Sa lahat ng iba pang mga kaso, kung nais ng developer na ihatid ang kanyang nilikha sa anyo kung saan niya ito ginawa, kailangan lang niyang piliin ang OpenGL.

crsib

DiDi, kakaiba ang sinasabi mo. Una sa lahat, ang D3D9 ay nasa lahat ng dako mula noong XP, at, sorpresa, sa XBox at ilan Windows Mobile mga telepono. Available ang D3D11 sa lahat ng PC na may Vista+, WinRT, WP8. Malamang na ito ay sa susunod na henerasyon ng XBox.

Hindi gumagana ang OpenGL sa PC. May maliit na pagkakataon na ang lahat ay gagana sa AMD. Wala akong sasabihin tungkol sa Intel. Ang user, lalo na ang baboy, ay maaaring walang mga driver, na magbibigay sa kanya ng cool na software rendering at suporta para sa API 1.1. Kasabay nito, mayroong isang mahusay na pagkakataon na ang laro ng D3D ay gagana nang mahusay.

DiDi

crsib, sana magkaroon ka ng sarili mong game projects.. sapat na sa akin na sapat na ang nakita kong code para isulat para lang nasaan man ang larawan kung saan naroon ang D3D9 na ito, hindi na ako magtatalo na karamihan sa mga programmer na gumagamit Ang DirectX ay hindi mga tamad na tao, hindi katulad ng mga mas gusto ang OpenGL, ngunit hindi ito nagdaragdag ng anumang halaga sa DirectX mismo. Sa huli, para sa akin personal, ang panukala ay ang mga gastos ng mga developer, at sa kaso ng direktang sila ay hindi katimbang mas mataas na may mas hindi gaanong kapaki-pakinabang na output sa huli.

crsib

meron lang ako. At sa OpenGL ES. Hindi ko maintindihan ang biro tungkol sa mga gastos sa paggawa. Ang pagsubaybay sa estado ng pipeline sa OpenGL ay pagpapahirap pa rin, dahil sa ilang kadahilanan ang isang makabuluhang bahagi nito ay nakapaloob sa mga graphic na "primitives". Ang pagpapanatiling portable ng code ay karaniwang mahirap. Ang ES 1 ay walang mga kinakailangan para sa mga format ng compression ng texture ng hardware, ang ES 2.0 ay may mahinang ETC. Bilang resulta, para sa parehong Android kailangan mong mag-assemble ng isang pack ng mga build na may mga texture sa iba't ibang mga format. Hindi ko rin pinag-uusapan ang katotohanan na ang PowerVR at Mali at Adreno sa ilang mga lugar ay may direktang kabaligtaran na mga diskarte sa pag-optimize sa antas ng OpenGL (kasama ang diskarte nito sa abstraction ng hardware). Ayaw ko kasing pag-usapan ang PC. Dahil sa ang katunayan na ang OpenGL ay kailangang gumana, ang aking mga computer ay palaging may nVidia accelerator. Wala na talaga akong choice. Halos masisiguro ko na ang code na nakasulat alinsunod sa pamantayan sa Intel GMA/HD ay hindi gagana nang bobo, kahit na mag-install ako ng 10 driver. Well, o ito ay gagana sa paraang ito ay magiging mas mahusay kung ito ay matapat na hindi gumana. Halos pareho lang ng kwento sa ATI/AMD, medyo gumanda lang ang sitwasyon.

Sa pangkalahatan, ang iyong mga komento ay pakinggan sa diwa ng isang baguhang developer na walang oras na dumaan sa lahat ng mga bilog ng impiyerno ng pagbuo ng produksyon sa OpenGL