GLTF Improvements (#120)

* fixing gltf tests to work on windows

* Start of instancing refactor

* GLTF read now is smart about not decoding textures twice

* Automatic GPU instancing now collapsing children nodes

* reader now properly interpretting children

* GLTF Reader fixes

* Can now expand GPU instances into proper gltf nodes using the Expand instancing strategy

* nodes now have children array field

* Start of loading extensions

* Can now read all Material GLTF extensions

Author: EliCDavis

.github/workflows/release.yml

@@ -30,7 +30,7 @@ jobs:
       - name: Push Nix-cached Release Artifacts
         run: |
           nix run .#sri-check-up --print-build-logs
-          nix run .#release --print-build-logs
+          nix run .#gh-release --print-build-logs
 
   deploy:
     runs-on: ubuntu-latest

cmd/polyform/main.go

@@ -102,6 +102,32 @@ func main() {
 		}}
 	})
 
+	serialize.Register(nodeSerializer, func(g coloring.Gradient[float64]) manifest.Entry {
+		width := 100
+		height := 20
+		i := image.NewGray(image.Rect(0, 0, width, height))
+		for x := range width {
+			v := uint8(g.Sample(float64(x)/100.) * 255.)
+			for y := range height {
+				i.SetGray(x, y, color.Gray{Y: v})
+			}
+		}
+		return manifest.Entry{Artifact: basics.Image{Image: i}}
+	})
+
+	serialize.Register(nodeSerializer, func(g coloring.Gradient[coloring.Color]) manifest.Entry {
+		width := 100
+		height := 20
+		i := image.NewRGBA(image.Rect(0, 0, width, height))
+		for x := range width {
+			v := g.Sample(float64(x) / 100.)
+			for y := range height {
+				i.Set(x, y, v)
+			}
+		}
+		return manifest.Entry{Artifact: basics.Image{Image: i}}
+	})
+
 	app := generator.App{
 		Name:        "Polyform",
 		Description: "Immutable mesh processing pipelines",

drawing/coloring/operations.go

@@ -5,7 +5,7 @@ import (
 	"math"
 )
 
-func MultiplyRGBByConstant(c color.Color, amount float64) color.Color {
+func ScaleRGB(c color.Color, amount float64) color.Color {
 	r, g, b, a := c.RGBA()
 
 	rVal := math.Round(float64(r>>8) * amount)
@@ -20,7 +20,7 @@ func MultiplyRGBByConstant(c color.Color, amount float64) color.Color {
 	}
 }
 
-func MultiplyColorByConstant(c color.Color, amount float64) color.Color {
+func ScaleColor(c color.Color, amount float64) color.Color {
 	r, g, b, a := c.RGBA()
 
 	rVal := math.Round(float64(r>>8) * amount)

drawing/coloring/operations_test.go

@@ -158,7 +158,7 @@ func TestAddRGB(t *testing.T) {
 }
 
 func TestMultiplyRGBByConstant(t *testing.T) {
-	scaled := coloring.MultiplyRGBByConstant(color.RGBA{R: 2, G: 100, B: 150, A: 200}, 0.5)
+	scaled := coloring.ScaleRGB(color.RGBA{R: 2, G: 100, B: 150, A: 200}, 0.5)
 
 	assert.True(t, coloring.RedEqual(scaled, 1))
 	assert.True(t, coloring.GreenEqual(scaled, 50))

drawing/texturing/blur.go

@@ -1,49 +1,32 @@
 package texturing
 
 import (
+	"cmp"
 	"image"
 	"image/color"
+	"math"
 
 	"github.com/EliCDavis/polyform/drawing/coloring"
+	"github.com/EliCDavis/polyform/nodes"
+	"github.com/EliCDavis/vector"
+	"github.com/EliCDavis/vector/vector1"
+	"github.com/EliCDavis/vector/vector2"
+	"github.com/EliCDavis/vector/vector3"
 )
 
-func GaussianBlur(src image.Image) image.Image {
-	dst := image.NewRGBA(src.Bounds())
-	ConvolveImage(src, func(x, y int, vals []color.Color) {
-		x1y1 := coloring.MultiplyRGBByConstant(vals[0], 1./16)
-		x2y1 := coloring.MultiplyRGBByConstant(vals[1], 2./16)
-		x3y1 := coloring.MultiplyRGBByConstant(vals[2], 1./16)
-
-		x1y2 := coloring.MultiplyRGBByConstant(vals[3], 2./16)
-		x2y2 := coloring.MultiplyRGBByConstant(vals[4], 4./16)
-		x3y2 := coloring.MultiplyRGBByConstant(vals[5], 2./16)
-
-		x1y3 := coloring.MultiplyRGBByConstant(vals[6], 1./16)
-		x2y3 := coloring.MultiplyRGBByConstant(vals[7], 2./16)
-		x3y3 := coloring.MultiplyRGBByConstant(vals[8], 1./16)
-
-		dst.Set(x, y, coloring.AddRGB(
-			x1y1, x2y1, x3y1,
-			x1y2, x2y2, x3y2,
-			x1y3, x2y3, x3y3,
-		))
-	})
-	return dst
-}
-
 func boxBlur(src image.Image, dst *image.RGBA) {
 	ConvolveImage(src, func(x, y int, vals []color.Color) {
-		x1y1 := coloring.MultiplyRGBByConstant(vals[0], 1./9)
-		x2y1 := coloring.MultiplyRGBByConstant(vals[1], 1./9)
-		x3y1 := coloring.MultiplyRGBByConstant(vals[2], 1./9)
+		x1y1 := coloring.ScaleRGB(vals[0], 1./9)
+		x2y1 := coloring.ScaleRGB(vals[1], 1./9)
+		x3y1 := coloring.ScaleRGB(vals[2], 1./9)
 
-		x1y2 := coloring.MultiplyRGBByConstant(vals[3], 1./9)
-		x2y2 := coloring.MultiplyRGBByConstant(vals[4], 1./9)
-		x3y2 := coloring.MultiplyRGBByConstant(vals[5], 1./9)
+		x1y2 := coloring.ScaleRGB(vals[3], 1./9)
+		x2y2 := coloring.ScaleRGB(vals[4], 1./9)
+		x3y2 := coloring.ScaleRGB(vals[5], 1./9)
 
-		x1y3 := coloring.MultiplyRGBByConstant(vals[6], 1./9)
-		x2y3 := coloring.MultiplyRGBByConstant(vals[7], 1./9)
-		x3y3 := coloring.MultiplyRGBByConstant(vals[8], 1./9)
+		x1y3 := coloring.ScaleRGB(vals[6], 1./9)
+		x2y3 := coloring.ScaleRGB(vals[7], 1./9)
+		x3y3 := coloring.ScaleRGB(vals[8], 1./9)
 
 		dst.Set(x, y, coloring.AddRGB(
 			x1y1, x2y1, x3y1,
@@ -82,3 +65,137 @@ func BoxBlurNTimes(src image.Image, iterations int) image.Image {
 	}
 	return dst
 }
+
+// Generates a normalized 1D Gaussian kernel
+func gaussianKernel(radius int, sigma float64) []float64 {
+	kernel := make([]float64, 2*radius+1)
+	var sum float64
+
+	sigma2 := sigma * sigma * 2
+	for i := -radius; i <= radius; i++ {
+		v := math.Exp(-(float64(i * i)) / sigma2)
+		kernel[i+radius] = v
+		sum += v
+	}
+	for i := range kernel {
+		kernel[i] /= sum
+	}
+	return kernel
+}
+
+func clamp[T cmp.Ordered](i, minimum, maximum T) T {
+	return max(min(i, maximum), minimum)
+}
+
+// Applies a 1D convolution along x or y
+func convolve1DGaussian[T any](space vector.Space[T], src Texture[T], dst Texture[T], kernel []float64, horizontal bool) {
+	radius := len(kernel) / 2
+
+	if horizontal {
+		src.ScanParallel(func(x, y int, v T) {
+			var accum T
+			for k := -radius; k <= radius; k++ {
+				sx := clamp(x+k, 0, src.width-1)
+				weighted := space.Scale(src.Get(sx, y), kernel[k+radius])
+				accum = space.Add(accum, weighted)
+			}
+			dst.Set(x, y, accum)
+		})
+	} else {
+		src.ScanParallel(func(x, y int, v T) {
+			var accum T
+			for k := -radius; k <= radius; k++ {
+				sy := clamp(y+k, 0, src.height-1)
+				weighted := space.Scale(src.Get(x, sy), kernel[k+radius])
+				accum = space.Add(accum, weighted)
+			}
+			dst.Set(x, y, accum)
+		})
+	}
+}
+
+// GaussianBlur applies a Gaussian blur to the texture
+func RadialGaussianBlur[T any](space vector.Space[T], src Texture[T], radius int, sigma float64) Texture[T] {
+	kernel := gaussianKernel(radius, sigma)
+
+	tmp := NewTexture[T](src.width, src.height)
+	out := NewTexture[T](src.width, src.height)
+
+	// Horizontal then vertical
+	convolve1DGaussian(space, src, tmp, kernel, true)
+	convolve1DGaussian(space, tmp, out, kernel, false)
+
+	return out
+}
+
+type GaussianBlurFloatNode struct {
+	Texture nodes.Output[Texture[float64]] `description:"Texture to blur"`
+	Radius  nodes.Output[int]              `description:"Size of the kernel in pixels"`
+	Signma  nodes.Output[float64]          `description:"standard deviation of the gaussian"`
+}
+
+func (n GaussianBlurFloatNode) Value(out *nodes.StructOutput[Texture[float64]]) {
+	if n.Texture == nil {
+		return
+	}
+	out.Set(RadialGaussianBlur(
+		vector1.Space[float64]{},
+		nodes.GetOutputValue(out, n.Texture),
+		nodes.TryGetOutputValue(out, n.Radius, 1),
+		nodes.TryGetOutputValue(out, n.Signma, 1),
+	))
+}
+
+type GaussianBlurFloat2Node struct {
+	Texture nodes.Output[Texture[vector2.Float64]] `description:"Texture to blur"`
+	Radius  nodes.Output[int]                      `description:"Size of the kernel in pixels"`
+	Signma  nodes.Output[float64]                  `description:"standard deviation of the gaussian"`
+}
+
+func (n GaussianBlurFloat2Node) Value(out *nodes.StructOutput[Texture[vector2.Float64]]) {
+	if n.Texture == nil {
+		return
+	}
+	out.Set(RadialGaussianBlur(
+		vector2.Space[float64]{},
+		nodes.GetOutputValue(out, n.Texture),
+		nodes.TryGetOutputValue(out, n.Radius, 1),
+		nodes.TryGetOutputValue(out, n.Signma, 1),
+	))
+}
+
+type GaussianBlurFloat3Node struct {
+	Texture nodes.Output[Texture[vector3.Float64]] `description:"Texture to blur"`
+	Radius  nodes.Output[int]                      `description:"Size of the kernel in pixels"`
+	Signma  nodes.Output[float64]                  `description:"standard deviation of the gaussian"`
+}
+
+func (n GaussianBlurFloat3Node) Value(out *nodes.StructOutput[Texture[vector3.Float64]]) {
+	if n.Texture == nil {
+		return
+	}
+	out.Set(RadialGaussianBlur(
+		vector3.Space[float64]{},
+		nodes.GetOutputValue(out, n.Texture),
+		nodes.TryGetOutputValue(out, n.Radius, 1),
+		nodes.TryGetOutputValue(out, n.Signma, 1),
+	))
+}
+
+type GaussianBlurColorNode struct {
+	Texture nodes.Output[Texture[coloring.Color]] `description:"Texture to blur"`
+	Radius  nodes.Output[int]                     `description:"Size of the kernel in pixels"`
+	Signma  nodes.Output[float64]                 `description:"standard deviation of the gaussian"`
+}
+
+func (n GaussianBlurColorNode) Value(out *nodes.StructOutput[Texture[coloring.Color]]) {
+	if n.Texture == nil {
+		return
+	}
+	out.Set(RadialGaussianBlur(
+		coloring.Space{},
+		nodes.GetOutputValue(out, n.Texture),
+		nodes.TryGetOutputValue(out, n.Radius, 1),
+		nodes.TryGetOutputValue(out, n.Signma, 1),
+	))
+}

drawing/texturing/color.go

@@ -0,0 +1,54 @@
+package texturing
+
+import (
+	"github.com/EliCDavis/polyform/drawing/coloring"
+)
+
+func DivideColor(a, b Texture[coloring.Color]) (*Texture[coloring.Color], error) {
+	if !resolutionsMatch([]Texture[coloring.Color]{a, b}) {
+		return nil, ErrMismatchDimensions
+	}
+
+	result := NewTexture[coloring.Color](a.width, a.height)
+	a.ScanParallel(func(x, y int, v coloring.Color) {
+		other := b.Get(x, y)
+		result.Set(x, y, coloring.Color{
+			R: v.R / other.R,
+			G: v.G / other.G,
+			B: v.B / other.B,
+			A: v.A / other.A,
+		})
+	})
+
+	return &result, nil
+}
+
+func MaxColor(a Texture[coloring.Color], other float64) Texture[coloring.Color] {
+
+	result := NewTexture[coloring.Color](a.width, a.height)
+	a.ScanParallel(func(x, y int, v coloring.Color) {
+		result.Set(x, y, coloring.Color{
+			R: max(v.R, other),
+			G: max(v.G, other),
+			B: max(v.B, other),
+			A: max(v.A, other),
+		})
+	})
+
+	return result
+}
+
+func ClampColor(a Texture[coloring.Color], minimum, maximum float64) Texture[coloring.Color] {
+
+	result := NewTexture[coloring.Color](a.width, a.height)
+	a.ScanParallel(func(x, y int, v coloring.Color) {
+		result.Set(x, y, coloring.Color{
+			R: min(max(v.R, minimum), maximum),
+			G: min(max(v.G, minimum), maximum),
+			B: min(max(v.B, minimum), maximum),
+			A: min(max(v.A, minimum), maximum),
+		})
+	})
+
+	return result
+}

drawing/texturing/errors.go

@@ -0,0 +1,5 @@
+package texturing
+
+import "errors"
+
+var ErrMismatchDimensions = errors.New("mismatch texture resolutions")

drawing/texturing/float.go

@@ -6,6 +6,16 @@ import (
 	"github.com/EliCDavis/polyform/nodes"
 )
 
+func OneMinus(in Texture[float64]) Texture[float64] {
+	result := NewTexture[float64](in.width, in.height)
+	for y := range in.height {
+		for x := range in.width {
+			result.Set(x, y, 1-in.Get(x, y))
+		}
+	}
+	return result
+}
+
 type OneMinusNode struct {
 	Texture nodes.Output[Texture[float64]]
 }
@@ -14,17 +24,7 @@ func (n OneMinusNode) Result(out *nodes.StructOutput[Texture[float64]]) {
 	if n.Texture == nil {
 		return
 	}
-
-	tex := nodes.GetOutputValue(out, n.Texture)
-	result := NewTexture[float64](tex.width, tex.height)
-
-	for y := range tex.height {
-		for x := range tex.width {
-			result.Set(x, y, 1-tex.Get(x, y))
-		}
-	}
-
-	out.Set(result)
+	out.Set(OneMinus(nodes.GetOutputValue(out, n.Texture)))
 }
 
 type MultiplyFloat1Node struct {

drawing/texturing/nodes.go

@@ -79,5 +79,10 @@ func init() {
 
 	refutil.RegisterType[nodes.Struct[DotProductNode]](factory)
 
+	refutil.RegisterType[nodes.Struct[GaussianBlurFloatNode]](factory)
+	refutil.RegisterType[nodes.Struct[GaussianBlurFloat2Node]](factory)
+	refutil.RegisterType[nodes.Struct[GaussianBlurFloat3Node]](factory)
+	refutil.RegisterType[nodes.Struct[GaussianBlurColorNode]](factory)
+
 	generator.RegisterTypes(factory)
 }