Texture projective et éclairage différé

Dans ma question précédente , j'ai demandé s'il était possible de faire une texturation projective avec un éclairage différé. Maintenant (plus de six mois plus tard), j'ai un problème avec ma mise en œuvre de la même chose. J'essaie d'appliquer cette technique en passage de lumière. (mon projecteur n'affecte pas l'albédo). J'ai ce projecteur Voir une matrice de projection:

Matrix projection = Matrix.CreateOrthographicOffCenter(-halfWidth * Scale, halfWidth * Scale, -halfHeight * Scale, halfHeight * Scale, 1, 100000);
Matrix view       = Matrix.CreateLookAt(Position, Target, Vector3.Up);

Où halfWidthet halfHeightest la moitié de la largeur et de la hauteur de la texture, Positionest la position targetdu projecteur et est la cible du projecteur. Cela semble correct. Je dessine un quad en plein écran avec ce shader:

float4x4 InvViewProjection;

texture2D DepthTexture;
texture2D NormalTexture;
texture2D ProjectorTexture;

float4x4 ProjectorViewProjection;

sampler2D depthSampler = sampler_state {
    texture = <DepthTexture>;
    minfilter = point;
    magfilter = point;
    mipfilter = point;
};

sampler2D normalSampler = sampler_state {
    texture = <NormalTexture>;
    minfilter = point;
    magfilter = point;
    mipfilter = point;
};

sampler2D projectorSampler = sampler_state {
    texture = <ProjectorTexture>;
    AddressU  = Clamp;
    AddressV  = Clamp;
};

float viewportWidth;
float viewportHeight;

// Calculate the 2D screen position of a 3D position
float2 postProjToScreen(float4 position) {
    float2 screenPos = position.xy / position.w;
    return 0.5f * (float2(screenPos.x, -screenPos.y) + 1);
}

// Calculate the size of one half of a pixel, to convert
// between texels and pixels
float2 halfPixel() {
    return 0.5f / float2(viewportWidth, viewportHeight);
}

struct VertexShaderInput {
    float4 Position : POSITION0;
};

struct VertexShaderOutput {
    float4 Position :POSITION0;
    float4 PositionCopy : TEXCOORD1;
};

VertexShaderOutput VertexShaderFunction(VertexShaderInput input) {
    VertexShaderOutput output;
    output.Position = input.Position;
    output.PositionCopy=output.Position;
    return output;
}

float4 PixelShaderFunction(VertexShaderOutput input) : COLOR0 {
    float2 texCoord =postProjToScreen(input.PositionCopy) + halfPixel();

    // Extract the depth for this pixel from the depth map
    float4 depth = tex2D(depthSampler, texCoord);
    //return float4(depth.r,0,0,1);
    // Recreate the position with the UV coordinates and depth value
    float4 position;
    position.x = texCoord.x * 2 - 1;
    position.y = (1 - texCoord.y) * 2 - 1;
    position.z = depth.r;
    position.w = 1.0f;

    // Transform position from screen space to world space
    position = mul(position, InvViewProjection);
    position.xyz /= position.w;
    //compute projection
    float3 projection=tex2D(projectorSampler,postProjToScreen(mul(position,ProjectorViewProjection)) + halfPixel());
    return float4(projection,1);
}

Dans la première partie du pixel shader, la position récupérée du G-buffer (ce code que j'utilise dans d'autres shaders sans aucun problème) est ensuite transformée dans l'espace de projection du projecteur. Le problème est que la projection n'apparaît pas. Voici une image de ma situation:

Les lignes vertes sont le tronc du projecteur rendu. Où est mon erreur cachée? J'utilise XNA 4. Merci pour vos conseils et désolé pour mon anglais.

ÉDITER:

Le shader ci-dessus fonctionne mais la projection était trop petite. Lorsque j'ai changé la propriété Scale en une grande valeur (par exemple 100), la projection apparaît. Mais lorsque la caméra se déplace vers la projection, la projection se développe, comme on peut le voir sur cette vidéo YouTube .

Dans votre shader, vous devrez supprimer le position.xyz /= w;car c'est ce qui cause votre problème de redimensionnement:

// Transform position from screen space to world space 
position = mul(position, InvViewProjection); 
position.xyz /= position.w;  <<-- Comment this out

Cela devrait faire l'affaire.

Si vous obtenez des résultats trop petits et atteignez cette taille, c'est peut-être parce que le tronc est toujours dans un espace de 1 à -1 ou de 0 à 1 ou similaire? Est-ce là votre origine autour de laquelle le tronc est basé?