Uses of Annotation Interface
club.doki7.ffm.annotation.Unsafe

Packages that use Unsafe

Package	Description
club.doki7.ffm	Utility library for Java 22 FFM (Project Panama) APIs.
club.doki7.ffm.ptr	Utility classes encapsulating MemorySegment, providing type-safe way to access native memory.
club.doki7.glfw.datatype
club.doki7.glfw.handle
club.doki7.openal.handle
club.doki7.opencl.datatype
club.doki7.opencl.handle
club.doki7.opengl.handle
club.doki7.openxr.datatype
club.doki7.openxr.handle
club.doki7.sdl3.datatype
club.doki7.sdl3.handle
club.doki7.shaderc.datatype
club.doki7.shaderc.handle
club.doki7.stb.image.datatype
club.doki7.stb.imageresize.datatype
club.doki7.stb.imageresize.handle
club.doki7.stb.truetype.datatype
club.doki7.stb.vorbis.datatype
club.doki7.stb.vorbis.handle
club.doki7.vma.datatype
club.doki7.vma.handle
club.doki7.vulkan.datatype	Structure (struct or union) types of Vulkan API.
club.doki7.vulkan.handle	Opaque handle types of Vulkan API.
club.doki7.webgpu.datatype
club.doki7.webgpu.handle

Uses of Unsafe in club.doki7.ffm

Methods in club.doki7.ffm with annotations of type Unsafe

Modifier and Type	Method	Description
void	LibcArena.freeNonAllocated(@NotNull MemorySegment ms)	Frees memory that was allocated by libc allocator, but not via LibcArena.allocate(long, long).

Uses of Unsafe in club.doki7.ffm.ptr

Methods in club.doki7.ffm.ptr with annotations of type Unsafe

Modifier and Type	Method	Description
@NotNull String	BytePtr.readString()	Assumes the BytePtr is a null-terminated string, reads the string from the beginning of the underlying memory segment, until the first NUL byte is encountered.
@NotNull String	WCharPtr.readWString()	(Windows only) Assume the WCharPtr is a Windows wide character string, reads the wide string from the beginning of the underlying memory segment, until the first NUL byte is encountered.
@NotNull BytePtr	BytePtr.reinterpret(long newSize)	Assume the BytePtr is capable of holding at least newSize bytes, create a new view BytePtr that uses the same backing storage as this BytePtr, but with the new size.
@NotNull CLongPtr	CLongPtr.reinterpret(long newSize)	Assume the CLongPtr is capable of holding at least newSize elements, create a new view CLongPtr that uses the same backing storage as this CLongPtr, but with the new size.
@NotNull DoublePtr	DoublePtr.reinterpret(long newSize)	Assume the DoublePtr is capable of holding at least newSize doubles, create a new view DoublePtr that uses the same backing storage as this DoublePtr, but with the new size.
@NotNull FloatPtr	FloatPtr.reinterpret(long newSize)	Assume the FloatPtr is capable of holding at least newSize floats, create a new view FloatPtr that uses the same backing storage as this FloatPtr, but with the new size.
@NotNull IntPtr	IntPtr.reinterpret(long newSize)	Assume the IntPtr is capable of holding at least newSize integers, create a new view IntPtr that uses the same backing storage as this IntPtr, but with the new size.
@NotNull LongPtr	LongPtr.reinterpret(long newSize)	Assume the LongPtr is capable of holding at least newSize long integers, create a new view LongPtr that uses the same backing storage as this LongPtr, but with the new size.
@NotNull PointerPtr	PointerPtr.reinterpret(long newSize)	Assume the PointerPtr is capable of holding at least newSize pointers, create a new view PointerPtr that uses the same backing storage as this PointerPtr, but with the new size.
@NotNull ShortPtr	ShortPtr.reinterpret(long newSize)	Assume the ShortPtr is capable of holding at least newSize short integers, create a new view ShortPtr that uses the same backing storage as this ShortPtr, but with the new size.

Uses of Unsafe in club.doki7.glfw.datatype

Methods in club.doki7.glfw.datatype with annotations of type Unsafe

Modifier and Type	Method	Description
@NotNull GLFWallocator.Ptr	GLFWallocator.Ptr.reinterpret(long newSize)	Assume the GLFWallocator.Ptr is capable of holding at least newSize structures, create a new view GLFWallocator.Ptr that uses the same backing storage as this GLFWallocator.Ptr, but with the new size.
@NotNull GLFWgamepadstate.Ptr	GLFWgamepadstate.Ptr.reinterpret(long newSize)	Assume the GLFWgamepadstate.Ptr is capable of holding at least newSize structures, create a new view GLFWgamepadstate.Ptr that uses the same backing storage as this GLFWgamepadstate.Ptr, but with the new size.
@NotNull GLFWgammaramp.Ptr	GLFWgammaramp.Ptr.reinterpret(long newSize)	Assume the GLFWgammaramp.Ptr is capable of holding at least newSize structures, create a new view GLFWgammaramp.Ptr that uses the same backing storage as this GLFWgammaramp.Ptr, but with the new size.
@NotNull GLFWimage.Ptr	GLFWimage.Ptr.reinterpret(long newSize)	Assume the GLFWimage.Ptr is capable of holding at least newSize structures, create a new view GLFWimage.Ptr that uses the same backing storage as this GLFWimage.Ptr, but with the new size.
@NotNull GLFWvidmode.Ptr	GLFWvidmode.Ptr.reinterpret(long newSize)	Assume the GLFWvidmode.Ptr is capable of holding at least newSize structures, create a new view GLFWvidmode.Ptr that uses the same backing storage as this GLFWvidmode.Ptr, but with the new size.

Uses of Unsafe in club.doki7.glfw.handle

Methods in club.doki7.glfw.handle with annotations of type Unsafe

Modifier and Type	Method	Description
GLFWcursor.Ptr	GLFWcursor.Ptr.reinterpret(long newSize)	Assume the GLFWcursor.Ptr is capable of holding at least newSize handles, create a new view GLFWcursor.Ptr that uses the same backing storage as this GLFWcursor.Ptr, but with the new size.
GLFWmonitor.Ptr	GLFWmonitor.Ptr.reinterpret(long newSize)	Assume the GLFWmonitor.Ptr is capable of holding at least newSize handles, create a new view GLFWmonitor.Ptr that uses the same backing storage as this GLFWmonitor.Ptr, but with the new size.
GLFWwindow.Ptr	GLFWwindow.Ptr.reinterpret(long newSize)	Assume the GLFWwindow.Ptr is capable of holding at least newSize handles, create a new view GLFWwindow.Ptr that uses the same backing storage as this GLFWwindow.Ptr, but with the new size.

Uses of Unsafe in club.doki7.openal.handle

Methods in club.doki7.openal.handle with annotations of type Unsafe

Modifier and Type	Method	Description
_GUID.Ptr	_GUID.Ptr.reinterpret(long newSize)	Assume the _GUID.Ptr is capable of holding at least newSize handles, create a new view _GUID.Ptr that uses the same backing storage as this _GUID.Ptr, but with the new size.
ALCcontext.Ptr	ALCcontext.Ptr.reinterpret(long newSize)	Assume the ALCcontext.Ptr is capable of holding at least newSize handles, create a new view ALCcontext.Ptr that uses the same backing storage as this ALCcontext.Ptr, but with the new size.
ALCdevice.Ptr	ALCdevice.Ptr.reinterpret(long newSize)	Assume the ALCdevice.Ptr is capable of holding at least newSize handles, create a new view ALCdevice.Ptr that uses the same backing storage as this ALCdevice.Ptr, but with the new size.

Uses of Unsafe in club.doki7.opencl.datatype

Methods in club.doki7.opencl.datatype with annotations of type Unsafe

Modifier and Type	Method	Description
CLMutableDispatchArgKhr.Ptr	CLMutableDispatchConfigKhr.argList(int assumedCount)
CLMutableDispatchArgKhr.Ptr	CLMutableDispatchConfigKhr.argSvmList(int assumedCount)
CLMutableDispatchExecInfoKhr.Ptr	CLMutableDispatchConfigKhr.execInfoList(int assumedCount)
@NotNull CLBufferRegion.Ptr	CLBufferRegion.Ptr.reinterpret(long newSize)	Assume the CLBufferRegion.Ptr is capable of holding at least newSize structures, create a new view CLBufferRegion.Ptr that uses the same backing storage as this CLBufferRegion.Ptr, but with the new size.
@NotNull CLDeviceIntegerDotProductAccelerationPropertiesKhr.Ptr	CLDeviceIntegerDotProductAccelerationPropertiesKhr.Ptr.reinterpret(long newSize)	Assume the CLDeviceIntegerDotProductAccelerationPropertiesKhr.Ptr is capable of holding at least newSize structures, create a new view CLDeviceIntegerDotProductAccelerationPropertiesKhr.Ptr that uses the same backing storage as this CLDeviceIntegerDotProductAccelerationPropertiesKhr.Ptr, but with the new size.
@NotNull CLDevicePciBusInfoKhr.Ptr	CLDevicePciBusInfoKhr.Ptr.reinterpret(long newSize)	Assume the CLDevicePciBusInfoKhr.Ptr is capable of holding at least newSize structures, create a new view CLDevicePciBusInfoKhr.Ptr that uses the same backing storage as this CLDevicePciBusInfoKhr.Ptr, but with the new size.
@NotNull CLDx9SurfaceInfoKhr.Ptr	CLDx9SurfaceInfoKhr.Ptr.reinterpret(long newSize)	Assume the CLDx9SurfaceInfoKhr.Ptr is capable of holding at least newSize structures, create a new view CLDx9SurfaceInfoKhr.Ptr that uses the same backing storage as this CLDx9SurfaceInfoKhr.Ptr, but with the new size.
@NotNull CLImageDesc.Ptr	CLImageDesc.Ptr.reinterpret(long newSize)	Assume the CLImageDesc.Ptr is capable of holding at least newSize structures, create a new view CLImageDesc.Ptr that uses the same backing storage as this CLImageDesc.Ptr, but with the new size.
@NotNull CLImageDescBufferOrMemObject.Ptr	CLImageDescBufferOrMemObject.Ptr.reinterpret(long newSize)	Assume the CLImageDescBufferOrMemObject.Ptr is capable of holding at least newSize structures, create a new view CLImageDescBufferOrMemObject.Ptr that uses the same backing storage as this CLImageDescBufferOrMemObject.Ptr, but with the new size.
@NotNull CLImageFormat.Ptr	CLImageFormat.Ptr.reinterpret(long newSize)	Assume the CLImageFormat.Ptr is capable of holding at least newSize structures, create a new view CLImageFormat.Ptr that uses the same backing storage as this CLImageFormat.Ptr, but with the new size.
@NotNull CLMemAndroidNativeBufferHostPtr.Ptr	CLMemAndroidNativeBufferHostPtr.Ptr.reinterpret(long newSize)	Assume the CLMemAndroidNativeBufferHostPtr.Ptr is capable of holding at least newSize structures, create a new view CLMemAndroidNativeBufferHostPtr.Ptr that uses the same backing storage as this CLMemAndroidNativeBufferHostPtr.Ptr, but with the new size.
@NotNull CLMemExtHostPtr.Ptr	CLMemExtHostPtr.Ptr.reinterpret(long newSize)	Assume the CLMemExtHostPtr.Ptr is capable of holding at least newSize structures, create a new view CLMemExtHostPtr.Ptr that uses the same backing storage as this CLMemExtHostPtr.Ptr, but with the new size.
@NotNull CLMemIonHostPtr.Ptr	CLMemIonHostPtr.Ptr.reinterpret(long newSize)	Assume the CLMemIonHostPtr.Ptr is capable of holding at least newSize structures, create a new view CLMemIonHostPtr.Ptr that uses the same backing storage as this CLMemIonHostPtr.Ptr, but with the new size.
@NotNull CLMotionEstimationDescIntel.Ptr	CLMotionEstimationDescIntel.Ptr.reinterpret(long newSize)	Assume the CLMotionEstimationDescIntel.Ptr is capable of holding at least newSize structures, create a new view CLMotionEstimationDescIntel.Ptr that uses the same backing storage as this CLMotionEstimationDescIntel.Ptr, but with the new size.
@NotNull CLMutableDispatchArgKhr.Ptr	CLMutableDispatchArgKhr.Ptr.reinterpret(long newSize)	Assume the CLMutableDispatchArgKhr.Ptr is capable of holding at least newSize structures, create a new view CLMutableDispatchArgKhr.Ptr that uses the same backing storage as this CLMutableDispatchArgKhr.Ptr, but with the new size.
@NotNull CLMutableDispatchConfigKhr.Ptr	CLMutableDispatchConfigKhr.Ptr.reinterpret(long newSize)	Assume the CLMutableDispatchConfigKhr.Ptr is capable of holding at least newSize structures, create a new view CLMutableDispatchConfigKhr.Ptr that uses the same backing storage as this CLMutableDispatchConfigKhr.Ptr, but with the new size.
@NotNull CLMutableDispatchExecInfoKhr.Ptr	CLMutableDispatchExecInfoKhr.Ptr.reinterpret(long newSize)	Assume the CLMutableDispatchExecInfoKhr.Ptr is capable of holding at least newSize structures, create a new view CLMutableDispatchExecInfoKhr.Ptr that uses the same backing storage as this CLMutableDispatchExecInfoKhr.Ptr, but with the new size.
@NotNull CLNameVersion.Ptr	CLNameVersion.Ptr.reinterpret(long newSize)	Assume the CLNameVersion.Ptr is capable of holding at least newSize structures, create a new view CLNameVersion.Ptr that uses the same backing storage as this CLNameVersion.Ptr, but with the new size.
@NotNull CLNameVersionKhr.Ptr	CLNameVersionKhr.Ptr.reinterpret(long newSize)	Assume the CLNameVersionKhr.Ptr is capable of holding at least newSize structures, create a new view CLNameVersionKhr.Ptr that uses the same backing storage as this CLNameVersionKhr.Ptr, but with the new size.
@NotNull CLQueueFamilyPropertiesIntel.Ptr	CLQueueFamilyPropertiesIntel.Ptr.reinterpret(long newSize)	Assume the CLQueueFamilyPropertiesIntel.Ptr is capable of holding at least newSize structures, create a new view CLQueueFamilyPropertiesIntel.Ptr that uses the same backing storage as this CLQueueFamilyPropertiesIntel.Ptr, but with the new size.
@NotNull VAImageFormatCLREF.Ptr	VAImageFormatCLREF.Ptr.reinterpret(long newSize)	Assume the VAImageFormatCLREF.Ptr is capable of holding at least newSize structures, create a new view VAImageFormatCLREF.Ptr that uses the same backing storage as this VAImageFormatCLREF.Ptr, but with the new size.

Uses of Unsafe in club.doki7.opencl.handle

Methods in club.doki7.opencl.handle with annotations of type Unsafe

Modifier and Type	Method	Description
CLAcceleratorIntel.Ptr	CLAcceleratorIntel.Ptr.reinterpret(long newSize)	Assume the CLAcceleratorIntel.Ptr is capable of holding at least newSize handles, create a new view CLAcceleratorIntel.Ptr that uses the same backing storage as this CLAcceleratorIntel.Ptr, but with the new size.
CLCommandBufferKhr.Ptr	CLCommandBufferKhr.Ptr.reinterpret(long newSize)	Assume the CLCommandBufferKhr.Ptr is capable of holding at least newSize handles, create a new view CLCommandBufferKhr.Ptr that uses the same backing storage as this CLCommandBufferKhr.Ptr, but with the new size.
CLCommandQueue.Ptr	CLCommandQueue.Ptr.reinterpret(long newSize)	Assume the CLCommandQueue.Ptr is capable of holding at least newSize handles, create a new view CLCommandQueue.Ptr that uses the same backing storage as this CLCommandQueue.Ptr, but with the new size.
CLContext.Ptr	CLContext.Ptr.reinterpret(long newSize)	Assume the CLContext.Ptr is capable of holding at least newSize handles, create a new view CLContext.Ptr that uses the same backing storage as this CLContext.Ptr, but with the new size.
CLDeviceId.Ptr	CLDeviceId.Ptr.reinterpret(long newSize)	Assume the CLDeviceId.Ptr is capable of holding at least newSize handles, create a new view CLDeviceId.Ptr that uses the same backing storage as this CLDeviceId.Ptr, but with the new size.
CLEvent.Ptr	CLEvent.Ptr.reinterpret(long newSize)	Assume the CLEvent.Ptr is capable of holding at least newSize handles, create a new view CLEvent.Ptr that uses the same backing storage as this CLEvent.Ptr, but with the new size.
CLGLsync.Ptr	CLGLsync.Ptr.reinterpret(long newSize)	Assume the CLGLsync.Ptr is capable of holding at least newSize handles, create a new view CLGLsync.Ptr that uses the same backing storage as this CLGLsync.Ptr, but with the new size.
CLIcdDispatch.Ptr	CLIcdDispatch.Ptr.reinterpret(long newSize)	Assume the CLIcdDispatch.Ptr is capable of holding at least newSize handles, create a new view CLIcdDispatch.Ptr that uses the same backing storage as this CLIcdDispatch.Ptr, but with the new size.
CLKernel.Ptr	CLKernel.Ptr.reinterpret(long newSize)	Assume the CLKernel.Ptr is capable of holding at least newSize handles, create a new view CLKernel.Ptr that uses the same backing storage as this CLKernel.Ptr, but with the new size.
CLMem.Ptr	CLMem.Ptr.reinterpret(long newSize)	Assume the CLMem.Ptr is capable of holding at least newSize handles, create a new view CLMem.Ptr that uses the same backing storage as this CLMem.Ptr, but with the new size.
CLMutableCommandKhr.Ptr	CLMutableCommandKhr.Ptr.reinterpret(long newSize)	Assume the CLMutableCommandKhr.Ptr is capable of holding at least newSize handles, create a new view CLMutableCommandKhr.Ptr that uses the same backing storage as this CLMutableCommandKhr.Ptr, but with the new size.
CLPlatformId.Ptr	CLPlatformId.Ptr.reinterpret(long newSize)	Assume the CLPlatformId.Ptr is capable of holding at least newSize handles, create a new view CLPlatformId.Ptr that uses the same backing storage as this CLPlatformId.Ptr, but with the new size.
CLProgram.Ptr	CLProgram.Ptr.reinterpret(long newSize)	Assume the CLProgram.Ptr is capable of holding at least newSize handles, create a new view CLProgram.Ptr that uses the same backing storage as this CLProgram.Ptr, but with the new size.
CLSampler.Ptr	CLSampler.Ptr.reinterpret(long newSize)	Assume the CLSampler.Ptr is capable of holding at least newSize handles, create a new view CLSampler.Ptr that uses the same backing storage as this CLSampler.Ptr, but with the new size.
CLSemaphoreKhr.Ptr	CLSemaphoreKhr.Ptr.reinterpret(long newSize)	Assume the CLSemaphoreKhr.Ptr is capable of holding at least newSize handles, create a new view CLSemaphoreKhr.Ptr that uses the same backing storage as this CLSemaphoreKhr.Ptr, but with the new size.

Uses of Unsafe in club.doki7.opengl.handle

Methods in club.doki7.opengl.handle with annotations of type Unsafe

Modifier and Type	Method	Description
GLeglClientBufferEXT.Ptr	GLeglClientBufferEXT.Ptr.reinterpret(long newSize)	Assume the GLeglClientBufferEXT.Ptr is capable of holding at least newSize handles, create a new view GLeglClientBufferEXT.Ptr that uses the same backing storage as this GLeglClientBufferEXT.Ptr, but with the new size.
GLeglImageOES.Ptr	GLeglImageOES.Ptr.reinterpret(long newSize)	Assume the GLeglImageOES.Ptr is capable of holding at least newSize handles, create a new view GLeglImageOES.Ptr that uses the same backing storage as this GLeglImageOES.Ptr, but with the new size.
GLsync.Ptr	GLsync.Ptr.reinterpret(long newSize)	Assume the GLsync.Ptr is capable of holding at least newSize handles, create a new view GLsync.Ptr that uses the same backing storage as this GLsync.Ptr, but with the new size.

Uses of Unsafe in club.doki7.openxr.datatype

Methods in club.doki7.openxr.datatype with annotations of type Unsafe

Modifier and Type	Method	Description
XrActiveActionSetPriorityEXT.Ptr	XrActiveActionSetPrioritiesEXT.actionSetPriorities(int assumedCount)
XrActiveActionSet.Ptr	XrActionsSyncInfo.activeActionSets(int assumedCount)
XrWorldMeshBlockRequestML.Ptr	XrWorldMeshGetInfoML.blocks(int assumedCount)
XrWorldMeshBlockML.Ptr	XrWorldMeshRequestCompletionML.blocks(int assumedCount)
XrSpatialBounded2DDataEXT.Ptr	XrSpatialComponentBounded2DListEXT.bounds(int assumedCount)
XrBoxf.Ptr	XrSpatialComponentBounded3DListEXT.bounds(int assumedCount)
XrSceneOrientedBoxBoundMSFT.Ptr	XrSceneBoundsMSFT.boxes(int assumedCount)
XrUuidMSFT.Ptr	XrSceneComponentsLocateInfoMSFT.componentIds(int assumedCount)
XrSceneComponentMSFT.Ptr	XrSceneComponentsMSFT.components(int assumedCount)
XrFoveationConfigurationHTC.Ptr	XrFoveationCustomModeInfoHTC.configs(int assumedCount)
XrSpaceFilterInfoBaseHeaderFB.Ptr	XrSpaceQueryInfoFB.excludeFilter(int assumedCount)
XrSpaceFilterInfoBaseHeaderFB.Ptr	XrSpaceQueryInfoFB.filter(int assumedCount)
XrDeserializeSceneFragmentMSFT.Ptr	XrSceneDeserializeInfoMSFT.fragments(int assumedCount)
XrSceneFrustumBoundMSFT.Ptr	XrSceneBoundsMSFT.frustums(int assumedCount)
XrUuid.Ptr	XrShareSpacesRecipientGroupsMETA.groups(int assumedCount)
XrPosef.Ptr	XrHandTrackingMeshFB.jointBindPoses(int assumedCount)
XrBodyJointLocationBD.Ptr	XrBodyJointLocationsBD.jointLocations(int assumedCount)
XrBodyJointLocationFB.Ptr	XrBodyJointLocationsFB.jointLocations(int assumedCount)
XrBodyJointLocationHTC.Ptr	XrBodyJointLocationsHTC.jointLocations(int assumedCount)
XrHandJointLocationEXT.Ptr	XrHandJointLocationsEXT.jointLocations(int assumedCount)
XrBodySkeletonJointFB.Ptr	XrBodySkeletonFB.joints(int assumedCount)
XrBodySkeletonJointHTC.Ptr	XrBodySkeletonHTC.joints(int assumedCount)
XrHandJointVelocityEXT.Ptr	XrHandJointVelocitiesEXT.jointVelocities(int assumedCount)
XrCompositionLayerBaseHeader.Ptr	XrRecommendedLayerResolutionGetInfoMETA.layer(int assumedCount)
XrForceFeedbackCurlApplyLocationMNDX.Ptr	XrForceFeedbackCurlApplyLocationsMNDX.locations(int assumedCount)
XrSceneComponentLocationMSFT.Ptr	XrSceneComponentLocationsMSFT.locations(int assumedCount)
XrSpaceLocationData.Ptr	XrSpaceLocations.locations(int assumedCount)
XrSpaceLocationData.Ptr	XrSpaceLocationsKHR.locations(int assumedCount)
XrPosef.Ptr	XrSpatialComponentAnchorListEXT.locations(int assumedCount)
XrSpatialMarkerDataEXT.Ptr	XrSpatialComponentMarkerListEXT.markers(int assumedCount)
XrWorldMeshBlockStateML.Ptr	XrWorldMeshStateRequestCompletionML.meshBlockStates(int assumedCount)
XrSpatialMeshDataEXT.Ptr	XrSpatialComponentMesh2DListEXT.meshes(int assumedCount)
XrSpatialMeshDataEXT.Ptr	XrSpatialComponentMesh3DListEXT.meshes(int assumedCount)
XrApiLayerNextInfo.Ptr	XrApiLayerNextInfo.next(int assumedCount)
XrBaseInStructure.Ptr	XrBaseInStructure.next(int assumedCount)
XrBaseOutStructure.Ptr	XrBaseOutStructure.next(int assumedCount)
XrApiLayerNextInfo.Ptr	XrApiLayerCreateInfo.nextInfo(int assumedCount)
XrControllerModelNodePropertiesMSFT.Ptr	XrControllerModelPropertiesMSFT.nodeProperties(int assumedCount)
XrRenderModelAssetNodePropertiesEXT.Ptr	XrRenderModelAssetPropertiesEXT.nodeProperties(int assumedCount)
XrControllerModelNodeStateMSFT.Ptr	XrControllerModelStateMSFT.nodeStates(int assumedCount)
XrRenderModelNodeStateEXT.Ptr	XrRenderModelStateEXT.nodeStates(int assumedCount)
XrVector3f.Ptr	XrWorldMeshBlockML.normalBuffer(int assumedCount)
XrDebugUtilsObjectNameInfoEXT.Ptr	XrDebugUtilsMessengerCallbackDataEXT.objects(int assumedCount)
XrHapticBaseHeader.Ptr	XrInteractionProfileAnalogThresholdVALVE.offHaptic(int assumedCount)
XrHapticBaseHeader.Ptr	XrInteractionProfileDpadBindingEXT.offHaptic(int assumedCount)
XrHapticBaseHeader.Ptr	XrInteractionProfileAnalogThresholdVALVE.onHaptic(int assumedCount)
XrHapticBaseHeader.Ptr	XrInteractionProfileDpadBindingEXT.onHaptic(int assumedCount)
XrViveTrackerPathsHTCX.Ptr	XrEventDataViveTrackerConnectedHTCX.paths(int assumedCount)
XrSpatialPersistenceDataEXT.Ptr	XrSpatialComponentPersistenceListEXT.persistData(int assumedCount)
XrUuid.Ptr	XrSpatialDiscoveryPersistenceUuidFilterEXT.persistedUuids(int assumedCount)
XrPlaneDetectorLocationEXT.Ptr	XrPlaneDetectorLocationsEXT.planeLocations(int assumedCount)
XrSpatialPolygon2DDataEXT.Ptr	XrSpatialComponentPolygon2DListEXT.polygons(int assumedCount)
XrSceneMarkerQRCodeMSFT.Ptr	XrSceneMarkerQRCodesMSFT.qrCodes(int assumedCount)
XrShareSpacesRecipientBaseHeaderMETA.Ptr	XrShareSpacesInfoMETA.recipientInfo(int assumedCount)
@NotNull LUID.Ptr	LUID.Ptr.reinterpret(long newSize)	Assume the LUID.Ptr is capable of holding at least newSize structures, create a new view LUID.Ptr that uses the same backing storage as this LUID.Ptr, but with the new size.
@NotNull MLCoordinateFrameUID.Ptr	MLCoordinateFrameUID.Ptr.reinterpret(long newSize)	Assume the MLCoordinateFrameUID.Ptr is capable of holding at least newSize structures, create a new view MLCoordinateFrameUID.Ptr that uses the same backing storage as this MLCoordinateFrameUID.Ptr, but with the new size.
@NotNull XrActionCreateInfo.Ptr	XrActionCreateInfo.Ptr.reinterpret(long newSize)	Assume the XrActionCreateInfo.Ptr is capable of holding at least newSize structures, create a new view XrActionCreateInfo.Ptr that uses the same backing storage as this XrActionCreateInfo.Ptr, but with the new size.
@NotNull XrActionSetCreateInfo.Ptr	XrActionSetCreateInfo.Ptr.reinterpret(long newSize)	Assume the XrActionSetCreateInfo.Ptr is capable of holding at least newSize structures, create a new view XrActionSetCreateInfo.Ptr that uses the same backing storage as this XrActionSetCreateInfo.Ptr, but with the new size.
@NotNull XrActionSpaceCreateInfo.Ptr	XrActionSpaceCreateInfo.Ptr.reinterpret(long newSize)	Assume the XrActionSpaceCreateInfo.Ptr is capable of holding at least newSize structures, create a new view XrActionSpaceCreateInfo.Ptr that uses the same backing storage as this XrActionSpaceCreateInfo.Ptr, but with the new size.
@NotNull XrActionsSyncInfo.Ptr	XrActionsSyncInfo.Ptr.reinterpret(long newSize)	Assume the XrActionsSyncInfo.Ptr is capable of holding at least newSize structures, create a new view XrActionsSyncInfo.Ptr that uses the same backing storage as this XrActionsSyncInfo.Ptr, but with the new size.
@NotNull XrActionStateBoolean.Ptr	XrActionStateBoolean.Ptr.reinterpret(long newSize)	Assume the XrActionStateBoolean.Ptr is capable of holding at least newSize structures, create a new view XrActionStateBoolean.Ptr that uses the same backing storage as this XrActionStateBoolean.Ptr, but with the new size.
@NotNull XrActionStateFloat.Ptr	XrActionStateFloat.Ptr.reinterpret(long newSize)	Assume the XrActionStateFloat.Ptr is capable of holding at least newSize structures, create a new view XrActionStateFloat.Ptr that uses the same backing storage as this XrActionStateFloat.Ptr, but with the new size.
@NotNull XrActionStateGetInfo.Ptr	XrActionStateGetInfo.Ptr.reinterpret(long newSize)	Assume the XrActionStateGetInfo.Ptr is capable of holding at least newSize structures, create a new view XrActionStateGetInfo.Ptr that uses the same backing storage as this XrActionStateGetInfo.Ptr, but with the new size.
@NotNull XrActionStatePose.Ptr	XrActionStatePose.Ptr.reinterpret(long newSize)	Assume the XrActionStatePose.Ptr is capable of holding at least newSize structures, create a new view XrActionStatePose.Ptr that uses the same backing storage as this XrActionStatePose.Ptr, but with the new size.
@NotNull XrActionStateVector2f.Ptr	XrActionStateVector2f.Ptr.reinterpret(long newSize)	Assume the XrActionStateVector2f.Ptr is capable of holding at least newSize structures, create a new view XrActionStateVector2f.Ptr that uses the same backing storage as this XrActionStateVector2f.Ptr, but with the new size.
@NotNull XrActionSuggestedBinding.Ptr	XrActionSuggestedBinding.Ptr.reinterpret(long newSize)	Assume the XrActionSuggestedBinding.Ptr is capable of holding at least newSize structures, create a new view XrActionSuggestedBinding.Ptr that uses the same backing storage as this XrActionSuggestedBinding.Ptr, but with the new size.
@NotNull XrActiveActionSet.Ptr	XrActiveActionSet.Ptr.reinterpret(long newSize)	Assume the XrActiveActionSet.Ptr is capable of holding at least newSize structures, create a new view XrActiveActionSet.Ptr that uses the same backing storage as this XrActiveActionSet.Ptr, but with the new size.
@NotNull XrActiveActionSetPrioritiesEXT.Ptr	XrActiveActionSetPrioritiesEXT.Ptr.reinterpret(long newSize)	Assume the XrActiveActionSetPrioritiesEXT.Ptr is capable of holding at least newSize structures, create a new view XrActiveActionSetPrioritiesEXT.Ptr that uses the same backing storage as this XrActiveActionSetPrioritiesEXT.Ptr, but with the new size.
@NotNull XrActiveActionSetPriorityEXT.Ptr	XrActiveActionSetPriorityEXT.Ptr.reinterpret(long newSize)	Assume the XrActiveActionSetPriorityEXT.Ptr is capable of holding at least newSize structures, create a new view XrActiveActionSetPriorityEXT.Ptr that uses the same backing storage as this XrActiveActionSetPriorityEXT.Ptr, but with the new size.
@NotNull XrAnchorSpaceCreateInfoBD.Ptr	XrAnchorSpaceCreateInfoBD.Ptr.reinterpret(long newSize)	Assume the XrAnchorSpaceCreateInfoBD.Ptr is capable of holding at least newSize structures, create a new view XrAnchorSpaceCreateInfoBD.Ptr that uses the same backing storage as this XrAnchorSpaceCreateInfoBD.Ptr, but with the new size.
@NotNull XrAndroidSurfaceSwapchainCreateInfoFB.Ptr	XrAndroidSurfaceSwapchainCreateInfoFB.Ptr.reinterpret(long newSize)	Assume the XrAndroidSurfaceSwapchainCreateInfoFB.Ptr is capable of holding at least newSize structures, create a new view XrAndroidSurfaceSwapchainCreateInfoFB.Ptr that uses the same backing storage as this XrAndroidSurfaceSwapchainCreateInfoFB.Ptr, but with the new size.
@NotNull XrApiLayerCreateInfo.Ptr	XrApiLayerCreateInfo.Ptr.reinterpret(long newSize)	Assume the XrApiLayerCreateInfo.Ptr is capable of holding at least newSize structures, create a new view XrApiLayerCreateInfo.Ptr that uses the same backing storage as this XrApiLayerCreateInfo.Ptr, but with the new size.
@NotNull XrApiLayerNextInfo.Ptr	XrApiLayerNextInfo.Ptr.reinterpret(long newSize)	Assume the XrApiLayerNextInfo.Ptr is capable of holding at least newSize structures, create a new view XrApiLayerNextInfo.Ptr that uses the same backing storage as this XrApiLayerNextInfo.Ptr, but with the new size.
@NotNull XrApiLayerProperties.Ptr	XrApiLayerProperties.Ptr.reinterpret(long newSize)	Assume the XrApiLayerProperties.Ptr is capable of holding at least newSize structures, create a new view XrApiLayerProperties.Ptr that uses the same backing storage as this XrApiLayerProperties.Ptr, but with the new size.
@NotNull XrApplicationInfo.Ptr	XrApplicationInfo.Ptr.reinterpret(long newSize)	Assume the XrApplicationInfo.Ptr is capable of holding at least newSize structures, create a new view XrApplicationInfo.Ptr that uses the same backing storage as this XrApplicationInfo.Ptr, but with the new size.
@NotNull XrBaseInStructure.Ptr	XrBaseInStructure.Ptr.reinterpret(long newSize)	Assume the XrBaseInStructure.Ptr is capable of holding at least newSize structures, create a new view XrBaseInStructure.Ptr that uses the same backing storage as this XrBaseInStructure.Ptr, but with the new size.
@NotNull XrBaseOutStructure.Ptr	XrBaseOutStructure.Ptr.reinterpret(long newSize)	Assume the XrBaseOutStructure.Ptr is capable of holding at least newSize structures, create a new view XrBaseOutStructure.Ptr that uses the same backing storage as this XrBaseOutStructure.Ptr, but with the new size.
@NotNull XrBindingModificationBaseHeaderKHR.Ptr	XrBindingModificationBaseHeaderKHR.Ptr.reinterpret(long newSize)	Assume the XrBindingModificationBaseHeaderKHR.Ptr is capable of holding at least newSize structures, create a new view XrBindingModificationBaseHeaderKHR.Ptr that uses the same backing storage as this XrBindingModificationBaseHeaderKHR.Ptr, but with the new size.
@NotNull XrBindingModificationsKHR.Ptr	XrBindingModificationsKHR.Ptr.reinterpret(long newSize)	Assume the XrBindingModificationsKHR.Ptr is capable of holding at least newSize structures, create a new view XrBindingModificationsKHR.Ptr that uses the same backing storage as this XrBindingModificationsKHR.Ptr, but with the new size.
@NotNull XrBodyJointLocationBD.Ptr	XrBodyJointLocationBD.Ptr.reinterpret(long newSize)	Assume the XrBodyJointLocationBD.Ptr is capable of holding at least newSize structures, create a new view XrBodyJointLocationBD.Ptr that uses the same backing storage as this XrBodyJointLocationBD.Ptr, but with the new size.
@NotNull XrBodyJointLocationFB.Ptr	XrBodyJointLocationFB.Ptr.reinterpret(long newSize)	Assume the XrBodyJointLocationFB.Ptr is capable of holding at least newSize structures, create a new view XrBodyJointLocationFB.Ptr that uses the same backing storage as this XrBodyJointLocationFB.Ptr, but with the new size.
@NotNull XrBodyJointLocationHTC.Ptr	XrBodyJointLocationHTC.Ptr.reinterpret(long newSize)	Assume the XrBodyJointLocationHTC.Ptr is capable of holding at least newSize structures, create a new view XrBodyJointLocationHTC.Ptr that uses the same backing storage as this XrBodyJointLocationHTC.Ptr, but with the new size.
@NotNull XrBodyJointLocationsBD.Ptr	XrBodyJointLocationsBD.Ptr.reinterpret(long newSize)	Assume the XrBodyJointLocationsBD.Ptr is capable of holding at least newSize structures, create a new view XrBodyJointLocationsBD.Ptr that uses the same backing storage as this XrBodyJointLocationsBD.Ptr, but with the new size.
@NotNull XrBodyJointLocationsFB.Ptr	XrBodyJointLocationsFB.Ptr.reinterpret(long newSize)	Assume the XrBodyJointLocationsFB.Ptr is capable of holding at least newSize structures, create a new view XrBodyJointLocationsFB.Ptr that uses the same backing storage as this XrBodyJointLocationsFB.Ptr, but with the new size.
@NotNull XrBodyJointLocationsHTC.Ptr	XrBodyJointLocationsHTC.Ptr.reinterpret(long newSize)	Assume the XrBodyJointLocationsHTC.Ptr is capable of holding at least newSize structures, create a new view XrBodyJointLocationsHTC.Ptr that uses the same backing storage as this XrBodyJointLocationsHTC.Ptr, but with the new size.
@NotNull XrBodyJointsLocateInfoBD.Ptr	XrBodyJointsLocateInfoBD.Ptr.reinterpret(long newSize)	Assume the XrBodyJointsLocateInfoBD.Ptr is capable of holding at least newSize structures, create a new view XrBodyJointsLocateInfoBD.Ptr that uses the same backing storage as this XrBodyJointsLocateInfoBD.Ptr, but with the new size.
@NotNull XrBodyJointsLocateInfoFB.Ptr	XrBodyJointsLocateInfoFB.Ptr.reinterpret(long newSize)	Assume the XrBodyJointsLocateInfoFB.Ptr is capable of holding at least newSize structures, create a new view XrBodyJointsLocateInfoFB.Ptr that uses the same backing storage as this XrBodyJointsLocateInfoFB.Ptr, but with the new size.
@NotNull XrBodyJointsLocateInfoHTC.Ptr	XrBodyJointsLocateInfoHTC.Ptr.reinterpret(long newSize)	Assume the XrBodyJointsLocateInfoHTC.Ptr is capable of holding at least newSize structures, create a new view XrBodyJointsLocateInfoHTC.Ptr that uses the same backing storage as this XrBodyJointsLocateInfoHTC.Ptr, but with the new size.
@NotNull XrBodySkeletonFB.Ptr	XrBodySkeletonFB.Ptr.reinterpret(long newSize)	Assume the XrBodySkeletonFB.Ptr is capable of holding at least newSize structures, create a new view XrBodySkeletonFB.Ptr that uses the same backing storage as this XrBodySkeletonFB.Ptr, but with the new size.
@NotNull XrBodySkeletonHTC.Ptr	XrBodySkeletonHTC.Ptr.reinterpret(long newSize)	Assume the XrBodySkeletonHTC.Ptr is capable of holding at least newSize structures, create a new view XrBodySkeletonHTC.Ptr that uses the same backing storage as this XrBodySkeletonHTC.Ptr, but with the new size.
@NotNull XrBodySkeletonJointFB.Ptr	XrBodySkeletonJointFB.Ptr.reinterpret(long newSize)	Assume the XrBodySkeletonJointFB.Ptr is capable of holding at least newSize structures, create a new view XrBodySkeletonJointFB.Ptr that uses the same backing storage as this XrBodySkeletonJointFB.Ptr, but with the new size.
@NotNull XrBodySkeletonJointHTC.Ptr	XrBodySkeletonJointHTC.Ptr.reinterpret(long newSize)	Assume the XrBodySkeletonJointHTC.Ptr is capable of holding at least newSize structures, create a new view XrBodySkeletonJointHTC.Ptr that uses the same backing storage as this XrBodySkeletonJointHTC.Ptr, but with the new size.
@NotNull XrBodyTrackerCreateInfoBD.Ptr	XrBodyTrackerCreateInfoBD.Ptr.reinterpret(long newSize)	Assume the XrBodyTrackerCreateInfoBD.Ptr is capable of holding at least newSize structures, create a new view XrBodyTrackerCreateInfoBD.Ptr that uses the same backing storage as this XrBodyTrackerCreateInfoBD.Ptr, but with the new size.
@NotNull XrBodyTrackerCreateInfoFB.Ptr	XrBodyTrackerCreateInfoFB.Ptr.reinterpret(long newSize)	Assume the XrBodyTrackerCreateInfoFB.Ptr is capable of holding at least newSize structures, create a new view XrBodyTrackerCreateInfoFB.Ptr that uses the same backing storage as this XrBodyTrackerCreateInfoFB.Ptr, but with the new size.
@NotNull XrBodyTrackerCreateInfoHTC.Ptr	XrBodyTrackerCreateInfoHTC.Ptr.reinterpret(long newSize)	Assume the XrBodyTrackerCreateInfoHTC.Ptr is capable of holding at least newSize structures, create a new view XrBodyTrackerCreateInfoHTC.Ptr that uses the same backing storage as this XrBodyTrackerCreateInfoHTC.Ptr, but with the new size.
@NotNull XrBoundary2DFB.Ptr	XrBoundary2DFB.Ptr.reinterpret(long newSize)	Assume the XrBoundary2DFB.Ptr is capable of holding at least newSize structures, create a new view XrBoundary2DFB.Ptr that uses the same backing storage as this XrBoundary2DFB.Ptr, but with the new size.
@NotNull XrBoundSourcesForActionEnumerateInfo.Ptr	XrBoundSourcesForActionEnumerateInfo.Ptr.reinterpret(long newSize)	Assume the XrBoundSourcesForActionEnumerateInfo.Ptr is capable of holding at least newSize structures, create a new view XrBoundSourcesForActionEnumerateInfo.Ptr that uses the same backing storage as this XrBoundSourcesForActionEnumerateInfo.Ptr, but with the new size.
@NotNull XrBoxf.Ptr	XrBoxf.Ptr.reinterpret(long newSize)	Assume the XrBoxf.Ptr is capable of holding at least newSize structures, create a new view XrBoxf.Ptr that uses the same backing storage as this XrBoxf.Ptr, but with the new size.
@NotNull XrBoxfKHR.Ptr	XrBoxfKHR.Ptr.reinterpret(long newSize)	Assume the XrBoxfKHR.Ptr is capable of holding at least newSize structures, create a new view XrBoxfKHR.Ptr that uses the same backing storage as this XrBoxfKHR.Ptr, but with the new size.
@NotNull XrColocationAdvertisementStartInfoMETA.Ptr	XrColocationAdvertisementStartInfoMETA.Ptr.reinterpret(long newSize)	Assume the XrColocationAdvertisementStartInfoMETA.Ptr is capable of holding at least newSize structures, create a new view XrColocationAdvertisementStartInfoMETA.Ptr that uses the same backing storage as this XrColocationAdvertisementStartInfoMETA.Ptr, but with the new size.
@NotNull XrColocationAdvertisementStopInfoMETA.Ptr	XrColocationAdvertisementStopInfoMETA.Ptr.reinterpret(long newSize)	Assume the XrColocationAdvertisementStopInfoMETA.Ptr is capable of holding at least newSize structures, create a new view XrColocationAdvertisementStopInfoMETA.Ptr that uses the same backing storage as this XrColocationAdvertisementStopInfoMETA.Ptr, but with the new size.
@NotNull XrColocationDiscoveryStartInfoMETA.Ptr	XrColocationDiscoveryStartInfoMETA.Ptr.reinterpret(long newSize)	Assume the XrColocationDiscoveryStartInfoMETA.Ptr is capable of holding at least newSize structures, create a new view XrColocationDiscoveryStartInfoMETA.Ptr that uses the same backing storage as this XrColocationDiscoveryStartInfoMETA.Ptr, but with the new size.
@NotNull XrColocationDiscoveryStopInfoMETA.Ptr	XrColocationDiscoveryStopInfoMETA.Ptr.reinterpret(long newSize)	Assume the XrColocationDiscoveryStopInfoMETA.Ptr is capable of holding at least newSize structures, create a new view XrColocationDiscoveryStopInfoMETA.Ptr that uses the same backing storage as this XrColocationDiscoveryStopInfoMETA.Ptr, but with the new size.
@NotNull XrColor3f.Ptr	XrColor3f.Ptr.reinterpret(long newSize)	Assume the XrColor3f.Ptr is capable of holding at least newSize structures, create a new view XrColor3f.Ptr that uses the same backing storage as this XrColor3f.Ptr, but with the new size.
@NotNull XrColor3fKHR.Ptr	XrColor3fKHR.Ptr.reinterpret(long newSize)	Assume the XrColor3fKHR.Ptr is capable of holding at least newSize structures, create a new view XrColor3fKHR.Ptr that uses the same backing storage as this XrColor3fKHR.Ptr, but with the new size.
@NotNull XrColor4f.Ptr	XrColor4f.Ptr.reinterpret(long newSize)	Assume the XrColor4f.Ptr is capable of holding at least newSize structures, create a new view XrColor4f.Ptr that uses the same backing storage as this XrColor4f.Ptr, but with the new size.
@NotNull XrCompositionLayerAlphaBlendFB.Ptr	XrCompositionLayerAlphaBlendFB.Ptr.reinterpret(long newSize)	Assume the XrCompositionLayerAlphaBlendFB.Ptr is capable of holding at least newSize structures, create a new view XrCompositionLayerAlphaBlendFB.Ptr that uses the same backing storage as this XrCompositionLayerAlphaBlendFB.Ptr, but with the new size.
@NotNull XrCompositionLayerBaseHeader.Ptr	XrCompositionLayerBaseHeader.Ptr.reinterpret(long newSize)	Assume the XrCompositionLayerBaseHeader.Ptr is capable of holding at least newSize structures, create a new view XrCompositionLayerBaseHeader.Ptr that uses the same backing storage as this XrCompositionLayerBaseHeader.Ptr, but with the new size.
@NotNull XrCompositionLayerColorScaleBiasKHR.Ptr	XrCompositionLayerColorScaleBiasKHR.Ptr.reinterpret(long newSize)	Assume the XrCompositionLayerColorScaleBiasKHR.Ptr is capable of holding at least newSize structures, create a new view XrCompositionLayerColorScaleBiasKHR.Ptr that uses the same backing storage as this XrCompositionLayerColorScaleBiasKHR.Ptr, but with the new size.
@NotNull XrCompositionLayerCubeKHR.Ptr	XrCompositionLayerCubeKHR.Ptr.reinterpret(long newSize)	Assume the XrCompositionLayerCubeKHR.Ptr is capable of holding at least newSize structures, create a new view XrCompositionLayerCubeKHR.Ptr that uses the same backing storage as this XrCompositionLayerCubeKHR.Ptr, but with the new size.
@NotNull XrCompositionLayerCylinderKHR.Ptr	XrCompositionLayerCylinderKHR.Ptr.reinterpret(long newSize)	Assume the XrCompositionLayerCylinderKHR.Ptr is capable of holding at least newSize structures, create a new view XrCompositionLayerCylinderKHR.Ptr that uses the same backing storage as this XrCompositionLayerCylinderKHR.Ptr, but with the new size.
@NotNull XrCompositionLayerDepthInfoKHR.Ptr	XrCompositionLayerDepthInfoKHR.Ptr.reinterpret(long newSize)	Assume the XrCompositionLayerDepthInfoKHR.Ptr is capable of holding at least newSize structures, create a new view XrCompositionLayerDepthInfoKHR.Ptr that uses the same backing storage as this XrCompositionLayerDepthInfoKHR.Ptr, but with the new size.
@NotNull XrCompositionLayerDepthTestFB.Ptr	XrCompositionLayerDepthTestFB.Ptr.reinterpret(long newSize)	Assume the XrCompositionLayerDepthTestFB.Ptr is capable of holding at least newSize structures, create a new view XrCompositionLayerDepthTestFB.Ptr that uses the same backing storage as this XrCompositionLayerDepthTestFB.Ptr, but with the new size.
@NotNull XrCompositionLayerDepthTestVARJO.Ptr	XrCompositionLayerDepthTestVARJO.Ptr.reinterpret(long newSize)	Assume the XrCompositionLayerDepthTestVARJO.Ptr is capable of holding at least newSize structures, create a new view XrCompositionLayerDepthTestVARJO.Ptr that uses the same backing storage as this XrCompositionLayerDepthTestVARJO.Ptr, but with the new size.
@NotNull XrCompositionLayerEquirect2KHR.Ptr	XrCompositionLayerEquirect2KHR.Ptr.reinterpret(long newSize)	Assume the XrCompositionLayerEquirect2KHR.Ptr is capable of holding at least newSize structures, create a new view XrCompositionLayerEquirect2KHR.Ptr that uses the same backing storage as this XrCompositionLayerEquirect2KHR.Ptr, but with the new size.
@NotNull XrCompositionLayerEquirectKHR.Ptr	XrCompositionLayerEquirectKHR.Ptr.reinterpret(long newSize)	Assume the XrCompositionLayerEquirectKHR.Ptr is capable of holding at least newSize structures, create a new view XrCompositionLayerEquirectKHR.Ptr that uses the same backing storage as this XrCompositionLayerEquirectKHR.Ptr, but with the new size.
@NotNull XrCompositionLayerImageLayoutFB.Ptr	XrCompositionLayerImageLayoutFB.Ptr.reinterpret(long newSize)	Assume the XrCompositionLayerImageLayoutFB.Ptr is capable of holding at least newSize structures, create a new view XrCompositionLayerImageLayoutFB.Ptr that uses the same backing storage as this XrCompositionLayerImageLayoutFB.Ptr, but with the new size.
@NotNull XrCompositionLayerPassthroughFB.Ptr	XrCompositionLayerPassthroughFB.Ptr.reinterpret(long newSize)	Assume the XrCompositionLayerPassthroughFB.Ptr is capable of holding at least newSize structures, create a new view XrCompositionLayerPassthroughFB.Ptr that uses the same backing storage as this XrCompositionLayerPassthroughFB.Ptr, but with the new size.
@NotNull XrCompositionLayerPassthroughHTC.Ptr	XrCompositionLayerPassthroughHTC.Ptr.reinterpret(long newSize)	Assume the XrCompositionLayerPassthroughHTC.Ptr is capable of holding at least newSize structures, create a new view XrCompositionLayerPassthroughHTC.Ptr that uses the same backing storage as this XrCompositionLayerPassthroughHTC.Ptr, but with the new size.
@NotNull XrCompositionLayerProjection.Ptr	XrCompositionLayerProjection.Ptr.reinterpret(long newSize)	Assume the XrCompositionLayerProjection.Ptr is capable of holding at least newSize structures, create a new view XrCompositionLayerProjection.Ptr that uses the same backing storage as this XrCompositionLayerProjection.Ptr, but with the new size.
@NotNull XrCompositionLayerProjectionView.Ptr	XrCompositionLayerProjectionView.Ptr.reinterpret(long newSize)	Assume the XrCompositionLayerProjectionView.Ptr is capable of holding at least newSize structures, create a new view XrCompositionLayerProjectionView.Ptr that uses the same backing storage as this XrCompositionLayerProjectionView.Ptr, but with the new size.
@NotNull XrCompositionLayerQuad.Ptr	XrCompositionLayerQuad.Ptr.reinterpret(long newSize)	Assume the XrCompositionLayerQuad.Ptr is capable of holding at least newSize structures, create a new view XrCompositionLayerQuad.Ptr that uses the same backing storage as this XrCompositionLayerQuad.Ptr, but with the new size.
@NotNull XrCompositionLayerReprojectionInfoMSFT.Ptr	XrCompositionLayerReprojectionInfoMSFT.Ptr.reinterpret(long newSize)	Assume the XrCompositionLayerReprojectionInfoMSFT.Ptr is capable of holding at least newSize structures, create a new view XrCompositionLayerReprojectionInfoMSFT.Ptr that uses the same backing storage as this XrCompositionLayerReprojectionInfoMSFT.Ptr, but with the new size.
@NotNull XrCompositionLayerReprojectionPlaneOverrideMSFT.Ptr	XrCompositionLayerReprojectionPlaneOverrideMSFT.Ptr.reinterpret(long newSize)	Assume the XrCompositionLayerReprojectionPlaneOverrideMSFT.Ptr is capable of holding at least newSize structures, create a new view XrCompositionLayerReprojectionPlaneOverrideMSFT.Ptr that uses the same backing storage as this XrCompositionLayerReprojectionPlaneOverrideMSFT.Ptr, but with the new size.
@NotNull XrCompositionLayerSecureContentFB.Ptr	XrCompositionLayerSecureContentFB.Ptr.reinterpret(long newSize)	Assume the XrCompositionLayerSecureContentFB.Ptr is capable of holding at least newSize structures, create a new view XrCompositionLayerSecureContentFB.Ptr that uses the same backing storage as this XrCompositionLayerSecureContentFB.Ptr, but with the new size.
@NotNull XrCompositionLayerSettingsFB.Ptr	XrCompositionLayerSettingsFB.Ptr.reinterpret(long newSize)	Assume the XrCompositionLayerSettingsFB.Ptr is capable of holding at least newSize structures, create a new view XrCompositionLayerSettingsFB.Ptr that uses the same backing storage as this XrCompositionLayerSettingsFB.Ptr, but with the new size.
@NotNull XrCompositionLayerSpaceWarpInfoFB.Ptr	XrCompositionLayerSpaceWarpInfoFB.Ptr.reinterpret(long newSize)	Assume the XrCompositionLayerSpaceWarpInfoFB.Ptr is capable of holding at least newSize structures, create a new view XrCompositionLayerSpaceWarpInfoFB.Ptr that uses the same backing storage as this XrCompositionLayerSpaceWarpInfoFB.Ptr, but with the new size.
@NotNull XrControllerModelKeyStateMSFT.Ptr	XrControllerModelKeyStateMSFT.Ptr.reinterpret(long newSize)	Assume the XrControllerModelKeyStateMSFT.Ptr is capable of holding at least newSize structures, create a new view XrControllerModelKeyStateMSFT.Ptr that uses the same backing storage as this XrControllerModelKeyStateMSFT.Ptr, but with the new size.
@NotNull XrControllerModelNodePropertiesMSFT.Ptr	XrControllerModelNodePropertiesMSFT.Ptr.reinterpret(long newSize)	Assume the XrControllerModelNodePropertiesMSFT.Ptr is capable of holding at least newSize structures, create a new view XrControllerModelNodePropertiesMSFT.Ptr that uses the same backing storage as this XrControllerModelNodePropertiesMSFT.Ptr, but with the new size.
@NotNull XrControllerModelNodeStateMSFT.Ptr	XrControllerModelNodeStateMSFT.Ptr.reinterpret(long newSize)	Assume the XrControllerModelNodeStateMSFT.Ptr is capable of holding at least newSize structures, create a new view XrControllerModelNodeStateMSFT.Ptr that uses the same backing storage as this XrControllerModelNodeStateMSFT.Ptr, but with the new size.
@NotNull XrControllerModelPropertiesMSFT.Ptr	XrControllerModelPropertiesMSFT.Ptr.reinterpret(long newSize)	Assume the XrControllerModelPropertiesMSFT.Ptr is capable of holding at least newSize structures, create a new view XrControllerModelPropertiesMSFT.Ptr that uses the same backing storage as this XrControllerModelPropertiesMSFT.Ptr, but with the new size.
@NotNull XrControllerModelStateMSFT.Ptr	XrControllerModelStateMSFT.Ptr.reinterpret(long newSize)	Assume the XrControllerModelStateMSFT.Ptr is capable of holding at least newSize structures, create a new view XrControllerModelStateMSFT.Ptr that uses the same backing storage as this XrControllerModelStateMSFT.Ptr, but with the new size.
@NotNull XrCoordinateSpaceCreateInfoML.Ptr	XrCoordinateSpaceCreateInfoML.Ptr.reinterpret(long newSize)	Assume the XrCoordinateSpaceCreateInfoML.Ptr is capable of holding at least newSize structures, create a new view XrCoordinateSpaceCreateInfoML.Ptr that uses the same backing storage as this XrCoordinateSpaceCreateInfoML.Ptr, but with the new size.
@NotNull XrCreateSpatialAnchorsCompletionML.Ptr	XrCreateSpatialAnchorsCompletionML.Ptr.reinterpret(long newSize)	Assume the XrCreateSpatialAnchorsCompletionML.Ptr is capable of holding at least newSize structures, create a new view XrCreateSpatialAnchorsCompletionML.Ptr that uses the same backing storage as this XrCreateSpatialAnchorsCompletionML.Ptr, but with the new size.
@NotNull XrCreateSpatialContextCompletionEXT.Ptr	XrCreateSpatialContextCompletionEXT.Ptr.reinterpret(long newSize)	Assume the XrCreateSpatialContextCompletionEXT.Ptr is capable of holding at least newSize structures, create a new view XrCreateSpatialContextCompletionEXT.Ptr that uses the same backing storage as this XrCreateSpatialContextCompletionEXT.Ptr, but with the new size.
@NotNull XrCreateSpatialDiscoverySnapshotCompletionEXT.Ptr	XrCreateSpatialDiscoverySnapshotCompletionEXT.Ptr.reinterpret(long newSize)	Assume the XrCreateSpatialDiscoverySnapshotCompletionEXT.Ptr is capable of holding at least newSize structures, create a new view XrCreateSpatialDiscoverySnapshotCompletionEXT.Ptr that uses the same backing storage as this XrCreateSpatialDiscoverySnapshotCompletionEXT.Ptr, but with the new size.
@NotNull XrCreateSpatialDiscoverySnapshotCompletionInfoEXT.Ptr	XrCreateSpatialDiscoverySnapshotCompletionInfoEXT.Ptr.reinterpret(long newSize)	Assume the XrCreateSpatialDiscoverySnapshotCompletionInfoEXT.Ptr is capable of holding at least newSize structures, create a new view XrCreateSpatialDiscoverySnapshotCompletionInfoEXT.Ptr that uses the same backing storage as this XrCreateSpatialDiscoverySnapshotCompletionInfoEXT.Ptr, but with the new size.
@NotNull XrCreateSpatialPersistenceContextCompletionEXT.Ptr	XrCreateSpatialPersistenceContextCompletionEXT.Ptr.reinterpret(long newSize)	Assume the XrCreateSpatialPersistenceContextCompletionEXT.Ptr is capable of holding at least newSize structures, create a new view XrCreateSpatialPersistenceContextCompletionEXT.Ptr that uses the same backing storage as this XrCreateSpatialPersistenceContextCompletionEXT.Ptr, but with the new size.
@NotNull XrDebugUtilsLabelEXT.Ptr	XrDebugUtilsLabelEXT.Ptr.reinterpret(long newSize)	Assume the XrDebugUtilsLabelEXT.Ptr is capable of holding at least newSize structures, create a new view XrDebugUtilsLabelEXT.Ptr that uses the same backing storage as this XrDebugUtilsLabelEXT.Ptr, but with the new size.
@NotNull XrDebugUtilsMessengerCallbackDataEXT.Ptr	XrDebugUtilsMessengerCallbackDataEXT.Ptr.reinterpret(long newSize)	Assume the XrDebugUtilsMessengerCallbackDataEXT.Ptr is capable of holding at least newSize structures, create a new view XrDebugUtilsMessengerCallbackDataEXT.Ptr that uses the same backing storage as this XrDebugUtilsMessengerCallbackDataEXT.Ptr, but with the new size.
@NotNull XrDebugUtilsMessengerCreateInfoEXT.Ptr	XrDebugUtilsMessengerCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the XrDebugUtilsMessengerCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view XrDebugUtilsMessengerCreateInfoEXT.Ptr that uses the same backing storage as this XrDebugUtilsMessengerCreateInfoEXT.Ptr, but with the new size.
@NotNull XrDebugUtilsObjectNameInfoEXT.Ptr	XrDebugUtilsObjectNameInfoEXT.Ptr.reinterpret(long newSize)	Assume the XrDebugUtilsObjectNameInfoEXT.Ptr is capable of holding at least newSize structures, create a new view XrDebugUtilsObjectNameInfoEXT.Ptr that uses the same backing storage as this XrDebugUtilsObjectNameInfoEXT.Ptr, but with the new size.
@NotNull XrDeserializeSceneFragmentMSFT.Ptr	XrDeserializeSceneFragmentMSFT.Ptr.reinterpret(long newSize)	Assume the XrDeserializeSceneFragmentMSFT.Ptr is capable of holding at least newSize structures, create a new view XrDeserializeSceneFragmentMSFT.Ptr that uses the same backing storage as this XrDeserializeSceneFragmentMSFT.Ptr, but with the new size.
@NotNull XrDevicePcmSampleRateGetInfoFB.Ptr	XrDevicePcmSampleRateGetInfoFB.Ptr.reinterpret(long newSize)	Assume the XrDevicePcmSampleRateGetInfoFB.Ptr is capable of holding at least newSize structures, create a new view XrDevicePcmSampleRateGetInfoFB.Ptr that uses the same backing storage as this XrDevicePcmSampleRateGetInfoFB.Ptr, but with the new size.
@NotNull XrDevicePcmSampleRateStateFB.Ptr	XrDevicePcmSampleRateStateFB.Ptr.reinterpret(long newSize)	Assume the XrDevicePcmSampleRateStateFB.Ptr is capable of holding at least newSize structures, create a new view XrDevicePcmSampleRateStateFB.Ptr that uses the same backing storage as this XrDevicePcmSampleRateStateFB.Ptr, but with the new size.
@NotNull XrDigitalLensControlALMALENCE.Ptr	XrDigitalLensControlALMALENCE.Ptr.reinterpret(long newSize)	Assume the XrDigitalLensControlALMALENCE.Ptr is capable of holding at least newSize structures, create a new view XrDigitalLensControlALMALENCE.Ptr that uses the same backing storage as this XrDigitalLensControlALMALENCE.Ptr, but with the new size.
@NotNull XrEnvironmentDepthHandRemovalSetInfoMETA.Ptr	XrEnvironmentDepthHandRemovalSetInfoMETA.Ptr.reinterpret(long newSize)	Assume the XrEnvironmentDepthHandRemovalSetInfoMETA.Ptr is capable of holding at least newSize structures, create a new view XrEnvironmentDepthHandRemovalSetInfoMETA.Ptr that uses the same backing storage as this XrEnvironmentDepthHandRemovalSetInfoMETA.Ptr, but with the new size.
@NotNull XrEnvironmentDepthImageAcquireInfoMETA.Ptr	XrEnvironmentDepthImageAcquireInfoMETA.Ptr.reinterpret(long newSize)	Assume the XrEnvironmentDepthImageAcquireInfoMETA.Ptr is capable of holding at least newSize structures, create a new view XrEnvironmentDepthImageAcquireInfoMETA.Ptr that uses the same backing storage as this XrEnvironmentDepthImageAcquireInfoMETA.Ptr, but with the new size.
@NotNull XrEnvironmentDepthImageMETA.Ptr	XrEnvironmentDepthImageMETA.Ptr.reinterpret(long newSize)	Assume the XrEnvironmentDepthImageMETA.Ptr is capable of holding at least newSize structures, create a new view XrEnvironmentDepthImageMETA.Ptr that uses the same backing storage as this XrEnvironmentDepthImageMETA.Ptr, but with the new size.
@NotNull XrEnvironmentDepthImageViewMETA.Ptr	XrEnvironmentDepthImageViewMETA.Ptr.reinterpret(long newSize)	Assume the XrEnvironmentDepthImageViewMETA.Ptr is capable of holding at least newSize structures, create a new view XrEnvironmentDepthImageViewMETA.Ptr that uses the same backing storage as this XrEnvironmentDepthImageViewMETA.Ptr, but with the new size.
@NotNull XrEnvironmentDepthProviderCreateInfoMETA.Ptr	XrEnvironmentDepthProviderCreateInfoMETA.Ptr.reinterpret(long newSize)	Assume the XrEnvironmentDepthProviderCreateInfoMETA.Ptr is capable of holding at least newSize structures, create a new view XrEnvironmentDepthProviderCreateInfoMETA.Ptr that uses the same backing storage as this XrEnvironmentDepthProviderCreateInfoMETA.Ptr, but with the new size.
@NotNull XrEnvironmentDepthSwapchainCreateInfoMETA.Ptr	XrEnvironmentDepthSwapchainCreateInfoMETA.Ptr.reinterpret(long newSize)	Assume the XrEnvironmentDepthSwapchainCreateInfoMETA.Ptr is capable of holding at least newSize structures, create a new view XrEnvironmentDepthSwapchainCreateInfoMETA.Ptr that uses the same backing storage as this XrEnvironmentDepthSwapchainCreateInfoMETA.Ptr, but with the new size.
@NotNull XrEnvironmentDepthSwapchainStateMETA.Ptr	XrEnvironmentDepthSwapchainStateMETA.Ptr.reinterpret(long newSize)	Assume the XrEnvironmentDepthSwapchainStateMETA.Ptr is capable of holding at least newSize structures, create a new view XrEnvironmentDepthSwapchainStateMETA.Ptr that uses the same backing storage as this XrEnvironmentDepthSwapchainStateMETA.Ptr, but with the new size.
@NotNull XrEventDataBaseHeader.Ptr	XrEventDataBaseHeader.Ptr.reinterpret(long newSize)	Assume the XrEventDataBaseHeader.Ptr is capable of holding at least newSize structures, create a new view XrEventDataBaseHeader.Ptr that uses the same backing storage as this XrEventDataBaseHeader.Ptr, but with the new size.
@NotNull XrEventDataBuffer.Ptr	XrEventDataBuffer.Ptr.reinterpret(long newSize)	Assume the XrEventDataBuffer.Ptr is capable of holding at least newSize structures, create a new view XrEventDataBuffer.Ptr that uses the same backing storage as this XrEventDataBuffer.Ptr, but with the new size.
@NotNull XrEventDataColocationAdvertisementCompleteMETA.Ptr	XrEventDataColocationAdvertisementCompleteMETA.Ptr.reinterpret(long newSize)	Assume the XrEventDataColocationAdvertisementCompleteMETA.Ptr is capable of holding at least newSize structures, create a new view XrEventDataColocationAdvertisementCompleteMETA.Ptr that uses the same backing storage as this XrEventDataColocationAdvertisementCompleteMETA.Ptr, but with the new size.
@NotNull XrEventDataColocationDiscoveryCompleteMETA.Ptr	XrEventDataColocationDiscoveryCompleteMETA.Ptr.reinterpret(long newSize)	Assume the XrEventDataColocationDiscoveryCompleteMETA.Ptr is capable of holding at least newSize structures, create a new view XrEventDataColocationDiscoveryCompleteMETA.Ptr that uses the same backing storage as this XrEventDataColocationDiscoveryCompleteMETA.Ptr, but with the new size.
@NotNull XrEventDataColocationDiscoveryResultMETA.Ptr	XrEventDataColocationDiscoveryResultMETA.Ptr.reinterpret(long newSize)	Assume the XrEventDataColocationDiscoveryResultMETA.Ptr is capable of holding at least newSize structures, create a new view XrEventDataColocationDiscoveryResultMETA.Ptr that uses the same backing storage as this XrEventDataColocationDiscoveryResultMETA.Ptr, but with the new size.
@NotNull XrEventDataDisplayRefreshRateChangedFB.Ptr	XrEventDataDisplayRefreshRateChangedFB.Ptr.reinterpret(long newSize)	Assume the XrEventDataDisplayRefreshRateChangedFB.Ptr is capable of holding at least newSize structures, create a new view XrEventDataDisplayRefreshRateChangedFB.Ptr that uses the same backing storage as this XrEventDataDisplayRefreshRateChangedFB.Ptr, but with the new size.
@NotNull XrEventDataEventsLost.Ptr	XrEventDataEventsLost.Ptr.reinterpret(long newSize)	Assume the XrEventDataEventsLost.Ptr is capable of holding at least newSize structures, create a new view XrEventDataEventsLost.Ptr that uses the same backing storage as this XrEventDataEventsLost.Ptr, but with the new size.
@NotNull XrEventDataEyeCalibrationChangedML.Ptr	XrEventDataEyeCalibrationChangedML.Ptr.reinterpret(long newSize)	Assume the XrEventDataEyeCalibrationChangedML.Ptr is capable of holding at least newSize structures, create a new view XrEventDataEyeCalibrationChangedML.Ptr that uses the same backing storage as this XrEventDataEyeCalibrationChangedML.Ptr, but with the new size.
@NotNull XrEventDataHeadsetFitChangedML.Ptr	XrEventDataHeadsetFitChangedML.Ptr.reinterpret(long newSize)	Assume the XrEventDataHeadsetFitChangedML.Ptr is capable of holding at least newSize structures, create a new view XrEventDataHeadsetFitChangedML.Ptr that uses the same backing storage as this XrEventDataHeadsetFitChangedML.Ptr, but with the new size.
@NotNull XrEventDataInstanceLossPending.Ptr	XrEventDataInstanceLossPending.Ptr.reinterpret(long newSize)	Assume the XrEventDataInstanceLossPending.Ptr is capable of holding at least newSize structures, create a new view XrEventDataInstanceLossPending.Ptr that uses the same backing storage as this XrEventDataInstanceLossPending.Ptr, but with the new size.
@NotNull XrEventDataInteractionProfileChanged.Ptr	XrEventDataInteractionProfileChanged.Ptr.reinterpret(long newSize)	Assume the XrEventDataInteractionProfileChanged.Ptr is capable of holding at least newSize structures, create a new view XrEventDataInteractionProfileChanged.Ptr that uses the same backing storage as this XrEventDataInteractionProfileChanged.Ptr, but with the new size.
@NotNull XrEventDataInteractionRenderModelsChangedEXT.Ptr	XrEventDataInteractionRenderModelsChangedEXT.Ptr.reinterpret(long newSize)	Assume the XrEventDataInteractionRenderModelsChangedEXT.Ptr is capable of holding at least newSize structures, create a new view XrEventDataInteractionRenderModelsChangedEXT.Ptr that uses the same backing storage as this XrEventDataInteractionRenderModelsChangedEXT.Ptr, but with the new size.
@NotNull XrEventDataLocalizationChangedML.Ptr	XrEventDataLocalizationChangedML.Ptr.reinterpret(long newSize)	Assume the XrEventDataLocalizationChangedML.Ptr is capable of holding at least newSize structures, create a new view XrEventDataLocalizationChangedML.Ptr that uses the same backing storage as this XrEventDataLocalizationChangedML.Ptr, but with the new size.
@NotNull XrEventDataMainSessionVisibilityChangedEXTX.Ptr	XrEventDataMainSessionVisibilityChangedEXTX.Ptr.reinterpret(long newSize)	Assume the XrEventDataMainSessionVisibilityChangedEXTX.Ptr is capable of holding at least newSize structures, create a new view XrEventDataMainSessionVisibilityChangedEXTX.Ptr that uses the same backing storage as this XrEventDataMainSessionVisibilityChangedEXTX.Ptr, but with the new size.
@NotNull XrEventDataMarkerTrackingUpdateVARJO.Ptr	XrEventDataMarkerTrackingUpdateVARJO.Ptr.reinterpret(long newSize)	Assume the XrEventDataMarkerTrackingUpdateVARJO.Ptr is capable of holding at least newSize structures, create a new view XrEventDataMarkerTrackingUpdateVARJO.Ptr that uses the same backing storage as this XrEventDataMarkerTrackingUpdateVARJO.Ptr, but with the new size.
@NotNull XrEventDataPassthroughLayerResumedMETA.Ptr	XrEventDataPassthroughLayerResumedMETA.Ptr.reinterpret(long newSize)	Assume the XrEventDataPassthroughLayerResumedMETA.Ptr is capable of holding at least newSize structures, create a new view XrEventDataPassthroughLayerResumedMETA.Ptr that uses the same backing storage as this XrEventDataPassthroughLayerResumedMETA.Ptr, but with the new size.
@NotNull XrEventDataPassthroughStateChangedFB.Ptr	XrEventDataPassthroughStateChangedFB.Ptr.reinterpret(long newSize)	Assume the XrEventDataPassthroughStateChangedFB.Ptr is capable of holding at least newSize structures, create a new view XrEventDataPassthroughStateChangedFB.Ptr that uses the same backing storage as this XrEventDataPassthroughStateChangedFB.Ptr, but with the new size.
@NotNull XrEventDataPerfSettingsEXT.Ptr	XrEventDataPerfSettingsEXT.Ptr.reinterpret(long newSize)	Assume the XrEventDataPerfSettingsEXT.Ptr is capable of holding at least newSize structures, create a new view XrEventDataPerfSettingsEXT.Ptr that uses the same backing storage as this XrEventDataPerfSettingsEXT.Ptr, but with the new size.
@NotNull XrEventDataReferenceSpaceChangePending.Ptr	XrEventDataReferenceSpaceChangePending.Ptr.reinterpret(long newSize)	Assume the XrEventDataReferenceSpaceChangePending.Ptr is capable of holding at least newSize structures, create a new view XrEventDataReferenceSpaceChangePending.Ptr that uses the same backing storage as this XrEventDataReferenceSpaceChangePending.Ptr, but with the new size.
@NotNull XrEventDataSceneCaptureCompleteFB.Ptr	XrEventDataSceneCaptureCompleteFB.Ptr.reinterpret(long newSize)	Assume the XrEventDataSceneCaptureCompleteFB.Ptr is capable of holding at least newSize structures, create a new view XrEventDataSceneCaptureCompleteFB.Ptr that uses the same backing storage as this XrEventDataSceneCaptureCompleteFB.Ptr, but with the new size.
@NotNull XrEventDataSenseDataProviderStateChangedBD.Ptr	XrEventDataSenseDataProviderStateChangedBD.Ptr.reinterpret(long newSize)	Assume the XrEventDataSenseDataProviderStateChangedBD.Ptr is capable of holding at least newSize structures, create a new view XrEventDataSenseDataProviderStateChangedBD.Ptr that uses the same backing storage as this XrEventDataSenseDataProviderStateChangedBD.Ptr, but with the new size.
@NotNull XrEventDataSenseDataUpdatedBD.Ptr	XrEventDataSenseDataUpdatedBD.Ptr.reinterpret(long newSize)	Assume the XrEventDataSenseDataUpdatedBD.Ptr is capable of holding at least newSize structures, create a new view XrEventDataSenseDataUpdatedBD.Ptr that uses the same backing storage as this XrEventDataSenseDataUpdatedBD.Ptr, but with the new size.
@NotNull XrEventDataSessionStateChanged.Ptr	XrEventDataSessionStateChanged.Ptr.reinterpret(long newSize)	Assume the XrEventDataSessionStateChanged.Ptr is capable of holding at least newSize structures, create a new view XrEventDataSessionStateChanged.Ptr that uses the same backing storage as this XrEventDataSessionStateChanged.Ptr, but with the new size.
@NotNull XrEventDataShareSpacesCompleteMETA.Ptr	XrEventDataShareSpacesCompleteMETA.Ptr.reinterpret(long newSize)	Assume the XrEventDataShareSpacesCompleteMETA.Ptr is capable of holding at least newSize structures, create a new view XrEventDataShareSpacesCompleteMETA.Ptr that uses the same backing storage as this XrEventDataShareSpacesCompleteMETA.Ptr, but with the new size.
@NotNull XrEventDataSpaceEraseCompleteFB.Ptr	XrEventDataSpaceEraseCompleteFB.Ptr.reinterpret(long newSize)	Assume the XrEventDataSpaceEraseCompleteFB.Ptr is capable of holding at least newSize structures, create a new view XrEventDataSpaceEraseCompleteFB.Ptr that uses the same backing storage as this XrEventDataSpaceEraseCompleteFB.Ptr, but with the new size.
@NotNull XrEventDataSpaceListSaveCompleteFB.Ptr	XrEventDataSpaceListSaveCompleteFB.Ptr.reinterpret(long newSize)	Assume the XrEventDataSpaceListSaveCompleteFB.Ptr is capable of holding at least newSize structures, create a new view XrEventDataSpaceListSaveCompleteFB.Ptr that uses the same backing storage as this XrEventDataSpaceListSaveCompleteFB.Ptr, but with the new size.
@NotNull XrEventDataSpaceQueryCompleteFB.Ptr	XrEventDataSpaceQueryCompleteFB.Ptr.reinterpret(long newSize)	Assume the XrEventDataSpaceQueryCompleteFB.Ptr is capable of holding at least newSize structures, create a new view XrEventDataSpaceQueryCompleteFB.Ptr that uses the same backing storage as this XrEventDataSpaceQueryCompleteFB.Ptr, but with the new size.
@NotNull XrEventDataSpaceQueryResultsAvailableFB.Ptr	XrEventDataSpaceQueryResultsAvailableFB.Ptr.reinterpret(long newSize)	Assume the XrEventDataSpaceQueryResultsAvailableFB.Ptr is capable of holding at least newSize structures, create a new view XrEventDataSpaceQueryResultsAvailableFB.Ptr that uses the same backing storage as this XrEventDataSpaceQueryResultsAvailableFB.Ptr, but with the new size.
@NotNull XrEventDataSpaceSaveCompleteFB.Ptr	XrEventDataSpaceSaveCompleteFB.Ptr.reinterpret(long newSize)	Assume the XrEventDataSpaceSaveCompleteFB.Ptr is capable of holding at least newSize structures, create a new view XrEventDataSpaceSaveCompleteFB.Ptr that uses the same backing storage as this XrEventDataSpaceSaveCompleteFB.Ptr, but with the new size.
@NotNull XrEventDataSpaceSetStatusCompleteFB.Ptr	XrEventDataSpaceSetStatusCompleteFB.Ptr.reinterpret(long newSize)	Assume the XrEventDataSpaceSetStatusCompleteFB.Ptr is capable of holding at least newSize structures, create a new view XrEventDataSpaceSetStatusCompleteFB.Ptr that uses the same backing storage as this XrEventDataSpaceSetStatusCompleteFB.Ptr, but with the new size.
@NotNull XrEventDataSpaceShareCompleteFB.Ptr	XrEventDataSpaceShareCompleteFB.Ptr.reinterpret(long newSize)	Assume the XrEventDataSpaceShareCompleteFB.Ptr is capable of holding at least newSize structures, create a new view XrEventDataSpaceShareCompleteFB.Ptr that uses the same backing storage as this XrEventDataSpaceShareCompleteFB.Ptr, but with the new size.
@NotNull XrEventDataSpatialAnchorCreateCompleteFB.Ptr	XrEventDataSpatialAnchorCreateCompleteFB.Ptr.reinterpret(long newSize)	Assume the XrEventDataSpatialAnchorCreateCompleteFB.Ptr is capable of holding at least newSize structures, create a new view XrEventDataSpatialAnchorCreateCompleteFB.Ptr that uses the same backing storage as this XrEventDataSpatialAnchorCreateCompleteFB.Ptr, but with the new size.
@NotNull XrEventDataSpatialDiscoveryRecommendedEXT.Ptr	XrEventDataSpatialDiscoveryRecommendedEXT.Ptr.reinterpret(long newSize)	Assume the XrEventDataSpatialDiscoveryRecommendedEXT.Ptr is capable of holding at least newSize structures, create a new view XrEventDataSpatialDiscoveryRecommendedEXT.Ptr that uses the same backing storage as this XrEventDataSpatialDiscoveryRecommendedEXT.Ptr, but with the new size.
@NotNull XrEventDataStartColocationAdvertisementCompleteMETA.Ptr	XrEventDataStartColocationAdvertisementCompleteMETA.Ptr.reinterpret(long newSize)	Assume the XrEventDataStartColocationAdvertisementCompleteMETA.Ptr is capable of holding at least newSize structures, create a new view XrEventDataStartColocationAdvertisementCompleteMETA.Ptr that uses the same backing storage as this XrEventDataStartColocationAdvertisementCompleteMETA.Ptr, but with the new size.
@NotNull XrEventDataStartColocationDiscoveryCompleteMETA.Ptr	XrEventDataStartColocationDiscoveryCompleteMETA.Ptr.reinterpret(long newSize)	Assume the XrEventDataStartColocationDiscoveryCompleteMETA.Ptr is capable of holding at least newSize structures, create a new view XrEventDataStartColocationDiscoveryCompleteMETA.Ptr that uses the same backing storage as this XrEventDataStartColocationDiscoveryCompleteMETA.Ptr, but with the new size.
@NotNull XrEventDataStopColocationAdvertisementCompleteMETA.Ptr	XrEventDataStopColocationAdvertisementCompleteMETA.Ptr.reinterpret(long newSize)	Assume the XrEventDataStopColocationAdvertisementCompleteMETA.Ptr is capable of holding at least newSize structures, create a new view XrEventDataStopColocationAdvertisementCompleteMETA.Ptr that uses the same backing storage as this XrEventDataStopColocationAdvertisementCompleteMETA.Ptr, but with the new size.
@NotNull XrEventDataStopColocationDiscoveryCompleteMETA.Ptr	XrEventDataStopColocationDiscoveryCompleteMETA.Ptr.reinterpret(long newSize)	Assume the XrEventDataStopColocationDiscoveryCompleteMETA.Ptr is capable of holding at least newSize structures, create a new view XrEventDataStopColocationDiscoveryCompleteMETA.Ptr that uses the same backing storage as this XrEventDataStopColocationDiscoveryCompleteMETA.Ptr, but with the new size.
@NotNull XrEventDataUserPresenceChangedEXT.Ptr	XrEventDataUserPresenceChangedEXT.Ptr.reinterpret(long newSize)	Assume the XrEventDataUserPresenceChangedEXT.Ptr is capable of holding at least newSize structures, create a new view XrEventDataUserPresenceChangedEXT.Ptr that uses the same backing storage as this XrEventDataUserPresenceChangedEXT.Ptr, but with the new size.
@NotNull XrEventDataVirtualKeyboardBackspaceMETA.Ptr	XrEventDataVirtualKeyboardBackspaceMETA.Ptr.reinterpret(long newSize)	Assume the XrEventDataVirtualKeyboardBackspaceMETA.Ptr is capable of holding at least newSize structures, create a new view XrEventDataVirtualKeyboardBackspaceMETA.Ptr that uses the same backing storage as this XrEventDataVirtualKeyboardBackspaceMETA.Ptr, but with the new size.
@NotNull XrEventDataVirtualKeyboardCommitTextMETA.Ptr	XrEventDataVirtualKeyboardCommitTextMETA.Ptr.reinterpret(long newSize)	Assume the XrEventDataVirtualKeyboardCommitTextMETA.Ptr is capable of holding at least newSize structures, create a new view XrEventDataVirtualKeyboardCommitTextMETA.Ptr that uses the same backing storage as this XrEventDataVirtualKeyboardCommitTextMETA.Ptr, but with the new size.
@NotNull XrEventDataVirtualKeyboardEnterMETA.Ptr	XrEventDataVirtualKeyboardEnterMETA.Ptr.reinterpret(long newSize)	Assume the XrEventDataVirtualKeyboardEnterMETA.Ptr is capable of holding at least newSize structures, create a new view XrEventDataVirtualKeyboardEnterMETA.Ptr that uses the same backing storage as this XrEventDataVirtualKeyboardEnterMETA.Ptr, but with the new size.
@NotNull XrEventDataVirtualKeyboardHiddenMETA.Ptr	XrEventDataVirtualKeyboardHiddenMETA.Ptr.reinterpret(long newSize)	Assume the XrEventDataVirtualKeyboardHiddenMETA.Ptr is capable of holding at least newSize structures, create a new view XrEventDataVirtualKeyboardHiddenMETA.Ptr that uses the same backing storage as this XrEventDataVirtualKeyboardHiddenMETA.Ptr, but with the new size.
@NotNull XrEventDataVirtualKeyboardShownMETA.Ptr	XrEventDataVirtualKeyboardShownMETA.Ptr.reinterpret(long newSize)	Assume the XrEventDataVirtualKeyboardShownMETA.Ptr is capable of holding at least newSize structures, create a new view XrEventDataVirtualKeyboardShownMETA.Ptr that uses the same backing storage as this XrEventDataVirtualKeyboardShownMETA.Ptr, but with the new size.
@NotNull XrEventDataVisibilityMaskChangedKHR.Ptr	XrEventDataVisibilityMaskChangedKHR.Ptr.reinterpret(long newSize)	Assume the XrEventDataVisibilityMaskChangedKHR.Ptr is capable of holding at least newSize structures, create a new view XrEventDataVisibilityMaskChangedKHR.Ptr that uses the same backing storage as this XrEventDataVisibilityMaskChangedKHR.Ptr, but with the new size.
@NotNull XrEventDataViveTrackerConnectedHTCX.Ptr	XrEventDataViveTrackerConnectedHTCX.Ptr.reinterpret(long newSize)	Assume the XrEventDataViveTrackerConnectedHTCX.Ptr is capable of holding at least newSize structures, create a new view XrEventDataViveTrackerConnectedHTCX.Ptr that uses the same backing storage as this XrEventDataViveTrackerConnectedHTCX.Ptr, but with the new size.
@NotNull XrExtensionProperties.Ptr	XrExtensionProperties.Ptr.reinterpret(long newSize)	Assume the XrExtensionProperties.Ptr is capable of holding at least newSize structures, create a new view XrExtensionProperties.Ptr that uses the same backing storage as this XrExtensionProperties.Ptr, but with the new size.
@NotNull XrExtent2Df.Ptr	XrExtent2Df.Ptr.reinterpret(long newSize)	Assume the XrExtent2Df.Ptr is capable of holding at least newSize structures, create a new view XrExtent2Df.Ptr that uses the same backing storage as this XrExtent2Df.Ptr, but with the new size.
@NotNull XrExtent2Di.Ptr	XrExtent2Di.Ptr.reinterpret(long newSize)	Assume the XrExtent2Di.Ptr is capable of holding at least newSize structures, create a new view XrExtent2Di.Ptr that uses the same backing storage as this XrExtent2Di.Ptr, but with the new size.
@NotNull XrExtent3Df.Ptr	XrExtent3Df.Ptr.reinterpret(long newSize)	Assume the XrExtent3Df.Ptr is capable of holding at least newSize structures, create a new view XrExtent3Df.Ptr that uses the same backing storage as this XrExtent3Df.Ptr, but with the new size.
@NotNull XrExtent3DfEXT.Ptr	XrExtent3DfEXT.Ptr.reinterpret(long newSize)	Assume the XrExtent3DfEXT.Ptr is capable of holding at least newSize structures, create a new view XrExtent3DfEXT.Ptr that uses the same backing storage as this XrExtent3DfEXT.Ptr, but with the new size.
@NotNull XrExtent3DfFB.Ptr	XrExtent3DfFB.Ptr.reinterpret(long newSize)	Assume the XrExtent3DfFB.Ptr is capable of holding at least newSize structures, create a new view XrExtent3DfFB.Ptr that uses the same backing storage as this XrExtent3DfFB.Ptr, but with the new size.
@NotNull XrExtent3DfKHR.Ptr	XrExtent3DfKHR.Ptr.reinterpret(long newSize)	Assume the XrExtent3DfKHR.Ptr is capable of holding at least newSize structures, create a new view XrExtent3DfKHR.Ptr that uses the same backing storage as this XrExtent3DfKHR.Ptr, but with the new size.
@NotNull XrExternalCameraExtrinsicsOCULUS.Ptr	XrExternalCameraExtrinsicsOCULUS.Ptr.reinterpret(long newSize)	Assume the XrExternalCameraExtrinsicsOCULUS.Ptr is capable of holding at least newSize structures, create a new view XrExternalCameraExtrinsicsOCULUS.Ptr that uses the same backing storage as this XrExternalCameraExtrinsicsOCULUS.Ptr, but with the new size.
@NotNull XrExternalCameraIntrinsicsOCULUS.Ptr	XrExternalCameraIntrinsicsOCULUS.Ptr.reinterpret(long newSize)	Assume the XrExternalCameraIntrinsicsOCULUS.Ptr is capable of holding at least newSize structures, create a new view XrExternalCameraIntrinsicsOCULUS.Ptr that uses the same backing storage as this XrExternalCameraIntrinsicsOCULUS.Ptr, but with the new size.
@NotNull XrExternalCameraOCULUS.Ptr	XrExternalCameraOCULUS.Ptr.reinterpret(long newSize)	Assume the XrExternalCameraOCULUS.Ptr is capable of holding at least newSize structures, create a new view XrExternalCameraOCULUS.Ptr that uses the same backing storage as this XrExternalCameraOCULUS.Ptr, but with the new size.
@NotNull XrEyeGazeFB.Ptr	XrEyeGazeFB.Ptr.reinterpret(long newSize)	Assume the XrEyeGazeFB.Ptr is capable of holding at least newSize structures, create a new view XrEyeGazeFB.Ptr that uses the same backing storage as this XrEyeGazeFB.Ptr, but with the new size.
@NotNull XrEyeGazeSampleTimeEXT.Ptr	XrEyeGazeSampleTimeEXT.Ptr.reinterpret(long newSize)	Assume the XrEyeGazeSampleTimeEXT.Ptr is capable of holding at least newSize structures, create a new view XrEyeGazeSampleTimeEXT.Ptr that uses the same backing storage as this XrEyeGazeSampleTimeEXT.Ptr, but with the new size.
@NotNull XrEyeGazesFB.Ptr	XrEyeGazesFB.Ptr.reinterpret(long newSize)	Assume the XrEyeGazesFB.Ptr is capable of holding at least newSize structures, create a new view XrEyeGazesFB.Ptr that uses the same backing storage as this XrEyeGazesFB.Ptr, but with the new size.
@NotNull XrEyeGazesInfoFB.Ptr	XrEyeGazesInfoFB.Ptr.reinterpret(long newSize)	Assume the XrEyeGazesInfoFB.Ptr is capable of holding at least newSize structures, create a new view XrEyeGazesInfoFB.Ptr that uses the same backing storage as this XrEyeGazesInfoFB.Ptr, but with the new size.
@NotNull XrEyeTrackerCreateInfoFB.Ptr	XrEyeTrackerCreateInfoFB.Ptr.reinterpret(long newSize)	Assume the XrEyeTrackerCreateInfoFB.Ptr is capable of holding at least newSize structures, create a new view XrEyeTrackerCreateInfoFB.Ptr that uses the same backing storage as this XrEyeTrackerCreateInfoFB.Ptr, but with the new size.
@NotNull XrFaceExpressionInfo2FB.Ptr	XrFaceExpressionInfo2FB.Ptr.reinterpret(long newSize)	Assume the XrFaceExpressionInfo2FB.Ptr is capable of holding at least newSize structures, create a new view XrFaceExpressionInfo2FB.Ptr that uses the same backing storage as this XrFaceExpressionInfo2FB.Ptr, but with the new size.
@NotNull XrFaceExpressionInfoFB.Ptr	XrFaceExpressionInfoFB.Ptr.reinterpret(long newSize)	Assume the XrFaceExpressionInfoFB.Ptr is capable of holding at least newSize structures, create a new view XrFaceExpressionInfoFB.Ptr that uses the same backing storage as this XrFaceExpressionInfoFB.Ptr, but with the new size.
@NotNull XrFaceExpressionStatusFB.Ptr	XrFaceExpressionStatusFB.Ptr.reinterpret(long newSize)	Assume the XrFaceExpressionStatusFB.Ptr is capable of holding at least newSize structures, create a new view XrFaceExpressionStatusFB.Ptr that uses the same backing storage as this XrFaceExpressionStatusFB.Ptr, but with the new size.
@NotNull XrFaceExpressionWeights2FB.Ptr	XrFaceExpressionWeights2FB.Ptr.reinterpret(long newSize)	Assume the XrFaceExpressionWeights2FB.Ptr is capable of holding at least newSize structures, create a new view XrFaceExpressionWeights2FB.Ptr that uses the same backing storage as this XrFaceExpressionWeights2FB.Ptr, but with the new size.
@NotNull XrFaceExpressionWeightsFB.Ptr	XrFaceExpressionWeightsFB.Ptr.reinterpret(long newSize)	Assume the XrFaceExpressionWeightsFB.Ptr is capable of holding at least newSize structures, create a new view XrFaceExpressionWeightsFB.Ptr that uses the same backing storage as this XrFaceExpressionWeightsFB.Ptr, but with the new size.
@NotNull XrFaceTrackerCreateInfo2FB.Ptr	XrFaceTrackerCreateInfo2FB.Ptr.reinterpret(long newSize)	Assume the XrFaceTrackerCreateInfo2FB.Ptr is capable of holding at least newSize structures, create a new view XrFaceTrackerCreateInfo2FB.Ptr that uses the same backing storage as this XrFaceTrackerCreateInfo2FB.Ptr, but with the new size.
@NotNull XrFaceTrackerCreateInfoFB.Ptr	XrFaceTrackerCreateInfoFB.Ptr.reinterpret(long newSize)	Assume the XrFaceTrackerCreateInfoFB.Ptr is capable of holding at least newSize structures, create a new view XrFaceTrackerCreateInfoFB.Ptr that uses the same backing storage as this XrFaceTrackerCreateInfoFB.Ptr, but with the new size.
@NotNull XrFacialExpressionBlendShapeGetInfoML.Ptr	XrFacialExpressionBlendShapeGetInfoML.Ptr.reinterpret(long newSize)	Assume the XrFacialExpressionBlendShapeGetInfoML.Ptr is capable of holding at least newSize structures, create a new view XrFacialExpressionBlendShapeGetInfoML.Ptr that uses the same backing storage as this XrFacialExpressionBlendShapeGetInfoML.Ptr, but with the new size.
@NotNull XrFacialExpressionBlendShapePropertiesML.Ptr	XrFacialExpressionBlendShapePropertiesML.Ptr.reinterpret(long newSize)	Assume the XrFacialExpressionBlendShapePropertiesML.Ptr is capable of holding at least newSize structures, create a new view XrFacialExpressionBlendShapePropertiesML.Ptr that uses the same backing storage as this XrFacialExpressionBlendShapePropertiesML.Ptr, but with the new size.
@NotNull XrFacialExpressionClientCreateInfoML.Ptr	XrFacialExpressionClientCreateInfoML.Ptr.reinterpret(long newSize)	Assume the XrFacialExpressionClientCreateInfoML.Ptr is capable of holding at least newSize structures, create a new view XrFacialExpressionClientCreateInfoML.Ptr that uses the same backing storage as this XrFacialExpressionClientCreateInfoML.Ptr, but with the new size.
@NotNull XrFacialExpressionsHTC.Ptr	XrFacialExpressionsHTC.Ptr.reinterpret(long newSize)	Assume the XrFacialExpressionsHTC.Ptr is capable of holding at least newSize structures, create a new view XrFacialExpressionsHTC.Ptr that uses the same backing storage as this XrFacialExpressionsHTC.Ptr, but with the new size.
@NotNull XrFacialTrackerCreateInfoHTC.Ptr	XrFacialTrackerCreateInfoHTC.Ptr.reinterpret(long newSize)	Assume the XrFacialTrackerCreateInfoHTC.Ptr is capable of holding at least newSize structures, create a new view XrFacialTrackerCreateInfoHTC.Ptr that uses the same backing storage as this XrFacialTrackerCreateInfoHTC.Ptr, but with the new size.
@NotNull XrForceFeedbackCurlApplyLocationMNDX.Ptr	XrForceFeedbackCurlApplyLocationMNDX.Ptr.reinterpret(long newSize)	Assume the XrForceFeedbackCurlApplyLocationMNDX.Ptr is capable of holding at least newSize structures, create a new view XrForceFeedbackCurlApplyLocationMNDX.Ptr that uses the same backing storage as this XrForceFeedbackCurlApplyLocationMNDX.Ptr, but with the new size.
@NotNull XrForceFeedbackCurlApplyLocationsMNDX.Ptr	XrForceFeedbackCurlApplyLocationsMNDX.Ptr.reinterpret(long newSize)	Assume the XrForceFeedbackCurlApplyLocationsMNDX.Ptr is capable of holding at least newSize structures, create a new view XrForceFeedbackCurlApplyLocationsMNDX.Ptr that uses the same backing storage as this XrForceFeedbackCurlApplyLocationsMNDX.Ptr, but with the new size.
@NotNull XrFoveatedViewConfigurationViewVARJO.Ptr	XrFoveatedViewConfigurationViewVARJO.Ptr.reinterpret(long newSize)	Assume the XrFoveatedViewConfigurationViewVARJO.Ptr is capable of holding at least newSize structures, create a new view XrFoveatedViewConfigurationViewVARJO.Ptr that uses the same backing storage as this XrFoveatedViewConfigurationViewVARJO.Ptr, but with the new size.
@NotNull XrFoveationApplyInfoHTC.Ptr	XrFoveationApplyInfoHTC.Ptr.reinterpret(long newSize)	Assume the XrFoveationApplyInfoHTC.Ptr is capable of holding at least newSize structures, create a new view XrFoveationApplyInfoHTC.Ptr that uses the same backing storage as this XrFoveationApplyInfoHTC.Ptr, but with the new size.
@NotNull XrFoveationConfigurationHTC.Ptr	XrFoveationConfigurationHTC.Ptr.reinterpret(long newSize)	Assume the XrFoveationConfigurationHTC.Ptr is capable of holding at least newSize structures, create a new view XrFoveationConfigurationHTC.Ptr that uses the same backing storage as this XrFoveationConfigurationHTC.Ptr, but with the new size.
@NotNull XrFoveationCustomModeInfoHTC.Ptr	XrFoveationCustomModeInfoHTC.Ptr.reinterpret(long newSize)	Assume the XrFoveationCustomModeInfoHTC.Ptr is capable of holding at least newSize structures, create a new view XrFoveationCustomModeInfoHTC.Ptr that uses the same backing storage as this XrFoveationCustomModeInfoHTC.Ptr, but with the new size.
@NotNull XrFoveationDynamicModeInfoHTC.Ptr	XrFoveationDynamicModeInfoHTC.Ptr.reinterpret(long newSize)	Assume the XrFoveationDynamicModeInfoHTC.Ptr is capable of holding at least newSize structures, create a new view XrFoveationDynamicModeInfoHTC.Ptr that uses the same backing storage as this XrFoveationDynamicModeInfoHTC.Ptr, but with the new size.
@NotNull XrFoveationEyeTrackedProfileCreateInfoMETA.Ptr	XrFoveationEyeTrackedProfileCreateInfoMETA.Ptr.reinterpret(long newSize)	Assume the XrFoveationEyeTrackedProfileCreateInfoMETA.Ptr is capable of holding at least newSize structures, create a new view XrFoveationEyeTrackedProfileCreateInfoMETA.Ptr that uses the same backing storage as this XrFoveationEyeTrackedProfileCreateInfoMETA.Ptr, but with the new size.
@NotNull XrFoveationEyeTrackedStateMETA.Ptr	XrFoveationEyeTrackedStateMETA.Ptr.reinterpret(long newSize)	Assume the XrFoveationEyeTrackedStateMETA.Ptr is capable of holding at least newSize structures, create a new view XrFoveationEyeTrackedStateMETA.Ptr that uses the same backing storage as this XrFoveationEyeTrackedStateMETA.Ptr, but with the new size.
@NotNull XrFoveationLevelProfileCreateInfoFB.Ptr	XrFoveationLevelProfileCreateInfoFB.Ptr.reinterpret(long newSize)	Assume the XrFoveationLevelProfileCreateInfoFB.Ptr is capable of holding at least newSize structures, create a new view XrFoveationLevelProfileCreateInfoFB.Ptr that uses the same backing storage as this XrFoveationLevelProfileCreateInfoFB.Ptr, but with the new size.
@NotNull XrFoveationProfileCreateInfoFB.Ptr	XrFoveationProfileCreateInfoFB.Ptr.reinterpret(long newSize)	Assume the XrFoveationProfileCreateInfoFB.Ptr is capable of holding at least newSize structures, create a new view XrFoveationProfileCreateInfoFB.Ptr that uses the same backing storage as this XrFoveationProfileCreateInfoFB.Ptr, but with the new size.
@NotNull XrFovf.Ptr	XrFovf.Ptr.reinterpret(long newSize)	Assume the XrFovf.Ptr is capable of holding at least newSize structures, create a new view XrFovf.Ptr that uses the same backing storage as this XrFovf.Ptr, but with the new size.
@NotNull XrFrameBeginInfo.Ptr	XrFrameBeginInfo.Ptr.reinterpret(long newSize)	Assume the XrFrameBeginInfo.Ptr is capable of holding at least newSize structures, create a new view XrFrameBeginInfo.Ptr that uses the same backing storage as this XrFrameBeginInfo.Ptr, but with the new size.
@NotNull XrFrameEndInfo.Ptr	XrFrameEndInfo.Ptr.reinterpret(long newSize)	Assume the XrFrameEndInfo.Ptr is capable of holding at least newSize structures, create a new view XrFrameEndInfo.Ptr that uses the same backing storage as this XrFrameEndInfo.Ptr, but with the new size.
@NotNull XrFrameEndInfoML.Ptr	XrFrameEndInfoML.Ptr.reinterpret(long newSize)	Assume the XrFrameEndInfoML.Ptr is capable of holding at least newSize structures, create a new view XrFrameEndInfoML.Ptr that uses the same backing storage as this XrFrameEndInfoML.Ptr, but with the new size.
@NotNull XrFrameState.Ptr	XrFrameState.Ptr.reinterpret(long newSize)	Assume the XrFrameState.Ptr is capable of holding at least newSize structures, create a new view XrFrameState.Ptr that uses the same backing storage as this XrFrameState.Ptr, but with the new size.
@NotNull XrFrameSynthesisConfigViewEXT.Ptr	XrFrameSynthesisConfigViewEXT.Ptr.reinterpret(long newSize)	Assume the XrFrameSynthesisConfigViewEXT.Ptr is capable of holding at least newSize structures, create a new view XrFrameSynthesisConfigViewEXT.Ptr that uses the same backing storage as this XrFrameSynthesisConfigViewEXT.Ptr, but with the new size.
@NotNull XrFrameSynthesisInfoEXT.Ptr	XrFrameSynthesisInfoEXT.Ptr.reinterpret(long newSize)	Assume the XrFrameSynthesisInfoEXT.Ptr is capable of holding at least newSize structures, create a new view XrFrameSynthesisInfoEXT.Ptr that uses the same backing storage as this XrFrameSynthesisInfoEXT.Ptr, but with the new size.
@NotNull XrFrameWaitInfo.Ptr	XrFrameWaitInfo.Ptr.reinterpret(long newSize)	Assume the XrFrameWaitInfo.Ptr is capable of holding at least newSize structures, create a new view XrFrameWaitInfo.Ptr that uses the same backing storage as this XrFrameWaitInfo.Ptr, but with the new size.
@NotNull XrFrustumf.Ptr	XrFrustumf.Ptr.reinterpret(long newSize)	Assume the XrFrustumf.Ptr is capable of holding at least newSize structures, create a new view XrFrustumf.Ptr that uses the same backing storage as this XrFrustumf.Ptr, but with the new size.
@NotNull XrFrustumfKHR.Ptr	XrFrustumfKHR.Ptr.reinterpret(long newSize)	Assume the XrFrustumfKHR.Ptr is capable of holding at least newSize structures, create a new view XrFrustumfKHR.Ptr that uses the same backing storage as this XrFrustumfKHR.Ptr, but with the new size.
@NotNull XrFutureCancelInfoEXT.Ptr	XrFutureCancelInfoEXT.Ptr.reinterpret(long newSize)	Assume the XrFutureCancelInfoEXT.Ptr is capable of holding at least newSize structures, create a new view XrFutureCancelInfoEXT.Ptr that uses the same backing storage as this XrFutureCancelInfoEXT.Ptr, but with the new size.
@NotNull XrFutureCompletionBaseHeaderEXT.Ptr	XrFutureCompletionBaseHeaderEXT.Ptr.reinterpret(long newSize)	Assume the XrFutureCompletionBaseHeaderEXT.Ptr is capable of holding at least newSize structures, create a new view XrFutureCompletionBaseHeaderEXT.Ptr that uses the same backing storage as this XrFutureCompletionBaseHeaderEXT.Ptr, but with the new size.
@NotNull XrFutureCompletionEXT.Ptr	XrFutureCompletionEXT.Ptr.reinterpret(long newSize)	Assume the XrFutureCompletionEXT.Ptr is capable of holding at least newSize structures, create a new view XrFutureCompletionEXT.Ptr that uses the same backing storage as this XrFutureCompletionEXT.Ptr, but with the new size.
@NotNull XrFuturePollInfoEXT.Ptr	XrFuturePollInfoEXT.Ptr.reinterpret(long newSize)	Assume the XrFuturePollInfoEXT.Ptr is capable of holding at least newSize structures, create a new view XrFuturePollInfoEXT.Ptr that uses the same backing storage as this XrFuturePollInfoEXT.Ptr, but with the new size.
@NotNull XrFuturePollResultEXT.Ptr	XrFuturePollResultEXT.Ptr.reinterpret(long newSize)	Assume the XrFuturePollResultEXT.Ptr is capable of holding at least newSize structures, create a new view XrFuturePollResultEXT.Ptr that uses the same backing storage as this XrFuturePollResultEXT.Ptr, but with the new size.
@NotNull XrFuturePollResultProgressBD.Ptr	XrFuturePollResultProgressBD.Ptr.reinterpret(long newSize)	Assume the XrFuturePollResultProgressBD.Ptr is capable of holding at least newSize structures, create a new view XrFuturePollResultProgressBD.Ptr that uses the same backing storage as this XrFuturePollResultProgressBD.Ptr, but with the new size.
@NotNull XrGeometryInstanceCreateInfoFB.Ptr	XrGeometryInstanceCreateInfoFB.Ptr.reinterpret(long newSize)	Assume the XrGeometryInstanceCreateInfoFB.Ptr is capable of holding at least newSize structures, create a new view XrGeometryInstanceCreateInfoFB.Ptr that uses the same backing storage as this XrGeometryInstanceCreateInfoFB.Ptr, but with the new size.
@NotNull XrGeometryInstanceTransformFB.Ptr	XrGeometryInstanceTransformFB.Ptr.reinterpret(long newSize)	Assume the XrGeometryInstanceTransformFB.Ptr is capable of holding at least newSize structures, create a new view XrGeometryInstanceTransformFB.Ptr that uses the same backing storage as this XrGeometryInstanceTransformFB.Ptr, but with the new size.
@NotNull XrGlobalDimmerFrameEndInfoML.Ptr	XrGlobalDimmerFrameEndInfoML.Ptr.reinterpret(long newSize)	Assume the XrGlobalDimmerFrameEndInfoML.Ptr is capable of holding at least newSize structures, create a new view XrGlobalDimmerFrameEndInfoML.Ptr that uses the same backing storage as this XrGlobalDimmerFrameEndInfoML.Ptr, but with the new size.
@NotNull XrGraphicsBindingD3D11KHR.Ptr	XrGraphicsBindingD3D11KHR.Ptr.reinterpret(long newSize)	Assume the XrGraphicsBindingD3D11KHR.Ptr is capable of holding at least newSize structures, create a new view XrGraphicsBindingD3D11KHR.Ptr that uses the same backing storage as this XrGraphicsBindingD3D11KHR.Ptr, but with the new size.
@NotNull XrGraphicsBindingD3D12KHR.Ptr	XrGraphicsBindingD3D12KHR.Ptr.reinterpret(long newSize)	Assume the XrGraphicsBindingD3D12KHR.Ptr is capable of holding at least newSize structures, create a new view XrGraphicsBindingD3D12KHR.Ptr that uses the same backing storage as this XrGraphicsBindingD3D12KHR.Ptr, but with the new size.
@NotNull XrGraphicsBindingEGLMNDX.Ptr	XrGraphicsBindingEGLMNDX.Ptr.reinterpret(long newSize)	Assume the XrGraphicsBindingEGLMNDX.Ptr is capable of holding at least newSize structures, create a new view XrGraphicsBindingEGLMNDX.Ptr that uses the same backing storage as this XrGraphicsBindingEGLMNDX.Ptr, but with the new size.
@NotNull XrGraphicsBindingMetalKHR.Ptr	XrGraphicsBindingMetalKHR.Ptr.reinterpret(long newSize)	Assume the XrGraphicsBindingMetalKHR.Ptr is capable of holding at least newSize structures, create a new view XrGraphicsBindingMetalKHR.Ptr that uses the same backing storage as this XrGraphicsBindingMetalKHR.Ptr, but with the new size.
@NotNull XrGraphicsBindingOpenGLESAndroidKHR.Ptr	XrGraphicsBindingOpenGLESAndroidKHR.Ptr.reinterpret(long newSize)	Assume the XrGraphicsBindingOpenGLESAndroidKHR.Ptr is capable of holding at least newSize structures, create a new view XrGraphicsBindingOpenGLESAndroidKHR.Ptr that uses the same backing storage as this XrGraphicsBindingOpenGLESAndroidKHR.Ptr, but with the new size.
@NotNull XrGraphicsBindingOpenGLWaylandKHR.Ptr	XrGraphicsBindingOpenGLWaylandKHR.Ptr.reinterpret(long newSize)	Assume the XrGraphicsBindingOpenGLWaylandKHR.Ptr is capable of holding at least newSize structures, create a new view XrGraphicsBindingOpenGLWaylandKHR.Ptr that uses the same backing storage as this XrGraphicsBindingOpenGLWaylandKHR.Ptr, but with the new size.
@NotNull XrGraphicsBindingOpenGLWin32KHR.Ptr	XrGraphicsBindingOpenGLWin32KHR.Ptr.reinterpret(long newSize)	Assume the XrGraphicsBindingOpenGLWin32KHR.Ptr is capable of holding at least newSize structures, create a new view XrGraphicsBindingOpenGLWin32KHR.Ptr that uses the same backing storage as this XrGraphicsBindingOpenGLWin32KHR.Ptr, but with the new size.
@NotNull XrGraphicsBindingOpenGLXcbKHR.Ptr	XrGraphicsBindingOpenGLXcbKHR.Ptr.reinterpret(long newSize)	Assume the XrGraphicsBindingOpenGLXcbKHR.Ptr is capable of holding at least newSize structures, create a new view XrGraphicsBindingOpenGLXcbKHR.Ptr that uses the same backing storage as this XrGraphicsBindingOpenGLXcbKHR.Ptr, but with the new size.
@NotNull XrGraphicsBindingOpenGLXlibKHR.Ptr	XrGraphicsBindingOpenGLXlibKHR.Ptr.reinterpret(long newSize)	Assume the XrGraphicsBindingOpenGLXlibKHR.Ptr is capable of holding at least newSize structures, create a new view XrGraphicsBindingOpenGLXlibKHR.Ptr that uses the same backing storage as this XrGraphicsBindingOpenGLXlibKHR.Ptr, but with the new size.
@NotNull XrGraphicsBindingVulkan2KHR.Ptr	XrGraphicsBindingVulkan2KHR.Ptr.reinterpret(long newSize)	Assume the XrGraphicsBindingVulkan2KHR.Ptr is capable of holding at least newSize structures, create a new view XrGraphicsBindingVulkan2KHR.Ptr that uses the same backing storage as this XrGraphicsBindingVulkan2KHR.Ptr, but with the new size.
@NotNull XrGraphicsBindingVulkanKHR.Ptr	XrGraphicsBindingVulkanKHR.Ptr.reinterpret(long newSize)	Assume the XrGraphicsBindingVulkanKHR.Ptr is capable of holding at least newSize structures, create a new view XrGraphicsBindingVulkanKHR.Ptr that uses the same backing storage as this XrGraphicsBindingVulkanKHR.Ptr, but with the new size.
@NotNull XrGraphicsRequirementsD3D11KHR.Ptr	XrGraphicsRequirementsD3D11KHR.Ptr.reinterpret(long newSize)	Assume the XrGraphicsRequirementsD3D11KHR.Ptr is capable of holding at least newSize structures, create a new view XrGraphicsRequirementsD3D11KHR.Ptr that uses the same backing storage as this XrGraphicsRequirementsD3D11KHR.Ptr, but with the new size.
@NotNull XrGraphicsRequirementsD3D12KHR.Ptr	XrGraphicsRequirementsD3D12KHR.Ptr.reinterpret(long newSize)	Assume the XrGraphicsRequirementsD3D12KHR.Ptr is capable of holding at least newSize structures, create a new view XrGraphicsRequirementsD3D12KHR.Ptr that uses the same backing storage as this XrGraphicsRequirementsD3D12KHR.Ptr, but with the new size.
@NotNull XrGraphicsRequirementsMetalKHR.Ptr	XrGraphicsRequirementsMetalKHR.Ptr.reinterpret(long newSize)	Assume the XrGraphicsRequirementsMetalKHR.Ptr is capable of holding at least newSize structures, create a new view XrGraphicsRequirementsMetalKHR.Ptr that uses the same backing storage as this XrGraphicsRequirementsMetalKHR.Ptr, but with the new size.
@NotNull XrGraphicsRequirementsOpenGLESKHR.Ptr	XrGraphicsRequirementsOpenGLESKHR.Ptr.reinterpret(long newSize)	Assume the XrGraphicsRequirementsOpenGLESKHR.Ptr is capable of holding at least newSize structures, create a new view XrGraphicsRequirementsOpenGLESKHR.Ptr that uses the same backing storage as this XrGraphicsRequirementsOpenGLESKHR.Ptr, but with the new size.
@NotNull XrGraphicsRequirementsOpenGLKHR.Ptr	XrGraphicsRequirementsOpenGLKHR.Ptr.reinterpret(long newSize)	Assume the XrGraphicsRequirementsOpenGLKHR.Ptr is capable of holding at least newSize structures, create a new view XrGraphicsRequirementsOpenGLKHR.Ptr that uses the same backing storage as this XrGraphicsRequirementsOpenGLKHR.Ptr, but with the new size.
@NotNull XrGraphicsRequirementsVulkan2KHR.Ptr	XrGraphicsRequirementsVulkan2KHR.Ptr.reinterpret(long newSize)	Assume the XrGraphicsRequirementsVulkan2KHR.Ptr is capable of holding at least newSize structures, create a new view XrGraphicsRequirementsVulkan2KHR.Ptr that uses the same backing storage as this XrGraphicsRequirementsVulkan2KHR.Ptr, but with the new size.
@NotNull XrGraphicsRequirementsVulkanKHR.Ptr	XrGraphicsRequirementsVulkanKHR.Ptr.reinterpret(long newSize)	Assume the XrGraphicsRequirementsVulkanKHR.Ptr is capable of holding at least newSize structures, create a new view XrGraphicsRequirementsVulkanKHR.Ptr that uses the same backing storage as this XrGraphicsRequirementsVulkanKHR.Ptr, but with the new size.
@NotNull XrHandCapsuleFB.Ptr	XrHandCapsuleFB.Ptr.reinterpret(long newSize)	Assume the XrHandCapsuleFB.Ptr is capable of holding at least newSize structures, create a new view XrHandCapsuleFB.Ptr that uses the same backing storage as this XrHandCapsuleFB.Ptr, but with the new size.
@NotNull XrHandJointLocationEXT.Ptr	XrHandJointLocationEXT.Ptr.reinterpret(long newSize)	Assume the XrHandJointLocationEXT.Ptr is capable of holding at least newSize structures, create a new view XrHandJointLocationEXT.Ptr that uses the same backing storage as this XrHandJointLocationEXT.Ptr, but with the new size.
@NotNull XrHandJointLocationsEXT.Ptr	XrHandJointLocationsEXT.Ptr.reinterpret(long newSize)	Assume the XrHandJointLocationsEXT.Ptr is capable of holding at least newSize structures, create a new view XrHandJointLocationsEXT.Ptr that uses the same backing storage as this XrHandJointLocationsEXT.Ptr, but with the new size.
@NotNull XrHandJointsLocateInfoEXT.Ptr	XrHandJointsLocateInfoEXT.Ptr.reinterpret(long newSize)	Assume the XrHandJointsLocateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view XrHandJointsLocateInfoEXT.Ptr that uses the same backing storage as this XrHandJointsLocateInfoEXT.Ptr, but with the new size.
@NotNull XrHandJointsMotionRangeInfoEXT.Ptr	XrHandJointsMotionRangeInfoEXT.Ptr.reinterpret(long newSize)	Assume the XrHandJointsMotionRangeInfoEXT.Ptr is capable of holding at least newSize structures, create a new view XrHandJointsMotionRangeInfoEXT.Ptr that uses the same backing storage as this XrHandJointsMotionRangeInfoEXT.Ptr, but with the new size.
@NotNull XrHandJointVelocitiesEXT.Ptr	XrHandJointVelocitiesEXT.Ptr.reinterpret(long newSize)	Assume the XrHandJointVelocitiesEXT.Ptr is capable of holding at least newSize structures, create a new view XrHandJointVelocitiesEXT.Ptr that uses the same backing storage as this XrHandJointVelocitiesEXT.Ptr, but with the new size.
@NotNull XrHandJointVelocityEXT.Ptr	XrHandJointVelocityEXT.Ptr.reinterpret(long newSize)	Assume the XrHandJointVelocityEXT.Ptr is capable of holding at least newSize structures, create a new view XrHandJointVelocityEXT.Ptr that uses the same backing storage as this XrHandJointVelocityEXT.Ptr, but with the new size.
@NotNull XrHandMeshIndexBufferMSFT.Ptr	XrHandMeshIndexBufferMSFT.Ptr.reinterpret(long newSize)	Assume the XrHandMeshIndexBufferMSFT.Ptr is capable of holding at least newSize structures, create a new view XrHandMeshIndexBufferMSFT.Ptr that uses the same backing storage as this XrHandMeshIndexBufferMSFT.Ptr, but with the new size.
@NotNull XrHandMeshMSFT.Ptr	XrHandMeshMSFT.Ptr.reinterpret(long newSize)	Assume the XrHandMeshMSFT.Ptr is capable of holding at least newSize structures, create a new view XrHandMeshMSFT.Ptr that uses the same backing storage as this XrHandMeshMSFT.Ptr, but with the new size.
@NotNull XrHandMeshSpaceCreateInfoMSFT.Ptr	XrHandMeshSpaceCreateInfoMSFT.Ptr.reinterpret(long newSize)	Assume the XrHandMeshSpaceCreateInfoMSFT.Ptr is capable of holding at least newSize structures, create a new view XrHandMeshSpaceCreateInfoMSFT.Ptr that uses the same backing storage as this XrHandMeshSpaceCreateInfoMSFT.Ptr, but with the new size.
@NotNull XrHandMeshUpdateInfoMSFT.Ptr	XrHandMeshUpdateInfoMSFT.Ptr.reinterpret(long newSize)	Assume the XrHandMeshUpdateInfoMSFT.Ptr is capable of holding at least newSize structures, create a new view XrHandMeshUpdateInfoMSFT.Ptr that uses the same backing storage as this XrHandMeshUpdateInfoMSFT.Ptr, but with the new size.
@NotNull XrHandMeshVertexBufferMSFT.Ptr	XrHandMeshVertexBufferMSFT.Ptr.reinterpret(long newSize)	Assume the XrHandMeshVertexBufferMSFT.Ptr is capable of holding at least newSize structures, create a new view XrHandMeshVertexBufferMSFT.Ptr that uses the same backing storage as this XrHandMeshVertexBufferMSFT.Ptr, but with the new size.
@NotNull XrHandMeshVertexMSFT.Ptr	XrHandMeshVertexMSFT.Ptr.reinterpret(long newSize)	Assume the XrHandMeshVertexMSFT.Ptr is capable of holding at least newSize structures, create a new view XrHandMeshVertexMSFT.Ptr that uses the same backing storage as this XrHandMeshVertexMSFT.Ptr, but with the new size.
@NotNull XrHandPoseTypeInfoMSFT.Ptr	XrHandPoseTypeInfoMSFT.Ptr.reinterpret(long newSize)	Assume the XrHandPoseTypeInfoMSFT.Ptr is capable of holding at least newSize structures, create a new view XrHandPoseTypeInfoMSFT.Ptr that uses the same backing storage as this XrHandPoseTypeInfoMSFT.Ptr, but with the new size.
@NotNull XrHandTrackerCreateInfoEXT.Ptr	XrHandTrackerCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the XrHandTrackerCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view XrHandTrackerCreateInfoEXT.Ptr that uses the same backing storage as this XrHandTrackerCreateInfoEXT.Ptr, but with the new size.
@NotNull XrHandTrackingAimStateFB.Ptr	XrHandTrackingAimStateFB.Ptr.reinterpret(long newSize)	Assume the XrHandTrackingAimStateFB.Ptr is capable of holding at least newSize structures, create a new view XrHandTrackingAimStateFB.Ptr that uses the same backing storage as this XrHandTrackingAimStateFB.Ptr, but with the new size.
@NotNull XrHandTrackingCapsulesStateFB.Ptr	XrHandTrackingCapsulesStateFB.Ptr.reinterpret(long newSize)	Assume the XrHandTrackingCapsulesStateFB.Ptr is capable of holding at least newSize structures, create a new view XrHandTrackingCapsulesStateFB.Ptr that uses the same backing storage as this XrHandTrackingCapsulesStateFB.Ptr, but with the new size.
@NotNull XrHandTrackingDataSourceInfoEXT.Ptr	XrHandTrackingDataSourceInfoEXT.Ptr.reinterpret(long newSize)	Assume the XrHandTrackingDataSourceInfoEXT.Ptr is capable of holding at least newSize structures, create a new view XrHandTrackingDataSourceInfoEXT.Ptr that uses the same backing storage as this XrHandTrackingDataSourceInfoEXT.Ptr, but with the new size.
@NotNull XrHandTrackingDataSourceStateEXT.Ptr	XrHandTrackingDataSourceStateEXT.Ptr.reinterpret(long newSize)	Assume the XrHandTrackingDataSourceStateEXT.Ptr is capable of holding at least newSize structures, create a new view XrHandTrackingDataSourceStateEXT.Ptr that uses the same backing storage as this XrHandTrackingDataSourceStateEXT.Ptr, but with the new size.
@NotNull XrHandTrackingMeshFB.Ptr	XrHandTrackingMeshFB.Ptr.reinterpret(long newSize)	Assume the XrHandTrackingMeshFB.Ptr is capable of holding at least newSize structures, create a new view XrHandTrackingMeshFB.Ptr that uses the same backing storage as this XrHandTrackingMeshFB.Ptr, but with the new size.
@NotNull XrHandTrackingScaleFB.Ptr	XrHandTrackingScaleFB.Ptr.reinterpret(long newSize)	Assume the XrHandTrackingScaleFB.Ptr is capable of holding at least newSize structures, create a new view XrHandTrackingScaleFB.Ptr that uses the same backing storage as this XrHandTrackingScaleFB.Ptr, but with the new size.
@NotNull XrHapticActionInfo.Ptr	XrHapticActionInfo.Ptr.reinterpret(long newSize)	Assume the XrHapticActionInfo.Ptr is capable of holding at least newSize structures, create a new view XrHapticActionInfo.Ptr that uses the same backing storage as this XrHapticActionInfo.Ptr, but with the new size.
@NotNull XrHapticAmplitudeEnvelopeVibrationFB.Ptr	XrHapticAmplitudeEnvelopeVibrationFB.Ptr.reinterpret(long newSize)	Assume the XrHapticAmplitudeEnvelopeVibrationFB.Ptr is capable of holding at least newSize structures, create a new view XrHapticAmplitudeEnvelopeVibrationFB.Ptr that uses the same backing storage as this XrHapticAmplitudeEnvelopeVibrationFB.Ptr, but with the new size.
@NotNull XrHapticBaseHeader.Ptr	XrHapticBaseHeader.Ptr.reinterpret(long newSize)	Assume the XrHapticBaseHeader.Ptr is capable of holding at least newSize structures, create a new view XrHapticBaseHeader.Ptr that uses the same backing storage as this XrHapticBaseHeader.Ptr, but with the new size.
@NotNull XrHapticPcmVibrationFB.Ptr	XrHapticPcmVibrationFB.Ptr.reinterpret(long newSize)	Assume the XrHapticPcmVibrationFB.Ptr is capable of holding at least newSize structures, create a new view XrHapticPcmVibrationFB.Ptr that uses the same backing storage as this XrHapticPcmVibrationFB.Ptr, but with the new size.
@NotNull XrHapticVibration.Ptr	XrHapticVibration.Ptr.reinterpret(long newSize)	Assume the XrHapticVibration.Ptr is capable of holding at least newSize structures, create a new view XrHapticVibration.Ptr that uses the same backing storage as this XrHapticVibration.Ptr, but with the new size.
@NotNull XrHolographicWindowAttachmentMSFT.Ptr	XrHolographicWindowAttachmentMSFT.Ptr.reinterpret(long newSize)	Assume the XrHolographicWindowAttachmentMSFT.Ptr is capable of holding at least newSize structures, create a new view XrHolographicWindowAttachmentMSFT.Ptr that uses the same backing storage as this XrHolographicWindowAttachmentMSFT.Ptr, but with the new size.
@NotNull XrInputSourceLocalizedNameGetInfo.Ptr	XrInputSourceLocalizedNameGetInfo.Ptr.reinterpret(long newSize)	Assume the XrInputSourceLocalizedNameGetInfo.Ptr is capable of holding at least newSize structures, create a new view XrInputSourceLocalizedNameGetInfo.Ptr that uses the same backing storage as this XrInputSourceLocalizedNameGetInfo.Ptr, but with the new size.
@NotNull XrInstanceCreateInfo.Ptr	XrInstanceCreateInfo.Ptr.reinterpret(long newSize)	Assume the XrInstanceCreateInfo.Ptr is capable of holding at least newSize structures, create a new view XrInstanceCreateInfo.Ptr that uses the same backing storage as this XrInstanceCreateInfo.Ptr, but with the new size.
@NotNull XrInstanceCreateInfoAndroidKHR.Ptr	XrInstanceCreateInfoAndroidKHR.Ptr.reinterpret(long newSize)	Assume the XrInstanceCreateInfoAndroidKHR.Ptr is capable of holding at least newSize structures, create a new view XrInstanceCreateInfoAndroidKHR.Ptr that uses the same backing storage as this XrInstanceCreateInfoAndroidKHR.Ptr, but with the new size.
@NotNull XrInstanceProperties.Ptr	XrInstanceProperties.Ptr.reinterpret(long newSize)	Assume the XrInstanceProperties.Ptr is capable of holding at least newSize structures, create a new view XrInstanceProperties.Ptr that uses the same backing storage as this XrInstanceProperties.Ptr, but with the new size.
@NotNull XrInteractionProfileAnalogThresholdVALVE.Ptr	XrInteractionProfileAnalogThresholdVALVE.Ptr.reinterpret(long newSize)	Assume the XrInteractionProfileAnalogThresholdVALVE.Ptr is capable of holding at least newSize structures, create a new view XrInteractionProfileAnalogThresholdVALVE.Ptr that uses the same backing storage as this XrInteractionProfileAnalogThresholdVALVE.Ptr, but with the new size.
@NotNull XrInteractionProfileDpadBindingEXT.Ptr	XrInteractionProfileDpadBindingEXT.Ptr.reinterpret(long newSize)	Assume the XrInteractionProfileDpadBindingEXT.Ptr is capable of holding at least newSize structures, create a new view XrInteractionProfileDpadBindingEXT.Ptr that uses the same backing storage as this XrInteractionProfileDpadBindingEXT.Ptr, but with the new size.
@NotNull XrInteractionProfileState.Ptr	XrInteractionProfileState.Ptr.reinterpret(long newSize)	Assume the XrInteractionProfileState.Ptr is capable of holding at least newSize structures, create a new view XrInteractionProfileState.Ptr that uses the same backing storage as this XrInteractionProfileState.Ptr, but with the new size.
@NotNull XrInteractionProfileSuggestedBinding.Ptr	XrInteractionProfileSuggestedBinding.Ptr.reinterpret(long newSize)	Assume the XrInteractionProfileSuggestedBinding.Ptr is capable of holding at least newSize structures, create a new view XrInteractionProfileSuggestedBinding.Ptr that uses the same backing storage as this XrInteractionProfileSuggestedBinding.Ptr, but with the new size.
@NotNull XrInteractionRenderModelIdsEnumerateInfoEXT.Ptr	XrInteractionRenderModelIdsEnumerateInfoEXT.Ptr.reinterpret(long newSize)	Assume the XrInteractionRenderModelIdsEnumerateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view XrInteractionRenderModelIdsEnumerateInfoEXT.Ptr that uses the same backing storage as this XrInteractionRenderModelIdsEnumerateInfoEXT.Ptr, but with the new size.
@NotNull XrInteractionRenderModelSubactionPathInfoEXT.Ptr	XrInteractionRenderModelSubactionPathInfoEXT.Ptr.reinterpret(long newSize)	Assume the XrInteractionRenderModelSubactionPathInfoEXT.Ptr is capable of holding at least newSize structures, create a new view XrInteractionRenderModelSubactionPathInfoEXT.Ptr that uses the same backing storage as this XrInteractionRenderModelSubactionPathInfoEXT.Ptr, but with the new size.
@NotNull XrInteractionRenderModelTopLevelUserPathGetInfoEXT.Ptr	XrInteractionRenderModelTopLevelUserPathGetInfoEXT.Ptr.reinterpret(long newSize)	Assume the XrInteractionRenderModelTopLevelUserPathGetInfoEXT.Ptr is capable of holding at least newSize structures, create a new view XrInteractionRenderModelTopLevelUserPathGetInfoEXT.Ptr that uses the same backing storage as this XrInteractionRenderModelTopLevelUserPathGetInfoEXT.Ptr, but with the new size.
@NotNull XrKeyboardSpaceCreateInfoFB.Ptr	XrKeyboardSpaceCreateInfoFB.Ptr.reinterpret(long newSize)	Assume the XrKeyboardSpaceCreateInfoFB.Ptr is capable of holding at least newSize structures, create a new view XrKeyboardSpaceCreateInfoFB.Ptr that uses the same backing storage as this XrKeyboardSpaceCreateInfoFB.Ptr, but with the new size.
@NotNull XrKeyboardTrackingDescriptionFB.Ptr	XrKeyboardTrackingDescriptionFB.Ptr.reinterpret(long newSize)	Assume the XrKeyboardTrackingDescriptionFB.Ptr is capable of holding at least newSize structures, create a new view XrKeyboardTrackingDescriptionFB.Ptr that uses the same backing storage as this XrKeyboardTrackingDescriptionFB.Ptr, but with the new size.
@NotNull XrKeyboardTrackingQueryFB.Ptr	XrKeyboardTrackingQueryFB.Ptr.reinterpret(long newSize)	Assume the XrKeyboardTrackingQueryFB.Ptr is capable of holding at least newSize structures, create a new view XrKeyboardTrackingQueryFB.Ptr that uses the same backing storage as this XrKeyboardTrackingQueryFB.Ptr, but with the new size.
@NotNull XrLoaderInitInfoAndroidKHR.Ptr	XrLoaderInitInfoAndroidKHR.Ptr.reinterpret(long newSize)	Assume the XrLoaderInitInfoAndroidKHR.Ptr is capable of holding at least newSize structures, create a new view XrLoaderInitInfoAndroidKHR.Ptr that uses the same backing storage as this XrLoaderInitInfoAndroidKHR.Ptr, but with the new size.
@NotNull XrLoaderInitInfoBaseHeaderKHR.Ptr	XrLoaderInitInfoBaseHeaderKHR.Ptr.reinterpret(long newSize)	Assume the XrLoaderInitInfoBaseHeaderKHR.Ptr is capable of holding at least newSize structures, create a new view XrLoaderInitInfoBaseHeaderKHR.Ptr that uses the same backing storage as this XrLoaderInitInfoBaseHeaderKHR.Ptr, but with the new size.
@NotNull XrLocalDimmingFrameEndInfoMETA.Ptr	XrLocalDimmingFrameEndInfoMETA.Ptr.reinterpret(long newSize)	Assume the XrLocalDimmingFrameEndInfoMETA.Ptr is capable of holding at least newSize structures, create a new view XrLocalDimmingFrameEndInfoMETA.Ptr that uses the same backing storage as this XrLocalDimmingFrameEndInfoMETA.Ptr, but with the new size.
@NotNull XrLocalizationEnableEventsInfoML.Ptr	XrLocalizationEnableEventsInfoML.Ptr.reinterpret(long newSize)	Assume the XrLocalizationEnableEventsInfoML.Ptr is capable of holding at least newSize structures, create a new view XrLocalizationEnableEventsInfoML.Ptr that uses the same backing storage as this XrLocalizationEnableEventsInfoML.Ptr, but with the new size.
@NotNull XrLocalizationMapImportInfoML.Ptr	XrLocalizationMapImportInfoML.Ptr.reinterpret(long newSize)	Assume the XrLocalizationMapImportInfoML.Ptr is capable of holding at least newSize structures, create a new view XrLocalizationMapImportInfoML.Ptr that uses the same backing storage as this XrLocalizationMapImportInfoML.Ptr, but with the new size.
@NotNull XrLocalizationMapML.Ptr	XrLocalizationMapML.Ptr.reinterpret(long newSize)	Assume the XrLocalizationMapML.Ptr is capable of holding at least newSize structures, create a new view XrLocalizationMapML.Ptr that uses the same backing storage as this XrLocalizationMapML.Ptr, but with the new size.
@NotNull XrLocalizationMapQueryInfoBaseHeaderML.Ptr	XrLocalizationMapQueryInfoBaseHeaderML.Ptr.reinterpret(long newSize)	Assume the XrLocalizationMapQueryInfoBaseHeaderML.Ptr is capable of holding at least newSize structures, create a new view XrLocalizationMapQueryInfoBaseHeaderML.Ptr that uses the same backing storage as this XrLocalizationMapQueryInfoBaseHeaderML.Ptr, but with the new size.
@NotNull XrMapLocalizationRequestInfoML.Ptr	XrMapLocalizationRequestInfoML.Ptr.reinterpret(long newSize)	Assume the XrMapLocalizationRequestInfoML.Ptr is capable of holding at least newSize structures, create a new view XrMapLocalizationRequestInfoML.Ptr that uses the same backing storage as this XrMapLocalizationRequestInfoML.Ptr, but with the new size.
@NotNull XrMarkerDetectorAprilTagInfoML.Ptr	XrMarkerDetectorAprilTagInfoML.Ptr.reinterpret(long newSize)	Assume the XrMarkerDetectorAprilTagInfoML.Ptr is capable of holding at least newSize structures, create a new view XrMarkerDetectorAprilTagInfoML.Ptr that uses the same backing storage as this XrMarkerDetectorAprilTagInfoML.Ptr, but with the new size.
@NotNull XrMarkerDetectorArucoInfoML.Ptr	XrMarkerDetectorArucoInfoML.Ptr.reinterpret(long newSize)	Assume the XrMarkerDetectorArucoInfoML.Ptr is capable of holding at least newSize structures, create a new view XrMarkerDetectorArucoInfoML.Ptr that uses the same backing storage as this XrMarkerDetectorArucoInfoML.Ptr, but with the new size.
@NotNull XrMarkerDetectorCreateInfoML.Ptr	XrMarkerDetectorCreateInfoML.Ptr.reinterpret(long newSize)	Assume the XrMarkerDetectorCreateInfoML.Ptr is capable of holding at least newSize structures, create a new view XrMarkerDetectorCreateInfoML.Ptr that uses the same backing storage as this XrMarkerDetectorCreateInfoML.Ptr, but with the new size.
@NotNull XrMarkerDetectorCustomProfileInfoML.Ptr	XrMarkerDetectorCustomProfileInfoML.Ptr.reinterpret(long newSize)	Assume the XrMarkerDetectorCustomProfileInfoML.Ptr is capable of holding at least newSize structures, create a new view XrMarkerDetectorCustomProfileInfoML.Ptr that uses the same backing storage as this XrMarkerDetectorCustomProfileInfoML.Ptr, but with the new size.
@NotNull XrMarkerDetectorSizeInfoML.Ptr	XrMarkerDetectorSizeInfoML.Ptr.reinterpret(long newSize)	Assume the XrMarkerDetectorSizeInfoML.Ptr is capable of holding at least newSize structures, create a new view XrMarkerDetectorSizeInfoML.Ptr that uses the same backing storage as this XrMarkerDetectorSizeInfoML.Ptr, but with the new size.
@NotNull XrMarkerDetectorSnapshotInfoML.Ptr	XrMarkerDetectorSnapshotInfoML.Ptr.reinterpret(long newSize)	Assume the XrMarkerDetectorSnapshotInfoML.Ptr is capable of holding at least newSize structures, create a new view XrMarkerDetectorSnapshotInfoML.Ptr that uses the same backing storage as this XrMarkerDetectorSnapshotInfoML.Ptr, but with the new size.
@NotNull XrMarkerDetectorStateML.Ptr	XrMarkerDetectorStateML.Ptr.reinterpret(long newSize)	Assume the XrMarkerDetectorStateML.Ptr is capable of holding at least newSize structures, create a new view XrMarkerDetectorStateML.Ptr that uses the same backing storage as this XrMarkerDetectorStateML.Ptr, but with the new size.
@NotNull XrMarkerSpaceCreateInfoML.Ptr	XrMarkerSpaceCreateInfoML.Ptr.reinterpret(long newSize)	Assume the XrMarkerSpaceCreateInfoML.Ptr is capable of holding at least newSize structures, create a new view XrMarkerSpaceCreateInfoML.Ptr that uses the same backing storage as this XrMarkerSpaceCreateInfoML.Ptr, but with the new size.
@NotNull XrMarkerSpaceCreateInfoVARJO.Ptr	XrMarkerSpaceCreateInfoVARJO.Ptr.reinterpret(long newSize)	Assume the XrMarkerSpaceCreateInfoVARJO.Ptr is capable of holding at least newSize structures, create a new view XrMarkerSpaceCreateInfoVARJO.Ptr that uses the same backing storage as this XrMarkerSpaceCreateInfoVARJO.Ptr, but with the new size.
@NotNull XrNegotiateApiLayerRequest.Ptr	XrNegotiateApiLayerRequest.Ptr.reinterpret(long newSize)	Assume the XrNegotiateApiLayerRequest.Ptr is capable of holding at least newSize structures, create a new view XrNegotiateApiLayerRequest.Ptr that uses the same backing storage as this XrNegotiateApiLayerRequest.Ptr, but with the new size.
@NotNull XrNegotiateLoaderInfo.Ptr	XrNegotiateLoaderInfo.Ptr.reinterpret(long newSize)	Assume the XrNegotiateLoaderInfo.Ptr is capable of holding at least newSize structures, create a new view XrNegotiateLoaderInfo.Ptr that uses the same backing storage as this XrNegotiateLoaderInfo.Ptr, but with the new size.
@NotNull XrNegotiateRuntimeRequest.Ptr	XrNegotiateRuntimeRequest.Ptr.reinterpret(long newSize)	Assume the XrNegotiateRuntimeRequest.Ptr is capable of holding at least newSize structures, create a new view XrNegotiateRuntimeRequest.Ptr that uses the same backing storage as this XrNegotiateRuntimeRequest.Ptr, but with the new size.
@NotNull XrNewSceneComputeInfoMSFT.Ptr	XrNewSceneComputeInfoMSFT.Ptr.reinterpret(long newSize)	Assume the XrNewSceneComputeInfoMSFT.Ptr is capable of holding at least newSize structures, create a new view XrNewSceneComputeInfoMSFT.Ptr that uses the same backing storage as this XrNewSceneComputeInfoMSFT.Ptr, but with the new size.
@NotNull XrOffset2Df.Ptr	XrOffset2Df.Ptr.reinterpret(long newSize)	Assume the XrOffset2Df.Ptr is capable of holding at least newSize structures, create a new view XrOffset2Df.Ptr that uses the same backing storage as this XrOffset2Df.Ptr, but with the new size.
@NotNull XrOffset2Di.Ptr	XrOffset2Di.Ptr.reinterpret(long newSize)	Assume the XrOffset2Di.Ptr is capable of holding at least newSize structures, create a new view XrOffset2Di.Ptr that uses the same backing storage as this XrOffset2Di.Ptr, but with the new size.
@NotNull XrOffset3DfFB.Ptr	XrOffset3DfFB.Ptr.reinterpret(long newSize)	Assume the XrOffset3DfFB.Ptr is capable of holding at least newSize structures, create a new view XrOffset3DfFB.Ptr that uses the same backing storage as this XrOffset3DfFB.Ptr, but with the new size.
@NotNull XrPassthroughBrightnessContrastSaturationFB.Ptr	XrPassthroughBrightnessContrastSaturationFB.Ptr.reinterpret(long newSize)	Assume the XrPassthroughBrightnessContrastSaturationFB.Ptr is capable of holding at least newSize structures, create a new view XrPassthroughBrightnessContrastSaturationFB.Ptr that uses the same backing storage as this XrPassthroughBrightnessContrastSaturationFB.Ptr, but with the new size.
@NotNull XrPassthroughColorHTC.Ptr	XrPassthroughColorHTC.Ptr.reinterpret(long newSize)	Assume the XrPassthroughColorHTC.Ptr is capable of holding at least newSize structures, create a new view XrPassthroughColorHTC.Ptr that uses the same backing storage as this XrPassthroughColorHTC.Ptr, but with the new size.
@NotNull XrPassthroughColorLutCreateInfoMETA.Ptr	XrPassthroughColorLutCreateInfoMETA.Ptr.reinterpret(long newSize)	Assume the XrPassthroughColorLutCreateInfoMETA.Ptr is capable of holding at least newSize structures, create a new view XrPassthroughColorLutCreateInfoMETA.Ptr that uses the same backing storage as this XrPassthroughColorLutCreateInfoMETA.Ptr, but with the new size.
@NotNull XrPassthroughColorLutDataMETA.Ptr	XrPassthroughColorLutDataMETA.Ptr.reinterpret(long newSize)	Assume the XrPassthroughColorLutDataMETA.Ptr is capable of holding at least newSize structures, create a new view XrPassthroughColorLutDataMETA.Ptr that uses the same backing storage as this XrPassthroughColorLutDataMETA.Ptr, but with the new size.
@NotNull XrPassthroughColorLutUpdateInfoMETA.Ptr	XrPassthroughColorLutUpdateInfoMETA.Ptr.reinterpret(long newSize)	Assume the XrPassthroughColorLutUpdateInfoMETA.Ptr is capable of holding at least newSize structures, create a new view XrPassthroughColorLutUpdateInfoMETA.Ptr that uses the same backing storage as this XrPassthroughColorLutUpdateInfoMETA.Ptr, but with the new size.
@NotNull XrPassthroughColorMapInterpolatedLutMETA.Ptr	XrPassthroughColorMapInterpolatedLutMETA.Ptr.reinterpret(long newSize)	Assume the XrPassthroughColorMapInterpolatedLutMETA.Ptr is capable of holding at least newSize structures, create a new view XrPassthroughColorMapInterpolatedLutMETA.Ptr that uses the same backing storage as this XrPassthroughColorMapInterpolatedLutMETA.Ptr, but with the new size.
@NotNull XrPassthroughColorMapLutMETA.Ptr	XrPassthroughColorMapLutMETA.Ptr.reinterpret(long newSize)	Assume the XrPassthroughColorMapLutMETA.Ptr is capable of holding at least newSize structures, create a new view XrPassthroughColorMapLutMETA.Ptr that uses the same backing storage as this XrPassthroughColorMapLutMETA.Ptr, but with the new size.
@NotNull XrPassthroughColorMapMonoToMonoFB.Ptr	XrPassthroughColorMapMonoToMonoFB.Ptr.reinterpret(long newSize)	Assume the XrPassthroughColorMapMonoToMonoFB.Ptr is capable of holding at least newSize structures, create a new view XrPassthroughColorMapMonoToMonoFB.Ptr that uses the same backing storage as this XrPassthroughColorMapMonoToMonoFB.Ptr, but with the new size.
@NotNull XrPassthroughColorMapMonoToRgbaFB.Ptr	XrPassthroughColorMapMonoToRgbaFB.Ptr.reinterpret(long newSize)	Assume the XrPassthroughColorMapMonoToRgbaFB.Ptr is capable of holding at least newSize structures, create a new view XrPassthroughColorMapMonoToRgbaFB.Ptr that uses the same backing storage as this XrPassthroughColorMapMonoToRgbaFB.Ptr, but with the new size.
@NotNull XrPassthroughCreateInfoFB.Ptr	XrPassthroughCreateInfoFB.Ptr.reinterpret(long newSize)	Assume the XrPassthroughCreateInfoFB.Ptr is capable of holding at least newSize structures, create a new view XrPassthroughCreateInfoFB.Ptr that uses the same backing storage as this XrPassthroughCreateInfoFB.Ptr, but with the new size.
@NotNull XrPassthroughCreateInfoHTC.Ptr	XrPassthroughCreateInfoHTC.Ptr.reinterpret(long newSize)	Assume the XrPassthroughCreateInfoHTC.Ptr is capable of holding at least newSize structures, create a new view XrPassthroughCreateInfoHTC.Ptr that uses the same backing storage as this XrPassthroughCreateInfoHTC.Ptr, but with the new size.
@NotNull XrPassthroughKeyboardHandsIntensityFB.Ptr	XrPassthroughKeyboardHandsIntensityFB.Ptr.reinterpret(long newSize)	Assume the XrPassthroughKeyboardHandsIntensityFB.Ptr is capable of holding at least newSize structures, create a new view XrPassthroughKeyboardHandsIntensityFB.Ptr that uses the same backing storage as this XrPassthroughKeyboardHandsIntensityFB.Ptr, but with the new size.
@NotNull XrPassthroughLayerCreateInfoFB.Ptr	XrPassthroughLayerCreateInfoFB.Ptr.reinterpret(long newSize)	Assume the XrPassthroughLayerCreateInfoFB.Ptr is capable of holding at least newSize structures, create a new view XrPassthroughLayerCreateInfoFB.Ptr that uses the same backing storage as this XrPassthroughLayerCreateInfoFB.Ptr, but with the new size.
@NotNull XrPassthroughMeshTransformInfoHTC.Ptr	XrPassthroughMeshTransformInfoHTC.Ptr.reinterpret(long newSize)	Assume the XrPassthroughMeshTransformInfoHTC.Ptr is capable of holding at least newSize structures, create a new view XrPassthroughMeshTransformInfoHTC.Ptr that uses the same backing storage as this XrPassthroughMeshTransformInfoHTC.Ptr, but with the new size.
@NotNull XrPassthroughPreferencesMETA.Ptr	XrPassthroughPreferencesMETA.Ptr.reinterpret(long newSize)	Assume the XrPassthroughPreferencesMETA.Ptr is capable of holding at least newSize structures, create a new view XrPassthroughPreferencesMETA.Ptr that uses the same backing storage as this XrPassthroughPreferencesMETA.Ptr, but with the new size.
@NotNull XrPassthroughStyleFB.Ptr	XrPassthroughStyleFB.Ptr.reinterpret(long newSize)	Assume the XrPassthroughStyleFB.Ptr is capable of holding at least newSize structures, create a new view XrPassthroughStyleFB.Ptr that uses the same backing storage as this XrPassthroughStyleFB.Ptr, but with the new size.
@NotNull XrPerformanceMetricsCounterMETA.Ptr	XrPerformanceMetricsCounterMETA.Ptr.reinterpret(long newSize)	Assume the XrPerformanceMetricsCounterMETA.Ptr is capable of holding at least newSize structures, create a new view XrPerformanceMetricsCounterMETA.Ptr that uses the same backing storage as this XrPerformanceMetricsCounterMETA.Ptr, but with the new size.
@NotNull XrPerformanceMetricsStateMETA.Ptr	XrPerformanceMetricsStateMETA.Ptr.reinterpret(long newSize)	Assume the XrPerformanceMetricsStateMETA.Ptr is capable of holding at least newSize structures, create a new view XrPerformanceMetricsStateMETA.Ptr that uses the same backing storage as this XrPerformanceMetricsStateMETA.Ptr, but with the new size.
@NotNull XrPersistSpatialEntityCompletionEXT.Ptr	XrPersistSpatialEntityCompletionEXT.Ptr.reinterpret(long newSize)	Assume the XrPersistSpatialEntityCompletionEXT.Ptr is capable of holding at least newSize structures, create a new view XrPersistSpatialEntityCompletionEXT.Ptr that uses the same backing storage as this XrPersistSpatialEntityCompletionEXT.Ptr, but with the new size.
@NotNull XrPlaneDetectorBeginInfoEXT.Ptr	XrPlaneDetectorBeginInfoEXT.Ptr.reinterpret(long newSize)	Assume the XrPlaneDetectorBeginInfoEXT.Ptr is capable of holding at least newSize structures, create a new view XrPlaneDetectorBeginInfoEXT.Ptr that uses the same backing storage as this XrPlaneDetectorBeginInfoEXT.Ptr, but with the new size.
@NotNull XrPlaneDetectorCreateInfoEXT.Ptr	XrPlaneDetectorCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the XrPlaneDetectorCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view XrPlaneDetectorCreateInfoEXT.Ptr that uses the same backing storage as this XrPlaneDetectorCreateInfoEXT.Ptr, but with the new size.
@NotNull XrPlaneDetectorGetInfoEXT.Ptr	XrPlaneDetectorGetInfoEXT.Ptr.reinterpret(long newSize)	Assume the XrPlaneDetectorGetInfoEXT.Ptr is capable of holding at least newSize structures, create a new view XrPlaneDetectorGetInfoEXT.Ptr that uses the same backing storage as this XrPlaneDetectorGetInfoEXT.Ptr, but with the new size.
@NotNull XrPlaneDetectorLocationEXT.Ptr	XrPlaneDetectorLocationEXT.Ptr.reinterpret(long newSize)	Assume the XrPlaneDetectorLocationEXT.Ptr is capable of holding at least newSize structures, create a new view XrPlaneDetectorLocationEXT.Ptr that uses the same backing storage as this XrPlaneDetectorLocationEXT.Ptr, but with the new size.
@NotNull XrPlaneDetectorLocationsEXT.Ptr	XrPlaneDetectorLocationsEXT.Ptr.reinterpret(long newSize)	Assume the XrPlaneDetectorLocationsEXT.Ptr is capable of holding at least newSize structures, create a new view XrPlaneDetectorLocationsEXT.Ptr that uses the same backing storage as this XrPlaneDetectorLocationsEXT.Ptr, but with the new size.
@NotNull XrPlaneDetectorPolygonBufferEXT.Ptr	XrPlaneDetectorPolygonBufferEXT.Ptr.reinterpret(long newSize)	Assume the XrPlaneDetectorPolygonBufferEXT.Ptr is capable of holding at least newSize structures, create a new view XrPlaneDetectorPolygonBufferEXT.Ptr that uses the same backing storage as this XrPlaneDetectorPolygonBufferEXT.Ptr, but with the new size.
@NotNull XrPosef.Ptr	XrPosef.Ptr.reinterpret(long newSize)	Assume the XrPosef.Ptr is capable of holding at least newSize structures, create a new view XrPosef.Ptr that uses the same backing storage as this XrPosef.Ptr, but with the new size.
@NotNull XrQuaternionf.Ptr	XrQuaternionf.Ptr.reinterpret(long newSize)	Assume the XrQuaternionf.Ptr is capable of holding at least newSize structures, create a new view XrQuaternionf.Ptr that uses the same backing storage as this XrQuaternionf.Ptr, but with the new size.
@NotNull XrQueriedSenseDataBD.Ptr	XrQueriedSenseDataBD.Ptr.reinterpret(long newSize)	Assume the XrQueriedSenseDataBD.Ptr is capable of holding at least newSize structures, create a new view XrQueriedSenseDataBD.Ptr that uses the same backing storage as this XrQueriedSenseDataBD.Ptr, but with the new size.
@NotNull XrQueriedSenseDataGetInfoBD.Ptr	XrQueriedSenseDataGetInfoBD.Ptr.reinterpret(long newSize)	Assume the XrQueriedSenseDataGetInfoBD.Ptr is capable of holding at least newSize structures, create a new view XrQueriedSenseDataGetInfoBD.Ptr that uses the same backing storage as this XrQueriedSenseDataGetInfoBD.Ptr, but with the new size.
@NotNull XrRecommendedLayerResolutionGetInfoMETA.Ptr	XrRecommendedLayerResolutionGetInfoMETA.Ptr.reinterpret(long newSize)	Assume the XrRecommendedLayerResolutionGetInfoMETA.Ptr is capable of holding at least newSize structures, create a new view XrRecommendedLayerResolutionGetInfoMETA.Ptr that uses the same backing storage as this XrRecommendedLayerResolutionGetInfoMETA.Ptr, but with the new size.
@NotNull XrRecommendedLayerResolutionMETA.Ptr	XrRecommendedLayerResolutionMETA.Ptr.reinterpret(long newSize)	Assume the XrRecommendedLayerResolutionMETA.Ptr is capable of holding at least newSize structures, create a new view XrRecommendedLayerResolutionMETA.Ptr that uses the same backing storage as this XrRecommendedLayerResolutionMETA.Ptr, but with the new size.
@NotNull XrRect2Df.Ptr	XrRect2Df.Ptr.reinterpret(long newSize)	Assume the XrRect2Df.Ptr is capable of holding at least newSize structures, create a new view XrRect2Df.Ptr that uses the same backing storage as this XrRect2Df.Ptr, but with the new size.
@NotNull XrRect2Di.Ptr	XrRect2Di.Ptr.reinterpret(long newSize)	Assume the XrRect2Di.Ptr is capable of holding at least newSize structures, create a new view XrRect2Di.Ptr that uses the same backing storage as this XrRect2Di.Ptr, but with the new size.
@NotNull XrRect3DfFB.Ptr	XrRect3DfFB.Ptr.reinterpret(long newSize)	Assume the XrRect3DfFB.Ptr is capable of holding at least newSize structures, create a new view XrRect3DfFB.Ptr that uses the same backing storage as this XrRect3DfFB.Ptr, but with the new size.
@NotNull XrReferenceSpaceCreateInfo.Ptr	XrReferenceSpaceCreateInfo.Ptr.reinterpret(long newSize)	Assume the XrReferenceSpaceCreateInfo.Ptr is capable of holding at least newSize structures, create a new view XrReferenceSpaceCreateInfo.Ptr that uses the same backing storage as this XrReferenceSpaceCreateInfo.Ptr, but with the new size.
@NotNull XrRenderModelAssetCreateInfoEXT.Ptr	XrRenderModelAssetCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the XrRenderModelAssetCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view XrRenderModelAssetCreateInfoEXT.Ptr that uses the same backing storage as this XrRenderModelAssetCreateInfoEXT.Ptr, but with the new size.
@NotNull XrRenderModelAssetDataEXT.Ptr	XrRenderModelAssetDataEXT.Ptr.reinterpret(long newSize)	Assume the XrRenderModelAssetDataEXT.Ptr is capable of holding at least newSize structures, create a new view XrRenderModelAssetDataEXT.Ptr that uses the same backing storage as this XrRenderModelAssetDataEXT.Ptr, but with the new size.
@NotNull XrRenderModelAssetDataGetInfoEXT.Ptr	XrRenderModelAssetDataGetInfoEXT.Ptr.reinterpret(long newSize)	Assume the XrRenderModelAssetDataGetInfoEXT.Ptr is capable of holding at least newSize structures, create a new view XrRenderModelAssetDataGetInfoEXT.Ptr that uses the same backing storage as this XrRenderModelAssetDataGetInfoEXT.Ptr, but with the new size.
@NotNull XrRenderModelAssetNodePropertiesEXT.Ptr	XrRenderModelAssetNodePropertiesEXT.Ptr.reinterpret(long newSize)	Assume the XrRenderModelAssetNodePropertiesEXT.Ptr is capable of holding at least newSize structures, create a new view XrRenderModelAssetNodePropertiesEXT.Ptr that uses the same backing storage as this XrRenderModelAssetNodePropertiesEXT.Ptr, but with the new size.
@NotNull XrRenderModelAssetPropertiesEXT.Ptr	XrRenderModelAssetPropertiesEXT.Ptr.reinterpret(long newSize)	Assume the XrRenderModelAssetPropertiesEXT.Ptr is capable of holding at least newSize structures, create a new view XrRenderModelAssetPropertiesEXT.Ptr that uses the same backing storage as this XrRenderModelAssetPropertiesEXT.Ptr, but with the new size.
@NotNull XrRenderModelAssetPropertiesGetInfoEXT.Ptr	XrRenderModelAssetPropertiesGetInfoEXT.Ptr.reinterpret(long newSize)	Assume the XrRenderModelAssetPropertiesGetInfoEXT.Ptr is capable of holding at least newSize structures, create a new view XrRenderModelAssetPropertiesGetInfoEXT.Ptr that uses the same backing storage as this XrRenderModelAssetPropertiesGetInfoEXT.Ptr, but with the new size.
@NotNull XrRenderModelBufferFB.Ptr	XrRenderModelBufferFB.Ptr.reinterpret(long newSize)	Assume the XrRenderModelBufferFB.Ptr is capable of holding at least newSize structures, create a new view XrRenderModelBufferFB.Ptr that uses the same backing storage as this XrRenderModelBufferFB.Ptr, but with the new size.
@NotNull XrRenderModelCapabilitiesRequestFB.Ptr	XrRenderModelCapabilitiesRequestFB.Ptr.reinterpret(long newSize)	Assume the XrRenderModelCapabilitiesRequestFB.Ptr is capable of holding at least newSize structures, create a new view XrRenderModelCapabilitiesRequestFB.Ptr that uses the same backing storage as this XrRenderModelCapabilitiesRequestFB.Ptr, but with the new size.
@NotNull XrRenderModelCreateInfoEXT.Ptr	XrRenderModelCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the XrRenderModelCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view XrRenderModelCreateInfoEXT.Ptr that uses the same backing storage as this XrRenderModelCreateInfoEXT.Ptr, but with the new size.
@NotNull XrRenderModelLoadInfoFB.Ptr	XrRenderModelLoadInfoFB.Ptr.reinterpret(long newSize)	Assume the XrRenderModelLoadInfoFB.Ptr is capable of holding at least newSize structures, create a new view XrRenderModelLoadInfoFB.Ptr that uses the same backing storage as this XrRenderModelLoadInfoFB.Ptr, but with the new size.
@NotNull XrRenderModelNodeStateEXT.Ptr	XrRenderModelNodeStateEXT.Ptr.reinterpret(long newSize)	Assume the XrRenderModelNodeStateEXT.Ptr is capable of holding at least newSize structures, create a new view XrRenderModelNodeStateEXT.Ptr that uses the same backing storage as this XrRenderModelNodeStateEXT.Ptr, but with the new size.
@NotNull XrRenderModelPathInfoFB.Ptr	XrRenderModelPathInfoFB.Ptr.reinterpret(long newSize)	Assume the XrRenderModelPathInfoFB.Ptr is capable of holding at least newSize structures, create a new view XrRenderModelPathInfoFB.Ptr that uses the same backing storage as this XrRenderModelPathInfoFB.Ptr, but with the new size.
@NotNull XrRenderModelPropertiesEXT.Ptr	XrRenderModelPropertiesEXT.Ptr.reinterpret(long newSize)	Assume the XrRenderModelPropertiesEXT.Ptr is capable of holding at least newSize structures, create a new view XrRenderModelPropertiesEXT.Ptr that uses the same backing storage as this XrRenderModelPropertiesEXT.Ptr, but with the new size.
@NotNull XrRenderModelPropertiesFB.Ptr	XrRenderModelPropertiesFB.Ptr.reinterpret(long newSize)	Assume the XrRenderModelPropertiesFB.Ptr is capable of holding at least newSize structures, create a new view XrRenderModelPropertiesFB.Ptr that uses the same backing storage as this XrRenderModelPropertiesFB.Ptr, but with the new size.
@NotNull XrRenderModelPropertiesGetInfoEXT.Ptr	XrRenderModelPropertiesGetInfoEXT.Ptr.reinterpret(long newSize)	Assume the XrRenderModelPropertiesGetInfoEXT.Ptr is capable of holding at least newSize structures, create a new view XrRenderModelPropertiesGetInfoEXT.Ptr that uses the same backing storage as this XrRenderModelPropertiesGetInfoEXT.Ptr, but with the new size.
@NotNull XrRenderModelSpaceCreateInfoEXT.Ptr	XrRenderModelSpaceCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the XrRenderModelSpaceCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view XrRenderModelSpaceCreateInfoEXT.Ptr that uses the same backing storage as this XrRenderModelSpaceCreateInfoEXT.Ptr, but with the new size.
@NotNull XrRenderModelStateEXT.Ptr	XrRenderModelStateEXT.Ptr.reinterpret(long newSize)	Assume the XrRenderModelStateEXT.Ptr is capable of holding at least newSize structures, create a new view XrRenderModelStateEXT.Ptr that uses the same backing storage as this XrRenderModelStateEXT.Ptr, but with the new size.
@NotNull XrRenderModelStateGetInfoEXT.Ptr	XrRenderModelStateGetInfoEXT.Ptr.reinterpret(long newSize)	Assume the XrRenderModelStateGetInfoEXT.Ptr is capable of holding at least newSize structures, create a new view XrRenderModelStateGetInfoEXT.Ptr that uses the same backing storage as this XrRenderModelStateGetInfoEXT.Ptr, but with the new size.
@NotNull XrRoomLayoutFB.Ptr	XrRoomLayoutFB.Ptr.reinterpret(long newSize)	Assume the XrRoomLayoutFB.Ptr is capable of holding at least newSize structures, create a new view XrRoomLayoutFB.Ptr that uses the same backing storage as this XrRoomLayoutFB.Ptr, but with the new size.
@NotNull XrSceneBoundsMSFT.Ptr	XrSceneBoundsMSFT.Ptr.reinterpret(long newSize)	Assume the XrSceneBoundsMSFT.Ptr is capable of holding at least newSize structures, create a new view XrSceneBoundsMSFT.Ptr that uses the same backing storage as this XrSceneBoundsMSFT.Ptr, but with the new size.
@NotNull XrSceneCaptureInfoBD.Ptr	XrSceneCaptureInfoBD.Ptr.reinterpret(long newSize)	Assume the XrSceneCaptureInfoBD.Ptr is capable of holding at least newSize structures, create a new view XrSceneCaptureInfoBD.Ptr that uses the same backing storage as this XrSceneCaptureInfoBD.Ptr, but with the new size.
@NotNull XrSceneCaptureRequestInfoFB.Ptr	XrSceneCaptureRequestInfoFB.Ptr.reinterpret(long newSize)	Assume the XrSceneCaptureRequestInfoFB.Ptr is capable of holding at least newSize structures, create a new view XrSceneCaptureRequestInfoFB.Ptr that uses the same backing storage as this XrSceneCaptureRequestInfoFB.Ptr, but with the new size.
@NotNull XrSceneComponentLocationMSFT.Ptr	XrSceneComponentLocationMSFT.Ptr.reinterpret(long newSize)	Assume the XrSceneComponentLocationMSFT.Ptr is capable of holding at least newSize structures, create a new view XrSceneComponentLocationMSFT.Ptr that uses the same backing storage as this XrSceneComponentLocationMSFT.Ptr, but with the new size.
@NotNull XrSceneComponentLocationsMSFT.Ptr	XrSceneComponentLocationsMSFT.Ptr.reinterpret(long newSize)	Assume the XrSceneComponentLocationsMSFT.Ptr is capable of holding at least newSize structures, create a new view XrSceneComponentLocationsMSFT.Ptr that uses the same backing storage as this XrSceneComponentLocationsMSFT.Ptr, but with the new size.
@NotNull XrSceneComponentMSFT.Ptr	XrSceneComponentMSFT.Ptr.reinterpret(long newSize)	Assume the XrSceneComponentMSFT.Ptr is capable of holding at least newSize structures, create a new view XrSceneComponentMSFT.Ptr that uses the same backing storage as this XrSceneComponentMSFT.Ptr, but with the new size.
@NotNull XrSceneComponentParentFilterInfoMSFT.Ptr	XrSceneComponentParentFilterInfoMSFT.Ptr.reinterpret(long newSize)	Assume the XrSceneComponentParentFilterInfoMSFT.Ptr is capable of holding at least newSize structures, create a new view XrSceneComponentParentFilterInfoMSFT.Ptr that uses the same backing storage as this XrSceneComponentParentFilterInfoMSFT.Ptr, but with the new size.
@NotNull XrSceneComponentsGetInfoMSFT.Ptr	XrSceneComponentsGetInfoMSFT.Ptr.reinterpret(long newSize)	Assume the XrSceneComponentsGetInfoMSFT.Ptr is capable of holding at least newSize structures, create a new view XrSceneComponentsGetInfoMSFT.Ptr that uses the same backing storage as this XrSceneComponentsGetInfoMSFT.Ptr, but with the new size.
@NotNull XrSceneComponentsLocateInfoMSFT.Ptr	XrSceneComponentsLocateInfoMSFT.Ptr.reinterpret(long newSize)	Assume the XrSceneComponentsLocateInfoMSFT.Ptr is capable of holding at least newSize structures, create a new view XrSceneComponentsLocateInfoMSFT.Ptr that uses the same backing storage as this XrSceneComponentsLocateInfoMSFT.Ptr, but with the new size.
@NotNull XrSceneComponentsMSFT.Ptr	XrSceneComponentsMSFT.Ptr.reinterpret(long newSize)	Assume the XrSceneComponentsMSFT.Ptr is capable of holding at least newSize structures, create a new view XrSceneComponentsMSFT.Ptr that uses the same backing storage as this XrSceneComponentsMSFT.Ptr, but with the new size.
@NotNull XrSceneCreateInfoMSFT.Ptr	XrSceneCreateInfoMSFT.Ptr.reinterpret(long newSize)	Assume the XrSceneCreateInfoMSFT.Ptr is capable of holding at least newSize structures, create a new view XrSceneCreateInfoMSFT.Ptr that uses the same backing storage as this XrSceneCreateInfoMSFT.Ptr, but with the new size.
@NotNull XrSceneDeserializeInfoMSFT.Ptr	XrSceneDeserializeInfoMSFT.Ptr.reinterpret(long newSize)	Assume the XrSceneDeserializeInfoMSFT.Ptr is capable of holding at least newSize structures, create a new view XrSceneDeserializeInfoMSFT.Ptr that uses the same backing storage as this XrSceneDeserializeInfoMSFT.Ptr, but with the new size.
@NotNull XrSceneFrustumBoundMSFT.Ptr	XrSceneFrustumBoundMSFT.Ptr.reinterpret(long newSize)	Assume the XrSceneFrustumBoundMSFT.Ptr is capable of holding at least newSize structures, create a new view XrSceneFrustumBoundMSFT.Ptr that uses the same backing storage as this XrSceneFrustumBoundMSFT.Ptr, but with the new size.
@NotNull XrSceneMarkerMSFT.Ptr	XrSceneMarkerMSFT.Ptr.reinterpret(long newSize)	Assume the XrSceneMarkerMSFT.Ptr is capable of holding at least newSize structures, create a new view XrSceneMarkerMSFT.Ptr that uses the same backing storage as this XrSceneMarkerMSFT.Ptr, but with the new size.
@NotNull XrSceneMarkerQRCodeMSFT.Ptr	XrSceneMarkerQRCodeMSFT.Ptr.reinterpret(long newSize)	Assume the XrSceneMarkerQRCodeMSFT.Ptr is capable of holding at least newSize structures, create a new view XrSceneMarkerQRCodeMSFT.Ptr that uses the same backing storage as this XrSceneMarkerQRCodeMSFT.Ptr, but with the new size.
@NotNull XrSceneMarkerQRCodesMSFT.Ptr	XrSceneMarkerQRCodesMSFT.Ptr.reinterpret(long newSize)	Assume the XrSceneMarkerQRCodesMSFT.Ptr is capable of holding at least newSize structures, create a new view XrSceneMarkerQRCodesMSFT.Ptr that uses the same backing storage as this XrSceneMarkerQRCodesMSFT.Ptr, but with the new size.
@NotNull XrSceneMarkersMSFT.Ptr	XrSceneMarkersMSFT.Ptr.reinterpret(long newSize)	Assume the XrSceneMarkersMSFT.Ptr is capable of holding at least newSize structures, create a new view XrSceneMarkersMSFT.Ptr that uses the same backing storage as this XrSceneMarkersMSFT.Ptr, but with the new size.
@NotNull XrSceneMarkerTypeFilterMSFT.Ptr	XrSceneMarkerTypeFilterMSFT.Ptr.reinterpret(long newSize)	Assume the XrSceneMarkerTypeFilterMSFT.Ptr is capable of holding at least newSize structures, create a new view XrSceneMarkerTypeFilterMSFT.Ptr that uses the same backing storage as this XrSceneMarkerTypeFilterMSFT.Ptr, but with the new size.
@NotNull XrSceneMeshBuffersGetInfoMSFT.Ptr	XrSceneMeshBuffersGetInfoMSFT.Ptr.reinterpret(long newSize)	Assume the XrSceneMeshBuffersGetInfoMSFT.Ptr is capable of holding at least newSize structures, create a new view XrSceneMeshBuffersGetInfoMSFT.Ptr that uses the same backing storage as this XrSceneMeshBuffersGetInfoMSFT.Ptr, but with the new size.
@NotNull XrSceneMeshBuffersMSFT.Ptr	XrSceneMeshBuffersMSFT.Ptr.reinterpret(long newSize)	Assume the XrSceneMeshBuffersMSFT.Ptr is capable of holding at least newSize structures, create a new view XrSceneMeshBuffersMSFT.Ptr that uses the same backing storage as this XrSceneMeshBuffersMSFT.Ptr, but with the new size.
@NotNull XrSceneMeshesMSFT.Ptr	XrSceneMeshesMSFT.Ptr.reinterpret(long newSize)	Assume the XrSceneMeshesMSFT.Ptr is capable of holding at least newSize structures, create a new view XrSceneMeshesMSFT.Ptr that uses the same backing storage as this XrSceneMeshesMSFT.Ptr, but with the new size.
@NotNull XrSceneMeshIndicesUint16MSFT.Ptr	XrSceneMeshIndicesUint16MSFT.Ptr.reinterpret(long newSize)	Assume the XrSceneMeshIndicesUint16MSFT.Ptr is capable of holding at least newSize structures, create a new view XrSceneMeshIndicesUint16MSFT.Ptr that uses the same backing storage as this XrSceneMeshIndicesUint16MSFT.Ptr, but with the new size.
@NotNull XrSceneMeshIndicesUint32MSFT.Ptr	XrSceneMeshIndicesUint32MSFT.Ptr.reinterpret(long newSize)	Assume the XrSceneMeshIndicesUint32MSFT.Ptr is capable of holding at least newSize structures, create a new view XrSceneMeshIndicesUint32MSFT.Ptr that uses the same backing storage as this XrSceneMeshIndicesUint32MSFT.Ptr, but with the new size.
@NotNull XrSceneMeshMSFT.Ptr	XrSceneMeshMSFT.Ptr.reinterpret(long newSize)	Assume the XrSceneMeshMSFT.Ptr is capable of holding at least newSize structures, create a new view XrSceneMeshMSFT.Ptr that uses the same backing storage as this XrSceneMeshMSFT.Ptr, but with the new size.
@NotNull XrSceneMeshVertexBufferMSFT.Ptr	XrSceneMeshVertexBufferMSFT.Ptr.reinterpret(long newSize)	Assume the XrSceneMeshVertexBufferMSFT.Ptr is capable of holding at least newSize structures, create a new view XrSceneMeshVertexBufferMSFT.Ptr that uses the same backing storage as this XrSceneMeshVertexBufferMSFT.Ptr, but with the new size.
@NotNull XrSceneObjectMSFT.Ptr	XrSceneObjectMSFT.Ptr.reinterpret(long newSize)	Assume the XrSceneObjectMSFT.Ptr is capable of holding at least newSize structures, create a new view XrSceneObjectMSFT.Ptr that uses the same backing storage as this XrSceneObjectMSFT.Ptr, but with the new size.
@NotNull XrSceneObjectsMSFT.Ptr	XrSceneObjectsMSFT.Ptr.reinterpret(long newSize)	Assume the XrSceneObjectsMSFT.Ptr is capable of holding at least newSize structures, create a new view XrSceneObjectsMSFT.Ptr that uses the same backing storage as this XrSceneObjectsMSFT.Ptr, but with the new size.
@NotNull XrSceneObjectTypesFilterInfoMSFT.Ptr	XrSceneObjectTypesFilterInfoMSFT.Ptr.reinterpret(long newSize)	Assume the XrSceneObjectTypesFilterInfoMSFT.Ptr is capable of holding at least newSize structures, create a new view XrSceneObjectTypesFilterInfoMSFT.Ptr that uses the same backing storage as this XrSceneObjectTypesFilterInfoMSFT.Ptr, but with the new size.
@NotNull XrSceneObserverCreateInfoMSFT.Ptr	XrSceneObserverCreateInfoMSFT.Ptr.reinterpret(long newSize)	Assume the XrSceneObserverCreateInfoMSFT.Ptr is capable of holding at least newSize structures, create a new view XrSceneObserverCreateInfoMSFT.Ptr that uses the same backing storage as this XrSceneObserverCreateInfoMSFT.Ptr, but with the new size.
@NotNull XrSceneOrientedBoxBoundMSFT.Ptr	XrSceneOrientedBoxBoundMSFT.Ptr.reinterpret(long newSize)	Assume the XrSceneOrientedBoxBoundMSFT.Ptr is capable of holding at least newSize structures, create a new view XrSceneOrientedBoxBoundMSFT.Ptr that uses the same backing storage as this XrSceneOrientedBoxBoundMSFT.Ptr, but with the new size.
@NotNull XrScenePlaneAlignmentFilterInfoMSFT.Ptr	XrScenePlaneAlignmentFilterInfoMSFT.Ptr.reinterpret(long newSize)	Assume the XrScenePlaneAlignmentFilterInfoMSFT.Ptr is capable of holding at least newSize structures, create a new view XrScenePlaneAlignmentFilterInfoMSFT.Ptr that uses the same backing storage as this XrScenePlaneAlignmentFilterInfoMSFT.Ptr, but with the new size.
@NotNull XrScenePlaneMSFT.Ptr	XrScenePlaneMSFT.Ptr.reinterpret(long newSize)	Assume the XrScenePlaneMSFT.Ptr is capable of holding at least newSize structures, create a new view XrScenePlaneMSFT.Ptr that uses the same backing storage as this XrScenePlaneMSFT.Ptr, but with the new size.
@NotNull XrScenePlanesMSFT.Ptr	XrScenePlanesMSFT.Ptr.reinterpret(long newSize)	Assume the XrScenePlanesMSFT.Ptr is capable of holding at least newSize structures, create a new view XrScenePlanesMSFT.Ptr that uses the same backing storage as this XrScenePlanesMSFT.Ptr, but with the new size.
@NotNull XrSceneSphereBoundMSFT.Ptr	XrSceneSphereBoundMSFT.Ptr.reinterpret(long newSize)	Assume the XrSceneSphereBoundMSFT.Ptr is capable of holding at least newSize structures, create a new view XrSceneSphereBoundMSFT.Ptr that uses the same backing storage as this XrSceneSphereBoundMSFT.Ptr, but with the new size.
@NotNull XrSecondaryViewConfigurationFrameEndInfoMSFT.Ptr	XrSecondaryViewConfigurationFrameEndInfoMSFT.Ptr.reinterpret(long newSize)	Assume the XrSecondaryViewConfigurationFrameEndInfoMSFT.Ptr is capable of holding at least newSize structures, create a new view XrSecondaryViewConfigurationFrameEndInfoMSFT.Ptr that uses the same backing storage as this XrSecondaryViewConfigurationFrameEndInfoMSFT.Ptr, but with the new size.
@NotNull XrSecondaryViewConfigurationFrameStateMSFT.Ptr	XrSecondaryViewConfigurationFrameStateMSFT.Ptr.reinterpret(long newSize)	Assume the XrSecondaryViewConfigurationFrameStateMSFT.Ptr is capable of holding at least newSize structures, create a new view XrSecondaryViewConfigurationFrameStateMSFT.Ptr that uses the same backing storage as this XrSecondaryViewConfigurationFrameStateMSFT.Ptr, but with the new size.
@NotNull XrSecondaryViewConfigurationLayerInfoMSFT.Ptr	XrSecondaryViewConfigurationLayerInfoMSFT.Ptr.reinterpret(long newSize)	Assume the XrSecondaryViewConfigurationLayerInfoMSFT.Ptr is capable of holding at least newSize structures, create a new view XrSecondaryViewConfigurationLayerInfoMSFT.Ptr that uses the same backing storage as this XrSecondaryViewConfigurationLayerInfoMSFT.Ptr, but with the new size.
@NotNull XrSecondaryViewConfigurationSessionBeginInfoMSFT.Ptr	XrSecondaryViewConfigurationSessionBeginInfoMSFT.Ptr.reinterpret(long newSize)	Assume the XrSecondaryViewConfigurationSessionBeginInfoMSFT.Ptr is capable of holding at least newSize structures, create a new view XrSecondaryViewConfigurationSessionBeginInfoMSFT.Ptr that uses the same backing storage as this XrSecondaryViewConfigurationSessionBeginInfoMSFT.Ptr, but with the new size.
@NotNull XrSecondaryViewConfigurationStateMSFT.Ptr	XrSecondaryViewConfigurationStateMSFT.Ptr.reinterpret(long newSize)	Assume the XrSecondaryViewConfigurationStateMSFT.Ptr is capable of holding at least newSize structures, create a new view XrSecondaryViewConfigurationStateMSFT.Ptr that uses the same backing storage as this XrSecondaryViewConfigurationStateMSFT.Ptr, but with the new size.
@NotNull XrSecondaryViewConfigurationSwapchainCreateInfoMSFT.Ptr	XrSecondaryViewConfigurationSwapchainCreateInfoMSFT.Ptr.reinterpret(long newSize)	Assume the XrSecondaryViewConfigurationSwapchainCreateInfoMSFT.Ptr is capable of holding at least newSize structures, create a new view XrSecondaryViewConfigurationSwapchainCreateInfoMSFT.Ptr that uses the same backing storage as this XrSecondaryViewConfigurationSwapchainCreateInfoMSFT.Ptr, but with the new size.
@NotNull XrSemanticLabelsFB.Ptr	XrSemanticLabelsFB.Ptr.reinterpret(long newSize)	Assume the XrSemanticLabelsFB.Ptr is capable of holding at least newSize structures, create a new view XrSemanticLabelsFB.Ptr that uses the same backing storage as this XrSemanticLabelsFB.Ptr, but with the new size.
@NotNull XrSemanticLabelsSupportInfoFB.Ptr	XrSemanticLabelsSupportInfoFB.Ptr.reinterpret(long newSize)	Assume the XrSemanticLabelsSupportInfoFB.Ptr is capable of holding at least newSize structures, create a new view XrSemanticLabelsSupportInfoFB.Ptr that uses the same backing storage as this XrSemanticLabelsSupportInfoFB.Ptr, but with the new size.
@NotNull XrSenseDataFilterPlaneOrientationBD.Ptr	XrSenseDataFilterPlaneOrientationBD.Ptr.reinterpret(long newSize)	Assume the XrSenseDataFilterPlaneOrientationBD.Ptr is capable of holding at least newSize structures, create a new view XrSenseDataFilterPlaneOrientationBD.Ptr that uses the same backing storage as this XrSenseDataFilterPlaneOrientationBD.Ptr, but with the new size.
@NotNull XrSenseDataFilterSemanticBD.Ptr	XrSenseDataFilterSemanticBD.Ptr.reinterpret(long newSize)	Assume the XrSenseDataFilterSemanticBD.Ptr is capable of holding at least newSize structures, create a new view XrSenseDataFilterSemanticBD.Ptr that uses the same backing storage as this XrSenseDataFilterSemanticBD.Ptr, but with the new size.
@NotNull XrSenseDataFilterUuidBD.Ptr	XrSenseDataFilterUuidBD.Ptr.reinterpret(long newSize)	Assume the XrSenseDataFilterUuidBD.Ptr is capable of holding at least newSize structures, create a new view XrSenseDataFilterUuidBD.Ptr that uses the same backing storage as this XrSenseDataFilterUuidBD.Ptr, but with the new size.
@NotNull XrSenseDataProviderCreateInfoBD.Ptr	XrSenseDataProviderCreateInfoBD.Ptr.reinterpret(long newSize)	Assume the XrSenseDataProviderCreateInfoBD.Ptr is capable of holding at least newSize structures, create a new view XrSenseDataProviderCreateInfoBD.Ptr that uses the same backing storage as this XrSenseDataProviderCreateInfoBD.Ptr, but with the new size.
@NotNull XrSenseDataProviderCreateInfoSpatialMeshBD.Ptr	XrSenseDataProviderCreateInfoSpatialMeshBD.Ptr.reinterpret(long newSize)	Assume the XrSenseDataProviderCreateInfoSpatialMeshBD.Ptr is capable of holding at least newSize structures, create a new view XrSenseDataProviderCreateInfoSpatialMeshBD.Ptr that uses the same backing storage as this XrSenseDataProviderCreateInfoSpatialMeshBD.Ptr, but with the new size.
@NotNull XrSenseDataProviderStartInfoBD.Ptr	XrSenseDataProviderStartInfoBD.Ptr.reinterpret(long newSize)	Assume the XrSenseDataProviderStartInfoBD.Ptr is capable of holding at least newSize structures, create a new view XrSenseDataProviderStartInfoBD.Ptr that uses the same backing storage as this XrSenseDataProviderStartInfoBD.Ptr, but with the new size.
@NotNull XrSenseDataQueryCompletionBD.Ptr	XrSenseDataQueryCompletionBD.Ptr.reinterpret(long newSize)	Assume the XrSenseDataQueryCompletionBD.Ptr is capable of holding at least newSize structures, create a new view XrSenseDataQueryCompletionBD.Ptr that uses the same backing storage as this XrSenseDataQueryCompletionBD.Ptr, but with the new size.
@NotNull XrSenseDataQueryInfoBD.Ptr	XrSenseDataQueryInfoBD.Ptr.reinterpret(long newSize)	Assume the XrSenseDataQueryInfoBD.Ptr is capable of holding at least newSize structures, create a new view XrSenseDataQueryInfoBD.Ptr that uses the same backing storage as this XrSenseDataQueryInfoBD.Ptr, but with the new size.
@NotNull XrSerializedSceneFragmentDataGetInfoMSFT.Ptr	XrSerializedSceneFragmentDataGetInfoMSFT.Ptr.reinterpret(long newSize)	Assume the XrSerializedSceneFragmentDataGetInfoMSFT.Ptr is capable of holding at least newSize structures, create a new view XrSerializedSceneFragmentDataGetInfoMSFT.Ptr that uses the same backing storage as this XrSerializedSceneFragmentDataGetInfoMSFT.Ptr, but with the new size.
@NotNull XrSessionActionSetsAttachInfo.Ptr	XrSessionActionSetsAttachInfo.Ptr.reinterpret(long newSize)	Assume the XrSessionActionSetsAttachInfo.Ptr is capable of holding at least newSize structures, create a new view XrSessionActionSetsAttachInfo.Ptr that uses the same backing storage as this XrSessionActionSetsAttachInfo.Ptr, but with the new size.
@NotNull XrSessionBeginInfo.Ptr	XrSessionBeginInfo.Ptr.reinterpret(long newSize)	Assume the XrSessionBeginInfo.Ptr is capable of holding at least newSize structures, create a new view XrSessionBeginInfo.Ptr that uses the same backing storage as this XrSessionBeginInfo.Ptr, but with the new size.
@NotNull XrSessionCreateInfo.Ptr	XrSessionCreateInfo.Ptr.reinterpret(long newSize)	Assume the XrSessionCreateInfo.Ptr is capable of holding at least newSize structures, create a new view XrSessionCreateInfo.Ptr that uses the same backing storage as this XrSessionCreateInfo.Ptr, but with the new size.
@NotNull XrSessionCreateInfoOverlayEXTX.Ptr	XrSessionCreateInfoOverlayEXTX.Ptr.reinterpret(long newSize)	Assume the XrSessionCreateInfoOverlayEXTX.Ptr is capable of holding at least newSize structures, create a new view XrSessionCreateInfoOverlayEXTX.Ptr that uses the same backing storage as this XrSessionCreateInfoOverlayEXTX.Ptr, but with the new size.
@NotNull XrSharedSpatialAnchorDownloadInfoBD.Ptr	XrSharedSpatialAnchorDownloadInfoBD.Ptr.reinterpret(long newSize)	Assume the XrSharedSpatialAnchorDownloadInfoBD.Ptr is capable of holding at least newSize structures, create a new view XrSharedSpatialAnchorDownloadInfoBD.Ptr that uses the same backing storage as this XrSharedSpatialAnchorDownloadInfoBD.Ptr, but with the new size.
@NotNull XrShareSpacesInfoMETA.Ptr	XrShareSpacesInfoMETA.Ptr.reinterpret(long newSize)	Assume the XrShareSpacesInfoMETA.Ptr is capable of holding at least newSize structures, create a new view XrShareSpacesInfoMETA.Ptr that uses the same backing storage as this XrShareSpacesInfoMETA.Ptr, but with the new size.
@NotNull XrShareSpacesRecipientBaseHeaderMETA.Ptr	XrShareSpacesRecipientBaseHeaderMETA.Ptr.reinterpret(long newSize)	Assume the XrShareSpacesRecipientBaseHeaderMETA.Ptr is capable of holding at least newSize structures, create a new view XrShareSpacesRecipientBaseHeaderMETA.Ptr that uses the same backing storage as this XrShareSpacesRecipientBaseHeaderMETA.Ptr, but with the new size.
@NotNull XrShareSpacesRecipientGroupsMETA.Ptr	XrShareSpacesRecipientGroupsMETA.Ptr.reinterpret(long newSize)	Assume the XrShareSpacesRecipientGroupsMETA.Ptr is capable of holding at least newSize structures, create a new view XrShareSpacesRecipientGroupsMETA.Ptr that uses the same backing storage as this XrShareSpacesRecipientGroupsMETA.Ptr, but with the new size.
@NotNull XrSimultaneousHandsAndControllersTrackingPauseInfoMETA.Ptr	XrSimultaneousHandsAndControllersTrackingPauseInfoMETA.Ptr.reinterpret(long newSize)	Assume the XrSimultaneousHandsAndControllersTrackingPauseInfoMETA.Ptr is capable of holding at least newSize structures, create a new view XrSimultaneousHandsAndControllersTrackingPauseInfoMETA.Ptr that uses the same backing storage as this XrSimultaneousHandsAndControllersTrackingPauseInfoMETA.Ptr, but with the new size.
@NotNull XrSimultaneousHandsAndControllersTrackingResumeInfoMETA.Ptr	XrSimultaneousHandsAndControllersTrackingResumeInfoMETA.Ptr.reinterpret(long newSize)	Assume the XrSimultaneousHandsAndControllersTrackingResumeInfoMETA.Ptr is capable of holding at least newSize structures, create a new view XrSimultaneousHandsAndControllersTrackingResumeInfoMETA.Ptr that uses the same backing storage as this XrSimultaneousHandsAndControllersTrackingResumeInfoMETA.Ptr, but with the new size.
@NotNull XrSpaceComponentFilterInfoFB.Ptr	XrSpaceComponentFilterInfoFB.Ptr.reinterpret(long newSize)	Assume the XrSpaceComponentFilterInfoFB.Ptr is capable of holding at least newSize structures, create a new view XrSpaceComponentFilterInfoFB.Ptr that uses the same backing storage as this XrSpaceComponentFilterInfoFB.Ptr, but with the new size.
@NotNull XrSpaceComponentStatusFB.Ptr	XrSpaceComponentStatusFB.Ptr.reinterpret(long newSize)	Assume the XrSpaceComponentStatusFB.Ptr is capable of holding at least newSize structures, create a new view XrSpaceComponentStatusFB.Ptr that uses the same backing storage as this XrSpaceComponentStatusFB.Ptr, but with the new size.
@NotNull XrSpaceComponentStatusSetInfoFB.Ptr	XrSpaceComponentStatusSetInfoFB.Ptr.reinterpret(long newSize)	Assume the XrSpaceComponentStatusSetInfoFB.Ptr is capable of holding at least newSize structures, create a new view XrSpaceComponentStatusSetInfoFB.Ptr that uses the same backing storage as this XrSpaceComponentStatusSetInfoFB.Ptr, but with the new size.
@NotNull XrSpaceContainerFB.Ptr	XrSpaceContainerFB.Ptr.reinterpret(long newSize)	Assume the XrSpaceContainerFB.Ptr is capable of holding at least newSize structures, create a new view XrSpaceContainerFB.Ptr that uses the same backing storage as this XrSpaceContainerFB.Ptr, but with the new size.
@NotNull XrSpaceEraseInfoFB.Ptr	XrSpaceEraseInfoFB.Ptr.reinterpret(long newSize)	Assume the XrSpaceEraseInfoFB.Ptr is capable of holding at least newSize structures, create a new view XrSpaceEraseInfoFB.Ptr that uses the same backing storage as this XrSpaceEraseInfoFB.Ptr, but with the new size.
@NotNull XrSpaceFilterInfoBaseHeaderFB.Ptr	XrSpaceFilterInfoBaseHeaderFB.Ptr.reinterpret(long newSize)	Assume the XrSpaceFilterInfoBaseHeaderFB.Ptr is capable of holding at least newSize structures, create a new view XrSpaceFilterInfoBaseHeaderFB.Ptr that uses the same backing storage as this XrSpaceFilterInfoBaseHeaderFB.Ptr, but with the new size.
@NotNull XrSpaceGroupUuidFilterInfoMETA.Ptr	XrSpaceGroupUuidFilterInfoMETA.Ptr.reinterpret(long newSize)	Assume the XrSpaceGroupUuidFilterInfoMETA.Ptr is capable of holding at least newSize structures, create a new view XrSpaceGroupUuidFilterInfoMETA.Ptr that uses the same backing storage as this XrSpaceGroupUuidFilterInfoMETA.Ptr, but with the new size.
@NotNull XrSpaceListSaveInfoFB.Ptr	XrSpaceListSaveInfoFB.Ptr.reinterpret(long newSize)	Assume the XrSpaceListSaveInfoFB.Ptr is capable of holding at least newSize structures, create a new view XrSpaceListSaveInfoFB.Ptr that uses the same backing storage as this XrSpaceListSaveInfoFB.Ptr, but with the new size.
@NotNull XrSpaceLocation.Ptr	XrSpaceLocation.Ptr.reinterpret(long newSize)	Assume the XrSpaceLocation.Ptr is capable of holding at least newSize structures, create a new view XrSpaceLocation.Ptr that uses the same backing storage as this XrSpaceLocation.Ptr, but with the new size.
@NotNull XrSpaceLocationData.Ptr	XrSpaceLocationData.Ptr.reinterpret(long newSize)	Assume the XrSpaceLocationData.Ptr is capable of holding at least newSize structures, create a new view XrSpaceLocationData.Ptr that uses the same backing storage as this XrSpaceLocationData.Ptr, but with the new size.
@NotNull XrSpaceLocationDataKHR.Ptr	XrSpaceLocationDataKHR.Ptr.reinterpret(long newSize)	Assume the XrSpaceLocationDataKHR.Ptr is capable of holding at least newSize structures, create a new view XrSpaceLocationDataKHR.Ptr that uses the same backing storage as this XrSpaceLocationDataKHR.Ptr, but with the new size.
@NotNull XrSpaceLocations.Ptr	XrSpaceLocations.Ptr.reinterpret(long newSize)	Assume the XrSpaceLocations.Ptr is capable of holding at least newSize structures, create a new view XrSpaceLocations.Ptr that uses the same backing storage as this XrSpaceLocations.Ptr, but with the new size.
@NotNull XrSpaceLocationsKHR.Ptr	XrSpaceLocationsKHR.Ptr.reinterpret(long newSize)	Assume the XrSpaceLocationsKHR.Ptr is capable of holding at least newSize structures, create a new view XrSpaceLocationsKHR.Ptr that uses the same backing storage as this XrSpaceLocationsKHR.Ptr, but with the new size.
@NotNull XrSpaceQueryInfoBaseHeaderFB.Ptr	XrSpaceQueryInfoBaseHeaderFB.Ptr.reinterpret(long newSize)	Assume the XrSpaceQueryInfoBaseHeaderFB.Ptr is capable of holding at least newSize structures, create a new view XrSpaceQueryInfoBaseHeaderFB.Ptr that uses the same backing storage as this XrSpaceQueryInfoBaseHeaderFB.Ptr, but with the new size.
@NotNull XrSpaceQueryInfoFB.Ptr	XrSpaceQueryInfoFB.Ptr.reinterpret(long newSize)	Assume the XrSpaceQueryInfoFB.Ptr is capable of holding at least newSize structures, create a new view XrSpaceQueryInfoFB.Ptr that uses the same backing storage as this XrSpaceQueryInfoFB.Ptr, but with the new size.
@NotNull XrSpaceQueryResultFB.Ptr	XrSpaceQueryResultFB.Ptr.reinterpret(long newSize)	Assume the XrSpaceQueryResultFB.Ptr is capable of holding at least newSize structures, create a new view XrSpaceQueryResultFB.Ptr that uses the same backing storage as this XrSpaceQueryResultFB.Ptr, but with the new size.
@NotNull XrSpaceQueryResultsFB.Ptr	XrSpaceQueryResultsFB.Ptr.reinterpret(long newSize)	Assume the XrSpaceQueryResultsFB.Ptr is capable of holding at least newSize structures, create a new view XrSpaceQueryResultsFB.Ptr that uses the same backing storage as this XrSpaceQueryResultsFB.Ptr, but with the new size.
@NotNull XrSpaceSaveInfoFB.Ptr	XrSpaceSaveInfoFB.Ptr.reinterpret(long newSize)	Assume the XrSpaceSaveInfoFB.Ptr is capable of holding at least newSize structures, create a new view XrSpaceSaveInfoFB.Ptr that uses the same backing storage as this XrSpaceSaveInfoFB.Ptr, but with the new size.
@NotNull XrSpaceShareInfoFB.Ptr	XrSpaceShareInfoFB.Ptr.reinterpret(long newSize)	Assume the XrSpaceShareInfoFB.Ptr is capable of holding at least newSize structures, create a new view XrSpaceShareInfoFB.Ptr that uses the same backing storage as this XrSpaceShareInfoFB.Ptr, but with the new size.
@NotNull XrSpacesLocateInfo.Ptr	XrSpacesLocateInfo.Ptr.reinterpret(long newSize)	Assume the XrSpacesLocateInfo.Ptr is capable of holding at least newSize structures, create a new view XrSpacesLocateInfo.Ptr that uses the same backing storage as this XrSpacesLocateInfo.Ptr, but with the new size.
@NotNull XrSpacesLocateInfoKHR.Ptr	XrSpacesLocateInfoKHR.Ptr.reinterpret(long newSize)	Assume the XrSpacesLocateInfoKHR.Ptr is capable of holding at least newSize structures, create a new view XrSpacesLocateInfoKHR.Ptr that uses the same backing storage as this XrSpacesLocateInfoKHR.Ptr, but with the new size.
@NotNull XrSpaceStorageLocationFilterInfoFB.Ptr	XrSpaceStorageLocationFilterInfoFB.Ptr.reinterpret(long newSize)	Assume the XrSpaceStorageLocationFilterInfoFB.Ptr is capable of holding at least newSize structures, create a new view XrSpaceStorageLocationFilterInfoFB.Ptr that uses the same backing storage as this XrSpaceStorageLocationFilterInfoFB.Ptr, but with the new size.
@NotNull XrSpaceTriangleMeshGetInfoMETA.Ptr	XrSpaceTriangleMeshGetInfoMETA.Ptr.reinterpret(long newSize)	Assume the XrSpaceTriangleMeshGetInfoMETA.Ptr is capable of holding at least newSize structures, create a new view XrSpaceTriangleMeshGetInfoMETA.Ptr that uses the same backing storage as this XrSpaceTriangleMeshGetInfoMETA.Ptr, but with the new size.
@NotNull XrSpaceTriangleMeshMETA.Ptr	XrSpaceTriangleMeshMETA.Ptr.reinterpret(long newSize)	Assume the XrSpaceTriangleMeshMETA.Ptr is capable of holding at least newSize structures, create a new view XrSpaceTriangleMeshMETA.Ptr that uses the same backing storage as this XrSpaceTriangleMeshMETA.Ptr, but with the new size.
@NotNull XrSpaceUserCreateInfoFB.Ptr	XrSpaceUserCreateInfoFB.Ptr.reinterpret(long newSize)	Assume the XrSpaceUserCreateInfoFB.Ptr is capable of holding at least newSize structures, create a new view XrSpaceUserCreateInfoFB.Ptr that uses the same backing storage as this XrSpaceUserCreateInfoFB.Ptr, but with the new size.
@NotNull XrSpaceUuidFilterInfoFB.Ptr	XrSpaceUuidFilterInfoFB.Ptr.reinterpret(long newSize)	Assume the XrSpaceUuidFilterInfoFB.Ptr is capable of holding at least newSize structures, create a new view XrSpaceUuidFilterInfoFB.Ptr that uses the same backing storage as this XrSpaceUuidFilterInfoFB.Ptr, but with the new size.
@NotNull XrSpaceVelocities.Ptr	XrSpaceVelocities.Ptr.reinterpret(long newSize)	Assume the XrSpaceVelocities.Ptr is capable of holding at least newSize structures, create a new view XrSpaceVelocities.Ptr that uses the same backing storage as this XrSpaceVelocities.Ptr, but with the new size.
@NotNull XrSpaceVelocitiesKHR.Ptr	XrSpaceVelocitiesKHR.Ptr.reinterpret(long newSize)	Assume the XrSpaceVelocitiesKHR.Ptr is capable of holding at least newSize structures, create a new view XrSpaceVelocitiesKHR.Ptr that uses the same backing storage as this XrSpaceVelocitiesKHR.Ptr, but with the new size.
@NotNull XrSpaceVelocity.Ptr	XrSpaceVelocity.Ptr.reinterpret(long newSize)	Assume the XrSpaceVelocity.Ptr is capable of holding at least newSize structures, create a new view XrSpaceVelocity.Ptr that uses the same backing storage as this XrSpaceVelocity.Ptr, but with the new size.
@NotNull XrSpaceVelocityData.Ptr	XrSpaceVelocityData.Ptr.reinterpret(long newSize)	Assume the XrSpaceVelocityData.Ptr is capable of holding at least newSize structures, create a new view XrSpaceVelocityData.Ptr that uses the same backing storage as this XrSpaceVelocityData.Ptr, but with the new size.
@NotNull XrSpaceVelocityDataKHR.Ptr	XrSpaceVelocityDataKHR.Ptr.reinterpret(long newSize)	Assume the XrSpaceVelocityDataKHR.Ptr is capable of holding at least newSize structures, create a new view XrSpaceVelocityDataKHR.Ptr that uses the same backing storage as this XrSpaceVelocityDataKHR.Ptr, but with the new size.
@NotNull XrSpatialAnchorCompletionResultML.Ptr	XrSpatialAnchorCompletionResultML.Ptr.reinterpret(long newSize)	Assume the XrSpatialAnchorCompletionResultML.Ptr is capable of holding at least newSize structures, create a new view XrSpatialAnchorCompletionResultML.Ptr that uses the same backing storage as this XrSpatialAnchorCompletionResultML.Ptr, but with the new size.
@NotNull XrSpatialAnchorCreateCompletionBD.Ptr	XrSpatialAnchorCreateCompletionBD.Ptr.reinterpret(long newSize)	Assume the XrSpatialAnchorCreateCompletionBD.Ptr is capable of holding at least newSize structures, create a new view XrSpatialAnchorCreateCompletionBD.Ptr that uses the same backing storage as this XrSpatialAnchorCreateCompletionBD.Ptr, but with the new size.
@NotNull XrSpatialAnchorCreateInfoBD.Ptr	XrSpatialAnchorCreateInfoBD.Ptr.reinterpret(long newSize)	Assume the XrSpatialAnchorCreateInfoBD.Ptr is capable of holding at least newSize structures, create a new view XrSpatialAnchorCreateInfoBD.Ptr that uses the same backing storage as this XrSpatialAnchorCreateInfoBD.Ptr, but with the new size.
@NotNull XrSpatialAnchorCreateInfoEXT.Ptr	XrSpatialAnchorCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the XrSpatialAnchorCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view XrSpatialAnchorCreateInfoEXT.Ptr that uses the same backing storage as this XrSpatialAnchorCreateInfoEXT.Ptr, but with the new size.
@NotNull XrSpatialAnchorCreateInfoFB.Ptr	XrSpatialAnchorCreateInfoFB.Ptr.reinterpret(long newSize)	Assume the XrSpatialAnchorCreateInfoFB.Ptr is capable of holding at least newSize structures, create a new view XrSpatialAnchorCreateInfoFB.Ptr that uses the same backing storage as this XrSpatialAnchorCreateInfoFB.Ptr, but with the new size.
@NotNull XrSpatialAnchorCreateInfoHTC.Ptr	XrSpatialAnchorCreateInfoHTC.Ptr.reinterpret(long newSize)	Assume the XrSpatialAnchorCreateInfoHTC.Ptr is capable of holding at least newSize structures, create a new view XrSpatialAnchorCreateInfoHTC.Ptr that uses the same backing storage as this XrSpatialAnchorCreateInfoHTC.Ptr, but with the new size.
@NotNull XrSpatialAnchorCreateInfoMSFT.Ptr	XrSpatialAnchorCreateInfoMSFT.Ptr.reinterpret(long newSize)	Assume the XrSpatialAnchorCreateInfoMSFT.Ptr is capable of holding at least newSize structures, create a new view XrSpatialAnchorCreateInfoMSFT.Ptr that uses the same backing storage as this XrSpatialAnchorCreateInfoMSFT.Ptr, but with the new size.
@NotNull XrSpatialAnchorFromPersistedAnchorCreateInfoMSFT.Ptr	XrSpatialAnchorFromPersistedAnchorCreateInfoMSFT.Ptr.reinterpret(long newSize)	Assume the XrSpatialAnchorFromPersistedAnchorCreateInfoMSFT.Ptr is capable of holding at least newSize structures, create a new view XrSpatialAnchorFromPersistedAnchorCreateInfoMSFT.Ptr that uses the same backing storage as this XrSpatialAnchorFromPersistedAnchorCreateInfoMSFT.Ptr, but with the new size.
@NotNull XrSpatialAnchorNameHTC.Ptr	XrSpatialAnchorNameHTC.Ptr.reinterpret(long newSize)	Assume the XrSpatialAnchorNameHTC.Ptr is capable of holding at least newSize structures, create a new view XrSpatialAnchorNameHTC.Ptr that uses the same backing storage as this XrSpatialAnchorNameHTC.Ptr, but with the new size.
@NotNull XrSpatialAnchorPersistenceInfoMSFT.Ptr	XrSpatialAnchorPersistenceInfoMSFT.Ptr.reinterpret(long newSize)	Assume the XrSpatialAnchorPersistenceInfoMSFT.Ptr is capable of holding at least newSize structures, create a new view XrSpatialAnchorPersistenceInfoMSFT.Ptr that uses the same backing storage as this XrSpatialAnchorPersistenceInfoMSFT.Ptr, but with the new size.
@NotNull XrSpatialAnchorPersistenceNameMSFT.Ptr	XrSpatialAnchorPersistenceNameMSFT.Ptr.reinterpret(long newSize)	Assume the XrSpatialAnchorPersistenceNameMSFT.Ptr is capable of holding at least newSize structures, create a new view XrSpatialAnchorPersistenceNameMSFT.Ptr that uses the same backing storage as this XrSpatialAnchorPersistenceNameMSFT.Ptr, but with the new size.
@NotNull XrSpatialAnchorPersistInfoBD.Ptr	XrSpatialAnchorPersistInfoBD.Ptr.reinterpret(long newSize)	Assume the XrSpatialAnchorPersistInfoBD.Ptr is capable of holding at least newSize structures, create a new view XrSpatialAnchorPersistInfoBD.Ptr that uses the same backing storage as this XrSpatialAnchorPersistInfoBD.Ptr, but with the new size.
@NotNull XrSpatialAnchorsCreateInfoBaseHeaderML.Ptr	XrSpatialAnchorsCreateInfoBaseHeaderML.Ptr.reinterpret(long newSize)	Assume the XrSpatialAnchorsCreateInfoBaseHeaderML.Ptr is capable of holding at least newSize structures, create a new view XrSpatialAnchorsCreateInfoBaseHeaderML.Ptr that uses the same backing storage as this XrSpatialAnchorsCreateInfoBaseHeaderML.Ptr, but with the new size.
@NotNull XrSpatialAnchorsCreateInfoFromPoseML.Ptr	XrSpatialAnchorsCreateInfoFromPoseML.Ptr.reinterpret(long newSize)	Assume the XrSpatialAnchorsCreateInfoFromPoseML.Ptr is capable of holding at least newSize structures, create a new view XrSpatialAnchorsCreateInfoFromPoseML.Ptr that uses the same backing storage as this XrSpatialAnchorsCreateInfoFromPoseML.Ptr, but with the new size.
@NotNull XrSpatialAnchorsCreateInfoFromUuidsML.Ptr	XrSpatialAnchorsCreateInfoFromUuidsML.Ptr.reinterpret(long newSize)	Assume the XrSpatialAnchorsCreateInfoFromUuidsML.Ptr is capable of holding at least newSize structures, create a new view XrSpatialAnchorsCreateInfoFromUuidsML.Ptr that uses the same backing storage as this XrSpatialAnchorsCreateInfoFromUuidsML.Ptr, but with the new size.
@NotNull XrSpatialAnchorsCreateStorageInfoML.Ptr	XrSpatialAnchorsCreateStorageInfoML.Ptr.reinterpret(long newSize)	Assume the XrSpatialAnchorsCreateStorageInfoML.Ptr is capable of holding at least newSize structures, create a new view XrSpatialAnchorsCreateStorageInfoML.Ptr that uses the same backing storage as this XrSpatialAnchorsCreateStorageInfoML.Ptr, but with the new size.
@NotNull XrSpatialAnchorsDeleteCompletionDetailsML.Ptr	XrSpatialAnchorsDeleteCompletionDetailsML.Ptr.reinterpret(long newSize)	Assume the XrSpatialAnchorsDeleteCompletionDetailsML.Ptr is capable of holding at least newSize structures, create a new view XrSpatialAnchorsDeleteCompletionDetailsML.Ptr that uses the same backing storage as this XrSpatialAnchorsDeleteCompletionDetailsML.Ptr, but with the new size.
@NotNull XrSpatialAnchorsDeleteCompletionML.Ptr	XrSpatialAnchorsDeleteCompletionML.Ptr.reinterpret(long newSize)	Assume the XrSpatialAnchorsDeleteCompletionML.Ptr is capable of holding at least newSize structures, create a new view XrSpatialAnchorsDeleteCompletionML.Ptr that uses the same backing storage as this XrSpatialAnchorsDeleteCompletionML.Ptr, but with the new size.
@NotNull XrSpatialAnchorsDeleteInfoML.Ptr	XrSpatialAnchorsDeleteInfoML.Ptr.reinterpret(long newSize)	Assume the XrSpatialAnchorsDeleteInfoML.Ptr is capable of holding at least newSize structures, create a new view XrSpatialAnchorsDeleteInfoML.Ptr that uses the same backing storage as this XrSpatialAnchorsDeleteInfoML.Ptr, but with the new size.
@NotNull XrSpatialAnchorShareInfoBD.Ptr	XrSpatialAnchorShareInfoBD.Ptr.reinterpret(long newSize)	Assume the XrSpatialAnchorShareInfoBD.Ptr is capable of holding at least newSize structures, create a new view XrSpatialAnchorShareInfoBD.Ptr that uses the same backing storage as this XrSpatialAnchorShareInfoBD.Ptr, but with the new size.
@NotNull XrSpatialAnchorSpaceCreateInfoMSFT.Ptr	XrSpatialAnchorSpaceCreateInfoMSFT.Ptr.reinterpret(long newSize)	Assume the XrSpatialAnchorSpaceCreateInfoMSFT.Ptr is capable of holding at least newSize structures, create a new view XrSpatialAnchorSpaceCreateInfoMSFT.Ptr that uses the same backing storage as this XrSpatialAnchorSpaceCreateInfoMSFT.Ptr, but with the new size.
@NotNull XrSpatialAnchorsPublishCompletionDetailsML.Ptr	XrSpatialAnchorsPublishCompletionDetailsML.Ptr.reinterpret(long newSize)	Assume the XrSpatialAnchorsPublishCompletionDetailsML.Ptr is capable of holding at least newSize structures, create a new view XrSpatialAnchorsPublishCompletionDetailsML.Ptr that uses the same backing storage as this XrSpatialAnchorsPublishCompletionDetailsML.Ptr, but with the new size.
@NotNull XrSpatialAnchorsPublishCompletionML.Ptr	XrSpatialAnchorsPublishCompletionML.Ptr.reinterpret(long newSize)	Assume the XrSpatialAnchorsPublishCompletionML.Ptr is capable of holding at least newSize structures, create a new view XrSpatialAnchorsPublishCompletionML.Ptr that uses the same backing storage as this XrSpatialAnchorsPublishCompletionML.Ptr, but with the new size.
@NotNull XrSpatialAnchorsPublishInfoML.Ptr	XrSpatialAnchorsPublishInfoML.Ptr.reinterpret(long newSize)	Assume the XrSpatialAnchorsPublishInfoML.Ptr is capable of holding at least newSize structures, create a new view XrSpatialAnchorsPublishInfoML.Ptr that uses the same backing storage as this XrSpatialAnchorsPublishInfoML.Ptr, but with the new size.
@NotNull XrSpatialAnchorsQueryCompletionML.Ptr	XrSpatialAnchorsQueryCompletionML.Ptr.reinterpret(long newSize)	Assume the XrSpatialAnchorsQueryCompletionML.Ptr is capable of holding at least newSize structures, create a new view XrSpatialAnchorsQueryCompletionML.Ptr that uses the same backing storage as this XrSpatialAnchorsQueryCompletionML.Ptr, but with the new size.
@NotNull XrSpatialAnchorsQueryInfoBaseHeaderML.Ptr	XrSpatialAnchorsQueryInfoBaseHeaderML.Ptr.reinterpret(long newSize)	Assume the XrSpatialAnchorsQueryInfoBaseHeaderML.Ptr is capable of holding at least newSize structures, create a new view XrSpatialAnchorsQueryInfoBaseHeaderML.Ptr that uses the same backing storage as this XrSpatialAnchorsQueryInfoBaseHeaderML.Ptr, but with the new size.
@NotNull XrSpatialAnchorsQueryInfoRadiusML.Ptr	XrSpatialAnchorsQueryInfoRadiusML.Ptr.reinterpret(long newSize)	Assume the XrSpatialAnchorsQueryInfoRadiusML.Ptr is capable of holding at least newSize structures, create a new view XrSpatialAnchorsQueryInfoRadiusML.Ptr that uses the same backing storage as this XrSpatialAnchorsQueryInfoRadiusML.Ptr, but with the new size.
@NotNull XrSpatialAnchorStateML.Ptr	XrSpatialAnchorStateML.Ptr.reinterpret(long newSize)	Assume the XrSpatialAnchorStateML.Ptr is capable of holding at least newSize structures, create a new view XrSpatialAnchorStateML.Ptr that uses the same backing storage as this XrSpatialAnchorStateML.Ptr, but with the new size.
@NotNull XrSpatialAnchorsUpdateExpirationCompletionDetailsML.Ptr	XrSpatialAnchorsUpdateExpirationCompletionDetailsML.Ptr.reinterpret(long newSize)	Assume the XrSpatialAnchorsUpdateExpirationCompletionDetailsML.Ptr is capable of holding at least newSize structures, create a new view XrSpatialAnchorsUpdateExpirationCompletionDetailsML.Ptr that uses the same backing storage as this XrSpatialAnchorsUpdateExpirationCompletionDetailsML.Ptr, but with the new size.
@NotNull XrSpatialAnchorsUpdateExpirationCompletionML.Ptr	XrSpatialAnchorsUpdateExpirationCompletionML.Ptr.reinterpret(long newSize)	Assume the XrSpatialAnchorsUpdateExpirationCompletionML.Ptr is capable of holding at least newSize structures, create a new view XrSpatialAnchorsUpdateExpirationCompletionML.Ptr that uses the same backing storage as this XrSpatialAnchorsUpdateExpirationCompletionML.Ptr, but with the new size.
@NotNull XrSpatialAnchorsUpdateExpirationInfoML.Ptr	XrSpatialAnchorsUpdateExpirationInfoML.Ptr.reinterpret(long newSize)	Assume the XrSpatialAnchorsUpdateExpirationInfoML.Ptr is capable of holding at least newSize structures, create a new view XrSpatialAnchorsUpdateExpirationInfoML.Ptr that uses the same backing storage as this XrSpatialAnchorsUpdateExpirationInfoML.Ptr, but with the new size.
@NotNull XrSpatialAnchorUnpersistInfoBD.Ptr	XrSpatialAnchorUnpersistInfoBD.Ptr.reinterpret(long newSize)	Assume the XrSpatialAnchorUnpersistInfoBD.Ptr is capable of holding at least newSize structures, create a new view XrSpatialAnchorUnpersistInfoBD.Ptr that uses the same backing storage as this XrSpatialAnchorUnpersistInfoBD.Ptr, but with the new size.
@NotNull XrSpatialBounded2DDataEXT.Ptr	XrSpatialBounded2DDataEXT.Ptr.reinterpret(long newSize)	Assume the XrSpatialBounded2DDataEXT.Ptr is capable of holding at least newSize structures, create a new view XrSpatialBounded2DDataEXT.Ptr that uses the same backing storage as this XrSpatialBounded2DDataEXT.Ptr, but with the new size.
@NotNull XrSpatialBufferEXT.Ptr	XrSpatialBufferEXT.Ptr.reinterpret(long newSize)	Assume the XrSpatialBufferEXT.Ptr is capable of holding at least newSize structures, create a new view XrSpatialBufferEXT.Ptr that uses the same backing storage as this XrSpatialBufferEXT.Ptr, but with the new size.
@NotNull XrSpatialBufferGetInfoEXT.Ptr	XrSpatialBufferGetInfoEXT.Ptr.reinterpret(long newSize)	Assume the XrSpatialBufferGetInfoEXT.Ptr is capable of holding at least newSize structures, create a new view XrSpatialBufferGetInfoEXT.Ptr that uses the same backing storage as this XrSpatialBufferGetInfoEXT.Ptr, but with the new size.
@NotNull XrSpatialCapabilityComponentTypesEXT.Ptr	XrSpatialCapabilityComponentTypesEXT.Ptr.reinterpret(long newSize)	Assume the XrSpatialCapabilityComponentTypesEXT.Ptr is capable of holding at least newSize structures, create a new view XrSpatialCapabilityComponentTypesEXT.Ptr that uses the same backing storage as this XrSpatialCapabilityComponentTypesEXT.Ptr, but with the new size.
@NotNull XrSpatialCapabilityConfigurationAnchorEXT.Ptr	XrSpatialCapabilityConfigurationAnchorEXT.Ptr.reinterpret(long newSize)	Assume the XrSpatialCapabilityConfigurationAnchorEXT.Ptr is capable of holding at least newSize structures, create a new view XrSpatialCapabilityConfigurationAnchorEXT.Ptr that uses the same backing storage as this XrSpatialCapabilityConfigurationAnchorEXT.Ptr, but with the new size.
@NotNull XrSpatialCapabilityConfigurationAprilTagEXT.Ptr	XrSpatialCapabilityConfigurationAprilTagEXT.Ptr.reinterpret(long newSize)	Assume the XrSpatialCapabilityConfigurationAprilTagEXT.Ptr is capable of holding at least newSize structures, create a new view XrSpatialCapabilityConfigurationAprilTagEXT.Ptr that uses the same backing storage as this XrSpatialCapabilityConfigurationAprilTagEXT.Ptr, but with the new size.
@NotNull XrSpatialCapabilityConfigurationArucoMarkerEXT.Ptr	XrSpatialCapabilityConfigurationArucoMarkerEXT.Ptr.reinterpret(long newSize)	Assume the XrSpatialCapabilityConfigurationArucoMarkerEXT.Ptr is capable of holding at least newSize structures, create a new view XrSpatialCapabilityConfigurationArucoMarkerEXT.Ptr that uses the same backing storage as this XrSpatialCapabilityConfigurationArucoMarkerEXT.Ptr, but with the new size.
@NotNull XrSpatialCapabilityConfigurationBaseHeaderEXT.Ptr	XrSpatialCapabilityConfigurationBaseHeaderEXT.Ptr.reinterpret(long newSize)	Assume the XrSpatialCapabilityConfigurationBaseHeaderEXT.Ptr is capable of holding at least newSize structures, create a new view XrSpatialCapabilityConfigurationBaseHeaderEXT.Ptr that uses the same backing storage as this XrSpatialCapabilityConfigurationBaseHeaderEXT.Ptr, but with the new size.
@NotNull XrSpatialCapabilityConfigurationMicroQrCodeEXT.Ptr	XrSpatialCapabilityConfigurationMicroQrCodeEXT.Ptr.reinterpret(long newSize)	Assume the XrSpatialCapabilityConfigurationMicroQrCodeEXT.Ptr is capable of holding at least newSize structures, create a new view XrSpatialCapabilityConfigurationMicroQrCodeEXT.Ptr that uses the same backing storage as this XrSpatialCapabilityConfigurationMicroQrCodeEXT.Ptr, but with the new size.
@NotNull XrSpatialCapabilityConfigurationPlaneTrackingEXT.Ptr	XrSpatialCapabilityConfigurationPlaneTrackingEXT.Ptr.reinterpret(long newSize)	Assume the XrSpatialCapabilityConfigurationPlaneTrackingEXT.Ptr is capable of holding at least newSize structures, create a new view XrSpatialCapabilityConfigurationPlaneTrackingEXT.Ptr that uses the same backing storage as this XrSpatialCapabilityConfigurationPlaneTrackingEXT.Ptr, but with the new size.
@NotNull XrSpatialCapabilityConfigurationQrCodeEXT.Ptr	XrSpatialCapabilityConfigurationQrCodeEXT.Ptr.reinterpret(long newSize)	Assume the XrSpatialCapabilityConfigurationQrCodeEXT.Ptr is capable of holding at least newSize structures, create a new view XrSpatialCapabilityConfigurationQrCodeEXT.Ptr that uses the same backing storage as this XrSpatialCapabilityConfigurationQrCodeEXT.Ptr, but with the new size.
@NotNull XrSpatialComponentAnchorListEXT.Ptr	XrSpatialComponentAnchorListEXT.Ptr.reinterpret(long newSize)	Assume the XrSpatialComponentAnchorListEXT.Ptr is capable of holding at least newSize structures, create a new view XrSpatialComponentAnchorListEXT.Ptr that uses the same backing storage as this XrSpatialComponentAnchorListEXT.Ptr, but with the new size.
@NotNull XrSpatialComponentBounded2DListEXT.Ptr	XrSpatialComponentBounded2DListEXT.Ptr.reinterpret(long newSize)	Assume the XrSpatialComponentBounded2DListEXT.Ptr is capable of holding at least newSize structures, create a new view XrSpatialComponentBounded2DListEXT.Ptr that uses the same backing storage as this XrSpatialComponentBounded2DListEXT.Ptr, but with the new size.
@NotNull XrSpatialComponentBounded3DListEXT.Ptr	XrSpatialComponentBounded3DListEXT.Ptr.reinterpret(long newSize)	Assume the XrSpatialComponentBounded3DListEXT.Ptr is capable of holding at least newSize structures, create a new view XrSpatialComponentBounded3DListEXT.Ptr that uses the same backing storage as this XrSpatialComponentBounded3DListEXT.Ptr, but with the new size.
@NotNull XrSpatialComponentDataQueryConditionEXT.Ptr	XrSpatialComponentDataQueryConditionEXT.Ptr.reinterpret(long newSize)	Assume the XrSpatialComponentDataQueryConditionEXT.Ptr is capable of holding at least newSize structures, create a new view XrSpatialComponentDataQueryConditionEXT.Ptr that uses the same backing storage as this XrSpatialComponentDataQueryConditionEXT.Ptr, but with the new size.
@NotNull XrSpatialComponentDataQueryResultEXT.Ptr	XrSpatialComponentDataQueryResultEXT.Ptr.reinterpret(long newSize)	Assume the XrSpatialComponentDataQueryResultEXT.Ptr is capable of holding at least newSize structures, create a new view XrSpatialComponentDataQueryResultEXT.Ptr that uses the same backing storage as this XrSpatialComponentDataQueryResultEXT.Ptr, but with the new size.
@NotNull XrSpatialComponentMarkerListEXT.Ptr	XrSpatialComponentMarkerListEXT.Ptr.reinterpret(long newSize)	Assume the XrSpatialComponentMarkerListEXT.Ptr is capable of holding at least newSize structures, create a new view XrSpatialComponentMarkerListEXT.Ptr that uses the same backing storage as this XrSpatialComponentMarkerListEXT.Ptr, but with the new size.
@NotNull XrSpatialComponentMesh2DListEXT.Ptr	XrSpatialComponentMesh2DListEXT.Ptr.reinterpret(long newSize)	Assume the XrSpatialComponentMesh2DListEXT.Ptr is capable of holding at least newSize structures, create a new view XrSpatialComponentMesh2DListEXT.Ptr that uses the same backing storage as this XrSpatialComponentMesh2DListEXT.Ptr, but with the new size.
@NotNull XrSpatialComponentMesh3DListEXT.Ptr	XrSpatialComponentMesh3DListEXT.Ptr.reinterpret(long newSize)	Assume the XrSpatialComponentMesh3DListEXT.Ptr is capable of holding at least newSize structures, create a new view XrSpatialComponentMesh3DListEXT.Ptr that uses the same backing storage as this XrSpatialComponentMesh3DListEXT.Ptr, but with the new size.
@NotNull XrSpatialComponentParentListEXT.Ptr	XrSpatialComponentParentListEXT.Ptr.reinterpret(long newSize)	Assume the XrSpatialComponentParentListEXT.Ptr is capable of holding at least newSize structures, create a new view XrSpatialComponentParentListEXT.Ptr that uses the same backing storage as this XrSpatialComponentParentListEXT.Ptr, but with the new size.
@NotNull XrSpatialComponentPersistenceListEXT.Ptr	XrSpatialComponentPersistenceListEXT.Ptr.reinterpret(long newSize)	Assume the XrSpatialComponentPersistenceListEXT.Ptr is capable of holding at least newSize structures, create a new view XrSpatialComponentPersistenceListEXT.Ptr that uses the same backing storage as this XrSpatialComponentPersistenceListEXT.Ptr, but with the new size.
@NotNull XrSpatialComponentPlaneAlignmentListEXT.Ptr	XrSpatialComponentPlaneAlignmentListEXT.Ptr.reinterpret(long newSize)	Assume the XrSpatialComponentPlaneAlignmentListEXT.Ptr is capable of holding at least newSize structures, create a new view XrSpatialComponentPlaneAlignmentListEXT.Ptr that uses the same backing storage as this XrSpatialComponentPlaneAlignmentListEXT.Ptr, but with the new size.
@NotNull XrSpatialComponentPlaneSemanticLabelListEXT.Ptr	XrSpatialComponentPlaneSemanticLabelListEXT.Ptr.reinterpret(long newSize)	Assume the XrSpatialComponentPlaneSemanticLabelListEXT.Ptr is capable of holding at least newSize structures, create a new view XrSpatialComponentPlaneSemanticLabelListEXT.Ptr that uses the same backing storage as this XrSpatialComponentPlaneSemanticLabelListEXT.Ptr, but with the new size.
@NotNull XrSpatialComponentPolygon2DListEXT.Ptr	XrSpatialComponentPolygon2DListEXT.Ptr.reinterpret(long newSize)	Assume the XrSpatialComponentPolygon2DListEXT.Ptr is capable of holding at least newSize structures, create a new view XrSpatialComponentPolygon2DListEXT.Ptr that uses the same backing storage as this XrSpatialComponentPolygon2DListEXT.Ptr, but with the new size.
@NotNull XrSpatialContextCreateInfoEXT.Ptr	XrSpatialContextCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the XrSpatialContextCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view XrSpatialContextCreateInfoEXT.Ptr that uses the same backing storage as this XrSpatialContextCreateInfoEXT.Ptr, but with the new size.
@NotNull XrSpatialContextPersistenceConfigEXT.Ptr	XrSpatialContextPersistenceConfigEXT.Ptr.reinterpret(long newSize)	Assume the XrSpatialContextPersistenceConfigEXT.Ptr is capable of holding at least newSize structures, create a new view XrSpatialContextPersistenceConfigEXT.Ptr that uses the same backing storage as this XrSpatialContextPersistenceConfigEXT.Ptr, but with the new size.
@NotNull XrSpatialDiscoveryPersistenceUuidFilterEXT.Ptr	XrSpatialDiscoveryPersistenceUuidFilterEXT.Ptr.reinterpret(long newSize)	Assume the XrSpatialDiscoveryPersistenceUuidFilterEXT.Ptr is capable of holding at least newSize structures, create a new view XrSpatialDiscoveryPersistenceUuidFilterEXT.Ptr that uses the same backing storage as this XrSpatialDiscoveryPersistenceUuidFilterEXT.Ptr, but with the new size.
@NotNull XrSpatialDiscoverySnapshotCreateInfoEXT.Ptr	XrSpatialDiscoverySnapshotCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the XrSpatialDiscoverySnapshotCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view XrSpatialDiscoverySnapshotCreateInfoEXT.Ptr that uses the same backing storage as this XrSpatialDiscoverySnapshotCreateInfoEXT.Ptr, but with the new size.
@NotNull XrSpatialEntityAnchorCreateInfoBD.Ptr	XrSpatialEntityAnchorCreateInfoBD.Ptr.reinterpret(long newSize)	Assume the XrSpatialEntityAnchorCreateInfoBD.Ptr is capable of holding at least newSize structures, create a new view XrSpatialEntityAnchorCreateInfoBD.Ptr that uses the same backing storage as this XrSpatialEntityAnchorCreateInfoBD.Ptr, but with the new size.
@NotNull XrSpatialEntityComponentDataBaseHeaderBD.Ptr	XrSpatialEntityComponentDataBaseHeaderBD.Ptr.reinterpret(long newSize)	Assume the XrSpatialEntityComponentDataBaseHeaderBD.Ptr is capable of holding at least newSize structures, create a new view XrSpatialEntityComponentDataBaseHeaderBD.Ptr that uses the same backing storage as this XrSpatialEntityComponentDataBaseHeaderBD.Ptr, but with the new size.
@NotNull XrSpatialEntityComponentDataBoundingBox2DBD.Ptr	XrSpatialEntityComponentDataBoundingBox2DBD.Ptr.reinterpret(long newSize)	Assume the XrSpatialEntityComponentDataBoundingBox2DBD.Ptr is capable of holding at least newSize structures, create a new view XrSpatialEntityComponentDataBoundingBox2DBD.Ptr that uses the same backing storage as this XrSpatialEntityComponentDataBoundingBox2DBD.Ptr, but with the new size.
@NotNull XrSpatialEntityComponentDataBoundingBox3DBD.Ptr	XrSpatialEntityComponentDataBoundingBox3DBD.Ptr.reinterpret(long newSize)	Assume the XrSpatialEntityComponentDataBoundingBox3DBD.Ptr is capable of holding at least newSize structures, create a new view XrSpatialEntityComponentDataBoundingBox3DBD.Ptr that uses the same backing storage as this XrSpatialEntityComponentDataBoundingBox3DBD.Ptr, but with the new size.
@NotNull XrSpatialEntityComponentDataLocationBD.Ptr	XrSpatialEntityComponentDataLocationBD.Ptr.reinterpret(long newSize)	Assume the XrSpatialEntityComponentDataLocationBD.Ptr is capable of holding at least newSize structures, create a new view XrSpatialEntityComponentDataLocationBD.Ptr that uses the same backing storage as this XrSpatialEntityComponentDataLocationBD.Ptr, but with the new size.
@NotNull XrSpatialEntityComponentDataPlaneOrientationBD.Ptr	XrSpatialEntityComponentDataPlaneOrientationBD.Ptr.reinterpret(long newSize)	Assume the XrSpatialEntityComponentDataPlaneOrientationBD.Ptr is capable of holding at least newSize structures, create a new view XrSpatialEntityComponentDataPlaneOrientationBD.Ptr that uses the same backing storage as this XrSpatialEntityComponentDataPlaneOrientationBD.Ptr, but with the new size.
@NotNull XrSpatialEntityComponentDataPolygonBD.Ptr	XrSpatialEntityComponentDataPolygonBD.Ptr.reinterpret(long newSize)	Assume the XrSpatialEntityComponentDataPolygonBD.Ptr is capable of holding at least newSize structures, create a new view XrSpatialEntityComponentDataPolygonBD.Ptr that uses the same backing storage as this XrSpatialEntityComponentDataPolygonBD.Ptr, but with the new size.
@NotNull XrSpatialEntityComponentDataSemanticBD.Ptr	XrSpatialEntityComponentDataSemanticBD.Ptr.reinterpret(long newSize)	Assume the XrSpatialEntityComponentDataSemanticBD.Ptr is capable of holding at least newSize structures, create a new view XrSpatialEntityComponentDataSemanticBD.Ptr that uses the same backing storage as this XrSpatialEntityComponentDataSemanticBD.Ptr, but with the new size.
@NotNull XrSpatialEntityComponentDataTriangleMeshBD.Ptr	XrSpatialEntityComponentDataTriangleMeshBD.Ptr.reinterpret(long newSize)	Assume the XrSpatialEntityComponentDataTriangleMeshBD.Ptr is capable of holding at least newSize structures, create a new view XrSpatialEntityComponentDataTriangleMeshBD.Ptr that uses the same backing storage as this XrSpatialEntityComponentDataTriangleMeshBD.Ptr, but with the new size.
@NotNull XrSpatialEntityComponentGetInfoBD.Ptr	XrSpatialEntityComponentGetInfoBD.Ptr.reinterpret(long newSize)	Assume the XrSpatialEntityComponentGetInfoBD.Ptr is capable of holding at least newSize structures, create a new view XrSpatialEntityComponentGetInfoBD.Ptr that uses the same backing storage as this XrSpatialEntityComponentGetInfoBD.Ptr, but with the new size.
@NotNull XrSpatialEntityFromIdCreateInfoEXT.Ptr	XrSpatialEntityFromIdCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the XrSpatialEntityFromIdCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view XrSpatialEntityFromIdCreateInfoEXT.Ptr that uses the same backing storage as this XrSpatialEntityFromIdCreateInfoEXT.Ptr, but with the new size.
@NotNull XrSpatialEntityLocationGetInfoBD.Ptr	XrSpatialEntityLocationGetInfoBD.Ptr.reinterpret(long newSize)	Assume the XrSpatialEntityLocationGetInfoBD.Ptr is capable of holding at least newSize structures, create a new view XrSpatialEntityLocationGetInfoBD.Ptr that uses the same backing storage as this XrSpatialEntityLocationGetInfoBD.Ptr, but with the new size.
@NotNull XrSpatialEntityPersistInfoEXT.Ptr	XrSpatialEntityPersistInfoEXT.Ptr.reinterpret(long newSize)	Assume the XrSpatialEntityPersistInfoEXT.Ptr is capable of holding at least newSize structures, create a new view XrSpatialEntityPersistInfoEXT.Ptr that uses the same backing storage as this XrSpatialEntityPersistInfoEXT.Ptr, but with the new size.
@NotNull XrSpatialEntityStateBD.Ptr	XrSpatialEntityStateBD.Ptr.reinterpret(long newSize)	Assume the XrSpatialEntityStateBD.Ptr is capable of holding at least newSize structures, create a new view XrSpatialEntityStateBD.Ptr that uses the same backing storage as this XrSpatialEntityStateBD.Ptr, but with the new size.
@NotNull XrSpatialEntityUnpersistInfoEXT.Ptr	XrSpatialEntityUnpersistInfoEXT.Ptr.reinterpret(long newSize)	Assume the XrSpatialEntityUnpersistInfoEXT.Ptr is capable of holding at least newSize structures, create a new view XrSpatialEntityUnpersistInfoEXT.Ptr that uses the same backing storage as this XrSpatialEntityUnpersistInfoEXT.Ptr, but with the new size.
@NotNull XrSpatialFilterTrackingStateEXT.Ptr	XrSpatialFilterTrackingStateEXT.Ptr.reinterpret(long newSize)	Assume the XrSpatialFilterTrackingStateEXT.Ptr is capable of holding at least newSize structures, create a new view XrSpatialFilterTrackingStateEXT.Ptr that uses the same backing storage as this XrSpatialFilterTrackingStateEXT.Ptr, but with the new size.
@NotNull XrSpatialGraphNodeBindingPropertiesGetInfoMSFT.Ptr	XrSpatialGraphNodeBindingPropertiesGetInfoMSFT.Ptr.reinterpret(long newSize)	Assume the XrSpatialGraphNodeBindingPropertiesGetInfoMSFT.Ptr is capable of holding at least newSize structures, create a new view XrSpatialGraphNodeBindingPropertiesGetInfoMSFT.Ptr that uses the same backing storage as this XrSpatialGraphNodeBindingPropertiesGetInfoMSFT.Ptr, but with the new size.
@NotNull XrSpatialGraphNodeBindingPropertiesMSFT.Ptr	XrSpatialGraphNodeBindingPropertiesMSFT.Ptr.reinterpret(long newSize)	Assume the XrSpatialGraphNodeBindingPropertiesMSFT.Ptr is capable of holding at least newSize structures, create a new view XrSpatialGraphNodeBindingPropertiesMSFT.Ptr that uses the same backing storage as this XrSpatialGraphNodeBindingPropertiesMSFT.Ptr, but with the new size.
@NotNull XrSpatialGraphNodeSpaceCreateInfoMSFT.Ptr	XrSpatialGraphNodeSpaceCreateInfoMSFT.Ptr.reinterpret(long newSize)	Assume the XrSpatialGraphNodeSpaceCreateInfoMSFT.Ptr is capable of holding at least newSize structures, create a new view XrSpatialGraphNodeSpaceCreateInfoMSFT.Ptr that uses the same backing storage as this XrSpatialGraphNodeSpaceCreateInfoMSFT.Ptr, but with the new size.
@NotNull XrSpatialGraphStaticNodeBindingCreateInfoMSFT.Ptr	XrSpatialGraphStaticNodeBindingCreateInfoMSFT.Ptr.reinterpret(long newSize)	Assume the XrSpatialGraphStaticNodeBindingCreateInfoMSFT.Ptr is capable of holding at least newSize structures, create a new view XrSpatialGraphStaticNodeBindingCreateInfoMSFT.Ptr that uses the same backing storage as this XrSpatialGraphStaticNodeBindingCreateInfoMSFT.Ptr, but with the new size.
@NotNull XrSpatialMarkerDataEXT.Ptr	XrSpatialMarkerDataEXT.Ptr.reinterpret(long newSize)	Assume the XrSpatialMarkerDataEXT.Ptr is capable of holding at least newSize structures, create a new view XrSpatialMarkerDataEXT.Ptr that uses the same backing storage as this XrSpatialMarkerDataEXT.Ptr, but with the new size.
@NotNull XrSpatialMarkerSizeEXT.Ptr	XrSpatialMarkerSizeEXT.Ptr.reinterpret(long newSize)	Assume the XrSpatialMarkerSizeEXT.Ptr is capable of holding at least newSize structures, create a new view XrSpatialMarkerSizeEXT.Ptr that uses the same backing storage as this XrSpatialMarkerSizeEXT.Ptr, but with the new size.
@NotNull XrSpatialMarkerStaticOptimizationEXT.Ptr	XrSpatialMarkerStaticOptimizationEXT.Ptr.reinterpret(long newSize)	Assume the XrSpatialMarkerStaticOptimizationEXT.Ptr is capable of holding at least newSize structures, create a new view XrSpatialMarkerStaticOptimizationEXT.Ptr that uses the same backing storage as this XrSpatialMarkerStaticOptimizationEXT.Ptr, but with the new size.
@NotNull XrSpatialMeshDataEXT.Ptr	XrSpatialMeshDataEXT.Ptr.reinterpret(long newSize)	Assume the XrSpatialMeshDataEXT.Ptr is capable of holding at least newSize structures, create a new view XrSpatialMeshDataEXT.Ptr that uses the same backing storage as this XrSpatialMeshDataEXT.Ptr, but with the new size.
@NotNull XrSpatialPersistenceContextCreateInfoEXT.Ptr	XrSpatialPersistenceContextCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the XrSpatialPersistenceContextCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view XrSpatialPersistenceContextCreateInfoEXT.Ptr that uses the same backing storage as this XrSpatialPersistenceContextCreateInfoEXT.Ptr, but with the new size.
@NotNull XrSpatialPersistenceDataEXT.Ptr	XrSpatialPersistenceDataEXT.Ptr.reinterpret(long newSize)	Assume the XrSpatialPersistenceDataEXT.Ptr is capable of holding at least newSize structures, create a new view XrSpatialPersistenceDataEXT.Ptr that uses the same backing storage as this XrSpatialPersistenceDataEXT.Ptr, but with the new size.
@NotNull XrSpatialPolygon2DDataEXT.Ptr	XrSpatialPolygon2DDataEXT.Ptr.reinterpret(long newSize)	Assume the XrSpatialPolygon2DDataEXT.Ptr is capable of holding at least newSize structures, create a new view XrSpatialPolygon2DDataEXT.Ptr that uses the same backing storage as this XrSpatialPolygon2DDataEXT.Ptr, but with the new size.
@NotNull XrSpatialUpdateSnapshotCreateInfoEXT.Ptr	XrSpatialUpdateSnapshotCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the XrSpatialUpdateSnapshotCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view XrSpatialUpdateSnapshotCreateInfoEXT.Ptr that uses the same backing storage as this XrSpatialUpdateSnapshotCreateInfoEXT.Ptr, but with the new size.
@NotNull XrSpheref.Ptr	XrSpheref.Ptr.reinterpret(long newSize)	Assume the XrSpheref.Ptr is capable of holding at least newSize structures, create a new view XrSpheref.Ptr that uses the same backing storage as this XrSpheref.Ptr, but with the new size.
@NotNull XrSpherefKHR.Ptr	XrSpherefKHR.Ptr.reinterpret(long newSize)	Assume the XrSpherefKHR.Ptr is capable of holding at least newSize structures, create a new view XrSpherefKHR.Ptr that uses the same backing storage as this XrSpherefKHR.Ptr, but with the new size.
@NotNull XrSwapchainCreateInfo.Ptr	XrSwapchainCreateInfo.Ptr.reinterpret(long newSize)	Assume the XrSwapchainCreateInfo.Ptr is capable of holding at least newSize structures, create a new view XrSwapchainCreateInfo.Ptr that uses the same backing storage as this XrSwapchainCreateInfo.Ptr, but with the new size.
@NotNull XrSwapchainCreateInfoFoveationFB.Ptr	XrSwapchainCreateInfoFoveationFB.Ptr.reinterpret(long newSize)	Assume the XrSwapchainCreateInfoFoveationFB.Ptr is capable of holding at least newSize structures, create a new view XrSwapchainCreateInfoFoveationFB.Ptr that uses the same backing storage as this XrSwapchainCreateInfoFoveationFB.Ptr, but with the new size.
@NotNull XrSwapchainImageAcquireInfo.Ptr	XrSwapchainImageAcquireInfo.Ptr.reinterpret(long newSize)	Assume the XrSwapchainImageAcquireInfo.Ptr is capable of holding at least newSize structures, create a new view XrSwapchainImageAcquireInfo.Ptr that uses the same backing storage as this XrSwapchainImageAcquireInfo.Ptr, but with the new size.
@NotNull XrSwapchainImageBaseHeader.Ptr	XrSwapchainImageBaseHeader.Ptr.reinterpret(long newSize)	Assume the XrSwapchainImageBaseHeader.Ptr is capable of holding at least newSize structures, create a new view XrSwapchainImageBaseHeader.Ptr that uses the same backing storage as this XrSwapchainImageBaseHeader.Ptr, but with the new size.
@NotNull XrSwapchainImageD3D11KHR.Ptr	XrSwapchainImageD3D11KHR.Ptr.reinterpret(long newSize)	Assume the XrSwapchainImageD3D11KHR.Ptr is capable of holding at least newSize structures, create a new view XrSwapchainImageD3D11KHR.Ptr that uses the same backing storage as this XrSwapchainImageD3D11KHR.Ptr, but with the new size.
@NotNull XrSwapchainImageD3D12KHR.Ptr	XrSwapchainImageD3D12KHR.Ptr.reinterpret(long newSize)	Assume the XrSwapchainImageD3D12KHR.Ptr is capable of holding at least newSize structures, create a new view XrSwapchainImageD3D12KHR.Ptr that uses the same backing storage as this XrSwapchainImageD3D12KHR.Ptr, but with the new size.
@NotNull XrSwapchainImageFoveationVulkanFB.Ptr	XrSwapchainImageFoveationVulkanFB.Ptr.reinterpret(long newSize)	Assume the XrSwapchainImageFoveationVulkanFB.Ptr is capable of holding at least newSize structures, create a new view XrSwapchainImageFoveationVulkanFB.Ptr that uses the same backing storage as this XrSwapchainImageFoveationVulkanFB.Ptr, but with the new size.
@NotNull XrSwapchainImageMetalKHR.Ptr	XrSwapchainImageMetalKHR.Ptr.reinterpret(long newSize)	Assume the XrSwapchainImageMetalKHR.Ptr is capable of holding at least newSize structures, create a new view XrSwapchainImageMetalKHR.Ptr that uses the same backing storage as this XrSwapchainImageMetalKHR.Ptr, but with the new size.
@NotNull XrSwapchainImageOpenGLESKHR.Ptr	XrSwapchainImageOpenGLESKHR.Ptr.reinterpret(long newSize)	Assume the XrSwapchainImageOpenGLESKHR.Ptr is capable of holding at least newSize structures, create a new view XrSwapchainImageOpenGLESKHR.Ptr that uses the same backing storage as this XrSwapchainImageOpenGLESKHR.Ptr, but with the new size.
@NotNull XrSwapchainImageOpenGLKHR.Ptr	XrSwapchainImageOpenGLKHR.Ptr.reinterpret(long newSize)	Assume the XrSwapchainImageOpenGLKHR.Ptr is capable of holding at least newSize structures, create a new view XrSwapchainImageOpenGLKHR.Ptr that uses the same backing storage as this XrSwapchainImageOpenGLKHR.Ptr, but with the new size.
@NotNull XrSwapchainImageReleaseInfo.Ptr	XrSwapchainImageReleaseInfo.Ptr.reinterpret(long newSize)	Assume the XrSwapchainImageReleaseInfo.Ptr is capable of holding at least newSize structures, create a new view XrSwapchainImageReleaseInfo.Ptr that uses the same backing storage as this XrSwapchainImageReleaseInfo.Ptr, but with the new size.
@NotNull XrSwapchainImageVulkan2KHR.Ptr	XrSwapchainImageVulkan2KHR.Ptr.reinterpret(long newSize)	Assume the XrSwapchainImageVulkan2KHR.Ptr is capable of holding at least newSize structures, create a new view XrSwapchainImageVulkan2KHR.Ptr that uses the same backing storage as this XrSwapchainImageVulkan2KHR.Ptr, but with the new size.
@NotNull XrSwapchainImageVulkanKHR.Ptr	XrSwapchainImageVulkanKHR.Ptr.reinterpret(long newSize)	Assume the XrSwapchainImageVulkanKHR.Ptr is capable of holding at least newSize structures, create a new view XrSwapchainImageVulkanKHR.Ptr that uses the same backing storage as this XrSwapchainImageVulkanKHR.Ptr, but with the new size.
@NotNull XrSwapchainImageWaitInfo.Ptr	XrSwapchainImageWaitInfo.Ptr.reinterpret(long newSize)	Assume the XrSwapchainImageWaitInfo.Ptr is capable of holding at least newSize structures, create a new view XrSwapchainImageWaitInfo.Ptr that uses the same backing storage as this XrSwapchainImageWaitInfo.Ptr, but with the new size.
@NotNull XrSwapchainStateAndroidSurfaceDimensionsFB.Ptr	XrSwapchainStateAndroidSurfaceDimensionsFB.Ptr.reinterpret(long newSize)	Assume the XrSwapchainStateAndroidSurfaceDimensionsFB.Ptr is capable of holding at least newSize structures, create a new view XrSwapchainStateAndroidSurfaceDimensionsFB.Ptr that uses the same backing storage as this XrSwapchainStateAndroidSurfaceDimensionsFB.Ptr, but with the new size.
@NotNull XrSwapchainStateBaseHeaderFB.Ptr	XrSwapchainStateBaseHeaderFB.Ptr.reinterpret(long newSize)	Assume the XrSwapchainStateBaseHeaderFB.Ptr is capable of holding at least newSize structures, create a new view XrSwapchainStateBaseHeaderFB.Ptr that uses the same backing storage as this XrSwapchainStateBaseHeaderFB.Ptr, but with the new size.
@NotNull XrSwapchainStateFoveationFB.Ptr	XrSwapchainStateFoveationFB.Ptr.reinterpret(long newSize)	Assume the XrSwapchainStateFoveationFB.Ptr is capable of holding at least newSize structures, create a new view XrSwapchainStateFoveationFB.Ptr that uses the same backing storage as this XrSwapchainStateFoveationFB.Ptr, but with the new size.
@NotNull XrSwapchainStateSamplerOpenGLESFB.Ptr	XrSwapchainStateSamplerOpenGLESFB.Ptr.reinterpret(long newSize)	Assume the XrSwapchainStateSamplerOpenGLESFB.Ptr is capable of holding at least newSize structures, create a new view XrSwapchainStateSamplerOpenGLESFB.Ptr that uses the same backing storage as this XrSwapchainStateSamplerOpenGLESFB.Ptr, but with the new size.
@NotNull XrSwapchainStateSamplerVulkanFB.Ptr	XrSwapchainStateSamplerVulkanFB.Ptr.reinterpret(long newSize)	Assume the XrSwapchainStateSamplerVulkanFB.Ptr is capable of holding at least newSize structures, create a new view XrSwapchainStateSamplerVulkanFB.Ptr that uses the same backing storage as this XrSwapchainStateSamplerVulkanFB.Ptr, but with the new size.
@NotNull XrSwapchainSubImage.Ptr	XrSwapchainSubImage.Ptr.reinterpret(long newSize)	Assume the XrSwapchainSubImage.Ptr is capable of holding at least newSize structures, create a new view XrSwapchainSubImage.Ptr that uses the same backing storage as this XrSwapchainSubImage.Ptr, but with the new size.
@NotNull XrSystemAnchorPropertiesHTC.Ptr	XrSystemAnchorPropertiesHTC.Ptr.reinterpret(long newSize)	Assume the XrSystemAnchorPropertiesHTC.Ptr is capable of holding at least newSize structures, create a new view XrSystemAnchorPropertiesHTC.Ptr that uses the same backing storage as this XrSystemAnchorPropertiesHTC.Ptr, but with the new size.
@NotNull XrSystemBodyTrackingPropertiesBD.Ptr	XrSystemBodyTrackingPropertiesBD.Ptr.reinterpret(long newSize)	Assume the XrSystemBodyTrackingPropertiesBD.Ptr is capable of holding at least newSize structures, create a new view XrSystemBodyTrackingPropertiesBD.Ptr that uses the same backing storage as this XrSystemBodyTrackingPropertiesBD.Ptr, but with the new size.
@NotNull XrSystemBodyTrackingPropertiesFB.Ptr	XrSystemBodyTrackingPropertiesFB.Ptr.reinterpret(long newSize)	Assume the XrSystemBodyTrackingPropertiesFB.Ptr is capable of holding at least newSize structures, create a new view XrSystemBodyTrackingPropertiesFB.Ptr that uses the same backing storage as this XrSystemBodyTrackingPropertiesFB.Ptr, but with the new size.
@NotNull XrSystemBodyTrackingPropertiesHTC.Ptr	XrSystemBodyTrackingPropertiesHTC.Ptr.reinterpret(long newSize)	Assume the XrSystemBodyTrackingPropertiesHTC.Ptr is capable of holding at least newSize structures, create a new view XrSystemBodyTrackingPropertiesHTC.Ptr that uses the same backing storage as this XrSystemBodyTrackingPropertiesHTC.Ptr, but with the new size.
@NotNull XrSystemColocationDiscoveryPropertiesMETA.Ptr	XrSystemColocationDiscoveryPropertiesMETA.Ptr.reinterpret(long newSize)	Assume the XrSystemColocationDiscoveryPropertiesMETA.Ptr is capable of holding at least newSize structures, create a new view XrSystemColocationDiscoveryPropertiesMETA.Ptr that uses the same backing storage as this XrSystemColocationDiscoveryPropertiesMETA.Ptr, but with the new size.
@NotNull XrSystemColorSpacePropertiesFB.Ptr	XrSystemColorSpacePropertiesFB.Ptr.reinterpret(long newSize)	Assume the XrSystemColorSpacePropertiesFB.Ptr is capable of holding at least newSize structures, create a new view XrSystemColorSpacePropertiesFB.Ptr that uses the same backing storage as this XrSystemColorSpacePropertiesFB.Ptr, but with the new size.
@NotNull XrSystemEnvironmentDepthPropertiesMETA.Ptr	XrSystemEnvironmentDepthPropertiesMETA.Ptr.reinterpret(long newSize)	Assume the XrSystemEnvironmentDepthPropertiesMETA.Ptr is capable of holding at least newSize structures, create a new view XrSystemEnvironmentDepthPropertiesMETA.Ptr that uses the same backing storage as this XrSystemEnvironmentDepthPropertiesMETA.Ptr, but with the new size.
@NotNull XrSystemEyeGazeInteractionPropertiesEXT.Ptr	XrSystemEyeGazeInteractionPropertiesEXT.Ptr.reinterpret(long newSize)	Assume the XrSystemEyeGazeInteractionPropertiesEXT.Ptr is capable of holding at least newSize structures, create a new view XrSystemEyeGazeInteractionPropertiesEXT.Ptr that uses the same backing storage as this XrSystemEyeGazeInteractionPropertiesEXT.Ptr, but with the new size.
@NotNull XrSystemEyeTrackingPropertiesFB.Ptr	XrSystemEyeTrackingPropertiesFB.Ptr.reinterpret(long newSize)	Assume the XrSystemEyeTrackingPropertiesFB.Ptr is capable of holding at least newSize structures, create a new view XrSystemEyeTrackingPropertiesFB.Ptr that uses the same backing storage as this XrSystemEyeTrackingPropertiesFB.Ptr, but with the new size.
@NotNull XrSystemFaceTrackingProperties2FB.Ptr	XrSystemFaceTrackingProperties2FB.Ptr.reinterpret(long newSize)	Assume the XrSystemFaceTrackingProperties2FB.Ptr is capable of holding at least newSize structures, create a new view XrSystemFaceTrackingProperties2FB.Ptr that uses the same backing storage as this XrSystemFaceTrackingProperties2FB.Ptr, but with the new size.
@NotNull XrSystemFaceTrackingPropertiesFB.Ptr	XrSystemFaceTrackingPropertiesFB.Ptr.reinterpret(long newSize)	Assume the XrSystemFaceTrackingPropertiesFB.Ptr is capable of holding at least newSize structures, create a new view XrSystemFaceTrackingPropertiesFB.Ptr that uses the same backing storage as this XrSystemFaceTrackingPropertiesFB.Ptr, but with the new size.
@NotNull XrSystemFacialExpressionPropertiesML.Ptr	XrSystemFacialExpressionPropertiesML.Ptr.reinterpret(long newSize)	Assume the XrSystemFacialExpressionPropertiesML.Ptr is capable of holding at least newSize structures, create a new view XrSystemFacialExpressionPropertiesML.Ptr that uses the same backing storage as this XrSystemFacialExpressionPropertiesML.Ptr, but with the new size.
@NotNull XrSystemFacialTrackingPropertiesHTC.Ptr	XrSystemFacialTrackingPropertiesHTC.Ptr.reinterpret(long newSize)	Assume the XrSystemFacialTrackingPropertiesHTC.Ptr is capable of holding at least newSize structures, create a new view XrSystemFacialTrackingPropertiesHTC.Ptr that uses the same backing storage as this XrSystemFacialTrackingPropertiesHTC.Ptr, but with the new size.
@NotNull XrSystemForceFeedbackCurlPropertiesMNDX.Ptr	XrSystemForceFeedbackCurlPropertiesMNDX.Ptr.reinterpret(long newSize)	Assume the XrSystemForceFeedbackCurlPropertiesMNDX.Ptr is capable of holding at least newSize structures, create a new view XrSystemForceFeedbackCurlPropertiesMNDX.Ptr that uses the same backing storage as this XrSystemForceFeedbackCurlPropertiesMNDX.Ptr, but with the new size.
@NotNull XrSystemFoveatedRenderingPropertiesVARJO.Ptr	XrSystemFoveatedRenderingPropertiesVARJO.Ptr.reinterpret(long newSize)	Assume the XrSystemFoveatedRenderingPropertiesVARJO.Ptr is capable of holding at least newSize structures, create a new view XrSystemFoveatedRenderingPropertiesVARJO.Ptr that uses the same backing storage as this XrSystemFoveatedRenderingPropertiesVARJO.Ptr, but with the new size.
@NotNull XrSystemFoveationEyeTrackedPropertiesMETA.Ptr	XrSystemFoveationEyeTrackedPropertiesMETA.Ptr.reinterpret(long newSize)	Assume the XrSystemFoveationEyeTrackedPropertiesMETA.Ptr is capable of holding at least newSize structures, create a new view XrSystemFoveationEyeTrackedPropertiesMETA.Ptr that uses the same backing storage as this XrSystemFoveationEyeTrackedPropertiesMETA.Ptr, but with the new size.
@NotNull XrSystemGetInfo.Ptr	XrSystemGetInfo.Ptr.reinterpret(long newSize)	Assume the XrSystemGetInfo.Ptr is capable of holding at least newSize structures, create a new view XrSystemGetInfo.Ptr that uses the same backing storage as this XrSystemGetInfo.Ptr, but with the new size.
@NotNull XrSystemGraphicsProperties.Ptr	XrSystemGraphicsProperties.Ptr.reinterpret(long newSize)	Assume the XrSystemGraphicsProperties.Ptr is capable of holding at least newSize structures, create a new view XrSystemGraphicsProperties.Ptr that uses the same backing storage as this XrSystemGraphicsProperties.Ptr, but with the new size.
@NotNull XrSystemHandTrackingMeshPropertiesMSFT.Ptr	XrSystemHandTrackingMeshPropertiesMSFT.Ptr.reinterpret(long newSize)	Assume the XrSystemHandTrackingMeshPropertiesMSFT.Ptr is capable of holding at least newSize structures, create a new view XrSystemHandTrackingMeshPropertiesMSFT.Ptr that uses the same backing storage as this XrSystemHandTrackingMeshPropertiesMSFT.Ptr, but with the new size.
@NotNull XrSystemHandTrackingPropertiesEXT.Ptr	XrSystemHandTrackingPropertiesEXT.Ptr.reinterpret(long newSize)	Assume the XrSystemHandTrackingPropertiesEXT.Ptr is capable of holding at least newSize structures, create a new view XrSystemHandTrackingPropertiesEXT.Ptr that uses the same backing storage as this XrSystemHandTrackingPropertiesEXT.Ptr, but with the new size.
@NotNull XrSystemHeadsetIdPropertiesMETA.Ptr	XrSystemHeadsetIdPropertiesMETA.Ptr.reinterpret(long newSize)	Assume the XrSystemHeadsetIdPropertiesMETA.Ptr is capable of holding at least newSize structures, create a new view XrSystemHeadsetIdPropertiesMETA.Ptr that uses the same backing storage as this XrSystemHeadsetIdPropertiesMETA.Ptr, but with the new size.
@NotNull XrSystemKeyboardTrackingPropertiesFB.Ptr	XrSystemKeyboardTrackingPropertiesFB.Ptr.reinterpret(long newSize)	Assume the XrSystemKeyboardTrackingPropertiesFB.Ptr is capable of holding at least newSize structures, create a new view XrSystemKeyboardTrackingPropertiesFB.Ptr that uses the same backing storage as this XrSystemKeyboardTrackingPropertiesFB.Ptr, but with the new size.
@NotNull XrSystemMarkerTrackingPropertiesVARJO.Ptr	XrSystemMarkerTrackingPropertiesVARJO.Ptr.reinterpret(long newSize)	Assume the XrSystemMarkerTrackingPropertiesVARJO.Ptr is capable of holding at least newSize structures, create a new view XrSystemMarkerTrackingPropertiesVARJO.Ptr that uses the same backing storage as this XrSystemMarkerTrackingPropertiesVARJO.Ptr, but with the new size.
@NotNull XrSystemMarkerUnderstandingPropertiesML.Ptr	XrSystemMarkerUnderstandingPropertiesML.Ptr.reinterpret(long newSize)	Assume the XrSystemMarkerUnderstandingPropertiesML.Ptr is capable of holding at least newSize structures, create a new view XrSystemMarkerUnderstandingPropertiesML.Ptr that uses the same backing storage as this XrSystemMarkerUnderstandingPropertiesML.Ptr, but with the new size.
@NotNull XrSystemNotificationsSetInfoML.Ptr	XrSystemNotificationsSetInfoML.Ptr.reinterpret(long newSize)	Assume the XrSystemNotificationsSetInfoML.Ptr is capable of holding at least newSize structures, create a new view XrSystemNotificationsSetInfoML.Ptr that uses the same backing storage as this XrSystemNotificationsSetInfoML.Ptr, but with the new size.
@NotNull XrSystemPassthroughColorLutPropertiesMETA.Ptr	XrSystemPassthroughColorLutPropertiesMETA.Ptr.reinterpret(long newSize)	Assume the XrSystemPassthroughColorLutPropertiesMETA.Ptr is capable of holding at least newSize structures, create a new view XrSystemPassthroughColorLutPropertiesMETA.Ptr that uses the same backing storage as this XrSystemPassthroughColorLutPropertiesMETA.Ptr, but with the new size.
@NotNull XrSystemPassthroughProperties2FB.Ptr	XrSystemPassthroughProperties2FB.Ptr.reinterpret(long newSize)	Assume the XrSystemPassthroughProperties2FB.Ptr is capable of holding at least newSize structures, create a new view XrSystemPassthroughProperties2FB.Ptr that uses the same backing storage as this XrSystemPassthroughProperties2FB.Ptr, but with the new size.
@NotNull XrSystemPassthroughPropertiesFB.Ptr	XrSystemPassthroughPropertiesFB.Ptr.reinterpret(long newSize)	Assume the XrSystemPassthroughPropertiesFB.Ptr is capable of holding at least newSize structures, create a new view XrSystemPassthroughPropertiesFB.Ptr that uses the same backing storage as this XrSystemPassthroughPropertiesFB.Ptr, but with the new size.
@NotNull XrSystemPlaneDetectionPropertiesEXT.Ptr	XrSystemPlaneDetectionPropertiesEXT.Ptr.reinterpret(long newSize)	Assume the XrSystemPlaneDetectionPropertiesEXT.Ptr is capable of holding at least newSize structures, create a new view XrSystemPlaneDetectionPropertiesEXT.Ptr that uses the same backing storage as this XrSystemPlaneDetectionPropertiesEXT.Ptr, but with the new size.
@NotNull XrSystemProperties.Ptr	XrSystemProperties.Ptr.reinterpret(long newSize)	Assume the XrSystemProperties.Ptr is capable of holding at least newSize structures, create a new view XrSystemProperties.Ptr that uses the same backing storage as this XrSystemProperties.Ptr, but with the new size.
@NotNull XrSystemPropertiesBodyTrackingFullBodyMETA.Ptr	XrSystemPropertiesBodyTrackingFullBodyMETA.Ptr.reinterpret(long newSize)	Assume the XrSystemPropertiesBodyTrackingFullBodyMETA.Ptr is capable of holding at least newSize structures, create a new view XrSystemPropertiesBodyTrackingFullBodyMETA.Ptr that uses the same backing storage as this XrSystemPropertiesBodyTrackingFullBodyMETA.Ptr, but with the new size.
@NotNull XrSystemRenderModelPropertiesFB.Ptr	XrSystemRenderModelPropertiesFB.Ptr.reinterpret(long newSize)	Assume the XrSystemRenderModelPropertiesFB.Ptr is capable of holding at least newSize structures, create a new view XrSystemRenderModelPropertiesFB.Ptr that uses the same backing storage as this XrSystemRenderModelPropertiesFB.Ptr, but with the new size.
@NotNull XrSystemSimultaneousHandsAndControllersPropertiesMETA.Ptr	XrSystemSimultaneousHandsAndControllersPropertiesMETA.Ptr.reinterpret(long newSize)	Assume the XrSystemSimultaneousHandsAndControllersPropertiesMETA.Ptr is capable of holding at least newSize structures, create a new view XrSystemSimultaneousHandsAndControllersPropertiesMETA.Ptr that uses the same backing storage as this XrSystemSimultaneousHandsAndControllersPropertiesMETA.Ptr, but with the new size.
@NotNull XrSystemSpaceWarpPropertiesFB.Ptr	XrSystemSpaceWarpPropertiesFB.Ptr.reinterpret(long newSize)	Assume the XrSystemSpaceWarpPropertiesFB.Ptr is capable of holding at least newSize structures, create a new view XrSystemSpaceWarpPropertiesFB.Ptr that uses the same backing storage as this XrSystemSpaceWarpPropertiesFB.Ptr, but with the new size.
@NotNull XrSystemSpatialAnchorPropertiesBD.Ptr	XrSystemSpatialAnchorPropertiesBD.Ptr.reinterpret(long newSize)	Assume the XrSystemSpatialAnchorPropertiesBD.Ptr is capable of holding at least newSize structures, create a new view XrSystemSpatialAnchorPropertiesBD.Ptr that uses the same backing storage as this XrSystemSpatialAnchorPropertiesBD.Ptr, but with the new size.
@NotNull XrSystemSpatialAnchorSharingPropertiesBD.Ptr	XrSystemSpatialAnchorSharingPropertiesBD.Ptr.reinterpret(long newSize)	Assume the XrSystemSpatialAnchorSharingPropertiesBD.Ptr is capable of holding at least newSize structures, create a new view XrSystemSpatialAnchorSharingPropertiesBD.Ptr that uses the same backing storage as this XrSystemSpatialAnchorSharingPropertiesBD.Ptr, but with the new size.
@NotNull XrSystemSpatialEntityGroupSharingPropertiesMETA.Ptr	XrSystemSpatialEntityGroupSharingPropertiesMETA.Ptr.reinterpret(long newSize)	Assume the XrSystemSpatialEntityGroupSharingPropertiesMETA.Ptr is capable of holding at least newSize structures, create a new view XrSystemSpatialEntityGroupSharingPropertiesMETA.Ptr that uses the same backing storage as this XrSystemSpatialEntityGroupSharingPropertiesMETA.Ptr, but with the new size.
@NotNull XrSystemSpatialEntityPropertiesFB.Ptr	XrSystemSpatialEntityPropertiesFB.Ptr.reinterpret(long newSize)	Assume the XrSystemSpatialEntityPropertiesFB.Ptr is capable of holding at least newSize structures, create a new view XrSystemSpatialEntityPropertiesFB.Ptr that uses the same backing storage as this XrSystemSpatialEntityPropertiesFB.Ptr, but with the new size.
@NotNull XrSystemSpatialEntitySharingPropertiesMETA.Ptr	XrSystemSpatialEntitySharingPropertiesMETA.Ptr.reinterpret(long newSize)	Assume the XrSystemSpatialEntitySharingPropertiesMETA.Ptr is capable of holding at least newSize structures, create a new view XrSystemSpatialEntitySharingPropertiesMETA.Ptr that uses the same backing storage as this XrSystemSpatialEntitySharingPropertiesMETA.Ptr, but with the new size.
@NotNull XrSystemSpatialMeshPropertiesBD.Ptr	XrSystemSpatialMeshPropertiesBD.Ptr.reinterpret(long newSize)	Assume the XrSystemSpatialMeshPropertiesBD.Ptr is capable of holding at least newSize structures, create a new view XrSystemSpatialMeshPropertiesBD.Ptr that uses the same backing storage as this XrSystemSpatialMeshPropertiesBD.Ptr, but with the new size.
@NotNull XrSystemSpatialPlanePropertiesBD.Ptr	XrSystemSpatialPlanePropertiesBD.Ptr.reinterpret(long newSize)	Assume the XrSystemSpatialPlanePropertiesBD.Ptr is capable of holding at least newSize structures, create a new view XrSystemSpatialPlanePropertiesBD.Ptr that uses the same backing storage as this XrSystemSpatialPlanePropertiesBD.Ptr, but with the new size.
@NotNull XrSystemSpatialScenePropertiesBD.Ptr	XrSystemSpatialScenePropertiesBD.Ptr.reinterpret(long newSize)	Assume the XrSystemSpatialScenePropertiesBD.Ptr is capable of holding at least newSize structures, create a new view XrSystemSpatialScenePropertiesBD.Ptr that uses the same backing storage as this XrSystemSpatialScenePropertiesBD.Ptr, but with the new size.
@NotNull XrSystemSpatialSensingPropertiesBD.Ptr	XrSystemSpatialSensingPropertiesBD.Ptr.reinterpret(long newSize)	Assume the XrSystemSpatialSensingPropertiesBD.Ptr is capable of holding at least newSize structures, create a new view XrSystemSpatialSensingPropertiesBD.Ptr that uses the same backing storage as this XrSystemSpatialSensingPropertiesBD.Ptr, but with the new size.
@NotNull XrSystemTrackingProperties.Ptr	XrSystemTrackingProperties.Ptr.reinterpret(long newSize)	Assume the XrSystemTrackingProperties.Ptr is capable of holding at least newSize structures, create a new view XrSystemTrackingProperties.Ptr that uses the same backing storage as this XrSystemTrackingProperties.Ptr, but with the new size.
@NotNull XrSystemUserPresencePropertiesEXT.Ptr	XrSystemUserPresencePropertiesEXT.Ptr.reinterpret(long newSize)	Assume the XrSystemUserPresencePropertiesEXT.Ptr is capable of holding at least newSize structures, create a new view XrSystemUserPresencePropertiesEXT.Ptr that uses the same backing storage as this XrSystemUserPresencePropertiesEXT.Ptr, but with the new size.
@NotNull XrSystemVirtualKeyboardPropertiesMETA.Ptr	XrSystemVirtualKeyboardPropertiesMETA.Ptr.reinterpret(long newSize)	Assume the XrSystemVirtualKeyboardPropertiesMETA.Ptr is capable of holding at least newSize structures, create a new view XrSystemVirtualKeyboardPropertiesMETA.Ptr that uses the same backing storage as this XrSystemVirtualKeyboardPropertiesMETA.Ptr, but with the new size.
@NotNull XrTriangleMeshCreateInfoFB.Ptr	XrTriangleMeshCreateInfoFB.Ptr.reinterpret(long newSize)	Assume the XrTriangleMeshCreateInfoFB.Ptr is capable of holding at least newSize structures, create a new view XrTriangleMeshCreateInfoFB.Ptr that uses the same backing storage as this XrTriangleMeshCreateInfoFB.Ptr, but with the new size.
@NotNull XrUnpersistSpatialEntityCompletionEXT.Ptr	XrUnpersistSpatialEntityCompletionEXT.Ptr.reinterpret(long newSize)	Assume the XrUnpersistSpatialEntityCompletionEXT.Ptr is capable of holding at least newSize structures, create a new view XrUnpersistSpatialEntityCompletionEXT.Ptr that uses the same backing storage as this XrUnpersistSpatialEntityCompletionEXT.Ptr, but with the new size.
@NotNull XrUserCalibrationEnableEventsInfoML.Ptr	XrUserCalibrationEnableEventsInfoML.Ptr.reinterpret(long newSize)	Assume the XrUserCalibrationEnableEventsInfoML.Ptr is capable of holding at least newSize structures, create a new view XrUserCalibrationEnableEventsInfoML.Ptr that uses the same backing storage as this XrUserCalibrationEnableEventsInfoML.Ptr, but with the new size.
@NotNull XrUuid.Ptr	XrUuid.Ptr.reinterpret(long newSize)	Assume the XrUuid.Ptr is capable of holding at least newSize structures, create a new view XrUuid.Ptr that uses the same backing storage as this XrUuid.Ptr, but with the new size.
@NotNull XrUuidEXT.Ptr	XrUuidEXT.Ptr.reinterpret(long newSize)	Assume the XrUuidEXT.Ptr is capable of holding at least newSize structures, create a new view XrUuidEXT.Ptr that uses the same backing storage as this XrUuidEXT.Ptr, but with the new size.
@NotNull XrUuidMSFT.Ptr	XrUuidMSFT.Ptr.reinterpret(long newSize)	Assume the XrUuidMSFT.Ptr is capable of holding at least newSize structures, create a new view XrUuidMSFT.Ptr that uses the same backing storage as this XrUuidMSFT.Ptr, but with the new size.
@NotNull XrVector2f.Ptr	XrVector2f.Ptr.reinterpret(long newSize)	Assume the XrVector2f.Ptr is capable of holding at least newSize structures, create a new view XrVector2f.Ptr that uses the same backing storage as this XrVector2f.Ptr, but with the new size.
@NotNull XrVector3f.Ptr	XrVector3f.Ptr.reinterpret(long newSize)	Assume the XrVector3f.Ptr is capable of holding at least newSize structures, create a new view XrVector3f.Ptr that uses the same backing storage as this XrVector3f.Ptr, but with the new size.
@NotNull XrVector4f.Ptr	XrVector4f.Ptr.reinterpret(long newSize)	Assume the XrVector4f.Ptr is capable of holding at least newSize structures, create a new view XrVector4f.Ptr that uses the same backing storage as this XrVector4f.Ptr, but with the new size.
@NotNull XrVector4sFB.Ptr	XrVector4sFB.Ptr.reinterpret(long newSize)	Assume the XrVector4sFB.Ptr is capable of holding at least newSize structures, create a new view XrVector4sFB.Ptr that uses the same backing storage as this XrVector4sFB.Ptr, but with the new size.
@NotNull XrView.Ptr	XrView.Ptr.reinterpret(long newSize)	Assume the XrView.Ptr is capable of holding at least newSize structures, create a new view XrView.Ptr that uses the same backing storage as this XrView.Ptr, but with the new size.
@NotNull XrViewConfigurationDepthRangeEXT.Ptr	XrViewConfigurationDepthRangeEXT.Ptr.reinterpret(long newSize)	Assume the XrViewConfigurationDepthRangeEXT.Ptr is capable of holding at least newSize structures, create a new view XrViewConfigurationDepthRangeEXT.Ptr that uses the same backing storage as this XrViewConfigurationDepthRangeEXT.Ptr, but with the new size.
@NotNull XrViewConfigurationProperties.Ptr	XrViewConfigurationProperties.Ptr.reinterpret(long newSize)	Assume the XrViewConfigurationProperties.Ptr is capable of holding at least newSize structures, create a new view XrViewConfigurationProperties.Ptr that uses the same backing storage as this XrViewConfigurationProperties.Ptr, but with the new size.
@NotNull XrViewConfigurationView.Ptr	XrViewConfigurationView.Ptr.reinterpret(long newSize)	Assume the XrViewConfigurationView.Ptr is capable of holding at least newSize structures, create a new view XrViewConfigurationView.Ptr that uses the same backing storage as this XrViewConfigurationView.Ptr, but with the new size.
@NotNull XrViewConfigurationViewFovEPIC.Ptr	XrViewConfigurationViewFovEPIC.Ptr.reinterpret(long newSize)	Assume the XrViewConfigurationViewFovEPIC.Ptr is capable of holding at least newSize structures, create a new view XrViewConfigurationViewFovEPIC.Ptr that uses the same backing storage as this XrViewConfigurationViewFovEPIC.Ptr, but with the new size.
@NotNull XrViewLocateFoveatedRenderingVARJO.Ptr	XrViewLocateFoveatedRenderingVARJO.Ptr.reinterpret(long newSize)	Assume the XrViewLocateFoveatedRenderingVARJO.Ptr is capable of holding at least newSize structures, create a new view XrViewLocateFoveatedRenderingVARJO.Ptr that uses the same backing storage as this XrViewLocateFoveatedRenderingVARJO.Ptr, but with the new size.
@NotNull XrViewLocateInfo.Ptr	XrViewLocateInfo.Ptr.reinterpret(long newSize)	Assume the XrViewLocateInfo.Ptr is capable of holding at least newSize structures, create a new view XrViewLocateInfo.Ptr that uses the same backing storage as this XrViewLocateInfo.Ptr, but with the new size.
@NotNull XrViewState.Ptr	XrViewState.Ptr.reinterpret(long newSize)	Assume the XrViewState.Ptr is capable of holding at least newSize structures, create a new view XrViewState.Ptr that uses the same backing storage as this XrViewState.Ptr, but with the new size.
@NotNull XrVirtualKeyboardAnimationStateMETA.Ptr	XrVirtualKeyboardAnimationStateMETA.Ptr.reinterpret(long newSize)	Assume the XrVirtualKeyboardAnimationStateMETA.Ptr is capable of holding at least newSize structures, create a new view XrVirtualKeyboardAnimationStateMETA.Ptr that uses the same backing storage as this XrVirtualKeyboardAnimationStateMETA.Ptr, but with the new size.
@NotNull XrVirtualKeyboardCreateInfoMETA.Ptr	XrVirtualKeyboardCreateInfoMETA.Ptr.reinterpret(long newSize)	Assume the XrVirtualKeyboardCreateInfoMETA.Ptr is capable of holding at least newSize structures, create a new view XrVirtualKeyboardCreateInfoMETA.Ptr that uses the same backing storage as this XrVirtualKeyboardCreateInfoMETA.Ptr, but with the new size.
@NotNull XrVirtualKeyboardInputInfoMETA.Ptr	XrVirtualKeyboardInputInfoMETA.Ptr.reinterpret(long newSize)	Assume the XrVirtualKeyboardInputInfoMETA.Ptr is capable of holding at least newSize structures, create a new view XrVirtualKeyboardInputInfoMETA.Ptr that uses the same backing storage as this XrVirtualKeyboardInputInfoMETA.Ptr, but with the new size.
@NotNull XrVirtualKeyboardLocationInfoMETA.Ptr	XrVirtualKeyboardLocationInfoMETA.Ptr.reinterpret(long newSize)	Assume the XrVirtualKeyboardLocationInfoMETA.Ptr is capable of holding at least newSize structures, create a new view XrVirtualKeyboardLocationInfoMETA.Ptr that uses the same backing storage as this XrVirtualKeyboardLocationInfoMETA.Ptr, but with the new size.
@NotNull XrVirtualKeyboardModelAnimationStatesMETA.Ptr	XrVirtualKeyboardModelAnimationStatesMETA.Ptr.reinterpret(long newSize)	Assume the XrVirtualKeyboardModelAnimationStatesMETA.Ptr is capable of holding at least newSize structures, create a new view XrVirtualKeyboardModelAnimationStatesMETA.Ptr that uses the same backing storage as this XrVirtualKeyboardModelAnimationStatesMETA.Ptr, but with the new size.
@NotNull XrVirtualKeyboardModelVisibilitySetInfoMETA.Ptr	XrVirtualKeyboardModelVisibilitySetInfoMETA.Ptr.reinterpret(long newSize)	Assume the XrVirtualKeyboardModelVisibilitySetInfoMETA.Ptr is capable of holding at least newSize structures, create a new view XrVirtualKeyboardModelVisibilitySetInfoMETA.Ptr that uses the same backing storage as this XrVirtualKeyboardModelVisibilitySetInfoMETA.Ptr, but with the new size.
@NotNull XrVirtualKeyboardSpaceCreateInfoMETA.Ptr	XrVirtualKeyboardSpaceCreateInfoMETA.Ptr.reinterpret(long newSize)	Assume the XrVirtualKeyboardSpaceCreateInfoMETA.Ptr is capable of holding at least newSize structures, create a new view XrVirtualKeyboardSpaceCreateInfoMETA.Ptr that uses the same backing storage as this XrVirtualKeyboardSpaceCreateInfoMETA.Ptr, but with the new size.
@NotNull XrVirtualKeyboardTextContextChangeInfoMETA.Ptr	XrVirtualKeyboardTextContextChangeInfoMETA.Ptr.reinterpret(long newSize)	Assume the XrVirtualKeyboardTextContextChangeInfoMETA.Ptr is capable of holding at least newSize structures, create a new view XrVirtualKeyboardTextContextChangeInfoMETA.Ptr that uses the same backing storage as this XrVirtualKeyboardTextContextChangeInfoMETA.Ptr, but with the new size.
@NotNull XrVirtualKeyboardTextureDataMETA.Ptr	XrVirtualKeyboardTextureDataMETA.Ptr.reinterpret(long newSize)	Assume the XrVirtualKeyboardTextureDataMETA.Ptr is capable of holding at least newSize structures, create a new view XrVirtualKeyboardTextureDataMETA.Ptr that uses the same backing storage as this XrVirtualKeyboardTextureDataMETA.Ptr, but with the new size.
@NotNull XrVisibilityMaskKHR.Ptr	XrVisibilityMaskKHR.Ptr.reinterpret(long newSize)	Assume the XrVisibilityMaskKHR.Ptr is capable of holding at least newSize structures, create a new view XrVisibilityMaskKHR.Ptr that uses the same backing storage as this XrVisibilityMaskKHR.Ptr, but with the new size.
@NotNull XrVisualMeshComputeLodInfoMSFT.Ptr	XrVisualMeshComputeLodInfoMSFT.Ptr.reinterpret(long newSize)	Assume the XrVisualMeshComputeLodInfoMSFT.Ptr is capable of holding at least newSize structures, create a new view XrVisualMeshComputeLodInfoMSFT.Ptr that uses the same backing storage as this XrVisualMeshComputeLodInfoMSFT.Ptr, but with the new size.
@NotNull XrViveTrackerPathsHTCX.Ptr	XrViveTrackerPathsHTCX.Ptr.reinterpret(long newSize)	Assume the XrViveTrackerPathsHTCX.Ptr is capable of holding at least newSize structures, create a new view XrViveTrackerPathsHTCX.Ptr that uses the same backing storage as this XrViveTrackerPathsHTCX.Ptr, but with the new size.
@NotNull XrVulkanDeviceCreateInfoKHR.Ptr	XrVulkanDeviceCreateInfoKHR.Ptr.reinterpret(long newSize)	Assume the XrVulkanDeviceCreateInfoKHR.Ptr is capable of holding at least newSize structures, create a new view XrVulkanDeviceCreateInfoKHR.Ptr that uses the same backing storage as this XrVulkanDeviceCreateInfoKHR.Ptr, but with the new size.
@NotNull XrVulkanGraphicsDeviceGetInfoKHR.Ptr	XrVulkanGraphicsDeviceGetInfoKHR.Ptr.reinterpret(long newSize)	Assume the XrVulkanGraphicsDeviceGetInfoKHR.Ptr is capable of holding at least newSize structures, create a new view XrVulkanGraphicsDeviceGetInfoKHR.Ptr that uses the same backing storage as this XrVulkanGraphicsDeviceGetInfoKHR.Ptr, but with the new size.
@NotNull XrVulkanInstanceCreateInfoKHR.Ptr	XrVulkanInstanceCreateInfoKHR.Ptr.reinterpret(long newSize)	Assume the XrVulkanInstanceCreateInfoKHR.Ptr is capable of holding at least newSize structures, create a new view XrVulkanInstanceCreateInfoKHR.Ptr that uses the same backing storage as this XrVulkanInstanceCreateInfoKHR.Ptr, but with the new size.
@NotNull XrVulkanSwapchainCreateInfoMETA.Ptr	XrVulkanSwapchainCreateInfoMETA.Ptr.reinterpret(long newSize)	Assume the XrVulkanSwapchainCreateInfoMETA.Ptr is capable of holding at least newSize structures, create a new view XrVulkanSwapchainCreateInfoMETA.Ptr that uses the same backing storage as this XrVulkanSwapchainCreateInfoMETA.Ptr, but with the new size.
@NotNull XrVulkanSwapchainFormatListCreateInfoKHR.Ptr	XrVulkanSwapchainFormatListCreateInfoKHR.Ptr.reinterpret(long newSize)	Assume the XrVulkanSwapchainFormatListCreateInfoKHR.Ptr is capable of holding at least newSize structures, create a new view XrVulkanSwapchainFormatListCreateInfoKHR.Ptr that uses the same backing storage as this XrVulkanSwapchainFormatListCreateInfoKHR.Ptr, but with the new size.
@NotNull XrWorldMeshBlockML.Ptr	XrWorldMeshBlockML.Ptr.reinterpret(long newSize)	Assume the XrWorldMeshBlockML.Ptr is capable of holding at least newSize structures, create a new view XrWorldMeshBlockML.Ptr that uses the same backing storage as this XrWorldMeshBlockML.Ptr, but with the new size.
@NotNull XrWorldMeshBlockRequestML.Ptr	XrWorldMeshBlockRequestML.Ptr.reinterpret(long newSize)	Assume the XrWorldMeshBlockRequestML.Ptr is capable of holding at least newSize structures, create a new view XrWorldMeshBlockRequestML.Ptr that uses the same backing storage as this XrWorldMeshBlockRequestML.Ptr, but with the new size.
@NotNull XrWorldMeshBlockStateML.Ptr	XrWorldMeshBlockStateML.Ptr.reinterpret(long newSize)	Assume the XrWorldMeshBlockStateML.Ptr is capable of holding at least newSize structures, create a new view XrWorldMeshBlockStateML.Ptr that uses the same backing storage as this XrWorldMeshBlockStateML.Ptr, but with the new size.
@NotNull XrWorldMeshBufferML.Ptr	XrWorldMeshBufferML.Ptr.reinterpret(long newSize)	Assume the XrWorldMeshBufferML.Ptr is capable of holding at least newSize structures, create a new view XrWorldMeshBufferML.Ptr that uses the same backing storage as this XrWorldMeshBufferML.Ptr, but with the new size.
@NotNull XrWorldMeshBufferRecommendedSizeInfoML.Ptr	XrWorldMeshBufferRecommendedSizeInfoML.Ptr.reinterpret(long newSize)	Assume the XrWorldMeshBufferRecommendedSizeInfoML.Ptr is capable of holding at least newSize structures, create a new view XrWorldMeshBufferRecommendedSizeInfoML.Ptr that uses the same backing storage as this XrWorldMeshBufferRecommendedSizeInfoML.Ptr, but with the new size.
@NotNull XrWorldMeshBufferSizeML.Ptr	XrWorldMeshBufferSizeML.Ptr.reinterpret(long newSize)	Assume the XrWorldMeshBufferSizeML.Ptr is capable of holding at least newSize structures, create a new view XrWorldMeshBufferSizeML.Ptr that uses the same backing storage as this XrWorldMeshBufferSizeML.Ptr, but with the new size.
@NotNull XrWorldMeshDetectorCreateInfoML.Ptr	XrWorldMeshDetectorCreateInfoML.Ptr.reinterpret(long newSize)	Assume the XrWorldMeshDetectorCreateInfoML.Ptr is capable of holding at least newSize structures, create a new view XrWorldMeshDetectorCreateInfoML.Ptr that uses the same backing storage as this XrWorldMeshDetectorCreateInfoML.Ptr, but with the new size.
@NotNull XrWorldMeshGetInfoML.Ptr	XrWorldMeshGetInfoML.Ptr.reinterpret(long newSize)	Assume the XrWorldMeshGetInfoML.Ptr is capable of holding at least newSize structures, create a new view XrWorldMeshGetInfoML.Ptr that uses the same backing storage as this XrWorldMeshGetInfoML.Ptr, but with the new size.
@NotNull XrWorldMeshRequestCompletionInfoML.Ptr	XrWorldMeshRequestCompletionInfoML.Ptr.reinterpret(long newSize)	Assume the XrWorldMeshRequestCompletionInfoML.Ptr is capable of holding at least newSize structures, create a new view XrWorldMeshRequestCompletionInfoML.Ptr that uses the same backing storage as this XrWorldMeshRequestCompletionInfoML.Ptr, but with the new size.
@NotNull XrWorldMeshRequestCompletionML.Ptr	XrWorldMeshRequestCompletionML.Ptr.reinterpret(long newSize)	Assume the XrWorldMeshRequestCompletionML.Ptr is capable of holding at least newSize structures, create a new view XrWorldMeshRequestCompletionML.Ptr that uses the same backing storage as this XrWorldMeshRequestCompletionML.Ptr, but with the new size.
@NotNull XrWorldMeshStateRequestCompletionML.Ptr	XrWorldMeshStateRequestCompletionML.Ptr.reinterpret(long newSize)	Assume the XrWorldMeshStateRequestCompletionML.Ptr is capable of holding at least newSize structures, create a new view XrWorldMeshStateRequestCompletionML.Ptr that uses the same backing storage as this XrWorldMeshStateRequestCompletionML.Ptr, but with the new size.
@NotNull XrWorldMeshStateRequestInfoML.Ptr	XrWorldMeshStateRequestInfoML.Ptr.reinterpret(long newSize)	Assume the XrWorldMeshStateRequestInfoML.Ptr is capable of holding at least newSize structures, create a new view XrWorldMeshStateRequestInfoML.Ptr that uses the same backing storage as this XrWorldMeshStateRequestInfoML.Ptr, but with the new size.
XrSpaceQueryResultFB.Ptr	XrSpaceQueryResultsFB.results(int assumedCount)
XrSpatialAnchorCompletionResultML.Ptr	XrSpatialAnchorsDeleteCompletionDetailsML.results(int assumedCount)
XrSpatialAnchorCompletionResultML.Ptr	XrSpatialAnchorsPublishCompletionDetailsML.results(int assumedCount)
XrSpatialAnchorCompletionResultML.Ptr	XrSpatialAnchorsUpdateExpirationCompletionDetailsML.results(int assumedCount)
XrSceneMarkerMSFT.Ptr	XrSceneMarkersMSFT.sceneMarkers(int assumedCount)
XrSceneMeshMSFT.Ptr	XrSceneMeshesMSFT.sceneMeshes(int assumedCount)
XrSceneObjectMSFT.Ptr	XrSceneObjectsMSFT.sceneObjects(int assumedCount)
XrScenePlaneMSFT.Ptr	XrScenePlanesMSFT.scenePlanes(int assumedCount)
XrDebugUtilsLabelEXT.Ptr	XrDebugUtilsMessengerCallbackDataEXT.sessionLabels(int assumedCount)
XrSceneSphereBoundMSFT.Ptr	XrSceneBoundsMSFT.spheres(int assumedCount)
XrSpatialEntityStateBD.Ptr	XrQueriedSenseDataBD.states(int assumedCount)
XrVirtualKeyboardAnimationStateMETA.Ptr	XrVirtualKeyboardModelAnimationStatesMETA.states(int assumedCount)
XrSwapchainSubImage.Ptr	XrFoveationApplyInfoHTC.subImages(int assumedCount)
XrActionSuggestedBinding.Ptr	XrInteractionProfileSuggestedBinding.suggestedBindings(int assumedCount)
XrUuidEXT.Ptr	XrSenseDataFilterUuidBD.uuids(int assumedCount)
XrUuidEXT.Ptr	XrSpaceContainerFB.uuids(int assumedCount)
XrUuidEXT.Ptr	XrSpaceUuidFilterInfoFB.uuids(int assumedCount)
XrUuidEXT.Ptr	XrSpatialAnchorsCreateInfoFromUuidsML.uuids(int assumedCount)
XrUuidEXT.Ptr	XrSpatialAnchorsDeleteInfoML.uuids(int assumedCount)
XrUuidEXT.Ptr	XrSpatialAnchorsPublishCompletionML.uuids(int assumedCount)
XrUuidEXT.Ptr	XrSpatialAnchorsQueryCompletionML.uuids(int assumedCount)
XrUuidEXT.Ptr	XrSpatialAnchorsUpdateExpirationInfoML.uuids(int assumedCount)
XrSpaceVelocityData.Ptr	XrSpaceVelocities.velocities(int assumedCount)
XrSpaceVelocityData.Ptr	XrSpaceVelocitiesKHR.velocities(int assumedCount)
XrVector4sFB.Ptr	XrHandTrackingMeshFB.vertexBlendIndices(int assumedCount)
XrVector4f.Ptr	XrHandTrackingMeshFB.vertexBlendWeights(int assumedCount)
XrVector3f.Ptr	XrTriangleMeshCreateInfoFB.vertexBuffer(int assumedCount)
XrVector3f.Ptr	XrWorldMeshBlockML.vertexBuffer(int assumedCount)
XrVector3f.Ptr	XrHandTrackingMeshFB.vertexNormals(int assumedCount)
XrVector3f.Ptr	XrHandTrackingMeshFB.vertexPositions(int assumedCount)
XrVector2f.Ptr	XrHandTrackingMeshFB.vertexUVs(int assumedCount)
XrVector2f.Ptr	XrBoundary2DFB.vertices(int assumedCount)
XrHandMeshVertexMSFT.Ptr	XrHandMeshVertexBufferMSFT.vertices(int assumedCount)
XrVector3f.Ptr	XrPassthroughMeshTransformInfoHTC.vertices(int assumedCount)
XrVector2f.Ptr	XrPlaneDetectorPolygonBufferEXT.vertices(int assumedCount)
XrVector3f.Ptr	XrSceneMeshVertexBufferMSFT.vertices(int assumedCount)
XrVector3f.Ptr	XrSpaceTriangleMeshMETA.vertices(int assumedCount)
XrVector2f.Ptr	XrSpatialEntityComponentDataPolygonBD.vertices(int assumedCount)
XrVector3f.Ptr	XrSpatialEntityComponentDataTriangleMeshBD.vertices(int assumedCount)
XrVector2f.Ptr	XrVisibilityMaskKHR.vertices(int assumedCount)
XrSecondaryViewConfigurationLayerInfoMSFT.Ptr	XrSecondaryViewConfigurationFrameEndInfoMSFT.viewConfigurationLayersInfo(int assumedCount)
XrSecondaryViewConfigurationStateMSFT.Ptr	XrSecondaryViewConfigurationFrameStateMSFT.viewConfigurationStates(int assumedCount)
XrCompositionLayerProjectionView.Ptr	XrCompositionLayerProjection.views(int assumedCount)
VkAllocationCallbacks.Ptr	XrVulkanDeviceCreateInfoKHR.vulkanAllocator(int assumedCount)
VkAllocationCallbacks.Ptr	XrVulkanInstanceCreateInfoKHR.vulkanAllocator(int assumedCount)
VkDeviceCreateInfo.Ptr	XrVulkanDeviceCreateInfoKHR.vulkanCreateInfo(int assumedCount)
VkInstanceCreateInfo.Ptr	XrVulkanInstanceCreateInfoKHR.vulkanCreateInfo(int assumedCount)
XrUuidEXT.Ptr	XrRoomLayoutFB.wallUuids(int assumedCount)

Uses of Unsafe in club.doki7.openxr.handle

Methods in club.doki7.openxr.handle with annotations of type Unsafe

Modifier and Type	Method	Description
XrAction.Ptr	XrAction.Ptr.reinterpret(long newSize)	Assume the XrAction.Ptr is capable of holding at least newSize handles, create a new view XrAction.Ptr that uses the same backing storage as this XrAction.Ptr, but with the new size.
XrActionSet.Ptr	XrActionSet.Ptr.reinterpret(long newSize)	Assume the XrActionSet.Ptr is capable of holding at least newSize handles, create a new view XrActionSet.Ptr that uses the same backing storage as this XrActionSet.Ptr, but with the new size.
XrAnchorBD.Ptr	XrAnchorBD.Ptr.reinterpret(long newSize)	Assume the XrAnchorBD.Ptr is capable of holding at least newSize handles, create a new view XrAnchorBD.Ptr that uses the same backing storage as this XrAnchorBD.Ptr, but with the new size.
XrBodyTrackerBD.Ptr	XrBodyTrackerBD.Ptr.reinterpret(long newSize)	Assume the XrBodyTrackerBD.Ptr is capable of holding at least newSize handles, create a new view XrBodyTrackerBD.Ptr that uses the same backing storage as this XrBodyTrackerBD.Ptr, but with the new size.
XrBodyTrackerFB.Ptr	XrBodyTrackerFB.Ptr.reinterpret(long newSize)	Assume the XrBodyTrackerFB.Ptr is capable of holding at least newSize handles, create a new view XrBodyTrackerFB.Ptr that uses the same backing storage as this XrBodyTrackerFB.Ptr, but with the new size.
XrBodyTrackerHTC.Ptr	XrBodyTrackerHTC.Ptr.reinterpret(long newSize)	Assume the XrBodyTrackerHTC.Ptr is capable of holding at least newSize handles, create a new view XrBodyTrackerHTC.Ptr that uses the same backing storage as this XrBodyTrackerHTC.Ptr, but with the new size.
XrDebugUtilsMessengerEXT.Ptr	XrDebugUtilsMessengerEXT.Ptr.reinterpret(long newSize)	Assume the XrDebugUtilsMessengerEXT.Ptr is capable of holding at least newSize handles, create a new view XrDebugUtilsMessengerEXT.Ptr that uses the same backing storage as this XrDebugUtilsMessengerEXT.Ptr, but with the new size.
XrEnvironmentDepthProviderMETA.Ptr	XrEnvironmentDepthProviderMETA.Ptr.reinterpret(long newSize)	Assume the XrEnvironmentDepthProviderMETA.Ptr is capable of holding at least newSize handles, create a new view XrEnvironmentDepthProviderMETA.Ptr that uses the same backing storage as this XrEnvironmentDepthProviderMETA.Ptr, but with the new size.
XrEnvironmentDepthSwapchainMETA.Ptr	XrEnvironmentDepthSwapchainMETA.Ptr.reinterpret(long newSize)	Assume the XrEnvironmentDepthSwapchainMETA.Ptr is capable of holding at least newSize handles, create a new view XrEnvironmentDepthSwapchainMETA.Ptr that uses the same backing storage as this XrEnvironmentDepthSwapchainMETA.Ptr, but with the new size.
XrExportedLocalizationMapML.Ptr	XrExportedLocalizationMapML.Ptr.reinterpret(long newSize)	Assume the XrExportedLocalizationMapML.Ptr is capable of holding at least newSize handles, create a new view XrExportedLocalizationMapML.Ptr that uses the same backing storage as this XrExportedLocalizationMapML.Ptr, but with the new size.
XrEyeTrackerFB.Ptr	XrEyeTrackerFB.Ptr.reinterpret(long newSize)	Assume the XrEyeTrackerFB.Ptr is capable of holding at least newSize handles, create a new view XrEyeTrackerFB.Ptr that uses the same backing storage as this XrEyeTrackerFB.Ptr, but with the new size.
XrFaceTracker2FB.Ptr	XrFaceTracker2FB.Ptr.reinterpret(long newSize)	Assume the XrFaceTracker2FB.Ptr is capable of holding at least newSize handles, create a new view XrFaceTracker2FB.Ptr that uses the same backing storage as this XrFaceTracker2FB.Ptr, but with the new size.
XrFaceTrackerFB.Ptr	XrFaceTrackerFB.Ptr.reinterpret(long newSize)	Assume the XrFaceTrackerFB.Ptr is capable of holding at least newSize handles, create a new view XrFaceTrackerFB.Ptr that uses the same backing storage as this XrFaceTrackerFB.Ptr, but with the new size.
XrFacialExpressionClientML.Ptr	XrFacialExpressionClientML.Ptr.reinterpret(long newSize)	Assume the XrFacialExpressionClientML.Ptr is capable of holding at least newSize handles, create a new view XrFacialExpressionClientML.Ptr that uses the same backing storage as this XrFacialExpressionClientML.Ptr, but with the new size.
XrFacialTrackerHTC.Ptr	XrFacialTrackerHTC.Ptr.reinterpret(long newSize)	Assume the XrFacialTrackerHTC.Ptr is capable of holding at least newSize handles, create a new view XrFacialTrackerHTC.Ptr that uses the same backing storage as this XrFacialTrackerHTC.Ptr, but with the new size.
XrFoveationProfileFB.Ptr	XrFoveationProfileFB.Ptr.reinterpret(long newSize)	Assume the XrFoveationProfileFB.Ptr is capable of holding at least newSize handles, create a new view XrFoveationProfileFB.Ptr that uses the same backing storage as this XrFoveationProfileFB.Ptr, but with the new size.
XrFutureEXT.Ptr	XrFutureEXT.Ptr.reinterpret(long newSize)	Assume the XrFutureEXT.Ptr is capable of holding at least newSize handles, create a new view XrFutureEXT.Ptr that uses the same backing storage as this XrFutureEXT.Ptr, but with the new size.
XrGeometryInstanceFB.Ptr	XrGeometryInstanceFB.Ptr.reinterpret(long newSize)	Assume the XrGeometryInstanceFB.Ptr is capable of holding at least newSize handles, create a new view XrGeometryInstanceFB.Ptr that uses the same backing storage as this XrGeometryInstanceFB.Ptr, but with the new size.
XrHandTrackerEXT.Ptr	XrHandTrackerEXT.Ptr.reinterpret(long newSize)	Assume the XrHandTrackerEXT.Ptr is capable of holding at least newSize handles, create a new view XrHandTrackerEXT.Ptr that uses the same backing storage as this XrHandTrackerEXT.Ptr, but with the new size.
XrInstance.Ptr	XrInstance.Ptr.reinterpret(long newSize)	Assume the XrInstance.Ptr is capable of holding at least newSize handles, create a new view XrInstance.Ptr that uses the same backing storage as this XrInstance.Ptr, but with the new size.
XrMarkerDetectorML.Ptr	XrMarkerDetectorML.Ptr.reinterpret(long newSize)	Assume the XrMarkerDetectorML.Ptr is capable of holding at least newSize handles, create a new view XrMarkerDetectorML.Ptr that uses the same backing storage as this XrMarkerDetectorML.Ptr, but with the new size.
XrPassthroughColorLutMETA.Ptr	XrPassthroughColorLutMETA.Ptr.reinterpret(long newSize)	Assume the XrPassthroughColorLutMETA.Ptr is capable of holding at least newSize handles, create a new view XrPassthroughColorLutMETA.Ptr that uses the same backing storage as this XrPassthroughColorLutMETA.Ptr, but with the new size.
XrPassthroughFB.Ptr	XrPassthroughFB.Ptr.reinterpret(long newSize)	Assume the XrPassthroughFB.Ptr is capable of holding at least newSize handles, create a new view XrPassthroughFB.Ptr that uses the same backing storage as this XrPassthroughFB.Ptr, but with the new size.
XrPassthroughHTC.Ptr	XrPassthroughHTC.Ptr.reinterpret(long newSize)	Assume the XrPassthroughHTC.Ptr is capable of holding at least newSize handles, create a new view XrPassthroughHTC.Ptr that uses the same backing storage as this XrPassthroughHTC.Ptr, but with the new size.
XrPassthroughLayerFB.Ptr	XrPassthroughLayerFB.Ptr.reinterpret(long newSize)	Assume the XrPassthroughLayerFB.Ptr is capable of holding at least newSize handles, create a new view XrPassthroughLayerFB.Ptr that uses the same backing storage as this XrPassthroughLayerFB.Ptr, but with the new size.
XrPlaneDetectorEXT.Ptr	XrPlaneDetectorEXT.Ptr.reinterpret(long newSize)	Assume the XrPlaneDetectorEXT.Ptr is capable of holding at least newSize handles, create a new view XrPlaneDetectorEXT.Ptr that uses the same backing storage as this XrPlaneDetectorEXT.Ptr, but with the new size.
XrRenderModelAssetEXT.Ptr	XrRenderModelAssetEXT.Ptr.reinterpret(long newSize)	Assume the XrRenderModelAssetEXT.Ptr is capable of holding at least newSize handles, create a new view XrRenderModelAssetEXT.Ptr that uses the same backing storage as this XrRenderModelAssetEXT.Ptr, but with the new size.
XrRenderModelEXT.Ptr	XrRenderModelEXT.Ptr.reinterpret(long newSize)	Assume the XrRenderModelEXT.Ptr is capable of holding at least newSize handles, create a new view XrRenderModelEXT.Ptr that uses the same backing storage as this XrRenderModelEXT.Ptr, but with the new size.
XrSceneMSFT.Ptr	XrSceneMSFT.Ptr.reinterpret(long newSize)	Assume the XrSceneMSFT.Ptr is capable of holding at least newSize handles, create a new view XrSceneMSFT.Ptr that uses the same backing storage as this XrSceneMSFT.Ptr, but with the new size.
XrSceneObserverMSFT.Ptr	XrSceneObserverMSFT.Ptr.reinterpret(long newSize)	Assume the XrSceneObserverMSFT.Ptr is capable of holding at least newSize handles, create a new view XrSceneObserverMSFT.Ptr that uses the same backing storage as this XrSceneObserverMSFT.Ptr, but with the new size.
XrSenseDataProviderBD.Ptr	XrSenseDataProviderBD.Ptr.reinterpret(long newSize)	Assume the XrSenseDataProviderBD.Ptr is capable of holding at least newSize handles, create a new view XrSenseDataProviderBD.Ptr that uses the same backing storage as this XrSenseDataProviderBD.Ptr, but with the new size.
XrSenseDataSnapshotBD.Ptr	XrSenseDataSnapshotBD.Ptr.reinterpret(long newSize)	Assume the XrSenseDataSnapshotBD.Ptr is capable of holding at least newSize handles, create a new view XrSenseDataSnapshotBD.Ptr that uses the same backing storage as this XrSenseDataSnapshotBD.Ptr, but with the new size.
XrSession.Ptr	XrSession.Ptr.reinterpret(long newSize)	Assume the XrSession.Ptr is capable of holding at least newSize handles, create a new view XrSession.Ptr that uses the same backing storage as this XrSession.Ptr, but with the new size.
XrSpace.Ptr	XrSpace.Ptr.reinterpret(long newSize)	Assume the XrSpace.Ptr is capable of holding at least newSize handles, create a new view XrSpace.Ptr that uses the same backing storage as this XrSpace.Ptr, but with the new size.
XrSpaceUserFB.Ptr	XrSpaceUserFB.Ptr.reinterpret(long newSize)	Assume the XrSpaceUserFB.Ptr is capable of holding at least newSize handles, create a new view XrSpaceUserFB.Ptr that uses the same backing storage as this XrSpaceUserFB.Ptr, but with the new size.
XrSpatialAnchorMSFT.Ptr	XrSpatialAnchorMSFT.Ptr.reinterpret(long newSize)	Assume the XrSpatialAnchorMSFT.Ptr is capable of holding at least newSize handles, create a new view XrSpatialAnchorMSFT.Ptr that uses the same backing storage as this XrSpatialAnchorMSFT.Ptr, but with the new size.
XrSpatialAnchorsStorageML.Ptr	XrSpatialAnchorsStorageML.Ptr.reinterpret(long newSize)	Assume the XrSpatialAnchorsStorageML.Ptr is capable of holding at least newSize handles, create a new view XrSpatialAnchorsStorageML.Ptr that uses the same backing storage as this XrSpatialAnchorsStorageML.Ptr, but with the new size.
XrSpatialAnchorStoreConnectionMSFT.Ptr	XrSpatialAnchorStoreConnectionMSFT.Ptr.reinterpret(long newSize)	Assume the XrSpatialAnchorStoreConnectionMSFT.Ptr is capable of holding at least newSize handles, create a new view XrSpatialAnchorStoreConnectionMSFT.Ptr that uses the same backing storage as this XrSpatialAnchorStoreConnectionMSFT.Ptr, but with the new size.
XrSpatialContextEXT.Ptr	XrSpatialContextEXT.Ptr.reinterpret(long newSize)	Assume the XrSpatialContextEXT.Ptr is capable of holding at least newSize handles, create a new view XrSpatialContextEXT.Ptr that uses the same backing storage as this XrSpatialContextEXT.Ptr, but with the new size.
XrSpatialEntityEXT.Ptr	XrSpatialEntityEXT.Ptr.reinterpret(long newSize)	Assume the XrSpatialEntityEXT.Ptr is capable of holding at least newSize handles, create a new view XrSpatialEntityEXT.Ptr that uses the same backing storage as this XrSpatialEntityEXT.Ptr, but with the new size.
XrSpatialGraphNodeBindingMSFT.Ptr	XrSpatialGraphNodeBindingMSFT.Ptr.reinterpret(long newSize)	Assume the XrSpatialGraphNodeBindingMSFT.Ptr is capable of holding at least newSize handles, create a new view XrSpatialGraphNodeBindingMSFT.Ptr that uses the same backing storage as this XrSpatialGraphNodeBindingMSFT.Ptr, but with the new size.
XrSpatialPersistenceContextEXT.Ptr	XrSpatialPersistenceContextEXT.Ptr.reinterpret(long newSize)	Assume the XrSpatialPersistenceContextEXT.Ptr is capable of holding at least newSize handles, create a new view XrSpatialPersistenceContextEXT.Ptr that uses the same backing storage as this XrSpatialPersistenceContextEXT.Ptr, but with the new size.
XrSpatialSnapshotEXT.Ptr	XrSpatialSnapshotEXT.Ptr.reinterpret(long newSize)	Assume the XrSpatialSnapshotEXT.Ptr is capable of holding at least newSize handles, create a new view XrSpatialSnapshotEXT.Ptr that uses the same backing storage as this XrSpatialSnapshotEXT.Ptr, but with the new size.
XrSwapchain.Ptr	XrSwapchain.Ptr.reinterpret(long newSize)	Assume the XrSwapchain.Ptr is capable of holding at least newSize handles, create a new view XrSwapchain.Ptr that uses the same backing storage as this XrSwapchain.Ptr, but with the new size.
XrTriangleMeshFB.Ptr	XrTriangleMeshFB.Ptr.reinterpret(long newSize)	Assume the XrTriangleMeshFB.Ptr is capable of holding at least newSize handles, create a new view XrTriangleMeshFB.Ptr that uses the same backing storage as this XrTriangleMeshFB.Ptr, but with the new size.
XrVirtualKeyboardMETA.Ptr	XrVirtualKeyboardMETA.Ptr.reinterpret(long newSize)	Assume the XrVirtualKeyboardMETA.Ptr is capable of holding at least newSize handles, create a new view XrVirtualKeyboardMETA.Ptr that uses the same backing storage as this XrVirtualKeyboardMETA.Ptr, but with the new size.
XrWorldMeshDetectorML.Ptr	XrWorldMeshDetectorML.Ptr.reinterpret(long newSize)	Assume the XrWorldMeshDetectorML.Ptr is capable of holding at least newSize handles, create a new view XrWorldMeshDetectorML.Ptr that uses the same backing storage as this XrWorldMeshDetectorML.Ptr, but with the new size.

Uses of Unsafe in club.doki7.sdl3.datatype

Methods in club.doki7.sdl3.datatype with annotations of type Unsafe

Modifier and Type	Method	Description
SDL_MessageBoxButtonData.Ptr	SDL_MessageBoxData.buttons(int assumedCount)
SDL_GPUColorTargetDescription.Ptr	SDL_GPUGraphicsPipelineTargetInfo.color_target_descriptions(int assumedCount)
SDL_Color.Ptr	SDL_Palette.colors(int assumedCount)
SDL_MessageBoxColorScheme.Ptr	SDL_MessageBoxData.colorScheme(int assumedCount)
SDL_hid_device_info.Ptr	SDL_hid_device_info.next(int assumedCount)
@NotNull SDL_alignment_test.Ptr	SDL_alignment_test.Ptr.reinterpret(long newSize)	Assume the SDL_alignment_test.Ptr is capable of holding at least newSize structures, create a new view SDL_alignment_test.Ptr that uses the same backing storage as this SDL_alignment_test.Ptr, but with the new size.
@NotNull SDL_AsyncIOOutcome.Ptr	SDL_AsyncIOOutcome.Ptr.reinterpret(long newSize)	Assume the SDL_AsyncIOOutcome.Ptr is capable of holding at least newSize structures, create a new view SDL_AsyncIOOutcome.Ptr that uses the same backing storage as this SDL_AsyncIOOutcome.Ptr, but with the new size.
@NotNull SDL_AtomicInt.Ptr	SDL_AtomicInt.Ptr.reinterpret(long newSize)	Assume the SDL_AtomicInt.Ptr is capable of holding at least newSize structures, create a new view SDL_AtomicInt.Ptr that uses the same backing storage as this SDL_AtomicInt.Ptr, but with the new size.
@NotNull SDL_AtomicU32.Ptr	SDL_AtomicU32.Ptr.reinterpret(long newSize)	Assume the SDL_AtomicU32.Ptr is capable of holding at least newSize structures, create a new view SDL_AtomicU32.Ptr that uses the same backing storage as this SDL_AtomicU32.Ptr, but with the new size.
@NotNull SDL_AudioDeviceEvent.Ptr	SDL_AudioDeviceEvent.Ptr.reinterpret(long newSize)	Assume the SDL_AudioDeviceEvent.Ptr is capable of holding at least newSize structures, create a new view SDL_AudioDeviceEvent.Ptr that uses the same backing storage as this SDL_AudioDeviceEvent.Ptr, but with the new size.
@NotNull SDL_AudioSpec.Ptr	SDL_AudioSpec.Ptr.reinterpret(long newSize)	Assume the SDL_AudioSpec.Ptr is capable of holding at least newSize structures, create a new view SDL_AudioSpec.Ptr that uses the same backing storage as this SDL_AudioSpec.Ptr, but with the new size.
@NotNull SDL_CameraDeviceEvent.Ptr	SDL_CameraDeviceEvent.Ptr.reinterpret(long newSize)	Assume the SDL_CameraDeviceEvent.Ptr is capable of holding at least newSize structures, create a new view SDL_CameraDeviceEvent.Ptr that uses the same backing storage as this SDL_CameraDeviceEvent.Ptr, but with the new size.
@NotNull SDL_CameraSpec.Ptr	SDL_CameraSpec.Ptr.reinterpret(long newSize)	Assume the SDL_CameraSpec.Ptr is capable of holding at least newSize structures, create a new view SDL_CameraSpec.Ptr that uses the same backing storage as this SDL_CameraSpec.Ptr, but with the new size.
@NotNull SDL_ClipboardEvent.Ptr	SDL_ClipboardEvent.Ptr.reinterpret(long newSize)	Assume the SDL_ClipboardEvent.Ptr is capable of holding at least newSize structures, create a new view SDL_ClipboardEvent.Ptr that uses the same backing storage as this SDL_ClipboardEvent.Ptr, but with the new size.
@NotNull SDL_Color.Ptr	SDL_Color.Ptr.reinterpret(long newSize)	Assume the SDL_Color.Ptr is capable of holding at least newSize structures, create a new view SDL_Color.Ptr that uses the same backing storage as this SDL_Color.Ptr, but with the new size.
@NotNull SDL_CommonEvent.Ptr	SDL_CommonEvent.Ptr.reinterpret(long newSize)	Assume the SDL_CommonEvent.Ptr is capable of holding at least newSize structures, create a new view SDL_CommonEvent.Ptr that uses the same backing storage as this SDL_CommonEvent.Ptr, but with the new size.
@NotNull SDL_DateTime.Ptr	SDL_DateTime.Ptr.reinterpret(long newSize)	Assume the SDL_DateTime.Ptr is capable of holding at least newSize structures, create a new view SDL_DateTime.Ptr that uses the same backing storage as this SDL_DateTime.Ptr, but with the new size.
@NotNull SDL_DialogFileFilter.Ptr	SDL_DialogFileFilter.Ptr.reinterpret(long newSize)	Assume the SDL_DialogFileFilter.Ptr is capable of holding at least newSize structures, create a new view SDL_DialogFileFilter.Ptr that uses the same backing storage as this SDL_DialogFileFilter.Ptr, but with the new size.
@NotNull SDL_DisplayEvent.Ptr	SDL_DisplayEvent.Ptr.reinterpret(long newSize)	Assume the SDL_DisplayEvent.Ptr is capable of holding at least newSize structures, create a new view SDL_DisplayEvent.Ptr that uses the same backing storage as this SDL_DisplayEvent.Ptr, but with the new size.
@NotNull SDL_DisplayMode.Ptr	SDL_DisplayMode.Ptr.reinterpret(long newSize)	Assume the SDL_DisplayMode.Ptr is capable of holding at least newSize structures, create a new view SDL_DisplayMode.Ptr that uses the same backing storage as this SDL_DisplayMode.Ptr, but with the new size.
@NotNull SDL_DropEvent.Ptr	SDL_DropEvent.Ptr.reinterpret(long newSize)	Assume the SDL_DropEvent.Ptr is capable of holding at least newSize structures, create a new view SDL_DropEvent.Ptr that uses the same backing storage as this SDL_DropEvent.Ptr, but with the new size.
@NotNull SDL_Event.Ptr	SDL_Event.Ptr.reinterpret(long newSize)	Assume the SDL_Event.Ptr is capable of holding at least newSize structures, create a new view SDL_Event.Ptr that uses the same backing storage as this SDL_Event.Ptr, but with the new size.
@NotNull SDL_FColor.Ptr	SDL_FColor.Ptr.reinterpret(long newSize)	Assume the SDL_FColor.Ptr is capable of holding at least newSize structures, create a new view SDL_FColor.Ptr that uses the same backing storage as this SDL_FColor.Ptr, but with the new size.
@NotNull SDL_Finger.Ptr	SDL_Finger.Ptr.reinterpret(long newSize)	Assume the SDL_Finger.Ptr is capable of holding at least newSize structures, create a new view SDL_Finger.Ptr that uses the same backing storage as this SDL_Finger.Ptr, but with the new size.
@NotNull SDL_FPoint.Ptr	SDL_FPoint.Ptr.reinterpret(long newSize)	Assume the SDL_FPoint.Ptr is capable of holding at least newSize structures, create a new view SDL_FPoint.Ptr that uses the same backing storage as this SDL_FPoint.Ptr, but with the new size.
@NotNull SDL_FRect.Ptr	SDL_FRect.Ptr.reinterpret(long newSize)	Assume the SDL_FRect.Ptr is capable of holding at least newSize structures, create a new view SDL_FRect.Ptr that uses the same backing storage as this SDL_FRect.Ptr, but with the new size.
@NotNull SDL_GamepadAxisEvent.Ptr	SDL_GamepadAxisEvent.Ptr.reinterpret(long newSize)	Assume the SDL_GamepadAxisEvent.Ptr is capable of holding at least newSize structures, create a new view SDL_GamepadAxisEvent.Ptr that uses the same backing storage as this SDL_GamepadAxisEvent.Ptr, but with the new size.
@NotNull SDL_GamepadBinding_Input_Axis.Ptr	SDL_GamepadBinding_Input_Axis.Ptr.reinterpret(long newSize)	Assume the SDL_GamepadBinding_Input_Axis.Ptr is capable of holding at least newSize structures, create a new view SDL_GamepadBinding_Input_Axis.Ptr that uses the same backing storage as this SDL_GamepadBinding_Input_Axis.Ptr, but with the new size.
@NotNull SDL_GamepadBinding_Input_Hat.Ptr	SDL_GamepadBinding_Input_Hat.Ptr.reinterpret(long newSize)	Assume the SDL_GamepadBinding_Input_Hat.Ptr is capable of holding at least newSize structures, create a new view SDL_GamepadBinding_Input_Hat.Ptr that uses the same backing storage as this SDL_GamepadBinding_Input_Hat.Ptr, but with the new size.
@NotNull SDL_GamepadBinding_Input.Ptr	SDL_GamepadBinding_Input.Ptr.reinterpret(long newSize)	Assume the SDL_GamepadBinding_Input.Ptr is capable of holding at least newSize structures, create a new view SDL_GamepadBinding_Input.Ptr that uses the same backing storage as this SDL_GamepadBinding_Input.Ptr, but with the new size.
@NotNull SDL_GamepadBinding_Output_Axis.Ptr	SDL_GamepadBinding_Output_Axis.Ptr.reinterpret(long newSize)	Assume the SDL_GamepadBinding_Output_Axis.Ptr is capable of holding at least newSize structures, create a new view SDL_GamepadBinding_Output_Axis.Ptr that uses the same backing storage as this SDL_GamepadBinding_Output_Axis.Ptr, but with the new size.
@NotNull SDL_GamepadBinding_Output.Ptr	SDL_GamepadBinding_Output.Ptr.reinterpret(long newSize)	Assume the SDL_GamepadBinding_Output.Ptr is capable of holding at least newSize structures, create a new view SDL_GamepadBinding_Output.Ptr that uses the same backing storage as this SDL_GamepadBinding_Output.Ptr, but with the new size.
@NotNull SDL_GamepadBinding.Ptr	SDL_GamepadBinding.Ptr.reinterpret(long newSize)	Assume the SDL_GamepadBinding.Ptr is capable of holding at least newSize structures, create a new view SDL_GamepadBinding.Ptr that uses the same backing storage as this SDL_GamepadBinding.Ptr, but with the new size.
@NotNull SDL_GamepadButtonEvent.Ptr	SDL_GamepadButtonEvent.Ptr.reinterpret(long newSize)	Assume the SDL_GamepadButtonEvent.Ptr is capable of holding at least newSize structures, create a new view SDL_GamepadButtonEvent.Ptr that uses the same backing storage as this SDL_GamepadButtonEvent.Ptr, but with the new size.
@NotNull SDL_GamepadDeviceEvent.Ptr	SDL_GamepadDeviceEvent.Ptr.reinterpret(long newSize)	Assume the SDL_GamepadDeviceEvent.Ptr is capable of holding at least newSize structures, create a new view SDL_GamepadDeviceEvent.Ptr that uses the same backing storage as this SDL_GamepadDeviceEvent.Ptr, but with the new size.
@NotNull SDL_GamepadSensorEvent.Ptr	SDL_GamepadSensorEvent.Ptr.reinterpret(long newSize)	Assume the SDL_GamepadSensorEvent.Ptr is capable of holding at least newSize structures, create a new view SDL_GamepadSensorEvent.Ptr that uses the same backing storage as this SDL_GamepadSensorEvent.Ptr, but with the new size.
@NotNull SDL_GamepadTouchpadEvent.Ptr	SDL_GamepadTouchpadEvent.Ptr.reinterpret(long newSize)	Assume the SDL_GamepadTouchpadEvent.Ptr is capable of holding at least newSize structures, create a new view SDL_GamepadTouchpadEvent.Ptr that uses the same backing storage as this SDL_GamepadTouchpadEvent.Ptr, but with the new size.
@NotNull SDL_GPUBlitInfo.Ptr	SDL_GPUBlitInfo.Ptr.reinterpret(long newSize)	Assume the SDL_GPUBlitInfo.Ptr is capable of holding at least newSize structures, create a new view SDL_GPUBlitInfo.Ptr that uses the same backing storage as this SDL_GPUBlitInfo.Ptr, but with the new size.
@NotNull SDL_GPUBlitRegion.Ptr	SDL_GPUBlitRegion.Ptr.reinterpret(long newSize)	Assume the SDL_GPUBlitRegion.Ptr is capable of holding at least newSize structures, create a new view SDL_GPUBlitRegion.Ptr that uses the same backing storage as this SDL_GPUBlitRegion.Ptr, but with the new size.
@NotNull SDL_GPUBufferBinding.Ptr	SDL_GPUBufferBinding.Ptr.reinterpret(long newSize)	Assume the SDL_GPUBufferBinding.Ptr is capable of holding at least newSize structures, create a new view SDL_GPUBufferBinding.Ptr that uses the same backing storage as this SDL_GPUBufferBinding.Ptr, but with the new size.
@NotNull SDL_GPUBufferCreateInfo.Ptr	SDL_GPUBufferCreateInfo.Ptr.reinterpret(long newSize)	Assume the SDL_GPUBufferCreateInfo.Ptr is capable of holding at least newSize structures, create a new view SDL_GPUBufferCreateInfo.Ptr that uses the same backing storage as this SDL_GPUBufferCreateInfo.Ptr, but with the new size.
@NotNull SDL_GPUBufferLocation.Ptr	SDL_GPUBufferLocation.Ptr.reinterpret(long newSize)	Assume the SDL_GPUBufferLocation.Ptr is capable of holding at least newSize structures, create a new view SDL_GPUBufferLocation.Ptr that uses the same backing storage as this SDL_GPUBufferLocation.Ptr, but with the new size.
@NotNull SDL_GPUBufferRegion.Ptr	SDL_GPUBufferRegion.Ptr.reinterpret(long newSize)	Assume the SDL_GPUBufferRegion.Ptr is capable of holding at least newSize structures, create a new view SDL_GPUBufferRegion.Ptr that uses the same backing storage as this SDL_GPUBufferRegion.Ptr, but with the new size.
@NotNull SDL_GPUColorTargetBlendState.Ptr	SDL_GPUColorTargetBlendState.Ptr.reinterpret(long newSize)	Assume the SDL_GPUColorTargetBlendState.Ptr is capable of holding at least newSize structures, create a new view SDL_GPUColorTargetBlendState.Ptr that uses the same backing storage as this SDL_GPUColorTargetBlendState.Ptr, but with the new size.
@NotNull SDL_GPUColorTargetDescription.Ptr	SDL_GPUColorTargetDescription.Ptr.reinterpret(long newSize)	Assume the SDL_GPUColorTargetDescription.Ptr is capable of holding at least newSize structures, create a new view SDL_GPUColorTargetDescription.Ptr that uses the same backing storage as this SDL_GPUColorTargetDescription.Ptr, but with the new size.
@NotNull SDL_GPUColorTargetInfo.Ptr	SDL_GPUColorTargetInfo.Ptr.reinterpret(long newSize)	Assume the SDL_GPUColorTargetInfo.Ptr is capable of holding at least newSize structures, create a new view SDL_GPUColorTargetInfo.Ptr that uses the same backing storage as this SDL_GPUColorTargetInfo.Ptr, but with the new size.
@NotNull SDL_GPUComputePipelineCreateInfo.Ptr	SDL_GPUComputePipelineCreateInfo.Ptr.reinterpret(long newSize)	Assume the SDL_GPUComputePipelineCreateInfo.Ptr is capable of holding at least newSize structures, create a new view SDL_GPUComputePipelineCreateInfo.Ptr that uses the same backing storage as this SDL_GPUComputePipelineCreateInfo.Ptr, but with the new size.
@NotNull SDL_GPUDepthStencilState.Ptr	SDL_GPUDepthStencilState.Ptr.reinterpret(long newSize)	Assume the SDL_GPUDepthStencilState.Ptr is capable of holding at least newSize structures, create a new view SDL_GPUDepthStencilState.Ptr that uses the same backing storage as this SDL_GPUDepthStencilState.Ptr, but with the new size.
@NotNull SDL_GPUDepthStencilTargetInfo.Ptr	SDL_GPUDepthStencilTargetInfo.Ptr.reinterpret(long newSize)	Assume the SDL_GPUDepthStencilTargetInfo.Ptr is capable of holding at least newSize structures, create a new view SDL_GPUDepthStencilTargetInfo.Ptr that uses the same backing storage as this SDL_GPUDepthStencilTargetInfo.Ptr, but with the new size.
@NotNull SDL_GPUGraphicsPipelineCreateInfo.Ptr	SDL_GPUGraphicsPipelineCreateInfo.Ptr.reinterpret(long newSize)	Assume the SDL_GPUGraphicsPipelineCreateInfo.Ptr is capable of holding at least newSize structures, create a new view SDL_GPUGraphicsPipelineCreateInfo.Ptr that uses the same backing storage as this SDL_GPUGraphicsPipelineCreateInfo.Ptr, but with the new size.
@NotNull SDL_GPUGraphicsPipelineTargetInfo.Ptr	SDL_GPUGraphicsPipelineTargetInfo.Ptr.reinterpret(long newSize)	Assume the SDL_GPUGraphicsPipelineTargetInfo.Ptr is capable of holding at least newSize structures, create a new view SDL_GPUGraphicsPipelineTargetInfo.Ptr that uses the same backing storage as this SDL_GPUGraphicsPipelineTargetInfo.Ptr, but with the new size.
@NotNull SDL_GPUIndexedIndirectDrawCommand.Ptr	SDL_GPUIndexedIndirectDrawCommand.Ptr.reinterpret(long newSize)	Assume the SDL_GPUIndexedIndirectDrawCommand.Ptr is capable of holding at least newSize structures, create a new view SDL_GPUIndexedIndirectDrawCommand.Ptr that uses the same backing storage as this SDL_GPUIndexedIndirectDrawCommand.Ptr, but with the new size.
@NotNull SDL_GPUIndirectDispatchCommand.Ptr	SDL_GPUIndirectDispatchCommand.Ptr.reinterpret(long newSize)	Assume the SDL_GPUIndirectDispatchCommand.Ptr is capable of holding at least newSize structures, create a new view SDL_GPUIndirectDispatchCommand.Ptr that uses the same backing storage as this SDL_GPUIndirectDispatchCommand.Ptr, but with the new size.
@NotNull SDL_GPUIndirectDrawCommand.Ptr	SDL_GPUIndirectDrawCommand.Ptr.reinterpret(long newSize)	Assume the SDL_GPUIndirectDrawCommand.Ptr is capable of holding at least newSize structures, create a new view SDL_GPUIndirectDrawCommand.Ptr that uses the same backing storage as this SDL_GPUIndirectDrawCommand.Ptr, but with the new size.
@NotNull SDL_GPUMultisampleState.Ptr	SDL_GPUMultisampleState.Ptr.reinterpret(long newSize)	Assume the SDL_GPUMultisampleState.Ptr is capable of holding at least newSize structures, create a new view SDL_GPUMultisampleState.Ptr that uses the same backing storage as this SDL_GPUMultisampleState.Ptr, but with the new size.
@NotNull SDL_GPURasterizerState.Ptr	SDL_GPURasterizerState.Ptr.reinterpret(long newSize)	Assume the SDL_GPURasterizerState.Ptr is capable of holding at least newSize structures, create a new view SDL_GPURasterizerState.Ptr that uses the same backing storage as this SDL_GPURasterizerState.Ptr, but with the new size.
@NotNull SDL_GPUSamplerCreateInfo.Ptr	SDL_GPUSamplerCreateInfo.Ptr.reinterpret(long newSize)	Assume the SDL_GPUSamplerCreateInfo.Ptr is capable of holding at least newSize structures, create a new view SDL_GPUSamplerCreateInfo.Ptr that uses the same backing storage as this SDL_GPUSamplerCreateInfo.Ptr, but with the new size.
@NotNull SDL_GPUShaderCreateInfo.Ptr	SDL_GPUShaderCreateInfo.Ptr.reinterpret(long newSize)	Assume the SDL_GPUShaderCreateInfo.Ptr is capable of holding at least newSize structures, create a new view SDL_GPUShaderCreateInfo.Ptr that uses the same backing storage as this SDL_GPUShaderCreateInfo.Ptr, but with the new size.
@NotNull SDL_GPUStencilOpState.Ptr	SDL_GPUStencilOpState.Ptr.reinterpret(long newSize)	Assume the SDL_GPUStencilOpState.Ptr is capable of holding at least newSize structures, create a new view SDL_GPUStencilOpState.Ptr that uses the same backing storage as this SDL_GPUStencilOpState.Ptr, but with the new size.
@NotNull SDL_GPUStorageBufferReadWriteBinding.Ptr	SDL_GPUStorageBufferReadWriteBinding.Ptr.reinterpret(long newSize)	Assume the SDL_GPUStorageBufferReadWriteBinding.Ptr is capable of holding at least newSize structures, create a new view SDL_GPUStorageBufferReadWriteBinding.Ptr that uses the same backing storage as this SDL_GPUStorageBufferReadWriteBinding.Ptr, but with the new size.
@NotNull SDL_GPUStorageTextureReadWriteBinding.Ptr	SDL_GPUStorageTextureReadWriteBinding.Ptr.reinterpret(long newSize)	Assume the SDL_GPUStorageTextureReadWriteBinding.Ptr is capable of holding at least newSize structures, create a new view SDL_GPUStorageTextureReadWriteBinding.Ptr that uses the same backing storage as this SDL_GPUStorageTextureReadWriteBinding.Ptr, but with the new size.
@NotNull SDL_GPUTextureCreateInfo.Ptr	SDL_GPUTextureCreateInfo.Ptr.reinterpret(long newSize)	Assume the SDL_GPUTextureCreateInfo.Ptr is capable of holding at least newSize structures, create a new view SDL_GPUTextureCreateInfo.Ptr that uses the same backing storage as this SDL_GPUTextureCreateInfo.Ptr, but with the new size.
@NotNull SDL_GPUTextureLocation.Ptr	SDL_GPUTextureLocation.Ptr.reinterpret(long newSize)	Assume the SDL_GPUTextureLocation.Ptr is capable of holding at least newSize structures, create a new view SDL_GPUTextureLocation.Ptr that uses the same backing storage as this SDL_GPUTextureLocation.Ptr, but with the new size.
@NotNull SDL_GPUTextureRegion.Ptr	SDL_GPUTextureRegion.Ptr.reinterpret(long newSize)	Assume the SDL_GPUTextureRegion.Ptr is capable of holding at least newSize structures, create a new view SDL_GPUTextureRegion.Ptr that uses the same backing storage as this SDL_GPUTextureRegion.Ptr, but with the new size.
@NotNull SDL_GPUTextureSamplerBinding.Ptr	SDL_GPUTextureSamplerBinding.Ptr.reinterpret(long newSize)	Assume the SDL_GPUTextureSamplerBinding.Ptr is capable of holding at least newSize structures, create a new view SDL_GPUTextureSamplerBinding.Ptr that uses the same backing storage as this SDL_GPUTextureSamplerBinding.Ptr, but with the new size.
@NotNull SDL_GPUTextureTransferInfo.Ptr	SDL_GPUTextureTransferInfo.Ptr.reinterpret(long newSize)	Assume the SDL_GPUTextureTransferInfo.Ptr is capable of holding at least newSize structures, create a new view SDL_GPUTextureTransferInfo.Ptr that uses the same backing storage as this SDL_GPUTextureTransferInfo.Ptr, but with the new size.
@NotNull SDL_GPUTransferBufferCreateInfo.Ptr	SDL_GPUTransferBufferCreateInfo.Ptr.reinterpret(long newSize)	Assume the SDL_GPUTransferBufferCreateInfo.Ptr is capable of holding at least newSize structures, create a new view SDL_GPUTransferBufferCreateInfo.Ptr that uses the same backing storage as this SDL_GPUTransferBufferCreateInfo.Ptr, but with the new size.
@NotNull SDL_GPUTransferBufferLocation.Ptr	SDL_GPUTransferBufferLocation.Ptr.reinterpret(long newSize)	Assume the SDL_GPUTransferBufferLocation.Ptr is capable of holding at least newSize structures, create a new view SDL_GPUTransferBufferLocation.Ptr that uses the same backing storage as this SDL_GPUTransferBufferLocation.Ptr, but with the new size.
@NotNull SDL_GPUVertexAttribute.Ptr	SDL_GPUVertexAttribute.Ptr.reinterpret(long newSize)	Assume the SDL_GPUVertexAttribute.Ptr is capable of holding at least newSize structures, create a new view SDL_GPUVertexAttribute.Ptr that uses the same backing storage as this SDL_GPUVertexAttribute.Ptr, but with the new size.
@NotNull SDL_GPUVertexBufferDescription.Ptr	SDL_GPUVertexBufferDescription.Ptr.reinterpret(long newSize)	Assume the SDL_GPUVertexBufferDescription.Ptr is capable of holding at least newSize structures, create a new view SDL_GPUVertexBufferDescription.Ptr that uses the same backing storage as this SDL_GPUVertexBufferDescription.Ptr, but with the new size.
@NotNull SDL_GPUVertexInputState.Ptr	SDL_GPUVertexInputState.Ptr.reinterpret(long newSize)	Assume the SDL_GPUVertexInputState.Ptr is capable of holding at least newSize structures, create a new view SDL_GPUVertexInputState.Ptr that uses the same backing storage as this SDL_GPUVertexInputState.Ptr, but with the new size.
@NotNull SDL_GPUViewport.Ptr	SDL_GPUViewport.Ptr.reinterpret(long newSize)	Assume the SDL_GPUViewport.Ptr is capable of holding at least newSize structures, create a new view SDL_GPUViewport.Ptr that uses the same backing storage as this SDL_GPUViewport.Ptr, but with the new size.
@NotNull SDL_GUID.Ptr	SDL_GUID.Ptr.reinterpret(long newSize)	Assume the SDL_GUID.Ptr is capable of holding at least newSize structures, create a new view SDL_GUID.Ptr that uses the same backing storage as this SDL_GUID.Ptr, but with the new size.
@NotNull SDL_HapticCondition.Ptr	SDL_HapticCondition.Ptr.reinterpret(long newSize)	Assume the SDL_HapticCondition.Ptr is capable of holding at least newSize structures, create a new view SDL_HapticCondition.Ptr that uses the same backing storage as this SDL_HapticCondition.Ptr, but with the new size.
@NotNull SDL_HapticConstant.Ptr	SDL_HapticConstant.Ptr.reinterpret(long newSize)	Assume the SDL_HapticConstant.Ptr is capable of holding at least newSize structures, create a new view SDL_HapticConstant.Ptr that uses the same backing storage as this SDL_HapticConstant.Ptr, but with the new size.
@NotNull SDL_HapticCustom.Ptr	SDL_HapticCustom.Ptr.reinterpret(long newSize)	Assume the SDL_HapticCustom.Ptr is capable of holding at least newSize structures, create a new view SDL_HapticCustom.Ptr that uses the same backing storage as this SDL_HapticCustom.Ptr, but with the new size.
@NotNull SDL_HapticDirection.Ptr	SDL_HapticDirection.Ptr.reinterpret(long newSize)	Assume the SDL_HapticDirection.Ptr is capable of holding at least newSize structures, create a new view SDL_HapticDirection.Ptr that uses the same backing storage as this SDL_HapticDirection.Ptr, but with the new size.
@NotNull SDL_HapticEffect.Ptr	SDL_HapticEffect.Ptr.reinterpret(long newSize)	Assume the SDL_HapticEffect.Ptr is capable of holding at least newSize structures, create a new view SDL_HapticEffect.Ptr that uses the same backing storage as this SDL_HapticEffect.Ptr, but with the new size.
@NotNull SDL_HapticLeftRight.Ptr	SDL_HapticLeftRight.Ptr.reinterpret(long newSize)	Assume the SDL_HapticLeftRight.Ptr is capable of holding at least newSize structures, create a new view SDL_HapticLeftRight.Ptr that uses the same backing storage as this SDL_HapticLeftRight.Ptr, but with the new size.
@NotNull SDL_HapticPeriodic.Ptr	SDL_HapticPeriodic.Ptr.reinterpret(long newSize)	Assume the SDL_HapticPeriodic.Ptr is capable of holding at least newSize structures, create a new view SDL_HapticPeriodic.Ptr that uses the same backing storage as this SDL_HapticPeriodic.Ptr, but with the new size.
@NotNull SDL_HapticRamp.Ptr	SDL_HapticRamp.Ptr.reinterpret(long newSize)	Assume the SDL_HapticRamp.Ptr is capable of holding at least newSize structures, create a new view SDL_HapticRamp.Ptr that uses the same backing storage as this SDL_HapticRamp.Ptr, but with the new size.
@NotNull SDL_hid_device_info.Ptr	SDL_hid_device_info.Ptr.reinterpret(long newSize)	Assume the SDL_hid_device_info.Ptr is capable of holding at least newSize structures, create a new view SDL_hid_device_info.Ptr that uses the same backing storage as this SDL_hid_device_info.Ptr, but with the new size.
@NotNull SDL_InitState.Ptr	SDL_InitState.Ptr.reinterpret(long newSize)	Assume the SDL_InitState.Ptr is capable of holding at least newSize structures, create a new view SDL_InitState.Ptr that uses the same backing storage as this SDL_InitState.Ptr, but with the new size.
@NotNull SDL_IOStreamInterface.Ptr	SDL_IOStreamInterface.Ptr.reinterpret(long newSize)	Assume the SDL_IOStreamInterface.Ptr is capable of holding at least newSize structures, create a new view SDL_IOStreamInterface.Ptr that uses the same backing storage as this SDL_IOStreamInterface.Ptr, but with the new size.
@NotNull SDL_JoyAxisEvent.Ptr	SDL_JoyAxisEvent.Ptr.reinterpret(long newSize)	Assume the SDL_JoyAxisEvent.Ptr is capable of holding at least newSize structures, create a new view SDL_JoyAxisEvent.Ptr that uses the same backing storage as this SDL_JoyAxisEvent.Ptr, but with the new size.
@NotNull SDL_JoyBallEvent.Ptr	SDL_JoyBallEvent.Ptr.reinterpret(long newSize)	Assume the SDL_JoyBallEvent.Ptr is capable of holding at least newSize structures, create a new view SDL_JoyBallEvent.Ptr that uses the same backing storage as this SDL_JoyBallEvent.Ptr, but with the new size.
@NotNull SDL_JoyBatteryEvent.Ptr	SDL_JoyBatteryEvent.Ptr.reinterpret(long newSize)	Assume the SDL_JoyBatteryEvent.Ptr is capable of holding at least newSize structures, create a new view SDL_JoyBatteryEvent.Ptr that uses the same backing storage as this SDL_JoyBatteryEvent.Ptr, but with the new size.
@NotNull SDL_JoyButtonEvent.Ptr	SDL_JoyButtonEvent.Ptr.reinterpret(long newSize)	Assume the SDL_JoyButtonEvent.Ptr is capable of holding at least newSize structures, create a new view SDL_JoyButtonEvent.Ptr that uses the same backing storage as this SDL_JoyButtonEvent.Ptr, but with the new size.
@NotNull SDL_JoyDeviceEvent.Ptr	SDL_JoyDeviceEvent.Ptr.reinterpret(long newSize)	Assume the SDL_JoyDeviceEvent.Ptr is capable of holding at least newSize structures, create a new view SDL_JoyDeviceEvent.Ptr that uses the same backing storage as this SDL_JoyDeviceEvent.Ptr, but with the new size.
@NotNull SDL_JoyHatEvent.Ptr	SDL_JoyHatEvent.Ptr.reinterpret(long newSize)	Assume the SDL_JoyHatEvent.Ptr is capable of holding at least newSize structures, create a new view SDL_JoyHatEvent.Ptr that uses the same backing storage as this SDL_JoyHatEvent.Ptr, but with the new size.
@NotNull SDL_KeyboardDeviceEvent.Ptr	SDL_KeyboardDeviceEvent.Ptr.reinterpret(long newSize)	Assume the SDL_KeyboardDeviceEvent.Ptr is capable of holding at least newSize structures, create a new view SDL_KeyboardDeviceEvent.Ptr that uses the same backing storage as this SDL_KeyboardDeviceEvent.Ptr, but with the new size.
@NotNull SDL_KeyboardEvent.Ptr	SDL_KeyboardEvent.Ptr.reinterpret(long newSize)	Assume the SDL_KeyboardEvent.Ptr is capable of holding at least newSize structures, create a new view SDL_KeyboardEvent.Ptr that uses the same backing storage as this SDL_KeyboardEvent.Ptr, but with the new size.
@NotNull SDL_Locale.Ptr	SDL_Locale.Ptr.reinterpret(long newSize)	Assume the SDL_Locale.Ptr is capable of holding at least newSize structures, create a new view SDL_Locale.Ptr that uses the same backing storage as this SDL_Locale.Ptr, but with the new size.
@NotNull SDL_MessageBoxButtonData.Ptr	SDL_MessageBoxButtonData.Ptr.reinterpret(long newSize)	Assume the SDL_MessageBoxButtonData.Ptr is capable of holding at least newSize structures, create a new view SDL_MessageBoxButtonData.Ptr that uses the same backing storage as this SDL_MessageBoxButtonData.Ptr, but with the new size.
@NotNull SDL_MessageBoxColor.Ptr	SDL_MessageBoxColor.Ptr.reinterpret(long newSize)	Assume the SDL_MessageBoxColor.Ptr is capable of holding at least newSize structures, create a new view SDL_MessageBoxColor.Ptr that uses the same backing storage as this SDL_MessageBoxColor.Ptr, but with the new size.
@NotNull SDL_MessageBoxColorScheme.Ptr	SDL_MessageBoxColorScheme.Ptr.reinterpret(long newSize)	Assume the SDL_MessageBoxColorScheme.Ptr is capable of holding at least newSize structures, create a new view SDL_MessageBoxColorScheme.Ptr that uses the same backing storage as this SDL_MessageBoxColorScheme.Ptr, but with the new size.
@NotNull SDL_MessageBoxData.Ptr	SDL_MessageBoxData.Ptr.reinterpret(long newSize)	Assume the SDL_MessageBoxData.Ptr is capable of holding at least newSize structures, create a new view SDL_MessageBoxData.Ptr that uses the same backing storage as this SDL_MessageBoxData.Ptr, but with the new size.
@NotNull SDL_MouseButtonEvent.Ptr	SDL_MouseButtonEvent.Ptr.reinterpret(long newSize)	Assume the SDL_MouseButtonEvent.Ptr is capable of holding at least newSize structures, create a new view SDL_MouseButtonEvent.Ptr that uses the same backing storage as this SDL_MouseButtonEvent.Ptr, but with the new size.
@NotNull SDL_MouseDeviceEvent.Ptr	SDL_MouseDeviceEvent.Ptr.reinterpret(long newSize)	Assume the SDL_MouseDeviceEvent.Ptr is capable of holding at least newSize structures, create a new view SDL_MouseDeviceEvent.Ptr that uses the same backing storage as this SDL_MouseDeviceEvent.Ptr, but with the new size.
@NotNull SDL_MouseMotionEvent.Ptr	SDL_MouseMotionEvent.Ptr.reinterpret(long newSize)	Assume the SDL_MouseMotionEvent.Ptr is capable of holding at least newSize structures, create a new view SDL_MouseMotionEvent.Ptr that uses the same backing storage as this SDL_MouseMotionEvent.Ptr, but with the new size.
@NotNull SDL_MouseWheelEvent.Ptr	SDL_MouseWheelEvent.Ptr.reinterpret(long newSize)	Assume the SDL_MouseWheelEvent.Ptr is capable of holding at least newSize structures, create a new view SDL_MouseWheelEvent.Ptr that uses the same backing storage as this SDL_MouseWheelEvent.Ptr, but with the new size.
@NotNull SDL_Palette.Ptr	SDL_Palette.Ptr.reinterpret(long newSize)	Assume the SDL_Palette.Ptr is capable of holding at least newSize structures, create a new view SDL_Palette.Ptr that uses the same backing storage as this SDL_Palette.Ptr, but with the new size.
@NotNull SDL_PathInfo.Ptr	SDL_PathInfo.Ptr.reinterpret(long newSize)	Assume the SDL_PathInfo.Ptr is capable of holding at least newSize structures, create a new view SDL_PathInfo.Ptr that uses the same backing storage as this SDL_PathInfo.Ptr, but with the new size.
@NotNull SDL_PenAxisEvent.Ptr	SDL_PenAxisEvent.Ptr.reinterpret(long newSize)	Assume the SDL_PenAxisEvent.Ptr is capable of holding at least newSize structures, create a new view SDL_PenAxisEvent.Ptr that uses the same backing storage as this SDL_PenAxisEvent.Ptr, but with the new size.
@NotNull SDL_PenButtonEvent.Ptr	SDL_PenButtonEvent.Ptr.reinterpret(long newSize)	Assume the SDL_PenButtonEvent.Ptr is capable of holding at least newSize structures, create a new view SDL_PenButtonEvent.Ptr that uses the same backing storage as this SDL_PenButtonEvent.Ptr, but with the new size.
@NotNull SDL_PenMotionEvent.Ptr	SDL_PenMotionEvent.Ptr.reinterpret(long newSize)	Assume the SDL_PenMotionEvent.Ptr is capable of holding at least newSize structures, create a new view SDL_PenMotionEvent.Ptr that uses the same backing storage as this SDL_PenMotionEvent.Ptr, but with the new size.
@NotNull SDL_PenProximityEvent.Ptr	SDL_PenProximityEvent.Ptr.reinterpret(long newSize)	Assume the SDL_PenProximityEvent.Ptr is capable of holding at least newSize structures, create a new view SDL_PenProximityEvent.Ptr that uses the same backing storage as this SDL_PenProximityEvent.Ptr, but with the new size.
@NotNull SDL_PenTouchEvent.Ptr	SDL_PenTouchEvent.Ptr.reinterpret(long newSize)	Assume the SDL_PenTouchEvent.Ptr is capable of holding at least newSize structures, create a new view SDL_PenTouchEvent.Ptr that uses the same backing storage as this SDL_PenTouchEvent.Ptr, but with the new size.
@NotNull SDL_PixelFormatDetails.Ptr	SDL_PixelFormatDetails.Ptr.reinterpret(long newSize)	Assume the SDL_PixelFormatDetails.Ptr is capable of holding at least newSize structures, create a new view SDL_PixelFormatDetails.Ptr that uses the same backing storage as this SDL_PixelFormatDetails.Ptr, but with the new size.
@NotNull SDL_Point.Ptr	SDL_Point.Ptr.reinterpret(long newSize)	Assume the SDL_Point.Ptr is capable of holding at least newSize structures, create a new view SDL_Point.Ptr that uses the same backing storage as this SDL_Point.Ptr, but with the new size.
@NotNull SDL_QuitEvent.Ptr	SDL_QuitEvent.Ptr.reinterpret(long newSize)	Assume the SDL_QuitEvent.Ptr is capable of holding at least newSize structures, create a new view SDL_QuitEvent.Ptr that uses the same backing storage as this SDL_QuitEvent.Ptr, but with the new size.
@NotNull SDL_Rect.Ptr	SDL_Rect.Ptr.reinterpret(long newSize)	Assume the SDL_Rect.Ptr is capable of holding at least newSize structures, create a new view SDL_Rect.Ptr that uses the same backing storage as this SDL_Rect.Ptr, but with the new size.
@NotNull SDL_RenderEvent.Ptr	SDL_RenderEvent.Ptr.reinterpret(long newSize)	Assume the SDL_RenderEvent.Ptr is capable of holding at least newSize structures, create a new view SDL_RenderEvent.Ptr that uses the same backing storage as this SDL_RenderEvent.Ptr, but with the new size.
@NotNull SDL_SensorEvent.Ptr	SDL_SensorEvent.Ptr.reinterpret(long newSize)	Assume the SDL_SensorEvent.Ptr is capable of holding at least newSize structures, create a new view SDL_SensorEvent.Ptr that uses the same backing storage as this SDL_SensorEvent.Ptr, but with the new size.
@NotNull SDL_StorageInterface.Ptr	SDL_StorageInterface.Ptr.reinterpret(long newSize)	Assume the SDL_StorageInterface.Ptr is capable of holding at least newSize structures, create a new view SDL_StorageInterface.Ptr that uses the same backing storage as this SDL_StorageInterface.Ptr, but with the new size.
@NotNull SDL_TextEditingCandidatesEvent.Ptr	SDL_TextEditingCandidatesEvent.Ptr.reinterpret(long newSize)	Assume the SDL_TextEditingCandidatesEvent.Ptr is capable of holding at least newSize structures, create a new view SDL_TextEditingCandidatesEvent.Ptr that uses the same backing storage as this SDL_TextEditingCandidatesEvent.Ptr, but with the new size.
@NotNull SDL_TextEditingEvent.Ptr	SDL_TextEditingEvent.Ptr.reinterpret(long newSize)	Assume the SDL_TextEditingEvent.Ptr is capable of holding at least newSize structures, create a new view SDL_TextEditingEvent.Ptr that uses the same backing storage as this SDL_TextEditingEvent.Ptr, but with the new size.
@NotNull SDL_TextInputEvent.Ptr	SDL_TextInputEvent.Ptr.reinterpret(long newSize)	Assume the SDL_TextInputEvent.Ptr is capable of holding at least newSize structures, create a new view SDL_TextInputEvent.Ptr that uses the same backing storage as this SDL_TextInputEvent.Ptr, but with the new size.
@NotNull SDL_TouchFingerEvent.Ptr	SDL_TouchFingerEvent.Ptr.reinterpret(long newSize)	Assume the SDL_TouchFingerEvent.Ptr is capable of holding at least newSize structures, create a new view SDL_TouchFingerEvent.Ptr that uses the same backing storage as this SDL_TouchFingerEvent.Ptr, but with the new size.
@NotNull SDL_UserEvent.Ptr	SDL_UserEvent.Ptr.reinterpret(long newSize)	Assume the SDL_UserEvent.Ptr is capable of holding at least newSize structures, create a new view SDL_UserEvent.Ptr that uses the same backing storage as this SDL_UserEvent.Ptr, but with the new size.
@NotNull SDL_Vertex.Ptr	SDL_Vertex.Ptr.reinterpret(long newSize)	Assume the SDL_Vertex.Ptr is capable of holding at least newSize structures, create a new view SDL_Vertex.Ptr that uses the same backing storage as this SDL_Vertex.Ptr, but with the new size.
@NotNull SDL_VirtualJoystickDesc.Ptr	SDL_VirtualJoystickDesc.Ptr.reinterpret(long newSize)	Assume the SDL_VirtualJoystickDesc.Ptr is capable of holding at least newSize structures, create a new view SDL_VirtualJoystickDesc.Ptr that uses the same backing storage as this SDL_VirtualJoystickDesc.Ptr, but with the new size.
@NotNull SDL_VirtualJoystickSensorDesc.Ptr	SDL_VirtualJoystickSensorDesc.Ptr.reinterpret(long newSize)	Assume the SDL_VirtualJoystickSensorDesc.Ptr is capable of holding at least newSize structures, create a new view SDL_VirtualJoystickSensorDesc.Ptr that uses the same backing storage as this SDL_VirtualJoystickSensorDesc.Ptr, but with the new size.
@NotNull SDL_VirtualJoystickTouchpadDesc.Ptr	SDL_VirtualJoystickTouchpadDesc.Ptr.reinterpret(long newSize)	Assume the SDL_VirtualJoystickTouchpadDesc.Ptr is capable of holding at least newSize structures, create a new view SDL_VirtualJoystickTouchpadDesc.Ptr that uses the same backing storage as this SDL_VirtualJoystickTouchpadDesc.Ptr, but with the new size.
@NotNull SDL_WindowEvent.Ptr	SDL_WindowEvent.Ptr.reinterpret(long newSize)	Assume the SDL_WindowEvent.Ptr is capable of holding at least newSize structures, create a new view SDL_WindowEvent.Ptr that uses the same backing storage as this SDL_WindowEvent.Ptr, but with the new size.
SDL_VirtualJoystickSensorDesc.Ptr	SDL_VirtualJoystickDesc.sensors(int assumedCount)
SDL_VirtualJoystickTouchpadDesc.Ptr	SDL_VirtualJoystickDesc.touchpads(int assumedCount)
SDL_GPUVertexAttribute.Ptr	SDL_GPUVertexInputState.vertex_attributes(int assumedCount)
SDL_GPUVertexBufferDescription.Ptr	SDL_GPUVertexInputState.vertex_buffer_descriptions(int assumedCount)

Uses of Unsafe in club.doki7.sdl3.handle

Methods in club.doki7.sdl3.handle with annotations of type Unsafe

Modifier and Type	Method	Description
MSG.Ptr	MSG.Ptr.reinterpret(long newSize)	Assume the MSG.Ptr is capable of holding at least newSize handles, create a new view MSG.Ptr that uses the same backing storage as this MSG.Ptr, but with the new size.
SDL_AsyncIO.Ptr	SDL_AsyncIO.Ptr.reinterpret(long newSize)	Assume the SDL_AsyncIO.Ptr is capable of holding at least newSize handles, create a new view SDL_AsyncIO.Ptr that uses the same backing storage as this SDL_AsyncIO.Ptr, but with the new size.
SDL_AsyncIOQueue.Ptr	SDL_AsyncIOQueue.Ptr.reinterpret(long newSize)	Assume the SDL_AsyncIOQueue.Ptr is capable of holding at least newSize handles, create a new view SDL_AsyncIOQueue.Ptr that uses the same backing storage as this SDL_AsyncIOQueue.Ptr, but with the new size.
SDL_AudioStream.Ptr	SDL_AudioStream.Ptr.reinterpret(long newSize)	Assume the SDL_AudioStream.Ptr is capable of holding at least newSize handles, create a new view SDL_AudioStream.Ptr that uses the same backing storage as this SDL_AudioStream.Ptr, but with the new size.
SDL_Camera.Ptr	SDL_Camera.Ptr.reinterpret(long newSize)	Assume the SDL_Camera.Ptr is capable of holding at least newSize handles, create a new view SDL_Camera.Ptr that uses the same backing storage as this SDL_Camera.Ptr, but with the new size.
SDL_Condition.Ptr	SDL_Condition.Ptr.reinterpret(long newSize)	Assume the SDL_Condition.Ptr is capable of holding at least newSize handles, create a new view SDL_Condition.Ptr that uses the same backing storage as this SDL_Condition.Ptr, but with the new size.
SDL_Cursor.Ptr	SDL_Cursor.Ptr.reinterpret(long newSize)	Assume the SDL_Cursor.Ptr is capable of holding at least newSize handles, create a new view SDL_Cursor.Ptr that uses the same backing storage as this SDL_Cursor.Ptr, but with the new size.
SDL_DisplayModeData.Ptr	SDL_DisplayModeData.Ptr.reinterpret(long newSize)	Assume the SDL_DisplayModeData.Ptr is capable of holding at least newSize handles, create a new view SDL_DisplayModeData.Ptr that uses the same backing storage as this SDL_DisplayModeData.Ptr, but with the new size.
SDL_Environment.Ptr	SDL_Environment.Ptr.reinterpret(long newSize)	Assume the SDL_Environment.Ptr is capable of holding at least newSize handles, create a new view SDL_Environment.Ptr that uses the same backing storage as this SDL_Environment.Ptr, but with the new size.
SDL_Gamepad.Ptr	SDL_Gamepad.Ptr.reinterpret(long newSize)	Assume the SDL_Gamepad.Ptr is capable of holding at least newSize handles, create a new view SDL_Gamepad.Ptr that uses the same backing storage as this SDL_Gamepad.Ptr, but with the new size.
SDL_GLContext.Ptr	SDL_GLContext.Ptr.reinterpret(long newSize)	Assume the SDL_GLContext.Ptr is capable of holding at least newSize handles, create a new view SDL_GLContext.Ptr that uses the same backing storage as this SDL_GLContext.Ptr, but with the new size.
SDL_GPUBuffer.Ptr	SDL_GPUBuffer.Ptr.reinterpret(long newSize)	Assume the SDL_GPUBuffer.Ptr is capable of holding at least newSize handles, create a new view SDL_GPUBuffer.Ptr that uses the same backing storage as this SDL_GPUBuffer.Ptr, but with the new size.
SDL_GPUCommandBuffer.Ptr	SDL_GPUCommandBuffer.Ptr.reinterpret(long newSize)	Assume the SDL_GPUCommandBuffer.Ptr is capable of holding at least newSize handles, create a new view SDL_GPUCommandBuffer.Ptr that uses the same backing storage as this SDL_GPUCommandBuffer.Ptr, but with the new size.
SDL_GPUComputePass.Ptr	SDL_GPUComputePass.Ptr.reinterpret(long newSize)	Assume the SDL_GPUComputePass.Ptr is capable of holding at least newSize handles, create a new view SDL_GPUComputePass.Ptr that uses the same backing storage as this SDL_GPUComputePass.Ptr, but with the new size.
SDL_GPUComputePipeline.Ptr	SDL_GPUComputePipeline.Ptr.reinterpret(long newSize)	Assume the SDL_GPUComputePipeline.Ptr is capable of holding at least newSize handles, create a new view SDL_GPUComputePipeline.Ptr that uses the same backing storage as this SDL_GPUComputePipeline.Ptr, but with the new size.
SDL_GPUCopyPass.Ptr	SDL_GPUCopyPass.Ptr.reinterpret(long newSize)	Assume the SDL_GPUCopyPass.Ptr is capable of holding at least newSize handles, create a new view SDL_GPUCopyPass.Ptr that uses the same backing storage as this SDL_GPUCopyPass.Ptr, but with the new size.
SDL_GPUDevice.Ptr	SDL_GPUDevice.Ptr.reinterpret(long newSize)	Assume the SDL_GPUDevice.Ptr is capable of holding at least newSize handles, create a new view SDL_GPUDevice.Ptr that uses the same backing storage as this SDL_GPUDevice.Ptr, but with the new size.
SDL_GPUFence.Ptr	SDL_GPUFence.Ptr.reinterpret(long newSize)	Assume the SDL_GPUFence.Ptr is capable of holding at least newSize handles, create a new view SDL_GPUFence.Ptr that uses the same backing storage as this SDL_GPUFence.Ptr, but with the new size.
SDL_GPUGraphicsPipeline.Ptr	SDL_GPUGraphicsPipeline.Ptr.reinterpret(long newSize)	Assume the SDL_GPUGraphicsPipeline.Ptr is capable of holding at least newSize handles, create a new view SDL_GPUGraphicsPipeline.Ptr that uses the same backing storage as this SDL_GPUGraphicsPipeline.Ptr, but with the new size.
SDL_GPURenderPass.Ptr	SDL_GPURenderPass.Ptr.reinterpret(long newSize)	Assume the SDL_GPURenderPass.Ptr is capable of holding at least newSize handles, create a new view SDL_GPURenderPass.Ptr that uses the same backing storage as this SDL_GPURenderPass.Ptr, but with the new size.
SDL_GPUSampler.Ptr	SDL_GPUSampler.Ptr.reinterpret(long newSize)	Assume the SDL_GPUSampler.Ptr is capable of holding at least newSize handles, create a new view SDL_GPUSampler.Ptr that uses the same backing storage as this SDL_GPUSampler.Ptr, but with the new size.
SDL_GPUShader.Ptr	SDL_GPUShader.Ptr.reinterpret(long newSize)	Assume the SDL_GPUShader.Ptr is capable of holding at least newSize handles, create a new view SDL_GPUShader.Ptr that uses the same backing storage as this SDL_GPUShader.Ptr, but with the new size.
SDL_GPUTexture.Ptr	SDL_GPUTexture.Ptr.reinterpret(long newSize)	Assume the SDL_GPUTexture.Ptr is capable of holding at least newSize handles, create a new view SDL_GPUTexture.Ptr that uses the same backing storage as this SDL_GPUTexture.Ptr, but with the new size.
SDL_GPUTransferBuffer.Ptr	SDL_GPUTransferBuffer.Ptr.reinterpret(long newSize)	Assume the SDL_GPUTransferBuffer.Ptr is capable of holding at least newSize handles, create a new view SDL_GPUTransferBuffer.Ptr that uses the same backing storage as this SDL_GPUTransferBuffer.Ptr, but with the new size.
SDL_Haptic.Ptr	SDL_Haptic.Ptr.reinterpret(long newSize)	Assume the SDL_Haptic.Ptr is capable of holding at least newSize handles, create a new view SDL_Haptic.Ptr that uses the same backing storage as this SDL_Haptic.Ptr, but with the new size.
SDL_hid_device.Ptr	SDL_hid_device.Ptr.reinterpret(long newSize)	Assume the SDL_hid_device.Ptr is capable of holding at least newSize handles, create a new view SDL_hid_device.Ptr that uses the same backing storage as this SDL_hid_device.Ptr, but with the new size.
SDL_iconv_t.Ptr	SDL_iconv_t.Ptr.reinterpret(long newSize)	Assume the SDL_iconv_t.Ptr is capable of holding at least newSize handles, create a new view SDL_iconv_t.Ptr that uses the same backing storage as this SDL_iconv_t.Ptr, but with the new size.
SDL_IOStream.Ptr	SDL_IOStream.Ptr.reinterpret(long newSize)	Assume the SDL_IOStream.Ptr is capable of holding at least newSize handles, create a new view SDL_IOStream.Ptr that uses the same backing storage as this SDL_IOStream.Ptr, but with the new size.
SDL_Joystick.Ptr	SDL_Joystick.Ptr.reinterpret(long newSize)	Assume the SDL_Joystick.Ptr is capable of holding at least newSize handles, create a new view SDL_Joystick.Ptr that uses the same backing storage as this SDL_Joystick.Ptr, but with the new size.
SDL_Mutex.Ptr	SDL_Mutex.Ptr.reinterpret(long newSize)	Assume the SDL_Mutex.Ptr is capable of holding at least newSize handles, create a new view SDL_Mutex.Ptr that uses the same backing storage as this SDL_Mutex.Ptr, but with the new size.
SDL_Process.Ptr	SDL_Process.Ptr.reinterpret(long newSize)	Assume the SDL_Process.Ptr is capable of holding at least newSize handles, create a new view SDL_Process.Ptr that uses the same backing storage as this SDL_Process.Ptr, but with the new size.
SDL_Renderer.Ptr	SDL_Renderer.Ptr.reinterpret(long newSize)	Assume the SDL_Renderer.Ptr is capable of holding at least newSize handles, create a new view SDL_Renderer.Ptr that uses the same backing storage as this SDL_Renderer.Ptr, but with the new size.
SDL_RWLock.Ptr	SDL_RWLock.Ptr.reinterpret(long newSize)	Assume the SDL_RWLock.Ptr is capable of holding at least newSize handles, create a new view SDL_RWLock.Ptr that uses the same backing storage as this SDL_RWLock.Ptr, but with the new size.
SDL_Semaphore.Ptr	SDL_Semaphore.Ptr.reinterpret(long newSize)	Assume the SDL_Semaphore.Ptr is capable of holding at least newSize handles, create a new view SDL_Semaphore.Ptr that uses the same backing storage as this SDL_Semaphore.Ptr, but with the new size.
SDL_Sensor.Ptr	SDL_Sensor.Ptr.reinterpret(long newSize)	Assume the SDL_Sensor.Ptr is capable of holding at least newSize handles, create a new view SDL_Sensor.Ptr that uses the same backing storage as this SDL_Sensor.Ptr, but with the new size.
SDL_SharedObject.Ptr	SDL_SharedObject.Ptr.reinterpret(long newSize)	Assume the SDL_SharedObject.Ptr is capable of holding at least newSize handles, create a new view SDL_SharedObject.Ptr that uses the same backing storage as this SDL_SharedObject.Ptr, but with the new size.
SDL_Storage.Ptr	SDL_Storage.Ptr.reinterpret(long newSize)	Assume the SDL_Storage.Ptr is capable of holding at least newSize handles, create a new view SDL_Storage.Ptr that uses the same backing storage as this SDL_Storage.Ptr, but with the new size.
SDL_Surface.Ptr	SDL_Surface.Ptr.reinterpret(long newSize)	Assume the SDL_Surface.Ptr is capable of holding at least newSize handles, create a new view SDL_Surface.Ptr that uses the same backing storage as this SDL_Surface.Ptr, but with the new size.
SDL_Texture.Ptr	SDL_Texture.Ptr.reinterpret(long newSize)	Assume the SDL_Texture.Ptr is capable of holding at least newSize handles, create a new view SDL_Texture.Ptr that uses the same backing storage as this SDL_Texture.Ptr, but with the new size.
SDL_Thread.Ptr	SDL_Thread.Ptr.reinterpret(long newSize)	Assume the SDL_Thread.Ptr is capable of holding at least newSize handles, create a new view SDL_Thread.Ptr that uses the same backing storage as this SDL_Thread.Ptr, but with the new size.
SDL_Tray.Ptr	SDL_Tray.Ptr.reinterpret(long newSize)	Assume the SDL_Tray.Ptr is capable of holding at least newSize handles, create a new view SDL_Tray.Ptr that uses the same backing storage as this SDL_Tray.Ptr, but with the new size.
SDL_TrayEntry.Ptr	SDL_TrayEntry.Ptr.reinterpret(long newSize)	Assume the SDL_TrayEntry.Ptr is capable of holding at least newSize handles, create a new view SDL_TrayEntry.Ptr that uses the same backing storage as this SDL_TrayEntry.Ptr, but with the new size.
SDL_TrayMenu.Ptr	SDL_TrayMenu.Ptr.reinterpret(long newSize)	Assume the SDL_TrayMenu.Ptr is capable of holding at least newSize handles, create a new view SDL_TrayMenu.Ptr that uses the same backing storage as this SDL_TrayMenu.Ptr, but with the new size.
SDL_Window.Ptr	SDL_Window.Ptr.reinterpret(long newSize)	Assume the SDL_Window.Ptr is capable of holding at least newSize handles, create a new view SDL_Window.Ptr that uses the same backing storage as this SDL_Window.Ptr, but with the new size.
XTaskQueueHandle.Ptr	XTaskQueueHandle.Ptr.reinterpret(long newSize)	Assume the XTaskQueueHandle.Ptr is capable of holding at least newSize handles, create a new view XTaskQueueHandle.Ptr that uses the same backing storage as this XTaskQueueHandle.Ptr, but with the new size.
XUserHandle.Ptr	XUserHandle.Ptr.reinterpret(long newSize)	Assume the XUserHandle.Ptr is capable of holding at least newSize handles, create a new view XUserHandle.Ptr that uses the same backing storage as this XUserHandle.Ptr, but with the new size.

Uses of Unsafe in club.doki7.shaderc.datatype

Methods in club.doki7.shaderc.datatype with annotations of type Unsafe

Modifier and Type	Method	Description
@NotNull ShadercIncludeResult.Ptr	ShadercIncludeResult.Ptr.reinterpret(long newSize)	Assume the ShadercIncludeResult.Ptr is capable of holding at least newSize structures, create a new view ShadercIncludeResult.Ptr that uses the same backing storage as this ShadercIncludeResult.Ptr, but with the new size.

Uses of Unsafe in club.doki7.shaderc.handle

Methods in club.doki7.shaderc.handle with annotations of type Unsafe

Modifier and Type	Method	Description
ShadercCompilationResult.Ptr	ShadercCompilationResult.Ptr.reinterpret(long newSize)	Assume the ShadercCompilationResult.Ptr is capable of holding at least newSize handles, create a new view ShadercCompilationResult.Ptr that uses the same backing storage as this ShadercCompilationResult.Ptr, but with the new size.
ShadercCompileOptions.Ptr	ShadercCompileOptions.Ptr.reinterpret(long newSize)	Assume the ShadercCompileOptions.Ptr is capable of holding at least newSize handles, create a new view ShadercCompileOptions.Ptr that uses the same backing storage as this ShadercCompileOptions.Ptr, but with the new size.
ShadercCompiler.Ptr	ShadercCompiler.Ptr.reinterpret(long newSize)	Assume the ShadercCompiler.Ptr is capable of holding at least newSize handles, create a new view ShadercCompiler.Ptr that uses the same backing storage as this ShadercCompiler.Ptr, but with the new size.

Uses of Unsafe in club.doki7.stb.image.datatype

Methods in club.doki7.stb.image.datatype with annotations of type Unsafe

Modifier and Type	Method	Description
@NotNull STBI_IoCallbacks.Ptr	STBI_IoCallbacks.Ptr.reinterpret(long newSize)	Assume the STBI_IoCallbacks.Ptr is capable of holding at least newSize structures, create a new view STBI_IoCallbacks.Ptr that uses the same backing storage as this STBI_IoCallbacks.Ptr, but with the new size.

Uses of Unsafe in club.doki7.stb.imageresize.datatype

Methods in club.doki7.stb.imageresize.datatype with annotations of type Unsafe

Modifier and Type	Method	Description
@NotNull STBIR_PROFILEINFO.Ptr	STBIR_PROFILEINFO.Ptr.reinterpret(long newSize)	Assume the STBIR_PROFILEINFO.Ptr is capable of holding at least newSize structures, create a new view STBIR_PROFILEINFO.Ptr that uses the same backing storage as this STBIR_PROFILEINFO.Ptr, but with the new size.
@NotNull STBIR_RESIZE.Ptr	STBIR_RESIZE.Ptr.reinterpret(long newSize)	Assume the STBIR_RESIZE.Ptr is capable of holding at least newSize structures, create a new view STBIR_RESIZE.Ptr that uses the same backing storage as this STBIR_RESIZE.Ptr, but with the new size.

Uses of Unsafe in club.doki7.stb.imageresize.handle

Methods in club.doki7.stb.imageresize.handle with annotations of type Unsafe

Modifier and Type	Method	Description
STBIR_Info.Ptr	STBIR_Info.Ptr.reinterpret(long newSize)	Assume the STBIR_Info.Ptr is capable of holding at least newSize handles, create a new view STBIR_Info.Ptr that uses the same backing storage as this STBIR_Info.Ptr, but with the new size.

Uses of Unsafe in club.doki7.stb.truetype.datatype

Methods in club.doki7.stb.truetype.datatype with annotations of type Unsafe

Modifier and Type	Method	Description
STBTT_Packedchar.Ptr	STBTT_PackRange.chardataForRange(int assumedCount)
@NotNull STBTT_AlignedQuad.Ptr	STBTT_AlignedQuad.Ptr.reinterpret(long newSize)	Assume the STBTT_AlignedQuad.Ptr is capable of holding at least newSize structures, create a new view STBTT_AlignedQuad.Ptr that uses the same backing storage as this STBTT_AlignedQuad.Ptr, but with the new size.
@NotNull STBTT_Bakedchar.Ptr	STBTT_Bakedchar.Ptr.reinterpret(long newSize)	Assume the STBTT_Bakedchar.Ptr is capable of holding at least newSize structures, create a new view STBTT_Bakedchar.Ptr that uses the same backing storage as this STBTT_Bakedchar.Ptr, but with the new size.
@NotNull STBTT_Bitmap.Ptr	STBTT_Bitmap.Ptr.reinterpret(long newSize)	Assume the STBTT_Bitmap.Ptr is capable of holding at least newSize structures, create a new view STBTT_Bitmap.Ptr that uses the same backing storage as this STBTT_Bitmap.Ptr, but with the new size.
@NotNull STBTT_Buf.Ptr	STBTT_Buf.Ptr.reinterpret(long newSize)	Assume the STBTT_Buf.Ptr is capable of holding at least newSize structures, create a new view STBTT_Buf.Ptr that uses the same backing storage as this STBTT_Buf.Ptr, but with the new size.
@NotNull STBTT_Fontinfo.Ptr	STBTT_Fontinfo.Ptr.reinterpret(long newSize)	Assume the STBTT_Fontinfo.Ptr is capable of holding at least newSize structures, create a new view STBTT_Fontinfo.Ptr that uses the same backing storage as this STBTT_Fontinfo.Ptr, but with the new size.
@NotNull STBTT_Kerningentry.Ptr	STBTT_Kerningentry.Ptr.reinterpret(long newSize)	Assume the STBTT_Kerningentry.Ptr is capable of holding at least newSize structures, create a new view STBTT_Kerningentry.Ptr that uses the same backing storage as this STBTT_Kerningentry.Ptr, but with the new size.
@NotNull STBTT_PackContext.Ptr	STBTT_PackContext.Ptr.reinterpret(long newSize)	Assume the STBTT_PackContext.Ptr is capable of holding at least newSize structures, create a new view STBTT_PackContext.Ptr that uses the same backing storage as this STBTT_PackContext.Ptr, but with the new size.
@NotNull STBTT_Packedchar.Ptr	STBTT_Packedchar.Ptr.reinterpret(long newSize)	Assume the STBTT_Packedchar.Ptr is capable of holding at least newSize structures, create a new view STBTT_Packedchar.Ptr that uses the same backing storage as this STBTT_Packedchar.Ptr, but with the new size.
@NotNull STBTT_PackRange.Ptr	STBTT_PackRange.Ptr.reinterpret(long newSize)	Assume the STBTT_PackRange.Ptr is capable of holding at least newSize structures, create a new view STBTT_PackRange.Ptr that uses the same backing storage as this STBTT_PackRange.Ptr, but with the new size.
@NotNull STBTT_Vertex.Ptr	STBTT_Vertex.Ptr.reinterpret(long newSize)	Assume the STBTT_Vertex.Ptr is capable of holding at least newSize structures, create a new view STBTT_Vertex.Ptr that uses the same backing storage as this STBTT_Vertex.Ptr, but with the new size.

Uses of Unsafe in club.doki7.stb.vorbis.datatype

Methods in club.doki7.stb.vorbis.datatype with annotations of type Unsafe

Modifier and Type	Method	Description
@NotNull STB_VorbisAlloc.Ptr	STB_VorbisAlloc.Ptr.reinterpret(long newSize)	Assume the STB_VorbisAlloc.Ptr is capable of holding at least newSize structures, create a new view STB_VorbisAlloc.Ptr that uses the same backing storage as this STB_VorbisAlloc.Ptr, but with the new size.
@NotNull STB_VorbisComment.Ptr	STB_VorbisComment.Ptr.reinterpret(long newSize)	Assume the STB_VorbisComment.Ptr is capable of holding at least newSize structures, create a new view STB_VorbisComment.Ptr that uses the same backing storage as this STB_VorbisComment.Ptr, but with the new size.
@NotNull STB_VorbisInfo.Ptr	STB_VorbisInfo.Ptr.reinterpret(long newSize)	Assume the STB_VorbisInfo.Ptr is capable of holding at least newSize structures, create a new view STB_VorbisInfo.Ptr that uses the same backing storage as this STB_VorbisInfo.Ptr, but with the new size.

Uses of Unsafe in club.doki7.stb.vorbis.handle

Methods in club.doki7.stb.vorbis.handle with annotations of type Unsafe

Modifier and Type	Method	Description
STB_Vorbis.Ptr	STB_Vorbis.Ptr.reinterpret(long newSize)	Assume the STB_Vorbis.Ptr is capable of holding at least newSize handles, create a new view STB_Vorbis.Ptr that uses the same backing storage as this STB_Vorbis.Ptr, but with the new size.

Uses of Unsafe in club.doki7.vma.datatype

Methods in club.doki7.vma.datatype with annotations of type Unsafe

Modifier and Type	Method	Description
VkAllocationCallbacks.Ptr	VmaAllocatorCreateInfo.pAllocationCallbacks(int assumedCount)
VkAllocationCallbacks.Ptr	VmaVirtualBlockCreateInfo.pAllocationCallbacks(int assumedCount)
VmaDeviceMemoryCallbacks.Ptr	VmaAllocatorCreateInfo.pDeviceMemoryCallbacks(int assumedCount)
VmaDefragmentationMove.Ptr	VmaDefragmentationPassMoveInfo.pMoves(int assumedCount)
VmaVulkanFunctions.Ptr	VmaAllocatorCreateInfo.pVulkanFunctions(int assumedCount)
@NotNull VmaAllocationCreateInfo.Ptr	VmaAllocationCreateInfo.Ptr.reinterpret(long newSize)	Assume the VmaAllocationCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VmaAllocationCreateInfo.Ptr that uses the same backing storage as this VmaAllocationCreateInfo.Ptr, but with the new size.
@NotNull VmaAllocationInfo.Ptr	VmaAllocationInfo.Ptr.reinterpret(long newSize)	Assume the VmaAllocationInfo.Ptr is capable of holding at least newSize structures, create a new view VmaAllocationInfo.Ptr that uses the same backing storage as this VmaAllocationInfo.Ptr, but with the new size.
@NotNull VmaAllocationInfo2.Ptr	VmaAllocationInfo2.Ptr.reinterpret(long newSize)	Assume the VmaAllocationInfo2.Ptr is capable of holding at least newSize structures, create a new view VmaAllocationInfo2.Ptr that uses the same backing storage as this VmaAllocationInfo2.Ptr, but with the new size.
@NotNull VmaAllocatorCreateInfo.Ptr	VmaAllocatorCreateInfo.Ptr.reinterpret(long newSize)	Assume the VmaAllocatorCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VmaAllocatorCreateInfo.Ptr that uses the same backing storage as this VmaAllocatorCreateInfo.Ptr, but with the new size.
@NotNull VmaAllocatorInfo.Ptr	VmaAllocatorInfo.Ptr.reinterpret(long newSize)	Assume the VmaAllocatorInfo.Ptr is capable of holding at least newSize structures, create a new view VmaAllocatorInfo.Ptr that uses the same backing storage as this VmaAllocatorInfo.Ptr, but with the new size.
@NotNull VmaBudget.Ptr	VmaBudget.Ptr.reinterpret(long newSize)	Assume the VmaBudget.Ptr is capable of holding at least newSize structures, create a new view VmaBudget.Ptr that uses the same backing storage as this VmaBudget.Ptr, but with the new size.
@NotNull VmaDefragmentationInfo.Ptr	VmaDefragmentationInfo.Ptr.reinterpret(long newSize)	Assume the VmaDefragmentationInfo.Ptr is capable of holding at least newSize structures, create a new view VmaDefragmentationInfo.Ptr that uses the same backing storage as this VmaDefragmentationInfo.Ptr, but with the new size.
@NotNull VmaDefragmentationMove.Ptr	VmaDefragmentationMove.Ptr.reinterpret(long newSize)	Assume the VmaDefragmentationMove.Ptr is capable of holding at least newSize structures, create a new view VmaDefragmentationMove.Ptr that uses the same backing storage as this VmaDefragmentationMove.Ptr, but with the new size.
@NotNull VmaDefragmentationPassMoveInfo.Ptr	VmaDefragmentationPassMoveInfo.Ptr.reinterpret(long newSize)	Assume the VmaDefragmentationPassMoveInfo.Ptr is capable of holding at least newSize structures, create a new view VmaDefragmentationPassMoveInfo.Ptr that uses the same backing storage as this VmaDefragmentationPassMoveInfo.Ptr, but with the new size.
@NotNull VmaDefragmentationStats.Ptr	VmaDefragmentationStats.Ptr.reinterpret(long newSize)	Assume the VmaDefragmentationStats.Ptr is capable of holding at least newSize structures, create a new view VmaDefragmentationStats.Ptr that uses the same backing storage as this VmaDefragmentationStats.Ptr, but with the new size.
@NotNull VmaDetailedStatistics.Ptr	VmaDetailedStatistics.Ptr.reinterpret(long newSize)	Assume the VmaDetailedStatistics.Ptr is capable of holding at least newSize structures, create a new view VmaDetailedStatistics.Ptr that uses the same backing storage as this VmaDetailedStatistics.Ptr, but with the new size.
@NotNull VmaDeviceMemoryCallbacks.Ptr	VmaDeviceMemoryCallbacks.Ptr.reinterpret(long newSize)	Assume the VmaDeviceMemoryCallbacks.Ptr is capable of holding at least newSize structures, create a new view VmaDeviceMemoryCallbacks.Ptr that uses the same backing storage as this VmaDeviceMemoryCallbacks.Ptr, but with the new size.
@NotNull VmaPoolCreateInfo.Ptr	VmaPoolCreateInfo.Ptr.reinterpret(long newSize)	Assume the VmaPoolCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VmaPoolCreateInfo.Ptr that uses the same backing storage as this VmaPoolCreateInfo.Ptr, but with the new size.
@NotNull VmaStatistics.Ptr	VmaStatistics.Ptr.reinterpret(long newSize)	Assume the VmaStatistics.Ptr is capable of holding at least newSize structures, create a new view VmaStatistics.Ptr that uses the same backing storage as this VmaStatistics.Ptr, but with the new size.
@NotNull VmaTotalStatistics.Ptr	VmaTotalStatistics.Ptr.reinterpret(long newSize)	Assume the VmaTotalStatistics.Ptr is capable of holding at least newSize structures, create a new view VmaTotalStatistics.Ptr that uses the same backing storage as this VmaTotalStatistics.Ptr, but with the new size.
@NotNull VmaVirtualAllocationCreateInfo.Ptr	VmaVirtualAllocationCreateInfo.Ptr.reinterpret(long newSize)	Assume the VmaVirtualAllocationCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VmaVirtualAllocationCreateInfo.Ptr that uses the same backing storage as this VmaVirtualAllocationCreateInfo.Ptr, but with the new size.
@NotNull VmaVirtualAllocationInfo.Ptr	VmaVirtualAllocationInfo.Ptr.reinterpret(long newSize)	Assume the VmaVirtualAllocationInfo.Ptr is capable of holding at least newSize structures, create a new view VmaVirtualAllocationInfo.Ptr that uses the same backing storage as this VmaVirtualAllocationInfo.Ptr, but with the new size.
@NotNull VmaVirtualBlockCreateInfo.Ptr	VmaVirtualBlockCreateInfo.Ptr.reinterpret(long newSize)	Assume the VmaVirtualBlockCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VmaVirtualBlockCreateInfo.Ptr that uses the same backing storage as this VmaVirtualBlockCreateInfo.Ptr, but with the new size.
@NotNull VmaVulkanFunctions.Ptr	VmaVulkanFunctions.Ptr.reinterpret(long newSize)	Assume the VmaVulkanFunctions.Ptr is capable of holding at least newSize structures, create a new view VmaVulkanFunctions.Ptr that uses the same backing storage as this VmaVulkanFunctions.Ptr, but with the new size.

Uses of Unsafe in club.doki7.vma.handle

Methods in club.doki7.vma.handle with annotations of type Unsafe

Modifier and Type	Method	Description
VmaAllocation.Ptr	VmaAllocation.Ptr.reinterpret(long newSize)	Assume the VmaAllocation.Ptr is capable of holding at least newSize handles, create a new view VmaAllocation.Ptr that uses the same backing storage as this VmaAllocation.Ptr, but with the new size.
VmaAllocator.Ptr	VmaAllocator.Ptr.reinterpret(long newSize)	Assume the VmaAllocator.Ptr is capable of holding at least newSize handles, create a new view VmaAllocator.Ptr that uses the same backing storage as this VmaAllocator.Ptr, but with the new size.
VmaDefragmentationContext.Ptr	VmaDefragmentationContext.Ptr.reinterpret(long newSize)	Assume the VmaDefragmentationContext.Ptr is capable of holding at least newSize handles, create a new view VmaDefragmentationContext.Ptr that uses the same backing storage as this VmaDefragmentationContext.Ptr, but with the new size.
VmaPool.Ptr	VmaPool.Ptr.reinterpret(long newSize)	Assume the VmaPool.Ptr is capable of holding at least newSize handles, create a new view VmaPool.Ptr that uses the same backing storage as this VmaPool.Ptr, but with the new size.
VmaVirtualAllocation.Ptr	VmaVirtualAllocation.Ptr.reinterpret(long newSize)	Assume the VmaVirtualAllocation.Ptr is capable of holding at least newSize handles, create a new view VmaVirtualAllocation.Ptr that uses the same backing storage as this VmaVirtualAllocation.Ptr, but with the new size.
VmaVirtualBlock.Ptr	VmaVirtualBlock.Ptr.reinterpret(long newSize)	Assume the VmaVirtualBlock.Ptr is capable of holding at least newSize handles, create a new view VmaVirtualBlock.Ptr that uses the same backing storage as this VmaVirtualBlock.Ptr, but with the new size.

Uses of Unsafe in club.doki7.vulkan.datatype

Methods in club.doki7.vulkan.datatype with annotations of type Unsafe

Modifier and Type	Method	Description
VkDeviceFaultAddressInfoEXT.Ptr	VkDeviceFaultInfoEXT.pAddressInfos(int assumedCount)
VkApplicationInfo.Ptr	VkInstanceCreateInfo.pApplicationInfo(int assumedCount)
VkInputAttachmentAspectReference.Ptr	VkRenderPassInputAttachmentAspectCreateInfo.pAspectReferences(int assumedCount)
VkFramebufferAttachmentImageInfo.Ptr	VkFramebufferAttachmentsCreateInfo.pAttachmentImageInfos(int assumedCount)
VkAttachmentSampleLocationsEXT.Ptr	VkRenderPassSampleLocationsBeginInfoEXT.pAttachmentInitialSampleLocations(int assumedCount)
VkPipelineColorBlendAttachmentState.Ptr	VkPipelineColorBlendStateCreateInfo.pAttachments(int assumedCount)
VkAttachmentDescription.Ptr	VkRenderPassCreateInfo.pAttachments(int assumedCount)
VkAttachmentDescription2.Ptr	VkRenderPassCreateInfo2.pAttachments(int assumedCount)
VkDescriptorSetLayoutBinding.Ptr	VkDescriptorSetLayoutCreateInfo.pBindings(int assumedCount)
VkSparseMemoryBind.Ptr	VkSparseBufferMemoryBindInfo.pBinds(int assumedCount)
VkSparseImageMemoryBind.Ptr	VkSparseImageMemoryBindInfo.pBinds(int assumedCount)
VkSparseMemoryBind.Ptr	VkSparseImageOpaqueMemoryBindInfo.pBinds(int assumedCount)
VkSparseBufferMemoryBindInfo.Ptr	VkBindSparseInfo.pBufferBinds(int assumedCount)
VkDescriptorBufferInfo.Ptr	VkWriteDescriptorSet.pBufferInfo(int assumedCount)
VkBufferMemoryBarrier2.Ptr	VkDependencyInfo.pBufferMemoryBarriers(int assumedCount)
StdVideoAV1CDEF.Ptr	StdVideoDecodeAV1PictureInfo.pCDEF(int assumedCount)
StdVideoAV1CDEF.Ptr	StdVideoEncodeAV1PictureInfo.pCDEF(int assumedCount)
VkClearValue.Ptr	VkRenderPassBeginInfo.pClearValues(int assumedCount)
VkClusterAccelerationStructureClustersBottomLevelInputNV.Ptr	VkClusterAccelerationStructureOpInputNV.pClustersBottomLevel(int assumedCount)
VkDebugUtilsLabelEXT.Ptr	VkDebugUtilsMessengerCallbackDataEXT.pCmdBufLabels(int assumedCount)
VkRenderingAttachmentInfo.Ptr	VkRenderingInfo.pColorAttachments(int assumedCount)
VkAttachmentReference.Ptr	VkSubpassDescription.pColorAttachments(int assumedCount)
VkAttachmentReference2.Ptr	VkSubpassDescription2.pColorAttachments(int assumedCount)
VkPipelineColorBlendStateCreateInfo.Ptr	VkGraphicsPipelineCreateInfo.pColorBlendState(int assumedCount)
StdVideoAV1ColorConfig.Ptr	StdVideoAV1SequenceHeader.pColorConfig(int assumedCount)
VkSysmemColorSpaceFUCHSIA.Ptr	VkImageFormatConstraintsInfoFUCHSIA.pColorSpaces(int assumedCount)
VkDescriptorImageInfo.Ptr	VkDescriptorDataEXT.pCombinedImageSampler(int assumedCount)
VkCommandBufferSubmitInfo.Ptr	VkSubmitInfo2.pCommandBufferInfos(int assumedCount)
VkBufferCreateInfo.Ptr	VkDeviceBufferMemoryRequirements.pCreateInfo(int assumedCount)
VkImageCreateInfo.Ptr	VkDeviceImageMemoryRequirements.pCreateInfo(int assumedCount)
VkImageCreateInfo.Ptr	VkDeviceImageSubresourceInfo.pCreateInfo(int assumedCount)
VkCoarseSampleOrderCustomNV.Ptr	VkPipelineViewportCoarseSampleOrderStateCreateInfoNV.pCustomSampleOrders(int assumedCount)
StdVideoH265DecPicBufMgr.Ptr	StdVideoH265SequenceParameterSet.pDecPicBufMgr(int assumedCount)
StdVideoH265DecPicBufMgr.Ptr	StdVideoH265VideoParameterSet.pDecPicBufMgr(int assumedCount)
VkSubpassDependency.Ptr	VkRenderPassCreateInfo.pDependencies(int assumedCount)
VkSubpassDependency2.Ptr	VkRenderPassCreateInfo2.pDependencies(int assumedCount)
VkRenderingAttachmentInfo.Ptr	VkRenderingInfo.pDepthAttachment(int assumedCount)
VkDepthClampRangeEXT.Ptr	VkPipelineViewportDepthClampControlCreateInfoEXT.pDepthClampRange(int assumedCount)
VkAttachmentReference.Ptr	VkSubpassDescription.pDepthStencilAttachment(int assumedCount)
VkAttachmentReference2.Ptr	VkSubpassDescription2.pDepthStencilAttachment(int assumedCount)
VkAttachmentReference2.Ptr	VkSubpassDescriptionDepthStencilResolve.pDepthStencilResolveAttachment(int assumedCount)
VkPipelineDepthStencilStateCreateInfo.Ptr	VkGraphicsPipelineCreateInfo.pDepthStencilState(int assumedCount)
VkDescriptorUpdateTemplateEntry.Ptr	VkDescriptorUpdateTemplateCreateInfo.pDescriptorUpdateEntries(int assumedCount)
VkWriteDescriptorSet.Ptr	VkPushDescriptorSetInfo.pDescriptorWrites(int assumedCount)
VkRect2D.Ptr	VkDeviceGroupRenderPassBeginInfo.pDeviceRenderAreas(int assumedCount)
VkRect2D.Ptr	VkPipelineDiscardRectangleStateCreateInfoEXT.pDiscardRectangles(int assumedCount)
VkDirectDriverLoadingInfoLUNARG.Ptr	VkDirectDriverLoadingListLUNARG.pDrivers(int assumedCount)
VkDrmFormatModifierProperties2EXT.Ptr	VkDrmFormatModifierPropertiesList2EXT.pDrmFormatModifierProperties(int assumedCount)
VkDrmFormatModifierPropertiesEXT.Ptr	VkDrmFormatModifierPropertiesListEXT.pDrmFormatModifierProperties(int assumedCount)
VkPipelineDynamicStateCreateInfo.Ptr	VkGraphicsPipelineCreateInfo.pDynamicState(int assumedCount)
VkPipelineDynamicStateCreateInfo.Ptr	VkRayTracingPipelineCreateInfoKHR.pDynamicState(int assumedCount)
VkPhysicalDeviceFeatures.Ptr	VkDeviceCreateInfo.pEnabledFeatures(int assumedCount)
VkRect2D.Ptr	VkPipelineViewportExclusiveScissorStateCreateInfoNV.pExclusiveScissors(int assumedCount)
VkIndirectCommandsExecutionSetTokenEXT.Ptr	VkIndirectCommandsTokenDataEXT.pExecutionSet(int assumedCount)
StdVideoEncodeAV1ExtensionHeader.Ptr	StdVideoEncodeAV1PictureInfo.pExtensionHeader(int assumedCount)
StdVideoEncodeAV1ExtensionHeader.Ptr	StdVideoEncodeAV1ReferenceInfo.pExtensionHeader(int assumedCount)
NvSciSyncFenceVKREF.Ptr	VkSemaphoreSciSyncCreateInfoNV.pFence(int assumedCount)
StdVideoAV1FilmGrain.Ptr	StdVideoDecodeAV1PictureInfo.pFilmGrain(int assumedCount)
VkImageFormatConstraintsInfoFUCHSIA.Ptr	VkImageConstraintsInfoFUCHSIA.pFormatConstraints(int assumedCount)
VkOffset2D.Ptr	VkRenderPassFragmentDensityMapOffsetEndInfoEXT.pFragmentDensityOffsets(int assumedCount)
VkAttachmentReference2.Ptr	VkFragmentShadingRateAttachmentInfoKHR.pFragmentShadingRateAttachment(int assumedCount)
VkAccelerationStructureGeometryKHR.Ptr	VkAccelerationStructureBuildGeometryInfoKHR.pGeometries(int assumedCount)
VkGeometryNV.Ptr	VkAccelerationStructureInfoNV.pGeometries(int assumedCount)
StdVideoAV1GlobalMotion.Ptr	StdVideoDecodeAV1PictureInfo.pGlobalMotion(int assumedCount)
StdVideoAV1GlobalMotion.Ptr	StdVideoEncodeAV1PictureInfo.pGlobalMotion(int assumedCount)
VkGraphicsShaderGroupCreateInfoNV.Ptr	VkGraphicsPipelineShaderGroupsCreateInfoNV.pGroups(int assumedCount)
VkRayTracingShaderGroupCreateInfoKHR.Ptr	VkRayTracingPipelineCreateInfoKHR.pGroups(int assumedCount)
VkRayTracingShaderGroupCreateInfoNV.Ptr	VkRayTracingPipelineCreateInfoNV.pGroups(int assumedCount)
StdVideoH264HrdParameters.Ptr	StdVideoH264SequenceParameterSetVui.pHrdParameters(int assumedCount)
StdVideoH265HrdParameters.Ptr	StdVideoH265SequenceParameterSetVui.pHrdParameters(int assumedCount)
StdVideoH265HrdParameters.Ptr	StdVideoH265VideoParameterSet.pHrdParameters(int assumedCount)
VkSparseImageMemoryBindInfo.Ptr	VkBindSparseInfo.pImageBinds(int assumedCount)
VkDescriptorImageInfo.Ptr	VkWriteDescriptorSet.pImageInfo(int assumedCount)
VkImageMemoryBarrier2.Ptr	VkDependencyInfo.pImageMemoryBarriers(int assumedCount)
VkSparseImageOpaqueMemoryBindInfo.Ptr	VkBindSparseInfo.pImageOpaqueBinds(int assumedCount)
VkIndirectCommandsIndexBufferTokenEXT.Ptr	VkIndirectCommandsTokenDataEXT.pIndexBuffer(int assumedCount)
VkCommandBufferInheritanceInfo.Ptr	VkCommandBufferBeginInfo.pInheritanceInfo(int assumedCount)
VkPipelineInputAssemblyStateCreateInfo.Ptr	VkGraphicsPipelineCreateInfo.pInputAssemblyState(int assumedCount)
VkDescriptorImageInfo.Ptr	VkDescriptorDataEXT.pInputAttachmentImage(int assumedCount)
VkAttachmentReference.Ptr	VkSubpassDescription.pInputAttachments(int assumedCount)
VkAttachmentReference2.Ptr	VkSubpassDescription2.pInputAttachments(int assumedCount)
VkPipelineBinaryKeysAndDataKHR.Ptr	VkPipelineBinaryCreateInfoKHR.pKeysAndDataInfo(int assumedCount)
VkPhysicalDeviceLayeredApiPropertiesKHR.Ptr	VkPhysicalDeviceLayeredApiPropertiesListKHR.pLayeredApis(int assumedCount)
VkVideoEncodeRateControlLayerInfoKHR.Ptr	VkVideoEncodeRateControlInfoKHR.pLayers(int assumedCount)
VkPipelineLibraryCreateInfoKHR.Ptr	VkExecutionGraphPipelineCreateInfoAMDX.pLibraryInfo(int assumedCount)
VkPipelineLibraryCreateInfoKHR.Ptr	VkRayTracingPipelineCreateInfoKHR.pLibraryInfo(int assumedCount)
VkRayTracingPipelineInterfaceCreateInfoKHR.Ptr	VkRayTracingPipelineCreateInfoKHR.pLibraryInterface(int assumedCount)
StdVideoEncodeH265LongTermRefPics.Ptr	StdVideoEncodeH265PictureInfo.pLongTermRefPics(int assumedCount)
StdVideoH265LongTermRefPicsSps.Ptr	StdVideoH265SequenceParameterSet.pLongTermRefPicsSps(int assumedCount)
StdVideoAV1LoopFilter.Ptr	StdVideoDecodeAV1PictureInfo.pLoopFilter(int assumedCount)
StdVideoAV1LoopFilter.Ptr	StdVideoEncodeAV1PictureInfo.pLoopFilter(int assumedCount)
StdVideoAV1LoopRestoration.Ptr	StdVideoDecodeAV1PictureInfo.pLoopRestoration(int assumedCount)
StdVideoAV1LoopRestoration.Ptr	StdVideoEncodeAV1PictureInfo.pLoopRestoration(int assumedCount)
VkSpecializationMapEntry.Ptr	VkSpecializationInfo.pMapEntries(int assumedCount)
VkMemoryBarrier2.Ptr	VkDependencyInfo.pMemoryBarriers(int assumedCount)
VkClusterAccelerationStructureMoveObjectsInputNV.Ptr	VkClusterAccelerationStructureOpInputNV.pMoveObjects(int assumedCount)
VkPipelineMultisampleStateCreateInfo.Ptr	VkGraphicsPipelineCreateInfo.pMultisampleState(int assumedCount)
VkMutableDescriptorTypeListEXT.Ptr	VkMutableDescriptorTypeCreateInfoEXT.pMutableDescriptorTypeLists(int assumedCount)
VkVideoEncodeH264NaluSliceInfoKHR.Ptr	VkVideoEncodeH264PictureInfoKHR.pNaluSliceEntries(int assumedCount)
VkVideoEncodeH265NaluSliceSegmentInfoKHR.Ptr	VkVideoEncodeH265PictureInfoKHR.pNaluSliceSegmentEntries(int assumedCount)
VkBaseInStructure.Ptr	VkBaseInStructure.pNext(int assumedCount)
VkBaseOutStructure.Ptr	VkBaseOutStructure.pNext(int assumedCount)
VkDebugUtilsObjectNameInfoEXT.Ptr	VkDebugUtilsMessengerCallbackDataEXT.pObjects(int assumedCount)
VkRefreshObjectKHR.Ptr	VkRefreshObjectListKHR.pObjects(int assumedCount)
VkVideoDecodeH264SessionParametersAddInfoKHR.Ptr	VkVideoDecodeH264SessionParametersCreateInfoKHR.pParametersAddInfo(int assumedCount)
VkVideoDecodeH265SessionParametersAddInfoKHR.Ptr	VkVideoDecodeH265SessionParametersCreateInfoKHR.pParametersAddInfo(int assumedCount)
VkVideoEncodeH264SessionParametersAddInfoKHR.Ptr	VkVideoEncodeH264SessionParametersCreateInfoKHR.pParametersAddInfo(int assumedCount)
VkVideoEncodeH265SessionParametersAddInfoKHR.Ptr	VkVideoEncodeH265SessionParametersCreateInfoKHR.pParametersAddInfo(int assumedCount)
VkRect2D.Ptr	VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM.pPerViewRenderAreas(int assumedCount)
VkVideoPictureResourceInfoKHR.Ptr	VkVideoReferenceSlotInfoKHR.pPictureResource(int assumedCount)
VkPipelineBinaryDataKHR.Ptr	VkPipelineBinaryKeysAndDataKHR.pPipelineBinaryData(int assumedCount)
VkPipelineBinaryKeyKHR.Ptr	VkPipelineBinaryKeysAndDataKHR.pPipelineBinaryKeys(int assumedCount)
VkPipelineCreateInfoKHR.Ptr	VkPipelineBinaryCreateInfoKHR.pPipelineCreateInfo(int assumedCount)
VkPipelineCreationFeedback.Ptr	VkPipelineCreationFeedbackCreateInfo.pPipelineCreationFeedback(int assumedCount)
VkIndirectExecutionSetPipelineInfoEXT.Ptr	VkIndirectExecutionSetInfoEXT.pPipelineInfo(int assumedCount)
VkPipelineCreationFeedback.Ptr	VkPipelineCreationFeedbackCreateInfo.pPipelineStageCreationFeedbacks(int assumedCount)
VkSubresourceLayout.Ptr	VkImageDrmFormatModifierExplicitCreateInfoEXT.pPlaneLayouts(int assumedCount)
VkDescriptorPoolSize.Ptr	VkDescriptorPoolCreateInfo.pPoolSizes(int assumedCount)
VkSubpassSampleLocationsEXT.Ptr	VkRenderPassSampleLocationsBeginInfoEXT.pPostSubpassSampleLocations(int assumedCount)
StdVideoH265PredictorPaletteEntries.Ptr	StdVideoH265PictureParameterSet.pPredictorPaletteEntries(int assumedCount)
StdVideoH265PredictorPaletteEntries.Ptr	StdVideoH265SequenceParameterSet.pPredictorPaletteEntries(int assumedCount)
VkAntiLagPresentationInfoAMD.Ptr	VkAntiLagDataAMD.pPresentationInfo(int assumedCount)
VkVideoProfileInfoKHR.Ptr	VkVideoProfileListInfoKHR.pProfiles(int assumedCount)
StdVideoH265ProfileTierLevel.Ptr	StdVideoH265SequenceParameterSet.pProfileTierLevel(int assumedCount)
StdVideoH265ProfileTierLevel.Ptr	StdVideoH265VideoParameterSet.pProfileTierLevel(int assumedCount)
VkIndirectCommandsPushConstantTokenEXT.Ptr	VkIndirectCommandsTokenDataEXT.pPushConstant(int assumedCount)
VkPushConstantRange.Ptr	VkIndirectExecutionSetShaderInfoEXT.pPushConstantRanges(int assumedCount)
VkPushConstantRange.Ptr	VkPipelineLayoutCreateInfo.pPushConstantRanges(int assumedCount)
VkPushConstantRange.Ptr	VkShaderCreateInfoEXT.pPushConstantRanges(int assumedCount)
StdVideoAV1Quantization.Ptr	StdVideoDecodeAV1PictureInfo.pQuantization(int assumedCount)
StdVideoAV1Quantization.Ptr	StdVideoEncodeAV1PictureInfo.pQuantization(int assumedCount)
VkDeviceQueueCreateInfo.Ptr	VkDeviceCreateInfo.pQueueCreateInfos(int assumedCount)
VkDebugUtilsLabelEXT.Ptr	VkDebugUtilsMessengerCallbackDataEXT.pQueueLabels(int assumedCount)
VkPipelineRasterizationStateCreateInfo.Ptr	VkGraphicsPipelineCreateInfo.pRasterizationState(int assumedCount)
VkRectLayerKHR.Ptr	VkPresentRegionKHR.pRectangles(int assumedCount)
VkVideoReferenceSlotInfoKHR.Ptr	VkVideoBeginCodingInfoKHR.pReferenceSlots(int assumedCount)
VkVideoReferenceSlotInfoKHR.Ptr	VkVideoDecodeInfoKHR.pReferenceSlots(int assumedCount)
VkVideoReferenceSlotInfoKHR.Ptr	VkVideoEncodeInfoKHR.pReferenceSlots(int assumedCount)
StdVideoEncodeH264RefListModEntry.Ptr	StdVideoEncodeH264ReferenceListsInfo.pRefList0ModOperations(int assumedCount)
StdVideoEncodeH264RefListModEntry.Ptr	StdVideoEncodeH264ReferenceListsInfo.pRefList1ModOperations(int assumedCount)
StdVideoEncodeH264ReferenceListsInfo.Ptr	StdVideoEncodeH264PictureInfo.pRefLists(int assumedCount)
StdVideoEncodeH265ReferenceListsInfo.Ptr	StdVideoEncodeH265PictureInfo.pRefLists(int assumedCount)
StdVideoEncodeH264RefPicMarkingEntry.Ptr	StdVideoEncodeH264ReferenceListsInfo.pRefPicMarkingOperations(int assumedCount)
VkImageBlit2.Ptr	VkBlitImageInfo2.pRegions(int assumedCount)
VkBufferCopy2.Ptr	VkCopyBufferInfo2.pRegions(int assumedCount)
VkBufferImageCopy2.Ptr	VkCopyBufferToImageInfo2.pRegions(int assumedCount)
VkImageCopy2.Ptr	VkCopyImageInfo2.pRegions(int assumedCount)
VkBufferImageCopy2.Ptr	VkCopyImageToBufferInfo2.pRegions(int assumedCount)
VkImageCopy2.Ptr	VkCopyImageToImageInfo.pRegions(int assumedCount)
VkImageToMemoryCopy.Ptr	VkCopyImageToMemoryInfo.pRegions(int assumedCount)
VkMemoryToImageCopy.Ptr	VkCopyMemoryToImageInfo.pRegions(int assumedCount)
VkRect2D.Ptr	VkOpticalFlowExecuteInfoNV.pRegions(int assumedCount)
VkPresentRegionKHR.Ptr	VkPresentRegionsKHR.pRegions(int assumedCount)
VkImageResolve2.Ptr	VkResolveImageInfo2.pRegions(int assumedCount)
VkRenderPassCreationFeedbackInfoEXT.Ptr	VkRenderPassCreationFeedbackCreateInfoEXT.pRenderPassFeedback(int assumedCount)
VkAttachmentReference.Ptr	VkSubpassDescription.pResolveAttachments(int assumedCount)
VkAttachmentReference2.Ptr	VkSubpassDescription2.pResolveAttachments(int assumedCount)
VkDescriptorImageInfo.Ptr	VkDescriptorDataEXT.pSampledImage(int assumedCount)
VkCoarseSampleLocationNV.Ptr	VkCoarseSampleOrderCustomNV.pSampleLocations(int assumedCount)
VkSampleLocationEXT.Ptr	VkSampleLocationsInfoEXT.pSampleLocations(int assumedCount)
StdVideoH264ScalingLists.Ptr	StdVideoH264PictureParameterSet.pScalingLists(int assumedCount)
StdVideoH264ScalingLists.Ptr	StdVideoH264SequenceParameterSet.pScalingLists(int assumedCount)
StdVideoH265ScalingLists.Ptr	StdVideoH265PictureParameterSet.pScalingLists(int assumedCount)
StdVideoH265ScalingLists.Ptr	StdVideoH265SequenceParameterSet.pScalingLists(int assumedCount)
VkRect2D.Ptr	VkPipelineViewportStateCreateInfo.pScissors(int assumedCount)
StdVideoAV1Segmentation.Ptr	StdVideoDecodeAV1PictureInfo.pSegmentation(int assumedCount)
StdVideoAV1Segmentation.Ptr	StdVideoEncodeAV1PictureInfo.pSegmentation(int assumedCount)
StdVideoH264SequenceParameterSetVui.Ptr	StdVideoH264SequenceParameterSet.pSequenceParameterSetVui(int assumedCount)
StdVideoH265SequenceParameterSetVui.Ptr	StdVideoH265SequenceParameterSet.pSequenceParameterSetVui(int assumedCount)
VkIndirectExecutionSetShaderLayoutInfoEXT.Ptr	VkIndirectExecutionSetShaderInfoEXT.pSetLayoutInfos(int assumedCount)
VkLayerSettingEXT.Ptr	VkLayerSettingsCreateInfoEXT.pSettings(int assumedCount)
VkVideoReferenceSlotInfoKHR.Ptr	VkVideoDecodeInfoKHR.pSetupReferenceSlot(int assumedCount)
VkVideoReferenceSlotInfoKHR.Ptr	VkVideoEncodeInfoKHR.pSetupReferenceSlot(int assumedCount)
VkIndirectExecutionSetShaderInfoEXT.Ptr	VkIndirectExecutionSetInfoEXT.pShaderInfo(int assumedCount)
VkShadingRatePaletteNV.Ptr	VkPipelineViewportShadingRateImageStateCreateInfoNV.pShadingRatePalettes(int assumedCount)
StdVideoH265ShortTermRefPicSet.Ptr	StdVideoEncodeH265PictureInfo.pShortTermRefPicSet(int assumedCount)
StdVideoH265ShortTermRefPicSet.Ptr	StdVideoH265SequenceParameterSet.pShortTermRefPicSet(int assumedCount)
VkSemaphoreSubmitInfo.Ptr	VkSubmitInfo2.pSignalSemaphoreInfos(int assumedCount)
VkSpecializationInfo.Ptr	VkPipelineShaderStageCreateInfo.pSpecializationInfo(int assumedCount)
VkSpecializationInfo.Ptr	VkShaderCreateInfoEXT.pSpecializationInfo(int assumedCount)
VkRect2D.Ptr	VkBindImageMemoryDeviceGroupInfo.pSplitInstanceBindRegions(int assumedCount)
VkPipelineShaderStageCreateInfo.Ptr	VkExecutionGraphPipelineCreateInfoAMDX.pStages(int assumedCount)
VkPipelineShaderStageCreateInfo.Ptr	VkGraphicsPipelineCreateInfo.pStages(int assumedCount)
VkPipelineShaderStageCreateInfo.Ptr	VkGraphicsShaderGroupCreateInfoNV.pStages(int assumedCount)
VkPipelineShaderStageCreateInfo.Ptr	VkRayTracingPipelineCreateInfoKHR.pStages(int assumedCount)
VkPipelineShaderStageCreateInfo.Ptr	VkRayTracingPipelineCreateInfoNV.pStages(int assumedCount)
StdVideoEncodeAV1DecoderModelInfo.Ptr	VkVideoEncodeAV1SessionParametersCreateInfoKHR.pStdDecoderModelInfo(int assumedCount)
VkExtensionProperties.Ptr	VkVideoSessionCreateInfoKHR.pStdHeaderVersion(int assumedCount)
StdVideoEncodeAV1OperatingPointInfo.Ptr	VkVideoEncodeAV1SessionParametersCreateInfoKHR.pStdOperatingPoints(int assumedCount)
StdVideoDecodeAV1PictureInfo.Ptr	VkVideoDecodeAV1PictureInfoKHR.pStdPictureInfo(int assumedCount)
StdVideoDecodeH264PictureInfo.Ptr	VkVideoDecodeH264PictureInfoKHR.pStdPictureInfo(int assumedCount)
StdVideoDecodeH265PictureInfo.Ptr	VkVideoDecodeH265PictureInfoKHR.pStdPictureInfo(int assumedCount)
StdVideoEncodeAV1PictureInfo.Ptr	VkVideoEncodeAV1PictureInfoKHR.pStdPictureInfo(int assumedCount)
StdVideoEncodeH264PictureInfo.Ptr	VkVideoEncodeH264PictureInfoKHR.pStdPictureInfo(int assumedCount)
StdVideoEncodeH265PictureInfo.Ptr	VkVideoEncodeH265PictureInfoKHR.pStdPictureInfo(int assumedCount)
StdVideoH264PictureParameterSet.Ptr	VkVideoDecodeH264InlineSessionParametersInfoKHR.pStdPPS(int assumedCount)
StdVideoH265PictureParameterSet.Ptr	VkVideoDecodeH265InlineSessionParametersInfoKHR.pStdPPS(int assumedCount)
StdVideoH264PictureParameterSet.Ptr	VkVideoDecodeH264SessionParametersAddInfoKHR.pStdPPSs(int assumedCount)
StdVideoH265PictureParameterSet.Ptr	VkVideoDecodeH265SessionParametersAddInfoKHR.pStdPPSs(int assumedCount)
StdVideoH264PictureParameterSet.Ptr	VkVideoEncodeH264SessionParametersAddInfoKHR.pStdPPSs(int assumedCount)
StdVideoH265PictureParameterSet.Ptr	VkVideoEncodeH265SessionParametersAddInfoKHR.pStdPPSs(int assumedCount)
StdVideoDecodeAV1ReferenceInfo.Ptr	VkVideoDecodeAV1DpbSlotInfoKHR.pStdReferenceInfo(int assumedCount)
StdVideoDecodeH264ReferenceInfo.Ptr	VkVideoDecodeH264DpbSlotInfoKHR.pStdReferenceInfo(int assumedCount)
StdVideoDecodeH265ReferenceInfo.Ptr	VkVideoDecodeH265DpbSlotInfoKHR.pStdReferenceInfo(int assumedCount)
StdVideoEncodeAV1ReferenceInfo.Ptr	VkVideoEncodeAV1DpbSlotInfoKHR.pStdReferenceInfo(int assumedCount)
StdVideoEncodeH264ReferenceInfo.Ptr	VkVideoEncodeH264DpbSlotInfoKHR.pStdReferenceInfo(int assumedCount)
StdVideoEncodeH265ReferenceInfo.Ptr	VkVideoEncodeH265DpbSlotInfoKHR.pStdReferenceInfo(int assumedCount)
StdVideoAV1SequenceHeader.Ptr	VkVideoDecodeAV1InlineSessionParametersInfoKHR.pStdSequenceHeader(int assumedCount)
StdVideoAV1SequenceHeader.Ptr	VkVideoDecodeAV1SessionParametersCreateInfoKHR.pStdSequenceHeader(int assumedCount)
StdVideoAV1SequenceHeader.Ptr	VkVideoEncodeAV1SessionParametersCreateInfoKHR.pStdSequenceHeader(int assumedCount)
StdVideoEncodeH264SliceHeader.Ptr	VkVideoEncodeH264NaluSliceInfoKHR.pStdSliceHeader(int assumedCount)
StdVideoEncodeH265SliceSegmentHeader.Ptr	VkVideoEncodeH265NaluSliceSegmentInfoKHR.pStdSliceSegmentHeader(int assumedCount)
StdVideoH264SequenceParameterSet.Ptr	VkVideoDecodeH264InlineSessionParametersInfoKHR.pStdSPS(int assumedCount)
StdVideoH265SequenceParameterSet.Ptr	VkVideoDecodeH265InlineSessionParametersInfoKHR.pStdSPS(int assumedCount)
StdVideoH264SequenceParameterSet.Ptr	VkVideoDecodeH264SessionParametersAddInfoKHR.pStdSPSs(int assumedCount)
StdVideoH265SequenceParameterSet.Ptr	VkVideoDecodeH265SessionParametersAddInfoKHR.pStdSPSs(int assumedCount)
StdVideoH264SequenceParameterSet.Ptr	VkVideoEncodeH264SessionParametersAddInfoKHR.pStdSPSs(int assumedCount)
StdVideoH265SequenceParameterSet.Ptr	VkVideoEncodeH265SessionParametersAddInfoKHR.pStdSPSs(int assumedCount)
StdVideoH265VideoParameterSet.Ptr	VkVideoDecodeH265InlineSessionParametersInfoKHR.pStdVPS(int assumedCount)
StdVideoH265VideoParameterSet.Ptr	VkVideoDecodeH265SessionParametersAddInfoKHR.pStdVPSs(int assumedCount)
StdVideoH265VideoParameterSet.Ptr	VkVideoEncodeH265SessionParametersAddInfoKHR.pStdVPSs(int assumedCount)
VkRenderingAttachmentInfo.Ptr	VkRenderingInfo.pStencilAttachment(int assumedCount)
VkDescriptorAddressInfoEXT.Ptr	VkDescriptorDataEXT.pStorageBuffer(int assumedCount)
VkDescriptorImageInfo.Ptr	VkDescriptorDataEXT.pStorageImage(int assumedCount)
VkDescriptorAddressInfoEXT.Ptr	VkDescriptorDataEXT.pStorageTexelBuffer(int assumedCount)
VkIndirectCommandsStreamNV.Ptr	VkGeneratedCommandsInfoNV.pStreams(int assumedCount)
VkRenderPassStripeInfoARM.Ptr	VkRenderPassStripeBeginInfoARM.pStripeInfos(int assumedCount)
VkSemaphoreSubmitInfo.Ptr	VkRenderPassStripeSubmitInfoARM.pStripeSemaphoreInfos(int assumedCount)
StdVideoH265SubLayerHrdParameters.Ptr	StdVideoH265HrdParameters.pSubLayerHrdParametersNal(int assumedCount)
StdVideoH265SubLayerHrdParameters.Ptr	StdVideoH265HrdParameters.pSubLayerHrdParametersVcl(int assumedCount)
VkSubpassDescription.Ptr	VkRenderPassCreateInfo.pSubpasses(int assumedCount)
VkSubpassDescription2.Ptr	VkRenderPassCreateInfo2.pSubpasses(int assumedCount)
VkRenderPassSubpassFeedbackInfoEXT.Ptr	VkRenderPassSubpassFeedbackCreateInfoEXT.pSubpassFeedback(int assumedCount)
VkImageSubresource2.Ptr	VkDeviceImageSubresourceInfo.pSubresource(int assumedCount)
VkPipelineTessellationStateCreateInfo.Ptr	VkGraphicsPipelineCreateInfo.pTessellationState(int assumedCount)
VkPipelineTessellationStateCreateInfo.Ptr	VkGraphicsShaderGroupCreateInfoNV.pTessellationState(int assumedCount)
StdVideoAV1TileInfo.Ptr	StdVideoDecodeAV1PictureInfo.pTileInfo(int assumedCount)
StdVideoAV1TileInfo.Ptr	StdVideoEncodeAV1PictureInfo.pTileInfo(int assumedCount)
VkPresentTimeGOOGLE.Ptr	VkPresentTimesInfoGOOGLE.pTimes(int assumedCount)
StdVideoAV1TimingInfo.Ptr	StdVideoAV1SequenceHeader.pTimingInfo(int assumedCount)
VkLatencyTimingsFrameReportNV.Ptr	VkGetLatencyMarkerInfoNV.pTimings(int assumedCount)
VkIndirectCommandsLayoutTokenEXT.Ptr	VkIndirectCommandsLayoutCreateInfoEXT.pTokens(int assumedCount)
VkIndirectCommandsLayoutTokenNV.Ptr	VkIndirectCommandsLayoutCreateInfoNV.pTokens(int assumedCount)
VkClusterAccelerationStructureTriangleClusterInputNV.Ptr	VkClusterAccelerationStructureOpInputNV.pTriangleClusters(int assumedCount)
VkDescriptorAddressInfoEXT.Ptr	VkDescriptorDataEXT.pUniformBuffer(int assumedCount)
VkDescriptorAddressInfoEXT.Ptr	VkDescriptorDataEXT.pUniformTexelBuffer(int assumedCount)
VkMicromapUsageEXT.Ptr	VkAccelerationStructureTrianglesDisplacementMicromapNV.pUsageCounts(int assumedCount)
VkMicromapUsageEXT.Ptr	VkAccelerationStructureTrianglesOpacityMicromapEXT.pUsageCounts(int assumedCount)
VkMicromapUsageEXT.Ptr	VkMicromapBuildInfoEXT.pUsageCounts(int assumedCount)
VkDeviceFaultVendorInfoEXT.Ptr	VkDeviceFaultInfoEXT.pVendorInfos(int assumedCount)
VkVertexInputAttributeDescription.Ptr	VkPipelineVertexInputStateCreateInfo.pVertexAttributeDescriptions(int assumedCount)
VkVertexInputBindingDescription.Ptr	VkPipelineVertexInputStateCreateInfo.pVertexBindingDescriptions(int assumedCount)
VkVertexInputBindingDivisorDescription.Ptr	VkPipelineVertexInputDivisorStateCreateInfo.pVertexBindingDivisors(int assumedCount)
VkIndirectCommandsVertexBufferTokenEXT.Ptr	VkIndirectCommandsTokenDataEXT.pVertexBuffer(int assumedCount)
VkPipelineVertexInputStateCreateInfo.Ptr	VkGraphicsPipelineCreateInfo.pVertexInputState(int assumedCount)
VkPipelineVertexInputStateCreateInfo.Ptr	VkGraphicsShaderGroupCreateInfoNV.pVertexInputState(int assumedCount)
VkVideoProfileInfoKHR.Ptr	VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR.pVideoProfile(int assumedCount)
VkVideoProfileInfoKHR.Ptr	VkVideoSessionCreateInfoKHR.pVideoProfile(int assumedCount)
VkViewport.Ptr	VkCommandBufferInheritanceViewportScissorInfoNV.pViewportDepths(int assumedCount)
VkViewport.Ptr	VkPipelineViewportStateCreateInfo.pViewports(int assumedCount)
VkPipelineViewportStateCreateInfo.Ptr	VkGraphicsPipelineCreateInfo.pViewportState(int assumedCount)
VkViewportSwizzleNV.Ptr	VkPipelineViewportSwizzleStateCreateInfoNV.pViewportSwizzles(int assumedCount)
VkViewportWScalingNV.Ptr	VkPipelineViewportWScalingStateCreateInfoNV.pViewportWScalings(int assumedCount)
VkSemaphoreSubmitInfo.Ptr	VkSubmitInfo2.pWaitSemaphoreInfos(int assumedCount)
StdVideoEncodeH264WeightTable.Ptr	StdVideoEncodeH264SliceHeader.pWeightTable(int assumedCount)
StdVideoEncodeH265WeightTable.Ptr	StdVideoEncodeH265SliceSegmentHeader.pWeightTable(int assumedCount)
@NotNull NvSciSyncFenceVKREF.Ptr	NvSciSyncFenceVKREF.Ptr.reinterpret(long newSize)	Assume the NvSciSyncFenceVKREF.Ptr is capable of holding at least newSize structures, create a new view NvSciSyncFenceVKREF.Ptr that uses the same backing storage as this NvSciSyncFenceVKREF.Ptr, but with the new size.
@NotNull StdVideoAV1CDEF.Ptr	StdVideoAV1CDEF.Ptr.reinterpret(long newSize)	Assume the StdVideoAV1CDEF.Ptr is capable of holding at least newSize structures, create a new view StdVideoAV1CDEF.Ptr that uses the same backing storage as this StdVideoAV1CDEF.Ptr, but with the new size.
@NotNull StdVideoAV1ColorConfig.Ptr	StdVideoAV1ColorConfig.Ptr.reinterpret(long newSize)	Assume the StdVideoAV1ColorConfig.Ptr is capable of holding at least newSize structures, create a new view StdVideoAV1ColorConfig.Ptr that uses the same backing storage as this StdVideoAV1ColorConfig.Ptr, but with the new size.
@NotNull StdVideoAV1ColorConfigFlags.Ptr	StdVideoAV1ColorConfigFlags.Ptr.reinterpret(long newSize)	Assume the StdVideoAV1ColorConfigFlags.Ptr is capable of holding at least newSize structures, create a new view StdVideoAV1ColorConfigFlags.Ptr that uses the same backing storage as this StdVideoAV1ColorConfigFlags.Ptr, but with the new size.
@NotNull StdVideoAV1FilmGrain.Ptr	StdVideoAV1FilmGrain.Ptr.reinterpret(long newSize)	Assume the StdVideoAV1FilmGrain.Ptr is capable of holding at least newSize structures, create a new view StdVideoAV1FilmGrain.Ptr that uses the same backing storage as this StdVideoAV1FilmGrain.Ptr, but with the new size.
@NotNull StdVideoAV1FilmGrainFlags.Ptr	StdVideoAV1FilmGrainFlags.Ptr.reinterpret(long newSize)	Assume the StdVideoAV1FilmGrainFlags.Ptr is capable of holding at least newSize structures, create a new view StdVideoAV1FilmGrainFlags.Ptr that uses the same backing storage as this StdVideoAV1FilmGrainFlags.Ptr, but with the new size.
@NotNull StdVideoAV1GlobalMotion.Ptr	StdVideoAV1GlobalMotion.Ptr.reinterpret(long newSize)	Assume the StdVideoAV1GlobalMotion.Ptr is capable of holding at least newSize structures, create a new view StdVideoAV1GlobalMotion.Ptr that uses the same backing storage as this StdVideoAV1GlobalMotion.Ptr, but with the new size.
@NotNull StdVideoAV1LoopFilter.Ptr	StdVideoAV1LoopFilter.Ptr.reinterpret(long newSize)	Assume the StdVideoAV1LoopFilter.Ptr is capable of holding at least newSize structures, create a new view StdVideoAV1LoopFilter.Ptr that uses the same backing storage as this StdVideoAV1LoopFilter.Ptr, but with the new size.
@NotNull StdVideoAV1LoopFilterFlags.Ptr	StdVideoAV1LoopFilterFlags.Ptr.reinterpret(long newSize)	Assume the StdVideoAV1LoopFilterFlags.Ptr is capable of holding at least newSize structures, create a new view StdVideoAV1LoopFilterFlags.Ptr that uses the same backing storage as this StdVideoAV1LoopFilterFlags.Ptr, but with the new size.
@NotNull StdVideoAV1LoopRestoration.Ptr	StdVideoAV1LoopRestoration.Ptr.reinterpret(long newSize)	Assume the StdVideoAV1LoopRestoration.Ptr is capable of holding at least newSize structures, create a new view StdVideoAV1LoopRestoration.Ptr that uses the same backing storage as this StdVideoAV1LoopRestoration.Ptr, but with the new size.
@NotNull StdVideoAV1Quantization.Ptr	StdVideoAV1Quantization.Ptr.reinterpret(long newSize)	Assume the StdVideoAV1Quantization.Ptr is capable of holding at least newSize structures, create a new view StdVideoAV1Quantization.Ptr that uses the same backing storage as this StdVideoAV1Quantization.Ptr, but with the new size.
@NotNull StdVideoAV1QuantizationFlags.Ptr	StdVideoAV1QuantizationFlags.Ptr.reinterpret(long newSize)	Assume the StdVideoAV1QuantizationFlags.Ptr is capable of holding at least newSize structures, create a new view StdVideoAV1QuantizationFlags.Ptr that uses the same backing storage as this StdVideoAV1QuantizationFlags.Ptr, but with the new size.
@NotNull StdVideoAV1Segmentation.Ptr	StdVideoAV1Segmentation.Ptr.reinterpret(long newSize)	Assume the StdVideoAV1Segmentation.Ptr is capable of holding at least newSize structures, create a new view StdVideoAV1Segmentation.Ptr that uses the same backing storage as this StdVideoAV1Segmentation.Ptr, but with the new size.
@NotNull StdVideoAV1SequenceHeader.Ptr	StdVideoAV1SequenceHeader.Ptr.reinterpret(long newSize)	Assume the StdVideoAV1SequenceHeader.Ptr is capable of holding at least newSize structures, create a new view StdVideoAV1SequenceHeader.Ptr that uses the same backing storage as this StdVideoAV1SequenceHeader.Ptr, but with the new size.
@NotNull StdVideoAV1SequenceHeaderFlags.Ptr	StdVideoAV1SequenceHeaderFlags.Ptr.reinterpret(long newSize)	Assume the StdVideoAV1SequenceHeaderFlags.Ptr is capable of holding at least newSize structures, create a new view StdVideoAV1SequenceHeaderFlags.Ptr that uses the same backing storage as this StdVideoAV1SequenceHeaderFlags.Ptr, but with the new size.
@NotNull StdVideoAV1TileInfo.Ptr	StdVideoAV1TileInfo.Ptr.reinterpret(long newSize)	Assume the StdVideoAV1TileInfo.Ptr is capable of holding at least newSize structures, create a new view StdVideoAV1TileInfo.Ptr that uses the same backing storage as this StdVideoAV1TileInfo.Ptr, but with the new size.
@NotNull StdVideoAV1TileInfoFlags.Ptr	StdVideoAV1TileInfoFlags.Ptr.reinterpret(long newSize)	Assume the StdVideoAV1TileInfoFlags.Ptr is capable of holding at least newSize structures, create a new view StdVideoAV1TileInfoFlags.Ptr that uses the same backing storage as this StdVideoAV1TileInfoFlags.Ptr, but with the new size.
@NotNull StdVideoAV1TimingInfo.Ptr	StdVideoAV1TimingInfo.Ptr.reinterpret(long newSize)	Assume the StdVideoAV1TimingInfo.Ptr is capable of holding at least newSize structures, create a new view StdVideoAV1TimingInfo.Ptr that uses the same backing storage as this StdVideoAV1TimingInfo.Ptr, but with the new size.
@NotNull StdVideoAV1TimingInfoFlags.Ptr	StdVideoAV1TimingInfoFlags.Ptr.reinterpret(long newSize)	Assume the StdVideoAV1TimingInfoFlags.Ptr is capable of holding at least newSize structures, create a new view StdVideoAV1TimingInfoFlags.Ptr that uses the same backing storage as this StdVideoAV1TimingInfoFlags.Ptr, but with the new size.
@NotNull StdVideoDecodeAV1PictureInfo.Ptr	StdVideoDecodeAV1PictureInfo.Ptr.reinterpret(long newSize)	Assume the StdVideoDecodeAV1PictureInfo.Ptr is capable of holding at least newSize structures, create a new view StdVideoDecodeAV1PictureInfo.Ptr that uses the same backing storage as this StdVideoDecodeAV1PictureInfo.Ptr, but with the new size.
@NotNull StdVideoDecodeAV1PictureInfoFlags.Ptr	StdVideoDecodeAV1PictureInfoFlags.Ptr.reinterpret(long newSize)	Assume the StdVideoDecodeAV1PictureInfoFlags.Ptr is capable of holding at least newSize structures, create a new view StdVideoDecodeAV1PictureInfoFlags.Ptr that uses the same backing storage as this StdVideoDecodeAV1PictureInfoFlags.Ptr, but with the new size.
@NotNull StdVideoDecodeAV1ReferenceInfo.Ptr	StdVideoDecodeAV1ReferenceInfo.Ptr.reinterpret(long newSize)	Assume the StdVideoDecodeAV1ReferenceInfo.Ptr is capable of holding at least newSize structures, create a new view StdVideoDecodeAV1ReferenceInfo.Ptr that uses the same backing storage as this StdVideoDecodeAV1ReferenceInfo.Ptr, but with the new size.
@NotNull StdVideoDecodeAV1ReferenceInfoFlags.Ptr	StdVideoDecodeAV1ReferenceInfoFlags.Ptr.reinterpret(long newSize)	Assume the StdVideoDecodeAV1ReferenceInfoFlags.Ptr is capable of holding at least newSize structures, create a new view StdVideoDecodeAV1ReferenceInfoFlags.Ptr that uses the same backing storage as this StdVideoDecodeAV1ReferenceInfoFlags.Ptr, but with the new size.
@NotNull StdVideoDecodeH264PictureInfo.Ptr	StdVideoDecodeH264PictureInfo.Ptr.reinterpret(long newSize)	Assume the StdVideoDecodeH264PictureInfo.Ptr is capable of holding at least newSize structures, create a new view StdVideoDecodeH264PictureInfo.Ptr that uses the same backing storage as this StdVideoDecodeH264PictureInfo.Ptr, but with the new size.
@NotNull StdVideoDecodeH264PictureInfoFlags.Ptr	StdVideoDecodeH264PictureInfoFlags.Ptr.reinterpret(long newSize)	Assume the StdVideoDecodeH264PictureInfoFlags.Ptr is capable of holding at least newSize structures, create a new view StdVideoDecodeH264PictureInfoFlags.Ptr that uses the same backing storage as this StdVideoDecodeH264PictureInfoFlags.Ptr, but with the new size.
@NotNull StdVideoDecodeH264ReferenceInfo.Ptr	StdVideoDecodeH264ReferenceInfo.Ptr.reinterpret(long newSize)	Assume the StdVideoDecodeH264ReferenceInfo.Ptr is capable of holding at least newSize structures, create a new view StdVideoDecodeH264ReferenceInfo.Ptr that uses the same backing storage as this StdVideoDecodeH264ReferenceInfo.Ptr, but with the new size.
@NotNull StdVideoDecodeH264ReferenceInfoFlags.Ptr	StdVideoDecodeH264ReferenceInfoFlags.Ptr.reinterpret(long newSize)	Assume the StdVideoDecodeH264ReferenceInfoFlags.Ptr is capable of holding at least newSize structures, create a new view StdVideoDecodeH264ReferenceInfoFlags.Ptr that uses the same backing storage as this StdVideoDecodeH264ReferenceInfoFlags.Ptr, but with the new size.
@NotNull StdVideoDecodeH265PictureInfo.Ptr	StdVideoDecodeH265PictureInfo.Ptr.reinterpret(long newSize)	Assume the StdVideoDecodeH265PictureInfo.Ptr is capable of holding at least newSize structures, create a new view StdVideoDecodeH265PictureInfo.Ptr that uses the same backing storage as this StdVideoDecodeH265PictureInfo.Ptr, but with the new size.
@NotNull StdVideoDecodeH265PictureInfoFlags.Ptr	StdVideoDecodeH265PictureInfoFlags.Ptr.reinterpret(long newSize)	Assume the StdVideoDecodeH265PictureInfoFlags.Ptr is capable of holding at least newSize structures, create a new view StdVideoDecodeH265PictureInfoFlags.Ptr that uses the same backing storage as this StdVideoDecodeH265PictureInfoFlags.Ptr, but with the new size.
@NotNull StdVideoDecodeH265ReferenceInfo.Ptr	StdVideoDecodeH265ReferenceInfo.Ptr.reinterpret(long newSize)	Assume the StdVideoDecodeH265ReferenceInfo.Ptr is capable of holding at least newSize structures, create a new view StdVideoDecodeH265ReferenceInfo.Ptr that uses the same backing storage as this StdVideoDecodeH265ReferenceInfo.Ptr, but with the new size.
@NotNull StdVideoDecodeH265ReferenceInfoFlags.Ptr	StdVideoDecodeH265ReferenceInfoFlags.Ptr.reinterpret(long newSize)	Assume the StdVideoDecodeH265ReferenceInfoFlags.Ptr is capable of holding at least newSize structures, create a new view StdVideoDecodeH265ReferenceInfoFlags.Ptr that uses the same backing storage as this StdVideoDecodeH265ReferenceInfoFlags.Ptr, but with the new size.
@NotNull StdVideoEncodeAV1DecoderModelInfo.Ptr	StdVideoEncodeAV1DecoderModelInfo.Ptr.reinterpret(long newSize)	Assume the StdVideoEncodeAV1DecoderModelInfo.Ptr is capable of holding at least newSize structures, create a new view StdVideoEncodeAV1DecoderModelInfo.Ptr that uses the same backing storage as this StdVideoEncodeAV1DecoderModelInfo.Ptr, but with the new size.
@NotNull StdVideoEncodeAV1ExtensionHeader.Ptr	StdVideoEncodeAV1ExtensionHeader.Ptr.reinterpret(long newSize)	Assume the StdVideoEncodeAV1ExtensionHeader.Ptr is capable of holding at least newSize structures, create a new view StdVideoEncodeAV1ExtensionHeader.Ptr that uses the same backing storage as this StdVideoEncodeAV1ExtensionHeader.Ptr, but with the new size.
@NotNull StdVideoEncodeAV1OperatingPointInfo.Ptr	StdVideoEncodeAV1OperatingPointInfo.Ptr.reinterpret(long newSize)	Assume the StdVideoEncodeAV1OperatingPointInfo.Ptr is capable of holding at least newSize structures, create a new view StdVideoEncodeAV1OperatingPointInfo.Ptr that uses the same backing storage as this StdVideoEncodeAV1OperatingPointInfo.Ptr, but with the new size.
@NotNull StdVideoEncodeAV1OperatingPointInfoFlags.Ptr	StdVideoEncodeAV1OperatingPointInfoFlags.Ptr.reinterpret(long newSize)	Assume the StdVideoEncodeAV1OperatingPointInfoFlags.Ptr is capable of holding at least newSize structures, create a new view StdVideoEncodeAV1OperatingPointInfoFlags.Ptr that uses the same backing storage as this StdVideoEncodeAV1OperatingPointInfoFlags.Ptr, but with the new size.
@NotNull StdVideoEncodeAV1PictureInfo.Ptr	StdVideoEncodeAV1PictureInfo.Ptr.reinterpret(long newSize)	Assume the StdVideoEncodeAV1PictureInfo.Ptr is capable of holding at least newSize structures, create a new view StdVideoEncodeAV1PictureInfo.Ptr that uses the same backing storage as this StdVideoEncodeAV1PictureInfo.Ptr, but with the new size.
@NotNull StdVideoEncodeAV1PictureInfoFlags.Ptr	StdVideoEncodeAV1PictureInfoFlags.Ptr.reinterpret(long newSize)	Assume the StdVideoEncodeAV1PictureInfoFlags.Ptr is capable of holding at least newSize structures, create a new view StdVideoEncodeAV1PictureInfoFlags.Ptr that uses the same backing storage as this StdVideoEncodeAV1PictureInfoFlags.Ptr, but with the new size.
@NotNull StdVideoEncodeAV1ReferenceInfo.Ptr	StdVideoEncodeAV1ReferenceInfo.Ptr.reinterpret(long newSize)	Assume the StdVideoEncodeAV1ReferenceInfo.Ptr is capable of holding at least newSize structures, create a new view StdVideoEncodeAV1ReferenceInfo.Ptr that uses the same backing storage as this StdVideoEncodeAV1ReferenceInfo.Ptr, but with the new size.
@NotNull StdVideoEncodeAV1ReferenceInfoFlags.Ptr	StdVideoEncodeAV1ReferenceInfoFlags.Ptr.reinterpret(long newSize)	Assume the StdVideoEncodeAV1ReferenceInfoFlags.Ptr is capable of holding at least newSize structures, create a new view StdVideoEncodeAV1ReferenceInfoFlags.Ptr that uses the same backing storage as this StdVideoEncodeAV1ReferenceInfoFlags.Ptr, but with the new size.
@NotNull StdVideoEncodeH264PictureInfo.Ptr	StdVideoEncodeH264PictureInfo.Ptr.reinterpret(long newSize)	Assume the StdVideoEncodeH264PictureInfo.Ptr is capable of holding at least newSize structures, create a new view StdVideoEncodeH264PictureInfo.Ptr that uses the same backing storage as this StdVideoEncodeH264PictureInfo.Ptr, but with the new size.
@NotNull StdVideoEncodeH264PictureInfoFlags.Ptr	StdVideoEncodeH264PictureInfoFlags.Ptr.reinterpret(long newSize)	Assume the StdVideoEncodeH264PictureInfoFlags.Ptr is capable of holding at least newSize structures, create a new view StdVideoEncodeH264PictureInfoFlags.Ptr that uses the same backing storage as this StdVideoEncodeH264PictureInfoFlags.Ptr, but with the new size.
@NotNull StdVideoEncodeH264ReferenceInfo.Ptr	StdVideoEncodeH264ReferenceInfo.Ptr.reinterpret(long newSize)	Assume the StdVideoEncodeH264ReferenceInfo.Ptr is capable of holding at least newSize structures, create a new view StdVideoEncodeH264ReferenceInfo.Ptr that uses the same backing storage as this StdVideoEncodeH264ReferenceInfo.Ptr, but with the new size.
@NotNull StdVideoEncodeH264ReferenceInfoFlags.Ptr	StdVideoEncodeH264ReferenceInfoFlags.Ptr.reinterpret(long newSize)	Assume the StdVideoEncodeH264ReferenceInfoFlags.Ptr is capable of holding at least newSize structures, create a new view StdVideoEncodeH264ReferenceInfoFlags.Ptr that uses the same backing storage as this StdVideoEncodeH264ReferenceInfoFlags.Ptr, but with the new size.
@NotNull StdVideoEncodeH264ReferenceListsInfo.Ptr	StdVideoEncodeH264ReferenceListsInfo.Ptr.reinterpret(long newSize)	Assume the StdVideoEncodeH264ReferenceListsInfo.Ptr is capable of holding at least newSize structures, create a new view StdVideoEncodeH264ReferenceListsInfo.Ptr that uses the same backing storage as this StdVideoEncodeH264ReferenceListsInfo.Ptr, but with the new size.
@NotNull StdVideoEncodeH264ReferenceListsInfoFlags.Ptr	StdVideoEncodeH264ReferenceListsInfoFlags.Ptr.reinterpret(long newSize)	Assume the StdVideoEncodeH264ReferenceListsInfoFlags.Ptr is capable of holding at least newSize structures, create a new view StdVideoEncodeH264ReferenceListsInfoFlags.Ptr that uses the same backing storage as this StdVideoEncodeH264ReferenceListsInfoFlags.Ptr, but with the new size.
@NotNull StdVideoEncodeH264RefListModEntry.Ptr	StdVideoEncodeH264RefListModEntry.Ptr.reinterpret(long newSize)	Assume the StdVideoEncodeH264RefListModEntry.Ptr is capable of holding at least newSize structures, create a new view StdVideoEncodeH264RefListModEntry.Ptr that uses the same backing storage as this StdVideoEncodeH264RefListModEntry.Ptr, but with the new size.
@NotNull StdVideoEncodeH264RefPicMarkingEntry.Ptr	StdVideoEncodeH264RefPicMarkingEntry.Ptr.reinterpret(long newSize)	Assume the StdVideoEncodeH264RefPicMarkingEntry.Ptr is capable of holding at least newSize structures, create a new view StdVideoEncodeH264RefPicMarkingEntry.Ptr that uses the same backing storage as this StdVideoEncodeH264RefPicMarkingEntry.Ptr, but with the new size.
@NotNull StdVideoEncodeH264SliceHeader.Ptr	StdVideoEncodeH264SliceHeader.Ptr.reinterpret(long newSize)	Assume the StdVideoEncodeH264SliceHeader.Ptr is capable of holding at least newSize structures, create a new view StdVideoEncodeH264SliceHeader.Ptr that uses the same backing storage as this StdVideoEncodeH264SliceHeader.Ptr, but with the new size.
@NotNull StdVideoEncodeH264SliceHeaderFlags.Ptr	StdVideoEncodeH264SliceHeaderFlags.Ptr.reinterpret(long newSize)	Assume the StdVideoEncodeH264SliceHeaderFlags.Ptr is capable of holding at least newSize structures, create a new view StdVideoEncodeH264SliceHeaderFlags.Ptr that uses the same backing storage as this StdVideoEncodeH264SliceHeaderFlags.Ptr, but with the new size.
@NotNull StdVideoEncodeH264WeightTable.Ptr	StdVideoEncodeH264WeightTable.Ptr.reinterpret(long newSize)	Assume the StdVideoEncodeH264WeightTable.Ptr is capable of holding at least newSize structures, create a new view StdVideoEncodeH264WeightTable.Ptr that uses the same backing storage as this StdVideoEncodeH264WeightTable.Ptr, but with the new size.
@NotNull StdVideoEncodeH264WeightTableFlags.Ptr	StdVideoEncodeH264WeightTableFlags.Ptr.reinterpret(long newSize)	Assume the StdVideoEncodeH264WeightTableFlags.Ptr is capable of holding at least newSize structures, create a new view StdVideoEncodeH264WeightTableFlags.Ptr that uses the same backing storage as this StdVideoEncodeH264WeightTableFlags.Ptr, but with the new size.
@NotNull StdVideoEncodeH265LongTermRefPics.Ptr	StdVideoEncodeH265LongTermRefPics.Ptr.reinterpret(long newSize)	Assume the StdVideoEncodeH265LongTermRefPics.Ptr is capable of holding at least newSize structures, create a new view StdVideoEncodeH265LongTermRefPics.Ptr that uses the same backing storage as this StdVideoEncodeH265LongTermRefPics.Ptr, but with the new size.
@NotNull StdVideoEncodeH265PictureInfo.Ptr	StdVideoEncodeH265PictureInfo.Ptr.reinterpret(long newSize)	Assume the StdVideoEncodeH265PictureInfo.Ptr is capable of holding at least newSize structures, create a new view StdVideoEncodeH265PictureInfo.Ptr that uses the same backing storage as this StdVideoEncodeH265PictureInfo.Ptr, but with the new size.
@NotNull StdVideoEncodeH265PictureInfoFlags.Ptr	StdVideoEncodeH265PictureInfoFlags.Ptr.reinterpret(long newSize)	Assume the StdVideoEncodeH265PictureInfoFlags.Ptr is capable of holding at least newSize structures, create a new view StdVideoEncodeH265PictureInfoFlags.Ptr that uses the same backing storage as this StdVideoEncodeH265PictureInfoFlags.Ptr, but with the new size.
@NotNull StdVideoEncodeH265ReferenceInfo.Ptr	StdVideoEncodeH265ReferenceInfo.Ptr.reinterpret(long newSize)	Assume the StdVideoEncodeH265ReferenceInfo.Ptr is capable of holding at least newSize structures, create a new view StdVideoEncodeH265ReferenceInfo.Ptr that uses the same backing storage as this StdVideoEncodeH265ReferenceInfo.Ptr, but with the new size.
@NotNull StdVideoEncodeH265ReferenceInfoFlags.Ptr	StdVideoEncodeH265ReferenceInfoFlags.Ptr.reinterpret(long newSize)	Assume the StdVideoEncodeH265ReferenceInfoFlags.Ptr is capable of holding at least newSize structures, create a new view StdVideoEncodeH265ReferenceInfoFlags.Ptr that uses the same backing storage as this StdVideoEncodeH265ReferenceInfoFlags.Ptr, but with the new size.
@NotNull StdVideoEncodeH265ReferenceListsInfo.Ptr	StdVideoEncodeH265ReferenceListsInfo.Ptr.reinterpret(long newSize)	Assume the StdVideoEncodeH265ReferenceListsInfo.Ptr is capable of holding at least newSize structures, create a new view StdVideoEncodeH265ReferenceListsInfo.Ptr that uses the same backing storage as this StdVideoEncodeH265ReferenceListsInfo.Ptr, but with the new size.
@NotNull StdVideoEncodeH265ReferenceListsInfoFlags.Ptr	StdVideoEncodeH265ReferenceListsInfoFlags.Ptr.reinterpret(long newSize)	Assume the StdVideoEncodeH265ReferenceListsInfoFlags.Ptr is capable of holding at least newSize structures, create a new view StdVideoEncodeH265ReferenceListsInfoFlags.Ptr that uses the same backing storage as this StdVideoEncodeH265ReferenceListsInfoFlags.Ptr, but with the new size.
@NotNull StdVideoEncodeH265SliceSegmentHeader.Ptr	StdVideoEncodeH265SliceSegmentHeader.Ptr.reinterpret(long newSize)	Assume the StdVideoEncodeH265SliceSegmentHeader.Ptr is capable of holding at least newSize structures, create a new view StdVideoEncodeH265SliceSegmentHeader.Ptr that uses the same backing storage as this StdVideoEncodeH265SliceSegmentHeader.Ptr, but with the new size.
@NotNull StdVideoEncodeH265SliceSegmentHeaderFlags.Ptr	StdVideoEncodeH265SliceSegmentHeaderFlags.Ptr.reinterpret(long newSize)	Assume the StdVideoEncodeH265SliceSegmentHeaderFlags.Ptr is capable of holding at least newSize structures, create a new view StdVideoEncodeH265SliceSegmentHeaderFlags.Ptr that uses the same backing storage as this StdVideoEncodeH265SliceSegmentHeaderFlags.Ptr, but with the new size.
@NotNull StdVideoEncodeH265WeightTable.Ptr	StdVideoEncodeH265WeightTable.Ptr.reinterpret(long newSize)	Assume the StdVideoEncodeH265WeightTable.Ptr is capable of holding at least newSize structures, create a new view StdVideoEncodeH265WeightTable.Ptr that uses the same backing storage as this StdVideoEncodeH265WeightTable.Ptr, but with the new size.
@NotNull StdVideoEncodeH265WeightTableFlags.Ptr	StdVideoEncodeH265WeightTableFlags.Ptr.reinterpret(long newSize)	Assume the StdVideoEncodeH265WeightTableFlags.Ptr is capable of holding at least newSize structures, create a new view StdVideoEncodeH265WeightTableFlags.Ptr that uses the same backing storage as this StdVideoEncodeH265WeightTableFlags.Ptr, but with the new size.
@NotNull StdVideoH264HrdParameters.Ptr	StdVideoH264HrdParameters.Ptr.reinterpret(long newSize)	Assume the StdVideoH264HrdParameters.Ptr is capable of holding at least newSize structures, create a new view StdVideoH264HrdParameters.Ptr that uses the same backing storage as this StdVideoH264HrdParameters.Ptr, but with the new size.
@NotNull StdVideoH264PictureParameterSet.Ptr	StdVideoH264PictureParameterSet.Ptr.reinterpret(long newSize)	Assume the StdVideoH264PictureParameterSet.Ptr is capable of holding at least newSize structures, create a new view StdVideoH264PictureParameterSet.Ptr that uses the same backing storage as this StdVideoH264PictureParameterSet.Ptr, but with the new size.
@NotNull StdVideoH264PpsFlags.Ptr	StdVideoH264PpsFlags.Ptr.reinterpret(long newSize)	Assume the StdVideoH264PpsFlags.Ptr is capable of holding at least newSize structures, create a new view StdVideoH264PpsFlags.Ptr that uses the same backing storage as this StdVideoH264PpsFlags.Ptr, but with the new size.
@NotNull StdVideoH264ScalingLists.Ptr	StdVideoH264ScalingLists.Ptr.reinterpret(long newSize)	Assume the StdVideoH264ScalingLists.Ptr is capable of holding at least newSize structures, create a new view StdVideoH264ScalingLists.Ptr that uses the same backing storage as this StdVideoH264ScalingLists.Ptr, but with the new size.
@NotNull StdVideoH264SequenceParameterSet.Ptr	StdVideoH264SequenceParameterSet.Ptr.reinterpret(long newSize)	Assume the StdVideoH264SequenceParameterSet.Ptr is capable of holding at least newSize structures, create a new view StdVideoH264SequenceParameterSet.Ptr that uses the same backing storage as this StdVideoH264SequenceParameterSet.Ptr, but with the new size.
@NotNull StdVideoH264SequenceParameterSetVui.Ptr	StdVideoH264SequenceParameterSetVui.Ptr.reinterpret(long newSize)	Assume the StdVideoH264SequenceParameterSetVui.Ptr is capable of holding at least newSize structures, create a new view StdVideoH264SequenceParameterSetVui.Ptr that uses the same backing storage as this StdVideoH264SequenceParameterSetVui.Ptr, but with the new size.
@NotNull StdVideoH264SpsFlags.Ptr	StdVideoH264SpsFlags.Ptr.reinterpret(long newSize)	Assume the StdVideoH264SpsFlags.Ptr is capable of holding at least newSize structures, create a new view StdVideoH264SpsFlags.Ptr that uses the same backing storage as this StdVideoH264SpsFlags.Ptr, but with the new size.
@NotNull StdVideoH264SpsVuiFlags.Ptr	StdVideoH264SpsVuiFlags.Ptr.reinterpret(long newSize)	Assume the StdVideoH264SpsVuiFlags.Ptr is capable of holding at least newSize structures, create a new view StdVideoH264SpsVuiFlags.Ptr that uses the same backing storage as this StdVideoH264SpsVuiFlags.Ptr, but with the new size.
@NotNull StdVideoH265DecPicBufMgr.Ptr	StdVideoH265DecPicBufMgr.Ptr.reinterpret(long newSize)	Assume the StdVideoH265DecPicBufMgr.Ptr is capable of holding at least newSize structures, create a new view StdVideoH265DecPicBufMgr.Ptr that uses the same backing storage as this StdVideoH265DecPicBufMgr.Ptr, but with the new size.
@NotNull StdVideoH265HrdFlags.Ptr	StdVideoH265HrdFlags.Ptr.reinterpret(long newSize)	Assume the StdVideoH265HrdFlags.Ptr is capable of holding at least newSize structures, create a new view StdVideoH265HrdFlags.Ptr that uses the same backing storage as this StdVideoH265HrdFlags.Ptr, but with the new size.
@NotNull StdVideoH265HrdParameters.Ptr	StdVideoH265HrdParameters.Ptr.reinterpret(long newSize)	Assume the StdVideoH265HrdParameters.Ptr is capable of holding at least newSize structures, create a new view StdVideoH265HrdParameters.Ptr that uses the same backing storage as this StdVideoH265HrdParameters.Ptr, but with the new size.
@NotNull StdVideoH265LongTermRefPicsSps.Ptr	StdVideoH265LongTermRefPicsSps.Ptr.reinterpret(long newSize)	Assume the StdVideoH265LongTermRefPicsSps.Ptr is capable of holding at least newSize structures, create a new view StdVideoH265LongTermRefPicsSps.Ptr that uses the same backing storage as this StdVideoH265LongTermRefPicsSps.Ptr, but with the new size.
@NotNull StdVideoH265PictureParameterSet.Ptr	StdVideoH265PictureParameterSet.Ptr.reinterpret(long newSize)	Assume the StdVideoH265PictureParameterSet.Ptr is capable of holding at least newSize structures, create a new view StdVideoH265PictureParameterSet.Ptr that uses the same backing storage as this StdVideoH265PictureParameterSet.Ptr, but with the new size.
@NotNull StdVideoH265PpsFlags.Ptr	StdVideoH265PpsFlags.Ptr.reinterpret(long newSize)	Assume the StdVideoH265PpsFlags.Ptr is capable of holding at least newSize structures, create a new view StdVideoH265PpsFlags.Ptr that uses the same backing storage as this StdVideoH265PpsFlags.Ptr, but with the new size.
@NotNull StdVideoH265PredictorPaletteEntries.Ptr	StdVideoH265PredictorPaletteEntries.Ptr.reinterpret(long newSize)	Assume the StdVideoH265PredictorPaletteEntries.Ptr is capable of holding at least newSize structures, create a new view StdVideoH265PredictorPaletteEntries.Ptr that uses the same backing storage as this StdVideoH265PredictorPaletteEntries.Ptr, but with the new size.
@NotNull StdVideoH265ProfileTierLevel.Ptr	StdVideoH265ProfileTierLevel.Ptr.reinterpret(long newSize)	Assume the StdVideoH265ProfileTierLevel.Ptr is capable of holding at least newSize structures, create a new view StdVideoH265ProfileTierLevel.Ptr that uses the same backing storage as this StdVideoH265ProfileTierLevel.Ptr, but with the new size.
@NotNull StdVideoH265ProfileTierLevelFlags.Ptr	StdVideoH265ProfileTierLevelFlags.Ptr.reinterpret(long newSize)	Assume the StdVideoH265ProfileTierLevelFlags.Ptr is capable of holding at least newSize structures, create a new view StdVideoH265ProfileTierLevelFlags.Ptr that uses the same backing storage as this StdVideoH265ProfileTierLevelFlags.Ptr, but with the new size.
@NotNull StdVideoH265ScalingLists.Ptr	StdVideoH265ScalingLists.Ptr.reinterpret(long newSize)	Assume the StdVideoH265ScalingLists.Ptr is capable of holding at least newSize structures, create a new view StdVideoH265ScalingLists.Ptr that uses the same backing storage as this StdVideoH265ScalingLists.Ptr, but with the new size.
@NotNull StdVideoH265SequenceParameterSet.Ptr	StdVideoH265SequenceParameterSet.Ptr.reinterpret(long newSize)	Assume the StdVideoH265SequenceParameterSet.Ptr is capable of holding at least newSize structures, create a new view StdVideoH265SequenceParameterSet.Ptr that uses the same backing storage as this StdVideoH265SequenceParameterSet.Ptr, but with the new size.
@NotNull StdVideoH265SequenceParameterSetVui.Ptr	StdVideoH265SequenceParameterSetVui.Ptr.reinterpret(long newSize)	Assume the StdVideoH265SequenceParameterSetVui.Ptr is capable of holding at least newSize structures, create a new view StdVideoH265SequenceParameterSetVui.Ptr that uses the same backing storage as this StdVideoH265SequenceParameterSetVui.Ptr, but with the new size.
@NotNull StdVideoH265ShortTermRefPicSet.Ptr	StdVideoH265ShortTermRefPicSet.Ptr.reinterpret(long newSize)	Assume the StdVideoH265ShortTermRefPicSet.Ptr is capable of holding at least newSize structures, create a new view StdVideoH265ShortTermRefPicSet.Ptr that uses the same backing storage as this StdVideoH265ShortTermRefPicSet.Ptr, but with the new size.
@NotNull StdVideoH265ShortTermRefPicSetFlags.Ptr	StdVideoH265ShortTermRefPicSetFlags.Ptr.reinterpret(long newSize)	Assume the StdVideoH265ShortTermRefPicSetFlags.Ptr is capable of holding at least newSize structures, create a new view StdVideoH265ShortTermRefPicSetFlags.Ptr that uses the same backing storage as this StdVideoH265ShortTermRefPicSetFlags.Ptr, but with the new size.
@NotNull StdVideoH265SpsFlags.Ptr	StdVideoH265SpsFlags.Ptr.reinterpret(long newSize)	Assume the StdVideoH265SpsFlags.Ptr is capable of holding at least newSize structures, create a new view StdVideoH265SpsFlags.Ptr that uses the same backing storage as this StdVideoH265SpsFlags.Ptr, but with the new size.
@NotNull StdVideoH265SpsVuiFlags.Ptr	StdVideoH265SpsVuiFlags.Ptr.reinterpret(long newSize)	Assume the StdVideoH265SpsVuiFlags.Ptr is capable of holding at least newSize structures, create a new view StdVideoH265SpsVuiFlags.Ptr that uses the same backing storage as this StdVideoH265SpsVuiFlags.Ptr, but with the new size.
@NotNull StdVideoH265SubLayerHrdParameters.Ptr	StdVideoH265SubLayerHrdParameters.Ptr.reinterpret(long newSize)	Assume the StdVideoH265SubLayerHrdParameters.Ptr is capable of holding at least newSize structures, create a new view StdVideoH265SubLayerHrdParameters.Ptr that uses the same backing storage as this StdVideoH265SubLayerHrdParameters.Ptr, but with the new size.
@NotNull StdVideoH265VideoParameterSet.Ptr	StdVideoH265VideoParameterSet.Ptr.reinterpret(long newSize)	Assume the StdVideoH265VideoParameterSet.Ptr is capable of holding at least newSize structures, create a new view StdVideoH265VideoParameterSet.Ptr that uses the same backing storage as this StdVideoH265VideoParameterSet.Ptr, but with the new size.
@NotNull StdVideoH265VpsFlags.Ptr	StdVideoH265VpsFlags.Ptr.reinterpret(long newSize)	Assume the StdVideoH265VpsFlags.Ptr is capable of holding at least newSize structures, create a new view StdVideoH265VpsFlags.Ptr that uses the same backing storage as this StdVideoH265VpsFlags.Ptr, but with the new size.
@NotNull VkAabbPositionsKHR.Ptr	VkAabbPositionsKHR.Ptr.reinterpret(long newSize)	Assume the VkAabbPositionsKHR.Ptr is capable of holding at least newSize structures, create a new view VkAabbPositionsKHR.Ptr that uses the same backing storage as this VkAabbPositionsKHR.Ptr, but with the new size.
@NotNull VkAccelerationStructureBuildGeometryInfoKHR.Ptr	VkAccelerationStructureBuildGeometryInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkAccelerationStructureBuildGeometryInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkAccelerationStructureBuildGeometryInfoKHR.Ptr that uses the same backing storage as this VkAccelerationStructureBuildGeometryInfoKHR.Ptr, but with the new size.
@NotNull VkAccelerationStructureBuildRangeInfoKHR.Ptr	VkAccelerationStructureBuildRangeInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkAccelerationStructureBuildRangeInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkAccelerationStructureBuildRangeInfoKHR.Ptr that uses the same backing storage as this VkAccelerationStructureBuildRangeInfoKHR.Ptr, but with the new size.
@NotNull VkAccelerationStructureBuildSizesInfoKHR.Ptr	VkAccelerationStructureBuildSizesInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkAccelerationStructureBuildSizesInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkAccelerationStructureBuildSizesInfoKHR.Ptr that uses the same backing storage as this VkAccelerationStructureBuildSizesInfoKHR.Ptr, but with the new size.
@NotNull VkAccelerationStructureCaptureDescriptorDataInfoEXT.Ptr	VkAccelerationStructureCaptureDescriptorDataInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkAccelerationStructureCaptureDescriptorDataInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkAccelerationStructureCaptureDescriptorDataInfoEXT.Ptr that uses the same backing storage as this VkAccelerationStructureCaptureDescriptorDataInfoEXT.Ptr, but with the new size.
@NotNull VkAccelerationStructureCreateInfoKHR.Ptr	VkAccelerationStructureCreateInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkAccelerationStructureCreateInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkAccelerationStructureCreateInfoKHR.Ptr that uses the same backing storage as this VkAccelerationStructureCreateInfoKHR.Ptr, but with the new size.
@NotNull VkAccelerationStructureCreateInfoNV.Ptr	VkAccelerationStructureCreateInfoNV.Ptr.reinterpret(long newSize)	Assume the VkAccelerationStructureCreateInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkAccelerationStructureCreateInfoNV.Ptr that uses the same backing storage as this VkAccelerationStructureCreateInfoNV.Ptr, but with the new size.
@NotNull VkAccelerationStructureDeviceAddressInfoKHR.Ptr	VkAccelerationStructureDeviceAddressInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkAccelerationStructureDeviceAddressInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkAccelerationStructureDeviceAddressInfoKHR.Ptr that uses the same backing storage as this VkAccelerationStructureDeviceAddressInfoKHR.Ptr, but with the new size.
@NotNull VkAccelerationStructureGeometryAabbsDataKHR.Ptr	VkAccelerationStructureGeometryAabbsDataKHR.Ptr.reinterpret(long newSize)	Assume the VkAccelerationStructureGeometryAabbsDataKHR.Ptr is capable of holding at least newSize structures, create a new view VkAccelerationStructureGeometryAabbsDataKHR.Ptr that uses the same backing storage as this VkAccelerationStructureGeometryAabbsDataKHR.Ptr, but with the new size.
@NotNull VkAccelerationStructureGeometryDataKHR.Ptr	VkAccelerationStructureGeometryDataKHR.Ptr.reinterpret(long newSize)	Assume the VkAccelerationStructureGeometryDataKHR.Ptr is capable of holding at least newSize structures, create a new view VkAccelerationStructureGeometryDataKHR.Ptr that uses the same backing storage as this VkAccelerationStructureGeometryDataKHR.Ptr, but with the new size.
@NotNull VkAccelerationStructureGeometryInstancesDataKHR.Ptr	VkAccelerationStructureGeometryInstancesDataKHR.Ptr.reinterpret(long newSize)	Assume the VkAccelerationStructureGeometryInstancesDataKHR.Ptr is capable of holding at least newSize structures, create a new view VkAccelerationStructureGeometryInstancesDataKHR.Ptr that uses the same backing storage as this VkAccelerationStructureGeometryInstancesDataKHR.Ptr, but with the new size.
@NotNull VkAccelerationStructureGeometryKHR.Ptr	VkAccelerationStructureGeometryKHR.Ptr.reinterpret(long newSize)	Assume the VkAccelerationStructureGeometryKHR.Ptr is capable of holding at least newSize structures, create a new view VkAccelerationStructureGeometryKHR.Ptr that uses the same backing storage as this VkAccelerationStructureGeometryKHR.Ptr, but with the new size.
@NotNull VkAccelerationStructureGeometryLinearSweptSpheresDataNV.Ptr	VkAccelerationStructureGeometryLinearSweptSpheresDataNV.Ptr.reinterpret(long newSize)	Assume the VkAccelerationStructureGeometryLinearSweptSpheresDataNV.Ptr is capable of holding at least newSize structures, create a new view VkAccelerationStructureGeometryLinearSweptSpheresDataNV.Ptr that uses the same backing storage as this VkAccelerationStructureGeometryLinearSweptSpheresDataNV.Ptr, but with the new size.
@NotNull VkAccelerationStructureGeometryMotionTrianglesDataNV.Ptr	VkAccelerationStructureGeometryMotionTrianglesDataNV.Ptr.reinterpret(long newSize)	Assume the VkAccelerationStructureGeometryMotionTrianglesDataNV.Ptr is capable of holding at least newSize structures, create a new view VkAccelerationStructureGeometryMotionTrianglesDataNV.Ptr that uses the same backing storage as this VkAccelerationStructureGeometryMotionTrianglesDataNV.Ptr, but with the new size.
@NotNull VkAccelerationStructureGeometrySpheresDataNV.Ptr	VkAccelerationStructureGeometrySpheresDataNV.Ptr.reinterpret(long newSize)	Assume the VkAccelerationStructureGeometrySpheresDataNV.Ptr is capable of holding at least newSize structures, create a new view VkAccelerationStructureGeometrySpheresDataNV.Ptr that uses the same backing storage as this VkAccelerationStructureGeometrySpheresDataNV.Ptr, but with the new size.
@NotNull VkAccelerationStructureGeometryTrianglesDataKHR.Ptr	VkAccelerationStructureGeometryTrianglesDataKHR.Ptr.reinterpret(long newSize)	Assume the VkAccelerationStructureGeometryTrianglesDataKHR.Ptr is capable of holding at least newSize structures, create a new view VkAccelerationStructureGeometryTrianglesDataKHR.Ptr that uses the same backing storage as this VkAccelerationStructureGeometryTrianglesDataKHR.Ptr, but with the new size.
@NotNull VkAccelerationStructureInfoNV.Ptr	VkAccelerationStructureInfoNV.Ptr.reinterpret(long newSize)	Assume the VkAccelerationStructureInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkAccelerationStructureInfoNV.Ptr that uses the same backing storage as this VkAccelerationStructureInfoNV.Ptr, but with the new size.
@NotNull VkAccelerationStructureInstanceKHR.Ptr	VkAccelerationStructureInstanceKHR.Ptr.reinterpret(long newSize)	Assume the VkAccelerationStructureInstanceKHR.Ptr is capable of holding at least newSize structures, create a new view VkAccelerationStructureInstanceKHR.Ptr that uses the same backing storage as this VkAccelerationStructureInstanceKHR.Ptr, but with the new size.
@NotNull VkAccelerationStructureMatrixMotionInstanceNV.Ptr	VkAccelerationStructureMatrixMotionInstanceNV.Ptr.reinterpret(long newSize)	Assume the VkAccelerationStructureMatrixMotionInstanceNV.Ptr is capable of holding at least newSize structures, create a new view VkAccelerationStructureMatrixMotionInstanceNV.Ptr that uses the same backing storage as this VkAccelerationStructureMatrixMotionInstanceNV.Ptr, but with the new size.
@NotNull VkAccelerationStructureMemoryRequirementsInfoNV.Ptr	VkAccelerationStructureMemoryRequirementsInfoNV.Ptr.reinterpret(long newSize)	Assume the VkAccelerationStructureMemoryRequirementsInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkAccelerationStructureMemoryRequirementsInfoNV.Ptr that uses the same backing storage as this VkAccelerationStructureMemoryRequirementsInfoNV.Ptr, but with the new size.
@NotNull VkAccelerationStructureMotionInfoNV.Ptr	VkAccelerationStructureMotionInfoNV.Ptr.reinterpret(long newSize)	Assume the VkAccelerationStructureMotionInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkAccelerationStructureMotionInfoNV.Ptr that uses the same backing storage as this VkAccelerationStructureMotionInfoNV.Ptr, but with the new size.
@NotNull VkAccelerationStructureMotionInstanceDataNV.Ptr	VkAccelerationStructureMotionInstanceDataNV.Ptr.reinterpret(long newSize)	Assume the VkAccelerationStructureMotionInstanceDataNV.Ptr is capable of holding at least newSize structures, create a new view VkAccelerationStructureMotionInstanceDataNV.Ptr that uses the same backing storage as this VkAccelerationStructureMotionInstanceDataNV.Ptr, but with the new size.
@NotNull VkAccelerationStructureMotionInstanceNV.Ptr	VkAccelerationStructureMotionInstanceNV.Ptr.reinterpret(long newSize)	Assume the VkAccelerationStructureMotionInstanceNV.Ptr is capable of holding at least newSize structures, create a new view VkAccelerationStructureMotionInstanceNV.Ptr that uses the same backing storage as this VkAccelerationStructureMotionInstanceNV.Ptr, but with the new size.
@NotNull VkAccelerationStructureSRTMotionInstanceNV.Ptr	VkAccelerationStructureSRTMotionInstanceNV.Ptr.reinterpret(long newSize)	Assume the VkAccelerationStructureSRTMotionInstanceNV.Ptr is capable of holding at least newSize structures, create a new view VkAccelerationStructureSRTMotionInstanceNV.Ptr that uses the same backing storage as this VkAccelerationStructureSRTMotionInstanceNV.Ptr, but with the new size.
@NotNull VkAccelerationStructureTrianglesDisplacementMicromapNV.Ptr	VkAccelerationStructureTrianglesDisplacementMicromapNV.Ptr.reinterpret(long newSize)	Assume the VkAccelerationStructureTrianglesDisplacementMicromapNV.Ptr is capable of holding at least newSize structures, create a new view VkAccelerationStructureTrianglesDisplacementMicromapNV.Ptr that uses the same backing storage as this VkAccelerationStructureTrianglesDisplacementMicromapNV.Ptr, but with the new size.
@NotNull VkAccelerationStructureTrianglesOpacityMicromapEXT.Ptr	VkAccelerationStructureTrianglesOpacityMicromapEXT.Ptr.reinterpret(long newSize)	Assume the VkAccelerationStructureTrianglesOpacityMicromapEXT.Ptr is capable of holding at least newSize structures, create a new view VkAccelerationStructureTrianglesOpacityMicromapEXT.Ptr that uses the same backing storage as this VkAccelerationStructureTrianglesOpacityMicromapEXT.Ptr, but with the new size.
@NotNull VkAccelerationStructureVersionInfoKHR.Ptr	VkAccelerationStructureVersionInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkAccelerationStructureVersionInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkAccelerationStructureVersionInfoKHR.Ptr that uses the same backing storage as this VkAccelerationStructureVersionInfoKHR.Ptr, but with the new size.
@NotNull VkAcquireNextImageInfoKHR.Ptr	VkAcquireNextImageInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkAcquireNextImageInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkAcquireNextImageInfoKHR.Ptr that uses the same backing storage as this VkAcquireNextImageInfoKHR.Ptr, but with the new size.
@NotNull VkAcquireProfilingLockInfoKHR.Ptr	VkAcquireProfilingLockInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkAcquireProfilingLockInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkAcquireProfilingLockInfoKHR.Ptr that uses the same backing storage as this VkAcquireProfilingLockInfoKHR.Ptr, but with the new size.
@NotNull VkAllocationCallbacks.Ptr	VkAllocationCallbacks.Ptr.reinterpret(long newSize)	Assume the VkAllocationCallbacks.Ptr is capable of holding at least newSize structures, create a new view VkAllocationCallbacks.Ptr that uses the same backing storage as this VkAllocationCallbacks.Ptr, but with the new size.
@NotNull VkAmigoProfilingSubmitInfoSEC.Ptr	VkAmigoProfilingSubmitInfoSEC.Ptr.reinterpret(long newSize)	Assume the VkAmigoProfilingSubmitInfoSEC.Ptr is capable of holding at least newSize structures, create a new view VkAmigoProfilingSubmitInfoSEC.Ptr that uses the same backing storage as this VkAmigoProfilingSubmitInfoSEC.Ptr, but with the new size.
@NotNull VkAndroidHardwareBufferFormatProperties2ANDROID.Ptr	VkAndroidHardwareBufferFormatProperties2ANDROID.Ptr.reinterpret(long newSize)	Assume the VkAndroidHardwareBufferFormatProperties2ANDROID.Ptr is capable of holding at least newSize structures, create a new view VkAndroidHardwareBufferFormatProperties2ANDROID.Ptr that uses the same backing storage as this VkAndroidHardwareBufferFormatProperties2ANDROID.Ptr, but with the new size.
@NotNull VkAndroidHardwareBufferFormatPropertiesANDROID.Ptr	VkAndroidHardwareBufferFormatPropertiesANDROID.Ptr.reinterpret(long newSize)	Assume the VkAndroidHardwareBufferFormatPropertiesANDROID.Ptr is capable of holding at least newSize structures, create a new view VkAndroidHardwareBufferFormatPropertiesANDROID.Ptr that uses the same backing storage as this VkAndroidHardwareBufferFormatPropertiesANDROID.Ptr, but with the new size.
@NotNull VkAndroidHardwareBufferFormatResolvePropertiesANDROID.Ptr	VkAndroidHardwareBufferFormatResolvePropertiesANDROID.Ptr.reinterpret(long newSize)	Assume the VkAndroidHardwareBufferFormatResolvePropertiesANDROID.Ptr is capable of holding at least newSize structures, create a new view VkAndroidHardwareBufferFormatResolvePropertiesANDROID.Ptr that uses the same backing storage as this VkAndroidHardwareBufferFormatResolvePropertiesANDROID.Ptr, but with the new size.
@NotNull VkAndroidHardwareBufferPropertiesANDROID.Ptr	VkAndroidHardwareBufferPropertiesANDROID.Ptr.reinterpret(long newSize)	Assume the VkAndroidHardwareBufferPropertiesANDROID.Ptr is capable of holding at least newSize structures, create a new view VkAndroidHardwareBufferPropertiesANDROID.Ptr that uses the same backing storage as this VkAndroidHardwareBufferPropertiesANDROID.Ptr, but with the new size.
@NotNull VkAndroidHardwareBufferUsageANDROID.Ptr	VkAndroidHardwareBufferUsageANDROID.Ptr.reinterpret(long newSize)	Assume the VkAndroidHardwareBufferUsageANDROID.Ptr is capable of holding at least newSize structures, create a new view VkAndroidHardwareBufferUsageANDROID.Ptr that uses the same backing storage as this VkAndroidHardwareBufferUsageANDROID.Ptr, but with the new size.
@NotNull VkAndroidSurfaceCreateInfoKHR.Ptr	VkAndroidSurfaceCreateInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkAndroidSurfaceCreateInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkAndroidSurfaceCreateInfoKHR.Ptr that uses the same backing storage as this VkAndroidSurfaceCreateInfoKHR.Ptr, but with the new size.
@NotNull VkAntiLagDataAMD.Ptr	VkAntiLagDataAMD.Ptr.reinterpret(long newSize)	Assume the VkAntiLagDataAMD.Ptr is capable of holding at least newSize structures, create a new view VkAntiLagDataAMD.Ptr that uses the same backing storage as this VkAntiLagDataAMD.Ptr, but with the new size.
@NotNull VkAntiLagPresentationInfoAMD.Ptr	VkAntiLagPresentationInfoAMD.Ptr.reinterpret(long newSize)	Assume the VkAntiLagPresentationInfoAMD.Ptr is capable of holding at least newSize structures, create a new view VkAntiLagPresentationInfoAMD.Ptr that uses the same backing storage as this VkAntiLagPresentationInfoAMD.Ptr, but with the new size.
@NotNull VkApplicationInfo.Ptr	VkApplicationInfo.Ptr.reinterpret(long newSize)	Assume the VkApplicationInfo.Ptr is capable of holding at least newSize structures, create a new view VkApplicationInfo.Ptr that uses the same backing storage as this VkApplicationInfo.Ptr, but with the new size.
@NotNull VkApplicationParametersEXT.Ptr	VkApplicationParametersEXT.Ptr.reinterpret(long newSize)	Assume the VkApplicationParametersEXT.Ptr is capable of holding at least newSize structures, create a new view VkApplicationParametersEXT.Ptr that uses the same backing storage as this VkApplicationParametersEXT.Ptr, but with the new size.
@NotNull VkAttachmentDescription.Ptr	VkAttachmentDescription.Ptr.reinterpret(long newSize)	Assume the VkAttachmentDescription.Ptr is capable of holding at least newSize structures, create a new view VkAttachmentDescription.Ptr that uses the same backing storage as this VkAttachmentDescription.Ptr, but with the new size.
@NotNull VkAttachmentDescription2.Ptr	VkAttachmentDescription2.Ptr.reinterpret(long newSize)	Assume the VkAttachmentDescription2.Ptr is capable of holding at least newSize structures, create a new view VkAttachmentDescription2.Ptr that uses the same backing storage as this VkAttachmentDescription2.Ptr, but with the new size.
@NotNull VkAttachmentDescriptionStencilLayout.Ptr	VkAttachmentDescriptionStencilLayout.Ptr.reinterpret(long newSize)	Assume the VkAttachmentDescriptionStencilLayout.Ptr is capable of holding at least newSize structures, create a new view VkAttachmentDescriptionStencilLayout.Ptr that uses the same backing storage as this VkAttachmentDescriptionStencilLayout.Ptr, but with the new size.
@NotNull VkAttachmentReference.Ptr	VkAttachmentReference.Ptr.reinterpret(long newSize)	Assume the VkAttachmentReference.Ptr is capable of holding at least newSize structures, create a new view VkAttachmentReference.Ptr that uses the same backing storage as this VkAttachmentReference.Ptr, but with the new size.
@NotNull VkAttachmentReference2.Ptr	VkAttachmentReference2.Ptr.reinterpret(long newSize)	Assume the VkAttachmentReference2.Ptr is capable of holding at least newSize structures, create a new view VkAttachmentReference2.Ptr that uses the same backing storage as this VkAttachmentReference2.Ptr, but with the new size.
@NotNull VkAttachmentReferenceStencilLayout.Ptr	VkAttachmentReferenceStencilLayout.Ptr.reinterpret(long newSize)	Assume the VkAttachmentReferenceStencilLayout.Ptr is capable of holding at least newSize structures, create a new view VkAttachmentReferenceStencilLayout.Ptr that uses the same backing storage as this VkAttachmentReferenceStencilLayout.Ptr, but with the new size.
@NotNull VkAttachmentSampleCountInfoAMD.Ptr	VkAttachmentSampleCountInfoAMD.Ptr.reinterpret(long newSize)	Assume the VkAttachmentSampleCountInfoAMD.Ptr is capable of holding at least newSize structures, create a new view VkAttachmentSampleCountInfoAMD.Ptr that uses the same backing storage as this VkAttachmentSampleCountInfoAMD.Ptr, but with the new size.
@NotNull VkAttachmentSampleLocationsEXT.Ptr	VkAttachmentSampleLocationsEXT.Ptr.reinterpret(long newSize)	Assume the VkAttachmentSampleLocationsEXT.Ptr is capable of holding at least newSize structures, create a new view VkAttachmentSampleLocationsEXT.Ptr that uses the same backing storage as this VkAttachmentSampleLocationsEXT.Ptr, but with the new size.
@NotNull VkBaseInStructure.Ptr	VkBaseInStructure.Ptr.reinterpret(long newSize)	Assume the VkBaseInStructure.Ptr is capable of holding at least newSize structures, create a new view VkBaseInStructure.Ptr that uses the same backing storage as this VkBaseInStructure.Ptr, but with the new size.
@NotNull VkBaseOutStructure.Ptr	VkBaseOutStructure.Ptr.reinterpret(long newSize)	Assume the VkBaseOutStructure.Ptr is capable of holding at least newSize structures, create a new view VkBaseOutStructure.Ptr that uses the same backing storage as this VkBaseOutStructure.Ptr, but with the new size.
@NotNull VkBindAccelerationStructureMemoryInfoNV.Ptr	VkBindAccelerationStructureMemoryInfoNV.Ptr.reinterpret(long newSize)	Assume the VkBindAccelerationStructureMemoryInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkBindAccelerationStructureMemoryInfoNV.Ptr that uses the same backing storage as this VkBindAccelerationStructureMemoryInfoNV.Ptr, but with the new size.
@NotNull VkBindBufferMemoryDeviceGroupInfo.Ptr	VkBindBufferMemoryDeviceGroupInfo.Ptr.reinterpret(long newSize)	Assume the VkBindBufferMemoryDeviceGroupInfo.Ptr is capable of holding at least newSize structures, create a new view VkBindBufferMemoryDeviceGroupInfo.Ptr that uses the same backing storage as this VkBindBufferMemoryDeviceGroupInfo.Ptr, but with the new size.
@NotNull VkBindBufferMemoryInfo.Ptr	VkBindBufferMemoryInfo.Ptr.reinterpret(long newSize)	Assume the VkBindBufferMemoryInfo.Ptr is capable of holding at least newSize structures, create a new view VkBindBufferMemoryInfo.Ptr that uses the same backing storage as this VkBindBufferMemoryInfo.Ptr, but with the new size.
@NotNull VkBindDescriptorBufferEmbeddedSamplersInfoEXT.Ptr	VkBindDescriptorBufferEmbeddedSamplersInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkBindDescriptorBufferEmbeddedSamplersInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkBindDescriptorBufferEmbeddedSamplersInfoEXT.Ptr that uses the same backing storage as this VkBindDescriptorBufferEmbeddedSamplersInfoEXT.Ptr, but with the new size.
@NotNull VkBindDescriptorSetsInfo.Ptr	VkBindDescriptorSetsInfo.Ptr.reinterpret(long newSize)	Assume the VkBindDescriptorSetsInfo.Ptr is capable of holding at least newSize structures, create a new view VkBindDescriptorSetsInfo.Ptr that uses the same backing storage as this VkBindDescriptorSetsInfo.Ptr, but with the new size.
@NotNull VkBindImageMemoryDeviceGroupInfo.Ptr	VkBindImageMemoryDeviceGroupInfo.Ptr.reinterpret(long newSize)	Assume the VkBindImageMemoryDeviceGroupInfo.Ptr is capable of holding at least newSize structures, create a new view VkBindImageMemoryDeviceGroupInfo.Ptr that uses the same backing storage as this VkBindImageMemoryDeviceGroupInfo.Ptr, but with the new size.
@NotNull VkBindImageMemoryInfo.Ptr	VkBindImageMemoryInfo.Ptr.reinterpret(long newSize)	Assume the VkBindImageMemoryInfo.Ptr is capable of holding at least newSize structures, create a new view VkBindImageMemoryInfo.Ptr that uses the same backing storage as this VkBindImageMemoryInfo.Ptr, but with the new size.
@NotNull VkBindImageMemorySwapchainInfoKHR.Ptr	VkBindImageMemorySwapchainInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkBindImageMemorySwapchainInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkBindImageMemorySwapchainInfoKHR.Ptr that uses the same backing storage as this VkBindImageMemorySwapchainInfoKHR.Ptr, but with the new size.
@NotNull VkBindImagePlaneMemoryInfo.Ptr	VkBindImagePlaneMemoryInfo.Ptr.reinterpret(long newSize)	Assume the VkBindImagePlaneMemoryInfo.Ptr is capable of holding at least newSize structures, create a new view VkBindImagePlaneMemoryInfo.Ptr that uses the same backing storage as this VkBindImagePlaneMemoryInfo.Ptr, but with the new size.
@NotNull VkBindIndexBufferIndirectCommandEXT.Ptr	VkBindIndexBufferIndirectCommandEXT.Ptr.reinterpret(long newSize)	Assume the VkBindIndexBufferIndirectCommandEXT.Ptr is capable of holding at least newSize structures, create a new view VkBindIndexBufferIndirectCommandEXT.Ptr that uses the same backing storage as this VkBindIndexBufferIndirectCommandEXT.Ptr, but with the new size.
@NotNull VkBindIndexBufferIndirectCommandNV.Ptr	VkBindIndexBufferIndirectCommandNV.Ptr.reinterpret(long newSize)	Assume the VkBindIndexBufferIndirectCommandNV.Ptr is capable of holding at least newSize structures, create a new view VkBindIndexBufferIndirectCommandNV.Ptr that uses the same backing storage as this VkBindIndexBufferIndirectCommandNV.Ptr, but with the new size.
@NotNull VkBindMemoryStatus.Ptr	VkBindMemoryStatus.Ptr.reinterpret(long newSize)	Assume the VkBindMemoryStatus.Ptr is capable of holding at least newSize structures, create a new view VkBindMemoryStatus.Ptr that uses the same backing storage as this VkBindMemoryStatus.Ptr, but with the new size.
@NotNull VkBindPipelineIndirectCommandNV.Ptr	VkBindPipelineIndirectCommandNV.Ptr.reinterpret(long newSize)	Assume the VkBindPipelineIndirectCommandNV.Ptr is capable of holding at least newSize structures, create a new view VkBindPipelineIndirectCommandNV.Ptr that uses the same backing storage as this VkBindPipelineIndirectCommandNV.Ptr, but with the new size.
@NotNull VkBindShaderGroupIndirectCommandNV.Ptr	VkBindShaderGroupIndirectCommandNV.Ptr.reinterpret(long newSize)	Assume the VkBindShaderGroupIndirectCommandNV.Ptr is capable of holding at least newSize structures, create a new view VkBindShaderGroupIndirectCommandNV.Ptr that uses the same backing storage as this VkBindShaderGroupIndirectCommandNV.Ptr, but with the new size.
@NotNull VkBindSparseInfo.Ptr	VkBindSparseInfo.Ptr.reinterpret(long newSize)	Assume the VkBindSparseInfo.Ptr is capable of holding at least newSize structures, create a new view VkBindSparseInfo.Ptr that uses the same backing storage as this VkBindSparseInfo.Ptr, but with the new size.
@NotNull VkBindVertexBufferIndirectCommandEXT.Ptr	VkBindVertexBufferIndirectCommandEXT.Ptr.reinterpret(long newSize)	Assume the VkBindVertexBufferIndirectCommandEXT.Ptr is capable of holding at least newSize structures, create a new view VkBindVertexBufferIndirectCommandEXT.Ptr that uses the same backing storage as this VkBindVertexBufferIndirectCommandEXT.Ptr, but with the new size.
@NotNull VkBindVertexBufferIndirectCommandNV.Ptr	VkBindVertexBufferIndirectCommandNV.Ptr.reinterpret(long newSize)	Assume the VkBindVertexBufferIndirectCommandNV.Ptr is capable of holding at least newSize structures, create a new view VkBindVertexBufferIndirectCommandNV.Ptr that uses the same backing storage as this VkBindVertexBufferIndirectCommandNV.Ptr, but with the new size.
@NotNull VkBindVideoSessionMemoryInfoKHR.Ptr	VkBindVideoSessionMemoryInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkBindVideoSessionMemoryInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkBindVideoSessionMemoryInfoKHR.Ptr that uses the same backing storage as this VkBindVideoSessionMemoryInfoKHR.Ptr, but with the new size.
@NotNull VkBlitImageCubicWeightsInfoQCOM.Ptr	VkBlitImageCubicWeightsInfoQCOM.Ptr.reinterpret(long newSize)	Assume the VkBlitImageCubicWeightsInfoQCOM.Ptr is capable of holding at least newSize structures, create a new view VkBlitImageCubicWeightsInfoQCOM.Ptr that uses the same backing storage as this VkBlitImageCubicWeightsInfoQCOM.Ptr, but with the new size.
@NotNull VkBlitImageInfo2.Ptr	VkBlitImageInfo2.Ptr.reinterpret(long newSize)	Assume the VkBlitImageInfo2.Ptr is capable of holding at least newSize structures, create a new view VkBlitImageInfo2.Ptr that uses the same backing storage as this VkBlitImageInfo2.Ptr, but with the new size.
@NotNull VkBufferCaptureDescriptorDataInfoEXT.Ptr	VkBufferCaptureDescriptorDataInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkBufferCaptureDescriptorDataInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkBufferCaptureDescriptorDataInfoEXT.Ptr that uses the same backing storage as this VkBufferCaptureDescriptorDataInfoEXT.Ptr, but with the new size.
@NotNull VkBufferCollectionBufferCreateInfoFUCHSIA.Ptr	VkBufferCollectionBufferCreateInfoFUCHSIA.Ptr.reinterpret(long newSize)	Assume the VkBufferCollectionBufferCreateInfoFUCHSIA.Ptr is capable of holding at least newSize structures, create a new view VkBufferCollectionBufferCreateInfoFUCHSIA.Ptr that uses the same backing storage as this VkBufferCollectionBufferCreateInfoFUCHSIA.Ptr, but with the new size.
@NotNull VkBufferCollectionConstraintsInfoFUCHSIA.Ptr	VkBufferCollectionConstraintsInfoFUCHSIA.Ptr.reinterpret(long newSize)	Assume the VkBufferCollectionConstraintsInfoFUCHSIA.Ptr is capable of holding at least newSize structures, create a new view VkBufferCollectionConstraintsInfoFUCHSIA.Ptr that uses the same backing storage as this VkBufferCollectionConstraintsInfoFUCHSIA.Ptr, but with the new size.
@NotNull VkBufferCollectionCreateInfoFUCHSIA.Ptr	VkBufferCollectionCreateInfoFUCHSIA.Ptr.reinterpret(long newSize)	Assume the VkBufferCollectionCreateInfoFUCHSIA.Ptr is capable of holding at least newSize structures, create a new view VkBufferCollectionCreateInfoFUCHSIA.Ptr that uses the same backing storage as this VkBufferCollectionCreateInfoFUCHSIA.Ptr, but with the new size.
@NotNull VkBufferCollectionImageCreateInfoFUCHSIA.Ptr	VkBufferCollectionImageCreateInfoFUCHSIA.Ptr.reinterpret(long newSize)	Assume the VkBufferCollectionImageCreateInfoFUCHSIA.Ptr is capable of holding at least newSize structures, create a new view VkBufferCollectionImageCreateInfoFUCHSIA.Ptr that uses the same backing storage as this VkBufferCollectionImageCreateInfoFUCHSIA.Ptr, but with the new size.
@NotNull VkBufferCollectionPropertiesFUCHSIA.Ptr	VkBufferCollectionPropertiesFUCHSIA.Ptr.reinterpret(long newSize)	Assume the VkBufferCollectionPropertiesFUCHSIA.Ptr is capable of holding at least newSize structures, create a new view VkBufferCollectionPropertiesFUCHSIA.Ptr that uses the same backing storage as this VkBufferCollectionPropertiesFUCHSIA.Ptr, but with the new size.
@NotNull VkBufferConstraintsInfoFUCHSIA.Ptr	VkBufferConstraintsInfoFUCHSIA.Ptr.reinterpret(long newSize)	Assume the VkBufferConstraintsInfoFUCHSIA.Ptr is capable of holding at least newSize structures, create a new view VkBufferConstraintsInfoFUCHSIA.Ptr that uses the same backing storage as this VkBufferConstraintsInfoFUCHSIA.Ptr, but with the new size.
@NotNull VkBufferCopy.Ptr	VkBufferCopy.Ptr.reinterpret(long newSize)	Assume the VkBufferCopy.Ptr is capable of holding at least newSize structures, create a new view VkBufferCopy.Ptr that uses the same backing storage as this VkBufferCopy.Ptr, but with the new size.
@NotNull VkBufferCopy2.Ptr	VkBufferCopy2.Ptr.reinterpret(long newSize)	Assume the VkBufferCopy2.Ptr is capable of holding at least newSize structures, create a new view VkBufferCopy2.Ptr that uses the same backing storage as this VkBufferCopy2.Ptr, but with the new size.
@NotNull VkBufferCreateInfo.Ptr	VkBufferCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkBufferCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkBufferCreateInfo.Ptr that uses the same backing storage as this VkBufferCreateInfo.Ptr, but with the new size.
@NotNull VkBufferDeviceAddressCreateInfoEXT.Ptr	VkBufferDeviceAddressCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkBufferDeviceAddressCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkBufferDeviceAddressCreateInfoEXT.Ptr that uses the same backing storage as this VkBufferDeviceAddressCreateInfoEXT.Ptr, but with the new size.
@NotNull VkBufferDeviceAddressInfo.Ptr	VkBufferDeviceAddressInfo.Ptr.reinterpret(long newSize)	Assume the VkBufferDeviceAddressInfo.Ptr is capable of holding at least newSize structures, create a new view VkBufferDeviceAddressInfo.Ptr that uses the same backing storage as this VkBufferDeviceAddressInfo.Ptr, but with the new size.
@NotNull VkBufferImageCopy.Ptr	VkBufferImageCopy.Ptr.reinterpret(long newSize)	Assume the VkBufferImageCopy.Ptr is capable of holding at least newSize structures, create a new view VkBufferImageCopy.Ptr that uses the same backing storage as this VkBufferImageCopy.Ptr, but with the new size.
@NotNull VkBufferImageCopy2.Ptr	VkBufferImageCopy2.Ptr.reinterpret(long newSize)	Assume the VkBufferImageCopy2.Ptr is capable of holding at least newSize structures, create a new view VkBufferImageCopy2.Ptr that uses the same backing storage as this VkBufferImageCopy2.Ptr, but with the new size.
@NotNull VkBufferMemoryBarrier.Ptr	VkBufferMemoryBarrier.Ptr.reinterpret(long newSize)	Assume the VkBufferMemoryBarrier.Ptr is capable of holding at least newSize structures, create a new view VkBufferMemoryBarrier.Ptr that uses the same backing storage as this VkBufferMemoryBarrier.Ptr, but with the new size.
@NotNull VkBufferMemoryBarrier2.Ptr	VkBufferMemoryBarrier2.Ptr.reinterpret(long newSize)	Assume the VkBufferMemoryBarrier2.Ptr is capable of holding at least newSize structures, create a new view VkBufferMemoryBarrier2.Ptr that uses the same backing storage as this VkBufferMemoryBarrier2.Ptr, but with the new size.
@NotNull VkBufferMemoryRequirementsInfo2.Ptr	VkBufferMemoryRequirementsInfo2.Ptr.reinterpret(long newSize)	Assume the VkBufferMemoryRequirementsInfo2.Ptr is capable of holding at least newSize structures, create a new view VkBufferMemoryRequirementsInfo2.Ptr that uses the same backing storage as this VkBufferMemoryRequirementsInfo2.Ptr, but with the new size.
@NotNull VkBufferOpaqueCaptureAddressCreateInfo.Ptr	VkBufferOpaqueCaptureAddressCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkBufferOpaqueCaptureAddressCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkBufferOpaqueCaptureAddressCreateInfo.Ptr that uses the same backing storage as this VkBufferOpaqueCaptureAddressCreateInfo.Ptr, but with the new size.
@NotNull VkBufferUsageFlags2CreateInfo.Ptr	VkBufferUsageFlags2CreateInfo.Ptr.reinterpret(long newSize)	Assume the VkBufferUsageFlags2CreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkBufferUsageFlags2CreateInfo.Ptr that uses the same backing storage as this VkBufferUsageFlags2CreateInfo.Ptr, but with the new size.
@NotNull VkBufferViewCreateInfo.Ptr	VkBufferViewCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkBufferViewCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkBufferViewCreateInfo.Ptr that uses the same backing storage as this VkBufferViewCreateInfo.Ptr, but with the new size.
@NotNull VkBuildPartitionedAccelerationStructureIndirectCommandNV.Ptr	VkBuildPartitionedAccelerationStructureIndirectCommandNV.Ptr.reinterpret(long newSize)	Assume the VkBuildPartitionedAccelerationStructureIndirectCommandNV.Ptr is capable of holding at least newSize structures, create a new view VkBuildPartitionedAccelerationStructureIndirectCommandNV.Ptr that uses the same backing storage as this VkBuildPartitionedAccelerationStructureIndirectCommandNV.Ptr, but with the new size.
@NotNull VkBuildPartitionedAccelerationStructureInfoNV.Ptr	VkBuildPartitionedAccelerationStructureInfoNV.Ptr.reinterpret(long newSize)	Assume the VkBuildPartitionedAccelerationStructureInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkBuildPartitionedAccelerationStructureInfoNV.Ptr that uses the same backing storage as this VkBuildPartitionedAccelerationStructureInfoNV.Ptr, but with the new size.
@NotNull VkCalibratedTimestampInfoKHR.Ptr	VkCalibratedTimestampInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkCalibratedTimestampInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkCalibratedTimestampInfoKHR.Ptr that uses the same backing storage as this VkCalibratedTimestampInfoKHR.Ptr, but with the new size.
@NotNull VkCheckpointData2NV.Ptr	VkCheckpointData2NV.Ptr.reinterpret(long newSize)	Assume the VkCheckpointData2NV.Ptr is capable of holding at least newSize structures, create a new view VkCheckpointData2NV.Ptr that uses the same backing storage as this VkCheckpointData2NV.Ptr, but with the new size.
@NotNull VkCheckpointDataNV.Ptr	VkCheckpointDataNV.Ptr.reinterpret(long newSize)	Assume the VkCheckpointDataNV.Ptr is capable of holding at least newSize structures, create a new view VkCheckpointDataNV.Ptr that uses the same backing storage as this VkCheckpointDataNV.Ptr, but with the new size.
@NotNull VkClearAttachment.Ptr	VkClearAttachment.Ptr.reinterpret(long newSize)	Assume the VkClearAttachment.Ptr is capable of holding at least newSize structures, create a new view VkClearAttachment.Ptr that uses the same backing storage as this VkClearAttachment.Ptr, but with the new size.
@NotNull VkClearColorValue.Ptr	VkClearColorValue.Ptr.reinterpret(long newSize)	Assume the VkClearColorValue.Ptr is capable of holding at least newSize structures, create a new view VkClearColorValue.Ptr that uses the same backing storage as this VkClearColorValue.Ptr, but with the new size.
@NotNull VkClearDepthStencilValue.Ptr	VkClearDepthStencilValue.Ptr.reinterpret(long newSize)	Assume the VkClearDepthStencilValue.Ptr is capable of holding at least newSize structures, create a new view VkClearDepthStencilValue.Ptr that uses the same backing storage as this VkClearDepthStencilValue.Ptr, but with the new size.
@NotNull VkClearRect.Ptr	VkClearRect.Ptr.reinterpret(long newSize)	Assume the VkClearRect.Ptr is capable of holding at least newSize structures, create a new view VkClearRect.Ptr that uses the same backing storage as this VkClearRect.Ptr, but with the new size.
@NotNull VkClearValue.Ptr	VkClearValue.Ptr.reinterpret(long newSize)	Assume the VkClearValue.Ptr is capable of holding at least newSize structures, create a new view VkClearValue.Ptr that uses the same backing storage as this VkClearValue.Ptr, but with the new size.
@NotNull VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV.Ptr	VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV.Ptr.reinterpret(long newSize)	Assume the VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV.Ptr that uses the same backing storage as this VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV.Ptr, but with the new size.
@NotNull VkClusterAccelerationStructureBuildTriangleClusterInfoNV.Ptr	VkClusterAccelerationStructureBuildTriangleClusterInfoNV.Ptr.reinterpret(long newSize)	Assume the VkClusterAccelerationStructureBuildTriangleClusterInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkClusterAccelerationStructureBuildTriangleClusterInfoNV.Ptr that uses the same backing storage as this VkClusterAccelerationStructureBuildTriangleClusterInfoNV.Ptr, but with the new size.
@NotNull VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.Ptr	VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.Ptr.reinterpret(long newSize)	Assume the VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.Ptr that uses the same backing storage as this VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV.Ptr, but with the new size.
@NotNull VkClusterAccelerationStructureClustersBottomLevelInputNV.Ptr	VkClusterAccelerationStructureClustersBottomLevelInputNV.Ptr.reinterpret(long newSize)	Assume the VkClusterAccelerationStructureClustersBottomLevelInputNV.Ptr is capable of holding at least newSize structures, create a new view VkClusterAccelerationStructureClustersBottomLevelInputNV.Ptr that uses the same backing storage as this VkClusterAccelerationStructureClustersBottomLevelInputNV.Ptr, but with the new size.
@NotNull VkClusterAccelerationStructureCommandsInfoNV.Ptr	VkClusterAccelerationStructureCommandsInfoNV.Ptr.reinterpret(long newSize)	Assume the VkClusterAccelerationStructureCommandsInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkClusterAccelerationStructureCommandsInfoNV.Ptr that uses the same backing storage as this VkClusterAccelerationStructureCommandsInfoNV.Ptr, but with the new size.
@NotNull VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV.Ptr	VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV.Ptr.reinterpret(long newSize)	Assume the VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV.Ptr is capable of holding at least newSize structures, create a new view VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV.Ptr that uses the same backing storage as this VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV.Ptr, but with the new size.
@NotNull VkClusterAccelerationStructureInputInfoNV.Ptr	VkClusterAccelerationStructureInputInfoNV.Ptr.reinterpret(long newSize)	Assume the VkClusterAccelerationStructureInputInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkClusterAccelerationStructureInputInfoNV.Ptr that uses the same backing storage as this VkClusterAccelerationStructureInputInfoNV.Ptr, but with the new size.
@NotNull VkClusterAccelerationStructureInstantiateClusterInfoNV.Ptr	VkClusterAccelerationStructureInstantiateClusterInfoNV.Ptr.reinterpret(long newSize)	Assume the VkClusterAccelerationStructureInstantiateClusterInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkClusterAccelerationStructureInstantiateClusterInfoNV.Ptr that uses the same backing storage as this VkClusterAccelerationStructureInstantiateClusterInfoNV.Ptr, but with the new size.
@NotNull VkClusterAccelerationStructureMoveObjectsInfoNV.Ptr	VkClusterAccelerationStructureMoveObjectsInfoNV.Ptr.reinterpret(long newSize)	Assume the VkClusterAccelerationStructureMoveObjectsInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkClusterAccelerationStructureMoveObjectsInfoNV.Ptr that uses the same backing storage as this VkClusterAccelerationStructureMoveObjectsInfoNV.Ptr, but with the new size.
@NotNull VkClusterAccelerationStructureMoveObjectsInputNV.Ptr	VkClusterAccelerationStructureMoveObjectsInputNV.Ptr.reinterpret(long newSize)	Assume the VkClusterAccelerationStructureMoveObjectsInputNV.Ptr is capable of holding at least newSize structures, create a new view VkClusterAccelerationStructureMoveObjectsInputNV.Ptr that uses the same backing storage as this VkClusterAccelerationStructureMoveObjectsInputNV.Ptr, but with the new size.
@NotNull VkClusterAccelerationStructureOpInputNV.Ptr	VkClusterAccelerationStructureOpInputNV.Ptr.reinterpret(long newSize)	Assume the VkClusterAccelerationStructureOpInputNV.Ptr is capable of holding at least newSize structures, create a new view VkClusterAccelerationStructureOpInputNV.Ptr that uses the same backing storage as this VkClusterAccelerationStructureOpInputNV.Ptr, but with the new size.
@NotNull VkClusterAccelerationStructureTriangleClusterInputNV.Ptr	VkClusterAccelerationStructureTriangleClusterInputNV.Ptr.reinterpret(long newSize)	Assume the VkClusterAccelerationStructureTriangleClusterInputNV.Ptr is capable of holding at least newSize structures, create a new view VkClusterAccelerationStructureTriangleClusterInputNV.Ptr that uses the same backing storage as this VkClusterAccelerationStructureTriangleClusterInputNV.Ptr, but with the new size.
@NotNull VkCoarseSampleLocationNV.Ptr	VkCoarseSampleLocationNV.Ptr.reinterpret(long newSize)	Assume the VkCoarseSampleLocationNV.Ptr is capable of holding at least newSize structures, create a new view VkCoarseSampleLocationNV.Ptr that uses the same backing storage as this VkCoarseSampleLocationNV.Ptr, but with the new size.
@NotNull VkCoarseSampleOrderCustomNV.Ptr	VkCoarseSampleOrderCustomNV.Ptr.reinterpret(long newSize)	Assume the VkCoarseSampleOrderCustomNV.Ptr is capable of holding at least newSize structures, create a new view VkCoarseSampleOrderCustomNV.Ptr that uses the same backing storage as this VkCoarseSampleOrderCustomNV.Ptr, but with the new size.
@NotNull VkColorBlendAdvancedEXT.Ptr	VkColorBlendAdvancedEXT.Ptr.reinterpret(long newSize)	Assume the VkColorBlendAdvancedEXT.Ptr is capable of holding at least newSize structures, create a new view VkColorBlendAdvancedEXT.Ptr that uses the same backing storage as this VkColorBlendAdvancedEXT.Ptr, but with the new size.
@NotNull VkColorBlendEquationEXT.Ptr	VkColorBlendEquationEXT.Ptr.reinterpret(long newSize)	Assume the VkColorBlendEquationEXT.Ptr is capable of holding at least newSize structures, create a new view VkColorBlendEquationEXT.Ptr that uses the same backing storage as this VkColorBlendEquationEXT.Ptr, but with the new size.
@NotNull VkCommandBufferAllocateInfo.Ptr	VkCommandBufferAllocateInfo.Ptr.reinterpret(long newSize)	Assume the VkCommandBufferAllocateInfo.Ptr is capable of holding at least newSize structures, create a new view VkCommandBufferAllocateInfo.Ptr that uses the same backing storage as this VkCommandBufferAllocateInfo.Ptr, but with the new size.
@NotNull VkCommandBufferBeginInfo.Ptr	VkCommandBufferBeginInfo.Ptr.reinterpret(long newSize)	Assume the VkCommandBufferBeginInfo.Ptr is capable of holding at least newSize structures, create a new view VkCommandBufferBeginInfo.Ptr that uses the same backing storage as this VkCommandBufferBeginInfo.Ptr, but with the new size.
@NotNull VkCommandBufferInheritanceConditionalRenderingInfoEXT.Ptr	VkCommandBufferInheritanceConditionalRenderingInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkCommandBufferInheritanceConditionalRenderingInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkCommandBufferInheritanceConditionalRenderingInfoEXT.Ptr that uses the same backing storage as this VkCommandBufferInheritanceConditionalRenderingInfoEXT.Ptr, but with the new size.
@NotNull VkCommandBufferInheritanceInfo.Ptr	VkCommandBufferInheritanceInfo.Ptr.reinterpret(long newSize)	Assume the VkCommandBufferInheritanceInfo.Ptr is capable of holding at least newSize structures, create a new view VkCommandBufferInheritanceInfo.Ptr that uses the same backing storage as this VkCommandBufferInheritanceInfo.Ptr, but with the new size.
@NotNull VkCommandBufferInheritanceRenderingInfo.Ptr	VkCommandBufferInheritanceRenderingInfo.Ptr.reinterpret(long newSize)	Assume the VkCommandBufferInheritanceRenderingInfo.Ptr is capable of holding at least newSize structures, create a new view VkCommandBufferInheritanceRenderingInfo.Ptr that uses the same backing storage as this VkCommandBufferInheritanceRenderingInfo.Ptr, but with the new size.
@NotNull VkCommandBufferInheritanceRenderPassTransformInfoQCOM.Ptr	VkCommandBufferInheritanceRenderPassTransformInfoQCOM.Ptr.reinterpret(long newSize)	Assume the VkCommandBufferInheritanceRenderPassTransformInfoQCOM.Ptr is capable of holding at least newSize structures, create a new view VkCommandBufferInheritanceRenderPassTransformInfoQCOM.Ptr that uses the same backing storage as this VkCommandBufferInheritanceRenderPassTransformInfoQCOM.Ptr, but with the new size.
@NotNull VkCommandBufferInheritanceViewportScissorInfoNV.Ptr	VkCommandBufferInheritanceViewportScissorInfoNV.Ptr.reinterpret(long newSize)	Assume the VkCommandBufferInheritanceViewportScissorInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkCommandBufferInheritanceViewportScissorInfoNV.Ptr that uses the same backing storage as this VkCommandBufferInheritanceViewportScissorInfoNV.Ptr, but with the new size.
@NotNull VkCommandBufferSubmitInfo.Ptr	VkCommandBufferSubmitInfo.Ptr.reinterpret(long newSize)	Assume the VkCommandBufferSubmitInfo.Ptr is capable of holding at least newSize structures, create a new view VkCommandBufferSubmitInfo.Ptr that uses the same backing storage as this VkCommandBufferSubmitInfo.Ptr, but with the new size.
@NotNull VkCommandPoolCreateInfo.Ptr	VkCommandPoolCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkCommandPoolCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkCommandPoolCreateInfo.Ptr that uses the same backing storage as this VkCommandPoolCreateInfo.Ptr, but with the new size.
@NotNull VkComponentMapping.Ptr	VkComponentMapping.Ptr.reinterpret(long newSize)	Assume the VkComponentMapping.Ptr is capable of holding at least newSize structures, create a new view VkComponentMapping.Ptr that uses the same backing storage as this VkComponentMapping.Ptr, but with the new size.
@NotNull VkComputePipelineCreateInfo.Ptr	VkComputePipelineCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkComputePipelineCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkComputePipelineCreateInfo.Ptr that uses the same backing storage as this VkComputePipelineCreateInfo.Ptr, but with the new size.
@NotNull VkComputePipelineIndirectBufferInfoNV.Ptr	VkComputePipelineIndirectBufferInfoNV.Ptr.reinterpret(long newSize)	Assume the VkComputePipelineIndirectBufferInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkComputePipelineIndirectBufferInfoNV.Ptr that uses the same backing storage as this VkComputePipelineIndirectBufferInfoNV.Ptr, but with the new size.
@NotNull VkConditionalRenderingBeginInfoEXT.Ptr	VkConditionalRenderingBeginInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkConditionalRenderingBeginInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkConditionalRenderingBeginInfoEXT.Ptr that uses the same backing storage as this VkConditionalRenderingBeginInfoEXT.Ptr, but with the new size.
@NotNull VkConformanceVersion.Ptr	VkConformanceVersion.Ptr.reinterpret(long newSize)	Assume the VkConformanceVersion.Ptr is capable of holding at least newSize structures, create a new view VkConformanceVersion.Ptr that uses the same backing storage as this VkConformanceVersion.Ptr, but with the new size.
@NotNull VkConvertCooperativeVectorMatrixInfoNV.Ptr	VkConvertCooperativeVectorMatrixInfoNV.Ptr.reinterpret(long newSize)	Assume the VkConvertCooperativeVectorMatrixInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkConvertCooperativeVectorMatrixInfoNV.Ptr that uses the same backing storage as this VkConvertCooperativeVectorMatrixInfoNV.Ptr, but with the new size.
@NotNull VkCooperativeMatrixFlexibleDimensionsPropertiesNV.Ptr	VkCooperativeMatrixFlexibleDimensionsPropertiesNV.Ptr.reinterpret(long newSize)	Assume the VkCooperativeMatrixFlexibleDimensionsPropertiesNV.Ptr is capable of holding at least newSize structures, create a new view VkCooperativeMatrixFlexibleDimensionsPropertiesNV.Ptr that uses the same backing storage as this VkCooperativeMatrixFlexibleDimensionsPropertiesNV.Ptr, but with the new size.
@NotNull VkCooperativeMatrixPropertiesKHR.Ptr	VkCooperativeMatrixPropertiesKHR.Ptr.reinterpret(long newSize)	Assume the VkCooperativeMatrixPropertiesKHR.Ptr is capable of holding at least newSize structures, create a new view VkCooperativeMatrixPropertiesKHR.Ptr that uses the same backing storage as this VkCooperativeMatrixPropertiesKHR.Ptr, but with the new size.
@NotNull VkCooperativeMatrixPropertiesNV.Ptr	VkCooperativeMatrixPropertiesNV.Ptr.reinterpret(long newSize)	Assume the VkCooperativeMatrixPropertiesNV.Ptr is capable of holding at least newSize structures, create a new view VkCooperativeMatrixPropertiesNV.Ptr that uses the same backing storage as this VkCooperativeMatrixPropertiesNV.Ptr, but with the new size.
@NotNull VkCooperativeVectorPropertiesNV.Ptr	VkCooperativeVectorPropertiesNV.Ptr.reinterpret(long newSize)	Assume the VkCooperativeVectorPropertiesNV.Ptr is capable of holding at least newSize structures, create a new view VkCooperativeVectorPropertiesNV.Ptr that uses the same backing storage as this VkCooperativeVectorPropertiesNV.Ptr, but with the new size.
@NotNull VkCopyAccelerationStructureInfoKHR.Ptr	VkCopyAccelerationStructureInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkCopyAccelerationStructureInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkCopyAccelerationStructureInfoKHR.Ptr that uses the same backing storage as this VkCopyAccelerationStructureInfoKHR.Ptr, but with the new size.
@NotNull VkCopyAccelerationStructureToMemoryInfoKHR.Ptr	VkCopyAccelerationStructureToMemoryInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkCopyAccelerationStructureToMemoryInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkCopyAccelerationStructureToMemoryInfoKHR.Ptr that uses the same backing storage as this VkCopyAccelerationStructureToMemoryInfoKHR.Ptr, but with the new size.
@NotNull VkCopyBufferInfo2.Ptr	VkCopyBufferInfo2.Ptr.reinterpret(long newSize)	Assume the VkCopyBufferInfo2.Ptr is capable of holding at least newSize structures, create a new view VkCopyBufferInfo2.Ptr that uses the same backing storage as this VkCopyBufferInfo2.Ptr, but with the new size.
@NotNull VkCopyBufferToImageInfo2.Ptr	VkCopyBufferToImageInfo2.Ptr.reinterpret(long newSize)	Assume the VkCopyBufferToImageInfo2.Ptr is capable of holding at least newSize structures, create a new view VkCopyBufferToImageInfo2.Ptr that uses the same backing storage as this VkCopyBufferToImageInfo2.Ptr, but with the new size.
@NotNull VkCopyCommandTransformInfoQCOM.Ptr	VkCopyCommandTransformInfoQCOM.Ptr.reinterpret(long newSize)	Assume the VkCopyCommandTransformInfoQCOM.Ptr is capable of holding at least newSize structures, create a new view VkCopyCommandTransformInfoQCOM.Ptr that uses the same backing storage as this VkCopyCommandTransformInfoQCOM.Ptr, but with the new size.
@NotNull VkCopyDescriptorSet.Ptr	VkCopyDescriptorSet.Ptr.reinterpret(long newSize)	Assume the VkCopyDescriptorSet.Ptr is capable of holding at least newSize structures, create a new view VkCopyDescriptorSet.Ptr that uses the same backing storage as this VkCopyDescriptorSet.Ptr, but with the new size.
@NotNull VkCopyImageInfo2.Ptr	VkCopyImageInfo2.Ptr.reinterpret(long newSize)	Assume the VkCopyImageInfo2.Ptr is capable of holding at least newSize structures, create a new view VkCopyImageInfo2.Ptr that uses the same backing storage as this VkCopyImageInfo2.Ptr, but with the new size.
@NotNull VkCopyImageToBufferInfo2.Ptr	VkCopyImageToBufferInfo2.Ptr.reinterpret(long newSize)	Assume the VkCopyImageToBufferInfo2.Ptr is capable of holding at least newSize structures, create a new view VkCopyImageToBufferInfo2.Ptr that uses the same backing storage as this VkCopyImageToBufferInfo2.Ptr, but with the new size.
@NotNull VkCopyImageToImageInfo.Ptr	VkCopyImageToImageInfo.Ptr.reinterpret(long newSize)	Assume the VkCopyImageToImageInfo.Ptr is capable of holding at least newSize structures, create a new view VkCopyImageToImageInfo.Ptr that uses the same backing storage as this VkCopyImageToImageInfo.Ptr, but with the new size.
@NotNull VkCopyImageToMemoryInfo.Ptr	VkCopyImageToMemoryInfo.Ptr.reinterpret(long newSize)	Assume the VkCopyImageToMemoryInfo.Ptr is capable of holding at least newSize structures, create a new view VkCopyImageToMemoryInfo.Ptr that uses the same backing storage as this VkCopyImageToMemoryInfo.Ptr, but with the new size.
@NotNull VkCopyMemoryIndirectCommandNV.Ptr	VkCopyMemoryIndirectCommandNV.Ptr.reinterpret(long newSize)	Assume the VkCopyMemoryIndirectCommandNV.Ptr is capable of holding at least newSize structures, create a new view VkCopyMemoryIndirectCommandNV.Ptr that uses the same backing storage as this VkCopyMemoryIndirectCommandNV.Ptr, but with the new size.
@NotNull VkCopyMemoryToAccelerationStructureInfoKHR.Ptr	VkCopyMemoryToAccelerationStructureInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkCopyMemoryToAccelerationStructureInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkCopyMemoryToAccelerationStructureInfoKHR.Ptr that uses the same backing storage as this VkCopyMemoryToAccelerationStructureInfoKHR.Ptr, but with the new size.
@NotNull VkCopyMemoryToImageIndirectCommandNV.Ptr	VkCopyMemoryToImageIndirectCommandNV.Ptr.reinterpret(long newSize)	Assume the VkCopyMemoryToImageIndirectCommandNV.Ptr is capable of holding at least newSize structures, create a new view VkCopyMemoryToImageIndirectCommandNV.Ptr that uses the same backing storage as this VkCopyMemoryToImageIndirectCommandNV.Ptr, but with the new size.
@NotNull VkCopyMemoryToImageInfo.Ptr	VkCopyMemoryToImageInfo.Ptr.reinterpret(long newSize)	Assume the VkCopyMemoryToImageInfo.Ptr is capable of holding at least newSize structures, create a new view VkCopyMemoryToImageInfo.Ptr that uses the same backing storage as this VkCopyMemoryToImageInfo.Ptr, but with the new size.
@NotNull VkCopyMemoryToMicromapInfoEXT.Ptr	VkCopyMemoryToMicromapInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkCopyMemoryToMicromapInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkCopyMemoryToMicromapInfoEXT.Ptr that uses the same backing storage as this VkCopyMemoryToMicromapInfoEXT.Ptr, but with the new size.
@NotNull VkCopyMicromapInfoEXT.Ptr	VkCopyMicromapInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkCopyMicromapInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkCopyMicromapInfoEXT.Ptr that uses the same backing storage as this VkCopyMicromapInfoEXT.Ptr, but with the new size.
@NotNull VkCopyMicromapToMemoryInfoEXT.Ptr	VkCopyMicromapToMemoryInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkCopyMicromapToMemoryInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkCopyMicromapToMemoryInfoEXT.Ptr that uses the same backing storage as this VkCopyMicromapToMemoryInfoEXT.Ptr, but with the new size.
@NotNull VkCudaFunctionCreateInfoNV.Ptr	VkCudaFunctionCreateInfoNV.Ptr.reinterpret(long newSize)	Assume the VkCudaFunctionCreateInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkCudaFunctionCreateInfoNV.Ptr that uses the same backing storage as this VkCudaFunctionCreateInfoNV.Ptr, but with the new size.
@NotNull VkCudaLaunchInfoNV.Ptr	VkCudaLaunchInfoNV.Ptr.reinterpret(long newSize)	Assume the VkCudaLaunchInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkCudaLaunchInfoNV.Ptr that uses the same backing storage as this VkCudaLaunchInfoNV.Ptr, but with the new size.
@NotNull VkCudaModuleCreateInfoNV.Ptr	VkCudaModuleCreateInfoNV.Ptr.reinterpret(long newSize)	Assume the VkCudaModuleCreateInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkCudaModuleCreateInfoNV.Ptr that uses the same backing storage as this VkCudaModuleCreateInfoNV.Ptr, but with the new size.
@NotNull VkCuFunctionCreateInfoNVX.Ptr	VkCuFunctionCreateInfoNVX.Ptr.reinterpret(long newSize)	Assume the VkCuFunctionCreateInfoNVX.Ptr is capable of holding at least newSize structures, create a new view VkCuFunctionCreateInfoNVX.Ptr that uses the same backing storage as this VkCuFunctionCreateInfoNVX.Ptr, but with the new size.
@NotNull VkCuLaunchInfoNVX.Ptr	VkCuLaunchInfoNVX.Ptr.reinterpret(long newSize)	Assume the VkCuLaunchInfoNVX.Ptr is capable of holding at least newSize structures, create a new view VkCuLaunchInfoNVX.Ptr that uses the same backing storage as this VkCuLaunchInfoNVX.Ptr, but with the new size.
@NotNull VkCuModuleCreateInfoNVX.Ptr	VkCuModuleCreateInfoNVX.Ptr.reinterpret(long newSize)	Assume the VkCuModuleCreateInfoNVX.Ptr is capable of holding at least newSize structures, create a new view VkCuModuleCreateInfoNVX.Ptr that uses the same backing storage as this VkCuModuleCreateInfoNVX.Ptr, but with the new size.
@NotNull VkCuModuleTexturingModeCreateInfoNVX.Ptr	VkCuModuleTexturingModeCreateInfoNVX.Ptr.reinterpret(long newSize)	Assume the VkCuModuleTexturingModeCreateInfoNVX.Ptr is capable of holding at least newSize structures, create a new view VkCuModuleTexturingModeCreateInfoNVX.Ptr that uses the same backing storage as this VkCuModuleTexturingModeCreateInfoNVX.Ptr, but with the new size.
@NotNull VkD3D12FenceSubmitInfoKHR.Ptr	VkD3D12FenceSubmitInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkD3D12FenceSubmitInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkD3D12FenceSubmitInfoKHR.Ptr that uses the same backing storage as this VkD3D12FenceSubmitInfoKHR.Ptr, but with the new size.
@NotNull VkDebugMarkerMarkerInfoEXT.Ptr	VkDebugMarkerMarkerInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkDebugMarkerMarkerInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkDebugMarkerMarkerInfoEXT.Ptr that uses the same backing storage as this VkDebugMarkerMarkerInfoEXT.Ptr, but with the new size.
@NotNull VkDebugMarkerObjectNameInfoEXT.Ptr	VkDebugMarkerObjectNameInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkDebugMarkerObjectNameInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkDebugMarkerObjectNameInfoEXT.Ptr that uses the same backing storage as this VkDebugMarkerObjectNameInfoEXT.Ptr, but with the new size.
@NotNull VkDebugMarkerObjectTagInfoEXT.Ptr	VkDebugMarkerObjectTagInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkDebugMarkerObjectTagInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkDebugMarkerObjectTagInfoEXT.Ptr that uses the same backing storage as this VkDebugMarkerObjectTagInfoEXT.Ptr, but with the new size.
@NotNull VkDebugReportCallbackCreateInfoEXT.Ptr	VkDebugReportCallbackCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkDebugReportCallbackCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkDebugReportCallbackCreateInfoEXT.Ptr that uses the same backing storage as this VkDebugReportCallbackCreateInfoEXT.Ptr, but with the new size.
@NotNull VkDebugUtilsLabelEXT.Ptr	VkDebugUtilsLabelEXT.Ptr.reinterpret(long newSize)	Assume the VkDebugUtilsLabelEXT.Ptr is capable of holding at least newSize structures, create a new view VkDebugUtilsLabelEXT.Ptr that uses the same backing storage as this VkDebugUtilsLabelEXT.Ptr, but with the new size.
@NotNull VkDebugUtilsMessengerCallbackDataEXT.Ptr	VkDebugUtilsMessengerCallbackDataEXT.Ptr.reinterpret(long newSize)	Assume the VkDebugUtilsMessengerCallbackDataEXT.Ptr is capable of holding at least newSize structures, create a new view VkDebugUtilsMessengerCallbackDataEXT.Ptr that uses the same backing storage as this VkDebugUtilsMessengerCallbackDataEXT.Ptr, but with the new size.
@NotNull VkDebugUtilsMessengerCreateInfoEXT.Ptr	VkDebugUtilsMessengerCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkDebugUtilsMessengerCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkDebugUtilsMessengerCreateInfoEXT.Ptr that uses the same backing storage as this VkDebugUtilsMessengerCreateInfoEXT.Ptr, but with the new size.
@NotNull VkDebugUtilsObjectNameInfoEXT.Ptr	VkDebugUtilsObjectNameInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkDebugUtilsObjectNameInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkDebugUtilsObjectNameInfoEXT.Ptr that uses the same backing storage as this VkDebugUtilsObjectNameInfoEXT.Ptr, but with the new size.
@NotNull VkDebugUtilsObjectTagInfoEXT.Ptr	VkDebugUtilsObjectTagInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkDebugUtilsObjectTagInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkDebugUtilsObjectTagInfoEXT.Ptr that uses the same backing storage as this VkDebugUtilsObjectTagInfoEXT.Ptr, but with the new size.
@NotNull VkDecompressMemoryRegionNV.Ptr	VkDecompressMemoryRegionNV.Ptr.reinterpret(long newSize)	Assume the VkDecompressMemoryRegionNV.Ptr is capable of holding at least newSize structures, create a new view VkDecompressMemoryRegionNV.Ptr that uses the same backing storage as this VkDecompressMemoryRegionNV.Ptr, but with the new size.
@NotNull VkDedicatedAllocationBufferCreateInfoNV.Ptr	VkDedicatedAllocationBufferCreateInfoNV.Ptr.reinterpret(long newSize)	Assume the VkDedicatedAllocationBufferCreateInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkDedicatedAllocationBufferCreateInfoNV.Ptr that uses the same backing storage as this VkDedicatedAllocationBufferCreateInfoNV.Ptr, but with the new size.
@NotNull VkDedicatedAllocationImageCreateInfoNV.Ptr	VkDedicatedAllocationImageCreateInfoNV.Ptr.reinterpret(long newSize)	Assume the VkDedicatedAllocationImageCreateInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkDedicatedAllocationImageCreateInfoNV.Ptr that uses the same backing storage as this VkDedicatedAllocationImageCreateInfoNV.Ptr, but with the new size.
@NotNull VkDedicatedAllocationMemoryAllocateInfoNV.Ptr	VkDedicatedAllocationMemoryAllocateInfoNV.Ptr.reinterpret(long newSize)	Assume the VkDedicatedAllocationMemoryAllocateInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkDedicatedAllocationMemoryAllocateInfoNV.Ptr that uses the same backing storage as this VkDedicatedAllocationMemoryAllocateInfoNV.Ptr, but with the new size.
@NotNull VkDependencyInfo.Ptr	VkDependencyInfo.Ptr.reinterpret(long newSize)	Assume the VkDependencyInfo.Ptr is capable of holding at least newSize structures, create a new view VkDependencyInfo.Ptr that uses the same backing storage as this VkDependencyInfo.Ptr, but with the new size.
@NotNull VkDepthBiasInfoEXT.Ptr	VkDepthBiasInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkDepthBiasInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkDepthBiasInfoEXT.Ptr that uses the same backing storage as this VkDepthBiasInfoEXT.Ptr, but with the new size.
@NotNull VkDepthBiasRepresentationInfoEXT.Ptr	VkDepthBiasRepresentationInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkDepthBiasRepresentationInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkDepthBiasRepresentationInfoEXT.Ptr that uses the same backing storage as this VkDepthBiasRepresentationInfoEXT.Ptr, but with the new size.
@NotNull VkDepthClampRangeEXT.Ptr	VkDepthClampRangeEXT.Ptr.reinterpret(long newSize)	Assume the VkDepthClampRangeEXT.Ptr is capable of holding at least newSize structures, create a new view VkDepthClampRangeEXT.Ptr that uses the same backing storage as this VkDepthClampRangeEXT.Ptr, but with the new size.
@NotNull VkDescriptorAddressInfoEXT.Ptr	VkDescriptorAddressInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkDescriptorAddressInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkDescriptorAddressInfoEXT.Ptr that uses the same backing storage as this VkDescriptorAddressInfoEXT.Ptr, but with the new size.
@NotNull VkDescriptorBufferBindingInfoEXT.Ptr	VkDescriptorBufferBindingInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkDescriptorBufferBindingInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkDescriptorBufferBindingInfoEXT.Ptr that uses the same backing storage as this VkDescriptorBufferBindingInfoEXT.Ptr, but with the new size.
@NotNull VkDescriptorBufferBindingPushDescriptorBufferHandleEXT.Ptr	VkDescriptorBufferBindingPushDescriptorBufferHandleEXT.Ptr.reinterpret(long newSize)	Assume the VkDescriptorBufferBindingPushDescriptorBufferHandleEXT.Ptr is capable of holding at least newSize structures, create a new view VkDescriptorBufferBindingPushDescriptorBufferHandleEXT.Ptr that uses the same backing storage as this VkDescriptorBufferBindingPushDescriptorBufferHandleEXT.Ptr, but with the new size.
@NotNull VkDescriptorBufferInfo.Ptr	VkDescriptorBufferInfo.Ptr.reinterpret(long newSize)	Assume the VkDescriptorBufferInfo.Ptr is capable of holding at least newSize structures, create a new view VkDescriptorBufferInfo.Ptr that uses the same backing storage as this VkDescriptorBufferInfo.Ptr, but with the new size.
@NotNull VkDescriptorDataEXT.Ptr	VkDescriptorDataEXT.Ptr.reinterpret(long newSize)	Assume the VkDescriptorDataEXT.Ptr is capable of holding at least newSize structures, create a new view VkDescriptorDataEXT.Ptr that uses the same backing storage as this VkDescriptorDataEXT.Ptr, but with the new size.
@NotNull VkDescriptorGetInfoEXT.Ptr	VkDescriptorGetInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkDescriptorGetInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkDescriptorGetInfoEXT.Ptr that uses the same backing storage as this VkDescriptorGetInfoEXT.Ptr, but with the new size.
@NotNull VkDescriptorImageInfo.Ptr	VkDescriptorImageInfo.Ptr.reinterpret(long newSize)	Assume the VkDescriptorImageInfo.Ptr is capable of holding at least newSize structures, create a new view VkDescriptorImageInfo.Ptr that uses the same backing storage as this VkDescriptorImageInfo.Ptr, but with the new size.
@NotNull VkDescriptorPoolCreateInfo.Ptr	VkDescriptorPoolCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkDescriptorPoolCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkDescriptorPoolCreateInfo.Ptr that uses the same backing storage as this VkDescriptorPoolCreateInfo.Ptr, but with the new size.
@NotNull VkDescriptorPoolInlineUniformBlockCreateInfo.Ptr	VkDescriptorPoolInlineUniformBlockCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkDescriptorPoolInlineUniformBlockCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkDescriptorPoolInlineUniformBlockCreateInfo.Ptr that uses the same backing storage as this VkDescriptorPoolInlineUniformBlockCreateInfo.Ptr, but with the new size.
@NotNull VkDescriptorPoolSize.Ptr	VkDescriptorPoolSize.Ptr.reinterpret(long newSize)	Assume the VkDescriptorPoolSize.Ptr is capable of holding at least newSize structures, create a new view VkDescriptorPoolSize.Ptr that uses the same backing storage as this VkDescriptorPoolSize.Ptr, but with the new size.
@NotNull VkDescriptorSetAllocateInfo.Ptr	VkDescriptorSetAllocateInfo.Ptr.reinterpret(long newSize)	Assume the VkDescriptorSetAllocateInfo.Ptr is capable of holding at least newSize structures, create a new view VkDescriptorSetAllocateInfo.Ptr that uses the same backing storage as this VkDescriptorSetAllocateInfo.Ptr, but with the new size.
@NotNull VkDescriptorSetBindingReferenceVALVE.Ptr	VkDescriptorSetBindingReferenceVALVE.Ptr.reinterpret(long newSize)	Assume the VkDescriptorSetBindingReferenceVALVE.Ptr is capable of holding at least newSize structures, create a new view VkDescriptorSetBindingReferenceVALVE.Ptr that uses the same backing storage as this VkDescriptorSetBindingReferenceVALVE.Ptr, but with the new size.
@NotNull VkDescriptorSetLayoutBinding.Ptr	VkDescriptorSetLayoutBinding.Ptr.reinterpret(long newSize)	Assume the VkDescriptorSetLayoutBinding.Ptr is capable of holding at least newSize structures, create a new view VkDescriptorSetLayoutBinding.Ptr that uses the same backing storage as this VkDescriptorSetLayoutBinding.Ptr, but with the new size.
@NotNull VkDescriptorSetLayoutBindingFlagsCreateInfo.Ptr	VkDescriptorSetLayoutBindingFlagsCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkDescriptorSetLayoutBindingFlagsCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkDescriptorSetLayoutBindingFlagsCreateInfo.Ptr that uses the same backing storage as this VkDescriptorSetLayoutBindingFlagsCreateInfo.Ptr, but with the new size.
@NotNull VkDescriptorSetLayoutCreateInfo.Ptr	VkDescriptorSetLayoutCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkDescriptorSetLayoutCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkDescriptorSetLayoutCreateInfo.Ptr that uses the same backing storage as this VkDescriptorSetLayoutCreateInfo.Ptr, but with the new size.
@NotNull VkDescriptorSetLayoutHostMappingInfoVALVE.Ptr	VkDescriptorSetLayoutHostMappingInfoVALVE.Ptr.reinterpret(long newSize)	Assume the VkDescriptorSetLayoutHostMappingInfoVALVE.Ptr is capable of holding at least newSize structures, create a new view VkDescriptorSetLayoutHostMappingInfoVALVE.Ptr that uses the same backing storage as this VkDescriptorSetLayoutHostMappingInfoVALVE.Ptr, but with the new size.
@NotNull VkDescriptorSetLayoutSupport.Ptr	VkDescriptorSetLayoutSupport.Ptr.reinterpret(long newSize)	Assume the VkDescriptorSetLayoutSupport.Ptr is capable of holding at least newSize structures, create a new view VkDescriptorSetLayoutSupport.Ptr that uses the same backing storage as this VkDescriptorSetLayoutSupport.Ptr, but with the new size.
@NotNull VkDescriptorSetVariableDescriptorCountAllocateInfo.Ptr	VkDescriptorSetVariableDescriptorCountAllocateInfo.Ptr.reinterpret(long newSize)	Assume the VkDescriptorSetVariableDescriptorCountAllocateInfo.Ptr is capable of holding at least newSize structures, create a new view VkDescriptorSetVariableDescriptorCountAllocateInfo.Ptr that uses the same backing storage as this VkDescriptorSetVariableDescriptorCountAllocateInfo.Ptr, but with the new size.
@NotNull VkDescriptorSetVariableDescriptorCountLayoutSupport.Ptr	VkDescriptorSetVariableDescriptorCountLayoutSupport.Ptr.reinterpret(long newSize)	Assume the VkDescriptorSetVariableDescriptorCountLayoutSupport.Ptr is capable of holding at least newSize structures, create a new view VkDescriptorSetVariableDescriptorCountLayoutSupport.Ptr that uses the same backing storage as this VkDescriptorSetVariableDescriptorCountLayoutSupport.Ptr, but with the new size.
@NotNull VkDescriptorUpdateTemplateCreateInfo.Ptr	VkDescriptorUpdateTemplateCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkDescriptorUpdateTemplateCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkDescriptorUpdateTemplateCreateInfo.Ptr that uses the same backing storage as this VkDescriptorUpdateTemplateCreateInfo.Ptr, but with the new size.
@NotNull VkDescriptorUpdateTemplateEntry.Ptr	VkDescriptorUpdateTemplateEntry.Ptr.reinterpret(long newSize)	Assume the VkDescriptorUpdateTemplateEntry.Ptr is capable of holding at least newSize structures, create a new view VkDescriptorUpdateTemplateEntry.Ptr that uses the same backing storage as this VkDescriptorUpdateTemplateEntry.Ptr, but with the new size.
@NotNull VkDeviceAddressBindingCallbackDataEXT.Ptr	VkDeviceAddressBindingCallbackDataEXT.Ptr.reinterpret(long newSize)	Assume the VkDeviceAddressBindingCallbackDataEXT.Ptr is capable of holding at least newSize structures, create a new view VkDeviceAddressBindingCallbackDataEXT.Ptr that uses the same backing storage as this VkDeviceAddressBindingCallbackDataEXT.Ptr, but with the new size.
@NotNull VkDeviceBufferMemoryRequirements.Ptr	VkDeviceBufferMemoryRequirements.Ptr.reinterpret(long newSize)	Assume the VkDeviceBufferMemoryRequirements.Ptr is capable of holding at least newSize structures, create a new view VkDeviceBufferMemoryRequirements.Ptr that uses the same backing storage as this VkDeviceBufferMemoryRequirements.Ptr, but with the new size.
@NotNull VkDeviceCreateInfo.Ptr	VkDeviceCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkDeviceCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkDeviceCreateInfo.Ptr that uses the same backing storage as this VkDeviceCreateInfo.Ptr, but with the new size.
@NotNull VkDeviceDeviceMemoryReportCreateInfoEXT.Ptr	VkDeviceDeviceMemoryReportCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkDeviceDeviceMemoryReportCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkDeviceDeviceMemoryReportCreateInfoEXT.Ptr that uses the same backing storage as this VkDeviceDeviceMemoryReportCreateInfoEXT.Ptr, but with the new size.
@NotNull VkDeviceDiagnosticsConfigCreateInfoNV.Ptr	VkDeviceDiagnosticsConfigCreateInfoNV.Ptr.reinterpret(long newSize)	Assume the VkDeviceDiagnosticsConfigCreateInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkDeviceDiagnosticsConfigCreateInfoNV.Ptr that uses the same backing storage as this VkDeviceDiagnosticsConfigCreateInfoNV.Ptr, but with the new size.
@NotNull VkDeviceEventInfoEXT.Ptr	VkDeviceEventInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkDeviceEventInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkDeviceEventInfoEXT.Ptr that uses the same backing storage as this VkDeviceEventInfoEXT.Ptr, but with the new size.
@NotNull VkDeviceFaultAddressInfoEXT.Ptr	VkDeviceFaultAddressInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkDeviceFaultAddressInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkDeviceFaultAddressInfoEXT.Ptr that uses the same backing storage as this VkDeviceFaultAddressInfoEXT.Ptr, but with the new size.
@NotNull VkDeviceFaultCountsEXT.Ptr	VkDeviceFaultCountsEXT.Ptr.reinterpret(long newSize)	Assume the VkDeviceFaultCountsEXT.Ptr is capable of holding at least newSize structures, create a new view VkDeviceFaultCountsEXT.Ptr that uses the same backing storage as this VkDeviceFaultCountsEXT.Ptr, but with the new size.
@NotNull VkDeviceFaultInfoEXT.Ptr	VkDeviceFaultInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkDeviceFaultInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkDeviceFaultInfoEXT.Ptr that uses the same backing storage as this VkDeviceFaultInfoEXT.Ptr, but with the new size.
@NotNull VkDeviceFaultVendorBinaryHeaderVersionOneEXT.Ptr	VkDeviceFaultVendorBinaryHeaderVersionOneEXT.Ptr.reinterpret(long newSize)	Assume the VkDeviceFaultVendorBinaryHeaderVersionOneEXT.Ptr is capable of holding at least newSize structures, create a new view VkDeviceFaultVendorBinaryHeaderVersionOneEXT.Ptr that uses the same backing storage as this VkDeviceFaultVendorBinaryHeaderVersionOneEXT.Ptr, but with the new size.
@NotNull VkDeviceFaultVendorInfoEXT.Ptr	VkDeviceFaultVendorInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkDeviceFaultVendorInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkDeviceFaultVendorInfoEXT.Ptr that uses the same backing storage as this VkDeviceFaultVendorInfoEXT.Ptr, but with the new size.
@NotNull VkDeviceGroupBindSparseInfo.Ptr	VkDeviceGroupBindSparseInfo.Ptr.reinterpret(long newSize)	Assume the VkDeviceGroupBindSparseInfo.Ptr is capable of holding at least newSize structures, create a new view VkDeviceGroupBindSparseInfo.Ptr that uses the same backing storage as this VkDeviceGroupBindSparseInfo.Ptr, but with the new size.
@NotNull VkDeviceGroupCommandBufferBeginInfo.Ptr	VkDeviceGroupCommandBufferBeginInfo.Ptr.reinterpret(long newSize)	Assume the VkDeviceGroupCommandBufferBeginInfo.Ptr is capable of holding at least newSize structures, create a new view VkDeviceGroupCommandBufferBeginInfo.Ptr that uses the same backing storage as this VkDeviceGroupCommandBufferBeginInfo.Ptr, but with the new size.
@NotNull VkDeviceGroupDeviceCreateInfo.Ptr	VkDeviceGroupDeviceCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkDeviceGroupDeviceCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkDeviceGroupDeviceCreateInfo.Ptr that uses the same backing storage as this VkDeviceGroupDeviceCreateInfo.Ptr, but with the new size.
@NotNull VkDeviceGroupPresentCapabilitiesKHR.Ptr	VkDeviceGroupPresentCapabilitiesKHR.Ptr.reinterpret(long newSize)	Assume the VkDeviceGroupPresentCapabilitiesKHR.Ptr is capable of holding at least newSize structures, create a new view VkDeviceGroupPresentCapabilitiesKHR.Ptr that uses the same backing storage as this VkDeviceGroupPresentCapabilitiesKHR.Ptr, but with the new size.
@NotNull VkDeviceGroupPresentInfoKHR.Ptr	VkDeviceGroupPresentInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkDeviceGroupPresentInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkDeviceGroupPresentInfoKHR.Ptr that uses the same backing storage as this VkDeviceGroupPresentInfoKHR.Ptr, but with the new size.
@NotNull VkDeviceGroupRenderPassBeginInfo.Ptr	VkDeviceGroupRenderPassBeginInfo.Ptr.reinterpret(long newSize)	Assume the VkDeviceGroupRenderPassBeginInfo.Ptr is capable of holding at least newSize structures, create a new view VkDeviceGroupRenderPassBeginInfo.Ptr that uses the same backing storage as this VkDeviceGroupRenderPassBeginInfo.Ptr, but with the new size.
@NotNull VkDeviceGroupSubmitInfo.Ptr	VkDeviceGroupSubmitInfo.Ptr.reinterpret(long newSize)	Assume the VkDeviceGroupSubmitInfo.Ptr is capable of holding at least newSize structures, create a new view VkDeviceGroupSubmitInfo.Ptr that uses the same backing storage as this VkDeviceGroupSubmitInfo.Ptr, but with the new size.
@NotNull VkDeviceGroupSwapchainCreateInfoKHR.Ptr	VkDeviceGroupSwapchainCreateInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkDeviceGroupSwapchainCreateInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkDeviceGroupSwapchainCreateInfoKHR.Ptr that uses the same backing storage as this VkDeviceGroupSwapchainCreateInfoKHR.Ptr, but with the new size.
@NotNull VkDeviceImageMemoryRequirements.Ptr	VkDeviceImageMemoryRequirements.Ptr.reinterpret(long newSize)	Assume the VkDeviceImageMemoryRequirements.Ptr is capable of holding at least newSize structures, create a new view VkDeviceImageMemoryRequirements.Ptr that uses the same backing storage as this VkDeviceImageMemoryRequirements.Ptr, but with the new size.
@NotNull VkDeviceImageSubresourceInfo.Ptr	VkDeviceImageSubresourceInfo.Ptr.reinterpret(long newSize)	Assume the VkDeviceImageSubresourceInfo.Ptr is capable of holding at least newSize structures, create a new view VkDeviceImageSubresourceInfo.Ptr that uses the same backing storage as this VkDeviceImageSubresourceInfo.Ptr, but with the new size.
@NotNull VkDeviceMemoryOpaqueCaptureAddressInfo.Ptr	VkDeviceMemoryOpaqueCaptureAddressInfo.Ptr.reinterpret(long newSize)	Assume the VkDeviceMemoryOpaqueCaptureAddressInfo.Ptr is capable of holding at least newSize structures, create a new view VkDeviceMemoryOpaqueCaptureAddressInfo.Ptr that uses the same backing storage as this VkDeviceMemoryOpaqueCaptureAddressInfo.Ptr, but with the new size.
@NotNull VkDeviceMemoryOverallocationCreateInfoAMD.Ptr	VkDeviceMemoryOverallocationCreateInfoAMD.Ptr.reinterpret(long newSize)	Assume the VkDeviceMemoryOverallocationCreateInfoAMD.Ptr is capable of holding at least newSize structures, create a new view VkDeviceMemoryOverallocationCreateInfoAMD.Ptr that uses the same backing storage as this VkDeviceMemoryOverallocationCreateInfoAMD.Ptr, but with the new size.
@NotNull VkDeviceMemoryReportCallbackDataEXT.Ptr	VkDeviceMemoryReportCallbackDataEXT.Ptr.reinterpret(long newSize)	Assume the VkDeviceMemoryReportCallbackDataEXT.Ptr is capable of holding at least newSize structures, create a new view VkDeviceMemoryReportCallbackDataEXT.Ptr that uses the same backing storage as this VkDeviceMemoryReportCallbackDataEXT.Ptr, but with the new size.
@NotNull VkDeviceOrHostAddressConstAMDX.Ptr	VkDeviceOrHostAddressConstAMDX.Ptr.reinterpret(long newSize)	Assume the VkDeviceOrHostAddressConstAMDX.Ptr is capable of holding at least newSize structures, create a new view VkDeviceOrHostAddressConstAMDX.Ptr that uses the same backing storage as this VkDeviceOrHostAddressConstAMDX.Ptr, but with the new size.
@NotNull VkDeviceOrHostAddressConstKHR.Ptr	VkDeviceOrHostAddressConstKHR.Ptr.reinterpret(long newSize)	Assume the VkDeviceOrHostAddressConstKHR.Ptr is capable of holding at least newSize structures, create a new view VkDeviceOrHostAddressConstKHR.Ptr that uses the same backing storage as this VkDeviceOrHostAddressConstKHR.Ptr, but with the new size.
@NotNull VkDeviceOrHostAddressKHR.Ptr	VkDeviceOrHostAddressKHR.Ptr.reinterpret(long newSize)	Assume the VkDeviceOrHostAddressKHR.Ptr is capable of holding at least newSize structures, create a new view VkDeviceOrHostAddressKHR.Ptr that uses the same backing storage as this VkDeviceOrHostAddressKHR.Ptr, but with the new size.
@NotNull VkDevicePipelineBinaryInternalCacheControlKHR.Ptr	VkDevicePipelineBinaryInternalCacheControlKHR.Ptr.reinterpret(long newSize)	Assume the VkDevicePipelineBinaryInternalCacheControlKHR.Ptr is capable of holding at least newSize structures, create a new view VkDevicePipelineBinaryInternalCacheControlKHR.Ptr that uses the same backing storage as this VkDevicePipelineBinaryInternalCacheControlKHR.Ptr, but with the new size.
@NotNull VkDevicePrivateDataCreateInfo.Ptr	VkDevicePrivateDataCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkDevicePrivateDataCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkDevicePrivateDataCreateInfo.Ptr that uses the same backing storage as this VkDevicePrivateDataCreateInfo.Ptr, but with the new size.
@NotNull VkDeviceQueueCreateInfo.Ptr	VkDeviceQueueCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkDeviceQueueCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkDeviceQueueCreateInfo.Ptr that uses the same backing storage as this VkDeviceQueueCreateInfo.Ptr, but with the new size.
@NotNull VkDeviceQueueGlobalPriorityCreateInfo.Ptr	VkDeviceQueueGlobalPriorityCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkDeviceQueueGlobalPriorityCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkDeviceQueueGlobalPriorityCreateInfo.Ptr that uses the same backing storage as this VkDeviceQueueGlobalPriorityCreateInfo.Ptr, but with the new size.
@NotNull VkDeviceQueueInfo2.Ptr	VkDeviceQueueInfo2.Ptr.reinterpret(long newSize)	Assume the VkDeviceQueueInfo2.Ptr is capable of holding at least newSize structures, create a new view VkDeviceQueueInfo2.Ptr that uses the same backing storage as this VkDeviceQueueInfo2.Ptr, but with the new size.
@NotNull VkDeviceQueueShaderCoreControlCreateInfoARM.Ptr	VkDeviceQueueShaderCoreControlCreateInfoARM.Ptr.reinterpret(long newSize)	Assume the VkDeviceQueueShaderCoreControlCreateInfoARM.Ptr is capable of holding at least newSize structures, create a new view VkDeviceQueueShaderCoreControlCreateInfoARM.Ptr that uses the same backing storage as this VkDeviceQueueShaderCoreControlCreateInfoARM.Ptr, but with the new size.
@NotNull VkDeviceSemaphoreSciSyncPoolReservationCreateInfoNV.Ptr	VkDeviceSemaphoreSciSyncPoolReservationCreateInfoNV.Ptr.reinterpret(long newSize)	Assume the VkDeviceSemaphoreSciSyncPoolReservationCreateInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkDeviceSemaphoreSciSyncPoolReservationCreateInfoNV.Ptr that uses the same backing storage as this VkDeviceSemaphoreSciSyncPoolReservationCreateInfoNV.Ptr, but with the new size.
@NotNull VkDirectDriverLoadingInfoLUNARG.Ptr	VkDirectDriverLoadingInfoLUNARG.Ptr.reinterpret(long newSize)	Assume the VkDirectDriverLoadingInfoLUNARG.Ptr is capable of holding at least newSize structures, create a new view VkDirectDriverLoadingInfoLUNARG.Ptr that uses the same backing storage as this VkDirectDriverLoadingInfoLUNARG.Ptr, but with the new size.
@NotNull VkDirectDriverLoadingListLUNARG.Ptr	VkDirectDriverLoadingListLUNARG.Ptr.reinterpret(long newSize)	Assume the VkDirectDriverLoadingListLUNARG.Ptr is capable of holding at least newSize structures, create a new view VkDirectDriverLoadingListLUNARG.Ptr that uses the same backing storage as this VkDirectDriverLoadingListLUNARG.Ptr, but with the new size.
@NotNull VkDirectFBSurfaceCreateInfoEXT.Ptr	VkDirectFBSurfaceCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkDirectFBSurfaceCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkDirectFBSurfaceCreateInfoEXT.Ptr that uses the same backing storage as this VkDirectFBSurfaceCreateInfoEXT.Ptr, but with the new size.
@NotNull VkDispatchGraphCountInfoAMDX.Ptr	VkDispatchGraphCountInfoAMDX.Ptr.reinterpret(long newSize)	Assume the VkDispatchGraphCountInfoAMDX.Ptr is capable of holding at least newSize structures, create a new view VkDispatchGraphCountInfoAMDX.Ptr that uses the same backing storage as this VkDispatchGraphCountInfoAMDX.Ptr, but with the new size.
@NotNull VkDispatchGraphInfoAMDX.Ptr	VkDispatchGraphInfoAMDX.Ptr.reinterpret(long newSize)	Assume the VkDispatchGraphInfoAMDX.Ptr is capable of holding at least newSize structures, create a new view VkDispatchGraphInfoAMDX.Ptr that uses the same backing storage as this VkDispatchGraphInfoAMDX.Ptr, but with the new size.
@NotNull VkDispatchIndirectCommand.Ptr	VkDispatchIndirectCommand.Ptr.reinterpret(long newSize)	Assume the VkDispatchIndirectCommand.Ptr is capable of holding at least newSize structures, create a new view VkDispatchIndirectCommand.Ptr that uses the same backing storage as this VkDispatchIndirectCommand.Ptr, but with the new size.
@NotNull VkDispatchTileInfoQCOM.Ptr	VkDispatchTileInfoQCOM.Ptr.reinterpret(long newSize)	Assume the VkDispatchTileInfoQCOM.Ptr is capable of holding at least newSize structures, create a new view VkDispatchTileInfoQCOM.Ptr that uses the same backing storage as this VkDispatchTileInfoQCOM.Ptr, but with the new size.
@NotNull VkDisplayEventInfoEXT.Ptr	VkDisplayEventInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkDisplayEventInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkDisplayEventInfoEXT.Ptr that uses the same backing storage as this VkDisplayEventInfoEXT.Ptr, but with the new size.
@NotNull VkDisplayModeCreateInfoKHR.Ptr	VkDisplayModeCreateInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkDisplayModeCreateInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkDisplayModeCreateInfoKHR.Ptr that uses the same backing storage as this VkDisplayModeCreateInfoKHR.Ptr, but with the new size.
@NotNull VkDisplayModeParametersKHR.Ptr	VkDisplayModeParametersKHR.Ptr.reinterpret(long newSize)	Assume the VkDisplayModeParametersKHR.Ptr is capable of holding at least newSize structures, create a new view VkDisplayModeParametersKHR.Ptr that uses the same backing storage as this VkDisplayModeParametersKHR.Ptr, but with the new size.
@NotNull VkDisplayModeProperties2KHR.Ptr	VkDisplayModeProperties2KHR.Ptr.reinterpret(long newSize)	Assume the VkDisplayModeProperties2KHR.Ptr is capable of holding at least newSize structures, create a new view VkDisplayModeProperties2KHR.Ptr that uses the same backing storage as this VkDisplayModeProperties2KHR.Ptr, but with the new size.
@NotNull VkDisplayModePropertiesKHR.Ptr	VkDisplayModePropertiesKHR.Ptr.reinterpret(long newSize)	Assume the VkDisplayModePropertiesKHR.Ptr is capable of holding at least newSize structures, create a new view VkDisplayModePropertiesKHR.Ptr that uses the same backing storage as this VkDisplayModePropertiesKHR.Ptr, but with the new size.
@NotNull VkDisplayModeStereoPropertiesNV.Ptr	VkDisplayModeStereoPropertiesNV.Ptr.reinterpret(long newSize)	Assume the VkDisplayModeStereoPropertiesNV.Ptr is capable of holding at least newSize structures, create a new view VkDisplayModeStereoPropertiesNV.Ptr that uses the same backing storage as this VkDisplayModeStereoPropertiesNV.Ptr, but with the new size.
@NotNull VkDisplayNativeHdrSurfaceCapabilitiesAMD.Ptr	VkDisplayNativeHdrSurfaceCapabilitiesAMD.Ptr.reinterpret(long newSize)	Assume the VkDisplayNativeHdrSurfaceCapabilitiesAMD.Ptr is capable of holding at least newSize structures, create a new view VkDisplayNativeHdrSurfaceCapabilitiesAMD.Ptr that uses the same backing storage as this VkDisplayNativeHdrSurfaceCapabilitiesAMD.Ptr, but with the new size.
@NotNull VkDisplayPlaneCapabilities2KHR.Ptr	VkDisplayPlaneCapabilities2KHR.Ptr.reinterpret(long newSize)	Assume the VkDisplayPlaneCapabilities2KHR.Ptr is capable of holding at least newSize structures, create a new view VkDisplayPlaneCapabilities2KHR.Ptr that uses the same backing storage as this VkDisplayPlaneCapabilities2KHR.Ptr, but with the new size.
@NotNull VkDisplayPlaneCapabilitiesKHR.Ptr	VkDisplayPlaneCapabilitiesKHR.Ptr.reinterpret(long newSize)	Assume the VkDisplayPlaneCapabilitiesKHR.Ptr is capable of holding at least newSize structures, create a new view VkDisplayPlaneCapabilitiesKHR.Ptr that uses the same backing storage as this VkDisplayPlaneCapabilitiesKHR.Ptr, but with the new size.
@NotNull VkDisplayPlaneInfo2KHR.Ptr	VkDisplayPlaneInfo2KHR.Ptr.reinterpret(long newSize)	Assume the VkDisplayPlaneInfo2KHR.Ptr is capable of holding at least newSize structures, create a new view VkDisplayPlaneInfo2KHR.Ptr that uses the same backing storage as this VkDisplayPlaneInfo2KHR.Ptr, but with the new size.
@NotNull VkDisplayPlaneProperties2KHR.Ptr	VkDisplayPlaneProperties2KHR.Ptr.reinterpret(long newSize)	Assume the VkDisplayPlaneProperties2KHR.Ptr is capable of holding at least newSize structures, create a new view VkDisplayPlaneProperties2KHR.Ptr that uses the same backing storage as this VkDisplayPlaneProperties2KHR.Ptr, but with the new size.
@NotNull VkDisplayPlanePropertiesKHR.Ptr	VkDisplayPlanePropertiesKHR.Ptr.reinterpret(long newSize)	Assume the VkDisplayPlanePropertiesKHR.Ptr is capable of holding at least newSize structures, create a new view VkDisplayPlanePropertiesKHR.Ptr that uses the same backing storage as this VkDisplayPlanePropertiesKHR.Ptr, but with the new size.
@NotNull VkDisplayPowerInfoEXT.Ptr	VkDisplayPowerInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkDisplayPowerInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkDisplayPowerInfoEXT.Ptr that uses the same backing storage as this VkDisplayPowerInfoEXT.Ptr, but with the new size.
@NotNull VkDisplayPresentInfoKHR.Ptr	VkDisplayPresentInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkDisplayPresentInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkDisplayPresentInfoKHR.Ptr that uses the same backing storage as this VkDisplayPresentInfoKHR.Ptr, but with the new size.
@NotNull VkDisplayProperties2KHR.Ptr	VkDisplayProperties2KHR.Ptr.reinterpret(long newSize)	Assume the VkDisplayProperties2KHR.Ptr is capable of holding at least newSize structures, create a new view VkDisplayProperties2KHR.Ptr that uses the same backing storage as this VkDisplayProperties2KHR.Ptr, but with the new size.
@NotNull VkDisplayPropertiesKHR.Ptr	VkDisplayPropertiesKHR.Ptr.reinterpret(long newSize)	Assume the VkDisplayPropertiesKHR.Ptr is capable of holding at least newSize structures, create a new view VkDisplayPropertiesKHR.Ptr that uses the same backing storage as this VkDisplayPropertiesKHR.Ptr, but with the new size.
@NotNull VkDisplaySurfaceCreateInfoKHR.Ptr	VkDisplaySurfaceCreateInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkDisplaySurfaceCreateInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkDisplaySurfaceCreateInfoKHR.Ptr that uses the same backing storage as this VkDisplaySurfaceCreateInfoKHR.Ptr, but with the new size.
@NotNull VkDisplaySurfaceStereoCreateInfoNV.Ptr	VkDisplaySurfaceStereoCreateInfoNV.Ptr.reinterpret(long newSize)	Assume the VkDisplaySurfaceStereoCreateInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkDisplaySurfaceStereoCreateInfoNV.Ptr that uses the same backing storage as this VkDisplaySurfaceStereoCreateInfoNV.Ptr, but with the new size.
@NotNull VkDrawIndexedIndirectCommand.Ptr	VkDrawIndexedIndirectCommand.Ptr.reinterpret(long newSize)	Assume the VkDrawIndexedIndirectCommand.Ptr is capable of holding at least newSize structures, create a new view VkDrawIndexedIndirectCommand.Ptr that uses the same backing storage as this VkDrawIndexedIndirectCommand.Ptr, but with the new size.
@NotNull VkDrawIndirectCommand.Ptr	VkDrawIndirectCommand.Ptr.reinterpret(long newSize)	Assume the VkDrawIndirectCommand.Ptr is capable of holding at least newSize structures, create a new view VkDrawIndirectCommand.Ptr that uses the same backing storage as this VkDrawIndirectCommand.Ptr, but with the new size.
@NotNull VkDrawIndirectCountIndirectCommandEXT.Ptr	VkDrawIndirectCountIndirectCommandEXT.Ptr.reinterpret(long newSize)	Assume the VkDrawIndirectCountIndirectCommandEXT.Ptr is capable of holding at least newSize structures, create a new view VkDrawIndirectCountIndirectCommandEXT.Ptr that uses the same backing storage as this VkDrawIndirectCountIndirectCommandEXT.Ptr, but with the new size.
@NotNull VkDrawMeshTasksIndirectCommandEXT.Ptr	VkDrawMeshTasksIndirectCommandEXT.Ptr.reinterpret(long newSize)	Assume the VkDrawMeshTasksIndirectCommandEXT.Ptr is capable of holding at least newSize structures, create a new view VkDrawMeshTasksIndirectCommandEXT.Ptr that uses the same backing storage as this VkDrawMeshTasksIndirectCommandEXT.Ptr, but with the new size.
@NotNull VkDrawMeshTasksIndirectCommandNV.Ptr	VkDrawMeshTasksIndirectCommandNV.Ptr.reinterpret(long newSize)	Assume the VkDrawMeshTasksIndirectCommandNV.Ptr is capable of holding at least newSize structures, create a new view VkDrawMeshTasksIndirectCommandNV.Ptr that uses the same backing storage as this VkDrawMeshTasksIndirectCommandNV.Ptr, but with the new size.
@NotNull VkDrmFormatModifierProperties2EXT.Ptr	VkDrmFormatModifierProperties2EXT.Ptr.reinterpret(long newSize)	Assume the VkDrmFormatModifierProperties2EXT.Ptr is capable of holding at least newSize structures, create a new view VkDrmFormatModifierProperties2EXT.Ptr that uses the same backing storage as this VkDrmFormatModifierProperties2EXT.Ptr, but with the new size.
@NotNull VkDrmFormatModifierPropertiesEXT.Ptr	VkDrmFormatModifierPropertiesEXT.Ptr.reinterpret(long newSize)	Assume the VkDrmFormatModifierPropertiesEXT.Ptr is capable of holding at least newSize structures, create a new view VkDrmFormatModifierPropertiesEXT.Ptr that uses the same backing storage as this VkDrmFormatModifierPropertiesEXT.Ptr, but with the new size.
@NotNull VkDrmFormatModifierPropertiesList2EXT.Ptr	VkDrmFormatModifierPropertiesList2EXT.Ptr.reinterpret(long newSize)	Assume the VkDrmFormatModifierPropertiesList2EXT.Ptr is capable of holding at least newSize structures, create a new view VkDrmFormatModifierPropertiesList2EXT.Ptr that uses the same backing storage as this VkDrmFormatModifierPropertiesList2EXT.Ptr, but with the new size.
@NotNull VkDrmFormatModifierPropertiesListEXT.Ptr	VkDrmFormatModifierPropertiesListEXT.Ptr.reinterpret(long newSize)	Assume the VkDrmFormatModifierPropertiesListEXT.Ptr is capable of holding at least newSize structures, create a new view VkDrmFormatModifierPropertiesListEXT.Ptr that uses the same backing storage as this VkDrmFormatModifierPropertiesListEXT.Ptr, but with the new size.
@NotNull VkEventCreateInfo.Ptr	VkEventCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkEventCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkEventCreateInfo.Ptr that uses the same backing storage as this VkEventCreateInfo.Ptr, but with the new size.
@NotNull VkExecutionGraphPipelineCreateInfoAMDX.Ptr	VkExecutionGraphPipelineCreateInfoAMDX.Ptr.reinterpret(long newSize)	Assume the VkExecutionGraphPipelineCreateInfoAMDX.Ptr is capable of holding at least newSize structures, create a new view VkExecutionGraphPipelineCreateInfoAMDX.Ptr that uses the same backing storage as this VkExecutionGraphPipelineCreateInfoAMDX.Ptr, but with the new size.
@NotNull VkExecutionGraphPipelineScratchSizeAMDX.Ptr	VkExecutionGraphPipelineScratchSizeAMDX.Ptr.reinterpret(long newSize)	Assume the VkExecutionGraphPipelineScratchSizeAMDX.Ptr is capable of holding at least newSize structures, create a new view VkExecutionGraphPipelineScratchSizeAMDX.Ptr that uses the same backing storage as this VkExecutionGraphPipelineScratchSizeAMDX.Ptr, but with the new size.
@NotNull VkExportFenceCreateInfo.Ptr	VkExportFenceCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkExportFenceCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkExportFenceCreateInfo.Ptr that uses the same backing storage as this VkExportFenceCreateInfo.Ptr, but with the new size.
@NotNull VkExportFenceSciSyncInfoNV.Ptr	VkExportFenceSciSyncInfoNV.Ptr.reinterpret(long newSize)	Assume the VkExportFenceSciSyncInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkExportFenceSciSyncInfoNV.Ptr that uses the same backing storage as this VkExportFenceSciSyncInfoNV.Ptr, but with the new size.
@NotNull VkExportFenceWin32HandleInfoKHR.Ptr	VkExportFenceWin32HandleInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkExportFenceWin32HandleInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkExportFenceWin32HandleInfoKHR.Ptr that uses the same backing storage as this VkExportFenceWin32HandleInfoKHR.Ptr, but with the new size.
@NotNull VkExportMemoryAllocateInfo.Ptr	VkExportMemoryAllocateInfo.Ptr.reinterpret(long newSize)	Assume the VkExportMemoryAllocateInfo.Ptr is capable of holding at least newSize structures, create a new view VkExportMemoryAllocateInfo.Ptr that uses the same backing storage as this VkExportMemoryAllocateInfo.Ptr, but with the new size.
@NotNull VkExportMemoryAllocateInfoNV.Ptr	VkExportMemoryAllocateInfoNV.Ptr.reinterpret(long newSize)	Assume the VkExportMemoryAllocateInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkExportMemoryAllocateInfoNV.Ptr that uses the same backing storage as this VkExportMemoryAllocateInfoNV.Ptr, but with the new size.
@NotNull VkExportMemorySciBufInfoNV.Ptr	VkExportMemorySciBufInfoNV.Ptr.reinterpret(long newSize)	Assume the VkExportMemorySciBufInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkExportMemorySciBufInfoNV.Ptr that uses the same backing storage as this VkExportMemorySciBufInfoNV.Ptr, but with the new size.
@NotNull VkExportMemoryWin32HandleInfoKHR.Ptr	VkExportMemoryWin32HandleInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkExportMemoryWin32HandleInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkExportMemoryWin32HandleInfoKHR.Ptr that uses the same backing storage as this VkExportMemoryWin32HandleInfoKHR.Ptr, but with the new size.
@NotNull VkExportMemoryWin32HandleInfoNV.Ptr	VkExportMemoryWin32HandleInfoNV.Ptr.reinterpret(long newSize)	Assume the VkExportMemoryWin32HandleInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkExportMemoryWin32HandleInfoNV.Ptr that uses the same backing storage as this VkExportMemoryWin32HandleInfoNV.Ptr, but with the new size.
@NotNull VkExportMetalBufferInfoEXT.Ptr	VkExportMetalBufferInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkExportMetalBufferInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkExportMetalBufferInfoEXT.Ptr that uses the same backing storage as this VkExportMetalBufferInfoEXT.Ptr, but with the new size.
@NotNull VkExportMetalCommandQueueInfoEXT.Ptr	VkExportMetalCommandQueueInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkExportMetalCommandQueueInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkExportMetalCommandQueueInfoEXT.Ptr that uses the same backing storage as this VkExportMetalCommandQueueInfoEXT.Ptr, but with the new size.
@NotNull VkExportMetalDeviceInfoEXT.Ptr	VkExportMetalDeviceInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkExportMetalDeviceInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkExportMetalDeviceInfoEXT.Ptr that uses the same backing storage as this VkExportMetalDeviceInfoEXT.Ptr, but with the new size.
@NotNull VkExportMetalIOSurfaceInfoEXT.Ptr	VkExportMetalIOSurfaceInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkExportMetalIOSurfaceInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkExportMetalIOSurfaceInfoEXT.Ptr that uses the same backing storage as this VkExportMetalIOSurfaceInfoEXT.Ptr, but with the new size.
@NotNull VkExportMetalObjectCreateInfoEXT.Ptr	VkExportMetalObjectCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkExportMetalObjectCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkExportMetalObjectCreateInfoEXT.Ptr that uses the same backing storage as this VkExportMetalObjectCreateInfoEXT.Ptr, but with the new size.
@NotNull VkExportMetalObjectsInfoEXT.Ptr	VkExportMetalObjectsInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkExportMetalObjectsInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkExportMetalObjectsInfoEXT.Ptr that uses the same backing storage as this VkExportMetalObjectsInfoEXT.Ptr, but with the new size.
@NotNull VkExportMetalSharedEventInfoEXT.Ptr	VkExportMetalSharedEventInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkExportMetalSharedEventInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkExportMetalSharedEventInfoEXT.Ptr that uses the same backing storage as this VkExportMetalSharedEventInfoEXT.Ptr, but with the new size.
@NotNull VkExportMetalTextureInfoEXT.Ptr	VkExportMetalTextureInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkExportMetalTextureInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkExportMetalTextureInfoEXT.Ptr that uses the same backing storage as this VkExportMetalTextureInfoEXT.Ptr, but with the new size.
@NotNull VkExportSemaphoreCreateInfo.Ptr	VkExportSemaphoreCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkExportSemaphoreCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkExportSemaphoreCreateInfo.Ptr that uses the same backing storage as this VkExportSemaphoreCreateInfo.Ptr, but with the new size.
@NotNull VkExportSemaphoreSciSyncInfoNV.Ptr	VkExportSemaphoreSciSyncInfoNV.Ptr.reinterpret(long newSize)	Assume the VkExportSemaphoreSciSyncInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkExportSemaphoreSciSyncInfoNV.Ptr that uses the same backing storage as this VkExportSemaphoreSciSyncInfoNV.Ptr, but with the new size.
@NotNull VkExportSemaphoreWin32HandleInfoKHR.Ptr	VkExportSemaphoreWin32HandleInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkExportSemaphoreWin32HandleInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkExportSemaphoreWin32HandleInfoKHR.Ptr that uses the same backing storage as this VkExportSemaphoreWin32HandleInfoKHR.Ptr, but with the new size.
@NotNull VkExtensionProperties.Ptr	VkExtensionProperties.Ptr.reinterpret(long newSize)	Assume the VkExtensionProperties.Ptr is capable of holding at least newSize structures, create a new view VkExtensionProperties.Ptr that uses the same backing storage as this VkExtensionProperties.Ptr, but with the new size.
@NotNull VkExtent2D.Ptr	VkExtent2D.Ptr.reinterpret(long newSize)	Assume the VkExtent2D.Ptr is capable of holding at least newSize structures, create a new view VkExtent2D.Ptr that uses the same backing storage as this VkExtent2D.Ptr, but with the new size.
@NotNull VkExtent3D.Ptr	VkExtent3D.Ptr.reinterpret(long newSize)	Assume the VkExtent3D.Ptr is capable of holding at least newSize structures, create a new view VkExtent3D.Ptr that uses the same backing storage as this VkExtent3D.Ptr, but with the new size.
@NotNull VkExternalBufferProperties.Ptr	VkExternalBufferProperties.Ptr.reinterpret(long newSize)	Assume the VkExternalBufferProperties.Ptr is capable of holding at least newSize structures, create a new view VkExternalBufferProperties.Ptr that uses the same backing storage as this VkExternalBufferProperties.Ptr, but with the new size.
@NotNull VkExternalComputeQueueCreateInfoNV.Ptr	VkExternalComputeQueueCreateInfoNV.Ptr.reinterpret(long newSize)	Assume the VkExternalComputeQueueCreateInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkExternalComputeQueueCreateInfoNV.Ptr that uses the same backing storage as this VkExternalComputeQueueCreateInfoNV.Ptr, but with the new size.
@NotNull VkExternalComputeQueueDataParamsNV.Ptr	VkExternalComputeQueueDataParamsNV.Ptr.reinterpret(long newSize)	Assume the VkExternalComputeQueueDataParamsNV.Ptr is capable of holding at least newSize structures, create a new view VkExternalComputeQueueDataParamsNV.Ptr that uses the same backing storage as this VkExternalComputeQueueDataParamsNV.Ptr, but with the new size.
@NotNull VkExternalComputeQueueDeviceCreateInfoNV.Ptr	VkExternalComputeQueueDeviceCreateInfoNV.Ptr.reinterpret(long newSize)	Assume the VkExternalComputeQueueDeviceCreateInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkExternalComputeQueueDeviceCreateInfoNV.Ptr that uses the same backing storage as this VkExternalComputeQueueDeviceCreateInfoNV.Ptr, but with the new size.
@NotNull VkExternalFenceProperties.Ptr	VkExternalFenceProperties.Ptr.reinterpret(long newSize)	Assume the VkExternalFenceProperties.Ptr is capable of holding at least newSize structures, create a new view VkExternalFenceProperties.Ptr that uses the same backing storage as this VkExternalFenceProperties.Ptr, but with the new size.
@NotNull VkExternalFormatANDROID.Ptr	VkExternalFormatANDROID.Ptr.reinterpret(long newSize)	Assume the VkExternalFormatANDROID.Ptr is capable of holding at least newSize structures, create a new view VkExternalFormatANDROID.Ptr that uses the same backing storage as this VkExternalFormatANDROID.Ptr, but with the new size.
@NotNull VkExternalFormatQNX.Ptr	VkExternalFormatQNX.Ptr.reinterpret(long newSize)	Assume the VkExternalFormatQNX.Ptr is capable of holding at least newSize structures, create a new view VkExternalFormatQNX.Ptr that uses the same backing storage as this VkExternalFormatQNX.Ptr, but with the new size.
@NotNull VkExternalImageFormatProperties.Ptr	VkExternalImageFormatProperties.Ptr.reinterpret(long newSize)	Assume the VkExternalImageFormatProperties.Ptr is capable of holding at least newSize structures, create a new view VkExternalImageFormatProperties.Ptr that uses the same backing storage as this VkExternalImageFormatProperties.Ptr, but with the new size.
@NotNull VkExternalImageFormatPropertiesNV.Ptr	VkExternalImageFormatPropertiesNV.Ptr.reinterpret(long newSize)	Assume the VkExternalImageFormatPropertiesNV.Ptr is capable of holding at least newSize structures, create a new view VkExternalImageFormatPropertiesNV.Ptr that uses the same backing storage as this VkExternalImageFormatPropertiesNV.Ptr, but with the new size.
@NotNull VkExternalMemoryAcquireUnmodifiedEXT.Ptr	VkExternalMemoryAcquireUnmodifiedEXT.Ptr.reinterpret(long newSize)	Assume the VkExternalMemoryAcquireUnmodifiedEXT.Ptr is capable of holding at least newSize structures, create a new view VkExternalMemoryAcquireUnmodifiedEXT.Ptr that uses the same backing storage as this VkExternalMemoryAcquireUnmodifiedEXT.Ptr, but with the new size.
@NotNull VkExternalMemoryBufferCreateInfo.Ptr	VkExternalMemoryBufferCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkExternalMemoryBufferCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkExternalMemoryBufferCreateInfo.Ptr that uses the same backing storage as this VkExternalMemoryBufferCreateInfo.Ptr, but with the new size.
@NotNull VkExternalMemoryImageCreateInfo.Ptr	VkExternalMemoryImageCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkExternalMemoryImageCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkExternalMemoryImageCreateInfo.Ptr that uses the same backing storage as this VkExternalMemoryImageCreateInfo.Ptr, but with the new size.
@NotNull VkExternalMemoryImageCreateInfoNV.Ptr	VkExternalMemoryImageCreateInfoNV.Ptr.reinterpret(long newSize)	Assume the VkExternalMemoryImageCreateInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkExternalMemoryImageCreateInfoNV.Ptr that uses the same backing storage as this VkExternalMemoryImageCreateInfoNV.Ptr, but with the new size.
@NotNull VkExternalMemoryProperties.Ptr	VkExternalMemoryProperties.Ptr.reinterpret(long newSize)	Assume the VkExternalMemoryProperties.Ptr is capable of holding at least newSize structures, create a new view VkExternalMemoryProperties.Ptr that uses the same backing storage as this VkExternalMemoryProperties.Ptr, but with the new size.
@NotNull VkExternalSemaphoreProperties.Ptr	VkExternalSemaphoreProperties.Ptr.reinterpret(long newSize)	Assume the VkExternalSemaphoreProperties.Ptr is capable of holding at least newSize structures, create a new view VkExternalSemaphoreProperties.Ptr that uses the same backing storage as this VkExternalSemaphoreProperties.Ptr, but with the new size.
@NotNull VkFenceCreateInfo.Ptr	VkFenceCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkFenceCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkFenceCreateInfo.Ptr that uses the same backing storage as this VkFenceCreateInfo.Ptr, but with the new size.
@NotNull VkFenceGetFdInfoKHR.Ptr	VkFenceGetFdInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkFenceGetFdInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkFenceGetFdInfoKHR.Ptr that uses the same backing storage as this VkFenceGetFdInfoKHR.Ptr, but with the new size.
@NotNull VkFenceGetSciSyncInfoNV.Ptr	VkFenceGetSciSyncInfoNV.Ptr.reinterpret(long newSize)	Assume the VkFenceGetSciSyncInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkFenceGetSciSyncInfoNV.Ptr that uses the same backing storage as this VkFenceGetSciSyncInfoNV.Ptr, but with the new size.
@NotNull VkFenceGetWin32HandleInfoKHR.Ptr	VkFenceGetWin32HandleInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkFenceGetWin32HandleInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkFenceGetWin32HandleInfoKHR.Ptr that uses the same backing storage as this VkFenceGetWin32HandleInfoKHR.Ptr, but with the new size.
@NotNull VkFilterCubicImageViewImageFormatPropertiesEXT.Ptr	VkFilterCubicImageViewImageFormatPropertiesEXT.Ptr.reinterpret(long newSize)	Assume the VkFilterCubicImageViewImageFormatPropertiesEXT.Ptr is capable of holding at least newSize structures, create a new view VkFilterCubicImageViewImageFormatPropertiesEXT.Ptr that uses the same backing storage as this VkFilterCubicImageViewImageFormatPropertiesEXT.Ptr, but with the new size.
@NotNull VkFormatProperties.Ptr	VkFormatProperties.Ptr.reinterpret(long newSize)	Assume the VkFormatProperties.Ptr is capable of holding at least newSize structures, create a new view VkFormatProperties.Ptr that uses the same backing storage as this VkFormatProperties.Ptr, but with the new size.
@NotNull VkFormatProperties2.Ptr	VkFormatProperties2.Ptr.reinterpret(long newSize)	Assume the VkFormatProperties2.Ptr is capable of holding at least newSize structures, create a new view VkFormatProperties2.Ptr that uses the same backing storage as this VkFormatProperties2.Ptr, but with the new size.
@NotNull VkFormatProperties3.Ptr	VkFormatProperties3.Ptr.reinterpret(long newSize)	Assume the VkFormatProperties3.Ptr is capable of holding at least newSize structures, create a new view VkFormatProperties3.Ptr that uses the same backing storage as this VkFormatProperties3.Ptr, but with the new size.
@NotNull VkFragmentShadingRateAttachmentInfoKHR.Ptr	VkFragmentShadingRateAttachmentInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkFragmentShadingRateAttachmentInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkFragmentShadingRateAttachmentInfoKHR.Ptr that uses the same backing storage as this VkFragmentShadingRateAttachmentInfoKHR.Ptr, but with the new size.
@NotNull VkFrameBoundaryEXT.Ptr	VkFrameBoundaryEXT.Ptr.reinterpret(long newSize)	Assume the VkFrameBoundaryEXT.Ptr is capable of holding at least newSize structures, create a new view VkFrameBoundaryEXT.Ptr that uses the same backing storage as this VkFrameBoundaryEXT.Ptr, but with the new size.
@NotNull VkFramebufferAttachmentImageInfo.Ptr	VkFramebufferAttachmentImageInfo.Ptr.reinterpret(long newSize)	Assume the VkFramebufferAttachmentImageInfo.Ptr is capable of holding at least newSize structures, create a new view VkFramebufferAttachmentImageInfo.Ptr that uses the same backing storage as this VkFramebufferAttachmentImageInfo.Ptr, but with the new size.
@NotNull VkFramebufferAttachmentsCreateInfo.Ptr	VkFramebufferAttachmentsCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkFramebufferAttachmentsCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkFramebufferAttachmentsCreateInfo.Ptr that uses the same backing storage as this VkFramebufferAttachmentsCreateInfo.Ptr, but with the new size.
@NotNull VkFramebufferCreateInfo.Ptr	VkFramebufferCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkFramebufferCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkFramebufferCreateInfo.Ptr that uses the same backing storage as this VkFramebufferCreateInfo.Ptr, but with the new size.
@NotNull VkFramebufferMixedSamplesCombinationNV.Ptr	VkFramebufferMixedSamplesCombinationNV.Ptr.reinterpret(long newSize)	Assume the VkFramebufferMixedSamplesCombinationNV.Ptr is capable of holding at least newSize structures, create a new view VkFramebufferMixedSamplesCombinationNV.Ptr that uses the same backing storage as this VkFramebufferMixedSamplesCombinationNV.Ptr, but with the new size.
@NotNull VkGeneratedCommandsInfoEXT.Ptr	VkGeneratedCommandsInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkGeneratedCommandsInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkGeneratedCommandsInfoEXT.Ptr that uses the same backing storage as this VkGeneratedCommandsInfoEXT.Ptr, but with the new size.
@NotNull VkGeneratedCommandsInfoNV.Ptr	VkGeneratedCommandsInfoNV.Ptr.reinterpret(long newSize)	Assume the VkGeneratedCommandsInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkGeneratedCommandsInfoNV.Ptr that uses the same backing storage as this VkGeneratedCommandsInfoNV.Ptr, but with the new size.
@NotNull VkGeneratedCommandsMemoryRequirementsInfoEXT.Ptr	VkGeneratedCommandsMemoryRequirementsInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkGeneratedCommandsMemoryRequirementsInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkGeneratedCommandsMemoryRequirementsInfoEXT.Ptr that uses the same backing storage as this VkGeneratedCommandsMemoryRequirementsInfoEXT.Ptr, but with the new size.
@NotNull VkGeneratedCommandsMemoryRequirementsInfoNV.Ptr	VkGeneratedCommandsMemoryRequirementsInfoNV.Ptr.reinterpret(long newSize)	Assume the VkGeneratedCommandsMemoryRequirementsInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkGeneratedCommandsMemoryRequirementsInfoNV.Ptr that uses the same backing storage as this VkGeneratedCommandsMemoryRequirementsInfoNV.Ptr, but with the new size.
@NotNull VkGeneratedCommandsPipelineInfoEXT.Ptr	VkGeneratedCommandsPipelineInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkGeneratedCommandsPipelineInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkGeneratedCommandsPipelineInfoEXT.Ptr that uses the same backing storage as this VkGeneratedCommandsPipelineInfoEXT.Ptr, but with the new size.
@NotNull VkGeneratedCommandsShaderInfoEXT.Ptr	VkGeneratedCommandsShaderInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkGeneratedCommandsShaderInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkGeneratedCommandsShaderInfoEXT.Ptr that uses the same backing storage as this VkGeneratedCommandsShaderInfoEXT.Ptr, but with the new size.
@NotNull VkGeometryAABBNV.Ptr	VkGeometryAABBNV.Ptr.reinterpret(long newSize)	Assume the VkGeometryAABBNV.Ptr is capable of holding at least newSize structures, create a new view VkGeometryAABBNV.Ptr that uses the same backing storage as this VkGeometryAABBNV.Ptr, but with the new size.
@NotNull VkGeometryDataNV.Ptr	VkGeometryDataNV.Ptr.reinterpret(long newSize)	Assume the VkGeometryDataNV.Ptr is capable of holding at least newSize structures, create a new view VkGeometryDataNV.Ptr that uses the same backing storage as this VkGeometryDataNV.Ptr, but with the new size.
@NotNull VkGeometryNV.Ptr	VkGeometryNV.Ptr.reinterpret(long newSize)	Assume the VkGeometryNV.Ptr is capable of holding at least newSize structures, create a new view VkGeometryNV.Ptr that uses the same backing storage as this VkGeometryNV.Ptr, but with the new size.
@NotNull VkGeometryTrianglesNV.Ptr	VkGeometryTrianglesNV.Ptr.reinterpret(long newSize)	Assume the VkGeometryTrianglesNV.Ptr is capable of holding at least newSize structures, create a new view VkGeometryTrianglesNV.Ptr that uses the same backing storage as this VkGeometryTrianglesNV.Ptr, but with the new size.
@NotNull VkGetLatencyMarkerInfoNV.Ptr	VkGetLatencyMarkerInfoNV.Ptr.reinterpret(long newSize)	Assume the VkGetLatencyMarkerInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkGetLatencyMarkerInfoNV.Ptr that uses the same backing storage as this VkGetLatencyMarkerInfoNV.Ptr, but with the new size.
@NotNull VkGraphicsPipelineCreateInfo.Ptr	VkGraphicsPipelineCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkGraphicsPipelineCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkGraphicsPipelineCreateInfo.Ptr that uses the same backing storage as this VkGraphicsPipelineCreateInfo.Ptr, but with the new size.
@NotNull VkGraphicsPipelineLibraryCreateInfoEXT.Ptr	VkGraphicsPipelineLibraryCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkGraphicsPipelineLibraryCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkGraphicsPipelineLibraryCreateInfoEXT.Ptr that uses the same backing storage as this VkGraphicsPipelineLibraryCreateInfoEXT.Ptr, but with the new size.
@NotNull VkGraphicsPipelineShaderGroupsCreateInfoNV.Ptr	VkGraphicsPipelineShaderGroupsCreateInfoNV.Ptr.reinterpret(long newSize)	Assume the VkGraphicsPipelineShaderGroupsCreateInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkGraphicsPipelineShaderGroupsCreateInfoNV.Ptr that uses the same backing storage as this VkGraphicsPipelineShaderGroupsCreateInfoNV.Ptr, but with the new size.
@NotNull VkGraphicsShaderGroupCreateInfoNV.Ptr	VkGraphicsShaderGroupCreateInfoNV.Ptr.reinterpret(long newSize)	Assume the VkGraphicsShaderGroupCreateInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkGraphicsShaderGroupCreateInfoNV.Ptr that uses the same backing storage as this VkGraphicsShaderGroupCreateInfoNV.Ptr, but with the new size.
@NotNull VkHdrMetadataEXT.Ptr	VkHdrMetadataEXT.Ptr.reinterpret(long newSize)	Assume the VkHdrMetadataEXT.Ptr is capable of holding at least newSize structures, create a new view VkHdrMetadataEXT.Ptr that uses the same backing storage as this VkHdrMetadataEXT.Ptr, but with the new size.
@NotNull VkHdrVividDynamicMetadataHUAWEI.Ptr	VkHdrVividDynamicMetadataHUAWEI.Ptr.reinterpret(long newSize)	Assume the VkHdrVividDynamicMetadataHUAWEI.Ptr is capable of holding at least newSize structures, create a new view VkHdrVividDynamicMetadataHUAWEI.Ptr that uses the same backing storage as this VkHdrVividDynamicMetadataHUAWEI.Ptr, but with the new size.
@NotNull VkHeadlessSurfaceCreateInfoEXT.Ptr	VkHeadlessSurfaceCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkHeadlessSurfaceCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkHeadlessSurfaceCreateInfoEXT.Ptr that uses the same backing storage as this VkHeadlessSurfaceCreateInfoEXT.Ptr, but with the new size.
@NotNull VkHostImageCopyDevicePerformanceQuery.Ptr	VkHostImageCopyDevicePerformanceQuery.Ptr.reinterpret(long newSize)	Assume the VkHostImageCopyDevicePerformanceQuery.Ptr is capable of holding at least newSize structures, create a new view VkHostImageCopyDevicePerformanceQuery.Ptr that uses the same backing storage as this VkHostImageCopyDevicePerformanceQuery.Ptr, but with the new size.
@NotNull VkHostImageLayoutTransitionInfo.Ptr	VkHostImageLayoutTransitionInfo.Ptr.reinterpret(long newSize)	Assume the VkHostImageLayoutTransitionInfo.Ptr is capable of holding at least newSize structures, create a new view VkHostImageLayoutTransitionInfo.Ptr that uses the same backing storage as this VkHostImageLayoutTransitionInfo.Ptr, but with the new size.
@NotNull VkImageAlignmentControlCreateInfoMESA.Ptr	VkImageAlignmentControlCreateInfoMESA.Ptr.reinterpret(long newSize)	Assume the VkImageAlignmentControlCreateInfoMESA.Ptr is capable of holding at least newSize structures, create a new view VkImageAlignmentControlCreateInfoMESA.Ptr that uses the same backing storage as this VkImageAlignmentControlCreateInfoMESA.Ptr, but with the new size.
@NotNull VkImageBlit.Ptr	VkImageBlit.Ptr.reinterpret(long newSize)	Assume the VkImageBlit.Ptr is capable of holding at least newSize structures, create a new view VkImageBlit.Ptr that uses the same backing storage as this VkImageBlit.Ptr, but with the new size.
@NotNull VkImageBlit2.Ptr	VkImageBlit2.Ptr.reinterpret(long newSize)	Assume the VkImageBlit2.Ptr is capable of holding at least newSize structures, create a new view VkImageBlit2.Ptr that uses the same backing storage as this VkImageBlit2.Ptr, but with the new size.
@NotNull VkImageCaptureDescriptorDataInfoEXT.Ptr	VkImageCaptureDescriptorDataInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkImageCaptureDescriptorDataInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkImageCaptureDescriptorDataInfoEXT.Ptr that uses the same backing storage as this VkImageCaptureDescriptorDataInfoEXT.Ptr, but with the new size.
@NotNull VkImageCompressionControlEXT.Ptr	VkImageCompressionControlEXT.Ptr.reinterpret(long newSize)	Assume the VkImageCompressionControlEXT.Ptr is capable of holding at least newSize structures, create a new view VkImageCompressionControlEXT.Ptr that uses the same backing storage as this VkImageCompressionControlEXT.Ptr, but with the new size.
@NotNull VkImageCompressionPropertiesEXT.Ptr	VkImageCompressionPropertiesEXT.Ptr.reinterpret(long newSize)	Assume the VkImageCompressionPropertiesEXT.Ptr is capable of holding at least newSize structures, create a new view VkImageCompressionPropertiesEXT.Ptr that uses the same backing storage as this VkImageCompressionPropertiesEXT.Ptr, but with the new size.
@NotNull VkImageConstraintsInfoFUCHSIA.Ptr	VkImageConstraintsInfoFUCHSIA.Ptr.reinterpret(long newSize)	Assume the VkImageConstraintsInfoFUCHSIA.Ptr is capable of holding at least newSize structures, create a new view VkImageConstraintsInfoFUCHSIA.Ptr that uses the same backing storage as this VkImageConstraintsInfoFUCHSIA.Ptr, but with the new size.
@NotNull VkImageCopy.Ptr	VkImageCopy.Ptr.reinterpret(long newSize)	Assume the VkImageCopy.Ptr is capable of holding at least newSize structures, create a new view VkImageCopy.Ptr that uses the same backing storage as this VkImageCopy.Ptr, but with the new size.
@NotNull VkImageCopy2.Ptr	VkImageCopy2.Ptr.reinterpret(long newSize)	Assume the VkImageCopy2.Ptr is capable of holding at least newSize structures, create a new view VkImageCopy2.Ptr that uses the same backing storage as this VkImageCopy2.Ptr, but with the new size.
@NotNull VkImageCreateInfo.Ptr	VkImageCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkImageCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkImageCreateInfo.Ptr that uses the same backing storage as this VkImageCreateInfo.Ptr, but with the new size.
@NotNull VkImageDrmFormatModifierExplicitCreateInfoEXT.Ptr	VkImageDrmFormatModifierExplicitCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkImageDrmFormatModifierExplicitCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkImageDrmFormatModifierExplicitCreateInfoEXT.Ptr that uses the same backing storage as this VkImageDrmFormatModifierExplicitCreateInfoEXT.Ptr, but with the new size.
@NotNull VkImageDrmFormatModifierListCreateInfoEXT.Ptr	VkImageDrmFormatModifierListCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkImageDrmFormatModifierListCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkImageDrmFormatModifierListCreateInfoEXT.Ptr that uses the same backing storage as this VkImageDrmFormatModifierListCreateInfoEXT.Ptr, but with the new size.
@NotNull VkImageDrmFormatModifierPropertiesEXT.Ptr	VkImageDrmFormatModifierPropertiesEXT.Ptr.reinterpret(long newSize)	Assume the VkImageDrmFormatModifierPropertiesEXT.Ptr is capable of holding at least newSize structures, create a new view VkImageDrmFormatModifierPropertiesEXT.Ptr that uses the same backing storage as this VkImageDrmFormatModifierPropertiesEXT.Ptr, but with the new size.
@NotNull VkImageFormatConstraintsInfoFUCHSIA.Ptr	VkImageFormatConstraintsInfoFUCHSIA.Ptr.reinterpret(long newSize)	Assume the VkImageFormatConstraintsInfoFUCHSIA.Ptr is capable of holding at least newSize structures, create a new view VkImageFormatConstraintsInfoFUCHSIA.Ptr that uses the same backing storage as this VkImageFormatConstraintsInfoFUCHSIA.Ptr, but with the new size.
@NotNull VkImageFormatListCreateInfo.Ptr	VkImageFormatListCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkImageFormatListCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkImageFormatListCreateInfo.Ptr that uses the same backing storage as this VkImageFormatListCreateInfo.Ptr, but with the new size.
@NotNull VkImageFormatProperties.Ptr	VkImageFormatProperties.Ptr.reinterpret(long newSize)	Assume the VkImageFormatProperties.Ptr is capable of holding at least newSize structures, create a new view VkImageFormatProperties.Ptr that uses the same backing storage as this VkImageFormatProperties.Ptr, but with the new size.
@NotNull VkImageFormatProperties2.Ptr	VkImageFormatProperties2.Ptr.reinterpret(long newSize)	Assume the VkImageFormatProperties2.Ptr is capable of holding at least newSize structures, create a new view VkImageFormatProperties2.Ptr that uses the same backing storage as this VkImageFormatProperties2.Ptr, but with the new size.
@NotNull VkImageMemoryBarrier.Ptr	VkImageMemoryBarrier.Ptr.reinterpret(long newSize)	Assume the VkImageMemoryBarrier.Ptr is capable of holding at least newSize structures, create a new view VkImageMemoryBarrier.Ptr that uses the same backing storage as this VkImageMemoryBarrier.Ptr, but with the new size.
@NotNull VkImageMemoryBarrier2.Ptr	VkImageMemoryBarrier2.Ptr.reinterpret(long newSize)	Assume the VkImageMemoryBarrier2.Ptr is capable of holding at least newSize structures, create a new view VkImageMemoryBarrier2.Ptr that uses the same backing storage as this VkImageMemoryBarrier2.Ptr, but with the new size.
@NotNull VkImageMemoryRequirementsInfo2.Ptr	VkImageMemoryRequirementsInfo2.Ptr.reinterpret(long newSize)	Assume the VkImageMemoryRequirementsInfo2.Ptr is capable of holding at least newSize structures, create a new view VkImageMemoryRequirementsInfo2.Ptr that uses the same backing storage as this VkImageMemoryRequirementsInfo2.Ptr, but with the new size.
@NotNull VkImagePipeSurfaceCreateInfoFUCHSIA.Ptr	VkImagePipeSurfaceCreateInfoFUCHSIA.Ptr.reinterpret(long newSize)	Assume the VkImagePipeSurfaceCreateInfoFUCHSIA.Ptr is capable of holding at least newSize structures, create a new view VkImagePipeSurfaceCreateInfoFUCHSIA.Ptr that uses the same backing storage as this VkImagePipeSurfaceCreateInfoFUCHSIA.Ptr, but with the new size.
@NotNull VkImagePlaneMemoryRequirementsInfo.Ptr	VkImagePlaneMemoryRequirementsInfo.Ptr.reinterpret(long newSize)	Assume the VkImagePlaneMemoryRequirementsInfo.Ptr is capable of holding at least newSize structures, create a new view VkImagePlaneMemoryRequirementsInfo.Ptr that uses the same backing storage as this VkImagePlaneMemoryRequirementsInfo.Ptr, but with the new size.
@NotNull VkImageResolve.Ptr	VkImageResolve.Ptr.reinterpret(long newSize)	Assume the VkImageResolve.Ptr is capable of holding at least newSize structures, create a new view VkImageResolve.Ptr that uses the same backing storage as this VkImageResolve.Ptr, but with the new size.
@NotNull VkImageResolve2.Ptr	VkImageResolve2.Ptr.reinterpret(long newSize)	Assume the VkImageResolve2.Ptr is capable of holding at least newSize structures, create a new view VkImageResolve2.Ptr that uses the same backing storage as this VkImageResolve2.Ptr, but with the new size.
@NotNull VkImageSparseMemoryRequirementsInfo2.Ptr	VkImageSparseMemoryRequirementsInfo2.Ptr.reinterpret(long newSize)	Assume the VkImageSparseMemoryRequirementsInfo2.Ptr is capable of holding at least newSize structures, create a new view VkImageSparseMemoryRequirementsInfo2.Ptr that uses the same backing storage as this VkImageSparseMemoryRequirementsInfo2.Ptr, but with the new size.
@NotNull VkImageStencilUsageCreateInfo.Ptr	VkImageStencilUsageCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkImageStencilUsageCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkImageStencilUsageCreateInfo.Ptr that uses the same backing storage as this VkImageStencilUsageCreateInfo.Ptr, but with the new size.
@NotNull VkImageSubresource.Ptr	VkImageSubresource.Ptr.reinterpret(long newSize)	Assume the VkImageSubresource.Ptr is capable of holding at least newSize structures, create a new view VkImageSubresource.Ptr that uses the same backing storage as this VkImageSubresource.Ptr, but with the new size.
@NotNull VkImageSubresource2.Ptr	VkImageSubresource2.Ptr.reinterpret(long newSize)	Assume the VkImageSubresource2.Ptr is capable of holding at least newSize structures, create a new view VkImageSubresource2.Ptr that uses the same backing storage as this VkImageSubresource2.Ptr, but with the new size.
@NotNull VkImageSubresourceLayers.Ptr	VkImageSubresourceLayers.Ptr.reinterpret(long newSize)	Assume the VkImageSubresourceLayers.Ptr is capable of holding at least newSize structures, create a new view VkImageSubresourceLayers.Ptr that uses the same backing storage as this VkImageSubresourceLayers.Ptr, but with the new size.
@NotNull VkImageSubresourceRange.Ptr	VkImageSubresourceRange.Ptr.reinterpret(long newSize)	Assume the VkImageSubresourceRange.Ptr is capable of holding at least newSize structures, create a new view VkImageSubresourceRange.Ptr that uses the same backing storage as this VkImageSubresourceRange.Ptr, but with the new size.
@NotNull VkImageSwapchainCreateInfoKHR.Ptr	VkImageSwapchainCreateInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkImageSwapchainCreateInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkImageSwapchainCreateInfoKHR.Ptr that uses the same backing storage as this VkImageSwapchainCreateInfoKHR.Ptr, but with the new size.
@NotNull VkImageToMemoryCopy.Ptr	VkImageToMemoryCopy.Ptr.reinterpret(long newSize)	Assume the VkImageToMemoryCopy.Ptr is capable of holding at least newSize structures, create a new view VkImageToMemoryCopy.Ptr that uses the same backing storage as this VkImageToMemoryCopy.Ptr, but with the new size.
@NotNull VkImageViewAddressPropertiesNVX.Ptr	VkImageViewAddressPropertiesNVX.Ptr.reinterpret(long newSize)	Assume the VkImageViewAddressPropertiesNVX.Ptr is capable of holding at least newSize structures, create a new view VkImageViewAddressPropertiesNVX.Ptr that uses the same backing storage as this VkImageViewAddressPropertiesNVX.Ptr, but with the new size.
@NotNull VkImageViewASTCDecodeModeEXT.Ptr	VkImageViewASTCDecodeModeEXT.Ptr.reinterpret(long newSize)	Assume the VkImageViewASTCDecodeModeEXT.Ptr is capable of holding at least newSize structures, create a new view VkImageViewASTCDecodeModeEXT.Ptr that uses the same backing storage as this VkImageViewASTCDecodeModeEXT.Ptr, but with the new size.
@NotNull VkImageViewCaptureDescriptorDataInfoEXT.Ptr	VkImageViewCaptureDescriptorDataInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkImageViewCaptureDescriptorDataInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkImageViewCaptureDescriptorDataInfoEXT.Ptr that uses the same backing storage as this VkImageViewCaptureDescriptorDataInfoEXT.Ptr, but with the new size.
@NotNull VkImageViewCreateInfo.Ptr	VkImageViewCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkImageViewCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkImageViewCreateInfo.Ptr that uses the same backing storage as this VkImageViewCreateInfo.Ptr, but with the new size.
@NotNull VkImageViewHandleInfoNVX.Ptr	VkImageViewHandleInfoNVX.Ptr.reinterpret(long newSize)	Assume the VkImageViewHandleInfoNVX.Ptr is capable of holding at least newSize structures, create a new view VkImageViewHandleInfoNVX.Ptr that uses the same backing storage as this VkImageViewHandleInfoNVX.Ptr, but with the new size.
@NotNull VkImageViewMinLodCreateInfoEXT.Ptr	VkImageViewMinLodCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkImageViewMinLodCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkImageViewMinLodCreateInfoEXT.Ptr that uses the same backing storage as this VkImageViewMinLodCreateInfoEXT.Ptr, but with the new size.
@NotNull VkImageViewSampleWeightCreateInfoQCOM.Ptr	VkImageViewSampleWeightCreateInfoQCOM.Ptr.reinterpret(long newSize)	Assume the VkImageViewSampleWeightCreateInfoQCOM.Ptr is capable of holding at least newSize structures, create a new view VkImageViewSampleWeightCreateInfoQCOM.Ptr that uses the same backing storage as this VkImageViewSampleWeightCreateInfoQCOM.Ptr, but with the new size.
@NotNull VkImageViewSlicedCreateInfoEXT.Ptr	VkImageViewSlicedCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkImageViewSlicedCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkImageViewSlicedCreateInfoEXT.Ptr that uses the same backing storage as this VkImageViewSlicedCreateInfoEXT.Ptr, but with the new size.
@NotNull VkImageViewUsageCreateInfo.Ptr	VkImageViewUsageCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkImageViewUsageCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkImageViewUsageCreateInfo.Ptr that uses the same backing storage as this VkImageViewUsageCreateInfo.Ptr, but with the new size.
@NotNull VkImportAndroidHardwareBufferInfoANDROID.Ptr	VkImportAndroidHardwareBufferInfoANDROID.Ptr.reinterpret(long newSize)	Assume the VkImportAndroidHardwareBufferInfoANDROID.Ptr is capable of holding at least newSize structures, create a new view VkImportAndroidHardwareBufferInfoANDROID.Ptr that uses the same backing storage as this VkImportAndroidHardwareBufferInfoANDROID.Ptr, but with the new size.
@NotNull VkImportFenceFdInfoKHR.Ptr	VkImportFenceFdInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkImportFenceFdInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkImportFenceFdInfoKHR.Ptr that uses the same backing storage as this VkImportFenceFdInfoKHR.Ptr, but with the new size.
@NotNull VkImportFenceSciSyncInfoNV.Ptr	VkImportFenceSciSyncInfoNV.Ptr.reinterpret(long newSize)	Assume the VkImportFenceSciSyncInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkImportFenceSciSyncInfoNV.Ptr that uses the same backing storage as this VkImportFenceSciSyncInfoNV.Ptr, but with the new size.
@NotNull VkImportFenceWin32HandleInfoKHR.Ptr	VkImportFenceWin32HandleInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkImportFenceWin32HandleInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkImportFenceWin32HandleInfoKHR.Ptr that uses the same backing storage as this VkImportFenceWin32HandleInfoKHR.Ptr, but with the new size.
@NotNull VkImportMemoryBufferCollectionFUCHSIA.Ptr	VkImportMemoryBufferCollectionFUCHSIA.Ptr.reinterpret(long newSize)	Assume the VkImportMemoryBufferCollectionFUCHSIA.Ptr is capable of holding at least newSize structures, create a new view VkImportMemoryBufferCollectionFUCHSIA.Ptr that uses the same backing storage as this VkImportMemoryBufferCollectionFUCHSIA.Ptr, but with the new size.
@NotNull VkImportMemoryFdInfoKHR.Ptr	VkImportMemoryFdInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkImportMemoryFdInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkImportMemoryFdInfoKHR.Ptr that uses the same backing storage as this VkImportMemoryFdInfoKHR.Ptr, but with the new size.
@NotNull VkImportMemoryHostPointerInfoEXT.Ptr	VkImportMemoryHostPointerInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkImportMemoryHostPointerInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkImportMemoryHostPointerInfoEXT.Ptr that uses the same backing storage as this VkImportMemoryHostPointerInfoEXT.Ptr, but with the new size.
@NotNull VkImportMemoryMetalHandleInfoEXT.Ptr	VkImportMemoryMetalHandleInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkImportMemoryMetalHandleInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkImportMemoryMetalHandleInfoEXT.Ptr that uses the same backing storage as this VkImportMemoryMetalHandleInfoEXT.Ptr, but with the new size.
@NotNull VkImportMemorySciBufInfoNV.Ptr	VkImportMemorySciBufInfoNV.Ptr.reinterpret(long newSize)	Assume the VkImportMemorySciBufInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkImportMemorySciBufInfoNV.Ptr that uses the same backing storage as this VkImportMemorySciBufInfoNV.Ptr, but with the new size.
@NotNull VkImportMemoryWin32HandleInfoKHR.Ptr	VkImportMemoryWin32HandleInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkImportMemoryWin32HandleInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkImportMemoryWin32HandleInfoKHR.Ptr that uses the same backing storage as this VkImportMemoryWin32HandleInfoKHR.Ptr, but with the new size.
@NotNull VkImportMemoryWin32HandleInfoNV.Ptr	VkImportMemoryWin32HandleInfoNV.Ptr.reinterpret(long newSize)	Assume the VkImportMemoryWin32HandleInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkImportMemoryWin32HandleInfoNV.Ptr that uses the same backing storage as this VkImportMemoryWin32HandleInfoNV.Ptr, but with the new size.
@NotNull VkImportMemoryZirconHandleInfoFUCHSIA.Ptr	VkImportMemoryZirconHandleInfoFUCHSIA.Ptr.reinterpret(long newSize)	Assume the VkImportMemoryZirconHandleInfoFUCHSIA.Ptr is capable of holding at least newSize structures, create a new view VkImportMemoryZirconHandleInfoFUCHSIA.Ptr that uses the same backing storage as this VkImportMemoryZirconHandleInfoFUCHSIA.Ptr, but with the new size.
@NotNull VkImportMetalBufferInfoEXT.Ptr	VkImportMetalBufferInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkImportMetalBufferInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkImportMetalBufferInfoEXT.Ptr that uses the same backing storage as this VkImportMetalBufferInfoEXT.Ptr, but with the new size.
@NotNull VkImportMetalIOSurfaceInfoEXT.Ptr	VkImportMetalIOSurfaceInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkImportMetalIOSurfaceInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkImportMetalIOSurfaceInfoEXT.Ptr that uses the same backing storage as this VkImportMetalIOSurfaceInfoEXT.Ptr, but with the new size.
@NotNull VkImportMetalSharedEventInfoEXT.Ptr	VkImportMetalSharedEventInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkImportMetalSharedEventInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkImportMetalSharedEventInfoEXT.Ptr that uses the same backing storage as this VkImportMetalSharedEventInfoEXT.Ptr, but with the new size.
@NotNull VkImportMetalTextureInfoEXT.Ptr	VkImportMetalTextureInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkImportMetalTextureInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkImportMetalTextureInfoEXT.Ptr that uses the same backing storage as this VkImportMetalTextureInfoEXT.Ptr, but with the new size.
@NotNull VkImportScreenBufferInfoQNX.Ptr	VkImportScreenBufferInfoQNX.Ptr.reinterpret(long newSize)	Assume the VkImportScreenBufferInfoQNX.Ptr is capable of holding at least newSize structures, create a new view VkImportScreenBufferInfoQNX.Ptr that uses the same backing storage as this VkImportScreenBufferInfoQNX.Ptr, but with the new size.
@NotNull VkImportSemaphoreFdInfoKHR.Ptr	VkImportSemaphoreFdInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkImportSemaphoreFdInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkImportSemaphoreFdInfoKHR.Ptr that uses the same backing storage as this VkImportSemaphoreFdInfoKHR.Ptr, but with the new size.
@NotNull VkImportSemaphoreSciSyncInfoNV.Ptr	VkImportSemaphoreSciSyncInfoNV.Ptr.reinterpret(long newSize)	Assume the VkImportSemaphoreSciSyncInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkImportSemaphoreSciSyncInfoNV.Ptr that uses the same backing storage as this VkImportSemaphoreSciSyncInfoNV.Ptr, but with the new size.
@NotNull VkImportSemaphoreWin32HandleInfoKHR.Ptr	VkImportSemaphoreWin32HandleInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkImportSemaphoreWin32HandleInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkImportSemaphoreWin32HandleInfoKHR.Ptr that uses the same backing storage as this VkImportSemaphoreWin32HandleInfoKHR.Ptr, but with the new size.
@NotNull VkImportSemaphoreZirconHandleInfoFUCHSIA.Ptr	VkImportSemaphoreZirconHandleInfoFUCHSIA.Ptr.reinterpret(long newSize)	Assume the VkImportSemaphoreZirconHandleInfoFUCHSIA.Ptr is capable of holding at least newSize structures, create a new view VkImportSemaphoreZirconHandleInfoFUCHSIA.Ptr that uses the same backing storage as this VkImportSemaphoreZirconHandleInfoFUCHSIA.Ptr, but with the new size.
@NotNull VkIndirectCommandsExecutionSetTokenEXT.Ptr	VkIndirectCommandsExecutionSetTokenEXT.Ptr.reinterpret(long newSize)	Assume the VkIndirectCommandsExecutionSetTokenEXT.Ptr is capable of holding at least newSize structures, create a new view VkIndirectCommandsExecutionSetTokenEXT.Ptr that uses the same backing storage as this VkIndirectCommandsExecutionSetTokenEXT.Ptr, but with the new size.
@NotNull VkIndirectCommandsIndexBufferTokenEXT.Ptr	VkIndirectCommandsIndexBufferTokenEXT.Ptr.reinterpret(long newSize)	Assume the VkIndirectCommandsIndexBufferTokenEXT.Ptr is capable of holding at least newSize structures, create a new view VkIndirectCommandsIndexBufferTokenEXT.Ptr that uses the same backing storage as this VkIndirectCommandsIndexBufferTokenEXT.Ptr, but with the new size.
@NotNull VkIndirectCommandsLayoutCreateInfoEXT.Ptr	VkIndirectCommandsLayoutCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkIndirectCommandsLayoutCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkIndirectCommandsLayoutCreateInfoEXT.Ptr that uses the same backing storage as this VkIndirectCommandsLayoutCreateInfoEXT.Ptr, but with the new size.
@NotNull VkIndirectCommandsLayoutCreateInfoNV.Ptr	VkIndirectCommandsLayoutCreateInfoNV.Ptr.reinterpret(long newSize)	Assume the VkIndirectCommandsLayoutCreateInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkIndirectCommandsLayoutCreateInfoNV.Ptr that uses the same backing storage as this VkIndirectCommandsLayoutCreateInfoNV.Ptr, but with the new size.
@NotNull VkIndirectCommandsLayoutTokenEXT.Ptr	VkIndirectCommandsLayoutTokenEXT.Ptr.reinterpret(long newSize)	Assume the VkIndirectCommandsLayoutTokenEXT.Ptr is capable of holding at least newSize structures, create a new view VkIndirectCommandsLayoutTokenEXT.Ptr that uses the same backing storage as this VkIndirectCommandsLayoutTokenEXT.Ptr, but with the new size.
@NotNull VkIndirectCommandsLayoutTokenNV.Ptr	VkIndirectCommandsLayoutTokenNV.Ptr.reinterpret(long newSize)	Assume the VkIndirectCommandsLayoutTokenNV.Ptr is capable of holding at least newSize structures, create a new view VkIndirectCommandsLayoutTokenNV.Ptr that uses the same backing storage as this VkIndirectCommandsLayoutTokenNV.Ptr, but with the new size.
@NotNull VkIndirectCommandsPushConstantTokenEXT.Ptr	VkIndirectCommandsPushConstantTokenEXT.Ptr.reinterpret(long newSize)	Assume the VkIndirectCommandsPushConstantTokenEXT.Ptr is capable of holding at least newSize structures, create a new view VkIndirectCommandsPushConstantTokenEXT.Ptr that uses the same backing storage as this VkIndirectCommandsPushConstantTokenEXT.Ptr, but with the new size.
@NotNull VkIndirectCommandsStreamNV.Ptr	VkIndirectCommandsStreamNV.Ptr.reinterpret(long newSize)	Assume the VkIndirectCommandsStreamNV.Ptr is capable of holding at least newSize structures, create a new view VkIndirectCommandsStreamNV.Ptr that uses the same backing storage as this VkIndirectCommandsStreamNV.Ptr, but with the new size.
@NotNull VkIndirectCommandsTokenDataEXT.Ptr	VkIndirectCommandsTokenDataEXT.Ptr.reinterpret(long newSize)	Assume the VkIndirectCommandsTokenDataEXT.Ptr is capable of holding at least newSize structures, create a new view VkIndirectCommandsTokenDataEXT.Ptr that uses the same backing storage as this VkIndirectCommandsTokenDataEXT.Ptr, but with the new size.
@NotNull VkIndirectCommandsVertexBufferTokenEXT.Ptr	VkIndirectCommandsVertexBufferTokenEXT.Ptr.reinterpret(long newSize)	Assume the VkIndirectCommandsVertexBufferTokenEXT.Ptr is capable of holding at least newSize structures, create a new view VkIndirectCommandsVertexBufferTokenEXT.Ptr that uses the same backing storage as this VkIndirectCommandsVertexBufferTokenEXT.Ptr, but with the new size.
@NotNull VkIndirectExecutionSetCreateInfoEXT.Ptr	VkIndirectExecutionSetCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkIndirectExecutionSetCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkIndirectExecutionSetCreateInfoEXT.Ptr that uses the same backing storage as this VkIndirectExecutionSetCreateInfoEXT.Ptr, but with the new size.
@NotNull VkIndirectExecutionSetInfoEXT.Ptr	VkIndirectExecutionSetInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkIndirectExecutionSetInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkIndirectExecutionSetInfoEXT.Ptr that uses the same backing storage as this VkIndirectExecutionSetInfoEXT.Ptr, but with the new size.
@NotNull VkIndirectExecutionSetPipelineInfoEXT.Ptr	VkIndirectExecutionSetPipelineInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkIndirectExecutionSetPipelineInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkIndirectExecutionSetPipelineInfoEXT.Ptr that uses the same backing storage as this VkIndirectExecutionSetPipelineInfoEXT.Ptr, but with the new size.
@NotNull VkIndirectExecutionSetShaderInfoEXT.Ptr	VkIndirectExecutionSetShaderInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkIndirectExecutionSetShaderInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkIndirectExecutionSetShaderInfoEXT.Ptr that uses the same backing storage as this VkIndirectExecutionSetShaderInfoEXT.Ptr, but with the new size.
@NotNull VkIndirectExecutionSetShaderLayoutInfoEXT.Ptr	VkIndirectExecutionSetShaderLayoutInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkIndirectExecutionSetShaderLayoutInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkIndirectExecutionSetShaderLayoutInfoEXT.Ptr that uses the same backing storage as this VkIndirectExecutionSetShaderLayoutInfoEXT.Ptr, but with the new size.
@NotNull VkInitializePerformanceApiInfoINTEL.Ptr	VkInitializePerformanceApiInfoINTEL.Ptr.reinterpret(long newSize)	Assume the VkInitializePerformanceApiInfoINTEL.Ptr is capable of holding at least newSize structures, create a new view VkInitializePerformanceApiInfoINTEL.Ptr that uses the same backing storage as this VkInitializePerformanceApiInfoINTEL.Ptr, but with the new size.
@NotNull VkInputAttachmentAspectReference.Ptr	VkInputAttachmentAspectReference.Ptr.reinterpret(long newSize)	Assume the VkInputAttachmentAspectReference.Ptr is capable of holding at least newSize structures, create a new view VkInputAttachmentAspectReference.Ptr that uses the same backing storage as this VkInputAttachmentAspectReference.Ptr, but with the new size.
@NotNull VkInstanceCreateInfo.Ptr	VkInstanceCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkInstanceCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkInstanceCreateInfo.Ptr that uses the same backing storage as this VkInstanceCreateInfo.Ptr, but with the new size.
@NotNull VkIOSSurfaceCreateInfoMVK.Ptr	VkIOSSurfaceCreateInfoMVK.Ptr.reinterpret(long newSize)	Assume the VkIOSSurfaceCreateInfoMVK.Ptr is capable of holding at least newSize structures, create a new view VkIOSSurfaceCreateInfoMVK.Ptr that uses the same backing storage as this VkIOSSurfaceCreateInfoMVK.Ptr, but with the new size.
@NotNull VkLatencySleepInfoNV.Ptr	VkLatencySleepInfoNV.Ptr.reinterpret(long newSize)	Assume the VkLatencySleepInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkLatencySleepInfoNV.Ptr that uses the same backing storage as this VkLatencySleepInfoNV.Ptr, but with the new size.
@NotNull VkLatencySleepModeInfoNV.Ptr	VkLatencySleepModeInfoNV.Ptr.reinterpret(long newSize)	Assume the VkLatencySleepModeInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkLatencySleepModeInfoNV.Ptr that uses the same backing storage as this VkLatencySleepModeInfoNV.Ptr, but with the new size.
@NotNull VkLatencySubmissionPresentIdNV.Ptr	VkLatencySubmissionPresentIdNV.Ptr.reinterpret(long newSize)	Assume the VkLatencySubmissionPresentIdNV.Ptr is capable of holding at least newSize structures, create a new view VkLatencySubmissionPresentIdNV.Ptr that uses the same backing storage as this VkLatencySubmissionPresentIdNV.Ptr, but with the new size.
@NotNull VkLatencySurfaceCapabilitiesNV.Ptr	VkLatencySurfaceCapabilitiesNV.Ptr.reinterpret(long newSize)	Assume the VkLatencySurfaceCapabilitiesNV.Ptr is capable of holding at least newSize structures, create a new view VkLatencySurfaceCapabilitiesNV.Ptr that uses the same backing storage as this VkLatencySurfaceCapabilitiesNV.Ptr, but with the new size.
@NotNull VkLatencyTimingsFrameReportNV.Ptr	VkLatencyTimingsFrameReportNV.Ptr.reinterpret(long newSize)	Assume the VkLatencyTimingsFrameReportNV.Ptr is capable of holding at least newSize structures, create a new view VkLatencyTimingsFrameReportNV.Ptr that uses the same backing storage as this VkLatencyTimingsFrameReportNV.Ptr, but with the new size.
@NotNull VkLayerProperties.Ptr	VkLayerProperties.Ptr.reinterpret(long newSize)	Assume the VkLayerProperties.Ptr is capable of holding at least newSize structures, create a new view VkLayerProperties.Ptr that uses the same backing storage as this VkLayerProperties.Ptr, but with the new size.
@NotNull VkLayerSettingEXT.Ptr	VkLayerSettingEXT.Ptr.reinterpret(long newSize)	Assume the VkLayerSettingEXT.Ptr is capable of holding at least newSize structures, create a new view VkLayerSettingEXT.Ptr that uses the same backing storage as this VkLayerSettingEXT.Ptr, but with the new size.
@NotNull VkLayerSettingsCreateInfoEXT.Ptr	VkLayerSettingsCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkLayerSettingsCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkLayerSettingsCreateInfoEXT.Ptr that uses the same backing storage as this VkLayerSettingsCreateInfoEXT.Ptr, but with the new size.
@NotNull VkMacOSSurfaceCreateInfoMVK.Ptr	VkMacOSSurfaceCreateInfoMVK.Ptr.reinterpret(long newSize)	Assume the VkMacOSSurfaceCreateInfoMVK.Ptr is capable of holding at least newSize structures, create a new view VkMacOSSurfaceCreateInfoMVK.Ptr that uses the same backing storage as this VkMacOSSurfaceCreateInfoMVK.Ptr, but with the new size.
@NotNull VkMappedMemoryRange.Ptr	VkMappedMemoryRange.Ptr.reinterpret(long newSize)	Assume the VkMappedMemoryRange.Ptr is capable of holding at least newSize structures, create a new view VkMappedMemoryRange.Ptr that uses the same backing storage as this VkMappedMemoryRange.Ptr, but with the new size.
@NotNull VkMemoryAllocateFlagsInfo.Ptr	VkMemoryAllocateFlagsInfo.Ptr.reinterpret(long newSize)	Assume the VkMemoryAllocateFlagsInfo.Ptr is capable of holding at least newSize structures, create a new view VkMemoryAllocateFlagsInfo.Ptr that uses the same backing storage as this VkMemoryAllocateFlagsInfo.Ptr, but with the new size.
@NotNull VkMemoryAllocateInfo.Ptr	VkMemoryAllocateInfo.Ptr.reinterpret(long newSize)	Assume the VkMemoryAllocateInfo.Ptr is capable of holding at least newSize structures, create a new view VkMemoryAllocateInfo.Ptr that uses the same backing storage as this VkMemoryAllocateInfo.Ptr, but with the new size.
@NotNull VkMemoryBarrier.Ptr	VkMemoryBarrier.Ptr.reinterpret(long newSize)	Assume the VkMemoryBarrier.Ptr is capable of holding at least newSize structures, create a new view VkMemoryBarrier.Ptr that uses the same backing storage as this VkMemoryBarrier.Ptr, but with the new size.
@NotNull VkMemoryBarrier2.Ptr	VkMemoryBarrier2.Ptr.reinterpret(long newSize)	Assume the VkMemoryBarrier2.Ptr is capable of holding at least newSize structures, create a new view VkMemoryBarrier2.Ptr that uses the same backing storage as this VkMemoryBarrier2.Ptr, but with the new size.
@NotNull VkMemoryBarrierAccessFlags3KHR.Ptr	VkMemoryBarrierAccessFlags3KHR.Ptr.reinterpret(long newSize)	Assume the VkMemoryBarrierAccessFlags3KHR.Ptr is capable of holding at least newSize structures, create a new view VkMemoryBarrierAccessFlags3KHR.Ptr that uses the same backing storage as this VkMemoryBarrierAccessFlags3KHR.Ptr, but with the new size.
@NotNull VkMemoryDedicatedAllocateInfo.Ptr	VkMemoryDedicatedAllocateInfo.Ptr.reinterpret(long newSize)	Assume the VkMemoryDedicatedAllocateInfo.Ptr is capable of holding at least newSize structures, create a new view VkMemoryDedicatedAllocateInfo.Ptr that uses the same backing storage as this VkMemoryDedicatedAllocateInfo.Ptr, but with the new size.
@NotNull VkMemoryDedicatedRequirements.Ptr	VkMemoryDedicatedRequirements.Ptr.reinterpret(long newSize)	Assume the VkMemoryDedicatedRequirements.Ptr is capable of holding at least newSize structures, create a new view VkMemoryDedicatedRequirements.Ptr that uses the same backing storage as this VkMemoryDedicatedRequirements.Ptr, but with the new size.
@NotNull VkMemoryFdPropertiesKHR.Ptr	VkMemoryFdPropertiesKHR.Ptr.reinterpret(long newSize)	Assume the VkMemoryFdPropertiesKHR.Ptr is capable of holding at least newSize structures, create a new view VkMemoryFdPropertiesKHR.Ptr that uses the same backing storage as this VkMemoryFdPropertiesKHR.Ptr, but with the new size.
@NotNull VkMemoryGetAndroidHardwareBufferInfoANDROID.Ptr	VkMemoryGetAndroidHardwareBufferInfoANDROID.Ptr.reinterpret(long newSize)	Assume the VkMemoryGetAndroidHardwareBufferInfoANDROID.Ptr is capable of holding at least newSize structures, create a new view VkMemoryGetAndroidHardwareBufferInfoANDROID.Ptr that uses the same backing storage as this VkMemoryGetAndroidHardwareBufferInfoANDROID.Ptr, but with the new size.
@NotNull VkMemoryGetFdInfoKHR.Ptr	VkMemoryGetFdInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkMemoryGetFdInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkMemoryGetFdInfoKHR.Ptr that uses the same backing storage as this VkMemoryGetFdInfoKHR.Ptr, but with the new size.
@NotNull VkMemoryGetMetalHandleInfoEXT.Ptr	VkMemoryGetMetalHandleInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkMemoryGetMetalHandleInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkMemoryGetMetalHandleInfoEXT.Ptr that uses the same backing storage as this VkMemoryGetMetalHandleInfoEXT.Ptr, but with the new size.
@NotNull VkMemoryGetRemoteAddressInfoNV.Ptr	VkMemoryGetRemoteAddressInfoNV.Ptr.reinterpret(long newSize)	Assume the VkMemoryGetRemoteAddressInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkMemoryGetRemoteAddressInfoNV.Ptr that uses the same backing storage as this VkMemoryGetRemoteAddressInfoNV.Ptr, but with the new size.
@NotNull VkMemoryGetSciBufInfoNV.Ptr	VkMemoryGetSciBufInfoNV.Ptr.reinterpret(long newSize)	Assume the VkMemoryGetSciBufInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkMemoryGetSciBufInfoNV.Ptr that uses the same backing storage as this VkMemoryGetSciBufInfoNV.Ptr, but with the new size.
@NotNull VkMemoryGetWin32HandleInfoKHR.Ptr	VkMemoryGetWin32HandleInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkMemoryGetWin32HandleInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkMemoryGetWin32HandleInfoKHR.Ptr that uses the same backing storage as this VkMemoryGetWin32HandleInfoKHR.Ptr, but with the new size.
@NotNull VkMemoryGetZirconHandleInfoFUCHSIA.Ptr	VkMemoryGetZirconHandleInfoFUCHSIA.Ptr.reinterpret(long newSize)	Assume the VkMemoryGetZirconHandleInfoFUCHSIA.Ptr is capable of holding at least newSize structures, create a new view VkMemoryGetZirconHandleInfoFUCHSIA.Ptr that uses the same backing storage as this VkMemoryGetZirconHandleInfoFUCHSIA.Ptr, but with the new size.
@NotNull VkMemoryHeap.Ptr	VkMemoryHeap.Ptr.reinterpret(long newSize)	Assume the VkMemoryHeap.Ptr is capable of holding at least newSize structures, create a new view VkMemoryHeap.Ptr that uses the same backing storage as this VkMemoryHeap.Ptr, but with the new size.
@NotNull VkMemoryHostPointerPropertiesEXT.Ptr	VkMemoryHostPointerPropertiesEXT.Ptr.reinterpret(long newSize)	Assume the VkMemoryHostPointerPropertiesEXT.Ptr is capable of holding at least newSize structures, create a new view VkMemoryHostPointerPropertiesEXT.Ptr that uses the same backing storage as this VkMemoryHostPointerPropertiesEXT.Ptr, but with the new size.
@NotNull VkMemoryMapInfo.Ptr	VkMemoryMapInfo.Ptr.reinterpret(long newSize)	Assume the VkMemoryMapInfo.Ptr is capable of holding at least newSize structures, create a new view VkMemoryMapInfo.Ptr that uses the same backing storage as this VkMemoryMapInfo.Ptr, but with the new size.
@NotNull VkMemoryMapPlacedInfoEXT.Ptr	VkMemoryMapPlacedInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkMemoryMapPlacedInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkMemoryMapPlacedInfoEXT.Ptr that uses the same backing storage as this VkMemoryMapPlacedInfoEXT.Ptr, but with the new size.
@NotNull VkMemoryMetalHandlePropertiesEXT.Ptr	VkMemoryMetalHandlePropertiesEXT.Ptr.reinterpret(long newSize)	Assume the VkMemoryMetalHandlePropertiesEXT.Ptr is capable of holding at least newSize structures, create a new view VkMemoryMetalHandlePropertiesEXT.Ptr that uses the same backing storage as this VkMemoryMetalHandlePropertiesEXT.Ptr, but with the new size.
@NotNull VkMemoryOpaqueCaptureAddressAllocateInfo.Ptr	VkMemoryOpaqueCaptureAddressAllocateInfo.Ptr.reinterpret(long newSize)	Assume the VkMemoryOpaqueCaptureAddressAllocateInfo.Ptr is capable of holding at least newSize structures, create a new view VkMemoryOpaqueCaptureAddressAllocateInfo.Ptr that uses the same backing storage as this VkMemoryOpaqueCaptureAddressAllocateInfo.Ptr, but with the new size.
@NotNull VkMemoryPriorityAllocateInfoEXT.Ptr	VkMemoryPriorityAllocateInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkMemoryPriorityAllocateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkMemoryPriorityAllocateInfoEXT.Ptr that uses the same backing storage as this VkMemoryPriorityAllocateInfoEXT.Ptr, but with the new size.
@NotNull VkMemoryRequirements.Ptr	VkMemoryRequirements.Ptr.reinterpret(long newSize)	Assume the VkMemoryRequirements.Ptr is capable of holding at least newSize structures, create a new view VkMemoryRequirements.Ptr that uses the same backing storage as this VkMemoryRequirements.Ptr, but with the new size.
@NotNull VkMemoryRequirements2.Ptr	VkMemoryRequirements2.Ptr.reinterpret(long newSize)	Assume the VkMemoryRequirements2.Ptr is capable of holding at least newSize structures, create a new view VkMemoryRequirements2.Ptr that uses the same backing storage as this VkMemoryRequirements2.Ptr, but with the new size.
@NotNull VkMemorySciBufPropertiesNV.Ptr	VkMemorySciBufPropertiesNV.Ptr.reinterpret(long newSize)	Assume the VkMemorySciBufPropertiesNV.Ptr is capable of holding at least newSize structures, create a new view VkMemorySciBufPropertiesNV.Ptr that uses the same backing storage as this VkMemorySciBufPropertiesNV.Ptr, but with the new size.
@NotNull VkMemoryToImageCopy.Ptr	VkMemoryToImageCopy.Ptr.reinterpret(long newSize)	Assume the VkMemoryToImageCopy.Ptr is capable of holding at least newSize structures, create a new view VkMemoryToImageCopy.Ptr that uses the same backing storage as this VkMemoryToImageCopy.Ptr, but with the new size.
@NotNull VkMemoryType.Ptr	VkMemoryType.Ptr.reinterpret(long newSize)	Assume the VkMemoryType.Ptr is capable of holding at least newSize structures, create a new view VkMemoryType.Ptr that uses the same backing storage as this VkMemoryType.Ptr, but with the new size.
@NotNull VkMemoryUnmapInfo.Ptr	VkMemoryUnmapInfo.Ptr.reinterpret(long newSize)	Assume the VkMemoryUnmapInfo.Ptr is capable of holding at least newSize structures, create a new view VkMemoryUnmapInfo.Ptr that uses the same backing storage as this VkMemoryUnmapInfo.Ptr, but with the new size.
@NotNull VkMemoryWin32HandlePropertiesKHR.Ptr	VkMemoryWin32HandlePropertiesKHR.Ptr.reinterpret(long newSize)	Assume the VkMemoryWin32HandlePropertiesKHR.Ptr is capable of holding at least newSize structures, create a new view VkMemoryWin32HandlePropertiesKHR.Ptr that uses the same backing storage as this VkMemoryWin32HandlePropertiesKHR.Ptr, but with the new size.
@NotNull VkMemoryZirconHandlePropertiesFUCHSIA.Ptr	VkMemoryZirconHandlePropertiesFUCHSIA.Ptr.reinterpret(long newSize)	Assume the VkMemoryZirconHandlePropertiesFUCHSIA.Ptr is capable of holding at least newSize structures, create a new view VkMemoryZirconHandlePropertiesFUCHSIA.Ptr that uses the same backing storage as this VkMemoryZirconHandlePropertiesFUCHSIA.Ptr, but with the new size.
@NotNull VkMetalSurfaceCreateInfoEXT.Ptr	VkMetalSurfaceCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkMetalSurfaceCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkMetalSurfaceCreateInfoEXT.Ptr that uses the same backing storage as this VkMetalSurfaceCreateInfoEXT.Ptr, but with the new size.
@NotNull VkMicromapBuildInfoEXT.Ptr	VkMicromapBuildInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkMicromapBuildInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkMicromapBuildInfoEXT.Ptr that uses the same backing storage as this VkMicromapBuildInfoEXT.Ptr, but with the new size.
@NotNull VkMicromapBuildSizesInfoEXT.Ptr	VkMicromapBuildSizesInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkMicromapBuildSizesInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkMicromapBuildSizesInfoEXT.Ptr that uses the same backing storage as this VkMicromapBuildSizesInfoEXT.Ptr, but with the new size.
@NotNull VkMicromapCreateInfoEXT.Ptr	VkMicromapCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkMicromapCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkMicromapCreateInfoEXT.Ptr that uses the same backing storage as this VkMicromapCreateInfoEXT.Ptr, but with the new size.
@NotNull VkMicromapTriangleEXT.Ptr	VkMicromapTriangleEXT.Ptr.reinterpret(long newSize)	Assume the VkMicromapTriangleEXT.Ptr is capable of holding at least newSize structures, create a new view VkMicromapTriangleEXT.Ptr that uses the same backing storage as this VkMicromapTriangleEXT.Ptr, but with the new size.
@NotNull VkMicromapUsageEXT.Ptr	VkMicromapUsageEXT.Ptr.reinterpret(long newSize)	Assume the VkMicromapUsageEXT.Ptr is capable of holding at least newSize structures, create a new view VkMicromapUsageEXT.Ptr that uses the same backing storage as this VkMicromapUsageEXT.Ptr, but with the new size.
@NotNull VkMicromapVersionInfoEXT.Ptr	VkMicromapVersionInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkMicromapVersionInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkMicromapVersionInfoEXT.Ptr that uses the same backing storage as this VkMicromapVersionInfoEXT.Ptr, but with the new size.
@NotNull VkMultiDrawIndexedInfoEXT.Ptr	VkMultiDrawIndexedInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkMultiDrawIndexedInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkMultiDrawIndexedInfoEXT.Ptr that uses the same backing storage as this VkMultiDrawIndexedInfoEXT.Ptr, but with the new size.
@NotNull VkMultiDrawInfoEXT.Ptr	VkMultiDrawInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkMultiDrawInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkMultiDrawInfoEXT.Ptr that uses the same backing storage as this VkMultiDrawInfoEXT.Ptr, but with the new size.
@NotNull VkMultisampledRenderToSingleSampledInfoEXT.Ptr	VkMultisampledRenderToSingleSampledInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkMultisampledRenderToSingleSampledInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkMultisampledRenderToSingleSampledInfoEXT.Ptr that uses the same backing storage as this VkMultisampledRenderToSingleSampledInfoEXT.Ptr, but with the new size.
@NotNull VkMultisamplePropertiesEXT.Ptr	VkMultisamplePropertiesEXT.Ptr.reinterpret(long newSize)	Assume the VkMultisamplePropertiesEXT.Ptr is capable of holding at least newSize structures, create a new view VkMultisamplePropertiesEXT.Ptr that uses the same backing storage as this VkMultisamplePropertiesEXT.Ptr, but with the new size.
@NotNull VkMultiviewPerViewAttributesInfoNVX.Ptr	VkMultiviewPerViewAttributesInfoNVX.Ptr.reinterpret(long newSize)	Assume the VkMultiviewPerViewAttributesInfoNVX.Ptr is capable of holding at least newSize structures, create a new view VkMultiviewPerViewAttributesInfoNVX.Ptr that uses the same backing storage as this VkMultiviewPerViewAttributesInfoNVX.Ptr, but with the new size.
@NotNull VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM.Ptr	VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM.Ptr.reinterpret(long newSize)	Assume the VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM.Ptr is capable of holding at least newSize structures, create a new view VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM.Ptr that uses the same backing storage as this VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM.Ptr, but with the new size.
@NotNull VkMutableDescriptorTypeCreateInfoEXT.Ptr	VkMutableDescriptorTypeCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkMutableDescriptorTypeCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkMutableDescriptorTypeCreateInfoEXT.Ptr that uses the same backing storage as this VkMutableDescriptorTypeCreateInfoEXT.Ptr, but with the new size.
@NotNull VkMutableDescriptorTypeListEXT.Ptr	VkMutableDescriptorTypeListEXT.Ptr.reinterpret(long newSize)	Assume the VkMutableDescriptorTypeListEXT.Ptr is capable of holding at least newSize structures, create a new view VkMutableDescriptorTypeListEXT.Ptr that uses the same backing storage as this VkMutableDescriptorTypeListEXT.Ptr, but with the new size.
@NotNull VkOffset2D.Ptr	VkOffset2D.Ptr.reinterpret(long newSize)	Assume the VkOffset2D.Ptr is capable of holding at least newSize structures, create a new view VkOffset2D.Ptr that uses the same backing storage as this VkOffset2D.Ptr, but with the new size.
@NotNull VkOffset3D.Ptr	VkOffset3D.Ptr.reinterpret(long newSize)	Assume the VkOffset3D.Ptr is capable of holding at least newSize structures, create a new view VkOffset3D.Ptr that uses the same backing storage as this VkOffset3D.Ptr, but with the new size.
@NotNull VkOpaqueCaptureDescriptorDataCreateInfoEXT.Ptr	VkOpaqueCaptureDescriptorDataCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkOpaqueCaptureDescriptorDataCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkOpaqueCaptureDescriptorDataCreateInfoEXT.Ptr that uses the same backing storage as this VkOpaqueCaptureDescriptorDataCreateInfoEXT.Ptr, but with the new size.
@NotNull VkOpticalFlowExecuteInfoNV.Ptr	VkOpticalFlowExecuteInfoNV.Ptr.reinterpret(long newSize)	Assume the VkOpticalFlowExecuteInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkOpticalFlowExecuteInfoNV.Ptr that uses the same backing storage as this VkOpticalFlowExecuteInfoNV.Ptr, but with the new size.
@NotNull VkOpticalFlowImageFormatInfoNV.Ptr	VkOpticalFlowImageFormatInfoNV.Ptr.reinterpret(long newSize)	Assume the VkOpticalFlowImageFormatInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkOpticalFlowImageFormatInfoNV.Ptr that uses the same backing storage as this VkOpticalFlowImageFormatInfoNV.Ptr, but with the new size.
@NotNull VkOpticalFlowImageFormatPropertiesNV.Ptr	VkOpticalFlowImageFormatPropertiesNV.Ptr.reinterpret(long newSize)	Assume the VkOpticalFlowImageFormatPropertiesNV.Ptr is capable of holding at least newSize structures, create a new view VkOpticalFlowImageFormatPropertiesNV.Ptr that uses the same backing storage as this VkOpticalFlowImageFormatPropertiesNV.Ptr, but with the new size.
@NotNull VkOpticalFlowSessionCreateInfoNV.Ptr	VkOpticalFlowSessionCreateInfoNV.Ptr.reinterpret(long newSize)	Assume the VkOpticalFlowSessionCreateInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkOpticalFlowSessionCreateInfoNV.Ptr that uses the same backing storage as this VkOpticalFlowSessionCreateInfoNV.Ptr, but with the new size.
@NotNull VkOpticalFlowSessionCreatePrivateDataInfoNV.Ptr	VkOpticalFlowSessionCreatePrivateDataInfoNV.Ptr.reinterpret(long newSize)	Assume the VkOpticalFlowSessionCreatePrivateDataInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkOpticalFlowSessionCreatePrivateDataInfoNV.Ptr that uses the same backing storage as this VkOpticalFlowSessionCreatePrivateDataInfoNV.Ptr, but with the new size.
@NotNull VkOutOfBandQueueTypeInfoNV.Ptr	VkOutOfBandQueueTypeInfoNV.Ptr.reinterpret(long newSize)	Assume the VkOutOfBandQueueTypeInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkOutOfBandQueueTypeInfoNV.Ptr that uses the same backing storage as this VkOutOfBandQueueTypeInfoNV.Ptr, but with the new size.
@NotNull VkPartitionedAccelerationStructureFlagsNV.Ptr	VkPartitionedAccelerationStructureFlagsNV.Ptr.reinterpret(long newSize)	Assume the VkPartitionedAccelerationStructureFlagsNV.Ptr is capable of holding at least newSize structures, create a new view VkPartitionedAccelerationStructureFlagsNV.Ptr that uses the same backing storage as this VkPartitionedAccelerationStructureFlagsNV.Ptr, but with the new size.
@NotNull VkPartitionedAccelerationStructureInstancesInputNV.Ptr	VkPartitionedAccelerationStructureInstancesInputNV.Ptr.reinterpret(long newSize)	Assume the VkPartitionedAccelerationStructureInstancesInputNV.Ptr is capable of holding at least newSize structures, create a new view VkPartitionedAccelerationStructureInstancesInputNV.Ptr that uses the same backing storage as this VkPartitionedAccelerationStructureInstancesInputNV.Ptr, but with the new size.
@NotNull VkPartitionedAccelerationStructureUpdateInstanceDataNV.Ptr	VkPartitionedAccelerationStructureUpdateInstanceDataNV.Ptr.reinterpret(long newSize)	Assume the VkPartitionedAccelerationStructureUpdateInstanceDataNV.Ptr is capable of holding at least newSize structures, create a new view VkPartitionedAccelerationStructureUpdateInstanceDataNV.Ptr that uses the same backing storage as this VkPartitionedAccelerationStructureUpdateInstanceDataNV.Ptr, but with the new size.
@NotNull VkPartitionedAccelerationStructureWriteInstanceDataNV.Ptr	VkPartitionedAccelerationStructureWriteInstanceDataNV.Ptr.reinterpret(long newSize)	Assume the VkPartitionedAccelerationStructureWriteInstanceDataNV.Ptr is capable of holding at least newSize structures, create a new view VkPartitionedAccelerationStructureWriteInstanceDataNV.Ptr that uses the same backing storage as this VkPartitionedAccelerationStructureWriteInstanceDataNV.Ptr, but with the new size.
@NotNull VkPartitionedAccelerationStructureWritePartitionTranslationDataNV.Ptr	VkPartitionedAccelerationStructureWritePartitionTranslationDataNV.Ptr.reinterpret(long newSize)	Assume the VkPartitionedAccelerationStructureWritePartitionTranslationDataNV.Ptr is capable of holding at least newSize structures, create a new view VkPartitionedAccelerationStructureWritePartitionTranslationDataNV.Ptr that uses the same backing storage as this VkPartitionedAccelerationStructureWritePartitionTranslationDataNV.Ptr, but with the new size.
@NotNull VkPastPresentationTimingGOOGLE.Ptr	VkPastPresentationTimingGOOGLE.Ptr.reinterpret(long newSize)	Assume the VkPastPresentationTimingGOOGLE.Ptr is capable of holding at least newSize structures, create a new view VkPastPresentationTimingGOOGLE.Ptr that uses the same backing storage as this VkPastPresentationTimingGOOGLE.Ptr, but with the new size.
@NotNull VkPerformanceConfigurationAcquireInfoINTEL.Ptr	VkPerformanceConfigurationAcquireInfoINTEL.Ptr.reinterpret(long newSize)	Assume the VkPerformanceConfigurationAcquireInfoINTEL.Ptr is capable of holding at least newSize structures, create a new view VkPerformanceConfigurationAcquireInfoINTEL.Ptr that uses the same backing storage as this VkPerformanceConfigurationAcquireInfoINTEL.Ptr, but with the new size.
@NotNull VkPerformanceCounterDescriptionKHR.Ptr	VkPerformanceCounterDescriptionKHR.Ptr.reinterpret(long newSize)	Assume the VkPerformanceCounterDescriptionKHR.Ptr is capable of holding at least newSize structures, create a new view VkPerformanceCounterDescriptionKHR.Ptr that uses the same backing storage as this VkPerformanceCounterDescriptionKHR.Ptr, but with the new size.
@NotNull VkPerformanceCounterKHR.Ptr	VkPerformanceCounterKHR.Ptr.reinterpret(long newSize)	Assume the VkPerformanceCounterKHR.Ptr is capable of holding at least newSize structures, create a new view VkPerformanceCounterKHR.Ptr that uses the same backing storage as this VkPerformanceCounterKHR.Ptr, but with the new size.
@NotNull VkPerformanceCounterResultKHR.Ptr	VkPerformanceCounterResultKHR.Ptr.reinterpret(long newSize)	Assume the VkPerformanceCounterResultKHR.Ptr is capable of holding at least newSize structures, create a new view VkPerformanceCounterResultKHR.Ptr that uses the same backing storage as this VkPerformanceCounterResultKHR.Ptr, but with the new size.
@NotNull VkPerformanceMarkerInfoINTEL.Ptr	VkPerformanceMarkerInfoINTEL.Ptr.reinterpret(long newSize)	Assume the VkPerformanceMarkerInfoINTEL.Ptr is capable of holding at least newSize structures, create a new view VkPerformanceMarkerInfoINTEL.Ptr that uses the same backing storage as this VkPerformanceMarkerInfoINTEL.Ptr, but with the new size.
@NotNull VkPerformanceOverrideInfoINTEL.Ptr	VkPerformanceOverrideInfoINTEL.Ptr.reinterpret(long newSize)	Assume the VkPerformanceOverrideInfoINTEL.Ptr is capable of holding at least newSize structures, create a new view VkPerformanceOverrideInfoINTEL.Ptr that uses the same backing storage as this VkPerformanceOverrideInfoINTEL.Ptr, but with the new size.
@NotNull VkPerformanceQueryReservationInfoKHR.Ptr	VkPerformanceQueryReservationInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkPerformanceQueryReservationInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkPerformanceQueryReservationInfoKHR.Ptr that uses the same backing storage as this VkPerformanceQueryReservationInfoKHR.Ptr, but with the new size.
@NotNull VkPerformanceQuerySubmitInfoKHR.Ptr	VkPerformanceQuerySubmitInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkPerformanceQuerySubmitInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkPerformanceQuerySubmitInfoKHR.Ptr that uses the same backing storage as this VkPerformanceQuerySubmitInfoKHR.Ptr, but with the new size.
@NotNull VkPerformanceStreamMarkerInfoINTEL.Ptr	VkPerformanceStreamMarkerInfoINTEL.Ptr.reinterpret(long newSize)	Assume the VkPerformanceStreamMarkerInfoINTEL.Ptr is capable of holding at least newSize structures, create a new view VkPerformanceStreamMarkerInfoINTEL.Ptr that uses the same backing storage as this VkPerformanceStreamMarkerInfoINTEL.Ptr, but with the new size.
@NotNull VkPerformanceValueDataINTEL.Ptr	VkPerformanceValueDataINTEL.Ptr.reinterpret(long newSize)	Assume the VkPerformanceValueDataINTEL.Ptr is capable of holding at least newSize structures, create a new view VkPerformanceValueDataINTEL.Ptr that uses the same backing storage as this VkPerformanceValueDataINTEL.Ptr, but with the new size.
@NotNull VkPerformanceValueINTEL.Ptr	VkPerformanceValueINTEL.Ptr.reinterpret(long newSize)	Assume the VkPerformanceValueINTEL.Ptr is capable of holding at least newSize structures, create a new view VkPerformanceValueINTEL.Ptr that uses the same backing storage as this VkPerformanceValueINTEL.Ptr, but with the new size.
@NotNull VkPerTileBeginInfoQCOM.Ptr	VkPerTileBeginInfoQCOM.Ptr.reinterpret(long newSize)	Assume the VkPerTileBeginInfoQCOM.Ptr is capable of holding at least newSize structures, create a new view VkPerTileBeginInfoQCOM.Ptr that uses the same backing storage as this VkPerTileBeginInfoQCOM.Ptr, but with the new size.
@NotNull VkPerTileEndInfoQCOM.Ptr	VkPerTileEndInfoQCOM.Ptr.reinterpret(long newSize)	Assume the VkPerTileEndInfoQCOM.Ptr is capable of holding at least newSize structures, create a new view VkPerTileEndInfoQCOM.Ptr that uses the same backing storage as this VkPerTileEndInfoQCOM.Ptr, but with the new size.
@NotNull VkPhysicalDevice16BitStorageFeatures.Ptr	VkPhysicalDevice16BitStorageFeatures.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDevice16BitStorageFeatures.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDevice16BitStorageFeatures.Ptr that uses the same backing storage as this VkPhysicalDevice16BitStorageFeatures.Ptr, but with the new size.
@NotNull VkPhysicalDevice4444FormatsFeaturesEXT.Ptr	VkPhysicalDevice4444FormatsFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDevice4444FormatsFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDevice4444FormatsFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDevice4444FormatsFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDevice8BitStorageFeatures.Ptr	VkPhysicalDevice8BitStorageFeatures.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDevice8BitStorageFeatures.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDevice8BitStorageFeatures.Ptr that uses the same backing storage as this VkPhysicalDevice8BitStorageFeatures.Ptr, but with the new size.
@NotNull VkPhysicalDeviceAccelerationStructureFeaturesKHR.Ptr	VkPhysicalDeviceAccelerationStructureFeaturesKHR.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceAccelerationStructureFeaturesKHR.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceAccelerationStructureFeaturesKHR.Ptr that uses the same backing storage as this VkPhysicalDeviceAccelerationStructureFeaturesKHR.Ptr, but with the new size.
@NotNull VkPhysicalDeviceAccelerationStructurePropertiesKHR.Ptr	VkPhysicalDeviceAccelerationStructurePropertiesKHR.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceAccelerationStructurePropertiesKHR.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceAccelerationStructurePropertiesKHR.Ptr that uses the same backing storage as this VkPhysicalDeviceAccelerationStructurePropertiesKHR.Ptr, but with the new size.
@NotNull VkPhysicalDeviceAddressBindingReportFeaturesEXT.Ptr	VkPhysicalDeviceAddressBindingReportFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceAddressBindingReportFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceAddressBindingReportFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceAddressBindingReportFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceAmigoProfilingFeaturesSEC.Ptr	VkPhysicalDeviceAmigoProfilingFeaturesSEC.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceAmigoProfilingFeaturesSEC.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceAmigoProfilingFeaturesSEC.Ptr that uses the same backing storage as this VkPhysicalDeviceAmigoProfilingFeaturesSEC.Ptr, but with the new size.
@NotNull VkPhysicalDeviceAntiLagFeaturesAMD.Ptr	VkPhysicalDeviceAntiLagFeaturesAMD.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceAntiLagFeaturesAMD.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceAntiLagFeaturesAMD.Ptr that uses the same backing storage as this VkPhysicalDeviceAntiLagFeaturesAMD.Ptr, but with the new size.
@NotNull VkPhysicalDeviceASTCDecodeFeaturesEXT.Ptr	VkPhysicalDeviceASTCDecodeFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceASTCDecodeFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceASTCDecodeFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceASTCDecodeFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT.Ptr	VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.Ptr	VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT.Ptr	VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT.Ptr	VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceBorderColorSwizzleFeaturesEXT.Ptr	VkPhysicalDeviceBorderColorSwizzleFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceBorderColorSwizzleFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceBorderColorSwizzleFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceBorderColorSwizzleFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceBufferDeviceAddressFeatures.Ptr	VkPhysicalDeviceBufferDeviceAddressFeatures.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceBufferDeviceAddressFeatures.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceBufferDeviceAddressFeatures.Ptr that uses the same backing storage as this VkPhysicalDeviceBufferDeviceAddressFeatures.Ptr, but with the new size.
@NotNull VkPhysicalDeviceBufferDeviceAddressFeaturesEXT.Ptr	VkPhysicalDeviceBufferDeviceAddressFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceBufferDeviceAddressFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceBufferDeviceAddressFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceBufferDeviceAddressFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceClusterAccelerationStructureFeaturesNV.Ptr	VkPhysicalDeviceClusterAccelerationStructureFeaturesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceClusterAccelerationStructureFeaturesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceClusterAccelerationStructureFeaturesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceClusterAccelerationStructureFeaturesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceClusterAccelerationStructurePropertiesNV.Ptr	VkPhysicalDeviceClusterAccelerationStructurePropertiesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceClusterAccelerationStructurePropertiesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceClusterAccelerationStructurePropertiesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceClusterAccelerationStructurePropertiesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI.Ptr	VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI.Ptr that uses the same backing storage as this VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI.Ptr, but with the new size.
@NotNull VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI.Ptr	VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI.Ptr that uses the same backing storage as this VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI.Ptr, but with the new size.
@NotNull VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI.Ptr	VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI.Ptr that uses the same backing storage as this VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI.Ptr, but with the new size.
@NotNull VkPhysicalDeviceCoherentMemoryFeaturesAMD.Ptr	VkPhysicalDeviceCoherentMemoryFeaturesAMD.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceCoherentMemoryFeaturesAMD.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceCoherentMemoryFeaturesAMD.Ptr that uses the same backing storage as this VkPhysicalDeviceCoherentMemoryFeaturesAMD.Ptr, but with the new size.
@NotNull VkPhysicalDeviceColorWriteEnableFeaturesEXT.Ptr	VkPhysicalDeviceColorWriteEnableFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceColorWriteEnableFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceColorWriteEnableFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceColorWriteEnableFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceCommandBufferInheritanceFeaturesNV.Ptr	VkPhysicalDeviceCommandBufferInheritanceFeaturesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceCommandBufferInheritanceFeaturesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceCommandBufferInheritanceFeaturesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceCommandBufferInheritanceFeaturesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR.Ptr	VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR.Ptr that uses the same backing storage as this VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR.Ptr, but with the new size.
@NotNull VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR.Ptr	VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR.Ptr that uses the same backing storage as this VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR.Ptr, but with the new size.
@NotNull VkPhysicalDeviceConditionalRenderingFeaturesEXT.Ptr	VkPhysicalDeviceConditionalRenderingFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceConditionalRenderingFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceConditionalRenderingFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceConditionalRenderingFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceConservativeRasterizationPropertiesEXT.Ptr	VkPhysicalDeviceConservativeRasterizationPropertiesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceConservativeRasterizationPropertiesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceConservativeRasterizationPropertiesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceConservativeRasterizationPropertiesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceCooperativeMatrix2FeaturesNV.Ptr	VkPhysicalDeviceCooperativeMatrix2FeaturesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceCooperativeMatrix2FeaturesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceCooperativeMatrix2FeaturesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceCooperativeMatrix2FeaturesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceCooperativeMatrix2PropertiesNV.Ptr	VkPhysicalDeviceCooperativeMatrix2PropertiesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceCooperativeMatrix2PropertiesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceCooperativeMatrix2PropertiesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceCooperativeMatrix2PropertiesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceCooperativeMatrixFeaturesKHR.Ptr	VkPhysicalDeviceCooperativeMatrixFeaturesKHR.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceCooperativeMatrixFeaturesKHR.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceCooperativeMatrixFeaturesKHR.Ptr that uses the same backing storage as this VkPhysicalDeviceCooperativeMatrixFeaturesKHR.Ptr, but with the new size.
@NotNull VkPhysicalDeviceCooperativeMatrixFeaturesNV.Ptr	VkPhysicalDeviceCooperativeMatrixFeaturesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceCooperativeMatrixFeaturesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceCooperativeMatrixFeaturesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceCooperativeMatrixFeaturesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceCooperativeMatrixPropertiesKHR.Ptr	VkPhysicalDeviceCooperativeMatrixPropertiesKHR.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceCooperativeMatrixPropertiesKHR.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceCooperativeMatrixPropertiesKHR.Ptr that uses the same backing storage as this VkPhysicalDeviceCooperativeMatrixPropertiesKHR.Ptr, but with the new size.
@NotNull VkPhysicalDeviceCooperativeMatrixPropertiesNV.Ptr	VkPhysicalDeviceCooperativeMatrixPropertiesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceCooperativeMatrixPropertiesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceCooperativeMatrixPropertiesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceCooperativeMatrixPropertiesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceCooperativeVectorFeaturesNV.Ptr	VkPhysicalDeviceCooperativeVectorFeaturesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceCooperativeVectorFeaturesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceCooperativeVectorFeaturesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceCooperativeVectorFeaturesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceCooperativeVectorPropertiesNV.Ptr	VkPhysicalDeviceCooperativeVectorPropertiesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceCooperativeVectorPropertiesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceCooperativeVectorPropertiesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceCooperativeVectorPropertiesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceCopyMemoryIndirectFeaturesNV.Ptr	VkPhysicalDeviceCopyMemoryIndirectFeaturesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceCopyMemoryIndirectFeaturesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceCopyMemoryIndirectFeaturesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceCopyMemoryIndirectFeaturesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceCopyMemoryIndirectPropertiesNV.Ptr	VkPhysicalDeviceCopyMemoryIndirectPropertiesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceCopyMemoryIndirectPropertiesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceCopyMemoryIndirectPropertiesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceCopyMemoryIndirectPropertiesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceCornerSampledImageFeaturesNV.Ptr	VkPhysicalDeviceCornerSampledImageFeaturesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceCornerSampledImageFeaturesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceCornerSampledImageFeaturesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceCornerSampledImageFeaturesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceCoverageReductionModeFeaturesNV.Ptr	VkPhysicalDeviceCoverageReductionModeFeaturesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceCoverageReductionModeFeaturesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceCoverageReductionModeFeaturesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceCoverageReductionModeFeaturesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceCubicClampFeaturesQCOM.Ptr	VkPhysicalDeviceCubicClampFeaturesQCOM.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceCubicClampFeaturesQCOM.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceCubicClampFeaturesQCOM.Ptr that uses the same backing storage as this VkPhysicalDeviceCubicClampFeaturesQCOM.Ptr, but with the new size.
@NotNull VkPhysicalDeviceCubicWeightsFeaturesQCOM.Ptr	VkPhysicalDeviceCubicWeightsFeaturesQCOM.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceCubicWeightsFeaturesQCOM.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceCubicWeightsFeaturesQCOM.Ptr that uses the same backing storage as this VkPhysicalDeviceCubicWeightsFeaturesQCOM.Ptr, but with the new size.
@NotNull VkPhysicalDeviceCudaKernelLaunchFeaturesNV.Ptr	VkPhysicalDeviceCudaKernelLaunchFeaturesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceCudaKernelLaunchFeaturesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceCudaKernelLaunchFeaturesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceCudaKernelLaunchFeaturesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceCudaKernelLaunchPropertiesNV.Ptr	VkPhysicalDeviceCudaKernelLaunchPropertiesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceCudaKernelLaunchPropertiesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceCudaKernelLaunchPropertiesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceCudaKernelLaunchPropertiesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceCustomBorderColorFeaturesEXT.Ptr	VkPhysicalDeviceCustomBorderColorFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceCustomBorderColorFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceCustomBorderColorFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceCustomBorderColorFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceCustomBorderColorPropertiesEXT.Ptr	VkPhysicalDeviceCustomBorderColorPropertiesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceCustomBorderColorPropertiesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceCustomBorderColorPropertiesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceCustomBorderColorPropertiesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV.Ptr	VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceDepthBiasControlFeaturesEXT.Ptr	VkPhysicalDeviceDepthBiasControlFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceDepthBiasControlFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceDepthBiasControlFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceDepthBiasControlFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceDepthClampControlFeaturesEXT.Ptr	VkPhysicalDeviceDepthClampControlFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceDepthClampControlFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceDepthClampControlFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceDepthClampControlFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceDepthClampZeroOneFeaturesKHR.Ptr	VkPhysicalDeviceDepthClampZeroOneFeaturesKHR.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceDepthClampZeroOneFeaturesKHR.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceDepthClampZeroOneFeaturesKHR.Ptr that uses the same backing storage as this VkPhysicalDeviceDepthClampZeroOneFeaturesKHR.Ptr, but with the new size.
@NotNull VkPhysicalDeviceDepthClipControlFeaturesEXT.Ptr	VkPhysicalDeviceDepthClipControlFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceDepthClipControlFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceDepthClipControlFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceDepthClipControlFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceDepthClipEnableFeaturesEXT.Ptr	VkPhysicalDeviceDepthClipEnableFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceDepthClipEnableFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceDepthClipEnableFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceDepthClipEnableFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceDepthStencilResolveProperties.Ptr	VkPhysicalDeviceDepthStencilResolveProperties.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceDepthStencilResolveProperties.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceDepthStencilResolveProperties.Ptr that uses the same backing storage as this VkPhysicalDeviceDepthStencilResolveProperties.Ptr, but with the new size.
@NotNull VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT.Ptr	VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceDescriptorBufferFeaturesEXT.Ptr	VkPhysicalDeviceDescriptorBufferFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceDescriptorBufferFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceDescriptorBufferFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceDescriptorBufferFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceDescriptorBufferPropertiesEXT.Ptr	VkPhysicalDeviceDescriptorBufferPropertiesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceDescriptorBufferPropertiesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceDescriptorBufferPropertiesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceDescriptorBufferPropertiesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceDescriptorIndexingFeatures.Ptr	VkPhysicalDeviceDescriptorIndexingFeatures.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceDescriptorIndexingFeatures.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceDescriptorIndexingFeatures.Ptr that uses the same backing storage as this VkPhysicalDeviceDescriptorIndexingFeatures.Ptr, but with the new size.
@NotNull VkPhysicalDeviceDescriptorIndexingProperties.Ptr	VkPhysicalDeviceDescriptorIndexingProperties.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceDescriptorIndexingProperties.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceDescriptorIndexingProperties.Ptr that uses the same backing storage as this VkPhysicalDeviceDescriptorIndexingProperties.Ptr, but with the new size.
@NotNull VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV.Ptr	VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE.Ptr	VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE.Ptr that uses the same backing storage as this VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE.Ptr, but with the new size.
@NotNull VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.Ptr	VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT.Ptr	VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV.Ptr	VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT.Ptr	VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV.Ptr	VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceDeviceMemoryReportFeaturesEXT.Ptr	VkPhysicalDeviceDeviceMemoryReportFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceDeviceMemoryReportFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceDeviceMemoryReportFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceDeviceMemoryReportFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceDiagnosticsConfigFeaturesNV.Ptr	VkPhysicalDeviceDiagnosticsConfigFeaturesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceDiagnosticsConfigFeaturesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceDiagnosticsConfigFeaturesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceDiagnosticsConfigFeaturesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceDiscardRectanglePropertiesEXT.Ptr	VkPhysicalDeviceDiscardRectanglePropertiesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceDiscardRectanglePropertiesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceDiscardRectanglePropertiesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceDiscardRectanglePropertiesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceDisplacementMicromapFeaturesNV.Ptr	VkPhysicalDeviceDisplacementMicromapFeaturesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceDisplacementMicromapFeaturesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceDisplacementMicromapFeaturesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceDisplacementMicromapFeaturesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceDisplacementMicromapPropertiesNV.Ptr	VkPhysicalDeviceDisplacementMicromapPropertiesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceDisplacementMicromapPropertiesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceDisplacementMicromapPropertiesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceDisplacementMicromapPropertiesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceDriverProperties.Ptr	VkPhysicalDeviceDriverProperties.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceDriverProperties.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceDriverProperties.Ptr that uses the same backing storage as this VkPhysicalDeviceDriverProperties.Ptr, but with the new size.
@NotNull VkPhysicalDeviceDrmPropertiesEXT.Ptr	VkPhysicalDeviceDrmPropertiesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceDrmPropertiesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceDrmPropertiesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceDrmPropertiesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceDynamicRenderingFeatures.Ptr	VkPhysicalDeviceDynamicRenderingFeatures.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceDynamicRenderingFeatures.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceDynamicRenderingFeatures.Ptr that uses the same backing storage as this VkPhysicalDeviceDynamicRenderingFeatures.Ptr, but with the new size.
@NotNull VkPhysicalDeviceDynamicRenderingLocalReadFeatures.Ptr	VkPhysicalDeviceDynamicRenderingLocalReadFeatures.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceDynamicRenderingLocalReadFeatures.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceDynamicRenderingLocalReadFeatures.Ptr that uses the same backing storage as this VkPhysicalDeviceDynamicRenderingLocalReadFeatures.Ptr, but with the new size.
@NotNull VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT.Ptr	VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceExclusiveScissorFeaturesNV.Ptr	VkPhysicalDeviceExclusiveScissorFeaturesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceExclusiveScissorFeaturesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceExclusiveScissorFeaturesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceExclusiveScissorFeaturesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceExtendedDynamicState2FeaturesEXT.Ptr	VkPhysicalDeviceExtendedDynamicState2FeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceExtendedDynamicState2FeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceExtendedDynamicState2FeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceExtendedDynamicState2FeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.Ptr	VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceExtendedDynamicState3FeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceExtendedDynamicState3PropertiesEXT.Ptr	VkPhysicalDeviceExtendedDynamicState3PropertiesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceExtendedDynamicState3PropertiesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceExtendedDynamicState3PropertiesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceExtendedDynamicState3PropertiesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceExtendedDynamicStateFeaturesEXT.Ptr	VkPhysicalDeviceExtendedDynamicStateFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceExtendedDynamicStateFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceExtendedDynamicStateFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceExtendedDynamicStateFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV.Ptr	VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV.Ptr	VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceExternalBufferInfo.Ptr	VkPhysicalDeviceExternalBufferInfo.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceExternalBufferInfo.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceExternalBufferInfo.Ptr that uses the same backing storage as this VkPhysicalDeviceExternalBufferInfo.Ptr, but with the new size.
@NotNull VkPhysicalDeviceExternalComputeQueuePropertiesNV.Ptr	VkPhysicalDeviceExternalComputeQueuePropertiesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceExternalComputeQueuePropertiesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceExternalComputeQueuePropertiesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceExternalComputeQueuePropertiesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceExternalFenceInfo.Ptr	VkPhysicalDeviceExternalFenceInfo.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceExternalFenceInfo.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceExternalFenceInfo.Ptr that uses the same backing storage as this VkPhysicalDeviceExternalFenceInfo.Ptr, but with the new size.
@NotNull VkPhysicalDeviceExternalFormatResolveFeaturesANDROID.Ptr	VkPhysicalDeviceExternalFormatResolveFeaturesANDROID.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceExternalFormatResolveFeaturesANDROID.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceExternalFormatResolveFeaturesANDROID.Ptr that uses the same backing storage as this VkPhysicalDeviceExternalFormatResolveFeaturesANDROID.Ptr, but with the new size.
@NotNull VkPhysicalDeviceExternalFormatResolvePropertiesANDROID.Ptr	VkPhysicalDeviceExternalFormatResolvePropertiesANDROID.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceExternalFormatResolvePropertiesANDROID.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceExternalFormatResolvePropertiesANDROID.Ptr that uses the same backing storage as this VkPhysicalDeviceExternalFormatResolvePropertiesANDROID.Ptr, but with the new size.
@NotNull VkPhysicalDeviceExternalImageFormatInfo.Ptr	VkPhysicalDeviceExternalImageFormatInfo.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceExternalImageFormatInfo.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceExternalImageFormatInfo.Ptr that uses the same backing storage as this VkPhysicalDeviceExternalImageFormatInfo.Ptr, but with the new size.
@NotNull VkPhysicalDeviceExternalMemoryHostPropertiesEXT.Ptr	VkPhysicalDeviceExternalMemoryHostPropertiesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceExternalMemoryHostPropertiesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceExternalMemoryHostPropertiesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceExternalMemoryHostPropertiesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceExternalMemoryRDMAFeaturesNV.Ptr	VkPhysicalDeviceExternalMemoryRDMAFeaturesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceExternalMemoryRDMAFeaturesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceExternalMemoryRDMAFeaturesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceExternalMemoryRDMAFeaturesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceExternalMemorySciBufFeaturesNV.Ptr	VkPhysicalDeviceExternalMemorySciBufFeaturesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceExternalMemorySciBufFeaturesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceExternalMemorySciBufFeaturesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceExternalMemorySciBufFeaturesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX.Ptr	VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX.Ptr that uses the same backing storage as this VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX.Ptr, but with the new size.
@NotNull VkPhysicalDeviceExternalSciSync2FeaturesNV.Ptr	VkPhysicalDeviceExternalSciSync2FeaturesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceExternalSciSync2FeaturesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceExternalSciSync2FeaturesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceExternalSciSync2FeaturesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceExternalSciSyncFeaturesNV.Ptr	VkPhysicalDeviceExternalSciSyncFeaturesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceExternalSciSyncFeaturesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceExternalSciSyncFeaturesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceExternalSciSyncFeaturesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceExternalSemaphoreInfo.Ptr	VkPhysicalDeviceExternalSemaphoreInfo.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceExternalSemaphoreInfo.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceExternalSemaphoreInfo.Ptr that uses the same backing storage as this VkPhysicalDeviceExternalSemaphoreInfo.Ptr, but with the new size.
@NotNull VkPhysicalDeviceFaultFeaturesEXT.Ptr	VkPhysicalDeviceFaultFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceFaultFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceFaultFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceFaultFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceFeatures.Ptr	VkPhysicalDeviceFeatures.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceFeatures.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceFeatures.Ptr that uses the same backing storage as this VkPhysicalDeviceFeatures.Ptr, but with the new size.
@NotNull VkPhysicalDeviceFeatures2.Ptr	VkPhysicalDeviceFeatures2.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceFeatures2.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceFeatures2.Ptr that uses the same backing storage as this VkPhysicalDeviceFeatures2.Ptr, but with the new size.
@NotNull VkPhysicalDeviceFloatControlsProperties.Ptr	VkPhysicalDeviceFloatControlsProperties.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceFloatControlsProperties.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceFloatControlsProperties.Ptr that uses the same backing storage as this VkPhysicalDeviceFloatControlsProperties.Ptr, but with the new size.
@NotNull VkPhysicalDeviceFragmentDensityMap2FeaturesEXT.Ptr	VkPhysicalDeviceFragmentDensityMap2FeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceFragmentDensityMap2FeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceFragmentDensityMap2FeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceFragmentDensityMap2FeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceFragmentDensityMap2PropertiesEXT.Ptr	VkPhysicalDeviceFragmentDensityMap2PropertiesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceFragmentDensityMap2PropertiesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceFragmentDensityMap2PropertiesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceFragmentDensityMap2PropertiesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceFragmentDensityMapFeaturesEXT.Ptr	VkPhysicalDeviceFragmentDensityMapFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceFragmentDensityMapFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceFragmentDensityMapFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceFragmentDensityMapFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT.Ptr	VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT.Ptr	VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceFragmentDensityMapPropertiesEXT.Ptr	VkPhysicalDeviceFragmentDensityMapPropertiesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceFragmentDensityMapPropertiesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceFragmentDensityMapPropertiesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceFragmentDensityMapPropertiesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR.Ptr	VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR.Ptr that uses the same backing storage as this VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR.Ptr, but with the new size.
@NotNull VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR.Ptr	VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR.Ptr that uses the same backing storage as this VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR.Ptr, but with the new size.
@NotNull VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT.Ptr	VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV.Ptr	VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV.Ptr	VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceFragmentShadingRateFeaturesKHR.Ptr	VkPhysicalDeviceFragmentShadingRateFeaturesKHR.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceFragmentShadingRateFeaturesKHR.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceFragmentShadingRateFeaturesKHR.Ptr that uses the same backing storage as this VkPhysicalDeviceFragmentShadingRateFeaturesKHR.Ptr, but with the new size.
@NotNull VkPhysicalDeviceFragmentShadingRateKHR.Ptr	VkPhysicalDeviceFragmentShadingRateKHR.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceFragmentShadingRateKHR.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceFragmentShadingRateKHR.Ptr that uses the same backing storage as this VkPhysicalDeviceFragmentShadingRateKHR.Ptr, but with the new size.
@NotNull VkPhysicalDeviceFragmentShadingRatePropertiesKHR.Ptr	VkPhysicalDeviceFragmentShadingRatePropertiesKHR.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceFragmentShadingRatePropertiesKHR.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceFragmentShadingRatePropertiesKHR.Ptr that uses the same backing storage as this VkPhysicalDeviceFragmentShadingRatePropertiesKHR.Ptr, but with the new size.
@NotNull VkPhysicalDeviceFrameBoundaryFeaturesEXT.Ptr	VkPhysicalDeviceFrameBoundaryFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceFrameBoundaryFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceFrameBoundaryFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceFrameBoundaryFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceGlobalPriorityQueryFeatures.Ptr	VkPhysicalDeviceGlobalPriorityQueryFeatures.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceGlobalPriorityQueryFeatures.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceGlobalPriorityQueryFeatures.Ptr that uses the same backing storage as this VkPhysicalDeviceGlobalPriorityQueryFeatures.Ptr, but with the new size.
@NotNull VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT.Ptr	VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT.Ptr	VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceGroupProperties.Ptr	VkPhysicalDeviceGroupProperties.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceGroupProperties.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceGroupProperties.Ptr that uses the same backing storage as this VkPhysicalDeviceGroupProperties.Ptr, but with the new size.
@NotNull VkPhysicalDeviceHdrVividFeaturesHUAWEI.Ptr	VkPhysicalDeviceHdrVividFeaturesHUAWEI.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceHdrVividFeaturesHUAWEI.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceHdrVividFeaturesHUAWEI.Ptr that uses the same backing storage as this VkPhysicalDeviceHdrVividFeaturesHUAWEI.Ptr, but with the new size.
@NotNull VkPhysicalDeviceHostImageCopyFeatures.Ptr	VkPhysicalDeviceHostImageCopyFeatures.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceHostImageCopyFeatures.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceHostImageCopyFeatures.Ptr that uses the same backing storage as this VkPhysicalDeviceHostImageCopyFeatures.Ptr, but with the new size.
@NotNull VkPhysicalDeviceHostImageCopyProperties.Ptr	VkPhysicalDeviceHostImageCopyProperties.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceHostImageCopyProperties.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceHostImageCopyProperties.Ptr that uses the same backing storage as this VkPhysicalDeviceHostImageCopyProperties.Ptr, but with the new size.
@NotNull VkPhysicalDeviceHostQueryResetFeatures.Ptr	VkPhysicalDeviceHostQueryResetFeatures.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceHostQueryResetFeatures.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceHostQueryResetFeatures.Ptr that uses the same backing storage as this VkPhysicalDeviceHostQueryResetFeatures.Ptr, but with the new size.
@NotNull VkPhysicalDeviceIDProperties.Ptr	VkPhysicalDeviceIDProperties.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceIDProperties.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceIDProperties.Ptr that uses the same backing storage as this VkPhysicalDeviceIDProperties.Ptr, but with the new size.
@NotNull VkPhysicalDeviceImage2DViewOf3DFeaturesEXT.Ptr	VkPhysicalDeviceImage2DViewOf3DFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceImage2DViewOf3DFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceImage2DViewOf3DFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceImage2DViewOf3DFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceImageAlignmentControlFeaturesMESA.Ptr	VkPhysicalDeviceImageAlignmentControlFeaturesMESA.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceImageAlignmentControlFeaturesMESA.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceImageAlignmentControlFeaturesMESA.Ptr that uses the same backing storage as this VkPhysicalDeviceImageAlignmentControlFeaturesMESA.Ptr, but with the new size.
@NotNull VkPhysicalDeviceImageAlignmentControlPropertiesMESA.Ptr	VkPhysicalDeviceImageAlignmentControlPropertiesMESA.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceImageAlignmentControlPropertiesMESA.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceImageAlignmentControlPropertiesMESA.Ptr that uses the same backing storage as this VkPhysicalDeviceImageAlignmentControlPropertiesMESA.Ptr, but with the new size.
@NotNull VkPhysicalDeviceImageCompressionControlFeaturesEXT.Ptr	VkPhysicalDeviceImageCompressionControlFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceImageCompressionControlFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceImageCompressionControlFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceImageCompressionControlFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT.Ptr	VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceImageDrmFormatModifierInfoEXT.Ptr	VkPhysicalDeviceImageDrmFormatModifierInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceImageDrmFormatModifierInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceImageDrmFormatModifierInfoEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceImageDrmFormatModifierInfoEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceImageFormatInfo2.Ptr	VkPhysicalDeviceImageFormatInfo2.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceImageFormatInfo2.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceImageFormatInfo2.Ptr that uses the same backing storage as this VkPhysicalDeviceImageFormatInfo2.Ptr, but with the new size.
@NotNull VkPhysicalDeviceImagelessFramebufferFeatures.Ptr	VkPhysicalDeviceImagelessFramebufferFeatures.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceImagelessFramebufferFeatures.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceImagelessFramebufferFeatures.Ptr that uses the same backing storage as this VkPhysicalDeviceImagelessFramebufferFeatures.Ptr, but with the new size.
@NotNull VkPhysicalDeviceImageProcessing2FeaturesQCOM.Ptr	VkPhysicalDeviceImageProcessing2FeaturesQCOM.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceImageProcessing2FeaturesQCOM.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceImageProcessing2FeaturesQCOM.Ptr that uses the same backing storage as this VkPhysicalDeviceImageProcessing2FeaturesQCOM.Ptr, but with the new size.
@NotNull VkPhysicalDeviceImageProcessing2PropertiesQCOM.Ptr	VkPhysicalDeviceImageProcessing2PropertiesQCOM.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceImageProcessing2PropertiesQCOM.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceImageProcessing2PropertiesQCOM.Ptr that uses the same backing storage as this VkPhysicalDeviceImageProcessing2PropertiesQCOM.Ptr, but with the new size.
@NotNull VkPhysicalDeviceImageProcessingFeaturesQCOM.Ptr	VkPhysicalDeviceImageProcessingFeaturesQCOM.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceImageProcessingFeaturesQCOM.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceImageProcessingFeaturesQCOM.Ptr that uses the same backing storage as this VkPhysicalDeviceImageProcessingFeaturesQCOM.Ptr, but with the new size.
@NotNull VkPhysicalDeviceImageProcessingPropertiesQCOM.Ptr	VkPhysicalDeviceImageProcessingPropertiesQCOM.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceImageProcessingPropertiesQCOM.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceImageProcessingPropertiesQCOM.Ptr that uses the same backing storage as this VkPhysicalDeviceImageProcessingPropertiesQCOM.Ptr, but with the new size.
@NotNull VkPhysicalDeviceImageRobustnessFeatures.Ptr	VkPhysicalDeviceImageRobustnessFeatures.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceImageRobustnessFeatures.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceImageRobustnessFeatures.Ptr that uses the same backing storage as this VkPhysicalDeviceImageRobustnessFeatures.Ptr, but with the new size.
@NotNull VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT.Ptr	VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceImageViewImageFormatInfoEXT.Ptr	VkPhysicalDeviceImageViewImageFormatInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceImageViewImageFormatInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceImageViewImageFormatInfoEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceImageViewImageFormatInfoEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceImageViewMinLodFeaturesEXT.Ptr	VkPhysicalDeviceImageViewMinLodFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceImageViewMinLodFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceImageViewMinLodFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceImageViewMinLodFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceIndexTypeUint8Features.Ptr	VkPhysicalDeviceIndexTypeUint8Features.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceIndexTypeUint8Features.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceIndexTypeUint8Features.Ptr that uses the same backing storage as this VkPhysicalDeviceIndexTypeUint8Features.Ptr, but with the new size.
@NotNull VkPhysicalDeviceInheritedViewportScissorFeaturesNV.Ptr	VkPhysicalDeviceInheritedViewportScissorFeaturesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceInheritedViewportScissorFeaturesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceInheritedViewportScissorFeaturesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceInheritedViewportScissorFeaturesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceInlineUniformBlockFeatures.Ptr	VkPhysicalDeviceInlineUniformBlockFeatures.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceInlineUniformBlockFeatures.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceInlineUniformBlockFeatures.Ptr that uses the same backing storage as this VkPhysicalDeviceInlineUniformBlockFeatures.Ptr, but with the new size.
@NotNull VkPhysicalDeviceInlineUniformBlockProperties.Ptr	VkPhysicalDeviceInlineUniformBlockProperties.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceInlineUniformBlockProperties.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceInlineUniformBlockProperties.Ptr that uses the same backing storage as this VkPhysicalDeviceInlineUniformBlockProperties.Ptr, but with the new size.
@NotNull VkPhysicalDeviceInvocationMaskFeaturesHUAWEI.Ptr	VkPhysicalDeviceInvocationMaskFeaturesHUAWEI.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceInvocationMaskFeaturesHUAWEI.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceInvocationMaskFeaturesHUAWEI.Ptr that uses the same backing storage as this VkPhysicalDeviceInvocationMaskFeaturesHUAWEI.Ptr, but with the new size.
@NotNull VkPhysicalDeviceLayeredApiPropertiesKHR.Ptr	VkPhysicalDeviceLayeredApiPropertiesKHR.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceLayeredApiPropertiesKHR.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceLayeredApiPropertiesKHR.Ptr that uses the same backing storage as this VkPhysicalDeviceLayeredApiPropertiesKHR.Ptr, but with the new size.
@NotNull VkPhysicalDeviceLayeredApiPropertiesListKHR.Ptr	VkPhysicalDeviceLayeredApiPropertiesListKHR.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceLayeredApiPropertiesListKHR.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceLayeredApiPropertiesListKHR.Ptr that uses the same backing storage as this VkPhysicalDeviceLayeredApiPropertiesListKHR.Ptr, but with the new size.
@NotNull VkPhysicalDeviceLayeredApiVulkanPropertiesKHR.Ptr	VkPhysicalDeviceLayeredApiVulkanPropertiesKHR.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceLayeredApiVulkanPropertiesKHR.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceLayeredApiVulkanPropertiesKHR.Ptr that uses the same backing storage as this VkPhysicalDeviceLayeredApiVulkanPropertiesKHR.Ptr, but with the new size.
@NotNull VkPhysicalDeviceLayeredDriverPropertiesMSFT.Ptr	VkPhysicalDeviceLayeredDriverPropertiesMSFT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceLayeredDriverPropertiesMSFT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceLayeredDriverPropertiesMSFT.Ptr that uses the same backing storage as this VkPhysicalDeviceLayeredDriverPropertiesMSFT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceLegacyDitheringFeaturesEXT.Ptr	VkPhysicalDeviceLegacyDitheringFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceLegacyDitheringFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceLegacyDitheringFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceLegacyDitheringFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT.Ptr	VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT.Ptr	VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceLimits.Ptr	VkPhysicalDeviceLimits.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceLimits.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceLimits.Ptr that uses the same backing storage as this VkPhysicalDeviceLimits.Ptr, but with the new size.
@NotNull VkPhysicalDeviceLinearColorAttachmentFeaturesNV.Ptr	VkPhysicalDeviceLinearColorAttachmentFeaturesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceLinearColorAttachmentFeaturesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceLinearColorAttachmentFeaturesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceLinearColorAttachmentFeaturesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceLineRasterizationFeatures.Ptr	VkPhysicalDeviceLineRasterizationFeatures.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceLineRasterizationFeatures.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceLineRasterizationFeatures.Ptr that uses the same backing storage as this VkPhysicalDeviceLineRasterizationFeatures.Ptr, but with the new size.
@NotNull VkPhysicalDeviceLineRasterizationProperties.Ptr	VkPhysicalDeviceLineRasterizationProperties.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceLineRasterizationProperties.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceLineRasterizationProperties.Ptr that uses the same backing storage as this VkPhysicalDeviceLineRasterizationProperties.Ptr, but with the new size.
@NotNull VkPhysicalDeviceMaintenance3Properties.Ptr	VkPhysicalDeviceMaintenance3Properties.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceMaintenance3Properties.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceMaintenance3Properties.Ptr that uses the same backing storage as this VkPhysicalDeviceMaintenance3Properties.Ptr, but with the new size.
@NotNull VkPhysicalDeviceMaintenance4Features.Ptr	VkPhysicalDeviceMaintenance4Features.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceMaintenance4Features.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceMaintenance4Features.Ptr that uses the same backing storage as this VkPhysicalDeviceMaintenance4Features.Ptr, but with the new size.
@NotNull VkPhysicalDeviceMaintenance4Properties.Ptr	VkPhysicalDeviceMaintenance4Properties.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceMaintenance4Properties.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceMaintenance4Properties.Ptr that uses the same backing storage as this VkPhysicalDeviceMaintenance4Properties.Ptr, but with the new size.
@NotNull VkPhysicalDeviceMaintenance5Features.Ptr	VkPhysicalDeviceMaintenance5Features.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceMaintenance5Features.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceMaintenance5Features.Ptr that uses the same backing storage as this VkPhysicalDeviceMaintenance5Features.Ptr, but with the new size.
@NotNull VkPhysicalDeviceMaintenance5Properties.Ptr	VkPhysicalDeviceMaintenance5Properties.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceMaintenance5Properties.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceMaintenance5Properties.Ptr that uses the same backing storage as this VkPhysicalDeviceMaintenance5Properties.Ptr, but with the new size.
@NotNull VkPhysicalDeviceMaintenance6Features.Ptr	VkPhysicalDeviceMaintenance6Features.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceMaintenance6Features.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceMaintenance6Features.Ptr that uses the same backing storage as this VkPhysicalDeviceMaintenance6Features.Ptr, but with the new size.
@NotNull VkPhysicalDeviceMaintenance6Properties.Ptr	VkPhysicalDeviceMaintenance6Properties.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceMaintenance6Properties.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceMaintenance6Properties.Ptr that uses the same backing storage as this VkPhysicalDeviceMaintenance6Properties.Ptr, but with the new size.
@NotNull VkPhysicalDeviceMaintenance7FeaturesKHR.Ptr	VkPhysicalDeviceMaintenance7FeaturesKHR.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceMaintenance7FeaturesKHR.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceMaintenance7FeaturesKHR.Ptr that uses the same backing storage as this VkPhysicalDeviceMaintenance7FeaturesKHR.Ptr, but with the new size.
@NotNull VkPhysicalDeviceMaintenance7PropertiesKHR.Ptr	VkPhysicalDeviceMaintenance7PropertiesKHR.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceMaintenance7PropertiesKHR.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceMaintenance7PropertiesKHR.Ptr that uses the same backing storage as this VkPhysicalDeviceMaintenance7PropertiesKHR.Ptr, but with the new size.
@NotNull VkPhysicalDeviceMaintenance8FeaturesKHR.Ptr	VkPhysicalDeviceMaintenance8FeaturesKHR.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceMaintenance8FeaturesKHR.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceMaintenance8FeaturesKHR.Ptr that uses the same backing storage as this VkPhysicalDeviceMaintenance8FeaturesKHR.Ptr, but with the new size.
@NotNull VkPhysicalDeviceMapMemoryPlacedFeaturesEXT.Ptr	VkPhysicalDeviceMapMemoryPlacedFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceMapMemoryPlacedFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceMapMemoryPlacedFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceMapMemoryPlacedFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceMapMemoryPlacedPropertiesEXT.Ptr	VkPhysicalDeviceMapMemoryPlacedPropertiesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceMapMemoryPlacedPropertiesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceMapMemoryPlacedPropertiesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceMapMemoryPlacedPropertiesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceMemoryBudgetPropertiesEXT.Ptr	VkPhysicalDeviceMemoryBudgetPropertiesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceMemoryBudgetPropertiesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceMemoryBudgetPropertiesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceMemoryBudgetPropertiesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceMemoryDecompressionFeaturesNV.Ptr	VkPhysicalDeviceMemoryDecompressionFeaturesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceMemoryDecompressionFeaturesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceMemoryDecompressionFeaturesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceMemoryDecompressionFeaturesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceMemoryDecompressionPropertiesNV.Ptr	VkPhysicalDeviceMemoryDecompressionPropertiesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceMemoryDecompressionPropertiesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceMemoryDecompressionPropertiesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceMemoryDecompressionPropertiesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceMemoryPriorityFeaturesEXT.Ptr	VkPhysicalDeviceMemoryPriorityFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceMemoryPriorityFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceMemoryPriorityFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceMemoryPriorityFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceMemoryProperties.Ptr	VkPhysicalDeviceMemoryProperties.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceMemoryProperties.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceMemoryProperties.Ptr that uses the same backing storage as this VkPhysicalDeviceMemoryProperties.Ptr, but with the new size.
@NotNull VkPhysicalDeviceMemoryProperties2.Ptr	VkPhysicalDeviceMemoryProperties2.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceMemoryProperties2.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceMemoryProperties2.Ptr that uses the same backing storage as this VkPhysicalDeviceMemoryProperties2.Ptr, but with the new size.
@NotNull VkPhysicalDeviceMeshShaderFeaturesEXT.Ptr	VkPhysicalDeviceMeshShaderFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceMeshShaderFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceMeshShaderFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceMeshShaderFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceMeshShaderFeaturesNV.Ptr	VkPhysicalDeviceMeshShaderFeaturesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceMeshShaderFeaturesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceMeshShaderFeaturesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceMeshShaderFeaturesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceMeshShaderPropertiesEXT.Ptr	VkPhysicalDeviceMeshShaderPropertiesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceMeshShaderPropertiesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceMeshShaderPropertiesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceMeshShaderPropertiesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceMeshShaderPropertiesNV.Ptr	VkPhysicalDeviceMeshShaderPropertiesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceMeshShaderPropertiesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceMeshShaderPropertiesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceMeshShaderPropertiesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceMultiDrawFeaturesEXT.Ptr	VkPhysicalDeviceMultiDrawFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceMultiDrawFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceMultiDrawFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceMultiDrawFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceMultiDrawPropertiesEXT.Ptr	VkPhysicalDeviceMultiDrawPropertiesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceMultiDrawPropertiesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceMultiDrawPropertiesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceMultiDrawPropertiesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.Ptr	VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceMultiviewFeatures.Ptr	VkPhysicalDeviceMultiviewFeatures.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceMultiviewFeatures.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceMultiviewFeatures.Ptr that uses the same backing storage as this VkPhysicalDeviceMultiviewFeatures.Ptr, but with the new size.
@NotNull VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX.Ptr	VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX.Ptr that uses the same backing storage as this VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX.Ptr, but with the new size.
@NotNull VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM.Ptr	VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM.Ptr that uses the same backing storage as this VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM.Ptr, but with the new size.
@NotNull VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM.Ptr	VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM.Ptr that uses the same backing storage as this VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM.Ptr, but with the new size.
@NotNull VkPhysicalDeviceMultiviewProperties.Ptr	VkPhysicalDeviceMultiviewProperties.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceMultiviewProperties.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceMultiviewProperties.Ptr that uses the same backing storage as this VkPhysicalDeviceMultiviewProperties.Ptr, but with the new size.
@NotNull VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT.Ptr	VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceNestedCommandBufferFeaturesEXT.Ptr	VkPhysicalDeviceNestedCommandBufferFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceNestedCommandBufferFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceNestedCommandBufferFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceNestedCommandBufferFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceNestedCommandBufferPropertiesEXT.Ptr	VkPhysicalDeviceNestedCommandBufferPropertiesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceNestedCommandBufferPropertiesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceNestedCommandBufferPropertiesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceNestedCommandBufferPropertiesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT.Ptr	VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceOpacityMicromapFeaturesEXT.Ptr	VkPhysicalDeviceOpacityMicromapFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceOpacityMicromapFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceOpacityMicromapFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceOpacityMicromapFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceOpacityMicromapPropertiesEXT.Ptr	VkPhysicalDeviceOpacityMicromapPropertiesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceOpacityMicromapPropertiesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceOpacityMicromapPropertiesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceOpacityMicromapPropertiesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceOpticalFlowFeaturesNV.Ptr	VkPhysicalDeviceOpticalFlowFeaturesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceOpticalFlowFeaturesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceOpticalFlowFeaturesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceOpticalFlowFeaturesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceOpticalFlowPropertiesNV.Ptr	VkPhysicalDeviceOpticalFlowPropertiesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceOpticalFlowPropertiesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceOpticalFlowPropertiesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceOpticalFlowPropertiesNV.Ptr, but with the new size.
@NotNull VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT.Ptr	VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV.Ptr	VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV.Ptr that uses the same backing storage as this VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV.Ptr, but with the new size.
@NotNull VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV.Ptr	VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV.Ptr that uses the same backing storage as this VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV.Ptr, but with the new size.
@NotNull VkPhysicalDevicePCIBusInfoPropertiesEXT.Ptr	VkPhysicalDevicePCIBusInfoPropertiesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDevicePCIBusInfoPropertiesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDevicePCIBusInfoPropertiesEXT.Ptr that uses the same backing storage as this VkPhysicalDevicePCIBusInfoPropertiesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDevicePerformanceQueryFeaturesKHR.Ptr	VkPhysicalDevicePerformanceQueryFeaturesKHR.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDevicePerformanceQueryFeaturesKHR.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDevicePerformanceQueryFeaturesKHR.Ptr that uses the same backing storage as this VkPhysicalDevicePerformanceQueryFeaturesKHR.Ptr, but with the new size.
@NotNull VkPhysicalDevicePerformanceQueryPropertiesKHR.Ptr	VkPhysicalDevicePerformanceQueryPropertiesKHR.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDevicePerformanceQueryPropertiesKHR.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDevicePerformanceQueryPropertiesKHR.Ptr that uses the same backing storage as this VkPhysicalDevicePerformanceQueryPropertiesKHR.Ptr, but with the new size.
@NotNull VkPhysicalDevicePerStageDescriptorSetFeaturesNV.Ptr	VkPhysicalDevicePerStageDescriptorSetFeaturesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDevicePerStageDescriptorSetFeaturesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDevicePerStageDescriptorSetFeaturesNV.Ptr that uses the same backing storage as this VkPhysicalDevicePerStageDescriptorSetFeaturesNV.Ptr, but with the new size.
@NotNull VkPhysicalDevicePipelineBinaryFeaturesKHR.Ptr	VkPhysicalDevicePipelineBinaryFeaturesKHR.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDevicePipelineBinaryFeaturesKHR.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDevicePipelineBinaryFeaturesKHR.Ptr that uses the same backing storage as this VkPhysicalDevicePipelineBinaryFeaturesKHR.Ptr, but with the new size.
@NotNull VkPhysicalDevicePipelineBinaryPropertiesKHR.Ptr	VkPhysicalDevicePipelineBinaryPropertiesKHR.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDevicePipelineBinaryPropertiesKHR.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDevicePipelineBinaryPropertiesKHR.Ptr that uses the same backing storage as this VkPhysicalDevicePipelineBinaryPropertiesKHR.Ptr, but with the new size.
@NotNull VkPhysicalDevicePipelineCreationCacheControlFeatures.Ptr	VkPhysicalDevicePipelineCreationCacheControlFeatures.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDevicePipelineCreationCacheControlFeatures.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDevicePipelineCreationCacheControlFeatures.Ptr that uses the same backing storage as this VkPhysicalDevicePipelineCreationCacheControlFeatures.Ptr, but with the new size.
@NotNull VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR.Ptr	VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR.Ptr that uses the same backing storage as this VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR.Ptr, but with the new size.
@NotNull VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT.Ptr	VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDevicePipelineOpacityMicromapFeaturesARM.Ptr	VkPhysicalDevicePipelineOpacityMicromapFeaturesARM.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDevicePipelineOpacityMicromapFeaturesARM.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDevicePipelineOpacityMicromapFeaturesARM.Ptr that uses the same backing storage as this VkPhysicalDevicePipelineOpacityMicromapFeaturesARM.Ptr, but with the new size.
@NotNull VkPhysicalDevicePipelinePropertiesFeaturesEXT.Ptr	VkPhysicalDevicePipelinePropertiesFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDevicePipelinePropertiesFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDevicePipelinePropertiesFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDevicePipelinePropertiesFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDevicePipelineProtectedAccessFeatures.Ptr	VkPhysicalDevicePipelineProtectedAccessFeatures.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDevicePipelineProtectedAccessFeatures.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDevicePipelineProtectedAccessFeatures.Ptr that uses the same backing storage as this VkPhysicalDevicePipelineProtectedAccessFeatures.Ptr, but with the new size.
@NotNull VkPhysicalDevicePipelineRobustnessFeatures.Ptr	VkPhysicalDevicePipelineRobustnessFeatures.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDevicePipelineRobustnessFeatures.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDevicePipelineRobustnessFeatures.Ptr that uses the same backing storage as this VkPhysicalDevicePipelineRobustnessFeatures.Ptr, but with the new size.
@NotNull VkPhysicalDevicePipelineRobustnessProperties.Ptr	VkPhysicalDevicePipelineRobustnessProperties.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDevicePipelineRobustnessProperties.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDevicePipelineRobustnessProperties.Ptr that uses the same backing storage as this VkPhysicalDevicePipelineRobustnessProperties.Ptr, but with the new size.
@NotNull VkPhysicalDevicePointClippingProperties.Ptr	VkPhysicalDevicePointClippingProperties.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDevicePointClippingProperties.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDevicePointClippingProperties.Ptr that uses the same backing storage as this VkPhysicalDevicePointClippingProperties.Ptr, but with the new size.
@NotNull VkPhysicalDevicePortabilitySubsetFeaturesKHR.Ptr	VkPhysicalDevicePortabilitySubsetFeaturesKHR.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDevicePortabilitySubsetFeaturesKHR.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDevicePortabilitySubsetFeaturesKHR.Ptr that uses the same backing storage as this VkPhysicalDevicePortabilitySubsetFeaturesKHR.Ptr, but with the new size.
@NotNull VkPhysicalDevicePortabilitySubsetPropertiesKHR.Ptr	VkPhysicalDevicePortabilitySubsetPropertiesKHR.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDevicePortabilitySubsetPropertiesKHR.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDevicePortabilitySubsetPropertiesKHR.Ptr that uses the same backing storage as this VkPhysicalDevicePortabilitySubsetPropertiesKHR.Ptr, but with the new size.
@NotNull VkPhysicalDevicePresentBarrierFeaturesNV.Ptr	VkPhysicalDevicePresentBarrierFeaturesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDevicePresentBarrierFeaturesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDevicePresentBarrierFeaturesNV.Ptr that uses the same backing storage as this VkPhysicalDevicePresentBarrierFeaturesNV.Ptr, but with the new size.
@NotNull VkPhysicalDevicePresentIdFeaturesKHR.Ptr	VkPhysicalDevicePresentIdFeaturesKHR.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDevicePresentIdFeaturesKHR.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDevicePresentIdFeaturesKHR.Ptr that uses the same backing storage as this VkPhysicalDevicePresentIdFeaturesKHR.Ptr, but with the new size.
@NotNull VkPhysicalDevicePresentMeteringFeaturesNV.Ptr	VkPhysicalDevicePresentMeteringFeaturesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDevicePresentMeteringFeaturesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDevicePresentMeteringFeaturesNV.Ptr that uses the same backing storage as this VkPhysicalDevicePresentMeteringFeaturesNV.Ptr, but with the new size.
@NotNull VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT.Ptr	VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDevicePresentWaitFeaturesKHR.Ptr	VkPhysicalDevicePresentWaitFeaturesKHR.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDevicePresentWaitFeaturesKHR.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDevicePresentWaitFeaturesKHR.Ptr that uses the same backing storage as this VkPhysicalDevicePresentWaitFeaturesKHR.Ptr, but with the new size.
@NotNull VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT.Ptr	VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT.Ptr	VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDevicePrivateDataFeatures.Ptr	VkPhysicalDevicePrivateDataFeatures.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDevicePrivateDataFeatures.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDevicePrivateDataFeatures.Ptr that uses the same backing storage as this VkPhysicalDevicePrivateDataFeatures.Ptr, but with the new size.
@NotNull VkPhysicalDeviceProperties.Ptr	VkPhysicalDeviceProperties.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceProperties.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceProperties.Ptr that uses the same backing storage as this VkPhysicalDeviceProperties.Ptr, but with the new size.
@NotNull VkPhysicalDeviceProperties2.Ptr	VkPhysicalDeviceProperties2.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceProperties2.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceProperties2.Ptr that uses the same backing storage as this VkPhysicalDeviceProperties2.Ptr, but with the new size.
@NotNull VkPhysicalDeviceProtectedMemoryFeatures.Ptr	VkPhysicalDeviceProtectedMemoryFeatures.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceProtectedMemoryFeatures.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceProtectedMemoryFeatures.Ptr that uses the same backing storage as this VkPhysicalDeviceProtectedMemoryFeatures.Ptr, but with the new size.
@NotNull VkPhysicalDeviceProtectedMemoryProperties.Ptr	VkPhysicalDeviceProtectedMemoryProperties.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceProtectedMemoryProperties.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceProtectedMemoryProperties.Ptr that uses the same backing storage as this VkPhysicalDeviceProtectedMemoryProperties.Ptr, but with the new size.
@NotNull VkPhysicalDeviceProvokingVertexFeaturesEXT.Ptr	VkPhysicalDeviceProvokingVertexFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceProvokingVertexFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceProvokingVertexFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceProvokingVertexFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceProvokingVertexPropertiesEXT.Ptr	VkPhysicalDeviceProvokingVertexPropertiesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceProvokingVertexPropertiesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceProvokingVertexPropertiesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceProvokingVertexPropertiesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDevicePushDescriptorProperties.Ptr	VkPhysicalDevicePushDescriptorProperties.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDevicePushDescriptorProperties.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDevicePushDescriptorProperties.Ptr that uses the same backing storage as this VkPhysicalDevicePushDescriptorProperties.Ptr, but with the new size.
@NotNull VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.Ptr	VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceRawAccessChainsFeaturesNV.Ptr	VkPhysicalDeviceRawAccessChainsFeaturesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceRawAccessChainsFeaturesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceRawAccessChainsFeaturesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceRawAccessChainsFeaturesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceRayQueryFeaturesKHR.Ptr	VkPhysicalDeviceRayQueryFeaturesKHR.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceRayQueryFeaturesKHR.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceRayQueryFeaturesKHR.Ptr that uses the same backing storage as this VkPhysicalDeviceRayQueryFeaturesKHR.Ptr, but with the new size.
@NotNull VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV.Ptr	VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV.Ptr	VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV.Ptr	VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR.Ptr	VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR.Ptr that uses the same backing storage as this VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR.Ptr, but with the new size.
@NotNull VkPhysicalDeviceRayTracingMotionBlurFeaturesNV.Ptr	VkPhysicalDeviceRayTracingMotionBlurFeaturesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceRayTracingMotionBlurFeaturesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceRayTracingMotionBlurFeaturesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceRayTracingMotionBlurFeaturesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceRayTracingPipelineFeaturesKHR.Ptr	VkPhysicalDeviceRayTracingPipelineFeaturesKHR.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceRayTracingPipelineFeaturesKHR.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceRayTracingPipelineFeaturesKHR.Ptr that uses the same backing storage as this VkPhysicalDeviceRayTracingPipelineFeaturesKHR.Ptr, but with the new size.
@NotNull VkPhysicalDeviceRayTracingPipelinePropertiesKHR.Ptr	VkPhysicalDeviceRayTracingPipelinePropertiesKHR.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceRayTracingPipelinePropertiesKHR.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceRayTracingPipelinePropertiesKHR.Ptr that uses the same backing storage as this VkPhysicalDeviceRayTracingPipelinePropertiesKHR.Ptr, but with the new size.
@NotNull VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR.Ptr	VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR.Ptr that uses the same backing storage as this VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR.Ptr, but with the new size.
@NotNull VkPhysicalDeviceRayTracingPropertiesNV.Ptr	VkPhysicalDeviceRayTracingPropertiesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceRayTracingPropertiesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceRayTracingPropertiesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceRayTracingPropertiesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceRayTracingValidationFeaturesNV.Ptr	VkPhysicalDeviceRayTracingValidationFeaturesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceRayTracingValidationFeaturesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceRayTracingValidationFeaturesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceRayTracingValidationFeaturesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG.Ptr	VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG.Ptr that uses the same backing storage as this VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG.Ptr, but with the new size.
@NotNull VkPhysicalDeviceRenderPassStripedFeaturesARM.Ptr	VkPhysicalDeviceRenderPassStripedFeaturesARM.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceRenderPassStripedFeaturesARM.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceRenderPassStripedFeaturesARM.Ptr that uses the same backing storage as this VkPhysicalDeviceRenderPassStripedFeaturesARM.Ptr, but with the new size.
@NotNull VkPhysicalDeviceRenderPassStripedPropertiesARM.Ptr	VkPhysicalDeviceRenderPassStripedPropertiesARM.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceRenderPassStripedPropertiesARM.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceRenderPassStripedPropertiesARM.Ptr that uses the same backing storage as this VkPhysicalDeviceRenderPassStripedPropertiesARM.Ptr, but with the new size.
@NotNull VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV.Ptr	VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT.Ptr	VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceRobustness2FeaturesEXT.Ptr	VkPhysicalDeviceRobustness2FeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceRobustness2FeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceRobustness2FeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceRobustness2FeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceRobustness2PropertiesEXT.Ptr	VkPhysicalDeviceRobustness2PropertiesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceRobustness2PropertiesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceRobustness2PropertiesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceRobustness2PropertiesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceSampleLocationsPropertiesEXT.Ptr	VkPhysicalDeviceSampleLocationsPropertiesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceSampleLocationsPropertiesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceSampleLocationsPropertiesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceSampleLocationsPropertiesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceSamplerFilterMinmaxProperties.Ptr	VkPhysicalDeviceSamplerFilterMinmaxProperties.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceSamplerFilterMinmaxProperties.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceSamplerFilterMinmaxProperties.Ptr that uses the same backing storage as this VkPhysicalDeviceSamplerFilterMinmaxProperties.Ptr, but with the new size.
@NotNull VkPhysicalDeviceSamplerYcbcrConversionFeatures.Ptr	VkPhysicalDeviceSamplerYcbcrConversionFeatures.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceSamplerYcbcrConversionFeatures.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceSamplerYcbcrConversionFeatures.Ptr that uses the same backing storage as this VkPhysicalDeviceSamplerYcbcrConversionFeatures.Ptr, but with the new size.
@NotNull VkPhysicalDeviceScalarBlockLayoutFeatures.Ptr	VkPhysicalDeviceScalarBlockLayoutFeatures.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceScalarBlockLayoutFeatures.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceScalarBlockLayoutFeatures.Ptr that uses the same backing storage as this VkPhysicalDeviceScalarBlockLayoutFeatures.Ptr, but with the new size.
@NotNull VkPhysicalDeviceSchedulingControlsFeaturesARM.Ptr	VkPhysicalDeviceSchedulingControlsFeaturesARM.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceSchedulingControlsFeaturesARM.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceSchedulingControlsFeaturesARM.Ptr that uses the same backing storage as this VkPhysicalDeviceSchedulingControlsFeaturesARM.Ptr, but with the new size.
@NotNull VkPhysicalDeviceSchedulingControlsPropertiesARM.Ptr	VkPhysicalDeviceSchedulingControlsPropertiesARM.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceSchedulingControlsPropertiesARM.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceSchedulingControlsPropertiesARM.Ptr that uses the same backing storage as this VkPhysicalDeviceSchedulingControlsPropertiesARM.Ptr, but with the new size.
@NotNull VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures.Ptr	VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures.Ptr that uses the same backing storage as this VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures.Ptr, but with the new size.
@NotNull VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV.Ptr	VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.Ptr	VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.Ptr	VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceShaderAtomicFloatFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceShaderAtomicInt64Features.Ptr	VkPhysicalDeviceShaderAtomicInt64Features.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceShaderAtomicInt64Features.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceShaderAtomicInt64Features.Ptr that uses the same backing storage as this VkPhysicalDeviceShaderAtomicInt64Features.Ptr, but with the new size.
@NotNull VkPhysicalDeviceShaderBfloat16FeaturesKHR.Ptr	VkPhysicalDeviceShaderBfloat16FeaturesKHR.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceShaderBfloat16FeaturesKHR.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceShaderBfloat16FeaturesKHR.Ptr that uses the same backing storage as this VkPhysicalDeviceShaderBfloat16FeaturesKHR.Ptr, but with the new size.
@NotNull VkPhysicalDeviceShaderClockFeaturesKHR.Ptr	VkPhysicalDeviceShaderClockFeaturesKHR.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceShaderClockFeaturesKHR.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceShaderClockFeaturesKHR.Ptr that uses the same backing storage as this VkPhysicalDeviceShaderClockFeaturesKHR.Ptr, but with the new size.
@NotNull VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM.Ptr	VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM.Ptr that uses the same backing storage as this VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM.Ptr, but with the new size.
@NotNull VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM.Ptr	VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM.Ptr that uses the same backing storage as this VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM.Ptr, but with the new size.
@NotNull VkPhysicalDeviceShaderCoreProperties2AMD.Ptr	VkPhysicalDeviceShaderCoreProperties2AMD.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceShaderCoreProperties2AMD.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceShaderCoreProperties2AMD.Ptr that uses the same backing storage as this VkPhysicalDeviceShaderCoreProperties2AMD.Ptr, but with the new size.
@NotNull VkPhysicalDeviceShaderCorePropertiesAMD.Ptr	VkPhysicalDeviceShaderCorePropertiesAMD.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceShaderCorePropertiesAMD.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceShaderCorePropertiesAMD.Ptr that uses the same backing storage as this VkPhysicalDeviceShaderCorePropertiesAMD.Ptr, but with the new size.
@NotNull VkPhysicalDeviceShaderCorePropertiesARM.Ptr	VkPhysicalDeviceShaderCorePropertiesARM.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceShaderCorePropertiesARM.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceShaderCorePropertiesARM.Ptr that uses the same backing storage as this VkPhysicalDeviceShaderCorePropertiesARM.Ptr, but with the new size.
@NotNull VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures.Ptr	VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures.Ptr that uses the same backing storage as this VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures.Ptr, but with the new size.
@NotNull VkPhysicalDeviceShaderDrawParametersFeatures.Ptr	VkPhysicalDeviceShaderDrawParametersFeatures.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceShaderDrawParametersFeatures.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceShaderDrawParametersFeatures.Ptr that uses the same backing storage as this VkPhysicalDeviceShaderDrawParametersFeatures.Ptr, but with the new size.
@NotNull VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD.Ptr	VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD.Ptr that uses the same backing storage as this VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD.Ptr, but with the new size.
@NotNull VkPhysicalDeviceShaderEnqueueFeaturesAMDX.Ptr	VkPhysicalDeviceShaderEnqueueFeaturesAMDX.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceShaderEnqueueFeaturesAMDX.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceShaderEnqueueFeaturesAMDX.Ptr that uses the same backing storage as this VkPhysicalDeviceShaderEnqueueFeaturesAMDX.Ptr, but with the new size.
@NotNull VkPhysicalDeviceShaderEnqueuePropertiesAMDX.Ptr	VkPhysicalDeviceShaderEnqueuePropertiesAMDX.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceShaderEnqueuePropertiesAMDX.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceShaderEnqueuePropertiesAMDX.Ptr that uses the same backing storage as this VkPhysicalDeviceShaderEnqueuePropertiesAMDX.Ptr, but with the new size.
@NotNull VkPhysicalDeviceShaderExpectAssumeFeatures.Ptr	VkPhysicalDeviceShaderExpectAssumeFeatures.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceShaderExpectAssumeFeatures.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceShaderExpectAssumeFeatures.Ptr that uses the same backing storage as this VkPhysicalDeviceShaderExpectAssumeFeatures.Ptr, but with the new size.
@NotNull VkPhysicalDeviceShaderFloat16Int8Features.Ptr	VkPhysicalDeviceShaderFloat16Int8Features.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceShaderFloat16Int8Features.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceShaderFloat16Int8Features.Ptr that uses the same backing storage as this VkPhysicalDeviceShaderFloat16Int8Features.Ptr, but with the new size.
@NotNull VkPhysicalDeviceShaderFloatControls2Features.Ptr	VkPhysicalDeviceShaderFloatControls2Features.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceShaderFloatControls2Features.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceShaderFloatControls2Features.Ptr that uses the same backing storage as this VkPhysicalDeviceShaderFloatControls2Features.Ptr, but with the new size.
@NotNull VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT.Ptr	VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceShaderImageFootprintFeaturesNV.Ptr	VkPhysicalDeviceShaderImageFootprintFeaturesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceShaderImageFootprintFeaturesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceShaderImageFootprintFeaturesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceShaderImageFootprintFeaturesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceShaderIntegerDotProductFeatures.Ptr	VkPhysicalDeviceShaderIntegerDotProductFeatures.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceShaderIntegerDotProductFeatures.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceShaderIntegerDotProductFeatures.Ptr that uses the same backing storage as this VkPhysicalDeviceShaderIntegerDotProductFeatures.Ptr, but with the new size.
@NotNull VkPhysicalDeviceShaderIntegerDotProductProperties.Ptr	VkPhysicalDeviceShaderIntegerDotProductProperties.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceShaderIntegerDotProductProperties.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceShaderIntegerDotProductProperties.Ptr that uses the same backing storage as this VkPhysicalDeviceShaderIntegerDotProductProperties.Ptr, but with the new size.
@NotNull VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL.Ptr	VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL.Ptr that uses the same backing storage as this VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL.Ptr, but with the new size.
@NotNull VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR.Ptr	VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR.Ptr that uses the same backing storage as this VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR.Ptr, but with the new size.
@NotNull VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT.Ptr	VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT.Ptr	VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceShaderObjectFeaturesEXT.Ptr	VkPhysicalDeviceShaderObjectFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceShaderObjectFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceShaderObjectFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceShaderObjectFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceShaderObjectPropertiesEXT.Ptr	VkPhysicalDeviceShaderObjectPropertiesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceShaderObjectPropertiesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceShaderObjectPropertiesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceShaderObjectPropertiesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceShaderQuadControlFeaturesKHR.Ptr	VkPhysicalDeviceShaderQuadControlFeaturesKHR.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceShaderQuadControlFeaturesKHR.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceShaderQuadControlFeaturesKHR.Ptr that uses the same backing storage as this VkPhysicalDeviceShaderQuadControlFeaturesKHR.Ptr, but with the new size.
@NotNull VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR.Ptr	VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR.Ptr that uses the same backing storage as this VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR.Ptr, but with the new size.
@NotNull VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT.Ptr	VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceShaderSMBuiltinsFeaturesNV.Ptr	VkPhysicalDeviceShaderSMBuiltinsFeaturesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceShaderSMBuiltinsFeaturesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceShaderSMBuiltinsFeaturesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceShaderSMBuiltinsFeaturesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceShaderSMBuiltinsPropertiesNV.Ptr	VkPhysicalDeviceShaderSMBuiltinsPropertiesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceShaderSMBuiltinsPropertiesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceShaderSMBuiltinsPropertiesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceShaderSMBuiltinsPropertiesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures.Ptr	VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures.Ptr that uses the same backing storage as this VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures.Ptr, but with the new size.
@NotNull VkPhysicalDeviceShaderSubgroupRotateFeatures.Ptr	VkPhysicalDeviceShaderSubgroupRotateFeatures.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceShaderSubgroupRotateFeatures.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceShaderSubgroupRotateFeatures.Ptr that uses the same backing storage as this VkPhysicalDeviceShaderSubgroupRotateFeatures.Ptr, but with the new size.
@NotNull VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.Ptr	VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.Ptr that uses the same backing storage as this VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.Ptr, but with the new size.
@NotNull VkPhysicalDeviceShaderTerminateInvocationFeatures.Ptr	VkPhysicalDeviceShaderTerminateInvocationFeatures.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceShaderTerminateInvocationFeatures.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceShaderTerminateInvocationFeatures.Ptr that uses the same backing storage as this VkPhysicalDeviceShaderTerminateInvocationFeatures.Ptr, but with the new size.
@NotNull VkPhysicalDeviceShaderTileImageFeaturesEXT.Ptr	VkPhysicalDeviceShaderTileImageFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceShaderTileImageFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceShaderTileImageFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceShaderTileImageFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceShaderTileImagePropertiesEXT.Ptr	VkPhysicalDeviceShaderTileImagePropertiesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceShaderTileImagePropertiesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceShaderTileImagePropertiesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceShaderTileImagePropertiesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceShadingRateImageFeaturesNV.Ptr	VkPhysicalDeviceShadingRateImageFeaturesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceShadingRateImageFeaturesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceShadingRateImageFeaturesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceShadingRateImageFeaturesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceShadingRateImagePropertiesNV.Ptr	VkPhysicalDeviceShadingRateImagePropertiesNV.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceShadingRateImagePropertiesNV.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceShadingRateImagePropertiesNV.Ptr that uses the same backing storage as this VkPhysicalDeviceShadingRateImagePropertiesNV.Ptr, but with the new size.
@NotNull VkPhysicalDeviceSparseImageFormatInfo2.Ptr	VkPhysicalDeviceSparseImageFormatInfo2.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceSparseImageFormatInfo2.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceSparseImageFormatInfo2.Ptr that uses the same backing storage as this VkPhysicalDeviceSparseImageFormatInfo2.Ptr, but with the new size.
@NotNull VkPhysicalDeviceSparseProperties.Ptr	VkPhysicalDeviceSparseProperties.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceSparseProperties.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceSparseProperties.Ptr that uses the same backing storage as this VkPhysicalDeviceSparseProperties.Ptr, but with the new size.
@NotNull VkPhysicalDeviceSubgroupProperties.Ptr	VkPhysicalDeviceSubgroupProperties.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceSubgroupProperties.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceSubgroupProperties.Ptr that uses the same backing storage as this VkPhysicalDeviceSubgroupProperties.Ptr, but with the new size.
@NotNull VkPhysicalDeviceSubgroupSizeControlFeatures.Ptr	VkPhysicalDeviceSubgroupSizeControlFeatures.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceSubgroupSizeControlFeatures.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceSubgroupSizeControlFeatures.Ptr that uses the same backing storage as this VkPhysicalDeviceSubgroupSizeControlFeatures.Ptr, but with the new size.
@NotNull VkPhysicalDeviceSubgroupSizeControlProperties.Ptr	VkPhysicalDeviceSubgroupSizeControlProperties.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceSubgroupSizeControlProperties.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceSubgroupSizeControlProperties.Ptr that uses the same backing storage as this VkPhysicalDeviceSubgroupSizeControlProperties.Ptr, but with the new size.
@NotNull VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT.Ptr	VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceSubpassShadingFeaturesHUAWEI.Ptr	VkPhysicalDeviceSubpassShadingFeaturesHUAWEI.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceSubpassShadingFeaturesHUAWEI.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceSubpassShadingFeaturesHUAWEI.Ptr that uses the same backing storage as this VkPhysicalDeviceSubpassShadingFeaturesHUAWEI.Ptr, but with the new size.
@NotNull VkPhysicalDeviceSubpassShadingPropertiesHUAWEI.Ptr	VkPhysicalDeviceSubpassShadingPropertiesHUAWEI.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceSubpassShadingPropertiesHUAWEI.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceSubpassShadingPropertiesHUAWEI.Ptr that uses the same backing storage as this VkPhysicalDeviceSubpassShadingPropertiesHUAWEI.Ptr, but with the new size.
@NotNull VkPhysicalDeviceSurfaceInfo2KHR.Ptr	VkPhysicalDeviceSurfaceInfo2KHR.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceSurfaceInfo2KHR.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceSurfaceInfo2KHR.Ptr that uses the same backing storage as this VkPhysicalDeviceSurfaceInfo2KHR.Ptr, but with the new size.
@NotNull VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT.Ptr	VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceSynchronization2Features.Ptr	VkPhysicalDeviceSynchronization2Features.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceSynchronization2Features.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceSynchronization2Features.Ptr that uses the same backing storage as this VkPhysicalDeviceSynchronization2Features.Ptr, but with the new size.
@NotNull VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT.Ptr	VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceTexelBufferAlignmentProperties.Ptr	VkPhysicalDeviceTexelBufferAlignmentProperties.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceTexelBufferAlignmentProperties.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceTexelBufferAlignmentProperties.Ptr that uses the same backing storage as this VkPhysicalDeviceTexelBufferAlignmentProperties.Ptr, but with the new size.
@NotNull VkPhysicalDeviceTextureCompressionASTCHDRFeatures.Ptr	VkPhysicalDeviceTextureCompressionASTCHDRFeatures.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceTextureCompressionASTCHDRFeatures.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceTextureCompressionASTCHDRFeatures.Ptr that uses the same backing storage as this VkPhysicalDeviceTextureCompressionASTCHDRFeatures.Ptr, but with the new size.
@NotNull VkPhysicalDeviceTileMemoryHeapFeaturesQCOM.Ptr	VkPhysicalDeviceTileMemoryHeapFeaturesQCOM.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceTileMemoryHeapFeaturesQCOM.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceTileMemoryHeapFeaturesQCOM.Ptr that uses the same backing storage as this VkPhysicalDeviceTileMemoryHeapFeaturesQCOM.Ptr, but with the new size.
@NotNull VkPhysicalDeviceTileMemoryHeapPropertiesQCOM.Ptr	VkPhysicalDeviceTileMemoryHeapPropertiesQCOM.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceTileMemoryHeapPropertiesQCOM.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceTileMemoryHeapPropertiesQCOM.Ptr that uses the same backing storage as this VkPhysicalDeviceTileMemoryHeapPropertiesQCOM.Ptr, but with the new size.
@NotNull VkPhysicalDeviceTilePropertiesFeaturesQCOM.Ptr	VkPhysicalDeviceTilePropertiesFeaturesQCOM.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceTilePropertiesFeaturesQCOM.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceTilePropertiesFeaturesQCOM.Ptr that uses the same backing storage as this VkPhysicalDeviceTilePropertiesFeaturesQCOM.Ptr, but with the new size.
@NotNull VkPhysicalDeviceTileShadingFeaturesQCOM.Ptr	VkPhysicalDeviceTileShadingFeaturesQCOM.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceTileShadingFeaturesQCOM.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceTileShadingFeaturesQCOM.Ptr that uses the same backing storage as this VkPhysicalDeviceTileShadingFeaturesQCOM.Ptr, but with the new size.
@NotNull VkPhysicalDeviceTileShadingPropertiesQCOM.Ptr	VkPhysicalDeviceTileShadingPropertiesQCOM.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceTileShadingPropertiesQCOM.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceTileShadingPropertiesQCOM.Ptr that uses the same backing storage as this VkPhysicalDeviceTileShadingPropertiesQCOM.Ptr, but with the new size.
@NotNull VkPhysicalDeviceTimelineSemaphoreFeatures.Ptr	VkPhysicalDeviceTimelineSemaphoreFeatures.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceTimelineSemaphoreFeatures.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceTimelineSemaphoreFeatures.Ptr that uses the same backing storage as this VkPhysicalDeviceTimelineSemaphoreFeatures.Ptr, but with the new size.
@NotNull VkPhysicalDeviceTimelineSemaphoreProperties.Ptr	VkPhysicalDeviceTimelineSemaphoreProperties.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceTimelineSemaphoreProperties.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceTimelineSemaphoreProperties.Ptr that uses the same backing storage as this VkPhysicalDeviceTimelineSemaphoreProperties.Ptr, but with the new size.
@NotNull VkPhysicalDeviceToolProperties.Ptr	VkPhysicalDeviceToolProperties.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceToolProperties.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceToolProperties.Ptr that uses the same backing storage as this VkPhysicalDeviceToolProperties.Ptr, but with the new size.
@NotNull VkPhysicalDeviceTransformFeedbackFeaturesEXT.Ptr	VkPhysicalDeviceTransformFeedbackFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceTransformFeedbackFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceTransformFeedbackFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceTransformFeedbackFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceTransformFeedbackPropertiesEXT.Ptr	VkPhysicalDeviceTransformFeedbackPropertiesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceTransformFeedbackPropertiesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceTransformFeedbackPropertiesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceTransformFeedbackPropertiesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceUniformBufferStandardLayoutFeatures.Ptr	VkPhysicalDeviceUniformBufferStandardLayoutFeatures.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceUniformBufferStandardLayoutFeatures.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceUniformBufferStandardLayoutFeatures.Ptr that uses the same backing storage as this VkPhysicalDeviceUniformBufferStandardLayoutFeatures.Ptr, but with the new size.
@NotNull VkPhysicalDeviceVariablePointersFeatures.Ptr	VkPhysicalDeviceVariablePointersFeatures.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceVariablePointersFeatures.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceVariablePointersFeatures.Ptr that uses the same backing storage as this VkPhysicalDeviceVariablePointersFeatures.Ptr, but with the new size.
@NotNull VkPhysicalDeviceVertexAttributeDivisorFeatures.Ptr	VkPhysicalDeviceVertexAttributeDivisorFeatures.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceVertexAttributeDivisorFeatures.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceVertexAttributeDivisorFeatures.Ptr that uses the same backing storage as this VkPhysicalDeviceVertexAttributeDivisorFeatures.Ptr, but with the new size.
@NotNull VkPhysicalDeviceVertexAttributeDivisorProperties.Ptr	VkPhysicalDeviceVertexAttributeDivisorProperties.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceVertexAttributeDivisorProperties.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceVertexAttributeDivisorProperties.Ptr that uses the same backing storage as this VkPhysicalDeviceVertexAttributeDivisorProperties.Ptr, but with the new size.
@NotNull VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT.Ptr	VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT.Ptr	VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT.Ptr	VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceVideoEncodeAV1FeaturesKHR.Ptr	VkPhysicalDeviceVideoEncodeAV1FeaturesKHR.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceVideoEncodeAV1FeaturesKHR.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceVideoEncodeAV1FeaturesKHR.Ptr that uses the same backing storage as this VkPhysicalDeviceVideoEncodeAV1FeaturesKHR.Ptr, but with the new size.
@NotNull VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR.Ptr	VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR.Ptr that uses the same backing storage as this VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR.Ptr, but with the new size.
@NotNull VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR.Ptr	VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR.Ptr that uses the same backing storage as this VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR.Ptr, but with the new size.
@NotNull VkPhysicalDeviceVideoFormatInfoKHR.Ptr	VkPhysicalDeviceVideoFormatInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceVideoFormatInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceVideoFormatInfoKHR.Ptr that uses the same backing storage as this VkPhysicalDeviceVideoFormatInfoKHR.Ptr, but with the new size.
@NotNull VkPhysicalDeviceVideoMaintenance1FeaturesKHR.Ptr	VkPhysicalDeviceVideoMaintenance1FeaturesKHR.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceVideoMaintenance1FeaturesKHR.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceVideoMaintenance1FeaturesKHR.Ptr that uses the same backing storage as this VkPhysicalDeviceVideoMaintenance1FeaturesKHR.Ptr, but with the new size.
@NotNull VkPhysicalDeviceVideoMaintenance2FeaturesKHR.Ptr	VkPhysicalDeviceVideoMaintenance2FeaturesKHR.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceVideoMaintenance2FeaturesKHR.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceVideoMaintenance2FeaturesKHR.Ptr that uses the same backing storage as this VkPhysicalDeviceVideoMaintenance2FeaturesKHR.Ptr, but with the new size.
@NotNull VkPhysicalDeviceVulkan11Features.Ptr	VkPhysicalDeviceVulkan11Features.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceVulkan11Features.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceVulkan11Features.Ptr that uses the same backing storage as this VkPhysicalDeviceVulkan11Features.Ptr, but with the new size.
@NotNull VkPhysicalDeviceVulkan11Properties.Ptr	VkPhysicalDeviceVulkan11Properties.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceVulkan11Properties.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceVulkan11Properties.Ptr that uses the same backing storage as this VkPhysicalDeviceVulkan11Properties.Ptr, but with the new size.
@NotNull VkPhysicalDeviceVulkan12Features.Ptr	VkPhysicalDeviceVulkan12Features.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceVulkan12Features.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceVulkan12Features.Ptr that uses the same backing storage as this VkPhysicalDeviceVulkan12Features.Ptr, but with the new size.
@NotNull VkPhysicalDeviceVulkan12Properties.Ptr	VkPhysicalDeviceVulkan12Properties.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceVulkan12Properties.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceVulkan12Properties.Ptr that uses the same backing storage as this VkPhysicalDeviceVulkan12Properties.Ptr, but with the new size.
@NotNull VkPhysicalDeviceVulkan13Features.Ptr	VkPhysicalDeviceVulkan13Features.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceVulkan13Features.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceVulkan13Features.Ptr that uses the same backing storage as this VkPhysicalDeviceVulkan13Features.Ptr, but with the new size.
@NotNull VkPhysicalDeviceVulkan13Properties.Ptr	VkPhysicalDeviceVulkan13Properties.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceVulkan13Properties.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceVulkan13Properties.Ptr that uses the same backing storage as this VkPhysicalDeviceVulkan13Properties.Ptr, but with the new size.
@NotNull VkPhysicalDeviceVulkan14Features.Ptr	VkPhysicalDeviceVulkan14Features.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceVulkan14Features.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceVulkan14Features.Ptr that uses the same backing storage as this VkPhysicalDeviceVulkan14Features.Ptr, but with the new size.
@NotNull VkPhysicalDeviceVulkan14Properties.Ptr	VkPhysicalDeviceVulkan14Properties.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceVulkan14Properties.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceVulkan14Properties.Ptr that uses the same backing storage as this VkPhysicalDeviceVulkan14Properties.Ptr, but with the new size.
@NotNull VkPhysicalDeviceVulkanMemoryModelFeatures.Ptr	VkPhysicalDeviceVulkanMemoryModelFeatures.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceVulkanMemoryModelFeatures.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceVulkanMemoryModelFeatures.Ptr that uses the same backing storage as this VkPhysicalDeviceVulkanMemoryModelFeatures.Ptr, but with the new size.
@NotNull VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.Ptr	VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.Ptr that uses the same backing storage as this VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.Ptr, but with the new size.
@NotNull VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT.Ptr	VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceYcbcrDegammaFeaturesQCOM.Ptr	VkPhysicalDeviceYcbcrDegammaFeaturesQCOM.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceYcbcrDegammaFeaturesQCOM.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceYcbcrDegammaFeaturesQCOM.Ptr that uses the same backing storage as this VkPhysicalDeviceYcbcrDegammaFeaturesQCOM.Ptr, but with the new size.
@NotNull VkPhysicalDeviceYcbcrImageArraysFeaturesEXT.Ptr	VkPhysicalDeviceYcbcrImageArraysFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceYcbcrImageArraysFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceYcbcrImageArraysFeaturesEXT.Ptr that uses the same backing storage as this VkPhysicalDeviceYcbcrImageArraysFeaturesEXT.Ptr, but with the new size.
@NotNull VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures.Ptr	VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures.Ptr is capable of holding at least newSize structures, create a new view VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures.Ptr that uses the same backing storage as this VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures.Ptr, but with the new size.
@NotNull VkPipelineBinaryCreateInfoKHR.Ptr	VkPipelineBinaryCreateInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkPipelineBinaryCreateInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkPipelineBinaryCreateInfoKHR.Ptr that uses the same backing storage as this VkPipelineBinaryCreateInfoKHR.Ptr, but with the new size.
@NotNull VkPipelineBinaryDataInfoKHR.Ptr	VkPipelineBinaryDataInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkPipelineBinaryDataInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkPipelineBinaryDataInfoKHR.Ptr that uses the same backing storage as this VkPipelineBinaryDataInfoKHR.Ptr, but with the new size.
@NotNull VkPipelineBinaryDataKHR.Ptr	VkPipelineBinaryDataKHR.Ptr.reinterpret(long newSize)	Assume the VkPipelineBinaryDataKHR.Ptr is capable of holding at least newSize structures, create a new view VkPipelineBinaryDataKHR.Ptr that uses the same backing storage as this VkPipelineBinaryDataKHR.Ptr, but with the new size.
@NotNull VkPipelineBinaryHandlesInfoKHR.Ptr	VkPipelineBinaryHandlesInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkPipelineBinaryHandlesInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkPipelineBinaryHandlesInfoKHR.Ptr that uses the same backing storage as this VkPipelineBinaryHandlesInfoKHR.Ptr, but with the new size.
@NotNull VkPipelineBinaryInfoKHR.Ptr	VkPipelineBinaryInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkPipelineBinaryInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkPipelineBinaryInfoKHR.Ptr that uses the same backing storage as this VkPipelineBinaryInfoKHR.Ptr, but with the new size.
@NotNull VkPipelineBinaryKeyKHR.Ptr	VkPipelineBinaryKeyKHR.Ptr.reinterpret(long newSize)	Assume the VkPipelineBinaryKeyKHR.Ptr is capable of holding at least newSize structures, create a new view VkPipelineBinaryKeyKHR.Ptr that uses the same backing storage as this VkPipelineBinaryKeyKHR.Ptr, but with the new size.
@NotNull VkPipelineBinaryKeysAndDataKHR.Ptr	VkPipelineBinaryKeysAndDataKHR.Ptr.reinterpret(long newSize)	Assume the VkPipelineBinaryKeysAndDataKHR.Ptr is capable of holding at least newSize structures, create a new view VkPipelineBinaryKeysAndDataKHR.Ptr that uses the same backing storage as this VkPipelineBinaryKeysAndDataKHR.Ptr, but with the new size.
@NotNull VkPipelineCacheCreateInfo.Ptr	VkPipelineCacheCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkPipelineCacheCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkPipelineCacheCreateInfo.Ptr that uses the same backing storage as this VkPipelineCacheCreateInfo.Ptr, but with the new size.
@NotNull VkPipelineCacheHeaderVersionOne.Ptr	VkPipelineCacheHeaderVersionOne.Ptr.reinterpret(long newSize)	Assume the VkPipelineCacheHeaderVersionOne.Ptr is capable of holding at least newSize structures, create a new view VkPipelineCacheHeaderVersionOne.Ptr that uses the same backing storage as this VkPipelineCacheHeaderVersionOne.Ptr, but with the new size.
@NotNull VkPipelineColorBlendAdvancedStateCreateInfoEXT.Ptr	VkPipelineColorBlendAdvancedStateCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkPipelineColorBlendAdvancedStateCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkPipelineColorBlendAdvancedStateCreateInfoEXT.Ptr that uses the same backing storage as this VkPipelineColorBlendAdvancedStateCreateInfoEXT.Ptr, but with the new size.
@NotNull VkPipelineColorBlendAttachmentState.Ptr	VkPipelineColorBlendAttachmentState.Ptr.reinterpret(long newSize)	Assume the VkPipelineColorBlendAttachmentState.Ptr is capable of holding at least newSize structures, create a new view VkPipelineColorBlendAttachmentState.Ptr that uses the same backing storage as this VkPipelineColorBlendAttachmentState.Ptr, but with the new size.
@NotNull VkPipelineColorBlendStateCreateInfo.Ptr	VkPipelineColorBlendStateCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkPipelineColorBlendStateCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkPipelineColorBlendStateCreateInfo.Ptr that uses the same backing storage as this VkPipelineColorBlendStateCreateInfo.Ptr, but with the new size.
@NotNull VkPipelineColorWriteCreateInfoEXT.Ptr	VkPipelineColorWriteCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkPipelineColorWriteCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkPipelineColorWriteCreateInfoEXT.Ptr that uses the same backing storage as this VkPipelineColorWriteCreateInfoEXT.Ptr, but with the new size.
@NotNull VkPipelineCompilerControlCreateInfoAMD.Ptr	VkPipelineCompilerControlCreateInfoAMD.Ptr.reinterpret(long newSize)	Assume the VkPipelineCompilerControlCreateInfoAMD.Ptr is capable of holding at least newSize structures, create a new view VkPipelineCompilerControlCreateInfoAMD.Ptr that uses the same backing storage as this VkPipelineCompilerControlCreateInfoAMD.Ptr, but with the new size.
@NotNull VkPipelineCoverageModulationStateCreateInfoNV.Ptr	VkPipelineCoverageModulationStateCreateInfoNV.Ptr.reinterpret(long newSize)	Assume the VkPipelineCoverageModulationStateCreateInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkPipelineCoverageModulationStateCreateInfoNV.Ptr that uses the same backing storage as this VkPipelineCoverageModulationStateCreateInfoNV.Ptr, but with the new size.
@NotNull VkPipelineCoverageReductionStateCreateInfoNV.Ptr	VkPipelineCoverageReductionStateCreateInfoNV.Ptr.reinterpret(long newSize)	Assume the VkPipelineCoverageReductionStateCreateInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkPipelineCoverageReductionStateCreateInfoNV.Ptr that uses the same backing storage as this VkPipelineCoverageReductionStateCreateInfoNV.Ptr, but with the new size.
@NotNull VkPipelineCoverageToColorStateCreateInfoNV.Ptr	VkPipelineCoverageToColorStateCreateInfoNV.Ptr.reinterpret(long newSize)	Assume the VkPipelineCoverageToColorStateCreateInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkPipelineCoverageToColorStateCreateInfoNV.Ptr that uses the same backing storage as this VkPipelineCoverageToColorStateCreateInfoNV.Ptr, but with the new size.
@NotNull VkPipelineCreateFlags2CreateInfo.Ptr	VkPipelineCreateFlags2CreateInfo.Ptr.reinterpret(long newSize)	Assume the VkPipelineCreateFlags2CreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkPipelineCreateFlags2CreateInfo.Ptr that uses the same backing storage as this VkPipelineCreateFlags2CreateInfo.Ptr, but with the new size.
@NotNull VkPipelineCreateInfoKHR.Ptr	VkPipelineCreateInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkPipelineCreateInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkPipelineCreateInfoKHR.Ptr that uses the same backing storage as this VkPipelineCreateInfoKHR.Ptr, but with the new size.
@NotNull VkPipelineCreationFeedback.Ptr	VkPipelineCreationFeedback.Ptr.reinterpret(long newSize)	Assume the VkPipelineCreationFeedback.Ptr is capable of holding at least newSize structures, create a new view VkPipelineCreationFeedback.Ptr that uses the same backing storage as this VkPipelineCreationFeedback.Ptr, but with the new size.
@NotNull VkPipelineCreationFeedbackCreateInfo.Ptr	VkPipelineCreationFeedbackCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkPipelineCreationFeedbackCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkPipelineCreationFeedbackCreateInfo.Ptr that uses the same backing storage as this VkPipelineCreationFeedbackCreateInfo.Ptr, but with the new size.
@NotNull VkPipelineDepthStencilStateCreateInfo.Ptr	VkPipelineDepthStencilStateCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkPipelineDepthStencilStateCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkPipelineDepthStencilStateCreateInfo.Ptr that uses the same backing storage as this VkPipelineDepthStencilStateCreateInfo.Ptr, but with the new size.
@NotNull VkPipelineDiscardRectangleStateCreateInfoEXT.Ptr	VkPipelineDiscardRectangleStateCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkPipelineDiscardRectangleStateCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkPipelineDiscardRectangleStateCreateInfoEXT.Ptr that uses the same backing storage as this VkPipelineDiscardRectangleStateCreateInfoEXT.Ptr, but with the new size.
@NotNull VkPipelineDynamicStateCreateInfo.Ptr	VkPipelineDynamicStateCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkPipelineDynamicStateCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkPipelineDynamicStateCreateInfo.Ptr that uses the same backing storage as this VkPipelineDynamicStateCreateInfo.Ptr, but with the new size.
@NotNull VkPipelineExecutableInfoKHR.Ptr	VkPipelineExecutableInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkPipelineExecutableInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkPipelineExecutableInfoKHR.Ptr that uses the same backing storage as this VkPipelineExecutableInfoKHR.Ptr, but with the new size.
@NotNull VkPipelineExecutableInternalRepresentationKHR.Ptr	VkPipelineExecutableInternalRepresentationKHR.Ptr.reinterpret(long newSize)	Assume the VkPipelineExecutableInternalRepresentationKHR.Ptr is capable of holding at least newSize structures, create a new view VkPipelineExecutableInternalRepresentationKHR.Ptr that uses the same backing storage as this VkPipelineExecutableInternalRepresentationKHR.Ptr, but with the new size.
@NotNull VkPipelineExecutablePropertiesKHR.Ptr	VkPipelineExecutablePropertiesKHR.Ptr.reinterpret(long newSize)	Assume the VkPipelineExecutablePropertiesKHR.Ptr is capable of holding at least newSize structures, create a new view VkPipelineExecutablePropertiesKHR.Ptr that uses the same backing storage as this VkPipelineExecutablePropertiesKHR.Ptr, but with the new size.
@NotNull VkPipelineExecutableStatisticKHR.Ptr	VkPipelineExecutableStatisticKHR.Ptr.reinterpret(long newSize)	Assume the VkPipelineExecutableStatisticKHR.Ptr is capable of holding at least newSize structures, create a new view VkPipelineExecutableStatisticKHR.Ptr that uses the same backing storage as this VkPipelineExecutableStatisticKHR.Ptr, but with the new size.
@NotNull VkPipelineExecutableStatisticValueKHR.Ptr	VkPipelineExecutableStatisticValueKHR.Ptr.reinterpret(long newSize)	Assume the VkPipelineExecutableStatisticValueKHR.Ptr is capable of holding at least newSize structures, create a new view VkPipelineExecutableStatisticValueKHR.Ptr that uses the same backing storage as this VkPipelineExecutableStatisticValueKHR.Ptr, but with the new size.
@NotNull VkPipelineFragmentShadingRateEnumStateCreateInfoNV.Ptr	VkPipelineFragmentShadingRateEnumStateCreateInfoNV.Ptr.reinterpret(long newSize)	Assume the VkPipelineFragmentShadingRateEnumStateCreateInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkPipelineFragmentShadingRateEnumStateCreateInfoNV.Ptr that uses the same backing storage as this VkPipelineFragmentShadingRateEnumStateCreateInfoNV.Ptr, but with the new size.
@NotNull VkPipelineFragmentShadingRateStateCreateInfoKHR.Ptr	VkPipelineFragmentShadingRateStateCreateInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkPipelineFragmentShadingRateStateCreateInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkPipelineFragmentShadingRateStateCreateInfoKHR.Ptr that uses the same backing storage as this VkPipelineFragmentShadingRateStateCreateInfoKHR.Ptr, but with the new size.
@NotNull VkPipelineIndirectDeviceAddressInfoNV.Ptr	VkPipelineIndirectDeviceAddressInfoNV.Ptr.reinterpret(long newSize)	Assume the VkPipelineIndirectDeviceAddressInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkPipelineIndirectDeviceAddressInfoNV.Ptr that uses the same backing storage as this VkPipelineIndirectDeviceAddressInfoNV.Ptr, but with the new size.
@NotNull VkPipelineInfoKHR.Ptr	VkPipelineInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkPipelineInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkPipelineInfoKHR.Ptr that uses the same backing storage as this VkPipelineInfoKHR.Ptr, but with the new size.
@NotNull VkPipelineInputAssemblyStateCreateInfo.Ptr	VkPipelineInputAssemblyStateCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkPipelineInputAssemblyStateCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkPipelineInputAssemblyStateCreateInfo.Ptr that uses the same backing storage as this VkPipelineInputAssemblyStateCreateInfo.Ptr, but with the new size.
@NotNull VkPipelineLayoutCreateInfo.Ptr	VkPipelineLayoutCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkPipelineLayoutCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkPipelineLayoutCreateInfo.Ptr that uses the same backing storage as this VkPipelineLayoutCreateInfo.Ptr, but with the new size.
@NotNull VkPipelineLibraryCreateInfoKHR.Ptr	VkPipelineLibraryCreateInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkPipelineLibraryCreateInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkPipelineLibraryCreateInfoKHR.Ptr that uses the same backing storage as this VkPipelineLibraryCreateInfoKHR.Ptr, but with the new size.
@NotNull VkPipelineMultisampleStateCreateInfo.Ptr	VkPipelineMultisampleStateCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkPipelineMultisampleStateCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkPipelineMultisampleStateCreateInfo.Ptr that uses the same backing storage as this VkPipelineMultisampleStateCreateInfo.Ptr, but with the new size.
@NotNull VkPipelinePropertiesIdentifierEXT.Ptr	VkPipelinePropertiesIdentifierEXT.Ptr.reinterpret(long newSize)	Assume the VkPipelinePropertiesIdentifierEXT.Ptr is capable of holding at least newSize structures, create a new view VkPipelinePropertiesIdentifierEXT.Ptr that uses the same backing storage as this VkPipelinePropertiesIdentifierEXT.Ptr, but with the new size.
@NotNull VkPipelineRasterizationConservativeStateCreateInfoEXT.Ptr	VkPipelineRasterizationConservativeStateCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkPipelineRasterizationConservativeStateCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkPipelineRasterizationConservativeStateCreateInfoEXT.Ptr that uses the same backing storage as this VkPipelineRasterizationConservativeStateCreateInfoEXT.Ptr, but with the new size.
@NotNull VkPipelineRasterizationDepthClipStateCreateInfoEXT.Ptr	VkPipelineRasterizationDepthClipStateCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkPipelineRasterizationDepthClipStateCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkPipelineRasterizationDepthClipStateCreateInfoEXT.Ptr that uses the same backing storage as this VkPipelineRasterizationDepthClipStateCreateInfoEXT.Ptr, but with the new size.
@NotNull VkPipelineRasterizationLineStateCreateInfo.Ptr	VkPipelineRasterizationLineStateCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkPipelineRasterizationLineStateCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkPipelineRasterizationLineStateCreateInfo.Ptr that uses the same backing storage as this VkPipelineRasterizationLineStateCreateInfo.Ptr, but with the new size.
@NotNull VkPipelineRasterizationProvokingVertexStateCreateInfoEXT.Ptr	VkPipelineRasterizationProvokingVertexStateCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkPipelineRasterizationProvokingVertexStateCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkPipelineRasterizationProvokingVertexStateCreateInfoEXT.Ptr that uses the same backing storage as this VkPipelineRasterizationProvokingVertexStateCreateInfoEXT.Ptr, but with the new size.
@NotNull VkPipelineRasterizationStateCreateInfo.Ptr	VkPipelineRasterizationStateCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkPipelineRasterizationStateCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkPipelineRasterizationStateCreateInfo.Ptr that uses the same backing storage as this VkPipelineRasterizationStateCreateInfo.Ptr, but with the new size.
@NotNull VkPipelineRasterizationStateRasterizationOrderAMD.Ptr	VkPipelineRasterizationStateRasterizationOrderAMD.Ptr.reinterpret(long newSize)	Assume the VkPipelineRasterizationStateRasterizationOrderAMD.Ptr is capable of holding at least newSize structures, create a new view VkPipelineRasterizationStateRasterizationOrderAMD.Ptr that uses the same backing storage as this VkPipelineRasterizationStateRasterizationOrderAMD.Ptr, but with the new size.
@NotNull VkPipelineRasterizationStateStreamCreateInfoEXT.Ptr	VkPipelineRasterizationStateStreamCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkPipelineRasterizationStateStreamCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkPipelineRasterizationStateStreamCreateInfoEXT.Ptr that uses the same backing storage as this VkPipelineRasterizationStateStreamCreateInfoEXT.Ptr, but with the new size.
@NotNull VkPipelineRenderingCreateInfo.Ptr	VkPipelineRenderingCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkPipelineRenderingCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkPipelineRenderingCreateInfo.Ptr that uses the same backing storage as this VkPipelineRenderingCreateInfo.Ptr, but with the new size.
@NotNull VkPipelineRepresentativeFragmentTestStateCreateInfoNV.Ptr	VkPipelineRepresentativeFragmentTestStateCreateInfoNV.Ptr.reinterpret(long newSize)	Assume the VkPipelineRepresentativeFragmentTestStateCreateInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkPipelineRepresentativeFragmentTestStateCreateInfoNV.Ptr that uses the same backing storage as this VkPipelineRepresentativeFragmentTestStateCreateInfoNV.Ptr, but with the new size.
@NotNull VkPipelineRobustnessCreateInfo.Ptr	VkPipelineRobustnessCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkPipelineRobustnessCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkPipelineRobustnessCreateInfo.Ptr that uses the same backing storage as this VkPipelineRobustnessCreateInfo.Ptr, but with the new size.
@NotNull VkPipelineSampleLocationsStateCreateInfoEXT.Ptr	VkPipelineSampleLocationsStateCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkPipelineSampleLocationsStateCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkPipelineSampleLocationsStateCreateInfoEXT.Ptr that uses the same backing storage as this VkPipelineSampleLocationsStateCreateInfoEXT.Ptr, but with the new size.
@NotNull VkPipelineShaderStageCreateInfo.Ptr	VkPipelineShaderStageCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkPipelineShaderStageCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkPipelineShaderStageCreateInfo.Ptr that uses the same backing storage as this VkPipelineShaderStageCreateInfo.Ptr, but with the new size.
@NotNull VkPipelineShaderStageModuleIdentifierCreateInfoEXT.Ptr	VkPipelineShaderStageModuleIdentifierCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkPipelineShaderStageModuleIdentifierCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkPipelineShaderStageModuleIdentifierCreateInfoEXT.Ptr that uses the same backing storage as this VkPipelineShaderStageModuleIdentifierCreateInfoEXT.Ptr, but with the new size.
@NotNull VkPipelineShaderStageNodeCreateInfoAMDX.Ptr	VkPipelineShaderStageNodeCreateInfoAMDX.Ptr.reinterpret(long newSize)	Assume the VkPipelineShaderStageNodeCreateInfoAMDX.Ptr is capable of holding at least newSize structures, create a new view VkPipelineShaderStageNodeCreateInfoAMDX.Ptr that uses the same backing storage as this VkPipelineShaderStageNodeCreateInfoAMDX.Ptr, but with the new size.
@NotNull VkPipelineShaderStageRequiredSubgroupSizeCreateInfo.Ptr	VkPipelineShaderStageRequiredSubgroupSizeCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkPipelineShaderStageRequiredSubgroupSizeCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkPipelineShaderStageRequiredSubgroupSizeCreateInfo.Ptr that uses the same backing storage as this VkPipelineShaderStageRequiredSubgroupSizeCreateInfo.Ptr, but with the new size.
@NotNull VkPipelineTessellationDomainOriginStateCreateInfo.Ptr	VkPipelineTessellationDomainOriginStateCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkPipelineTessellationDomainOriginStateCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkPipelineTessellationDomainOriginStateCreateInfo.Ptr that uses the same backing storage as this VkPipelineTessellationDomainOriginStateCreateInfo.Ptr, but with the new size.
@NotNull VkPipelineTessellationStateCreateInfo.Ptr	VkPipelineTessellationStateCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkPipelineTessellationStateCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkPipelineTessellationStateCreateInfo.Ptr that uses the same backing storage as this VkPipelineTessellationStateCreateInfo.Ptr, but with the new size.
@NotNull VkPipelineVertexInputDivisorStateCreateInfo.Ptr	VkPipelineVertexInputDivisorStateCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkPipelineVertexInputDivisorStateCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkPipelineVertexInputDivisorStateCreateInfo.Ptr that uses the same backing storage as this VkPipelineVertexInputDivisorStateCreateInfo.Ptr, but with the new size.
@NotNull VkPipelineVertexInputStateCreateInfo.Ptr	VkPipelineVertexInputStateCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkPipelineVertexInputStateCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkPipelineVertexInputStateCreateInfo.Ptr that uses the same backing storage as this VkPipelineVertexInputStateCreateInfo.Ptr, but with the new size.
@NotNull VkPipelineViewportCoarseSampleOrderStateCreateInfoNV.Ptr	VkPipelineViewportCoarseSampleOrderStateCreateInfoNV.Ptr.reinterpret(long newSize)	Assume the VkPipelineViewportCoarseSampleOrderStateCreateInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkPipelineViewportCoarseSampleOrderStateCreateInfoNV.Ptr that uses the same backing storage as this VkPipelineViewportCoarseSampleOrderStateCreateInfoNV.Ptr, but with the new size.
@NotNull VkPipelineViewportDepthClampControlCreateInfoEXT.Ptr	VkPipelineViewportDepthClampControlCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkPipelineViewportDepthClampControlCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkPipelineViewportDepthClampControlCreateInfoEXT.Ptr that uses the same backing storage as this VkPipelineViewportDepthClampControlCreateInfoEXT.Ptr, but with the new size.
@NotNull VkPipelineViewportDepthClipControlCreateInfoEXT.Ptr	VkPipelineViewportDepthClipControlCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkPipelineViewportDepthClipControlCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkPipelineViewportDepthClipControlCreateInfoEXT.Ptr that uses the same backing storage as this VkPipelineViewportDepthClipControlCreateInfoEXT.Ptr, but with the new size.
@NotNull VkPipelineViewportExclusiveScissorStateCreateInfoNV.Ptr	VkPipelineViewportExclusiveScissorStateCreateInfoNV.Ptr.reinterpret(long newSize)	Assume the VkPipelineViewportExclusiveScissorStateCreateInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkPipelineViewportExclusiveScissorStateCreateInfoNV.Ptr that uses the same backing storage as this VkPipelineViewportExclusiveScissorStateCreateInfoNV.Ptr, but with the new size.
@NotNull VkPipelineViewportShadingRateImageStateCreateInfoNV.Ptr	VkPipelineViewportShadingRateImageStateCreateInfoNV.Ptr.reinterpret(long newSize)	Assume the VkPipelineViewportShadingRateImageStateCreateInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkPipelineViewportShadingRateImageStateCreateInfoNV.Ptr that uses the same backing storage as this VkPipelineViewportShadingRateImageStateCreateInfoNV.Ptr, but with the new size.
@NotNull VkPipelineViewportStateCreateInfo.Ptr	VkPipelineViewportStateCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkPipelineViewportStateCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkPipelineViewportStateCreateInfo.Ptr that uses the same backing storage as this VkPipelineViewportStateCreateInfo.Ptr, but with the new size.
@NotNull VkPipelineViewportSwizzleStateCreateInfoNV.Ptr	VkPipelineViewportSwizzleStateCreateInfoNV.Ptr.reinterpret(long newSize)	Assume the VkPipelineViewportSwizzleStateCreateInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkPipelineViewportSwizzleStateCreateInfoNV.Ptr that uses the same backing storage as this VkPipelineViewportSwizzleStateCreateInfoNV.Ptr, but with the new size.
@NotNull VkPipelineViewportWScalingStateCreateInfoNV.Ptr	VkPipelineViewportWScalingStateCreateInfoNV.Ptr.reinterpret(long newSize)	Assume the VkPipelineViewportWScalingStateCreateInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkPipelineViewportWScalingStateCreateInfoNV.Ptr that uses the same backing storage as this VkPipelineViewportWScalingStateCreateInfoNV.Ptr, but with the new size.
@NotNull VkPresentFrameTokenGGP.Ptr	VkPresentFrameTokenGGP.Ptr.reinterpret(long newSize)	Assume the VkPresentFrameTokenGGP.Ptr is capable of holding at least newSize structures, create a new view VkPresentFrameTokenGGP.Ptr that uses the same backing storage as this VkPresentFrameTokenGGP.Ptr, but with the new size.
@NotNull VkPresentIdKHR.Ptr	VkPresentIdKHR.Ptr.reinterpret(long newSize)	Assume the VkPresentIdKHR.Ptr is capable of holding at least newSize structures, create a new view VkPresentIdKHR.Ptr that uses the same backing storage as this VkPresentIdKHR.Ptr, but with the new size.
@NotNull VkPresentInfoKHR.Ptr	VkPresentInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkPresentInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkPresentInfoKHR.Ptr that uses the same backing storage as this VkPresentInfoKHR.Ptr, but with the new size.
@NotNull VkPresentRegionKHR.Ptr	VkPresentRegionKHR.Ptr.reinterpret(long newSize)	Assume the VkPresentRegionKHR.Ptr is capable of holding at least newSize structures, create a new view VkPresentRegionKHR.Ptr that uses the same backing storage as this VkPresentRegionKHR.Ptr, but with the new size.
@NotNull VkPresentRegionsKHR.Ptr	VkPresentRegionsKHR.Ptr.reinterpret(long newSize)	Assume the VkPresentRegionsKHR.Ptr is capable of holding at least newSize structures, create a new view VkPresentRegionsKHR.Ptr that uses the same backing storage as this VkPresentRegionsKHR.Ptr, but with the new size.
@NotNull VkPresentTimeGOOGLE.Ptr	VkPresentTimeGOOGLE.Ptr.reinterpret(long newSize)	Assume the VkPresentTimeGOOGLE.Ptr is capable of holding at least newSize structures, create a new view VkPresentTimeGOOGLE.Ptr that uses the same backing storage as this VkPresentTimeGOOGLE.Ptr, but with the new size.
@NotNull VkPresentTimesInfoGOOGLE.Ptr	VkPresentTimesInfoGOOGLE.Ptr.reinterpret(long newSize)	Assume the VkPresentTimesInfoGOOGLE.Ptr is capable of holding at least newSize structures, create a new view VkPresentTimesInfoGOOGLE.Ptr that uses the same backing storage as this VkPresentTimesInfoGOOGLE.Ptr, but with the new size.
@NotNull VkPrivateDataSlotCreateInfo.Ptr	VkPrivateDataSlotCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkPrivateDataSlotCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkPrivateDataSlotCreateInfo.Ptr that uses the same backing storage as this VkPrivateDataSlotCreateInfo.Ptr, but with the new size.
@NotNull VkProtectedSubmitInfo.Ptr	VkProtectedSubmitInfo.Ptr.reinterpret(long newSize)	Assume the VkProtectedSubmitInfo.Ptr is capable of holding at least newSize structures, create a new view VkProtectedSubmitInfo.Ptr that uses the same backing storage as this VkProtectedSubmitInfo.Ptr, but with the new size.
@NotNull VkPushConstantRange.Ptr	VkPushConstantRange.Ptr.reinterpret(long newSize)	Assume the VkPushConstantRange.Ptr is capable of holding at least newSize structures, create a new view VkPushConstantRange.Ptr that uses the same backing storage as this VkPushConstantRange.Ptr, but with the new size.
@NotNull VkPushConstantsInfo.Ptr	VkPushConstantsInfo.Ptr.reinterpret(long newSize)	Assume the VkPushConstantsInfo.Ptr is capable of holding at least newSize structures, create a new view VkPushConstantsInfo.Ptr that uses the same backing storage as this VkPushConstantsInfo.Ptr, but with the new size.
@NotNull VkPushDescriptorSetInfo.Ptr	VkPushDescriptorSetInfo.Ptr.reinterpret(long newSize)	Assume the VkPushDescriptorSetInfo.Ptr is capable of holding at least newSize structures, create a new view VkPushDescriptorSetInfo.Ptr that uses the same backing storage as this VkPushDescriptorSetInfo.Ptr, but with the new size.
@NotNull VkPushDescriptorSetWithTemplateInfo.Ptr	VkPushDescriptorSetWithTemplateInfo.Ptr.reinterpret(long newSize)	Assume the VkPushDescriptorSetWithTemplateInfo.Ptr is capable of holding at least newSize structures, create a new view VkPushDescriptorSetWithTemplateInfo.Ptr that uses the same backing storage as this VkPushDescriptorSetWithTemplateInfo.Ptr, but with the new size.
@NotNull VkQueryLowLatencySupportNV.Ptr	VkQueryLowLatencySupportNV.Ptr.reinterpret(long newSize)	Assume the VkQueryLowLatencySupportNV.Ptr is capable of holding at least newSize structures, create a new view VkQueryLowLatencySupportNV.Ptr that uses the same backing storage as this VkQueryLowLatencySupportNV.Ptr, but with the new size.
@NotNull VkQueryPoolCreateInfo.Ptr	VkQueryPoolCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkQueryPoolCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkQueryPoolCreateInfo.Ptr that uses the same backing storage as this VkQueryPoolCreateInfo.Ptr, but with the new size.
@NotNull VkQueryPoolPerformanceCreateInfoKHR.Ptr	VkQueryPoolPerformanceCreateInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkQueryPoolPerformanceCreateInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkQueryPoolPerformanceCreateInfoKHR.Ptr that uses the same backing storage as this VkQueryPoolPerformanceCreateInfoKHR.Ptr, but with the new size.
@NotNull VkQueryPoolPerformanceQueryCreateInfoINTEL.Ptr	VkQueryPoolPerformanceQueryCreateInfoINTEL.Ptr.reinterpret(long newSize)	Assume the VkQueryPoolPerformanceQueryCreateInfoINTEL.Ptr is capable of holding at least newSize structures, create a new view VkQueryPoolPerformanceQueryCreateInfoINTEL.Ptr that uses the same backing storage as this VkQueryPoolPerformanceQueryCreateInfoINTEL.Ptr, but with the new size.
@NotNull VkQueryPoolVideoEncodeFeedbackCreateInfoKHR.Ptr	VkQueryPoolVideoEncodeFeedbackCreateInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkQueryPoolVideoEncodeFeedbackCreateInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkQueryPoolVideoEncodeFeedbackCreateInfoKHR.Ptr that uses the same backing storage as this VkQueryPoolVideoEncodeFeedbackCreateInfoKHR.Ptr, but with the new size.
@NotNull VkQueueFamilyCheckpointProperties2NV.Ptr	VkQueueFamilyCheckpointProperties2NV.Ptr.reinterpret(long newSize)	Assume the VkQueueFamilyCheckpointProperties2NV.Ptr is capable of holding at least newSize structures, create a new view VkQueueFamilyCheckpointProperties2NV.Ptr that uses the same backing storage as this VkQueueFamilyCheckpointProperties2NV.Ptr, but with the new size.
@NotNull VkQueueFamilyCheckpointPropertiesNV.Ptr	VkQueueFamilyCheckpointPropertiesNV.Ptr.reinterpret(long newSize)	Assume the VkQueueFamilyCheckpointPropertiesNV.Ptr is capable of holding at least newSize structures, create a new view VkQueueFamilyCheckpointPropertiesNV.Ptr that uses the same backing storage as this VkQueueFamilyCheckpointPropertiesNV.Ptr, but with the new size.
@NotNull VkQueueFamilyGlobalPriorityProperties.Ptr	VkQueueFamilyGlobalPriorityProperties.Ptr.reinterpret(long newSize)	Assume the VkQueueFamilyGlobalPriorityProperties.Ptr is capable of holding at least newSize structures, create a new view VkQueueFamilyGlobalPriorityProperties.Ptr that uses the same backing storage as this VkQueueFamilyGlobalPriorityProperties.Ptr, but with the new size.
@NotNull VkQueueFamilyProperties.Ptr	VkQueueFamilyProperties.Ptr.reinterpret(long newSize)	Assume the VkQueueFamilyProperties.Ptr is capable of holding at least newSize structures, create a new view VkQueueFamilyProperties.Ptr that uses the same backing storage as this VkQueueFamilyProperties.Ptr, but with the new size.
@NotNull VkQueueFamilyProperties2.Ptr	VkQueueFamilyProperties2.Ptr.reinterpret(long newSize)	Assume the VkQueueFamilyProperties2.Ptr is capable of holding at least newSize structures, create a new view VkQueueFamilyProperties2.Ptr that uses the same backing storage as this VkQueueFamilyProperties2.Ptr, but with the new size.
@NotNull VkQueueFamilyQueryResultStatusPropertiesKHR.Ptr	VkQueueFamilyQueryResultStatusPropertiesKHR.Ptr.reinterpret(long newSize)	Assume the VkQueueFamilyQueryResultStatusPropertiesKHR.Ptr is capable of holding at least newSize structures, create a new view VkQueueFamilyQueryResultStatusPropertiesKHR.Ptr that uses the same backing storage as this VkQueueFamilyQueryResultStatusPropertiesKHR.Ptr, but with the new size.
@NotNull VkQueueFamilyVideoPropertiesKHR.Ptr	VkQueueFamilyVideoPropertiesKHR.Ptr.reinterpret(long newSize)	Assume the VkQueueFamilyVideoPropertiesKHR.Ptr is capable of holding at least newSize structures, create a new view VkQueueFamilyVideoPropertiesKHR.Ptr that uses the same backing storage as this VkQueueFamilyVideoPropertiesKHR.Ptr, but with the new size.
@NotNull VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV.Ptr	VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV.Ptr.reinterpret(long newSize)	Assume the VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV.Ptr that uses the same backing storage as this VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV.Ptr, but with the new size.
@NotNull VkRayTracingPipelineCreateInfoKHR.Ptr	VkRayTracingPipelineCreateInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkRayTracingPipelineCreateInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkRayTracingPipelineCreateInfoKHR.Ptr that uses the same backing storage as this VkRayTracingPipelineCreateInfoKHR.Ptr, but with the new size.
@NotNull VkRayTracingPipelineCreateInfoNV.Ptr	VkRayTracingPipelineCreateInfoNV.Ptr.reinterpret(long newSize)	Assume the VkRayTracingPipelineCreateInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkRayTracingPipelineCreateInfoNV.Ptr that uses the same backing storage as this VkRayTracingPipelineCreateInfoNV.Ptr, but with the new size.
@NotNull VkRayTracingPipelineInterfaceCreateInfoKHR.Ptr	VkRayTracingPipelineInterfaceCreateInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkRayTracingPipelineInterfaceCreateInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkRayTracingPipelineInterfaceCreateInfoKHR.Ptr that uses the same backing storage as this VkRayTracingPipelineInterfaceCreateInfoKHR.Ptr, but with the new size.
@NotNull VkRayTracingShaderGroupCreateInfoKHR.Ptr	VkRayTracingShaderGroupCreateInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkRayTracingShaderGroupCreateInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkRayTracingShaderGroupCreateInfoKHR.Ptr that uses the same backing storage as this VkRayTracingShaderGroupCreateInfoKHR.Ptr, but with the new size.
@NotNull VkRayTracingShaderGroupCreateInfoNV.Ptr	VkRayTracingShaderGroupCreateInfoNV.Ptr.reinterpret(long newSize)	Assume the VkRayTracingShaderGroupCreateInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkRayTracingShaderGroupCreateInfoNV.Ptr that uses the same backing storage as this VkRayTracingShaderGroupCreateInfoNV.Ptr, but with the new size.
@NotNull VkRect2D.Ptr	VkRect2D.Ptr.reinterpret(long newSize)	Assume the VkRect2D.Ptr is capable of holding at least newSize structures, create a new view VkRect2D.Ptr that uses the same backing storage as this VkRect2D.Ptr, but with the new size.
@NotNull VkRectLayerKHR.Ptr	VkRectLayerKHR.Ptr.reinterpret(long newSize)	Assume the VkRectLayerKHR.Ptr is capable of holding at least newSize structures, create a new view VkRectLayerKHR.Ptr that uses the same backing storage as this VkRectLayerKHR.Ptr, but with the new size.
@NotNull VkRefreshCycleDurationGOOGLE.Ptr	VkRefreshCycleDurationGOOGLE.Ptr.reinterpret(long newSize)	Assume the VkRefreshCycleDurationGOOGLE.Ptr is capable of holding at least newSize structures, create a new view VkRefreshCycleDurationGOOGLE.Ptr that uses the same backing storage as this VkRefreshCycleDurationGOOGLE.Ptr, but with the new size.
@NotNull VkRefreshObjectKHR.Ptr	VkRefreshObjectKHR.Ptr.reinterpret(long newSize)	Assume the VkRefreshObjectKHR.Ptr is capable of holding at least newSize structures, create a new view VkRefreshObjectKHR.Ptr that uses the same backing storage as this VkRefreshObjectKHR.Ptr, but with the new size.
@NotNull VkRefreshObjectListKHR.Ptr	VkRefreshObjectListKHR.Ptr.reinterpret(long newSize)	Assume the VkRefreshObjectListKHR.Ptr is capable of holding at least newSize structures, create a new view VkRefreshObjectListKHR.Ptr that uses the same backing storage as this VkRefreshObjectListKHR.Ptr, but with the new size.
@NotNull VkReleaseCapturedPipelineDataInfoKHR.Ptr	VkReleaseCapturedPipelineDataInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkReleaseCapturedPipelineDataInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkReleaseCapturedPipelineDataInfoKHR.Ptr that uses the same backing storage as this VkReleaseCapturedPipelineDataInfoKHR.Ptr, but with the new size.
@NotNull VkReleaseSwapchainImagesInfoEXT.Ptr	VkReleaseSwapchainImagesInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkReleaseSwapchainImagesInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkReleaseSwapchainImagesInfoEXT.Ptr that uses the same backing storage as this VkReleaseSwapchainImagesInfoEXT.Ptr, but with the new size.
@NotNull VkRenderingAreaInfo.Ptr	VkRenderingAreaInfo.Ptr.reinterpret(long newSize)	Assume the VkRenderingAreaInfo.Ptr is capable of holding at least newSize structures, create a new view VkRenderingAreaInfo.Ptr that uses the same backing storage as this VkRenderingAreaInfo.Ptr, but with the new size.
@NotNull VkRenderingAttachmentInfo.Ptr	VkRenderingAttachmentInfo.Ptr.reinterpret(long newSize)	Assume the VkRenderingAttachmentInfo.Ptr is capable of holding at least newSize structures, create a new view VkRenderingAttachmentInfo.Ptr that uses the same backing storage as this VkRenderingAttachmentInfo.Ptr, but with the new size.
@NotNull VkRenderingAttachmentLocationInfo.Ptr	VkRenderingAttachmentLocationInfo.Ptr.reinterpret(long newSize)	Assume the VkRenderingAttachmentLocationInfo.Ptr is capable of holding at least newSize structures, create a new view VkRenderingAttachmentLocationInfo.Ptr that uses the same backing storage as this VkRenderingAttachmentLocationInfo.Ptr, but with the new size.
@NotNull VkRenderingEndInfoEXT.Ptr	VkRenderingEndInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkRenderingEndInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkRenderingEndInfoEXT.Ptr that uses the same backing storage as this VkRenderingEndInfoEXT.Ptr, but with the new size.
@NotNull VkRenderingFragmentDensityMapAttachmentInfoEXT.Ptr	VkRenderingFragmentDensityMapAttachmentInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkRenderingFragmentDensityMapAttachmentInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkRenderingFragmentDensityMapAttachmentInfoEXT.Ptr that uses the same backing storage as this VkRenderingFragmentDensityMapAttachmentInfoEXT.Ptr, but with the new size.
@NotNull VkRenderingFragmentShadingRateAttachmentInfoKHR.Ptr	VkRenderingFragmentShadingRateAttachmentInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkRenderingFragmentShadingRateAttachmentInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkRenderingFragmentShadingRateAttachmentInfoKHR.Ptr that uses the same backing storage as this VkRenderingFragmentShadingRateAttachmentInfoKHR.Ptr, but with the new size.
@NotNull VkRenderingInfo.Ptr	VkRenderingInfo.Ptr.reinterpret(long newSize)	Assume the VkRenderingInfo.Ptr is capable of holding at least newSize structures, create a new view VkRenderingInfo.Ptr that uses the same backing storage as this VkRenderingInfo.Ptr, but with the new size.
@NotNull VkRenderingInputAttachmentIndexInfo.Ptr	VkRenderingInputAttachmentIndexInfo.Ptr.reinterpret(long newSize)	Assume the VkRenderingInputAttachmentIndexInfo.Ptr is capable of holding at least newSize structures, create a new view VkRenderingInputAttachmentIndexInfo.Ptr that uses the same backing storage as this VkRenderingInputAttachmentIndexInfo.Ptr, but with the new size.
@NotNull VkRenderPassAttachmentBeginInfo.Ptr	VkRenderPassAttachmentBeginInfo.Ptr.reinterpret(long newSize)	Assume the VkRenderPassAttachmentBeginInfo.Ptr is capable of holding at least newSize structures, create a new view VkRenderPassAttachmentBeginInfo.Ptr that uses the same backing storage as this VkRenderPassAttachmentBeginInfo.Ptr, but with the new size.
@NotNull VkRenderPassBeginInfo.Ptr	VkRenderPassBeginInfo.Ptr.reinterpret(long newSize)	Assume the VkRenderPassBeginInfo.Ptr is capable of holding at least newSize structures, create a new view VkRenderPassBeginInfo.Ptr that uses the same backing storage as this VkRenderPassBeginInfo.Ptr, but with the new size.
@NotNull VkRenderPassCreateInfo.Ptr	VkRenderPassCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkRenderPassCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkRenderPassCreateInfo.Ptr that uses the same backing storage as this VkRenderPassCreateInfo.Ptr, but with the new size.
@NotNull VkRenderPassCreateInfo2.Ptr	VkRenderPassCreateInfo2.Ptr.reinterpret(long newSize)	Assume the VkRenderPassCreateInfo2.Ptr is capable of holding at least newSize structures, create a new view VkRenderPassCreateInfo2.Ptr that uses the same backing storage as this VkRenderPassCreateInfo2.Ptr, but with the new size.
@NotNull VkRenderPassCreationControlEXT.Ptr	VkRenderPassCreationControlEXT.Ptr.reinterpret(long newSize)	Assume the VkRenderPassCreationControlEXT.Ptr is capable of holding at least newSize structures, create a new view VkRenderPassCreationControlEXT.Ptr that uses the same backing storage as this VkRenderPassCreationControlEXT.Ptr, but with the new size.
@NotNull VkRenderPassCreationFeedbackCreateInfoEXT.Ptr	VkRenderPassCreationFeedbackCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkRenderPassCreationFeedbackCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkRenderPassCreationFeedbackCreateInfoEXT.Ptr that uses the same backing storage as this VkRenderPassCreationFeedbackCreateInfoEXT.Ptr, but with the new size.
@NotNull VkRenderPassCreationFeedbackInfoEXT.Ptr	VkRenderPassCreationFeedbackInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkRenderPassCreationFeedbackInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkRenderPassCreationFeedbackInfoEXT.Ptr that uses the same backing storage as this VkRenderPassCreationFeedbackInfoEXT.Ptr, but with the new size.
@NotNull VkRenderPassFragmentDensityMapCreateInfoEXT.Ptr	VkRenderPassFragmentDensityMapCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkRenderPassFragmentDensityMapCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkRenderPassFragmentDensityMapCreateInfoEXT.Ptr that uses the same backing storage as this VkRenderPassFragmentDensityMapCreateInfoEXT.Ptr, but with the new size.
@NotNull VkRenderPassFragmentDensityMapOffsetEndInfoEXT.Ptr	VkRenderPassFragmentDensityMapOffsetEndInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkRenderPassFragmentDensityMapOffsetEndInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkRenderPassFragmentDensityMapOffsetEndInfoEXT.Ptr that uses the same backing storage as this VkRenderPassFragmentDensityMapOffsetEndInfoEXT.Ptr, but with the new size.
@NotNull VkRenderPassInputAttachmentAspectCreateInfo.Ptr	VkRenderPassInputAttachmentAspectCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkRenderPassInputAttachmentAspectCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkRenderPassInputAttachmentAspectCreateInfo.Ptr that uses the same backing storage as this VkRenderPassInputAttachmentAspectCreateInfo.Ptr, but with the new size.
@NotNull VkRenderPassMultiviewCreateInfo.Ptr	VkRenderPassMultiviewCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkRenderPassMultiviewCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkRenderPassMultiviewCreateInfo.Ptr that uses the same backing storage as this VkRenderPassMultiviewCreateInfo.Ptr, but with the new size.
@NotNull VkRenderPassSampleLocationsBeginInfoEXT.Ptr	VkRenderPassSampleLocationsBeginInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkRenderPassSampleLocationsBeginInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkRenderPassSampleLocationsBeginInfoEXT.Ptr that uses the same backing storage as this VkRenderPassSampleLocationsBeginInfoEXT.Ptr, but with the new size.
@NotNull VkRenderPassStripeBeginInfoARM.Ptr	VkRenderPassStripeBeginInfoARM.Ptr.reinterpret(long newSize)	Assume the VkRenderPassStripeBeginInfoARM.Ptr is capable of holding at least newSize structures, create a new view VkRenderPassStripeBeginInfoARM.Ptr that uses the same backing storage as this VkRenderPassStripeBeginInfoARM.Ptr, but with the new size.
@NotNull VkRenderPassStripeInfoARM.Ptr	VkRenderPassStripeInfoARM.Ptr.reinterpret(long newSize)	Assume the VkRenderPassStripeInfoARM.Ptr is capable of holding at least newSize structures, create a new view VkRenderPassStripeInfoARM.Ptr that uses the same backing storage as this VkRenderPassStripeInfoARM.Ptr, but with the new size.
@NotNull VkRenderPassStripeSubmitInfoARM.Ptr	VkRenderPassStripeSubmitInfoARM.Ptr.reinterpret(long newSize)	Assume the VkRenderPassStripeSubmitInfoARM.Ptr is capable of holding at least newSize structures, create a new view VkRenderPassStripeSubmitInfoARM.Ptr that uses the same backing storage as this VkRenderPassStripeSubmitInfoARM.Ptr, but with the new size.
@NotNull VkRenderPassSubpassFeedbackCreateInfoEXT.Ptr	VkRenderPassSubpassFeedbackCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkRenderPassSubpassFeedbackCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkRenderPassSubpassFeedbackCreateInfoEXT.Ptr that uses the same backing storage as this VkRenderPassSubpassFeedbackCreateInfoEXT.Ptr, but with the new size.
@NotNull VkRenderPassSubpassFeedbackInfoEXT.Ptr	VkRenderPassSubpassFeedbackInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkRenderPassSubpassFeedbackInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkRenderPassSubpassFeedbackInfoEXT.Ptr that uses the same backing storage as this VkRenderPassSubpassFeedbackInfoEXT.Ptr, but with the new size.
@NotNull VkRenderPassTileShadingCreateInfoQCOM.Ptr	VkRenderPassTileShadingCreateInfoQCOM.Ptr.reinterpret(long newSize)	Assume the VkRenderPassTileShadingCreateInfoQCOM.Ptr is capable of holding at least newSize structures, create a new view VkRenderPassTileShadingCreateInfoQCOM.Ptr that uses the same backing storage as this VkRenderPassTileShadingCreateInfoQCOM.Ptr, but with the new size.
@NotNull VkRenderPassTransformBeginInfoQCOM.Ptr	VkRenderPassTransformBeginInfoQCOM.Ptr.reinterpret(long newSize)	Assume the VkRenderPassTransformBeginInfoQCOM.Ptr is capable of holding at least newSize structures, create a new view VkRenderPassTransformBeginInfoQCOM.Ptr that uses the same backing storage as this VkRenderPassTransformBeginInfoQCOM.Ptr, but with the new size.
@NotNull VkResolveImageInfo2.Ptr	VkResolveImageInfo2.Ptr.reinterpret(long newSize)	Assume the VkResolveImageInfo2.Ptr is capable of holding at least newSize structures, create a new view VkResolveImageInfo2.Ptr that uses the same backing storage as this VkResolveImageInfo2.Ptr, but with the new size.
@NotNull VkSampleLocationEXT.Ptr	VkSampleLocationEXT.Ptr.reinterpret(long newSize)	Assume the VkSampleLocationEXT.Ptr is capable of holding at least newSize structures, create a new view VkSampleLocationEXT.Ptr that uses the same backing storage as this VkSampleLocationEXT.Ptr, but with the new size.
@NotNull VkSampleLocationsInfoEXT.Ptr	VkSampleLocationsInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkSampleLocationsInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkSampleLocationsInfoEXT.Ptr that uses the same backing storage as this VkSampleLocationsInfoEXT.Ptr, but with the new size.
@NotNull VkSamplerBlockMatchWindowCreateInfoQCOM.Ptr	VkSamplerBlockMatchWindowCreateInfoQCOM.Ptr.reinterpret(long newSize)	Assume the VkSamplerBlockMatchWindowCreateInfoQCOM.Ptr is capable of holding at least newSize structures, create a new view VkSamplerBlockMatchWindowCreateInfoQCOM.Ptr that uses the same backing storage as this VkSamplerBlockMatchWindowCreateInfoQCOM.Ptr, but with the new size.
@NotNull VkSamplerBorderColorComponentMappingCreateInfoEXT.Ptr	VkSamplerBorderColorComponentMappingCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkSamplerBorderColorComponentMappingCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkSamplerBorderColorComponentMappingCreateInfoEXT.Ptr that uses the same backing storage as this VkSamplerBorderColorComponentMappingCreateInfoEXT.Ptr, but with the new size.
@NotNull VkSamplerCaptureDescriptorDataInfoEXT.Ptr	VkSamplerCaptureDescriptorDataInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkSamplerCaptureDescriptorDataInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkSamplerCaptureDescriptorDataInfoEXT.Ptr that uses the same backing storage as this VkSamplerCaptureDescriptorDataInfoEXT.Ptr, but with the new size.
@NotNull VkSamplerCreateInfo.Ptr	VkSamplerCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkSamplerCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkSamplerCreateInfo.Ptr that uses the same backing storage as this VkSamplerCreateInfo.Ptr, but with the new size.
@NotNull VkSamplerCubicWeightsCreateInfoQCOM.Ptr	VkSamplerCubicWeightsCreateInfoQCOM.Ptr.reinterpret(long newSize)	Assume the VkSamplerCubicWeightsCreateInfoQCOM.Ptr is capable of holding at least newSize structures, create a new view VkSamplerCubicWeightsCreateInfoQCOM.Ptr that uses the same backing storage as this VkSamplerCubicWeightsCreateInfoQCOM.Ptr, but with the new size.
@NotNull VkSamplerCustomBorderColorCreateInfoEXT.Ptr	VkSamplerCustomBorderColorCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkSamplerCustomBorderColorCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkSamplerCustomBorderColorCreateInfoEXT.Ptr that uses the same backing storage as this VkSamplerCustomBorderColorCreateInfoEXT.Ptr, but with the new size.
@NotNull VkSamplerReductionModeCreateInfo.Ptr	VkSamplerReductionModeCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkSamplerReductionModeCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkSamplerReductionModeCreateInfo.Ptr that uses the same backing storage as this VkSamplerReductionModeCreateInfo.Ptr, but with the new size.
@NotNull VkSamplerYcbcrConversionCreateInfo.Ptr	VkSamplerYcbcrConversionCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkSamplerYcbcrConversionCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkSamplerYcbcrConversionCreateInfo.Ptr that uses the same backing storage as this VkSamplerYcbcrConversionCreateInfo.Ptr, but with the new size.
@NotNull VkSamplerYcbcrConversionImageFormatProperties.Ptr	VkSamplerYcbcrConversionImageFormatProperties.Ptr.reinterpret(long newSize)	Assume the VkSamplerYcbcrConversionImageFormatProperties.Ptr is capable of holding at least newSize structures, create a new view VkSamplerYcbcrConversionImageFormatProperties.Ptr that uses the same backing storage as this VkSamplerYcbcrConversionImageFormatProperties.Ptr, but with the new size.
@NotNull VkSamplerYcbcrConversionInfo.Ptr	VkSamplerYcbcrConversionInfo.Ptr.reinterpret(long newSize)	Assume the VkSamplerYcbcrConversionInfo.Ptr is capable of holding at least newSize structures, create a new view VkSamplerYcbcrConversionInfo.Ptr that uses the same backing storage as this VkSamplerYcbcrConversionInfo.Ptr, but with the new size.
@NotNull VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM.Ptr	VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM.Ptr.reinterpret(long newSize)	Assume the VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM.Ptr is capable of holding at least newSize structures, create a new view VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM.Ptr that uses the same backing storage as this VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM.Ptr, but with the new size.
@NotNull VkSciSyncAttributesInfoNV.Ptr	VkSciSyncAttributesInfoNV.Ptr.reinterpret(long newSize)	Assume the VkSciSyncAttributesInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkSciSyncAttributesInfoNV.Ptr that uses the same backing storage as this VkSciSyncAttributesInfoNV.Ptr, but with the new size.
@NotNull VkScreenBufferFormatPropertiesQNX.Ptr	VkScreenBufferFormatPropertiesQNX.Ptr.reinterpret(long newSize)	Assume the VkScreenBufferFormatPropertiesQNX.Ptr is capable of holding at least newSize structures, create a new view VkScreenBufferFormatPropertiesQNX.Ptr that uses the same backing storage as this VkScreenBufferFormatPropertiesQNX.Ptr, but with the new size.
@NotNull VkScreenBufferPropertiesQNX.Ptr	VkScreenBufferPropertiesQNX.Ptr.reinterpret(long newSize)	Assume the VkScreenBufferPropertiesQNX.Ptr is capable of holding at least newSize structures, create a new view VkScreenBufferPropertiesQNX.Ptr that uses the same backing storage as this VkScreenBufferPropertiesQNX.Ptr, but with the new size.
@NotNull VkScreenSurfaceCreateInfoQNX.Ptr	VkScreenSurfaceCreateInfoQNX.Ptr.reinterpret(long newSize)	Assume the VkScreenSurfaceCreateInfoQNX.Ptr is capable of holding at least newSize structures, create a new view VkScreenSurfaceCreateInfoQNX.Ptr that uses the same backing storage as this VkScreenSurfaceCreateInfoQNX.Ptr, but with the new size.
@NotNull VkSemaphoreCreateInfo.Ptr	VkSemaphoreCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkSemaphoreCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkSemaphoreCreateInfo.Ptr that uses the same backing storage as this VkSemaphoreCreateInfo.Ptr, but with the new size.
@NotNull VkSemaphoreGetFdInfoKHR.Ptr	VkSemaphoreGetFdInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkSemaphoreGetFdInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkSemaphoreGetFdInfoKHR.Ptr that uses the same backing storage as this VkSemaphoreGetFdInfoKHR.Ptr, but with the new size.
@NotNull VkSemaphoreGetSciSyncInfoNV.Ptr	VkSemaphoreGetSciSyncInfoNV.Ptr.reinterpret(long newSize)	Assume the VkSemaphoreGetSciSyncInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkSemaphoreGetSciSyncInfoNV.Ptr that uses the same backing storage as this VkSemaphoreGetSciSyncInfoNV.Ptr, but with the new size.
@NotNull VkSemaphoreGetWin32HandleInfoKHR.Ptr	VkSemaphoreGetWin32HandleInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkSemaphoreGetWin32HandleInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkSemaphoreGetWin32HandleInfoKHR.Ptr that uses the same backing storage as this VkSemaphoreGetWin32HandleInfoKHR.Ptr, but with the new size.
@NotNull VkSemaphoreGetZirconHandleInfoFUCHSIA.Ptr	VkSemaphoreGetZirconHandleInfoFUCHSIA.Ptr.reinterpret(long newSize)	Assume the VkSemaphoreGetZirconHandleInfoFUCHSIA.Ptr is capable of holding at least newSize structures, create a new view VkSemaphoreGetZirconHandleInfoFUCHSIA.Ptr that uses the same backing storage as this VkSemaphoreGetZirconHandleInfoFUCHSIA.Ptr, but with the new size.
@NotNull VkSemaphoreSciSyncCreateInfoNV.Ptr	VkSemaphoreSciSyncCreateInfoNV.Ptr.reinterpret(long newSize)	Assume the VkSemaphoreSciSyncCreateInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkSemaphoreSciSyncCreateInfoNV.Ptr that uses the same backing storage as this VkSemaphoreSciSyncCreateInfoNV.Ptr, but with the new size.
@NotNull VkSemaphoreSciSyncPoolCreateInfoNV.Ptr	VkSemaphoreSciSyncPoolCreateInfoNV.Ptr.reinterpret(long newSize)	Assume the VkSemaphoreSciSyncPoolCreateInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkSemaphoreSciSyncPoolCreateInfoNV.Ptr that uses the same backing storage as this VkSemaphoreSciSyncPoolCreateInfoNV.Ptr, but with the new size.
@NotNull VkSemaphoreSignalInfo.Ptr	VkSemaphoreSignalInfo.Ptr.reinterpret(long newSize)	Assume the VkSemaphoreSignalInfo.Ptr is capable of holding at least newSize structures, create a new view VkSemaphoreSignalInfo.Ptr that uses the same backing storage as this VkSemaphoreSignalInfo.Ptr, but with the new size.
@NotNull VkSemaphoreSubmitInfo.Ptr	VkSemaphoreSubmitInfo.Ptr.reinterpret(long newSize)	Assume the VkSemaphoreSubmitInfo.Ptr is capable of holding at least newSize structures, create a new view VkSemaphoreSubmitInfo.Ptr that uses the same backing storage as this VkSemaphoreSubmitInfo.Ptr, but with the new size.
@NotNull VkSemaphoreTypeCreateInfo.Ptr	VkSemaphoreTypeCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkSemaphoreTypeCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkSemaphoreTypeCreateInfo.Ptr that uses the same backing storage as this VkSemaphoreTypeCreateInfo.Ptr, but with the new size.
@NotNull VkSemaphoreWaitInfo.Ptr	VkSemaphoreWaitInfo.Ptr.reinterpret(long newSize)	Assume the VkSemaphoreWaitInfo.Ptr is capable of holding at least newSize structures, create a new view VkSemaphoreWaitInfo.Ptr that uses the same backing storage as this VkSemaphoreWaitInfo.Ptr, but with the new size.
@NotNull VkSetDescriptorBufferOffsetsInfoEXT.Ptr	VkSetDescriptorBufferOffsetsInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkSetDescriptorBufferOffsetsInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkSetDescriptorBufferOffsetsInfoEXT.Ptr that uses the same backing storage as this VkSetDescriptorBufferOffsetsInfoEXT.Ptr, but with the new size.
@NotNull VkSetLatencyMarkerInfoNV.Ptr	VkSetLatencyMarkerInfoNV.Ptr.reinterpret(long newSize)	Assume the VkSetLatencyMarkerInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkSetLatencyMarkerInfoNV.Ptr that uses the same backing storage as this VkSetLatencyMarkerInfoNV.Ptr, but with the new size.
@NotNull VkSetPresentConfigNV.Ptr	VkSetPresentConfigNV.Ptr.reinterpret(long newSize)	Assume the VkSetPresentConfigNV.Ptr is capable of holding at least newSize structures, create a new view VkSetPresentConfigNV.Ptr that uses the same backing storage as this VkSetPresentConfigNV.Ptr, but with the new size.
@NotNull VkSetStateFlagsIndirectCommandNV.Ptr	VkSetStateFlagsIndirectCommandNV.Ptr.reinterpret(long newSize)	Assume the VkSetStateFlagsIndirectCommandNV.Ptr is capable of holding at least newSize structures, create a new view VkSetStateFlagsIndirectCommandNV.Ptr that uses the same backing storage as this VkSetStateFlagsIndirectCommandNV.Ptr, but with the new size.
@NotNull VkShaderCreateInfoEXT.Ptr	VkShaderCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkShaderCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkShaderCreateInfoEXT.Ptr that uses the same backing storage as this VkShaderCreateInfoEXT.Ptr, but with the new size.
@NotNull VkShaderModuleCreateInfo.Ptr	VkShaderModuleCreateInfo.Ptr.reinterpret(long newSize)	Assume the VkShaderModuleCreateInfo.Ptr is capable of holding at least newSize structures, create a new view VkShaderModuleCreateInfo.Ptr that uses the same backing storage as this VkShaderModuleCreateInfo.Ptr, but with the new size.
@NotNull VkShaderModuleIdentifierEXT.Ptr	VkShaderModuleIdentifierEXT.Ptr.reinterpret(long newSize)	Assume the VkShaderModuleIdentifierEXT.Ptr is capable of holding at least newSize structures, create a new view VkShaderModuleIdentifierEXT.Ptr that uses the same backing storage as this VkShaderModuleIdentifierEXT.Ptr, but with the new size.
@NotNull VkShaderModuleValidationCacheCreateInfoEXT.Ptr	VkShaderModuleValidationCacheCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkShaderModuleValidationCacheCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkShaderModuleValidationCacheCreateInfoEXT.Ptr that uses the same backing storage as this VkShaderModuleValidationCacheCreateInfoEXT.Ptr, but with the new size.
@NotNull VkShaderResourceUsageAMD.Ptr	VkShaderResourceUsageAMD.Ptr.reinterpret(long newSize)	Assume the VkShaderResourceUsageAMD.Ptr is capable of holding at least newSize structures, create a new view VkShaderResourceUsageAMD.Ptr that uses the same backing storage as this VkShaderResourceUsageAMD.Ptr, but with the new size.
@NotNull VkShaderStatisticsInfoAMD.Ptr	VkShaderStatisticsInfoAMD.Ptr.reinterpret(long newSize)	Assume the VkShaderStatisticsInfoAMD.Ptr is capable of holding at least newSize structures, create a new view VkShaderStatisticsInfoAMD.Ptr that uses the same backing storage as this VkShaderStatisticsInfoAMD.Ptr, but with the new size.
@NotNull VkShadingRatePaletteNV.Ptr	VkShadingRatePaletteNV.Ptr.reinterpret(long newSize)	Assume the VkShadingRatePaletteNV.Ptr is capable of holding at least newSize structures, create a new view VkShadingRatePaletteNV.Ptr that uses the same backing storage as this VkShadingRatePaletteNV.Ptr, but with the new size.
@NotNull VkSharedPresentSurfaceCapabilitiesKHR.Ptr	VkSharedPresentSurfaceCapabilitiesKHR.Ptr.reinterpret(long newSize)	Assume the VkSharedPresentSurfaceCapabilitiesKHR.Ptr is capable of holding at least newSize structures, create a new view VkSharedPresentSurfaceCapabilitiesKHR.Ptr that uses the same backing storage as this VkSharedPresentSurfaceCapabilitiesKHR.Ptr, but with the new size.
@NotNull VkSparseBufferMemoryBindInfo.Ptr	VkSparseBufferMemoryBindInfo.Ptr.reinterpret(long newSize)	Assume the VkSparseBufferMemoryBindInfo.Ptr is capable of holding at least newSize structures, create a new view VkSparseBufferMemoryBindInfo.Ptr that uses the same backing storage as this VkSparseBufferMemoryBindInfo.Ptr, but with the new size.
@NotNull VkSparseImageFormatProperties.Ptr	VkSparseImageFormatProperties.Ptr.reinterpret(long newSize)	Assume the VkSparseImageFormatProperties.Ptr is capable of holding at least newSize structures, create a new view VkSparseImageFormatProperties.Ptr that uses the same backing storage as this VkSparseImageFormatProperties.Ptr, but with the new size.
@NotNull VkSparseImageFormatProperties2.Ptr	VkSparseImageFormatProperties2.Ptr.reinterpret(long newSize)	Assume the VkSparseImageFormatProperties2.Ptr is capable of holding at least newSize structures, create a new view VkSparseImageFormatProperties2.Ptr that uses the same backing storage as this VkSparseImageFormatProperties2.Ptr, but with the new size.
@NotNull VkSparseImageMemoryBind.Ptr	VkSparseImageMemoryBind.Ptr.reinterpret(long newSize)	Assume the VkSparseImageMemoryBind.Ptr is capable of holding at least newSize structures, create a new view VkSparseImageMemoryBind.Ptr that uses the same backing storage as this VkSparseImageMemoryBind.Ptr, but with the new size.
@NotNull VkSparseImageMemoryBindInfo.Ptr	VkSparseImageMemoryBindInfo.Ptr.reinterpret(long newSize)	Assume the VkSparseImageMemoryBindInfo.Ptr is capable of holding at least newSize structures, create a new view VkSparseImageMemoryBindInfo.Ptr that uses the same backing storage as this VkSparseImageMemoryBindInfo.Ptr, but with the new size.
@NotNull VkSparseImageMemoryRequirements.Ptr	VkSparseImageMemoryRequirements.Ptr.reinterpret(long newSize)	Assume the VkSparseImageMemoryRequirements.Ptr is capable of holding at least newSize structures, create a new view VkSparseImageMemoryRequirements.Ptr that uses the same backing storage as this VkSparseImageMemoryRequirements.Ptr, but with the new size.
@NotNull VkSparseImageMemoryRequirements2.Ptr	VkSparseImageMemoryRequirements2.Ptr.reinterpret(long newSize)	Assume the VkSparseImageMemoryRequirements2.Ptr is capable of holding at least newSize structures, create a new view VkSparseImageMemoryRequirements2.Ptr that uses the same backing storage as this VkSparseImageMemoryRequirements2.Ptr, but with the new size.
@NotNull VkSparseImageOpaqueMemoryBindInfo.Ptr	VkSparseImageOpaqueMemoryBindInfo.Ptr.reinterpret(long newSize)	Assume the VkSparseImageOpaqueMemoryBindInfo.Ptr is capable of holding at least newSize structures, create a new view VkSparseImageOpaqueMemoryBindInfo.Ptr that uses the same backing storage as this VkSparseImageOpaqueMemoryBindInfo.Ptr, but with the new size.
@NotNull VkSparseMemoryBind.Ptr	VkSparseMemoryBind.Ptr.reinterpret(long newSize)	Assume the VkSparseMemoryBind.Ptr is capable of holding at least newSize structures, create a new view VkSparseMemoryBind.Ptr that uses the same backing storage as this VkSparseMemoryBind.Ptr, but with the new size.
@NotNull VkSpecializationInfo.Ptr	VkSpecializationInfo.Ptr.reinterpret(long newSize)	Assume the VkSpecializationInfo.Ptr is capable of holding at least newSize structures, create a new view VkSpecializationInfo.Ptr that uses the same backing storage as this VkSpecializationInfo.Ptr, but with the new size.
@NotNull VkSpecializationMapEntry.Ptr	VkSpecializationMapEntry.Ptr.reinterpret(long newSize)	Assume the VkSpecializationMapEntry.Ptr is capable of holding at least newSize structures, create a new view VkSpecializationMapEntry.Ptr that uses the same backing storage as this VkSpecializationMapEntry.Ptr, but with the new size.
@NotNull VkSRTDataNV.Ptr	VkSRTDataNV.Ptr.reinterpret(long newSize)	Assume the VkSRTDataNV.Ptr is capable of holding at least newSize structures, create a new view VkSRTDataNV.Ptr that uses the same backing storage as this VkSRTDataNV.Ptr, but with the new size.
@NotNull VkStencilOpState.Ptr	VkStencilOpState.Ptr.reinterpret(long newSize)	Assume the VkStencilOpState.Ptr is capable of holding at least newSize structures, create a new view VkStencilOpState.Ptr that uses the same backing storage as this VkStencilOpState.Ptr, but with the new size.
@NotNull VkStreamDescriptorSurfaceCreateInfoGGP.Ptr	VkStreamDescriptorSurfaceCreateInfoGGP.Ptr.reinterpret(long newSize)	Assume the VkStreamDescriptorSurfaceCreateInfoGGP.Ptr is capable of holding at least newSize structures, create a new view VkStreamDescriptorSurfaceCreateInfoGGP.Ptr that uses the same backing storage as this VkStreamDescriptorSurfaceCreateInfoGGP.Ptr, but with the new size.
@NotNull VkStridedDeviceAddressNV.Ptr	VkStridedDeviceAddressNV.Ptr.reinterpret(long newSize)	Assume the VkStridedDeviceAddressNV.Ptr is capable of holding at least newSize structures, create a new view VkStridedDeviceAddressNV.Ptr that uses the same backing storage as this VkStridedDeviceAddressNV.Ptr, but with the new size.
@NotNull VkStridedDeviceAddressRegionKHR.Ptr	VkStridedDeviceAddressRegionKHR.Ptr.reinterpret(long newSize)	Assume the VkStridedDeviceAddressRegionKHR.Ptr is capable of holding at least newSize structures, create a new view VkStridedDeviceAddressRegionKHR.Ptr that uses the same backing storage as this VkStridedDeviceAddressRegionKHR.Ptr, but with the new size.
@NotNull VkSubmitInfo.Ptr	VkSubmitInfo.Ptr.reinterpret(long newSize)	Assume the VkSubmitInfo.Ptr is capable of holding at least newSize structures, create a new view VkSubmitInfo.Ptr that uses the same backing storage as this VkSubmitInfo.Ptr, but with the new size.
@NotNull VkSubmitInfo2.Ptr	VkSubmitInfo2.Ptr.reinterpret(long newSize)	Assume the VkSubmitInfo2.Ptr is capable of holding at least newSize structures, create a new view VkSubmitInfo2.Ptr that uses the same backing storage as this VkSubmitInfo2.Ptr, but with the new size.
@NotNull VkSubpassBeginInfo.Ptr	VkSubpassBeginInfo.Ptr.reinterpret(long newSize)	Assume the VkSubpassBeginInfo.Ptr is capable of holding at least newSize structures, create a new view VkSubpassBeginInfo.Ptr that uses the same backing storage as this VkSubpassBeginInfo.Ptr, but with the new size.
@NotNull VkSubpassDependency.Ptr	VkSubpassDependency.Ptr.reinterpret(long newSize)	Assume the VkSubpassDependency.Ptr is capable of holding at least newSize structures, create a new view VkSubpassDependency.Ptr that uses the same backing storage as this VkSubpassDependency.Ptr, but with the new size.
@NotNull VkSubpassDependency2.Ptr	VkSubpassDependency2.Ptr.reinterpret(long newSize)	Assume the VkSubpassDependency2.Ptr is capable of holding at least newSize structures, create a new view VkSubpassDependency2.Ptr that uses the same backing storage as this VkSubpassDependency2.Ptr, but with the new size.
@NotNull VkSubpassDescription.Ptr	VkSubpassDescription.Ptr.reinterpret(long newSize)	Assume the VkSubpassDescription.Ptr is capable of holding at least newSize structures, create a new view VkSubpassDescription.Ptr that uses the same backing storage as this VkSubpassDescription.Ptr, but with the new size.
@NotNull VkSubpassDescription2.Ptr	VkSubpassDescription2.Ptr.reinterpret(long newSize)	Assume the VkSubpassDescription2.Ptr is capable of holding at least newSize structures, create a new view VkSubpassDescription2.Ptr that uses the same backing storage as this VkSubpassDescription2.Ptr, but with the new size.
@NotNull VkSubpassDescriptionDepthStencilResolve.Ptr	VkSubpassDescriptionDepthStencilResolve.Ptr.reinterpret(long newSize)	Assume the VkSubpassDescriptionDepthStencilResolve.Ptr is capable of holding at least newSize structures, create a new view VkSubpassDescriptionDepthStencilResolve.Ptr that uses the same backing storage as this VkSubpassDescriptionDepthStencilResolve.Ptr, but with the new size.
@NotNull VkSubpassEndInfo.Ptr	VkSubpassEndInfo.Ptr.reinterpret(long newSize)	Assume the VkSubpassEndInfo.Ptr is capable of holding at least newSize structures, create a new view VkSubpassEndInfo.Ptr that uses the same backing storage as this VkSubpassEndInfo.Ptr, but with the new size.
@NotNull VkSubpassResolvePerformanceQueryEXT.Ptr	VkSubpassResolvePerformanceQueryEXT.Ptr.reinterpret(long newSize)	Assume the VkSubpassResolvePerformanceQueryEXT.Ptr is capable of holding at least newSize structures, create a new view VkSubpassResolvePerformanceQueryEXT.Ptr that uses the same backing storage as this VkSubpassResolvePerformanceQueryEXT.Ptr, but with the new size.
@NotNull VkSubpassSampleLocationsEXT.Ptr	VkSubpassSampleLocationsEXT.Ptr.reinterpret(long newSize)	Assume the VkSubpassSampleLocationsEXT.Ptr is capable of holding at least newSize structures, create a new view VkSubpassSampleLocationsEXT.Ptr that uses the same backing storage as this VkSubpassSampleLocationsEXT.Ptr, but with the new size.
@NotNull VkSubpassShadingPipelineCreateInfoHUAWEI.Ptr	VkSubpassShadingPipelineCreateInfoHUAWEI.Ptr.reinterpret(long newSize)	Assume the VkSubpassShadingPipelineCreateInfoHUAWEI.Ptr is capable of holding at least newSize structures, create a new view VkSubpassShadingPipelineCreateInfoHUAWEI.Ptr that uses the same backing storage as this VkSubpassShadingPipelineCreateInfoHUAWEI.Ptr, but with the new size.
@NotNull VkSubresourceHostMemcpySize.Ptr	VkSubresourceHostMemcpySize.Ptr.reinterpret(long newSize)	Assume the VkSubresourceHostMemcpySize.Ptr is capable of holding at least newSize structures, create a new view VkSubresourceHostMemcpySize.Ptr that uses the same backing storage as this VkSubresourceHostMemcpySize.Ptr, but with the new size.
@NotNull VkSubresourceLayout.Ptr	VkSubresourceLayout.Ptr.reinterpret(long newSize)	Assume the VkSubresourceLayout.Ptr is capable of holding at least newSize structures, create a new view VkSubresourceLayout.Ptr that uses the same backing storage as this VkSubresourceLayout.Ptr, but with the new size.
@NotNull VkSubresourceLayout2.Ptr	VkSubresourceLayout2.Ptr.reinterpret(long newSize)	Assume the VkSubresourceLayout2.Ptr is capable of holding at least newSize structures, create a new view VkSubresourceLayout2.Ptr that uses the same backing storage as this VkSubresourceLayout2.Ptr, but with the new size.
@NotNull VkSurfaceCapabilities2EXT.Ptr	VkSurfaceCapabilities2EXT.Ptr.reinterpret(long newSize)	Assume the VkSurfaceCapabilities2EXT.Ptr is capable of holding at least newSize structures, create a new view VkSurfaceCapabilities2EXT.Ptr that uses the same backing storage as this VkSurfaceCapabilities2EXT.Ptr, but with the new size.
@NotNull VkSurfaceCapabilities2KHR.Ptr	VkSurfaceCapabilities2KHR.Ptr.reinterpret(long newSize)	Assume the VkSurfaceCapabilities2KHR.Ptr is capable of holding at least newSize structures, create a new view VkSurfaceCapabilities2KHR.Ptr that uses the same backing storage as this VkSurfaceCapabilities2KHR.Ptr, but with the new size.
@NotNull VkSurfaceCapabilitiesFullScreenExclusiveEXT.Ptr	VkSurfaceCapabilitiesFullScreenExclusiveEXT.Ptr.reinterpret(long newSize)	Assume the VkSurfaceCapabilitiesFullScreenExclusiveEXT.Ptr is capable of holding at least newSize structures, create a new view VkSurfaceCapabilitiesFullScreenExclusiveEXT.Ptr that uses the same backing storage as this VkSurfaceCapabilitiesFullScreenExclusiveEXT.Ptr, but with the new size.
@NotNull VkSurfaceCapabilitiesKHR.Ptr	VkSurfaceCapabilitiesKHR.Ptr.reinterpret(long newSize)	Assume the VkSurfaceCapabilitiesKHR.Ptr is capable of holding at least newSize structures, create a new view VkSurfaceCapabilitiesKHR.Ptr that uses the same backing storage as this VkSurfaceCapabilitiesKHR.Ptr, but with the new size.
@NotNull VkSurfaceCapabilitiesPresentBarrierNV.Ptr	VkSurfaceCapabilitiesPresentBarrierNV.Ptr.reinterpret(long newSize)	Assume the VkSurfaceCapabilitiesPresentBarrierNV.Ptr is capable of holding at least newSize structures, create a new view VkSurfaceCapabilitiesPresentBarrierNV.Ptr that uses the same backing storage as this VkSurfaceCapabilitiesPresentBarrierNV.Ptr, but with the new size.
@NotNull VkSurfaceFormat2KHR.Ptr	VkSurfaceFormat2KHR.Ptr.reinterpret(long newSize)	Assume the VkSurfaceFormat2KHR.Ptr is capable of holding at least newSize structures, create a new view VkSurfaceFormat2KHR.Ptr that uses the same backing storage as this VkSurfaceFormat2KHR.Ptr, but with the new size.
@NotNull VkSurfaceFormatKHR.Ptr	VkSurfaceFormatKHR.Ptr.reinterpret(long newSize)	Assume the VkSurfaceFormatKHR.Ptr is capable of holding at least newSize structures, create a new view VkSurfaceFormatKHR.Ptr that uses the same backing storage as this VkSurfaceFormatKHR.Ptr, but with the new size.
@NotNull VkSurfaceFullScreenExclusiveInfoEXT.Ptr	VkSurfaceFullScreenExclusiveInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkSurfaceFullScreenExclusiveInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkSurfaceFullScreenExclusiveInfoEXT.Ptr that uses the same backing storage as this VkSurfaceFullScreenExclusiveInfoEXT.Ptr, but with the new size.
@NotNull VkSurfaceFullScreenExclusiveWin32InfoEXT.Ptr	VkSurfaceFullScreenExclusiveWin32InfoEXT.Ptr.reinterpret(long newSize)	Assume the VkSurfaceFullScreenExclusiveWin32InfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkSurfaceFullScreenExclusiveWin32InfoEXT.Ptr that uses the same backing storage as this VkSurfaceFullScreenExclusiveWin32InfoEXT.Ptr, but with the new size.
@NotNull VkSurfacePresentModeCompatibilityEXT.Ptr	VkSurfacePresentModeCompatibilityEXT.Ptr.reinterpret(long newSize)	Assume the VkSurfacePresentModeCompatibilityEXT.Ptr is capable of holding at least newSize structures, create a new view VkSurfacePresentModeCompatibilityEXT.Ptr that uses the same backing storage as this VkSurfacePresentModeCompatibilityEXT.Ptr, but with the new size.
@NotNull VkSurfacePresentModeEXT.Ptr	VkSurfacePresentModeEXT.Ptr.reinterpret(long newSize)	Assume the VkSurfacePresentModeEXT.Ptr is capable of holding at least newSize structures, create a new view VkSurfacePresentModeEXT.Ptr that uses the same backing storage as this VkSurfacePresentModeEXT.Ptr, but with the new size.
@NotNull VkSurfacePresentScalingCapabilitiesEXT.Ptr	VkSurfacePresentScalingCapabilitiesEXT.Ptr.reinterpret(long newSize)	Assume the VkSurfacePresentScalingCapabilitiesEXT.Ptr is capable of holding at least newSize structures, create a new view VkSurfacePresentScalingCapabilitiesEXT.Ptr that uses the same backing storage as this VkSurfacePresentScalingCapabilitiesEXT.Ptr, but with the new size.
@NotNull VkSurfaceProtectedCapabilitiesKHR.Ptr	VkSurfaceProtectedCapabilitiesKHR.Ptr.reinterpret(long newSize)	Assume the VkSurfaceProtectedCapabilitiesKHR.Ptr is capable of holding at least newSize structures, create a new view VkSurfaceProtectedCapabilitiesKHR.Ptr that uses the same backing storage as this VkSurfaceProtectedCapabilitiesKHR.Ptr, but with the new size.
@NotNull VkSwapchainCounterCreateInfoEXT.Ptr	VkSwapchainCounterCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkSwapchainCounterCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkSwapchainCounterCreateInfoEXT.Ptr that uses the same backing storage as this VkSwapchainCounterCreateInfoEXT.Ptr, but with the new size.
@NotNull VkSwapchainCreateInfoKHR.Ptr	VkSwapchainCreateInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkSwapchainCreateInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkSwapchainCreateInfoKHR.Ptr that uses the same backing storage as this VkSwapchainCreateInfoKHR.Ptr, but with the new size.
@NotNull VkSwapchainDisplayNativeHdrCreateInfoAMD.Ptr	VkSwapchainDisplayNativeHdrCreateInfoAMD.Ptr.reinterpret(long newSize)	Assume the VkSwapchainDisplayNativeHdrCreateInfoAMD.Ptr is capable of holding at least newSize structures, create a new view VkSwapchainDisplayNativeHdrCreateInfoAMD.Ptr that uses the same backing storage as this VkSwapchainDisplayNativeHdrCreateInfoAMD.Ptr, but with the new size.
@NotNull VkSwapchainLatencyCreateInfoNV.Ptr	VkSwapchainLatencyCreateInfoNV.Ptr.reinterpret(long newSize)	Assume the VkSwapchainLatencyCreateInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkSwapchainLatencyCreateInfoNV.Ptr that uses the same backing storage as this VkSwapchainLatencyCreateInfoNV.Ptr, but with the new size.
@NotNull VkSwapchainPresentBarrierCreateInfoNV.Ptr	VkSwapchainPresentBarrierCreateInfoNV.Ptr.reinterpret(long newSize)	Assume the VkSwapchainPresentBarrierCreateInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkSwapchainPresentBarrierCreateInfoNV.Ptr that uses the same backing storage as this VkSwapchainPresentBarrierCreateInfoNV.Ptr, but with the new size.
@NotNull VkSwapchainPresentFenceInfoEXT.Ptr	VkSwapchainPresentFenceInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkSwapchainPresentFenceInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkSwapchainPresentFenceInfoEXT.Ptr that uses the same backing storage as this VkSwapchainPresentFenceInfoEXT.Ptr, but with the new size.
@NotNull VkSwapchainPresentModeInfoEXT.Ptr	VkSwapchainPresentModeInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkSwapchainPresentModeInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkSwapchainPresentModeInfoEXT.Ptr that uses the same backing storage as this VkSwapchainPresentModeInfoEXT.Ptr, but with the new size.
@NotNull VkSwapchainPresentModesCreateInfoEXT.Ptr	VkSwapchainPresentModesCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkSwapchainPresentModesCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkSwapchainPresentModesCreateInfoEXT.Ptr that uses the same backing storage as this VkSwapchainPresentModesCreateInfoEXT.Ptr, but with the new size.
@NotNull VkSwapchainPresentScalingCreateInfoEXT.Ptr	VkSwapchainPresentScalingCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkSwapchainPresentScalingCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkSwapchainPresentScalingCreateInfoEXT.Ptr that uses the same backing storage as this VkSwapchainPresentScalingCreateInfoEXT.Ptr, but with the new size.
@NotNull VkSysmemColorSpaceFUCHSIA.Ptr	VkSysmemColorSpaceFUCHSIA.Ptr.reinterpret(long newSize)	Assume the VkSysmemColorSpaceFUCHSIA.Ptr is capable of holding at least newSize structures, create a new view VkSysmemColorSpaceFUCHSIA.Ptr that uses the same backing storage as this VkSysmemColorSpaceFUCHSIA.Ptr, but with the new size.
@NotNull VkTextureLODGatherFormatPropertiesAMD.Ptr	VkTextureLODGatherFormatPropertiesAMD.Ptr.reinterpret(long newSize)	Assume the VkTextureLODGatherFormatPropertiesAMD.Ptr is capable of holding at least newSize structures, create a new view VkTextureLODGatherFormatPropertiesAMD.Ptr that uses the same backing storage as this VkTextureLODGatherFormatPropertiesAMD.Ptr, but with the new size.
@NotNull VkTileMemoryBindInfoQCOM.Ptr	VkTileMemoryBindInfoQCOM.Ptr.reinterpret(long newSize)	Assume the VkTileMemoryBindInfoQCOM.Ptr is capable of holding at least newSize structures, create a new view VkTileMemoryBindInfoQCOM.Ptr that uses the same backing storage as this VkTileMemoryBindInfoQCOM.Ptr, but with the new size.
@NotNull VkTileMemoryRequirementsQCOM.Ptr	VkTileMemoryRequirementsQCOM.Ptr.reinterpret(long newSize)	Assume the VkTileMemoryRequirementsQCOM.Ptr is capable of holding at least newSize structures, create a new view VkTileMemoryRequirementsQCOM.Ptr that uses the same backing storage as this VkTileMemoryRequirementsQCOM.Ptr, but with the new size.
@NotNull VkTileMemorySizeInfoQCOM.Ptr	VkTileMemorySizeInfoQCOM.Ptr.reinterpret(long newSize)	Assume the VkTileMemorySizeInfoQCOM.Ptr is capable of holding at least newSize structures, create a new view VkTileMemorySizeInfoQCOM.Ptr that uses the same backing storage as this VkTileMemorySizeInfoQCOM.Ptr, but with the new size.
@NotNull VkTilePropertiesQCOM.Ptr	VkTilePropertiesQCOM.Ptr.reinterpret(long newSize)	Assume the VkTilePropertiesQCOM.Ptr is capable of holding at least newSize structures, create a new view VkTilePropertiesQCOM.Ptr that uses the same backing storage as this VkTilePropertiesQCOM.Ptr, but with the new size.
@NotNull VkTimelineSemaphoreSubmitInfo.Ptr	VkTimelineSemaphoreSubmitInfo.Ptr.reinterpret(long newSize)	Assume the VkTimelineSemaphoreSubmitInfo.Ptr is capable of holding at least newSize structures, create a new view VkTimelineSemaphoreSubmitInfo.Ptr that uses the same backing storage as this VkTimelineSemaphoreSubmitInfo.Ptr, but with the new size.
@NotNull VkTraceRaysIndirectCommand2KHR.Ptr	VkTraceRaysIndirectCommand2KHR.Ptr.reinterpret(long newSize)	Assume the VkTraceRaysIndirectCommand2KHR.Ptr is capable of holding at least newSize structures, create a new view VkTraceRaysIndirectCommand2KHR.Ptr that uses the same backing storage as this VkTraceRaysIndirectCommand2KHR.Ptr, but with the new size.
@NotNull VkTraceRaysIndirectCommandKHR.Ptr	VkTraceRaysIndirectCommandKHR.Ptr.reinterpret(long newSize)	Assume the VkTraceRaysIndirectCommandKHR.Ptr is capable of holding at least newSize structures, create a new view VkTraceRaysIndirectCommandKHR.Ptr that uses the same backing storage as this VkTraceRaysIndirectCommandKHR.Ptr, but with the new size.
@NotNull VkTransformMatrixKHR.Ptr	VkTransformMatrixKHR.Ptr.reinterpret(long newSize)	Assume the VkTransformMatrixKHR.Ptr is capable of holding at least newSize structures, create a new view VkTransformMatrixKHR.Ptr that uses the same backing storage as this VkTransformMatrixKHR.Ptr, but with the new size.
@NotNull VkValidationCacheCreateInfoEXT.Ptr	VkValidationCacheCreateInfoEXT.Ptr.reinterpret(long newSize)	Assume the VkValidationCacheCreateInfoEXT.Ptr is capable of holding at least newSize structures, create a new view VkValidationCacheCreateInfoEXT.Ptr that uses the same backing storage as this VkValidationCacheCreateInfoEXT.Ptr, but with the new size.
@NotNull VkValidationFeaturesEXT.Ptr	VkValidationFeaturesEXT.Ptr.reinterpret(long newSize)	Assume the VkValidationFeaturesEXT.Ptr is capable of holding at least newSize structures, create a new view VkValidationFeaturesEXT.Ptr that uses the same backing storage as this VkValidationFeaturesEXT.Ptr, but with the new size.
@NotNull VkValidationFlagsEXT.Ptr	VkValidationFlagsEXT.Ptr.reinterpret(long newSize)	Assume the VkValidationFlagsEXT.Ptr is capable of holding at least newSize structures, create a new view VkValidationFlagsEXT.Ptr that uses the same backing storage as this VkValidationFlagsEXT.Ptr, but with the new size.
@NotNull VkVertexInputAttributeDescription.Ptr	VkVertexInputAttributeDescription.Ptr.reinterpret(long newSize)	Assume the VkVertexInputAttributeDescription.Ptr is capable of holding at least newSize structures, create a new view VkVertexInputAttributeDescription.Ptr that uses the same backing storage as this VkVertexInputAttributeDescription.Ptr, but with the new size.
@NotNull VkVertexInputAttributeDescription2EXT.Ptr	VkVertexInputAttributeDescription2EXT.Ptr.reinterpret(long newSize)	Assume the VkVertexInputAttributeDescription2EXT.Ptr is capable of holding at least newSize structures, create a new view VkVertexInputAttributeDescription2EXT.Ptr that uses the same backing storage as this VkVertexInputAttributeDescription2EXT.Ptr, but with the new size.
@NotNull VkVertexInputBindingDescription.Ptr	VkVertexInputBindingDescription.Ptr.reinterpret(long newSize)	Assume the VkVertexInputBindingDescription.Ptr is capable of holding at least newSize structures, create a new view VkVertexInputBindingDescription.Ptr that uses the same backing storage as this VkVertexInputBindingDescription.Ptr, but with the new size.
@NotNull VkVertexInputBindingDescription2EXT.Ptr	VkVertexInputBindingDescription2EXT.Ptr.reinterpret(long newSize)	Assume the VkVertexInputBindingDescription2EXT.Ptr is capable of holding at least newSize structures, create a new view VkVertexInputBindingDescription2EXT.Ptr that uses the same backing storage as this VkVertexInputBindingDescription2EXT.Ptr, but with the new size.
@NotNull VkVertexInputBindingDivisorDescription.Ptr	VkVertexInputBindingDivisorDescription.Ptr.reinterpret(long newSize)	Assume the VkVertexInputBindingDivisorDescription.Ptr is capable of holding at least newSize structures, create a new view VkVertexInputBindingDivisorDescription.Ptr that uses the same backing storage as this VkVertexInputBindingDivisorDescription.Ptr, but with the new size.
@NotNull VkVideoBeginCodingInfoKHR.Ptr	VkVideoBeginCodingInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoBeginCodingInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoBeginCodingInfoKHR.Ptr that uses the same backing storage as this VkVideoBeginCodingInfoKHR.Ptr, but with the new size.
@NotNull VkVideoCapabilitiesKHR.Ptr	VkVideoCapabilitiesKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoCapabilitiesKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoCapabilitiesKHR.Ptr that uses the same backing storage as this VkVideoCapabilitiesKHR.Ptr, but with the new size.
@NotNull VkVideoCodingControlInfoKHR.Ptr	VkVideoCodingControlInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoCodingControlInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoCodingControlInfoKHR.Ptr that uses the same backing storage as this VkVideoCodingControlInfoKHR.Ptr, but with the new size.
@NotNull VkVideoDecodeAV1CapabilitiesKHR.Ptr	VkVideoDecodeAV1CapabilitiesKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoDecodeAV1CapabilitiesKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoDecodeAV1CapabilitiesKHR.Ptr that uses the same backing storage as this VkVideoDecodeAV1CapabilitiesKHR.Ptr, but with the new size.
@NotNull VkVideoDecodeAV1DpbSlotInfoKHR.Ptr	VkVideoDecodeAV1DpbSlotInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoDecodeAV1DpbSlotInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoDecodeAV1DpbSlotInfoKHR.Ptr that uses the same backing storage as this VkVideoDecodeAV1DpbSlotInfoKHR.Ptr, but with the new size.
@NotNull VkVideoDecodeAV1InlineSessionParametersInfoKHR.Ptr	VkVideoDecodeAV1InlineSessionParametersInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoDecodeAV1InlineSessionParametersInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoDecodeAV1InlineSessionParametersInfoKHR.Ptr that uses the same backing storage as this VkVideoDecodeAV1InlineSessionParametersInfoKHR.Ptr, but with the new size.
@NotNull VkVideoDecodeAV1PictureInfoKHR.Ptr	VkVideoDecodeAV1PictureInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoDecodeAV1PictureInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoDecodeAV1PictureInfoKHR.Ptr that uses the same backing storage as this VkVideoDecodeAV1PictureInfoKHR.Ptr, but with the new size.
@NotNull VkVideoDecodeAV1ProfileInfoKHR.Ptr	VkVideoDecodeAV1ProfileInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoDecodeAV1ProfileInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoDecodeAV1ProfileInfoKHR.Ptr that uses the same backing storage as this VkVideoDecodeAV1ProfileInfoKHR.Ptr, but with the new size.
@NotNull VkVideoDecodeAV1SessionParametersCreateInfoKHR.Ptr	VkVideoDecodeAV1SessionParametersCreateInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoDecodeAV1SessionParametersCreateInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoDecodeAV1SessionParametersCreateInfoKHR.Ptr that uses the same backing storage as this VkVideoDecodeAV1SessionParametersCreateInfoKHR.Ptr, but with the new size.
@NotNull VkVideoDecodeCapabilitiesKHR.Ptr	VkVideoDecodeCapabilitiesKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoDecodeCapabilitiesKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoDecodeCapabilitiesKHR.Ptr that uses the same backing storage as this VkVideoDecodeCapabilitiesKHR.Ptr, but with the new size.
@NotNull VkVideoDecodeH264CapabilitiesKHR.Ptr	VkVideoDecodeH264CapabilitiesKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoDecodeH264CapabilitiesKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoDecodeH264CapabilitiesKHR.Ptr that uses the same backing storage as this VkVideoDecodeH264CapabilitiesKHR.Ptr, but with the new size.
@NotNull VkVideoDecodeH264DpbSlotInfoKHR.Ptr	VkVideoDecodeH264DpbSlotInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoDecodeH264DpbSlotInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoDecodeH264DpbSlotInfoKHR.Ptr that uses the same backing storage as this VkVideoDecodeH264DpbSlotInfoKHR.Ptr, but with the new size.
@NotNull VkVideoDecodeH264InlineSessionParametersInfoKHR.Ptr	VkVideoDecodeH264InlineSessionParametersInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoDecodeH264InlineSessionParametersInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoDecodeH264InlineSessionParametersInfoKHR.Ptr that uses the same backing storage as this VkVideoDecodeH264InlineSessionParametersInfoKHR.Ptr, but with the new size.
@NotNull VkVideoDecodeH264PictureInfoKHR.Ptr	VkVideoDecodeH264PictureInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoDecodeH264PictureInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoDecodeH264PictureInfoKHR.Ptr that uses the same backing storage as this VkVideoDecodeH264PictureInfoKHR.Ptr, but with the new size.
@NotNull VkVideoDecodeH264ProfileInfoKHR.Ptr	VkVideoDecodeH264ProfileInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoDecodeH264ProfileInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoDecodeH264ProfileInfoKHR.Ptr that uses the same backing storage as this VkVideoDecodeH264ProfileInfoKHR.Ptr, but with the new size.
@NotNull VkVideoDecodeH264SessionParametersAddInfoKHR.Ptr	VkVideoDecodeH264SessionParametersAddInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoDecodeH264SessionParametersAddInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoDecodeH264SessionParametersAddInfoKHR.Ptr that uses the same backing storage as this VkVideoDecodeH264SessionParametersAddInfoKHR.Ptr, but with the new size.
@NotNull VkVideoDecodeH264SessionParametersCreateInfoKHR.Ptr	VkVideoDecodeH264SessionParametersCreateInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoDecodeH264SessionParametersCreateInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoDecodeH264SessionParametersCreateInfoKHR.Ptr that uses the same backing storage as this VkVideoDecodeH264SessionParametersCreateInfoKHR.Ptr, but with the new size.
@NotNull VkVideoDecodeH265CapabilitiesKHR.Ptr	VkVideoDecodeH265CapabilitiesKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoDecodeH265CapabilitiesKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoDecodeH265CapabilitiesKHR.Ptr that uses the same backing storage as this VkVideoDecodeH265CapabilitiesKHR.Ptr, but with the new size.
@NotNull VkVideoDecodeH265DpbSlotInfoKHR.Ptr	VkVideoDecodeH265DpbSlotInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoDecodeH265DpbSlotInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoDecodeH265DpbSlotInfoKHR.Ptr that uses the same backing storage as this VkVideoDecodeH265DpbSlotInfoKHR.Ptr, but with the new size.
@NotNull VkVideoDecodeH265InlineSessionParametersInfoKHR.Ptr	VkVideoDecodeH265InlineSessionParametersInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoDecodeH265InlineSessionParametersInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoDecodeH265InlineSessionParametersInfoKHR.Ptr that uses the same backing storage as this VkVideoDecodeH265InlineSessionParametersInfoKHR.Ptr, but with the new size.
@NotNull VkVideoDecodeH265PictureInfoKHR.Ptr	VkVideoDecodeH265PictureInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoDecodeH265PictureInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoDecodeH265PictureInfoKHR.Ptr that uses the same backing storage as this VkVideoDecodeH265PictureInfoKHR.Ptr, but with the new size.
@NotNull VkVideoDecodeH265ProfileInfoKHR.Ptr	VkVideoDecodeH265ProfileInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoDecodeH265ProfileInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoDecodeH265ProfileInfoKHR.Ptr that uses the same backing storage as this VkVideoDecodeH265ProfileInfoKHR.Ptr, but with the new size.
@NotNull VkVideoDecodeH265SessionParametersAddInfoKHR.Ptr	VkVideoDecodeH265SessionParametersAddInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoDecodeH265SessionParametersAddInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoDecodeH265SessionParametersAddInfoKHR.Ptr that uses the same backing storage as this VkVideoDecodeH265SessionParametersAddInfoKHR.Ptr, but with the new size.
@NotNull VkVideoDecodeH265SessionParametersCreateInfoKHR.Ptr	VkVideoDecodeH265SessionParametersCreateInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoDecodeH265SessionParametersCreateInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoDecodeH265SessionParametersCreateInfoKHR.Ptr that uses the same backing storage as this VkVideoDecodeH265SessionParametersCreateInfoKHR.Ptr, but with the new size.
@NotNull VkVideoDecodeInfoKHR.Ptr	VkVideoDecodeInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoDecodeInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoDecodeInfoKHR.Ptr that uses the same backing storage as this VkVideoDecodeInfoKHR.Ptr, but with the new size.
@NotNull VkVideoDecodeUsageInfoKHR.Ptr	VkVideoDecodeUsageInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoDecodeUsageInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoDecodeUsageInfoKHR.Ptr that uses the same backing storage as this VkVideoDecodeUsageInfoKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeAV1CapabilitiesKHR.Ptr	VkVideoEncodeAV1CapabilitiesKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeAV1CapabilitiesKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeAV1CapabilitiesKHR.Ptr that uses the same backing storage as this VkVideoEncodeAV1CapabilitiesKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeAV1DpbSlotInfoKHR.Ptr	VkVideoEncodeAV1DpbSlotInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeAV1DpbSlotInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeAV1DpbSlotInfoKHR.Ptr that uses the same backing storage as this VkVideoEncodeAV1DpbSlotInfoKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeAV1FrameSizeKHR.Ptr	VkVideoEncodeAV1FrameSizeKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeAV1FrameSizeKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeAV1FrameSizeKHR.Ptr that uses the same backing storage as this VkVideoEncodeAV1FrameSizeKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeAV1GopRemainingFrameInfoKHR.Ptr	VkVideoEncodeAV1GopRemainingFrameInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeAV1GopRemainingFrameInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeAV1GopRemainingFrameInfoKHR.Ptr that uses the same backing storage as this VkVideoEncodeAV1GopRemainingFrameInfoKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeAV1PictureInfoKHR.Ptr	VkVideoEncodeAV1PictureInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeAV1PictureInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeAV1PictureInfoKHR.Ptr that uses the same backing storage as this VkVideoEncodeAV1PictureInfoKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeAV1ProfileInfoKHR.Ptr	VkVideoEncodeAV1ProfileInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeAV1ProfileInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeAV1ProfileInfoKHR.Ptr that uses the same backing storage as this VkVideoEncodeAV1ProfileInfoKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeAV1QIndexKHR.Ptr	VkVideoEncodeAV1QIndexKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeAV1QIndexKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeAV1QIndexKHR.Ptr that uses the same backing storage as this VkVideoEncodeAV1QIndexKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeAV1QualityLevelPropertiesKHR.Ptr	VkVideoEncodeAV1QualityLevelPropertiesKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeAV1QualityLevelPropertiesKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeAV1QualityLevelPropertiesKHR.Ptr that uses the same backing storage as this VkVideoEncodeAV1QualityLevelPropertiesKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeAV1QuantizationMapCapabilitiesKHR.Ptr	VkVideoEncodeAV1QuantizationMapCapabilitiesKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeAV1QuantizationMapCapabilitiesKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeAV1QuantizationMapCapabilitiesKHR.Ptr that uses the same backing storage as this VkVideoEncodeAV1QuantizationMapCapabilitiesKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeAV1RateControlInfoKHR.Ptr	VkVideoEncodeAV1RateControlInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeAV1RateControlInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeAV1RateControlInfoKHR.Ptr that uses the same backing storage as this VkVideoEncodeAV1RateControlInfoKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeAV1RateControlLayerInfoKHR.Ptr	VkVideoEncodeAV1RateControlLayerInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeAV1RateControlLayerInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeAV1RateControlLayerInfoKHR.Ptr that uses the same backing storage as this VkVideoEncodeAV1RateControlLayerInfoKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeAV1SessionCreateInfoKHR.Ptr	VkVideoEncodeAV1SessionCreateInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeAV1SessionCreateInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeAV1SessionCreateInfoKHR.Ptr that uses the same backing storage as this VkVideoEncodeAV1SessionCreateInfoKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeAV1SessionParametersCreateInfoKHR.Ptr	VkVideoEncodeAV1SessionParametersCreateInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeAV1SessionParametersCreateInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeAV1SessionParametersCreateInfoKHR.Ptr that uses the same backing storage as this VkVideoEncodeAV1SessionParametersCreateInfoKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeCapabilitiesKHR.Ptr	VkVideoEncodeCapabilitiesKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeCapabilitiesKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeCapabilitiesKHR.Ptr that uses the same backing storage as this VkVideoEncodeCapabilitiesKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeH264CapabilitiesKHR.Ptr	VkVideoEncodeH264CapabilitiesKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeH264CapabilitiesKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeH264CapabilitiesKHR.Ptr that uses the same backing storage as this VkVideoEncodeH264CapabilitiesKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeH264DpbSlotInfoKHR.Ptr	VkVideoEncodeH264DpbSlotInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeH264DpbSlotInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeH264DpbSlotInfoKHR.Ptr that uses the same backing storage as this VkVideoEncodeH264DpbSlotInfoKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeH264FrameSizeKHR.Ptr	VkVideoEncodeH264FrameSizeKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeH264FrameSizeKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeH264FrameSizeKHR.Ptr that uses the same backing storage as this VkVideoEncodeH264FrameSizeKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeH264GopRemainingFrameInfoKHR.Ptr	VkVideoEncodeH264GopRemainingFrameInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeH264GopRemainingFrameInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeH264GopRemainingFrameInfoKHR.Ptr that uses the same backing storage as this VkVideoEncodeH264GopRemainingFrameInfoKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeH264NaluSliceInfoKHR.Ptr	VkVideoEncodeH264NaluSliceInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeH264NaluSliceInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeH264NaluSliceInfoKHR.Ptr that uses the same backing storage as this VkVideoEncodeH264NaluSliceInfoKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeH264PictureInfoKHR.Ptr	VkVideoEncodeH264PictureInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeH264PictureInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeH264PictureInfoKHR.Ptr that uses the same backing storage as this VkVideoEncodeH264PictureInfoKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeH264ProfileInfoKHR.Ptr	VkVideoEncodeH264ProfileInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeH264ProfileInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeH264ProfileInfoKHR.Ptr that uses the same backing storage as this VkVideoEncodeH264ProfileInfoKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeH264QpKHR.Ptr	VkVideoEncodeH264QpKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeH264QpKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeH264QpKHR.Ptr that uses the same backing storage as this VkVideoEncodeH264QpKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeH264QualityLevelPropertiesKHR.Ptr	VkVideoEncodeH264QualityLevelPropertiesKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeH264QualityLevelPropertiesKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeH264QualityLevelPropertiesKHR.Ptr that uses the same backing storage as this VkVideoEncodeH264QualityLevelPropertiesKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeH264QuantizationMapCapabilitiesKHR.Ptr	VkVideoEncodeH264QuantizationMapCapabilitiesKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeH264QuantizationMapCapabilitiesKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeH264QuantizationMapCapabilitiesKHR.Ptr that uses the same backing storage as this VkVideoEncodeH264QuantizationMapCapabilitiesKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeH264RateControlInfoKHR.Ptr	VkVideoEncodeH264RateControlInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeH264RateControlInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeH264RateControlInfoKHR.Ptr that uses the same backing storage as this VkVideoEncodeH264RateControlInfoKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeH264RateControlLayerInfoKHR.Ptr	VkVideoEncodeH264RateControlLayerInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeH264RateControlLayerInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeH264RateControlLayerInfoKHR.Ptr that uses the same backing storage as this VkVideoEncodeH264RateControlLayerInfoKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeH264SessionCreateInfoKHR.Ptr	VkVideoEncodeH264SessionCreateInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeH264SessionCreateInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeH264SessionCreateInfoKHR.Ptr that uses the same backing storage as this VkVideoEncodeH264SessionCreateInfoKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeH264SessionParametersAddInfoKHR.Ptr	VkVideoEncodeH264SessionParametersAddInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeH264SessionParametersAddInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeH264SessionParametersAddInfoKHR.Ptr that uses the same backing storage as this VkVideoEncodeH264SessionParametersAddInfoKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeH264SessionParametersCreateInfoKHR.Ptr	VkVideoEncodeH264SessionParametersCreateInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeH264SessionParametersCreateInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeH264SessionParametersCreateInfoKHR.Ptr that uses the same backing storage as this VkVideoEncodeH264SessionParametersCreateInfoKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeH264SessionParametersFeedbackInfoKHR.Ptr	VkVideoEncodeH264SessionParametersFeedbackInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeH264SessionParametersFeedbackInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeH264SessionParametersFeedbackInfoKHR.Ptr that uses the same backing storage as this VkVideoEncodeH264SessionParametersFeedbackInfoKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeH264SessionParametersGetInfoKHR.Ptr	VkVideoEncodeH264SessionParametersGetInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeH264SessionParametersGetInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeH264SessionParametersGetInfoKHR.Ptr that uses the same backing storage as this VkVideoEncodeH264SessionParametersGetInfoKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeH265CapabilitiesKHR.Ptr	VkVideoEncodeH265CapabilitiesKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeH265CapabilitiesKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeH265CapabilitiesKHR.Ptr that uses the same backing storage as this VkVideoEncodeH265CapabilitiesKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeH265DpbSlotInfoKHR.Ptr	VkVideoEncodeH265DpbSlotInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeH265DpbSlotInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeH265DpbSlotInfoKHR.Ptr that uses the same backing storage as this VkVideoEncodeH265DpbSlotInfoKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeH265FrameSizeKHR.Ptr	VkVideoEncodeH265FrameSizeKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeH265FrameSizeKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeH265FrameSizeKHR.Ptr that uses the same backing storage as this VkVideoEncodeH265FrameSizeKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeH265GopRemainingFrameInfoKHR.Ptr	VkVideoEncodeH265GopRemainingFrameInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeH265GopRemainingFrameInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeH265GopRemainingFrameInfoKHR.Ptr that uses the same backing storage as this VkVideoEncodeH265GopRemainingFrameInfoKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeH265NaluSliceSegmentInfoKHR.Ptr	VkVideoEncodeH265NaluSliceSegmentInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeH265NaluSliceSegmentInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeH265NaluSliceSegmentInfoKHR.Ptr that uses the same backing storage as this VkVideoEncodeH265NaluSliceSegmentInfoKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeH265PictureInfoKHR.Ptr	VkVideoEncodeH265PictureInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeH265PictureInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeH265PictureInfoKHR.Ptr that uses the same backing storage as this VkVideoEncodeH265PictureInfoKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeH265ProfileInfoKHR.Ptr	VkVideoEncodeH265ProfileInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeH265ProfileInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeH265ProfileInfoKHR.Ptr that uses the same backing storage as this VkVideoEncodeH265ProfileInfoKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeH265QpKHR.Ptr	VkVideoEncodeH265QpKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeH265QpKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeH265QpKHR.Ptr that uses the same backing storage as this VkVideoEncodeH265QpKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeH265QualityLevelPropertiesKHR.Ptr	VkVideoEncodeH265QualityLevelPropertiesKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeH265QualityLevelPropertiesKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeH265QualityLevelPropertiesKHR.Ptr that uses the same backing storage as this VkVideoEncodeH265QualityLevelPropertiesKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeH265QuantizationMapCapabilitiesKHR.Ptr	VkVideoEncodeH265QuantizationMapCapabilitiesKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeH265QuantizationMapCapabilitiesKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeH265QuantizationMapCapabilitiesKHR.Ptr that uses the same backing storage as this VkVideoEncodeH265QuantizationMapCapabilitiesKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeH265RateControlInfoKHR.Ptr	VkVideoEncodeH265RateControlInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeH265RateControlInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeH265RateControlInfoKHR.Ptr that uses the same backing storage as this VkVideoEncodeH265RateControlInfoKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeH265RateControlLayerInfoKHR.Ptr	VkVideoEncodeH265RateControlLayerInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeH265RateControlLayerInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeH265RateControlLayerInfoKHR.Ptr that uses the same backing storage as this VkVideoEncodeH265RateControlLayerInfoKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeH265SessionCreateInfoKHR.Ptr	VkVideoEncodeH265SessionCreateInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeH265SessionCreateInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeH265SessionCreateInfoKHR.Ptr that uses the same backing storage as this VkVideoEncodeH265SessionCreateInfoKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeH265SessionParametersAddInfoKHR.Ptr	VkVideoEncodeH265SessionParametersAddInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeH265SessionParametersAddInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeH265SessionParametersAddInfoKHR.Ptr that uses the same backing storage as this VkVideoEncodeH265SessionParametersAddInfoKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeH265SessionParametersCreateInfoKHR.Ptr	VkVideoEncodeH265SessionParametersCreateInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeH265SessionParametersCreateInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeH265SessionParametersCreateInfoKHR.Ptr that uses the same backing storage as this VkVideoEncodeH265SessionParametersCreateInfoKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeH265SessionParametersFeedbackInfoKHR.Ptr	VkVideoEncodeH265SessionParametersFeedbackInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeH265SessionParametersFeedbackInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeH265SessionParametersFeedbackInfoKHR.Ptr that uses the same backing storage as this VkVideoEncodeH265SessionParametersFeedbackInfoKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeH265SessionParametersGetInfoKHR.Ptr	VkVideoEncodeH265SessionParametersGetInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeH265SessionParametersGetInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeH265SessionParametersGetInfoKHR.Ptr that uses the same backing storage as this VkVideoEncodeH265SessionParametersGetInfoKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeInfoKHR.Ptr	VkVideoEncodeInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeInfoKHR.Ptr that uses the same backing storage as this VkVideoEncodeInfoKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeQualityLevelInfoKHR.Ptr	VkVideoEncodeQualityLevelInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeQualityLevelInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeQualityLevelInfoKHR.Ptr that uses the same backing storage as this VkVideoEncodeQualityLevelInfoKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeQualityLevelPropertiesKHR.Ptr	VkVideoEncodeQualityLevelPropertiesKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeQualityLevelPropertiesKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeQualityLevelPropertiesKHR.Ptr that uses the same backing storage as this VkVideoEncodeQualityLevelPropertiesKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeQuantizationMapCapabilitiesKHR.Ptr	VkVideoEncodeQuantizationMapCapabilitiesKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeQuantizationMapCapabilitiesKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeQuantizationMapCapabilitiesKHR.Ptr that uses the same backing storage as this VkVideoEncodeQuantizationMapCapabilitiesKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeQuantizationMapInfoKHR.Ptr	VkVideoEncodeQuantizationMapInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeQuantizationMapInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeQuantizationMapInfoKHR.Ptr that uses the same backing storage as this VkVideoEncodeQuantizationMapInfoKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR.Ptr	VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR.Ptr that uses the same backing storage as this VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeRateControlInfoKHR.Ptr	VkVideoEncodeRateControlInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeRateControlInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeRateControlInfoKHR.Ptr that uses the same backing storage as this VkVideoEncodeRateControlInfoKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeRateControlLayerInfoKHR.Ptr	VkVideoEncodeRateControlLayerInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeRateControlLayerInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeRateControlLayerInfoKHR.Ptr that uses the same backing storage as this VkVideoEncodeRateControlLayerInfoKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeSessionParametersFeedbackInfoKHR.Ptr	VkVideoEncodeSessionParametersFeedbackInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeSessionParametersFeedbackInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeSessionParametersFeedbackInfoKHR.Ptr that uses the same backing storage as this VkVideoEncodeSessionParametersFeedbackInfoKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeSessionParametersGetInfoKHR.Ptr	VkVideoEncodeSessionParametersGetInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeSessionParametersGetInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeSessionParametersGetInfoKHR.Ptr that uses the same backing storage as this VkVideoEncodeSessionParametersGetInfoKHR.Ptr, but with the new size.
@NotNull VkVideoEncodeUsageInfoKHR.Ptr	VkVideoEncodeUsageInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEncodeUsageInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEncodeUsageInfoKHR.Ptr that uses the same backing storage as this VkVideoEncodeUsageInfoKHR.Ptr, but with the new size.
@NotNull VkVideoEndCodingInfoKHR.Ptr	VkVideoEndCodingInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoEndCodingInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoEndCodingInfoKHR.Ptr that uses the same backing storage as this VkVideoEndCodingInfoKHR.Ptr, but with the new size.
@NotNull VkVideoFormatAV1QuantizationMapPropertiesKHR.Ptr	VkVideoFormatAV1QuantizationMapPropertiesKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoFormatAV1QuantizationMapPropertiesKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoFormatAV1QuantizationMapPropertiesKHR.Ptr that uses the same backing storage as this VkVideoFormatAV1QuantizationMapPropertiesKHR.Ptr, but with the new size.
@NotNull VkVideoFormatH265QuantizationMapPropertiesKHR.Ptr	VkVideoFormatH265QuantizationMapPropertiesKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoFormatH265QuantizationMapPropertiesKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoFormatH265QuantizationMapPropertiesKHR.Ptr that uses the same backing storage as this VkVideoFormatH265QuantizationMapPropertiesKHR.Ptr, but with the new size.
@NotNull VkVideoFormatPropertiesKHR.Ptr	VkVideoFormatPropertiesKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoFormatPropertiesKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoFormatPropertiesKHR.Ptr that uses the same backing storage as this VkVideoFormatPropertiesKHR.Ptr, but with the new size.
@NotNull VkVideoFormatQuantizationMapPropertiesKHR.Ptr	VkVideoFormatQuantizationMapPropertiesKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoFormatQuantizationMapPropertiesKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoFormatQuantizationMapPropertiesKHR.Ptr that uses the same backing storage as this VkVideoFormatQuantizationMapPropertiesKHR.Ptr, but with the new size.
@NotNull VkVideoInlineQueryInfoKHR.Ptr	VkVideoInlineQueryInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoInlineQueryInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoInlineQueryInfoKHR.Ptr that uses the same backing storage as this VkVideoInlineQueryInfoKHR.Ptr, but with the new size.
@NotNull VkVideoPictureResourceInfoKHR.Ptr	VkVideoPictureResourceInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoPictureResourceInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoPictureResourceInfoKHR.Ptr that uses the same backing storage as this VkVideoPictureResourceInfoKHR.Ptr, but with the new size.
@NotNull VkVideoProfileInfoKHR.Ptr	VkVideoProfileInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoProfileInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoProfileInfoKHR.Ptr that uses the same backing storage as this VkVideoProfileInfoKHR.Ptr, but with the new size.
@NotNull VkVideoProfileListInfoKHR.Ptr	VkVideoProfileListInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoProfileListInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoProfileListInfoKHR.Ptr that uses the same backing storage as this VkVideoProfileListInfoKHR.Ptr, but with the new size.
@NotNull VkVideoReferenceSlotInfoKHR.Ptr	VkVideoReferenceSlotInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoReferenceSlotInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoReferenceSlotInfoKHR.Ptr that uses the same backing storage as this VkVideoReferenceSlotInfoKHR.Ptr, but with the new size.
@NotNull VkVideoSessionCreateInfoKHR.Ptr	VkVideoSessionCreateInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoSessionCreateInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoSessionCreateInfoKHR.Ptr that uses the same backing storage as this VkVideoSessionCreateInfoKHR.Ptr, but with the new size.
@NotNull VkVideoSessionMemoryRequirementsKHR.Ptr	VkVideoSessionMemoryRequirementsKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoSessionMemoryRequirementsKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoSessionMemoryRequirementsKHR.Ptr that uses the same backing storage as this VkVideoSessionMemoryRequirementsKHR.Ptr, but with the new size.
@NotNull VkVideoSessionParametersCreateInfoKHR.Ptr	VkVideoSessionParametersCreateInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoSessionParametersCreateInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoSessionParametersCreateInfoKHR.Ptr that uses the same backing storage as this VkVideoSessionParametersCreateInfoKHR.Ptr, but with the new size.
@NotNull VkVideoSessionParametersUpdateInfoKHR.Ptr	VkVideoSessionParametersUpdateInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoSessionParametersUpdateInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkVideoSessionParametersUpdateInfoKHR.Ptr that uses the same backing storage as this VkVideoSessionParametersUpdateInfoKHR.Ptr, but with the new size.
@NotNull VkViewport.Ptr	VkViewport.Ptr.reinterpret(long newSize)	Assume the VkViewport.Ptr is capable of holding at least newSize structures, create a new view VkViewport.Ptr that uses the same backing storage as this VkViewport.Ptr, but with the new size.
@NotNull VkViewportSwizzleNV.Ptr	VkViewportSwizzleNV.Ptr.reinterpret(long newSize)	Assume the VkViewportSwizzleNV.Ptr is capable of holding at least newSize structures, create a new view VkViewportSwizzleNV.Ptr that uses the same backing storage as this VkViewportSwizzleNV.Ptr, but with the new size.
@NotNull VkViewportWScalingNV.Ptr	VkViewportWScalingNV.Ptr.reinterpret(long newSize)	Assume the VkViewportWScalingNV.Ptr is capable of holding at least newSize structures, create a new view VkViewportWScalingNV.Ptr that uses the same backing storage as this VkViewportWScalingNV.Ptr, but with the new size.
@NotNull VkViSurfaceCreateInfoNN.Ptr	VkViSurfaceCreateInfoNN.Ptr.reinterpret(long newSize)	Assume the VkViSurfaceCreateInfoNN.Ptr is capable of holding at least newSize structures, create a new view VkViSurfaceCreateInfoNN.Ptr that uses the same backing storage as this VkViSurfaceCreateInfoNN.Ptr, but with the new size.
@NotNull VkWaylandSurfaceCreateInfoKHR.Ptr	VkWaylandSurfaceCreateInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkWaylandSurfaceCreateInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkWaylandSurfaceCreateInfoKHR.Ptr that uses the same backing storage as this VkWaylandSurfaceCreateInfoKHR.Ptr, but with the new size.
@NotNull VkWin32KeyedMutexAcquireReleaseInfoKHR.Ptr	VkWin32KeyedMutexAcquireReleaseInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkWin32KeyedMutexAcquireReleaseInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkWin32KeyedMutexAcquireReleaseInfoKHR.Ptr that uses the same backing storage as this VkWin32KeyedMutexAcquireReleaseInfoKHR.Ptr, but with the new size.
@NotNull VkWin32KeyedMutexAcquireReleaseInfoNV.Ptr	VkWin32KeyedMutexAcquireReleaseInfoNV.Ptr.reinterpret(long newSize)	Assume the VkWin32KeyedMutexAcquireReleaseInfoNV.Ptr is capable of holding at least newSize structures, create a new view VkWin32KeyedMutexAcquireReleaseInfoNV.Ptr that uses the same backing storage as this VkWin32KeyedMutexAcquireReleaseInfoNV.Ptr, but with the new size.
@NotNull VkWin32SurfaceCreateInfoKHR.Ptr	VkWin32SurfaceCreateInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkWin32SurfaceCreateInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkWin32SurfaceCreateInfoKHR.Ptr that uses the same backing storage as this VkWin32SurfaceCreateInfoKHR.Ptr, but with the new size.
@NotNull VkWriteDescriptorSet.Ptr	VkWriteDescriptorSet.Ptr.reinterpret(long newSize)	Assume the VkWriteDescriptorSet.Ptr is capable of holding at least newSize structures, create a new view VkWriteDescriptorSet.Ptr that uses the same backing storage as this VkWriteDescriptorSet.Ptr, but with the new size.
@NotNull VkWriteDescriptorSetAccelerationStructureKHR.Ptr	VkWriteDescriptorSetAccelerationStructureKHR.Ptr.reinterpret(long newSize)	Assume the VkWriteDescriptorSetAccelerationStructureKHR.Ptr is capable of holding at least newSize structures, create a new view VkWriteDescriptorSetAccelerationStructureKHR.Ptr that uses the same backing storage as this VkWriteDescriptorSetAccelerationStructureKHR.Ptr, but with the new size.
@NotNull VkWriteDescriptorSetAccelerationStructureNV.Ptr	VkWriteDescriptorSetAccelerationStructureNV.Ptr.reinterpret(long newSize)	Assume the VkWriteDescriptorSetAccelerationStructureNV.Ptr is capable of holding at least newSize structures, create a new view VkWriteDescriptorSetAccelerationStructureNV.Ptr that uses the same backing storage as this VkWriteDescriptorSetAccelerationStructureNV.Ptr, but with the new size.
@NotNull VkWriteDescriptorSetInlineUniformBlock.Ptr	VkWriteDescriptorSetInlineUniformBlock.Ptr.reinterpret(long newSize)	Assume the VkWriteDescriptorSetInlineUniformBlock.Ptr is capable of holding at least newSize structures, create a new view VkWriteDescriptorSetInlineUniformBlock.Ptr that uses the same backing storage as this VkWriteDescriptorSetInlineUniformBlock.Ptr, but with the new size.
@NotNull VkWriteDescriptorSetPartitionedAccelerationStructureNV.Ptr	VkWriteDescriptorSetPartitionedAccelerationStructureNV.Ptr.reinterpret(long newSize)	Assume the VkWriteDescriptorSetPartitionedAccelerationStructureNV.Ptr is capable of holding at least newSize structures, create a new view VkWriteDescriptorSetPartitionedAccelerationStructureNV.Ptr that uses the same backing storage as this VkWriteDescriptorSetPartitionedAccelerationStructureNV.Ptr, but with the new size.
@NotNull VkWriteIndirectExecutionSetPipelineEXT.Ptr	VkWriteIndirectExecutionSetPipelineEXT.Ptr.reinterpret(long newSize)	Assume the VkWriteIndirectExecutionSetPipelineEXT.Ptr is capable of holding at least newSize structures, create a new view VkWriteIndirectExecutionSetPipelineEXT.Ptr that uses the same backing storage as this VkWriteIndirectExecutionSetPipelineEXT.Ptr, but with the new size.
@NotNull VkWriteIndirectExecutionSetShaderEXT.Ptr	VkWriteIndirectExecutionSetShaderEXT.Ptr.reinterpret(long newSize)	Assume the VkWriteIndirectExecutionSetShaderEXT.Ptr is capable of holding at least newSize structures, create a new view VkWriteIndirectExecutionSetShaderEXT.Ptr that uses the same backing storage as this VkWriteIndirectExecutionSetShaderEXT.Ptr, but with the new size.
@NotNull VkXcbSurfaceCreateInfoKHR.Ptr	VkXcbSurfaceCreateInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkXcbSurfaceCreateInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkXcbSurfaceCreateInfoKHR.Ptr that uses the same backing storage as this VkXcbSurfaceCreateInfoKHR.Ptr, but with the new size.
@NotNull VkXlibSurfaceCreateInfoKHR.Ptr	VkXlibSurfaceCreateInfoKHR.Ptr.reinterpret(long newSize)	Assume the VkXlibSurfaceCreateInfoKHR.Ptr is capable of holding at least newSize structures, create a new view VkXlibSurfaceCreateInfoKHR.Ptr that uses the same backing storage as this VkXlibSurfaceCreateInfoKHR.Ptr, but with the new size.
@NotNull VkXYColorEXT.Ptr	VkXYColorEXT.Ptr.reinterpret(long newSize)	Assume the VkXYColorEXT.Ptr is capable of holding at least newSize structures, create a new view VkXYColorEXT.Ptr that uses the same backing storage as this VkXYColorEXT.Ptr, but with the new size.

Uses of Unsafe in club.doki7.vulkan.handle

Methods in club.doki7.vulkan.handle with annotations of type Unsafe

Modifier and Type	Method	Description
VkAccelerationStructureKHR.Ptr	VkAccelerationStructureKHR.Ptr.reinterpret(long newSize)	Assume the VkAccelerationStructureKHR.Ptr is capable of holding at least newSize handles, create a new view VkAccelerationStructureKHR.Ptr that uses the same backing storage as this VkAccelerationStructureKHR.Ptr, but with the new size.
VkAccelerationStructureNV.Ptr	VkAccelerationStructureNV.Ptr.reinterpret(long newSize)	Assume the VkAccelerationStructureNV.Ptr is capable of holding at least newSize handles, create a new view VkAccelerationStructureNV.Ptr that uses the same backing storage as this VkAccelerationStructureNV.Ptr, but with the new size.
VkBuffer.Ptr	VkBuffer.Ptr.reinterpret(long newSize)	Assume the VkBuffer.Ptr is capable of holding at least newSize handles, create a new view VkBuffer.Ptr that uses the same backing storage as this VkBuffer.Ptr, but with the new size.
VkBufferCollectionFUCHSIA.Ptr	VkBufferCollectionFUCHSIA.Ptr.reinterpret(long newSize)	Assume the VkBufferCollectionFUCHSIA.Ptr is capable of holding at least newSize handles, create a new view VkBufferCollectionFUCHSIA.Ptr that uses the same backing storage as this VkBufferCollectionFUCHSIA.Ptr, but with the new size.
VkBufferView.Ptr	VkBufferView.Ptr.reinterpret(long newSize)	Assume the VkBufferView.Ptr is capable of holding at least newSize handles, create a new view VkBufferView.Ptr that uses the same backing storage as this VkBufferView.Ptr, but with the new size.
VkCommandBuffer.Ptr	VkCommandBuffer.Ptr.reinterpret(long newSize)	Assume the VkCommandBuffer.Ptr is capable of holding at least newSize handles, create a new view VkCommandBuffer.Ptr that uses the same backing storage as this VkCommandBuffer.Ptr, but with the new size.
VkCommandPool.Ptr	VkCommandPool.Ptr.reinterpret(long newSize)	Assume the VkCommandPool.Ptr is capable of holding at least newSize handles, create a new view VkCommandPool.Ptr that uses the same backing storage as this VkCommandPool.Ptr, but with the new size.
VkCudaFunctionNV.Ptr	VkCudaFunctionNV.Ptr.reinterpret(long newSize)	Assume the VkCudaFunctionNV.Ptr is capable of holding at least newSize handles, create a new view VkCudaFunctionNV.Ptr that uses the same backing storage as this VkCudaFunctionNV.Ptr, but with the new size.
VkCudaModuleNV.Ptr	VkCudaModuleNV.Ptr.reinterpret(long newSize)	Assume the VkCudaModuleNV.Ptr is capable of holding at least newSize handles, create a new view VkCudaModuleNV.Ptr that uses the same backing storage as this VkCudaModuleNV.Ptr, but with the new size.
VkCuFunctionNVX.Ptr	VkCuFunctionNVX.Ptr.reinterpret(long newSize)	Assume the VkCuFunctionNVX.Ptr is capable of holding at least newSize handles, create a new view VkCuFunctionNVX.Ptr that uses the same backing storage as this VkCuFunctionNVX.Ptr, but with the new size.
VkCuModuleNVX.Ptr	VkCuModuleNVX.Ptr.reinterpret(long newSize)	Assume the VkCuModuleNVX.Ptr is capable of holding at least newSize handles, create a new view VkCuModuleNVX.Ptr that uses the same backing storage as this VkCuModuleNVX.Ptr, but with the new size.
VkDebugReportCallbackEXT.Ptr	VkDebugReportCallbackEXT.Ptr.reinterpret(long newSize)	Assume the VkDebugReportCallbackEXT.Ptr is capable of holding at least newSize handles, create a new view VkDebugReportCallbackEXT.Ptr that uses the same backing storage as this VkDebugReportCallbackEXT.Ptr, but with the new size.
VkDebugUtilsMessengerEXT.Ptr	VkDebugUtilsMessengerEXT.Ptr.reinterpret(long newSize)	Assume the VkDebugUtilsMessengerEXT.Ptr is capable of holding at least newSize handles, create a new view VkDebugUtilsMessengerEXT.Ptr that uses the same backing storage as this VkDebugUtilsMessengerEXT.Ptr, but with the new size.
VkDeferredOperationKHR.Ptr	VkDeferredOperationKHR.Ptr.reinterpret(long newSize)	Assume the VkDeferredOperationKHR.Ptr is capable of holding at least newSize handles, create a new view VkDeferredOperationKHR.Ptr that uses the same backing storage as this VkDeferredOperationKHR.Ptr, but with the new size.
VkDescriptorPool.Ptr	VkDescriptorPool.Ptr.reinterpret(long newSize)	Assume the VkDescriptorPool.Ptr is capable of holding at least newSize handles, create a new view VkDescriptorPool.Ptr that uses the same backing storage as this VkDescriptorPool.Ptr, but with the new size.
VkDescriptorSet.Ptr	VkDescriptorSet.Ptr.reinterpret(long newSize)	Assume the VkDescriptorSet.Ptr is capable of holding at least newSize handles, create a new view VkDescriptorSet.Ptr that uses the same backing storage as this VkDescriptorSet.Ptr, but with the new size.
VkDescriptorSetLayout.Ptr	VkDescriptorSetLayout.Ptr.reinterpret(long newSize)	Assume the VkDescriptorSetLayout.Ptr is capable of holding at least newSize handles, create a new view VkDescriptorSetLayout.Ptr that uses the same backing storage as this VkDescriptorSetLayout.Ptr, but with the new size.
VkDescriptorUpdateTemplate.Ptr	VkDescriptorUpdateTemplate.Ptr.reinterpret(long newSize)	Assume the VkDescriptorUpdateTemplate.Ptr is capable of holding at least newSize handles, create a new view VkDescriptorUpdateTemplate.Ptr that uses the same backing storage as this VkDescriptorUpdateTemplate.Ptr, but with the new size.
VkDevice.Ptr	VkDevice.Ptr.reinterpret(long newSize)	Assume the VkDevice.Ptr is capable of holding at least newSize handles, create a new view VkDevice.Ptr that uses the same backing storage as this VkDevice.Ptr, but with the new size.
VkDeviceMemory.Ptr	VkDeviceMemory.Ptr.reinterpret(long newSize)	Assume the VkDeviceMemory.Ptr is capable of holding at least newSize handles, create a new view VkDeviceMemory.Ptr that uses the same backing storage as this VkDeviceMemory.Ptr, but with the new size.
VkDisplayKHR.Ptr	VkDisplayKHR.Ptr.reinterpret(long newSize)	Assume the VkDisplayKHR.Ptr is capable of holding at least newSize handles, create a new view VkDisplayKHR.Ptr that uses the same backing storage as this VkDisplayKHR.Ptr, but with the new size.
VkDisplayModeKHR.Ptr	VkDisplayModeKHR.Ptr.reinterpret(long newSize)	Assume the VkDisplayModeKHR.Ptr is capable of holding at least newSize handles, create a new view VkDisplayModeKHR.Ptr that uses the same backing storage as this VkDisplayModeKHR.Ptr, but with the new size.
VkEvent.Ptr	VkEvent.Ptr.reinterpret(long newSize)	Assume the VkEvent.Ptr is capable of holding at least newSize handles, create a new view VkEvent.Ptr that uses the same backing storage as this VkEvent.Ptr, but with the new size.
VkExternalComputeQueueNV.Ptr	VkExternalComputeQueueNV.Ptr.reinterpret(long newSize)	Assume the VkExternalComputeQueueNV.Ptr is capable of holding at least newSize handles, create a new view VkExternalComputeQueueNV.Ptr that uses the same backing storage as this VkExternalComputeQueueNV.Ptr, but with the new size.
VkFence.Ptr	VkFence.Ptr.reinterpret(long newSize)	Assume the VkFence.Ptr is capable of holding at least newSize handles, create a new view VkFence.Ptr that uses the same backing storage as this VkFence.Ptr, but with the new size.
VkFramebuffer.Ptr	VkFramebuffer.Ptr.reinterpret(long newSize)	Assume the VkFramebuffer.Ptr is capable of holding at least newSize handles, create a new view VkFramebuffer.Ptr that uses the same backing storage as this VkFramebuffer.Ptr, but with the new size.
VkImage.Ptr	VkImage.Ptr.reinterpret(long newSize)	Assume the VkImage.Ptr is capable of holding at least newSize handles, create a new view VkImage.Ptr that uses the same backing storage as this VkImage.Ptr, but with the new size.
VkImageView.Ptr	VkImageView.Ptr.reinterpret(long newSize)	Assume the VkImageView.Ptr is capable of holding at least newSize handles, create a new view VkImageView.Ptr that uses the same backing storage as this VkImageView.Ptr, but with the new size.
VkIndirectCommandsLayoutEXT.Ptr	VkIndirectCommandsLayoutEXT.Ptr.reinterpret(long newSize)	Assume the VkIndirectCommandsLayoutEXT.Ptr is capable of holding at least newSize handles, create a new view VkIndirectCommandsLayoutEXT.Ptr that uses the same backing storage as this VkIndirectCommandsLayoutEXT.Ptr, but with the new size.
VkIndirectCommandsLayoutNV.Ptr	VkIndirectCommandsLayoutNV.Ptr.reinterpret(long newSize)	Assume the VkIndirectCommandsLayoutNV.Ptr is capable of holding at least newSize handles, create a new view VkIndirectCommandsLayoutNV.Ptr that uses the same backing storage as this VkIndirectCommandsLayoutNV.Ptr, but with the new size.
VkIndirectExecutionSetEXT.Ptr	VkIndirectExecutionSetEXT.Ptr.reinterpret(long newSize)	Assume the VkIndirectExecutionSetEXT.Ptr is capable of holding at least newSize handles, create a new view VkIndirectExecutionSetEXT.Ptr that uses the same backing storage as this VkIndirectExecutionSetEXT.Ptr, but with the new size.
VkInstance.Ptr	VkInstance.Ptr.reinterpret(long newSize)	Assume the VkInstance.Ptr is capable of holding at least newSize handles, create a new view VkInstance.Ptr that uses the same backing storage as this VkInstance.Ptr, but with the new size.
VkMicromapEXT.Ptr	VkMicromapEXT.Ptr.reinterpret(long newSize)	Assume the VkMicromapEXT.Ptr is capable of holding at least newSize handles, create a new view VkMicromapEXT.Ptr that uses the same backing storage as this VkMicromapEXT.Ptr, but with the new size.
VkOpticalFlowSessionNV.Ptr	VkOpticalFlowSessionNV.Ptr.reinterpret(long newSize)	Assume the VkOpticalFlowSessionNV.Ptr is capable of holding at least newSize handles, create a new view VkOpticalFlowSessionNV.Ptr that uses the same backing storage as this VkOpticalFlowSessionNV.Ptr, but with the new size.
VkPerformanceConfigurationINTEL.Ptr	VkPerformanceConfigurationINTEL.Ptr.reinterpret(long newSize)	Assume the VkPerformanceConfigurationINTEL.Ptr is capable of holding at least newSize handles, create a new view VkPerformanceConfigurationINTEL.Ptr that uses the same backing storage as this VkPerformanceConfigurationINTEL.Ptr, but with the new size.
VkPhysicalDevice.Ptr	VkPhysicalDevice.Ptr.reinterpret(long newSize)	Assume the VkPhysicalDevice.Ptr is capable of holding at least newSize handles, create a new view VkPhysicalDevice.Ptr that uses the same backing storage as this VkPhysicalDevice.Ptr, but with the new size.
VkPipeline.Ptr	VkPipeline.Ptr.reinterpret(long newSize)	Assume the VkPipeline.Ptr is capable of holding at least newSize handles, create a new view VkPipeline.Ptr that uses the same backing storage as this VkPipeline.Ptr, but with the new size.
VkPipelineBinaryKHR.Ptr	VkPipelineBinaryKHR.Ptr.reinterpret(long newSize)	Assume the VkPipelineBinaryKHR.Ptr is capable of holding at least newSize handles, create a new view VkPipelineBinaryKHR.Ptr that uses the same backing storage as this VkPipelineBinaryKHR.Ptr, but with the new size.
VkPipelineCache.Ptr	VkPipelineCache.Ptr.reinterpret(long newSize)	Assume the VkPipelineCache.Ptr is capable of holding at least newSize handles, create a new view VkPipelineCache.Ptr that uses the same backing storage as this VkPipelineCache.Ptr, but with the new size.
VkPipelineLayout.Ptr	VkPipelineLayout.Ptr.reinterpret(long newSize)	Assume the VkPipelineLayout.Ptr is capable of holding at least newSize handles, create a new view VkPipelineLayout.Ptr that uses the same backing storage as this VkPipelineLayout.Ptr, but with the new size.
VkPrivateDataSlot.Ptr	VkPrivateDataSlot.Ptr.reinterpret(long newSize)	Assume the VkPrivateDataSlot.Ptr is capable of holding at least newSize handles, create a new view VkPrivateDataSlot.Ptr that uses the same backing storage as this VkPrivateDataSlot.Ptr, but with the new size.
VkQueryPool.Ptr	VkQueryPool.Ptr.reinterpret(long newSize)	Assume the VkQueryPool.Ptr is capable of holding at least newSize handles, create a new view VkQueryPool.Ptr that uses the same backing storage as this VkQueryPool.Ptr, but with the new size.
VkQueue.Ptr	VkQueue.Ptr.reinterpret(long newSize)	Assume the VkQueue.Ptr is capable of holding at least newSize handles, create a new view VkQueue.Ptr that uses the same backing storage as this VkQueue.Ptr, but with the new size.
VkRenderPass.Ptr	VkRenderPass.Ptr.reinterpret(long newSize)	Assume the VkRenderPass.Ptr is capable of holding at least newSize handles, create a new view VkRenderPass.Ptr that uses the same backing storage as this VkRenderPass.Ptr, but with the new size.
VkSampler.Ptr	VkSampler.Ptr.reinterpret(long newSize)	Assume the VkSampler.Ptr is capable of holding at least newSize handles, create a new view VkSampler.Ptr that uses the same backing storage as this VkSampler.Ptr, but with the new size.
VkSamplerYcbcrConversion.Ptr	VkSamplerYcbcrConversion.Ptr.reinterpret(long newSize)	Assume the VkSamplerYcbcrConversion.Ptr is capable of holding at least newSize handles, create a new view VkSamplerYcbcrConversion.Ptr that uses the same backing storage as this VkSamplerYcbcrConversion.Ptr, but with the new size.
VkSemaphore.Ptr	VkSemaphore.Ptr.reinterpret(long newSize)	Assume the VkSemaphore.Ptr is capable of holding at least newSize handles, create a new view VkSemaphore.Ptr that uses the same backing storage as this VkSemaphore.Ptr, but with the new size.
VkSemaphoreSciSyncPoolNV.Ptr	VkSemaphoreSciSyncPoolNV.Ptr.reinterpret(long newSize)	Assume the VkSemaphoreSciSyncPoolNV.Ptr is capable of holding at least newSize handles, create a new view VkSemaphoreSciSyncPoolNV.Ptr that uses the same backing storage as this VkSemaphoreSciSyncPoolNV.Ptr, but with the new size.
VkShaderEXT.Ptr	VkShaderEXT.Ptr.reinterpret(long newSize)	Assume the VkShaderEXT.Ptr is capable of holding at least newSize handles, create a new view VkShaderEXT.Ptr that uses the same backing storage as this VkShaderEXT.Ptr, but with the new size.
VkShaderModule.Ptr	VkShaderModule.Ptr.reinterpret(long newSize)	Assume the VkShaderModule.Ptr is capable of holding at least newSize handles, create a new view VkShaderModule.Ptr that uses the same backing storage as this VkShaderModule.Ptr, but with the new size.
VkSurfaceKHR.Ptr	VkSurfaceKHR.Ptr.reinterpret(long newSize)	Assume the VkSurfaceKHR.Ptr is capable of holding at least newSize handles, create a new view VkSurfaceKHR.Ptr that uses the same backing storage as this VkSurfaceKHR.Ptr, but with the new size.
VkSwapchainKHR.Ptr	VkSwapchainKHR.Ptr.reinterpret(long newSize)	Assume the VkSwapchainKHR.Ptr is capable of holding at least newSize handles, create a new view VkSwapchainKHR.Ptr that uses the same backing storage as this VkSwapchainKHR.Ptr, but with the new size.
VkValidationCacheEXT.Ptr	VkValidationCacheEXT.Ptr.reinterpret(long newSize)	Assume the VkValidationCacheEXT.Ptr is capable of holding at least newSize handles, create a new view VkValidationCacheEXT.Ptr that uses the same backing storage as this VkValidationCacheEXT.Ptr, but with the new size.
VkVideoSessionKHR.Ptr	VkVideoSessionKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoSessionKHR.Ptr is capable of holding at least newSize handles, create a new view VkVideoSessionKHR.Ptr that uses the same backing storage as this VkVideoSessionKHR.Ptr, but with the new size.
VkVideoSessionParametersKHR.Ptr	VkVideoSessionParametersKHR.Ptr.reinterpret(long newSize)	Assume the VkVideoSessionParametersKHR.Ptr is capable of holding at least newSize handles, create a new view VkVideoSessionParametersKHR.Ptr that uses the same backing storage as this VkVideoSessionParametersKHR.Ptr, but with the new size.

Uses of Unsafe in club.doki7.webgpu.datatype

Methods in club.doki7.webgpu.datatype with annotations of type Unsafe

Modifier and Type	Method	Description
WGPUVertexAttribute.Ptr	WGPUVertexBufferLayout.attributes(int assumedCount)
WGPUBlendState.Ptr	WGPUColorTargetState.blend(int assumedCount)
WGPUVertexBufferLayout.Ptr	WGPUVertexState.buffers(int assumedCount)
WGPURenderPassColorAttachment.Ptr	WGPURenderPassDescriptor.colorAttachments(int assumedCount)
WGPUConstantEntry.Ptr	WGPUFragmentState.constants(int assumedCount)
WGPUConstantEntry.Ptr	WGPUProgrammableStageDescriptor.constants(int assumedCount)
WGPUConstantEntry.Ptr	WGPUVertexState.constants(int assumedCount)
WGPUShaderDefine.Ptr	WGPUShaderSourceGLSL.defines(int assumedCount)
WGPUDepthStencilState.Ptr	WGPURenderPipelineDescriptor.depthStencil(int assumedCount)
WGPURenderPassDepthStencilAttachment.Ptr	WGPURenderPassDescriptor.depthStencilAttachment(int assumedCount)
WGPUBindGroupEntry.Ptr	WGPUBindGroupDescriptor.entries(int assumedCount)
WGPUBindGroupLayoutEntry.Ptr	WGPUBindGroupLayoutDescriptor.entries(int assumedCount)
WGPUFragmentState.Ptr	WGPURenderPipelineDescriptor.fragment(int assumedCount)
WGPUCompilationMessage.Ptr	WGPUCompilationInfo.messages(int assumedCount)
WGPUChainedStruct.Ptr	WGPUChainedStruct.next(int assumedCount)
WGPUChainedStructOut.Ptr	WGPUChainedStructOut.next(int assumedCount)
WGPUChainedStruct.Ptr	WGPUAdapterInfo.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPUBindGroupDescriptor.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPUBindGroupEntry.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPUBindGroupLayoutDescriptor.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPUBindGroupLayoutEntry.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPUBufferBindingLayout.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPUBufferDescriptor.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPUBufferMapCallbackInfo.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPUColorTargetState.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPUCommandBufferDescriptor.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPUCommandEncoderDescriptor.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPUCompilationInfo.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPUCompilationInfoCallbackInfo.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPUCompilationMessage.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPUComputePassDescriptor.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPUComputePipelineDescriptor.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPUConstantEntry.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPUCreateComputePipelineAsyncCallbackInfo.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPUCreateRenderPipelineAsyncCallbackInfo.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPUDepthStencilState.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPUDeviceDescriptor.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPUDeviceLostCallbackInfo.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPUFragmentState.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPUInstanceCapabilities.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPUInstanceDescriptor.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPUInstanceEnumerateAdapterOptions.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPULimits.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPUMultisampleState.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPUPipelineLayoutDescriptor.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPUPopErrorScopeCallbackInfo.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPUPrimitiveState.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPUProgrammableStageDescriptor.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPUQuerySetDescriptor.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPUQueueDescriptor.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPUQueueWorkDoneCallbackInfo.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPURenderBundleDescriptor.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPURenderBundleEncoderDescriptor.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPURenderPassColorAttachment.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPURenderPassDescriptor.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPURenderPipelineDescriptor.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPURequestAdapterCallbackInfo.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPURequestAdapterOptions.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPURequestDeviceCallbackInfo.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPUSamplerBindingLayout.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPUSamplerDescriptor.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPUShaderModuleDescriptor.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPUStorageTextureBindingLayout.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPUSurfaceCapabilities.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPUSurfaceConfiguration.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPUSurfaceDescriptor.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPUSurfaceTexture.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPUTextureBindingLayout.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPUTextureDescriptor.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPUTextureViewDescriptor.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPUUncapturedErrorCallbackInfo.nextInChain(int assumedCount)
WGPUChainedStruct.Ptr	WGPUVertexState.nextInChain(int assumedCount)
WGPUPushConstantRange.Ptr	WGPUPipelineLayoutExtras.pushConstantRanges(int assumedCount)
@NotNull WGPUAdapterInfo.Ptr	WGPUAdapterInfo.Ptr.reinterpret(long newSize)	Assume the WGPUAdapterInfo.Ptr is capable of holding at least newSize structures, create a new view WGPUAdapterInfo.Ptr that uses the same backing storage as this WGPUAdapterInfo.Ptr, but with the new size.
@NotNull WGPUBindGroupDescriptor.Ptr	WGPUBindGroupDescriptor.Ptr.reinterpret(long newSize)	Assume the WGPUBindGroupDescriptor.Ptr is capable of holding at least newSize structures, create a new view WGPUBindGroupDescriptor.Ptr that uses the same backing storage as this WGPUBindGroupDescriptor.Ptr, but with the new size.
@NotNull WGPUBindGroupEntry.Ptr	WGPUBindGroupEntry.Ptr.reinterpret(long newSize)	Assume the WGPUBindGroupEntry.Ptr is capable of holding at least newSize structures, create a new view WGPUBindGroupEntry.Ptr that uses the same backing storage as this WGPUBindGroupEntry.Ptr, but with the new size.
@NotNull WGPUBindGroupEntryExtras.Ptr	WGPUBindGroupEntryExtras.Ptr.reinterpret(long newSize)	Assume the WGPUBindGroupEntryExtras.Ptr is capable of holding at least newSize structures, create a new view WGPUBindGroupEntryExtras.Ptr that uses the same backing storage as this WGPUBindGroupEntryExtras.Ptr, but with the new size.
@NotNull WGPUBindGroupLayoutDescriptor.Ptr	WGPUBindGroupLayoutDescriptor.Ptr.reinterpret(long newSize)	Assume the WGPUBindGroupLayoutDescriptor.Ptr is capable of holding at least newSize structures, create a new view WGPUBindGroupLayoutDescriptor.Ptr that uses the same backing storage as this WGPUBindGroupLayoutDescriptor.Ptr, but with the new size.
@NotNull WGPUBindGroupLayoutEntry.Ptr	WGPUBindGroupLayoutEntry.Ptr.reinterpret(long newSize)	Assume the WGPUBindGroupLayoutEntry.Ptr is capable of holding at least newSize structures, create a new view WGPUBindGroupLayoutEntry.Ptr that uses the same backing storage as this WGPUBindGroupLayoutEntry.Ptr, but with the new size.
@NotNull WGPUBindGroupLayoutEntryExtras.Ptr	WGPUBindGroupLayoutEntryExtras.Ptr.reinterpret(long newSize)	Assume the WGPUBindGroupLayoutEntryExtras.Ptr is capable of holding at least newSize structures, create a new view WGPUBindGroupLayoutEntryExtras.Ptr that uses the same backing storage as this WGPUBindGroupLayoutEntryExtras.Ptr, but with the new size.
@NotNull WGPUBlendComponent.Ptr	WGPUBlendComponent.Ptr.reinterpret(long newSize)	Assume the WGPUBlendComponent.Ptr is capable of holding at least newSize structures, create a new view WGPUBlendComponent.Ptr that uses the same backing storage as this WGPUBlendComponent.Ptr, but with the new size.
@NotNull WGPUBlendState.Ptr	WGPUBlendState.Ptr.reinterpret(long newSize)	Assume the WGPUBlendState.Ptr is capable of holding at least newSize structures, create a new view WGPUBlendState.Ptr that uses the same backing storage as this WGPUBlendState.Ptr, but with the new size.
@NotNull WGPUBufferBindingLayout.Ptr	WGPUBufferBindingLayout.Ptr.reinterpret(long newSize)	Assume the WGPUBufferBindingLayout.Ptr is capable of holding at least newSize structures, create a new view WGPUBufferBindingLayout.Ptr that uses the same backing storage as this WGPUBufferBindingLayout.Ptr, but with the new size.
@NotNull WGPUBufferDescriptor.Ptr	WGPUBufferDescriptor.Ptr.reinterpret(long newSize)	Assume the WGPUBufferDescriptor.Ptr is capable of holding at least newSize structures, create a new view WGPUBufferDescriptor.Ptr that uses the same backing storage as this WGPUBufferDescriptor.Ptr, but with the new size.
@NotNull WGPUBufferMapCallbackInfo.Ptr	WGPUBufferMapCallbackInfo.Ptr.reinterpret(long newSize)	Assume the WGPUBufferMapCallbackInfo.Ptr is capable of holding at least newSize structures, create a new view WGPUBufferMapCallbackInfo.Ptr that uses the same backing storage as this WGPUBufferMapCallbackInfo.Ptr, but with the new size.
@NotNull WGPUChainedStruct.Ptr	WGPUChainedStruct.Ptr.reinterpret(long newSize)	Assume the WGPUChainedStruct.Ptr is capable of holding at least newSize structures, create a new view WGPUChainedStruct.Ptr that uses the same backing storage as this WGPUChainedStruct.Ptr, but with the new size.
@NotNull WGPUChainedStructOut.Ptr	WGPUChainedStructOut.Ptr.reinterpret(long newSize)	Assume the WGPUChainedStructOut.Ptr is capable of holding at least newSize structures, create a new view WGPUChainedStructOut.Ptr that uses the same backing storage as this WGPUChainedStructOut.Ptr, but with the new size.
@NotNull WGPUColor.Ptr	WGPUColor.Ptr.reinterpret(long newSize)	Assume the WGPUColor.Ptr is capable of holding at least newSize structures, create a new view WGPUColor.Ptr that uses the same backing storage as this WGPUColor.Ptr, but with the new size.
@NotNull WGPUColorTargetState.Ptr	WGPUColorTargetState.Ptr.reinterpret(long newSize)	Assume the WGPUColorTargetState.Ptr is capable of holding at least newSize structures, create a new view WGPUColorTargetState.Ptr that uses the same backing storage as this WGPUColorTargetState.Ptr, but with the new size.
@NotNull WGPUCommandBufferDescriptor.Ptr	WGPUCommandBufferDescriptor.Ptr.reinterpret(long newSize)	Assume the WGPUCommandBufferDescriptor.Ptr is capable of holding at least newSize structures, create a new view WGPUCommandBufferDescriptor.Ptr that uses the same backing storage as this WGPUCommandBufferDescriptor.Ptr, but with the new size.
@NotNull WGPUCommandEncoderDescriptor.Ptr	WGPUCommandEncoderDescriptor.Ptr.reinterpret(long newSize)	Assume the WGPUCommandEncoderDescriptor.Ptr is capable of holding at least newSize structures, create a new view WGPUCommandEncoderDescriptor.Ptr that uses the same backing storage as this WGPUCommandEncoderDescriptor.Ptr, but with the new size.
@NotNull WGPUCompilationInfo.Ptr	WGPUCompilationInfo.Ptr.reinterpret(long newSize)	Assume the WGPUCompilationInfo.Ptr is capable of holding at least newSize structures, create a new view WGPUCompilationInfo.Ptr that uses the same backing storage as this WGPUCompilationInfo.Ptr, but with the new size.
@NotNull WGPUCompilationInfoCallbackInfo.Ptr	WGPUCompilationInfoCallbackInfo.Ptr.reinterpret(long newSize)	Assume the WGPUCompilationInfoCallbackInfo.Ptr is capable of holding at least newSize structures, create a new view WGPUCompilationInfoCallbackInfo.Ptr that uses the same backing storage as this WGPUCompilationInfoCallbackInfo.Ptr, but with the new size.
@NotNull WGPUCompilationMessage.Ptr	WGPUCompilationMessage.Ptr.reinterpret(long newSize)	Assume the WGPUCompilationMessage.Ptr is capable of holding at least newSize structures, create a new view WGPUCompilationMessage.Ptr that uses the same backing storage as this WGPUCompilationMessage.Ptr, but with the new size.
@NotNull WGPUComputePassDescriptor.Ptr	WGPUComputePassDescriptor.Ptr.reinterpret(long newSize)	Assume the WGPUComputePassDescriptor.Ptr is capable of holding at least newSize structures, create a new view WGPUComputePassDescriptor.Ptr that uses the same backing storage as this WGPUComputePassDescriptor.Ptr, but with the new size.
@NotNull WGPUComputePassTimestampWrites.Ptr	WGPUComputePassTimestampWrites.Ptr.reinterpret(long newSize)	Assume the WGPUComputePassTimestampWrites.Ptr is capable of holding at least newSize structures, create a new view WGPUComputePassTimestampWrites.Ptr that uses the same backing storage as this WGPUComputePassTimestampWrites.Ptr, but with the new size.
@NotNull WGPUComputePipelineDescriptor.Ptr	WGPUComputePipelineDescriptor.Ptr.reinterpret(long newSize)	Assume the WGPUComputePipelineDescriptor.Ptr is capable of holding at least newSize structures, create a new view WGPUComputePipelineDescriptor.Ptr that uses the same backing storage as this WGPUComputePipelineDescriptor.Ptr, but with the new size.
@NotNull WGPUConstantEntry.Ptr	WGPUConstantEntry.Ptr.reinterpret(long newSize)	Assume the WGPUConstantEntry.Ptr is capable of holding at least newSize structures, create a new view WGPUConstantEntry.Ptr that uses the same backing storage as this WGPUConstantEntry.Ptr, but with the new size.
@NotNull WGPUCreateComputePipelineAsyncCallbackInfo.Ptr	WGPUCreateComputePipelineAsyncCallbackInfo.Ptr.reinterpret(long newSize)	Assume the WGPUCreateComputePipelineAsyncCallbackInfo.Ptr is capable of holding at least newSize structures, create a new view WGPUCreateComputePipelineAsyncCallbackInfo.Ptr that uses the same backing storage as this WGPUCreateComputePipelineAsyncCallbackInfo.Ptr, but with the new size.
@NotNull WGPUCreateRenderPipelineAsyncCallbackInfo.Ptr	WGPUCreateRenderPipelineAsyncCallbackInfo.Ptr.reinterpret(long newSize)	Assume the WGPUCreateRenderPipelineAsyncCallbackInfo.Ptr is capable of holding at least newSize structures, create a new view WGPUCreateRenderPipelineAsyncCallbackInfo.Ptr that uses the same backing storage as this WGPUCreateRenderPipelineAsyncCallbackInfo.Ptr, but with the new size.
@NotNull WGPUDepthStencilState.Ptr	WGPUDepthStencilState.Ptr.reinterpret(long newSize)	Assume the WGPUDepthStencilState.Ptr is capable of holding at least newSize structures, create a new view WGPUDepthStencilState.Ptr that uses the same backing storage as this WGPUDepthStencilState.Ptr, but with the new size.
@NotNull WGPUDeviceDescriptor.Ptr	WGPUDeviceDescriptor.Ptr.reinterpret(long newSize)	Assume the WGPUDeviceDescriptor.Ptr is capable of holding at least newSize structures, create a new view WGPUDeviceDescriptor.Ptr that uses the same backing storage as this WGPUDeviceDescriptor.Ptr, but with the new size.
@NotNull WGPUDeviceExtras.Ptr	WGPUDeviceExtras.Ptr.reinterpret(long newSize)	Assume the WGPUDeviceExtras.Ptr is capable of holding at least newSize structures, create a new view WGPUDeviceExtras.Ptr that uses the same backing storage as this WGPUDeviceExtras.Ptr, but with the new size.
@NotNull WGPUDeviceLostCallbackInfo.Ptr	WGPUDeviceLostCallbackInfo.Ptr.reinterpret(long newSize)	Assume the WGPUDeviceLostCallbackInfo.Ptr is capable of holding at least newSize structures, create a new view WGPUDeviceLostCallbackInfo.Ptr that uses the same backing storage as this WGPUDeviceLostCallbackInfo.Ptr, but with the new size.
@NotNull WGPUExtent3d.Ptr	WGPUExtent3d.Ptr.reinterpret(long newSize)	Assume the WGPUExtent3d.Ptr is capable of holding at least newSize structures, create a new view WGPUExtent3d.Ptr that uses the same backing storage as this WGPUExtent3d.Ptr, but with the new size.
@NotNull WGPUFragmentState.Ptr	WGPUFragmentState.Ptr.reinterpret(long newSize)	Assume the WGPUFragmentState.Ptr is capable of holding at least newSize structures, create a new view WGPUFragmentState.Ptr that uses the same backing storage as this WGPUFragmentState.Ptr, but with the new size.
@NotNull WGPUFuture.Ptr	WGPUFuture.Ptr.reinterpret(long newSize)	Assume the WGPUFuture.Ptr is capable of holding at least newSize structures, create a new view WGPUFuture.Ptr that uses the same backing storage as this WGPUFuture.Ptr, but with the new size.
@NotNull WGPUFutureWaitInfo.Ptr	WGPUFutureWaitInfo.Ptr.reinterpret(long newSize)	Assume the WGPUFutureWaitInfo.Ptr is capable of holding at least newSize structures, create a new view WGPUFutureWaitInfo.Ptr that uses the same backing storage as this WGPUFutureWaitInfo.Ptr, but with the new size.
@NotNull WGPUGlobalReport.Ptr	WGPUGlobalReport.Ptr.reinterpret(long newSize)	Assume the WGPUGlobalReport.Ptr is capable of holding at least newSize structures, create a new view WGPUGlobalReport.Ptr that uses the same backing storage as this WGPUGlobalReport.Ptr, but with the new size.
@NotNull WGPUHubReport.Ptr	WGPUHubReport.Ptr.reinterpret(long newSize)	Assume the WGPUHubReport.Ptr is capable of holding at least newSize structures, create a new view WGPUHubReport.Ptr that uses the same backing storage as this WGPUHubReport.Ptr, but with the new size.
@NotNull WGPUInstanceCapabilities.Ptr	WGPUInstanceCapabilities.Ptr.reinterpret(long newSize)	Assume the WGPUInstanceCapabilities.Ptr is capable of holding at least newSize structures, create a new view WGPUInstanceCapabilities.Ptr that uses the same backing storage as this WGPUInstanceCapabilities.Ptr, but with the new size.
@NotNull WGPUInstanceDescriptor.Ptr	WGPUInstanceDescriptor.Ptr.reinterpret(long newSize)	Assume the WGPUInstanceDescriptor.Ptr is capable of holding at least newSize structures, create a new view WGPUInstanceDescriptor.Ptr that uses the same backing storage as this WGPUInstanceDescriptor.Ptr, but with the new size.
@NotNull WGPUInstanceEnumerateAdapterOptions.Ptr	WGPUInstanceEnumerateAdapterOptions.Ptr.reinterpret(long newSize)	Assume the WGPUInstanceEnumerateAdapterOptions.Ptr is capable of holding at least newSize structures, create a new view WGPUInstanceEnumerateAdapterOptions.Ptr that uses the same backing storage as this WGPUInstanceEnumerateAdapterOptions.Ptr, but with the new size.
@NotNull WGPUInstanceExtras.Ptr	WGPUInstanceExtras.Ptr.reinterpret(long newSize)	Assume the WGPUInstanceExtras.Ptr is capable of holding at least newSize structures, create a new view WGPUInstanceExtras.Ptr that uses the same backing storage as this WGPUInstanceExtras.Ptr, but with the new size.
@NotNull WGPULimits.Ptr	WGPULimits.Ptr.reinterpret(long newSize)	Assume the WGPULimits.Ptr is capable of holding at least newSize structures, create a new view WGPULimits.Ptr that uses the same backing storage as this WGPULimits.Ptr, but with the new size.
@NotNull WGPUMultisampleState.Ptr	WGPUMultisampleState.Ptr.reinterpret(long newSize)	Assume the WGPUMultisampleState.Ptr is capable of holding at least newSize structures, create a new view WGPUMultisampleState.Ptr that uses the same backing storage as this WGPUMultisampleState.Ptr, but with the new size.
@NotNull WGPUNativeLimits.Ptr	WGPUNativeLimits.Ptr.reinterpret(long newSize)	Assume the WGPUNativeLimits.Ptr is capable of holding at least newSize structures, create a new view WGPUNativeLimits.Ptr that uses the same backing storage as this WGPUNativeLimits.Ptr, but with the new size.
@NotNull WGPUOrigin3d.Ptr	WGPUOrigin3d.Ptr.reinterpret(long newSize)	Assume the WGPUOrigin3d.Ptr is capable of holding at least newSize structures, create a new view WGPUOrigin3d.Ptr that uses the same backing storage as this WGPUOrigin3d.Ptr, but with the new size.
@NotNull WGPUPipelineLayoutDescriptor.Ptr	WGPUPipelineLayoutDescriptor.Ptr.reinterpret(long newSize)	Assume the WGPUPipelineLayoutDescriptor.Ptr is capable of holding at least newSize structures, create a new view WGPUPipelineLayoutDescriptor.Ptr that uses the same backing storage as this WGPUPipelineLayoutDescriptor.Ptr, but with the new size.
@NotNull WGPUPipelineLayoutExtras.Ptr	WGPUPipelineLayoutExtras.Ptr.reinterpret(long newSize)	Assume the WGPUPipelineLayoutExtras.Ptr is capable of holding at least newSize structures, create a new view WGPUPipelineLayoutExtras.Ptr that uses the same backing storage as this WGPUPipelineLayoutExtras.Ptr, but with the new size.
@NotNull WGPUPopErrorScopeCallbackInfo.Ptr	WGPUPopErrorScopeCallbackInfo.Ptr.reinterpret(long newSize)	Assume the WGPUPopErrorScopeCallbackInfo.Ptr is capable of holding at least newSize structures, create a new view WGPUPopErrorScopeCallbackInfo.Ptr that uses the same backing storage as this WGPUPopErrorScopeCallbackInfo.Ptr, but with the new size.
@NotNull WGPUPrimitiveState.Ptr	WGPUPrimitiveState.Ptr.reinterpret(long newSize)	Assume the WGPUPrimitiveState.Ptr is capable of holding at least newSize structures, create a new view WGPUPrimitiveState.Ptr that uses the same backing storage as this WGPUPrimitiveState.Ptr, but with the new size.
@NotNull WGPUProgrammableStageDescriptor.Ptr	WGPUProgrammableStageDescriptor.Ptr.reinterpret(long newSize)	Assume the WGPUProgrammableStageDescriptor.Ptr is capable of holding at least newSize structures, create a new view WGPUProgrammableStageDescriptor.Ptr that uses the same backing storage as this WGPUProgrammableStageDescriptor.Ptr, but with the new size.
@NotNull WGPUPushConstantRange.Ptr	WGPUPushConstantRange.Ptr.reinterpret(long newSize)	Assume the WGPUPushConstantRange.Ptr is capable of holding at least newSize structures, create a new view WGPUPushConstantRange.Ptr that uses the same backing storage as this WGPUPushConstantRange.Ptr, but with the new size.
@NotNull WGPUQuerySetDescriptor.Ptr	WGPUQuerySetDescriptor.Ptr.reinterpret(long newSize)	Assume the WGPUQuerySetDescriptor.Ptr is capable of holding at least newSize structures, create a new view WGPUQuerySetDescriptor.Ptr that uses the same backing storage as this WGPUQuerySetDescriptor.Ptr, but with the new size.
@NotNull WGPUQuerySetDescriptorExtras.Ptr	WGPUQuerySetDescriptorExtras.Ptr.reinterpret(long newSize)	Assume the WGPUQuerySetDescriptorExtras.Ptr is capable of holding at least newSize structures, create a new view WGPUQuerySetDescriptorExtras.Ptr that uses the same backing storage as this WGPUQuerySetDescriptorExtras.Ptr, but with the new size.
@NotNull WGPUQueueDescriptor.Ptr	WGPUQueueDescriptor.Ptr.reinterpret(long newSize)	Assume the WGPUQueueDescriptor.Ptr is capable of holding at least newSize structures, create a new view WGPUQueueDescriptor.Ptr that uses the same backing storage as this WGPUQueueDescriptor.Ptr, but with the new size.
@NotNull WGPUQueueWorkDoneCallbackInfo.Ptr	WGPUQueueWorkDoneCallbackInfo.Ptr.reinterpret(long newSize)	Assume the WGPUQueueWorkDoneCallbackInfo.Ptr is capable of holding at least newSize structures, create a new view WGPUQueueWorkDoneCallbackInfo.Ptr that uses the same backing storage as this WGPUQueueWorkDoneCallbackInfo.Ptr, but with the new size.
@NotNull WGPURegistryReport.Ptr	WGPURegistryReport.Ptr.reinterpret(long newSize)	Assume the WGPURegistryReport.Ptr is capable of holding at least newSize structures, create a new view WGPURegistryReport.Ptr that uses the same backing storage as this WGPURegistryReport.Ptr, but with the new size.
@NotNull WGPURenderBundleDescriptor.Ptr	WGPURenderBundleDescriptor.Ptr.reinterpret(long newSize)	Assume the WGPURenderBundleDescriptor.Ptr is capable of holding at least newSize structures, create a new view WGPURenderBundleDescriptor.Ptr that uses the same backing storage as this WGPURenderBundleDescriptor.Ptr, but with the new size.
@NotNull WGPURenderBundleEncoderDescriptor.Ptr	WGPURenderBundleEncoderDescriptor.Ptr.reinterpret(long newSize)	Assume the WGPURenderBundleEncoderDescriptor.Ptr is capable of holding at least newSize structures, create a new view WGPURenderBundleEncoderDescriptor.Ptr that uses the same backing storage as this WGPURenderBundleEncoderDescriptor.Ptr, but with the new size.
@NotNull WGPURenderPassColorAttachment.Ptr	WGPURenderPassColorAttachment.Ptr.reinterpret(long newSize)	Assume the WGPURenderPassColorAttachment.Ptr is capable of holding at least newSize structures, create a new view WGPURenderPassColorAttachment.Ptr that uses the same backing storage as this WGPURenderPassColorAttachment.Ptr, but with the new size.
@NotNull WGPURenderPassDepthStencilAttachment.Ptr	WGPURenderPassDepthStencilAttachment.Ptr.reinterpret(long newSize)	Assume the WGPURenderPassDepthStencilAttachment.Ptr is capable of holding at least newSize structures, create a new view WGPURenderPassDepthStencilAttachment.Ptr that uses the same backing storage as this WGPURenderPassDepthStencilAttachment.Ptr, but with the new size.
@NotNull WGPURenderPassDescriptor.Ptr	WGPURenderPassDescriptor.Ptr.reinterpret(long newSize)	Assume the WGPURenderPassDescriptor.Ptr is capable of holding at least newSize structures, create a new view WGPURenderPassDescriptor.Ptr that uses the same backing storage as this WGPURenderPassDescriptor.Ptr, but with the new size.
@NotNull WGPURenderPassMaxDrawCount.Ptr	WGPURenderPassMaxDrawCount.Ptr.reinterpret(long newSize)	Assume the WGPURenderPassMaxDrawCount.Ptr is capable of holding at least newSize structures, create a new view WGPURenderPassMaxDrawCount.Ptr that uses the same backing storage as this WGPURenderPassMaxDrawCount.Ptr, but with the new size.
@NotNull WGPURenderPassTimestampWrites.Ptr	WGPURenderPassTimestampWrites.Ptr.reinterpret(long newSize)	Assume the WGPURenderPassTimestampWrites.Ptr is capable of holding at least newSize structures, create a new view WGPURenderPassTimestampWrites.Ptr that uses the same backing storage as this WGPURenderPassTimestampWrites.Ptr, but with the new size.
@NotNull WGPURenderPipelineDescriptor.Ptr	WGPURenderPipelineDescriptor.Ptr.reinterpret(long newSize)	Assume the WGPURenderPipelineDescriptor.Ptr is capable of holding at least newSize structures, create a new view WGPURenderPipelineDescriptor.Ptr that uses the same backing storage as this WGPURenderPipelineDescriptor.Ptr, but with the new size.
@NotNull WGPURequestAdapterCallbackInfo.Ptr	WGPURequestAdapterCallbackInfo.Ptr.reinterpret(long newSize)	Assume the WGPURequestAdapterCallbackInfo.Ptr is capable of holding at least newSize structures, create a new view WGPURequestAdapterCallbackInfo.Ptr that uses the same backing storage as this WGPURequestAdapterCallbackInfo.Ptr, but with the new size.
@NotNull WGPURequestAdapterOptions.Ptr	WGPURequestAdapterOptions.Ptr.reinterpret(long newSize)	Assume the WGPURequestAdapterOptions.Ptr is capable of holding at least newSize structures, create a new view WGPURequestAdapterOptions.Ptr that uses the same backing storage as this WGPURequestAdapterOptions.Ptr, but with the new size.
@NotNull WGPURequestDeviceCallbackInfo.Ptr	WGPURequestDeviceCallbackInfo.Ptr.reinterpret(long newSize)	Assume the WGPURequestDeviceCallbackInfo.Ptr is capable of holding at least newSize structures, create a new view WGPURequestDeviceCallbackInfo.Ptr that uses the same backing storage as this WGPURequestDeviceCallbackInfo.Ptr, but with the new size.
@NotNull WGPUSamplerBindingLayout.Ptr	WGPUSamplerBindingLayout.Ptr.reinterpret(long newSize)	Assume the WGPUSamplerBindingLayout.Ptr is capable of holding at least newSize structures, create a new view WGPUSamplerBindingLayout.Ptr that uses the same backing storage as this WGPUSamplerBindingLayout.Ptr, but with the new size.
@NotNull WGPUSamplerDescriptor.Ptr	WGPUSamplerDescriptor.Ptr.reinterpret(long newSize)	Assume the WGPUSamplerDescriptor.Ptr is capable of holding at least newSize structures, create a new view WGPUSamplerDescriptor.Ptr that uses the same backing storage as this WGPUSamplerDescriptor.Ptr, but with the new size.
@NotNull WGPUShaderDefine.Ptr	WGPUShaderDefine.Ptr.reinterpret(long newSize)	Assume the WGPUShaderDefine.Ptr is capable of holding at least newSize structures, create a new view WGPUShaderDefine.Ptr that uses the same backing storage as this WGPUShaderDefine.Ptr, but with the new size.
@NotNull WGPUShaderModuleDescriptor.Ptr	WGPUShaderModuleDescriptor.Ptr.reinterpret(long newSize)	Assume the WGPUShaderModuleDescriptor.Ptr is capable of holding at least newSize structures, create a new view WGPUShaderModuleDescriptor.Ptr that uses the same backing storage as this WGPUShaderModuleDescriptor.Ptr, but with the new size.
@NotNull WGPUShaderModuleDescriptorSpirV.Ptr	WGPUShaderModuleDescriptorSpirV.Ptr.reinterpret(long newSize)	Assume the WGPUShaderModuleDescriptorSpirV.Ptr is capable of holding at least newSize structures, create a new view WGPUShaderModuleDescriptorSpirV.Ptr that uses the same backing storage as this WGPUShaderModuleDescriptorSpirV.Ptr, but with the new size.
@NotNull WGPUShaderSourceGLSL.Ptr	WGPUShaderSourceGLSL.Ptr.reinterpret(long newSize)	Assume the WGPUShaderSourceGLSL.Ptr is capable of holding at least newSize structures, create a new view WGPUShaderSourceGLSL.Ptr that uses the same backing storage as this WGPUShaderSourceGLSL.Ptr, but with the new size.
@NotNull WGPUShaderSourceSpirv.Ptr	WGPUShaderSourceSpirv.Ptr.reinterpret(long newSize)	Assume the WGPUShaderSourceSpirv.Ptr is capable of holding at least newSize structures, create a new view WGPUShaderSourceSpirv.Ptr that uses the same backing storage as this WGPUShaderSourceSpirv.Ptr, but with the new size.
@NotNull WGPUShaderSourceWgsl.Ptr	WGPUShaderSourceWgsl.Ptr.reinterpret(long newSize)	Assume the WGPUShaderSourceWgsl.Ptr is capable of holding at least newSize structures, create a new view WGPUShaderSourceWgsl.Ptr that uses the same backing storage as this WGPUShaderSourceWgsl.Ptr, but with the new size.
@NotNull WGPUStencilFaceState.Ptr	WGPUStencilFaceState.Ptr.reinterpret(long newSize)	Assume the WGPUStencilFaceState.Ptr is capable of holding at least newSize structures, create a new view WGPUStencilFaceState.Ptr that uses the same backing storage as this WGPUStencilFaceState.Ptr, but with the new size.
@NotNull WGPUStorageTextureBindingLayout.Ptr	WGPUStorageTextureBindingLayout.Ptr.reinterpret(long newSize)	Assume the WGPUStorageTextureBindingLayout.Ptr is capable of holding at least newSize structures, create a new view WGPUStorageTextureBindingLayout.Ptr that uses the same backing storage as this WGPUStorageTextureBindingLayout.Ptr, but with the new size.
@NotNull WGPUStringView.Ptr	WGPUStringView.Ptr.reinterpret(long newSize)	Assume the WGPUStringView.Ptr is capable of holding at least newSize structures, create a new view WGPUStringView.Ptr that uses the same backing storage as this WGPUStringView.Ptr, but with the new size.
@NotNull WGPUSupportedFeatures.Ptr	WGPUSupportedFeatures.Ptr.reinterpret(long newSize)	Assume the WGPUSupportedFeatures.Ptr is capable of holding at least newSize structures, create a new view WGPUSupportedFeatures.Ptr that uses the same backing storage as this WGPUSupportedFeatures.Ptr, but with the new size.
@NotNull WGPUSupportedWgslLanguageFeatures.Ptr	WGPUSupportedWgslLanguageFeatures.Ptr.reinterpret(long newSize)	Assume the WGPUSupportedWgslLanguageFeatures.Ptr is capable of holding at least newSize structures, create a new view WGPUSupportedWgslLanguageFeatures.Ptr that uses the same backing storage as this WGPUSupportedWgslLanguageFeatures.Ptr, but with the new size.
@NotNull WGPUSurfaceCapabilities.Ptr	WGPUSurfaceCapabilities.Ptr.reinterpret(long newSize)	Assume the WGPUSurfaceCapabilities.Ptr is capable of holding at least newSize structures, create a new view WGPUSurfaceCapabilities.Ptr that uses the same backing storage as this WGPUSurfaceCapabilities.Ptr, but with the new size.
@NotNull WGPUSurfaceConfiguration.Ptr	WGPUSurfaceConfiguration.Ptr.reinterpret(long newSize)	Assume the WGPUSurfaceConfiguration.Ptr is capable of holding at least newSize structures, create a new view WGPUSurfaceConfiguration.Ptr that uses the same backing storage as this WGPUSurfaceConfiguration.Ptr, but with the new size.
@NotNull WGPUSurfaceConfigurationExtras.Ptr	WGPUSurfaceConfigurationExtras.Ptr.reinterpret(long newSize)	Assume the WGPUSurfaceConfigurationExtras.Ptr is capable of holding at least newSize structures, create a new view WGPUSurfaceConfigurationExtras.Ptr that uses the same backing storage as this WGPUSurfaceConfigurationExtras.Ptr, but with the new size.
@NotNull WGPUSurfaceDescriptor.Ptr	WGPUSurfaceDescriptor.Ptr.reinterpret(long newSize)	Assume the WGPUSurfaceDescriptor.Ptr is capable of holding at least newSize structures, create a new view WGPUSurfaceDescriptor.Ptr that uses the same backing storage as this WGPUSurfaceDescriptor.Ptr, but with the new size.
@NotNull WGPUSurfaceSourceAndroidNativeWindow.Ptr	WGPUSurfaceSourceAndroidNativeWindow.Ptr.reinterpret(long newSize)	Assume the WGPUSurfaceSourceAndroidNativeWindow.Ptr is capable of holding at least newSize structures, create a new view WGPUSurfaceSourceAndroidNativeWindow.Ptr that uses the same backing storage as this WGPUSurfaceSourceAndroidNativeWindow.Ptr, but with the new size.
@NotNull WGPUSurfaceSourceMetalLayer.Ptr	WGPUSurfaceSourceMetalLayer.Ptr.reinterpret(long newSize)	Assume the WGPUSurfaceSourceMetalLayer.Ptr is capable of holding at least newSize structures, create a new view WGPUSurfaceSourceMetalLayer.Ptr that uses the same backing storage as this WGPUSurfaceSourceMetalLayer.Ptr, but with the new size.
@NotNull WGPUSurfaceSourceWaylandSurface.Ptr	WGPUSurfaceSourceWaylandSurface.Ptr.reinterpret(long newSize)	Assume the WGPUSurfaceSourceWaylandSurface.Ptr is capable of holding at least newSize structures, create a new view WGPUSurfaceSourceWaylandSurface.Ptr that uses the same backing storage as this WGPUSurfaceSourceWaylandSurface.Ptr, but with the new size.
@NotNull WGPUSurfaceSourceWindowsHwnd.Ptr	WGPUSurfaceSourceWindowsHwnd.Ptr.reinterpret(long newSize)	Assume the WGPUSurfaceSourceWindowsHwnd.Ptr is capable of holding at least newSize structures, create a new view WGPUSurfaceSourceWindowsHwnd.Ptr that uses the same backing storage as this WGPUSurfaceSourceWindowsHwnd.Ptr, but with the new size.
@NotNull WGPUSurfaceSourceXcbWindow.Ptr	WGPUSurfaceSourceXcbWindow.Ptr.reinterpret(long newSize)	Assume the WGPUSurfaceSourceXcbWindow.Ptr is capable of holding at least newSize structures, create a new view WGPUSurfaceSourceXcbWindow.Ptr that uses the same backing storage as this WGPUSurfaceSourceXcbWindow.Ptr, but with the new size.
@NotNull WGPUSurfaceSourceXlibWindow.Ptr	WGPUSurfaceSourceXlibWindow.Ptr.reinterpret(long newSize)	Assume the WGPUSurfaceSourceXlibWindow.Ptr is capable of holding at least newSize structures, create a new view WGPUSurfaceSourceXlibWindow.Ptr that uses the same backing storage as this WGPUSurfaceSourceXlibWindow.Ptr, but with the new size.
@NotNull WGPUSurfaceTexture.Ptr	WGPUSurfaceTexture.Ptr.reinterpret(long newSize)	Assume the WGPUSurfaceTexture.Ptr is capable of holding at least newSize structures, create a new view WGPUSurfaceTexture.Ptr that uses the same backing storage as this WGPUSurfaceTexture.Ptr, but with the new size.
@NotNull WGPUTexelCopyBufferInfo.Ptr	WGPUTexelCopyBufferInfo.Ptr.reinterpret(long newSize)	Assume the WGPUTexelCopyBufferInfo.Ptr is capable of holding at least newSize structures, create a new view WGPUTexelCopyBufferInfo.Ptr that uses the same backing storage as this WGPUTexelCopyBufferInfo.Ptr, but with the new size.
@NotNull WGPUTexelCopyBufferLayout.Ptr	WGPUTexelCopyBufferLayout.Ptr.reinterpret(long newSize)	Assume the WGPUTexelCopyBufferLayout.Ptr is capable of holding at least newSize structures, create a new view WGPUTexelCopyBufferLayout.Ptr that uses the same backing storage as this WGPUTexelCopyBufferLayout.Ptr, but with the new size.
@NotNull WGPUTexelCopyTextureInfo.Ptr	WGPUTexelCopyTextureInfo.Ptr.reinterpret(long newSize)	Assume the WGPUTexelCopyTextureInfo.Ptr is capable of holding at least newSize structures, create a new view WGPUTexelCopyTextureInfo.Ptr that uses the same backing storage as this WGPUTexelCopyTextureInfo.Ptr, but with the new size.
@NotNull WGPUTextureBindingLayout.Ptr	WGPUTextureBindingLayout.Ptr.reinterpret(long newSize)	Assume the WGPUTextureBindingLayout.Ptr is capable of holding at least newSize structures, create a new view WGPUTextureBindingLayout.Ptr that uses the same backing storage as this WGPUTextureBindingLayout.Ptr, but with the new size.
@NotNull WGPUTextureDescriptor.Ptr	WGPUTextureDescriptor.Ptr.reinterpret(long newSize)	Assume the WGPUTextureDescriptor.Ptr is capable of holding at least newSize structures, create a new view WGPUTextureDescriptor.Ptr that uses the same backing storage as this WGPUTextureDescriptor.Ptr, but with the new size.
@NotNull WGPUTextureViewDescriptor.Ptr	WGPUTextureViewDescriptor.Ptr.reinterpret(long newSize)	Assume the WGPUTextureViewDescriptor.Ptr is capable of holding at least newSize structures, create a new view WGPUTextureViewDescriptor.Ptr that uses the same backing storage as this WGPUTextureViewDescriptor.Ptr, but with the new size.
@NotNull WGPUUncapturedErrorCallbackInfo.Ptr	WGPUUncapturedErrorCallbackInfo.Ptr.reinterpret(long newSize)	Assume the WGPUUncapturedErrorCallbackInfo.Ptr is capable of holding at least newSize structures, create a new view WGPUUncapturedErrorCallbackInfo.Ptr that uses the same backing storage as this WGPUUncapturedErrorCallbackInfo.Ptr, but with the new size.
@NotNull WGPUVertexAttribute.Ptr	WGPUVertexAttribute.Ptr.reinterpret(long newSize)	Assume the WGPUVertexAttribute.Ptr is capable of holding at least newSize structures, create a new view WGPUVertexAttribute.Ptr that uses the same backing storage as this WGPUVertexAttribute.Ptr, but with the new size.
@NotNull WGPUVertexBufferLayout.Ptr	WGPUVertexBufferLayout.Ptr.reinterpret(long newSize)	Assume the WGPUVertexBufferLayout.Ptr is capable of holding at least newSize structures, create a new view WGPUVertexBufferLayout.Ptr that uses the same backing storage as this WGPUVertexBufferLayout.Ptr, but with the new size.
@NotNull WGPUVertexState.Ptr	WGPUVertexState.Ptr.reinterpret(long newSize)	Assume the WGPUVertexState.Ptr is capable of holding at least newSize structures, create a new view WGPUVertexState.Ptr that uses the same backing storage as this WGPUVertexState.Ptr, but with the new size.
WGPULimits.Ptr	WGPUDeviceDescriptor.requiredLimits(int assumedCount)
WGPUColorTargetState.Ptr	WGPUFragmentState.targets(int assumedCount)
WGPUComputePassTimestampWrites.Ptr	WGPUComputePassDescriptor.timestampWrites(int assumedCount)
WGPURenderPassTimestampWrites.Ptr	WGPURenderPassDescriptor.timestampWrites(int assumedCount)

Uses of Unsafe in club.doki7.webgpu.handle

Methods in club.doki7.webgpu.handle with annotations of type Unsafe

Modifier and Type	Method	Description
WGPUAdapter.Ptr	WGPUAdapter.Ptr.reinterpret(long newSize)	Assume the WGPUAdapter.Ptr is capable of holding at least newSize handles, create a new view WGPUAdapter.Ptr that uses the same backing storage as this WGPUAdapter.Ptr, but with the new size.
WGPUBindGroup.Ptr	WGPUBindGroup.Ptr.reinterpret(long newSize)	Assume the WGPUBindGroup.Ptr is capable of holding at least newSize handles, create a new view WGPUBindGroup.Ptr that uses the same backing storage as this WGPUBindGroup.Ptr, but with the new size.
WGPUBindGroupLayout.Ptr	WGPUBindGroupLayout.Ptr.reinterpret(long newSize)	Assume the WGPUBindGroupLayout.Ptr is capable of holding at least newSize handles, create a new view WGPUBindGroupLayout.Ptr that uses the same backing storage as this WGPUBindGroupLayout.Ptr, but with the new size.
WGPUBuffer.Ptr	WGPUBuffer.Ptr.reinterpret(long newSize)	Assume the WGPUBuffer.Ptr is capable of holding at least newSize handles, create a new view WGPUBuffer.Ptr that uses the same backing storage as this WGPUBuffer.Ptr, but with the new size.
WGPUCommandBuffer.Ptr	WGPUCommandBuffer.Ptr.reinterpret(long newSize)	Assume the WGPUCommandBuffer.Ptr is capable of holding at least newSize handles, create a new view WGPUCommandBuffer.Ptr that uses the same backing storage as this WGPUCommandBuffer.Ptr, but with the new size.
WGPUCommandEncoder.Ptr	WGPUCommandEncoder.Ptr.reinterpret(long newSize)	Assume the WGPUCommandEncoder.Ptr is capable of holding at least newSize handles, create a new view WGPUCommandEncoder.Ptr that uses the same backing storage as this WGPUCommandEncoder.Ptr, but with the new size.
WGPUComputePassEncoder.Ptr	WGPUComputePassEncoder.Ptr.reinterpret(long newSize)	Assume the WGPUComputePassEncoder.Ptr is capable of holding at least newSize handles, create a new view WGPUComputePassEncoder.Ptr that uses the same backing storage as this WGPUComputePassEncoder.Ptr, but with the new size.
WGPUComputePipeline.Ptr	WGPUComputePipeline.Ptr.reinterpret(long newSize)	Assume the WGPUComputePipeline.Ptr is capable of holding at least newSize handles, create a new view WGPUComputePipeline.Ptr that uses the same backing storage as this WGPUComputePipeline.Ptr, but with the new size.
WGPUDevice.Ptr	WGPUDevice.Ptr.reinterpret(long newSize)	Assume the WGPUDevice.Ptr is capable of holding at least newSize handles, create a new view WGPUDevice.Ptr that uses the same backing storage as this WGPUDevice.Ptr, but with the new size.
WGPUInstance.Ptr	WGPUInstance.Ptr.reinterpret(long newSize)	Assume the WGPUInstance.Ptr is capable of holding at least newSize handles, create a new view WGPUInstance.Ptr that uses the same backing storage as this WGPUInstance.Ptr, but with the new size.
WGPUPipelineLayout.Ptr	WGPUPipelineLayout.Ptr.reinterpret(long newSize)	Assume the WGPUPipelineLayout.Ptr is capable of holding at least newSize handles, create a new view WGPUPipelineLayout.Ptr that uses the same backing storage as this WGPUPipelineLayout.Ptr, but with the new size.
WGPUQuerySet.Ptr	WGPUQuerySet.Ptr.reinterpret(long newSize)	Assume the WGPUQuerySet.Ptr is capable of holding at least newSize handles, create a new view WGPUQuerySet.Ptr that uses the same backing storage as this WGPUQuerySet.Ptr, but with the new size.
WGPUQueue.Ptr	WGPUQueue.Ptr.reinterpret(long newSize)	Assume the WGPUQueue.Ptr is capable of holding at least newSize handles, create a new view WGPUQueue.Ptr that uses the same backing storage as this WGPUQueue.Ptr, but with the new size.
WGPURenderBundle.Ptr	WGPURenderBundle.Ptr.reinterpret(long newSize)	Assume the WGPURenderBundle.Ptr is capable of holding at least newSize handles, create a new view WGPURenderBundle.Ptr that uses the same backing storage as this WGPURenderBundle.Ptr, but with the new size.
WGPURenderBundleEncoder.Ptr	WGPURenderBundleEncoder.Ptr.reinterpret(long newSize)	Assume the WGPURenderBundleEncoder.Ptr is capable of holding at least newSize handles, create a new view WGPURenderBundleEncoder.Ptr that uses the same backing storage as this WGPURenderBundleEncoder.Ptr, but with the new size.
WGPURenderPassEncoder.Ptr	WGPURenderPassEncoder.Ptr.reinterpret(long newSize)	Assume the WGPURenderPassEncoder.Ptr is capable of holding at least newSize handles, create a new view WGPURenderPassEncoder.Ptr that uses the same backing storage as this WGPURenderPassEncoder.Ptr, but with the new size.
WGPURenderPipeline.Ptr	WGPURenderPipeline.Ptr.reinterpret(long newSize)	Assume the WGPURenderPipeline.Ptr is capable of holding at least newSize handles, create a new view WGPURenderPipeline.Ptr that uses the same backing storage as this WGPURenderPipeline.Ptr, but with the new size.
WGPUSampler.Ptr	WGPUSampler.Ptr.reinterpret(long newSize)	Assume the WGPUSampler.Ptr is capable of holding at least newSize handles, create a new view WGPUSampler.Ptr that uses the same backing storage as this WGPUSampler.Ptr, but with the new size.
WGPUShaderModule.Ptr	WGPUShaderModule.Ptr.reinterpret(long newSize)	Assume the WGPUShaderModule.Ptr is capable of holding at least newSize handles, create a new view WGPUShaderModule.Ptr that uses the same backing storage as this WGPUShaderModule.Ptr, but with the new size.
WGPUSurface.Ptr	WGPUSurface.Ptr.reinterpret(long newSize)	Assume the WGPUSurface.Ptr is capable of holding at least newSize handles, create a new view WGPUSurface.Ptr that uses the same backing storage as this WGPUSurface.Ptr, but with the new size.
WGPUTexture.Ptr	WGPUTexture.Ptr.reinterpret(long newSize)	Assume the WGPUTexture.Ptr is capable of holding at least newSize handles, create a new view WGPUTexture.Ptr that uses the same backing storage as this WGPUTexture.Ptr, but with the new size.
WGPUTextureView.Ptr	WGPUTextureView.Ptr.reinterpret(long newSize)	Assume the WGPUTextureView.Ptr is capable of holding at least newSize handles, create a new view WGPUTextureView.Ptr that uses the same backing storage as this WGPUTextureView.Ptr, but with the new size.