def main():
init()
window = create_window(500, 500, "Hi", None, None)
make_context_current(window)
initial_setup()
colors = {
"front": (1, 0, 0),
"back": (0, 1, 0),
"left": (1, 1, 0),
"right": (1, 0, 1),
"up": (0, 0, 1),
"down": (0, 1, 1),
}
glClearColor(1, 1, 1, 1)
glEnable(GL_DEPTH_TEST)
set_lightning()
while not window_should_close(window):
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
glRotate(1, 0, 1, 0)
draw_cube(0, 0, 0, 5, colors)
swap_buffers(window)
poll_events()
terminate()
def run(self):
# initializer timer
glfw.set_time(0.0)
t = 0.0
while not glfw.window_should_close(self.win) and not self.exitNow:
# update every x seconds
currT = glfw.get_time()
if currT - t > 0.1:
# update time
t = currT
# clear
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
# build projection matrix
pMatrix = glutils.perspective(45.0, self.aspect, 0.1, 100.0)
mvMatrix = glutils.lookAt([0.0, 0.0, -2.0], [0.0, 0.0, 0.0],
[0.0, 1.0, 0.0])
# render
self.scene.render(pMatrix, mvMatrix)
# step
self.scene.step()
glfw.swap_buffers(self.win)
# Poll for and process events
glfw.poll_events()
# end
glfw.terminate()
def swap_buffers(self):
"""
Swap buffers, increment frame counter and pull events
"""
glfw.swap_buffers(self.window)
self.frames += 1
glfw.poll_events()
def main():
# Initialize the library
if not glfw.init():
return
# Create a windowed mode window and its OpenGL context
window = glfw.create_window(window_width, window_height, "Hello World", None, None)
if not window:
glfw.terminate()
return
# Make the window's context current
glfw.make_context_current(window)
glfw.set_window_size_callback(window, on_window_size)
initGL(window)
# Loop until the user closes the window
while not glfw.window_should_close(window):
# Render here, e.g. using pyOpenGL
display()
# Swap front and back buffers
glfw.swap_buffers(window)
# Poll for and process events
glfw.poll_events()
glfw.terminate()
def __init__(self):
self.dir = Dir.empty
self.run = True
self.snake = Player()
if not glfw.init():
return
self.window = glfw.create_window(400, 300, "Hello, World!", None, None)
if not self.window:
glfw.terminate()
return
glfw.make_context_current(self.window)
glfw.set_key_callback(self.window, self.key_callback)
while self.run and not glfw.window_should_close(self.window):
# Update player's position
self.snake.play(self.dir)
sleep(0.075)
self.draw()
glfw.swap_buffers(self.window)
glfw.poll_events()
if self.snake.alive is False:
sleep(1.075)
self.run = False
glfw.terminate()
def mainLoop(mainLoopObject, window):
VAO = mainLoopObject["VAO"]
i = mainLoopObject["Indexs"]
VertexCount = mainLoopObject["VertexCount"]
pos = mainLoopObject["VertexBuffer"]
shaderProgram = mainLoopObject["ShaderProgram"]
glEnableVertexAttribArray(0)
# Loop until the user closes the window
while not glfw.window_should_close(window):
glClearColor(0.1, 0.1, 0.5, 1)
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
transMatrix = glGetUniformLocation(shaderProgram, "transMatrix")
glUseProgram(shaderProgram)
glUniformMatrix4fv(transMatrix, 1, GL_TRUE, Matrix.translate(0.5 , 0.0 , 0))
glBindVertexArray(VAO)
glBindBuffer(GL_ARRAY_BUFFER, pos)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, i)
# draw triangle using index
glDrawElements(GL_TRIANGLES, 3, GL_UNSIGNED_INT, ctypes.c_void_p(0))
# Swap front and back buffers
glfw.swap_buffers(window)
glfw.poll_events()
glBindVertexArray(0)
glUseProgram(0)
def run(self):
# Initialize the library
if not glfw.init():
return
# Create a windowed mode window and its OpenGL context
self.window = glfw.create_window(640, 480, "Hello World", None, None)
if not self.window:
glfw.terminate()
return
renderer = RiftGLRendererCompatibility()
# Paint a triangle in the center of the screen
renderer.append(TriangleDrawerCompatibility())
# Make the window's context current
glfw.make_context_current(self.window)
# Initialize Oculus Rift
renderer.init_gl()
renderer.rift.recenter_pose()
glfw.set_key_callback(self.window, self.key_callback)
# Loop until the user closes the window
while not glfw.window_should_close(self.window):
# Render here, e.g. using pyOpenGL
renderer.display_rift_gl()
# Swap front and back buffers
glfw.swap_buffers(self.window)
# Poll for and process events
glfw.poll_events()
glfw.terminate()
def main(): # Initialize the library if not glfw.init(): return glfw.set_error_callback(error_callback) # Create a windowed mode window and its OpenGL context window = glfw.create_window(640, 480, "Hello World", None, None) if not window: glfw.terminate() return # Make the window's context current glfw.make_context_current(window) program = common2d.init_shader_program() # Loop until the user closes the window while not glfw.window_should_close(window): # Render here common2d.display(program) # Swap front and back buffers glfw.swap_buffers(window) # Poll for and process events glfw.poll_events() glfw.terminate()
def main():
if not glfw.init():
return
window = glfw.create_window(640, 480, "ラララ", None, None)
if not window:
glfw.terminate()
return
#init
glfw.make_context_current(window)
gluOrtho2D(0.0, 640, 0.0, 480) #where is this in glfw?
# loop
while not glfw.window_should_close(window):
glClear(GL_COLOR_BUFFER_BIT)
randomWidth()
drawLine(100.0, 400.0, 200.0, 400.0)
drawLine(440.0, 400.0, 540.0, 400.0)
drawLine(320.0, 350.0, 320.0, 330.0)
drawLine(100.0, 400.0, 200.0, 400.0)
drawLine(300.0, 200.0, 340.0, 200.0)
glfw.swap_buffers(window)
glfw.poll_events()
glfw.swap_interval(2)
glfw.terminate()
def main():
global angles, angley, anglez, scale, carcass, sphere
if not glfw.init():
return
window = glfw.create_window(640, 640, "Lab2", None, None)
if not window:
glfw.terminate()
return
glfw.make_context_current(window)
glfw.set_key_callback(window, key_callback)
glfw.set_framebuffer_size_callback(window, resize_callback)
glfw.set_window_pos_callback(window, drag_callback)
l_cube = Cube(0, 0, 0, 1)
# r_cube = Cube(0, 0, 0, 1)
sphere.recount(parts)
while not glfw.window_should_close(window):
glEnable(GL_DEPTH_TEST)
glDepthFunc(GL_LESS)
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
set_projection()
glLoadIdentity()
sphere.draw(scale, angles, [0.3, 0.0, 0.4], carcass)
# r_cube.draw(scale, angles, [0.3, 0.2, 0.4], carcass)
l_cube.draw(0.5, [0, 0, 0], [-0.5, 0.0, -0.25], False)
glfw.swap_buffers(window)
glfw.poll_events()
glfw.destroy_window(window)
glfw.terminate()
def main():
global R, T
if not glfw.init(): return
window = glfw.create_window(480, 480, "2015004584", None, None)
if not window:
glfw.terminate()
return
glfw.set_key_callback(window, key_callback)
glfw.make_context_current(window)
glfw.swap_interval(0)
while not glfw.window_should_close(window):
glfw.poll_events()
clear()
axis()
glMultMatrixf(R.T)
glMultMatrixf(T.T)
render()
glfw.swap_buffers(window)
glfw.terminate()
def main():
global vertices, window_height, window_width, to_redraw
if not glfw.init():
return
window = glfw.create_window(400, 400, "Lab4", None, None)
if not window:
glfw.terminate()
return
glfw.make_context_current(window)
glfw.set_key_callback(window, key_callback)
glfw.set_framebuffer_size_callback(window, resize_callback)
glfw.set_mouse_button_callback(window, mouse_button_callback)
glEnable(GL_DEPTH_TEST)
glDepthFunc(GL_LESS)
glClearColor(0, 0, 0, 0)
while not glfw.window_should_close(window):
# print(vertices)
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
draw()
glfw.swap_buffers(window)
glfw.poll_events()
glfw.destroy_window(window)
glfw.terminate()
def main():
window = init_window()
if not window:
return
shader = get_shader()
vao = get_vertex()
tex = bind_texture("wall.png")
tex2 = bind_texture("wall2.jpg")
gl.glViewport(0, 0, WINDOW_WIDTH, WINDOW_HEIGHT)
gl.glEnable(gl.GL_DEPTH_TEST)
# Loop until the user closes the window
while not glfw.window_should_close(window):
# Poll for and process events
glfw.poll_events()
# Render here, e.g. using pyOpenGL
render(shader, vao, tex, tex2)
# Swap front and back buffers
glfw.swap_buffers(window)
time.sleep(0.05)
gl.glDeleteVertexArrays(1, vao)
glfw.terminate()
def renderLoop(self):
self.initGL()
while not glfw.window_should_close(self.window):
w, h = glfw.get_framebuffer_size(self.window)
self.renderFrame()
glfw.swap_buffers(self.window)
glfw.poll_events()
self.destroyGL()
def draw_a_triangle():
if not glfw.init():
return -1;
# Create a windowed mode window and its OpenGL context
glfw.window_hint(glfw.SAMPLES, 4)
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3)
glfw.window_hint(glfw.OPENGL_FORWARD_COMPAT, GL_TRUE)
glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
window = glfw.create_window(1024, 768, "Triangle", None, None);
if window == None:
glfw.terminate()
return -1
# Make the window's context current
glfw.make_context_current(window)
# glfw.Experimental = True
glClearColor(0.0, 0.1, 0.2, 1.0)
flatten = lambda l: [u for t in l for u in t]
vertices = [(-1.0, -1.0, 0.0),
(1.0, -1.0, 0.0),
(0.0, 1.0, 0.0)]
indices = range(3)
vao_handle = glGenVertexArrays(1)
glBindVertexArray(vao_handle)
program_handle = tools.load_program("../shader/simple.v.glsl",
"../shader/simple.f.glsl")
f_vertices = flatten(vertices)
c_vertices = (c_float*len(f_vertices))(*f_vertices)
v_buffer = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, v_buffer)
glBufferData(GL_ARRAY_BUFFER, c_vertices, GL_STATIC_DRAW)
glEnableVertexAttribArray(0)
glBindBuffer(GL_ARRAY_BUFFER, v_buffer)
glVertexAttribPointer(0,
#glGetAttribLocation(program_handle, "vertexPosition_modelspace"),
3, GL_FLOAT, False, 0, None)
# Loop until the user closes the window
while not glfw.window_should_close(window):
# Render here
glClear(GL_COLOR_BUFFER_BIT)
glUseProgram(program_handle)
glDrawArrays(GL_TRIANGLES, 0, 3)
glDisableVertexAttribArray(vao_handle)
# Swap front and back buffers
glfw.swap_buffers(window)
# Poll for and process events
glfw.poll_events()
glfw.terminate();
pass
def render_scene(self):
"render scene one time"
self.init_gl() # should be a no-op after the first frame is rendered
glfw.make_context_current(self.window)
self.renderer.render_scene()
# Done rendering
# glfw.swap_buffers(self.window) # avoid double buffering to avoid stalling
glFlush() # single buffering
glfw.poll_events()
def show(molecule, width=500, height=500,
show_bonds=True, bonds_method='radii', bonds_param=None,
camera=None, title='mogli'):
"""
Interactively show the given molecule with OpenGL. By default, bonds are
drawn, if this is undesired the show_bonds parameter can be set to False.
For information on the bond calculation, see Molecule.calculate_bonds.
If you pass a tuple of camera position, center of view and an up vector to
the camera parameter, the camera will be set accordingly. Otherwise the
molecule will be viewed in the direction of the z axis, with the y axis
pointing upward.
"""
global _camera
molecule.positions -= np.mean(molecule.positions, axis=0)
max_atom_distance = np.max(la.norm(molecule.positions, axis=1))
if show_bonds:
molecule.calculate_bonds(bonds_method, bonds_param)
# If GR3 was initialized earlier, it would use a different context, so
# it will be terminated first.
gr3.terminate()
# Initialize GLFW and create an OpenGL context
glfw.init()
glfw.window_hint(glfw.SAMPLES, 16)
window = glfw.create_window(width, height, title, None, None)
glfw.make_context_current(window)
glEnable(GL_MULTISAMPLE)
# Set up the camera (it will be changed during mouse rotation)
if camera is None:
camera_distance = -max_atom_distance*2.5
camera = ((0, 0, camera_distance),
(0, 0, 0),
(0, 1, 0))
camera = np.array(camera)
_camera = camera
# Create the GR3 scene
gr3.setbackgroundcolor(255, 255, 255, 0)
_create_gr3_scene(molecule, show_bonds)
# Configure GLFW
glfw.set_cursor_pos_callback(window, _mouse_move_callback)
glfw.set_mouse_button_callback(window, _mouse_click_callback)
glfw.swap_interval(1)
# Start the GLFW main loop
while not glfw.window_should_close(window):
glfw.poll_events()
width, height = glfw.get_window_size(window)
glViewport(0, 0, width, height)
_set_gr3_camera()
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
gr3.drawimage(0, width, 0, height,
width, height, gr3.GR3_Drawable.GR3_DRAWABLE_OPENGL)
glfw.swap_buffers(window)
glfw.terminate()
gr3.terminate()
def main():
# Initialize the library
if not glfw.init():
return
# Create a windowed mode window and its OpenGL context
window = glfw.create_window(640, 480, "Hello World", None, None)
if not window:
glfw.terminate()
return
# Make the window's context current
glfw.make_context_current(window)
# Loop until the user closes the window
while not glfw.window_should_close(window):
# Render here, e.g. using pyOpenGL
# Swap front and back buffers
glfw.swap_buffers(window)
gl_begin( GL_TRIANGLES )
glColor3f( 1.0, 0.0, 0.0 )
glVertex3f( 0.0, 1.0, 0.0 )
glColor3f( 0.0, 1.0, 0.0 )
glVertex3f( -1.0, -1.0, 1.0 )
glColor3f( 0.0, 0.0, 1.0 )
glVertex3f( 1.0, -1.0, 1.0)
glColor3f( 1.0, 0.0, 0.0 )
glVertex3f( 0.0, 1.0, 0.0)
glColor3f( 0.0, 1.0, 0.0 )
glVertex3f( -1.0, -1.0, 1.0)
glColor3f( 0.0, 0.0, 1.0 )
glVertex3f( 0.0, -1.0, -1.0)
#glColor3f( 1.0f, 0.0f, 0.0f )
#glVertex3f( 0.0f, 1.0f, 0.0f)
#glColor3f( 0.0f, 1.0f, 0.0f )
#glVertex3f( 0.0f, -1.0f, -1.0f)
#glColor3f( 0.0f, 0.0f, 1.0f )
#glVertex3f( 1.0f, -1.0f, 1.0f)
#glColor3f( 1.0f, 0.0f, 0.0f )
#glVertex3f( -1.0f, -1.0f, 1.0f)
#glColor3f( 0.0f, 1.0f, 0.0f )
#glVertex3f( 0.0f, -1.0f, -1.0f)
#glColor3f( 0.0f, 0.0f, 1.0f )
#glVertex3f( 1.0f, -1.0f, 1.0f)
glEnd()
# Poll for and process events
glfw.poll_events()
glfw.terminate()
def run(self):
self.setup()
while not self.quit:
self.clear_screen()
self.update()
self.render()
glfw.swap_buffers(self.window)
glfw.poll_events()
# time.sleep(.03)
self.teardown()
def main():
# Initialize the library
if not glfw.init():
return
# Set some window hints
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3);
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3);
glfw.window_hint(glfw.OPENGL_FORWARD_COMPAT, GL.GL_TRUE);
glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE);
glfw.window_hint(glfw.SAMPLES, 16)
# This works as expected
glfw.window_hint(glfw.RESIZABLE, 0)
# These should work, but don't :(
# could control focus w/ http://crunchbang.org/forums/viewtopic.php?id=22226
# ended up using xdotool, see run.py
glfw.window_hint(glfw.FOCUSED, 0)
# I've set 'shader-*' to raise in openbox-rc as workaround
# Looking at the code and confirming version 3.1.2 and it should work
glfw.window_hint(glfw.FLOATING, 1)
# Create a windowed mode window and its OpenGL context
window = glfw.create_window(300, 300, "shader-test", None, None)
if not window:
glfw.terminate()
return
# Move Window
glfw.set_window_pos(window, 1600, 50)
# Make the window's context current
glfw.make_context_current(window)
# vsync
glfw.swap_interval(1)
# Setup GL shaders, data, etc.
initialize()
# Loop until the user closes the window
while not glfw.window_should_close(window):
# Render here, e.g. using pyOpenGL
render()
# Swap front and back buffers
glfw.swap_buffers(window)
# Poll for and process events
glfw.poll_events()
glfw.terminate()
def main_loop(self):
while True:
glfw.poll_events()
if glfw.window_should_close(self.window) or self.should_exit:
self.do_exit()
return
try:
self._render()
except StopIteration:
self.do_exit()
return
def render(self):
"""
Render the current simulation state to the screen or off-screen buffer.
"""
if self.window is None:
return
elif glfw.window_should_close(self.window):
exit(0)
with self._gui_lock:
super().render()
glfw.poll_events()
def draw(x):
set_param(x)
# Render here
# Make the window's context current
shaject_mat = shadow_proj_mat(vec3(0,1,0), vec3(0,-0.45,0), light_pos)
glfw.make_context_current(window)
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
# draw the scene
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_CULL_FACE)
glViewport(0,0,width,height)
glUseProgram(program_handle)
glUniform3f(light_pos_loc, light_pos.x, light_pos.y, light_pos.z)
model_view_inv = (view_mat * cube.model_mat).inverse()
glUniformMatrix4fv(MVint_loc, 1, GL_TRUE, model_view_inv.toList())
glUniformMatrix4fv(M_loc, 1, GL_FALSE, cube.model_mat.toList())
MVP = proj_mat * view_mat * cube.model_mat
glUniformMatrix4fv(MVP_loc, 1, GL_FALSE, MVP.toList())
glDrawElements(GL_TRIANGLES, len(cube.obj.indices),
GL_UNSIGNED_SHORT, None);
glUniformMatrix4fv(MVint_loc, 1, GL_TRUE, floor_MVinv.toList())
glUniformMatrix4fv(M_loc, 1, GL_FALSE, floor_model_mat.toList())
glUniformMatrix4fv(MVP_loc, 1, GL_FALSE, floor_MVP.toList())
glDrawElements(GL_TRIANGLES, len(cube.obj.indices),
GL_UNSIGNED_SHORT, None)
glDisable(GL_CULL_FACE)
glUseProgram(shadow_program_handle)
glUniformMatrix4fv(shadow_MsVP_loc, 1, GL_FALSE, (VP_mat*shaject_mat*cube.model_mat).toList())
glDrawElements(GL_TRIANGLES, len(cube.obj.indices),
GL_UNSIGNED_SHORT, None)
glViewport(width, 0, width, height)
glDisable(GL_CULL_FACE)
glUseProgram(basic_program_handle)
glDrawElements(GL_TRIANGLES, len(cube.obj.indices),
GL_UNSIGNED_SHORT, None)
glUseProgram(shadow_program_handle)
glUniformMatrix4fv(shadow_MsVP_loc, 1, GL_FALSE, (VP_mat_top*shaject_mat*cube.model_mat).toList())
# glUniformMatrix4fv(shadow_M_loc, 1, GL_FALSE, model_mat.toList())
# glUniformMatrix4fv(shadow_VP_loc, 1, GL_FALSE, VP_mat_top.toList())
glDrawElements(GL_TRIANGLES, len(cube.obj.indices),
GL_UNSIGNED_SHORT, None)
# Swap front and back buffers
glfw.swap_buffers(window)
glfw.poll_events()
def main():
if not glfw.init():
return
window = glfw.create_window(640, 480, "Lab2", None, None)
if not window:
glfw.terminate()
return
glfw.make_context_current(window)
glfw.set_key_callback(window, key_callback)
while not glfw.window_should_close(window) and not ex:
draw()
glfw.swap_buffers(window)
glfw.poll_events()
glfw.terminate()
def main(): global current_vao global vaos if not opengl_init(): return glfw.set_input_mode(window,glfw.STICKY_KEYS,GL_TRUE) glfw.set_key_callback(window,key_event) # Set opengl clear color to something other than red (color used by the fragment shader) glClearColor(0,0,0.4,0) # Create vertex array object (VAO) 1: Full Triangle vao = glGenVertexArrays(1) glBindVertexArray(vao) init_object(vertex_data) glBindVertexArray(0) # Create vertex array object (VAO) 2: 1/2 Triangle vao2 = glGenVertexArrays(1) glBindVertexArray(vao2) init_object(vertex_data2) glBindVertexArray(0) program_id = common.LoadShaders( "SimpleVertexShader.vertexshader", "SimpleFragmentShader.fragmentshader" ) vertex_buffer = glGenBuffers(1) current_vao = 0 vaos = [vao,vao2] glewInit() while glfw.get_key(window,glfw.KEY_ESCAPE) != glfw.PRESS and not glfw.window_should_close(window): glClear(GL_COLOR_BUFFER_BIT) glUseProgram(program_id) glBindVertexArray(vaos[current_vao]) # Draw the triangle ! glDrawArrays (GL_TRIANGLES, 0, 3)#3 indices starting at 0 -> 1 triangle glBindVertexArray(0) # Swap front and back buffers glfw.swap_buffers(window) # Poll for and process events glfw.poll_events() glfw.terminate()
def main():
global delta
global angle
# Initialize the library
if not glfw.init():
return
# Create a windowed mode window and its OpenGL context
window = glfw.create_window(640, 640, "Lab1", None, None)
if not window:
glfw.terminate()
return
# Make the window's context current
glfw.make_context_current(window)
glfw.set_key_callback(window, key_callback)
# Loop until the user closes the window
while not glfw.window_should_close(window):
# Render here, e.g. using pyOpenGL
glClear(GL_COLOR_BUFFER_BIT)
glLoadIdentity()
glClearColor(1.0, 1.0, 1.0, 1.0)
glPushMatrix()
glRotatef(angle, 0, 0, 1)
glBegin(GL_QUADS)
glColor3f(0.0,0.0,0.0)
glVertex3f( 0.5, 0.5, 0.0)
glColor3f(1.0,0.0,0.0)
glVertex3f(-0.5, 0.5, 0.0)
glColor3f(0.0,0.0,1.0)
glVertex3f(-0.5, -0.5, 0.0)
glColor3f(1.0,0.0,1.0)
glVertex3f( 0.5, -0.5, 0.0)
glEnd()
glPopMatrix()
angle += delta
# Swap front and back buffers
glfw.swap_buffers(window)
# Poll for and process events
glfw.poll_events()
glfw.destroy_window(window)
glfw.terminate()
def main():
if not glfw.init(): return
window = glfw.create_window(640,640,'2015004584', None,None)
if not window:
glfw.terminate()
return
glfw.make_context_current(window)
glfw.set_key_callback(window, key_callback)
while not glfw.window_should_close(window):
glfw.poll_events()
render(gCamAng)
glfw.swap_buffers(window)
glfw.terminate()
def main():
# Initialize the library
if not glfw.init():
return
# Open Window and create its OpenGL context
window = glfw.create_window(1024, 768, "Tutorial 01", None, None)
#
glfw.window_hint(glfw.SAMPLES, 4)
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3)
glfw.window_hint(glfw.OPENGL_FORWARD_COMPAT, GL_TRUE)
glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
if not window:
print("Failed to open GLFW window. If you have an Intel GPU, they are not 3.3 compatible. Try the 2.1 version of the tutorials.\n",file=sys.stderr)
glfw.terminate()
return
# Initialize GLEW
glfw.make_context_current(window)
glewExperimental = True
# GLEW is a framework for testing extension availability. Please see tutorial notes for
# more information including why can remove this code.
if glewInit() != GLEW_OK:
print("Failed to initialize GLEW\n",file=sys.stderr);
return
glfw.set_input_mode(window,glfw.STICKY_KEYS,True)
# Loop until the user closes the window
#while not glfw.window_should_close(window):
while glfw.get_key(window,glfw.KEY_ESCAPE) != glfw.PRESS and not glfw.window_should_close(window):
# Draw nothing sucker
# Swap front and back buffers
glfw.swap_buffers(window)
# Poll for and process events
glfw.poll_events()
glfw.terminate()
def main():
if not glfw.init(): return
window = glfw.create_window(480, 480, "Hello World", None, None)
if not window:
glfw.terminate()
return
glfw.set_key_callback(window, key_callback)
glfw.make_context_current(window)
while not glfw.window_should_close(window):
glfw.poll_events()
render()
glfw.swap_buffers(window)
glfw.terminate()
def main():
if not glfw_init_routine():
return
if not gl_init_routine():
return
# Main event loop
while not glfw.window_should_close(window):
update_surface()
render()
glfw.swap_buffers(window)
mark_blob()
do_input()
glfw.poll_events()
gl_deinit_routine()
glfw.terminate()
def poll_events():
glfw.poll_events()
def main():
glfw.init()
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3)
glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
window = glfw.create_window(width, height, "LearnOpenGL", None, None)
if not window:
print("Window Creation failed!")
glfw.terminate()
glfw.make_context_current(window)
glfw.set_window_size_callback(window, on_resize)
gl.glEnable(gl.GL_DEPTH_TEST)
shader = Shader(CURDIR / 'shaders/6.1.coordinate_systems.vs',
CURDIR / 'shaders/6.1.coordinate_systems.fs')
vertices = [
# positions tex_coords
-0.5,
-0.5,
-0.5,
0.0,
0.0,
0.5,
-0.5,
-0.5,
1.0,
0.0,
0.5,
0.5,
-0.5,
1.0,
1.0,
0.5,
0.5,
-0.5,
1.0,
1.0,
-0.5,
0.5,
-0.5,
0.0,
1.0,
-0.5,
-0.5,
-0.5,
0.0,
0.0,
-0.5,
-0.5,
0.5,
0.0,
0.0,
0.5,
-0.5,
0.5,
1.0,
0.0,
0.5,
0.5,
0.5,
1.0,
1.0,
0.5,
0.5,
0.5,
1.0,
1.0,
-0.5,
0.5,
0.5,
0.0,
1.0,
-0.5,
-0.5,
0.5,
0.0,
0.0,
-0.5,
0.5,
0.5,
1.0,
0.0,
-0.5,
0.5,
-0.5,
1.0,
1.0,
-0.5,
-0.5,
-0.5,
0.0,
1.0,
-0.5,
-0.5,
-0.5,
0.0,
1.0,
-0.5,
-0.5,
0.5,
0.0,
0.0,
-0.5,
0.5,
0.5,
1.0,
0.0,
0.5,
0.5,
0.5,
1.0,
0.0,
0.5,
0.5,
-0.5,
1.0,
1.0,
0.5,
-0.5,
-0.5,
0.0,
1.0,
0.5,
-0.5,
-0.5,
0.0,
1.0,
0.5,
-0.5,
0.5,
0.0,
0.0,
0.5,
0.5,
0.5,
1.0,
0.0,
-0.5,
-0.5,
-0.5,
0.0,
1.0,
0.5,
-0.5,
-0.5,
1.0,
1.0,
0.5,
-0.5,
0.5,
1.0,
0.0,
0.5,
-0.5,
0.5,
1.0,
0.0,
-0.5,
-0.5,
0.5,
0.0,
0.0,
-0.5,
-0.5,
-0.5,
0.0,
1.0,
-0.5,
0.5,
-0.5,
0.0,
1.0,
0.5,
0.5,
-0.5,
1.0,
1.0,
0.5,
0.5,
0.5,
1.0,
0.0,
0.5,
0.5,
0.5,
1.0,
0.0,
-0.5,
0.5,
0.5,
0.0,
0.0,
-0.5,
0.5,
-0.5,
0.0,
1.0
]
vertices = (c_float * len(vertices))(*vertices)
vao = gl.glGenVertexArrays(1)
gl.glBindVertexArray(vao)
vbo = gl.glGenBuffers(1)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vbo)
gl.glBufferData(gl.GL_ARRAY_BUFFER, sizeof(vertices), vertices,
gl.GL_STATIC_DRAW)
gl.glVertexAttribPointer(0, 3, gl.GL_FLOAT, gl.GL_FALSE,
5 * sizeof(c_float), c_void_p(0))
gl.glEnableVertexAttribArray(0)
gl.glVertexAttribPointer(1, 2, gl.GL_FLOAT,
gl.GL_FALSE, 5 * sizeof(c_float),
c_void_p(3 * sizeof(c_float)))
gl.glEnableVertexAttribArray(1)
# -- load texture 1
texture1 = gl.glGenTextures(1)
gl.glBindTexture(gl.GL_TEXTURE_2D, texture1)
# -- texture wrapping
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S, gl.GL_REPEAT)
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T, gl.GL_REPEAT)
# -- texture filterting
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR)
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR)
img = Image.open(Tex('container.jpg')).transpose(Image.FLIP_TOP_BOTTOM)
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGB, img.width, img.height, 0,
gl.GL_RGB, gl.GL_UNSIGNED_BYTE, img.tobytes())
gl.glGenerateMipmap(gl.GL_TEXTURE_2D)
# -- load texture 2
texture2 = gl.glGenTextures(1)
gl.glBindTexture(gl.GL_TEXTURE_2D, texture2)
# -- texture wrapping
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S, gl.GL_REPEAT)
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T, gl.GL_REPEAT)
# -- texture filterting
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR)
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR)
img = Image.open(Tex('awesomeface.png')).transpose(Image.FLIP_TOP_BOTTOM)
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGB, img.width, img.height, 0,
gl.GL_RGBA, gl.GL_UNSIGNED_BYTE, img.tobytes())
gl.glGenerateMipmap(gl.GL_TEXTURE_2D)
shader.use()
shader.set_int("texture1", 0)
shader.set_int("texture2", 1)
while not glfw.window_should_close(window):
process_input(window)
gl.glClearColor(.2, .3, .3, 1.0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glActiveTexture(gl.GL_TEXTURE0)
gl.glBindTexture(gl.GL_TEXTURE_2D, texture1)
gl.glActiveTexture(gl.GL_TEXTURE1)
gl.glBindTexture(gl.GL_TEXTURE_2D, texture2)
shader.use()
model = Matrix44.from_x_rotation(
glfw.get_time() * 0.5) * Matrix44.from_y_rotation(glfw.get_time())
view = Matrix44.from_translation([0, 0, -3])
projection = Matrix44.perspective_projection(45, width / height, 0.1,
100.0)
shader.set_mat4('view', view)
shader.set_mat4('model', model)
shader.set_mat4('projection', projection)
gl.glBindVertexArray(vao)
gl.glDrawArrays(gl.GL_TRIANGLES, 0, 36)
glfw.poll_events()
glfw.swap_buffers(window)
gl.glDeleteVertexArrays(1, id(vao))
gl.glDeleteBuffers(1, id(vbo))
glfw.terminate()
def visualize_env(env, mode, max_steps=sys.maxsize, speedup=1):
timestep = 0.05
# step ahead with all-zero action
if mode == 'noop':
for _ in range(max_steps):
env.render()
time.sleep(timestep / speedup)
elif mode == 'random':
env.reset()
env.render()
for i in range(max_steps):
action = env.action_space.sample()
_, _, done, _ = env.step(action)
# if i % 10 == 0:
env.render()
# import time as ttime
time.sleep(timestep / speedup)
if done:
env.reset()
elif mode == 'static':
env.reset()
while True:
env.render()
time.sleep(timestep / speedup)
elif mode == 'human':
if hasattr(env, 'start_interactive'):
env.start_interactive()
else:
env.reset()
env.render()
tr = 0.
from metaworlds.envs.box2d import Box2DEnv
if isinstance(env, Box2DEnv):
for _ in range(max_steps):
pygame.event.pump()
keys = pygame.key.get_pressed()
action = env.action_from_keys(keys)
ob, r, done, _ = env.step(action)
tr += r
env.render()
time.sleep(timestep / speedup)
if done:
tr = 0.
env.reset()
return
from metaworlds.envs.mujoco import MujocoEnv
from metaworlds.envs.mujoco.maze import MazeEnv
if isinstance(env, (MujocoEnv, MazeEnv)):
trs = [tr]
actions = [np.zeros(2)]
import mujoco_py # noqa: F401
import glfw
def cb(window, key, scancode, action, mods):
actions[0] = env.action_from_key(key)
glfw.set_key_callback(env.viewer.window, cb)
while True:
try:
actions[0] = np.zeros(2)
glfw.poll_events()
# if np.linalg.norm(actions[0]) > 0:
ob, r, done, info = env.step(actions[0])
trs[0] += r
env.render()
# time.sleep(env.timestep / speedup)
time.sleep(env.timestep / speedup)
if done:
trs[0] = 0.
env.reset()
except Exception as e:
print(e)
return
assert hasattr(
env, "start_interactive"
), "The environment must implement method start_interactive"
env.start_interactive()
# Assume using matplotlib
# TODO - make this logic more legit
# env.render()
# import matplotlib.pyplot as plt
# def handle_key_pressed(event):
# action = env.action_from_key(event.key)
# if action is not None:
# _, _, done, _ = env.step(action)
# if done:
# plt.close()
# return
# env.render()
#
# env.matplotlib_figure.canvas.mpl_connect('key_press_event',
# handle_key_pressed)
# plt.ioff()
# plt.show()
else:
raise ValueError('Unsupported mode: %s' % mode)
def main():
if not opengl_init():
return
glfw.set_input_mode(window, glfw.STICKY_KEYS, GL_TRUE)
# Set opengl clear color to something other than red (color used by the fragment shader)
glClearColor(0, 0, 0.4, 0)
vertex_array_id = glGenVertexArrays(1)
glBindVertexArray(vertex_array_id)
program_id = common.LoadShaders(
".\\shaders\\Tutorial2\\SimpleVertexShader.vertexshader",
".\\shaders\\Tutorial2\\SimpleFragmentShader.fragmentshader")
vertex_data = [-1.0, -1.0, 0.0, 1.0, -1.0, 0.0, 0.0, 1.0, 0.0]
vertex_buffer = glGenBuffers(1)
# GLFloat = c_types.c_float
array_type = GLfloat * len(vertex_data)
# array_type = c_types.c_float_array_9 so unpack values of vertex array
x = array_type(*vertex_data)
glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer)
glBufferData(GL_ARRAY_BUFFER,
len(vertex_data) * 4, array_type(*vertex_data),
GL_STATIC_DRAW)
while glfw.get_key(
window, glfw.KEY_ESCAPE
) != glfw.PRESS and not glfw.window_should_close(window):
glClear(GL_COLOR_BUFFER_BIT)
glUseProgram(program_id)
# Bind vertex buffer data to the attribute 0 in our shader.
# Note: This can also be done in the VAO itself (see vao_test.py)
# Enable the vertex attribute at element[0], in this case that's the triangle's vertices
# this could also be color, normals, etc. It isn't necessary to disable these
#
glEnableVertexAttribArray(0)
glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer)
glVertexAttribPointer(
0, # attribute 0. No particular reason for 0, but must match the layout in the shader.
3, # len(vertex_data)
GL_FLOAT, # type
GL_FALSE, # ormalized?
0, # stride
null # array buffer offset (c_type == void*)
)
# Draw the triangle !
glDrawArrays(GL_TRIANGLES, 0,
3) #3 indices starting at 0 -> 1 triangle
# Not strictly necessary because we only have
glDisableVertexAttribArray(0)
# Swap front and back buffers
glfw.swap_buffers(window)
# Poll for and process events
glfw.poll_events()
# note braces around vertex_buffer and vertex_array_id.
# These 2 functions expect arrays of values
glDeleteBuffers(1, [vertex_buffer])
glDeleteProgram(program_id)
glDeleteVertexArrays(1, [vertex_array_id])
glfw.terminate()
def main():
#inicia glfw
if not glfw.init():
return
#crea la ventana,
# independientemente del SO que usemos
window = glfw.create_window(800,800,"space invaders", None, None)
#Configuramos OpenGL
glfw.window_hint(glfw.SAMPLES, 4)
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR,3)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR,3)
glfw.window_hint(glfw.OPENGL_FORWARD_COMPAT, GL_TRUE)
glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
#Validamos que se cree la ventana
if not window:
glfw.terminate()
return
#Establecemos el contexto
glfw.make_context_current(window)
#Activamos la validación de
# funciones modernas de OpenGL
glewExperimental = True
#Inicializar GLEW
if glewInit() != GLEW_OK:
print("No se pudo inicializar GLEW")
return
#Obtenemos versiones de OpenGL y Shaders
version = glGetString(GL_VERSION)
print(version)
version_shaders = glGetString(GL_SHADING_LANGUAGE_VERSION)
print(version_shaders)
glfw.set_key_callback(window, key_callback)
#-----------------#
inicializarObstaculos()
while not glfw.window_should_close(window):
#Establece regiond e dibujo
glViewport(0,0,800,800)
#Establece color de borrado
glClearColor(0.0,0.0,0.0,1)
#Borra el contenido de la ventana
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
actualizar(window)
#Dibujar
dibujar()
#Preguntar si hubo entradas de perifericos
#(Teclado, mouse, game pad, etc.)
glfw.poll_events()
#Intercambia los buffers
glfw.swap_buffers(window)
#Se destruye la ventana para liberar memoria
glfw.destroy_window(window)
#Termina los procesos que inició glfw.init
glfw.terminate()
def main():
# initialize glfw
if not glfw.init():
return
window = glfw.create_window(800, 600, "My OpenGL window", None, None)
if not window:
glfw.terminate()
return
glfw.make_context_current(window)
vertex_shader = """
#version 330
in vec3 position;
uniform mat4 transform;
out vec3 newColor;
void main()
{
gl_Position = transform * vec4(position, 1.0f);
//newColor = vec3(1.0,0.0,0.0);
newColor = vec3(position.x,0.0,0.0);
}
"""
fragment_shader = """
#version 330
in vec3 newColor;
out vec4 outColor;
void main()
{
outColor = vec4(newColor, 1.0f);
}
"""
shader = OpenGL.GL.shaders.compileProgram(
OpenGL.GL.shaders.compileShader(vertex_shader, GL_VERTEX_SHADER),
OpenGL.GL.shaders.compileShader(fragment_shader, GL_FRAGMENT_SHADER))
glUseProgram(shader)
glClearColor(0.2, 0.3, 0.2, 1.0)
glEnable(GL_DEPTH_TEST)
#glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)
pers = glm.perspective(0.5, 1.0, 0.1, 10.0)
#print pers
trans = glm.translate(glm.mat4(1.0), glm.vec3(0.0, 0.0, -8.5))
while not glfw.window_should_close(window):
glfw.poll_events()
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
#rot_x = glm.rotate(glm.mat4(1.0),0.5 * glfw.get_time(),glm.vec3(1.0,0.0,0.0))
#rot_y = glm.rotate(glm.mat4(1.0),0.5 * glfw.get_time(),glm.vec3(0.0,1.0,0.0))
transformLoc = glGetUniformLocation(shader, "transform")
glUniformMatrix4fv(transformLoc, 1, GL_FALSE,
glm.value_ptr(pers * trans))
qobj = gluNewQuadric()
gluSphere(qobj, 1, 50, 50)
glfw.swap_buffers(window)
glfw.terminate()
def main():
vertex_src = """
# version 330
layout(location = 0) in vec3 a_position;
layout(location = 1) in vec3 a_color;
out vec3 v_color;
void main()
{
gl_Position = vec4(a_position, 1.0);
v_color = a_color;
}
"""
fragment_src = """
# version 330
in vec3 v_color;
out vec4 out_color;
void main()
{
out_color = vec4(v_color, 1.0);
}
"""
def window_resize(window, width, height):
glViewport(0, 0, width, height)
# initializing glfw library
if not glfw.init():
raise Exception("glfw can not be initialized!")
if "Windows" in pltf.platform():
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 4)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 6)
glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
glfw.window_hint(glfw.OPENGL_FORWARD_COMPAT, True)
else:
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 4)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 1)
glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
glfw.window_hint(glfw.OPENGL_FORWARD_COMPAT, True)
# creating the window
window = glfw.create_window(1280, 720, "My OpenGL window", None, None)
# check if window was created
if not window:
glfw.terminate()
raise Exception("glfw window can not be created!")
# set window's position
glfw.set_window_pos(window, 100, 100)
# set the callback function for window resize
glfw.set_window_size_callback(window, window_resize)
# make the context current
glfw.make_context_current(window)
vertices = [-0.5, -0.5, 0.0, 1.0, 0.0, 0.0,
0.5, -0.5, 0.0, 0.0, 1.0, 0.0,
-0.5, 0.5, 0.0, 0.0, 0.0, 1.0,
0.5, 0.5, 0.0, 1.0, 1.0, 1.0]
vertices = np.array(vertices, dtype=np.float32)
VAO = glGenVertexArrays(1)
glBindVertexArray(VAO)
shader = compileProgram(compileShader(vertex_src, GL_VERTEX_SHADER), compileShader(fragment_src, GL_FRAGMENT_SHADER))
VBO = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, VBO)
glBufferData(GL_ARRAY_BUFFER, vertices.nbytes, vertices, GL_STATIC_DRAW)
glEnableVertexAttribArray(0)
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 24, ctypes.c_void_p(0))
glEnableVertexAttribArray(1)
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 24, ctypes.c_void_p(12))
glBindVertexArray(0)
glBindBuffer(GL_ARRAY_BUFFER, 0)
# glUseProgram(shader)
glClearColor(0, 0.1, 0.1, 1)
# the main application loop
while not glfw.window_should_close(window):
glfw.poll_events()
glClear(GL_COLOR_BUFFER_BIT)
glUseProgram(shader)
glBindVertexArray(VAO)
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4)
glBindVertexArray(0)
glUseProgram(0)
glfw.swap_buffers(window)
# terminate glfw, free up allocated resources
glfw.terminate()
shapeDice = createDice()
gpuDice = es.GPUShape().initBuffers()
textureShaderProgram.setupVAO(gpuDice)
gpuDice.fillBuffers(shapeDice.vertices, shapeDice.indices, GL_STATIC_DRAW)
gpuDice.texture = es.textureSimpleSetup(getAssetPath("dice_blue.jpg"),
GL_REPEAT, GL_REPEAT, GL_LINEAR,
GL_LINEAR)
cpuAxis = bs.createAxis(2)
gpuAxis = es.GPUShape().initBuffers()
colorShaderProgram.setupVAO(gpuAxis)
gpuAxis.fillBuffers(cpuAxis.vertices, cpuAxis.indices, GL_STATIC_DRAW)
while not glfw.window_should_close(window):
# Using GLFW to check for input events
glfw.poll_events()
# Filling or not the shapes depending on the controller state
if (controller.fillPolygon):
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)
else:
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)
# Clearing the screen in both, color and depth
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
projection = tr.ortho(-1, 1, -1, 1, 0.1, 100)
view = tr.lookAt(np.array([10, 10, 5]), np.array([0, 0, 0]),
np.array([0, 0, 1]))
def main():
glfw.init()
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3)
glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
window = glfw.create_window(800, 600, "LearnOpenGL", None, None)
if not window:
print("Window Creation failed!")
glfw.terminate()
glfw.make_context_current(window)
glfw.set_window_size_callback(window, on_resize)
shader = Shader(CURDIR / 'shaders/5.1.transform.vs', CURDIR / 'shaders/5.1.transform.fs')
vertices = [
# positions tex_coords
0.5, 0.5, 0.0, 1.0, 1.0, # top right
0.5, -0.5, 0.0, 1.0, 0.0, # bottom right
-0.5, -0.5, 0.0, 0.0, 0.0, # bottom left
-0.5, 0.5, 0.0, 0.0, 1.0, # top left
]
vertices = (c_float * len(vertices))(*vertices)
indices = [
0, 1, 3,
1, 2, 3
]
indices = (c_uint * len(indices))(*indices)
vao = gl.glGenVertexArrays(1)
gl.glBindVertexArray(vao)
vbo = gl.glGenBuffers(1)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vbo)
gl.glBufferData(gl.GL_ARRAY_BUFFER, sizeof(vertices), vertices, gl.GL_STATIC_DRAW)
ebo = gl.glGenBuffers(1)
gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, ebo)
gl.glBufferData(gl.GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, gl.GL_STATIC_DRAW)
gl.glVertexAttribPointer(0, 3, gl.GL_FLOAT, gl.GL_FALSE, 5 * sizeof(c_float), c_void_p(0))
gl.glEnableVertexAttribArray(0)
gl.glVertexAttribPointer(1, 2, gl.GL_FLOAT, gl.GL_FALSE, 5 * sizeof(c_float), c_void_p(3 * sizeof(c_float)))
gl.glEnableVertexAttribArray(1)
# -- load texture 1
texture1 = gl.glGenTextures(1)
gl.glBindTexture(gl.GL_TEXTURE_2D, texture1)
# -- texture wrapping
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S, gl.GL_REPEAT)
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T, gl.GL_REPEAT)
# -- texture filterting
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR)
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR)
img = Image.open(Tex('container.jpg')).transpose(Image.FLIP_TOP_BOTTOM)
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGB, img.width, img.height, 0, gl.GL_RGB, gl.GL_UNSIGNED_BYTE, img.tobytes())
gl.glGenerateMipmap(gl.GL_TEXTURE_2D)
# -- load texture 2
texture2 = gl.glGenTextures(1)
gl.glBindTexture(gl.GL_TEXTURE_2D, texture2)
# -- texture wrapping
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S, gl.GL_REPEAT)
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T, gl.GL_REPEAT)
# -- texture filterting
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR)
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR)
img = Image.open(Tex('awesomeface.png')).transpose(Image.FLIP_TOP_BOTTOM)
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGB, img.width, img.height, 0, gl.GL_RGBA, gl.GL_UNSIGNED_BYTE, img.tobytes())
gl.glGenerateMipmap(gl.GL_TEXTURE_2D)
shader.use()
shader.set_int("texture1", 0)
shader.set_int("texture2", 1)
while not glfw.window_should_close(window):
process_input(window)
gl.glClearColor(.2, .3, .3, 1.0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
gl.glActiveTexture(gl.GL_TEXTURE0)
gl.glBindTexture(gl.GL_TEXTURE_2D, texture1)
gl.glActiveTexture(gl.GL_TEXTURE1)
gl.glBindTexture(gl.GL_TEXTURE_2D, texture2)
translation = Matrix44.from_translation([0.5, -0.5, 0.0])
rotation = Matrix44.from_z_rotation(glfw.get_time())
transform = translation * rotation
shader.use()
shader.set_mat4('transform', transform)
gl.glBindVertexArray(vao)
gl.glDrawElements(gl.GL_TRIANGLES, 6, gl.GL_UNSIGNED_INT, c_void_p(0))
# -- second container
translation = Matrix44.from_translation([-0.5, 0.5, 0.0])
scale = Matrix44.from_scale([math.sin(glfw.get_time())]*3)
transform = translation * scale
shader.set_mat4('transform', transform)
gl.glDrawElements(gl.GL_TRIANGLES, 6, gl.GL_UNSIGNED_INT, c_void_p(0))
glfw.poll_events()
glfw.swap_buffers(window)
gl.glDeleteVertexArrays(1, id(vao))
gl.glDeleteBuffers(1, id(vbo))
gl.glDeleteBuffers(1, id(ebo))
glfw.terminate()
def main():
# initialize glfw
if not glfw.init():
return
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3)
glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
glfw.window_hint(glfw.OPENGL_FORWARD_COMPAT, True)
w_width, w_height = 800, 600
window = glfw.create_window(w_width, w_height, "My OpenGL window", None,
None)
if not window:
glfw.terminate()
return
glfw.make_context_current(window)
glfw.set_window_size_callback(window, window_resize)
obj = ObjLoader()
obj.load_model("res/monkey_smooth.obj")
texture_offset = len(obj.vertex_index) * 12
normal_offset = (texture_offset + len(obj.texture_index) * 8)
VAO = glGenVertexArrays(1)
glBindVertexArray(VAO)
shader = ShaderLoader.compile_shader("shaders/video_18_vert.vs",
"shaders/video_18_frag.fs")
VBO = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, VBO)
glBufferData(GL_ARRAY_BUFFER, obj.model.itemsize * len(obj.model),
obj.model, GL_STATIC_DRAW)
#positions
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, obj.model.itemsize * 3,
ctypes.c_void_p(0))
glEnableVertexAttribArray(0)
#textures
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, obj.model.itemsize * 2,
ctypes.c_void_p(texture_offset))
glEnableVertexAttribArray(1)
#normals
glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, obj.model.itemsize * 3,
ctypes.c_void_p(normal_offset))
glEnableVertexAttribArray(2)
glBindVertexArray(0)
glBindBuffer(GL_ARRAY_BUFFER, 0)
texture = glGenTextures(1)
glBindTexture(GL_TEXTURE_2D, texture)
# Set the texture wrapping parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT)
# Set texture filtering parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
# load image
image = Image.open("res/monkey.jpg")
flipped_image = image.transpose(Image.FLIP_TOP_BOTTOM)
img_data = numpy.array(list(flipped_image.getdata()), numpy.uint8)
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, image.width, image.height, 0,
GL_RGB, GL_UNSIGNED_BYTE, img_data)
glClearColor(0.2, 0.3, 0.2, 1.0)
glEnable(GL_DEPTH_TEST)
#glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)
view = pyrr.matrix44.create_from_translation(pyrr.Vector3([0.0, 0.0,
-3.0]))
projection = pyrr.matrix44.create_perspective_projection_matrix(
65.0, w_width / w_height, 0.1, 100.0)
model = pyrr.matrix44.create_from_translation(pyrr.Vector3([0.0, 0.0,
0.0]))
glUseProgram(shader)
view_loc = glGetUniformLocation(shader, "view")
proj_loc = glGetUniformLocation(shader, "projection")
model_loc = glGetUniformLocation(shader, "model")
transform_loc = glGetUniformLocation(shader, "transform")
light_loc = glGetUniformLocation(shader, "light")
glUniformMatrix4fv(view_loc, 1, GL_FALSE, view)
glUniformMatrix4fv(proj_loc, 1, GL_FALSE, projection)
glUniformMatrix4fv(model_loc, 1, GL_FALSE, model)
glUseProgram(0)
while not glfw.window_should_close(window):
glfw.poll_events()
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
#rot_x = pyrr.Matrix44.from_x_rotation(0.5 * glfw.get_time() )
rot_y = pyrr.Matrix44.from_y_rotation(0.8 * glfw.get_time())
glUseProgram(shader)
glUniformMatrix4fv(transform_loc, 1, GL_FALSE, rot_y)
glUniformMatrix4fv(light_loc, 1, GL_FALSE, rot_y)
glBindVertexArray(VAO)
glDrawArrays(GL_TRIANGLES, 0, len(obj.vertex_index))
glBindVertexArray(0)
glUseProgram(0)
glfw.swap_buffers(window)
glDeleteProgram(shader)
glDeleteVertexArrays(1, [VAO])
glDeleteBuffers(1, [VBO])
glfw.terminate()
def main():
global delta_time, last_frame
glfw.init()
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3)
glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
window = glfw.create_window(SRC_WIDTH, SRC_HEIGHT, "learnOpenGL", None,
None)
if not window:
glfw.terminate()
raise ValueError("Failed to create window")
glfw.make_context_current(window)
glfw.set_framebuffer_size_callback(window, framebuffer_size_callback)
glfw.set_cursor_pos_callback(window, mouse_callback)
glfw.set_scroll_callback(window, scroll_callback)
glfw.set_input_mode(window, glfw.CURSOR, glfw.CURSOR_DISABLED)
gl.glEnable(gl.GL_DEPTH_TEST)
lamp_shader = Shader(CURDIR / "shaders/1.lamp.vs",
CURDIR / "shaders/1.lamp.fs")
lighting_shader = Shader(CURDIR / "shaders/5.1.light_casters.vs",
CURDIR / "shaders/5.1.light_casters.fs")
vertices = [
# positions normals texture coords
-0.5,
-0.5,
-0.5,
0.0,
0.0,
-1.0,
0.0,
0.0,
0.5,
-0.5,
-0.5,
0.0,
0.0,
-1.0,
1.0,
0.0,
0.5,
0.5,
-0.5,
0.0,
0.0,
-1.0,
1.0,
1.0,
0.5,
0.5,
-0.5,
0.0,
0.0,
-1.0,
1.0,
1.0,
-0.5,
0.5,
-0.5,
0.0,
0.0,
-1.0,
0.0,
1.0,
-0.5,
-0.5,
-0.5,
0.0,
0.0,
-1.0,
0.0,
0.0,
-0.5,
-0.5,
0.5,
0.0,
0.0,
1.0,
0.0,
0.0,
0.5,
-0.5,
0.5,
0.0,
0.0,
1.0,
1.0,
0.0,
0.5,
0.5,
0.5,
0.0,
0.0,
1.0,
1.0,
1.0,
0.5,
0.5,
0.5,
0.0,
0.0,
1.0,
1.0,
1.0,
-0.5,
0.5,
0.5,
0.0,
0.0,
1.0,
0.0,
1.0,
-0.5,
-0.5,
0.5,
0.0,
0.0,
1.0,
0.0,
0.0,
-0.5,
0.5,
0.5,
-1.0,
0.0,
0.0,
1.0,
0.0,
-0.5,
0.5,
-0.5,
-1.0,
0.0,
0.0,
1.0,
1.0,
-0.5,
-0.5,
-0.5,
-1.0,
0.0,
0.0,
0.0,
1.0,
-0.5,
-0.5,
-0.5,
-1.0,
0.0,
0.0,
0.0,
1.0,
-0.5,
-0.5,
0.5,
-1.0,
0.0,
0.0,
0.0,
0.0,
-0.5,
0.5,
0.5,
-1.0,
0.0,
0.0,
1.0,
0.0,
0.5,
0.5,
0.5,
1.0,
0.0,
0.0,
1.0,
0.0,
0.5,
0.5,
-0.5,
1.0,
0.0,
0.0,
1.0,
1.0,
0.5,
-0.5,
-0.5,
1.0,
0.0,
0.0,
0.0,
1.0,
0.5,
-0.5,
-0.5,
1.0,
0.0,
0.0,
0.0,
1.0,
0.5,
-0.5,
0.5,
1.0,
0.0,
0.0,
0.0,
0.0,
0.5,
0.5,
0.5,
1.0,
0.0,
0.0,
1.0,
0.0,
-0.5,
-0.5,
-0.5,
0.0,
-1.0,
0.0,
0.0,
1.0,
0.5,
-0.5,
-0.5,
0.0,
-1.0,
0.0,
1.0,
1.0,
0.5,
-0.5,
0.5,
0.0,
-1.0,
0.0,
1.0,
0.0,
0.5,
-0.5,
0.5,
0.0,
-1.0,
0.0,
1.0,
0.0,
-0.5,
-0.5,
0.5,
0.0,
-1.0,
0.0,
0.0,
0.0,
-0.5,
-0.5,
-0.5,
0.0,
-1.0,
0.0,
0.0,
1.0,
-0.5,
0.5,
-0.5,
0.0,
1.0,
0.0,
0.0,
1.0,
0.5,
0.5,
-0.5,
0.0,
1.0,
0.0,
1.0,
1.0,
0.5,
0.5,
0.5,
0.0,
1.0,
0.0,
1.0,
0.0,
0.5,
0.5,
0.5,
0.0,
1.0,
0.0,
1.0,
0.0,
-0.5,
0.5,
0.5,
0.0,
1.0,
0.0,
0.0,
0.0,
-0.5,
0.5,
-0.5,
0.0,
1.0,
0.0,
0.0,
1.0
]
vertices = (c_float * len(vertices))(*vertices)
cube_positions = [(0.0, 0.0, 0.0), (2.0, 5.0, -15.0), (-1.5, -2.2, -2.5),
(-3.8, -2.0, -12.3), (2.4, -0.4, -3.5),
(-1.7, 3.0, -7.5), (1.3, -2.0, -2.5), (1.5, 2.0, -2.5),
(1.5, 0.2, -1.5), (-1.3, 1.0, -1.5)]
cube_vao = gl.glGenVertexArrays(1)
vbo = gl.glGenBuffers(1)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vbo)
gl.glBufferData(gl.GL_ARRAY_BUFFER, sizeof(vertices), vertices,
gl.GL_STATIC_DRAW)
gl.glBindVertexArray(cube_vao)
# -- position attribute
gl.glVertexAttribPointer(0, 3, gl.GL_FLOAT, gl.GL_FALSE,
8 * sizeof(c_float), c_void_p(0))
gl.glEnableVertexAttribArray(0)
# -- normal attribute
gl.glVertexAttribPointer(1, 3, gl.GL_FLOAT,
gl.GL_FALSE, 8 * sizeof(c_float),
c_void_p(3 * sizeof(c_float)))
gl.glEnableVertexAttribArray(1)
# -- texture coordinate
gl.glVertexAttribPointer(2, 2, gl.GL_FLOAT,
gl.GL_FALSE, 8 * sizeof(c_float),
c_void_p(6 * sizeof(c_float)))
gl.glEnableVertexAttribArray(2)
# -- second configure light vao (vbo is the same)
light_vao = gl.glGenVertexArrays(1)
gl.glBindVertexArray(light_vao)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vbo)
gl.glVertexAttribPointer(0, 3, gl.GL_FLOAT, gl.GL_FALSE,
8 * sizeof(c_float), c_void_p(0))
gl.glEnableVertexAttribArray(0)
# -- load texture
diffuse_map = load_texture("container2.png")
specular_map = load_texture("container2_specular.png")
# -- shader configuration
lighting_shader.use()
lighting_shader.set_int("material.diffuse", 0)
lighting_shader.set_int("material.specular", 1)
while not glfw.window_should_close(window):
# -- time logic
current_frame = glfw.get_time()
delta_time = current_frame - last_frame
last_frame = current_frame
# -- input
process_input(window)
# -- render
gl.glClearColor(0.1, 0.1, 0.1, 1.0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
lighting_shader.use()
lighting_shader.set_vec3("light.direction", Vector3([-0.2, -1.0,
-0.3]))
lighting_shader.set_vec3("viewPos", camera.position)
# -- light properties
lighting_shader.set_vec3("light.ambient", Vector3([0.2, 0.2, 0.2]))
lighting_shader.set_vec3("light.diffuse", Vector3([0.5, 0.5, 0.5]))
lighting_shader.set_vec3("light.specular", Vector3([1.0, 1.0, 1.0]))
# -- material properties
lighting_shader.set_float("material.shininess", 32.0)
# -- view.projection transformations
projection = Matrix44.perspective_projection(camera.zoom,
SRC_WIDTH / SRC_HEIGHT,
0.1, 100.0)
view = camera.get_view_matrix()
lighting_shader.set_mat4("projection", projection)
lighting_shader.set_mat4("view", view)
# -- world transformation
model = Matrix44.identity()
lighting_shader.set_mat4("model", model)
# -- bind diffuse map
gl.glActiveTexture(gl.GL_TEXTURE0)
gl.glBindTexture(gl.GL_TEXTURE_2D, diffuse_map)
# -- bind specular map
gl.glActiveTexture(gl.GL_TEXTURE1)
gl.glBindTexture(gl.GL_TEXTURE_2D, specular_map)
# -- render cube
# gl.glBindVertexArray(cube_vao)
# gl.glDrawArrays(gl.GL_TRIANGLES, 0, 36)
# -- render continers
gl.glBindVertexArray(cube_vao)
for idx, position in enumerate(cube_positions):
angle = 20.0 * idx
rotation = matrix44.create_from_axis_rotation([1.0, 0.3, 0.5],
math.radians(angle))
translation = Matrix44.from_translation(position)
model = translation * rotation
lighting_shader.set_mat4('model', model)
gl.glDrawArrays(gl.GL_TRIANGLES, 0, 36)
# a lamp object is weird when we only have a directional light, don't render the light object
# -- draw lamp object
# lamp_shader.use()
# lamp_shader.set_mat4("projection", projection)
# lamp_shader.set_mat4("view", view)
# model = Matrix44.identity()
# model *= Matrix44.from_translation(light_pos)
# model *= Matrix44.from_scale(Vector3([.2, .2, .2]))
# lamp_shader.set_mat4("model", model)
# gl.glBindVertexArray(light_vao)
# gl.glDrawArrays(gl.GL_TRIANGLES, 0, 36)
glfw.swap_buffers(window)
glfw.poll_events()
gl.glDeleteVertexArrays(1, id(cube_vao))
gl.glDeleteVertexArrays(1, id(light_vao))
gl.glDeleteBuffers(1, id(vbo))
glfw.terminate()
def monkey_jump(structure):
if __name__ == '__main__':
# Initialize glfw
if not glfw.init():
sys.exit()
width = 700
height = 700
window = glfw.create_window(width, height, 'Saltarin', None, None)
if not window:
glfw.terminate()
sys.exit()
glfw.make_context_current(window)
# Creamos el controlador
controlador = Controller()
# Connecting the callback function 'on_key' to handle keyboard events
glfw.set_key_callback(window, controlador.on_key)
# Creating shader programs for textures and for colors
texture = es.SimpleTextureTransformShaderProgram()
color = es.SimpleTransformShaderProgram()
# Setting up the clear screen color
glClearColor(0.15, 0.15, 0.15, 1.0)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
glEnable(GL_BLEND )
# Creamos los objetos
fondo = Fondobaja()
mono = Mono("parado.png")
pasto=Pasto()
# Leemos el csv
def leer(estructura):
with open(estructura) as csv_file:
csv_reader = csv.reader(csv_file, delimiter=',')
r=[]
for row in csv_reader:
r.append(row[0])
return r
r=leer(structure)
#creamos las barras a partir del csv
barra = BarraCreator(r, mono)
controlador.set_model(mono)
controlador.set_barra(barra)
controlador.set_fondo(fondo)
t0=0
while not glfw.window_should_close(window):
# Using GLFW to check for input events
glfw.poll_events()
# Filling or not the shapes depending on the controller state
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)
# Clearing the screen in both, color and depth
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
# Dibujamos
ti = glfw.get_time()
dt = ti - t0
t0 = ti
#dibujamos el fondo y hacemos que se mueva
fondo.create_fondo()
fondo.update(0.2 * dt)
fondo.draw(texture)
#Dibujamos el pasto al al comienzo y se comienza a mover
pasto.update(0.2*dt)
pasto.draw(texture)
#Dibujamos las barras
barra.create_barra()
barra.update(0.4 * dt)
#se revisan las barras creadas para que el mono salte en ellas y se dibuja el mono
mono.jump(barra)
mono.draw(texture)
#se dibujan las barras
barra.draw(color)
#si el mono perdió, se pone la pantalla como game over
if mono.loser:
mono=Mono("gameover.png")
mono.loser=True
monoTransform= tr.uniformScale(1.7)
mono.tra = monoTransform
#si el mono ganó, se indica la victoria
elif mono.winner :
mono=Mono("victory2.png")
monoTransform= tr.uniformScale(1.7)
mono.tra = monoTransform
# Once the drawing is rendered, buffers are swap so an uncomplete drawing is never seen.
glfw.swap_buffers(window)
glfw.terminate()
def main():
rows = 0
columns = 0
height = 0
while rows < 5 or columns < 5 or height < 5:
print(
"The board should be at least 5 x 5 x 5 ! Make sure your inputs are numeric"
)
try:
rows = int(input("Enter an odd number of rows: "))
columns = int(input("Enter an odd number of columns: "))
height = int(input("Enter an odd number of layers: "))
except ValueError:
rows = 0
columns = 0
height = 0
if rows % 2 == 0:
rows += 1
if columns % 2 == 0:
columns += 1
if height % 2 == 0:
height += 1
print("Game initiated with size " + str(rows) + " x " + str(columns) +
" x " + str(height))
print("")
print(
"Use the mouse whilst holding the left click button to rotate the arena"
)
print("Use the WASD keys to control movement of the arena")
print(
"When selecting a place for your counter, type the row number first, and click enter, then type the column number next, and click enter. If the rows and"
" columns chosen are valid, then the counter will be placed in the bottom layer"
)
print(
"If a counter is already placed in that position in the layer, then the counter will be placed one layer higher than it"
)
print(
"Connect 4's can be found in all 3 dimensions, so watch out for diagonal connects between layers!"
)
print(
"Once a connect has been made, the game will end and a white line will display the positions of the connected counters on the screen"
)
print("Good luck and remember to have fun!")
print(
"Graphics by Kasim Rehman Bhatti, game mechanics by Atharva Vadeyar, server hosting by Tillega Narayanan"
)
print(
"This game was created using Python for both the machnics and graphics of the game. The graphics work by using Modern OpenGL"
)
NewGame = Game3D(rows, columns, height)
WindowName = "OpenGL Testing"
if not glfw.init():
return
ScreenWidth = 1920
ScreenHeight = 1080
window = glfw.create_window(ScreenWidth, ScreenHeight, WindowName, None,
None)
Scale = 0.5
Ratio = ScreenWidth / ScreenHeight
ScaledRatio = Scale * Ratio
if not window:
glfw.terminate()
glfw.make_context_current(window)
glfw.swap_interval(1)
NewRender = Renderer()
NewRender.AddShader("Shaders\Complete Shader")
textureNumber = NewRender.attachTextures("Textures")
vertexSize = NewRender.returnVertexSize()
NewObjectLibrary = ObjectLibrary(textureNumber, vertexSize)
oxpos = 0
oypos = 0
Change = 0.05
ChangeTX = 0.00
ChangeTY = 0.00
ChangeTZ = 0.00
CurrentQuaternion = [0, 0, 0, 1]
First = True
multiplier = (rows * columns) / 40
if (rows * columns) < 40:
multiplier = 1
radius = 0.27
depth = 0.05
accuracy = 60
length = 0.7
objectCentre = [0, 0, -4]
rotationCentre = [0, 0, -4]
texture = 2
color = [0, 0, 0.4]
counterTexture = 3
counterColor1 = [0.7, 0, 0]
counterColor2 = [0.7, 0.7, 0]
bltc = [
objectCentre[0] + (-(rows / 2)) * length,
objectCentre[2] + (-(columns / 2)) * length
]
trtc = [
objectCentre[0] + (rows / 2) * length,
objectCentre[2] + (columns / 2) * length
]
for k in range(0, int(height)):
for j in range(-int(rows / 2), int(rows / 2) + 1):
for i in range(-int(columns / 2), int(columns / 2) + 1):
NewObjectLibrary.CreateCounterHolder(
radius, depth, accuracy, length, bltc, trtc,
objectCentre[0] + j * length,
objectCentre[1] + (k * multiplier),
objectCentre[2] + i * length, rotationCentre[0],
rotationCentre[1], rotationCentre[2], color, texture)
a = [
objectCentre[0] - ((rows * length) / 2),
objectCentre[1] + (k * multiplier) + depth,
objectCentre[2] - ((columns * length) / 2)
]
b = [
objectCentre[0] + ((rows * length) / 2),
objectCentre[1] + (k * multiplier) + depth,
objectCentre[2] - ((columns * length) / 2)
]
c = [
objectCentre[0] + ((rows * length) / 2), (k * multiplier),
objectCentre[2] - ((columns * length) / 2)
]
d = [
objectCentre[0] - ((rows * length) / 2), (k * multiplier),
objectCentre[2] - ((columns * length) / 2)
]
NewObjectLibrary.CreateRectangle(a, b, c, d, objectCentre[0],
objectCentre[1],
objectCentre[2], color,
texture)
a = [
objectCentre[0] - ((rows * length) / 2),
objectCentre[1] + (k * multiplier) + depth,
objectCentre[2] + ((columns * length) / 2)
]
b = [
objectCentre[0] + ((rows * length) / 2),
objectCentre[1] + (k * multiplier) + depth,
objectCentre[2] + ((columns * length) / 2)
]
c = [
objectCentre[0] + ((rows * length) / 2), (k * multiplier),
objectCentre[2] + ((columns * length) / 2)
]
d = [
objectCentre[0] - ((rows * length) / 2), (k * multiplier),
objectCentre[2] + ((columns * length) / 2)
]
NewObjectLibrary.CreateRectangle(a, b, c, d, objectCentre[0],
objectCentre[1],
objectCentre[2], color,
texture)
a = [
objectCentre[0] + ((rows * length) / 2),
objectCentre[1] + (k * multiplier) + depth,
objectCentre[2] + ((columns * length) / 2)
]
b = [
objectCentre[0] + ((rows * length) / 2),
objectCentre[1] + (k * multiplier) + depth,
objectCentre[2] - ((columns * length) / 2)
]
c = [
objectCentre[0] + ((rows * length) / 2), (k * multiplier),
objectCentre[2] - ((columns * length) / 2)
]
d = [
objectCentre[0] + ((rows * length) / 2), (k * multiplier),
objectCentre[2] + ((columns * length) / 2)
]
NewObjectLibrary.CreateRectangle(a, b, c, d, objectCentre[0],
objectCentre[1],
objectCentre[2], color,
texture)
a = [
objectCentre[0] - ((rows * length) / 2),
objectCentre[1] + (k * multiplier) + depth,
objectCentre[2] + ((columns * length) / 2)
]
b = [
objectCentre[0] - ((rows * length) / 2),
objectCentre[1] + (k * multiplier) + depth,
objectCentre[2] - ((columns * length) / 2)
]
c = [
objectCentre[0] - ((rows * length) / 2), (k * multiplier),
objectCentre[2] - ((columns * length) / 2)
]
d = [
objectCentre[0] - ((rows * length) / 2), (k * multiplier),
objectCentre[2] + ((columns * length) / 2)
]
NewObjectLibrary.CreateRectangle(a, b, c, d, objectCentre[0],
objectCentre[1],
objectCentre[2], color,
texture)
color = [[0, 0, 0.4], [0, 0, 0.4], [0, 0, 0.4], [0, 0, 0.4], [0, 0, 0.4],
[0, 0, 0.4]]
texture = [2, 2, 2, 2, 2, 2]
NewObjectLibrary.CreateCuboid(rows * length + 2, depth, columns * length,
objectCentre[0], objectCentre[1] - 1,
objectCentre[2], rotationCentre[0],
rotationCentre[1], rotationCentre[2], color,
texture)
NewObjectLibrary.CreateCuboid(0.1, 2 * depth, columns * length,
objectCentre[0] - ((rows * length) / 2),
objectCentre[1] - 1 + depth, objectCentre[2],
rotationCentre[0], rotationCentre[1],
rotationCentre[2], color, texture)
NewObjectLibrary.CreateCuboid(0.1, 2 * depth, columns * length,
objectCentre[0] + ((rows * length) / 2),
objectCentre[1] - 1 + depth, objectCentre[2],
rotationCentre[0], rotationCentre[1],
rotationCentre[2], color, texture)
for i in range(-int(columns / 2), int(columns / 2) + 1):
NewObjectLibrary.CreateCylinder(
radius, depth, accuracy,
objectCentre[0] - ((rows * length) / 2) - 0.5,
objectCentre[1] - 1 + depth, objectCentre[2] + i * length,
rotationCentre[0], rotationCentre[1], rotationCentre[2],
counterColor1, counterTexture)
for i in range(-int(columns / 2), int(columns / 2) + 1):
NewObjectLibrary.CreateCylinder(
radius, depth, accuracy,
objectCentre[0] + ((rows * length) / 2) + 0.5,
objectCentre[1] - 1 + depth, objectCentre[2] + i * length,
rotationCentre[0], rotationCentre[1], rotationCentre[2],
counterColor2, counterTexture)
NewObjectLibrary.sortVertices()
FOVradians = 1
Near = 3
Far = -1
Done = False
currentNumber = -1
currentNumberBuffer = [-1, -1]
lastBackspace = False
lastEnter = False
currentIndex = 0
last = [
False, False, False, False, False, False, False, False, False, False
]
lastclicked = False
connectFound = False
startBuffer = [-1, -1, -1]
endBuffer = [-1, -1, -1]
NewGame.show_state()
override = False
while not glfw.window_should_close(window) and not Done:
NewRender.ProjectAndStretch(FOVradians, Near, Far, Scale, ScaledRatio)
if glfw.get_key(window, glfw.KEY_Q) == glfw.PRESS:
Done = True
if glfw.get_key(window, glfw.KEY_D) == glfw.PRESS:
ChangeTX += Change
if glfw.get_key(window, glfw.KEY_W) == glfw.PRESS:
ChangeTY += Change
if glfw.get_key(window, glfw.KEY_A) == glfw.PRESS:
ChangeTX -= Change
if glfw.get_key(window, glfw.KEY_S) == glfw.PRESS:
ChangeTY -= Change
if glfw.get_key(window, glfw.KEY_I) == glfw.PRESS:
ChangeTZ -= Change
if glfw.get_key(window, glfw.KEY_L) == glfw.PRESS:
ChangeTZ += Change
enterList = clicked(window, glfw.KEY_ENTER, lastEnter, override)
lastEnter = enterList[1]
enter = enterList[0]
enterList = clicked(window, glfw.KEY_BACKSPACE, lastBackspace,
override)
lastBackspace = enterList[1]
backspace = enterList[0]
if backspace:
if currentNumber == 0:
currentNumber = -1
elif currentNumber != -1:
currentNumber /= 10
currentNumber = int(currentNumber)
for i in range(0, 10):
enterList = receiveInputCounter(window, 0 + i, glfw.KEY_0 + i,
last[i], currentNumber, override)
currentNumber = enterList[2]
last[i] = enterList[1]
if enter:
if currentNumber != -1:
currentNumberBuffer[currentIndex] = currentNumber
currentIndex += 1
currentNumber = -1
if currentIndex == 2:
currentIndex = 0
if currentNumberBuffer[0] != -1 and currentNumberBuffer[
1] != -1 and not connectFound:
EnteredRow = False
EnteredColumn = False
if currentNumberBuffer[0] > rows - 1:
print("invalid row")
else:
EnteredRow = True
if currentNumberBuffer[1] > columns - 1:
print("invalid column")
else:
EnteredColumn = True
initialPlayer = NewGame.return_player()
if EnteredRow and EnteredColumn:
added = NewGame.add(currentNumberBuffer[0],
currentNumberBuffer[1], initialPlayer)
newHeight = height - (added + 1)
(turn, arrays) = NewGame.newTurn(currentNumberBuffer[0],
currentNumberBuffer[1],
newHeight)
if turn == 1:
connectFound = True
startBuffer = arrays[0]
startBuffer[2] = -(startBuffer[2] + 1)
endBuffer = arrays[1]
endBuffer[2] = -(endBuffer[2] + 1)
print(startBuffer)
print(endBuffer)
if added != -1 and added != -2:
if initialPlayer == 1:
counterColor = counterColor1
else:
counterColor = counterColor2
NewObjectLibrary.CreateCylinder(
radius, depth, accuracy, objectCentre[0] +
((currentNumberBuffer[0] - int(rows / 2)) * length),
objectCentre[1] + (newHeight * multiplier),
objectCentre[2] +
((currentNumberBuffer[1] - int(columns / 2)) * length),
rotationCentre[0], rotationCentre[1],
rotationCentre[2], counterColor, counterTexture)
NewObjectLibrary.sortVertices()
NewGame.player_switch()
print("")
print("New state")
NewGame.show_state()
currentNumber = -1
currentNumberBuffer = [-1, -1]
else:
currentNumberBuffer = [-1, -1]
else:
currentNumber = -1
currentNumberBuffer = [-1, -1]
if connectFound:
if startBuffer[0] != -1 and startBuffer[1] != -1 and startBuffer[
2] != -1:
if startBuffer[0] > rows - 1:
startBuffer[0] = rows - 1
if startBuffer[1] > columns - 1:
startBuffer[1] = columns - 1
if startBuffer[2] > height - 1:
startBuffer[2] = height - 1
if endBuffer[0] != -1 and endBuffer[1] != -1 and endBuffer[
2] != -1:
if endBuffer[0] > rows - 1:
endBuffer[0] = rows - 1
if endBuffer[1] > columns - 1:
endBuffer[1] = columns - 1
if endBuffer[2] > height - 1:
endBuffer[2] = height - 1
a = [
objectCentre[0] +
((startBuffer[0] - int(rows / 2)) * length),
objectCentre[1] + (startBuffer[2] * multiplier) + 0.2,
objectCentre[2] +
((startBuffer[1] - int(columns / 2)) * length + 0.05)
]
b = [
objectCentre[0] +
((startBuffer[0] - int(rows / 2)) * length),
objectCentre[1] + (startBuffer[2] * multiplier) + 0.2,
objectCentre[2] +
((startBuffer[1] - int(columns / 2)) * length - 0.05)
]
d = [
objectCentre[0] +
((endBuffer[0] - int(rows / 2)) * length),
objectCentre[1] + (endBuffer[2] * multiplier) + 0.2,
objectCentre[2] +
((endBuffer[1] - int(columns / 2)) * length + 0.05)
]
c = [
objectCentre[0] +
((endBuffer[0] - int(rows / 2)) * length),
objectCentre[1] + (endBuffer[2] * multiplier) + 0.2,
objectCentre[2] +
((endBuffer[1] - int(columns / 2)) * length - 0.05)
]
NewObjectLibrary.CreateRectangle(a, b, c, d, objectCentre[0],
objectCentre[1],
objectCentre[2], [1, 1, 1],
counterTexture)
NewObjectLibrary.sortVertices()
connectFound = False
xypos = glfw.get_cursor_pos(window)
xpos = xypos[0]
ypos = xypos[1]
click = glfw.get_mouse_button(window, glfw.MOUSE_BUTTON_LEFT)
if click == glfw.PRESS:
clickbool = True
else:
clickbool = False
if clickbool and lastclicked:
Deltay = xpos - oxpos
Deltax = ypos - oypos
AngleX = 0.00
AngleY = 0.00
if Deltay < 0:
AngleY = Change * 120 * (-Deltay / ScreenHeight)
elif Deltay > 0:
AngleY = Change * 120 * (-Deltay / ScreenHeight)
if Deltax < 0:
AngleX = Change * 240 * (-Deltax / ScreenWidth)
elif Deltax > 0:
AngleX = Change * 240 * (-Deltax / ScreenWidth)
Quat = [
m.sin(AngleX / 2) * m.cos(AngleY / 2),
m.sin(AngleY / 2) * m.cos(AngleX / 2),
m.sin(AngleX / 2) * m.sin(AngleY / 2),
m.cos(AngleX / 2) * m.cos(AngleY / 2)
]
if First:
CurrentQuaternion = Quat
CurrentQuaternion = normalizeQuaternion(CurrentQuaternion)
First = False
else:
CurrentQuaternion = multiplyQuaternions(
Quat, CurrentQuaternion)
CurrentQuaternion = normalizeQuaternion(CurrentQuaternion)
NewRender.RotateQuaternion(CurrentQuaternion)
NewRender.Translate(ChangeTX, ChangeTY, ChangeTZ)
NewRender.Lighting(0, 2, 2)
NewRender.Draw3D(NewObjectLibrary.returnVertices())
oxpos = xpos
oypos = ypos
lastclicked = clickbool
glfw.swap_buffers(window)
glfw.poll_events()
glfw.terminate()
def PollEvents():
glfw.poll_events()
def run(self):
glfw_native.glfwGetCocoaWindow.argtypes = [
ctypes.POINTER(glfw._GLFWwindow)
]
glfw_native.glfwGetCocoaWindow.restype = ctypes.c_void_p
glfw_native.glfwCreateWindow.argtypes = [
ctypes.c_int,
ctypes.c_int,
ctypes.c_char_p,
]
glfw_native.glfwCreateWindow.restype = ctypes.POINTER(glfw._GLFWwindow)
glfw_native.glfwMakeContextCurrent.argtypes = [
ctypes.POINTER(glfw._GLFWwindow)
]
glfw_native.glfwWindowShouldClose.argtypes = [
ctypes.POINTER(glfw._GLFWwindow)
]
glfw_native.glfwWindowShouldClose.restype = ctypes.c_int
glfw.init()
glfw.window_hint(glfw.CLIENT_API, glfw.NO_API)
glfw.window_hint(glfw.COCOA_RETINA_FRAMEBUFFER, glfw.TRUE)
self.window = glfw.create_window(self.width, self.height, self.title,
None, None)
self.fb_width, self.fb_height = glfw.get_framebuffer_size(self.window)
self.hidpi = self.fb_width != self.width or self.fb_height != self.height
glfw.set_window_size_callback(self.window, self._handle_window_resize)
handle, display = None, None
if sys.platform == "darwin":
glfw_native.glfwGetCocoaWindow.argtypes = [
ctypes.POINTER(glfw._GLFWwindow)
]
glfw_native.glfwGetCocoaWindow.restype = ctypes.c_void_p
handle = glfw_native.glfwGetCocoaWindow(self.window)
elif sys.platform == "windows":
glfw_native.glfwGetWin32Window.argtypes = [
ctypes.POINTER(glfw._GLFWwindow)
]
glfw_native.glfwGetWin32Window.restype = ctypes.c_void_p
handle = glfw_native.glfwGetWin32Window(self.window)
elif sys.platform == "linux":
glfw_native.glfwGetX11Window.argtypes = [
ctypes.POINTER(glfw._GLFWwindow)
]
glfw_native.glfwGetX11Window.restype = ctypes.c_void_p
handle = glfw_native.glfwGetX11Window(self.window)
display = glfw_native.glfwGetX11Display()
data = bgfx.PlatformData()
data.ndt = display
data.nwh = as_void_ptr(handle)
data.context = None
data.backBuffer = None
data.backBufferDS = None
self.init(data)
last_time = None
while not glfw.window_should_close(self.window):
glfw.poll_events()
now = time.perf_counter()
if not last_time:
last_time = now
frame_time = now - last_time
last_time = now
self.update(frame_time)
self.shutdown()
glfw.terminate()
def main():
# declare draw method so it can be reused during resizing
def draw():
gl.glClearColor(0.2, 0.3, 0.3, 1.0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
gl.glUseProgram(shaderProgram)
gl.glBindVertexArray(VAO)
gl.glDrawElements(gl.GL_TRIANGLES, 3 * indices.shape[0],
gl.GL_UNSIGNED_INT, None)
gl.glBindVertexArray(0)
glfw.swap_buffers(window)
# declaring resize callback in main to allow access to variables
def window_size_callback(window, width, height):
gl.glViewport(0, 0, width, height)
# calling draw to allow drawing while resizing
draw()
# glfw: initialize and configure
glfw.init()
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3)
glfw.window_hint(glfw.OPENGL_PROFILE,
glfw.OPENGL_CORE_PROFILE) # No deprecated functions
glfw.window_hint(glfw.RESIZABLE, gl.GL_TRUE)
# checking if run on Mac OS X
if sys.platform == 'darwin':
glfw.window_hint(glfw.OPENGL_FORWARD_COMPAT, gl.GL_TRUE)
# glfw window creation
window = glfw.create_window(WIDTH, HEIGHT, 'LearnOpenGL', None,
None) # tutorial: (800, 600...
if window is None:
glfw.terminate()
raise Exception("ERROR: Failed to create GLFW window")
glfw.make_context_current(window)
glfw.set_key_callback(window, key_callback)
width, height = glfw.get_framebuffer_size(window)
glfw.set_window_size_callback(window, window_size_callback)
# build and compile shader program
# vertex shader
vertexShader = gl.glCreateShader(gl.GL_VERTEX_SHADER)
gl.glShaderSource(vertexShader, vertexShaderSource)
gl.glCompileShader(vertexShader)
if not gl.glGetShaderiv(vertexShader, gl.GL_COMPILE_STATUS):
infoLog = gl.glGetShaderInfoLog(vertexShader).decode()
raise Exception("ERROR::SHADER::VERTEX::COMPILATION_FAILED\n" +
infoLog)
# fragment shader
fragmentShader = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
gl.glShaderSource(fragmentShader, fragmentShaderSource)
gl.glCompileShader(fragmentShader)
if not gl.glGetShaderiv(fragmentShader, gl.GL_COMPILE_STATUS):
infoLog = gl.glGetShaderInfoLog(fragmentShader).decode()
raise Exception("ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n" +
infoLog)
# link shaders
shaderProgram = gl.glCreateProgram()
gl.glAttachShader(shaderProgram, vertexShader)
gl.glAttachShader(shaderProgram, fragmentShader)
gl.glLinkProgram(shaderProgram)
if not gl.glGetProgramiv(shaderProgram, gl.GL_LINK_STATUS):
infoLog = gl.glGetProgramInfoLog(shaderProgram).decode()
raise Exception("ERROR::SHADER::PROGRAM::LINKING_FAILED\n" + infoLog)
gl.glDeleteShader(vertexShader)
gl.glDeleteShader(fragmentShader)
# set up vertex data (and buffer(s)) and configure vertex attributes
vertices = np.array(
[
[0.5, 0.5, 0.0], # Left
[0.5, -0.5, 0.0], # Right
[-0.5, -0.5, 0.0],
[-0.5, 0.5, 0.0],
[1.0, -0.5, 0.0]
], # Top
dtype=np.float32)
indices = np.array(
[
[3, 2, 1], # first triangle
[0, 1, 4]
], # second triangle
dtype=np.int32)
VBO, VAO, EBO = gl.GLuint(), gl.GLuint(), gl.GLuint()
gl.glGenVertexArrays(1, VAO) # 1 -> 1 buffer to be generated
gl.glGenBuffers(1, VBO)
gl.glGenBuffers(1, EBO)
# bind the Vertex Array Object first, then bind and set vertex buffer(s), and then configure vertex attributes(s)
gl.glBindVertexArray(VAO)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER,
VBO) # bind = make active/current for subsequent ops
gl.glBufferData(gl.GL_ARRAY_BUFFER, vertices, gl.GL_STATIC_DRAW)
gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, EBO)
gl.glBufferData(gl.GL_ELEMENT_ARRAY_BUFFER, indices, gl.GL_STATIC_DRAW)
stride = vertices.itemsize * vertices.shape[1]
offset = gl.ctypes.c_void_p(vertices.itemsize * 0)
gl.glVertexAttribPointer(0, 3, gl.GL_FLOAT, gl.GL_FALSE, stride, offset)
gl.glEnableVertexAttribArray(0) # location = 0
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, 0)
gl.glBindVertexArray(0)
# to put in wireframe mode
# gl.glPolygonMode(gl.GL_FRONT_AND_BACK, gl.GL_LINE)
# render loop
while not glfw.window_should_close(window):
glfw.poll_events()
draw()
glfw.terminate()
return 0
def main():
if not glfw.init():
return
window = glfw.create_window(2 * size_x, 2 * size_y, "lab", None, None)
if not window:
glfw.terminate()
return
glfw.make_context_current(window)
glfw.set_key_callback(window, moveevent)
glClearColor(0.3, 0.3, 0.3, 1)
glEnable(GL_DEPTH_TEST)
glLoadIdentity()
glMultMatrixd([
1,
0,
0,
0, # move back
0,
1,
0,
0,
0,
0,
1,
0,
-0.9,
-0.9,
0.2,
1
])
cos45 = math.sqrt(2) / 2
glMultMatrixd([
1,
0,
0,
0, # ox 45
0,
cos45,
cos45,
0,
0,
-cos45,
cos45,
0,
0,
0,
0,
1
])
glMultMatrixd([
cos45,
cos45,
0,
0, # oz 45
-cos45,
cos45,
0,
0,
0,
0,
1,
0,
0,
0,
0,
1
])
glMultMatrixd([
1,
0,
0,
0, # move to center
0,
1,
0,
0,
0,
0,
1,
0,
0.9,
0.9,
-0.2,
1
])
glPushMatrix()
def mainbox():
glMultMatrixd([
scale * xscale,
0,
0,
0, # back center + scale
0,
scale * yscale,
0,
0,
0,
0,
scale * zscale,
0,
0,
0,
0.5,
1
])
glMultMatrixd([
math.cos(oztr),
math.sin(oztr),
0,
0, # z rotate
-math.sin(oztr),
math.cos(oztr),
0,
0,
0,
0,
1,
0,
0,
0,
0,
1
])
glMultMatrixd([
math.cos(oytr),
0,
math.sin(oytr),
0, # y rotate
0,
1,
0,
0,
-math.sin(oytr),
0,
math.cos(oytr),
0,
0,
0,
0,
1
])
glMultMatrixd([
1,
0,
0,
0, # x rotate
0,
math.cos(oxtr),
-math.sin(oxtr),
0,
0,
math.sin(oxtr),
math.cos(oxtr),
0,
0,
0,
0,
1
])
glMultMatrixd([
1,
0,
0,
0, # move to center
0,
1,
0,
0,
0,
0,
1,
0,
0,
0,
-0.5,
1
])
glBegin(GL_QUADS if colormode else GL_LINES)
glColor3f(1, 0, 0)
glVertex3f(-0.5, -0.5, -0.5)
glVertex3f(0.5, -0.5, -0.5)
glVertex3f(0.5, 0.5, -0.5)
glVertex3f(-0.5, 0.5, -0.5)
glColor3f(0, 1, 0)
glVertex3f(-0.5, -0.5, 0.5)
glVertex3f(0.5, -0.5, 0.5)
glVertex3f(0.5, 0.5, 0.5)
glVertex3f(-0.5, 0.5, 0.5)
glColor3f(0, 0, 1)
glVertex3f(-0.5, -0.5, -0.5)
glVertex3f(-0.5, 0.5, -0.5)
glVertex3f(-0.5, 0.5, 0.5)
glVertex3f(-0.5, -0.5, 0.5)
glColor3f(0, 0.5, 0.5)
glVertex3f(0.5, -0.5, -0.5)
glVertex3f(0.5, 0.5, -0.5)
glVertex3f(0.5, 0.5, 0.5)
glVertex3f(0.5, -0.5, 0.5)
glColor3f(0.5, 0.2, 0.7)
glVertex3f(0.5, -0.5, -0.5)
glVertex3f(0.5, -0.5, 0.5)
glVertex3f(-0.5, -0.5, 0.5)
glVertex3f(-0.5, -0.5, -0.5)
glColor3f(0.5, 0.5, 0)
glVertex3f(0.5, 0.5, -0.5)
glVertex3f(0.5, 0.5, 0.5)
glVertex3f(-0.5, 0.5, 0.5)
glVertex3f(-0.5, 0.5, -0.5)
glEnd()
def minibox():
glPopMatrix()
glBegin(GL_QUADS)
glColor3f(0.8, 0.2, 0.2)
glVertex3f(-0.9, -0.9, 0.2)
glVertex3f(-0.8, -0.9, 0.2)
glVertex3f(-0.8, -0.8, 0.2)
glVertex3f(-0.9, -0.8, 0.2)
glColor3f(0.2, 0.8, 0.2)
glVertex3f(-0.9, -0.9, 0.2)
glVertex3f(-0.9, -0.9, 0.3)
glVertex3f(-0.9, -0.8, 0.3)
glVertex3f(-0.9, -0.8, 0.2)
glColor3f(0.2, 0.2, 0.8)
glVertex3f(-0.9, -0.9, 0.2)
glVertex3f(-0.8, -0.9, 0.2)
glVertex3f(-0.8, -0.9, 0.3)
glVertex3f(-0.9, -0.9, 0.3)
glEnd()
glPushMatrix()
def ortograph():
# front view
glViewport(0, size_y, size_x, size_y)
glLoadIdentity()
glMultMatrixd([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, -1, 0, 0, 0, 0, 1])
mainbox()
# top view
glViewport(0, 0, size_x, size_y)
glLoadIdentity()
glMultMatrixd([1, 0, 0, 0, 0, 0, -1, 0, 0, -1, 0, 0, 0, 0, 0, 1])
mainbox()
# side view
glViewport(size_x, size_y, size_x, size_y)
glLoadIdentity()
glMultMatrixd([0, 0, -1, 0, 0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 0, 1])
mainbox()
# main view
glViewport(size_x, 0, size_x, size_y)
glLoadIdentity()
glMultMatrixd([
0.87,
0,
1,
0.5, # double point perspective
0,
1,
0,
0,
0.5,
0,
-1.73,
-0.87,
0,
0,
1,
2
])
glMultMatrixd(
[1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, xpos, ypos, zpos, 1])
mainbox()
while not glfw.window_should_close(window):
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
ortograph()
minibox()
glfw.swap_buffers(window)
glfw.poll_events()
time.sleep(0.01)
glfw.destroy_window(window)
glfw.terminate()
def display(window):
global triangles
global shift_x, shift_y
glClear(GL_COLOR_BUFFER_BIT)
glLoadIdentity()
glClearColor(1.0, 1.0, 1.0, 1.0)
glPushMatrix()
#glRotatef(angle, 0, 0, 1)
glBegin(GL_TRIANGLES)
if mode:
colors = colors_1
else:
colors = colors_2
for i in range(len(triangles) - 2):
glColor3f(*colors[0])
glVertex2f(triangles[i][0], triangles[i][1])
glColor3f(*colors[1])
glVertex2f(triangles[i + 1][0], triangles[i + 1][1])
glColor3f(*colors[2])
glVertex2f(triangles[i + 2][0], triangles[i + 2][1])
glEnd()
if mode:
to_x = triangles[-1][0] + shift_x + random() * size * 7
to_y = triangles[-1][1] + shift_y + random() * size * 7
else:
to_x = triangles[0][0] + shift_x + random() * size * 7
to_y = triangles[0][1] + shift_y + random() * size * 7
shift_x += (random() * size - size / 2)
shift_y += (random() * size - size / 2)
if 1 - to_x < 0.2:
shift_x -= random() * size * 1.5
if to_x - (-1) < 0.2:
shift_x += random() * size * 1.5
if 1 - to_y < 0.3:
shift_y -= random() * size * 1.5
if to_y - (-1) < 0.3:
shift_y += random() * size * 1.5
if to_x > 1:
if mode:
to_x = triangles[-1][0] - random() * size
else:
to_x = triangles[0][0] - random() * size
if to_x < -1:
if mode:
to_x = triangles[-1][0] + random() * size
else:
to_x = triangles[0][0] + random() * size
if to_y > 1:
if mode:
to_y = triangles[-1][1] - random() * size
else:
to_y = triangles[0][1] - random() * size
if to_y < -1:
if mode:
to_y = triangles[-1][1] + random() * size
else:
to_y = triangles[0][1] + random() * size
if mode:
triangles.append((to_x, to_y))
else:
triangles.insert(0, (to_x, to_y))
#triangles.append((random()*size - size/2, random()*size - size/2))
if len(triangles) > max_len:
if mode:
triangles = triangles[1:]
else:
triangles = triangles[:-1]
time.sleep(0.1)
glPopMatrix()
glfw.swap_buffers(window)
glfw.poll_events()
def main():
global shader
vertex_src = """
# version 330
layout(location = 0) in vec3 a_position;
layout(location = 1) in vec2 a_texture;
layout(location = 2) in vec3 a_normal;
uniform mat4 model;
uniform mat4 projection;
uniform mat4 view;
out vec2 v_texture;
void main()
{
gl_Position = projection * view * model * vec4(a_position, 1.0);
v_texture = a_texture;
}
"""
fragment_src = """
# version 330
in vec2 v_texture;
out vec4 out_color;
uniform sampler2D s_texture;
void main()
{
out_color = texture(s_texture, v_texture);
}
"""
# initializing glfw library
if not glfw.init():
raise Exception("glfw can not be initialized!")
if "Windows" in pltf.platform():
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 4)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 6)
glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
glfw.window_hint(glfw.OPENGL_FORWARD_COMPAT, True)
else:
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 4)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 1)
glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
glfw.window_hint(glfw.OPENGL_FORWARD_COMPAT, True)
# creating the window
window = glfw.create_window(1280, 720, "My OpenGL window", None, None)
# check if window was created
if not window:
glfw.terminate()
raise Exception("glfw window can not be created!")
# set window's position
glfw.set_window_pos(window, 100, 100)
# set the callback function for window resize
glfw.set_window_size_callback(window, window_resize_clb)
# set the mouse position callback
glfw.set_cursor_pos_callback(window, mouse_look_clb)
# set the keyboard input callback
glfw.set_key_callback(window, key_input_clb)
# capture the mouse cursor
glfw.set_input_mode(window, glfw.CURSOR, glfw.CURSOR_DISABLED)
# make the context current
glfw.make_context_current(window)
# load here the 3d meshes
chibi_indices, chibi_buffer = ObjLoader.load_model("meshes/chibi.obj")
plane_buffer = [
0.0, 0.0, 0.0, 0.0, 0.0, 10.0, 0.0, 0.0, 1.0, 0.0, 10.0, 10.0, 0.0,
1.0, 1.0, 0.0, 10.0, 0.0, 0.0, 1.0
]
plane_buffer = np.array(plane_buffer, dtype=np.float32)
plane_indices = [0, 1, 2, 2, 3, 0]
plane_indices = np.array(plane_indices, dtype=np.uint32)
# VAO and VBO
VAO = glGenVertexArrays(2)
VBO = glGenBuffers(2)
EBO = glGenBuffers(1)
# Chibi VAO
glBindVertexArray(VAO[0])
shader = compileProgram(compileShader(vertex_src, GL_VERTEX_SHADER),
compileShader(fragment_src, GL_FRAGMENT_SHADER))
# Chibi Vertex Buffer Object
glBindBuffer(GL_ARRAY_BUFFER, VBO[0])
glBufferData(GL_ARRAY_BUFFER, chibi_buffer.nbytes, chibi_buffer,
GL_STATIC_DRAW)
# chibi vertices
glEnableVertexAttribArray(0)
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, chibi_buffer.itemsize * 8,
ctypes.c_void_p(0))
# chibi textures
glEnableVertexAttribArray(1)
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, chibi_buffer.itemsize * 8,
ctypes.c_void_p(12))
# chibi normals
glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, chibi_buffer.itemsize * 8,
ctypes.c_void_p(20))
glEnableVertexAttribArray(2)
# Plane VAO
glBindVertexArray(VAO[1])
# Plane Vertex Buffer Object
glBindBuffer(GL_ARRAY_BUFFER, VBO[1])
glBufferData(GL_ARRAY_BUFFER, plane_buffer.nbytes, plane_buffer,
GL_STATIC_DRAW)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO)
glBufferData(GL_ELEMENT_ARRAY_BUFFER, plane_indices.nbytes, plane_indices,
GL_STATIC_DRAW)
# plane vertices
glEnableVertexAttribArray(0)
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, plane_buffer.itemsize * 5,
ctypes.c_void_p(0))
# plane textures
glEnableVertexAttribArray(1)
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, plane_buffer.itemsize * 5,
ctypes.c_void_p(12))
textures = glGenTextures(2)
load_texture("meshes/chibi.png", textures[0])
# create texture for the plane
glBindTexture(GL_TEXTURE_2D, textures[1])
# texture wrapping params
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT)
# texture filtering params
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1280, 720, 0, GL_RGBA,
GL_UNSIGNED_BYTE, None)
glBindTexture(GL_TEXTURE_2D, 0)
depth_buff = glGenRenderbuffers(1)
glBindRenderbuffer(GL_RENDERBUFFER, depth_buff)
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, 1280, 720)
FBO = glGenFramebuffers(1)
glBindFramebuffer(GL_FRAMEBUFFER, FBO)
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
textures[1], 0)
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
GL_RENDERBUFFER, depth_buff)
glBindFramebuffer(GL_FRAMEBUFFER, 0)
glUseProgram(shader)
glClearColor(0, 0.1, 0.1, 1)
glEnable(GL_DEPTH_TEST)
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
projection = pyrr.matrix44.create_perspective_projection_matrix(
45, 1280 / 720, 0.1, 100)
chibi_pos_main = pyrr.matrix44.create_from_translation(
pyrr.Vector3([0, 0, -5]))
plane_pos = pyrr.matrix44.create_from_translation(
pyrr.Vector3([-20, -3, -10]))
model_loc = glGetUniformLocation(shader, "model")
proj_loc = glGetUniformLocation(shader, "projection")
view_loc = glGetUniformLocation(shader, "view")
glUniformMatrix4fv(proj_loc, 1, GL_FALSE, projection)
glUseProgram(0)
# the main application loop
while not glfw.window_should_close(window):
glfw.poll_events()
do_movement()
glClearColor(0, 0.1, 0.1, 1)
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
view = cam.get_view_matrix()
glUseProgram(shader)
glUniformMatrix4fv(view_loc, 1, GL_FALSE, view)
rot_y = pyrr.Matrix44.from_y_rotation(0.8 * glfw.get_time())
model = pyrr.matrix44.multiply(rot_y, chibi_pos_main)
# draw the chibi character
glBindVertexArray(VAO[0])
glBindTexture(GL_TEXTURE_2D, textures[0])
glUniformMatrix4fv(model_loc, 1, GL_FALSE, model)
glDrawArrays(GL_TRIANGLES, 0, len(chibi_indices))
# draw the chibi to the custom frame buffer
glBindFramebuffer(GL_FRAMEBUFFER, FBO)
glClearColor(0.0, 0.0, 0.0, 1.0)
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
glDrawArrays(GL_TRIANGLES, 0, len(chibi_indices))
glBindVertexArray(0)
glBindFramebuffer(GL_FRAMEBUFFER, 0)
# draw the plane
glBindVertexArray(VAO[1])
glBindTexture(GL_TEXTURE_2D, textures[1])
glUniformMatrix4fv(model_loc, 1, GL_FALSE, plane_pos)
glDrawElements(GL_TRIANGLES, len(plane_indices), GL_UNSIGNED_INT, None)
glUseProgram(0)
glfw.swap_buffers(window)
# terminate glfw, free up allocated resources
glfw.terminate()
def main():
width = 1920
height = 1080
# Initialize the library
if not glfw.init():
return
# Create a windowed mode window and its OpenGL context
window = glfw.create_window(width, height, "OpenCV", None, None)
if not window:
glfw.terminate()
return
# Make the window's context current
glfw.make_context_current(window)
fullscreen_quad = Quad()
quad = Quad(width=8, height=5, center=False)
fullscreen_shader = Shader()
fullscreen_shader.set_shader(vert='canvas.vert', frag='canvas.frag')
quad_shader = Shader()
quad_shader.set_shader(vert='quad.vert', frag='quad.frag')
fullscreen_texture = Texture()
quad_texture = Texture()
quad_texture.set_texture('D:/Documents/projects/PyTools/PyTools/inner_chessboard.jpg')
criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001)
objp = np.zeros((6 * 9, 3), np.float32)
objp[:, :2] = np.mgrid[0:9, 0:6].T.reshape(-1, 2)
axis = np.float32([[3, 0, 0], [0, 3, 0], [0, 0, -3]]).reshape(-1, 3)
objp = np.array([
objp[0],
objp[8],
objp[45],
objp[53]
])
cap = cv2.VideoCapture('D:/Documents/projects/PyTools/PyTools/chessboard2.mp4')
projection = projection_matrix_from_intrinsic_julian(camera_matrix=PIXEL_3_XL_CAMERA_MATRIX, near=0.1,
far=1000.0, width=width, height=height)
view = pyrr.matrix44.create_look_at(eye=np.array([0, 0, 50]), target=np.array([0, 0, 0]), up=np.array([0, 1, 0]))
model = pyrr.matrix44.create_identity()
i = 0
while cap.isOpened():
# Capture frame-by-frame
ret, img = cap.read()
cv2.imwrite('frames/img{}.jpg'.format(i), img)
i += 1
if ret:
# cv2.imwrite("img.jpg", img)
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
ret, corners = cv2.findChessboardCorners(gray, (9, 6), None)
corners = np.array([
corners[0],
corners[8],
corners[45],
corners[53]
])
if ret:
corners2 = cv2.cornerSubPix(gray, corners, (11, 11), (-1, -1), criteria)
# Find the rotation and translation vectors.
ret, rvecs, tvecs = cv2.solvePnP(objp, corners2, PIXEL_3_XL_CAMERA_MATRIX, None)
# convert rvecs and tvecs
if ret:
view = view_matrix_from_rvec_tvec(rvec=rvecs, tvec=tvecs)
# project 3D points to image plane
imgpts, jac = cv2.projectPoints(axis, rvecs, tvecs, PIXEL_3_XL_CAMERA_MATRIX, None)
img = draw(img, corners2, imgpts)
cv2.flip(img, 0, img)
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img = np.true_divide(img, 255.0)
# fullscreen
fullscreen_texture.set_texture_from_buffer(img)
fullscreen_shader.use_shader()
glActiveTexture(GL_TEXTURE0)
fullscreen_texture.use_texture()
glUniform1i(glGetUniformLocation(fullscreen_shader.programId, "draw_texture"), 0)
fullscreen_quad.draw()
# quad
quad_shader.use_shader()
glActiveTexture(GL_TEXTURE0)
quad_texture.use_texture()
glUniform1i(glGetUniformLocation(quad_shader.programId, "draw_texture"), 0)
glUniformMatrix4fv(glGetUniformLocation(quad_shader.programId, "P"), 1, GL_FALSE, projection)
glUniformMatrix4fv(glGetUniformLocation(quad_shader.programId, "V"), 1, GL_FALSE, view)
glUniformMatrix4fv(glGetUniformLocation(quad_shader.programId, "M"), 1, GL_FALSE, model)
quad.draw()
# Swap front and back buffers
glfw.swap_buffers(window)
# Poll for and process events
glfw.poll_events()
else:
break
cv2.destroyAllWindows()
def render_snippet(
source,
file_path,
title="",
width=200,
height=200,
auto_layout=False,
output_dir='.',
click=None,
):
_patch_imgui()
source = find_fonts(source)
init_source, frame_source = split_sources(source)
init_code = compile(init_source, '<str>', 'exec')
frame_code = compile(frame_source, '<str>', 'exec')
window_name = "minimal ImGui/GLFW3 example"
if not glfw.init():
print("Could not initialize OpenGL context")
exit(1)
# OS X supports only forward-compatible core profiles from 3.2
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3)
glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
glfw.window_hint(glfw.OPENGL_FORWARD_COMPAT, gl.GL_TRUE)
# note: creating context without window is tricky so made window invisible
glfw.window_hint(glfw.VISIBLE, False)
window = glfw.create_window(int(width), int(height), window_name, None,
None)
glfw.make_context_current(window)
if not window:
glfw.terminate()
print("Could not initialize Window")
exit(1)
impl = GlfwRenderer(window)
if init_source:
exec(init_code, locals(), globals())
glfw.poll_events()
# render target for framebuffer
texture = gl.glGenTextures(1)
gl.glBindTexture(gl.GL_TEXTURE_2D, texture)
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGBA, width, height, 0,
gl.GL_RGB, gl.GL_UNSIGNED_BYTE, None)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER,
gl.GL_NEAREST)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER,
gl.GL_NEAREST)
# create new framebuffer
offscreen_fb = gl.glGenFramebuffers(1)
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, offscreen_fb)
# attach texture to framebuffer
gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0,
gl.GL_TEXTURE_2D, texture, 0)
# note: Clicking simulation is hacky as f**k and it
# requires at least three frames to be rendered:
# * 1st with mouse in position but without button pressed.
# * 2nd in roughly same posiotion of mouse to turn on hover
# mouse button starts to press but still does not trigger click.
# * 3rd in the same position with button pressed still to finally
# trigger the "clicked" state.
# note: If clicking simulation is not required we draw only one frame.
for m_state in ([None, None, None] if not click else [False, True, True]):
# note: Mouse click MUST be simulated before new_frame call!
if click:
impl.io.mouse_draw_cursor = True
simulate_click(click[0], click[1], m_state)
else:
# just make sure mouse state is clear
_clear_mouse()
impl.process_inputs()
imgui.new_frame()
with imgui.styled(imgui.STYLE_ALPHA, 1):
imgui.core.set_next_window_size(0, 0)
if auto_layout:
imgui.set_next_window_size(width - 10, height - 10)
imgui.set_next_window_position(impl.io.display_size.x * 0.5,
impl.io.display_size.y * 0.5,
pivot_x=0.5,
pivot_y=0.5)
exec(frame_code, locals(), globals())
gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, offscreen_fb)
gl.glClearColor(1, 1, 1, 0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
imgui.render()
impl.render(imgui.get_draw_data())
# retrieve pixels from framebuffer and write to file
pixels = gl.glReadPixels(0, 0, width, height, gl.GL_RGBA,
gl.GL_UNSIGNED_BYTE)
image = Image.frombytes('RGBA', (width, height), pixels)
# note: glReadPixels returns lines "bottom to top" but PIL reads bytes
# top to bottom
image = image.transpose(Image.FLIP_TOP_BOTTOM)
image.save(os.path.join(output_dir, file_path))
glfw.terminate()
def main():
# initialize glfw
if not glfw.init():
return
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 4)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3)
#creating the window
window = glfw.create_window(800, 600, "My OpenGL window", None, None)
if not window:
glfw.terminate()
return
glfw.make_context_current(window)
imgui.create_context()
impl = GlfwRenderer(window)
# positions colors texture coords
quad = [
-1.0, -1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, -1.0, 0.0, 0.0, 1.0,
0.0, 1.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, -1.0, 1.0, 0.0,
1.0, 1.0, 1.0, 0.0, 1.0
]
quad = np.array(quad, dtype=np.float32)
indices = [0, 1, 2, 2, 3, 0]
indices = np.array(indices, dtype=np.uint32)
vertex_shader = """
#version 430
in layout(location = 0) vec3 position;
in layout(location = 1) vec3 color;
in layout(location = 2) vec2 inTexCoords;
out vec3 newColor;
out vec2 outTexCoords;
void main()
{
gl_Position = vec4(position, 1.0f);
newColor = color;
outTexCoords = vec2(inTexCoords.x, 1.0f - inTexCoords.y);
}
"""
fragment_shader = """
#version 430
in vec3 newColor;
in vec2 outTexCoords;
out vec4 outColor;
uniform sampler2DArray samplerTex;
uniform int sliderR;
uniform int sliderG;
uniform int sliderB;
void main()
{
// newcolor just shows you how to pass values through the shader stages
//outColor = vec4(newColor, 1.0f);
float texDataR = texture(samplerTex, vec3(outTexCoords, float(sliderR))).x;
float texDataG = texture(samplerTex, vec3(outTexCoords, float(sliderG))).x;
float texDataB = texture(samplerTex, vec3(outTexCoords, float(sliderB))).x;
outColor = vec4(texDataR * 100.0f, texDataG * 100.0f, texDataB * 100.0f, 1.0f);
}
"""
shader = OpenGL.GL.shaders.compileProgram(
OpenGL.GL.shaders.compileShader(vertex_shader, GL_VERTEX_SHADER),
OpenGL.GL.shaders.compileShader(fragment_shader, GL_FRAGMENT_SHADER))
compute_shader = """
#version 430
layout(local_size_x = 32, local_size_y = 32) in;
layout(binding= 0, r8ui) uniform uimage2DArray imageArray;
layout(binding= 1, rgba32f) uniform image2D outputImage;
void main()
{
uvec2 pix = gl_GlobalInvocationID.xy;
ivec3 imSize = imageSize(imageArray);
float sumPixel = 0.0f;
if (pix.x < imSize.x && pix.y < imSize.y)
{
for (int z = 0; z < imSize.z; z++)
{
sumPixel += float(imageLoad(imageArray, ivec3(pix, z)).z);
}
}
imageStore(outputImage, ivec2(pix), vec4(sumPixel, sumPixel / float(imSize.z), 69.0f, 8008135.0f));
}
"""
computeShader = OpenGL.GL.shaders.compileProgram(
OpenGL.GL.shaders.compileShader(compute_shader, GL_COMPUTE_SHADER))
VAO = glGenVertexArrays(1)
glBindVertexArray(VAO)
VBO = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, VBO)
glBufferData(GL_ARRAY_BUFFER, 128, quad, GL_STATIC_DRAW)
EBO = glGenBuffers(1)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO)
glBufferData(GL_ELEMENT_ARRAY_BUFFER, 24, indices, GL_STATIC_DRAW)
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 32, ctypes.c_void_p(0))
glEnableVertexAttribArray(0)
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 32, ctypes.c_void_p(12))
glEnableVertexAttribArray(1)
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 32, ctypes.c_void_p(24))
glEnableVertexAttribArray(2)
sliderR_loc = glGetUniformLocation(shader, "sliderR")
sliderG_loc = glGetUniformLocation(shader, "sliderG")
sliderB_loc = glGetUniformLocation(shader, "sliderB")
images, lambdas = get_data("D:\data\hysperspectral\snapscan_data_png")
#image = Image.open("./maybotDance.JPG")
#for index, image in enumerate(images):
numberOfImages = len(images)
#print(numberOfImages)
height, width = images[0].shape[0:2]
# GENERATE TEXTURES
hyperspectralDataTexture = createTexture(GL_TEXTURE_2D_ARRAY, GL_R8, 1,
width, height, numberOfImages,
GL_LINEAR, GL_LINEAR)
outputTexture = createTexture(GL_TEXTURE_2D, GL_RGBA32F, 1, width, height,
1, GL_LINEAR, GL_LINEAR)
#img_data = numpy.array(list(image.getdata()), numpy.uint8)
#print(width)
#print(height)
#print(images[0])
# Allocate the immutable GPU memory storage -more efficient than mutable memory if you are not going to change image size after creation
glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
glPixelStorei(GL_UNPACK_ROW_LENGTH, width)
# fill each image in the array with the same img_data
for i in range(numberOfImages):
#cv2.imshow('image', images[i]*1000.0)
#cv2.waitKey(0)
#print(images[i].strides)
img_data = np.array(images[i].data, np.uint8)
#print(img_data.shape[0:2])
glTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, i, width, height, 1,
GL_RED, GL_UNSIGNED_BYTE, img_data)
#cv2.destroyAllWindows()
#print("reached here")
glClearColor(0.2, 0.3, 0.2, 1.0)
sliderRValue = 0
sliderGValue = 0
sliderBValue = 0
while not glfw.window_should_close(window):
glfw.poll_events()
impl.process_inputs()
imgui.new_frame()
glUseProgram(shader)
w, h = glfw.get_framebuffer_size(window)
glViewport(0, 0, int(w / 2), h)
glClear(GL_COLOR_BUFFER_BIT)
glUniform1i(sliderR_loc, sliderRValue)
glUniform1i(sliderG_loc, sliderGValue)
glUniform1i(sliderB_loc, 50)
#glPolygonMode(GL_FRONT_AND_BACK, GL_LINE );
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, None)
glUniform1i(sliderB_loc, sliderBValue)
glViewport(int(w / 2), 0, int(w / 2), h)
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, None)
imgui.begin("My first imgui success!", True)
changedR, sliderRValue = imgui.slider_int("sliceR",
sliderRValue,
min_value=0,
max_value=numberOfImages)
changedG, sliderGValue = imgui.slider_int("sliceG",
sliderGValue,
min_value=0,
max_value=numberOfImages)
changedB, sliderBValue = imgui.slider_int("sliceB",
sliderBValue,
min_value=0,
max_value=numberOfImages)
if imgui.button("do some compute"):
do_some_compute(computeShader, hyperspectralDataTexture,
outputTexture, width, height)
if imgui.button("get memory back"):
read_texture_memory(outputTexture, width, height)
imgui.end()
imgui.render()
impl.render(imgui.get_draw_data())
glfw.swap_buffers(window)
glfw.terminate()
def main():
# initialize glfw
if not glfw.init():
return
w_width, w_height = 1280, 720
aspect_ratio = w_width / w_height
window = glfw.create_window(w_width, w_height, "My OpenGL window", None,
None)
if not window:
glfw.terminate()
return
glfw.make_context_current(window)
glfw.set_window_size_callback(window, window_resize)
glfw.set_cursor_pos_callback(window, cursor_pos_callback)
glfw.set_mouse_button_callback(window, mouse_button_callback)
# positions
cube = [
-0.5, -0.5, 0.5, 0.5, -0.5, 0.5, 0.5, 0.5, 0.5, -0.5, 0.5, 0.5, -0.5,
-0.5, -0.5, 0.5, -0.5, -0.5, 0.5, 0.5, -0.5, -0.5, 0.5, -0.5, 0.5,
-0.5, -0.5, 0.5, 0.5, -0.5, 0.5, 0.5, 0.5, 0.5, -0.5, 0.5, -0.5, 0.5,
-0.5, -0.5, -0.5, -0.5, -0.5, -0.5, 0.5, -0.5, 0.5, 0.5, -0.5, -0.5,
-0.5, 0.5, -0.5, -0.5, 0.5, -0.5, 0.5, -0.5, -0.5, 0.5, 0.5, 0.5, -0.5,
-0.5, 0.5, -0.5, -0.5, 0.5, 0.5, 0.5, 0.5, 0.5
]
cube = numpy.array(cube, dtype=numpy.float32)
indices = [
0, 1, 2, 2, 3, 0, 4, 5, 6, 6, 7, 4, 8, 9, 10, 10, 11, 8, 12, 13, 14,
14, 15, 12, 16, 17, 18, 18, 19, 16, 20, 21, 22, 22, 23, 20
]
indices = numpy.array(indices, dtype=numpy.uint32)
vertex_shader = """
#version 330
in layout(location = 0) vec3 position;
uniform mat4 vp;
uniform mat4 model;
void main()
{
gl_Position = vp * model * vec4(position, 1.0f);
}
"""
fragment_shader = """
#version 330
out vec4 outColor;
uniform vec3 color;
void main()
{
outColor = vec4(color, 1.0);
}
"""
shader = OpenGL.GL.shaders.compileProgram(
OpenGL.GL.shaders.compileShader(vertex_shader, GL_VERTEX_SHADER),
OpenGL.GL.shaders.compileShader(fragment_shader, GL_FRAGMENT_SHADER))
# vertex buffer object and element buffer object
VBO = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, VBO)
glBufferData(GL_ARRAY_BUFFER, cube.itemsize * len(cube), cube,
GL_STATIC_DRAW)
EBO = glGenBuffers(1)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO)
glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.itemsize * len(indices),
indices, GL_STATIC_DRAW)
# position
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, cube.itemsize * 3,
ctypes.c_void_p(0))
glEnableVertexAttribArray(0)
######################################################################################
# picking texture and a frame buffer object
pick_texture = glGenTextures(1)
glBindTexture(GL_TEXTURE_2D, pick_texture)
FBO = glGenFramebuffers(1)
glBindFramebuffer(GL_FRAMEBUFFER, FBO)
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 1280, 720, 0, GL_RGB, GL_FLOAT,
None)
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
pick_texture, 0)
glBindFramebuffer(GL_FRAMEBUFFER, 0)
glBindTexture(GL_TEXTURE_2D, 0)
######################################################################################
glUseProgram(shader)
glEnable(GL_DEPTH_TEST)
view = matrix44.create_from_translation(Vector3([0.0, 0.0, -4.0]))
projection = matrix44.create_perspective_projection_matrix(
45.0, aspect_ratio, 0.1, 100.0)
vp = matrix44.multiply(view, projection)
vp_loc = glGetUniformLocation(shader, "vp")
model_loc = glGetUniformLocation(shader, "model")
color_loc = glGetUniformLocation(shader, "color")
cube_positions = [(-2.0, 0.0, 0.0), (0.0, 0.0, 0.0), (2.0, 0.0, 0.0)]
cube_colors = [(1.0, 0.0, 0.0), (1.0, 0.0, 0.0), (1.0, 0.0, 0.0)]
pick_colors = [(1.0, 0.0, 0.0), (0.0, 1.0, 0.0), (0.0, 0.0, 1.0)]
glUniformMatrix4fv(vp_loc, 1, GL_FALSE, vp)
while not glfw.window_should_close(window):
glfw.poll_events()
glClearColor(0.2, 0.3, 0.2, 1.0)
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
rot_y = Matrix44.from_y_rotation(glfw.get_time() * 2)
# draw to the default frame buffer
for i in range(len(cube_positions)):
model = matrix44.create_from_translation(cube_positions[i])
glUniform3fv(color_loc, 1, cube_colors[i])
if i == 0:
if red_rot:
glUniformMatrix4fv(model_loc, 1, GL_FALSE, rot_y * model)
else:
glUniformMatrix4fv(model_loc, 1, GL_FALSE, model)
elif i == 1:
if green_rot:
glUniformMatrix4fv(model_loc, 1, GL_FALSE, rot_y * model)
else:
glUniformMatrix4fv(model_loc, 1, GL_FALSE, model)
else:
if blue_rot:
glUniformMatrix4fv(model_loc, 1, GL_FALSE, rot_y * model)
else:
glUniformMatrix4fv(model_loc, 1, GL_FALSE, model)
glDrawElements(GL_TRIANGLES, len(indices), GL_UNSIGNED_INT, None)
# draw to the custom frame buffer object
glBindFramebuffer(GL_FRAMEBUFFER, FBO)
glClearColor(0.0, 0.0, 0.0, 1.0)
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
for i in range(len(cube_positions)):
pick_model = matrix44.create_from_translation(cube_positions[i])
glUniform3fv(color_loc, 1, pick_colors[i])
glUniformMatrix4fv(model_loc, 1, GL_FALSE, pick_model)
glDrawElements(GL_TRIANGLES, len(indices), GL_UNSIGNED_INT, None)
if pick:
picker()
glBindFramebuffer(GL_FRAMEBUFFER, 0)
glfw.swap_buffers(window)
glfw.terminate()
def main():
if len(sys.argv) < 2:
print('I need a path to the project\'s root')
return 1
project_path = Path(sys.argv[1])
if not os.path.isdir(project_path):
print('Invalid path')
return 1
project_file = project_path / 'project.plik'
if os.path.isfile(project_file):
printf(HTML(f'<gray>Found project file at {project_file}</gray>'))
# Init graphics
imgui.create_context()
window = _glfw_init(500, 1000)
renderer = GlfwRenderer(window)
__main_locals_marker = None
def on_glfw_key(window, key, scancode, action, mods):
renderer.keyboard_callback(window, key, scancode, action, mods)
if action == glfw.RELEASE:
if key in (glfw.KEY_PAUSE, glfw.KEY_SCROLL_LOCK):
# Pretty slow I assume, but reliable
frame = inspect.currentframe()
while frame:
if '__main_locals_marker' in frame.f_locals:
break
frame = frame.f_back
ipshell(local_ns=frame.f_locals)
# Need to set this after creating the renderer because by default it does its own hooks
glfw.set_key_callback(window, on_glfw_key)
# TODO
state = State()
state.project_path = project_path
state.project_file = project_file
app.prompt.start(state)
running = True
while not glfw.window_should_close(window) and running:
glfw.poll_events()
renderer.process_inputs()
# TODO Render only when any events are detected to lower CPU usage
imgui.new_frame()
imgui.show_test_window()
# state.window_width, state.window_height = glfw.get_window_size(window)
# TODO Just set the font at the beginning!
# with imgui.font(font):
running = app.prompt.process_next_entry(state)
gl.glClearColor(.1, .1, .1, .1)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
imgui.render()
renderer.render(imgui.get_draw_data())
glfw.swap_buffers(window)
renderer.shutdown()
glfw.terminate()
def main():
# initialize glfw
if not glfw.init():
return
screen_width = 800
screen_height = 600
window = glfw.create_window(screen_width, screen_height, "LearnOpenGL",
None, None)
if not window:
glfw.terminate()
return
glfw.make_context_current(window)
vertices = [
-0.5,
-0.5,
-0.5,
0.0,
0.0,
1.0,
0.5,
-0.5,
-0.5,
1.0,
0.0,
1.0,
0.5,
0.5,
-0.5,
1.0,
1.0,
1.0,
0.5,
0.5,
-0.5,
1.0,
1.0,
1.0,
-0.5,
0.5,
-0.5,
0.0,
1.0,
1.0,
-0.5,
-0.5,
-0.5,
0.0,
0.0,
1.0,
-0.5,
-0.5,
0.5,
0.0,
0.0,
1.0,
0.5,
-0.5,
0.5,
1.0,
0.0,
1.0,
0.5,
0.5,
0.5,
1.0,
1.0,
1.0,
0.5,
0.5,
0.5,
1.0,
1.0,
1.0,
-0.5,
0.5,
0.5,
0.0,
1.0,
1.0,
-0.5,
-0.5,
0.5,
0.0,
0.0,
1.0,
-0.5,
0.5,
0.5,
1.0,
0.0,
1.0,
-0.5,
0.5,
-0.5,
1.0,
1.0,
1.0,
-0.5,
-0.5,
-0.5,
0.0,
1.0,
1.0,
-0.5,
-0.5,
-0.5,
0.0,
1.0,
1.0,
-0.5,
-0.5,
0.5,
0.0,
0.0,
1.0,
-0.5,
0.5,
0.5,
1.0,
0.0,
1.0,
0.5,
0.5,
0.5,
1.0,
0.0,
1.0,
0.5,
0.5,
-0.5,
1.0,
1.0,
1.0,
0.5,
-0.5,
-0.5,
0.0,
1.0,
1.0,
0.5,
-0.5,
-0.5,
0.0,
1.0,
1.0,
0.5,
-0.5,
0.5,
0.0,
0.0,
1.0,
0.5,
0.5,
0.5,
1.0,
0.0,
1.0,
-0.5,
-0.5,
-0.5,
0.0,
1.0,
1.0,
0.5,
-0.5,
-0.5,
1.0,
1.0,
1.0,
0.5,
-0.5,
0.5,
1.0,
0.0,
1.0,
0.5,
-0.5,
0.5,
1.0,
0.0,
1.0,
-0.5,
-0.5,
0.5,
0.0,
0.0,
1.0,
-0.5,
-0.5,
-0.5,
0.0,
1.0,
1.0,
-0.5,
0.5,
-0.5,
0.0,
1.0,
1.0,
0.5,
0.5,
-0.5,
1.0,
1.0,
1.0,
0.5,
0.5,
0.5,
1.0,
0.0,
1.0,
0.5,
0.5,
0.5,
1.0,
0.0,
1.0,
-0.5,
0.5,
0.5,
0.0,
0.0,
1.0,
-0.5,
0.5,
-0.5,
0.0,
1.0,
1.0,
]
vertices = np.array(vertices, dtype=np.float32)
view = glm.mat4(1.0)
view = glm.translate(view, glm.vec3(0.0, 0.0, -3.0))
projection = glm.perspective(glm.radians(45.0),
screen_width / screen_height, 0.1, 100.0)
vertex_shader = """
#version 330 core
layout (location = 0) in vec3 aPos; // the position variable has attribute position 0
layout (location = 1) in vec3 aColor; // the color variable has attribute position 1
out vec3 ourColor; // output a color to the fragment shader
uniform mat4 model;
uniform mat4 view;
uniform mat4 projection;
void main()
{
gl_Position = projection * view * model * vec4(aPos, 1.0);
ourColor = aColor; // set ourColor to the input color we got from the vertex data
}
"""
fragment_shader = """
#version 330 core
out vec4 FragColor;
in vec3 ourColor;
void main()
{
FragColor = vec4(ourColor, 1.0);
}
"""
shader = OpenGL.GL.shaders.compileProgram(
OpenGL.GL.shaders.compileShader(vertex_shader, GL_VERTEX_SHADER),
OpenGL.GL.shaders.compileShader(fragment_shader, GL_FRAGMENT_SHADER))
VAO = glGenVertexArrays(1)
VBO = glGenBuffers(
1) # vertex buffer object, which stores vertices in the GPU's memory.
glBindVertexArray(VAO)
glBindBuffer(GL_ARRAY_BUFFER, VBO) # now, all calls will configure VBO
glBufferData(GL_ARRAY_BUFFER, vertices.nbytes, vertices,
GL_STATIC_DRAW) # copy user-defined data into VBO
# position attribute
glVertexAttribPointer(0, 3, GL_FLOAT,
GL_FALSE, 6 * np.dtype(np.float32).itemsize,
ctypes.c_void_p(0))
glEnableVertexAttribArray(0)
# color attribute
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE,
6 * np.dtype(np.float32).itemsize,
ctypes.c_void_p(3 * np.dtype(np.float32).itemsize))
glEnableVertexAttribArray(1)
glBindBuffer(GL_ARRAY_BUFFER, 0)
glBindVertexArray(0)
glfw.set_framebuffer_size_callback(window, framebuffer_size_callback)
glEnable(GL_DEPTH_TEST)
# render loop
while not glfw.window_should_close(window):
# input
process_input(window)
# rendering commands here
glClearColor(0.2, 0.3, 0.3, 1.0) # state-setting function
glClear(GL_COLOR_BUFFER_BIT
| GL_DEPTH_BUFFER_BIT) # state-using function
# render triangle
glUseProgram(shader)
model = glm.mat4(1.0)
model = glm.rotate(model, glm.radians(float(glfw.get_time()) * 50.0),
glm.vec3(0.5, 1.0, 0.0))
modelLoc = glGetUniformLocation(shader, "model")
glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm.value_ptr(model))
viewLoc = glGetUniformLocation(shader, "view")
glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm.value_ptr(view))
projectionLoc = glGetUniformLocation(shader, "projection")
glUniformMatrix4fv(projectionLoc, 1, GL_FALSE,
glm.value_ptr(projection))
glBindVertexArray(VAO)
glDrawArrays(GL_TRIANGLES, 0, 36)
# check and call events and swap the buffers
glfw.swap_buffers(window)
glfw.poll_events()
glfw.terminate()
def main():
# Initialize GLFW and open a window
if not opengl_init():
return
# Enable key events
glfw.set_input_mode(window, glfw.STICKY_KEYS, GL_TRUE)
glfw.set_cursor_pos(window, 1024 / 2, 768 / 2)
# Set opengl clear color to something other than red (color used by the fragment shader)
glClearColor(0.0, 0.0, 0.4, 0.0)
# Enable depth test
glEnable(GL_DEPTH_TEST)
# Accept fragment if it closer to the camera than the former one
glDepthFunc(GL_LESS)
# Cull triangles which normal is not towards the camera
glEnable(GL_CULL_FACE)
vertex_array_id = glGenVertexArrays(1)
glBindVertexArray(vertex_array_id)
# Create and compile our GLSL program from the shaders
program_id = common.LoadShaders(
".\\shaders\\Tutorial7\\TransformVertexShader.vertexshader",
".\\shaders\\Tutorial7\\TextureFragmentShader.fragmentshader")
# Get a handle for our "MVP" uniform
matrix_id = glGetUniformLocation(program_id, "MVP")
# Load the texture
texture = load_image(".\\content\\uvmap.bmp")
# Get a handle for our "myTextureSampler" uniform
texture_id = glGetUniformLocation(program_id, "myTextureSampler")
# Read our OBJ file
vertices, faces, uvs, normals, colors = objloader.load(
".\\content\\cube.obj")
vertex_data, uv_data, normal_data = objloader.process_obj(
vertices, faces, uvs, normals, colors)
# Our OBJ loader uses Python lists, convert to ctype arrays before sending to OpenGL
vertex_data = objloader.generate_2d_ctypes(vertex_data)
uv_data = objloader.generate_2d_ctypes(uv_data)
# Load OBJ in to a VBO
vertex_buffer = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer)
glBufferData(GL_ARRAY_BUFFER,
len(vertex_data) * 4 * 3, vertex_data, GL_STATIC_DRAW)
uv_buffer = glGenBuffers(1)
array_type = GLfloat * len(uv_data)
glBindBuffer(GL_ARRAY_BUFFER, uv_buffer)
glBufferData(GL_ARRAY_BUFFER,
len(uv_data) * 4 * 2, uv_data, GL_STATIC_DRAW)
# vsync and glfw do not play nice. when vsync is enabled mouse movement is jittery.
common.disable_vsyc()
while glfw.get_key(
window, glfw.KEY_ESCAPE
) != glfw.PRESS and not glfw.window_should_close(window):
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
glUseProgram(program_id)
controls.computeMatricesFromInputs(window)
ProjectionMatrix = controls.getProjectionMatrix()
ViewMatrix = controls.getViewMatrix()
ModelMatrix = mat4.identity()
mvp = ProjectionMatrix * ViewMatrix * ModelMatrix
# Send our transformation to the currently bound shader,
# in the "MVP" uniform
glUniformMatrix4fv(matrix_id, 1, GL_FALSE, mvp.data)
# Bind our texture in Texture Unit 0
glActiveTexture(GL_TEXTURE0)
glBindTexture(GL_TEXTURE_2D, texture)
# Set our "myTextureSampler" sampler to user Texture Unit 0
glUniform1i(texture_id, 0)
#1rst attribute buffer : vertices
glEnableVertexAttribArray(0)
glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer)
glVertexAttribPointer(
0, # attribute 0. No particular reason for 0, but must match the layout in the shader.
3, # len(vertex_data)
GL_FLOAT, # type
GL_FALSE, # ormalized?
0, # stride
null # array buffer offset (c_type == void*)
)
# 2nd attribute buffer : colors
glEnableVertexAttribArray(1)
glBindBuffer(GL_ARRAY_BUFFER, uv_buffer)
glVertexAttribPointer(
1, # attribute 1. No particular reason for 1, but must match the layout in the shader.
2, # len(vertex_data)
GL_FLOAT, # type
GL_FALSE, # ormalized?
0, # stride
null # array buffer offset (c_type == void*)
)
# Draw the triangles, vertex data now contains individual vertices
# so use array length
glDrawArrays(GL_TRIANGLES, 0, len(vertex_data))
# Not strictly necessary because we only have
glDisableVertexAttribArray(0)
glDisableVertexAttribArray(1)
# Swap front and back buffers
glfw.swap_buffers(window)
# Poll for and process events
glfw.poll_events()
# !Note braces around vertex_buffer and uv_buffer.
# glDeleteBuffers expects a list of buffers to delete
glDeleteBuffers(1, [vertex_buffer])
glDeleteBuffers(1, [uv_buffer])
glDeleteProgram(program_id)
glDeleteTextures([texture_id])
glDeleteVertexArrays(1, [vertex_array_id])
glfw.terminate()
def main2():
img = cv2.imread('img.jpg', cv2.IMREAD_COLOR)
# cv2.imwrite("img.jpg", img)
img = cv2.resize(img, (2305, 1297))
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
(height, width, channels) = img.shape
# Initialize the library
if not glfw.init():
return
# Create a windowed mode window and its OpenGL context
window = glfw.create_window(width, height, "OpenCV", None, None)
if not window:
glfw.terminate()
return
# Make the window's context current
glfw.make_context_current(window)
fullscreen_quad = Quad()
quad = Quad(width=8, height=5, center=False)
fullscreen_shader = Shader()
fullscreen_shader.set_shader(vert='canvas.vert', frag='canvas.frag')
quad_shader = Shader()
quad_shader.set_shader(vert='quad.vert', frag='quad.frag')
fullscreen_texture = Texture()
quad_texture = Texture()
quad_texture.set_texture('D:/Documents/projects/PyTools/PyTools/inner_chessboard.jpg')
criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001)
objp = np.zeros((6 * 9, 3), np.float32)
objp[:, :2] = np.mgrid[0:9, 0:6].T.reshape(-1, 2)
axis = np.float32([[3, 0, 0], [0, 3, 0], [0, 0, -3]]).reshape(-1, 3)
objp = np.array([
objp[0],
objp[8],
objp[45],
objp[53]
])
projection = projection_pixel_3xl(width, height)
view = pyrr.matrix44.create_look_at(np.array([-20,0,-10]), np.array([0,0,0]), np.array([0,1,0]))
model = pyrr.matrix44.create_identity()
ret, corners = cv2.findChessboardCorners(gray, (9, 6), None)
corners = np.array([
corners[0],
corners[8],
corners[45],
corners[53]
])
if ret:
corners2 = cv2.cornerSubPix(gray, corners, (11, 11), (-1, -1), criteria)
# Find the rotation and translation vectors.
ret, rvecs, tvecs = cv2.solvePnP(objp, corners2, PIXEL_3_XL_CAMERA_MATRIX, None)
# convert rvecs and tvecs
if ret:
#view = view_matrix_from_rvec_tvec(rvec=rvecs, tvec=tvecs)
print(projection)
print(view)
# project 3D points to image plane
imgpts, jac = cv2.projectPoints(axis, rvecs, tvecs, PIXEL_3_XL_CAMERA_MATRIX, None)
img = draw(img, corners2, imgpts)
cv2.flip(img, 0, img)
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img = np.true_divide(img, 255.0)
while not glfw.window_should_close(window):
# fullscreen
fullscreen_texture.set_texture_from_buffer(img)
fullscreen_shader.use_shader()
glActiveTexture(GL_TEXTURE0)
fullscreen_texture.use_texture()
glUniform1i(glGetUniformLocation(fullscreen_shader.programId, "draw_texture"), 0)
fullscreen_quad.draw()
# quad
quad_shader.use_shader()
glActiveTexture(GL_TEXTURE0)
quad_texture.use_texture()
glUniform1i(glGetUniformLocation(quad_shader.programId, "draw_texture"), 0)
glUniformMatrix4fv(glGetUniformLocation(quad_shader.programId, "P"), 1, GL_FALSE, projection)
glUniformMatrix4fv(glGetUniformLocation(quad_shader.programId, "V"), 1, GL_FALSE, view)
glUniformMatrix4fv(glGetUniformLocation(quad_shader.programId, "M"), 1, GL_FALSE, model)
quad.draw()
# Swap front and back buffers
glfw.swap_buffers(window)
# Poll for and process events
glfw.poll_events()
glfw.terminate()
def loop_once(self):
self.render()
# Swap front and back buffers
glfw.swap_buffers(self.window)
# Poll for and process events
glfw.poll_events()
def main():
glfw.init()
glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 3)
glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3)
glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
window = glfw.create_window(800, 600, "LearnOpenGL", None, None)
if not window:
print("Window Creation failed!")
glfw.terminate()
glfw.make_context_current(window)
glfw.set_window_size_callback(window, on_resize)
shader = Shader(CURDIR / 'shaders/4.1.texture.vs',
CURDIR / 'shaders/4.1.texture.fs')
shader_mix = Shader(CURDIR / 'shaders/4.1.texture.vs',
CURDIR / 'shaders/4.1.texture_mix.fs')
vertices = [
# positions colors tex_coords
0.5,
0.5,
0.0,
1.0,
0.0,
0.0,
1.0,
1.0, # top right
0.5,
-0.5,
0.0,
0.0,
1.0,
0.0,
1.0,
0.0, # bottom right
-0.5,
-0.5,
0.0,
0.0,
0.0,
1.0,
0.0,
0.0, # bottom left
-0.5,
0.5,
0.0,
1.0,
1.0,
0.0,
0.0,
1.0, # top left
]
vertices = (c_float * len(vertices))(*vertices)
indices = [0, 1, 3, 1, 2, 3]
indices = (c_uint * len(indices))(*indices)
vao = gl.glGenVertexArrays(1)
gl.glBindVertexArray(vao)
vbo = gl.glGenBuffers(1)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, vbo)
gl.glBufferData(gl.GL_ARRAY_BUFFER, sizeof(vertices), vertices,
gl.GL_STATIC_DRAW)
ebo = gl.glGenBuffers(1)
gl.glBindBuffer(gl.GL_ELEMENT_ARRAY_BUFFER, ebo)
gl.glBufferData(gl.GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices,
gl.GL_STATIC_DRAW)
gl.glVertexAttribPointer(0, 3, gl.GL_FLOAT, gl.GL_FALSE,
8 * sizeof(c_float), c_void_p(0))
gl.glEnableVertexAttribArray(0)
gl.glVertexAttribPointer(1, 3, gl.GL_FLOAT,
gl.GL_FALSE, 8 * sizeof(c_float),
c_void_p(3 * sizeof(c_float)))
gl.glEnableVertexAttribArray(1)
gl.glVertexAttribPointer(2, 2, gl.GL_FLOAT,
gl.GL_FALSE, 8 * sizeof(c_float),
c_void_p(6 * sizeof(c_float)))
gl.glEnableVertexAttribArray(2)
# -- load texture
texture = gl.glGenTextures(1)
gl.glBindTexture(gl.GL_TEXTURE_2D, texture)
# -- texture wrapping
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S, gl.GL_REPEAT)
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T, gl.GL_REPEAT)
# -- texture filterting
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER,
gl.GL_LINEAR_MIPMAP_LINEAR)
gl.glTexParameter(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR)
img = Image.open(Tex('container.jpg'))
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGB, img.width, img.height, 0,
gl.GL_RGB, gl.GL_UNSIGNED_BYTE, img.tobytes())
gl.glGenerateMipmap(gl.GL_TEXTURE_2D)
while not glfw.window_should_close(window):
process_input(window)
gl.glClearColor(.2, .3, .3, 1.0)
gl.glClear(gl.GL_COLOR_BUFFER_BIT)
gl.glBindTexture(gl.GL_TEXTURE_2D, texture)
shader.use()
# -- uncomment to see mixture of vertex color and texture color
# shader_mix.use()
gl.glBindVertexArray(vao)
gl.glDrawElements(gl.GL_TRIANGLES, 6, gl.GL_UNSIGNED_INT, c_void_p(0))
glfw.poll_events()
glfw.swap_buffers(window)
gl.glDeleteVertexArrays(1, id(vao))
gl.glDeleteBuffers(1, id(vbo))
gl.glDeleteBuffers(1, id(ebo))
glfw.terminate()
def visualize(shapes_list):
"""
Displays the 3D shape within the visualization window.
----------------------------
Args:
shapes_list (obj: 'list' of obj: 'Shape'): The list of shapes
"""
global xrot, yrot, shapes, vertices, indices
# create window to render 3d mesh
window = create_window()
InitGL(1280, 720)
shapes = shapes_list
vertices = np.array(shapes[i].vertices)
indices = np.array(shapes[i].faces)
# set background color of window
glClearColor(0.9, 0.9, 0.9, 1)
# the main application loop
while not glfw.window_should_close(window):
# create vertices and indices from imported data
glfw.poll_events()
width, height = glfw.get_framebuffer_size(window)
glViewport(0, 0, width, height)
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
glMatrixMode(GL_PROJECTION)
glLoadIdentity()
glFrustum(-1.0, 1.0, -1.0, 1.0, 2.5, 20.0)
glMatrixMode(GL_MODELVIEW)
glPushMatrix()
glEnable(GL_POLYGON_OFFSET_FILL)
glPolygonOffset(1.0, 2)
# Translate based on the xas, yas, and z values.
glTranslatef(xas, yas, z)
glRotatef(xrot, 1.0, 0.0, 0.0) # Rotate On The X Axis
glRotatef(yrot, 0.0, 1.0, 0.0) # Rotate On The Y Axis
for index in indices:
# Allows handling of quads and triangles
glBegin(GL_TRIANGLES)
glColor3f(0.5, 0.5, 0.5)
for number in index[1:]:
glVertex3f(vertices[number][0], vertices[number][1],
vertices[number][2])
glEnd()
if DRAW_EDGES:
for index in indices:
# Draws the lines for the vertices
glBegin(GL_LINES)
glColor3f(0.0, 0.0, 0.0)
for number in index[1:]:
glVertex3f(vertices[number][0], vertices[number][1],
vertices[number][2])
glEnd()
glDisable(GL_POLYGON_OFFSET_FILL)
glPopMatrix()
# Add the speed to the rotation value, is increased by keypressing.
xrot += xspeed
yrot += yspeed
glfw.swap_buffers(window)
# terminate glfw, free up allocated resources
print(saves)
glfw.terminate()
