def __init__(self):
self._shader_program = ShaderProgram(self._get_floor_vs_fn(), self._get_floor_fs_fn())
for _, attrib in EnvironmentRender.VertexAttributes.__members__.items():
self._shader_program.bind_attribute(attrib.value["location"], attrib.value["name"])
self._shader_program.compile()
vertices, normals, texcoords = mesh.create_grid_mesh(1000, 1000, 100)
self._vertices = np.asarray(vertices, dtype=np.float32)
self._normals = np.asarray(normals, dtype=np.float32)
self._texcoords = np.asarray(texcoords, dtype=np.float32)
print(self._texcoords)
self._vao = GL.glGenVertexArrays(1)
GL.glBindVertexArray(self._vao)
# Generate buffer object for the mesh vertices
self._vertex_bo = GL.glGenBuffers(1)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, self._vertex_bo)
GL.glBufferData(GL.GL_ARRAY_BUFFER, self._vertices.nbytes,
self._vertices, GL.GL_STATIC_DRAW)
# Setup Vertex Attrib Pointer
pos_attrib_pointer = EnvironmentRender.VertexAttributes.Position.value["location"]
GL.glEnableVertexAttribArray(pos_attrib_pointer)
GL.glVertexAttribPointer(pos_attrib_pointer, 3, GL.GL_FLOAT, False, 0, ctypes.c_void_p(0))
self._normal_bo = GL.glGenBuffers(1)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, self._normal_bo)
GL.glBufferData(GL.GL_ARRAY_BUFFER, self._normals.nbytes,
self._normals, GL.GL_STATIC_DRAW)
normal_attrib_pointer = EnvironmentRender.VertexAttributes.Normal.value["location"]
GL.glEnableVertexAttribArray(normal_attrib_pointer)
GL.glVertexAttribPointer(normal_attrib_pointer, 3, GL.GL_FLOAT, False, 0, ctypes.c_void_p(0))
self._texcoord_bo = GL.glGenBuffers(1)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, self._texcoord_bo)
GL.glBufferData(GL.GL_ARRAY_BUFFER, self._texcoords.nbytes, self._texcoords, GL.GL_STATIC_DRAW)
texcoord_attrib_pointer = EnvironmentRender.VertexAttributes.TexCoord.value["location"]
GL.glEnableVertexAttribArray(texcoord_attrib_pointer)
GL.glVertexAttribPointer(texcoord_attrib_pointer, 2, GL.GL_FLOAT, False, 0, ctypes.c_void_p(0))
# Unbind each used GL object
GL.glBindVertexArray(0)
GL.glDisableVertexAttribArray(pos_attrib_pointer)
GL.glDisableVertexAttribArray(normal_attrib_pointer)
GL.glDisableVertexAttribArray(texcoord_attrib_pointer)
GL.glBindBuffer(GL.GL_ARRAY_BUFFER, 0)
floor_image = PIL.Image.open('textures/floor.png')
floor_texture_data = np.array(list(floor_image.getdata()), np.uint8)
self.floor_texture = GL.glGenTextures(1)
GL.glBindTexture(GL.GL_TEXTURE_2D, self.floor_texture)
GL.glTexParameterf(GL.GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 8.0);
GL.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_LINEAR)
GL.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_LINEAR_MIPMAP_LINEAR)
GL.glTexImage2D(GL.GL_TEXTURE_2D, 0, GL.GL_RGBA, floor_image.size[0], floor_image.size[1], 0, GL.GL_RGBA, GL.GL_UNSIGNED_BYTE, floor_texture_data)
GL.glGenerateMipmap(GL.GL_TEXTURE_2D)
def __init__(self, *args, **kwargs):
self.boundary = '--boundarydonotcross'
self.html = open('index.html', 'r').read()
# Handle Arguments
self.input_path = _args.i[0]
self.rotation = _args.r[0]
self.output_width = int(_args.c[0].split('x')[0])
self.output_height = int(_args.c[0].split('x')[1])
self.frame_rate = _args.f[0]
self.frame_skip_rate = _args.k[0]
self.recognize_scale = 0.2
self.predictor = dlib.shape_predictor('../shapes/shape_predictor_68_face_landmarks.dat')
self.face_cascade = toolbox.loadCascade('haarcascade_frontalface_default.xml')
# Define skipping vars
self.skip_frames = None
self.skip_frame_x = None
self.skip_frame_y = None
self.skip_rect = None
self.skip_points = None
# OpenGL
self.quad = Quad()
self.quad_program = ShaderProgram(fragment=self.quad.fragment, vertex=self.quad.vertex)
self.quad.loadVBOs(self.quad_program)
self.quad.loadElements()
super(CustomHandler, self).__init__(*args, **kwargs)
def initGL(output_width, output_height):
glutInit(sys.argv)
glutInitDisplayMode(GLUT_3_2_CORE_PROFILE | GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH)
glutInitWindowSize(output_width, output_height)
glutCreateWindow("Virtual Window")
print('')
print('Vendor: ' + glGetString(GL_VENDOR).decode('utf-8'))
print('Renderer: ' + glGetString(GL_RENDERER).decode('utf-8'))
print('OpenGL Version: ' + glGetString(GL_VERSION).decode('utf-8'))
print('Shader Version: ' + glGetString(GL_SHADING_LANGUAGE_VERSION).decode('utf-8'))
if not glUseProgram:
print('Missing Shader Objects!')
sys.exit(1)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
global QUAD
QUAD = Quad()
global QUAD_PROGRAM
QUAD_PROGRAM = ShaderProgram(fragment=QUAD.fragment, vertex=QUAD.vertex)
QUAD.loadVBOs(QUAD_PROGRAM)
QUAD.loadElements()
def getGLFrame(frame, points, output_width, output_height):
############## OpengGL ##############
p1, p2, p3 = points[39], points[42], points[33]
w, h = output_width, output_height
p1 = [(p1[1] / w) * 2 - 1, -((p1[0] / h) * 2 - 1)]
p2 = [(p2[1] / w) * 2 - 1, -((p2[0] / h) * 2 - 1)]
p3 = [(p3[1] / w) * 2 - 1, -((p3[0] / h) * 2 - 1)]
triangle = Triangle(p1, p2, p3)
tri_program = ShaderProgram(fragment=triangle.fragment, vertex=triangle.vertex)
triangle.loadVBOs(tri_program)
triangle.loadElements()
glClear(GL_COLOR_BUFFER_BIT)
glClearColor (0.0, 0.0, 0.0, 1.0)
#-----------------------------------#
QUAD_PROGRAM.start()
toolbox.bind(QUAD)
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, w, h, 0, GL_BGR, GL_UNSIGNED_BYTE, frame)
glDrawElements(GL_TRIANGLES, len(QUAD.elements) * 3, GL_UNSIGNED_INT, None)
toolbox.unbind()
QUAD_PROGRAM.stop()
#-----------------------------------#
tri_program.start()
toolbox.bind(triangle)
glDrawElements(GL_TRIANGLES, len(triangle.elements) * 3, GL_UNSIGNED_INT, None)
toolbox.unbind()
tri_program.stop()
#-----------------------------------#
glFinish()
glPixelStorei(GL_PACK_ALIGNMENT, 1)
buffer = glReadPixels(0, 0, output_width, output_height, GL_BGR, GL_UNSIGNED_BYTE)
image = Image.frombytes('RGB', (output_width, output_height), buffer)
image = image.transpose(Image.FLIP_TOP_BOTTOM)
frame = np.asarray(image, dtype=np.uint8)
glutSwapBuffers()
#####################################
return frame
def init():
grid_vertices, grid_mesh = generate_grid_mesh(-10, 10, step=0.5)
global shader_program
shader_program = ShaderProgram("resources/shaders/shader.vs", "resources/shaders/shader.fg")
shader_program.init()
global robot_program
robot_program = ShaderProgram("resources/shaders/shader_robot.vs", "resources/shaders/shader_robot.fg")
robot_program.init()
global grid_model
grid_model = Model([grid_vertices], indices=[grid_mesh])
global human_model
human_model = ColladaModel("resources/human.dae")
glEnable(GL_DEPTH_TEST)
def _create_shaders(self):
"""Creates the shader program"""
self._shader_program = ShaderProgram(self._get_vertex_shader_fn(),
self._get_fragent_shader_fn())
# Setup Vertex Attributes
for _, attrib in MotionRender.VertexAttributes.__members__.items():
self._shader_program.bind_attribute(attrib.value["location"],
attrib.value["name"])
self._shader_program.compile()
def initp():
global robot_program
# Load shaders
robot_program = ShaderProgram("resources/shaders/shader_robot.vs",
"resources/shaders/shader_robot.fg")
robot_program.init()
global human_model
# Load dae file
human_model = ColladaModel("resources/human.dae")
# Enable depth test
glEnable(GL_DEPTH_TEST)
def loadGlTextures(app):
app.cubeVao, app.cubeBuffer = loadCubeVao()
CLIENT_DATA.skyboxVao = loadSkyVao()
CLIENT_DATA.glTextures = {}
for (name, sides) in app.texturePaths.items():
CLIENT_DATA.glTextures[name] = imageToTexture(loadBlockUVFromSides(app, **sides))
CLIENT_DATA.breakTextures = []
for i in range(10):
CLIENT_DATA.breakTextures.append(loadTexture(f'assets/destroy_stage_{i}.png'))
CLIENT_DATA.blockProgram = ShaderProgram('shaders/blockShader.vert', 'shaders/blockShader.frag')
CLIENT_DATA.chunkProgram = ShaderProgram('shaders/chunkShader.vert', 'shaders/chunkShader.frag')
CLIENT_DATA.guiProgram = ShaderProgram('shaders/guiShader.vert', 'shaders/guiShader.frag')
CLIENT_DATA.entityProgram = ShaderProgram('shaders/entityShader.vert', 'shaders/entityShader.frag')
CLIENT_DATA.skyProgram = ShaderProgram('shaders/skyShader.vert', 'shaders/skyShader.frag')
CLIENT_DATA.transProgram = ShaderProgram('shaders/transShader.vert', 'shaders/transShader.frag')
vertices = np.array([
1.0, 1.0, 1.0, 0.0, # top right
1.0, -1.0, 1.0, 1.0, # bottom right
-1.0, -1.0, 0.0, 1.0, # bottom left
-1.0, 1.0, 0.0, 0.0, # top left
], dtype='float32')
indices = np.array([
0, 1, 3,
1, 2, 3,
], dtype='uint32')
vao: int = glGenVertexArrays(1) #type:ignore
vbo: int = glGenBuffers(1) #type:ignore
ebo: int = glGenBuffers(1) #type:ignore
glBindVertexArray(vao)
glBindBuffer(GL_ARRAY_BUFFER, vbo)
glBufferData(GL_ARRAY_BUFFER, vertices.nbytes, vertices, GL_STATIC_DRAW)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo)
glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.nbytes, indices, GL_STATIC_DRAW)
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * 4, ctypes.c_void_p(0))
glEnableVertexAttribArray(0)
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * 4, ctypes.c_void_p(2 * 4))
glEnableVertexAttribArray(1)
glBindBuffer(GL_ARRAY_BUFFER, 0)
glBindVertexArray(0)
CLIENT_DATA.fullscreenVao = vao
def __init__(self, width, height):
self._createGlSurface()
self.texture = 0
self.resize(width, height)
self._createGlTexture()
self.width = width
self.height = height
self.program = ShaderProgram('shaders/guiShader.vert',
'shaders/guiShader.frag')
self.font = ImageFont.truetype('assets/minecraft_font.ttf', 16)
def main():
setupWindow()
mesh = Mesh(vertices, indices)
camera = Camera2D(DIMENSIONS[0], DIMENSIONS[1])
# Create the shader program and configure its uniforms.
shaderprogram = ShaderProgram("shaders/vertex.shader",
"shaders/fragment.shader")
shaderprogram.setUniform2f("resolution", DIMENSIONS[0], DIMENSIONS[1])
shaderprogram.setUniform2f("scale", camera.scaleVector[0],
camera.scaleVector[1])
shaderprogram.setUniform1i("iterations", DEFAULT_ITERATIONS)
while True:
handleEvents()
pan, zoom = camera.move()
if pan:
shaderprogram.setUniform2f("cameraPos", camera.position[0],
camera.position[1])
if zoom:
shaderprogram.setUniform2f("scale", camera.scaleVector[0],
camera.scaleVector[1])
if AUTO_UPDATE_ITERATIONS:
iterations = getIterationCount(camera.scale)
shaderprogram.setUniform1i("iterations", iterations)
renderer.clearScreen()
# Render the quads.
renderer.render2D(mesh, shaderprogram.shader)
# Swap buffers.
pygame.display.flip()
def add_program(self, name, shaders):
shaders = [self.shaders[i] for i in shaders]
sp = ShaderProgram(shaders)
self.programs[name] = sp
