Shader GLSL pour brillant spéculaire réflexions sur une surface cubemapped

J'ai écrit un shader pour l'environnement cubemapping

*Vertex shader *

varying vec3 Normal;
varying vec3 EyeDir;
uniform samplerCube cubeMap;

void main()
{
        gl_Position = gl_ModelViewProjectionMatrix*gl_Vertex;
        Normal = gl_NormalMatrix * gl_Normal;
        EyeDir = vec3(gl_ModelViewMatrix * gl_Vertex);
}

*Fragment shader *

varying vec3 Normal;
varying vec3 EyeDir;

uniform samplerCube cubeMap;

 void main(void)
 {
    vec3 reflectedDirection = normalize(reflect(EyeDir, normalize(Normal)));
    reflectedDirection.y = -reflectedDirection.y;
    vec4 fragColor = textureCube(cubeMap, reflectedDirection);
    gl_FragColor = fragColor;
}

C'est le résultat classique:
Shader GLSL pour brillant spéculaire réflexions sur une surface cubemapped
Maintenant, je veux ajouter quelques spéculaire blanc mettre en évidence afin d'obtenir un son plus brillant effet, comme motherpearl. Comment est-il possible d'ajouter ce type de mettre en évidence? Comme dans cette image dois-je calculer la somme d'un composant spéculaire à gl_FragColor?
Une première tentative est de calculer la réflexion spéculaire dans le vertex shader

vec3 s = normalize(vec3(gl_LightSource[0].position - EyeDir));
vec3 v = normalize(EyeDir);
vec3 r = reflect( s, Normal );
vec3 ambient = vec3(gl_LightSource[0].ambient*gl_FrontMaterial.ambient);

float sDotN = max( dot(s,Normal), 0.0 );
vec3 diffuse = vec3(gl_LightSource[0].diffuse * gl_FrontMaterial.diffuse * sDotN);
vec3 spec = vec3(0.0);
if( sDotN > 0.0 )
    spec = gl_LightSource[0].specular * gl_FrontMaterial.specular * pow( max( dot(r,v), 2.0 ), gl_FrontMaterial.shininess );

LightIntensity = 0*ambient + 0*diffuse +  spec;

et de la multiplier à gl_FragColor mais l'effet-je obtenir n'est pas convaincante.

Quelqu'un a idée de comment le faire?

Je m'attends à ce que vous l'ajouter plutôt que de les multiplier, car c'est de la lumière supplémentaire, pas de moduler le montant de la réflexion - à moins que j'ai mal compris 🙂
Pourquoi ajouter? et si fragColor valeurs RVB sont trop gros? Est-il une sorte de moyenne pondérée je dois adopter?
Eh bien, ma compréhension, c'est que vous voulez calculer la réflexion, et ensuite, en plus d'ajouter quelques reflets spéculaires, si vous voulez ajouter de la lumière à la fois (et sans doute de serrage de valeurs). Je ne suis pas 100% sûr et ne peut pas aider sur le détail (c'est pourquoi c'est un commentaire, pas une réponse... désolé)
Il semble qu'un modèle raisonnable pour le fragment de couleur est gl_FragColor = texture*(ambient+diffuse) + specular
Pouvez-vous nous montrer l'effet que vous avez obtenu ce que vous trouver pas convaincant?

OriginalL'auteur linello | 2012-08-03

c++glsl graphics opengl

Voici un exemple de la façon dont vous :

Mère-de-Perle-Effet HORS:

Shader GLSL pour brillant spéculaire réflexions sur une surface cubemapped

Mère-de-Perle-Effet SUR:

Vertex shader:

uniform vec3 fvEyePosition;

varying vec3 ViewDirection;
varying vec3 Normal;

void main( void )
{
   gl_Position = ftransform();
   vec4 fvObjectPosition = gl_ModelViewMatrix * gl_Vertex;

   ViewDirection  = fvEyePosition - fvObjectPosition.xyz;
   Normal         = gl_NormalMatrix * gl_Normal;
}

Fragment shader:

uniform samplerCube cubeMap;

varying vec3 ViewDirection;
varying vec3 Normal;

const float mother_pearl_brightness = 1.5;

#define MOTHER_PEARL

void main( void )
{
   vec3  fvNormal         = normalize(Normal);
   vec3  fvViewDirection  = normalize(ViewDirection);
   vec3  fvReflection     = normalize(reflect(fvViewDirection, fvNormal)); 

#ifdef MOTHER_PEARL
   float view_dot_normal = max(dot(fvNormal, fvViewDirection), 0.0);
   float view_dot_normal_inverse = 1.0 - view_dot_normal;

   gl_FragColor = textureCube(cubeMap, fvReflection) * view_dot_normal;
   gl_FragColor.r += mother_pearl_brightness * textureCube(cubeMap, fvReflection + vec3(0.1, 0.0, 0.0) * view_dot_normal_inverse) * (1.0 - view_dot_normal);
   gl_FragColor.g += mother_pearl_brightness * textureCube(cubeMap, fvReflection + vec3(0.0, 0.1, 0.0) * view_dot_normal_inverse) * (1.0 - view_dot_normal);
   gl_FragColor.b += mother_pearl_brightness * textureCube(cubeMap, fvReflection + vec3(0.0, 0.0, 0.1) * view_dot_normal_inverse) * (1.0 - view_dot_normal);
#else
   gl_FragColor = textureCube(cubeMap, fvReflection);
#endif
}

Bien sur la façon dont le R, G et B les composants sont calculés n'est pas très correct, mais je poste ce code pour vous montrer le chemin, pas la solution.

EDIT:

Voici la promesse de la "bonne" version de l'irisé shader:

Vertex shader:

varying vec3 v_view_direction;
varying vec3 v_normal;
varying vec2 v_texture_coordinate;

void main(void)
{
   gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
   v_texture_coordinate = gl_MultiTexCoord0.xy;
   v_view_direction = -gl_ModelViewMatrix[3].xyz;
   v_normal = gl_NormalMatrix * gl_Normal;
}

Fragment shader:

uniform samplerCube texture_reflection;
uniform sampler2D texture_iridescence;
uniform sampler2D texture_noise;

varying vec3 v_view_direction;
varying vec3 v_normal;
varying vec2 v_texture_coordinate;

const float noise_strength = 0.5;

void main(void)
{
   vec3 n_normal = normalize(v_normal);
   vec3 n_wiew_direction = normalize(v_view_direction);
   vec3 n_reflection = normalize(reflect(n_wiew_direction, n_normal)); 

   vec3 noise_vector = (texture2D(texture_noise, v_texture_coordinate).xyz - vec3(0.5)) * noise_strength;

   float inverse_dot_view = 1.0 - max(dot(normalize(n_normal + noise_vector), n_wiew_direction), 0.0);
   vec3 lookup_table_color = texture2D(texture_iridescence, vec2(inverse_dot_view, 0.0)).rgb;

   gl_FragColor.rgb = textureCube(texture_reflection, n_reflection).rgb * lookup_table_color * 2.5;
   gl_FragColor.a = 1.0;
}

Résultats

Aucun effet iridescent:

Shader GLSL pour brillant spéculaire réflexions sur une surface cubemapped

Effet Iridescent (recherche de la texture 1):

Shader GLSL pour brillant spéculaire réflexions sur une surface cubemapped

Effet Iridescent (recherche de texture 2):

Shader GLSL pour brillant spéculaire réflexions sur une surface cubemapped

Irisations de recherche texture 2:
Shader GLSL pour brillant spéculaire réflexions sur une surface cubemapped

La texture de bruit:

Shader GLSL pour brillant spéculaire réflexions sur une surface cubemapped

Remarques:

Les irisations de recherche de la texture pourrait être aussi une texture 1D, ce qui serait beaucoup plus efficace en terme de mémoire.

Aussi, la manière dont le bruit vecteur est calculé est en fait non-sens. La bonne solution serait d'utiliser le "bump". Mais bon, ça fonctionne! 😀

c'est très cool en effet, merci!
Pas de problème, mon ami!
Ok mon ami. La nouvelle version est en place.
C'est des choses vraiment bien. Je me demande comment vous allez au sujet de se débarrasser des artéfacts de repliement sur les bords de la visualisation?
Êtes-vous parler de l'aliasing sur le buste modèle? Qui est causé par le modèle lui-même (c'est un scan 3D). Il n'y a plus d'aliasing que mip-mapping doit prendre soin d'elle le long des bords.

OriginalL'auteur Tara

Vous devez vous connecter pour publier un commentaire.