8B64CB6DA41BD3…987E44D45C37

Arguments · 7

1. #1art3d
2. #2art.gno
3. #3package art3d import ( "crypto/sha256" "math" "strings" "gno.land/p/nt/ufmt/v0" ) const ( canvasW, canvasH = 170.0, 170.0 subjX, subjY = 85.0, 78.0 ) func itoa(v int64) string { if v == 0 { return "0" } neg := v < 0 if neg { v = -v } var b [20]byte i := len(b) for v > 0 { i-- b[i] = byte('0' + v%10) v /= 10 } if neg { i-- b[i] = '-' } return string(b[i:]) } func fnum(v float64) string { return cnum(v) } func fnumPad(v float64) string { neg := v < 0 if neg { v = -v } scaled := int64(v*100 + 0.5) whole := scaled / 100 frac := scaled % 100 fracStr := itoa(frac) if frac < 10 { fracStr = "0" + fracStr } s := itoa(whole) + "." + fracStr if neg { return "-" + s } return s } func cnum(v float64) string { s := fnumPad(v) if strings.Contains(s, ".") { s = strings.TrimRight(strings.TrimRight(s, "0"), ".") } if strings.HasPrefix(s, "0.") { s = s[1:] } else if strings.HasPrefix(s, "-0.") { s = "-" + s[2:] } return s } func fnum1(v float64) string { neg := v < 0 if neg { v = -v } scaled := int64(v*10 + 0.5) s := itoa(scaled/10) + "." + itoa(scaled%10) if neg { return "-" + s } return s } func pctnum(v float64) string { return fnum(v) } func hexToRGB(hex string) (int, int, int) { h := hex if len(h) > 0 && h[0] == '#' { h = h[1:] } r := hexByte(h[0:2]) g := hexByte(h[2:4]) b := hexByte(h[4:6]) return r, g, b } func hexByte(s string) int { v := 0 for i := 0; i < len(s); i++ { c := s[i] var d int switch { case c >= '0' && c <= '9': d = int(c - '0') case c >= 'a' && c <= 'f': d = int(c-'a') + 10 case c >= 'A' && c <= 'F': d = int(c-'A') + 10 } v = v*16 + d } return v } func rgbToHex(r, g, b int) string { return "#" + hexDigit2(r) + hexDigit2(g) + hexDigit2(b) } func hexDigit2(v int) string { if v < 0 { v = 0 } if v > 255 { v = 255 } const digits = "0123456789abcdef" return string(digits[v/16]) + string(digits[v%16]) } func clampByte(v float64) int { iv := int(v) if iv < 0 { return 0 } if iv > 255 { return 255 } return iv } func lighten(hex string, amt float64) string { r, g, b := hexToRGB(hex) nr := clampByte(float64(r) + (255-float64(r))*amt) ng := clampByte(float64(g) + (255-float64(g))*amt) nb := clampByte(float64(b) + (255-float64(b))*amt) return rgbToHex(nr, ng, nb) } func mixHex(hex, target string, amt float64) string { r1, g1, b1 := hexToRGB(hex) r2, g2, b2 := hexToRGB(target) nr := clampByte(float64(r1) + float64(r2-r1)*amt) ng := clampByte(float64(g1) + float64(g2-g1)*amt) nb := clampByte(float64(b1) + float64(b2-b1)*amt) return rgbToHex(nr, ng, nb) } func hueRotate(hex string, deg float64) string { c, sn := math.Cos(deg*math.Pi/180), math.Sin(deg*math.Pi/180) r, g, b := hexToRGB(hex) fr, fg, fb := float64(r), float64(g), float64(b) nr := (0.213+c*0.787-sn*0.213)*fr + (0.715-c*0.715-sn*0.715)*fg + (0.072-c*0.072+sn*0.928)*fb ng := (0.213-c*0.213+sn*0.143)*fr + (0.715+c*0.285+sn*0.140)*fg + (0.072-c*0.072-sn*0.283)*fb nb := (0.213-c*0.213-sn*0.787)*fr + (0.715-c*0.715+sn*0.715)*fg + (0.072+c*0.928+sn*0.072)*fb return rgbToHex(clampByte(nr), clampByte(ng), clampByte(nb)) } func shadeSeries(hex string, n int, lo, hi float64) []string { r, g, b := hexToRGB(hex) out := make([]string, n) for i := 0; i < n; i++ { t := lo if n > 1 { t = lo + (hi-lo)*float64(i)/float64(n-1) } out[i] = rgbToHex(clampByte(float64(r)*t), clampByte(float64(g)*t), clampByte(float64(b)*t)) } return out } type prng struct { seed string n int } func newPRNG(seed string) *prng { return &prng{seed: seed} } func (p *prng) next() uint64 { p.n++ material := p.seed + ":" + itoa(int64(p.n)) // same bytes as "%s:%d" sum := sha256.Sum256([]byte(material)) var v uint64 for i := 0; i < 8; i++ { v = v<<8 | uint64(sum[i]) } return v } func (p *prng) floatIn(lo, hi float64) float64 { frac := float64(p.next()%1000000) / 1000000.0 return lo + frac*(hi-lo) } func (p *prng) intn(n int) int { if n <= 1 { return 0 } return int(p.next() % uint64(n)) } type pt struct{ x, y float64 } func polyPath(pts []pt) string { s := "M" for i, p := range pts { if i > 0 { s += " L" } s += fnum(p.x) + "," + fnum(p.y) } return s + " Z" } func polygonPoints(pts []pt) string { s := "" for i, p := range pts { if i > 0 { s += " " } s += fnum(p.x) + "," + fnum(p.y) } return s } type gstop struct { pct float64 color string op float64 } type gramp struct { x1, y1, x2, y2 float64 stops []gstop } func (g gramp) sample(px, py float64) (string, float64) { dx, dy := g.x2-g.x1, g.y2-g.y1 t := ((px-g.x1)*dx + (py-g.y1)*dy) / (dx*dx + dy*dy) * 100 if t < 0 { t = 0 } if t > 100 { t = 100 } for i := 1; i < len(g.stops); i++ { if t <= g.stops[i].pct { a, b := g.stops[i-1], g.stops[i] f := (t - a.pct) / (b.pct - a.pct) return mixHex(a.color, b.color, f), a.op + (b.op-a.op)*f } } last := g.stops[len(g.stops)-1] return last.color, last.op } func centroid(poly []pt) (float64, float64) { cx, cy := 0.0, 0.0 for _, p := range poly { cx += p.x cy += p.y } return cx / float64(len(poly)), cy / float64(len(poly)) } type facetStyle struct { flash gramp ringCent []pt prof fireProfile zone *prng // per-facet hue drift and shade jitter, seeded per token stone string // which crystal habit a Raw Crystal takes thumb bool } type fireProfile struct { sat, hit float64 pinpoints int shadow string bodyMix float64 neutral string } func fireProfileFor(stone, colorName string) fireProfile { if stone == "Diamond" { switch colorName { case "Colorless": return fireProfile{1.0, 0.85, 5, "#0d1222", 0.12, "#f4f7fc"} case "Black": return fireProfile{0.15, 0.35, 1, "#000000", 0, ""} } return fireProfile{0.95, 0.7, 4, "#0b0d18", 0, ""} } if stone == "Quartz" { if colorName == "Rock Crystal" { return fireProfile{0.4, 0.6, 3, "#141a2c", 0.25, "#e8edf4"} } return fireProfile{0.35, 0.5, 3, "#000000", 0, ""} } if colorName == "Colorless" { return fireProfile{1.0, 0.7, 4, "#141a2c", 0.55, "#dfe4ee"} } if colorName == "White" { return fireProfile{0.85, 0.6, 3, "#7d86a0", 0, ""} } if colorName == "Crystal" { return fireProfile{1.0, 0.78, 4, "#141a2c", 0.3, "#e4e9f2"} } if stone == "Topaz" { return fireProfile{0.5, 0.5, 3, "#000000", 0, ""} } return fireProfile{0.7, 0.5, 3, "#000000", 0, ""} } const fireZoneDeg = 7.0 type rgbI struct{ r, g, b int } func toRGBI(hex string) rgbI { r, g, b := hexToRGB(hex); return rgbI{r, g, b} } func (c rgbI) hex() string { return rgbToHex(c.r, c.g, c.b) } func mixI(a, b rgbI, amt float64) rgbI { return rgbI{ clampByte(float64(a.r) + float64(b.r-a.r)*amt), clampByte(float64(a.g) + float64(b.g-a.g)*amt), clampByte(float64(a.b) + float64(b.b-a.b)*amt), } } func hueRotateI(x rgbI, deg float64) rgbI { c, sn := math.Cos(deg*math.Pi/180), math.Sin(deg*math.Pi/180) fr, fg, fb := float64(x.r), float64(x.g), float64(x.b) nr := (0.213+c*0.787-sn*0.213)*fr + (0.715-c*0.715-sn*0.715)*fg + (0.072-c*0.072+sn*0.928)*fb ng := (0.213-c*0.213+sn*0.143)*fr + (0.715+c*0.285+sn*0.140)*fg + (0.072-c*0.072-sn*0.283)*fb nb := (0.213-c*0.213-sn*0.787)*fr + (0.715-c*0.715+sn*0.715)*fg + (0.072+c*0.928+sn*0.072)*fb return rgbI{clampByte(nr), clampByte(ng), clampByte(nb)} } func hex3I(x rgbI) string { d := "0123456789abcdef" q := func(v int) byte { return d[(v+8)*15/255%16] } return "#" + string([]byte{q(x.r), q(x.g), q(x.b)}) } var whiteI = rgbI{255, 255, 255} func darken(hex, shadow string, amt float64) string { if amt > 0.95 { amt = 0.95 } return mixHex(hex, shadow, amt) } const prismFlash = true func flashRamp(ext, sat float64) gramp { r := gramp{x1: subjX - ext, y1: subjY - ext, x2: subjX + ext, y2: subjY + ext} if !prismFlash { r.stops = []gstop{{0, "#ffffff", 1}, {100, "#ffffff", 0.25}} return r } r.stops = []gstop{ {0, "#ffffff", 1}, {14, "#ff4040", 0.95}, {28, "#ff9a1f", 0.95}, {42, "#ffe81f", 0.9}, {56, "#35ff7a", 0.85}, {70, "#22ccff", 0.8}, {84, "#5566ff", 0.75}, {100, "#c04dff", 0.7}, } for i := range r.stops { r.stops[i].color = mixHex(r.stops[i].color, "#ffffff", 1-sat) } return r } type v3 struct{ x, y, z float64 } func vsub(a, b v3) v3 { return v3{a.x - b.x, a.y - b.y, a.z - b.z} } func vdot(a, b v3) float64 { return a.x*b.x + a.y*b.y + a.z*b.z } func vcross(a, b v3) v3 { return v3{a.y*b.z - a.z*b.y, a.z*b.x - a.x*b.z, a.x*b.y - a.y*b.x} } func vscale(a v3, k float64) v3 { return v3{a.x * k, a.y * k, a.z * k} } func vnorm(a v3) v3 { l := math.Sqrt(vdot(a, a)) if l == 0 { return a } return v3{a.x / l, a.y / l, a.z / l} } func sgnPow(v, e float64) float64 { if v < 0 { return -math.Pow(-v, e) } return math.Pow(v, e) } type outlineFn func(t float64) (float64, float64) func circleOutline(t float64) (float64, float64) { a := 2 * math.Pi * t return math.Cos(a), math.Sin(a) } func superOutline(p float64) outlineFn { return func(t float64) (float64, float64) { a := 2 * math.Pi * t return sgnPow(math.Cos(a), 2/p), sgnPow(math.Sin(a), 2/p) } } func polyOutline(vs []pt) outlineFn { return func(t float64) (float64, float64) { n := len(vs) f := t * float64(n) k := int(math.Floor(f)) fr := f - float64(k) a := vs[((k%n)+n)%n] b := vs[(((k+1)%n)+n)%n] return a.x + (b.x-a.x)*fr, a.y + (b.y-a.y)*fr } } func octagon(hw, hh, c float64) []pt { return []pt{ {hw - c, hh}, {-hw + c, hh}, {-hw, hh - c}, {-hw, -hh + c}, {-hw + c, -hh}, {hw - c, -hh}, {hw, -hh + c}, {hw, hh - c}, } } func pearOutline(t float64) (float64, float64) { a := 2 * math.Pi * t c := math.Cos(a) return c*0.92 + 0.08, 0.7 * math.Sin(a) * (1 - 0.46*c) } func marquiseOutline(t float64) (float64, float64) { a := 2 * math.Pi * t return math.Cos(a), 0.52 * sgnPow(math.Sin(a), 1.35) } func heartOutline(t float64) (float64, float64) { a := 2 * math.Pi * t sn := math.Sin(a) y := (13*math.Cos(a) - 4*math.Cos(2*a) - 1.4*math.Cos(3*a) - 0.5*math.Cos(4*a)) / 17 return 0.88*sn*sn*sn + 0.12*sn, (y + 0.1576) / 0.7894 } func trillionOutline(t float64) (float64, float64) { vs := []pt{{0, 1}, {-0.866, -0.5}, {0.866, -0.5}} f := t * 3 k := int(math.Floor(f)) fr := f - float64(k) a, b := vs[((k%3)+3)%3], vs[(((k+1)%3)+3)%3] bulge := 1 + 0.16*math.Sin(math.Pi*fr) return (a.x + (b.x-a.x)*fr) * bulge, (a.y + (b.y-a.y)*fr) * bulge } type cutSpec struct { n int brilliant bool outline outlineFn rx, ry float64 } var ShapeNames = []string{ "Round Brilliant", "Oval", "Cushion", "Emerald Cut", "Asscher", "Radiant", "Princess Cut", "Pear", "Marquise", "Trillion", "Heart", "Rose Cut", "Raw Crystal", } const ( shapeHeart = 10 shapeRose = 11 shapeRaw = 12 ) const stoneScale = 0.78 func cutFor(shapeIdx int) cutSpec { c := cutForUnscaled(shapeIdx) c.rx, c.ry = c.rx*stoneScale, c.ry*stoneScale return c } func cutForUnscaled(shapeIdx int) cutSpec { switch shapeIdx { case 1: return cutSpec{8, true, circleOutline, 30, 21.5} case 2: return cutSpec{8, true, superOutline(3.4), 27, 24} case 3: return cutSpec{8, false, polyOutline(octagon(1, 1, 0.3)), 30, 21} case 4: return cutSpec{8, false, polyOutline(octagon(1, 1, 0.36)), 25, 25} case 5: return cutSpec{8, true, polyOutline(octagon(1, 1, 0.3)), 29, 22.5} case 6: return cutSpec{8, true, polyOutline([]pt{{1, 1}, {0, 1}, {-1, 1}, {-1, 0}, {-1, -1}, {0, -1}, {1, -1}, {1, 0}}), 23.5, 23.5} case 7: return cutSpec{8, true, pearOutline, 31, 27} case 8: return cutSpec{8, true, marquiseOutline, 33, 30} case 9: return cutSpec{9, true, trillionOutline, 27, 27} case shapeHeart: return cutSpec{10, true, heartOutline, 29, 28} case shapeRose: return cutSpec{6, true, circleOutline, 27, 27} case shapeRaw: return cutSpec{0, false, circleOutline, 27, 27} // sized per stone in buildRaw } return cutSpec{8, true, circleOutline, 27, 27} } func CutsForStone(stone string) []int { switch stone { case "Diamond": return []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, shapeHeart, shapeRose, shapeRaw} case "Sapphire": return []int{1, 2, 0, 3, 7, shapeHeart, 8, 9, 6, shapeRose, shapeRaw} case "Topaz": return []int{3, 1, 7, 2, 8, 0, 9, shapeHeart, 6, shapeRaw} } return []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, shapeHeart, shapeRose, shapeRaw} } const ( kCrown = iota kTable kPav ) type face struct { p []v3 kind int } func ringPts(c cutSpec, n int, scale, z, off float64) []v3 { out := make([]v3, n) for k := 0; k < n; k++ { x, y := c.outline((float64(k) + off) / float64(n)) out[k] = v3{x * c.rx * scale, y * c.ry * scale, z} } return out } func buildCut(c cutSpec) (faces []face, girdle []v3) { base := c.rx if c.ry < base { base = c.ry } hc, hp := 0.34*base, 0.9*base n := c.n if c.brilliant { T := ringPts(c, n, 0.56, hc, 0) B := ringPts(c, n, 0.8, hc*0.46, 0.5) G := ringPts(c, 2*n, 1, 0, 0) culet := v3{0, 0, -hp} faces = append(faces, face{T, kTable}) for k := 0; k < n; k++ { k1 := (k + 1) % n faces = append(faces, face{[]v3{T[k], B[k], T[k1]}, kCrown}) faces = append(faces, face{[]v3{T[k1], B[k], G[(2*k+2)%(2*n)], B[k1]}, kCrown}) faces = append(faces, face{[]v3{B[k], G[2*k], G[2*k+1]}, kCrown}) faces = append(faces, face{[]v3{B[k], G[2*k+1], G[(2*k+2)%(2*n)]}, kCrown}) faces = append(faces, face{[]v3{G[2*k], G[2*k+1], G[(2*k+2)%(2*n)], culet}, kPav}) } return faces, G } T := ringPts(c, n, 0.54, hc, 0) S := ringPts(c, n, 0.78, hc*0.5, 0) G := ringPts(c, n, 1, 0, 0) P1 := ringPts(c, n, 0.7, -hp*0.42, 0) P2 := ringPts(c, n, 0.38, -hp*0.78, 0) K := ringPts(c, n, 0.1, -hp, 0) faces = append(faces, face{T, kTable}) rows := [][2][]v3{{T, S}, {S, G}} for _, r := range rows { for k := 0; k < n; k++ { k1 := (k + 1) % n faces = append(faces, face{[]v3{r[0][k], r[0][k1], r[1][k1], r[1][k]}, kCrown}) } } prow := [][2][]v3{{G, P1}, {P1, P2}, {P2, K}} for _, r := range prow { for k := 0; k < n; k++ { k1 := (k + 1) % n faces = append(faces, face{[]v3{r[0][k], r[0][k1], r[1][k1], r[1][k]}, kPav}) } } return faces, G } func buildRose(c cutSpec) (faces []face, girdle []v3) { n := c.n base := math.Min(c.rx, c.ry) h := 0.62 * base apex := v3{0, 0, h} R := ringPts(c, n, 0.55, h*0.62, 0.5) G := ringPts(c, 2*n, 1, 0, 0) for k := 0; k < n; k++ { k1 := (k + 1) % n faces = append(faces, face{[]v3{apex, R[k], R[k1]}, kCrown}) faces = append(faces, face{[]v3{G[2*k], G[2*k+1], R[k]}, kCrown}) faces = append(faces, face{[]v3{G[2*k+1], G[(2*k+2)%(2*n)], R[k]}, kCrown}) faces = append(faces, face{[]v3{R[k], G[(2*k+2)%(2*n)], R[k1]}, kCrown}) } back := make([]v3, len(G)) for i := range G { back[len(G)-1-i] = G[i] } faces = append(faces, face{back, kPav}) return faces, G } func ringX(n int, x, ry, rz, phase float64) []v3 { out := make([]v3, n) for k := 0; k < n; k++ { a := 2*math.Pi*(float64(k)+phase)/float64(n) + math.Pi/2 out[k] = v3{x, ry * math.Cos(a), rz * math.Sin(a)} } return out } func bandX(a, b []v3) []face { var fs []face for k := range a { k1 := (k + 1) % len(a) fs = append(fs, face{[]v3{a[k], a[k1], b[k1], b[k]}, kCrown}) } return fs } func capX(r []v3) face { return face{r, kCrown} } func turnFaces(fs []face, ax, az float64) []face { cx, sx, cz, sz := math.Cos(ax), math.Sin(ax), math.Cos(az), math.Sin(az) for i := range fs { fs[i].kind = kPav for j, p := range fs[i].p { y, z := p.y*cx-p.z*sx, p.y*sx+p.z*cx fs[i].p[j] = v3{p.x*cz - y*sz, p.x*sz + y*cz, z} } } return fs } func buildRaw(stone string) (faces []face, girdle []v3) { deg := math.Pi / 180 switch stone { case "Diamond": a, b, h := 25.0*stoneScale, 22.0*stoneScale, 23.0*stoneScale v := []v3{{a, 0, 0}, {0, b, 0}, {-a, 0, 0}, {0, -b, 0}} top, bot := v3{0, 0, h}, v3{0, 0, -h} for k := 0; k < 4; k++ { k1 := (k + 1) % 4 faces = append(faces, face{[]v3{top, v[k], v[k1]}, kCrown}) faces = append(faces, face{[]v3{bot, v[k1], v[k]}, kCrown}) } return turnFaces(faces, -38*deg, 28*deg), nil case "Sapphire": L, R := 26.0*stoneScale, 16.0*stoneScale r0 := ringX(6, -L, R*0.42, R*0.42, 0) r1 := ringX(6, -L*0.3, R, R*0.94, 0) r2 := ringX(6, L*0.3, R, R*0.94, 0) r3 := ringX(6, L, R*0.42, R*0.42, 0) faces = append(faces, bandX(r0, r1)...) faces = append(faces, bandX(r1, r2)...) faces = append(faces, bandX(r2, r3)...) faces = append(faces, capX(r3)) rev := make([]v3, 6) for i := range r0 { rev[5-i] = r0[i] } faces = append(faces, capX(rev)) return turnFaces(faces, -30*deg, -14*deg), nil } if stone == "Quartz" { L, R := 27.0*stoneScale, 12.5*stoneScale r0 := ringX(6, -L, R*1.04, R, 0) r1 := ringX(6, L*0.4, R, R*0.96, 0) point := v3{L, 0, 0} faces = append(faces, bandX(r0, r1)...) for k := 0; k < 6; k++ { faces = append(faces, face{[]v3{r1[k], r1[(k+1)%6], point}, kCrown}) } rev := make([]v3, 6) for i := range r0 { rev[5-i] = r0[i] } faces = append(faces, capX(rev)) return turnFaces(faces, -32*deg, 16*deg), nil } L, ry, rz := 26.0*stoneScale, 16.0*stoneScale, 13.0*stoneScale r0 := ringX(8, -L, ry, rz, 0.5) r1 := ringX(8, L*0.5, ry, rz, 0.5) tip := ringX(8, L*0.82, ry*0.45, rz*0.45, 0.5) point := v3{L, 0, 0} faces = append(faces, bandX(r0, r1)...) faces = append(faces, bandX(r1, tip)...) for k := 0; k < 8; k++ { faces = append(faces, face{[]v3{tip[k], tip[(k+1)%8], point}, kCrown}) } rev := make([]v3, 8) for i := range r0 { rev[7-i] = r0[i] } faces = append(faces, capX(rev)) return turnFaces(faces, -30*deg, 12*deg), nil } const viewTilt = 61.0 const ( pieceCY = subjY + 1.5 ) func n1(v float64) string { neg := v < 0 if neg { v = -v } t := int64(v*10 + 0.5) w, f := t/10, t%10 s := "" if f == 0 { s = itoa(w) } else if w == 0 { s = "." + string(byte('0'+f)) } else { s = itoa(w) + "." + string(byte('0'+f)) } if neg && t != 0 { return "-" + s } return s } func relPath(ps []pt) string { s := "M" + n1(ps[0].x) + " " + n1(ps[0].y) + "l" px, py := math.Round(ps[0].x*10)/10, math.Round(ps[0].y*10)/10 for i := 1; i < len(ps); i++ { qx, qy := math.Round(ps[i].x*10)/10, math.Round(ps[i].y*10)/10 dx, dy := n1(qx-px), n1(qy-py) if i > 1 && dx[0] != '-' { s += " " } s += dx if dy[0] != '-' { s += " " } s += dy px, py = qx, qy } return s + "z" } func hex3(h string) string { r, g, b := hexToRGB(h) d := "0123456789abcdef" q := func(v int) byte { return d[(v+8)*15/255%16] } return "#" + string([]byte{q(r), q(g), q(b)}) } func convexHull(ps []pt) []pt { n := len(ps) idx := make([]int, n) for i := range idx { idx[i] = i } less := func(a, b int) bool { return ps[a].x < ps[b].x || (ps[a].x == ps[b].x && ps[a].y < ps[b].y) } tmp := make([]int, n) for w := 1; w < n; w *= 2 { for lo := 0; lo < n; lo += 2 * w { mid, hi := lo+w, lo+2*w if mid > n { mid = n } if hi > n { hi = n } i, j, k := lo, mid, lo for i < mid && j < hi { if less(idx[j], idx[i]) { tmp[k] = idx[j] j++ } else { tmp[k] = idx[i] i++ } k++ } for i < mid { tmp[k] = idx[i] i++ k++ } for j < hi { tmp[k] = idx[j] j++ k++ } } idx, tmp = tmp, idx } cr := func(o, a, b pt) float64 { return (a.x-o.x)*(b.y-o.y) - (a.y-o.y)*(b.x-o.x) } var h []pt for pass := 0; pass < 2; pass++ { start := len(h) for i := 0; i < n; i++ { p := ps[idx[i]] if pass == 1 { p = ps[idx[n-1-i]] } for len(h) >= start+2 && cr(h[len(h)-2], h[len(h)-1], p) <= 0 { h = h[:len(h)-1] } h = append(h, p) } h = h[:len(h)-1] } return h } func polyArea(ps []pt) float64 { a := 0.0 for i := range ps { j := (i + 1) % len(ps) a += ps[i].x*ps[j].y - ps[j].x*ps[i].y } if a < 0 { return -a / 2 } return a / 2 } func clipHalf(ps []pt, ox, oy, nx, ny float64) []pt { if len(ps) == 0 { return ps } d := func(q pt) float64 { return (q.x-ox)*nx + (q.y-oy)*ny } var out []pt for i := range ps { a, b := ps[i], ps[(i+1)%len(ps)] da, db := d(a), d(b) if da <= 0 { out = append(out, a) } if (da < 0 && db > 0) || (da > 0 && db < 0) { t := da / (da - db) out = append(out, pt{a.x + (b.x-a.x)*t, a.y + (b.y-a.y)*t}) } } return out } func clipToConvex(ps, win []pt) []pt { for i := range win { a, b := win[i], win[(i+1)%len(win)] nx, ny := b.y-a.y, a.x-b.x mid := pt{(a.x + b.x) / 2, (a.y + b.y) / 2} cx, cy := centroid(win) if (mid.x-cx)*nx+(mid.y-cy)*ny < 0 { nx, ny = -nx, -ny } ps = clipHalf(ps, a.x, a.y, nx, ny) if len(ps) < 3 { return nil } } return ps } func splitPoly(ps []pt, ang float64) ([]pt, []pt) { cx, cy := centroid(ps) nx, ny := math.Cos(ang), math.Sin(ang) return clipHalf(ps, cx, cy, nx, ny), clipHalf(ps, cx, cy, -nx, -ny) } func renderSolid3D(shapeIdx int, base, salt string, fs *facetStyle) (under, facets, over string) { c := cutFor(shapeIdx) var faces []face var girdle []v3 switch shapeIdx { case shapeRose: faces, girdle = buildRose(c) case shapeRaw: faces, girdle = buildRaw(fs.stone) default: faces, girdle = buildCut(c) } raw := shapeIdx == shapeRaw sh := fs.prof.shadow if fs.prof.neutral != "" { base = fs.prof.neutral } base = mixHex(base, sh, fs.prof.bodyMix) deep := darken(base, sh, 0.9) bright := lighten(base, 0.5) fs.flash = flashRamp(28, fs.prof.sat) deepI, baseI, brightI := toRGBI(deep), toRGBI(base), toRGBI(bright) toneI := func(lum float64) rgbI { if lum < 0 { lum = 0 } if lum > 1 { lum = 1 } if lum < 0.5 { return mixI(deepI, baseI, lum*2) } return mixI(baseI, brightI, (lum-0.5)*2) } tone := func(lum float64) string { return toneI(lum).hex() } yaw := fs.zone.floatIn(-13, 13) * math.Pi / 180 th := viewTilt * math.Pi / 180 cy, sy := math.Cos(yaw), math.Sin(yaw) ct, stt := math.Cos(th), math.Sin(th) view := func(p v3) v3 { x1, y1 := p.x*cy-p.y*sy, p.x*sy+p.y*cy return v3{x1, y1*ct + p.z*stt, p.z*ct - y1*stt} } ex0, ey0, ex1, ey1 := 1e9, 1e9, -1e9, -1e9 for _, f := range faces { for _, p := range f.p { q := view(p) ex0, ey0 = math.Min(ex0, q.x), math.Min(ey0, q.y) ex1, ey1 = math.Max(ex1, q.x), math.Max(ey1, q.y) } } ox, oy := -(ex0+ex1)/2, -(ey0+ey1)/2 scr := func(p v3) pt { return pt{subjX + p.x + ox, pieceCY - (p.y + oy)} } light := vnorm(v3{-0.5, 0.62, 0.6}) inside := v3{0, 0, -0.25 * c.ry} if raw { inside = v3{} } else if shapeIdx == shapeRose { inside = v3{0, 0, 0.15 * c.ry} } type drawn struct { pts []pt depth float64 fill string kind int lum float64 nv v3 jit, drift, thick float64 ext bool } shadeFront := func(kind int, nv, L v3, jit, drift, thick float64, ext bool) (string, float64) { H := vnorm(v3{L.x, L.y, L.z + 1}) lam := math.Max(0, vdot(nv, L)) lum := 0.03 + 0.7*math.Pow(lam, 2.1) + jit if ext { lum *= 0.3 } if kind == kTable { lum = 0.36 + 0.26*lam } if kind == kPav { lum = 0.22 + 0.5*math.Max(0, vdot(vscale(nv, -1), L)) + jit } if raw { lum = 0.3 + 0.42*math.Pow(lam, 1.4) + 0.22*math.Max(0, vdot(vscale(nv, -1), L)) + jit*0.6 } col := mixI(toneI(lum), deepI, 0.34*thick*thick) if sp := math.Pow(math.Max(0, vdot(nv, H)), 28); sp > 0.3 { col = mixI(col, whiteI, sp*0.85) } if lum > 0.5 && kind != kTable { amt := math.Min(1, (lum-0.5)/0.4) * dispersionMix * fs.prof.sat t := math.Atan2(nv.y, nv.x)/math.Pi + drift/40 col = mixI(col, spectrumAtI(t), amt) } return hex3I(hueRotateI(col, drift)), lum } var back, front, pav []drawn var all []pt for _, f := range faces { vp := make([]v3, len(f.p)) ctr := v3{} for i, p := range f.p { vp[i] = view(p) ctr = v3{ctr.x + p.x, ctr.y + p.y, ctr.z + p.z} } ctr = vscale(ctr, 1/float64(len(f.p))) nm := v3{} for i := range f.p { a, b := f.p[i], f.p[(i+1)%len(f.p)] nm = v3{nm.x + (a.y-b.y)*(a.z+b.z), nm.y + (a.z-b.z)*(a.x+b.x), nm.z + (a.x-b.x)*(a.y+b.y)} } nm = vnorm(nm) if vdot(nm, vsub(ctr, inside)) < 0 { nm = vscale(nm, -1) } nv := vnorm(view(nm)) d := drawn{kind: f.kind} for _, p := range vp { d.pts = append(d.pts, scr(p)) d.depth += p.z all = append(all, scr(p)) } d.depth /= float64(len(vp)) rN := math.Sqrt((ctr.x/c.rx)*(ctr.x/c.rx) + (ctr.y/c.ry)*(ctr.y/c.ry)) if rN > 1 { rN = 1 } thick := 1 - rN jit := fs.zone.floatIn(-0.13, 0.13) if nv.z > 0.02 { ext := f.kind == kCrown && fs.zone.floatIn(0, 1) < 0.28 drift := fs.zone.floatIn(-fireZoneDeg, fireZoneDeg) d.nv, d.jit, d.drift, d.thick, d.ext = nv, jit, drift, thick, ext d.fill, d.lum = shadeFront(f.kind, nv, light, jit, drift, thick, ext) front = append(front, d) if f.kind == kPav { pav = append(pav, d) } } else if f.kind == kPav { inner := vscale(nv, -1) lum := 0.2 + 0.6*math.Max(0, vdot(inner, light)) + jit d.fill = hex3(mixHex(tone(lum), deep, 0.34*thick*thick)) d.lum = lum back = append(back, d) pav = append(pav, d) } } sortDrawn := func(ds []drawn) { for i := 1; i < len(ds); i++ { for j := i; j > 0 && ds[j].depth < ds[j-1].depth; j-- { ds[j], ds[j-1] = ds[j-1], ds[j] } } } sortDrawn(back) sortDrawn(front) hull := convexHull(all) if shapeIdx == shapeHeart { hull = nil for _, g := range girdle { hull = append(hull, scr(view(g))) } } var underB, facetsB strings.Builder underB.WriteString(`<defs><radialGradient id="bd` + salt + `" cx=".4" cy=".35" r=".75">` + `<stop offset="0" stop-color="` + hex3(base) + `"/><stop offset=".5" stop-color="` + hex3(darken(base, sh, 0.25)) + `"/><stop offset="1" stop-color="` + hex3(darken(base, sh, 0.85)) + `"/></radialGradient></defs>` + `<path d="` + relPath(hull) + `" fill="url(#bd` + salt + `)" opacity=".7"/><g fill-opacity=".6">`) for _, d := range back { underB.WriteString(`<path d="` + relPath(d.pts) + `" fill="` + d.fill + `"/>`) } underB.WriteString(`</g>`) nCrown := 0 for _, d := range front { if d.kind == kCrown { nCrown++ } } candP := 1.0 if nCrown > fireMaxFacets { candP = float64(fireMaxFacets) / float64(nCrown) * 1.25 } nCand := 0 nSplit := 0 if raw || fs.thumb { candP = 0 } for _, d := range front { if d.kind == kTable && shapeIdx == shapeHeart { facetsB.WriteString(`<path d="` + relPath(d.pts) + `" fill="` + d.fill + `" fill-opacity=".46"/>`) continue } if d.kind == kTable { facetsB.WriteString(`<path d="` + relPath(d.pts) + `" fill="` + d.fill + `" fill-opacity=".46"/>`) win := convexHull(d.pts) tx, ty := centroid(win) if len(pav) > 0 && !fs.thumb { bx0, by0, bx1, by1 := 1e9, 1e9, -1e9, -1e9 for _, b := range pav { for _, q := range b.pts { bx0, by0 = math.Min(bx0, q.x), math.Min(by0, q.y) bx1, by1 = math.Max(bx1, q.x), math.Max(by1, q.y) } } wx0, wy0, wx1, wy1 := 1e9, 1e9, -1e9, -1e9 for _, q := range win { wx0, wy0 = math.Min(wx0, q.x), math.Min(wy0, q.y) wx1, wy1 = math.Max(wx1, q.x), math.Max(wy1, q.y) } k := 0.92 * math.Min((wx1-wx0)/math.Max(1, bx1-bx0), (wy1-wy0)/math.Max(1, by1-by0)) bx, by := (bx0+bx1)/2, (by0+by1)/2 var mosB strings.Builder nRefl := 0 for _, b := range pav { if nRefl >= 8 { break } mp := make([]pt, len(b.pts)) for i, q := range b.pts { mp[i] = pt{tx + (q.x-bx)*k, ty - (q.y-by)*k} } cl := clipToConvex(mp, win) if len(cl) < 3 || polyArea(cl) < 4 { continue } nRefl++ mosB.WriteString(`<path d="` + relPath(cl) + `" fill="` + hex3(tone(b.lum*0.95)) + `"/>`) } if mosB.Len() > 0 { facetsB.WriteString(`<g fill-opacity=".55">` + mosB.String() + `</g>`) } } continue } if d.kind == kCrown && nCand < fireMaxFacets && fs.zone.floatIn(0, 1) < candP { nCand++ cx, cyy := centroid(d.pts) fs.ringCent = append(fs.ringCent, pt{cx, cyy}) facetsB.WriteString(`<path d="` + relPath(d.pts) + `" fill="` + d.fill + `" class="f"/>`) continue } if !raw && nSplit < 6 && polyArea(d.pts) > 26 && fs.zone.floatIn(0, 1) < 0.5 { a, b := splitPoly(d.pts, fs.zone.floatIn(0, math.Pi)) if len(a) >= 3 && len(b) >= 3 { nSplit++ lo := hex3(mixHex(tone(math.Max(0, d.lum*0.6-0.04)), deep, 0.18)) hi := hex3(tone(math.Min(1, d.lum*1.35+0.06))) facetsB.WriteString(`<path d="` + relPath(a) + `" fill="` + hi + `"/><path d="` + relPath(b) + `" fill="` + lo + `"/>`) continue } } facetsB.WriteString(`<path d="` + relPath(d.pts) + `" fill="` + d.fill + `"/>`) } _, _, _, _, rotDeg := motionPhases(salt) type cand struct { i int fill string delta float64 } for si, sgn := range []float64{1, -1} { if fs.thumb { break } a := -sgn * rotDeg * lightSwing * math.Pi / 180 ca, sa := math.Cos(a), math.Sin(a) L := vnorm(v3{light.x*ca - light.y*sa, light.x*sa + light.y*ca, light.z}) var cs []cand for i, d := range front { if d.kind == kTable { continue } f2, _ := shadeFront(d.kind, d.nv, L, d.jit, d.drift, d.thick, d.ext) if dl := lumaDelta(f2, d.fill); dl > 0.06 && polyArea(d.pts) > 3 { cs = append(cs, cand{i, f2, dl}) } } for i := 1; i < len(cs); i++ { for j := i; j > 0 && cs[j].delta > cs[j-1].delta; j-- { cs[j], cs[j-1] = cs[j-1], cs[j] } } if len(cs) > lightMaxFacets { cs = cs[:lightMaxFacets] } if len(cs) == 0 { continue } cls := "gt-la" if si == 1 { cls = "gt-lb" } facetsB.WriteString(`<g class="` + cls + `" opacity="0">`) for _, c := range cs { facetsB.WriteString(`<path d="` + relPath(front[c.i].pts) + `" fill="` + c.fill + `"/>`) } facetsB.WriteString(`</g>`) } gd, lastG := "", "" for i := range girdle { a, b := view(girdle[i]), view(girdle[(i+1)%len(girdle)]) mid := vscale(v3{girdle[i].x + girdle[(i+1)%len(girdle)].x, girdle[i].y + girdle[(i+1)%len(girdle)].y, 0}, 0.5) if view(vnorm(mid)).z-0 > -0.05 && view(mid).z >= view(v3{}).z-0.01 { pa, pb := scr(a), scr(b) sa := n1(pa.x) + " " + n1(pa.y) if sa != lastG { gd += "M" + sa } lastG = n1(pb.x) + " " + n1(pb.y) gd += " " + lastG } } over = `<path d="` + gd + `" fill="none" stroke="` + hex3(lighten(base, 0.18)) + `" stroke-width=".7" stroke-linecap="round" opacity=".4"/>` return underB.String(), facetsB.String(), over } const dispersionMix = 0.32 var spectrum = []string{"#ff4040", "#ff9a1f", "#ffe81f", "#35ff7a", "#22ccff", "#5566ff", "#c04dff"} var spectrumI = func() []rgbI { out := make([]rgbI, len(spectrum)) for i, h := range spectrum { out[i] = toRGBI(h) } return out }() func spectrumAtI(t float64) rgbI { t = t - math.Floor(t) f := t * float64(len(spectrumI)) i := int(f) return mixI(spectrumI[i%len(spectrumI)], spectrumI[(i+1)%len(spectrumI)], f-float64(i)) } func spectrumAt(t float64) string { t = t - math.Floor(t) f := t * float64(len(spectrum)) i := int(f) return mixHex(spectrum[i%len(spectrum)], spectrum[(i+1)%len(spectrum)], f-float64(i)) } const ( lightSwing = 2.2 lightMaxFacets = 12 ) func lumaDelta(a, b string) float64 { wide := func(h string) string { if len(h) == 4 { return "#" + h[1:2] + h[1:2] + h[2:3] + h[2:3] + h[3:4] + h[3:4] } return h } ar, ag, ab := hexToRGB(wide(a)) br, bg, bb := hexToRGB(wide(b)) d := (0.2126*float64(ar-br) + 0.7152*float64(ag-bg) + 0.0722*float64(ab-bb)) / 255 if d < 0 { return -d } return d } const fireMaxFacets = 12 const starfield = true func renderStars(salt string) string { if !starfield { return "" } rnd := newPRNG("stars" + salt) type star struct{ x, y float64 } var byLevel [4][]star for i := 0; i < 36; i++ { x, y := rnd.floatIn(3, canvasW-3), rnd.floatIn(3, 127) k := rnd.intn(20) dx, dy := x-subjX, y-subjY if r := math.Sqrt(dx*dx + dy*dy); r > 43 && r < 58 { continue } lvl := 0 // most stars are faint; a few are bright switch { case k >= 18: lvl = 3 case k >= 14: lvl = 2 case k >= 8: lvl = 1 } byLevel[lvl] = append(byLevel[lvl], star{x, y}) } widths := [4]string{".45", ".6", ".85", "1.15"} ops := [4]string{".22", ".38", ".58", ".85"} var b strings.Builder b.WriteString(`<g stroke="#fff" stroke-linecap="round" fill="none">`) var tw []star for l := 0; l < 4; l++ { if len(byLevel[l]) == 0 { continue } d := "" for i, st := range byLevel[l] { if l >= 1 && l <= 2 && len(tw) < 3 && i%3 == 0 { tw = append(tw, st) continue } d += "M" + n1(st.x) + " " + n1(st.y) + "h.01" } if d != "" { b.WriteString(`<path d="` + d + `" stroke-width="` + widths[l] + `" opacity="` + ops[l] + `"/>`) } } for _, st := range tw { dur := rnd.floatIn(5, 12) b.WriteString(`<path d="M` + n1(st.x) + " " + n1(st.y) + `h.01" stroke-width=".9" opacity=".4" class="gt-tw" style="--d:` + fnum1(dur) + `s;--dl:-` + fnum1(rnd.floatIn(0, dur)) + `s"/>`) } b.WriteString(`</g>`) return b.String() } func pearlLusterGradient(gid, base, metal string) string { r, g, b := hexToRGB(base) lum := (0.2126*float64(r) + 0.7152*float64(g) + 0.0722*float64(b)) / 255 shadow := "#4a4038" if lum < 0.4 { shadow = "#000000" } hi := base sc, ss, sw := ".6", ".32", ".16" mo := ".3" if lum < 0.4 { mo = ".22" hi = mixHex(base, "#c9d2d8", 0.28) sc, ss, sw = ".34", ".16", ".07" } return `<radialGradient id="` + gid + `" cx=".4" cy=".36" r=".7" fx=".34" fy=".28">` + `<stop offset="0" stop-color="` + hi + `"/>` + `<stop offset=".4" stop-color="` + mixHex(base, shadow, 0.13) + `"/>` + `<stop offset=".76" stop-color="` + mixHex(base, shadow, 0.36) + `"/>` + `<stop offset=".93" stop-color="` + mixHex(base, shadow, 0.5) + `"/>` + `<stop offset="1" stop-color="` + mixHex(base, shadow, 0.3) + `"/></radialGradient>` + `<radialGradient id="` + gid + `o" cx=".45" cy=".44" r=".62">` + `<stop offset=".3" stop-color="#fff" stop-opacity="0"/>` + `<stop offset=".62" stop-color="#ffb3cf" stop-opacity=".2"/>` + `<stop offset=".88" stop-color="#b3ffd6" stop-opacity=".2"/>` + `<stop offset="1" stop-color="#c3d3ff" stop-opacity=".12"/></radialGradient>` + `<radialGradient id="` + gid + `s" cx=".36" cy=".3" r=".4">` + `<stop offset="0" stop-color="#fff" stop-opacity="` + sc + `"/>` + `<stop offset=".35" stop-color="#fff" stop-opacity="` + ss + `"/>` + `<stop offset=".7" stop-color="#fff" stop-opacity=".06"/>` + `<stop offset="1" stop-color="#fff" stop-opacity="0"/></radialGradient>` + `<radialGradient id="` + gid + `m" cx=".42" cy=".36" r=".68">` + `<stop offset=".78" stop-color="` + metal + `" stop-opacity="0"/>` + `<stop offset=".93" stop-color="` + metal + `" stop-opacity="` + mo + `"/>` + `<stop offset="1" stop-color="` + metal + `" stop-opacity="0"/></radialGradient>` + `<radialGradient id="` + gid + `w" cx=".66" cy=".73" r=".2">` + `<stop offset="0" stop-color="#fff" stop-opacity="` + sw + `"/>` + `<stop offset="1" stop-color="#fff" stop-opacity="0"/></radialGradient>` } func pearlLayers(shape, gid, between string) string { i := strings.Index(shape, ` fill="`) if i < 0 { return shape } cp := func(suffix string) string { return shape[:i] + ` fill="url(#` + gid + suffix + `)"/>` } return shape + cp("o") + cp("m") + between + cp("w") + cp("s") } func pearlSweepColorIntensity(base string) float64 { r, g, b := hexToRGB(base) lum := 0.2126*float64(r)/255 + 0.7152*float64(g)/255 + 0.0722*float64(b)/255 if lum < 0.4 { return 0.55 } return 2.0 } func pearlSweepGradient(gid, base string) string { mult := pearlSweepColorIntensity(base) o1, o2, o3 := fnum(0.3*mult), fnum(0.35*mult), fnum(0.3*mult) return `<linearGradient id="` + gid + `" x1="0%" y1="0%" x2="100%" y2="0%">` + `<stop offset="0%" stop-color="#ffffff" stop-opacity="0"/>` + `<stop offset="18%" stop-color="#ffd2e6" stop-opacity="` + o1 + `"/>` + `<stop offset="38%" stop-color="#cfe8ff" stop-opacity="` + o2 + `"/>` + `<stop offset="58%" stop-color="#d4ffe4" stop-opacity="` + o3 + `"/>` + `<stop offset="80%" stop-color="#fff0c2" stop-opacity="` + o3 + `"/>` + `<stop offset="100%" stop-color="#ffffff" stop-opacity="0"/>` + `</linearGradient>` } func pearlSweepOverlay(salt, base, shapeGeom string, w, h float64) string { rnd := newPRNG(salt + "-sweep") const passes = 3 total := 15.0 + rnd.floatIn(0, 9) durs := make([]float64, passes) sumDur := 0.0 for i := 0; i < passes; i++ { durs[i] = 2.4 + rnd.floatIn(0, 2.2) sumDur += durs[i] } gapTotal := total - sumDur if gapTotal < float64(passes)*0.5 { gapTotal = float64(passes) * 0.5 } weights := make([]float64, passes) sumW := 0.0 for i := 0; i < passes; i++ { weights[i] = 0.4 + rnd.floatIn(0, 1) sumW += weights[i] } gaps := make([]float64, passes) for i := 0; i < passes; i++ { gaps[i] = weights[i] / sumW * gapTotal } starts := make([]float64, passes) t := gaps[0] for i := 0; i < passes; i++ { starts[i] = t t += durs[i] if i < passes-1 { t += gaps[i+1] } } travel := w * 1.05 clipID := "clp" + salt gradID := "swp" + salt off, on1, on2, out := fnum(-travel), fnum(-travel*0.5), fnum(travel*0.5), fnum(travel) var defs strings.Builder defs.WriteString(`<defs><clipPath id="` + clipID + `">` + shapeGeom + `</clipPath>`) defs.WriteString(pearlSweepGradient(gradID, base)) var marks strings.Builder marks.WriteString(`<g clip-path="url(#` + clipID + `)">`) for i := 0; i < passes; i++ { angle := fnum(rnd.floatIn(0, 360)) startPct := starts[i] / total * 100 durPct := durs[i] / total * 100 rampPct := durPct * 0.32 if rampPct > 6 { rampPct = 6 } p0, p1, p2, p3 := startPct, startPct+rampPct, startPct+durPct-rampPct, startPct+durPct kf := "swp" + salt + "_" + ufmt.Sprintf("%d", i) closing := "" if p3 < 99.999 { closing = `100%{transform:translate(` + off + `px,0);opacity:0}` } defs.WriteString(`<style>@keyframes ` + kf + `{` + `0%{transform:translate(` + off + `px,0);opacity:0}` + fnum(p0) + `%{transform:translate(` + off + `px,0);opacity:0}` + fnum(p1) + `%{transform:translate(` + on1 + `px,0);opacity:1}` + fnum(p2) + `%{transform:translate(` + on2 + `px,0);opacity:1}` + fnum(p3) + `%{transform:translate(` + out + `px,0);opacity:0}` + closing + `}</style>`) marks.WriteString(`<g transform="rotate(` + angle + ` ` + fnum(subjX) + ` ` + fnum(subjY) + `)">` + `<rect x="` + fnum(subjX-w*1.3) + `" y="` + fnum(subjY-h*0.95) + `" width="` + fnum(w*2.6) + `" height="` + fnum(h*1.9) + `" fill="url(#` + gradID + `)" opacity="0" style="mix-blend-mode:screen;animation:` + kf + ` ` + fnum(total) + `s linear infinite"/>` + `</g>`) } marks.WriteString(`</g>`) defs.WriteString(`</defs>`) return defs.String() + marks.String() } func pearlRound(base, metal, salt string) string { gid := "prl" + salt r := 24.0 * stoneScale body := `<circle cx="` + fnum(subjX) + `" cy="` + fnum(subjY) + `" r="` + fnum(r) + `" fill="url(#` + gid + `)"/>` clipGeom := `<circle cx="` + fnum(subjX) + `" cy="` + fnum(subjY) + `" r="` + fnum(r) + `"/>` sweep := pearlSweepOverlay(salt, base, clipGeom, r*2, r*2) return `<defs>` + pearlLusterGradient(gid, base, metal) + `</defs>` + pearlLayers(body, gid, "") + sweep } func pearlOval(base, metal, salt string) string { gid := "prl" + salt rx, ry := 18.0*stoneScale, 25.0*stoneScale body := `<ellipse cx="` + fnum(subjX) + `" cy="` + fnum(subjY) + `" rx="` + fnum(rx) + `" ry="` + fnum(ry) + `" fill="url(#` + gid + `)"/>` clipGeom := `<ellipse cx="` + fnum(subjX) + `" cy="` + fnum(subjY) + `" rx="` + fnum(rx) + `" ry="` + fnum(ry) + `"/>` sweep := pearlSweepOverlay(salt, base, clipGeom, rx*2, ry*2) return `<defs>` + pearlLusterGradient(gid, base, metal) + `</defs>` + pearlLayers(body, gid, "") + sweep } func pearlButton(base, metal, salt string) string { gid := "prl" + salt rx, ry := 25.0*stoneScale, 18.0*stoneScale body := `<ellipse cx="` + fnum(subjX) + `" cy="` + fnum(subjY) + `" rx="` + fnum(rx) + `" ry="` + fnum(ry) + `" fill="url(#` + gid + `)"/>` clipGeom := `<ellipse cx="` + fnum(subjX) + `" cy="` + fnum(subjY) + `" rx="` + fnum(rx) + `" ry="` + fnum(ry) + `"/>` sweep := pearlSweepOverlay(salt, base, clipGeom, rx*2, ry*2) return `<defs>` + pearlLusterGradient(gid, base, metal) + `</defs>` + pearlLayers(body, gid, "") + sweep } func pearlDrop(base, metal, salt string) string { gid := "prl" + salt w, h := 32.0*stoneScale, 42.0*stoneScale path := `M ` + fnum(subjX) + ` ` + fnum(subjY-h*0.55) + ` C ` + fnum(subjX+w*0.55) + ` ` + fnum(subjY-h*0.15) + ` ` + fnum(subjX+w*0.42) + ` ` + fnum(subjY+h*0.42) + ` ` + fnum(subjX) + ` ` + fnum(subjY+h*0.48) + ` C ` + fnum(subjX-w*0.42) + ` ` + fnum(subjY+h*0.42) + ` ` + fnum(subjX-w*0.55) + ` ` + fnum(subjY-h*0.15) + ` ` + fnum(subjX) + ` ` + fnum(subjY-h*0.55) + ` Z` body := `<path d="` + path + `" fill="url(#` + gid + `)"/>` clipGeom := `<path d="` + path + `"/>` sweep := pearlSweepOverlay(salt, base, clipGeom, w*1.6, h*0.9) return `<defs>` + pearlLusterGradient(gid, base, metal) + `</defs>` + pearlLayers(body, gid, "") + sweep } func pearlBaroqueOutline(seed string) []pt { rnd := newPRNG(seed) n := 10 pts := make([]pt, n) for k := 0; k < n; k++ { a := 2 * math.Pi * float64(k) / float64(n) rr := 21.0 * stoneScale * (0.75 + 0.4*rnd.floatIn(0, 1)) pts[k] = pt{subjX + rr*math.Cos(a)*1.1, subjY + rr*math.Sin(a)*0.9} } return pts } func pearlBaroqueSmoothPath(pts []pt) string { n := len(pts) mid := func(a, b pt) pt { return pt{(a.x + b.x) / 2, (a.y + b.y) / 2} } start := mid(pts[n-1], pts[0]) path := "M " + fnum(start.x) + " " + fnum(start.y) for k := 0; k < n; k++ { next := pts[(k+1)%n] m := mid(pts[k], next) path += " Q " + fnum(pts[k].x) + " " + fnum(pts[k].y) + " " + fnum(m.x) + " " + fnum(m.y) } return path + " Z" } func pearlBaroque(base, metal, salt string) string { gid := "prl" + salt pathD := pearlBaroqueSmoothPath(pearlBaroqueOutline("baroque" + salt)) body := `<path d="` + pathD + `" fill="url(#` + gid + `)"/>` clipGeom := `<path d="` + pathD + `"/>` sweep := pearlSweepOverlay(salt, base, clipGeom, 40*stoneScale, 30*stoneScale) return `<defs>` + pearlLusterGradient(gid, base, metal) + `</defs>` + pearlLayers(body, gid, "") + sweep } func pearlCircled(base, metal, salt string) string { gid := "prl" + salt r := 24.0 * stoneScale body := `<circle cx="` + fnum(subjX) + `" cy="` + fnum(subjY) + `" r="` + fnum(r) + `" fill="url(#` + gid + `)"/>` ringTone := mixHex(base, "#000000", 0.12) rings := "" for _, f := range []float64{0.42, 0.58, 0.74, 0.9} { rings += `<circle cx="` + fnum(subjX) + `" cy="` + fnum(subjY) + `" r="` + fnum(r*f) + `" fill="none" stroke="` + ringTone + `" stroke-width="0.9" opacity="0.35"/>` } clipGeom := `<circle cx="` + fnum(subjX) + `" cy="` + fnum(subjY) + `" r="` + fnum(r) + `"/>` sweep := pearlSweepOverlay(salt, base, clipGeom, r*2, r*2) return `<defs>` + pearlLusterGradient(gid, base, metal) + `</defs>` + pearlLayers(body, gid, rings) + sweep } var PearlShapeNames = []string{"Round", "Oval", "Button", "Drop", "Baroque", "Circled"} func renderPearlShape(shapeIdx int, base, metal, salt string) string { switch shapeIdx { case 0: return pearlRound(base, metal, salt) case 1: return pearlOval(base, metal, salt) case 2: return pearlButton(base, metal, salt) case 3: return pearlDrop(base, metal, salt) case 4: return pearlBaroque(base, metal, salt) default: return pearlCircled(base, metal, salt) } } func renderRing(metalHi, metalLo, salt string) string { gid := "ring" + salt bright := lighten(metalHi, 0.45) deep := mixHex(metalLo, "#000000", 0.45) st := func(off, c string) string { return `<stop offset="` + off + `" stop-color="` + c + `"/>` } defs := `<linearGradient id="` + gid + `" x2="1" y2="1">` + st("0", bright) + st(".12", metalHi) + st(".26", deep) + st(".4", metalLo) + st(".52", bright) + st(".64", metalHi) + st(".78", deep) + st(".9", metalLo) + st("1", bright) + `</linearGradient>` outer := `<g fill="none" transform="translate(` + cnum(subjX) + ` ` + cnum(subjY) + `)">` + `<circle r="52.6" stroke="#000" stroke-width="1.6" opacity=".45"/>` + `<circle r="50" stroke="url(#` + gid + `)" stroke-width="4.4"/>` + `<circle r="52.3" stroke="` + deep + `" stroke-width=".7" opacity=".8"/>` + `<circle r="47.7" stroke="` + deep + `" stroke-width=".6" opacity=".7"/>` + `<circle r="48.5" stroke="` + lighten(metalHi, 0.35) + `" stroke-width=".5" opacity=".45"/></g>` const rOut = 46.0 const coreHalf = 0.6 const outwardBloom = 0.9 glowR := rOut + outwardBloom + 3 pct := func(v float64) float64 { p := v / glowR * 100 if p < 0 { p = 0 } if p > 100 { p = 100 } return p } coreColor := lighten(metalHi, 0.25) donutStops := func(inwardBloom, peakOp float64, gid string) string { bloomOp := peakOp * 0.35 midOp := peakOp * 0.7 return `<radialGradient id="` + gid + `" cx="50%" cy="50%" r="50%">` + `<stop offset="0%" stop-color="` + metalHi + `" stop-opacity="0"/>` + `<stop offset="` + pctnum(pct(rOut-inwardBloom-1.5)) + `%" stop-color="` + metalHi + `" stop-opacity="0"/>` + `<stop offset="` + pctnum(pct(rOut-inwardBloom)) + `%" stop-color="` + metalHi + `" stop-opacity="` + fnum(bloomOp) + `"/>` + `<stop offset="` + pctnum(pct(rOut-coreHalf)) + `%" stop-color="` + coreColor + `" stop-opacity="` + fnum(midOp) + `"/>` + `<stop offset="` + pctnum(pct(rOut)) + `%" stop-color="` + coreColor + `" stop-opacity="` + fnum(peakOp) + `"/>` + `<stop offset="` + pctnum(pct(rOut+coreHalf)) + `%" stop-color="` + coreColor + `" stop-opacity="` + fnum(midOp) + `"/>` + `<stop offset="` + pctnum(pct(rOut+outwardBloom)) + `%" stop-color="` + metalHi + `" stop-opacity="` + fnum(bloomOp) + `"/>` + `<stop offset="` + pctnum(pct(rOut+outwardBloom+1)) + `%" stop-color="` + metalHi + `" stop-opacity="0"/>` + `<stop offset="100%" stop-color="` + metalHi + `" stop-opacity="0"/></radialGradient>` } rnd := newPRNG("energy" + salt) gidA, gidB := "glowA"+salt, "glowB"+salt dur := rnd.floatIn(2.13, 3.2) phase := rnd.floatIn(0, dur) stopsA := donutStops(2.5*2.0/3.0*0.5, 0.4, gidA) stopsB := donutStops(8.0*2.0/3.0*0.5, 0.6, gidB) energy := `<defs>` + stopsA + stopsB + `</defs>` + `<g>` + `<circle cx="` + fnum(subjX) + `" cy="` + fnum(subjY) + `" r="` + fnum(glowR) + `" fill="url(#` + gidA + `)"/>` + `<circle cx="` + fnum(subjX) + `" cy="` + fnum(subjY) + `" r="` + fnum(glowR) + `" fill="url(#` + gidB + `)" opacity="0" class="gt-glow" style="--glow-dur:` + fnum(dur) + `s;--glow-delay:-` + fnum(phase) + `s"/>` + `</g>` return `<defs>` + defs + `</defs>` + outer + energy } const ( motionVDur, motionHDur, motionRDur, motionSDur = 3.4, 4.66, 5.81, 6.56 motionRotMin, motionRotMax = 4.0, 8.0 motionScale = 1.09 ) func motionPhases(salt string) (vphase, hphase, rphase, sphase, rotDeg float64) { rnd := newPRNG("motion" + salt) vphase = rnd.floatIn(0, motionVDur) hphase = rnd.floatIn(0, motionHDur) rphase = rnd.floatIn(0, motionRDur) sphase = rnd.floatIn(0, motionSDur) rotDeg = rnd.floatIn(motionRotMin, motionRotMax) return } func applyMotion(content, salt string) string { vphase, hphase, rphase, sphase, rotDeg := motionPhases(salt) return `<g transform="translate(` + fnum(subjX) + ` ` + fnum(subjY) + `)">` + `<g class="gt-v" style="--v-dur:` + fnum(motionVDur) + `s;--v-delay:-` + fnum(vphase) + `s">` + `<g class="gt-h" style="--h-dur:` + fnum(motionHDur) + `s;--h-delay:-` + fnum(hphase) + `s">` + `<g class="gt-r" style="--r-dur:` + fnum(motionRDur) + `s;--r-delay:-` + fnum(rphase) + `s;--rot-deg:` + fnum(rotDeg) + `deg">` + `<g class="gt-s" style="--s-dur:` + fnum(motionSDur) + `s;--s-delay:-` + fnum(sphase) + `s">` + `<g transform="translate(-` + fnum(subjX) + ` -` + fnum(subjY) + `)">` + content + `</g></g></g></g></g></g>` } const dotX, dotY = subjX + 50, subjY + 42 func renderStatusBadge(active bool) string { if active { return `<circle cx="` + fnum(dotX) + `" cy="` + fnum(dotY) + `" r="4" fill="#7fd88f"/>` + `<g transform="translate(` + fnum(dotX) + ` ` + fnum(dotY) + `)"><circle r="4" fill="none" stroke="#7fd88f" stroke-width="1.2" class="gt-badge-pulse" opacity="0.8"/></g>` } return `<circle cx="` + fnum(dotX) + `" cy="` + fnum(dotY) + `" r="4" fill="#5a5f6b"/>` } type facetSpan struct { start, end int ringMember bool } func scanFacetSpans(markup string) []facetSpan { var spans []facetSpan i := 0 for { rel := strings.Index(markup[i:], "<") if rel < 0 { break } start := i + rel relEnd := strings.Index(markup[start:], "/>") if relEnd < 0 { break } end := start + relEnd + 2 tag := markup[start:end] i = end isFacetTag := strings.HasPrefix(tag, "<path") || strings.HasPrefix(tag, "<circle") || strings.HasPrefix(tag, "<polygon") if !isFacetTag { continue } spans = append(spans, facetSpan{start: start, end: end, ringMember: strings.Contains(tag, `class="f"`)}) } return spans } const ( fireSweepAxis = -35.0 * math.Pi / 180 fireSweepSpan = 1.6 // seconds a sweep takes to cross the stone ) func applyCascade(markup, tidStr string, fs *facetStyle) (overlay string, css string) { if fs == nil || len(fs.ringCent) == 0 { return "", "" } spans := scanFacetSpans(markup) rnd := newPRNG("fire" + tidStr) _, _, rphase, _, _ := motionPhases(tidStr) period := 2 * motionRDur axis := fireSweepAxis + rnd.floatIn(-0.3, 0.3) dx, dy := math.Cos(axis), math.Sin(axis) ka, kb := "fa"+tidStr, "fb"+tidStr shape := func(at float64) string { return fnum1(at) + `%{opacity:0}` + fnum1(at+2) + `%{opacity:var(--o);fill:#fff}` + fnum1(at+4.5) + `%{opacity:.4;fill:var(--c)}` + fnum1(at+8) + `%{opacity:0}` } per := fnum(period) css = `.` + ka + `{animation:` + ka + ` ` + per + `s linear infinite}.` + kb + `{animation:` + kb + ` ` + per + `s linear infinite}` + `@keyframes ` + ka + `{` + shape(12.5) + `100%{opacity:0}}` + `@keyframes ` + kb + `{` + shape(62.5) + `100%{opacity:0}}` var out strings.Builder ringIdx := -1 for _, span := range spans { if !span.ringMember { continue } ringIdx++ if ringIdx >= len(fs.ringCent) { break } c := fs.ringCent[ringIdx] color, colorOp := fs.flash.sample(c.x, c.y) pos := ((c.x-subjX)*dx + (c.y-pieceCY)*dy) / (30 * stoneScale) name := ka if rnd.floatIn(0, 1) < 0.5 { name, pos = kb, -pos } delay := rphase - 0.25*motionRDur + period - pos*fireSweepSpan/2 tag := markup[span.start:span.end] geomEnd := strings.Index(tag, `" fill=`) if geomEnd < 0 { continue } out.WriteString(tag[:geomEnd] + `" opacity="0" class="` + name + `" style="--o:` + fnum(math.Round(rnd.floatIn(0.55, 0.9)*colorOp*10)/10) + `;--c:` + hex3(color) + `;animation-delay:-` + fnum1(delay) + `s"/>`) } return out.String(), css } func renderMetalLabelRect(metalHi, metalLo string, x, y, w, h, rx float64, salt string) string { gid := "lg" + salt bright := lighten(metalHi, 0.4) deep := mixHex(metalLo, "#000000", 0.5) st := func(off, c string) string { return `<stop offset="` + off + `" stop-color="` + c + `"/>` } defs := `<linearGradient id="` + gid + `">` + st("0", metalLo) + st(".22", metalHi) + st(".42", bright) + st(".62", metalHi) + st("1", metalLo) + `</linearGradient>` rect := `<rect x="` + cnum(x) + `" y="` + cnum(y) + `" width="` + cnum(w) + `" height="` + cnum(h) + `" rx="` + cnum(rx) + `" fill="url(#` + gid + `)" stroke="` + deep + `" stroke-width=".8"/>` const in_ = 0.9 arc := ` a` + cnum(rx-in_) + ` ` + cnum(rx-in_) + ` 0 0 ` d := cnum(rx - in_) edges := `<g fill="none" stroke-linecap="round">` + `<path d="M` + cnum(x+in_) + ` ` + cnum(y+rx) + arc + `1 ` + d + ` -` + d + `H` + cnum(x+w-rx) + arc + `1 ` + d + ` ` + d + `" stroke="` + lighten(metalHi, 0.45) + `" stroke-width=".45" opacity=".4"/>` + `<path d="M` + cnum(x+in_) + ` ` + cnum(y+h-rx) + arc + `0 ` + d + ` ` + d + `H` + cnum(x+w-rx) + arc + `0 ` + d + ` -` + d + `" stroke="` + deep + `" stroke-width=".5" opacity=".5"/></g>` sid := "sh" + salt defs += `<g id="` + sid + `"><circle cx=".15" cy=".2" r="1.6" fill="` + deep + `" opacity=".55"/>` + `<circle r="1.3" fill="` + mixHex(metalLo, metalHi, 0.4) + `" stroke="` + deep + `" stroke-width=".25"/>` + `<circle cx="-.4" cy="-.4" r=".75" fill="` + lighten(metalHi, 0.3) + `" opacity=".35"/></g>` seed := 0 for k := 0; k < len(salt); k++ { seed += int(salt[k]) } heads, slots := "", "" n := 0 for _, px := range []float64{x + 4.2, x + w - 4.2} { for _, py := range []float64{y + 3.7, y + h - 3.7} { heads += `<use href="#` + sid + `" x="` + cnum(px) + `" y="` + cnum(py) + `"/>` ang := float64((seed*37+n*71)%180) * math.Pi / 180 dx, dy := 0.9*math.Cos(ang), 0.9*math.Sin(ang) slots += `M` + cnum(px-dx) + ` ` + cnum(py-dy) + `l` + cnum(2*dx) + ` ` + cnum(2*dy) n++ } } rivets := heads + `<path d="` + slots + `" stroke="` + deep + `" stroke-width=".45" stroke-linecap="round"/>` return `<defs>` + defs + `</defs>` + rect + edges + rivets } const ( plateFont = `'DIN Alternate',Bahnschrift,'Roboto Condensed',sans-serif` plateSize = 8.6 plateSpacing = 1.1 plateMaxW = 100.0 ) func renderPlateText(label, fill, metalHi string) string { g := `<g font-size="` + cnum(plateSize) + `" letter-spacing="` + cnum(plateSpacing) + `" text-anchor="middle" font-family="` + plateFont + `" font-weight="700"` if est := float64(len(label))*(plateSize*0.52+plateSpacing); est > plateMaxW { g += ` textLength="` + cnum(plateMaxW) + `" lengthAdjust="spacingAndGlyphs"` } x := cnum(subjX) return g + `><text x="` + x + `" y="144.9" fill="` + lighten(metalHi, 0.5) + `" opacity=".45">` + label + `</text>` + `<text x="` + x + `" y="144.4" fill="` + fill + `">` + label + `</text></g>` } func renderSerialText(tidStr, color string) string { return `<text x="` + fnum(subjX) + `" y="159.5" font-size="6.5" text-anchor="middle" fill="` + color + `" font-family="ui-monospace,monospace" opacity="0.85">#` + tidStr + `</text>` } type namedColor struct{ hex, name string } var stoneByChain = map[string]string{ "TOPAZ-1": "Topaz", "SAPPHIRE-1": "Sapphire", "PEARL-1": "Pearl", "GNOLAND-1": "Diamond", } var stonePalettes = map[string][]namedColor{ "Sapphire": { {"#2a5fe0", "Blue"}, {"#ff6ea4", "Pink"}, {"#ff8501", "Orange"}, {"#ffd500", "Yellow"}, {"#1aa88a", "Green"}, {"#a658ff", "Violet"}, {"#e6e9f8", "White"}, {"#ff8f72", "Padparadscha"}, }, "Topaz": { {"#f5edd1", "Colorless"}, {"#ffa300", "Imperial"}, {"#ffd100", "Golden"}, {"#c96a28", "Sherry Brown"}, {"#86cdf2", "Sky Blue"}, {"#ff96ba", "Pink"}, }, "Quartz": { {"#eef2f7", "Rock Crystal"}, {"#9b59d6", "Amethyst"}, {"#f2b01e", "Citrine"}, {"#f5b9ca", "Rose Quartz"}, {"#7d6250", "Smoky Quartz"}, {"#a9d9a2", "Prasiolite"}, }, "Diamond": { {"#f3f6fc", "Colorless"}, {"#ffc400", "Fancy Yellow"}, {"#ff4f9a", "Fancy Pink"}, {"#1f8fff", "Fancy Blue"}, {"#14c46e", "Fancy Green"}, {"#d9a560", "Champagne"}, {"#b4561a", "Cognac"}, {"#2b2d34", "Black"}, {"#e0243a", "Red"}, {"#ff7a1a", "Orange"}, {"#9b4fd6", "Purple"}, }, "Pearl": { {"#f8f6f0", "White"}, {"#f0e4c8", "Cream"}, {"#3a3a3c", "Black"}, {"#c8cdd4", "Silver"}, {"#d4af6a", "Gold"}, {"#f0d4dc", "Pink"}, {"#f2c9a8", "Peach"}, {"#d8cbe0", "Lavender"}, }, } var colorWeights = map[string][]int{ "Diamond": {30, 18, 5, 4, 3, 14, 12, 8, 1, 3, 2}, "Quartz": {25, 25, 18, 9, 18, 5}, } const defaultColorWeight = 5 func colorWeight(stone string, idx int) int { w, ok := colorWeights[stone] if !ok { return 1 } if idx < len(w) { return w[idx] } return defaultColorWeight } func PickColorIndex(stone string, roll uint64) int { n := ColorPaletteSize(stone) total := 0 for i := 0; i < n; i++ { total += colorWeight(stone, i) } r := int(roll % uint64(total)) for i := 0; i < n; i++ { r -= colorWeight(stone, i) if r < 0 { return i } } return n - 1 } func ColorProbability(stone string, idx int) float64 { n := ColorPaletteSize(stone) total := 0 for i := 0; i < n; i++ { total += colorWeight(stone, i) } return float64(colorWeight(stone, idx)) / float64(total) } func ColorRarityCSV(stone string) string { n := ColorPaletteSize(stone) total := 0 for i := 0; i < n; i++ { total += colorWeight(stone, i) } out := make([]string, n) for i := 0; i < n; i++ { pm := colorWeight(stone, i) * 1000 / total out[i] = colorForStone(stone, i).name + ":" + ufmt.Sprintf("%d.%d", pm/10, pm%10) } return strings.Join(out, ";") } func ChainAlwaysActive(chain string) bool { return chain == "GNOLAND-1" } var stoneNames = []string{"Sapphire", "Topaz", "Pearl", "Diamond", "Quartz"} func registerStoneName(stone string) { for _, s := range stoneNames { if s == stone { return } } stoneNames = append(stoneNames, stone) } func SetStoneForChain(chainName, stone string) { stoneByChain[chainName] = stone registerStoneName(stone) } func AddStoneColor(stone, hex, name string) { stonePalettes[stone] = append(stonePalettes[stone], namedColor{hex: hex, name: name}) registerStoneName(stone) } func StoneNamesCSV() string { return strings.Join(stoneNames, ";") } func ColorPaletteCSV(stone string) string { palette := stonePalettes[stone] pairs := make([]string, len(palette)) for i, c := range palette { pairs[i] = c.hex + ":" + c.name } return strings.Join(pairs, ";") } func MetalToneHex(metalName string) string { t, ok := metals[metalName] if !ok { return "" } return t.hi + ";" + t.lo } func StoneForChain(chain string) string { if s, ok := stoneByChain[chain]; ok { return s } return "Quartz" } func colorForStone(stone string, colorIdx int) namedColor { palette := stonePalettes[stone] if len(palette) == 0 { palette = stonePalettes["Quartz"] } if colorIdx < 0 { colorIdx = 0 } if colorIdx >= len(palette) { colorIdx = len(palette) - 1 } return palette[colorIdx] } func ColorPaletteSize(stone string) int { if n := len(stonePalettes[stone]); n > 0 { return n } return len(stonePalettes["Quartz"]) } func FindShapeIndex(stone, name string) (idx int, ok bool) { names := ShapeNames if stone == "Pearl" { names = PearlShapeNames } for i, s := range names { if s == name { return i, true } } return -1, false } func FindColorIndex(chain, colorName string) (idx int, ok bool) { stone := StoneForChain(chain) palette := stonePalettes[stone] if len(palette) == 0 { palette = stonePalettes["Quartz"] } for i, c := range palette { if c.name == colorName { return i, true } } return -1, false } type metalTone struct{ hi, lo string } var metals = map[string]metalTone{ "Gold": {"#a48b3f", "#6a5117"}, "Silver": {"#95989c", "#5e646c"}, "Bronze": {"#865b34", "#52391d"}, "Platinum": {"#c3c6c8", "#87909a"}, "Obsidian": {"#3a3d47", "#0d0e12"}, } var MetalNames = []string{"Gold", "Silver", "Bronze", "Platinum", "Obsidian"} type metalLabelTone struct{ bg, text string } var metalLabel = map[string]metalLabelTone{ "Gold": {"#f4d060", "#04121a"}, "Silver": {"#dfe4ea", "#04121a"}, "Bronze": {"#c9884f", "#04121a"}, "Platinum": {"#eef2f5", "#04121a"}, "Obsidian": {"#5a5f6b", "#e8e9f0"}, } func RenderTokenThumbSVG(chain, metal string, shapeIdx, colorIdx int, active bool, tidStr string) string { svg, _, _, _ := renderToken(chain, metal, shapeIdx, colorIdx, active, tidStr, true) return svg } func RenderTokenSVG(chain, metal string, shapeIdx, colorIdx int, active bool, tidStr string) (svg string, stone string, colorHex string, colorName string) { return renderToken(chain, metal, shapeIdx, colorIdx, active, tidStr, false) } func renderToken(chain, metal string, shapeIdx, colorIdx int, active bool, tidStr string, thumb bool) (svg string, stone string, colorHex string, colorName string) { var cascadeCSS string stone = StoneForChain(chain) if ChainAlwaysActive(chain) { active = true } nc := colorForStone(stone, colorIdx) colorHex, colorName = nc.hex, nc.name mt := metals[metal] ringEls := renderRing(mt.hi, mt.lo, tidStr) var pieceMarkup string if stone == "Pearl" { pearl := renderPearlShape(shapeIdx, colorHex, mt.hi, tidStr) overlay, css := applyCascade(pearl, tidStr, nil) pieceMarkup, cascadeCSS = pearl+overlay, css } else { fs := &facetStyle{prof: fireProfileFor(stone, colorName), zone: newPRNG("zone" + tidStr), stone: stone, thumb: thumb} under, facets, over := renderSolid3D(shapeIdx, colorHex, tidStr, fs) overlay, css := applyCascade(facets, tidStr, fs) cascadeCSS = css pieceMarkup = under + `<g fill-opacity=".9">` + facets + `</g>` + overlay + over } floatingPiece := applyMotion(pieceMarkup, tidStr) status := renderStatusBadge(active) serial := renderSerialText(tidStr, mt.hi) labelText := metalLabel[metal].text labelRect := renderMetalLabelRect(mt.hi, mt.lo, 24, 134, 122, 15, 3, tidStr) inner := `<rect width="` + fnum(canvasW) + `" height="` + fnum(canvasH) + `" fill="#0a0b10"/>` + renderStars(tidStr) + ringEls + floatingPiece + status + serial + labelRect + renderPlateText(chain+" CHAIN", labelText, mt.hi) svg = `<svg xmlns="http://www.w3.org/2000/svg" width="` + fnum(canvasW) + `" height="` + fnum(canvasH) + `" viewBox="0 0 ` + fnum(canvasW) + ` ` + fnum(canvasH) + `">` + styleBlock() + `<style>` + cascadeCSS + `</style>` + inner + `</svg>` return svg, stone, colorHex, colorName } func styleBlock() string { const easeOut = "cubic-bezier(0,0,.3,1)" return `<style>.gt-v,.gt-h,.gt-r,.gt-s{will-change:transform}` + `.gt-v{animation:gt-v var(--v-dur) ease-in-out var(--v-delay) infinite}` + `.gt-h{animation:gt-h var(--h-dur) ease-in-out var(--h-delay) infinite}` + `.gt-r{animation:gt-r var(--r-dur) ease-in-out var(--r-delay) infinite}` + `.gt-s{animation:gt-s var(--s-dur) ease-in-out var(--s-delay) infinite}` + `.gt-glow{animation:gt-glow var(--glow-dur) ease-in-out var(--glow-delay) infinite}` + `.gt-la{animation:gt-la var(--r-dur) ease-in-out var(--r-delay) infinite}` + `.gt-lb{animation:gt-lb var(--r-dur) ease-in-out var(--r-delay) infinite}` + `@keyframes gt-la{0%,50%,100%{opacity:0}25%{opacity:1}}` + `@keyframes gt-lb{0%,50%,100%{opacity:0}75%{opacity:1}}` + `.gt-badge-pulse{animation:gt-bp 1.8s ` + easeOut + ` infinite}` + `@keyframes gt-v{0%,100%{transform:translateY(2.5px)}50%{transform:translateY(-2.5px)}}` + `@keyframes gt-h{50%{transform:translateX(1.8px)}}` + `@keyframes gt-r{25%{transform:rotate(calc(-1*var(--rot-deg)))}75%{transform:rotate(var(--rot-deg))}}` + `@keyframes gt-s{50%{transform:scale(` + fnum(motionScale) + `)}}` + `.gt-tw{animation:gt-tw var(--d) ease-in-out var(--dl) infinite}@keyframes gt-tw{0%,84%,100%{opacity:.4}90%{opacity:1}94%{opacity:.2}}` + `@keyframes gt-glow{50%{opacity:1}}` + `@keyframes gt-bp{from{transform:scale(1);opacity:.8}to{transform:scale(2.25);opacity:0}}` + `</style>` }
4. #4gnomod.toml
5. #5module = "gno.land/p/g1wx60nkcp5lfsxmedeg7sfs47tzxkath05u63t4/art3d" gno = "0.9"
6. #6/gno.MemPackageType
7. #7 MPUserAll