def __init__(self, width, height): """ :param width and height: size of the window in pixels. """ pyglet.window.Window.__init__(self, width, height, caption="Wythoff Explorer", resizable=True, visible=False, vsync=False) self._start_time = time.clock() self._last = self._now = self._start_time self._frame_count = 0 # count number of frames rendered so far self.shaderA = Shader( ["./glsl_wythoff/wythoff.vert"], ["./glsl_wythoff/common.frag", "./glsl_wythoff/BufferA.frag"]) self.shaderB = Shader( ["./glsl_wythoff/wythoff.vert"], ["./glsl_wythoff/common.frag", "./glsl_wythoff/main.frag"]) self.font_texture = create_image_texture(FONT_TEXTURE) self.noise_texture = create_image_texture(NOISE_TEXTURE) self.iChannel0 = pyglet.image.Texture.create_for_size( gl.GL_TEXTURE_2D, width, height, gl.GL_RGBA32F_ARB) gl.glActiveTexture(gl.GL_TEXTURE0) gl.glBindTexture(self.iChannel0.target, self.iChannel0.id) gl.glActiveTexture(gl.GL_TEXTURE1) gl.glBindTexture(gl.GL_TEXTURE_2D, self.font_texture) gl.glActiveTexture(gl.GL_TEXTURE2) gl.glBindTexture(gl.GL_TEXTURE_2D, self.noise_texture) with FrameBuffer() as self.bufferA: self.bufferA.attach_texture(self.iChannel0) # initialize the shaders with self.shaderA: self.shaderA.vertex_attrib("position", [-1, -1, 1, -1, -1, 1, 1, 1]) self.shaderA.uniformf("iResolution", width, height, 0.0) self.shaderA.uniformf("iTime", 0.0) self.shaderA.uniformf("iMouse", 0.0, 0.0, 0.0, 0.0) self.shaderA.uniformi("iChannel0", 0) self.shaderA.uniformi("iChannel1", 1) self.shaderA.uniformi("iChannel2", 2) self.shaderA.uniformf("iDate", *get_idate()) self.shaderA.uniformf("iTimeDelta", 0) with self.shaderB: self.shaderB.vertex_attrib("position", [-1, -1, 1, -1, -1, 1, 1, 1]) self.shaderB.uniformf("iResolution", width, height, 0.0) self.shaderB.uniformf("iTime", 0.0) self.shaderB.uniformf("iMouse", 0.0, 0.0, 0.0, 0.0) self.shaderB.uniformi("iChannel0", 0) self.shaderB.uniformi("iChannel1", 1) self.shaderB.uniformi("iChannel2", 2) self.shaderB.uniformf("iDate", *get_idate()) self.shaderA.uniformf("iTimeDelta", 0)
def __init__(self, width, height, pattern, scale, video): """ width, height: size of the window in pixels. scale: the size of the texture is (width//scale) x (height//scale). pattern: the initial pattern. video: if non-zero then save frams from the beginning. """ pyglet.window.Window.__init__(self, width, height, caption='GrayScott Simulation', visible=False, vsync=False) # palette is used for coloring the pattern. self.pattern = pattern self.palette = np.array([(0.0, 0.0, 0.0, 0.0), (0.0, 1.0, 0.0, 0.2), (1.0, 1.0, 0.0, 0.21), (1.0, 0.0, 0.0, 0.4), (1.0, 1.0, 1.0, 0.6)]) # we use `reaction_shader` to do the computations in a backend framebuffer, # and `render_shader` to show the pattern in the frontend window buffer. self.reaction_shader = Shader('./glsl/default.vert', './glsl/reaction.frag') self.render_shader = Shader('./glsl/default.vert', './glsl/render.frag') # size of the texture. self.tex_width = width // scale self.tex_height = height // scale self.uv_texture = create_uv_texture(width // scale, height // scale) gl.glActiveTexture(gl.GL_TEXTURE0) gl.glBindTexture(self.uv_texture.target, self.uv_texture.id) # use an invisible buffer to do the computation. with FrameBuffer() as self.fbo: self.fbo.attach_texture(self.uv_texture) # why do we need this? the reason is in the 'on_mouse_drag' function. self.mouse_down = False # put all patterns in a list for iterating over them. self._species = list(SPECIES.keys()) # set the uniforms and varying attributes in the two shaders. self.init_reaction_shader() self.init_render_shader() self.frame_count = 0 self.video_on = video self.skip = 30 self.max_frames = 1000000
def main(): cam = Camera("hw2") cam.createView(Point3f(0.0, 0.0, 30.0), Vector3f(0.0, 1.0, 0.0)) cam.setNear(1) cam.setFar(1000) viewer = Viewer(cam) color_shader = Shader("vert.vs", "frag.fs") geom_shader = Shader("point_shadows_depth.vs", "point_shadows_depth.fs", "point_shadows_depth.gs") lighter_shader = Shader("light_vert.vs", "light_frag.fs") """ image = load_texture("textures/cube2.png") second_image = load_texture("textures/cube.png") """ sphere_obj = ObjLoader() sphere_obj.load_model("object_files/sphere.obj") cornell_obj = ObjLoader() cornell_obj.load_modell_cornell("object_files/cornell.obj") LighterObject = LightObject(lighter_shader, [18, 3, 0], sphere_obj, [1.0, 1.0, 3.0], True) LighterObject2 = LightObject(lighter_shader, [0, 40, 0], sphere_obj, [1.0, 1.0, 3.0], False) ShadowsObject = RenderShadows(cam, color_shader, geom_shader, [0, 0, -5], cornell_obj, None, None, LighterObject, LighterObject2) CornellObject = ShapeFromObjectFile(cam, color_shader, [0, 0, -5], cornell_obj, None, None, LighterObject, LighterObject2) viewer.add( ["Shadow", True, ShadowsObject, False, LighterObject, LighterObject2]) viewer.add( ["Cornell", True, CornellObject, False, LighterObject, LighterObject2]) viewer.add([ "Lighter1", True, LighterObject, False, LighterObject, LighterObject2 ]) viewer.add([ "Lighter2", True, LighterObject2, False, LighterObject, LighterObject2 ]) print("Press a to enable/disable lighter1 animation.") print("Press 1 and 2 to enable/disable lighters.") print("Press b to enable/disable blinn specular formula for lighters.") print("Press x and Shift +x to move in x direction.") print("Press y and Shift +y to move in y direction.") print("Press z and Shift +z to move in z direction.") glutMainLoop()
def gameLoad(eel): global current_state, setup, shaders, canvases, font, iptext current_state = GameState.MENU setup = False if shaders is None: shaders = [] for frag in shadernames: sh = Shader(b'pass.vert', frag) with sh: sh.setUniform(b'canvasTexture', (0,)) sh.setUniform(b'resolution', eel.dimensions) shaders.append(sh) if canvases is None: canvases = [Canvas(*eel.dimensions) for i in range(2)] if font is None: font = Font("Ubuntu-R.ttf") for i, v in enumerate(menu_str): menu.append(( Rectangle(20 - 10, 100 + 60*i - 40, width=600, height=50, fill=True), font.text(20, 100 + 60*i, v) )) for item in menu: item[0].setColor(20, 20, 20) iptext = font.text(20, 160, b'')
def load_shader(self, name): with open('../res/'+name+'.frag','r') as f: frag = f.read() with open('../res/'+name+'.vert','r') as f: vert = f.read() self.shaders[name] = Shader(vert=[vert],frag=[frag]) return self.shaders[name]
def __init__(self, width, height, aa): pyglet.window.Window.__init__( self, width, height, caption="Loxodromic transformation", resizable=True, visible=False, vsync=False, ) self._start_time = time.clock() self.shader = Shader(["./glsl/loxodrome.vert"], ["./glsl/loxodrome.frag"]) self.buffer = pyglet.image.get_buffer_manager().get_color_buffer() texture = create_image_texture(WOOD_TEXTURE) gl.glActiveTexture(gl.GL_TEXTURE0) gl.glBindTexture(gl.GL_TEXTURE_2D, texture) with self.shader: self.shader.vertex_attrib("position", [-1, -1, 1, -1, -1, 1, 1, 1]) self.shader.uniformf("iResolution", width, height, 0.0) self.shader.uniformf("iTime", 0.0) self.shader.uniformi("iTexture", 0) self.shader.uniformi("AA", aa)
def __init__(self): # feel free to move this up in the viewer as per other practicals self.shader = Shader(TEXTURE_VERT, TEXTURE_FRAG) # triangle and face buffers vertices = np.array(((7, 9, 0), (10, 9, 0), (10, 10, 0), (7, 10, 0)), np.float32) faces = np.array(((0, 1, 2), (0, 2, 3)), np.uint32) self.vertex_array = VertexArray( [vertices, [(0, 0), (-1, 0), (-1, -1), (0, -1)]], faces) # interactive toggles self.wrap = cycle([ GL.GL_REPEAT, GL.GL_MIRRORED_REPEAT, GL.GL_CLAMP_TO_BORDER, GL.GL_CLAMP_TO_EDGE ]) self.filter = cycle([(GL.GL_NEAREST, GL.GL_NEAREST), (GL.GL_LINEAR, GL.GL_LINEAR), (GL.GL_LINEAR, GL.GL_LINEAR_MIPMAP_LINEAR)]) self.wrap_mode, self.filter_mode = next(self.wrap), next(self.filter) # setup texture and upload it to GPU self.textures = { "CLEAR": Texture("control/arrows.png", self.wrap_mode, *self.filter_mode), "UP": Texture("control/arrowsUP.png", self.wrap_mode, *self.filter_mode), "LEFT": Texture("control/arrowsRIGHT.png", self.wrap_mode, *self.filter_mode), "RIGHT": Texture("control/arrowsLEFT.png", self.wrap_mode, *self.filter_mode) } self.texture = self.textures["CLEAR"]
def __init__(self, dash_atlas=None): self.dash_atlas = dash_atlas self.vtype = np.dtype([('a_center', 'f4', 2), ('a_texcoord', 'f4', 2)]) self.utype = np.dtype([('fg_color', 'f4', 4), ('bg_color', 'f4', 4), ('translate', 'f4', 2), ('scale', 'f4', 1), ('rotate', 'f4', 1), ('radius', 'f4', 1), ('linewidth', 'f4', 1), ('antialias', 'f4', 1), ('dash_phase', 'f4', 1), ('dash_period', 'f4', 1), ('dash_index', 'f4', 1), ('dash_caps', 'f4', 2)]) Collection.__init__(self, self.vtype, self.utype) if dash_atlas is None: self.dash_atlas = DashAtlas() else: self.dash_atlas = dash_atlas shaders = os.path.join(os.path.dirname(__file__),'shaders') vertex_shader= os.path.join( shaders, 'circles.vert') fragment_shader= os.path.join( shaders, 'circles.frag') self.shader = Shader( open(vertex_shader).read(), open(fragment_shader).read() )
def getShader( frag, seed ): with open ("shaders/basicvert.glsl", "r") as vertfile: vert = vertfile.read() with open ("shaders/noise.glsl", "r") as noisefile: noise = noisefile.read() with open ("shaders/utils.glsl", "r") as utilsfile: utils = utilsfile.read() with open ("shaders/header.glsl", "r") as headerfile: header = headerfile.read() fullfrag = header + noise + utils + frag with open( "Output/" + str( seed ) + "/" + str( seed ) + ".glsl", "w") as text_file: text_file.write( frag ) with open( "Output/" + str( seed ) + "/" + str( seed ) + "full.glsl", "w") as text_file: text_file.write( fullfrag ) shader = Shader( vert, fullfrag ) shader.bind() shader.uniformf( "iResolution", x, y ) return shader
def __init__(self, width, height, sample_rate=8, video_rate=24, antialiasing=1): pyglet.window.Window.__init__(self, width, height, caption="Mobius transformation in hyperbolic 3-space", resizable=True, visible=False, vsync=False) self._start_time = time.clock() self.shader = Shader(["./glsl/mobius.vert"], ["./glsl/helpers.frag", "./glsl/mobius.frag"]) self.apply = True self.elliptic = True self.hyperbolic = True self.video_on = False self.buffer = pyglet.image.get_buffer_manager().get_color_buffer() self.sample_rate = sample_rate self.video_rate = video_rate self.frame_count = 0 with self.shader: self.shader.vertex_attrib("position", [-1, -1, 1, -1, -1, 1, 1, 1]) self.shader.uniformf("iResolution", width, height, 0.0) self.shader.uniformf("iTime", 0.0) self.shader.uniformi("iApply", self.apply) self.shader.uniformi("iElliptic", self.elliptic) self.shader.uniformi("iHyperbolic", self.hyperbolic) self.shader.uniformf("iMobius.A", -1, 0.0) self.shader.uniformf("iMobius.B", 1, 0.0) self.shader.uniformf("iMobius.C", -1, 0.0) self.shader.uniformf("iMobius.D", -1, 0.0) self.shader.uniformi("AA", antialiasing)
def getNamedShader(vert, frag=None): vertFile, fragFile = getShaderFiles(vert, frag) vertString = open(vertFile).read() fragString = open(fragFile).read() return Shader([vertString], [fragString])
def __init__(self, dash_atlas=None): self.vtype = np.dtype([('a_position', 'f4', 2), ('a_segment', 'f4', 2), ('a_angles', 'f4', 2), ('a_tangents', 'f4', 4), ('a_texcoord', 'f4', 2)]) self.utype = np.dtype([('color', 'f4', 4), ('translate', 'f4', 2), ('scale', 'f4', 1), ('rotate', 'f4', 1), ('linewidth', 'f4', 1), ('antialias', 'f4', 1), ('linecaps', 'f4', 2), ('linejoin', 'f4', 1), ('miter_limit', 'f4', 1), ('length', 'f4', 1), ('dash_phase', 'f4', 1), ('dash_period', 'f4', 1), ('dash_index', 'f4', 1), ('dash_caps', 'f4', 2), ('closed', 'f4', 1)]) Collection.__init__(self, self.vtype, self.utype) shaders = os.path.join(os.path.dirname(__file__), 'shaders') vertex_shader = os.path.join(shaders, 'dash-lines-2D.vert') fragment_shader = os.path.join(shaders, 'dash-lines-2D.frag') #fragment_shader= os.path.join( shaders, 'test.frag') if dash_atlas is None: self.dash_atlas = DashAtlas() else: self.dash_atlas = dash_atlas self.shader = Shader( open(vertex_shader).read(), open(fragment_shader).read())
def initializeGL(self): self.cell_width = (2 * self.screen_width / len(self.game.field[0]) / self.screen_width) self.cell_height = (2 * self.screen_height / len(self.game.field) / self.screen_height) self.shader = Shader('shader.vs', 'shader.fs') self.shader.save_attr_locations(['aVertexPosition', 'aVertexTexCoord']) self.shader.save_uniform_locations(['uTexture']) self.shader.bind() GL.glEnable(GL.GL_DEPTH_TEST) GL.glClearColor(255, 255, 255, 1) GL.glViewport(0, 0, self.screen_width, self.screen_height) self.setGeometry(0, 0, self.screen_width, self.screen_height) self.set_field() self.start_spawn() self.draw_timer = Timer(self.update, consts.REDRAW_TIME) self.draw_timer.start_timer() GL.glEnable(GL.GL_BLEND) GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA)
def __init__(self, width, height, zoom): """ :param width & height: size of the main window in pixels. :param zoom: zoom factor of the scene. Keyboard control: 1. press `Enter` to save screenshots. 2. press `Esc` to exit. """ pyglet.window.Window.__init__(self, width, height, caption="Wang-Tile", resizable=True, visible=False, vsync=False) self._start_time = time.clock() self.shader = Shader(["./glsl/wang.vert"], ["./glsl/wang.frag"]) cubemap = create_cubemap_texture(CUBEMAP_IMAGES) gl.glActiveTexture(gl.GL_TEXTURE0) gl.glBindTexture(gl.GL_TEXTURE_CUBE_MAP, cubemap) with self.shader: self.shader.vertex_attrib("position", [-1, -1, 1, -1, -1, 1, 1, 1]) self.shader.uniformf("iResolution", width, height, 0.0) self.shader.uniformf("iTime", 0.0) self.shader.uniformf("zoom", zoom) self.shader.uniformi("cubemap", 0)
def __init__(self): self.vtype = np.dtype([('a_curr', 'f4', 3), ('a_texcoord', 'f4', 2)]) self.utype = np.dtype([ ('fg_color', 'f4', 4), ('length', 'f4', 1), ('linewidth', 'f4', 1), ('antialias', 'f4', 1), ('dash_phase', 'f4', 1), ('dash_period', 'f4', 1), ('dash_index', 'f4', 1), ('dash_caps', 'f4', 2) ]) Collection.__init__(self, self.vtype, self.utype) self.dash_atlas = DashAtlas() dsize = self.vbuffer._dsize a_curr = self.vbuffer.attribute('a_curr') a_texcoord = self.vbuffer.attribute('a_texcoord') a_index = self.vbuffer.attribute('a_index') a_next = VertexAttribute('a_next', a_curr.count, a_curr.gltype, a_curr.stride, a_curr.offset) a_prev = VertexAttribute('a_prev', a_curr.count, a_curr.gltype, a_curr.stride, a_curr.offset) self.attributes.extend([a_prev, a_next]) a_index.offset += 2 * dsize a_curr.offset += 2 * dsize a_texcoord.offset += 2 * dsize a_next.offset += 4 * dsize shaders = os.path.join(os.path.dirname(__file__), '.') vertex_shader = os.path.join(shaders, 'dash-lines.vert') fragment_shader = os.path.join(shaders, 'dash-lines.frag') self.shader = Shader( open(vertex_shader).read(), open(fragment_shader).read())
def __init__(self, width, height, scene, video, sample_rate, video_rate, antialiasing): pyglet.window.Window.__init__( self, width, height, caption="Mobius transformation in hyperbolic 3-space", resizable=True, visible=False, vsync=False) self._start_time = time.clock() self.shader = Shader(["./glsl/mobius.vert"], ["./glsl/mobius.frag"]) self.apply, self.elliptic, self.hyperbolic = [ int(x) for x in bin(scene)[2:].zfill(3) ] self.video_on = video self.buffer = pyglet.image.get_buffer_manager().get_color_buffer() self.sample_rate = sample_rate self.video_rate = video_rate self.frame_count = 0 if self.video_on: self.ffmpeg_pipe = self.create_new_pipe() with self.shader: self.shader.vertex_attrib("position", [-1, -1, 1, -1, -1, 1, 1, 1]) self.shader.uniformf("iResolution", width, height, 0.0) self.shader.uniformf("iTime", 0.0) self.shader.uniformi("iApply", self.apply) self.shader.uniformi("iElliptic", self.elliptic) self.shader.uniformi("iHyperbolic", self.hyperbolic) self.shader.uniformf("iMobius.A", -1, 0.0) self.shader.uniformf("iMobius.B", 1, 0.0) self.shader.uniformf("iMobius.C", -1, 0.0) self.shader.uniformf("iMobius.D", -1, 0.0) self.shader.uniformi("AA", antialiasing)
def __init__(self, width, height, pqr, AA=2): """ :param width and height: size of the window in pixels. :param pqr: Coxeter diagram of the tessellation. :param AA: antialiasing level. """ pyglet.window.Window.__init__( self, width, height, caption="Hyperbolic Honeycomb {}-{}-{}".format(*pqr), resizable=True, visible=False, vsync=False) self.pqr = pqr self._start_time = time.clock() self.shader = Shader(["./glsl/hyperbolic3d.vert"], ["./glsl/hyperbolic3d.frag"]) self.buffer = pyglet.image.get_buffer_manager().get_color_buffer() # create the texture texture = create_image_texture(IMG_PATH) gl.glActiveTexture(gl.GL_TEXTURE0) gl.glBindTexture(gl.GL_TEXTURE_2D, texture) with self.shader: self.shader.vertex_attrib("position", [-1, -1, 1, -1, -1, 1, 1, 1]) self.shader.uniformf("iResolution", self.width, self.height, 0.0) self.shader.uniformf("iTime", 0.0) self.shader.uniformi("iTexture", 0) self.shader.uniformf("pqr", *self.pqr) self.shader.uniformi("AA", AA)
def __init__(self, width, height, pqr, trunc_type, AA=2): """ :param width and height: size of the window in pixels. :param pqr: a 3-tuple of integers which specifies the Coxeter diagram of the tessellation. :param trunc_type: a 4-tuple of non-negative floats which determines the truncation type of the honeycomb. :param AA: antialiasing level. """ pyglet.window.Window.__init__(self, width, height, caption="Hyperbolic Honeycomb {}-{}-{}".format(*pqr), resizable=True, visible=False, vsync=False) self.pqr = pqr self.trunc_type = trunc_type self._start_time = time.clock() self.shader = Shader(["./glsl/hyperbolic3d.vert"], ["./glsl/hyperbolic3d.frag"]) self.buffer = pyglet.image.get_buffer_manager().get_color_buffer() with self.shader: self.shader.vertex_attrib("position", [-1, -1, 1, -1, -1, 1, 1, 1]) self.shader.uniformf("iResolution", self.width, self.height, 0.0) self.shader.uniformf("iTime", 0.0) self.shader.uniformf("iMouse", 0.0, 0.0, 0.0, 0.0) self.shader.uniformf("PQR", *self.pqr) self.shader.uniformf("truncType", *self.trunc_type) self.shader.uniformi("AA", AA)
def __init__(self, width, height): pyglet.window.Window.__init__(self, width, height, caption="Manderbrot Set", resizable=True, visible=False, vsync=False) self.shader = Shader(['./glsl/mandel.vert'], ['./glsl/mandel.frag']) with self.shader: self.shader.vertex_attrib('position', [-1, -1, 1, -1, -1, 1, 1, 1]) self.shader.vertex_attrib('texcoord', [0, 0, 1, 0, 0, 1, 1, 1])
def __init__(self): super(JuliaWindow, self).__init__(caption = 'julia', width = 512, height = 512) self.C = (-0.70176, -0.3842) shader_path = 'julia' self.shader = Shader( ' '.join(open('%s.v.glsl' % shader_path)), ' '.join(open('%s.f.glsl' % shader_path)) )
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/3.6.shader.vs', CURDIR / 'shaders/3.6.shader.fs') data = [ -0.5, -0.5, 0.0, 0.5, -0.5, 0.0, 0.0, 0.5, 0.0, ] data = (c_float * len(data))(*data) 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(data), data, gl.GL_STATIC_DRAW) # -- vertices gl.glVertexAttribPointer(0, 3, gl.GL_FLOAT, gl.GL_FALSE, 3 * sizeof(c_float), c_void_p(0)) gl.glEnableVertexAttribArray(0) while not glfw.window_should_close(window): process_input(window) gl.glClearColor(.2, .3, .3, 1.0) gl.glClear(gl.GL_COLOR_BUFFER_BIT) shader.use() gl.glBindVertexArray(vao) gl.glDrawArrays(gl.GL_TRIANGLES, 0, 3) glfw.poll_events() glfw.swap_buffers(window) gl.glDeleteVertexArrays(1, id(vao)) gl.glDeleteBuffers(1, id(vbo)) glfw.terminate()
def __init__(self, radius=0, color=(1.0, 0.0, 0.0, 0.5)): self.radius = radius self.color = color self.shader = Shader("res/shaders/grid") self.elements = [] self.generate()
def __init__(self, scene): self.batch = pyglet.graphics.Batch() self.translate = Parameter(default=Vector3(0,0,0)) self.rotate= Parameter(default=Vector3(0,0,0)) self.scale= Parameter(default=Vector3(1,1,1)) self.shader = Shader(self.vertex_shader, self.fragment_shader) scene.objects.append( self )
def __init__(self): # Setup the GLSL program with open('molgl.vert','r') as f: vert = f.readlines() with open('molgl.frag','r') as f: frag = f.readlines() self.shader = Shader(vert=vert, frag=frag) # Some parameters glEnable(GL_DEPTH_TEST) glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)
def init_shader(self): self.shader = Shader({ GL_VERTEX_SHADER: 'shaders/shader.vert', GL_GEOMETRY_SHADER: 'shaders/shader.geom', GL_FRAGMENT_SHADER: 'shaders/shader.frag' }) self.shader.create() self.shader_time = self.get_shader_time() self.freeze_time = False self.time = 0. self.logger.debug('Shader program initialized')
def setup(self): # Set up vertices and indices self.terrainVertices = np.array(self.getVertices(self.vertexCount), dtype='float32') self.terrainIndices = np.array(self.getIndices(self.vertexCount), dtype='uint32') # Setup shaders self.shader = Shader(vertex_source="shaders/terrain.vs", fragment_source="shaders/terrain.fs") self.shader.use() # Set model matrix of terrain # self.model = Matrix44.from_translation(np.array(self.position)) self.model = QMatrix4x4() self.model.scale(500.5, 1.0, 500.5) #self.model.translate(self.position) self.shader.setMat4("model", self.model) # Create Vertex Array Object self.__vao = glGenVertexArrays(1) glBindVertexArray(self.__vao) # Create Buffers and assign data bufs = glGenBuffers(2) glBindBuffer(GL_ARRAY_BUFFER, bufs[0]) glBufferData(GL_ARRAY_BUFFER, sizeof(ctypes.c_float) * len(self.terrainVertices), (ctypes.c_float * len(self.terrainVertices))(*self.terrainVertices), GL_STATIC_DRAW) glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, bufs[1]) glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(ctypes.c_uint) * len(self.terrainIndices), (ctypes.c_uint * len(self.terrainIndices))(*self.terrainIndices), GL_STATIC_DRAW) # Turn on position attribute and set its size glEnableVertexAttribArray(0) glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(ctypes.c_float), None) # Unbind buffers and VAO glBindBuffer(GL_ARRAY_BUFFER, 0) glBindVertexArray(0) # Setup textures self.colors = ReadTexture("textures/atacama_rgb3.jpg") self.rewardMap = createEmptyTexture() self.heightMap = bindHeightMap(self.heightMap.getHeightMap()) self.shader.stop()
def __init__(self): super(PlasmaWindow, self).__init__(caption='plasma', width=512, height=512) self.C1 = (.0, .0) self.C2 = (.2, .2) self.C3 = (-.2, -.2) shader_path = 'plasma' self.shader = Shader(''.join(open('%s.v.glsl' % shader_path)), ''.join(open('%s.f.glsl' % shader_path)))
def __init__(self, device): self.device = device self.renderMode = FM_WIREFRAME self.vertex_buffer = [] self.index_buffer = [] self.shader = Shader() self.camera_pos = Vector4() return
def on_key_press(self, symbol, modifiers): """Keyboard interface. """ if symbol == key.ENTER: self.save_screenshot() if symbol == key.ESCAPE: pyglet.app.exit() if symbol == key.L and (modifiers & key.LCTRL): scene_file = load() self.shader = Shader(["./glsl/fractal3d.vert"], [scene_file]) self.init_shader()
def LoadShaderFromFile(vshader_filename='', pshader_filename='', gshader_filename=''): if (vshader_filename == '' and pshader_filename == '' and gshader_filename == ''): return None vshader_buffer = OpenFileAsStringBuffer(vshader_filename) pshader_buffer = OpenFileAsStringBuffer(pshader_filename) gshader_buffer = OpenFileAsStringBuffer(gshader_filename) return Shader(vshader_buffer, pshader_buffer, gshader_buffer)