shaders

Documentation

Index

• Variables
• func Compile[V, F, M any](prog Program[V, F, M])
• type CanvasItemVertexAttributes
• type Global
• type Program
• type RenderingOption2D
• type Type2D
• type Type3D

Variables

var RenderingOptions2D = xyz.AccessorFor(RenderingOption2D.Values)

Functions

func Compile

func Compile[V, F, M any](prog Program[V, F, M])

Types

type CanvasItemVertexAttributes

type CanvasItemVertexAttributes struct {
	Global

	// Local space to world space transform. World space is the coordinates you normally use in the editor.
	ModelMatrix mat4.ColumnMajor `gd:"MODEL_MATRIX"`

	// World space to canvas space transform. In canvas space the origin is the upper-left corner of the
	// screen and coordinates ranging from (0, 0) to viewport size.
	CanvasMatrix mat4.ColumnMajor `gd:"CANVAS_MATRIX"`

	// Canvas space to clip space. In clip space coordinates ranging from (-1, -1) to (1, 1).
	ScreenMatrix mat4.ColumnMajor `gd:"SCREEN_MATRIX"`

	InstanceID     int.X     `gd:"INSTANCE_ID"`     // InstanceID for instancing.
	InstanceCustom vec4.XYZW `gd:"INSTANCE_CUSTOM"` // InstanceCustom data.
	AtLightPass    bool.X    `gd:"AT_LIGHT_PASS"`   // Always false.

	// Normalized pixel size of default 2D texture. For a Sprite2D with a texture of size 64x32px,
	// TEXTURE_PIXEL_SIZE = vec2(1/64, 1/32)
	TexturePixelSize vec2.XY `gd:"TEXTURE_PIXEL_SIZE"`

	Position vec2.XY `gd:"VERTEX"`    // Vertex, in local space.
	ID       float.X `gd:"VERTEX_ID"` // The index of the current vertex in the vertex buffer.

	UV        vec2.XY   `gd:"UV"`         // Normalized texture coordinates. Range from 0 to 1.
	Color     vec4.RGBA `gd:"COLOR"`      // Color from vertex primitive.
	PointSize float.X   `gd:"POINT_SIZE"` // Point size for point drawing.
	Custom0   vec4.XYZW `gd:"CUSTOM0"`    // Custom value from vertex primitive.
	Custom1   vec4.XYZW `gd:"CUSTOM1"`    // Custom value from vertex primitive.
}

type Global

type Global struct {
	// Global time since the engine has started, in seconds. It repeats after every 3,600 seconds (which can be changed with
	// the rollover setting). It's not affected by time_scale or pausing. If you need a TIME variable that can be scaled or
	// paused, add your own global shader uniform and update it each frame.
	Time vec1.X `gd:"TIME"`
}

type Program

type Program[V, F, M any] interface {
	Super() ShaderMaterial.Instance

	Fragment(V) F
	Material(F) M
	Lighting(M) vec4.RGBA
	// contains filtered or unexported methods
}

type RenderingOption2D

type RenderingOption2D xyz.Switch[string, struct {
	BlendingModeMix            RenderingOption2D `json:"blend_mix"`             // Mix blend mode (alpha is transparency), default.
	BlendingModeAdd            RenderingOption2D `json:"blend_add"`             // Additive blend mode.
	BlendingModeSub            RenderingOption2D `json:"blend_sub"`             // Subtractive blend mode.
	BlendingModeMul            RenderingOption2D `json:"blend_mul"`             // Multiplicative blend mode.
	BlendingPremultipliedAlpha RenderingOption2D `json:"blend_premul_alpha"`    // Pre-multiplied alpha blend mode.
	BlendingDisabled           RenderingOption2D `json:"blend_disabled"`        // Disable blending, values (including alpha) are written as-is.
	Unshaded                   RenderingOption2D `json:"unshaded"`              // Result is just albedo. No lighting/shading happens in material.
	LightOnly                  RenderingOption2D `json:"light_only"`            // Only draw on light pass.
	SkipVertexTransform        RenderingOption2D `json:"skip_vertex_transform"` // VERTEX needs to be transformed manually in vertex function.
	WorldVertexCoordinates     RenderingOption2D `json:"world_vertex_coords"`   // VERTEX is modified in world coordinates instead of local.
}]

type Type2D

type Type2D struct {
	classdb.Extension[goShader, ShaderMaterial.Instance]
}

type Type3D

type Type3D struct {
	classdb.Extension[goShader, ShaderMaterial.Instance]
}