def _load_scene(self):
# ratcave instantly creates gl resources so we can't import earlier
import ratcave as rc
# Insert filename into WavefrontReader.
obj_filename = rc.resources.obj_primitives
obj_reader = rc.WavefrontReader(obj_filename)
# Create Mesh
self._monkey = obj_reader.get_mesh("Monkey", scale=.7)
self._monkey.position.xyz = 0, 0, 0
self._monkey.uniforms['diffuse'] = 0., 0., 1.
self._monkey.uniforms['spec_weight'] = 300.
self._torus = obj_reader.get_mesh("TorusSmooth")
self._torus.position.xyz = 0, 0, 0
self._torus.rotation.x = 20
self._torus.uniforms['diffuse'] = 1., 0., 0.
self._torus.uniforms['spec_weight'] = 300.
# Create Scene
self._scene = rc.Scene(meshes=[self._monkey, self._torus])
self._scene.light.position.z = 3
self._scene.light.position.x = 3
# Prebuild shader
with rc.default_shader:
pass
# mutables
self._torus_xpos = imgui.Float(0)
self._cam_angle = imgui.Float(0)
self._cam_dist = imgui.Float(3)
def __init__(self, *args, **kwargs):
"""
Returns Window with everything needed for doing arena scanning. Will automatically close when all camera movement
has completed.
"""
super(GridScanWindow, self).__init__(*args, **kwargs)
wavefront_reader = rc.WavefrontReader(rc.resources.obj_primitives)
self.mesh = wavefront_reader.get_mesh('Grid',
position=[0., 0., -1.],
scale=1.5,
point_size=12,
drawstyle='point')
self.mesh.uniforms['diffuse'] = [1., 1., 1.] # Make white
self.mesh.uniforms['flat_shading'] = True
self.scene = rc.Scene([self.mesh], bgColor=(0, 0, 0))
self.scene.camera.ortho_mode = True
dist = .06
self.cam_positions = ((dist * np.sin(ang), dist * np.cos(ang), -1)
for ang in np.linspace(0, 2 * np.pi, 40)[:-1])
self.marker_pos = []
pyglet.clock.schedule(self.detect_projection_point)
pyglet.clock.schedule(self.move_camera)
def __init__(self):
super(World, self).__init__();
self.scene = rc.Scene(meshes=[],camera=rc.Camera(orientation0=(0, 0, -1),rotation=(0, 0, 0)))
self.scene.bgColor = 33, 33, 33
self.name = 'World';
self.objs = [];
self.objs_num = len(self.objs);
self.rules = [];
self.rules_num = len(self.rules);
self.size = 32;
def __init__(self,client_sock,server_sock):
#Handling user keyboard inputs
self.keys = key.KeyStateHandler()
window.push_handlers(self.keys)
#Used for reading and handling user inputs
self.client_sock = client_sock
self.server_sock = server_sock
#Default stats label to be displayed
self.stats = ['Fall Status: False','Fall Distance: Nan']
# Load Meshes and put into a Scene
obj_reader = rc.WavefrontReader(rc.resources.obj_primitives)
self.sphere = obj_reader.get_mesh('Sphere', position=(0, 0, -3),scale=0.3)
self.torus = obj_reader.get_mesh('Torus', position=(0, 0, -3),scale=0.5)
self.torus2 = obj_reader.get_mesh('Torus', position=(0, 0, -3),scale=0.5)
#set up diffuse color for meshes
self.sphere.uniforms['diffuse'] = [.6, .6, .6]
self.torus.uniforms['diffuse'] = [1, 0, 0]
self.torus2.uniforms['diffuse'] = [0, 0, 1]
#setting up the defaults
self.azimuth = 0
self.pitch = 0
self.roll = 0
self.vx = 0
self.vy = 0
self.vz = 0
#add meshes to scene
self.scene = rc.Scene(meshes=[self.sphere,self.torus,self.torus2])
#set up scene background color
self.scene.bgColor = 138/255, 113/255, 145/255
#schdules the update and user input functions to run
pyglet.clock.schedule_interval(self.update, 1.0/40.0)
# pyglet.clock.schedule_interval(self.get_recent_valid_data, 1.0/60.0)
pyglet.clock.schedule(self.user_inputs)
#used to display animation
self.begin_animation = False
#exit game condition
self.end_game=False
self.animation_data = []
self.display_data = Queue()
self.iter_barrier = threading.Barrier(2)
def make_scene(self):
# Insert filename into WavefrontReader.
obj_filename = rc.resources.obj_primitives
obj_reader = rc.WavefrontReader(obj_filename)
# Create Mesh
monkey = obj_reader.get_mesh("Monkey")
monkey.position.xyz = 0, 0, -5
# Create Scene
self.scene = rc.Scene(meshes=[monkey], bgColor=(0, 1, 0))
def load_projected_scene(arena_file, projector_file, motive_client):
"""Scene-building convenience function. Returns (scene, arena, arena_rb) from filenames and motive."""
arena, arena_rb = get_arena_with_rigidbody(arena_objfilename=arena_file,
motive_client=motive_client)
beamer = get_beamer_camera(fname=projector_file)
scene = rc.Scene(meshes=[arena], bgColor=(.6, 0, 0))
scene.camera.position.xyz = beamer.position.xyz
scene.camera.rotation.xyz = beamer.rotation.xyz
scene.camera.projection.fov_y = beamer.projection.fov_y
scene.camera.projection.aspect = beamer.projection.aspect
scene.gl_states = scene.gl_states[:-1]
scene.light.position.xyz = beamer.position.xyz
return scene, arena, arena_rb
def view_mesh(body, obj_filename):
# """Displays mesh in .obj file. Useful for checking that files are rendering properly."""
reader = rc.WavefrontReader(obj_filename)
mesh = reader.get_mesh(body, position=(0, 0, -1))
print(mesh.vertices.shape)
mesh.scale.x = .2 / np.ptp(mesh.vertices, axis=0).max()
camera = rc.Camera(projection=rc.PerspectiveProjection(fov_y=20))
light = rc.Light(position=(camera.position.xyz))
scene = rc.Scene(meshes=[mesh],
camera=camera,
light=light,
bgColor=(.2, .4, .2))
scene.gl_states = scene.gl_states[:-1]
display = pyglet.window.get_platform().get_default_display()
screen = display.get_screens()[0]
window = pyglet.window.Window(fullscreen=True, screen=screen)
fbo = rc.FBO(rc.Texture(width=4096, height=4096))
quad = rc.gen_fullscreen_quad()
quad.texture = fbo.texture
label = pyglet.text.Label()
@window.event
def on_draw():
with rc.resources.genShader, fbo:
scene.draw()
with rc.resources.deferredShader:
quad.draw()
verts_mean = np.ptp(mesh.vertices, axis=0)
label.text = 'Name: {}\nRotation: {}\nSize: {} x {} x {}'.format(
mesh.name, mesh.rotation, verts_mean[0], verts_mean[1],
verts_mean[2])
label.draw()
@window.event
def on_resize(width, height):
camera.projection.aspect = float(width) / height
@window.event
def on_mouse_motion(x, y, dx, dy):
x, y = x / float(window.width) - .5, y / float(window.height) - .5
mesh.rotation.x = -360 * y
mesh.rotation.y = 360 * x
pyglet.app.run()
def __init__(self, screenidx=1, color=(1., 1., 1.), scale=0.09, *args, **kwargs):
display = pyglet.window.get_platform().get_default_display()
screen = display.get_screens()[screenidx]
super(DotWindow, self).__init__(screen=screen, *args, **kwargs)
spheres = gen_spheres(scale=scale, color=color)
self.scene = rc.Scene(meshes=spheres, bgColor=(0,)*3)
cam = self.scene.camera
self.shader = rc.Shader.from_file(*rc.resources.genShader)
cam.projection = rc.OrthoProjection(origin='center', coords='relative')
cam.update()
pyglet.clock.schedule(update_silently)
def __init__(self, projector, serial_device, *args, **kwargs):
super(LatencyDisplayApp, self).__init__(*args, **kwargs)
self.device = serial_device
pyglet.clock.schedule(lambda dt: None)
reader = rc.WavefrontReader(rc.resources.obj_primitives)
self.dot = reader.get_mesh('Sphere', scale=.02, position=(0, 0, 0))
self.dot.uniforms['diffuse'] = 1., 0., 0.
self.dot.uniforms['flat_shading'] = True
self.scene = rc.Scene(meshes=[self.dot], bgColor=(0., 0., 0.))
self.scene.camera = projector
self.scene.camera.projection.aspect = 1.7777
self.shader3d = rc.Shader.from_file(*rc.resources.genShader)
self.latency_display = pyglet.text.Label(text='Waiting for Stimulus Switch..', x=0, y=0, font_size=36)
pyglet.clock.schedule(self.update_latency_display)
def __init__(self, *args, **kwargs):
super(RotationWindow, self).__init__(*args, **kwargs)
pyglet.clock.schedule(lambda dt: None)
reader = rc.WavefrontReader(rc.resources.obj_primitives)
self.mesh = reader.get_mesh('Monkey', scale=.05, position=(0, 0, 0))
self.mesh.rotation = self.mesh.rotation.to_quaternion()
self.scene = rc.Scene(meshes=[self.mesh], bgColor=(0., 0., 0.))
self.fbo = rc.FBO(rc.Texture(width=4096, height=4096))
self.quad = rc.gen_fullscreen_quad()
self.quad.texture = self.fbo.texture
self.label = pyglet.text.Label()
self.shader3d = rc.Shader.from_file(*rc.resources.genShader)
self.shaderAA = rc.Shader.from_file(*rc.resources.deferredShader)
def __init_window(self, width, height, name):
self.window = pyglet.window.Window(width=width,
height=height,
caption=name)
self.world = rc.EmptyEntity(name='world')
self.world.position.xyz = 0, 0, -2
self.world.scale = 0.5
self.grid = self.__make_grid()
self.scene = rc.Scene(meshes=self.world)
self.scene.camera.position.xyz = 0, 0, 2
self.world.rotation.xyz = 45, 45, 0
self.__reset_drawing()
#This is called on the draw event
@self.window.event
def on_draw():
with rc.default_shader:
self.scene.draw()
[lbl.draw() for lbl in self.labels]
self.__reset_drawing()
#This is called during a mouse drag event
@self.window.event
def on_mouse_drag(x, y, dx, dy, buttons, modifiers):
rot_speed = 1.0
self.world.rotation.y += dx * rot_speed
self.world.rotation.x -= dy * rot_speed
#Register keyboard handler
keys = key.KeyStateHandler()
self.window.push_handlers(keys)
def on_key_press(dt):
camera_speed = 3
if keys[key.W]:
self.scene.camera.position.z -= camera_speed * dt
if keys[key.S]:
self.scene.camera.position.z += camera_speed * dt
if keys[key.R]:
self.scene.camera.position.xyz = 0, 0, 0
self.world.rotation.xyz = 0, 0, 0
#Processes key presses on a clock schedule
pyglet.clock.schedule(on_key_press)
def load_projected_scene(arena_file, projector_file, motive_client):
"""Scene-building convenience function. Returns (scene, arena, arena_rb) from filenames and motive."""
arena = rc.WavefrontReader(arena_file).get_mesh('Arena')
arena.uniforms['diffuse'] = 1., 1, 1
arena.uniforms['flat_shading'] = False
arena.rotation = arena.rotation.to_quaternion()
arena_rb = motive_client.rigid_bodies['Arena']
arena.position.xyz = arena_rb.position
arena.rotation.wxyz = arena_rb.quaternion
scene = rc.Scene(meshes=[arena], bgColor=(.6, 0, 0))
scene.gl_states = scene.gl_states[:-1]
beamer = rc.Camera.from_pickle(projector_file)
scene.camera.position.xyz = beamer.position.xyz
scene.camera.rotation.xyz = beamer.rotation.xyz
scene.camera.projection.fov_y = 41.5
scene.camera.projection.aspect = 1.7778
scene.light.position.xyz = scene.camera.position.xyz
return scene, arena, arena_rb
def __init__(self, max_points=1000, *args, **kwargs):
"""
Returns Window with everything needed for doing projector calibration.
Keyword Args:
-max_points (int): total number of data points to collect before exiting.
"""
super(PointScanWindow, self).__init__(*args, **kwargs)
wavefront_reader = rc.WavefrontReader(rc.resources.obj_primitives)
self.mesh = wavefront_reader.get_mesh('Sphere', position=[0., 0., -1.], scale=.01)
self.mesh.uniforms['diffuse'] = [1., 1., 1.] # Make white
self.mesh.uniforms['flat_shading'] = True
self.scene = rc.Scene([self.mesh], bgColor=(0, 0, 0))
self.scene.camera.ortho_mode = True
self.max_points = max_points
self.screen_pos = []
self.marker_pos = []
pyglet.clock.schedule(self.detect_projection_point)
pyglet.clock.schedule(self._close_if_max_points_reached)
def main():
FULLSCREEN = True
reader = rc.WavefrontReader('resources/maze.obj')
arena = reader.get_mesh('Cube')
arena.textures.append(rc.Texture.from_image(rc.resources.img_uvgrid))
sphere = reader.get_mesh('Sphere') # , position=(0, 0, -1))
cylinder = reader.get_mesh('Cylinder') # , position=(0, 0, -1))
player = rc.Camera(projection=rc.PerspectiveProjection(z_near=.001,
z_far=4.5),
position=(0, .3, 0))
player.rotation.axes = 'sxyz'
scene = rc.Scene(meshes=[arena, sphere, cylinder],
camera=player,
bgColor=(1., 0., 0.))
#scene.gl_states = scene.gl_states[:-1]
window = FPSGame(player=player, scene=scene, fullscreen=FULLSCREEN)
pyglet.app.run()
sphere.uniforms = rc.UniformCollection()
else:
sphere.uniforms['diffuse']= np.random.random(3)
sphere.update()
yield sphere
spheres = [sphere for sphere in sphere_factory(reader, NUM_OBJECTS)]
if IS_MOVING:
for sphere in spheres:
sphere.rot_velocity = 45 * np.random.random()
# Debug Text
label_fps = pyglet.text.Label('FPS', font_size=20)
# Create Scenes and FBOs to render onto
proj_scene = rc.Scene(meshes=spheres)
proj_scene.camera.aspect = 1.
proj_scene.camera.fov_y = 90.
god_scene = rc.Scene(meshes=[player, screen])
cubetexture = rc.TextureCube(width=CUBEMAP_TEXTURE_SIZE, height=CUBEMAP_TEXTURE_SIZE)
screen.texture = cubetexture
fbo_cube = rc.FBO(cubetexture)
aaShader = rc.resources.aaShader
aa_texture = rc.Texture()
fbo_aa = rc.FBO(aa_texture)
fullscreen_quad = rc.resources.gen_fullscreen_quad()
fullscreen_quad.texture = aa_texture
def __init__(self,
arena_objfile,
projector_file,
fullscreen=True,
screen=1,
antialiasing=True,
vsync=False,
fps_mode=False,
*args,
**kwargs):
"""
A Pyglet Window that sets up the arena, beamer, and virtual scenes, along with motive update and draw functions
for updating and rendering a virtual reality environment in a ratCAVE setup.
"""
self.__display = pyglet.window.get_platform().get_default_display()
self.__screen = self.__display.get_screens()[screen]
super(self.__class__, self).__init__(fullscreen=fullscreen,
screen=self.__screen,
vsync=vsync,
*args,
**kwargs)
self.cube_fbo = rc.FBO(texture=rc.TextureCube(width=4096, height=4096))
self.arena = rc.WavefrontReader(arena_objfile).get_mesh(
cfg.ARENA_MESH_NAME)
self.arena.uniforms['diffuse'] = cfg.ARENA_LIGHTING_DIFFUSE
self.arena.uniforms['flat_shading'] = cfg.ARENA_LIGHTING_FLAT_SHADING
self.arena.rotation = self.arena.rotation.to_quaternion()
self.arena_rb = motive.rigid_bodies[cfg.ARENA_MOTIVE_NAME]
self.arena.position.xyz = self.arena_rb.position
self.arena.rotation.wxyz = self.arena_rb.quaternion
beamer = rc.Camera.from_pickle(projector_file)
beamer.projection.aspect = 1.77778
beamer.projection.fov_y = 41.5
self.active_scene = rc.Scene(meshes=[self.arena],
bgColor=(.6, 0, 0),
camera=beamer)
self.active_scene.gl_states.states = self.active_scene.gl_states.states[:
-1]
self.active_scene.light.position.xyz = beamer.position.xyz
self.orig_texture = None
self.shader = rc.resources.cube_shader
self._vr_scenes = set()
self.current_vr_scene = None
self.rodent_rb = motive.rigid_bodies[cfg.RODENT_MOTIVE_NAME]
self.antialiasing = antialiasing
# self.fbo_aa = rc.FBO(rc.Texture(width=4096, height=4096, mipmap=True))
# self.aa_quad = rc.gen_fullscreen_quad()
# self.aa_quad.texture = self.fbo_aa.texture
# self.shader_deferred = rc.Shader.from_file(*rc.resources.deferredShader)
if fps_mode:
raise NotImplementedError(
"Haven't gotten fps_mode to work properly yet.")
self.fps_mode = fps_mode
pyglet.clock.schedule(self.update)
terrain_reader = rc.WavefrontReader(terrain_file)
# Get terrain mesh
terrain = get_terrain(terrain_reader, terrain_file)
# Get tree mesh
tree_file = "tree.obj"
tree_render = rc.WavefrontReader(tree_file)
trees = scatter_randomly(terrain, tree_render, tree_file)
scene_items.extend(trees)
scene_items.append(terrain)
return scene_items
# Create scene
scene_items = build_scene()
scene = rc.Scene(meshes=scene_items)
scene.bgColor = 138 / 255.0, 216 / 255.0, 249 / 255.0
# Set fov of camera for wider view and preventing culling too soon
scene.camera.projection.fov_y = 100.
# Save camera home position, if we want to reset
cam_home = scene.camera.position.xyz
# Allow camera translation using keyboard
def move_camera_with_keys(dt):
camera_speed = 3
if keys[key.LEFT]:
scene.camera.position.x -= camera_speed * dt
if keys[key.RIGHT]:
# Inserir o caminho do arquivo do obj
obj_filename2 = path.join('thorFinal.obj')
# Ler o arquivo obj e retorna os pontos
obj_reader = rc.WavefrontReader(obj_filename2)
# Create Mesh
thor = obj_reader.get_mesh("thor")
# Seta a posição inicial, escala, ?
thor.position.xyz = 0, 0, -2
scale = .1
thor.scale = scale
thor.uniforms['diffuse'] = [.5, .0, .8]
# Cria a cena
scene = rc.Scene(meshes=[thor])
scene.bgColor = 0.4, 0.2, 0.4
scene.light.position = 0, 3, -1
# Cria a camera
camera = rc.Camera(projection=rc.PerspectiveProjection(fov_y=90, aspect=1.))
scene.camera = camera
#Faz a projeção da cena
projected_scene = rc.Scene(meshes=[thor], bgColor=(1., 1., 1.))
projected_scene.light.position = scene.light.position
projected_scene.camera = rc.Camera(position=(0, 0, 5), rotation=(0, 0, 0))
projected_scene.camera.projection.z_far = 50
# Atualiza a movimentação da camera e do objeto
def move_camera(dt):
global scale
# projector.rot_x = -90
projector.rot_x = rot[0] - 1.
projector.rot_y = rot[1]
projector.rot_z = 180 - rot[2]
# projector._rot_matrix = projdict['rotation']
display = pyglet.window.get_platform().get_default_display()
screen = display.get_screens()[1]
window = pyglet.window.Window(vsync=True, fullscreen=True, screen=screen)
reader = rc.WavefrontReader(rc.resources.obj_primitives)
sphere = reader.get_mesh('Sphere', scale=.01)
sphere.position = rbody.position
print(sphere.uniforms)
sphere.uniforms['flat_shading'] = 1
scene = rc.Scene(meshes=[sphere], bgColor=(0, .02, 0))
scene.camera = projector
scene.light.position = projector.position
label = pyglet.text.Label('FPS', font_size=20)
label_fps = pyglet.text.Label('FPS', font_size=20)
fps_display = pyglet.clock.ClockDisplay()
@window.event
def on_draw():
sphere.position = rbody.position
scene.draw()
# label.draw()
# label_fps.draw()
import pyglet
import ratcave as rc
import math, time
window = pyglet.window.Window(resizable=True)
# Assemble the Virtual Scene
obj_reader = rc.WavefrontReader(rc.resources.obj_primitives)
sphere = obj_reader.get_mesh("Sphere", position=(0, 0, 2), scale=0.2)
sphere.uniforms['diffuse'] = 1, 0, 0
cube = obj_reader.get_mesh("Cube", position=(0, 0, 0), scale=0.2)
cube.uniforms['diffuse'] = 1, 1, 0
# virtual_scene = rc.Scene(meshes=[sphere, cube], bgColor=(0., 0., 1.))
virtual_scene = rc.Scene(meshes=[cube, sphere], bgColor=(0., 0., 1.))
virtual_scene.light.position.xyz = 0, 3, -1
cube_camera = rc.Camera(
projection=rc.PerspectiveProjection(fov_y=90, aspect=1.))
virtual_scene.camera = cube_camera
# Assemble the Projected Scene
monkey = obj_reader.get_mesh("Monkey", position=(0, 0, -1), scale=0.8)
screen = obj_reader.get_mesh("Plane",
position=(0, 0, 1),
rotation=(1.5, 180, 0))
projected_scene = rc.Scene(meshes=[monkey, screen, sphere, cube],
bgColor=(1., .5, 1.))
projected_scene.light.position = virtual_scene.light.position
window = pyglet.window.Window(resizable=True)
keys = key.KeyStateHandler()
window.push_handlers(keys)
global f
f = 0
# get an object
model_file = rc.resources.obj_primitives
monkey = rc.WavefrontReader("M206v4.obj").get_mesh('Cube', scale=.1)
monkey.position.xyz = 0, 0, -3.5
monkey.uniforms['diffuse'] = [0.255, 0.191, 0.] # RGB values
scene = rc.Scene(meshes=[monkey])
scene.camera.rotation.x = -15
scene.light.rotation.x = -15
def move_camera(dt):
camera_speed = 3
if keys[key.LEFT]:
scene.camera.position.x -= camera_speed * dt
if keys[key.RIGHT]:
scene.camera.position.x += camera_speed * dt
if keys[key.UP]:
scene.camera.position.y -= camera_speed * dt
if keys[key.DOWN]:
scene.camera.position.y += camera_speed * dt
cylinder.uniforms['flat_shading'] = True
cylinder.point_size = .02
cylinder.position.x = -.3
cylinder.scale.xyz = .5
cyl2 = cylinder.copy()
cyl2.position.x = 0
# cyl2.rotation.x = 20
cyl3 = cylinder.copy()
cyl3.position.x = .3
cyl3.rotation.y = 30
win = pyglet.window.Window(fullscreen=True)
scene = rc.Scene(meshes=[cylinder, cyl2, cyl3], bgColor=(0, 0, 0), camera=rc.Camera(projection=rc.OrthoProjection(coords='relative')))
fps_label = pyglet.window.FPSDisplay(window=win)
@win.event
def on_draw():
with rc.default_shader:
scene.draw()
fps_label.draw()
#
def update(dt):
cylinder.rotation.x += 100 * dt
cyl2.rotation.y += 100 * dt
cyl3.rotation.z += 100 * dt
pyglet.clock.schedule(update)
final_color = vec4(vec3(brightness), 1.) ;
}
"""
shader = rc.Shader(vert=vert_shader, frag=frag_shader)
plane = rc.WavefrontReader(rc.resources.obj_primitives).get_mesh(
'Plane') #gen_fullscreen_quad()
plane.scale.xyz = .2
plane.position.xyz = 0, 0, -1
plane.uniforms['theta'] = 0.
plane.uniforms['width'] = .01
window = pyglet.window.Window(fullscreen=True)
scene = rc.Scene(meshes=[plane],
bgColor=(.5, .5, .5),
camera=rc.Camera(projection=rc.OrthoProjection()))
# Draw Function
@window.event
def on_draw():
with shader:
scene.draw()
def update(dt):
plane.uniforms['theta'] += dt * 7.
pyglet.clock.schedule(update)
def debug_view(vertices, texcoord, image=None, window_size=(800, 600)):
# creates the window and sets its properties
width, height = window_size
window = pyglet.window.Window(width=width,
height=height,
caption='Debug Viewer',
resizable=False)
num_verts = 3 * vertices.shape[0]
model = ratcave.Mesh(arrays=(vertices.reshape(num_verts, 3),
texcoord.reshape(num_verts, 2)))
model.position.xyz = 0, 0, -10
if image is not None:
image = image.transpose(PIL.Image.FLIP_TOP_BOTTOM)
imgdata = pyglet.image.ImageData(image.width, image.height, 'RGBA',
image.tobytes())
mipmap = False
tex = imgdata.get_mipmapped_texture(
) if mipmap else imgdata.get_texture()
pyglet.gl.glBindTexture(pyglet.gl.GL_TEXTURE_2D, 0)
model.textures.append(
ratcave.Texture(id=tex.id, data=tex, mipmap=mipmap))
scene = ratcave.Scene(meshes=[model])
scene.camera.projection = ratcave.PerspectiveProjection(60.0,
width /
float(height),
z_far=100.0)
def update(dt):
pass
pyglet.clock.schedule(update)
shader = ratcave.Shader(vert=vert_shader, frag=frag_shader)
@window.event
def on_resize(width, height):
# TODO update scene.camera.projection.viewport
scene.camera.projection.aspect = width / float(height)
return pyglet.event.EVENT_HANDLED
@window.event
def on_draw():
with shader:
scene.draw()
@window.event
def on_mouse_scroll(x, y, scroll_x, scroll_y):
# scroll the MOUSE WHEEL to zoom
scene.camera.position.z -= scroll_y / 10.0
@window.event
def on_mouse_drag(x, y, dx, dy, button, modifiers):
# press the LEFT MOUSE BUTTON to rotate
if button == pyglet.window.mouse.LEFT:
model.rotation.y += dx / 5.0
model.rotation.x -= dy / 5.0
# press the LEFT and RIGHT MOUSE BUTTONS simultaneously to pan
if button == pyglet.window.mouse.LEFT | pyglet.window.mouse.RIGHT:
scene.camera.position.x -= dx / 100.0
scene.camera.position.y -= dy / 100.0
# starts the application
pyglet.app.run()
def main():
#gettign positions of rigib bodies in real time
client = NatClient()
arena_rb = client.rigid_bodies['Arena']
rat_rb = client.rigid_bodies['Rat']
window = pyglet.window.Window(resizable=True, fullscreen=True, screen=get_screen(1)) # Opening the basic pyglet window
# Load Arena
remove_image_lines_from_mtl('assets/3D/grass_scene.mtl')
arena_filename = 'assets/3D/grass_scene.obj'# we are taking an arena which has been opened in blender and rendered to 3D after scanning it does not have flipped normals
arena_reader = rc.WavefrontReader(arena_filename) # loading the mesh of the arena thought a wavefrontreader
arena = arena_reader.get_mesh("Arena", position=arena_rb.position) # making the wafrotn into mesh so we can extrude texture ont top of it.
arena.uniforms['diffuse'] = 1., 1., 1. # addign a white diffuse material to the arena
arena.rotation = arena.rotation.to_quaternion() # we also need to get arena's rotation not just xyz so it can be tracked and moved if it gets bumped
# Load the projector as a Ratcave camera, set light to its position
projector = rc.Camera.from_pickle('assets/3D/projector.pkl') # settign the pickle filled of the projector, which gives us the coordinates of where the projector is
projector.position.x += .004
projector.projection = rc.PerspectiveProjection(fov_y =40.5, aspect=1.777777778)
light = rc.Light(position=projector.position)
## Make Virtual Scene ##
fields = []
for x, z in itertools.product([-.8, 0, .8], [-1.6, 0, 1.6]):
field = load_textured_mesh(arena_reader, 'grass', 'grass.png')
field.position.x += x
field.position.z += z
fields.append(field)
ground = load_textured_mesh(arena_reader, 'Ground', 'dirt.png')
sky = load_textured_mesh(arena_reader, 'Sky', 'sky.png')
snake = load_textured_mesh(arena_reader, 'Snake', 'snake.png')
rat_camera = rc.Camera(projection=rc.PerspectiveProjection(aspect=1, fov_y=90, z_near=.001, z_far=10), position=rat_rb.position) # settign the camera to be on top of the rats head
meshes = [ground, sky, snake] + fields
for mesh in meshes:
mesh.uniforms['diffuse'] = 1., 1., 1.
mesh.uniforms['flat_shading'] = False
mesh.parent = arena
virtual_scene = rc.Scene(meshes=meshes, light=light, camera=rat_camera, bgColor=(0, 0, 255)) # seetign aset virtual scene to be projected as the mesh of the arena
virtual_scene.gl_states.states = virtual_scene.gl_states.states[:-1]
## Make Cubemapping work on arena
cube_texture = rc.TextureCube(width=4096, height=4096) # usign cube mapping to import eh image on the texture of the arena
framebuffer = rc.FBO(texture=cube_texture) ## creating a fr`amebuffer as the texture - in tut 4 it was the blue screen
arena.textures.append(cube_texture)
# Stereo
vr_camgroup = rc.StereoCameraGroup(distance=.05)
vr_camgroup.rotation = vr_camgroup.rotation.to_quaternion()
# updating the posiotn of the arena in xyz and also in rotational perspective
def update(dt):
"""main update function: put any movement or tracking steps in here, because it will be run constantly!"""
vr_camgroup.position, vr_camgroup.rotation.xyzw = rat_rb.position, rat_rb.quaternion # setting the actual osiont of the rat camera to vbe of the rat position
arena.uniforms['playerPos'] = rat_rb.position
arena.position, arena.rotation.xyzw = arena_rb.position, arena_rb.quaternion
arena.position.y -= .02
pyglet.clock.schedule(update) # making it so that the app updates in real time
@window.event
def on_draw():
## Render virtual scene onto cube texture
with framebuffer:
with cube_shader:
for mask, camside in zip([(True, False, False, True), (False, True, True, True)], [vr_camgroup.left, vr_camgroup.right]):
gl.glColorMask(*mask)
virtual_scene.camera.position.xyz = camside.position_global
virtual_scene.draw360_to_texture(cube_texture)
## Render real scene onto screen
gl.glColorMask(True, True, True, True)
window.clear()
with cube_shader: # usign cube shader to create the actuall 6 sided virtual cube which gets upated with position and angle of the camera/viewer
rc.clear_color(255, 0, 0)
# why is it here 39? e
with projector, light:
arena.draw()
# actually run everything.
pyglet.app.run()
# Create Window and Add Keyboard State Handler to it's Event Loop
window = pyglet.window.Window()
keys = key.KeyStateHandler()
window.push_handlers(keys)
# Insert filename into WavefrontReader.
obj_filename = "3D.obj"
obj_reader = rc.WavefrontReader(obj_filename)
# Create Mesh
Object = obj_reader.get_mesh("3D.obj", position=(0, -0.4, -3), scale=.6)
#create camera
# Create Scene
scene = rc.Scene(meshes=[Object])
# Functions to Run in Event Loop
def rotate_meshes(dt):
Object.rotation.y += 0 * dt # dt is the time between frames
pyglet.clock.schedule(rotate_meshes)
def move_camera(dt):
#camera_speed = 3
if keys[key.LEFT]:
#scene.camera.position.y -= camera_speed * dt
Object.rotation.y -= 17 * dt
def lerp(vecA, vecB, time):
'''
Linear interpolation between two vectors.
Function from pyGameMath: https://github.com/explosiveduck/pyGameMath
'''
return (vecA * time) + (vecB * (1.0 - time))
win = pyglet.window.Window()
reader = rc.WavefrontReader(rc.resources.obj_primitives)
mesh = reader.get_mesh('MonkeySmooth', position=(0, 0, -2), scale=.2)
scene = rc.Scene(meshes=[mesh],
bgColor=(0.5, 0, 0),
camera=rc.Camera(projection=rc.OrthoProjection()))
fps_label = pyglet.window.FPSDisplay(window=win)
@win.event
def on_draw():
with rc.default_shader:
scene.draw()
fps_label.draw()
def animation_sequence(mesh, nframes=50):
verts_orig = mesh.arrays[0][:, :3].copy()
verts_normed = (verts_orig.T / np.linalg.norm(verts_orig, axis=1)).T
{
final_color = vec4(diffuse, 1.);
}
"""
shader = rc.Shader(vert=vert_shader, frag=frag_shader)
# Create window and OpenGL context (always must come first!)
window = pyglet.window.Window()
# Load Meshes and put into a Scene
obj_reader = rc.WavefrontReader(rc.resources.obj_primitives)
torus = obj_reader.get_mesh('Torus', position=(0, 0, -2))
torus.uniforms['diffuse'] = [.5, .0, .8]
scene = rc.Scene(meshes=[torus])
# Constantly-Running mesh rotation, for fun
def update(dt):
torus.rotation.y += 20. * dt
pyglet.clock.schedule(update)
def update_color(dt):
torus.uniforms['diffuse'][0] = 0.5 * math.sin(time.clock() * 30) + .5
pyglet.clock.schedule(update_color)
from psychopy import visual, event
import ratcave as rc
import numpy as np
from numpy.random import random
n_points = 1000
width, height = 0.2, 0.5
theta = random(n_points) * np.pi * 2
verts = np.vstack((np.sin(theta) * width, (random(n_points) - .5) * height,
np.cos(theta) * width)).T
cylinder = rc.Mesh.from_incomplete_data(verts,
drawmode=rc.gl.GL_POINTS,
position=(0, 0, -2),
point_size=2,
mean_center=False)
cylinder.uniforms['diffuse'] = 1., 1., 1.
cylinder.uniforms['flat_shading'] = True
scene = rc.Scene(meshes=[cylinder], bgColor=(0., 0, 0))
scene.camera.projection = rc.OrthoProjection()
win = visual.Window()
while 'escape' not in event.getKeys():
cylinder.rotation.y += .02
with rc.default_shader:
scene.draw()
win.flip()
width, height = 0.2, 0.5
theta = random(n_points) * np.pi * 2
verts = np.vstack((np.sin(theta) * width, (random(n_points) - .5) * height,
np.cos(theta) * width)).T
cylinder = rc.Mesh.from_incomplete_data(verts,
position=(0, 0, -2),
mean_center=False,
drawmode=rc.gl.GL_POINTS,
point_size=.02)
cylinder.uniforms['diffuse'] = 1., 1., 1.
cylinder.uniforms['flat_shading'] = True
cylinder.rotation.x = 20
scene = rc.Scene(meshes=[cylinder],
bgColor=(0., 0, 0),
camera=rc.Camera(projection=rc.OrthoProjection()))
win = pyglet.window.Window(fullscreen=True)
fps_label = pyglet.window.FPSDisplay(window=win)
@win.event
def on_draw():
with rc.default_shader:
scene.draw()
fps_label.draw()
def update(dt):
cylinder.rotation.y += 100 * dt
