### Shader Pack Installation

Source: https://context7.com/irisshaders/iris/llms.txt

Instructions on how to install shader packs for Iris.

```APIDOC
## Shader Pack Installation

Shader packs are installed by placing them in the shader packs folder. The path varies by operating system.

### Shader Pack Folder Locations

- **Windows**: `%APPDATA%\.minecraft\shaderpacks`
- **Linux**: `~/.minecraft/shaderpacks`
- **macOS**: `~/Library/Application Support/minecraft/shaderpacks`

### Supported Formats

- `.zip` files (recommended)
- Extracted folders containing a `shaders/` directory

### Installation Steps

1. Download the shader pack (`.zip` file).
2. Place the downloaded file or folder into the `shaderpacks` folder.
3. In-game: Navigate to `Options > Video Settings > Shader Packs`.
4. Select the desired shader pack and click `Apply`.
```

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

### Shader Pack Installation Locations and Steps

Source: https://context7.com/irisshaders/iris/llms.txt

Provides the default folder locations for shader packs across different operating systems and outlines the steps for installing a shader pack. Supported formats include .zip files and extracted folders.

```text
# Shader Pack Folder Locations

Windows:  %APPDATA%\.minecraft\shaderpacks
Linux:    ~/.minecraft/shaderpacks
macOS:    ~/Library/Application Support/minecraft/shaderpacks

# Supported formats:
- .zip files (recommended)
- Extracted folders containing shaders/ directory

# To install:
1. Download shader pack (.zip file)
2. Place in shaderpacks folder
3. In-game: Options > Video Settings > Shader Packs
4. Select shader pack and click Apply
```

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

### Developer Integration Guide

Source: https://context7.com/irisshaders/iris/llms.txt

Guidance for mod developers integrating with Iris Shaders.

```APIDOC
## Developer Integration Guide

Iris Shaders is designed for seamless integration with other Minecraft mods. Developers can leverage Iris's API to ensure shader compatibility and enhance rendering.

### Recommended Integration Patterns

- **Check Shader Presence**: Use `IrisApi.getInstance().isShaderPackInUse()` to conditionally apply shader-specific rendering logic.
- **Shadow Pass Detection**: Utilize `isRenderingShadowPass()` for mods that implement custom culling or rendering logic during shadow passes.
- **Custom Render Pipelines**: The `assignPipeline()` method allows for deep integration, enabling mods to register their own custom render pipelines with Iris.

### Dependencies

- **Sodium**: Iris requires Sodium for full functionality.
- **Indium**: Mods using the Fabric Rendering API should include Indium for compatibility with Iris.

### Mod Loaders

Iris supports both **Fabric** and **NeoForge** mod loaders on modern Minecraft versions.
```

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

### IrisApi.getInstance() - Get API Instance

Source: https://context7.com/irisshaders/iris/llms.txt

Retrieves the singleton instance of the Iris API, providing access to all shader-related functionalities.

```APIDOC
## IrisApi.getInstance()

### Description
The main entry point to the Iris API. Returns the singleton IrisApi instance that provides access to all shader-related functionality including shader pack status, configuration, and rendering utilities.

### Method
`IrisApi.getInstance()`

### Endpoint
N/A (Java method call)

### Parameters
None

### Request Example
```java
import net.irisshaders.iris.api.v0.IrisApi;

// Get the Iris API instance
IrisApi api = IrisApi.getInstance();

// Check API revision for feature compatibility
int revision = api.getMinorApiRevision(); // Returns 3 for current version
```

### Response
#### Success Response
- **api** (IrisApi) - The singleton IrisApi instance.

### Response Example
```java
// IrisApi instance is returned directly
```
```

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

### Get Iris API Instance

Source: https://context7.com/irisshaders/iris/llms.txt

Retrieve the singleton IrisApi instance to access all shader-related functionalities. Check the API revision for feature compatibility.

```java
import net.irisshaders.iris.api.v0.IrisApi;

// Get the Iris API instance
IrisApi api = IrisApi.getInstance();

// Check API revision for feature compatibility
int revision = api.getMinorApiRevision(); // Returns 3 for current version
```

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

### Build Iris Shaders from Source

Source: https://github.com/irisshaders/iris/blob/26.1/docs/usage/development-builds.md

Execute this command in your terminal to build the Iris shaders project. This will generate a JAR file in the build/libs directory.

```bash
gradlew build
```

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

### Create and Render Text Quads with IrisTextVertexSink

Source: https://context7.com/irisshaders/iris/llms.txt

Demonstrates how to create a vertex sink for custom text rendering and then render a text quad using the Iris API. Ensure IrisApi is initialized and a vertex sink is created with a specified capacity and buffer allocator.

```java
import net.irisshaders.iris.api.v0.IrisApi;
import net.irisshaders.iris.api.v0.IrisTextVertexSink;
import com.mojang.blaze3d.vertex.VertexFormat;
import java.nio.ByteBuffer;

public class CustomTextRenderer {
    public void renderText() {
        IrisApi api = IrisApi.getInstance();

        // Create a vertex sink for 100 quads max
        IrisTextVertexSink sink = api.createTextVertexSink(100, size -> {
            return ByteBuffer.allocateDirect(size);
        });

        // Get vertex format for compatibility
        VertexFormat format = sink.getUnderlyingVertexFormat();
        ByteBuffer buffer = sink.getUnderlyingByteBuffer();

        // Render a text quad
        // Parameters: x1, y1, x2, y2, z, color (ABGR), u1, v1, u2, v2, light
        int colorABGR = 0xFF_FF_FF_FF; // White, full alpha
        sink.quad(
            0.0f, 0.0f,     // top-left position
            16.0f, 16.0f,   // bottom-right position
            0.0f,           // z depth
            colorABGR,      // packed ABGR color
            0.0f, 0.0f,     // UV top-left
            1.0f, 1.0f,     // UV bottom-right
            0xF000F0        // packed light coordinate
        );
    }
}
```

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

### Open Iris Shader Menu

Source: https://context7.com/irisshaders/iris/llms.txt

Opens the main Iris GUI shader selection screen. Requires a valid Screen instance or null as the parent. The returned Object must be cast to Screen.

```java
import net.irisshaders.iris.api.v0.IrisApi;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.screens.Screen;

public class ShaderScreenOpener {
    public void openShaderMenu() {
        IrisApi api = IrisApi.getInstance();
        Screen currentScreen = Minecraft.getInstance().screen;

        // Open shader pack selection screen
        Object shaderScreen = api.openMainIrisScreenObj(currentScreen);
        Minecraft.getInstance().setScreen((Screen) shaderScreen);
    }

    public String getButtonTranslationKey() {
        // Returns "options.iris.shaderPackSelection"
        return IrisApi.getInstance().getMainScreenLanguageKey();
    }
}
```

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

### Get Sun Path Rotation

Source: https://context7.com/irisshaders/iris/llms.txt

Retrieves the sun path rotation angle used by the active shader pack. Returns 0 if no shader pack is loaded. Useful for synchronizing mod lighting with shader effects.

```java
import net.irisshaders.iris.api.v0.IrisApi;

public class SunPositionCalculator {
    public float calculateSunAngle(float worldTime) {
        IrisApi api = IrisApi.getInstance();

        float sunPathRotation = api.getSunPathRotation();

        // Apply shader pack's sun path rotation to calculations
        float adjustedAngle = worldTime * 360.0f + sunPathRotation;
        return adjustedAngle;
    }
}
```

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

### Implement Custom Item Light Emission with IrisItemLightProvider

Source: https://context7.com/irisshaders/iris/llms.txt

Shows how to implement the IrisItemLightProvider interface to provide custom lighting information for items. Override getLightEmission for light level and getLightColor for RGB glow color.

```java
import net.irisshaders.iris.api.v0.item.IrisItemLightProvider;
import net.minecraft.world.entity.player.Player;
import net.minecraft.world.item.ItemStack;
import org.joml.Vector3f;

public class GlowingItem implements IrisItemLightProvider {

    @Override
    public int getLightEmission(Player player, ItemStack stack) {
        // Return light level (0-15)
        // Default implementation checks if item is a light-emitting block
        return 15; // Maximum brightness
    }

    @Override
    public Vector3f getLightColor(Player player, ItemStack stack) {
        // Return RGB color for the light (values 0.0-1.0)
        // Default is white (1, 1, 1)
        return new Vector3f(1.0f, 0.8f, 0.2f); // Warm orange glow
    }
}
```

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

### Build Specific Iris Loader

Source: https://github.com/irisshaders/iris/blob/26.1/docs/usage/development-builds.md

Use these commands to build only the Fabric or NeoForge loader for Iris shaders. This is useful if you only need one specific loader.

```bash
gradlew :fabric:build
```

```bash
gradlew :neoforge:build
```

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

### IrisApi.openMainIrisScreenObj()

Source: https://context7.com/irisshaders/iris/llms.txt

Opens the main Iris GUI screen, which is the shader selection screen. This method is designed to avoid direct Minecraft class dependencies by using Objects, but the parent must be a valid Screen instance or null.

```APIDOC
## IrisApi.openMainIrisScreenObj()

### Description
Opens the main Iris GUI screen (shader selection screen). The method takes and returns Objects to avoid direct Minecraft class dependencies, but the parent must be a valid Screen instance or null.

### Method
`openMainIrisScreenObj(Object parent)`

### Endpoint
N/A (Java method call)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```java
IrisApi api = IrisApi.getInstance();
Screen currentScreen = Minecraft.getInstance().screen;
Object shaderScreen = api.openMainIrisScreenObj(currentScreen);
Minecraft.getInstance().setScreen((Screen) shaderScreen);
```

### Response
#### Success Response (200)
- **shaderScreen** (Object) - An object representing the shader selection screen, which can be cast to a `Screen`.

#### Response Example
```json
// No direct JSON response, returns an Object that can be cast to Screen
```
```

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

### Configure Custom Images in shaders.properties

Source: https://github.com/irisshaders/iris/blob/26.1/docs/changelogs/1.6.0/full.md

Configure custom images for passing arbitrary image data between programs. Specify sampler name, format, internal format, pixel type, and clearing/sizing behavior.

```properties
image.imageName = samplerName format internalFormat pixelType <shouldClearOnNewFrame> <isRelative> <relativeX/absoluteX> <relativeY/absoluteY> <absoluteZ>
```

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

### Iris Keyboard Shortcuts

Source: https://context7.com/irisshaders/iris/llms.txt

Default in-game keyboard shortcuts for quick shader management.

```APIDOC
## Keyboard Shortcuts

Iris provides in-game keyboard shortcuts for quick shader management without using the GUI.

### Default Shortcuts
- **K**: Toggle shaders on/off instantly
- **O**: Open shader pack menu with transparent background (see changes in real-time)
- **R**: Reload the currently active shader pack

*Note: These can be rebound in the Controls menu.*
```

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

### Initialize Unassigned Output Variables

Source: https://github.com/irisshaders/iris/blob/26.1/docs/usage/debugging.md

Creates an initialization for an output variable if it exists but is never assigned to. Compatibility patching is skipped for array types, and a warning is produced.

```glsl
out vec4 fragColor;
void main() {
  // fragColor is never assigned
}
```

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

### Enable/Disable Shaders and Apply

Source: https://context7.com/irisshaders/iris/llms.txt

Immediately enable or disable shaders and apply the change. This action triggers a shader reload and saves the setting to the configuration file. Useful for dynamic shader toggling.

```java
import net.irisshaders.iris.api.v0.IrisApi;
import net.irisshaders.iris.api.v0.IrisApiConfig;

public class ShaderToggle {
    public void toggleShaders() {
        IrisApiConfig config = IrisApi.getInstance().getConfig();

        // Disable shaders
        config.setShadersEnabledAndApply(false);

        // Enable shaders
        config.setShadersEnabledAndApply(true);
    }

    public void disableOnPerformanceIssue() {
        if (detectLowFPS()) {
            IrisApi.getInstance().getConfig().setShadersEnabledAndApply(false);
            notifyUser("Shaders disabled due to performance");
        }
    }
}
```

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

### Iris Default Keyboard Shortcuts

Source: https://context7.com/irisshaders/iris/llms.txt

Lists the default keyboard shortcuts provided by Iris for quick shader management. These shortcuts can be rebound in the game's Controls menu.

```text
# Default Iris Keyboard Shortcuts

K - Toggle shaders on/off instantly
O - Open shader pack menu with transparent background (see changes in real-time)
R - Reload the currently active shader pack

# These can be rebound in Controls menu
```

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

### Insert Missing Input Variable Declarations

Source: https://github.com/irisshaders/iris/blob/26.1/docs/usage/debugging.md

Inserts missing input variable declarations and initializes them with default values in the main function. This mitigates errors on drivers that require corresponding output variables from the previous stage.

```glsl
in vec4 color;
void main() {
  // ...
}
```

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

### IrisItemLightProvider API

Source: https://context7.com/irisshaders/iris/llms.txt

Interface for custom item light emission with shader support. Allows items to provide dynamic lighting information for shader packs that support held item lighting.

```APIDOC
## IrisItemLightProvider

Interface for custom item light emission with shader support. Allows items to provide dynamic lighting information for shader packs that support held item lighting.

### Methods
- `getLightEmission(Player player, ItemStack stack)`: Returns the light level (0-15) emitted by the item.
- `getLightColor(Player player, ItemStack stack)`: Returns the RGB color (0.0-1.0) of the light emitted by the item.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```java
import net.irisshaders.iris.api.v0.item.IrisItemLightProvider;
import net.minecraft.world.entity.player.Player;
import net.minecraft.world.item.ItemStack;
import org.joml.Vector3f;

public class GlowingItem implements IrisItemLightProvider {

    @Override
    public int getLightEmission(Player player, ItemStack stack) {
        // Return light level (0-15)
        // Default implementation checks if item is a light-emitting block
        return 15; // Maximum brightness
    }

    @Override
    public Vector3f getLightColor(Player player, ItemStack stack) {
        // Return RGB color for the light (values 0.0-1.0)
        // Default is white (1, 1, 1)
        return new Vector3f(1.0f, 0.8f, 0.2f); // Warm orange glow
    }
}
```

### Response
#### Success Response (200)
- `getLightEmission`: `int` - Light level (0-15).
- `getLightColor`: `Vector3f` - RGB color (0.0-1.0).

#### Response Example
(See Request Example for usage)
```

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

### IrisApiConfig.areShadersEnabled() - Check if Shaders are Loaded

Source: https://context7.com/irisshaders/iris/llms.txt

Checks if a shader pack is loaded from disk, regardless of whether it's currently in use.

```APIDOC
## IrisApiConfig.areShadersEnabled()

### Description
Checks whether a shader pack is loaded from disk. Note that a shader pack can be loaded but not in use if compilation failed. For most use cases, prefer `IrisApi.isShaderPackInUse()` instead.

### Method
`IrisApiConfig.areShadersEnabled()`

### Endpoint
N/A (Java method call)

### Parameters
None

### Request Example
```java
import net.irisshaders.iris.api.v0.IrisApi;
import net.irisshaders.iris.api.v0.IrisApiConfig;

public class ShaderStatusChecker {
    public void checkStatus() {
        IrisApiConfig config = IrisApi.getInstance().getConfig();

        boolean loadedFromDisk = config.areShadersEnabled();
        boolean actuallyRendering = IrisApi.getInstance().isShaderPackInUse();

        if (loadedFromDisk && !actuallyRendering) {
            System.out.println("Shader pack loaded but failed to compile");
        }
    }
}
```

### Response
#### Success Response
- **shadersEnabled** (boolean) - True if a shader pack is loaded from disk, false otherwise.

#### Response Example
```
// Returns true or false
```
```

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

### Activate Higher Shadowcolor Buffers

Source: https://github.com/irisshaders/iris/blob/26.1/docs/changelogs/1.6.0/full.md

Enable the use of extra shadowcolor buffers by activating the `HIGHER_SHADOWCOLOR` feature flag. This allows for more shadow detail or complexity.

```properties
HIGHER_SHADOWCOLOR
```

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

### Configure Shader Storage Buffer Objects (SSBOs)

Source: https://github.com/irisshaders/iris/blob/26.1/docs/changelogs/1.6.0/full.md

Define SSBOs in shaders.properties by specifying the buffer object index and its byte size. This allows for passing arbitrary data between programs or frames.

```properties
bufferObject.index = byteSize
```

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

### IrisApi.assignPipeline()

Source: https://context7.com/irisshaders/iris/llms.txt

Assigns a custom render pipeline to a specific Iris shader program. This enables mods to register their own rendering logic for categories like entities, terrain, or particles.

```APIDOC
## IrisApi.assignPipeline()

### Description
Assigns a render pipeline to an Iris shader program. This allows mods to register custom render pipelines for specific shader categories like entities, terrain, or particles.

### Method
`assignPipeline(RenderPipeline pipeline, IrisProgram program)`
`assignPipeline(RenderPipeline pipeline, IrisShadowProgram shadowProgram)`

### Endpoint
N/A (Java method call)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```java
IrisApi api = IrisApi.getInstance();

// Register custom entity pipeline
api.assignPipeline(myEntityPipeline, IrisProgram.ENTITIES);

// Register translucent entity pipeline
api.assignPipeline(myTranslucentPipeline, IrisProgram.ENTITIES_TRANSLUCENT);

// Register terrain pipeline
api.assignPipeline(myTerrainPipeline, IrisProgram.TERRAIN);

// Register shadow pipeline
api.assignPipeline(myShadowPipeline, IrisShadowProgram.SHADOW);
```

### Response
#### Success Response (200)
This method does not return a value upon success.

#### Response Example
```json
// No direct JSON response
```
```

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

### Fix Uninitialized Waving Parameters in Chocapic v4

Source: https://github.com/irisshaders/iris/blob/26.1/docs/ShaderpackBugs.md

Apply this diff to initialize waving parameters to zero in Chocapic v4 shaders to prevent random flashing holes in the terrain. This corrects issues caused by uninitialized variables leading to undefined vertex positions.

```diff
-	float parm0,parm1,parm2,parm3,parm4,parm5 = 0.0;
+	float parm0 = 0.0,parm1 = 0.0,parm2 = 0.0,parm3 = 0.0,parm4 = 0.0,parm5 = 0.0;
```

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

### Read from Custom Image (Sampler) in GLSL

Source: https://github.com/irisshaders/iris/blob/26.1/docs/changelogs/1.6.0/full.md

Use `uniform sampler2D` to declare a readable image (sampler) in GLSL. The `texture2D` function is used to sample color data from the texture.

```glsl
uniform sampler2D samplerName;

// The difference between a sampler and an image is that you cannot write to a sampler, but it will be filtered linearly.
// Choose what you need depending on the case at hand.

void main() {
    gl_FragData[0] = texture2D(samplerName, gl_FragCoord.xy);
}
```

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

### IrisTextVertexSink API

Source: https://context7.com/irisshaders/iris/llms.txt

Interface for custom text rendering with shader support. Provides methods to create and write text quads with proper vertex formats.

```APIDOC
## IrisTextVertexSink

Interface for custom text rendering with shader support. Provides methods to create and write text quads with proper vertex formats.

### Method
`api.createTextVertexSink(int maxQuads, IntFunction<ByteBuffer> bufferProvider)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```java
import net.irisshaders.iris.api.v0.IrisApi;
import net.irisshaders.iris.api.v0.IrisTextVertexSink;
import com.mojang.blaze3d.vertex.VertexFormat;
import java.nio.ByteBuffer;
import java.util.function.IntFunction;

public class CustomTextRenderer {
    public void renderText() {
        IrisApi api = IrisApi.getInstance();

        // Create a vertex sink for 100 quads max
        IrisTextVertexSink sink = api.createTextVertexSink(100, size -> {
            return ByteBuffer.allocateDirect(size);
        });

        // Get vertex format for compatibility
        VertexFormat format = sink.getUnderlyingVertexFormat();
        ByteBuffer buffer = sink.getUnderlyingByteBuffer();

        // Render a text quad
        // Parameters: x1, y1, x2, y2, z, color (ABGR), u1, v1, u2, v2, light
        int colorABGR = 0xFF_FF_FF_FF; // White, full alpha
        sink.quad(
            0.0f, 0.0f,     // top-left position
            16.0f, 16.0f,   // bottom-right position
            0.0f,           // z depth
            colorABGR,      // packed ABGR color
            0.0f, 0.0f,     // UV top-left
            1.0f, 1.0f,     // UV bottom-right
            0xF000F0        // packed light coordinate
        );
    }
}
```

### Response
#### Success Response (200)
`IrisTextVertexSink` object for rendering text quads.

#### Response Example
(See Request Example for usage)
```

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

### Configure Indirect Compute Shaders

Source: https://github.com/irisshaders/iris/blob/26.1/docs/changelogs/1.7.0/full.md

To use Indirect Compute shaders, specify the buffer object number and offset in shaders.properties. The object at the specified offset in the SSBO must be of type uvec3. Failure to do so can lead to system instability.

```properties
indirect.pass = bufferObjectNumber offsetInBuffer
```

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

### Write to Custom Image in GLSL

Source: https://github.com/irisshaders/iris/blob/26.1/docs/changelogs/1.6.0/full.md

Use `uniform image2D` to declare a writable image in GLSL. The `imageStore` function can be used to write pixel data to the image at specified coordinates.

```glsl
uniform image2D imageName;
void main() {
    imageStore(imageName, ivec2(gl_FragCoord.xy), vec4(gl_FragCoord.xy, 0, 1));
}
```

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

### IrisApi.isRenderingShadowPass() - Check Shadow Pass Rendering

Source: https://context7.com/irisshaders/iris/llms.txt

Verifies if Iris is currently rendering the shadow pass, useful for custom culling logic.

```APIDOC
## IrisApi.isRenderingShadowPass()

### Description
Checks whether Iris is currently rendering the shadow pass. Useful for mods with custom culling that may not work correctly during shadow rendering. This method can only return true if `isShaderPackInUse()` also returns true.

### Method
`IrisApi.isRenderingShadowPass()`

### Endpoint
N/A (Java method call)

### Parameters
None

### Request Example
```java
import net.irisshaders.iris.api.v0.IrisApi;

public class CustomCullingMod {
    public void performCulling() {
        IrisApi api = IrisApi.getInstance();

        if (api.isRenderingShadowPass()) {
            // Disable custom culling during shadow pass
            // (e.g., for Immersive Portals compatibility)
            return;
        }

        // Apply custom culling logic
        applyCulling();
    }
}
```

### Response
#### Success Response
- **renderingShadowPass** (boolean) - True if the shadow pass is being rendered, false otherwise.

#### Response Example
```
// Returns true or false
```
```

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

### IrisApi.isShaderPackInUse() - Check Shader Pack Status

Source: https://context7.com/irisshaders/iris/llms.txt

Determines if a shader pack is currently active and rendering. Returns false if no shader pack is enabled or if compilation failed.

```APIDOC
## IrisApi.isShaderPackInUse()

### Description
Checks whether a shader pack is currently active and being used for rendering. Returns false if no shader pack is enabled or if compilation failed. This is the primary method for mods that need to enable custom workarounds when shaders are active.

### Method
`IrisApi.isShaderPackInUse()`

### Endpoint
N/A (Java method call)

### Parameters
None

### Request Example
```java
import net.irisshaders.iris.api.v0.IrisApi;

public class MyModRenderer {
    public void render() {
        IrisApi api = IrisApi.getInstance();

        if (api.isShaderPackInUse()) {
            // Apply shader-compatible rendering path
            renderWithShaderSupport();
        } else {
            // Use standard vanilla rendering
            renderVanilla();
        }
    }
}
```

### Response
#### Success Response
- **shaderPackInUse** (boolean) - True if a shader pack is active, false otherwise.

#### Response Example
```
// Returns true or false
```
```

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

### IrisApiConfig.setShadersEnabledAndApply() - Enable/Disable Shaders

Source: https://context7.com/irisshaders/iris/llms.txt

Enables or disables shaders and applies the change immediately, triggering a shader reload and persisting the setting.

```APIDOC
## IrisApiConfig.setShadersEnabledAndApply()

### Description
Enables or disables shaders and applies the change immediately. This triggers a shader reload and persists the setting to the configuration file.

### Method
`IrisApiConfig.setShadersEnabledAndApply(boolean enabled)`

### Endpoint
N/A (Java method call)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **enabled** (boolean) - Required - True to enable shaders, false to disable.

### Request Example
```java
import net.irisshaders.iris.api.v0.IrisApi;
import net.irisshaders.iris.api.v0.IrisApiConfig;

public class ShaderToggle {
    public void toggleShaders() {
        IrisApiConfig config = IrisApi.getInstance().getConfig();

        // Disable shaders
        config.setShadersEnabledAndApply(false);

        // Enable shaders
        config.setShadersEnabledAndApply(true);
    }

    public void disableOnPerformanceIssue() {
        if (detectLowFPS()) {
            IrisApi.getInstance().getConfig().setShadersEnabledAndApply(false);
            notifyUser("Shaders disabled due to performance");
        }
    }
}
```

### Response
#### Success Response (200)
No specific response body, operation is performed.

#### Response Example
```
// No response body
```
```

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

### Fix Enchantment Glint Z-fighting in Sildur's Vibrant

Source: https://github.com/irisshaders/iris/blob/26.1/docs/ShaderpackBugs.md

Replace the matrix multiplication logic in gbuffers_armor_glint.vsh with ftransform() to resolve z-fighting issues with enchantment glints in the nether and end dimensions. This addresses precision errors introduced by matrix multiplications.

```glsl
gl_Position = ftransform();
```