Kotlin DSL pro AGSL shadery Android

Kotlin DSL pro AGSL šedery v Androidu: typizovaný přístup

Vývoj šederů na AGSL pro Android s RuntimeShader a RenderEffect často naráží na řetězcové literály, manuální vazbu uniform a slabou podporu IDE. Kotlin DSL tyto problémy řeší generováním nativního AGSL kódu bez ztráty výkonu. Knihovna převádí typizované konstrukce na hotové šedery, přičemž zachovává přístup k původnímu AGSL přes metodu agslSource().

To umožňuje soustředit se na logiku efektů, ne na syntax řetězců. Podpora API 33+, integrace s Compose a standardní knihovna procedurálních primitivů.

Problémy čistého AGSL v Kotlinu

Šedery v řetězcích ztrácejí výhody IDE: automatické doplňování, refactoring, kontrolu typů. Uniform se deklarují ručně, chyby v názvech vedou k pádům. Složité efekty se smoothstep, fract, mix se rozrůstají v nečitelný kód. V Compose se přidává obal pro čas a aktualizace.

DSL tyto překážky odstraňuje: uniform jsou typizované, mezivýpočty pojmenované přes let(), standardní funkce volány deklarativně.

Připojení knihovny

Přidejte závislosti do build.gradle:

dependencies {
    implementation("io.github.i-redbyte:redbytefx-core:1.0.0")
    implementation("io.github.i-redbyte:redbytefx-compose:1.0.0")
    implementation("io.github.i-redbyte:redbytefx-stdlib:1.0.0")
}

Srovnání: vlnové posun

Čistý AGSL

uniform shader content;
uniform float wave_amplitude;
uniform float wave_frequency;

half4 main(float2 fragCoord) {
  float2 offset = float2(
    0.0,
    sin(fragCoord.x * wave_frequency) * wave_amplitude
  );
  return content.eval(fragCoord + offset);
}

V Kotlin DSL

val effect = redbytefx {
    val amplitudeUniform = uniformFloat(0f, "wave_amplitude")
    val frequencyUniform = uniformFloat(0.08f, "wave_frequency")

    val x = let(fragCoord.x, "x")
    val waveOffset = let(
        float2(0f, sin(x * frequencyUniform) * amplitudeUniform),
        "wave_offset"
    )

    sample(fragCoord + waveOffset)
}

Generovaný AGSL je logicky identický, ale zdrojový kód je typizovaný a čitelný.

Příklady efektů podle složitosti

1. Wave: základní efekt

Jednoduchý posun po Y s sin. Ideální pro osvojení fragCoord, sample(), uniform. let() pojmenovává kroky bez zbytečného složení.

2. Signal: funkce a masky

val effect = redbytefx {
    val densityUniform = uniformFloat(8f, "signal_density")
    val lineWidthUniform = uniformFloat(0.08f, "signal_line_width")
    val amountUniform = uniformFloat(0.85f, "signal_amount")

    val pulseBand = fn(
        name = "pulse_band",
        arg1 = FloatType,
        arg2 = FloatType,
        returns = FloatType
    ) { phase, threshold ->
        step(threshold, smoothstep(0.08f, 0.92f, fract(phase)))
    }

    val base = let(sample(), "base")
    val uv = let(normalizedUv(), "uv")
    val grid = let(gridMask(uv, densityUniform, lineWidthUniform), "grid")
    val scan = let(scanlines(fragCoord.y, 14f, 3f), "scan")
    val pulse = let(pulseBand(uv.y * densityUniform * 0.5f + grid * 0.35f, 0.55f), "pulse")
    val hardMask = let(step(0.45f, scan * pulse), "hard_mask")
    val active = let((grid gt 0.05f) or (hardMask gt 0.5f), "active")
    val accent = let(color(float3(0.05f, 0.95f, 0.82f), base.a), "accent")
    val mixed = let(mix(base, accent, min(grid * 0.85f + hardMask * 0.35f, 1f)), "mixed")

    ifElse(active, mix(base, mixed, amountUniform), base)
}

fn() vyčleňuje funkce, gridMask() a scanlines() ze stdlib zjednodušují masky. ifElse() zachovává deklarativnost.

3. Radar: polární souřadnice

val effect = redbytefx {
    val time by autoUniformTime()
    val speed by autoUniformFloat(0.72f)
    val radius by autoUniformFloat(0.34f)
    val amount by autoUniformFloat(0.86f)

    val base = let(sample(), "base")
    val uv = let(fragCoord / resolution, "uv")
    val polar = let(polarCoordinates(uv), "polar")
    val sweepAngle = let(fract(time * speed * 0.08f), "sweep_angle")
    val sweep = let(angularSweep(uv = uv, angle = sweepAngle, width = 0.12f, feather = 0.03f), "sweep")
    val arc = let(
        arcMask(
            uv = uv,
            radius = radius,
            ringWidth = 0.09f,
            angle = sweepAngle,
            arcWidth = 0.18f,
            feather = 0.03f
        ),
        "arc"
    )
    val outerRing = let(ringMask(uv, radius = radius, width = 0.016f, feather = 0.012f), "outer_ring")
    val innerRing = let(ringMask(uv, radius = max(radius * 0.58f, 0.08f), width = 0.014f, feather = 0.012f), "inner_ring")
    val beam = let(radialRamp(uv = uv, innerRadius = float(0.06f), outerRadius = radius + 0.18f), "beam")
    val mask = let(max(max(sweep * beam, arc), max(outerRing, innerRing)), "mask")

    val tint = let(
        color(
            mix(0.05f, 0.18f, polar.x * 1.4f),
            mix(0.24f, 1f, sweep + arc * 0.55f),
            mix(0.10f, 0.62f, polar.y * 0.45f + outerRing * 0.35f),
            base.a
        ),
        "tint"
    )

    val screened = let(maskedScreen(base, tint, mask, amount), "screened")
    maskedOverlay(screened, color(float3(0.82f, 1f, 0.72f), base.a), arc, amount * 0.32f)
}

polarCoordinates(), arcMask(), ringMask() ze stdlib nahrazují ruční smoothstep. maskedScreen() a maskedOverlay() zjednodušují kompozici.

4. Metaballs: procedurální tvary

Efekt staví SDF-kruhy se smoothed min pro neonové shluky. DSL je vhodný pro plnohodnotné procedurální efekty, zachovává čitelnost složité geometrie.

Co je důležité

• Kotlin DSL generuje nativní AGSL bez overheadu, ověřitelné přes agslSource().
• Typizované uniform a let() řeší problémy řetězcového kódu a refaktoringu.
• Standardní knihovna (gridMask, polarCoordinates, arcMask) šetří čas na primitivy.
• fn() a ifElse() podporují modularitu bez imperativnosti.
• Integrace s Compose přes autoUniformTime() a vazbu parametrů.

— Editorial Team