Vector inverse node, circumference node, randomize array changes, grid fixes

Author: EliCDavis

generator/examples/tower.json

@@ -14,6 +14,8 @@ func init() {
 
 	refutil.RegisterType[Round](factory)
 
+	refutil.RegisterType[nodes.Struct[CircumferenceNode]](factory)
+
 	refutil.RegisterType[nodes.Struct[DifferenceNodeData[int]]](factory)
 	refutil.RegisterType[nodes.Struct[DifferenceNodeData[float64]]](factory)
 	refutil.RegisterType[nodes.Struct[DifferencesToArrayNodeData[int]]](factory)
@@ -216,3 +218,27 @@ func (cn RoundNodeData) Float() nodes.StructOutput[float64] {
 	}
 	return nodes.NewStructOutput(math.Round(cn.In.Value()))
 }
+
+// ============================================================================
+
+type CircumferenceNode struct {
+	Radius nodes.Output[float64]
+}
+
+func (cn CircumferenceNode) Description() string {
+	return "Circumference of a circle"
+}
+
+func (cn CircumferenceNode) Int() nodes.StructOutput[int] {
+	if cn.Radius == nil {
+		return nodes.NewStructOutput(0)
+	}
+	return nodes.NewStructOutput(int(math.Round(cn.Radius.Value() * 2 * math.Pi)))
+}
+
+func (cn CircumferenceNode) Float() nodes.StructOutput[float64] {
+	if cn.Radius == nil {
+		return nodes.NewStructOutput(0.)
+	}
+	return nodes.NewStructOutput(math.Round(cn.Radius.Value() * 2 * math.Pi))
+}

math/nodes.go

@@ -59,10 +59,19 @@ type RandomizeArrayNodeData struct {
 	ScaleMaximum       nodes.Output[vector3.Float64]
 	RotationMinimum    nodes.Output[vector3.Float64]
 	RotationMaximum    nodes.Output[vector3.Float64]
-	Samples            nodes.Output[int]
+	Array              nodes.Output[[]TRS]
 }
 
 func (tnd RandomizeArrayNodeData) Out() nodes.StructOutput[[]TRS] {
+	if tnd.Array == nil {
+		return nodes.NewStructOutput[[]TRS](nil)
+	}
+
+	input := tnd.Array.Value()
+	if len(input) == 0 {
+		return nodes.NewStructOutput[[]TRS](nil)
+	}
+
 	minT := nodes.TryGetOutputValue(tnd.TranslationMinimum, vector3.Zero[float64]())
 	maxT := nodes.TryGetOutputValue(tnd.TranslationMaximum, vector3.Zero[float64]())
 	rangeT := maxT.Sub(minT)
@@ -75,9 +84,9 @@ func (tnd RandomizeArrayNodeData) Out() nodes.StructOutput[[]TRS] {
 	maxR := nodes.TryGetOutputValue(tnd.RotationMaximum, vector3.Zero[float64]())
 	rangeR := maxR.Sub(minR)
 
-	samples := make([]TRS, max(nodes.TryGetOutputValue(tnd.Samples, 0), 0))
-	for i := range samples {
-		samples[i] = New(
+	out := make([]TRS, len(input))
+	for i := range out {
+		sample := New(
 			minT.Add(vector3.New(
 				rangeT.X()*rand.Float64(),
 				rangeT.Y()*rand.Float64(),
@@ -88,16 +97,16 @@ func (tnd RandomizeArrayNodeData) Out() nodes.StructOutput[[]TRS] {
 				rangeR.Y()*rand.Float64(),
 				rangeR.Z()*rand.Float64(),
 			))),
-			// quaternion.Identity(),
 			minS.Add(vector3.New(
 				rangeS.X()*rand.Float64(),
 				rangeS.Y()*rand.Float64(),
 				rangeS.Z()*rand.Float64(),
 			)),
 		)
+		out[i] = input[i].Multiply(sample)
 	}
 
-	return nodes.NewStructOutput(samples)
+	return nodes.NewStructOutput(out)
 }
 
 // ============================================================================

math/trs/nodes.go

@@ -87,3 +87,42 @@ func (cn Dot) Dot() nodes.StructOutput[float64] {
 func (cn Dot) DotDescription() string {
 	return "The dot product of A and B. If either value is not set, then 0 is returned"
 }
+
+// ============================================================================
+
+type Inverse[T vector.Number] struct {
+	Vector nodes.Output[vector3.Vector[T]]
+}
+
+func (cn Inverse[T]) additive() vector3.Vector[float64] {
+	if cn.Vector == nil {
+		return vector3.Zero[float64]()
+	}
+
+	return cn.Vector.Value().ToFloat64().Scale(-1)
+}
+
+func (cn Inverse[T]) multiplicative() vector3.Vector[float64] {
+	if cn.Vector == nil {
+		return vector3.Zero[float64]()
+	}
+
+	in := cn.Vector.Value().ToFloat64()
+	return vector3.New(1./in.X(), 1./in.Y(), 1./in.Z())
+}
+
+func (cn Inverse[T]) Additive() nodes.StructOutput[vector3.Vector[float64]] {
+	return nodes.NewStructOutput(cn.additive())
+}
+
+func (cn Inverse[T]) AdditiveInt() nodes.StructOutput[vector3.Vector[int]] {
+	return nodes.NewStructOutput(cn.additive().ToInt())
+}
+
+func (cn Inverse[T]) Multiplicative() nodes.StructOutput[vector3.Vector[float64]] {
+	return nodes.NewStructOutput(cn.multiplicative())
+}
+
+func (cn Inverse[T]) MultiplicativeInt() nodes.StructOutput[vector3.Vector[int]] {
+	return nodes.NewStructOutput(cn.multiplicative().RoundToInt())
+}

math/vector3/convenience.go

@@ -53,5 +53,8 @@ func init() {
 	refutil.RegisterType[nodes.Struct[DistancesToNodes[float64]]](factory)
 	refutil.RegisterType[nodes.Struct[DistancesToNodes[int]]](factory)
 
+	refutil.RegisterType[nodes.Struct[Inverse[int]]](factory)
+	refutil.RegisterType[nodes.Struct[Inverse[float64]]](factory)
+
 	generator.RegisterTypes(factory)
 }

math/vector3/nodes.go

@@ -55,8 +55,8 @@ func (g Grid) Vector2() []vector2.Float64 {
 		bottomLeft = bottomLeft.SetY(0)
 	}
 
-	for x := range g.Rows {
-		for y := range g.Columns {
+	for y := range g.Rows {
+		for x := range g.Columns {
 			inc := vector2.New(
 				widthInc*float64(x),
 				heightInc*float64(y),

modeling/repeat/grid.go

@@ -31,6 +31,22 @@ func TestGrid(t *testing.T) {
 			rows: 0, column: 1, width: 1, height: 1,
 			expect: []vector2.Float64{},
 		},
+		"vertical line": {
+			rows: 3, column: 1, width: 1, height: 1,
+			expect: []vector2.Float64{
+				vector2.New(0., -0.5),
+				vector2.New(0., 0.0),
+				vector2.New(0., 0.5),
+			},
+		},
+		"horizontal line": {
+			rows: 1, column: 3, width: 1, height: 1,
+			expect: []vector2.Float64{
+				vector2.New(-0.5, 0.),
+				vector2.New(0.0, 0.),
+				vector2.New(0.5, 0.),
+			},
+		},
 		"4 corners": {
 			rows: 2, column: 2, width: 1, height: 1,
 			expect: []vector2.Float64{