math

README

Math

Primitive math utilities to be used by the remaining of the library. Math imports nothing, everything else imports it. There is a slight hierarchy to the sub-packages found in math.

Sample

Sample serves as a group of definitions for defining a mapping from one numeric value to another. Another term for this is "function" or "mapping" but golang already took both of those keywords so I settled on "sample". Code throughout polyform uses the definitions like sample.FloatToVec2 to indicate this method maps a float to a Vector 2 value.

There are also some general utility functions for building common mappings between two domains of numbers.

• Compose - Takes an array of sample functions and feeds the output value from one function into the input value to the next function before finally returning the final value.
  • ComposeFloat
  • ComposeVec2
  • ComposeVec3
• LinearMapping - Remaps some float value between A and B to sample a line in N-Dimensional space linearly.
  • LinearFloatMapping
  • LinearVector2Mapping
  • LinearVector3Mapping
• Trig
  • Sin - Maps a float value to a sin wave with some specified amplitude and frequency.
  • Cos - Maps a float value to a sin wave with some specified amplitude and frequency.

Curves

Curves builds off of the sample package. The one restriction it makes is that the input domain is restricted to float values between 0 and 1. This is where more common animation curves reside.

Noise

Different noise algorithms commonly used in procedural generation.

SDF

SDF implementations of different geometry primitives, along with common math functions. Basically slowly picking through Inigo Quilez's Distfunction article as I need them in my different projects.

TRS

Math around Translation / Rotation / Scale Matrices

Documentation

Index

• type DifferenceData
  • func (cn DifferenceData[T]) Process() (T, error)
• type DifferenceNode
• type DivideData
  • func (cn DivideData[T]) Process() (T, error)
• type DivideNode
• type Multiply
• type MultiplyData
  • func (cn MultiplyData[T]) Process() (T, error)
• type Round
• type RoundData
  • func (cn RoundData[T]) Process() (int, error)
• type SumData
  • func (cn SumData[T]) Process() (T, error)
• type SumNode

Types

type DifferenceData

type DifferenceData[T vector.Number] struct {
	A nodes.NodeOutput[T]
	B nodes.NodeOutput[T]
}

func (DifferenceData[T]) Process

func (cn DifferenceData[T]) Process() (T, error)

type DifferenceNode

type DifferenceNode = nodes.Struct[float64, DifferenceData[float64]]

============================================================================

type DivideData

type DivideData[T vector.Number] struct {
	Dividend nodes.NodeOutput[T]
	Divisor  nodes.NodeOutput[T]
}

func (DivideData[T]) Process

func (cn DivideData[T]) Process() (T, error)

type DivideNode

type DivideNode = nodes.Struct[float64, DivideData[float64]]

============================================================================

type Multiply

type Multiply = nodes.Struct[float64, MultiplyData[float64]]

============================================================================

type MultiplyData

type MultiplyData[T vector.Number] struct {
	A nodes.NodeOutput[T]
	B nodes.NodeOutput[T]
}

func (MultiplyData[T]) Process

func (cn MultiplyData[T]) Process() (T, error)

type Round

type Round = nodes.Struct[int, RoundData[float64]]

============================================================================

type RoundData

type RoundData[T vector.Number] struct {
	A nodes.NodeOutput[T]
}

func (RoundData[T]) Process

func (cn RoundData[T]) Process() (int, error)

type SumData

type SumData[T vector.Number] struct {
	Values []nodes.NodeOutput[T]
}

func (SumData[T]) Process

func (cn SumData[T]) Process() (T, error)

type SumNode

type SumNode = nodes.Struct[float64, SumData[float64]]

============================================================================