vector3

type AddToArrayNodeData ¶ added in v0.27.0

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

func (cn AddToArrayNodeData[T]) Out() nodes.StructOutput[[]vector3.Vector[T]]

type ArrayFromComponentsNodeData ¶ added in v0.25.0

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

func (snd ArrayFromComponentsNodeData[T]) Out() nodes.StructOutput[[]vector3.Vector[T]]

type ArrayFromNodesNodeData ¶ added in v0.25.0

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

func (node ArrayFromNodesNodeData[T]) 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() nodes.StructOutput[float64]

func (d Distance[T]) Int() 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() 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() 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() 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() 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() nodes.StructOutput[vector3.Vector[float64]]

func (cn Double[T]) Int() nodes.StructOutput[vector3.Vector[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() nodes.StructOutput[vector3.Vector[float64]]

func (cn Half[T]) Int() nodes.StructOutput[vector3.Vector[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() nodes.StructOutput[vector3.Vector[float64]]

func (cn Inverse[T]) AdditiveInt() nodes.StructOutput[vector3.Vector[int]]

func (cn Inverse[T]) Multiplicative() nodes.StructOutput[vector3.Vector[float64]]

func (cn Inverse[T]) MultiplicativeInt() nodes.StructOutput[vector3.Vector[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() nodes.StructOutput[float64]

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

type NewNodeData ¶

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

func (cn NewNodeData[T]) 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() nodes.StructOutput[vector3.Float64]

type NormalizeArray ¶ added in v0.30.0

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

func (cn NormalizeArray) Normalized() nodes.StructOutput[[]vector3.Float64]

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() nodes.StructOutput[vector3.Vector[float64]]

func (cn Scale[T]) Int() nodes.StructOutput[vector3.Vector[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() nodes.StructOutput[T]

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

func (node Select[T]) Z() 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() nodes.StructOutput[[]T]

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

func (node SelectArray[T]) Z() 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() nodes.StructOutput[vector3.Vector[T]]

type SubtractToArrayNodeData ¶ added in v0.30.0

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

func (cn SubtractToArrayNodeData[T]) Out() nodes.StructOutput[[]vector3.Vector[T]]

type SumNodeData ¶

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

func (cn SumNodeData[T]) Out() nodes.StructOutput[vector3.Vector[T]]