Пример #1
0
def build_door(config, key):
    center = mid(config.base_left, config.base_right)

    # left
    glPushMatrix()

    left_vertices = quad(config.base_left, center, config.height)

    with_tail_edges, no_tail_edges = make_edges(left_vertices, 0)
    with_tail_surfaces, no_tail_surfaces = make_surface(left_vertices, 0)

    left_edges = with_tail_edges
    left_surfaces = with_tail_surfaces

    glTranslate(config.base_left[0], config.base_left[1], config.base_left[2])
    glRotatef(config.alpha, 0, 1, 0)
    glTranslate(-config.base_left[0], -config.base_left[1],
                -config.base_left[2])

    draw_object(
        DrawableObject(left_surfaces, left_vertices, left_edges, 'door'),
        DataUtil.textures_id['door'])

    # build(left_edges, left_vertices, left_surfaces)

    if config.run:
        if config.state:
            config.alpha += delta_rotate
            if config.alpha >= limit_door[1] or config.alpha <= limit_door[0]:
                door_conf[key[0]][key[1]].run_reverse()
                door_conf[key[0]][key[1]].state_reverse()
        else:
            config.alpha -= delta_rotate
            if config.alpha >= limit_door[1] or config.alpha <= limit_door[0]:
                door_conf[key[0]][key[1]].run_reverse()
                door_conf[key[0]][key[1]].state_reverse()

    glPopMatrix()

    # right
    glPushMatrix()
    right_vertices = quad(config.base_right, center, config.height)

    with_tail_edges, no_tail_edges = make_edges(right_vertices, 0)
    with_tail_surfaces, no_tail_surfaces = make_surface(right_vertices, 0)

    right_edges = with_tail_edges
    right_surfaces = with_tail_surfaces

    glTranslate(config.base_right[0], config.base_right[1],
                config.base_right[2])
    glRotatef(-config.alpha, 0, 1, 0)
    glTranslate(-config.base_right[0], -config.base_right[1],
                -config.base_right[2])

    draw_object(
        DrawableObject(right_surfaces, right_vertices, right_edges, 'door'),
        DataUtil.textures_id['door'])
    # build(right_edges, right_vertices, right_surfaces)
    glPopMatrix()
Пример #2
0
def build_block_plain(center, l, d, notify=False, parent=None, t='ground1'):
    vertices = (
        (center[0] - l / 2, center[1], center[2] - d / 2),
        (center[0] - l / 2, center[1], center[2] + d / 2),
        (center[0] + l / 2, center[1], center[2] + d / 2),
        (center[0] + l / 2, center[1], center[2] - d / 2),
    )

    if notify:
        print('plain', vertices)

    with_tail_edges, no_tail_edges = make_edges(vertices,
                                                len(DataUtil.vertices))
    with_tail_surfaces, no_tail_surfaces = make_surface(
        vertices, len(DataUtil.vertices))

    DataUtil.edges += with_tail_edges
    DataUtil.surfaces += with_tail_surfaces
    DataUtil.vertices += vertices

    valid_points(DataUtil.vertices, 3, 'plain')
    valid_edges(DataUtil.edges, DataUtil.vertices, 'plain')
    if parent is not None:
        parent.vertices += vertices
        parent.edges += no_tail_edges
        parent.surfaces = no_tail_surfaces
        return parent

    return DrawableObject(no_tail_surfaces, vertices, no_tail_edges, t)
Пример #3
0
def build_plain(origin, end, d, parent=None):
    vertices = (
        origin,
        (origin[0], origin[1], origin[2] + d),
        (end[0], end[1], end[2] + d),
        end,
    )
    with_tail_edges, no_tail_edges = make_edges(vertices,
                                                len(DataUtil.vertices))
    with_tail_surfaces, no_tail_surfaces = make_surface(
        vertices, len(DataUtil.vertices))

    DataUtil.edges += with_tail_edges
    DataUtil.surfaces += with_tail_surfaces
    DataUtil.vertices += vertices

    valid_points(DataUtil.vertices, 3, 'plain')
    valid_edges(DataUtil.edges, DataUtil.vertices, 'plain')

    if parent is not None:
        parent.vertices += vertices
        parent.edges += no_tail_edges
        parent.surfaces = no_tail_surfaces
        return parent

    return DrawableObject(no_tail_surfaces, vertices, no_tail_edges, '')
Пример #4
0
def build_top(x_origin, y_origin, z_origin):
    top = []
    vertices = (
        (x_origin + width / 2, y_origin + height + tower_height * 0.2,
         z_origin),
        (x_origin + width / 2, y_origin + height + tower_height * 0.2,
         z_origin + depth),
        (x_origin + width, y_origin + height, z_origin + depth),
        (x_origin + width, y_origin + height, z_origin),
    )
    with_tail_edges, no_tail_edges = make_edges(vertices,
                                                len(DataUtil.vertices))
    with_tail_surfaces, no_tail_surfaces = make_surface(
        vertices, len(DataUtil.vertices))

    DataUtil.edges += with_tail_edges
    DataUtil.surfaces += with_tail_surfaces
    DataUtil.vertices += vertices
    top.append(DrawableObject(no_tail_surfaces, vertices, no_tail_edges,
                              'top'))

    vertices = (
        (x_origin + width / 2, y_origin + height + tower_height * 0.2,
         z_origin),
        (x_origin + width / 2, y_origin + height + tower_height * 0.2,
         z_origin + depth),
        (x_origin, y_origin + height, z_origin + depth),
        (x_origin, y_origin + height, z_origin),
    )
    with_tail_edges, no_tail_edges = make_edges(vertices,
                                                len(DataUtil.vertices))
    with_tail_surfaces, no_tail_surfaces = make_surface(
        vertices, len(DataUtil.vertices))

    DataUtil.edges += with_tail_edges
    DataUtil.surfaces += with_tail_surfaces
    DataUtil.vertices += vertices

    top.append(DrawableObject(no_tail_surfaces, vertices, no_tail_edges,
                              'top'))

    valid_points(DataUtil.vertices, 3, 'top')
    valid_edges(DataUtil.edges, DataUtil.vertices, 'top')
    return top
Пример #5
0
def build_any_plain(vertices, notify=False, parent=None, t='table'):
    if notify:
        print('plain', vertices)

    with_tail_edges, no_tail_edges = make_edges(vertices,
                                                len(DataUtil.vertices))
    with_tail_surfaces, no_tail_surfaces = make_surface(
        vertices, len(DataUtil.vertices))

    DataUtil.edges += with_tail_edges
    DataUtil.surfaces += with_tail_surfaces
    DataUtil.vertices += vertices

    valid_points(DataUtil.vertices, 3, 'plain')
    valid_edges(DataUtil.edges, DataUtil.vertices, 'plain')
    if parent is not None:
        parent.vertices += vertices
        parent.edges += no_tail_edges
        parent.surfaces = no_tail_surfaces
        return parent
    return DrawableObject(no_tail_surfaces, vertices, no_tail_edges, t)
Пример #6
0
def build_arc_wall(arc_center,
                   top_origin,
                   top_end,
                   radius,
                   x_or_z,
                   h,
                   parent=None,
                   t=''):
    vertices = (top_origin, top_end)

    for i in range(180, 360):
        rad = math.pi * i / 180
        x = arc_center[0] + radius * math.cos(rad) if x_or_z else arc_center[0]
        y = arc_center[1] + radius * math.sin(rad)
        z = arc_center[2] if x_or_z else arc_center[2] + radius * math.cos(rad)
        vertices += ((x, y, z), )

    with_tail_edges, no_tail_edges = make_edges(vertices,
                                                len(DataUtil.vertices))
    with_tail_surfaces, no_tail_surfaces = make_surface(
        vertices, len(DataUtil.vertices))

    DataUtil.edges += with_tail_edges
    DataUtil.surfaces += with_tail_surfaces
    DataUtil.vertices += vertices

    if parent is not None:
        parent.vertices += vertices
        parent.edges += no_tail_edges
        parent.surfaces = no_tail_surfaces
        return parent

    return DrawableObject(no_tail_surfaces,
                          vertices,
                          no_tail_edges,
                          type_name=t)
Пример #7
0
def build_wall(origin, end, h, notify=False, type_name="wall", parent=None):
    vertices = quad(origin, end, h)
    if notify:
        print('wall', vertices)

    with_tail_edges, no_tail_edges = make_edges(vertices,
                                                len(DataUtil.vertices))
    with_tail_surfaces, no_tail_surfaces = make_surface(
        vertices, len(DataUtil.vertices))

    DataUtil.edges += with_tail_edges
    DataUtil.surfaces += with_tail_surfaces
    DataUtil.vertices += vertices

    valid_points(DataUtil.vertices, 3, 'wall')
    valid_edges(DataUtil.edges, DataUtil.vertices, 'wall')

    if parent is not None:
        parent.vertices += vertices
        parent.edges += no_tail_edges
        parent.surfaces = no_tail_surfaces
        return parent

    return DrawableObject(no_tail_surfaces, vertices, no_tail_edges, type_name)