Lois de diffusion de la lumière

Signaler
Messages postés
33
Date d'inscription
jeudi 2 septembre 2004
Statut
Membre
Dernière intervention
27 septembre 2004
-
Messages postés
101
Date d'inscription
samedi 9 février 2002
Statut
Membre
Dernière intervention
5 mai 2009
-
Les lois proposées par OpenGl ne sont pas satisfaisantes dans le cas de mon études :

Quelqu'un aurait-il une idée pour soit :

coder la loi en question (minnaert, objets célestes)
mais comment l'insérer sans aucune prise en charge d'OpenGL
(qu'il n'ajoute pas d'ombres à celles qu'il mettrait automatiquement)

modifier le source des lois d'OpenGL
où trouver ce source ?

Merci,

3 réponses

Messages postés
101
Date d'inscription
samedi 9 février 2002
Statut
Membre
Dernière intervention
5 mai 2009

Ecrit un shader opengl.

C'est un programme que tu charges dans la memoire de la carte graphique.

Il y a deux types de shaders :

Les vertex shaders qui sont applelés pour chaque glVertex*(...) que tu envoi à openGL.

Pour chaque vertex

input :

* coordonnées 3d des sommets
* couleur en chaque sommet
* normale
* coordonnées de texture,
* lights (position, vecteur direction, ...)

output :

* coordonnées 2d des sommets sur l'ecran.
* couleurs en chaque sommet
* coordonnées de texture

fonction :

* projeter les point 3D des triangles à l'écran (2D) via les matrices MODEL_VIEW et PROJECTION

* calculer l'éclairage (en fonctions des lights, des couleurs de sommets et de la normale à la facette)

Les pixels shader sont appelés lors du remplissage des pixels à l'écran (les pixels qui composent un triangle). Il te permettet le choisir la couleur du pixel à l'ecran.

Pour chaque pixel :

input :

* couleurs (idem)
* coordonnées de texture (interpolées linéairement dans le triangle)

output :

* couleur du pixel

fonction :

* calculer la couleur finale du pixel (mix entre la couleur et les textures)

La, je vient de te decrire le fonctionnement normal. Apres ca, tu peux choisir ce que tu veux faire comme calculs dès l'instant que tu respectes inputs et ouputs.

Pour ce qui est du language de programmation, tu as soit l'assembleur ARB ou le Cg. Si tu connais pas trop les languages d'assemblage, utilises plutot Cg qui utilise une syntaxe proche du C.

http://oss.sgi.com/projects/ogl-sample/registry/ARB/fragment_program.txt
http://developer.nvidia.com/page/cg_main.html

tib
Messages postés
33
Date d'inscription
jeudi 2 septembre 2004
Statut
Membre
Dernière intervention
27 septembre 2004

dans "fragment_program.txt"
qu'entendent-ils par fog ? field of ... ?

ça me parait complexe...
tu n'aurais pas un prototype de shader plus explicite ?

Ce qui me permettrait peut etre de voir ce qu'il faut
respecter par input et output

Merci
Messages postés
101
Date d'inscription
samedi 9 février 2002
Statut
Membre
Dernière intervention
5 mai 2009

Utilises pluot Cg qui te compile de l'assembleur ARB. La syntaxe est plus facile à comprendre.

http://developer.nvidia.com/page/cg_main.html

je te copies un vertex program Cg type (copier coller du manuel) :

//inputs du shader
struct appin{
float4 Position : POSITION; //position du sommet
float4 Normal : NORMAL; //normal au sommet
};

//outputs
struct vertout{
float4 HPosition : POSITION; //position du sommet projeté
float4 Color : COLOR; //couleur du sommet
};

vertout main(appin IN,
uniform float4x4 ModelViewProj,
uniform float4x4 ModelViewIT,
uniform float4 LightVec)
{
vertout OUT;
// Transform vertex position into homogenous clip-space.
OUT.HPosition = mul(ModelViewProj, IN.Position);

// Transform normal from model-space to view-space.
float3 normalVec = normalize(mul(ModelViewIT,IN.Normal).xyz);

// Store normalized light vector.
float3 lightVec = normalize(LightVec.xyz);

// Calculate half angle vector.
float3 eyeVec = float3(0.0, 0.0, 1.0);
float3 halfVec = normalize(lightVec + eyeVec);

// Calculate diffuse component.
float diffuse = dot(normalVec, lightVec);

// Calculate specular component.
float specular = dot(normalVec, halfVec);

// Use the lit function to compute lighting vector from
// diffuse and specular values.
float4 lighting = lit(diffuse, specular, 32);

// Blue diffuse material
float3 diffuseMaterial = float3(0.0, 0.0, 1.0);

// White specular material
float3 specularMaterial = float3(1.0, 1.0, 1.0);

// Combine diffuse and specular contributions and
// output final vertex color.
OUT.Color.rgb = lighting.y * diffuseMaterial +
lighting.z * specularMaterial;
OUT.Color.a = 1.0;
return;
}