DirectX Vertex Darstellung

[neolithos]

In vielen Tut's und Bsp's wird IDirect3DVertex8, direct nach dem das Direct3D Interface erstellt wurde, erstellt.
Die Daten werden immer in einem extra Speicher gehalten und in der Render fkt in den Vertex-Buffer hineinkopiert.

Da bei diesem vorgehen Speicher verschwendet wird, folgende Fragen:

Ich verwendet derzeit den Vertex-Buffer als speicher, daher nur werden die Daten nur einmal gehalten, es gibt also keine Kopie davon, da ich die Daten direkt manipulire.

Kann das Probleme geben bzw. Wie muss der Vertex erstellt sein? Was bedeutet der Usage-Parameter (D3DUSAGE_WRITEONLY) genau?

Wann und wo werden die Vertexe benötigt, nur für DrawPrimitive oder auch für Present?

---------------------------------------------------------------------

Kennt jemand ne seite wo, etwas genaueres steht zu der ganzen geschichte!

[neolithos]

Wollte es nur nochmal in Erinnerung rufen.

[OregonGhost]

Du musst den IDirect3DVertexBuffer8 als Managed Resource erstellen, heißt bei der Erstellung gibst du als Pool D3DPOOL_MANAGED an. Dann übernimmt Direct3D die komplette Verwaltung, aber dafür ist er nicht so gut geeignet für dynamische Daten. Dafür müsstest du einen anderen Pool nehmen, und in dem Fall müsstest du immer, wenn ein Device Lost ist, die Daten neu reinkopieren. Genau das macht Direct3D aber auch im Managed Pool, nur halt automatisch. Das hängt damit zusammen, dass bei einem Device Lost das Gerät (heißt die Grafikkarte) ihren Speicher "verliert", in dem der Vertexbuffer seine Daten hält.

In jedem Fall ist es FALSCH, d.h. nicht gerade performanceträchtig, diese Kopieraktion in der Render-Funktion (oder in einer beliebigen anderen Funktion, die pro Frame aufgerufen wird) durchzuführen. Wenn du WRITE_ONLY nimmst, heißt das, du kannst die Vertices NICHT auslesen, musst sie also alle selbst erzeugen und kannst sie nicht verändern (sondern nur neu schreiben). Die Vertices werden bei DrawPrimitive benötigt. Dir muss im übrigen klar sein, dass es relativ ineffizient ist, ständig den Buffer zu locken etc. Beschreibe am besten nochmal genauer, was du mit den Vertices machen willst und wie und wann.

[neolithos]

Erst mal Danke für die ausführliche Antwort...

Da ich noch blutiger Änfänger bin hab ich mir einen kleinen Sternen-Himmel gebastelt (es sieht so aus als würde man aus dem Seitenfenster eines Raumschiffes schauen).

Es gibt n Ebenen mit m Sternen. Die Sterne auf einer Ebene bewegen sich unterschiedlich schnell.

Anz. Sterne = n + mn + m(n - 1) + ... + m1
Speicher = Anz. Sterne * 16 (x, y, z, color)

[n steht für frei wählbar]
[mn ist m indiziert durch n]

Die Menge an Daten immer kopieren war mir relativ lästig, vorallem gerinde Fps (wert's mal durchtesten).

Der Fehler Lost-Devices ist mir gestern auch untergekommen, doch weiß ich noch nicht genau wie ich damit umgehen soll, habe bis jetzt noch kein Tut. gefunden der diesen Fehler auswertet.

Weiterhin ist mir aufgefallen das meine Fps-raten viel zu gering sind. Bei wesentlich komplexeren Grafiken in Spielen, ist jene wesentlich geringer. Auch aus diesem Grund habe ich auch die Frage gestellt.

Meine Fps-Berechnung:
Init: Zähler nullsetzen, StartTime auf GetTickCount

iFrame-Zähler in Render-Funktion eröhen

Berechnung:
fps = 1000 * iFrame / (GetTickCount - StartTime)

sollte funktionieren oder?

[OregonGhost]

Dass du mit Lost Devices nicht umgehen kannst, ist natürlich ungünstig - ist aber ganz einfach, einfach mal im DX SDK unter Lost Devices nachgucken. Ist ein klein wenig Routine und gehört zu jedem Programm. Es ist auch kein richtiger Fehler, sondern deine Anwendung gibt halt ihren exklusiven Modus auf und verliert daher den Grafikkartenspeicher. Mit IDirect3DDevice8::Reset() musst du darauf reagieren.

Dein FPS-Zähler wird prinzipiell funktionieren. Alternativ kannst du auch die Zeit mit QueryPerformanceCounter in jedem Frame messen (das ist innerhalb des Frames eine praktische Sache). Der Kehrwert sind die aktuellen ("instant") FPS, wenn du es über längere Zeit mittelst, schwankt das auch nicht so stark.

Wie zeichnest du die Sterne? Als Textur? Oder einfach so als 3D-Objekt?

Du musst nicht unbedingt die Vertices bearbeiten, laut SDK sollte man wenn möglich immer Matrixtransformationen verwenden.

[neolithos]

Erstmal habe ich ein Orthogonales (2D) Koordinatensystem eingestellt.

Die Sterne werden in einem großen Vertex-Buffer gehalten.
Ein Stern stellt einfach nur ein Punkt dar.

Wie gesagt klein und einfach, dachte ich (jedenfalls in DOS war das so).
-> Info: ich überarbeite gerade alte DOS-Spielereien um ein wenig DX zu lernen.

Aber es gibt wie gesagt dieses kleinen Detail's.

---------

Ist überhaupt direktes kopieren in den BackBuffer bei großen Objekten sinnvoll/schnell oder lieber an der stelle ein Viereck erstellen mit Texture?

---------

Wie geh ich zur Zeit mit den Lost Devices um:
1. Ich zerstöre alle D3D-Objecte (Surface, Texturen, Vertexes, Texte außer Device)
2. Rufe Reset
3. Baue alles wieder auf

Ist das zuviel des guten?

---------

Langsam mach die ganze sache Spaß (lob @OregonGhost)!!! :bounce2:

[OregonGhost]

Ein Stern stellt einen Punkt dar?
Nimmst du Point Sprites, oder arbeitest du direkt auf dem Backbuffer?

Ich glaube in DOS war eine Menge anders als unter Windows und mit Direct3D ;c)

---

IMMER (egal wie groß) ein Viereck mit Textur erstellen. In einem anderen Thread (der war auch von dir, glaube ich (c; ) habe ich auf Tutorials auf gamedev.net hingewiesen, diese passen hier auch. Genau das empfehle ich auch: Nimm eine Textur, die einen oder mehrere Sterne enthält und rendere ein Viereck für jeden Stern.

Du brauchst dann nur vier Vertices im Vertexbuffer.
Diese bekommen Standardkoordinaten (z.B. (-1,-1;1,-1;-1,1;1,1)), die du mit Transformationsmatrizen auf das entsprechende Format bringst und auch an die richtige Stelle. Du nimmst auch Standardtexturkoordinaten (von 0,0 bis 1,1) und transformierst diese per Texturtransformationsmatrix so hin, dass der richtige Ausschnitt aus der Textur genommen wird.

Das hat nämlich einen Vorteil: Die Grafikkarte übernimmt den Löwenanteil der Arbeit. Zum Beispiel muss die CPU pro Stern jeweils zwei Matrizen berechnen, während die Grafikkarte dies pro Vertex machen muss (also acht). Mit Mipmapping wird auch der Rasterizer nicht mehr ganz so stark gefordert (stell's z.B. auf bilineare Filterung).

In Direct3D ist seit Version 8 eigentlich eine direkte Manipulation des Backbuffers nicht mehr vorgesehen.

---

Du musst bei einem Device Lost nur Objekte zerstören, die sich nicht im Managed Pool befinden. Wenn du so vorgehst, wie ich oben beschrieben habe, können sowohl der Vertexbuffer als auch die Textur im Managed Pool liegen. Wenn du weiterhin den Vertexbuffer ständig verändern willst, musst du ihn in den Default Pool schieben und ihm Dynamic Usage zuweisen. In dem Fall musst du ihn tatsächlich zerstören, dann das Device resetten und den Buffer neu erzeugen und füllen. Die Textur kann trotzdem im Managed Pool liegen, wenn du sie nicht bearbeiten willst.

Du brauchst eigentlich keinen Zugriff auf Surfaces. Folglich brauchst du eigentlich auch keine Surfaces zu zerstören. Ansonsten gilt dasselbe wie oben.

---

Wenn du noch Fragen hast (und ich bin sicher, du hast jetzt einige neue, auch wenn die alten beantwortet sind (c; ), dann frag' nur. Wenn du C++ lesen kannst, kann ich dir auch den Code von meinem Spriterenderer schicken, der macht genau das, was ich da oben beschrieben habe.

Die meisten Fragen beantwortet aber das DirectX SDK, insbesondere alles, was im DirectX Graphics -> Programming Guide steht...

--- und noch ein Addendum:

Wenn ich richtig verstehe, nutzt du den Vertexbuffer nur als Speicher für deine eigenen Routinen. Dafür ist er nicht gedacht. Er ist dafür gedacht, Vertices (d.h. die 3D-Punkte, die die Grafikkarte direkt rendern soll) darin zu speichern. Wenn eh' nur die CPU damit arbeitet, ist es effizienter, ein pimpfiges Array zu verwenden. Das gilt auch, wenn du meine oben beschriebene Methode verwenden willst - in den Vertexbuffer gehören dann die vier Eckvertices des Vierecks, die Koordinaten der Sterne (die ja nur punktförmig sind), hältst du besser in einem Array, denn aus ihnen musst du (sprich die CPU) ja die Matrizen errechnen. Die Farbe (die du auch in deinem Array speicherst) gibst du den Sternen übrigens, indem du den Texture Factor festlegst, und als Farboperation die Multiplikation der Texturfarbe mit dem Texture Factor angibst.

[neolithos]

Jeder Stern ist ein Vertex-Punkt.
In den Backbuffer kopier ich bei einen anderen Programm! Ich werde es aber jetzt anders machen.

------

Ich werde mich mal mit den X-Funtionen von D3D beschäftigen, denn das klingt ja nach dem Verfahren die ich zum Abitur gebraucht habe (Verschiebe zum Koordinatenursprung, rechne, Schiebe zurück).

------

Wenn die Teile im Manage Pool sind kann man sie anscheinend nicht mehr so richtig bearbeiten. Das ist mir bei einem Surface aufgefallen, von welchem ich einen DC geholt habe, das ging nur mit D3DPOOL_DEFAULT, jeder andere Wert führte zu einen Fehler. (DX9)

------

Die DirectX SDK hab ich schon zu genüge strabaziert, doch fällt mir immer wieder auf, das sie manchmal nicht Tief genug geht.

------

Ob C++, VO, Basic oder Pascal mir ist das Egal, denn wenn man eine Sprache kann, kann man die anderen wenigstens Lesen.
1. Übrigens es wäre nicht schlecht wenn ich mal ein etwas realitätsnahe Bsp hätte, denn der Programm aufbau macht mir noch Probleme.
2. Zweites wollte ich über DX auch mal wieder C++ Programmieren. Leider hab ich noch etwas scheu davor, da C++ leicht genau mit Datentypen und Interfaces ist (zum Freigeben muss man ja noch Release rufen).

------

Wöllte ich die Sterne als kleine Bildschchen auf den Schirm bringen müsste ich nach deiner Beschreibung einen Vertext-Buffer für 4 Vertex's haben, den ich sagen wir mal 350 mal befülle und mit DrawPrimitiv zeichne.

Code:

for(int iStern = 0; iStern < 350; iStern)
{
  xBuffer->Lock(  );
  befülle Vertexe
  Transformiere zur Position
  xBuffer->UnLock();
  xDevice->DrawPrimitive(D3DPT_TRIANGLESTRIP, 0, 4);
}

So ungefähr würde ich denken.

<- ich kann auch C++ (e bissle)

Weitere Fragen kommen bestimmt, aber erst nächste Woche!

[OregonGhost]

Zitat:

Ich werde mich mal mit den X-Funtionen von D3D beschäftigen, denn das klingt ja nach dem Verfahren die ich zum Abitur gebraucht habe (Verschiebe zum Koordinatenursprung, rechne, Schiebe zurück).

Im Prinzip ja ;c)
D3DX enthält lediglich Hilfsfunktionen, du kannst es natürlich auch ohne machen ;c)

---

Wozu brauchst du in einer Direct3D-Anwendung einen DC?

---

Das mit dem Vertexbuffer stimmt nicht. Du befüllst ihn EINMAL. Wenn du jetzt dein Sprite rendern willst, verschiebst du den Ursprung z.B. mit einer D3XMatrixTranslation an die jeweilige Stelle, rotierst und skalierst gegebenenfalls mit D3XMatrixScaling und D3DXMatrixRotation* und dann musst du noch eine Matrix erstellen, die auf der Textur den richtigen Bereich auswählt (also Translation + Skalierung), die du als Texturtransformationsmatrix Direct3D übergibst. Der Witz ist, der Vertexbuffer braucht von dir nie wieder angetastet zu werden (außer du willst ihn freigeben). Die Parameter für die Matrix-Funktionen sind also lediglich Größe und Position der Sterne, die du in einem Array hältst. Auf dieses Array kann die CPU wesentlich schneller zugreifen als auf einen Vertexbuffer.

[neolithos]

Ganz so versteh ich das nicht, denn ich habe ja 350 Sterne und nicht einen. Und ich wollte auch nich 350 VertextBuffer anlegen. Denn jeder Stern besitz nur die Eigenschaften X, Y und Helligkeit (12 Byte pro Stern). Genauso will ich nicht 350 mal das selbe Bild geladen haben, denn dann werden aus den 12*350 schnell mehr. Bei diesen Beispiel mag das nicht stören, aber ....

-----

Den DC-Hab ich für eine kleinen Info-Bereich benötigt.

mit CreateOffScreenSurface (D3DPOOL_DEFAULT) angelegt.

GetDC
Etwas reingemalt [Linen (DrawEdge) und Text (DrawText)]
ReleaseDC
<- was ich nur einmal mache

und dann immer wieder auf den Bildschirm gerendert.

-----

> Nenn mich verrückt :spin: ...

Kennst du noch das alte Train aus den 286-Zeiten von dem Russen.
Ich will es mal aus den gedächtnis neu entwerfen. Mal sehen! :freak: :lol:

Aber erst wenn ich jedes detail bei den Sternen begriffen habe. [Punkt]

[OregonGhost]

OK, ich erkläre es nochmal ganz langsam. Sozusagen zum Mitschreiben (aber es ist ja schon Text (c; ).

Du hast ein Array. In dem hältst du die Informationen über deine Sterne, also in deinem Fall X, Y und Farbe. In jedem Frame änderst du in diesem Array deine Sterne und nirgendwo sonst.

Wenn du jetzt renderst, erzeugst du für jeden Stern eine Transformationsmatrix und zusätzlich eine Texturtransformationsmatrix. Diese teilst du Direct3D mit. Dann sagst du Direct3D, es möge deinen Vertexbuffer zeichnen, in dem sich immer noch nur ein Rechteck mit Textur befindet. Die Matrizen erledigen alles übrige.
Pseudo-Code zum Rendern:

Code:

for (int i = 0; i < nStarCount; i++)
{
  D3DXMATRIX matTrans;
  D3DXMatrixTranslation(&matTrans, Stern[i].x, Stern[i].y, 0);
  m_pDevice->SetTransform(D3DTS_WORLDMATRIX, &matTrans);
  m_pDevice->DrawPrimitive(D3DPT_TRIANGLESTRIP, 0, 2);
}

Vorher musst du natürlich deinen Vertexbuffer als StreamSource gesetzt haben, und auch das FVF muss gesetzt sein. Es bleibt bei EINEM Vertexbuffer mit EINEM Rechteck. Ebenso muss die Textur und die Color Operation etc. geladen und gesetzt sein, aber eben auch nur EINMAL. Vielleicht musst du dir klarmachen, dass deine Sterne etwas mit deiner Physik selbst zu tun haben, der Vertexbuffer hingegen NUR fürs Rendern gedacht ist.

---

Wenn es dir nur um eine Textanzeige geht, solltest du dir ID3DXFont angucken, das ist voll hardwarebeschleunigte Textanzeige.

[neolithos]

Ist ja genial :hello: ! hab ich gleich mal gedruckt für zu Hause!

Weil du gerade mal da bist

Ist es möglich das 2D und das 3D Koordinatensystem zu mischen?

Grund:

2D-Menü mit Schaltern
3D-Animation

----

Danke für ID3DXFont hatte ich aber schon in der Kaffeepause gefunden! Man hat sonst nix zu tun :mrgreen:

[neolithos]

Delphi-Quellcode:

 D3DXMATRIX matTrans; 
  D3DXMatrixTranslation(&matTrans, Stern[i].x, Stern[i].y, 0); 
  m_pDevice->SetTransform(D3DTS_WORLDMATRIX(0), &matTrans); 
  m_pDevice->DrawPrimitive(D3DPT_TRIANGLESTRIP, 0, 2);

Aus probiert Läuft...

Nun hab ich etwas weiter geforscht, und dabei bin ich auf die Idee gekommen das ich alle Körper in Einheitsvertexes speichere (jede kannte des Quadrates ist eins Lang).

D3DXMatrixScaling kann ich die größe Manipulierenm doch wie kann ich Nachträglich die Position ändern (an Hand eines Vectors eine Verschiebung durchfühen).

D3DXMatrixTranslation und D3DXMatrixScaling erstellen ja neue Matrizen.

Wobei die nöchste frage warum D3DXMatrix 4x4 Werte hat?

[OregonGhost]

Du musst IMMER die Matrizen in folgender Reihenfolge multiplizieren:

Skalierung * Rotation * Translation

Ich zeige dir hier mal den Render-Code von meinem Spriterenderer in stark verkürzter (Pseudo-)Form:

Code:

   // Matrices for positioning, rotation and scaling
   D3DXMATRIX matTemp, matPosition, matRotation, matScaling;
   D3DXMatrixIdentity(&matTemp);

   // Dimensions in Pixel space
   float fWidth = csi.fWidth * cti.sSize.cx;
   float fHeight = csi.fHeight * cti.sSize.cy;
   
   x -= (fScaleX - 1.0f) * fRotationCenterX * fWidth;
   y -= (fScaleY - 1.0f) * fRotationCenterY * fHeight;

   D3DXMatrixScaling(&matScaling, fScaleX * fWidth / 100.0f, fScaleY * fHeight / 100.0f, 1.0f);
   matTemp = matTemp * matScaling;

   // Rotation (done only if wanted)
   if (fRotationAngle != 0.0f)
   {
      D3DXMatrixRotationZ(&matRotation, fRotationAngle);
      matTemp = matTemp * matRotation;
   }

   // Bias for texel -> pixel matching
   x -= 0.5f;
   y -= 0.5f;

   // Translation
   D3DXMatrixTranslation(&matPosition, x - m_sScreen.cx / 2 - fRotationCenterX * fWidth, m_sScreen.cy - y - m_sScreen.cy / 2 + fRotationCenterY * fHeight, 0.0f);

   matTemp = matTemp * matPosition;

   m_pDevice->SetTransform(D3DTS_WORLD, &matTemp);

   // Set modulation color and texture if not the same as in the previous call
   if (m_clLastColor != clColor)
   {
      m_pDevice->SetRenderState(D3DRS_TEXTUREFACTOR, clColor);
      m_clLastColor = clColor;
   }
   if (m_nLastTextureIndex != nTextureIndex)
   {
      m_pDevice->SetTexture(0, m_pInfos[nTextureIndex].ppTextures[0]);
      m_nLastTextureIndex = nTextureIndex;
   }

   // Texture Coordinate Transformation
   D3DXMatrixScaling(&matScaling, csi.fWidth, csi.fHeight, 1.0f);
   D3DXMatrixIdentity(&matPosition);
   matPosition._31 = csi.fLeft;
   matPosition._32 = csi.fTop;
   
   matTemp = matScaling * matPosition;

   m_pDevice->SetTransform(D3DTS_TEXTURE0, &matTemp);

   HRESULT hr = m_pDevice->DrawPrimitive(D3DPT_TRIANGLESTRIP, 0, 2);
   return hr;

In Delphi kannst du übrigens, wenn ich mich nicht irre, die Matrizen nicht direkt multiplizieren, sondern musst den Umweg über D3DXMatrixMultiply etc. gehen.
Copy&Paste würde ich dir nicht empfehlen, weil zum einen eine ganze Menge fehlt, und du zum anderen so viele Variablen etc. neu definieren müsstest, dass du schneller zum Ziel kommst, wenn du alles selbst schreibst ;c) Aber vielleicht ist das ganze so etwas anschaulicher.

Klar kannst du 2D und 3D mischen. Wenn du 2D rendern willst, nimmst du halt ein orthogonales Koordinatensystem, wenn du 3D rendern willst, ein perspektivisches. Geht alles über Welt-/Ansicht-/Projektionstransformation.

Warum die Matrizen 4x4 sind, kann ich dir gar nicht so genau sagen, aber das steht, wenn ich nicht irre, im DirectX SDK ;c)

[edit=Daniel B]Delphi-Tags korrigiert. Mfg, Daniel B[/edit]
[edit=Daniel B]Code-Tags wieder eingefügt. :mrgreen: Sorry. Mfg, Daniel B[/edit]

[neolithos]

Ich bin derzeit von den Sternen weg, und wittme mich einem DOS-Spiel, welches ich von 8 Jahren geschrieben habe (Snake). Die Funktionalität steht schon. Bloß mit dem Zeichnen haberts noch.

Mit deinem Spriterender klappt es bei mir noch nicht drumm dachte ich schick ich dir per PM ein paar code-schnipsel, vielleicht siehst du ja, woran es liegen könnte, warum der müselig gemahlte Apfel nicht dargestellt wird, sonder die vollständige Texture. Mit den einfachen Texturen klappt es ja schon gut.

Kann man Teile der Texture Transparent darstellen?

Ich bin für kritik am Quellcode noch völlig hoffen!

Falls du das ganze Project für die Analyse brauchst sag bescheit.

[OregonGhost]

Ich schau's mir an, aber garantiere dir nicht, dass es sofort was wird ;C)

Du kannst Teile der Textur transparent darstellen. Dazu hast du zwei Möglichkeiten:
1. Du speicherst und lädst die Textur mit Alphakanal. Optimal hierfür geeignet sind die Formate TGA (unkomprimiert) und PNG (verlustfrei komprimiert), die D3DX unterstützt.
2. Die D3DXCreateTexture*-Funktionen (zumindest alle mit "Ex" am Ende) unterstützen das Angeben einer transparenten Farbe. Diese wird dann beim Laden durch völlige Transparenz (Alphakanal = 0) ersetzt.

@Daniel B.: Wozu Delphi-Tags? Es handelt sich um C++-Code, und so werden die Blöcke als Kommentare angezeigt ;c)

EDIT:
Kann sein, dass ich es gefunden habe. Du musst Direct3D noch mitteilen, dass du Texturtransformationen angeben willst. Ich habe mich da etwas am Design von ID3DXSprite orientiert: Es gibt eine Begin-Funktion, die diese Initialisierungen durchführt, und eine End-Funktion, die die Änderungen rückgängig macht, und dazwischen muss man halt rendern. Ist halt wegen Effizienz und so...
So etwas muss also noch rein:

Code:

m_pDevice->SetTextureStageState( 0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT2);

Außerdem empfehle ich, den CLAMP-Modus zu aktivieren:

Code:

m_pDevice->SetSamplerState( 0, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
m_pDevice->SetSamplerState( 0, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
m_pDevice->SetSamplerState( 0, D3DSAMP_ADDRESSW, D3DTADDRESS_CLAMP);

Und außerdem, wie in meinem geposteten Code zu sehen, den Bias von 0.5 hinzuzufügen. Dies und CLAMP tragen dazu bei, dass ein Texel genau auf einen Bildschirmpixel gemappt wird (steht glaube ich auch im SDK, sonst gibt es zu dem Thema einen Artikel auf gamedev.net).

[neolithos]

*PRINT* Das ist mal wieder Stoff für nen langen abend zu Hause!

Mit dem CLAMP-Modus ab ich selbst mit Hilfe der SDK noch nicht ganz so geschnitten, aber es ist ja noch nicht aller Tage abend.

Bei dem Spielfeld (TSnake.Render) rendern, die 2944 Flächen, verliehr ich die meiste Zeit, gibt es dort eine Möglichkeit das zu beschleunigen.
Bei mir zu Hause bin ich zur Zeit bei 25 Fps an dieser stelle.

[neolithos]

So die Texturen werden jetzt ordentlich dargestellt, durch den BIAS was immer das auch ist, jedenfalls die Position mit 0.5 Addiert schon gings. Ich hoffe nicht nur Gott weiß warum.

Der CLAMP-Modus hatte keinen Einfluss und seh zwischen den Modis noch nicht ganz durch (CLAMP,MIRROR, WRAP, BORDER, MIRRORONCE).

ForceWord scheint nur die Enumeration auf 4 Byre zubringen.

Wichtig ist mir derzeit aber eher wie ich die Fps drücken kann!
Und irgentwo hab ich mal gelesen man könnte mit QueryPerformanceCounter die Fps raten leichter berechnen! Wie soll das denn gehen?

[OregonGhost]

Das mit dem BIAS und dem CLAMP steht in irgendeinem Artikel auf gamedev.net oder gamasutra.com oder vielleicht auch im SDK. Der Bias ist dafür zuständig, einen Texel immer genau auf einen Pixel zu mappen. Clamping hingegen sorgt dafür, dass es an den Rändern keine Probleme mit dem Bias gibt.

FORCE_DWORD ist in allen D3D-Enums enthalten und ist tatsächlich nur für die 4-Byte-Ausrichtung zuständig.

Berechnest du deine FPS bisher nicht mit GetTickCount? QueryPerformanceCounter funktioniert ähnlich, hat aber eine viel höhere Auflösung. Daher kannst du auch prima am Anfang des Frames die Zeit berechnen, die seit dem Anfang des letzten Frames vergangen ist -> Frametime, die du für die Physik benötigst, und der Kehrwert sind die FPS.

Was übrigens auch wichtig ist, wenn die Textur nicht 1:1 gerendert werden soll, (weiß gerade nicht, ob du das gemacht hast), ist Mipmapping.

Es gibt sicherlich mehrere Methoden, die Performance zu steigern. Du darfst nur nie vergessen, dass die Füllrate der Grafikkarte eine unüberwindbare Barriere darstellt. Auf der anderen Seite kannst du durch Caching eine Menge erreichen. Da jeder SetRenderState, SetTexture, SetTextureStageState etc. reichlich Performance kostet (ebenso wie ein Lock), solltest du das nur durchführen, wenn nötig. Also nur dann die Textur setzen, wenn sie noch nicht gesetzt etc. Eine weitere Möglichkeit des Caching sind die Stateblocks, mit denen du sehr schnell eine riesige Menge an States etc. ändern kannst.

Ich weiß auch nicht, wie Delphi das handhabt, aber in C wird eine Fließkommazahl standardmäßig als Double betrachtet. Float-Berechnungen sind aber schneller, und D3D akzeptiert sowieso nur floats, daher auch immer 1.0f etc. in meinem Code.

[neolithos]

Danke für den Tip mit den StateBlocks, gleich mal angeschauft. Sieht nützlich aus.
Für weitere Suchhinweise bin ich immer zu haben. Ich will mein kleines sinnloses Snake so professionel wie nur möglich aufgebaut wissen (von der Programmierseite her).

Was hälts du davon, wenn ich das Spiel-Feld (Gras und Fels) mittels ID3DXRenderToSurface in eine Texture via IDirect3DTexture9::GetSurfaceLevel rendere?

Das MipMapping werde ich heut haben gleich mal durchforsten.
Der CLAMP-Modus ist jetz endlich klar.

Übrigens das kleine Spiel sieht immer besser aus, ich werde mal die Anw zukommen lassen per PM, aber erst Montag da ich die Diskette vergessen hab.

Zur der Seite www.gamasutra.com:
Lohnt es sich dort Anzumelden und so viele Info's einzugeben.

[OregonGhost]

Das mit dem RenderToTexture wollte ich heute auch noch vorschlagen ;c)
Du musst aber darauf achten, dass nicht jede Hardware mit großen Texturen umgehen kann. Du kannst entweder auf Nummer sicher gehen und 256x256-Texturen verwenden, oder du fragst eben ab, was für Texturen die Hardware drauf hat. Alternativ kannst du auch dieselbe Methode verwenden, die man früher bei "echter" 2D-Grafik verwandt hat: Du updatest nur die Bereiche, die upgedatet werden müssen. Wenn ich mich recht entsinne, ist IDirect3DDevice9::Clear dafür aber weniger geeignet, besser ein einfarbiges Texturenrechteck... Aber das kennst du ja schon ;C)

ID3DXRenderToTexture musst du gar nicht verwenden, es geht auch ohne (musst nur eine dynamische Textur als RenderTarget festlegen).

Zum Thema Anmelden:
Gamasutra ist neben gamedev.net die größte und wahrscheinlich professionellste Spiele-Entwickler-Site. Und da willst du dich nicht anmelden? Vielleicht findest du da ja einen Job ;C)
Du kriegst halt regelmäßig einen Newsletter (weiß gerade nicht, ob man den ablehnen kann, ich hab' ihn genommen), aber sonst eigentlich nichts. Außerdem veranstalten die die größte Spieleentwicklermesse Games Developer Conference (und GDC Europe) und veröffentlichen das "Game Developer"-Magazin. Ich glaube, denen kannst du trauen...

[neolithos]

Idee: Man könnte vielleicht ein OffScreenSurface machen und das immer in der BackBuffer kopieren?

Nur kurz zur Information ich habe derzeit einen Job in der Anwendungsentwicklung (PPS-Systeme). Das werde ich in einem Monat auch Studieren für ca. 5 Jahre.

Zum Ausgleich zur Anwendungsprogrammierung will ich mit Grafik herumspielen.

Auch auf die Gefahr hin das ich mich wiederhole. Das habe ich unter DOS nämlich sehr gern gemacht. Schade das aus meine 2D-Grafik Engine (ich nenn es eigentlich nicht, lief aber auf einem 286 fast FlickkerFree, bei vielen Fenstern leider nicht mehr) nur ein kommerzielles Programm entstanden ist (1 mal verkauft, ich war jung und brauchte das Geld).

Na gut ich trag mal was in die Felder ein!

Weil ich gerade ne Antowrt schreibe. Wie gut sind die PNG's, die von Paint Shop Pro erzeugt (auf den Alpha-Kanal bezogen). Gibt was besseres. Denn ich habe zur Zeit probleme mit dem Alpha-Kanal meiner Schlange, die ist nicht nur dort Trasparent wo es sein soll sondern komplett.

Nochmal:
Vielen Dank für die vielen Tipps! :bounce2: :hello: :coder:

[neolithos]

Ich schick mal ne PN mit den aktuellen Stand.

Probleme:

1. Das "DurchsichtigMachem" der Schlange funktioniert nicht bzw. zu gut
2. Die Schlangentexturen sind verschoben

Mal sehen...