KTX for Unity

https://docs.unity3d.com/Packages/com.unity.cloud.ktx@3.6/
Admin
KTX for Unity is a Unity package that enables users to load KTX 2.0 or Basis Universal texture...
Tokens:23,355
Snippets:269
Trust Score:10
Update:4 months ago
Show doc for...
Tokens:
Raw
### Create Regular Basis File

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/manual/creating-textures.html

Use `basisu` to create a standard .basis file from an input image. Basis Universal must be installed.

```bash
# For Basis files:
# Create regular basis file from an input image
basisu -output_file regular.basis input.png
```

--------------------------------

### Create Regular KTX File

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/manual/creating-textures.html

Use `toktx` to create a standard KTX file from an input image. Ensure KTX-Software is installed.

```bash
# For KTX files:
# Create regular KTX file from an input image
toktx --bcmp regular.ktx2 input.png
```

--------------------------------

### Get StreamingAssets URL

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/api/KtxUnity.TextureBase.html

Converts a relative sub-path within StreamingAssets to an absolute URI, suitable for use with UnityWebRequest.

```csharp
string url = TextureBase.GetStreamingAssetsUrl("path/to/file.ktx");
```

--------------------------------

### Create Unity-Compatible Basis File

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/manual/creating-textures.html

Use `basisu` with the `--y_flip` parameter to create a .basis file with vertical flipping, suitable for Unity.

```bash
# Create a y-flipped basis file, fit for Unity out of the box
basisu -y_flip -output_file unity_flipped.basis input.png
```

--------------------------------

### Create Unity-Compatible KTX File

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/manual/creating-textures.html

Use `toktx` with the `--lower_left_maps_to_s0t0` parameter to create a KTX file with vertical flipping, suitable for Unity.

```bash
# Create a y-flipped KTX file, fit for Unity out of the box
toktx --lower_left_maps_to_s0t0 --bcmp unity_flipped.ktx2 input.png
```

--------------------------------

### LoadFromStreamingAssets (string, bool, uint, uint, uint, bool)

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/api/KtxUnity.TextureBase.html

Loads a KTX or Basis Universal texture from the StreamingAssets folder.

```APIDOC
## LoadFromStreamingAssets (string, bool, uint, uint, uint, bool)

### Description
Loads a KTX or Basis Universal texture from the StreamingAssets folder. See https://docs.unity3d.com/Manual/StreamingAssets.html for more information.

### Method
public Task<TextureResult> LoadFromStreamingAssets(string filePath, bool linear = false, uint layer = 0, uint faceSlice = 0, uint mipLevel = 0, bool mipChain = true)

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- **filePath** (string) - Required - Path to the file, relative to StreamingAssets
- **linear** (bool) - Optional - Depicts if texture is sampled in linear or sRGB gamma color space.
- **layer** (uint) - Optional - Texture array layer to import
- **faceSlice** (uint) - Optional - Cubemap face or 3D/volume texture slice to import.
- **mipLevel** (uint) - Optional - Lowest mipmap level to import (where 0 is the highest resolution). Lower mipmap levels (of higher resolution) are being discarded. Useful to limit texture resolution.
- **mipChain** (bool) - Optional - If true, a mipmap chain (if present) is imported.

### Request Example
- Not provided in source.

### Response
#### Success Response (200)
- **ErrorCode** (ErrorCode) - The result code of the operation.
- **texture** (Texture2D) - The resulting texture.
- **orientation** (TextureOrientation) - The orientation of the texture.

#### Response Example
- Not provided in source.
```

--------------------------------

### LoadFromUrl (string, bool, uint, uint, uint, bool)

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/api/KtxUnity.TextureBase.html

Loads a KTX or Basis Universal texture from a URL.

```APIDOC
## LoadFromUrl (string, bool, uint, uint, uint, bool)

### Description
Loads a KTX or Basis Universal texture from a URL.

### Method
public Task<TextureResult> LoadFromUrl(string url, bool linear = false, uint layer = 0, uint faceSlice = 0, uint mipLevel = 0, bool mipChain = true)

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- **url** (string) - Required - URL to the ktx/basis file to load
- **linear** (bool) - Optional - Depicts if texture is sampled in linear or sRGB gamma color space.
- **layer** (uint) - Optional - Texture array layer to import
- **faceSlice** (uint) - Optional - Cubemap face or 3D/volume texture slice to import.
- **mipLevel** (uint) - Optional - Lowest mipmap level to import (where 0 is the highest resolution). Lower mipmap levels (of higher resolution) are being discarded. Useful to limit texture resolution.
- **mipChain** (bool) - Optional - If true, a mipmap chain (if present) is imported.

### Request Example
- Not provided in source.

### Response
#### Success Response (200)
- **ErrorCode** (ErrorCode) - The result code of the operation.
- **texture** (Texture2D) - The resulting texture.
- **orientation** (TextureOrientation) - The orientation of the texture.

#### Response Example
- Not provided in source.
```

--------------------------------

### LoadFromUrl (string, GraphicsFormat, uint, uint, uint, bool)

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/api/KtxUnity.TextureBase.html

Loads a KTX or Basis Universal texture from a URL with a specified target format.

```APIDOC
## LoadFromUrl (string, GraphicsFormat, uint, uint, uint, bool)

### Description
Loads a KTX or Basis Universal texture from a URL with a specified target format.

### Method
public Task<TextureResult> LoadFromUrl(string url, GraphicsFormat targetFormat, uint layer = 0, uint faceSlice = 0, uint mipLevel = 0, bool mipChain = true)

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- **url** (string) - Required - URL to the ktx/basis file to load
- **targetFormat** (GraphicsFormat) - Required - Desired texture format
- **layer** (uint) - Optional - Texture array layer to import
- **faceSlice** (uint) - Optional - Cubemap face or 3D/volume texture slice to import.
- **mipLevel** (uint) - Optional - Lowest mipmap level to import (where 0 is the highest resolution). Lower mipmap levels (of higher resolution) are being discarded. Useful to limit texture resolution.
- **mipChain** (bool) - Optional - If true, a mipmap chain (if present) is imported.

### Request Example
- Not provided in source.

### Response
#### Success Response (200)
- **ErrorCode** (ErrorCode) - The result code of the operation.
- **texture** (Texture2D) - The resulting texture.
- **orientation** (TextureOrientation) - The orientation of the texture.

#### Response Example
- Not provided in source.
```

--------------------------------

### LoadFromStreamingAssets (string, GraphicsFormat, uint, uint, uint, bool)

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/api/KtxUnity.TextureBase.html

Loads a KTX or Basis Universal texture from the StreamingAssets folder with a specified target format.

```APIDOC
## LoadFromStreamingAssets (string, GraphicsFormat, uint, uint, uint, bool)

### Description
Loads a KTX or Basis Universal texture from the StreamingAssets folder with a specified target format. See https://docs.unity3d.com/Manual/StreamingAssets.html for more information.

### Method
public Task<TextureResult> LoadFromStreamingAssets(string filePath, GraphicsFormat targetFormat, uint layer = 0, uint faceSlice = 0, uint mipLevel = 0, bool mipChain = true)

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- **filePath** (string) - Required - Path to the file, relative to StreamingAssets
- **targetFormat** (GraphicsFormat) - Required - Desired texture format
- **layer** (uint) - Optional - Texture array layer to import
- **faceSlice** (uint) - Optional - Cubemap face or 3D/volume texture slice to import.
- **mipLevel** (uint) - Optional - Lowest mipmap level to import (where 0 is the highest resolution). Lower mipmap levels (of higher resolution) are being discarded. Useful to limit texture resolution.
- **mipChain** (bool) - Optional - If true, a mipmap chain (if present) is imported.

### Request Example
- Not provided in source.

### Response
#### Success Response (200)
- **ErrorCode** (ErrorCode) - The result code of the operation.
- **texture** (Texture2D) - The resulting texture.
- **orientation** (TextureOrientation) - The orientation of the texture.

#### Response Example
- Not provided in source.
```

--------------------------------

### LoadTexture2D with Layer, FaceSlice, MipLevel, and MipChain options

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/api/KtxUnity.TextureBase.html

Loads a Texture2D with options to specify texture array layer, cubemap face, mip level, and whether to import the mip chain. Defaults are provided for convenience.

```csharp
public abstract Task<TextureResult> LoadTexture2D(bool linear = false, uint layer = 0, uint faceSlice = 0, uint mipLevel = 0, bool mipChain = true)
```

--------------------------------

### Load KTX/Basis Texture from URL (Target Format)

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/api/KtxUnity.TextureBase.html

Loads a KTX or Basis Universal texture from a specified URL, allowing specification of the target graphics format.

```csharp
public Task<TextureResult> LoadFromUrl(string url, GraphicsFormat targetFormat, uint layer = 0, uint faceSlice = 0, uint mipLevel = 0, bool mipChain = true)
```

--------------------------------

### LoadTexture2D(GraphicsFormat, uint, uint, uint, bool)

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/api/KtxUnity.KtxTexture.html

Creates a Texture2D from the previously opened texture, allowing control over the target GPU format, layer, slice, mip level, and mip chain import. This is part of the low-level API for finer control.

```APIDOC
## LoadTexture2D(GraphicsFormat, uint, uint, uint, bool)

### Description
Creates a Texture2D from the previously opened texture. Transcodes or decodes the texture into a desired GPU compatible format (if required) and uploads it to GPU memory. Part of the low-level API that provides finer control over the loading process.

### Method
`public override Task<TextureResult> LoadTexture2D(GraphicsFormat targetFormat, uint layer = 0, uint faceSlice = 0, uint mipLevel = 0, bool mipChain = true)`

### Parameters
#### Path Parameters
- **targetFormat** (GraphicsFormat) - Desired texture format.
- **layer** (uint) - Texture array layer to import.
- **faceSlice** (uint) - Cubemap face or 3D/volume texture slice to import.
- **mipLevel** (uint) - Lowest mipmap level to import (where 0 is the highest resolution). Lower mipmap levels (of higher resolution) are being discarded. Useful to limit texture resolution.
- **mipChain** (bool) - If true, a mipmap chain (if present) is imported.

### Returns
#### Success Response
- **Task<TextureResult>** - A TextureResult that contains an ErrorCode, the resulting texture and its orientation.

### See Also
- Open(ReadOnly)
- Dispose()
```

--------------------------------

### LoadTexture2D(bool, uint, uint, uint, bool)

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/api/KtxUnity.KtxTexture.html

Creates a Texture2D from the previously opened texture, allowing control over color space, layer, slice, mip level, and mip chain import. This is part of the low-level API for finer control.

```APIDOC
## LoadTexture2D(bool, uint, uint, uint, bool)

### Description
Creates a Texture2D from the previously opened texture. Allows control over color space, layer, slice, mip level, and mip chain import. This is part of the low-level API that provides finer control over the loading process.

### Method
`public override Task<TextureResult> LoadTexture2D(bool linear, uint layer = 0, uint faceSlice = 0, uint mipLevel = 0, bool mipChain = true)`

### Parameters
#### Path Parameters
- **linear** (bool) - Depicts if texture is sampled in linear or sRGB gamma color space.
- **layer** (uint) - Texture array layer to import.
- **faceSlice** (uint) - Cubemap face or 3D/volume texture slice to import.
- **mipLevel** (uint) - Lowest mipmap level to import (where 0 is the highest resolution). Lower mipmap levels (of higher resolution) are being discarded. Useful to limit texture resolution.
- **mipChain** (bool) - If true, a mipmap chain (if present) is imported.

### Returns
#### Success Response
- **Task<TextureResult>** - A TextureResult that contains an ErrorCode, the resulting texture and its orientation.

### See Also
- Open(ReadOnly)
- Dispose()
```

--------------------------------

### Load Texture from Bytes (Default Format)

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/api/KtxUnity.TextureBase.html

Loads a KTX or Basis Universal texture from a native byte buffer. Allows specifying color space, layer, face/slice, and mip level.

```csharp
Task<TextureResult> result = textureBase.LoadFromBytes(data, linear: true, layer: 0, faceSlice: 0, mipLevel: 0, mipChain: true);
```

--------------------------------

### LoadTexture2D(bool, uint, uint, uint, bool)

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/api/KtxUnity.TextureBase.html

Creates a Texture2D from the previously opened texture. Transcodes or decodes the texture into a GPU compatible format (if required) and uploads it to GPU memory. This overload allows specifying layer, faceSlice, mipLevel, and mipChain options.

```APIDOC
## LoadTexture2D(bool, uint, uint, uint, bool)

### Description
Creates a Texture2D from the previously opened texture. Transcodes or decodes the texture into a GPU compatible format (if required) and uploads it to GPU memory. Part of the low-level API that provides finer control over the loading process.

### Declaration
```csharp
public abstract Task<TextureResult> LoadTexture2D(bool linear = false, uint layer = 0, uint faceSlice = 0, uint mipLevel = 0, bool mipChain = true)
```

### Parameters
#### Parameters
- **linear** (bool) - Depicts if texture is sampled in linear or sRGB gamma color space.
- **layer** (uint) - Texture array layer to import.
- **faceSlice** (uint) - Cubemap face or 3D/volume texture slice to import.
- **mipLevel** (uint) - Lowest mipmap level to import (where 0 is the highest resolution). Lower mipmap levels (of higher resolution) are being discarded. Useful to limit texture resolution.
- **mipChain** (bool) - If true, a mipmap chain (if present) is imported.

### Returns
#### Returns
- **Task<TextureResult>** - A TextureResult that contains an ErrorCode, the resulting texture and its orientation.

### See Also
- Open(ReadOnly)
- Dispose()
```

--------------------------------

### LoadFromBytes(NativeSlice<byte>, GraphicsFormat, uint, uint, uint, bool)

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/api/KtxUnity.TextureBase.html

Loads a KTX or Basis Universal texture from a native byte slice, specifying the target graphics format. Note: This overload is marked as obsolete.

```APIDOC
## LoadFromBytes(NativeSlice<byte>, GraphicsFormat, uint, uint, uint, bool)

### Description
Loads a KTX or Basis Universal texture from a buffer.

### Declaration
```csharp
public Task<TextureResult> LoadFromBytes(NativeSlice<byte> data, GraphicsFormat targetFormat, uint layer = 0, uint faceSlice = 0, uint mipLevel = 0, bool mipChain = true)
```

### Parameters
#### Path Parameters
- **data** (NativeSlice<byte>) - Required - Native buffer that holds the ktx/basis file
- **targetFormat** (GraphicsFormat) - Required - Desired texture format
- **layer** (uint) - Optional - Texture array layer to import. Defaults to 0.
- **faceSlice** (uint) - Optional - Cubemap face or 3D/volume texture slice to import. Defaults to 0.
- **mipLevel** (uint) - Optional - Lowest mipmap level to import (where 0 is the highest resolution). Lower mipmap levels (of higher resolution) are being discarded. Useful to limit texture resolution. Defaults to 0.
- **mipChain** (bool) - Optional - If true, a mipmap chain (if present) is imported. Defaults to true.

### Returns
- **Task<TextureResult>** - A TextureResult that contains an ErrorCode, the resulting texture and its orientation.
```

--------------------------------

### LoadTexture2D with GraphicsFormat Parameter

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/api/KtxUnity.BasisUniversalTexture.html

Creates a Texture2D from the opened texture, trans-coding or decoding it to a specified GPU-compatible format and uploading it to GPU memory. Allows specifying target format, layer, face/slice, mip level, and mip chain import.

```csharp
public override Task<TextureResult> LoadTexture2D(GraphicsFormat targetFormat, uint layer = 0, uint faceSlice = 0, uint mipLevel = 0, bool mipChain = true)
```

--------------------------------

### TextureBase

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/api/KtxUnity.html

Loads a KTX or Basis Universal texture from the StreamingAssets folder, a URL, or a buffer.

```APIDOC
## Class TextureBase

### Description
Loads a KTX or Basis Universal texture from the StreamingAssets folder, a URL, or a buffer.

### Methods
(No methods explicitly documented in the source)
```

--------------------------------

### LoadFromBytes(NativeArray<byte>.ReadOnly, bool, uint, uint, uint, bool)

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/api/KtxUnity.TextureBase.html

Loads a KTX or Basis Universal texture from a native byte buffer with options for color space, layer, face/slice, and mipmap level.

```APIDOC
## LoadFromBytes(NativeArray<byte>.ReadOnly, bool, uint, uint, uint, bool)

### Description
Loads a KTX or Basis Universal texture from a buffer.

### Declaration
```csharp
public Task<TextureResult> LoadFromBytes(NativeArray<byte>.ReadOnly data, bool linear = false, uint layer = 0, uint faceSlice = 0, uint mipLevel = 0, bool mipChain = true)
```

### Parameters
#### Path Parameters
- **data** (NativeArray<byte>.ReadOnly) - Required - Native buffer that holds the ktx/basis file
- **linear** (bool) - Optional - Depicts if texture is sampled in linear or sRGB gamma color space. Defaults to false.
- **layer** (uint) - Optional - Texture array layer to import. Defaults to 0.
- **faceSlice** (uint) - Optional - Cubemap face or 3D/volume texture slice to import. Defaults to 0.
- **mipLevel** (uint) - Optional - Lowest mipmap level to import (where 0 is the highest resolution). Lower mipmap levels (of higher resolution) are being discarded. Useful to limit texture resolution. Defaults to 0.
- **mipChain** (bool) - Optional - If true, a mipmap chain (if present) is imported. Defaults to true.

### Returns
- **Task<TextureResult>** - A TextureResult that contains an ErrorCode, the resulting texture and its orientation.
```

--------------------------------

### Load KTX/Basis Texture from URL (Linear)

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/api/KtxUnity.TextureBase.html

Loads a KTX or Basis Universal texture from a specified URL. This overload assumes the texture is sampled in a linear color space.

```csharp
public Task<TextureResult> LoadFromUrl(string url, bool linear = false, uint layer = 0, uint faceSlice = 0, uint mipLevel = 0, bool mipChain = true)
```

--------------------------------

### LoadFromBytes(NativeSlice<byte>, bool, uint, uint, uint, bool)

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/api/KtxUnity.TextureBase.html

Loads a KTX or Basis Universal texture from a native byte slice. This overload is obsolete and users should prefer the NativeArray<byte>.ReadOnly version.

```APIDOC
## LoadFromBytes(NativeSlice<byte>, bool, uint, uint, uint, bool)

### Description
Loads a KTX or Basis Universal texture from a buffer.

### Declaration
```csharp
[Obsolete("Use the overload that accepts a NativeArray<byte>.ReadOnly data")]
public Task<TextureResult> LoadFromBytes(NativeSlice<byte> data, bool linear = false, uint layer = 0, uint faceSlice = 0, uint mipLevel = 0, bool mipChain = true)
```

### Parameters
#### Path Parameters
- **data** (NativeSlice<byte>) - Required - Native buffer that holds the ktx/basis file
- **linear** (bool) - Optional - Depicts if texture is sampled in linear or sRGB gamma color space. Defaults to false.
- **layer** (uint) - Optional - Texture array layer to import. Defaults to 0.
- **faceSlice** (uint) - Optional - Cubemap face or 3D/volume texture slice to import. Defaults to 0.
- **mipLevel** (uint) - Optional - Lowest mipmap level to import (where 0 is the highest resolution). Lower mipmap levels (of higher resolution) are being discarded. Useful to limit texture resolution. Defaults to 0.
- **mipChain** (bool) - Optional - If true, a mipmap chain (if present) is imported. Defaults to true.

### Returns
- **Task<TextureResult>** - A TextureResult that contains an ErrorCode, the resulting texture and its orientation.
```

--------------------------------

### LoadFromBytes(NativeArray<byte>.ReadOnly, GraphicsFormat, uint, uint, uint, bool)

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/api/KtxUnity.TextureBase.html

Loads a KTX or Basis Universal texture from a native byte buffer, specifying the target graphics format and other loading options.

```APIDOC
## LoadFromBytes(NativeArray<byte>.ReadOnly, GraphicsFormat, uint, uint, uint, bool)

### Description
Loads a KTX or Basis Universal texture from a buffer.

### Declaration
```csharp
public Task<TextureResult> LoadFromBytes(NativeArray<byte>.ReadOnly data, GraphicsFormat targetFormat, uint layer = 0, uint faceSlice = 0, uint mipLevel = 0, bool mipChain = true)
```

### Parameters
#### Path Parameters
- **data** (NativeArray<byte>.ReadOnly) - Required - Native buffer that holds the ktx/basis file
- **targetFormat** (GraphicsFormat) - Required - Desired texture format
- **layer** (uint) - Optional - Texture array layer to import. Defaults to 0.
- **faceSlice** (uint) - Optional - Cubemap face or 3D/volume texture slice to import. Defaults to 0.
- **mipLevel** (uint) - Optional - Lowest mipmap level to import (where 0 is the highest resolution). Lower mipmap levels (of higher resolution) are being discarded. Useful to limit texture resolution. Defaults to 0.
- **mipChain** (bool) - Optional - If true, a mipmap chain (if present) is imported. Defaults to true.

### Returns
- **Task<TextureResult>** - A TextureResult that contains an ErrorCode, the resulting texture and its orientation.
```

--------------------------------

### Load KTX/Basis Texture from StreamingAssets (Target Format)

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/api/KtxUnity.TextureBase.html

Loads a KTX or Basis Universal texture from the Unity StreamingAssets folder, allowing specification of the target graphics format.

```csharp
public Task<TextureResult> LoadFromStreamingAssets(string filePath, GraphicsFormat targetFormat, uint layer = 0, uint faceSlice = 0, uint mipLevel = 0, bool mipChain = true)
```

--------------------------------

### Load Texture from Bytes (Target Format)

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/api/KtxUnity.TextureBase.html

Loads a KTX or Basis Universal texture from a native byte buffer, specifying a target GraphicsFormat. Allows control over layer, face/slice, and mip level.

```csharp
Task<TextureResult> result = textureBase.LoadFromBytes(data, GraphicsFormat.RGBA32_Srgb, layer: 0, faceSlice: 0, mipLevel: 0, mipChain: true);
```

--------------------------------

### LoadTexture2D with Boolean Parameter

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/api/KtxUnity.BasisUniversalTexture.html

Creates a Texture2D from the opened texture, trans-coding or decoding it to a GPU-compatible format and uploading it to GPU memory. Allows specifying color space, layer, face/slice, mip level, and mip chain import.

```csharp
public override Task<TextureResult> LoadTexture2D(bool linear = false, uint layer = 0, uint faceSlice = 0, uint mipLevel = 0, bool mipChain = true)
```

--------------------------------

### BasisUniversalTexture.LoadTexture2D (GraphicsFormat, uint, uint, uint, bool)

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/api/KtxUnity.BasisUniversalTexture.html

Creates a Texture2D from the opened texture, transcoding or decoding it into a specified GPU-compatible format and uploading it to GPU memory. This is part of the low-level API.

```APIDOC
## LoadTexture2D(GraphicsFormat, uint, uint, uint, bool)

### Description
Creates a Texture2D from the previously opened texture. Transcodes or decodes the texture into a desired GPU compatible format (if required) and uploads it to GPU memory. Part of the low-level API that provides finer control over the loading process.

### Method
`public override Task<TextureResult> LoadTexture2D(GraphicsFormat targetFormat, uint layer = 0, uint faceSlice = 0, uint mipLevel = 0, bool mipChain = true)`

### Parameters
#### Path Parameters
- **targetFormat** (GraphicsFormat) - Required - Desired texture format.
- **layer** (uint) - Optional - Texture array layer to import.
- **faceSlice** (uint) - Optional - Cubemap face or 3D/volume texture slice to import.
- **mipLevel** (uint) - Optional - Lowest mipmap level to import (where 0 is the highest resolution). Lower mipmap levels (of higher resolution) are being discarded. Useful to limit texture resolution.
- **mipChain** (bool) - Optional - If true, a mipmap chain (if present) is imported.

### Returns
#### Success Response
- **TextureResult** - A TextureResult that contains an ErrorCode, the resulting texture and its orientation.

### Overrides
TextureBase.LoadTexture2D(GraphicsFormat, uint, uint, uint, bool)

### See Also
- Open(ReadOnly)
- Dispose()
```

--------------------------------

### LoadTexture2D(bool, bool)

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/api/KtxUnity.TextureBase.html

Creates a Texture2D from the previously opened texture. Transcodes or decodes the texture into a GPU compatible format (if required) and uploads it to GPU memory. This is part of the low-level API that provides finer control over the loading process.

```APIDOC
## LoadTexture2D(bool, bool)

### Description
Creates a Texture2D from the previously opened texture. Transcodes or decodes the texture into a GPU compatible format (if required) and uploads it to GPU memory. Part of the low-level API that provides finer control over the loading process.

### Declaration
```csharp
public Task<TextureResult> LoadTexture2D(bool linear, bool readable)
```

### Parameters
#### Parameters
- **linear** (bool) - Depicts if texture is sampled in linear or sRGB gamma color space.
- **readable** (bool) - When the value is true, a copy of the texture is kept in CPU memory and Texture.isReadable|isReadable is true. The default value is false.

### Returns
#### Returns
- **Task<TextureResult>** - A TextureResult that contains an ErrorCode, the resulting texture and its orientation.

### See Also
- Open(ReadOnly)
- Dispose()
```

--------------------------------

### LoadTexture2D with TargetFormat and MipChain options

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/api/KtxUnity.TextureBase.html

Loads a Texture2D into a specified GPU compatible format, with options for layer, face slice, mip level, and mip chain. Useful when a specific output format is required.

```csharp
public abstract Task<TextureResult> LoadTexture2D(GraphicsFormat targetFormat, uint layer = 0, uint faceSlice = 0, uint mipLevel = 0, bool mipChain = true)
```

--------------------------------

### LoadTexture2D with Linear and Readable options

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/api/KtxUnity.TextureBase.html

Creates a Texture2D from an opened texture, allowing control over color space and CPU memory readability. Use this for fine-grained control over texture loading.

```csharp
public Task<TextureResult> LoadTexture2D(bool linear, bool readable)
```

--------------------------------

### Load KTX/Basis Texture from Bytes

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/api/KtxUnity.TextureBase.html

Loads a KTX or Basis Universal texture from a native byte slice. Use this overload when you have the texture data in a NativeArray<byte>.ReadOnly.

```csharp
[Obsolete("Use the overload that accepts a NativeArray<byte>.ReadOnly data")]
public Task<TextureResult> LoadFromBytes(NativeSlice<byte> data, GraphicsFormat targetFormat, uint layer = 0, uint faceSlice = 0, uint mipLevel = 0, bool mipChain = true)
```

--------------------------------

### KtxTexture Methods

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/api/KtxUnity.KtxTexture.html

Provides methods for managing KTX texture resources and loading them into Texture2D objects.

```APIDOC
## Class KtxTexture

### Methods
#### Dispose()
Releases all resources. Part of the low-level API that provides finer control over the loading process.
##### Declaration
```
public override void Dispose()
```

#### LoadTexture2D(bool, uint, uint, uint, bool)
Creates a Texture2D from the previously opened texture. Transcodes or decodes the texture into a GPU compatible format (if required) and uploads it to GPU memory. Part of the low-level API that provides finer control over the loading process.
##### Declaration
```
public override Task<TextureResult> LoadTexture2D(bool linear = false, uint layer = 0, uint faceSlice = 0, uint mipLevel = 0, bool mipChain = true)
```
```

--------------------------------

### BasisUniversalTexture.LoadTexture2D (bool, uint, uint, uint, bool)

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/api/KtxUnity.BasisUniversalTexture.html

Creates a Texture2D from the opened texture, transcoding or decoding it to a GPU-compatible format and uploading it to GPU memory. This method is part of the low-level API.

```APIDOC
## LoadTexture2D(bool, uint, uint, uint, bool)

### Description
Creates a Texture2D from the previously opened texture. Transcodes or decodes the texture into a GPU compatible format (if required) and uploads it to GPU memory. Part of the low-level API that provides finer control over the loading process.

### Method
`public override Task<TextureResult> LoadTexture2D(bool linear = false, uint layer = 0, uint faceSlice = 0, uint mipLevel = 0, bool mipChain = true)`

### Parameters
#### Path Parameters
- **linear** (bool) - Optional - Depicts if texture is sampled in linear or sRGB gamma color space.
- **layer** (uint) - Optional - Texture array layer to import.
- **faceSlice** (uint) - Optional - Cubemap face or 3D/volume texture slice to import.
- **mipLevel** (uint) - Optional - Lowest mipmap level to import (where 0 is the highest resolution). Lower mipmap levels (of higher resolution) are being discarded. Useful to limit texture resolution.
- **mipChain** (bool) - Optional - If true, a mipmap chain (if present) is imported.

### Returns
#### Success Response
- **TextureResult** - A TextureResult that contains an ErrorCode, the resulting texture and its orientation.

### Overrides
TextureBase.LoadTexture2D(bool, uint, uint, uint, bool)

### See Also
- Open(ReadOnly)
- Dispose()
```

--------------------------------

### Open Texture from NativeSlice (Obsolete)

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/api/KtxUnity.KtxTexture.html

Loads a KTX texture from raw byte data provided as a NativeSlice. This overload is obsolete and users should prefer the NativeArray<byte>.ReadOnly version.

```csharp
[Obsolete("Use the overload that accepts a NativeArray<byte>.ReadOnly data")]
public override ErrorCode Open(NativeSlice<byte> data)
```

--------------------------------

### Load KTX/Basis Texture from StreamingAssets (Linear)

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/api/KtxUnity.TextureBase.html

Loads a KTX or Basis Universal texture from the Unity StreamingAssets folder. This overload assumes the texture is sampled in a linear color space.

```csharp
public Task<TextureResult> LoadFromStreamingAssets(string filePath, bool linear = false, uint layer = 0, uint faceSlice = 0, uint mipLevel = 0, bool mipChain = true)
```

--------------------------------

### Open Texture with NativeSlice (Obsolete)

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/api/KtxUnity.BasisUniversalTexture.html

Loads a texture from memory using a NativeSlice. This overload is obsolete and users should prefer the NativeArray.ReadOnly overload.

```csharp
[Obsolete("Use the overload that accepts a NativeArray<byte>.ReadOnly data")]
public override ErrorCode Open(NativeSlice<byte> data)
{
    // Implementation details
}
```

--------------------------------

### LoadFromBytes

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/api/KtxUnity.TextureBase.html

Loads a KTX or Basis Universal texture from a native byte slice. This method is obsolete and a new overload accepting NativeArray<byte>.ReadOnly is recommended.

```APIDOC
## LoadFromBytes

### Description
Loads a KTX or Basis Universal texture from a native byte slice. This method is obsolete and a new overload accepting NativeArray<byte>.ReadOnly is recommended.

### Method
public Task<TextureResult> LoadFromBytes(NativeSlice<byte> data, GraphicsFormat targetFormat, uint layer = 0, uint faceSlice = 0, uint mipLevel = 0, bool mipChain = true)

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- **data** (NativeSlice<byte>) - Required - Native buffer that holds the ktx/basis file
- **targetFormat** (GraphicsFormat) - Required - Desired texture format
- **layer** (uint) - Optional - Texture array layer to import
- **faceSlice** (uint) - Optional - Cubemap face or 3D/volume texture slice to import.
- **mipLevel** (uint) - Optional - Lowest mipmap level to import (where 0 is the highest resolution). Lower mipmap levels (of higher resolution) are being discarded. Useful to limit texture resolution.
- **mipChain** (bool) - Optional - If true, a mipmap chain (if present) is imported.

### Request Example
- Not provided in source.

### Response
#### Success Response (200)
- **ErrorCode** (ErrorCode) - The result code of the operation.
- **texture** (Texture2D) - The resulting texture.
- **orientation** (TextureOrientation) - The orientation of the texture.

#### Response Example
- Not provided in source.
```

--------------------------------

### KtxTexture

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/api/KtxUnity.html

Loads a KTX texture from the StreamingAssets folder, a URL, or a buffer.

```APIDOC
## Class KtxTexture

### Description
Loads a KTX texture from the StreamingAssets folder, a URL, or a buffer.

### Methods
(No methods explicitly documented in the source)
```

--------------------------------

### Load KTX Texture from Streaming Assets

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/manual/how-to.html

Loads a KTX texture from the StreamingAssets folder. Use this for non-color value textures like normal maps. Supports loading from URLs or memory as alternatives.

```csharp
using KtxUnity;
…
async void Start() {

    // Create KTX texture instance
    var texture = new KtxTexture();

    // Linear color sampling. Needed for non-color value textures (e.g. normal maps)
    bool linearColor = true;

    // Load file from Streaming Assets folder (relative path)
    var result = await texture.LoadFromStreamingAssets("trout.ktx", linearColor);

    // Alternative: Load from URL
    // var result = await texture.LoadFromUrl("https://myserver.com/trout.ktx", linearColor);

    // Alternative: Load from memory
    // var result = await texture.LoadFromBytes(nativeArray, linearColor);

    if (result != null) {
        // Use texture. For example, apply texture to a material
        targetMaterial.mainTexture = result.texture;

        // Optional: Support arbitrary texture orientation by flipping the texture if necessary
        var scale = targetMaterial.mainTextureScale;
        scale.x = result.orientation.IsXFlipped() ? -1 : 1;
        scale.y = result.orientation.IsYFlipped() ? -1 : 1;
        targetMaterial.mainTextureScale = scale;
    }
}
…
```

--------------------------------

### Open(NativeSlice<byte>)

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/api/KtxUnity.BasisUniversalTexture.html

Loads a texture from memory using a native slice. This method is obsolete and users should prefer the overload that accepts a NativeArray<byte>.ReadOnly.

```APIDOC
## Open(NativeSlice<byte>)

### Description
Loads a texture from memory using a native slice. This method is obsolete and users should prefer the overload that accepts a NativeArray<byte>.ReadOnly.

### Method
```csharp
[Obsolete("Use the overload that accepts a NativeArray<byte>.ReadOnly data")]
public override ErrorCode Open(NativeSlice<byte> data)
```

### Parameters
#### Path Parameters
- **data** (NativeSlice<byte>) - Input texture data

### Returns
#### Success Response
- **ErrorCode** - Success if loading was successful or an error-specific code otherwise.

### See Also
- LoadTexture2D(bool, uint, uint, uint, bool)
- LoadTexture2D(GraphicsFormat, uint, uint, uint, bool)
- Dispose()
```

--------------------------------

### Open(NativeArray<byte>.ReadOnly)

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/api/KtxUnity.BasisUniversalTexture.html

Loads a texture from memory using a read-only native array. This is part of the low-level API for finer control over the loading process.

```APIDOC
## Open(NativeArray<byte>.ReadOnly)

### Description
Loads a texture from memory using a read-only native array. This is part of the low-level API for finer control over the loading process.

### Method
```csharp
public override ErrorCode Open(NativeArray<byte>.ReadOnly data)
```

### Parameters
#### Path Parameters
- **data** (NativeArray<byte>.ReadOnly) - Input texture data

### Returns
#### Success Response
- **ErrorCode** - Success if loading was successful or an error-specific code otherwise.

### See Also
- LoadTexture2D(bool, uint, uint, uint, bool)
- LoadTexture2D(GraphicsFormat, uint, uint, uint, bool)
- Dispose()
```

--------------------------------

### TextureResult Constructors

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/api/KtxUnity.TextureResult.html

Provides documentation for the different constructors of the TextureResult class, used for creating empty, invalid, or successful texture loading results.

```APIDOC
## TextureResult()

### Description
Creates an empty TextureResult.

### Declaration
```csharp
public TextureResult()
```
```

```APIDOC
## TextureResult(ErrorCode)

### Description
Creates an invalid TextureResult with an ErrorCode.

### Declaration
```csharp
public TextureResult(ErrorCode errorCode)
```

### Parameters
- **errorCode** (ErrorCode) - Required - The ErrorCode from the failed texture import.
```

```APIDOC
## TextureResult(Texture2D, TextureOrientation)

### Description
Creates a successful TextureResult with a Texture2D and a TextureOrientation.

### Declaration
```csharp
public TextureResult(Texture2D texture, TextureOrientation orientation)
```

### Parameters
- **texture** (Texture2D) - Required - The successfully imported Texture2D.
- **orientation** (TextureOrientation) - Required - The TextureOrientation of the imported texture.
```

--------------------------------

### TextureOrientation

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/api/KtxUnity.html

See Section 5.2 in https://registry.khronos.org/KTX/specs/2.0/ktxspec.v2.html#_ktxorientation

```APIDOC
## Enum TextureOrientation

### Description
See Section 5.2 in https://registry.khronos.org/KTX/specs/2.0/ktxspec.v2.html#_ktxorientation

### Members
(No members explicitly documented in the source)
```

--------------------------------

### Create Sprite from Basis Universal Texture

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/manual/how-to.html

Loads a Basis Universal texture and creates a Sprite for UI elements. Handles texture orientation and calculates RectTransform size for preserving aspect ratio.

```csharp
using KtxUnity;
…
async void Start() {

    // Create a basis universal texture instance
    var texture = new BasisUniversalTexture();

    // Load file from Streaming Assets folder
    var result = await texture.LoadFromStreamingAssets("dachstein.basis");

    if (result != null) {
        // Calculate correct size
        var pos = new Vector2(0,0);
        var size = new Vector2(result.texture.width, result.texture.height);

        // Flip Sprite, if required
        if(result.orientation.IsXFlipped()) {
            pos.x = size.x;
            size.x *= -1;
        }

        if(result.orientation.IsYFlipped()) {
            pos.y = size.y;
            size.y *= -1;
        }

        // Create a Sprite and assign it to the Image
        GetComponent<Image>().sprite = Sprite.Create(result.texture, new Rect(pos, size), Vector2.zero);

        // Preserve aspect ratio:
        // Flipping the sprite by making the size x or y negative (above) breaks Image's `Preserve Aspect` feature
        // You can/have to calculate the RectTransform size yourself. Example:

        // Calculate correct size and assign it to the RectTransform
        const float scale = 0.5f; // Set this to whatever size you need it - best make it a serialized class field
        var rt = GetComponent<RectTransform>();
        rt.sizeDelta = new Vector2(result.texture.width*scale, result.texture.height*scale);
    }
}
…
```

--------------------------------

### TextureResult Constructor with Texture and Orientation

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/api/KtxUnity.TextureResult.html

Creates a successful TextureResult, providing the loaded Texture2D and its TextureOrientation.

```csharp
public TextureResult(Texture2D texture, TextureOrientation orientation)

```

--------------------------------

### LoadTexture2D

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/api/KtxUnity.KtxTexture.html

Loads a KTX texture into a Texture2D object with specified parameters.

```APIDOC
## LoadTexture2D(bool, uint, uint, uint, bool)

### Description
Loads a KTX texture with specific format and dimensions.

### Parameters
#### Path Parameters
- **bool** (bool) - Required - Indicates if mipmaps are generated.
- **uint** (uint) - Required - The width of the texture.
- **uint** (uint) - Required - The height of the texture.
- **uint** (uint) - Required - The depth of the texture.
- **bool** (bool) - Required - Indicates if sRGB format is used.

### Response
#### Success Response
- **Texture2D** - The loaded texture.

## LoadTexture2D(GraphicsFormat, uint, uint, uint, bool)

### Description
Loads a KTX texture with a specified GraphicsFormat and dimensions.

### Parameters
#### Path Parameters
- **GraphicsFormat** (GraphicsFormat) - Required - The graphics format of the texture.
- **uint** (uint) - Required - The width of the texture.
- **uint** (uint) - Required - The height of the texture.
- **uint** (uint) - Required - The depth of the texture.
- **bool** (bool) - Required - Indicates if sRGB format is used.

### Response
#### Success Response
- **Texture2D** - The loaded texture.
```

--------------------------------

### Open(ReadOnly)

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/api/KtxUnity.TextureBase.html

Loads a texture from memory using a read-only NativeArray. This is part of the low-level API for fine-grained control over texture loading.

```APIDOC
## Open(ReadOnly)

### Description
Loads a texture from memory. Part of the low-level API that provides finer control over the loading process.

### Method
`public abstract ErrorCode Open(NativeArray<byte>.ReadOnly data)`

### Parameters
#### Path Parameters
- **data** (NativeArray<byte>.ReadOnly) - Input texture data

### Returns
#### Success Response
- **ErrorCode** - Success if loading was successful or an error-specific code otherwise.

### See Also
- LoadTexture2D(bool, uint, uint, uint, bool)
- LoadTexture2D(GraphicsFormat, uint, uint, uint, bool)
- Dispose()
```

--------------------------------

### ManagedNativeArray Constructor

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/api/KtxUnity.ManagedNativeArray.html

Initializes a new instance of the ManagedNativeArray class by wrapping a managed byte array. This operation does not copy memory.

```csharp
public ManagedNativeArray(byte[] original)
{
}
```

--------------------------------

### Dispose()

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/api/KtxUnity.TextureBase.html

Releases all resources associated with the texture. This is part of the low-level API for fine-grained control over the loading process.

```APIDOC
## Dispose()

### Description
Releases all resources.

### Declaration
```csharp
public abstract void Dispose()
```

### See Also
Open(ReadOnly)
LoadTexture2D(bool, uint, uint, uint, bool)
LoadTexture2D(GraphicsFormat, uint, uint, uint, bool)
Dispose()
```

--------------------------------

### BasisUniversalTexture

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/api/KtxUnity.html

Loads a Basis Universal texture from the StreamingAssets folder, a URL, or a buffer.

```APIDOC
## Class BasisUniversalTexture

### Description
Loads a Basis Universal texture from the StreamingAssets folder, a URL, or a buffer.

### Methods
(No methods explicitly documented in the source)
```

--------------------------------

### KtxTexture Properties

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/api/KtxUnity.KtxTexture.html

Provides access to various properties of the KTX texture, such as its dimensions, alpha channel presence, compression status, and orientation.

```csharp
public uint baseDepth { get; }
```

```csharp
public uint baseHeight { get; }
```

```csharp
public uint baseWidth { get; }
```

```csharp
public bool hasAlpha { get; }
```

```csharp
public bool isArray { get; }
```

```csharp
public bool isCompressed { get; }
```

```csharp
public bool isCubemap { get; }
```

```csharp
public bool isMultipleOfFour { get; }
```

```csharp
public bool isPowerOfTwo { get; }
```

```csharp
public bool isSquare { get; }
```

```csharp
public bool needsTranscoding { get; }
```

```csharp
public uint numDimensions { get; }
```

```csharp
public uint numFaces { get; }
```

```csharp
public uint numLayers { get; }
```

```csharp
public uint numLevels { get; }
```

```csharp
public TextureOrientation orientation { get; }
```

--------------------------------

### ManagedNativeArray Constructor

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/api/KtxUnity.ManagedNativeArray.html

Initializes a new instance of the ManagedNativeArray class, wrapping a managed byte array in a NativeArray<byte> without copying memory.

```APIDOC
## ManagedNativeArray(byte[])

### Description
Wraps a managed byte[] in a NativeArray<byte> without copying memory.

### Parameters
* **original** (byte[]) - Required - The original byte[] to convert into a NativeArray<byte>.
```

--------------------------------

### TextureResult Constructor with ErrorCode

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/api/KtxUnity.TextureResult.html

Creates an invalid TextureResult, indicating a failed texture import by providing an ErrorCode.

```csharp
public TextureResult(ErrorCode errorCode)

```

--------------------------------

### Open Texture from NativeArray

Source: https://docs.unity3d.com/Packages/com.unity.cloud.ktx%403.6/api/KtxUnity.KtxTexture.html

Loads a KTX texture from raw byte data provided as a read-only NativeArray. This is part of the low-level API for direct memory loading.

```csharp
public override ErrorCode Open(NativeArray<byte>.ReadOnly data)
```
Tokens:
Raw