예제 #1
0
파일: _test.py 프로젝트: hotgloupi/8cube
 def test_fill_rect_rgb(self):
     s = Surface(100, 100)
     s.fill_rect(gl.recti(0, 0, 10, 10), gl.col3f("red"))
     s.fill_rect(gl.recti(0, 90, 10, 100), gl.col3f("green"))
     s.fill_rect(gl.recti(90, 0, 100, 10), gl.col3f("blue"))
     s.fill_rect(gl.recti(90, 90, 100, 100), gl.col3f("white"))
     self._compare_surface(s, "test_fill_rect_rgb")
예제 #2
0
파일: mesh.py 프로젝트: hotgloupi/8cube
 def __init__(self):
     self.window = cube.system.create_window("Test mesh", 640, 480, cube.gl.renderer.Name.OpenGL)
     w = h = 1
     m = Mesh()
     m.mode = Mode.quads
     m.append(
         Kind.vertex,
         vec3f(0, 0, 0),
         vec3f(w, 0, 0),
         vec3f(w, 0, h),
         vec3f(0, 0, h),
         # vec3f(w, h, 0),
         # vec3f(-w, h, 0),
         # vec3f(-w, -h, 0),
         # vec3f(w, -h, 0),
         Kind.color,
         col3f("whitesmoke"),
         col3f("whitesmoke"),
         col3f("whitesmoke"),
         col3f("#000042"),
     )
     print(m)
     r = self.window.renderer
     self.view = m.view(r)
     self.shader = r.new_shader_program(
         [r.new_vertex_shader([vertex_shader]), r.new_fragment_shader([fragment_shader])]
     )
     self.running = False
     self.window.inputs.on_quit.connect(self.stop)
     self.window.inputs.on_resize.connect(self._on_resize)
     self.window.poll()
     self._on_resize(640, 480)
예제 #3
0
def create(game):
    mat = gl.Material('ground')
    mat.ambient = gl.col3f('black')
    mat.diffuse = gl.col3f('brown')
    mat.specular = gl.col3f('gray')
    mat.shininess = 1000
    mat.shading_model = gl.material.ShadingModel.gouraud
    mat.add_texture("ground.bmp", gl.TextureType.ambient, gl.TextureMapping.uv,
                    gl.StackOperation.add, gl.TextureMapMode.wrap,
                    gl.BlendMode.basic)
    mesh = gl.Mesh()
    mesh.mode = gl.DrawMode.quads
    size = 40
    step = 1.0 / size
    for i in (i / size for i in range(size)):
        x = i
        for j in (i / size for i in range(size)):
            y = 1.0 - j
            mesh.kind = gl.ContentKind.vertex
            mesh.append(gl.vec3f(x, y, 0))
            mesh.append(gl.vec3f(x, y - step, 0))
            mesh.append(gl.vec3f(x + step, y - step, 0))
            mesh.append(gl.vec3f(x + step, y, 0))
            mesh.kind = gl.ContentKind.tex_coord0
            mesh.append(gl.vec2f(i, j))
            mesh.append(gl.vec2f(i, j + step))
            mesh.append(gl.vec2f(i + step, j + step))
            mesh.append(gl.vec2f(i + step, j))
            mesh.kind = gl.ContentKind.normal
            mesh.append(gl.vec3f(0, 0, 1))
            mesh.append(gl.vec3f(0, 0, 1))
            mesh.append(gl.vec3f(0, 0, 1))
            mesh.append(gl.vec3f(0, 0, 1))
    light = game.renderer.new_light(
        gl.PointLightInfo(
            gl.vec3f(0, 2, -1),
            gl.Color3f("#888"),
            gl.Color3f("#333"),
        ))
    ground = game.entity_manager.create("ground")
    ground.add_component(
        cubeapp.game.entity.component.Transform(
            gl.matrix.rotate(
                gl.matrix.translate(gl.matrix.scale(gl.mat4f(), gl.vec3f(20)),
                                    gl.vec3f(-.5, 0, 0)), units.deg(-90),
                gl.vec3f(1, 0, 0))))
    ground.add_component(cubeapp.game.entity.component.Bindable(mat))
    ground.add_component(cubeapp.game.entity.component.Drawable(mesh))
    return ground
예제 #4
0
파일: renderer.py 프로젝트: hotgloupi/8cube
 def __init__(self, renderer):
     self.renderer = renderer
     self.__materials = {}
     for lod in range(8):
         mat = gl.Material('ground-%s' % lod)
         mat.ambient = gl.col3f('#' + ('%s' % (lod + 1)) * 3)
         self.__materials[lod] = mat.bindable(renderer)
     mesh = gl.Mesh()
     mesh.mode = gl.DrawMode.quads
     size = 16
     step = 1.0 / size
     for i in (i / size for i in range(size)):
         x = i
         for j in (i / size for i in range(size)):
             y = 1.0 - j
             mesh.kind = gl.ContentKind.vertex
             mesh.append(gl.vec3f(x, 0, y - step))
             mesh.append(gl.vec3f(x, 0, y))
             mesh.append(gl.vec3f(x + step, 0, y))
             mesh.append(gl.vec3f(x + step, 0, y - step))
             mesh.kind = gl.ContentKind.tex_coord0
             mesh.append(gl.vec2f(i, j + step))
             mesh.append(gl.vec2f(i + step, j + step))
             mesh.append(gl.vec2f(i + step, j))
             mesh.append(gl.vec2f(i, j))
             mesh.kind = gl.ContentKind.normal
             mesh.append(gl.vec3f(0, 1, 0))
             mesh.append(gl.vec3f(0, 1, 0))
             mesh.append(gl.vec3f(0, 1, 0))
             mesh.append(gl.vec3f(0, 1, 0))
     self.mesh = mesh.drawable(self.renderer)
     self.__chunks = {}
예제 #5
0
def create(game, x, z):
    mat = gl.Material('player')
    mat.ambient = gl.col3f('#100')
    mat.diffuse = gl.col3f('#f55')
    mat.specular = gl.col3f('#f00')
    mat.shininess = .5
    mat.shading_model = gl.material.ShadingModel.gouraud

    mesh = gl.Spheref(gl.vec3f(0), 1).drawable(game.renderer)

    entity = game.entity_manager.create('Darkling')
    transform = entity.add_component(
        Transform(gl.matrix.translate(gl.mat4f(), gl.vec3f(x, 1, z))))
    entity.add_component(Bindable(mat))
    entity.add_component(Drawable(mesh))
    return entity
예제 #6
0
def create(game, x, z):
    mat = gl.Material('player')
    mat.ambient = gl.col3f('#100')
    mat.diffuse = gl.col3f('#f55')
    mat.specular = gl.col3f('#f00')
    mat.shininess = .5
    mat.shading_model = gl.material.ShadingModel.gouraud

    mesh = gl.Spheref(gl.vec3f(0), 1).drawable(game.renderer)

    entity = game.entity_manager.create('Darkling')
    transform = entity.add_component(
        Transform(gl.matrix.translate(gl.mat4f(), gl.vec3f(x, 1, z)))
    )
    entity.add_component(Bindable(mat))
    entity.add_component(Drawable(mesh))
    return entity
예제 #7
0
    def __call__(self, ev, delta):
        tiles = pos_to_tiles(self.board, ev.new, ev.player.radius)
        ev.player.force = gl.vec3f(0)
        self.current_tiles = tiles
        colliding = []
        for tile in tiles:
            controllers = self.cells.get(tile, [])
            for controller in controllers:
                controller(self.board, tile, ev.player, colliding)

        for tile in self.last_colliding:
            if tile not in colliding:
                self.cells.get(tile)[0].prepare(self.board, tile)
        self.last_colliding = colliding
        tile_w, tile_h = self.board.tile_width, self.board.tile_height
        border = gl.vec2f(self.board.border, self.board.border)
        for i, tile in enumerate(colliding):
            self.cells.get(tile)[0].set_color(self.board, tile, gl.col3f('purple'))
            tile_pos = gl.vec2f(tile.x * tile_w, tile.y * tile_h) + border
            print("PIF!", i, ev.new, tile, tile_pos, self.board.border,
                  tile_w, tile_h)
            if ev.new.x >= tile_pos.x and \
               ev.new.x < tile_pos.x + tile_w:
                if ev.new.y + ev.player.radius >= tile_pos.y \
                   and ev.new.y < tile_pos.y + tile_h:
                    print("YEAH!", i, ev.new, tile, tile_pos, self.board.border,
                          tile_w, tile_h)
                    if ev.player.velocity.y > 0:
                        ev.player.velocity.y *= -.5
                    if abs(ev.player.velocity.y) < 50:
                        ev.player.force = -ev.player.gravity
                        ev.player.velocity.y = 0
                        ev.player.velocity.x *= .9
                        if abs(ev.player.velocity.x) < 5:
                            ev.player.velocity.x = 0
                    ev.player.pos.y = tile_pos.y - ev.player.radius
                elif ev.new.y - ev.player.radius <= tile_pos.y + tile_h and \
                     ev.new.y > tile_pos.y:
                    print("BIM")
                    if ev.player.velocity.y < 0:
                        ev.player.velocity.y *= -1
                    ev.player.pos.y = tile_pos.y + tile_h + ev.player.radius
            if ev.new.y >= tile_pos.y and \
               ev.new.y < tile_pos.y + tile_h:
                if ev.new.x > ev.old.x and \
                   ev.new.x + ev.player.radius >= tile_pos.x and \
                   ev.new.x < tile_pos.x + tile_w:
                    if ev.player.velocity.x > 0:
                        ev.player.velocity.x *= -.9
                    ev.player.pos.x = tile_pos.x - ev.player.radius
                elif ev.new.x - ev.player.radius <= tile_pos.x + tile_w and \
                     ev.new.x > tile_pos.x:
                    if ev.player.velocity.x < 0:
                        ev.player.velocity.x *= -.9
                    ev.player.pos.x = tile_pos.x + tile_w + ev.player.radius
예제 #8
0
 def test_update_ambiant(self, painter):
     material = Material()
     material.ambiant = gl.col3f(1,0,0)
     mesh = gl.Spheref(gl.vec3f(0), 1).drawable(self.renderer)
     painter.state.look_at(
         gl.vec3f(0, .8, 10), gl.vec3f(0, 0, 0), gl.vec3f(0, 1, 0)
     )
     painter.state.perspective(
         angle.deg(35), 200 / 200, 0.005, 30.0
     )
     bindable = material.bindable(self.renderer)
     s = painter.push_state()
     s.translate(1, 0, 0)
     with painter.bind([bindable]):
         painter.draw([mesh])
     painter.pop_state()
     s = painter.push_state()
     s.translate(-1, 0, 0)
     material.ambiant = gl.col3f(0, 1, 1)
     with painter.bind([bindable]):
         painter.draw([mesh])
예제 #9
0
파일: game.py 프로젝트: hotgloupi/8cube
    def create_cube(self):
        mat = gl.Material('cube')
        mat.ambient = gl.col3f('#100')
        mat.diffuse = gl.col3f('#f55')
        mat.specular = gl.col3f('#f00')
        mat.shininess = 5
        mat.shading_model = gl.material.ShadingModel.gouraud


        mesh =  cube.gl.Cube3f(cube.gl.vec3f(), 1).drawable(self.renderer)

        entity = self.entity_manager.create('Cube')
        transform = entity.add_component(
            Transform(gl.matrix.scale(gl.mat4f(), gl.vec3f(4)))
        )
        entity.add_component(Bindable(mat))
        entity.add_component(Drawable(mesh))
        class Animate:
            channels = ['tick']
            velocity = 10
            def __call__(self, ev, delta):
                transform.node.rotate(units.deg(45) * delta * self.velocity, gl.vec3f(1, .5, 0))
        entity.add_component(Controller(Animate()))
        return entity
예제 #10
0
def create(shape, entity_manager):
    mat = gl.Material('power')
    mat.ambient = gl.col3f('#888')
    mat.diffuse = gl.col3f('#000')
    mat.specular = gl.col3f('#000')
    #mat.shininess = 0
    #mat.shading_model = gl.material.ShadingModel.gouraud
    mat.add_color(
        gl.ShaderParameterType.vec3,
        gl.StackOperation.add
    )
    mesh = gl.Mesh()
    mesh.mode = gl.DrawMode.quads
    mesh.kind = gl.ContentKind.vertex
    mesh.append(gl.vec3f(0, 0, 0))
    mesh.append(gl.vec3f(0, 1, 0))
    mesh.append(gl.vec3f(1, 1, 0))
    mesh.append(gl.vec3f(1, 0, 0))
    mesh.kind = gl.ContentKind.color
    mesh.append(gl.col3f('red'))
    mesh.append(gl.col3f('green'))
    mesh.append(gl.col3f('green'))
    mesh.append(gl.col3f('red'))
    mesh.kind = gl.ContentKind.normal
    mesh.append(gl.vec3f(0, 0, 1))
    mesh.append(gl.vec3f(0, 0, 1))
    mesh.append(gl.vec3f(0, 0, 1))
    mesh.append(gl.vec3f(0, 0, 1))
    power = entity_manager.create('power', shape = shape)

    transform = power.add_component(Transform(power_matrix(shape)))
    power.add_component(Bindable(mat))
    power.add_component(Drawable(mesh))

    refill = Controller(Refill(power))

    def start_power(ev, delta):
        power.add_component(refill)
    power.add_component(Controller(start_power, ['start-power']))

    def stop_power(ev, delta):
        power.remove_component(refill)
        power.shape.h = 1
        transform.node.value = power_matrix(power.shape)
    power.add_component(Controller(stop_power, ['stop-power']))

    return power
예제 #11
0
def create(game):
    mat = gl.Material('ground')
    mat.ambient = gl.col3f('black')
    mat.diffuse = gl.col3f('brown')
    mat.specular = gl.col3f('gray')
    mat.shininess = 1000
    mat.shading_model = gl.material.ShadingModel.gouraud
    mat.add_texture(
        "ground.bmp",
        gl.TextureType.ambient,
        gl.TextureMapping.uv,
        gl.StackOperation.add,
        gl.TextureMapMode.wrap,
        gl.BlendMode.basic
    )
    mesh = gl.Mesh()
    mesh.mode = gl.DrawMode.quads
    size = 40
    step = 1.0 / size
    for i in (i / size for i in range(size)):
        x = i
        for j in (i / size for i in range(size)):
            y = 1.0 - j
            mesh.kind = gl.ContentKind.vertex
            mesh.append(gl.vec3f(x, y, 0))
            mesh.append(gl.vec3f(x, y - step, 0))
            mesh.append(gl.vec3f(x + step, y - step, 0))
            mesh.append(gl.vec3f(x + step, y, 0))
            mesh.kind = gl.ContentKind.tex_coord0
            mesh.append(gl.vec2f(i, j))
            mesh.append(gl.vec2f(i, j + step))
            mesh.append(gl.vec2f(i + step, j + step))
            mesh.append(gl.vec2f(i + step, j))
            mesh.kind = gl.ContentKind.normal
            mesh.append(gl.vec3f(0, 0, 1))
            mesh.append(gl.vec3f(0, 0, 1))
            mesh.append(gl.vec3f(0, 0, 1))
            mesh.append(gl.vec3f(0, 0, 1))
    light = game.renderer.new_light(
        gl.PointLightInfo(
            gl.vec3f(0, 2, -1),
            gl.Color3f("#888"),
            gl.Color3f("#333"),
        )
    )
    ground = game.entity_manager.create("ground")
    ground.add_component(
        cubeapp.game.entity.component.Transform(
            gl.matrix.rotate(
                gl.matrix.translate(
                    gl.matrix.scale(gl.mat4f(), gl.vec3f(20)),
                    gl.vec3f(-.5, 0, 0)
                ),
                units.deg(-90),
                gl.vec3f(1, 0, 0)
            )
        )
    )
    ground.add_component(
        cubeapp.game.entity.component.Bindable(mat)
    )
    ground.add_component(
        cubeapp.game.entity.component.Drawable(mesh)
    )
    return ground
예제 #12
0
 def rand_color():
     import random
     return gl.col3f(random.random(), random.random(), random.random())
예제 #13
0
 def rand_color():
     import random
     return gl.col3f(random.random(), random.random(), random.random())
예제 #14
0
def create(game, size, border, tile_width, tile_height, rows):
    mat = gl.Material('ground')
    mat.ambient = gl.col3f('#888')
    mat.diffuse = gl.col3f('#000')
    mat.specular = gl.col3f('#000')
    #mat.shininess = 0
    #mat.shading_model = gl.material.ShadingModel.gouraud
    mat.add_color(
        gl.ShaderParameterType.vec3,
        gl.StackOperation.add
    )
    coords = []
    colors = []
    indices = list(range(size.x * size.y * 4))
    for i in range(size.x):
        x = i * tile_width + border
        for j in range(size.y):
            y = j * tile_height + border
            coords.extend([
                gl.vec3f(x, y, 0),
                gl.vec3f(x, y + tile_height, 0),
                gl.vec3f(x + tile_width, y + tile_height, 0),
                gl.vec3f(x + tile_width, y, 0),
            ])
            colors.extend([
                gl.col3f('#356712'),
                gl.col3f('#356712'),
                gl.col3f('#356712'),
                gl.col3f('#356712'),
            ])
    ground_vb = game.renderer.new_vertex_buffer([
        gl.make_vba(
            gl.ContentKind.vertex,
            coords,
            gl.ContentHint.static_content
        ),
        gl.make_vba(
            gl.ContentKind.color,
            colors,
            gl.ContentHint.static_content
        )
    ])
    ground_ib = game.renderer.new_index_buffer(
        gl.make_vba(
            gl.ContentKind.index,
            indices,
            gl.ContentHint.static_content
        )
    )
    # Set initial color
    #colors_attr = ground_vb[1]
    #colors_attr[0] = gl.col3f('blue')
    #colors_attr[1] = gl.col3f('blue')
    #ground_vb.reload(1)

    board = game.entity_manager.create(
        'board',
        ib = ground_ib,
        vb = ground_vb,
        size = size,
        tile_height = tile_height,
        tile_width = tile_width,
        border = border,
        rows = rows,
        event_manager = game.event_manager,
    )
    transform = board.add_component(
        Transform(
            gl.matrix.translate(
                #gl.matrix.scale(
                   gl.mat4f(),
                #    gl.vec3f(size, size, 1)
                #),
                gl.vec3f(-.5, -.5, 0)
            )
        )
    )
    board.add_component(Bindable(mat))
    board.add_component(Drawable(DrawGround(board, len(indices))))
    board.add_component(Controller(CellManager(board = board)))

    return board
예제 #15
0
        board.event_manager.push(
            Event('set-board-friction',  friction = self.friction)
        )

class Wall:
    def prepare(self, board, tile):
        pass

    def __call__(self, board, tile, player, colliding):
        colliding.append(tile)

# Mapping between ascii codes and controllers
# Multiple controllers can be set per character, their __call__ method will
# be triggered whenever the player cross a particular cell.
cell_controllers = {
    '@': (Cell(gl.col3f('red')), ),
    '#': (Cell(gl.col3f('white')), Wall()),
    'x': (
        Cell(gl.col3f('#2342ff')),
        SetBoardFriction(friction = 5),
    ),
}

class CellManager(Controller):
    """Centralize all cell controllers"""
    channels = ['player-moved']
    def __init__(self, board):
        self.cells = {}
        self.current_tiles = None
        self.board = board
        y = 0