Tech, szoftvertervezés és programozás

A hardveres Z-buffer aktuális tartaémát szeretném kezelni(olvasni, majd alkalmazásban számolni vele, és végül felülírni)

A BGI-t (igen, a borland-os, és itt lenne egy olyan kérdés, hogy ismersz-e olyan elérhető verziót, ami letölthető, van benne egérkezelés, és VSC++ -ban is használható ?, mert ami nekünk van, az egy bgi.a fájl, amit a VS nem képes kezelni, weben találtam egy másik változatot, de abban nincs egérkezelés, és sokkal lasabb a DevC++-által használt .a-s változatnál ) és a DirectX-et esezm ágában sincs keverni, de a gyakvezérünk azt mondta, h legyen benne a programban a z-buffer kezelés jól láthatóan, meg háromszög kirajzolás is valami növekményes módszerrel (ezt már lepötyögtem neki)

Az Engine deklarálása pedig a mainben van, és ahogy a hsz-ből ki vettem, vagy az egyke minta, vagy a gondos és szorgalmas #include marad. (valami még egyszerűbb (lustább megoldást kerestem), de most asszem elleszek azzal, ha mindent globálisként hozok létre, meg egy forrásállományba dolgozok, mert az osztályokból álló projektet nehéz átbűvölni devcpp-ba.

Szervusz Carlos!
Azt szeretném megkérdezni, hogy Visual C++-ban hogyan lehet több processzoron programozni? Sokat keresgéltem a neten, de általában olyanokat találtam, amik nem teljesen egyértelműek a számomra. Továbbá a Gyakorlati C++ c. könyvedben nem találtam ehhez leírást (de lehet, hogy bamba vagyok ).
Lenne egy másik kérdésem is. Az x86-os architektúrában vannak az MMX és az SSE kiterjesztések. Ehhez tudtommal assembly programozás kell, ami számomra annyira nem probléma. A kérdésem az volna (amihez egyáltalán nem találtam normális leírást), hogy igaz-e az az állítás, miszerint az x64-es arch. ezeket alapból tartalmazza, azaz nem szükséges külön SSE kódokat implementálni?
Az előbbiből egy harmadik kérdésem is eszembe jutott. Egy kódban milyen módosítások kellenek, ha 64 biten akarok directX programot fejleszteni?
Válaszodat előre is köszönöm.

Üdv Quantum!
A C++ önmagában nem támogatja a többszálú programozást, mivel az operációs rendszer szintű funkcionalitás. Az adott platform lehetőségeit az OS (Win, *nix, stb.) SDK-jából lehet kibogarászni (Windows esetében lásd MSDN).
Az MMX SSE kérdésben szinte biztos, hogy az újabb processzorok alapból támogatják, a 64 bitesekről nem is beszélve. A DirectX pl. eleve ki van optimalizálva, hogy felismerje és kiaknázza az MMX vagy a 3DNow! előnyeit.
Személy szerint még nem fejlesztettem 64 bites Windows-ra, úgyhogy többet nem tudok segíteni.

Köszönöm válaszodat.
Megpróbálom összeszedni a kérdésemet, mert most kicsit megkavarodtam.
Az, hogy a Cpp nem támogatja a többszálú programozást, azt a több magra értetted, vagy alapból a párhuzamos programozásra? Mert olyat már láttam, hogy külön szálakat lehetett programozni, amik egy processzoron párhuzamosan futnak, ilyennel a Java nyelvben is találkoztam.
Az MSDNA-n megtaláltam a "magosítást", build néven.
Ha játékot fejlesztek DirectX-ben, szükségem van-e arra, hogy szálakat kezeljek, vagy a DirectX automatikusan párhuzamosít? Gondolok itt arra, hogy külön szálon kell futnia pl. a renderelésnek, a mesterséges intelligenciának és a zenének is.

>> "Az, hogy a Cpp nem támogatja a többszálú programozást, azt a több magra értetted, vagy alapból a párhuzamos programozásra?"
A C++ *nem* támogatja a többszálú programozást. Azaz nem rendelkezik szabványos utasításokkal, amelyek a szálak menedzselését tennék lehetővé.
A Java az más, mivel az feltételezi a virtuális gépet (JVM), amely fegoldja a platformok közötti különbséget. Amolyan oprendszer az oprendszerben, aminek persze megvan az ára is mellesleg. A C++ forráskód szinten platformfüggetlen ugyan, de csak addig, ameddig nem teszünk bele platformfüggő API-hívásokat. Mivel a C++ fordító nem bytekódot generál, mint a Java, hanem végrehajtható állományokat, az alkalmazást minden egyes target-re (oprendszerre) le kell fordítani és linkelni ahhoz, hogy működjön. Másképp mondva egy Windows-os exe nem fog Linux alatt vagy Mac OSX-en futni.

A másik félreértést is tisztázzuk. A többszálú programozás forrás szinten nem különbözteti meg az egymagos vagy a többmagos processzorokat. Már a 80386-os is képes volt a multithreading-re, de kellett egy Linus Torwalds ahhoz, hogy ezt ki is aknázza. Persze a többszálú programozás valódi előnyeit többmagos vagy multiprocesszoros környezetben lehet igazán élvezni. De hangsúlyozom, fejlesztőként neked ez mindegy, az oprendszer valósítja meg az ütemezést / terhelésmegosztást. Azonban arra is fel kell készülni, hogy többszálú alkalmazások készítésekor újabb problémák merülnek fel, amelyekkel nem szembesülsz egy szál esetén. Ez a fórum kevés ahhoz, hogy a többszálú programozást részletesen kitárgyaljuk, elég haladó témakör, amivel számos könyv foglalkozik.
A DirectX nem párhuzamosít automatikusan, azonban egy extra paramétert meg kell adni ahhoz, hogy jelezd a keretrendszernek, hogy több szálat fogsz alkalmazni (legalábbis DX9 alatt). A szálak kezelését neked kell megvalósítanod, beleértve a szinkronizálást és egyéb nyalánkságokat. Szerintem egy egyszerűbb prototípussal kezdd, ne egyből egy játékban próbáld ki a többszálas programozást, ahol egyéb tényezők is bekavarhatnak.

Üdvözlet Mindenkinek!

Nekem 1 C++-al kapcsolatos kérdésem lenne:
Olvastam a könyvben, hogy egy osztályban lehet használni statikus adattagokat is.
Kipróbáltam, és egyszerű esetekkel működik is, ám ha memóriát szeretnék lefoglalni akkor problémákba ütközök.

Tehát ki tudna segíteni valaki, hogy az alábbi kódot hogyan lehet kijavítani:
class StaticClass {
public:
static int *p;
static void f() {
p = new int;
}
};
int StaticClass::*p=NULL;

int main()
{
StaticClass::f();
return 0;
}

A fordító üzenete:
1>Linking...
1>testcpp.obj : error LNK2001: unresolved external symbol "public: static int * StaticClass:" (?p@StaticClass@@2PAHA)
1>D:\cpp\testcpp\Debug\testcpp.exe : fatal error LNK1120: 1 unresolved externals