vrclient: fix up const types

37 files changed, 125 insertions, 129 deletions

diff --git a/vrclient_x64/gen_wrapper.py b/vrclient_x64/gen_wrapper.py
index 98052336..282e3764 100755
--- a/vrclient_x64/gen_wrapper.py
+++ b/vrclient_x64/gen_wrapper.py
@@ -388,10 +388,12 @@ def handle_method(cfile, classname, winclassname, cppname, method, cpp, cpp_h, e
                     typename = "win" + do_wrap[0] + "_" + display_sdkver(sdkver) + " **"
                 elif real_type.get_canonical().kind == clang.cindex.TypeKind.RECORD and \
                         struct_needs_conversion(real_type.get_canonical()):
-                    do_win_to_lin = (strip_ns(real_type.spelling), param.spelling)
-                    do_lin_to_win = (strip_ns(real_type.spelling), param.spelling)
+                    do_win_to_lin = (strip_const(strip_ns(real_type.spelling)), param.spelling)
+                    if not real_type.is_const_qualified():
+                        do_lin_to_win = (strip_const(strip_ns(real_type.spelling)), param.spelling)
                     #preserve pointers
-                    typename = typename.replace(real_type.spelling, "win%s_%s" % (strip_ns(real_type.spelling), display_sdkver(sdkver)))
+                    print("typename: \"" + typename + "\" real_type.spelling: \"" + real_type.spelling + "\"")
+                    typename = typename.replace(strip_ns(real_type.spelling), "win%s_%s" % (strip_ns(real_type.spelling), display_sdkver(sdkver)))
 
         if param.spelling == "":
             cfile.write(", %s _%s" % (typename, unnamed))
@@ -425,7 +427,10 @@ def handle_method(cfile, classname, winclassname, cppname, method, cpp, cpp_h, e
             cfile.write("    %s path_result;\n" % method.result_type.spelling)
 
     if do_lin_to_win or do_win_to_lin:
-        cpp.write("    %s lin;\n" % do_lin_to_win[0])
+        if do_lin_to_win:
+            cpp.write("    %s lin;\n" % do_lin_to_win[0])
+        else:
+            cpp.write("    %s lin;\n" % do_win_to_lin[0])
         cpp.write("    %s _ret;\n" % method.result_type.spelling)
 
     if do_wrap:
@@ -541,6 +546,7 @@ def handle_method(cfile, classname, winclassname, cppname, method, cpp, cpp_h, e
     if do_lin_to_win:
         cpp.write("    if(%s)\n" % do_lin_to_win[1])
         cpp.write("        struct_%s_%s_lin_to_win(&lin, %s);\n" % (strip_ns(do_lin_to_win[0]), display_sdkver(sdkver), do_lin_to_win[1]))
+    if do_lin_to_win or do_win_to_lin:
         cpp.write("    return _ret;\n")
     if do_wrap:
         cpp.write("    if(_ret == 0)\n")
diff --git a/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_005.cpp b/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_005.cpp
index cc4e2c9c..c00a4558 100644
--- a/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_005.cpp
+++ b/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_005.cpp
@@ -79,7 +79,7 @@ void cppIVRCompositor_IVRCompositor_005_ClearOverlay(void *linux_side)
     ((IVRCompositor*)linux_side)->ClearOverlay();
 }
 
-bool cppIVRCompositor_IVRCompositor_005_GetFrameTiming(void *linux_side, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo)
+bool cppIVRCompositor_IVRCompositor_005_GetFrameTiming(void *linux_side, winCompositor_FrameTiming_091 * pTiming, uint32_t unFramesAgo)
 {
     Compositor_FrameTiming lin;
     bool _ret;
diff --git a/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_005.h b/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_005.h
index c345946d..f1514b1a 100644
--- a/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_005.h
+++ b/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_005.h
@@ -15,7 +15,7 @@ extern void cppIVRCompositor_IVRCompositor_005_SetOverlay(void *, void *, Compos
 extern void cppIVRCompositor_IVRCompositor_005_SetOverlayRaw(void *, void *, uint32_t, uint32_t, uint32_t, Compositor_OverlaySettings *);
 extern void cppIVRCompositor_IVRCompositor_005_SetOverlayFromFile(void *, const char *, Compositor_OverlaySettings *);
 extern void cppIVRCompositor_IVRCompositor_005_ClearOverlay(void *);
-extern bool cppIVRCompositor_IVRCompositor_005_GetFrameTiming(void *, Compositor_FrameTiming *, uint32_t);
+extern bool cppIVRCompositor_IVRCompositor_005_GetFrameTiming(void *, winCompositor_FrameTiming_091 *, uint32_t);
 extern void cppIVRCompositor_IVRCompositor_005_FadeToColor(void *, float, float, float, float, float, bool);
 extern void cppIVRCompositor_IVRCompositor_005_FadeGrid(void *, float, bool);
 extern void cppIVRCompositor_IVRCompositor_005_CompositorBringToFront(void *);
diff --git a/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_006.cpp b/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_006.cpp
index 480dd820..fbaf2796 100644
--- a/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_006.cpp
+++ b/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_006.cpp
@@ -54,7 +54,7 @@ void cppIVRCompositor_IVRCompositor_006_ClearLastSubmittedFrame(void *linux_side
     ((IVRCompositor*)linux_side)->ClearLastSubmittedFrame();
 }
 
-bool cppIVRCompositor_IVRCompositor_006_GetFrameTiming(void *linux_side, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo)
+bool cppIVRCompositor_IVRCompositor_006_GetFrameTiming(void *linux_side, winCompositor_FrameTiming_092 * pTiming, uint32_t unFramesAgo)
 {
     Compositor_FrameTiming lin;
     bool _ret;
diff --git a/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_006.h b/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_006.h
index f8ed46d9..43d80e33 100644
--- a/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_006.h
+++ b/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_006.h
@@ -10,7 +10,7 @@ extern void cppIVRCompositor_IVRCompositor_006_SetGraphicsDevice(void *, Composi
 extern VRCompositorError cppIVRCompositor_IVRCompositor_006_WaitGetPoses(void *, TrackedDevicePose_t *, uint32_t, TrackedDevicePose_t *, uint32_t);
 extern VRCompositorError cppIVRCompositor_IVRCompositor_006_Submit(void *, Hmd_Eye, void *, VRTextureBounds_t *);
 extern void cppIVRCompositor_IVRCompositor_006_ClearLastSubmittedFrame(void *);
-extern bool cppIVRCompositor_IVRCompositor_006_GetFrameTiming(void *, Compositor_FrameTiming *, uint32_t);
+extern bool cppIVRCompositor_IVRCompositor_006_GetFrameTiming(void *, winCompositor_FrameTiming_092 *, uint32_t);
 extern void cppIVRCompositor_IVRCompositor_006_FadeToColor(void *, float, float, float, float, float, bool);
 extern void cppIVRCompositor_IVRCompositor_006_FadeGrid(void *, float, bool);
 extern void cppIVRCompositor_IVRCompositor_006_CompositorBringToFront(void *);
diff --git a/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_007.cpp b/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_007.cpp
index 6fb6579a..2843e49f 100644
--- a/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_007.cpp
+++ b/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_007.cpp
@@ -49,7 +49,7 @@ void cppIVRCompositor_IVRCompositor_007_ClearLastSubmittedFrame(void *linux_side
     ((IVRCompositor*)linux_side)->ClearLastSubmittedFrame();
 }
 
-bool cppIVRCompositor_IVRCompositor_007_GetFrameTiming(void *linux_side, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo)
+bool cppIVRCompositor_IVRCompositor_007_GetFrameTiming(void *linux_side, winCompositor_FrameTiming_098 * pTiming, uint32_t unFramesAgo)
 {
     Compositor_FrameTiming lin;
     bool _ret;
diff --git a/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_007.h b/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_007.h
index adfa3dae..49ab1da4 100644
--- a/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_007.h
+++ b/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_007.h
@@ -9,7 +9,7 @@ extern float cppIVRCompositor_IVRCompositor_007_GetGamma(void *);
 extern VRCompositorError cppIVRCompositor_IVRCompositor_007_WaitGetPoses(void *, TrackedDevicePose_t *, uint32_t, TrackedDevicePose_t *, uint32_t);
 extern VRCompositorError cppIVRCompositor_IVRCompositor_007_Submit(void *, Hmd_Eye, GraphicsAPIConvention, void *, VRTextureBounds_t *);
 extern void cppIVRCompositor_IVRCompositor_007_ClearLastSubmittedFrame(void *);
-extern bool cppIVRCompositor_IVRCompositor_007_GetFrameTiming(void *, Compositor_FrameTiming *, uint32_t);
+extern bool cppIVRCompositor_IVRCompositor_007_GetFrameTiming(void *, winCompositor_FrameTiming_098 *, uint32_t);
 extern void cppIVRCompositor_IVRCompositor_007_FadeToColor(void *, float, float, float, float, float, bool);
 extern void cppIVRCompositor_IVRCompositor_007_FadeGrid(void *, float, bool);
 extern void cppIVRCompositor_IVRCompositor_007_CompositorBringToFront(void *);
diff --git a/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_008.cpp b/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_008.cpp
index 47a34054..1ab4a081 100644
--- a/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_008.cpp
+++ b/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_008.cpp
@@ -49,7 +49,7 @@ void cppIVRCompositor_IVRCompositor_008_ClearLastSubmittedFrame(void *linux_side
     ((IVRCompositor*)linux_side)->ClearLastSubmittedFrame();
 }
 
-bool cppIVRCompositor_IVRCompositor_008_GetFrameTiming(void *linux_side, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo)
+bool cppIVRCompositor_IVRCompositor_008_GetFrameTiming(void *linux_side, winCompositor_FrameTiming_0910 * pTiming, uint32_t unFramesAgo)
 {
     Compositor_FrameTiming lin;
     bool _ret;
diff --git a/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_008.h b/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_008.h
index b23e106f..e00750d2 100644
--- a/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_008.h
+++ b/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_008.h
@@ -9,7 +9,7 @@ extern float cppIVRCompositor_IVRCompositor_008_GetGamma(void *);
 extern VRCompositorError cppIVRCompositor_IVRCompositor_008_WaitGetPoses(void *, TrackedDevicePose_t *, uint32_t, TrackedDevicePose_t *, uint32_t);
 extern VRCompositorError cppIVRCompositor_IVRCompositor_008_Submit(void *, Hmd_Eye, GraphicsAPIConvention, void *, VRTextureBounds_t *, VRSubmitFlags_t);
 extern void cppIVRCompositor_IVRCompositor_008_ClearLastSubmittedFrame(void *);
-extern bool cppIVRCompositor_IVRCompositor_008_GetFrameTiming(void *, Compositor_FrameTiming *, uint32_t);
+extern bool cppIVRCompositor_IVRCompositor_008_GetFrameTiming(void *, winCompositor_FrameTiming_0910 *, uint32_t);
 extern void cppIVRCompositor_IVRCompositor_008_FadeToColor(void *, float, float, float, float, float, bool);
 extern void cppIVRCompositor_IVRCompositor_008_FadeGrid(void *, float, bool);
 extern void cppIVRCompositor_IVRCompositor_008_SetSkyboxOverride(void *, GraphicsAPIConvention, void *, void *, void *, void *, void *, void *);
diff --git a/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_009.cpp b/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_009.cpp
index 6dbd3713..0d5b41ec 100644
--- a/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_009.cpp
+++ b/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_009.cpp
@@ -44,7 +44,7 @@ void cppIVRCompositor_IVRCompositor_009_PostPresentHandoff(void *linux_side)
     ((IVRCompositor*)linux_side)->PostPresentHandoff();
 }
 
-bool cppIVRCompositor_IVRCompositor_009_GetFrameTiming(void *linux_side, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo)
+bool cppIVRCompositor_IVRCompositor_009_GetFrameTiming(void *linux_side, winCompositor_FrameTiming_0913 * pTiming, uint32_t unFramesAgo)
 {
     Compositor_FrameTiming lin;
     bool _ret;
diff --git a/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_009.h b/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_009.h
index 677c854a..7b1bf541 100644
--- a/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_009.h
+++ b/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_009.h
@@ -8,7 +8,7 @@ extern EVRCompositorError cppIVRCompositor_IVRCompositor_009_GetLastPoses(void *
 extern EVRCompositorError cppIVRCompositor_IVRCompositor_009_Submit(void *, EVREye, Texture_t *, VRTextureBounds_t *, EVRSubmitFlags);
 extern void cppIVRCompositor_IVRCompositor_009_ClearLastSubmittedFrame(void *);
 extern void cppIVRCompositor_IVRCompositor_009_PostPresentHandoff(void *);
-extern bool cppIVRCompositor_IVRCompositor_009_GetFrameTiming(void *, Compositor_FrameTiming *, uint32_t);
+extern bool cppIVRCompositor_IVRCompositor_009_GetFrameTiming(void *, winCompositor_FrameTiming_0913 *, uint32_t);
 extern float cppIVRCompositor_IVRCompositor_009_GetFrameTimeRemaining(void *);
 extern void cppIVRCompositor_IVRCompositor_009_FadeToColor(void *, float, float, float, float, float, bool);
 extern void cppIVRCompositor_IVRCompositor_009_FadeGrid(void *, float, bool);
diff --git a/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_010.cpp b/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_010.cpp
index 2e4edf7e..d0d8bd56 100644
--- a/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_010.cpp
+++ b/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_010.cpp
@@ -44,7 +44,7 @@ void cppIVRCompositor_IVRCompositor_010_PostPresentHandoff(void *linux_side)
     ((IVRCompositor*)linux_side)->PostPresentHandoff();
 }
 
-bool cppIVRCompositor_IVRCompositor_010_GetFrameTiming(void *linux_side, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo)
+bool cppIVRCompositor_IVRCompositor_010_GetFrameTiming(void *linux_side, winCompositor_FrameTiming_0914 * pTiming, uint32_t unFramesAgo)
 {
     Compositor_FrameTiming lin;
     bool _ret;
diff --git a/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_010.h b/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_010.h
index 58348748..7e0d9d2f 100644
--- a/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_010.h
+++ b/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_010.h
@@ -8,7 +8,7 @@ extern EVRCompositorError cppIVRCompositor_IVRCompositor_010_GetLastPoses(void *
 extern EVRCompositorError cppIVRCompositor_IVRCompositor_010_Submit(void *, EVREye, Texture_t *, VRTextureBounds_t *, EVRSubmitFlags);
 extern void cppIVRCompositor_IVRCompositor_010_ClearLastSubmittedFrame(void *);
 extern void cppIVRCompositor_IVRCompositor_010_PostPresentHandoff(void *);
-extern bool cppIVRCompositor_IVRCompositor_010_GetFrameTiming(void *, Compositor_FrameTiming *, uint32_t);
+extern bool cppIVRCompositor_IVRCompositor_010_GetFrameTiming(void *, winCompositor_FrameTiming_0914 *, uint32_t);
 extern float cppIVRCompositor_IVRCompositor_010_GetFrameTimeRemaining(void *);
 extern void cppIVRCompositor_IVRCompositor_010_FadeToColor(void *, float, float, float, float, float, bool);
 extern void cppIVRCompositor_IVRCompositor_010_FadeGrid(void *, float, bool);
diff --git a/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_016.cpp b/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_016.cpp
index 6c0ffbc0..24e437f3 100644
--- a/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_016.cpp
+++ b/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_016.cpp
@@ -49,7 +49,7 @@ void cppIVRCompositor_IVRCompositor_016_PostPresentHandoff(void *linux_side)
     ((IVRCompositor*)linux_side)->PostPresentHandoff();
 }
 
-bool cppIVRCompositor_IVRCompositor_016_GetFrameTiming(void *linux_side, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo)
+bool cppIVRCompositor_IVRCompositor_016_GetFrameTiming(void *linux_side, winCompositor_FrameTiming_103 * pTiming, uint32_t unFramesAgo)
 {
     Compositor_FrameTiming lin;
     bool _ret;
diff --git a/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_016.h b/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_016.h
index 4710ab13..d8a2572e 100644
--- a/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_016.h
+++ b/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_016.h
@@ -9,7 +9,7 @@ extern EVRCompositorError cppIVRCompositor_IVRCompositor_016_GetLastPoseForTrack
 extern EVRCompositorError cppIVRCompositor_IVRCompositor_016_Submit(void *, EVREye, Texture_t *, VRTextureBounds_t *, EVRSubmitFlags);
 extern void cppIVRCompositor_IVRCompositor_016_ClearLastSubmittedFrame(void *);
 extern void cppIVRCompositor_IVRCompositor_016_PostPresentHandoff(void *);
-extern bool cppIVRCompositor_IVRCompositor_016_GetFrameTiming(void *, Compositor_FrameTiming *, uint32_t);
+extern bool cppIVRCompositor_IVRCompositor_016_GetFrameTiming(void *, winCompositor_FrameTiming_103 *, uint32_t);
 extern float cppIVRCompositor_IVRCompositor_016_GetFrameTimeRemaining(void *);
 extern void cppIVRCompositor_IVRCompositor_016_GetCumulativeStats(void *, Compositor_CumulativeStats *, uint32_t);
 extern void cppIVRCompositor_IVRCompositor_016_FadeToColor(void *, float, float, float, float, float, bool);
diff --git a/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_003.cpp b/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_003.cpp
index e8649342..f798d914 100644
--- a/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_003.cpp
+++ b/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_003.cpp
@@ -34,7 +34,7 @@ vr::EVRInputError cppIVRInput_IVRInput_003_UpdateActionState(void *linux_side, V
     return ((IVRInput*)linux_side)->UpdateActionState((vr::VRActiveActionSet_t *)pSets, (uint32_t)unSizeOfVRSelectedActionSet_t, (uint32_t)unSetCount);
 }
 
-vr::EVRInputError cppIVRInput_IVRInput_003_GetDigitalActionData(void *linux_side, VRActionHandle_t action, InputDigitalActionData_t * pActionData, uint32_t unActionDataSize)
+vr::EVRInputError cppIVRInput_IVRInput_003_GetDigitalActionData(void *linux_side, VRActionHandle_t action, winInputDigitalActionData_t_1015 * pActionData, uint32_t unActionDataSize)
 {
     InputDigitalActionData_t lin;
     vr::EVRInputError _ret;
@@ -46,7 +46,7 @@ vr::EVRInputError cppIVRInput_IVRInput_003_GetDigitalActionData(void *linux_side
     return _ret;
 }
 
-vr::EVRInputError cppIVRInput_IVRInput_003_GetAnalogActionData(void *linux_side, VRActionHandle_t action, InputAnalogActionData_t * pActionData, uint32_t unActionDataSize)
+vr::EVRInputError cppIVRInput_IVRInput_003_GetAnalogActionData(void *linux_side, VRActionHandle_t action, winInputAnalogActionData_t_1015 * pActionData, uint32_t unActionDataSize)
 {
     InputAnalogActionData_t lin;
     vr::EVRInputError _ret;
@@ -58,7 +58,7 @@ vr::EVRInputError cppIVRInput_IVRInput_003_GetAnalogActionData(void *linux_side,
     return _ret;
 }
 
-vr::EVRInputError cppIVRInput_IVRInput_003_GetPoseActionData(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, InputPoseActionData_t * pActionData, uint32_t unActionDataSize)
+vr::EVRInputError cppIVRInput_IVRInput_003_GetPoseActionData(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, winInputPoseActionData_t_1015 * pActionData, uint32_t unActionDataSize)
 {
     InputPoseActionData_t lin;
     vr::EVRInputError _ret;
@@ -70,7 +70,7 @@ vr::EVRInputError cppIVRInput_IVRInput_003_GetPoseActionData(void *linux_side, V
     return _ret;
 }
 
-vr::EVRInputError cppIVRInput_IVRInput_003_GetSkeletalActionData(void *linux_side, VRActionHandle_t action, EVRSkeletalTransformSpace eBoneParent, float fPredictedSecondsFromNow, InputSkeletonActionData_t * pActionData, uint32_t unActionDataSize, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount)
+vr::EVRInputError cppIVRInput_IVRInput_003_GetSkeletalActionData(void *linux_side, VRActionHandle_t action, EVRSkeletalTransformSpace eBoneParent, float fPredictedSecondsFromNow, winInputSkeletonActionData_t_1015 * pActionData, uint32_t unActionDataSize, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount)
 {
     InputSkeletonActionData_t lin;
     vr::EVRInputError _ret;
diff --git a/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_003.h b/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_003.h
index 1d2a3ca4..a89723bf 100644
--- a/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_003.h
+++ b/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_003.h
@@ -6,10 +6,10 @@ extern EVRInputError cppIVRInput_IVRInput_003_GetActionSetHandle(void *, const c
 extern EVRInputError cppIVRInput_IVRInput_003_GetActionHandle(void *, const char *, VRActionHandle_t *);
 extern EVRInputError cppIVRInput_IVRInput_003_GetInputSourceHandle(void *, const char *, VRInputValueHandle_t *);
 extern EVRInputError cppIVRInput_IVRInput_003_UpdateActionState(void *, VRActiveActionSet_t *, uint32_t, uint32_t);
-extern EVRInputError cppIVRInput_IVRInput_003_GetDigitalActionData(void *, VRActionHandle_t, InputDigitalActionData_t *, uint32_t);
-extern EVRInputError cppIVRInput_IVRInput_003_GetAnalogActionData(void *, VRActionHandle_t, InputAnalogActionData_t *, uint32_t);
-extern EVRInputError cppIVRInput_IVRInput_003_GetPoseActionData(void *, VRActionHandle_t, ETrackingUniverseOrigin, float, InputPoseActionData_t *, uint32_t);
-extern EVRInputError cppIVRInput_IVRInput_003_GetSkeletalActionData(void *, VRActionHandle_t, EVRSkeletalTransformSpace, float, InputSkeletonActionData_t *, uint32_t, VRBoneTransform_t *, uint32_t);
+extern EVRInputError cppIVRInput_IVRInput_003_GetDigitalActionData(void *, VRActionHandle_t, winInputDigitalActionData_t_1015 *, uint32_t);
+extern EVRInputError cppIVRInput_IVRInput_003_GetAnalogActionData(void *, VRActionHandle_t, winInputAnalogActionData_t_1015 *, uint32_t);
+extern EVRInputError cppIVRInput_IVRInput_003_GetPoseActionData(void *, VRActionHandle_t, ETrackingUniverseOrigin, float, winInputPoseActionData_t_1015 *, uint32_t);
+extern EVRInputError cppIVRInput_IVRInput_003_GetSkeletalActionData(void *, VRActionHandle_t, EVRSkeletalTransformSpace, float, winInputSkeletonActionData_t_1015 *, uint32_t, VRBoneTransform_t *, uint32_t);
 extern EVRInputError cppIVRInput_IVRInput_003_GetSkeletalActionDataCompressed(void *, VRActionHandle_t, EVRSkeletalTransformSpace, float, void *, uint32_t, uint32_t *);
 extern EVRInputError cppIVRInput_IVRInput_003_UncompressSkeletalActionData(void *, void *, uint32_t, EVRSkeletalTransformSpace *, VRBoneTransform_t *, uint32_t);
 extern EVRInputError cppIVRInput_IVRInput_003_TriggerHapticVibrationAction(void *, VRActionHandle_t, float, float, float, float);
diff --git a/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_004.cpp b/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_004.cpp
index e08f3f06..1f7af255 100644
--- a/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_004.cpp
+++ b/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_004.cpp
@@ -34,7 +34,7 @@ vr::EVRInputError cppIVRInput_IVRInput_004_UpdateActionState(void *linux_side, V
     return ((IVRInput*)linux_side)->UpdateActionState((vr::VRActiveActionSet_t *)pSets, (uint32_t)unSizeOfVRSelectedActionSet_t, (uint32_t)unSetCount);
 }
 
-vr::EVRInputError cppIVRInput_IVRInput_004_GetDigitalActionData(void *linux_side, VRActionHandle_t action, InputDigitalActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+vr::EVRInputError cppIVRInput_IVRInput_004_GetDigitalActionData(void *linux_side, VRActionHandle_t action, winInputDigitalActionData_t_1017 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     InputDigitalActionData_t lin;
     vr::EVRInputError _ret;
@@ -46,7 +46,7 @@ vr::EVRInputError cppIVRInput_IVRInput_004_GetDigitalActionData(void *linux_side
     return _ret;
 }
 
-vr::EVRInputError cppIVRInput_IVRInput_004_GetAnalogActionData(void *linux_side, VRActionHandle_t action, InputAnalogActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+vr::EVRInputError cppIVRInput_IVRInput_004_GetAnalogActionData(void *linux_side, VRActionHandle_t action, winInputAnalogActionData_t_1017 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     InputAnalogActionData_t lin;
     vr::EVRInputError _ret;
@@ -58,7 +58,7 @@ vr::EVRInputError cppIVRInput_IVRInput_004_GetAnalogActionData(void *linux_side,
     return _ret;
 }
 
-vr::EVRInputError cppIVRInput_IVRInput_004_GetPoseActionData(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, InputPoseActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+vr::EVRInputError cppIVRInput_IVRInput_004_GetPoseActionData(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, winInputPoseActionData_t_1017 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     InputPoseActionData_t lin;
     vr::EVRInputError _ret;
@@ -70,7 +70,7 @@ vr::EVRInputError cppIVRInput_IVRInput_004_GetPoseActionData(void *linux_side, V
     return _ret;
 }
 
-vr::EVRInputError cppIVRInput_IVRInput_004_GetSkeletalActionData(void *linux_side, VRActionHandle_t action, InputSkeletalActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+vr::EVRInputError cppIVRInput_IVRInput_004_GetSkeletalActionData(void *linux_side, VRActionHandle_t action, winInputSkeletalActionData_t_1017 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     InputSkeletalActionData_t lin;
     vr::EVRInputError _ret;
diff --git a/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_004.h b/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_004.h
index 036122f6..6591085e 100644
--- a/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_004.h
+++ b/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_004.h
@@ -6,10 +6,10 @@ extern EVRInputError cppIVRInput_IVRInput_004_GetActionSetHandle(void *, const c
 extern EVRInputError cppIVRInput_IVRInput_004_GetActionHandle(void *, const char *, VRActionHandle_t *);
 extern EVRInputError cppIVRInput_IVRInput_004_GetInputSourceHandle(void *, const char *, VRInputValueHandle_t *);
 extern EVRInputError cppIVRInput_IVRInput_004_UpdateActionState(void *, VRActiveActionSet_t *, uint32_t, uint32_t);
-extern EVRInputError cppIVRInput_IVRInput_004_GetDigitalActionData(void *, VRActionHandle_t, InputDigitalActionData_t *, uint32_t, VRInputValueHandle_t);
-extern EVRInputError cppIVRInput_IVRInput_004_GetAnalogActionData(void *, VRActionHandle_t, InputAnalogActionData_t *, uint32_t, VRInputValueHandle_t);
-extern EVRInputError cppIVRInput_IVRInput_004_GetPoseActionData(void *, VRActionHandle_t, ETrackingUniverseOrigin, float, InputPoseActionData_t *, uint32_t, VRInputValueHandle_t);
-extern EVRInputError cppIVRInput_IVRInput_004_GetSkeletalActionData(void *, VRActionHandle_t, InputSkeletalActionData_t *, uint32_t, VRInputValueHandle_t);
+extern EVRInputError cppIVRInput_IVRInput_004_GetDigitalActionData(void *, VRActionHandle_t, winInputDigitalActionData_t_1017 *, uint32_t, VRInputValueHandle_t);
+extern EVRInputError cppIVRInput_IVRInput_004_GetAnalogActionData(void *, VRActionHandle_t, winInputAnalogActionData_t_1017 *, uint32_t, VRInputValueHandle_t);
+extern EVRInputError cppIVRInput_IVRInput_004_GetPoseActionData(void *, VRActionHandle_t, ETrackingUniverseOrigin, float, winInputPoseActionData_t_1017 *, uint32_t, VRInputValueHandle_t);
+extern EVRInputError cppIVRInput_IVRInput_004_GetSkeletalActionData(void *, VRActionHandle_t, winInputSkeletalActionData_t_1017 *, uint32_t, VRInputValueHandle_t);
 extern EVRInputError cppIVRInput_IVRInput_004_GetSkeletalBoneData(void *, VRActionHandle_t, EVRSkeletalTransformSpace, EVRSkeletalMotionRange, VRBoneTransform_t *, uint32_t, VRInputValueHandle_t);
 extern EVRInputError cppIVRInput_IVRInput_004_GetSkeletalBoneDataCompressed(void *, VRActionHandle_t, EVRSkeletalTransformSpace, EVRSkeletalMotionRange, void *, uint32_t, uint32_t *, VRInputValueHandle_t);
 extern EVRInputError cppIVRInput_IVRInput_004_DecompressSkeletalBoneData(void *, void *, uint32_t, EVRSkeletalTransformSpace *, VRBoneTransform_t *, uint32_t);
diff --git a/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_005.cpp b/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_005.cpp
index 5c510df3..4f375f05 100644
--- a/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_005.cpp
+++ b/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_005.cpp
@@ -34,7 +34,7 @@ vr::EVRInputError cppIVRInput_IVRInput_005_UpdateActionState(void *linux_side, V
     return ((IVRInput*)linux_side)->UpdateActionState((vr::VRActiveActionSet_t *)pSets, (uint32_t)unSizeOfVRSelectedActionSet_t, (uint32_t)unSetCount);
 }
 
-vr::EVRInputError cppIVRInput_IVRInput_005_GetDigitalActionData(void *linux_side, VRActionHandle_t action, InputDigitalActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+vr::EVRInputError cppIVRInput_IVRInput_005_GetDigitalActionData(void *linux_side, VRActionHandle_t action, winInputDigitalActionData_t_1322 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     InputDigitalActionData_t lin;
     vr::EVRInputError _ret;
@@ -46,7 +46,7 @@ vr::EVRInputError cppIVRInput_IVRInput_005_GetDigitalActionData(void *linux_side
     return _ret;
 }
 
-vr::EVRInputError cppIVRInput_IVRInput_005_GetAnalogActionData(void *linux_side, VRActionHandle_t action, InputAnalogActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+vr::EVRInputError cppIVRInput_IVRInput_005_GetAnalogActionData(void *linux_side, VRActionHandle_t action, winInputAnalogActionData_t_1322 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     InputAnalogActionData_t lin;
     vr::EVRInputError _ret;
@@ -58,7 +58,7 @@ vr::EVRInputError cppIVRInput_IVRInput_005_GetAnalogActionData(void *linux_side,
     return _ret;
 }
 
-vr::EVRInputError cppIVRInput_IVRInput_005_GetPoseActionData(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, InputPoseActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+vr::EVRInputError cppIVRInput_IVRInput_005_GetPoseActionData(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, winInputPoseActionData_t_1322 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     InputPoseActionData_t lin;
     vr::EVRInputError _ret;
@@ -70,7 +70,7 @@ vr::EVRInputError cppIVRInput_IVRInput_005_GetPoseActionData(void *linux_side, V
     return _ret;
 }
 
-vr::EVRInputError cppIVRInput_IVRInput_005_GetSkeletalActionData(void *linux_side, VRActionHandle_t action, InputSkeletalActionData_t * pActionData, uint32_t unActionDataSize)
+vr::EVRInputError cppIVRInput_IVRInput_005_GetSkeletalActionData(void *linux_side, VRActionHandle_t action, winInputSkeletalActionData_t_1322 * pActionData, uint32_t unActionDataSize)
 {
     InputSkeletalActionData_t lin;
     vr::EVRInputError _ret;
diff --git a/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_005.h b/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_005.h
index 126dcdb7..c0293237 100644
--- a/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_005.h
+++ b/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_005.h
@@ -6,10 +6,10 @@ extern EVRInputError cppIVRInput_IVRInput_005_GetActionSetHandle(void *, const c
 extern EVRInputError cppIVRInput_IVRInput_005_GetActionHandle(void *, const char *, VRActionHandle_t *);
 extern EVRInputError cppIVRInput_IVRInput_005_GetInputSourceHandle(void *, const char *, VRInputValueHandle_t *);
 extern EVRInputError cppIVRInput_IVRInput_005_UpdateActionState(void *, VRActiveActionSet_t *, uint32_t, uint32_t);
-extern EVRInputError cppIVRInput_IVRInput_005_GetDigitalActionData(void *, VRActionHandle_t, InputDigitalActionData_t *, uint32_t, VRInputValueHandle_t);
-extern EVRInputError cppIVRInput_IVRInput_005_GetAnalogActionData(void *, VRActionHandle_t, InputAnalogActionData_t *, uint32_t, VRInputValueHandle_t);
-extern EVRInputError cppIVRInput_IVRInput_005_GetPoseActionData(void *, VRActionHandle_t, ETrackingUniverseOrigin, float, InputPoseActionData_t *, uint32_t, VRInputValueHandle_t);
-extern EVRInputError cppIVRInput_IVRInput_005_GetSkeletalActionData(void *, VRActionHandle_t, InputSkeletalActionData_t *, uint32_t);
+extern EVRInputError cppIVRInput_IVRInput_005_GetDigitalActionData(void *, VRActionHandle_t, winInputDigitalActionData_t_1322 *, uint32_t, VRInputValueHandle_t);
+extern EVRInputError cppIVRInput_IVRInput_005_GetAnalogActionData(void *, VRActionHandle_t, winInputAnalogActionData_t_1322 *, uint32_t, VRInputValueHandle_t);
+extern EVRInputError cppIVRInput_IVRInput_005_GetPoseActionData(void *, VRActionHandle_t, ETrackingUniverseOrigin, float, winInputPoseActionData_t_1322 *, uint32_t, VRInputValueHandle_t);
+extern EVRInputError cppIVRInput_IVRInput_005_GetSkeletalActionData(void *, VRActionHandle_t, winInputSkeletalActionData_t_1322 *, uint32_t);
 extern EVRInputError cppIVRInput_IVRInput_005_GetBoneCount(void *, VRActionHandle_t, uint32_t *);
 extern EVRInputError cppIVRInput_IVRInput_005_GetBoneHierarchy(void *, VRActionHandle_t, BoneIndex_t *, uint32_t);
 extern EVRInputError cppIVRInput_IVRInput_005_GetBoneName(void *, VRActionHandle_t, BoneIndex_t, char *, uint32_t);
diff --git a/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_006.cpp b/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_006.cpp
index 5221e77b..f06f9cc7 100644
--- a/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_006.cpp
+++ b/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_006.cpp
@@ -34,7 +34,7 @@ vr::EVRInputError cppIVRInput_IVRInput_006_UpdateActionState(void *linux_side, V
     return ((IVRInput*)linux_side)->UpdateActionState((vr::VRActiveActionSet_t *)pSets, (uint32_t)unSizeOfVRSelectedActionSet_t, (uint32_t)unSetCount);
 }
 
-vr::EVRInputError cppIVRInput_IVRInput_006_GetDigitalActionData(void *linux_side, VRActionHandle_t action, InputDigitalActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+vr::EVRInputError cppIVRInput_IVRInput_006_GetDigitalActionData(void *linux_side, VRActionHandle_t action, winInputDigitalActionData_t_1418 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     InputDigitalActionData_t lin;
     vr::EVRInputError _ret;
@@ -46,7 +46,7 @@ vr::EVRInputError cppIVRInput_IVRInput_006_GetDigitalActionData(void *linux_side
     return _ret;
 }
 
-vr::EVRInputError cppIVRInput_IVRInput_006_GetAnalogActionData(void *linux_side, VRActionHandle_t action, InputAnalogActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+vr::EVRInputError cppIVRInput_IVRInput_006_GetAnalogActionData(void *linux_side, VRActionHandle_t action, winInputAnalogActionData_t_1418 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     InputAnalogActionData_t lin;
     vr::EVRInputError _ret;
@@ -58,7 +58,7 @@ vr::EVRInputError cppIVRInput_IVRInput_006_GetAnalogActionData(void *linux_side,
     return _ret;
 }
 
-vr::EVRInputError cppIVRInput_IVRInput_006_GetPoseActionDataRelativeToNow(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, InputPoseActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+vr::EVRInputError cppIVRInput_IVRInput_006_GetPoseActionDataRelativeToNow(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, winInputPoseActionData_t_1418 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     InputPoseActionData_t lin;
     vr::EVRInputError _ret;
@@ -70,7 +70,7 @@ vr::EVRInputError cppIVRInput_IVRInput_006_GetPoseActionDataRelativeToNow(void *
     return _ret;
 }
 
-vr::EVRInputError cppIVRInput_IVRInput_006_GetPoseActionDataForNextFrame(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, InputPoseActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+vr::EVRInputError cppIVRInput_IVRInput_006_GetPoseActionDataForNextFrame(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, winInputPoseActionData_t_1418 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     InputPoseActionData_t lin;
     vr::EVRInputError _ret;
@@ -82,7 +82,7 @@ vr::EVRInputError cppIVRInput_IVRInput_006_GetPoseActionDataForNextFrame(void *l
     return _ret;
 }
 
-vr::EVRInputError cppIVRInput_IVRInput_006_GetSkeletalActionData(void *linux_side, VRActionHandle_t action, InputSkeletalActionData_t * pActionData, uint32_t unActionDataSize)
+vr::EVRInputError cppIVRInput_IVRInput_006_GetSkeletalActionData(void *linux_side, VRActionHandle_t action, winInputSkeletalActionData_t_1418 * pActionData, uint32_t unActionDataSize)
 {
     InputSkeletalActionData_t lin;
     vr::EVRInputError _ret;
diff --git a/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_006.h b/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_006.h
index 8f5b86c4..c1c4256c 100644
--- a/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_006.h
+++ b/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_006.h
@@ -6,11 +6,11 @@ extern EVRInputError cppIVRInput_IVRInput_006_GetActionSetHandle(void *, const c
 extern EVRInputError cppIVRInput_IVRInput_006_GetActionHandle(void *, const char *, VRActionHandle_t *);
 extern EVRInputError cppIVRInput_IVRInput_006_GetInputSourceHandle(void *, const char *, VRInputValueHandle_t *);
 extern EVRInputError cppIVRInput_IVRInput_006_UpdateActionState(void *, VRActiveActionSet_t *, uint32_t, uint32_t);
-extern EVRInputError cppIVRInput_IVRInput_006_GetDigitalActionData(void *, VRActionHandle_t, InputDigitalActionData_t *, uint32_t, VRInputValueHandle_t);
-extern EVRInputError cppIVRInput_IVRInput_006_GetAnalogActionData(void *, VRActionHandle_t, InputAnalogActionData_t *, uint32_t, VRInputValueHandle_t);
-extern EVRInputError cppIVRInput_IVRInput_006_GetPoseActionDataRelativeToNow(void *, VRActionHandle_t, ETrackingUniverseOrigin, float, InputPoseActionData_t *, uint32_t, VRInputValueHandle_t);
-extern EVRInputError cppIVRInput_IVRInput_006_GetPoseActionDataForNextFrame(void *, VRActionHandle_t, ETrackingUniverseOrigin, InputPoseActionData_t *, uint32_t, VRInputValueHandle_t);
-extern EVRInputError cppIVRInput_IVRInput_006_GetSkeletalActionData(void *, VRActionHandle_t, InputSkeletalActionData_t *, uint32_t);
+extern EVRInputError cppIVRInput_IVRInput_006_GetDigitalActionData(void *, VRActionHandle_t, winInputDigitalActionData_t_1418 *, uint32_t, VRInputValueHandle_t);
+extern EVRInputError cppIVRInput_IVRInput_006_GetAnalogActionData(void *, VRActionHandle_t, winInputAnalogActionData_t_1418 *, uint32_t, VRInputValueHandle_t);
+extern EVRInputError cppIVRInput_IVRInput_006_GetPoseActionDataRelativeToNow(void *, VRActionHandle_t, ETrackingUniverseOrigin, float, winInputPoseActionData_t_1418 *, uint32_t, VRInputValueHandle_t);
+extern EVRInputError cppIVRInput_IVRInput_006_GetPoseActionDataForNextFrame(void *, VRActionHandle_t, ETrackingUniverseOrigin, winInputPoseActionData_t_1418 *, uint32_t, VRInputValueHandle_t);
+extern EVRInputError cppIVRInput_IVRInput_006_GetSkeletalActionData(void *, VRActionHandle_t, winInputSkeletalActionData_t_1418 *, uint32_t);
 extern EVRInputError cppIVRInput_IVRInput_006_GetBoneCount(void *, VRActionHandle_t, uint32_t *);
 extern EVRInputError cppIVRInput_IVRInput_006_GetBoneHierarchy(void *, VRActionHandle_t, BoneIndex_t *, uint32_t);
 extern EVRInputError cppIVRInput_IVRInput_006_GetBoneName(void *, VRActionHandle_t, BoneIndex_t, char *, uint32_t);
diff --git a/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_007.cpp b/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_007.cpp
index 83d0ffc8..6d1fdaa5 100644
--- a/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_007.cpp
+++ b/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_007.cpp
@@ -34,7 +34,7 @@ vr::EVRInputError cppIVRInput_IVRInput_007_UpdateActionState(void *linux_side, V
     return ((IVRInput*)linux_side)->UpdateActionState((vr::VRActiveActionSet_t *)pSets, (uint32_t)unSizeOfVRSelectedActionSet_t, (uint32_t)unSetCount);
 }
 
-vr::EVRInputError cppIVRInput_IVRInput_007_GetDigitalActionData(void *linux_side, VRActionHandle_t action, InputDigitalActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+vr::EVRInputError cppIVRInput_IVRInput_007_GetDigitalActionData(void *linux_side, VRActionHandle_t action, winInputDigitalActionData_t_1610 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     InputDigitalActionData_t lin;
     vr::EVRInputError _ret;
@@ -46,7 +46,7 @@ vr::EVRInputError cppIVRInput_IVRInput_007_GetDigitalActionData(void *linux_side
     return _ret;
 }
 
-vr::EVRInputError cppIVRInput_IVRInput_007_GetAnalogActionData(void *linux_side, VRActionHandle_t action, InputAnalogActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+vr::EVRInputError cppIVRInput_IVRInput_007_GetAnalogActionData(void *linux_side, VRActionHandle_t action, winInputAnalogActionData_t_1610 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     InputAnalogActionData_t lin;
     vr::EVRInputError _ret;
@@ -58,7 +58,7 @@ vr::EVRInputError cppIVRInput_IVRInput_007_GetAnalogActionData(void *linux_side,
     return _ret;
 }
 
-vr::EVRInputError cppIVRInput_IVRInput_007_GetPoseActionDataRelativeToNow(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, InputPoseActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+vr::EVRInputError cppIVRInput_IVRInput_007_GetPoseActionDataRelativeToNow(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, winInputPoseActionData_t_1610 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     InputPoseActionData_t lin;
     vr::EVRInputError _ret;
@@ -70,7 +70,7 @@ vr::EVRInputError cppIVRInput_IVRInput_007_GetPoseActionDataRelativeToNow(void *
     return _ret;
 }
 
-vr::EVRInputError cppIVRInput_IVRInput_007_GetPoseActionDataForNextFrame(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, InputPoseActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+vr::EVRInputError cppIVRInput_IVRInput_007_GetPoseActionDataForNextFrame(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, winInputPoseActionData_t_1610 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     InputPoseActionData_t lin;
     vr::EVRInputError _ret;
@@ -82,7 +82,7 @@ vr::EVRInputError cppIVRInput_IVRInput_007_GetPoseActionDataForNextFrame(void *l
     return _ret;
 }
 
-vr::EVRInputError cppIVRInput_IVRInput_007_GetSkeletalActionData(void *linux_side, VRActionHandle_t action, InputSkeletalActionData_t * pActionData, uint32_t unActionDataSize)
+vr::EVRInputError cppIVRInput_IVRInput_007_GetSkeletalActionData(void *linux_side, VRActionHandle_t action, winInputSkeletalActionData_t_1610 * pActionData, uint32_t unActionDataSize)
 {
     InputSkeletalActionData_t lin;
     vr::EVRInputError _ret;
diff --git a/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_007.h b/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_007.h
index cc84fe75..b3243a56 100644
--- a/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_007.h
+++ b/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_007.h
@@ -6,11 +6,11 @@ extern EVRInputError cppIVRInput_IVRInput_007_GetActionSetHandle(void *, const c
 extern EVRInputError cppIVRInput_IVRInput_007_GetActionHandle(void *, const char *, VRActionHandle_t *);
 extern EVRInputError cppIVRInput_IVRInput_007_GetInputSourceHandle(void *, const char *, VRInputValueHandle_t *);
 extern EVRInputError cppIVRInput_IVRInput_007_UpdateActionState(void *, VRActiveActionSet_t *, uint32_t, uint32_t);
-extern EVRInputError cppIVRInput_IVRInput_007_GetDigitalActionData(void *, VRActionHandle_t, InputDigitalActionData_t *, uint32_t, VRInputValueHandle_t);
-extern EVRInputError cppIVRInput_IVRInput_007_GetAnalogActionData(void *, VRActionHandle_t, InputAnalogActionData_t *, uint32_t, VRInputValueHandle_t);
-extern EVRInputError cppIVRInput_IVRInput_007_GetPoseActionDataRelativeToNow(void *, VRActionHandle_t, ETrackingUniverseOrigin, float, InputPoseActionData_t *, uint32_t, VRInputValueHandle_t);
-extern EVRInputError cppIVRInput_IVRInput_007_GetPoseActionDataForNextFrame(void *, VRActionHandle_t, ETrackingUniverseOrigin, InputPoseActionData_t *, uint32_t, VRInputValueHandle_t);
-extern EVRInputError cppIVRInput_IVRInput_007_GetSkeletalActionData(void *, VRActionHandle_t, InputSkeletalActionData_t *, uint32_t);
+extern EVRInputError cppIVRInput_IVRInput_007_GetDigitalActionData(void *, VRActionHandle_t, winInputDigitalActionData_t_1610 *, uint32_t, VRInputValueHandle_t);
+extern EVRInputError cppIVRInput_IVRInput_007_GetAnalogActionData(void *, VRActionHandle_t, winInputAnalogActionData_t_1610 *, uint32_t, VRInputValueHandle_t);
+extern EVRInputError cppIVRInput_IVRInput_007_GetPoseActionDataRelativeToNow(void *, VRActionHandle_t, ETrackingUniverseOrigin, float, winInputPoseActionData_t_1610 *, uint32_t, VRInputValueHandle_t);
+extern EVRInputError cppIVRInput_IVRInput_007_GetPoseActionDataForNextFrame(void *, VRActionHandle_t, ETrackingUniverseOrigin, winInputPoseActionData_t_1610 *, uint32_t, VRInputValueHandle_t);
+extern EVRInputError cppIVRInput_IVRInput_007_GetSkeletalActionData(void *, VRActionHandle_t, winInputSkeletalActionData_t_1610 *, uint32_t);
 extern EVRInputError cppIVRInput_IVRInput_007_GetBoneCount(void *, VRActionHandle_t, uint32_t *);
 extern EVRInputError cppIVRInput_IVRInput_007_GetBoneHierarchy(void *, VRActionHandle_t, BoneIndex_t *, uint32_t);
 extern EVRInputError cppIVRInput_IVRInput_007_GetBoneName(void *, VRActionHandle_t, BoneIndex_t, char *, uint32_t);
diff --git a/vrclient_x64/vrclient_x64/cppIVRRenderModels_IVRRenderModels_002.cpp b/vrclient_x64/vrclient_x64/cppIVRRenderModels_IVRRenderModels_002.cpp
index 1a805312..714a3c1d 100644
--- a/vrclient_x64/vrclient_x64/cppIVRRenderModels_IVRRenderModels_002.cpp
+++ b/vrclient_x64/vrclient_x64/cppIVRRenderModels_IVRRenderModels_002.cpp
@@ -71,13 +71,11 @@ uint32_t cppIVRRenderModels_IVRRenderModels_002_GetComponentRenderModelName(void
 
 bool cppIVRRenderModels_IVRRenderModels_002_GetComponentState(void *linux_side, const char * pchRenderModelName, const char * pchComponentName, VRControllerState_t * pControllerState, RenderModel_ComponentState_t * pComponentState)
 {
-    const VRControllerState_t lin;
+    VRControllerState_t lin;
     bool _ret;
     if(pControllerState)
-        struct_const VRControllerState_t_0915_win_to_lin(pControllerState, &lin);
+        struct_VRControllerState_t_0915_win_to_lin(pControllerState, &lin);
     _ret = ((IVRRenderModels*)linux_side)->GetComponentState((const char *)pchRenderModelName, (const char *)pchComponentName, pControllerState ? &lin : nullptr, (vr::RenderModel_ComponentState_t *)pComponentState);
-    if(pControllerState)
-        struct_const VRControllerState_t_0915_lin_to_win(&lin, pControllerState);
     return _ret;
 }
 
diff --git a/vrclient_x64/vrclient_x64/cppIVRRenderModels_IVRRenderModels_004.cpp b/vrclient_x64/vrclient_x64/cppIVRRenderModels_IVRRenderModels_004.cpp
index dac49e01..d3c9d642 100644
--- a/vrclient_x64/vrclient_x64/cppIVRRenderModels_IVRRenderModels_004.cpp
+++ b/vrclient_x64/vrclient_x64/cppIVRRenderModels_IVRRenderModels_004.cpp
@@ -81,13 +81,11 @@ uint32_t cppIVRRenderModels_IVRRenderModels_004_GetComponentRenderModelName(void
 
 bool cppIVRRenderModels_IVRRenderModels_004_GetComponentState(void *linux_side, const char * pchRenderModelName, const char * pchComponentName, VRControllerState_t * pControllerState, RenderModel_ControllerMode_State_t * pState, RenderModel_ComponentState_t * pComponentState)
 {
-    const VRControllerState_t lin;
+    VRControllerState_t lin;
     bool _ret;
     if(pControllerState)
-        struct_const VRControllerState_t_0918_win_to_lin(pControllerState, &lin);
+        struct_VRControllerState_t_0918_win_to_lin(pControllerState, &lin);
     _ret = ((IVRRenderModels*)linux_side)->GetComponentState((const char *)pchRenderModelName, (const char *)pchComponentName, pControllerState ? &lin : nullptr, (const vr::RenderModel_ControllerMode_State_t *)pState, (vr::RenderModel_ComponentState_t *)pComponentState);
-    if(pControllerState)
-        struct_const VRControllerState_t_0918_lin_to_win(&lin, pControllerState);
     return _ret;
 }
 
diff --git a/vrclient_x64/vrclient_x64/cppIVRRenderModels_IVRRenderModels_005.cpp b/vrclient_x64/vrclient_x64/cppIVRRenderModels_IVRRenderModels_005.cpp
index fe716371..868dbe25 100644
--- a/vrclient_x64/vrclient_x64/cppIVRRenderModels_IVRRenderModels_005.cpp
+++ b/vrclient_x64/vrclient_x64/cppIVRRenderModels_IVRRenderModels_005.cpp
@@ -86,13 +86,11 @@ uint32_t cppIVRRenderModels_IVRRenderModels_005_GetComponentRenderModelName(void
 
 bool cppIVRRenderModels_IVRRenderModels_005_GetComponentState(void *linux_side, const char * pchRenderModelName, const char * pchComponentName, VRControllerState_t * pControllerState, RenderModel_ControllerMode_State_t * pState, RenderModel_ComponentState_t * pComponentState)
 {
-    const VRControllerState_t lin;
+    VRControllerState_t lin;
     bool _ret;
     if(pControllerState)
-        struct_const VRControllerState_t_1015_win_to_lin(pControllerState, &lin);
+        struct_VRControllerState_t_1015_win_to_lin(pControllerState, &lin);
     _ret = ((IVRRenderModels*)linux_side)->GetComponentState((const char *)pchRenderModelName, (const char *)pchComponentName, pControllerState ? &lin : nullptr, (const vr::RenderModel_ControllerMode_State_t *)pState, (vr::RenderModel_ComponentState_t *)pComponentState);
-    if(pControllerState)
-        struct_const VRControllerState_t_1015_lin_to_win(&lin, pControllerState);
     return _ret;
 }
 
diff --git a/vrclient_x64/vrclient_x64/cppIVRRenderModels_IVRRenderModels_006.cpp b/vrclient_x64/vrclient_x64/cppIVRRenderModels_IVRRenderModels_006.cpp
index 2285e46b..d687bcde 100644
--- a/vrclient_x64/vrclient_x64/cppIVRRenderModels_IVRRenderModels_006.cpp
+++ b/vrclient_x64/vrclient_x64/cppIVRRenderModels_IVRRenderModels_006.cpp
@@ -91,13 +91,11 @@ bool cppIVRRenderModels_IVRRenderModels_006_GetComponentStateForDevicePath(void
 
 bool cppIVRRenderModels_IVRRenderModels_006_GetComponentState(void *linux_side, const char * pchRenderModelName, const char * pchComponentName, VRControllerState_t * pControllerState, RenderModel_ControllerMode_State_t * pState, RenderModel_ComponentState_t * pComponentState)
 {
-    const VRControllerState_t lin;
+    VRControllerState_t lin;
     bool _ret;
     if(pControllerState)
-        struct_const VRControllerState_t_1610_win_to_lin(pControllerState, &lin);
+        struct_VRControllerState_t_1610_win_to_lin(pControllerState, &lin);
     _ret = ((IVRRenderModels*)linux_side)->GetComponentState((const char *)pchRenderModelName, (const char *)pchComponentName, pControllerState ? &lin : nullptr, (const vr::RenderModel_ControllerMode_State_t *)pState, (vr::RenderModel_ComponentState_t *)pComponentState);
-    if(pControllerState)
-        struct_const VRControllerState_t_1610_lin_to_win(&lin, pControllerState);
     return _ret;
 }
 
diff --git a/vrclient_x64/vrclient_x64/cppIVRTrackedCamera_IVRTrackedCamera_001.cpp b/vrclient_x64/vrclient_x64/cppIVRTrackedCamera_IVRTrackedCamera_001.cpp
index aba62de4..41a649d5 100644
--- a/vrclient_x64/vrclient_x64/cppIVRTrackedCamera_IVRTrackedCamera_001.cpp
+++ b/vrclient_x64/vrclient_x64/cppIVRTrackedCamera_IVRTrackedCamera_001.cpp
@@ -66,13 +66,11 @@ const vr::CameraVideoStreamFrame_t * cppIVRTrackedCamera_IVRTrackedCamera_001_Ge
 
 bool cppIVRTrackedCamera_IVRTrackedCamera_001_ReleaseVideoStreamFrame(void *linux_side, TrackedDeviceIndex_t nDeviceIndex, CameraVideoStreamFrame_t * pFrameImage)
 {
-    const CameraVideoStreamFrame_t lin;
+    CameraVideoStreamFrame_t lin;
     bool _ret;
     if(pFrameImage)
-        struct_const CameraVideoStreamFrame_t_0914_win_to_lin(pFrameImage, &lin);
+        struct_CameraVideoStreamFrame_t_0914_win_to_lin(pFrameImage, &lin);
     _ret = ((IVRTrackedCamera*)linux_side)->ReleaseVideoStreamFrame((vr::TrackedDeviceIndex_t)nDeviceIndex, pFrameImage ? &lin : nullptr);
-    if(pFrameImage)
-        struct_const CameraVideoStreamFrame_t_0914_lin_to_win(&lin, pFrameImage);
     return _ret;
 }
 
diff --git a/vrclient_x64/vrclient_x64/cppIVRTrackedCamera_IVRTrackedCamera_004.cpp b/vrclient_x64/vrclient_x64/cppIVRTrackedCamera_IVRTrackedCamera_004.cpp
index 83634ed8..39c63eee 100644
--- a/vrclient_x64/vrclient_x64/cppIVRTrackedCamera_IVRTrackedCamera_004.cpp
+++ b/vrclient_x64/vrclient_x64/cppIVRTrackedCamera_IVRTrackedCamera_004.cpp
@@ -44,7 +44,7 @@ vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_004_ReleaseVideoS
     return ((IVRTrackedCamera*)linux_side)->ReleaseVideoStreamingService((vr::TrackedCameraHandle_t)hTrackedCamera);
 }
 
-vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamFrameBuffer(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pFrameBuffer, uint32_t nFrameBufferSize, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize)
+vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamFrameBuffer(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pFrameBuffer, uint32_t nFrameBufferSize, winCameraVideoStreamFrameHeader_t_1017 * pFrameHeader, uint32_t nFrameHeaderSize)
 {
     CameraVideoStreamFrameHeader_t lin;
     vr::EVRTrackedCameraError _ret;
@@ -61,7 +61,7 @@ vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStrea
     return ((IVRTrackedCamera*)linux_side)->GetVideoStreamTextureSize((vr::TrackedDeviceIndex_t)nDeviceIndex, (vr::EVRTrackedCameraFrameType)eFrameType, (vr::VRTextureBounds_t *)pTextureBounds, (uint32_t *)pnWidth, (uint32_t *)pnHeight);
 }
 
-vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureD3D11(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize)
+vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureD3D11(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView, winCameraVideoStreamFrameHeader_t_1017 * pFrameHeader, uint32_t nFrameHeaderSize)
 {
     CameraVideoStreamFrameHeader_t lin;
     vr::EVRTrackedCameraError _ret;
@@ -73,7 +73,7 @@ vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStrea
     return _ret;
 }
 
-vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureGL(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, glUInt_t * pglTextureId, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize)
+vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureGL(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, glUInt_t * pglTextureId, winCameraVideoStreamFrameHeader_t_1017 * pFrameHeader, uint32_t nFrameHeaderSize)
 {
     CameraVideoStreamFrameHeader_t lin;
     vr::EVRTrackedCameraError _ret;
diff --git a/vrclient_x64/vrclient_x64/cppIVRTrackedCamera_IVRTrackedCamera_004.h b/vrclient_x64/vrclient_x64/cppIVRTrackedCamera_IVRTrackedCamera_004.h
index addedb44..e82fa992 100644
--- a/vrclient_x64/vrclient_x64/cppIVRTrackedCamera_IVRTrackedCamera_004.h
+++ b/vrclient_x64/vrclient_x64/cppIVRTrackedCamera_IVRTrackedCamera_004.h
@@ -8,10 +8,10 @@ extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_004_GetCameraI
 extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_004_GetCameraProjection(void *, TrackedDeviceIndex_t, EVRTrackedCameraFrameType, float, float, HmdMatrix44_t *);
 extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_004_AcquireVideoStreamingService(void *, TrackedDeviceIndex_t, TrackedCameraHandle_t *);
 extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_004_ReleaseVideoStreamingService(void *, TrackedCameraHandle_t);
-extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamFrameBuffer(void *, TrackedCameraHandle_t, EVRTrackedCameraFrameType, void *, uint32_t, CameraVideoStreamFrameHeader_t *, uint32_t);
+extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamFrameBuffer(void *, TrackedCameraHandle_t, EVRTrackedCameraFrameType, void *, uint32_t, winCameraVideoStreamFrameHeader_t_1017 *, uint32_t);
 extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureSize(void *, TrackedDeviceIndex_t, EVRTrackedCameraFrameType, VRTextureBounds_t *, uint32_t *, uint32_t *);
-extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureD3D11(void *, TrackedCameraHandle_t, EVRTrackedCameraFrameType, void *, void **, CameraVideoStreamFrameHeader_t *, uint32_t);
-extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureGL(void *, TrackedCameraHandle_t, EVRTrackedCameraFrameType, glUInt_t *, CameraVideoStreamFrameHeader_t *, uint32_t);
+extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureD3D11(void *, TrackedCameraHandle_t, EVRTrackedCameraFrameType, void *, void **, winCameraVideoStreamFrameHeader_t_1017 *, uint32_t);
+extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureGL(void *, TrackedCameraHandle_t, EVRTrackedCameraFrameType, glUInt_t *, winCameraVideoStreamFrameHeader_t_1017 *, uint32_t);
 extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_004_ReleaseVideoStreamTextureGL(void *, TrackedCameraHandle_t, glUInt_t);
 #ifdef __cplusplus
 }
diff --git a/vrclient_x64/vrclient_x64/cppIVRTrackedCamera_IVRTrackedCamera_005.cpp b/vrclient_x64/vrclient_x64/cppIVRTrackedCamera_IVRTrackedCamera_005.cpp
index c8b34870..adc5ecd6 100644
--- a/vrclient_x64/vrclient_x64/cppIVRTrackedCamera_IVRTrackedCamera_005.cpp
+++ b/vrclient_x64/vrclient_x64/cppIVRTrackedCamera_IVRTrackedCamera_005.cpp
@@ -44,7 +44,7 @@ vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_005_ReleaseVideoS
     return ((IVRTrackedCamera*)linux_side)->ReleaseVideoStreamingService((vr::TrackedCameraHandle_t)hTrackedCamera);
 }
 
-vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamFrameBuffer(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pFrameBuffer, uint32_t nFrameBufferSize, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize)
+vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamFrameBuffer(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pFrameBuffer, uint32_t nFrameBufferSize, winCameraVideoStreamFrameHeader_t_1610 * pFrameHeader, uint32_t nFrameHeaderSize)
 {
     CameraVideoStreamFrameHeader_t lin;
     vr::EVRTrackedCameraError _ret;
@@ -61,7 +61,7 @@ vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_005_GetVideoStrea
     return ((IVRTrackedCamera*)linux_side)->GetVideoStreamTextureSize((vr::TrackedDeviceIndex_t)nDeviceIndex, (vr::EVRTrackedCameraFrameType)eFrameType, (vr::VRTextureBounds_t *)pTextureBounds, (uint32_t *)pnWidth, (uint32_t *)pnHeight);
 }
 
-vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamTextureD3D11(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize)
+vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamTextureD3D11(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView, winCameraVideoStreamFrameHeader_t_1610 * pFrameHeader, uint32_t nFrameHeaderSize)
 {
     CameraVideoStreamFrameHeader_t lin;
     vr::EVRTrackedCameraError _ret;
@@ -73,7 +73,7 @@ vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_005_GetVideoStrea
     return _ret;
 }
 
-vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamTextureGL(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, glUInt_t * pglTextureId, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize)
+vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamTextureGL(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, glUInt_t * pglTextureId, winCameraVideoStreamFrameHeader_t_1610 * pFrameHeader, uint32_t nFrameHeaderSize)
 {
     CameraVideoStreamFrameHeader_t lin;
     vr::EVRTrackedCameraError _ret;
diff --git a/vrclient_x64/vrclient_x64/cppIVRTrackedCamera_IVRTrackedCamera_005.h b/vrclient_x64/vrclient_x64/cppIVRTrackedCamera_IVRTrackedCamera_005.h
index 6e52d18e..35e67c4c 100644
--- a/vrclient_x64/vrclient_x64/cppIVRTrackedCamera_IVRTrackedCamera_005.h
+++ b/vrclient_x64/vrclient_x64/cppIVRTrackedCamera_IVRTrackedCamera_005.h
@@ -8,10 +8,10 @@ extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_005_GetCameraI
 extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_005_GetCameraProjection(void *, TrackedDeviceIndex_t, uint32_t, EVRTrackedCameraFrameType, float, float, HmdMatrix44_t *);
 extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_005_AcquireVideoStreamingService(void *, TrackedDeviceIndex_t, TrackedCameraHandle_t *);
 extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_005_ReleaseVideoStreamingService(void *, TrackedCameraHandle_t);
-extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamFrameBuffer(void *, TrackedCameraHandle_t, EVRTrackedCameraFrameType, void *, uint32_t, CameraVideoStreamFrameHeader_t *, uint32_t);
+extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamFrameBuffer(void *, TrackedCameraHandle_t, EVRTrackedCameraFrameType, void *, uint32_t, winCameraVideoStreamFrameHeader_t_1610 *, uint32_t);
 extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamTextureSize(void *, TrackedDeviceIndex_t, EVRTrackedCameraFrameType, VRTextureBounds_t *, uint32_t *, uint32_t *);
-extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamTextureD3D11(void *, TrackedCameraHandle_t, EVRTrackedCameraFrameType, void *, void **, CameraVideoStreamFrameHeader_t *, uint32_t);
-extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamTextureGL(void *, TrackedCameraHandle_t, EVRTrackedCameraFrameType, glUInt_t *, CameraVideoStreamFrameHeader_t *, uint32_t);
+extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamTextureD3D11(void *, TrackedCameraHandle_t, EVRTrackedCameraFrameType, void *, void **, winCameraVideoStreamFrameHeader_t_1610 *, uint32_t);
+extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamTextureGL(void *, TrackedCameraHandle_t, EVRTrackedCameraFrameType, glUInt_t *, winCameraVideoStreamFrameHeader_t_1610 *, uint32_t);
 extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_005_ReleaseVideoStreamTextureGL(void *, TrackedCameraHandle_t, glUInt_t);
 #ifdef __cplusplus
 }
diff --git a/vrclient_x64/vrclient_x64/winIVRCompositor.c b/vrclient_x64/vrclient_x64/winIVRCompositor.c
index 4ce0f641..ff2fc4dc 100644
--- a/vrclient_x64/vrclient_x64/winIVRCompositor.c
+++ b/vrclient_x64/vrclient_x64/winIVRCompositor.c
@@ -2650,7 +2650,7 @@ void __thiscall winIVRCompositor_IVRCompositor_016_PostPresentHandoff(winIVRComp
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_016_GetFrameTiming, 12)
-bool __thiscall winIVRCompositor_IVRCompositor_016_GetFrameTiming(winIVRCompositor_IVRCompositor_016 *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo)
+bool __thiscall winIVRCompositor_IVRCompositor_016_GetFrameTiming(winIVRCompositor_IVRCompositor_016 *_this, winCompositor_FrameTiming_103 * pTiming, uint32_t unFramesAgo)
 {
     TRACE("%p\n", _this);
     return cppIVRCompositor_IVRCompositor_016_GetFrameTiming(_this->linux_side, pTiming, unFramesAgo);
@@ -4611,7 +4611,7 @@ void __thiscall winIVRCompositor_IVRCompositor_010_PostPresentHandoff(winIVRComp
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_010_GetFrameTiming, 12)
-bool __thiscall winIVRCompositor_IVRCompositor_010_GetFrameTiming(winIVRCompositor_IVRCompositor_010 *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo)
+bool __thiscall winIVRCompositor_IVRCompositor_010_GetFrameTiming(winIVRCompositor_IVRCompositor_010 *_this, winCompositor_FrameTiming_0914 * pTiming, uint32_t unFramesAgo)
 {
     TRACE("%p\n", _this);
     return cppIVRCompositor_IVRCompositor_010_GetFrameTiming(_this->linux_side, pTiming, unFramesAgo);
@@ -4888,7 +4888,7 @@ void __thiscall winIVRCompositor_IVRCompositor_009_PostPresentHandoff(winIVRComp
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_009_GetFrameTiming, 12)
-bool __thiscall winIVRCompositor_IVRCompositor_009_GetFrameTiming(winIVRCompositor_IVRCompositor_009 *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo)
+bool __thiscall winIVRCompositor_IVRCompositor_009_GetFrameTiming(winIVRCompositor_IVRCompositor_009 *_this, winCompositor_FrameTiming_0913 * pTiming, uint32_t unFramesAgo)
 {
     TRACE("%p\n", _this);
     return cppIVRCompositor_IVRCompositor_009_GetFrameTiming(_this->linux_side, pTiming, unFramesAgo);
@@ -5172,7 +5172,7 @@ void __thiscall winIVRCompositor_IVRCompositor_008_ClearLastSubmittedFrame(winIV
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_008_GetFrameTiming, 12)
-bool __thiscall winIVRCompositor_IVRCompositor_008_GetFrameTiming(winIVRCompositor_IVRCompositor_008 *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo)
+bool __thiscall winIVRCompositor_IVRCompositor_008_GetFrameTiming(winIVRCompositor_IVRCompositor_008 *_this, winCompositor_FrameTiming_0910 * pTiming, uint32_t unFramesAgo)
 {
     TRACE("%p\n", _this);
     return cppIVRCompositor_IVRCompositor_008_GetFrameTiming(_this->linux_side, pTiming, unFramesAgo);
@@ -5467,7 +5467,7 @@ void __thiscall winIVRCompositor_IVRCompositor_007_ClearLastSubmittedFrame(winIV
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_007_GetFrameTiming, 12)
-bool __thiscall winIVRCompositor_IVRCompositor_007_GetFrameTiming(winIVRCompositor_IVRCompositor_007 *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo)
+bool __thiscall winIVRCompositor_IVRCompositor_007_GetFrameTiming(winIVRCompositor_IVRCompositor_007 *_this, winCompositor_FrameTiming_098 * pTiming, uint32_t unFramesAgo)
 {
     TRACE("%p\n", _this);
     return cppIVRCompositor_IVRCompositor_007_GetFrameTiming(_this->linux_side, pTiming, unFramesAgo);
@@ -5706,7 +5706,7 @@ void __thiscall winIVRCompositor_IVRCompositor_006_ClearLastSubmittedFrame(winIV
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_006_GetFrameTiming, 12)
-bool __thiscall winIVRCompositor_IVRCompositor_006_GetFrameTiming(winIVRCompositor_IVRCompositor_006 *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo)
+bool __thiscall winIVRCompositor_IVRCompositor_006_GetFrameTiming(winIVRCompositor_IVRCompositor_006 *_this, winCompositor_FrameTiming_092 * pTiming, uint32_t unFramesAgo)
 {
     TRACE("%p\n", _this);
     return cppIVRCompositor_IVRCompositor_006_GetFrameTiming(_this->linux_side, pTiming, unFramesAgo);
@@ -5984,7 +5984,7 @@ void __thiscall winIVRCompositor_IVRCompositor_005_ClearOverlay(winIVRCompositor
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_005_GetFrameTiming, 12)
-bool __thiscall winIVRCompositor_IVRCompositor_005_GetFrameTiming(winIVRCompositor_IVRCompositor_005 *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo)
+bool __thiscall winIVRCompositor_IVRCompositor_005_GetFrameTiming(winIVRCompositor_IVRCompositor_005 *_this, winCompositor_FrameTiming_091 * pTiming, uint32_t unFramesAgo)
 {
     TRACE("%p\n", _this);
     return cppIVRCompositor_IVRCompositor_005_GetFrameTiming(_this->linux_side, pTiming, unFramesAgo);
diff --git a/vrclient_x64/vrclient_x64/winIVRInput.c b/vrclient_x64/vrclient_x64/winIVRInput.c
index 3565b258..033b7db1 100644
--- a/vrclient_x64/vrclient_x64/winIVRInput.c
+++ b/vrclient_x64/vrclient_x64/winIVRInput.c
@@ -63,35 +63,35 @@ EVRInputError __thiscall winIVRInput_IVRInput_007_UpdateActionState(winIVRInput_
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_007_GetDigitalActionData, 28)
-EVRInputError __thiscall winIVRInput_IVRInput_007_GetDigitalActionData(winIVRInput_IVRInput_007 *_this, VRActionHandle_t action, InputDigitalActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+EVRInputError __thiscall winIVRInput_IVRInput_007_GetDigitalActionData(winIVRInput_IVRInput_007 *_this, VRActionHandle_t action, winInputDigitalActionData_t_1610 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     TRACE("%p\n", _this);
     return cppIVRInput_IVRInput_007_GetDigitalActionData(_this->linux_side, action, pActionData, unActionDataSize, ulRestrictToDevice);
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_007_GetAnalogActionData, 28)
-EVRInputError __thiscall winIVRInput_IVRInput_007_GetAnalogActionData(winIVRInput_IVRInput_007 *_this, VRActionHandle_t action, InputAnalogActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+EVRInputError __thiscall winIVRInput_IVRInput_007_GetAnalogActionData(winIVRInput_IVRInput_007 *_this, VRActionHandle_t action, winInputAnalogActionData_t_1610 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     TRACE("%p\n", _this);
     return cppIVRInput_IVRInput_007_GetAnalogActionData(_this->linux_side, action, pActionData, unActionDataSize, ulRestrictToDevice);
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_007_GetPoseActionDataRelativeToNow, 36)
-EVRInputError __thiscall winIVRInput_IVRInput_007_GetPoseActionDataRelativeToNow(winIVRInput_IVRInput_007 *_this, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, InputPoseActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+EVRInputError __thiscall winIVRInput_IVRInput_007_GetPoseActionDataRelativeToNow(winIVRInput_IVRInput_007 *_this, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, winInputPoseActionData_t_1610 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     TRACE("%p\n", _this);
     return cppIVRInput_IVRInput_007_GetPoseActionDataRelativeToNow(_this->linux_side, action, eOrigin, fPredictedSecondsFromNow, pActionData, unActionDataSize, ulRestrictToDevice);
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_007_GetPoseActionDataForNextFrame, 32)
-EVRInputError __thiscall winIVRInput_IVRInput_007_GetPoseActionDataForNextFrame(winIVRInput_IVRInput_007 *_this, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, InputPoseActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+EVRInputError __thiscall winIVRInput_IVRInput_007_GetPoseActionDataForNextFrame(winIVRInput_IVRInput_007 *_this, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, winInputPoseActionData_t_1610 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     TRACE("%p\n", _this);
     return cppIVRInput_IVRInput_007_GetPoseActionDataForNextFrame(_this->linux_side, action, eOrigin, pActionData, unActionDataSize, ulRestrictToDevice);
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_007_GetSkeletalActionData, 20)
-EVRInputError __thiscall winIVRInput_IVRInput_007_GetSkeletalActionData(winIVRInput_IVRInput_007 *_this, VRActionHandle_t action, InputSkeletalActionData_t * pActionData, uint32_t unActionDataSize)
+EVRInputError __thiscall winIVRInput_IVRInput_007_GetSkeletalActionData(winIVRInput_IVRInput_007 *_this, VRActionHandle_t action, winInputSkeletalActionData_t_1610 * pActionData, uint32_t unActionDataSize)
 {
     TRACE("%p\n", _this);
     return cppIVRInput_IVRInput_007_GetSkeletalActionData(_this->linux_side, action, pActionData, unActionDataSize);
@@ -365,35 +365,35 @@ EVRInputError __thiscall winIVRInput_IVRInput_006_UpdateActionState(winIVRInput_
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_006_GetDigitalActionData, 28)
-EVRInputError __thiscall winIVRInput_IVRInput_006_GetDigitalActionData(winIVRInput_IVRInput_006 *_this, VRActionHandle_t action, InputDigitalActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+EVRInputError __thiscall winIVRInput_IVRInput_006_GetDigitalActionData(winIVRInput_IVRInput_006 *_this, VRActionHandle_t action, winInputDigitalActionData_t_1418 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     TRACE("%p\n", _this);
     return cppIVRInput_IVRInput_006_GetDigitalActionData(_this->linux_side, action, pActionData, unActionDataSize, ulRestrictToDevice);
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_006_GetAnalogActionData, 28)
-EVRInputError __thiscall winIVRInput_IVRInput_006_GetAnalogActionData(winIVRInput_IVRInput_006 *_this, VRActionHandle_t action, InputAnalogActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+EVRInputError __thiscall winIVRInput_IVRInput_006_GetAnalogActionData(winIVRInput_IVRInput_006 *_this, VRActionHandle_t action, winInputAnalogActionData_t_1418 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     TRACE("%p\n", _this);
     return cppIVRInput_IVRInput_006_GetAnalogActionData(_this->linux_side, action, pActionData, unActionDataSize, ulRestrictToDevice);
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_006_GetPoseActionDataRelativeToNow, 36)
-EVRInputError __thiscall winIVRInput_IVRInput_006_GetPoseActionDataRelativeToNow(winIVRInput_IVRInput_006 *_this, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, InputPoseActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+EVRInputError __thiscall winIVRInput_IVRInput_006_GetPoseActionDataRelativeToNow(winIVRInput_IVRInput_006 *_this, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, winInputPoseActionData_t_1418 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     TRACE("%p\n", _this);
     return cppIVRInput_IVRInput_006_GetPoseActionDataRelativeToNow(_this->linux_side, action, eOrigin, fPredictedSecondsFromNow, pActionData, unActionDataSize, ulRestrictToDevice);
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_006_GetPoseActionDataForNextFrame, 32)
-EVRInputError __thiscall winIVRInput_IVRInput_006_GetPoseActionDataForNextFrame(winIVRInput_IVRInput_006 *_this, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, InputPoseActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+EVRInputError __thiscall winIVRInput_IVRInput_006_GetPoseActionDataForNextFrame(winIVRInput_IVRInput_006 *_this, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, winInputPoseActionData_t_1418 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     TRACE("%p\n", _this);
     return cppIVRInput_IVRInput_006_GetPoseActionDataForNextFrame(_this->linux_side, action, eOrigin, pActionData, unActionDataSize, ulRestrictToDevice);
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_006_GetSkeletalActionData, 20)
-EVRInputError __thiscall winIVRInput_IVRInput_006_GetSkeletalActionData(winIVRInput_IVRInput_006 *_this, VRActionHandle_t action, InputSkeletalActionData_t * pActionData, uint32_t unActionDataSize)
+EVRInputError __thiscall winIVRInput_IVRInput_006_GetSkeletalActionData(winIVRInput_IVRInput_006 *_this, VRActionHandle_t action, winInputSkeletalActionData_t_1418 * pActionData, uint32_t unActionDataSize)
 {
     TRACE("%p\n", _this);
     return cppIVRInput_IVRInput_006_GetSkeletalActionData(_this->linux_side, action, pActionData, unActionDataSize);
@@ -658,28 +658,28 @@ EVRInputError __thiscall winIVRInput_IVRInput_005_UpdateActionState(winIVRInput_
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_005_GetDigitalActionData, 28)
-EVRInputError __thiscall winIVRInput_IVRInput_005_GetDigitalActionData(winIVRInput_IVRInput_005 *_this, VRActionHandle_t action, InputDigitalActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+EVRInputError __thiscall winIVRInput_IVRInput_005_GetDigitalActionData(winIVRInput_IVRInput_005 *_this, VRActionHandle_t action, winInputDigitalActionData_t_1322 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     TRACE("%p\n", _this);
     return cppIVRInput_IVRInput_005_GetDigitalActionData(_this->linux_side, action, pActionData, unActionDataSize, ulRestrictToDevice);
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_005_GetAnalogActionData, 28)
-EVRInputError __thiscall winIVRInput_IVRInput_005_GetAnalogActionData(winIVRInput_IVRInput_005 *_this, VRActionHandle_t action, InputAnalogActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+EVRInputError __thiscall winIVRInput_IVRInput_005_GetAnalogActionData(winIVRInput_IVRInput_005 *_this, VRActionHandle_t action, winInputAnalogActionData_t_1322 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     TRACE("%p\n", _this);
     return cppIVRInput_IVRInput_005_GetAnalogActionData(_this->linux_side, action, pActionData, unActionDataSize, ulRestrictToDevice);
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_005_GetPoseActionData, 36)
-EVRInputError __thiscall winIVRInput_IVRInput_005_GetPoseActionData(winIVRInput_IVRInput_005 *_this, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, InputPoseActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+EVRInputError __thiscall winIVRInput_IVRInput_005_GetPoseActionData(winIVRInput_IVRInput_005 *_this, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, winInputPoseActionData_t_1322 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     TRACE("%p\n", _this);
     return cppIVRInput_IVRInput_005_GetPoseActionData(_this->linux_side, action, eOrigin, fPredictedSecondsFromNow, pActionData, unActionDataSize, ulRestrictToDevice);
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_005_GetSkeletalActionData, 20)
-EVRInputError __thiscall winIVRInput_IVRInput_005_GetSkeletalActionData(winIVRInput_IVRInput_005 *_this, VRActionHandle_t action, InputSkeletalActionData_t * pActionData, uint32_t unActionDataSize)
+EVRInputError __thiscall winIVRInput_IVRInput_005_GetSkeletalActionData(winIVRInput_IVRInput_005 *_this, VRActionHandle_t action, winInputSkeletalActionData_t_1322 * pActionData, uint32_t unActionDataSize)
 {
     TRACE("%p\n", _this);
     return cppIVRInput_IVRInput_005_GetSkeletalActionData(_this->linux_side, action, pActionData, unActionDataSize);
@@ -942,28 +942,28 @@ EVRInputError __thiscall winIVRInput_IVRInput_004_UpdateActionState(winIVRInput_
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_004_GetDigitalActionData, 28)
-EVRInputError __thiscall winIVRInput_IVRInput_004_GetDigitalActionData(winIVRInput_IVRInput_004 *_this, VRActionHandle_t action, InputDigitalActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+EVRInputError __thiscall winIVRInput_IVRInput_004_GetDigitalActionData(winIVRInput_IVRInput_004 *_this, VRActionHandle_t action, winInputDigitalActionData_t_1017 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     TRACE("%p\n", _this);
     return cppIVRInput_IVRInput_004_GetDigitalActionData(_this->linux_side, action, pActionData, unActionDataSize, ulRestrictToDevice);
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_004_GetAnalogActionData, 28)
-EVRInputError __thiscall winIVRInput_IVRInput_004_GetAnalogActionData(winIVRInput_IVRInput_004 *_this, VRActionHandle_t action, InputAnalogActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+EVRInputError __thiscall winIVRInput_IVRInput_004_GetAnalogActionData(winIVRInput_IVRInput_004 *_this, VRActionHandle_t action, winInputAnalogActionData_t_1017 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     TRACE("%p\n", _this);
     return cppIVRInput_IVRInput_004_GetAnalogActionData(_this->linux_side, action, pActionData, unActionDataSize, ulRestrictToDevice);
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_004_GetPoseActionData, 36)
-EVRInputError __thiscall winIVRInput_IVRInput_004_GetPoseActionData(winIVRInput_IVRInput_004 *_this, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, InputPoseActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+EVRInputError __thiscall winIVRInput_IVRInput_004_GetPoseActionData(winIVRInput_IVRInput_004 *_this, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, winInputPoseActionData_t_1017 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     TRACE("%p\n", _this);
     return cppIVRInput_IVRInput_004_GetPoseActionData(_this->linux_side, action, eOrigin, fPredictedSecondsFromNow, pActionData, unActionDataSize, ulRestrictToDevice);
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_004_GetSkeletalActionData, 28)
-EVRInputError __thiscall winIVRInput_IVRInput_004_GetSkeletalActionData(winIVRInput_IVRInput_004 *_this, VRActionHandle_t action, InputSkeletalActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+EVRInputError __thiscall winIVRInput_IVRInput_004_GetSkeletalActionData(winIVRInput_IVRInput_004 *_this, VRActionHandle_t action, winInputSkeletalActionData_t_1017 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     TRACE("%p\n", _this);
     return cppIVRInput_IVRInput_004_GetSkeletalActionData(_this->linux_side, action, pActionData, unActionDataSize, ulRestrictToDevice);
@@ -1163,28 +1163,28 @@ EVRInputError __thiscall winIVRInput_IVRInput_003_UpdateActionState(winIVRInput_
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_003_GetDigitalActionData, 20)
-EVRInputError __thiscall winIVRInput_IVRInput_003_GetDigitalActionData(winIVRInput_IVRInput_003 *_this, VRActionHandle_t action, InputDigitalActionData_t * pActionData, uint32_t unActionDataSize)
+EVRInputError __thiscall winIVRInput_IVRInput_003_GetDigitalActionData(winIVRInput_IVRInput_003 *_this, VRActionHandle_t action, winInputDigitalActionData_t_1015 * pActionData, uint32_t unActionDataSize)
 {
     TRACE("%p\n", _this);
     return cppIVRInput_IVRInput_003_GetDigitalActionData(_this->linux_side, action, pActionData, unActionDataSize);
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_003_GetAnalogActionData, 20)
-EVRInputError __thiscall winIVRInput_IVRInput_003_GetAnalogActionData(winIVRInput_IVRInput_003 *_this, VRActionHandle_t action, InputAnalogActionData_t * pActionData, uint32_t unActionDataSize)
+EVRInputError __thiscall winIVRInput_IVRInput_003_GetAnalogActionData(winIVRInput_IVRInput_003 *_this, VRActionHandle_t action, winInputAnalogActionData_t_1015 * pActionData, uint32_t unActionDataSize)
 {
     TRACE("%p\n", _this);
     return cppIVRInput_IVRInput_003_GetAnalogActionData(_this->linux_side, action, pActionData, unActionDataSize);
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_003_GetPoseActionData, 28)
-EVRInputError __thiscall winIVRInput_IVRInput_003_GetPoseActionData(winIVRInput_IVRInput_003 *_this, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, InputPoseActionData_t * pActionData, uint32_t unActionDataSize)
+EVRInputError __thiscall winIVRInput_IVRInput_003_GetPoseActionData(winIVRInput_IVRInput_003 *_this, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, winInputPoseActionData_t_1015 * pActionData, uint32_t unActionDataSize)
 {
     TRACE("%p\n", _this);
     return cppIVRInput_IVRInput_003_GetPoseActionData(_this->linux_side, action, eOrigin, fPredictedSecondsFromNow, pActionData, unActionDataSize);
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_003_GetSkeletalActionData, 36)
-EVRInputError __thiscall winIVRInput_IVRInput_003_GetSkeletalActionData(winIVRInput_IVRInput_003 *_this, VRActionHandle_t action, EVRSkeletalTransformSpace eBoneParent, float fPredictedSecondsFromNow, InputSkeletonActionData_t * pActionData, uint32_t unActionDataSize, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount)
+EVRInputError __thiscall winIVRInput_IVRInput_003_GetSkeletalActionData(winIVRInput_IVRInput_003 *_this, VRActionHandle_t action, EVRSkeletalTransformSpace eBoneParent, float fPredictedSecondsFromNow, winInputSkeletonActionData_t_1015 * pActionData, uint32_t unActionDataSize, VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount)
 {
     TRACE("%p\n", _this);
     return cppIVRInput_IVRInput_003_GetSkeletalActionData(_this->linux_side, action, eBoneParent, fPredictedSecondsFromNow, pActionData, unActionDataSize, pTransformArray, unTransformArrayCount);
diff --git a/vrclient_x64/vrclient_x64/winIVRTrackedCamera.c b/vrclient_x64/vrclient_x64/winIVRTrackedCamera.c
index 8ff25fa7..122ae5b2 100644
--- a/vrclient_x64/vrclient_x64/winIVRTrackedCamera.c
+++ b/vrclient_x64/vrclient_x64/winIVRTrackedCamera.c
@@ -75,7 +75,7 @@ EVRTrackedCameraError __thiscall winIVRTrackedCamera_IVRTrackedCamera_005_Releas
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamFrameBuffer, 32)
-EVRTrackedCameraError __thiscall winIVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamFrameBuffer(winIVRTrackedCamera_IVRTrackedCamera_005 *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pFrameBuffer, uint32_t nFrameBufferSize, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize)
+EVRTrackedCameraError __thiscall winIVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamFrameBuffer(winIVRTrackedCamera_IVRTrackedCamera_005 *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pFrameBuffer, uint32_t nFrameBufferSize, winCameraVideoStreamFrameHeader_t_1610 * pFrameHeader, uint32_t nFrameHeaderSize)
 {
     TRACE("%p\n", _this);
     return cppIVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamFrameBuffer(_this->linux_side, hTrackedCamera, eFrameType, pFrameBuffer, nFrameBufferSize, pFrameHeader, nFrameHeaderSize);
@@ -89,14 +89,14 @@ EVRTrackedCameraError __thiscall winIVRTrackedCamera_IVRTrackedCamera_005_GetVid
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamTextureD3D11, 32)
-EVRTrackedCameraError __thiscall winIVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamTextureD3D11(winIVRTrackedCamera_IVRTrackedCamera_005 *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize)
+EVRTrackedCameraError __thiscall winIVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamTextureD3D11(winIVRTrackedCamera_IVRTrackedCamera_005 *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView, winCameraVideoStreamFrameHeader_t_1610 * pFrameHeader, uint32_t nFrameHeaderSize)
 {
     TRACE("%p\n", _this);
     return cppIVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamTextureD3D11(_this->linux_side, hTrackedCamera, eFrameType, pD3D11DeviceOrResource, ppD3D11ShaderResourceView, pFrameHeader, nFrameHeaderSize);
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamTextureGL, 28)
-EVRTrackedCameraError __thiscall winIVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamTextureGL(winIVRTrackedCamera_IVRTrackedCamera_005 *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, glUInt_t * pglTextureId, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize)
+EVRTrackedCameraError __thiscall winIVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamTextureGL(winIVRTrackedCamera_IVRTrackedCamera_005 *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, glUInt_t * pglTextureId, winCameraVideoStreamFrameHeader_t_1610 * pFrameHeader, uint32_t nFrameHeaderSize)
 {
     TRACE("%p\n", _this);
     return cppIVRTrackedCamera_IVRTrackedCamera_005_GetVideoStreamTextureGL(_this->linux_side, hTrackedCamera, eFrameType, pglTextureId, pFrameHeader, nFrameHeaderSize);
@@ -240,7 +240,7 @@ EVRTrackedCameraError __thiscall winIVRTrackedCamera_IVRTrackedCamera_004_Releas
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamFrameBuffer, 32)
-EVRTrackedCameraError __thiscall winIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamFrameBuffer(winIVRTrackedCamera_IVRTrackedCamera_004 *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pFrameBuffer, uint32_t nFrameBufferSize, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize)
+EVRTrackedCameraError __thiscall winIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamFrameBuffer(winIVRTrackedCamera_IVRTrackedCamera_004 *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pFrameBuffer, uint32_t nFrameBufferSize, winCameraVideoStreamFrameHeader_t_1017 * pFrameHeader, uint32_t nFrameHeaderSize)
 {
     TRACE("%p\n", _this);
     return cppIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamFrameBuffer(_this->linux_side, hTrackedCamera, eFrameType, pFrameBuffer, nFrameBufferSize, pFrameHeader, nFrameHeaderSize);
@@ -254,14 +254,14 @@ EVRTrackedCameraError __thiscall winIVRTrackedCamera_IVRTrackedCamera_004_GetVid
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureD3D11, 32)
-EVRTrackedCameraError __thiscall winIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureD3D11(winIVRTrackedCamera_IVRTrackedCamera_004 *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize)
+EVRTrackedCameraError __thiscall winIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureD3D11(winIVRTrackedCamera_IVRTrackedCamera_004 *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView, winCameraVideoStreamFrameHeader_t_1017 * pFrameHeader, uint32_t nFrameHeaderSize)
 {
     TRACE("%p\n", _this);
     return cppIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureD3D11(_this->linux_side, hTrackedCamera, eFrameType, pD3D11DeviceOrResource, ppD3D11ShaderResourceView, pFrameHeader, nFrameHeaderSize);
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureGL, 28)
-EVRTrackedCameraError __thiscall winIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureGL(winIVRTrackedCamera_IVRTrackedCamera_004 *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, glUInt_t * pglTextureId, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize)
+EVRTrackedCameraError __thiscall winIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureGL(winIVRTrackedCamera_IVRTrackedCamera_004 *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, glUInt_t * pglTextureId, winCameraVideoStreamFrameHeader_t_1017 * pFrameHeader, uint32_t nFrameHeaderSize)
 {
     TRACE("%p\n", _this);
     return cppIVRTrackedCamera_IVRTrackedCamera_004_GetVideoStreamTextureGL(_this->linux_side, hTrackedCamera, eFrameType, pglTextureId, pFrameHeader, nFrameHeaderSize);