package vendor:windows/GameInput

Source

APP_LOCAL_DEVICE_ID :: distinct [32]u8

ArcadeStickButtons :: distinct bit_set[ArcadeStickButtonsFlag; i32]

ArcadeStickButtonsFlag :: enum i32 {
	Menu     = 0, 
	View     = 1, 
	Up       = 2, 
	Down     = 3, 
	Left     = 4, 
	Right    = 5, 
	Action1  = 6, 
	Action2  = 7, 
	Action3  = 8, 
	Action4  = 9, 
	Action5  = 10, 
	Action6  = 11, 
	Special1 = 12, 
	Special2 = 13, 
}

ArcadeStickInfo :: struct {
	menuButtonLabel:     Label,
	viewButtonLabel:     Label,
	stickUpLabel:        Label,
	stickDownLabel:      Label,
	stickLeftLabel:      Label,
	stickRightLabel:     Label,
	actionButton1Label:  Label,
	actionButton2Label:  Label,
	actionButton3Label:  Label,
	actionButton4Label:  Label,
	actionButton5Label:  Label,
	actionButton6Label:  Label,
	specialButton1Label: Label,
	specialButton2Label: Label,
}

ArcadeStickState :: struct {
	buttons: ArcadeStickButtons,
}

BatteryState :: struct {
	chargeRate:         f32,
	maxChargeRate:      f32,
	remainingCapacity:  f32,
	fullChargeCapacity: f32,
	status:             BatteryStatus,
}

BatteryStatus :: enum i32 {
	Unknown     = -1, 
	NotPresent  = 0, 
	Discharging = 1, 
	Idle        = 2, 
	Charging    = 3, 
}

CallbackToken :: distinct u64

ControllerAxisInfo :: struct {
	mappedInputKinds:  Kind,
	label:             Label,
	isContinuous:      bool,
	isNonlinear:       bool,
	isQuantized:       bool,
	hasRestValue:      bool,
	restValue:         f32,
	resolution:        u64,
	legacyDInputIndex: u16,
	legacyHidIndex:    u16,
	rawReportIndex:    u32,
	inputReport:       ^RawDeviceReportInfo,
	inputReportItem:   ^RawDeviceReportItemInfo,
}

ControllerButtonInfo :: struct {
	mappedInputKinds:  Kind,
	label:             Label,
	legacyDInputIndex: u16,
	legacyHidIndex:    u16,
	rawReportIndex:    u32,
	inputReport:       ^RawDeviceReportInfo,
	inputReportItem:   ^RawDeviceReportItemInfo,
}

ControllerSwitchInfo :: struct {
	mappedInputKinds:  Kind,
	label:             Label,
	positionLabels:    [9]Label,
	kind:              SwitchKind,
	legacyDInputIndex: u16,
	legacyHidIndex:    u16,
	rawReportIndex:    u32,
	inputReport:       ^RawDeviceReportInfo,
	inputReportItem:   ^RawDeviceReportItemInfo,
}

DeviceCallback :: proc "stdcall" (callbackToken: CallbackToken, ctx: rawptr, device: ^IGameInputDevice, timestamp: u64, currentState: DeviceStatus, previousState: DeviceStatus)

DeviceCapabilities :: distinct bit_set[DeviceCapabilitiesFlag; i32]

DeviceCapabilitiesFlag :: enum i32 {
	Audio           = 0, 
	PluginModule    = 1, 
	PowerOff        = 2, 
	Synchronization = 3, 
	Wireless        = 4, 
}

DeviceFamily :: enum i32 {
	Virtual   = -1, 
	Aggregate = 0, 
	XboxOne   = 1, 
	Xbox360   = 2, 
	Hid       = 3, 
	I8042     = 4, 
}

DeviceInfo :: struct {
	infoSize:                 u32,
	vendorId:                 u16,
	productId:                u16,
	revisionNumber:           u16,
	interfaceNumber:          u8,
	collectionNumber:         u8,
	usage:                    Usage,
	hardwareVersion:          Version,
	firmwareVersion:          Version,
	deviceId:                 APP_LOCAL_DEVICE_ID,
	deviceRootId:             APP_LOCAL_DEVICE_ID,
	deviceFamily:             DeviceFamily,
	capabilities:             DeviceCapabilities,
	supportedInput:           Kind,
	supportedRumbleMotors:    RumbleMotors,
	inputReportCount:         u32,
	outputReportCount:        u32,
	featureReportCount:       u32,
	controllerAxisCount:      u32,
	controllerButtonCount:    u32,
	controllerSwitchCount:    u32,
	touchPointCount:          u32,
	touchSensorCount:         u32,
	forceFeedbackMotorCount:  u32,
	hapticFeedbackMotorCount: u32,
	deviceStringCount:        u32,
	deviceDescriptorSize:     u32,
	inputReportInfo:          ^RawDeviceReportInfo,
	outputReportInfo:         ^RawDeviceReportInfo,
	featureReportInfo:        ^RawDeviceReportInfo,
	controllerAxisInfo:       ^ControllerAxisInfo,
	controllerButtonInfo:     ^ControllerButtonInfo,
	controllerSwitchInfo:     ^ControllerSwitchInfo,
	keyboardInfo:             ^KeyboardInfo,
	mouseInfo:                ^MouseInfo,
	touchSensorInfo:          ^TouchSensorInfo,
	motionInfo:               ^MotionInfo,
	arcadeStickInfo:          ^ArcadeStickInfo,
	flightStickInfo:          ^FlightStickInfo,
	gamepadInfo:              ^GamepadInfo,
	racingWheelInfo:          ^RacingWheelInfo,
	uiNavigationInfo:         ^UiNavigationInfo,
	forceFeedbackMotorInfo:   ^ForceFeedbackMotorInfo,
	hapticFeedbackMotorInfo:  ^HapticFeedbackMotorInfo,
	displayName:              ^String,
	deviceStrings:            ^String,
	deviceDescriptorData:     rawptr,
}

DeviceStatus :: distinct bit_set[DeviceStatusFlag; i32]

DeviceStatusFlag :: enum i32 {
	Connected     = 0, 
	InputEnabled  = 1, 
	OutputEnabled = 2, 
	RawIoEnabled  = 3, 
	AudioCapture  = 4, 
	AudioRender   = 5, 
	Synchronized  = 6, 
	Wireless      = 7, 
	UserIdle      = 20, 
}

EnumerationKind :: enum i32 {
	NoEnumeration       = 0, 
	AsyncEnumeration    = 1, 
	BlockingEnumeration = 2, 
}

FeedbackAxes :: distinct bit_set[FeedbackAxesFlag; i32]

FeedbackAxesFlag :: enum i32 {
	LinearX  = 0, 
	LinearY  = 1, 
	LinearZ  = 2, 
	AngularX = 3, 
	AngularY = 4, 
	AngularZ = 5, 
	Normal   = 6, 
}

FeedbackEffectState :: enum i32 {
	Stopped = 0, 
	Running = 1, 
	Paused  = 2, 
}

FlightStickButtons :: distinct bit_set[FlightStickButtonsFlag; i32]

FlightStickButtonsFlag :: enum i32 {
	None          = 0, 
	Menu          = 1, 
	View          = 2, 
	FirePrimary   = 3, 
	FireSecondary = 4, 
}

FlightStickInfo :: struct {
	menuButtonLabel:          Label,
	viewButtonLabel:          Label,
	firePrimaryButtonLabel:   Label,
	fireSecondaryButtonLabel: Label,
	hatSwitchKind:            SwitchKind,
}

FlightStickState :: struct {
	buttons:   FlightStickButtons,
	hatSwitch: SwitchPosition,
	roll:      f32,
	pitch:     f32,
	yaw:       f32,
	throttle:  f32,
}

FocusPolicy :: distinct bit_set[FocusPolicyFlag; i32]

FocusPolicyFlag :: enum i32 {
	DisableBackgroundInput         = 0, 
	ExclusiveForegroundInput       = 1, 
	DisableBackgroundGuideButton   = 2, 
	ExclusiveForegroundGuideButton = 3, 
	DisableBackgroundShareButton   = 4, 
	ExclusiveForegroundShareButton = 5, 
}

ForceFeedbackConditionParams :: struct {
	magnitude:            ForceFeedbackMagnitude,
	positiveCoefficient:  f32,
	negativeCoefficient:  f32,
	maxPositiveMagnitude: f32,
	maxNegativeMagnitude: f32,
	deadZone:             f32,
	bias:                 f32,
}

ForceFeedbackConstantParams :: struct {
	envelope:  ForceFeedbackEnvelope,
	magnitude: ForceFeedbackMagnitude,
}

ForceFeedbackEffectKind :: enum i32 {
	Constant         = 0, 
	Ramp             = 1, 
	SineWave         = 2, 
	SquareWave       = 3, 
	TriangleWave     = 4, 
	SawtoothUpWave   = 5, 
	SawtoothDownWave = 6, 
	Spring           = 7, 
	Friction         = 8, 
	Damper           = 9, 
	Inertia          = 10, 
}

ForceFeedbackEnvelope :: struct {
	attackDuration:  u64,
	sustainDuration: u64,
	releaseDuration: u64,
	attackGain:      f32,
	sustainGain:     f32,
	releaseGain:     f32,
	playCount:       u32,
	repeatDelay:     u64,
}

ForceFeedbackMagnitude :: struct {
	linearX:  f32,
	linearY:  f32,
	linearZ:  f32,
	angularX: f32,
	angularY: f32,
	angularZ: f32,
	normal:   f32,
}

ForceFeedbackMotorInfo :: struct {
	supportedAxes:                     FeedbackAxes,
	location:                          Location,
	locationId:                        u32,
	maxSimultaneousEffects:            u32,
	isConstantEffectSupported:         bool,
	isRampEffectSupported:             bool,
	isSineWaveEffectSupported:         bool,
	isSquareWaveEffectSupported:       bool,
	isTriangleWaveEffectSupported:     bool,
	isSawtoothUpWaveEffectSupported:   bool,
	isSawtoothDownWaveEffectSupported: bool,
	isSpringEffectSupported:           bool,
	isFrictionEffectSupported:         bool,
	isDamperEffectSupported:           bool,
	isInertiaEffectSupported:          bool,
}

ForceFeedbackParams :: struct {
	kind: ForceFeedbackEffectKind,
	using _: struct #raw_union {
		constant:         ForceFeedbackConstantParams,
		ramp:             ForceFeedbackRampParams,
		sineWave:         ForceFeedbackPeriodicParams,
		squareWave:       ForceFeedbackPeriodicParams,
		triangleWave:     ForceFeedbackPeriodicParams,
		sawtoothUpWave:   ForceFeedbackPeriodicParams,
		sawtoothDownWave: ForceFeedbackPeriodicParams,
		spring:           ForceFeedbackConditionParams,
		friction:         ForceFeedbackConditionParams,
		damper:           ForceFeedbackConditionParams,
		inertia:          ForceFeedbackConditionParams,
	},
}

ForceFeedbackPeriodicParams :: struct {
	envelope:  ForceFeedbackEnvelope,
	magnitude: ForceFeedbackMagnitude,
	frequency: f32,
	phase:     f32,
	bias:      f32,
}

ForceFeedbackRampParams :: struct {
	envelope:       ForceFeedbackEnvelope,
	startMagnitude: ForceFeedbackMagnitude,
	endMagnitude:   ForceFeedbackMagnitude,
}

GamepadButtons :: distinct bit_set[GamepadButtonsFlag; i32]

GamepadButtonsFlag :: enum i32 {
	Menu            = 0, 
	View            = 1, 
	A               = 2, 
	B               = 3, 
	X               = 4, 
	Y               = 5, 
	DPadUp          = 6, 
	DPadDown        = 7, 
	DPadLeft        = 8, 
	DPadRight       = 9, 
	LeftShoulder    = 10, 
	RightShoulder   = 11, 
	LeftThumbstick  = 12, 
	RightThumbstick = 13, 
}

GamepadInfo :: struct {
	menuButtonLabel:            Label,
	viewButtonLabel:            Label,
	aButtonLabel:               Label,
	bButtonLabel:               Label,
	xButtonLabel:               Label,
	yButtonLabel:               Label,
	dpadUpLabel:                Label,
	dpadDownLabel:              Label,
	dpadLeftLabel:              Label,
	dpadRightLabel:             Label,
	leftShoulderButtonLabel:    Label,
	rightShoulderButtonLabel:   Label,
	leftThumbstickButtonLabel:  Label,
	rightThumbstickButtonLabel: Label,
}

GamepadState :: struct {
	buttons:          GamepadButtons,
	leftTrigger:      f32,
	rightTrigger:     f32,
	leftThumbstickX:  f32,
	leftThumbstickY:  f32,
	rightThumbstickX: f32,
	rightThumbstickY: f32,
}

GuideButtonCallback :: proc "stdcall" (callbackToken: CallbackToken, ctx: rawptr, device: ^IGameInputDevice, timestamp: u64, isPressed: bool)

HANDLE :: sys_windows.HANDLE

HRESULT :: sys_windows.HRESULT

HapticFeedbackMotorInfo :: struct {
	mappedRumbleMotor: RumbleMotors,
	location:          Location,
	locationId:        u32,
	waveformCount:     u32,
	waveformInfo:      [^]HapticWaveformInfo `fmt:"v,waveformCount"`,
}

HapticFeedbackParams :: struct {
	waveformIndex: u32,
	duration:      u64,
	intensity:     f32,
	playCount:     u32,
	repeatDelay:   u64,
}

HapticWaveformInfo :: struct {
	usage:                  Usage,
	isDurationSupported:    bool,
	isIntensitySupported:   bool,
	isRepeatSupported:      bool,
	isRepeatDelaySupported: bool,
	defaultDuration:        u64,
}

IGameInput :: struct #raw_union {
	iunknown:          sys_windows.IUnknown,
	using igameinput_vtable: ^IGameInput_VTable,
}

IGameInputDevice :: struct #raw_union {
	iunknown:                sys_windows.IUnknown,
	using igameinputdevice_vtable: ^IGameInputDevice_Vtable,
}

IGameInputDevice_Vtable :: struct {
	using iunknown_vtable:           sys_windows.IUnknown_VTable,
	GetDeviceInfo:                   proc "stdcall" (this: ^IGameInputDevice) -> ^DeviceInfo,
	GetDeviceStatus:                 proc "stdcall" (this: ^IGameInputDevice) -> DeviceStatus,
	GetBatteryState:                 proc "stdcall" (this: ^IGameInputDevice, state: ^BatteryState),
	CreateForceFeedbackEffect:       proc "stdcall" (this: ^IGameInputDevice, motorIndex: u32, params: ^ForceFeedbackParams, effect: ^^IGameInputForceFeedbackEffect) -> sys_windows.HRESULT,
	IsForceFeedbackMotorPoweredOn:   proc "stdcall" (this: ^IGameInputDevice, motorIndex: u32) -> bool,
	SetForceFeedbackMotorGain:       proc "stdcall" (this: ^IGameInputDevice, motorIndex: u32, masterGain: f32),
	SetHapticMotorState:             proc "stdcall" (this: ^IGameInputDevice, motorIndex: u32, params: ^HapticFeedbackParams) -> sys_windows.HRESULT,
	SetRumbleState:                  proc "stdcall" (this: ^IGameInputDevice, params: ^RumbleParams),
	SetInputSynchronizationState:    proc "stdcall" (this: ^IGameInputDevice, enabled: bool),
	SendInputSynchronizationHint:    proc "stdcall" (this: ^IGameInputDevice),
	PowerOff:                        proc "stdcall" (this: ^IGameInputDevice),
	CreateRawDeviceReport:           proc "stdcall" (this: ^IGameInputDevice, reportId: u32, reportKind: RawDeviceReportKind, report: ^^IGameInputRawDeviceReport) -> sys_windows.HRESULT,
	GetRawDeviceFeature:             proc "stdcall" (this: ^IGameInputDevice, reportId: u32, report: ^^IGameInputRawDeviceReport) -> sys_windows.HRESULT,
	SetRawDeviceFeature:             proc "stdcall" (this: ^IGameInputDevice, report: ^IGameInputRawDeviceReport) -> sys_windows.HRESULT,
	SendRawDeviceOutput:             proc "stdcall" (this: ^IGameInputDevice, report: ^IGameInputRawDeviceReport) -> sys_windows.HRESULT,
	SendRawDeviceOutputWithResponse: proc "stdcall" (this: ^IGameInputDevice, requestReport: ^IGameInputRawDeviceReport, responseReport: ^^IGameInputRawDeviceReport) -> sys_windows.HRESULT,
	ExecuteRawDeviceIoControl:       proc "stdcall" (this: ^IGameInputDevice, controlCode: u32, inputBufferSize: uint, inputBuffer: rawptr, outputBufferSize: uint, outputBuffer: rawptr, outputSize: ^uint) -> sys_windows.HRESULT,
	AcquireExclusiveRawDeviceAccess: proc "stdcall" (this: ^IGameInputDevice, timeoutInMicroseconds: u64) -> bool,
	ReleaseExclusiveRawDeviceAccess: proc "stdcall" (this: ^IGameInputDevice),
}

IGameInputDispatcher :: struct #raw_union {
	iunknown:                    sys_windows.IUnknown,
	using igameinputdispatcher_vtable: ^IGameInputDispatcher_Vtable,
}

IGameInputDispatcher_Vtable :: struct {
	using iunknown_vtable: sys_windows.IUnknown_VTable,
	Dispatch:        proc "stdcall" (this: ^IGameInputDispatcher, quotaInMicroseconds: u64) -> bool,
	OpenWaitHandle:  proc "stdcall" (this: ^IGameInputDispatcher, waitHandle: ^sys_windows.HANDLE) -> sys_windows.HRESULT,
}

IGameInputForceFeedbackEffect :: struct #raw_union {
	iunknown:                             sys_windows.IUnknown,
	using igameinputforcefeedbackeffect_vtable: ^IGameInputForceFeedbackEffect_Vtable,
}

IGameInputForceFeedbackEffect_Vtable :: struct {
	using iunknown_vtable: sys_windows.IUnknown_VTable,
	GetDevice:       proc "stdcall" (this: ^IGameInputForceFeedbackEffect, device: ^^IGameInputDevice),
	GetMotorIndex:   proc "stdcall" (this: ^IGameInputForceFeedbackEffect) -> u32,
	GetGain:         proc "stdcall" (this: ^IGameInputForceFeedbackEffect) -> f32,
	SetGain:         proc "stdcall" (this: ^IGameInputForceFeedbackEffect, gain: f32),
	GetParams:       proc "stdcall" (this: ^IGameInputForceFeedbackEffect, params: ^ForceFeedbackParams),
	SetParams:       proc "stdcall" (this: ^IGameInputForceFeedbackEffect, params: ^ForceFeedbackParams) -> bool,
	GetState:        proc "stdcall" (this: ^IGameInputForceFeedbackEffect) -> FeedbackEffectState,
	SetState:        proc "stdcall" (this: ^IGameInputForceFeedbackEffect, state: FeedbackEffectState),
}

IGameInputRawDeviceReport :: struct #raw_union {
	iunknown:                         sys_windows.IUnknown,
	using igameinputrawdevicereport_vtable: ^IGameInputRawDeviceReport_Vtable,
}

IGameInputRawDeviceReport_Vtable :: struct {
	using iunknown_vtable: sys_windows.IUnknown_VTable,
	GetDevice:       proc "stdcall" (this: ^IGameInputRawDeviceReport, device: ^^IGameInputDevice),
	GetReportInfo:   proc "stdcall" (this: ^IGameInputRawDeviceReport) -> ^RawDeviceReportInfo,
	GetRawDataSize:  proc "stdcall" (this: ^IGameInputRawDeviceReport) -> uint,
	GetRawData:      proc "stdcall" (this: ^IGameInputRawDeviceReport, bufferSize: uint, buffer: rawptr) -> uint,
	SetRawData:      proc "stdcall" (this: ^IGameInputRawDeviceReport, bufferSize: uint, buffer: rawptr) -> bool,
	GetItemValue:    proc "stdcall" (this: ^IGameInputRawDeviceReport, itemIndex: u32, value: ^u64) -> bool,
	SetItemValue:    proc "stdcall" (this: ^IGameInputRawDeviceReport, itemIndex: u32, value: u64) -> bool,
	ResetItemValue:  proc "stdcall" (this: ^IGameInputRawDeviceReport, itemIndex: u32) -> bool,
	ResetAllItems:   proc "stdcall" (this: ^IGameInputRawDeviceReport) -> bool,
}

IGameInputReading :: struct #raw_union {
	iunknown:                 sys_windows.IUnknown,
	using igameinputreading_vtable: ^IGameInputReading_VTable,
}

IGameInputReading_VTable :: struct {
	using iunknown_vtable:    sys_windows.IUnknown_VTable,
	GetInputKind:             proc "stdcall" (this: ^IGameInputReading) -> Kind,
	GetSequenceNumber:        proc "stdcall" (this: ^IGameInputReading) -> u64,
	GetTimestamp:             proc "stdcall" (this: ^IGameInputReading) -> u64,
	GetDevice:                proc "stdcall" (this: ^IGameInputReading, device: ^^IGameInputDevice),
	GetRawReport:             proc "stdcall" (this: ^IGameInputReading, report: ^^IGameInputRawDeviceReport) -> bool,
	GetControllerAxisCount:   proc "stdcall" (this: ^IGameInputReading) -> u32,
	GetControllerAxisState:   proc "stdcall" (this: ^IGameInputReading, stateArrayCount: u32, stateArray: [^]f32) -> u32,
	GetControllerButtonCount: proc "stdcall" (this: ^IGameInputReading) -> u32,
	GetControllerButtonState: proc "stdcall" (this: ^IGameInputReading, stateArrayCount: u32, stateArray: [^]bool) -> u32,
	GetControllerSwitchCount: proc "stdcall" (this: ^IGameInputReading) -> u32,
	GetControllerSwitchState: proc "stdcall" (this: ^IGameInputReading, stateArrayCount: u32, stateArray: [^]SwitchPosition) -> u32,
	GetKeyCount:              proc "stdcall" (this: ^IGameInputReading) -> u32,
	GetKeyState:              proc "stdcall" (this: ^IGameInputReading, stateArrayCount: u32, stateArray: [^]KeyState) -> u32,
	GetMouseState:            proc "stdcall" (this: ^IGameInputReading, state: ^MouseState) -> bool,
	GetTouchCount:            proc "stdcall" (this: ^IGameInputReading) -> u32,
	GetTouchState:            proc "stdcall" (this: ^IGameInputReading, stateArrayCount: u32, stateArray: [^]TouchState) -> u32,
	GetMotionState:           proc "stdcall" (this: ^IGameInputReading, state: ^MotionState) -> bool,
	GetArcadeStickState:      proc "stdcall" (this: ^IGameInputReading, state: ^ArcadeStickState) -> bool,
	GetFlightStickState:      proc "stdcall" (this: ^IGameInputReading, state: ^FlightStickState) -> bool,
	GetGamepadState:          proc "stdcall" (this: ^IGameInputReading, state: ^GamepadState) -> bool,
	GetRacingWheelState:      proc "stdcall" (this: ^IGameInputReading, state: ^RacingWheelState) -> bool,
	GetUiNavigationState:     proc "stdcall" (this: ^IGameInputReading, state: ^UiNavigationState) -> bool,
}

IGameInput_VTable :: struct {
	using iunknown_vtable:          sys_windows.IUnknown_VTable,
	GetCurrentTimestamp:            proc "stdcall" (this: ^IGameInput) -> u64,
	GetCurrentReading:              proc "stdcall" (this: ^IGameInput, inputKind: Kind, device: ^IGameInputDevice, reading: ^^IGameInputReading) -> sys_windows.HRESULT,
	GetNextReading:                 proc "stdcall" (this: ^IGameInput, referenceReading: ^IGameInputReading, inputKind: Kind, device: ^IGameInputDevice, reading: ^^IGameInputReading) -> sys_windows.HRESULT,
	GetPreviousReading:             proc "stdcall" (this: ^IGameInput, referenceReading: ^IGameInputReading, inputKind: Kind, device: ^IGameInputDevice, reading: ^^IGameInputReading) -> sys_windows.HRESULT,
	GetTemporalReading:             proc "stdcall" (this: ^IGameInput, timestamp: u64, device: ^IGameInputDevice, reading: ^^IGameInputReading) -> sys_windows.HRESULT,
	RegisterReadingCallback:        proc "stdcall" (this: ^IGameInput, device: ^IGameInputDevice, inputKind: Kind, analogThreshold: f32, ctx: rawptr, callbackFunc: ReadingCallback, callbackToken: ^CallbackToken) -> sys_windows.HRESULT,
	RegisterDeviceCallback:         proc "stdcall" (this: ^IGameInput, device: ^IGameInputDevice, inputKind: Kind, statusFilter: DeviceStatus, enumerationKind: EnumerationKind, ctx: rawptr, callbackFunc: DeviceCallback, callbackToken: ^CallbackToken) -> sys_windows.HRESULT,
	RegisterSystemButtonCallback:   proc "stdcall" (this: ^IGameInput, device: ^IGameInputDevice, buttonFilter: SystemButtons, ctx: rawptr, callbackFunc: SystemButtonCallback, callbackToken: ^CallbackToken) -> sys_windows.HRESULT,
	RegisterKeyboardLayoutCallback: proc "stdcall" (this: ^IGameInput, device: ^IGameInputDevice, ctx: rawptr, callbackFunc: KeyboardLayoutCallback, callbackToken: ^CallbackToken) -> sys_windows.HRESULT,
	StopCallback:                   proc "stdcall" (this: ^IGameInput, callbackToken: CallbackToken),
	UnregisterCallback:             proc "stdcall" (this: ^IGameInput, callbackToken: CallbackToken, timeoutInMicroseconds: u64) -> bool,
	CreateDispatcher:               proc "stdcall" (this: ^IGameInput, dispatcher: ^^IGameInputDispatcher) -> sys_windows.HRESULT,
	CreateAggregateDevice:          proc "stdcall" (this: ^IGameInput, kind: Kind, device: ^^IGameInputDevice) -> sys_windows.HRESULT,
	FindDeviceFromId:               proc "stdcall" (this: ^IGameInput, value: ^APP_LOCAL_DEVICE_ID, device: ^^IGameInputDevice) -> sys_windows.HRESULT,
	FindDeviceFromObject:           proc "stdcall" (this: ^IGameInput, value: ^sys_windows.IUnknown, device: ^^IGameInputDevice) -> sys_windows.HRESULT,
	FindDeviceFromPlatformHandle:   proc "stdcall" (this: ^IGameInput, value: sys_windows.HANDLE, device: ^^IGameInputDevice) -> sys_windows.HRESULT,
	FindDeviceFromPlatformString:   proc "stdcall" (this: ^IGameInput, value: [^]u16, device: ^^IGameInputDevice) -> sys_windows.HRESULT,
	EnableOemDeviceSupport:         proc "stdcall" (this: ^IGameInput, vendorId: u16, productId: u16, interfaceNumber: u8, collectionNumber: u8) -> sys_windows.HRESULT,
	SetFocusPolicy:                 proc "stdcall" (this: ^IGameInput, policy: FocusPolicy),
}

IID :: sys_windows.GUID

IUnknown :: sys_windows.IUnknown

IUnknown_VTable :: sys_windows.IUnknown_VTable

KeyState :: struct {
	scanCode:   u32,
	codePoint:  u32,
	virtualKey: u8,
	isDeadKey:  bool,
}

KeyboardInfo :: struct {
	kind:                KeyboardKind,
	layout:              u32,
	keyCount:            u32,
	functionKeyCount:    u32,
	maxSimultaneousKeys: u32,
	platformType:        u32,
	platformSubtype:     u32,
	nativeLanguage:      ^String,
}

KeyboardKind :: enum i32 {
	UnknownKeyboard = -1, 
	AnsiKeyboard    = 0, 
	IsoKeyboard     = 1, 
	KsKeyboard      = 2, 
	AbntKeyboard    = 3, 
	JisKeyboard     = 4, 
}

KeyboardLayoutCallback :: proc "stdcall" (callbackToken: CallbackToken, ctx: rawptr, device: ^IGameInputDevice, timestamp: u64, currentState: DeviceStatus, previousState: DeviceStatus)

Kind :: distinct bit_set[KindFlag; i32]

KindFlag :: enum i32 {
	RawDeviceReport  = 0, 
	ControllerAxis   = 1, 
	ControllerButton = 2, 
	ControllerSwitch = 3, 
	Keyboard         = 4, 
	Mouse            = 5, 
	Touch            = 8, 
	Motion           = 12, 
	ArcadeStick      = 16, 
	FlightStick      = 17, 
	Gamepad          = 18, 
	RacingWheel      = 19, 
	UiNavigation     = 20, 
}

Label :: enum i32 {
	Unknown                  = -1, 
	None                     = 0, 
	XboxGuide                = 1, 
	XboxBack                 = 2, 
	XboxStart                = 3, 
	XboxMenu                 = 4, 
	XboxView                 = 5, 
	XboxA                    = 7, 
	XboxB                    = 8, 
	XboxX                    = 9, 
	XboxY                    = 10, 
	XboxDPadUp               = 11, 
	XboxDPadDown             = 12, 
	XboxDPadLeft             = 13, 
	XboxDPadRight            = 14, 
	XboxLeftShoulder         = 15, 
	XboxLeftTrigger          = 16, 
	XboxLeftStickButton      = 17, 
	XboxRightShoulder        = 18, 
	XboxRightTrigger         = 19, 
	XboxRightStickButton     = 20, 
	XboxPaddle1              = 21, 
	XboxPaddle2              = 22, 
	XboxPaddle3              = 23, 
	XboxPaddle4              = 24, 
	LetterA                  = 25, 
	LetterB                  = 26, 
	LetterC                  = 27, 
	LetterD                  = 28, 
	LetterE                  = 29, 
	LetterF                  = 30, 
	LetterG                  = 31, 
	LetterH                  = 32, 
	LetterI                  = 33, 
	LetterJ                  = 34, 
	LetterK                  = 35, 
	LetterL                  = 36, 
	LetterM                  = 37, 
	LetterN                  = 38, 
	LetterO                  = 39, 
	LetterP                  = 40, 
	LetterQ                  = 41, 
	LetterR                  = 42, 
	LetterS                  = 43, 
	LetterT                  = 44, 
	LetterU                  = 45, 
	LetterV                  = 46, 
	LetterW                  = 47, 
	LetterX                  = 48, 
	LetterY                  = 49, 
	LetterZ                  = 50, 
	Number0                  = 51, 
	Number1                  = 52, 
	Number2                  = 53, 
	Number3                  = 54, 
	Number4                  = 55, 
	Number5                  = 56, 
	Number6                  = 57, 
	Number7                  = 58, 
	Number8                  = 59, 
	Number9                  = 60, 
	ArrowUp                  = 61, 
	ArrowUpRight             = 62, 
	ArrowRight               = 63, 
	ArrowDownRight           = 64, 
	ArrowDown                = 65, 
	ArrowDownLLeft           = 66, 
	ArrowLeft                = 67, 
	ArrowUpLeft              = 68, 
	ArrowUpDown              = 69, 
	ArrowLeftRight           = 70, 
	ArrowUpDownLeftRight     = 71, 
	ArrowClockwise           = 72, 
	ArrowCounterClockwise    = 73, 
	ArrowReturn              = 74, 
	IconBranding             = 75, 
	IconHome                 = 76, 
	IconMenu                 = 77, 
	IconCross                = 78, 
	IconCircle               = 79, 
	IconSquare               = 80, 
	IconTriangle             = 81, 
	IconStar                 = 82, 
	IconDPadUp               = 83, 
	IconDPadDown             = 84, 
	IconDPadLeft             = 85, 
	IconDPadRight            = 86, 
	IconDialClockwise        = 87, 
	IconDialCounterClockwise = 88, 
	IconSliderLeftRight      = 89, 
	IconSliderUpDown         = 90, 
	IconWheelUpDown          = 91, 
	IconPlus                 = 92, 
	IconMinus                = 93, 
	IconSuspension           = 94, 
	Home                     = 95, 
	Guide                    = 96, 
	Mode                     = 97, 
	Select                   = 98, 
	Menu                     = 99, 
	View                     = 100, 
	Back                     = 101, 
	Start                    = 102, 
	Options                  = 103, 
	Share                    = 104, 
	Up                       = 105, 
	Down                     = 106, 
	Left                     = 107, 
	Right                    = 108, 
	LB                       = 109, 
	LT                       = 110, 
	LSB                      = 111, 
	L1                       = 112, 
	L2                       = 113, 
	L3                       = 114, 
	RB                       = 115, 
	RT                       = 116, 
	RSB                      = 117, 
	R1                       = 118, 
	R2                       = 119, 
	R3                       = 120, 
	P1                       = 121, 
	P2                       = 122, 
	P3                       = 123, 
	P4                       = 124, 
}

Location :: enum i32 {
	Unknown  = -1, 
	Chassis  = 0, 
	Display  = 1, 
	Axis     = 2, 
	Button   = 3, 
	Switch   = 4, 
	Key      = 5, 
	TouchPad = 6, 
}

MotionAccuracy :: enum i32 {
	AccuracyUnknown = -1, 
	Unavailable     = 0, 
	Unreliable      = 1, 
	Approximate     = 2, 
	Accurate        = 3, 
}

MotionInfo :: struct {
	maxAcceleration:          f32,
	maxAngularVelocity:       f32,
	maxMagneticFieldStrength: f32,
}

MotionState :: struct {
	accelerationX:         f32,
	accelerationY:         f32,
	accelerationZ:         f32,
	angularVelocityX:      f32,
	angularVelocityY:      f32,
	angularVelocityZ:      f32,
	magneticFieldX:        f32,
	magneticFieldY:        f32,
	magneticFieldZ:        f32,
	orientationW:          f32,
	orientationX:          f32,
	orientationY:          f32,
	orientationZ:          f32,
	accelerometerAccuracy: MotionAccuracy,
	gyroscopeAccuracy:     MotionAccuracy,
	magnetometerAccuracy:  MotionAccuracy,
	orientationAccuracy:   MotionAccuracy,
}

MouseButtons :: distinct bit_set[MouseButtonsFlag; i32]

MouseButtonsFlag :: enum i32 {
	LeftButton     = 0, 
	RightButton    = 1, 
	MiddleButton   = 2, 
	Button4        = 3, 
	Button5        = 4, 
	WheelTiltLeft  = 5, 
	WheelTiltRight = 6, 
}

MouseInfo :: struct {
	supportedButtons: MouseButtons,
	sampleRate:       u32,
	sensorDpi:        u32,
	hasWheelX:        bool,
	hasWheelY:        bool,
}

MouseState :: struct {
	buttons:   MouseButtons,
	positionX: i64,
	positionY: i64,
	wheelX:    i64,
	wheelY:    i64,
}

RacingWheelButtons :: distinct bit_set[RacingWheelButtonsFlag; i32]

RacingWheelButtonsFlag :: enum i32 {
	Menu         = 0, 
	View         = 1, 
	PreviousGear = 2, 
	NextGear     = 3, 
	DpadUp       = 4, 
	DpadDown     = 5, 
	DpadLeft     = 6, 
	DpadRight    = 7, 
}

RacingWheelInfo :: struct {
	menuButtonLabel:         Label,
	viewButtonLabel:         Label,
	previousGearButtonLabel: Label,
	nextGearButtonLabel:     Label,
	dpadUpLabel:             Label,
	dpadDownLabel:           Label,
	dpadLeftLabel:           Label,
	dpadRightLabel:          Label,
	hasClutch:               bool,
	hasHandbrake:            bool,
	hasPatternShifter:       bool,
	minPatternShifterGear:   i32,
	maxPatternShifterGear:   i32,
	maxWheelAngle:           f32,
}

RacingWheelState :: struct {
	buttons:            RacingWheelButtons,
	patternShifterGear: i32,
	wheel:              f32,
	throttle:           f32,
	brake:              f32,
	clutch:             f32,
	handbrake:          f32,
}

RawDeviceItemCollectionInfo :: struct {
	kind:            RawDeviceItemCollectionKind,
	childCount:      u32,
	siblingCount:    u32,
	usageCount:      u32,
	usages:          [^]Usage `fmt:v,usageCount`,
	parent:          ^RawDeviceItemCollectionInfo,
	firstSibling:    ^RawDeviceItemCollectionInfo,
	previousSibling: ^RawDeviceItemCollectionInfo,
	nextSibling:     ^RawDeviceItemCollectionInfo,
	lastSibling:     ^RawDeviceItemCollectionInfo,
	firstChild:      ^RawDeviceItemCollectionInfo,
	lastChild:       ^RawDeviceItemCollectionInfo,
}

RawDeviceItemCollectionKind :: enum i32 {
	UnknownItemCollection       = -1, 
	PhysicalItemCollection      = 0, 
	ApplicationItemCollection   = 1, 
	LogicalItemCollection       = 2, 
	ReportItemCollection        = 3, 
	NamedArrayItemCollection    = 4, 
	UsageSwitchItemCollection   = 5, 
	UsageModifierItemCollection = 6, 
}

RawDevicePhysicalUnitKind :: enum i32 {
	Unknown             = -1, 
	None                = 0, 
	Time                = 1, 
	Frequency           = 2, 
	Length              = 3, 
	Velocity            = 4, 
	Acceleration        = 5, 
	Mass                = 6, 
	Momentum            = 7, 
	Force               = 8, 
	Pressure            = 9, 
	Angle               = 10, 
	AngularVelocity     = 11, 
	AngularAcceleration = 12, 
	AngularMass         = 13, 
	AngularMomentum     = 14, 
	AngularTorque       = 15, 
	ElectricCurrent     = 16, 
	ElectricCharge      = 17, 
	ElectricPotential   = 18, 
	Energy              = 19, 
	Power               = 20, 
	Temperature         = 21, 
	LuminousIntensity   = 22, 
	LuminousFlux        = 23, 
	Illuminance         = 24, 
}

RawDeviceReportInfo :: struct {
	kind:      RawDeviceReportKind,
	id:        u32,
	size:      u32,
	itemCount: u32,
	items:     [^]RawDeviceReportItemInfo `fmt:"v,itemCount"`,
}

RawDeviceReportItemFlag :: enum i32 {
	ConstantItem   = 0, 
	ArrayItem      = 1, 
	RelativeItem   = 2, 
	WraparoundItem = 3, 
	NonlinearItem  = 4, 
	StableItem     = 5, 
	NullableItem   = 6, 
	VolatileItem   = 7, 
	BufferedItem   = 8, 
}

RawDeviceReportItemFlags :: distinct bit_set[RawDeviceReportItemFlag; i32]

RawDeviceReportItemInfo :: struct {
	bitOffset:                u32,
	bitSize:                  u32,
	logicalMin:               i64,
	logicalMax:               i64,
	physicalMin:              f64,
	physicalMax:              f64,
	physicalUnits:            RawDevicePhysicalUnitKind,
	rawPhysicalUnits:         u32,
	rawPhysicalUnitsExponent: i32,
	flags:                    RawDeviceReportItemFlags,
	usageCount:               u32,
	usages:                   [^]Usage `fmt:"v,usageCount"`,
	collection:               ^RawDeviceItemCollectionInfo,
	itemString:               ^String,
}

RawDeviceReportKind :: enum i32 {
	InputReport   = 0, 
	OutputReport  = 1, 
	FeatureReport = 2, 
}

ReadingCallback :: proc "stdcall" (callbackToken: CallbackToken, ctx: rawptr, reading: ^IGameInputReading, hasOverrunOccured: bool)

RumbleMotors :: distinct bit_set[RumbleMotorsFlag; i32]

RumbleMotorsFlag :: enum i32 {
	LowFrequency  = 0, 
	HighFrequency = 1, 
	LeftTrigger   = 2, 
	RightTrigger  = 3, 
}

RumbleParams :: struct {
	lowFrequency:  f32,
	highFrequency: f32,
	leftTrigger:   f32,
	rightTrigger:  f32,
}

String :: struct {
	sizeInBytes:    u32,
	codePointCount: u32,
	data:           [^]u8,
}

SwitchKind :: enum i32 {
	UnknownSwitchKind = -1, 
	TwoWaySwitch      = 0, 
	FourWaySwitch     = 1, 
	EightWaySwitch    = 2, 
}

SwitchPosition :: enum i32 {
	Center    = 0, 
	Up        = 1, 
	UpRight   = 2, 
	Right     = 3, 
	DownRight = 4, 
	Down      = 5, 
	DownLeft  = 6, 
	Left      = 7, 
	UpLeft    = 8, 
}

SystemButtonCallback :: proc "stdcall" (callbackToken: CallbackToken, ctx: rawptr, device: ^IGameInputDevice, timestamp: u64, currentState: DeviceStatus, previousState: DeviceStatus)

SystemButtons :: distinct bit_set[SystemButtonsFlag; i32]

SystemButtonsFlag :: enum i32 {
	Guide = 0, 
	Share = 1, 
}

TouchSensorInfo :: struct {
	mappedInputKinds: Kind,
	label:            Label,
	location:         Location,
	locationId:       u32,
	resolutionX:      u64,
	resolutionY:      u64,
	shape:            TouchShape,
	aspectRatio:      f32,
	orientation:      f32,
	physicalWidth:    f32,
	physicalHeight:   f32,
	maxPressure:      f32,
	maxProximity:     f32,
	maxTouchPoints:   u32,
}

TouchShape :: enum i32 {
	Unknown            = -1, 
	Point              = 0, 
	Shape1DLinear      = 1, 
	Shape1DRadial      = 2, 
	Shape1DIrregular   = 3, 
	Shape2DRectangular = 4, 
	Shape2DElliptical  = 5, 
	Shape2DIrregular   = 6, 
}

TouchState :: struct {
	touchId:           u64,
	sensorIndex:       u32,
	positionX:         f32,
	positionY:         f32,
	pressure:          f32,
	proximity:         f32,
	contactRectTop:    f32,
	contactRectLeft:   f32,
	contactRectRight:  f32,
	contactRectBottom: f32,
}

UiNavigationButtons :: distinct bit_set[UiNavigationButtonsFlag; i32]

UiNavigationButtonsFlag :: enum i32 {
	Menu        = 0, 
	View        = 1, 
	Accept      = 2, 
	Cancel      = 3, 
	Up          = 4, 
	Down        = 5, 
	Left        = 6, 
	Right       = 7, 
	Context1    = 8, 
	Context2    = 9, 
	Context3    = 10, 
	Context4    = 11, 
	PageUp      = 12, 
	PageDown    = 13, 
	PageLeft    = 14, 
	PageRight   = 15, 
	ScrollUp    = 16, 
	ScrollDown  = 17, 
	ScrollLeft  = 18, 
	ScrollRight = 19, 
}

UiNavigationInfo :: struct {
	menuButtonLabel:        Label,
	viewButtonLabel:        Label,
	acceptButtonLabel:      Label,
	cancelButtonLabel:      Label,
	upButtonLabel:          Label,
	downButtonLabel:        Label,
	leftButtonLabel:        Label,
	rightButtonLabel:       Label,
	contextButton1Label:    Label,
	contextButton2Label:    Label,
	contextButton3Label:    Label,
	contextButton4Label:    Label,
	pageUpButtonLabel:      Label,
	pageDownButtonLabel:    Label,
	pageLeftButtonLabel:    Label,
	pageRightButtonLabel:   Label,
	scrollUpButtonLabel:    Label,
	scrollDownButtonLabel:  Label,
	scrollLeftButtonLabel:  Label,
	scrollRightButtonLabel: Label,
	guideButtonLabel:       Label,
}

UiNavigationState :: struct {
	buttons: UiNavigationButtons,
}

Usage :: struct {
	page: u16,
	id:   u16,
}

Version :: struct {
	major:    u16,
	minor:    u16,
	build:    u16,
	revision: u16,
}

CURRENT_CALLBACK_TOKEN_VALUE :: CallbackToken(0xFFFFFFFFFFFFFFFF)

DEVICE_DISCONNECTED :: HRESULT(-0x7C75FFFF)

DEVICE_NOT_FOUND :: HRESULT(-0x7C75FFFE)

IGameInputDevice_UUID_STRING: string : "31DD86FB-4C1B-408A-868F-439B3CD47125"

IGameInputDispatcher_UUID_STRING: string : "415EED2E-98CB-42C2-8F28-B94601074E31"

IGameInputForceFeedbackEffect_UUID_STRING: string : "51BDA05E-F742-45D9-B085-9444AE48381D"

IGameInputRawDeviceReport_UUID_STRING: string : "61F08CF1-1FFC-40CA-A2B8-E1AB8BC5B6DC"

IGameInputReading_UUID_STRING: string : "2156947A-E1FA-4DE0-A30B-D812931DBD8D"

IGameInput_UUID_STRING: string : "11BE2A7E-4254-445A-9C09-FFC40F006918"

INSUFFICIENT_FORCE_FEEDBACK_RESOURCES :: HRESULT(-0x7C75FFFA)

INVALID_CALLBACK_TOKEN_VALUE :: CallbackToken(0x0000000000000000)

Kind_Controller: Kind : {.ControllerAxis, .ControllerButton, .ControllerSwitch}

READING_NOT_FOUND :: HRESULT(-0x7C75FFFD)

REFERENCE_READING_TOO_OLD :: HRESULT(-0x7C75FFFC)

TIMESTAMP_OUT_OF_RANGE :: HRESULT(-0x7C75FFFB)

IGameInputDevice_UUID: ^sys_windows.GUID = …

IGameInputDispatcher_UUID: ^sys_windows.GUID = …

IGameInputForceFeedbackEffect_UUID: ^sys_windows.GUID = …

IGameInputRawDeviceReport_UUID: ^sys_windows.GUID = …

IGameInputReading_UUID: ^sys_windows.GUID = …

IGameInput_UUID: ^sys_windows.GUID = …

Create :: proc "stdcall" (gameInput: ^^IGameInput) -> sys_windows.HRESULT ---