Discussion :

[cyber_N]

HELLO LE MONDE!!

Cela fait maintenant 3 bons jours que je recherche une explication claire sur le BUMP MAPPING.

J'ai trouvé quelques programmes qui montre l'effet du bump mapping (certains sont vraiment incroyables et vraiment bluffants !!)

Mais ils sont trop complexes:
- y a des fichiers bourrés de code en pagaille, qui, à mon goût, ne servent à rien pour expliquer uniquement (QUE) le bump mapping.
- soit il montrent l'effet du bump mapping dans un véritable monde 3D et non pas sur un objet SIMPLE, comme une plaque d'épaisseur nulle, ce qui impose des fichiers supplémentaires qui contiennent les infos de ce monde 3D à charger et du code "à ralonge" dans le fichier principale....

En voyant certaines descriptions et codes qui seraient quasiment à ma portée, j'aurais trop de questions à poser sur le moment (je pense notamment au bon tutorial de Paul sur OpenGL.org intitullé "Simple Bump Mapping")

Pourriez - vous m'aiguiller sur des tutoriaux concrêts (et non pas simplement qu'une explication sous forme de dessins ou de textes) qui mettent en valeur SIMPLEMENT LE bump mapping.

Merci encore.
Séb.

[Bourriko]

EDIT : Désolé, je n'avais pas lu ton post en entier.

Bonjour,

J'ai aussi eu du mal avec le bumpmapping car à partir de là, il faut vraiment
avoir des notions de maths et comprendre les différentes matrices d'openGL.

J'ai appris à partir de ce tutorial :
http://www.paulsprojects.net/tutorials/tutorials.html

Et pour passer à des formes arbitraires, je me suis servi de ce code pour calculer la bonne matrice :
http://www.terathon.com/code/tangent.html
Le code était tellement bon que j'ai acheté le bouquin dont il est tiré.

[shenron666]

Le Dot3 Bump

sur nehe tu as un article à ce sujet : http://nehe.gamedev.net/data/articles/article.asp?article=20
le Dot3 bump mapping est expliqué et il y a un code source en bas qui montre l'effet sur un quad

http://www.codesampler.com/oglsrc.htm

Page 4 tu as le "Dot3 Per-Pixel Bump Mapping" (nécessite des extensions récentes)
Page 9 tu as le "Emboss Bump Mapping" (moins bien mais nécessite juste l'extension multitexture"

note : la démo nehe tourne sur un chipset intel intégré i865G, et je crois que les autres également

[cyber_N]

HELLO LE MONDE!! 8)

Merci à vous 2 de m'aider sur un sujet aussi coriace que le bump mapping


Bourriko : (joli nom! )
Je suis donc pas le seul à galérer (c'est le mot !!) sur le bumpmap.
Au sujet du bout de programme (que tu aimes tant) lien : http://www.terathon.com/code/tangent.html
SI J'AI BIEN COMPRIS:
celui calcule les tangentes S et T de chaque quads de la forme 3D "arbitraire" passée à la fonction et les triangles des quads ??

Shenron666 :
Cool !! Enfin un programme qui montre le vrai bumpmapping sur une forme plus simple !!
Il m'a semblé remarquer que ce type de bumpmapping ( Dot 3 ) n'est pas spéculaire GRRRR ?? (il est juste diffus, tu comfirmes ??)

PS: A mes débuts sur OpenGL, il y a de cela 6 jours, , je suivait les tutos de NeHe mais je trouvait que le résultat de son bump mapping été trop .... pas visible (il fallait avoir les yeux bien ouvert pour voir un semblant de relief)
Tandis que celui que tu me montres et les tutos de Paul ont un effet .... immédiat !!

Connais tu encore un autre site traitant du BUMPMAPPING?
en tout cas merci pour cette indication

[shenron666]

Il m'a semblé remarquer que ce type de bumpmapping ( Dot 3 ) n'est pas spéculaire GRRRR ?? (il est juste diffus, tu comfirmes ??)

les exemples et démos montrent juste un bump diffus c'est vrai, je confirme
par contre, pour un bump spéculaire, je ne sais pas si les techniques employées peuvent êtres utilisées

pour une demo de bump mapping spéculaire tu peux toujours regarder ici :
http://www.ati.com/developer/sdk/RadeonSDK/Html/Samples/OpenGL/RadeonCombine3SpecMap.html

si je trouve d'autres liens je te fait signe

[cyber_N]

HELLO (RE).

Merci encore pour les liens éventuelles que tu pourrais apporter. (Je prend note)
< Les tuto sur le BMapping, ca manque cruellement sur le net. Pourtant c'est un effet essentiel et basique des jeux nouveaux et à venir (je pense à Doom3(ttes surfaces), HL2(pour l'eau), UT2007(surtout les personnages), ....).... mais je reconnais, c'est dur!! MAIS J'Y ARRIVERAIS !! GRRRR >
....

Je souhaiterais [ te ou vous ] poser 2 questions primordiales:
- à un moment donné du BumpMapping, il est question de prendre se qu'ils
appellent la matrice inverse; j'ai eu 2 explications la dessus mais
impossible de tout comprendre (passer de l'espace Objet à l'espace
Tangent) (-> il me faudrait des images (représentation) pour comprendre)

- je comprend pas pourquoi il existe un "cube map" en plus des 2 autres
textures (celle normale + la texture de relief). En voyant comment est
composé la texture de relief, on image....mais j'ai pas tout compris.
(c'est en fait les equivalents des coordonnées x,y,z avec z face à nous,
c'est pour cela que la texture est bleu ( bleu = z )).
Y a une histoire de vecteurs (dont le vecteur lumière) dont on
transforme leurs coordonnées x,y,z en R,G,B....

C'est tout ce que je sait....

Pouvez-[vous / tu] répondre à ces questions ou avez-[vous / tu] des liens qui l'expliquent bien et qui s'approfondissent la-dessus....

Merci-encore.
Séb.

[bafman]

pour realiser du dot 3 bump mapping il te faut :

- un vecteur qui represente la normale de la surface, c'est la fameuse normal map
- un vecteur qui va du fragment (le pixel avant les operation de blending et autre...) a la lumiere, c'est a ca que sert la cube map (bien qu'on puisse s'en passer avec un fragment program)

avec ca, il faut aussi l'espace local de chaque vertex (les normal/binormal/tangeante) qui permettent de transformer la position de la lumiere. en effet ta normal map (qu'on appelle aussi local map pour cette raison) a été concu sur un plan donné (generalement XY) hors tes polygones ne seront pour la plus part pas sur ce même plan, il faut donc projeter la position de la lumiere dans l'espace local du vertex (d'ou local map )pour qu'elle ait la bonne position relativement à la normal map

[cyber_N]

Bonjour (RE²)

En étudiant un prgm : http://www.codesampler.com/oglsrc.htm , j'assimile presque tout le programme, mais, 2 points sont encore obscures car c'est pas assez imagée :
- ce cube map plus que pénible (je suis sûr que c'est simple en plus....) qui est en faite un dégradé de rouge , de vert, de bleu qui doit être modulé et combiné avec les autres textures pour je ne sais quelle raison.... (je fait quand même un "semblant de lien" avec la normal map)

- ET SUROUT, LE FIN DU FIN : cette inversion de matrice (transformer de l'Espace Tangent à l'Espace Object) que je n'est jamais compris. Je veux dire par là : je vois pas pourquoi et comment une inversion (1 / x) va faire passer de l'Espace T à l'Espace O ??

bafman à écrit:

- un vecteur qui represente la normale de la surface, c'est la fameuse normal map.

-> Pas que la normale (couleur bleu = Z); il y a aussi les autres couleurs X, Y....

un vecteur qui va du fragment (le pixel avant les operations de blending et autres...) à la lumiere, c'est à ca que sert la cube map (bien qu'on puisse s'en passer avec un fragment program)

-> c'est quoi un fragment ??
En plus, on peux pas accéder à chaque pixels de chaque polygone de la forme 3D. C'est OpenGL qui se charge que récupérer et combiner les pixels....

Merci encore.
Séb.

[Metrix]

RE:

Je dis peut-etre une connerie mais apparement y'a 2 tutaux different pour le bump sur la meme page:

http://www.codesampler.com/oglsrc/oglsrc_4.htm#ogl_dot3_bump_mapping
http://www.codesampler.com/oglsrc/oglsrc_7.htm#ogl_emboss_bump_mapping
Le FPS est vraiment bah chez moi pour le 2eme...

Aprés je les ai pas regardé en detail donc je ne sais aps si les 2 sont des "specular bump" mais le 2eme me parait plus simple...j'ai pas dis facile mais plus simple

Apres personnelement pour le taff j'utilise le "Normal Mapping" donc je peux expliquer vite fait comment les creer et comment elle sont construites:

Voici le volume que l'on souhaite creer:


La Normal Map que l'on doit obtenir:


Pour générer cette Normal Map il faut 3 images, la difference entre les 3 image sera l'orientation de l'éclairage du volumes soit X,Y,Z

1)Lumiere située a droite donc sur X pour lequel on va associer la couleur rouge pour le mixage, on la nomme la Xnormal


2)Lumiere située en haut donc sur Y pour lequel on va associer la couleur verte pour le mixage, on la nomme la Ynormal


3)Lumiere située au vers nous et eclaire le centre de l'image donc sur Z pour lequel on va associer la couleur bleu pour le mixage, on la nomme la Znormal

Pour la Znormal plus les faces seront verticales plus elle seront foncé et inversement plus elle seront horizontal plus elle seront clair. Pour ceux qui utilise 3dsmax c'est l'équivalent de la texture Falloff, Sous maya c'est un peux plus compliquer mais fesable.
Ensuite il suffit just de mixer ces 3 images avec les couleur respective et on a une Normale Map RGB

Pour finir vous avez peut-etre remarqué qu'il y a une habitude d'association des couleurs avec les axes:
X:Rouge, Y: Vert, Z: Bleu
Pourkoi ca bah enfaite pour définir des coordonés d'un point on le fais en XYZ pour une couleur en RGB donc on les associes dans l'ordre, d'ailleur ca peut aider de se souvenir de ca pour le "glColor":
X:Rouge(1,0,0) | Y:Vert(0,1,0) | Z: Bleu(0,0,1)

Voila désolé d'etre partie en peu en live mais si ca peut en aider certain aussi bien pour la normal map que pour la convention de couleur.
Sinon dites le moi si c'est inutile ca fera gagner du temps a tout le monde.

[cyber_N]

Merci Métrix pour l'explication de la normal MAP!
En images, on y voit plus clair....

Mais pourquoi, EN PLUS de cette "normal map", faut-il construire un cube map dont la couleur sera combinée à la normal map ??

[Metrix]

Euh le cube map ca peut servir a 2 choses mais enfaite ca a la meme fonction si on reflechi bien.

1)Ca sert a creer un environement de reflection la totalisté de la scene sera dans un cube geant avec les normal inversées.
Pour le texturer on aurra besoin d'un cube map (en forme de croix de Jesus lol)
Exemple
Ce qui donne un environnement exterieur cubic qu'on ne verra plus si on se place dedans
Ce n'est pas celui utilisé dans le tuto


2) Il sert de projection mais non environementale car la map utilisé ne sera plus une croix mais simplement une image normale 256*256 pixel par exemple.Il en existe plusieurs assez utile et enfaite ca evite de definit les UV de chaque vertex.
Projection cubique (cube mapping)
Projection en Plan (Flat mapping)
Projection cylindrique (Tube mapping)
Projection sphérique (Sphere mapping)


Donc je pensse que le cube map est utilisé pour la projection des textures apres pour pouvoir associer le bump et le diffuse on est obligé d'utiliser un espece de blend shape et le mix des 2 ser projecté par cube mapping.

Enfin dans le domaine de l'infographie c'est cette definition de cube map qu'on utilise j'espere que c'est la meme en OpenGL

D'ailleur j'ai trouvé un autre tutaux si ca peut t'aider:
http://www.zanir.szm.sk/20-29.html

[cyber_N]

Et l'inversion de matrices alors ??
Pourquoi cette inversion fait passer de l'espace de tangentes à l'espace objet_??
(note: je sais ce qu'est une inversion de matrice
de manière mathématiques: calcul du déterminant, différences, ....)

Avec des "images"(txt et images), je crois que je comprendrais....

Merci.
Séb.

[Metrix]

Alors enfaite de se que j'ai compris c'est une histoire de coordonnées local et world pour le vecteur lumiere:
Je vais essayer de traduire a peu pres le truc mais bon vu mon niveau d'anglais je sais pas si ca pourra t'aider:

Cet échantillon démontre comment créer la tangente, la binormal et des vecteurs normaux, pour chaque vertex de notre scéne d'essai (un cube). Ces vecteurs sont utilisés pendant le rendu pour définir une matrice de tangente inverse pour chaque vertex. Ceci doit être fait parce qu'une map-normal stock ses normales dans l'espace de tangente. Donc, nous avons besoin d'une matrice de tangente inverse donc nous pouvons transformer le vecteur lumiere de notre scène de "l'espace d'objet" dans "l'espace de tangente". Une fois transformé, nous codons alors ce nouveau vecteur lumiére comme une couleur de RGB et le passons dans le blend(mélangeur) pour donner finalement la couleur Diffuse du vertex

A se que je me rappel des vieux cours de maths c'est:

vB = vT^vN
vB: vecteur binormal
vT: vecteur tangent
vN: vecteur normal

Et normalement enfaite vB vT et vN donne un repere orthonormé local (trièdre de Frenet) au vertex.
Apparement pour retrouvé vB on peut aussi avoir un methode plus concrete:


Mais je suis pas sur a 100% de se truc la car si on prend l'exemple suivant ca marche pas:
vT(0,0,1)
vN(0,1,0)
donc pour que ca soir othonormé normalement vB(1,0,0)
Mais si on calcul ca donne vB(1,0,1)
Enfin si un vrai matheux peux confirmer...car bon mon niveau de maths est pas super

Sinon pour la matrice inverse c'est peut-etre pour renversé les coordonné local mais la ???

J'espere que tu vas y arriver car c'est en effet compliqué.

[Antickriszt]

non, vB = (-1, 0, 0), d'après la formule que t'as donné...

mais je ne peux rien expliquer de plus car je n'ai pas eu le temps de tout suivre...

[cyber_N]

Je comprends tout à fait ce que tu veux dire, ....
sauf la fin de ton explication :
la tangente correspond toujours à X, donc : T(t, 0, 0);
la Binormal correspond toujours à Y, donc : B(0, b, 0);
la Normal correspond toujours à Z, donc : Z(0, z, 0);

Et pour le repère :
ATTENTION -> DirectX comme OpenGL sont nativement "main-gauche" !!
(Ce qui est contraire aux lois des mathématiques).
C'est une source fréquente d'erreurs.

Donc on a un repère comme celui-ci :
Les X+ vers la droite, les Y+ vers le haut et les Z+ vers le fond écran.

Y+ Z+
^ ^
| /
| /
*____> X+

Ok pour les explications sur la matrice inverse !!
Je viens de les mettre en confrontation avec le programme de bump-mapping dont dont tu as traduit les premières lignes (sans doute à l'aide d'un traducteur comme celui de BabelFish) mais je te remercie vivement - je l'ai fais moi aussi )

C'est celui-ci, le prog. le plus simple pour apprendre le bump-mapping:

(Et je le conseille vivement à ceux qui veulent apprendre cette technique)

Name: ogl_dot3_bump_mapping.cpp
Author: Kevin Harris (kevin@codesampler.com)

En ce moment je tente d'en faire une classe CBumpMapping et de réécrire à la ma sauce les headers (.h) des fichiers vector3f.h, matrix4x4f.h

Merci vivement pour vos explications et le temps passé à écrire tout ça!!
Si j'ai rien d'autres à vous poser, je crois que je vais mettre le post en état : :résolu: .... à voir....

[Metrix]

Bah j'espere que tu vas y arriver car tu as vraiment essayé!

sinon j'ai refais le calcul et je me suis gourré ca donne bien:
vB(1, 0, 0)
pour vB (-1,0,0) il aurais fallut que vT (0,-1,0)

sinon la traduc c du moi mais bon j'aurais peut-etre du utiliser un traducteur...

Sinon tu as essayé les autre methodes que le dot3?

[Antickriszt]

comment tu calculs un produit vectoriel toi ?

[bafman]

pour en revenire a l'utilisation de la cube map:

pour ton bump tu a besoin d'un vecteur normal et d'un vecteur vers la source de lumiere. ensuit la carte realise un produit scalaire entre ces 2 vecteurs, ce qui donne le dot3.

le vecteur normal au plan vient de la normal map... logique...
par contre tu n'a rien pour te donner le vecteur vers la lumiere... c'est a ca que sert la cube map. En fait elle represente une sorte de normal map dont tout les vecteur pointent vers le centre, ainsi si tu place la cube map a l'emplacement de la lumiere comme ceci

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
glMatrixMode(GL_TEXTURE);
glPushMatrix();
glTranslate(posLightX,posLightY,posLightZ);
glMatrixMode(GL_MODELVIEW);

tu aura sur tes polygones la projection de la cube map avec des normales dirigée vers la source lumineuse...

[cyber_N]

Salut tous le monde.

par contre tu n'a rien pour te donner le vecteur vers la lumiere... c'est a ca que sert la cube map

Quand on crée une source lumineuse dans OpenGL, on indique bien un vecteur où la source va pointer?
Il suffit de réutiliser ce vecteur et de trouver l'angle que celui-ci réalise avec la normale ne tous nos vertices?

Qu'en pensez-vous ??

[shenron666]

Sauf que la normale des vertices comme tu le dis toi même est ... par vertices, et le bump mapping doit se faire par pixels, d'où la nécessité d'une texture qui va permettre de trouver la relation entre les normales des pixels (la normal map) et la lumière