Calcul des normales :?

[comtois]

J'obtiens ça avec la première méthode



Et ça avec la deuxième ( en reprenant plus ou moins bien un exemple de darkbasic)


Dans les deux cas , le résultat n'est pas satisfaisant

Si quelqu'un sait comment faire ? ou a des idées pour améliorer la chose je suis preneur

Je mettrai le source pour obtenir ces trucs étranges demain .
Je vais essayer de le mettre un peu plus en ordre , pour l'instant c'est une compile de différents codes

[cederavic]

jete un coup d'oeil ici : http://membres.lycos.fr/heulin/3D/chap6.html

[comtois]

J'ai bien peur que ça ne soit pas suffisant , c'est la première méthode que j'ai employée qui est décrite sur ce site .

Enfin ,seulement pour le calcul de la normale , pour le calcul des lumières ,c'est Ogre qui le fait .

Bon je vais vérifier tout ça demain ,merci


PS: En fait pour moi c'est pas très clair , car si je comprends bien , avec setmeshdata , il faut une normale par point , alors que dans l'exemple de ce site ( et sur d'autres sites) le calcul de la normale se fait pour une surface ( un triangle ) . On devrait donc avoir autant de normales que de triangles ,or dans l'exemple de danilo ou dans d'autres , il y a autant de normales que de points . Et c'est là que je bloque , que faut-il renseigner dans setmeshdata ?

comment sont appliquées les datas que l'on fournit dans le calcul de la lumière ?

[comtois]

Bon finalement , je n'ai pas encore changé la procédure qui calcule les normales ( c'est à faire parce que je ne calcule pas tous les points )

Mais en augmentant la taille de la matrice ,j'obtiens un résultat satisfaisant .Du moins qui s'approche de ce que j'espérais.
Par contre si je mets une taille importante ,par exemple Matrix\largeur=5000 et Matrix\Profondeur=5000 , on voit bien la tache que fait la lumière, et c'est pas beau

Pour tester , vous aurez besoin d'une image , ou alors il faut mettre en commentaire le chargement de l'image dans la section "Texture" et décommenter la création de la texture qui précède.

C'est pas clair ? tant pis

Voici l'image que j'utilise pour les tests



Et ça donne ça



Bon c'est vraiment pas terrible ,parce que si je m'amuse à changer les valeurs de decaleX et decaleZ , j'obtiens n'importe quoi

si quelqu'un sait comment faire ?

Code : Tout sélectionner

;-Constantes
#ScreenWidth = 1024 
#ScreenHeight = 768 
#ScreenDepth = 32 

;-Structures
Structure Vecteur
  x.f
  y.f
  Z.f
EndStructure
Structure Matrix
  Largeur.f
  Profondeur.f
  NbFacetteX.l      ;>0 et <256 si FaceCachee=#False , ou <128 si FaceCachee=#True 
  NbFacetteZ.l      ;( j'ai pas encore vérifié si ça passe => à calculer)
  FaceCachee.l      ; si =True on double les triangles pour voir l'entité des deux côtés
  PointIDMemory.l
  TriangleIDMemory.l
  TextureIDMemory.l
  NormaleIDMemory.l
EndStructure

;-Variables 
Global Matrix.Matrix 
Global CamLocateX.f, CamLocateY.f, CamLocateZ.f,CamLocateX.f,CamLocateY.f,CamLocateZ.f
Global Mode.b ,AngleVague.f,Vitesse.f

Procedure HauteurPoint(x.l, Z.l, Hauteur.f)
  If x > -1 And x <= Matrix\NbFacetteX And Z > -1 And Z <= Matrix\NbFacetteZ 
    Adresse = Matrix\PointIDMemory + 4
    Adresse = Adresse + (x + (Z * (Matrix\NbFacetteX + 1))) * 12 
    PokeF(Adresse, Hauteur)
    SetMeshData(0, 0, Matrix\PointIDMemory, (Matrix\NbFacetteX + 1) * (Matrix\NbFacetteZ + 1))
    ProcedureReturn #True
  Else
    ProcedureReturn #False
  EndIf  
EndProcedure
Procedure HauteurFacette(x.l, Z.l, Hauteur.f)
  If x > 0 And x <= Matrix\NbFacetteX And Z > 0 And Z <= Matrix\NbFacetteZ
    Adresse = Matrix\PointIDMemory + 4
    Adresse + (x + (Z * (Matrix\NbFacetteX + 1))) * 12 
    PokeF(Adresse, Hauteur)
    Adresse - 12
    PokeF(Adresse, Hauteur)
    Adresse  - (Matrix\NbFacetteX + 1) * 12
    PokeF(Adresse, Hauteur)
    Adresse + 12
    PokeF(Adresse, Hauteur)
    SetMeshData(0, 0, Matrix\PointIDMemory, (Matrix\NbFacetteX + 1) * (Matrix\NbFacetteZ + 1))
    ProcedureReturn #True
  Else
    ProcedureReturn #False
  EndIf  
EndProcedure
Procedure Matrice() 
  TailleFacetteX.f = Matrix\Largeur / Matrix\NbFacetteX 
  TailleFacetteZ.f = Matrix\Profondeur / Matrix\NbFacetteZ 
  
  ;/Points
  Adresse = Matrix\PointIDMemory 
  For b = 0 To Matrix\NbFacetteZ 
    For a = 0 To Matrix\NbFacetteX 
      PokeF(Adresse, (a - Matrix\NbFacetteX / 2) * TailleFacetteX) 
      PokeF(Adresse + 4, 0) 
      PokeF(Adresse + 8, (b - Matrix\NbFacetteZ / 2) * TailleFacetteZ) 
      Adresse + 12 
    Next 
  Next
  
  ;/Triangles
  If Matrix\FaceCachee
    Nbtriangle.l = 4
  Else
    Nbtriangle = 2
  EndIf  
  Index = 6 * Nbtriangle
  Adresse = Matrix\TriangleIDMemory 
  
  NbPointX = Matrix\NbFacetteX + 1 
  For b = 0 To Matrix\NbFacetteZ - 1 
    For a = 0 To Matrix\NbFacetteX - 1 
      P1 = a + (b * NbPointX) 
      P2 = P1 + 1 
      P3 = a + (b + 1) * NbPointX 
      P4 = P3 + 1 
      PokeW(Adresse, P3) 
      PokeW(Adresse + 2, P2) 
      PokeW(Adresse + 4, P1) 
      PokeW(Adresse + 6, P2) 
      PokeW(Adresse + 8, P3) 
      PokeW(Adresse + 10, P4) 
      
      If Matrix\FaceCachee
        PokeW(Adresse + 12, P1) 
        PokeW(Adresse + 14, P2) 
        PokeW(Adresse + 16, P3) 
        PokeW(Adresse + 18, P4) 
        PokeW(Adresse + 20, P3) 
        PokeW(Adresse + 22, P2) 
      EndIf 
      Adresse + Index 
    Next 
  Next 
  
  ;/Texture
  Adresse = Matrix\TextureIDMemory 
  For b = 0 To Matrix\NbFacetteZ 
    For a = 0 To Matrix\NbFacetteX 
      PokeF(Adresse, a / Matrix\NbFacetteX) 
      PokeF(Adresse + 4, b / Matrix\NbFacetteZ) 
      Adresse + 8 
    Next 
  Next 
  
EndProcedure 
Procedure NormalesMatrice()
  Vecteur1.Vecteur
  Vecteur2.Vecteur
  Pos1.Vecteur
  Pos2.Vecteur
  Pos3.Vecteur
  
  Normale.Vecteur
 
  Address = Matrix\PointIDMemory + 4
  AdrNormale = Matrix\NormaleIDMemory 
  
  TailleFacetteX.f = Matrix\Largeur / Matrix\NbFacetteX 
  TailleFacetteZ.f = Matrix\Profondeur / Matrix\NbFacetteZ 
  
  For Z = 1 To Matrix\NbFacetteZ
    For x = 1 To Matrix\NbFacetteX
      Pos1\x = x
      Pos1\y = PeekF(Address + (x+(Z*(Matrix\NbFacetteX+1)))*12) 
      Pos1\Z = Z
      
      Pos2\x = x
      Pos2\y = PeekF(Address + (x+((Z-1)*(Matrix\NbFacetteX+1)))*12)
      Pos2\Z = Z - 1
      
      Pos3\x = x - 1
      Pos3\y = PeekF(Address + (x - 1 + (Z * (Matrix\NbFacetteX + 1))) * 12)
      Pos3\Z = Z
      
      Vecteur1\x = (Pos1\x - Pos2\x)*TailleFacetteX
      Vecteur1\y = (Pos1\y - Pos2\y)
      Vecteur1\Z = (Pos1\Z - Pos2\Z)*TailleFacetteZ

      Vecteur2\x = (Pos1\x - Pos3\x)*TailleFacetteX
      Vecteur2\y = (Pos1\y - Pos3\y)
      Vecteur2\Z = (Pos1\Z - Pos3\Z)*TailleFacetteZ
   
      Normale\x = ((Vecteur1\y * Vecteur2\Z) - (Vecteur1\Z * Vecteur2\y))
      Normale\y = ((Vecteur1\Z * Vecteur2\x) - (Vecteur1\x * Vecteur2\Z))
      Normale\Z = ((Vecteur1\x * Vecteur2\y) - (Vecteur1\y * Vecteur2\x))
  
      Magnitude.f = Sqr(Normale\x*Normale\x + Normale\y*Normale\y + Normale\Z*Normale\Z)
      Normale\x / Magnitude
      Normale\y / Magnitude
      Normale\Z / Magnitude
      PokeF(AdrNormale    , Normale\x)
      PokeF(AdrNormale + 4, Normale\y)
      PokeF(AdrNormale + 8, Normale\Z)
      AdrNormale + 12 
      
    Next x
  Next Z   
  SetMeshData(0, 3, Matrix\NormaleIDMemory , (Matrix\NbFacetteX + 1) * (Matrix\NbFacetteZ + 1)) 
EndProcedure
Procedure.f Wrapvalue(Angle.f) 
  Angle / 360 
  Angle - Int(Angle) 
  If Angle < 0 
    ProcedureReturn (Angle + 1) * 360 
  Else 
    ProcedureReturn Angle * 360 
  EndIf 
EndProcedure
Procedure.f Sind( Angle.f ) 
  ;calcule le sin d'un angle en degré 
  a.f = Angle  * 0.0174533 
  ProcedureReturn Sin( a ) 
EndProcedure 
Procedure vagues() 
  Adresse = Matrix\PointIDMemory + 4 
  decaleX = 15
  decaleZ = 17
  Hauteur = 17
  For Z = 0 To Matrix\NbFacetteZ
    For x = 0 To Matrix\NbFacetteX
      Sommet.f = Sind(AngleVague + (x * decaleX) + (Z * decaleZ)) * Hauteur 
      PokeF(Adresse, Sommet) 
      Adresse + 12 
    Next x 
  Next Z 
  SetMeshData(0, 0, Matrix\PointIDMemory, (Matrix\NbFacetteX + 1) * (Matrix\NbFacetteZ + 1)) 
EndProcedure 
Procedure GestionTouches() 
  If KeyboardReleased(#PB_Key_F1) 
    Mode = #PB_Camera_Wireframe - Mode 
    CameraRenderMode(0, Mode) 
  EndIf 

  CamLocateX - 2 * KeyboardPushed(#PB_Key_Left) / 128 
  CamLocateX + 2 * KeyboardPushed(#PB_Key_Right) / 128 
  CamLocateY + 2 * KeyboardPushed(#PB_Key_PageUp) / 128 
  CamLocateY - 2 * KeyboardPushed(#PB_Key_PageDown) / 128 
  CamLocateZ - 2 * KeyboardPushed(#PB_Key_Up) / 128 
  CamLocateZ + 2 * KeyboardPushed(#PB_Key_Down) / 128 
  
  ;SnapShot 
  If KeyboardReleased(#PB_Key_F12)
    hBitmap = CreateImage(0, #ScreenWidth, #ScreenHeight)
    hdc = StartDrawing(ImageOutput())
    SelectObject_(hdc, hBitmap)
    BitBlt_(hdc, 0, 0, #ScreenWidth, #ScreenHeight, GetDC_(GetDesktopWindow_()), 0, 0, #SRCCOPY)
    StopDrawing()
    DeleteDC_(hdc)
    SetClipboardData(#PB_ClipboardImage, ImageID()) 
  EndIf
EndProcedure 
Procedure AfficheAide()
  StartDrawing(ScreenOutput())
    DrawingMode(1)
    FrontColor(255,255,255)
    Locate(10,10)
    DrawText("CamLocateX = " + StrF(CamLocateX))
    Locate(10,30)
    DrawText("CamLocateY = " + StrF(CamLocateY))
    Locate(10,50)
    DrawText("CamLocateZ = " + StrF(CamLocateZ))
  StopDrawing()
EndProcedure
; 
;- Main starts here 
; 
If InitEngine3D() And InitSprite() And InitKeyboard() And OpenScreen(#ScreenWidth, #ScreenHeight, #ScreenDepth, "FRW Matrix") 
  ;/Divers
  Vitesse=3.0
  
  ;/Paramètres de la matrice
  Matrix\Largeur    = 1000
  Matrix\Profondeur = 1000
  Matrix\NbFacetteX = 50
  Matrix\NbFacetteZ = 50
  Matrix\FaceCachee = #True
  Matrix\PointIDMemory    = AllocateMemory(12 * (Matrix\NbFacetteX + 1) * (Matrix\NbFacetteZ + 1)) 
  Matrix\TriangleIDMemory = AllocateMemory(12 * Matrix\NbFacetteX * Matrix\NbFacetteZ * 4) 
  Matrix\TextureIDMemory  = AllocateMemory(12 * (Matrix\NbFacetteX + 1) * (Matrix\NbFacetteZ + 1)) 
  Matrix\NormaleIDMemory  = AllocateMemory(12 * (Matrix\NbFacetteX + 1) * (Matrix\NbFacetteZ + 1))
  Matrice()
  
  ;/Mesh 
  CreateMesh(0) 
  SetMeshData(0, 0, Matrix\PointIDMemory   , (Matrix\NbFacetteX + 1) * (Matrix\NbFacetteZ + 1)) 
  SetMeshData(0, 1, Matrix\TriangleIDMemory, (Matrix\NbFacetteX) * (Matrix\NbFacetteZ) * 4) 
  SetMeshData(0, 2, Matrix\TextureIDMemory , (Matrix\NbFacetteX + 1) * (Matrix\NbFacetteZ + 1)) 
  SetMeshData(0, 3, Matrix\NormaleIDMemory , (Matrix\NbFacetteX + 1) * (Matrix\NbFacetteZ + 1))  
  
  ;/Texture
;/Sans image
   TextureXSize = 256
   TextureYSize = 256 
;   CreateTexture(0, TextureXSize, TextureYSize) 
;   StartDrawing(TextureOutput(0)) 
;     Box(0, 0, TextureXSize, TextureYSize, #Blue) 
;     DrawingMode(4) 
;     Box(0, 0, TextureXSize , TextureYSize , #White) 
;   StopDrawing() 
  
;/Avec une image   
  UsePNGImageDecoder()
  LoadImage(0,"data\purebasiclogonew.png")    
  CreateTexture(0,TextureXSize,TextureYSize) 
  StartDrawing(TextureOutput(0)) 
  DrawImage(UseImage(0), 0, 0) 
  DrawingMode(4) 
  Box(1, 1, TextureXSize - 2, TextureYSize - 2, RGB(255,255,255)) 
  StopDrawing() 
  
  ;/Material
  CreateMaterial(0, TextureID(0)) ; Material 
  MaterialFilteringMode(0, #PB_Material_Trilinear)
  
  ;/Entity
  CreateEntity(0, MeshID(0), MaterialID(0)) 
  
  ;/Caméra
  CamLocateX = 0 
  CamLocateY = 845 
  CamLocateZ = 915 
  CamLookAtX = EntityX(0)
  CamLookAtY = EntityY(0)
  CamLookAtZ = EntityZ(0)
  CreateCamera(0, 0, 0, 100, 100)
   
  ;/Lumière
  AmbientColor(RGB(80,80,120))
  CreateLight(0,RGB(200,200,200))
  LightLocate(0, 150, 200, 150) 
  
  Repeat 
    ClearScreen(0, 0, 0) 
    ExamineKeyboard() 
    GestionTouches()
   ;/Donne une forme à la matrice
    AngleVague = Wrapvalue(AngleVague + Vitesse) 
    vagues() 
    NormalesMatrice()   
    CameraLocate(0, CamLocateX, CamLocateY, CamLocateZ) 
    CameraLookAt(0,CamLookAtX,CamLookAtY,CamLookAtZ)
    RenderWorld() 
    AfficheAide()
    FlipBuffers() 
  Until KeyboardPushed(#PB_Key_Escape) 
Else 
  MessageRequester("Error", "Something fails to initialize 3D engine", 0) 
EndIf 
End

[cederavic]

il te faut calculer la normale perpendiculaire a chaque vertex, sur le site il t'explique comment calculer celle d'une face, donc tu ne devrait pas avoir trop de mal

[comtois]

Cederavic , oui c'est ce que j'ai fait , enfin presque , j'ai loupé quelques vertex je vais reprendre ça , mais mon problème c'est qu'un vertex est commun à plusieurs facettes , alors je me disais qu'il faudrait pour bien faire qu'à chaque triangle correspondent 3 vertex

Actuellement pour X*Z Facettes, j'ai X*Z*2 Triangles et j'ai X+1*Z+1 Vertex

X=2
Z=2
Soit 4 facettes,8 triangles ,et 9 vertex

il faudrait que j'essaye avec 3 Vertex par triangle ?
Soit 4 facettes , 8 triangles ,et 24 Vertex , ça va vite me limiter dans la taille maxi d'une matrice ,et ralentir dans les calculs , mais pour l'instant , je ne vois pas comment faire autrement .
Je vais faire un essai comme ça

[cederavic]

ben oui, logiquement il y a 3 vertex par face, et puis tu peut toujours fair eun scale entity pour agrandir

[Chris]

Ben en tout cas , moi, je trouve ça super!

(Bon, d'accord, ça n'aide pas vraiment, ce que je dis, mais je fais ce que je peux )

Chris

[comtois]

Si ça n'aide pas , ça redonne du coeur à l'ouvrage en tout cas

En attendant que je me remette dans les calculs des normales

pour donner une petite touche "Made In France",Voila une autre texture

Code : Tout sélectionner

  ;/Texture 
  ;/Sans image 
  TextureXSize = 256 
  TextureYSize = 256 
  CreateTexture(0, TextureXSize, TextureYSize) 
  StartDrawing(TextureOutput(0)) 
    Box(0, 0, TextureXSize/3, TextureYSize, #Blue) 
    Box(TextureXSize/3, 0, TextureXSize*2/3, TextureYSize, #White)
    Box(TextureXSize*2/3, 0, TextureXSize, TextureYSize, #Red)
    DrawingMode(4) 
    Box(0, 0, TextureXSize , TextureYSize , #White) 
  StopDrawing() 

Sinon dans la section Texture avec image ,j'ai oublié de mettre un Resize pour charger n'importe quelle image .

Code : Tout sélectionner

  ;/Avec une image    
;   UseJPEGImageDecoder() 
;   LoadImage(0,"data\France.jpg")  
;   ResizeImage(0,TextureXSize,TextureYSize)

[Guimauve]

http://mathworld.wolfram.com/NormalVector.html

J'ai fait une petite recherche et j'ai trouver ça. À mon avis il est possible de calculer la normal d'un triangle en se disant que c'est un plan 3D.

Chaque triangle à 3 vertices mais qu'est ce qui t'empèche de repasser les vertices qui sont communs dans les calculs. Sauf qu'on a pas le choix, ça va prendre du temps processeur pour faire les calculs.

Moi j'ai eu un idée et malheureusement, j'ai pas eu le temps de la mettre à l'épreuve. Si on prend une matrice plate et qu'il y a 65000 triangles est-ce qu'on est d'accord pour dire que faire le calcul de 65000 normales est un calcul parfaitement inutile. Dans le fond on a besoin d'un seul vecteur pour faire le rendu.

Dans ton problème il y a des ondulations. Sauf que l'orientation des normales se répètent d'une vague à l'autre. Donc on peut optimiser les calculs en calculant les normales d'une vague et en appliquant ces normales à toutes autres les vagues.

A+
Guimauve

[comtois]

Merci à toi pour le site ,malheureusement j'ai du mal avec l'anglais , enfin je vais quand même y jeter un oeil .On ne sait jamais je pourrais apprendre quelque chose de nouveau .

Pour l'optimisation , tu as sûrement raison , mais je n'en suis pas encore là
Je voudrais dans un premier temps calculer convenablement les normales .

Pour calculer la normale d'une surface (triangle), ok , je pense que le site de Cederavic et le tien traite de ce sujet .
Mais le problème c'est que si j'ai bien compris , purebasic ( Ogre ) attend une valeur pour chaque vertex qui composent le triangle , et non pas une seule valeur pour le triangle.
En fait , il faudrait que je calcule la normale de la surface et que je l'applique aux trois vertex qui la composent ?

Et comme mes vertex sont en commun avec plusieurs triangles ,quand je calcule la normale pour un point d'un triangle , j'en calcule une autre pour le même point qui est commun avec le triangle voisin .
Enfin c'est comme ça que je le comprends .et j'obtiens un truc pas cohérent.

Bon sur ce , je vais tenter de lire le site que tu m'as indiqué

[fweil]

comtois,

Pour calculer la normale, tu dois disposer de 3 points, c'est à dire forcément les sommets (vertices) d'une facette. Que chaque sommet appartiennent ou non à d'autres facettes importe peu à ce moment là.

Les trois sommets sont nécessaires pour une facette donnée car tu recherche la normale à la facette, et le calcul implique de connaître le support plan 3D de la facette. Le plus simple est bien de prendre les coordonnées x, y, z de cahque sommet.

La normale d'une droite, perpendiculaire, nécessite de connaître deux points de la droite, la normale d'un plan, la facette étant une partie de ce plan, nécessite 3 points du plan.

Pour finir la théorie, il est nécessaire d'indiquer précisément les trois sommets et pas autre chose, car ensuite ce caul de normale s'applique pour étudier l'indice de lumière de la facette et le moteur 3D doit donc appliquer une quantité de réfraction au barycentre des trois sommets, et pas ailleurs.

A partir de là, les formulations sont assez simples, il s'agit de calculer l'équation d'une droite perpendiculaire au plan 3D passant par le barycentre des trois points définissant ce plan.

J'espère que cela t'éclairci un peu le truc ...

[comtois]

Les trois sommets sont nécessaires pour une facette donnée car tu recherches la normale à la facette, et le calcul implique de connaître le support plan 3D de la facette.

Ben justement non , c'est là mon problème ,car si j'ai bien compris ,c'est la normale à chaque sommet qu'il faut renseigner .

Et à ce propos je viens de lire un truc qui parle de normale moyenne , bon c'est pour calculer une couleur , mais je me demande si ça ne correspond pas exactement à ce que je cherche à faire ??

Voici une image qui représente bien le problème à résoudre , enfin à mon avis.



si c'est ça, maintenant ,j'ai un autre problème ,c'est comment calculer la moyenne des normales

http://raphaello.univ-fcomte.fr/IG/Phys ... ysique.htm

[comtois]

Voila comment je fais actuellement

Je prends bien les 3 points qui composent un triangle
Pos1
Pos2
Pos3

Code : Tout sélectionner

For Z = 1 To Matrix\NbFacetteZ 
    For x = 1 To Matrix\NbFacetteX 
      Pos1\x = x 
      Pos1\y = PeekF(Address + (x+(Z*(Matrix\NbFacetteX+1)))*12) 
      Pos1\Z = Z 
      
      Pos2\x = x 
      Pos2\y = PeekF(Address + (x+((Z-1)*(Matrix\NbFacetteX+1)))*12) 
      Pos2\Z = Z - 1 
      
      Pos3\x = x - 1 
      Pos3\y = PeekF(Address + (x - 1 + (Z * (Matrix\NbFacetteX + 1))) * 12) 
      Pos3\Z = Z 
      
      Vecteur1\x = (Pos1\x - Pos2\x)*TailleFacetteX 
      Vecteur1\y = (Pos1\y - Pos2\y) 
      Vecteur1\Z = (Pos1\Z - Pos2\Z)*TailleFacetteZ 

      Vecteur2\x = (Pos1\x - Pos3\x)*TailleFacetteX 
      Vecteur2\y = (Pos1\y - Pos3\y) 
      Vecteur2\Z = (Pos1\Z - Pos3\Z)*TailleFacetteZ 
    
      Normale\x = ((Vecteur1\y * Vecteur2\Z) - (Vecteur1\Z * Vecteur2\y)) 
      Normale\y = ((Vecteur1\Z * Vecteur2\x) - (Vecteur1\x * Vecteur2\Z)) 
      Normale\Z = ((Vecteur1\x * Vecteur2\y) - (Vecteur1\y * Vecteur2\x)) 
  
      Magnitude.f = Sqr(Normale\x*Normale\x + Normale\y*Normale\y + Normale\Z*Normale\Z) 
      Normale\x / Magnitude 
      Normale\y / Magnitude 
      Normale\Z / Magnitude 
      PokeF(AdrNormale    , Normale\x) 
      PokeF(AdrNormale + 4, Normale\y) 
      PokeF(AdrNormale + 8, Normale\Z) 
      AdrNormale + 12 
      
    Next x 
  Next Z    

[fweil]

Faut que je retourne réfléchir au truc moi, là je sais pas encore répondre à coup sûr !

Mais je lache pas, juste un peu de temps pour réfléchir.

...