texturing

type AddColorNode struct {
	Textures []nodes.Output[Texture[coloring.Color]]
}

type AddFloat1Node struct {
	Textures []nodes.Output[Texture[float64]]
}

type AddFloat2Node struct {
	Textures []nodes.Output[Texture[vector2.Float64]]
}

type AddFloat3Node struct {
	Textures []nodes.Output[Texture[vector3.Float64]]
}

type AddFloat4Node struct {
	Textures []nodes.Output[Texture[vector4.Float64]]
}

type ApplyGradientNode[T any] struct {
	Time     nodes.Output[Texture[float64]]
	Gradient nodes.Output[coloring.Gradient[T]]
}

type ApplyMaskNode[T any] struct {
	Texture nodes.Output[Texture[T]]
	Mask    nodes.Output[Texture[bool]]
	Fill    nodes.Output[T]
}

type Artifact[T any] struct {
	Texture    Texture[T]
	Conversion func(v T) color.Color
}

type ColorToImageNode struct {
	Texture nodes.Output[Texture[coloring.Color]]
}

type CompareValueNode[T vector.Number] struct {
	Texture nodes.Output[Texture[T]]
	Value   nodes.Output[T]
}

type DebugUV struct {
	ImageResolution int
	BoardResolution int

	PositiveCheckerColor color.Color
	NegativeCheckerColor color.Color

	XColorScale color.Color
	YColorScale color.Color
}

type DebugUVNode struct {
	ImageResolution      nodes.Output[int]
	BoardResolution      nodes.Output[int]
	PositiveCheckerColor nodes.Output[coloring.Color]
	NegativeCheckerColor nodes.Output[coloring.Color]
	XColorScale          nodes.Output[coloring.Color]
	YColorScale          nodes.Output[coloring.Color]
}

type DotProductNode struct {
	Texture nodes.Output[Texture[vector3.Float64]]
	Vector  nodes.Output[vector3.Float64]
}

type FloatToImageNode struct {
	R nodes.Output[Texture[float64]]
	G nodes.Output[Texture[float64]]
	B nodes.Output[Texture[float64]]
	A nodes.Output[Texture[float64]]

	RFill nodes.Output[float64]
	GFill nodes.Output[float64]
	BFill nodes.Output[float64]
	AFill nodes.Output[float64]
}

type FromArrayNode[T any] struct {
	Array  nodes.Output[[]T]
	Width  nodes.Output[int]
	Height nodes.Output[int]
}

type FromImageNode struct {
	Image nodes.Output[image.Image]
}

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"`
}

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"`
}

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"`
}

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"`
}

type InvalidDimension vector2.Vector[int]

type LinearGradient[T any] struct {
	Repetitions float64
	Rotation    float64
	Width       int
	Height      int
	Gradient    coloring.Gradient[T]
}

type LinearGradientNode[T any] struct {
	Repetitions nodes.Output[float64]
	Rotation    nodes.Output[float64]
	Width       nodes.Output[int]
	Height      nodes.Output[int]
	Gradient    nodes.Output[coloring.Gradient[T]]
}

type MaskToSDFNode struct {
	Mask nodes.Output[Texture[bool]]
}

type MultiplyFloat1Node struct {
	Textures []nodes.Output[Texture[float64]]
}

type NoiseNode struct {
	Width       nodes.Output[int]             `description:"number of pixels in the x direction of the texture"`
	Height      nodes.Output[int]             `description:"number of pixels in the y direction of the texture"`
	Scale       nodes.Output[vector2.Float64] `description:"the X and Y scale of the first octave noise"`
	Folds       nodes.Output[int]             `description:"the number of folds (offsetting the noise negatively and taking the absolute value)"`
	Octaves     nodes.Output[int]             `description:"the number of iterations"`
	Persistence nodes.Output[float64]         `description:"the strength of each subsequent iteration"`
	Offset      nodes.Output[float64]         `description:"the offset of the points, can be used to animate the noise"`
	Seed        nodes.Output[float64]         `description:"RNG seed"`
	Polar       nodes.Output[bool]            `description:"Whether or not to use polar coordinates to sample the random function"`
}

type OneMinusNode struct {
	Texture nodes.Output[Texture[float64]]
}

type PerlinNode struct {
	Width     nodes.Output[int]
	Height    nodes.Output[int]
	Positive  nodes.Output[float64]
	Negative  nodes.Output[float64]
	Frequency nodes.Output[vector2.Float64]
}

type RadialGradient[T any] struct {
	Repetitions float64
	Width       int
	Height      int
	Gradient    coloring.Gradient[T]
}

type RadialGradientNode[T any] struct {
	Repetitions nodes.Output[float64]
	Width       nodes.Output[int]
	Height      nodes.Output[int]
	Gradient    nodes.Output[coloring.Gradient[T]]
}

type SampleSDFNode struct {
	Texture nodes.Output[Texture[float64]]
	Size    nodes.Output[vector3.Float64]
}

type ScaleColorNode struct {
	Texture nodes.Output[Texture[coloring.Color]]
	Scale   nodes.Output[Texture[float64]]
}

type ScaleColorUniformNode struct {
	Texture nodes.Output[Texture[coloring.Color]]
	Scale   nodes.Output[float64]
}

type ScaleFloat1UniformNode struct {
	Texture nodes.Output[Texture[float64]]
	Scale   nodes.Output[float64]
}

type ScaleFloat2UniformNode struct {
	Texture nodes.Output[Texture[vector2.Float64]]
	Scale   nodes.Output[float64]
}

type ScaleFloat3UniformNode struct {
	Texture nodes.Output[Texture[vector3.Float64]]
	Scale   nodes.Output[float64]
}

type ScaleFloat4UniformNode struct {
	Texture nodes.Output[Texture[vector4.Float64]]
	Scale   nodes.Output[float64]
}

type SeamlessPerlinNode struct {
	Dimensions nodes.Output[int]
	Positive   nodes.Output[float64]
	Negative   nodes.Output[float64]
	Octaves    nodes.Output[int]
	Frequency  nodes.Output[float64]
}

type SelectColorNode struct {
	Texture nodes.Output[Texture[coloring.Color]]
}

type SelectNode[T any] struct{ Texture nodes.Output[Texture[T]] }

type Texture[T any] struct {
	// contains filtered or unexported fields
}

type UniformNode[T any] struct {
	Fill   nodes.Output[T]
	Width  nodes.Output[int]
	Height nodes.Output[int]
}