msl

type AttributeMapping struct {
	ShaderLocation uint32
	Offset         uint32
	Format         VertexFormat
}

type BindExternalTextureTarget struct {
	Planes [3]uint8
	Params uint8
}

type BindSamplerTarget struct {
	// IsInline indicates the sampler is an inline (constexpr) sampler.
	IsInline bool
	// Slot is the binding slot (for resource samplers) or index into
	// Options.InlineSamplers (for inline samplers).
	Slot uint8
}

type BindTarget struct {
	// Buffer is the buffer binding slot. Nil if not bound as buffer.
	Buffer *uint8

	// Texture is the texture binding slot. Nil if not bound as texture.
	Texture *uint8

	// Sampler is the sampler binding slot. Nil if not bound as sampler.
	Sampler *BindSamplerTarget

	// ExternalTexture is the binding for external texture planes + params.
	ExternalTexture *BindExternalTextureTarget

	// Mutable indicates if this is a read-write resource.
	Mutable bool
}

type EntryPointResources struct {
	// Resources maps (group, binding) pairs to Metal bind targets.
	Resources map[ir.ResourceBinding]BindTarget

	// SizesBuffer is the buffer slot for runtime array sizes.
	// Required when using runtime-sized arrays.
	SizesBuffer *uint8

	// ImmediatesBuffer is the buffer slot for immediate data.
	// Nil if immediate data is not used.
	ImmediatesBuffer *uint8
}

type InlineSampler struct {
	Coord       SamplerCoord
	Address     [3]SamplerAddress
	BorderColor SamplerBorderColor
	MagFilter   SamplerFilter
	MinFilter   SamplerFilter
	MipFilter   *SamplerFilter // nil if not set
	CompareFunc SamplerCompareFunc
}

type Options struct {
	// LangVersion is the MSL version written in the header and the
	// highest one the output may use; the zero value is 2.1 (Rust naga's
	// default is 1.0). The backend never raises it: a feature of a newer
	// MSL is an error, a *backend.VersionError in backend.VersionMSL that
	// names the feature and the version it needs, as Rust naga refuses it.
	// Pass the device's highest supported version.
	LangVersion Version

	// PerEntryPointMap maps entry point names to their resource bindings.
	// If nil, bindings are auto-generated: the module's resource globals,
	// sorted by (group, binding), get consecutive buffer, texture and sampler
	// slots. These slots depend on which globals the module has, so
	// naga.ProcessOverrides with an EntryPoint, which removes unused globals,
	// can move them. Pass a map for stable slots (Rust naga requires one).
	// A non-nil map, empty too, must give every resource an entry point uses
	// a slot of its kind in that entry point's entry, and the sizes and
	// immediates buffers it needs; an entry point without an entry has none.
	// Otherwise Compile fails with an error wrapping
	// backend.ErrMissingBinding, unless FakeMissingBindings is set.
	PerEntryPointMap map[string]EntryPointResources

	// InlineSamplers defines constexpr samplers to be inlined into the code.
	// Referenced by BindSamplerTarget.Slot when IsInline is true.
	InlineSamplers []InlineSampler

	// BoundsCheckPolicies selects how out-of-bounds indices and image loads
	// are handled. The zero value is backend.BoundsCheckRestrict everywhere,
	// which WebGPU requires; Rust naga's default is Unchecked, and wgpu-hal's
	// Metal backend passes Restrict for Index, Buffer and ImageLoad (Unchecked
	// when its runtime bounds checks are off) and Unchecked for BindingArray.
	// Every field honors every policy, as Rust naga's MSL writer does:
	// Restrict with metal::min on the index (a runtime-sized array takes its
	// length from the sizes buffer) and on image coordinates,
	// ReadZeroSkipWrite with a ternary or an if around the access,
	// Unchecked with no code.
	BoundsCheckPolicies backend.BoundsCheckPolicies

	// ZeroInitializeWorkgroupMemory is how compute entry points zero the
	// threadgroup variables they use, as WebGPU requires. The zero value,
	// backend.ZeroInitWorkgroupPolyfill, stores zero to them from the first
	// invocation and adds a threadgroup barrier, as Rust naga's default
	// zero_initialize_workgroup_memory: true does. ZeroInitWorkgroupNone
	// leaves them as they are; ZeroInitWorkgroupNative is an error, Metal
	// has no way to ask for it.
	ZeroInitializeWorkgroupMemory backend.ZeroInitializeWorkgroupMemoryMode

	// SkipLoopBounding leaves loops as they are. By default every loop gets
	// a decrementing 64-bit counter that breaks out of it, so an infinite
	// loop, undefined behavior that can hang the device, ends. Rust naga's
	// force_loop_bounding defaults to true, and wgpu-hal passes true.
	SkipLoopBounding bool

	// FakeMissingBindings writes a placeholder attribute, [[user(fake0)]],
	// for a resource a non-nil PerEntryPointMap gives no slot, instead of
	// failing. Rust naga's fake_missing_bindings defaults to true; wgpu-hal
	// passes false, the zero value here.
	FakeMissingBindings bool

	// EntryPoint selects the one entry point to write, as Rust naga's
	// msl::PipelineOptions::entry_point; nil writes every entry point. One
	// the module does not have is an error wrapping
	// backend.ErrEntryPointNotFound.
	EntryPoint *backend.EntryPointSelector

	// AllowAndForcePointSize forces point size output for vertex shaders.
	AllowAndForcePointSize bool

	// VertexPulling, when set, makes vertex entry points read their inputs
	// from vertex buffers instead of stage_in (Rust naga's
	// vertex_pulling_transform with its vertex_buffer_mappings).
	VertexPulling *VertexPullingOptions

	// ClampFragDepth, when set, clamps the depth a fragment entry point
	// writes to the range in two f32, min then max, at byte offset
	// ClampFragDepth.Offset of the entry point's immediates buffer
	// (EntryPointResources.ImmediatesBuffer), which it then needs. WebGPU
	// clamps frag_depth to the viewport's depth range; the caller puts the
	// viewport's minDepth and maxDepth there, where Dawn's ClampFragDepth
	// transform reads them on Metal, and as the spirv option of the same
	// name reads them from push constants. An entry point with immediate
	// data of its own finds the range in the same buffer, so Offset has to
	// be past that data. Rust naga has no such option.
	ClampFragDepth *backend.ClampFragDepth

	// FixedSampleMask, when set, is the render pipeline's sample mask, which
	// a fragment entry point applies itself: it ANDs it into the sample_mask
	// it returns, or returns it as a [[sample_mask]] output when it returns
	// none. Metal has no pipeline sample mask; Dawn folds it into the shader
	// the same way. Leave it nil for a mask of all ones. Rust naga has no
	// such option.
	FixedSampleMask *uint32
}

type SamplerAddress int

type SamplerBorderColor int

type SamplerCompareFunc int

type SamplerCoord int

type SamplerFilter int

type TranslationInfo struct {
	// EntryPointNames maps original entry point names to generated MSL names.
	EntryPointNames map[string]string

	// RequiresSizesBuffer indicates if a sizes buffer is needed for
	// runtime-sized arrays.
	RequiresSizesBuffer bool
}

type Version struct {
	Major uint8
	Minor uint8
}

type VertexBufferMapping struct {
	ID         uint32
	Stride     uint32
	StepMode   VertexBufferStepMode
	Attributes []AttributeMapping
}

type VertexBufferStepMode int

type VertexFormat int

type VertexPullingOptions struct {
	// VertexBuffers describes the vertex buffers and their attributes.
	VertexBuffers []VertexBufferMapping
}