codegen

type BindTarget struct {
	// Space is the register space (0-based).
	// Spaces allow multiple resources to use the same register index.
	Space uint8

	// Register is the register index within the space.
	Register uint32

	// BindingArraySize is the array size for binding arrays.
	// If nil, the resource is not an array.
	BindingArraySize *uint32

	// DynamicStorageBufferOffsetsIndex is the index into the dynamic buffer offsets
	// constant buffer for this binding. When set, the generated HLSL adds the
	// dynamic offset to ByteAddressBuffer Load/Store addresses.
	// This is the index in the buffer at Options.DynamicStorageBufferOffsetsTargets.
	// Matches Rust naga's BindTarget::dynamic_storage_buffer_offsets_index.
	DynamicStorageBufferOffsetsIndex *uint32

	// RestrictIndexing indicates that this specific binding should have bounds
	// checking applied to array indices, even for Uniform address space.
	// Matches Rust naga's BindTarget::restrict_indexing.
	RestrictIndexing bool
}

type Error struct {
	// Kind categorizes the error.
	Kind ErrorKind

	// Message provides details about the error.
	Message string

	// Span optionally identifies the source location.
	Span *Span
}

type ErrorKind uint8

type ExternalTextureBindTarget struct {
	// Planes contains the bind targets for the 3 plane textures.
	Planes [3]BindTarget
	// Params is the bind target for the parameters cbuffer.
	Params BindTarget
}

type ExternalTextureBindingMap map[ResourceBinding]ExternalTextureBindTarget

type FeatureFlags uint32

type FragmentEntryPoint struct {
	// Module is the IR module containing the fragment entry point.
	Module *ir.Module
	// Function is the fragment entry point function.
	Function *ir.Function
}

type Io int

type OffsetsBindTarget struct {
	Space    uint8
	Register uint32
	Size     uint32
}

type Options struct {
	// ShaderModel specifies the target shader model.
	// Defaults to ShaderModel5_1 for maximum compatibility.
	ShaderModel ShaderModel

	// BindingMap maps source resource bindings to HLSL register targets.
	// If a binding is not found in the map and FakeMissingBindings is false,
	// compilation will fail with ErrMissingBinding.
	BindingMap map[ResourceBinding]BindTarget

	// SamplerHeapTargets specifies binding targets for sampler heaps.
	// Used with SM 6.6+ bindless resources.
	SamplerHeapTargets SamplerHeapBindTargets

	// SamplerBufferBindingMap maps group numbers to bind targets for
	// sampler index buffers (StructuredBuffer<uint>). When a sampler is
	// encountered, the sampler heap arrays and corresponding index buffer
	// are written. Matches Rust naga's sampler_buffer_binding_map.
	SamplerBufferBindingMap map[uint32]BindTarget

	// ExternalTextureBindingMap maps resource bindings to external texture
	// bind targets. External textures are decomposed into 3 plane textures
	// and a parameters cbuffer.
	// Matches Rust naga's Options::external_texture_binding_map.
	ExternalTextureBindingMap ExternalTextureBindingMap

	// FakeMissingBindings generates automatic bindings for resources
	// not found in BindingMap. Useful for testing or simple shaders.
	FakeMissingBindings bool

	// ZeroInitializeWorkgroupMemory emits code to zero-initialize
	// groupshared variables at the start of compute shaders.
	// Required for portability as HLSL doesn't guarantee zero initialization.
	ZeroInitializeWorkgroupMemory bool

	// RestrictIndexing adds bounds checks to array/buffer accesses.
	// Prevents undefined behavior from out-of-bounds reads/writes.
	RestrictIndexing bool

	// ForceLoopBounding adds maximum iteration limits to loops.
	// Prevents infinite loops that could hang the GPU.
	ForceLoopBounding bool

	// DynamicStorageBufferOffsetsTargets maps group indices to their bind targets
	// for dynamic storage buffer offset constant buffers. When a storage buffer
	// binding has DynamicStorageBufferOffsetsIndex set, the generated HLSL adds
	// the dynamic offset from the corresponding constant buffer to Load/Store addresses.
	// Matches Rust naga's Options::dynamic_storage_buffer_offsets_targets.
	DynamicStorageBufferOffsetsTargets map[uint32]OffsetsBindTarget

	// SpecialConstantsBinding specifies the binding for the NagaConstants
	// constant buffer. When set, the HLSL output includes a NagaConstants
	// struct with first_vertex, first_instance, and other fields. Vertex
	// and instance indices are offset by these values, and NumWorkGroups
	// is replaced with a uint3 from these values.
	// Matches Rust naga's special_constants_binding option.
	SpecialConstantsBinding *BindTarget

	// EntryPoint specifies which entry point to compile.
	// If empty, the first entry point is used.
	EntryPoint string

	// FragmentEntryPoint specifies a fragment entry point to consider when
	// generating the output interface of vertex entry points.
	// If provided, vertex outputs not consumed by this fragment shader's
	// inputs will be stripped from the vertex output struct.
	// Matches Rust naga's FragmentEntryPoint.
	FragmentEntryPoint *FragmentEntryPoint
}

type RegisterType uint8

type ResourceBinding struct {
	// Group corresponds to WGSL @group or SPIR-V DescriptorSet.
	Group uint32

	// Binding corresponds to WGSL @binding or SPIR-V Binding.
	Binding uint32
}

type SamplerHeapBindTargets struct {
	// StandardSamplers is the binding for non-comparison samplers.
	StandardSamplers BindTarget

	// ComparisonSamplers is the binding for comparison samplers.
	ComparisonSamplers BindTarget
}

type ShaderModel uint8

type Span struct {
	// Start is the byte offset of the span start.
	Start uint32

	// End is the byte offset of the span end.
	End uint32
}

type TranslationInfo struct {
	// EntryPointNames maps original entry point names to generated HLSL names.
	// HLSL requires "main" for the entry point in single-shader compilation.
	EntryPointNames map[string]string

	// UsedFeatures indicates which shader features are used.
	UsedFeatures FeatureFlags

	// RequiredShaderModel is the minimum shader model needed for this shader.
	// May be higher than the requested model if features require it.
	RequiredShaderModel ShaderModel

	// RegisterBindings maps resource names to their HLSL register bindings.
	// Format: "resourceName" -> "register(t0, space0)"
	RegisterBindings map[string]string

	// HelperFunctions lists any helper functions that were generated.
	HelperFunctions []string
}

type Writer struct {
	textutil.IndentWriter // provides Out, Indent, WriteLine, WriteIndent, PushIndent, PopIndent
	// contains filtered or unexported fields
}