tilt-shift-camera/app/src/main/res/raw/tiltshift_fragment.glsl

#extension GL_OES_EGL_image_external : require

// Fragment shader for tilt-shift effect
// Supports both linear and radial blur modes

precision mediump float;

// Camera texture (external texture for camera preview)
uniform samplerExternalOES uTexture;

// Effect parameters
uniform int uMode;              // 0 = linear, 1 = radial
uniform int uIsFrontCamera;     // 0 = back camera, 1 = front camera
uniform float uAngle;           // Rotation angle in radians
uniform float uPositionX;       // Horizontal center of focus (0-1)
uniform float uPositionY;       // Vertical center of focus (0-1)
uniform float uSize;            // Size of in-focus region (0-1)
uniform float uBlurAmount;      // Maximum blur intensity (0-1)
uniform float uFalloff;         // Transition sharpness (0-1, higher = more gradual)
uniform float uAspectRatio;     // Ellipse aspect ratio for radial mode
uniform vec2 uResolution;       // Texture resolution for proper sampling

// Precomputed trig for the adjusted angle (avoids per-fragment cos/sin calls)
uniform float uCosAngle;
uniform float uSinAngle;

varying vec2 vTexCoord;

// Calculate signed distance from the focus region for LINEAR mode
float linearFocusDistance(vec2 uv) {
    // Center point of the focus region
    // Transform from screen coordinates to texture coordinates
    // Back camera: Screen (x,y) -> Texture (y, 1-x)
    // Front camera: Screen (x,y) -> Texture (1-y, 1-x) (additional X flip for mirror)
    vec2 center;
    if (uIsFrontCamera == 1) {
        center = vec2(1.0 - uPositionY, 1.0 - uPositionX);
    } else {
        center = vec2(uPositionY, 1.0 - uPositionX);
    }
    vec2 offset = uv - center;

    // Correct for screen aspect ratio to make coordinate space square
    float screenAspect = uResolution.x / uResolution.y;
    offset.y *= screenAspect;

    // Use precomputed cos/sin for the adjusted angle
    float rotatedY = -offset.x * uSinAngle + offset.y * uCosAngle;

    return abs(rotatedY);
}

// Calculate signed distance from the focus region for RADIAL mode
float radialFocusDistance(vec2 uv) {
    // Center point of the focus region
    vec2 center;
    if (uIsFrontCamera == 1) {
        center = vec2(1.0 - uPositionY, 1.0 - uPositionX);
    } else {
        center = vec2(uPositionY, 1.0 - uPositionX);
    }
    vec2 offset = uv - center;

    // Correct for screen aspect ratio
    float screenAspect = uResolution.x / uResolution.y;
    offset.y *= screenAspect;

    // Use precomputed cos/sin for rotation
    vec2 rotated = vec2(
        offset.x * uCosAngle - offset.y * uSinAngle,
        offset.x * uSinAngle + offset.y * uCosAngle
    );

    // Apply ellipse aspect ratio
    rotated.x /= uAspectRatio;

    // Distance from center (elliptical)
    return length(rotated);
}

// Calculate blur factor based on distance from focus
float blurFactor(float dist) {
    float halfSize = uSize * 0.5;
    // Falloff range scales with the falloff parameter
    float transitionSize = halfSize * uFalloff;

    if (dist < halfSize) {
        return 0.0;  // In focus region
    }

    // Smooth falloff using smoothstep
    float normalizedDist = (dist - halfSize) / max(transitionSize, 0.001);
    return smoothstep(0.0, 1.0, normalizedDist) * uBlurAmount;
}

// Sample with Gaussian blur (9-tap, sigma ~= 2.0, unrolled for GLSL ES 1.00 compatibility)
vec4 sampleBlurred(vec2 uv, float blur) {
    if (blur < 0.01) {
        return texture2D(uTexture, uv);
    }

    vec2 texelSize = 1.0 / uResolution;

    // For radial mode, blur in radial direction from center
    // For linear mode, blur perpendicular to focus line
    vec2 blurDir;
    if (uMode == 1) {
        // Radial: blur away from center
        vec2 center;
        if (uIsFrontCamera == 1) {
            center = vec2(1.0 - uPositionY, 1.0 - uPositionX);
        } else {
            center = vec2(uPositionY, 1.0 - uPositionX);
        }
        vec2 toCenter = uv - center;
        float len = length(toCenter);
        if (len > 0.001) {
            blurDir = toCenter / len;
        } else {
            blurDir = vec2(1.0, 0.0);
        }
    } else {
        // Linear: blur perpendicular to focus line using precomputed trig
        blurDir = vec2(uCosAngle, uSinAngle);
    }

    // Scale blur radius by blur amount
    float radius = blur * 20.0;
    vec2 step = blurDir * texelSize * radius;

    // Unrolled 9-tap Gaussian blur (avoids integer-branched weight lookup)
    vec4 color = vec4(0.0);
    color += texture2D(uTexture, uv + step * -4.0) * 0.0162;
    color += texture2D(uTexture, uv + step * -3.0) * 0.0540;
    color += texture2D(uTexture, uv + step * -2.0) * 0.1216;
    color += texture2D(uTexture, uv + step * -1.0) * 0.1933;
    color += texture2D(uTexture, uv)                * 0.2258;
    color += texture2D(uTexture, uv + step *  1.0) * 0.1933;
    color += texture2D(uTexture, uv + step *  2.0) * 0.1216;
    color += texture2D(uTexture, uv + step *  3.0) * 0.0540;
    color += texture2D(uTexture, uv + step *  4.0) * 0.0162;

    return color;
}

void main() {
    float dist;
    if (uMode == 1) {
        dist = radialFocusDistance(vTexCoord);
    } else {
        dist = linearFocusDistance(vTexCoord);
    }
    float blur = blurFactor(dist);

    gl_FragColor = sampleBlurred(vTexCoord, blur);
}