Backdrop

https://kyant.gitbook.io/backdrop
Admin
The Backdrop library allows drawing a copy of the background to a foreground with various effects,...
Tokens:8,303
Snippets:84
Trust Score:10
Update:2 months ago
Show doc for...
Tokens:
Raw
### Initialize MainNavHost

Source: https://kyant.gitbook.io/backdrop/tutorials/glass-bottom-bar.md

Basic setup for the main navigation host within a Box container.

```kotlin
Box(Modifier.fillMaxSize()) {
    MainNavHost()
}
```

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

### GET https://kyant.gitbook.io/backdrop/api/backdrop-effects.md

Source: https://kyant.gitbook.io/backdrop/api/backdrop-effects.md

Query the documentation dynamically by asking a question.

```APIDOC
## GET https://kyant.gitbook.io/backdrop/api/backdrop-effects.md

### Description
Perform an HTTP GET request on the current page URL to query the documentation dynamically.

### Method
GET

### Endpoint
https://kyant.gitbook.io/backdrop/api/backdrop-effects.md

### Parameters
#### Query Parameters
- **ask** (string) - Required - The immediate question to ask.
- **goal** (string) - Optional - The broader end goal to tailor the answer.
```

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

### Install Backdrop via Gradle

Source: https://kyant.gitbook.io/backdrop/get-started.md

Add the dependency to your build.gradle.kts file to include the library in your project.

```kts
dependencies {
    implementation("io.github.kyant0:backdrop:<version>")
}
```

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

### GET /backdrop/get-started.md

Source: https://kyant.gitbook.io/backdrop/llms.txt

Performs a query against the documentation index to retrieve an answer based on a specific question and optional goal.

```APIDOC
## GET /backdrop/get-started.md

### Description
Perform an HTTP GET request on the documentation index to ask a question and receive a direct answer with relevant excerpts.

### Method
GET

### Endpoint
https://kyant.gitbook.io/backdrop/get-started.md

### Parameters
#### Query Parameters
- **ask** (string) - Required - The immediate, specific, and self-contained question.
- **goal** (string) - Optional - Describes the broader end goal to help tailor the answer.
```

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

### GET /backdrop/tutorials.md

Source: https://kyant.gitbook.io/backdrop/tutorials

Performs a dynamic query against the documentation to retrieve answers and relevant excerpts based on a specific question and optional goal.

```APIDOC
## GET /backdrop/tutorials.md

### Description
Performs a dynamic query against the documentation to retrieve answers and relevant excerpts based on a specific question and optional goal.

### Method
GET

### Endpoint
https://kyant.gitbook.io/backdrop/tutorials.md

### Parameters
#### Query Parameters
- **ask** (string) - Required - The immediate question to ask, written in natural language.
- **goal** (string) - Optional - Describes the broader end goal to help tailor the answer.
```

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

### GET /api/backdrops.md

Source: https://kyant.gitbook.io/backdrop/api/backdrops.md

Perform an HTTP GET request on the documentation page URL to query information dynamically.

```APIDOC
## GET /api/backdrops.md

### Description
Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter to retrieve information from the documentation.

### Method
GET

### Endpoint
https://kyant.gitbook.io/backdrop/api/backdrops.md

### Parameters
#### Query Parameters
- **ask** (string) - Required - The immediate question to ask.
- **goal** (string) - Optional - The broader end goal to tailor the answer.
```

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

### Query documentation via HTTP

Source: https://kyant.gitbook.io/backdrop/get-started.md

Perform an HTTP GET request to the documentation URL to ask questions dynamically.

```http
GET https://kyant.gitbook.io/backdrop/get-started.md?ask=<question>&goal=<endgoal>
```

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

### GET /tutorials/interactive-glass-bottom-bar.md

Source: https://kyant.gitbook.io/backdrop/tutorials/interactive-glass-bottom-bar.md

Queries the documentation page dynamically to retrieve answers, excerpts, and sources based on a user question and optional goal.

```APIDOC
## GET /tutorials/interactive-glass-bottom-bar.md

### Description
Performs a dynamic query on the documentation page to retrieve information not explicitly present in the static content.

### Method
GET

### Endpoint
https://kyant.gitbook.io/backdrop/tutorials/interactive-glass-bottom-bar.md

### Parameters
#### Query Parameters
- **ask** (string) - Required - The specific, self-contained question to ask the documentation.
- **goal** (string) - Optional - The broader end goal to help tailor the response context.
```

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

### GET /tutorials/glass-bottom-bar.md

Source: https://kyant.gitbook.io/backdrop/tutorials/glass-bottom-bar.md

Queries the documentation for a specific question, optionally providing a broader goal to refine the context of the response.

```APIDOC
## GET /tutorials/glass-bottom-bar.md

### Description
Perform an HTTP GET request on the current page URL to query the documentation dynamically. This returns a direct answer to the provided question along with relevant excerpts and sources.

### Method
GET

### Endpoint
https://kyant.gitbook.io/backdrop/tutorials/glass-bottom-bar.md

### Parameters
#### Query Parameters
- **ask** (string) - Required - The immediate question to ask, written in natural language.
- **goal** (string) - Optional - Describes the broader end goal to help tailor the answer.
```

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

### GET /backdrop/faq.md

Source: https://kyant.gitbook.io/backdrop/faq.md

Perform a dynamic query against the documentation to retrieve answers, excerpts, and sources based on a specific question and optional goal.

```APIDOC
## GET /backdrop/faq.md

### Description
Perform an HTTP GET request on the documentation page URL to query information dynamically.

### Method
GET

### Endpoint
https://kyant.gitbook.io/backdrop/faq.md

### Parameters
#### Query Parameters
- **ask** (string) - Required - The immediate question to ask, written in natural language.
- **goal** (string) - Optional - The broader end goal to help tailor the answer.
```

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

### GET /tutorials/glass-slider.md

Source: https://kyant.gitbook.io/backdrop/tutorials/glass-slider.md

Queries the documentation page for specific information using a natural language question and an optional goal context.

```APIDOC
## GET /tutorials/glass-slider.md

### Description
Performs a dynamic query against the documentation page to retrieve answers, excerpts, and sources based on a user question.

### Method
GET

### Endpoint
https://kyant.gitbook.io/backdrop/tutorials/glass-slider.md

### Parameters
#### Query Parameters
- **ask** (string) - Required - The specific, self-contained natural language question.
- **goal** (string) - Optional - The broader end goal to help tailor the response context.
```

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

### Query documentation via HTTP

Source: https://kyant.gitbook.io/backdrop/tutorials/progressive-blur.md

Perform an HTTP GET request to query the documentation dynamically with specific questions and goals.

```http
GET https://kyant.gitbook.io/backdrop/tutorials/progressive-blur.md?ask=<question>&goal=<endgoal>
```

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

### GET /tutorials/smoother-rounded-corners.md

Source: https://kyant.gitbook.io/backdrop/tutorials/smoother-rounded-corners.md

Performs a dynamic query against the documentation page to retrieve answers to specific questions.

```APIDOC
## GET /tutorials/smoother-rounded-corners.md

### Description
Queries the documentation dynamically to receive a direct answer and relevant excerpts based on the provided question.

### Method
GET

### Endpoint
https://kyant.gitbook.io/backdrop/tutorials/smoother-rounded-corners.md

### Parameters
#### Query Parameters
- **ask** (string) - Required - The specific, self-contained question to ask.
- **goal** (string) - Optional - The broader end goal to help tailor the response.
```

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

### GET /tutorials/glass-bottom-sheet.md

Source: https://kyant.gitbook.io/backdrop/tutorials/glass-bottom-sheet.md

Performs a dynamic query against the documentation page to retrieve answers and relevant excerpts based on a specific question and optional goal.

```APIDOC
## GET /tutorials/glass-bottom-sheet.md

### Description
Queries the documentation dynamically to retrieve answers and relevant excerpts based on a natural language question.

### Method
GET

### Endpoint
https://kyant.gitbook.io/backdrop/tutorials/glass-bottom-sheet.md

### Parameters
#### Query Parameters
- **ask** (string) - Required - The specific, self-contained question to ask the documentation.
- **goal** (string) - Optional - The broader end goal to help tailor the response context.
```

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

### GET /api.md

Source: https://kyant.gitbook.io/backdrop/api

Performs a dynamic query against the documentation to retrieve answers, excerpts, and sources based on a specific question and optional goal.

```APIDOC
## GET /api.md

### Description
Performs a dynamic query against the documentation to retrieve answers, excerpts, and sources based on a specific question and optional goal.

### Method
GET

### Endpoint
https://kyant.gitbook.io/backdrop/api.md

### Parameters
#### Query Parameters
- **ask** (string) - Required - The immediate question to ask the documentation.
- **goal** (string) - Optional - The broader end goal to help tailor the answer.

### Response
#### Success Response (200)
- **response** (string) - Contains a direct answer to the question and relevant excerpts and sources from the documentation.
```

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

### Initialize GlassSlider in Main Layout

Source: https://kyant.gitbook.io/backdrop/tutorials/glass-slider.md

Integrate the GlassSlider component into the main layout using a layer backdrop.

```kotlin
Box(Modifier.fillMaxSize()) {
    val backgroundColor = Color.White
    val backdrop = rememberLayerBackdrop {
        drawRect(backgroundColor)
        drawContent()
    }

    MainNavHost(
        modifier = Modifier.layerBackdrop(backdrop)
    )

    GlassSlider(backdrop = backdrop)
}
```

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

### Apply Opacity

Source: https://kyant.gitbook.io/backdrop/api/backdrop-effects.md

Sets the alpha transparency for the backdrop.

```kotlin
opacity(alpha: Float)
```

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

### Final Glass Bottom Bar Implementation

Source: https://kyant.gitbook.io/backdrop/tutorials/glass-bottom-bar.md

Complete code integrating background drawing, effects, and surface readability.

```kotlin
Box(Modifier.fillMaxSize()) {
    val backgroundColor = Color.White
    val backdrop = rememberLayerBackdrop {
        drawRect(backgroundColor)
        drawContent()
    }

    MainNavHost(
        modifier = Modifier.layerBackdrop(backdrop)
    )

    Box(
        Modifier
            .safeContentPadding()
            .drawBackdrop(
                backdrop = backdrop,
                shape = { CircleShape },
                effects = {
                    vibrancy()
                    blur(4f.dp.toPx())
                    lens(16f.dp.toPx(), 32f.dp.toPx())
                },
                onDrawSurface = { drawRect(Color.White.copy(alpha = 0.5f)) }
            )
            .height(64f.dp)
            .fillMaxWidth()
            .align(Alignment.BottomCenter)
    )
}
```

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

### Apply Color Controls

Source: https://kyant.gitbook.io/backdrop/api/backdrop-effects.md

Adjusts brightness, contrast, and saturation levels.

```kotlin
colorControls(
    brightness: Float = 0f,
    contrast: Float = 1f,
    saturation: Float = 1f
)
```

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

### Draw Background to Backdrop

Source: https://kyant.gitbook.io/backdrop/tutorials/glass-bottom-bar.md

Configure the backdrop to include a background color and content drawing.

```kotlin
val backgroundColor = Color.White
val backdrop = rememberLayerBackdrop {
    drawRect(backgroundColor)
    drawContent()
}
```

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

### Implement GlassBottomSheet in Kotlin

Source: https://kyant.gitbook.io/backdrop/tutorials/glass-bottom-sheet.md

Defines a composable function that applies backdrop effects to a bottom sheet layout. Requires the Backdrop library and appropriate Compose foundation imports.

```kotlin
// your package

import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.BoxScope
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.safeContentPadding
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.dp
import com.kyant.backdrop.Backdrop
import com.kyant.backdrop.backdrops.rememberLayerBackdrop
import com.kyant.backdrop.drawBackdrop
import com.kyant.backdrop.effects.blur
import com.kyant.backdrop.effects.lens
import com.kyant.backdrop.effects.vibrancy

@Composable
fun BoxScope.GlassBottomSheet(backdrop: Backdrop) {
    val bottomSheetBackdrop = rememberLayerBackdrop()
    Column(
        Modifier
            .safeContentPadding()
            .drawBackdrop(
                backdrop = backdrop,
                shape = { RoundedCornerShape(44f.dp) },
                effects = {
                    vibrancy()
                    blur(4f.dp.toPx())
                    lens(24f.dp.toPx(), 48f.dp.toPx(), true)
                },
                exportedBackdrop = bottomSheetBackdrop,
                onDrawSurface = { drawRect(Color.White.copy(alpha = 0.5f)) }
            )
            .fillMaxWidth()
            .align(Alignment.BottomCenter)
    ) {
        Spacer(Modifier.height(256f.dp))
        Box(
            Modifier
                .padding(16f.dp)
                .drawBackdrop(
                    backdrop = bottomSheetBackdrop,
                    shape = { CircleShape },
                    shadow = null,
                    effects = {
                        vibrancy()
                        blur(4f.dp.toPx())
                        lens(16f.dp.toPx(), 32f.dp.toPx())
                    },
                    onDrawSurface = { drawRect(Color.White.copy(alpha = 0.5f)) }
                )
                .height(56f.dp)
                .fillMaxWidth()
        )
    }
}
```

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

### Implement Press-to-Scale Animation

Source: https://kyant.gitbook.io/backdrop/tutorials/interactive-glass-bottom-bar.md

Initial implementation of a scaling animation using graphicsLayer, which causes the backdrop to scale incorrectly.

```kotlin
val animationScope = rememberCoroutineScope()
val progressAnimation = remember { Animatable(0f) }

Box(
    Modifier
        .graphicsLayer {
            val progress = progressAnimation.value
            val maxScale = (size.width + 16f.dp.toPx()) / size.width
            val scale = lerp(1f, maxScale, progress)
            scaleX = scale
            scaleY = scale
        }
        .drawBackdrop(
            backdrop = backdrop,
            shape = { CircleShape },
            effects = {
                vibrancy()
                blur(4f.dp.toPx())
                lens(16f.dp.toPx(), 32f.dp.toPx())
            },
            onDrawSurface = { drawRect(Color.White.copy(alpha = 0.5f)) }
        )
        .clickable {}
        .pointerInput(animationScope) {
            val animationSpec = spring(0.5f, 300f, 0.001f)
            awaitEachGesture {
                // press
                awaitFirstDown()
                animationScope.launch {
                    progressAnimation.animateTo(1f, animationSpec)
                }

                // release
                waitForUpOrCancellation()
                animationScope.launch {
                    progressAnimation.animateTo(0f, animationSpec)
                }
            }
        }
        .fillMaxHeight()
        .weight(1f)
)
```

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

### Implement Glass Bottom Sheet in Compose

Source: https://kyant.gitbook.io/backdrop/tutorials/glass-bottom-sheet.md

Uses a Box container with a rememberLayerBackdrop to manage the glass effect and content rendering.

```kotlin
Box(Modifier.fillMaxSize()) {
    val backgroundColor = Color.White
    val backdrop = rememberLayerBackdrop {
        drawRect(backgroundColor)
        drawContent()
    }

    MainNavHost(
        modifier = Modifier.layerBackdrop(backdrop)
    )

    GlassBottomSheet(backdrop = backdrop)
}
```

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

### Draw Backdrop and Lens Effect

Source: https://kyant.gitbook.io/backdrop/tutorials/glass-bottom-bar.md

Initial implementation of a layer backdrop with a lens effect applied to a bottom-aligned Box.

```kotlin
Box(Modifier.fillMaxSize()) {
    val backdrop = rememberLayerBackdrop()

    MainNavHost(
        modifier = Modifier.layerBackdrop(backdrop)
    )

    Box(
        Modifier
            .safeContentPadding()
            .drawBackdrop(
                backdrop = backdrop,
                shape = { CircleShape },
                effects = {
                    lens(16f.dp.toPx(), 32f.dp.toPx())
                }
            )
            .height(64f.dp)
            .fillMaxWidth()
            .align(Alignment.BottomCenter)
    )
}
```

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

### Create a GlassBottomSheet component

Source: https://kyant.gitbook.io/backdrop/tutorials/glass-bottom-sheet.md

Defines a composable function that applies vibrancy, blur, and lens effects to a bottom sheet and an internal glass button.

```kotlin
// your package

import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.BoxScope
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.safeContentPadding
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.dp
import com.kyant.backdrop.Backdrop
import com.kyant.backdrop.drawBackdrop
import com.kyant.backdrop.effects.blur
import com.kyant.backdrop.effects.lens
import com.kyant.backdrop.effects.vibrancy

@Composable
fun BoxScope.GlassBottomSheet(backdrop: Backdrop) {
    Column(
        Modifier
            .safeContentPadding()
            .drawBackdrop(
                backdrop = backdrop,
                shape = { RoundedCornerShape(44f.dp) },
                effects = {
                    vibrancy()
                    blur(4f.dp.toPx())
                    lens(24f.dp.toPx(), 48f.dp.toPx(), true)
                },
                onDrawSurface = { drawRect(Color.White.copy(alpha = 0.5f)) }
            )
            .fillMaxWidth()
            .align(Alignment.BottomCenter)
    ) {
        Spacer(Modifier.height(256f.dp))
        // glass button
        Box(
            Modifier
                .padding(16f.dp)
                .drawBackdrop(
                    backdrop = backdrop,
                    shape = { CircleShape },
                    shadow = null,
                    effects = {
                        vibrancy()
                        blur(4f.dp.toPx())
                        lens(16f.dp.toPx(), 32f.dp.toPx())
                    },
                    onDrawSurface = { drawRect(Color.White.copy(alpha = 0.5f)) }
                )
                .height(56f.dp)
                .fillMaxWidth()
        )
    }
}
```

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

### Add Surface for Readability

Source: https://kyant.gitbook.io/backdrop/tutorials/glass-bottom-bar.md

Improve UI readability by drawing a semi-transparent surface over the backdrop.

```kotlin
Modifier.drawBackdrop(
    backdrop = backdrop,
    shape = { CircleShape },
    effects = {
        vibrancy()
        blur(4f.dp.toPx())
        lens(16f.dp.toPx(), 32f.dp.toPx())
    },
    onDrawSurface = { drawRect(Color.White.copy(alpha = 0.5f)) }
)
```

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

### Create a Tinted Glass Bottom Bar

Source: https://kyant.gitbook.io/backdrop/tutorials/glass-bottom-bar.md

Uses rememberLayerBackdrop to capture content and applies drawBackdrop with vibrancy, blur, and lens effects to create a glass-morphism UI component.

```kotlin
Box(Modifier.fillMaxSize()) {
    val backgroundColor = Color.White
    val backdrop = rememberLayerBackdrop {
        drawRect(backgroundColor)
        drawContent()
    }

    MainNavHost(
        modifier = Modifier.layerBackdrop(backdrop)
    )

    Row(
        Modifier
            .safeContentPadding()
            .height(64f.dp)
            .fillMaxWidth()
            .align(Alignment.BottomCenter),
        horizontalArrangement = Arrangement.spacedBy(8f.dp),
        verticalAlignment = Alignment.CenterVertically
    ) {
        Box(
            Modifier
                .drawBackdrop(
                    backdrop = backdrop,
                    shape = { CircleShape },
                    effects = {
                        vibrancy()
                        blur(4f.dp.toPx())
                        lens(16f.dp.toPx(), 32f.dp.toPx())
                    },
                    onDrawSurface = { drawRect(Color.White.copy(alpha = 0.5f)) }
                )
                .fillMaxHeight()
                .weight(1f)
        )
        Box(
            Modifier
                .drawBackdrop(
                    backdrop = backdrop,
                    shape = { CircleShape },
                    effects = {
                        vibrancy()
                        blur(4f.dp.toPx())
                        lens(16f.dp.toPx(), 32f.dp.toPx())
                    },
                    onDrawSurface = {
                        val tint = Color(0xFF0088FF)
                        drawRect(tint, blendMode = BlendMode.Hue)
                        drawRect(tint.copy(alpha = 0.75f))
                    }
                )
                .aspectRatio(1f)
        )
    }
}
```

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

### Apply Vibrancy

Source: https://kyant.gitbook.io/backdrop/api/backdrop-effects.md

Multiplies saturation by 1.5, equivalent to colorControls(saturation = 1.5f).

```kotlin
vibrancy()
```

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

### Implement Interactive Glass Bottom Bar in Kotlin

Source: https://kyant.gitbook.io/backdrop/tutorials/interactive-glass-bottom-bar.md

Uses rememberLayerBackdrop and drawBackdrop to apply visual effects like blur and vibrancy to UI components.

```kotlin
Box(Modifier.fillMaxSize()) {
    val backgroundColor = Color.White
    val backdrop = rememberLayerBackdrop {
        drawRect(backgroundColor)
        drawContent()
    }

    MainNavHost(
        modifier = Modifier.layerBackdrop(backdrop)
    )

    Row(
        Modifier
            .safeContentPadding()
            .height(64f.dp)
            .fillMaxWidth()
            .align(Alignment.BottomCenter),
        horizontalArrangement = Arrangement.spacedBy(8f.dp),
        verticalAlignment = Alignment.CenterVertically
    ) {
        val animationScope = rememberCoroutineScope()
        val progressAnimation = remember { Animatable(0f) }

        Box(
            Modifier
                .drawBackdrop(
                    backdrop = backdrop,
                    shape = { CircleShape },
                    effects = {
                        vibrancy()
                        blur(4f.dp.toPx())
                        lens(16f.dp.toPx(), 32f.dp.toPx())
                    },
                    layerBlock = {
                        val progress = progressAnimation.value
                        val maxScale = (size.width + 16f.dp.toPx()) / size.width
                        val scale = lerp(1f, maxScale, progress)
                        scaleX = scale
                        scaleY = scale
                    },
                    onDrawSurface = { drawRect(Color.White.copy(alpha = 0.5f)) }
                )
                .clickable(interactionSource = null, indication = null) {}
                .pointerInput(animationScope) {
                    val animationSpec = spring(0.5f, 300f, 0.001f)
                    awaitEachGesture {
                        // press
                        awaitFirstDown()
                        animationScope.launch {
                            progressAnimation.animateTo(1f, animationSpec)
                        }

                        // release
                        waitForUpOrCancellation()
                        animationScope.launch {
                            progressAnimation.animateTo(0f, animationSpec)
                        }
                    }
                }
                .fillMaxHeight()
                .weight(1f)
        )
        Box(
            Modifier
                .drawBackdrop(
                    backdrop = backdrop,
                    shape = { ContinuousCapsule },
                    effects = {
                        vibrancy()
                        blur(4f.dp.toPx())
                        lens(16f.dp.toPx(), 32f.dp.toPx())
                    },
                    onDrawSurface = {
                        val tint = Color(0xFF0088FF)
                        drawRect(tint, blendMode = BlendMode.Hue)
                        drawRect(tint.copy(alpha = 0.75f))
                    }
                )
                .aspectRatio(1f)
        )
    }
}
```

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

### Incorrect implementation of nested backdrops

Source: https://kyant.gitbook.io/backdrop/tutorials/glass-bottom-sheet.md

Demonstrates an invalid approach that causes a rendering loop by using layerBackdrop inside a drawBackdrop chain.

```kotlin
val bottomSheetBackdrop = rememberLayerBackdrop()
Column(
    Modifier
        .layerBackdrop(bottomSheetBackdrop)
        .drawBackdrop()
) {
    // glass button
    Box(
        Modifier
            .drawBackdrop(
                backdrop = bottomSheetBackdrop,
            )
    )
}
```

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

### Apply Custom ColorFilter

Source: https://kyant.gitbook.io/backdrop/api/backdrop-effects.md

Applies a custom ColorFilter to the backdrop.

```kotlin
colorFilter(colorFilter: ColorFilter)
```

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

### Correct implementation of nested backdrops

Source: https://kyant.gitbook.io/backdrop/tutorials/glass-bottom-sheet.md

Uses exportedBackdrop to prevent content rendering loops when nesting backdrop layers.

```kotlin
val bottomSheetBackdrop = rememberLayerBackdrop()
Column(
    Modifier
        .drawBackdrop(
            backdrop = backdrop,
            exportedBackdrop = bottomSheetBackdrop,
        )
) {
    // glass button
    Box(
        Modifier
            .drawBackdrop(
                backdrop = bottomSheetBackdrop,
            )
    )
}
```

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

### Apply Gamma Adjustment

Source: https://kyant.gitbook.io/backdrop/api/backdrop-effects.md

Adjusts gamma levels; requires Android 13 or higher.

```kotlin
gammaAdjustment(power: Float)
```

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

### Apply Blur and Vibrancy Effects

Source: https://kyant.gitbook.io/backdrop/tutorials/glass-bottom-bar.md

Enhance the backdrop visual impact by adding vibrancy and blur effects.

```kotlin
Modifier.drawBackdrop(
    backdrop = backdrop,
    shape = { CircleShape },
    effects = {
        vibrancy()
        blur(4f.dp.toPx())
        lens(16f.dp.toPx(), 32f.dp.toPx())
    }
)
```

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

### Apply Exposure Adjustment

Source: https://kyant.gitbook.io/backdrop/api/backdrop-effects.md

Adjusts the exposure value (ev) of the backdrop.

```kotlin
exposureAdjustment(ev: Float)
```

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

### Implement GlassSlider Component

Source: https://kyant.gitbook.io/backdrop/tutorials/glass-slider.md

Define the GlassSlider composable with track and thumb layers, utilizing lens effects for refraction.

```kotlin
// your package

import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.BoxWithConstraints
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.offset
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.dp
import com.kyant.backdrop.Backdrop
import com.kyant.backdrop.backdrops.layerBackdrop
import com.kyant.backdrop.backdrops.rememberLayerBackdrop
import com.kyant.backdrop.drawBackdrop
import com.kyant.backdrop.effects.lens

@Composable
fun GlassSlider(
    backdrop: Backdrop,
    modifier: Modifier = Modifier
) {
    BoxWithConstraints(
        modifier
            .padding(horizontal = 24f.dp)
            .fillMaxWidth(),
        contentAlignment = Alignment.CenterStart
    ) {
        val trackBackdrop = rememberLayerBackdrop()

        // track
        Box(
            Modifier
                .layerBackdrop(trackBackdrop)
                .background(Color(0xFF0088FF), CircleShape)
                .height(6f.dp)
                .fillMaxWidth()
        )

        // thumb
        Box(
            Modifier
                .offset(x = maxWidth / 2f - 28f.dp)
                .drawBackdrop(
                    // We want to draw both of `backdrop` and `trackBackdrop`
                    backdrop = trackBackdrop,
                    shape = { CircleShape },
                    effects = {
                        lens(
                            refractionHeight = 12f.dp.toPx(),
                            refractionAmount = 16f.dp.toPx(),
                            chromaticAberration = true
                        )
                    }
                )
                .size(56f.dp, 32f.dp)
        )
    }
}
```

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

### Apply Custom RenderEffect

Source: https://kyant.gitbook.io/backdrop/api/backdrop-effects.md

Applies a custom RenderEffect or a RuntimeShaderEffect.

```kotlin
effect(effect: RenderEffect)
```

```kotlin
runtimeShaderEffect(
    key: String,
    shaderString: String,
    uniformShaderName: String,
    block: RuntimeShader.() -> Unit
)
```

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

### Apply Blur Effect

Source: https://kyant.gitbook.io/backdrop/api/backdrop-effects.md

Applies a blur effect with a specified radius and edge treatment.

```kotlin
blur(
    radius: Float,
    edgeTreatment: TileMode = TileMode.Clamp
)
```

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

### Implement alpha-masked progressive blur in Kotlin

Source: https://kyant.gitbook.io/backdrop/tutorials/progressive-blur.md

Applies a blur effect with an alpha mask using a custom RuntimeShader. Requires Android Tiramisu or higher for RenderEffect support.

```kotlin
Modifier.drawPlainBackdrop(
    backdrop = backdrop,
    shape = { RectangleShape },
    effects = {
        blur(4f.dp.toPx())
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
            effect(
                RenderEffect.createRuntimeShaderEffect(
                    obtainRuntimeShader(
                        "AlphaMask",
                        """
uniform shader content;

uniform float2 size;
layout(color) uniform half4 tint;
uniform float tintIntensity;

half4 main(float2 coord) {
    float blurAlpha = smoothstep(size.y, size.y * 0.5, coord.y);
    float tintAlpha = smoothstep(size.y, size.y * 0.5, coord.y);
    return mix(content.eval(coord) * blurAlpha, tint * tintAlpha, tintIntensity);
}"""
                    ).apply {
                        setFloatUniform("size", size.width, size.height)
                        setColorUniform("tint", tintColor.toArgb())
                        setFloatUniform("tintIntensity", 0.8f)
                    },
                    "content"
                )
            )
        }
    }
)
```

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

### Prevent Backdrop Scaling with layerBlock

Source: https://kyant.gitbook.io/backdrop/tutorials/interactive-glass-bottom-bar.md

Corrected implementation using the layerBlock parameter within drawBackdrop to ensure the backdrop remains static while the component scales.

```kotlin
val animationScope = rememberCoroutineScope()
val progressAnimation = remember { Animatable(0f) }

Box(
    Modifier
        .drawBackdrop(
            backdrop = backdrop,
            shape = { CircleShape },
            effects = {
                vibrancy()
                blur(4f.dp.toPx())
                lens(16f.dp.toPx(), 32f.dp.toPx())
            },
            layerBlock = {
                val progress = progressAnimation.value
                val maxScale = (size.width + 16f.dp.toPx()) / size.width
                val scale = lerp(1f, maxScale, progress)
                scaleX = scale
                scaleY = scale
            },
            onDrawSurface = { drawRect(Color.White.copy(alpha = 0.5f)) }
        )
        .clickable(interactionSource = null, indication = null) {}
        .pointerInput(animationScope) {
            val animationSpec = spring(0.5f, 300f, 0.001f)
            awaitEachGesture {
                // press
                awaitFirstDown()
                animationScope.launch {
                    progressAnimation.animateTo(1f, animationSpec)
                }

                // release
                waitForUpOrCancellation()
                animationScope.launch {
                    progressAnimation.animateTo(0f, animationSpec)
                }
            }
        }
        .fillMaxHeight()
        .weight(1f)
)
```

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

### Apply Lens Effect

Source: https://kyant.gitbook.io/backdrop/api/backdrop-effects.md

Applies a lens refraction effect; requires Android 13+ and a CornerBasedShape.

```kotlin
lens(
    refractionHeight: Float,
    refractionAmount: Float = height,
    depthEffect: Boolean = false,
    chromaticAberration: Boolean = false
)
```
Tokens:
Raw