vector3D.toString()->byte[40]
Classe: vector3D
Convertit un vecteur 3D en une chaîne de caractères.
v = vector3D(x=24,y=32,z=11)
v.toString() # => "[24.000000:32.000000:11.000000]"
vector3D.cross(v:vector3D)->vector3D
Classe: vector3D
Calcule le produit en croix du vecteur 3D avec le vecteur 3D v passé en paramètre. Le résultat d’un produit en croix est un nouveau vecteur 3D.
vector3D.dot(v:vector3D)->float
Classe: vector3D
Calcule le produit scalaire du vecteur 3D avec le vecteur 3D v passé en paramètre.
vector3D.distance(v:vector3D)->float
Classe: vector3D
Calcule la distance entre deux vecteurs 3D.
vector3D.magnitude()->float
Classe: vector3D
Calcule la longueur du vecteur 3D.
vector3D.random()
Classe: vector3D
Crée un vecteur directionnel 3D aléatoire de longueur 1.
vector3D.fromAngle(alpha:float, theta:float)
Classe: vector3D
Crée un vecteur 3D normalisé avec la direction alpha et thêta en radians.
vector3D.mulScalar(s:float)
Classe: vector3D
Multiplie la valeur s par les valeurs x, y et z du vecteur 3D (multiplication scalaire)
v1 = vector(x=4,y=8,z=2)
v1.mulScalar(10)
vector3D.subScalar(s:float)
Classe: vector3D
Soustrait la valeur s des valeurs x, y et z du vecteur 3D (soustraction scalaire)
v1 = vector3D(x=4,y=8,z=2)
v1.subScalar(10)
vector3D.addScalar(s:float)
Classe: vector3D
Ajoute la valeur s aux valeurs x, y et z du vecteur 3D (addition scalaire)
v1 = vector3D(x=4,y=8,z=2)
v1.addScalar(10)
vector3D.sub(v:vector3D)
Classe: vector3D
Soustrait le vecteur 3D v du vecteur 3D
v1 = vector3D(x=4,y=8,z=2)
v2 = vector3D(x=3.5,y=1.8,z=1.1)
v1.sub(v2)
vector3D.add(v:vector3D)
Classe: vector3D
Ajoute le vecteur 3D v au vecteur 3D.
v1 = vector3D(x=4,y=8,z=2)
v2 = vector3D(x=3.5,y=1.8,z=1.1)
v1.add(v2)
vector3D.normalize()
Classe: vector3D
Normalise le vecteur 3D. Cela signifie qu’après l’appel, la longueur du vecteur est égale à 1.
v = vector3D(x=5,y=10,z=3)
v.normalize()
vector.toString()->byte[30]
Classe: vector
Convertit un vecteur en une chaîne de caractères.
v = vector(x=24,y=32)
v.toString() # => "[24.000000:32.000000]"
vector.limit(xMin:float, xMax:float, yMin:float, yMax:float)
Classe: vector
Limite le vecteur à la plage définie (xMin… xMax & yMin… yMax).
vector.limitToScreen(offset:int)
Classe: vector
Limite le vecteur à la zone visible de l’écran (0… 239).
Il est possible de choisir un décalage supérieur à 0 pour réduire la zone visible.
v = vector(x=-5,y=250)
v.limitToScreen(0)
v.x # => 0
v.y # => 239
v.limitToScreen(5)
v.x # => 5
v.y # => 234
vector.dot(v:vector)->float
Classe: vector
Calcule le produit scalaire du vecteur avec le vecteur v passé en paramètre.
vector.angle()->float
Classe: vector
Donne l’angle en radian du vecteur.
vector.distance(v:vector)->float
Classe: vector
Calcule la distance entre deux vecteurs.
vector.magnitude()->float
Classe: vector
Calcule la longueur du vecteur.
vector.random()
Classe: vector
Crée un vecteur directionnel aléatoire de longueur 1.
L’exemple suivant dessine 3000 vecteurs aléatoires, chacun d’une longueur aléatoire comprise entre 0 et 100 pixels et d’une luminosité différente.
for i in 3000:
v:vector
v.random()
v.mulScalar(random(0,100))
strokeHSV(110,255,random(0,255))
drawLine(120,120,120+v.x,120+v.y)
update()
vector.fromAngle(angle:float)
Classe: vector
Crée un vecteur normalisé avec la direction angle en radians.
L’exemple suivant dessine 12 cercles u un cercle.
2*PI est la circonférence du cercle unitaire. Nous le divisons en 12 parties et initialisons ainsi la direction du vecteur. Avec mulScalar(..), nous modifions ensuite la longueur du vecteur, qui correspond au rayon du cercle.
for i in 12:
f = PI/6*i
v:vecteur
v.fromAngle(f)
v.mulScalar(80)
drawCircle(120+v.x,120+v.y,5)
update()
vector.subScalar(s:float)
Classe: vector
Soustrait la valeur s à chacune des valeurs x et y du vecteur (soustraction scalaire).
v1 = vector(x=4,y=8)
v1.subScalar(10)
vector.mulScalar(s:float)
Classe: vector
Multiplie la valeur s par les valeurs x et y du vecteur (multiplication scalaire).
v1 = vector(x=4,y=8)
v1.mulScalar(10)
vector.addScalar(s:float)
Classe: vector
Ajoute la valeur s à chacune des valeurs x et y du vecteur (addition scalaire).
v1 = vector(x=4,y=8)
v1.addScalar(10)
vector.sub(v:vector)
Classe: vector
Soustrait le vecteur v du vecteur
v1 = vector(x=4,y=8)
v2 = vector(x=3.5,y=1.8)
v1.sub(v2)
vector.normalize()
Classe: vector
Normalise le vecteur. Cela signifie qu’après l’appel, la longueur du vecteur est égale à 1.
v = vector(x=5,y=10)
v.normalize()
vector.add(v:vector)
Classe: vector
Ajoute le vecteur v au vecteur
v1 = vector(x=4,y=8)
v2 = vector(x=3.5,y=1.8)
v1.add(v2)