Correctly rendering overlapping triangles?

Question

I started learning DirectX 9 in C#. I want to render two triangles and rotate them around the Y axis.

In this part I initialize the Device:

public bool InitializeDevice()
{
    try
    {
        meshList = new List<Sphere>();

        // 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 
} 

For the VertexBuffer I use the CustomVertex.PositionColored[].

In this part I setup the matrices and render the primitives:

/// <summary>
/// Berechnen und Darstellen des Bildes
/// </summary>
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();
}

/// <summary>
/// Setzt die Matrizen auf
/// </summary>
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)
}

Start position

After rotation

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?

Answer 1

There are different approaches for handling overlapping faces in 3D applications:

• Depth-Buffering
• Painter's Algorithm

A depth buffer (or Z-buffer) is a very common solution, since it gives perfect results for opaque geometry.

The depth buffer is a texture that stores depth information of rendered pixels. If the distance of the pixel to the camera is greater than the value for that pixel in the depth buffer, the pixel is discarded. If it is closer to the camera, the color is written to the render target and the depth is updated.

---

• Creating a Depth Buffer (Direct3D 9)
• Depth sorting alpha blended objects