2010. október 16., szombat

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.

2010. október 15., péntek

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.

2010. október 7., csütörtök

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

2010. szeptember 12., vasárnap

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.

2010. szeptember 2., csütörtök

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:


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!

2010. augusztus 28., szombat

2010. augusztus 27., péntek

Befutott a nyár utolsó Catalystja

Az AMD hivatalosan is elérhetővé tette a Catalyst legújabb kiadását, mely a Windows 7, Vista és XP operációs rendszereket támogatja. A 10.8-as verziójú, WHQL aláírással rendelkező drivercsomag a Radeon HD 2000, 3000, 4000 és 5000 szériás grafikus kártyákhoz, valamint a HD sorozatba tartozó Mobility és integrált Radeonokhoz telepíthető. Fontos megjegyezni, hogy a Toshiba, a Sony és a Panasonic nem engedélyezte a notebookokhoz tartozó terméktámogatást.
A driver a szokásos hibajavítások mellett, bevezeti az OpenGL ES 2.0-s kódok támogatását. A WebGL szabvány segítségével az erre felkészített böngészők képesek a háromdimenziós grafika gyorsítására. Ez különösen a HTML5 esetben lesz fontos, hiszen az új jelölőnyelv segítségével külső pluginek alkalmazása nélkül jeleníthető meg egy részletekben gazdag weboldal. Az AMD támogatása az összes Radeon HD szériás kártyán elérhető, továbbá Windows 7, Vista és XP alatt is működik.
A multimédiás szolgáltatások is javultak. Az új meghajtóban beállított fejlett videobeállítások mostantól alkalmazhatók az internetes videókon is. Itt érdemes megemlíteni, hogy Windows XP alatt nem érhető el az összes szolgáltatás, így a legjobb képminőség eléréséhez Windows 7 vagy Vista szükséges. A játékok szempontjából a StarCraft 2 hivatalosan is megkapta az élsimítás támogatást, továbbá az alkalmazásprofilokon keresztül növelhető a CrossFireX rendszerek teljesítménye az Eyefinity konfigurációk esetén. Pár programban kisebb sebességnövekedésekre is lehet számítani. Az AMD három játék erejéig kimérte a változásokat, amiket az alábbi felsorolás részletez:
  • Far Cry 2 – akár 2-6% Radeon HD 5700-5800 sorozat esetén és +3-8% HD 4800 mellett
  • Left 4 Dead 2 – akár 3-5% Radeon HD 5700-5800 sorozat esetén
  • Stormrise – akár 5-10% Radeon HD 5500-5600 sorozat mellett
Az augusztusi Catalyst szoftvercsomag és a hozzá tartozó dokumentáció, valamint a legfrissebb alkalmazásprofil letölthető az AMD szerveréről. A mobil termékek esetében ezt a weboldalt érdemes használni.

nakamichi

2010. augusztus 26., csütörtök

SlimDX9 03 - És legyen világosság…

Legutóbb ott hagytuk abba a SDX leckénket, hogy létrehoztunk egy csonka gúlát a háromdimenziós térben és megforgattuk azt. Mivel nem definiáltunk normál vektorokat ezért a megvilágítást ki kellet kapcsolnunk, hogy valamit lássunk a gúlánkból. Persze fények nélkül a számítógépes grafika semmit sem ér, ezért most egy egyszerű példa segítségével belekóstolunk a fények világába.

Természetesen az első lépés a megvilágítás bekapcsolása, amit a következő sorral tehetünk meg:

device.SetRenderState(RenderState.Lighting, true);

A következő fontos dolog a megfelelő Vertex formátum megadása, ahol már helyet kapnak a normál vektorok is:
  [StructLayout(LayoutKind.Sequential)]
struct Vertex
{
public Vector3 Position;
public Vector3 Normal;
public int Color;
public static readonly VertexFormat Format = VertexFormat.Position | VertexFormat.Normal | VertexFormat.Diffuse;

public Vertex(float vX, float vY, float vZ, float nX, float nY, float nZ, int color)
{
Position = new Vector3(vX, vY, vZ);
Normal = new Vector3(nX, nY, nZ);
Color = color;
}
}
Ezután a modell létrehozása következik, ami ebben az esetben egy kocka. Itt a csúcspontok mellet, a normálvektorokat és a csúcspontok színértékét is megadjuk:
    private void OnResourceLoad()
{
int c1 = Color.Red.ToArgb();
int c2 = Color.Green.ToArgb();
int c3 = Color.Blue.ToArgb();

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

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

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

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

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

// kocka alja
new Vertex(-1.5f, -1.5f, -1.5f, 0, -1, 0, c3),
new Vertex(+1.5f, -1.5f, -1.5f, 0, -1, 0, c3),
new Vertex(-1.5f, -1.5f, +1.5f, 0, -1, 0, c3),
new Vertex(-1.5f, -1.5f, +1.5f, 0, -1, 0, c3),
new Vertex(+1.5f, -1.5f, -1.5f, 0, -1, 0, c3),
new Vertex(+1.5f, -1.5f, +1.5f, 0, -1, 0, c3),
};
}
A normálvektor egy olyan vektor, ami az adott háromszögre merőleges. Ennek ellenére normálvektort csak csúcsponthoz rendelhetünk hozzá.

Egy háromszög és a rá merőleges normál vektor

Ezután létre kell hozni egy fényforrást, ami jelen példánkban pontszerű lesz (Point light). A fényforrásokat a Light struktúra segítségével hozhatjuk létre:
           Light light = new Light()
{
Type = LightType.Point,
Range = 10000f,
Attenuation0 = 1f,
Diffuse = Color.White,
Position = new Vector3(-2, -2, +10)
};
A pontszerű fényforrás egyenletesen sugározz, a fény minden irányban haladhat. A pontszerű fényforrás definiálásakor meg kell adni a pozíciót (Position), a fény hatótávolságát (Range), valamint a fény intenzitásának távolsággal arányos csökkenését meghatározó együtthatót (Attenuation0, Attenuation1, Attenuation2). A létrehozott fényforrást be kell állítani:

device.SetLight(0, light);

Az első szám a Light Index, míg a második az index-el hivatkozható Light struktúra. Majd a beállított fényforrást engedélyezni kell:

device.EnableLight(0, true);

A fentieket a SetupLight() metódus foglalja össze:
       private void SetupLight()
{
device.SetRenderState(RenderState.Lighting, true);

Light light = new Light()
{
Type = LightType.Point,
Range = 10000f,
Attenuation0 = 1f,
Diffuse = Color.White,
Position = new Vector3(-2, -2, +10)
};

device.SetLight(0, light);
device.EnableLight(0, true);
}
Természetesen a fényekkel később ennél sokkal részletesebben fogunk foglalkozni, ez csak egy kis ízelítő belőle. A példa többi része már ismerős és könnyedén értelmezhető, eredménye pedig itt látható:


A teljes forrás pedig letölthető innen:


Most is meg kell jegyeznem, hogy Nyisztor Károly könyvei is sokat segítettek a bejegyzés írása közben.

2010. augusztus 24., kedd

Frissült az OpenCL platform

Az OpenCL platformot még 2008 végén mutatta be a Khronos Group, ám most elérkezett egy apróbb frissítés ideje. Az nyílt forrású 1.1-s felület a funkcionalitás területén javított, így jobb programozhatóság és nagyobb teljesítmény várható tőle.
A platform új adattípusokat vezet be, melyek közül a legfontosabbak a háromkomponenses vektorok, illetve az új képformátumok. Az 1.1-es felület jobb együttműködést garantál az OpenGL API-val, továbbá lehetőség lesz operációkat végezni egy puffer kijelölt terültén.


Az ARM és az AMD üdvözölte a bejelentést. Sőt az utóbbi vállalat elmondta, hogy a Fusion APU-k, illetve az ATI Streammel kompatibilis hardverek támogatni fogják a megújult felületet. Az NVIDIA még nem szólalt meg az OpenCL 1.1-gyel kapcsolatban, de nyilvánvaló, hogy dolgoznak az implementáláson, így a GeForce GTX 400 család is kezelni fogja a platformot.