gltests/tex_shader.py at main · pyunity/gltests · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
from OpenGL.GL import * # lgtm [py/polluting-import]
from PIL import Image
from ctypes import c_float, c_ubyte, c_void_p
import glm
import pygame

def convert(type, list):
    return (type * len(list))(*list)

def loadTexture(path):
    img = Image.open(path)
    img_data = img.tobytes()
    width, height = img.size
    texture = glGenTextures(1)
    glBindTexture(GL_TEXTURE_2D, texture)
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0,
        GL_RGB, GL_UNSIGNED_BYTE, img_data)
    glEnable(GL_TEXTURE_2D)
    return texture

class Shader:
    def __init__(self, vertex, frag):
        self.vertexShader = glCreateShader(GL_VERTEX_SHADER)
        glShaderSource(self.vertexShader, vertex, 1, None)
        glCompileShader(self.vertexShader)

        self.fragShader = glCreateShader(GL_FRAGMENT_SHADER)
        glShaderSource(self.fragShader, frag, 1, None)
        glCompileShader(self.fragShader)

        self.program = glCreateProgram()
        glAttachShader(self.program, self.vertexShader)
        glAttachShader(self.program, self.fragShader)
        glLinkProgram(self.program)

        success = glGetProgramiv(self.program, GL_LINK_STATUS)
        if not success:
            log = glGetProgramInfoLog(self.program, 512, None)
            print(log)

        glDeleteShader(self.vertexShader)
        glDeleteShader(self.fragShader)

        self.proj = glGetUniformLocation(self.program, b"projection")
        self.view = glGetUniformLocation(self.program, b"view")

    def use(self):
        glUseProgram(self.program)

screen = pygame.display.set_mode((800, 500), pygame.DOUBLEBUF | pygame.OPENGL)

shader = Shader(
"""#version 330 core
layout (location = 0) in vec3 aPos;
layout (location = 1) in vec3 aColor;
layout (location = 2) in vec2 aTexCoord;

uniform mat4 projection;
uniform mat4 view;

out vec4 gl_Position;
out vec3 ourColor;
out vec2 TexCoord;

void main()
{
    gl_Position = projection * view * vec4(aPos, 1.0);
    ourColor = aColor;
    TexCoord = vec2(aTexCoord.x, aTexCoord.y);
}""",
"""#version 330 core
out vec4 FragColor;

in vec3 ourColor;
in vec2 TexCoord;

uniform sampler2D ourTexture;

void main()
{
    FragColor = texture(ourTexture, TexCoord) * ourColor;
}"""
)

vertices = [
    # vertex       # color     # texcoord
    -1,  1,  0,    1, 0, 0,    0, 0,
     1,  1,  0,    0, 1, 0,    1, 0,
     1, -1,  0,    0, 0, 1,    1, 1,
    -1, -1,  0,    1, 1, 0,    0, 1
]

indices = [
    0, 1, 2,
    0, 2, 3,
]

img = loadTexture("..\\..\\pyunity.png")

vbo = glGenBuffers(1)
vao = glGenVertexArrays(1)
glBindVertexArray(vao)
glBindBuffer(GL_ARRAY_BUFFER, vbo)
glBufferData(GL_ARRAY_BUFFER, len(vertices) * sizeof(c_float), convert(c_float, vertices), GL_STATIC_DRAW)

glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(c_float), None)
glEnableVertexAttribArray(0)
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(c_float), c_void_p(3 * sizeof(c_float)))
glEnableVertexAttribArray(1)
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(c_float), c_void_p(6 * sizeof(c_float)))
glEnableVertexAttribArray(2)

ibo = glGenBuffers(1)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo)
glBufferData(GL_ELEMENT_ARRAY_BUFFER, len(indices), convert(c_ubyte, indices), GL_STATIC_DRAW)

view = glm.lookAt([0, 0, 7.5], [0, 0, 0], [0, 1, 0])
projection = glm.perspective(glm.radians(60), 800 / 500, 0.03, 50)
viewPtr, projPtr = glm.value_ptr(view), glm.value_ptr(projection)

done = False
clock = pygame.time.Clock()
while not done:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            done = True

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

    shader.use()
    glUniformMatrix4fv(shader.view, 1, GL_FALSE, viewPtr)
    glUniformMatrix4fv(shader.proj, 1, GL_FALSE, projPtr)
    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, None)

    pygame.display.flip()
    clock.tick(60)