Texturing Overhaul (#115)

* Start of texturing nodes

* Scale along normal now can sample texture for values

* New noise functions, serializing and rendering textures in graph view

* output images now update

* color test fixes

* fix: better sri CI handling (#117)

- Renames "update-sris" -> "sri-check-up"
- Refactors this script so that it both handles updating the SRIs when
  run locally, but also prints the SRI difference to the log when in CI.
- Uses this script in workflows to check the SRIs before continuing with
  expensive build and release steps.
- Refactors the 'apps' section into main let expression for use in build
  phases if needed.

example output seen in CI:
```bash
$: nix run .#sri-check-up
package-lock.json.sri mismatch
specified: sha256-uea6z39yYjpLTjq+ne3NJdabTQ/N91tLtBqfQMSYcAI=
got: sha256-gF8IDK1WKmNwXcIfm62kkDSzSxIceKgpSxuwzQDlmcQ=
If this difference is expected, please replace the SRI hash in this file with the one we got

```

* hash update

* fix: oopsie (#118)

* node outputs are now threadsafe

* WebColor => Color, fix torus UVs

* noise node

* Radial Gradient, ApplyGradient, add and scale color, new terrain example

* fixing examples

---------

Co-authored-by: Kaleb Pace <[email protected]>

Author: EliCDavis

.github/workflows/build.yml

@@ -27,8 +27,10 @@ jobs:
       - uses: DeterminateSystems/nix-installer-action@main
       - uses: DeterminateSystems/flakehub-cache-action@main
 
-      - name: Restore Nix-cached Release Artifacts
-        run: nix build .#release -Lo ./artifacts
+      - name: Build Nix-cached Release Artifacts
+        run: |
+          nix run .#sri-check-up --print-build-logs
+          nix build .#release --print-build-logs --out-link ./artifacts
 
   pages:
     runs-on: ubuntu-latest
@@ -37,5 +39,7 @@ jobs:
       - uses: DeterminateSystems/nix-installer-action@main
       - uses: DeterminateSystems/flakehub-cache-action@main
 
-      - name: Restore Nix-cached Pages Artifacts
-        run: nix build .#pages -Lo ./dist
+      - name: Build Nix-cached Pages Artifacts
+        run: |
+          nix run .#sri-check-up --print-build-logs
+          nix build .#pages --print-build-logs --out-link ./dist

.github/workflows/release.yml

@@ -27,12 +27,10 @@ jobs:
       - uses: DeterminateSystems/nix-installer-action@main
       - uses: DeterminateSystems/flakehub-cache-action@main
 
-      - name: Restore Nix-cached Release Artifacts
-        run: nix build .#release -Lo ./artifacts
-
-      - name: Publish GitHub Release
+      - name: Push Nix-cached Release Artifacts
         run: |
-          gh release upload $GITHUB_REF_NAME ./artifacts/* --clobber
+          nix run .#sri-check-up --print-build-logs
+          nix run .#release --print-build-logs
 
   deploy:
     runs-on: ubuntu-latest
@@ -45,7 +43,9 @@ jobs:
       - uses: DeterminateSystems/flakehub-cache-action@main
 
       - name: Restore Nix-cached Pages Artifacts
-        run: nix build .#pages -Lo ./dist
+        run: |
+          nix run .#sri-check-up --print-build-logs
+          nix build .#pages --print-build-logs --out-link ./dist
 
       - name: Setup Pages
         uses: actions/configure-pages@v4

cmd/polyform/main.go

@@ -2,6 +2,9 @@ package main
 
 import (
 	"fmt"
+	"image"
+	"image/color"
+	"math"
 	"os"
 	"strings"
 
@@ -12,6 +15,8 @@ import (
 	// Import these so they register their nodes with the generator
 	"github.com/EliCDavis/polyform/drawing/coloring"
 	_ "github.com/EliCDavis/polyform/drawing/coloring"
+	"github.com/EliCDavis/polyform/drawing/texturing"
+	_ "github.com/EliCDavis/polyform/drawing/texturing"
 	_ "github.com/EliCDavis/polyform/drawing/texturing/normals"
 
 	_ "github.com/EliCDavis/polyform/formats/colmap"
@@ -23,9 +28,12 @@ import (
 	_ "github.com/EliCDavis/polyform/formats/spz"
 	_ "github.com/EliCDavis/polyform/formats/stl"
 
+	"github.com/EliCDavis/polyform/generator/manifest"
+	"github.com/EliCDavis/polyform/generator/manifest/basics"
 	_ "github.com/EliCDavis/polyform/generator/manifest/basics"
 	_ "github.com/EliCDavis/polyform/generator/parameter"
 	"github.com/EliCDavis/polyform/generator/schema"
+	"github.com/EliCDavis/polyform/generator/serialize"
 	"github.com/EliCDavis/polyform/generator/variable"
 
 	_ "github.com/EliCDavis/polyform/math"
@@ -53,6 +61,47 @@ import (
 )
 
 func main() {
+	nodeSerializer := &serialize.TypeSwitch[manifest.Entry]{}
+
+	serialize.Register(nodeSerializer, func(i image.Image) manifest.Entry {
+		return manifest.Entry{Artifact: basics.Image{Image: i}}
+	})
+
+	serialize.Register(nodeSerializer, func(tex texturing.Texture[float64]) manifest.Entry {
+		return manifest.Entry{Artifact: texturing.Artifact[float64]{
+			Texture: tex,
+			Conversion: func(v float64) color.Color {
+				b := byte(math.Min(math.Max(v, 0), 1) * 255)
+				return color.RGBA{R: b, G: b, B: b, A: 255}
+			},
+		}}
+	})
+
+	serialize.Register(nodeSerializer, func(tex texturing.Texture[bool]) manifest.Entry {
+		return manifest.Entry{Artifact: texturing.Artifact[bool]{
+			Texture: tex,
+			Conversion: func(b bool) color.Color {
+				var v byte = 0
+				if b {
+					v = 255
+				}
+				return color.RGBA{R: v, G: v, B: v, A: 255}
+			},
+		}}
+	})
+
+	serialize.Register(nodeSerializer, func(i texturing.Texture[color.Color]) manifest.Entry {
+		return manifest.Entry{Artifact: texturing.Artifact[color.Color]{
+			Texture: i,
+			Conversion: func(b color.Color) color.Color {
+				if b == nil {
+					return color.RGBA{R: 0, G: 0, B: 0, A: 255}
+				}
+				return b
+			},
+		}}
+	})
+
 	app := generator.App{
 		Name:        "Polyform",
 		Description: "Immutable mesh processing pipelines",
@@ -65,7 +114,7 @@ func main() {
 				},
 			},
 		},
-
+		NodeOutputSerialization: nodeSerializer,
 		VariableFactory: func(variableType string) (variable.Variable, error) {
 			switch strings.ToLower(variableType) {
 			case "float64":
@@ -98,8 +147,8 @@ func main() {
 			case "geometry.aabb":
 				return &variable.TypeVariable[geometry.AABB]{}, nil
 
-			case "coloring.webcolor":
-				return &variable.TypeVariable[coloring.WebColor]{}, nil
+			case "coloring.color":
+				return &variable.TypeVariable[coloring.Color]{}, nil
 
 			case "image.image":
 				return &variable.ImageVariable{}, nil

cmd/polywasm/server.go

@@ -36,7 +36,7 @@ func serverCommand() *cli.Command {
 			fs := http.FileServer(http.Dir(dir))
 			log.Print("Serving " + dir + " on http://" + url)
 			return http.ListenAndServe(url, http.HandlerFunc(func(resp http.ResponseWriter, req *http.Request) {
-				resp.Header().Add("Cache-Control", "no-cache")
+				resp.Header().Add("Cache-Control", "no-store")
 				if strings.HasSuffix(req.URL.Path, ".wasm") {
 					resp.Header().Set("content-type", "application/wasm")
 				}

docs/resources/README.md

@@ -14,6 +14,9 @@ Resources either directly contributing to the code, or are just interesting find
   - Tiling Noise
     - [ _Tiling Noise_ by Ronja](https://www.ronja-tutorials.com/post/029-tiling-noise/)
     - [gamedev.stackexchange _How do you generate tileable Perlin noise?_](https://gamedev.stackexchange.com/questions/23625/how-do-you-generate-tileable-perlin-noise)
+  - Buncha noise functions
+    - https://github.com/RodZill4/material-maker/blob/3b18267f29f0ead260aae1d3cf0d731db492981a/addons/material_maker/nodes/fbm2.mmg#L449
+  - [_Fractional Brownian Motion_ by Inigo Quilez](https://iquilezles.org/articles/fbm/)
 - Sampling and Distribution
   - Quasirandom
     - [The Unreasonable Effectiveness of Quasirandom Sequences](https://extremelearning.com.au/unreasonable-effectiveness-of-quasirandom-sequences/)

drawing/coloring/colors.go

@@ -1,25 +1,25 @@
 package coloring
 
-func Black() WebColor {
-	return WebColor{0, 0, 0, 255}
+func Black() Color {
+	return Color{0, 0, 0, 1}
 }
 
-func Grey(b byte) WebColor {
-	return WebColor{b, b, b, 255}
+func Grey(b float64) Color {
+	return Color{b, b, b, 1}
 }
 
-func White() WebColor {
-	return WebColor{255, 255, 255, 255}
+func White() Color {
+	return Color{1, 1, 1, 1}
 }
 
 // func Red() WebColor {
-// 	return WebColor{255, 0, 0, 255}
+// 	return WebColor{1, 0, 0, 1}
 // }
 
 // func Green() WebColor {
-// 	return WebColor{0, 255, 0, 255}
+// 	return WebColor{0, 1, 0, 1}
 // }
 
 // func Blue() WebColor {
-// 	return WebColor{0, 0, 255, 255}
+// 	return WebColor{0, 0, 1, 1}
 // }

drawing/coloring/colors_test.go

@@ -9,17 +9,17 @@ import (
 
 func TestColor(t *testing.T) {
 	tests := map[string]struct {
-		input coloring.WebColor
-		wantR byte
-		wantG byte
-		wantB byte
-		wantA byte
+		input coloring.Color
+		wantR float64
+		wantG float64
+		wantB float64
+		wantA float64
 	}{
-		"black": {input: coloring.Black(), wantR: 0, wantG: 0, wantB: 0, wantA: 255},
-		"white": {input: coloring.White(), wantR: 255, wantG: 255, wantB: 255, wantA: 255},
-		// "red":   {input: coloring.Red(), wantR: 255, wantG: 0, wantB: 0, wantA: 255},
-		// "green": {input: coloring.Green(), wantR: 0, wantG: 255, wantB: 0, wantA: 255},
-		// "blue":  {input: coloring.Blue(), wantR: 0, wantG: 0, wantB: 255, wantA: 255},
+		"black": {input: coloring.Black(), wantR: 0, wantG: 0, wantB: 0, wantA: 1},
+		"white": {input: coloring.White(), wantR: 1, wantG: 1, wantB: 1, wantA: 1},
+		// "red":   {input: coloring.Red(), wantR: 1, wantG: 0, wantB: 0, wantA: 1},
+		// "green": {input: coloring.Green(), wantR: 0, wantG: 1, wantB: 0, wantA: 1},
+		// "blue":  {input: coloring.Blue(), wantR: 0, wantG: 0, wantB: 1, wantA: 1},
 	}
 
 	for name, tc := range tests {

drawing/coloring/gradient.go

@@ -1,27 +1,55 @@
 package coloring
 
 import (
-	"image/color"
 	"sort"
+
+	"github.com/EliCDavis/vector"
+	"github.com/EliCDavis/vector/vector1"
+	"github.com/EliCDavis/vector/vector2"
+	"github.com/EliCDavis/vector/vector3"
+	"github.com/EliCDavis/vector/vector4"
 )
 
-type GradientKey struct {
+type GradientKey[T any] struct {
 	Time  float64
-	Color color.Color
+	Value T
 }
 
-type normalizedGradientKey struct {
+type normalizedGradientKey[T any] struct {
 	Time  float64
-	Color color.Color
+	Color T
+}
+
+func NewGradient1D(keys ...GradientKey[float64]) Gradient[float64] {
+	return NewGradient(vector1.Space[float64]{}, keys...)
+}
+
+func NewGradient2D(keys ...GradientKey[vector2.Float64]) Gradient[vector2.Float64] {
+	return NewGradient(vector2.Space[float64]{}, keys...)
+}
+
+func NewGradient3D(keys ...GradientKey[vector3.Float64]) Gradient[vector3.Float64] {
+	return NewGradient(vector3.Space[float64]{}, keys...)
+}
+
+func NewGradient4D(keys ...GradientKey[vector4.Float64]) Gradient[vector4.Float64] {
+	return NewGradient(vector4.Space[float64]{}, keys...)
 }
 
-func NewGradient(keys ...GradientKey) Gradient {
+func NewGradientColor(keys ...GradientKey[Color]) Gradient[Color] {
+	return NewGradient(Space{}, keys...)
+}
+
+func NewGradient[T any](space vector.Space[T], keys ...GradientKey[T]) Gradient[T] {
 	if len(keys) == 0 {
-		return Gradient{keys: []normalizedGradientKey{}}
+		return Gradient[T]{
+			space: space,
+			keys:  []normalizedGradientKey[T]{},
+		}
 	}
 
 	// Create a copy to avoid modifying the original slice
-	keysCopy := make([]GradientKey, len(keys))
+	keysCopy := make([]GradientKey[T], len(keys))
 	copy(keysCopy, keys)
 
 	// Sort keys by time
@@ -35,28 +63,33 @@ func NewGradient(keys ...GradientKey) Gradient {
 	timeRange := maxTime - minTime
 
 	// Create normalized keys
-	normalizedKeys := make([]normalizedGradientKey, len(keysCopy))
+	normalizedKeys := make([]normalizedGradientKey[T], len(keysCopy))
 	for i, key := range keysCopy {
 		normalizedTime := 0.0
 		if timeRange > 0 {
 			normalizedTime = (key.Time - minTime) / timeRange
 		}
-		normalizedKeys[i] = normalizedGradientKey{
+		normalizedKeys[i] = normalizedGradientKey[T]{
 			Time:  normalizedTime,
-			Color: key.Color,
+			Color: key.Value,
 		}
 	}
 
-	return Gradient{keys: normalizedKeys}
+	return Gradient[T]{
+		keys:  normalizedKeys,
+		space: space,
+	}
 }
 
-type Gradient struct {
-	keys []normalizedGradientKey
+type Gradient[T any] struct {
+	keys  []normalizedGradientKey[T]
+	space vector.Space[T]
 }
 
-func (g Gradient) Sample(t float64) color.Color {
+func (g Gradient[T]) Sample(t float64) T {
 	if len(g.keys) == 0 {
-		return color.RGBA{0, 0, 0, 255} // Default to black
+		var t T
+		return t
 	}
 
 	if len(g.keys) == 1 {
@@ -96,23 +129,8 @@ func (g Gradient) Sample(t float64) color.Color {
 	factor := (t - leftKey.Time) / timeRange
 
 	// Interpolate between the two colors
-	return interpolateColors(leftKey.Color, rightKey.Color, factor)
-}
-
-// Helper function to interpolate between two colors
-func interpolateColors(c1, c2 color.Color, factor float64) color.Color {
-	r1, g1, b1, a1 := c1.RGBA()
-	r2, g2, b2, a2 := c2.RGBA()
-
-	// Convert to 8-bit values for easier arithmetic
-	r1, g1, b1, a1 = r1>>8, g1>>8, b1>>8, a1>>8
-	r2, g2, b2, a2 = r2>>8, g2>>8, b2>>8, a2>>8
-
-	// Linear interpolation
-	r := uint8(float64(r1)*(1-factor) + float64(r2)*factor)
-	g := uint8(float64(g1)*(1-factor) + float64(g2)*factor)
-	b := uint8(float64(b1)*(1-factor) + float64(b2)*factor)
-	a := uint8(float64(a1)*(1-factor) + float64(a2)*factor)
-
-	return color.RGBA{r, g, b, a}
+	return g.space.Add(
+		g.space.Scale(leftKey.Color, 1-factor),
+		g.space.Scale(rightKey.Color, factor),
+	)
 }