def _def_uv_tform(self,*args,**kwargs):
if hasattr(self,'uv_tform'):return
kweys = kwargs.keys()
pos = kwargs[ke] if 'uv_pos' in kweys else dpv.zero()
rot = kwargs[ke] if 'uv_rot' in kweys else dpv.zero()
scl = kwargs[ke] if 'uv_scl' in kweys else dpv.one()
tpar = kwargs[ke] if 'uv_parent' in kweys else None
tchi = kwargs[ke] if 'uv_children' in kweys else []
ntf = dtf.tform(self,parent = tpar,
pos = pos,rot = rot,scl = scl,
children = [ch.uv_tform for ch in tchi])
self.uv_tform = ntf
def some_input():
ls = [5, 10, 15]
ws = [2, 4, 6, 8]
base = dpv.vector(50, 50, 0)
fixed_pts = []
for sq in range(5):
pt = base.copy().translate_x(sq * 25).translate_y(sq * 10)
l, w = rm.choice(ls), rm.choice(ws)
corners = mpu.make_corners(pt, l, w, 0)
fixed_pts.extend(corners)
hole_corners = [pt.copy() for pt in fixed_pts]
region_pts = []
for lpt in range(5):
pt = dpv.zero().translate_x(lpt * 100).translate_y(
(4 * lpt - lpt**2) * 100)
region_pts.append(pt)
region_pts.append(dpv.vector(200, -100, 0))
for rpt in region_pts:
print(rpt)
target_polygon_edge_length = 10
target_primitive_edge_length = 200
theinput = {
'fixed_pts': fixed_pts,
'hole_pts': hole_corners,
'region_pts': region_pts,
'polygon_edge_length': target_polygon_edge_length,
'primitive_edge_length': target_primitive_edge_length,
}
return theinput
def _def_uv_tform(self, *args, **kwargs):
if hasattr(self, 'uv_tform'): return
kweys = kwargs.keys()
pos = kwargs[ke] if 'uv_pos' in kweys else dpv.zero()
rot = kwargs[ke] if 'uv_rot' in kweys else dpv.zero()
scl = kwargs[ke] if 'uv_scl' in kweys else dpv.one()
tpar = kwargs[ke] if 'uv_parent' in kweys else None
tchi = kwargs[ke] if 'uv_children' in kweys else []
ntf = dtf.tform(self,
parent=tpar,
pos=pos,
rot=rot,
scl=scl,
children=[ch.uv_tform for ch in tchi])
self.uv_tform = ntf
def inside_circle_xy(pt,center,radius):
dzero = dpv.zero()
dzhat = dpv.zhat
pt = pt.project_plane(dzero,dzhat)
center = center.project_plane(dzero,dzhat)
ins = not dpv.distance(pt,center) > radius
return ins
def point_ring(r,n):
st = dpv.zero().translate_x(r)
alpha = PI*(2.0/n)
points = []
for x in range(n):
points.append(st.copy().rotate_z(x*alpha))
return points
def road(start = None,end = None,tip = None,tail = None):
if start is None:start = dpv.zero()
if end is None:end = dpv.vector(100,100,-10)
if tip is None:tip = dpv.vector(0,1,0)
if tail is None:tail = dpv.vector(0,1,0)
rd = dr.road(start,end,tip,tail)
return rd
def some_input():
ls = [5, 10, 15]
ws = [2, 4, 6, 8]
base = dpv.vector(50,50,0)
fixed_pts = []
for sq in range(5):
pt = base.copy().translate_x(sq*25).translate_y(sq*10)
l,w = rm.choice(ls),rm.choice(ws)
corners = mpu.make_corners(pt,l,w,0)
fixed_pts.extend(corners)
hole_corners = [pt.copy() for pt in fixed_pts]
region_pts = []
for lpt in range(5):
pt = dpv.zero().translate_x(lpt*100).translate_y((4*lpt-lpt**2)*100)
region_pts.append(pt)
region_pts.append(dpv.vector(200,-100,0))
for rpt in region_pts:print(rpt)
target_polygon_edge_length = 10
target_primitive_edge_length = 200
theinput = {
'fixed_pts':fixed_pts,
'hole_pts':hole_corners,
'region_pts':region_pts,
'polygon_edge_length':target_polygon_edge_length,
'primitive_edge_length':target_primitive_edge_length,
}
return theinput
def road(start=None, end=None, tip=None, tail=None):
if start is None: start = dpv.zero()
if end is None: end = dpv.vector(100, 100, -10)
if tip is None: tip = dpv.vector(0, 1, 0)
if tail is None: tail = dpv.vector(0, 1, 0)
rd = dr.road(start, end, tip, tail)
return rd
def __init__(self,owner,**kwargs):
self.owner = owner
self._def('parent',None,**kwargs)
self._def('children',[],**kwargs)
self._def('pos',dpv.zero(),**kwargs)
#self._def('rot',dpv.zero(),**kwargs)
self._def('rot',dpq.zero(),**kwargs)
self._def('scl',dpv.one(),**kwargs)
def __init__(self, owner, **kwargs):
self.owner = owner
self._def('parent', None, **kwargs)
self._def('children', [], **kwargs)
self._def('pos', dpv.zero(), **kwargs)
#self._def('rot',dpv.zero(),**kwargs)
self._def('rot', dpq.zero(), **kwargs)
self._def('scl', dpv.one(), **kwargs)
def _profile(self, stepheight, steplength):
line = []
p = dpv.zero()
for sx in range(self.steps):
line.append(p.copy())
p.translate_z(stepheight)
line.append(p.copy())
p.translate_y(steplength)
line.append(p.copy())
return line
def _profile(self,stepheight,steplength):
line = []
p = dpv.zero()
for sx in range(self.steps):
line.append(p.copy())
p.translate_z(stepheight)
line.append(p.copy())
p.translate_y(steplength)
line.append(p.copy())
return line
def grow(self, seed, pfaces, nfaces, years):
gface, seedposition = seed
gpt = seedposition.copy()
pactive = pfaces[gface]
tactive = dpr.tangent(*pactive)
nactive = dpr.normal(*pactive)
ctrlpts = [gpt.copy()]
ctrlpts.append(ctrlpts[-1].copy().translate_z(0.25))
pi2 = numpy.pi / 2.0
while years:
years -= 1
r = 1.0
t = -pi2 / 3.0 if years % 2 == 0 else pi2 / 3.0
q = dq.q_from_av(t, nactive)
#dgpt is where to go from the last point
# it must be aware of structures to creep on
dgpt = tactive.copy().rotate(q).scale_u(r)
ctrlpts.append(ctrlpts[-1].copy().translate(dgpt))
tactive = dpv.v1_v2(ctrlpts[-2], ctrlpts[-1]).normalize()
# consider if the active face should change
ctrlpts.append(ctrlpts[-1].copy().translate_z(-0.25))
#splined = []
#splined.append(ctrlpts[0])
#for x in range(3,len(ctrlpts)):
# v1,v2,v3,v4 = ctrlpts[x-3],ctrlpts[x-2],ctrlpts[x-1],ctrlpts[x]
# splined.extend(dpv.vector_spline(v1,v2,v3,v4,5))
##splined.append(ctrlpts[-1])
#splined = ctrlpts[:]
loop = dpr.point_ring(0.1, 8)
ctrl = dpv.zero()
loop.append(loop[0].copy())
nfs = self._extrude(loop, ctrlpts, dpv.zero())
return self
def grow(self,seed,pfaces,nfaces,years):
gface,seedposition = seed
gpt = seedposition.copy()
pactive = pfaces[gface]
tactive = dpr.tangent(*pactive)
nactive = dpr.normal(*pactive)
ctrlpts = [gpt.copy()]
ctrlpts.append(ctrlpts[-1].copy().translate_z(0.25))
pi2 = numpy.pi/2.0
while years:
years -= 1
r = 1.0
t = -pi2/3.0 if years % 2 == 0 else pi2/3.0
q = dq.q_from_av(t,nactive)
#dgpt is where to go from the last point
# it must be aware of structures to creep on
dgpt = tactive.copy().rotate(q).scale_u(r)
ctrlpts.append(ctrlpts[-1].copy().translate(dgpt))
tactive = dpv.v1_v2(ctrlpts[-2],ctrlpts[-1]).normalize()
# consider if the active face should change
ctrlpts.append(ctrlpts[-1].copy().translate_z(-0.25))
#splined = []
#splined.append(ctrlpts[0])
#for x in range(3,len(ctrlpts)):
# v1,v2,v3,v4 = ctrlpts[x-3],ctrlpts[x-2],ctrlpts[x-1],ctrlpts[x]
# splined.extend(dpv.vector_spline(v1,v2,v3,v4,5))
##splined.append(ctrlpts[-1])
#splined = ctrlpts[:]
loop = dpr.point_ring(0.1,8)
ctrl = dpv.zero()
loop.append(loop[0].copy())
nfs = self._extrude(loop,ctrlpts,dpv.zero())
return self
def _def_tform(self,*args,**kwargs):
if hasattr(self,'tform'):return
kweys = kwargs.keys()
pos = kwargs['pos'] if 'pos' in kweys else dpv.zero()
rot = kwargs['rot'] if 'rot' in kweys else dpq.zero()
scl = kwargs['scl'] if 'scl' in kweys else dpv.one()
tpar = kwargs['parent'] if 'parent' in kweys else None
tchi = kwargs['children'] if 'children' in kweys else []
ntf = dtf.tform(self,parent = tpar,
pos = pos,rot = rot,scl = scl,
children = [ch.tform for ch in tchi])
self.tform = ntf
def _geo(self):
for pdx in range(self.pieces):
zero = dpv.zero()
p1 = self._point(zero)
p2 = self._point(p1)
ps = [p1, p2]
t = random.random() * 2 * numpy.pi
dpv.rotate_z_coords_about(ps, dpv.center_of_mass(ps), t)
p3 = p2.copy().translate_z(self.height)
p4 = p1.copy().translate_z(self.height)
nfs = self._quad(p4, p1, p2, p3, m='grass4')
self._scale_uv_v(nfs, 0.75)
self._translate_uv_v(nfs, 0.05)
def lsystem_graph():
g = graph()
l = 0
p = dpv.zero()
d = dpv.xhat.copy()
lsys = infralsystem(0)._realize(p,d)
ndps,edgs = lsys.nodes,lsys.edges
ndxs = []
nexs = []
for ndp in ndps:ndxs.append(g._node(node(ndp,layer = l))[l])
for edg in edgs:nexs.append(g._connect_nodes(ndxs[edg[0]],ndxs[edg[1]]))
return g
def polygon(n):
angle = 360.0/n
turns = [x*angle for x in range(n)]
poly = [dpv.zero()]
current_angle = 0.0
for si in range(n):
l,t = 1.0,turns[si]
current_angle = t
dx = l*numpy.cos(rad(current_angle))
dy = l*numpy.sin(rad(current_angle))
new = poly[-1].copy().translate_x(dx).translate_y(dy)
poly.append(new)
poly.pop()
dpv.translate_coords(poly,dpv.center_of_mass(poly).flip())
return poly
def model(self):
p = dpv.zero()
d = dpv.z()
#ltree(-1)._realize(p,d)
total = dmo.model()
#tps = [(x,y) for x in range(3) for y in range(3)]
tps = [(x,y) for x in range(1) for y in range(1)]
for i,xy in enumerate(tps):
x,y = xy
kws = {'seed':i}
self.ltree._realize(p,d)
lmod = self.model
lmod.translate(dpv.vector(10*x,10*y,0))
total._consume(lmod)
return total
def model(self):
p = dpv.zero()
d = dpv.z()
#ltree(-1)._realize(p,d)
total = dmo.model()
#tps = [(x,y) for x in range(3) for y in range(3)]
tps = [(x, y) for x in range(1) for y in range(1)]
for i, xy in enumerate(tps):
x, y = xy
kws = {'seed': i}
self.ltree._realize(p, d)
lmod = self.model
lmod.translate(dpv.vector(10 * x, 10 * y, 0))
total._consume(lmod)
return total
def _curve(self,**kwargs):
if 'curve' in kwargs.keys() and kwargs['curve']:
self.curve = kwargs['curve']
else:
self.curve = [dpv.zero(),
dpv.zero().translate_z(5),
dpv.zero().translate_z(5).translate_y(5),
dpv.zero().translate_z(5).translate_y(5).translate(dpv.vector(1,1,2)),
dpv.zero().translate_z(5).translate_y(5).translate(dpv.vector(1,1,2)).translate_x(4),
dpv.zero().translate_z(5).translate_y(5).translate(dpv.vector(1,1,2)).translate_x(4).translate_z(-2)]
def _def_tform(self, *args, **kwargs):
if hasattr(self, 'tform'): return
kweys = kwargs.keys()
pos = kwargs['pos'] if 'pos' in kweys else dpv.zero()
rot = kwargs['rot'] if 'rot' in kweys else dpq.zero()
scl = kwargs['scl'] if 'scl' in kweys else dpv.one()
tpar = kwargs['parent'] if 'parent' in kweys else None
tchi = kwargs['children'] if 'children' in kweys else []
ntf = dtf.tform(self,
parent=tpar,
pos=pos,
rot=rot,
scl=scl,
children=[ch.tform for ch in tchi])
self.tform = ntf
def _geo_from_profile(self, line, l, w, h, steps, stepheight, steplength):
topleft = [pt.copy().translate_x(-w / 2.0) for pt in line]
topright = [pt.copy().translate_x(w / 2.0) for pt in line]
bottom = dpr.point_line(dpv.zero(), dpv.vector(0, l, h), steps)
for bdx in range(steps):
bottom.insert(2 * bdx + 1, bottom[2 * bdx + 1].copy())
dpv.translate_coords_z(bottom[1:], -stepheight)
bottomleft = [pt.copy().translate_x(-w / 2.0) for pt in bottom]
bottomright = [pt.copy().translate_x(w / 2.0) for pt in bottom]
nfs = []
nfs.extend(self._bridge(topleft, topright))
nfs.extend(self._bridge(bottomleft, topleft))
nfs.extend(self._bridge(topright, bottomright))
nfs.extend(self._bridge(bottomright, bottomleft))
nfs.extend(
self._quad(topleft[-1], topright[-1], bottomright[-1],
bottomleft[-1]))
def __init__(self, *args, **kwargs):
dgc.context.__init__(self, *args, **kwargs)
self._def('style', 'uturn', **kwargs)
self._def('p', dpv.zero(), **kwargs)
self._def('l', 10, **kwargs)
self._def('w', 8, **kwargs)
if args:
b = args[0]
s = b.stories
fheights, cheights, wheights = b.fheights, b.cheights, b.wheights
else:
s = 3
fheights, cheights, wheights = [0.25] * s, [0.25] * s, [4.0] * s
self._def('stories', s, **kwargs)
self._def('fheights', fheights, **kwargs)
self._def('cheights', cheights, **kwargs)
self._def('wheights', wheights, **kwargs)
def _geo_from_profile(self,line,l,w,h,steps,stepheight,steplength):
topleft = [pt.copy().translate_x(-w/2.0) for pt in line]
topright = [pt.copy().translate_x(w/2.0) for pt in line]
bottom = dpr.point_line(dpv.zero(),dpv.vector(0,l,h),steps)
for bdx in range(steps):
bottom.insert(2*bdx+1,bottom[2*bdx+1].copy())
dpv.translate_coords_z(bottom[1:],-stepheight)
bottomleft = [pt.copy().translate_x(-w/2.0) for pt in bottom]
bottomright = [pt.copy().translate_x(w/2.0) for pt in bottom]
nfs = []
nfs.extend(self._bridge(topleft,topright))
nfs.extend(self._bridge(bottomleft,topleft))
nfs.extend(self._bridge(topright,bottomright))
nfs.extend(self._bridge(bottomright,bottomleft))
nfs.extend(self._quad(
topleft[-1],topright[-1],
bottomright[-1],bottomleft[-1]))
def __init__(self,*args,**kwargs):
dgc.context.__init__(self,*args,**kwargs)
self._def('style','uturn',**kwargs)
self._def('p',dpv.zero(),**kwargs)
self._def('l',10,**kwargs)
self._def('w',8,**kwargs)
if args:
b = args[0]
s = b.stories
fheights,cheights,wheights = b.fheights,b.cheights,b.wheights
else:
s = 3
fheights,cheights,wheights = [0.25]*s,[0.25]*s,[4.0]*s
self._def('stories',s,**kwargs)
self._def('fheights',fheights,**kwargs)
self._def('cheights',cheights,**kwargs)
self._def('wheights',wheights,**kwargs)
def _curve(self, **kwargs):
if 'curve' in kwargs.keys() and kwargs['curve']:
self.curve = kwargs['curve']
else:
self.curve = [
dpv.zero(),
dpv.zero().translate_z(5),
dpv.zero().translate_z(5).translate_y(5),
dpv.zero().translate_z(5).translate_y(5).translate(
dpv.vector(1, 1, 2)),
dpv.zero().translate_z(5).translate_y(5).translate(
dpv.vector(1, 1, 2)).translate_x(4),
dpv.zero().translate_z(5).translate_y(5).translate(
dpv.vector(1, 1, 2)).translate_x(4).translate_z(-2)
]
def test():
import dilap.construct as dlc
p = dpv.zero()
d = dpv.z()
#pythagoras_tree()._realize(p,d)
#dragon_curve()._realize(p,d)
total = dmo.model()
#for l in range(5):tree(l)._realize(p,d)
ltree(-1)._realize(p,d)
tps = [(x,y) for x in range(3) for y in range(3)]
for i,xy in enumerate(tps):
x,y = xy
kws = {'seed':i}
lmod = ltree(-1,**kws)._realize(p,d).model
lmod.translate(dpv.vector(10*x,10*y,0))
total._consume(lmod)
dlc.build(total)
def should_shaft(self, plans, rmplan):
rps, eps, ips, sps = plans
sdist = 1000.0
rpos = dpv.vector(rmplan[1]['x'], rmplan[1]['y'], 0)
for sp in sps:
spos = sp[1]['p']
sd = dpv.distance(spos, rpos)
if sd < sdist: sdist = sd
splan = None
newl, neww = rmplan[1]['l'], rmplan[1]['w']
if sdist > self.min_shaft_distance and newl >= 16 and neww >= 18:
shx, shy = rmplan[1]['x'], rmplan[1]['y']
shl = 8
shw = 10
sps = dpv.vector(shx, shy, 0)
gap = (dpv.zero(), shl, shw)
rmplan[1]['shafted'] = True
rmplan[1]['fgap'] = gap
rmplan[1]['cgap'] = gap
splan = ((), {'p': sps, 'l': gap[1], 'w': gap[2]})
return splan
def should_shaft(self,plans,rmplan):
rps,eps,ips,sps = plans
sdist = 1000.0
rpos = dpv.vector(rmplan[1]['x'],rmplan[1]['y'],0)
for sp in sps:
spos = sp[1]['p']
sd = dpv.distance(spos,rpos)
if sd < sdist:sdist = sd
splan = None
newl,neww = rmplan[1]['l'],rmplan[1]['w']
if sdist > self.min_shaft_distance and newl >= 16 and neww >= 18:
shx,shy = rmplan[1]['x'],rmplan[1]['y']
shl = 8
shw = 10
sps = dpv.vector(shx,shy,0)
gap = (dpv.zero(),shl,shw)
rmplan[1]['shafted'] = True
rmplan[1]['fgap'] = gap
rmplan[1]['cgap'] = gap
splan = ((),{'p':sps,'l':gap[1],'w':gap[2]})
return splan
def floor():
gap = (dpv.zero(), 2, 3)
f = dlc.floor(gap=gap)
dlc.build(f)
def generate_story(self, level, worn=0):
offset = dpv.zero().translate_z(self._story_height(level))
storynodes = self.fplan.sgraph.nodes
for n in storynodes:
n.translate(offset)
self._nodes_to_graph(*storynodes)
def _geo(self):
control = dpv.zero()
self._extrude(self.loop,self.curve,control,m = self.m)
def floor():
gap = (dpv.zero(),2,3)
f = dlc.floor(gap = gap)
dlc.build(f)
def _geo(self):
control = dpv.zero()
self._extrude(self.loop, self.curve, control, m=self.m)
def wall():
v1 = dpv.zero()
v2 = dpv.zero().translate_x(5).translate_y(10)
wa = dlc.wall(v1,v2,3,0.25)
dlc.build(wa)
def wall():
v1 = dpv.zero()
v2 = dpv.zero().translate_x(5).translate_y(10)
wa = dlc.wall(v1, v2, 3, 0.25)
dlc.build(wa)
