325 lines
11 KiB
Swift
325 lines
11 KiB
Swift
#!/usr/bin/env swift
|
||
import Foundation
|
||
import CoreGraphics
|
||
import ImageIO
|
||
|
||
// Programmatic Redline app icon.
|
||
// Draws a 1024×1024 master, writes AppIcon.iconset (16…1024 incl. @2x),
|
||
// and compiles Resources/AppIcon.icns via iconutil.
|
||
//
|
||
// Usage:
|
||
// swift scripts/make-icon.swift
|
||
// swift scripts/make-icon.swift --preview /path/to/icon-512.png
|
||
|
||
private let masterSize = 1024
|
||
|
||
private enum Palette {
|
||
static let charcoalTop = CGColor(srgbRed: 44.0 / 255.0, green: 44.0 / 255.0, blue: 46.0 / 255.0, alpha: 1)
|
||
static let charcoalBottom = CGColor(srgbRed: 28.0 / 255.0, green: 28.0 / 255.0, blue: 30.0 / 255.0, alpha: 1) // #1C1C1E
|
||
static let white = CGColor(srgbRed: 1, green: 1, blue: 1, alpha: 1)
|
||
static let redline = CGColor(srgbRed: 229.0 / 255.0, green: 72.0 / 255.0, blue: 63.0 / 255.0, alpha: 1) // #E5483F
|
||
}
|
||
|
||
private struct IconsetEntry {
|
||
let filename: String
|
||
let pixels: Int
|
||
}
|
||
|
||
private let iconsetEntries: [IconsetEntry] = [
|
||
IconsetEntry(filename: "icon_16x16.png", pixels: 16),
|
||
IconsetEntry(filename: "icon_16x16@2x.png", pixels: 32),
|
||
IconsetEntry(filename: "icon_32x32.png", pixels: 32),
|
||
IconsetEntry(filename: "icon_32x32@2x.png", pixels: 64),
|
||
IconsetEntry(filename: "icon_128x128.png", pixels: 128),
|
||
IconsetEntry(filename: "icon_128x128@2x.png", pixels: 256),
|
||
IconsetEntry(filename: "icon_256x256.png", pixels: 256),
|
||
IconsetEntry(filename: "icon_256x256@2x.png", pixels: 512),
|
||
IconsetEntry(filename: "icon_512x512.png", pixels: 512),
|
||
IconsetEntry(filename: "icon_512x512@2x.png", pixels: 1024),
|
||
]
|
||
|
||
// MARK: - Geometry
|
||
|
||
/// Apple-style continuous-corner rounded square (squircle-like).
|
||
/// Superellipse |x/a|^n + |y/b|^n = 1 with n≈5, inset 1px so antialiased
|
||
/// edge pixels are not clipped by the bitmap.
|
||
private func continuousRoundedSquare(size: CGFloat, exponent n: CGFloat = 5.0, segments: Int = 256) -> CGPath {
|
||
let inset: CGFloat = 1
|
||
let a = (size - inset * 2) / 2
|
||
let cx = size / 2
|
||
let cy = size / 2
|
||
let twoOverN = 2 / n
|
||
let path = CGMutablePath()
|
||
for i in 0...segments {
|
||
let theta = CGFloat(i) / CGFloat(segments) * 2 * .pi
|
||
let ct = cos(theta)
|
||
let st = sin(theta)
|
||
let x = cx + (ct < 0 ? -1 : 1) * pow(abs(ct), twoOverN) * a
|
||
let y = cy + (st < 0 ? -1 : 1) * pow(abs(st), twoOverN) * a
|
||
if i == 0 {
|
||
path.move(to: CGPoint(x: x, y: y))
|
||
} else {
|
||
path.addLine(to: CGPoint(x: x, y: y))
|
||
}
|
||
}
|
||
path.closeSubpath()
|
||
return path
|
||
}
|
||
|
||
// MARK: - Drawing
|
||
|
||
private func drawMasterIcon(size: Int) -> CGImage {
|
||
let s = CGFloat(size)
|
||
let colorSpace = CGColorSpace(name: CGColorSpace.sRGB)!
|
||
let bitmapInfo = CGBitmapInfo.byteOrder32Big.rawValue | CGImageAlphaInfo.premultipliedLast.rawValue
|
||
guard let ctx = CGContext(
|
||
data: nil,
|
||
width: size,
|
||
height: size,
|
||
bitsPerComponent: 8,
|
||
bytesPerRow: 0,
|
||
space: colorSpace,
|
||
bitmapInfo: bitmapInfo
|
||
) else {
|
||
fputs("error: failed to create \(size)×\(size) bitmap context\n", stderr)
|
||
exit(1)
|
||
}
|
||
|
||
ctx.setShouldAntialias(true)
|
||
ctx.setAllowsAntialiasing(true)
|
||
ctx.interpolationQuality = .high
|
||
|
||
// Flip to top-left origin so "top-to-bottom gradient" is literal.
|
||
ctx.translateBy(x: 0, y: s)
|
||
ctx.scaleBy(x: 1, y: -1)
|
||
|
||
ctx.clear(CGRect(x: 0, y: 0, width: s, height: s))
|
||
|
||
let squircle = continuousRoundedSquare(size: s)
|
||
|
||
ctx.saveGState()
|
||
ctx.addPath(squircle)
|
||
ctx.clip()
|
||
|
||
let gradient = CGGradient(
|
||
colorsSpace: colorSpace,
|
||
colors: [Palette.charcoalTop, Palette.charcoalBottom] as CFArray,
|
||
locations: [0, 1]
|
||
)!
|
||
ctx.drawLinearGradient(
|
||
gradient,
|
||
start: CGPoint(x: s / 2, y: 0),
|
||
end: CGPoint(x: s / 2, y: s),
|
||
options: [.drawsBeforeStartLocation, .drawsAfterEndLocation]
|
||
)
|
||
ctx.restoreGState()
|
||
|
||
// Viewfinder corner brackets: thick L-strokes, rounded caps/joins, inset ~18%.
|
||
let inset = s * 0.18
|
||
let bracketWidth = s * 0.095
|
||
let arm = s * 0.155
|
||
let centerline = inset + bracketWidth / 2
|
||
|
||
ctx.saveGState()
|
||
ctx.addPath(squircle)
|
||
ctx.clip()
|
||
ctx.setStrokeColor(Palette.white)
|
||
ctx.setLineWidth(bracketWidth)
|
||
ctx.setLineCap(.round)
|
||
ctx.setLineJoin(.round)
|
||
|
||
func strokeBracket(cornerX: CGFloat, cornerY: CGFloat, dirX: CGFloat, dirY: CGFloat) {
|
||
let path = CGMutablePath()
|
||
path.move(to: CGPoint(x: cornerX + dirX * arm, y: cornerY))
|
||
path.addLine(to: CGPoint(x: cornerX, y: cornerY))
|
||
path.addLine(to: CGPoint(x: cornerX, y: cornerY + dirY * arm))
|
||
ctx.addPath(path)
|
||
ctx.strokePath()
|
||
}
|
||
|
||
// Top-left, top-right, bottom-left, bottom-right.
|
||
strokeBracket(cornerX: centerline, cornerY: centerline, dirX: 1, dirY: 1)
|
||
strokeBracket(cornerX: s - centerline, cornerY: centerline, dirX: -1, dirY: 1)
|
||
strokeBracket(cornerX: centerline, cornerY: s - centerline, dirX: 1, dirY: -1)
|
||
strokeBracket(cornerX: s - centerline, cornerY: s - centerline, dirX: -1, dirY: -1)
|
||
|
||
// Bold redline slash over the frame, lower-left bracket area → upper-right.
|
||
let slashWidth = s * 0.078
|
||
ctx.setStrokeColor(Palette.redline)
|
||
ctx.setLineWidth(slashWidth)
|
||
ctx.setLineCap(.round)
|
||
ctx.setLineJoin(.round)
|
||
let slashInset = centerline + arm * 0.12
|
||
let slash = CGMutablePath()
|
||
slash.move(to: CGPoint(x: slashInset, y: s - slashInset))
|
||
slash.addLine(to: CGPoint(x: s - slashInset, y: slashInset))
|
||
ctx.addPath(slash)
|
||
ctx.strokePath()
|
||
ctx.restoreGState()
|
||
|
||
guard let image = ctx.makeImage() else {
|
||
fputs("error: failed to materialize master CGImage\n", stderr)
|
||
exit(1)
|
||
}
|
||
return image
|
||
}
|
||
|
||
private func scaledImage(_ image: CGImage, pixels: Int) -> CGImage {
|
||
if image.width == pixels && image.height == pixels {
|
||
return image
|
||
}
|
||
let colorSpace = CGColorSpace(name: CGColorSpace.sRGB)!
|
||
let bitmapInfo = CGBitmapInfo.byteOrder32Big.rawValue | CGImageAlphaInfo.premultipliedLast.rawValue
|
||
guard let ctx = CGContext(
|
||
data: nil,
|
||
width: pixels,
|
||
height: pixels,
|
||
bitsPerComponent: 8,
|
||
bytesPerRow: 0,
|
||
space: colorSpace,
|
||
bitmapInfo: bitmapInfo
|
||
) else {
|
||
fputs("error: failed to create \(pixels)×\(pixels) scale context\n", stderr)
|
||
exit(1)
|
||
}
|
||
ctx.interpolationQuality = .high
|
||
ctx.setShouldAntialias(true)
|
||
ctx.draw(image, in: CGRect(x: 0, y: 0, width: pixels, height: pixels))
|
||
guard let out = ctx.makeImage() else {
|
||
fputs("error: failed to scale image to \(pixels)px\n", stderr)
|
||
exit(1)
|
||
}
|
||
return out
|
||
}
|
||
|
||
private func writePNG(_ image: CGImage, to url: URL) {
|
||
let dir = url.deletingLastPathComponent()
|
||
try? FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
|
||
if FileManager.default.fileExists(atPath: url.path) {
|
||
try? FileManager.default.removeItem(at: url)
|
||
}
|
||
guard let dest = CGImageDestinationCreateWithURL(url as CFURL, "public.png" as CFString, 1, nil) else {
|
||
fputs("error: cannot create PNG destination at \(url.path)\n", stderr)
|
||
exit(1)
|
||
}
|
||
CGImageDestinationAddImage(dest, image, nil)
|
||
if !CGImageDestinationFinalize(dest) {
|
||
fputs("error: failed to write PNG \(url.path)\n", stderr)
|
||
exit(1)
|
||
}
|
||
}
|
||
|
||
// MARK: - Paths / CLI
|
||
|
||
private func repoRoot() -> URL {
|
||
let cwd = URL(fileURLWithPath: FileManager.default.currentDirectoryPath, isDirectory: true)
|
||
let arg0 = URL(fileURLWithPath: CommandLine.arguments[0])
|
||
let scriptURL: URL
|
||
if arg0.path.hasPrefix("/") {
|
||
scriptURL = arg0.standardizedFileURL
|
||
} else {
|
||
scriptURL = cwd.appendingPathComponent(arg0.path).standardizedFileURL
|
||
}
|
||
let fromScript = scriptURL.deletingLastPathComponent().deletingLastPathComponent()
|
||
if FileManager.default.fileExists(atPath: fromScript.appendingPathComponent("Package.swift").path) {
|
||
return fromScript
|
||
}
|
||
if FileManager.default.fileExists(atPath: cwd.appendingPathComponent("Package.swift").path) {
|
||
return cwd
|
||
}
|
||
fputs("error: could not find repo root (Package.swift)\n", stderr)
|
||
exit(1)
|
||
}
|
||
|
||
private func parsePreviewPath() -> String? {
|
||
let args = CommandLine.arguments
|
||
var i = 1
|
||
var preview: String?
|
||
while i < args.count {
|
||
let arg = args[i]
|
||
if arg == "--preview" {
|
||
i += 1
|
||
guard i < args.count else {
|
||
fputs("error: --preview requires a path\n", stderr)
|
||
exit(1)
|
||
}
|
||
preview = args[i]
|
||
} else if arg.hasPrefix("--preview=") {
|
||
preview = String(arg.dropFirst("--preview=".count))
|
||
} else if arg == "--help" || arg == "-h" {
|
||
fputs("Usage: swift scripts/make-icon.swift [--preview PATH]\n", stderr)
|
||
exit(0)
|
||
} else {
|
||
fputs("error: unknown argument \(arg)\n", stderr)
|
||
fputs("Usage: swift scripts/make-icon.swift [--preview PATH]\n", stderr)
|
||
exit(1)
|
||
}
|
||
i += 1
|
||
}
|
||
return preview
|
||
}
|
||
|
||
private func runIconutil(iconset: URL, icns: URL) {
|
||
let proc = Process()
|
||
proc.executableURL = URL(fileURLWithPath: "/usr/bin/iconutil")
|
||
proc.arguments = ["-c", "icns", iconset.path, "-o", icns.path]
|
||
proc.standardOutput = FileHandle.standardOutput
|
||
proc.standardError = FileHandle.standardError
|
||
do {
|
||
try proc.run()
|
||
proc.waitUntilExit()
|
||
} catch {
|
||
fputs("error: failed to launch iconutil: \(error)\n", stderr)
|
||
exit(1)
|
||
}
|
||
if proc.terminationStatus != 0 {
|
||
fputs("error: iconutil exited \(proc.terminationStatus)\n", stderr)
|
||
exit(1)
|
||
}
|
||
}
|
||
|
||
// MARK: - Main
|
||
|
||
let root = repoRoot()
|
||
let resources = root.appendingPathComponent("Resources", isDirectory: true)
|
||
let icnsURL = resources.appendingPathComponent("AppIcon.icns")
|
||
let previewPath = parsePreviewPath()
|
||
let fm = FileManager.default
|
||
|
||
print("==> Drawing \(masterSize)×\(masterSize) master")
|
||
let master = drawMasterIcon(size: masterSize)
|
||
|
||
let iconset = fm.temporaryDirectory.appendingPathComponent("Redline-AppIcon-\(UUID().uuidString).iconset", isDirectory: true)
|
||
|
||
do {
|
||
try fm.createDirectory(at: iconset, withIntermediateDirectories: true)
|
||
try fm.createDirectory(at: resources, withIntermediateDirectories: true)
|
||
|
||
print("==> Writing AppIcon.iconset")
|
||
for entry in iconsetEntries {
|
||
let img = scaledImage(master, pixels: entry.pixels)
|
||
writePNG(img, to: iconset.appendingPathComponent(entry.filename))
|
||
}
|
||
|
||
if fm.fileExists(atPath: icnsURL.path) {
|
||
try fm.removeItem(at: icnsURL)
|
||
}
|
||
|
||
print("==> Compiling \(icnsURL.path)")
|
||
runIconutil(iconset: iconset, icns: icnsURL)
|
||
|
||
try? fm.removeItem(at: iconset)
|
||
} catch {
|
||
try? fm.removeItem(at: iconset)
|
||
fputs("error: \(error)\n", stderr)
|
||
exit(1)
|
||
}
|
||
|
||
if let previewPath {
|
||
let previewURL = URL(fileURLWithPath: previewPath)
|
||
print("==> Writing 512px preview \(previewURL.path)")
|
||
writePNG(scaledImage(master, pixels: 512), to: previewURL)
|
||
}
|
||
|
||
print("App icon: \(icnsURL.path)")
|