GameInputForceFeedbackConditionParams

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct GameInputForceFeedbackMagnitude
{
    public float linearX;
    public float linearY;
    public float linearZ;
    public float angularX;
    public float angularY;
    public float angularZ;
    public float normal;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct GameInputForceFeedbackConditionParams
{
    public GameInputForceFeedbackMagnitude magnitude;
    public float positiveCoefficient;
    public float negativeCoefficient;
    public float maxPositiveMagnitude;
    public float maxNegativeMagnitude;
    public float deadZone;
    public float bias;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure GameInputForceFeedbackMagnitude
    Public linearX As Single
    Public linearY As Single
    Public linearZ As Single
    Public angularX As Single
    Public angularY As Single
    Public angularZ As Single
    Public normal As Single
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure GameInputForceFeedbackConditionParams
    Public magnitude As GameInputForceFeedbackMagnitude
    Public positiveCoefficient As Single
    Public negativeCoefficient As Single
    Public maxPositiveMagnitude As Single
    Public maxNegativeMagnitude As Single
    Public deadZone As Single
    Public bias As Single
End Structure

import ctypes
from ctypes import wintypes

class GameInputForceFeedbackMagnitude(ctypes.Structure):
    _fields_ = [
        ("linearX", ctypes.c_float),
        ("linearY", ctypes.c_float),
        ("linearZ", ctypes.c_float),
        ("angularX", ctypes.c_float),
        ("angularY", ctypes.c_float),
        ("angularZ", ctypes.c_float),
        ("normal", ctypes.c_float),
    ]

class GameInputForceFeedbackConditionParams(ctypes.Structure):
    _fields_ = [
        ("magnitude", GameInputForceFeedbackMagnitude),
        ("positiveCoefficient", ctypes.c_float),
        ("negativeCoefficient", ctypes.c_float),
        ("maxPositiveMagnitude", ctypes.c_float),
        ("maxNegativeMagnitude", ctypes.c_float),
        ("deadZone", ctypes.c_float),
        ("bias", ctypes.c_float),
    ]

#[repr(C)]
pub struct GameInputForceFeedbackMagnitude {
    pub linearX: f32,
    pub linearY: f32,
    pub linearZ: f32,
    pub angularX: f32,
    pub angularY: f32,
    pub angularZ: f32,
    pub normal: f32,
}

#[repr(C)]
pub struct GameInputForceFeedbackConditionParams {
    pub magnitude: GameInputForceFeedbackMagnitude,
    pub positiveCoefficient: f32,
    pub negativeCoefficient: f32,
    pub maxPositiveMagnitude: f32,
    pub maxNegativeMagnitude: f32,
    pub deadZone: f32,
    pub bias: f32,
}

import "golang.org/x/sys/windows"

type GameInputForceFeedbackMagnitude struct {
	linearX float32
	linearY float32
	linearZ float32
	angularX float32
	angularY float32
	angularZ float32
	normal float32
}

type GameInputForceFeedbackConditionParams struct {
	magnitude GameInputForceFeedbackMagnitude
	positiveCoefficient float32
	negativeCoefficient float32
	maxPositiveMagnitude float32
	maxNegativeMagnitude float32
	deadZone float32
	bias float32
}

type
  GameInputForceFeedbackMagnitude = record
    linearX: Single;
    linearY: Single;
    linearZ: Single;
    angularX: Single;
    angularY: Single;
    angularZ: Single;
    normal: Single;
  end;

  GameInputForceFeedbackConditionParams = record
    magnitude: GameInputForceFeedbackMagnitude;
    positiveCoefficient: Single;
    negativeCoefficient: Single;
    maxPositiveMagnitude: Single;
    maxNegativeMagnitude: Single;
    deadZone: Single;
    bias: Single;
  end;

const GameInputForceFeedbackMagnitude = extern struct {
    linearX: f32,
    linearY: f32,
    linearZ: f32,
    angularX: f32,
    angularY: f32,
    angularZ: f32,
    normal: f32,
};

const GameInputForceFeedbackConditionParams = extern struct {
    magnitude: GameInputForceFeedbackMagnitude,
    positiveCoefficient: f32,
    negativeCoefficient: f32,
    maxPositiveMagnitude: f32,
    maxNegativeMagnitude: f32,
    deadZone: f32,
    bias: f32,
};

type
  GameInputForceFeedbackMagnitude {.bycopy.} = object
    linearX: float32
    linearY: float32
    linearZ: float32
    angularX: float32
    angularY: float32
    angularZ: float32
    normal: float32

  GameInputForceFeedbackConditionParams {.bycopy.} = object
    magnitude: GameInputForceFeedbackMagnitude
    positiveCoefficient: float32
    negativeCoefficient: float32
    maxPositiveMagnitude: float32
    maxNegativeMagnitude: float32
    deadZone: float32
    bias: float32

struct GameInputForceFeedbackMagnitude
{
    float linearX;
    float linearY;
    float linearZ;
    float angularX;
    float angularY;
    float angularZ;
    float normal;
}

struct GameInputForceFeedbackConditionParams
{
    GameInputForceFeedbackMagnitude magnitude;
    float positiveCoefficient;
    float negativeCoefficient;
    float maxPositiveMagnitude;
    float maxNegativeMagnitude;
    float deadZone;
    float bias;
}