Les NURBS sans fautes.
Introduction
- interpolation et extrapolation
- degrés et ordre
- patch UV
VRML
Réalisation
- premier patch
- controlPoint, order, weight
- un tube
- une sphère
- un baril
- un beignet
- multipatch
Exemple de réalisation
Références
#---------Introduction-------------
Dés l'apparition de la modélisation 3D et des gros calculateurs,
il s'est posé le problème de décrire des formes complexes.
Certes il est intéressant d'avoir un gros calculateur pour calculer
des formules mathématiques complexes mais si les paramètres
de ces fonctions dépassent largement l'imagination humaine, elles
sont inexploitables. Il a alors été envisagé de créer
des courbes interpolées dont la forme ressemble aux courbes les plus
complexes mais dont les paramètres sont directement manipulable par
l'être humain grâce à quelques points de contrôles.
Ainsi sont nées les courbes de Béziers en 1971, aujourd'hui
encore très utilisées par les graphistes. Le besoin croissant
de réalisme et de formules permettant de modéliser des formes
organiques a conduit à la création des NURBS (Non Uniform
Rational Beta-Splines) qui utilisent l'extrapolation de points de contrôles.
Ce tutorial se penchera donc sur la manipulation manuelle de quelques paramètres
des NURBS, il se voudra très pragmatique -au risque de choquer quelques
mathématiciens puristes par ses approximations- mais comme le but
même de NURBS est d'être facilement manipulable, je ne vois
pas ce qui m'empêcherait de le faire -au risque de démystifier
une technique réservée aux logiciels à 5 000$.
| Ce tutorial exige un minimun de connaissance en
3D et en VRML. Il se veut néanmoins le plus abordable possible.
Tous les exemples ont été réalisé avec Notepad,
un peu de calcul mental et force copier/coller. |
1- Interpolation et extrapolation.
Les NURBS sont des courbe réalisées par extrapolation
de points, contrairement aux courbes de Bézier plus connues qui sont
réalisées par interpolation.
 courbe
interpolée, style Bézier.
 courbe
extrapolée, style b-spline.
2- Degré et ordre.
Les NURBS ont besoins d'un minimum de points à extrapoler
suivant leur degré ou ordre.
Il suffit de savoir que le mode de calcule des NURBS utilise une forme polynomiale,
ainsi les courbes de style :
a+bx seront
de degré 1,
a+bx+cx²
seront de degré 2,
a+bx+cx²+dx3 seront de degré
3
ce sont les trois principales types de courbes utilisées.
La notation VRML utilise l'ordre à la place du degré de la
courbe, l'ordre étant égale au degré+1.
Cela se justifie par le fait :
qu'une courbe de degré 1, donc d'ordre 2 nécessitera au minimum
de 2 points pour être calculée et aura un aspect de ligne brisée.
qu'une courbe de degré 2, donc d'ordre 3 nécessitera au minimum
de 3 points pour être calculée.
qu'une courbe de degré 3, donc d'ordre 4 nécessitera au minimum
de 4 points pour être calculée, elle sera le plus souvent utilisée
car elle permet de décrire à peu prés n'importe quelle
courbure.
| C'est la notion la plus importante pour
bien comprendre les NURBS, plus le degré de la courbe est élevé,
plus un grand nombre de points est pris en compte pour interpoler la
courbe d'où une courbure plus douce, plus le degré de
la courbe est faible, plus la courbure est serrée jusqu'au degré
1 où la courbure décrit une ligne brisée. |
3- Patch UV.
Pour décrire une surface, on utilisera une réseau de points
formant un quadrillage aussi appelé patch.
On distinguera les deux dimensions U et V formant
ce réseau. 
On organisera alors les points (appelés aussi points de contrôle)
selon ces deux dimensions.
U0V0 U1V0 U2V0 U3V0 U4V0
U0V1 U1V1 U2V1 U3V1 U4V1
U0V2 U1V2 U2V2 U3V2 U4V2
U0V3 U1V3 U2V3 U3V3 U4V3
| Un des attraits des patchs NURBS, c'est que leur conception en
dimensions UV permet de les texturer directement avec la technique UVmap
sans avoir à rajouter des coordonnées de texture. |
La création d'un patch nécessite peu de points, c'est à
peu prés tout ce dont nous avons besoin pour créer des formes
simples et spectaculaire. Ce travail peut se faire à la main et sans
gros efforts et on dispose de moteurs 3D qui se chargent de tous les calculs
à notre place pourvu qu'on leur fournissent quelques renseignements
supplémentaires. On s'intéressera donc aux moteurs 3D dédiés
à l'affichage du VRML qui rempliront très biens cette tâche.
L'intéret des NURBS pour les ceux qui s'intéressent aux VRML
est de produire des formes complexes avec des fichiers de faible poids au
regard du nombre de poligônes engendrés.
#---------VRML-------------
1-Moteurs 3D VRML supportant les NURBS.
Pluggin pour Microsoft Internet Explorer
Blaxxun : Contact
ParrallelGraphics : Cortona
Contact 4.3 (le plus avancé en matière
de NURBS, code source dans le domaine publique)
Applications
GLView (moteur Contact 4.3)
Modeleurs
WhiteDune
Spazz3D
Discreet : 3DMax (pluggin d'exportation Blaxxun)
Rhino3D (pas d'export des NURBS directement
en vrml)
Nous utiliserons la notation proposée par Blaxxun qui sert de
référence (compatible Cortona).
NotationVRML
types de champs, champs par défaut composant le nœud
NurbsSurface:
NurbsSurface{
field SFInt32 uDimension 0 # 0~+inf
field SFInt32 vDimension 0 # 0~+inf
field MFFloat uKnot [] # -inf~+inf
field MFFloat vKnot [] # -inf~+inf
field SFInt32 uOrder 3 #
2~+inf
field SFInt32 vOrder 3 #
2~+inf
exposedField MFVec3f controlPoint [] # -inf~+inf
exposedField MFFloat weight [] # 0~+inf
exposedField SFInt32 uTessellation 0 # 0~+inf
exposedField SFInt32 vTessellation 0 # 0~+inf
exposedField SFNode texCoord [] # -inf~+inf
field SFBool ccw TRUE #
TRUE/FALSE
field SFBool solid TRUE #
TRUE/FALSE
}
NurbsSurface est un nœud de type géométrique
(IndexFaceSet, Box ...).
on l'utilisera généralement ainsi :
Shape{
appearance Appearance{}
geometry NurbsSurface{}
}
Pour éviter les messages d'erreurs et par soucis de concordance
avec les spécifications VRML, on déclarera préalablement
:
EXTERNPROTO NurbsSurface [
field SFInt32 uDimension
field SFInt32 vDimension
field MFFloat uKnot
field MFFloat vKnot
field SFInt32 uOrder
field SFInt32 vOrder
exposedField MFVec3f controlPoint
exposedField MFFloat weight
exposedField SFInt32 uTessellation
exposedField SFInt32 vTessellation
exposedField SFNode texCoord
field SFBool ccw
field SFBool solid
]
[ "urn:inet:blaxxun.com:node:NurbsSurface"
"http://www.blaxxun.com/vrml/protos/nurbs.wrl#NurbsSurface"
]
|
#-------Réalisation----------
1-Premier patch.
-éditons un patch 4x4.
On a donc les deux dimension U et V :
uDimension 4
vDimension 4
 |
|
Création d'un patch avec
Spazz3d.
Il peut être utile de créer un patch dans Spazz3D.
Réalisons le premier exemple de ce tutorial dans Spazz3D.
-"create swept extrusion or nurb"
-cliquer gauche a l'origine (0, 0, 0)
-dans la fenêtre cross-section, aidez vous de la grille et du
snap, éditer 4 point horizontaux à (0, 0), (1, 0), (2,
0), (3,0) et faire OK (cela définira la dimension U)
-se mettre dans la vue de face
-dans l'éditeur de propriété> trans
-remettre les valeurs à zéro
-dans l'éditeur de propriété> sweep
-cocher "edit spline"
-flèche haut pour sélectionner la "vertebra"
du haut
-"insert vertebra after" 2 fois (cela définira la dimension
V)
-décocher "edit spline"
-NURBS : Order "4"
-Tess. "2 2"
-File>Vrml Export Option
-décocher GZip World
-sauver File>export VRML97 world ...
exemple : Spazz3D.wrl
vous pouvez maintenant éditer votre patch manuellement dans
un éditeur de texte.
|
-éditons les points comme sur la figure.
controlPoint[
#V0
0 0 0
#U0
1 0 0
#U1
2 0 0
#U2
3 0 0 #U3
#V1
0 1 0
#U0
1 1 0
#U1
2 1 0
#U2
3 1 0 #U3
#V2
0 2 0
#U0
1 2 0
#U1
2 2 0 #U2
3 2 0 #U3
#V3
0 3 0
#U0
1 3 0
#U1
2 3 0
#U2
3 3 0
#U3
]
Décidons de faire une surface d'ordre 4
uOrder 4
vOrder 4
Nous pouvons alors déterminer les nœuds uKnot et vKnot selon
une formule assez simple qui assure un résultat uniforme. Ces nœuds
sont des sortes de lignes de force qui détermine la manière
dont les points de contrôle agissent sur la surface (lignes noires
sur la figure) et les limites du domaine dans lequelles la surface est rendue.
Exemple 1 :
uDimension 4
uOrder 2
L'ordre est 2 alors je met 2 zeros,
0 0
la dimension (le nombre de points dans la direction U) est 4 alors je
rajoute 1 2 3 4,
0 0 1 2 3 4
L'ordre est 2 alors je surligne les 2 derniers,
0 0 1 2 3 4
et je les remplace par le premier chiffre surligné 3 3.
0 0 1 2 3 3
uKnot [0 0 1 2 3 3]
Exemple 2 :
vDimension 8
vOrder 4
L'ordre est 4 alors je met 4 zeros,
0 0 0 0
la dimension est 8 alors je rajoute 1 2 3 4 5 6 7 8,
0 0 0 0 1 2 3 4 5 6 7 8
L'ordre est 4 alors je surligne les 4 derniers,
0 0 0 0 1 2 3 4 5 6 7 8
et je les remplace par le premier chiffre surligné 5 5 5 5.
0 0 0 0 1 2 3 4 5 5 5 5
vKnot [0 0 0 0 1 2 3 4 5 5 5 5]
Ici nous avons :
uOrder 4
vOrder 4
uDimension 4
vDimension 4
Dans les deux cas l'ordre est 4 alors je met 4 zeros
0 0 0 0
la dimension est 4 alors je rajoute 1 2 3 4
0 0 0 0 1 2 3 4
L'ordre est 4 alors je surligne les 4 derniers
0 0 0 0 1 2 3 4
et je les remplace par le premier chiffre surligné 1 1 1 1
0 0 0 0 1 1 1 1
Donc:
uKnot [0 0 0 0 1 1 1 1]
vKnot [0 0 0 0 1 1 1 1]
c'est le point le plus délicat
de la création de NURBS,
rappelons nous que dimension minimum = ordre,
rappelons nous que le nombre de nœuds = dimension + ordre
,
les "ordre" premiers et les "ordre" derniers nœuds
ont la même valeur,
le nœud de rang "ordre" aura toujours la valeur 0, après
on incrémente de 1 jusqu'à atteindre les "ordre"
derniers nœuds. |
Nous avons désormais tous les éléments pour faire
notre première surface nurbs.
patch1.wrl.txt , patch1.wrl , Spazz3D.wrl
2-controlPoint, order, weight.
Commençons donc à nous amuser à déplacer les
points de contrôle.
controlPoint[
#V0
-1 -1 0 #U0
1 0 0
#U1
2 0 0
#U2
4 -1 0 #U3
#V1
0 1 0
#U0
1 1 2
#U1
2 1 2
#U2
3 1 0 #U3
#V2
0 2 0
#U0
1 2 2
#U1
2 2 2 #U2
3 2 0 #U3
#V3
-1 4 0 #U0
1 3 0
#U1
2 3 0
#U2
4 4 0
#U3
]
C'est déjà mieux,
 patch2.wrl
Agissons maintenant sur la différence d'ordre.
uOrder 4
vOrder 2
Puisque vOrder à changer il faut changer aussi vKnot
uKnot [0 0 0 0 1 1 1 1]
vKnot [0 0 1 2 3 3]
Un ordre moindre de la dimensinon V a pour effet de créer des cassures
dans la courbure de direction V, cela peut donner un effet intéressant
(exemple d'effet utilisant l'ordre des courbures : order.wrl).
 patch3.wrl
On a délaissé le champ weight (poids) pour l'instant, occupons-nous
en.
| Les beta_splines ayant une composante de poids seront appelées
beta-splines rationnelles (NURBS=Non Uniforme Rational
Beta-Splines) |
weight[
1 1 1 1
1 1 1 1
1 1 1 1
1 1 1 1
]
Vous noterez qu'il y a un poids par point de contrôle.
Ce sont les valeurs par défaut, si le poids est supérieurà
1, le point de contrôle associé va attirer la surface à
lui comme un aimant, si le poids se rapproche de 0 il va repousser la surface
weight[
1 1 1 1
1 100 1 1
1 1 1 1
1 1 1 1
]
Une deuxième manipulation est nécéssaire car le VRML
utilise la notation non-euclidienne des NURBS, il faut donc multiplier les
coordonnées du point de contrôle par son poids.
controlPoint[
#V0
-1 -1 0 #U0
1 0 0
#U1
2 0 0
#U2
4 -1 0 #U3
#V1
0 1 0
#U0
100 100 200 #U1
2 1 2
#U2
3 1 0 #U3
#V2
0 2 0
#U0
1 2 2
#U1
2 2 2 #U2
3 2 0 #U3
#V3
-1 4 0 #U0
1 3 0
#U1
2 3 0
#U2
4 4 0
#U3
]
Il est a noté que la surface est attirée par le point de contrôle
original (1, 1, 2) et non (100, 100, 200)
 patch4.wrl
C'est trés bien un patch rectangulaire mais que faire si on
veut un patch triangulaire. Cela ne pose pas de problèmes particulier.
Il faut seulement respecter le nombre de points dans chaque direction
et nous sommes complètement libre de leur position ce qui nous
permet de faire des points confondus.
controlPoint[
#V0
0 0 0
#U0
1 0 0
#U1
2 0 0
#U2
3 0 0 #U3
#V1
0 1 0
#U0
0.66 1 0 #U1
1.33 1 0 #U2
2 1 0 #U3
#V2
0 2 0
#U0
0.33 2 0 #U1
0.66 2 0 #U2
1 2 0 #U3
#V3
0 3 0
#U0 les quatres points
doivent
0 3 0
#U1 apparaître
même s'ils sont
0 3 0
#U2 confondus.
0 3 0
#U3
] |
3-Un tube.
Étudions maintenant quelques cas particuliers. Un tube se définira
comme un patch fermé dans la direction U ou V.
Regardons tout d'abord un exemple du problème posé.
 tube1.wrl
 tube2.wrl
tube3.wrl
On s'aperçoit qu'il y a une discontinuité dans la surface
à l'endroit de la jointure. La manière de palier à
ce problème est de rajouté des points de contrôle et
de modifier les nœuds pour que le surplus de surface ne soit pas rendu.
Prenons quatre points qui définiront la circonférence du tube
( Attention : on ne fermera pas la courbe à ce stade, on voudra
plutôt un genre de gouttière).
#V0
-1 0 0
0 0 -1
1 0 0
0 0 1
Redoublons ces points pour définir la longueur du tube.
#V0
-1 0 0
0 0 -1
1 0 0
0 0 1
#V1
-1 5 0
0 5 -1
1 5 0
0 5 1
Nous devons décider désormais de l'ordre U et V avant de continuer.
Posons l'ordre V à 2 puisque l'on veut un tube rectiligne (cela évite
de rajouter des points inutiles, seuls 2 points sont nécéssaires).
Prenons 4 pour l'ordre U. La règle est de prolonger U par les "degrés"
(ordre-1) premiers U.
On remarquera que pour l'ordre 2 (degré 1), la surface sera tout
simplement fermée sans ajout de points supplémentaires.
uOrder 4
vOrder 2
controlPoint[
#V0
-1 0 0 #U0
0 0 -1 #U1
1 0 0 #U2
0 0 1 #U3
-1 0 0 #U0
fermeture de la courbe
0 0 -1 #U1
1 0 0 #U2
#V1
-1 5 0 #U0
0 5 -1 #U1
1 5 0 #U2
0 5 1 #U3
-1 5 0 #U0
fermeture de la courbe
0 5 -1 #U1
1 5 0 #U2
]
Nous avons donc les dimensions :
uDimension 7
vDimension 2
Calculons les nœuds selon la méthode habituelle.
uKnot[0 0 0 0 1 2 3 4 4 4 4]
vKnot[0 0 1 1]
Modifions uKnot pour que le premier et le dernier nœud ne soit pas
rendu.
Commençons comme un knot normal sans remplacer les derniers knots.
0 0 0 0 1 2 3 4 5 6 7
surlignons les premiers 0 et incrémentons jusqu'à zero
0 0 0 0 1 2 3 4 5 6 7
-3 -1 -2 0 1 2 3 4 5 6 7
Notons qu'on a rajouter 3 points et qu'on commence à -3 et uDimention
est 7 qu'on incrémente jusqu'à 7.
On remarquera que la règle immuable nombre de noeuds=ordre+dimension
est respectée, ainsi que notre règle officieuse, le "ordre"
nœud est toujours 0.
uKnot[-3 -2 -1 0 1 2 3 4 5 6 ]
vKnot[0 0 1 1]
Voilà !
Il se trouve que la règle "le ordre nœud a pour
valeur 0" est juste un moyen mnémotechnique pour ne pas
se tromper.
[ 0 1 2 3 4 5 6 7 8 9 10 11] <=> [-3 -2 -1 0 1 2 3 4
5 6 7]
Seule la répartition uniforme des nœuds importe :
[0 0 1 1] <=> [0 0 10 10]
ou bien,
[0 0 1 2 2] <=> [0 0 2 4 4]
On pourra bien entendu mélanger les 2 notations étudiées
au besoin.
[-3 -2 -1 0 1 2 3 4 5 6 7] surface U0~U1 et U5~U6
non rendue.
[-3 -2 -1 0 1 2 3 4 4 4 4] surface U0~U1 non rendue.
[0 0 0 0 1 2 3 4 5 6 7] surface U5~U6 non rendue.
|
Qu'en est-il de la propriété non uniforme des NURBS
(Non Uniform Rational Beta-Splines).
Tant que les nœuds sont de valeur croissante, on peut faire varier
leur valeur avec un impact directe sur le rendu final, c'est pourquoi
l'on parle de beta-splines non uniforme. On ne se risquera que peu a
de telles manipulations car l'effet est peu prévisible. On préférera
manipuler les points de contrôle dans la plupart des cas.
Exemple de modifications des noeuds : knots.wrl |
4-Une sphère.
 tube3.wrl
 sphere1.wrl
 sphere2.wrl
La règle pour former une sphère est de faire un tube et de
le fermer par un point situé au centre des points formant les extrémités
du tube (dans le même plan).
Reprenons le tube que nous venons de faire et fermons le.
0 0 0
0 0 0
0 0 0
0 0 0
0 0 0
0 0 0
0 0 0
-1 0 0
0 0 -1
1 0 0
0 0 1
-1 0 0
0 0 -1
1 0 0
-1 5 0
0 5 -1
1 5 0
0 5 1
-1 5 0
0 5 -1
1 5 0
0 5 0
0 5 0
0 5 0
0 5 0
0 5 0
0 5 0
0 5 0
Nous avons :
uDimension 7
vDimension 4
Posons V d'ordre 4 :
uOrder 4
vOder 4
Nous avons donc :
uKnot[-3 -2 -1 0 1 2 3 4 5 6 7 ] #tube
vKnot[0 0 0 0 1 1 1 1]
Réglons la hauteur afin de former une sphère.
0 0 0
0 0 0
0 0 0
0 0 0
0 0 0
0 0 0
0 0 0
-1 0 0
0 0 -1
1 0 0
0 0 1
-1 0 0
0 0 -1
1 0 0
-1 1 0
0 1 -1
1 1 0
0 1 1
-1 1 0
0 1 -1
1 1 0
0 1 0
0 1 0
0 1 0
0 1 0
0 1 0
0 1 0
0 1 0
Je parle de sphère mais c'est bien sûr une forme approchante
de la sphère, rappelons nous que les NURBS sont un moyen de se
rapprocher de formes complexes à moindre coût.
Une bonne approximation de la sphère est de faire un tube de
section carrée de coté R et de hauteur R*racine carrée
de 1/2. |
Voilà!
Les formes ovoïdes sont souvent la base de la modélisation
des NURBS et c'est ce qui à grandement fait leur succès,
elles permettent de générer des formes organiques de façon
pertinente et on peut commencer à entr'apercevoir la force des
NURBS dans leur capacité à être très facilement
déformées ce qui sera très appréciable pour
le travail d'animation de ces mêmes formes.
oeuf.wrl 
mush.wrl |
5-Un baril.
Un baril est un cylindre plein, nous reprendrons la même démarche
que pour faire une sphère.
 baril1.wrl
 baril2.wrl
 baril3.wrl
Nous avons vu précédemment qu'il était possible
de créer un cassure dans la courbure de la surface grâce
aux différences d'ordre entre U et V.
Une autre méthode plus souple consiste à multiplier les
points de contrôle autour de l'endroit voulu, ce qui accentuera
la courbure. Dans l'édition à la main, on se contentera
de doubler ces points par copier/coller.
doublon d'un point de contrôle, courbe en rouge. |
Prenons un tube :
-1 0 0
0 0 -1
1 0 0
0 0 1
-1 0 0
0 0 -1
1 0 0
-1 3 0
0 3 -1
1 3 0
0 3 1
-1 3 0
0 3 -1
1 3 0
Redoublons les extrémités :
-1 0 0 #V0
-doublon
0 0 -1
1 0 0
0 0 1
-1 0 0
0 0 -1
1 0 0
-1 0 0 #V0
0 0 -1
1 0 0
0 0 1
-1 0 0
0 0 -1
1 0 0
-1 3 0 #V1
0 3 -1
1 3 0
0 3 1
-1 3 0
0 3 -1
1 3 0
-1 3 0 #V1
-doublon
0 3 -1
1 3 0
0 3 1
-1 3 0
0 3 -1
1 3 0
Refermons les extrémités et ajoutons une dimension V intermédiaire.
0 0 0
0 0 0
0 0 0
0 0 0
0 0 0
0 0 0
0 0 0
0 0 0
-1 0 0
0 0 -1
1 0 0
0 0 1
-1 0 0
0 0 -1
1 0 0
-1 0 0
0 0 -1
1 0 0
0 0 1
-1 0 0
0 0 -1
1 0 0
-1.5 1.5 0
0 1.5 -1.5
1.5 1.5 0
0 1.5 1.5
-1.5 1.5 0
0 1.5 -1.5
1.5 1.5 0
-1 3 0
0 3 -1
1 3 0
0 3 1
-1 3 0
0 3 -1
1 3 0
-1 3 0
0 3 -1
1 3 0
0 3 1
-1 3 0
0 3 -1
1 3 0
0 3 0
0 3 0
0 3 0
0 3 0
0 3 0
0 3 0
0 3 0
Nous avons donc :
uDimension 7
vDimension 7
uOrder 4
vOrder 4
uKnot [-3 -2 -1 0 1 2 3 4 5 6 7
]
vKnot [0 0 0 0 1 2 3 4 4 4 4
]
voilà !!
Pour faire un simple cylindre plein, il suffit juste
de fermer les extrémités et de garder vOrder 2.
uDimension 7
vDimension 4
uOrder 4
vOrder 2
controlPoint[
0 0 0
0 0 0
0 0 0
0 0 0
0 0 0
0 0 0
0 0 0
-1 0 0
0 0 -1
1 0 0
0 0 1
-1 0 0
0 0 -1
1 0 0
-1 3 0
0 3 -1
1 3 0
0 3 1
-1 3 0
0 3 -1
1 3 0
0 3 0
0 3 0
0 3 0
0 3 0
0 3 0
0 3 0
0 3 0
]
uKnot [-3 -2 -1 0 1 2 3 4 5 6 7
]
vKnot [0 0 1 2 3 3
]
|
6-Un beignet.
Un beignet (un tore) est un tube replié sur lui même.
 tore.wrl
Éditons le profil sans refermer la surface (une gouttière
repliée)
-1 0 0
-2 -1 0
-3 0 0
-2 1 0
0 0 1
0 -1 2
0 0 3
0 1 2
1 0 0
2 -1 0
3 0 0
2 1 0
0 0 -1
0 -1 -2
0 0 -3
0 1 -2
Choisissons l'ordre 3 pour changer, refermons dans la dimension U donc 2
points supplémentaires (ordre-1).
-1 0 0
-2 -1 0
-3 0 0
-2 1 0
-1 0 0
-2 -1 0
0 0 1
0 -1 2
0 0 3
0 1 2
0 0 1
0 -1 2
1 0 0
2 -1 0
3 0 0
2 1 0
1 0 0
2 -1 0
0 0 -1
0 -1 -2
0 0 -3
0 1 -2
0 0 -1
0 -1 -2
Refermons maintenant dans la direction V.
-1 0 0
-2 -1 0
-3 0 0
-2 1 0
-1 0 0
-2 -1 0
0 0 1
0 -1 2
0 0 3
0 1 2
0 0 1
0 -1 2
1 0 0
2 -1 0
3 0 0
2 1 0
1 0 0
2 -1 0
0 0 -1
0 -1 -2
0 0 -3
0 1 -2
0 0 -1
0 -1 -2
-1 0 0
-2 -1 0
-3 0 0
-2 1 0
-1 0 0
-2 -1 0
0 0 1
0 -1 2
0 0 3
0 1 2
0 0 1
0 -1 2
Nous avons donc :
uDimension 6
vDimension 6
uOrder 3
vOder 3
uKnot[-2 -1 0 1 2 3 4 5 6]
vKnot[-2 -1 0 1 2 3 4 5 6]
Voilà!
7-Multipatch.
Nous n'avons étudié pour l'instant que des formes crées
à l'aide d'un seule patch. Pour joindre des patchs de façon
fluide nous considèrerons chaque patch comme un tore mais au lieux
de le fusionner avec lui même on le fusionnera avec ses voisins.
 multipatch.wrl
| Cela s'approche de la technique utilisée par un logiciel comme
Lightwave3D. Avec cette technique il est envisageable de tranformer
n'importe quel mesh composé de quadrangles (et de triangles)
en multipatch. |
#---------Exemple de Réalisation-------------
Voici un exemple d'objet, entièrement réalisé à
la main, il reprend les techniques étudiées précédemment.
 
 
bateau_scene.wrl
On notera la simplicité avec laquelle s'applique les textures dans
le domaine UV.
 coque3.jpg
#---------Références-------------
http://www.web3d.org/fs_specifications.htm
http://developer.blaxxun.com/spec/nurbs/nurbsinvrml.pdf
http://developer.blaxxun.com/spec/vrmlscript/vrmlscript.html
http://developer.blaxxun.com/download/doc/3dauthoring.pdf
|
Apprenez le VRML
