5 réponses à ce sujet

[jsellam]

Hello tout le monde,

Est-ce que l'un d'entre vous saurais manipuler vertexxyz dans un fragment shader minko pour en connaitre sa position X et Y, pour ensuite les utiliser en tant qu'UV
C'est travailler ma seconde passe de shader.

Merci à vous

[jsellam]

En fait, j'ai regardé ici, ligne 64 :
https://github.com/a...ssShader.as#L64

mais ça n'a pas l'air d'être ça, et je ne comprends pas à quoi sert la classe PostProcessingShaderPart, et si je dois l'utiliser ou pas

[Jean-Marc Le Roux]

PostProcessingShaderPart donne des méthodes/propriétés utiles pour faire du post-process.
Par exemple, PostProcessingShaderPart.vertexPosition retourne directement la position du vertex telle qu'elle est censée être pour faire du post-processing (c'est à dire quand on rend un simple quad qui prend tout l'écran).

Pour avoir les coordonnées XY d'un vertex en screen space :

var screenPosition : SFloat = localToScreen(vertexXYZ);
 

Ca donne le vertex à l'écran dans un espace normalisé compris dans [-1 .. 1].
Pour en faire des UVs mappées sur l'écran:

var screenUV : SFloat = divide(add(screenPosition.xy, 1), 2);
 

[jsellam]

ok, merci pour l'info.
Quand j'utilise PostProcessingShaderPart pour retourner le vertex position, j'ai une scene totalement transparente (aucun polygone n'apparait), même en retournant du rouge dans mon fragment shader.


Par contre, en utilisant :

override protected function getVertexPosition() : SFloat
{
    return localToScreen(vertexXYZ)
}
 

et

override protected function getPixelColor():SFloat
{
   var screenPosition:SFloat = localToScreen(interpolate(vertexXYZ));
   var screenUV:SFloat = divide(add(screenPosition.xy, 1), 2);
   return float4(screenUV.x,0,0,1)
}
 

j'obtien le rendu suivant :

[jsellam]

voila comment je construit cet effet :

var terrainTarget:RenderTarget = new RenderTarget(256, 256, new TextureResource(256, 256), 0, 0x000000FF)
var mapEffect:Effect = new Effect(new RGBATerranShader(terrainTarget),new UnderwaterShader(terrainTarget.textureResource))
 

[Jean-Marc Le Roux]

Attention : les effets de post processing doivent être utilisé comme indiqué dans le PostProcessingExample :

https://github.com/a...ssingExample.as

Les shaders de post processing passent sur un quad de taille 1, avec donc des position de vertex entre -0.5, et 0.5.
Pour en faire un quad qui prend tout l'écran, on doit donc étirer ce quad (x2) et c'est exactement ce que donne PostProcessingShaderPart.vertexPosition :

public function get vertexPosition() : SFloat
{
  // mutiplier w par 0.5 <=> multiplier x, y, z par 2
  return multiply(vertexXYZ, float4(1, 1, 1, .5));
}
 

Donc dans du post-processing, on n'utilise pas du tout localToScreen ou même localToWorld, puisqu'on a juste a scaler le quad pour lui faire prendre tout l'écran. De plus, ce quad n'est pas "dans la scène", c'est juste idée d'avoir un shader qui passe sur chaque pixel de l'écran.

La formule du dessus pour transformer des coordonnées écran en UV n'est pas tout à fait juste. Voilà la bonne:

var screenUV : SFloat = divide(add(interpolate(screenVertexPosition.xy), 1), 2);

screenUV = float2(screenUV.x, subtract(1, screenUV.y));
 

On peut vérifier que ça fonctionne en la retournant comme résultat du pixel shader du post processing :

return float4(screenUV, 0, 0);