def childrens_playground_swingset(length=2.2, num=2, height=2.1, width=1.6):
"""
"""
frame_thick = 0.06
path = ddd.point([-width / 2, 0], name="Swing path").line_to([-width*2/6, height - width*2/6])
path = path.arc_to([width*2/6, height - width *2/6], [0, height - width*2/6], ccw=False)
path = path.line_to([width / 2, 0])
side_mat = random.choice([ddd.mats.metal_paint_red, ddd.mats.metal_paint_green, ddd.mats.metal_paint_yellow])
frameside = path.buffer(frame_thick / 2).material(side_mat)
frameside = frameside.extrude(frame_thick, center=True).rotate(ddd.ROT_FLOOR_TO_FRONT).rotate(ddd.ROT_TOP_CCW)
frameside = frameside.material(ddd.mats.steel)
frameside = ddd.uv.map_cubic(frameside)
frameside1 = frameside.translate([-length/2, 0, 0])
frameside2 = frameside.translate([length/2, 0, 0])
topbar = ddd.point([(-length + frame_thick) / 2, 0], name="Swing top bar").line_to([(length - frame_thick) / 2, 0])
topbar = topbar.buffer(frame_thick / 2).extrude(frame_thick, center=True).translate([0, 0, height - frame_thick / 4])
topbar = topbar.material(ddd.mats.steel)
topbar = ddd.uv.map_cubic(topbar)
swingset = ddd.group3([frameside1, frameside2, topbar], name="Playground swingset")
for i in range(num):
posx = -length / 2 + (i + 0.5) * (length / (num))
swing = childrens_playground_swing(height=height - 0.4)
swing = swing.translate([posx, 0, height])
swingset.append(swing)
item = swingset
item = ddd.meshops.batch_by_material(item).clean(remove_degenerate=False)
return item
def tap_push(r=0.01, height=0.1, length=0.15):
base = ddd.point(name="Tap").buffer(r, resolution=2)
path = ddd.point().line_to([0, height
]).line_to([length, height
]).line_to([length, height * 0.5])
item = base.extrude_along(path)
item = item.rotate(ddd.ROT_FLOOR_TO_FRONT).rotate(ddd.ROT_TOP_CW)
item = item.material(ddd.mats.steel)
item = ddd.uv.map_cubic(item)
return item
def trafficlights_head(height=0.8, depth=0.3):
head = ddd.rect([-0.15, 0, 0.15, height], name="TrafficLight Box").material(ddd.mats.metal_paint_green).extrude(depth)
disc_green = ddd.disc(ddd.point([0, 0.2]), r=0.09, name="TrafficLight Disc Green").material(ddd.mats.light_green).extrude(0.05)
disc_orange = ddd.disc(ddd.point([0, 0.4]), r=0.09, name="TrafficLight Disc Green").material(ddd.mats.light_orange).extrude(0.05)
disc_red = ddd.disc(ddd.point([0, 0.6]), r=0.09, name="TrafficLight Disc Green").material(ddd.mats.light_red).extrude(0.05)
discs = ddd.group([disc_green, disc_orange, disc_red], name="TrafficLight Discs").translate([0, 0, depth]) # Put discs over head
head = ddd.group([head, discs], name="TrafficLight Head").translate([0, -height / 2.0, 0]) # Center vertically
head = head.rotate([math.pi / 2.0, 0, 0])
head = ddd.uv.map_cubic(head)
return head
def cable(a, b, thick=0.20):
"""
Rigid cable (segment) between two points.
TODO: this extrusion approach and rotation can be improved using extrude along like cable_catenary does.
"""
a = np.array(a)
b = np.array(b)
#path = ddd.line([a, b])
#path_section = ddd.point(name="Cable").buffer(thick * 0.5, resolution=1, cap_style=ddd.CAP_ROUND)
#cable = path_section.extrude_path(path)
length = np.linalg.norm(b - a)
cable = ddd.point(name="Cable").buffer(thick * 0.5, resolution=1).extrude(length + thick).translate([0, 0, -thick * 0.5])
cable = cable.merge_vertices().smooth(math.pi)
cable = ddd.uv.map_cylindrical(cable, split=False)
vector_up = [0, 0, 1]
vector_dir = (b - a) / length
rot_axis = np.cross(vector_up, vector_dir)
rot_angle = math.asin(np.linalg.norm(rot_axis))
if rot_angle > 0.00001:
rotation = transformations.quaternion_about_axis(rot_angle, rot_axis / np.linalg.norm(rot_axis))
cable = cable.rotate_quaternion(rotation)
cable = cable.translate(a)
return cable
def lighthouse(height=10, r=1.5):
mat = random.choice([ddd.mats.metal_paint_green, ddd.mats.metal_paint_red])
disc = ddd.point([0, 0]).buffer(r, resolution=3, cap_style=ddd.CAP_ROUND)
obj = disc.extrude_step(disc, height * 0.3)
obj = obj.extrude_step(disc.scale(0.7), height * 0.5)
obj = obj.extrude_step(disc.scale(1.0), height * 0.18)
obj = obj.extrude_step(disc.scale(1.2), height * 0.02)
obj = obj.material(mat)
obj = ddd.uv.map_cylindrical(obj)
obj.name = "Lighthouse"
lamp = lamp_ball(r=0.2).material(mat)
lamp = ddd.uv.map_spherical(lamp)
top = post(top=lamp, mat_post=ddd.mats.steel).translate([0, 0, height])
rail = disc.scale(1.2).extrude_step(disc.scale(1.2), 1.0, base=False, cap=False) #.twosided()
rail = rail.translate([0, 0, height]).material(ddd.mats.railing)
rail = ddd.uv.map_cylindrical(rail)
obj = ddd.group([obj, top, rail], name="Lighthouse Small")
return obj
def osm_augment_rocks_generate_rocks(obj, osm, root):
"""
"""
item_density_m2 = 1.0 / 1000.0
num_items = int((obj.area() * item_density_m2))
def filter_func_noise(coords):
val = noise.pnoise2(coords[0],
coords[1],
octaves=2,
persistence=0.5,
lacunarity=2,
repeatx=1024,
repeaty=1024,
base=0)
return (val > random.uniform(-0.5, 0.5))
items = ddd.group2(name='Rocks: %s' % obj.name)
for p in obj.random_points(num_points=num_items,
filter_func=filter_func_noise):
item = ddd.point(p, name="Rock")
#item.extra['ddd:aug:status'] = 'added'
item.extra['ddd:item'] = 'natural_rock'
item.extra['ddd:angle'] = ddd.random.angle()
items.append(item)
root.find("/ItemsNodes").append(items.children)
def patio_chair(width=0.45, length=0.45, seat_height=0.40):
seat_thick = 0.05
seat = ddd.rect([0, 0, width, length], name="Chair seat").recenter().extrude(seat_thick)
seat = ddd.uv.map_cubic(seat)
seat = seat.translate([0, 0, seat_height - seat_thick])
stool = ddd.group3([seat], name="Chair stool")
leg_thick = 0.05
leg_padding = leg_thick
for c in [(1, 1), (-1, 1), (-1, -1), (1, -1)]:
leg = ddd.point([c[0] * (width / 2 - leg_padding), c[1] * (length / 2 - leg_padding)]).buffer(leg_thick / 2).extrude(seat_height - seat_thick)
leg = ddd.uv.map_cylindrical(leg)
stool.append(leg)
stool = stool.material(ddd.mats.steel)
stool = ddd.collision.aabox_from_aabb(stool)
back_height = 0.3
back = ddd.rect([width, seat_thick], name="Chair Back").recenter().extrude(back_height)
back = back.material(ddd.mats.steel)
back = ddd.uv.map_cubic(back)
back = back.translate([0, length / 2 - seat_thick, seat_height])
back = ddd.collision.aabox_from_aabb(back)
chair = ddd.group3([stool, back], name="Chair")
chair.extra['ddd:mass'] = 2.5
chair = ddd.meshops.batch_by_material(chair).clean(remove_degenerate=False)
return chair
def osm_augment_plants_generate_grass_blades(obj, osm, root):
"""
Generates grass blades.
"""
blade_density_m2 = 1.0 / 20.0
num_blades = int((obj.area() * blade_density_m2))
def filter_func_noise(coords):
val = noise.pnoise2(coords[0],
coords[1],
octaves=2,
persistence=0.5,
lacunarity=2,
repeatx=1024,
repeaty=1024,
base=0)
return (val > random.uniform(-0.5, 0.5))
blades = ddd.group2(name='Grass Blades: %s' % obj.name)
for p in obj.random_points(num_points=num_blades,
filter_func=filter_func_noise):
blade = ddd.point(p, name="Grass Blade")
#blade.extra['ddd:aug:status'] = 'added'
blade.extra['ddd:item'] = 'grass_blade' # TODO: Change to DDD
blades.append(blade)
root.find("/ItemsNodes").append(blades.children)
def generate_item_2d_outdoor_seating(self, feature):
# Distribute centers for seating (ideally, grid if shape is almost square, sampled if not)
# For now, using center:
center = feature.centroid()
table = center.copy(name="Outdoor seating table: %s" % feature.name)
table.extra['osm:amenity'] = 'table'
table.extra['osm:seats'] = random.randint(0, 4)
umbrella = ddd.group2()
if random.uniform(0, 1) < 0.8:
umbrella = center.copy(name="Outdoor seating umbrella: %s" % feature.name)
umbrella.extra['osmext:amenity'] = 'umbrella'
chairs = ddd.group2(name="Outdoor seating seats")
ang_offset = random.choice([0, math.pi / 2, math.pi, math.pi * 3/4])
for i in range(table.extra['osm:seats']):
ang = ang_offset + (2 * math.pi / table.extra['osm:seats']) * i + random.uniform(-0.1, 0.1)
chair = ddd.point([0, random.uniform(0.7, 1.1)], name="Outdoor seating seat %d: %s" % (i, feature.name))
chair = chair.rotate(ang).translate(center.geom.coords[0])
chair.extra['osm:amenity'] = 'seat'
chair.extra['ddd:angle'] = ang + random.uniform(-0.1, 0.1) # * (180 / math.pi)
chairs.append(chair)
item = ddd.group2([table, umbrella, chairs], "Outdoor seating: %s" % feature.name)
return item
'''
def generate_item_3d_crane(self, item_2d):
coords = item_2d.geom.coords[0]
oriented_point = ddd.point(coords)
try:
oriented_point = ddd.snap.project(
ddd.point(coords),
self.osm.ways_2d['0']) # FIXME: Align to coastline if any?
except Exception as e:
logger.error("Could not orient crane: %s", item_2d)
oriented_point.extra['ddd:angle'] = 0
item_3d = industrial.crane_vertical()
item_3d = item_3d.rotate(
[0, 0, oriented_point.extra['ddd:angle'] - math.pi / 2])
item_3d = item_3d.translate([coords[0], coords[1], 0.0])
item_3d.name = 'Crane: %s' % item_2d.name
return item_3d
def column(r=0.1, height=2.0, top=None):
col = ddd.point([0, 0]).buffer(r, resolution =1).extrude(height)
col = ddd.uv.map_cubic(col)
if top:
top = top.translate([0, 0, height])
col = ddd.group([col, top])
return col
def uv_apply_func(x, y, z, idx):
# Find nearest point in shape (or children), and return its height
closest_o, closest_d = obj_2d.closest(ddd.point([x, y]))
closest_uv = None
closest_distsqr = float('inf')
if closest_o.extra.get('uv', None):
for idx, v in enumerate(closest_o.geom.exterior.coords):
point_2d = [v[0], v[1], 0]
diff = [point_2d[0] - x, point_2d[1] - y]
distsqr = (diff[0]**2) + (diff[1]**2)
if (distsqr < closest_distsqr):
closest_uv = closest_o.extra['uv'][idx]
closest_distsqr = distsqr
else:
logger.error(
"Closest object has no UV mapping: %s (%s) (obj_2d=%s, obj_3d=%s)",
closest_o, closest_o.extra.get('uv', None), obj_2d, obj_3d)
raise DDDException("Closest object has no UV mapping: %s (%s)" %
(closest_o, closest_o.extra.get('uv', None)),
ddd_obj=obj_3d)
if closest_uv is None:
logger.error("Error mapping 3D from 2D (3d=%s, 2d=%s %s %s)",
obj_3d, obj_2d, obj_2d.geom,
[x.geom for x in obj_2d.children])
raise DDDException(
"Could not map 3D from 2D (no closest vertex found): %s" %
obj_3d,
ddd_obj=obj_3d)
return closest_uv
def childrens_playground_arc(length=3.25, width=1.0, sides=7, height=None):
arc_thick = 0.08
bar_thick = 0.05
if height is None:
height = length / 2 * 0.9
circleline = ddd.regularpolygon(sides * 2, name="Childrens Playground Arc Side Arc").rotate(-math.pi / 2).outline().scale([length / 2, height])
arcline = circleline.intersection(ddd.rect([-length, 0.1, length, height * 2]))
arc = circleline.buffer(arc_thick / 2).intersection(ddd.rect([-length, 0, length, height * 2]))
arc = arc.extrude(arc_thick, center=True).material(ddd.mats.metal_paint_red)
arc = arc.rotate(ddd.ROT_FLOOR_TO_FRONT)
arc = ddd.uv.map_cubic(arc)
arc1 = arc.copy().translate([0, -width / 2, 0])
arc2 = arc.copy().translate([0, +width / 2, 0])
item = ddd.group([arc1, arc2])
bar = ddd.point(name="Childrens Playground Arc Bar").buffer(bar_thick / 2).extrude(width - arc_thick, center=True).rotate(ddd.ROT_FLOOR_TO_FRONT)
bar = ddd.uv.map_cubic(bar)
mats = [ddd.mats.metal_paint_white, ddd.mats.metal_paint_red]
for idx, p in enumerate(arcline.geom.coords[1:-1]):
pbar = bar.copy().translate([p[0], 0, p[1]])
pbar = pbar.material(mats[idx % 2])
item.append(pbar)
item = ddd.meshops.batch_by_material(item).clean(remove_degenerate=False)
return item
def cart_wheel_axis(height_to_axis=0.1,
wheel_radius=0.075,
width=0.06,
thick_interior=0.032):
"""
"""
#wheel_radius = height_to_axis * 0.75
#height_to_axis = wheel_radius * 1.25 # 0.10
item = ddd.point().line_to([0, -height_to_axis]).line_to(
[width, -height_to_axis - wheel_radius * 0.5]).line_to([width, 0])
item = ddd.polygon(item.geom.coords)
item = item.translate([-width * 0.5, 0]).triangulate().twosided()
item = item.rotate(ddd.ROT_FLOOR_TO_FRONT).rotate(ddd.ROT_TOP_CW)
side1 = item.copy().translate([-thick_interior, 0, 0])
side2 = item.copy().translate([thick_interior, 0, 0])
item = side1.append(side2)
item = item.combine()
item = item.material(ddd.mats.steel)
item = ddd.uv.map_cubic(item)
item.set('ddd:connector:axis', [0, 0, -height_to_axis])
return item
def bar_u(height=0.8, width=0.4, r=0.15, thick=0.1):
"""
A U-shaped figure, like that used for handles, bycicle stands...
"""
vertical_height = height - r
base = ddd.regularpolygon(6, r=thick * 0.5, name="U-Shape")
path = ddd.point().line_to([0,
vertical_height]).arc_to([r, height],
[r, vertical_height],
True,
resolution=1)
path = path.line_to([width - r,
height]).arc_to([width, vertical_height],
[width - r, vertical_height],
True,
resolution=1)
path = path.line_to([width, 0])
item = base.extrude_along(path)
item = item.rotate(ddd.ROT_FLOOR_TO_FRONT) #.rotate(ddd.ROT_TOP_CW)
item = item.translate([-width * 0.5, 0, 0])
item = item.material(ddd.mats.steel)
item = ddd.uv.map_cubic(item)
return item
def osm_augment_plants_generate_flowers(obj, osm, root):
blade_density_m2 = 1.0 / 20.0
num_blades = int((obj.area() * blade_density_m2))
def filter_func_noise(coords):
val = noise.pnoise2(coords[0],
coords[1],
octaves=2,
persistence=0.5,
lacunarity=2,
repeatx=1024,
repeaty=1024,
base=0)
return (val > random.uniform(-0.5, 0.5))
blades = ddd.group2(name='Flowers: %s' % obj.name)
for p in obj.random_points(num_points=num_blades,
filter_func=filter_func_noise):
blade = ddd.point(p, name="Flowers")
#blade.extra['ddd:aug:status'] = 'added'
blade.extra['ddd:item'] = 'flowers'
blade.extra['ddd:flowers:type'] = random.choice(('blue', 'roses'))
blades.append(blade)
root.find("/ItemsNodes").append(blades.children)
def childrens_playground_slide(length=4.5, height=None, width=0.60):
slide_thick = 0.03
side_thick = 0.06
if height is None:
height = length * 0.45
side_mat = random.choice([ddd.mats.metal_paint_red, ddd.mats.metal_paint_green, ddd.mats.metal_paint_yellow])
slideline = ddd.point([0, 0], name="Slide").line_to([0.5, 0]).line_to([3, 1.5]).line_to([3.5, 1.5])
# TODO: slideline.interpolate_cubic(), or slideline.smooth() or similar
slideprofile = slideline.buffer(slide_thick / 2, cap_style=ddd.CAP_FLAT)
slide = slideprofile.scale([1 / 4.5 * length, 1 / 2.0 * height])
slide = slide.extrude(width - side_thick, center=True).rotate(ddd.ROT_FLOOR_TO_FRONT)
slide = slide.material(ddd.mats.steel)
slide = ddd.uv.map_cubic(slide)
slidesideprofile = slideline.line_to([3.5, 1.7]).line_to([3, 1.7]).line_to([0.5, 0.2]).line_to([0, 0.2])
slidesideprofile = ddd.polygon(list(slidesideprofile.geom.coords), name="Slide profile")
stairssideprofile = ddd.polygon([[3.5, 1.5], [3.5, 2], [4, 2], [4, 1.5], [4.5, 0], [4.0, 0], [3.5, 1.5]])
stairssideprofile = stairssideprofile.union(ddd.point([3.75, 2]).buffer(0.25, cap_style=ddd.CAP_ROUND))
stairssideprofile = stairssideprofile.subtract(ddd.point([3.75, 2]).buffer(0.15, cap_style=ddd.CAP_ROUND, resolution=2)) # Hole
stairssideprofile = stairssideprofile.translate([-0.25, 0])
slidesideprofile = slidesideprofile.union(stairssideprofile)
slidesideprofile = slidesideprofile.scale([1 / 4.5 * length, 1 / 2.0 * height])
slidesideprofile = slidesideprofile.extrude(side_thick, center=True).rotate(ddd.ROT_FLOOR_TO_FRONT)
slidesideprofile = slidesideprofile.material(side_mat)
slidesideprofile = ddd.uv.map_cubic(slidesideprofile)
slidesideprofile1 = slidesideprofile.translate([0, width / 2, 0])
slidesideprofile2 = slidesideprofile.translate([0, -width / 2, 0])
item = ddd.group([slide, slidesideprofile1, slidesideprofile2])
numsteps = int((height - 1) / 0.3) + 1
for i in range(numsteps):
step = ddd.box([-0.1, -((width - side_thick) / 2), 0, 0.1, ((width - side_thick) / 2), 0.05], name="Slide Step")
step = step.translate([4 - (i + 1) * (0.5 / (numsteps + 1)), 0, (i + 1) * 0.3]).material(ddd.mats.steel)
step = ddd.uv.map_cubic(step)
item.append(step)
item = item.translate([-4.5/2, 0, 0]).rotate(ddd.ROT_TOP_CCW)
item = ddd.meshops.batch_by_material(item).clean(remove_degenerate=False)
return item
def room_items(root, pipeline, obj):
points = obj.random_points(5)
for p in points:
pos = [p[0], p[1]]
item = ddd.point(pos, "ItemRandom")
item.extra['godot:instance'] = "res://scenes/items/ItemGeneric.tscn"
root.find("/Items").append(item)
def osm_config_locale_es_vigo(root, osm, pipeline):
config = ddd.point([-8.723, 42.238], name="Vigo Config")
config.extra['osm:tree:type'] = {
'default': 1.9,
'fir': 0.1
} #, 'fir': 1, 'palm': 0.25}
#config.extra['ddd:aug:itemfill:types'] = {'default': 1, 'fir': 1}
pipeline.data['ddd:config:items'].append(config)
def floor_decoration_objects_fore(root, pipeline, obj):
sprites_obj_floor = [
ddd.mats.obj_bush_def,
ddd.mats.obj_bush_wide,
ddd.mats.obj_tree1,
ddd.mats.obj_tree2,
ddd.mats.obj_tree3,
ddd.mats.obj_tree4, # ddd.mats.obj_tree_intro,
ddd.mats.obj_barsx4,
ddd.mats.obj_plant,
ddd.mats.obj_grid_panel,
ddd.mats.obj_grid_panel_broken,
ddd.mats.obj_plantsx1,
ddd.mats.obj_plantsx3,
ddd.mats.obj_flowerpot,
ddd.mats.obj_flowers1,
ddd.mats.obj_flowers2,
# ddd.mats.obj_mailbox, ddd.mats.obj_bin, ddd.mats.obj_bench,
]
line = obj.extra['floor_line']
l = line.geom.length
for d in (random.uniform(0.0, 1.0) *
l, ): # random.uniform(0.0, 1.0) * l):
p, segment_idx, segment_coords_a, segment_coords_b = line.interpolate_segment(
d)
pos = [p[0], p[1] - 20.0]
rndscale = random.uniform(0.8, 1.3)
itempos = ddd.point(pos, "Floor Deco Object Fore")
itempos = ddd.snap.project(itempos, line, +16.0 * rndscale)
materials_floor = sprites_obj_floor
material = random.choice(materials_floor)
item = TextureAtlasUtils().create_sprite_rect(material)
item = item.material(material)
# TODO: Scale to sprite dimensions
# item = item.scale([32.0, -32.0])
rndscale = rndscale * material.extra.get("godot:obj:scale", 1.0)
item.extra['godot:scale'] = [rndscale, rndscale]
item = item.scale([rndscale, rndscale])
item = ddd.align.anchor(item, [0.0, 0.5])
item = item.translate(itempos.centroid())
item.extra['ddd:angle'] = itempos.extra['ddd:angle'] - math.pi / 2.0
item.extra['ddd:z_index'] = 39 # 39 # 45
item.extra['godot:self_modulate'] = [
0.45 * 255, 0.4 * 255, 0.4 * 255, 255
]
item.extra['godot:light_mask'] = 0
root.find("/Rooms/").append(item)
def osm_config_locale_es_huesca(root, osm, pipeline):
config = ddd.point([-0.4116850, 42.1367415], name="Huesca Config")
config.extra['osm:tree:type'] = {
'default': 1,
'fir': 0.1
} #, 'fir': 1, 'palm': 0.25}
#config.extra['ddd:aug:itemfill:types'] = {'default': 1, 'fir': 1}
pipeline.data['ddd:config:items'].append(config)
def treetop(r=1.75, flatness=0.3, subdivisions=1):
treetop = ddd.sphere(center=ddd.point([random.uniform(-r * 0.2, r * 0.2), random.uniform(-r * 0.2, r * 0.2), 0]), r=r, subdivisions=subdivisions)
treetop = treetop.scale([1.0, 1.0, (1.0 - flatness) * random.uniform(0.85, 1.15)])
treetop = treetop.smooth(math.pi * 2 / 3)
treetop = ddd.uv.map_spherical(treetop, scale=[3, 2])
treetop = filters.noise_random(treetop, scale=0.25)
treetop.extra['ddd:collider'] = False
treetop.name = "Treetop"
return treetop
def features_gen(pipeline, root, logger):
area = ddd.disc(r=100.0)
points_coords = area.random_points(num_points=200)
points = ddd.group2([ddd.point(c) for c in points_coords], name="Points")
points.extra['points_coords'] = points_coords
root.find("/Features2").append(area)
root.find("/Features2").append(points)
def patio_umbrella(side=2.5, height=2.5):
base_height = 0.04
base_side = 0.4
base_weight = ddd.rect([base_side, base_side], name="Base weight").recenter()
base_weight = base_weight.extrude(base_height).material(ddd.mats.metal_paint_white)
base_weight = ddd.uv.map_cubic(base_weight)
pole_r = 0.04
pole = ddd.point(name="Pole").buffer(pole_r).extrude(height - base_height).translate([0, 0, base_height])
pole = pole.material(ddd.mats.metal_paint_white)
pole = ddd.uv.map_cylindrical(pole)
umbrella_height = height - 1.8
umbrella = ddd.rect([side, side], name="Umbrella").recenter().material(ddd.mats.rope)
umbrella = umbrella.extrude_step(ddd.point(), umbrella_height, base=False, cap=False)
umbrella = umbrella.twosided().translate([0, 0, height - umbrella_height - 0.02])
umbrella = ddd.uv.map_cubic(umbrella)
#EXTRUSION_METHOD_WRAP
item = ddd.group([base_weight, pole, umbrella])
return item
def ladder_pool(height=1.75, width=0.6):
"""
"""
arc_thick = 0.08
bar_thick = 0.05
arc_radius = 0.35
steps_interval = 0.30
height_above_ground = arc_radius
circleline = ddd.point([-arc_radius, 0], "Ladder").arc_to([arc_radius, 0], [0, 0], False, resolution=4)
circleline = circleline.line_rel([0, -(height - height_above_ground)])
circleline = circleline.arc_to([0, -(height - height_above_ground + arc_radius)], [0, -(height - height_above_ground)], False)
#circleline = circleline.simplify(0.01)
#regularpolygon(sides * 2, name="Childrens Playground Arc Side Arc").rotate(-math.pi / 2).outline().scale([length / 2, height])
#arcline = circleline.intersection(ddd.rect([-length, 0.1, length, height * 2]))
arc = circleline.buffer(arc_thick / 2, cap_style=ddd.CAP_FLAT) #.intersection(ddd.rect([-length, 0, length, height * 2]))
arc = arc.extrude(arc_thick, center=True).material(ddd.mats.steel)
arc = arc.rotate(ddd.ROT_FLOOR_TO_FRONT)
arc = ddd.uv.map_cubic(arc)
arc1 = arc.copy().translate([0, -width / 2, 0])
arc2 = arc.copy().translate([0, +width / 2, 0])
item = ddd.group([arc1, arc2])
bar = ddd.point(name="Ladder step").buffer(bar_thick / 2).extrude(width - arc_thick, center=True).rotate(ddd.ROT_FLOOR_TO_FRONT)
bar = bar.material(ddd.mats.steel)
bar = ddd.uv.map_cubic(bar)
stepsline = ddd.line([[arc_radius, 0], [arc_radius, -(height - height_above_ground)]])
numsteps = int(stepsline.length() / steps_interval) + 1
step_interval_adjusted = stepsline.length() / numsteps
for idx in range(numsteps):
(p, segment_idx, segment_coords_a, segment_coords_b) = stepsline.interpolate_segment(idx * step_interval_adjusted)
pbar = bar.copy().translate([p[0], 0, p[1]])
item.append(pbar)
item = item.combine()
item = item.rotate(ddd.ROT_TOP_CW)
return item
def post_box(height=1.10, r=0.35):
circle = ddd.point([0, 0]).buffer(r, resolution=3, cap_style=ddd.CAP_ROUND)
obj = circle.extrude_step(circle, 0.35)
obj = obj.extrude_step(circle.scale([0.9, 0.9, 1]), 0.02)
obj = obj.extrude_step(circle.scale([0.9, 0.9, 1]), height - 0.4)
obj = obj.extrude_step(circle.scale([1.0, 1.0, 1]), 0.05)
obj = obj.extrude_step(circle.scale([1.0, 1.0, 1]), 0.10)
obj = obj.extrude_step(circle.scale([0.6, 0.6, 1]), 0.05)
obj = obj.material(ddd.mats.metal_paint_yellow)
obj = ddd.uv.map_cylindrical(obj)
obj.name = "Post Box"
logger.warn("Post Box collider should be a cylinder.")
return obj
def uv_apply_func(x, y, z, idx):
# Find nearest point in path
d = path.geom.project(ddd.point([x, y, z]).geom)
#print(x, y, z, idx, d, path)
interpolate_result = path.interpolate_segment(d)
if interpolate_result:
p, segment_idx, segment_coords_a, segment_coords_b = interpolate_result
pol = LinearRing([segment_coords_a, segment_coords_b, [x, y, z]])
return (line_x_offset + (line_x_width * (-1 if pol.is_ccw else 1)),
(d * line_d_scale) + line_d_offset)
else:
logger.error("Cannot interpolate segment: %s", path)
return (line_x_offset, d)
def generate_item_2d_childrens_playground(self, feature):
# Distribute centers for seating (ideally, grid if shape is almost square, sampled if not)
# For now, using center:
center = feature.centroid()
#if center.geom.is_empty: return ddd.group2()
items = [ddd.point(name="Swingset Swing", extra={'osm:playground': 'swing'}),
ddd.point(name="Swingset Monkey Bar", extra={'osm:playground': 'monkey_bar'})]
if random.uniform(0, 1) < 0.8:
items.append(ddd.point(name="Swingset Sandbox", extra={'osm:playground': 'sandbox'}))
if random.uniform(0, 1) < 0.8:
items.append(ddd.point(name="Swingset Slide", extra={'osm:playground': 'slide'}))
if random.uniform(0, 1) < 0.8:
items.append(ddd.point(name="Swingset Swing 2", extra={'osm:playground': 'swing'}))
items = ddd.group2(items, name="Childrens Playground: %s" % feature.name)
items = ddd.align.polar(items, 3, offset=random.uniform(0, math.pi * 2))
items = items.translate(center.geom.coords[0])
return items
def ceiling_decoration_objects_fore(root, pipeline, obj):
sprites_obj_ceiling = [ # ddd.mats.obj_pipes,
ddd.mats.obj_vines1, ddd.mats.obj_vines2, ddd.mats.obj_vines_h1,
ddd.mats.obj_vines_h2, ddd.mats.obj_cables_h, ddd.mats.obj_cables2,
ddd.mats.obj_beam1, ddd.mats.obj_beam2
]
line = obj.extra['ceiling_line']
l = line.length()
min_length = 50
if l < min_length: return
positions = [
random.uniform(0.0, 1.0) * l for _ in range(1 + int(l / 200.0))
]
for d in positions:
p, segment_idx, segment_coords_a, segment_coords_b = line.interpolate_segment(
d)
pos = [p[0], p[1] - 20.0]
rndscale = random.uniform(0.8, 1.3)
itempos = ddd.point(pos, "Ceiling Deco Object")
itempos = ddd.snap.project(itempos, line, 0.0 * rndscale)
materials_ceiling = sprites_obj_ceiling
material = random.choice(materials_ceiling)
item = TextureAtlasUtils().create_sprite_rect(material)
item.name = "Ceiling Deco Object Fore: %s" % material.name
item = item.material(material)
# TODO: Scale to sprite dimensions
# item = item.scale([32.0, -32.0])
item.extra['godot:scale'] = [rndscale, rndscale]
item = item.scale([rndscale, rndscale])
item = ddd.align.anchor(item, [0.5, -0.5])
item = item.translate(itempos.centroid())
# item.extra['ddd:angle'] = itempos.extra['ddd:angle'] - math.pi / 2.0
item.extra['ddd:z_index'] = 39 # 39 # 45
item.extra['godot:self_modulate'] = [
0.35 * 255, 0.3 * 255, 0.3 * 255, 255
]
item.extra['godot:light_mask'] = 0
root.find("/Rooms/").append(item)
def room_items(root, pipeline, obj):
obj = pipeline.data['rooms:background_union']
points = obj.random_points(5) #50
return # No random objects
for p in points:
pos = [p[0], p[1]]
item = ddd.point(pos, "ItemRandom")
item.extra['gdc:item'] = True
item.extra['godot:instance'] = "res://scenes/items/ItemGeneric.tscn"
root.find("/Items").append(item)
