Pages: 1
Salut, Je ne sais pas si le post est au bon endroit mais le sujet a le mérite d'être assez explicite.
J'ai testé une class sympa pour faire un "waternode" avec des shaders pour la réflexion/réfraction.
http://irrlicht.sourceforge.net/phpBB2/ … ;start=150
J'avoue être largué en shaders mais je ne pense pas qu'ils soit en cause ce coup ci..
En fait la refractionmap affiche même ce qui se trouve au dessus de la surface : (pas normal non ?).
De plus, la réflexionmap affiche ce qui est sous l'eau ... (soucis inverse)
Ne serait-il pas possible de demander un rendu incluant uniquement les vertex au dessous de l'eau pour que la réfractionmap soit clean?
RefractionMap=VideoDriver->addRenderTargetTexture(renderTargetSize);
Si le screen parait bizard c'est non seulement que la réfraction est bugué mais aussi que j'ai désactivé la réflection afin d'y voir plus clair.
Je l'ai déjà dis je suis une bille en shaders mais je pense avoir compris que j'ai peut-être dis une bétise :
Les shaders peuvent peut-être ignorer les vertex au dessus du plan d'eau ... donc je les donne afin que vous y voyez plus clair :
PS :
struct PS_OUTPUT {
vec4 Color;
};
struct PS_INPUT {
vec4 Position;
vec2 BumpMapTexCoord;
vec4 RefractionMapTexCoord;
vec4 ReflectionMapTexCoord;
vec3 Position3D;
};
//
// Global variable definitions
//
uniform vec3 CameraPosition;
uniform float ColorBlendFactor;
uniform sampler2D ReflectionMap;
uniform sampler2D RefractionMap;
uniform sampler2D WaterBump;
uniform vec4 WaterColor;
uniform float WaveHeight;
//
// Function declarations
//
PS_OUTPUT xlat_main( in PS_INPUT Input );
//
// Function definitions
//
PS_OUTPUT xlat_main( in PS_INPUT Input ) {
vec4 bumpColor;
vec2 perturbation;
vec2 ProjectedRefractionTexCoords;
vec4 refractiveColor;
vec2 ProjectedReflectionTexCoords;
vec4 reflectiveColor;
vec3 eyeVector;
vec3 normalVector = vec3( 0.000000, 1.00000, 0.000000);
float fresnelTerm;
vec4 combinedColor;
PS_OUTPUT Output;
bumpColor = texture2D( WaterBump, Input.BumpMapTexCoord);
perturbation = (WaveHeight * (bumpColor.xy - 0.500000));
ProjectedRefractionTexCoords.x = (((Input.RefractionMapTexCoord.x / Input.RefractionMapTexCoord.w ) / 2.00000) + 0.500000);
ProjectedRefractionTexCoords.y = (((( Input.RefractionMapTexCoord.y ) / Input.RefractionMapTexCoord.w ) / 2.00000) + 0.500000);
refractiveColor = texture2D( RefractionMap, (ProjectedRefractionTexCoords + perturbation));
ProjectedReflectionTexCoords.x = (((Input.ReflectionMapTexCoord.x / Input.ReflectionMapTexCoord.w ) / 2.00000) + 0.500000);
ProjectedReflectionTexCoords.y = (((( Input.ReflectionMapTexCoord.y ) / Input.ReflectionMapTexCoord.w ) / 2.00000) + 0.500000);
reflectiveColor = texture2D( ReflectionMap, (ProjectedReflectionTexCoords + perturbation));
eyeVector = normalize( (CameraPosition - Input.Position3D) );
fresnelTerm = max( dot( eyeVector, normalVector), 0.000000);
combinedColor = mix( refractiveColor, (reflectiveColor * (1.00000 - fresnelTerm)), vec4( 0.250000));
Output.Color = ((ColorBlendFactor * WaterColor) + ((1.00000 - ColorBlendFactor) * combinedColor));
return Output;
}
//
// Translator's entry point
//
void main() {
PS_OUTPUT xlat_retVal;
PS_INPUT xlat_temp_Input;
xlat_temp_Input.Position = vec4( gl_FragCoord);
xlat_temp_Input.BumpMapTexCoord = vec2( gl_TexCoord[0]);
xlat_temp_Input.RefractionMapTexCoord = vec4( gl_TexCoord[1]);
xlat_temp_Input.ReflectionMapTexCoord = vec4( gl_TexCoord[2]);
xlat_temp_Input.Position3D = vec3( gl_TexCoord[3]);
xlat_retVal = xlat_main( xlat_temp_Input);
gl_FragData[0] = vec4( xlat_retVal.Color);
}VS :
struct VS_OUTPUT {
vec4 Position;
vec2 BumpMapTexCoord;
vec4 RefractionMapTexCoord;
vec4 ReflectionMapTexCoord;
vec3 Position3D;
};
struct VS_INPUT {
vec4 Position;
vec4 Color;
vec2 TexCoord0;
};
//
// Global variable definitions
//
uniform float Time;
uniform mat4 View;
uniform float WaveLength;
uniform vec2 WindDirection;
uniform float WindForce;
uniform mat4 WorldReflectionViewProj;
uniform mat4 WorldViewProj;
//
// Function declarations
//
VS_OUTPUT xlat_main( in VS_INPUT Input );
//
// Function definitions
//
VS_OUTPUT xlat_main( in VS_INPUT Input ) {
VS_OUTPUT Output;
Output.Position = ( WorldViewProj * Input.Position );
Output.BumpMapTexCoord = ((Input.TexCoord0 / WaveLength) + ((Time * WindForce) * WindDirection));
Output.RefractionMapTexCoord = ( WorldViewProj * Input.Position );
Output.ReflectionMapTexCoord = ( WorldReflectionViewProj * Input.Position);
Output.Position3D = vec3( ( View * Input.Position ));
return Output;
}
//
// Translator's entry point
//
void main() {
VS_OUTPUT xlat_retVal;
VS_INPUT xlat_temp_Input;
xlat_temp_Input.Position = vec4( gl_Vertex);
xlat_temp_Input.Color = vec4( gl_Color);
xlat_temp_Input.TexCoord0 = vec2( gl_MultiTexCoord0);
xlat_retVal = xlat_main( xlat_temp_Input);
gl_Position = vec4( xlat_retVal.Position);
gl_TexCoord[0] = vec4( xlat_retVal.BumpMapTexCoord, 0.0, 0.0);
gl_TexCoord[1] = vec4( xlat_retVal.RefractionMapTexCoord);
gl_TexCoord[2] = vec4( xlat_retVal.ReflectionMapTexCoord);
gl_TexCoord[3] = vec4( xlat_retVal.Position3D, 0.0);
}Dernière modification par TUpac (22-09-2009 13:17:06)
Hors ligne
Même si je n'ai pas vraiment le temps en ce moment de me plonger dans ton code (désolé 
)
il y a un post intéressant depuis quelques jour qui devrait peut-être t'intéresser: http://irrlicht.sourceforge.net/phpBB2/ … hp?t=35170
Hors ligne
Merci je matte un peu tout ça mais il n'a pas l'air de divulguer son code sur son myspace.
J'vais ptet' le MP sur le forum pour lui poser la question. Il a apparemment fait un shader qui opacifie les zones profondes !! génial pour gagner en FPS et surtout en réalisme! A propos de FPS par contre c'est un soucis énorme. je ne peux pas afficher l'eau + 50 mesh simples !! le FPS passe à moins de 15 et c'est injouable (sur une 8800). Je penses que ça serait nettement plus fluide si on pouvait ignorer les mesh superflus lors du rendu des shaders.
J'ai bon espoir merci encore tmyke
Dernière modification par TUpac (22-09-2009 22:19:52)
Hors ligne
Pages: 1
