Happy New Year Demo!

[JeGX]

Pour les heureux possesseurs de cartes ATI genre X700, la démo des fetes de fin d'année de Satry se présente ainsi:



Cette effet d'accumulation des flocons de neige sur les bords widescreen est vraiment cool mais malheureusement est du à un petit bug quelque part dans le moteur 3D... Mais sur ce coup, je n'irai pas le traquer  

La demo est downloadable ici:  Happy New Year Demo

[John Difool]

Salut JeGX!!!
Sympa la demo pour noel, en effet le bug rend bien.

J'ais plusieurs questions à te poser:

J'ais commencé une demo où j'utilise les pixels shader, les shadows caster et un spot que j'ais acroché en tant qu'enfant à la camera. Cependant, je n'arrive pas à projeter l'ombre sur mes modeles utilisant les pixels shaders (mes models sont tous éclairés sans voir le rond du spot, qui du faite se voi seulement sur le sol.)
En revanche, si j'utilise un bump mapping simple sa fonctione!
Voila pour la premiere question.

La suivante,
j'aimerais diriger cette lumiere à l'aide de hotkey, certainement en lua, mais je n'ais pas trouvé les expliquations.
Et par la suite, faire suivre cette lumiere par ma camera, en laissant un petit temps de retard à la camera pour augmenter l'impression.

Et enfin,
comment peut on faire un mapping potable avec des formes plus complexes qu'un mesh.
Du style, texture uvw sur 3ds max.

Merci d'avance, !!!!.
ps: je m'eclate bien sur hyperion ça assure, ya que mon ordi qu'est pas content!!! :cry:

[JeGX]

Hello!

Content qu'Hyperion te plaise, c'est le but!

Premiere question: il faut que tu code dans ton pixel shader le rendu d'un spot. Si tu es un peu patient (un ou deux petit jours j'espere) je vais poser un petite demo sur ce sujet. Il ne faut pas oublier qu'à partir du moment ou tu utilise les shaders programmables, tu dois tout recoder toi-même. Si ca marche avec un bump mapping simple c'est tout simplement que dans ce cas là, ce sont les fonctions cablées du pipeline 3D qui sont utilisées et bien sur le spot y est codé.

Mais pour obtenir le code du spot light en GLSL, tu peut aussi te servir du tool de 3DLabs:

http://developer.3dlabs.com/downloads/shadergen/index.htm .

Ce tool te permet d'avoir la version GLSL des fonctions cablées du pipeline 3D. Essai le et pourquoi pas, si tu en sort un tout petit Code Sample sur le spot light en GLSL je me ferai une joie de le mettre online!

Pour la seconde question, essai de coder directement dans un script LUA la recuperation des touches sans passer par les hotkeys.
Regarde le Code Sample 92 dans:
http://www.ozone3d.net/repository_hyperion_cs_interactivity.php

Troisième question: qu'est-ce que tu entends par une forme plus complexe qu'un mesh?

[JeGX]

Voilà en attendant le code issu de ShaderGen 3.0 pour une lumière de type spot :

Code: [Select]


/*******************************************************
*  Fixed.vert Fixed Function Equivalent Vertex Shader  *
*   Automatically Generated by 3Dlabs GLSL ShaderGen   *
*             http://developer.3dlabs.com              *
*******************************************************/
vec4 Ambient;
vec4 Diffuse;
vec4 Specular;


void spotLight(in int i, in vec3 normal, in vec3 eye, in vec3 ecPosition3)
{
   float nDotVP;            // normal . light direction
   float nDotHV;            // normal . light half vector
   float pf;                // power factor
   float spotDot;           // cosine of angle between spotlight
   float spotAttenuation;   // spotlight attenuation factor
   float attenuation;       // computed attenuation factor
   float d;                 // distance from surface to light source
   vec3  VP;                // direction from surface to light position
   vec3  halfVector;        // direction of maximum highlights

   // Compute vector from surface to light position
   VP = vec3 (gl_LightSource[i].position) - ecPosition3;

   // Compute distance between surface and light position
   d = length(VP);

   // Normalize the vector from surface to light position
   VP = normalize(VP);

   // Compute attenuation
   attenuation = 1.0 / (gl_LightSource[i].constantAttenuation +
       gl_LightSource[i].linearAttenuation * d +
       gl_LightSource[i].quadraticAttenuation * d * d);

   // See if point on surface is inside cone of illumination
   spotDot = dot(-VP, normalize(gl_LightSource[i].spotDirection));

   if (spotDot < gl_LightSource[i].spotCosCutoff)
   {
       spotAttenuation = 0.0; // light adds no contribution
   }
   else
   {
       spotAttenuation = pow(spotDot, gl_LightSource[i].spotExponent);

   }
   // Combine the spotlight and distance attenuation.
   attenuation *= spotAttenuation;

   halfVector = normalize(VP + eye);

   nDotVP = max(0.0, dot(normal, VP));
   nDotHV = max(0.0, dot(normal, halfVector));

   if (nDotVP == 0.0)
   {
       pf = 0.0;
   }
   else
   {
       pf = pow(nDotHV, gl_FrontMaterial.shininess);

   }
   Ambient  += gl_LightSource[i].ambient * attenuation;
   Diffuse  += gl_LightSource[i].diffuse * nDotVP * attenuation;
   Specular += gl_LightSource[i].specular * pf * attenuation;

}

vec3 fnormal(void)
{
    //Compute the normal
    vec3 normal = gl_NormalMatrix * gl_Normal;
    normal = normalize(normal);
    return normal;
}

void flight(in vec3 normal, in vec4 ecPosition, float alphaFade)
{
    vec4 color;
    vec3 ecPosition3;
    vec3 eye;

    ecPosition3 = (vec3 (ecPosition)) / ecPosition.w;
    eye = vec3 (0.0, 0.0, 1.0);

    // Clear the light intensity accumulators
    Ambient  = vec4 (0.0);
    Diffuse  = vec4 (0.0);
    Specular = vec4 (0.0);

    spotLight(0, normal, eye, ecPosition3);

    color = gl_FrontLightModelProduct.sceneColor +
      Ambient  * gl_FrontMaterial.ambient +
      Diffuse  * gl_FrontMaterial.diffuse;
    color += Specular * gl_FrontMaterial.specular;
    color = clamp( color, 0.0, 1.0 );
    gl_FrontColor = color;

    gl_FrontColor.a *= alphaFade;
}


void main (void)
{
    vec3  transformedNormal;
    float alphaFade = 1.0;

    // Eye-coordinate position of vertex, needed in various calculations
    vec4 ecPosition = gl_ModelViewMatrix * gl_Vertex;

    // Do fixed functionality vertex transform
    gl_Position = ftransform();
    transformedNormal = fnormal();
    flight(transformedNormal, ecPosition, alphaFade);
}



et  pour le pixel shader:

Code: [Select]


/*******************************************************
* Fixed.frag Fixed Function Equivalent Fragment Shader *
*   Automatically Generated by 3Dlabs GLSL ShaderGen   *
*             http://developer.3dlabs.com              *
*******************************************************/

void main (void)
{
    vec4 color;

    color = gl_Color;

    gl_FragColor = color;
}




Mais bon, ce code de spot light n'est pas par pixel, alors je posterai très bientot un Code Sample sur le sujet.

[John Difool]

Désolé de ne pas t'avoir repondu plus tôt, mais je n'ais pas encors internet,
Merci dre prendre le temps de me répondre c'est vraiment sympa!!! je vais voir à tout ca, cependant, il faut que je me penche sur les shader et je suis loin d'avoir le nivaux pour coder moi même celui là, pour l'instant je suis au stade bidouille.
Mais, j'y travail!

Pour ma derniere question, en fait, je n'arrive pas à donner des coordonnées de texture à mes models ou mesh de manieres à les texturer sans défaut.
Par exemple, si je veux texturer un cylindre, il reste une bande mal recouverte. Et, dans mon cas je veux texturer des arbre modelisés prealablement sous 3ds, qui son donc bien plus complexe qu'un cylindre.
Comment faire pour résoudre se probléme?

Par ailleurs, ma lumiere que je dirige est en fait un omni, avec lequel, j'aimerai lui atribuer une distance déclérage faible, et même avec un bump mapping simple le probleme se pose.
Si je diminue la distance d'éclairage de l'omni cela retire de l'intencité à mon éclairage mais pas sa distance.
Pour exemple, tout mes cylindre simulant des arbres, sont éclairés de maniere omogéne même celui positionné le plus loin de la distance d'affichage.

Voila mon reel problème!!!

En attendant, je vais me pencher d'avantage sur le codage des shader ( Si j'arrive à comprendre...)

Merci encors pour tes réponces!
J'esserais de t'envoyer les premieres image de ma démo bientôt, ce sera plus explicite !!!

[JeGX]

Tu utilises quel soft de modélisation?

Le coup de la bande mal recouverte est du au fait qu'il manque des vertices
(des vertices en double) afin d'assurer le rebouclage des coordonnées de textures.

Avec 3DStudio MAX par exemple, si tu fais une simple sphère texturée et que tu l'exporte en *.3ds, il resultat est impeccable. La même sphère exportée en *.ase va générer cette bande où la texture se repète un grand nombre de fois dans un tout petit interval.

Pour ton probléme d'eclairage, regarde le code sample 69. Une lumière atténuée y est utilisée.

Pour les shaders, n'oublie pas de regarder les tutors dispos sur le site (surtout celui pour débuter: GLSL Intro )
et commence par faire des projets tous simples...

Essai de créer un nouveau topic pour les images de ta demo sinon celui ci  va devenir incompréhensible  

[John Difool]

Salut!!!

J'utilise 3ds max 5, et en effet j'exportais mes models en .ase, donc je vais essayer avec le format 3DS.

Pour le reste, je vais recommencer depuit le début et plus simplement .

Merci encors, à plus!!!

[JeGX]

Just comme ça au passage, le tutor sur le spot en GLSL est dispo.
Voir ici: http://www.ozone3d.net/phpBB2/viewtopic.php?t=71