Einführung in OpenGL mit GLUT / Freeglut / Kohei Tokai / Engineering Co., Ltd. ist.
Hauptsächlich Linux Mint, sekundäres Windows. OpenGL Es ist eine glBegin-Methode, die hier und da als "alt" oder "jetzt" geschrieben wird.
Starten Sie die Seite OpenGL (2) PyOpenGL mit Python installieren, die nach der Suche nach "pyglfw tutorial" angezeigt wird. Wenn Sie nur die Essenz verlassen,
# based on https://maku.blog/p/665rua3/
import glfw
from OpenGL.GL import *
if not glfw.init():
raise RuntimeError('Could not initialize GLFW3')
window = glfw.create_window(300, 300, 'Program', None, None)
if not window:
glfw.terminate()
raise RuntimeError('Could not create an window')
glfw.make_context_current(window)
while not glfw.window_should_close(window):
glfw.poll_events()
glfw.terminate()
Wenn Sie dies jedoch tun, während Sie den Systemmonitor ausführen, ist einer der CPU-Kerne 100%. poll_events () endet in einem Augenblick, ruft dies jedoch wiederholt auf. Es ist eine gute Idee, eine Pause zu machen. damit
import time
time.sleep(1e-3)
Einfach reinstecken. Aber muss ich das selbst machen? Es wurde vorbereitet.
glfw.wait_events_timeout(1e-3)
Ist. Daher basiert es auf dem vorherigen Code "poll_events ()", der in "glfw.wait_events_timeout (1e-3)" geändert wurde. [Postscript] Ich fand es anders. Es ist "glfw.wait_events ()" anstelle von "glfw.wait_events_timeout (1e-3)". Sie müssen die Referenz richtig lesen.
It puts the thread to sleep until at least one event has been received and then processes all received events. This saves a great deal of CPU cycles and is useful for, for example, editing tools.
(Dieser Satz ist eine Anleitung, keine Referenz). Der Code auf dieser Seite wurde behoben. Ich war überzeugt, dass die ereignisgesteuerte Schleife schnell laufen musste.
glfw.wait_events_timeout () ist nützlich in der Animation.
Die Schleife kann "pass" sein, weil sie nichts bewirkt. Sie akzeptiert nicht einmal das x-Ereignis, das Sie drücken, um das Programm zu beenden, und es gibt keine Möglichkeit, es zu beenden. Wenn Sie weiterhin x drücken, wird "Keine Antwort vom Programm" angezeigt.
version.py
import glfw
from OpenGL.GL import *
print('GLFW version:', glfw.get_version())
if not glfw.init():
raise RuntimeError('Could not initialize GLFW3')
window = glfw.create_window(300, 300, 'prog1 5.1', None, None)
if not window:
glfw.terminate()
raise RuntimeError('Could not create an window')
glfw.make_context_current(window)
print('Vendor :', glGetString(GL_VENDOR))
print('GPU :', glGetString(GL_RENDERER))
print('OpenGL version :', glGetString(GL_VERSION))
glfw.terminate()
In meiner Umgebung war die GLFW-Version 3.2.1 für Linux Mint und 3.3.2 für Windows. (26.4.2020)
Aber. Unter Windows mit zwei alten Maschinen The driver does not appear to support OpenGL. Absturz mit der Nachricht. In beiden Fällen sind die Grafiken in die CPU integriert. Einer ist der i3 M380, was natürlich ist, da der Abschnitt OpenGL-Version bei Anzeige mit der Software OpenGL Extension Viewer nicht zutreffend ist. Der andere ist i5-2500, und Viewer sagt Version 3.1, aber er stürzt ab, wenn ich den Rendering-Test von Viewer durchführe. Das Grafiksystem soll OpenGL unterstützen, aber es scheint nicht zu funktionieren.
Da es sich um ein Ereignis handelt, müssen Sie zuerst das Ereignis kennen. event.py ist ein Programm, das zwei wichtige fensterbezogene Ereignisse erkennt, window_size und window_refresh. In GLFW heißt die Funktion, die den Rückruf an ein Ereignis bindet, "glfw.set_xxx_callback". Da das erste Argument dieser Funktionen window ist, werden wir sie nach dem Erstellen des Fensters aufrufen (nach glfw.create_window).
win_event.py
# mini version
# size is NOT invoked at start.
# refresh is NOT invoked at start on Windows.
import glfw
from OpenGL.GL import *
def init():
glClearColor(0.0, 0.0, 1.0, 1.0)
def window_size(window, w, h):
global n_size
n_size += 1
print('Size', n_size, w, h)
def window_refresh(window):
global n_refresh
n_refresh += 1
print('Refresh', n_refresh)
n_size = 0
n_refresh = 0
if not glfw.init():
raise RuntimeError('Could not initialize GLFW3')
window = glfw.create_window(300, 300, 'Window events', None, None)
if not window:
glfw.terminate()
raise RuntimeError('Could not create an window')
glfw.set_window_size_callback(window, window_size)
glfw.set_window_refresh_callback(window, window_refresh)
glfw.make_context_current(window)
init()
while not glfw.window_should_close(window):
glfw.wait_events()
glfw.terminate()
Wenn Sie dies unter Windows ausführen, können Sie sehen, dass das Fenster erstellt wurde, aber kein Ereignis ausgelöst wurde. Beachten Sie, dass die Aktualisierung unter Linux erfolgt. Es ist sehr problematisch, dass die Bedienung je nach Betriebssystem unterschiedlich ist. Damit es auf beiden Betriebssystemen mit einem Code funktioniert, muss das Betriebssystem erkannt oder mit Windows abgeglichen werden, das nicht auftritt. (Ergänzung: Es kann ein Unterschied in der GLFW-Version sein, kein Unterschied im Betriebssystem.)
Wenn Sie jetzt darüber nachdenken, ist die Aktualisierung nur eine Neuauflage. Es ist keine Belichtung, die in solchen Situationen häufig verwendet wird. Es kann das Argument von GLFW sein, dass die erste Zeichnung genau das ist. Außerdem geben wir die Größe an, wenn wir glfw.create_window aufrufen. Es kann das Argument von GLFW sein, dass Sie die Anfangsgröße kennen.
Aus diesem Grund ist es problematisch, dass die anfängliche Operation nicht dem Rückruf überlassen werden kann.
Wenn Sie das Fenster als Symbol symbolisieren und dann erneut öffnen, tritt unter Linux kein Ereignis auf, aber unter Windows. Es tritt kein Ereignis auf, wenn ein Teil des Fensters von einem anderen Fenster ausgeblendet und dann wieder nach vorne gebracht wird.
Wenn Sie die Größe des Fensters mit der Maus leicht ändern, können Sie als Nächstes sehen, dass die Größen- und Aktualisierungsereignisse paarweise in dieser Reihenfolge auftreten.
Ich werde auch die Vollversion posten.
win_event_full.py
# full version
# size is NOT invoked at start.
# refresh is NOT invoked at start on Windows.
# size is invoked at iconify on Windows.
import glfw
from OpenGL.GL import *
def init():
glClearColor(0.0, 0.0, 1.0, 1.0)
def window_size(window, w, h):
global n_size
n_size += 1
print('Size', n_size, w, h)
def framebuffer_size(window, w, h):
global n_FB_size
n_FB_size += 1
print('Framebuffer Size', n_FB_size, w, h)
def window_pos(window, x, y):
global n_pos
n_pos += 1
print('Position', n_pos, x, y)
def window_iconify(window, iconified):
global n_icon
n_icon += 1
print('Iconify', n_size, iconified)
def window_refresh(window):
global n_refresh
n_refresh += 1
print('Refresh', n_refresh)
n_size = 0
n_FB_size = 0
n_pos = 0
n_icon = 0
n_refresh = 0
if not glfw.init():
raise RuntimeError('Could not initialize GLFW3')
window = glfw.create_window(300, 300, 'Window events', None, None)
if not window:
glfw.terminate()
raise RuntimeError('Could not create an window')
glfw.set_window_size_callback(window, window_size)
glfw.set_framebuffer_size_callback(window, framebuffer_size)
glfw.set_window_pos_callback(window, window_pos)
glfw.set_window_iconify_callback(window, window_iconify)
glfw.set_window_refresh_callback(window, window_refresh)
glfw.make_context_current(window)
init()
while not glfw.window_should_close(window):
glfw.wait_events()
glfw.terminate()
Dies ist das Basisprogramm für Standbilder, die sich überhaupt nicht bewegen. 5.1 im Dateinamen hängt von der Basis ab, also keine Sorge.
Python:prog1_5.1_GLFW.py
import glfw
from OpenGL.GL import *
def display():
glClear(GL_COLOR_BUFFER_BIT)
glBegin(GL_LINE_LOOP)
glVertex2d(-0.9, -0.9)
glVertex2d( 0.9, -0.9)
glVertex2d( 0.9, 0.9)
glVertex2d(-0.9, 0.9)
glEnd()
glfw.swap_buffers(window)
def init():
glClearColor(0.0, 0.0, 1.0, 1.0)
display() # necessary only on Windows
def window_refresh(window):
display()
if not glfw.init():
raise RuntimeError('Could not initialize GLFW3')
window = glfw.create_window(300, 300, 'prog1 5.1', None, None)
if not window:
glfw.terminate()
raise RuntimeError('Could not create an window')
glfw.set_window_refresh_callback(window, window_refresh)
glfw.make_context_current(window)
init()
while not glfw.window_should_close(window):
glfw.wait_events()
glfw.terminate()
Da das Zeichnen für die Anfangsphase und window_refresh erforderlich ist, wird es als display bezeichnet und ist unabhängig von der Rückruffunktion window_refresh.
Da GLFW von Anfang an doppelt puffert, ist das Ende der Anzeigefunktion glfw.swap_buffers.
Was macht die Funktion make_context_current übrigens? Machen Sie den Kontext "aktuell" ... Das Argument ist Fenster. Ein Programm kann mehrere Fenster haben. Es ist make_context_current, das bestimmt, für welches Fenster die aktuelle Operation ist. 2wins.py ist ein Programm mit zwei Fenstern. In diesem Fall können wir nicht die ganze Zeit in einem Fenster auf ein Ereignis warten, daher verwenden wir "glfw.wait_events_timeout ()" anstelle von "glfw.wait_events".
2wins.py
import glfw
from OpenGL.GL import *
class GLwin:
def __init__(self, title, xpos, ypos, window_refresh_fun, init_fun):
self.window = glfw.create_window(300, 300, title, None, None)
if not self.window:
glfw.terminate()
raise RuntimeError('Could not create an window')
glfw.set_window_pos(self.window, xpos, ypos)
glfw.set_window_refresh_callback(self.window, window_refresh_fun)
glfw.make_context_current(self.window)
init_fun(self.window)
def window_should_close(self):
return glfw.window_should_close(self.window)
def wait_events_timeout(self):
glfw.make_context_current(self.window)
glfw.wait_events_timeout(1e-3)
def display1(window):
glClear(GL_COLOR_BUFFER_BIT)
glLineWidth(15)
glColor3d(1.0, 1.0, 0.0)
glBegin(GL_LINES)
glVertex2d(-0.8, 0.0)
glVertex2d( 0.8, 0.0)
glEnd()
glfw.swap_buffers(window)
def display2(window):
glClear(GL_COLOR_BUFFER_BIT)
glLineWidth(15)
glColor3d(1.0, 0.0, 1.0)
glBegin(GL_LINES)
glVertex2d(0.0, -0.8)
glVertex2d(0.0, 0.8)
glEnd()
glfw.swap_buffers(window)
def init1(window):
glClearColor(1.0, 0.0, 0.0, 1.0)
display1(window) # necessary only on Windows
def init2(window):
glClearColor(0.0, 1.0, 0.0, 1.0)
display2(window) # necessary only on Windows
def window_refresh1(window):
display1(window)
def window_refresh2(window):
display2(window)
if not glfw.init():
raise RuntimeError('Could not initialize GLFW3')
glwin1 = GLwin('Window 1', 100, 200, window_refresh1, init1)
glwin2 = GLwin('Window 2', 450, 200, window_refresh2, init2)
while not ( glwin1.window_should_close() or glwin2.window_should_close() ):
glwin1.wait_events_timeout()
glwin2.wait_events_timeout()
glfw.terminate()
Die Veranstaltung ist wie folgt. cursor_pos Wenn sich der Cursor bewegt cursor_enter Wenn der Cursor das Fenster betritt oder verlässt mouse_button Wenn die Maustaste gedrückt wird scrollen Wenn das Einstellrad in der Mitte der Maus gedreht wird (y), wenn es nach links oder rechts geneigt ist (x)
In GLFW können die Koordinaten x und y nicht abgerufen werden. Wenn die Koordinaten benötigt werden, erhalten Sie sie mit glfw.get_cursor_pos.
mouse_event.py
import glfw
from OpenGL.GL import *
def init():
glClearColor(0.0, 0.0, 1.0, 1.0)
display() # necessary only on Windows
def display():
glClear(GL_COLOR_BUFFER_BIT)
glfw.swap_buffers(window)
def cursor_pos(window, xpos, ypos):
print('cursor_pos:', xpos, ypos)
def cursor_enter(window, entered):
print('cursor_enter:', entered)
def mouse_button(window, button, action, mods):
pos = glfw.get_cursor_pos(window)
print('mouse:', button, end='')
if button == glfw.MOUSE_BUTTON_LEFT:
print('(Left)', end='')
if button == glfw.MOUSE_BUTTON_RIGHT:
print('(Right)', end='')
if button == glfw.MOUSE_BUTTON_MIDDLE:
print('(Middle)', end='')
if action == glfw.PRESS:
print(' press')
elif action == glfw.RELEASE:
print(' release')
else:
print(' hogehoge')
x, y = pos
print(pos, x, y)
def scroll(window, xoffset, yoffset):
print('scroll:', xoffset, yoffset)
def window_refresh(window):
display()
if not glfw.init():
raise RuntimeError('Could not initialize GLFW3')
window = glfw.create_window(300, 300, 'mouse on GLFW', None, None)
if not window:
glfw.terminate()
raise RuntimeError('Could not create an window')
glfw.set_cursor_pos_callback(window, cursor_pos)
glfw.set_cursor_enter_callback(window, cursor_enter)
glfw.set_mouse_button_callback(window, mouse_button)
glfw.set_scroll_callback(window, scroll)
glfw.set_window_refresh_callback(window, window_refresh)
glfw.make_context_current(window)
init()
while not glfw.window_should_close(window):
glfw.wait_events()
glfw.terminate()
Was Sie mit key erhalten, ist ein ganzzahliger Wert, der als Schlüsselcode bezeichnet wird. Sie müssen jedoch nicht wissen, wie hoch der Schlüsselcode für den Schlüssel XX ist. Alle Schlüssel haben Konstanten. Das Programm zeigt Beispiele für A, Cursortasten nach oben und Eingabe.
keyboard.py
import glfw
from OpenGL.GL import *
def display():
glClear(GL_COLOR_BUFFER_BIT)
glfw.swap_buffers(window)
def init():
glClearColor(0.0, 0.0, 1.0, 1.0)
display() # necessary only on Windows
def keyboard(window, key, scancode, action, mods):
print('KB:', key, chr(key), end=' ')
if action == glfw.PRESS:
print('press')
elif action == glfw.REPEAT:
print('repeat')
elif action == glfw.RELEASE:
print('release')
if key == glfw.KEY_A:
print('This is A.')
elif key == glfw.KEY_UP:
print('This is Up.')
elif key == glfw.KEY_ENTER:
print('This is Enter.')
def window_refresh(window):
display()
if not glfw.init():
raise RuntimeError('Could not initialize GLFW3')
window = glfw.create_window(300, 300, 'KB on GLFW', None, None)
if not window:
glfw.terminate()
raise RuntimeError('Could not create an window')
glfw.set_key_callback(window, keyboard)
glfw.set_window_refresh_callback(window, window_refresh)
glfw.make_context_current(window)
init()
while not glfw.window_should_close(window):
glfw.wait_events()
glfw.terminate()
pyglfws Was scheint eine Projektseite zu sein sagt nicht viel. Auf dieser Seite befindet sich ein Link namens Homepage, der jedoch unterbrochen ist. Es gibt eine Seite namens Spiegeln. Ich möchte eine Referenz auf einer solchen Seite sehen, kann sie aber nicht finden.
Schauen Sie sich also die [GLFW-Seite] an (https://www.glfw.org/). Wenn Sie zu Dokumentation> HTML-Dokumentation gehen, finden Sie sowohl Tutorial als auch Referenz.
Die Frage ist, die GLFW-Seite ist in C geschrieben, aber was passiert in Python?
Wenn Sie die vorherigen mit Funktionen vergleichen, glfwCreateWindow → glfw.create_window Es sieht aus wie das. Kamelkoffer → Schlangenkoffer. Die Anzahl der Argumente kann zwischen C und Python unterschiedlich sein. Pythons glfw.get_cursor_pos (Fenster) hat ein Argument, nur Fenster, und gibt die Koordinaten in tapple, aber in C zurück void glfwGetCursorPos(GLFWwindow * window, double * xpos, double * ypos); Es ist in Form von.
Für Konstanten sieht es so aus: GLFW_MOUSE_BUTTON_LEFT → glfw.MOUSE_BUTTON_LEFT.
Lassen Sie uns Code wie diesen haben. In der Funktion "Größe ändern" müssen in Windows Maßnahmen gegen das Ereignis "window_size" ergriffen werden, das zum Zeitpunkt der Symbolisierung auftritt und dessen Fenstergröße 0 wird.
[Postscript 2020/5/19] Die Funktionsargumente wurden im Abschnitt Libapi der pyglfw-Projektseite beschrieben, auf dem oben "Keine große Sache" stand.
Python:8.4_GLFW.py
import glfw
from OpenGL.GL import *
from OpenGL.GLU import *
W_INIT = 360
H_INIT = 300
VERTEX = [
[0.0, 0.0, 0.0], # A
[1.0, 0.0, 0.0], # B
[1.0, 1.0, 0.0], # C
[0.0, 1.0, 0.0], # D
[0.0, 0.0, 1.0], # E
[1.0, 0.0, 1.0], # F
[1.0, 1.0, 1.0], # G
[0.0, 1.0, 1.0] # H
]
EDGE = [
[0, 1], # a (A-B)
[1, 2], # i (B-C)
[2, 3], # u (C-D)
[3, 0], # e (D-A)
[4, 5], # o (E-F)
[5, 6], # ka (F-G)
[6, 7], # ki (G-H)
[7, 4], # ku (H-E)
[0, 4], # ke (A-E)
[1, 5], # ko (B-F)
[2, 6], # sa (C-G)
[3, 7] # shi (D-H)
]
def display():
glClear(GL_COLOR_BUFFER_BIT)
glBegin(GL_LINES)
for edge1 in EDGE:
for i in edge1:
glVertex3dv(VERTEX[i])
glEnd()
glfw.swap_buffers(window)
def set_view(w, h):
glLoadIdentity()
gluPerspective(35.0, w/h, 1.0, 100.0)
gluLookAt(3.0, 4.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0)
def resize(window, w, h):
# for iconify on Windows
if h==0:
return
glViewport(0, 0, w, h)
set_view(w, h)
def init():
gray = 0.6
glClearColor(gray, gray, gray, 1.0)
set_view(W_INIT, H_INIT)
display() # necessary only on Windows
def window_refresh(window):
display()
if not glfw.init():
raise RuntimeError('Could not initialize GLFW3')
window = glfw.create_window(W_INIT, H_INIT, 'Wireframe', None, None)
if not window:
glfw.terminate()
raise RuntimeError('Could not create an window')
glfw.set_window_size_callback(window, resize)
glfw.set_window_refresh_callback(window, window_refresh)
glfw.make_context_current(window)
init()
while not glfw.window_should_close(window):
glfw.wait_events()
glfw.terminate()
In der Schleife kann, wenn sie ausgeführt wird, die folgende Zeichnung ausgeführt werden, und poll_events, andernfalls wait_events_timeout. Während der Ausführung ist es langsamer, wenn Sie wait_events_timeout anstelle von poll_events festlegen. Wenn Sie DOUBLE_BUFFERING am Anfang auf False setzen, wird eine einzelne Pufferung erstellt, die flackert, anstatt schnell zu sein.
Python:9.1-2_GLFW.py
import glfw
from OpenGL.GL import *
from OpenGL.GLU import *
DOUBLE_BUFFERING = True
W_INIT = 320
H_INIT = 240
VERTEX = [
[0.0, 0.0, 0.0], # A
[1.0, 0.0, 0.0], # B
[1.0, 1.0, 0.0], # C
[0.0, 1.0, 0.0], # D
[0.0, 0.0, 1.0], # E
[1.0, 0.0, 1.0], # F
[1.0, 1.0, 1.0], # G
[0.0, 1.0, 1.0] # H
]
EDGE = [
[0, 1], # a (A-B)
[1, 2], # i (B-C)
[2, 3], # u (C-D)
[3, 0], # e (D-A)
[4, 5], # o (E-F)
[5, 6], # ka (F-G)
[6, 7], # ki (G-H)
[7, 4], # ku (H-E)
[0, 4], # ke (A-E)
[1, 5], # ko (B-F)
[2, 6], # sa (C-G)
[3, 7] # shi (D-H)
]
def display():
global r
glClear(GL_COLOR_BUFFER_BIT)
glLoadIdentity()
gluLookAt(3.0, 4.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0)
glRotated(r, 0.0, 1.0, 0.0)
glColor3d(0.0, 0.0, 0.0)
glBegin(GL_LINES)
for edge1 in EDGE:
for i in edge1:
glVertex3dv(VERTEX[i])
glEnd()
if DOUBLE_BUFFERING:
glfw.swap_buffers(window)
else:
glFlush()
r += 1
if r==360:
r = 0
def set_view(w, h):
glMatrixMode(GL_PROJECTION)
glLoadIdentity()
gluPerspective(35.0, w/h, 1.0, 100.0)
glMatrixMode(GL_MODELVIEW)
def resize(window, w, h):
# for iconify on Windows
if h==0:
return
glViewport(0, 0, w, h)
set_view(w, h)
def mouse_button(window, button, action, mods):
global rotation
if action == glfw.PRESS:
rotation = ( button == glfw.MOUSE_BUTTON_LEFT )
def init():
gray = 0.8
glClearColor(gray, gray, gray, 1.0)
set_view(W_INIT, H_INIT)
display() # necessary only on Windows
def window_refresh(window): # for resize
display()
r = 0
rotation = False
if not glfw.init():
raise RuntimeError('Could not initialize GLFW3')
if not DOUBLE_BUFFERING:
glfw.window_hint(glfw.DOUBLEBUFFER, glfw.FALSE)
window = glfw.create_window(W_INIT, H_INIT, 'Animation on GLFW', None, None)
if not window:
glfw.terminate()
raise RuntimeError('Could not create an window')
glfw.set_mouse_button_callback(window, mouse_button)
glfw.set_window_size_callback(window, resize)
glfw.set_window_refresh_callback(window, window_refresh)
glfw.make_context_current(window)
init()
while not glfw.window_should_close(window):
if rotation:
display()
glfw.poll_events()
# glfw.wait_events_timeout(1e-2)
else:
glfw.wait_events_timeout(1e-3)
glfw.terminate()
Recommended Posts