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)
