vector3

type AddToArrayNode ¶ added in v0.32.0

type AddToArrayNode[T vector.Number] struct {
	Amount nodes.Output[vector3.Vector[T]]
	Array  nodes.Output[[]vector3.Vector[T]]
}

func (cn AddToArrayNode[T]) Out(out *nodes.StructOutput[[]vector3.Vector[T]])

type ArrayFromComponentsNode ¶ added in v0.32.0

type ArrayFromComponentsNode[T vector.Number] struct {
	X nodes.Output[[]T]
	Y nodes.Output[[]T]
	Z nodes.Output[[]T]
}

func (snd ArrayFromComponentsNode[T]) Out(out *nodes.StructOutput[[]vector3.Vector[T]])

type ArrayFromNodesNode ¶ added in v0.32.0

type ArrayFromNodesNode[T vector.Number] struct {
	In []nodes.Output[vector3.Vector[T]]
}

func (node ArrayFromNodesNode[T]) Out(out *nodes.StructOutput[[]vector3.Vector[T]])

type Distance ¶ added in v0.27.0

type Distance[T vector.Number] struct {
	A nodes.Output[vector3.Vector[T]]
	B nodes.Output[vector3.Vector[T]]
}

Returns a single float, representing the distance between A and B

func (d Distance[T]) Float64(out *nodes.StructOutput[float64])

func (d Distance[T]) Int(out *nodes.StructOutput[int])

type Distances ¶ added in v0.27.0

type Distances[T vector.Number] struct {
	A nodes.Output[[]vector3.Vector[T]]
	B nodes.Output[[]vector3.Vector[T]]
}

Returns an array of floats, representing distance(a[i], b[i])

func (d Distances[T]) Distances(out *nodes.StructOutput[[]float64])

type DistancesToArray ¶ added in v0.27.0

type DistancesToArray[T vector.Number] struct {
	In    nodes.Output[vector3.Vector[T]]
	Array nodes.Output[[]vector3.Vector[T]]
}

Returns an array of floats, representing the distance between A to every element in B

func (d DistancesToArray[T]) Distances(out *nodes.StructOutput[[]float64])

type DistancesToNodes ¶ added in v0.27.0

type DistancesToNodes[T vector.Number] struct {
	In    nodes.Output[vector3.Vector[T]]
	Nodes []nodes.Output[vector3.Vector[T]]
}

Returns an array of floats, representing the distance between A to every node connected to B

func (d DistancesToNodes[T]) Distances(out *nodes.StructOutput[[]float64])

type Dot ¶ added in v0.25.0

type Dot struct {
	A nodes.Output[vector3.Float64]
	B nodes.Output[vector3.Float64]
}

func (cn Dot) Dot(out *nodes.StructOutput[float64])

func (cn Dot) DotDescription() string

type Double ¶ added in v0.25.0

type Double[T vector.Number] struct {
	In nodes.Output[vector3.Vector[T]]
}

func (cn Double[T]) Float64(out *nodes.StructOutput[vector3.Float64])

func (cn Double[T]) Int(out *nodes.StructOutput[vector3.Int])

type Half ¶ added in v0.25.0

type Half[T vector.Number] struct {
	In nodes.Output[vector3.Vector[T]]
}

func (cn Half[T]) Float64(out *nodes.StructOutput[vector3.Float64])

func (cn Half[T]) Int(out *nodes.StructOutput[vector3.Int])

type Inverse ¶ added in v0.27.1

type Inverse[T vector.Number] struct {
	Vector nodes.Output[vector3.Vector[T]]
}

func (cn Inverse[T]) Additive(out *nodes.StructOutput[vector3.Float64])

func (cn Inverse[T]) AdditiveInt(out *nodes.StructOutput[vector3.Int])

func (cn Inverse[T]) Multiplicative(out *nodes.StructOutput[vector3.Float64])

func (cn Inverse[T]) MultiplicativeInt(out *nodes.StructOutput[vector3.Int])

type Length ¶ added in v0.25.0

type Length[T vector.Number] struct {
	In nodes.Output[vector3.Vector[T]]
}

func (cn Length[T]) Float64(out *nodes.StructOutput[float64])

func (cn Length[T]) Int(out *nodes.StructOutput[int])

type NewNode ¶ added in v0.32.0

type NewNode[T vector.Number] struct {
	X nodes.Output[T]
	Y nodes.Output[T]
	Z nodes.Output[T]
}

func (cn NewNode[T]) Out(out *nodes.StructOutput[vector3.Vector[T]])

type Normalize ¶ added in v0.30.0

type Normalize struct {
	In nodes.Output[vector3.Float64]
}

func (cn Normalize) NormalizeDescription() string

func (cn Normalize) Normalized(out *nodes.StructOutput[vector3.Float64])

type NormalizeArray ¶ added in v0.30.0

type NormalizeArray struct {
	In nodes.Output[[]vector3.Float64]
}

func (cn NormalizeArray) Global(out *nodes.StructOutput[[]vector3.Float64])

func (cn NormalizeArray) GlobalDescription() string

func (cn NormalizeArray) Local(out *nodes.StructOutput[[]vector3.Float64])

func (cn NormalizeArray) LocalDescription() string

type Scale ¶ added in v0.25.0

type Scale[T vector.Number] struct {
	Vector nodes.Output[vector3.Vector[T]] `description:"The vector to scale"`
	Amount nodes.Output[float64]           `description:"The amount the scale by (defaults to 1.0)"`
}

func (cn Scale[T]) Float64(out *nodes.StructOutput[vector3.Float64])

func (cn Scale[T]) Int(out *nodes.StructOutput[vector3.Int])

type Select ¶ added in v0.25.0

type Select[T vector.Number] struct {
	In nodes.Output[vector3.Vector[T]]
}

func (node Select[T]) X(out *nodes.StructOutput[T])

func (node Select[T]) Y(out *nodes.StructOutput[T])

func (node Select[T]) Z(out *nodes.StructOutput[T])

type SelectArray ¶ added in v0.25.0

type SelectArray[T vector.Number] struct {
	In nodes.Output[[]vector3.Vector[T]]
}

func (node SelectArray[T]) X(out *nodes.StructOutput[[]T])

func (node SelectArray[T]) Y(out *nodes.StructOutput[[]T])

func (node SelectArray[T]) Z(out *nodes.StructOutput[[]T])

type Subtract ¶ added in v0.30.0

type Subtract[T vector.Number] struct {
	A nodes.Output[vector3.Vector[T]]
	B nodes.Output[vector3.Vector[T]]
}

func (d Subtract[T]) Out(out *nodes.StructOutput[vector3.Vector[T]])

type SubtractToArrayNode ¶ added in v0.32.0

type SubtractToArrayNode[T vector.Number] struct {
	Amount nodes.Output[vector3.Vector[T]]
	Array  nodes.Output[[]vector3.Vector[T]]
}

func (cn SubtractToArrayNode[T]) Out(out *nodes.StructOutput[[]vector3.Vector[T]])

type SumNode ¶ added in v0.32.0

type SumNode[T vector.Number] struct {
	Values []nodes.Output[vector3.Vector[T]]
}

func (cn SumNode[T]) Out(out *nodes.StructOutput[vector3.Vector[T]])