DirectX Vertex Darstellung

[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 ! 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

[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. 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.