SlimDX9 07 - Material Alpha Blending

Az elmúlt SlimDX leckékben megismerkedtünk a fények, anyagok és textúrák adta lehetőségekkel. Láthattuk, hogy milyen egyszerű az alkalmazásuk és, hogy milyen gyönyörű grafikai hatások valósíthatóak meg velük. Az anyagok, illetve textúrák hozzárendelésével a felületek is élethűbb hatást keltenek. De még meggyőzőbbé válik a kép, ha az anyagokat, textúrákat és fényeket együtt alkalmazzuk. Ehhez mos az előző leckékben bemutatott ismereteket ötvözzük egy új projektben. Lássunk is hozzá.

Mivel anyagokat és textúrákat is használunk, vertexünk és vertexformátumunk megfelelően kibővül:

   [StructLayout(LayoutKind.Sequential)]
  struct Vertex
  {
      public Vector3 Position;
      public Vector3 Normal;
      public Vector2 Texel;

      public static readonly int Stride = Marshal.SizeOf(typeof(Vertex));
      public static readonly VertexFormat Format = VertexFormat.Position | VertexFormat.Normal | VertexFormat.Texture1;

      public Vertex(float vx, float vy, float vz,
          float nx, float ny, float nz, float u, float v)
      {
          Position = new Vector3(vx, vy, vz);
          Normal = new Vector3(nx, ny, nz);
          Texel = new Vector2(u, v);
      }
  }

A fenti vertexformátúm a vertex, a felületi normális és a textúra koordinátákat tárolja el. A kocka vertexeinek megadásakor minden tag inicializásáról gondoskodni kell:

data = new Vertex[]
{
// elülső oldal
new Vertex(-1.5f, +1.5f, -1.5f, 0, 0, -1, 0, 0),
new Vertex(+1.5f, +1.5f, -1.5f, 0, 0, -1, 1, 0),
new Vertex(-1.5f, -1.5f, -1.5f, 0, 0, -1, 0, 1),
new Vertex(-1.5f, -1.5f, -1.5f, 0, 0, -1, 0, 1),
new Vertex(+1.5f, +1.5f, -1.5f, 0, 0, -1, 1, 0),
new Vertex(+1.5f, -1.5f, -1.5f, 0, 0, -1, 1, 1),
…

Az alkalmazott anyagtulajdonságokat a SetupMaterial(), a textúrákat pedig a SetupTexture() metódusban állítjuk, ill. töltjük be. A fényforrás beállításáról a SetupLight() metódus gondoskodik. Ennek eredményeként a képernyőn, három forgó kockát láthatnánk, amelyek a megadott anyagtulajdonságoknak megfelelően verik vissza a fényt. Igen, ennyi az egész, de még nem érdemes megállni…

Anyag és alfa keverés

Az alfa keverésről már írtam az OpenGL leckesorozatban, az elv itt is ugyan az: a színeket RGBA formátumban kell megadni ahol is az (A) érték szolgál alfa-csatornaként. Az alfa-csatorna értéke azt mutatja, hogy a létrehozandó képpont színéhez milyen arányban járul hozzá a forrás pixelének színe. Szerencsére az alfa keveréshez kényelmes függvényeket biztosít számunkra a DirectX API. Első lépésként engedélyezni kell az alfa keverést:

device.SetRenderState(RenderState.AlphaBlendEnable, true);

Azt szeretnénk, hogy anyagunk színe érvényesüljön, ezért beállítjuk az anyagot mint a diffúz fényvisszaverődés forrását:

device.SetRenderState(RenderState.DiffuseMaterialSource, true);

Ezután beállítjuk az első textúramegjelenítés szakasz alfa műveletét, amely a TextureStage.AlphaArg1 értéket fogja használni. Esetünkben ez a diffúz komponens, tehát az anyag színe:

device.SetTextureStageState(0, TextureStage.AlphaArg1, TextureArgument.Diffuse);
device.SetTextureStageState(0, TextureStage.AlphaOperation, TextureOperation.SelectArg1);

Végül az alfa keverés módszerét kell beállítani. A példában a következő képletet fogjuk megvalósítani:

szín = forrás_szín × forrás_alfa + cél_színe × (1 - forrás_alfa)

Ugyanez a SlimDX nyelvére fordítva:

device.SetRenderState(RenderState.SourceBlend, Blend.SourceAlpha);
device.SetRenderState(RenderState.DestinationBlend, Blend.InverseSourceAlpha);

Az anyag diffúz komponensének alfa értékét futás alatt folyamatosan fogjuk változtatni egy szinusz függvény segítségével a DrawCube() metódusban (lásd forráskód). A végeredmény pedig itt látható, az ablakban három forgó kockát csodálhatunk, amelyek fokozatosan elfakulnak, majd újra megjelennek.

Anyag, fény, textúra, és alfa keverés...

A teljes forrás itt érhető el:

DOWNLOAD

A bejegyzés megírásában nagy segítségemre voltak Nyisztor Károly DirectX-el kapcsolatos könyvei.

Így fognak kinézni az AMD új Radeon HD csúcskártyái

Bár az AMD már korábban bejelentette, hogy ezen a héten piacra dobja majd őket, mindeddig nem lehetett tudni, hogy hogyan is fognak az új Radeon HD 6850 ill. 6870-es kártyák kinézni. A cég azonban hétfőn végre eljuttatta a sajtóhoz az első fotókat a következő generációs kártyáiról, amelyeket így végre mi is be tudunk mutatni mindenkinek.

A képek megerősítik, hogy az új csúcskártyák nem kevesebb, mint összesen 5 (!) darab különböző videókimenettel fognak rendelkezni, amelyek között két DVI és egy HDMI csatlakozó mellett az új, modernebb technológiát képviselő DisplayPort Mini kapukból is megtalálható lesz kettő. Utóbbiak használatához ugyanis valószínűleg konverter lesz majd szükséges a legtöbb konfigurációban, de jelenlétük biztosítja, hogy kiváló minőségben jusson el a jel a monitorokhoz akkor is, ha azok több méterre helyezkednek el a géptől.

Természetesen mindkét kártya dupla PCI-Express helyet igényel majd, ráadásul a nagyobb testvér 6870-es a tápegységtől is két darab, külön sínen lévő 6 pólusú csatlakozót követel majd a megfelelő energiaellátás biztosításához. Kisebb testvére, a 6850 ugyanakkor szerényebb igényekkel lép fel, és egyetlen extra PCI tápcsatlakozóval is megelégszik majd, így a nem feltétlenül legcsúcskategóriásabb tápok ill. egy második táp a házba szerelése nélkül is is esélyes lesz egy kétkártyás konfiguráció összeállítása belőle.

Az új DirectX 11-es Radeon HD 6850 és HD 6870 hivatalosan pénteken fog érkezni - árukra vonatkozó információkat is ekkor lehet majd megtudni róluk.

Sting

GeForce GT 440 - olcsó Fermi videókártya az Nvidia-tól

Az Nvidia az elmúlt hét végén csendben piacra dobta új, GeForce GT 440 típusjelű videókártyáját. A Fermi generációból származó új kártya a cég termékkínálatának gyakorlatilag legolcsóbb tagját képezi, amely azonban ennek ellenére igen szép grafikai teljesítményt bocsát az alkalmazások rendelkezésére.

Az elsősorban csak alkalmi játékosoknak szánt kártya lelkét egy GF106 típusjelű, 144 feldolgozóutas processzor képezi, amely saját maga 594 MHz-en fut, és egy 192-bites vezérlőn keresztül éri el az akár 1800 MHz-es frekvencián pörgő GDDR3 grafikus memóriát. Utóbbiból a leggyengébb változaton másfél, míg a legerősebben 3 GB-nyi kap majd helyet.

Nvidia GeForce GT 440

A kártya támogatja az összes manapság elvárt grafikus technológiát, beleértve a DirectX 11-et, a Shader Model 5.0-t, az OpenGL 4.0-t, de a Blu-ray videók dekódolása és lejátszása sem jelent problémát számára, sőt, maximum kétutas SLI konfigurációba is kapcsolható. A már elavultnak tekinthető D-Sub mellett DVI és HDMI csatlakozóval is ellátták, így gyakorlatilag bármilyen monitorhoz csatlakoztatható - utóbbi port pedig a HDCP-t is támogatja, így a jogvédett nagyfelbontású tartalmak átvitele is megoldott rajta keresztül.
Az Nvidia GeForce 440 kevesebb mint száz dollárba - azaz, húszezer forintba - kerül majd; ugyanakkor a kártya kiskereskedelmi forgalomban egyelőre nem lesz kapható, hanem mindössze OEM-ek vásárolhatják majd meg előszerelt PC-ikbe történő beépítésre.

Sting

Az északi-irány meghatározása a „bot és árnyék” módszerrel

A ember már évezredekkel ezelőtt rájött, hogy a Nap szabályos járását követi az árnyékok változása is. A földbe leszúrt karó árnyéka reggel hosszan elhúzódva nyugat felé mutat. Ahogy a Nap emelkedik az égen az árnyék úgy rövidül, és iránya egyre inkább észak felé fordul. Délben a bot árnyéka a legrövidebb, és északi irányú, délután kelet felé fordul. Ahogy a Nap ereszkedik égi pályáján, úgy nő meg az árnyék hossza is. Napnyugtakor az árnyék kelet felé mutat…

A fentiek alapján bármikor meg tudjuk határozni az északi irányt, csak egy bot kell hozzá. Szúrjunk le a sima földbe egy kb. fél méteres, egyenes botot. A bot köré rajzoljunk egy olyan kört, amelynek sugara megegyezik a bot árnyékának hosszával. A bot árnyékának és a körívnek a metszéspontját jelöljük meg egy kővel. Ahogy a Nap halad a pályáján, az árnyék hossza is változik. Amikor az árnyék hossza ismét pontosan a kör sugarával megegyező hosszúságú lesz, akkor az árnyék körívvel alkotott metszéspontját ismét jelöljük meg egy kővel. A leszúrt botot a két kővel összekötő egyenesek szögfelezője az északi féltekén a déli, a déli féltekén pedig az északi irányt mutatja. Természetesen ezek ismeretében már az kelet-nyugati irány is könnyedén meghatározható.

Ennek meghatározására azonban ismert egy másik módszer is, amely ugyancsak a bot-árnyék módszert alkalmazza. Ehhez a sima földbe le kell szúrnunk egy egyenes botot, amely kb. 1 m magas. Tegyünk az árnyék végére egy követ. Majd kb. 15 perc elteltével ismét jelöljük meg a bot árnyékának végét egy kővel. A két követ összekötő egyenes jelöli ki a nyugat-keleti irányt. Ebből az irányvonalból valamint a napszak és azon ismeret birtokában, hogy a Nap keleten kel, nyugaton nyugszik, megállapítható, hogy merre van kelet ill. merre van nyugat. Az észak-déli irány természetesen erre merőlegesen szintén meghatározható.

SlimDX9 06 - Textúrázás alapfokon

Az előző néhány bejegyzésben láttuk, hogy hogyan építhetünk fel egyszerű objektumokat és azokhoz hogyan rendelhetünk különféle anyagtulajdonságokat. Azonban, ha realizmusra törekszünk, egy komplex jelenet felépítése óriási munkát jelentene, gondoljunk csak egy csempézett falra vagy egy hajópadlóra. Itt jön a képbe a texture mapping eljárás ami Dr. Edwin Catmull 1974-es doktori disszertációjából származik. Ebben a leckében ezért a textúrázás alapjaival fogunk megismerkedni a DirectX API keretein belül.

Tex-tor-túra

Kezdetben a textúra nem volt más, mint egy kétdimenziós tömb, melynek minden pontja az adott pontbeli szín koordinátáit tartalmazta (körülbelül, mint egy bitmap formátumú kép (.bmp), a neve is hasonló: bittérképes textúra). Később megjelentek összetettebb textúrázási módszerek is, például a procedurális textúrázás, illetve a 3D textúrák. Előbbi lényege, hogy a textúránkat olyan módszerekkel generáljuk, melyek különféle zajokat adnak a kapott bittérképhez, például fraktál- vagy turbulencia-alapú zajokat. Ezek hasonlítanak a természetben előforduló „zajokra”, így egy igen realisztikus képet kapunk, amely minden újra-generáláskor egy kicsit változik. Ezzel a módszerrel például fa, szikla, gránit és márvány anyagokat szokás generálni. A másik módszer, a háromdimenziós textúrázás esetén n darab (ahol n kettő hatványa) kétdimenziós textúránk van, és mindig a mélységtől függ, melyiket használjuk.

(1) 3D-s modell textúra nélkül, (2) 3D-s modell textúrával

De térjünk is vissza a bittérképes textúrázáshoz. Egy textúrázott test azt jelenti, hogy a felszínének pontjait kölcsönös kapcsolatba hozzuk egy kép pontjaival, azaz a test pontjainak színét egy képből kapjuk. A testet, mint megbeszéltük, felbonthatjuk háromszögekre. Ezek a háromszögek és egy kép pontjai között kell leképezési módszert találnunk. Ez DirectX-ben nagyon egyszerű, a háromszög minden pontjához megmondjuk, hogy a textúra melyik pontja esik rá. Ehhez csupán a textúra-koordinátarendszert kell ismerni. A textúra egy kép, azaz egy téglalap. A téglalap bal felső sarka az origó, a két, ebből a pontból kiinduló oldalak pedig a bázisvektorok. Azaz a jobb felső sarok az (1,0), a balalsó sarok pedig a (0,1) pont:

Mivel a textúrák mérete nem egységes, be kellett vezetni egy egységes rendszert, amelyben és UV értékei 0 és 1 között mozognak. A DirectX-ben megengedett a mintakoordináták határértékeinek a túllépése. Azon értékek esetében, amelyek a [0,1] intervallumon kívül esnek, az éppen beállított szabály lép életbe. Megadhatjuk, hogy a minta egész koordinátaérték túllépésekor tükröződjön, ismétlődjön stb.

Hárdkódolás: Textúra betöltés

Az elmélet után vegyünk egy nagy levegőt és vágjunk bele a megvalósításba. Az első és egyik legfontosabb dolog a megfelelő vertexformátum kialakítása:

  [StructLayout(LayoutKind.Sequential)]
 struct Vertex
 {
     public Vector3 Position;
     public Vector2 Texture;
     public static readonly VertexFormat Format = VertexFormat.Position | VertexFormat.Texture1;
     public static readonly int Stride = Marshal.SizeOf(typeof(Vertex));

     public Vertex(float x, float y, float z, float u, float v)
     {
         Position = new Vector3(x, y, z);
         Texture = new Vector2(u, v);
     }
 }

Ez azt jelenti, hogy a vertexeink természetesen transzformálatlanok, és egyetlen textúrát akarunk rá kifeszíteni (nincs jelenleg multitextúrázás). Több textúra használatáról majd később. A Stride a Vertex struktúra méretét tárolja, később még szükség lesz, mivel bevezetjük majd a Vertex Buffer fogalmát. Most azonban egyenlőre maradjunk a textúrázásnál.
A textúrához felhasználni kívánt képet a SlimDX-ben a Texture.FromFile() metódus felhasználásával tölthetjük be, ami a következő paramétereket várja: device a DirectX eszköz, fileName a betöltendő kép neve, usage a használat körülményeit rögzíti, míg a pool a memóriakezelést állítja be. A függvény a .bmp, .dds, .dib, .hdr, .jpg, .pfm, .png, .ppm, és .tga típusú képeket tud feldolgozni:

Texture texture = Texture.FromFile(device, "directx.png", 0, Pool.Managed);

A textúrák megjelenítését szűrők alkalmazásával finomíthatjuk. A következő két sor egy anizotróp nagyító, illetve kicsinyítő szűrőt állít be, amelyeket az első (nulla indexű) megjelenítési szakaszban alkalmazunk:

device.SetSamplerState(0, SamplerState.MinFilter, TextureFilter.Anisotropic);

device.SetSamplerState(0, SamplerState.MagFilter, TextureFilter.Anisotropic);

Megjelenítéskor a létrehozott textúrát hozzárendeljük a mintavételezési szakaszhoz (sampler stage) a SetTexture() hívással: device.SetTexture(0, texture);

A textúrázott kockát az OnResourceLoad() metódusban töltjük fel, csak itt a színek helyett a textúrakoordinátákat adjuk meg a pozíció mellett:

data = new Vertex[]
{
// elülső oldal
new Vertex(-1.5f, +1.5f, -1.5f, 0, 0),
...

Ezzel tulajdon képen végeztünk is a textúrázással, a részletek a mintakódban megtalálhatóak. Persze, nagyon nagy ez a téma, és itt csak az alapokat beszéltük át. Most viszont ismerkedjünk meg a Vertex Buffer fogalmával, mivel nélküle elképzelhetetlen a hatékony renderelés.

Hárdkódolás: Vertex buffer

A vertex buffer egy olyan tároló, persze a memóriában, mely a vertex adatokat tárolja. A Direct3D ezt használja adatfolyamként, azaz ebből veszi ki a vertexeket sorrendben. Ezért fontos ismernünk a vertex buffer létrehozási módját, illetve feltöltését. Tehát nézzük, hogy kell létrehozni egy vertex buffert. Nyilván kell egy buffer:

private VertexBuffer vertices;

Ezt kell most létrehoznunk:

vertices = new VertexBuffer(device, 36 * Vertex.Stride, Usage.WriteOnly, Vertex.Format, Pool.Managed);

Itt csupán a paramétereket kell megbeszélni. Ez első paraméter a DirectX eszköz, amit létrehoztunk. A következő a természetesen a vertex buffer mérete, ami a vertexek száma és a Vertex struktúra méretének szorzata. Mivel egy kockát jelenítünk meg ezért 36 vertexre van szükség. A következő paraméter általánosan a használat körülményeiről szól. Komoly optimalizálást jelenthet a csak írható puffer létrehozása, amelyet az Usage.WriteOnly jelez. Ezáltal közöljük a rendszerrel, hogy csak is írni fogunk az adott buffer memóriaterületére, ami lehetővé teszi az írás és képszintézis szempontjából optimális memóriaterület kiválasztását. A következő paraméter a tárolt vertexek típusát adja meg, ezt tudni kell a tárolás módja miatt. A Pool.Managed a memóriakezeléssel kapcsolatos (hova rakja a buffert), ilyenkor a DirectX automatikusan abba a memóriába menti a vertexeket, amihez hozzáfér (általában a rendszermemória). Most már csak fel kellene tölteni a buffert. Ezért először a buffer címe kell, amit a Lock paranccsal tudjuk lekérni (illetve ez engedélyezi az írást illetve olvasást, mivel a Lock és az Unlock között lezárjuk a memóriát, kívülről nem elérhető). Ehhez létrehozunk egy DataStream objektumot és zároljuk a buffert:

DataStream stream = vertices.Lock(0, 0, LockFlags.None);

Az első paraméter azt adja meg, hogy hányadik bájttól kezdve akarjuk zárolni, a második pedig azt, hogy onnantól kezdve mekkora területet (bájtokban). Ez mindkettő 0, hiszen ekkor az egész buffert zárolja. Az utolsó paraméter a zárolás módját jellemzik, flagek, nekünk most nem kell. Ekkor a data tömbben tárolt vertexeket át kell ide másolni: stream.WriteRange(data);
Ezután lezárjuk a buffert: vertices.Unlock();
Kész is lennénk, már csak meg kell jeleníteni. Ez a vertex buffer-es módszer azért jó, mert sokkal gyorsabb, mint sima tömbből töltögetni be a vertexek adatait, illetve az adatfolyamban a típusigazítás is gyorsít. A következő beállítandó az aktuális adatfolyam, amelyből a vertexeket kivesszük:

device.SetStreamSource(0, vertices, 0, Vertex.Stride);

Az első paraméter az adatfolyam száma, azaz ezt állítjuk be. Alapértelmezésben a 0 aktív. Ez azért jó, mert több adatfolyamot egyszerre beállíthatunk, majd azt megjelenítésnél gyorsan váltogathatjuk a SetStreamSourceFreq() függvénnyel, de ez most nem fontos. A következő annak a vertexbuffernek a mutatója, amelyikhez akarjuk kötni az adatfolyamot, ez nyilván az előbb létrehozott bufferünk, benne a háromszögek pontjaival. A következő paraméter egy eltolás paraméter, azaz honnan kezdődnek az adatfolyamban a vertexek adatai (bájtokban). Ezt nem is biztos, hogy támogatja az eszköz. Az utolsó paraméter FVF vertexeknél egy vertex mérete, ugyanis ekkora „adagokban” kapjuk a vertexeket. Most pedig jön az érdemi rajzolás, méghozzá a

device.DrawPrimitives(PrimitiveType.TriangleList, 0, 12);

függvénnyel. Ez most különálló háromszögeket rajzol. Ez a függvény az aktuális adatfolyamban található, második paraméterben megadott sorszámú vertextől kezdődően rajzol annyi primitívet, ahányat az utolsó paraméterben megadtunk. Vertex Buffer használata esetén a DrawPrimitives függvény használatos a DrawUserPrimitives helyett. Most már nincs más hátra, mint letölteni a példa forrását és gyönyörködni a textúrázott objektumokban: DOWNLOAD

Textúrázott kockák...

Ezzel a végére is értünk a mai SlimDX anyagnak és egy nagy lépést tettünk a hatékony és látványos DirectX alkalmazások felé. A bejegyzés megírásában nagy segítségemre voltak Nyisztor Károly DirectX-el kapcsolatos könyvei.

Ilyen volt a Windows 1.0

Az eredeti sajtóközlemény és egy rövid videó a Windows 1.0 előnyeiről. A program 1985. november 20-án jelent meg.
1985. november 20-án jelent meg egy apró program PC-kre, a neve Windows Premiere Edition.1 volt. A többi történelem, a Microsoft a világ egyik legnagyobb vállalata, alapítója Bill Gates pedig a világ leggazdagabb embere. Most a Windows 7 a legújabb verzió a Microsoft operációs rendszeréből.

A Microsoft egyik vezetője, Ray Ozzie találta meg a dolgozószobájában az első Windowsról az akkor kiadott sajtóanyagot és úgy döntött, hogy nyilvánosságra hozza a dokumentumokat. Az eredeti szövegből egy részlet:

A Microsoft Windows kiterjeszti a DOS operációs rendszert, valamennyi most létező alkalmazással kompatibilis. A Windows segítségével egyszerre több programmal is lehet dolgozni egyidőben, könnyen válthatunk köztük anélkül, hogy újra kelljen indítani az adott programot. Emellett sok új generációs alkalmazást is kínál.

lica

Sajátmárkás grafikus kártyákat ad ki az Nvidia

Az Nvidia mindeddig csak más gyártók számára szállított grafikus chipeket videókártyákba vagy alaplapba ill. notebookba építéshez, saját maga azonban nem volt jelen a szóban forgó termékek piacán. Ez azonban a múlté - a jelek szerint ugyanis a videóchipek piacát uraló gyártó hamarosan sajátmárkás videókártyákkal fog megjelenni a piacon.

A doboz már külsőre is elüt a többi gyártó termékeitől...

A HardOCP magazin egyik munkatársának sikerült az Egyesült Államokban a népszerű Best Buy elektronikai áruházlánc egyik üzletében kiszúrnia, megszereznie és letesztelnie az Nvidia sajátmárkás videókártyáinak egyik első példányát. A termékről a chipgyártó képviselője a megkeresére elárulta, hogy valóban egy eredeti Nvidia videókártyáról van szó, amely azonban valamiért a hivatalos bejelentés előtt jelent meg az áruház polcain.

Az egyébként igen igényes és jól tervezett dobozban érkező kártyákat ugyan nem maga az Nvidia gyártja - hiszen ehhez nincsenek megfelelő gyárai -, de az ő márkaneve alatt jelenik meg, és ő is biztosítja a támogatást is a termékekhez. A kártyákra a gyártó ráadásul 3 év garanciát vállal, ami legalább egy évvel több a más gyártók által a hasonló modellek esetében vállaltnál.

... de belsejében is ízig-vérig Nvidia.

A magazin beszámolója szerint ugyan a boltban látott Nvidia kártyák nem voltak a legolcsóbbak (a GTX 460-as változat például 300 dollárba, azaz közel 60.000 forintba került), de gyakorlatilag egy árszintet képviseltek a professzionális márkát képező PNY azonos chipre épülő termékeivel, ami azt jelenti, hogy - tekintve a kártya igényes kivitelét és az árban foglalt gyártói támogatást is - nem tekinthetők túlárazottnak sem.

Még a Platinum támogatási fokozatban is 3 év gyártói garancia jár mellé

Az még egyelőre kérdéses, hogy az Nvidia pontosan melyik szegmensekben és mely piacokon fog sajátmárkás termékeivel megjelenni, de ezzel kapcsolatban a cég képviselője jövő hétre ígért részletetek egy hivatalos bejelentés keretében.

Sting

Nyílt forrású csomagkezelőt adott ki a Microsoft

A Microsoft szerdán jelentette be NuPack nevű nyílt forrású csomagkezelő rendszere egy előzetes változatának elérhetőségét. A .NET alapú projektekhez használható "package manager" szoftver célja, hogy egyszerűvé tegye a fejlesztők és a felhasználók számára az alkalmazásokban felhasználható nyílt forrású könyvtárak megkeresését, telepítését és beüzemelését a Windows rendszereken.

"A NuPack-kal az a célunk, hogy olyan egyszerűvé tegyük a nyílt forrású könyvtárak integrálását a .NET projektkbe, amennyire csak lehet", közölte Scott Guthrie a csomagkezelőt bemutató blogbejegyzésében, amely szerint egyébként a NuPack-nak a Microsoft jövőben központi szerepet kíván szánni a .NET platformon. Ez utóbbi többek között azt jelenti, hogy az új csomagkezelő natív támogatást fog kapni a Visual Studio fejlesztőrendszerben, amely automatikusan képes lesz az elkészült szoftvereknek megfelelő csomagok legenerálására.

A NuPack csomagkezelő minden Visual Studio változatba be fog kerülni

A NuPack lehetőséget ad a fejlesztők számára, hogy azok alkalmazásaikat egy központi tárházba (repository) regisztrálják, amit más fejlesztők szabadon kereshetnek, illetve a bennük elhelyezett könyvtárakat letölthetik és beépíthetik saját alkalmazásaikba. A csomagkezelő nem a könyvtár részét képező kódokat tölti le, de az által igényelt esetleges függőségeket is, amelyeket természetesen automatikusan kezel a rendszer.

További részletek és dokumentáció itt.

Sting

SlimDX9 05 - A csúcspontformátum megadása

Most már, hogy túl vagyunk pár példán észrevehettük, hogy a használt vertex struktúrát mindig az éppen aktuális feladathoz igazítottuk. Ez azért tehettük meg, mert a DirectX a vertexek attribútumait leíró rugalmas vertex formátumot használja (Flexible Vertex Format, FVF) a csúcspontok leírásához.

Egy csúcspontot a háromdimenziós térben egy koordináta számhármassal írhatunk le. Valójában azonban ennél sokkal több információra van szükség ahhoz, hogy a vertexek adatain valóban hasznos és főleg látványos műveleteket tudjunk végrehajtani.
A pozíción kívül számos egyéb paramétere lehet a geometriát leíró csúcspontnak. Az attribútumok számossága és típusa aszerint változik, hogy milyen vizuális hatást szeretnénk elérni. A pozíción kívül a normálvektor, a színérték, a pontméret, az emisszív fény színe, a textúra koordináta, stb. is nagyon fontos lehet. A szükséges jellemzőket a fejlesztők szabadon állíthatják be a Direct3D rugalmas vertex formátumán keresztül.
Az FVF használatával saját csúcspontformátumot alkothatunk, úgy, hogy a használt tulajdonságokat egy sor különböző jellemző vagy (|) kapcsolatával rögzítjük. A vertex leíráshoz felhasználható jellemzőket a következő ábra mutatja be:

DirectX Flexible Vertex Format (FVF)

A SlimDX-ben a VertexFormat felsorolás tagjai közül kerülnek ki a felhasznált jellemzők. A jellemzőket pedig a logikai vagy kapcsolat segítségével kapcsolhatjuk össze. A vertex leírása során a sorrend mindig nagyon fontos, ezért erre különösen figyeljünk.
Minden ilyen rugalmas vertex formátumhoz tartozik egy struktúra, a textúrázáshoz a következő szükséges minimálisan:

    [StructLayout(LayoutKind.Sequential)]
   struct Vertex
   {
       public Vector3 Position;
       public Vector2 Texture;
       public static readonly VertexFormat Format = VertexFormat.Position | VertexFormat.Texture1;
       public static readonly int Stride = Marshal.SizeOf(typeof(Vertex));

       public Vertex(float x, float y, float z, float u, float v)
       {
           Position = new Vector3(x, y, z);
           Texture = new Vector2(u, v);
       }
   }

Ez azt jelenti, hogy a csúcspontjaink természetesen transzformálatlanok, és egyetlen textúrát akarunk rájuk kifeszíteni (nincs jelenleg multitextúrázás). Több textúra használatáról majd később. A Stride a Vertex struktúra méretét tárolja, később még szükség lesz rá, mivel lassan bevezetjük a Vertex Buffer fogalmát is.
Remélem sikerült mindenkinek megérteni az FVF működését és mindenki képes lesz saját vertex formátumát megalkotni.

SlimDX9 04 - Anyagok és fényvisszaverődés

Legutóbb láttuk, hogy megvilágítással és fényhatásokkal jelentősen növelhetjük a megjelenített objektumok valóságosságát. Ehhez most hozzávesszük még az anyagtulajdonságokat, hogy még látványosabb hatásokat érjünk el. Az anyagok segítségével befolyásolhatjuk a beeső fény viselkedését. A SlimDX-ben a Material struktúra használható anyagok létrehozására. Adattagjain keresztül beállíthatjuk az anyag által visszavert fény tulajdonságait. A következő komponensek állnak rendelkezésre:

• Diffuse (Color4): a terjedő fényvisszaverődést (diffuse light) határozza meg. Szórt megvilágítás és matt felületek esetében találkozhatunk a diffúz fényvisszaverődéssel.
• Ambient (Color4): ez a komponens a szórt fény visszaverődését határozza meg adott anyaggal bevont felületről . A szórt fény mindenütt jelen van.
• Specular (Color4): a fényfolt-visszaverődés jellemzőit állíthatjuk be általa. A sima, csiszolt felületekre az jellemző, hogy fény hatására fényes foltok képződnek rajtuk.
• Emissive (Color4): ezzel az adattaggal a sugárzó felületek jellemzőit állíthatjuk be. A sugárzó felületek saját fényt bocsátanak ki, amelyet a színe jellemez.
• Power (float, értéke [0,∞]): a komponenssel állíthatjuk be a fényfolt visszaverődés mértékét, minél nagyobb az értéke, annál élesebb és kisebb, míg kisebb értékek esetében elmosottabb és nagyobb kiterjedésű fényfoltot kapunk.
  

A DirectX-ben az anyag (material) gyakorlatilag a felületek fényvisszaverő, illetve fénykibocsátó tulajdonságait határozza meg. Gyakorlati példánkban három kockát jelenítünk meg, amelyeket a következő, egymástól eltérő anyagokkal látunk el:

• téglaszerű, vörös, matt anyag, amely csak a terjedő fényt veri vissza;
• sárga, erősen fényfolt visszaverő anyag;
• ezüstös anyag, csillogó felület mintázására.
  

Az anyagokat a következő módon deklarálunk:

Material gRedMaterial, gYellowMaterial, gWhiteMaterial;

Az anyagok inicializálását a void InitMaterials() függvény végzi. Elsőként a téglaszerű anyagot definiáljuk:

gRedMaterial = new Material()
{ Diffuse = new Color4(1.0f, 1.0f, 0.5f, 0.2f) };

Csak a Diffuse komponenst állítjuk, ezáltal az anyag csak a terjedő fényt fogja visszaverni, tehát matt felületű lesz. A következő anyag sárga, erősen fényfolt visszaverő:

          gYellowMaterial = new Material()
         {
             // terjedő fényvisszaverődés beállítása
             Diffuse = new Color4(1.0f, 0.5f, 0.5f, 0.0f),
             // szórt fény visszaverődésének beállítása
             Ambient = new Color4(1.0f, 1.0f, 1.0f, 0.5f),
             // fényfoltvisszaverődés
             Specular = new Color4(1.0f, 1.0f, 1.0f, 0.0f),
             // éles, kis kiterjedésű fényfolt
             Power = 80
         };

Mivel minden egyes komponens esetében a vörös és zöld értékei érvényesülnek, végeredményül egy sárga anyagot kapunk. A Power érték kis kiterjedésű fényfoltot eredményez. A harmadik anyag ezüstös, csillogó anyagot, ezért a terjedő és fényfolt képző komponenseken van a hangsúly:

          gWhiteMaterial = new Material()
         {
             // terjedő fényvisszaverődés beállítása
             Diffuse = new Color4(1.0f, 0.3f, 0.3f, 0.3f),
             // szórt fény visszaverődésének beállítása,
             // ezüstös anyag, teljes mértékben visszaveri a környezet fényeit
             Ambient = new Color4(1.0f, 1.0f, 1.0f, 1.0f),
             // sugárzó anyag
             Emissive = new Color4(1.0f, 0.4f, 0.4f, 0.4f),
             // fényfoltvisszaverődés
             Specular = new Color4(1.0f, 1.0f, 1.0f, 1.0f),
             // kiterjedtebb fényfolt
             Power = 15
         }

A jobb hatás érdekében ezüstös anyagunk saját fénnyel is rendelkezik, amely fokozza a ragyogást, a Power kisebb értéke pedig nagyobb fényfoltot eredményez. Természetesen a visszavert fényhez szükség van fényforrásra is. Ehhez létrehozunk egy direkcionális fényforrást, továbbá engedélyezzük a fényfolt képződést. Először is definiáljuk a fényforrás irányát, ami egy vektor lesz:

Vector3 dirVec = new Vector3(2.0f, 2.0f, -5.0f);

Normalizáljuk az irányvektort: dirVec.Normalize();

Ezután a Light struktúrát feltöltjük:

          Light light = new Light()
         {
             Type = LightType.Directional,
             Direction = dirVec,
             Diffuse = new Color4(1.0f, 1.0f, 1.0f, 1.0f),
             Ambient = new Color4(1.0f, 0.1f, 0.1f, 0.1f),
             Specular = new Color4(1.0f, 1.0f, 1.0f, 1.0f),
         };

Mivel egy direkcionális fényforrást szeretnénk létrehozni – itt az irány és a szín adott, azonban a forrás helyzete nem meghatározott –, ezért kizárólag csak a típusát, az irányát, a diffúz és a fényfolt képző adattagokat kell beállítani. Ahhoz, hogy fényfoltok képződjenek, engedélyezni kell azt a következő hívással:

device.SetRenderState(RenderState.SpecularEnable, true);

A fényfolt képzés elég számításigényes feladat, éppen ezért alapból nincs is engedélyezve. A fenti beállításokon kívül természetesen még be kell kapcsolni a megvilágítást valamint meg kell adni a kockák felületeinek normálvektorait is. Ehhez, most is definiálunk egy saját vertex formátumot, amely a vertex koordinátákon kívül tartalmazza a normálvektorokat is:

  [StructLayout(LayoutKind.Sequential)]
 struct Vertex
 {
     public Vector3 Position;
     public Vector3 Normal;
     public static readonly VertexFormat Format =
                            VertexFormat.Position | VertexFormat.Normal;

     public Vertex(float vX, float vY, float vZ,
                   float nX, float nY, float nZ)
     {
         Position = new Vector3(vX, vY, vZ);
         Normal = new Vector3(nX, nY, nZ);
     }
 }

A kockánkat pedig az OnResourceLoad() metódus fogja megvalósítani, amiben meghívjuk a InitMaterials() metódust és feltöltjük a vertices tömböt:

      private void OnResourceLoad()
     {
         InitMaterials();

         vertices = new Vertex[]
         {
              // elülső oldal
              new Vertex(-1.5f, +1.5f, -1.5f, 0, 0, -1),
              new Vertex(+1.5f, +1.5f, -1.5f, 0, 0, -1), 
              new Vertex(-1.5f, -1.5f, -1.5f, 0, 0, -1),
              new Vertex(-1.5f, -1.5f, -1.5f, 0, 0, -1),
              new Vertex(+1.5f, +1.5f, -1.5f, 0, 0, -1), 
              new Vertex(+1.5f, -1.5f, -1.5f, 0, 0, -1),

              // jobb oldal
              new Vertex(+1.5f, +1.5f, -1.5f, +1, 0, 0), 
              new Vertex(+1.5f, +1.5f, +1.5f, +1, 0, 0),
              new Vertex(+1.5f, -1.5f, -1.5f, +1, 0, 0),
              new Vertex(+1.5f, -1.5f, -1.5f, +1, 0, 0),
              new Vertex(+1.5f, +1.5f, +1.5f, +1, 0, 0),
              new Vertex(+1.5f, -1.5f, +1.5f, +1, 0, 0),

              // hátsó oldal
              new Vertex(+1.5f, +1.5f, +1.5f, 0, 0, +1),
              new Vertex(-1.5f, +1.5f, +1.5f, 0, 0, +1),
              new Vertex(+1.5f, -1.5f, +1.5f, 0, 0, +1),
              new Vertex(+1.5f, -1.5f, +1.5f, 0, 0, +1),
              new Vertex(-1.5f, +1.5f, +1.5f, 0, 0, +1),
              new Vertex(-1.5f, -1.5f, +1.5f, 0, 0, +1),

              // bal oldal
              new Vertex(-1.5f, +1.5f, +1.5f, -1, 0, 0),
              new Vertex(-1.5f, +1.5f, -1.5f, -1, 0, 0),
              new Vertex(-1.5f, -1.5f, +1.5f, -1, 0, 0),
              new Vertex(-1.5f, -1.5f, +1.5f, -1, 0, 0),
              new Vertex(-1.5f, +1.5f, -1.5f, -1, 0, 0),
              new Vertex(-1.5f, -1.5f, -1.5f, -1, 0, 0),

              // kocka teteje
              new Vertex(-1.5f, +1.5f, +1.5f, 0, +1, 0),
              new Vertex(+1.5f, +1.5f, +1.5f, 0, +1, 0),
              new Vertex(-1.5f, +1.5f, -1.5f, 0, +1, 0),
              new Vertex(-1.5f, +1.5f, -1.5f, 0, +1, 0),
              new Vertex(+1.5f, +1.5f, +1.5f, 0, +1, 0),
              new Vertex(+1.5f, +1.5f, -1.5f, 0, +1, 0),

              // kocka alja
              new Vertex(-1.5f, -1.5f, -1.5f, 0, -1, 0),
              new Vertex(+1.5f, -1.5f, -1.5f, 0, -1, 0),
              new Vertex(-1.5f, -1.5f, +1.5f, 0, -1, 0),
              new Vertex(-1.5f, -1.5f, +1.5f, 0, -1, 0),
              new Vertex(+1.5f, -1.5f, -1.5f, 0, -1, 0),
              new Vertex(+1.5f, -1.5f, +1.5f, 0, -1, 0),
         };
     }

Mivel a kocka ezen oldala felénk néz, normálvektora merőleges a képernyő síkjára, és kifelé – azaz a szemlélő felé – mutat, ezért koordinátái (x,y,z) formában (0,0,-1) . Ezt a logikát kell követni a többi oldal esetében is. Végezetül tekintsük meg az eredményt:

Anyagok + fények + transzformációk

A teljes forrás letölthető innen:

DOWNLOAD

A tutoriál írása során nagy hasznomra volt Nyisztor Károly: Grafika és játékprogramozás DirectX-szel c. könyve, amit mindenkinek nyugodt lelkiismerettel ajánlok!