building.cga

/**
 * File:    building.cga
 * Created: 21 Aug 2020 12:25:40 GMT
 * Author:  Esri R&D Center Zurich
 */

version "2020.0"


// ------------------------------
// Attributes
// ------------------------------

@Group("Info", 0)

@Order(1)
attr name = ""


@Group("Building Mass", 1)

@Order(1)
@Range(min=3, max=80, stepsize=1, restricted=false)
attr height = 20

@Order(2)
@Range(min=0, max=10, stepsize=1, restricted=false)
attr roofHeight = 5

@Order(3)
@Enum("flat", "gable", "hip", "mansard", "M shaped")
attr roofShape = getInitRoofShape


@Group("Mass Details", 2)

@Order(1)
@Range(min=0, max=5, stepsize=1, restricted=false)
attr numBoxesOnFlatRoof = 2

@Order(2)
@Range(min=0, max=10, stepsize=0.5, restricted=false)
@Description("has tower/podium when non-negative")
attr podiumHeight = 0


@Group("Facade Details", 3)

@Order(1)
@Range(min=3, max=5, stepsize=0.5, restricted=false)
attr floorHeight = 4

@Order(2)
@Range(min=0, max=2, stepsize=0.1, restricted=false)
attr raisedHeight = 0.5 * floorHeight

@Order(3)
@Range(min=1, max=10, stepsize=1, restricted=false)
attr tileWidth = 4

@Order(4)
@Range(min=1, max=5, stepsize=1, restricted=false)
attr windowWidth = 2

@Order(5)
@Range(min=1, max=5, stepsize=1, restricted=false)
attr windowHeight = 2

@Order(6)
@Range(min=0.05, max=0.5, stepsize=0.05, restricted=false)
attr windowDepth = 0.25

@Order(7)
@Range(min=10, max=60, stepsize=5, restricted=false)
@Description("split facades into pieces of approximately this facade length or less")
attr approxFacadeWidth = 40

@Order(8)
@Description("approx width of breaks between long facades")
@Range(min=1, max=10, stepsize=1, restricted=false)
attr innerPaddingWidth = 4


@Group("Roof Colors", 4)

@Order(1)
@Color
attr roofColor = "#d96a6a"

@Order(2)
@Color
attr boxOnRoofColor = "#d96a6a"


@Group("Facade Colors", 5)

@Order(1)
@Color
attr groundColor = "#fff5de"

@Order(2)
@Color
attr upperColor = "#fff5de"

@Order(3)
@Color
attr topColor = "#fff5de"

@Order(4)
@Color
attr paddingColor = "#ffffff"

@Order(5)
@Color
attr windowColor = "#c7cccb"

@Order(6)
@Color
attr windowFrameColor = "#c7cccb"


@Group("Locally Editable Attributes", 6)

@Order(1)
@Handle(shape=Facade, type=selector, occlusion=false)
@Enum("wall", "windows", "one window", "double windows 1", "double windows 2")
attr windowPattern = "windows"


@Hidden
attr _isGroundFloor = false
@Hidden
attr _isTopFloor = false
@Hidden
attr _isPodium = false
@Hidden
attr _isTower = false


// ------------------------------
// Constants and Functions
// ------------------------------

const cleanupTolerance = 0.5
const minTowerFraction = 0.6		// tower is fraction of orig width
const maxTowerFraction = 0.8
const roofOverhang = 0.5
const raisedBorderRoofWidth = 0.25	// raised border on flat roof
const raisedBorderRoofHeight = 0.5
const minBoxWidth = 3				// boxes on flat roof
const minBoxHeight = 1
const maxBoxHeight = max(minBoxHeight, roofHeight)
const mansardAngle = 70				// angle of lower slope of mansard roof
const mansardFraction = 0.7			// fraction of roofHeight for lower part of mansard roof
const windowFrameThickness = 0.1

getInitRoofShape =
	case roofHeight==0:			"flat"
	case geometry.area>4000:	"mansard"
	else: 						"hip"

getMinBoxWidth = max(min(0.1*scope.sx, 0.1*scope.sy), minBoxWidth)
getMaxBoxWidth = max(min(0.4*scope.sx, 0.4*scope.sy), minBoxWidth)



// ------------------------------
// Start Rule
// ------------------------------


Lot -->
	case podiumHeight>0:
		Reports
		cleanupGeometry(all, cleanupTolerance)
		Podium
		Tower
	else:
	   	Reports
	   	cleanupGeometry(all, cleanupTolerance)
		extrude(height-roofHeight)
		Mass


// ------------------------------
// Mass
// ------------------------------

Podium -->
	set(_isPodium, true)
	set(roofShape, "flat")
	set(numBoxesOnFlatRoof, 0)
	extrude(podiumHeight)
	Mass
	
Tower -->
	t(0, podiumHeight, 0)
	alignScopeToGeometry(yUp, largest, longest)
	innerRectangle(scope) { shape: Tower_Resize(scope.sx, scope.sz, rand(minTowerFraction, maxTowerFraction)*scope.sx, rand(minTowerFraction, maxTowerFraction)*scope.sz) }
	
Tower_Resize(x, z, newX, newZ) -->
	s(newX, 0, newZ)
	t(rand(0, x-newX), 0, rand(0, z-newZ))
	extrude(height-podiumHeight-roofHeight)
	set(_isTower, true)
	Mass
		
Mass -->
    comp(f) { top= Roof
    		| side: Facade(windowPattern)
    		| bottom: Bottom. }
   	
// ------------------------------
// Roof
// ------------------------------

Roof --> 
	case roofShape=="flat":		FlatRoof
	case roofShape=="gable":	GableRoof
	case roofShape=="hip":		HipRoof
	case roofShape=="mansard": 	MansardRoof
	case roofShape=="M shaped":	MShapedRoof
	else:						HipRoof
		
FlatRoof -->
    offset(-raisedBorderRoofWidth)
    comp(f) { inside: RoofMaterial
    				  Boxes(getMinBoxWidth, getMaxBoxWidth)
    		| border: extrude(raisedBorderRoofHeight) RoofMaterial }
    
Boxes(minWidth, maxWidth) -->
	case numBoxesOnFlatRoof>0:
		offset(-0.5*maxWidth)
		comp(f) { inside: scatter(surface, numBoxesOnFlatRoof, uniform) { Box(minWidth, maxWidth) } }
	else:
		NIL

Box(minWidth, maxWidth) -->
	set(trim.vertical, false)
	primitiveCube()
	s(rand(minWidth,maxWidth), rand(minBoxHeight,maxBoxHeight), rand(minWidth,maxWidth))
	center(xz)
	color(boxOnRoofColor)

GableRoof -->
	roofGable(byHeight, roofHeight, roofOverhang)
	comp(f) { vertical: set(_isTopFloor, true) Wall
			| all: RoofMaterial }
	
HipRoof -->
    roofHip(byHeight, roofHeight, roofOverhang)
    RoofMaterial
    
MansardRoof -->
	roofHip(byAngle, mansardAngle, roofOverhang)
	split(y) { mansardFraction*roofHeight: comp(f) { bottom: NIL
									   | top: roofHip(byHeight, (1-mansardFraction)*roofHeight)
									   		  RoofMaterial
									   | all: RoofMaterial } }

MShapedRoof -->
	comp(f) { all: alignScopeToGeometry(yUp, any, longest)
				   split(z) { ~1: GableRoof | ~1: GableRoof } }

RoofMaterial -->
	color(roofColor)
	
	
// ------------------------------
// Facade
// ------------------------------

Facade(pattern) -->
	split(y) { raisedHeight: RaisedWall
			 | { ~floorHeight: Floor(split.index, pattern) }* }
 
RaisedWall -->
	case _isTower:
		Floor(0, "wall")
	else:
		set(_isGroundFloor, true)
		Wall
   
Floor(floorInd, pattern) --> 
	set(_isGroundFloor, floorInd==0 && !_isTower)
	set(_isTopFloor, floorInd==split.total-1 && !_isPodium)
	[
	case scope.sx<windowWidth:
		Wall
	else:
		split(x) { ~1: Padding
				 | ~12: FloorSection(pattern)
				 | ~1: Padding }
	]

FloorSection(pattern) -->
	split(x) { { ~approxFacadeWidth: Windows(pattern)
			   | ~innerPaddingWidth: Padding }*
			 | ~approxFacadeWidth: Windows(pattern) }
		
Windows(pattern) -->
	case pattern=="wall":
		Wall
	case pattern=="one window":
		Tile
	case pattern=="double windows 1":
		split(x) { ~1: Wall
				 | ~tileWidth: Tile
				 | ~tileWidth: Tile
				 | ~1: Wall }*
	case pattern=="double windows 2":
		split(x) { ~tileWidth: Tile_DoubleWindow }*
	else:
		split(x) { ~tileWidth: Tile }*
	
Tile -->
	split(x) { ~1: Wall
			 | windowWidth: split(y) { ~1: Wall
			 						 | windowHeight: Window
			 						 | ~1: Wall }
			 | ~1: Wall }
	
Tile_DoubleWindow -->
	split(x) { ~2: Wall
			 | windowWidth: split(y) { ~1: Wall
			 						 | windowHeight: Window
			 						 | ~1: Wall }
			 | windowWidth: split(y) { ~1: Wall
			 						 | windowHeight: Window
			 						 | ~1: Wall }
			 | ~2: Wall }

Window -->
	t(0, 0, -windowDepth)
	offset(-windowFrameThickness)
	comp(f) { inside: Glass
			| border: extrude(windowDepth+0.1) WindowFrame }

Glass -->
	color(windowColor)
	
WindowFrame -->
	color(windowFrameColor)
	
Padding -->
	case _isGroundFloor && (groundColor!=upperColor):
		color(groundColor)
	case _isTopFloor && (topColor!=upperColor):
		color(topColor)
	else:
		color(paddingColor)
				
Wall -->
	case _isGroundFloor:
		color(groundColor)
	case _isTopFloor:
		color(topColor)
	else:
		color(upperColor)		
	
	
// ------------------------------
// Reports
// ------------------------------

Reports -->
	report("name", name)