def setup(self):
self.wasd = pg.WASD(self, speed=8)
self.wasd.look_at((-10, 0, 0), (0, 0, 0))
# cuboids
self.context = pg.Context(pg.DirectionalLightProgram())
self.context.use_color = True
self.context.ambient_color = (0.5, 0.5, 0.5)
self.context.light_color = (0.5, 0.5, 0.5)
self.context.light_direction = pg.normalize((-1, 1, 1))
data = []
n = 16
for x in range(256):
z = random.randint(-n, n)
y = random.randint(-n, n)
cuboid = pg.Cuboid(x, x + 1, y - 0.5, y + 0.5, z - 0.5, z + 0.5)
color = pg.hex_color(random.randint(0, 0xffffff))
colors = [color] * len(cuboid.positions)
data.extend(pg.interleave(
cuboid.positions, cuboid.normals, colors))
self.context.position, self.context.normal, self.context.color = (
pg.VertexBuffer(data).slices(3, 3, 3))
# bullets
self.bullet = pg.Context(pg.DirectionalLightProgram())
self.bullet.ambient_color = (0.5, 0.5, 0.5)
self.bullet.light_color = (0.5, 0.5, 0.5)
sphere = pg.Sphere(3, 0.05, (0, 0, 0))
self.bullet.position = pg.VertexBuffer(sphere.positions)
self.bullet.normal = pg.VertexBuffer(sphere.normals)
self.bullets = []
# crosshairs
self.crosshairs = pg.Context(pg.SolidColorProgram())
self.crosshairs.position = pg.VertexBuffer(pg.Crosshairs().positions)
def __init__(self, occupied):
self.occupied = occupied
self.context = pg.Context(pg.DirectionalLightProgram())
self.context.object_color = pg.hex_color(random.choice(COLORS))
self.context.position = self.positions = pg.VertexBuffer()
self.context.normal = self.normals = pg.VertexBuffer()
self.restart()
def setup(self):
self.wasd = pg.WASD(self)
self.wasd.look_at((0, 0, 2), (0, 0, 0))
self.program = pg.DirectionalLightProgram()
self.context = pg.Context(self.program)
sphere = pg.Sphere(3, 0.5, (0, 0, 0))
self.context.position = pg.VertexBuffer(sphere.positions)
self.context.normal = pg.VertexBuffer(sphere.normals)
def setup(self):
self.font = pg.Font(self, 1, '/Library/Fonts/Arial.ttf', 24)
self.wasd = pg.WASD(self)
self.wasd.look_at(pg.normalize((1, 0, 1)), (0, 0, 0))
self.context = pg.Context(pg.DirectionalLightProgram())
self.context.sampler = pg.Texture(0, 'examples/earth.png')
self.context.use_texture = True
sphere = pg.Sphere(4, 0.5, (0, 0, 0))
self.context.position = pg.VertexBuffer(sphere.positions)
self.context.normal = pg.VertexBuffer(sphere.normals)
self.context.uv = pg.VertexBuffer(sphere.uvs)
def run(self):
context = pg.Context(Program())
font = pg.Font(self, 2, FONT, 24, (0, 0, 0, 1))
self.message = 'loading triangle mesh'
mesh = pg.STL('examples/%s.stl' % NAME).center()
self.triangles = '%d triangles' % (len(mesh.positions) / 3)
self.message = 'computing bounding box'
(x0, y0, z0), (x1, y1, z1) = pg.bounding_box(mesh.positions)
context.uv0 = (x0, z0)
context.uv1 = (x1, z1)
self.message = 'generating vertex buffer'
context.position = pg.VertexBuffer(mesh.positions)
self.message = 'generating height map'
p = mesh.positions
lookup = defaultdict(list)
for v1, v2, v3 in zip(p[::3], p[1::3], p[2::3]):
x, y, z = v1
x, z = int(round(x / STEP)), int(round(z / STEP))
lookup[(x, z)].append((v1, v2, v3))
self.message = 'loading brightness texture'
context.sampler = pg.Texture(0, 'examples/%s.jpg' % NAME)
self.message = 'loading normal texture'
context.normal_sampler = pg.Texture(1, 'examples/%s.png' % NAME)
self.result = {
'font': font,
'context': context,
'lookup': lookup,
}
def setup(self):
data = []
shape = pg.Plane((0, 0, 0), (0, 0, 1), 0.5, False)
for _ in xrange(COUNT):
x = (random.random() - 0.5) * FIELD_SIZE
y = (random.random() - 0.5) * FIELD_SIZE
z = random.random() * FIELD_DEPTH
mesh = pg.Matrix().translate((x, y, z)) * shape
data.extend(mesh.positions)
self.context = pg.Context(pg.SolidColorProgram())
self.context.position = pg.VertexBuffer(data)
def setup(self):
self.wasd = pg.WASD(self, speed=3)
self.wasd.look_at((-5, 4, 5), (0, 0, 0))
self.context = pg.Context(pg.DirectionalLightProgram())
data = []
points = pg.poisson_disc(-4, -4, 4, 4, 1, 32)
for x, z in points:
noise = pg.simplex2(10 + x * 0.25, 10 + z * 0.25, 4)
y = (noise + 1) / 1
shape = pg.Cone((x, 0, z), (x, y, z), 0.4, 36)
data.extend(pg.interleave(shape.positions, shape.normals))
shape = pg.Sphere(3, 0.3, (x, y, z))
data.extend(pg.interleave(shape.positions, shape.normals))
self.context.position, self.context.normal = (
pg.VertexBuffer(data).slices(3, 3))
self.plane = pg.Context(pg.DirectionalLightProgram())
self.plane.object_color = (1, 1, 1)
shape = pg.Plane((0, -0.1, 0), (0, 1, 0), 5)
data = pg.interleave(shape.positions, shape.normals)
self.plane.position, self.plane.normal = (pg.VertexBuffer(data).slices(
3, 3))
self.axes = pg.Context(pg.SolidColorProgram())
self.axes.color = (0.3, 0.3, 0.3)
self.axes.position = pg.VertexBuffer(pg.Axes(100).positions)
def setup(self):
plane = pg.Plane((0, 0, 0), (0, 0, 1), 1)
self.context = pg.Context(Program())
self.context.position = pg.VertexBuffer(plane.positions)
self.context.matrix = pg.Matrix().orthographic(-1, 1, -1, 1, -1, 1)
self.positions = []
n = GRID_SIZE
m = CIRCLE_SPACING
for i in range(n):
for j in range(n):
x = (i - (n - 1) / 2.0) * m
y = (j - (n - 1) / 2.0) * m
d = (x * x + y * y)**0.5
self.positions.append((x, y, d))
self.max_distance = max(x[-1] for x in self.positions)
def setup(self):
self.wasd = pg.WASD(self, speed=30)
self.wasd.look_at((-20, 20, -8), (0, 0, 0))
self.context = pg.Context(pg.DirectionalLightProgram())
self.context.use_color = True
self.context.specular_power = 8.0
self.context.specular_multiplier = 0.3
normals = defaultdict(list)
position = []
normal = []
color = []
size = 50
# generate height map
height = {}
colors = {}
for x in xrange(-size, size + 1):
for z in xrange(-size, size + 1):
height[(x, z)] = noise(x, z)
colors[(x, z)] = generate_color(x, z)
# generate triangles and track normals for all vertices
for x in xrange(-size, size):
for z in xrange(-size, size):
t1 = [x + 0, z + 0, x + 1, z + 0, x + 0, z + 1]
t2 = [x + 0, z + 1, x + 1, z + 0, x + 1, z + 1]
for t in [t1, t2]:
x1, z1, x2, z2, x3, z3 = t
p1 = (x1, height[(x1, z1)], z1)
p2 = (x2, height[(x2, z2)], z2)
p3 = (x3, height[(x3, z3)], z3)
c1 = colors[(x1, z1)]
c2 = colors[(x2, z2)]
c3 = colors[(x3, z3)]
position.extend([p3, p2, p1])
color.extend([c3, c2, c1])
n = pg.normalize(pg.cross(pg.sub(p3, p1), pg.sub(p2, p1)))
normals[(x1, z1)].append(n)
normals[(x2, z2)].append(n)
normals[(x3, z3)].append(n)
# compute average normal for all vertices
for key, value in normals.items():
normals[key] = pg.normalize(reduce(pg.add, value))
for x, y, z in position:
normal.append(normals[(x, z)])
# generate vertex buffer
vb = pg.VertexBuffer(pg.interleave(position, normal, color))
self.context.position, self.context.normal, self.context.color = (
vb.slices(3, 3, 3))
def draw_lines(self):
bits = ('0' * 4 + '1' * 4) * 2
shift = int(self.t * 16) % len(bits)
bits = bits[shift:] + bits[:shift]
glLineStipple(1, int(bits, 2))
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
matrix = self.wasd.get_matrix()
matrix = matrix.perspective(65, self.aspect, ZNEAR, ZFAR)
self.lines.matrix = matrix
data = []
x1, y1, z1 = self.get_position()
for x2, y2, z2 in self._positions:
data.append((x2, y2, z2))
data.append((x1, y1, z1))
if data:
self.lines.position = pg.VertexBuffer(data)
glEnable(GL_BLEND)
glEnable(GL_LINE_STIPPLE)
self.lines.draw(pg.GL_LINES)
glDisable(GL_LINE_STIPPLE)
glDisable(GL_BLEND)
self.lines.position.delete()
def setup(self):
plane = pg.Plane((0, 0, 0), (0, 0, 1), 1)
self.context = pg.Context(Program())
self.context.position = pg.VertexBuffer(plane.positions)
self.context.matrix = pg.Matrix().orthographic(-1, 1, -1, 1, -1, 1)