OpenGL ES oder DirectX

Moin

Mich würde mal Interessieren, was besser ist. OpenGL ES oder DirectX Moible.

Habe irgendwo mal gelesen, dass DirectX ab WM7 nicht mehr unterstützt wird. Ist das so richtig oder wollte mir da wer mist erzählen?

Gibt es Geschwindigkeitsunterschiede?

MfG

Tr1umph

'Besser' ist immer so eine Frage. Ich benutze seit Jahren OpenGL(ES). Das Gerücht habe ich auch schon gehört. In Windows Mobile ruft DirectX intern OpenGLES auf!
Um die 3D Leistung zu messen habe ich einen OpenGLES Test (Englisch) geschrieben. Kannst ja mal in den source code reinschauen.
Ist in C# .net geschrieben, aber auch DirectX gibt's als managed Variante.
Versuche ein kleines Demo in beiden Sprachen zu schreiben und du wirst sehen was dir besser liegt.

Im Gegensatz zu den Desktop Versionen der API's ist im mobilen Bereich OpenGl ES 99% vorzuziehen: OpenGl wird besser von der Hardware unterstützt (meist keine Hardware D3DM Unterstützung), kann deutlich mehr (erst recht mit OpenGl ES 2.0 mit Shadern!) und du findest weitaus mehr Hilfe im Netz. Der einzige Vorteil von DirectX ist, dass es im Gegensatz zu OpenGl offiziel von MS unterstützt wird, mit WM7 soll aber auch OpenGl offiziell unterstützt werden.

Kann mir hier vielleicht jemand von den Cracks auf die Sprünge helfen?
Ich hab ein kleines Spiel geschrieben, welches zuerst mit dem normalen Graphics-Objekt die Sachen gezeichnet hat. Damit lief auch alles flüssig, aber ich konnte kein AlphaBlending oder Rotation verwenden, weswegen ich nun auf DirectX Mobile umgestiegen bin. Mit Entsetzen musste ich aber feststellen, dass damit mein Spiel nun mit gefühlten 0.01 Frames pro Sekunde läuft.

Meine Logik sieht einen Timer vor, der momentan alle 100ms den HTC Lagesensor abfragt und dann dem Spiel einen 'Tick' schickt. Hier geht dann der Rest weiter, wie Animation berechnen, Collision-Detection, Rendern.

Nun, wenn ich alles ausblende und nur die Spielfigur rendere, dann komme ich auf vielleicht 5 fps.

Kann es sein, dass DirectX alles per Software macht und die Hardware-Beschleunigung sich langweilt? Ich verstehe es irgendwie nicht.

Muss ich tatsächlich OpelGL benutzen? Davor habe ich ein bischen Schiss, da ich bisher keine schönen Tutorials gefunden habe.

Ich entwickel unter Visual Studio 2005 in C#. Hier mal der Code, den ich benutze, um das Graphics Device zu initialisieren, vielleicht habe ich ja da schon den Fehler?

Code:

private void InitGraphicsDevice()
{
    PresentParameters present = new PresentParameters();

    present.Windowed = false;
    present.SwapEffect = SwapEffect.Discard;
    present.BackBufferCount = 1;
    present.BackBufferWidth = 480;
    present.BackBufferHeight = 800;

    this.GraphicsDevice = new Device(0, DeviceType.Default, this.Owner, CreateFlags.None, present);
    this.GraphicsDevice.DeviceReset += new EventHandler(OnDeviceReset);
}

Leider ist es so das direct3d mobile oft nur sehr schlecht unterstützt wird: der Treiber ist oft nur ein Wrapper für opengl oder es wird der default renderere verwendet welcher eine reine software lösung ist und die hardware gar nicht nutzt. Wenn du sichergehen willst solltest du opengl es verwenden oder eine hybride engine entwickeln (ist gar nicht sooo schwierig).

Zudem solltest du nie Timer verwenden. Ich z.b checke immer die Zeit die für 30 bilder berechnet wurde und errechne daraus den durchschnitt pro frame. Dann rendere ich die szene so oft wie möglich, wobei sämtliche animationen von dem oben berechneten wert abhängen. So ist sichergestellt dass auf jedem gerät so schnell wie möglich gerendert wird und dass die Animation unabängig von der performance immer gleich schnell abläuft.

Noch ein Tipp zum gsensor. Das abfragen der lage alle 100 ms kann sich negativ auf die performance auswirken. Statdessen solltest du die lage seltener abfragen und dann z.b folgendermassen interpolieren:

GlVector3F current; //der lage vektor der im spiel verwendet wird
GlVector3F target; //der vektor der vom gsensor z.b 2 mal pro sekunde abgefragt wird
bei jedem rendern der szene berechnest du current dann folgendermassen neu:
current = current * 0.9f + target*0.1f;

so solltest du mehr performance bekommen und kleine ungenauigkeiten des sensors sollten minimiert werden.

PS: OpenGl kann tatsächlich etwas mühsam sein. Probier doch mal meine Tigre Engine, da gibts auch viele Beispiele und es ist wirklich nicht schwierig

Danke Phippu, für den ausführlichen und interessanten Beitrag.
Deine Tigre-Engine hatte ich schon mal ausprobiert, kam aber auf Anhieb nicht so schnell damit klar. Werde es aber nun nochmals ausprobieren.

Wenn das dann klappt, werde ich mir Deinen Tipp bzgl. des Lagesensors und des Timers zu Herzen nehmen und einbauen.

Falls du Hilfe mit der Tigre Engine brauchst helfe ich natürlich gerne! Ich denke dass du damit aber schneller zum Ziel kommst anstatt mit d3d. Der Code von oben kannst du in Tigre z.b mit einer Zeile erreichen:

ICore core = new Core(mainform);

In der Tutorials Sektion auf meiner Seite findest du bereits 2 Starthilfen und den Source Code von den Beispielen sollte eigentlich auch leicht verständlich sein.

Hi,
ja mit den Tutorials kam ich nicht auf Anhieb klar, da ich für mein Spiel keine 3D-Modelle oder Kameras etc. brauche. Ich möchte nur mit Sprites arbeiten, also "eigentlich" nur 2D.

Habe mal ein kleines OpenGLES 1.x Tutorial erstellt.

Hier mal ein Quickstart zu Tigre mit 2D:

1) erstelle die beiden Felder:

private readonly ICore core;
private readonly ISceneGraph graph;

2) dann brauchst du einen Core und einen Graphen, das erreichst du mit:

core = new GlCore(this);
graph = new GlSceneGraph(core);

3) füge folgende zeilen zum rendern hinzu:

protected override void OnPaintBackground(PaintEventArgs e) { }
protected override void OnPaint(PaintEventArgs e)
{
graph.Render();
Invalidate();
}

Bis jetzt ist alles wie im Tutorial. Wenn du das alles selbst implementieren willst wird du eine Weile brauchen...

dann zum 2d teil mit einem sprite.

5) dazu must du eine textur laden, und das geht folgendermassen:

GlMaterial material = graph.AddMaterial("Material01");
material.PrimaryTexture = graph.AddTexture(pfad-zu der datei,false)
material.DisableLighting = true;

6) dann erstellst du das sprite:

GlMesh2D sprite = new GlMesh2D(Geometry2D.Plane(128,128,true,false));
sprite.Material = material;
graph.Root2D.AddChild(sprite);

damit bist du schon am Ziel, wenn du die position ändern willst kannst du dies mit sprite.Position = new GlVector2F(x,y) tun. Sprites können auch rotiert und skaliert werden. Der Code oben mag ev nach viel aussehen, wenn du alles selbst implementieren willst wirst du schnell tausende zeilen code haben. Der code oben sollte aber wirklich einfach verständlich sein, zudem kannst du wirklich alles anpassen

Cool, danke, das verstehe ich alles soweit, nur 2 Fragen dazu:

1. Kann ich Texturen auch aus Streams laden?
2. Und: wie bestimme ich den Z-Index der Sprites?

Ich habe zum Beispiel einen großen (scrollenden) Background und dann eben die einzlen kleinen Figuren als separate Sprites. Bisher hatte ich den Background ebenfalls als Sprite angelegt.

Ich freue mich schon auf heute Abend, wenn ich das endlich mal ausprobieren kann

Ist beides noch nicht implementiert, falls du willst ist dass aber schnell implementiert. Die objekte werden in der Reihenfolge gerendert wie sie erstellt werden. Du kannst also z.B beim material noch Material.DisableDepthTest = true stellen und dann kannst du problemlos ein sprite vor dem anderen rendern. Für den Background gibt es sogar eine extra klasse (Graph.Background). Wenn du denn background scrollen möchtest kannst du z.B die Textur Matrix Verschieben (siehe demo). Ach noch etwas:
wenn du transparente texturen hast (z.b wolken) dann kannst du die textur mit dem argument transparent = true laden und musst beim material dann noch AlphaBlending = true setzten

Awesome! Das mit der Reihenfolge hat sich quasi erledigt, wenn es eine eigene Background-Klasse gibt. Hauptsache, die ist im Hintergrund.