DirectX noch lausiger als GDI+ - irgendwas ist falsch

Salute

Nachdem ich mit viel nachforschen schon mal herausgefunden habe, wie man ein einfaches bmp per DirectX zeichnen kann, habe ich meine Tile Scroll Engine auf DirectX umgestellt.

Alles übernommen, nur die Zeichenroutine ausgewechselt.

Nur, das Teil läuft langsamer als mit GDI+, irgendwo muss ein grober Fehler sein.

Der DirectX Main Loop sollte korrekt sein, hat mit einem 3D Beispiel auch funktioniert.

In der Main Funktion initialisiere ich die Map, das hatte ich vorher im Konstruktor.
Geändert hat sich eigentlich nur der Imagearray, der jetzt durch einen Texturearray ausgewechselt wurde.
So werden die Texturen nur einmal geladen und gut ist.

            // Texture Array erstellen, um in der Map bzw. Tile nutzen zu können
            Texture[] textures = new Texture[] {
                TextureLoader.FromFile(this._device, Application.StartupPath + @"\img\tiles\weed.bmp"),
                TextureLoader.FromFile(this._device, Application.StartupPath + @"\img\tiles\water.bmp"),
                TextureLoader.FromFile(this._device, Application.StartupPath + @"\img\tiles\baum.bmp")
            };

Das Device wird so initialisiert:

        protected bool InitializeGraphics() {
            // Hauptparameter für die Grafik übergeben
            PresentParameters pres = new PresentParameters();
            pres.Windowed = true;
            pres.SwapEffect = SwapEffect.Copy;

            // Device erstellen
            this._device = new Device(0, DeviceType.Hardware, this,
                CreateFlags.SoftwareVertexProcessing, pres);
            return true;
        }

Dann habe ich eine Wrapperfunktion um Sprites zu zeichnen, eigentlich brauche ich nur Tiles aber scheinbar gibt es da keine Funktion dafür (bin offen für neues!)

        #region Predefined Draw Helper Methods (Wrapper)

        public void DrawSprite(Device device, Texture tex, Vector3 vector3) {
            Sprite sprite = new Sprite(device);

            sprite.Begin(SpriteFlags.None);
            sprite.Draw(tex, new Vector3(0, 0, 0), vector3, Color.White.ToArgb());
            sprite.End();

            sprite.Dispose();
            sprite = null;
        }

        #endregion

Die Render Funktion (wird nur im Main Loop aufgerufen:

        protected void Render() {
            // Backbuffer leeren
            this._device.Clear(ClearFlags.Target, Color.Black, 1.0F, 0);

            // Dem Device mitteilen, das die Scene jetzt beginnt
            this._device.BeginScene();

            // Hier kann gezeichnet werden

            for (int i = 0; i < this._map.Tiles.Length; i++) {
                if (this._map.TileNeedsToDraw(this._map.Tiles[i])) {
                    DrawSprite(this._device, this._map.Textures[this._map.Tiles[i].TextureKey], this._map.getScreenVector3(this._map.Tiles[i].GlobalPoint));
                }
            }


            // Teilt Direct3D mit, das wir mit dem zeichnen fertig sind
            this._device.EndScene();

            // Backbuffer auf den Bildschirm zeichnen
            this._device.Present();

Hat es hier irgendwo einen schwerwiegenden Fehler drin?
Wenn es gleich lahm laufen würde wie mit GDI+, würde ich auf einen Fehler im restlichen Code tippen, nur läuft es noch langsamer.

Das ganze ist im Moment noch ein bisschen Quick & Dirty.
Ich muss die ganzen Sachen aus der Map Klasse noch besser integrieren, das ich nicht immer über this._map.xxxx gehen muss.

Ich vermute das Render() zu häuffig aufgerufen wird und er mit der For Schleife des zeichnens nicht nachmag.

Gruss Peter

Das Sprite objekt sollte nur einmal instanziert werden -> InitializeGraphics.
Das .Begin kommt vor die schleife, .End() nach der schleife.

Danke für deine Antwort!

1. Hab ich geändert.

Original von EvilTK
Das .Begin kommt vor die schleife, .End() nach der schleife.

Versteh ich nicht ganz, wie meinst du das?
Welche Schleife?
Welches .Begin?

<edit>
Du meinst, das .Begin nicht in den Wrapper sondern for die Zeichenschleife? -> genau so.

YUHUUUUU, jetzt läufts 🙂)))
Vielen Dank für deine Verbesserungen!

Noch eine Frage am Rande.
Was hat es eigentlich mit der Version 2.0 von der Microsoft.DirectX auf sich?, ansonsten hab ich von allem ja nur Version 1.x.
</edit>

Gruss Peter

MDX 2.0 verwendet die features des .NET 2.0. Generics, Anynome Methoden usw. thats all
Die MDX 2.0 dll hat sich am 5.10.2006 selbst zerstört.

Muss den Code von Microsoft posten, ich hab mich fast nicht mehr eingekriegt, als ich das gelesen hab.

public static unsafe void CheckTimeBomb()
{
      DateTime time1 = new DateTime(0x7d6, 10, 5);
      if (DateTime.Compare(DateTime.Today, time1) >= 0)
      {
            MessageBoxW(null, *CUT*, 0x2000); //<-- messagebox text war zu lang
            throw new TimeBombException("This pre-release version of DirectX has expired, please upgrade to the latest version from [URL]http://www.microsoft.com/directx[/URL]");
      }
}

Hihi, netter Code 🙂

Wenn ich aber mit MDX 1. 0 unter FW 2.0 programmiere, kann ich diese Features ja auch benutzen, wo liegt den hier genau der Unterschied?
Das ich mit 1.0 kein List<Texture> machen kann und mit 2.0 geht das, weil der Typ "Texture" Generics kompatibel ist?

Dann werde ich in Betracht ziehen, auf XNA umzusteigen.

Gruss Peter

Hallo Peter Bucher,

das hat nichts mit dem Typ Texture zu tun, sondern damit, dass es Generics und damit auch den Typ List erst in 2.0 gibt.

herbivore

Hallo Herbivore

Original von herbivore
das hat nichts mit dem Typ Texture zu tun, sondern damit, dass es Generics und damit auch den Typ List erst in 2.0 gibt.

Das es Generics und List<> erst in 2.0 gibt ist mir klar.
Hmm, jetzt wird mir die ganze Sache klarer, MDX 2.0 verwendet intern die Features von .NET 2.0?

In der Anwendung würde es also keinen Unterschied machen?

Gruss Peter