title: Correctly rendering overlapping triangles?
body: <p>I started learning DirectX 9 in C#. I want to render two triangles and rotate them around the Y axis.</p>
  
  <p>In this part I initialize the Device:</p>
  
  <pre><code>public bool InitializeDevice()
  {
      try
      {
          meshList = new List&lt;Sphere&gt;();
  
          // Erstellt die PresentParameters für weitere Einstellungen des Device
          PresentParameters presParams = new PresentParameters() {
              Windowed = true,                // Device nur innerhalbe des Fensterhandels benutzen
              SwapEffect = SwapEffect.Discard, // Grafikkarte entscheidet selbst wie sie den Backbuffer zur anzeige bringt
          };
  
          // Erzeugt eine Instanz von dem Device
          device = new Device(0,                                      // Nummer fuer den Grafikadapter der verwendet wird                  
                              DeviceType.Hardware,                    // Parameter über die Garfikkarte oder CPU ausführen
                              Panel_3D,                               // Fensterhadel für das Device 
                              CreateFlags.SoftwareVertexProcessing,   // Einstellung des Device. Gibt an, dass die Vertices nur per Software verarbeitet werden 
                              presParams);                            // Gibt die weiteren Einstellungen mit
  
          // Wenn das Device neupositioniert wird
          device.DeviceReset += new System.EventHandler(this.OnResetDevice);
          // Führt das Reset aus
          OnResetDevice(device, null);
  
          // Definiert keine Vor und Rückseite
          device.RenderState.CullMode = Cull.Clockwise;
          // Direct3D-Beleuchtung deaktivieren
          device.RenderState.Lighting = false;
          // Beschreibt einen festen Füllmodus
          device.RenderState.FillMode = FillMode.Solid;
  
          // Erstellt den Buffer für die Vertices (Lab Koordinatensystem)
          vertexBuffer = new VertexBuffer(typeof(CustomVertex.PositionColored),   // Typ der Vertices
                                          18,                                     // Anzahl der Vertices
                                          device,                                 // Gerätekontext unser device
                                          0,                                      // Anzahl der Flags zur Verarbeitung der Vertice
                                          CustomVertex.PositionColored.Format,    // Typ der Vertices (Weil man auch eigene Strukturen definieren kann)
                                          Pool.Default);                          // Speicherung der Vertices
  
          // Event welches aufgerufen wird wenn der Vertexbuffer erstellt wurde
          vertexBuffer.Created += new System.EventHandler(this.OnCreateVertexBuffer);
          // Event wird von Hand aufgerufen
          this.OnCreateVertexBuffer(vertexBuffer, null);
  
          return true;    // Device wurde erstellt
      }
      catch { return false; } // Device konnte nicht erstellt werden 
  } 
  </code></pre>
  
  <p>For the VertexBuffer I use the <code>CustomVertex.PositionColored[]</code>.</p>
  
  <p>In this part I setup the matrices and render the primitives:</p>
  
  <pre><code>/// &lt;summary&gt;
  /// Berechnen und Darstellen des Bildes
  /// &lt;/summary&gt;
  public void Render()
  {
      // Fragt ob das Device erstellt wurde und noch gültig ist
      if (device == null)
          return;
  
      // Inhalt des Backbuffers löschen und das ganze mit einer Farbe einfärben
      device.Clear(ClearFlags.Target,         // Die entsprechende Oberfläche
                      System.Drawing.Color.Black,// Die Farbe 
                      1.0f,                      // Abstand vom Betrachter, an dem die Oberfläche gelöscht wird und einen Wert, ...
                      0);                        // ...der in jedem Stencil-Buffer-Eintrag gespeichert wird.
  
      // Anfang der Szene
      device.BeginScene();
      // Matrizen aufsetzen
      SetupMatrices();
  
      // Bindet den Buffer an das Device
      device.SetStreamSource(0,           // Nummer des Streams
                              vertexBuffer,// Der Buffer
                              0);          // StartOffset in dem Buffer
  
      // Teilt dem Device das Format der Vertices mit
      device.VertexFormat = CustomVertex.PositionColored.Format;
      // Zeichnet die Dreiecke
      device.DrawPrimitives(PrimitiveType.LineList,   // Typ der Primitive
                              0,                        // Eintrag des ersten Vertex
                              3);                       // Anzahl der Primetive
  
      // Zeichnet das Rechteck
      device.DrawPrimitives(PrimitiveType.TriangleList,   // Typ der Primitive
                              6,                            // Eintrag des ersten Vertex
                              4);                           // Anzahl der Primetive
  
      // Ende der Szene
      device.EndScene();
      // Bringt die Zeichnung auf das Fensterhandle
      device.Present();
  }
  
  /// &lt;summary&gt;
  /// Setzt die Matrizen auf
  /// &lt;/summary&gt;
  private void SetupMatrices()
  {
      Matrix MX = Matrix.RotationX(impValue.ObjektRotationY);
      impValue.ObjektRotationY = 0;
      Matrix MY = Matrix.RotationY(impValue.ObjektRotationX);
      impValue.ObjektRotationX = 0;
  
      Matrix Rotation = device.Transform.World;
      Rotation *= MY;
      Rotation *= MX;
  
      // Rotiert das device entlag der X und Y Achse
      device.Transform.World = Rotation;
  
      // Setzt den Benutzerblickwinkel auf
      device.Transform.View = Matrix.LookAtLH(new Vector3(impValue.KameraPosX, impValue.KameraPosY, impValue.KameraPosZ), // Kameraposition
                              new Vector3(impValue.SchauPosX, impValue.SchauPosY, impValue.SchauPosZ),                    // Punkt, auf den geschaut wird
                              new Vector3(impValue.OberstePosX, impValue.OberstePosY, impValue.OberstePosZ));             // Vektor der angibt, wo oben ist
  
      // Setzt die Ansichtsmatrix auf (Linke-Hand-orientiertes System)
      device.Transform.Projection = Matrix.PerspectiveFovLH(impValue.BlickWinkel, // Sichtbereich (Blickwinkel)
                                      impValue.SeitenVerhaeltnis,                   // Seitenverhältnis
                                      impValue.NaheEbene,                           // Abstand zum nächsten sichtbaren Punkt (nahe Ebene)
                                      impValue.FerneEbene);                         // Abstand zum letzten sichtbaren Punkt (ferne Ebene)
  }
  </code></pre>
  
  <h3>Start position</h3>
  
  <p><a href="https://i.stack.imgur.com/x7j1y.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/x7j1y.png" alt="Two triangles, red in front of white"></a>
  </p>
  
  <h3>After rotation</h3>
  
  <p><a href="https://i.stack.imgur.com/P1jum.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/P1jum.png" alt="Same triangles, but rotated; red still in front of white"></a>
  </p>
  
  <p>In the second picture you can see my problem. The red triangle is in front of the white triangle. How can I draw the red triangle behind the white triangle?</p>