//

// StandardLibrary.swift

// ShapeScript

//

// Created by Nick Lockwood on 18/12/2018.

// Copyright © 2018 Nick Lockwood. All rights reserved.

//

import Euclid

import Foundation

#if canImport(SVGPath)

import SVGPath

#endif

/// Standard library symbols. Useful for syntax highlighting

public let stdlibSymbols: Set<String> = {

var keys = Set<String>()

for (key, symbol) in Symbols.all {

keys.insert(key)

switch symbol {

case let .block(type, _):

keys.formUnion(type.options.keys)

case .function, .property, .constant, .option, .placeholder:

break

}

}

return keys

}()

extension Symbols {

static func + (lhs: Symbols, rhs: Symbols) -> Symbols {

lhs.merging(rhs) { $1 }

}

static let transform: Symbols = [

"position": .property(.vector, { parameter, context in

context.transform.translation = parameter.vectorValue

}, { context in

.vector(context.transform.translation)

}),

"orientation": .property(.rotation, { parameter, context in

context.transform.rotation = parameter.rotationValue

}, { context in

.rotation(context.transform.rotation)

}),

"size": .property(.size, { parameter, context in

context.transform.scale = parameter.vectorValue

}, { context in

.size(context.transform.scale)

}),

]

static let childTransform: Symbols = [

"translate": .command(.vector) { parameter, context in

let vector = parameter.vectorValue

context.childTransform.translate(by: vector)

},

"rotate": .command(.rotation) { parameter, context in

let rotation = parameter.rotationValue

context.childTransform.rotate(by: rotation)

},

"scale": .command(.size) { parameter, context in

let scale = parameter.vectorValue

context.childTransform.scale(by: scale)

},

]

static let colors: Symbols = [

"white": .constant(.color(.white)),

"black": .constant(.color(.black)),

"gray": .constant(.color(.gray)),

"red": .constant(.color(.red)),

"green": .constant(.color(.green)),

"blue": .constant(.color(.blue)),

"yellow": .constant(.color(.yellow)),

"cyan": .constant(.color(.cyan)),

"magenta": .constant(.color(.magenta)),

"orange": .constant(.color(.orange)),

]

static let color: Symbols = colors + [

"color": .property(.color, { parameter, context in

context.material.albedo = parameter.colorOrTextureValue

}, { context in

.color(context.material.color ?? .white)

}),

]

static let material: Symbols = color + [

"opacity": .property(.numberOrTexture, { parameter, context in

switch parameter {

case let .number(opacity):

let opacity = opacity * context.opacity

context.material.opacity = .color(.init(opacity, opacity))

case let .texture(texture):

guard let texture else { fallthrough }

let opacity = texture.intensity * context.opacity

context.material.opacity = .texture(texture.withIntensity(opacity))

default:

let opacity = context.opacity

context.material.opacity = .color(.init(opacity, opacity))

}

}, { context in

switch context.material.opacity ?? .color(.white) {

case let .color(color):

return .number(color.a / context.opacity)

case let .texture(texture):

// Since user cannot specify texture opacity, this should always be 1

let opacity = texture.intensity / context.opacity

return .texture(texture.withIntensity(opacity))

}

}),

"texture": .property(.texture, { parameter, context in

context.material.albedo = parameter.colorOrTextureValue

}, { context in

.texture(context.material.texture)

}),

"normals": .property(.texture, { parameter, context in

context.material.normals = parameter.value as? Texture

}, { context in

.texture(context.material.normals)

}),

"metallicity": .property(.numberOrTexture, { parameter, context in

context.material.metallicity = parameter.numberOrTextureValue

}, { context in

.numberOrTexture(context.material.metallicity ?? .color(.black))

}),

"roughness": .property(.numberOrTexture, { parameter, context in

context.material.roughness = parameter.numberOrTextureValue

}, { context in

.numberOrTexture(context.material.roughness ?? .color(.black))

}),

"glow": .property(.colorOrTexture, { parameter, context in

context.material.glow = parameter.colorOrTextureValue

}, { context in

.colorOrTexture(context.material.glow ?? .color(.black))

}),

"material": .property(.material, { parameter, context in

context.material = parameter.value as? Material ?? .default

}, { context in

.material(context.material)

}),

]

static let polygons: Symbols = [

"polygon": .block(.init(.polygon, [:], .point, .list(.polygon))) { context in

let path = Path(context.children.compactMap {

$0.value as? PathPoint

}).transformed(by: context.transform)

let polygons = path.closed().facePolygons(material: context.material)

return .tuple(polygons.map { .polygon($0) })

},

]

static let meshes: Symbols = [

// primitives

"cone": .block(.shape) { context in

.mesh(Geometry(type: .cone(segments: context.detail), in: context))

},

"cylinder": .block(.shape) { context in

.mesh(Geometry(type: .cylinder(segments: context.detail), in: context))

},

"sphere": .block(.shape) { context in

.mesh(Geometry(type: .sphere(segments: context.detail), in: context))

},

"cube": .block(.shape) { context in

.mesh(Geometry(type: .cube, in: context))

},

// container

"group": .block(.group) { context in

.mesh(Geometry(type: .group, in: context))

},

// builders

"extrude": .block(.init(.builder, [

"along": .list(.path),

"twist": .halfturns,

"axisAligned": .boolean,

], .path, .list(.mesh))) { context in

let twist = context.value(for: "twist")?.angleValue ?? .zero

let align: Path.Alignment = context.value(for: "axisAligned").map {

$0.boolValue ? .axis : .tangent

} ?? .default

if let along = context.value(for: "along")?.tupleValue as? [Path] {

// shapes follow a common path

return .mesh(Geometry(type: .extrude(context.paths, .init(

along: along.map { $0.withDetail(context.detail, twist: twist) },

twist: twist,

align: align

)), in: context))

}

if twist == .zero {

// Fast path - can reuse meshes (good for text)

return .mesh(Geometry(

type: .extrude(context.paths, .default),

in: context

))

}

// Slow path, each calculated separately, no reuse

return .tuple(context.paths.map {

let vector = $0.faceNormal / 2

let along = Path.line(-vector, vector).withDetail(context.detail, twist: twist)

return .mesh(Geometry(type: .extrude([$0], .init(

along: [along],

twist: twist,

align: align

)), in: context))

})

},

"lathe": .block(.builder) { context in

.mesh(Geometry(

type: .lathe(context.paths, segments: context.detail),

in: context

))

},

"loft": .block(.builder) { context in

.mesh(Geometry(type: .loft(context.paths), in: context))

},

"fill": .block(.builder) { context in

.mesh(Geometry(type: .fill(context.paths), in: context))

},

"hull": .block(.hull) { context in

let vertices = try context.children.flatMap { child -> [Vertex] in

switch child {

case let .point(point):

return [Vertex(point)]

case let .path(path):

return path.subpaths.flatMap(\.edgeVertices)

case let .mesh(geometry):

return geometry.path?.subpaths.flatMap(\.edgeVertices) ?? []

default:

throw RuntimeErrorType.assertionFailure(

"Unexpected child of type \(child.type) in hull"

)

}

}

return .mesh(Geometry(type: .hull(vertices), in: context))

},

"minkowski": .block(.minkowski) { context in

.mesh(Geometry(type: .minkowski, in: context))

},

// mesh

"mesh": .block(.mesh) { context in

let polygons = context.children.compactMap { $0.value as? Polygon }

return .mesh(Geometry(type: .mesh(Mesh(polygons)), in: context))

},

// csg

"union": .block(.group) { context in

.mesh(Geometry(type: .union, in: context))

},

"difference": .block(.group) { context in

.mesh(Geometry(type: .difference, in: context))

},

"intersection": .block(.group) { context in

.mesh(Geometry(type: .intersection, in: context))

},

"xor": .block(.group) { context in

.mesh(Geometry(type: .xor, in: context))

},

"stencil": .block(.group) { context in

.mesh(Geometry(type: .stencil, in: context))

},

// lights

"light": .block(.init(.node, [

"position": .vector,

"orientation": .rotation,

"color": .color,

"spread": .halfturns,

"penumbra": .number,

"shadow": .number,

], .void, .mesh)) { context in

let position = context.value(for: "position")?.value as? Vector

position.map { context.transform.translation = $0 }

let orientation = context.value(for: "orientation")?.value as? Rotation

orientation.map { context.transform.rotation = $0 }

return .mesh(Geometry(

type: .light(Light(

position: position,

orientation: orientation,

color: context.value(for: "color")?.colorValue ?? Light.default.color,

spread: context.value(for: "spread")?.angleValue ?? Light.default.spread,

penumbra: context.value(for: "penumbra")?.doubleValue ?? Light.default.penumbra,

shadowOpacity: context.value(for: "shadow")?.doubleValue ?? Light.default.shadowOpacity

)),

in: context

))

},

// debug

"debug": .block(.group) { context in

for case let .mesh(geometry) in context.children {

geometry.debug = true

}

if context.children.count == 1,

case let .mesh(child) = context.children[0]

{

return .mesh(child)

}

return .mesh(Geometry(type: .group, in: context))

},

]

static let paths: Symbols = [

"path": .block(.path) { context in

var subpaths = [Path]()

var points = [PathPoint]()

func endPath() {

if !points.isEmpty {

subpaths.append(.curve(points, detail: context.detail / 4))

}

points.removeAll()

}

for child in context.children {

switch child {

case let .point(point):

points.append(point)

case let .path(path):

endPath()

subpaths.append(path)

case .tuple:

// Special case due to tuple type returning element type

throw RuntimeErrorType.assertionFailure(

"Unexpected child of type tuple in path"

)

default:

throw RuntimeErrorType.assertionFailure(

"Unexpected child of type \(child.errorDescription) in path"

)

}

}

endPath()

if subpaths.count != 1 {

subpaths = [Path(subpaths: subpaths)]

}

return .path(subpaths[0].transformed(by: context.transform))

},

"arc": .block(.init(.polygon, [

"angle": .halfturns,

], .void, .list(.point))) { context in

let angle = context.value(for: "angle")?.angleValue ?? .pi

let span = Swift.max(0, Swift.min(1, abs(angle.radians) / (2 * .pi)))

var segments = Int(ceil(span * Double(context.detail)))

switch span {

case 0 ..< 0.5:

segments = Swift.max(1, segments)

case 0.5 ..< 1:

segments = Swift.max(2, segments)

default:

segments = Swift.max(3, segments)

}

return .path(Path.arc(

angle: angle,

segments: segments,

color: context.material.color

).transformed(by: context.transform))

},

"circle": .block(.pathShape) { context in

.path(Path.circle(

segments: context.detail,

color: context.material.color

).transformed(by: context.transform))

},

"square": .block(.pathShape) { context in

.path(Path.square(

color: context.material.color

).transformed(by: context.transform))

},

"polygon": .block(.init(.polygon, [

"sides": .number,

], .optional(.point), .union([.path, .list(.polygon)]))) { context in

let sides = context.value(for: "sides")?.intValue

let points = context.children.compactMap { $0.value as? PathPoint }

if !points.isEmpty {

if sides != nil {

throw RuntimeErrorType.assertionFailure("Polygon cannot have both sides and points")

}

let path = Path(points).transformed(by: context.transform)

let polygons = path.closed().facePolygons(material: context.material)

return .tuple(polygons.map { .polygon($0) })

}

return .path(Path.polygon(

sides: sides ?? 5,

color: context.material.color

).transformed(by: context.transform))

},

"roundrect": .block(.init(.pathShape, [

"radius": .number,

"size": .size,

], .void, .path)) { context in

let size = context.value(for: "size")?.value as? Vector ?? .one

let scale = Swift.min(size.x, size.y)

let radius = (context.value(for: "radius")?.doubleValue ?? 0.25) * scale

return .path(Path.roundedRectangle(

width: size.x,

height: size.y,

radius: radius,

detail: context.detail / 4,

color: context.material.color

).transformed(by: context.transform))

},

"text": .block(.init(.pathShape, [

"font": .font,

"wrapwidth": .number,

"linespacing": .number,

], .text, .list(.path))) { context in

let width = context.value(for: "wrapwidth")?.doubleValue

let text = context.children.compactMap { $0.value as? TextValue }

let paths = Path.text(text, width: width, detail: context.detail / 8)

return .tuple(paths.map { .path($0.transformed(by: context.transform)) })

},

"svgpath": .block(.init(.pathShape, [:], .string, .path)) { context in

let text = context.children.map(\.stringValue).joined(separator: "\n")

let svgPath: SVGPath

do {

svgPath = try SVGPath(string: text)

} catch let error as SVGError {

throw RuntimeErrorType.assertionFailure(error.message)

}

return .path(Path(

svgPath,

detail: context.detail / 4,

color: context.material.color

).transformed(by: context.transform))

},

]

static let points: Symbols = [

"point": .command(.vector) { parameter, context in

try context.addValue(.point(.point(

parameter.vectorValue,

color: context.material.color

)))

},

]

static let pathPoints: Symbols = _merge(points, [

"curve": .command(.vector) { parameter, context in

try context.addValue(.point(.curve(

parameter.vectorValue,

color: context.material.color

)))

},

])

static let functions: Symbols = [

// Debug

"print": .command(.list(.any)) { value, context in

context.debugLog(value.tupleValue)

},

"assert": .command(.tuple([.boolean, .optional(.string)])) { value, _ in

let values = value.tupleValue

if values[0] as? Bool == false {

throw RuntimeErrorType.assertionFailure(

values.count == 2 ? values[1] as? String ?? "" : ""

)

}

},

"pause": .function(.optional(.any), .any) { value, context in

try context.hitBreakpoint()

return value

},

// Logic

"true": .constant(.boolean(true)),

"false": .constant(.boolean(false)),

"not": .function(.boolean, .boolean) { value, _ in

.boolean(!value.boolValue)

},

// Unbounded range

"from": .function(.number, .range) { value, _ in

.range(.init(from: value.doubleValue, to: nil))

},

// Randomness

"rnd": .function(.void, .number) { _, context in

.number(context.random.next())

},

"seed": .property(.number, { value, context in

context.random = RandomSequence(seed: value.doubleValue)

}, { context in

.number(Double(context.random.seed))

}),

// Math

"abs": .function(.number, .number) { value, _ in

.number(value.doubleValue.magnitude)

},

"sign": .function(.number, .number) { value, _ in

switch value.doubleValue {

case 0: return .number(0)

case ..<0: return .number(-1)

default: return .number(1)

}

},

"ceil": .function(.number, .number) { value, _ in

.number(value.doubleValue.rounded(.up))

},

"floor": .function(.number, .number) { value, _ in

.number(value.doubleValue.rounded(.down))

},

"round": .function(.number, .number) { value, _ in

.number(value.doubleValue.rounded())

},

"max": .function(.list(.number), .number) { value, _ in

.number(value.doublesValue.max() ?? 0)

},

"min": .function(.list(.number), .number) { value, _ in

.number(value.doublesValue.min() ?? 0)

},

"sum": .function(.list(.list(.number)), .list(.number)) { value, _ in

let values = value.tupleValue as! [[Double]]

if values.count == 1 {

return .number(values[0].reduce(0, +))

}

// Vector sum

var columns = values.reduce(0) { Swift.max($0, $1.count) }

var sums = [Double](repeating: 0, count: columns)

for vector in values {

for i in vector.indices {

sums[i] += vector[i]

}

}

return sums.isEmpty ? 0 : .tuple(sums.map { .number($0) })

},

"sqrt": .function(.number, .number) { value, _ in

.number(sqrt(value.doubleValue))

},

"pow": .function(.numberPair, .number) { value, _ in

let values = value.doublesValue

return .number(pow(values[0], values[1]))

},

// Trigonometry

"cos": .function(.radians, .number) { value, _ in

.number(cos(value.doubleValue))

},

"acos": .function(.number, .radians) { value, _ in

.radians(acos(value.doubleValue))

},

"sin": .function(.radians, .number) { value, _ in

.number(sin(value.doubleValue))

},

"asin": .function(.number, .radians) { value, _ in

.radians(asin(value.doubleValue))

},

"tan": .function(.radians, .number) { value, _ in

.number(tan(value.doubleValue))

},

"atan": .function(.number, .radians) { value, _ in

.radians(atan(value.doubleValue))

},

"atan2": .function(.numberPair, .radians) { value, _ in

let values = value.doublesValue

return .radians(atan2(values[0], values[1]))

},

"pi": .constant(.radians(.pi)),

// Linear algebra

"dot": .function(.tuple([.list(.number), .list(.number)]), .number) { value, _ in

let values = value.tupleValue as! [[Double]]

return .number(zip(values[0], values[1]).map { $0 * $1 }.reduce(0, +))

},

"cross": .function(.tuple([.vector, .vector]), .list(.number)) { value, _ in

let values = value.tupleValue as! [Vector]

return .tuple(values[0].cross(values[1]).components.map { .number($0) })

},

"length": .function(.list(.number), .number) { value, _ in

let values = value.tupleValue as! [Double]

return .number(sqrt(values.map { $0 * $0 }.reduce(0, +)))

},

"normalize": .function(.list(.number), .list(.number)) { value, _ in

let values = value.tupleValue as! [Double]

let length = sqrt(values.map { $0 * $0 }.reduce(0, +))

return .tuple(values.map { .number(length > 0 ? $0 / length : 0) })

},

// Strings

"split": .function(.tuple([.string, .string]), .list(.string)) { value, _ in

let string = value.tupleValue[0] as! String

let separator = value.tupleValue[1] as! String

return .tuple(string

.components(separatedBy: separator)

.map { .string($0) })

},

"join": .function(.tuple([.list(.any), .string]), .string) { value, _ in

guard case let .tuple(args) = value, args.count == 2,

case let .tuple(stringValues) = args[0],

case let .string(separator) = args[1]

else {

throw RuntimeErrorType.assertionFailure(

"Invalid arguments to join function"

)

}

let strings = stringValues.map(\.stringValue)

return .string(strings.joined(separator: separator))

},

"trim": .function(.string, .string) { value, _ in

.string(value.stringValue.trimmingCharacters(

in: .whitespacesAndNewlines

))

},

// Fonts

"fonts": .function(.void, .list(.string)) { _, context in

.tuple(context.fontNames.map { .string($0) })

},

// Object

"object": .block(.init([:], ["*": .any], .void, .any)) { context in

var result = [String: ShapeScript.Value]()

for name in context.options.keys {

result[name] = context.value(for: name)

}

return .object(result)

},

]

static let name: Symbols = [

"name": .property(.string, { parameter, context in

context.name = parameter.stringValue

}, { context in

.string(context.name)

}),

]

static let background: Symbols = [

"background": .getter(.colorOrTexture) { context in

.colorOrTexture(context.background ?? .color(.clear))

},

]

static let font: Symbols = [

"font": .property(.font, { parameter, context in

context.font = parameter.stringValue

}, { context in

.font(context.font)

}),

]

static let detail: Symbols = [

"detail": .property(.number, { parameter, context in

// TODO: throw error if min/max detail level exceeded

context.detail = Swift.max(0, parameter.intValue)

}, { context in

.number(Double(context.detail))

}),

]

static let smoothing: Symbols = [

"smoothing": .property(.halfturns, { parameter, context in

// TODO: find a better way to represent null/auto

let angle = Swift.min(.pi, parameter.angleValue ?? .zero)

context.smoothing = angle < .zero ? nil : angle

}, { context in

.halfturns(context.smoothing.map(\.halfturns) ?? -1)

}),

]

static let root: Symbols = _merge(global, font, detail, smoothing, material, childTransform, [

"camera": .block(.init(.node, [

"position": .vector,

"orientation": .rotation,

"size": .size,

"background": .colorOrTexture,

"antialiased": .boolean,

"fov": .halfturns,

"width": .number,

"height": .number,

], .void, .mesh)) { context in

let position = context.value(for: "position")?.value as? Vector

position.map { context.transform.translation = $0 }

let orientation = context.value(for: "orientation")?.value as? Rotation

orientation.map { context.transform.rotation = $0 }

let scale = context.value(for: "size")?.value as? Vector

scale.map { context.transform.scale = $0 }

return .mesh(Geometry(

type: .camera(Camera(

position: position,

orientation: orientation,

scale: scale,

background: context.value(for: "background")?.colorOrTextureValue,

antialiased: context.value(for: "antialiased")?.boolValue ?? Camera.default.antialiased,

fov: context.value(for: "fov")?.angleValue,

width: context.value(for: "width")?.doubleValue,

height: context.value(for: "height")?.doubleValue

)),

in: context

))

},

"background": .property(.colorOrTexture, { parameter, context in

context.background = MaterialProperty(parameter.value)

}, { context in

.colorOrTexture(context.background ?? .color(.clear))

}),

])

static let global: Symbols = _merge(functions, colors, meshes, paths)

static let node: Symbols = _merge(transform, name, background)

static let shape: Symbols = _merge(node, detail, smoothing, material)

static let group: Symbols = _merge(shape, childTransform, font)

static let user: Symbols = _merge(shape, font)

static let builder: Symbols = group

static let hull: Symbols = _merge(group, points)

static let polygon: Symbols = _merge(transform, childTransform, points, color)

static let mesh: Symbols = _merge(node, smoothing, color, childTransform, polygons)

static let pathShape: Symbols = _merge(transform, detail, color, background)

static let path: Symbols = _merge(pathShape, childTransform, font, pathPoints)

static let definition: Symbols = _merge(root, pathPoints)

static let all: Symbols = _merge(definition, shape, path)

}

extension EvaluationContext {

var paths: [Path] {

children.compactMap { $0.value as? Path }

}

}

extension Geometry {

convenience init(type: GeometryType, in context: EvaluationContext) {

self.init(

type: type,

name: context.name,

transform: context.transform,

material: context.material,

smoothing: context.smoothing,

children: context.children.compactMap { $0.value as? Geometry },

sourceLocation: context.sourceLocation

)

}

}

private func _merge(_ symbols: Symbols...) -> Symbols {

var result = Symbols()

for symbols in symbols {

result.merge(symbols) { $1 }

}

return result

}