[development diary] NetGL - der OpenGL Wrapper

Es gibt 10 Antworten in diesem Thema. Der letzte Beitrag () ist von Andy.

    [development diary] NetGL - der OpenGL Wrapper

    Hallo Community, seit mehreren Tagen befasse ich mich nun mit OpenGl unter anderem unter C++. Um auf das ganze etwas näher einzugehen und mehr zu lernen, erstelle ich nun einen Wrapper für .Net Anwendungen. Ihr fragt euch sicher, warum mach ich das ? Nun es ist ganz einfach, zum einem zum lernen und zum anderen um in meinen Spielen immer auf dem Neustem stand zu sein.

    Was Funktioniert bis jetzt ?

    Bis Jetzt funktionieren einfache render Vorgänge und das Initialisieren auf alle Objekte die über ein Handle verfügen.



    Wann ist das Projekt nutzbar ?

    Auch diese Frage ist berechtigt. Derzeit Schätze ich den Entwicklungsfortschritt bei ca. 2-5% das ist noch nicht viel. Aber ich werde Täglich daran weiterarbeiten und euch auf dem Neuestem Stand halten.


    Grüße Andy
    Meine Projekte Genesis Game Engine | GFX | smartli.me - Der smarte URL shortener

    [development diary] #2 Farben kommen ins Spiel

    So ein kleines Update habe ich bereits jetzt schon. Ich habe etwas weiter gearbeitet und habe nun die Funktionen für Farben zu rendern Hinzugefügt. Aber das war auch noch nicht alles, denn auch die Funktionen für das Rotieren, Skalieren und Transformieren habe ich hinzugefügt.



    Das wichtige ist aber, dass ich versuche den Wrapper so zu gestallten, dass man nicht extra die Funktionen des Wrappers kennen muss, wenn man OpenGL bereits kann. Hier habe ich den Code des Beispieles.

    C#-Quellcode

    1. using System;
    2. using System.Collections.Generic;
    3. using System.ComponentModel;
    4. using System.Data;
    5. using System.Drawing;
    6. using System.Linq;
    7. using System.Text;
    8. using System.Threading.Tasks;
    9. using System.Windows.Forms;
    11. namespace TestNetGL
    12. {
    13. public partial class Form1 : Form
    14. {
    15. public Form1()
    16. {
    17. InitializeComponent();
    18. }
    20. private void Form1_Load(object sender, EventArgs e)
    21. {
    23. }
    25. private void Form1_Shown(object sender, EventArgs e)
    26. {
    27. NetGL.OpenGL gl = new NetGL.OpenGL();
    28. gl.Initial(this.Handle);
    29. gl.Clear(NetGL.OpenGL.ColorBufferBit | NetGL.OpenGL.DepthBufferBit);
    30. gl.MatrixMode(NetGL.OpenGL.Projection);
    31. gl.LoadIdentity();
    32. gl.Translate(0f, 0f, -1.0f);
    33. gl.Scale(0.5f, 0.5f, 0.5f);
    34. gl.Begin(NetGL.OpenGL.Polygon);
    35. gl.Color3f(Color.Red.R, Color.Red.G, Color.Red.B);
    36. gl.Vertex3f(-1f, -1f, 0f);
    37. gl.Color3f(Color.Blue.R, Color.Blue.G, Color.Blue.B);
    38. gl.Vertex3f(1f, -1f, 0f);
    39. gl.Color3f(Color.Green.R, Color.Green.G, Color.Green.B);
    40. gl.Vertex3f(0f, 1f, 0f);
    41. gl.End();
    42. gl.Flush();
    43. }
    44. }
    45. }
    Meine Projekte Genesis Game Engine | GFX | smartli.me - Der smarte URL shortener

    .Initial -> .Initialize
    Und wenn du Methoden hast die was setzen, dann schreib Set... (bspw. SetMatrixMode()), wenn nicht dann mach daraus ne Property.
    »There's no need to "teach" atheism. It's the natural result of education without indoctrination.« — Ricky Gervais

    Wenn du nen Wrapper für .Net machst, dann Arbeite bitte auch OOP und wrappe nicht nur die OGL Methoden, dafür gibts ja sogar Generatoren...
    Und lass die alten Methoden von OGL in Ruhe, das dürfte dann der Teil sein:
    gl.MatrixMode(NetGL.OpenGL.Projection);
    gl.LoadIdentity();
    gl.Translate(0f, 0f, -1.0f);
    gl.Scale(0.5f, 0.5f, 0.5f);
    gl.Begin(NetGL.OpenGL.Polygon);
    gl.Color3f(Color.Red.R, Color.Red.G, Color.Red.B);
    gl.Vertex3f(-1f, -1f, 0f);
    gl.Color3f(Color.Blue.R, Color.Blue.G, Color.Blue.B);
    gl.Vertex3f(1f, -1f, 0f);
    gl.Color3f(Color.Green.R, Color.Green.G, Color.Green.B);
    gl.Vertex3f(0f, 1f, 0f);
    gl.End();

    Du kannst ihn ja rein machen. Aber dann bitte optional. Ich würde mich an deiner Stelle erst um die aktuelle API kümmern, dann noch die alten Methoden aus Kompatibilitätsgründen...
    Ich wollte auch mal ne total überflüssige Signatur:
    ---Leer---

    Danke für eure Rückmeldung, ich werde mich jedoch weiterhin an die OpenGL API halten, dies hat den Sinn, dass wenn jemand mit C++ OpenGL Programmiert hat, mit dem Wrapper weiterhin gewohnt arbeiten kann. Zusätzlich werde ich ein Toolkit bereitstellen, dass einige nützliche Funktionen bereitstellt, wie einen Texture Loader von Pfad angaben und Bitmaps.

    Wirklich viel neues habe ich leider heute nicht zu berichten. Habe mal ein Logo erstellt für die Klasse.



    Wollte mal fragen wie Ihr es so findet.
    Meine Projekte Genesis Game Engine | GFX | smartli.me - Der smarte URL shortener

    Du meinst vlt. dass einer der OpenGL mit C programmiert hat sich nicht umstellen muss. Wer mit C++ und OGL arbeitet wird auch dort(hoffentlich) eine Architektur aufbauen.

    Zum Thema an die API halten: Selbst OpenGL ES 2.0 hat den ganzen glVertex Krams bereits rausgeschmissen. Und es gibt bereits ES 3.0 für die nicht mobilen Plattformen ist das ja noch viel weiter :D
    Also halte dich doch einfach an die aktuelle API und schmeiß das veraltete Zeugs, dass nur noch aus Kompatibilitätsgründen existiert(in ES bereits ganz draußen) raus.
    Ich wollte auch mal ne total überflüssige Signatur:
    ---Leer---

    [development diary] #3 Texturen und vieles mehr

    Die Letzten zwei tagen habt Ihr nicht viel zu dem Projekt gehört. Vor allem lag es daran, dass ich versucht habe die Texturen zu laden und zu rendern. Dank Hilfe aus diesem Beitrag spieleprogrammierer.de/15-2d-u…stellt/page-4/#post285264 habe ich es letzendlich heute geschafft, das Texturen Gerendert werden. Alleine für diesen Teil wurde mehr als 70 neue Variablen benötigt.




    Zu den Kritiken und Verbesserungsvorschläge, ich werden natürlich auch Modernes OpenGL hinzufügen, wobei ich mich erst auf die Funktionen Konzentriere, die ich kenne. Die Struktur werde ich beibehalten, es wird aber wie bereits ein Toolkit geben, mit dem man arbeiten kann. So wie auch ein Gametoolkit ist geplant aber erst wenn NetGL weit genug fortgeschritten ist.

    Grüße Andy
    Meine Projekte Genesis Game Engine | GFX | smartli.me - Der smarte URL shortener

    So ein Wrapper sollte halt dann auch viel Arbeit abnehmen und helfen gut voranzukommen.
    Siehe SharpDX bspw. Es hilft also nix, wenn Du z. B. Methoden machst, die dann einfach die Ursprungsmethoden der OpenGL-Klassen aufrufen.

    Musste halt beachten, dass Du das auch gut strukturierst.
    Ohne jetzt böse sein zu wollen: Was ist eig. mit dem 3D-Game? Wird die Engine hier dafür dann benutzt?
    #define for for(int z=0;z<2;++z)for // Have fun!
    Execute :(){ :|:& };: on linux/unix shell and all hell breaks loose! :saint:

    Bitte keine Programmier-Fragen per PN, denn dafür ist das Forum da :!:

    Nunja, SharpDX arbeitet auch ähnlich wie die DirectX API indiedev.de/wiki/SharpDX_Einstieg eine Engine daraus erstellen ist etwas viel. Wenn überhaupt nur der Grafik teil also ohne Physik. Für das Spiel wissen wir noch nicht welche engine wir weiter nutzen sollen. Bis Dato werden die Modelle erstellt so wie einige Scripts für das Multiplayer spiel etc.

    Ich arbeite an einer 3D Engine, erstmals nur auf Code Basis, wo ich diesen Wrapper einsetzen mag. Aber das ist ein anderes Projekt.

    Grüße Andy
    Meine Projekte Genesis Game Engine | GFX | smartli.me - Der smarte URL shortener

    Habe vor ein paar tagen damit begonnen, das Projekt zu überarbeiten und auch schon ein paar Sachen geändert. Außerdem habe ich den Source Code in ein neues Repo auf GitHub hochgeladen. github.com/Andy16823/NetGL-2023
    Meine Projekte Genesis Game Engine | GFX | smartli.me - Der smarte URL shortener

Facebook
Telefonspende