def _imposter_gen(res, vs, fs, n_row=9, dist=10):
context = mg.create_standalone_context()
vs = _read(vs)
fs = _read(fs)
program = context.program(vertex_shader=vs, fragment_shader=fs)
vao = _screen_quad(program, context)
u_campos = program['u_campos']
if "u_drawbg" in program:
program["u_drawbg"].value = False
atlas = Image.new("RGBA", (res, res))
winw, winh = int(res / n_row), int(res / n_row)
window_tex = context.texture((winw, winh), 4, dtype="f4")
frame = context.framebuffer([window_tex])
frame.use()
for pos, uv in _rotate_around(n_row, dist):
u_campos.value = pos
vao.render()
u = uv[0] * winw
v = uv[1] * winh
data = np.frombuffer(window_tex.read(), dtype="f4")
data = data.reshape((winw, winh, 4))
data = _flatten_array(data)
img = Image.fromarray(data)
atlas.paste(img, (u, v))
return atlas
def _compute_driven_generation(width, height, cs_path):
x, y, z = 1024, 1, 1
cs_args = {
'X': x,
'Y': y,
'Z': z,
'WIDTH': width,
'HEIGHT': height,
}
cs = _read(cs_path, cs_args)
context = mg.create_standalone_context()
compute_shader = context.compute_shader(cs)
in_data = np.random.uniform(0.0, 1.0, (width, height, 4))
out_data = np.zeros((width, height, 4))
in_buffer = context.buffer(in_data.astype('f4'))
in_buffer.bind_to_storage_buffer(0)
out_buffer = context.buffer(out_data.astype('f4'))
out_buffer.bind_to_storage_buffer(1)
compute_shader.run(x, y, z)
data = np.frombuffer(out_buffer.read(), dtype='f4')
data = data.reshape((height, width, 4))
return _flatten_array(data)
def _randomized_vertical_gradient(width, height):
import random
def lerp(x, y, w):
rw = 1.0 - w
r = x[0] * rw + y[0] * w
g = x[1] * rw + y[1] * w
b = x[2] * rw + y[2] * w
return r, g, b
palettes = []
for i in range(10):
v = i * 0.1 + random.random() * 0.1
palettes.append((v, v, v))
palettes[0] = (0.0, 0.0, 0.0)
palettes[9] = (1.0, 1.0, 1.0)
data = np.zeros(shape=(height, width, 4))
for x in range(width):
for y in range(height):
hr = y / height
for i in range(1, 10):
if hr < i * 0.1:
p = (hr - ((i - 1) * 0.1)) / 0.1
p0 = palettes[i - 1]
p1 = palettes[i - 0]
r, g, b = lerp(p0, p1, p)
break
data[y, x] = (r, g, b, 1.0)
return _flatten_array(data)
def _generate_screentone(width, height):
data = np.zeros(shape=(height, width, 4))
for x in range(height):
for y in range(width):
if abs((x % 4) - (y % 4)) < 0.4:
data[x, y] = (0, 0, 0, 1.0)
else:
data[x, y] = (1, 1, 1, 1.0)
return _flatten_array(data)
def paintGL(self):
if self.vao:
t = time.time() - self.start_time
self.u_time.value = t
x = math.cos(t) * +7.0
z = math.sin(t) * -7.0
self.u_campos.value = (x, 4.0, z)
self.vao.render()
self.update()
if self.is_recording:
self.frame_buffer.use()
self.vao.render()
data = self.tex.read()
data = np.frombuffer(data, dtype='f4')
data = data.reshape(self.size[1], self.size[0], 4)
data = _flatten_array(data)
self.mp4_writer.append_data(data)
def _screenspace_generation(width,
height,
vspath,
fspath,
start_time=0.0,
end_time=1.0,
frames=1,
**uniforms):
vs = _read(vspath)
fs = _read(fspath)
context = mg.create_standalone_context()
program = context.program(vertex_shader=vs, fragment_shader=fs)
vao = _screen_quad(program, context)
for k, v in uniforms.items():
if k not in program:
continue
program[k].value = v
test_texture = context.texture((width, height), 4)
test_texture.use(0)
frame_tex = context.texture((width, height), 4, dtype='f4')
frame = context.framebuffer([frame_tex])
frame.use()
u_time = {"value": 0.0}
if "u_time" in program:
u_time = program["u_time"]
span = end_time - start_time
step = span / max(float(frames), 0.0)
for t in range(int(frames)):
u_time.value = start_time + step * t
vao.render()
result_bytes = frame_tex.read()
data = np.frombuffer(result_bytes, dtype='f4')
data = data.reshape((height, width, 4))
yield _flatten_array(data)
