Exemplo n.º 1
0
    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.active_scene, self.arena, self.arena_rb = utils.load_projected_scene(
            arena_file=arena_objfile,
            projector_file=projector_file,
            motive_client=motive)

        self.orig_texture = None

        self.shader = rc.Shader.from_file(*rc.resources.genShader)
        self._vr_scenes = set()
        self.current_vr_scene = None

        self.rat_rb = motive.rigid_bodies['Rat']

        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:
            pass
            # raise NotImplementedError("Haven't gotten fps_mode to work properly yet.")
        self.fps_mode = fps_mode

        pyglet.clock.schedule(self.update)
Exemplo n.º 2
0
def setup_deferred_rendering():
    """Return (Shader, FBO, QuadMesh) for deferred rendering."""
    fbo = rc.FBO(rc.Texture(width=4096, height=4096, mipmap=True))
    quad = rc.gen_fullscreen_quad("DeferredQuad")
    quad.texture = fbo.texture
    shader = rc.Shader.from_file(*rc.resources.deferredShader)
    return RenderCollection(shader=shader, fbo=fbo, quad=quad)
Exemplo n.º 3
0
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()
Exemplo n.º 4
0
    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)
Exemplo n.º 5
0
monkey.point_size = .1

plane = obj_reader.get_mesh('Plane')
plane.position.xyz = 0, 0, -5
plane.rotation.x = 0
plane.scale.xyz = 8
plane.uniforms['spec_weight'] = 0

fps_display = pyglet.window.FPSDisplay(window)

light = rc.Light()
light.projection.fov_y = 75.
light.position.z = 3
light.time = 0.

fbo_shadow = rc.FBO(texture=rc.DepthTexture(width=2048, height=2048))
plane.textures.append(fbo_shadow.texture)
plane.textures.append(rc.Texture.from_image(rc.resources.img_colorgrid))
monkey.textures.append(fbo_shadow.texture)


@window.event
def on_draw():
    window.clear()
    with ExitStack() as stack:
        for shader in [rc.resources.shadow_shader, rc.default_shader]:
            with shader, rc.default_states, light, rc.default_camera:
                if shader == rc.resources.shadow_shader:
                    stack.enter_context(fbo_shadow)
                    window.clear()
                else:
Exemplo n.º 6
0
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

# Run Display and Update Loops
@window.event
def on_resize(width, height):
    # proj_scene.camera.aspect = width / float(height)
    god_scene.camera.aspect = width / float(height)
    fullscreen_quad.uniforms['frameBufSize'] = float(width), float(height)
Exemplo n.º 7
0
# 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
projected_scene.camera = rc.Camera(position=(0, 4, 0), rotation=(-90, 0, 0))
projected_scene.camera.projection.z_far = 6

# Create Framebuffer and Textures
cube_texture = rc.texture.TextureCube(
    width=1024, height=1024)  # this is the actual cube texture
cube_fbo = rc.FBO(texture=cube_texture)
screen.textures.append(cube_texture)

clock = 0.


def update(dt):
    global clock
    clock += dt
    monkey.position.x = math.sin(1.3 * clock)
    virtual_scene.camera.position.xyz = monkey.position.xyz
    screen.uniforms['playerPos'] = virtual_scene.camera.position.xyz


pyglet.clock.schedule(update)
Exemplo n.º 8
0
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()
Exemplo n.º 9
0
    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)
Exemplo n.º 10
0
import ratcave as rc

win = pyglet.window.Window(resizable=True)

reader = rc.WavefrontReader(rc.resources.obj_primitives)
stars = reader.get_mesh('Torus', drawmode=rc.POINTS)
stars.point_size = 3
stars.uniforms['diffuse'] = 1., 1., 1.
stars.position.xyz = 0, 0, -2
stars.scale.xyz = 1.2

monkey = reader.get_mesh('Monkey', position=(0, 0.1, -2))
monkey.uniforms['flat_shading'] = True
monkey.uniforms['diffuse'] = 1., 1., 1.

fbo = rc.FBO(texture=rc.Texture(width=win.width, height=win.height))


def update(dt):
    stars.rotation.z += 10. * dt


pyglet.clock.schedule(update)


@win.event
def on_draw():

    with rc.default_shader:
        with fbo:
            pyglet.gl.glClearColor(0, 0, 0, 1)
Exemplo n.º 11
0
def vr_demo(motive_filename, projector_filename, arena_filename, body, screen):

    motive.initialize()
    motive_filename = motive_filename.encode()
    motive.load_project(motive_filename)

    body = motive.get_rigid_bodies()[body]
    for el in range(3):
        body.reset_orientation()
        motive.update()
    arena_body = motive.get_rigid_bodies()['Arena']

    # Load projector's Camera object, created from the calib_projector ratcave_utils CLI tool.
    display = pyglet.window.get_platform().get_default_display()
    screen = display.get_screens()[screen]
    window = pyglet.window.Window(fullscreen=False, screen=screen, vsync=False)

    fbo = rc.FBO(rc.TextureCube(width=4096, height=4096))

    shader3d = rc.Shader.from_file(*rc.resources.genShader)

    reader = rc.WavefrontReader(rc.resources.obj_primitives)
    mesh = reader.get_mesh('Monkey', scale=.022, position=(0, 0, .3))
    mesh.position.y = .6
    mesh.uniforms['ambient'] = .15, .15, .15

    # mesh.rotation = mesh.rotation.to_quaternion()

    arena = rc.WavefrontReader(arena_filename.encode()).get_mesh('Arena')
    arena.rotation = arena.rotation.to_quaternion()
    arena.texture = fbo.texture

    floor = reader.get_mesh('Plane',
                            scale=50,
                            position=(0, 0, 0),
                            mean_center=True)

    # floor.scale.x = 20
    floor.rotation.x = -90
    floor.texture = fbo.texture
    # floor.rotation.x = 180

    vr_scene = rc.Scene(meshes=[mesh], bgColor=(0., .3, 0))
    vr_scene.camera.projection.fov_y = 90
    vr_scene.camera.projection.aspect = 1.
    vr_scene.camera.projection.z_near = .005
    vr_scene.camera.projection.z_far = 2.

    fbo_aa = rc.FBO(rc.Texture(width=4096, height=4096, mipmap=True))
    quad = rc.gen_fullscreen_quad()
    quad.texture = fbo_aa.texture
    shader_deferred = rc.Shader.from_file(*rc.resources.deferredShader)

    scene = rc.Scene(meshes=[arena, floor], bgColor=(0., 0., .3))

    camera = rc.Camera.from_pickle(projector_filename.encode())
    camera.projection.fov_y = 39
    scene.camera = camera
    scene.light.position.xyz = camera.position.xyz
    vr_scene.light.position.xyz = camera.position.xyz

    @window.event
    def on_draw():
        with shader3d:
            with fbo:
                vr_scene.camera.projection.match_aspect_to_viewport()
                vr_scene.draw360_to_texture(fbo.texture)
            scene.camera.projection.match_aspect_to_viewport()
            with fbo_aa:

                scene.draw()
        with shader_deferred:
            quad.draw()

    def update_body(dt, body):
        motive.update()
        mesh.position.xyz = arena_body.location
        mesh.position.y -= .07
        # mesh.rotation.xyzw = arena_body.rotation_quats
        # mesh.rotation.y += 10 * dt

        arena.position.xyz = arena_body.location
        arena.rotation.xyzw = arena_body.rotation_quats

        vr_scene.camera.position.xyz = body.location
        scene.camera.uniforms['playerPos'] = body.location

    pyglet.clock.schedule(update_body, body)

    pyglet.app.run()
Exemplo n.º 12
0
)  # seetign aset virtual scene to be projected as the mesh of the arena
virtual_scene.gl_states.states = virtual_scene.gl_states.states[:-1]

checkerboard_texture = rc.Texture.from_image(
    rc.resources.img_uvgrid)  # or 'assets/wood.jpg'
wall.textures.append(checkerboard_texture)
virtual_arena.textures.append(checkerboard_texture)
virtual_arena.uniforms['flat_shading'] = True
wall.uniforms['flat_shading'] = True

## 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)


# 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!"""
    rat_camera.position = rat_rb.position  # 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
    virtual_arena.position, virtual_arena.rotation = arena.position, arena.rotation


pyglet.clock.schedule(update)  # making it so that the app updates in real time