Python之OpenGL笔记(22)：箭头控制平面直角坐标系中的圆圈移动

一、目的

1、箭头控制平面直角坐标系中的圆圈上下左右移动；

二、程序运行结果

三、glfw回调函数set_key_callback

glfw.set_key_callback(window, on_key) 设置键盘回调函数。
def on_key(window, key, scancode, action, mods):打开键（窗体、键值、扫描码、动作、辅助键）
   参数说明：
   window ：发生事件的窗体
   key ：激发的键值
   scancode ：键值的系统扫描码
   action：动作GLFW_PRESS, GLFW_RELEASE or GLFW_REPEAT.
   mods： 辅助键ALT，CTRL，SHIFT，META

四、glfw键值

KEY_0 = 48
KEY_1 = 49
KEY_2 = 50
KEY_3 = 51
KEY_4 = 52
KEY_5 = 53
KEY_6 = 54
KEY_7 = 55
KEY_8 = 56
KEY_9 = 57
KEY_A = 65
KEY_APOSTROPHE = 39
KEY_B = 66
KEY_BACKSLASH = 92
KEY_BACKSPACE = 259
KEY_C = 67
KEY_CAPS_LOCK = 280
KEY_COMMA = 44
KEY_D = 68
KEY_DELETE = 261
KEY_DOWN = 264
KEY_E = 69
KEY_END = 269
KEY_ENTER = 257
KEY_EQUAL = 61
KEY_ESCAPE = 256
KEY_F = 70
KEY_F1 = 290
KEY_F10 = 299
KEY_F11 = 300
KEY_F12 = 301
KEY_F13 = 302
KEY_F14 = 303
KEY_F15 = 304
KEY_F16 = 305
KEY_F17 = 306
KEY_F18 = 307
KEY_F19 = 308
KEY_F2 = 291
KEY_F20 = 309
KEY_F21 = 310
KEY_F22 = 311
KEY_F23 = 312
KEY_F24 = 313
KEY_F25 = 314
KEY_F3 = 292
KEY_F4 = 293
KEY_F5 = 294
KEY_F6 = 295
KEY_F7 = 296
KEY_F8 = 297
KEY_F9 = 298
KEY_G = 71
KEY_GRAVE_ACCENT = 96
KEY_H = 72
KEY_HOME = 268
KEY_I = 73
KEY_INSERT = 260
KEY_J = 74
KEY_K = 75
KEY_KP_0 = 320
KEY_KP_1 = 321
KEY_KP_2 = 322
KEY_KP_3 = 323
KEY_KP_4 = 324
KEY_KP_5 = 325
KEY_KP_6 = 326
KEY_KP_7 = 327
KEY_KP_8 = 328
KEY_KP_9 = 329
KEY_KP_ADD = 334
KEY_KP_DECIMAL = 330
KEY_KP_DIVIDE = 331
KEY_KP_ENTER = 335
KEY_KP_EQUAL = 336
KEY_KP_MULTIPLY = 332
KEY_KP_SUBTRACT = 333
KEY_L = 76
KEY_LAST = 348
KEY_LEFT = 263
KEY_LEFT_ALT = 342
KEY_LEFT_BRACKET = 91
KEY_LEFT_CONTROL = 341
KEY_LEFT_SHIFT = 340
KEY_LEFT_SUPER = 343
KEY_M = 77
KEY_MENU = 348
KEY_MINUS = 45
KEY_N = 78
KEY_NUM_LOCK = 282
KEY_O = 79
KEY_P = 80
KEY_PAGE_DOWN = 267
KEY_PAGE_UP = 266
KEY_PAUSE = 284
KEY_PERIOD = 46
KEY_PRINT_SCREEN = 283
KEY_Q = 81
KEY_R = 82
KEY_RIGHT = 262
KEY_RIGHT_ALT = 346
KEY_RIGHT_BRACKET = 93
KEY_RIGHT_CONTROL = 345
KEY_RIGHT_SHIFT = 344
KEY_RIGHT_SUPER = 347
KEY_S = 83
KEY_SCROLL_LOCK = 281
KEY_SEMICOLON = 59
KEY_SLASH = 47
KEY_SPACE = 32
KEY_T = 84
KEY_TAB = 258
KEY_U = 85
KEY_UNKNOWN = -1
KEY_UP = 265
KEY_V = 86
KEY_W = 87
KEY_WORLD_1 = 161
KEY_WORLD_2 = 162
KEY_X = 88
KEY_Y = 89
KEY_Z = 90

五、源代码

"""
dalong2020_3.py
Author: dalong10
Description: Draw a Circle, learning OPENGL 
"""
import glutils    #Common OpenGL utilities,see glutils.py  
import sys, random, math
import OpenGL
from OpenGL.GL import *
from OpenGL.GL.shaders import *
import numpy 
import numpy as np
import glfw

strVS = """
#version 330 core
layout(location = 0) in vec3 position;
uniform float a;
uniform float b;
uniform float c;
void main(){
	mat4 rot1=mat4(vec4(1.0, 0.0,0.0,0),
				vec4(0.0, 1.0,0.0,0),
				vec4(0.0,0.0,1.0,0.0),
				vec4(a,b,c,1.0));
	gl_Position =rot1 * vec4(position.x, position.y, position.z, 1.0);
	}
"""

strFS1 = """
#version 330 core
out vec4 color;
void main(){
	color = vec4(1.0, 0.0, 0.0, 1.0);
	}
"""

strFS2 = """
#version 330 core
out vec4 color;
void main(){
	color = vec4(1.0, 1.0, 0.0, 1.0);
	}
"""

class FirstCircle:
    def __init__(self, myFS,myvertices):
        self.myFS = myFS
        self.vertices = myvertices

        # load shaders
        if myFS>0:
            strFS=strFS1
        else:
            strFS=strFS2	
        self.program = glutils.loadShaders(strVS, strFS)
        glUseProgram(self.program)
        
        vertices =  myvertices       
        # set up vertex array object (VAO)
        self.vao = glGenVertexArrays(1)
        glBindVertexArray(self.vao)
        # set up VBOs
        vertexData = numpy.array(vertices, numpy.float32)
        self.vertexBuffer = glGenBuffers(1)
        glBindBuffer(GL_ARRAY_BUFFER, self.vertexBuffer)
        glBufferData(GL_ARRAY_BUFFER, 4*len(vertexData), vertexData, 
                     GL_STATIC_DRAW)
        #enable arrays
        self.vertIndex = 0
        glEnableVertexAttribArray(self.vertIndex)
        # set buffers 
        glBindBuffer(GL_ARRAY_BUFFER, self.vertexBuffer)
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, None)
        # unbind VAO
        glBindVertexArray(0)

    def render(self, myFS,xx,yy,zz):
        # use shader
        glUseProgram(self.program)
        # bind VAO
        glBindVertexArray(self.vao)
        # draw
        if myFS>0:
            glUniform1f(glGetUniformLocation(self.program, "a"), xx)
            glUniform1f(glGetUniformLocation(self.program, "b"), yy)
            glUniform1f(glGetUniformLocation(self.program, "c"), zz)
            glDrawArrays(GL_LINE_LOOP, 0, 60 )
        else:
            glDrawArrays(GL_LINES, 0, self.vertices.size )
        # unbind VAO
        glBindVertexArray(0)

def drawCircle( x0,y0,R):
    PI = 3.14159265358979323846264
    statcky=60  #分成60份
    angleHy =  (2*PI)/statcky
    NumAngleHy = 0.0 # 当前横向角度
    d=numpy.array([], numpy.float32)
    for i in range(statcky):    #描点法画圆
        NumAngleHy = angleHy*i  # 
        x=R*np.cos(NumAngleHy)
        y=R*np.sin(NumAngleHy)
        d=np.hstack((d,numpy.array([x0+x,y0+y,0], numpy.float32) ))
    #d=np.hstack((d, numpy.array([x+R,y+R,0], numpy.float32) )) 
    return numpy.array(d, numpy.float32)

#Is called whenever a key is pressed/released via GLFW
def on_key(window, key, scancode, action, mods):
    if key == glfw.KEY_ESCAPE and action == glfw.PRESS:
        glfw.set_window_should_close(window,1)
    elif key >0  and key<1024 :
        if action == glfw.PRESS:
            keys[key]=True
        elif (action == glfw.RELEASE):
            keys[key]=False 

def do_movement():
    global xx
    global yy  
    #Key controls
    if (keys[glfw.KEY_UP]):
        if yy<1.0:
            yy = yy+0.01
    if (keys[glfw.KEY_DOWN]):
        if yy>-1.0:
            yy = yy-0.01
    if (keys[glfw.KEY_RIGHT]):
        if xx<1.0:
            xx = xx+0.01
    if (keys[glfw.KEY_LEFT]):
        if xx>-1.0:
            xx = xx-0.01
    if (keys[glfw.KEY_ENTER]):
        xx =0
        yy =0


if __name__ == '__main__':
    import sys
    import glfw
    import OpenGL.GL as gl
    global xx
    global yy  
    keys=numpy.zeros(1024)

    # Initialize the library
    if not glfw.init():
        sys.exit()

    # Create a windowed mode window and its OpenGL context
    window = glfw.create_window(400, 400, "Draw a Circle", None, None)
    if not window:
        glfw.terminate()
        sys.exit()

    # Make the window's context current
    glfw.make_context_current(window)
    # Install a key handler
    glfw.set_key_callback(window, on_key)
    
    t=0.9
    c=numpy.array([-t,0,0, t,0,0 , 0,t,0 , 0, -t, 0] , numpy.float32) #X,Y轴
    
    for i in range(19):    #X轴画线
        x=float(t*(-9.0+i)/10)
        c_i=numpy.array([x,0,0,x,0.02,0], numpy.float32)
        c=np.hstack((c,c_i ))
    c_i=numpy.array([t,0,0,t-0.02,0.02,0 , t,0,0,t-0.02,-0.02,0 ], numpy.float32)
    c=np.hstack((c,c_i ))
    for i in range(19):    #Y轴画线
        y=float(t*(-9.0+i)/10)
        c_i=numpy.array([0,y,0,0.02,y,0], numpy.float32)
        c=np.hstack((c,c_i ))
    c_i=numpy.array([0,t,0,0.02,t-0.02,0 ,0, t,0,-0.02,t-0.02,0 ], numpy.float32)
    c=np.hstack((c,c_i ))

    Circle1=drawCircle(0.0,0.0,0.2)

    xx=0.0
    yy=0.0
    zz=0    

    width, height = glfw.get_framebuffer_size(window)
    ratio = width / float(height)
    gl.glViewport(0, 0, width, height)
    gl.glClear(gl.GL_COLOR_BUFFER_BIT)
    gl.glClearColor(0.0,0.0,4.0,0.0)
    firstTriangle0 = FirstCircle(0,c)
    firstTriangle1 = FirstCircle(1,Circle1)
    # Loop until the user closes the window
    while not glfw.window_should_close(window):
        # Render here
        width, height = glfw.get_framebuffer_size(window)
        ratio = width / float(height)
        gl.glViewport(0, 0, width, height)
        gl.glClear(gl.GL_COLOR_BUFFER_BIT)
        glfw.poll_events()
        do_movement()
        # render
        firstTriangle0.render(0,0.0,0.0,0.0)
        firstTriangle1.render(1,xx,yy,zz)

        # Swap front and back buffers
        glfw.swap_buffers(window)

        # Poll for and process events
        glfw.poll_events()
    glfw.terminate()