Getting World Space Position in a Shader Pass

I see you're trying to reconstruct world space positions from a depth texture in a shader pass. Your code is missing the crucial getViewPosition() function that's needed to complete the workflow.

Here's how you can implement the missing function and properly reconstruct world positions from the depth buffer:

The Missing getViewPosition Function

Add this function to your fragment shader:

GLSLCopied
vec4 getViewPosition(vec2 uv, float depth, float clipW) {
    // Convert UV to clip space (-1 to 1)
    vec2 clipXY = uv * 2.0 - 1.0;
    
    // Reconstruct view-space position
    vec4 viewPosition = vec4(
        clipXY * clipW,
        viewZ,
        1.0
    );
    
    // Apply inverse projection to get the view position
    viewPosition = cameraProjectionMatrixInverse * viewPosition;
    return viewPosition;
}

Complete Fragment Shader

Here's a more complete version of your fragment shader:

GLSLCopied
uniform sampler2D tDepth;
uniform float cameraNear;
uniform float cameraFar;
uniform mat4 cameraProjectionMatrix;
uniform mat4 cameraProjectionMatrixInverse; // You need to add this uniform
uniform mat4 cameraWorldMatrix;
varying vec2 vUv;

#include <packing>

float getLinearDepth(const in vec2 screenPosition) {
    #if PERSPECTIVE_CAMERA == 1
        float fragCoordZ = texture2D(tDepth, screenPosition).x;
        float viewZ = perspectiveDepthToViewZ(fragCoordZ, cameraNear, cameraFar);
        return viewZToOrthographicDepth(viewZ, cameraNear, cameraFar);
    #else
        return texture2D(tDepth, screenPosition).x;
    #endif
}

float getViewZ(const in vec2 screenPosition) {
    float fragCoordZ = texture2D(tDepth, screenPosition).x;
    float viewZ = perspectiveDepthToViewZ(fragCoordZ, cameraNear, cameraFar);
    return viewZ;
}

vec4 getViewPosition(vec2 uv, float depth, float clipW) {
    // Convert UV to clip space (-1 to 1)
    vec2 clipXY = uv * 2.0 - 1.0;
    
    // Reconstruct view-space position
    float viewZ = getViewZ(uv);
    vec4 viewPosition = vec4(
        clipXY * clipW,
        viewZ,
        1.0
    );
    
    // Apply inverse projection to get the view position
    viewPosition = cameraProjectionMatrixInverse * viewPosition;
    return viewPosition;
}

void main() {
    float viewZ = getViewZ(vUv);
    float clipW = cameraProjectionMatrix[2][3] * viewZ + cameraProjectionMatrix[3][3];
    vec4 viewPos = getViewPosition(vUv, 0.0, clipW);
    vec4 worldPos = cameraWorldMatrix * viewPos;
    
    // Use worldPos as needed
    gl_FragColor = vec4(worldPos.xyz, 1.0);
}

JavaScript Setup

In your JavaScript code, you need to pass the camera matrices to the shader:

JAVASCRIPTCopied
// In your render loop or when setting up the shader
const shader = yourShaderMaterial;

shader.uniforms.cameraNear.value = camera.near;
shader.uniforms.cameraFar.value = camera.far;
shader.uniforms.cameraProjectionMatrix.value = camera.projectionMatrix;
shader.uniforms.cameraProjectionMatrixInverse.value = camera.projectionMatrixInverse;
shader.uniforms.cameraWorldMatrix.value = camera.matrixWorld;

Make sure to define these uniforms in your shader material:

JAVASCRIPTCopied
const shaderMaterial = new THREE.ShaderMaterial({
    uniforms: {
        tDepth: { value: yourDepthTexture },
        cameraNear: { value: camera.near },
        cameraFar: { value: camera.far },
        cameraProjectionMatrix: { value: camera.projectionMatrix },
        cameraProjectionMatrixInverse: { value: camera.projectionMatrixInverse },
        cameraWorldMatrix: { value: camera.matrixWorld }
    },
    vertexShader: vertexShaderCode,
    fragmentShader: fragmentShaderCode
});

This approach should give you world space positions that are independent of the camera's movement, as you're properly transforming from view space to world space using the camera's world matrix.