# SPDX-License-Identifier: GPL-2.0-or-later # Authors: dudecon, jambay # Module notes: # # Grout needs to be implemented. # consider removing wedge crit for small "c" and "cl" values # wrap around for openings on radial stonework? # auto-clip wall edge to SMALL for radial and domes. # unregister doesn't release all references. # repeat for opening doesn't distribute evenly when radialized - see wrap around # note above. # if opening width == indent*2 the edge blocks fail (row of blocks cross opening). # if openings overlap fills inverse with blocks - see h/v slots. # Negative grout width creates a pair of phantom blocks, separated by grout # width, inside the edges. # if block width variance is 0, and edging is on, right edge blocks create a "vertical seam" import bpy from random import random from math import ( fmod, sqrt, sin, cos, atan, pi as PI, ) # Set to True to enable debug_prints DEBUG = False # A few constants SMALL = 0.000000000001 # for values that must be != 0; see UI options/variables - sort of a bug to be fixed NOTZERO = 0.01 # Global variables # General masonry Settings # ------------------------ settings = { 'w': 1.2, 'wv': 0.3, 'h': .6, 'hv': 0.3, 'd': 0.3, 'dv': 0.1, 'g': 0.1, 'gv': 0.07, 'gd': 0.01, 'gdv': 0.0, 'b': 0, 'bv': 0, 'f': 0.0, 'fv': 0.0, 't': 0.0, 'sdv': 0.1, 'hwt': 0.5, 'aln': 0, 'wm': 0.8, 'hm': 0.3, 'dm': 0.1, 'woff': 0.0, 'woffv': 0.0, 'eoff': 0.3, 'eoffv': 0.0, 'rwhl': 1, 'hb': 0, 'ht': 0, 'ge': 0, 'physics': 0 } """ settings DOCUMENTATION: 'w':width 'wv':widthVariation 'h':height 'hv':heightVariation 'd':depth 'dv':depthVariation 'g':grout 'gv':groutVariation 'gd':groutDepth 'gdv':groutDepthVariation 'b':bevel 'bv':bevelVariation 'f':flawSize 'fv':flawSizeVariation 'ff':flawFraction 't':taper 'sdv':subdivision(distance or angle) 'hwt':row height effect on block widths in the row (0=no effect, 1=1:1 relationship, negative values allowed, 0.5 works well) 'aln':alignment(0=none, 1=rows w/features, 2=features w/rows) (currently unused) 'wm':width minimum 'hm':height minimum 'dm':depth minimum 'woff':row start offset(fraction of width) 'woffv':width offset variation(fraction of width) 'eoff':edge offset 'eoffv':edge offset variation 'rwhl':row height lock(1 is all blocks in row have same height) 'hb':bottom row height 'ht': top row height 'ge': grout the edges 'physics': set up for physics """ # dims = area of wall (face) # ------------------------ dims = { 's': 0, 'e': PI * 3 / 2, 'b': 0.1, 't': 12.3 } # radial """ dims DOCUMENTATION: 's':start x or theta 'e':end x or theta 'b':bottom z or r 't':top z or r 'w' = e-s and h = t-b; calculated to optimize for various operations/usages dims = {'s':-12, 'e':15, 'w':27, 'b':-15., 't':15., 'h':30} dims = {'s':-bayDim/2, 'e':bayDim/2, 'b':-5., 't':10.} # bay settings? """ # ------------------------ radialized = 0 # Radiating from one point - round/disc; instead of square slope = 0 # Warp/slope; curved over like a vaulted tunnel # 'bigblock': merge adjacent blocks into single large blocks bigBlock = 0 # Merge blocks # Gaps in blocks for various apertures # ------------------------ # openingSpecs = [] openingSpecs = [ {'w': 0.5, 'h': 0.5, 'x': 0.8, 'z': 2.7, 'rp': 1, 'b': 0.0, 'v': 0, 'vl': 0, 't': 0, 'tl': 0} ] """ openingSpecs DOCUMENTATION: 'w': opening width, 'h': opening height, 'x': horizontal position, 'z': vertical position, 'rp': make multiple openings, with a spacing of x, 'b': bevel the opening, inside only, like an arrow slit. 'v': height of the top arch, 'vl':height of the bottom arch, 't': thickness of the top arch, 'tl': thickness of the bottom arch """ # Add blocks to make platforms # ------------------------ shelfExt = 0 shelfSpecs = { 'w': 0.5, 'h': 0.5, 'd': 0.3, 'x': 0.8, 'z': 2.7 } """ shelfSpecs DOCUMENTATION: 'w': block width, 'h': block height, 'd': block depth (shelf size; offset from wall) 'x': horizontal start position, 'z': vertical start position """ # Add blocks to make steps # ------------------------ stepMod = 0 stepSpecs = { 'x': 0.0, 'z': -10, 'w': 10.0, 'h': 10.0, 'v': 0.7, 't': 1.0, 'd': 1.0 } """ stepSpecs DOCUMENTATION: 'x': horizontal start position, 'z': vertical start position, 'w': step area width, 'h': step area height, 'v': riser height, 't': tread width, 'd': block depth (step size; offset from wall) """ stepLeft = 0 shelfBack = 0 stepOnly = 0 stepBack = 0 # switchable prints def debug_prints(func="", text="Message", var=None): global DEBUG if DEBUG: print("\n[{}]\nmessage: {}".format(func, text)) if var: print("Error: ", var) # pass variables just like for the regular prints def debug_print_vars(*args, **kwargs): global DEBUG if DEBUG: print(*args, **kwargs) # easier way to get to the random function def rnd(): return random() # random number from -0.5 to 0.5 def rndc(): return (random() - 0.5) # random number from -1.0 to 1.0 def rndd(): return (random() - 0.5) * 2.0 # Opening Test suite # opening test function def test(TestN=13): dims = {'s': -29., 'e': 29., 'b': -6., 't': TestN * 7.5} openingSpecs = [] for i in range(TestN): x = (random() - 0.5) * 6 z = i * 7.5 v = .2 + i * (3. / TestN) vl = 3.2 - i * (3. / TestN) t = 0.3 + random() tl = 0.3 + random() rn = random() * 2 openingSpecs += [{'w': 3.1 + rn, 'h': 0.3 + rn, 'x': float(x), 'z': float(z), 'rp': 0, 'b': 0., 'v': float(v), 'vl': float(vl), 't': float(t), 'tl': float(tl)}] return dims, openingSpecs # dims, openingSpecs = test(15) # For filling a linear space with divisions def fill(left, right, avedst, mindst=0.0, dev=0.0, pad=(0.0, 0.0), num=0, center=0): __doc__ = """\ Fills a linear range with points and returns an ordered list of those points including the end points. left: the lower boundary right: the upper boundary avedst: the average distance between points mindst: the minimum distance between points dev: the maximum random deviation from avedst pad: tends to move the points near the bounds right (positive) or left (negative). element 0 pads the lower bounds, element 1 pads the upper bounds num: substitutes a numerical limit for the right limit. fill will then make a num+1 element list center: flag to center the elements in the range, 0 == disabled """ poslist = [left] curpos = left + pad[0] # Set offset by average spacing, then add blocks (fall through); # if not at right edge. if center: curpos += ((right - left - mindst * 2) % avedst) / 2 + mindst if curpos - poslist[-1] < mindst: curpos = poslist[-1] + mindst + rnd() * dev / 2 # clip to right edge. if (right - curpos < mindst) or (right - curpos < mindst - pad[1]): poslist.append(right) return poslist else: poslist.append(curpos) # unused... for now. if num: idx = len(poslist) while idx < num + 1: curpos += avedst + rndd() * dev if curpos - poslist[-1] < mindst: curpos = poslist[-1] + mindst + rnd() * dev / 2 poslist.append(curpos) idx += 1 return poslist # make block edges else: while True: # loop for blocks curpos += avedst + rndd() * dev if curpos - poslist[-1] < mindst: curpos = poslist[-1] + mindst + rnd() * dev / 2 # close off edges at limit if (right - curpos < mindst) or (right - curpos < mindst - pad[1]): poslist.append(right) return poslist else: poslist.append(curpos) # For generating block geometry def MakeABlock(bounds, segsize, vll=0, Offsets=None, FaceExclude=[], bevel=0, xBevScl=1): __doc__ = """\ MakeABlock returns lists of points and faces to be made into a square cornered block, subdivided along the length, with optional bevels. bounds: a list of boundary positions: 0:left, 1:right, 2:bottom, 3:top, 4:back, 5:front segsize: the maximum size before lengthwise subdivision occurs vll: the number of vertexes already in the mesh. len(mesh.verts) should give this number. Offsets: list of coordinate delta values. Offsets are lists, [x,y,z] in [ 0:left_bottom_back, 1:left_bottom_front, 2:left_top_back, 3:left_top_front, 4:right_bottom_back, 5:right_bottom_front, 6:right_top_back, 7:right_top_front, ] FaceExclude: list of faces to exclude from the faces list. see bounds above for indices xBevScl: how much to divide the end (+- x axis) bevel dimensions. Set to current average radius to compensate for angular distortion on curved blocks """ slices = fill(bounds[0], bounds[1], segsize, segsize, center=1) points = [] faces = [] if Offsets is None: points.append([slices[0], bounds[4], bounds[2]]) points.append([slices[0], bounds[5], bounds[2]]) points.append([slices[0], bounds[5], bounds[3]]) points.append([slices[0], bounds[4], bounds[3]]) for x in slices[1:-1]: points.append([x, bounds[4], bounds[2]]) points.append([x, bounds[5], bounds[2]]) points.append([x, bounds[5], bounds[3]]) points.append([x, bounds[4], bounds[3]]) points.append([slices[-1], bounds[4], bounds[2]]) points.append([slices[-1], bounds[5], bounds[2]]) points.append([slices[-1], bounds[5], bounds[3]]) points.append([slices[-1], bounds[4], bounds[3]]) else: points.append([slices[0] + Offsets[0][0], bounds[4] + Offsets[0][1], bounds[2] + Offsets[0][2]]) points.append([slices[0] + Offsets[1][0], bounds[5] + Offsets[1][1], bounds[2] + Offsets[1][2]]) points.append([slices[0] + Offsets[3][0], bounds[5] + Offsets[3][1], bounds[3] + Offsets[3][2]]) points.append([slices[0] + Offsets[2][0], bounds[4] + Offsets[2][1], bounds[3] + Offsets[2][2]]) for x in slices[1: -1]: xwt = (x - bounds[0]) / (bounds[1] - bounds[0]) points.append([x + Offsets[0][0] * (1 - xwt) + Offsets[4][0] * xwt, bounds[4] + Offsets[0][1] * (1 - xwt) + Offsets[4][1] * xwt, bounds[2] + Offsets[0][2] * (1 - xwt) + Offsets[4][2] * xwt]) points.append([x + Offsets[1][0] * (1 - xwt) + Offsets[5][0] * xwt, bounds[5] + Offsets[1][1] * (1 - xwt) + Offsets[5][1] * xwt, bounds[2] + Offsets[1][2] * (1 - xwt) + Offsets[5][2] * xwt]) points.append([x + Offsets[3][0] * (1 - xwt) + Offsets[7][0] * xwt, bounds[5] + Offsets[3][1] * (1 - xwt) + Offsets[7][1] * xwt, bounds[3] + Offsets[3][2] * (1 - xwt) + Offsets[7][2] * xwt]) points.append([x + Offsets[2][0] * (1 - xwt) + Offsets[6][0] * xwt, bounds[4] + Offsets[2][1] * (1 - xwt) + Offsets[6][1] * xwt, bounds[3] + Offsets[2][2] * (1 - xwt) + Offsets[6][2] * xwt]) points.append([slices[-1] + Offsets[4][0], bounds[4] + Offsets[4][1], bounds[2] + Offsets[4][2]]) points.append([slices[-1] + Offsets[5][0], bounds[5] + Offsets[5][1], bounds[2] + Offsets[5][2]]) points.append([slices[-1] + Offsets[7][0], bounds[5] + Offsets[7][1], bounds[3] + Offsets[7][2]]) points.append([slices[-1] + Offsets[6][0], bounds[4] + Offsets[6][1], bounds[3] + Offsets[6][2]]) faces.append([vll, vll + 3, vll + 2, vll + 1]) for x in range(len(slices) - 1): faces.append([vll, vll + 1, vll + 5, vll + 4]) vll += 1 faces.append([vll, vll + 1, vll + 5, vll + 4]) vll += 1 faces.append([vll, vll + 1, vll + 5, vll + 4]) vll += 1 faces.append([vll, vll - 3, vll + 1, vll + 4]) vll += 1 faces.append([vll, vll + 1, vll + 2, vll + 3]) return points, faces # For generating Keystone Geometry def MakeAKeystone(xpos, width, zpos, ztop, zbtm, thick, bevel, vll=0, FaceExclude=[], xBevScl=1): __doc__ = """\ MakeAKeystone returns lists of points and faces to be made into a square cornered keystone, with optional bevels. xpos: x position of the centerline width: x width of the keystone at the widest point (discounting bevels) zpos: z position of the widest point ztop: distance from zpos to the top zbtm: distance from zpos to the bottom thick: thickness bevel: the amount to raise the back vertex to account for arch beveling vll: the number of vertexes already in the mesh. len(mesh.verts) should give this number faceExclude: list of faces to exclude from the faces list. 0:left, 1:right, 2:bottom, 3:top, 4:back, 5:front xBevScl: how much to divide the end (+- x axis) bevel dimensions. Set to current average radius to compensate for angular distortion on curved blocks """ points = [] faces = [] faceinclude = [1 for x in range(6)] for x in FaceExclude: faceinclude[x] = 0 Top = zpos + ztop Btm = zpos - zbtm Wid = width / 2.0 Thk = thick / 2.0 # The front top point points.append([xpos, Thk, Top]) # The front left point points.append([xpos - Wid, Thk, zpos]) # The front bottom point points.append([xpos, Thk, Btm]) # The front right point points.append([xpos + Wid, Thk, zpos]) MirrorPoints = [] for i in points: MirrorPoints.append([i[0], -i[1], i[2]]) points += MirrorPoints points[6][2] += bevel faces.append([3, 2, 1, 0]) faces.append([4, 5, 6, 7]) faces.append([4, 7, 3, 0]) faces.append([5, 4, 0, 1]) faces.append([6, 5, 1, 2]) faces.append([7, 6, 2, 3]) # Offset the vertex numbers by the number of vertices already in the list for i in range(len(faces)): for j in range(len(faces[i])): faces[i][j] += vll return points, faces # for finding line/circle intercepts def circ(offs=0., r=1.): __doc__ = """\ offs is the distance perpendicular to the line to the center of the circle r is the radius of the circle circ returns the distance parallel to the line to the center of the circle at the intercept. """ offs = abs(offs) if offs > r: return None elif offs == r: return 0. else: return sqrt(r ** 2 - offs ** 2) # class openings in the wall class opening: __doc__ = """\ This is the class for holding the data for the openings in the wall. It has methods for returning the edges of the opening for any given position value, as well as bevel settings and top and bottom positions. It stores the 'style' of the opening, and all other pertinent information. """ # x = 0. # x position of the opening # z = 0. # x position of the opening # w = 0. # width of the opening # h = 0. # height of the opening r = 0 # top radius of the arch (derived from 'v') rl = 0 # lower radius of the arch (derived from 'vl') rt = 0 # top arch thickness rtl = 0 # lower arch thickness ts = 0 # Opening side thickness, if greater than average width, replaces it. c = 0 # top arch corner position (for low arches), distance from the top of the straight sides cl = 0 # lower arch corner position (for low arches), distance from the top of the straight sides # form = 0 # arch type (unused for now) # b = 0. # back face bevel distance, like an arrow slit v = 0. # top arch height vl = 0. # lower arch height # variable "s" is used for "side" in the "edge" function. # it is a signed int, multiplied by the width to get + or - of the center def btm(self): if self.vl <= self.w / 2: return self.z - self.h / 2 - self.vl - self.rtl else: return self.z - sqrt((self.rl + self.rtl) ** 2 - (self.rl - self.w / 2) ** 2) - self.h / 2 def top(self): if self.v <= self.w / 2: return self.z + self.h / 2 + self.v + self.rt else: return sqrt((self.r + self.rt) ** 2 - (self.r - self.w / 2) ** 2) + self.z + self.h / 2 # crits returns the critical split points, or discontinuities, used for making rows def crits(self): critlist = [] if self.vl > 0: # for lower arch # add the top point if it is pointed # if self.vl >= self.w/2.: critlist.append(self.btm()) if self.vl < self.w / 2.: # else: for low arches, with wedge blocks under them # critlist.append(self.btm()) critlist.append(self.z - self.h / 2 - self.cl) if self.h > 0: # if it has a height, append points at the top and bottom of the main square section critlist += [self.z - self.h / 2, self.z + self.h / 2] else: # otherwise, append just one in the center critlist.append(self.z) if self.v > 0: # for the upper arch if self.v < self.w / 2: # add the splits for the upper wedge blocks, if needed critlist.append(self.z + self.h / 2 + self.c) # critlist.append(self.top()) # otherwise just add the top point, if it is pointed # else: critlist.append(self.top()) return critlist # get the side position of the opening. # ht is the z position; s is the side: 1 for right, -1 for left # if the height passed is above or below the opening, return None def edgeS(self, ht, s): # set the row radius: 1 for standard wall (flat) if radialized: if slope: r1 = abs(dims['t'] * sin(ht * PI / (dims['t'] * 2))) else: r1 = abs(ht) else: r1 = 1 # Go through all the options, and return the correct value if ht < self.btm(): # too low return None elif ht > self.top(): # too high return None # Check for circ returning None - prevent TypeError (script failure) with float. # in this range, pass the lower arch info elif ht <= self.z - self.h / 2 - self.cl: if self.vl > self.w / 2: circVal = circ(ht - self.z + self.h / 2, self.rl + self.rtl) if circVal is None: return None else: return self.x + s * (self.w / 2. - self.rl + circVal) / r1 else: circVal = circ(ht - self.z + self.h / 2 + self.vl - self.rl, self.rl + self.rtl) if circVal is None: return None else: return self.x + s * circVal / r1 # in this range, pass the top arch info elif ht >= self.z + self.h / 2 + self.c: if self.v > self.w / 2: circVal = circ(ht - self.z - self.h / 2, self.r + self.rt) if circVal is None: return None else: return self.x + s * (self.w / 2. - self.r + circVal) / r1 else: circVal = circ(ht - (self.z + self.h / 2 + self.v - self.r), self.r + self.rt) if circVal is None: return None else: return self.x + s * circVal / r1 # in this range pass the lower corner edge info elif ht <= self.z - self.h / 2: d = sqrt(self.rtl ** 2 - self.cl ** 2) if self.cl > self.rtl / sqrt(2.): return self.x + s * (self.w / 2 + (self.z - self.h / 2 - ht) * d / self.cl) / r1 else: return self.x + s * (self.w / 2 + d) / r1 # in this range pass the upper corner edge info elif ht >= self.z + self.h / 2: d = sqrt(self.rt ** 2 - self.c ** 2) if self.c > self.rt / sqrt(2.): return self.x + s * (self.w / 2 + (ht - self.z - self.h / 2) * d / self.c) / r1 else: return self.x + s * (self.w / 2 + d) / r1 # in this range, pass the middle info (straight sides) else: return self.x + s * self.w / 2 / r1 # get the top or bottom of the opening # ht is the x position; s is the side: 1 for top, -1 for bottom def edgeV(self, ht, s): dist = abs(self.x - ht) def radialAdjust(dist, sideVal): # take the distance and adjust for radial geometry, return dist if radialized: if slope: dist = dist * abs(dims['t'] * sin(sideVal * PI / (dims['t'] * 2))) else: dist = dist * sideVal return dist if s > 0: # and (dist <= self.edgeS(self.z + self.h / 2 + self.c, 1) - self.x): # check top down # hack for radialized masonry, import approx Z instead of self.top() dist = radialAdjust(dist, self.top()) # no arch on top, flat if not self.r: return self.z + self.h / 2 # pointed arch on top elif self.v > self.w / 2: circVal = circ(dist - self.w / 2 + self.r, self.r + self.rt) if circVal is None: return None else: return self.z + self.h / 2 + circVal # domed arch on top else: circVal = circ(dist, self.r + self.rt) if circVal is None: return None else: return self.z + self.h / 2 + self.v - self.r + circVal else: # and (dist <= self.edgeS(self.z - self.h / 2 - self.cl, 1) - self.x): # check bottom up # hack for radialized masonry, import approx Z instead of self.top() dist = radialAdjust(dist, self.btm()) # no arch on bottom if not self.rl: return self.z - self.h / 2 # pointed arch on bottom elif self.vl > self.w / 2: circVal = circ(dist - self.w / 2 + self.rl, self.rl + self.rtl) if circVal is None: return None else: return self.z - self.h / 2 - circVal # old conditional? if (dist-self.w / 2 + self.rl) <= (self.rl + self.rtl): # domed arch on bottom else: circVal = circ(dist, self.rl + self.rtl) # dist-self.w / 2 + self.rl if circVal is None: return None else: return self.z - self.h / 2 - self.vl + self.rl - circVal # and this never happens - but, leave it as failsafe :) debug_prints(func="opening.EdgeV", text="Got all the way out of the edgeV! Not good!") debug_print_vars("opening x = ", self.x, ", opening z = ", self.z) return 0.0 def edgeBev(self, ht): if ht > (self.z + self.h / 2): return 0.0 if ht < (self.z - self.h / 2): return 0.0 if radialized: if slope: r1 = abs(dims['t'] * sin(ht * PI / (dims['t'] * 2))) else: r1 = abs(ht) else: r1 = 1 bevel = self.b / r1 return bevel def __init__(self, xpos, zpos, width, height, archHeight=0, archThk=0, archHeightLower=0, archThkLower=0, bevel=0, edgeThk=0): self.x = float(xpos) self.z = float(zpos) self.w = float(width) self.h = float(height) self.rt = archThk self.rtl = archThkLower self.v = archHeight self.vl = archHeightLower if self.w <= 0: self.w = SMALL # find the upper arch radius if archHeight >= width / 2: # just one arch, low long self.r = (self.v ** 2) / self.w + self.w / 4 elif archHeight <= 0: # No arches self.r = 0 self.v = 0 else: # Two arches self.r = (self.w ** 2) / (8 * self.v) + self.v / 2. self.c = self.rt * cos(atan(self.w / (2 * (self.r - self.v)))) # find the lower arch radius if archHeightLower >= width / 2: self.rl = (self.vl ** 2) / self.w + self.w / 4 elif archHeightLower <= 0: self.rl = 0 self.vl = 0 else: self.rl = (self.w ** 2) / (8 * self.vl) + self.vl / 2. self.cl = self.rtl * cos(atan(self.w / (2 * (self.rl - self.vl)))) # self.form = something? self.b = float(bevel) self.ts = edgeThk # class for the whole wall boundaries; a sub-class of "opening" class openingInvert(opening): # this is supposed to switch the sides of the opening # so the wall will properly enclose the whole wall. def edgeS(self, ht, s): return opening.edgeS(self, ht, -s) def edgeV(self, ht, s): return opening.edgeV(self, ht, -s) # class rows in the wall class rowOb: __doc__ = """\ This is the class for holding the data for individual rows of blocks. each row is required to have some edge blocks, and can also have intermediate sections of "normal" blocks. """ radius = 1 EdgeOffset = 0. def FillBlocks(self): # Set the radius variable, in the case of radial geometry if radialized: if slope: self.radius = dims['t'] * (sin(self.z * PI / (dims['t'] * 2))) else: self.radius = self.z # initialize internal variables from global settings SetH = settings['h'] SetHwt = settings['hwt'] SetWid = settings['w'] SetWidMin = settings['wm'] SetWidVar = settings['wv'] SetGrt = settings['g'] SetGrtVar = settings['gv'] SetRowHeightLink = settings['rwhl'] SetDepth = settings['d'] SetDepthVar = settings['dv'] # height weight, used for making shorter rows have narrower blocks, and vice-versa hwt = ((self.h / SetH - 1) * SetHwt + 1) # set variables for persistent values: loop optimization, readability, single ref for changes. avgDist = hwt * SetWid / self.radius minDist = SetWidMin / self.radius deviation = hwt * SetWidVar / self.radius grtOffset = SetGrt / (2 * self.radius) # init loop variables that may change... grt = (SetGrt + rndc() * SetGrtVar) / (self.radius) ThisBlockHeight = self.h + rndc() * (1 - SetRowHeightLink) * SetGrtVar ThisBlockDepth = rndd() * SetDepthVar + SetDepth for segment in self.RowSegments: divs = fill(segment[0] + grtOffset, segment[1] - grtOffset, avgDist, minDist, deviation) # loop through the divisions, adding blocks for each one for i in range(len(divs) - 1): ThisBlockx = (divs[i] + divs[i + 1]) / 2 ThisBlockw = divs[i + 1] - divs[i] - grt self.BlocksNorm.append([ThisBlockx, self.z, ThisBlockw, ThisBlockHeight, ThisBlockDepth, None]) if SetDepthVar: # vary depth ThisBlockDepth = rndd() * SetDepthVar + SetDepth if SetGrtVar: # vary grout grt = (SetGrt + rndc() * SetGrtVar) / (self.radius) ThisBlockHeight = self.h + rndc() * (1 - SetRowHeightLink) * SetGrtVar def __init__(self, centerheight, rowheight, edgeoffset=0.): self.z = float(centerheight) self.h = float(rowheight) self.EdgeOffset = float(edgeoffset) # THIS INITIALIZATION IS IMPORTANT! OTHERWISE ALL OBJECTS WILL HAVE THE SAME LISTS! self.BlocksEdge = [] self.RowSegments = [] self.BlocksNorm = [] def arch(ra, rt, x, z, archStart, archEnd, bevel, bevAngle, vll): __doc__ = """\ Makes a list of faces and vertexes for arches. ra: the radius of the arch, to the center of the bricks rt: the thickness of the arch x: x center location of the circular arc, as if the arch opening were centered on x = 0 z: z center location of the arch anglebeg: start angle of the arch, in radians, from vertical? angleend: end angle of the arch, in radians, from vertical? bevel: how much to bevel the inside of the arch. vll: how long is the vertex list already? """ avlist = [] aflist = [] # initialize internal variables for global settings SetGrt = settings['g'] SetGrtVar = settings['gv'] SetDepth = settings['d'] SetDepthVar = settings['dv'] # Init loop variables def bevelEdgeOffset(offsets, bevel, side): """ Take the block offsets and modify it for the correct bevel. offsets = the offset list. See MakeABlock bevel = how much to offset the edge side = -1 for left (right side), 1 for right (left side) """ left = (0, 2, 3) right = (4, 6, 7) if side == 1: pointsToAffect = right else: pointsToAffect = left for num in pointsToAffect: offsets[num] = offsets[num][:] offsets[num][0] += -bevel * side ArchInner = ra - rt / 2 ArchOuter = ra + rt / 2 - SetGrt + rndc() * SetGrtVar DepthBack = - SetDepth / 2 - rndc() * SetDepthVar DepthFront = SetDepth / 2 + rndc() * SetDepthVar if radialized: subdivision = settings['sdv'] else: subdivision = 0.12 grt = (SetGrt + rndc() * SetGrtVar) / (2 * ra) # init grout offset for loop # set up the offsets, it will be the same for every block offsets = ([[0] * 2 + [bevel]] + [[0] * 3] * 3) * 2 # make the divisions in the "length" of the arch divs = fill(archStart, archEnd, settings['w'] / ra, settings['wm'] / ra, settings['wv'] / ra) for i in range(len(divs) - 1): if i == 0: ThisOffset = offsets[:] bevelEdgeOffset(ThisOffset, bevAngle, - 1) elif i == len(divs) - 2: ThisOffset = offsets[:] bevelEdgeOffset(ThisOffset, bevAngle, 1) else: ThisOffset = offsets geom = MakeABlock( [divs[i] + grt, divs[i + 1] - grt, ArchInner, ArchOuter, DepthBack, DepthFront], subdivision, len(avlist) + vll, ThisOffset, [], None, ra ) avlist += geom[0] aflist += geom[1] if SetDepthVar: # vary depth DepthBack = -SetDepth / 2 - rndc() * SetDepthVar DepthFront = SetDepth / 2 + rndc() * SetDepthVar if SetGrtVar: # vary grout grt = (settings['g'] + rndc() * SetGrtVar) / (2 * ra) ArchOuter = ra + rt / 2 - SetGrt + rndc() * SetGrtVar for i, vert in enumerate(avlist): v0 = vert[2] * sin(vert[0]) + x v1 = vert[1] v2 = vert[2] * cos(vert[0]) + z if radialized == 1: if slope == 1: r1 = dims['t'] * (sin(v2 * PI / (dims['t'] * 2))) else: r1 = v2 v0 = v0 / r1 avlist[i] = [v0, v1, v2] return (avlist, aflist) def sketch(): __doc__ = """ \ The 'sketch' function creates a list of openings from the general specifications passed to it. It takes curved and domed walls into account, placing the openings at the appropriate angular locations """ boundlist = [] for x in openingSpecs: if x['rp']: if radialized: r1 = x['z'] else: r1 = 1 if x['x'] > (x['w'] + settings['wm']): spacing = x['x'] / r1 else: spacing = (x['w'] + settings['wm']) / r1 minspacing = (x['w'] + settings['wm']) / r1 divs = fill(dims['s'], dims['e'], spacing, minspacing, center=1) for posidx in range(len(divs) - 2): boundlist.append(opening(divs[posidx + 1], x['z'], x['w'], x['h'], x['v'], x['t'], x['vl'], x['tl'], x['b'])) else: boundlist.append(opening(x['x'], x['z'], x['w'], x['h'], x['v'], x['t'], x['vl'], x['tl'], x['b'])) # check for overlapping edges? return boundlist def wedgeBlocks(row, opening, leftPos, rightPos, edgeBinary, r1): __doc__ = """\ Makes wedge blocks for the left and right sides, depending example: wedgeBlocks(row, LeftWedgeEdge, LNerEdge, LEB, r1) wedgeBlocks(row, RNerEdge, RightWedgeEdge, REB, r1) """ wedgeEdges = fill(leftPos, rightPos, settings['w'] / r1, settings['wm'] / r1, settings['wv'] / r1) for i in range(len(wedgeEdges) - 1): x = (wedgeEdges[i + 1] + wedgeEdges[i]) / 2 grt = (settings['g'] + rndd() * settings['gv']) / r1 w = wedgeEdges[i + 1] - wedgeEdges[i] - grt ThisBlockDepth = rndd() * settings['dv'] + settings['d'] # edgeV may return "None" - causing TypeError for math op. # use 0 until wedgeBlocks operation worked out edgeVal = opening.edgeV(x - w / 2, edgeBinary) if edgeVal is None: edgeVal = 0.0 LeftVertOffset = -(row.z - (row.h / 2) * edgeBinary - edgeVal) # edgeV may return "None" - causing TypeError for math op. # use 0 until wedgeBlocks operation worked out edgeVal = opening.edgeV(x + w / 2, edgeBinary) if edgeVal is None: edgeVal = 0.0 RightVertOffset = -(row.z - (row.h / 2) * edgeBinary - edgeVal) # Wedges are on top = off, blank, off, blank # Wedges are on btm = blank, off, blank, off ThisBlockOffsets = [[0, 0, LeftVertOffset]] * 2 + [[0] * 3] * 2 + [[0, 0, RightVertOffset]] * 2 # Insert or append "blank" for top or bottom wedges. if edgeBinary == 1: ThisBlockOffsets = ThisBlockOffsets + [[0] * 3] * 2 else: ThisBlockOffsets = [[0] * 3] * 2 + ThisBlockOffsets row.BlocksEdge.append([x, row.z, w, row.h, ThisBlockDepth, ThisBlockOffsets]) return None def bevelBlockOffsets(offsets, bevel, side): """ Take the block offsets and modify it for the correct bevel. offsets = the offset list. See MakeABlock bevel = how much to offset the edge side = -1 for left (right side), 1 for right (left side) """ if side == 1: pointsToAffect = (0, 2) # right else: pointsToAffect = (4, 6) # left for num in pointsToAffect: offsets[num] = offsets[num][:] offsets[num][0] += bevel * side def rowProcessing(row, Thesketch, WallBoundaries): __doc__ = """\ Take row and opening data and process a single row, adding edge and fill blocks to the row data. """ # set end blocks # check for openings, record top and bottom of row for right and left of each # if both top and bottom intersect create blocks on each edge, appropriate to the size of the overlap # if only one side intersects, run fill to get edge positions, but this should never happen if radialized: # this checks for radial stonework, and sets the row radius if required if slope: r1 = abs(dims['t'] * sin(row.z * PI / (dims['t'] * 2))) else: r1 = abs(row.z) else: r1 = 1 # set the edge grout thickness, especially with radial stonework in mind edgrt = settings['ge'] * (settings['g'] / 2 + rndc() * settings['gv']) / (2 * r1) # Sets up a list of intersections of top of row with openings, # from left to right [left edge of opening, right edge of opening, etc...] # initially just the left and right edge of the wall edgetop = [[dims['s'] + row.EdgeOffset / r1 + edgrt, WallBoundaries], [dims['e'] + row.EdgeOffset / r1 - edgrt, WallBoundaries]] # Same as edgetop, but for the bottms of the rows edgebtm = [[dims['s'] + row.EdgeOffset / r1 + edgrt, WallBoundaries], [dims['e'] + row.EdgeOffset / r1 - edgrt, WallBoundaries]] # set up some useful values for the top and bottom of the rows. rowTop = row.z + row.h / 2 rowBtm = row.z - row.h / 2 for hole in Thesketch: # check the top and bottom of the row, looking at the opening from the right e = [hole.edgeS(rowTop, -1), hole.edgeS(rowBtm, -1)] # If either one hit the opening, make split points for the left side of the opening. if e[0] or e[1]: e += [hole.edgeS(rowTop, 1), hole.edgeS(rowBtm, 1)] # If one of them missed for some reason, set that value to # the middle of the opening. for i, pos in enumerate(e): if pos is None: e[i] = hole.x # add the intersects to the list of edge points edgetop.append([e[0], hole]) edgetop.append([e[2], hole]) edgebtm.append([e[1], hole]) edgebtm.append([e[3], hole]) # We want to make the walls in order, so sort the intersects. # This is where you would want to remove edge points that are out of order # so that you don't get the "oddity where overlapping openings # create blocks inversely" problem # Note: sort ended up comparing function pointers # if both Openings and Slots were enabled with Repeats in one of them try: edgetop.sort(key=lambda x: x[0]) edgebtm.sort(key=lambda x: x[0]) except Exception as ex: debug_prints(func="rowProcessing", text="Sorting has failed", var=ex) # these two loops trim the edges to the limits of the wall. # This way openings extending outside the wall don't enlarge the wall. while True: try: if ((edgetop[-1][0] > dims['e'] + row.EdgeOffset / r1) or (edgebtm[-1][0] > dims['e'] + row.EdgeOffset / r1)): edgetop[-2:] = [] edgebtm[-2:] = [] else: break except IndexError: break # still trimming the edges... while True: try: if ((edgetop[0][0] < dims['s'] + row.EdgeOffset / r1) or (edgebtm[0][0] < dims['s'] + row.EdgeOffset / r1)): edgetop[:2] = [] edgebtm[:2] = [] else: break except IndexError: break # make those edge blocks and rows! Wooo! # This loop goes through each section, (a pair of points in edgetop) # and places the edge blocks and inbetween normal block zones into the row object for OpnSplitNo in range(int(len(edgetop) / 2)): # left edge is edge[2*OpnSplitNo], right edge edgex[2*OpnSplitNo+1] leftEdgeIndex = 2 * OpnSplitNo rightEdgeIndex = 2 * OpnSplitNo + 1 # get the openings, to save time and confusion leftOpening = edgetop[leftEdgeIndex][1] rightOpening = edgetop[rightEdgeIndex][1] # find the difference between the edge top and bottom on both sides LTop = edgetop[leftEdgeIndex][0] LBtm = edgebtm[leftEdgeIndex][0] RTop = edgetop[rightEdgeIndex][0] RBtm = edgebtm[rightEdgeIndex][0] LDiff = LBtm - LTop RDiff = RTop - RBtm # which is further out on each side, top or bottom? if LDiff > 0: LNerEdge = LBtm # the nearer edge left LEB = 1 # Left Edge Boolean, set to 1 if furthest edge is top, -1 if it is bottom else: LNerEdge = LTop LEB = -1 if RDiff > 0: RNerEdge = RBtm # the nearer edge right REB = 1 # Right Edge Boolean, set to 1 if furthest edge is top, -1 if it is bottom else: RNerEdge = RTop REB = -1 # Right Edge Boolean, set to 1 if furthest edge is top, -1 if it is bottom # The space between the closest edges of the openings in this section of the row InnerDiff = RNerEdge - LNerEdge # The mid point between the nearest edges InnerMid = (RNerEdge + LNerEdge) / 2 # maximum distance to span with one block MaxWid = (settings['w'] + settings['wv']) / r1 AveWid = settings['w'] # check the left and right sides for wedge blocks # Check and run the left edge first # find the edge of the correct side, offset for minimum block height. The LEB decides top or bottom ZPositionCheck = row.z + (row.h / 2 - settings['hm']) * LEB # edgeS may return "None" LeftWedgeEdge = leftOpening.edgeS(ZPositionCheck, 1) if (abs(LDiff) > AveWid) or (not LeftWedgeEdge): # make wedge blocks if not LeftWedgeEdge: LeftWedgeEdge = leftOpening.x wedgeBlocks(row, leftOpening, LeftWedgeEdge, LNerEdge, LEB, r1) # set the near and far edge settings to vertical, so the other edge blocks don't interfere LTop, LBtm = LNerEdge, LNerEdge LDiff = 0 # Now do the wedge blocks for the right, same drill... repeated code? # find the edge of the correct side, offset for minimum block height. The REB decides top or bottom ZPositionCheck = row.z + (row.h / 2 - settings['hm']) * REB # edgeS may return "None" RightWedgeEdge = rightOpening.edgeS(ZPositionCheck, -1) if (abs(RDiff) > AveWid) or (not RightWedgeEdge): # make wedge blocks if not RightWedgeEdge: RightWedgeEdge = rightOpening.x wedgeBlocks(row, rightOpening, RNerEdge, RightWedgeEdge, REB, r1) # set the near and far edge settings to vertical, so the other edge blocks don't interfere RTop, RBtm = RNerEdge, RNerEdge RDiff = 0 # Check to see if the edges are close enough toegther to warrant a single block filling it if (InnerDiff < MaxWid): # if this is true, then this row is just one block! x = (LNerEdge + RNerEdge) / 2. w = InnerDiff ThisBlockDepth = rndd() * settings['dv'] + settings['d'] BtmOff = LBtm - LNerEdge TopOff = LTop - LNerEdge ThisBlockOffsets = [[BtmOff, 0, 0]] * 2 + [[TopOff, 0, 0]] * 2 BtmOff = RBtm - RNerEdge TopOff = RTop - RNerEdge ThisBlockOffsets += [[BtmOff, 0, 0]] * 2 + [[TopOff, 0, 0]] * 2 bevel = leftOpening.edgeBev(rowTop) bevelBlockOffsets(ThisBlockOffsets, bevel, 1) bevel = rightOpening.edgeBev(rowTop) bevelBlockOffsets(ThisBlockOffsets, bevel, -1) row.BlocksEdge.append([x, row.z, w, row.h, ThisBlockDepth, ThisBlockOffsets]) continue # it's not one block, must be two or more # set up the offsets for the left BtmOff = LBtm - LNerEdge TopOff = LTop - LNerEdge leftOffsets = [[BtmOff, 0, 0]] * 2 + [[TopOff, 0, 0]] * 2 + [[0] * 3] * 4 bevelL = leftOpening.edgeBev(rowTop) bevelBlockOffsets(leftOffsets, bevelL, 1) # and now for the right BtmOff = RBtm - RNerEdge TopOff = RTop - RNerEdge rightOffsets = [[0] * 3] * 4 + [[BtmOff, 0, 0]] * 2 + [[TopOff, 0, 0]] * 2 bevelR = rightOpening.edgeBev(rowTop) bevelBlockOffsets(rightOffsets, bevelR, -1) # check to see if it is only two blocks if (InnerDiff < MaxWid * 2): # this row is just two blocks! Left block, then right block # div is the x position of the dividing point between the two bricks div = InnerMid + (rndd() * settings['wv']) / r1 # set the grout distance, since we need grout separation between the blocks grt = (settings['g'] + rndc() * settings['gv']) / r1 # set the x position and width for the left block x = (div + LNerEdge) / 2 - grt / 4 w = (div - LNerEdge) - grt / 2 ThisBlockDepth = rndd() * settings['dv'] + settings['d'] # For reference: EdgeBlocks = [[x, z, w, h, d, [corner offset matrix]], [etc.]] row.BlocksEdge.append([x, row.z, w, row.h, ThisBlockDepth, leftOffsets]) # Initialize for the block on the right side x = (div + RNerEdge) / 2 + grt / 4 w = (RNerEdge - div) - grt / 2 ThisBlockDepth = rndd() * settings['dv'] + settings['d'] row.BlocksEdge.append([x, row.z, w, row.h, ThisBlockDepth, rightOffsets]) continue # program should only get here if there are more than two blocks in the row, and no wedge blocks # make Left edge block # set the grout grt = (settings['g'] + rndc() * settings['gv']) / r1 # set the x position and width for the left block widOptions = [settings['w'], bevelL + settings['wm'], leftOpening.ts] baseWid = max(widOptions) w = (rndd() * settings['wv'] + baseWid + row. EdgeOffset) widOptions[0] = settings['wm'] widOptions[2] = w w = max(widOptions) / r1 - grt x = w / 2 + LNerEdge + grt / 2 BlockRowL = x + w / 2 ThisBlockDepth = rndd() * settings['dv'] + settings['d'] row.BlocksEdge.append([x, row.z, w, row.h, ThisBlockDepth, leftOffsets]) # make Right edge block # set the grout grt = (settings['g'] + rndc() * settings['gv']) / r1 # set the x position and width for the left block widOptions = [settings['w'], bevelR + settings['wm'], rightOpening.ts] baseWid = max(widOptions) w = (rndd() * settings['wv'] + baseWid + row.EdgeOffset) widOptions[0] = settings['wm'] widOptions[2] = w w = max(widOptions) / r1 - grt x = RNerEdge - w / 2 - grt / 2 BlockRowR = x - w / 2 ThisBlockDepth = rndd() * settings['dv'] + settings['d'] row.BlocksEdge.append([x, row.z, w, row.h, ThisBlockDepth, rightOffsets]) row.RowSegments.append([BlockRowL, BlockRowR]) return None def plan(Thesketch, oldrows=0): __doc__ = """\ The 'plan' function takes the data generated by the sketch function and the global settings and creates a list of blocks. It passes out a list of row heights, edge positions, edge blocks, and rows of blocks. """ # if we were passed a list of rows already, use those; else make a list. if oldrows: rows = oldrows else: # rows holds the important information common to all rows # rows = [list of row objects] rows = [] # splits are places where we NEED a row division, to accommodate openings # add a split for the bottom row splits = [dims['b'] + settings['hb']] # add a split for each critical point on each opening for hole in Thesketch: splits += hole.crits() # and, a split for the top row splits.append(dims['t'] - settings['ht']) splits.sort() # divs are the normal old row divisions, add them between the top and bottom split divs = fill(splits[0], splits[-1], settings['h'], settings['hm'] + settings['g'], settings['hv'])[1: -1] # remove the divisions that are too close to the splits, so we don't get tiny thin rows for i in range(len(divs) - 1, -1, -1): for j in range(len(splits)): diff = abs(divs[i] - splits[j]) if diff < (settings['h'] - settings['hv'] + settings['g']): del(divs[i]) break # now merge the divs and splits lists divs += splits # add bottom and/or top points, if bottom and/or top row heights are more than zero if settings['hb'] > 0: divs.insert(0, dims['b']) if settings['ht'] > 0: divs.append(dims['t']) divs.sort() # trim the rows to the bottom and top of the wall if divs[0] < dims['b']: divs[:1] = [] if divs[-1] > dims['t']: divs[-1:] = [] # now, make the data for each row # rows = [[center height,row height,edge offset],[etc.]] divCount = len(divs) - 1 # number of divs to check divCheck = 0 # current div entry while divCheck < divCount: RowZ = (divs[divCheck] + divs[divCheck + 1]) / 2 RowHeight = divs[divCheck + 1] - divs[divCheck] - settings['g'] + rndc() * \ settings['rwhl'] * settings['gv'] EdgeOffset = settings['eoff'] * (fmod(divCheck, 2) - 0.5) + settings['eoffv'] * rndd() # if row height is too shallow: delete next div entry, decrement total, and recheck current entry. if RowHeight < settings['hm']: del(divs[divCheck + 1]) divCount -= 1 # Adjust count for removed div entry. continue rows.append(rowOb(RowZ, RowHeight, EdgeOffset)) divCheck += 1 # on to next div entry # set up a special opening object to handle the edges of the wall x = (dims['s'] + dims['e']) / 2 z = (dims['t'] + dims['b']) / 2 w = (dims['e'] - dims['s']) h = (dims['t'] - dims['b']) WallBoundaries = openingInvert(x, z, w, h) # Go over each row in the list, set up edge blocks and block sections for rownum in range(len(rows)): rowProcessing(rows[rownum], Thesketch, WallBoundaries) # now return the things everyone needs # return [rows,edgeBlocks,blockRows,Asketch] return [rows, Thesketch] def archGeneration(hole, vlist, flist, sideSign): __doc__ = """\ Makes arches for the top and bottom, depending on sideSign example, Lower arch: archGeneration(hole, vlist, flist, -1) example, Upper arch: archGeneration(hole, vlist, flist, 1) hole is the opening object that the arch is for add the vertices to vlist add the faces to flist sideSign is + or - 1, for the top or bottom arch. Other values may cause errors. """ # working arrays for vectors and faces avlist = [] aflist = [] # Top (1) or bottom (-1) if sideSign == -1: r = hole.rl # radius of the arch rt = hole.rtl # thickness of the arch (stone height) v = hole.vl # height of the arch c = hole.cl else: r = hole.r # radius of the arch rt = hole.rt # thickness of the arch (stone height) v = hole.v # height of the arch c = hole.c ra = r + rt / 2 # average radius of the arch x = hole.x w = hole.w h = hole.h z = hole.z bev = hole.b sideSignInv = -sideSign if v > w / 2: # two arcs, to make a pointed arch # positioning zpos = z + (h / 2) * sideSign xoffset = r - w / 2 # left side top, right side bottom # angles reference straight up, and are in radians bevRad = r + bev bevHt = sqrt(bevRad ** 2 - (bevRad - (w / 2 + bev)) ** 2) midHalfAngle = atan(v / (r - w / 2)) midHalfAngleBevel = atan(bevHt / (r - w / 2)) bevelAngle = midHalfAngle - midHalfAngleBevel anglebeg = (PI / 2) * (sideSignInv) angleend = (PI / 2) * (sideSignInv) + midHalfAngle avlist, aflist = arch(ra, rt, (xoffset) * (sideSign), zpos, anglebeg, angleend, bev, bevelAngle, len(vlist)) for i, vert in enumerate(avlist): avlist[i] = [vert[0] + hole.x, vert[1], vert[2]] vlist += avlist flist += aflist # right side top, left side bottom # angles reference straight up, and are in radians anglebeg = (PI / 2) * (sideSign) - midHalfAngle angleend = (PI / 2) * (sideSign) avlist, aflist = arch(ra, rt, (xoffset) * (sideSignInv), zpos, anglebeg, angleend, bev, bevelAngle, len(vlist)) for i, vert in enumerate(avlist): avlist[i] = [vert[0] + hole.x, vert[1], vert[2]] vlist += avlist flist += aflist # keystone Dpth = settings['d'] + rndc() * settings['dv'] Grout = settings['g'] + rndc() * settings['gv'] angleBevel = (PI / 2) * (sideSign) - midHalfAngle Wdth = (rt - Grout - bev) * 2 * sin(angleBevel) * sideSign # note, sin may be negative MidZ = ((sideSign) * (bevHt + h / 2.0) + z) + (rt - Grout - bev) \ * cos(angleBevel) # note, cos may come out negative nearCorner = sideSign * (MidZ - z) - v - h / 2 if sideSign == 1: TopHt = hole.top() - MidZ - Grout BtmHt = nearCorner else: BtmHt = - (hole.btm() - MidZ) - Grout TopHt = nearCorner # set the amount to bevel the keystone keystoneBevel = (bevHt - v) * sideSign if Wdth >= settings['hm']: avlist, aflist = MakeAKeystone(x, Wdth, MidZ, TopHt, BtmHt, Dpth, keystoneBevel, len(vlist)) if radialized: for i, vert in enumerate(avlist): if slope: r1 = dims['t'] * sin(vert[2] * PI / (dims['t'] * 2)) else: r1 = vert[2] avlist[i] = [((vert[0] - hole.x) / r1) + hole.x, vert[1], vert[2]] vlist += avlist flist += aflist # remove "debug note" once bevel is finalized. else: debug_prints(func="archGeneration", text="Keystone was too narrow - " + str(Wdth)) else: # only one arc - curve not peak. # bottom (sideSign -1) arch has poorly sized blocks... zpos = z + (sideSign * (h / 2 + v - r)) # single arc positioning # angles reference straight up, and are in radians if sideSign == -1: angleOffset = PI else: angleOffset = 0.0 if v < w / 2: halfangle = atan(w / (2 * (r - v))) anglebeg = angleOffset - halfangle angleend = angleOffset + halfangle else: anglebeg = angleOffset - PI / 2 angleend = angleOffset + PI / 2 avlist, aflist = arch(ra, rt, 0, zpos, anglebeg, angleend, bev, 0.0, len(vlist)) for i, vert in enumerate(avlist): avlist[i] = [vert[0] + x, vert[1], vert[2]] vlist += avlist flist += aflist # Make the Side Stones grt = (settings['g'] + rndc() * settings['gv']) width = sqrt(rt ** 2 - c ** 2) - grt if c > settings['hm'] + grt and c < width + grt: if radialized: subdivision = settings['sdv'] * (zpos + (h / 2) * sideSign) else: subdivision = settings['sdv'] # set the height of the block, it should be as high as the max corner position, minus grout height = c - grt * (0.5 + c / (width + grt)) # the vertical offset for the short side of the block voff = sideSign * (settings['hm'] - height) xstart = w / 2 zstart = z + sideSign * (h / 2 + grt / 2) woffset = width * (settings['hm'] + grt / 2) / (c - grt / 2) depth = rndd() * settings['dv'] + settings['d'] if sideSign == 1: offsets = [[0] * 3] * 6 + [[0] * 2 + [voff]] * 2 topSide = zstart + height btmSide = zstart else: offsets = [[0] * 3] * 4 + [[0] * 2 + [voff]] * 2 + [[0] * 3] * 2 topSide = zstart btmSide = zstart - height # Do some stuff to incorporate bev here bevelBlockOffsets(offsets, bev, -1) avlist, aflist = MakeABlock( [x - xstart - width, x - xstart - woffset, btmSide, topSide, -depth / 2, depth / 2], subdivision, len(vlist), Offsets=offsets, xBevScl=1 ) # top didn't use radialized in prev version; # just noting for clarity - may need to revise for "sideSign == 1" if radialized: for i, vert in enumerate(avlist): avlist[i] = [((vert[0] - x) / vert[2]) + x, vert[1], vert[2]] vlist += avlist flist += aflist # keep sizing same - neat arches = master masons :) # grt = (settings['g'] + rndc()*settings['gv']) # height = c - grt*(0.5 + c/(width + grt)) # if grout varies may as well change width too... width = sqrt(rt**2 - c**2) - grt # voff = sideSign * (settings['hm'] - height) # woffset = width*(settings['hm'] + grt/2)/(c - grt/2) if sideSign == 1: offsets = [[0] * 3] * 2 + [[0] * 2 + [voff]] * 2 + [[0] * 3] * 4 topSide = zstart + height btmSide = zstart else: offsets = [[0] * 2 + [voff]] * 2 + [[0] * 3] * 6 topSide = zstart btmSide = zstart - height # Do some stuff to incorporate bev here bevelBlockOffsets(offsets, bev, 1) avlist, aflist = MakeABlock( [x + xstart + woffset, x + xstart + width, btmSide, topSide, -depth / 2, depth / 2], subdivision, len(vlist), Offsets=offsets, xBevScl=1 ) # top didn't use radialized in prev version; # just noting for clarity - may need to revise for "sideSign == 1" if radialized: for i, vert in enumerate(avlist): avlist[i] = [((vert[0] - x) / vert[2]) + x, vert[1], vert[2]] vlist += avlist flist += aflist return None def build(Aplan): __doc__ = """\ Build creates the geometry for the wall, based on the "Aplan" object from the "plan" function. If physics is enabled, then it make a number of individual blocks with physics interaction enabled. Otherwise it creates geometry for the blocks, arches, etc. of the wall. """ vlist = [] flist = [] rows = Aplan[0] # all the edge blocks, redacted # AllBlocks = [[x, z, w, h, d, [corner offset matrix]], [etc.]] # loop through each row, adding the normal old blocks for rowidx in range(len(rows)): rows[rowidx].FillBlocks() AllBlocks = [] # If the wall is set to merge blocks, check all the blocks to see if you can merge any # seems to only merge vertical, should do horizontal too if bigBlock: for rowidx in range(len(rows) - 1): if radialized: if slope: r1 = dims['t'] * sin(abs(rows[rowidx].z) * PI / (dims['t'] * 2)) else: r1 = abs(rows[rowidx].z) else: r1 = 1 Tolerance = settings['g'] / r1 idxThis = len(rows[rowidx].BlocksNorm[:]) - 1 idxThat = len(rows[rowidx + 1].BlocksNorm[:]) - 1 while True: # end loop when either array idx wraps if idxThis < 0 or idxThat < 0: break blockThis = rows[rowidx].BlocksNorm[idxThis] blockThat = rows[rowidx + 1].BlocksNorm[idxThat] # seems to only merge vertical, should do horizontal too... cx, cz, cw, ch, cd = blockThis[:5] ox, oz, ow, oh, od = blockThat[:5] if (abs(cw - ow) < Tolerance) and (abs(cx - ox) < Tolerance): if cw > ow: BlockW = ow else: BlockW = cw AllBlocks.append([(cx + ox) / 2, (cz + oz + (oh - ch) / 2) / 2, BlockW, abs(cz - oz) + (ch + oh) / 2, (cd + od) / 2, None]) rows[rowidx].BlocksNorm.pop(idxThis) rows[rowidx + 1].BlocksNorm.pop(idxThat) idxThis -= 1 idxThat -= 1 elif cx > ox: idxThis -= 1 else: idxThat -= 1 # Add blocks to create a "shelf/platform". # Does not account for openings (crosses gaps - which is a good thing) if shelfExt: SetGrtOff = settings['g'] / 2 # half grout for block size modifier # Use wall block settings for shelf SetBW = settings['w'] SetBWVar = settings['wv'] SetBWMin = settings['wm'] SetBH = settings['h'] # Shelf area settings ShelfLft = shelfSpecs['x'] ShelfBtm = shelfSpecs['z'] ShelfEnd = ShelfLft + shelfSpecs['w'] ShelfTop = ShelfBtm + shelfSpecs['h'] ShelfThk = shelfSpecs['d'] * 2 # use double-depth due to offsets to position at cursor. # Use "corners" to adjust position so not centered on depth. # Facing shelf, at cursor (middle of wall blocks) # - this way no gaps between platform and wall face due to wall block depth. wallDepth = settings['d'] / 2 # offset by wall depth so step depth matches UI setting :) if shelfBack: # place blocks on backside of wall ShelfOffsets = [ [0, ShelfThk / 2, 0], [0, wallDepth, 0], [0, ShelfThk / 2, 0], [0, wallDepth, 0], [0, ShelfThk / 2, 0], [0, wallDepth, 0], [0, ShelfThk / 2, 0], [0, wallDepth, 0] ] else: ShelfOffsets = [ [0, -wallDepth, 0], [0, -ShelfThk / 2, 0], [0, -wallDepth, 0], [0, -ShelfThk / 2, 0], [0, -wallDepth, 0], [0, -ShelfThk / 2, 0], [0, -wallDepth, 0], [0, -ShelfThk / 2, 0] ] # Add blocks for each "shelf row" in area while ShelfBtm < ShelfTop: # Make blocks for each row - based on rowOb::fillblocks # Does not vary grout. divs = fill(ShelfLft, ShelfEnd, SetBW, SetBWMin, SetBWVar) # loop through the row divisions, adding blocks for each one for i in range(len(divs) - 1): ThisBlockx = (divs[i] + divs[i + 1]) / 2 ThisBlockw = divs[i + 1] - divs[i] - SetGrtOff AllBlocks.append([ThisBlockx, ShelfBtm, ThisBlockw, SetBH, ShelfThk, ShelfOffsets]) ShelfBtm += SetBH + SetGrtOff # moving up to next row... # Add blocks to create "steps". # Does not account for openings (crosses gaps - which is a good thing) if stepMod: SetGrtOff = settings['g'] / 2 # half grout for block size modifier # Vary block width by wall block variations. SetWidVar = settings['wv'] SetWidMin = settings['wm'] StepXMod = stepSpecs['t'] # width of step/tread, also sets basic block size. StepZMod = stepSpecs['v'] StepLft = stepSpecs['x'] StepRt = stepSpecs['x'] + stepSpecs['w'] StepBtm = stepSpecs['z'] + StepZMod / 2 # Start offset for centered blocks StepWide = stepSpecs['w'] StepTop = StepBtm + stepSpecs['h'] StepThk = stepSpecs['d'] * 2 # use double-depth due to offsets to position at cursor. # Use "corners" to adjust steps so not centered on depth. # Facing steps, at cursor (middle of wall blocks) # - this way no gaps between steps and wall face due to wall block depth. # Also, will work fine as stand-alone if not used with wall (try block depth 0 and see what happens). wallDepth = settings['d'] / 2 if stepBack: # place blocks on backside of wall StepOffsets = [ [0, StepThk / 2, 0], [0, wallDepth, 0], [0, StepThk / 2, 0], [0, wallDepth, 0], [0, StepThk / 2, 0], [0, wallDepth, 0], [0, StepThk / 2, 0], [0, wallDepth, 0] ] else: StepOffsets = [ [0, -wallDepth, 0], [0, -StepThk / 2, 0], [0, -wallDepth, 0], [0, -StepThk / 2, 0], [0, -wallDepth, 0], [0, -StepThk / 2, 0], [0, -wallDepth, 0], [0, -StepThk / 2, 0] ] # Add steps for each "step row" in area (neg width is interesting but prevented) while StepBtm < StepTop and StepWide > 0: # Make blocks for each step row - based on rowOb::fillblocks # Does not vary grout. if stepOnly: # "cantilevered steps" if stepLeft: stepStart = StepRt - StepXMod else: stepStart = StepLft AllBlocks.append([stepStart, StepBtm, StepXMod, StepZMod, StepThk, StepOffsets]) else: divs = fill(StepLft, StepRt, StepXMod, SetWidMin, SetWidVar) # loop through the row divisions, adding blocks for each one for i in range(len(divs) - 1): ThisBlockx = (divs[i] + divs[i + 1]) / 2 ThisBlockw = divs[i + 1] - divs[i] - SetGrtOff AllBlocks.append([ThisBlockx, StepBtm, ThisBlockw, StepZMod, StepThk, StepOffsets]) StepBtm += StepZMod + SetGrtOff # moving up to next row... StepWide -= StepXMod # reduce step width # adjust side limit depending on direction of steps if stepLeft: StepRt -= StepXMod # move in from right else: StepLft += StepXMod # move in from left # Copy all the blocks out of the rows for row in rows: AllBlocks += row.BlocksEdge AllBlocks += row.BlocksNorm # This loop makes individual blocks for each block specified in the plan for block in AllBlocks: x, z, w, h, d, corners = block if radialized: if slope: r1 = dims['t'] * sin(z * PI / (dims['t'] * 2)) else: r1 = z else: r1 = 1 geom = MakeABlock([x - w / 2, x + w / 2, z - h / 2, z + h / 2, -d / 2, d / 2], settings['sdv'], len(vlist), corners, None, settings['b'] + rndd() * settings['bv'], r1) vlist += geom[0] flist += geom[1] # This loop makes Arches for every opening specified in the plan. for hole in Aplan[1]: # lower arch stones if hole.vl > 0 and hole.rtl > (settings['g'] + settings['hm']): # make lower arch blocks archGeneration(hole, vlist, flist, -1) # top arch stones if hole.v > 0 and hole.rt > (settings['g'] + settings['hm']): # make upper arch blocks archGeneration(hole, vlist, flist, 1) # Warp all the points for domed stonework if slope: for i, vert in enumerate(vlist): vlist[i] = [vert[0], (dims['t'] + vert[1]) * cos(vert[2] * PI / (2 * dims['t'])), (dims['t'] + vert[1]) * sin(vert[2] * PI / (2 * dims['t']))] # Warp all the points for radial stonework if radialized: for i, vert in enumerate(vlist): vlist[i] = [vert[2] * cos(vert[0]), vert[2] * sin(vert[0]), vert[1]] return vlist, flist # The main function def createWall(radial, curve, openings, mergeBlox, shelf, shelfSide, steps, stepDir, stepBare, stepSide): __doc__ = """\ Call all the functions you need to make a wall, return the verts and faces. """ global radialized global slope global openingSpecs global bigBlock global shelfExt global stepMod global stepLeft global shelfBack global stepOnly global stepBack # set all the working variables from passed parameters radialized = radial slope = curve openingSpecs = openings bigBlock = mergeBlox shelfExt = shelf stepMod = steps stepLeft = stepDir shelfBack = shelfSide stepOnly = stepBare stepBack = stepSide asketch = sketch() aplan = plan(asketch, 0) return build(aplan)