ogl4au3 2.0 Alpha - Zweite große OpenGL UDF mit vielen Beispielen

  • ogl4au3

    v 2.0 Alpha
    Willkommen zur 2. großen OpenGl-UDF für AutoIt3.
    Die UDF findet sich im Ordner Includes und heißt opengl.au3. Diese UDF inkludiert automatisch alle
    anderen UDFs die für die Funktionalität von ogl4au3 verantwortlich sind. Sie muss als einziges
    inkludiert werden.
    Im Ordner Media finden sich alle Dateien, die in den Beispielen gebraucht werden. Die Beispiele
    sind im Ordner Examples mit Nummern angeführt, die ihe Komplexität symbolisiert.
    Werte, die ihr selbst einstellen dürft sind mit ; Public gekennzeichnet!

    Inbetriebnahme
    Um die UDF zu nutzen, muss opengl.au3 inkludiert werden. Alle anderen Includes müssen sich
    im selben Ordner wie opengl.au3 aufhalten. Alle DLLs müssen ebenfalls im SkriptDir liegen, das heißt
    alle DLLs, die sich auch im Examples Ordner finden (!).

    Hilfe
    Die "Hilfe" findet sich im Ordner Doc. Der gewünschte Artikel lässt sich per Windows-Dateisuche finden

    Bugs

    • Hilfe ist unvollständig, nicht übersetzt und nicht ausgefüllt
    • Beispiele sind nicht ganz optimal geschrieben / aufgeräumt
    • UDFs sind weder aufgeräumt noch konform noch irgendwie sonst ordentlich
    • Hier und da noch ein Bug...


    Download
    Der Download kann über wpt-get erfolgen (Dateigröße, und es ist für mich einfacher zu verwalten!):

    Code
    wpt-get install ogl4au3-2.0

    Download-Direktlink

    mfG :rock:

    2 Mal editiert, zuletzt von minx (9. Januar 2013 um 22:18)

  • Schaut sehr interessant aus, und nach viel Arbeit für dich. ;)

    Muss ich mich mal unbedingt durch die Beispiele arbeiten. :D

    Und eine FPS-Anzeige bei den Beispielen wäre echt nicht schlecht. :P

    Mfg

    There's a joke that C has the speed and efficieny of assembly language combined with readability of....assembly language. In other words, it's just a glorified assembly language. - Teh Interwebz

    C makes it easy to shoot yourself in the foot; C++ makes it harder, but when you do, you blow off your whole leg. - Bjarne Stroustrup
    Genie zu sein, bedeutet für mich, alles zu tun, was ich will. - Klaus Kinski

  • Bei den wichtigen Beispielen kann man die FPS selbst einstellen. Allgemein wird die Performance ja durch das Anzeigen der FPS gemindert ^^

  • Hi,

    Zitat

    Allgemein wird die Performance ja durch das Anzeigen der FPS gemindert

    naja, ein wenn ein simpler 2-zeiler, der 1x pro Sekunde aufgerufen wird, "Performance" mindert, dann ist es mit der Performance nicht weit her^^

    FPS Gerippe
    [autoit]

    AdlibRegister("_fps", 1000) ;FramesPerSecond
    $fps = 0

    [/autoit] [autoit][/autoit] [autoit]

    while 1
    ;irgendein grafikkram
    $fps+=1
    WEnd

    [/autoit] [autoit][/autoit] [autoit]

    Func _fps()
    tooltip ($fps & " FPS")
    $fps = 0
    EndFunc ;==>_fps

    [/autoit]

    das ist imho so ziemlich das mit AutoIt machbare Maximum.
    Interessant ist, dass die "FPS" mal locker im Bereich von 10-20% schwanken, abhängig davon, was sonst noch so auf dem Rechner los ist!

    FPS im Script
    [autoit]

    ; ogl4au3 Example: Rotating Textured Box
    ; Autor: minx

    [/autoit] [autoit][/autoit] [autoit]

    ; Dies ist ein einfaches Beispiel, wie man Texturen in OpenGl nutzen kann. Das Fenstermanagement übernimmt wie immer
    ; glfw. Das Textur-Laden und Registrieren übernimt freundlicherweise komplett SOIL!
    ; Wir brauchen dann nur noch in den TEXTURE_2D Modus zu gehen, und jedem Eckpunkt noch einen Texturpunkt zuordnen.
    ; ^ Das erledigt meine Extension: extTexCube()
    ; Das wars schon!

    [/autoit] [autoit][/autoit] [autoit]

    #include "..\Includes\opengl.au3"

    [/autoit] [autoit][/autoit] [autoit]

    Local $iAlpha = 0.00 ; Rotationswinkel um den Würfel zu drehen.
    Dim $iW, $iH, $iChannels ; Container für die Werte, die von SOIL übergeben werden. Channel: RGB(A)

    [/autoit] [autoit][/autoit] [autoit]

    glInit()
    gluInit()
    glfwInit()

    [/autoit] [autoit][/autoit] [autoit]

    glfwOpenWindowHint($GLFW_WINDOW_NO_RESIZE, 1); Resize nicht möglich
    glfwOpenWindow(500, 500, 8, 8, 8, 0, 8, 0, $GLFW_WINDOW); Fenster öffnen
    glfwSetWindowTitle("Spining Cube"); Titel setzen
    glMatrixMode($GL_PROJECTION); Projektionseinstellungen
    gluPerspective(20, 500 / 500, 5, 15); Perspektive
    glViewport(0, 0, 500, 500); Viewport
    glMatrixMode($GL_MODELVIEW); Betrachtungsmodus
    $textureId = extTexture3a("..\Media\crate.jpg")
    ;glEnable($GL_CULL_FACE) ; Rückseite hinten belassen und nicht rendern. Sonst geht alles drunter & drüber!
    glEnable($GL_TEXTURE_2D) ; Texturmodus
    glEnable($GL_DEPTH_TEST)

    [/autoit] [autoit][/autoit] [autoit]

    AdlibRegister("_fps", 1000) ;FramesPerSecond
    $fps = 0

    [/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

    While glfwGetWindowParam($GLFW_OPENED) And Not glfwGetKey($GLFW_KEY_ESC)
    ;Grafikgedöns einschalten, DAS kostet Performance^^
    glClear($GL_COLOR_BUFFER_BIT + $GL_DEPTH_BUFFER_BIT)
    glLoadIdentity()
    glTranslatef(0, 0, -10); Einen Schritt zurück
    glRotatef(30, 1, 0, 0); Leicht von oben schauend
    glRotatef($iAlpha, 0, 1, 0.2); Waagerecht rotieren mit Winkel
    extTexCube(0, 0, 0, .25) ; Würfel zeichnen. Das Mappen übernimmt glext.
    extTexCube(.6, 0, 0, .25)
    extTexCube(.25, .5, .3, .25)
    extTexCube(.4, 0, .6, .25)
    $iAlpha += .4 ; Winkel erhöhen.
    glfwSwapBuffers() ; Buffer tauschen.
    $fps+=1
    WEnd

    [/autoit] [autoit][/autoit] [autoit]

    ; Aufräumen:
    glDeleteTextures(1, $textureId)
    glfwTerminate()
    glTerminate()

    [/autoit] [autoit][/autoit] [autoit]

    Func _fps()
    glfwSetWindowTitle("Spining Cube "&$fps & " FPS"); Titel setzen
    $fps = 0
    EndFunc ;==>_fps

    [/autoit]


    Mausschubser erhöhen die FPS, indem sie den Nager über den Schreibtisch bewegen....


    minx,
    viel Fleissarbeit, die API nach AutoIt zu portieren, aber was ich als AutoIt-ler schmerzlich vermisse, sind "Einfachst"-Befehle, die 80% des (in so gut wie jedem existierenden GL-Programm) anfallenden identischen Codes mittels simpler Anweisungen kapseln.
    Im Stile der "Extensions" ;)

  • was ich als AutoIt-ler schmerzlich vermisse, sind "Einfachst"-Befehle, die 80% des (in so gut wie jedem existierenden GL-Programm) anfallenden identischen Codes mittels simpler Anweisungen kapseln.
    Im Stile der "Extensions"

    Da OpenGL eine Low-Level API ist, ist dies "von Haus aus" nicht nötig. Würde man es immer weiter abstrahieren, wäre man bei Irrlicht und Co. (nebenbei fehlt dann die Möglichkeit doch durch kleine Umordnungen noch Performanceschübe zu bekommen ;) ).

  • Bei der Vorigen Version der UDF wurde das ganze i der GUI angezeigt von GUICreate. Kann man jetzt irgendwo einstellen, dass er das wieder machen soll, also embedded?

  • Du kannst alle GLFW Befehle weglassen und die alte Funktion nehmen. Allerdings ist dies weder sicher noch gut im Handling. Embedded geht aber nur so. Viellicht füge ich das noch als Extension hinzu.

  • Hi,
    im Zuge der Zusammenarbeit von OpenGL und OpenCL benötigte ich einige Funktionen der glew32.dll
    glew ist, so wie ich das jetzt überblicken kann, mit hunderten Funktionen am Start. Eine Handvoll dieser Funktionen habe ich schon konvertiert.

    minx, hast du einen "C nach AutoIt"-Konverter, den du auf die *.h-files loslässt?
    So etwas ähnliches hatte ich mir für die Konvertierung von OpenCl nach AutoIt geschrieben, allerdings war noch bissl Handarbeit nötig, vor allem die Typen bei den DllCall´s sind imho bissl schwierig automatisch zu ermitteln.

  • James hat einen C nach Au3. Allerdings nehmen einige Funktionen, wie z.B. die ...fv Arrays auf. Da wäre es gut von Hand nachzubessern. GLEW und allgemein die EXT_... sind auch wichtig für das ganze - schön, dass du dich doch ranwagst ^^

    Generell kann man erstmal automatisch konvertieren, dann aber selbst Hand anlegen. Eben wegen den Typen. Einbinden kannst du das als ogl_glew_{functions/constants} direkt nach der eigentlichen (ogl_gl_functions). Dann kannst du als DLL gleich die Konstante mitbenutzen.

  • die Extensions-Funktionen sitzen größtenteils als Pointer-Adresse in der dll, da isses dann einfach, hab mir nen universellen "Aufrufer" geschrieben. Der holt sich über GetProcAddress() den Pointer und called per DllCallAddress() dann die dort liegende Adresse.
    Muss jetzt nur die in der dll liegenden Funktionen und Aufrufparameter auseinanderklabustern...
    Für die Typen schreib ich mir ne Ersetzungstabelle, ist am einfachsten.

    Aber zuerst muss ich mal mein Script funktionsfähig haben und überhaupt KAPIEREN was da Sache ist mit OpenGL^^
    Ich werde dann "einfachst"-GL-Funktionen haben und alles kapseln, was unnötig ist. Sozusagen dem User vorbestimmen, was er am Ende sehen soll im Fenster^^
    Ziel ist, sehr simpel per CL die Bufferdaten von GL zu manipulieren, das hab ich so weit schon lauffähig. Erst mal in 2D, 3D ist nur noch ne Fleißarbeit. Natürlich kann man die Shader immer noch über GL-Befehle beeinflussen, also Kamerafahrten usw sind dann Sache von Freaks wie dir^^

    Der Speedunterschied zum GDI-"blitten" ist jedenfalls gewaltig, habe schon Funktionen, um die Ausführungszeiten und Buffertransferzeiten vom CL-Kernel zu messen, die Ergebnisse sind Beeindruckend....

  • Naja,
    die Frage ist, ob ich jemandem den Umstieg von GDI nach OpenGL schmackhaft mache, indem ich ihm mit 50 Zeilen GL-Code zeige, was er mit GDI in 5 Zeilen hinbekommt...
    Dass bei GL 50% der Befehle "Standard" sind, die immer und ewig in jedem Programm durchgenudelt werden müssen, weiss der GDI-User vorher nicht!

    Wenn ich aber (schau dir dazu meine Beispiele in OpenCl an) eine Zeile "abstrahierten GL-Code" fürs Fenster erstellen habe, eine weitere, um eine *.PNG in diesem Fenster darzustellen, eine dritte, um einen xyz-Filter über diese Grafik laufen zu lassen, ja DANN wird der GDI-Fuzzi plötzlich wach ;)
    3D alleine ist ja nur die halbe Wahrheit, auch in 2D hat OpenGL Vorteile.

    Zitat

    Sonst bringen allgemeine Tutorials für OpenGl den Nutzern nichts mehr

    Ganz ehrlich, schau dich mal im Internet zum Thema "allgemeine Tutorials" um. Wenn der "Nutzer" davon 5% gebrauchen kann, dann ist das bestimmt nicht weit weg von der Wahrheit. Ich brauche ein Tutorial, um herauszufinden, ob ich mein Problem mit einfachen Mitteln und einem entsprechenden Werkzeug lösen kann.
    Ich habe ca. 1h damit zugebracht, die "wehende Deutschlandfahne" aus deinem Beispiel vollflächig gerade und fensterfüllend, also "native 2D" darzustellen. Mit Hilfe von ca. 5 weiteren "Tutorials" aus dem Inet. Soviel dazu :rolleyes:
    Dass diese Aktion auch noch 20 Zeilen Code braucht, und ich bei den meisten Funktions-Parametern auch noch rumspielen musste um herauszubekommen, was sie für einen Zweck erfüllen, hat mich ehrlich gesagt nicht begeistert!

  • Der Umstieg von GDI zu OpenGL. Wie bereits mehrfach erwähnt ist OpenGl nicht darauf ausgelegt Einfachst-Befehle zu bieten. Wenn dies der Wunsch ist, dann habe ich für diesen Zweck das ext-Include gemacht.

    Such ich nach OpenGl Tutorials (NeHe, das offizielle, BASIC) dann zeigt OpenGl seine Stärken, die in den immer gleichen Befehlen liegt! Man kann es 1:1 portieren ^^. Der Nutzer kann weit über 50% der vorhandenen OpenGl Tuts nutzen :P, so wie ich es auch getan habe.

    Klar ist OpenGl 2D wie auch 3D begabt. Dazu gibt es übrigens noch einige Funktionen in der soil. Manchmal hilft es auch einfach die API Doku zu lesen, welche bei glfw, ogl, soil eine der Besten ist, die ich je lesen durfte.

    -> Wenn du abstrahieren willst, dann erstelle die Funktionen im der ext. ABER, damit man Standard-Ressourcen nutzen kann - jeder - sollten die originalen Befehle erhalten bleiben, DENN dies ist bei GDI genauso der Fall und einfach Standard beim Programmieren. Erst wenn die Funktionen - die genau das tun, und genau so aussehen wie in der DLL oder anderen Programmiersprachen - funktionieren, kann man abstrahieren. Dennoch muss die Systemübergreifende Kompatibilität gewährleistet sein, was der Grundgedanke bei OpenGL ist. Soviel dazu :rolleyes: :P

    Wenn dich erste Gehversuche frustrieren, dann befass dich weiter damit, oder frag einfach ^^. (Für OpenGl gibts übrigens auch eine wunderbare Onlinehilfe). Gegen einfache Befehle hat keiner was - schon gar nicht ich - allerdings müssen die Grundstrukturen verfügbar sein. Ansonsten sind alles bloß "blinde Nutzer", die bei Tweaks, die manchmal nur durch einen einzelnen kleinen Befehl erreicht werden, nicht mehr weiterwissen.

    Mal OT:
    GDI wird von Microsoft auch gerade etwas verstoßen (eigentlich schon länger). Statt sich weiter auf den "Ausbau" von GDI zu konzentrieren sollte man den von MS vorgeschlagenen Weg gehen und mal DirectX benutzen ^^. Denn irgendwann ist Sense mit dem GDI Zeugs - und dann stehn se da :D

  • minx: Hast du evtl. schonwas erreicht bei Embedded OpenGl-Fenster?

    Ich hab es mal probiert wie bei Embedded Notepad mit dem _WinAPI_SetParent. Das ist aber Müll.

  • Zwei etwas "bünzlige" Bemerkungen:
    1. Beim Beispiel mit der Erde (Sphere) steht in der Titelleiste "Spining Cube" ^^
    2. Beim Beispiel "Snow" erscheint etwa in der Mitte des Bildschirms ein kleiner roter Strich

    Bin eg. kein grosser Fan von OpenGL, aber an und zu doch recht praktisch wenn man nicht gleich 100 neue Dinge lernen muss nur um ein 3D-Objekt anzuzeigen ;) Seltsam, dass momentan immer sobald ich bei einem Skript festsitze jemand (unbeabsichtigt) eine Lösung dafür postet ^^ Besten Dank

    Bild1: Ich beim debuggen

  • Der kleine Rote Strich ist ein 3D Zeiger, der Windrichtung und Windstärke anzeigt. Die kannst du beide mit der Tastatur beeinflussen :rolleyes: