def _create_main_scene(self):
gui = Frame()
# Main Layout
layout = VLayout(margins=(50, 20))
layout += (
# -- title text
HLayout(Label("TRIGGERED", font_size=42)),
# -- buttons
VLayout(
TextButton(
"Play", font_size=24, w=200, radius=10,
callback=lambda: self._switch_scene("game")
),
TextButton(
"Settings", font_size=24, w=200, radius=10,
callback=lambda: self._switch_scene("settings"),
),
TextButton(
"Exit", font_size=24, w=200, radius=10,
callback=lambda: pg.app.exit()
),
margins=(0, 20)
),
)
gui += layout
# -- Create the scene
main = Scene("main")
main.add("gui", gui)
self.scenes.append(main)
return main
def initialize(self):
print("Initializing program...")
self.renderer = Renderer()
self.scene = Scene()
self.camera = Camera()
self.rig = MovementRig()
self.rig.add(self.camera)
self.scene.add(self.rig)
self.rig.setPosition(0, 0, 4)
geometry = BoxGeometry()
material = SurfaceBasicMaterial({"useVertexColors": 1})
self.mesh = Mesh(geometry, material)
self.mesh.rotateX(0.6)
self.mesh.rotateY(-0.6)
self.mesh.rotateZ(-0.4)
self.scene.add(self.mesh)
# add a backdrop
backGeometry = PolygonGeometry(sides=64, radius=2)
backMaterial = SurfaceBasicMaterial({"baseColor": [1, 1, 0]})
self.backdrop = Mesh(backGeometry, backMaterial)
self.backdrop.rotateX(1.57)
self.backdrop.setPosition(0, -1, 0)
self.scene.add(self.backdrop)
def initialize(self):
print("Initializing program...")
self.renderer = Renderer()
self.scene = Scene()
self.camera = Camera()
geometry = BoxGeometry()
material = SurfaceBasicMaterial({"useVertexColors": 1})
self.mesh = Mesh(geometry, material)
self.mesh.rotateX(0.6)
self.mesh.rotateY(-0.6)
self.mesh.rotateZ(-0.4)
self.scene.add(self.mesh)
# pull camera towards viewer
self.camera.setPosition(0, 0, 4)
# add a backdrop
backGeometry = BoxGeometry(width=2, height=2, depth=0.01)
backMaterial = SurfaceBasicMaterial({"baseColor": [1, 1, 0]})
self.backdrop = Mesh(backGeometry, backMaterial)
self.backdrop.rotateX(1.57)
self.backdrop.setPosition(0, -1, 0)
self.scene.add(self.backdrop)
class Test(Base):
def initialize(self):
print("Initializing program...")
self.renderer = Renderer()
self.scene = Scene()
self.camera = Camera()
# pull camera towards viewer
self.camera.setPosition(0, 0, 7)
geometry = Geometry()
posData = []
for x in range(-32, 32, 3):
posData.append([x/10, sin(x/10), 0])
geometry.addAttribute("vec3", "vertexPosition", posData)
geometry.countVertices()
pointMaterial = PointBasicMaterial({"baseColor": [1,1,0]})
self.pointMesh = Mesh(geometry, pointMaterial)
lineMaterial = LineBasicMaterial({"baseColor": [1,0,1]})
self.lineMesh = Mesh(geometry,lineMaterial)
self.scene.add(self.pointMesh)
self.scene.add(self.lineMesh)
def update(self):
self.renderer.render(self.scene, self.camera)
def _create_pause_scene(self):
gui = Frame()
# Main Layout
layout = VLayout()
layout += (
# -- title text
HLayout(Label("PAUSE", font_size=42)),
# -- buttons
HLayout(
TextButton(
"Continue",
font_size=24,
callback=lambda: self._switch_scene("game"),
),
TextButton(
"Main", font_size=24, callback=lambda: self._switch_scene("main")
),
),
)
gui += layout
pause = Scene("pause")
pause.add("pause_gui", gui)
self.scenes.append(pause)
return pause
def __init__(self):
self.main_screen = pygame.display.set_mode(size) # pygame.FULLSCREEN
self.scene = Scene(pygame.Rect(0, 0, width, height), self.main_screen)
self.input_handler = InputHandler()
self.input_handler.bind(pygame.K_f, self.toggle_full_screen)
self.full_screen = False
self.ui = UserInterface(pygame.Rect(0, 0, width, height))
self.scene.add_sprite(self.ui)
self.score_ui = TextElement(
pygame.Rect(width - 100, height // 2, 200, 200), "0:0", 40)
self.ui.add_element(self.score_ui)
self.scene.add_handler(SmileCollisionHandler(self.collide_edge))
self.start_pos = width // 2 - 100, height // 2 - 100
self.smile = Smile(self.start_pos)
self.scene.add_sprite(self.smile)
self.scene.add_sprite(
PaddleAI(pygame.Rect(width // 2 - 100, 50, 200, 20), self.smile))
player_paddle = PaddleAI(
pygame.Rect(width // 2 - 100, height - 70, 200, 20), self.smile)
self.scene.add_sprite(player_paddle)
self.player = Player(player_paddle, self.scene)
self.player.bind_keys(self.input_handler)
self.score = [0, 0]
class Test(Base):
def initialize(self):
print("Initializing program...")
self.renderer = Renderer()
self.scene = Scene()
self.camera = Camera()
# pull camera towards viewer
self.camera.setPosition(0, 0, 7)
geometry = SphereGeometry(radius=3)
vsCode = """
in vec3 vertexPosition;
in vec3 vertexColor;
uniform mat4 modelMatrix;
uniform mat4 viewMatrix;
uniform mat4 projectionMatrix;
out vec3 color;
uniform float time;
void main()
{
float offset = 0.2 * sin(2.0 * vertexPosition.x + time);
vec3 pos = vertexPosition + vec3(0, offset, 0);
gl_Position = projectionMatrix * viewMatrix * modelMatrix * vec4(pos, 1);
color = vertexColor;
}
"""
fsCode = """
in vec3 color;
uniform float time;
out vec4 fragColor;
void main()
{
float r = abs(sin(time));
vec4 c = vec4(r, -0.5*r, -0.5*r, 0);
fragColor = vec4(color , 1) + c;
}
"""
material = Material(vsCode, fsCode)
material.addUniform("float", "time", 0)
material.locateUniforms()
self.time = 0
self.mesh = Mesh(geometry, material)
self.scene.add(self.mesh)
def update(self):
self.time += 1/60
self.mesh.material.uniforms["time"].data = self.time
self.renderer.render(self.scene, self.camera)
class Display(QPygletWidget):
def on_init(self):
#res = pyglet.media.load("R:/adachi.webm")
#animation = pyglet.image.load_animation("adachi.gif")
#animation = res.get_animation()
#bin = pyglet.image.atlas.TextureBin()
#animation.add_to_texture_bin(bin)
#self.sprite = pyglet.sprite.Sprite(animation)
#self.sprite.base_width = self.sprite.width
#self.sprite.base_height = self.sprite.height
#self.player = pyglet.media.Player()
#self.player.queue(res)
#self.player.on_player_next_source = lambda: self.player.queue(res)
#self.player.loop = True
#self.player.play()
char = core.asset.Character('123456')
char.load()
self.scene = Scene()
char._open_tars()
print(char.content_tars)
self.scene.layers['background'] = core.pylget_loader.load_animation(
char.emotes[0].idle,
char.content_tars[char.files[char.emotes[0].idle.filename]])
char._close_tars()
self.label = pyglet.text.Label(
text="This is a pyglet label rendered in a Qt widget :)",
x=self.width() / 2,
y=self.height() / 2,
anchor_x='center',
anchor_y='center')
self.base_width = 256
self.base_height = 192
self.setMinimumSize(QSize(256, 192))
#self.setMaximumSize(QSize(256, 192))
self.enable_alpha()
def on_draw(self):
pyglet.app.event_loop.idle()
self.label.draw()
self.scene.draw()
#self.player.texture.blit(0, 0, width=self.base_width, height=self.base_height)
#self.sprite.draw()
def on_resize(self, w, h):
super().on_resize(w, h)
self.label.x = w / 2
self.label.y = h / 2
scale = min(w // self.base_width, h // self.base_height)
gl.glLoadIdentity()
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER,
gl.GL_NEAREST)
gl.glScalef(scale, scale, scale)
def enable_alpha(self):
gl.glEnable(gl.GL_BLEND)
gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
class Test(Base):
def initialize(self):
print("Initializing program...")
self.renderer = Renderer()
self.scene = Scene()
self.camera = Camera()
# pull camera towards viewer
self.camera.setPosition(0, 0, 7)
geometry = SphereGeometry(radius=3)
vsCode = """
in vec3 vertexPosition;
out vec3 position;
uniform mat4 modelMatrix;
uniform mat4 viewMatrix;
uniform mat4 projectionMatrix;
void main()
{
vec4 pos = vec4(vertexPosition, 1);
gl_Position = projectionMatrix * viewMatrix * modelMatrix * pos;
position = vertexPosition;
}
"""
fsCode = """
in vec3 position;
out vec4 fragColor;
void main()
{
vec3 color = fract(position);
fragColor = vec4(color,1);
}
"""
material = Material(vsCode, fsCode)
material.locateUniforms()
self.mesh = Mesh(geometry, material)
self.scene.add(self.mesh)
def update(self):
self.mesh.rotateY(0.01)
self.renderer.render(self.scene, self.camera)
def initialize(self):
print("Initializing program...")
self.renderer = Renderer()
self.scene = Scene()
self.camera = Camera()
# pull camera towards viewer
self.camera.setPosition(0, 0, 4)
geometry = BoxGeometry()
material = SurfaceBasicMaterial({"useVertexColors": 1})
self.mesh = Mesh(geometry, material)
self.scene.add(self.mesh)
def main():
config = pyglet.gl.Config(double_buffer=True, sample_buffers=1, samples=4)
win = pyglet.window.Window(config=config)
renderer = Renderer()
scene = Scene()
camera = Camera()
camera.translate(0, 0, 2)
particleSystem = ParticleSystem()
scene.add(particleSystem.boundBoxMesh)
scene.add(particleSystem.particleMesh)
def update(dt: float):
particleSystem()
# mesh.rotate(0, 0.1, 0.1)
clock = pyglet.clock.schedule_interval(update, 1 / 120)
@win.event
def on_draw():
win.clear()
renderer.render(scene, camera)
@win.event
def on_mouse_drag(x, y, dx, dy, buttons, modifiers):
if buttons & pyglet.window.mouse.RIGHT:
scene.rotate(-dy / 10, dx / 10, 0)
@win.event
def on_mouse_scroll(x, y, scroll_x, scroll_y):
camera.translate(0, 0, -scroll_y)
# @win.event
# def on_key_press(symbol, modifiers):
# if symbol == pyglet.window.key.A:
# camera.translate(-0.1, 0, 0)
# if symbol == pyglet.window.key.D:
# camera.translate(0.1, 0, 0)
# if symbol == pyglet.window.key.W:
# camera.translate(0, 0.1, 0)
# if symbol == pyglet.window.key.S:
# camera.translate(0,-0.1, 0)
pyglet.app.run()
def initialize(self):
print("Initializing program...")
self.renderer = Renderer()
self.scene = Scene()
self.camera = Camera()
self.rig = MovementRig(unitsPerSecond=25, degreesPerSecond=90)
self.rig.add(self.camera)
self.scene.add(self.rig)
self.rig.setPosition(0, 0, 4)
geometry = GridDotGeometry(width=1000,
height=1000,
heightResolution=300,
widthResolution=300)
material = SurfaceBasicMaterial({"useVertexColors": 1})
self.mesh = Mesh(geometry, material)
self.scene.add(self.mesh)
self.scene.add(AxesHelper(axisLength=3, lineWidth=2))
def main():
renderer, scene, camera = Renderer(), Scene(), Camera()
geometry = TorusGeometry()
material = SurfaceMaterial()
mesh = Mesh(geometry, material)
scene.add(mesh)
mesh.translate(0, 0, -5)
win = Window(renderer, scene, camera)
class Test(Base):
def initialize(self):
print("Initializing program...")
self.renderer = Renderer()
self.scene = Scene()
self.camera = Camera()
self.rig = MovementRig(unitsPerSecond=25, degreesPerSecond=90)
self.rig.add(self.camera)
self.scene.add(self.rig)
self.rig.setPosition(0, 0, 4)
geometry = GridDotGeometry(width=1000,
height=1000,
heightResolution=300,
widthResolution=300)
material = SurfaceBasicMaterial({"useVertexColors": 1})
self.mesh = Mesh(geometry, material)
self.scene.add(self.mesh)
self.scene.add(AxesHelper(axisLength=3, lineWidth=2))
def update(self):
if self.input.isKeyDown("p"):
self.mesh.material.settings[
"wireframe"] = not self.mesh.material.settings["wireframe"]
self.rig.update(self.input, 1 / 60)
self.renderer.render(self.scene, self.camera)
class Test(Base):
def initialize(self):
print("Initializing program...")
self.renderer = Renderer()
self.scene = Scene()
self.camera = Camera()
self.rig = MovementRig()
self.rig.add(self.camera)
self.scene.add(self.rig)
self.rig.setPosition(0, 0, 4)
geometry = PlaneGeometry(width=100, height=100,widthResolution=100, heightResolution=100)
material = SurfaceBasicMaterial({"useVertexColors":1})
self.terrain = Mesh(geometry, material)
self.terrain.rotateX(3.14/2)
self.scene.add(self.terrain)
self.scene.add(AxesHelper(axisLength=3))
def update(self):
self.rig.update(self.input, 1/60)
self.renderer.render(self.scene, self.camera)
def _create_settings_scene(self):
gui = Frame()
# Main Layout
layout = VLayout()
layout += (
# -- title text
HLayout(Label("SETTINGS", font_size=42)),
# -- buttons
HLayout(
TextButton(
"Back to MainMenu",
font_size=24,
callback=lambda: self._switch_scene("main"),
),
TextButton("Exit", font_size=24, callback=lambda: pg.app.exit()),
),
)
gui += layout
settings = Scene("settings")
settings.add("settings_gui", gui)
self.scenes.append(settings)
return settings
def on_init(self):
#res = pyglet.media.load("R:/adachi.webm")
#animation = pyglet.image.load_animation("adachi.gif")
#animation = res.get_animation()
#bin = pyglet.image.atlas.TextureBin()
#animation.add_to_texture_bin(bin)
#self.sprite = pyglet.sprite.Sprite(animation)
#self.sprite.base_width = self.sprite.width
#self.sprite.base_height = self.sprite.height
#self.player = pyglet.media.Player()
#self.player.queue(res)
#self.player.on_player_next_source = lambda: self.player.queue(res)
#self.player.loop = True
#self.player.play()
char = core.asset.Character('123456')
char.load()
self.scene = Scene()
char._open_tars()
print(char.content_tars)
self.scene.layers['background'] = core.pylget_loader.load_animation(
char.emotes[0].idle,
char.content_tars[char.files[char.emotes[0].idle.filename]])
char._close_tars()
self.label = pyglet.text.Label(
text="This is a pyglet label rendered in a Qt widget :)",
x=self.width() / 2,
y=self.height() / 2,
anchor_x='center',
anchor_y='center')
self.base_width = 256
self.base_height = 192
self.setMinimumSize(QSize(256, 192))
#self.setMaximumSize(QSize(256, 192))
self.enable_alpha()
def create_scene(primitives):
"""Create a default scene."""
# create the accelerator
aggregate = GridAccel(primitives, False)
# create the lights
lights = []
# light = PointLight()
# lights.append(light)
# create the scene
scene = Scene(aggregate, lights, volume_region=None)
return scene
def EstimateDirect(scene: Scene, renderer: Renderer, light: Light, p: Point3d, n: Normal, wo: Vector3d,
time: float, bsdf: BSDF, lightSample: LightSample, bsdfSample: BSDFSample,
BxDFTypeFlag: int) -> Spectrum:
Ld = Spectrum(0.0)
visibility = VisibilityTester()
wi, Li, lightPdf = light.Sample_L1(p, lightSample, time, visibility)
if lightPdf > 0.0 and not Li.get_is_black():
f = bsdf.f(wo, wi, BxDFTypeFlag)
if not f.get_is_black() and visibility.Unoccluded(scene):
# Add light's contribution to reflected radiance
#Li *= visibility.Transmittance(scene, renderer, None)
inv_lightPdf = 1.0 / lightPdf
if light.get_is_delta_light():
Ld += f * Li * math.fabs(Vector3d.dot(wi, n)) * inv_lightPdf
else:
bsdfPdf = bsdf.get_Pdf(wo, wi, BxDFTypeFlag)
weight = PowerHeuristic(1, lightPdf, 1, bsdfPdf)
Ld += f * Li * math.fabs(Vector3d.dot(wi, n)) * weight * inv_lightPdf
# Sample BSDF with multiple importance sampling
if not light.get_is_delta_light():
wi, bsdfPdf, sampledType, f = bsdf.Sample_f(wo, bsdfSample, BxDFTypeFlag)
if not f.get_is_black() and bsdfPdf > 0.0:
weight = 1.0
if not (BxDFTypeFlag & BxDFType.BSDF_SPECULAR):
lightPdf = light.get_pdf(p, wi)
if lightPdf == 0.0:
return Ld
weight = PowerHeuristic(1, bsdfPdf, 1, lightPdf)
# Add light contribution from BSDF sampling
lightIsect = Intersection()
Li = Spectrum(0.0)
ray = Ray(p, wi, 1e-3, infinity_max_f, time)
if scene.get_intersection(ray, lightIsect):
if lightIsect.primitive.GetAreaLight() == light:
Li = lightIsect.Le(-wi)
else:
Li = light.Le(ray)
if not Li.get_is_black():
Li *= 1.0 #todo renderer.Transmittance(scene, ray, None)
Ld += f * Li * math.fabs(Vector3d.dot(wi, n)) * weight / bsdfPdf
return Ld
def Li(self, scene: Scene, renderer: Renderer, ray: Ray, intersection: Intersection, sample: Sample)->Spectrum:
occlusion = 0
intersection.ray_epsilon = infinity_max_f
bsdf = intersection.get_bsdf(ray)
p = bsdf.dgShading.point
n = maths.tools.get_face_forward(intersection.differentialGeometry.normal, -ray.direction)
for i in range(self.samples_count):
w = maths.tools.get_uniform_sample_sphere(random(), random())
if Vector3d.dot(w, n) < 0.0:
w = -w
r = Ray(p, w, 0.01, self.max_distance)
if scene.get_is_intersected(r):
occlusion += 1
return Spectrum(1.0-(float(occlusion) / float(self.samples_count)))
Show the picture.
"""
if __name__ == "__main__":
engine = Engine(500, 500)
camera = Camera([0, 0, 0], [1, 0, 0], [0, -1, 0], fov=1)
#camera = ThinLensCamera([0,0,0], [1,0,0], [0,-1,0], radius=0.0, focal_distance=6, fov=1)
#light = Light([10,0,10])
#light = LightProb("hdrmap/grace_probe.pfm")
light = LightProb("hdrmap/stpeters_probe.pfm")
scene = Scene(light)
#scene.addobject(Sphere([0,0,0], 1000, anti=True))
#scene.addobject(Triangle(([-1000, -1000, 200], [1000,-1000, 200], [1000,1000, 200]), color=[255,0,0]))
#scene.addobject(Triangle(([-1000, -1000, 200], [1000,1000, 200], [-1000, 1000, 200])))
#scene.addobject(Triangle(([-10000, -10000, -1000], [10000,-10000, -1000], [10000,10000, -1000])))
#scene.addobject(Triangle(([-10000, -10000, -1000], [10000,10000, -1000], [-10000, 10000, -1000])))
np.random.seed(10)
for i in range(30):
x, y, z, r = np.random.randn(4)
choice = np.random.choice(a=[False, True])
scene.addobject(
Sphere([x * 50, y * 50, 100 + z * 10],
def _get_scene():
level = list(levels.values())[current_level]
game = Scene("game")
game.add("physics", PhysicsWorld())
game.add("camera", Camera())
game.add("map", Map(level.map))
game.add("player", Player(position=level.player))
game.add("enemy", EnemyCollection(level.enemies, level.waypoints))
# -- setup camera
game.camera.bounds = (0, 0, *game.map.size)
game.camera.track(game.player)
self.scenes.append(game)
return game
def Unoccluded(self, scene: Scene)->bool:
return not scene.get_is_intersected(self.ray)
def __init__(self):
Scene.__init__(self)
class Game:
def __init__(self):
self.main_screen = pygame.display.set_mode(size) # pygame.FULLSCREEN
self.scene = Scene(pygame.Rect(0, 0, width, height), self.main_screen)
self.input_handler = InputHandler()
self.input_handler.bind(pygame.K_f, self.toggle_full_screen)
self.full_screen = False
self.ui = UserInterface(pygame.Rect(0, 0, width, height))
self.scene.add_sprite(self.ui)
self.score_ui = TextElement(
pygame.Rect(width - 100, height // 2, 200, 200), "0:0", 40)
self.ui.add_element(self.score_ui)
self.scene.add_handler(SmileCollisionHandler(self.collide_edge))
self.start_pos = width // 2 - 100, height // 2 - 100
self.smile = Smile(self.start_pos)
self.scene.add_sprite(self.smile)
self.scene.add_sprite(
PaddleAI(pygame.Rect(width // 2 - 100, 50, 200, 20), self.smile))
player_paddle = PaddleAI(
pygame.Rect(width // 2 - 100, height - 70, 200, 20), self.smile)
self.scene.add_sprite(player_paddle)
self.player = Player(player_paddle, self.scene)
self.player.bind_keys(self.input_handler)
self.score = [0, 0]
def toggle_full_screen(self):
self.full_screen = not self.full_screen
pygame.display.quit()
pygame.display.init()
if self.full_screen:
self.main_screen = pygame.display.set_mode(size, pygame.FULLSCREEN)
else:
self.main_screen = pygame.display.set_mode(size)
def _render_sprite(self, sprite):
self.main_screen.blit(sprite.rendered_sprite, sprite.rect)
def collide_edge(self, top):
if top:
self.score[1] += 1
else:
self.score[0] += 1
self.score_ui.text = "{}:{}".format(self.score[0], self.score[1])
self.restart()
def restart(self):
self.smile.rect = pygame.Rect(self.start_pos[0], self.start_pos[1],
self.smile.rect.w, self.smile.rect.h)
def game_tick(self):
events = pygame.event.get()
for event in events:
if event.type == pygame.QUIT:
sys.exit()
[
self.input_handler.handle(i)
for i, k in enumerate(pygame.key.get_pressed()) if k != 0
]
self.main_screen.fill(white)
[h.update() for h in self.scene.get_handlers()]
for sp in self.scene.get_sprites():
if sp.need_render:
sp.update_render()
sp.need_render = False
[self._render_sprite(sp) for sp in self.scene.get_sprites()]
pygame.display.flip()
