Richtige Rendering überlappende Dreiecke?

Question

Ich habe angefangen, DirectX 9 in C # zu lernen. Ich möchte zwei Dreiecke rendern und um die y-Achse drehen.

In diesem Teil initialiere ich das Gerät:

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 
} 

Für den Vertexbuffer benutze ich das CustomVertex.PositionColored[].

In diesem Teil setze ich die Matrizen ein und render die Primitiven:

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

Startposition

Nach der Rotation

Im zweiten Bild sehen Sie mein Problem. Das rote Dreieck befindet sich vor dem weißen Dreieck. Wie kann ich das rote Dreieck hinter dem weißen Dreieck ziehen?

Answer 1

Es gibt verschiedene Ansätze für die Handhabung überlappender Gesichter in 3D-Anwendungen:

• Tiefenpufferung
• Maler Algorithmus

Ein Tiefenpuffer (oder Z-Puffer) ist eine sehr häufige Lösung, da sie perfekte Ergebnisse für die undurchsichtige Geometrie ergibt.

Der Tiefenpuffer ist eine Textur, die Tiefeninformationen von gerenderten Pixeln speichert. Wenn der Abstand des Pixels an der Kamera größer ist als der Wert für dieses Pixel in dem Tiefenpuffer, wird das Pixel verworfen. Wenn es näher an der Kamera ist, wird die Farbe in das Render-Ziel geschrieben, und die Tiefe wird aktualisiert.

---

• Erstellen eines Tiefenpuffers (Direct3d 9)
• Tiefensortierung Alpha-Mischobjekte