Implement two-pass separable Gaussian blur for camera preview
Replace the single-pass 9-tap directional blur with a three-pass pipeline: passthrough (camera→FBO), horizontal blur (FBO-A→FBO-B), vertical blur (FBO-B→screen). This produces a true 2D Gaussian with a 13-tap kernel per pass, eliminating the visible banding/streaking of the old approach. Key changes: - TiltShiftRenderer: FBO ping-pong with two color textures, separate fullscreen quad for blur passes (no crop-to-fill), drawQuad helper - TiltShiftShader: manages two programs (passthrough + blur), blur program uses raw screen-space angle (no camera rotation adjustment) - tiltshift_fragment.glsl: rewritten for sampler2D in screen space, aspect correction on X axis (height-normalized), uBlurDirection uniform for H/V selection, wider falloff (3x multiplier) - New tiltshift_passthrough_fragment.glsl for camera→FBO copy - TiltShiftOverlay: shrink PINCH_SIZE zone (1.3x, was 2.0x) so pinch-to-zoom is reachable over more of the screen - CameraManager: optimistic zoom update fixes pinch-to-zoom stalling (stale zoomRatio base prevented delta accumulation) Bump version to 1.1.3. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
This commit is contained in:
parent
aab1ff38a4
commit
f3baa723be
7 changed files with 397 additions and 298 deletions
|
|
@ -174,24 +174,14 @@ class CameraManager(private val context: Context) {
|
|||
}
|
||||
|
||||
/**
|
||||
* Sets the zoom ratio. Updates UI state only after the camera confirms the change.
|
||||
* Sets the zoom ratio. Updates UI state immediately so that rapid pinch-to-zoom
|
||||
* gestures accumulate correctly (each frame uses the latest ratio as its base).
|
||||
* If the camera rejects the value, the next successful set corrects the state.
|
||||
*/
|
||||
fun setZoom(ratio: Float) {
|
||||
val clamped = ratio.coerceIn(_minZoomRatio.value, _maxZoomRatio.value)
|
||||
val future = camera?.cameraControl?.setZoomRatio(clamped)
|
||||
if (future != null) {
|
||||
future.addListener({
|
||||
try {
|
||||
future.get()
|
||||
_zoomRatio.value = clamped
|
||||
} catch (e: Exception) {
|
||||
Log.w(TAG, "Zoom operation failed", e)
|
||||
}
|
||||
}, ContextCompat.getMainExecutor(context))
|
||||
} else {
|
||||
// Optimistic update when camera not available (e.g. during init)
|
||||
_zoomRatio.value = clamped
|
||||
}
|
||||
_zoomRatio.value = clamped
|
||||
camera?.cameraControl?.setZoomRatio(clamped)
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -5,6 +5,7 @@ import android.graphics.SurfaceTexture
|
|||
import android.opengl.GLES11Ext
|
||||
import android.opengl.GLES20
|
||||
import android.opengl.GLSurfaceView
|
||||
import android.util.Log
|
||||
import java.nio.ByteBuffer
|
||||
import java.nio.ByteOrder
|
||||
import java.nio.FloatBuffer
|
||||
|
|
@ -12,10 +13,16 @@ import javax.microedition.khronos.egl.EGLConfig
|
|||
import javax.microedition.khronos.opengles.GL10
|
||||
|
||||
/**
|
||||
* OpenGL renderer for applying tilt-shift effect to camera preview.
|
||||
* OpenGL renderer for applying tilt-shift effect to camera preview
|
||||
* using a two-pass separable Gaussian blur.
|
||||
*
|
||||
* This renderer receives camera frames via SurfaceTexture and applies
|
||||
* the tilt-shift blur effect using GLSL shaders.
|
||||
* Rendering pipeline (3 draw calls per frame):
|
||||
* 1. **Passthrough**: camera texture → FBO-A (handles coordinate transform via vertex/texcoord)
|
||||
* 2. **Horizontal blur**: FBO-A → FBO-B (13-tap Gaussian, tilt-shift mask)
|
||||
* 3. **Vertical blur**: FBO-B → screen (13-tap Gaussian, tilt-shift mask)
|
||||
*
|
||||
* The passthrough decouples the camera's rotated coordinate system from the blur
|
||||
* passes, which work entirely in screen space.
|
||||
*/
|
||||
class TiltShiftRenderer(
|
||||
private val context: Context,
|
||||
|
|
@ -23,16 +30,30 @@ class TiltShiftRenderer(
|
|||
private val onFrameAvailable: () -> Unit
|
||||
) : GLSurfaceView.Renderer {
|
||||
|
||||
companion object {
|
||||
private const val TAG = "TiltShiftRenderer"
|
||||
}
|
||||
|
||||
private lateinit var shader: TiltShiftShader
|
||||
private var surfaceTexture: SurfaceTexture? = null
|
||||
private var cameraTextureId: Int = 0
|
||||
|
||||
private lateinit var vertexBuffer: FloatBuffer
|
||||
private lateinit var texCoordBuffer: FloatBuffer
|
||||
// Camera quad: crop-to-fill vertices + rotated texcoords (pass 1 only)
|
||||
private lateinit var cameraVertexBuffer: FloatBuffer
|
||||
private lateinit var cameraTexCoordBuffer: FloatBuffer
|
||||
|
||||
// Fullscreen quad for blur passes (no crop, standard texcoords)
|
||||
private lateinit var fullscreenVertexBuffer: FloatBuffer
|
||||
private lateinit var fullscreenTexCoordBuffer: FloatBuffer
|
||||
|
||||
private var surfaceWidth: Int = 0
|
||||
private var surfaceHeight: Int = 0
|
||||
|
||||
// FBO resources: one framebuffer, two color textures for ping-pong
|
||||
private var fboId: Int = 0
|
||||
private var fboTexA: Int = 0
|
||||
private var fboTexB: Int = 0
|
||||
|
||||
// Current effect parameters (updated from UI thread)
|
||||
@Volatile
|
||||
var blurParameters: BlurParameters = BlurParameters.DEFAULT
|
||||
|
|
@ -69,27 +90,33 @@ class TiltShiftRenderer(
|
|||
@Volatile
|
||||
private var currentTexCoords = texCoordsBack
|
||||
|
||||
@Volatile
|
||||
private var updateTexCoordBuffer = false
|
||||
|
||||
override fun onSurfaceCreated(gl: GL10?, config: EGLConfig?) {
|
||||
GLES20.glClearColor(0f, 0f, 0f, 1f)
|
||||
|
||||
// Initialize shader
|
||||
shader = TiltShiftShader(context)
|
||||
shader.initialize()
|
||||
|
||||
// Allocate vertex buffer (8 floats = 4 vertices × 2 components)
|
||||
vertexBuffer = ByteBuffer.allocateDirect(8 * 4)
|
||||
.order(ByteOrder.nativeOrder())
|
||||
.asFloatBuffer()
|
||||
// Fill with default full-screen quad; will be recomputed when camera resolution is known
|
||||
vertexBuffer.put(floatArrayOf(-1f, -1f, 1f, -1f, -1f, 1f, 1f, 1f))
|
||||
vertexBuffer.position(0)
|
||||
// Camera quad vertex buffer (crop-to-fill, recomputed when resolution is known)
|
||||
cameraVertexBuffer = allocateFloatBuffer(8)
|
||||
cameraVertexBuffer.put(floatArrayOf(-1f, -1f, 1f, -1f, -1f, 1f, 1f, 1f))
|
||||
cameraVertexBuffer.position(0)
|
||||
|
||||
// Create texture coordinate buffer
|
||||
texCoordBuffer = ByteBuffer.allocateDirect(currentTexCoords.size * 4)
|
||||
.order(ByteOrder.nativeOrder())
|
||||
.asFloatBuffer()
|
||||
.put(currentTexCoords)
|
||||
texCoordBuffer.position(0)
|
||||
// Camera texcoord buffer (rotated for portrait)
|
||||
cameraTexCoordBuffer = allocateFloatBuffer(8)
|
||||
cameraTexCoordBuffer.put(currentTexCoords)
|
||||
cameraTexCoordBuffer.position(0)
|
||||
|
||||
// Fullscreen quad for blur passes (standard coords)
|
||||
fullscreenVertexBuffer = allocateFloatBuffer(8)
|
||||
fullscreenVertexBuffer.put(floatArrayOf(-1f, -1f, 1f, -1f, -1f, 1f, 1f, 1f))
|
||||
fullscreenVertexBuffer.position(0)
|
||||
|
||||
fullscreenTexCoordBuffer = allocateFloatBuffer(8)
|
||||
fullscreenTexCoordBuffer.put(floatArrayOf(0f, 0f, 1f, 0f, 0f, 1f, 1f, 1f))
|
||||
fullscreenTexCoordBuffer.position(0)
|
||||
|
||||
// Create camera texture
|
||||
val textures = IntArray(1)
|
||||
|
|
@ -114,88 +141,75 @@ class TiltShiftRenderer(
|
|||
surfaceWidth = width
|
||||
surfaceHeight = height
|
||||
vertexBufferDirty = true
|
||||
recreateFBOs(width, height)
|
||||
}
|
||||
|
||||
override fun onDrawFrame(gl: GL10?) {
|
||||
// Update texture with latest camera frame
|
||||
surfaceTexture?.updateTexImage()
|
||||
|
||||
// Recompute vertex buffer for crop-to-fill when camera or surface dimensions change
|
||||
if (vertexBufferDirty) {
|
||||
recomputeVertices()
|
||||
vertexBufferDirty = false
|
||||
}
|
||||
|
||||
// Update texture coordinate buffer if camera changed
|
||||
if (updateTexCoordBuffer) {
|
||||
texCoordBuffer.clear()
|
||||
texCoordBuffer.put(currentTexCoords)
|
||||
texCoordBuffer.position(0)
|
||||
cameraTexCoordBuffer.clear()
|
||||
cameraTexCoordBuffer.put(currentTexCoords)
|
||||
cameraTexCoordBuffer.position(0)
|
||||
updateTexCoordBuffer = false
|
||||
}
|
||||
|
||||
val params = blurParameters
|
||||
|
||||
// --- Pass 1: Camera → FBO-A (passthrough with crop-to-fill) ---
|
||||
GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, fboId)
|
||||
GLES20.glFramebufferTexture2D(
|
||||
GLES20.GL_FRAMEBUFFER, GLES20.GL_COLOR_ATTACHMENT0,
|
||||
GLES20.GL_TEXTURE_2D, fboTexA, 0
|
||||
)
|
||||
GLES20.glViewport(0, 0, surfaceWidth, surfaceHeight)
|
||||
GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT)
|
||||
|
||||
// Use shader and set parameters
|
||||
shader.use(cameraTextureId, blurParameters, surfaceWidth, surfaceHeight, isFrontCamera)
|
||||
|
||||
// Set vertex positions
|
||||
GLES20.glEnableVertexAttribArray(shader.aPositionLocation)
|
||||
GLES20.glVertexAttribPointer(
|
||||
shader.aPositionLocation,
|
||||
2,
|
||||
GLES20.GL_FLOAT,
|
||||
false,
|
||||
0,
|
||||
vertexBuffer
|
||||
shader.usePassthrough(cameraTextureId)
|
||||
drawQuad(
|
||||
shader.passthroughPositionLoc, shader.passthroughTexCoordLoc,
|
||||
cameraVertexBuffer, cameraTexCoordBuffer
|
||||
)
|
||||
|
||||
// Set texture coordinates
|
||||
GLES20.glEnableVertexAttribArray(shader.aTexCoordLocation)
|
||||
GLES20.glVertexAttribPointer(
|
||||
shader.aTexCoordLocation,
|
||||
2,
|
||||
GLES20.GL_FLOAT,
|
||||
false,
|
||||
0,
|
||||
texCoordBuffer
|
||||
// --- Pass 2: FBO-A → FBO-B (horizontal blur) ---
|
||||
GLES20.glFramebufferTexture2D(
|
||||
GLES20.GL_FRAMEBUFFER, GLES20.GL_COLOR_ATTACHMENT0,
|
||||
GLES20.GL_TEXTURE_2D, fboTexB, 0
|
||||
)
|
||||
GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT)
|
||||
shader.useBlurPass(fboTexA, params, surfaceWidth, surfaceHeight, 1f, 0f)
|
||||
drawQuad(
|
||||
shader.blurPositionLoc, shader.blurTexCoordLoc,
|
||||
fullscreenVertexBuffer, fullscreenTexCoordBuffer
|
||||
)
|
||||
|
||||
// Draw quad
|
||||
GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, 4)
|
||||
|
||||
// Cleanup
|
||||
GLES20.glDisableVertexAttribArray(shader.aPositionLocation)
|
||||
GLES20.glDisableVertexAttribArray(shader.aTexCoordLocation)
|
||||
// --- Pass 3: FBO-B → screen (vertical blur) ---
|
||||
GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, 0)
|
||||
GLES20.glViewport(0, 0, surfaceWidth, surfaceHeight)
|
||||
GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT)
|
||||
shader.useBlurPass(fboTexB, params, surfaceWidth, surfaceHeight, 0f, 1f)
|
||||
drawQuad(
|
||||
shader.blurPositionLoc, shader.blurTexCoordLoc,
|
||||
fullscreenVertexBuffer, fullscreenTexCoordBuffer
|
||||
)
|
||||
}
|
||||
|
||||
/**
|
||||
* Updates blur parameters. Thread-safe.
|
||||
*/
|
||||
fun updateParameters(params: BlurParameters) {
|
||||
blurParameters = params
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets whether using front camera. Updates texture coordinates accordingly.
|
||||
* Thread-safe - actual buffer update happens on next frame.
|
||||
*/
|
||||
fun setFrontCamera(front: Boolean) {
|
||||
if (isFrontCamera != front) {
|
||||
isFrontCamera = front
|
||||
currentTexCoords = if (front) texCoordsFront else texCoordsBack
|
||||
// Buffer will be updated on next draw
|
||||
updateTexCoordBuffer = true
|
||||
}
|
||||
}
|
||||
|
||||
@Volatile
|
||||
private var updateTexCoordBuffer = false
|
||||
|
||||
/**
|
||||
* Sets the camera preview resolution for crop-to-fill aspect ratio correction.
|
||||
* Thread-safe — vertex buffer is recomputed on the next frame.
|
||||
*/
|
||||
fun setCameraResolution(width: Int, height: Int) {
|
||||
if (cameraWidth != width || cameraHeight != height) {
|
||||
cameraWidth = width
|
||||
|
|
@ -204,45 +218,6 @@ class TiltShiftRenderer(
|
|||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Recomputes vertex positions to achieve crop-to-fill.
|
||||
*
|
||||
* The camera sensor is landscape; after the 90° rotation applied via texture coordinates,
|
||||
* the effective portrait dimensions are (cameraHeight × cameraWidth). We scale the vertex
|
||||
* quad so the camera frame fills the screen without stretching — the GPU clips the overflow.
|
||||
*/
|
||||
private fun recomputeVertices() {
|
||||
var scaleX = 1f
|
||||
var scaleY = 1f
|
||||
|
||||
if (cameraWidth > 0 && cameraHeight > 0 && surfaceWidth > 0 && surfaceHeight > 0) {
|
||||
// After 90° rotation: portrait width = cameraHeight, portrait height = cameraWidth
|
||||
val cameraRatio = cameraHeight.toFloat() / cameraWidth
|
||||
val screenRatio = surfaceWidth.toFloat() / surfaceHeight
|
||||
|
||||
if (cameraRatio > screenRatio) {
|
||||
// Camera wider than screen → crop sides
|
||||
scaleX = cameraRatio / screenRatio
|
||||
} else {
|
||||
// Camera taller than screen → crop top/bottom
|
||||
scaleY = screenRatio / cameraRatio
|
||||
}
|
||||
}
|
||||
|
||||
vertexBuffer.clear()
|
||||
vertexBuffer.put(floatArrayOf(
|
||||
-scaleX, -scaleY,
|
||||
scaleX, -scaleY,
|
||||
-scaleX, scaleY,
|
||||
scaleX, scaleY
|
||||
))
|
||||
vertexBuffer.position(0)
|
||||
}
|
||||
|
||||
/**
|
||||
* Releases OpenGL resources.
|
||||
* Must be called from GL thread.
|
||||
*/
|
||||
fun release() {
|
||||
shader.release()
|
||||
surfaceTexture?.release()
|
||||
|
|
@ -252,5 +227,117 @@ class TiltShiftRenderer(
|
|||
GLES20.glDeleteTextures(1, intArrayOf(cameraTextureId), 0)
|
||||
cameraTextureId = 0
|
||||
}
|
||||
|
||||
deleteFBOs()
|
||||
}
|
||||
|
||||
// --- Private helpers ---
|
||||
|
||||
private fun drawQuad(
|
||||
positionLoc: Int,
|
||||
texCoordLoc: Int,
|
||||
vertices: FloatBuffer,
|
||||
texCoords: FloatBuffer
|
||||
) {
|
||||
GLES20.glEnableVertexAttribArray(positionLoc)
|
||||
GLES20.glVertexAttribPointer(positionLoc, 2, GLES20.GL_FLOAT, false, 0, vertices)
|
||||
|
||||
GLES20.glEnableVertexAttribArray(texCoordLoc)
|
||||
GLES20.glVertexAttribPointer(texCoordLoc, 2, GLES20.GL_FLOAT, false, 0, texCoords)
|
||||
|
||||
GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, 4)
|
||||
|
||||
GLES20.glDisableVertexAttribArray(positionLoc)
|
||||
GLES20.glDisableVertexAttribArray(texCoordLoc)
|
||||
}
|
||||
|
||||
/**
|
||||
* Recomputes camera vertex positions to achieve crop-to-fill.
|
||||
*
|
||||
* The camera sensor is landscape; after the 90° rotation applied via texture coordinates,
|
||||
* the effective portrait dimensions are (cameraHeight × cameraWidth). We scale the vertex
|
||||
* quad so the camera frame fills the surface without stretching — the GPU clips the overflow.
|
||||
*/
|
||||
private fun recomputeVertices() {
|
||||
var scaleX = 1f
|
||||
var scaleY = 1f
|
||||
|
||||
if (cameraWidth > 0 && cameraHeight > 0 && surfaceWidth > 0 && surfaceHeight > 0) {
|
||||
val cameraRatio = cameraHeight.toFloat() / cameraWidth
|
||||
val screenRatio = surfaceWidth.toFloat() / surfaceHeight
|
||||
|
||||
if (cameraRatio > screenRatio) {
|
||||
scaleX = cameraRatio / screenRatio
|
||||
} else {
|
||||
scaleY = screenRatio / cameraRatio
|
||||
}
|
||||
}
|
||||
|
||||
cameraVertexBuffer.clear()
|
||||
cameraVertexBuffer.put(floatArrayOf(
|
||||
-scaleX, -scaleY,
|
||||
scaleX, -scaleY,
|
||||
-scaleX, scaleY,
|
||||
scaleX, scaleY
|
||||
))
|
||||
cameraVertexBuffer.position(0)
|
||||
}
|
||||
|
||||
private fun recreateFBOs(width: Int, height: Int) {
|
||||
deleteFBOs()
|
||||
|
||||
// Create two color textures for ping-pong
|
||||
val texIds = IntArray(2)
|
||||
GLES20.glGenTextures(2, texIds, 0)
|
||||
fboTexA = texIds[0]
|
||||
fboTexB = texIds[1]
|
||||
|
||||
for (texId in texIds) {
|
||||
GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, texId)
|
||||
GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_LINEAR)
|
||||
GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_LINEAR)
|
||||
GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_S, GLES20.GL_CLAMP_TO_EDGE)
|
||||
GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_T, GLES20.GL_CLAMP_TO_EDGE)
|
||||
GLES20.glTexImage2D(
|
||||
GLES20.GL_TEXTURE_2D, 0, GLES20.GL_RGBA,
|
||||
width, height, 0,
|
||||
GLES20.GL_RGBA, GLES20.GL_UNSIGNED_BYTE, null
|
||||
)
|
||||
}
|
||||
|
||||
// Create single FBO (we swap the attached texture for ping-pong)
|
||||
val fbos = IntArray(1)
|
||||
GLES20.glGenFramebuffers(1, fbos, 0)
|
||||
fboId = fbos[0]
|
||||
|
||||
// Verify with texture A
|
||||
GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, fboId)
|
||||
GLES20.glFramebufferTexture2D(
|
||||
GLES20.GL_FRAMEBUFFER, GLES20.GL_COLOR_ATTACHMENT0,
|
||||
GLES20.GL_TEXTURE_2D, fboTexA, 0
|
||||
)
|
||||
val status = GLES20.glCheckFramebufferStatus(GLES20.GL_FRAMEBUFFER)
|
||||
if (status != GLES20.GL_FRAMEBUFFER_COMPLETE) {
|
||||
Log.e(TAG, "FBO incomplete: $status")
|
||||
}
|
||||
GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, 0)
|
||||
}
|
||||
|
||||
private fun deleteFBOs() {
|
||||
if (fboId != 0) {
|
||||
GLES20.glDeleteFramebuffers(1, intArrayOf(fboId), 0)
|
||||
fboId = 0
|
||||
}
|
||||
if (fboTexA != 0 || fboTexB != 0) {
|
||||
GLES20.glDeleteTextures(2, intArrayOf(fboTexA, fboTexB), 0)
|
||||
fboTexA = 0
|
||||
fboTexB = 0
|
||||
}
|
||||
}
|
||||
|
||||
private fun allocateFloatBuffer(floatCount: Int): FloatBuffer {
|
||||
return ByteBuffer.allocateDirect(floatCount * 4)
|
||||
.order(ByteOrder.nativeOrder())
|
||||
.asFloatBuffer()
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -4,57 +4,167 @@ import android.content.Context
|
|||
import android.opengl.GLES11Ext
|
||||
import android.opengl.GLES20
|
||||
import no.naiv.tiltshift.R
|
||||
import kotlin.math.cos
|
||||
import kotlin.math.sin
|
||||
import java.io.BufferedReader
|
||||
import java.io.InputStreamReader
|
||||
import kotlin.math.cos
|
||||
import kotlin.math.sin
|
||||
|
||||
/**
|
||||
* Manages OpenGL shader programs for the tilt-shift effect.
|
||||
* Manages OpenGL shader programs for the two-pass tilt-shift effect.
|
||||
*
|
||||
* Two programs:
|
||||
* - **Passthrough**: copies camera texture (external OES) to an FBO, handling the
|
||||
* coordinate transform via vertex/texcoord setup.
|
||||
* - **Blur**: applies a directional Gaussian blur with tilt-shift mask.
|
||||
* Used twice per frame (horizontal then vertical) via the [uBlurDirection] uniform.
|
||||
*/
|
||||
class TiltShiftShader(private val context: Context) {
|
||||
|
||||
var programId: Int = 0
|
||||
private set
|
||||
// --- Passthrough program (camera → FBO) ---
|
||||
|
||||
// Attribute locations
|
||||
var aPositionLocation: Int = 0
|
||||
private set
|
||||
var aTexCoordLocation: Int = 0
|
||||
private set
|
||||
private var passthroughProgramId: Int = 0
|
||||
|
||||
// Uniform locations
|
||||
private var uTextureLocation: Int = 0
|
||||
private var uModeLocation: Int = 0
|
||||
private var uIsFrontCameraLocation: Int = 0
|
||||
private var uAngleLocation: Int = 0
|
||||
private var uPositionXLocation: Int = 0
|
||||
private var uPositionYLocation: Int = 0
|
||||
private var uSizeLocation: Int = 0
|
||||
private var uBlurAmountLocation: Int = 0
|
||||
private var uFalloffLocation: Int = 0
|
||||
private var uAspectRatioLocation: Int = 0
|
||||
private var uResolutionLocation: Int = 0
|
||||
private var uCosAngleLocation: Int = 0
|
||||
private var uSinAngleLocation: Int = 0
|
||||
var passthroughPositionLoc: Int = 0
|
||||
private set
|
||||
var passthroughTexCoordLoc: Int = 0
|
||||
private set
|
||||
private var passthroughTextureLoc: Int = 0
|
||||
|
||||
// --- Blur program (FBO → FBO/screen) ---
|
||||
|
||||
private var blurProgramId: Int = 0
|
||||
|
||||
var blurPositionLoc: Int = 0
|
||||
private set
|
||||
var blurTexCoordLoc: Int = 0
|
||||
private set
|
||||
private var blurTextureLoc: Int = 0
|
||||
private var blurModeLoc: Int = 0
|
||||
private var blurPositionXLoc: Int = 0
|
||||
private var blurPositionYLoc: Int = 0
|
||||
private var blurSizeLoc: Int = 0
|
||||
private var blurAmountLoc: Int = 0
|
||||
private var blurFalloffLoc: Int = 0
|
||||
private var blurAspectRatioLoc: Int = 0
|
||||
private var blurResolutionLoc: Int = 0
|
||||
private var blurCosAngleLoc: Int = 0
|
||||
private var blurSinAngleLoc: Int = 0
|
||||
private var blurDirectionLoc: Int = 0
|
||||
|
||||
/**
|
||||
* Compiles and links the shader program.
|
||||
* Compiles and links both shader programs.
|
||||
* Must be called from GL thread.
|
||||
*/
|
||||
fun initialize() {
|
||||
val vertexSource = loadShaderSource(R.raw.tiltshift_vertex)
|
||||
val fragmentSource = loadShaderSource(R.raw.tiltshift_fragment)
|
||||
|
||||
val vertexShader = compileShader(GLES20.GL_VERTEX_SHADER, vertexSource)
|
||||
val fragmentShader = compileShader(GLES20.GL_FRAGMENT_SHADER, fragmentSource)
|
||||
|
||||
programId = GLES20.glCreateProgram()
|
||||
// Passthrough program
|
||||
val passthroughFragSource = loadShaderSource(R.raw.tiltshift_passthrough_fragment)
|
||||
val passthroughFragShader = compileShader(GLES20.GL_FRAGMENT_SHADER, passthroughFragSource)
|
||||
passthroughProgramId = linkProgram(vertexShader, passthroughFragShader)
|
||||
GLES20.glDeleteShader(passthroughFragShader)
|
||||
|
||||
passthroughPositionLoc = GLES20.glGetAttribLocation(passthroughProgramId, "aPosition")
|
||||
passthroughTexCoordLoc = GLES20.glGetAttribLocation(passthroughProgramId, "aTexCoord")
|
||||
passthroughTextureLoc = GLES20.glGetUniformLocation(passthroughProgramId, "uTexture")
|
||||
|
||||
// Blur program
|
||||
val blurFragSource = loadShaderSource(R.raw.tiltshift_fragment)
|
||||
val blurFragShader = compileShader(GLES20.GL_FRAGMENT_SHADER, blurFragSource)
|
||||
blurProgramId = linkProgram(vertexShader, blurFragShader)
|
||||
GLES20.glDeleteShader(blurFragShader)
|
||||
|
||||
blurPositionLoc = GLES20.glGetAttribLocation(blurProgramId, "aPosition")
|
||||
blurTexCoordLoc = GLES20.glGetAttribLocation(blurProgramId, "aTexCoord")
|
||||
blurTextureLoc = GLES20.glGetUniformLocation(blurProgramId, "uTexture")
|
||||
blurModeLoc = GLES20.glGetUniformLocation(blurProgramId, "uMode")
|
||||
blurPositionXLoc = GLES20.glGetUniformLocation(blurProgramId, "uPositionX")
|
||||
blurPositionYLoc = GLES20.glGetUniformLocation(blurProgramId, "uPositionY")
|
||||
blurSizeLoc = GLES20.glGetUniformLocation(blurProgramId, "uSize")
|
||||
blurAmountLoc = GLES20.glGetUniformLocation(blurProgramId, "uBlurAmount")
|
||||
blurFalloffLoc = GLES20.glGetUniformLocation(blurProgramId, "uFalloff")
|
||||
blurAspectRatioLoc = GLES20.glGetUniformLocation(blurProgramId, "uAspectRatio")
|
||||
blurResolutionLoc = GLES20.glGetUniformLocation(blurProgramId, "uResolution")
|
||||
blurCosAngleLoc = GLES20.glGetUniformLocation(blurProgramId, "uCosAngle")
|
||||
blurSinAngleLoc = GLES20.glGetUniformLocation(blurProgramId, "uSinAngle")
|
||||
blurDirectionLoc = GLES20.glGetUniformLocation(blurProgramId, "uBlurDirection")
|
||||
|
||||
// Vertex shader is linked into both programs and can be freed
|
||||
GLES20.glDeleteShader(vertexShader)
|
||||
}
|
||||
|
||||
/**
|
||||
* Activates the passthrough program and binds the camera texture.
|
||||
*/
|
||||
fun usePassthrough(cameraTextureId: Int) {
|
||||
GLES20.glUseProgram(passthroughProgramId)
|
||||
GLES20.glActiveTexture(GLES20.GL_TEXTURE0)
|
||||
GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, cameraTextureId)
|
||||
GLES20.glUniform1i(passthroughTextureLoc, 0)
|
||||
}
|
||||
|
||||
/**
|
||||
* Activates the blur program and sets all uniforms for one blur pass.
|
||||
*
|
||||
* @param fboTextureId The FBO color attachment to sample from.
|
||||
* @param params Current blur parameters.
|
||||
* @param width Surface width in pixels.
|
||||
* @param height Surface height in pixels.
|
||||
* @param dirX Blur direction X component (1 for horizontal pass, 0 for vertical).
|
||||
* @param dirY Blur direction Y component (0 for horizontal pass, 1 for vertical).
|
||||
*/
|
||||
fun useBlurPass(
|
||||
fboTextureId: Int,
|
||||
params: BlurParameters,
|
||||
width: Int,
|
||||
height: Int,
|
||||
dirX: Float,
|
||||
dirY: Float
|
||||
) {
|
||||
GLES20.glUseProgram(blurProgramId)
|
||||
|
||||
GLES20.glActiveTexture(GLES20.GL_TEXTURE0)
|
||||
GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, fboTextureId)
|
||||
GLES20.glUniform1i(blurTextureLoc, 0)
|
||||
|
||||
GLES20.glUniform1i(blurModeLoc, if (params.mode == BlurMode.RADIAL) 1 else 0)
|
||||
GLES20.glUniform1f(blurPositionXLoc, params.positionX)
|
||||
GLES20.glUniform1f(blurPositionYLoc, params.positionY)
|
||||
GLES20.glUniform1f(blurSizeLoc, params.size)
|
||||
GLES20.glUniform1f(blurAmountLoc, params.blurAmount)
|
||||
GLES20.glUniform1f(blurFalloffLoc, params.falloff)
|
||||
GLES20.glUniform1f(blurAspectRatioLoc, params.aspectRatio)
|
||||
GLES20.glUniform2f(blurResolutionLoc, width.toFloat(), height.toFloat())
|
||||
|
||||
// Raw screen-space angle (no camera rotation adjustment needed — FBO is already
|
||||
// in screen orientation after the passthrough pass)
|
||||
GLES20.glUniform1f(blurCosAngleLoc, cos(params.angle))
|
||||
GLES20.glUniform1f(blurSinAngleLoc, sin(params.angle))
|
||||
|
||||
GLES20.glUniform2f(blurDirectionLoc, dirX, dirY)
|
||||
}
|
||||
|
||||
/**
|
||||
* Releases both shader programs.
|
||||
*/
|
||||
fun release() {
|
||||
if (passthroughProgramId != 0) {
|
||||
GLES20.glDeleteProgram(passthroughProgramId)
|
||||
passthroughProgramId = 0
|
||||
}
|
||||
if (blurProgramId != 0) {
|
||||
GLES20.glDeleteProgram(blurProgramId)
|
||||
blurProgramId = 0
|
||||
}
|
||||
}
|
||||
|
||||
private fun linkProgram(vertexShader: Int, fragmentShader: Int): Int {
|
||||
val programId = GLES20.glCreateProgram()
|
||||
GLES20.glAttachShader(programId, vertexShader)
|
||||
GLES20.glAttachShader(programId, fragmentShader)
|
||||
GLES20.glLinkProgram(programId)
|
||||
|
||||
// Check for link errors
|
||||
val linkStatus = IntArray(1)
|
||||
GLES20.glGetProgramiv(programId, GLES20.GL_LINK_STATUS, linkStatus, 0)
|
||||
if (linkStatus[0] == 0) {
|
||||
|
|
@ -63,72 +173,7 @@ class TiltShiftShader(private val context: Context) {
|
|||
throw RuntimeException("Shader program link failed: $error")
|
||||
}
|
||||
|
||||
// Get attribute locations
|
||||
aPositionLocation = GLES20.glGetAttribLocation(programId, "aPosition")
|
||||
aTexCoordLocation = GLES20.glGetAttribLocation(programId, "aTexCoord")
|
||||
|
||||
// Get uniform locations
|
||||
uTextureLocation = GLES20.glGetUniformLocation(programId, "uTexture")
|
||||
uModeLocation = GLES20.glGetUniformLocation(programId, "uMode")
|
||||
uIsFrontCameraLocation = GLES20.glGetUniformLocation(programId, "uIsFrontCamera")
|
||||
uAngleLocation = GLES20.glGetUniformLocation(programId, "uAngle")
|
||||
uPositionXLocation = GLES20.glGetUniformLocation(programId, "uPositionX")
|
||||
uPositionYLocation = GLES20.glGetUniformLocation(programId, "uPositionY")
|
||||
uSizeLocation = GLES20.glGetUniformLocation(programId, "uSize")
|
||||
uBlurAmountLocation = GLES20.glGetUniformLocation(programId, "uBlurAmount")
|
||||
uFalloffLocation = GLES20.glGetUniformLocation(programId, "uFalloff")
|
||||
uAspectRatioLocation = GLES20.glGetUniformLocation(programId, "uAspectRatio")
|
||||
uResolutionLocation = GLES20.glGetUniformLocation(programId, "uResolution")
|
||||
uCosAngleLocation = GLES20.glGetUniformLocation(programId, "uCosAngle")
|
||||
uSinAngleLocation = GLES20.glGetUniformLocation(programId, "uSinAngle")
|
||||
|
||||
// Clean up shaders (they're linked into program now)
|
||||
GLES20.glDeleteShader(vertexShader)
|
||||
GLES20.glDeleteShader(fragmentShader)
|
||||
}
|
||||
|
||||
/**
|
||||
* Uses the shader program and sets uniforms.
|
||||
*/
|
||||
fun use(textureId: Int, params: BlurParameters, width: Int, height: Int, isFrontCamera: Boolean = false) {
|
||||
GLES20.glUseProgram(programId)
|
||||
|
||||
// Bind camera texture
|
||||
GLES20.glActiveTexture(GLES20.GL_TEXTURE0)
|
||||
GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, textureId)
|
||||
GLES20.glUniform1i(uTextureLocation, 0)
|
||||
|
||||
// Set effect parameters
|
||||
GLES20.glUniform1i(uModeLocation, if (params.mode == BlurMode.RADIAL) 1 else 0)
|
||||
GLES20.glUniform1i(uIsFrontCameraLocation, if (isFrontCamera) 1 else 0)
|
||||
GLES20.glUniform1f(uAngleLocation, params.angle)
|
||||
GLES20.glUniform1f(uPositionXLocation, params.positionX)
|
||||
GLES20.glUniform1f(uPositionYLocation, params.positionY)
|
||||
GLES20.glUniform1f(uSizeLocation, params.size)
|
||||
GLES20.glUniform1f(uBlurAmountLocation, params.blurAmount)
|
||||
GLES20.glUniform1f(uFalloffLocation, params.falloff)
|
||||
GLES20.glUniform1f(uAspectRatioLocation, params.aspectRatio)
|
||||
GLES20.glUniform2f(uResolutionLocation, width.toFloat(), height.toFloat())
|
||||
|
||||
// Precompute angle trig on CPU to avoid per-fragment transcendental calls.
|
||||
// The adjusted angle accounts for the 90deg coordinate transform.
|
||||
val adjustedAngle = if (isFrontCamera) {
|
||||
-params.angle - (Math.PI / 2).toFloat()
|
||||
} else {
|
||||
params.angle + (Math.PI / 2).toFloat()
|
||||
}
|
||||
GLES20.glUniform1f(uCosAngleLocation, cos(adjustedAngle))
|
||||
GLES20.glUniform1f(uSinAngleLocation, sin(adjustedAngle))
|
||||
}
|
||||
|
||||
/**
|
||||
* Releases shader resources.
|
||||
*/
|
||||
fun release() {
|
||||
if (programId != 0) {
|
||||
GLES20.glDeleteProgram(programId)
|
||||
programId = 0
|
||||
}
|
||||
return programId
|
||||
}
|
||||
|
||||
private fun loadShaderSource(resourceId: Int): String {
|
||||
|
|
@ -142,7 +187,6 @@ class TiltShiftShader(private val context: Context) {
|
|||
GLES20.glShaderSource(shader, source)
|
||||
GLES20.glCompileShader(shader)
|
||||
|
||||
// Check for compile errors
|
||||
val compileStatus = IntArray(1)
|
||||
GLES20.glGetShaderiv(shader, GLES20.GL_COMPILE_STATUS, compileStatus, 0)
|
||||
if (compileStatus[0] == 0) {
|
||||
|
|
|
|||
|
|
@ -232,9 +232,9 @@ private fun determineGestureType(
|
|||
return when {
|
||||
// Very center of focus zone -> rotation (small area)
|
||||
distFromCenter < focusSize * 0.3f -> GestureType.ROTATE
|
||||
// Near the blur effect -> size adjustment (large area)
|
||||
distFromCenter < focusSize * 2.0f -> GestureType.PINCH_SIZE
|
||||
// Far outside -> camera zoom
|
||||
// Near the blur boundary -> size adjustment
|
||||
distFromCenter < focusSize * 1.3f -> GestureType.PINCH_SIZE
|
||||
// Outside the effect -> camera zoom
|
||||
else -> GestureType.PINCH_ZOOM
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue