@bloomengine/engine 0.4.1 → 0.4.2

package/native/tvos/metal-patched/src/capturedescriptor.rs

@@ -0,0 +1,76 @@
+// Copyright 2020 GFX developers
+//
+// Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
+// http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
+// http://opensource.org/licenses/MIT>, at your option. This file may not be
+// copied, modified, or distributed except according to those terms.
+
+use super::*;
+
+use std::path::Path;
+
+/// See <https://developer.apple.com/documentation/metal/mtlcapturedestination?language=objc>
+#[repr(u64)]
+#[allow(non_camel_case_types)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
+pub enum MTLCaptureDestination {
+    DeveloperTools = 1,
+    GpuTraceDocument = 2,
+}
+
+/// See <https://developer.apple.com/documentation/metal/mtlcapturedescriptor>
+pub enum MTLCaptureDescriptor {}
+
+foreign_obj_type! {
+    type CType = MTLCaptureDescriptor;
+    pub struct CaptureDescriptor;
+}
+
+impl CaptureDescriptor {
+    pub fn new() -> Self {
+        unsafe {
+            let class = class!(MTLCaptureDescriptor);
+            msg_send![class, new]
+        }
+    }
+}
+
+impl CaptureDescriptorRef {
+    /// See <https://developer.apple.com/documentation/metal/mtlcapturedescriptor/3237248-captureobject>
+    pub fn set_capture_device(&self, device: &DeviceRef) {
+        unsafe { msg_send![self, setCaptureObject: device] }
+    }
+
+    /// See <https://developer.apple.com/documentation/metal/mtlcapturedescriptor/3237248-captureobject>
+    pub fn set_capture_scope(&self, scope: &CaptureScopeRef) {
+        unsafe { msg_send![self, setCaptureObject: scope] }
+    }
+
+    /// See <https://developer.apple.com/documentation/metal/mtlcapturedescriptor/3237248-captureobject>
+    pub fn set_capture_command_queue(&self, command_queue: &CommandQueueRef) {
+        unsafe { msg_send![self, setCaptureObject: command_queue] }
+    }
+
+    /// See <https://developer.apple.com/documentation/metal/mtlcapturedescriptor/3237250-outputurl>
+    pub fn output_url(&self) -> &Path {
+        let url: &URLRef = unsafe { msg_send![self, outputURL] };
+        Path::new(url.path())
+    }
+
+    /// See <https://developer.apple.com/documentation/metal/mtlcapturedescriptor/3237250-outputurl>
+    pub fn set_output_url<P: AsRef<Path>>(&self, output_url: P) {
+        let output_url_string = String::from("file://") + output_url.as_ref().to_str().unwrap();
+        let output_url = URL::new_with_string(&output_url_string);
+        unsafe { msg_send![self, setOutputURL: output_url] }
+    }
+
+    /// See <https://developer.apple.com/documentation/metal/mtlcapturedescriptor?language=objc>
+    pub fn destination(&self) -> MTLCaptureDestination {
+        unsafe { msg_send![self, destination] }
+    }
+
+    /// See <https://developer.apple.com/documentation/metal/mtlcapturedescriptor?language=objc>
+    pub fn set_destination(&self, destination: MTLCaptureDestination) {
+        unsafe { msg_send![self, setDestination: destination] }
+    }
+}

package/native/tvos/metal-patched/src/capturemanager.rs

@@ -0,0 +1,113 @@
+// Copyright 2018 GFX developers
+//
+// Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
+// http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
+// http://opensource.org/licenses/MIT>, at your option. This file may not be
+// copied, modified, or distributed except according to those terms.
+
+use super::*;
+use std::ffi::CStr;
+
+/// See <https://developer.apple.com/documentation/metal/mtlcapturescope>
+pub enum MTLCaptureScope {}
+
+foreign_obj_type! {
+    type CType = MTLCaptureScope;
+    pub struct CaptureScope;
+}
+
+impl CaptureScopeRef {
+    pub fn begin_scope(&self) {
+        unsafe { msg_send![self, beginScope] }
+    }
+
+    pub fn end_scope(&self) {
+        unsafe { msg_send![self, endScope] }
+    }
+
+    pub fn label(&self) -> &str {
+        unsafe {
+            let label = msg_send![self, label];
+            crate::nsstring_as_str(label)
+        }
+    }
+}
+
+/// See <https://developer.apple.com/documentation/metal/mtlcapturemanager>
+pub enum MTLCaptureManager {}
+
+foreign_obj_type! {
+    type CType = MTLCaptureManager;
+    pub struct CaptureManager;
+}
+
+impl CaptureManager {
+    pub fn shared<'a>() -> &'a CaptureManagerRef {
+        unsafe {
+            let class = class!(MTLCaptureManager);
+            msg_send![class, sharedCaptureManager]
+        }
+    }
+}
+
+impl CaptureManagerRef {
+    pub fn new_capture_scope_with_device(&self, device: &DeviceRef) -> CaptureScope {
+        unsafe { msg_send![self, newCaptureScopeWithDevice: device] }
+    }
+
+    pub fn new_capture_scope_with_command_queue(
+        &self,
+        command_queue: &CommandQueueRef,
+    ) -> CaptureScope {
+        unsafe { msg_send![self, newCaptureScopeWithCommandQueue: command_queue] }
+    }
+
+    pub fn default_capture_scope(&self) -> Option<&CaptureScopeRef> {
+        unsafe { msg_send![self, defaultCaptureScope] }
+    }
+
+    pub fn set_default_capture_scope(&self, scope: &CaptureScopeRef) {
+        unsafe { msg_send![self, setDefaultCaptureScope: scope] }
+    }
+
+    /// Starts capturing with the capture session defined by a descriptor object.
+    ///
+    /// This function will panic if Metal capture is not enabled.  Capture can be enabled by
+    /// either:
+    ///   1. Running from Xcode
+    ///   2. Setting the environment variable `METAL_CAPTURE_ENABLED=1`
+    ///   3. Adding an info.plist file containing the `MetalCaptureEnabled` key set to `YES`
+    pub fn start_capture(&self, descriptor: &CaptureDescriptorRef) -> Result<(), String> {
+        unsafe {
+            Ok(try_objc! { err =>
+                msg_send![self, startCaptureWithDescriptor: descriptor
+                                error: &mut err]
+            })
+        }
+    }
+
+    pub fn start_capture_with_device(&self, device: &DeviceRef) {
+        unsafe { msg_send![self, startCaptureWithDevice: device] }
+    }
+
+    pub fn start_capture_with_command_queue(&self, command_queue: &CommandQueueRef) {
+        unsafe { msg_send![self, startCaptureWithCommandQueue: command_queue] }
+    }
+
+    pub fn start_capture_with_scope(&self, scope: &CaptureScopeRef) {
+        unsafe { msg_send![self, startCaptureWithScope: scope] }
+    }
+
+    pub fn stop_capture(&self) {
+        unsafe { msg_send![self, stopCapture] }
+    }
+
+    pub fn is_capturing(&self) -> bool {
+        unsafe { msg_send![self, isCapturing] }
+    }
+
+    /// See <https://developer.apple.com/documentation/metal/mtlcapturemanager/3237260-supportsdestination?language=objc>
+    pub fn supports_destination(&self, destination: MTLCaptureDestination) -> bool {
+        unsafe { msg_send![self, supportsDestination: destination] }
+    }
+}

package/native/tvos/metal-patched/src/commandbuffer.rs

@@ -0,0 +1,192 @@
+// Copyright 2016 GFX developers
+//
+// Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
+// http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
+// http://opensource.org/licenses/MIT>, at your option. This file may not be
+// copied, modified, or distributed except according to those terms.
+
+use super::*;
+
+use block::Block;
+
+/// See <https://developer.apple.com/documentation/metal/mtlcommandbufferstatus>
+#[repr(u32)]
+#[allow(non_camel_case_types)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
+pub enum MTLCommandBufferStatus {
+    NotEnqueued = 0,
+    Enqueued = 1,
+    Committed = 2,
+    Scheduled = 3,
+    Completed = 4,
+    Error = 5,
+}
+
+/// See <https://developer.apple.com/documentation/metal/mtlcommandbuffererror>
+#[repr(u32)]
+#[allow(non_camel_case_types)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
+pub enum MTLCommandBufferError {
+    None = 0,
+    Internal = 1,
+    Timeout = 2,
+    PageFault = 3,
+    Blacklisted = 4,
+    NotPermitted = 7,
+    OutOfMemory = 8,
+    InvalidResource = 9,
+    Memoryless = 10,
+    DeviceRemoved = 11,
+}
+
+/// See <https://developer.apple.com/documentation/metal/mtldispatchtype>
+#[repr(u32)]
+#[allow(non_camel_case_types)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
+pub enum MTLDispatchType {
+    Serial = 0,
+    Concurrent = 1,
+}
+
+type CommandBufferHandler<'a> = Block<(&'a CommandBufferRef,), ()>;
+
+/// See <https://developer.apple.com/documentation/metal/mtlcommandbuffer>.
+pub enum MTLCommandBuffer {}
+
+foreign_obj_type! {
+    type CType = MTLCommandBuffer;
+    pub struct CommandBuffer;
+}
+
+impl CommandBufferRef {
+    pub fn label(&self) -> &str {
+        unsafe {
+            let label = msg_send![self, label];
+            crate::nsstring_as_str(label)
+        }
+    }
+
+    pub fn set_label(&self, label: &str) {
+        unsafe {
+            let nslabel = crate::nsstring_from_str(label);
+            let () = msg_send![self, setLabel: nslabel];
+        }
+    }
+
+    pub fn enqueue(&self) {
+        unsafe { msg_send![self, enqueue] }
+    }
+
+    pub fn commit(&self) {
+        unsafe { msg_send![self, commit] }
+    }
+
+    pub fn status(&self) -> MTLCommandBufferStatus {
+        unsafe { msg_send![self, status] }
+    }
+
+    pub fn present_drawable(&self, drawable: &DrawableRef) {
+        unsafe { msg_send![self, presentDrawable: drawable] }
+    }
+
+    pub fn wait_until_completed(&self) {
+        unsafe { msg_send![self, waitUntilCompleted] }
+    }
+
+    pub fn wait_until_scheduled(&self) {
+        unsafe { msg_send![self, waitUntilScheduled] }
+    }
+
+    pub fn add_completed_handler(&self, block: &CommandBufferHandler) {
+        unsafe { msg_send![self, addCompletedHandler: block] }
+    }
+
+    pub fn add_scheduled_handler(&self, block: &CommandBufferHandler) {
+        unsafe { msg_send![self, addScheduledHandler: block] }
+    }
+
+    pub fn new_blit_command_encoder(&self) -> &BlitCommandEncoderRef {
+        unsafe { msg_send![self, blitCommandEncoder] }
+    }
+
+    pub fn blit_command_encoder_with_descriptor(
+        &self,
+        descriptor: &BlitPassDescriptorRef,
+    ) -> &BlitCommandEncoderRef {
+        unsafe { msg_send![self, blitCommandEncoderWithDescriptor: descriptor] }
+    }
+
+    pub fn new_compute_command_encoder(&self) -> &ComputeCommandEncoderRef {
+        unsafe { msg_send![self, computeCommandEncoder] }
+    }
+
+    pub fn compute_command_encoder_with_dispatch_type(
+        &self,
+        ty: MTLDispatchType,
+    ) -> &ComputeCommandEncoderRef {
+        unsafe { msg_send![self, computeCommandEncoderWithDispatchType: ty] }
+    }
+
+    pub fn compute_command_encoder_with_descriptor(
+        &self,
+        descriptor: &ComputePassDescriptorRef,
+    ) -> &ComputeCommandEncoderRef {
+        unsafe { msg_send![self, computeCommandEncoderWithDescriptor: descriptor] }
+    }
+
+    pub fn new_render_command_encoder(
+        &self,
+        descriptor: &RenderPassDescriptorRef,
+    ) -> &RenderCommandEncoderRef {
+        unsafe { msg_send![self, renderCommandEncoderWithDescriptor: descriptor] }
+    }
+
+    pub fn new_parallel_render_command_encoder(
+        &self,
+        descriptor: &RenderPassDescriptorRef,
+    ) -> &ParallelRenderCommandEncoderRef {
+        unsafe { msg_send![self, parallelRenderCommandEncoderWithDescriptor: descriptor] }
+    }
+
+    pub fn new_acceleration_structure_command_encoder(
+        &self,
+    ) -> &AccelerationStructureCommandEncoderRef {
+        unsafe { msg_send![self, accelerationStructureCommandEncoder] }
+    }
+
+    pub fn acceleration_structure_command_encoder_with_descriptor(
+        &self,
+        descriptor: &AccelerationStructurePassDescriptorRef,
+    ) -> &AccelerationStructureCommandEncoderRef {
+        unsafe { msg_send![self, accelerationStructureCommandEncoderWithDescriptor: descriptor] }
+    }
+
+    pub fn encode_signal_event(&self, event: &EventRef, new_value: u64) {
+        unsafe {
+            msg_send![self,
+                encodeSignalEvent: event
+                value: new_value
+            ]
+        }
+    }
+
+    pub fn encode_wait_for_event(&self, event: &EventRef, value: u64) {
+        unsafe {
+            msg_send![self,
+                encodeWaitForEvent: event
+                value: value
+            ]
+        }
+    }
+
+    pub fn push_debug_group(&self, name: &str) {
+        unsafe {
+            let nslabel = crate::nsstring_from_str(name);
+            msg_send![self, pushDebugGroup: nslabel]
+        }
+    }
+
+    pub fn pop_debug_group(&self) {
+        unsafe { msg_send![self, popDebugGroup] }
+    }
+}

package/native/tvos/metal-patched/src/commandqueue.rs

@@ -0,0 +1,44 @@
+// Copyright 2016 GFX developers
+//
+// Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
+// http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
+// http://opensource.org/licenses/MIT>, at your option. This file may not be
+// copied, modified, or distributed except according to those terms.
+
+use super::*;
+
+/// See <https://developer.apple.com/documentation/metal/mtlcommandqueue>.
+pub enum MTLCommandQueue {}
+
+foreign_obj_type! {
+    type CType = MTLCommandQueue;
+    pub struct CommandQueue;
+}
+
+impl CommandQueueRef {
+    pub fn label(&self) -> &str {
+        unsafe {
+            let label = msg_send![self, label];
+            crate::nsstring_as_str(label)
+        }
+    }
+
+    pub fn set_label(&self, label: &str) {
+        unsafe {
+            let nslabel = crate::nsstring_from_str(label);
+            let () = msg_send![self, setLabel: nslabel];
+        }
+    }
+
+    pub fn new_command_buffer(&self) -> &CommandBufferRef {
+        unsafe { msg_send![self, commandBuffer] }
+    }
+
+    pub fn new_command_buffer_with_unretained_references(&self) -> &CommandBufferRef {
+        unsafe { msg_send![self, commandBufferWithUnretainedReferences] }
+    }
+
+    pub fn device(&self) -> &DeviceRef {
+        unsafe { msg_send![self, device] }
+    }
+}

package/native/tvos/metal-patched/src/computepass.rs

@@ -0,0 +1,107 @@
+use super::*;
+
+/// See <https://developer.apple.com/documentation/metal/mtlcomputepassdescriptor>
+pub enum MTLComputePassDescriptor {}
+
+foreign_obj_type! {
+    type CType = MTLComputePassDescriptor;
+    pub struct ComputePassDescriptor;
+}
+
+impl ComputePassDescriptor {
+    /// Creates a default compute pass descriptor with no attachments.
+    pub fn new<'a>() -> &'a ComputePassDescriptorRef {
+        unsafe { msg_send![class!(MTLComputePassDescriptor), computePassDescriptor] }
+    }
+}
+
+impl ComputePassDescriptorRef {
+    pub fn sample_buffer_attachments(
+        &self,
+    ) -> &ComputePassSampleBufferAttachmentDescriptorArrayRef {
+        unsafe { msg_send![self, sampleBufferAttachments] }
+    }
+
+    pub fn set_dispatch_type(&self, ty: MTLDispatchType) {
+        unsafe { msg_send![self, setDispatchType: ty] }
+    }
+}
+
+/// See <https://developer.apple.com/documentation/metal/mtlcomputepasssamplebufferattachmentdescriptorarray>
+pub enum MTLComputePassSampleBufferAttachmentDescriptorArray {}
+
+foreign_obj_type! {
+    type CType = MTLComputePassSampleBufferAttachmentDescriptorArray;
+    pub struct ComputePassSampleBufferAttachmentDescriptorArray;
+}
+
+impl ComputePassSampleBufferAttachmentDescriptorArrayRef {
+    pub fn object_at(
+        &self,
+        index: NSUInteger,
+    ) -> Option<&ComputePassSampleBufferAttachmentDescriptorRef> {
+        unsafe { msg_send![self, objectAtIndexedSubscript: index] }
+    }
+
+    pub fn set_object_at(
+        &self,
+        index: NSUInteger,
+        attachment: Option<&ComputePassSampleBufferAttachmentDescriptorRef>,
+    ) {
+        unsafe {
+            msg_send![self, setObject:attachment
+                     atIndexedSubscript:index]
+        }
+    }
+}
+
+/// See <https://developer.apple.com/documentation/metal/mtlcomputepasssamplebufferattachmentdescriptor>
+pub enum MTLComputePassSampleBufferAttachmentDescriptor {}
+
+foreign_obj_type! {
+    type CType = MTLComputePassSampleBufferAttachmentDescriptor;
+    pub struct ComputePassSampleBufferAttachmentDescriptor;
+}
+
+impl ComputePassSampleBufferAttachmentDescriptor {
+    pub fn new() -> Self {
+        let class = class!(MTLComputePassSampleBufferAttachmentDescriptor);
+        unsafe { msg_send![class, new] }
+    }
+}
+
+impl ComputePassSampleBufferAttachmentDescriptorRef {
+    pub fn sample_buffer(&self) -> Option<&CounterSampleBufferRef> {
+        unsafe { msg_send![self, sampleBuffer] }
+    }
+
+    pub fn set_sample_buffer(&self, sample_buffer: &CounterSampleBufferRef) {
+        unsafe { msg_send![self, setSampleBuffer: sample_buffer] }
+    }
+
+    pub fn start_of_encoder_sample_index(&self) -> NSUInteger {
+        unsafe { msg_send![self, startOfEncoderSampleIndex] }
+    }
+
+    pub fn set_start_of_encoder_sample_index(&self, start_of_encoder_sample_index: NSUInteger) {
+        unsafe {
+            msg_send![
+                self,
+                setStartOfEncoderSampleIndex: start_of_encoder_sample_index
+            ]
+        }
+    }
+
+    pub fn end_of_encoder_sample_index(&self) -> NSUInteger {
+        unsafe { msg_send![self, endOfEncoderSampleIndex] }
+    }
+
+    pub fn set_end_of_encoder_sample_index(&self, end_of_encoder_sample_index: NSUInteger) {
+        unsafe {
+            msg_send![
+                self,
+                setEndOfEncoderSampleIndex: end_of_encoder_sample_index
+            ]
+        }
+    }
+}

package/native/tvos/metal-patched/src/constants.rs

@@ -0,0 +1,152 @@
+// Copyright 2016 GFX developers
+//
+// Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
+// http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
+// http://opensource.org/licenses/MIT>, at your option. This file may not be
+// copied, modified, or distributed except according to those terms.
+
+/// See <https://developer.apple.com/documentation/metal/mtlpixelformat>
+#[repr(u64)]
+#[allow(non_camel_case_types)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum MTLPixelFormat {
+    Invalid = 0,
+    A8Unorm = 1,
+    R8Unorm = 10,
+    R8Unorm_sRGB = 11,
+    R8Snorm = 12,
+    R8Uint = 13,
+    R8Sint = 14,
+    R16Unorm = 20,
+    R16Snorm = 22,
+    R16Uint = 23,
+    R16Sint = 24,
+    R16Float = 25,
+    RG8Unorm = 30,
+    RG8Unorm_sRGB = 31,
+    RG8Snorm = 32,
+    RG8Uint = 33,
+    RG8Sint = 34,
+    B5G6R5Unorm = 40,
+    A1BGR5Unorm = 41,
+    ABGR4Unorm = 42,
+    BGR5A1Unorm = 43,
+    R32Uint = 53,
+    R32Sint = 54,
+    R32Float = 55,
+    RG16Unorm = 60,
+    RG16Snorm = 62,
+    RG16Uint = 63,
+    RG16Sint = 64,
+    RG16Float = 65,
+    RGBA8Unorm = 70,
+    RGBA8Unorm_sRGB = 71,
+    RGBA8Snorm = 72,
+    RGBA8Uint = 73,
+    RGBA8Sint = 74,
+    BGRA8Unorm = 80,
+    BGRA8Unorm_sRGB = 81,
+    RGB10A2Unorm = 90,
+    RGB10A2Uint = 91,
+    RG11B10Float = 92,
+    RGB9E5Float = 93,
+    BGR10A2Unorm = 94,
+    RG32Uint = 103,
+    RG32Sint = 104,
+    RG32Float = 105,
+    RGBA16Unorm = 110,
+    RGBA16Snorm = 112,
+    RGBA16Uint = 113,
+    RGBA16Sint = 114,
+    RGBA16Float = 115,
+    RGBA32Uint = 123,
+    RGBA32Sint = 124,
+    RGBA32Float = 125,
+    BC1_RGBA = 130,
+    BC1_RGBA_sRGB = 131,
+    BC2_RGBA = 132,
+    BC2_RGBA_sRGB = 133,
+    BC3_RGBA = 134,
+    BC3_RGBA_sRGB = 135,
+    BC4_RUnorm = 140,
+    BC4_RSnorm = 141,
+    BC5_RGUnorm = 142,
+    BC5_RGSnorm = 143,
+    BC6H_RGBFloat = 150,
+    BC6H_RGBUfloat = 151,
+    BC7_RGBAUnorm = 152,
+    BC7_RGBAUnorm_sRGB = 153,
+    PVRTC_RGB_2BPP = 160,
+    PVRTC_RGB_2BPP_sRGB = 161,
+    PVRTC_RGB_4BPP = 162,
+    PVRTC_RGB_4BPP_sRGB = 163,
+    PVRTC_RGBA_2BPP = 164,
+    PVRTC_RGBA_2BPP_sRGB = 165,
+    PVRTC_RGBA_4BPP = 166,
+    PVRTC_RGBA_4BPP_sRGB = 167,
+    EAC_R11Unorm = 170,
+    EAC_R11Snorm = 172,
+    EAC_RG11Unorm = 174,
+    EAC_RG11Snorm = 176,
+    EAC_RGBA8 = 178,
+    EAC_RGBA8_sRGB = 179,
+    ETC2_RGB8 = 180,
+    ETC2_RGB8_sRGB = 181,
+    ETC2_RGB8A1 = 182,
+    ETC2_RGB8A1_sRGB = 183,
+    ASTC_4x4_sRGB = 186,
+    ASTC_5x4_sRGB = 187,
+    ASTC_5x5_sRGB = 188,
+    ASTC_6x5_sRGB = 189,
+    ASTC_6x6_sRGB = 190,
+    ASTC_8x5_sRGB = 192,
+    ASTC_8x6_sRGB = 193,
+    ASTC_8x8_sRGB = 194,
+    ASTC_10x5_sRGB = 195,
+    ASTC_10x6_sRGB = 196,
+    ASTC_10x8_sRGB = 197,
+    ASTC_10x10_sRGB = 198,
+    ASTC_12x10_sRGB = 199,
+    ASTC_12x12_sRGB = 200,
+    ASTC_4x4_LDR = 204,
+    ASTC_5x4_LDR = 205,
+    ASTC_5x5_LDR = 206,
+    ASTC_6x5_LDR = 207,
+    ASTC_6x6_LDR = 208,
+    ASTC_8x5_LDR = 210,
+    ASTC_8x6_LDR = 211,
+    ASTC_8x8_LDR = 212,
+    ASTC_10x5_LDR = 213,
+    ASTC_10x6_LDR = 214,
+    ASTC_10x8_LDR = 215,
+    ASTC_10x10_LDR = 216,
+    ASTC_12x10_LDR = 217,
+    ASTC_12x12_LDR = 218,
+    ASTC_4x4_HDR = 222,
+    ASTC_5x4_HDR = 223,
+    ASTC_5x5_HDR = 224,
+    ASTC_6x5_HDR = 225,
+    ASTC_6x6_HDR = 226,
+    ASTC_8x5_HDR = 228,
+    ASTC_8x6_HDR = 229,
+    ASTC_8x8_HDR = 230,
+    ASTC_10x5_HDR = 231,
+    ASTC_10x6_HDR = 232,
+    ASTC_10x8_HDR = 233,
+    ASTC_10x10_HDR = 234,
+    ASTC_12x10_HDR = 235,
+    ASTC_12x12_HDR = 236,
+    GBGR422 = 240,
+    BGRG422 = 241,
+    Depth16Unorm = 250,
+    Depth32Float = 252,
+    Stencil8 = 253,
+    Depth24Unorm_Stencil8 = 255,
+    Depth32Float_Stencil8 = 260,
+    X32_Stencil8 = 261,
+    X24_Stencil8 = 262,
+    BGRA10_XR = 552,
+    BGRA10_XR_SRGB = 553,
+    BGR10_XR = 554,
+    BGR10_XR_SRGB = 555,
+}