gpu

package
v0.0.0-...-01268d7 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Mar 3, 2025 License: MIT Imports: 1 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func NewQuadExpression

func NewQuadExpression[Q Quad](expr Expression) Q

func Set

func Set(ptr Pointer, val Evaluator)

Types

type AnyBool

type AnyBool interface {
	~bool | ~Bool
}

type AnyFloat

type AnyFloat interface {
	~float32 | ~float64 | ~Float
}

type AnyInt

type AnyInt interface {
	~int8 | ~int16 | ~int32 | ~int64 | ~int | ~Int
}

type AnyUint

type AnyUint interface {
	~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uint | ~uintptr | ~Uint
}

type Bool

type Bool = struct {
	X bool
	// contains filtered or unexported fields
}

func NewBool

func NewBool[T AnyBool](x T) Bool

func NewBoolExpression

func NewBoolExpression(e Expression) Bool

type Evaluator

type Evaluator interface {
	// contains filtered or unexported methods
}

func Evaluate

func Evaluate(e Evaluator) Evaluator

type Expression

type Expression struct {
	// contains filtered or unexported fields
}

func Fn

func Fn(name string, args ...Evaluator) Expression

func New

func New(e Evaluator) Expression

func Op

func Op(a Evaluator, op string, b Evaluator) Expression

func Out

func Out(t string) Expression

type Float

type Float = struct {
	X float64
	// contains filtered or unexported fields
}

func NewFloat

func NewFloat[T AnyFloat](x T) Float

func NewFloatExpression

func NewFloatExpression(e Expression) Float

type FunctionCall

type FunctionCall struct {
	Name string
	Args []Evaluator
}

type Identifier

type Identifier string

type Int

type Int = struct {
	X int
	// contains filtered or unexported fields
}

func NewInt

func NewInt[T AnyInt](x T) Int

func NewIntExpression

func NewIntExpression(e Expression) Int

type Mat2

type Mat2 = struct {
	Columns [2][2]Float
	// contains filtered or unexported fields
}

func NewMat2

func NewMat2[C00, C01, C10, C11 AnyFloat](c00 C00, c01 C01, c10 C10, c11 C11) Mat2

func NewMat2Expression

func NewMat2Expression(e Expression) Mat2

type Mat3

type Mat3 = struct {
	Columns [3][3]Float
	// contains filtered or unexported fields
}

func NewMat3

func NewMat3[C00, C01, C02, C10, C11, C12, C20, C21, C22 AnyFloat](c00 C00, c01 C01, c02 C02, c10 C10, c11 C11, c12 C12, c20 C20, c21 C21, c22 C22) Mat3

func NewMat3Expression

func NewMat3Expression(e Expression) Mat3

type Mat4

type Mat4 = struct {
	Columns [4][4]Float
	// contains filtered or unexported fields
}

func NewMat4

func NewMat4[C00, C01, C02, C03, C10, C11, C12, C13, C20, C21, C22, C23, C30, C31, C32, C33 AnyFloat](c00 C00, c01 C01, c02 C02, c03 C03, c10 C10, c11 C11, c12 C12, c13 C13, c20 C20, c21 C21, c22 C22, c23 C23, c30 C30, c31 C31, c32 C32, c33 C33) Mat4

func NewMat4Expression

func NewMat4Expression(e Expression) Mat4

type Operation

type Operation struct {
	A  Evaluator
	B  Evaluator
	Op string
}

type Output

type Output struct {
	Index *int
	Type  string
}

type Pointer

type Pointer interface {
	// contains filtered or unexported methods
}

type Quad

type Quad interface {
	~Vec4 | ~Vec4i | ~Vec4u | ~RGBA
}

type RGB

type RGB = struct {
	R, G, B Float
	// contains filtered or unexported fields
}

func NewRGB

func NewRGB[R, G, B AnyFloat](r R, g G, b B) RGB

func NewRGBExpression

func NewRGBExpression(e Expression) RGB

type RGBA

type RGBA = struct {
	R, G, B, A Float
	// contains filtered or unexported fields
}

func NewRGBA

func NewRGBA[R, G, B, A AnyFloat](r R, g G, b B, a A) RGBA

func NewRGBAExpression

func NewRGBAExpression(e Expression) RGBA

type Ternary

type Ternary struct {
	If Evaluator
	A  Evaluator
	B  Evaluator
}

type Uint

type Uint = struct {
	X uint
	// contains filtered or unexported fields
}

func NewUint

func NewUint[T AnyUint](x T) Uint

func NewUintExpression

func NewUintExpression(e Expression) Uint

type Vec2

type Vec2 = struct {
	X, Y Float
	// contains filtered or unexported fields
}

func NewVec2

func NewVec2[X, Y AnyFloat](x X, y Y) Vec2

func NewVec2Expression

func NewVec2Expression(e Expression) Vec2

type Vec2b

type Vec2b = struct {
	X, Y Bool
	// contains filtered or unexported fields
}

func NewVec2b

func NewVec2b[X, Y AnyBool](x X, y Y) Vec2b

func NewVec2bExpression

func NewVec2bExpression(e Expression) Vec2b

type Vec2i

type Vec2i = struct {
	X, Y Int
	// contains filtered or unexported fields
}

func NewVec2i

func NewVec2i[X, Y AnyInt](x X, y Y) Vec2i

func NewVec2iExpression

func NewVec2iExpression(e Expression) Vec2i

type Vec2u

type Vec2u = struct {
	X, Y Uint
	// contains filtered or unexported fields
}

func NewVec2u

func NewVec2u[X, Y AnyUint](x X, y Y) Vec2u

func NewVec2uExpression

func NewVec2uExpression(e Expression) Vec2u

type Vec3

type Vec3 = struct {
	X, Y, Z Float
	// contains filtered or unexported fields
}

func NewVec3

func NewVec3[X, Y, Z AnyFloat](x X, y Y, z Z) Vec3

func NewVec3Expression

func NewVec3Expression(e Expression) Vec3

type Vec3b

type Vec3b = struct {
	X, Y, Z Bool
	// contains filtered or unexported fields
}

func NewVec3b

func NewVec3b[X, Y, Z AnyBool](x X, y Y, z Z) Vec3b

func NewVec3bExpression

func NewVec3bExpression(e Expression) Vec3b

type Vec3i

type Vec3i = struct {
	X, Y, Z Int
	// contains filtered or unexported fields
}

func NewVec3i

func NewVec3i[X, Y, Z AnyInt](x X, y Y, z Z) Vec3i

func NewVec3iExpression

func NewVec3iExpression(e Expression) Vec3i

type Vec3u

type Vec3u = struct {
	X, Y, Z Uint
	// contains filtered or unexported fields
}

func NewVec3u

func NewVec3u[X, Y, Z AnyUint](x X, y Y, z Z) Vec3u

func NewVec3uExpression

func NewVec3uExpression(e Expression) Vec3u

type Vec4

type Vec4 = struct {
	X, Y, Z, W Float
	// contains filtered or unexported fields
}

func NewVec4

func NewVec4[X, Y, Z, W AnyFloat](x X, y Y, z Z, w W) Vec4

func NewVec4Expression

func NewVec4Expression(e Expression) Vec4

type Vec4b

type Vec4b = struct {
	X, Y, Z, W Bool
	// contains filtered or unexported fields
}

func NewVec4b

func NewVec4b[X, Y, Z, W AnyBool](x X, y Y, z Z, w W) Vec4b

func NewVec4bExpression

func NewVec4bExpression(e Expression) Vec4b

type Vec4i

type Vec4i = struct {
	X, Y, Z, W Int
	// contains filtered or unexported fields
}

func NewVec4i

func NewVec4i[X, Y, Z, W AnyInt](x X, y Y, z Z, w W) Vec4i

func NewVec4iExpression

func NewVec4iExpression(e Expression) Vec4i

type Vec4u

type Vec4u = struct {
	X, Y, Z, W Uint
	// contains filtered or unexported fields
}

func NewVec4u

func NewVec4u[X, Y, Z, W AnyUint](x X, y Y, z Z, w W) Vec4u

func NewVec4uExpression

func NewVec4uExpression(e Expression) Vec4u

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL